From 3c1d70f20b5d5bad3bec121e589187d15f325a9b Mon Sep 17 00:00:00 2001
From: Thomas Vigouroux <thomas.vigouroux@protonmail.com>
Date: Mon, 25 Jul 2022 12:23:04 +0200
Subject: feat(treesitter): allow customizing language symbol name

---
 src/nvim/lua/treesitter.c | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index f0d847e352..90b13181fb 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -14,10 +14,12 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
+#include <uv.h>
 
 #include "nvim/api/private/helpers.h"
 #include "nvim/buffer.h"
 #include "nvim/lib/kvec.h"
+#include "nvim/log.h"
 #include "nvim/lua/treesitter.h"
 #include "nvim/memline.h"
 #include "tree_sitter/api.h"
@@ -145,18 +147,27 @@ int tslua_has_language(lua_State *L)
   return 1;
 }
 
+// Creates the language into the internal language map.
+//
+// Returns true if the language is correctly loaded in the language map
 int tslua_add_language(lua_State *L)
 {
   const char *path = luaL_checkstring(L, 1);
   const char *lang_name = luaL_checkstring(L, 2);
+  const char *symbol_name = lang_name;
+
+  if (lua_gettop(L) >= 3 && !lua_isnil(L, 3)) {
+    symbol_name = luaL_checkstring(L, 3);
+  }
 
   if (pmap_has(cstr_t)(&langs, lang_name)) {
-    return 0;
+    lua_pushboolean(L, true);
+    return 1;
   }
 
 #define BUFSIZE 128
   char symbol_buf[BUFSIZE];
-  snprintf(symbol_buf, BUFSIZE, "tree_sitter_%s", lang_name);
+  snprintf(symbol_buf, BUFSIZE, "tree_sitter_%s", symbol_name);
 #undef BUFSIZE
 
   uv_lib_t lib;
@@ -179,6 +190,7 @@ int tslua_add_language(lua_State *L)
 
   TSLanguage *lang = lang_parser();
   if (lang == NULL) {
+    uv_dlclose(&lib);
     return luaL_error(L, "Failed to load parser %s: internal error", path);
   }
 
-- 
cgit 


From 2fd25fb909fd4472c46c8c3c652b21d70bac9e77 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 07:20:23 +0800
Subject: vim-patch:8.1.0832: confirm() is not tested (#19896)

Problem:    confirm() is not tested.
Solution:   Add a test. (Dominique Pelle, closes vim/vim#3868)
https://github.com/vim/vim/commit/2e0500921891e4fec57e97d3c0021aa2d2b4d7ae
---
 src/nvim/testdir/test_filechanged.vim |  6 ++--
 src/nvim/testdir/test_functions.vim   | 57 +++++++++++++++++++++++++++++++++++
 2 files changed, 61 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filechanged.vim b/src/nvim/testdir/test_filechanged.vim
index b77f02afd1..fef0eb732f 100644
--- a/src/nvim/testdir/test_filechanged.vim
+++ b/src/nvim/testdir/test_filechanged.vim
@@ -140,7 +140,8 @@ func Test_FileChangedShell_edit()
 endfunc
 
 func Test_FileChangedShell_edit_dialog()
-  throw 'Skipped: requires a UI to be active'
+  " requires a UI to be active
+  throw 'Skipped: use test/functional/legacy/filechanged_spec.lua'
   CheckNotGui
   CheckUnix  " Using low level feedkeys() does not work on MS-Windows.
 
@@ -190,7 +191,8 @@ func Test_FileChangedShell_edit_dialog()
 endfunc
 
 func Test_file_changed_dialog()
-  throw 'Skipped: requires a UI to be active'
+  " requires a UI to be active
+  throw 'Skipped: use test/functional/legacy/filechanged_spec.lua'
   CheckUnix
   CheckNotGui
   au! FileChangedShell
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index ee63c0e1bd..05636199a4 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -1700,6 +1700,63 @@ func Test_platform_name()
   endif
 endfunc
 
+" Test confirm({msg} [, {choices} [, {default} [, {type}]]])
+func Test_confirm()
+  " requires a UI to be active
+  throw 'Skipped: use test/functional/vimscript/input_spec.lua'
+  if !has('unix') || has('gui_running')
+    return
+  endif
+
+  call feedkeys('o', 'L')
+  let a = confirm('Press O to proceed')
+  call assert_equal(1, a)
+
+  call feedkeys('y', 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No")
+  call assert_equal(1, a)
+
+  call feedkeys('n', 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No")
+  call assert_equal(2, a)
+
+  " confirm() should return 0 when pressing CTRL-C.
+  call feedkeys("\<C-c>", 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No")
+  call assert_equal(0, a)
+
+  " <Esc> requires another character to avoid it being seen as the start of an
+  " escape sequence.  Zero should be harmless.
+  call feedkeys("\<Esc>0", 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No")
+  call assert_equal(0, a)
+
+  " Default choice is returned when pressing <CR>.
+  call feedkeys("\<CR>", 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No")
+  call assert_equal(1, a)
+
+  call feedkeys("\<CR>", 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No", 2)
+  call assert_equal(2, a)
+
+  call feedkeys("\<CR>", 'L')
+  let a = confirm('Are you sure?', "&Yes\n&No", 0)
+  call assert_equal(0, a)
+
+  " Test with the {type} 4th argument
+  for type in ['Error', 'Question', 'Info', 'Warning', 'Generic']
+    call feedkeys('y', 'L')
+    let a = confirm('Are you sure?', "&Yes\n&No\n", 1, type)
+    call assert_equal(1, a)
+  endfor
+
+  call assert_fails('call confirm([])', 'E730:')
+  call assert_fails('call confirm("Are you sure?", [])', 'E730:')
+  call assert_fails('call confirm("Are you sure?", "&Yes\n&No\n", [])', 'E745:')
+  call assert_fails('call confirm("Are you sure?", "&Yes\n&No\n", 0, [])', 'E730:')
+endfunc
+
 func Test_readdir()
   call mkdir('Xdir')
   call writefile([], 'Xdir/foo.txt')
-- 
cgit 


From 48a4657aee76e41d097b0730c91bcca78b5bc9c7 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 08:36:22 +0800
Subject: vim-patch:8.1.{1915,1921,1953} (#19900)

vim-patch:8.1.1915: more functions can be used as methods

Problem:    More functions can be used as methods.
Solution:   Make various functions usable as a method.
https://github.com/vim/vim/commit/1a3a89168d61c2fed91cbca812cf1c6983901b79

Move debugbreak() to the right place.

vim-patch:8.1.1921: more functions can be used as methods

Problem:    More functions can be used as methods.
Solution:   Make various functions usable as a method.
https://github.com/vim/vim/commit/a4208966fb289a505ebdef62bbc37c214069bab4

vim-patch:8.1.1953: more functions can be used as a method

Problem:    More functions can be used as a method.
Solution:   Allow more functions to be used as a method.
https://github.com/vim/vim/commit/f9f24ce7a0e5988fedf2e2ff751818f9b07510a6

Omit test_termcodes.vim: cannot be used and superseded by later patches.
Cherry-pick test_bufline.vim change from patch 8.1.1993.
---
 src/nvim/testdir/test_blob.vim        | 2 +-
 src/nvim/testdir/test_bufline.vim     | 2 +-
 src/nvim/testdir/test_cd.vim          | 2 +-
 src/nvim/testdir/test_cursor_func.vim | 2 +-
 src/nvim/testdir/test_diffmode.vim    | 6 +-----
 src/nvim/testdir/test_functions.vim   | 7 ++++---
 6 files changed, 9 insertions(+), 12 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_blob.vim b/src/nvim/testdir/test_blob.vim
index af42b3857d..70529c14d5 100644
--- a/src/nvim/testdir/test_blob.vim
+++ b/src/nvim/testdir/test_blob.vim
@@ -294,7 +294,7 @@ func Test_blob_index()
   call assert_equal(2, index(0zDEADBEEF, 0xBE))
   call assert_equal(-1, index(0zDEADBEEF, 0))
   call assert_equal(2, index(0z11111111, 0x11, 2))
-  call assert_equal(3, index(0z11110111, 0x11, 2))
+  call assert_equal(3, 0z11110111->index(0x11, 2))
   call assert_equal(2, index(0z11111111, 0x11, -2))
   call assert_equal(3, index(0z11110111, 0x11, -2))
 
diff --git a/src/nvim/testdir/test_bufline.vim b/src/nvim/testdir/test_bufline.vim
index 579d3a5eb5..939147b83b 100644
--- a/src/nvim/testdir/test_bufline.vim
+++ b/src/nvim/testdir/test_bufline.vim
@@ -19,7 +19,7 @@ func Test_setbufline_getbufline()
   let b = bufnr('%')
   wincmd w
   call assert_equal(1, setbufline(b, 5, ['x']))
-  call assert_equal(1, setbufline(bufnr('$') + 1, 1, ['x']))
+  call assert_equal(1, ['x']->setbufline(bufnr('$') + 1, 1))
   call assert_equal(0, setbufline(b, 4, ['d', 'e']))
   call assert_equal(['c'], b->getbufline(3))
   call assert_equal(['d'], getbufline(b, 4))
diff --git a/src/nvim/testdir/test_cd.vim b/src/nvim/testdir/test_cd.vim
index a1e53df774..d6d44d1901 100644
--- a/src/nvim/testdir/test_cd.vim
+++ b/src/nvim/testdir/test_cd.vim
@@ -113,7 +113,7 @@ func Test_chdir_func()
   call assert_equal('z', fnamemodify(3->getcwd(2), ':t'))
   tabnext | wincmd t
   call assert_match('^\[tabpage\] .*/y$', trim(execute('verbose pwd')))
-  call chdir('..')
+  eval '..'->chdir()
   call assert_equal('Xdir', fnamemodify(getcwd(1, 2), ':t'))
   call assert_equal('Xdir', fnamemodify(getcwd(2, 2), ':t'))
   call assert_equal('z', fnamemodify(getcwd(3, 2), ':t'))
diff --git a/src/nvim/testdir/test_cursor_func.vim b/src/nvim/testdir/test_cursor_func.vim
index 3b8a5f27ad..f13842edc8 100644
--- a/src/nvim/testdir/test_cursor_func.vim
+++ b/src/nvim/testdir/test_cursor_func.vim
@@ -22,7 +22,7 @@ func Test_move_cursor()
   call cursor(3, 0)
   call assert_equal([3, 1, 0, 1], getcurpos()[1:])
   " below last line goes to last line
-  call cursor(9, 1)
+  eval [9, 1]->cursor()
   call assert_equal([4, 1, 0, 1], getcurpos()[1:])
   " pass string arguments
   call cursor('3', '3')
diff --git a/src/nvim/testdir/test_diffmode.vim b/src/nvim/testdir/test_diffmode.vim
index ea453b7174..1cb71664bd 100644
--- a/src/nvim/testdir/test_diffmode.vim
+++ b/src/nvim/testdir/test_diffmode.vim
@@ -744,17 +744,13 @@ func Test_diff_hlID()
 
   call diff_hlID(-1, 1)->synIDattr("name")->assert_equal("")
 
-  call assert_equal(diff_hlID(1, 1), hlID("DiffChange"))
   call diff_hlID(1, 1)->synIDattr("name")->assert_equal("DiffChange")
-  call assert_equal(diff_hlID(1, 2), hlID("DiffText"))
   call diff_hlID(1, 2)->synIDattr("name")->assert_equal("DiffText")
   call diff_hlID(2, 1)->synIDattr("name")->assert_equal("")
-  call assert_equal(diff_hlID(3, 1), hlID("DiffAdd"))
   call diff_hlID(3, 1)->synIDattr("name")->assert_equal("DiffAdd")
-  call diff_hlID(4, 1)->synIDattr("name")->assert_equal("")
+  eval 4->diff_hlID(1)->synIDattr("name")->assert_equal("")
 
   wincmd w
-  call assert_equal(diff_hlID(1, 1), hlID("DiffChange"))
   call assert_equal(synIDattr(diff_hlID(1, 1), "name"), "DiffChange")
   call assert_equal(synIDattr(diff_hlID(2, 1), "name"), "")
   call assert_equal(synIDattr(diff_hlID(3, 1), "name"), "")
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index 05636199a4..b024df5a45 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -1713,7 +1713,7 @@ func Test_confirm()
   call assert_equal(1, a)
 
   call feedkeys('y', 'L')
-  let a = confirm('Are you sure?', "&Yes\n&No")
+  let a = 'Are you sure?'->confirm("&Yes\n&No")
   call assert_equal(1, a)
 
   call feedkeys('n', 'L')
@@ -1727,7 +1727,7 @@ func Test_confirm()
 
   " <Esc> requires another character to avoid it being seen as the start of an
   " escape sequence.  Zero should be harmless.
-  call feedkeys("\<Esc>0", 'L')
+  eval "\<Esc>0"->feedkeys('L')
   let a = confirm('Are you sure?', "&Yes\n&No")
   call assert_equal(0, a)
 
@@ -1784,7 +1784,7 @@ func Test_readdir()
   let files = readdir('Xdir', {x -> len(add(l, x)) == 2 ? -1 : 1})
   call assert_equal(1, len(files))
 
-  call delete('Xdir', 'rf')
+  eval 'Xdir'->delete('rf')
 endfunc
 
 func Test_delete_rf()
@@ -1827,6 +1827,7 @@ endfunc
 
 func Test_char2nr()
   call assert_equal(12354, char2nr('あ', 1))
+  call assert_equal(120, 'x'->char2nr())
 endfunc
 
 func Test_charclass()
-- 
cgit 


From d5328ea408d93d53b46417a65ca3b2fc99ab64b6 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 10:38:53 +0800
Subject: vim-patch:8.2.0522: several errors are not tested for (#19901)

Problem:    Several errors are not tested for.
Solution:   Add tests. (Yegappan Lakshmanan, closes vim/vim#5892)
https://github.com/vim/vim/commit/ee4e0c1e9a81cb5d96e0060203a9033c2f28588e

Omit Test_range() change: reverted in patch 8.2.0615.
Cherry-pick Test_z_no_space_before_xxx() from patch 8.2.0195.
Cherry-pick Test_reverse_sort_uniq() change from patch 8.2.0183.
Make uniq() error behavior consistent with sort().
Cherry-pick Test_set_ttytype() change from patch 8.1.1826.
Cherry-pick quickfix checks from patch 8.1.2373 to test_preview.vim.
Test_viminfo_error() is applicable.
Cherry-pick E1058 from patch 8.2.0149 and port Test_deep_nest() to Lua.
---
 src/nvim/eval/typval.c                 |  8 ++---
 src/nvim/eval/userfunc.c               | 10 ++++--
 src/nvim/testdir/test_autocmd.vim      | 24 ++++++++++++++
 src/nvim/testdir/test_clientserver.vim |  6 ++++
 src/nvim/testdir/test_digraph.vim      | 13 ++++++++
 src/nvim/testdir/test_expr.vim         |  1 +
 src/nvim/testdir/test_highlight.vim    |  5 +--
 src/nvim/testdir/test_lambda.vim       | 18 +++++++++++
 src/nvim/testdir/test_listdict.vim     | 27 +++++++++-------
 src/nvim/testdir/test_options.vim      | 58 +++++++++++++++++++---------------
 src/nvim/testdir/test_preview.vim      |  7 ++++
 src/nvim/testdir/test_user_func.vim    |  7 ++++
 src/nvim/testdir/test_viminfo.vim      | 21 ++++++++++++
 src/nvim/testdir/test_vimscript.vim    | 23 ++++++++++++++
 14 files changed, 182 insertions(+), 46 deletions(-)
 create mode 100644 src/nvim/testdir/test_viminfo.vim

(limited to 'src')

diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 8822bb0491..7efbb1c793 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -1247,15 +1247,15 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
            ; li != NULL;) {
         listitem_T *const prev_li = TV_LIST_ITEM_PREV(l, li);
         if (item_compare_func_ptr(&prev_li, &li) == 0) {
-          if (info.item_compare_func_err) {  // -V547
-            emsg(_("E882: Uniq compare function failed"));
-            break;
-          }
           li = tv_list_item_remove(l, li);
         } else {
           idx++;
           li = TV_LIST_ITEM_NEXT(l, li);
         }
+        if (info.item_compare_func_err) {
+          emsg(_("E882: Uniq compare function failed"));
+          break;
+        }
       }
     }
 
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index c46cb6ba5d..2542a5aeb0 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1885,6 +1885,8 @@ theend:
   return name;
 }
 
+#define MAX_FUNC_NESTING 50
+
 /// ":function"
 void ex_function(exarg_T *eap)
 {
@@ -2304,8 +2306,12 @@ void ex_function(exarg_T *eap)
         p += eval_fname_script((const char *)p);
         xfree(trans_function_name((char **)&p, true, 0, NULL, NULL));
         if (*skipwhite((char *)p) == '(') {
-          nesting++;
-          indent += 2;
+          if (nesting == MAX_FUNC_NESTING - 1) {
+            emsg(_("E1058: function nesting too deep"));
+          } else {
+            nesting++;
+            indent += 2;
+          }
         }
       }
 
diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index 716511210d..5451dcf241 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -2724,6 +2724,30 @@ func Test_autocmd_FileReadCmd()
   delfunc ReadFileCmd
 endfunc
 
+" Test for passing invalid arguments to autocmd
+func Test_autocmd_invalid_args()
+  " Additional character after * for event
+  call assert_fails('autocmd *a Xfile set ff=unix', 'E215:')
+  augroup Test
+  augroup END
+  " Invalid autocmd event
+  call assert_fails('autocmd Bufabc Xfile set ft=vim', 'E216:')
+  " Invalid autocmd event in a autocmd group
+  call assert_fails('autocmd Test Bufabc Xfile set ft=vim', 'E216:')
+  augroup! Test
+  " Execute all autocmds
+  call assert_fails('doautocmd * BufEnter', 'E217:')
+  call assert_fails('augroup! x1a2b3', 'E367:')
+  call assert_fails('autocmd BufNew <buffer=999> pwd', 'E680:')
+endfunc
+
+" Test for deep nesting of autocmds
+func Test_autocmd_deep_nesting()
+  autocmd BufEnter Xfile doautocmd BufEnter Xfile
+  call assert_fails('doautocmd BufEnter Xfile', 'E218:')
+  autocmd! BufEnter Xfile
+endfunc
+
 " Tests for SigUSR1 autocmd event, which is only available on posix systems.
 func Test_autocmd_sigusr1()
   CheckUnix
diff --git a/src/nvim/testdir/test_clientserver.vim b/src/nvim/testdir/test_clientserver.vim
index 370d0cb190..66ee776a90 100644
--- a/src/nvim/testdir/test_clientserver.vim
+++ b/src/nvim/testdir/test_clientserver.vim
@@ -2,6 +2,11 @@
 
 source check.vim
 CheckFeature job
+
+if !has('clientserver')
+  call assert_fails('call remote_startserver("local")', 'E942:')
+endif
+
 CheckFeature clientserver
 
 source shared.vim
@@ -179,6 +184,7 @@ func Test_client_server()
 
   call assert_fails("let x = remote_peek([])", 'E730:')
   call assert_fails("let x = remote_read('vim10')", 'E277:')
+  call assert_fails("call server2client('abc', 'xyz')", 'E258:')
 endfunc
 
 " Uncomment this line to get a debugging log
diff --git a/src/nvim/testdir/test_digraph.vim b/src/nvim/testdir/test_digraph.vim
index acc34e5e7c..f08dff8605 100644
--- a/src/nvim/testdir/test_digraph.vim
+++ b/src/nvim/testdir/test_digraph.vim
@@ -211,6 +211,8 @@ func Test_digraphs()
   call Put_Dig("00")
   call Put_Dig("el")
   call assert_equal(['␀', 'ü', '∞', 'l'], getline(line('.')-3,line('.')))
+  call assert_fails('exe "digraph a\<Esc> 100"', 'E104:')
+  call assert_fails('exe "digraph \<Esc>a 100"', 'E104:')
   call assert_fails('digraph xy z', 'E39:')
   call assert_fails('digraph x', 'E1214:')
   bw!
@@ -491,6 +493,17 @@ func Test_show_digraph_cp1251()
   bwipe!
 endfunc
 
+" Test for error in a keymap file
+func Test_loadkeymap_error()
+  if !has('keymap')
+    return
+  endif
+  call assert_fails('loadkeymap', 'E105:')
+  call writefile(['loadkeymap', 'a'], 'Xkeymap')
+  call assert_fails('source Xkeymap', 'E791:')
+  call delete('Xkeymap')
+endfunc
+
 " Test for the characters displayed on the screen when entering a digraph
 func Test_entering_digraph()
   CheckRunVimInTerminal
diff --git a/src/nvim/testdir/test_expr.vim b/src/nvim/testdir/test_expr.vim
index 5b10e691e5..15622cd6fe 100644
--- a/src/nvim/testdir/test_expr.vim
+++ b/src/nvim/testdir/test_expr.vim
@@ -547,6 +547,7 @@ func Test_funcref()
   call assert_fails('echo funcref("{")', 'E475:')
   let OneByRef = funcref("One", repeat(["foo"], 20))
   call assert_fails('let OneByRef = funcref("One", repeat(["foo"], 21))', 'E118:')
+  call assert_fails('echo function("min") =~ function("min")', 'E694:')
 endfunc
 
 func Test_setmatches()
diff --git a/src/nvim/testdir/test_highlight.vim b/src/nvim/testdir/test_highlight.vim
index efdf44a0d6..8e808a00d0 100644
--- a/src/nvim/testdir/test_highlight.vim
+++ b/src/nvim/testdir/test_highlight.vim
@@ -731,7 +731,8 @@ func Test_1_highlight_Normalgroup_exists()
   endif
 endfunc
 
-function Test_no_space_before_xxx()
+" Do this test last, sometimes restoring the columns doesn't work
+func Test_z_no_space_before_xxx()
   " Note: we need to create this highlight group in the test because it does not exist in Neovim
   execute('hi StatusLineTermNC ctermfg=green')
   let l:org_columns = &columns
@@ -739,7 +740,7 @@ function Test_no_space_before_xxx()
   let l:hi_StatusLineTermNC = join(split(execute('hi StatusLineTermNC')))
   call assert_match('StatusLineTermNC xxx', l:hi_StatusLineTermNC)
   let &columns = l:org_columns
-endfunction
+endfunc
 
 " Test for :highlight command errors
 func Test_highlight_cmd_errors()
diff --git a/src/nvim/testdir/test_lambda.vim b/src/nvim/testdir/test_lambda.vim
index c1fe47d1c9..c178c87d3e 100644
--- a/src/nvim/testdir/test_lambda.vim
+++ b/src/nvim/testdir/test_lambda.vim
@@ -308,3 +308,21 @@ func Test_lambda_error()
   " This was causing a crash
   call assert_fails('ec{@{->{d->()()', 'E15')
 endfunc
+
+func Test_closure_error()
+  let l =<< trim END
+    func F1() closure
+      return 1
+    endfunc
+  END
+  call writefile(l, 'Xscript')
+  let caught_932 = 0
+  try
+    source Xscript
+  catch /E932:/
+    let caught_932 = 1
+  endtry
+  call assert_equal(1, caught_932)
+endfunc
+
+" vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_listdict.vim b/src/nvim/testdir/test_listdict.vim
index 2f4e1db4a1..08c415a069 100644
--- a/src/nvim/testdir/test_listdict.vim
+++ b/src/nvim/testdir/test_listdict.vim
@@ -604,20 +604,23 @@ func Test_reverse_sort_uniq()
   call assert_equal(['-0', 'A11', 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5], uniq(copy(l)))
   call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(l))
   call assert_equal([1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0'], reverse(reverse(l)))
-  call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(l))
-  call assert_equal([[0, 1, 2], [0, 1, 2], 4, 2, 2, 1.5, 'xaaa', 'x8', 'foo6', 'foo', 'foo', 'A11', '-0'], reverse(sort(l)))
-  call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(reverse(sort(l))))
-  call assert_equal(['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 4, [0, 1, 2]], uniq(sort(l)))
-
-  let l=[7, 9, 'one', 18, 12, 22, 'two', 10.0e-16, -1, 'three', 0xff, 0.22, 'four']
-  call assert_equal([-1, 'one', 'two', 'three', 'four', 1.0e-15, 0.22, 7, 9, 12, 18, 22, 255], sort(copy(l), 'n'))
-
-  let l=[7, 9, 18, 12, 22, 10.0e-16, -1, 0xff, 0, -0, 0.22, 'bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', {}, []]
-  call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 1))
-  call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i'))
-  call assert_equal(['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l)))
+  if has('float')
+    call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(l))
+    call assert_equal([[0, 1, 2], [0, 1, 2], 4, 2, 2, 1.5, 'xaaa', 'x8', 'foo6', 'foo', 'foo', 'A11', '-0'], reverse(sort(l)))
+    call assert_equal(['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]], sort(reverse(sort(l))))
+    call assert_equal(['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 4, [0, 1, 2]], uniq(sort(l)))
+
+    let l = [7, 9, 'one', 18, 12, 22, 'two', 10.0e-16, -1, 'three', 0xff, 0.22, 'four']
+    call assert_equal([-1, 'one', 'two', 'three', 'four', 1.0e-15, 0.22, 7, 9, 12, 18, 22, 255], sort(copy(l), 'n'))
+
+    let l = [7, 9, 18, 12, 22, 10.0e-16, -1, 0xff, 0, -0, 0.22, 'bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', {}, []]
+    call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 1))
+    call assert_equal(['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l), 'i'))
+    call assert_equal(['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}], sort(copy(l)))
+  endif
 
   call assert_fails('call reverse("")', 'E899:')
+  call assert_fails('call uniq([1, 2], {x, y -> []})', 'E882:')
 endfunc
 
 " reduce a list or a blob
diff --git a/src/nvim/testdir/test_options.vim b/src/nvim/testdir/test_options.vim
index e9a62d00a9..655d537336 100644
--- a/src/nvim/testdir/test_options.vim
+++ b/src/nvim/testdir/test_options.vim
@@ -234,6 +234,7 @@ func Test_complete()
   new
   call feedkeys("i\<C-N>\<Esc>", 'xt')
   bwipe!
+  call assert_fails('set complete=ix', 'E535:')
   set complete&
 endfun
 
@@ -431,32 +432,37 @@ func Test_copy_context()
 endfunc
 
 func Test_set_ttytype()
-  " Nvim does not support 'ttytype'.
-  if !has('nvim') && !has('gui_running') && has('unix')
-    " Setting 'ttytype' used to cause a double-free when exiting vim and
-    " when vim is compiled with -DEXITFREE.
-    set ttytype=ansi
-    call assert_equal('ansi', &ttytype)
-    call assert_equal(&ttytype, &term)
-    set ttytype=xterm
-    call assert_equal('xterm', &ttytype)
-    call assert_equal(&ttytype, &term)
-    try
-      set ttytype=
-      call assert_report('set ttytype= did not fail')
-    catch /E529/
-    endtry
-
-    " Some systems accept any terminal name and return dumb settings,
-    " check for failure of finding the entry and for missing 'cm' entry.
-    try
-      set ttytype=xxx
-      call assert_report('set ttytype=xxx did not fail')
-    catch /E522\|E437/
-    endtry
-
-    set ttytype&
-    call assert_equal(&ttytype, &term)
+  throw "Skipped: Nvim does not support 'ttytype'"
+  CheckUnix
+  CheckNotGui
+
+  " Setting 'ttytype' used to cause a double-free when exiting vim and
+  " when vim is compiled with -DEXITFREE.
+  set ttytype=ansi
+  call assert_equal('ansi', &ttytype)
+  call assert_equal(&ttytype, &term)
+  set ttytype=xterm
+  call assert_equal('xterm', &ttytype)
+  call assert_equal(&ttytype, &term)
+  try
+    set ttytype=
+    call assert_report('set ttytype= did not fail')
+  catch /E529/
+  endtry
+
+  " Some systems accept any terminal name and return dumb settings,
+  " check for failure of finding the entry and for missing 'cm' entry.
+  try
+    set ttytype=xxx
+    call assert_report('set ttytype=xxx did not fail')
+  catch /E522\|E437/
+  endtry
+
+  set ttytype&
+  call assert_equal(&ttytype, &term)
+
+  if has('gui') && !has('gui_running')
+    call assert_fails('set term=gui', 'E531:')
   endif
 endfunc
 
diff --git a/src/nvim/testdir/test_preview.vim b/src/nvim/testdir/test_preview.vim
index 6c4ae414d3..b7b908e761 100644
--- a/src/nvim/testdir/test_preview.vim
+++ b/src/nvim/testdir/test_preview.vim
@@ -1,5 +1,8 @@
 " Tests for the preview window
 
+source check.vim
+CheckFeature quickfix
+
 func Test_Psearch()
   " this used to cause ml_get errors
   help
@@ -13,6 +16,8 @@ func Test_Psearch()
 endfunc
 
 func Test_window_preview()
+  CheckFeature quickfix
+
   " Open a preview window
   pedit Xa
   call assert_equal(2, winnr('$'))
@@ -32,6 +37,8 @@ func Test_window_preview()
 endfunc
 
 func Test_window_preview_from_help()
+  CheckFeature quickfix
+
   filetype on
   call writefile(['/* some C code */'], 'Xpreview.c')
   help
diff --git a/src/nvim/testdir/test_user_func.vim b/src/nvim/testdir/test_user_func.vim
index 5231ef7b4f..c14624f5b4 100644
--- a/src/nvim/testdir/test_user_func.vim
+++ b/src/nvim/testdir/test_user_func.vim
@@ -169,3 +169,10 @@ endfunc
 func Test_failed_call_in_try()
   try | call UnknownFunc() | catch | endtry
 endfunc
+
+" Test for listing user-defined functions
+func Test_function_list()
+  call assert_fails("function Xabc", 'E123:')
+endfunc
+
+" vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_viminfo.vim b/src/nvim/testdir/test_viminfo.vim
new file mode 100644
index 0000000000..2d6d598011
--- /dev/null
+++ b/src/nvim/testdir/test_viminfo.vim
@@ -0,0 +1,21 @@
+
+" Test for errors in setting 'viminfo'
+func Test_viminfo_option_error()
+  " Missing number
+  call assert_fails('set viminfo=\"', 'E526:')
+  for c in split("'/:<@s", '\zs')
+    call assert_fails('set viminfo=' .. c, 'E526:')
+  endfor
+
+  " Missing comma
+  call assert_fails('set viminfo=%10!', 'E527:')
+  call assert_fails('set viminfo=!%10', 'E527:')
+  call assert_fails('set viminfo=h%10', 'E527:')
+  call assert_fails('set viminfo=c%10', 'E527:')
+  call assert_fails('set viminfo=:10%10', 'E527:')
+
+  " Missing ' setting
+  call assert_fails('set viminfo=%10', 'E528:')
+endfunc
+
+" vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_vimscript.vim b/src/nvim/testdir/test_vimscript.vim
index 0f204cdd0c..97e879c9ef 100644
--- a/src/nvim/testdir/test_vimscript.vim
+++ b/src/nvim/testdir/test_vimscript.vim
@@ -1829,6 +1829,9 @@ func Test_missing_end()
   endtry
   call assert_equal(1, caught_e733)
 
+  " Using endfunc with :if
+  call assert_fails('exe "if 1 | endfunc | endif"', 'E193:')
+
   " Missing 'in' in a :for statement
   call assert_fails('for i range(1) | endfor', 'E690:')
 endfunc
@@ -1875,6 +1878,15 @@ func Test_deep_nest()
       @a
       let @a = ''
     endfunc
+
+    " Deep nesting of function ... endfunction
+    func Test5()
+      let @a = join(repeat(['function X()'], 51), "\n")
+      let @a ..= "\necho v:true\n"
+      let @a ..= join(repeat(['endfunction'], 51), "\n")
+      @a
+      let @a = ''
+    endfunc
   [SCRIPT]
   call writefile(lines, 'Xscript')
 
@@ -1882,20 +1894,31 @@ func Test_deep_nest()
 
   " Deep nesting of if ... endif
   call term_sendkeys(buf, ":call Test1()\n")
+  call term_wait(buf)
   call WaitForAssert({-> assert_match('^E579:', term_getline(buf, 5))})
 
   " Deep nesting of for ... endfor
   call term_sendkeys(buf, ":call Test2()\n")
+  call term_wait(buf)
   call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))})
 
   " Deep nesting of while ... endwhile
   call term_sendkeys(buf, ":call Test3()\n")
+  call term_wait(buf)
   call WaitForAssert({-> assert_match('^E585:', term_getline(buf, 5))})
 
   " Deep nesting of try ... endtry
   call term_sendkeys(buf, ":call Test4()\n")
+  call term_wait(buf)
   call WaitForAssert({-> assert_match('^E601:', term_getline(buf, 5))})
 
+  " Deep nesting of function ... endfunction
+  call term_sendkeys(buf, ":call Test5()\n")
+  call term_wait(buf)
+  call WaitForAssert({-> assert_match('^E1058:', term_getline(buf, 4))})
+  call term_sendkeys(buf, "\<C-C>\n")
+  call term_wait(buf)
+
   "let l = ''
   "for i in range(1, 6)
   "  let l ..= term_getline(buf, i) . "\n"
-- 
cgit 


From 63df91c10a7ec492adae91c78cb51eb231c77d89 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 11:24:46 +0800
Subject: vim-patch:8.2.1046: insufficient tests for src/buffer.c (#19903)

Problem:    Insufficient tests for src/buffer.c.
Solution:   Add more tests.  Move comments related tests to a separate file.
            (Yegappan Lakshmanan, closes vim/vim#6325)
https://github.com/vim/vim/commit/b7e2483655d9b68df0c7349918027d800051a28a
---
 src/nvim/testdir/test_buffer.vim     | 206 ++++++++++++++++++++++++++
 src/nvim/testdir/test_cmdline.vim    |   1 +
 src/nvim/testdir/test_comments.vim   | 277 +++++++++++++++++++++++++++++++++++
 src/nvim/testdir/test_normal.vim     |   1 +
 src/nvim/testdir/test_textformat.vim | 272 ----------------------------------
 5 files changed, 485 insertions(+), 272 deletions(-)
 create mode 100644 src/nvim/testdir/test_comments.vim

(limited to 'src')

diff --git a/src/nvim/testdir/test_buffer.vim b/src/nvim/testdir/test_buffer.vim
index 67be3e6747..4def3b5df9 100644
--- a/src/nvim/testdir/test_buffer.vim
+++ b/src/nvim/testdir/test_buffer.vim
@@ -154,6 +154,24 @@ func Test_bdelete_cmd()
   set nobuflisted
   enew
   call assert_fails('bdelete ' .. bnr, 'E516:')
+
+  " Deleting more than one buffer
+  new Xbuf1
+  new Xbuf2
+  exe 'bdel ' .. bufnr('Xbuf2') .. ' ' .. bufnr('Xbuf1')
+  call assert_equal(1, winnr('$'))
+  call assert_equal(0, getbufinfo('Xbuf1')[0].loaded)
+  call assert_equal(0, getbufinfo('Xbuf2')[0].loaded)
+
+  " Deleting more than one buffer and an invalid buffer
+  new Xbuf1
+  new Xbuf2
+  let cmd = "exe 'bdel ' .. bufnr('Xbuf2') .. ' xxx ' .. bufnr('Xbuf1')"
+  call assert_fails(cmd, 'E94:')
+  call assert_equal(2, winnr('$'))
+  call assert_equal(1, getbufinfo('Xbuf1')[0].loaded)
+  call assert_equal(0, getbufinfo('Xbuf2')[0].loaded)
+
   %bwipe!
 endfunc
 
@@ -168,6 +186,194 @@ func Test_buffer_error()
   %bwipe
 endfunc
 
+" Test for the status messages displayed when unloading, deleting or wiping
+" out buffers
+func Test_buffer_statusmsg()
+  CheckEnglish
+  set report=1
+  new Xbuf1
+  new Xbuf2
+  let bnr = bufnr()
+  exe "normal 2\<C-G>"
+  call assert_match('buf ' .. bnr .. ':', v:statusmsg)
+  bunload Xbuf1 Xbuf2
+  call assert_equal('2 buffers unloaded', v:statusmsg)
+  bdel Xbuf1 Xbuf2
+  call assert_equal('2 buffers deleted', v:statusmsg)
+  bwipe Xbuf1 Xbuf2
+  call assert_equal('2 buffers wiped out', v:statusmsg)
+  set report&
+endfunc
+
+" Test for quitting the 'swapfile exists' dialog with the split buffer
+" command.
+func Test_buffer_sbuf_cleanup()
+  call writefile([], 'Xfile')
+  " first open the file in a buffer
+  new Xfile
+  let bnr = bufnr()
+  close
+  " create the swap file
+  call writefile([], '.Xfile.swp')
+  " Remove the catch-all that runtest.vim adds
+  au! SwapExists
+  augroup BufTest
+    au!
+    autocmd SwapExists Xfile let v:swapchoice='q'
+  augroup END
+  exe 'sbuf ' . bnr
+  call assert_equal(1, winnr('$'))
+  call assert_equal(0, getbufinfo('Xfile')[0].loaded)
+
+  " test for :sball
+  sball
+  call assert_equal(1, winnr('$'))
+  call assert_equal(0, getbufinfo('Xfile')[0].loaded)
+
+  %bw!
+  set shortmess+=F
+  let v:statusmsg = ''
+  edit Xfile
+  call assert_equal('', v:statusmsg)
+  call assert_equal(1, winnr('$'))
+  call assert_equal(0, getbufinfo('Xfile')[0].loaded)
+  set shortmess&
+
+  call delete('Xfile')
+  call delete('.Xfile.swp')
+  augroup BufTest
+    au!
+  augroup END
+  augroup! BufTest
+endfunc
+
+" Test for deleting a modified buffer with :confirm
+func Test_bdel_with_confirm()
+  " requires a UI to be active
+  throw 'Skipped: use test/functional/legacy/buffer_spec.lua'
+  CheckUnix
+  CheckNotGui
+  CheckFeature dialog_con
+  new
+  call setline(1, 'test')
+  call assert_fails('bdel', 'E89:')
+  call feedkeys('c', 'L')
+  confirm bdel
+  call assert_equal(2, winnr('$'))
+  call assert_equal(1, &modified)
+  call feedkeys('n', 'L')
+  confirm bdel
+  call assert_equal(1, winnr('$'))
+endfunc
+
+" Test for editing another buffer from a modified buffer with :confirm
+func Test_goto_buf_with_confirm()
+  " requires a UI to be active
+  throw 'Skipped: use test/functional/legacy/buffer_spec.lua'
+  CheckUnix
+  CheckNotGui
+  CheckFeature dialog_con
+  new Xfile
+  enew
+  call setline(1, 'test')
+  call assert_fails('b Xfile', 'E37:')
+  call feedkeys('c', 'L')
+  call assert_fails('confirm b Xfile', 'E37:')
+  call assert_equal(1, &modified)
+  call assert_equal('', @%)
+  call feedkeys('y', 'L')
+  call assert_fails('confirm b Xfile', 'E37:')
+  call assert_equal(1, &modified)
+  call assert_equal('', @%)
+  call feedkeys('n', 'L')
+  confirm b Xfile
+  call assert_equal('Xfile', @%)
+  close!
+endfunc
+
+" Test for splitting buffer with 'switchbuf'
+func Test_buffer_switchbuf()
+  new Xfile
+  wincmd w
+  set switchbuf=useopen
+  sbuf Xfile
+  call assert_equal(1, winnr())
+  call assert_equal(2, winnr('$'))
+  set switchbuf=usetab
+  tabnew
+  sbuf Xfile
+  call assert_equal(1, tabpagenr())
+  call assert_equal(2, tabpagenr('$'))
+  set switchbuf&
+  %bw
+endfunc
+
+" Test for BufAdd autocommand wiping out the buffer
+func Test_bufadd_autocmd_bwipe()
+  %bw!
+  augroup BufAdd_Wipe
+    au!
+    autocmd BufAdd Xfile %bw!
+  augroup END
+  edit Xfile
+  call assert_equal('', @%)
+  call assert_equal(0, bufexists('Xfile'))
+  augroup BufAdd_Wipe
+    au!
+  augroup END
+  augroup! BufAdd_Wipe
+endfunc
+
+" Test for trying to load a buffer with text locked
+" <C-\>e in the command line is used to lock the text
+func Test_load_buf_with_text_locked()
+  new Xfile1
+  edit Xfile2
+  let cmd = ":\<C-\>eexecute(\"normal \<C-O>\")\<CR>\<C-C>"
+  call assert_fails("call feedkeys(cmd, 'xt')", 'E565:')
+  %bw!
+endfunc
+
+" Test for using CTRL-^ to edit the alternative file keeping the cursor
+" position with 'nostartofline'. Also test using the 'buf' command.
+func Test_buffer_edit_altfile()
+  call writefile(repeat(['one two'], 50), 'Xfile1')
+  call writefile(repeat(['five six'], 50), 'Xfile2')
+  set nosol
+  edit Xfile1
+  call cursor(25, 5)
+  edit Xfile2
+  call cursor(30, 4)
+  exe "normal \<C-^>"
+  call assert_equal([0, 25, 5, 0], getpos('.'))
+  exe "normal \<C-^>"
+  call assert_equal([0, 30, 4, 0], getpos('.'))
+  buf Xfile1
+  call assert_equal([0, 25, 5, 0], getpos('.'))
+  buf Xfile2
+  call assert_equal([0, 30, 4, 0], getpos('.'))
+  set sol&
+  call delete('Xfile1')
+  call delete('Xfile2')
+endfunc
+
+" Test for running the :sball command with a maximum window count and a
+" modified buffer
+func Test_sball_with_count()
+  %bw!
+  edit Xfile1
+  call setline(1, ['abc'])
+  new Xfile2
+  new Xfile3
+  new Xfile4
+  2sball
+  call assert_equal(bufnr('Xfile4'), winbufnr(1))
+  call assert_equal(bufnr('Xfile1'), winbufnr(2))
+  call assert_equal(0, getbufinfo('Xfile2')[0].loaded)
+  call assert_equal(0, getbufinfo('Xfile3')[0].loaded)
+  %bw!
+endfunc
+
 func Test_badd_options()
   new SomeNewBuffer
   setlocal numberwidth=3
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index 72d2dc9cbb..b7c6c1e4d1 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -514,6 +514,7 @@ func Test_getcompletion()
   call delete('Xtags')
   set tags&
 
+  call assert_fails("call getcompletion('\\\\@!\\\\@=', 'buffer')", 'E871:')
   call assert_fails('call getcompletion("", "burp")', 'E475:')
   call assert_fails('call getcompletion("abc", [])', 'E475:')
 endfunc
diff --git a/src/nvim/testdir/test_comments.vim b/src/nvim/testdir/test_comments.vim
new file mode 100644
index 0000000000..c34b85c42d
--- /dev/null
+++ b/src/nvim/testdir/test_comments.vim
@@ -0,0 +1,277 @@
+" Tests for the various flags in the 'comments' option
+
+" Test for the 'n' flag in 'comments'
+func Test_comment_nested()
+  new
+  setlocal comments=n:> fo+=ro
+  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC\<C-C>Go\<BS>>>> F\nH"
+  exe "normal 5GOE\<C-C>6GoG"
+  let expected =<< trim END
+    > A
+    > B
+    > C
+    > D
+    >>>> E
+    >>>> F
+    >>>> G
+    >>>> H
+  END
+  call assert_equal(expected, getline(1, '$'))
+  close!
+endfunc
+
+" Test for the 'b' flag in 'comments'
+func Test_comment_blank()
+  new
+  setlocal comments=b:* fo+=ro
+  exe "normal i* E\nF\n\<BS>G\nH\<C-C>ggOC\<C-C>O\<BS>B\<C-C>OA\<C-C>2joD"
+  let expected =<< trim END
+    A
+    *B
+    * C
+    * D
+    * E
+    * F
+    *G
+    H
+  END
+  call assert_equal(expected, getline(1, '$'))
+  close!
+endfunc
+
+" Test for the 'f' flag in 'comments' (only the first line has a comment
+" string)
+func Test_comment_firstline()
+  new
+  setlocal comments=f:- fo+=ro
+  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
+  call assert_equal(['A', '- B', '  C', '  D'], getline(1, '$'))
+  %d
+  setlocal comments=:-
+  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
+  call assert_equal(['- A', '- B', '- C', '- D'], getline(1, '$'))
+  close!
+endfunc
+
+" Test for the 's', 'm' and 'e' flags in 'comments'
+" Test for automatically adding comment leaders in insert mode
+func Test_comment_threepiece()
+  new
+  setlocal expandtab
+  call setline(1, ["\t/*"])
+  setlocal formatoptions=croql
+  call cursor(1, 3)
+  call feedkeys("A\<cr>\<cr>/", 'tnix')
+  call assert_equal(["\t/*", " *", " */"], getline(1, '$'))
+
+  " If a comment ends in a single line, then don't add it in the next line
+  %d
+  call setline(1, '/* line1 */')
+  call feedkeys("A\<CR>next line", 'xt')
+  call assert_equal(['/* line1 */', 'next line'], getline(1, '$'))
+
+  %d
+  " Copy the trailing indentation from the leader comment to a new line
+  setlocal autoindent noexpandtab
+  call feedkeys("a\t/*\tone\ntwo\n/", 'xt')
+  call assert_equal(["\t/*\tone", "\t *\ttwo", "\t */"], getline(1, '$'))
+  close!
+endfunc
+
+" Test for the 'r' flag in 'comments' (right align comment)
+func Test_comment_rightalign()
+  new
+  setlocal comments=sr:/***,m:**,ex-2:******/ fo+=ro
+  exe "normal i=\<C-C>o\t  /***\nD\n/"
+  exe "normal 2GOA\<C-C>joB\<C-C>jOC\<C-C>joE\<C-C>GOF\<C-C>joG"
+  let expected =<< trim END
+    =
+    A
+    	  /***
+    	    ** B
+    	    ** C
+    	    ** D
+    	    ** E
+    	    **     F
+    	    ******/
+    G
+  END
+  call assert_equal(expected, getline(1, '$'))
+  close!
+endfunc
+
+" Test for the 'O' flag in 'comments'
+func Test_comment_O()
+  new
+  setlocal comments=Ob:* fo+=ro
+  exe "normal i* B\nD\<C-C>kOA\<C-C>joC"
+  let expected =<< trim END
+    A
+    * B
+    * C
+    * D
+  END
+  call assert_equal(expected, getline(1, '$'))
+  close!
+endfunc
+
+" Test for using a multibyte character as a comment leader
+func Test_comment_multibyte_leader()
+  new
+  let t =<< trim END
+    {
+    Ｘ
+    Ｘa
+    ＸaＹ
+    ＸＹ
+    ＸＹＺ
+    Ｘ Ｙ
+    Ｘ ＹＺ
+    ＸＸ
+    ＸＸa
+    ＸＸＹ
+    }
+  END
+  call setline(1, t)
+  call cursor(2, 1)
+
+  set tw=2 fo=cqm comments=n:Ｘ
+  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
+  let t =<< trim END
+    Ｘ
+    Ｘa
+    ＸaＹ
+    ＸＹ
+    ＸＹＺ
+    Ｘ Ｙ
+    Ｘ ＹＺ
+    ＸＸ
+    ＸＸa
+    ＸＸＹ
+  END
+  exe "normal o\n" . join(t, "\n")
+
+  let expected =<< trim END
+    {
+    Ｘ
+    Ｘa
+    Ｘa
+    ＸＹ
+    ＸＹ
+    ＸＹ
+    ＸＺ
+    Ｘ Ｙ
+    Ｘ Ｙ
+    Ｘ Ｚ
+    ＸＸ
+    ＸＸa
+    ＸＸＹ
+
+    Ｘ
+    Ｘa
+    Ｘa
+    ＸＹ
+    ＸＹ
+    ＸＹ
+    ＸＺ
+    Ｘ Ｙ
+    Ｘ Ｙ
+    Ｘ Ｚ
+    ＸＸ
+    ＸＸa
+    ＸＸＹ
+    }
+  END
+  call assert_equal(expected, getline(1, '$'))
+
+  set tw& fo& comments&
+  close!
+endfunc
+
+" Test for a space character in 'comments' setting
+func Test_comment_space()
+  new
+  setlocal comments=b:\ > fo+=ro
+  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC"
+  exe "normal Go > F\nH\<C-C>kOE\<C-C>joG"
+  let expected =<< trim END
+    A
+    > B
+    C
+    D
+     > E
+     > F
+     > G
+     > H
+  END
+  call assert_equal(expected, getline(1, '$'))
+  close!
+endfunc
+
+" Test for formatting lines with and without comments
+func Test_comment_format_lines()
+  new
+  call setline(1, ['one', '/* two */', 'three'])
+  normal gggqG
+  call assert_equal(['one', '/* two */', 'three'], getline(1, '$'))
+  close!
+endfunc
+
+" Test for using 'a' in 'formatoptions' with comments
+func Test_comment_autoformat()
+  new
+  setlocal formatoptions+=a
+  call feedkeys("a- one\n- two\n", 'xt')
+  call assert_equal(['- one', '- two', ''], getline(1, '$'))
+
+  %d
+  call feedkeys("a\none\n", 'xt')
+  call assert_equal(['', 'one', ''], getline(1, '$'))
+
+  setlocal formatoptions+=aw
+  %d
+  call feedkeys("aone \ntwo\n", 'xt')
+  call assert_equal(['one two', ''], getline(1, '$'))
+
+  %d
+  call feedkeys("aone\ntwo\n", 'xt')
+  call assert_equal(['one', 'two', ''], getline(1, '$'))
+
+  close!
+endfunc
+
+" Test for joining lines with comments ('j' flag in 'formatoptions')
+func Test_comment_join_lines_fo_j()
+  new
+  setlocal fo+=j comments=://
+  call setline(1, ['i++; // comment1', '           // comment2'])
+  normal J
+  call assert_equal('i++; // comment1 comment2', getline(1))
+  setlocal fo-=j
+  call setline(1, ['i++; // comment1', '           // comment2'])
+  normal J
+  call assert_equal('i++; // comment1 // comment2', getline(1))
+  " Test with nested comments
+  setlocal fo+=j comments=n:>,n:)
+  call setline(1, ['i++; > ) > ) comment1', '           > ) comment2'])
+  normal J
+  call assert_equal('i++; > ) > ) comment1 comment2', getline(1))
+  close!
+endfunc
+
+" Test for formatting lines where only the first line has a comment.
+func Test_comment_format_firstline_comment()
+  new
+  setlocal formatoptions=tcq
+  call setline(1, ['- one two', 'three'])
+  normal gggqG
+  call assert_equal(['- one two three'], getline(1, '$'))
+
+  %d
+  call setline(1, ['- one', '- two'])
+  normal gggqG
+  call assert_equal(['- one', '- two'], getline(1, '$'))
+  close!
+endfunc
+
+" vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_normal.vim b/src/nvim/testdir/test_normal.vim
index 2092b508ea..4f842189b6 100644
--- a/src/nvim/testdir/test_normal.vim
+++ b/src/nvim/testdir/test_normal.vim
@@ -1455,6 +1455,7 @@ func Test_normal21_nv_hat()
   edit Xfoo | %bw
   call assert_fails(':buffer #', 'E86')
   call assert_fails(':execute "normal! \<C-^>"', 'E23')
+  call assert_fails("normal i\<C-R>#", 'E23:')
 
   " Test for the expected behavior when switching between two named buffers.
   edit Xfoo | edit Xbar
diff --git a/src/nvim/testdir/test_textformat.vim b/src/nvim/testdir/test_textformat.vim
index 0fc56083aa..4eb6e69adf 100644
--- a/src/nvim/testdir/test_textformat.vim
+++ b/src/nvim/testdir/test_textformat.vim
@@ -962,78 +962,6 @@ func Test_tw_2_fo_tm_noai()
   bwipe!
 endfunc
 
-func Test_tw_2_fo_cqm_com()
-  new
-  let t =<< trim END
-    {
-    Ｘ
-    Ｘa
-    ＸaＹ
-    ＸＹ
-    ＸＹＺ
-    Ｘ Ｙ
-    Ｘ ＹＺ
-    ＸＸ
-    ＸＸa
-    ＸＸＹ
-    }
-  END
-  call setline(1, t)
-  call cursor(2, 1)
-
-  set tw=2 fo=cqm comments=n:Ｘ
-  exe "normal gqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgqjgqgq"
-  let t =<< trim END
-    Ｘ
-    Ｘa
-    ＸaＹ
-    ＸＹ
-    ＸＹＺ
-    Ｘ Ｙ
-    Ｘ ＹＺ
-    ＸＸ
-    ＸＸa
-    ＸＸＹ
-  END
-  exe "normal o\n" . join(t, "\n")
-
-  let expected =<< trim END
-    {
-    Ｘ
-    Ｘa
-    Ｘa
-    ＸＹ
-    ＸＹ
-    ＸＹ
-    ＸＺ
-    Ｘ Ｙ
-    Ｘ Ｙ
-    Ｘ Ｚ
-    ＸＸ
-    ＸＸa
-    ＸＸＹ
-
-    Ｘ
-    Ｘa
-    Ｘa
-    ＸＹ
-    ＸＹ
-    ＸＹ
-    ＸＺ
-    Ｘ Ｙ
-    Ｘ Ｙ
-    Ｘ Ｚ
-    ＸＸ
-    ＸＸa
-    ＸＸＹ
-    }
-  END
-  call assert_equal(expected, getline(1, '$'))
-
-  set tw& fo& comments&
-  bwipe!
-endfunc
-
 func Test_tw_2_fo_tm_replace()
   new
   let t =<< trim END
@@ -1161,140 +1089,6 @@ func Test_whichwrap_multi_byte()
   bwipe!
 endfunc
 
-" Test for automatically adding comment leaders in insert mode
-func Test_threepiece_comment()
-  new
-  setlocal expandtab
-  call setline(1, ["\t/*"])
-  setlocal formatoptions=croql
-  call cursor(1, 3)
-  call feedkeys("A\<cr>\<cr>/", 'tnix')
-  call assert_equal(["\t/*", " *", " */"], getline(1, '$'))
-
-  " If a comment ends in a single line, then don't add it in the next line
-  %d
-  call setline(1, '/* line1 */')
-  call feedkeys("A\<CR>next line", 'xt')
-  call assert_equal(['/* line1 */', 'next line'], getline(1, '$'))
-
-  %d
-  " Copy the trailing indentation from the leader comment to a new line
-  setlocal autoindent noexpandtab
-  call feedkeys("a\t/*\tone\ntwo\n/", 'xt')
-  call assert_equal(["\t/*\tone", "\t *\ttwo", "\t */"], getline(1, '$'))
-  close!
-endfunc
-
-" Test for the 'f' flag in 'comments' (only the first line has the comment
-" string)
-func Test_firstline_comment()
-  new
-  setlocal comments=f:- fo+=ro
-  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
-  call assert_equal(['A', '- B', '  C', '  D'], getline(1, '$'))
-  %d
-  setlocal comments=:-
-  exe "normal i- B\nD\<C-C>ggoC\<C-C>ggOA\<C-C>"
-  call assert_equal(['- A', '- B', '- C', '- D'], getline(1, '$'))
-  %bw!
-endfunc
-
-" Test for the 'r' flag in 'comments' (right align comment)
-func Test_comment_rightalign()
-  new
-  setlocal comments=sr:/***,m:**,ex-2:******/ fo+=ro
-  exe "normal i=\<C-C>o\t  /***\nD\n/"
-  exe "normal 2GOA\<C-C>joB\<C-C>jOC\<C-C>joE\<C-C>GOF\<C-C>joG"
-  let expected =<< trim END
-    =
-    A
-    	  /***
-    	    ** B
-    	    ** C
-    	    ** D
-    	    ** E
-    	    **     F
-    	    ******/
-    G
-  END
-  call assert_equal(expected, getline(1, '$'))
-  %bw!
-endfunc
-
-" Test for the 'b' flag in 'comments'
-func Test_comment_blank()
-  new
-  setlocal comments=b:* fo+=ro
-  exe "normal i* E\nF\n\<BS>G\nH\<C-C>ggOC\<C-C>O\<BS>B\<C-C>OA\<C-C>2joD"
-  let expected =<< trim END
-    A
-    *B
-    * C
-    * D
-    * E
-    * F
-    *G
-    H
-  END
-  call assert_equal(expected, getline(1, '$'))
-  %bw!
-endfunc
-
-" Test for the 'n' flag in comments
-func Test_comment_nested()
-  new
-  setlocal comments=n:> fo+=ro
-  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC\<C-C>Go\<BS>>>> F\nH"
-  exe "normal 5GOE\<C-C>6GoG"
-  let expected =<< trim END
-    > A
-    > B
-    > C
-    > D
-    >>>> E
-    >>>> F
-    >>>> G
-    >>>> H
-  END
-  call assert_equal(expected, getline(1, '$'))
-  %bw!
-endfunc
-
-" Test for a space character in 'comments' setting
-func Test_comment_space()
-  new
-  setlocal comments=b:\ > fo+=ro
-  exe "normal i> B\nD\<C-C>ggOA\<C-C>joC"
-  exe "normal Go > F\nH\<C-C>kOE\<C-C>joG"
-  let expected =<< trim END
-    A
-    > B
-    C
-    D
-     > E
-     > F
-     > G
-     > H
-  END
-  call assert_equal(expected, getline(1, '$'))
-  %bw!
-endfunc
-
-" Test for the 'O' flag in 'comments'
-func Test_comment_O()
-  new
-  setlocal comments=Ob:* fo+=ro
-  exe "normal i* B\nD\<C-C>kOA\<C-C>joC"
-  let expected =<< trim END
-    A
-    * B
-    * C
-    * D
-  END
-  call assert_equal(expected, getline(1, '$'))
-  %bw!
-endfunc
-
 " Test for 'a' and 'w' flags in 'formatoptions'
 func Test_fo_a_w()
   new
@@ -1334,25 +1128,6 @@ func Test_fo_a_w()
   %bw!
 endfunc
 
-" Test for 'j' flag in 'formatoptions'
-func Test_fo_j()
-  new
-  setlocal fo+=j comments=://
-  call setline(1, ['i++; // comment1', '           // comment2'])
-  normal J
-  call assert_equal('i++; // comment1 comment2', getline(1))
-  setlocal fo-=j
-  call setline(1, ['i++; // comment1', '           // comment2'])
-  normal J
-  call assert_equal('i++; // comment1 // comment2', getline(1))
-  " Test with nested comments
-  setlocal fo+=j comments=n:>,n:)
-  call setline(1, ['i++; > ) > ) comment1', '           > ) comment2'])
-  normal J
-  call assert_equal('i++; > ) > ) comment1 comment2', getline(1))
-  %bw!
-endfunc
-
 " Test for formatting lines using gq in visual mode
 func Test_visual_gq_format()
   new
@@ -1487,53 +1262,6 @@ func Test_fo_2()
   close!
 endfunc
 
-" Test for formatting lines where only the first line has a comment.
-func Test_fo_gq_with_firstline_comment()
-  new
-  setlocal formatoptions=tcq
-  call setline(1, ['- one two', 'three'])
-  normal gggqG
-  call assert_equal(['- one two three'], getline(1, '$'))
-
-  %d
-  call setline(1, ['- one', '- two'])
-  normal gggqG
-  call assert_equal(['- one', '- two'], getline(1, '$'))
-  close!
-endfunc
-
-" Test for trying to join a comment line with a non-comment line
-func Test_join_comments()
-  new
-  call setline(1, ['one', '/* two */', 'three'])
-  normal gggqG
-  call assert_equal(['one', '/* two */', 'three'], getline(1, '$'))
-  close!
-endfunc
-
-" Test for using 'a' in 'formatoptions' with comments
-func Test_autoformat_comments()
-  new
-  setlocal formatoptions+=a
-  call feedkeys("a- one\n- two\n", 'xt')
-  call assert_equal(['- one', '- two', ''], getline(1, '$'))
-
-  %d
-  call feedkeys("a\none\n", 'xt')
-  call assert_equal(['', 'one', ''], getline(1, '$'))
-
-  setlocal formatoptions+=aw
-  %d
-  call feedkeys("aone \ntwo\n", 'xt')
-  call assert_equal(['one two', ''], getline(1, '$'))
-
-  %d
-  call feedkeys("aone\ntwo\n", 'xt')
-  call assert_equal(['one', 'two', ''], getline(1, '$'))
-
-  close!
-endfunc
-
 " This was leaving the cursor after the end of a line.  Complicated way to
 " have the problem show up with valgrind.
 func Test_correct_cursor_position()
-- 
cgit 


From ffa1335047047ac00280ac742bcc6dfcc7fa3589 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 20 Aug 2022 07:54:14 +0800
Subject: vim-patch:8.2.4726: cannot use expand() to get the script name

Problem:    Cannot use expand() to get the script name.
Solution:   Support expand('<script>'). (closes vim/vim#10121)
https://github.com/vim/vim/commit/6013d0045dec7ca7c0068fbe186c42d754a7368b

Use `.sn_name` instead of `->sn_name` as v8.2.0154 hasn't been ported.
Cherry-pick builtin.txt expand() doc from latest Vim.
---
 src/nvim/ex_docmd.c              | 29 +++++++++++++++++++----
 src/nvim/runtime.c               | 24 ++++++++++++++++++-
 src/nvim/runtime.h               |  1 +
 src/nvim/testdir/test_expand.vim | 50 ++++++++++++++++++++++++++++++++++++++++
 4 files changed, 99 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 5e8c7dbdda..ac2a65844f 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -94,6 +94,12 @@ static char e_ambiguous_use_of_user_defined_command[]
   = N_("E464: Ambiguous use of user-defined command");
 static char e_not_an_editor_command[]
   = N_("E492: Not an editor command");
+static char e_no_source_file_name_to_substitute_for_sfile[]
+  = N_("E498: no :source file name to substitute for \"<sfile>\"");
+static char e_no_call_stack_to_substitute_for_stack[]
+  = N_("E489: no call stack to substitute for \"<stack>\"");
+static char e_no_script_file_name_to_substitute_for_script[]
+  = N_("E1274: No script file name to substitute for \"<script>\"");
 
 static int quitmore = 0;
 static bool ex_pressedreturn = false;
@@ -6564,6 +6570,7 @@ enum {
   SPEC_SFILE,
   SPEC_SLNUM,
   SPEC_STACK,
+  SPEC_SCRIPT,
   SPEC_AFILE,
   SPEC_ABUF,
   SPEC_AMATCH,
@@ -6588,6 +6595,7 @@ ssize_t find_cmdline_var(const char_u *src, size_t *usedlen)
     [SPEC_SFILE] = "<sfile>",           // ":so" file name
     [SPEC_SLNUM] = "<slnum>",           // ":so" file line number
     [SPEC_STACK] = "<stack>",           // call stack
+    [SPEC_SCRIPT] = "<script>",         // script file name
     [SPEC_AFILE] = "<afile>",           // autocommand file name
     [SPEC_ABUF] = "<abuf>",             // autocommand buffer number
     [SPEC_AMATCH] = "<amatch>",         // autocommand match name
@@ -6801,12 +6809,25 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
       break;
 
     case SPEC_SFILE:            // file name for ":so" command
+      result = estack_sfile(ESTACK_SFILE);
+      if (result == NULL) {
+        *errormsg = _(e_no_source_file_name_to_substitute_for_sfile);
+        return NULL;
+      }
+      resultbuf = result;  // remember allocated string
+      break;
     case SPEC_STACK:            // call stack
-      result = estack_sfile(spec_idx == SPEC_SFILE ? ESTACK_SFILE : ESTACK_STACK);
+      result = estack_sfile(ESTACK_STACK);
+      if (result == NULL) {
+        *errormsg = _(e_no_call_stack_to_substitute_for_stack);
+        return NULL;
+      }
+      resultbuf = result;  // remember allocated string
+      break;
+    case SPEC_SCRIPT:           // script file name
+      result = estack_sfile(ESTACK_SCRIPT);
       if (result == NULL) {
-        *errormsg = spec_idx == SPEC_SFILE
-          ? _("E498: no :source file name to substitute for \"<sfile>\"")
-          : _("E489: no call stack to substitute for \"<stack>\"");
+        *errormsg = _(e_no_script_file_name_to_substitute_for_script);
         return NULL;
       }
       resultbuf = result;  // remember allocated string
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 537c496ae2..412b78728e 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -100,7 +100,8 @@ void estack_pop(void)
 }
 
 /// Get the current value for <sfile> in allocated memory.
-/// @param which  ESTACK_SFILE for <sfile> and ESTACK_STACK for <stack>.
+/// @param which  ESTACK_SFILE for <sfile>, ESTACK_STACK for <stack> or
+///               ESTACK_SCRIPT for <script>.
 char *estack_sfile(estack_arg_T which)
 {
   estack_T *entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1;
@@ -111,6 +112,27 @@ char *estack_sfile(estack_arg_T which)
     return xstrdup(entry->es_name);
   }
 
+  // If evaluated in a function return the path of the script where the
+  // function is defined, at script level the current script path is returned
+  // instead.
+  if (which == ESTACK_SCRIPT) {
+    if (entry->es_type == ETYPE_UFUNC) {
+      sctx_T *def_ctx = &entry->es_info.ufunc->uf_script_ctx;
+      if (def_ctx->sc_sid > 0) {
+        return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
+      }
+    } else if (exestack.ga_len > 0) {
+      // Walk the stack backwards, starting from the current frame.
+      for (int idx = exestack.ga_len - 1; idx; idx--) {
+        entry = ((estack_T *)exestack.ga_data) + idx;
+        if (entry->es_type == ETYPE_SCRIPT) {
+          return xstrdup(entry->es_name);
+        }
+      }
+    }
+    return NULL;
+  }
+
   // Give information about each stack entry up to the root.
   // For a function we compose the call stack, as it was done in the past:
   //   "function One[123]..Two[456]..Three"
diff --git a/src/nvim/runtime.h b/src/nvim/runtime.h
index a255c6c096..03c426c79b 100644
--- a/src/nvim/runtime.h
+++ b/src/nvim/runtime.h
@@ -47,6 +47,7 @@ typedef enum {
   ESTACK_NONE,
   ESTACK_SFILE,
   ESTACK_STACK,
+  ESTACK_SCRIPT,
 } estack_arg_T;
 
 typedef struct scriptitem_S {
diff --git a/src/nvim/testdir/test_expand.vim b/src/nvim/testdir/test_expand.vim
index ce414e4b11..4b9140ef50 100644
--- a/src/nvim/testdir/test_expand.vim
+++ b/src/nvim/testdir/test_expand.vim
@@ -147,4 +147,54 @@ func Test_expandcmd_shell_nonomatch()
   call assert_equal('$*', expandcmd('$*'))
 endfunc
 
+func Test_expand_script_source()
+  let lines0 =<< trim [SCRIPT]
+    let g:script_level[0] = expand('<script>:t')
+    so Xscript1
+    func F0()
+      let g:func_level[0] = expand('<script>:t')
+    endfunc
+  [SCRIPT]
+
+  let lines1 =<< trim [SCRIPT]
+    let g:script_level[1] = expand('<script>:t')
+    so Xscript2
+    func F1()
+      let g:func_level[1] = expand('<script>:t')
+    endfunc
+  [SCRIPT]
+
+  let lines2 =<< trim [SCRIPT]
+    let g:script_level[2] = expand('<script>:t')
+    func F2()
+      let g:func_level[2] = expand('<script>:t')
+    endfunc
+  [SCRIPT]
+
+  call writefile(lines0, 'Xscript0')
+  call writefile(lines1, 'Xscript1')
+  call writefile(lines2, 'Xscript2')
+
+  " Check the expansion of <script> at script and function level.
+  let g:script_level = ['', '', '']
+  let g:func_level = ['', '', '']
+
+  so Xscript0
+  call F0()
+  call F1()
+  call F2()
+
+  call assert_equal(['Xscript0', 'Xscript1', 'Xscript2'], g:script_level)
+  call assert_equal(['Xscript0', 'Xscript1', 'Xscript2'], g:func_level)
+
+  unlet g:script_level g:func_level
+  delfunc F0
+  delfunc F1
+  delfunc F2
+
+  call delete('Xscript0')
+  call delete('Xscript1')
+  call delete('Xscript2')
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From a9e6cf0e64ede3fc26226fed3a5f94a7f5020918 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 12:11:05 +0800
Subject: vim-patch:8.2.4740: when expand() fails there is no error message

Problem:    When expand() fails there is no error message.
Solution:   When 'verbose' is set give an error message.
https://github.com/vim/vim/commit/575445200bd35283191ecd7a0d596b37c5b477a4
---
 src/nvim/eval/funcs.c            | 12 +++++++++---
 src/nvim/testdir/test_expand.vim | 12 ++++++++++--
 2 files changed, 19 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 181b17f747..6ff05b13e8 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1958,7 +1958,6 @@ static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "expand()" function
 static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
-  char *errormsg;
   int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
   bool error = false;
 #ifdef BACKSLASH_IN_FILENAME
@@ -1978,10 +1977,17 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   const char *s = tv_get_string(&argvars[0]);
   if (*s == '%' || *s == '#' || *s == '<') {
-    emsg_off++;
+    if (p_verbose == 0) {
+      emsg_off++;
+    }
     size_t len;
+    char *errormsg = NULL;
     char_u *result = eval_vars((char_u *)s, (char_u *)s, &len, NULL, &errormsg, NULL);
-    emsg_off--;
+    if (p_verbose == 0) {
+      emsg_off--;
+    } else if (errormsg != NULL) {
+      emsg(errormsg);
+    }
     if (rettv->v_type == VAR_LIST) {
       tv_list_alloc_ret(rettv, (result != NULL));
       if (result != NULL) {
diff --git a/src/nvim/testdir/test_expand.vim b/src/nvim/testdir/test_expand.vim
index 4b9140ef50..6579e09d5e 100644
--- a/src/nvim/testdir/test_expand.vim
+++ b/src/nvim/testdir/test_expand.vim
@@ -116,13 +116,21 @@ func Test_source_sfile()
     :call assert_equal('edit <cword>', expandcmd("edit <cword>"))
     :call assert_equal('edit <cexpr>', expandcmd("edit <cexpr>"))
     :call assert_fails('autocmd User MyCmd echo "<sfile>"', 'E498:')
+    :
+    :call assert_equal('', expand('<script>'))
+    :verbose echo expand('<script>')
+    :call add(v:errors, v:errmsg)
+    :verbose echo expand('<sfile>')
+    :call add(v:errors, v:errmsg)
     :call writefile(v:errors, 'Xresult')
     :qall!
-
   [SCRIPT]
   call writefile(lines, 'Xscript')
   if RunVim([], [], '--clean -s Xscript')
-    call assert_equal([], readfile('Xresult'))
+    call assert_equal([
+          \ 'E1274: No script file name to substitute for "<script>"',
+          \ 'E498: no :source file name to substitute for "<sfile>"'],
+          \ readfile('Xresult'))
   endif
   call delete('Xscript')
   call delete('Xresult')
-- 
cgit 


From 7afc17dec17bcc40c646b796f05d373e46916dd7 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 13:03:00 +0800
Subject: vim-patch:8.2.4741: startup test fails

Problem:    Startup test fails.
Solution:   Avoid an error for verbose expansion.  Fix that the "0verbose"
            command modifier doesn't work.
https://github.com/vim/vim/commit/60895f3e36def9beb7d5463e792e5154ad9a7a0a

Most code changes has already been ported.
---
 src/nvim/ex_docmd.c             | 25 +++++++++++++------------
 src/nvim/testdir/test_excmd.vim |  8 +++++---
 2 files changed, 18 insertions(+), 15 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index ac2a65844f..7ed28e823e 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -6617,18 +6617,19 @@ ssize_t find_cmdline_var(const char_u *src, size_t *usedlen)
 
 /// Evaluate cmdline variables.
 ///
-/// change '%'       to curbuf->b_ffname
-///        '#'       to curwin->w_alt_fnum
-///        '<cword>' to word under the cursor
-///        '<cWORD>' to WORD under the cursor
-///        '<cexpr>' to C-expression under the cursor
-///        '<cfile>' to path name under the cursor
-///        '<sfile>' to sourced file name
-///        '<stack>' to call stack
-///        '<slnum>' to sourced file line number
-///        '<afile>' to file name for autocommand
-///        '<abuf>'  to buffer number for autocommand
-///        '<amatch>' to matching name for autocommand
+/// change "%"       to curbuf->b_ffname
+///        "#"       to curwin->w_alt_fnum
+///        "<cword>" to word under the cursor
+///        "<cWORD>" to WORD under the cursor
+///        "<cexpr>" to C-expression under the cursor
+///        "<cfile>" to path name under the cursor
+///        "<sfile>" to sourced file name
+///        "<stack>" to call stack
+///        "<script>" to current script name
+///        "<slnum>" to sourced file line number
+///        "<afile>" to file name for autocommand
+///        "<abuf>"  to buffer number for autocommand
+///        "<amatch>" to matching name for autocommand
 ///
 /// When an error is detected, "errormsg" is set to a non-NULL pointer (may be
 /// "" for error without a message) and NULL is returned.
diff --git a/src/nvim/testdir/test_excmd.vim b/src/nvim/testdir/test_excmd.vim
index dac7a6989d..9a9e5c546b 100644
--- a/src/nvim/testdir/test_excmd.vim
+++ b/src/nvim/testdir/test_excmd.vim
@@ -568,10 +568,12 @@ endfunc
 
 " Test for the :verbose command
 func Test_verbose_cmd()
-  call assert_equal(['  verbose=1'], split(execute('verbose set vbs'), "\n"))
+  set verbose=3
+  call assert_match('  verbose=1\n\s*Last set from ', execute('verbose set vbs'), "\n")
   call assert_equal(['  verbose=0'], split(execute('0verbose set vbs'), "\n"))
-  let l = execute("4verbose set verbose | set verbose")
-  call assert_equal(['  verbose=4', '  verbose=0'], split(l, "\n"))
+  set verbose=0
+  call assert_match('  verbose=4\n\s*Last set from .*\n  verbose=0',
+        \ execute("4verbose set verbose | set verbose"))
 endfunc
 
 " Test for the :delete command and the related abbreviated commands
-- 
cgit 


From d0b9fe2d5a95def67acc83f713b932f3f12dea08 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 12:20:37 +0800
Subject: vim-patch:8.2.4749: <script> is not expanded in autocmd context

Problem:    <script> is not expanded in autocmd context.
Solution:   Add the context to the pattern struct. (closes vim/vim#10144)
            Rename AutoPatCmd to AutoPatCmd_T.
https://github.com/vim/vim/commit/eca7c60d68e63001dbe3c8e5d240b0895e607fc3

Omit AutoPatCmd -> AutoPatCmd_T rename as it is inconsistent.
Use `.sn_name` instead of `->sn_name` as v8.2.0154 hasn't been ported.
Omit acp_script_stx(), use member directly.
---
 src/nvim/autocmd.c               | 37 ++++++++++++++++++++++---------------
 src/nvim/autocmd.h               |  3 ++-
 src/nvim/runtime.c               | 37 +++++++++++++++++++++++--------------
 src/nvim/testdir/test_expand.vim | 27 ++++++++++++++++++---------
 4 files changed, 65 insertions(+), 39 deletions(-)

(limited to 'src')

diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 579c6c029f..c20db2910c 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -1811,16 +1811,15 @@ bool apply_autocmds_group(event_T event, char *fname, char *fname_io, bool force
   char *tail = path_tail(fname);
 
   // Find first autocommand that matches
-  AutoPatCmd patcmd;
-  patcmd.curpat = first_autopat[(int)event];
-  patcmd.nextcmd = NULL;
-  patcmd.group = group;
-  patcmd.fname = fname;
-  patcmd.sfname = sfname;
-  patcmd.tail = tail;
-  patcmd.event = event;
-  patcmd.arg_bufnr = autocmd_bufnr;
-  patcmd.next = NULL;
+  AutoPatCmd patcmd = {
+    .curpat = first_autopat[(int)event],
+    .group = group,
+    .fname = fname,
+    .sfname = sfname,
+    .tail = tail,
+    .event = event,
+    .arg_bufnr = autocmd_bufnr,
+  };
   auto_next_pat(&patcmd, false);
 
   // found one, start executing the autocommands
@@ -1984,9 +1983,12 @@ void auto_next_pat(AutoPatCmd *apc, int stop_at_last)
   AutoPat *ap;
   AutoCmd *cp;
   char *s;
-  char **const sourcing_namep = &SOURCING_NAME;
 
-  XFREE_CLEAR(*sourcing_namep);
+  estack_T *const entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1;
+
+  // Clear the exestack entry for this ETYPE_AUCMD entry.
+  XFREE_CLEAR(entry->es_name);
+  entry->es_info.aucmd = NULL;
 
   for (ap = apc->curpat; ap != NULL && !got_int; ap = ap->next) {
     apc->curpat = NULL;
@@ -2011,14 +2013,18 @@ void auto_next_pat(AutoPatCmd *apc, int stop_at_last)
         const size_t sourcing_name_len
           = (STRLEN(s) + strlen(name) + (size_t)ap->patlen + 1);
 
-        *sourcing_namep = xmalloc(sourcing_name_len);
-        snprintf(*sourcing_namep, sourcing_name_len, s, name, ap->pat);
+        char *const namep = xmalloc(sourcing_name_len);
+        snprintf(namep, sourcing_name_len, s, name, ap->pat);
         if (p_verbose >= 8) {
           verbose_enter();
-          smsg(_("Executing %s"), *sourcing_namep);
+          smsg(_("Executing %s"), namep);
           verbose_leave();
         }
 
+        // Update the exestack entry for this autocmd.
+        entry->es_name = namep;
+        entry->es_info.aucmd = apc;
+
         apc->curpat = ap;
         apc->nextcmd = ap->cmds;
         // mark last command
@@ -2150,6 +2156,7 @@ char *getnextac(int c, void *cookie, int indent, bool do_concat)
   // lua code, so that it works properly
   autocmd_nested = ac->nested;
   current_sctx = ac->script_ctx;
+  acp->script_ctx = current_sctx;
 
   if (ac->exec.type == CALLABLE_CB) {
     if (call_autocmd_callback(ac, acp)) {
diff --git a/src/nvim/autocmd.h b/src/nvim/autocmd.h
index d559d8c3d2..75a8a7aaa1 100644
--- a/src/nvim/autocmd.h
+++ b/src/nvim/autocmd.h
@@ -29,7 +29,7 @@ struct AutoCmd_S {
   bool nested;                          // If autocommands nest here
   bool last;                            // last command in list
   int64_t id;                           // ID used for uniquely tracking an autocmd.
-  sctx_T script_ctx;                    // script context where defined
+  sctx_T script_ctx;                    // script context where it is defined
   char *desc;                           // Description for the autocmd.
   AutoCmd *next;                        // Next AutoCmd in list
 };
@@ -59,6 +59,7 @@ struct AutoPatCmd_S {
   char *sfname;             // sfname to match with
   char *tail;               // tail of fname
   event_T event;            // current event
+  sctx_T script_ctx;        // script context where it is defined
   int arg_bufnr;            // initially equal to <abuf>, set to zero when buf is deleted
   Object *data;             // arbitrary data
   AutoPatCmd *next;         // chain of active apc-s for auto-invalidation
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 412b78728e..038aad12a4 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -104,7 +104,7 @@ void estack_pop(void)
 ///               ESTACK_SCRIPT for <script>.
 char *estack_sfile(estack_arg_T which)
 {
-  estack_T *entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1;
+  const estack_T *entry = ((estack_T *)exestack.ga_data) + exestack.ga_len - 1;
   if (which == ESTACK_SFILE && entry->es_type != ETYPE_UFUNC) {
     if (entry->es_name == NULL) {
       return NULL;
@@ -112,22 +112,31 @@ char *estack_sfile(estack_arg_T which)
     return xstrdup(entry->es_name);
   }
 
-  // If evaluated in a function return the path of the script where the
-  // function is defined, at script level the current script path is returned
+  // If evaluated in a function or autocommand, return the path of the script
+  // where it is defined, at script level the current script path is returned
   // instead.
   if (which == ESTACK_SCRIPT) {
-    if (entry->es_type == ETYPE_UFUNC) {
-      sctx_T *def_ctx = &entry->es_info.ufunc->uf_script_ctx;
-      if (def_ctx->sc_sid > 0) {
-        return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
-      }
-    } else if (exestack.ga_len > 0) {
-      // Walk the stack backwards, starting from the current frame.
-      for (int idx = exestack.ga_len - 1; idx; idx--) {
-        entry = ((estack_T *)exestack.ga_data) + idx;
-        if (entry->es_type == ETYPE_SCRIPT) {
-          return xstrdup(entry->es_name);
+    assert(entry == ((estack_T *)exestack.ga_data) + exestack.ga_len - 1);
+    // Walk the stack backwards, starting from the current frame.
+    for (int idx = exestack.ga_len - 1; idx >= 0; idx--, entry--) {
+      if (entry->es_type == ETYPE_UFUNC) {
+        const sctx_T *const def_ctx = &entry->es_info.ufunc->uf_script_ctx;
+
+        if (def_ctx->sc_sid > 0) {
+          return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
+        } else {
+          return NULL;
+        }
+      } else if (entry->es_type == ETYPE_AUCMD) {
+        const sctx_T *const def_ctx = &entry->es_info.aucmd->script_ctx;
+
+        if (def_ctx->sc_sid > 0) {
+          return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
+        } else {
+          return NULL;
         }
+      } else if (entry->es_type == ETYPE_SCRIPT) {
+        return xstrdup(entry->es_name);
       }
     }
     return NULL;
diff --git a/src/nvim/testdir/test_expand.vim b/src/nvim/testdir/test_expand.vim
index 6579e09d5e..aa131a49ff 100644
--- a/src/nvim/testdir/test_expand.vim
+++ b/src/nvim/testdir/test_expand.vim
@@ -157,43 +157,52 @@ endfunc
 
 func Test_expand_script_source()
   let lines0 =<< trim [SCRIPT]
-    let g:script_level[0] = expand('<script>:t')
+    call extend(g:script_level, [expand('<script>:t')])
     so Xscript1
     func F0()
-      let g:func_level[0] = expand('<script>:t')
+      call extend(g:func_level, [expand('<script>:t')])
     endfunc
+
+    au User * call extend(g:au_level, [expand('<script>:t')])
   [SCRIPT]
 
   let lines1 =<< trim [SCRIPT]
-    let g:script_level[1] = expand('<script>:t')
+    call extend(g:script_level, [expand('<script>:t')])
     so Xscript2
     func F1()
-      let g:func_level[1] = expand('<script>:t')
+      call extend(g:func_level, [expand('<script>:t')])
     endfunc
+
+    au User * call extend(g:au_level, [expand('<script>:t')])
   [SCRIPT]
 
   let lines2 =<< trim [SCRIPT]
-    let g:script_level[2] = expand('<script>:t')
+    call extend(g:script_level, [expand('<script>:t')])
     func F2()
-      let g:func_level[2] = expand('<script>:t')
+      call extend(g:func_level, [expand('<script>:t')])
     endfunc
+
+    au User * call extend(g:au_level, [expand('<script>:t')])
   [SCRIPT]
 
   call writefile(lines0, 'Xscript0')
   call writefile(lines1, 'Xscript1')
   call writefile(lines2, 'Xscript2')
 
-  " Check the expansion of <script> at script and function level.
-  let g:script_level = ['', '', '']
-  let g:func_level = ['', '', '']
+  " Check the expansion of <script> at different levels.
+  let g:script_level = []
+  let g:func_level = []
+  let g:au_level = []
 
   so Xscript0
   call F0()
   call F1()
   call F2()
+  doautocmd User
 
   call assert_equal(['Xscript0', 'Xscript1', 'Xscript2'], g:script_level)
   call assert_equal(['Xscript0', 'Xscript1', 'Xscript2'], g:func_level)
+  call assert_equal(['Xscript2', 'Xscript1', 'Xscript0'], g:au_level)
 
   unlet g:script_level g:func_level
   delfunc F0
-- 
cgit 


From f1b8683b8c2f4a48d501c9dedef664f17761b8ac Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 13:24:40 +0800
Subject: vim-patch:8.2.4841: empty string considered an error for expand()

Problem:    Empty string considered an error for expand() when 'verbose' is
            set. (Christian Brabandt)
Solution:   Do not give an error for an empty result. (closes vim/vim#10307)
https://github.com/vim/vim/commit/a96edb736d4274fc4aea460800780e06e1510812
---
 src/nvim/eval/funcs.c                 |  2 +-
 src/nvim/ex_docmd.c                   | 22 ++++++++++++----------
 src/nvim/path.c                       |  3 ++-
 src/nvim/testdir/test_expand_func.vim |  6 +++++-
 4 files changed, 20 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 6ff05b13e8..8d5b8c850c 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1982,7 +1982,7 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     }
     size_t len;
     char *errormsg = NULL;
-    char_u *result = eval_vars((char_u *)s, (char_u *)s, &len, NULL, &errormsg, NULL);
+    char_u *result = eval_vars((char_u *)s, (char_u *)s, &len, NULL, &errormsg, NULL, false);
     if (p_verbose == 0) {
       emsg_off--;
     } else if (errormsg != NULL) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 7ed28e823e..f9055a0e8b 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3705,7 +3705,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
     size_t srclen;
     int escaped;
     char *repl = (char *)eval_vars((char_u *)p, (char_u *)eap->arg, &srclen, &(eap->do_ecmd_lnum),
-                                   errormsgp, &escaped);
+                                   errormsgp, &escaped, true);
     if (*errormsgp != NULL) {           // error detected
       return FAIL;
     }
@@ -6634,18 +6634,19 @@ ssize_t find_cmdline_var(const char_u *src, size_t *usedlen)
 /// When an error is detected, "errormsg" is set to a non-NULL pointer (may be
 /// "" for error without a message) and NULL is returned.
 ///
-/// @param src       pointer into commandline
-/// @param srcstart  beginning of valid memory for src
-/// @param usedlen   characters after src that are used
-/// @param lnump     line number for :e command, or NULL
-/// @param errormsg  pointer to error message
-/// @param escaped   return value has escaped white space (can be NULL)
+/// @param src             pointer into commandline
+/// @param srcstart        beginning of valid memory for src
+/// @param usedlen         characters after src that are used
+/// @param lnump           line number for :e command, or NULL
+/// @param errormsg        pointer to error message
+/// @param escaped         return value has escaped white space (can be NULL)
+/// @param empty_is_error  empty result is considered an error
 ///
 /// @return          an allocated string if a valid match was found.
 ///                  Returns NULL if no match was found.  "usedlen" then still contains the
 ///                  number of characters to skip.
 char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnump, char **errormsg,
-                  int *escaped)
+                  int *escaped, bool empty_is_error)
 {
   char *result;
   char *resultbuf = NULL;
@@ -6890,7 +6891,7 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
     }
   }
 
-  if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH) {
+  if (empty_is_error && (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)) {
     if (valid != VALID_HEAD + VALID_PATH) {
       // xgettext:no-c-format
       *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
@@ -6919,7 +6920,8 @@ char *expand_sfile(char *arg)
       // replace "<sfile>" with the sourced file name, and do ":" stuff
       size_t srclen;
       char *errormsg;
-      char *repl = (char *)eval_vars((char_u *)p, (char_u *)result, &srclen, NULL, &errormsg, NULL);
+      char *repl = (char *)eval_vars((char_u *)p, (char_u *)result, &srclen, NULL, &errormsg, NULL,
+                                     true);
       if (errormsg != NULL) {
         if (*errormsg) {
           emsg(errormsg);
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 1500254de5..d50ef87b62 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -2135,7 +2135,8 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
 
   if (*exp_pat == '%' || *exp_pat == '#' || *exp_pat == '<') {
     emsg_off++;
-    eval_pat = eval_vars((char_u *)exp_pat, (char_u *)exp_pat, &usedlen, NULL, &ignored_msg, NULL);
+    eval_pat = eval_vars((char_u *)exp_pat, (char_u *)exp_pat, &usedlen, NULL, &ignored_msg, NULL,
+                         true);
     emsg_off--;
     if (eval_pat != NULL) {
       exp_pat = (char *)concat_str(eval_pat, (char_u *)exp_pat + usedlen);
diff --git a/src/nvim/testdir/test_expand_func.vim b/src/nvim/testdir/test_expand_func.vim
index df01d84f19..dfe4ce105c 100644
--- a/src/nvim/testdir/test_expand_func.vim
+++ b/src/nvim/testdir/test_expand_func.vim
@@ -107,10 +107,14 @@ endfunc
 
 func Test_expand()
   new
-  call assert_equal("",  expand('%:S'))
+  call assert_equal("''", expand('%:S'))
   call assert_equal('3', '<slnum>'->expand())
   call assert_equal(['4'], expand('<slnum>', v:false, v:true))
   " Don't add any line above this, otherwise <slnum> will change.
+  call assert_equal("", expand('%'))
+  set verbose=1
+  call assert_equal("", expand('%'))
+  set verbose=0
   quit
 endfunc
 
-- 
cgit 


From d459b6687704b7d1f230d0b14c0d59f87cf5f67d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 13:31:07 +0800
Subject: vim-patch:8.2.4842: expand("%:p") is not empty when there is no
 buffer name

Problem:    expand("%:p") is not empty when there is no buffer name.
Solution:   When ignoring errors still return NULL. (closes vim/vim#10311)
https://github.com/vim/vim/commit/211a5bb2353c66684f38527184a258921f95c9d9
---
 src/nvim/ex_docmd.c                   | 14 ++++++++------
 src/nvim/testdir/test_expand_func.vim |  3 ++-
 2 files changed, 10 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index f9055a0e8b..e8860ff0d4 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -6891,12 +6891,14 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
     }
   }
 
-  if (empty_is_error && (resultlen == 0 || valid != VALID_HEAD + VALID_PATH)) {
-    if (valid != VALID_HEAD + VALID_PATH) {
-      // xgettext:no-c-format
-      *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
-    } else {
-      *errormsg = _("E500: Evaluates to an empty string");
+  if (resultlen == 0 || valid != VALID_HEAD + VALID_PATH) {
+    if (empty_is_error) {
+      if (valid != VALID_HEAD + VALID_PATH) {
+        // xgettext:no-c-format
+        *errormsg = _("E499: Empty file name for '%' or '#', only works with \":p:h\"");
+      } else {
+        *errormsg = _("E500: Evaluates to an empty string");
+      }
     }
     result = NULL;
   } else {
diff --git a/src/nvim/testdir/test_expand_func.vim b/src/nvim/testdir/test_expand_func.vim
index dfe4ce105c..80bfdb8553 100644
--- a/src/nvim/testdir/test_expand_func.vim
+++ b/src/nvim/testdir/test_expand_func.vim
@@ -107,7 +107,7 @@ endfunc
 
 func Test_expand()
   new
-  call assert_equal("''", expand('%:S'))
+  call assert_equal("", expand('%:S'))
   call assert_equal('3', '<slnum>'->expand())
   call assert_equal(['4'], expand('<slnum>', v:false, v:true))
   " Don't add any line above this, otherwise <slnum> will change.
@@ -115,6 +115,7 @@ func Test_expand()
   set verbose=1
   call assert_equal("", expand('%'))
   set verbose=0
+  call assert_equal("", expand('%:p'))
   quit
 endfunc
 
-- 
cgit 


From 779a25f040704e4f1b56abedc901ec4f9829bb27 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Tue, 23 Aug 2022 14:30:02 +0100
Subject: refactor(spell.c): resolve clint errors (#19875)

Co-authored-by: zeertzjq <zeertzjq@outlook.com>
---
 src/nvim/spell.c | 436 ++++++++++++++++++++++++-------------------------------
 1 file changed, 186 insertions(+), 250 deletions(-)

(limited to 'src')

diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index da712a5753..40114f084d 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -56,50 +56,59 @@
 // Use DEBUG_TRIEWALK to print the changes made in suggest_trie_walk() for a
 // specific word.
 
-#include <assert.h>
-#include <inttypes.h>
-#include <limits.h>
-#include <stdbool.h>
-#include <stdlib.h>
-#include <string.h>
-#include <wctype.h>
-
-// for offsetof()
-#include <stddef.h>
-
-#include "nvim/ascii.h"
-#include "nvim/buffer.h"
-#include "nvim/change.h"
-#include "nvim/charset.h"
-#include "nvim/cursor.h"
-#include "nvim/drawscreen.h"
-#include "nvim/edit.h"
-#include "nvim/ex_cmds.h"
-#include "nvim/ex_docmd.h"
-#include "nvim/func_attr.h"
-#include "nvim/garray.h"
-#include "nvim/hashtab.h"
-#include "nvim/input.h"
-#include "nvim/insexpand.h"
-#include "nvim/mark.h"
-#include "nvim/mbyte.h"
-#include "nvim/memline.h"
-#include "nvim/memory.h"
-#include "nvim/message.h"
-#include "nvim/normal.h"
-#include "nvim/option.h"
-#include "nvim/os/input.h"
-#include "nvim/os/os.h"
-#include "nvim/os_unix.h"
-#include "nvim/path.h"
-#include "nvim/regexp.h"
-#include "nvim/search.h"
-#include "nvim/spell.h"
-#include "nvim/spellfile.h"
-#include "nvim/spellsuggest.h"
-#include "nvim/strings.h"
-#include "nvim/syntax.h"
-#include "nvim/undo.h"
+#include <assert.h>               // for assert
+#include <inttypes.h>             // for uint32_t, uint16_t, uint8_t
+#include <limits.h>               // for INT_MAX
+#include <stdbool.h>              // for false, true, bool
+#include <stddef.h>               // for NULL, size_t, ptrdiff_t
+#include <stdio.h>                // for snprintf
+#include <string.h>               // for memmove, strstr, memcpy, memset
+
+#include "nvim/ascii.h"           // for NUL, ascii_isdigit, ascii_iswhite
+#include "nvim/autocmd.h"         // for apply_autocmds
+#include "nvim/buffer.h"          // for bufref_valid, set_bufref, buf_is_empty
+#include "nvim/buffer_defs.h"     // for win_T, synblock_T, buf_T, w_p_...
+#include "nvim/change.h"          // for changed_bytes
+#include "nvim/charset.h"         // for skipwhite, getwhitecols, skipbin
+#include "nvim/cursor.h"          // for get_cursor_line_ptr
+#include "nvim/drawscreen.h"      // for NOT_VALID, redraw_later
+#include "nvim/eval/typval.h"     // for semsg
+#include "nvim/ex_cmds.h"         // for do_sub_msg
+#include "nvim/ex_cmds_defs.h"    // for exarg_T
+#include "nvim/ex_docmd.h"        // for do_cmdline_cmd
+#include "nvim/garray.h"          // for garray_T, GA_EMPTY, GA_APPEND_...
+#include "nvim/gettext.h"         // for _, N_
+#include "nvim/hashtab.h"         // for hash_clear_all, hash_init, has...
+#include "nvim/highlight_defs.h"  // for HLF_COUNT, hlf_T, HLF_SPB, HLF...
+#include "nvim/insexpand.h"       // for ins_compl_add_infercase, ins_c...
+#include "nvim/log.h"             // for ELOG
+#include "nvim/macros.h"          // for MB_PTR_ADV, MB_PTR_BACK, ASCII...
+#include "nvim/mark.h"            // for clearpos
+#include "nvim/mbyte.h"           // for utf_ptr2char, utf_char2bytes
+#include "nvim/memline.h"         // for ml_append, ml_get_buf, ml_close
+#include "nvim/memline_defs.h"    // for memline_T
+#include "nvim/memory.h"          // for xfree, xmalloc, xcalloc, xstrdup
+#include "nvim/message.h"         // for emsg, msg_puts, give_warning
+#include "nvim/option.h"          // for copy_option_part, set_option_v...
+#include "nvim/option_defs.h"     // for p_ws, OPT_LOCAL, p_enc, SHM_SE...
+#include "nvim/os/fs.h"           // for os_remove
+#include "nvim/os/input.h"        // for line_breakcheck
+#include "nvim/os/os_defs.h"      // for MAXPATHL
+#include "nvim/path.h"            // for path_full_compare, path_tail...
+#include "nvim/pos.h"             // for pos_T, colnr_T, linenr_T
+#include "nvim/regexp.h"          // for vim_regfree, vim_regexec, vim_...
+#include "nvim/regexp_defs.h"     // for regmatch_T, regprog_T
+#include "nvim/runtime.h"         // for DIP_ALL, do_in_runtimepath
+#include "nvim/search.h"          // for SEARCH_KEEP, for do_search
+#include "nvim/spell.h"           // for FUNC_ATTR_NONNULL_ALL, FUNC_AT...
+#include "nvim/spell_defs.h"      // for slang_T, langp_T, MAXWLEN, sal...
+#include "nvim/spellfile.h"       // for spell_load_file
+#include "nvim/spellsuggest.h"    // for spell_suggest_list
+#include "nvim/strings.h"         // for vim_strchr, vim_snprintf, conc...
+#include "nvim/syntax.h"          // for syn_get_id, syntax_present
+#include "nvim/types.h"           // for char_u
+#include "nvim/undo.h"            // for u_save_cursor
+#include "nvim/vim.h"             // for curwin, STRLEN, STRLCPY, STRNCMP
 
 // Result values.  Lower number is accepted over higher one.
 #define SP_BANNED       (-1)
@@ -209,9 +218,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
   matchinf_T mi;              // Most things are put in "mi" so that it can
                               // be passed to functions quickly.
   size_t nrlen = 0;              // found a number first
-  int c;
   size_t wrongcaplen = 0;
-  int lpi;
   bool count_word = docount;
   bool use_camel_case = *wp->w_s->b_p_spo != NUL;
   bool camel_case = false;
@@ -250,7 +257,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
     bool this_upper = false;  // init for gcc
 
     if (use_camel_case) {
-      c = utf_ptr2char((char *)mi.mi_fend);
+      int c = utf_ptr2char((char *)mi.mi_fend);
       this_upper = SPELL_ISUPPER(c);
     }
 
@@ -258,7 +265,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
       MB_PTR_ADV(mi.mi_fend);
       if (use_camel_case) {
         const bool prev_upper = this_upper;
-        c = utf_ptr2char((char *)mi.mi_fend);
+        int c = utf_ptr2char((char *)mi.mi_fend);
         this_upper = SPELL_ISUPPER(c);
         camel_case = !prev_upper && this_upper;
       }
@@ -267,7 +274,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
 
     if (capcol != NULL && *capcol == 0 && wp->w_s->b_cap_prog != NULL) {
       // Check word starting with capital letter.
-      c = utf_ptr2char((char *)ptr);
+      int c = utf_ptr2char((char *)ptr);
       if (!SPELL_ISUPPER(c)) {
         wrongcaplen = (size_t)(mi.mi_fend - ptr);
       }
@@ -308,7 +315,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
   // Loop over the languages specified in 'spelllang'.
   // We check them all, because a word may be matched longer in another
   // language.
-  for (lpi = 0; lpi < wp->w_s->b_langp.ga_len; ++lpi) {
+  for (int lpi = 0; lpi < wp->w_s->b_langp.ga_len; lpi++) {
     mi.mi_lp = LANGP_ENTRY(wp->w_s->b_langp, lpi);
 
     // If reloading fails the language is still in the list but everything
@@ -468,7 +475,6 @@ static void find_word(matchinf_T *mip, int mode)
   int endlen[MAXWLEN];              // length at possible word endings
   idx_T endidx[MAXWLEN];            // possible word endings
   int endidxcnt = 0;
-  int len;
   int c;
 
   // Repeat advancing in the tree until:
@@ -480,7 +486,7 @@ static void find_word(matchinf_T *mip, int mode)
       flen = fold_more(mip);
     }
 
-    len = byts[arridx++];
+    int len = byts[arridx++];
 
     // If the first possible byte is a zero the word could end here.
     // Remember this index, we first check for the longest word.
@@ -597,7 +603,7 @@ static void find_word(matchinf_T *mip, int mode)
     // prefix ID.
     // Repeat this if there are more flags/region alternatives until there
     // is a match.
-    for (len = byts[arridx - 1]; len > 0 && byts[arridx] == 0; len--, arridx++) {
+    for (int len = byts[arridx - 1]; len > 0 && byts[arridx] == 0; len--, arridx++) {
       uint32_t flags = (uint32_t)idxs[arridx];
 
       // For the fold-case tree check that the case of the checked word
@@ -616,11 +622,10 @@ static void find_word(matchinf_T *mip, int mode)
             || !spell_valid_case(mip->mi_capflags, (int)flags)) {
           continue;
         }
-      }
-      // When mode is FIND_PREFIX the word must support the prefix:
-      // check the prefix ID and the condition.  Do that for the list at
-      // mip->mi_prefarridx that find_prefix() filled.
-      else if (mode == FIND_PREFIX && !prefix_found) {
+      } else if (mode == FIND_PREFIX && !prefix_found) {
+        // When mode is FIND_PREFIX the word must support the prefix:
+        // check the prefix ID and the condition.  Do that for the list at
+        // mip->mi_prefarridx that find_prefix() filled.
         c = valid_word_prefix(mip->mi_prefcnt, mip->mi_prefarridx,
                               (int)flags,
                               mip->mi_word + mip->mi_cprefixlen, slang,
@@ -752,9 +757,8 @@ static void find_word(matchinf_T *mip, int mode)
           // COMPOUNDRULE, discard the compounded word.
           continue;
         }
-      }
-      // Check NEEDCOMPOUND: can't use word without compounding.
-      else if (flags & WF_NEEDCOMP) {
+      } else if (flags & WF_NEEDCOMP) {
+        // skip if word is only valid in a compound
         continue;
       }
 
@@ -792,14 +796,14 @@ static void find_word(matchinf_T *mip, int mode)
 #if 0
         c = mip->mi_compoff;
 #endif
-        ++mip->mi_complen;
+        mip->mi_complen++;
         if (flags & WF_COMPROOT) {
-          ++mip->mi_compextra;
+          mip->mi_compextra++;
         }
 
         // For NOBREAK we need to try all NOBREAK languages, at least
         // to find the ".add" file(s).
-        for (int lpi = 0; lpi < mip->mi_win->w_s->b_langp.ga_len; ++lpi) {
+        for (int lpi = 0; lpi < mip->mi_win->w_s->b_langp.ga_len; lpi++) {
           if (slang->sl_nobreak) {
             mip->mi_lp = LANGP_ENTRY(mip->mi_win->w_s->b_langp, lpi);
             if (mip->mi_lp->lp_slang->sl_fidxs == NULL
@@ -833,9 +837,9 @@ static void find_word(matchinf_T *mip, int mode)
             break;
           }
         }
-        --mip->mi_complen;
+        mip->mi_complen--;
         if (flags & WF_COMPROOT) {
-          --mip->mi_compextra;
+          mip->mi_compextra--;
         }
         mip->mi_lp = save_lp;
 
@@ -905,16 +909,13 @@ static void find_word(matchinf_T *mip, int mode)
 /// @param gap  &sl_comppat
 bool match_checkcompoundpattern(char_u *ptr, int wlen, garray_T *gap)
 {
-  char_u *p;
-  int len;
-
   for (int i = 0; i + 1 < gap->ga_len; i += 2) {
-    p = ((char_u **)gap->ga_data)[i + 1];
+    char_u *p = ((char_u **)gap->ga_data)[i + 1];
     if (STRNCMP(ptr + wlen, p, STRLEN(p)) == 0) {
       // Second part matches at start of following compound word, now
       // check if first part matches at end of previous word.
       p = ((char_u **)gap->ga_data)[i];
-      len = (int)STRLEN(p);
+      int len = (int)STRLEN(p);
       if (len <= wlen && STRNCMP(ptr + wlen - len, p, len) == 0) {
         return true;
       }
@@ -960,16 +961,12 @@ bool can_compound(slang_T *slang, const char_u *word, const char_u *flags)
 // Caller must check that slang->sl_comprules is not NULL.
 bool match_compoundrule(slang_T *slang, char_u *compflags)
 {
-  char_u *p;
-  int i;
-  int c;
-
   // loop over all the COMPOUNDRULE entries
-  for (p = slang->sl_comprules; *p != NUL; ++p) {
+  for (char_u *p = slang->sl_comprules; *p != NUL; p++) {
     // loop over the flags in the compound word we have made, match
     // them against the current rule entry
-    for (i = 0;; ++i) {
-      c = compflags[i];
+    for (int i = 0;; i++) {
+      int c = compflags[i];
       if (c == NUL) {
         // found a rule that matches for the flags we have so far
         return true;
@@ -1018,12 +1015,9 @@ bool match_compoundrule(slang_T *slang, char_u *compflags)
 int valid_word_prefix(int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang,
                       bool cond_req)
 {
-  int prefcnt;
-  int pidx;
-
   int prefid = (int)((unsigned)flags >> 24);
-  for (prefcnt = totprefcnt - 1; prefcnt >= 0; prefcnt--) {
-    pidx = slang->sl_pidxs[arridx + prefcnt];
+  for (int prefcnt = totprefcnt - 1; prefcnt >= 0; prefcnt--) {
+    int pidx = slang->sl_pidxs[arridx + prefcnt];
 
     // Check the prefix ID.
     if (prefid != (pidx & 0xff)) {
@@ -1063,30 +1057,23 @@ int valid_word_prefix(int totprefcnt, int arridx, int flags, char_u *word, slang
 static void find_prefix(matchinf_T *mip, int mode)
 {
   idx_T arridx = 0;
-  int len;
   int wlen = 0;
-  int flen;
-  int c;
-  char_u *ptr;
-  idx_T lo, hi, m;
   slang_T *slang = mip->mi_lp->lp_slang;
-  char_u *byts;
-  idx_T *idxs;
 
-  byts = slang->sl_pbyts;
+  char_u *byts = slang->sl_pbyts;
   if (byts == NULL) {
     return;                     // array is empty
   }
   // We use the case-folded word here, since prefixes are always
   // case-folded.
-  ptr = mip->mi_fword;
-  flen = mip->mi_fwordlen;      // available case-folded bytes
+  char_u *ptr = mip->mi_fword;
+  int flen = mip->mi_fwordlen;      // available case-folded bytes
   if (mode == FIND_COMPOUND) {
     // Skip over the previously found word(s).
     ptr += mip->mi_compoff;
     flen -= mip->mi_compoff;
   }
-  idxs = slang->sl_pidxs;
+  idx_T *idxs = slang->sl_pidxs;
 
   // Repeat advancing in the tree until:
   // - there is a byte that doesn't match,
@@ -1097,7 +1084,7 @@ static void find_prefix(matchinf_T *mip, int mode)
       flen = fold_more(mip);
     }
 
-    len = byts[arridx++];
+    int len = byts[arridx++];
 
     // If the first possible byte is a zero the prefix could end here.
     // Check if the following word matches and supports the prefix.
@@ -1137,11 +1124,11 @@ static void find_prefix(matchinf_T *mip, int mode)
     }
 
     // Perform a binary search in the list of accepted bytes.
-    c = ptr[wlen];
-    lo = arridx;
-    hi = arridx + len - 1;
+    int c = ptr[wlen];
+    idx_T lo = arridx;
+    idx_T hi = arridx + len - 1;
     while (lo < hi) {
-      m = (lo + hi) / 2;
+      idx_T m = (lo + hi) / 2;
       if (byts[m] > c) {
         hi = m - 1;
       } else if (byts[m] < c) {
@@ -1169,10 +1156,7 @@ static void find_prefix(matchinf_T *mip, int mode)
 // Return the length of the folded chars in bytes.
 static int fold_more(matchinf_T *mip)
 {
-  int flen;
-  char_u *p;
-
-  p = mip->mi_fend;
+  char_u *p = mip->mi_fend;
   do {
     MB_PTR_ADV(mip->mi_fend);
   } while (*mip->mi_fend != NUL && spell_iswordp(mip->mi_fend, mip->mi_win));
@@ -1185,7 +1169,7 @@ static int fold_more(matchinf_T *mip)
   (void)spell_casefold(mip->mi_win, p, (int)(mip->mi_fend - p),
                        mip->mi_fword + mip->mi_fwordlen,
                        MAXWLEN - mip->mi_fwordlen);
-  flen = (int)STRLEN(mip->mi_fword + mip->mi_fwordlen);
+  int flen = (int)STRLEN(mip->mi_fword + mip->mi_fwordlen);
   mip->mi_fwordlen += flen;
   return flen;
 }
@@ -1227,17 +1211,12 @@ bool no_spell_checking(win_T *wp)
 /// @return  0 if not found, length of the badly spelled word otherwise.
 size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *attrp)
 {
-  linenr_T lnum;
   pos_T found_pos;
   size_t found_len = 0;
-  char_u *line;
-  char_u *p;
-  char_u *endp;
   hlf_T attr = HLF_COUNT;
   size_t len;
   int has_syntax = syntax_present(wp);
   int col;
-  bool can_spell;
   char_u *buf = NULL;
   size_t buflen = 0;
   int skip = 0;
@@ -1258,11 +1237,11 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
   // We concatenate the start of the next line, so that wrapped words work
   // (e.g. "et<line-break>cetera").  Doesn't work when searching backwards
   // though...
-  lnum = wp->w_cursor.lnum;
+  linenr_T lnum = wp->w_cursor.lnum;
   clearpos(&found_pos);
 
   while (!got_int) {
-    line = ml_get_buf(wp->w_buffer, lnum, false);
+    char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
 
     len = STRLEN(line);
     if (buflen < len + MAXWLEN + 2) {
@@ -1302,8 +1281,8 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
                      ml_get_buf(wp->w_buffer, lnum + 1, false),
                      MAXWLEN);
     }
-    p = buf + skip;
-    endp = buf + len;
+    char_u *p = buf + skip;
+    char_u *endp = buf + len;
     while (p < endp) {
       // When searching backward don't search after the cursor.  Unless
       // we wrapped around the end of the buffer.
@@ -1329,10 +1308,11 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
               || ((colnr_T)(curline
                             ? p - buf + (ptrdiff_t)len
                             : p - buf) > wp->w_cursor.col)) {
+            bool can_spell;
             if (has_syntax) {
               col = (int)(p - buf);
               (void)syn_get_id(wp, lnum, (colnr_T)col,
-                               FALSE, &can_spell, FALSE);
+                               false, &can_spell, false);
               if (!can_spell) {
                 attr = HLF_COUNT;
               }
@@ -1342,9 +1322,11 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
 
             if (can_spell) {
               found_one = true;
-              found_pos.lnum = lnum;
-              found_pos.col = (int)(p - buf);
-              found_pos.coladd = 0;
+              found_pos = (pos_T) {
+                .lnum = lnum,
+                .col = (int)(p - buf),
+                .coladd = 0
+              };
               if (dir == FORWARD) {
                 // No need to search further.
                 wp->w_cursor = found_pos;
@@ -1457,10 +1439,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
 // to skip those bytes if the word was OK.
 void spell_cat_line(char_u *buf, char_u *line, int maxlen)
 {
-  char_u *p;
-  int n;
-
-  p = (char_u *)skipwhite((char *)line);
+  char_u *p = (char_u *)skipwhite((char *)line);
   while (vim_strchr("*#/\"\t", *p) != NULL) {
     p = (char_u *)skipwhite((char *)p + 1);
   }
@@ -1468,7 +1447,7 @@ void spell_cat_line(char_u *buf, char_u *line, int maxlen)
   if (*p != NUL) {
     // Only worth concatenating if there is something else than spaces to
     // concatenate.
-    n = (int)(p - line) + 1;
+    int n = (int)(p - line) + 1;
     if (n < maxlen - 1) {
       memset(buf, ' ', (size_t)n);
       STRLCPY(buf + n, p, maxlen - n);
@@ -1483,7 +1462,6 @@ static void spell_load_lang(char_u *lang)
   char fname_enc[85];
   int r;
   spelload_T sl;
-  int round;
 
   // Copy the language name to pass it to spell_load_cb() as a cookie.
   // It's truncated when an error is detected.
@@ -1493,7 +1471,7 @@ static void spell_load_lang(char_u *lang)
 
   // We may retry when no spell file is found for the language, an
   // autocommand may load it then.
-  for (round = 1; round <= 2; ++round) {
+  for (int round = 1; round <= 2; round++) {
     // Find the first spell file for "lang" in 'runtimepath' and load it.
     vim_snprintf((char *)fname_enc, sizeof(fname_enc) - 5,
                  "spell/%s.%s.spl", lang, spell_enc());
@@ -1624,7 +1602,7 @@ void slang_clear(slang_T *lp)
     GA_DEEP_CLEAR(gap, salitem_T, free_salitem);
   }
 
-  for (int i = 0; i < lp->sl_prefixcnt; ++i) {
+  for (int i = 0; i < lp->sl_prefixcnt; i++) {
     vim_regfree(lp->sl_prefprog[i]);
   }
   lp->sl_prefixcnt = 0;
@@ -1673,9 +1651,7 @@ void slang_clear_sug(slang_T *lp)
 static void spell_load_cb(char *fname, void *cookie)
 {
   spelload_T *slp = (spelload_T *)cookie;
-  slang_T *slang;
-
-  slang = spell_load_file((char_u *)fname, slp->sl_lang, NULL, false);
+  slang_T *slang = spell_load_file((char_u *)fname, slp->sl_lang, NULL, false);
   if (slang != NULL) {
     // When a previously loaded file has NOBREAK also use it for the
     // ".add" files.
@@ -1698,9 +1674,6 @@ static void spell_load_cb(char *fname, void *cookie)
 /// @param[in]  count  1 to count once, 10 to init
 void count_common_word(slang_T *lp, char_u *word, int len, uint8_t count)
 {
-  hash_T hash;
-  hashitem_T *hi;
-  wordcount_T *wc;
   char_u buf[MAXWLEN];
   char_u *p;
 
@@ -1713,9 +1686,10 @@ void count_common_word(slang_T *lp, char_u *word, int len, uint8_t count)
     p = buf;
   }
 
-  hash = hash_hash(p);
+  wordcount_T *wc;
+  hash_T hash = hash_hash(p);
   const size_t p_len = STRLEN(p);
-  hi = hash_lookup(&lp->sl_wordcount, (const char *)p, p_len, hash);
+  hashitem_T *hi = hash_lookup(&lp->sl_wordcount, (const char *)p, p_len, hash);
   if (HASHITEM_EMPTY(hi)) {
     wc = xmalloc(sizeof(wordcount_T) + p_len);
     memcpy(wc->wc_word, p, p_len + 1);
@@ -1734,9 +1708,7 @@ void count_common_word(slang_T *lp, char_u *word, int len, uint8_t count)
 // Like strchr() but independent of locale.
 bool byte_in_str(char_u *str, int n)
 {
-  char_u *p;
-
-  for (p = str; *p != NUL; ++p) {
+  for (char_u *p = str; *p != NUL; p++) {
     if (*p == n) {
       return true;
     }
@@ -1748,19 +1720,16 @@ bool byte_in_str(char_u *str, int n)
 // in "slang->sl_syl_items".
 int init_syl_tab(slang_T *slang)
 {
-  char_u *p;
-  char_u *s;
-  int l;
-
   ga_init(&slang->sl_syl_items, sizeof(syl_item_T), 4);
-  p = (char_u *)vim_strchr((char *)slang->sl_syllable, '/');
+  char_u *p = (char_u *)vim_strchr((char *)slang->sl_syllable, '/');
   while (p != NULL) {
     *p++ = NUL;
     if (*p == NUL) {        // trailing slash
       break;
     }
-    s = p;
+    char_u *s = p;
     p = (char_u *)vim_strchr((char *)p, '/');
+    int l;
     if (p == NULL) {
       l = (int)STRLEN(s);
     } else {
@@ -1786,8 +1755,6 @@ static int count_syllables(slang_T *slang, const char_u *word)
   int cnt = 0;
   bool skip = false;
   int len;
-  syl_item_T *syl;
-  int c;
 
   if (slang->sl_syllable == NULL) {
     return 0;
@@ -1803,8 +1770,8 @@ static int count_syllables(slang_T *slang, const char_u *word)
 
     // Find longest match of syllable items.
     len = 0;
-    for (int i = 0; i < slang->sl_syl_items.ga_len; ++i) {
-      syl = ((syl_item_T *)slang->sl_syl_items.ga_data) + i;
+    for (int i = 0; i < slang->sl_syl_items.ga_len; i++) {
+      syl_item_T *syl = ((syl_item_T *)slang->sl_syl_items.ga_data) + i;
       if (syl->sy_len > len
           && STRNCMP(p, syl->sy_chars, syl->sy_len) == 0) {
         len = syl->sy_len;
@@ -1815,12 +1782,12 @@ static int count_syllables(slang_T *slang, const char_u *word)
       skip = false;
     } else {
       // No recognized syllable item, at least a syllable char then?
-      c = utf_ptr2char((char *)p);
+      int c = utf_ptr2char((char *)p);
       len = utfc_ptr2len((char *)p);
       if (vim_strchr((char *)slang->sl_syllable, c) == NULL) {
         skip = false;               // No, search for next syllable
       } else if (!skip) {
-        ++cnt;                      // Yes, count it
+        cnt++;                      // Yes, count it
         skip = true;                // don't count following syllable chars
       }
     }
@@ -2013,7 +1980,7 @@ char *did_set_spelllang(win_T *wp)
       STRCAT(spf_name, ".spl");
 
       // If it was already found above then skip it.
-      for (c = 0; c < ga.ga_len; ++c) {
+      for (c = 0; c < ga.ga_len; c++) {
         p = LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
         if (p != NULL
             && path_full_compare((char *)spf_name, (char *)p, false, true) == kEqualFiles) {
@@ -2085,7 +2052,7 @@ char *did_set_spelllang(win_T *wp)
   // For each language figure out what language to use for sound folding and
   // REP items.  If the language doesn't support it itself use another one
   // with the same name.  E.g. for "en-math" use "en".
-  for (int i = 0; i < ga.ga_len; ++i) {
+  for (int i = 0; i < ga.ga_len; i++) {
     lp = LANGP_ENTRY(ga, i);
 
     // sound folding
@@ -2094,7 +2061,7 @@ char *did_set_spelllang(win_T *wp)
       lp->lp_sallang = lp->lp_slang;
     } else {
       // find first similar language that does sound folding
-      for (int j = 0; j < ga.ga_len; ++j) {
+      for (int j = 0; j < ga.ga_len; j++) {
         lp2 = LANGP_ENTRY(ga, j);
         if (!GA_EMPTY(&lp2->lp_slang->sl_sal)
             && STRNCMP(lp->lp_slang->sl_name,
@@ -2111,7 +2078,7 @@ char *did_set_spelllang(win_T *wp)
       lp->lp_replang = lp->lp_slang;
     } else {
       // find first similar language that has REP items
-      for (int j = 0; j < ga.ga_len; ++j) {
+      for (int j = 0; j < ga.ga_len; j++) {
         lp2 = LANGP_ENTRY(ga, j);
         if (!GA_EMPTY(&lp2->lp_slang->sl_rep)
             && STRNCMP(lp->lp_slang->sl_name,
@@ -2198,9 +2165,6 @@ int captype(char_u *word, char_u *end)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char_u *p;
-  int firstcap;
-  bool allcap;
-  bool past_second = false;              // past second word char
 
   // find first letter
   for (p = word; !spell_iswordp_nmw(p, curwin); MB_PTR_ADV(p)) {
@@ -2209,7 +2173,9 @@ int captype(char_u *word, char_u *end)
     }
   }
   int c = mb_ptr2char_adv((const char_u **)&p);
-  firstcap = allcap = SPELL_ISUPPER(c);
+  bool allcap;
+  bool firstcap = allcap = SPELL_ISUPPER(c);
+  bool past_second = false;              // past second word char
 
   // Need to check all letters to find a word with mixed upper/lower.
   // But a word with an upper char only at start is a ONECAP.
@@ -2242,9 +2208,8 @@ int captype(char_u *word, char_u *end)
 // Delete the internal wordlist and its .spl file.
 void spell_delete_wordlist(void)
 {
-  char_u fname[MAXPATHL] = { 0 };
-
   if (int_wordlist != NULL) {
+    char_u fname[MAXPATHL] = { 0 };
     os_remove((char *)int_wordlist);
     int_wordlist_spl(fname);
     os_remove((char *)fname);
@@ -2255,15 +2220,13 @@ void spell_delete_wordlist(void)
 // Free all languages.
 void spell_free_all(void)
 {
-  slang_T *slang;
-
   // Go through all buffers and handle 'spelllang'. <VN>
   FOR_ALL_BUFFERS(buf) {
     ga_clear(&buf->b_s.b_langp);
   }
 
   while (first_lang != NULL) {
-    slang = first_lang;
+    slang_T *slang = first_lang;
     first_lang = slang->sl_next;
     slang_free(slang);
   }
@@ -2320,7 +2283,7 @@ buf_T *open_spellbuf(void)
 void close_spellbuf(buf_T *buf)
 {
   if (buf != NULL) {
-    ml_close(buf, TRUE);
+    ml_close(buf, true);
     xfree(buf);
   }
 }
@@ -2328,28 +2291,26 @@ void close_spellbuf(buf_T *buf)
 // Init the chartab used for spelling for ASCII.
 void clear_spell_chartab(spelltab_T *sp)
 {
-  int i;
-
   // Init everything to false (zero).
   CLEAR_FIELD(sp->st_isw);
   CLEAR_FIELD(sp->st_isu);
 
-  for (i = 0; i < 256; i++) {
+  for (int i = 0; i < 256; i++) {
     sp->st_fold[i] = (char_u)i;
     sp->st_upper[i] = (char_u)i;
   }
 
   // We include digits. A word shouldn't start with a digit, but handling
   // that is done separately.
-  for (i = '0'; i <= '9'; ++i) {
+  for (int i = '0'; i <= '9'; i++) {
     sp->st_isw[i] = true;
   }
-  for (i = 'A'; i <= 'Z'; ++i) {
+  for (int i = 'A'; i <= 'Z'; i++) {
     sp->st_isw[i] = true;
     sp->st_isu[i] = true;
     sp->st_fold[i] = (char_u)(i + 0x20);
   }
-  for (i = 'a'; i <= 'z'; ++i) {
+  for (int i = 'a'; i <= 'z'; i++) {
     sp->st_isw[i] = true;
     sp->st_upper[i] = (char_u)(i - 0x20);
   }
@@ -2361,11 +2322,9 @@ void clear_spell_chartab(spelltab_T *sp)
 // locale.  For utf-8 we don't use isalpha() but our own functions.
 void init_spell_chartab(void)
 {
-  int i;
-
   did_set_spelltab = false;
   clear_spell_chartab(&spelltab);
-  for (i = 128; i < 256; i++) {
+  for (int i = 128; i < 256; i++) {
     int f = utf_fold(i);
     int u = mb_toupper(i);
 
@@ -2388,8 +2347,6 @@ void init_spell_chartab(void)
 bool spell_iswordp(const char_u *p, const win_T *wp)
   FUNC_ATTR_NONNULL_ALL
 {
-  int c;
-
   const int l = utfc_ptr2len((char *)p);
   const char_u *s = p;
   if (l == 1) {
@@ -2398,7 +2355,7 @@ bool spell_iswordp(const char_u *p, const win_T *wp)
       s = p + 1;                      // skip a mid-word character
     }
   } else {
-    c = utf_ptr2char((char *)p);
+    int c = utf_ptr2char((char *)p);
     if (c < 256
         ? wp->w_s->b_spell_ismw[c]
         : (wp->w_s->b_spell_ismw_mb != NULL
@@ -2407,7 +2364,7 @@ bool spell_iswordp(const char_u *p, const win_T *wp)
     }
   }
 
-  c = utf_ptr2char((char *)s);
+  int c = utf_ptr2char((char *)s);
   if (c > 255) {
     return spell_mb_isword_class(mb_get_class(s), wp);
   }
@@ -2508,18 +2465,14 @@ int spell_casefold(const win_T *wp, char_u *str, int len, char_u *buf, int bufle
 bool check_need_cap(linenr_T lnum, colnr_T col)
 {
   bool need_cap = false;
-  char_u *line;
-  char_u *line_copy = NULL;
-  char_u *p;
-  colnr_T endcol;
-  regmatch_T regmatch;
 
   if (curwin->w_s->b_cap_prog == NULL) {
     return false;
   }
 
-  line = get_cursor_line_ptr();
-  endcol = 0;
+  char_u *line = get_cursor_line_ptr();
+  char_u *line_copy = NULL;
+  colnr_T endcol = 0;
   if (getwhitecols(line) >= (int)col) {
     // At start of line, check if previous line is empty or sentence
     // ends there.
@@ -2542,9 +2495,11 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
 
   if (endcol > 0) {
     // Check if sentence ends before the bad word.
-    regmatch.regprog = curwin->w_s->b_cap_prog;
-    regmatch.rm_ic = FALSE;
-    p = line + endcol;
+    regmatch_T regmatch = {
+      .regprog = curwin->w_s->b_cap_prog,
+      .rm_ic = false
+    };
+    char_u *p = line + endcol;
     for (;;) {
       MB_PTR_BACK(line, p);
       if (p == line || spell_iswordp_nmw(p, curwin)) {
@@ -2568,10 +2523,6 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
 void ex_spellrepall(exarg_T *eap)
 {
   pos_T pos = curwin->w_cursor;
-  char_u *frompat;
-  int addlen;
-  char_u *line;
-  char_u *p;
   bool save_ws = p_ws;
   linenr_T prev_lnum = 0;
 
@@ -2579,10 +2530,11 @@ void ex_spellrepall(exarg_T *eap)
     emsg(_("E752: No previous spell replacement"));
     return;
   }
-  addlen = (int)(STRLEN(repl_to) - STRLEN(repl_from));
+  int addlen = (int)(STRLEN(repl_to) - STRLEN(repl_from));
 
-  frompat = xmalloc(STRLEN(repl_from) + 7);
-  sprintf((char *)frompat, "\\V\\<%s\\>", repl_from);
+  size_t frompatlen = STRLEN(repl_from) + 7;
+  char_u *frompat = xmalloc(frompatlen);
+  snprintf((char *)frompat, frompatlen, "\\V\\<%s\\>", repl_from);
   p_ws = false;
 
   sub_nsubs = 0;
@@ -2596,10 +2548,10 @@ void ex_spellrepall(exarg_T *eap)
 
     // Only replace when the right word isn't there yet.  This happens
     // when changing "etc" to "etc.".
-    line = get_cursor_line_ptr();
+    char_u *line = get_cursor_line_ptr();
     if (addlen <= 0 || STRNCMP(line + curwin->w_cursor.col,
                                repl_to, STRLEN(repl_to)) != 0) {
-      p = xmalloc(STRLEN(line) + (size_t)addlen + 1);
+      char_u *p = xmalloc(STRLEN(line) + (size_t)addlen + 1);
       memmove(p, line, (size_t)curwin->w_cursor.col);
       STRCPY(p + curwin->w_cursor.col, repl_to);
       STRCAT(p, line + curwin->w_cursor.col + STRLEN(repl_from));
@@ -2747,13 +2699,12 @@ char *eval_soundfold(const char *const word)
 /// @param[in,out]  res  destination for soundfolded word
 void spell_soundfold(slang_T *slang, char_u *inword, bool folded, char_u *res)
 {
-  char_u fword[MAXWLEN];
-  char_u *word;
-
   if (slang->sl_sofo) {
     // SOFOFROM and SOFOTO used
     spell_soundfold_sofo(slang, inword, res);
   } else {
+    char_u fword[MAXWLEN];
+    char_u *word;
     // SAL items used.  Requires the word to be case-folded.
     if (folded) {
       word = inword;
@@ -2820,29 +2771,26 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
   salitem_T *smp = (salitem_T *)slang->sl_sal.ga_data;
   int word[MAXWLEN] = { 0 };
   int wres[MAXWLEN] = { 0 };
-  int l;
   int *ws;
   int *pf;
-  int i, j, z;
+  int j, z;
   int reslen;
-  int n, k = 0;
+  int k = 0;
   int z0;
   int k0;
   int n0;
-  int c;
   int pri;
   int p0 = -333;
   int c0;
   bool did_white = false;
-  int wordlen;
 
   // Convert the multi-byte string to a wide-character string.
   // Remove accents, if wanted.  We actually remove all non-word characters.
   // But keep white space.
-  wordlen = 0;
+  int wordlen = 0;
   for (const char_u *s = inword; *s != NUL;) {
     const char_u *t = s;
-    c = mb_cptr2char_adv(&s);
+    int c = mb_cptr2char_adv(&s);
     if (slang->sl_rem_accents) {
       if (utf_class(c) == 0) {
         if (did_white) {
@@ -2861,13 +2809,14 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
   }
   word[wordlen] = NUL;
 
+  int c;
   // This algorithm comes from Aspell phonet.cpp.
   // Converted from C++ to C.  Added support for multi-byte chars.
   // Changed to keep spaces.
-  i = reslen = z = 0;
+  int i = reslen = z = 0;
   while ((c = word[i]) != NUL) {
     // Start with the first rule that has the character in the word.
-    n = slang->sl_sal_first[c & 0xff];
+    int n = slang->sl_sal_first[c & 0xff];
     z0 = 0;
 
     if (n >= 0) {
@@ -2875,7 +2824,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
       // If c is 0x300 need extra check for the end of the array, as
       // (c & 0xff) is NUL.
       for (; ((ws = smp[n].sm_lead_w)[0] & 0xff) == (c & 0xff)
-           && ws[0] != NUL; ++n) {
+           && ws[0] != NUL; n++) {
         // Quickly skip entries that don't match the word.  Most
         // entries are less than three chars, optimize for that.
         if (c != ws[0]) {
@@ -2887,7 +2836,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
             continue;
           }
           if (k > 2) {
-            for (j = 2; j < k; ++j) {
+            for (j = 2; j < k; j++) {
               if (word[i + j] != ws[j]) {
                 break;
               }
@@ -2948,7 +2897,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
             // Test follow-up rule for "word[i + k]"; loop over
             // all entries with the same index byte.
             for (; ((ws = smp[n0].sm_lead_w)[0] & 0xff)
-                 == (c0 & 0xff); ++n0) {
+                 == (c0 & 0xff); n0++) {
               // Quickly skip entries that don't match the word.
               if (c0 != ws[0]) {
                 continue;
@@ -2960,7 +2909,7 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
                 }
                 if (k0 > 2) {
                   pf = word + i + k + 1;
-                  for (j = 2; j < k0; ++j) {
+                  for (j = 2; j < k0; j++) {
                     if (*pf++ != ws[j]) {
                       break;
                     }
@@ -3102,8 +3051,8 @@ static void spell_soundfold_wsal(slang_T *slang, char_u *inword, char_u *res)
   }
 
   // Convert wide characters in "wres" to a multi-byte string in "res".
-  l = 0;
-  for (n = 0; n < reslen; n++) {
+  int l = 0;
+  for (int n = 0; n < reslen; n++) {
     l += utf_char2bytes(wres[n], (char *)res + l);
     if (l + MB_MAXBYTES > MAXWLEN) {
       break;
@@ -3143,12 +3092,11 @@ void ex_spellinfo(exarg_T *eap)
 // ":spelldump"
 void ex_spelldump(exarg_T *eap)
 {
-  char *spl;
-  long dummy;
-
   if (no_spell_checking(curwin)) {
     return;
   }
+  char *spl;
+  long dummy;
   (void)get_option_value("spl", &dummy, &spl, OPT_LOCAL);
 
   // Create a new empty buffer in a new window.
@@ -3192,7 +3140,6 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
   char_u *byts;
   idx_T *idxs;
   linenr_T lnum = 0;
-  int round;
   int depth;
   int n;
   int flags;
@@ -3220,7 +3167,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
 
   // Find out if we can support regions: All languages must support the same
   // regions or none at all.
-  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; ++lpi) {
+  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
     lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
     p = lp->lp_slang->sl_regions;
     if (p[0] != 0) {
@@ -3243,7 +3190,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
   }
 
   // Loop over all files loaded for the entries in 'spelllang'.
-  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; ++lpi) {
+  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
     lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
     slang = lp->lp_slang;
     if (slang->sl_fbyts == NULL) {          // reloading failed
@@ -3265,7 +3212,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
 
     // round 1: case-folded tree
     // round 2: keep-case tree
-    for (round = 1; round <= 2; ++round) {
+    for (int round = 1; round <= 2; round++) {
       if (round == 1) {
         dumpflags &= ~DUMPFLAG_KEEPCASE;
         byts = slang->sl_fbyts;
@@ -3291,7 +3238,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
         } else {
           // Do one more byte at this node.
           n = arridx[depth] + curi[depth];
-          ++curi[depth];
+          curi[depth]++;
           c = byts[n];
           if (c == 0 || depth >= MAXWLEN - 1) {
             // End of word or reached maximum length, deal with the
@@ -3359,10 +3306,8 @@ static void dump_word(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
 {
   bool keepcap = false;
   char_u *p;
-  char_u *tw;
   char_u cword[MAXWLEN];
   char_u badword[MAXWLEN + 10];
-  int i;
   int flags = wordflags;
 
   if (dumpflags & DUMPFLAG_ONECAP) {
@@ -3384,7 +3329,7 @@ static void dump_word(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
       keepcap = true;
     }
   }
-  tw = p;
+  char_u *tw = p;
 
   if (pat == NULL) {
     // Add flags and regions after a slash.
@@ -3400,7 +3345,7 @@ static void dump_word(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
         STRCAT(badword, "?");
       }
       if (flags & WF_REGION) {
-        for (i = 0; i < 7; i++) {
+        for (int i = 0; i < 7; i++) {
           if (flags & (0x10000 << i)) {
             const size_t badword_len = STRLEN(badword);
             snprintf((char *)badword + badword_len,
@@ -3451,34 +3396,27 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
   char_u prefix[MAXWLEN];
   char_u word_up[MAXWLEN];
   bool has_word_up = false;
-  int c;
-  char_u *byts;
-  idx_T *idxs;
   linenr_T lnum = startlnum;
-  int depth;
-  int n;
-  int len;
-  int i;
 
   // If the word starts with a lower-case letter make the word with an
   // upper-case letter in word_up[].
-  c = utf_ptr2char((char *)word);
+  int c = utf_ptr2char((char *)word);
   if (SPELL_TOUPPER(c) != c) {
     onecap_copy(word, word_up, true);
     has_word_up = true;
   }
 
-  byts = slang->sl_pbyts;
-  idxs = slang->sl_pidxs;
+  char_u *byts = slang->sl_pbyts;
+  idx_T *idxs = slang->sl_pidxs;
   if (byts != NULL) {           // array not is empty
     // Loop over all prefixes, building them byte-by-byte in prefix[].
     // When at the end of a prefix check that it supports "flags".
-    depth = 0;
+    int depth = 0;
     arridx[0] = 0;
     curi[0] = 1;
     while (depth >= 0 && !got_int) {
-      n = arridx[depth];
-      len = byts[n];
+      int n = arridx[depth];
+      int len = byts[n];
       if (curi[depth] > len) {
         // Done all bytes at this node, go up one level.
         depth--;
@@ -3486,11 +3424,12 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
       } else {
         // Do one more byte at this node.
         n += curi[depth];
-        ++curi[depth];
+        curi[depth]++;
         c = byts[n];
         if (c == 0) {
           // End of prefix, find out how many IDs there are.
-          for (i = 1; i < len; ++i) {
+          int i;
+          for (i = 1; i < len; i++) {
             if (byts[n + i] != 0) {
               break;
             }
@@ -3501,8 +3440,7 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
           if (c != 0) {
             STRLCPY(prefix + depth, word, MAXWLEN - depth);
             dump_word(slang, prefix, pat, dir, dumpflags,
-                      (c & WF_RAREPFX) ? (flags | WF_RARE)
-                                       : flags, lnum);
+                      (c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
             if (lnum != 0) {
               lnum++;
             }
@@ -3517,8 +3455,7 @@ static linenr_T dump_prefixes(slang_T *slang, char_u *word, char_u *pat, Directi
             if (c != 0) {
               STRLCPY(prefix + depth, word_up, MAXWLEN - depth);
               dump_word(slang, prefix, pat, dir, dumpflags,
-                        (c & WF_RAREPFX) ? (flags | WF_RARE)
-                                         : flags, lnum);
+                        (c & WF_RAREPFX) ? (flags | WF_RARE) : flags, lnum);
               if (lnum != 0) {
                 lnum++;
               }
@@ -3556,16 +3493,14 @@ char_u *spell_to_word_end(char_u *start, win_T *win)
 // Returns the column number of the word.
 int spell_word_start(int startcol)
 {
-  char_u *line;
-  char_u *p;
-  int col = 0;
-
   if (no_spell_checking(curwin)) {
     return startcol;
   }
 
+  char_u *line = get_cursor_line_ptr();
+  char_u *p;
+
   // Find a word character before "startcol".
-  line = get_cursor_line_ptr();
   for (p = line + startcol; p > line;) {
     MB_PTR_BACK(line, p);
     if (spell_iswordp_nmw(p, curwin)) {
@@ -3573,6 +3508,8 @@ int spell_word_start(int startcol)
     }
   }
 
+  int col = 0;
+
   // Go back to start of the word.
   while (p > line) {
     col = (int)(p - line);
@@ -3657,13 +3594,12 @@ char *compile_cap_prog(synblock_T *synblock)
   FUNC_ATTR_NONNULL_ALL
 {
   regprog_T *rp = synblock->b_cap_prog;
-  char_u *re;
 
   if (synblock->b_p_spc == NULL || *synblock->b_p_spc == NUL) {
     synblock->b_cap_prog = NULL;
   } else {
     // Prepend a ^ so that we only match at one column
-    re = concat_str((char_u *)"^", synblock->b_p_spc);
+    char_u *re = concat_str((char_u *)"^", synblock->b_p_spc);
     synblock->b_cap_prog = vim_regcomp((char *)re, RE_MAGIC);
     xfree(re);
     if (synblock->b_cap_prog == NULL) {
-- 
cgit 


From 6cc6e11929ad76a2dc5204aed95cb9ed1dafde23 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 23 Aug 2022 22:00:19 +0800
Subject: vim-patch:9.0.0206: redraw flags are not named specifically (#19913)

Problem:    Redraw flags are not named specifically.
Solution:   Prefix "UPD_" to the flags, for UPDate_screen().
https://github.com/vim/vim/commit/a4d158b3c839e96ed98ff87c7b7124ff4518c4ff
---
 src/nvim/api/extmark.c     |   2 +-
 src/nvim/api/vim.c         |   2 +-
 src/nvim/api/win_config.c  |   2 +-
 src/nvim/api/window.c      |   4 +-
 src/nvim/buffer.c          |   8 +--
 src/nvim/buffer_defs.h     |   2 +-
 src/nvim/change.c          |  20 +++---
 src/nvim/cmdexpand.c       |   2 +-
 src/nvim/cursor.c          |   2 +-
 src/nvim/debugger.c        |   2 +-
 src/nvim/diff.c            |   6 +-
 src/nvim/drawscreen.c      | 162 ++++++++++++++++++++++-----------------------
 src/nvim/drawscreen.h      |  14 ++--
 src/nvim/edit.c            |   8 +--
 src/nvim/eval/vars.c       |   2 +-
 src/nvim/ex_cmds.c         |  10 +--
 src/nvim/ex_docmd.c        |  24 +++----
 src/nvim/ex_getln.c        |  24 +++----
 src/nvim/fileio.c          |   2 +-
 src/nvim/fold.c            |   6 +-
 src/nvim/getchar.c         |   2 +-
 src/nvim/highlight_group.c |  12 ++--
 src/nvim/lua/executor.c    |   2 +-
 src/nvim/main.c            |   4 +-
 src/nvim/match.c           |  10 +--
 src/nvim/mbyte.c           |   2 +-
 src/nvim/memline.c         |   4 +-
 src/nvim/message.c         |  16 ++---
 src/nvim/mouse.c           |  10 +--
 src/nvim/move.c            |  30 ++++-----
 src/nvim/normal.c          |  40 +++++------
 src/nvim/ops.c             |  20 +++---
 src/nvim/option.c          |  18 ++---
 src/nvim/optionstr.c       |   8 +--
 src/nvim/popupmenu.c       |   2 +-
 src/nvim/quickfix.c        |   6 +-
 src/nvim/search.c          |  24 +++----
 src/nvim/sign.c            |   8 +--
 src/nvim/spell.c           |   4 +-
 src/nvim/spellfile.c       |   4 +-
 src/nvim/syntax.c          |  16 ++---
 src/nvim/tag.c             |   2 +-
 src/nvim/terminal.c        |   2 +-
 src/nvim/undo.c            |   2 +-
 src/nvim/window.c          |  62 ++++++++---------
 45 files changed, 307 insertions(+), 307 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index 933aa85530..3ac373283c 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -993,7 +993,7 @@ void nvim_set_decoration_provider(Integer ns_id, DictionaryOf(LuaRef) opts, Erro
   decor_provider_clear(p);
 
   // regardless of what happens, it seems good idea to redraw
-  redraw_all_later(NOT_VALID);  // TODO(bfredl): too soon?
+  redraw_all_later(UPD_NOT_VALID);  // TODO(bfredl): too soon?
 
   struct {
     const char *name;
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index ce91c1b4af..7fccacdb23 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -198,7 +198,7 @@ void nvim_set_hl_ns(Integer ns_id, Error *err)
 
   ns_hl_global = (NS)ns_id;
   hl_check_ns();
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
 }
 
 /// Set active namespace for highlights while redrawing.
diff --git a/src/nvim/api/win_config.c b/src/nvim/api/win_config.c
index 6c37df6af8..96c560efa1 100644
--- a/src/nvim/api/win_config.c
+++ b/src/nvim/api/win_config.c
@@ -202,7 +202,7 @@ void nvim_win_set_config(Window window, Dict(float_config) *config, Error *err)
     if (!win_new_float(win, false, fconfig, err)) {
       return;
     }
-    redraw_later(win, NOT_VALID);
+    redraw_later(win, UPD_NOT_VALID);
   } else {
     win_config_float(win, fconfig);
     win->w_pos_changed = true;
diff --git a/src/nvim/api/window.c b/src/nvim/api/window.c
index 580dfd8639..5203003369 100644
--- a/src/nvim/api/window.c
+++ b/src/nvim/api/window.c
@@ -118,7 +118,7 @@ void nvim_win_set_cursor(Window window, ArrayOf(Integer, 2) pos, Error *err)
   // make sure cursor is in visible range even if win != curwin
   update_topline_win(win);
 
-  redraw_later(win, VALID);
+  redraw_later(win, UPD_VALID);
   win->w_redr_status = true;
 }
 
@@ -449,5 +449,5 @@ void nvim_win_set_hl_ns(Window window, Integer ns_id, Error *err)
 
   win->w_ns_hl = (NS)ns_id;
   win->w_hl_needs_update = true;
-  redraw_later(win, NOT_VALID);
+  redraw_later(win, UPD_NOT_VALID);
 }
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 15fdd977c1..cc7f650265 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -1623,7 +1623,7 @@ void enter_buffer(buf_T *buf)
   }
   curbuf->b_last_used = time(NULL);
 
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
 /// Change to the directory of the current buffer.
@@ -4034,7 +4034,7 @@ void buf_signcols_add_check(buf_T *buf, sign_entry_T *added)
       buf->b_signcols.max++;
     }
     buf->b_signcols.size++;
-    redraw_buf_later(buf, NOT_VALID);
+    redraw_buf_later(buf, UPD_NOT_VALID);
     return;
   }
 
@@ -4055,7 +4055,7 @@ void buf_signcols_add_check(buf_T *buf, sign_entry_T *added)
     buf->b_signcols.size = linesum;
     buf->b_signcols.max = linesum;
     buf->b_signcols.sentinel = added->se_lnum;
-    redraw_buf_later(buf, NOT_VALID);
+    redraw_buf_later(buf, UPD_NOT_VALID);
   }
 }
 
@@ -4074,7 +4074,7 @@ int buf_signcols(buf_T *buf, int maximum)
     if (signcols != buf->b_signcols.size) {
       buf->b_signcols.size = signcols;
       buf->b_signcols.max = maximum;
-      redraw_buf_later(buf, NOT_VALID);
+      redraw_buf_later(buf, UPD_NOT_VALID);
     }
 
     buf->b_signcols.valid = true;
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 15b964f5ed..c56fd9e6a8 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -1353,7 +1353,7 @@ struct window_S {
 
   int w_redr_type;                  // type of redraw to be performed on win
   int w_upd_rows;                   // number of window lines to update when
-                                    // w_redr_type is REDRAW_TOP
+                                    // w_redr_type is UPD_REDRAW_TOP
   linenr_T w_redraw_top;            // when != 0: first line needing redraw
   linenr_T w_redraw_bot;            // when != 0: last line needing redraw
   bool w_redr_status;               // if true statusline/winbar must be redrawn
diff --git a/src/nvim/change.c b/src/nvim/change.c
index 5184dc0689..ab54c3ea88 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -223,8 +223,8 @@ static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, linenr_T
   FOR_ALL_TAB_WINDOWS(tp, wp) {
     if (wp->w_buffer == curbuf) {
       // Mark this window to be redrawn later.
-      if (wp->w_redr_type < VALID) {
-        wp->w_redr_type = VALID;
+      if (wp->w_redr_type < UPD_VALID) {
+        wp->w_redr_type = UPD_VALID;
       }
 
       // Check if a change in the buffer has invalidated the cached
@@ -301,17 +301,17 @@ static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, linenr_T
       // requires a redraw.
       if (wp->w_p_rnu && xtra != 0) {
         wp->w_last_cursor_lnum_rnu = 0;
-        redraw_later(wp, VALID);
+        redraw_later(wp, UPD_VALID);
       }
 
       // Cursor line highlighting probably need to be updated with
-      // "VALID" if it's below the change.
+      // "UPD_VALID" if it's below the change.
       // If the cursor line is inside the change we need to redraw more.
       if (wp->w_p_cul) {
         if (xtra == 0) {
-          redraw_later(wp, VALID);
+          redraw_later(wp, UPD_VALID);
         } else if (lnum <= wp->w_last_cursorline) {
-          redraw_later(wp, SOME_VALID);
+          redraw_later(wp, UPD_SOME_VALID);
         }
       }
     }
@@ -319,8 +319,8 @@ static void changed_common(linenr_T lnum, colnr_T col, linenr_T lnume, linenr_T
 
   // Call update_screen() later, which checks out what needs to be redrawn,
   // since it notices b_mod_set and then uses b_mod_*.
-  if (must_redraw < VALID) {
-    must_redraw = VALID;
+  if (must_redraw < UPD_VALID) {
+    must_redraw = UPD_VALID;
   }
 
   // when the cursor line is changed always trigger CursorMoved
@@ -364,7 +364,7 @@ void changed_bytes(linenr_T lnum, colnr_T col)
   if (curwin->w_p_diff) {
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp->w_p_diff && wp != curwin) {
-        redraw_later(wp, VALID);
+        redraw_later(wp, UPD_VALID);
         linenr_T wlnum = diff_lnum_win(lnum, wp);
         if (wlnum > 0) {
           changedOneline(wp->w_buffer, wlnum);
@@ -493,7 +493,7 @@ void changed_lines(linenr_T lnum, colnr_T col, linenr_T lnume, linenr_T xtra, bo
 
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp->w_p_diff && wp != curwin) {
-        redraw_later(wp, VALID);
+        redraw_later(wp, UPD_VALID);
         wlnum = diff_lnum_win(lnum, wp);
         if (wlnum > 0) {
           changed_lines_buf(wp->w_buffer, wlnum,
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index e82e98ba4e..543f99b270 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -2732,7 +2732,7 @@ void wildmenu_cleanup(CmdlineInfo *cclp)
     p_ls = save_p_ls;
     p_wmh = save_p_wmh;
     last_status(false);
-    update_screen(VALID);                 // redraw the screen NOW
+    update_screen(UPD_VALID);  // redraw the screen NOW
     redrawcmd();
     save_p_ls = -1;
     wild_menu_showing = 0;
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index d4670dedc7..14ebc11cbf 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -471,7 +471,7 @@ bool leftcol_changed(void)
   if (retval) {
     curwin->w_set_curswant = true;
   }
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
   return retval;
 }
 
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index a061bd961b..d2f4910e14 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -275,7 +275,7 @@ void do_debug(char_u *cmd)
 
   RedrawingDisabled--;
   no_wait_return--;
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
   need_wait_return = false;
   msg_scroll = save_msg_scroll;
   lines_left = Rows - 1;
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index bfafc3b4e0..90d621ae1e 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -120,7 +120,7 @@ void diff_buf_delete(buf_T *buf)
         // don't redraw right away, more might change or buffer state
         // is invalid right now
         need_diff_redraw = true;
-        redraw_later(curwin, VALID);
+        redraw_later(curwin, UPD_VALID);
       }
     }
   }
@@ -659,7 +659,7 @@ void diff_redraw(bool dofold)
       continue;
     }
 
-    redraw_later(wp, SOME_VALID);
+    redraw_later(wp, UPD_SOME_VALID);
     if (wp != curwin) {
       wp_other = wp;
     }
@@ -1448,7 +1448,7 @@ void diff_win_options(win_T *wp, int addbuf)
   if (addbuf) {
     diff_buf_add(wp->w_buffer);
   }
-  redraw_later(wp, NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
 }
 
 /// Set options not to show diffs.  For the current window or all windows.
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 2abff6c894..012c4ecb19 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -20,7 +20,7 @@
 //
 // Commands that scroll a window change w_topline and must call
 // check_cursor() to move the cursor into the visible part of the window, and
-// call redraw_later(wp, VALID) to have the window displayed by update_screen()
+// call redraw_later(wp, UPD_VALID) to have the window displayed by update_screen()
 // later.
 //
 // Commands that change text in the buffer must call changed_bytes() or
@@ -32,23 +32,23 @@
 //
 // Commands that change how a window is displayed (e.g., setting 'list') or
 // invalidate the contents of a window in another way (e.g., change fold
-// settings), must call redraw_later(wp, NOT_VALID) to have the whole window
+// settings), must call redraw_later(wp, UPD_NOT_VALID) to have the whole window
 // redisplayed by update_screen() later.
 //
 // Commands that change how a buffer is displayed (e.g., setting 'tabstop')
-// must call redraw_curbuf_later(NOT_VALID) to have all the windows for the
+// must call redraw_curbuf_later(UPD_NOT_VALID) to have all the windows for the
 // buffer redisplayed by update_screen() later.
 //
 // Commands that change highlighting and possibly cause a scroll too must call
-// redraw_later(wp, SOME_VALID) to update the whole window but still use
+// redraw_later(wp, UPD_SOME_VALID) to update the whole window but still use
 // scrolling to avoid redrawing everything.  But the length of displayed lines
-// must not change, use NOT_VALID then.
+// must not change, use UPD_NOT_VALID then.
 //
-// Commands that move the window position must call redraw_later(wp, NOT_VALID).
+// Commands that move the window position must call redraw_later(wp, UPD_NOT_VALID).
 // TODO(neovim): should minimize redrawing by scrolling when possible.
 //
 // Commands that change everything (e.g., resizing the screen) must call
-// redraw_all_later(NOT_VALID) or redraw_all_later(CLEAR).
+// redraw_all_later(UPD_NOT_VALID) or redraw_all_later(UPD_CLEAR).
 //
 // Things that are handled indirectly:
 // - When messages scroll the screen up, msg_scrolled will be set and
@@ -193,7 +193,7 @@ retry:
   default_grid.col_offset = 0;
   default_grid.handle = DEFAULT_GRID_HANDLE;
 
-  must_redraw = CLEAR;  // need to clear the screen later
+  must_redraw = UPD_CLEAR;  // need to clear the screen later
 
   RedrawingDisabled--;
 
@@ -235,18 +235,18 @@ void screenclear(void)
   clear_cmdline = false;
   mode_displayed = false;
 
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
   redraw_cmdline = true;
   redraw_tabline = true;
   redraw_popupmenu = true;
   pum_invalidate();
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
     if (wp->w_floating) {
-      wp->w_redr_type = CLEAR;
+      wp->w_redr_type = UPD_CLEAR;
     }
   }
-  if (must_redraw == CLEAR) {
-    must_redraw = NOT_VALID;  // no need to clear again
+  if (must_redraw == UPD_CLEAR) {
+    must_redraw = UPD_NOT_VALID;  // no need to clear again
   }
   compute_cmdrow();
   msg_row = cmdline_row;  // put cursor on last line for messages
@@ -341,7 +341,7 @@ void screen_resize(int width, int height)
       }
       if (State & MODE_CMDLINE) {
         redraw_popupmenu = false;
-        update_screen(NOT_VALID);
+        update_screen(UPD_NOT_VALID);
         redrawcmdline();
         if (pum_drawn()) {
           cmdline_pum_display(false);
@@ -355,7 +355,7 @@ void screen_resize(int width, int height)
           redraw_popupmenu = false;
           ins_compl_show_pum();
         }
-        update_screen(NOT_VALID);
+        update_screen(UPD_NOT_VALID);
         if (redrawing()) {
           setcursor();
         }
@@ -371,7 +371,7 @@ void screen_resize(int width, int height)
 /// Most code shouldn't call this directly, rather use redraw_later() and
 /// and redraw_all_later() to mark parts of the screen as needing a redraw.
 ///
-/// @param type set to a NOT_VALID to force redraw of entire screen
+/// @param type set to a UPD_NOT_VALID to force redraw of entire screen
 int update_screen(int type)
 {
   static bool did_intro = false;
@@ -403,15 +403,15 @@ int update_screen(int type)
   }
 
   // Need to update w_lines[].
-  if (curwin->w_lines_valid == 0 && type < NOT_VALID) {
-    type = NOT_VALID;
+  if (curwin->w_lines_valid == 0 && type < UPD_NOT_VALID) {
+    type = UPD_NOT_VALID;
   }
 
   // Postpone the redrawing when it's not needed and when being called
   // recursively.
   if (!redrawing() || updating_screen) {
     must_redraw = type;
-    if (type > INVERTED_ALL) {
+    if (type > UPD_INVERTED_ALL) {
       curwin->w_lines_valid = 0;  // don't use w_lines[].wl_size now
     }
     return FAIL;
@@ -428,7 +428,7 @@ int update_screen(int type)
     msg_scrolled_at_flush = 0;
   }
 
-  if (type >= CLEAR || !default_grid.valid) {
+  if (type >= UPD_CLEAR || !default_grid.valid) {
     ui_comp_set_screen_valid(false);
   }
 
@@ -445,8 +445,8 @@ int update_screen(int type)
     }
     if (msg_use_msgsep()) {
       msg_grid.throttled = false;
-      // CLEAR is already handled
-      if (type == NOT_VALID && !ui_has(kUIMultigrid) && msg_scrolled) {
+      // UPD_CLEAR is already handled
+      if (type == UPD_NOT_VALID && !ui_has(kUIMultigrid) && msg_scrolled) {
         ui_comp_set_screen_valid(false);
         for (int i = valid; i < Rows - p_ch; i++) {
           grid_clear_line(&default_grid, default_grid.line_offset[i],
@@ -457,7 +457,7 @@ int update_screen(int type)
             continue;
           }
           if (W_ENDROW(wp) > valid) {
-            wp->w_redr_type = MAX(wp->w_redr_type, NOT_VALID);
+            wp->w_redr_type = MAX(wp->w_redr_type, UPD_NOT_VALID);
           }
           if (!is_stl_global && W_ENDROW(wp) + wp->w_status_height > valid) {
             wp->w_redr_status = true;
@@ -470,8 +470,8 @@ int update_screen(int type)
       msg_grid_set_pos(Rows - (int)p_ch, false);
       msg_grid_invalid = false;
     } else if (msg_scrolled > Rows - 5) {  // clearing is faster
-      type = CLEAR;
-    } else if (type != CLEAR) {
+      type = UPD_CLEAR;
+    } else if (type != UPD_CLEAR) {
       check_for_delay(false);
       grid_ins_lines(&default_grid, 0, msg_scrolled, Rows, 0, Columns);
       FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
@@ -480,13 +480,13 @@ int update_screen(int type)
         }
         if (wp->w_winrow < msg_scrolled) {
           if (W_ENDROW(wp) > msg_scrolled
-              && wp->w_redr_type < REDRAW_TOP
+              && wp->w_redr_type < UPD_REDRAW_TOP
               && wp->w_lines_valid > 0
               && wp->w_topline == wp->w_lines[0].wl_lnum) {
             wp->w_upd_rows = msg_scrolled - wp->w_winrow;
-            wp->w_redr_type = REDRAW_TOP;
+            wp->w_redr_type = UPD_REDRAW_TOP;
           } else {
-            wp->w_redr_type = NOT_VALID;
+            wp->w_redr_type = UPD_NOT_VALID;
             if (wp->w_winrow + wp->w_winbar_height <= msg_scrolled) {
               wp->w_redr_status = true;
             }
@@ -517,10 +517,10 @@ int update_screen(int type)
     hl_changed = true;
   }
 
-  if (type == CLEAR) {          // first clear screen
+  if (type == UPD_CLEAR) {          // first clear screen
     screenclear();              // will reset clear_cmdline
     cmdline_screen_cleared();   // clear external cmdline state
-    type = NOT_VALID;
+    type = UPD_NOT_VALID;
     // must_redraw may be set indirectly, avoid another redraw later
     must_redraw = 0;
   } else if (!default_grid.valid) {
@@ -530,7 +530,7 @@ int update_screen(int type)
 
   // After disabling msgsep the grid might not have been deallocated yet,
   // hence we also need to check msg_grid.chars
-  if (type == NOT_VALID && (msg_use_grid() || msg_grid.chars)) {
+  if (type == UPD_NOT_VALID && (msg_use_grid() || msg_grid.chars)) {
     grid_fill(&default_grid, Rows - (int)p_ch, Rows, 0, Columns, ' ', ' ', 0);
   }
 
@@ -551,23 +551,23 @@ int update_screen(int type)
 
   // Force redraw when width of 'number' or 'relativenumber' column
   // changes.
-  if (curwin->w_redr_type < NOT_VALID
+  if (curwin->w_redr_type < UPD_NOT_VALID
       && curwin->w_nrwidth != ((curwin->w_p_nu || curwin->w_p_rnu)
                                ? number_width(curwin) : 0)) {
-    curwin->w_redr_type = NOT_VALID;
+    curwin->w_redr_type = UPD_NOT_VALID;
   }
 
   // Only start redrawing if there is really something to do.
-  if (type == INVERTED) {
+  if (type == UPD_INVERTED) {
     update_curswant();
   }
   if (curwin->w_redr_type < type
-      && !((type == VALID
+      && !((type == UPD_VALID
             && curwin->w_lines[0].wl_valid
             && curwin->w_topfill == curwin->w_old_topfill
             && curwin->w_botfill == curwin->w_old_botfill
             && curwin->w_topline == curwin->w_lines[0].wl_lnum)
-           || (type == INVERTED
+           || (type == UPD_INVERTED
                && VIsual_active
                && curwin->w_old_cursor_lnum == curwin->w_cursor.lnum
                && curwin->w_old_visual_mode == VIsual_mode
@@ -577,11 +577,11 @@ int update_screen(int type)
   }
 
   // Redraw the tab pages line if needed.
-  if (redraw_tabline || type >= NOT_VALID) {
-    update_window_hl(curwin, type >= NOT_VALID);
+  if (redraw_tabline || type >= UPD_NOT_VALID) {
+    update_window_hl(curwin, type >= UPD_NOT_VALID);
     FOR_ALL_TABS(tp) {
       if (tp != curtab) {
-        update_window_hl(tp->tp_curwin, type >= NOT_VALID);
+        update_window_hl(tp->tp_curwin, type >= UPD_NOT_VALID);
       }
     }
     draw_tabline();
@@ -590,7 +590,7 @@ int update_screen(int type)
   // Correct stored syntax highlighting info for changes in each displayed
   // buffer.  Each buffer must only be done once.
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    update_window_hl(wp, type >= NOT_VALID || hl_changed);
+    update_window_hl(wp, type >= UPD_NOT_VALID || hl_changed);
 
     buf_T *buf = wp->w_buffer;
     if (buf->b_mod_set) {
@@ -612,9 +612,9 @@ int update_screen(int type)
   screen_search_hl.rm.regprog = NULL;
 
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    if (wp->w_redr_type == CLEAR && wp->w_floating && wp->w_grid_alloc.chars) {
+    if (wp->w_redr_type == UPD_CLEAR && wp->w_floating && wp->w_grid_alloc.chars) {
       grid_invalidate(&wp->w_grid_alloc);
-      wp->w_redr_type = NOT_VALID;
+      wp->w_redr_type = UPD_NOT_VALID;
     }
 
     win_check_ns_hl(wp);
@@ -622,7 +622,7 @@ int update_screen(int type)
     // reallocate grid if needed.
     win_grid_alloc(wp);
 
-    if (wp->w_redr_border || wp->w_redr_type >= NOT_VALID) {
+    if (wp->w_redr_border || wp->w_redr_type >= UPD_NOT_VALID) {
       win_redr_border(wp);
     }
 
@@ -957,20 +957,20 @@ static void draw_sep_connectors_win(win_T *wp)
 ///
 /// How the window is redrawn depends on wp->w_redr_type.  Each type also
 /// implies the one below it.
-/// NOT_VALID    redraw the whole window
-/// SOME_VALID   redraw the whole window but do scroll when possible
-/// REDRAW_TOP   redraw the top w_upd_rows window lines, otherwise like VALID
-/// INVERTED     redraw the changed part of the Visual area
-/// INVERTED_ALL redraw the whole Visual area
-/// VALID        1. scroll up/down to adjust for a changed w_topline
-///              2. update lines at the top when scrolled down
-///              3. redraw changed text:
-///                 - if wp->w_buffer->b_mod_set set, update lines between
-///                   b_mod_top and b_mod_bot.
-///                 - if wp->w_redraw_top non-zero, redraw lines between
-///                   wp->w_redraw_top and wp->w_redr_bot.
-///                 - continue redrawing when syntax status is invalid.
-///              4. if scrolled up, update lines at the bottom.
+/// UPD_NOT_VALID    redraw the whole window
+/// UPD_SOME_VALID   redraw the whole window but do scroll when possible
+/// UPD_REDRAW_TOP   redraw the top w_upd_rows window lines, otherwise like UPD_VALID
+/// UPD_INVERTED     redraw the changed part of the Visual area
+/// UPD_INVERTED_ALL redraw the whole Visual area
+/// UPD_VALID        1. scroll up/down to adjust for a changed w_topline
+///                  2. update lines at the top when scrolled down
+///                  3. redraw changed text:
+///                     - if wp->w_buffer->b_mod_set set, update lines between
+///                       b_mod_top and b_mod_bot.
+///                     - if wp->w_redraw_top non-zero, redraw lines between
+///                       wp->w_redraw_top and wp->w_redr_bot.
+///                     - continue redrawing when syntax status is invalid.
+///                  4. if scrolled up, update lines at the bottom.
 /// This results in three areas that may need updating:
 /// top: from first row to top_end (when scrolled down)
 /// mid: from mid_start to mid_end (update inversion or changed text)
@@ -1016,7 +1016,7 @@ win_update_start:
 
   type = wp->w_redr_type;
 
-  if (type >= NOT_VALID) {
+  if (type >= UPD_NOT_VALID) {
     wp->w_redr_status = true;
     wp->w_lines_valid = 0;
   }
@@ -1047,7 +1047,7 @@ win_update_start:
   // changes.
   i = (wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) : 0;
   if (wp->w_nrwidth != i) {
-    type = NOT_VALID;
+    type = UPD_NOT_VALID;
     wp->w_nrwidth = i;
 
     if (buf->terminal) {
@@ -1059,7 +1059,7 @@ win_update_start:
     // When there are both inserted/deleted lines and specific lines to be
     // redrawn, w_redraw_top and w_redraw_bot may be invalid, just redraw
     // everything (only happens when redrawing is off for while).
-    type = NOT_VALID;
+    type = UPD_NOT_VALID;
   } else {
     // Set mod_top to the first line that needs displaying because of
     // changes.  Set mod_bot to the first line after the changes.
@@ -1173,7 +1173,7 @@ win_update_start:
 
   // When only displaying the lines at the top, set top_end.  Used when
   // window has scrolled down for msg_scrolled.
-  if (type == REDRAW_TOP) {
+  if (type == UPD_REDRAW_TOP) {
     j = 0;
     for (i = 0; i < wp->w_lines_valid; i++) {
       j += wp->w_lines[i].wl_size;
@@ -1184,10 +1184,10 @@ win_update_start:
     }
     if (top_end == 0) {
       // not found (cannot happen?): redraw everything
-      type = NOT_VALID;
+      type = UPD_NOT_VALID;
     } else {
-      // top area defined, the rest is VALID
-      type = VALID;
+      // top area defined, the rest is UPD_VALID
+      type = UPD_VALID;
     }
   }
 
@@ -1197,8 +1197,8 @@ win_update_start:
   // 2: wp->w_topline is below wp->w_lines[0].wl_lnum: may scroll up
   // 3: wp->w_topline is wp->w_lines[0].wl_lnum: find first entry in
   //    w_lines[] that needs updating.
-  if ((type == VALID || type == SOME_VALID
-       || type == INVERTED || type == INVERTED_ALL)
+  if ((type == UPD_VALID || type == UPD_SOME_VALID
+       || type == UPD_INVERTED || type == UPD_INVERTED_ALL)
       && !wp->w_botfill && !wp->w_old_botfill) {
     if (mod_top != 0
         && wp->w_topline == mod_top
@@ -1339,25 +1339,25 @@ win_update_start:
       mid_end = wp->w_grid.rows;
     }
   } else {
-    // Not VALID or INVERTED: redraw all lines.
+    // Not UPD_VALID or UPD_INVERTED: redraw all lines.
     mid_start = 0;
     mid_end = wp->w_grid.rows;
   }
 
-  if (type == SOME_VALID) {
-    // SOME_VALID: redraw all lines.
+  if (type == UPD_SOME_VALID) {
+    // UPD_SOME_VALID: redraw all lines.
     mid_start = 0;
     mid_end = wp->w_grid.rows;
-    type = NOT_VALID;
+    type = UPD_NOT_VALID;
   }
 
   // check if we are updating or removing the inverted part
   if ((VIsual_active && buf == curwin->w_buffer)
-      || (wp->w_old_cursor_lnum != 0 && type != NOT_VALID)) {
+      || (wp->w_old_cursor_lnum != 0 && type != UPD_NOT_VALID)) {
     linenr_T from, to;
 
     if (VIsual_active) {
-      if (VIsual_mode != wp->w_old_visual_mode || type == INVERTED_ALL) {
+      if (VIsual_mode != wp->w_old_visual_mode || type == UPD_INVERTED_ALL) {
         // If the type of Visual selection changed, redraw the whole
         // selection.  Also when the ownership of the X selection is
         // gained or lost.
@@ -1928,7 +1928,7 @@ win_update_start:
 
   kvi_destroy(line_providers);
 
-  if (wp->w_redr_type >= REDRAW_TOP) {
+  if (wp->w_redr_type >= UPD_REDRAW_TOP) {
     draw_vsep_win(wp);
     draw_hsep_win(wp);
     draw_sep_connectors_win(wp);
@@ -1985,13 +1985,13 @@ win_update_start:
 /// Redraw a window later, with update_screen(type).
 ///
 /// Set must_redraw only if not already set to a higher value.
-/// e.g. if must_redraw is CLEAR, type NOT_VALID will do nothing.
+/// e.g. if must_redraw is UPD_CLEAR, type UPD_NOT_VALID will do nothing.
 void redraw_later(win_T *wp, int type)
   FUNC_ATTR_NONNULL_ALL
 {
   if (!exiting && wp->w_redr_type < type) {
     wp->w_redr_type = type;
-    if (type >= NOT_VALID) {
+    if (type >= UPD_NOT_VALID) {
       wp->w_lines_valid = 0;
     }
     if (must_redraw < type) {   // must_redraw is the maximum of all windows
@@ -2015,7 +2015,7 @@ void redraw_all_later(int type)
 void screen_invalidate_highlights(void)
 {
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    redraw_later(wp, NOT_VALID);
+    redraw_later(wp, UPD_NOT_VALID);
     wp->w_grid_alloc.valid = false;
   }
 }
@@ -2056,7 +2056,7 @@ void redraw_buf_range_later(buf_T *buf,  linenr_T firstline, linenr_T lastline)
       if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lastline) {
         wp->w_redraw_bot = lastline;
       }
-      redraw_later(wp, VALID);
+      redraw_later(wp, UPD_VALID);
     }
   }
 }
@@ -2070,8 +2070,8 @@ void redraw_buf_status_later(buf_T *buf)
             || (wp == curwin && global_stl_height())
             || wp->w_winbar_height)) {
       wp->w_redr_status = true;
-      if (must_redraw < VALID) {
-        must_redraw = VALID;
+      if (must_redraw < UPD_VALID) {
+        must_redraw = UPD_VALID;
       }
     }
   }
@@ -2086,7 +2086,7 @@ void status_redraw_all(void)
     if ((!is_stl_global && wp->w_status_height) || (is_stl_global && wp == curwin)
         || wp->w_winbar_height) {
       wp->w_redr_status = true;
-      redraw_later(wp, VALID);
+      redraw_later(wp, UPD_VALID);
     }
   }
 }
@@ -2106,7 +2106,7 @@ void status_redraw_buf(buf_T *buf)
     if (wp->w_buffer == buf && ((!is_stl_global && wp->w_status_height)
                                 || (is_stl_global && wp == curwin) || wp->w_winbar_height)) {
       wp->w_redr_status = true;
-      redraw_later(wp, VALID);
+      redraw_later(wp, UPD_VALID);
     }
   }
 }
@@ -2162,6 +2162,6 @@ void redrawWinline(win_T *wp, linenr_T lnum)
     if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum) {
       wp->w_redraw_bot = lnum;
     }
-    redraw_later(wp, VALID);
+    redraw_later(wp, UPD_VALID);
   }
 }
diff --git a/src/nvim/drawscreen.h b/src/nvim/drawscreen.h
index 3eac1caaa1..ef99899581 100644
--- a/src/nvim/drawscreen.h
+++ b/src/nvim/drawscreen.h
@@ -6,13 +6,13 @@
 /// flags for update_screen()
 /// The higher the value, the higher the priority
 enum {
-  VALID        = 10,  ///< buffer not changed, or changes marked with b_mod_*
-  INVERTED     = 20,  ///< redisplay inverted part that changed
-  INVERTED_ALL = 25,  ///< redisplay whole inverted part
-  REDRAW_TOP   = 30,  ///< display first w_upd_rows screen lines
-  SOME_VALID   = 35,  ///< like NOT_VALID but may scroll
-  NOT_VALID    = 40,  ///< buffer needs complete redraw
-  CLEAR        = 50,  ///< screen messed up, clear it
+  UPD_VALID        = 10,  ///< buffer not changed, or changes marked with b_mod_*
+  UPD_INVERTED     = 20,  ///< redisplay inverted part that changed
+  UPD_INVERTED_ALL = 25,  ///< redisplay whole inverted part
+  UPD_REDRAW_TOP   = 30,  ///< display first w_upd_rows screen lines
+  UPD_SOME_VALID   = 35,  ///< like UPD_NOT_VALID but may scroll
+  UPD_NOT_VALID    = 40,  ///< buffer needs complete redraw
+  UPD_CLEAR        = 50,  ///< screen messed up, clear it
 };
 
 /// While redrawing the screen this flag is set.  It means the screen size
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index dc856f01fe..a06cef82a2 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -2621,7 +2621,7 @@ static void internal_format(int textwidth, int second_indent, int flags, int for
 
   if (!format_only && haveto_redraw) {
     update_topline(curwin);
-    redraw_curbuf_later(VALID);
+    redraw_curbuf_later(UPD_VALID);
   }
 }
 
@@ -5024,7 +5024,7 @@ static void ins_up(bool startcol)
     }
     if (old_topline != curwin->w_topline
         || old_topfill != curwin->w_topfill) {
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
     }
     start_arrow(&tpos);
     can_cindent = true;
@@ -5072,7 +5072,7 @@ static void ins_down(bool startcol)
     }
     if (old_topline != curwin->w_topline
         || old_topfill != curwin->w_topfill) {
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
     }
     start_arrow(&tpos);
     can_cindent = true;
@@ -5487,7 +5487,7 @@ static int ins_ctrl_ey(int tc)
     } else {
       scrollup_clamp();
     }
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
   } else {
     c = ins_copychar(curwin->w_cursor.lnum + (c == Ctrl_Y ? -1 : 1));
     if (c != NUL) {
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 23d77e0687..ed00b585b5 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -1300,7 +1300,7 @@ void set_var_const(const char *name, const size_t name_len, typval_T *const tv,
           set_search_direction(v->di_tv.vval.v_number ? '/' : '?');
         } else if (strcmp(varname, "hlsearch") == 0) {
           no_hlsearch = !v->di_tv.vval.v_number;
-          redraw_all_later(SOME_VALID);
+          redraw_all_later(UPD_SOME_VALID);
         }
         return;
       } else if (v->di_tv.v_type != tv->v_type) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 06a372bb93..b4e8c6de7b 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -867,7 +867,7 @@ void ex_retab(exarg_T *eap)
              && tabstop_eq(curbuf->b_p_vts_array, new_vts_array)) {
     // not changed
   } else {
-    redraw_curbuf_later(NOT_VALID);
+    redraw_curbuf_later(UPD_NOT_VALID);
   }
   if (first_line != 0) {
     changed_lines(first_line, 0, last_line + 1, 0L, true);
@@ -1368,7 +1368,7 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
       xfree(cmd_buf);
       goto error;
     }
-    redraw_curbuf_later(VALID);
+    redraw_curbuf_later(UPD_VALID);
   }
   read_linecount = curbuf->b_ml.ml_line_count;
 
@@ -2910,7 +2910,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     update_topline(curwin);
     curwin->w_scbind_pos = curwin->w_topline;
     *so_ptr = n;
-    redraw_curbuf_later(NOT_VALID);     // redraw this buffer later
+    redraw_curbuf_later(UPD_NOT_VALID);  // redraw this buffer later
   }
 
   // Change directories when the 'acd' option is set.
@@ -3959,9 +3959,9 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
 
               update_topline(curwin);
               validate_cursor();
-              update_screen(SOME_VALID);
+              update_screen(UPD_SOME_VALID);
               highlight_match = false;
-              redraw_later(curwin, SOME_VALID);
+              redraw_later(curwin, UPD_SOME_VALID);
 
               curwin->w_p_fen = save_p_fen;
               if (msg_row == Rows - 1) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index e8860ff0d4..457a7393e2 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -249,8 +249,8 @@ void do_exmode(void)
 
   RedrawingDisabled--;
   no_wait_return--;
-  redraw_all_later(NOT_VALID);
-  update_screen(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
+  update_screen(UPD_NOT_VALID);
   need_wait_return = false;
   msg_scroll = save_msg_scroll;
 }
@@ -5059,7 +5059,7 @@ static void ex_tabs(exarg_T *eap)
 static void ex_mode(exarg_T *eap)
 {
   if (*eap->arg == NUL) {
-    must_redraw = CLEAR;
+    must_redraw = UPD_CLEAR;
     ex_redraw(eap);
   } else {
     emsg(_(e_screenmode));
@@ -5151,7 +5151,7 @@ void do_exedit(exarg_T *eap, win_T *old_curwin)
         no_wait_return = 0;
         need_wait_return = false;
         msg_scroll = 0;
-        redraw_all_later(NOT_VALID);
+        redraw_all_later(UPD_NOT_VALID);
         pending_exmode_active = true;
 
         normal_enter(false, true);
@@ -5313,7 +5313,7 @@ static void ex_syncbind(exarg_T *eap)
         scrolldown(-y, true);
       }
       curwin->w_scbind_pos = topline;
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
       cursor_correct();
       curwin->w_redr_status = true;
     }
@@ -5381,7 +5381,7 @@ static void ex_read(exarg_T *eap)
           deleted_lines_mark(lnum, 1L);
         }
       }
-      redraw_curbuf_later(VALID);
+      redraw_curbuf_later(UPD_VALID);
     }
   }
 }
@@ -6052,11 +6052,11 @@ static void ex_redraw(exarg_T *eap)
   validate_cursor();
   update_topline(curwin);
   if (eap->forceit) {
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
     redraw_cmdline = true;
   }
-  update_screen(eap->forceit ? NOT_VALID
-                : VIsual_active ? INVERTED : 0);
+  update_screen(eap->forceit ? UPD_NOT_VALID
+                : VIsual_active ? UPD_INVERTED : 0);
   if (need_maketitle) {
     maketitle();
   }
@@ -6089,7 +6089,7 @@ static void ex_redrawstatus(exarg_T *eap)
   } else {
     status_redraw_curbuf();
   }
-  update_screen(VIsual_active ? INVERTED : 0);
+  update_screen(VIsual_active ? UPD_INVERTED : 0);
   RedrawingDisabled = r;
   p_lz = p;
   ui_flush();
@@ -6492,7 +6492,7 @@ static void ex_pedit(exarg_T *eap)
   if (curwin != curwin_save && win_valid(curwin_save)) {
     // Return cursor to where we were
     validate_cursor();
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
     win_enter(curwin_save, true);
   }
   g_do_tagpreview = 0;
@@ -7134,7 +7134,7 @@ void set_no_hlsearch(bool flag)
 static void ex_nohlsearch(exarg_T *eap)
 {
   set_no_hlsearch(true);
-  redraw_all_later(SOME_VALID);
+  redraw_all_later(UPD_SOME_VALID);
 }
 
 static void ex_fold(exarg_T *eap)
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 9a7b093282..0dce2fd2e2 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -415,7 +415,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
   if (patlen == 0 && !use_last_pat) {
     found = 0;
     set_no_hlsearch(true);  // turn off previous highlight
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   } else {
     int search_flags = SEARCH_OPT + SEARCH_NOOF + SEARCH_PEEK;
     ui_busy_start();
@@ -488,7 +488,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
     next_char = ccline.cmdbuff[skiplen + patlen];
     ccline.cmdbuff[skiplen + patlen] = NUL;
     if (empty_pattern(ccline.cmdbuff) && !no_hlsearch) {
-      redraw_all_later(SOME_VALID);
+      redraw_all_later(UPD_SOME_VALID);
       set_no_hlsearch(true);
     }
     ccline.cmdbuff[skiplen + patlen] = next_char;
@@ -500,7 +500,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
     curwin->w_redr_status = true;
   }
 
-  update_screen(SOME_VALID);
+  update_screen(UPD_SOME_VALID);
   highlight_match = false;
   restore_last_search_pattern();
 
@@ -585,9 +585,9 @@ static void finish_incsearch_highlighting(int gotesc, incsearch_state_T *s, bool
     p_magic = s->magic_save;
 
     validate_cursor();          // needed for TAB
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
     if (call_update_screen) {
-      update_screen(SOME_VALID);
+      update_screen(UPD_SOME_VALID);
     }
   }
 }
@@ -611,7 +611,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
 
     lastwin->w_p_so = 0;
     set_option_value("ch", 1L, NULL, 0);
-    update_screen(VALID);                 // redraw the screen NOW
+    update_screen(UPD_VALID);                 // redraw the screen NOW
 
     made_cmdheight_nonzero = false;
     lastwin->w_p_so = save_so;
@@ -883,7 +883,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
   State = s->save_State;
   if (cmdpreview != save_cmdpreview) {
     cmdpreview = save_cmdpreview;  // restore preview state
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   }
   may_trigger_modechanged();
   setmouse();
@@ -916,7 +916,7 @@ theend:
     // Restore cmdheight
     set_option_value("ch", 0L, NULL, 0);
     // Redraw is needed for command line completion
-    redraw_all_later(CLEAR);
+    redraw_all_later(UPD_CLEAR);
 
     made_cmdheight_nonzero = false;
   }
@@ -1395,7 +1395,7 @@ static int may_do_command_line_next_incsearch(int firstc, long count, incsearch_
     validate_cursor();
     highlight_match = true;
     save_viewstate(curwin, &s->old_viewstate);
-    update_screen(NOT_VALID);
+    update_screen(UPD_NOT_VALID);
     highlight_match = false;
     redrawcmdline();
     curwin->w_cursor = s->match_end;
@@ -2343,7 +2343,7 @@ static bool cmdpreview_may_show(CommandLineState *s)
   if (cmdpreview_type != 0) {
     int save_rd = RedrawingDisabled;
     RedrawingDisabled = 0;
-    update_screen(SOME_VALID);
+    update_screen(UPD_SOME_VALID);
     RedrawingDisabled = save_rd;
   }
 
@@ -2405,7 +2405,7 @@ static int command_line_changed(CommandLineState *s)
     // 'inccommand' preview has been shown.
   } else if (cmdpreview) {
     cmdpreview = false;
-    update_screen(SOME_VALID);  // Clear 'inccommand' preview.
+    update_screen(UPD_SOME_VALID);  // Clear 'inccommand' preview.
   } else {
     if (s->xpc.xp_context == EXPAND_NOTHING && (KeyTyped || vpeekc() == NUL)) {
       may_do_incsearch_highlighting(s->firstc, s->count, &s->is_state);
@@ -4128,7 +4128,7 @@ static int open_cmdwin(void)
     ccline.redraw_state = kCmdRedrawNone;
     ui_call_cmdline_hide(ccline.level);
   }
-  redraw_later(curwin, SOME_VALID);
+  redraw_later(curwin, UPD_SOME_VALID);
 
   // No Ex mode here!
   exmode_active = false;
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 5dfcbb0668..a21fc9e9d4 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -1749,7 +1749,7 @@ failed:
       linecnt = 0;
     }
     if (newfile || read_buffer) {
-      redraw_curbuf_later(NOT_VALID);
+      redraw_curbuf_later(UPD_NOT_VALID);
       // After reading the text into the buffer the diff info needs to
       // be updated.
       diff_invalidate(curbuf);
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 8ce24fd378..5824e02a85 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -394,7 +394,7 @@ void opFoldRange(pos_T firstpos, pos_T lastpos, int opening, int recurse, int ha
   }
   // Force a redraw to remove the Visual highlighting.
   if (had_visual) {
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 }
 
@@ -721,7 +721,7 @@ void deleteFold(win_T *const wp, const linenr_T start, const linenr_T end, const
     emsg(_(e_nofold));
     // Force a redraw to remove the Visual highlighting.
     if (had_visual) {
-      redraw_buf_later(wp->w_buffer, INVERTED);
+      redraw_buf_later(wp->w_buffer, UPD_INVERTED);
     }
   } else {
     // Deleting markers may make cursor column invalid
@@ -819,7 +819,7 @@ void foldUpdateAfterInsert(void)
 void foldUpdateAll(win_T *win)
 {
   win->w_foldinvalid = true;
-  redraw_later(win, NOT_VALID);
+  redraw_later(win, UPD_NOT_VALID);
 }
 
 // foldMoveTo() {{{2
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index c8d4ef18ac..8f0c2315c8 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1750,7 +1750,7 @@ static void getchar_common(typval_T *argvars, typval_T *rettv)
 
   if (!ui_has_messages()) {
     // redraw the screen after getchar()
-    update_screen(CLEAR);
+    update_screen(UPD_CLEAR);
   }
 
   set_vim_var_nr(VV_MOUSE_WIN, 0);
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 65a50df274..04aecc6c3a 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -756,7 +756,7 @@ void set_hl_group(int id, HlAttrs attrs, Dict(highlight) *dict, int link_id)
 
 update:
   if (!updating_screen) {
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
   need_highlight_changed = true;
 }
@@ -893,7 +893,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
         hlgroup->sg_script_ctx.sc_lnum += SOURCING_LNUM;
         nlua_set_sctx(&hlgroup->sg_script_ctx);
         hlgroup->sg_cleared = false;
-        redraw_all_later(SOME_VALID);
+        redraw_all_later(UPD_SOME_VALID);
 
         // Only call highlight changed() once after multiple changes
         need_highlight_changed = true;
@@ -916,7 +916,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
       }
       init_highlight(true, true);
       highlight_changed();
-      redraw_all_later(NOT_VALID);
+      redraw_all_later(UPD_NOT_VALID);
       return;
     }
     name_end = (const char *)skiptowhite((const char_u *)line);
@@ -1270,12 +1270,12 @@ void do_highlight(const char *line, const bool forceit, const bool init)
       // changed
       ui_refresh();
     } else {
-      // TUI and newer UIs will repaint the screen themselves. NOT_VALID
+      // TUI and newer UIs will repaint the screen themselves. UPD_NOT_VALID
       // redraw below will still handle usages of guibg=fg etc.
       ui_default_colors_set();
     }
     did_highlight_changed = true;
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   } else {
     set_hl_attr(idx);
   }
@@ -1292,7 +1292,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
     // redrawing.  This may happen when evaluating 'statusline' changes the
     // StatusLine group.
     if (!updating_screen) {
-      redraw_all_later(NOT_VALID);
+      redraw_all_later(UPD_NOT_VALID);
     }
     need_highlight_changed = true;
   }
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index d1d1480696..bc8d5a3577 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1578,7 +1578,7 @@ void ex_luado(exarg_T *const eap)
   }
   lua_pop(lstate, 1);
   check_cursor();
-  update_screen(NOT_VALID);
+  update_screen(UPD_NOT_VALID);
 }
 
 /// Run lua file
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 3cd0a96116..e4e30b7902 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -479,7 +479,7 @@ int main(int argc, char **argv)
   if (exmode_active || use_remote_ui || use_builtin_ui) {
     // Don't clear the screen when starting in Ex mode, or when a UI might have
     // displayed messages.
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
   } else {
     screenclear();  // clear screen
     TIME_MSG("clearing screen");
@@ -539,7 +539,7 @@ int main(int argc, char **argv)
   starting = 0;
 
   RedrawingDisabled = 0;
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
   no_wait_return = false;
 
   // 'autochdir' has been postponed.
diff --git a/src/nvim/match.c b/src/nvim/match.c
index 1c34c9f004..06489f0456 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -47,7 +47,7 @@ static int match_add(win_T *wp, const char *const grp, const char *const pat, in
   matchitem_T *m;
   int hlg_id;
   regprog_T *regprog = NULL;
-  int rtype = SOME_VALID;
+  int rtype = UPD_SOME_VALID;
 
   if (*grp == NUL || (pat != NULL && *pat == NUL)) {
     return -1;
@@ -193,7 +193,7 @@ static int match_add(win_T *wp, const char *const grp, const char *const pat, in
       }
       m->pos.toplnum = toplnum;
       m->pos.botlnum = botlnum;
-      rtype = VALID;
+      rtype = UPD_VALID;
     }
   }
 
@@ -227,7 +227,7 @@ static int match_delete(win_T *wp, int id, bool perr)
 {
   matchitem_T *cur = wp->w_match_head;
   matchitem_T *prev = cur;
-  int rtype = SOME_VALID;
+  int rtype = UPD_SOME_VALID;
 
   if (id < 1) {
     if (perr) {
@@ -268,7 +268,7 @@ static int match_delete(win_T *wp, int id, bool perr)
       wp->w_buffer->b_mod_bot = cur->pos.botlnum;
       wp->w_buffer->b_mod_xlines = 0;
     }
-    rtype = VALID;
+    rtype = UPD_VALID;
   }
   xfree(cur);
   redraw_later(wp, rtype);
@@ -287,7 +287,7 @@ void clear_matches(win_T *wp)
     xfree(wp->w_match_head);
     wp->w_match_head = m;
   }
-  redraw_later(wp, SOME_VALID);
+  redraw_later(wp, UPD_SOME_VALID);
 }
 
 /// Get match from ID 'id' in window 'wp'.
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index af9e214d92..4173730580 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -2857,7 +2857,7 @@ void f_setcellwidths(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   xfree(cw_table_save);
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
 }
 
 void f_charclass(typval_T *argvars, typval_T *rettv, FunPtr fptr)
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index fd8b2c55b5..3e3a41a963 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1222,7 +1222,7 @@ void ml_recover(bool checkext)
     msg_puts(_("\nYou may want to delete the .swp file now.\n\n"));
     cmdline_row = msg_row;
   }
-  redraw_curbuf_later(NOT_VALID);
+  redraw_curbuf_later(UPD_NOT_VALID);
 
 theend:
   xfree(fname_used);
@@ -2453,7 +2453,7 @@ int ml_replace(linenr_T lnum, char *line, bool copy)
 /// Do not use it after calling ml_replace().
 ///
 /// Check: The caller of this function should probably also call
-/// changed_lines(), unless update_screen(NOT_VALID) is used.
+/// changed_lines(), unless update_screen(UPD_NOT_VALID) is used.
 ///
 /// @return  FAIL for failure, OK otherwise
 int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 684cf7207c..ec06ece7d3 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1131,7 +1131,7 @@ void msg_end_prompt(void)
 
 /// Wait for the user to hit a key (normally Enter)
 ///
-/// @param redraw  if true, redraw the entire screen NOT_VALID
+/// @param redraw  if true, redraw the entire screen UPD_NOT_VALID
 ///                if false, do a normal redraw
 ///                if -1, don't redraw at all
 void wait_return(int redraw)
@@ -1143,7 +1143,7 @@ void wait_return(int redraw)
   FILE *save_scriptout;
 
   if (redraw == true) {
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
 
   // If using ":silent cmd", don't wait for a return.  Also don't set
@@ -1316,7 +1316,7 @@ void wait_return(int redraw)
     ui_refresh();
   } else if (!skip_redraw) {
     if (redraw == true || (msg_scrolled != 0 && redraw != -1)) {
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
     }
     if (ui_has(kUIMessages)) {
       msg_ext_clear(true);
@@ -2478,7 +2478,7 @@ void msg_reset_scroll(void)
       }
     }
   } else {
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
   msg_scrolled = 0;
   msg_scrolled_at_flush = 0;
@@ -2506,8 +2506,8 @@ static void inc_msg_scrolled(void)
     xfree(tofree);
   }
   msg_scrolled++;
-  if (must_redraw < VALID) {
-    must_redraw = VALID;
+  if (must_redraw < UPD_VALID) {
+    must_redraw = UPD_VALID;
   }
 }
 
@@ -3245,8 +3245,8 @@ void msg_ext_clear_later(void)
 {
   if (msg_ext_is_visible()) {
     msg_ext_need_clear = true;
-    if (must_redraw < VALID) {
-      must_redraw = VALID;
+    if (must_redraw < UPD_VALID) {
+      must_redraw = UPD_VALID;
     }
   }
 }
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index a8d0b3b584..b2d6a65955 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -179,7 +179,7 @@ retnomove:
     }
     if (flags & MOUSE_MAY_STOP_VIS) {
       end_visual_mode();
-      redraw_curbuf_later(INVERTED);            // delete the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // delete the inversion
     }
     return IN_BUFFER;
   }
@@ -279,7 +279,7 @@ retnomove:
                     : col >= fdc + (cmdwin_type == 0 && wp == curwin ? 0 : 1))
                 && (flags & MOUSE_MAY_STOP_VIS)))) {
       end_visual_mode();
-      redraw_curbuf_later(INVERTED);            // delete the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // delete the inversion
     }
     if (cmdwin_type != 0 && wp != curwin) {
       // A click outside the command-line window: Use modeless
@@ -345,7 +345,7 @@ retnomove:
     // before moving the cursor for a left click, stop Visual mode
     if (flags & MOUSE_MAY_STOP_VIS) {
       end_visual_mode();
-      redraw_curbuf_later(INVERTED);            // delete the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // delete the inversion
     }
 
     if (grid == 0) {
@@ -381,7 +381,7 @@ retnomove:
       check_topfill(curwin, false);
       curwin->w_valid &=
         ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
       row = 0;
     } else if (row >= curwin->w_height_inner) {
       count = 0;
@@ -410,7 +410,7 @@ retnomove:
         }
       }
       check_topfill(curwin, false);
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
       curwin->w_valid &=
         ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
       row = curwin->w_height_inner - 1;
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 1ed7acd012..883a9dfcb9 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -105,7 +105,7 @@ void redraw_for_cursorline(win_T *wp)
   if ((wp->w_valid & VALID_CROW) == 0 && !pum_visible()
       && (wp->w_p_rnu || win_cursorline_standout(wp))) {
     // win_line() will redraw the number column and cursorline only.
-    redraw_later(wp, VALID);
+    redraw_later(wp, UPD_VALID);
   }
 }
 
@@ -118,11 +118,11 @@ static void redraw_for_cursorcolumn(win_T *wp)
   if ((wp->w_valid & VALID_VIRTCOL) == 0 && !pum_visible()) {
     if (wp->w_p_cuc || ((HL_ATTR(HLF_LC) || win_hl_attr(wp, HLF_LC)) && using_hlsearch())) {
       // When 'cursorcolumn' is set or "CurSearch" is in use
-      // need to redraw with SOME_VALID.
-      redraw_later(wp, SOME_VALID);
+      // need to redraw with UPD_SOME_VALID.
+      redraw_later(wp, UPD_SOME_VALID);
     } else if (wp->w_p_cul && (wp->w_p_culopt_flags & CULOPT_SCRLINE)) {
-      // When 'cursorlineopt' contains "screenline" need to redraw with VALID.
-      redraw_later(wp, VALID);
+      // When 'cursorlineopt' contains "screenline" need to redraw with UPD_VALID.
+      redraw_later(wp, UPD_VALID);
     }
   }
   // If the cursor moves horizontally when 'concealcursor' is active, then the
@@ -184,7 +184,7 @@ void update_topline(win_T *wp)
   // If the buffer is empty, always set topline to 1.
   if (buf_is_empty(curbuf)) {             // special case - file is empty
     if (wp->w_topline != 1) {
-      redraw_later(wp, NOT_VALID);
+      redraw_later(wp, UPD_NOT_VALID);
     }
     wp->w_topline = 1;
     wp->w_botline = 2;
@@ -336,9 +336,9 @@ void update_topline(win_T *wp)
     dollar_vcol = -1;
     if (wp->w_skipcol != 0) {
       wp->w_skipcol = 0;
-      redraw_later(wp, NOT_VALID);
+      redraw_later(wp, UPD_NOT_VALID);
     } else {
-      redraw_later(wp, VALID);
+      redraw_later(wp, UPD_VALID);
     }
     // May need to set w_skipcol when cursor in w_topline.
     if (wp->w_cursor.lnum == wp->w_topline) {
@@ -450,7 +450,7 @@ void changed_window_setting_win(win_T *wp)
   wp->w_lines_valid = 0;
   changed_line_abv_curs_win(wp);
   wp->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP|VALID_TOPLINE);
-  redraw_later(wp, NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
 }
 
 /*
@@ -472,7 +472,7 @@ void set_topline(win_T *wp, linenr_T lnum)
   }
   wp->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_TOPLINE);
   // Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked.
-  redraw_later(wp, VALID);
+  redraw_later(wp, UPD_VALID);
 }
 
 /*
@@ -847,7 +847,7 @@ void curs_columns(win_T *wp, int may_scroll)
         wp->w_leftcol = new_leftcol;
         win_check_anchored_floats(wp);
         // screen has to be redrawn with new wp->w_leftcol
-        redraw_later(wp, NOT_VALID);
+        redraw_later(wp, UPD_NOT_VALID);
       }
     }
     wp->w_wcol -= wp->w_leftcol;
@@ -954,7 +954,7 @@ void curs_columns(win_T *wp, int may_scroll)
     wp->w_skipcol = 0;
   }
   if (prev_skipcol != wp->w_skipcol) {
-    redraw_later(wp, NOT_VALID);
+    redraw_later(wp, UPD_NOT_VALID);
   }
 
   redraw_for_cursorcolumn(curwin);
@@ -2040,7 +2040,7 @@ int onepage(Direction dir, long count)
     }
   }
 
-  redraw_later(curwin, VALID);
+  redraw_later(curwin, UPD_VALID);
   return retval;
 }
 
@@ -2232,7 +2232,7 @@ void halfpage(bool flag, linenr_T Prenum)
   check_topfill(curwin, !flag);
   cursor_correct();
   beginline(BL_SOL | BL_FIX);
-  redraw_later(curwin, VALID);
+  redraw_later(curwin, UPD_VALID);
 }
 
 void do_check_cursorbind(void)
@@ -2284,7 +2284,7 @@ void do_check_cursorbind(void)
       }
       // Correct cursor for multi-byte character.
       mb_adjust_cursor();
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
 
       // Only scroll when 'scrollbind' hasn't done this.
       if (!curwin->w_p_scb) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 2c7dadad0b..75900b735b 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -523,7 +523,7 @@ static bool normal_handle_special_visual_command(NormalState *s)
       && (nv_cmds[s->idx].cmd_flags & NV_STS)
       && !(mod_mask & MOD_MASK_SHIFT)) {
     end_visual_mode();
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 
   // Keys that work different when 'keymodel' contains "startsel"
@@ -1281,7 +1281,7 @@ static void normal_redraw(NormalState *s)
   validate_cursor();
 
   if (VIsual_active) {
-    redraw_curbuf_later(INVERTED);  // update inverted part
+    redraw_curbuf_later(UPD_INVERTED);  // update inverted part
     update_screen(0);
   } else if (must_redraw) {
     update_screen(0);
@@ -1838,7 +1838,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, long count, bool fixindent)
       }
       if (jump_flags) {
         jump_flags = jump_to_mouse(jump_flags, NULL, which_button);
-        redraw_curbuf_later(VIsual_active ? INVERTED : VALID);
+        redraw_curbuf_later(VIsual_active ? UPD_INVERTED : UPD_VALID);
         update_screen(0);
         setcursor();
         ui_flush();  // Update before showing popup menu
@@ -2186,7 +2186,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, long count, bool fixindent)
       curwin->w_set_curswant = true;
     }
     if (is_click) {
-      redraw_curbuf_later(INVERTED);            // update the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // update the inversion
     }
   } else if (VIsual_active && !old_active) {
     if (mod_mask & MOD_MASK_ALT) {
@@ -2311,7 +2311,7 @@ void reset_VIsual_and_resel(void)
 {
   if (VIsual_active) {
     end_visual_mode();
-    redraw_curbuf_later(INVERTED);      // delete the inversion later
+    redraw_curbuf_later(UPD_INVERTED);  // delete the inversion later
   }
   VIsual_reselect = false;
 }
@@ -2321,7 +2321,7 @@ void reset_VIsual(void)
 {
   if (VIsual_active) {
     end_visual_mode();
-    redraw_curbuf_later(INVERTED);      // delete the inversion later
+    redraw_curbuf_later(UPD_INVERTED);  // delete the inversion later
     VIsual_reselect = false;
   }
 }
@@ -2956,7 +2956,7 @@ void check_scrollbind(linenr_T topline_diff, long leftcol_diff)
         }
       }
 
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
       cursor_correct();
       curwin->w_redr_status = true;
     }
@@ -3490,7 +3490,7 @@ void scroll_redraw(int up, long count)
   if (moved) {
     curwin->w_viewport_invalid = true;
   }
-  redraw_later(curwin, VALID);
+  redraw_later(curwin, UPD_VALID);
 }
 
 /// Get the count specified after a 'z' command. Only the 'z<CR>', 'zl', 'zh',
@@ -3656,7 +3656,7 @@ static void nv_zet(cmdarg_T *cap)
 
   case 't':
     scroll_cursor_top(0, true);
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
     set_fraction(curwin);
     break;
 
@@ -3667,7 +3667,7 @@ static void nv_zet(cmdarg_T *cap)
 
   case 'z':
     scroll_cursor_halfway(true);
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
     set_fraction(curwin);
     break;
 
@@ -3690,7 +3690,7 @@ static void nv_zet(cmdarg_T *cap)
 
   case 'b':
     scroll_cursor_bot(0, true);
-    redraw_later(curwin, VALID);
+    redraw_later(curwin, UPD_VALID);
     set_fraction(curwin);
     break;
 
@@ -3742,7 +3742,7 @@ static void nv_zet(cmdarg_T *cap)
       }
       if (curwin->w_leftcol != col) {
         curwin->w_leftcol = col;
-        redraw_later(curwin, NOT_VALID);
+        redraw_later(curwin, UPD_NOT_VALID);
       }
     }
     break;
@@ -3763,7 +3763,7 @@ static void nv_zet(cmdarg_T *cap)
       }
       if (curwin->w_leftcol != col) {
         curwin->w_leftcol = col;
-        redraw_later(curwin, NOT_VALID);
+        redraw_later(curwin, UPD_NOT_VALID);
       }
     }
     break;
@@ -4098,7 +4098,7 @@ static void nv_clear(cmdarg_T *cap)
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       wp->w_s->b_syn_slow = false;
     }
-    redraw_later(curwin, CLEAR);
+    redraw_later(curwin, UPD_CLEAR);
   }
 }
 
@@ -5819,7 +5819,7 @@ static void nv_visual(cmdarg_T *cap)
       showmode();
       may_trigger_modechanged();
     }
-    redraw_curbuf_later(INVERTED);          // update the inversion
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
   } else {                // start Visual mode
     if (cap->count0 > 0 && resel_VIsual_mode != NUL) {
       // use previously selected part
@@ -5865,7 +5865,7 @@ static void nv_visual(cmdarg_T *cap)
       } else {
         curwin->w_set_curswant = true;
       }
-      redraw_curbuf_later(INVERTED);            // show the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // show the inversion
     } else {
       if (!cap->arg) {
         // start Select mode when 'selectmode' contains "cmd"
@@ -5931,7 +5931,7 @@ static void n_start_visual_mode(int c)
   }
   // Only need to redraw this line, unless still need to redraw an old
   // Visual area (when 'lazyredraw' is set).
-  if (curwin->w_redr_type < INVERTED) {
+  if (curwin->w_redr_type < UPD_INVERTED) {
     curwin->w_old_cursor_lnum = curwin->w_cursor.lnum;
     curwin->w_old_visual_lnum = curwin->w_cursor.lnum;
   }
@@ -6018,7 +6018,7 @@ static void nv_gv_cmd(cmdarg_T *cap)
     may_start_select('c');
   }
   setmouse();
-  redraw_curbuf_later(INVERTED);
+  redraw_curbuf_later(UPD_INVERTED);
   showmode();
 }
 
@@ -6901,7 +6901,7 @@ static void nv_normal(cmdarg_T *cap)
     }
     if (VIsual_active) {
       end_visual_mode();                // stop Visual
-      redraw_curbuf_later(INVERTED);
+      redraw_curbuf_later(UPD_INVERTED);
     }
   } else {
     clearopbeep(cap->oap);
@@ -6955,7 +6955,7 @@ static void nv_esc(cmdarg_T *cap)
     end_visual_mode();          // stop Visual
     check_cursor_col();         // make sure cursor is not beyond EOL
     curwin->w_set_curswant = true;
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   } else if (no_reason) {
     vim_beep(BO_ESC);
   }
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 3be4536f16..e4282ceff9 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -682,7 +682,7 @@ void op_reindent(oparg_T *oap, Indenter how)
                   oap->is_VIsual ? start_lnum + (linenr_T)oap->line_count :
                   last_changed + 1, 0L, true);
   } else if (oap->is_VIsual) {
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 
   if (oap->line_count > p_report) {
@@ -909,7 +909,7 @@ int do_record(int c)
       if (!ui_has_messages()) {
         // Enable macro indicator temporarily
         set_option_value("ch", 1L, NULL, 0);
-        update_screen(VALID);
+        update_screen(UPD_VALID);
 
         changed_cmdheight = true;
       }
@@ -963,7 +963,7 @@ int do_record(int c)
     if (changed_cmdheight) {
       // Restore cmdheight
       set_option_value("ch", 0L, NULL, 0);
-      redraw_all_later(CLEAR);
+      redraw_all_later(UPD_CLEAR);
     }
   }
   return retval;
@@ -2143,7 +2143,7 @@ void op_tilde(oparg_T *oap)
 
   if (!did_change && oap->is_VIsual) {
     // No change: need to remove the Visual selection
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 
   if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
@@ -2262,7 +2262,7 @@ void op_insert(oparg_T *oap, long count1)
 
   // vis block is still marked. Get rid of it now.
   curwin->w_cursor.lnum = oap->start.lnum;
-  update_screen(INVERTED);
+  update_screen(UPD_INVERTED);
 
   if (oap->motion_type == kMTBlockWise) {
     // When 'virtualedit' is used, need to insert the extra spaces before
@@ -4309,7 +4309,7 @@ static void op_format(oparg_T *oap, int keep_cursor)
 
   if (oap->is_VIsual) {
     // When there is no change: need to remove the Visual selection
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 
   if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
@@ -4370,7 +4370,7 @@ static void op_formatexpr(oparg_T *oap)
 {
   if (oap->is_VIsual) {
     // When there is no change: need to remove the Visual selection
-    redraw_curbuf_later(INVERTED);
+    redraw_curbuf_later(UPD_INVERTED);
   }
 
   if (fex_format(oap->start.lnum, oap->line_count, NUL) != 0) {
@@ -4962,7 +4962,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
 
     if (!change_cnt && oap->is_VIsual) {
       // No change: need to remove the Visual selection
-      redraw_curbuf_later(INVERTED);
+      redraw_curbuf_later(UPD_INVERTED);
     }
 
     // Set '[ mark if something changed. Keep the last end
@@ -6596,7 +6596,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
             && oap->motion_force == NUL) {
           // Make sure redrawing is correct.
           curwin->w_p_lbr = lbr_saved;
-          redraw_curbuf_later(INVERTED);
+          redraw_curbuf_later(UPD_INVERTED);
         }
       }
     }
@@ -6628,7 +6628,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
     if (oap->is_VIsual && (oap->empty || !MODIFIABLE(curbuf)
                            || oap->op_type == OP_FOLD)) {
       curwin->w_p_lbr = lbr_saved;
-      redraw_curbuf_later(INVERTED);
+      redraw_curbuf_later(UPD_INVERTED);
     }
 
     // If the end of an operator is in column one while oap->motion_type
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 0cf5b4bddf..b1d5be8cb7 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -847,7 +847,7 @@ int do_set(char *arg, int opt_flags)
         didset_options();
         didset_options2();
         ui_refresh_options();
-        redraw_all_later(CLEAR);
+        redraw_all_later(UPD_CLEAR);
       } else {
         showoptions(1, opt_flags);
         did_show = true;
@@ -2089,7 +2089,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
     paste_option_changed();
   } else if ((int *)varp == &p_ic && p_hls) {
     // when 'ignorecase' is set or reset and 'hlsearch' is set, redraw
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   } else if ((int *)varp == &p_hls) {
     // when 'hlsearch' is set or reset: reset no_hlsearch
     set_no_hlsearch(false);
@@ -2184,7 +2184,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
         // Enable Arabic shaping (major part of what Arabic requires)
         if (!p_arshape) {
           p_arshape = true;
-          redraw_all_later(NOT_VALID);
+          redraw_all_later(UPD_NOT_VALID);
         }
       }
 
@@ -2741,15 +2741,15 @@ void check_redraw(uint32_t flags)
     changed_window_setting();
   }
   if (flags & P_RBUF) {
-    redraw_curbuf_later(NOT_VALID);
+    redraw_curbuf_later(UPD_NOT_VALID);
   }
   if (flags & P_RWINONLY) {
-    redraw_later(curwin, NOT_VALID);
+    redraw_later(curwin, UPD_NOT_VALID);
   }
   if (doclear) {
-    redraw_all_later(CLEAR);
+    redraw_all_later(UPD_CLEAR);
   } else if (all) {
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
 }
 
@@ -3817,12 +3817,12 @@ void unset_global_local_option(char *name, void *from)
   case PV_LCS:
     clear_string_option(&((win_T *)from)->w_p_lcs);
     set_chars_option((win_T *)from, &((win_T *)from)->w_p_lcs, true);
-    redraw_later((win_T *)from, NOT_VALID);
+    redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_FCS:
     clear_string_option(&((win_T *)from)->w_p_fcs);
     set_chars_option((win_T *)from, &((win_T *)from)->w_p_fcs, true);
-    redraw_later((win_T *)from, NOT_VALID);
+    redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_VE:
     clear_string_option(&((win_T *)from)->w_p_ve);
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 3287abdd9c..78ae7e41ab 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -895,7 +895,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       // Redraw needed when switching to/from "mac": a CR in the text
       // will be displayed differently.
       if (get_fileformat(curbuf) == EOL_MAC || *oldval == 'm') {
-        redraw_curbuf_later(NOT_VALID);
+        redraw_curbuf_later(UPD_NOT_VALID);
       }
     }
   } else if (varp == (char_u **)&p_ffs) {  // 'fileformats'
@@ -962,7 +962,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         // here, so ignore the return value.
         (void)set_chars_option(wp, &wp->w_p_lcs, true);
       }
-      redraw_all_later(NOT_VALID);
+      redraw_all_later(UPD_NOT_VALID);
     }
   } else if (varp == &curwin->w_p_lcs) {  // local 'listchars'
     errmsg = set_chars_option(curwin, varp, true);
@@ -979,7 +979,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         // here, so ignore the return value.
         (void)set_chars_option(wp, &wp->w_p_fcs, true);
       }
-      redraw_all_later(NOT_VALID);
+      redraw_all_later(UPD_NOT_VALID);
     }
   } else if (varp == &curwin->w_p_fcs) {  // local 'fillchars'
     errmsg = set_chars_option(curwin, varp, true);
@@ -1158,7 +1158,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     } else {
       if (curwin->w_status_height || global_stl_height()) {
         curwin->w_redr_status = true;
-        redraw_later(curwin, VALID);
+        redraw_later(curwin, UPD_VALID);
       }
       curbuf->b_help = (curbuf->b_p_bt[0] == 'h');
       redraw_titles();
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index d392bb5a2c..2eaf0a17fb 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -802,7 +802,7 @@ static bool pum_set_selected(int n, int repeat)
 
             // Return cursor to where we were
             validate_cursor();
-            redraw_later(curwin, SOME_VALID);
+            redraw_later(curwin, UPD_SOME_VALID);
 
             // When the preview window was resized we need to
             // update the view on the buffer.  Only go back to
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index d5f4996f61..6d1bd27442 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -3710,7 +3710,7 @@ static void qf_win_goto(win_T *win, linenr_T lnum)
   curwin->w_cursor.coladd = 0;
   curwin->w_curswant = 0;
   update_topline(curwin);              // scroll to show the line
-  redraw_later(curwin, VALID);
+  redraw_later(curwin, UPD_VALID);
   curwin->w_redr_status = true;  // update ruler
   curwin = old_curwin;
   curbuf = curwin->w_buffer;
@@ -3898,7 +3898,7 @@ static void qf_update_buffer(qf_info_T *qi, qfline_T *old_last)
     // Only redraw when added lines are visible.  This avoids flickering when
     // the added lines are not visible.
     if ((win = qf_find_win(qi)) != NULL && old_line_count < win->w_botline) {
-      redraw_buf_later(buf, NOT_VALID);
+      redraw_buf_later(buf, UPD_NOT_VALID);
     }
   }
 }
@@ -4118,7 +4118,7 @@ static void qf_fill_buffer(qf_list_T *qfl, buf_T *buf, qfline_T *old_last, int q
     curbuf->b_ro_locked--;
 
     // make sure it will be redrawn
-    redraw_curbuf_later(NOT_VALID);
+    redraw_curbuf_later(UPD_NOT_VALID);
   }
 
   // Restore KeyTyped, setting 'filetype' may reset it.
diff --git a/src/nvim/search.c b/src/nvim/search.c
index c53d955974..ca5cb7f220 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -220,7 +220,7 @@ void save_re_pat(int idx, char_u *pat, int magic)
     last_idx = idx;
     // If 'hlsearch' set and search pat changed: need redraw.
     if (p_hls) {
-      redraw_all_later(SOME_VALID);
+      redraw_all_later(UPD_SOME_VALID);
     }
     set_no_hlsearch(false);
   }
@@ -498,7 +498,7 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
   }
   // If 'hlsearch' set and search pat changed: need redraw.
   if (p_hls && idx == last_idx && !no_hlsearch) {
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   }
 }
 
@@ -1093,7 +1093,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
    * Turn 'hlsearch' highlighting back on.
    */
   if (no_hlsearch && !(options & SEARCH_KEEP)) {
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
     set_no_hlsearch(false);
   }
 
@@ -2414,7 +2414,7 @@ void showmatch(int c)
         dollar_vcol = -1;
       }
       curwin->w_virtcol++;              // do display ')' just before "$"
-      update_screen(VALID);             // show the new char first
+      update_screen(UPD_VALID);         // show the new char first
 
       save_dollar_vcol = dollar_vcol;
       save_state = State;
@@ -3107,7 +3107,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
     if (VIsual_active) {
       // should do something when inclusive == false !
       VIsual = start_pos;
-      redraw_curbuf_later(INVERTED);            // update the inversion
+      redraw_curbuf_later(UPD_INVERTED);  // update the inversion
     } else {
       oap->start = start_pos;
       oap->motion_type = kMTCharWise;
@@ -3362,7 +3362,7 @@ extend:
     VIsual = start_pos;
     VIsual_mode = 'v';
     redraw_cmdline = true;    // show mode later
-    redraw_curbuf_later(INVERTED);      // update the inversion
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
   } else {
     // include a newline after the sentence, if there is one
     if (incl(&curwin->w_cursor) == -1) {
@@ -3502,7 +3502,7 @@ int current_block(oparg_T *oap, long count, int include, int what, int other)
     }
     VIsual = start_pos;
     VIsual_mode = 'v';
-    redraw_curbuf_later(INVERTED);      // update the inversion
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
     showmode();
   } else {
     oap->start = start_pos;
@@ -3744,7 +3744,7 @@ again:
     }
     VIsual = start_pos;
     VIsual_mode = 'v';
-    redraw_curbuf_later(INVERTED);      // update the inversion
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
     showmode();
   } else {
     oap->start = start_pos;
@@ -3924,7 +3924,7 @@ extend:
       VIsual.col = 0;
     }
     VIsual_mode = 'V';
-    redraw_curbuf_later(INVERTED);      // update the inversion
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
     showmode();
   } else {
     oap->start.lnum = start_lnum;
@@ -4196,7 +4196,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
                     && (VIsual.col == 0
                         || line[VIsual.col - 1] != quotechar))))) {
       VIsual = curwin->w_cursor;
-      redraw_curbuf_later(INVERTED);
+      redraw_curbuf_later(UPD_INVERTED);
     }
   } else {
     oap->start = curwin->w_cursor;
@@ -4389,7 +4389,7 @@ int current_search(long count, bool forward)
 
   may_start_select('c');
   setmouse();
-  redraw_curbuf_later(INVERTED);
+  redraw_curbuf_later(UPD_INVERTED);
   showmode();
 
   return OK;
@@ -5827,7 +5827,7 @@ search_line:
             && curwin != curwin_save && win_valid(curwin_save)) {
           // Return cursor to where we were
           validate_cursor();
-          redraw_later(curwin, VALID);
+          redraw_later(curwin, UPD_VALID);
           win_enter(curwin_save, true);
         }
         break;
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index f1ddbfd147..1f4daf392a 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -203,7 +203,7 @@ static void insert_sign(buf_T *buf, sign_entry_T *prev, sign_entry_T *next, int
     // When adding first sign need to redraw the windows to create the
     // column for signs.
     if (buf->b_signlist == NULL) {
-      redraw_buf_later(buf, NOT_VALID);
+      redraw_buf_later(buf, UPD_NOT_VALID);
       changed_line_abv_curs();
     }
 
@@ -576,7 +576,7 @@ static linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char_u *group)
   // When deleting the last sign the cursor position may change, because the
   // sign columns no longer shows.  And the 'signcolumn' may be hidden.
   if (buf->b_signlist == NULL) {
-    redraw_buf_later(buf, NOT_VALID);
+    redraw_buf_later(buf, UPD_NOT_VALID);
     changed_line_abv_curs();
   }
 
@@ -934,7 +934,7 @@ static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_
     // non-empty sign list.
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp->w_buffer->b_signlist != NULL) {
-        redraw_buf_later(wp->w_buffer, NOT_VALID);
+        redraw_buf_later(wp->w_buffer, UPD_NOT_VALID);
       }
     }
   }
@@ -1084,7 +1084,7 @@ static int sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T at
   }
   if (sign_id == 0) {
     // Delete all the signs in the specified buffer
-    redraw_buf_later(buf, NOT_VALID);
+    redraw_buf_later(buf, UPD_NOT_VALID);
     buf_delete_signs(buf, (char *)sign_group);
   } else {
     linenr_T lnum;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 40114f084d..ecb97afd02 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -2089,7 +2089,7 @@ char *did_set_spelllang(win_T *wp)
       }
     }
   }
-  redraw_later(wp, NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
 
 theend:
   xfree(spl_copy);
@@ -3117,7 +3117,7 @@ void ex_spelldump(exarg_T *eap)
   if (curbuf->b_ml.ml_line_count > 1) {
     ml_delete(curbuf->b_ml.ml_line_count, false);
   }
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
 /// Go through all possible words and:
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index be19e1d655..389f9902ba 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -1828,7 +1828,7 @@ static void spell_reload_one(char_u *fname, bool added_word)
         // reloading failed, clear the language
         slang_clear(slang);
       }
-      redraw_all_later(SOME_VALID);
+      redraw_all_later(UPD_SOME_VALID);
       didit = true;
     }
   }
@@ -5667,7 +5667,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
       buf_reload(buf, buf->b_orig_mode, false);
     }
 
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   }
   xfree(fnamebuf);
 }
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 005d7dc4e1..0fa93b87a1 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -3143,7 +3143,7 @@ static void syn_cmd_spell(exarg_T *eap, int syncing)
   }
 
   // assume spell checking changed, force a redraw
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
 /// Handle ":syntax iskeyword" command.
@@ -3183,7 +3183,7 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
       curbuf->b_p_isk = save_isk;
     }
   }
-  redraw_later(curwin, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
 }
 
 /*
@@ -3383,7 +3383,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
       arg = (char_u *)skipwhite((char *)arg_end);
     }
   }
-  redraw_curbuf_later(SOME_VALID);
+  redraw_curbuf_later(UPD_SOME_VALID);
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
@@ -4420,7 +4420,7 @@ error:
     semsg(_(e_invarg2), arg);
   }
 
-  redraw_curbuf_later(SOME_VALID);
+  redraw_curbuf_later(UPD_SOME_VALID);
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
@@ -4502,7 +4502,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
           ++curwin->w_s->b_syn_folditems;
         }
 
-        redraw_curbuf_later(SOME_VALID);
+        redraw_curbuf_later(UPD_SOME_VALID);
         syn_stack_free_all(curwin->w_s);          // Need to recompute all syntax.
         return;           // don't free the progs and patterns now
       }
@@ -4718,7 +4718,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
           }
         }
 
-        redraw_curbuf_later(SOME_VALID);
+        redraw_curbuf_later(UPD_SOME_VALID);
         syn_stack_free_all(curwin->w_s);  // Need to recompute all syntax.
         success = true;                   // don't free the progs and patterns now
       }
@@ -5021,7 +5021,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
     }
 
     if (got_clstr) {
-      redraw_curbuf_later(SOME_VALID);
+      redraw_curbuf_later(UPD_SOME_VALID);
       syn_stack_free_all(curwin->w_s);          // Need to recompute all.
     }
   }
@@ -5265,7 +5265,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
     semsg(_("E404: Illegal arguments: %s"), arg_start);
   } else if (!finished) {
     eap->nextcmd = (char *)check_nextcmd(arg_start);
-    redraw_curbuf_later(SOME_VALID);
+    redraw_curbuf_later(UPD_SOME_VALID);
     syn_stack_free_all(curwin->w_s);            // Need to recompute all syntax.
   }
 }
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 65c56bf01b..3c569ed7b8 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -2944,7 +2944,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
         && curwin != curwin_save && win_valid(curwin_save)) {
       // Return cursor to where we were
       validate_cursor();
-      redraw_later(curwin, VALID);
+      redraw_later(curwin, UPD_VALID);
       win_enter(curwin_save, true);
     }
 
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 08fcefaa88..1b4ac12aa6 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -1375,7 +1375,7 @@ static bool send_mouse_event(Terminal *term, int c)
     curwin->w_redr_status = true;
     curwin = save_curwin;
     curbuf = curwin->w_buffer;
-    redraw_later(mouse_win, NOT_VALID);
+    redraw_later(mouse_win, UPD_NOT_VALID);
     invalidate_terminal(term, -1, -1);
     // Only need to exit focus if the scrolled window is the terminal window
     return mouse_win == curwin;
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 75a09b244c..9f3d5bd1e8 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -2560,7 +2560,7 @@ static void u_undo_end(bool did_undo, bool absolute, bool quiet)
   {
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
       if (wp->w_buffer == curbuf && wp->w_p_cole > 0) {
-        redraw_later(wp, NOT_VALID);
+        redraw_later(wp, UPD_NOT_VALID);
       }
     }
   }
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 68c5b42e30..89611177f9 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -712,7 +712,7 @@ win_T *win_new_float(win_T *wp, bool last, FloatConfig fconfig, Error *err)
   win_config_float(wp, fconfig);
   win_set_inner_size(wp, true);
   wp->w_pos_changed = true;
-  redraw_later(wp, VALID);
+  redraw_later(wp, UPD_VALID);
   return wp;
 }
 
@@ -797,12 +797,12 @@ void win_config_float(win_T *wp, FloatConfig fconfig)
   }
 
   win_set_inner_size(wp, true);
-  must_redraw = MAX(must_redraw, VALID);
+  must_redraw = MAX(must_redraw, UPD_VALID);
 
   wp->w_pos_changed = true;
   if (change_external || change_border) {
     wp->w_hl_needs_update = true;
-    redraw_later(wp, NOT_VALID);
+    redraw_later(wp, UPD_NOT_VALID);
   }
 
   // compute initial position
@@ -839,7 +839,7 @@ void win_config_float(win_T *wp, FloatConfig fconfig)
   // changing border style while keeping border only requires redrawing border
   if (fconfig.border) {
     wp->w_redr_border = true;
-    redraw_later(wp, VALID);
+    redraw_later(wp, UPD_VALID);
   }
 }
 
@@ -928,7 +928,7 @@ void ui_ext_win_position(win_T *wp)
       wp->w_grid_alloc.focusable = wp->w_float_config.focusable;
       if (!valid) {
         wp->w_grid_alloc.valid = false;
-        redraw_later(wp, NOT_VALID);
+        redraw_later(wp, UPD_NOT_VALID);
       }
     }
   } else {
@@ -1474,8 +1474,8 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
 
   // Both windows need redrawing.  Update all status lines, in case they
   // show something related to the window count or position.
-  redraw_later(wp, NOT_VALID);
-  redraw_later(oldwin, NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
+  redraw_later(oldwin, UPD_NOT_VALID);
   status_redraw_all();
 
   if (need_status) {
@@ -1837,8 +1837,8 @@ static void win_exchange(long Prenum)
   }
 
   win_enter(wp, true);
-  redraw_later(curwin, NOT_VALID);
-  redraw_later(wp, NOT_VALID);
+  redraw_later(curwin, UPD_NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
 }
 
 // rotate windows: if upwards true the second window becomes the first one
@@ -1922,7 +1922,7 @@ static void win_rotate(bool upwards, int count)
   wp1->w_pos_changed = true;
   wp2->w_pos_changed = true;
 
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
 }
 
 /*
@@ -2034,7 +2034,7 @@ void win_move_after(win_T *win1, win_T *win2)
     frame_append(win2->w_frame, win1->w_frame);
 
     (void)win_comp_pos();  // recompute w_winrow for all windows
-    redraw_later(curwin, NOT_VALID);
+    redraw_later(curwin, UPD_NOT_VALID);
   }
   win_enter(win1, false);
 
@@ -2125,7 +2125,7 @@ static void win_equal_rec(win_T *next_curwin, bool current, frame_T *topfr, int
       frame_new_height(topfr, height, false, false);
       topfr->fr_win->w_wincol = col;
       frame_new_width(topfr, width, false, false);
-      redraw_all_later(NOT_VALID);
+      redraw_all_later(UPD_NOT_VALID);
     }
   } else if (topfr->fr_layout == FR_ROW) {
     topfr->fr_width = width;
@@ -2436,7 +2436,7 @@ void entering_window(win_T *const win)
 
 void win_init_empty(win_T *wp)
 {
-  redraw_later(wp, NOT_VALID);
+  redraw_later(wp, UPD_NOT_VALID);
   wp->w_lines_valid = 0;
   wp->w_cursor.lnum = 1;
   wp->w_curswant = wp->w_cursor.col = 0;
@@ -2935,7 +2935,7 @@ int win_close(win_T *win, bool free_buf, bool force)
   }
 
   curwin->w_pos_changed = true;
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
   return OK;
 }
 
@@ -4115,7 +4115,7 @@ int win_new_tabpage(int after, char_u *filename)
     newtp->tp_topframe = topframe;
     last_status(false);
 
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
 
     tabpage_check_windows(old_curtab);
 
@@ -4373,7 +4373,7 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, bool trigger_enter_a
     }
   }
 
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
 }
 
 /// tells external UI that windows and inline floats in old_curtab are invisible
@@ -4867,7 +4867,7 @@ static void win_enter_ext(win_T *const wp, const int flags)
   curwin->w_redr_status = true;
   redraw_tabline = true;
   if (restart_edit) {
-    redraw_later(curwin, VALID);  // causes status line redraw
+    redraw_later(curwin, UPD_VALID);  // causes status line redraw
   }
 
   // change background color according to NormalNC,
@@ -4875,11 +4875,11 @@ static void win_enter_ext(win_T *const wp, const int flags)
   if (curwin->w_hl_attr_normal != curwin->w_hl_attr_normalnc) {
     // TODO(bfredl): eventually we should be smart enough
     // to only recompose the window, not redraw it.
-    redraw_later(curwin, NOT_VALID);
+    redraw_later(curwin, UPD_NOT_VALID);
   }
   if (prevwin) {
     if (prevwin->w_hl_attr_normal != prevwin->w_hl_attr_normalnc) {
-      redraw_later(prevwin, NOT_VALID);
+      redraw_later(prevwin, UPD_NOT_VALID);
     }
   }
 
@@ -5470,7 +5470,7 @@ static void frame_comp_pos(frame_T *topfrp, int *row, int *col)
       // position changed, redraw
       wp->w_winrow = *row;
       wp->w_wincol = *col;
-      redraw_later(wp, NOT_VALID);
+      redraw_later(wp, UPD_NOT_VALID);
       wp->w_redr_status = true;
       wp->w_pos_changed = true;
     }
@@ -5513,7 +5513,7 @@ void win_setheight_win(int height, win_T *win)
   if (win->w_floating) {
     win->w_float_config.height = height;
     win_config_float(win, win->w_float_config);
-    redraw_later(win, NOT_VALID);
+    redraw_later(win, UPD_NOT_VALID);
   } else {
     frame_setheight(win->w_frame, height + win->w_hsep_height + win->w_status_height);
 
@@ -5533,7 +5533,7 @@ void win_setheight_win(int height, win_T *win)
     curtab->tp_ch_used = p_ch;
     msg_row = row;
     msg_col = 0;
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
     redraw_cmdline = true;
   }
 }
@@ -5735,13 +5735,13 @@ void win_setwidth_win(int width, win_T *wp)
   if (wp->w_floating) {
     wp->w_float_config.width = width;
     win_config_float(wp, wp->w_float_config);
-    redraw_later(wp, NOT_VALID);
+    redraw_later(wp, UPD_NOT_VALID);
   } else {
     frame_setwidth(wp->w_frame, width + wp->w_vsep_width);
 
     // recompute the window positions
     (void)win_comp_pos();
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
 }
 
@@ -6046,7 +6046,7 @@ void win_drag_status_line(win_T *dragwin, int offset)
   cmdline_row = row;
   p_ch = MAX(Rows - cmdline_row, p_ch_was_zero ? 0 : 1);
   curtab->tp_ch_used = p_ch;
-  redraw_all_later(SOME_VALID);
+  redraw_all_later(UPD_SOME_VALID);
   showmode();
 }
 
@@ -6153,7 +6153,7 @@ void win_drag_vsep_line(win_T *dragwin, int offset)
     }
   }
   (void)win_comp_pos();
-  redraw_all_later(NOT_VALID);
+  redraw_all_later(UPD_NOT_VALID);
 }
 
 #define FRACTION_MULT   16384L
@@ -6291,7 +6291,7 @@ void scroll_to_fraction(win_T *wp, int prev_height)
   }
 
   win_comp_scroll(wp);
-  redraw_later(wp, SOME_VALID);
+  redraw_later(wp, UPD_SOME_VALID);
   wp->w_redr_status = true;
   invalidate_botline_win(wp);
 }
@@ -6332,7 +6332,7 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
     if (!exiting && !made_cmdheight_nonzero && valid_cursor) {
       scroll_to_fraction(wp, prev_height);
     }
-    redraw_later(wp, NOT_VALID);  // SOME_VALID??
+    redraw_later(wp, UPD_NOT_VALID);  // UPD_SOME_VALID??
   }
 
   if (width != wp->w_width_inner) {
@@ -6346,7 +6346,7 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
         curs_columns(wp, true);  // validate w_wrow
       }
     }
-    redraw_later(wp, NOT_VALID);
+    redraw_later(wp, UPD_NOT_VALID);
   }
 
   if (wp->w_buffer->terminal) {
@@ -6766,7 +6766,7 @@ static void last_status_rec(frame_T *fr, bool statusline, bool is_stl_global)
       wp->w_hsep_height = 0;
       comp_col();
     }
-    redraw_all_later(SOME_VALID);
+    redraw_all_later(UPD_SOME_VALID);
   } else {
     // For a column or row frame, recursively call this function for all child frames
     FOR_ALL_FRAMES(fp, fr->fr_child) {
@@ -7066,7 +7066,7 @@ void restore_snapshot(int idx, int close_curwin)
     if (wp != NULL && close_curwin) {
       win_goto(wp);
     }
-    redraw_all_later(NOT_VALID);
+    redraw_all_later(UPD_NOT_VALID);
   }
   clear_snapshot(curtab, idx);
 }
-- 
cgit 


From c0d60526541a3cf977ae623471ae4a347b492af1 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Tue, 23 Aug 2022 09:33:08 +0200
Subject: perf(api): allow to use an arena for return values

---
 src/nvim/api/buffer.c                    |   4 +-
 src/nvim/api/private/dispatch.h          |   9 +-
 src/nvim/api/vim.c                       |  30 +-
 src/nvim/arglist.c                       |   8 +-
 src/nvim/cmdexpand.c                     |   2 +-
 src/nvim/cmdhist.c                       |   8 +-
 src/nvim/digraph.c                       |   8 +-
 src/nvim/eval.c                          |   2 +-
 src/nvim/eval.lua                        |  34 +-
 src/nvim/eval/funcs.c                    | 679 ++++++++++++++++---------------
 src/nvim/eval/funcs.h                    |   5 +-
 src/nvim/eval/typval.c                   |  16 +-
 src/nvim/eval/typval.h                   |   3 -
 src/nvim/eval/vars.c                     |  16 +-
 src/nvim/ex_docmd.c                      |   2 +-
 src/nvim/fold.c                          |  10 +-
 src/nvim/generators/c_grammar.lua        |   1 +
 src/nvim/generators/gen_api_dispatch.lua |  43 +-
 src/nvim/generators/gen_eval.lua         |  15 +-
 src/nvim/getchar.c                       |   6 +-
 src/nvim/insexpand.c                     |   8 +-
 src/nvim/mapping.c                       |   8 +-
 src/nvim/match.c                         |  14 +-
 src/nvim/mbyte.c                         |   4 +-
 src/nvim/memory.c                        |  46 ++-
 src/nvim/memory.h                        |   4 +
 src/nvim/menu.c                          |   2 +-
 src/nvim/msgpack_rpc/channel.c           |  14 +-
 src/nvim/msgpack_rpc/channel_defs.h      |   2 +-
 src/nvim/quickfix.c                      |   8 +-
 src/nvim/search.c                        |   6 +-
 src/nvim/sign.c                          |  18 +-
 src/nvim/testing.c                       |  30 +-
 src/nvim/types.h                         |  12 +-
 src/nvim/ui_client.c                     |   2 +-
 35 files changed, 583 insertions(+), 496 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 5e90e40dd3..43027473a0 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -1021,7 +1021,7 @@ void nvim_buf_del_var(Buffer buffer, String name, Error *err)
 /// @param buffer     Buffer handle, or 0 for current buffer
 /// @param[out] err   Error details, if any
 /// @return Buffer name
-String nvim_buf_get_name(Buffer buffer, Error *err)
+String nvim_buf_get_name(Buffer buffer, Arena *arena, Error *err)
   FUNC_API_SINCE(1)
 {
   String rv = STRING_INIT;
@@ -1031,7 +1031,7 @@ String nvim_buf_get_name(Buffer buffer, Error *err)
     return rv;
   }
 
-  return cstr_to_string((char *)buf->b_ffname);
+  return cstr_as_string((char *)buf->b_ffname);
 }
 
 /// Sets the full file name for a buffer
diff --git a/src/nvim/api/private/dispatch.h b/src/nvim/api/private/dispatch.h
index 4b7c394944..f92b205531 100644
--- a/src/nvim/api/private/dispatch.h
+++ b/src/nvim/api/private/dispatch.h
@@ -5,18 +5,23 @@
 
 typedef Object (*ApiDispatchWrapper)(uint64_t channel_id,
                                      Array args,
+                                     Arena *arena,
                                      Error *error);
 
 /// The rpc_method_handlers table, used in msgpack_rpc_dispatch(), stores
 /// functions of this type.
-typedef struct {
+struct MsgpackRpcRequestHandler {
   const char *name;
   ApiDispatchWrapper fn;
   bool fast;  // Function is safe to be executed immediately while running the
               // uv loop (the loop is run very frequently due to breakcheck).
               // If "fast" is false, the function is deferred, i e the call will
               // be put in the event queue, for safe handling later.
-} MsgpackRpcRequestHandler;
+  bool arena_return;  // return value is allocated in the arena (or statically)
+                      // and should not be freed as such.
+};
+
+extern const MsgpackRpcRequestHandler method_handlers[];
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "api/private/dispatch.h.generated.h"
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index ce91c1b4af..c333db1b37 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -1629,11 +1629,11 @@ Array nvim_list_chans(void)
 /// an error, it is a three-element array with the zero-based index of the call
 /// which resulted in an error, the error type and the error message. If an
 /// error occurred, the values from all preceding calls will still be returned.
-Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
+Array nvim_call_atomic(uint64_t channel_id, Array calls, Arena *arena, Error *err)
   FUNC_API_SINCE(1) FUNC_API_REMOTE_ONLY
 {
-  Array rv = ARRAY_DICT_INIT;
-  Array results = ARRAY_DICT_INIT;
+  Array rv = arena_array(arena, 2);
+  Array results = arena_array(arena, calls.size);
   Error nested_error = ERROR_INIT;
 
   size_t i;  // also used for freeing the variables
@@ -1676,29 +1676,32 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Error *err)
     if (ERROR_SET(&nested_error)) {
       break;
     }
-    Object result = handler.fn(channel_id, args, &nested_error);
+
+    Object result = handler.fn(channel_id, args, arena, &nested_error);
     if (ERROR_SET(&nested_error)) {
       // error handled after loop
       break;
     }
+    if (!handler.arena_return && result.type != kObjectTypeNil) {
+      // TODO: fix to not leak memory as fuck
+    }
 
-    ADD(results, result);
+    ADD_C(results, result);
   }
 
-  ADD(rv, ARRAY_OBJ(results));
+  ADD_C(rv, ARRAY_OBJ(results));
   if (ERROR_SET(&nested_error)) {
-    Array errval = ARRAY_DICT_INIT;
-    ADD(errval, INTEGER_OBJ((Integer)i));
-    ADD(errval, INTEGER_OBJ(nested_error.type));
-    ADD(errval, STRING_OBJ(cstr_to_string(nested_error.msg)));
-    ADD(rv, ARRAY_OBJ(errval));
+    Array errval = arena_array(arena, 3);
+    ADD_C(errval, INTEGER_OBJ((Integer)i));
+    ADD_C(errval, INTEGER_OBJ(nested_error.type));
+    ADD_C(errval, STRING_OBJ(cstr_to_string(nested_error.msg))); // TODO
+    ADD_C(rv, ARRAY_OBJ(errval));
   } else {
-    ADD(rv, NIL);
+    ADD_C(rv, NIL);
   }
   goto theend;
 
 validation_error:
-  api_free_array(results);
 theend:
   api_clear_error(&nested_error);
   return rv;
@@ -1803,6 +1806,7 @@ Dictionary nvim__stats(void)
   PUT(rv, "log_skip", INTEGER_OBJ(g_stats.log_skip));
   PUT(rv, "lua_refcount", INTEGER_OBJ(nlua_get_global_ref_count()));
   PUT(rv, "redraw", INTEGER_OBJ(g_stats.redraw));
+  PUT(rv, "arena_alloc_count", INTEGER_OBJ((Integer)arena_alloc_count));
   return rv;
 }
 
diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 0be83f0c05..4f940f2fa5 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -1074,7 +1074,7 @@ char *arg_all(void)
 }
 
 /// "argc([window id])" function
-void f_argc(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_argc(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type == VAR_UNKNOWN) {
     // use the current window
@@ -1095,13 +1095,13 @@ void f_argc(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "argidx()" function
-void f_argidx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_argidx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = curwin->w_arg_idx;
 }
 
 /// "arglistid()" function
-void f_arglistid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_arglistid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
   win_T *wp = find_tabwin(&argvars[0], &argvars[1]);
@@ -1123,7 +1123,7 @@ static void get_arglist_as_rettv(aentry_T *arglist, int argcount, typval_T *rett
 }
 
 /// "argv(nr)" function
-void f_argv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_argv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   aentry_T *arglist = NULL;
   int argcount = -1;
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index e82e98ba4e..df9f0a4512 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -2751,7 +2751,7 @@ void wildmenu_cleanup(CmdlineInfo *cclp)
 }
 
 /// "getcompletion()" function
-void f_getcompletion(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getcompletion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u *pat;
   expand_T xpc;
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 13f97ba1e8..b078fc6570 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -494,7 +494,7 @@ static int del_history_idx(int histype, int idx)
 }
 
 /// "histadd()" function
-void f_histadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_histadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   HistoryType histype;
 
@@ -517,7 +517,7 @@ void f_histadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "histdel()" function
-void f_histdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_histdel(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int n;
   const char *const str = tv_get_string_chk(&argvars[0]);  // NULL on type error
@@ -540,7 +540,7 @@ void f_histdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "histget()" function
-void f_histget(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_histget(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   HistoryType type;
   int idx;
@@ -562,7 +562,7 @@ void f_histget(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "histnr()" function
-void f_histnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_histnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const histname = tv_get_string_chk(&argvars[0]);
   HistoryType i = histname == NULL
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 0f511bd37c..de2dd09d1c 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1917,7 +1917,7 @@ static bool digraph_set_common(const typval_T *argchars, const typval_T *argdigr
 }
 
 /// "digraph_get()" function
-void f_digraph_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_digraph_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;  // Return empty string for failure
@@ -1938,7 +1938,7 @@ void f_digraph_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "digraph_getlist()" function
-void f_digraph_getlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_digraph_getlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool flag_list_all;
 
@@ -1957,7 +1957,7 @@ void f_digraph_getlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "digraph_set()" function
-void f_digraph_set(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_digraph_set(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_BOOL;
   rettv->vval.v_bool = kBoolVarFalse;
@@ -1970,7 +1970,7 @@ void f_digraph_set(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "digraph_setlist()" function
-void f_digraph_setlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_digraph_setlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_BOOL;
   rettv->vval.v_bool = kBoolVarFalse;
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 04f7347e1c..5a79cbe7d5 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -4968,7 +4968,7 @@ theend:
   return retval;
 }
 
-void common_function(typval_T *argvars, typval_T *rettv, bool is_funcref, FunPtr fptr)
+void common_function(typval_T *argvars, typval_T *rettv, bool is_funcref)
 {
   char *s;
   char *name;
diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index e4e9b34ec6..4863d8013d 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -23,7 +23,7 @@ end
 return {
   funcs={
     abs={args=1, base=1},
-    acos={args=1, base=1, func="float_op_wrapper", data="&acos"},  -- WJMc
+    acos={args=1, base=1, float_func="acos"},  -- WJMc
     add={args=2, base=1},
     ['and']={args=2, base=1},
     api_info={},
@@ -33,7 +33,7 @@ return {
     argidx={},
     arglistid={args={0, 2}},
     argv={args={0, 2}},
-    asin={args=1, base=1, func="float_op_wrapper", data="&asin"},  -- WJMc
+    asin={args=1, base=1, float_func="asin"},  -- WJMc
     assert_beeps={args=1, base=1},
     assert_equal={args={2, 3}, base=2},
     assert_equalfile={args={2, 3}, base=1},
@@ -47,7 +47,7 @@ return {
     assert_notmatch={args={2, 3}, base=2},
     assert_report={args=1, base=1},
     assert_true={args={1, 2}, base=1},
-    atan={args=1, base=1, func="float_op_wrapper", data="&atan"},
+    atan={args=1, base=1, float_func="atan"},
     atan2={args=2, base=1},
     browse={args=4},
     browsedir={args=2},
@@ -67,7 +67,7 @@ return {
     byteidx={args=2, base=1},
     byteidxcomp={args=2, base=1},
     call={args={2, 3}, base=1},
-    ceil={args=1, base=1, func="float_op_wrapper", data="&ceil"},
+    ceil={args=1, base=1, float_func="ceil"},
     changenr={},
     chanclose={args={1, 2}},
     chansend={args=2},
@@ -85,8 +85,8 @@ return {
     complete_info={args={0, 1}, base=1},
     confirm={args={1, 4}, base=1},
     copy={args=1, base=1},
-    cos={args=1, base=1, func="float_op_wrapper", data="&cos"},
-    cosh={args=1, base=1, func="float_op_wrapper", data="&cosh"},
+    cos={args=1, base=1, float_func="cos"},
+    cosh={args=1, base=1, float_func="cosh"},
     count={args={2, 4}, base=1},
     cscope_connection={args={0, 3}},
     ctxget={args={0, 1}},
@@ -117,7 +117,7 @@ return {
     execute={args={1, 2}, base=1},
     exepath={args=1, base=1},
     exists={args=1, base=1},
-    exp={args=1, base=1, func="float_op_wrapper", data="&exp"},
+    exp={args=1, base=1, float_func="exp"},
     expand={args={1, 3}, base=1},
     expandcmd={args=1, base=1},
     extend={args={2, 3}, base=1},
@@ -130,7 +130,7 @@ return {
     findfile={args={1, 3}, base=1},
     flatten={args={1, 2}, base=1},
     float2nr={args=1, base=1},
-    floor={args=1, base=1, func="float_op_wrapper", data="&floor"},
+    floor={args=1, base=1, float_func="floor"},
     fmod={args=2, base=1},
     fnameescape={args=1, base=1},
     fnamemodify={args=2, base=1},
@@ -245,8 +245,8 @@ return {
     lispindent={args=1, base=1},
     list2str={args={1, 2}, base=1},
     localtime={},
-    log={args=1, base=1, func="float_op_wrapper", data="&log"},
-    log10={args=1, base=1, func="float_op_wrapper", data="&log10"},
+    log={args=1, base=1, float_func="log"},
+    log10={args=1, base=1, float_func="log10"},
     luaeval={args={1, 2}, base=1},
     map={args=2, base=1},
     maparg={args={1, 4}, base=1},
@@ -304,7 +304,7 @@ return {
     ['repeat']={args=2, base=1},
     resolve={args=1, base=1},
     reverse={args=1, base=1},
-    round={args=1, base=1, func="float_op_wrapper", data="&round"},
+    round={args=1, base=1, float_func="round"},
     rpcnotify={args=varargs(2)},
     rpcrequest={args=varargs(2)},
     rpcstart={args={1, 2}},
@@ -358,8 +358,8 @@ return {
     sign_unplace={args={1, 2}, base=1},
     sign_unplacelist={args=1, base=1},
     simplify={args=1, base=1},
-    sin={args=1, base=1, func="float_op_wrapper", data="&sin"},
-    sinh={args=1, base=1, func="float_op_wrapper", data="&sinh"},
+    sin={args=1, base=1, float_func="sin"},
+    sinh={args=1, base=1, float_func="sinh"},
     sockconnect={args={2,3}},
     sort={args={1, 3}, base=1},
     soundfold={args=1, base=1},
@@ -367,7 +367,7 @@ return {
     spellbadword={args={0, 1}, base=1},
     spellsuggest={args={1, 3}, base=1},
     split={args={1, 3}, base=1},
-    sqrt={args=1, base=1, func="float_op_wrapper", data="&sqrt"},
+    sqrt={args=1, base=1, float_func="sqrt"},
     srand={args={0, 1}, base=1},
     stdpath={args=1},
     str2float={args=1, base=1},
@@ -402,8 +402,8 @@ return {
     tabpagewinnr={args={1, 2}, base=1},
     tagfiles={},
     taglist={args={1, 2}, base=1},
-    tan={args=1, base=1, func="float_op_wrapper", data="&tan"},
-    tanh={args=1, base=1, func="float_op_wrapper", data="&tanh"},
+    tan={args=1, base=1, float_func="tan"},
+    tanh={args=1, base=1, float_func="tanh"},
     tempname={},
     termopen={args={1, 2}},
     test_garbagecollect_now={},
@@ -417,7 +417,7 @@ return {
     toupper={args=1, base=1},
     tr={args=3, base=1},
     trim={args={1, 3}, base=1},
-    trunc={args=1, base=1, func="float_op_wrapper", data="&trunc"},
+    trunc={args=1, base=1, float_func="trunc"},
     type={args=1, base=1},
     undofile={args=1, base=1},
     undotree={},
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 181b17f747..5db584f6a8 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -114,6 +114,8 @@ static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");
 static char *e_invalwindow = N_("E957: Invalid window number");
 static char *e_reduceempty = N_("E998: Reduce of an empty %s with no initial value");
 
+static ArenaMem eval_reuse_blk = NULL;
+
 /// Dummy va_list for passing to vim_snprintf
 ///
 /// Used because:
@@ -251,26 +253,25 @@ static int non_zero_arg(typval_T *argvars)
 /// Some versions of glibc on i386 have an optimization that makes it harder to
 /// call math functions indirectly from inside an inlined function, causing
 /// compile-time errors. Avoid `inline` in that case. #3072
-static void float_op_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void float_op_wrapper(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   float_T f;
-  float_T (*function)(float_T) = (float_T (*)(float_T)) fptr;
 
   rettv->v_type = VAR_FLOAT;
   if (tv_get_float_chk(argvars, &f)) {
-    rettv->vval.v_float = function(f);
+    rettv->vval.v_float = fptr.float_func(f);
   } else {
     rettv->vval.v_float = 0.0;
   }
 }
 
-static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void api_wrapper(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
   }
 
-  ApiDispatchWrapper fn = (ApiDispatchWrapper)fptr;
+  MsgpackRpcRequestHandler handler = *fptr.api_handler;
 
   Array args = ARRAY_DICT_INIT;
 
@@ -279,7 +280,12 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
   Error err = ERROR_INIT;
-  Object result = fn(VIML_INTERNAL_CALL, args, &err);
+  Arena res_arena = ARENA_EMPTY;
+  if (handler.arena_return) {
+    // TODO(bfredl): also use arena for vim_to_object
+    arena_start(&res_arena, &eval_reuse_blk);
+  }
+  Object result = handler.fn(VIML_INTERNAL_CALL, args, &res_arena, &err);
 
   if (ERROR_SET(&err)) {
     semsg_multiline((const char *)e_api_error, err.msg);
@@ -292,15 +298,19 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 end:
   api_free_array(args);
-  api_free_object(result);
+  if (handler.arena_return) {
+    arena_mem_free(arena_finish(&res_arena), &eval_reuse_blk);
+  } else {
+    api_free_object(result);
+  }
   api_clear_error(&err);
 }
 
 /// "abs(expr)" function
-static void f_abs(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_abs(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type == VAR_FLOAT) {
-    float_op_wrapper(argvars, rettv, (FunPtr)&fabs);
+    float_op_wrapper(argvars, rettv, (EvalFuncData){ .float_func = &fabs });
   } else {
     bool error = false;
 
@@ -316,7 +326,7 @@ static void f_abs(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "add(list, item)" function
-static void f_add(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_add(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = 1;  // Default: failed.
   if (argvars[0].v_type == VAR_LIST) {
@@ -344,14 +354,14 @@ static void f_add(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "and(expr, expr)" function
-static void f_and(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_and(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
                          & tv_get_number_chk(&argvars[1], NULL);
 }
 
 /// "api_info()" function
-static void f_api_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_api_info(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   Dictionary metadata = api_metadata();
   (void)object_to_vim(DICTIONARY_OBJ(metadata), rettv, NULL);
@@ -359,7 +369,7 @@ static void f_api_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "append(lnum, string/list)" function
-static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_append(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const linenr_T lnum = tv_get_lnum(&argvars[0]);
 
@@ -367,7 +377,7 @@ static void f_append(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "appendbufline(buf, lnum, string/list)" function
-static void f_appendbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_appendbufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *const buf = tv_get_buf(&argvars[0], false);
   if (buf == NULL) {
@@ -379,7 +389,7 @@ static void f_appendbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "atan2()" function
-static void f_atan2(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_atan2(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   float_T fx;
   float_T fy;
@@ -393,16 +403,16 @@ static void f_atan2(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "browse(save, title, initdir, default)" function
-static void f_browse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_browse(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_string = NULL;
   rettv->v_type = VAR_STRING;
 }
 
 /// "browsedir(title, initdir)" function
-static void f_browsedir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_browsedir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  f_browse(argvars, rettv, NULL);
+  f_browse(argvars, rettv, fptr);
 }
 
 /// Find a buffer by number or exact name.
@@ -431,7 +441,7 @@ static buf_T *find_buffer(typval_T *avar)
 }
 
 /// "bufadd(expr)" function
-static void f_bufadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u *name = (char_u *)tv_get_string(&argvars[0]);
 
@@ -439,13 +449,13 @@ static void f_bufadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "bufexists(expr)" function
-static void f_bufexists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufexists(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = (find_buffer(&argvars[0]) != NULL);
 }
 
 /// "buflisted(expr)" function
-static void f_buflisted(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_buflisted(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *buf;
 
@@ -454,7 +464,7 @@ static void f_buflisted(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "bufload(expr)" function
-static void f_bufload(typval_T *argvars, typval_T *unused, FunPtr fptr)
+static void f_bufload(typval_T *argvars, typval_T *unused, EvalFuncData fptr)
 {
   buf_T *buf = get_buf_arg(&argvars[0]);
 
@@ -469,7 +479,7 @@ static void f_bufload(typval_T *argvars, typval_T *unused, FunPtr fptr)
 }
 
 /// "bufloaded(expr)" function
-static void f_bufloaded(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufloaded(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *buf;
 
@@ -478,7 +488,7 @@ static void f_bufloaded(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "bufname(expr)" function
-static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const buf_T *buf;
   rettv->v_type = VAR_STRING;
@@ -494,7 +504,7 @@ static void f_bufname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "bufnr(expr)" function
-static void f_bufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const buf_T *buf;
   bool error = false;
@@ -554,13 +564,13 @@ static void buf_win_common(typval_T *argvars, typval_T *rettv, bool get_nr)
 }
 
 /// "bufwinid(nr)" function
-static void f_bufwinid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufwinid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_win_common(argvars, rettv, false);
 }
 
 /// "bufwinnr(nr)" function
-static void f_bufwinnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_bufwinnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_win_common(argvars, rettv, true);
 }
@@ -630,7 +640,7 @@ buf_T *get_buf_arg(typval_T *arg)
 }
 
 /// "byte2line(byte)" function
-static void f_byte2line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_byte2line(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   long boff = tv_get_number(&argvars[0]) - 1;
   if (boff < 0) {
@@ -665,19 +675,19 @@ static void byteidx(typval_T *argvars, typval_T *rettv, int comp)
 }
 
 /// "byteidx()" function
-static void f_byteidx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_byteidx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   byteidx(argvars, rettv, false);
 }
 
 /// "byteidxcomp()" function
-static void f_byteidxcomp(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_byteidxcomp(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   byteidx(argvars, rettv, true);
 }
 
 /// "call(func, arglist [, dict])" function
-static void f_call(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_call(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[1].v_type != VAR_LIST) {
     emsg(_(e_listreq));
@@ -726,13 +736,13 @@ static void f_call(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "changenr()" function
-static void f_changenr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_changenr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = curbuf->b_u_seq_cur;
 }
 
 /// "chanclose(id[, stream])" function
-static void f_chanclose(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_chanclose(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -771,7 +781,7 @@ static void f_chanclose(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "chansend(id, data)" function
-static void f_chansend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_chansend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -812,7 +822,7 @@ static void f_chansend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "char2nr(string)" function
-static void f_char2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_char2nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[1].v_type != VAR_UNKNOWN) {
     if (!tv_check_num(&argvars[1])) {
@@ -861,13 +871,13 @@ static void get_col(typval_T *argvars, typval_T *rettv, bool charcol)
 }
 
 /// "charcol()" function
-static void f_charcol(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_charcol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_col(argvars, rettv, true);
 }
 
 /// "charidx()" function
-static void f_charidx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_charidx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -914,7 +924,7 @@ static void f_charidx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "chdir(dir)" function
-static void f_chdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_chdir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -949,7 +959,7 @@ static void f_chdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "cindent(lnum)" function
-static void f_cindent(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_cindent(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   pos_T pos = curwin->w_cursor;
   linenr_T lnum = tv_get_lnum(argvars);
@@ -977,13 +987,13 @@ win_T *get_optional_window(typval_T *argvars, int idx)
 }
 
 /// "col(string)" function
-static void f_col(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_col(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_col(argvars, rettv, false);
 }
 
 /// "confirm(message, buttons[, default [, type]])" function
-static void f_confirm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_confirm(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[NUMBUFLEN];
   char buf2[NUMBUFLEN];
@@ -1036,13 +1046,13 @@ static void f_confirm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "copy()" function
-static void f_copy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_copy(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   var_item_copy(NULL, &argvars[0], rettv, false, 0);
 }
 
 /// "count()" function
-static void f_count(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_count(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   long n = 0;
   int ic = 0;
@@ -1131,7 +1141,7 @@ static void f_count(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
 ///
 /// Checks the existence of a cscope connection.
-static void f_cscope_connection(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_cscope_connection(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int num = 0;
   const char *dbpath = NULL;
@@ -1152,7 +1162,7 @@ static void f_cscope_connection(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "ctxget([{index}])" function
-static void f_ctxget(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_ctxget(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   size_t index = 0;
   if (argvars[0].v_type == VAR_NUMBER) {
@@ -1176,7 +1186,7 @@ static void f_ctxget(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "ctxpop()" function
-static void f_ctxpop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_ctxpop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (!ctx_restore(NULL, kCtxAll)) {
     emsg(_("Context stack is empty"));
@@ -1184,7 +1194,7 @@ static void f_ctxpop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "ctxpush([{types}])" function
-static void f_ctxpush(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_ctxpush(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int types = kCtxAll;
   if (argvars[0].v_type == VAR_LIST) {
@@ -1215,7 +1225,7 @@ static void f_ctxpush(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "ctxset({context}[, {index}])" function
-static void f_ctxset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_ctxset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_DICT) {
     semsg(_(e_invarg2), "expected dictionary as first argument");
@@ -1255,7 +1265,7 @@ static void f_ctxset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "ctxsize()" function
-static void f_ctxsize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_ctxsize(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = (varnumber_T)ctx_size();
@@ -1327,13 +1337,13 @@ static void set_cursorpos(typval_T *argvars, typval_T *rettv, bool charcol)
 /// Moves the cursor to the specified line and column.
 ///
 /// @return  0 when the position could be set, -1 otherwise.
-static void f_cursor(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_cursor(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   set_cursorpos(argvars, rettv, false);
 }
 
 /// "debugbreak()" function
-static void f_debugbreak(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_debugbreak(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = FAIL;
   int pid = (int)tv_get_number(&argvars[0]);
@@ -1355,7 +1365,7 @@ static void f_debugbreak(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "deepcopy()" function
-static void f_deepcopy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_deepcopy(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int noref = 0;
 
@@ -1372,7 +1382,7 @@ static void f_deepcopy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "delete()" function
-static void f_delete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_delete(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
   if (check_secure()) {
@@ -1408,7 +1418,7 @@ static void f_delete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// dictwatcheradd(dict, key, funcref) function
-static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
@@ -1446,7 +1456,7 @@ static void f_dictwatcheradd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// dictwatcherdel(dict, key, funcref) function
-static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
@@ -1481,7 +1491,7 @@ static void f_dictwatcherdel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "deletebufline()" function
-static void f_deletebufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_deletebufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *const buf = tv_get_buf(&argvars[0], false);
   if (buf == NULL) {
@@ -1557,19 +1567,19 @@ static void f_deletebufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "did_filetype()" function
-static void f_did_filetype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_did_filetype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = did_filetype;
 }
 
 /// "diff_filler()" function
-static void f_diff_filler(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_diff_filler(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = MAX(0, diff_check(curwin, tv_get_lnum(argvars)));
 }
 
 /// "diff_hlID()" function
-static void f_diff_hlID(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_diff_hlID(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum = tv_get_lnum(argvars);
   static linenr_T prev_lnum = 0;
@@ -1619,7 +1629,7 @@ static void f_diff_hlID(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "empty({expr})" function
-static void f_empty(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_empty(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool n = true;
 
@@ -1669,7 +1679,7 @@ static void f_empty(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "environ()" function
-static void f_environ(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_environ(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
 
@@ -1714,7 +1724,7 @@ static void f_environ(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "escape({string}, {chars})" function
-static void f_escape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_escape(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[NUMBUFLEN];
 
@@ -1725,7 +1735,7 @@ static void f_escape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getenv()" function
-static void f_getenv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getenv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u *p = (char_u *)vim_getenv(tv_get_string(&argvars[0]));
 
@@ -1739,7 +1749,7 @@ static void f_getenv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "eval()" function
-static void f_eval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_eval(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *s = tv_get_string_chk(&argvars[0]);
   if (s != NULL) {
@@ -1760,13 +1770,13 @@ static void f_eval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "eventhandler()" function
-static void f_eventhandler(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_eventhandler(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = vgetc_busy;
 }
 
 /// "executable()" function
-static void f_executable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_executable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (tv_check_for_string(&argvars[0]) == FAIL) {
     return;
@@ -1795,7 +1805,7 @@ static char *get_list_line(int c, void *cookie, int indent, bool do_concat)
   return s == NULL ? NULL : xstrdup(s);
 }
 
-static void execute_common(typval_T *argvars, typval_T *rettv, FunPtr fptr, int arg_off)
+static void execute_common(typval_T *argvars, typval_T *rettv, int arg_off)
 {
   const int save_msg_silent = msg_silent;
   const int save_emsg_silent = emsg_silent;
@@ -1874,13 +1884,13 @@ static void execute_common(typval_T *argvars, typval_T *rettv, FunPtr fptr, int
 }
 
 /// "execute(command)" function
-static void f_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_execute(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  execute_common(argvars, rettv, fptr, 0);
+  execute_common(argvars, rettv, 0);
 }
 
 /// "win_execute(win_id, command)" function
-static void f_win_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_execute(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // Return an empty string if something fails.
   rettv->v_type = VAR_STRING;
@@ -1890,12 +1900,12 @@ static void f_win_execute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   tabpage_T *tp;
   win_T *wp = win_id2wp_tp(id, &tp);
   if (wp != NULL && tp != NULL) {
-    WIN_EXECUTE(wp, tp, execute_common(argvars, rettv, fptr, 1));
+    WIN_EXECUTE(wp, tp, execute_common(argvars, rettv, 1));
   }
 }
 
 /// "exepath()" function
-static void f_exepath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_exepath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (tv_check_for_nonempty_string(&argvars[0]) == FAIL) {
     return;
@@ -1916,7 +1926,7 @@ static void f_exepath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "exists()" function
-static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_exists(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int n = false;
 
@@ -1956,7 +1966,7 @@ static void f_exists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "expand()" function
-static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_expand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char *errormsg;
   int options = WILD_SILENT|WILD_USE_NL|WILD_LIST_NOTFOUND;
@@ -2027,7 +2037,7 @@ static void f_expand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "menu_get(path [, modes])" function
-static void f_menu_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_menu_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenMayKnow);
   int modes = MENU_ALL_MODES;
@@ -2040,7 +2050,7 @@ static void f_menu_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 /// "expandcmd()" function
 /// Expand all the special characters in a command string.
-static void f_expandcmd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_expandcmd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char *errormsg = NULL;
 
@@ -2064,7 +2074,7 @@ static void f_expandcmd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "flatten(list[, {maxdepth}])" function
-static void f_flatten(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_flatten(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool error = false;
 
@@ -2099,7 +2109,7 @@ static void f_flatten(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 /// "extend(list, list [, idx])" function
 /// "extend(dict, dict [, action])" function
-static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_extend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const arg_errmsg = N_("extend() argument");
 
@@ -2175,7 +2185,7 @@ static void f_extend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "feedkeys()" function
-static void f_feedkeys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_feedkeys(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // This is not allowed in the sandbox.  If the commands would still be
   // executed in the sandbox it would be OK, but it probably happens later,
@@ -2196,7 +2206,7 @@ static void f_feedkeys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "filereadable()" function
-static void f_filereadable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_filereadable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const p = tv_get_string(&argvars[0]);
   rettv->vval.v_number =
@@ -2206,7 +2216,7 @@ static void f_filereadable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// @return  0 for not writable
 ///          1 for writable file
 ///          2 for a dir which we have rights to write into.
-static void f_filewritable(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_filewritable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *filename = tv_get_string(&argvars[0]);
   rettv->vval.v_number = os_file_is_writable(filename);
@@ -2271,25 +2281,25 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 }
 
 /// "filter()" function
-static void f_filter(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_filter(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   filter_map(argvars, rettv, false);
 }
 
 /// "finddir({fname}[, {path}[, {count}]])" function
-static void f_finddir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_finddir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   findfilendir(argvars, rettv, FINDFILE_DIR);
 }
 
 /// "findfile({fname}[, {path}[, {count}]])" function
-static void f_findfile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_findfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   findfilendir(argvars, rettv, FINDFILE_FILE);
 }
 
 /// "float2nr({float})" function
-static void f_float2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_float2nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   float_T f;
 
@@ -2305,7 +2315,7 @@ static void f_float2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "fmod()" function
-static void f_fmod(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_fmod(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   float_T fx;
   float_T fy;
@@ -2319,14 +2329,14 @@ static void f_fmod(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "fnameescape({string})" function
-static void f_fnameescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_fnameescape(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_string = vim_strsave_fnameescape(tv_get_string(&argvars[0]), VSE_NONE);
   rettv->v_type = VAR_STRING;
 }
 
 /// "fnamemodify({fname}, {mods})" function
-static void f_fnamemodify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_fnamemodify(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u *fbuf = NULL;
   size_t len = 0;
@@ -2354,21 +2364,21 @@ static void f_fnamemodify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "foreground()" function
-static void f_foreground(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_foreground(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {}
 
-static void f_funcref(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_funcref(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  common_function(argvars, rettv, true, fptr);
+  common_function(argvars, rettv, true);
 }
 
-static void f_function(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_function(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  common_function(argvars, rettv, false, fptr);
+  common_function(argvars, rettv, false);
 }
 
 /// "garbagecollect()" function
-static void f_garbagecollect(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_garbagecollect(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // This is postponed until we are back at the toplevel, because we may be
   // using Lists and Dicts internally.  E.g.: ":echo [garbagecollect()]".
@@ -2380,7 +2390,7 @@ static void f_garbagecollect(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "get()" function
-static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   typval_T *tv = NULL;
   bool what_is_dict = false;
@@ -2477,7 +2487,7 @@ static void f_get(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getbufinfo()" function
-static void f_getbufinfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getbufinfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *argbuf = NULL;
   bool filtered = false;
@@ -2576,7 +2586,7 @@ static void get_buffer_lines(buf_T *buf, linenr_T start, linenr_T end, int retli
 }
 
 /// "getbufline()" function
-static void f_getbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getbufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *const buf = tv_get_buf_from_arg(&argvars[0]);
 
@@ -2589,7 +2599,7 @@ static void f_getbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getchangelist()" function
-static void f_getchangelist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getchangelist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, 2);
 
@@ -2694,13 +2704,13 @@ static void getpos_both(typval_T *argvars, typval_T *rettv, bool getcurpos, bool
 }
 
 /// "getcharpos()" function
-static void f_getcharpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcharpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getpos_both(argvars, rettv, false, true);
 }
 
 /// "getcharsearch()" function
-static void f_getcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
 
@@ -2712,33 +2722,33 @@ static void f_getcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getcmdcompltype()" function
-static void f_getcmdcompltype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdcompltype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = (char *)get_cmdline_completion();
 }
 
 /// "getcmdline()" function
-static void f_getcmdline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = (char *)get_cmdline_str();
 }
 
 /// "getcmdpos()" function
-static void f_getcmdpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = get_cmdline_pos() + 1;
 }
 
 /// "getcmdscreenpos()" function
-static void f_getcmdscreenpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdscreenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = get_cmdline_screen_pos() + 1;
 }
 
 /// "getcmdtype()" function
-static void f_getcmdtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdtype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = xmallocz(1);
@@ -2746,7 +2756,7 @@ static void f_getcmdtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getcmdwintype()" function
-static void f_getcmdwintype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcmdwintype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -2763,7 +2773,7 @@ static void f_getcmdwintype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// @pre  An argument may not be -1 if preceding arguments are not all -1.
 ///
 /// @post  The return value will be a string.
-static void f_getcwd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcwd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // Possible scope of working directory to return.
   CdScope scope = kCdScopeInvalid;
@@ -2876,14 +2886,14 @@ static void f_getcwd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getfontname()" function
-static void f_getfontname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getfontname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
 }
 
 /// "getfperm({fname})" function
-static void f_getfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getfperm(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char *perm = NULL;
   char_u flags[] = "rwx";
@@ -2903,7 +2913,7 @@ static void f_getfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getfsize({fname})" function
-static void f_getfsize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getfsize(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *fname = tv_get_string(&argvars[0]);
 
@@ -2928,7 +2938,7 @@ static void f_getfsize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getftime({fname})" function
-static void f_getftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *fname = tv_get_string(&argvars[0]);
 
@@ -2941,7 +2951,7 @@ static void f_getftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getftype({fname})" function
-static void f_getftype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getftype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u *type = NULL;
   char *t;
@@ -2975,7 +2985,7 @@ static void f_getftype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getjumplist()" function
-static void f_getjumplist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getjumplist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenMayKnow);
   win_T *const wp = find_tabwin(&argvars[0], &argvars[1]);
@@ -3006,7 +3016,7 @@ static void f_getjumplist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getline(lnum, [end])" function
-static void f_getline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T end;
   bool retlist;
@@ -3024,7 +3034,7 @@ static void f_getline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getmarklist()" function
-static void f_getmarklist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getmarklist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenMayKnow);
 
@@ -3042,7 +3052,7 @@ static void f_getmarklist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getmousepos()" function
-static void f_getmousepos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getmousepos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int row = mouse_row;
   int col = mouse_col;
@@ -3083,24 +3093,24 @@ static void f_getmousepos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getpid()" function
-static void f_getpid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getpid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = os_get_pid();
 }
 
 /// "getcurpos(string)" function
-static void f_getcurpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcurpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getpos_both(argvars, rettv, true, false);
 }
 
-static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getcursorcharpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getpos_both(argvars, rettv, true, true);
 }
 
 /// "getpos(string)" function
-static void f_getpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getpos_both(argvars, rettv, false, false);
 }
@@ -3126,7 +3136,7 @@ static int getreg_get_regname(typval_T *argvars)
 }
 
 /// "getreg()" function
-static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getreg(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int arg2 = false;
   bool return_list = false;
@@ -3162,7 +3172,7 @@ static void f_getreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getregtype()" function
-static void f_getregtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getregtype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // on error return an empty string
   rettv->v_type = VAR_STRING;
@@ -3182,7 +3192,7 @@ static void f_getregtype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "gettabinfo()" function
-static void f_gettabinfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_gettabinfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tabpage_T *tparg = NULL;
 
@@ -3214,7 +3224,7 @@ static void f_gettabinfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "gettagstack()" function
-static void f_gettagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_gettagstack(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = curwin;                  // default is current window
 
@@ -3231,7 +3241,7 @@ static void f_gettagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getwininfo()" function
-static void f_getwininfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getwininfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wparg = NULL;
 
@@ -3276,7 +3286,7 @@ static void dummy_timer_close_cb(TimeWatcher *tw, void *data)
 }
 
 /// "wait(timeout, condition[, interval])" function
-static void f_wait(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_wait(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = -1;
@@ -3330,7 +3340,7 @@ static void f_wait(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "win_screenpos()" function
-static void f_win_screenpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, 2);
   const win_T *const wp = find_win_by_nr_or_id(&argvars[0]);
@@ -3377,7 +3387,7 @@ static void win_move_into_split(win_T *wp, win_T *targetwin, int size, int flags
 }
 
 /// "win_splitmove()" function
-static void f_win_splitmove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_splitmove(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = find_win_by_nr_or_id(&argvars[0]);
   win_T *targetwin = find_win_by_nr_or_id(&argvars[1]);
@@ -3415,7 +3425,7 @@ static void f_win_splitmove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getwinpos({timeout})" function
-static void f_getwinpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getwinpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, 2);
   tv_list_append_number(rettv->vval.v_list, -1);
@@ -3423,19 +3433,19 @@ static void f_getwinpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getwinposx()" function
-static void f_getwinposx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getwinposx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 }
 
 /// "getwinposy()" function
-static void f_getwinposy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getwinposy(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 }
 
 /// "glob()" function
-static void f_glob(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_glob(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int options = WILD_SILENT|WILD_USE_NL;
   expand_T xpc;
@@ -3484,7 +3494,7 @@ static void f_glob(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "globpath()" function
-static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_globpath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int flags = WILD_IGNORE_COMPLETESLASH;  // Flags for globpath.
   bool error = false;
@@ -3534,7 +3544,7 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "glob2regpat()" function
-static void f_glob2regpat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_glob2regpat(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const pat = tv_get_string_chk(&argvars[0]);  // NULL on type error
 
@@ -3543,7 +3553,7 @@ static void f_glob2regpat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "has()" function
-static void f_has(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_has(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   static const char *const has_list[] = {
 #if defined(BSD) && !defined(__APPLE__)
@@ -3765,7 +3775,7 @@ static bool has_wsl(void)
 /// @pre  An argument may not be -1 if preceding arguments are not all -1.
 ///
 /// @post  The return value will be either the number `1` or `0`.
-static void f_haslocaldir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_haslocaldir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // Possible scope of working directory to return.
   CdScope scope = kCdScopeInvalid;
@@ -3855,19 +3865,19 @@ static void f_haslocaldir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "highlightID(name)" function
-static void f_hlID(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_hlID(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = syn_name2id(tv_get_string(&argvars[0]));
 }
 
 /// "highlight_exists()" function
-static void f_hlexists(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_hlexists(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = highlight_exists(tv_get_string(&argvars[0]));
 }
 
 /// "hostname()" function
-static void f_hostname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_hostname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char hostname[256];
 
@@ -3877,7 +3887,7 @@ static void f_hostname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// iconv() function
-static void f_iconv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_iconv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   vimconv_T vimconv;
 
@@ -3905,7 +3915,7 @@ static void f_iconv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "indent()" function
-static void f_indent(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_indent(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const linenr_T lnum = tv_get_lnum(argvars);
   if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) {
@@ -3916,7 +3926,7 @@ static void f_indent(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "index()" function
-static void f_index(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_index(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   long idx = 0;
   bool ic = false;
@@ -3991,19 +4001,19 @@ static bool inputsecret_flag = false;
 
 /// "input()" function
 ///     Also handles inputsecret() when inputsecret is set.
-static void f_input(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_input(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_user_input(argvars, rettv, false, inputsecret_flag);
 }
 
 /// "inputdialog()" function
-static void f_inputdialog(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_inputdialog(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_user_input(argvars, rettv, true, inputsecret_flag);
 }
 
 /// "inputlist()" function
-static void f_inputlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_inputlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_LIST) {
     semsg(_(e_listarg), "inputlist()");
@@ -4034,7 +4044,7 @@ static void f_inputlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 static garray_T ga_userinput = { 0, 0, sizeof(tasave_T), 4, NULL };
 
 /// "inputrestore()" function
-static void f_inputrestore(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_inputrestore(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (!GA_EMPTY(&ga_userinput)) {
     ga_userinput.ga_len--;
@@ -4048,7 +4058,7 @@ static void f_inputrestore(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "inputsave()" function
-static void f_inputsave(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_inputsave(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // Add an entry to the stack of typeahead storage.
   tasave_T *p = GA_APPEND_VIA_PTR(tasave_T, &ga_userinput);
@@ -4056,17 +4066,17 @@ static void f_inputsave(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "inputsecret()" function
-static void f_inputsecret(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_inputsecret(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   cmdline_star++;
   inputsecret_flag = true;
-  f_input(argvars, rettv, NULL);
+  f_input(argvars, rettv, fptr);
   cmdline_star--;
   inputsecret_flag = false;
 }
 
 /// "insert()" function
-static void f_insert(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   list_T *l;
   bool error = false;
@@ -4139,25 +4149,25 @@ static void f_insert(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
 /// "interrupt()" function
 static void f_interrupt(typval_T *argvars FUNC_ATTR_UNUSED, typval_T *rettv FUNC_ATTR_UNUSED,
-                        FunPtr fptr FUNC_ATTR_UNUSED)
+                        EvalFuncData fptr FUNC_ATTR_UNUSED)
 {
   got_int = true;
 }
 
 /// "invert(expr)" function
-static void f_invert(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_invert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = ~tv_get_number_chk(&argvars[0], NULL);
 }
 
 /// "isdirectory()" function
-static void f_isdirectory(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_isdirectory(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = os_isdir((const char_u *)tv_get_string(&argvars[0]));
 }
 
 /// "islocked()" function
-static void f_islocked(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_islocked(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   lval_T lv;
 
@@ -4199,7 +4209,7 @@ static void f_islocked(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "isinf()" function
-static void f_isinf(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_isinf(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type == VAR_FLOAT
       && xisinf(argvars[0].vval.v_float)) {
@@ -4208,14 +4218,14 @@ static void f_isinf(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "isnan()" function
-static void f_isnan(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_isnan(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = argvars[0].v_type == VAR_FLOAT
                          && xisnan(argvars[0].vval.v_float);
 }
 
 /// "id()" function
-static void f_id(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_id(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   const int len = vim_vsnprintf_typval(NULL, 0, "%p", dummy_ap, argvars);
@@ -4225,7 +4235,7 @@ static void f_id(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "jobpid(id)" function
-static void f_jobpid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_jobpid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -4249,7 +4259,7 @@ static void f_jobpid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "jobresize(job, width, height)" function
-static void f_jobresize(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_jobresize(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -4316,7 +4326,7 @@ static dict_T *create_environment(const dictitem_T *job_env, const bool clear_en
 
   if (!clear_env) {
     typval_T temp_env = TV_INITIAL_VALUE;
-    f_environ(NULL, &temp_env, NULL);
+    f_environ(NULL, &temp_env, (EvalFuncData){ .nullptr = NULL });
     tv_dict_extend(env, temp_env.vval.v_dict, "force");
     tv_dict_free(temp_env.vval.v_dict);
 
@@ -4405,7 +4415,7 @@ static dict_T *create_environment(const dictitem_T *job_env, const bool clear_en
 }
 
 /// "jobstart()" function
-static void f_jobstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -4525,7 +4535,7 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "jobstop()" function
-static void f_jobstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_jobstop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -4558,7 +4568,7 @@ static void f_jobstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "jobwait(ids[, timeout])" function
-static void f_jobwait(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_jobwait(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -4657,7 +4667,7 @@ static void f_jobwait(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// json_decode() function
-static void f_json_decode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_json_decode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char numbuf[NUMBUFLEN];
   const char *s = NULL;
@@ -4691,14 +4701,14 @@ static void f_json_decode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// json_encode() function
-static void f_json_encode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_json_encode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = encode_tv2json(&argvars[0], NULL);
 }
 
 /// "last_buffer_nr()" function.
-static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int n = 0;
 
@@ -4712,7 +4722,7 @@ static void f_last_buffer_nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "len()" function
-static void f_len(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_len(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   switch (argvars[0].v_type) {
   case VAR_STRING:
@@ -4783,19 +4793,19 @@ static void libcall_common(typval_T *argvars, typval_T *rettv, int out_type)
 }
 
 /// "libcall()" function
-static void f_libcall(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_libcall(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   libcall_common(argvars, rettv, VAR_STRING);
 }
 
 /// "libcallnr()" function
-static void f_libcallnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_libcallnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   libcall_common(argvars, rettv, VAR_NUMBER);
 }
 
 /// "line(string, [winid])" function
-static void f_line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_line(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum = 0;
   pos_T *fp = NULL;
@@ -4826,7 +4836,7 @@ static void f_line(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "line2byte(lnum)" function
-static void f_line2byte(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_line2byte(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const linenr_T lnum = tv_get_lnum(argvars);
   if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count + 1) {
@@ -4840,7 +4850,7 @@ static void f_line2byte(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "lispindent(lnum)" function
-static void f_lispindent(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_lispindent(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const pos_T pos = curwin->w_cursor;
   const linenr_T lnum = tv_get_lnum(argvars);
@@ -4854,13 +4864,13 @@ static void f_lispindent(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "localtime()" function
-static void f_localtime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_localtime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = (varnumber_T)time(NULL);
 }
 
 /// luaeval() function implementation
-static void f_luaeval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_luaeval(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   const char *const str = tv_get_string_chk(&argvars[0]);
@@ -4872,7 +4882,7 @@ static void f_luaeval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "map()" function
-static void f_map(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_map(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   filter_map(argvars, rettv, true);
 }
@@ -5090,31 +5100,31 @@ theend:
 }
 
 /// "match()" function
-static void f_match(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_match(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   find_some_match(argvars, rettv, kSomeMatch);
 }
 
 /// "matchend()" function
-static void f_matchend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_matchend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   find_some_match(argvars, rettv, kSomeMatchEnd);
 }
 
 /// "matchlist()" function
-static void f_matchlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_matchlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   find_some_match(argvars, rettv, kSomeMatchList);
 }
 
 /// "matchstr()" function
-static void f_matchstr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_matchstr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   find_some_match(argvars, rettv, kSomeMatchStr);
 }
 
 /// "matchstrpos()" function
-static void f_matchstrpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_matchstrpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   find_some_match(argvars, rettv, kSomeMatchStrPos);
 }
@@ -5169,19 +5179,19 @@ static void max_min(const typval_T *const tv, typval_T *const rettv, const bool
 }
 
 /// "max()" function
-static void f_max(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_max(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   max_min(argvars, rettv, true);
 }
 
 /// "min()" function
-static void f_min(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_min(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   max_min(argvars, rettv, false);
 }
 
 /// "mkdir()" function
-static void f_mkdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_mkdir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int prot = 0755;  // -V536
 
@@ -5226,7 +5236,7 @@ static void f_mkdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "mode()" function
-static void f_mode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_mode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[MODE_MAX_LENGTH];
 
@@ -5243,7 +5253,7 @@ static void f_mode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "msgpackdump()" function
-static void f_msgpackdump(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_msgpackdump(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   if (argvars[0].v_type != VAR_LIST) {
@@ -5382,7 +5392,7 @@ static void msgpackparse_unpack_blob(const blob_T *const blob, list_T *const ret
 }
 
 /// "msgpackparse" function
-static void f_msgpackparse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_msgpackparse(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   if (argvars[0].v_type != VAR_LIST && argvars[0].v_type != VAR_BLOB) {
@@ -5398,7 +5408,7 @@ static void f_msgpackparse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "nextnonblank()" function
-static void f_nextnonblank(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_nextnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum;
 
@@ -5415,7 +5425,7 @@ static void f_nextnonblank(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "nr2char()" function
-static void f_nr2char(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_nr2char(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[1].v_type != VAR_UNKNOWN) {
     if (!tv_check_num(&argvars[1])) {
@@ -5446,14 +5456,14 @@ static void f_nr2char(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "or(expr, expr)" function
-static void f_or(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_or(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
                          | tv_get_number_chk(&argvars[1], NULL);
 }
 
 /// "pathshorten()" function
-static void f_pathshorten(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_pathshorten(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int trim_len = 1;
 
@@ -5475,7 +5485,7 @@ static void f_pathshorten(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "pow()" function
-static void f_pow(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_pow(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   float_T fx;
   float_T fy;
@@ -5489,7 +5499,7 @@ static void f_pow(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "prevnonblank()" function
-static void f_prevnonblank(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_prevnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum = tv_get_lnum(argvars);
   if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) {
@@ -5503,7 +5513,7 @@ static void f_prevnonblank(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "printf()" function
-static void f_printf(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_printf(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -5525,7 +5535,7 @@ static void f_printf(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "prompt_setcallback({buffer}, {callback})" function
-static void f_prompt_setcallback(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_prompt_setcallback(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   Callback prompt_callback = { .type = kCallbackNone };
 
@@ -5548,7 +5558,7 @@ static void f_prompt_setcallback(typval_T *argvars, typval_T *rettv, FunPtr fptr
 }
 
 /// "prompt_setinterrupt({buffer}, {callback})" function
-static void f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   Callback interrupt_callback = { .type = kCallbackNone };
 
@@ -5571,7 +5581,7 @@ static void f_prompt_setinterrupt(typval_T *argvars, typval_T *rettv, FunPtr fpt
 }
 
 /// "prompt_getprompt({buffer})" function
-static void f_prompt_getprompt(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_prompt_getprompt(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   // return an empty string by default, e.g. it's not a prompt buffer
@@ -5591,7 +5601,7 @@ static void f_prompt_getprompt(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "prompt_setprompt({buffer}, {text})" function
-static void f_prompt_setprompt(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_prompt_setprompt(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
@@ -5607,14 +5617,14 @@ static void f_prompt_setprompt(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "pum_getpos()" function
-static void f_pum_getpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_pum_getpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   pum_set_event_info(rettv->vval.v_dict);
 }
 
 /// "pumvisible()" function
-static void f_pumvisible(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_pumvisible(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (pum_visible()) {
     rettv->vval.v_number = 1;
@@ -5622,7 +5632,7 @@ static void f_pumvisible(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "py3eval()" and "pyxeval()" functions (always python3)
-static void f_py3eval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_py3eval(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   script_host_eval("python3", argvars, rettv);
 }
@@ -5694,7 +5704,7 @@ static inline uint32_t shuffle_xoshiro128starstar(uint32_t *const x, uint32_t *c
 }
 
 /// "rand()" function
-static void f_rand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   uint32_t result;
 
@@ -5764,7 +5774,7 @@ theend:
 }
 
 /// "srand()" function
-static void f_srand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_srand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   uint32_t x = 0;
 
@@ -5786,19 +5796,19 @@ static void f_srand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "perleval()" function
-static void f_perleval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_perleval(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   script_host_eval("perl", argvars, rettv);
 }
 
 /// "rubyeval()" function
-static void f_rubyeval(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rubyeval(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   script_host_eval("ruby", argvars, rettv);
 }
 
 /// "range()" function
-static void f_range(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_range(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   varnumber_T end;
   varnumber_T stride = 1;
@@ -5868,7 +5878,7 @@ theend:
 }
 
 /// "readdir()" function
-static void f_readdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_readdir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenUnknown);
 
@@ -5886,7 +5896,7 @@ static void f_readdir(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "readfile()" function
-static void f_readfile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool binary = false;
   bool blob = false;
@@ -6069,7 +6079,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getreginfo()" function
-static void f_getreginfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_getreginfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int regname = getreg_get_regname(argvars);
   if (regname == 0) {
@@ -6119,18 +6129,18 @@ static void f_getreginfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "reg_executing()" function
-static void f_reg_executing(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reg_executing(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   return_register(reg_executing, rettv);
 }
 
 /// "reg_recording()" function
-static void f_reg_recording(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reg_recording(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   return_register(reg_recording, rettv);
 }
 
-static void f_reg_recorded(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reg_recorded(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   return_register(reg_recorded, rettv);
 }
@@ -6172,7 +6182,7 @@ static int list2proftime(typval_T *arg, proftime_T *tm) FUNC_ATTR_NONNULL_ALL
 ///             one argument it returns the time passed since the argument.
 ///             With two arguments it returns the time passed between
 ///             the two arguments.
-static void f_reltime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reltime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   proftime_T res;
   proftime_T start;
@@ -6214,7 +6224,7 @@ static void f_reltime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "reltimestr()" function
-static void f_reltimestr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reltimestr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   proftime_T tm;
@@ -6227,7 +6237,7 @@ static void f_reltimestr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "remove()" function
-static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_remove(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const arg_errmsg = N_("remove() argument");
 
@@ -6243,7 +6253,7 @@ static void f_remove(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "rename({from}, {to})" function
-static void f_rename(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rename(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     rettv->vval.v_number = -1;
@@ -6255,7 +6265,7 @@ static void f_rename(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "repeat()" function
-static void f_repeat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_repeat(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   varnumber_T n = tv_get_number(&argvars[1]);
   if (argvars[0].v_type == VAR_LIST) {
@@ -6292,7 +6302,7 @@ static void f_repeat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "resolve()" function
-static void f_resolve(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   const char *fname = tv_get_string(&argvars[0]);
@@ -6461,7 +6471,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "reverse({list})" function
-static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reverse(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type == VAR_BLOB) {
     blob_T *const b = argvars[0].vval.v_blob;
@@ -6486,7 +6496,7 @@ static void f_reverse(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "reduce(list, { accumulator, element -> value } [, initial])" function
-static void f_reduce(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reduce(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_LIST && argvars[0].v_type != VAR_BLOB) {
     emsg(_(e_listblobreq));
@@ -6786,7 +6796,7 @@ theend:
 }
 
 /// "rpcnotify()" function
-static void f_rpcnotify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rpcnotify(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -6821,7 +6831,7 @@ static void f_rpcnotify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "rpcrequest()" function
-static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rpcrequest(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -6875,6 +6885,7 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   uint64_t chan_id = (uint64_t)argvars[0].vval.v_number;
   const char *method = tv_get_string(&argvars[1]);
 
+  // TODO: putta in eval_reuse_blk
   ArenaMem res_mem = NULL;
   Object result = rpc_send_call(chan_id, method, args, &res_mem, &err);
 
@@ -6910,12 +6921,12 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   }
 
 end:
-  arena_mem_free(res_mem, NULL);
+  arena_mem_free(res_mem, &eval_reuse_blk);
   api_clear_error(&err);
 }
 
 /// "rpcstart()" function (DEPRECATED)
-static void f_rpcstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rpcstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -6982,7 +6993,7 @@ static void f_rpcstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "rpcstop()" function
-static void f_rpcstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_rpcstop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_NUMBER;
   rettv->vval.v_number = 0;
@@ -7000,7 +7011,7 @@ static void f_rpcstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   // if called with a job, stop it, else closes the channel
   uint64_t id = (uint64_t)argvars[0].vval.v_number;
   if (find_job(id, false)) {
-    f_jobstop(argvars, rettv, NULL);
+    f_jobstop(argvars, rettv, fptr);
   } else {
     const char *error;
     rettv->vval.v_number =
@@ -7012,7 +7023,7 @@ static void f_rpcstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "screenattr()" function
-static void f_screenattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenattr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
@@ -7030,7 +7041,7 @@ static void f_screenattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "screenchar()" function
-static void f_screenchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenchar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
@@ -7048,7 +7059,7 @@ static void f_screenchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "screenchars()" function
-static void f_screenchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenchars(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
@@ -7076,13 +7087,13 @@ static void f_screenchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// "screencol()" function
 ///
 /// First column is 1 to be consistent with virtcol().
-static void f_screencol(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screencol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = ui_current_col() + 1;
 }
 
 /// "screenpos({winid}, {lnum}, {col})" function
-static void f_screenpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   dict_T *dict = rettv->vval.v_dict;
@@ -7108,13 +7119,13 @@ static void f_screenpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "screenrow()" function
-static void f_screenrow(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenrow(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = ui_current_row() + 1;
 }
 
 /// "screenstring()" function
-static void f_screenstring(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_screenstring(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_string = NULL;
   rettv->v_type = VAR_STRING;
@@ -7133,7 +7144,7 @@ static void f_screenstring(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "search()" function
-static void f_search(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_search(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int flags = 0;
 
@@ -7141,7 +7152,7 @@ static void f_search(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "searchdecl()" function
-static void f_searchdecl(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_searchdecl(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int locally = 1;
   int thisblock = 0;
@@ -7236,13 +7247,13 @@ theend:
 }
 
 /// "searchpair()" function
-static void f_searchpair(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_searchpair(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = searchpair_cmn(argvars, NULL);
 }
 
 /// "searchpairpos()" function
-static void f_searchpairpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_searchpairpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   pos_T match_pos;
   int lnum = 0;
@@ -7426,7 +7437,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
 }
 
 /// "searchpos()" function
-static void f_searchpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_searchpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   pos_T match_pos;
   int flags = 0;
@@ -7446,7 +7457,7 @@ static void f_searchpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "serverlist()" function
-static void f_serverlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_serverlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   size_t n;
   char **addrs = server_address_list(&n);
@@ -7460,7 +7471,7 @@ static void f_serverlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "serverstart()" function
-static void f_serverstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_serverstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;  // Address of the new server
@@ -7505,7 +7516,7 @@ static void f_serverstart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "serverstop()" function
-static void f_serverstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_serverstop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
@@ -7525,7 +7536,7 @@ static void f_serverstop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setbufline()" function
-static void f_setbufline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setbufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum;
   buf_T *buf;
@@ -7577,12 +7588,12 @@ static void set_position(typval_T *argvars, typval_T *rettv, bool charpos)
 }
 
 /// "setcharpos()" function
-static void f_setcharpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setcharpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   set_position(argvars, rettv, true);
 }
 
-static void f_setcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_DICT) {
     emsg(_(e_dictreq));
@@ -7611,7 +7622,7 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setcmdpos()" function
-static void f_setcmdpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const int pos = (int)tv_get_number(&argvars[0]) - 1;
 
@@ -7621,13 +7632,13 @@ static void f_setcmdpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setcursorcharpos" function
-static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   set_cursorpos(argvars, rettv, true);
 }
 
 /// "setenv()" function
-static void f_setenv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setenv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char namebuf[NUMBUFLEN];
   char valbuf[NUMBUFLEN];
@@ -7642,7 +7653,7 @@ static void f_setenv(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setfperm({fname}, {mode})" function
-static void f_setfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setfperm(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = 0;
 
@@ -7673,14 +7684,14 @@ static void f_setfperm(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setline()" function
-static void f_setline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   linenr_T lnum = tv_get_lnum(&argvars[0]);
   set_buffer_lines(curbuf, lnum, false, &argvars[1], rettv);
 }
 
 /// "setpos()" function
-static void f_setpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   set_position(argvars, rettv, false);
 }
@@ -7716,7 +7727,7 @@ static int get_yank_type(char **const pp, MotionType *const yank_type, long *con
 }
 
 /// "setreg()" function
-static void f_setreg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_setreg(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool append = false;
 
@@ -7857,7 +7868,7 @@ free_lstval:
 }
 
 /// "settagstack()" function
-static void f_settagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_settagstack(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   static char *e_invact2 = N_("E962: Invalid action: '%s'");
   char action = 'r';
@@ -7908,7 +7919,7 @@ static void f_settagstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// f_sha256 - sha256({string}) function
-static void f_sha256(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_sha256(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *p = tv_get_string(&argvars[0]);
   const char *hash = sha256_bytes((const uint8_t *)p, strlen(p), NULL, 0);
@@ -7919,7 +7930,7 @@ static void f_sha256(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "shellescape({string})" function
-static void f_shellescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_shellescape(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const bool do_special = non_zero_arg(&argvars[1]);
 
@@ -7930,7 +7941,7 @@ static void f_shellescape(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// shiftwidth() function
-static void f_shiftwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_shiftwidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = 0;
 
@@ -7946,7 +7957,7 @@ static void f_shiftwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "simplify()" function
-static void f_simplify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_simplify(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const p = tv_get_string(&argvars[0]);
   rettv->vval.v_string = xstrdup(p);
@@ -7955,7 +7966,7 @@ static void f_simplify(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sockconnect()" function
-static void f_sockconnect(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_sockconnect(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_STRING || argvars[1].v_type != VAR_STRING) {
     emsg(_(e_invarg));
@@ -8007,7 +8018,7 @@ static void f_sockconnect(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "stdioopen()" function
-static void f_stdioopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_stdioopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_DICT) {
     emsg(_(e_invarg));
@@ -8041,7 +8052,7 @@ static void f_stdioopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "reltimefloat()" function
-static void f_reltimefloat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_reltimefloat(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FUNC_ATTR_NONNULL_ALL
 {
   proftime_T tm;
@@ -8054,7 +8065,7 @@ static void f_reltimefloat(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "soundfold({word})" function
-static void f_soundfold(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_soundfold(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   const char *const s = tv_get_string(&argvars[0]);
@@ -8062,7 +8073,7 @@ static void f_soundfold(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "spellbadword()" function
-static void f_spellbadword(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_spellbadword(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const int wo_spell_save = curwin->w_p_spell;
 
@@ -8118,7 +8129,7 @@ static void f_spellbadword(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "spellsuggest()" function
-static void f_spellsuggest(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_spellsuggest(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   garray_T ga = GA_EMPTY_INIT_VALUE;
   const int wo_spell_save = curwin->w_p_spell;
@@ -8165,7 +8176,7 @@ f_spellsuggest_return:
   curwin->w_p_spell = wo_spell_save;
 }
 
-static void f_split(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   colnr_T col = 0;
   bool keepempty = false;
@@ -8244,7 +8255,7 @@ theend:
 }
 
 /// "stdpath(type)" function
-static void f_stdpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_stdpath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -8276,7 +8287,7 @@ static void f_stdpath(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "str2float()" function
-static void f_str2float(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_str2float(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char *p = skipwhite(tv_get_string(&argvars[0]));
   bool isneg = (*p == '-');
@@ -8292,7 +8303,7 @@ static void f_str2float(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "str2list()" function
-static void f_str2list(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_str2list(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenUnknown);
   const char_u *p = (const char_u *)tv_get_string(&argvars[0]);
@@ -8303,7 +8314,7 @@ static void f_str2list(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "str2nr()" function
-static void f_str2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_str2nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int base = 10;
   int what = 0;
@@ -8346,7 +8357,7 @@ static void f_str2nr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strftime({format}[, {time}])" function
-static void f_strftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   time_t seconds;
 
@@ -8398,7 +8409,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strgetchar()" function
-static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strgetchar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -8426,7 +8437,7 @@ static void f_strgetchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "stridx()" function
-static void f_stridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_stridx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -8458,20 +8469,20 @@ static void f_stridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "string()" function
-static void f_string(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_string(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = encode_tv2string(&argvars[0], NULL);
 }
 
 /// "strlen()" function
-static void f_strlen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strlen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = (varnumber_T)strlen(tv_get_string(&argvars[0]));
 }
 
 /// "strchars()" function
-static void f_strchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strchars(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *s = tv_get_string(&argvars[0]);
   int skipcc = 0;
@@ -8494,7 +8505,7 @@ static void f_strchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strdisplaywidth()" function
-static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const s = tv_get_string(&argvars[0]);
   int col = 0;
@@ -8507,7 +8518,7 @@ static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strwidth()" function
-static void f_strwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strwidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const s = tv_get_string(&argvars[0]);
 
@@ -8515,7 +8526,7 @@ static void f_strwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strcharpart()" function
-static void f_strcharpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strcharpart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const p = tv_get_string(&argvars[0]);
   const size_t slen = STRLEN(p);
@@ -8569,7 +8580,7 @@ static void f_strcharpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strpart()" function
-static void f_strpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strpart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool error = false;
 
@@ -8615,7 +8626,7 @@ static void f_strpart(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strptime({format}, {timestring})" function
-static void f_strptime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strptime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char fmt_buf[NUMBUFLEN];
   char str_buf[NUMBUFLEN];
@@ -8647,7 +8658,7 @@ static void f_strptime(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strridx()" function
-static void f_strridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strridx(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[NUMBUFLEN];
   const char *const needle = tv_get_string_chk(&argvars[1]);
@@ -8690,14 +8701,14 @@ static void f_strridx(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "strtrans()" function
-static void f_strtrans(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_strtrans(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = transstr(tv_get_string(&argvars[0]), true);
 }
 
 /// "submatch()" function
-static void f_submatch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_submatch(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   bool error = false;
   int no = (int)tv_get_number_chk(&argvars[0], &error);
@@ -8728,7 +8739,7 @@ static void f_submatch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "substitute()" function
-static void f_substitute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_substitute(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char patbuf[NUMBUFLEN];
   char subbuf[NUMBUFLEN];
@@ -8757,14 +8768,14 @@ static void f_substitute(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "swapinfo(swap_filename)" function
-static void f_swapinfo(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_swapinfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   get_b0_dict(tv_get_string(argvars), rettv->vval.v_dict);
 }
 
 /// "swapname(expr)" function
-static void f_swapname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_swapname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   buf_T *buf = tv_get_buf(&argvars[0], false);
@@ -8778,7 +8789,7 @@ static void f_swapname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "synID(lnum, col, trans)" function
-static void f_synID(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_synID(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // -1 on type error (both)
   const linenr_T lnum = tv_get_lnum(argvars);
@@ -8797,7 +8808,7 @@ static void f_synID(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "synIDattr(id, what [, mode])" function
-static void f_synIDattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_synIDattr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const int id = (int)tv_get_number(&argvars[0]);
   const char *const what = tv_get_string(&argvars[1]);
@@ -8884,7 +8895,7 @@ static void f_synIDattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "synIDtrans(id)" function
-static void f_synIDtrans(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_synIDtrans(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int id = (int)tv_get_number(&argvars[0]);
 
@@ -8898,7 +8909,7 @@ static void f_synIDtrans(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "synconcealed(lnum, col)" function
-static void f_synconcealed(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_synconcealed(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int syntax_flags = 0;
   int cchar;
@@ -8940,7 +8951,7 @@ static void f_synconcealed(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "synstack(lnum, col)" function
-static void f_synstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_synstack(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_set_ret(rettv, NULL);
 
@@ -8964,18 +8975,18 @@ static void f_synstack(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// f_system - the VimL system() function
-static void f_system(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_system(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_system_output_as_rettv(argvars, rettv, false);
 }
 
-static void f_systemlist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_systemlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_system_output_as_rettv(argvars, rettv, true);
 }
 
 /// "tabpagebuflist()" function
-static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = NULL;
 
@@ -8997,7 +9008,7 @@ static void f_tabpagebuflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "tabpagenr()" function
-static void f_tabpagenr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tabpagenr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int nr = 1;
 
@@ -9083,7 +9094,7 @@ static int get_winnr(tabpage_T *tp, typval_T *argvar)
 }
 
 /// "tabpagewinnr()" function
-static void f_tabpagewinnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tabpagewinnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int nr = 1;
   tabpage_T *const tp = find_tabpage((int)tv_get_number(&argvars[0]));
@@ -9096,7 +9107,7 @@ static void f_tabpagewinnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "tagfiles()" function
-static void f_tagfiles(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tagfiles(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenUnknown);
   char *fname = xmalloc(MAXPATHL);
@@ -9113,7 +9124,7 @@ static void f_tagfiles(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "taglist()" function
-static void f_taglist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_taglist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const tag_pattern = tv_get_string(&argvars[0]);
 
@@ -9131,14 +9142,14 @@ static void f_taglist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "tempname()" function
-static void f_tempname(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tempname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = (char *)vim_tempname();
 }
 
 /// "termopen(cmd[, cwd])" function
-static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_termopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()) {
     return;
@@ -9261,7 +9272,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "timer_info([timer])" function
-static void f_timer_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_timer_info(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_UNKNOWN) {
     if (argvars[0].v_type != VAR_NUMBER) {
@@ -9279,7 +9290,7 @@ static void f_timer_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "timer_pause(timer, paused)" function
-static void f_timer_pause(typval_T *argvars, typval_T *unused, FunPtr fptr)
+static void f_timer_pause(typval_T *argvars, typval_T *unused, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_NUMBER) {
     emsg(_(e_number_exp));
@@ -9299,7 +9310,7 @@ static void f_timer_pause(typval_T *argvars, typval_T *unused, FunPtr fptr)
 }
 
 /// "timer_start(timeout, callback, opts)" function
-static void f_timer_start(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_timer_start(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int repeat = 1;
 
@@ -9331,7 +9342,7 @@ static void f_timer_start(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "timer_stop(timerid)" function
-static void f_timer_stop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_timer_stop(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_NUMBER) {
     emsg(_(e_number_exp));
@@ -9346,27 +9357,27 @@ static void f_timer_stop(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   timer_stop(timer);
 }
 
-static void f_timer_stopall(typval_T *argvars, typval_T *unused, FunPtr fptr)
+static void f_timer_stopall(typval_T *argvars, typval_T *unused, EvalFuncData fptr)
 {
   timer_stop_all();
 }
 
 /// "tolower(string)" function
-static void f_tolower(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tolower(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = strcase_save(tv_get_string(&argvars[0]), false);
 }
 
 /// "toupper(string)" function
-static void f_toupper(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_toupper(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = strcase_save(tv_get_string(&argvars[0]), true);
 }
 
 /// "tr(string, fromstr, tostr)" function
-static void f_tr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_tr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[NUMBUFLEN];
   char buf2[NUMBUFLEN];
@@ -9445,7 +9456,7 @@ error:
 }
 
 /// "trim({expr})" function
-static void f_trim(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf1[NUMBUFLEN];
   char buf2[NUMBUFLEN];
@@ -9532,7 +9543,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "type(expr)" function
-static void f_type(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_type(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int n = -1;
 
@@ -9564,7 +9575,7 @@ static void f_type(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "undofile(name)" function
-static void f_undofile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_undofile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   const char *const fname = tv_get_string(&argvars[0]);
@@ -9583,7 +9594,7 @@ static void f_undofile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "undotree()" function
-static void f_undotree(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_undotree(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
 
@@ -9601,7 +9612,7 @@ static void f_undotree(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "virtcol(string)" function
-static void f_virtcol(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_virtcol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   colnr_T vcol = 0;
   int fnum = curbuf->b_fnum;
@@ -9626,7 +9637,7 @@ static void f_virtcol(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "visualmode()" function
-static void f_visualmode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_visualmode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u str[2];
 
@@ -9642,7 +9653,7 @@ static void f_visualmode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "wildmenumode()" function
-static void f_wildmenumode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_wildmenumode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (wild_menu_showing || ((State & MODE_CMDLINE) && cmdline_pum_active())) {
     rettv->vval.v_number = 1;
@@ -9650,20 +9661,20 @@ static void f_wildmenumode(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "win_findbuf()" function
-static void f_win_findbuf(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_findbuf(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_list_alloc_ret(rettv, kListLenMayKnow);
   win_findbuf(argvars, rettv->vval.v_list);
 }
 
 /// "win_getid()" function
-static void f_win_getid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_getid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = win_getid(argvars);
 }
 
 /// "win_gettype(nr)" function
-static void f_win_gettype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_gettype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = curwin;
 
@@ -9690,25 +9701,25 @@ static void f_win_gettype(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "win_gotoid()" function
-static void f_win_gotoid(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_gotoid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = win_gotoid(argvars);
 }
 
 /// "win_id2tabwin()" function
-static void f_win_id2tabwin(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_id2tabwin(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_id2tabwin(argvars, rettv);
 }
 
 /// "win_id2win()" function
-static void f_win_id2win(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_id2win(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = win_id2win(argvars);
 }
 
 /// "win_move_separator()" function
-static void f_win_move_separator(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_move_separator(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = false;
 
@@ -9723,7 +9734,7 @@ static void f_win_move_separator(typval_T *argvars, typval_T *rettv, FunPtr fptr
 }
 
 /// "win_move_statusline()" function
-static void f_win_move_statusline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_win_move_statusline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp;
   int offset;
@@ -9741,7 +9752,7 @@ static void f_win_move_statusline(typval_T *argvars, typval_T *rettv, FunPtr fpt
 }
 
 /// "winbufnr(nr)" function
-static void f_winbufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winbufnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = find_win_by_nr_or_id(&argvars[0]);
   if (wp == NULL) {
@@ -9752,14 +9763,14 @@ static void f_winbufnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "wincol()" function
-static void f_wincol(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_wincol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   validate_cursor();
   rettv->vval.v_number = curwin->w_wcol + 1;
 }
 
 /// "winheight(nr)" function
-static void f_winheight(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winheight(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = find_win_by_nr_or_id(&argvars[0]);
   if (wp == NULL) {
@@ -9770,7 +9781,7 @@ static void f_winheight(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "winlayout()" function
-static void f_winlayout(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winlayout(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tabpage_T *tp;
 
@@ -9789,20 +9800,20 @@ static void f_winlayout(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "winline()" function
-static void f_winline(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   validate_cursor();
   rettv->vval.v_number = curwin->w_wrow + 1;
 }
 
 /// "winnr()" function
-static void f_winnr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winnr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = get_winnr(curtab, &argvars[0]);
 }
 
 /// "winrestcmd()" function
-static void f_winrestcmd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winrestcmd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u buf[50];
 
@@ -9829,7 +9840,7 @@ static void f_winrestcmd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "winrestview()" function
-static void f_winrestview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winrestview(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   dict_T *dict = argvars[0].vval.v_dict;
 
@@ -9879,7 +9890,7 @@ static void f_winrestview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "winsaveview()" function
-static void f_winsaveview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winsaveview(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   dict_T *dict = rettv->vval.v_dict;
@@ -9897,7 +9908,7 @@ static void f_winsaveview(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "winwidth(nr)" function
-static void f_winwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_winwidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = find_win_by_nr_or_id(&argvars[0]);
   if (wp == NULL) {
@@ -9908,21 +9919,21 @@ static void f_winwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "windowsversion()" function
-static void f_windowsversion(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_windowsversion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = xstrdup(windowsVersion);
 }
 
 /// "wordcount()" function
-static void f_wordcount(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_wordcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   cursor_pos_info(rettv->vval.v_dict);
 }
 
 /// "writefile()" function
-static void f_writefile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_writefile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -10000,7 +10011,7 @@ static void f_writefile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "xor(expr, expr)" function
-static void f_xor(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+static void f_xor(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = tv_get_number_chk(&argvars[0], NULL)
                          ^ tv_get_number_chk(&argvars[1], NULL);
diff --git a/src/nvim/eval/funcs.h b/src/nvim/eval/funcs.h
index 583ee0e75e..3aa255ed0b 100644
--- a/src/nvim/eval/funcs.h
+++ b/src/nvim/eval/funcs.h
@@ -1,11 +1,12 @@
 #ifndef NVIM_EVAL_FUNCS_H
 #define NVIM_EVAL_FUNCS_H
 
+#include "nvim/api/private/dispatch.h"
 #include "nvim/buffer_defs.h"
 #include "nvim/eval/typval.h"
 
 /// Prototype of C function that implements VimL function
-typedef void (*VimLFunc)(typval_T *args, typval_T *rvar, FunPtr data);
+typedef void (*VimLFunc)(typval_T *args, typval_T *rvar, EvalFuncData data);
 
 /// Special flags for base_arg @see EvalFuncDef
 #define BASE_NONE 0          ///< Not a method (no base argument).
@@ -19,7 +20,7 @@ typedef struct {
   uint8_t base_arg;  ///< Method base arg # (1-indexed), BASE_NONE or BASE_LAST.
   bool fast;         ///< Can be run in |api-fast| events
   VimLFunc func;     ///< Function implementation.
-  FunPtr data;       ///< Userdata for function implementation.
+  EvalFuncData data; ///< Userdata for function implementation.
 } EvalFuncDef;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 8822bb0491..53b4a94d8e 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -831,7 +831,7 @@ int tv_list_join(garray_T *const gap, list_T *const l, const char *const sep)
 }
 
 /// "join()" function
-void f_join(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_join(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_LIST) {
     emsg(_(e_listreq));
@@ -855,7 +855,7 @@ void f_join(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "list2str()" function
-void f_list2str(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_list2str(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   garray_T ga;
 
@@ -1267,13 +1267,13 @@ theend:
 }
 
 /// "sort"({list})" function
-void f_sort(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sort(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   do_sort_uniq(argvars, rettv, true);
 }
 
 /// "uniq({list})" function
-void f_uniq(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_uniq(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   do_sort_uniq(argvars, rettv, false);
 }
@@ -2806,25 +2806,25 @@ static void tv_dict_list(typval_T *const tv, typval_T *const rettv, const DictLi
 }
 
 /// "items(dict)" function
-void f_items(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_items(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_list(argvars, rettv, 2);
 }
 
 /// "keys()" function
-void f_keys(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_keys(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_list(argvars, rettv, 0);
 }
 
 /// "values(dict)" function
-void f_values(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_values(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_list(argvars, rettv, 1);
 }
 
 /// "has_key()" function
-void f_has_key(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_has_key(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_DICT) {
     emsg(_(e_dictreq));
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index c4bc9f603b..8177d01f90 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -25,9 +25,6 @@
 typedef int64_t varnumber_T;
 typedef uint64_t uvarnumber_T;
 
-/// Type used for VimL VAR_FLOAT values
-typedef double float_T;
-
 /// Refcount for dict or list that should not be freed
 enum { DO_NOT_FREE_CNT = (INT_MAX / 2), };
 
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 23d77e0687..39618e7dc8 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -1702,7 +1702,7 @@ bool var_exists(const char *var)
 }
 
 /// "gettabvar()" function
-void f_gettabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_gettabvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const varname = tv_get_string_chk(&argvars[1]);
   tabpage_T *const tp = find_tabpage((int)tv_get_number_chk(&argvars[0], NULL));
@@ -1716,19 +1716,19 @@ void f_gettabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "gettabwinvar()" function
-void f_gettabwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_gettabwinvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getwinvar(argvars, rettv, 1);
 }
 
 /// "getwinvar()" function
-void f_getwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getwinvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getwinvar(argvars, rettv, 0);
 }
 
 /// "getbufvar()" function
-void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getbufvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const varname = tv_get_string_chk(&argvars[1]);
   buf_T *const buf = tv_get_buf_from_arg(&argvars[0]);
@@ -1737,7 +1737,7 @@ void f_getbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "settabvar()" function
-void f_settabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_settabvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = 0;
 
@@ -1768,19 +1768,19 @@ void f_settabvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "settabwinvar()" function
-void f_settabwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_settabwinvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   setwinvar(argvars, rettv, 1);
 }
 
 /// "setwinvar()" function
-void f_setwinvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setwinvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   setwinvar(argvars, rettv, 0);
 }
 
 /// "setbufvar()" function
-void f_setbufvar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setbufvar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (check_secure()
       || !tv_check_str_or_nr(&argvars[0])) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 5e8c7dbdda..1a155488aa 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3047,7 +3047,7 @@ int cmd_exists(const char *const name)
 }
 
 /// "fullcommand" function
-void f_fullcommand(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_fullcommand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char *name = argvars[0].vval.v_string;
 
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 8ce24fd378..f1630f9370 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -3212,19 +3212,19 @@ static void foldclosed_both(typval_T *argvars, typval_T *rettv, int end)
 }
 
 /// "foldclosed()" function
-void f_foldclosed(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_foldclosed(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   foldclosed_both(argvars, rettv, false);
 }
 
 /// "foldclosedend()" function
-void f_foldclosedend(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_foldclosedend(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   foldclosed_both(argvars, rettv, true);
 }
 
 /// "foldlevel()" function
-void f_foldlevel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_foldlevel(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const linenr_T lnum = tv_get_lnum(argvars);
   if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count) {
@@ -3233,7 +3233,7 @@ void f_foldlevel(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "foldtext()" function
-void f_foldtext(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_foldtext(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -3279,7 +3279,7 @@ void f_foldtext(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "foldtextresult(lnum)" function
-void f_foldtextresult(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_foldtextresult(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char_u buf[FOLD_TEXT_LEN];
   static bool entered = false;
diff --git a/src/nvim/generators/c_grammar.lua b/src/nvim/generators/c_grammar.lua
index 70a7be86b5..d872ffd6a9 100644
--- a/src/nvim/generators/c_grammar.lua
+++ b/src/nvim/generators/c_grammar.lua
@@ -26,6 +26,7 @@ local c_id = (
 local c_void = P('void')
 local c_param_type = (
   ((P('Error') * fill * P('*') * fill) * Cc('error')) +
+  ((P('Arena') * fill * P('*') * fill) * Cc('arena')) +
   C((P('const ') ^ -1) * (c_id) * (ws ^ 1) * P('*')) +
   (C(c_id) * (ws ^ 1))
   )
diff --git a/src/nvim/generators/gen_api_dispatch.lua b/src/nvim/generators/gen_api_dispatch.lua
index b167767f7a..e4798bf5ce 100644
--- a/src/nvim/generators/gen_api_dispatch.lua
+++ b/src/nvim/generators/gen_api_dispatch.lua
@@ -17,6 +17,7 @@ local nvimdir = arg[1]
 package.path = nvimdir .. '/?.lua;' .. package.path
 
 _G.vim = loadfile(nvimdir..'/../../runtime/lua/vim/shared.lua')()
+_G.vim.inspect = loadfile(nvimdir..'/../../runtime/lua/vim/inspect.lua')()
 
 local hashy = require'generators.hashy'
 
@@ -72,6 +73,11 @@ for i = 6, #arg do
         -- for specifying errors
         fn.parameters[#fn.parameters] = nil
       end
+      if #fn.parameters ~= 0 and fn.parameters[#fn.parameters][1] == 'arena' then
+        -- return value is allocated in an arena
+        fn.arena_return = true
+        fn.parameters[#fn.parameters] = nil
+      end
     end
   end
   input:close()
@@ -210,7 +216,7 @@ for i = 1, #functions do
   if fn.impl_name == nil and fn.remote then
     local args = {}
 
-    output:write('Object handle_'..fn.name..'(uint64_t channel_id, Array args, Error *error)')
+    output:write('Object handle_'..fn.name..'(uint64_t channel_id, Array args, Arena* arena, Error *error)')
     output:write('\n{')
     output:write('\n#if MIN_LOG_LEVEL <= LOGLVL_DBG')
     output:write('\n  logmsg(LOGLVL_DBG, "RPC: ", NULL, -1, true, "ch %" PRIu64 ": invoke '
@@ -319,6 +325,10 @@ for i = 1, #functions do
       output:write(call_args)
     end
 
+    if fn.arena_return then
+        output:write(', arena')
+    end
+
     if fn.can_fail then
       -- if the function can fail, also pass a pointer to the local error object
       if #args > 0 then
@@ -355,11 +365,12 @@ local hashorder, hashfun = hashy.hashy_hash("msgpack_rpc_get_handler_for", vim.t
   return "method_handlers["..idx.."].name"
 end)
 
-output:write("static const MsgpackRpcRequestHandler method_handlers[] = {\n")
-for _, name in ipairs(hashorder) do
+output:write("const MsgpackRpcRequestHandler method_handlers[] = {\n")
+for n, name in ipairs(hashorder) do
   local fn = remote_fns[name]
+  fn.handler_id = n-1
   output:write('  { .name = "'..name..'", .fn = handle_'..  (fn.impl_name or fn.name)..
-               ', .fast = '..tostring(fn.fast)..'},\n')
+               ', .fast = '..tostring(fn.fast)..', .arena_return = '..tostring(not not fn.arena_return)..'},\n')
 end
 output:write("};\n\n")
 output:write(hashfun)
@@ -400,6 +411,10 @@ output:write([[
 #include "nvim/api/private/helpers.h"
 #include "nvim/lua/converter.h"
 #include "nvim/lua/executor.h"
+#include "nvim/memory.h"
+
+static ArenaMem lua_reuse_blk = { 0 };
+
 ]])
 include_headers(output, headers)
 output:write('\n')
@@ -477,6 +492,14 @@ local function process_function(fn)
   if fn.receives_channel_id then
     cparams = 'LUA_INTERNAL_CALL, ' .. cparams
   end
+  if fn.arena_return then
+    cparams = cparams .. '&arena, '
+    write_shifted_output(output, [[
+    Arena arena = ARENA_EMPTY;
+    arena_start(&arena, &lua_reuse_blk);
+    ]])
+  end
+
   if fn.can_fail then
     cparams = cparams .. '&err'
   else
@@ -511,15 +534,21 @@ local function process_function(fn)
     else
       return_type = fn.return_type
     end
+    local free_retval
+    if fn.arena_return then
+      free_retval = "arena_mem_free(arena_finish(&arena), &lua_reuse_blk);"
+    else
+      free_retval = "api_free_"..return_type:lower().."(ret);"
+    end
     write_shifted_output(output, string.format([[
     const %s ret = %s(%s);
     nlua_push_%s(lstate, ret, true);
-    api_free_%s(ret);
+  %s
   %s
   %s
     return 1;
-    ]], fn.return_type, fn.name, cparams, return_type, return_type:lower(),
-        free_at_exit_code, err_throw_code))
+    ]], fn.return_type, fn.name, cparams, return_type,
+        free_retval, free_at_exit_code, err_throw_code))
   else
     write_shifted_output(output, string.format([[
     %s(%s);
diff --git a/src/nvim/generators/gen_eval.lua b/src/nvim/generators/gen_eval.lua
index c72249161b..8e6d1f2634 100644
--- a/src/nvim/generators/gen_eval.lua
+++ b/src/nvim/generators/gen_eval.lua
@@ -28,13 +28,20 @@ local hashy = require'generators.hashy'
 local hashpipe = io.open(funcsfname, 'wb')
 
 local funcs = require('eval').funcs
+for _, func in pairs(funcs) do
+  if func.float_func then
+    func.func = "float_op_wrapper"
+    func.data = "{ .float_func = &"..func.float_func.." }"
+  end
+end
+
 local metadata = mpack.unpack(io.open(metadata_file, 'rb'):read("*all"))
 for _,fun in ipairs(metadata) do
   if fun.eval then
     funcs[fun.name] = {
       args=#fun.parameters,
       func='api_wrapper',
-      data='&handle_'..fun.name,
+      data='{ .api_handler = &method_handlers['..fun.handler_id..'] }'
     }
   end
 end
@@ -60,12 +67,12 @@ for _, name in ipairs(neworder) do
   end
   local base = def.base or "BASE_NONE"
   local func = def.func or ('f_' .. name)
-  local data = def.data or "NULL"
+  local data = def.data or "{ .nullptr = NULL }"
   local fast = def.fast and 'true' or 'false'
-  hashpipe:write(('  { "%s", %s, %s, %s, %s, &%s, (FunPtr)%s },\n')
+  hashpipe:write(('  { "%s", %s, %s, %s, %s, &%s, %s },\n')
                   :format(name, args[1], args[2], base, fast, func, data))
 end
-hashpipe:write('  { NULL, 0, 0, BASE_NONE, false, NULL, NULL },\n')
+hashpipe:write('  { NULL, 0, 0, BASE_NONE, false, NULL, { .nullptr = NULL } },\n')
 hashpipe:write("};\n\n")
 hashpipe:write(hashfun)
 hashpipe:close()
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index c8d4ef18ac..892c1a3553 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1810,13 +1810,13 @@ static void getchar_common(typval_T *argvars, typval_T *rettv)
 }
 
 /// "getchar()" function
-void f_getchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getchar(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getchar_common(argvars, rettv);
 }
 
 /// "getcharstr()" function
-void f_getcharstr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getcharstr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   getchar_common(argvars, rettv);
 
@@ -1836,7 +1836,7 @@ void f_getcharstr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getcharmod()" function
-void f_getcharmod(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getcharmod(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = mod_mask;
 }
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 938189f343..c092745242 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2256,7 +2256,7 @@ static void set_completion(colnr_T startcol, list_T *list)
 }
 
 /// "complete()" function
-void f_complete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_complete(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if ((State & MODE_INSERT) == 0) {
     emsg(_("E785: complete() can only be used in Insert mode"));
@@ -2280,13 +2280,13 @@ void f_complete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "complete_add()" function
-void f_complete_add(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_complete_add(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = ins_compl_add_tv(&argvars[0], 0, false);
 }
 
 /// "complete_check()" function
-void f_complete_check(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_complete_check(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int saved = RedrawingDisabled;
 
@@ -2441,7 +2441,7 @@ static void get_complete_info(list_T *what_list, dict_T *retdict)
 }
 
 /// "complete_info()" function
-void f_complete_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_complete_info(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
 
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 64a798a27b..9da7e9a947 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -1967,7 +1967,7 @@ char_u *check_map(char_u *keys, int mode, int exact, int ign_mod, int abbr, mapb
 }
 
 /// "hasmapto()" function
-void f_hasmapto(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_hasmapto(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *mode;
   const char *const name = tv_get_string(&argvars[0]);
@@ -2127,7 +2127,7 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
 }
 
 /// "mapset()" function
-void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_mapset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf[NUMBUFLEN];
   const char *which = tv_get_string_buf_chk(&argvars[0], buf);
@@ -2195,13 +2195,13 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "maparg()" function
-void f_maparg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_maparg(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_maparg(argvars, rettv, true);
 }
 
 /// "mapcheck()" function
-void f_mapcheck(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_mapcheck(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_maparg(argvars, rettv, false);
 }
diff --git a/src/nvim/match.c b/src/nvim/match.c
index 1c34c9f004..82a9bc6c25 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -859,7 +859,7 @@ static int matchadd_dict_arg(typval_T *tv, const char **conceal_char, win_T **wi
 }
 
 /// "clearmatches()" function
-void f_clearmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_clearmatches(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *win = get_optional_window(argvars, 0);
 
@@ -869,7 +869,7 @@ void f_clearmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "getmatches()" function
-void f_getmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getmatches(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   matchitem_T *cur;
   int i;
@@ -924,7 +924,7 @@ void f_getmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setmatches()" function
-void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setmatches(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   dict_T *d;
   list_T *s = NULL;
@@ -1027,7 +1027,7 @@ void f_setmatches(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "matchadd()" function
-void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matchadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char grpbuf[NUMBUFLEN];
   char patbuf[NUMBUFLEN];
@@ -1069,7 +1069,7 @@ void f_matchadd(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "matchaddpo()" function
-void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matchaddpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -1120,7 +1120,7 @@ void f_matchaddpos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "matcharg()" function
-void f_matcharg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matcharg(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const int id = (int)tv_get_number(&argvars[0]);
 
@@ -1143,7 +1143,7 @@ void f_matcharg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "matchdelete()" function
-void f_matchdelete(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matchdelete(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *win = get_optional_window(argvars, 1);
   if (win == NULL) {
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index af9e214d92..226944eb73 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -2748,7 +2748,7 @@ static int tv_nr_compare(const void *a1, const void *a2)
 }
 
 /// "setcellwidths()" function
-void f_setcellwidths(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setcellwidths(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (argvars[0].v_type != VAR_LIST || argvars[0].vval.v_list == NULL) {
     emsg(_(e_listreq));
@@ -2860,7 +2860,7 @@ void f_setcellwidths(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   redraw_all_later(NOT_VALID);
 }
 
-void f_charclass(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_charclass(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   if (tv_check_for_string(&argvars[0]) == FAIL
       || argvars[0].vval.v_string == NULL) {
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index fb36d4ccf4..91f066f458 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -534,15 +534,18 @@ void arena_start(Arena *arena, ArenaMem *reuse_blk)
   if (reuse_blk && *reuse_blk) {
     arena->cur_blk = (char *)(*reuse_blk);
     *reuse_blk = NULL;
+    arena->size = ARENA_BLOCK_SIZE;
+    arena->pos = 0;
+
+    // address is the same as as (struct consumed_blk *)arena->cur_blk
+    struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
+    assert((char *)blk == (char *)arena->cur_blk);
+    blk->prev = NULL;
   } else {
-    arena->cur_blk = xmalloc(ARENA_BLOCK_SIZE);
+    arena->cur_blk = NULL;
+    arena->size = 0;
+    arena->pos = 0;
   }
-  arena->pos = 0;
-  arena->size = ARENA_BLOCK_SIZE;
-  // address is the same as as (struct consumed_blk *)arena->cur_blk
-  struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
-  assert((char *)blk == (char *)arena->cur_blk);
-  blk->prev = NULL;
 }
 
 /// Finnish the allocations in an arena.
@@ -558,17 +561,35 @@ ArenaMem arena_finish(Arena *arena)
   return res;
 }
 
+void alloc_block(Arena *arena)
+{
+  struct consumed_blk *prev_blk = (struct consumed_blk *)arena->cur_blk;
+  arena->cur_blk = xmalloc(ARENA_BLOCK_SIZE);
+  arena->pos = 0;
+  arena->size = ARENA_BLOCK_SIZE;
+  struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
+  blk->prev = prev_blk;
+  arena_alloc_count++;
+}
+
+/// @param size if zero, will still return a non-null pointer, but not a unique one
 void *arena_alloc(Arena *arena, size_t size, bool align)
 {
   if (align) {
     arena->pos = (arena->pos + (ARENA_ALIGN - 1)) & ~(ARENA_ALIGN - 1);
   }
-  if (arena->pos + size > arena->size) {
-    if (size > (arena->size - sizeof(struct consumed_blk)) >> 1) {
+  if (arena->pos + size > arena->size || !arena->cur_blk) {
+    if (size > (ARENA_BLOCK_SIZE - sizeof(struct consumed_blk)) >> 1) {
       // if allocation is too big, allocate a large block with the requested
       // size, but still with block pointer head. We do this even for
       // arena->size / 2, as there likely is space left for the next
       // small allocation in the current block.
+      if (!arena->cur_blk) {
+        // to simplify free-list management, arena->cur_blk must
+        // always be a normal, ARENA_BLOCK_SIZE sized, block
+        alloc_block(arena);
+      }
+      arena_alloc_count++;
       char *alloc = xmalloc(size + sizeof(struct consumed_blk));
       struct consumed_blk *cur_blk = (struct consumed_blk *)arena->cur_blk;
       struct consumed_blk *fix_blk = (struct consumed_blk *)alloc;
@@ -576,12 +597,7 @@ void *arena_alloc(Arena *arena, size_t size, bool align)
       cur_blk->prev = fix_blk;
       return (alloc + sizeof(struct consumed_blk));
     } else {
-      struct consumed_blk *prev_blk = (struct consumed_blk *)arena->cur_blk;
-      arena->cur_blk = xmalloc(ARENA_BLOCK_SIZE);
-      arena->pos = 0;
-      arena->size = ARENA_BLOCK_SIZE;
-      struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
-      blk->prev = prev_blk;
+      alloc_block(arena);
     }
   }
 
diff --git a/src/nvim/memory.h b/src/nvim/memory.h
index 63d607c2ce..5e37847beb 100644
--- a/src/nvim/memory.h
+++ b/src/nvim/memory.h
@@ -6,6 +6,8 @@
 #include <stdint.h>  // for uint8_t
 #include <time.h>  // for time_t
 
+#include "nvim/macros.h"
+
 /// `malloc()` function signature
 typedef void *(*MemMalloc)(size_t);
 
@@ -37,6 +39,8 @@ extern MemRealloc mem_realloc;
 extern bool entered_free_all_mem;
 #endif
 
+EXTERN size_t arena_alloc_count INIT(=0);
+
 typedef struct consumed_blk {
   struct consumed_blk *prev;
 } *ArenaMem;
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index c3cf4457fc..efbeb26915 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -1945,7 +1945,7 @@ static void menuitem_getinfo(const char *menu_name, const vimmenu_T *menu, int m
 
 /// "menu_info()" function
 /// Return information about a menu (including all the child menus)
-void f_menu_info(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_menu_info(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   tv_dict_alloc_ret(rettv);
   dict_T *const retdict = rettv->vval.v_dict;
diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
index 1ca68979f4..66fd79c692 100644
--- a/src/nvim/msgpack_rpc/channel.c
+++ b/src/nvim/msgpack_rpc/channel.c
@@ -304,7 +304,8 @@ static void handle_request(Channel *channel, Unpacker *p, Array args)
   evdata->channel = channel;
   evdata->handler = p->handler;
   evdata->args = args;
-  evdata->used_mem = arena_finish(&p->arena);
+  evdata->used_mem = p->arena;
+  p->arena = (Arena)ARENA_EMPTY;
   evdata->request_id = p->request_id;
   channel_incref(channel);
   if (p->handler.fast) {
@@ -344,7 +345,8 @@ static void request_event(void **argv)
     // channel was closed, abort any pending requests
     goto free_ret;
   }
-  Object result = handler.fn(channel->id, e->args, &error);
+
+  Object result = handler.fn(channel->id, e->args, &e->used_mem, &error);
   if (e->type == kMessageTypeRequest || ERROR_SET(&error)) {
     // Send the response.
     msgpack_packer response;
@@ -355,13 +357,14 @@ static void request_event(void **argv)
                                               &error,
                                               result,
                                               &out_buffer));
-  } else {
+  }
+  if (!handler.arena_return) {
     api_free_object(result);
   }
 
 free_ret:
-  // e->args is allocated in an arena
-  arena_mem_free(e->used_mem, &channel->rpc.unpacker->reuse_blk);
+  // e->args (and possibly result) are allocated in an arena
+  arena_mem_free(arena_finish(&e->used_mem), &channel->rpc.unpacker->reuse_blk);
   channel_decref(channel);
   xfree(e);
   api_clear_error(&error);
@@ -624,7 +627,6 @@ static WBuffer *serialize_response(uint64_t channel_id, MessageType type, uint32
                                    1,  // responses only go though 1 channel
                                    xfree);
   msgpack_sbuffer_clear(sbuffer);
-  api_free_object(arg);
   return rv;
 }
 
diff --git a/src/nvim/msgpack_rpc/channel_defs.h b/src/nvim/msgpack_rpc/channel_defs.h
index e622ebddf5..404e68329a 100644
--- a/src/nvim/msgpack_rpc/channel_defs.h
+++ b/src/nvim/msgpack_rpc/channel_defs.h
@@ -27,7 +27,7 @@ typedef struct {
   MsgpackRpcRequestHandler handler;
   Array args;
   uint32_t request_id;
-  ArenaMem used_mem;
+  Arena used_mem;
 } RequestEvent;
 
 typedef struct {
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index d5f4996f61..0145fc46a7 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -7169,14 +7169,14 @@ static void get_qf_loc_list(int is_qf, win_T *wp, typval_T *what_arg, typval_T *
 }
 
 /// "getloclist()" function
-void f_getloclist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getloclist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   win_T *wp = find_win_by_nr_or_id(&argvars[0]);
   get_qf_loc_list(false, wp, &argvars[1], rettv);
 }
 
 /// "getqflist()" functions
-void f_getqflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_getqflist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   get_qf_loc_list(true, NULL, &argvars[0], rettv);
 }
@@ -7263,7 +7263,7 @@ skip_args:
 }
 
 /// "setloclist()" function
-void f_setloclist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setloclist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = -1;
 
@@ -7274,7 +7274,7 @@ void f_setloclist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "setqflist()" function
-void f_setqflist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_setqflist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   set_qf_ll_list(NULL, argvars, rettv);
 }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index c53d955974..65dedd9592 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -4637,7 +4637,7 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst
 }
 
 // "searchcount()" function
-void f_searchcount(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   pos_T pos = curwin->w_cursor;
   char_u *pattern = NULL;
@@ -5287,13 +5287,13 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv,
 }
 
 /// "matchfuzzy()" function
-void f_matchfuzzy(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matchfuzzy(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   do_fuzzymatch(argvars, rettv, false);
 }
 
 /// "matchfuzzypos()" function
-void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   do_fuzzymatch(argvars, rettv, true);
 }
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index f1ddbfd147..07679fb157 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -1964,7 +1964,7 @@ static void sign_define_multiple(list_T *l, list_T *retlist)
 }
 
 /// "sign_define()" function
-void f_sign_define(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_define(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *name;
 
@@ -1995,7 +1995,7 @@ void f_sign_define(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sign_getdefined()" function
-void f_sign_getdefined(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_getdefined(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *name = NULL;
 
@@ -2009,7 +2009,7 @@ void f_sign_getdefined(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sign_getplaced()" function
-void f_sign_getplaced(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_getplaced(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   buf_T *buf = NULL;
   dict_T *dict;
@@ -2067,7 +2067,7 @@ void f_sign_getplaced(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sign_jump()" function
-void f_sign_jump(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_jump(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int sign_id;
   char *sign_group = NULL;
@@ -2225,7 +2225,7 @@ cleanup:
 }
 
 /// "sign_place()" function
-void f_sign_place(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_place(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   dict_T *dict = NULL;
 
@@ -2243,7 +2243,7 @@ void f_sign_place(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sign_placelist()" function.  Place multiple signs.
-void f_sign_placelist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_placelist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int sign_id;
 
@@ -2283,7 +2283,7 @@ static void sign_undefine_multiple(list_T *l, list_T *retlist)
 }
 
 /// "sign_undefine()" function
-void f_sign_undefine(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_undefine(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *name;
 
@@ -2373,7 +2373,7 @@ cleanup:
 }
 
 /// "sign_unplace()" function
-void f_sign_unplace(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_unplace(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   dict_T *dict = NULL;
 
@@ -2396,7 +2396,7 @@ void f_sign_unplace(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "sign_unplacelist()" function
-void f_sign_unplacelist(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_sign_unplacelist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   int retval;
 
diff --git a/src/nvim/testing.c b/src/nvim/testing.c
index e70e9f2cbd..e3ffe1c7d1 100644
--- a/src/nvim/testing.c
+++ b/src/nvim/testing.c
@@ -326,19 +326,19 @@ static int assert_beeps(typval_T *argvars, bool no_beep)
 }
 
 /// "assert_beeps(cmd [, error])" function
-void f_assert_beeps(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_beeps(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_beeps(argvars, false);
 }
 
 /// "assert_nobeep(cmd [, error])" function
-void f_assert_nobeep(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_nobeep(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_beeps(argvars, true);
 }
 
 /// "assert_equal(expected, actual[, msg])" function
-void f_assert_equal(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_equal(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_equal_common(argvars, ASSERT_EQUAL);
 }
@@ -433,19 +433,19 @@ static int assert_equalfile(typval_T *argvars)
 }
 
 /// "assert_equalfile(fname-one, fname-two[, msg])" function
-void f_assert_equalfile(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_equalfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_equalfile(argvars);
 }
 
 /// "assert_notequal(expected, actual[, msg])" function
-void f_assert_notequal(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_notequal(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_equal_common(argvars, ASSERT_NOTEQUAL);
 }
 
 /// "assert_exception(string[, msg])" function
-void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_exception(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   garray_T ga;
 
@@ -468,7 +468,7 @@ void f_assert_exception(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "assert_fails(cmd [, error [, msg]])" function
-void f_assert_fails(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   const char *const cmd = tv_get_string_chk(&argvars[0]);
   garray_T ga;
@@ -513,7 +513,7 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 // "assert_false(actual[, msg])" function
-void f_assert_false(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_false(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_bool(argvars, false);
 }
@@ -574,25 +574,25 @@ static int assert_inrange(typval_T *argvars)
 }
 
 /// "assert_inrange(lower, upper[, msg])" function
-void f_assert_inrange(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_inrange(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_inrange(argvars);
 }
 
 /// "assert_match(pattern, actual[, msg])" function
-void f_assert_match(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_match(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_match_common(argvars, ASSERT_MATCH);
 }
 
 /// "assert_notmatch(pattern, actual[, msg])" function
-void f_assert_notmatch(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_notmatch(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_match_common(argvars, ASSERT_NOTMATCH);
 }
 
 /// "assert_report(msg)" function
-void f_assert_report(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_report(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   garray_T ga;
 
@@ -604,13 +604,13 @@ void f_assert_report(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "assert_true(actual[, msg])" function
-void f_assert_true(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_assert_true(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->vval.v_number = assert_bool(argvars, true);
 }
 
 /// "test_garbagecollect_now()" function
-void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   // This is dangerous, any Lists and Dicts used internally may be freed
   // while still in use.
@@ -618,7 +618,7 @@ void f_test_garbagecollect_now(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 }
 
 /// "test_write_list_log()" function
-void f_test_write_list_log(typval_T *const argvars, typval_T *const rettv, FunPtr fptr)
+void f_test_write_list_log(typval_T *const argvars, typval_T *const rettv, EvalFuncData fptr)
 {
   const char *const fname = tv_get_string_chk(&argvars[0]);
   if (fname == NULL) {
diff --git a/src/nvim/types.h b/src/nvim/types.h
index 477102276c..3fac97fc82 100644
--- a/src/nvim/types.h
+++ b/src/nvim/types.h
@@ -22,7 +22,17 @@ typedef int handle_T;
 // absent callback etc.
 typedef int LuaRef;
 
-typedef void (*FunPtr)(void);
+/// Type used for VimL VAR_FLOAT values
+typedef double float_T;
+
+typedef struct MsgpackRpcRequestHandler MsgpackRpcRequestHandler;
+
+typedef union {
+  float_T (*float_func)(float_T);
+  const MsgpackRpcRequestHandler *api_handler;
+  void *nullptr;
+} EvalFuncData;
+
 
 typedef handle_T NS;
 
diff --git a/src/nvim/ui_client.c b/src/nvim/ui_client.c
index a586fec3bf..265c54f72d 100644
--- a/src/nvim/ui_client.c
+++ b/src/nvim/ui_client.c
@@ -55,7 +55,7 @@ UIClientHandler ui_client_get_redraw_handler(const char *name, size_t name_len,
 /// async 'redraw' events, which are expected when nvim acts as an ui client.
 /// get handled in msgpack_rpc/unpacker.c and directly dispatched to handlers
 /// of specific ui events, like ui_client_event_grid_resize and so on.
-Object handle_ui_client_redraw(uint64_t channel_id, Array args, Error *error)
+Object handle_ui_client_redraw(uint64_t channel_id, Array args, Arena *arena, Error *error)
 {
   api_set_error(error, kErrorTypeValidation, "'redraw' cannot be sent as a request");
   return NIL;
-- 
cgit 


From 64d147b4719310093ca2d728ba68b23f7e0660df Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 06:28:37 +0800
Subject: vim-patch:9.0.0248: duplicate code in finding a script in the
 execution stack (#19917)

Problem:    Duplicate code in finding a script in the execution stack.
Solution:   Reduce duplicate code. (closes vim/vim#10961)
https://github.com/vim/vim/commit/a247142ae45308087b25f91c8af48399c8ac2943
---
 src/nvim/runtime.c | 24 +++++++-----------------
 1 file changed, 7 insertions(+), 17 deletions(-)

(limited to 'src')

diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 038aad12a4..a04ae271e1 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -116,25 +116,15 @@ char *estack_sfile(estack_arg_T which)
   // where it is defined, at script level the current script path is returned
   // instead.
   if (which == ESTACK_SCRIPT) {
-    assert(entry == ((estack_T *)exestack.ga_data) + exestack.ga_len - 1);
     // Walk the stack backwards, starting from the current frame.
     for (int idx = exestack.ga_len - 1; idx >= 0; idx--, entry--) {
-      if (entry->es_type == ETYPE_UFUNC) {
-        const sctx_T *const def_ctx = &entry->es_info.ufunc->uf_script_ctx;
-
-        if (def_ctx->sc_sid > 0) {
-          return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
-        } else {
-          return NULL;
-        }
-      } else if (entry->es_type == ETYPE_AUCMD) {
-        const sctx_T *const def_ctx = &entry->es_info.aucmd->script_ctx;
-
-        if (def_ctx->sc_sid > 0) {
-          return xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name));
-        } else {
-          return NULL;
-        }
+      if (entry->es_type == ETYPE_UFUNC || entry->es_type == ETYPE_AUCMD) {
+        const sctx_T *const def_ctx = (entry->es_type == ETYPE_UFUNC
+                                       ? &entry->es_info.ufunc->uf_script_ctx
+                                       : &entry->es_info.aucmd->script_ctx);
+        return def_ctx->sc_sid > 0
+                ? xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name))
+                : NULL;
       } else if (entry->es_type == ETYPE_SCRIPT) {
         return xstrdup(entry->es_name);
       }
-- 
cgit 


From 9a100ee169f80cbfe45872939ed9b4f70f6bfe3f Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 10:28:32 +0800
Subject: fix(cmdline): do not trigger completion at wrong time (#19920)

Cherry-picked from Vim patches 8.2.4339, 9.0.0238.
---
 src/nvim/ex_getln.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 0dce2fd2e2..febfff41e1 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1277,8 +1277,11 @@ static int command_line_execute(VimState *state, int key)
   // <S-Tab> goes to last match, in a clumsy way
   if (s->c == K_S_TAB && KeyTyped) {
     if (nextwild(&s->xpc, WILD_EXPAND_KEEP, 0, s->firstc != '@') == OK) {
-      // Trigger the popup menu when wildoptions=pum
-      showmatches(&s->xpc, p_wmnu && ((wim_flags[s->wim_index] & WIM_LIST) == 0));
+      if (s->xpc.xp_numfiles > 1
+          && ((!s->did_wild_list && (wim_flags[s->wim_index] & WIM_LIST)) || p_wmnu)) {
+        // Trigger the popup menu when wildoptions=pum
+        showmatches(&s->xpc, p_wmnu && ((wim_flags[s->wim_index] & WIM_LIST) == 0));
+      }
       nextwild(&s->xpc, WILD_PREV, 0, s->firstc != '@');
       nextwild(&s->xpc, WILD_PREV, 0, s->firstc != '@');
       return command_line_changed(s);
@@ -1798,13 +1801,16 @@ static int command_line_handle_key(CommandLineState *s)
     return command_line_not_changed(s);
 
   case Ctrl_A:            // all matches
-    if (nextwild(&s->xpc, WILD_ALL, 0, s->firstc != '@') == FAIL) {
-      break;
-    }
     if (cmdline_pum_active()) {
+      // As Ctrl-A completes all the matches, close the popup
+      // menu (if present)
       cmdline_pum_cleanup(&ccline);
-      s->xpc.xp_context = EXPAND_NOTHING;
     }
+    if (nextwild(&s->xpc, WILD_ALL, 0, s->firstc != '@') == FAIL) {
+      break;
+    }
+    s->xpc.xp_context = EXPAND_NOTHING;
+    s->did_wild_list = false;
     return command_line_changed(s);
 
   case Ctrl_L:
-- 
cgit 


From a4e4609d62c38b7b949e5c8079dfa5f10803bdcd Mon Sep 17 00:00:00 2001
From: sigmaSd <bedisnbiba@gmail.com>
Date: Wed, 24 Aug 2022 07:38:06 +0100
Subject: fix(path): path_is_url returns false for "foo:/" #19797

Problem:
path_to_url() returns false for single-slash URIs ("foo:/" vs "foo://").
This is not compliant with the URI spec. https://url.spec.whatwg.org/#url-representation
LSP in particular allows single-slash URIs.

Solution:
Relax path_to_url() to accept single-slash URIs. This is not fully
compliant (only ":" is required by the spec), but it is hopefully good
enough without causing false-positives in typical text files.

ref https://url.spec.whatwg.org/#windows-drive-letter
ref https://github.com/neovim/neovim/pull/19773
ref https://github.com/neovim/neovim/pull/19773#issuecomment-1214763769
---
 src/nvim/path.c   | 26 ++++++++++++++++++++++----
 src/nvim/window.c |  2 +-
 2 files changed, 23 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/path.c b/src/nvim/path.c
index d50ef87b62..ce0a7fb281 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -33,7 +33,7 @@
 #include "nvim/vim.h"
 #include "nvim/window.h"
 
-#define URL_SLASH       1               // path_is_url() has found "://"
+#define URL_SLASH       1               // path_is_url() has found ":/"
 #define URL_BACKSLASH   2               // path_is_url() has found ":\\"
 
 #ifdef gen_expand_wildcards
@@ -1751,12 +1751,26 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
   return file_name;
 }
 
-// Check if the "://" of a URL is at the pointer, return URL_SLASH.
+/// Checks for a Windows drive letter ("C:/") at the start of the path.
+///
+/// @see https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
+bool path_has_drive_letter(const char *p)
+  FUNC_ATTR_NONNULL_ALL
+{
+  return strlen(p) >= 2
+         && ASCII_ISALPHA(p[0])
+         && (p[1] == ':' || p[1] == '|')
+         && (strlen(p) == 2 || ((p[2] == '/') | (p[2] == '\\') | (p[2] == '?') | (p[2] == '#')));
+}
+
+// Check if the ":/" of a URL is at the pointer, return URL_SLASH.
 // Also check for ":\\", which MS Internet Explorer accepts, return
 // URL_BACKSLASH.
 int path_is_url(const char *p)
 {
-  if (strncmp(p, "://", 3) == 0) {
+  // In the spec ':' is enough to recognize a scheme
+  // https://url.spec.whatwg.org/#scheme-state
+  if (strncmp(p, ":/", 2) == 0) {
     return URL_SLASH;
   } else if (strncmp(p, ":\\\\", 3) == 0) {
     return URL_BACKSLASH;
@@ -1781,6 +1795,10 @@ int path_with_url(const char *fname)
     return 0;
   }
 
+  if (path_has_drive_letter(fname)) {
+    return 0;
+  }
+
   // check body: alpha or dash
   for (p = fname + 1; (isalpha(*p) || (*p == '-')); p++) {}
 
@@ -1789,7 +1807,7 @@ int path_with_url(const char *fname)
     return 0;
   }
 
-  // "://" or ":\\" must follow
+  // ":/" or ":\\" must follow
   return path_is_url(p);
 }
 
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 89611177f9..7ad5e49d2f 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6582,7 +6582,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
 
   /*
    * Search forward for the last char of the file name.
-   * Also allow "://" when ':' is not in 'isfname'.
+   * Also allow ":/" when ':' is not in 'isfname'.
    */
   len = 0;
   while (vim_isfilec(ptr[len]) || (ptr[len] == '\\' && ptr[len + 1] == ' ')
-- 
cgit 


From ef748af01d4f34766b95e7470fb0c6bf23bf17ad Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 13:33:15 +0800
Subject: vim-patch:8.2.3937: Insert mode completion function is too long

Problem:    Insert mode completion function is too long.
Solution:   Refactor into multiple functions. (Yegappan Lakshmanan,
            closes vim/vim#9423)
https://github.com/vim/vim/commit/edc6f103907a004b9e2265e232dc8be8bc594601

Cherry-pick a typo fix from patch 8.2.3637.
---
 src/nvim/insexpand.c                   | 745 +++++++++++++++++++--------------
 src/nvim/testdir/test_ins_complete.vim |  48 ++-
 2 files changed, 480 insertions(+), 313 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 938189f343..68acc3012b 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2464,6 +2464,422 @@ static bool thesaurus_func_complete(int type)
          && (*curbuf->b_p_tsrfu != NUL || *p_tsrfu != NUL);
 }
 
+/// Return value of process_next_cpt_value()
+enum {
+  INS_COMPL_CPT_OK = 1,
+  INS_COMPL_CPT_CONT,
+  INS_COMPL_CPT_END,
+};
+
+/// Process the next 'complete' option value in "e_cpt_arg".
+///
+/// If successful, the arguments are set as below:
+///   e_cpt_arg - pointer to the next option value in 'e_cpt_arg'
+///   compl_type_arg - type of insert mode completion to use
+///   found_all_arg - all matches of this type are found
+///   buf_arg - search for completions in this buffer
+///   first_match_pos - position of the first completion match
+///   last_match_pos - position of the last completion match
+///   set_match_pos - true if the first match position should be saved to avoid
+///                   loops after the search wraps around.
+///   dict - name of the dictionary or thesaurus file to search
+///   dict_f - flag specifying whether "dict" is an exact file name or not
+///
+/// @return  INS_COMPL_CPT_OK if the next value is processed successfully.
+///          INS_COMPL_CPT_CONT to skip the current value and process the next
+///          option value.
+///          INS_COMPL_CPT_END if all the values in "e_cpt" are processed.
+static int process_next_cpt_value(char **e_cpt_arg, int *compl_type_arg, bool *found_all_arg,
+                                  buf_T **buf_arg, pos_T *start_match_pos, pos_T *first_match_pos,
+                                  pos_T *last_match_pos, bool *set_match_pos, char_u **dict_arg,
+                                  int *dict_flag)
+{
+  char *e_cpt = *e_cpt_arg;
+  int compl_type = -1;
+  int status = INS_COMPL_CPT_OK;
+  buf_T *buf = *buf_arg;
+  bool found_all = false;
+  char_u *dict = NULL;
+  int dict_f = 0;
+
+  while (*e_cpt == ',' || *e_cpt == ' ') {
+    e_cpt++;
+  }
+  if (*e_cpt == '.' && !curbuf->b_scanned) {
+    buf = curbuf;
+    *first_match_pos = *start_match_pos;
+    // Move the cursor back one character so that ^N can match the
+    // word immediately after the cursor.
+    if (ctrl_x_mode_normal() && dec(first_match_pos) < 0) {
+      // Move the cursor to after the last character in the
+      // buffer, so that word at start of buffer is found
+      // correctly.
+      first_match_pos->lnum = buf->b_ml.ml_line_count;
+      first_match_pos->col = (colnr_T)STRLEN(ml_get(first_match_pos->lnum));
+    }
+    *last_match_pos = *first_match_pos;
+    compl_type = 0;
+
+    // Remember the first match so that the loop stops when we
+    // wrap and come back there a second time.
+    *set_match_pos = true;
+  } else if (vim_strchr("buwU", *e_cpt) != NULL
+             && (buf = ins_compl_next_buf(buf, *e_cpt)) != curbuf) {
+    // Scan a buffer, but not the current one.
+    if (buf->b_ml.ml_mfp != NULL) {  // loaded buffer
+      compl_started = true;
+      first_match_pos->col = last_match_pos->col = 0;
+      first_match_pos->lnum = buf->b_ml.ml_line_count + 1;
+      last_match_pos->lnum = 0;
+      compl_type = 0;
+    } else {  // unloaded buffer, scan like dictionary
+      found_all = true;
+      if (buf->b_fname == NULL) {
+        status = INS_COMPL_CPT_CONT;
+        goto done;
+      }
+      compl_type = CTRL_X_DICTIONARY;
+      dict = (char_u *)buf->b_fname;
+      dict_f = DICT_EXACT;
+    }
+    msg_hist_off = true;  // reset in msg_trunc_attr()
+    vim_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"),
+                 buf->b_fname == NULL
+                 ? buf_spname(buf)
+                 : buf->b_sfname == NULL
+                 ? buf->b_fname
+                 : buf->b_sfname);
+    (void)msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R));
+  } else if (*e_cpt == NUL) {
+    status = INS_COMPL_CPT_END;
+  } else {
+    if (ctrl_x_mode_line_or_eval()) {
+      compl_type = -1;
+    } else if (*e_cpt == 'k' || *e_cpt == 's') {
+      if (*e_cpt == 'k') {
+        compl_type = CTRL_X_DICTIONARY;
+      } else {
+        compl_type = CTRL_X_THESAURUS;
+      }
+      if (*++e_cpt != ',' && *e_cpt != NUL) {
+        dict = (char_u *)e_cpt;
+        dict_f = DICT_FIRST;
+      }
+    } else if (*e_cpt == 'i') {
+      compl_type = CTRL_X_PATH_PATTERNS;
+    } else if (*e_cpt == 'd') {
+      compl_type = CTRL_X_PATH_DEFINES;
+    } else if (*e_cpt == ']' || *e_cpt == 't') {
+      msg_hist_off = true;  // reset in msg_trunc_attr()
+      compl_type = CTRL_X_TAGS;
+      vim_snprintf((char *)IObuff, IOSIZE, "%s", _("Scanning tags."));
+      (void)msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R));
+    } else {
+      compl_type = -1;
+    }
+
+    // in any case e_cpt is advanced to the next entry
+    (void)copy_option_part(&e_cpt, (char *)IObuff, IOSIZE, ",");
+
+    found_all = true;
+    if (compl_type == -1) {
+      status = INS_COMPL_CPT_CONT;
+    }
+  }
+
+done:
+  *e_cpt_arg = e_cpt;
+  *compl_type_arg = compl_type;
+  *found_all_arg = found_all;
+  *buf_arg = buf;
+  *dict_arg = dict;
+  *dict_flag = dict_f;
+  return status;
+}
+
+/// Get the next set of identifiers or defines matching "compl_pattern" in
+/// included files.
+static void get_next_include_file_completion(int compl_type)
+{
+  find_pattern_in_path((char_u *)compl_pattern, compl_direction,
+                       STRLEN(compl_pattern), false, false,
+                       ((compl_type == CTRL_X_PATH_DEFINES
+                         && !(compl_cont_status & CONT_SOL))
+                        ? FIND_DEFINE : FIND_ANY),
+                       1L, ACTION_EXPAND, 1, MAXLNUM);
+}
+
+/// Get the next set of words matching "compl_pattern" in dictionary or
+/// thesaurus files.
+static void get_next_dict_tsr_completion(int compl_type, char_u **dict, int dict_f)
+{
+  if (thesaurus_func_complete(compl_type)) {
+    expand_by_function(compl_type, (char_u *)compl_pattern);
+  } else {
+    ins_compl_dictionaries(*dict != NULL ? *dict
+                           : (compl_type == CTRL_X_THESAURUS
+                              ? (*curbuf->b_p_tsr == NUL ? p_tsr : curbuf->b_p_tsr)
+                              : (*curbuf->b_p_dict == NUL ? p_dict : curbuf->b_p_dict)),
+                           (char_u *)compl_pattern,
+                           *dict != NULL ? dict_f : 0,
+                           compl_type == CTRL_X_THESAURUS);
+  }
+  *dict = NULL;
+}
+
+/// Get the next set of tag names matching "compl_pattern".
+static void get_next_tag_completion(void)
+{
+  // set p_ic according to p_ic, p_scs and pat for find_tags().
+  const int save_p_ic = p_ic;
+  p_ic = ignorecase((char_u *)compl_pattern);
+
+  // Find up to TAG_MANY matches.  Avoids that an enormous number
+  // of matches is found when compl_pattern is empty
+  g_tag_at_cursor = true;
+  char **matches;
+  int num_matches;
+  if (find_tags((char_u *)compl_pattern, &num_matches, &matches,
+                TAG_REGEXP | TAG_NAMES | TAG_NOIC | TAG_INS_COMP
+                | (ctrl_x_mode_not_default() ? TAG_VERBOSE : 0),
+                TAG_MANY, (char_u *)curbuf->b_ffname) == OK && num_matches > 0) {
+    ins_compl_add_matches(num_matches, matches, p_ic);
+  }
+  g_tag_at_cursor = false;
+  p_ic = save_p_ic;
+}
+
+/// Get the next set of filename matching "compl_pattern".
+static void get_next_filename_completion(void)
+{
+  char **matches;
+  int num_matches;
+  if (expand_wildcards(1, &compl_pattern, &num_matches, &matches,
+                       EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) != OK) {
+    return;
+  }
+
+  // May change home directory back to "~".
+  tilde_replace((char_u *)compl_pattern, num_matches, matches);
+#ifdef BACKSLASH_IN_FILENAME
+  if (curbuf->b_p_csl[0] != NUL) {
+    for (int i = 0; i < num_matches; i++) {
+      char_u *ptr = matches[i];
+      while (*ptr != NUL) {
+        if (curbuf->b_p_csl[0] == 's' && *ptr == '\\') {
+          *ptr = '/';
+        } else if (curbuf->b_p_csl[0] == 'b' && *ptr == '/') {
+          *ptr = '\\';
+        }
+        ptr += utfc_ptr2len(ptr);
+      }
+    }
+  }
+#endif
+  ins_compl_add_matches(num_matches, matches, p_fic || p_wic);
+}
+
+/// Get the next set of command-line completions matching "compl_pattern".
+static void get_next_cmdline_completion(void)
+{
+  char **matches;
+  int num_matches;
+  if (expand_cmdline(&compl_xp, (char_u *)compl_pattern,
+                     (int)STRLEN(compl_pattern),
+                     &num_matches, &matches) == EXPAND_OK) {
+    ins_compl_add_matches(num_matches, matches, false);
+  }
+}
+
+/// Get the next set of spell suggestions matching "compl_pattern".
+static void get_next_spell_completion(linenr_T lnum)
+{
+  char **matches;
+  int num_matches = expand_spelling(lnum, (char_u *)compl_pattern, &matches);
+  if (num_matches > 0) {
+    ins_compl_add_matches(num_matches, matches, p_ic);
+  }
+}
+
+/// Get the next set of words matching "compl_pattern" for default completion(s)
+/// (normal ^P/^N and ^X^L).
+/// Search for "compl_pattern" in the buffer "ins_buf" starting from the
+/// position "start_pos" in the "compl_direction" direction. If "save_match_pos"
+/// is true, then set the "first_match_pos" and "last_match_pos".
+///
+/// @param ins_buf          buffer being scanned
+/// @param start_pos        search start position
+/// @param cur_match_pos    current match position
+/// @param prev_match_pos   previous match position
+/// @param save_match_pos   set first_match_pos/last_match_pos
+/// @param first_match_pos  first match position
+/// @param last_match_pos   last match position
+/// @param scan_curbuf      scan current buffer for completion
+///
+/// @return  OK if a new next match is found, otherwise FAIL.
+static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *cur_match_pos,
+                                       pos_T *prev_match_pos, bool *save_match_pos,
+                                       pos_T *first_match_pos, pos_T *last_match_pos,
+                                       bool scan_curbuf)
+{
+  // If 'infercase' is set, don't use 'smartcase' here
+  const int save_p_scs = p_scs;
+  assert(ins_buf);
+  if (ins_buf->b_p_inf) {
+    p_scs = false;
+  }
+
+  // Buffers other than curbuf are scanned from the beginning or the
+  // end but never from the middle, thus setting nowrapscan in this
+  // buffers is a good idea, on the other hand, we always set
+  // wrapscan for curbuf to avoid missing matches -- Acevedo,Webb
+  const int save_p_ws = p_ws;
+  if (ins_buf != curbuf) {
+    p_ws = false;
+  } else if (scan_curbuf) {
+    p_ws = true;
+  }
+  bool looped_around = false;
+  int found_new_match = FAIL;
+  for (;;) {
+    bool cont_s_ipos = false;
+
+    msg_silent++;  // Don't want messages for wrapscan.
+    // ctrl_x_mode_line_or_eval() || word-wise search that
+    // has added a word that was at the beginning of the line.
+    if (ctrl_x_mode_line_or_eval()
+        || (compl_cont_status & CONT_SOL)) {
+      found_new_match = search_for_exact_line(ins_buf, cur_match_pos,
+                                              compl_direction, (char_u *)compl_pattern);
+    } else {
+      found_new_match = searchit(NULL, ins_buf, cur_match_pos, NULL,
+                                 compl_direction,
+                                 (char_u *)compl_pattern, 1L, SEARCH_KEEP + SEARCH_NFMSG,
+                                 RE_LAST, NULL);
+    }
+    msg_silent--;
+    if (!compl_started || *save_match_pos) {
+      // set "compl_started" even on fail
+      compl_started = true;
+      *first_match_pos = *cur_match_pos;
+      *last_match_pos = *cur_match_pos;
+      *save_match_pos = false;
+    } else if (first_match_pos->lnum == last_match_pos->lnum
+               && first_match_pos->col == last_match_pos->col) {
+      found_new_match = FAIL;
+    } else if ((compl_direction == FORWARD)
+               && (prev_match_pos->lnum > cur_match_pos->lnum
+                   || (prev_match_pos->lnum == cur_match_pos->lnum
+                       && prev_match_pos->col >= cur_match_pos->col))) {
+      if (looped_around) {
+        found_new_match = FAIL;
+      } else {
+        looped_around = true;
+      }
+    } else if ((compl_direction != FORWARD)
+               && (prev_match_pos->lnum < cur_match_pos->lnum
+                   || (prev_match_pos->lnum == cur_match_pos->lnum
+                       && prev_match_pos->col <= cur_match_pos->col))) {
+      if (looped_around) {
+        found_new_match = FAIL;
+      } else {
+        looped_around = true;
+      }
+    }
+    *prev_match_pos = *cur_match_pos;
+    if (found_new_match == FAIL) {
+      break;
+    }
+
+    // when ADDING, the text before the cursor matches, skip it
+    if ((compl_cont_status & CONT_ADDING) && ins_buf == curbuf
+        && start_pos->lnum == cur_match_pos->lnum
+        && start_pos->col == cur_match_pos->col) {
+      continue;
+    }
+    char_u *ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
+    int len;
+    if (ctrl_x_mode_line_or_eval()) {
+      if (compl_cont_status & CONT_ADDING) {
+        if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count) {
+          continue;
+        }
+        ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+        if (!p_paste) {
+          ptr = (char_u *)skipwhite((char *)ptr);
+        }
+      }
+      len = (int)STRLEN(ptr);
+    } else {
+      char_u *tmp_ptr = ptr;
+
+      if (compl_cont_status & CONT_ADDING) {
+        tmp_ptr += compl_length;
+        // Skip if already inside a word.
+        if (vim_iswordp(tmp_ptr)) {
+          continue;
+        }
+        // Find start of next word.
+        tmp_ptr = find_word_start(tmp_ptr);
+      }
+      // Find end of this word.
+      tmp_ptr = find_word_end(tmp_ptr);
+      len = (int)(tmp_ptr - ptr);
+
+      if ((compl_cont_status & CONT_ADDING) && len == compl_length) {
+        if (cur_match_pos->lnum < ins_buf->b_ml.ml_line_count) {
+          // Try next line, if any. the new word will be "join" as if the
+          // normal command "J" was used. IOSIZE is always greater than
+          // compl_length, so the next STRNCPY always works -- Acevedo
+          STRNCPY(IObuff, ptr, len);  // NOLINT(runtime/printf)
+          ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+          tmp_ptr = ptr = (char_u *)skipwhite((char *)ptr);
+          // Find start of next word.
+          tmp_ptr = find_word_start(tmp_ptr);
+          // Find end of next word.
+          tmp_ptr = find_word_end(tmp_ptr);
+          if (tmp_ptr > ptr) {
+            if (*ptr != ')' && IObuff[len - 1] != TAB) {
+              if (IObuff[len - 1] != ' ') {
+                IObuff[len++] = ' ';
+              }
+              // IObuf =~ "\k.* ", thus len >= 2
+              if (p_js
+                  && (IObuff[len - 2] == '.'
+                      || IObuff[len - 2] == '?'
+                      || IObuff[len - 2] == '!')) {
+                IObuff[len++] = ' ';
+              }
+            }
+            // copy as much as possible of the new word
+            if (tmp_ptr - ptr >= IOSIZE - len) {
+              tmp_ptr = ptr + IOSIZE - len - 1;
+            }
+            STRLCPY(IObuff + len, ptr, IOSIZE - len);
+            len += (int)(tmp_ptr - ptr);
+            cont_s_ipos = true;
+          }
+          IObuff[len] = NUL;
+          ptr = IObuff;
+        }
+        if (len == compl_length) {
+          continue;
+        }
+      }
+    }
+    if (ins_compl_add_infercase(ptr, len, p_ic,
+                                ins_buf == curbuf ? NULL : (char_u *)ins_buf->b_sfname,
+                                0, cont_s_ipos) != NOTDONE) {
+      found_new_match = OK;
+      break;
+    }
+  }
+  p_scs = save_p_scs;
+  p_ws = save_p_ws;
+
+  return found_new_match;
+}
+
 /// Get the next expansion(s), using "compl_pattern".
 /// The search starts at position "ini" in curbuf and in the direction
 /// compl_direction.
@@ -2481,16 +2897,9 @@ static int ins_compl_get_exp(pos_T *ini)
   static buf_T *ins_buf = NULL;          // buffer being scanned
 
   pos_T *pos;
-  char **matches;
-  int save_p_scs;
-  bool save_p_ws;
-  int save_p_ic;
   int i;
-  int num_matches;
-  int len;
   int found_new_match;
   int type = ctrl_x_mode;
-  char_u *ptr;
   char_u *dict = NULL;
   int dict_f = 0;
   bool set_match_pos;
@@ -2524,89 +2933,14 @@ static int ins_compl_get_exp(pos_T *ini)
     // entries from 'complete' that look in loaded buffers.
     if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval())
         && (!compl_started || found_all)) {
-      found_all = false;
-      while (*e_cpt == ',' || *e_cpt == ' ') {
-        e_cpt++;
-      }
-      if (*e_cpt == '.' && !curbuf->b_scanned) {
-        ins_buf = curbuf;
-        first_match_pos = *ini;
-        // Move the cursor back one character so that ^N can match the
-        // word immediately after the cursor.
-        if (ctrl_x_mode_normal() && dec(&first_match_pos) < 0) {
-          // Move the cursor to after the last character in the
-          // buffer, so that word at start of buffer is found
-          // correctly.
-          first_match_pos.lnum = ins_buf->b_ml.ml_line_count;
-          first_match_pos.col = (colnr_T)STRLEN(ml_get(first_match_pos.lnum));
-        }
-        last_match_pos = first_match_pos;
-        type = 0;
-
-        // Remember the first match so that the loop stops when we
-        // wrap and come back there a second time.
-        set_match_pos = true;
-      } else if (vim_strchr("buwU", *e_cpt) != NULL
-                 && (ins_buf = ins_compl_next_buf(ins_buf, *e_cpt)) != curbuf) {
-        // Scan a buffer, but not the current one.
-        if (ins_buf->b_ml.ml_mfp != NULL) {         // loaded buffer
-          compl_started = true;
-          first_match_pos.col = last_match_pos.col = 0;
-          first_match_pos.lnum = ins_buf->b_ml.ml_line_count + 1;
-          last_match_pos.lnum = 0;
-          type = 0;
-        } else {      // unloaded buffer, scan like dictionary
-          found_all = true;
-          if (ins_buf->b_fname == NULL) {
-            continue;
-          }
-          type = CTRL_X_DICTIONARY;
-          dict = (char_u *)ins_buf->b_fname;
-          dict_f = DICT_EXACT;
-        }
-        msg_hist_off = true;  // reset in msg_trunc_attr()
-        vim_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"),
-                     ins_buf->b_fname == NULL
-                     ? buf_spname(ins_buf)
-                     : ins_buf->b_sfname == NULL
-                     ? ins_buf->b_fname
-                     : ins_buf->b_sfname);
-        (void)msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R));
-      } else if (*e_cpt == NUL) {
+      int status = process_next_cpt_value(&e_cpt, &type, &found_all,
+                                          &ins_buf, ini, &first_match_pos, &last_match_pos,
+                                          &set_match_pos, &dict, &dict_f);
+      if (status == INS_COMPL_CPT_END) {
         break;
-      } else {
-        if (ctrl_x_mode_line_or_eval()) {
-          type = -1;
-        } else if (*e_cpt == 'k' || *e_cpt == 's') {
-          if (*e_cpt == 'k') {
-            type = CTRL_X_DICTIONARY;
-          } else {
-            type = CTRL_X_THESAURUS;
-          }
-          if (*++e_cpt != ',' && *e_cpt != NUL) {
-            dict = (char_u *)e_cpt;
-            dict_f = DICT_FIRST;
-          }
-        } else if (*e_cpt == 'i') {
-          type = CTRL_X_PATH_PATTERNS;
-        } else if (*e_cpt == 'd') {
-          type = CTRL_X_PATH_DEFINES;
-        } else if (*e_cpt == ']' || *e_cpt == 't') {
-          msg_hist_off = true;  // reset in msg_trunc_attr()
-          type = CTRL_X_TAGS;
-          vim_snprintf((char *)IObuff, IOSIZE, "%s", _("Scanning tags."));
-          (void)msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R));
-        } else {
-          type = -1;
-        }
-
-        // in any case e_cpt is advanced to the next entry
-        (void)copy_option_part(&e_cpt, (char *)IObuff, IOSIZE, ",");
-
-        found_all = true;
-        if (type == -1) {
-          continue;
-        }
+      }
+      if (status == INS_COMPL_CPT_CONT) {
+        continue;
       }
     }
 
@@ -2621,80 +2955,25 @@ static int ins_compl_get_exp(pos_T *ini)
       break;
     case CTRL_X_PATH_PATTERNS:
     case CTRL_X_PATH_DEFINES:
-      find_pattern_in_path((char_u *)compl_pattern, compl_direction,
-                           STRLEN(compl_pattern), false, false,
-                           ((type == CTRL_X_PATH_DEFINES
-                             && !(compl_cont_status & CONT_SOL))
-                            ? FIND_DEFINE
-                            : FIND_ANY),
-                           1L, ACTION_EXPAND, 1, MAXLNUM);
+      get_next_include_file_completion(type);
       break;
 
     case CTRL_X_DICTIONARY:
     case CTRL_X_THESAURUS:
-      if (thesaurus_func_complete(type)) {
-        expand_by_function(type, (char_u *)compl_pattern);
-      } else {
-        ins_compl_dictionaries(dict != NULL ? dict
-                               : (type == CTRL_X_THESAURUS
-                                  ? (*curbuf->b_p_tsr == NUL ? p_tsr : curbuf->b_p_tsr)
-                                  : (*curbuf->b_p_dict ==
-                                     NUL ? p_dict : curbuf->b_p_dict)),
-                               (char_u *)compl_pattern,
-                               dict != NULL ? dict_f : 0, type == CTRL_X_THESAURUS);
-      }
-      dict = NULL;
+      get_next_dict_tsr_completion(type, &dict, dict_f);
       break;
 
     case CTRL_X_TAGS:
-      // set p_ic according to p_ic, p_scs and pat for find_tags().
-      save_p_ic = p_ic;
-      p_ic = ignorecase((char_u *)compl_pattern);
-
-      // Find up to TAG_MANY matches.  Avoids that an enormous number
-      // of matches is found when compl_pattern is empty
-      g_tag_at_cursor = true;
-      if (find_tags((char_u *)compl_pattern, &num_matches, &matches,
-                    TAG_REGEXP | TAG_NAMES | TAG_NOIC | TAG_INS_COMP
-                    | (ctrl_x_mode_not_default() ? TAG_VERBOSE : 0),
-                    TAG_MANY, (char_u *)curbuf->b_ffname) == OK && num_matches > 0) {
-        ins_compl_add_matches(num_matches, matches, p_ic);
-      }
-      g_tag_at_cursor = false;
-      p_ic = save_p_ic;
+      get_next_tag_completion();
       break;
 
     case CTRL_X_FILES:
-      if (expand_wildcards(1, &compl_pattern, &num_matches, &matches,
-                           EW_FILE|EW_DIR|EW_ADDSLASH|EW_SILENT) == OK) {
-        // May change home directory back to "~".
-        tilde_replace((char_u *)compl_pattern, num_matches, matches);
-#ifdef BACKSLASH_IN_FILENAME
-        if (curbuf->b_p_csl[0] != NUL) {
-          for (int i = 0; i < num_matches; i++) {
-            char_u *ptr = matches[i];
-            while (*ptr != NUL) {
-              if (curbuf->b_p_csl[0] == 's' && *ptr == '\\') {
-                *ptr = '/';
-              } else if (curbuf->b_p_csl[0] == 'b' && *ptr == '/') {
-                *ptr = '\\';
-              }
-              ptr += utfc_ptr2len(ptr);
-            }
-          }
-        }
-#endif
-        ins_compl_add_matches(num_matches, matches, p_fic || p_wic);
-      }
+      get_next_filename_completion();
       break;
 
     case CTRL_X_CMDLINE:
     case CTRL_X_CMDLINE_CTRL_X:
-      if (expand_cmdline(&compl_xp, (char_u *)compl_pattern,
-                         (int)STRLEN(compl_pattern),
-                         &num_matches, &matches) == EXPAND_OK) {
-        ins_compl_add_matches(num_matches, matches, false);
-      }
+      get_next_cmdline_completion();
       break;
 
     case CTRL_X_FUNCTION:
@@ -2703,172 +2982,16 @@ static int ins_compl_get_exp(pos_T *ini)
       break;
 
     case CTRL_X_SPELL:
-      num_matches = expand_spelling(first_match_pos.lnum,
-                                    (char_u *)compl_pattern, &matches);
-      if (num_matches > 0) {
-        ins_compl_add_matches(num_matches, matches, p_ic);
-      }
+      get_next_spell_completion(first_match_pos.lnum);
       break;
 
     default:            // normal ^P/^N and ^X^L
-      // If 'infercase' is set, don't use 'smartcase' here
-      save_p_scs = p_scs;
-      assert(ins_buf);
-      if (ins_buf->b_p_inf) {
-        p_scs = false;
-      }
-
-      // Buffers other than curbuf are scanned from the beginning or the
-      // end but never from the middle, thus setting nowrapscan in this
-      // buffers is a good idea, on the other hand, we always set
-      // wrapscan for curbuf to avoid missing matches -- Acevedo,Webb
-      save_p_ws = p_ws;
-      if (ins_buf != curbuf) {
-        p_ws = false;
-      } else if (*e_cpt == '.') {
-        p_ws = true;
-      }
-      bool looped_around = false;
-      for (;;) {
-        bool cont_s_ipos = false;
-
-        msg_silent++;          // Don't want messages for wrapscan.
-        // ctrl_x_mode_line_or_eval() || word-wise search that
-        // has added a word that was at the beginning of the line.
-        if (ctrl_x_mode_line_or_eval()
-            || (compl_cont_status & CONT_SOL)) {
-          found_new_match = search_for_exact_line(ins_buf, pos,
-                                                  compl_direction,
-                                                  (char_u *)compl_pattern);
-        } else {
-          found_new_match = searchit(NULL, ins_buf, pos, NULL,
-                                     compl_direction,
-                                     (char_u *)compl_pattern, 1L,
-                                     SEARCH_KEEP + SEARCH_NFMSG,
-                                     RE_LAST, NULL);
-        }
-        msg_silent--;
-        if (!compl_started || set_match_pos) {
-          // set "compl_started" even on fail
-          compl_started = true;
-          first_match_pos = *pos;
-          last_match_pos = *pos;
-          set_match_pos = false;
-        } else if (first_match_pos.lnum == last_match_pos.lnum
-                   && first_match_pos.col == last_match_pos.col) {
-          found_new_match = FAIL;
-        } else if ((compl_direction == FORWARD)
-                   && (prev_pos.lnum > pos->lnum
-                       || (prev_pos.lnum == pos->lnum
-                           && prev_pos.col >= pos->col))) {
-          if (looped_around) {
-            found_new_match = FAIL;
-          } else {
-            looped_around = true;
-          }
-        } else if ((compl_direction != FORWARD)
-                   && (prev_pos.lnum < pos->lnum
-                       || (prev_pos.lnum == pos->lnum
-                           && prev_pos.col <= pos->col))) {
-          if (looped_around) {
-            found_new_match = FAIL;
-          } else {
-            looped_around = true;
-          }
-        }
-        prev_pos = *pos;
-        if (found_new_match == FAIL) {
-          if (ins_buf == curbuf) {
-            found_all = true;
-          }
-          break;
-        }
-
-        // when ADDING, the text before the cursor matches, skip it
-        if ((compl_cont_status & CONT_ADDING) && ins_buf == curbuf
-            && ini->lnum == pos->lnum
-            && ini->col == pos->col) {
-          continue;
-        }
-        ptr = ml_get_buf(ins_buf, pos->lnum, false) + pos->col;
-        if (ctrl_x_mode_line_or_eval()) {
-          if (compl_cont_status & CONT_ADDING) {
-            if (pos->lnum >= ins_buf->b_ml.ml_line_count) {
-              continue;
-            }
-            ptr = ml_get_buf(ins_buf, pos->lnum + 1, false);
-            if (!p_paste) {
-              ptr = (char_u *)skipwhite((char *)ptr);
-            }
-          }
-          len = (int)STRLEN(ptr);
-        } else {
-          char_u *tmp_ptr = ptr;
-
-          if (compl_cont_status & CONT_ADDING) {
-            tmp_ptr += compl_length;
-            // Skip if already inside a word.
-            if (vim_iswordp(tmp_ptr)) {
-              continue;
-            }
-            // Find start of next word.
-            tmp_ptr = find_word_start(tmp_ptr);
-          }
-          // Find end of this word.
-          tmp_ptr = find_word_end(tmp_ptr);
-          len = (int)(tmp_ptr - ptr);
-
-          if ((compl_cont_status & CONT_ADDING)
-              && len == compl_length) {
-            if (pos->lnum < ins_buf->b_ml.ml_line_count) {
-              // Try next line, if any. the new word will be "join" as if the
-              // normal command "J" was used. IOSIZE is always greater than
-              // compl_length, so the next STRNCPY always works -- Acevedo
-              STRNCPY(IObuff, ptr, len);  // NOLINT(runtime/printf)
-              ptr = ml_get_buf(ins_buf, pos->lnum + 1, false);
-              tmp_ptr = ptr = (char_u *)skipwhite((char *)ptr);
-              // Find start of next word.
-              tmp_ptr = find_word_start(tmp_ptr);
-              // Find end of next word.
-              tmp_ptr = find_word_end(tmp_ptr);
-              if (tmp_ptr > ptr) {
-                if (*ptr != ')' && IObuff[len - 1] != TAB) {
-                  if (IObuff[len - 1] != ' ') {
-                    IObuff[len++] = ' ';
-                  }
-                  // IObuf =~ "\k.* ", thus len >= 2
-                  if (p_js
-                      && (IObuff[len - 2] == '.'
-                          || IObuff[len - 2] == '?'
-                          || IObuff[len - 2] == '!')) {
-                    IObuff[len++] = ' ';
-                  }
-                }
-                // copy as much as possible of the new word
-                if (tmp_ptr - ptr >= IOSIZE - len) {
-                  tmp_ptr = ptr + IOSIZE - len - 1;
-                }
-                STRLCPY(IObuff + len, ptr, IOSIZE - len);
-                len += (int)(tmp_ptr - ptr);
-                cont_s_ipos = true;
-              }
-              IObuff[len] = NUL;
-              ptr = IObuff;
-            }
-            if (len == compl_length) {
-              continue;
-            }
-          }
-        }
-        if (ins_compl_add_infercase(ptr, len, p_ic,
-                                    ins_buf == curbuf ? NULL : (char_u *)ins_buf->b_sfname,
-                                    0, cont_s_ipos) != NOTDONE) {
-          found_new_match = OK;
-          break;
-        }
+      found_new_match = get_next_default_completion(ins_buf, ini, pos, &prev_pos,
+                                                    &set_match_pos, &first_match_pos,
+                                                    &last_match_pos, (*e_cpt == '.'));
+      if (found_new_match == FAIL && ins_buf == curbuf) {
+        found_all = true;
       }
-      p_scs = save_p_scs;
-      p_ws = save_p_ws;
     }
 
     // check if compl_curr_match has changed, (e.g. other type of
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 179218e48a..4cdede9cd0 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -44,11 +44,11 @@ func Test_ins_complete()
   exe "normal o\<C-X>\<C-P>\<C-P>\<C-X>\<C-X>\<C-N>\<C-X>\<C-N>\<C-N>"
   call assert_equal('run1 run2', getline('.'))
 
-  set cpt=.,w,i
+  set cpt=.,\ ,w,i
   " i-add-expands and switches to local
   exe "normal OM\<C-N>\<C-X>\<C-N>\<C-X>\<C-N>\<C-X>\<C-X>\<C-X>\<C-P>"
   call assert_equal("Makefile\tto\trun3", getline('.'))
-  " add-expands lines (it would end in an empty line if it didn't ignored
+  " add-expands lines (it would end in an empty line if it didn't ignore
   " itself)
   exe "normal o\<C-X>\<C-L>\<C-X>\<C-L>\<C-P>\<C-P>"
   call assert_equal("Makefile\tto\trun3", getline('.'))
@@ -721,6 +721,17 @@ func Test_complete_across_line()
   close!
 endfunc
 
+" Test for completing words with a '.' at the end of a word.
+func Test_complete_joinspaces()
+  new
+  call setline(1, ['one two.', 'three. four'])
+  set joinspaces
+  exe "normal Goon\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>"
+  call assert_equal("one two.  three. four", getline(3))
+  set joinspaces&
+  bw!
+endfunc
+
 " Test for using CTRL-L to add one character when completing matching
 func Test_complete_add_onechar()
   new
@@ -741,6 +752,39 @@ func Test_complete_add_onechar()
   close!
 endfunc
 
+" Test for using CTRL-X CTRL-L to complete whole lines lines
+func Test_complete_wholeline()
+  new
+  " complete one-line
+  call setline(1, ['a1', 'a2'])
+  exe "normal ggoa\<C-X>\<C-L>"
+  call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
+  " go to the next match (wrapping around the buffer)
+  exe "normal 2GCa\<C-X>\<C-L>\<C-N>"
+  call assert_equal(['a1', 'a', 'a2'], getline(1, '$'))
+  " go to the next match
+  exe "normal 2GCa\<C-X>\<C-L>\<C-N>\<C-N>"
+  call assert_equal(['a1', 'a2', 'a2'], getline(1, '$'))
+  exe "normal 2GCa\<C-X>\<C-L>\<C-N>\<C-N>\<C-N>"
+  call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
+  " repeat the test using CTRL-L
+  " go to the next match (wrapping around the buffer)
+  exe "normal 2GCa\<C-X>\<C-L>\<C-L>"
+  call assert_equal(['a1', 'a2', 'a2'], getline(1, '$'))
+  " go to the next match
+  exe "normal 2GCa\<C-X>\<C-L>\<C-L>\<C-L>"
+  call assert_equal(['a1', 'a', 'a2'], getline(1, '$'))
+  exe "normal 2GCa\<C-X>\<C-L>\<C-L>\<C-L>\<C-L>"
+  call assert_equal(['a1', 'a1', 'a2'], getline(1, '$'))
+  %d
+  " use CTRL-X CTRL-L to add one more line
+  call setline(1, ['a1', 'b1'])
+  setlocal complete=.
+  exe "normal ggOa\<C-X>\<C-L>\<C-X>\<C-L>\<C-X>\<C-L>"
+  call assert_equal(['a1', 'b1', '', 'a1', 'b1'], getline(1, '$'))
+  bw!
+endfunc
+
 " Test insert completion with 'cindent' (adjust the indent)
 func Test_complete_with_cindent()
   new
-- 
cgit 


From 9ac44c7f5daf28cd155942dbc697b51c6b3afdc0 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 13:15:38 +0800
Subject: vim-patch:8.2.3944: insert mode completion functions are too long

Problem:    Insert mode completion functions are too long.
Solution:   Split up into multiple functions. (Yegappan Lakshmanan,
            closes vim/vim#9431)
https://github.com/vim/vim/commit/5d2e007ccbfbd749a1f201d06965b8811ff50e6e

Cherry-pick can_cindent_get() -> get_can_cindent() from patch 8.1.2062.
---
 src/nvim/edit.c                        |    2 +-
 src/nvim/insexpand.c                   | 1222 ++++++++++++++++++--------------
 src/nvim/testdir/test_ins_complete.vim |   19 +
 3 files changed, 692 insertions(+), 551 deletions(-)

(limited to 'src')

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index a06cef82a2..545f3c0d9a 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -5654,7 +5654,7 @@ static char_u *do_insert_char_pre(int c)
   return res;
 }
 
-bool can_cindent_get(void)
+bool get_can_cindent(void)
 {
   return can_cindent;
 }
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 68acc3012b..d9f0c3419c 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1650,6 +1650,241 @@ void ins_compl_addfrommatch(void)
   ins_compl_addleader(c);
 }
 
+/// Set the CTRL-X completion mode based on the key 'c' typed after a CTRL-X.
+/// Uses the global variables: ctrl_x_mode, edit_submode, edit_submode_pre,
+/// compl_cont_mode and compl_cont_status.
+///
+/// @return  true when the character is not to be inserted.
+static bool set_ctrl_x_mode(const int c)
+{
+  bool retval = false;
+
+  switch (c) {
+  case Ctrl_E:
+  case Ctrl_Y:
+    // scroll the window one line up or down
+    ctrl_x_mode = CTRL_X_SCROLL;
+    if (!(State & REPLACE_FLAG)) {
+      edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)");
+    } else {
+      edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)");
+    }
+    edit_submode_pre = NULL;
+    showmode();
+    break;
+  case Ctrl_L:
+    // complete whole line
+    ctrl_x_mode = CTRL_X_WHOLE_LINE;
+    break;
+  case Ctrl_F:
+    // complete filenames
+    ctrl_x_mode = CTRL_X_FILES;
+    break;
+  case Ctrl_K:
+    // complete words from a dictionary
+    ctrl_x_mode = CTRL_X_DICTIONARY;
+    break;
+  case Ctrl_R:
+    // Register insertion without exiting CTRL-X mode
+    // Simply allow ^R to happen without affecting ^X mode
+    break;
+  case Ctrl_T:
+    // complete words from a thesaurus
+    ctrl_x_mode = CTRL_X_THESAURUS;
+    break;
+  case Ctrl_U:
+    // user defined completion
+    ctrl_x_mode = CTRL_X_FUNCTION;
+    break;
+  case Ctrl_O:
+    // omni completion
+    ctrl_x_mode = CTRL_X_OMNI;
+    break;
+  case 's':
+  case Ctrl_S:
+    // complete spelling suggestions
+    ctrl_x_mode = CTRL_X_SPELL;
+    emsg_off++;  // Avoid getting the E756 error twice.
+    spell_back_to_badword();
+    emsg_off--;
+    break;
+  case Ctrl_RSB:
+    // complete tag names
+    ctrl_x_mode = CTRL_X_TAGS;
+    break;
+  case Ctrl_I:
+  case K_S_TAB:
+    // complete keywords from included files
+    ctrl_x_mode = CTRL_X_PATH_PATTERNS;
+    break;
+  case Ctrl_D:
+    // complete definitions from included files
+    ctrl_x_mode = CTRL_X_PATH_DEFINES;
+    break;
+  case Ctrl_V:
+  case Ctrl_Q:
+    // complete vim commands
+    ctrl_x_mode = CTRL_X_CMDLINE;
+    break;
+  case Ctrl_Z:
+    // stop completion
+    ctrl_x_mode = CTRL_X_NORMAL;
+    edit_submode = NULL;
+    showmode();
+    retval = true;
+    break;
+  case Ctrl_P:
+  case Ctrl_N:
+    // ^X^P means LOCAL expansion if nothing interrupted (eg we
+    // just started ^X mode, or there were enough ^X's to cancel
+    // the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below)
+    // do normal expansion when interrupting a different mode (say
+    // ^X^F^X^P or ^P^X^X^P, see below)
+    // nothing changes if interrupting mode 0, (eg, the flag
+    // doesn't change when going to ADDING mode  -- Acevedo
+    if (!(compl_cont_status & CONT_INTRPT)) {
+      compl_cont_status |= CONT_LOCAL;
+    } else if (compl_cont_mode != 0) {
+      compl_cont_status &= ~CONT_LOCAL;
+    }
+    FALLTHROUGH;
+  default:
+    // If we have typed at least 2 ^X's... for modes != 0, we set
+    // compl_cont_status = 0 (eg, as if we had just started ^X
+    // mode).
+    // For mode 0, we set "compl_cont_mode" to an impossible
+    // value, in both cases ^X^X can be used to restart the same
+    // mode (avoiding ADDING mode).
+    // Undocumented feature: In a mode != 0 ^X^P and ^X^X^P start
+    // 'complete' and local ^P expansions respectively.
+    // In mode 0 an extra ^X is needed since ^X^P goes to ADDING
+    // mode  -- Acevedo
+    if (c == Ctrl_X) {
+      if (compl_cont_mode != 0) {
+        compl_cont_status = 0;
+      } else {
+        compl_cont_mode = CTRL_X_NOT_DEFINED_YET;
+      }
+    }
+    ctrl_x_mode = CTRL_X_NORMAL;
+    edit_submode = NULL;
+    showmode();
+    break;
+  }
+
+  return retval;
+}
+
+/// Stop insert completion mode
+static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
+{
+  // Get here when we have finished typing a sequence of ^N and
+  // ^P or other completion characters in CTRL-X mode.  Free up
+  // memory that was used, and make sure we can redo the insert.
+  if (compl_curr_match != NULL || compl_leader != NULL || c == Ctrl_E) {
+    // If any of the original typed text has been changed, eg when
+    // ignorecase is set, we must add back-spaces to the redo
+    // buffer.  We add as few as necessary to delete just the part
+    // of the original text that has changed.
+    // When using the longest match, edited the match or used
+    // CTRL-E then don't use the current match.
+    char_u *ptr;
+    if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) {
+      ptr = compl_curr_match->cp_str;
+    } else {
+      ptr = NULL;
+    }
+    ins_compl_fixRedoBufForLeader(ptr);
+  }
+
+  bool want_cindent = (get_can_cindent() && cindent_on());
+
+  // When completing whole lines: fix indent for 'cindent'.
+  // Otherwise, break line if it's too long.
+  if (compl_cont_mode == CTRL_X_WHOLE_LINE) {
+    // re-indent the current line
+    if (want_cindent) {
+      do_c_expr_indent();
+      want_cindent = false;                 // don't do it again
+    }
+  } else {
+    const int prev_col = curwin->w_cursor.col;
+
+    // put the cursor on the last char, for 'tw' formatting
+    if (prev_col > 0) {
+      dec_cursor();
+    }
+
+    // only format when something was inserted
+    if (!arrow_used && !ins_need_undo_get() && c != Ctrl_E) {
+      insertchar(NUL, 0, -1);
+    }
+
+    if (prev_col > 0
+        && get_cursor_line_ptr()[curwin->w_cursor.col] != NUL) {
+      inc_cursor();
+    }
+  }
+
+  // If the popup menu is displayed pressing CTRL-Y means accepting
+  // the selection without inserting anything.  When
+  // compl_enter_selects is set the Enter key does the same.
+  if ((c == Ctrl_Y || (compl_enter_selects
+                       && (c == CAR || c == K_KENTER || c == NL)))
+      && pum_visible()) {
+    retval = true;
+  }
+
+  // CTRL-E means completion is Ended, go back to the typed text.
+  // but only do this, if the Popup is still visible
+  if (c == Ctrl_E) {
+    ins_compl_delete();
+    if (compl_leader != NULL) {
+      ins_bytes(compl_leader + get_compl_len());
+    } else if (compl_first_match != NULL) {
+      ins_bytes(compl_orig_text + get_compl_len());
+    }
+    retval = true;
+  }
+
+  auto_format(false, true);
+
+  // Trigger the CompleteDonePre event to give scripts a chance to
+  // act upon the completion before clearing the info, and restore
+  // ctrl_x_mode, so that complete_info() can be used.
+  ctrl_x_mode = prev_mode;
+  ins_apply_autocmds(EVENT_COMPLETEDONEPRE);
+
+  ins_compl_free();
+  compl_started = false;
+  compl_matches = 0;
+  if (!shortmess(SHM_COMPLETIONMENU)) {
+    msg_clr_cmdline();  // necessary for "noshowmode"
+  }
+  ctrl_x_mode = CTRL_X_NORMAL;
+  compl_enter_selects = false;
+  if (edit_submode != NULL) {
+    edit_submode = NULL;
+    showmode();
+  }
+
+  if (c == Ctrl_C && cmdwin_type != 0) {
+    // Avoid the popup menu remains displayed when leaving the
+    // command line window.
+    update_screen(0);
+  }
+
+  // Indent now if a key was typed that is in 'cinkeys'.
+  if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) {
+    do_c_expr_indent();
+  }
+  // Trigger the CompleteDone event to give scripts a chance to act
+  // upon the end of completion.
+  ins_apply_autocmds(EVENT_COMPLETEDONE);
+
+  return retval;
+}
+
 /// Prepare for Insert mode completion, or stop it.
 /// Called just after typing a character in Insert mode.
 ///
@@ -1658,7 +1893,6 @@ void ins_compl_addfrommatch(void)
 /// @return true when the character is not to be inserted;
 bool ins_compl_prep(int c)
 {
-  char_u *ptr;
   bool retval = false;
   const int prev_mode = ctrl_x_mode;
 
@@ -1705,104 +1939,7 @@ bool ins_compl_prep(int c)
   if (ctrl_x_mode_not_defined_yet()) {
     // We have just typed CTRL-X and aren't quite sure which CTRL-X mode
     // it will be yet.  Now we decide.
-    switch (c) {
-    case Ctrl_E:
-    case Ctrl_Y:
-      ctrl_x_mode = CTRL_X_SCROLL;
-      if (!(State & REPLACE_FLAG)) {
-        edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)");
-      } else {
-        edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)");
-      }
-      edit_submode_pre = NULL;
-      showmode();
-      break;
-    case Ctrl_L:
-      ctrl_x_mode = CTRL_X_WHOLE_LINE;
-      break;
-    case Ctrl_F:
-      ctrl_x_mode = CTRL_X_FILES;
-      break;
-    case Ctrl_K:
-      ctrl_x_mode = CTRL_X_DICTIONARY;
-      break;
-    case Ctrl_R:
-      // Simply allow ^R to happen without affecting ^X mode
-      break;
-    case Ctrl_T:
-      ctrl_x_mode = CTRL_X_THESAURUS;
-      break;
-    case Ctrl_U:
-      ctrl_x_mode = CTRL_X_FUNCTION;
-      break;
-    case Ctrl_O:
-      ctrl_x_mode = CTRL_X_OMNI;
-      break;
-    case 's':
-    case Ctrl_S:
-      ctrl_x_mode = CTRL_X_SPELL;
-      emsg_off++;               // Avoid getting the E756 error twice.
-      spell_back_to_badword();
-      emsg_off--;
-      break;
-    case Ctrl_RSB:
-      ctrl_x_mode = CTRL_X_TAGS;
-      break;
-    case Ctrl_I:
-    case K_S_TAB:
-      ctrl_x_mode = CTRL_X_PATH_PATTERNS;
-      break;
-    case Ctrl_D:
-      ctrl_x_mode = CTRL_X_PATH_DEFINES;
-      break;
-    case Ctrl_V:
-    case Ctrl_Q:
-      ctrl_x_mode = CTRL_X_CMDLINE;
-      break;
-    case Ctrl_Z:
-      ctrl_x_mode = CTRL_X_NORMAL;
-      edit_submode = NULL;
-      showmode();
-      retval = true;
-      break;
-    case Ctrl_P:
-    case Ctrl_N:
-      // ^X^P means LOCAL expansion if nothing interrupted (eg we
-      // just started ^X mode, or there were enough ^X's to cancel
-      // the previous mode, say ^X^F^X^X^P or ^P^X^X^X^P, see below)
-      // do normal expansion when interrupting a different mode (say
-      // ^X^F^X^P or ^P^X^X^P, see below)
-      // nothing changes if interrupting mode 0, (eg, the flag
-      // doesn't change when going to ADDING mode  -- Acevedo
-      if (!(compl_cont_status & CONT_INTRPT)) {
-        compl_cont_status |= CONT_LOCAL;
-      } else if (compl_cont_mode != 0) {
-        compl_cont_status &= ~CONT_LOCAL;
-      }
-      FALLTHROUGH;
-    default:
-      // If we have typed at least 2 ^X's... for modes != 0, we set
-      // compl_cont_status = 0 (eg, as if we had just started ^X
-      // mode).
-      // For mode 0, we set "compl_cont_mode" to an impossible
-      // value, in both cases ^X^X can be used to restart the same
-      // mode (avoiding ADDING mode).
-      // Undocumented feature: In a mode != 0 ^X^P and ^X^X^P start
-      // 'complete' and local ^P expansions respectively.
-      // In mode 0 an extra ^X is needed since ^X^P goes to ADDING
-      // mode  -- Acevedo
-      if (c == Ctrl_X) {
-        if (compl_cont_mode != 0) {
-          compl_cont_status = 0;
-        } else {
-          compl_cont_mode = CTRL_X_NOT_DEFINED_YET;
-        }
-      }
-      ctrl_x_mode = CTRL_X_NORMAL;
-      edit_submode = NULL;
-      showmode();
-      break;
-    }
+    retval = set_ctrl_x_mode(c);
   } else if (ctrl_x_mode_not_default()) {
     // We're already in CTRL-X mode, do we stay in it?
     if (!vim_is_ctrl_x_key(c)) {
@@ -1827,107 +1964,7 @@ bool ins_compl_prep(int c)
          && c != Ctrl_R
          && !ins_compl_pum_key(c))
         || ctrl_x_mode == CTRL_X_FINISHED) {
-      // Get here when we have finished typing a sequence of ^N and
-      // ^P or other completion characters in CTRL-X mode.  Free up
-      // memory that was used, and make sure we can redo the insert.
-      if (compl_curr_match != NULL || compl_leader != NULL || c == Ctrl_E) {
-        // If any of the original typed text has been changed, eg when
-        // ignorecase is set, we must add back-spaces to the redo
-        // buffer.  We add as few as necessary to delete just the part
-        // of the original text that has changed.
-        // When using the longest match, edited the match or used
-        // CTRL-E then don't use the current match.
-        if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) {
-          ptr = compl_curr_match->cp_str;
-        } else {
-          ptr = NULL;
-        }
-        ins_compl_fixRedoBufForLeader(ptr);
-      }
-
-      bool want_cindent = (can_cindent_get() && cindent_on());
-
-      // When completing whole lines: fix indent for 'cindent'.
-      // Otherwise, break line if it's too long.
-      if (compl_cont_mode == CTRL_X_WHOLE_LINE) {
-        // re-indent the current line
-        if (want_cindent) {
-          do_c_expr_indent();
-          want_cindent = false;                 // don't do it again
-        }
-      } else {
-        int prev_col = curwin->w_cursor.col;
-
-        // put the cursor on the last char, for 'tw' formatting
-        if (prev_col > 0) {
-          dec_cursor();
-        }
-
-        if (!arrow_used && !ins_need_undo_get() && c != Ctrl_E) {
-          insertchar(NUL, 0, -1);
-        }
-
-        if (prev_col > 0
-            && get_cursor_line_ptr()[curwin->w_cursor.col] != NUL) {
-          inc_cursor();
-        }
-      }
-
-      // If the popup menu is displayed pressing CTRL-Y means accepting
-      // the selection without inserting anything.  When
-      // compl_enter_selects is set the Enter key does the same.
-      if ((c == Ctrl_Y || (compl_enter_selects
-                           && (c == CAR || c == K_KENTER || c == NL)))
-          && pum_visible()) {
-        retval = true;
-      }
-
-      // CTRL-E means completion is Ended, go back to the typed text.
-      // but only do this, if the Popup is still visible
-      if (c == Ctrl_E) {
-        ins_compl_delete();
-        if (compl_leader != NULL) {
-          ins_bytes(compl_leader + get_compl_len());
-        } else if (compl_first_match != NULL) {
-          ins_bytes(compl_orig_text + get_compl_len());
-        }
-        retval = true;
-      }
-
-      auto_format(false, true);
-
-      // Trigger the CompleteDonePre event to give scripts a chance to
-      // act upon the completion before clearing the info, and restore
-      // ctrl_x_mode, so that complete_info() can be used.
-      ctrl_x_mode = prev_mode;
-      ins_apply_autocmds(EVENT_COMPLETEDONEPRE);
-
-      ins_compl_free();
-      compl_started = false;
-      compl_matches = 0;
-      if (!shortmess(SHM_COMPLETIONMENU)) {
-        msg_clr_cmdline();                // necessary for "noshowmode"
-      }
-      ctrl_x_mode = CTRL_X_NORMAL;
-      compl_enter_selects = false;
-      if (edit_submode != NULL) {
-        edit_submode = NULL;
-        showmode();
-      }
-
-      // Avoid the popup menu remains displayed when leaving the
-      // command line window.
-      if (c == Ctrl_C && cmdwin_type != 0) {
-        update_screen(0);
-      }
-
-      // Indent now if a key was typed that is in 'cinkeys'.
-      if (want_cindent && in_cinkeys(KEY_COMPLETE, ' ', inindent(0))) {
-        do_c_expr_indent();
-      }
-      // Trigger the CompleteDone event to give scripts a chance to act
-      // upon the end of completion.
-      ins_apply_autocmds(EVENT_COMPLETEDONE);
+      retval = ins_compl_stop(c, prev_mode, retval);
     }
   } else if (ctrl_x_mode == CTRL_X_LOCAL_MSG) {
     // Trigger the CompleteDone event to give scripts a chance to act
@@ -2701,6 +2738,91 @@ static void get_next_spell_completion(linenr_T lnum)
   }
 }
 
+/// Return the next word or line from buffer "ins_buf" at position
+/// "cur_match_pos" for completion.  The length of the match is set in "len".
+/// @param ins_buf        buffer being scanned
+/// @param cur_match_pos  current match position
+/// @param match_len
+/// @param cont_s_ipos    next ^X<> will set initial_pos
+static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_pos, int *match_len,
+                                              bool *cont_s_ipos)
+{
+  *match_len = 0;
+  char_u *ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
+  int len;
+  if (ctrl_x_mode_line_or_eval()) {
+    if (compl_cont_status & CONT_ADDING) {
+      if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count) {
+        return NULL;
+      }
+      ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+      if (!p_paste) {
+        ptr = (char_u *)skipwhite((char *)ptr);
+      }
+    }
+    len = (int)STRLEN(ptr);
+  } else {
+    char_u *tmp_ptr = ptr;
+
+    if (compl_cont_status & CONT_ADDING) {
+      tmp_ptr += compl_length;
+      // Skip if already inside a word.
+      if (vim_iswordp(tmp_ptr)) {
+        return NULL;
+      }
+      // Find start of next word.
+      tmp_ptr = find_word_start(tmp_ptr);
+    }
+    // Find end of this word.
+    tmp_ptr = find_word_end(tmp_ptr);
+    len = (int)(tmp_ptr - ptr);
+
+    if ((compl_cont_status & CONT_ADDING) && len == compl_length) {
+      if (cur_match_pos->lnum < ins_buf->b_ml.ml_line_count) {
+        // Try next line, if any. the new word will be "join" as if the
+        // normal command "J" was used. IOSIZE is always greater than
+        // compl_length, so the next STRNCPY always works -- Acevedo
+        STRNCPY(IObuff, ptr, len);  // NOLINT(runtime/printf)
+        ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+        tmp_ptr = ptr = (char_u *)skipwhite((char *)ptr);
+        // Find start of next word.
+        tmp_ptr = find_word_start(tmp_ptr);
+        // Find end of next word.
+        tmp_ptr = find_word_end(tmp_ptr);
+        if (tmp_ptr > ptr) {
+          if (*ptr != ')' && IObuff[len - 1] != TAB) {
+            if (IObuff[len - 1] != ' ') {
+              IObuff[len++] = ' ';
+            }
+            // IObuf =~ "\k.* ", thus len >= 2
+            if (p_js
+                && (IObuff[len - 2] == '.'
+                    || IObuff[len - 2] == '?'
+                    || IObuff[len - 2] == '!')) {
+              IObuff[len++] = ' ';
+            }
+          }
+          // copy as much as possible of the new word
+          if (tmp_ptr - ptr >= IOSIZE - len) {
+            tmp_ptr = ptr + IOSIZE - len - 1;
+          }
+          STRLCPY(IObuff + len, ptr, IOSIZE - len);
+          len += (int)(tmp_ptr - ptr);
+          *cont_s_ipos = true;
+        }
+        IObuff[len] = NUL;
+        ptr = IObuff;
+      }
+      if (len == compl_length) {
+        return NULL;
+      }
+    }
+  }
+
+  *match_len = len;
+  return ptr;
+}
+
 /// Get the next set of words matching "compl_pattern" for default completion(s)
 /// (normal ^P/^N and ^X^L).
 /// Search for "compl_pattern" in the buffer "ins_buf" starting from the
@@ -2797,75 +2919,11 @@ static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *
         && start_pos->col == cur_match_pos->col) {
       continue;
     }
-    char_u *ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
     int len;
-    if (ctrl_x_mode_line_or_eval()) {
-      if (compl_cont_status & CONT_ADDING) {
-        if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count) {
-          continue;
-        }
-        ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
-        if (!p_paste) {
-          ptr = (char_u *)skipwhite((char *)ptr);
-        }
-      }
-      len = (int)STRLEN(ptr);
-    } else {
-      char_u *tmp_ptr = ptr;
-
-      if (compl_cont_status & CONT_ADDING) {
-        tmp_ptr += compl_length;
-        // Skip if already inside a word.
-        if (vim_iswordp(tmp_ptr)) {
-          continue;
-        }
-        // Find start of next word.
-        tmp_ptr = find_word_start(tmp_ptr);
-      }
-      // Find end of this word.
-      tmp_ptr = find_word_end(tmp_ptr);
-      len = (int)(tmp_ptr - ptr);
-
-      if ((compl_cont_status & CONT_ADDING) && len == compl_length) {
-        if (cur_match_pos->lnum < ins_buf->b_ml.ml_line_count) {
-          // Try next line, if any. the new word will be "join" as if the
-          // normal command "J" was used. IOSIZE is always greater than
-          // compl_length, so the next STRNCPY always works -- Acevedo
-          STRNCPY(IObuff, ptr, len);  // NOLINT(runtime/printf)
-          ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
-          tmp_ptr = ptr = (char_u *)skipwhite((char *)ptr);
-          // Find start of next word.
-          tmp_ptr = find_word_start(tmp_ptr);
-          // Find end of next word.
-          tmp_ptr = find_word_end(tmp_ptr);
-          if (tmp_ptr > ptr) {
-            if (*ptr != ')' && IObuff[len - 1] != TAB) {
-              if (IObuff[len - 1] != ' ') {
-                IObuff[len++] = ' ';
-              }
-              // IObuf =~ "\k.* ", thus len >= 2
-              if (p_js
-                  && (IObuff[len - 2] == '.'
-                      || IObuff[len - 2] == '?'
-                      || IObuff[len - 2] == '!')) {
-                IObuff[len++] = ' ';
-              }
-            }
-            // copy as much as possible of the new word
-            if (tmp_ptr - ptr >= IOSIZE - len) {
-              tmp_ptr = ptr + IOSIZE - len - 1;
-            }
-            STRLCPY(IObuff + len, ptr, IOSIZE - len);
-            len += (int)(tmp_ptr - ptr);
-            cont_s_ipos = true;
-          }
-          IObuff[len] = NUL;
-          ptr = IObuff;
-        }
-        if (len == compl_length) {
-          continue;
-        }
-      }
+    char_u *ptr = ins_comp_get_next_word_or_line(ins_buf, cur_match_pos, &len,
+                                                 &cont_s_ipos);
+    if (ptr == NULL) {
+      continue;
     }
     if (ins_compl_add_infercase(ptr, len, p_ic,
                                 ins_buf == curbuf ? NULL : (char_u *)ins_buf->b_sfname,
@@ -3060,6 +3118,31 @@ static int ins_compl_get_exp(pos_T *ini)
   return i;
 }
 
+/// Update "compl_shown_match" to the actually shown match, it may differ when
+/// "compl_leader" is used to omit some of the matches.
+static void ins_compl_update_shown_match(void)
+{
+  while (!ins_compl_equal(compl_shown_match,
+                          compl_leader, STRLEN(compl_leader))
+         && compl_shown_match->cp_next != NULL
+         && compl_shown_match->cp_next != compl_first_match) {
+    compl_shown_match = compl_shown_match->cp_next;
+  }
+
+  // If we didn't find it searching forward, and compl_shows_dir is
+  // backward, find the last match.
+  if (compl_shows_dir == BACKWARD
+      && !ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
+      && (compl_shown_match->cp_next == NULL
+          || compl_shown_match->cp_next == compl_first_match)) {
+    while (!ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
+           && compl_shown_match->cp_prev != NULL
+           && compl_shown_match->cp_prev != compl_first_match) {
+      compl_shown_match = compl_shown_match->cp_prev;
+    }
+  }
+}
+
 /// Delete the old text being completed.
 void ins_compl_delete(void)
 {
@@ -3096,82 +3179,54 @@ void ins_compl_insert(bool in_compl_func)
   }
 }
 
-/// Fill in the next completion in the current direction.
-/// If "allow_get_expansion" is true, then we may call ins_compl_get_exp() to
-/// get more completions.  If it is false, then we just do nothing when there
-/// are no more completions in a given direction.  The latter case is used when
-/// we are still in the middle of finding completions, to allow browsing
-/// through the ones found so far.
-/// @return  the total number of matches, or -1 if still unknown -- webb.
-///
-/// compl_curr_match is currently being used by ins_compl_get_exp(), so we use
-/// compl_shown_match here.
-///
-/// Note that this function may be called recursively once only.  First with
-/// "allow_get_expansion" true, which calls ins_compl_get_exp(), which in turn
-/// calls this function with "allow_get_expansion" false.
-///
-/// @param count          Repeat completion this many times; should be at least 1
-/// @param insert_match   Insert the newly selected match
-/// @param in_compl_func  Called from complete_check()
-static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match,
-                          bool in_compl_func)
+/// show the file name for the completion match (if any).  Truncate the file
+/// name to avoid a wait for return.
+static void ins_compl_show_filename(void)
 {
-  int num_matches = -1;
-  int todo = count;
-  compl_T *found_compl = NULL;
-  bool found_end = false;
-  const bool started = compl_started;
-
-  // When user complete function return -1 for findstart which is next
-  // time of 'always', compl_shown_match become NULL.
-  if (compl_shown_match == NULL) {
-    return -1;
+  char *const lead = _("match in file");
+  int space = sc_col - vim_strsize(lead) - 2;
+  if (space <= 0) {
+    return;
   }
 
-  if (compl_leader != NULL
-      && (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0) {
-    // Set "compl_shown_match" to the actually shown match, it may differ
-    // when "compl_leader" is used to omit some of the matches.
-    while (!ins_compl_equal(compl_shown_match,
-                            compl_leader, STRLEN(compl_leader))
-           && compl_shown_match->cp_next != NULL
-           && compl_shown_match->cp_next != compl_first_match) {
-      compl_shown_match = compl_shown_match->cp_next;
-    }
-
-    // If we didn't find it searching forward, and compl_shows_dir is
-    // backward, find the last match.
-    if (compl_shows_dir == BACKWARD
-        && !ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
-        && (compl_shown_match->cp_next == NULL
-            || compl_shown_match->cp_next == compl_first_match)) {
-      while (!ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
-             && compl_shown_match->cp_prev != NULL
-             && compl_shown_match->cp_prev != compl_first_match) {
-        compl_shown_match = compl_shown_match->cp_prev;
-      }
+  // We need the tail that fits.  With double-byte encoding going
+  // back from the end is very slow, thus go from the start and keep
+  // the text that fits in "space" between "s" and "e".
+  char *s;
+  char *e;
+  for (s = e = (char *)compl_shown_match->cp_fname; *e != NUL; MB_PTR_ADV(e)) {
+    space -= ptr2cells(e);
+    while (space < 0) {
+      space += ptr2cells(s);
+      MB_PTR_ADV(s);
     }
   }
+  msg_hist_off = true;
+  vim_snprintf((char *)IObuff, IOSIZE, "%s %s%s", lead,
+               (char_u *)s > compl_shown_match->cp_fname ? "<" : "", s);
+  msg((char *)IObuff);
+  msg_hist_off = false;
+  redraw_cmdline = false;  // don't overwrite!
+}
 
-  if (allow_get_expansion && insert_match
-      && (!(compl_get_longest || compl_restarting) || compl_used_match)) {
-    // Delete old text to be replaced
-    ins_compl_delete();
-  }
-
-  // When finding the longest common text we stick at the original text,
-  // don't let CTRL-N or CTRL-P move to the first match.
-  bool advance = count != 1 || !allow_get_expansion || !compl_get_longest;
-
-  // When restarting the search don't insert the first match either.
-  if (compl_restarting) {
-    advance = false;
-    compl_restarting = false;
-  }
+/// Find the next set of matches for completion. Repeat the completion 'todo'
+/// times.  The number of matches found is returned in 'num_matches'.
+///
+/// @param allow_get_expansion  If true, then ins_compl_get_exp() may be called to
+///                             get more completions.
+///                             If false, then do nothing when there are no more
+///                             completions in the given direction.
+/// @param todo  repeat completion this many times
+/// @param advance  If true, then completion will move to the first match.
+///                 Otherwise, the original text will be shown.
+///
+/// @return  OK on success and -1 if the number of matches are unknown.
+static int find_next_completion_match(bool allow_get_expansion, int todo, bool advance,
+                                      int *num_matches)
+{
+  bool found_end = false;
+  compl_T *found_compl = NULL;
 
-  // Repeat this for when <PageUp> or <PageDown> is typed.  But don't wrap
-  // around.
   while (--todo >= 0) {
     if (compl_shows_dir == FORWARD && compl_shown_match->cp_next != NULL) {
       compl_shown_match = compl_shown_match->cp_next;
@@ -3204,7 +3259,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
       }
 
       // Find matches.
-      num_matches = ins_compl_get_exp(&compl_startpos);
+      *num_matches = ins_compl_get_exp(&compl_startpos);
 
       // handle any pending completions
       while (compl_pending != 0 && compl_direction == compl_shows_dir
@@ -3242,6 +3297,69 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
     }
   }
 
+  return OK;
+}
+
+/// Fill in the next completion in the current direction.
+/// If "allow_get_expansion" is true, then we may call ins_compl_get_exp() to
+/// get more completions.  If it is false, then we just do nothing when there
+/// are no more completions in a given direction.  The latter case is used when
+/// we are still in the middle of finding completions, to allow browsing
+/// through the ones found so far.
+/// @return  the total number of matches, or -1 if still unknown -- webb.
+///
+/// compl_curr_match is currently being used by ins_compl_get_exp(), so we use
+/// compl_shown_match here.
+///
+/// Note that this function may be called recursively once only.  First with
+/// "allow_get_expansion" true, which calls ins_compl_get_exp(), which in turn
+/// calls this function with "allow_get_expansion" false.
+///
+/// @param count          Repeat completion this many times; should be at least 1
+/// @param insert_match   Insert the newly selected match
+/// @param in_compl_func  Called from complete_check()
+static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match,
+                          bool in_compl_func)
+{
+  int num_matches = -1;
+  int todo = count;
+  const bool started = compl_started;
+
+  // When user complete function return -1 for findstart which is next
+  // time of 'always', compl_shown_match become NULL.
+  if (compl_shown_match == NULL) {
+    return -1;
+  }
+
+  if (compl_leader != NULL
+      && (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0) {
+    // Update "compl_shown_match" to the actually shown match
+    ins_compl_update_shown_match();
+  }
+
+  if (allow_get_expansion && insert_match
+      && (!(compl_get_longest || compl_restarting) || compl_used_match)) {
+    // Delete old text to be replaced
+    ins_compl_delete();
+  }
+
+  // When finding the longest common text we stick at the original text,
+  // don't let CTRL-N or CTRL-P move to the first match.
+  bool advance = count != 1 || !allow_get_expansion || !compl_get_longest;
+
+  // When restarting the search don't insert the first match either.
+  if (compl_restarting) {
+    advance = false;
+    compl_restarting = false;
+  }
+
+  // Repeat this for when <PageUp> or <PageDown> is typed.  But don't wrap
+  // around.
+  if (find_next_completion_match(allow_get_expansion, todo, advance,
+                                 &num_matches) == -1) {
+    return -1;
+  }
+
   // Insert the text of the new completion, or the compl_leader.
   if (compl_no_insert && !started) {
     ins_bytes(compl_orig_text + get_compl_len());
@@ -3277,31 +3395,8 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
   }
 
   // Show the file name for the match (if any)
-  // Truncate the file name to avoid a wait for return.
   if (compl_shown_match->cp_fname != NULL) {
-    char *lead = _("match in file");
-    int space = sc_col - vim_strsize(lead) - 2;
-    char *s;
-    char *e;
-
-    if (space > 0) {
-      // We need the tail that fits.  With double-byte encoding going
-      // back from the end is very slow, thus go from the start and keep
-      // the text that fits in "space" between "s" and "e".
-      for (s = e = (char *)compl_shown_match->cp_fname; *e != NUL; MB_PTR_ADV(e)) {
-        space -= ptr2cells(e);
-        while (space < 0) {
-          space += ptr2cells(s);
-          MB_PTR_ADV(s);
-        }
-      }
-      msg_hist_off = true;
-      vim_snprintf((char *)IObuff, IOSIZE, "%s %s%s", lead,
-                   (char_u *)s > compl_shown_match->cp_fname ? "<" : "", s);
-      msg((char *)IObuff);
-      msg_hist_off = false;
-      redraw_cmdline = false;     // don't overwrite!
-    }
+    ins_compl_show_filename();
   }
 
   return num_matches;
@@ -3711,221 +3806,182 @@ static int compl_get_info(char_u *line, int startcol, colnr_T curs_col, bool *li
   return OK;
 }
 
-/// Do Insert mode completion.
-/// Called when character "c" was typed, which has a meaning for completion.
-/// Returns OK if completion was done, FAIL if something failed.
-int ins_complete(int c, bool enable_pum)
+/// Continue an interrupted completion mode search in "line".
+///
+/// If this same ctrl_x_mode has been interrupted use the text from
+/// "compl_startpos" to the cursor as a pattern to add a new word instead of
+/// expand the one before the cursor, in word-wise if "compl_startpos" is not in
+/// the same line as the cursor then fix it (the line has been split because it
+/// was longer than 'tw').  if SOL is set then skip the previous pattern, a word
+/// at the beginning of the line has been inserted, we'll look for that.
+static void ins_compl_continue_search(char_u *line)
 {
-  char_u *line;
-  int startcol = 0;                 // column where searched text starts
-  colnr_T curs_col;                 // cursor column
-  int n;
-  int save_w_wrow;
-  int save_w_leftcol;
-  int insert_match;
-  const bool save_did_ai = did_ai;
-  int flags = CP_ORIGINAL_TEXT;
-  bool line_invalid = false;
-
-  compl_direction = ins_compl_key2dir(c);
-  insert_match = ins_compl_use_match(c);
-
-  if (!compl_started) {
-    // First time we hit ^N or ^P (in a row, I mean)
-
-    did_ai = false;
-    did_si = false;
-    can_si = false;
-    can_si_back = false;
-    if (stop_arrow() == FAIL) {
-      return FAIL;
-    }
-
-    line = ml_get(curwin->w_cursor.lnum);
-    curs_col = curwin->w_cursor.col;
-    compl_pending = 0;
-
-    // If this same ctrl_x_mode has been interrupted use the text from
-    // "compl_startpos" to the cursor as a pattern to add a new word
-    // instead of expand the one before the cursor, in word-wise if
-    // "compl_startpos" is not in the same line as the cursor then fix it
-    // (the line has been split because it was longer than 'tw').  if SOL
-    // is set then skip the previous pattern, a word at the beginning of
-    // the line has been inserted, we'll look for that  -- Acevedo.
-    if ((compl_cont_status & CONT_INTRPT) == CONT_INTRPT
-        && compl_cont_mode == ctrl_x_mode) {
-      // it is a continued search
-      compl_cont_status &= ~CONT_INTRPT;        // remove INTRPT
-      if (ctrl_x_mode_normal()
-          || ctrl_x_mode_path_patterns()
-          || ctrl_x_mode_path_defines()) {
-        if (compl_startpos.lnum != curwin->w_cursor.lnum) {
-          // line (probably) wrapped, set compl_startpos to the
-          // first non_blank in the line, if it is not a wordchar
-          // include it to get a better pattern, but then we don't
-          // want the "\\<" prefix, check it below.
-          compl_col = (colnr_T)getwhitecols(line);
-          compl_startpos.col = compl_col;
-          compl_startpos.lnum = curwin->w_cursor.lnum;
-          compl_cont_status &= ~CONT_SOL;             // clear SOL if present
-        } else {
-          // S_IPOS was set when we inserted a word that was at the
-          // beginning of the line, which means that we'll go to SOL
-          // mode but first we need to redefine compl_startpos
-          if (compl_cont_status & CONT_S_IPOS) {
-            compl_cont_status |= CONT_SOL;
-            compl_startpos.col = (colnr_T)((char_u *)skipwhite((char *)line
-                                                               + compl_length
-                                                               + compl_startpos.col) - line);
-          }
-          compl_col = compl_startpos.col;
-        }
-        compl_length = curwin->w_cursor.col - (int)compl_col;
-        // IObuff is used to add a "word from the next line" would we
-        // have enough space?  just being paranoid
-#define MIN_SPACE 75
-        if (compl_length > (IOSIZE - MIN_SPACE)) {
-          compl_cont_status &= ~CONT_SOL;
-          compl_length = (IOSIZE - MIN_SPACE);
-          compl_col = curwin->w_cursor.col - compl_length;
-        }
-        compl_cont_status |= CONT_ADDING | CONT_N_ADDS;
-        if (compl_length < 1) {
-          compl_cont_status &= CONT_LOCAL;
-        }
-      } else if (ctrl_x_mode_line_or_eval()) {
-        compl_cont_status = CONT_ADDING | CONT_N_ADDS;
-      } else {
-        compl_cont_status = 0;
-      }
+  // it is a continued search
+  compl_cont_status &= ~CONT_INTRPT;  // remove INTRPT
+  if (ctrl_x_mode_normal()
+      || ctrl_x_mode_path_patterns()
+      || ctrl_x_mode_path_defines()) {
+    if (compl_startpos.lnum != curwin->w_cursor.lnum) {
+      // line (probably) wrapped, set compl_startpos to the
+      // first non_blank in the line, if it is not a wordchar
+      // include it to get a better pattern, but then we don't
+      // want the "\\<" prefix, check it below.
+      compl_col = (colnr_T)getwhitecols(line);
+      compl_startpos.col = compl_col;
+      compl_startpos.lnum = curwin->w_cursor.lnum;
+      compl_cont_status &= ~CONT_SOL;  // clear SOL if present
     } else {
-      compl_cont_status &= CONT_LOCAL;
-    }
-
-    if (!(compl_cont_status & CONT_ADDING)) {   // normal expansion
-      compl_cont_mode = ctrl_x_mode;
-      if (ctrl_x_mode_not_default()) {
-        // Remove LOCAL if ctrl_x_mode != CTRL_X_NORMAL
-        compl_cont_status = 0;
+      // S_IPOS was set when we inserted a word that was at the
+      // beginning of the line, which means that we'll go to SOL
+      // mode but first we need to redefine compl_startpos
+      if (compl_cont_status & CONT_S_IPOS) {
+        compl_cont_status |= CONT_SOL;
+        compl_startpos.col = (colnr_T)((char_u *)skipwhite((char *)line
+                                                           + compl_length
+                                                           + compl_startpos.col) - line);
       }
-      compl_cont_status |= CONT_N_ADDS;
-      compl_startpos = curwin->w_cursor;
-      startcol = (int)curs_col;
-      compl_col = 0;
+      compl_col = compl_startpos.col;
     }
-
-    // Work out completion pattern and original text -- webb
-    if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL) {
-      if (ctrl_x_mode_function() || ctrl_x_mode_omni()
-          || thesaurus_func_complete(ctrl_x_mode)) {
-        // restore did_ai, so that adding comment leader works
-        did_ai = save_did_ai;
-      }
-      return FAIL;
+    compl_length = curwin->w_cursor.col - (int)compl_col;
+    // IObuff is used to add a "word from the next line" would we
+    // have enough space?  just being paranoid
+#define MIN_SPACE 75
+    if (compl_length > (IOSIZE - MIN_SPACE)) {
+      compl_cont_status &= ~CONT_SOL;
+      compl_length = (IOSIZE - MIN_SPACE);
+      compl_col = curwin->w_cursor.col - compl_length;
     }
-    // If "line" was changed while getting completion info get it again.
-    if (line_invalid) {
-      line = ml_get(curwin->w_cursor.lnum);
+    compl_cont_status |= CONT_ADDING | CONT_N_ADDS;
+    if (compl_length < 1) {
+      compl_cont_status &= CONT_LOCAL;
     }
+  } else if (ctrl_x_mode_line_or_eval()) {
+    compl_cont_status = CONT_ADDING | CONT_N_ADDS;
+  } else {
+    compl_cont_status = 0;
+  }
+}
 
-    if (compl_cont_status & CONT_ADDING) {
-      edit_submode_pre = (char_u *)_(" Adding");
-      if (ctrl_x_mode_line_or_eval()) {
-        // Insert a new line, keep indentation but ignore 'comments'.
-        char_u *old = curbuf->b_p_com;
-
-        curbuf->b_p_com = (char_u *)"";
-        compl_startpos.lnum = curwin->w_cursor.lnum;
-        compl_startpos.col = compl_col;
-        ins_eol('\r');
-        curbuf->b_p_com = old;
-        compl_length = 0;
-        compl_col = curwin->w_cursor.col;
-      }
-    } else {
-      edit_submode_pre = NULL;
-      compl_startpos.col = compl_col;
-    }
+/// start insert mode completion
+static int ins_compl_start(void)
+{
+  const bool save_did_ai = did_ai;
 
-    if (compl_cont_status & CONT_LOCAL) {
-      edit_submode = (char_u *)_(ctrl_x_msgs[CTRL_X_LOCAL_MSG]);
-    } else {
-      edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode));
-    }
+  // First time we hit ^N or ^P (in a row, I mean)
 
-    // If any of the original typed text has been changed we need to fix
-    // the redo buffer.
-    ins_compl_fixRedoBufForLeader(NULL);
+  did_ai = false;
+  did_si = false;
+  can_si = false;
+  can_si_back = false;
+  if (stop_arrow() == FAIL) {
+    return FAIL;
+  }
 
-    // Always add completion for the original text.
-    xfree(compl_orig_text);
-    compl_orig_text = vim_strnsave(line + compl_col, (size_t)compl_length);
-    if (p_ic) {
-      flags |= CP_ICASE;
-    }
-    if (ins_compl_add(compl_orig_text, -1, NULL, NULL, false, NULL, 0,
-                      flags, false) != OK) {
-      XFREE_CLEAR(compl_pattern);
-      XFREE_CLEAR(compl_orig_text);
-      return FAIL;
+  char_u *line = ml_get(curwin->w_cursor.lnum);
+  colnr_T curs_col = curwin->w_cursor.col;
+  compl_pending = 0;
+
+  if ((compl_cont_status & CONT_INTRPT) == CONT_INTRPT
+      && compl_cont_mode == ctrl_x_mode) {
+    // this same ctrl-x_mode was interrupted previously. Continue the
+    // completion.
+    ins_compl_continue_search(line);
+  } else {
+    compl_cont_status &= CONT_LOCAL;
+  }
+
+  int startcol = 0;  // column where searched text starts
+  if (!(compl_cont_status & CONT_ADDING)) {   // normal expansion
+    compl_cont_mode = ctrl_x_mode;
+    if (ctrl_x_mode_not_default()) {
+      // Remove LOCAL if ctrl_x_mode != CTRL_X_NORMAL
+      compl_cont_status = 0;
     }
+    compl_cont_status |= CONT_N_ADDS;
+    compl_startpos = curwin->w_cursor;
+    startcol = (int)curs_col;
+    compl_col = 0;
+  }
 
-    // showmode might reset the internal line pointers, so it must
-    // be called before line = ml_get(), or when this address is no
-    // longer needed.  -- Acevedo.
-    edit_submode_extra = (char_u *)_("-- Searching...");
-    edit_submode_highl = HLF_COUNT;
-    showmode();
-    edit_submode_extra = NULL;
-    ui_flush();
-  } else if (insert_match && stop_arrow() == FAIL) {
+  // Work out completion pattern and original text -- webb
+  bool line_invalid = false;
+  if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL) {
+    if (ctrl_x_mode_function() || ctrl_x_mode_omni()
+        || thesaurus_func_complete(ctrl_x_mode)) {
+      // restore did_ai, so that adding comment leader works
+      did_ai = save_did_ai;
+    }
     return FAIL;
   }
+  // If "line" was changed while getting completion info get it again.
+  if (line_invalid) {
+    line = ml_get(curwin->w_cursor.lnum);
+  }
 
-  compl_shown_match = compl_curr_match;
-  compl_shows_dir = compl_direction;
+  if (compl_cont_status & CONT_ADDING) {
+    edit_submode_pre = (char_u *)_(" Adding");
+    if (ctrl_x_mode_line_or_eval()) {
+      // Insert a new line, keep indentation but ignore 'comments'.
+      char_u *old = curbuf->b_p_com;
 
-  // Find next match (and following matches).
-  save_w_wrow = curwin->w_wrow;
-  save_w_leftcol = curwin->w_leftcol;
-  n = ins_compl_next(true, ins_compl_key2count(c), insert_match, false);
+      curbuf->b_p_com = (char_u *)"";
+      compl_startpos.lnum = curwin->w_cursor.lnum;
+      compl_startpos.col = compl_col;
+      ins_eol('\r');
+      curbuf->b_p_com = old;
+      compl_length = 0;
+      compl_col = curwin->w_cursor.col;
+    }
+  } else {
+    edit_submode_pre = NULL;
+    compl_startpos.col = compl_col;
+  }
 
-  if (n > 1) {          // all matches have been found
-    compl_matches = n;
+  if (compl_cont_status & CONT_LOCAL) {
+    edit_submode = (char_u *)_(ctrl_x_msgs[CTRL_X_LOCAL_MSG]);
+  } else {
+    edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode));
   }
-  compl_curr_match = compl_shown_match;
-  compl_direction = compl_shows_dir;
 
-  // Eat the ESC that vgetc() returns after a CTRL-C to avoid leaving Insert
-  // mode.
-  if (got_int && !global_busy) {
-    (void)vgetc();
-    got_int = false;
+  // If any of the original typed text has been changed we need to fix
+  // the redo buffer.
+  ins_compl_fixRedoBufForLeader(NULL);
+
+  // Always add completion for the original text.
+  xfree(compl_orig_text);
+  compl_orig_text = vim_strnsave(line + compl_col, (size_t)compl_length);
+  int flags = CP_ORIGINAL_TEXT;
+  if (p_ic) {
+    flags |= CP_ICASE;
+  }
+  if (ins_compl_add(compl_orig_text, -1, NULL, NULL, false, NULL, 0,
+                    flags, false) != OK) {
+    XFREE_CLEAR(compl_pattern);
+    XFREE_CLEAR(compl_orig_text);
+    return FAIL;
   }
 
+  // showmode might reset the internal line pointers, so it must
+  // be called before line = ml_get(), or when this address is no
+  // longer needed.  -- Acevedo.
+  edit_submode_extra = (char_u *)_("-- Searching...");
+  edit_submode_highl = HLF_COUNT;
+  showmode();
+  edit_submode_extra = NULL;
+  ui_flush();
+
+  return OK;
+}
+
+/// display the completion status message
+static void ins_compl_show_statusmsg(void)
+{
   // we found no match if the list has only the "compl_orig_text"-entry
   if (compl_first_match == compl_first_match->cp_next) {
     edit_submode_extra = (compl_cont_status & CONT_ADDING)
                          && compl_length > 1
                          ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf);
     edit_submode_highl = HLF_E;
-    // remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode,
-    // because we couldn't expand anything at first place, but if we used
-    // ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word
-    // (such as M in M'exico) if not tried already.  -- Acevedo
-    if (compl_length > 1
-        || (compl_cont_status & CONT_ADDING)
-        || (ctrl_x_mode_not_default()
-            && !ctrl_x_mode_path_patterns()
-            && !ctrl_x_mode_path_defines())) {
-      compl_cont_status &= ~CONT_N_ADDS;
-    }
-  }
-
-  if (compl_curr_match->cp_flags & CP_CONT_S_IPOS) {
-    compl_cont_status |= CONT_S_IPOS;
-  } else {
-    compl_cont_status &= ~CONT_S_IPOS;
   }
 
   if (edit_submode_extra == NULL) {
@@ -3985,6 +4041,72 @@ int ins_complete(int c, bool enable_pum)
       msg_clr_cmdline();  // necessary for "noshowmode"
     }
   }
+}
+
+/// Do Insert mode completion.
+/// Called when character "c" was typed, which has a meaning for completion.
+/// Returns OK if completion was done, FAIL if something failed.
+int ins_complete(int c, bool enable_pum)
+{
+  int n;
+  int save_w_wrow;
+  int save_w_leftcol;
+  int insert_match;
+
+  compl_direction = ins_compl_key2dir(c);
+  insert_match = ins_compl_use_match(c);
+
+  if (!compl_started) {
+    if (ins_compl_start() == FAIL) {
+      return FAIL;
+    }
+  } else if (insert_match && stop_arrow() == FAIL) {
+    return FAIL;
+  }
+
+  compl_shown_match = compl_curr_match;
+  compl_shows_dir = compl_direction;
+
+  // Find next match (and following matches).
+  save_w_wrow = curwin->w_wrow;
+  save_w_leftcol = curwin->w_leftcol;
+  n = ins_compl_next(true, ins_compl_key2count(c), insert_match, false);
+
+  if (n > 1) {          // all matches have been found
+    compl_matches = n;
+  }
+  compl_curr_match = compl_shown_match;
+  compl_direction = compl_shows_dir;
+
+  // Eat the ESC that vgetc() returns after a CTRL-C to avoid leaving Insert
+  // mode.
+  if (got_int && !global_busy) {
+    (void)vgetc();
+    got_int = false;
+  }
+
+  // we found no match if the list has only the "compl_orig_text"-entry
+  if (compl_first_match == compl_first_match->cp_next) {
+    // remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode,
+    // because we couldn't expand anything at first place, but if we used
+    // ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word
+    // (such as M in M'exico) if not tried already.  -- Acevedo
+    if (compl_length > 1
+        || (compl_cont_status & CONT_ADDING)
+        || (ctrl_x_mode_not_default()
+            && !ctrl_x_mode_path_patterns()
+            && !ctrl_x_mode_path_defines())) {
+      compl_cont_status &= ~CONT_N_ADDS;
+    }
+  }
+
+  if (compl_curr_match->cp_flags & CP_CONT_S_IPOS) {
+    compl_cont_status |= CONT_S_IPOS;
+  } else {
+    compl_cont_status &= ~CONT_S_IPOS;
+  }
+
+  ins_compl_show_statusmsg();
 
   // Show the popup menu, unless we got interrupted.
   if (enable_pum && !compl_interrupted) {
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 4cdede9cd0..6f5f72e1ed 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -873,6 +873,25 @@ func Test_complete_stop()
   close!
 endfunc
 
+" Test for typing CTRL-R in insert completion mode to insert a register
+" content.
+func Test_complete_reginsert()
+  new
+  call setline(1, ['a1', 'a12', 'a123', 'a1234'])
+
+  " if a valid CTRL-X mode key is returned from <C-R>=, then it should be
+  " processed. Otherwise, CTRL-X mode should be stopped and the key should be
+  " inserted.
+  exe "normal Goa\<C-P>\<C-R>=\"\\<C-P>\"\<CR>"
+  call assert_equal('a123', getline(5))
+  let @r = "\<C-P>\<C-P>"
+  exe "normal GCa\<C-P>\<C-R>r"
+  call assert_equal('a12', getline(5))
+  exe "normal GCa\<C-P>\<C-R>=\"x\"\<CR>"
+  call assert_equal('a1234x', getline(5))
+  bw!
+endfunc
+
 func Test_issue_7021()
   CheckMSWindows
 
-- 
cgit 


From b0569f5813a019d5fe7a921b9d01f26eb1854b8d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 16:59:03 +0800
Subject: vim-patch:9.0.0020: with some completion reading past end of string
 (#19922)

Problem:    With some completion reading past end of string.
Solution:   Check the length of the string.
https://github.com/vim/vim/commit/f12129f1714f7d2301935bb21d896609bdac221c
---
 src/nvim/insexpand.c                   | 12 ++++++++++--
 src/nvim/testdir/test_ins_complete.vim |  8 ++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index d9f0c3419c..5655b31df1 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1839,10 +1839,18 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
   // but only do this, if the Popup is still visible
   if (c == Ctrl_E) {
     ins_compl_delete();
+    char_u *p = NULL;
     if (compl_leader != NULL) {
-      ins_bytes(compl_leader + get_compl_len());
+      p = compl_leader;
     } else if (compl_first_match != NULL) {
-      ins_bytes(compl_orig_text + get_compl_len());
+      p = compl_orig_text;
+    }
+    if (p != NULL) {
+      const int compl_len = get_compl_len();
+      const int len = (int)STRLEN(p);
+      if (len > compl_len) {
+        ins_bytes_len(p + compl_len, (size_t)(len - compl_len));
+      }
     }
     retval = true;
   }
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 6f5f72e1ed..54d3844100 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -947,4 +947,12 @@ func Test_complete_smartindent()
   delfunction! FooBarComplete
 endfunc
 
+func Test_complete_overrun()
+  " this was going past the end of the copied text
+  new
+  sil norm si”0s0
+  bwipe!
+endfunc
+
+
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From bcf5ee328e228d5a536b4de2069a79234f9f3e9e Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Tue, 23 Aug 2022 10:36:46 +0200
Subject: refactor(arena): use a shared block freelist

This is both simpler in client code and more effective (always reuse
block hottest in cache)
---
 src/nvim/eval/funcs.c                    | 11 ++-----
 src/nvim/ex_getln.c                      |  3 +-
 src/nvim/generators/gen_api_dispatch.lua |  5 +---
 src/nvim/highlight_group.c               |  2 +-
 src/nvim/lua/executor.c                  |  2 +-
 src/nvim/memory.c                        | 50 ++++++++++++++++++--------------
 src/nvim/memory.h                        |  2 +-
 src/nvim/msgpack_rpc/channel.c           |  8 ++---
 src/nvim/msgpack_rpc/unpacker.c          | 12 ++++----
 src/nvim/msgpack_rpc/unpacker.h          |  2 --
 src/nvim/popupmenu.c                     |  3 +-
 src/nvim/screen.c                        |  3 +-
 src/nvim/tui/input.c                     |  2 +-
 src/nvim/ui.c                            |  3 +-
 src/nvim/ui.h                            |  2 --
 15 files changed, 49 insertions(+), 61 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 5db584f6a8..cacac91ee8 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -114,8 +114,6 @@ static char *e_listblobarg = N_("E899: Argument of %s must be a List or Blob");
 static char *e_invalwindow = N_("E957: Invalid window number");
 static char *e_reduceempty = N_("E998: Reduce of an empty %s with no initial value");
 
-static ArenaMem eval_reuse_blk = NULL;
-
 /// Dummy va_list for passing to vim_snprintf
 ///
 /// Used because:
@@ -281,10 +279,6 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   Error err = ERROR_INIT;
   Arena res_arena = ARENA_EMPTY;
-  if (handler.arena_return) {
-    // TODO(bfredl): also use arena for vim_to_object
-    arena_start(&res_arena, &eval_reuse_blk);
-  }
   Object result = handler.fn(VIML_INTERNAL_CALL, args, &res_arena, &err);
 
   if (ERROR_SET(&err)) {
@@ -299,7 +293,7 @@ static void api_wrapper(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 end:
   api_free_array(args);
   if (handler.arena_return) {
-    arena_mem_free(arena_finish(&res_arena), &eval_reuse_blk);
+    arena_mem_free(arena_finish(&res_arena));
   } else {
     api_free_object(result);
   }
@@ -6885,7 +6879,6 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   uint64_t chan_id = (uint64_t)argvars[0].vval.v_number;
   const char *method = tv_get_string(&argvars[1]);
 
-  // TODO: putta in eval_reuse_blk
   ArenaMem res_mem = NULL;
   Object result = rpc_send_call(chan_id, method, args, &res_mem, &err);
 
@@ -6921,7 +6914,7 @@ static void f_rpcrequest(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
 end:
-  arena_mem_free(res_mem, &eval_reuse_blk);
+  arena_mem_free(res_mem);
   api_clear_error(&err);
 }
 
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 9a7b093282..ef6e1cbb22 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -3154,7 +3154,6 @@ draw_cmdline_no_arabicshape:
 static void ui_ext_cmdline_show(CmdlineInfo *line)
 {
   Arena arena = ARENA_EMPTY;
-  arena_start(&arena, &ui_ext_fixblk);
   Array content;
   if (cmdline_star) {
     content = arena_array(&arena, 1);
@@ -3199,7 +3198,7 @@ static void ui_ext_cmdline_show(CmdlineInfo *line)
                                  line->special_shift,
                                  line->level);
   }
-  arena_mem_free(arena_finish(&arena), &ui_ext_fixblk);
+  arena_mem_free(arena_finish(&arena));
 }
 
 void ui_ext_cmdline_block_append(size_t indent, const char *line)
diff --git a/src/nvim/generators/gen_api_dispatch.lua b/src/nvim/generators/gen_api_dispatch.lua
index e4798bf5ce..67b8f5f0f5 100644
--- a/src/nvim/generators/gen_api_dispatch.lua
+++ b/src/nvim/generators/gen_api_dispatch.lua
@@ -413,8 +413,6 @@ output:write([[
 #include "nvim/lua/executor.h"
 #include "nvim/memory.h"
 
-static ArenaMem lua_reuse_blk = { 0 };
-
 ]])
 include_headers(output, headers)
 output:write('\n')
@@ -496,7 +494,6 @@ local function process_function(fn)
     cparams = cparams .. '&arena, '
     write_shifted_output(output, [[
     Arena arena = ARENA_EMPTY;
-    arena_start(&arena, &lua_reuse_blk);
     ]])
   end
 
@@ -536,7 +533,7 @@ local function process_function(fn)
     end
     local free_retval
     if fn.arena_return then
-      free_retval = "arena_mem_free(arena_finish(&arena), &lua_reuse_blk);"
+      free_retval = "arena_mem_free(arena_finish(&arena));"
     else
       free_retval = "api_free_"..return_type:lower().."(ret);"
     end
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 65a50df274..3bdaee8066 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -1303,7 +1303,7 @@ void free_highlight(void)
 {
   ga_clear(&highlight_ga);
   map_destroy(cstr_t, int)(&highlight_unames);
-  arena_mem_free(arena_finish(&highlight_arena), NULL);
+  arena_mem_free(arena_finish(&highlight_arena));
 }
 
 #endif
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index d1d1480696..8316ab3bd1 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1093,7 +1093,7 @@ static int nlua_rpc(lua_State *lstate, bool request)
     Object result = rpc_send_call(chan_id, name, args, &res_mem, &err);
     if (!ERROR_SET(&err)) {
       nlua_push_Object(lstate, result, false);
-      arena_mem_free(res_mem, NULL);
+      arena_mem_free(res_mem);
     }
   } else {
     if (!rpc_send_event(chan_id, name, args)) {
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index 91f066f458..7b4b104ec7 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -60,6 +60,8 @@ void try_to_free_memory(void)
   // Try to save all buffers and release as many blocks as possible
   mf_release_all();
 
+  arena_free_reuse_blks();
+
   trying_to_free = false;
 }
 
@@ -528,23 +530,18 @@ void time_to_bytes(time_t time_, uint8_t buf[8])
 }
 
 #define ARENA_BLOCK_SIZE 4096
+#define REUSE_MAX 4
 
-void arena_start(Arena *arena, ArenaMem *reuse_blk)
-{
-  if (reuse_blk && *reuse_blk) {
-    arena->cur_blk = (char *)(*reuse_blk);
-    *reuse_blk = NULL;
-    arena->size = ARENA_BLOCK_SIZE;
-    arena->pos = 0;
+static struct consumed_blk *arena_reuse_blk;
+static size_t arena_reuse_blk_count = 0;
 
-    // address is the same as as (struct consumed_blk *)arena->cur_blk
-    struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
-    assert((char *)blk == (char *)arena->cur_blk);
-    blk->prev = NULL;
-  } else {
-    arena->cur_blk = NULL;
-    arena->size = 0;
-    arena->pos = 0;
+static void arena_free_reuse_blks(void)
+{
+  while (arena_reuse_blk_count > 0) {
+    struct consumed_blk *blk = arena_reuse_blk;
+    arena_reuse_blk = arena_reuse_blk->prev;
+    xfree(blk);
+    arena_reuse_blk_count--;
   }
 }
 
@@ -564,12 +561,18 @@ ArenaMem arena_finish(Arena *arena)
 void alloc_block(Arena *arena)
 {
   struct consumed_blk *prev_blk = (struct consumed_blk *)arena->cur_blk;
-  arena->cur_blk = xmalloc(ARENA_BLOCK_SIZE);
+  if (arena_reuse_blk_count > 0) {
+    arena->cur_blk = (char *)arena_reuse_blk;
+    arena_reuse_blk = arena_reuse_blk->prev;
+    arena_reuse_blk_count--;
+  } else {
+    arena_alloc_count++;
+    arena->cur_blk = xmalloc(ARENA_BLOCK_SIZE);
+  }
   arena->pos = 0;
   arena->size = ARENA_BLOCK_SIZE;
   struct consumed_blk *blk = arena_alloc(arena, sizeof(struct consumed_blk), true);
   blk->prev = prev_blk;
-  arena_alloc_count++;
 }
 
 /// @param size if zero, will still return a non-null pointer, but not a unique one
@@ -606,15 +609,17 @@ void *arena_alloc(Arena *arena, size_t size, bool align)
   return mem;
 }
 
-void arena_mem_free(ArenaMem mem, ArenaMem *reuse_blk)
+void arena_mem_free(ArenaMem mem)
 {
   struct consumed_blk *b = mem;
   // peel of the first block, as it is guaranteed to be ARENA_BLOCK_SIZE,
   // not a custom fix_blk
-  if (reuse_blk && *reuse_blk == NULL && b != NULL) {
-    *reuse_blk = b;
+  if (arena_reuse_blk_count < REUSE_MAX && b != NULL) {
+    struct consumed_blk *reuse_blk = b;
     b = b->prev;
-    (*reuse_blk)->prev = NULL;
+    reuse_blk->prev = arena_reuse_blk;
+    arena_reuse_blk = reuse_blk;
+    arena_reuse_blk_count++;
   }
 
   while (b) {
@@ -815,6 +820,9 @@ void free_all_mem(void)
 
   nlua_free_all_mem();
   ui_free_all_mem();
+
+  // should be last, in case earlier free functions deallocates arenas
+  arena_free_reuse_blks();
 }
 
 #endif
diff --git a/src/nvim/memory.h b/src/nvim/memory.h
index 5e37847beb..f407192331 100644
--- a/src/nvim/memory.h
+++ b/src/nvim/memory.h
@@ -52,7 +52,7 @@ typedef struct {
   size_t pos, size;
 } Arena;
 
-// inits an empty arena. use arena_start() to actually allocate space!
+// inits an empty arena.
 #define ARENA_EMPTY { .cur_blk = NULL, .pos = 0, .size = 0 }
 
 #define kv_fixsize_arena(a, v, s) \
diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
index 66fd79c692..f00c62f766 100644
--- a/src/nvim/msgpack_rpc/channel.c
+++ b/src/nvim/msgpack_rpc/channel.c
@@ -158,7 +158,7 @@ Object rpc_send_call(uint64_t id, const char *method_name, Array args, ArenaMem
     }
 
     // frame.result was allocated in an arena
-    arena_mem_free(frame.result_mem, &rpc->unpacker->reuse_blk);
+    arena_mem_free(frame.result_mem);
     frame.result_mem = NULL;
   }
 
@@ -244,7 +244,7 @@ static void parse_msgpack(Channel *channel)
         ui_client_event_raw_line(p->grid_line_event);
       } else if (p->ui_handler.fn != NULL && p->result.type == kObjectTypeArray) {
         p->ui_handler.fn(p->result.data.array);
-        arena_mem_free(arena_finish(&p->arena), &p->reuse_blk);
+        arena_mem_free(arena_finish(&p->arena));
       }
     } else if (p->type == kMessageTypeResponse) {
       ChannelCallFrame *frame = kv_last(channel->rpc.call_stack);
@@ -295,7 +295,7 @@ static void handle_request(Channel *channel, Unpacker *p, Array args)
   if (!p->handler.fn) {
     send_error(channel, p->type, p->request_id, p->unpack_error.msg);
     api_clear_error(&p->unpack_error);
-    arena_mem_free(arena_finish(&p->arena), &p->reuse_blk);
+    arena_mem_free(arena_finish(&p->arena));
     return;
   }
 
@@ -364,7 +364,7 @@ static void request_event(void **argv)
 
 free_ret:
   // e->args (and possibly result) are allocated in an arena
-  arena_mem_free(arena_finish(&e->used_mem), &channel->rpc.unpacker->reuse_blk);
+  arena_mem_free(arena_finish(&e->used_mem));
   channel_decref(channel);
   xfree(e);
   api_clear_error(&error);
diff --git a/src/nvim/msgpack_rpc/unpacker.c b/src/nvim/msgpack_rpc/unpacker.c
index c8e9fdd4c3..24480835a1 100644
--- a/src/nvim/msgpack_rpc/unpacker.c
+++ b/src/nvim/msgpack_rpc/unpacker.c
@@ -181,13 +181,11 @@ void unpacker_init(Unpacker *p)
   p->unpack_error = (Error)ERROR_INIT;
 
   p->arena = (Arena)ARENA_EMPTY;
-  p->reuse_blk = NULL;
 }
 
 void unpacker_teardown(Unpacker *p)
 {
-  arena_mem_free(p->reuse_blk, NULL);
-  arena_mem_free(arena_finish(&p->arena), NULL);
+  arena_mem_free(arena_finish(&p->arena));
 }
 
 bool unpacker_parse_header(Unpacker *p)
@@ -308,7 +306,7 @@ bool unpacker_advance(Unpacker *p)
       p->state = 10;
     } else {
       p->state = p->type == kMessageTypeResponse ? 1 : 2;
-      arena_start(&p->arena, &p->reuse_blk);
+      p->arena = (Arena)ARENA_EMPTY;
     }
   }
 
@@ -322,7 +320,7 @@ bool unpacker_advance(Unpacker *p)
       goto done;
     } else {
       // unpack other ui events using mpack_parse()
-      arena_start(&p->arena, &p->reuse_blk);
+      p->arena = (Arena)ARENA_EMPTY;
     }
   }
 
@@ -416,13 +414,13 @@ redo:
     if (p->ui_handler.fn != ui_client_event_grid_line) {
       p->state = 12;
       if (p->grid_line_event) {
-        arena_mem_free(arena_finish(&p->arena), &p->reuse_blk);
+        arena_mem_free(arena_finish(&p->arena));
         p->grid_line_event = NULL;
       }
       return true;
     } else {
       p->state = 13;
-      arena_start(&p->arena, &p->reuse_blk);
+      p->arena = (Arena)ARENA_EMPTY;
       p->grid_line_event = arena_alloc(&p->arena, sizeof *p->grid_line_event, true);
       g = p->grid_line_event;
     }
diff --git a/src/nvim/msgpack_rpc/unpacker.h b/src/nvim/msgpack_rpc/unpacker.h
index f39439be63..35048fb877 100644
--- a/src/nvim/msgpack_rpc/unpacker.h
+++ b/src/nvim/msgpack_rpc/unpacker.h
@@ -32,8 +32,6 @@ struct Unpacker {
   Error unpack_error;
 
   Arena arena;
-  // one length free-list of reusable blocks
-  ArenaMem reuse_blk;
 
   int nevents;
   int ncalls;
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index d392bb5a2c..f570556a29 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -156,7 +156,6 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
     if (pum_external) {
       if (array_changed) {
         Arena arena = ARENA_EMPTY;
-        arena_start(&arena, &ui_ext_fixblk);
         Array arr = arena_array(&arena, (size_t)size);
         for (int i = 0; i < size; i++) {
           Array item = arena_array(&arena, 4);
@@ -168,7 +167,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
         }
         ui_call_popupmenu_show(arr, selected, pum_win_row, cursor_col,
                                pum_anchor_grid);
-        arena_mem_free(arena_finish(&arena), &ui_ext_fixblk);
+        arena_mem_free(arena_finish(&arena));
       } else {
         ui_call_popupmenu_select(selected);
         return;
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index b471b93192..89b24e9440 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -1094,7 +1094,6 @@ void draw_tabline(void)
 static void ui_ext_tabline_update(void)
 {
   Arena arena = ARENA_EMPTY;
-  arena_start(&arena, &ui_ext_fixblk);
 
   size_t n_tabs = 0;
   FOR_ALL_TABS(tp) {
@@ -1135,7 +1134,7 @@ static void ui_ext_tabline_update(void)
   }
 
   ui_call_tabline_update(curtab->handle, tabs, curbuf->handle, buffers);
-  arena_mem_free(arena_finish(&arena), &ui_ext_fixblk);
+  arena_mem_free(arena_finish(&arena));
 }
 
 void get_trans_bufname(buf_T *buf)
diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index 61a59bcf06..6afe7defe3 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -238,7 +238,7 @@ static void tinput_wait_enqueue(void **argv)
         ArenaMem res_mem = NULL;
         Object result = rpc_send_call(ui_client_channel_id, "nvim_input", args, &res_mem, &err);
         consumed = result.type == kObjectTypeInteger ? (size_t)result.data.integer : 0;
-        arena_mem_free(res_mem, NULL);
+        arena_mem_free(res_mem);
       } else {
         consumed = input_enqueue(keys);
       }
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index da671a3ad1..0126ad62b5 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -517,11 +517,10 @@ void ui_flush(void)
   }
   if (pending_mode_info_update) {
     Arena arena = ARENA_EMPTY;
-    arena_start(&arena, &ui_ext_fixblk);
     Array style = mode_style_array(&arena);
     bool enabled = (*p_guicursor != NUL);
     ui_call_mode_info_set(enabled, style);
-    arena_mem_free(arena_finish(&arena), &ui_ext_fixblk);
+    arena_mem_free(arena_finish(&arena));
     pending_mode_info_update = false;
   }
   if (pending_mode_update && !starting) {
diff --git a/src/nvim/ui.h b/src/nvim/ui.h
index 7dd2f5bce3..996b3467a6 100644
--- a/src/nvim/ui.h
+++ b/src/nvim/ui.h
@@ -47,8 +47,6 @@ enum {
 
 typedef int LineFlags;
 
-EXTERN ArenaMem ui_ext_fixblk INIT(= NULL);
-
 struct ui_t {
   bool rgb;
   bool override;  ///< Force highest-requested UI capabilities.
-- 
cgit 


From 7784dc9e0d90284b0d9c9cf0833c27d4de22b7f4 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Tue, 23 Aug 2022 13:52:09 +0200
Subject: refactor(api): provide a temporary copy solution for nvim_call_atomic

Make the copy_object() family accept an optional arena. More than
half of the callsites should be refactored to use an arena later
anyway.
---
 src/nvim/api/autocmd.c                    |  4 +--
 src/nvim/api/extmark.c                    |  2 +-
 src/nvim/api/private/helpers.c            | 33 ++++++++++++----------
 src/nvim/api/ui.c                         |  6 ++--
 src/nvim/api/vim.c                        | 46 +++++++++++++++----------------
 src/nvim/autocmd.c                        |  2 +-
 src/nvim/context.c                        |  4 +--
 src/nvim/eval/funcs.c                     |  1 -
 src/nvim/eval/funcs.h                     | 14 +++++-----
 src/nvim/generators/gen_api_ui_events.lua |  6 ++--
 src/nvim/highlight.c                      |  2 +-
 src/nvim/memory.c                         |  4 +++
 src/nvim/message.c                        |  2 +-
 src/nvim/msgpack_rpc/channel.c            |  2 +-
 src/nvim/tui/input.c                      |  2 +-
 src/nvim/types.h                          |  1 -
 src/nvim/ui_bridge.c                      |  4 +--
 17 files changed, 71 insertions(+), 64 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/autocmd.c b/src/nvim/api/autocmd.c
index 79ae7994f7..1cf0211f43 100644
--- a/src/nvim/api/autocmd.c
+++ b/src/nvim/api/autocmd.c
@@ -887,12 +887,12 @@ static bool check_autocmd_string_array(Array arr, char *k, Error *err)
 static bool unpack_string_or_array(Array *array, Object *v, char *k, bool required, Error *err)
 {
   if (v->type == kObjectTypeString) {
-    ADD(*array, copy_object(*v));
+    ADD(*array, copy_object(*v, NULL));
   } else if (v->type == kObjectTypeArray) {
     if (!check_autocmd_string_array(v->data.array, k, err)) {
       return false;
     }
-    *array = copy_array(v->data.array);
+    *array = copy_array(v->data.array, NULL);
   } else {
     if (required) {
       api_set_error(err,
diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index 933aa85530..1d6eaa42b0 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -51,7 +51,7 @@ Integer nvim_create_namespace(String name)
   }
   id = next_namespace_id++;
   if (name.size > 0) {
-    String name_alloc = copy_string(name);
+    String name_alloc = copy_string(name, NULL);
     map_put(String, handle_T)(&namespace_ids, name_alloc, id);
   }
   return (Integer)id;
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index c466fc53e1..e35c58bf1b 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -618,6 +618,7 @@ void api_clear_error(Error *value)
   value->type = kErrorTypeNone;
 }
 
+/// @returns a shared value. caller must not modify it!
 Dictionary api_metadata(void)
 {
   static Dictionary metadata = ARRAY_DICT_INIT;
@@ -630,7 +631,7 @@ Dictionary api_metadata(void)
     init_type_metadata(&metadata);
   }
 
-  return copy_object(DICTIONARY_OBJ(metadata)).data.dictionary;
+  return metadata;
 }
 
 static void init_function_metadata(Dictionary *metadata)
@@ -715,36 +716,40 @@ static void init_type_metadata(Dictionary *metadata)
   PUT(*metadata, "types", DICTIONARY_OBJ(types));
 }
 
-String copy_string(String str)
+// all the copy_[object] functions allow arena=NULL,
+// then global allocations are used, and the resulting object
+// should be freed with an api_free_[object] function
+
+String copy_string(String str, Arena *arena)
 {
   if (str.data != NULL) {
-    return (String){ .data = xmemdupz(str.data, str.size), .size = str.size };
+    return (String){ .data = arena_memdupz(arena, str.data, str.size), .size = str.size };
   } else {
     return (String)STRING_INIT;
   }
 }
 
-Array copy_array(Array array)
+Array copy_array(Array array, Arena *arena)
 {
-  Array rv = ARRAY_DICT_INIT;
+  Array rv = arena_array(arena, array.size);
   for (size_t i = 0; i < array.size; i++) {
-    ADD(rv, copy_object(array.items[i]));
+    ADD(rv, copy_object(array.items[i], arena));
   }
   return rv;
 }
 
-Dictionary copy_dictionary(Dictionary dict)
+Dictionary copy_dictionary(Dictionary dict, Arena *arena)
 {
-  Dictionary rv = ARRAY_DICT_INIT;
+  Dictionary rv = arena_dict(arena, dict.size);
   for (size_t i = 0; i < dict.size; i++) {
     KeyValuePair item = dict.items[i];
-    PUT(rv, item.key.data, copy_object(item.value));
+    PUT_C(rv, copy_string(item.key, arena).data, copy_object(item.value, arena));
   }
   return rv;
 }
 
 /// Creates a deep clone of an object
-Object copy_object(Object obj)
+Object copy_object(Object obj, Arena *arena)
 {
   switch (obj.type) {
   case kObjectTypeBuffer:
@@ -757,13 +762,13 @@ Object copy_object(Object obj)
     return obj;
 
   case kObjectTypeString:
-    return STRING_OBJ(copy_string(obj.data.string));
+    return STRING_OBJ(copy_string(obj.data.string, arena));
 
   case kObjectTypeArray:
-    return ARRAY_OBJ(copy_array(obj.data.array));
+    return ARRAY_OBJ(copy_array(obj.data.array, arena));
 
   case kObjectTypeDictionary:
-    return DICTIONARY_OBJ(copy_dictionary(obj.data.dictionary));
+    return DICTIONARY_OBJ(copy_dictionary(obj.data.dictionary, arena));
 
   case kObjectTypeLuaRef:
     return LUAREF_OBJ(api_new_luaref(obj.data.luaref));
@@ -844,7 +849,7 @@ HlMessage parse_hl_msg(Array chunks, Error *err)
       goto free_exit;
     }
 
-    String str = copy_string(chunk.items[0].data.string);
+    String str = copy_string(chunk.items[0].data.string, NULL);
 
     int attr = 0;
     if (chunk.size == 2) {
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index 6f7bfa244a..e34dcbdb46 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -965,7 +965,7 @@ static Array translate_contents(UI *ui, Array contents)
     } else {
       ADD(new_item, DICTIONARY_OBJ((Dictionary)ARRAY_DICT_INIT));
     }
-    ADD(new_item, copy_object(item.items[1]));
+    ADD(new_item, copy_object(item.items[1], NULL));
     ADD(new_contents, ARRAY_OBJ(new_item));
   }
   return new_contents;
@@ -978,7 +978,7 @@ static Array translate_firstarg(UI *ui, Array args)
 
   ADD(new_args, ARRAY_OBJ(translate_contents(ui, contents)));
   for (size_t i = 1; i < args.size; i++) {
-    ADD(new_args, copy_object(args.items[i]));
+    ADD(new_args, copy_object(args.items[i], NULL));
   }
   return new_args;
 }
@@ -1024,7 +1024,7 @@ static void remote_ui_event(UI *ui, char *name, Array args)
         Array items = args.items[0].data.array;
         Array new_items = ARRAY_DICT_INIT;
         for (size_t i = 0; i < items.size; i++) {
-          ADD(new_items, copy_object(items.items[i].data.array.items[0]));
+          ADD(new_items, copy_object(items.items[i].data.array.items[0], NULL));
         }
         ADD_C(new_args, ARRAY_OBJ(new_items));
         push_call(ui, "wildmenu_show", new_args);
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index c333db1b37..7b70de7b12 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -1479,14 +1479,14 @@ void nvim_del_keymap(uint64_t channel_id, String mode, String lhs, Error *err)
 /// 1 is the |api-metadata| map (Dictionary).
 ///
 /// @returns 2-tuple [{channel-id}, {api-metadata}]
-Array nvim_get_api_info(uint64_t channel_id)
+Array nvim_get_api_info(uint64_t channel_id, Arena *arena)
   FUNC_API_SINCE(1) FUNC_API_FAST FUNC_API_REMOTE_ONLY
 {
-  Array rv = ARRAY_DICT_INIT;
+  Array rv = arena_array(arena, 2);
 
   assert(channel_id <= INT64_MAX);
-  ADD(rv, INTEGER_OBJ((int64_t)channel_id));
-  ADD(rv, DICTIONARY_OBJ(api_metadata()));
+  ADD_C(rv, INTEGER_OBJ((int64_t)channel_id));
+  ADD_C(rv, DICTIONARY_OBJ(api_metadata()));
 
   return rv;
 }
@@ -1545,9 +1545,9 @@ void nvim_set_client_info(uint64_t channel_id, String name, Dictionary version,
   FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
 {
   Dictionary info = ARRAY_DICT_INIT;
-  PUT(info, "name", copy_object(STRING_OBJ(name)));
+  PUT(info, "name", copy_object(STRING_OBJ(name), NULL));
 
-  version = copy_dictionary(version);
+  version = copy_dictionary(version, NULL);
   bool has_major = false;
   for (size_t i = 0; i < version.size; i++) {
     if (strequal(version.items[i].key.data, "major")) {
@@ -1560,9 +1560,9 @@ void nvim_set_client_info(uint64_t channel_id, String name, Dictionary version,
   }
   PUT(info, "version", DICTIONARY_OBJ(version));
 
-  PUT(info, "type", copy_object(STRING_OBJ(type)));
-  PUT(info, "methods", DICTIONARY_OBJ(copy_dictionary(methods)));
-  PUT(info, "attributes", DICTIONARY_OBJ(copy_dictionary(attributes)));
+  PUT(info, "type", copy_object(STRING_OBJ(type), NULL));
+  PUT(info, "methods", DICTIONARY_OBJ(copy_dictionary(methods, NULL)));
+  PUT(info, "attributes", DICTIONARY_OBJ(copy_dictionary(attributes, NULL)));
 
   rpc_set_client_info(channel_id, info);
 }
@@ -1642,21 +1642,21 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Arena *arena, Error *er
       api_set_error(err,
                     kErrorTypeValidation,
                     "Items in calls array must be arrays");
-      goto validation_error;
+      goto theend;
     }
     Array call = calls.items[i].data.array;
     if (call.size != 2) {
       api_set_error(err,
                     kErrorTypeValidation,
                     "Items in calls array must be arrays of size 2");
-      goto validation_error;
+      goto theend;
     }
 
     if (call.items[0].type != kObjectTypeString) {
       api_set_error(err,
                     kErrorTypeValidation,
                     "Name must be String");
-      goto validation_error;
+      goto theend;
     }
     String name = call.items[0].data.string;
 
@@ -1664,7 +1664,7 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Arena *arena, Error *er
       api_set_error(err,
                     kErrorTypeValidation,
                     "Args must be Array");
-      goto validation_error;
+      goto theend;
     }
     Array args = call.items[1].data.array;
 
@@ -1682,11 +1682,13 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Arena *arena, Error *er
       // error handled after loop
       break;
     }
-    if (!handler.arena_return && result.type != kObjectTypeNil) {
-      // TODO: fix to not leak memory as fuck
+    // TODO(bfredl): wastefull copy. It could be avoided to encoding to msgpack
+    // directly here. But `result` might become invalid when next api function
+    // is called in the loop.
+    ADD_C(results, copy_object(result, arena));
+    if (!handler.arena_return) {
+      api_free_object(result);
     }
-
-    ADD_C(results, result);
   }
 
   ADD_C(rv, ARRAY_OBJ(results));
@@ -1694,14 +1696,12 @@ Array nvim_call_atomic(uint64_t channel_id, Array calls, Arena *arena, Error *er
     Array errval = arena_array(arena, 3);
     ADD_C(errval, INTEGER_OBJ((Integer)i));
     ADD_C(errval, INTEGER_OBJ(nested_error.type));
-    ADD_C(errval, STRING_OBJ(cstr_to_string(nested_error.msg))); // TODO
+    ADD_C(errval, STRING_OBJ(copy_string(cstr_as_string(nested_error.msg), arena)));
     ADD_C(rv, ARRAY_OBJ(errval));
   } else {
     ADD_C(rv, NIL);
   }
-  goto theend;
 
-validation_error:
 theend:
   api_clear_error(&nested_error);
   return rv;
@@ -1754,7 +1754,7 @@ static void write_msg(String message, bool to_err)
 /// @return its argument.
 Object nvim__id(Object obj)
 {
-  return copy_object(obj);
+  return copy_object(obj, NULL);
 }
 
 /// Returns array given as argument.
@@ -1767,7 +1767,7 @@ Object nvim__id(Object obj)
 /// @return its argument.
 Array nvim__id_array(Array arr)
 {
-  return copy_object(ARRAY_OBJ(arr)).data.array;
+  return copy_array(arr, NULL);
 }
 
 /// Returns dictionary given as argument.
@@ -1780,7 +1780,7 @@ Array nvim__id_array(Array arr)
 /// @return its argument.
 Dictionary nvim__id_dictionary(Dictionary dct)
 {
-  return copy_object(DICTIONARY_OBJ(dct)).data.dictionary;
+  return copy_dictionary(dct, NULL);
 }
 
 /// Returns floating-point value given as argument.
diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 579c6c029f..5bb1bac02d 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -2051,7 +2051,7 @@ static bool call_autocmd_callback(const AutoCmd *ac, const AutoPatCmd *apc)
     PUT(data, "buf", INTEGER_OBJ(autocmd_bufnr));
 
     if (apc->data) {
-      PUT(data, "data", copy_object(*apc->data));
+      PUT(data, "data", copy_object(*apc->data, NULL));
     }
 
     int group = apc->curpat->group;
diff --git a/src/nvim/context.c b/src/nvim/context.c
index e3ae9355bf..34692cdf64 100644
--- a/src/nvim/context.c
+++ b/src/nvim/context.c
@@ -345,7 +345,7 @@ Dictionary ctx_to_dict(Context *ctx)
   PUT(rv, "jumps", ARRAY_OBJ(sbuf_to_array(ctx->jumps)));
   PUT(rv, "bufs", ARRAY_OBJ(sbuf_to_array(ctx->bufs)));
   PUT(rv, "gvars", ARRAY_OBJ(sbuf_to_array(ctx->gvars)));
-  PUT(rv, "funcs", ARRAY_OBJ(copy_array(ctx->funcs)));
+  PUT(rv, "funcs", ARRAY_OBJ(copy_array(ctx->funcs, NULL)));
 
   return rv;
 }
@@ -381,7 +381,7 @@ int ctx_from_dict(Dictionary dict, Context *ctx)
       ctx->gvars = array_to_sbuf(item.value.data.array);
     } else if (strequal(item.key.data, "funcs")) {
       types |= kCtxFuncs;
-      ctx->funcs = copy_object(item.value).data.array;
+      ctx->funcs = copy_object(item.value, NULL).data.array;
     }
   }
 
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index cacac91ee8..fe421aa272 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -359,7 +359,6 @@ static void f_api_info(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   Dictionary metadata = api_metadata();
   (void)object_to_vim(DICTIONARY_OBJ(metadata), rettv, NULL);
-  api_free_dictionary(metadata);
 }
 
 /// "append(lnum, string/list)" function
diff --git a/src/nvim/eval/funcs.h b/src/nvim/eval/funcs.h
index 3aa255ed0b..adff0b2441 100644
--- a/src/nvim/eval/funcs.h
+++ b/src/nvim/eval/funcs.h
@@ -14,13 +14,13 @@ typedef void (*VimLFunc)(typval_T *args, typval_T *rvar, EvalFuncData data);
 
 /// Structure holding VimL function definition
 typedef struct {
-  char *name;        ///< Name of the function.
-  uint8_t min_argc;  ///< Minimal number of arguments.
-  uint8_t max_argc;  ///< Maximal number of arguments.
-  uint8_t base_arg;  ///< Method base arg # (1-indexed), BASE_NONE or BASE_LAST.
-  bool fast;         ///< Can be run in |api-fast| events
-  VimLFunc func;     ///< Function implementation.
-  EvalFuncData data; ///< Userdata for function implementation.
+  char *name;         ///< Name of the function.
+  uint8_t min_argc;   ///< Minimal number of arguments.
+  uint8_t max_argc;   ///< Maximal number of arguments.
+  uint8_t base_arg;   ///< Method base arg # (1-indexed), BASE_NONE or BASE_LAST.
+  bool fast;          ///< Can be run in |api-fast| events
+  VimLFunc func;      ///< Function implementation.
+  EvalFuncData data;  ///< Userdata for function implementation.
 } EvalFuncDef;
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/generators/gen_api_ui_events.lua b/src/nvim/generators/gen_api_ui_events.lua
index 93bbaab74c..f9e888c20d 100755
--- a/src/nvim/generators/gen_api_ui_events.lua
+++ b/src/nvim/generators/gen_api_ui_events.lua
@@ -125,7 +125,7 @@ for i = 1, #events do
         local param = ev.parameters[j]
         local copy = 'copy_'..param[2]
         if param[1] == 'String' then
-          send = send..'  String copy_'..param[2]..' = copy_string('..param[2]..');\n'
+          send = send..'  String copy_'..param[2]..' = copy_string('..param[2]..', NULL);\n'
           argv = argv..', '..copy..'.data, INT2PTR('..copy..'.size)'
           recv = (recv..'  String '..param[2]..
                           ' = (String){.data = argv['..argc..'],'..
@@ -134,7 +134,7 @@ for i = 1, #events do
           recv_cleanup = recv_cleanup..'  api_free_string('..param[2]..');\n'
           argc = argc+2
         elseif param[1] == 'Array' then
-          send = send..'  Array '..copy..' = copy_array('..param[2]..');\n'
+          send = send..'  Array '..copy..' = copy_array('..param[2]..', NULL);\n'
           argv = argv..', '..copy..'.items, INT2PTR('..copy..'.size)'
           recv = (recv..'  Array '..param[2]..
                           ' = (Array){.items = argv['..argc..'],'..
@@ -144,7 +144,7 @@ for i = 1, #events do
           argc = argc+2
         elseif param[1] == 'Object' then
           send = send..'  Object *'..copy..' = xmalloc(sizeof(Object));\n'
-          send = send..'  *'..copy..' = copy_object('..param[2]..');\n'
+          send = send..'  *'..copy..' = copy_object('..param[2]..', NULL);\n'
           argv = argv..', '..copy
           recv = recv..'  Object '..param[2]..' = *(Object *)argv['..argc..'];\n'
           recv_argv = recv_argv..', '..param[2]
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index d6a18fcf8e..c5a84c731d 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -903,7 +903,7 @@ Dictionary hlattrs2dict(Dictionary *hl_alloc, HlAttrs ae, bool use_rgb)
     *hl_alloc = hl;
     return hl;
   } else {
-    Dictionary allocated = copy_dictionary(hl);
+    Dictionary allocated = copy_dictionary(hl, NULL);
     kv_destroy(hl);
     return allocated;
   }
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index 7b4b104ec7..a9785fcb7c 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -575,9 +575,13 @@ void alloc_block(Arena *arena)
   blk->prev = prev_blk;
 }
 
+/// @param arena if NULL, do a global allocation. caller must then free the value!
 /// @param size if zero, will still return a non-null pointer, but not a unique one
 void *arena_alloc(Arena *arena, size_t size, bool align)
 {
+  if (!arena) {
+    return xmalloc(size);
+  }
   if (align) {
     arena->pos = (arena->pos + (ARENA_ALIGN - 1)) & ~(ARENA_ALIGN - 1);
   }
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 684cf7207c..52e558a2f0 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1086,7 +1086,7 @@ void ex_messages(void *const eap_p)
             HlMessageChunk chunk = kv_A(p->multiattr, i);
             Array content_entry = ARRAY_DICT_INIT;
             ADD(content_entry, INTEGER_OBJ(chunk.attr));
-            ADD(content_entry, STRING_OBJ(copy_string(chunk.text)));
+            ADD(content_entry, STRING_OBJ(copy_string(chunk.text, NULL)));
             ADD(content, ARRAY_OBJ(content_entry));
           }
         } else if (p->msg && p->msg[0]) {
diff --git a/src/nvim/msgpack_rpc/channel.c b/src/nvim/msgpack_rpc/channel.c
index f00c62f766..d22bcb29d5 100644
--- a/src/nvim/msgpack_rpc/channel.c
+++ b/src/nvim/msgpack_rpc/channel.c
@@ -644,7 +644,7 @@ void rpc_set_client_info(uint64_t id, Dictionary info)
 
 Dictionary rpc_client_info(Channel *chan)
 {
-  return copy_dictionary(chan->rpc.info);
+  return copy_dictionary(chan->rpc.info, NULL);
 }
 
 const char *rpc_client_name(Channel *chan)
diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index 6afe7defe3..03cfb830e6 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -233,7 +233,7 @@ static void tinput_wait_enqueue(void **argv)
       if (ui_client_channel_id) {
         Array args = ARRAY_DICT_INIT;
         Error err = ERROR_INIT;
-        ADD(args, STRING_OBJ(copy_string(keys)));
+        ADD(args, STRING_OBJ(copy_string(keys, NULL)));
         // TODO(bfredl): could be non-blocking now with paste?
         ArenaMem res_mem = NULL;
         Object result = rpc_send_call(ui_client_channel_id, "nvim_input", args, &res_mem, &err);
diff --git a/src/nvim/types.h b/src/nvim/types.h
index 3fac97fc82..fb10bf21d9 100644
--- a/src/nvim/types.h
+++ b/src/nvim/types.h
@@ -33,7 +33,6 @@ typedef union {
   void *nullptr;
 } EvalFuncData;
 
-
 typedef handle_T NS;
 
 typedef struct expand expand_T;
diff --git a/src/nvim/ui_bridge.c b/src/nvim/ui_bridge.c
index 84098e9476..809d278029 100644
--- a/src/nvim/ui_bridge.c
+++ b/src/nvim/ui_bridge.c
@@ -194,9 +194,9 @@ static void ui_bridge_suspend_event(void **argv)
 
 static void ui_bridge_option_set(UI *ui, String name, Object value)
 {
-  String copy_name = copy_string(name);
+  String copy_name = copy_string(name, NULL);
   Object *copy_value = xmalloc(sizeof(Object));
-  *copy_value = copy_object(value);
+  *copy_value = copy_object(value, NULL);
   UI_BRIDGE_CALL(ui, option_set, 4, ui, copy_name.data,
                  INT2PTR(copy_name.size), copy_value);
   // TODO(bfredl): when/if TUI/bridge teardown is refactored to use events, the
-- 
cgit 


From b0fdce55d02c1da7da3257b33b91e974f89eceef Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 20:36:10 +0800
Subject: vim-patch:partial:8.2.3953: insert completion code is too complicated
 (#19923)

Problem:    Insert completion code is too complicated.
Solution:   More refactoring.  Move function arguments into a struct.
            (Yegappan Lakshmanan, closes vim/vim#9437)
https://github.com/vim/vim/commit/6ad84ab3e48d9490e4139df04f2c55b136f5501d

Skip most pum-related refactoring.
Cherry-pick rename to match_at_original_text() from patch 8.2.4001.
---
 src/nvim/insexpand.c | 690 ++++++++++++++++++++++++++-------------------------
 1 file changed, 350 insertions(+), 340 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 5655b31df1..4b0613229b 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -140,6 +140,21 @@ struct compl_S {
   int cp_number;                 ///< sequence number
 };
 
+/// state information used for getting the next set of insert completion
+/// matches.
+typedef struct {
+  char *e_cpt;            ///< current entry in 'complete'
+  buf_T *ins_buf;         ///< buffer being scanned
+  pos_T *cur_match_pos;   ///< current match position
+  pos_T prev_match_pos;   ///< previous match position
+  bool set_match_pos;     ///< save first_match_pos/last_match_pos
+  pos_T first_match_pos;  ///< first match position
+  pos_T last_match_pos;   ///< last match position
+  bool found_all;         ///< found all matches of a certain type.
+  char_u *dict;           ///< dictionary file to search
+  int dict_f;             ///< "dict" is an exact file name or not
+} ins_compl_next_state_T;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "insexpand.c.generated.h"
 #endif
@@ -162,6 +177,7 @@ static char e_compldel[] = N_("E840: Completion function deleted text");
 // "compl_curr_match" points to the currently selected entry.
 // "compl_shown_match" is different from compl_curr_match during
 // ins_compl_get_exp().
+// "compl_old_match" points to previous "compl_curr_match".
 
 static compl_T *compl_first_match = NULL;
 static compl_T *compl_curr_match = NULL;
@@ -445,6 +461,12 @@ bool vim_is_ctrl_x_key(int c)
   return false;
 }
 
+/// @return  true if "match" is the original text when the completion began.
+static bool match_at_original_text(const compl_T *const match)
+{
+  return match->cp_flags & CP_ORIGINAL_TEXT;
+}
+
 /// Check that character "c" is part of the item currently being
 /// completed.  Used to decide whether to abandon complete mode when the menu
 /// is visible.
@@ -479,6 +501,88 @@ bool ins_compl_accept_char(int c)
   return vim_iswordc(c);
 }
 
+/// Get the completed text by inferring the case of the originally typed text.
+static char_u *ins_compl_infercase_gettext(char_u *str, int actual_len, int actual_compl_length,
+                                           int min_len)
+{
+  bool has_lower = false;
+  bool was_letter = false;
+
+  // Allocate wide character array for the completion and fill it.
+  int *const wca = xmalloc((size_t)actual_len * sizeof(*wca));
+  {
+    const char_u *p = str;
+    for (int i = 0; i < actual_len; i++) {
+      wca[i] = mb_ptr2char_adv(&p);
+    }
+  }
+
+  // Rule 1: Were any chars converted to lower?
+  {
+    const char_u *p = compl_orig_text;
+    for (int i = 0; i < min_len; i++) {
+      const int c = mb_ptr2char_adv(&p);
+      if (mb_islower(c)) {
+        has_lower = true;
+        if (mb_isupper(wca[i])) {
+          // Rule 1 is satisfied.
+          for (i = actual_compl_length; i < actual_len; i++) {
+            wca[i] = mb_tolower(wca[i]);
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  // Rule 2: No lower case, 2nd consecutive letter converted to
+  // upper case.
+  if (!has_lower) {
+    const char_u *p = compl_orig_text;
+    for (int i = 0; i < min_len; i++) {
+      const int c = mb_ptr2char_adv(&p);
+      if (was_letter && mb_isupper(c) && mb_islower(wca[i])) {
+        // Rule 2 is satisfied.
+        for (i = actual_compl_length; i < actual_len; i++) {
+          wca[i] = mb_toupper(wca[i]);
+        }
+        break;
+      }
+      was_letter = mb_islower(c) || mb_isupper(c);
+    }
+  }
+
+  // Copy the original case of the part we typed.
+  {
+    const char_u *p = compl_orig_text;
+    for (int i = 0; i < min_len; i++) {
+      const int c = mb_ptr2char_adv(&p);
+      if (mb_islower(c)) {
+        wca[i] = mb_tolower(wca[i]);
+      } else if (mb_isupper(c)) {
+        wca[i] = mb_toupper(wca[i]);
+      }
+    }
+  }
+
+  // Generate encoding specific output from wide character array.
+  // Multi-byte characters can occupy up to five bytes more than
+  // ASCII characters, and we also need one byte for NUL, so stay
+  // six bytes away from the edge of IObuff.
+  {
+    char_u *p = IObuff;
+    int i = 0;
+    while (i < actual_len && (p - IObuff + 6) < IOSIZE) {
+      p += utf_char2bytes(wca[i++], (char *)p);
+    }
+    *p = NUL;
+  }
+
+  xfree(wca);
+
+  return IObuff;
+}
+
 /// This is like ins_compl_add(), but if 'ic' and 'inf' are set, then the
 /// case of the originally typed text is used, and the case of the completed
 /// text is inferred, ie this tries to work out what case you probably wanted
@@ -490,12 +594,9 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char_u *str = str_arg;
-  int i, c;
   int actual_len;                       // Take multi-byte characters
   int actual_compl_length;              // into account.
   int min_len;
-  bool has_lower = false;
-  bool was_letter = false;
   int flags = 0;
 
   if (p_ic && curbuf->b_p_inf && len > 0) {
@@ -526,79 +627,7 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
     min_len = actual_len < actual_compl_length
               ? actual_len : actual_compl_length;
 
-    // Allocate wide character array for the completion and fill it.
-    int *const wca = xmalloc((size_t)actual_len * sizeof(*wca));
-    {
-      const char_u *p = str;
-      for (i = 0; i < actual_len; i++) {
-        wca[i] = mb_ptr2char_adv(&p);
-      }
-    }
-
-    // Rule 1: Were any chars converted to lower?
-    {
-      const char_u *p = compl_orig_text;
-      for (i = 0; i < min_len; i++) {
-        c = mb_ptr2char_adv(&p);
-        if (mb_islower(c)) {
-          has_lower = true;
-          if (mb_isupper(wca[i])) {
-            // Rule 1 is satisfied.
-            for (i = actual_compl_length; i < actual_len; i++) {
-              wca[i] = mb_tolower(wca[i]);
-            }
-            break;
-          }
-        }
-      }
-    }
-
-    // Rule 2: No lower case, 2nd consecutive letter converted to
-    // upper case.
-    if (!has_lower) {
-      const char_u *p = compl_orig_text;
-      for (i = 0; i < min_len; i++) {
-        c = mb_ptr2char_adv(&p);
-        if (was_letter && mb_isupper(c) && mb_islower(wca[i])) {
-          // Rule 2 is satisfied.
-          for (i = actual_compl_length; i < actual_len; i++) {
-            wca[i] = mb_toupper(wca[i]);
-          }
-          break;
-        }
-        was_letter = mb_islower(c) || mb_isupper(c);
-      }
-    }
-
-    // Copy the original case of the part we typed.
-    {
-      const char_u *p = compl_orig_text;
-      for (i = 0; i < min_len; i++) {
-        c = mb_ptr2char_adv(&p);
-        if (mb_islower(c)) {
-          wca[i] = mb_tolower(wca[i]);
-        } else if (mb_isupper(c)) {
-          wca[i] = mb_toupper(wca[i]);
-        }
-      }
-    }
-
-    // Generate encoding specific output from wide character array.
-    // Multi-byte characters can occupy up to five bytes more than
-    // ASCII characters, and we also need one byte for NUL, so stay
-    // six bytes away from the edge of IObuff.
-    {
-      char_u *p = IObuff;
-      i = 0;
-      while (i < actual_len && (p - IObuff + 6) < IOSIZE) {
-        p += utf_char2bytes(wca[i++], (char *)p);
-      }
-      *p = NUL;
-    }
-
-    xfree(wca);
-
-    str = IObuff;
+    str = ins_compl_infercase_gettext(str, actual_len, actual_compl_length, min_len);
   }
   if (cont_s_ipos) {
     flags |= CP_CONT_S_IPOS;
@@ -661,7 +690,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
   if (compl_first_match != NULL && !adup) {
     match = compl_first_match;
     do {
-      if (!(match->cp_flags & CP_ORIGINAL_TEXT)
+      if (!match_at_original_text(match)
           && STRNCMP(match->cp_str, str, len) == 0
           && match->cp_str[len] == NUL) {
         FREE_CPTEXT(cptext, cptext_allocated);
@@ -777,6 +806,7 @@ static void ins_compl_longest_match(compl_T *match)
   if (compl_leader == NULL) {
     // First match, use it as a whole.
     compl_leader = vim_strsave(match->cp_str);
+
     had_match = (curwin->w_cursor.col > compl_col);
     ins_compl_delete();
     ins_bytes(compl_leader + get_compl_len());
@@ -788,40 +818,42 @@ static void ins_compl_longest_match(compl_T *match)
       ins_compl_delete();
     }
     compl_used_match = false;
-  } else {
-    // Reduce the text if this match differs from compl_leader.
-    p = compl_leader;
-    s = match->cp_str;
-    while (*p != NUL) {
-      c1 = utf_ptr2char((char *)p);
-      c2 = utf_ptr2char((char *)s);
-
-      if ((match->cp_flags & CP_ICASE)
-          ? (mb_tolower(c1) != mb_tolower(c2))
-          : (c1 != c2)) {
-        break;
-      }
-      MB_PTR_ADV(p);
-      MB_PTR_ADV(s);
-    }
 
-    if (*p != NUL) {
-      // Leader was shortened, need to change the inserted text.
-      *p = NUL;
-      had_match = (curwin->w_cursor.col > compl_col);
-      ins_compl_delete();
-      ins_bytes(compl_leader + get_compl_len());
-      ins_redraw(false);
+    return;
+  }
 
-      // When the match isn't there (to avoid matching itself) remove it
-      // again after redrawing.
-      if (!had_match) {
-        ins_compl_delete();
-      }
+  // Reduce the text if this match differs from compl_leader.
+  p = compl_leader;
+  s = match->cp_str;
+  while (*p != NUL) {
+    c1 = utf_ptr2char((char *)p);
+    c2 = utf_ptr2char((char *)s);
+
+    if ((match->cp_flags & CP_ICASE)
+        ? (mb_tolower(c1) != mb_tolower(c2))
+        : (c1 != c2)) {
+      break;
     }
+    MB_PTR_ADV(p);
+    MB_PTR_ADV(s);
+  }
 
-    compl_used_match = false;
+  if (*p != NUL) {
+    // Leader was shortened, need to change the inserted text.
+    *p = NUL;
+    had_match = (curwin->w_cursor.col > compl_col);
+    ins_compl_delete();
+    ins_bytes(compl_leader + get_compl_len());
+    ins_redraw(false);
+
+    // When the match isn't there (to avoid matching itself) remove it
+    // again after redrawing.
+    if (!had_match) {
+      ins_compl_delete();
+    }
   }
+
+  compl_used_match = false;
 }
 
 /// Add an array of matches to the list of matches.
@@ -846,20 +878,21 @@ static void ins_compl_add_matches(int num_matches, char **matches, int icase)
 /// Return the number of matches (excluding the original).
 static int ins_compl_make_cyclic(void)
 {
-  compl_T *match;
-  int count = 0;
+  if (compl_first_match == NULL) {
+    return 0;
+  }
 
-  if (compl_first_match != NULL) {
-    // Find the end of the list.
-    match = compl_first_match;
-    // there's always an entry for the compl_orig_text, it doesn't count.
-    while (match->cp_next != NULL && match->cp_next != compl_first_match) {
-      match = match->cp_next;
-      count++;
-    }
-    match->cp_next = compl_first_match;
-    compl_first_match->cp_prev = match;
+  // Find the end of the list.
+  compl_T *match = compl_first_match;
+  int count = 0;
+  // there's always an entry for the compl_orig_text, it doesn't count.
+  while (match->cp_next != NULL && match->cp_next != compl_first_match) {
+    match = match->cp_next;
+    count++;
   }
+  match->cp_next = compl_first_match;
+  compl_first_match->cp_prev = match;
+
   return count;
 }
 
@@ -898,10 +931,12 @@ static int compl_match_arraysize;
 /// Remove any popup menu.
 static void ins_compl_del_pum(void)
 {
-  if (compl_match_array != NULL) {
-    pum_undisplay(false);
-    XFREE_CLEAR(compl_match_array);
+  if (compl_match_array == NULL) {
+    return;
   }
+
+  pum_undisplay(false);
+  XFREE_CLEAR(compl_match_array);
 }
 
 /// Check if the popup menu should be displayed.
@@ -919,15 +954,14 @@ static bool pum_enough_matches(void)
 {
   // Don't display the popup menu if there are no matches or there is only
   // one (ignoring the original text).
-  compl_T *comp = compl_first_match;
+  compl_T *compl = compl_first_match;
   int i = 0;
   do {
-    if (comp == NULL
-        || ((comp->cp_flags & CP_ORIGINAL_TEXT) == 0 && ++i == 2)) {
+    if (compl == NULL || (!match_at_original_text(compl) && ++i == 2)) {
       break;
     }
-    comp = comp->cp_next;
-  } while (comp != compl_first_match);
+    compl = compl->cp_next;
+  } while (compl != compl_first_match);
 
   if (strstr((char *)p_cot, "menuone") != NULL) {
     return i >= 1;
@@ -1019,7 +1053,7 @@ void ins_compl_show_pum(void)
       lead_len = (int)STRLEN(compl_leader);
     }
     do {
-      if ((compl->cp_flags & CP_ORIGINAL_TEXT) == 0
+      if (!match_at_original_text(compl)
           && (compl_leader == NULL
               || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
         compl_match_arraysize++;
@@ -1034,14 +1068,14 @@ void ins_compl_show_pum(void)
     compl_match_array = xcalloc((size_t)compl_match_arraysize, sizeof(pumitem_T));
     // If the current match is the original text don't find the first
     // match after it, don't highlight anything.
-    if (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) {
+    if (match_at_original_text(compl_shown_match)) {
       shown_match_ok = true;
     }
 
     i = 0;
     compl = compl_first_match;
     do {
-      if ((compl->cp_flags & CP_ORIGINAL_TEXT) == 0
+      if (!match_at_original_text(compl)
           && (compl_leader == NULL
               || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
         if (!shown_match_ok) {
@@ -1080,7 +1114,7 @@ void ins_compl_show_pum(void)
 
         // When the original text is the shown match don't set
         // compl_shown_match.
-        if (compl->cp_flags & CP_ORIGINAL_TEXT) {
+        if (match_at_original_text(compl)) {
           shown_match_ok = true;
         }
 
@@ -1255,8 +1289,7 @@ static void ins_compl_files(int count, char **files, int thesaurus, int flags, r
 
     // Read dictionary file line by line.
     // Check each line for a match.
-    while (!got_int && !compl_interrupted
-           && !vim_fgets(buf, LSIZE, fp)) {
+    while (!got_int && !compl_interrupted && !vim_fgets(buf, LSIZE, fp)) {
       ptr = buf;
       while (vim_regexec(regmatch, (char *)buf, (colnr_T)(ptr - buf))) {
         ptr = regmatch->startp[0];
@@ -1603,13 +1636,13 @@ static void ins_compl_set_original_text(char_u *str)
   FUNC_ATTR_NONNULL_ALL
 {
   // Replace the original text entry.
-  // The CP_ORIGINAL_TEXT flag is either at the first item or might possibly be
-  // at the last item for backward completion
-  if (compl_first_match->cp_flags & CP_ORIGINAL_TEXT) {  // safety check
+  // The CP_ORIGINAL_TEXT flag is either at the first item or might possibly
+  // be at the last item for backward completion
+  if (match_at_original_text(compl_first_match)) {  // safety check
     xfree(compl_first_match->cp_str);
     compl_first_match->cp_str = vim_strsave(str);
   } else if (compl_first_match->cp_prev != NULL
-             && (compl_first_match->cp_prev->cp_flags & CP_ORIGINAL_TEXT)) {
+             && match_at_original_text(compl_first_match->cp_prev)) {
     xfree(compl_first_match->cp_prev->cp_str);
     compl_first_match->cp_prev->cp_str = vim_strsave(str);
   }
@@ -1628,20 +1661,20 @@ void ins_compl_addfrommatch(void)
   if ((int)STRLEN(p) <= len) {   // the match is too short
     // When still at the original match use the first entry that matches
     // the leader.
-    if (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) {
-      p = NULL;
-      for (cp = compl_shown_match->cp_next; cp != NULL
-           && cp != compl_first_match; cp = cp->cp_next) {
-        if (compl_leader == NULL
-            || ins_compl_equal(cp, compl_leader, STRLEN(compl_leader))) {
-          p = cp->cp_str;
-          break;
-        }
-      }
-      if (p == NULL || (int)STRLEN(p) <= len) {
-        return;
+    if (!match_at_original_text(compl_shown_match)) {
+      return;
+    }
+
+    p = NULL;
+    for (cp = compl_shown_match->cp_next; cp != NULL
+         && cp != compl_first_match; cp = cp->cp_next) {
+      if (compl_leader == NULL
+          || ins_compl_equal(cp, compl_leader, STRLEN(compl_leader))) {
+        p = cp->cp_str;
+        break;
       }
-    } else {
+    }
+    if (p == NULL || (int)STRLEN(p) <= len) {
       return;
     }
   }
@@ -2451,7 +2484,7 @@ static void get_complete_info(list_T *what_list, dict_T *retdict)
     if (ret == OK && compl_first_match != NULL) {
       compl_T *match = compl_first_match;
       do {
-        if (!(match->cp_flags & CP_ORIGINAL_TEXT)) {
+        if (!match_at_original_text(match)) {
           dict_T *di = tv_dict_alloc();
 
           tv_list_append_dict(li, di);
@@ -2516,105 +2549,101 @@ enum {
   INS_COMPL_CPT_END,
 };
 
-/// Process the next 'complete' option value in "e_cpt_arg".
+/// Process the next 'complete' option value in st->e_cpt.
 ///
 /// If successful, the arguments are set as below:
-///   e_cpt_arg - pointer to the next option value in 'e_cpt_arg'
+///   st->cpt - pointer to the next option value in "st->cpt"
 ///   compl_type_arg - type of insert mode completion to use
-///   found_all_arg - all matches of this type are found
-///   buf_arg - search for completions in this buffer
-///   first_match_pos - position of the first completion match
-///   last_match_pos - position of the last completion match
-///   set_match_pos - true if the first match position should be saved to avoid
-///                   loops after the search wraps around.
-///   dict - name of the dictionary or thesaurus file to search
-///   dict_f - flag specifying whether "dict" is an exact file name or not
+///   st->found_all - all matches of this type are found
+///   st->ins_buf - search for completions in this buffer
+///   st->first_match_pos - position of the first completion match
+///   st->last_match_pos - position of the last completion match
+///   st->set_match_pos - true if the first match position should be saved to
+///                       avoid loops after the search wraps around.
+///   st->dict - name of the dictionary or thesaurus file to search
+///   st->dict_f - flag specifying whether "dict" is an exact file name or not
 ///
 /// @return  INS_COMPL_CPT_OK if the next value is processed successfully.
 ///          INS_COMPL_CPT_CONT to skip the current value and process the next
 ///          option value.
-///          INS_COMPL_CPT_END if all the values in "e_cpt" are processed.
-static int process_next_cpt_value(char **e_cpt_arg, int *compl_type_arg, bool *found_all_arg,
-                                  buf_T **buf_arg, pos_T *start_match_pos, pos_T *first_match_pos,
-                                  pos_T *last_match_pos, bool *set_match_pos, char_u **dict_arg,
-                                  int *dict_flag)
+///          INS_COMPL_CPT_END if all the values in "st->e_cpt" are processed.
+static int process_next_cpt_value(ins_compl_next_state_T *st, int *compl_type_arg,
+                                  pos_T *start_match_pos)
 {
-  char *e_cpt = *e_cpt_arg;
   int compl_type = -1;
   int status = INS_COMPL_CPT_OK;
-  buf_T *buf = *buf_arg;
-  bool found_all = false;
-  char_u *dict = NULL;
-  int dict_f = 0;
 
-  while (*e_cpt == ',' || *e_cpt == ' ') {
-    e_cpt++;
+  st->found_all = false;
+
+  while (*st->e_cpt == ',' || *st->e_cpt == ' ') {
+    st->e_cpt++;
   }
-  if (*e_cpt == '.' && !curbuf->b_scanned) {
-    buf = curbuf;
-    *first_match_pos = *start_match_pos;
+
+  if (*st->e_cpt == '.' && !curbuf->b_scanned) {
+    st->ins_buf = curbuf;
+    st->first_match_pos = *start_match_pos;
     // Move the cursor back one character so that ^N can match the
     // word immediately after the cursor.
-    if (ctrl_x_mode_normal() && dec(first_match_pos) < 0) {
+    if (ctrl_x_mode_normal() && dec(&st->first_match_pos) < 0) {
       // Move the cursor to after the last character in the
       // buffer, so that word at start of buffer is found
       // correctly.
-      first_match_pos->lnum = buf->b_ml.ml_line_count;
-      first_match_pos->col = (colnr_T)STRLEN(ml_get(first_match_pos->lnum));
+      st->first_match_pos.lnum = st->ins_buf->b_ml.ml_line_count;
+      st->first_match_pos.col = (colnr_T)STRLEN(ml_get(st->first_match_pos.lnum));
     }
-    *last_match_pos = *first_match_pos;
+    st->last_match_pos = st->first_match_pos;
     compl_type = 0;
 
     // Remember the first match so that the loop stops when we
     // wrap and come back there a second time.
-    *set_match_pos = true;
-  } else if (vim_strchr("buwU", *e_cpt) != NULL
-             && (buf = ins_compl_next_buf(buf, *e_cpt)) != curbuf) {
+    st->set_match_pos = true;
+  } else if (vim_strchr("buwU", *st->e_cpt) != NULL
+             && (st->ins_buf = ins_compl_next_buf(st->ins_buf, *st->e_cpt)) != curbuf) {
     // Scan a buffer, but not the current one.
-    if (buf->b_ml.ml_mfp != NULL) {  // loaded buffer
+    if (st->ins_buf->b_ml.ml_mfp != NULL) {  // loaded buffer
       compl_started = true;
-      first_match_pos->col = last_match_pos->col = 0;
-      first_match_pos->lnum = buf->b_ml.ml_line_count + 1;
-      last_match_pos->lnum = 0;
+      st->first_match_pos.col = st->last_match_pos.col = 0;
+      st->first_match_pos.lnum = st->ins_buf->b_ml.ml_line_count + 1;
+      st->last_match_pos.lnum = 0;
       compl_type = 0;
     } else {  // unloaded buffer, scan like dictionary
-      found_all = true;
-      if (buf->b_fname == NULL) {
+      st->found_all = true;
+      if (st->ins_buf->b_fname == NULL) {
         status = INS_COMPL_CPT_CONT;
         goto done;
       }
       compl_type = CTRL_X_DICTIONARY;
-      dict = (char_u *)buf->b_fname;
-      dict_f = DICT_EXACT;
+      st->dict = (char_u *)st->ins_buf->b_fname;
+      st->dict_f = DICT_EXACT;
     }
     msg_hist_off = true;  // reset in msg_trunc_attr()
     vim_snprintf((char *)IObuff, IOSIZE, _("Scanning: %s"),
-                 buf->b_fname == NULL
-                 ? buf_spname(buf)
-                 : buf->b_sfname == NULL
-                 ? buf->b_fname
-                 : buf->b_sfname);
+                 st->ins_buf->b_fname == NULL
+                 ? buf_spname(st->ins_buf)
+                 : st->ins_buf->b_sfname == NULL
+                 ? st->ins_buf->b_fname
+                 : st->ins_buf->b_sfname);
     (void)msg_trunc_attr((char *)IObuff, true, HL_ATTR(HLF_R));
-  } else if (*e_cpt == NUL) {
+  } else if (*st->e_cpt == NUL) {
     status = INS_COMPL_CPT_END;
   } else {
     if (ctrl_x_mode_line_or_eval()) {
       compl_type = -1;
-    } else if (*e_cpt == 'k' || *e_cpt == 's') {
-      if (*e_cpt == 'k') {
+    } else if (*st->e_cpt == 'k' || *st->e_cpt == 's') {
+      if (*st->e_cpt == 'k') {
         compl_type = CTRL_X_DICTIONARY;
       } else {
         compl_type = CTRL_X_THESAURUS;
       }
-      if (*++e_cpt != ',' && *e_cpt != NUL) {
-        dict = (char_u *)e_cpt;
-        dict_f = DICT_FIRST;
+      if (*++st->e_cpt != ',' && *st->e_cpt != NUL) {
+        st->dict = (char_u *)st->e_cpt;
+        st->dict_f = DICT_FIRST;
       }
-    } else if (*e_cpt == 'i') {
+    } else if (*st->e_cpt == 'i') {
       compl_type = CTRL_X_PATH_PATTERNS;
-    } else if (*e_cpt == 'd') {
+    } else if (*st->e_cpt == 'd') {
       compl_type = CTRL_X_PATH_DEFINES;
-    } else if (*e_cpt == ']' || *e_cpt == 't') {
+    } else if (*st->e_cpt == ']' || *st->e_cpt == 't') {
       msg_hist_off = true;  // reset in msg_trunc_attr()
       compl_type = CTRL_X_TAGS;
       vim_snprintf((char *)IObuff, IOSIZE, "%s", _("Scanning tags."));
@@ -2624,21 +2653,16 @@ static int process_next_cpt_value(char **e_cpt_arg, int *compl_type_arg, bool *f
     }
 
     // in any case e_cpt is advanced to the next entry
-    (void)copy_option_part(&e_cpt, (char *)IObuff, IOSIZE, ",");
+    (void)copy_option_part(&st->e_cpt, (char *)IObuff, IOSIZE, ",");
 
-    found_all = true;
+    st->found_all = true;
     if (compl_type == -1) {
       status = INS_COMPL_CPT_CONT;
     }
   }
 
 done:
-  *e_cpt_arg = e_cpt;
   *compl_type_arg = compl_type;
-  *found_all_arg = found_all;
-  *buf_arg = buf;
-  *dict_arg = dict;
-  *dict_flag = dict_f;
   return status;
 }
 
@@ -2656,20 +2680,19 @@ static void get_next_include_file_completion(int compl_type)
 
 /// Get the next set of words matching "compl_pattern" in dictionary or
 /// thesaurus files.
-static void get_next_dict_tsr_completion(int compl_type, char_u **dict, int dict_f)
+static void get_next_dict_tsr_completion(int compl_type, char_u *dict, int dict_f)
 {
   if (thesaurus_func_complete(compl_type)) {
     expand_by_function(compl_type, (char_u *)compl_pattern);
   } else {
-    ins_compl_dictionaries(*dict != NULL ? *dict
+    ins_compl_dictionaries(dict != NULL ? dict
                            : (compl_type == CTRL_X_THESAURUS
                               ? (*curbuf->b_p_tsr == NUL ? p_tsr : curbuf->b_p_tsr)
                               : (*curbuf->b_p_dict == NUL ? p_dict : curbuf->b_p_dict)),
                            (char_u *)compl_pattern,
-                           *dict != NULL ? dict_f : 0,
+                           dict != NULL ? dict_f : 0,
                            compl_type == CTRL_X_THESAURUS);
   }
-  *dict = NULL;
 }
 
 /// Get the next set of tag names matching "compl_pattern".
@@ -2833,29 +2856,18 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
 
 /// Get the next set of words matching "compl_pattern" for default completion(s)
 /// (normal ^P/^N and ^X^L).
-/// Search for "compl_pattern" in the buffer "ins_buf" starting from the
-/// position "start_pos" in the "compl_direction" direction. If "save_match_pos"
-/// is true, then set the "first_match_pos" and "last_match_pos".
-///
-/// @param ins_buf          buffer being scanned
-/// @param start_pos        search start position
-/// @param cur_match_pos    current match position
-/// @param prev_match_pos   previous match position
-/// @param save_match_pos   set first_match_pos/last_match_pos
-/// @param first_match_pos  first match position
-/// @param last_match_pos   last match position
-/// @param scan_curbuf      scan current buffer for completion
+/// Search for "compl_pattern" in the buffer "st->ins_buf" starting from the
+/// position "st->start_pos" in the "compl_direction" direction. If
+/// "st->set_match_pos" is true, then set the "st->first_match_pos" and
+/// "st->last_match_pos".
 ///
 /// @return  OK if a new next match is found, otherwise FAIL.
-static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *cur_match_pos,
-                                       pos_T *prev_match_pos, bool *save_match_pos,
-                                       pos_T *first_match_pos, pos_T *last_match_pos,
-                                       bool scan_curbuf)
+static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_pos)
 {
   // If 'infercase' is set, don't use 'smartcase' here
   const int save_p_scs = p_scs;
-  assert(ins_buf);
-  if (ins_buf->b_p_inf) {
+  assert(st->ins_buf);
+  if (st->ins_buf->b_p_inf) {
     p_scs = false;
   }
 
@@ -2864,9 +2876,9 @@ static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *
   // buffers is a good idea, on the other hand, we always set
   // wrapscan for curbuf to avoid missing matches -- Acevedo,Webb
   const int save_p_ws = p_ws;
-  if (ins_buf != curbuf) {
+  if (st->ins_buf != curbuf) {
     p_ws = false;
-  } else if (scan_curbuf) {
+  } else if (*st->e_cpt == '.') {
     p_ws = true;
   }
   bool looped_around = false;
@@ -2879,62 +2891,61 @@ static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *
     // has added a word that was at the beginning of the line.
     if (ctrl_x_mode_line_or_eval()
         || (compl_cont_status & CONT_SOL)) {
-      found_new_match = search_for_exact_line(ins_buf, cur_match_pos,
+      found_new_match = search_for_exact_line(st->ins_buf, st->cur_match_pos,
                                               compl_direction, (char_u *)compl_pattern);
     } else {
-      found_new_match = searchit(NULL, ins_buf, cur_match_pos, NULL,
-                                 compl_direction,
-                                 (char_u *)compl_pattern, 1L, SEARCH_KEEP + SEARCH_NFMSG,
-                                 RE_LAST, NULL);
+      found_new_match = searchit(NULL, st->ins_buf, st->cur_match_pos,
+                                 NULL, compl_direction, (char_u *)compl_pattern, 1L,
+                                 SEARCH_KEEP + SEARCH_NFMSG, RE_LAST, NULL);
     }
     msg_silent--;
-    if (!compl_started || *save_match_pos) {
+    if (!compl_started || st->set_match_pos) {
       // set "compl_started" even on fail
       compl_started = true;
-      *first_match_pos = *cur_match_pos;
-      *last_match_pos = *cur_match_pos;
-      *save_match_pos = false;
-    } else if (first_match_pos->lnum == last_match_pos->lnum
-               && first_match_pos->col == last_match_pos->col) {
+      st->first_match_pos = *st->cur_match_pos;
+      st->last_match_pos = *st->cur_match_pos;
+      st->set_match_pos = false;
+    } else if (st->first_match_pos.lnum == st->last_match_pos.lnum
+               && st->first_match_pos.col == st->last_match_pos.col) {
       found_new_match = FAIL;
     } else if ((compl_direction == FORWARD)
-               && (prev_match_pos->lnum > cur_match_pos->lnum
-                   || (prev_match_pos->lnum == cur_match_pos->lnum
-                       && prev_match_pos->col >= cur_match_pos->col))) {
+               && (st->prev_match_pos.lnum > st->cur_match_pos->lnum
+                   || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
+                       && st->prev_match_pos.col >= st->cur_match_pos->col))) {
       if (looped_around) {
         found_new_match = FAIL;
       } else {
         looped_around = true;
       }
     } else if ((compl_direction != FORWARD)
-               && (prev_match_pos->lnum < cur_match_pos->lnum
-                   || (prev_match_pos->lnum == cur_match_pos->lnum
-                       && prev_match_pos->col <= cur_match_pos->col))) {
+               && (st->prev_match_pos.lnum < st->cur_match_pos->lnum
+                   || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
+                       && st->prev_match_pos.col <= st->cur_match_pos->col))) {
       if (looped_around) {
         found_new_match = FAIL;
       } else {
         looped_around = true;
       }
     }
-    *prev_match_pos = *cur_match_pos;
+    st->prev_match_pos = *st->cur_match_pos;
     if (found_new_match == FAIL) {
       break;
     }
 
     // when ADDING, the text before the cursor matches, skip it
-    if ((compl_cont_status & CONT_ADDING) && ins_buf == curbuf
-        && start_pos->lnum == cur_match_pos->lnum
-        && start_pos->col == cur_match_pos->col) {
+    if ((compl_cont_status & CONT_ADDING) && st->ins_buf == curbuf
+        && start_pos->lnum == st->cur_match_pos->lnum
+        && start_pos->col == st->cur_match_pos->col) {
       continue;
     }
     int len;
-    char_u *ptr = ins_comp_get_next_word_or_line(ins_buf, cur_match_pos, &len,
-                                                 &cont_s_ipos);
+    char_u *ptr = ins_comp_get_next_word_or_line(st->ins_buf, st->cur_match_pos,
+                                                 &len, &cont_s_ipos);
     if (ptr == NULL) {
       continue;
     }
     if (ins_compl_add_infercase(ptr, len, p_ic,
-                                ins_buf == curbuf ? NULL : (char_u *)ins_buf->b_sfname,
+                                st->ins_buf == curbuf ? NULL : (char_u *)st->ins_buf->b_sfname,
                                 0, cont_s_ipos) != NOTDONE) {
       found_new_match = OK;
       break;
@@ -2946,6 +2957,64 @@ static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *
   return found_new_match;
 }
 
+/// get the next set of completion matches for 'type'.
+/// @return  true if a new match is found, otherwise false.
+static bool get_next_completion_match(int type, ins_compl_next_state_T *st, pos_T *ini)
+{
+  int found_new_match = FAIL;
+
+  switch (type) {
+  case -1:
+    break;
+  case CTRL_X_PATH_PATTERNS:
+  case CTRL_X_PATH_DEFINES:
+    get_next_include_file_completion(type);
+    break;
+
+  case CTRL_X_DICTIONARY:
+  case CTRL_X_THESAURUS:
+    get_next_dict_tsr_completion(type, st->dict, st->dict_f);
+    st->dict = NULL;
+    break;
+
+  case CTRL_X_TAGS:
+    get_next_tag_completion();
+    break;
+
+  case CTRL_X_FILES:
+    get_next_filename_completion();
+    break;
+
+  case CTRL_X_CMDLINE:
+  case CTRL_X_CMDLINE_CTRL_X:
+    get_next_cmdline_completion();
+    break;
+
+  case CTRL_X_FUNCTION:
+  case CTRL_X_OMNI:
+    expand_by_function(type, (char_u *)compl_pattern);
+    break;
+
+  case CTRL_X_SPELL:
+    get_next_spell_completion(st->first_match_pos.lnum);
+    break;
+
+  default:            // normal ^P/^N and ^X^L
+    found_new_match = get_next_default_completion(st, ini);
+    if (found_new_match == FAIL && st->ins_buf == curbuf) {
+      st->found_all = true;
+    }
+  }
+
+  // check if compl_curr_match has changed, (e.g. other type of
+  // expansion added something)
+  if (type != 0 && compl_curr_match != compl_old_match) {
+    found_new_match = OK;
+  }
+
+  return found_new_match;
+}
+
 /// Get the next expansion(s), using "compl_pattern".
 /// The search starts at position "ini" in curbuf and in the direction
 /// compl_direction.
@@ -2955,21 +3024,10 @@ static int get_next_default_completion(buf_T *ins_buf, pos_T *start_pos, pos_T *
 /// Return the total number of matches or -1 if still unknown -- Acevedo
 static int ins_compl_get_exp(pos_T *ini)
 {
-  static pos_T first_match_pos;
-  static pos_T last_match_pos;
-  static char *e_cpt = "";               // curr. entry in 'complete'
-  static bool found_all = false;         // Found all matches of a
-                                         // certain type.
-  static buf_T *ins_buf = NULL;          // buffer being scanned
-
-  pos_T *pos;
+  static ins_compl_next_state_T st;
   int i;
   int found_new_match;
   int type = ctrl_x_mode;
-  char_u *dict = NULL;
-  int dict_f = 0;
-  bool set_match_pos;
-  pos_T prev_pos = { 0, 0, 0 };
 
   assert(curbuf != NULL);
 
@@ -2977,31 +3035,30 @@ static int ins_compl_get_exp(pos_T *ini)
     FOR_ALL_BUFFERS(buf) {
       buf->b_scanned = false;
     }
-    found_all = false;
-    ins_buf = curbuf;
-    e_cpt = (compl_cont_status & CONT_LOCAL) ? "." : (char *)curbuf->b_p_cpt;
-    last_match_pos = first_match_pos = *ini;
-  } else if (ins_buf != curbuf && !buf_valid(ins_buf)) {
-    ins_buf = curbuf;  // In case the buffer was wiped out.
+    st.found_all = false;
+    st.ins_buf = curbuf;
+    st.e_cpt = (compl_cont_status & CONT_LOCAL) ? "." : (char *)curbuf->b_p_cpt;
+    st.last_match_pos = st.first_match_pos = *ini;
+  } else if (st.ins_buf != curbuf && !buf_valid(st.ins_buf)) {
+    st.ins_buf = curbuf;  // In case the buffer was wiped out.
   }
-  assert(ins_buf != NULL);
+  assert(st.ins_buf != NULL);
 
   compl_old_match = compl_curr_match;   // remember the last current match
-  pos = (compl_direction == FORWARD) ? &last_match_pos : &first_match_pos;
+  st.cur_match_pos = (compl_direction == FORWARD
+                      ? &st.last_match_pos : &st.first_match_pos);
 
   // For ^N/^P loop over all the flags/windows/buffers in 'complete'
   for (;;) {
     found_new_match = FAIL;
-    set_match_pos = false;
+    st.set_match_pos = false;
 
     // For ^N/^P pick a new entry from e_cpt if compl_started is off,
     // or if found_all says this entry is done.  For ^X^L only use the
     // entries from 'complete' that look in loaded buffers.
     if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval())
-        && (!compl_started || found_all)) {
-      int status = process_next_cpt_value(&e_cpt, &type, &found_all,
-                                          &ins_buf, ini, &first_match_pos, &last_match_pos,
-                                          &set_match_pos, &dict, &dict_f);
+        && (!compl_started || st.found_all)) {
+      int status = process_next_cpt_value(&st, &type, ini);
       if (status == INS_COMPL_CPT_END) {
         break;
       }
@@ -3016,55 +3073,8 @@ static int ins_compl_get_exp(pos_T *ini)
       break;
     }
 
-    switch (type) {
-    case -1:
-      break;
-    case CTRL_X_PATH_PATTERNS:
-    case CTRL_X_PATH_DEFINES:
-      get_next_include_file_completion(type);
-      break;
-
-    case CTRL_X_DICTIONARY:
-    case CTRL_X_THESAURUS:
-      get_next_dict_tsr_completion(type, &dict, dict_f);
-      break;
-
-    case CTRL_X_TAGS:
-      get_next_tag_completion();
-      break;
-
-    case CTRL_X_FILES:
-      get_next_filename_completion();
-      break;
-
-    case CTRL_X_CMDLINE:
-    case CTRL_X_CMDLINE_CTRL_X:
-      get_next_cmdline_completion();
-      break;
-
-    case CTRL_X_FUNCTION:
-    case CTRL_X_OMNI:
-      expand_by_function(type, (char_u *)compl_pattern);
-      break;
-
-    case CTRL_X_SPELL:
-      get_next_spell_completion(first_match_pos.lnum);
-      break;
-
-    default:            // normal ^P/^N and ^X^L
-      found_new_match = get_next_default_completion(ins_buf, ini, pos, &prev_pos,
-                                                    &set_match_pos, &first_match_pos,
-                                                    &last_match_pos, (*e_cpt == '.'));
-      if (found_new_match == FAIL && ins_buf == curbuf) {
-        found_all = true;
-      }
-    }
-
-    // check if compl_curr_match has changed, (e.g. other type of
-    // expansion added something)
-    if (type != 0 && compl_curr_match != compl_old_match) {
-      found_new_match = OK;
-    }
+    // get the next set of completion matches
+    found_new_match = get_next_completion_match(type, &st, ini);
 
     // break the loop for specialized modes (use 'complete' just for the
     // generic ctrl_x_mode == CTRL_X_NORMAL) or when we've found a new match
@@ -3088,8 +3098,8 @@ static int ins_compl_get_exp(pos_T *ini)
     } else {
       // Mark a buffer scanned when it has been scanned completely
       if (type == 0 || type == CTRL_X_PATH_PATTERNS) {
-        assert(ins_buf);
-        ins_buf->b_scanned = true;
+        assert(st.ins_buf);
+        st.ins_buf->b_scanned = true;
       }
 
       compl_started = false;
@@ -3099,7 +3109,7 @@ static int ins_compl_get_exp(pos_T *ini)
 
   if ((ctrl_x_mode_normal()
        || ctrl_x_mode_line_or_eval())
-      && *e_cpt == NUL) {  // Got to end of 'complete'
+      && *st.e_cpt == NUL) {  // Got to end of 'complete'
     found_new_match = FAIL;
   }
 
@@ -3178,7 +3188,7 @@ void ins_compl_delete(void)
 void ins_compl_insert(bool in_compl_func)
 {
   ins_bytes(compl_shown_match->cp_str + get_compl_len());
-  compl_used_match = !(compl_shown_match->cp_flags & CP_ORIGINAL_TEXT);
+  compl_used_match = !match_at_original_text(compl_shown_match);
 
   dict_T *dict = ins_compl_dict_alloc(compl_shown_match);
   set_vim_var_dict(VV_COMPLETED_ITEM, dict);
@@ -3285,7 +3295,7 @@ static int find_next_completion_match(bool allow_get_expansion, int todo, bool a
       }
       found_end = false;
     }
-    if ((compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0
+    if (!match_at_original_text(compl_shown_match)
         && compl_leader != NULL
         && !ins_compl_equal(compl_shown_match,
                             compl_leader, STRLEN(compl_leader))) {
@@ -3340,7 +3350,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
   }
 
   if (compl_leader != NULL
-      && (compl_shown_match->cp_flags & CP_ORIGINAL_TEXT) == 0) {
+      && !match_at_original_text(compl_shown_match)) {
     // Update "compl_shown_match" to the actually shown match
     ins_compl_update_shown_match();
   }
@@ -3993,7 +4003,7 @@ static void ins_compl_show_statusmsg(void)
   }
 
   if (edit_submode_extra == NULL) {
-    if (compl_curr_match->cp_flags & CP_ORIGINAL_TEXT) {
+    if (match_at_original_text(compl_curr_match)) {
       edit_submode_extra = (char_u *)_("Back at original");
       edit_submode_highl = HLF_W;
     } else if (compl_cont_status & CONT_S_IPOS) {
-- 
cgit 


From f91b1885ddeaf971e17afe49b80f1b1412ecc8a2 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 21:02:45 +0800
Subject: feat(eval)!: make Vim functions return inner window width and height
 (#19743)

In non-multigrid UI the only change is that the returned height now
excludes winbar, and this is compatible with Vim.

In multigrid UI this means the return value of these functions now
reflect the space available for buffer lines in a window.

No change in nvim_win_get_height() and nvim_win_get_width().
---
 src/nvim/eval.c       | 4 ++--
 src/nvim/eval/funcs.c | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 04f7347e1c..10bfbf55bf 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -5228,12 +5228,12 @@ dict_T *get_win_info(win_T *wp, int16_t tpnr, int16_t winnr)
   tv_dict_add_nr(dict, S_LEN("tabnr"), tpnr);
   tv_dict_add_nr(dict, S_LEN("winnr"), winnr);
   tv_dict_add_nr(dict, S_LEN("winid"), wp->handle);
-  tv_dict_add_nr(dict, S_LEN("height"), wp->w_height);
+  tv_dict_add_nr(dict, S_LEN("height"), wp->w_height_inner);
   tv_dict_add_nr(dict, S_LEN("winrow"), wp->w_winrow + 1);
   tv_dict_add_nr(dict, S_LEN("topline"), wp->w_topline);
   tv_dict_add_nr(dict, S_LEN("botline"), wp->w_botline - 1);
   tv_dict_add_nr(dict, S_LEN("winbar"), wp->w_winbar_height);
-  tv_dict_add_nr(dict, S_LEN("width"), wp->w_width);
+  tv_dict_add_nr(dict, S_LEN("width"), wp->w_width_inner);
   tv_dict_add_nr(dict, S_LEN("bufnr"), wp->w_buffer->b_fnum);
   tv_dict_add_nr(dict, S_LEN("wincol"), wp->w_wincol + 1);
   tv_dict_add_nr(dict, S_LEN("textoff"), win_col_off(wp));
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 8d5b8c850c..77a5e7eea3 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -9771,7 +9771,7 @@ static void f_winheight(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (wp == NULL) {
     rettv->vval.v_number = -1;
   } else {
-    rettv->vval.v_number = wp->w_height;
+    rettv->vval.v_number = wp->w_height_inner;
   }
 }
 
@@ -9909,7 +9909,7 @@ static void f_winwidth(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (wp == NULL) {
     rettv->vval.v_number = -1;
   } else {
-    rettv->vval.v_number = wp->w_width;
+    rettv->vval.v_number = wp->w_width_inner;
   }
 }
 
-- 
cgit 


From b1eaa2b9a3bae46f6dcbab8dc3a84e0044b11317 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Wed, 24 Aug 2022 14:41:31 +0100
Subject: feat(lua): add vim.iconv (#18286)

Co-authored-by: Justin M. Keyes <justinkz@gmail.com>
---
 src/nvim/lua/stdlib.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 5a82ae30b5..64e9abe0c9 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -474,6 +474,52 @@ static int nlua_stricmp(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   return 1;
 }
 
+#if defined(HAVE_ICONV)
+
+/// Convert string from one encoding to another
+static int nlua_iconv(lua_State *lstate)
+{
+  int narg = lua_gettop(lstate);
+
+  if (narg < 3) {
+    return luaL_error(lstate, "Expected at least 3 arguments");
+  }
+
+  for (int i = 1; i <= 3; i++) {
+    if (lua_type(lstate, i) != LUA_TSTRING) {
+      return luaL_argerror(lstate, i, "expected string");
+    }
+  }
+
+  size_t str_len = 0;
+  const char *str = lua_tolstring(lstate, 1, &str_len);
+
+  char_u *from = enc_canonize(enc_skip((char_u *)lua_tolstring(lstate, 2, NULL)));
+  char_u *to   = enc_canonize(enc_skip((char_u *)lua_tolstring(lstate, 3, NULL)));
+
+  vimconv_T vimconv;
+  vimconv.vc_type = CONV_NONE;
+  convert_setup_ext(&vimconv, from, false, to, false);
+
+  char_u *ret = string_convert(&vimconv, (char_u *)str, &str_len);
+
+  convert_setup(&vimconv, NULL, NULL);
+
+  xfree(from);
+  xfree(to);
+
+  if (ret == NULL) {
+    lua_pushnil(lstate);
+  } else {
+    lua_pushlstring(lstate, (char *)ret, str_len);
+    xfree(ret);
+  }
+
+  return 1;
+}
+
+#endif
+
 void nlua_state_add_stdlib(lua_State *const lstate, bool is_thread)
 {
   if (!is_thread) {
@@ -519,6 +565,13 @@ void nlua_state_add_stdlib(lua_State *const lstate, bool is_thread)
     // vim.spell
     luaopen_spell(lstate);
     lua_setfield(lstate, -2, "spell");
+
+#if defined(HAVE_ICONV)
+    // vim.iconv
+    // depends on p_ambw, p_emoji
+    lua_pushcfunction(lstate, &nlua_iconv);
+    lua_setfield(lstate, -2, "iconv");
+#endif
   }
 
   // vim.mpack
-- 
cgit 


From 26ebf67c39d3776095706fafe34eea2e37013579 Mon Sep 17 00:00:00 2001
From: Thomas Vigouroux <thomas.vigouroux@protonmail.com>
Date: Wed, 24 Aug 2022 16:22:50 +0200
Subject: test(treesitter): make internal lang test pending when necessary

---
 src/nvim/lua/executor.c   |  3 +++
 src/nvim/lua/treesitter.c | 12 ++++++++++++
 2 files changed, 15 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 8cd0e9937b..38bc187f4f 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1662,6 +1662,9 @@ static void nlua_add_treesitter(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   lua_pushcfunction(lstate, tslua_has_language);
   lua_setfield(lstate, -2, "_ts_has_language");
 
+  lua_pushcfunction(lstate, tslua_remove_lang);
+  lua_setfield(lstate, -2, "_ts_remove_language");
+
   lua_pushcfunction(lstate, tslua_inspect_lang);
   lua_setfield(lstate, -2, "_ts_inspect_language");
 
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 90b13181fb..8b47939169 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -21,6 +21,7 @@
 #include "nvim/lib/kvec.h"
 #include "nvim/log.h"
 #include "nvim/lua/treesitter.h"
+#include "nvim/map.h"
 #include "nvim/memline.h"
 #include "tree_sitter/api.h"
 
@@ -210,6 +211,17 @@ int tslua_add_language(lua_State *L)
   return 1;
 }
 
+int tslua_remove_lang(lua_State *L)
+{
+  const char *lang_name = luaL_checkstring(L, 1);
+  bool present = pmap_has(cstr_t)(&langs, lang_name);
+  if (present) {
+    pmap_del(cstr_t)(&langs, lang_name);
+  }
+  lua_pushboolean(L, present);
+  return 1;
+}
+
 int tslua_inspect_lang(lua_State *L)
 {
   const char *lang_name = luaL_checkstring(L, 1);
-- 
cgit 


From 61be343ec8c5e4d504db7ba975b20af2f46ce50d Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Thu, 18 Aug 2022 14:23:04 +0100
Subject: feat(highlight)!: error on invalid names and allow '.' and '@'

Previously if a highlight group with a name outside the regexp
[a-zA-Z0-9_] was defined, Nvim would emit an "invalid character"
warning message. This was annoying for Lua scripts, as it was very hard
to debug what line of code was triggering this message since it didn't
produce a stack trace.

This has now been promoted to an error with the code E5248.

Additionally the ASCII character period ('.') and at-sign ('@') have
been added to the allowed list of characters of a highlight group name
to support the application of defining hierarchical highlight groups,
e.g. 'TS.keyword'.

Co-authored-by: Christian Clason <christian.clason@uni-due.de>
---
 src/nvim/globals.h               | 2 ++
 src/nvim/highlight_group.c       | 8 ++++----
 src/nvim/po/af.po                | 4 ++--
 src/nvim/po/ca.po                | 6 +++---
 src/nvim/po/cs.cp1250.po         | 6 +++---
 src/nvim/po/cs.po                | 6 +++---
 src/nvim/po/da.po                | 4 ++--
 src/nvim/po/de.po                | 4 ++--
 src/nvim/po/en_GB.po             | 4 ++--
 src/nvim/po/eo.po                | 4 ++--
 src/nvim/po/es.po                | 6 +++---
 src/nvim/po/fi.po                | 4 ++--
 src/nvim/po/fr.po                | 4 ++--
 src/nvim/po/ga.po                | 4 ++--
 src/nvim/po/it.po                | 6 +++---
 src/nvim/po/ko.UTF-8.po          | 6 +++---
 src/nvim/po/nb.po                | 6 +++---
 src/nvim/po/nl.po                | 4 ++--
 src/nvim/po/no.po                | 6 +++---
 src/nvim/po/pl.UTF-8.po          | 6 +++---
 src/nvim/po/pt_BR.po             | 4 ++--
 src/nvim/po/ru.po                | 6 +++---
 src/nvim/po/sk.cp1250.po         | 6 +++---
 src/nvim/po/sk.po                | 6 +++---
 src/nvim/po/sr.po                | 4 ++--
 src/nvim/po/sv.po                | 4 ++--
 src/nvim/po/tr.po                | 4 ++--
 src/nvim/po/uk.po                | 4 ++--
 src/nvim/po/vi.po                | 6 +++---
 src/nvim/po/zh_CN.UTF-8.po       | 6 +++---
 src/nvim/po/zh_TW.UTF-8.po       | 6 +++---
 src/nvim/testdir/test_syntax.vim | 2 +-
 32 files changed, 80 insertions(+), 78 deletions(-)

(limited to 'src')

diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 231220c319..67cd21e172 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -1021,6 +1021,8 @@ EXTERN char e_resulting_text_too_long[] INIT(= N_("E1240: Resulting text too lon
 
 EXTERN char e_line_number_out_of_range[] INIT(= N_("E1247: Line number out of range"));
 
+EXTERN char e_highlight_group_name_invalid_char[] INIT(= N_("E5248: Invalid character in group name"));
+
 EXTERN char e_highlight_group_name_too_long[] INIT(= N_("E1249: Highlight group name too long"));
 
 EXTERN char e_undobang_cannot_redo_or_move_branch[]
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 04aecc6c3a..ab241516e4 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -1750,11 +1750,11 @@ static int syn_add_group(const char *name, size_t len)
     if (!vim_isprintc(c)) {
       emsg(_("E669: Unprintable character in group name"));
       return 0;
-    } else if (!ASCII_ISALNUM(c) && c != '_') {
-      // This is an error, but since there previously was no check only give a warning.
+    } else if (!ASCII_ISALNUM(c) && c != '_' && c != '.' && c != '@') {
+      // '.' and '@' are allowed characters for use with treesitter capture names.
       msg_source(HL_ATTR(HLF_W));
-      msg(_("W18: Invalid character in group name"));
-      break;
+      emsg(_(e_highlight_group_name_invalid_char));
+      return 0;
     }
   }
 
diff --git a/src/nvim/po/af.po b/src/nvim/po/af.po
index 82345f8a46..d64789660e 100644
--- a/src/nvim/po/af.po
+++ b/src/nvim/po/af.po
@@ -5320,8 +5320,8 @@ msgstr "E424: Te veel verskillende uitlig-eienskappe in gebruik"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Onvertoonbare karakter in groepnaam"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ongeldige karakter groepnaam"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ongeldige karakter groepnaam"
 
 #~ msgid "E849: Too many highlight and syntax groups"
 #~ msgstr ""
diff --git a/src/nvim/po/ca.po b/src/nvim/po/ca.po
index 6c4d6ddd22..5869e6567c 100644
--- a/src/nvim/po/ca.po
+++ b/src/nvim/po/ca.po
@@ -5983,9 +5983,9 @@ msgstr "E424: Hi ha massa atributs de ressalt diferents en 
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Car�cter no imprimible en el nom del grup"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Hi ha un car�cter no v�lid en el nom del grup"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Hi ha un car�cter no v�lid en el nom del grup"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/cs.cp1250.po b/src/nvim/po/cs.cp1250.po
index 859039eb87..bce5c0fa76 100644
--- a/src/nvim/po/cs.cp1250.po
+++ b/src/nvim/po/cs.cp1250.po
@@ -6072,10 +6072,10 @@ msgstr ""
 msgid "E669: Unprintable character in group name"
 msgstr ""
 
-#: ../syntax.c:7434
+#: ../highlight_group.c:1756
 #, fuzzy
-msgid "W18: Invalid character in group name"
-msgstr "E182: Chybn� jm�no p��kazu"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Chybn� jm�no p��kazu"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/cs.po b/src/nvim/po/cs.po
index 4d9ad58836..f4eab3f0d4 100644
--- a/src/nvim/po/cs.po
+++ b/src/nvim/po/cs.po
@@ -6072,10 +6072,10 @@ msgstr ""
 msgid "E669: Unprintable character in group name"
 msgstr ""
 
-#: ../syntax.c:7434
+#: ../highlight_group.c:1756
 #, fuzzy
-msgid "W18: Invalid character in group name"
-msgstr "E182: Chybn� jm�no p��kazu"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Chybn� jm�no p��kazu"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/da.po b/src/nvim/po/da.po
index dfcc052288..1c3284f867 100644
--- a/src/nvim/po/da.po
+++ b/src/nvim/po/da.po
@@ -5599,8 +5599,8 @@ msgstr "E424: For mange forskellige fremhævningsattributter i brug"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Tegn som ikke kan udskrives i gruppenavn"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ugyldige tegn i gruppenavn"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ugyldige tegn i gruppenavn"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: For mange fremhævnings- og syntaksgrupper"
diff --git a/src/nvim/po/de.po b/src/nvim/po/de.po
index 2dde77e9f7..ce3fd77ede 100644
--- a/src/nvim/po/de.po
+++ b/src/nvim/po/de.po
@@ -5408,8 +5408,8 @@ msgid "E669: Unprintable character in group name"
 msgstr "E669: Nicht druckbare Zeichen im Namen der Gruppe"
 
 #: ../syntax.c:7304
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ung�ltiges Zeichen im Namen der Gruppe"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ung�ltiges Zeichen im Namen der Gruppe"
 
 #: ../syntax.c:7318
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/en_GB.po b/src/nvim/po/en_GB.po
index 66cdba6f92..81ee9ed6a0 100644
--- a/src/nvim/po/en_GB.po
+++ b/src/nvim/po/en_GB.po
@@ -5730,8 +5730,8 @@ msgstr ""
 msgid "E669: Unprintable character in group name"
 msgstr ""
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
 msgstr ""
 
 #: ../syntax.c:7448
diff --git a/src/nvim/po/eo.po b/src/nvim/po/eo.po
index 1c503d0a84..263fb61b18 100644
--- a/src/nvim/po/eo.po
+++ b/src/nvim/po/eo.po
@@ -5378,8 +5378,8 @@ msgstr "E424: Tro da malsamaj atributoj de emfazo uzataj"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Nepresebla signo en nomo de grupo"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Nevalida signo en nomo de grupo"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Nevalida signo en nomo de grupo"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Tro da emfazaj kaj sintaksaj grupoj"
diff --git a/src/nvim/po/es.po b/src/nvim/po/es.po
index adea651b7c..8a44f6a534 100644
--- a/src/nvim/po/es.po
+++ b/src/nvim/po/es.po
@@ -6053,9 +6053,9 @@ msgstr "E669: Carácter no imprimible en el nombre del grupo"
 
 # This is an error, but since there previously was no check only
 # * give a warning.
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Hay un carácter no válido en el nombre del grupo"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Hay un carácter no válido en el nombre del grupo"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/fi.po b/src/nvim/po/fi.po
index f10d4ce977..1c0da244ba 100644
--- a/src/nvim/po/fi.po
+++ b/src/nvim/po/fi.po
@@ -5369,8 +5369,8 @@ msgstr "E424: Liikaa eri korostusattribuutteja"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Tulostuskelvoton merkki ryhmän nimessä"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Virheellinen merkki ryhmän nimessä"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Virheellinen merkki ryhmän nimessä"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Liikaa korostuksia ja syntaksiryhmiä"
diff --git a/src/nvim/po/fr.po b/src/nvim/po/fr.po
index 614ba013e6..be2141cd6d 100644
--- a/src/nvim/po/fr.po
+++ b/src/nvim/po/fr.po
@@ -2040,8 +2040,8 @@ msgstr ""
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Caract�re non imprimable dans un nom de groupe"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Caract�re invalide dans un nom de groupe"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Caract�re invalide dans un nom de groupe"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Trop de groupes de surbrillance et de syntaxe"
diff --git a/src/nvim/po/ga.po b/src/nvim/po/ga.po
index 1c25ee481c..346f0faa84 100644
--- a/src/nvim/po/ga.po
+++ b/src/nvim/po/ga.po
@@ -5668,8 +5668,8 @@ msgstr "E424: An iomarca tr
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Carachtar neamhghrafach in ainm gr�pa"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Carachtar neamhbhail� in ainm gr�pa"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Carachtar neamhbhail� in ainm gr�pa"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: An iomarca gr�pa� aibhsithe agus comhr�ire"
diff --git a/src/nvim/po/it.po b/src/nvim/po/it.po
index 313280c807..152ed2cbe3 100644
--- a/src/nvim/po/it.po
+++ b/src/nvim/po/it.po
@@ -6046,9 +6046,9 @@ msgstr "E424: Troppi gruppi evidenziazione differenti in uso"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Carattere non stampabile in un nome di gruppo"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Carattere non ammesso in un nome di gruppo"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Carattere non ammesso in un nome di gruppo"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/ko.UTF-8.po b/src/nvim/po/ko.UTF-8.po
index b99c22caeb..09be710374 100644
--- a/src/nvim/po/ko.UTF-8.po
+++ b/src/nvim/po/ko.UTF-8.po
@@ -5913,9 +5913,9 @@ msgstr "E424: 너무 많은 다른 하이라이트 속성이 사용되고 있습
 msgid "E669: Unprintable character in group name"
 msgstr "E669: 그룹 이름에 출력할 수 없는 문자가 있습니다"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: 그룹 이름에 이상한 문자"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: 그룹 이름에 이상한 문자"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/nb.po b/src/nvim/po/nb.po
index 2285d755cf..9bc730ae71 100644
--- a/src/nvim/po/nb.po
+++ b/src/nvim/po/nb.po
@@ -5930,9 +5930,9 @@ msgstr "E424: For mange forskjellige uthevingsattributter i bruk"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Ikke-skrivbart tegn i gruppenavn"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ugyldig tegn i gruppenavn"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ugyldig tegn i gruppenavn"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/nl.po b/src/nvim/po/nl.po
index 00d113c83c..4d2e55adc6 100644
--- a/src/nvim/po/nl.po
+++ b/src/nvim/po/nl.po
@@ -5913,8 +5913,8 @@ msgstr ""
 msgid "E669: Unprintable character in group name"
 msgstr ""
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
 msgstr ""
 
 #: ../syntax.c:7448
diff --git a/src/nvim/po/no.po b/src/nvim/po/no.po
index 2285d755cf..9bc730ae71 100644
--- a/src/nvim/po/no.po
+++ b/src/nvim/po/no.po
@@ -5930,9 +5930,9 @@ msgstr "E424: For mange forskjellige uthevingsattributter i bruk"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Ikke-skrivbart tegn i gruppenavn"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ugyldig tegn i gruppenavn"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ugyldig tegn i gruppenavn"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/pl.UTF-8.po b/src/nvim/po/pl.UTF-8.po
index 5f1779d1bd..7e978113f6 100644
--- a/src/nvim/po/pl.UTF-8.po
+++ b/src/nvim/po/pl.UTF-8.po
@@ -5908,9 +5908,9 @@ msgstr "E424: Zbyt wiele różnych atrybutów podkreślania w użyciu"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Niedrukowalny znak w nazwie grupy"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: nieprawidłowy znak w nazwie grupy"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: nieprawidłowy znak w nazwie grupy"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/pt_BR.po b/src/nvim/po/pt_BR.po
index 533d916de1..bfd64b4d28 100644
--- a/src/nvim/po/pt_BR.po
+++ b/src/nvim/po/pt_BR.po
@@ -6070,8 +6070,8 @@ msgid "E669: Unprintable character in group name"
 msgstr "E669: Caractere n�o-imprim�vel no nome do grupo"
 
 #: ../syntax.c:7320
-msgid "W18: Invalid character in group name"
-msgstr "W18: Caractere inv�lido no nome do grupo"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Caractere inv�lido no nome do grupo"
 
 #: ../syntax.c:7334
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/ru.po b/src/nvim/po/ru.po
index 7566036d3e..da356770d7 100644
--- a/src/nvim/po/ru.po
+++ b/src/nvim/po/ru.po
@@ -5977,9 +5977,9 @@ msgstr "E424: Используется слишком много разных а
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Непечатный символ в имени группы"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Недопустимый символ в имени группы"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Недопустимый символ в имени группы"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/sk.cp1250.po b/src/nvim/po/sk.cp1250.po
index ff95c68a12..cb8b8c6abb 100644
--- a/src/nvim/po/sk.cp1250.po
+++ b/src/nvim/po/sk.cp1250.po
@@ -5940,9 +5940,9 @@ msgstr "E424: Pou
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Netla�iteln� znak v mene skupiny"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Chybn� znak v mene skupiny"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Chybn� znak v mene skupiny"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/sk.po b/src/nvim/po/sk.po
index d35622726f..4f9e1fe185 100644
--- a/src/nvim/po/sk.po
+++ b/src/nvim/po/sk.po
@@ -5940,9 +5940,9 @@ msgstr "E424: Pou
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Netla�iteln� znak v mene skupiny"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Chybn� znak v mene skupiny"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Chybn� znak v mene skupiny"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/sr.po b/src/nvim/po/sr.po
index 3c45e1bf80..cbdf736d0f 100644
--- a/src/nvim/po/sr.po
+++ b/src/nvim/po/sr.po
@@ -6050,8 +6050,8 @@ msgstr "E424: У употреби је превише различитих ат
 msgid "E669: Unprintable character in group name"
 msgstr "E669: У имену групе је карактер који не може да се штампа"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Неважећи карактер у имену групе"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Неважећи карактер у имену групе"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Превише синтаксних и група истицања"
diff --git a/src/nvim/po/sv.po b/src/nvim/po/sv.po
index d50c9d695d..406900f7b2 100644
--- a/src/nvim/po/sv.po
+++ b/src/nvim/po/sv.po
@@ -2056,8 +2056,8 @@ msgid "E669: Unprintable character in group name"
 msgstr "E669: Outskrivbart tecken i gruppnamn"
 
 #: ../syntax.c:7292
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ogiltigt tecken i gruppnamn"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ogiltigt tecken i gruppnamn"
 
 #: ../syntax.c:7306
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/tr.po b/src/nvim/po/tr.po
index fae2fd4967..20b667d198 100644
--- a/src/nvim/po/tr.po
+++ b/src/nvim/po/tr.po
@@ -3054,8 +3054,8 @@ msgstr "E423: İzin verilmeyen argüman: %s"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Grup adında yazdırılamayan karakter"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Grup adında geçersiz karakter"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Grup adında geçersiz karakter"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Çok fazla vurgulama ve sözdizim grupları"
diff --git a/src/nvim/po/uk.po b/src/nvim/po/uk.po
index da87d50683..427abd9b77 100644
--- a/src/nvim/po/uk.po
+++ b/src/nvim/po/uk.po
@@ -3058,8 +3058,8 @@ msgstr "E423: Неправильний аргумент: %s"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Недруковний символ у назві групи"
 
-msgid "W18: Invalid character in group name"
-msgstr "W18: Некоректний символ у назві групи"
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Некоректний символ у назві групи"
 
 msgid "E849: Too many highlight and syntax groups"
 msgstr "E849: Забагато груп підсвічування і синтаксису"
diff --git a/src/nvim/po/vi.po b/src/nvim/po/vi.po
index c693f910d8..ad59718a30 100644
--- a/src/nvim/po/vi.po
+++ b/src/nvim/po/vi.po
@@ -5975,9 +5975,9 @@ msgstr "E424: Sử dụng quá nhiều thuộc tính chiếu sáng cú pháp"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: Ký tự không thể tin ra trong tên nhóm"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: Ký tự không cho phép trong tên nhóm"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: Ký tự không cho phép trong tên nhóm"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/zh_CN.UTF-8.po b/src/nvim/po/zh_CN.UTF-8.po
index 70c1389d7f..373833fa80 100644
--- a/src/nvim/po/zh_CN.UTF-8.po
+++ b/src/nvim/po/zh_CN.UTF-8.po
@@ -5942,9 +5942,9 @@ msgstr "E424: 使用了太多不同的高亮度属性"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: 组名中存在不可显示字符"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: 组名中含有无效字符"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: 组名中含有无效字符"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/po/zh_TW.UTF-8.po b/src/nvim/po/zh_TW.UTF-8.po
index e2fb2d39d4..5da69dfe69 100644
--- a/src/nvim/po/zh_TW.UTF-8.po
+++ b/src/nvim/po/zh_TW.UTF-8.po
@@ -5969,9 +5969,9 @@ msgstr "E424: 使用了過多相異的高亮度屬性"
 msgid "E669: Unprintable character in group name"
 msgstr "E669: 群組名稱中有無法列印的字元"
 
-#: ../syntax.c:7434
-msgid "W18: Invalid character in group name"
-msgstr "W18: 群組名稱中有不正確的字元"
+#: ../highlight_group.c:1756
+msgid "E5248: Invalid character in group name"
+msgstr "E5248: 群組名稱中有不正確的字元"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
diff --git a/src/nvim/testdir/test_syntax.vim b/src/nvim/testdir/test_syntax.vim
index 7ba0149971..af93a37739 100644
--- a/src/nvim/testdir/test_syntax.vim
+++ b/src/nvim/testdir/test_syntax.vim
@@ -389,7 +389,7 @@ func Test_invalid_name()
   syn keyword Nop yes
   call assert_fails("syntax keyword Wr\x17ong bar", 'E669:')
   syntax keyword @Wrong bar
-  call assert_match('W18:', execute('1messages'))
+  call assert_fails("syntax keyword @#Wrong bar", 'E5248:')
   syn clear
   hi clear Nop
   hi clear @Wrong
-- 
cgit 


From 6b9ff5491d4a15c7ec92d70a769b3cc35ea06da9 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 06:41:04 +0800
Subject: fix(treesitter): free memory on removing parser (#19933)

This fixes the ASAN failure.
---
 src/nvim/lua/treesitter.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 8b47939169..954c3410d3 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -216,7 +216,9 @@ int tslua_remove_lang(lua_State *L)
   const char *lang_name = luaL_checkstring(L, 1);
   bool present = pmap_has(cstr_t)(&langs, lang_name);
   if (present) {
+    char *key = (char *)pmap_key(cstr_t)(&langs, lang_name);
     pmap_del(cstr_t)(&langs, lang_name);
+    xfree(key);
   }
   lua_pushboolean(L, present);
   return 1;
-- 
cgit 


From c366a63e4cdd97fc2818be348186a18e1b6eb8df Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 21:08:17 +0800
Subject: vim-patch:9.0.0045: reading past end of completion with a long line

Problem:    Reading past end of completion with a long line and 'infercase'
            set.
Solution:   Allocate the string if needed.
https://github.com/vim/vim/commit/caea66442d86e7bbba3bf3dc202c3c0d549b9853

Cherry-pick the deletion of a blank line from patch 9.0.0027.

N/A patches for version.c:

vim-patch:9.0.0054: compiler warning for size_t to int conversion

Problem:    Compiler warning for size_t to int conversion.
Solution:   Add type cast. (Mike Williams, closes vim/vim#10741)
https://github.com/vim/vim/commit/c7bd2f08e531f08723cdc677212a3633d11c9a97
---
 src/nvim/insexpand.c                   | 73 +++++++++++++++++++++-------------
 src/nvim/testdir/test_ins_complete.vim | 15 +++++++
 2 files changed, 60 insertions(+), 28 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 7f00f5307a..743537621b 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -502,17 +502,18 @@ bool ins_compl_accept_char(int c)
 }
 
 /// Get the completed text by inferring the case of the originally typed text.
-static char_u *ins_compl_infercase_gettext(char_u *str, int actual_len, int actual_compl_length,
-                                           int min_len)
+/// If the result is in allocated memory "tofree" is set to it.
+static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_char_len,
+                                           int min_len, char **tofree)
 {
   bool has_lower = false;
   bool was_letter = false;
 
   // Allocate wide character array for the completion and fill it.
-  int *const wca = xmalloc((size_t)actual_len * sizeof(*wca));
+  int *const wca = xmalloc((size_t)char_len * sizeof(*wca));
   {
     const char_u *p = str;
-    for (int i = 0; i < actual_len; i++) {
+    for (int i = 0; i < char_len; i++) {
       wca[i] = mb_ptr2char_adv(&p);
     }
   }
@@ -526,7 +527,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int actual_len, int actu
         has_lower = true;
         if (mb_isupper(wca[i])) {
           // Rule 1 is satisfied.
-          for (i = actual_compl_length; i < actual_len; i++) {
+          for (i = compl_char_len; i < char_len; i++) {
             wca[i] = mb_tolower(wca[i]);
           }
           break;
@@ -543,7 +544,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int actual_len, int actu
       const int c = mb_ptr2char_adv(&p);
       if (was_letter && mb_isupper(c) && mb_islower(wca[i])) {
         // Rule 2 is satisfied.
-        for (i = actual_compl_length; i < actual_len; i++) {
+        for (i = compl_char_len; i < char_len; i++) {
           wca[i] = mb_toupper(wca[i]);
         }
         break;
@@ -566,20 +567,35 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int actual_len, int actu
   }
 
   // Generate encoding specific output from wide character array.
-  // Multi-byte characters can occupy up to five bytes more than
-  // ASCII characters, and we also need one byte for NUL, so stay
-  // six bytes away from the edge of IObuff.
-  {
-    char_u *p = IObuff;
-    int i = 0;
-    while (i < actual_len && (p - IObuff + 6) < IOSIZE) {
-      p += utf_char2bytes(wca[i++], (char *)p);
+  garray_T gap;
+  char *p = (char *)IObuff;
+  int i = 0;
+  ga_init(&gap, 1, 500);
+  while (i < char_len) {
+    if (gap.ga_data != NULL) {
+      ga_grow(&gap, 10);
+      p = (char *)gap.ga_data + gap.ga_len;
+      gap.ga_len += utf_char2bytes(wca[i++], p);
+    } else if ((p - (char *)IObuff) + 6 >= IOSIZE) {
+      // Multi-byte characters can occupy up to five bytes more than
+      // ASCII characters, and we also need one byte for NUL, so when
+      // getting to six bytes from the edge of IObuff switch to using a
+      // growarray.  Add the character in the next round.
+      ga_grow(&gap, IOSIZE);
+      STRCPY(gap.ga_data, IObuff);
+      gap.ga_len = (int)STRLEN(IObuff);
+    } else {
+      p += utf_char2bytes(wca[i++], p);
     }
-    *p = NUL;
   }
-
   xfree(wca);
 
+  if (gap.ga_data != NULL) {
+    *tofree = gap.ga_data;
+    return gap.ga_data;
+  }
+
+  *p = NUL;
   return IObuff;
 }
 
@@ -594,10 +610,10 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
   FUNC_ATTR_NONNULL_ARG(1)
 {
   char_u *str = str_arg;
-  int actual_len;                       // Take multi-byte characters
-  int actual_compl_length;              // into account.
-  int min_len;
+  int char_len;  // count multi-byte characters
+  int compl_char_len;
   int flags = 0;
+  char *tofree = NULL;
 
   if (p_ic && curbuf->b_p_inf && len > 0) {
     // Infer case of completed part.
@@ -605,29 +621,28 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
     // Find actual length of completion.
     {
       const char_u *p = str;
-      actual_len = 0;
+      char_len = 0;
       while (*p != NUL) {
         MB_PTR_ADV(p);
-        actual_len++;
+        char_len++;
       }
     }
 
     // Find actual length of original text.
     {
       const char_u *p = compl_orig_text;
-      actual_compl_length = 0;
+      compl_char_len = 0;
       while (*p != NUL) {
         MB_PTR_ADV(p);
-        actual_compl_length++;
+        compl_char_len++;
       }
     }
 
-    // "actual_len" may be smaller than "actual_compl_length" when using
+    // "char_len" may be smaller than "compl_char_len" when using
     // thesaurus, only use the minimum when comparing.
-    min_len = actual_len < actual_compl_length
-              ? actual_len : actual_compl_length;
+    int min_len = char_len < compl_char_len ? char_len : compl_char_len;
 
-    str = ins_compl_infercase_gettext(str, actual_len, actual_compl_length, min_len);
+    str = ins_compl_infercase_gettext(str, char_len, compl_char_len, min_len, &tofree);
   }
   if (cont_s_ipos) {
     flags |= CP_CONT_S_IPOS;
@@ -636,7 +651,9 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
     flags |= CP_ICASE;
   }
 
-  return ins_compl_add(str, len, fname, NULL, false, NULL, dir, flags, false);
+  int res = ins_compl_add(str, len, fname, NULL, false, NULL, dir, flags, false);
+  xfree(tofree);
+  return res;
 }
 
 /// Add a match to the list of matches
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 54d3844100..6c59041451 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -954,5 +954,20 @@ func Test_complete_overrun()
   bwipe!
 endfunc
 
+func Test_infercase_very_long_line()
+  " this was truncating the line when inferring case
+  new
+  let longLine = "blah "->repeat(300)
+  let verylongLine = "blah "->repeat(400)
+  call setline(1, verylongLine)
+  call setline(2, longLine)
+  set ic infercase
+  exe "normal 2Go\<C-X>\<C-L>\<Esc>"
+  call assert_equal(longLine, getline(3))
+
+  bwipe!
+  set noic noinfercase
+endfunc
+
 
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 5d1f0c3eca9675bfdeb75402ec3340d05cc34732 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 21:40:14 +0800
Subject: vim-patch:9.0.0046: reading past end of completion with duplicate
 match

Problem:    Reading past end of completion with duplicate match.
Solution:   Check string length
https://github.com/vim/vim/commit/baefde14550231f6468ac2ed2ed495bc381c0c92
---
 src/nvim/insexpand.c                   |  2 +-
 src/nvim/testdir/test_ins_complete.vim | 10 ++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 743537621b..2d470aa992 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -709,7 +709,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
     do {
       if (!match_at_original_text(match)
           && STRNCMP(match->cp_str, str, len) == 0
-          && match->cp_str[len] == NUL) {
+          && ((int)STRLEN(match->cp_str) <= len || match->cp_str[len] == NUL)) {
         FREE_CPTEXT(cptext, cptext_allocated);
         return NOTDONE;
       }
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 6c59041451..cd7d83c8ea 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -969,5 +969,15 @@ func Test_infercase_very_long_line()
   set noic noinfercase
 endfunc
 
+func Test_ins_complete_add()
+  " this was reading past the end of allocated memory
+  new
+  norm o
+  norm 7o€€
+  sil! norm o
+
+  bwipe!
+endfunc
+
 
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 6680002169a8cc505186e81acc161bec40658d73 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 21:44:37 +0800
Subject: vim-patch:9.0.0060: accessing uninitialized memory when completing
 long line

Problem:    Accessing uninitialized memory when completing long line.
Solution:   Terminate string with NUL.
https://github.com/vim/vim/commit/b9e717367c395490149495cf375911b5d9de889e
---
 src/nvim/insexpand.c                   | 1 +
 src/nvim/testdir/test_ins_complete.vim | 7 +++++++
 2 files changed, 8 insertions(+)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 2d470aa992..56f8834b56 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -582,6 +582,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
       // getting to six bytes from the edge of IObuff switch to using a
       // growarray.  Add the character in the next round.
       ga_grow(&gap, IOSIZE);
+      *p = NUL;
       STRCPY(gap.ga_data, IObuff);
       gap.ga_len = (int)STRLEN(IObuff);
     } else {
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index cd7d83c8ea..9aa3881724 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -965,6 +965,13 @@ func Test_infercase_very_long_line()
   exe "normal 2Go\<C-X>\<C-L>\<Esc>"
   call assert_equal(longLine, getline(3))
 
+  " check that the too long text is NUL terminated
+  %del
+  norm o
+  norm 1987ax
+  exec "norm ox\<C-X>\<C-L>"
+  call assert_equal(repeat('x', 1987), getline(3))
+
   bwipe!
   set noic noinfercase
 endfunc
-- 
cgit 


From dd77a0062108d6ecfc00bbc50b0d6d738df0b89d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 24 Aug 2022 21:46:06 +0800
Subject: vim-patch:9.0.0102: reading past end of line with insert mode
 completion

Problem:    Reading past end of line with insert mode completion.
Solution:   Check text length.
https://github.com/vim/vim/commit/a6f9e300161f4cb54713da22f65b261595e8e614
---
 src/nvim/insexpand.c                   | 2 +-
 src/nvim/testdir/test_ins_complete.vim | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 56f8834b56..d22c1ff980 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2813,7 +2813,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
   } else {
     char_u *tmp_ptr = ptr;
 
-    if (compl_cont_status & CONT_ADDING) {
+    if (compl_cont_status & CONT_ADDING && compl_length <= (int)STRLEN(tmp_ptr)) {
       tmp_ptr += compl_length;
       // Skip if already inside a word.
       if (vim_iswordp(tmp_ptr)) {
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 9aa3881724..8f7d2cb278 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -986,5 +986,13 @@ func Test_ins_complete_add()
   bwipe!
 endfunc
 
+func Test_ins_complete_end_of_line()
+  " this was reading past the end of the line
+  new  
+  norm 8o€ý 
+  sil! norm o
+
+  bwipe!
+endfunc
 
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 6c9a91bebeaef7e863f4b37e8656f49e9aaf33ab Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 07:59:17 +0800
Subject: vim-patch:8.2.2534: missing test coverage
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem:    Missing test coverage.
Solution:   Improve test coverage for completion with different encodings,
            mapset(), and term function failures. (Dominique Pellé,
            closes vim/vim#7877)
https://github.com/vim/vim/commit/a1070eae77f635f08b6f2612726b905796baaa58

Cherry-pick E716 -> E715 change from patch 8.2.4861.
---
 src/nvim/testdir/test_edit.vim   | 38 +++++++++++++++++++++-----------------
 src/nvim/testdir/test_maparg.vim |  2 ++
 2 files changed, 23 insertions(+), 17 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_edit.vim b/src/nvim/testdir/test_edit.vim
index e26bbdc5be..fa288df0d9 100644
--- a/src/nvim/testdir/test_edit.vim
+++ b/src/nvim/testdir/test_edit.vim
@@ -713,23 +713,27 @@ endfunc
 
 func Test_edit_CTRL_N()
   " Check keyword completion
-  new
-  set complete=.
-  call setline(1, ['INFER', 'loWER', '', '', ])
-  call cursor(3, 1)
-  call feedkeys("Ai\<c-n>\<cr>\<esc>", "tnix")
-  call feedkeys("ILO\<c-n>\<cr>\<esc>", 'tnix')
-  call assert_equal(['INFER', 'loWER', 'i', 'LO', '', ''], getline(1, '$'))
-  %d
-  call setline(1, ['INFER', 'loWER', '', '', ])
-  call cursor(3, 1)
-  set ignorecase infercase
-  call feedkeys("Ii\<c-n>\<cr>\<esc>", "tnix")
-  call feedkeys("ILO\<c-n>\<cr>\<esc>", 'tnix')
-  call assert_equal(['INFER', 'loWER', 'infer', 'LOWER', '', ''], getline(1, '$'))
-
-  set noignorecase noinfercase complete&
-  bw!
+  " for e in ['latin1', 'utf-8']
+  for e in ['utf-8']
+    exe 'set encoding=' .. e
+    new
+    set complete=.
+    call setline(1, ['INFER', 'loWER', '', '', ])
+    call cursor(3, 1)
+    call feedkeys("Ai\<c-n>\<cr>\<esc>", "tnix")
+    call feedkeys("ILO\<c-n>\<cr>\<esc>", 'tnix')
+    call assert_equal(['INFER', 'loWER', 'i', 'LO', '', ''], getline(1, '$'), e)
+    %d
+    call setline(1, ['INFER', 'loWER', '', '', ])
+    call cursor(3, 1)
+    set ignorecase infercase
+    call feedkeys("Ii\<c-n>\<cr>\<esc>", "tnix")
+    call feedkeys("ILO\<c-n>\<cr>\<esc>", 'tnix')
+    call assert_equal(['INFER', 'loWER', 'infer', 'LOWER', '', ''], getline(1, '$'), e)
+
+    set noignorecase noinfercase complete&
+    bw!
+  endfor
 endfunc
 
 func Test_edit_CTRL_O()
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index dad4c81a7b..17c5f433ac 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -248,6 +248,8 @@ func Test_mapset()
   bwipe!
 
   call assert_fails('call mapset([], v:false, {})', 'E730:')
+  call assert_fails('call mapset("i", 0, "")', 'E715:')
+  call assert_fails('call mapset("i", 0, {})', 'E460:')
 endfunc
 
 func Check_ctrlb_map(d, check_alt)
-- 
cgit 


From cabc1861c478b36570bc8d6633097cd4729b8303 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 07:45:00 +0800
Subject: vim-patch:8.2.3989: some insert completion code is not tested

Problem:    Some insert completion code is not tested.
Solution:   Add a few tests.  Refactor thesaurus completion. (Yegappan
            Lakshmanan, closes vim/vim#9460)
https://github.com/vim/vim/commit/e982586f8eebf2b055987218f6d3f7a084c4bf69

vim-patch:9.0.0254: typo in function name

Problem:    Typo in function name.
Solution:   Rename the function. (closes vim/vim#10971)
https://github.com/vim/vim/commit/5fb3aabc2b0edd5573e107bb3bc103c348771f61
---
 src/nvim/insexpand.c                   |  93 +++++++++++++++++++-----------
 src/nvim/testdir/test_edit.vim         |  27 ++++++++-
 src/nvim/testdir/test_ins_complete.vim | 101 +++++++++++++++++++++++++++++++++
 3 files changed, 185 insertions(+), 36 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index d22c1ff980..21285a4365 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1005,6 +1005,8 @@ static dict_T *ins_compl_dict_alloc(compl_T *match)
   return dict;
 }
 
+/// Trigger the CompleteChanged autocmd event. Invoked each time the Insert mode
+/// completion menu is changed.
 static void trigger_complete_changed_event(int cur)
 {
   static bool recursive = false;
@@ -1181,8 +1183,8 @@ void ins_compl_show_pum(void)
 #define DICT_FIRST      (1)     ///< use just first element in "dict"
 #define DICT_EXACT      (2)     ///< "dict" is the exact name of a file
 
-/// Add any identifiers that match the given pattern in the list of dictionary
-/// files "dict_start" to the list of completions.
+/// Add any identifiers that match the given pattern "pat" in the list of
+/// dictionary files "dict_start" to the list of completions.
 ///
 /// @param flags      DICT_FIRST and/or DICT_EXACT
 /// @param thesaurus  Thesaurus completion
@@ -1283,6 +1285,54 @@ theend:
   xfree(buf);
 }
 
+/// Add all the words in the line "*buf_arg" from the thesaurus file "fname"
+/// skipping the word at 'skip_word'.
+///
+/// @return  OK on success.
+static int thesaurus_add_words_in_line(char *fname, char_u **buf_arg, int dir, char_u *skip_word)
+{
+  int status = OK;
+
+  // Add the other matches on the line
+  char_u *ptr = *buf_arg;
+  while (!got_int) {
+    // Find start of the next word.  Skip white
+    // space and punctuation.
+    ptr = find_word_start(ptr);
+    if (*ptr == NUL || *ptr == NL) {
+      break;
+    }
+    char_u *wstart = ptr;
+
+    // Find end of the word.
+    // Japanese words may have characters in
+    // different classes, only separate words
+    // with single-byte non-word characters.
+    while (*ptr != NUL) {
+      const int l = utfc_ptr2len((const char *)ptr);
+
+      if (l < 2 && !vim_iswordc(*ptr)) {
+        break;
+      }
+      ptr += l;
+    }
+
+    // Add the word. Skip the regexp match.
+    if (wstart != skip_word) {
+      status = ins_compl_add_infercase(wstart, (int)(ptr - wstart), p_ic,
+                                       (char_u *)fname, dir, false);
+      if (status == FAIL) {
+        break;
+      }
+    }
+  }
+
+  *buf_arg = ptr;
+  return status;
+}
+
+/// Process "count" dictionary/thesaurus "files" and add the text matching
+/// "regmatch".
 static void ins_compl_files(int count, char **files, int thesaurus, int flags, regmatch_T *regmatch,
                             char_u *buf, Direction *dir)
   FUNC_ATTR_NONNULL_ARG(2, 7)
@@ -1320,38 +1370,10 @@ static void ins_compl_files(int count, char **files, int thesaurus, int flags, r
                                         (int)(ptr - regmatch->startp[0]),
                                         p_ic, (char_u *)files[i], *dir, false);
         if (thesaurus) {
-          char_u *wstart;
-
-          // Add the other matches on the line
+          // For a thesaurus, add all the words in the line
           ptr = buf;
-          while (!got_int) {
-            // Find start of the next word.  Skip white
-            // space and punctuation.
-            ptr = find_word_start(ptr);
-            if (*ptr == NUL || *ptr == NL) {
-              break;
-            }
-            wstart = ptr;
-
-            // Find end of the word.
-            // Japanese words may have characters in
-            // different classes, only separate words
-            // with single-byte non-word characters.
-            while (*ptr != NUL) {
-              const int l = utfc_ptr2len((char *)ptr);
-
-              if (l < 2 && !vim_iswordc(*ptr)) {
-                break;
-              }
-              ptr += l;
-            }
-
-            // Add the word. Skip the regexp match.
-            if (wstart != regmatch->startp[0]) {
-              add_r = ins_compl_add_infercase(wstart, (int)(ptr - wstart),
-                                              p_ic, (char_u *)files[i], *dir, false);
-            }
-          }
+          add_r = thesaurus_add_words_in_line(files[i], &ptr, *dir,
+                                              regmatch->startp[0]);
         }
         if (add_r == OK) {
           // if dir was BACKWARD then honor it just once
@@ -1536,12 +1558,12 @@ int ins_compl_bs(void)
 
   xfree(compl_leader);
   compl_leader = vim_strnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
+
   ins_compl_new_leader();
   if (compl_shown_match != NULL) {
     // Make sure current match is not a hidden item.
     compl_curr_match = compl_shown_match;
   }
-
   return NUL;
 }
 
@@ -2401,6 +2423,8 @@ static char_u *ins_compl_mode(void)
   return (char_u *)"";
 }
 
+/// Assign the sequence number to all the completion matches which don't have
+/// one assigned yet.
 static void ins_compl_update_sequence_numbers(void)
 {
   int number = 0;
@@ -4154,6 +4178,7 @@ int ins_complete(int c, bool enable_pum)
   return OK;
 }
 
+/// Remove (if needed) and show the popup menu
 static void show_pum(int prev_w_wrow, int prev_w_leftcol)
 {
   // RedrawingDisabled may be set when invoked through complete().
diff --git a/src/nvim/testdir/test_edit.vim b/src/nvim/testdir/test_edit.vim
index fa288df0d9..679b877ef6 100644
--- a/src/nvim/testdir/test_edit.vim
+++ b/src/nvim/testdir/test_edit.vim
@@ -730,8 +730,13 @@ func Test_edit_CTRL_N()
     call feedkeys("Ii\<c-n>\<cr>\<esc>", "tnix")
     call feedkeys("ILO\<c-n>\<cr>\<esc>", 'tnix')
     call assert_equal(['INFER', 'loWER', 'infer', 'LOWER', '', ''], getline(1, '$'), e)
-
-    set noignorecase noinfercase complete&
+    set noignorecase noinfercase
+    %d
+    call setline(1, ['one word', 'two word'])
+    exe "normal! Goo\<C-P>\<C-X>\<C-P>"
+    call assert_equal('one word', getline(3))
+    %d
+    set complete&
     bw!
   endfor
 endfunc
@@ -897,6 +902,24 @@ func Test_edit_CTRL_T()
   bw!
 endfunc
 
+" Test thesaurus completion with different encodings
+func Test_thesaurus_complete_with_encoding()
+  call writefile(['angry furious mad enraged'], 'Xthesaurus')
+  set thesaurus=Xthesaurus
+  " for e in ['latin1', 'utf-8']
+  for e in ['utf-8']
+    exe 'set encoding=' .. e
+    new
+    call setline(1, 'mad')
+    call cursor(1, 1)
+    call feedkeys("A\<c-x>\<c-t>\<cr>\<esc>", 'tnix')
+    call assert_equal(['mad', ''], getline(1, '$'))
+    bw!
+  endfor
+  set thesaurus=
+  call delete('Xthesaurus')
+endfunc
+
 " Test 'thesaurusfunc'
 func MyThesaurus(findstart, base)
   let mythesaurus = [
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 8f7d2cb278..914d818eef 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -682,6 +682,21 @@ func Test_complete_func_error()
   call assert_equal([], complete_info(['items']).items)
 endfunc
 
+" Test for recursively starting completion mode using complete()
+func Test_recursive_complete_func()
+  func ListColors()
+    call complete(5, ["red", "blue"])
+    return ''
+  endfunc
+  new
+  call setline(1, ['a1', 'a2'])
+  set complete=.
+  exe "normal Goa\<C-X>\<C-L>\<C-R>=ListColors()\<CR>\<C-N>"
+  call assert_equal('a2blue', getline(3))
+  delfunc ListColors
+  bw!
+endfunc
+
 " Test for completing words following a completed word in a line
 func Test_complete_wrapscan()
   " complete words from another buffer
@@ -905,6 +920,92 @@ func Test_issue_7021()
   set completeslash=
 endfunc
 
+" Test for 'longest' setting in 'completeopt' with latin1 and utf-8 encodings
+func Test_complete_longest_match()
+  " for e in ['latin1', 'utf-8']
+  for e in ['utf-8']
+    exe 'set encoding=' .. e
+    new
+    set complete=.
+    set completeopt=menu,longest
+    call setline(1, ['pfx_a1', 'pfx_a12', 'pfx_a123', 'pfx_b1'])
+    exe "normal Gopfx\<C-P>"
+    call assert_equal('pfx_', getline(5))
+    bw!
+  endfor
+
+  " Test for completing additional words with longest match set
+  new
+  call setline(1, ['abc1', 'abd2'])
+  exe "normal Goab\<C-P>\<C-X>\<C-P>"
+  call assert_equal('ab', getline(3))
+  bw!
+  set complete& completeopt&
+endfunc
+
+" Test for removing the first displayed completion match and selecting the
+" match just before that.
+func Test_complete_erase_firstmatch()
+  new
+  call setline(1, ['a12', 'a34', 'a56'])
+  set complete=.
+  exe "normal Goa\<C-P>\<BS>\<BS>3\<CR>"
+  call assert_equal('a34', getline('$'))
+  set complete&
+  bw!
+endfunc
+
+" Test for completing whole lines from unloaded buffers
+func Test_complete_wholeline_unloadedbuf()
+  call writefile(['a line1', 'a line2', 'a line3'], "Xfile1")
+  edit Xfile1
+  enew
+  set complete=u
+  exe "normal! ia\<C-X>\<C-L>\<C-P>"
+  call assert_equal('a line2', getline(1))
+  %d
+  " completing from an unlisted buffer should fail
+  bdel Xfile1
+  exe "normal! ia\<C-X>\<C-L>\<C-P>"
+  call assert_equal('a', getline(1))
+  set complete&
+  %bw!
+  call delete("Xfile1")
+endfunc
+
+" Test for completing whole lines from unlisted buffers
+func Test_complete_wholeline_unlistedbuf()
+  call writefile(['a line1', 'a line2', 'a line3'], "Xfile1")
+  edit Xfile1
+  enew
+  set complete=U
+  " completing from a unloaded buffer should fail
+  exe "normal! ia\<C-X>\<C-L>\<C-P>"
+  call assert_equal('a', getline(1))
+  %d
+  bdel Xfile1
+  exe "normal! ia\<C-X>\<C-L>\<C-P>"
+  call assert_equal('a line2', getline(1))
+  set complete&
+  %bw!
+  call delete("Xfile1")
+endfunc
+
+" Test for adding a multibyte character using CTRL-L in completion mode
+func Test_complete_mbyte_char_add()
+  new
+  set complete=.
+  call setline(1, 'abė')
+  exe "normal! oa\<C-P>\<BS>\<BS>\<C-L>\<C-L>"
+  call assert_equal('abė', getline(2))
+  " Test for a leader with multibyte character
+  %d
+  call setline(1, 'abėĕ')
+  exe "normal! oabė\<C-P>"
+  call assert_equal('abėĕ', getline(2))
+  bw!
+endfunc
+
 " Test to ensure 'Scanning...' messages are not recorded in messages history
 func Test_z1_complete_no_history()
   new
-- 
cgit 


From 3290e472c09c126c014411c73a17d0b1827a795f Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 08:04:25 +0800
Subject: vim-patch:8.2.4037: Insert mode completion is insufficiently tested

Problem:    Insert mode completion is insufficiently tested.
Solution:   Add more tests.  Fix uncovered memory leak. (Yegappan Lakshmanan,
            closes vim/vim#9489)
https://github.com/vim/vim/commit/370791465e745354d66696de8cbd15504cf958c0
---
 src/nvim/insexpand.c                   |  38 ++++--
 src/nvim/testdir/test_ins_complete.vim | 235 +++++++++++++++++++++++++++++++++
 2 files changed, 260 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 21285a4365..ec885b33c3 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -659,17 +659,23 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
 
 /// Add a match to the list of matches
 ///
-/// @param[in]  str  Match to add.
-/// @param[in]  len  Match length, -1 to use #STRLEN.
-/// @param[in]  fname  File name match comes from. May be NULL.
-/// @param[in]  cptext  Extra text for popup menu. May be NULL. If not NULL,
-///                     must have exactly #CPT_COUNT items.
+/// @param[in]  str     text of the match to add
+/// @param[in]  len     length of "str". If -1, then the length of "str" is computed.
+/// @param[in]  fname   file name to associate with this match. May be NULL.
+/// @param[in]  cptext  list of strings to use with this match (for abbr, menu, info
+///                     and kind). May be NULL.
+///                     If not NULL, must have exactly #CPT_COUNT items.
 /// @param[in]  cptext_allocated  If true, will not copy cptext strings.
 ///
 ///                               @note Will free strings in case of error.
 ///                                     cptext itself will not be freed.
-/// @param[in]  cdir  Completion direction.
-/// @param[in]  adup  True if duplicate matches are to be accepted.
+/// @param[in]  user_data  user supplied data (any vim type) for this match
+/// @param[in]  cdir       match direction. If 0, use "compl_direction".
+/// @param[in]  flags_arg  match flags (cp_flags)
+/// @param[in]  adup       accept this match even if it is already present.
+///
+/// If "cdir" is FORWARD, then the match is added after the current match.
+/// Otherwise, it is added before the current match.
 ///
 /// @return NOTDONE if the given string is already in the list of completions,
 ///         otherwise it is added to the list and  OK is returned. FAIL will be
@@ -768,7 +774,8 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
     match->cp_user_data = *user_data;
   }
 
-  // Link the new match structure in the list of matches.
+  // Link the new match structure after (FORWARD) or before (BACKWARD) the
+  // current match in the list of matches .
   if (compl_first_match == NULL) {
     match->cp_next = match->cp_prev = NULL;
   } else if (dir == FORWARD) {
@@ -2265,10 +2272,15 @@ static int ins_compl_add_tv(typval_T *const tv, const Direction dir, bool fast)
     for (size_t i = 0; i < CPT_COUNT; i++) {
       xfree(cptext[i]);
     }
+    tv_clear(&user_data);
     return FAIL;
   }
-  return ins_compl_add((char_u *)word, -1, NULL,
-                       (char_u **)cptext, true, &user_data, dir, flags, dup);
+  int status = ins_compl_add((char_u *)word, -1, NULL, (char_u **)cptext, true,
+                             &user_data, dir, flags, dup);
+  if (status != OK) {
+    tv_clear(&user_data);
+  }
+  return status;
 }
 
 /// Add completions from a list.
@@ -2606,8 +2618,8 @@ enum {
 ///   st->dict_f - flag specifying whether "dict" is an exact file name or not
 ///
 /// @return  INS_COMPL_CPT_OK if the next value is processed successfully.
-///          INS_COMPL_CPT_CONT to skip the current value and process the next
-///          option value.
+///          INS_COMPL_CPT_CONT to skip the current completion source matching
+///          the "st->e_cpt" option value and process the next matching source.
 ///          INS_COMPL_CPT_END if all the values in "st->e_cpt" are processed.
 static int process_next_cpt_value(ins_compl_next_state_T *st, int *compl_type_arg,
                                   pos_T *start_match_pos)
@@ -3788,7 +3800,7 @@ static int get_userdefined_compl_info(colnr_T curs_col)
     return FAIL;
   }
 
-  // Reset extended parameters of completion, when start new
+  // Reset extended parameters of completion, when starting new
   // completion.
   compl_opt_refresh_always = false;
 
diff --git a/src/nvim/testdir/test_ins_complete.vim b/src/nvim/testdir/test_ins_complete.vim
index 914d818eef..3e563f29f9 100644
--- a/src/nvim/testdir/test_ins_complete.vim
+++ b/src/nvim/testdir/test_ins_complete.vim
@@ -68,6 +68,11 @@ func Test_ins_complete()
   call assert_equal('Xtest11.one', getline('.'))
   normal ddk
 
+  " Test for expanding a non-existing filename
+  exe "normal oa1b2X3Y4\<C-X>\<C-F>"
+  call assert_equal('a1b2X3Y4', getline('.'))
+  normal ddk
+
   set cpt=w
   " checks make_cyclic in other window
   exe "normal oST\<C-N>\<C-P>\<C-P>\<C-P>\<C-P>"
@@ -955,6 +960,27 @@ func Test_complete_erase_firstmatch()
   bw!
 endfunc
 
+" Test for completing words from unloaded buffers
+func Test_complete_from_unloadedbuf()
+  call writefile(['abc'], "Xfile1")
+  call writefile(['def'], "Xfile2")
+  edit Xfile1
+  edit Xfile2
+  new | close
+  enew
+  bunload Xfile1 Xfile2
+  set complete=u
+  " complete from an unloaded buffer
+  exe "normal! ia\<C-P>"
+  call assert_equal('abc', getline(1))
+  exe "normal! od\<C-P>"
+  call assert_equal('def', getline(2))
+  set complete&
+  %bw!
+  call delete("Xfile1")
+  call delete("Xfile2")
+endfunc
+
 " Test for completing whole lines from unloaded buffers
 func Test_complete_wholeline_unloadedbuf()
   call writefile(['a line1', 'a line2', 'a line3'], "Xfile1")
@@ -973,6 +999,26 @@ func Test_complete_wholeline_unloadedbuf()
   call delete("Xfile1")
 endfunc
 
+" Test for completing words from unlisted buffers
+func Test_complete_from_unlistedbuf()
+  call writefile(['abc'], "Xfile1")
+  call writefile(['def'], "Xfile2")
+  edit Xfile1
+  edit Xfile2
+  new | close
+  bdel Xfile1 Xfile2
+  set complete=U
+  " complete from an unlisted buffer
+  exe "normal! ia\<C-P>"
+  call assert_equal('abc', getline(1))
+  exe "normal! od\<C-P>"
+  call assert_equal('def', getline(2))
+  set complete&
+  %bw!
+  call delete("Xfile1")
+  call delete("Xfile2")
+endfunc
+
 " Test for completing whole lines from unlisted buffers
 func Test_complete_wholeline_unlistedbuf()
   call writefile(['a line1', 'a line2', 'a line3'], "Xfile1")
@@ -1006,6 +1052,195 @@ func Test_complete_mbyte_char_add()
   bw!
 endfunc
 
+" Test for using <C-X><C-P> for local expansion even if 'complete' is set to
+" not to complete matches from the local buffer. Also test using multiple
+" <C-X> to cancel the current completion mode.
+func Test_complete_local_expansion()
+  new
+  set complete=t
+  call setline(1, ['abc', 'def'])
+  exe "normal! Go\<C-X>\<C-P>"
+  call assert_equal("def", getline(3))
+  exe "normal! Go\<C-P>"
+  call assert_equal("", getline(4))
+  exe "normal! Go\<C-X>\<C-N>"
+  call assert_equal("abc", getline(5))
+  exe "normal! Go\<C-N>"
+  call assert_equal("", getline(6))
+
+  " use multiple <C-X> to cancel the previous completion mode
+  exe "normal! Go\<C-P>\<C-X>\<C-P>"
+  call assert_equal("", getline(7))
+  exe "normal! Go\<C-P>\<C-X>\<C-X>\<C-P>"
+  call assert_equal("", getline(8))
+  exe "normal! Go\<C-P>\<C-X>\<C-X>\<C-X>\<C-P>"
+  call assert_equal("abc", getline(9))
+
+  " interrupt the current completion mode
+  set completeopt=menu,noinsert
+  exe "normal! Go\<C-X>\<C-F>\<C-X>\<C-X>\<C-P>\<C-Y>"
+  call assert_equal("abc", getline(10))
+
+  " when only one <C-X> is used to interrupt, do normal expansion
+  exe "normal! Go\<C-X>\<C-F>\<C-X>\<C-P>"
+  call assert_equal("", getline(11))
+  set completeopt&
+
+  " using two <C-X> in non-completion mode and restarting the same mode
+  exe "normal! God\<C-X>\<C-X>\<C-P>\<C-X>\<C-X>\<C-P>\<C-Y>"
+  call assert_equal("def", getline(12))
+
+  " test for adding a match from the original empty text
+  %d
+  call setline(1, 'abc def g')
+  exe "normal! o\<C-X>\<C-P>\<C-N>\<C-X>\<C-P>"
+  call assert_equal('def', getline(2))
+  exe "normal! 0C\<C-X>\<C-N>\<C-P>\<C-X>\<C-N>"
+  call assert_equal('abc', getline(2))
+
+  bw!
+endfunc
+
+" Test for undoing changes after a insert-mode completion
+func Test_complete_undo()
+  new
+  set complete=.
+  " undo with 'ignorecase'
+  call setline(1, ['ABOVE', 'BELOW'])
+  set ignorecase
+  exe "normal! Goab\<C-G>u\<C-P>"
+  call assert_equal("ABOVE", getline(3))
+  undo
+  call assert_equal("ab", getline(3))
+  set ignorecase&
+  %d
+  " undo with longest match
+  set completeopt=menu,longest
+  call setline(1, ['above', 'about'])
+  exe "normal! Goa\<C-G>u\<C-P>"
+  call assert_equal("abo", getline(3))
+  undo
+  call assert_equal("a", getline(3))
+  set completeopt&
+  %d
+  " undo for line completion
+  call setline(1, ['above that change', 'below that change'])
+  exe "normal! Goabove\<C-G>u\<C-X>\<C-L>"
+  call assert_equal("above that change", getline(3))
+  undo
+  call assert_equal("above", getline(3))
+
+  bw!
+endfunc
+
+" Test for completing a very long word
+func Test_complete_long_word()
+  set complete&
+  new
+  call setline(1, repeat('x', 950) .. ' one two three')
+  exe "normal! Gox\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>"
+  call assert_equal(repeat('x', 950) .. ' one two three', getline(2))
+  %d
+  " should fail when more than 950 characters are in a word
+  call setline(1, repeat('x', 951) .. ' one two three')
+  exe "normal! Gox\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>\<C-X>\<C-P>"
+  call assert_equal(repeat('x', 951), getline(2))
+
+  " Test for adding a very long word to an existing completion
+  %d
+  call setline(1, ['abc', repeat('x', 1016) .. '012345'])
+  exe "normal! Goab\<C-P>\<C-X>\<C-P>"
+  call assert_equal('abc ' .. repeat('x', 1016) .. '0123', getline(3))
+  bw!
+endfunc
+
+" Test for some fields in the complete items used by complete()
+func Test_complete_items()
+  func CompleteItems(idx)
+    let items = [[#{word: "one", dup: 1, user_data: 'u1'}, #{word: "one", dup: 1, user_data: 'u2'}],
+          \ [#{word: "one", dup: 0, user_data: 'u3'}, #{word: "one", dup: 0, user_data: 'u4'}],
+          \ [#{word: "one", icase: 1, user_data: 'u7'}, #{word: "oNE", icase: 1, user_data: 'u8'}],
+          \ [#{user_data: 'u9'}],
+          \ [#{word: "", user_data: 'u10'}],
+          \ [#{word: "", empty: 1, user_data: 'u11'}]]
+    call complete(col('.'), items[a:idx])
+    return ''
+  endfunc
+  new
+  exe "normal! i\<C-R>=CompleteItems(0)\<CR>\<C-N>\<C-Y>"
+  call assert_equal('u2', v:completed_item.user_data)
+  call assert_equal('one', getline(1))
+  exe "normal! o\<C-R>=CompleteItems(1)\<CR>\<C-Y>"
+  call assert_equal('u3', v:completed_item.user_data)
+  call assert_equal('one', getline(2))
+  exe "normal! o\<C-R>=CompleteItems(1)\<CR>\<C-N>"
+  call assert_equal('', getline(3))
+  set completeopt=menu,noinsert
+  exe "normal! o\<C-R>=CompleteItems(2)\<CR>one\<C-N>\<C-Y>"
+  call assert_equal('oNE', getline(4))
+  call assert_equal('u8', v:completed_item.user_data)
+  set completeopt&
+  exe "normal! o\<C-R>=CompleteItems(3)\<CR>"
+  call assert_equal('', getline(5))
+  exe "normal! o\<C-R>=CompleteItems(4)\<CR>"
+  call assert_equal('', getline(6))
+  exe "normal! o\<C-R>=CompleteItems(5)\<CR>"
+  call assert_equal('', getline(7))
+  call assert_equal('u11', v:completed_item.user_data)
+  " pass invalid argument to complete()
+  let cmd = "normal! o\<C-R>=complete(1, [[]])\<CR>"
+  call assert_fails('exe cmd', 'E730:')
+  bw!
+  delfunc CompleteItems
+endfunc
+
+" Test for the "refresh" item in the dict returned by an insert completion
+" function
+func Test_complete_item_refresh_always()
+  let g:CallCount = 0
+  func! Tcomplete(findstart, base)
+    if a:findstart
+      " locate the start of the word
+      let line = getline('.')
+      let start = col('.') - 1
+      while start > 0 && line[start - 1] =~ '\a'
+        let start -= 1
+      endwhile
+      return start
+    else
+      let g:CallCount += 1
+      let res = ["update1", "update12", "update123"]
+      return #{words: res, refresh: 'always'}
+    endif
+  endfunc
+  new
+  set completeopt=menu,longest
+  set completefunc=Tcomplete
+  exe "normal! iup\<C-X>\<C-U>\<BS>\<BS>\<BS>\<BS>\<BS>"
+  call assert_equal('up', getline(1))
+  call assert_equal(2, g:CallCount)
+  set completeopt&
+  set completefunc&
+  bw!
+  delfunc Tcomplete
+endfunc
+
+" Test for completing from a thesaurus file without read permission
+func Test_complete_unreadable_thesaurus_file()
+  CheckUnix
+  CheckNotRoot
+
+  call writefile(['about', 'above'], 'Xfile')
+  call setfperm('Xfile', '---r--r--')
+  new
+  set complete=sXfile
+  exe "normal! ia\<C-P>"
+  call assert_equal('a', getline(1))
+  bw!
+  call delete('Xfile')
+  set complete&
+endfunc
+
 " Test to ensure 'Scanning...' messages are not recorded in messages history
 func Test_z1_complete_no_history()
   new
-- 
cgit 


From 45d09b46cebe928693f708b777e8b11ad6ec2602 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 09:07:04 +0800
Subject: vim-patch:8.2.3942: Coverity reports a possible memory leak

Problem:    Coverity reports a possible memory leak.
Solution:   Free the array if allocation fails.
https://github.com/vim/vim/commit/8e7cc6b920ddea37deaa5e6b7b3bdfff2222d137
---
 src/nvim/insexpand.c | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index ec885b33c3..bc02545ed8 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2820,6 +2820,8 @@ static void get_next_spell_completion(linenr_T lnum)
   int num_matches = expand_spelling(lnum, (char_u *)compl_pattern, &matches);
   if (num_matches > 0) {
     ins_compl_add_matches(num_matches, matches, p_ic);
+  } else {
+    xfree(matches);
   }
 }
 
-- 
cgit 


From b1833bb33b49a26e7552548e3541ac1480fee452 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 09:22:44 +0800
Subject: vim-patch:partial:8.2.4001: insert complete code uses global
 variables

Problem:    Insert complete code uses global variables.
Solution:   Make variables local to the file and use accessor functions.
            (Yegappan Lakshmanan, closes vim/vim#9470)
https://github.com/vim/vim/commit/d94fbfc74a8b8073e7a256c95fa6f39fc527c726

Skip changes in comments for callback-related functions (not ported).
Also make compl_busy static again.
---
 src/nvim/edit.c      |  10 ++-
 src/nvim/fold.c      |   2 +-
 src/nvim/getchar.c   |   2 +-
 src/nvim/globals.h   |  21 ------
 src/nvim/insexpand.c | 201 ++++++++++++++++++++++++++++++++++-----------------
 src/nvim/search.c    |  30 ++++----
 6 files changed, 160 insertions(+), 106 deletions(-)

(limited to 'src')

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 545f3c0d9a..81a67b86c3 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -92,6 +92,10 @@ typedef struct insert_state {
 #define BACKSPACE_WORD_NOT_SPACE    3
 #define BACKSPACE_LINE              4
 
+/// Set when doing something for completion that may call edit() recursively,
+/// which is not allowed.
+static bool compl_busy = false;
+
 static colnr_T Insstart_textlen;        // length of line when insert started
 static colnr_T Insstart_blank_vcol;     // vcol for first inserted blank
 static bool update_Insstart_orig = true;  // set Insstart_orig to Insstart
@@ -1091,7 +1095,7 @@ check_pum:
     // but it is under other ^X modes
     if (*curbuf->b_p_cpt == NUL
         && (ctrl_x_mode_normal() || ctrl_x_mode_whole_line())
-        && !(compl_cont_status & CONT_LOCAL)) {
+        && !compl_status_local()) {
       goto normalchar;
     }
 
@@ -1177,9 +1181,11 @@ normalchar:
 static void insert_do_complete(InsertState *s)
 {
   compl_busy = true;
+  disable_fold_update++;  // don't redraw folds here
   if (ins_complete(s->c, true) == FAIL) {
-    compl_cont_status = 0;
+    compl_status_clear();
   }
+  disable_fold_update--;
   compl_busy = false;
   can_si = may_do_si();  // allow smartindenting
 }
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 66f45e57f3..9cc17acb37 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -757,7 +757,7 @@ void clearFolding(win_T *win)
 /// The changes in lines from top to bot (inclusive).
 void foldUpdate(win_T *wp, linenr_T top, linenr_T bot)
 {
-  if (disable_fold_update || compl_busy || State & MODE_INSERT) {
+  if (disable_fold_update || State & MODE_INSERT) {
     return;
   }
 
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 8a8efbc578..36ca31783e 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1881,7 +1881,7 @@ static bool at_ins_compl_key(void)
     c = p[3] & 0x1f;
   }
   return (ctrl_x_mode_not_default() && vim_is_ctrl_x_key(c))
-         || ((compl_cont_status & CONT_LOCAL) && (c == Ctrl_N || c == Ctrl_P));
+         || (compl_status_local() && (c == Ctrl_N || c == Ctrl_P));
 }
 
 /// Check if typebuf.tb_buf[] contains a modifier plus key that can be changed
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 67cd21e172..67b113849c 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -159,27 +159,6 @@ EXTERN colnr_T dollar_vcol INIT(= -1);
 
 // Variables for Insert mode completion.
 
-// Length in bytes of the text being completed (this is deleted to be replaced
-// by the match.)
-EXTERN int compl_length INIT(= 0);
-
-// Set when doing something for completion that may call edit() recursively,
-// which is not allowed. Also used to disable folding during completion
-EXTERN bool compl_busy INIT(= false);
-
-// List of flags for method of completion.
-EXTERN int compl_cont_status INIT(= 0);
-#define CONT_ADDING    1       // "normal" or "adding" expansion
-#define CONT_INTRPT   (2 + 4)  // a ^X interrupted the current expansion
-                               // it's set only iff N_ADDS is set
-#define CONT_N_ADDS    4       // next ^X<> will add-new or expand-current
-#define CONT_S_IPOS    8       // next ^X<> will set initial_pos?
-                               // if so, word-wise-expansion will set SOL
-#define CONT_SOL       16      // pattern includes start of line, just for
-                               // word-wise expansion, not set for ^X^L
-#define CONT_LOCAL     32      // for ctrl_x_mode 0, ^X^P/^X^N do a local
-                               // expansion, (eg use complete=.)
-
 EXTERN char_u *edit_submode INIT(= NULL);        // msg for CTRL-X submode
 EXTERN char_u *edit_submode_pre INIT(= NULL);    // prepended to edit_submode
 EXTERN char_u *edit_submode_extra INIT(= NULL);  // appended to edit_submode
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index bc02545ed8..2308e923e2 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -219,12 +219,15 @@ static bool compl_started = false;
 ///< Which Ctrl-X mode are we in?
 static int ctrl_x_mode = CTRL_X_NORMAL;
 
-static int compl_matches = 0;
+static int compl_matches = 0;           ///< number of completion matches
 static char *compl_pattern = NULL;
 static Direction compl_direction = FORWARD;
 static Direction compl_shows_dir = FORWARD;
 static int compl_pending = 0;           ///< > 1 for postponed CTRL-N
 static pos_T compl_startpos;
+/// Length in bytes of the text being completed (this is deleted to be replaced
+/// by the match.)
+static int compl_length = 0;
 static colnr_T compl_col = 0;           ///< column where the text starts
                                         ///< that is being completed
 static char_u *compl_orig_text = NULL;  ///< text as it was before
@@ -232,6 +235,20 @@ static char_u *compl_orig_text = NULL;  ///< text as it was before
 static int compl_cont_mode = 0;
 static expand_T compl_xp;
 
+// List of flags for method of completion.
+static int compl_cont_status = 0;
+
+#define CONT_ADDING    1        ///< "normal" or "adding" expansion
+#define CONT_INTRPT    (2 + 4)  ///< a ^X interrupted the current expansion
+                                ///< it's set only iff N_ADDS is set
+#define CONT_N_ADDS    4        ///< next ^X<> will add-new or expand-current
+#define CONT_S_IPOS    8        ///< next ^X<> will set initial_pos?
+                                ///< if so, word-wise-expansion will set SOL
+#define CONT_SOL       16       ///< pattern includes start of line, just for
+                                ///< word-wise expansion, not set for ^X^L
+#define CONT_LOCAL     32       ///< for ctrl_x_mode 0, ^X^P/^X^N do a local
+                                ///< expansion, (eg use complete=.)
+
 static bool compl_opt_refresh_always = false;
 
 static size_t spell_bad_len = 0;   // length of located bad word
@@ -375,9 +392,52 @@ bool ctrl_x_mode_not_defined_yet(void)
   return ctrl_x_mode == CTRL_X_NOT_DEFINED_YET;
 }
 
-/// Check that the "dict" or "tsr" option can be used.
+/// @return  true if currently in "normal" or "adding" insert completion matches state
+bool compl_status_adding(void)
+{
+  return compl_cont_status & CONT_ADDING;
+}
+
+/// @return  true if the completion pattern includes start of line, just for
+///          word-wise expansion.
+bool compl_status_sol(void)
+{
+  return compl_cont_status & CONT_SOL;
+}
+
+/// @return  true if ^X^P/^X^N will do a local completion (i.e. use complete=.)
+bool compl_status_local(void)
+{
+  return compl_cont_status & CONT_LOCAL;
+}
+
+/// Clear the completion status flags
+void compl_status_clear(void)
+{
+  compl_cont_status = 0;
+}
+
+// @return  true if completion is using the forward direction matches
+static bool compl_dir_forward(void)
+{
+  return compl_direction == FORWARD;
+}
+
+/// @return  true if currently showing forward completion matches
+static bool compl_shows_dir_forward(void)
+{
+  return compl_shows_dir == FORWARD;
+}
+
+/// @return  true if currently showing backward completion matches
+static bool compl_shows_dir_backward(void)
+{
+  return compl_shows_dir == BACKWARD;
+}
+
+/// Check that the 'dictionary' or 'thesaurus' option can be used.
 ///
-/// @param  dict_opt  check "dict" when true, "tsr" when false.
+/// @param  dict_opt  check 'dictionary' when true, 'thesaurus' when false.
 bool check_compl_option(bool dict_opt)
 {
   if (dict_opt
@@ -467,6 +527,12 @@ static bool match_at_original_text(const compl_T *const match)
   return match->cp_flags & CP_ORIGINAL_TEXT;
 }
 
+/// @return  true if "match" is the first match in the completion list.
+static bool is_first_match(const compl_T *const match)
+{
+  return match == compl_first_match;
+}
+
 /// Check that character "c" is part of the item currently being
 /// completed.  Used to decide whether to abandon complete mode when the menu
 /// is visible.
@@ -721,7 +787,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
         return NOTDONE;
       }
       match = match->cp_next;
-    } while (match != NULL && match != compl_first_match);
+    } while (match != NULL && !is_first_match(match));
   }
 
   // Remove any popup menu before changing the list of matches.
@@ -911,7 +977,7 @@ static int ins_compl_make_cyclic(void)
   compl_T *match = compl_first_match;
   int count = 0;
   // there's always an entry for the compl_orig_text, it doesn't count.
-  while (match->cp_next != NULL && match->cp_next != compl_first_match) {
+  while (match->cp_next != NULL && !is_first_match(match->cp_next)) {
     match = match->cp_next;
     count++;
   }
@@ -986,7 +1052,7 @@ static bool pum_enough_matches(void)
       break;
     }
     compl = compl->cp_next;
-  } while (compl != compl_first_match);
+  } while (!is_first_match(compl));
 
   if (strstr((char *)p_cot, "menuone") != NULL) {
     return i >= 1;
@@ -1086,7 +1152,7 @@ void ins_compl_show_pum(void)
         compl_match_arraysize++;
       }
       compl = compl->cp_next;
-    } while (compl != NULL && compl != compl_first_match);
+    } while (compl != NULL && !is_first_match(compl));
     if (compl_match_arraysize == 0) {
       return;
     }
@@ -1153,7 +1219,7 @@ void ins_compl_show_pum(void)
         }
       }
       compl = compl->cp_next;
-    } while (compl != NULL && compl != compl_first_match);
+    } while (compl != NULL && !is_first_match(compl));
 
     if (!shown_match_ok) {        // no displayed match at all
       cur = -1;
@@ -1471,12 +1537,13 @@ static void ins_compl_free(void)
     }
     tv_clear(&match->cp_user_data);
     xfree(match);
-  } while (compl_curr_match != NULL && compl_curr_match != compl_first_match);
+  } while (compl_curr_match != NULL && !is_first_match(compl_curr_match));
   compl_first_match = compl_curr_match = NULL;
   compl_shown_match = NULL;
   compl_old_match = NULL;
 }
 
+/// Reset/clear the completion state.
 void ins_compl_clear(void)
 {
   compl_cont_status = 0;
@@ -1530,6 +1597,12 @@ colnr_T ins_compl_col(void)
   return compl_col;
 }
 
+/// Return the length in bytes of the text being completed
+int ins_compl_len(void)
+{
+  return compl_length;
+}
+
 /// Delete one character before the cursor and show the subset of the matches
 /// that match the word that is now before the cursor.
 /// Returns the character to be used, NUL if the work is done and another char
@@ -1714,7 +1787,7 @@ void ins_compl_addfrommatch(void)
 
     p = NULL;
     for (cp = compl_shown_match->cp_next; cp != NULL
-         && cp != compl_first_match; cp = cp->cp_next) {
+         && !is_first_match(cp); cp = cp->cp_next) {
       if (compl_leader == NULL
           || ins_compl_equal(cp, compl_leader, STRLEN(compl_leader))) {
         p = cp->cp_str;
@@ -1730,7 +1803,7 @@ void ins_compl_addfrommatch(void)
   ins_compl_addleader(c);
 }
 
-/// Set the CTRL-X completion mode based on the key 'c' typed after a CTRL-X.
+/// Set the CTRL-X completion mode based on the key "c" typed after a CTRL-X.
 /// Uses the global variables: ctrl_x_mode, edit_submode, edit_submode_pre,
 /// compl_cont_mode and compl_cont_status.
 ///
@@ -2135,7 +2208,7 @@ static buf_T *ins_compl_next_buf(buf_T *buf, int flag)
   return buf;
 }
 
-/// Get the user-defined completion function name for completion 'type'
+/// Get the user-defined completion function name for completion "type"
 static char_u *get_complete_funcname(int type)
 {
   switch (type) {
@@ -2442,13 +2515,12 @@ static void ins_compl_update_sequence_numbers(void)
   int number = 0;
   compl_T *match;
 
-  if (compl_direction == FORWARD) {
+  if (compl_dir_forward()) {
     // search backwards for the first valid (!= -1) number.
     // This should normally succeed already at the first loop
     // cycle, so it's fast!
     for (match = compl_curr_match->cp_prev;
-         match != NULL && match != compl_first_match;
-         match = match->cp_prev) {
+         match != NULL && !is_first_match(match); match = match->cp_prev) {
       if (match->cp_number != -1) {
         number = match->cp_number;
         break;
@@ -2468,8 +2540,7 @@ static void ins_compl_update_sequence_numbers(void)
     // number.  This should normally succeed already at the
     // first loop cycle, so it's fast!
     for (match = compl_curr_match->cp_next;
-         match != NULL && match != compl_first_match;
-         match = match->cp_next) {
+         match != NULL && !is_first_match(match); match = match->cp_next) {
       if (match->cp_number != -1) {
         number = match->cp_number;
         break;
@@ -2554,7 +2625,7 @@ static void get_complete_info(list_T *what_list, dict_T *retdict)
           }
         }
         match = match->cp_next;
-      } while (match != NULL && match != compl_first_match);
+      } while (match != NULL && !is_first_match(match));
     }
   }
 
@@ -2838,7 +2909,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
   char_u *ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
   int len;
   if (ctrl_x_mode_line_or_eval()) {
-    if (compl_cont_status & CONT_ADDING) {
+    if (compl_status_adding()) {
       if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count) {
         return NULL;
       }
@@ -2851,7 +2922,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
   } else {
     char_u *tmp_ptr = ptr;
 
-    if (compl_cont_status & CONT_ADDING && compl_length <= (int)STRLEN(tmp_ptr)) {
+    if (compl_status_adding() && compl_length <= (int)STRLEN(tmp_ptr)) {
       tmp_ptr += compl_length;
       // Skip if already inside a word.
       if (vim_iswordp(tmp_ptr)) {
@@ -2864,7 +2935,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
     tmp_ptr = find_word_end(tmp_ptr);
     len = (int)(tmp_ptr - ptr);
 
-    if ((compl_cont_status & CONT_ADDING) && len == compl_length) {
+    if (compl_status_adding() && len == compl_length) {
       if (cur_match_pos->lnum < ins_buf->b_ml.ml_line_count) {
         // Try next line, if any. the new word will be "join" as if the
         // normal command "J" was used. IOSIZE is always greater than
@@ -2945,8 +3016,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
     msg_silent++;  // Don't want messages for wrapscan.
     // ctrl_x_mode_line_or_eval() || word-wise search that
     // has added a word that was at the beginning of the line.
-    if (ctrl_x_mode_line_or_eval()
-        || (compl_cont_status & CONT_SOL)) {
+    if (ctrl_x_mode_line_or_eval() || (compl_cont_status & CONT_SOL)) {
       found_new_match = search_for_exact_line(st->ins_buf, st->cur_match_pos,
                                               compl_direction, (char_u *)compl_pattern);
     } else {
@@ -2964,7 +3034,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
     } else if (st->first_match_pos.lnum == st->last_match_pos.lnum
                && st->first_match_pos.col == st->last_match_pos.col) {
       found_new_match = FAIL;
-    } else if ((compl_direction == FORWARD)
+    } else if (compl_dir_forward()
                && (st->prev_match_pos.lnum > st->cur_match_pos->lnum
                    || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
                        && st->prev_match_pos.col >= st->cur_match_pos->col))) {
@@ -2973,7 +3043,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
       } else {
         looped_around = true;
       }
-    } else if ((compl_direction != FORWARD)
+    } else if (!compl_dir_forward()
                && (st->prev_match_pos.lnum < st->cur_match_pos->lnum
                    || (st->prev_match_pos.lnum == st->cur_match_pos->lnum
                        && st->prev_match_pos.col <= st->cur_match_pos->col))) {
@@ -2989,7 +3059,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
     }
 
     // when ADDING, the text before the cursor matches, skip it
-    if ((compl_cont_status & CONT_ADDING) && st->ins_buf == curbuf
+    if (compl_status_adding() && st->ins_buf == curbuf
         && start_pos->lnum == st->cur_match_pos->lnum
         && start_pos->col == st->cur_match_pos->col) {
       continue;
@@ -3013,7 +3083,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
   return found_new_match;
 }
 
-/// get the next set of completion matches for 'type'.
+/// get the next set of completion matches for "type".
 /// @return  true if a new match is found, otherwise false.
 static bool get_next_completion_match(int type, ins_compl_next_state_T *st, pos_T *ini)
 {
@@ -3101,8 +3171,7 @@ static int ins_compl_get_exp(pos_T *ini)
   assert(st.ins_buf != NULL);
 
   compl_old_match = compl_curr_match;   // remember the last current match
-  st.cur_match_pos = (compl_direction == FORWARD
-                      ? &st.last_match_pos : &st.first_match_pos);
+  st.cur_match_pos = (compl_dir_forward() ? &st.last_match_pos : &st.first_match_pos);
 
   // For ^N/^P loop over all the flags/windows/buffers in 'complete'
   for (;;) {
@@ -3134,8 +3203,7 @@ static int ins_compl_get_exp(pos_T *ini)
 
     // break the loop for specialized modes (use 'complete' just for the
     // generic ctrl_x_mode == CTRL_X_NORMAL) or when we've found a new match
-    if ((ctrl_x_mode_not_default()
-         && !ctrl_x_mode_line_or_eval())
+    if ((ctrl_x_mode_not_default() && !ctrl_x_mode_line_or_eval())
         || found_new_match != FAIL) {
       if (got_int) {
         break;
@@ -3145,8 +3213,7 @@ static int ins_compl_get_exp(pos_T *ini)
         ins_compl_check_keys(0, false);
       }
 
-      if ((ctrl_x_mode_not_default()
-           && !ctrl_x_mode_line_or_eval())
+      if ((ctrl_x_mode_not_default() && !ctrl_x_mode_line_or_eval())
           || compl_interrupted) {
         break;
       }
@@ -3163,16 +3230,14 @@ static int ins_compl_get_exp(pos_T *ini)
   }
   compl_started = true;
 
-  if ((ctrl_x_mode_normal()
-       || ctrl_x_mode_line_or_eval())
+  if ((ctrl_x_mode_normal() || ctrl_x_mode_line_or_eval())
       && *st.e_cpt == NUL) {  // Got to end of 'complete'
     found_new_match = FAIL;
   }
 
   i = -1;               // total of matches, unknown
   if (found_new_match == FAIL
-      || (ctrl_x_mode_not_default()
-          && !ctrl_x_mode_line_or_eval())) {
+      || (ctrl_x_mode_not_default() && !ctrl_x_mode_line_or_eval())) {
     i = ins_compl_make_cyclic();
   }
 
@@ -3180,7 +3245,7 @@ static int ins_compl_get_exp(pos_T *ini)
     // If several matches were added (FORWARD) or the search failed and has
     // just been made cyclic then we have to move compl_curr_match to the
     // next or previous entry (if any) -- Acevedo
-    compl_curr_match = compl_direction == FORWARD
+    compl_curr_match = compl_dir_forward()
                         ? compl_old_match->cp_next
                         : compl_old_match->cp_prev;
     if (compl_curr_match == NULL) {
@@ -3199,19 +3264,19 @@ static void ins_compl_update_shown_match(void)
   while (!ins_compl_equal(compl_shown_match,
                           compl_leader, STRLEN(compl_leader))
          && compl_shown_match->cp_next != NULL
-         && compl_shown_match->cp_next != compl_first_match) {
+         && !is_first_match(compl_shown_match->cp_next)) {
     compl_shown_match = compl_shown_match->cp_next;
   }
 
   // If we didn't find it searching forward, and compl_shows_dir is
   // backward, find the last match.
-  if (compl_shows_dir == BACKWARD
+  if (compl_shows_dir_backward()
       && !ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
       && (compl_shown_match->cp_next == NULL
-          || compl_shown_match->cp_next == compl_first_match)) {
+          || is_first_match(compl_shown_match->cp_next))) {
     while (!ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
            && compl_shown_match->cp_prev != NULL
-           && compl_shown_match->cp_prev != compl_first_match) {
+           && !is_first_match(compl_shown_match->cp_prev)) {
       compl_shown_match = compl_shown_match->cp_prev;
     }
   }
@@ -3224,7 +3289,7 @@ void ins_compl_delete(void)
 
   // In insert mode: Delete the typed part.
   // In replace mode: Put the old characters back, if any.
-  col = compl_col + (compl_cont_status & CONT_ADDING ? compl_length : 0);
+  col = compl_col + (compl_status_adding() ? compl_length : 0);
   if ((int)curwin->w_cursor.col > col) {
     if (stop_arrow() == FAIL) {
       return;
@@ -3283,7 +3348,7 @@ static void ins_compl_show_filename(void)
   redraw_cmdline = false;  // don't overwrite!
 }
 
-/// Find the next set of matches for completion. Repeat the completion 'todo'
+/// Find the next set of matches for completion. Repeat the completion "todo"
 /// times.  The number of matches found is returned in 'num_matches'.
 ///
 /// @param allow_get_expansion  If true, then ins_compl_get_exp() may be called to
@@ -3302,20 +3367,20 @@ static int find_next_completion_match(bool allow_get_expansion, int todo, bool a
   compl_T *found_compl = NULL;
 
   while (--todo >= 0) {
-    if (compl_shows_dir == FORWARD && compl_shown_match->cp_next != NULL) {
+    if (compl_shows_dir_forward() && compl_shown_match->cp_next != NULL) {
       compl_shown_match = compl_shown_match->cp_next;
       found_end = (compl_first_match != NULL
-                   && (compl_shown_match->cp_next == compl_first_match
-                       || compl_shown_match == compl_first_match));
-    } else if (compl_shows_dir == BACKWARD
+                   && (is_first_match(compl_shown_match->cp_next)
+                       || is_first_match(compl_shown_match)));
+    } else if (compl_shows_dir_backward()
                && compl_shown_match->cp_prev != NULL) {
-      found_end = (compl_shown_match == compl_first_match);
+      found_end = is_first_match(compl_shown_match);
       compl_shown_match = compl_shown_match->cp_prev;
-      found_end |= (compl_shown_match == compl_first_match);
+      found_end |= is_first_match(compl_shown_match);
     } else {
       if (!allow_get_expansion) {
         if (advance) {
-          if (compl_shows_dir == BACKWARD) {
+          if (compl_shows_dir_backward()) {
             compl_pending -= todo + 1;
           } else {
             compl_pending += todo + 1;
@@ -3325,7 +3390,7 @@ static int find_next_completion_match(bool allow_get_expansion, int todo, bool a
       }
 
       if (!compl_no_select && advance) {
-        if (compl_shows_dir == BACKWARD) {
+        if (compl_shows_dir_backward()) {
           compl_pending--;
         } else {
           compl_pending++;
@@ -3405,8 +3470,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
     return -1;
   }
 
-  if (compl_leader != NULL
-      && !match_at_original_text(compl_shown_match)) {
+  if (compl_leader != NULL && !match_at_original_text(compl_shown_match)) {
     // Update "compl_shown_match" to the actually shown match
     ins_compl_update_shown_match();
   }
@@ -3623,7 +3687,7 @@ static bool ins_compl_use_match(int c)
 static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
 {
   if ((compl_cont_status & CONT_SOL) || ctrl_x_mode_path_defines()) {
-    if (!(compl_cont_status & CONT_ADDING)) {
+    if (!compl_status_adding()) {
       while (--startcol >= 0 && vim_isIDc(line[startcol])) {}
       compl_col += ++startcol;
       compl_length = curs_col - startcol;
@@ -3633,7 +3697,7 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
     } else {
       compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
     }
-  } else if (compl_cont_status & CONT_ADDING) {
+  } else if (compl_status_adding()) {
     char_u *prefix = (char_u *)"\\<";
 
     // we need up to 2 extra chars for the prefix
@@ -3849,6 +3913,14 @@ static int get_spell_compl_info(int startcol, colnr_T curs_col)
 }
 
 /// Get the completion pattern, column and length.
+///
+/// @param startcol  start column number of the completion pattern/text
+/// @param cur_col   current cursor column
+///
+/// On return, "line_invalid" is set to true, if the current line may have
+/// become invalid and needs to be fetched again.
+///
+/// @return  OK on success.
 static int compl_get_info(char_u *line, int startcol, colnr_T curs_col, bool *line_invalid)
 {
   if (ctrl_x_mode_normal()
@@ -3866,12 +3938,12 @@ static int compl_get_info(char_u *line, int startcol, colnr_T curs_col, bool *li
     if (get_userdefined_compl_info(curs_col) == FAIL) {
       return FAIL;
     }
-    *line_invalid = true;  // 'line' may have become invalid
+    *line_invalid = true;  // "line" may have become invalid
   } else if (ctrl_x_mode_spell()) {
     if (get_spell_compl_info(startcol, curs_col) == FAIL) {
       return FAIL;
     }
-    *line_invalid = true;  // 'line' may have become invalid
+    *line_invalid = true;  // "line" may have become invalid
   } else {
     internal_error("ins_complete()");
     return FAIL;
@@ -3965,7 +4037,7 @@ static int ins_compl_start(void)
   }
 
   int startcol = 0;  // column where searched text starts
-  if (!(compl_cont_status & CONT_ADDING)) {   // normal expansion
+  if (!compl_status_adding()) {   // normal expansion
     compl_cont_mode = ctrl_x_mode;
     if (ctrl_x_mode_not_default()) {
       // Remove LOCAL if ctrl_x_mode != CTRL_X_NORMAL
@@ -3992,7 +4064,7 @@ static int ins_compl_start(void)
     line = ml_get(curwin->w_cursor.lnum);
   }
 
-  if (compl_cont_status & CONT_ADDING) {
+  if (compl_status_adding()) {
     edit_submode_pre = (char_u *)_(" Adding");
     if (ctrl_x_mode_line_or_eval()) {
       // Insert a new line, keep indentation but ignore 'comments'.
@@ -4051,9 +4123,8 @@ static int ins_compl_start(void)
 static void ins_compl_show_statusmsg(void)
 {
   // we found no match if the list has only the "compl_orig_text"-entry
-  if (compl_first_match == compl_first_match->cp_next) {
-    edit_submode_extra = (compl_cont_status & CONT_ADDING)
-                         && compl_length > 1
+  if (is_first_match(compl_first_match->cp_next)) {
+    edit_submode_extra = compl_status_adding() && compl_length > 1
                          ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf);
     edit_submode_highl = HLF_E;
   }
@@ -4160,13 +4231,13 @@ int ins_complete(int c, bool enable_pum)
   }
 
   // we found no match if the list has only the "compl_orig_text"-entry
-  if (compl_first_match == compl_first_match->cp_next) {
+  if (is_first_match(compl_first_match->cp_next)) {
     // remove N_ADDS flag, so next ^X<> won't try to go to ADDING mode,
     // because we couldn't expand anything at first place, but if we used
     // ^P, ^N, ^X^I or ^X^D we might want to add-expand a single-char-word
     // (such as M in M'exico) if not tried already.  -- Acevedo
     if (compl_length > 1
-        || (compl_cont_status & CONT_ADDING)
+        || compl_status_adding()
         || (ctrl_x_mode_not_default()
             && !ctrl_x_mode_path_patterns()
             && !ctrl_x_mode_path_defines())) {
diff --git a/src/nvim/search.c b/src/nvim/search.c
index d780451081..1c54dafcb1 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1499,16 +1499,15 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
 
     // when adding lines the matching line may be empty but it is not
     // ignored because we are interested in the next line -- Acevedo
-    if ((compl_cont_status & CONT_ADDING)
-        && !(compl_cont_status & CONT_SOL)) {
+    if (compl_status_adding() && !compl_status_sol()) {
       if (mb_strcmp_ic((bool)p_ic, (const char *)p, (const char *)pat) == 0) {
         return OK;
       }
     } else if (*p != NUL) {  // Ignore empty lines.
       // Expanding lines or words.
-      assert(compl_length >= 0);
-      if ((p_ic ? mb_strnicmp(p, pat, (size_t)compl_length)
-                : STRNCMP(p, pat, compl_length)) == 0) {
+      assert(ins_compl_len() >= 0);
+      if ((p_ic ? mb_strnicmp(p, pat, (size_t)ins_compl_len())
+           : STRNCMP(p, pat, ins_compl_len())) == 0) {
         return OK;
       }
     }
@@ -5309,7 +5308,7 @@ static char_u *get_line_and_copy(linenr_T lnum, char_u *buf)
 }
 
 /// Find identifiers or defines in included files.
-/// If p_ic && (compl_cont_status & CONT_SOL) then ptr must be in lowercase.
+/// If p_ic && compl_status_sol() then ptr must be in lowercase.
 ///
 /// @param ptr            pointer to search pattern
 /// @param dir            direction of expansion
@@ -5362,9 +5361,9 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
   file_line = xmalloc(LSIZE);
 
   if (type != CHECK_PATH && type != FIND_DEFINE
-      // when CONT_SOL is set compare "ptr" with the beginning of the line
-      // is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo
-      && !(compl_cont_status & CONT_SOL)) {
+      // when CONT_SOL is set compare "ptr" with the beginning of the
+      // line is faster than quote_meta/regcomp/regexec "ptr" -- Acevedo
+      && !compl_status_sol()) {
     pat = xmalloc(len + 5);
     assert(len <= INT_MAX);
     sprintf((char *)pat, whole ? "\\<%.*s\\>" : "%.*s", (int)len, ptr);
@@ -5604,8 +5603,7 @@ search_line:
        * define and this line didn't match define_prog above.
        */
       if (def_regmatch.regprog == NULL || define_matched) {
-        if (define_matched
-            || (compl_cont_status & CONT_SOL)) {
+        if (define_matched || compl_status_sol()) {
           // compare the first "len" chars from "ptr"
           startp = (char_u *)skipwhite((char *)p);
           if (p_ic) {
@@ -5671,8 +5669,8 @@ search_line:
         }
         found = true;
         aux = p = startp;
-        if (compl_cont_status & CONT_ADDING) {
-          p += compl_length;
+        if (compl_status_adding()) {
+          p += ins_compl_len();
           if (vim_iswordp(p)) {
             goto exit_matched;
           }
@@ -5681,7 +5679,7 @@ search_line:
         p = find_word_end(p);
         i = (int)(p - aux);
 
-        if ((compl_cont_status & CONT_ADDING) && i == compl_length) {
+        if (compl_status_adding() && i == ins_compl_len()) {
           // IOSIZE > compl_length, so the STRNCPY works
           STRNCPY(IObuff, aux, i);
 
@@ -5728,7 +5726,7 @@ search_line:
           IObuff[i] = NUL;
           aux = IObuff;
 
-          if (i == compl_length) {
+          if (i == ins_compl_len()) {
             goto exit_matched;
           }
         }
@@ -5838,7 +5836,7 @@ exit_matched:
       // are not at the end of it already
       if (def_regmatch.regprog == NULL
           && action == ACTION_EXPAND
-          && !(compl_cont_status & CONT_SOL)
+          && !compl_status_sol()
           && *startp != NUL
           && *(p = startp + utfc_ptr2len((char *)startp)) != NUL) {
         goto search_line;
-- 
cgit 


From e4e0e8ce6f282ad891d3e9b7cd66961d23e7cba3 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 12:07:49 +0800
Subject: refactor: ins_compl_show_pum() (#19938)

This marks the remaining part of Vim patch 8.2.3953 as ported, because
ins_compl_upd_pum() has been removed.

vim-patch:8.2.3953: insert completion code is too complicated

Problem:    Insert completion code is too complicated.
Solution:   More refactoring.  Move function arguments into a struct.
            (Yegappan Lakshmanan, closes vim/vim#9437)
https://github.com/vim/vim/commit/6ad84ab3e48d9490e4139df04f2c55b136f5501d
---
 src/nvim/insexpand.c | 214 +++++++++++++++++++++++++++------------------------
 1 file changed, 112 insertions(+), 102 deletions(-)

(limited to 'src')

diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 2308e923e2..bb94045ca4 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1108,141 +1108,151 @@ static void trigger_complete_changed_event(int cur)
   restore_v_event(v_event, &save_v_event);
 }
 
-/// Show the popup menu for the list of matches.
-/// Also adjusts "compl_shown_match" to an entry that is actually displayed.
-void ins_compl_show_pum(void)
+/// Build a popup menu to show the completion matches.
+///
+/// @return  the popup menu entry that should be selected,
+///          -1 if nothing should be selected.
+static int ins_compl_build_pum(void)
 {
-  compl_T *compl;
-  compl_T *shown_compl = NULL;
-  bool did_find_shown_match = false;
-  bool shown_match_ok = false;
-  int i;
-  int cur = -1;
-  colnr_T col;
-  int lead_len = 0;
-  bool array_changed = false;
+  // Need to build the popup menu list.
+  compl_match_arraysize = 0;
+  compl_T *compl = compl_first_match;
 
-  if (!pum_wanted() || !pum_enough_matches()) {
-    return;
+  // If it's user complete function and refresh_always,
+  // do not use "compl_leader" as prefix filter.
+  if (ins_compl_need_restart()) {
+    XFREE_CLEAR(compl_leader);
   }
 
-  // Dirty hard-coded hack: remove any matchparen highlighting.
-  do_cmdline_cmd("if exists('g:loaded_matchparen')|3match none|endif");
+  const int lead_len = compl_leader != NULL ? (int)STRLEN(compl_leader) : 0;
 
-  // Update the screen before drawing the popup menu over it.
-  update_screen(0);
-
-  if (compl_match_array == NULL) {
-    array_changed = true;
-    // Need to build the popup menu list.
-    compl_match_arraysize = 0;
-    compl = compl_first_match;
-    // If it's user complete function and refresh_always,
-    // do not use "compl_leader" as prefix filter.
-    if (ins_compl_need_restart()) {
-      XFREE_CLEAR(compl_leader);
-    }
-    if (compl_leader != NULL) {
-      lead_len = (int)STRLEN(compl_leader);
-    }
-    do {
-      if (!match_at_original_text(compl)
-          && (compl_leader == NULL
-              || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
-        compl_match_arraysize++;
-      }
-      compl = compl->cp_next;
-    } while (compl != NULL && !is_first_match(compl));
-    if (compl_match_arraysize == 0) {
-      return;
+  do {
+    if (!match_at_original_text(compl)
+        && (compl_leader == NULL
+            || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
+      compl_match_arraysize++;
     }
+    compl = compl->cp_next;
+  } while (compl != NULL && !is_first_match(compl));
 
-    assert(compl_match_arraysize >= 0);
-    compl_match_array = xcalloc((size_t)compl_match_arraysize, sizeof(pumitem_T));
-    // If the current match is the original text don't find the first
-    // match after it, don't highlight anything.
-    if (match_at_original_text(compl_shown_match)) {
-      shown_match_ok = true;
-    }
+  if (compl_match_arraysize == 0) {
+    return -1;
+  }
 
-    i = 0;
-    compl = compl_first_match;
-    do {
-      if (!match_at_original_text(compl)
-          && (compl_leader == NULL
-              || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
-        if (!shown_match_ok) {
-          if (compl == compl_shown_match || did_find_shown_match) {
-            // This item is the shown match or this is the
-            // first displayed item after the shown match.
-            compl_shown_match = compl;
-            did_find_shown_match = true;
-            shown_match_ok = true;
-          } else {
-            // Remember this displayed match for when the
-            // shown match is just below it.
-            shown_compl = compl;
-          }
-          cur = i;
-        }
+  assert(compl_match_arraysize >= 0);
+  compl_match_array = xcalloc((size_t)compl_match_arraysize, sizeof(pumitem_T));
 
-        if (compl->cp_text[CPT_ABBR] != NULL) {
-          compl_match_array[i].pum_text =
-            compl->cp_text[CPT_ABBR];
-        } else {
-          compl_match_array[i].pum_text = compl->cp_str;
-        }
-        compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND];
-        compl_match_array[i].pum_info = compl->cp_text[CPT_INFO];
-        if (compl->cp_text[CPT_MENU] != NULL) {
-          compl_match_array[i++].pum_extra =
-            compl->cp_text[CPT_MENU];
+  // If the current match is the original text don't find the first
+  // match after it, don't highlight anything.
+  bool shown_match_ok = match_at_original_text(compl_shown_match);
+
+  compl_T *shown_compl = NULL;
+  bool did_find_shown_match = false;
+  int cur = -1;
+  int i = 0;
+  compl = compl_first_match;
+  do {
+    if (!match_at_original_text(compl)
+        && (compl_leader == NULL
+            || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
+      if (!shown_match_ok) {
+        if (compl == compl_shown_match || did_find_shown_match) {
+          // This item is the shown match or this is the
+          // first displayed item after the shown match.
+          compl_shown_match = compl;
+          did_find_shown_match = true;
+          shown_match_ok = true;
         } else {
-          compl_match_array[i++].pum_extra = compl->cp_fname;
+          // Remember this displayed match for when the
+          // shown match is just below it.
+          shown_compl = compl;
         }
+        cur = i;
       }
 
-      if (compl == compl_shown_match) {
-        did_find_shown_match = true;
+      if (compl->cp_text[CPT_ABBR] != NULL) {
+        compl_match_array[i].pum_text = compl->cp_text[CPT_ABBR];
+      } else {
+        compl_match_array[i].pum_text = compl->cp_str;
+      }
+      compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND];
+      compl_match_array[i].pum_info = compl->cp_text[CPT_INFO];
+      if (compl->cp_text[CPT_MENU] != NULL) {
+        compl_match_array[i++].pum_extra = compl->cp_text[CPT_MENU];
+      } else {
+        compl_match_array[i++].pum_extra = compl->cp_fname;
+      }
+    }
 
-        // When the original text is the shown match don't set
-        // compl_shown_match.
-        if (match_at_original_text(compl)) {
-          shown_match_ok = true;
-        }
+    if (compl == compl_shown_match) {
+      did_find_shown_match = true;
 
-        if (!shown_match_ok && shown_compl != NULL) {
-          // The shown match isn't displayed, set it to the
-          // previously displayed match.
-          compl_shown_match = shown_compl;
-          shown_match_ok = true;
-        }
+      // When the original text is the shown match don't set
+      // compl_shown_match.
+      if (match_at_original_text(compl)) {
+        shown_match_ok = true;
       }
-      compl = compl->cp_next;
-    } while (compl != NULL && !is_first_match(compl));
 
-    if (!shown_match_ok) {        // no displayed match at all
-      cur = -1;
+      if (!shown_match_ok && shown_compl != NULL) {
+        // The shown match isn't displayed, set it to the
+        // previously displayed match.
+        compl_shown_match = shown_compl;
+        shown_match_ok = true;
+      }
     }
+    compl = compl->cp_next;
+  } while (compl != NULL && !is_first_match(compl));
+
+  if (!shown_match_ok) {  // no displayed match at all
+    cur = -1;
+  }
+
+  return cur;
+}
+
+/// Show the popup menu for the list of matches.
+/// Also adjusts "compl_shown_match" to an entry that is actually displayed.
+void ins_compl_show_pum(void)
+{
+  if (!pum_wanted() || !pum_enough_matches()) {
+    return;
+  }
+
+  // Dirty hard-coded hack: remove any matchparen highlighting.
+  do_cmdline_cmd("if exists('g:loaded_matchparen')|3match none|endif");
+
+  // Update the screen before drawing the popup menu over it.
+  update_screen(0);
+
+  int cur = -1;
+  bool array_changed = false;
+
+  if (compl_match_array == NULL) {
+    array_changed = true;
+    // Need to build the popup menu list.
+    cur = ins_compl_build_pum();
   } else {
     // popup menu already exists, only need to find the current item.
-    for (i = 0; i < compl_match_arraysize; i++) {
+    for (int i = 0; i < compl_match_arraysize; i++) {
       if (compl_match_array[i].pum_text == compl_shown_match->cp_str
-          || compl_match_array[i].pum_text
-          == compl_shown_match->cp_text[CPT_ABBR]) {
+          || compl_match_array[i].pum_text == compl_shown_match->cp_text[CPT_ABBR]) {
         cur = i;
         break;
       }
     }
   }
 
+  if (compl_match_array == NULL) {
+    return;
+  }
+
   // In Replace mode when a $ is displayed at the end of the line only
   // part of the screen would be updated.  We do need to redraw here.
   dollar_vcol = -1;
 
   // Compute the screen column of the start of the completed text.
   // Use the cursor to get all wrapping and other settings right.
-  col = curwin->w_cursor.col;
+  const colnr_T col = curwin->w_cursor.col;
   curwin->w_cursor.col = compl_col;
   pum_selected_item = cur;
   pum_display(compl_match_array, compl_match_arraysize, cur, array_changed, 0);
-- 
cgit 


From 711635872debd52930fac6d0a8f4204e7cc8d258 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 12:49:12 +0800
Subject: vim-patch:8.1.1085: compiler warning for possibly uninitialized
 variable

Problem:    Compiler warning for possibly uninitialized variable. (Tony
            Mechelynck)
Solution:   Make conditions more logical.
https://github.com/vim/vim/commit/bd9bf266fccbf7b7f09e476e09b61f0133e914db
---
 src/nvim/arabic.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/nvim/arabic.c b/src/nvim/arabic.c
index 06536e6e2b..b57019286f 100644
--- a/src/nvim/arabic.c
+++ b/src/nvim/arabic.c
@@ -320,22 +320,22 @@ int arabic_shape(int c, int *ccp, int *c1p, int prev_c, int prev_c1, int next_c)
     int backward_combine = !prev_laa && can_join(prev_c, c);
     int forward_combine = can_join(c, next_c);
 
-    if (backward_combine && forward_combine) {
-      curr_c = (int)curr_a->medial;
-    }
-    if (backward_combine && !forward_combine) {
-      curr_c = (int)curr_a->final;
-    }
-    if (!backward_combine && forward_combine) {
-      curr_c = (int)curr_a->initial;
-    }
-    if (!backward_combine && !forward_combine) {
-      curr_c = (int)curr_a->isolated;
+    if (backward_combine) {
+      if (forward_combine) {
+        curr_c = (int)curr_a->medial;
+      } else {
+        curr_c = (int)curr_a->final;
+      }
+    } else {
+      if (forward_combine) {
+        curr_c = (int)curr_a->initial;
+      } else {
+        curr_c = (int)curr_a->isolated;
+      }
     }
   }
 
-  // Sanity check -- curr_c should, in the future, never be 0.
-  // We should, in the future, insert a fatal error here.
+  // Character missing from the table means using original character.
   if (curr_c == NUL) {
     curr_c = c;
   }
-- 
cgit 


From 88738bd28fe078441d44337873e8f156cb22af29 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 12:58:14 +0800
Subject: vim-patch:8.2.1728: compiler warning for using uninitialized variable

Problem:    Compiler warning for using uninitialized variable. (John Marriott)
Solution:   Initialize "neighbor".
https://github.com/vim/vim/commit/c53e9c57a9846655c2d3169788f4beefa6d22d90
---
 src/nvim/search.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/search.c b/src/nvim/search.c
index 1c54dafcb1..6b390294c0 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -4868,7 +4868,7 @@ static int fuzzy_match_compute_score(const char_u *const str, const int strSz,
     if (currIdx > 0) {
       // Camel case
       const char_u *p = str;
-      int neighbor;
+      int neighbor = ' ';
 
       for (uint32_t sidx = 0; sidx < currIdx; sidx++) {
         neighbor = utf_ptr2char((char *)p);
-- 
cgit 


From 7656cd527bc22c9899f98d6a08a2b98de51d6f68 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 13:00:07 +0800
Subject: vim-patch:8.2.1960: warning for uninitialized variable

Problem:    Warning for uninitialized variable.
Solution:   Initialize the variable.
https://github.com/vim/vim/commit/0fd797eacd569a0680a86452c18713eacf6608fe
---
 src/nvim/eval/funcs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 988300f6f2..fc926cf5a9 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -5714,7 +5714,7 @@ static void f_rand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     // When no argument is given use the global seed list.
     if (!initialized) {
       // Initialize the global seed list.
-      uint32_t x;
+      uint32_t x = 0;
       init_srand(&x);
 
       gx = splitmix32(&x);
-- 
cgit 


From e7dd65eea382707e07b1f061298c4660d02022e5 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 13:04:03 +0800
Subject: vim-patch:8.2.2826: compiler warnings for int to size_t conversion

Problem:    Compiler warnings for int to size_t conversion. (Randall W.
            Morris)
Solution:   Add type casts.
https://github.com/vim/vim/commit/551c1aed65817558ac1ece541c246ea585645807

Still keep it size_t, but avoid calculating multiple times.
---
 src/nvim/quickfix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 5925f249a2..4d6f7a0f36 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -5140,6 +5140,7 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
   FUNC_ATTR_NONNULL_ARG(1, 3, 4, 5, 6)
 {
   bool found_match = false;
+  const size_t pat_len = STRLEN(spat);
 
   for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count && *tomatch > 0; lnum++) {
     colnr_T col = 0;
@@ -5181,7 +5182,6 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
         }
       }
     } else {
-      const size_t pat_len = STRLEN(spat);
       char *const str = (char *)ml_get_buf(buf, lnum, false);
       int score;
       uint32_t matches[MAX_FUZZY_MATCHES];
-- 
cgit 


From 6584f3a2b69b901900b9f267d62e06efbc15fec1 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 12:35:24 +0800
Subject: vim-patch:8.2.4289: warnings reported by MSVC

Problem:    Warnings reported by MSVC.
Solution:   Rename variables and other fixes. (Ken Takata, closes vim/vim#9689)
https://github.com/vim/vim/commit/5411910c77cba85212963a2fb71d8c71f8a5d203

N/A patches for version.c:

vim-patch:8.2.0091: compiler warnings for size_t / int types

Problem:    Compiler warnings for size_t / int types.
Solution:   Change type to size_t. (Mike Williams)
https://github.com/vim/vim/commit/4d7a248b644b647340ed1a25729e2ed586a54864

vim-patch:8.2.1299: compiler warning for using size_t for int and void pointer

Problem:    Compiler warning for using size_t for int and void pointer.
Solution:   Add type casts.
https://github.com/vim/vim/commit/d3bb6a82a51d549bbd597bb4e94d8f074009be2a

vim-patch:8.2.1906: warning for signed/unsigned

Problem:    Warning for signed/unsigned.
Solution:   Use size_t instead of int. (Mike Williams)
https://github.com/vim/vim/commit/a360dbe3b63bdca93bbf8cc431578a446e8ce14c

vim-patch:8.2.4531: LGTM warnings for condition and buffer size

Problem:    LGTM warnings for condition always true and buffer size too small.
Solution:   Remove the useless condition.  Make the buffer larger. (Goc
            Dundar, closes vim/vim#9914)
https://github.com/vim/vim/commit/f01a653ac50bb3542c24d26bb3fa5371cc3b2ed7

vim-patch:8.2.4624: old Coverity warning for resource leak

Problem:    Old Coverity warning for resource leak.
Solution:   Close the file if memory allocation fails.
https://github.com/vim/vim/commit/5d46dcfeed4fcbbab371e17e1072b0cc9abe5217

vim-patch:9.0.0129: compiler warning for int/size_t usage

Problem:    Compiler warning for int/size_t usage.
Solution:   Add a type cast. (Mike Williams, closes vim/vim#10830)
https://github.com/vim/vim/commit/ab146dac6b4148e770eb2bf61c72ef62d3ecfc65
---
 src/nvim/cmdexpand.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 5a53175b4a..50a84595fc 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -1939,13 +1939,12 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
       || xp->xp_context == EXPAND_FILES_IN_PATH) {
     // Expand file or directory names.
     bool free_pat = false;
-    int i;
 
     // for ":set path=" and ":set tags=" halve backslashes for escaped space
     if (xp->xp_backslash != XP_BS_NONE) {
       free_pat = true;
       pat = vim_strsave(pat);
-      for (i = 0; pat[i]; i++) {
+      for (int i = 0; pat[i]; i++) {
         if (pat[i] == '\\') {
           if (xp->xp_backslash == XP_BS_THREE
               && pat[i + 1] == '\\'
@@ -1979,8 +1978,8 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
     }
 #ifdef BACKSLASH_IN_FILENAME
     if (p_csl[0] != NUL && (options & WILD_IGNORE_COMPLETESLASH) == 0) {
-      for (int i = 0; i < *num_file; i++) {
-        char_u *ptr = (*file)[i];
+      for (int j = 0; j < *num_file; j++) {
+        char_u *ptr = (*file)[j];
         while (*ptr != NUL) {
           if (p_csl[0] == 's' && *ptr == '\\') {
             *ptr = '/';
-- 
cgit 


From f0658fd552ec2d72cdd3f09942fe104bc6265115 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 15:20:54 +0800
Subject: refactor: suppress clang and PVS warnings (#19940)

---
 src/nvim/eval.c        | 1 +
 src/nvim/eval/typval.c | 2 +-
 src/nvim/eval/vars.c   | 1 +
 src/nvim/insexpand.c   | 1 +
 4 files changed, 4 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index fb3270511a..1458d1ff36 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -8148,6 +8148,7 @@ repeat:
         // Only replace it when it starts with '~'
         if (*dirname == '~') {
           s = xstrdup(dirname);
+          assert(s != NULL);  // suppress clang "Argument with 'nonnull' attribute passed null"
           *fnamep = s;
           xfree(*bufp);
           *bufp = s;
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index dcfdb4ab8e..152c2eff8f 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -1252,7 +1252,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
           idx++;
           li = TV_LIST_ITEM_NEXT(l, li);
         }
-        if (info.item_compare_func_err) {
+        if (info.item_compare_func_err) {  // -V547
           emsg(_("E882: Uniq compare function failed"));
           break;
         }
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 03ffd42549..d1336b4e28 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -791,6 +791,7 @@ static void ex_unletlock(exarg_T *eap, char *argstart, int deep, ex_unletlock_ca
         semsg(_(e_invarg2), arg - 1);
         return;
       }
+      assert(*lv.ll_name == '$');  // suppress clang "Uninitialized argument value"
       if (!error && !eap->skip && callback(&lv, arg, eap, deep) == FAIL) {
         error = true;
       }
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index bb94045ca4..c92183dc2a 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -640,6 +640,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
   while (i < char_len) {
     if (gap.ga_data != NULL) {
       ga_grow(&gap, 10);
+      assert(gap.ga_data != NULL);  // suppress clang "Dereference of NULL pointer"
       p = (char *)gap.ga_data + gap.ga_len;
       gap.ga_len += utf_char2bytes(wca[i++], p);
     } else if ((p - (char *)IObuff) + 6 >= IOSIZE) {
-- 
cgit 


From 274e1122ade42095cd5b6416e70bda3aa0cb0423 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 17:57:32 +0800
Subject: fix(usercmd): also check for whitespace after escaped character
 (#19942)

---
 src/nvim/usercmd.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 59b8d10200..e130db69f2 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -1061,11 +1061,11 @@ bool uc_split_args_iter(const char *arg, size_t arglen, size_t *end, char *buf,
       buf[l++] = arg[++pos];
     } else {
       buf[l++] = arg[pos];
-      if (ascii_iswhite(arg[pos + 1])) {
-        *end = pos + 1;
-        *len = l;
-        return false;
-      }
+    }
+    if (ascii_iswhite(arg[pos + 1])) {
+      *end = pos + 1;
+      *len = l;
+      return false;
     }
   }
 
-- 
cgit 


From 1b29288709e75064b9188420d46e1028d7ee341e Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 19:06:26 +0800
Subject: vim-patch:8.2.4356: command line completion functions are very long
 (#19943)

Problem:    Command line completion functions are very long.
Solution:   Refactor into multiple functions. (Yegappan Lakshmanan,
            closes vim/vim#9753)
https://github.com/vim/vim/commit/620d8edba01bb2779485718dd1a99ca670ca894b

Change fifth argument of set_context_by_cmdname() to "context".
---
 src/nvim/cmdexpand.c | 1040 +++++++++++++++++++++++++++-----------------------
 1 file changed, 560 insertions(+), 480 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 50a84595fc..abf36734b9 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -275,6 +275,150 @@ void cmdline_pum_cleanup(CmdlineInfo *cclp)
   wildmenu_cleanup(cclp);
 }
 
+/// Get the next or prev cmdline completion match. The index of the match is set
+/// in "p_findex"
+static char_u *get_next_or_prev_match(int mode, expand_T *xp, int *p_findex, char_u *orig_save)
+{
+  if (xp->xp_numfiles <= 0) {
+    return NULL;
+  }
+
+  int findex = *p_findex;
+
+  if (mode == WILD_PREV) {
+    if (findex == -1) {
+      findex = xp->xp_numfiles;
+    }
+    findex--;
+  } else {  // mode == WILD_NEXT
+    findex++;
+  }
+
+  // When wrapping around, return the original string, set findex to -1.
+  if (findex < 0) {
+    if (orig_save == NULL) {
+      findex = xp->xp_numfiles - 1;
+    } else {
+      findex = -1;
+    }
+  }
+  if (findex >= xp->xp_numfiles) {
+    if (orig_save == NULL) {
+      findex = 0;
+    } else {
+      findex = -1;
+    }
+  }
+  if (compl_match_array) {
+    compl_selected = findex;
+    cmdline_pum_display(false);
+  } else if (p_wmnu) {
+    redraw_wildmenu(xp, xp->xp_numfiles, xp->xp_files, findex, cmd_showtail);
+  }
+  *p_findex = findex;
+
+  return vim_strsave(findex == -1 ? orig_save : (char_u *)xp->xp_files[findex]);
+}
+
+/// Start the command-line expansion and get the matches.
+static char_u *ExpandOne_start(int mode, expand_T *xp, char_u *str, int options)
+{
+  int non_suf_match;  // number without matching suffix
+  char_u *ss = NULL;
+
+  // Do the expansion.
+  if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
+#ifdef FNAME_ILLEGAL
+    // Illegal file name has been silently skipped.  But when there
+    // are wildcards, the real problem is that there was no match,
+    // causing the pattern to be added, which has illegal characters.
+    if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND)) {
+      semsg(_(e_nomatch2), str);
+    }
+#endif
+  } else if (xp->xp_numfiles == 0) {
+    if (!(options & WILD_SILENT)) {
+      semsg(_(e_nomatch2), str);
+    }
+  } else {
+    // Escape the matches for use on the command line.
+    ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
+
+    // Check for matching suffixes in file names.
+    if (mode != WILD_ALL && mode != WILD_ALL_KEEP
+        && mode != WILD_LONGEST) {
+      if (xp->xp_numfiles) {
+        non_suf_match = xp->xp_numfiles;
+      } else {
+        non_suf_match = 1;
+      }
+      if ((xp->xp_context == EXPAND_FILES
+           || xp->xp_context == EXPAND_DIRECTORIES)
+          && xp->xp_numfiles > 1) {
+        // More than one match; check suffix.
+        // The files will have been sorted on matching suffix in
+        // expand_wildcards, only need to check the first two.
+        non_suf_match = 0;
+        for (int i = 0; i < 2; i++) {
+          if (match_suffix((char_u *)xp->xp_files[i])) {
+            non_suf_match++;
+          }
+        }
+      }
+      if (non_suf_match != 1) {
+        // Can we ever get here unless it's while expanding
+        // interactively?  If not, we can get rid of this all
+        // together. Don't really want to wait for this message
+        // (and possibly have to hit return to continue!).
+        if (!(options & WILD_SILENT)) {
+          emsg(_(e_toomany));
+        } else if (!(options & WILD_NO_BEEP)) {
+          beep_flush();
+        }
+      }
+      if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE)) {
+        ss = vim_strsave((char_u *)xp->xp_files[0]);
+      }
+    }
+  }
+
+  return ss;
+}
+
+/// Return the longest common part in the list of cmdline completion matches.
+static char_u *find_longest_match(expand_T *xp, int options)
+{
+  size_t len = 0;
+
+  for (size_t mb_len; xp->xp_files[0][len]; len += mb_len) {
+    mb_len = (size_t)utfc_ptr2len(&xp->xp_files[0][len]);
+    int c0 = utf_ptr2char(&xp->xp_files[0][len]);
+    int i;
+    for (i = 1; i < xp->xp_numfiles; i++) {
+      int ci = utf_ptr2char(&xp->xp_files[i][len]);
+
+      if (p_fic && (xp->xp_context == EXPAND_DIRECTORIES
+                    || xp->xp_context == EXPAND_FILES
+                    || xp->xp_context == EXPAND_SHELLCMD
+                    || xp->xp_context == EXPAND_BUFFERS)) {
+        if (mb_tolower(c0) != mb_tolower(ci)) {
+          break;
+        }
+      } else if (c0 != ci) {
+        break;
+      }
+    }
+    if (i < xp->xp_numfiles) {
+      if (!(options & WILD_NO_BEEP)) {
+        vim_beep(BO_WILD);
+      }
+      break;
+    }
+  }
+
+  return (char_u *)xstrndup(xp->xp_files[0], len);
+}
+
 /// Do wildcard expansion on the string 'str'.
 /// Chars that should not be expanded must be preceded with a backslash.
 /// Return a pointer to allocated memory containing the new string.
@@ -295,6 +439,10 @@ void cmdline_pum_cleanup(CmdlineInfo *cclp)
 /// mode = WILD_ALL:         return all matches concatenated
 /// mode = WILD_LONGEST:     return longest matched part
 /// mode = WILD_ALL_KEEP:    get all matches, keep matches
+/// mode = WILD_APPLY:       apply the item selected in the cmdline completion
+///                          popup menu and close the menu.
+/// mode = WILD_CANCEL:      cancel and close the cmdline completion popup and
+///                          use the original text.
 ///
 /// options = WILD_LIST_NOTFOUND:    list entries without a match
 /// options = WILD_HOME_REPLACE:     do home_replace() for buffer names
@@ -316,56 +464,17 @@ char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode
   static char_u *orig_save = NULL;      // kept value of orig
   int orig_saved = false;
   int i;
-  int non_suf_match;                    // number without matching suffix
 
   // first handle the case of using an old match
   if (mode == WILD_NEXT || mode == WILD_PREV) {
-    if (xp->xp_numfiles > 0) {
-      if (mode == WILD_PREV) {
-        if (findex == -1) {
-          findex = xp->xp_numfiles;
-        }
-        findex--;
-      } else {  // mode == WILD_NEXT
-        findex++;
-      }
-
-      // When wrapping around, return the original string, set findex to
-      // -1.
-      if (findex < 0) {
-        if (orig_save == NULL) {
-          findex = xp->xp_numfiles - 1;
-        } else {
-          findex = -1;
-        }
-      }
-      if (findex >= xp->xp_numfiles) {
-        if (orig_save == NULL) {
-          findex = 0;
-        } else {
-          findex = -1;
-        }
-      }
-      if (compl_match_array) {
-        compl_selected = findex;
-        cmdline_pum_display(false);
-      } else if (p_wmnu) {
-        redraw_wildmenu(xp, xp->xp_numfiles, xp->xp_files, findex, cmd_showtail);
-      }
-      if (findex == -1) {
-        return vim_strsave(orig_save);
-      }
-      return vim_strsave((char_u *)xp->xp_files[findex]);
-    } else {
-      return NULL;
-    }
+    return get_next_or_prev_match(mode, xp, &findex, orig_save);
   }
 
   if (mode == WILD_CANCEL) {
     ss = vim_strsave(orig_save ? orig_save : (char_u *)"");
   } else if (mode == WILD_APPLY) {
-    ss =  vim_strsave(findex == -1 ? (orig_save ? orig_save : (char_u *)"") :
-                      (char_u *)xp->xp_files[findex]);
+    ss = vim_strsave(findex == -1 ? (orig_save ? orig_save : (char_u *)"")
+                     : (char_u *)xp->xp_files[findex]);
   }
 
   // free old names
@@ -385,93 +494,12 @@ char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode
     orig_save = orig;
     orig_saved = true;
 
-    // Do the expansion.
-    if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
-#ifdef FNAME_ILLEGAL
-      // Illegal file name has been silently skipped.  But when there
-      // are wildcards, the real problem is that there was no match,
-      // causing the pattern to be added, which has illegal characters.
-      if (!(options & WILD_SILENT) && (options & WILD_LIST_NOTFOUND)) {
-        semsg(_(e_nomatch2), str);
-      }
-#endif
-    } else if (xp->xp_numfiles == 0) {
-      if (!(options & WILD_SILENT)) {
-        semsg(_(e_nomatch2), str);
-      }
-    } else {
-      // Escape the matches for use on the command line.
-      ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
-
-      // Check for matching suffixes in file names.
-      if (mode != WILD_ALL && mode != WILD_ALL_KEEP
-          && mode != WILD_LONGEST) {
-        if (xp->xp_numfiles) {
-          non_suf_match = xp->xp_numfiles;
-        } else {
-          non_suf_match = 1;
-        }
-        if ((xp->xp_context == EXPAND_FILES
-             || xp->xp_context == EXPAND_DIRECTORIES)
-            && xp->xp_numfiles > 1) {
-          // More than one match; check suffix.
-          // The files will have been sorted on matching suffix in
-          // expand_wildcards, only need to check the first two.
-          non_suf_match = 0;
-          for (i = 0; i < 2; i++) {
-            if (match_suffix((char_u *)xp->xp_files[i])) {
-              non_suf_match++;
-            }
-          }
-        }
-        if (non_suf_match != 1) {
-          // Can we ever get here unless it's while expanding
-          // interactively?  If not, we can get rid of this all
-          // together. Don't really want to wait for this message
-          // (and possibly have to hit return to continue!).
-          if (!(options & WILD_SILENT)) {
-            emsg(_(e_toomany));
-          } else if (!(options & WILD_NO_BEEP)) {
-            beep_flush();
-          }
-        }
-        if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE)) {
-          ss = vim_strsave((char_u *)xp->xp_files[0]);
-        }
-      }
-    }
+    ss = ExpandOne_start(mode, xp, str, options);
   }
 
   // Find longest common part
   if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
-    size_t len = 0;
-
-    for (size_t mb_len; xp->xp_files[0][len]; len += mb_len) {
-      mb_len = (size_t)utfc_ptr2len(&xp->xp_files[0][len]);
-      int c0 = utf_ptr2char(&xp->xp_files[0][len]);
-      for (i = 1; i < xp->xp_numfiles; i++) {
-        int ci = utf_ptr2char(&xp->xp_files[i][len]);
-
-        if (p_fic && (xp->xp_context == EXPAND_DIRECTORIES
-                      || xp->xp_context == EXPAND_FILES
-                      || xp->xp_context == EXPAND_SHELLCMD
-                      || xp->xp_context == EXPAND_BUFFERS)) {
-          if (mb_tolower(c0) != mb_tolower(ci)) {
-            break;
-          }
-        } else if (c0 != ci) {
-          break;
-        }
-      }
-      if (i < xp->xp_numfiles) {
-        if (!(options & WILD_NO_BEEP)) {
-          vim_beep(BO_WILD);
-        }
-        break;
-      }
-    }
-
-    ss = (char_u *)xstrndup(xp->xp_files[0], len);
+    ss = find_longest_match(xp, options);
     findex = -1;  // next p_wc gets first one
   }
 
@@ -951,65 +979,23 @@ void set_expand_context(expand_T *xp)
   set_cmd_context(xp, ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
 }
 
-/// This is all pretty much copied from do_one_cmd(), with all the extra stuff
-/// we don't need/want deleted.  Maybe this could be done better if we didn't
-/// repeat all this stuff.  The only problem is that they may not stay
-/// perfectly compatible with each other, but then the command line syntax
-/// probably won't change that much -- webb.
+/// Sets the index of a built-in or user defined command "cmd" in eap->cmdidx.
+/// For user defined commands, the completion context is set in "xp" and the
+/// completion flags in "complp".
 ///
-/// @param buff  buffer for command string
-static const char *set_one_cmd_context(expand_T *xp, const char *buff)
+/// @return  a pointer to the text after the command or NULL for failure.
+static const char *set_cmd_index(const char *cmd, exarg_T *eap, expand_T *xp, int *complp)
 {
+  const char *p = NULL;
   size_t len = 0;
-  exarg_T ea;
-  int context = EXPAND_NOTHING;
-  bool forceit = false;
-  bool usefilter = false;  // Filter instead of file name.
-
-  ExpandInit(xp);
-  xp->xp_pattern = (char *)buff;
-  xp->xp_line = (char *)buff;
-  xp->xp_context = EXPAND_COMMANDS;  // Default until we get past command
-  ea.argt = 0;
-
-  // 2. skip comment lines and leading space, colons or bars
-  const char *cmd;
-  for (cmd = buff; vim_strchr(" \t:|", *cmd) != NULL; cmd++) {}
-  xp->xp_pattern = (char *)cmd;
-
-  if (*cmd == NUL) {
-    return NULL;
-  }
-  if (*cmd == '"') {        // ignore comment lines
-    xp->xp_context = EXPAND_NOTHING;
-    return NULL;
-  }
-
-  // 3. parse a range specifier of the form: addr [,addr] [;addr] ..
-  cmd = (const char *)skip_range(cmd, &xp->xp_context);
-
-  // 4. parse command
-  xp->xp_pattern = (char *)cmd;
-  if (*cmd == NUL) {
-    return NULL;
-  }
-  if (*cmd == '"') {
-    xp->xp_context = EXPAND_NOTHING;
-    return NULL;
-  }
-
-  if (*cmd == '|' || *cmd == '\n') {
-    return cmd + 1;                     // There's another command
-  }
 
   // Isolate the command and search for it in the command table.
   // Exceptions:
   // - the 'k' command can directly be followed by any character, but
   //   do accept "keepmarks", "keepalt" and "keepjumps".
   // - the 's' command can be followed directly by 'c', 'g', 'i', 'I' or 'r'
-  const char *p;
   if (*cmd == 'k' && cmd[1] != 'e') {
-    ea.cmdidx = CMD_k;
+    eap->cmdidx = CMD_k;
     p = cmd + 1;
   } else {
     p = cmd;
@@ -1040,7 +1026,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
       return NULL;
     }
 
-    ea.cmdidx = excmd_get_cmdidx(cmd, len);
+    eap->cmdidx = excmd_get_cmdidx(cmd, len);
 
     if (cmd[0] >= 'A' && cmd[0] <= 'Z') {
       while (ASCII_ISALNUM(*p) || *p == '*') {  // Allow * wild card
@@ -1055,227 +1041,131 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
     return NULL;
   }
 
-  if (ea.cmdidx == CMD_SIZE) {
+  if (eap->cmdidx == CMD_SIZE) {
     if (*cmd == 's' && vim_strchr("cgriI", cmd[1]) != NULL) {
-      ea.cmdidx = CMD_substitute;
+      eap->cmdidx = CMD_substitute;
       p = cmd + 1;
     } else if (cmd[0] >= 'A' && cmd[0] <= 'Z') {
-      ea.cmd = (char *)cmd;
-      p = (const char *)find_ucmd(&ea, (char *)p, NULL, xp, &context);
+      eap->cmd = (char *)cmd;
+      p = (const char *)find_ucmd(eap, (char *)p, NULL, xp, complp);
       if (p == NULL) {
-        ea.cmdidx = CMD_SIZE;  // Ambiguous user command.
+        eap->cmdidx = CMD_SIZE;  // Ambiguous user command.
       }
     }
   }
-  if (ea.cmdidx == CMD_SIZE) {
+  if (eap->cmdidx == CMD_SIZE) {
     // Not still touching the command and it was an illegal one
     xp->xp_context = EXPAND_UNSUCCESSFUL;
     return NULL;
   }
 
-  xp->xp_context = EXPAND_NOTHING;   // Default now that we're past command
-
-  if (*p == '!') {                  // forced commands
-    forceit = true;
-    p++;
-  }
-
-  // 5. parse arguments
-  if (!IS_USER_CMDIDX(ea.cmdidx)) {
-    ea.argt = excmd_get_argt(ea.cmdidx);
-  }
-
-  const char *arg = (const char *)skipwhite(p);
+  return p;
+}
 
-  // Skip over ++argopt argument
-  if ((ea.argt & EX_ARGOPT) && *arg != NUL && strncmp(arg, "++", 2) == 0) {
-    p = arg;
-    while (*p && !ascii_isspace(*p)) {
-      MB_PTR_ADV(p);
-    }
-    arg = (const char *)skipwhite(p);
-  }
+/// Set the completion context for a command argument with wild card characters.
+static void set_context_for_wildcard_arg(exarg_T *eap, const char *arg, bool usefilter,
+                                         expand_T *xp, int *complp)
+{
+  bool in_quote = false;
+  const char *bow = NULL;  // Beginning of word.
+  size_t len = 0;
 
-  if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update) {
-    if (*arg == '>') {  // Append.
-      if (*++arg == '>') {
-        arg++;
+  // Allow spaces within back-quotes to count as part of the argument
+  // being expanded.
+  xp->xp_pattern = skipwhite(arg);
+  const char *p = (const char *)xp->xp_pattern;
+  while (*p != NUL) {
+    int c = utf_ptr2char(p);
+    if (c == '\\' && p[1] != NUL) {
+      p++;
+    } else if (c == '`') {
+      if (!in_quote) {
+        xp->xp_pattern = (char *)p;
+        bow = p + 1;
       }
-      arg = (const char *)skipwhite(arg);
-    } else if (*arg == '!' && ea.cmdidx == CMD_write) {  // :w !filter
-      arg++;
-      usefilter = true;
-    }
-  }
-
-  if (ea.cmdidx == CMD_read) {
-    usefilter = forceit;                        // :r! filter if forced
-    if (*arg == '!') {                          // :r !filter
-      arg++;
-      usefilter = true;
-    }
-  }
-
-  if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift) {
-    while (*arg == *cmd) {  // allow any number of '>' or '<'
-      arg++;
-    }
-    arg = (const char *)skipwhite(arg);
-  }
-
-  // Does command allow "+command"?
-  if ((ea.argt & EX_CMDARG) && !usefilter && *arg == '+') {
-    // Check if we're in the +command
-    p = arg + 1;
-    arg = (const char *)skip_cmd_arg((char *)arg, false);
-
-    // Still touching the command after '+'?
-    if (*arg == NUL) {
-      return p;
-    }
-
-    // Skip space(s) after +command to get to the real argument.
-    arg = (const char *)skipwhite(arg);
-  }
-
-  // Check for '|' to separate commands and '"' to start comments.
-  // Don't do this for ":read !cmd" and ":write !cmd".
-  if ((ea.argt & EX_TRLBAR) && !usefilter) {
-    p = arg;
-    // ":redir @" is not the start of a comment
-    if (ea.cmdidx == CMD_redir && p[0] == '@' && p[1] == '"') {
-      p += 2;
-    }
-    while (*p) {
-      if (*p == Ctrl_V) {
-        if (p[1] != NUL) {
-          p++;
-        }
-      } else if ((*p == '"' && !(ea.argt & EX_NOTRLCOM))
-                 || *p == '|'
-                 || *p == '\n') {
-        if (*(p - 1) != '\\') {
-          if (*p == '|' || *p == '\n') {
-            return p + 1;
-          }
-          return NULL;              // It's a comment
+      in_quote = !in_quote;
+      // An argument can contain just about everything, except
+      // characters that end the command and white space.
+    } else if (c == '|' || c == '\n' || c == '"' || ascii_iswhite(c)) {
+      len = 0;  // avoid getting stuck when space is in 'isfname'
+      while (*p != NUL) {
+        c = utf_ptr2char(p);
+        if (c == '`' || vim_isfilec_or_wc(c)) {
+          break;
         }
+        len = (size_t)utfc_ptr2len(p);
+        MB_PTR_ADV(p);
       }
-      MB_PTR_ADV(p);
-    }
-  }
-
-  if (!(ea.argt & EX_EXTRA) && *arg != NUL && strchr("|\"", *arg) == NULL) {
-    // no arguments allowed but there is something
-    return NULL;
-  }
-
-  // Find start of last argument (argument just before cursor):
-  p = buff;
-  xp->xp_pattern = (char *)p;
-  len = strlen(buff);
-  while (*p && p < buff + len) {
-    if (*p == ' ' || *p == TAB) {
-      // Argument starts after a space.
-      xp->xp_pattern = (char *)++p;
-    } else {
-      if (*p == '\\' && *(p + 1) != NUL) {
-        p++;        // skip over escaped character
+      if (in_quote) {
+        bow = p;
+      } else {
+        xp->xp_pattern = (char *)p;
       }
-      MB_PTR_ADV(p);
+      p -= len;
     }
+    MB_PTR_ADV(p);
   }
 
-  if (ea.argt & EX_XFILE) {
-    int in_quote = false;
-    const char *bow = NULL;  // Beginning of word.
-
-    // Allow spaces within back-quotes to count as part of the argument
-    // being expanded.
-    xp->xp_pattern = skipwhite(arg);
-    p = (const char *)xp->xp_pattern;
-    while (*p != NUL) {
-      int c = utf_ptr2char(p);
-      if (c == '\\' && p[1] != NUL) {
-        p++;
-      } else if (c == '`') {
-        if (!in_quote) {
-          xp->xp_pattern = (char *)p;
-          bow = p + 1;
-        }
-        in_quote = !in_quote;
-        // An argument can contain just about everything, except
-        // characters that end the command and white space.
-      } else if (c == '|' || c == '\n' || c == '"' || ascii_iswhite(c)) {
-        len = 0;          // avoid getting stuck when space is in 'isfname'
-        while (*p != NUL) {
-          c = utf_ptr2char(p);
-          if (c == '`' || vim_isfilec_or_wc(c)) {
-            break;
-          }
-          len = (size_t)utfc_ptr2len(p);
-          MB_PTR_ADV(p);
-        }
-        if (in_quote) {
-          bow = p;
-        } else {
-          xp->xp_pattern = (char *)p;
-        }
-        p -= len;
-      }
-      MB_PTR_ADV(p);
-    }
-
-    // If we are still inside the quotes, and we passed a space, just
-    // expand from there.
-    if (bow != NULL && in_quote) {
-      xp->xp_pattern = (char *)bow;
-    }
-    xp->xp_context = EXPAND_FILES;
+  // If we are still inside the quotes, and we passed a space, just
+  // expand from there.
+  if (bow != NULL && in_quote) {
+    xp->xp_pattern = (char *)bow;
+  }
+  xp->xp_context = EXPAND_FILES;
 
-    // For a shell command more chars need to be escaped.
-    if (usefilter || ea.cmdidx == CMD_bang || ea.cmdidx == CMD_terminal) {
+  // For a shell command more chars need to be escaped.
+  if (usefilter || eap->cmdidx == CMD_bang || eap->cmdidx == CMD_terminal) {
 #ifndef BACKSLASH_IN_FILENAME
-      xp->xp_shell = true;
+    xp->xp_shell = true;
 #endif
-      // When still after the command name expand executables.
-      if (xp->xp_pattern == skipwhite(arg)) {
-        xp->xp_context = EXPAND_SHELLCMD;
-      }
+    // When still after the command name expand executables.
+    if (xp->xp_pattern == skipwhite(arg)) {
+      xp->xp_context = EXPAND_SHELLCMD;
     }
+  }
 
-    // Check for environment variable.
-    if (*xp->xp_pattern == '$') {
-      for (p = (const char *)xp->xp_pattern + 1; *p != NUL; p++) {
-        if (!vim_isIDc((uint8_t)(*p))) {
-          break;
-        }
-      }
-      if (*p == NUL) {
-        xp->xp_context = EXPAND_ENV_VARS;
-        xp->xp_pattern++;
-        // Avoid that the assignment uses EXPAND_FILES again.
-        if (context != EXPAND_USER_DEFINED && context != EXPAND_USER_LIST) {
-          context = EXPAND_ENV_VARS;
-        }
+  // Check for environment variable.
+  if (*xp->xp_pattern == '$') {
+    for (p = (const char *)xp->xp_pattern + 1; *p != NUL; p++) {
+      if (!vim_isIDc((uint8_t)(*p))) {
+        break;
       }
     }
-    // Check for user names.
-    if (*xp->xp_pattern == '~') {
-      for (p = (const char *)xp->xp_pattern + 1; *p != NUL && *p != '/'; p++) {}
-      // Complete ~user only if it partially matches a user name.
-      // A full match ~user<Tab> will be replaced by user's home
-      // directory i.e. something like ~user<Tab> -> /home/user/
-      if (*p == NUL && p > (const char *)xp->xp_pattern + 1
-          && match_user((char_u *)xp->xp_pattern + 1) >= 1) {
-        xp->xp_context = EXPAND_USER;
-        xp->xp_pattern++;
+    if (*p == NUL) {
+      xp->xp_context = EXPAND_ENV_VARS;
+      xp->xp_pattern++;
+      // Avoid that the assignment uses EXPAND_FILES again.
+      if (*complp != EXPAND_USER_DEFINED && *complp != EXPAND_USER_LIST) {
+        *complp = EXPAND_ENV_VARS;
       }
     }
   }
+  // Check for user names.
+  if (*xp->xp_pattern == '~') {
+    for (p = (const char *)xp->xp_pattern + 1; *p != NUL && *p != '/'; p++) {}
+    // Complete ~user only if it partially matches a user name.
+    // A full match ~user<Tab> will be replaced by user's home
+    // directory i.e. something like ~user<Tab> -> /home/user/
+    if (*p == NUL && p > (const char *)xp->xp_pattern + 1
+        && match_user((char_u *)xp->xp_pattern + 1) >= 1) {
+      xp->xp_context = EXPAND_USER;
+      xp->xp_pattern++;
+    }
+  }
+}
 
-  // 6. switch on command name
-  switch (ea.cmdidx) {
+/// Set the completion context in "xp" for command "cmd" with index "cmdidx".
+/// The argument to the command is "arg" and the argument flags is "argt".
+/// For user-defined commands and for environment variables, "context" has the
+/// completion type.
+///
+/// @return  a pointer to the next command, or NULL if there is no next command.
+static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, const char *arg,
+                                          uint32_t argt, int context, expand_T *xp, bool forceit)
+{
+  const char *p;
+
+  switch (cmdidx) {
   case CMD_find:
   case CMD_sfind:
   case CMD_tabfind:
@@ -1498,7 +1388,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_lexpr:
   case CMD_laddexpr:
   case CMD_lgetexpr:
-    set_context_for_expression(xp, (char *)arg, ea.cmdidx);
+    set_context_for_expression(xp, (char *)arg, cmdidx);
     break;
 
   case CMD_unlet:
@@ -1531,7 +1421,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_cscope:
   case CMD_lcscope:
   case CMD_scscope:
-    set_context_in_cscope_cmd(xp, arg, ea.cmdidx);
+    set_context_in_cscope_cmd(xp, arg, cmdidx);
     break;
   case CMD_sign:
     set_context_in_sign_cmd(xp, (char_u *)arg);
@@ -1561,7 +1451,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_USER_BUF:
     if (context != EXPAND_NOTHING) {
       // EX_XFILE: file names are handled above.
-      if (!(ea.argt & EX_XFILE)) {
+      if (!(argt & EX_XFILE)) {
         if (context == EXPAND_MENUS) {
           return (const char *)set_context_in_menu_cmd(xp, cmd, (char *)arg, forceit);
         } else if (context == EXPAND_COMMANDS) {
@@ -1607,7 +1497,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_xmap:
   case CMD_xnoremap:
     return (const char *)set_context_in_map_cmd(xp, (char *)cmd, (char_u *)arg, forceit, false,
-                                                false, ea.cmdidx);
+                                                false, cmdidx);
   case CMD_unmap:
   case CMD_nunmap:
   case CMD_vunmap:
@@ -1618,7 +1508,7 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_sunmap:
   case CMD_xunmap:
     return (const char *)set_context_in_map_cmd(xp, (char *)cmd, (char_u *)arg, forceit, false,
-                                                true, ea.cmdidx);
+                                                true, cmdidx);
   case CMD_mapclear:
   case CMD_nmapclear:
   case CMD_vmapclear:
@@ -1639,12 +1529,12 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   case CMD_iabbrev:
   case CMD_inoreabbrev:
     return (const char *)set_context_in_map_cmd(xp, (char *)cmd, (char_u *)arg, forceit, true,
-                                                false, ea.cmdidx);
+                                                false, cmdidx);
   case CMD_unabbreviate:
   case CMD_cunabbrev:
   case CMD_iunabbrev:
     return (const char *)set_context_in_map_cmd(xp, (char *)cmd, (char_u *)arg, forceit, true,
-                                                true, ea.cmdidx);
+                                                true, cmdidx);
   case CMD_menu:
   case CMD_noremenu:
   case CMD_unmenu:
@@ -1763,6 +1653,182 @@ static const char *set_one_cmd_context(expand_T *xp, const char *buff)
   return NULL;
 }
 
+/// This is all pretty much copied from do_one_cmd(), with all the extra stuff
+/// we don't need/want deleted.  Maybe this could be done better if we didn't
+/// repeat all this stuff.  The only problem is that they may not stay
+/// perfectly compatible with each other, but then the command line syntax
+/// probably won't change that much -- webb.
+///
+/// @param buff  buffer for command string
+static const char *set_one_cmd_context(expand_T *xp, const char *buff)
+{
+  size_t len = 0;
+  exarg_T ea;
+  int context = EXPAND_NOTHING;
+  bool forceit = false;
+  bool usefilter = false;  // Filter instead of file name.
+
+  ExpandInit(xp);
+  xp->xp_pattern = (char *)buff;
+  xp->xp_line = (char *)buff;
+  xp->xp_context = EXPAND_COMMANDS;  // Default until we get past command
+  ea.argt = 0;
+
+  // 1. skip comment lines and leading space, colons or bars
+  const char *cmd;
+  for (cmd = buff; vim_strchr(" \t:|", *cmd) != NULL; cmd++) {}
+  xp->xp_pattern = (char *)cmd;
+
+  if (*cmd == NUL) {
+    return NULL;
+  }
+  if (*cmd == '"') {  // ignore comment lines
+    xp->xp_context = EXPAND_NOTHING;
+    return NULL;
+  }
+
+  // 3. skip over a range specifier of the form: addr [,addr] [;addr] ..
+  cmd = (const char *)skip_range(cmd, &xp->xp_context);
+  xp->xp_pattern = (char *)cmd;
+  if (*cmd == NUL) {
+    return NULL;
+  }
+  if (*cmd == '"') {
+    xp->xp_context = EXPAND_NOTHING;
+    return NULL;
+  }
+
+  if (*cmd == '|' || *cmd == '\n') {
+    return cmd + 1;  // There's another command
+  }
+
+  // Get the command index.
+  const char *p = set_cmd_index(cmd, &ea, xp, &context);
+  if (p == NULL) {
+    return NULL;
+  }
+
+  xp->xp_context = EXPAND_NOTHING;  // Default now that we're past command
+
+  if (*p == '!') {  // forced commands
+    forceit = true;
+    p++;
+  }
+
+  // 6. parse arguments
+  if (!IS_USER_CMDIDX(ea.cmdidx)) {
+    ea.argt = excmd_get_argt(ea.cmdidx);
+  }
+
+  const char *arg = (const char *)skipwhite(p);
+
+  // Skip over ++argopt argument
+  if ((ea.argt & EX_ARGOPT) && *arg != NUL && strncmp(arg, "++", 2) == 0) {
+    p = arg;
+    while (*p && !ascii_isspace(*p)) {
+      MB_PTR_ADV(p);
+    }
+    arg = (const char *)skipwhite(p);
+  }
+
+  if (ea.cmdidx == CMD_write || ea.cmdidx == CMD_update) {
+    if (*arg == '>') {  // append
+      if (*++arg == '>') {
+        arg++;
+      }
+      arg = (const char *)skipwhite(arg);
+    } else if (*arg == '!' && ea.cmdidx == CMD_write) {  // :w !filter
+      arg++;
+      usefilter = true;
+    }
+  }
+
+  if (ea.cmdidx == CMD_read) {
+    usefilter = forceit;  // :r! filter if forced
+    if (*arg == '!') {    // :r !filter
+      arg++;
+      usefilter = true;
+    }
+  }
+
+  if (ea.cmdidx == CMD_lshift || ea.cmdidx == CMD_rshift) {
+    while (*arg == *cmd) {  // allow any number of '>' or '<'
+      arg++;
+    }
+    arg = (const char *)skipwhite(arg);
+  }
+
+  // Does command allow "+command"?
+  if ((ea.argt & EX_CMDARG) && !usefilter && *arg == '+') {
+    // Check if we're in the +command
+    p = arg + 1;
+    arg = (const char *)skip_cmd_arg((char *)arg, false);
+
+    // Still touching the command after '+'?
+    if (*arg == NUL) {
+      return p;
+    }
+
+    // Skip space(s) after +command to get to the real argument.
+    arg = (const char *)skipwhite(arg);
+  }
+
+  // Check for '|' to separate commands and '"' to start comments.
+  // Don't do this for ":read !cmd" and ":write !cmd".
+  if ((ea.argt & EX_TRLBAR) && !usefilter) {
+    p = arg;
+    // ":redir @" is not the start of a comment
+    if (ea.cmdidx == CMD_redir && p[0] == '@' && p[1] == '"') {
+      p += 2;
+    }
+    while (*p) {
+      if (*p == Ctrl_V) {
+        if (p[1] != NUL) {
+          p++;
+        }
+      } else if ((*p == '"' && !(ea.argt & EX_NOTRLCOM))
+                 || *p == '|'
+                 || *p == '\n') {
+        if (*(p - 1) != '\\') {
+          if (*p == '|' || *p == '\n') {
+            return p + 1;
+          }
+          return NULL;  // It's a comment
+        }
+      }
+      MB_PTR_ADV(p);
+    }
+  }
+
+  if (!(ea.argt & EX_EXTRA) && *arg != NUL && strchr("|\"", *arg) == NULL) {
+    // no arguments allowed but there is something
+    return NULL;
+  }
+
+  // Find start of last argument (argument just before cursor):
+  p = buff;
+  xp->xp_pattern = (char *)p;
+  len = strlen(buff);
+  while (*p && p < buff + len) {
+    if (*p == ' ' || *p == TAB) {
+      // argument starts after a space
+      xp->xp_pattern = (char *)++p;
+    } else {
+      if (*p == '\\' && *(p + 1) != NUL) {
+        p++;  // skip over escaped character
+      }
+      MB_PTR_ADV(p);
+    }
+  }
+
+  if (ea.argt & EX_XFILE) {
+    set_context_for_wildcard_arg(&ea, arg, usefilter, xp, &context);
+  }
+
+  // Switch on command name.
+  return set_context_by_cmdname(cmd, ea.cmdidx, arg, ea.argt, context, xp, forceit);
+}
+
 /// @param str  start of command line
 /// @param len  length of command line (excl. NUL)
 /// @param col  position of cursor
@@ -1848,6 +1914,66 @@ int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***
   return EXPAND_OK;
 }
 
+/// Expand file or directory names.
+static int expand_files_and_dirs(expand_T *xp, char_u *pat, char ***file, int *num_file, int flags,
+                                 int options)
+{
+  bool free_pat = false;
+
+  // for ":set path=" and ":set tags=" halve backslashes for escaped space
+  if (xp->xp_backslash != XP_BS_NONE) {
+    free_pat = true;
+    pat = vim_strsave(pat);
+    for (int i = 0; pat[i]; i++) {
+      if (pat[i] == '\\') {
+        if (xp->xp_backslash == XP_BS_THREE
+            && pat[i + 1] == '\\'
+            && pat[i + 2] == '\\'
+            && pat[i + 3] == ' ') {
+          STRMOVE(pat + i, pat + i + 3);
+        }
+        if (xp->xp_backslash == XP_BS_ONE
+            && pat[i + 1] == ' ') {
+          STRMOVE(pat + i, pat + i + 1);
+        }
+      }
+    }
+  }
+
+  if (xp->xp_context == EXPAND_FILES) {
+    flags |= EW_FILE;
+  } else if (xp->xp_context == EXPAND_FILES_IN_PATH) {
+    flags |= (EW_FILE | EW_PATH);
+  } else {
+    flags = (flags | EW_DIR) & ~EW_FILE;
+  }
+  if (options & WILD_ICASE) {
+    flags |= EW_ICASE;
+  }
+
+  // Expand wildcards, supporting %:h and the like.
+  int ret = expand_wildcards_eval(&pat, num_file, file, flags);
+  if (free_pat) {
+    xfree(pat);
+  }
+#ifdef BACKSLASH_IN_FILENAME
+  if (p_csl[0] != NUL && (options & WILD_IGNORE_COMPLETESLASH) == 0) {
+    for (int j = 0; j < *num_file; j++) {
+      char *ptr = (*file)[j];
+      while (*ptr != NUL) {
+        if (p_csl[0] == 's' && *ptr == '\\') {
+          *ptr = '/';
+        } else if (p_csl[0] == 'b' && *ptr == '/') {
+          *ptr = '\\';
+        }
+        ptr += utfc_ptr2len(ptr);
+      }
+    }
+  }
+#endif
+  return ret;
+}
+
 /// Function given to ExpandGeneric() to obtain the possible arguments of the
 /// ":behave {mswin,xterm}" command.
 static char *get_behave_arg(expand_T *xp FUNC_ATTR_UNUSED, int idx)
@@ -1905,6 +2031,67 @@ static char *get_healthcheck_names(expand_T *xp FUNC_ATTR_UNUSED, int idx)
   return NULL;
 }
 
+/// Do the expansion based on xp->xp_context and "rmp".
+static int ExpandOther(expand_T *xp, regmatch_T *rmp, int *num_file, char ***file)
+{
+  typedef CompleteListItemGetter ExpandFunc;
+  static struct expgen {
+    int context;
+    ExpandFunc func;
+    int ic;
+    int escaped;
+  } tab[] = {
+    { EXPAND_COMMANDS, get_command_name, false, true },
+    { EXPAND_BEHAVE, get_behave_arg, true, true },
+    { EXPAND_MAPCLEAR, get_mapclear_arg, true, true },
+    { EXPAND_MESSAGES, get_messages_arg, true, true },
+    { EXPAND_HISTORY, get_history_arg, true, true },
+    { EXPAND_USER_COMMANDS, get_user_commands, false, true },
+    { EXPAND_USER_ADDR_TYPE, get_user_cmd_addr_type, false, true },
+    { EXPAND_USER_CMD_FLAGS, get_user_cmd_flags, false, true },
+    { EXPAND_USER_NARGS, get_user_cmd_nargs, false, true },
+    { EXPAND_USER_COMPLETE, get_user_cmd_complete, false, true },
+    { EXPAND_USER_VARS, get_user_var_name, false, true },
+    { EXPAND_FUNCTIONS, get_function_name, false, true },
+    { EXPAND_USER_FUNC, get_user_func_name, false, true },
+    { EXPAND_EXPRESSION, get_expr_name, false, true },
+    { EXPAND_MENUS, get_menu_name, false, true },
+    { EXPAND_MENUNAMES, get_menu_names, false, true },
+    { EXPAND_SYNTAX, get_syntax_name, true, true },
+    { EXPAND_SYNTIME, get_syntime_arg, true, true },
+    { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, true },
+    { EXPAND_EVENTS, expand_get_event_name, true, false },
+    { EXPAND_AUGROUP, expand_get_augroup_name, true, false },
+    { EXPAND_CSCOPE, get_cscope_name, true, true },
+    { EXPAND_SIGN, get_sign_name, true, true },
+    { EXPAND_PROFILE, get_profile_name, true, true },
+#ifdef HAVE_WORKING_LIBINTL
+    { EXPAND_LANGUAGE, get_lang_arg, true, false },
+    { EXPAND_LOCALES, get_locales, true, false },
+#endif
+    { EXPAND_ENV_VARS, get_env_name, true, true },
+    { EXPAND_USER, get_users, true, false },
+    { EXPAND_ARGLIST, get_arglist_name, true, false },
+    { EXPAND_CHECKHEALTH, get_healthcheck_names, true, false },
+  };
+  int ret = FAIL;
+
+  // Find a context in the table and call the ExpandGeneric() with the
+  // right function to do the expansion.
+  for (int i = 0; i < (int)ARRAY_SIZE(tab); i++) {
+    if (xp->xp_context == tab[i].context) {
+      if (tab[i].ic) {
+        rmp->rm_ic = true;
+      }
+      ExpandGeneric(xp, rmp, num_file, file, tab[i].func, tab[i].escaped);
+      ret = OK;
+      break;
+    }
+  }
+
+  return ret;
+}
+
 /// Do the expansion based on xp->xp_context and "pat".
 ///
 /// @param options  WILD_ flags
@@ -1937,61 +2124,7 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
   if (xp->xp_context == EXPAND_FILES
       || xp->xp_context == EXPAND_DIRECTORIES
       || xp->xp_context == EXPAND_FILES_IN_PATH) {
-    // Expand file or directory names.
-    bool free_pat = false;
-
-    // for ":set path=" and ":set tags=" halve backslashes for escaped space
-    if (xp->xp_backslash != XP_BS_NONE) {
-      free_pat = true;
-      pat = vim_strsave(pat);
-      for (int i = 0; pat[i]; i++) {
-        if (pat[i] == '\\') {
-          if (xp->xp_backslash == XP_BS_THREE
-              && pat[i + 1] == '\\'
-              && pat[i + 2] == '\\'
-              && pat[i + 3] == ' ') {
-            STRMOVE(pat + i, pat + i + 3);
-          }
-          if (xp->xp_backslash == XP_BS_ONE
-              && pat[i + 1] == ' ') {
-            STRMOVE(pat + i, pat + i + 1);
-          }
-        }
-      }
-    }
-
-    if (xp->xp_context == EXPAND_FILES) {
-      flags |= EW_FILE;
-    } else if (xp->xp_context == EXPAND_FILES_IN_PATH) {
-      flags |= (EW_FILE | EW_PATH);
-    } else {
-      flags = (flags | EW_DIR) & ~EW_FILE;
-    }
-    if (options & WILD_ICASE) {
-      flags |= EW_ICASE;
-    }
-
-    // Expand wildcards, supporting %:h and the like.
-    ret = expand_wildcards_eval(&pat, num_file, file, flags);
-    if (free_pat) {
-      xfree(pat);
-    }
-#ifdef BACKSLASH_IN_FILENAME
-    if (p_csl[0] != NUL && (options & WILD_IGNORE_COMPLETESLASH) == 0) {
-      for (int j = 0; j < *num_file; j++) {
-        char_u *ptr = (*file)[j];
-        while (*ptr != NUL) {
-          if (p_csl[0] == 's' && *ptr == '\\') {
-            *ptr = '/';
-          } else if (p_csl[0] == 'b' && *ptr == '/') {
-            *ptr = '\\';
-          }
-          ptr += utfc_ptr2len(ptr);
-        }
-      }
-    }
-#endif
-    return ret;
+    return expand_files_and_dirs(xp, pat, file, num_file, flags, options);
   }
 
   *file = NULL;
@@ -2084,60 +2217,7 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
   } else if (xp->xp_context == EXPAND_USER_DEFINED) {
     ret = ExpandUserDefined(xp, &regmatch, num_file, file);
   } else {
-    typedef CompleteListItemGetter ExpandFunc;
-    static struct expgen {
-      int context;
-      ExpandFunc func;
-      int ic;
-      int escaped;
-    } tab[] = {
-      { EXPAND_COMMANDS, get_command_name, false, true },
-      { EXPAND_BEHAVE, get_behave_arg, true, true },
-      { EXPAND_MAPCLEAR, get_mapclear_arg, true, true },
-      { EXPAND_MESSAGES, get_messages_arg, true, true },
-      { EXPAND_HISTORY, get_history_arg, true, true },
-      { EXPAND_USER_COMMANDS, get_user_commands, false, true },
-      { EXPAND_USER_ADDR_TYPE, get_user_cmd_addr_type, false, true },
-      { EXPAND_USER_CMD_FLAGS, get_user_cmd_flags, false, true },
-      { EXPAND_USER_NARGS, get_user_cmd_nargs, false, true },
-      { EXPAND_USER_COMPLETE, get_user_cmd_complete, false, true },
-      { EXPAND_USER_VARS, get_user_var_name, false, true },
-      { EXPAND_FUNCTIONS, get_function_name, false, true },
-      { EXPAND_USER_FUNC, get_user_func_name, false, true },
-      { EXPAND_EXPRESSION, get_expr_name, false, true },
-      { EXPAND_MENUS, get_menu_name, false, true },
-      { EXPAND_MENUNAMES, get_menu_names, false, true },
-      { EXPAND_SYNTAX, get_syntax_name, true, true },
-      { EXPAND_SYNTIME, get_syntime_arg, true, true },
-      { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, true },
-      { EXPAND_EVENTS, expand_get_event_name, true, false },
-      { EXPAND_AUGROUP, expand_get_augroup_name, true, false },
-      { EXPAND_CSCOPE, get_cscope_name, true, true },
-      { EXPAND_SIGN, get_sign_name, true, true },
-      { EXPAND_PROFILE, get_profile_name, true, true },
-#ifdef HAVE_WORKING_LIBINTL
-      { EXPAND_LANGUAGE, get_lang_arg, true, false },
-      { EXPAND_LOCALES, get_locales, true, false },
-#endif
-      { EXPAND_ENV_VARS, get_env_name, true, true },
-      { EXPAND_USER, get_users, true, false },
-      { EXPAND_ARGLIST, get_arglist_name, true, false },
-      { EXPAND_CHECKHEALTH, get_healthcheck_names, true, false },
-    };
-
-    // Find a context in the table and call the ExpandGeneric() with the
-    // right function to do the expansion.
-    ret = FAIL;
-    for (int i = 0; i < (int)ARRAY_SIZE(tab); i++) {
-      if (xp->xp_context == tab[i].context) {
-        if (tab[i].ic) {
-          regmatch.rm_ic = true;
-        }
-        ExpandGeneric(xp, &regmatch, num_file, file, tab[i].func, tab[i].escaped);
-        ret = OK;
-        break;
-      }
-    }
+    ret = ExpandOther(xp, &regmatch, num_file, file);
   }
 
   vim_regfree(regmatch.regprog);
-- 
cgit 


From 93f24403f8cc760ff47979c596976b53a8b16358 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Wed, 24 Aug 2022 22:49:25 +0100
Subject: refactor: pre-incr to post-incr

---
 src/nvim/edit.c          | 20 +++++------
 src/nvim/eval/userfunc.c | 10 +++---
 src/nvim/ex_cmds.c       | 10 +++---
 src/nvim/ex_eval.c       | 22 ++++++------
 src/nvim/ex_getln.c      |  4 +--
 src/nvim/file_search.c   |  4 +--
 src/nvim/fileio.c        | 16 ++++-----
 src/nvim/garray.c        |  2 +-
 src/nvim/getchar.c       |  6 ++--
 src/nvim/hardcopy.c      | 20 +++++------
 src/nvim/hashtab.c       |  4 +--
 src/nvim/if_cscope.c     |  4 +--
 src/nvim/indent_c.c      | 12 +++----
 src/nvim/main.c          |  2 +-
 src/nvim/mark.c          | 20 +++++------
 src/nvim/mbyte.c         | 18 +++++-----
 src/nvim/memline.c       | 36 +++++++++----------
 src/nvim/menu.c          |  8 ++---
 src/nvim/message.c       |  9 +++--
 src/nvim/mouse.c         |  2 +-
 src/nvim/move.c          | 40 ++++++++++-----------
 src/nvim/ops.c           | 50 +++++++++++++-------------
 src/nvim/path.c          |  4 +--
 src/nvim/quickfix.c      |  8 ++---
 src/nvim/regexp_bt.c     |  2 +-
 src/nvim/screen.c        |  2 +-
 src/nvim/search.c        | 32 ++++++++---------
 src/nvim/spellfile.c     | 93 ++++++++++++++++++++++++------------------------
 src/nvim/spellsuggest.c  |  2 +-
 src/nvim/strings.c       | 10 +++---
 src/nvim/syntax.c        | 56 ++++++++++++++---------------
 src/nvim/tag.c           |  8 ++---
 src/nvim/undo.c          |  2 +-
 src/nvim/version.c       |  2 +-
 src/nvim/window.c        | 24 ++++++-------
 35 files changed, 278 insertions(+), 286 deletions(-)

(limited to 'src')

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 81a67b86c3..79317d3df6 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -452,7 +452,7 @@ static int insert_check(VimState *state)
         && (curwin->w_cursor.lnum != curwin->w_topline
             || curwin->w_topfill > 0)) {
       if (curwin->w_topfill > 0) {
-        --curwin->w_topfill;
+        curwin->w_topfill--;
       } else if (hasFolding(curwin->w_topline, NULL, &s->old_topline)) {
         set_topline(curwin, s->old_topline + 1);
       } else {
@@ -2692,7 +2692,7 @@ void auto_format(bool trailblank, bool prev_line)
    * the start of a paragraph.
    */
   if (prev_line && !paragraph_start(curwin->w_cursor.lnum)) {
-    --curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum--;
     if (u_save_cursor() == FAIL) {
       return;
     }
@@ -2993,7 +2993,7 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
       check_cursor_col();        // make sure it is not past the line
       for (;;) {
         if (gchar_cursor() == NUL && curwin->w_cursor.col > 0) {
-          --curwin->w_cursor.col;
+          curwin->w_cursor.col--;
         }
         cc = gchar_cursor();
         if (!ascii_iswhite(cc)) {
@@ -3010,7 +3010,7 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
         tpos = curwin->w_cursor;
         tpos.col++;
         if (cc != NUL && gchar_pos(&tpos) == NUL) {
-          ++curwin->w_cursor.col;         // put cursor back on the NUL
+          curwin->w_cursor.col++;         // put cursor back on the NUL
         }
       }
 
@@ -3082,8 +3082,8 @@ void beginline(int flags)
       char_u *ptr;
 
       for (ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr)
-           && !((flags & BL_FIX) && ptr[1] == NUL); ++ptr) {
-        ++curwin->w_cursor.col;
+           && !((flags & BL_FIX) && ptr[1] == NUL); ptr++) {
+        curwin->w_cursor.col++;
       }
     }
     curwin->w_set_curswant = TRUE;
@@ -3173,8 +3173,8 @@ int oneleft(void)
     return FAIL;
   }
 
-  curwin->w_set_curswant = TRUE;
-  --curwin->w_cursor.col;
+  curwin->w_set_curswant = true;
+  curwin->w_cursor.col--;
 
   // if the character on the left of the current cursor is a multi-byte
   // character, move to its first byte
@@ -3454,7 +3454,7 @@ int replace_push_mb(char_u *p)
   int l = utfc_ptr2len((char *)p);
   int j;
 
-  for (j = l - 1; j >= 0; --j) {
+  for (j = l - 1; j >= 0; j--) {
     replace_push(p[j]);
   }
   return l;
@@ -4271,7 +4271,7 @@ static void ins_ctrl_(void)
 {
   if (revins_on && revins_chars && revins_scol >= 0) {
     while (gchar_cursor() != NUL && revins_chars--) {
-      ++curwin->w_cursor.col;
+      curwin->w_cursor.col++;
     }
   }
   p_ri = !p_ri;
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 2542a5aeb0..bb2e2b19c2 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -852,7 +852,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
     saveRedobuff(&save_redo);
     did_save_redo = true;
   }
-  ++fp->uf_calls;
+  fp->uf_calls++;
   // check for CTRL-C hit
   line_breakcheck();
   // prepare the funccall_T structure
@@ -893,7 +893,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
     v->di_tv.v_type = VAR_DICT;
     v->di_tv.v_lock = VAR_UNLOCKED;
     v->di_tv.vval.v_dict = selfdict;
-    ++selfdict->dv_refcount;
+    selfdict->dv_refcount++;
   }
 
   // Init a: variables, unless none found (in lambda).
@@ -1071,7 +1071,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
         || (fc->caller != NULL && fc->caller->func->uf_profiling));
 
   if (func_or_func_caller_profiling) {
-    ++fp->uf_tm_count;
+    fp->uf_tm_count++;
     call_start = profile_start();
     fp->uf_tm_children = profile_zero();
   }
@@ -1929,7 +1929,7 @@ void ex_function(exarg_T *eap)
   if (ends_excmd(*eap->arg)) {
     if (!eap->skip) {
       todo = (int)func_hashtab.ht_used;
-      for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) {
+      for (hi = func_hashtab.ht_array; todo > 0 && !got_int; hi++) {
         if (!HASHITEM_EMPTY(hi)) {
           todo--;
           fp = HI2UF(hi);
@@ -1962,7 +1962,7 @@ void ex_function(exarg_T *eap)
         regmatch.rm_ic = p_ic;
 
         todo = (int)func_hashtab.ht_used;
-        for (hi = func_hashtab.ht_array; todo > 0 && !got_int; ++hi) {
+        for (hi = func_hashtab.ht_array; todo > 0 && !got_int; hi++) {
           if (!HASHITEM_EMPTY(hi)) {
             todo--;
             fp = HI2UF(hi);
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index b4e8c6de7b..e08e977ff5 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -678,7 +678,7 @@ void ex_sort(exarg_T *eap)
 
   // delete the original lines if appending worked
   if (i == count) {
-    for (i = 0; i < count; ++i) {
+    for (i = 0; i < count; i++) {
       ml_delete(eap->line1, false);
     }
   } else {
@@ -1103,7 +1103,7 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
     if (curwin->w_cursor.lnum < line2) {
       line2++;
     }
-    ++curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum++;
   }
 
   appended_lines_mark(n, count);
@@ -2601,7 +2601,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
 
           curwin->w_buffer = buf;
           curbuf = buf;
-          ++curbuf->b_nwindows;
+          curbuf->b_nwindows++;
 
           // Set 'fileformat', 'binary' and 'fenc' when forced.
           if (!oldbuf && eap != NULL) {
@@ -3018,7 +3018,7 @@ void ex_append(exarg_T *eap)
 
     // Look for the "." after automatic indent.
     vcol = 0;
-    for (p = theline; indent > vcol; ++p) {
+    for (p = theline; indent > vcol; p++) {
       if (*p == ' ') {
         vcol++;
       } else if (*p == TAB) {
@@ -3098,7 +3098,7 @@ void ex_change(exarg_T *eap)
     append_indent = get_indent_lnum(eap->line1);
   }
 
-  for (lnum = eap->line2; lnum >= eap->line1; --lnum) {
+  for (lnum = eap->line2; lnum >= eap->line1; lnum--) {
     if (curbuf->b_ml.ml_flags & ML_EMPTY) {         // nothing to delete
       break;
     }
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 82d6e66290..5ddcb0270b 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -830,7 +830,7 @@ void ex_if(exarg_T *eap)
   if (cstack->cs_idx == CSTACK_LEN - 1) {
     eap->errmsg = _("E579: :if nesting too deep");
   } else {
-    ++cstack->cs_idx;
+    cstack->cs_idx++;
     cstack->cs_flags[cstack->cs_idx] = 0;
 
     skip = CHECK_SKIP;
@@ -870,7 +870,7 @@ void ex_endif(exarg_T *eap)
       (void)do_intthrow(eap->cstack);
     }
 
-    --eap->cstack->cs_idx;
+    eap->cstack->cs_idx--;
   }
 }
 
@@ -964,8 +964,8 @@ void ex_while(exarg_T *eap)
      * cstack entry.
      */
     if ((cstack->cs_lflags & CSL_HAD_LOOP) == 0) {
-      ++cstack->cs_idx;
-      ++cstack->cs_looplevel;
+      cstack->cs_idx++;
+      cstack->cs_looplevel++;
       cstack->cs_line[cstack->cs_idx] = -1;
     }
     cstack->cs_flags[cstack->cs_idx] =
@@ -1118,7 +1118,7 @@ void ex_endwhile(exarg_T *eap)
         eap->errmsg = _(e_endtry);
       }
       // Try to find the matching ":while" and report what's missing.
-      for (idx = cstack->cs_idx; idx > 0; --idx) {
+      for (idx = cstack->cs_idx; idx > 0; idx--) {
         fl =  cstack->cs_flags[idx];
         if ((fl & CSF_TRY) && !(fl & CSF_FINALLY)) {
           // Give up at a try conditional not in its finally clause.
@@ -1248,8 +1248,8 @@ void ex_try(exarg_T *eap)
   if (cstack->cs_idx == CSTACK_LEN - 1) {
     eap->errmsg = _("E601: :try nesting too deep");
   } else {
-    ++cstack->cs_idx;
-    ++cstack->cs_trylevel;
+    cstack->cs_idx++;
+    cstack->cs_trylevel++;
     cstack->cs_flags[cstack->cs_idx] = CSF_TRY;
     cstack->cs_pending[cstack->cs_idx] = CSTP_NONE;
 
@@ -1314,7 +1314,7 @@ void ex_catch(exarg_T *eap)
       eap->errmsg = get_end_emsg(cstack);
       skip = true;
     }
-    for (idx = cstack->cs_idx; idx > 0; --idx) {
+    for (idx = cstack->cs_idx; idx > 0; idx--) {
       if (cstack->cs_flags[idx] & CSF_TRY) {
         break;
       }
@@ -1456,7 +1456,7 @@ void ex_finally(exarg_T *eap)
   } else {
     if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
       eap->errmsg = get_end_emsg(cstack);
-      for (idx = cstack->cs_idx - 1; idx > 0; --idx) {
+      for (idx = cstack->cs_idx - 1; idx > 0; idx--) {
         if (cstack->cs_flags[idx] & CSF_TRY) {
           break;
         }
@@ -1906,7 +1906,7 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
   int idx;
   int stop = FALSE;
 
-  for (idx = cstack->cs_idx; idx >= 0; --idx) {
+  for (idx = cstack->cs_idx; idx >= 0; idx--) {
     if (cstack->cs_flags[idx] & CSF_TRY) {
       /*
        * Discard anything pending in a finally clause and continue the
@@ -2036,7 +2036,7 @@ void rewind_conditionals(cstack_T *cstack, int idx, int cond_type, int *cond_lev
     if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR) {
       free_for_info(cstack->cs_forinfo[cstack->cs_idx]);
     }
-    --cstack->cs_idx;
+    cstack->cs_idx--;
   }
 }
 
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 43ea3e302b..afec21a86f 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1260,7 +1260,7 @@ static int command_line_execute(VimState *state, int key)
     }
 
     if (s->wim_index < 3) {
-      ++s->wim_index;
+      s->wim_index++;
     }
 
     if (s->c == ESC) {
@@ -1477,7 +1477,7 @@ static int command_line_handle_key(CommandLineState *s)
     // delete current character is the same as backspace on next
     // character, except at end of line
     if (s->c == K_DEL && ccline.cmdpos != ccline.cmdlen) {
-      ++ccline.cmdpos;
+      ccline.cmdpos++;
     }
 
     if (s->c == K_DEL) {
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 2d09e7aa71..53f87d0e42 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -1429,7 +1429,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
     ff_file_to_find = vim_strsave(NameBuff);
     if (options & FNAME_UNESC) {
       // Change all "\ " to " ".
-      for (ptr = ff_file_to_find; *ptr != NUL; ++ptr) {
+      for (ptr = ff_file_to_find; *ptr != NUL; ptr++) {
         if (ptr[0] == '\\' && ptr[1] == ' ') {
           memmove(ptr, ptr + 1, STRLEN(ptr));
         }
@@ -1466,7 +1466,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
 
       /* When FNAME_REL flag given first use the directory of the file.
        * Otherwise or when this fails use the current directory. */
-      for (int run = 1; run <= 2; ++run) {
+      for (int run = 1; run <= 2; run++) {
         size_t l = STRLEN(ff_file_to_find);
         if (run == 1
             && rel_to_curdir
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index a21fc9e9d4..39bf1b3670 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -583,7 +583,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     return FAIL;
   }
 
-  ++no_wait_return;         // don't wait for return yet
+  no_wait_return++;         // don't wait for return yet
 
   // Set '[ mark to the line above where the lines go (line 1 if zero).
   orig_start = curbuf->b_op_start;
@@ -1011,7 +1011,7 @@ retry:
                 // Change NL to NUL to reverse the effect done
                 // below.
                 n = (int)(size - tlen);
-                for (ni = 0; ni < n; ++ni) {
+                for (ni = 0; ni < n; ni++) {
                   if (p[ni] == NL) {
                     ptr[tlen++] = NUL;
                   } else {
@@ -1729,7 +1729,7 @@ failed:
     os_remove(tmpname);  // delete converted file
     xfree(tmpname);
   }
-  --no_wait_return;                     // may wait for return now
+  no_wait_return--;                     // may wait for return now
 
   /*
    * In recovery mode everything but autocommands is skipped.
@@ -1999,7 +1999,7 @@ static linenr_T readfile_linenr(linenr_T linecnt, char_u *p, char_u *endp)
   linenr_T lnum;
 
   lnum = curbuf->b_ml.ml_line_count - linecnt + 1;
-  for (s = p; s < endp; ++s) {
+  for (s = p; s < endp; s++) {
     if (*s == '\n') {
       lnum++;
     }
@@ -2317,7 +2317,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     overwriting = FALSE;
   }
 
-  ++no_wait_return;                 // don't wait for return yet
+  no_wait_return++;                 // don't wait for return yet
 
   /*
    * Set '[ and '] marks to the lines to be written.
@@ -3485,7 +3485,7 @@ restore_backup:
   }
 
   lnum -= start;            // compute number of written lines
-  --no_wait_return;         // may wait for return now
+  no_wait_return--;         // may wait for return now
 
 #if !defined(UNIX)
   fname = sfname;           // use shortname now, for the messages
@@ -3624,7 +3624,7 @@ restore_backup:
    * Finish up.  We get here either after failure or success.
    */
 fail:
-  --no_wait_return;             // may wait for return now
+  no_wait_return--;             // may wait for return now
 nofail:
 
   // Done saving, we accept changed buffer warnings again
@@ -3998,7 +3998,7 @@ static int buf_write_bytes(struct bw_info *ip)
           ip->bw_conv_error_lnum = ip->bw_start_lnum;
         }
         if (c == NL) {
-          ++ip->bw_start_lnum;
+          ip->bw_start_lnum++;
         }
       }
       if (flags & FIO_LATIN1) {
diff --git a/src/nvim/garray.c b/src/nvim/garray.c
index 7a3c14b1bb..1afabe4e10 100644
--- a/src/nvim/garray.c
+++ b/src/nvim/garray.c
@@ -131,7 +131,7 @@ void ga_remove_duplicate_strings(garray_T *gap)
         fnames[j - 1] = fnames[j];
       }
 
-      --gap->ga_len;
+      gap->ga_len--;
     }
   }
 }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 36ca31783e..1f4d28bcd3 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -932,7 +932,7 @@ int ins_typebuf(char *str, int noremap, int offset, bool nottyped, bool silent)
   } else {
     nrm = noremap;
   }
-  for (i = 0; i < addlen; ++i) {
+  for (i = 0; i < addlen; i++) {
     typebuf.tb_noremap[typebuf.tb_off + i + offset] =
       (char_u)((--nrm >= 0) ? val : RM_YES);
   }
@@ -2563,7 +2563,7 @@ static int vgetorpeek(bool advance)
                 curwin->w_wcol += curwin_col_off();
                 col = 0;  // no correction needed
               } else {
-                --curwin->w_wcol;
+                curwin->w_wcol--;
                 col = curwin->w_cursor.col - 1;
               }
             } else if (curwin->w_p_wrap && curwin->w_wrow) {
@@ -2929,7 +2929,7 @@ int fix_input_buffer(char_u *buf, int len)
   // Two characters are special: NUL and K_SPECIAL.
   // Replace       NUL by K_SPECIAL KS_ZERO    KE_FILLER
   // Replace K_SPECIAL by K_SPECIAL KS_SPECIAL KE_FILLER
-  for (i = len; --i >= 0; ++p) {
+  for (i = len; --i >= 0; p++) {
     if (p[0] == NUL
         || (p[0] == K_SPECIAL
             && (i < 2 || p[1] != KS_EXTRA))) {
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index e8410d1ee7..6f45b4a03d 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -324,7 +324,7 @@ static char *parse_list_options(char_u *option_str, option_table_T *table, size_
 
     len = (int)(colonp - stringp);
 
-    for (idx = 0; idx < table_size; ++idx) {
+    for (idx = 0; idx < table_size; idx++) {
       if (STRNICMP(stringp, table[idx].name, len) == 0) {
         break;
       }
@@ -526,7 +526,7 @@ int prt_get_unit(int idx)
   static char *(units[4]) = PRT_UNIT_NAMES;
 
   if (printer_opts[idx].present) {
-    for (i = 0; i < 4; ++i) {
+    for (i = 0; i < 4; i++) {
       if (STRNICMP(printer_opts[idx].string, units[i], 2) == 0) {
         u = i;
         break;
@@ -751,11 +751,9 @@ void ex_hardcopy(exarg_T *eap)
     /*
      * Loop over all pages in the print job: 1 2 3 ...
      */
-    for (page_count = 0; prtpos.file_line <= eap->line2; ++page_count) {
-      /*
-       * Loop over uncollated copies: 1 1 1, 2 2 2, 3 3 3, ...
-       * For duplex: 12 12 12 34 34 34, ...
-       */
+    for (page_count = 0; prtpos.file_line <= eap->line2; page_count++) {
+      // Loop over uncollated copies: 1 1 1, 2 2 2, 3 3 3, ...
+      // For duplex: 12 12 12 34 34 34, ...
       for (uncollated_copies = 0;
            uncollated_copies < settings.n_uncollated_copies;
            uncollated_copies++) {
@@ -765,10 +763,8 @@ void ex_hardcopy(exarg_T *eap)
         /*
          * Do front and rear side of a page.
          */
-        for (side = 0; side <= settings.duplex; ++side) {
-          /*
-           * Print one page.
-           */
+        for (side = 0; side <= settings.duplex; side++) {
+          // Print one page.
 
           // Check for interrupt character every page.
           os_breakcheck();
@@ -2298,7 +2294,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
     paper_name = "A4";
     paper_strlen = 2;
   }
-  for (i = 0; i < (int)PRT_MEDIASIZE_LEN; ++i) {
+  for (i = 0; i < (int)PRT_MEDIASIZE_LEN; i++) {
     if (STRLEN(prt_mediasize[i].name) == (unsigned)paper_strlen
         && STRNICMP(prt_mediasize[i].name, paper_name,
                     paper_strlen) == 0) {
diff --git a/src/nvim/hashtab.c b/src/nvim/hashtab.c
index 951e72ea52..308f64f011 100644
--- a/src/nvim/hashtab.c
+++ b/src/nvim/hashtab.c
@@ -67,7 +67,7 @@ void hash_clear(hashtab_T *ht)
 void hash_clear_all(hashtab_T *ht, unsigned int off)
 {
   size_t todo = ht->ht_used;
-  for (hashitem_T *hi = ht->ht_array; todo > 0; ++hi) {
+  for (hashitem_T *hi = ht->ht_array; todo > 0; hi++) {
     if (!HASHITEM_EMPTY(hi)) {
       xfree(hi->hi_key - off);
       todo--;
@@ -356,7 +356,7 @@ static void hash_may_resize(hashtab_T *ht, size_t minitems)
   hash_T newmask = newsize - 1;
   size_t todo = ht->ht_used;
 
-  for (hashitem_T *olditem = oldarray; todo > 0; ++olditem) {
+  for (hashitem_T *olditem = oldarray; todo > 0; olditem++) {
     if (HASHITEM_EMPTY(olditem)) {
       continue;
     }
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 689d1fce0d..9d3b2b0455 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -900,7 +900,7 @@ static int cs_find(exarg_T *eap)
    * Let's replace the NULs written by strtok() with spaces - we need the
    * spaces to correctly display the quickfix/location list window's title.
    */
-  for (int i = 0; i < eap_arg_len; ++i) {
+  for (int i = 0; i < eap_arg_len; i++) {
     if (NUL == eap->arg[i]) {
       eap->arg[i] = ' ';
     }
@@ -1838,7 +1838,7 @@ static void cs_release_csp(size_t i, bool freefnpp)
     // Can't use sigaction(), loop for two seconds.  First yield the CPU
     // to give cscope a chance to exit quickly.
     sleep(0);
-    for (waited = 0; waited < 40; ++waited) {
+    for (waited = 0; waited < 40; waited++) {
       pid = waitpid(csinfo[i].pid, &pstat, WNOHANG);
       waitpid_errno = errno;
       if (pid != 0) {
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 34a3de4f78..fe8c235cc1 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -383,7 +383,7 @@ bool cin_islabel(void)  // XXX
 
   cursor_save = curwin->w_cursor;
   while (curwin->w_cursor.lnum > 1) {
-    --curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum--;
 
     /*
      * If we're in a comment or raw string now, skip to the start of
@@ -434,7 +434,7 @@ static int cin_isinit(void)
   for (;;) {
     int i, l;
 
-    for (i = 0; i < (int)ARRAY_SIZE(skip); ++i) {
+    for (i = 0; i < (int)ARRAY_SIZE(skip); i++) {
       l = (int)strlen(skip[i]);
       if (cin_starts_with(s, skip[i])) {
         s = cin_skipcomment(s + l);
@@ -465,7 +465,7 @@ bool cin_iscase(const char_u *s, bool strict)
 {
   s = cin_skipcomment(s);
   if (cin_starts_with(s, "case")) {
-    for (s += 4; *s; ++s) {
+    for (s += 4; *s; s++) {
       s = cin_skipcomment(s);
       if (*s == NUL) {
         break;
@@ -588,7 +588,7 @@ static bool cin_is_cpp_namespace(const char_u *s)
  */
 static const char_u *after_label(const char_u *l)
 {
-  for (; *l; ++l) {
+  for (; *l; l++) {
     if (*l == ':') {
       if (l[1] == ':') {            // skip over "::" for C++
         l++;
@@ -2330,7 +2330,7 @@ int get_c_indent(void)
               /* look for opening unmatched paren, indent one level
                * for each additional level */
               n = 1;
-              for (col = 0; col < our_paren_pos.col; ++col) {
+              for (col = 0; col < our_paren_pos.col; col++) {
                 switch (l[col]) {
                 case '(':
                 case '{':
@@ -2388,7 +2388,7 @@ int get_c_indent(void)
            * but ignore (void) before the line (ignore_paren_col). */
           col = our_paren_pos.col;
           while ((int)our_paren_pos.col > ignore_paren_col) {
-            --our_paren_pos.col;
+            our_paren_pos.col--;
             switch (*ml_get_pos(&our_paren_pos)) {
             case '(':
               amount += curbuf->b_ind_unclosed2;
diff --git a/src/nvim/main.c b/src/nvim/main.c
index e4e30b7902..12c51e8a85 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1709,7 +1709,7 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
   }
 
   arg_idx = 1;
-  for (i = 1; i < parmp->window_count; ++i) {
+  for (i = 1; i < parmp->window_count; i++) {
     if (cwd != NULL) {
       os_chdir((char *)cwd);
     }
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 593275d489..a15a27650b 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -704,12 +704,12 @@ void fmarks_check_names(buf_T *buf)
     return;
   }
 
-  for (i = 0; i < NGLOBALMARKS; ++i) {
+  for (i = 0; i < NGLOBALMARKS; i++) {
     fmarks_check_one(&namedfm[i], name, buf);
   }
 
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    for (i = 0; i < wp->w_jumplistlen; ++i) {
+    for (i = 0; i < wp->w_jumplistlen; i++) {
       fmarks_check_one(&wp->w_jumplist[i], name, buf);
     }
   }
@@ -848,10 +848,10 @@ void ex_marks(exarg_T *eap)
   }
 
   show_one_mark('\'', arg, &curwin->w_pcmark, NULL, true);
-  for (i = 0; i < NMARKS; ++i) {
+  for (i = 0; i < NMARKS; i++) {
     show_one_mark(i + 'a', arg, &curbuf->b_namedm[i].mark, NULL, true);
   }
-  for (i = 0; i < NGLOBALMARKS; ++i) {
+  for (i = 0; i < NGLOBALMARKS; i++) {
     if (namedfm[i].fmark.fnum != 0) {
       name = fm_getname(&namedfm[i].fmark, 15);
     } else {
@@ -975,7 +975,7 @@ void ex_delmarks(exarg_T *eap)
           from = to = *p;
         }
 
-        for (i = from; i <= to; ++i) {
+        for (i = from; i <= to; i++) {
           if (lower) {
             curbuf->b_namedm[i - 'a'].mark.lnum = 0;
           } else {
@@ -1027,7 +1027,7 @@ void ex_jumps(exarg_T *eap)
   cleanup_jumplist(curwin, true);
   // Highlight title
   msg_puts_title(_("\n jump line  col file/text"));
-  for (i = 0; i < curwin->w_jumplistlen && !got_int; ++i) {
+  for (i = 0; i < curwin->w_jumplistlen && !got_int; i++) {
     if (curwin->w_jumplist[i].fmark.mark.lnum != 0) {
       name = fm_getname(&curwin->w_jumplist[i].fmark, 16);
 
@@ -1083,7 +1083,7 @@ void ex_changes(exarg_T *eap)
   // Highlight title
   msg_puts_title(_("\nchange line  col text"));
 
-  for (i = 0; i < curbuf->b_changelistlen && !got_int; ++i) {
+  for (i = 0; i < curbuf->b_changelistlen && !got_int; i++) {
     if (curbuf->b_changelist[i].mark.lnum != 0) {
       msg_putchar('\n');
       if (got_int) {
@@ -1391,7 +1391,7 @@ void mark_col_adjust(linenr_T lnum, colnr_T mincol, linenr_T lnum_amount, long c
    */
   FOR_ALL_WINDOWS_IN_TAB(win, curtab) {
     // marks in the jumplist
-    for (i = 0; i < win->w_jumplistlen; ++i) {
+    for (i = 0; i < win->w_jumplistlen; i++) {
       if (win->w_jumplist[i].fmark.fnum == fnum) {
         COL_ADJUST(&(win->w_jumplist[i].fmark.mark));
       }
@@ -1493,7 +1493,7 @@ void copy_jumplist(win_T *from, win_T *to)
 {
   int i;
 
-  for (i = 0; i < from->w_jumplistlen; ++i) {
+  for (i = 0; i < from->w_jumplistlen; i++) {
     to->w_jumplist[i] = from->w_jumplist[i];
     if (from->w_jumplist[i].fname != NULL) {
       to->w_jumplist[i].fname = xstrdup(from->w_jumplist[i].fname);
@@ -1717,7 +1717,7 @@ void free_jumplist(win_T *wp)
 {
   int i;
 
-  for (i = 0; i < wp->w_jumplistlen; ++i) {
+  for (i = 0; i < wp->w_jumplistlen; i++) {
     free_xfmark(wp->w_jumplist[i]);
   }
   wp->w_jumplistlen = 0;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index bfe5f70b6e..f9d8422481 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -882,7 +882,7 @@ int utf_ptr2len_len(const char_u *p, int size)
   } else {
     m = len;
   }
-  for (i = 1; i < m; ++i) {
+  for (i = 1; i < m; i++) {
     if ((p[i] & 0xc0) != 0x80) {
       return 1;
     }
@@ -1595,7 +1595,7 @@ void show_utf8(void)
   }
 
   clen = 0;
-  for (i = 0; i < len; ++i) {
+  for (i = 0; i < len; i++) {
     if (clen == 0) {
       // start of (composing) character, get its length
       if (i > 0) {
@@ -1632,10 +1632,10 @@ int utf_head_off(const char_u *base, const char_u *p)
   // Skip backwards over trailing bytes: 10xx.xxxx
   // Skip backwards again if on a composing char.
   const char_u *q;
-  for (q = p;; --q) {
+  for (q = p;; q--) {
     // Move s to the last byte of this char.
     const char_u *s;
-    for (s = q; (s[1] & 0xc0) == 0x80; ++s) {}
+    for (s = q; (s[1] & 0xc0) == 0x80; s++) {}
 
     // Move q to the first byte of this char.
     while (q > base && (*q & 0xc0) == 0x80) {
@@ -1975,7 +1975,7 @@ void utf_find_illegal(void)
     if (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) {
       break;
     }
-    ++curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum++;
     curwin->w_cursor.col = 0;
   }
 
@@ -2181,7 +2181,7 @@ char_u *enc_canonize(char_u *enc) FUNC_ATTR_NONNULL_RET
   char_u *r = xmalloc(STRLEN(enc) + 3);
   // Make it all lower case and replace '_' with '-'.
   p = r;
-  for (s = enc; *s != NUL; ++s) {
+  for (s = enc; *s != NUL; s++) {
     if (*s == '_') {
       *p++ = '-';
     } else {
@@ -2234,7 +2234,7 @@ static int enc_alias_search(const char_u *name)
 {
   int i;
 
-  for (i = 0; enc_alias_table[i].name != NULL; ++i) {
+  for (i = 0; enc_alias_table[i].name != NULL; i++) {
     if (STRCMP(name, enc_alias_table[i].name) == 0) {
       return enc_alias_table[i].canon;
     }
@@ -2567,7 +2567,7 @@ char_u *string_convert_ext(const vimconv_T *const vcp, char_u *ptr, size_t *lenp
   case CONV_TO_UTF8:            // latin1 to utf-8 conversion
     retval = xmalloc(len * 2 + 1);
     d = retval;
-    for (size_t i = 0; i < len; ++i) {
+    for (size_t i = 0; i < len; i++) {
       c = ptr[i];
       if (c < 0x80) {
         *d++ = (char_u)c;
@@ -2585,7 +2585,7 @@ char_u *string_convert_ext(const vimconv_T *const vcp, char_u *ptr, size_t *lenp
   case CONV_9_TO_UTF8:          // latin9 to utf-8 conversion
     retval = xmalloc(len * 3 + 1);
     d = retval;
-    for (size_t i = 0; i < len; ++i) {
+    for (size_t i = 0; i < len; i++) {
       c = ptr[i];
       switch (c) {
       case 0xa4:
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 3e3a41a963..980d6908f9 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1035,7 +1035,7 @@ void ml_recover(bool checkext)
       if (pp->pb_id == PTR_ID) {                // it is a pointer block
         // check line count when using pointer block first time
         if (idx == 0 && line_count != 0) {
-          for (i = 0; i < (int)pp->pb_count; ++i) {
+          for (i = 0; i < (int)pp->pb_count; i++) {
             line_count -= pp->pb_pointer[i].pe_line_count;
           }
           if (line_count != 0) {
@@ -1071,7 +1071,7 @@ void ml_recover(bool checkext)
               ml_append(lnum++, _("???LINES MISSING"),
                         (colnr_T)0, true);
             }
-            ++idx;                  // get same block again for next index
+            idx++;                  // get same block again for next index
             continue;
           }
 
@@ -1131,7 +1131,7 @@ void ml_recover(bool checkext)
             has_error = true;
           }
 
-          for (i = 0; i < dp->db_line_count; ++i) {
+          for (i = 0; i < dp->db_line_count; i++) {
             txt_start = (dp->db_index[i] & DB_INDEX_MASK);
             if (txt_start <= (int)HEADER_SIZE
                 || txt_start >= (int)dp->db_txt_end) {
@@ -1177,7 +1177,7 @@ void ml_recover(bool checkext)
       buf_inc_changedtick(curbuf);
     }
   } else {
-    for (idx = 1; idx <= lnum; ++idx) {
+    for (idx = 1; idx <= lnum; idx++) {
       // Need to copy one line, fetching the other one may flush it.
       p = vim_strsave(ml_get(idx));
       i = STRCMP(p, ml_get(idx + lnum));
@@ -1379,7 +1379,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
           if (--num_files == 0) {
             xfree(files);
           } else {
-            for (; i < num_files; ++i) {
+            for (; i < num_files; i++) {
               files[i] = files[i + 1];
             }
           }
@@ -1406,7 +1406,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
       }
 
       if (num_files) {
-        for (int i = 0; i < num_files; ++i) {
+        for (int i = 0; i < num_files; i++) {
           // print the swap file name
           msg_outnum((long)++file_count);
           msg_puts(".    ");
@@ -1422,7 +1422,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
       file_count += num_files;
     }
 
-    for (int i = 0; i < num_names; ++i) {
+    for (int i = 0; i < num_names; i++) {
       xfree(names[i]);
     }
     if (num_files > 0) {
@@ -2038,7 +2038,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
     dp = hp->bh_data;
   }
 
-  ++buf->b_ml.ml_line_count;
+  buf->b_ml.ml_line_count++;
 
   if ((int)dp->db_free >= space_needed) {       // enough room in data block
     /*
@@ -2286,7 +2286,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
                   &pp->pb_pointer[pb_idx + 1],
                   (size_t)(pp->pb_count - pb_idx - 1) * sizeof(PTR_EN));
         }
-        ++pp->pb_count;
+        pp->pb_count++;
         pp->pb_pointer[pb_idx].pe_line_count = line_count_left;
         pp->pb_pointer[pb_idx].pe_bnum = bnum_left;
         pp->pb_pointer[pb_idx].pe_page_count = page_count_left;
@@ -2561,7 +2561,7 @@ static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message)
   count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 2;
   idx = lnum - buf->b_ml.ml_locked_low;
 
-  --buf->b_ml.ml_line_count;
+  buf->b_ml.ml_line_count--;
 
   line_start = ((dp->db_index[idx]) & DB_INDEX_MASK);
   if (idx == 0) {               // first line in block, text at the end
@@ -2705,7 +2705,7 @@ linenr_T ml_firstmarked(void)
     dp = hp->bh_data;
 
     for (i = lnum - curbuf->b_ml.ml_locked_low;
-         lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) {
+         lnum <= curbuf->b_ml.ml_locked_high; i++, lnum++) {
       if ((dp->db_index[i]) & DB_MARKED) {
         (dp->db_index[i]) &= DB_INDEX_MASK;
         curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
@@ -2745,7 +2745,7 @@ void ml_clearmarked(void)
     dp = hp->bh_data;
 
     for (i = lnum - curbuf->b_ml.ml_locked_low;
-         lnum <= curbuf->b_ml.ml_locked_high; ++i, ++lnum) {
+         lnum <= curbuf->b_ml.ml_locked_high; i++, lnum++) {
       if ((dp->db_index[i]) & DB_MARKED) {
         (dp->db_index[i]) &= DB_INDEX_MASK;
         curbuf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
@@ -2965,7 +2965,7 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
   high = buf->b_ml.ml_line_count;
 
   if (action == ML_FIND) {      // first try stack entries
-    for (top = buf->b_ml.ml_stack_top - 1; top >= 0; --top) {
+    for (top = buf->b_ml.ml_stack_top - 1; top >= 0; top--) {
       ip = &(buf->b_ml.ml_stack[top]);
       if (ip->ip_low <= lnum && ip->ip_high >= lnum) {
         bnum = ip->ip_bnum;
@@ -3021,8 +3021,8 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
     ip->ip_high = high;
     ip->ip_index = -1;                  // index not known yet
 
-    dirty = FALSE;
-    for (idx = 0; idx < (int)pp->pb_count; ++idx) {
+    dirty = false;
+    for (idx = 0; idx < (int)pp->pb_count; idx++) {
       t = pp->pb_pointer[idx].pe_line_count;
       CHECK(t == 0, _("pe_line_count is zero"));
       if ((low += t) > lnum) {
@@ -3119,7 +3119,7 @@ static void ml_lineadd(buf_T *buf, int count)
   memfile_T *mfp = buf->b_ml.ml_mfp;
   bhdr_T *hp;
 
-  for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; --idx) {
+  for (idx = buf->b_ml.ml_stack_top - 1; idx >= 0; idx--) {
     ip = &(buf->b_ml.ml_stack[idx]);
     if ((hp = mf_get(mfp, ip->ip_bnum, 1)) == NULL) {
       break;
@@ -3610,10 +3610,10 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
         XFREE_CLEAR(fname);
         break;
       }
-      --fname[n - 2];                   // ".svz", ".suz", etc.
+      fname[n - 2]--;                   // ".svz", ".suz", etc.
       fname[n - 1] = 'z' + 1;
     }
-    --fname[n - 1];                     // ".swo", ".swn", etc.
+    fname[n - 1]--;                     // ".swo", ".swn", etc.
   }
 
   if (os_isdir((char_u *)dir_name)) {
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index efbeb26915..b7665c2d82 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -419,7 +419,7 @@ static int add_menu_path(const char *const menu_path, vimmenu_T *menuarg, const
     p = (call_data == NULL) ? NULL : xstrdup(call_data);
 
     // loop over all modes, may add more than one
-    for (i = 0; i < MENU_MODES; ++i) {
+    for (i = 0; i < MENU_MODES; i++) {
       if (modes & (1 << i)) {
         // free any old menu
         free_menu_string(menu, i);
@@ -933,7 +933,7 @@ char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool for
   xp->xp_context = EXPAND_UNSUCCESSFUL;
 
   // Check for priority numbers, enable and disable
-  for (p = arg; *p; ++p) {
+  for (p = arg; *p; p++) {
     if (!ascii_isdigit(*p) && *p != '.') {
       break;
     }
@@ -957,7 +957,7 @@ char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool for
 
   arg = after_dot = p;
 
-  for (; *p && !ascii_iswhite(*p); ++p) {
+  for (; *p && !ascii_iswhite(*p); p++) {
     if ((*p == '\\' || *p == Ctrl_V) && p[1] != NUL) {
       p++;
     } else if (*p == '.') {
@@ -1181,7 +1181,7 @@ static bool menu_namecmp(const char *const name, const char *const mname)
 {
   int i;
 
-  for (i = 0; name[i] != NUL && name[i] != TAB; ++i) {
+  for (i = 0; name[i] != NUL && name[i] != TAB; i++) {
     if (name[i] != mname[i]) {
       break;
     }
diff --git a/src/nvim/message.c b/src/nvim/message.c
index ab667c88ac..e29bacbd17 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -420,7 +420,7 @@ void trunc_string(char *s, char *buf, int room_in, int buflen)
   half = room / 2;
 
   // First part: Start of the string.
-  for (e = 0; len < half && e < buflen; ++e) {
+  for (e = 0; len < half && e < buflen; e++) {
     if (s[e] == NUL) {
       // text fits without truncating!
       buf[e] = NUL;
@@ -1641,7 +1641,7 @@ void msg_make(char_u *arg)
   }
   if (i < 0) {
     msg_putchar('\n');
-    for (i = 0; rs[i]; ++i) {
+    for (i = 0; rs[i]; i++) {
       msg_putchar(rs[i] - 3);
     }
   }
@@ -2817,7 +2817,7 @@ static int do_more_prompt(int typed_char)
     // "g<": Find first line on the last page.
     mp_last = msg_sb_start(last_msgchunk);
     for (i = 0; i < Rows - 2 && mp_last != NULL
-         && mp_last->sb_prev != NULL; ++i) {
+         && mp_last->sb_prev != NULL; i++) {
       mp_last = msg_sb_start(mp_last->sb_prev);
     }
   }
@@ -2936,8 +2936,7 @@ static int do_more_prompt(int typed_char)
         }
 
         // go to start of line at top of the screen
-        for (i = 0; i < Rows - 2 && mp != NULL && mp->sb_prev != NULL;
-             ++i) {
+        for (i = 0; i < Rows - 2 && mp != NULL && mp->sb_prev != NULL; i++) {
           mp = msg_sb_start(mp->sb_prev);
         }
 
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index b2d6a65955..3dfbeec048 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -374,7 +374,7 @@ retnomove:
         if (curwin->w_topfill < win_get_fill(curwin, curwin->w_topline)) {
           curwin->w_topfill++;
         } else {
-          --curwin->w_topline;
+          curwin->w_topline--;
           curwin->w_topfill = 0;
         }
       }
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 883a9dfcb9..b3ec3a8e7a 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -571,7 +571,7 @@ static void curs_rows(win_T *wp)
                      || wp->w_lines[0].wl_lnum > wp->w_topline);
   int i = 0;
   wp->w_cline_row = 0;
-  for (linenr_T lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) {
+  for (linenr_T lnum = wp->w_topline; lnum < wp->w_cursor.lnum; i++) {
     bool valid = false;
     if (!all_invalid && i < wp->w_lines_valid) {
       if (wp->w_lines[i].wl_lnum < lnum || !wp->w_lines[i].wl_valid) {
@@ -587,7 +587,7 @@ static void curs_rows(win_T *wp)
           valid = true;
         }
       } else if (wp->w_lines[i].wl_lnum > lnum) {
-        --i;                            // hold at inserted lines
+        i--;                            // hold at inserted lines
       }
     }
     if (valid && (lnum != wp->w_topline || !win_may_fill(wp))) {
@@ -1053,7 +1053,7 @@ bool scrolldown(long line_count, int byfold)
       if (curwin->w_topline == 1) {
         break;
       }
-      --curwin->w_topline;
+      curwin->w_topline--;
       curwin->w_topfill = 0;
       // A sequence of folded lines only counts for one logical line
       linenr_T first;
@@ -1068,7 +1068,7 @@ bool scrolldown(long line_count, int byfold)
         done += plines_win_nofill(curwin, curwin->w_topline, true);
       }
     }
-    --curwin->w_botline;                // approximate w_botline
+    curwin->w_botline--;                // approximate w_botline
     invalidate_botline();
   }
   curwin->w_wrow += done;               // keep w_wrow updated
@@ -1130,7 +1130,7 @@ bool scrollup(long line_count, int byfold)
     linenr_T lnum = curwin->w_topline;
     while (line_count--) {
       if (curwin->w_topfill > 0) {
-        --curwin->w_topfill;
+        curwin->w_topfill--;
       } else {
         if (byfold) {
           (void)hasFolding(lnum, NULL, &lnum);
@@ -1187,7 +1187,7 @@ void check_topfill(win_T *wp, bool down)
     int n = plines_win_nofill(wp, wp->w_topline, true);
     if (wp->w_topfill + n > wp->w_height_inner) {
       if (down && wp->w_topline > 1) {
-        --wp->w_topline;
+        wp->w_topline--;
         wp->w_topfill = 0;
       } else {
         wp->w_topfill = wp->w_height_inner - n;
@@ -1249,14 +1249,14 @@ void scrolldown_clamp(void)
   }
   if (end_row < curwin->w_height_inner - get_scrolloff_value(curwin)) {
     if (can_fill) {
-      ++curwin->w_topfill;
+      curwin->w_topfill++;
       check_topfill(curwin, true);
     } else {
-      --curwin->w_topline;
+      curwin->w_topline--;
       curwin->w_topfill = 0;
     }
     (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
-    --curwin->w_botline;            // approximate w_botline
+    curwin->w_botline--;            // approximate w_botline
     curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
   }
 }
@@ -1309,7 +1309,7 @@ static void topline_back(win_T *wp, lineoff_T *lp)
     lp->fill++;
     lp->height = 1;
   } else {
-    --lp->lnum;
+    lp->lnum--;
     lp->fill = 0;
     if (lp->lnum < 1) {
       lp->height = MAXCOL;
@@ -1335,7 +1335,7 @@ static void botline_forw(win_T *wp, lineoff_T *lp)
     lp->fill++;
     lp->height = 1;
   } else {
-    ++lp->lnum;
+    lp->lnum++;
     lp->fill = 0;
     assert(wp->w_buffer != 0);
     if (lp->lnum > wp->w_buffer->b_ml.ml_line_count) {
@@ -1726,7 +1726,7 @@ void scroll_cursor_halfway(int atend)
         }
         below += boff.height;
       } else {
-        ++below;                    // count a "~" line
+        below++;                    // count a "~" line
         if (atend) {
           used++;
         }
@@ -1899,7 +1899,7 @@ int onepage(Direction dir, long count)
       if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1) {
         // Vi compatible scrolling
         if (p_window <= 2) {
-          ++curwin->w_topline;
+          curwin->w_topline++;
         } else {
           curwin->w_topline += (linenr_T)p_window - 2;
         }
@@ -1935,7 +1935,7 @@ int onepage(Direction dir, long count)
       if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1) {
         // Vi compatible scrolling (sort of)
         if (p_window <= 2) {
-          --curwin->w_topline;
+          curwin->w_topline--;
         } else {
           curwin->w_topline -= (linenr_T)p_window - 2;
         }
@@ -2000,7 +2000,7 @@ int onepage(Direction dir, long count)
             max_topfill();
           }
           if (curwin->w_topfill == loff.fill) {
-            --curwin->w_topline;
+            curwin->w_topline--;
             curwin->w_topfill = 0;
           }
           comp_botline(curwin);
@@ -2144,7 +2144,7 @@ void halfpage(bool flag, linenr_T Prenum)
         curwin->w_topfill = win_get_fill(curwin, curwin->w_topline);
 
         if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
-          ++curwin->w_cursor.lnum;
+          curwin->w_cursor.lnum++;
           curwin->w_valid &=
             ~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
         }
@@ -2177,7 +2177,7 @@ void halfpage(bool flag, linenr_T Prenum)
                && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
           (void)hasFolding(curwin->w_cursor.lnum, NULL,
                            &curwin->w_cursor.lnum);
-          ++curwin->w_cursor.lnum;
+          curwin->w_cursor.lnum++;
         }
       } else {
         curwin->w_cursor.lnum += n;
@@ -2199,7 +2199,7 @@ void halfpage(bool flag, linenr_T Prenum)
         if (n < 0 && scrolled > 0) {
           break;
         }
-        --curwin->w_topline;
+        curwin->w_topline--;
         (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
         curwin->w_topfill = 0;
       }
@@ -2207,7 +2207,7 @@ void halfpage(bool flag, linenr_T Prenum)
                            VALID_BOTLINE|VALID_BOTLINE_AP);
       scrolled += i;
       if (curwin->w_cursor.lnum > 1) {
-        --curwin->w_cursor.lnum;
+        curwin->w_cursor.lnum--;
         curwin->w_valid &= ~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
       }
     }
@@ -2218,7 +2218,7 @@ void halfpage(bool flag, linenr_T Prenum)
         curwin->w_cursor.lnum = 1;
       } else if (hasAnyFolding(curwin)) {
         while (--n >= 0 && curwin->w_cursor.lnum > 1) {
-          --curwin->w_cursor.lnum;
+          curwin->w_cursor.lnum--;
           (void)hasFolding(curwin->w_cursor.lnum,
                            &curwin->w_cursor.lnum, NULL);
         }
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index e4282ceff9..1f6b154eed 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -234,7 +234,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
       // isn't set or 'cindent' isn't set or '#' isn't in 'cino'.
       shift_line(oap->op_type == OP_LSHIFT, p_sr, amount, false);
     }
-    ++curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum++;
   }
 
   if (oap->motion_type == kMTBlockWise) {
@@ -244,7 +244,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
     curwin->w_cursor.lnum = oap->start.lnum;
     beginline(BL_SOL | BL_FIX);       // shift_line() may have set cursor.col
   } else {
-    --curwin->w_cursor.lnum;            // put cursor on last line, for ":>"
+    curwin->w_cursor.lnum--;            // put cursor on last line, for ":>"
   }
   // The cursor line is not in a closed fold
   foldOpenCursor();
@@ -2002,7 +2002,7 @@ static int op_replace(oparg_T *oap, int c)
       curwin->w_cursor.col = 0;
       oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
       if (oap->end.col) {
-        --oap->end.col;
+        oap->end.col--;
       }
     } else if (!oap->inclusive) {
       dec(&(oap->end));
@@ -2116,7 +2116,7 @@ void op_tilde(oparg_T *oap)
       pos.col = 0;
       oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
       if (oap->end.col) {
-        --oap->end.col;
+        oap->end.col--;
       }
     } else if (!oap->inclusive) {
       dec(&(oap->end));
@@ -2282,7 +2282,7 @@ void op_insert(oparg_T *oap, long count1)
       coladvance_force(oap->op_type == OP_APPEND
           ? oap->end_vcol + 1 : getviscol());
       if (oap->op_type == OP_APPEND) {
-        --curwin->w_cursor.col;
+        curwin->w_cursor.col--;
       }
       curwin->w_ve_flags = old_ve_flags;
     }
@@ -2306,7 +2306,7 @@ void op_insert(oparg_T *oap, long count1)
       curwin->w_set_curswant = TRUE;
       while (*get_cursor_pos_ptr() != NUL
              && (curwin->w_cursor.col < bd.textcol + bd.textlen)) {
-        ++curwin->w_cursor.col;
+        curwin->w_cursor.col++;
       }
       if (bd.is_short && !bd.is_MAX) {
         // First line was too short, make it longer and adjust the
@@ -2412,7 +2412,7 @@ void op_insert(oparg_T *oap, long count1)
       if (oap->op_type == OP_APPEND) {
         pre_textlen += bd2.textlen - bd.textlen;
         if (bd2.endspaces) {
-          --bd2.textlen;
+          bd2.textlen--;
         }
       }
       bd.textcol = bd2.textcol;
@@ -3321,7 +3321,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       } else if (vcol > col) {
         bd.endspaces = vcol - col;
         bd.startspaces = incr - bd.endspaces;
-        --bd.textcol;
+        bd.textcol--;
         delcount = 1;
         bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
         if (oldp[bd.textcol] != TAB) {
@@ -3394,7 +3394,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       extmark_splice_cols(curbuf, (int)curwin->w_cursor.lnum - 1, bd.textcol,
                           delcount, (int)totlen + lines_appended, kExtmarkUndo);
 
-      ++curwin->w_cursor.lnum;
+      curwin->w_cursor.lnum++;
       if (i == 0) {
         curwin->w_cursor.col += bd.startspaces;
       }
@@ -3698,7 +3698,7 @@ error:
         // put cursor on first non-blank in first inserted line
         curwin->w_cursor.col = 0;
         if (dir == FORWARD) {
-          ++curwin->w_cursor.lnum;
+          curwin->w_cursor.lnum++;
         }
         beginline(BL_WHITE | BL_FIX);
       } else {  // put cursor on first inserted character
@@ -4088,11 +4088,11 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
         if (endcurr1 == ' ') {
           endcurr1 = endcurr2;
         } else {
-          ++spaces[t];
+          spaces[t]++;
         }
         // Extra space when 'joinspaces' set and line ends in '.', '?', or '!'.
         if (p_js && (endcurr1 == '.' || endcurr1 == '?' || endcurr1 == '!')) {
-          ++spaces[t];
+          spaces[t]++;
         }
       }
     }
@@ -4243,7 +4243,7 @@ static int same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, in
    * some text after it and the second line has the 'm' flag.
    */
   if (leader1_flags != NULL) {
-    for (p = leader1_flags; *p && *p != ':'; ++p) {
+    for (p = leader1_flags; *p && *p != ':'; p++) {
       if (*p == COM_FIRST) {
         return leader2_len == 0;
       }
@@ -4257,7 +4257,7 @@ static int same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, in
         if (leader2_flags == NULL || leader2_len == 0) {
           return FALSE;
         }
-        for (p = leader2_flags; *p && *p != ':'; ++p) {
+        for (p = leader2_flags; *p && *p != ':'; p++) {
           if (*p == COM_MIDDLE) {
             return TRUE;
           }
@@ -4274,7 +4274,7 @@ static int same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, in
   line1 = vim_strsave(ml_get(lnum));
   for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
   line2 = ml_get(lnum + 1);
-  for (idx2 = 0; idx2 < leader2_len; ++idx2) {
+  for (idx2 = 0; idx2 < leader2_len; idx2++) {
     if (!ascii_iswhite(line2[idx2])) {
       if (line1[idx1++] != line2[idx2]) {
         break;
@@ -4331,7 +4331,7 @@ static void op_format(oparg_T *oap, int keep_cursor)
    * line, so "." will do the next lines.
    */
   if (oap->end_adjusted && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
-    ++curwin->w_cursor.lnum;
+    curwin->w_cursor.lnum++;
   }
   beginline(BL_WHITE | BL_FIX);
   old_line_count = curbuf->b_ml.ml_line_count - old_line_count;
@@ -4466,10 +4466,8 @@ void format_lines(linenr_T line_count, int avoid_fex)
   }
 
   curwin->w_cursor.lnum--;
-  for (count = line_count; count != 0 && !got_int; --count) {
-    /*
-     * Advance to next paragraph.
-     */
+  for (count = line_count; count != 0 && !got_int; count--) {
+    // Advance to next paragraph.
     if (advance) {
       curwin->w_cursor.lnum++;
       prev_is_end_par = is_end_par;
@@ -5701,18 +5699,18 @@ static void str_to_reg(yankreg_T *y_ptr, MotionType yank_type, const char *str,
 
   // Count the number of lines within the string
   if (str_list) {
-    for (char_u **ss = (char_u **)str; *ss != NULL; ++ss) {
+    for (char_u **ss = (char_u **)str; *ss != NULL; ss++) {
       newlines++;
     }
   } else {
     newlines = memcnt(str, '\n', len);
     if (yank_type == kMTCharWise || len == 0 || str[len - 1] != '\n') {
       extraline = 1;
-      ++newlines;         // count extra newline at the end
+      newlines++;         // count extra newline at the end
     }
     if (y_ptr->y_size > 0 && y_ptr->y_type == kMTCharWise) {
       append = true;
-      --newlines;         // uncount newline when appending first line
+      newlines--;         // uncount newline when appending first line
     }
   }
 
@@ -5733,7 +5731,7 @@ static void str_to_reg(yankreg_T *y_ptr, MotionType yank_type, const char *str,
 
   // Find the end of each line and save it into the array.
   if (str_list) {
-    for (char_u **ss = (char_u **)str; *ss != NULL; ++ss, ++lnum) {
+    for (char_u **ss = (char_u **)str; *ss != NULL; ss++, lnum++) {
       size_t ss_len = STRLEN(*ss);
       pp[lnum] = xmemdupz(*ss, ss_len);
       if (ss_len > maxlen) {
@@ -5883,7 +5881,7 @@ void cursor_pos_info(dict_T *dict)
         max_pos = VIsual;
       }
       if (*p_sel == 'e' && max_pos.col > 0) {
-        --max_pos.col;
+        max_pos.col--;
       }
 
       if (l_VIsual_mode == Ctrl_V) {
@@ -5913,7 +5911,7 @@ void cursor_pos_info(dict_T *dict)
       line_count_selected = max_pos.lnum - min_pos.lnum + 1;
     }
 
-    for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; ++lnum) {
+    for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; lnum++) {
       // Check for a CTRL-C every 100000 characters.
       if (byte_count > last_check) {
         os_breakcheck();
diff --git a/src/nvim/path.c b/src/nvim/path.c
index ce0a7fb281..3b3156bc73 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -663,7 +663,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   // Now we have one wildcard component between "s" and "e".
   /* Remove backslashes between "wildoff" and the start of the wildcard
    * component. */
-  for (p = buf + wildoff; p < s; ++p) {
+  for (p = buf + wildoff; p < s; p++) {
     if (rem_backslash(p)) {
       STRMOVE(p, p + 1);
       e--;
@@ -672,7 +672,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   }
 
   // Check for "**" between "s" and "e".
-  for (p = s; p < e; ++p) {
+  for (p = s; p < e; p++) {
     if (p[0] == '*' && p[1] == '*') {
       starstar = true;
     }
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 4d6f7a0f36..6ce2b4d878 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -3180,7 +3180,7 @@ static void qf_fmt_text(const char *restrict text, char *restrict buf, int bufsi
   int i;
   const char *p = (char *)text;
 
-  for (i = 0; *p != NUL && i < bufsize - 1; ++i) {
+  for (i = 0; *p != NUL && i < bufsize - 1; i++) {
     if (*p == '\n') {
       buf[i] = ' ';
       while (*++p != NUL) {
@@ -3263,13 +3263,13 @@ void qf_age(exarg_T *eap)
         emsg(_("E380: At bottom of quickfix stack"));
         break;
       }
-      --qi->qf_curlist;
+      qi->qf_curlist--;
     } else {
       if (qi->qf_curlist >= qi->qf_listcount - 1) {
         emsg(_("E381: At top of quickfix stack"));
         break;
       }
-      ++qi->qf_curlist;
+      qi->qf_curlist++;
     }
   }
   qf_msg(qi, qi->qf_curlist, "");
@@ -4328,7 +4328,7 @@ static char *get_mef_name(void)
 
   char *p;
 
-  for (p = p_mef; *p; ++p) {
+  for (p = p_mef; *p; p++) {
     if (p[0] == '#' && p[1] == '#') {
       break;
     }
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index 769d2ceeef..d7a4f40ecf 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -4369,7 +4369,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
         case BRACE_COMPLEX + 8:
         case BRACE_COMPLEX + 9:
           no = op - BRACE_COMPLEX;
-          ++brace_count[no];
+          brace_count[no]++;
 
           // If not matched enough times yet, try one more
           if (brace_count[no] <= (brace_min[no] <= brace_max[no]
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 89b24e9440..58e195b745 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -1013,7 +1013,7 @@ void draw_tabline(void)
 
       modified = false;
 
-      for (wincount = 0; wp != NULL; wp = wp->w_next, ++wincount) {
+      for (wincount = 0; wp != NULL; wp = wp->w_next, wincount++) {
         if (bufIsChanged(wp->w_buffer)) {
           modified = true;
         }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 6b390294c0..6e5e12dd17 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -513,7 +513,7 @@ void last_pat_prog(regmmatch_T *regmatch)
     regmatch->regprog = NULL;
     return;
   }
-  ++emsg_off;           // So it doesn't beep if bad expr
+  emsg_off++;           // So it doesn't beep if bad expr
   (void)search_regcomp((char_u *)"", 0, last_idx, SEARCH_KEEP, regmatch);
   emsg_off--;
 }
@@ -632,7 +632,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
       lnum = pos->lnum;
     }
 
-    for (loop = 0; loop <= 1; ++loop) {     // loop twice if 'wrapscan' set
+    for (loop = 0; loop <= 1; loop++) {     // loop twice if 'wrapscan' set
       for (; lnum > 0 && lnum <= buf->b_ml.ml_line_count;
            lnum += dir, at_first_line = FALSE) {
         // Stop after checking "stop_lnum", if it's set.
@@ -991,7 +991,7 @@ static int first_submatch(regmmatch_T *rp)
 {
   int submatch;
 
-  for (submatch = 1;; ++submatch) {
+  for (submatch = 1;; submatch++) {
     if (rp->startpos[submatch].lnum >= 0) {
       break;
     }
@@ -1298,7 +1298,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
      */
     if (!spats[0].off.line && spats[0].off.off && pos.col < MAXCOL - 2) {
       if (spats[0].off.off > 0) {
-        for (c = spats[0].off.off; c; --c) {
+        for (c = spats[0].off.off; c; c--) {
           if (decl(&pos) == -1) {
             break;
           }
@@ -1308,7 +1308,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
           pos.col = MAXCOL;
         }
       } else {
-        for (c = spats[0].off.off; c; ++c) {
+        for (c = spats[0].off.off; c; c++) {
           if (incl(&pos) == -1) {
             break;
           }
@@ -1867,7 +1867,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
          * the line.
          */
         if (linep[pos.col] == NUL && pos.col) {
-          --pos.col;
+          pos.col--;
         }
         for (;;) {
           initc = utf_ptr2char((char *)linep + pos.col);
@@ -2001,7 +2001,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
         if (pos.lnum == 1) {            // start of file
           break;
         }
-        --pos.lnum;
+        pos.lnum--;
 
         if (maxtravel > 0 && ++traveled > maxtravel) {
           break;
@@ -2036,7 +2036,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
             || lispcomm) {
           break;
         }
-        ++pos.lnum;
+        pos.lnum++;
 
         if (maxtravel && traveled++ > maxtravel) {
           break;
@@ -2131,7 +2131,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
        * Watch out for "\\".
        */
       at_start = do_quotes;
-      for (ptr = linep; *ptr; ++ptr) {
+      for (ptr = linep; *ptr; ptr++) {
         if (ptr == linep + pos.col + backwards) {
           at_start = (do_quotes & 1);
         }
@@ -2211,7 +2211,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       if (do_quotes) {
         int col;
 
-        for (col = pos.col - 1; col >= 0; --col) {
+        for (col = pos.col - 1; col >= 0; col--) {
           if (linep[col] != '\\') {
             break;
           }
@@ -2522,7 +2522,7 @@ int findsent(Direction dir, long count)
       c = gchar_pos(&pos);
       if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, FALSE))) {
         if (dir == BACKWARD && pos.lnum != startlnum) {
-          ++pos.lnum;
+          pos.lnum++;
         }
         break;
       }
@@ -3298,7 +3298,7 @@ extend:
       }
       findsent_forward(count, at_start_sent);
       if (*p_sel == 'e') {
-        ++curwin->w_cursor.col;
+        curwin->w_cursor.col++;
       }
     }
     return OK;
@@ -3356,7 +3356,7 @@ extend:
       goto extend;
     }
     if (*p_sel == 'e') {
-      ++curwin->w_cursor.col;
+      curwin->w_cursor.col++;
     }
     VIsual = start_pos;
     VIsual_mode = 'v';
@@ -3409,7 +3409,7 @@ int current_block(oparg_T *oap, long count, int include, int what, int other)
     }
     if (gchar_cursor() == what) {
       // cursor on '(' or '{', move cursor just after it
-      ++curwin->w_cursor.col;
+      curwin->w_cursor.col++;
     }
   } else if (lt(VIsual, curwin->w_cursor)) {
     old_start = VIsual;
@@ -3803,7 +3803,7 @@ extend:
       }
 
       prev_start_is_white = -1;
-      for (t = 0; t < 2; ++t) {
+      for (t = 0; t < 2; t++) {
         start_lnum += dir;
         start_is_white = linewhite(start_lnum);
         if (prev_start_is_white == start_is_white) {
@@ -5638,7 +5638,7 @@ search_line:
             p = (char_u *)skipwhite((char *)line);
             if (matched
                 || (p[0] == '/' && p[1] == '*') || p[0] == '*') {
-              for (p = line; *p && p < startp; ++p) {
+              for (p = line; *p && p < startp; p++) {
                 if (matched
                     && p[0] == '/'
                     && (p[1] == '*' || p[1] == '/')) {
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 389f9902ba..676eff9f4a 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -845,12 +845,12 @@ static void tree_count_words(char_u *byts, idx_T *idxs)
     } else {
       // Do one more byte at this node.
       n = arridx[depth] + curi[depth];
-      ++curi[depth];
+      curi[depth]++;
 
       c = byts[n];
       if (c == 0) {
         // End of word, count it.
-        ++wordcount[depth];
+        wordcount[depth]++;
 
         // Skip over any other NUL bytes (same word with different
         // flags).
@@ -885,7 +885,7 @@ void suggest_load_files(void)
   int c;
 
   // Do this for all languages that support sound folding.
-  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; ++lpi) {
+  for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
     lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
     slang = lp->lp_slang;
     if (slang->sl_sugtime != 0 && !slang->sl_sugloaded) {
@@ -960,7 +960,7 @@ someerror:
       // Read all the wordnr lists into the buffer, one NUL terminated
       // list per line.
       ga_init(&ga, 1, 100);
-      for (wordnr = 0; wordnr < wcount; ++wordnr) {
+      for (wordnr = 0; wordnr < wcount; wordnr++) {
         ga.ga_len = 0;
         for (;;) {
           c = getc(fd);                                     // <sugline>
@@ -1142,10 +1142,10 @@ static int read_rep_section(FILE *fd, garray_T *gap, int16_t *first)
   }
 
   // Fill the first-index table.
-  for (int i = 0; i < 256; ++i) {
+  for (int i = 0; i < 256; i++) {
     first[i] = -1;
   }
-  for (int i = 0; i < gap->ga_len; ++i) {
+  for (int i = 0; i < gap->ga_len; i++) {
     ftp = &((fromto_T *)gap->ga_data)[i];
     if (first[*ftp->ft_from] == -1) {
       first[*ftp->ft_from] = (int16_t)i;
@@ -1200,7 +1200,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
 
     // Read up to the first special char into sm_lead.
     int i = 0;
-    for (; i < ccnt; ++i) {
+    for (; i < ccnt; i++) {
       c = getc(fd);                             // <salfrom>
       if (vim_strchr("0123456789(-<^$", c) != NULL) {
         break;
@@ -1213,7 +1213,7 @@ static int read_sal_section(FILE *fd, slang_T *slang)
     // Put (abc) chars in sm_oneof, if any.
     if (c == '(') {
       smp->sm_oneof = p;
-      for (++i; i < ccnt; ++i) {
+      for (++i; i < ccnt; i++) {
         c = getc(fd);                           // <salfrom>
         if (c == ')') {
           break;
@@ -1299,7 +1299,7 @@ static int read_words_section(FILE *fd, slang_T *lp, int len)
 
   while (done < len) {
     // Read one word at a time.
-    for (i = 0;; ++i) {
+    for (i = 0;; i++) {
       c = getc(fd);
       if (c == EOF) {
         return SP_TRUNCERROR;
@@ -1597,7 +1597,7 @@ static void set_sal_first(slang_T *lp)
   garray_T *gap = &lp->sl_sal;
 
   sfirst = lp->sl_sal_first;
-  for (int i = 0; i < 256; ++i) {
+  for (int i = 0; i < 256; i++) {
     sfirst[i] = -1;
   }
   smp = (salitem_T *)gap->ga_data;
@@ -1732,7 +1732,7 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
   byts[idx++] = (char_u)len;
 
   // Read the byte values, flag/region bytes and shared indexes.
-  for (i = 1; i <= len; ++i) {
+  for (i = 1; i <= len; i++) {
     c = getc(fd);                                       // <byte>
     if (c < 0) {
       return SP_TRUNCERROR;
@@ -1795,7 +1795,7 @@ static idx_T read_tree_node(FILE *fd, char_u *byts, idx_T *idxs, int maxidx, idx
   // Recursively read the children for non-shared siblings.
   // Skip the end-of-word ones (zero byte value) and the shared ones (and
   // remove SHARED_MASK)
-  for (i = 1; i <= len; ++i) {
+  for (i = 1; i <= len; i++) {
     if (byts[startidx + i] != 0) {
       if (idxs[startidx + i] & SHARED_MASK) {
         idxs[startidx + i] &= ~SHARED_MASK;
@@ -2580,7 +2580,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 
             // Didn't actually use ah_newID, backup si_newprefID.
             if (aff_todo == 0 && !did_postpone_prefix) {
-              --spin->si_newprefID;
+              spin->si_newprefID--;
               cur_aff->ah_newID = 0;
             }
           }
@@ -3068,7 +3068,7 @@ static void spell_free_aff(afffile_T *aff)
   // All this trouble to free the "ae_prog" items...
   for (ht = &aff->af_pref;; ht = &aff->af_suff) {
     todo = (int)ht->ht_used;
-    for (hi = ht->ht_array; todo > 0; ++hi) {
+    for (hi = ht->ht_array; todo > 0; hi++) {
       if (!HASHITEM_EMPTY(hi)) {
         todo--;
         ah = HI2AH(hi);
@@ -3434,7 +3434,7 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
   int use_condit;
 
   todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0 && retval == OK; ++hi) {
+  for (hi = ht->ht_array; todo > 0 && retval == OK; hi++) {
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
       ah = HI2AH(hi);
@@ -3540,8 +3540,8 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
 
                 // Combine the prefix IDs. Avoid adding the
                 // same ID twice.
-                for (i = 0; i < pfxlen; ++i) {
-                  for (j = 0; j < use_pfxlen; ++j) {
+                for (i = 0; i < pfxlen; i++) {
+                  for (j = 0; j < use_pfxlen; j++) {
                     if (pfxlist[i] == use_pfxlist[j]) {
                       break;
                     }
@@ -3562,9 +3562,8 @@ static int store_aff_word(spellinfo_T *spin, char_u *word, char_u *afflist, afff
                 // Combine the list of compound flags.
                 // Concatenate them to the prefix IDs list.
                 // Avoid adding the same ID twice.
-                for (i = pfxlen; pfxlist[i] != NUL; ++i) {
-                  for (j = use_pfxlen;
-                       use_pfxlist[j] != NUL; ++j) {
+                for (i = pfxlen; pfxlist[i] != NUL; i++) {
+                  for (j = use_pfxlen; use_pfxlist[j] != NUL; j++) {
                     if (pfxlist[i] == use_pfxlist[j]) {
                       break;
                     }
@@ -3858,7 +3857,7 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
     bl->sb_next = spin->si_blocks;
     spin->si_blocks = bl;
     bl->sb_used = 0;
-    ++spin->si_blocks_cnt;
+    spin->si_blocks_cnt++;
   }
 
   p = bl->sb_data + bl->sb_used;
@@ -3945,7 +3944,7 @@ static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, co
       break;
     }
   }
-  ++spin->si_foldwcount;
+  spin->si_foldwcount++;
 
   if (res == OK && (ct == WF_KEEPCAP || (flags & WF_KEEPCAP))) {
     for (const char_u *p = pfxlist; res == OK; p++) {
@@ -3957,7 +3956,7 @@ static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, co
         break;
       }
     }
-    ++spin->si_keepwcount;
+    spin->si_keepwcount++;
   }
   return res;
 }
@@ -3976,12 +3975,12 @@ static int tree_add_word(spellinfo_T *spin, char_u *word, wordnode_T *root, int
   int i;
 
   // Add each byte of the word to the tree, including the NUL at the end.
-  for (i = 0;; ++i) {
+  for (i = 0;; i++) {
     // When there is more than one reference to this node we need to make
     // a copy, so that we can modify it.  Copy the whole list of siblings
     // (we don't optimize for a partly shared list of siblings).
     if (node != NULL && node->wn_refs > 1) {
-      --node->wn_refs;
+      node->wn_refs--;
       copyprev = prev;
       for (copyp = node; copyp != NULL; copyp = copyp->wn_sibling) {
         // Allocate a new node and copy the info.
@@ -3991,7 +3990,7 @@ static int tree_add_word(spellinfo_T *spin, char_u *word, wordnode_T *root, int
         }
         np->wn_child = copyp->wn_child;
         if (np->wn_child != NULL) {
-          ++np->wn_child->wn_refs;              // child gets extra ref
+          np->wn_child->wn_refs++;              // child gets extra ref
         }
         np->wn_byte = copyp->wn_byte;
         if (np->wn_byte == NUL) {
@@ -4078,7 +4077,7 @@ static int tree_add_word(spellinfo_T *spin, char_u *word, wordnode_T *root, int
 #endif
 
   // count nr of words added since last message
-  ++spin->si_msg_count;
+  spin->si_msg_count++;
 
   if (spin->si_compress_cnt > 1) {
     if (--spin->si_compress_cnt == 1) {
@@ -4173,7 +4172,7 @@ static int deref_wordnode(spellinfo_T *spin, wordnode_T *node)
       free_wordnode(spin, np);
       cnt++;
     }
-    ++cnt;          // length field
+    cnt++;          // length field
   }
   return cnt;
 }
@@ -4185,7 +4184,7 @@ static void free_wordnode(spellinfo_T *spin, wordnode_T *n)
 {
   n->wn_child = spin->si_first_free;
   spin->si_first_free = n;
-  ++spin->si_free_count;
+  spin->si_free_count++;
 }
 
 // Compress a tree: find tails that are identical and can be shared.
@@ -4264,7 +4263,7 @@ static long node_compress(spellinfo_T *spin, wordnode_T *node, hashtab_T *ht, lo
             // Found one!  Now use that child in place of the
             // current one.  This means the current child and all
             // its siblings is unlinked from the tree.
-            ++tp->wn_refs;
+            tp->wn_refs++;
             compressed += deref_wordnode(spin, child);
             np->wn_child = tp;
             break;
@@ -4422,7 +4421,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
     put_bytes(fd, 1 + 128 + 2 + l, 4);                  // <sectionlen>
 
     fputc(128, fd);                                     // <charflagslen>
-    for (size_t i = 128; i < 256; ++i) {
+    for (size_t i = 128; i < 256; i++) {
       flags = 0;
       if (spelltab.st_isw[i]) {
         flags |= CF_WORD;
@@ -4466,7 +4465,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
   // round 1: SN_REP section
   // round 2: SN_SAL section (unless SN_SOFO is used)
   // round 3: SN_REPSAL section
-  for (unsigned int round = 1; round <= 3; ++round) {
+  for (unsigned int round = 1; round <= 3; round++) {
     garray_T *gap;
     if (round == 1) {
       gap = &spin->si_rep;
@@ -4500,13 +4499,13 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
     // Compute the length of what follows.
     size_t l = 2;  // count <repcount> or <salcount>
     assert(gap->ga_len >= 0);
-    for (size_t i = 0; i < (size_t)gap->ga_len; ++i) {
+    for (size_t i = 0; i < (size_t)gap->ga_len; i++) {
       fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
       l += 1 + STRLEN(ftp->ft_from);  // count <*fromlen> and <*from>
       l += 1 + STRLEN(ftp->ft_to);    // count <*tolen> and <*to>
     }
     if (round == 2) {
-      ++l;                            // count <salflags>
+      l++;                            // count <salflags>
     }
     put_bytes(fd, l, 4);                                // <sectionlen>
 
@@ -4525,11 +4524,11 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
     }
 
     put_bytes(fd, (uintmax_t)gap->ga_len, 2);    // <repcount> or <salcount>
-    for (size_t i = 0; i < (size_t)gap->ga_len; ++i) {
+    for (size_t i = 0; i < (size_t)gap->ga_len; i++) {
       // <rep> : <repfromlen> <repfrom> <reptolen> <repto>
       // <sal> : <salfromlen> <salfrom> <saltolen> <salto>
       fromto_T *ftp = &((fromto_T *)gap->ga_data)[i];
-      for (unsigned int rr = 1; rr <= 2; ++rr) {
+      for (unsigned int rr = 1; rr <= 2; rr++) {
         char_u *p = rr == 1 ? ftp->ft_from : ftp->ft_to;
         l = STRLEN(p);
         assert(l < INT_MAX);
@@ -4566,13 +4565,13 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
 
     // round 1: count the bytes
     // round 2: write the bytes
-    for (unsigned int round = 1; round <= 2; ++round) {
+    for (unsigned int round = 1; round <= 2; round++) {
       size_t todo;
       size_t len = 0;
       hashitem_T *hi;
 
       todo = spin->si_commonwords.ht_used;
-      for (hi = spin->si_commonwords.ht_array; todo > 0; ++hi) {
+      for (hi = spin->si_commonwords.ht_array; todo > 0; hi++) {
         if (!HASHITEM_EMPTY(hi)) {
           size_t l = STRLEN(hi->hi_key) + 1;
           len += l;
@@ -4689,7 +4688,7 @@ static int write_vim_spell(spellinfo_T *spin, char_u *fname)
 
   // <LWORDTREE>  <KWORDTREE>  <PREFIXTREE>
   spin->si_memtot = 0;
-  for (unsigned int round = 1; round <= 3; ++round) {
+  for (unsigned int round = 1; round <= 3; round++) {
     wordnode_T *tree;
     if (round == 1) {
       tree = spin->si_foldroot->wn_sibling;
@@ -5015,7 +5014,7 @@ static int sug_filltree(spellinfo_T *spin, slang_T *slang)
     } else {
       // Do one more byte at this node.
       n = arridx[depth] + curi[depth];
-      ++curi[depth];
+      curi[depth]++;
 
       c = byts[n];
       if (c == 0) {
@@ -5233,7 +5232,7 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
   assert(wcount >= 0);
   put_bytes(fd, (uintmax_t)wcount, 4);                  // <sugwcount>
 
-  for (linenr_T lnum = 1; lnum <= wcount; ++lnum) {
+  for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
     // <sugline>: <sugnr> ... NUL
     char_u *line = ml_get_buf(spin->si_spellbuf, lnum, false);
     size_t len = STRLEN(line) + 1;
@@ -5355,7 +5354,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
     // Init the aff and dic pointers.
     // Get the region names if there are more than 2 arguments.
-    for (i = 0; i < incount; ++i) {
+    for (i = 0; i < incount; i++) {
       afile[i] = NULL;
 
       if (incount > 1) {
@@ -5387,7 +5386,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
     // Read all the .aff and .dic files.
     // Text is converted to 'encoding'.
     // Words are stored in the case-folded and keep-case trees.
-    for (i = 0; i < incount && !error; ++i) {
+    for (i = 0; i < incount && !error; i++) {
       spin.si_conv.vc_type = CONV_NONE;
       spin.si_region = 1 << i;
 
@@ -5459,7 +5458,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
     hash_clear_all(&spin.si_commonwords, 0);
 
     // Free the .aff file structures.
-    for (i = 0; i < incount; ++i) {
+    for (i = 0; i < incount; i++) {
       if (afile[i] != NULL) {
         spell_free_aff(afile[i]);
       }
@@ -5759,7 +5758,7 @@ static void set_spell_charflags(char_u *flags, int cnt, char_u *fol)
 
   clear_spell_chartab(&new_st);
 
-  for (i = 0; i < 128; ++i) {
+  for (i = 0; i < 128; i++) {
     if (i < cnt) {
       new_st.st_isw[i + 128] = (flags[i] & CF_WORD) != 0;
       new_st.st_isu[i + 128] = (flags[i] & CF_UPPER) != 0;
@@ -5783,7 +5782,7 @@ static int set_spell_finish(spelltab_T *new_st)
 
   if (did_set_spelltab) {
     // check that it's the same table
-    for (i = 0; i < 256; ++i) {
+    for (i = 0; i < 256; i++) {
       if (spelltab.st_isw[i] != new_st->st_isw[i]
           || spelltab.st_isu[i] != new_st->st_isu[i]
           || spelltab.st_fold[i] != new_st->st_fold[i]
@@ -5846,7 +5845,7 @@ static void set_map_str(slang_T *lp, char_u *map)
   lp->sl_has_map = true;
 
   // Init the array and hash tables empty.
-  for (i = 0; i < 256; ++i) {
+  for (i = 0; i < 256; i++) {
     lp->sl_map_array[i] = 0;
   }
   hash_init(&lp->sl_map_hash);
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index b4a9bed437..ffce859ee8 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -3100,7 +3100,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword,
     // being replaced "thes," -> "these" is a different suggestion from
     // "thes" -> "these".
     stp = &SUG(*gap, 0);
-    for (i = gap->ga_len; --i >= 0; ++stp) {
+    for (i = gap->ga_len; --i >= 0; stp++) {
       if (stp->st_wordlen == goodlen
           && stp->st_orglen == badlen
           && STRNCMP(stp->st_word, goodword, goodlen) == 0) {
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 78312c738c..ac9d414be2 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -107,7 +107,7 @@ char_u *vim_strsave_escaped_ext(const char_u *string, const char_u *esc_chars, c
     if (vim_strchr((char *)esc_chars, *p) != NULL || (bsl && rem_backslash(p))) {
       length++;                         // count a backslash
     }
-    ++length;                           // count an ordinary char
+    length++;                           // count an ordinary char
   }
 
   char_u *escaped_string = xmalloc(length);
@@ -222,13 +222,13 @@ char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_n
     }
     if ((*p == '\n' && (csh_like || do_newline))
         || (*p == '!' && (csh_like || do_special))) {
-      ++length;                         // insert backslash
+      length++;                         // insert backslash
       if (csh_like && do_special) {
-        ++length;                       // insert backslash
+        length++;                       // insert backslash
       }
     }
     if (do_special && find_cmdline_var(p, &l) >= 0) {
-      ++length;                         // insert backslash
+      length++;                         // insert backslash
       p += l - 1;
     }
     if (*p == '\\' && fish_like) {
@@ -516,7 +516,7 @@ bool has_non_ascii(const char_u *s)
   const char_u *p;
 
   if (s != NULL) {
-    for (p = s; *p != NUL; ++p) {
+    for (p = s; *p != NUL; p++) {
       if (*p >= 128) {
         return true;
       }
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 0fa93b87a1..7794499582 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -609,7 +609,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     /*
      * Skip lines that end in a backslash.
      */
-    for (; start_lnum > 1; --start_lnum) {
+    for (; start_lnum > 1; start_lnum--) {
       line = ml_get(start_lnum - 1);
       if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
         break;
@@ -687,7 +687,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
        */
       validate_current_state();
 
-      for (current_lnum = lnum; current_lnum < end_lnum; ++current_lnum) {
+      for (current_lnum = lnum; current_lnum < end_lnum; current_lnum++) {
         syn_start_line();
         for (;;) {
           had_sync_point = syn_finish_line(true);
@@ -894,7 +894,7 @@ static void syn_update_ends(bool startofline)
    */
   int i = current_state.ga_len - 1;
   if (keepend_level >= 0) {
-    for (; i > keepend_level; --i) {
+    for (; i > keepend_level; i--) {
       if (CUR_STATE(i).si_flags & HL_EXTEND) {
         break;
       }
@@ -1186,7 +1186,7 @@ static void syn_stack_free_entry(synblock_T *block, synstate_T *p)
   clear_syn_state(p);
   p->sst_next = block->b_sst_firstfree;
   block->b_sst_firstfree = p;
-  ++block->b_sst_freecount;
+  block->b_sst_freecount++;
 }
 
 /*
@@ -1225,7 +1225,7 @@ static synstate_T *store_current_state(void)
    * If the current state contains a start or end pattern that continues
    * from the previous line, we can't use it.  Don't store it then.
    */
-  for (i = current_state.ga_len - 1; i >= 0; --i) {
+  for (i = current_state.ga_len - 1; i >= 0; i--) {
     cur_si = &CUR_STATE(i);
     if (cur_si->si_h_startpos.lnum >= current_lnum
         || cur_si->si_m_endpos.lnum >= current_lnum
@@ -1273,7 +1273,7 @@ static synstate_T *store_current_state(void)
       // list, after *sp
       p = syn_block->b_sst_firstfree;
       syn_block->b_sst_firstfree = p->sst_next;
-      --syn_block->b_sst_freecount;
+      syn_block->b_sst_freecount--;
       if (sp == NULL) {
         // Insert in front of the list
         p->sst_next = syn_block->b_sst_first;
@@ -1302,7 +1302,7 @@ static synstate_T *store_current_state(void)
     } else {
       bp = sp->sst_union.sst_stack;
     }
-    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_flags = (int)CUR_STATE(i).si_flags;
       bp[i].bs_seqnr = CUR_STATE(i).si_seqnr;
@@ -1336,7 +1336,7 @@ static void load_current_state(synstate_T *from)
     } else {
       bp = from->sst_union.sst_stack;
     }
-    for (i = 0; i < from->sst_stacksize; ++i) {
+    for (i = 0; i < from->sst_stacksize; i++) {
       CUR_STATE(i).si_idx = bp[i].bs_idx;
       CUR_STATE(i).si_flags = bp[i].bs_flags;
       CUR_STATE(i).si_seqnr = bp[i].bs_seqnr;
@@ -2024,7 +2024,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   current_flags = 0;
   current_seqnr = 0;
   if (cur_si != NULL) {
-    for (int idx = current_state.ga_len - 1; idx >= 0; --idx) {
+    for (int idx = current_state.ga_len - 1; idx >= 0; idx--) {
       sip = &CUR_STATE(idx);
       if ((current_lnum > sip->si_h_startpos.lnum
            || (current_lnum == sip->si_h_startpos.lnum
@@ -2406,7 +2406,7 @@ static void check_keepend(void)
    * won't do anything.  If there is no "extend" item "i" will be
    * "keepend_level" and all "keepend" items will work normally.
    */
-  for (i = current_state.ga_len - 1; i > keepend_level; --i) {
+  for (i = current_state.ga_len - 1; i > keepend_level; i--) {
     if (CUR_STATE(i).si_flags & HL_EXTEND) {
       break;
     }
@@ -2416,7 +2416,7 @@ static void check_keepend(void)
   maxpos.col = 0;
   maxpos_h.lnum = 0;
   maxpos_h.col = 0;
-  for (; i < current_state.ga_len; ++i) {
+  for (; i < current_state.ga_len; i++) {
     sip = &CUR_STATE(i);
     if (maxpos.lnum != 0) {
       limit_pos_zero(&sip->si_m_endpos, &maxpos);
@@ -2519,7 +2519,7 @@ static void pop_current_state(void)
 {
   if (!GA_EMPTY(&current_state)) {
     unref_extmatch(CUR_STATE(current_state.ga_len - 1).si_extmatch);
-    --current_state.ga_len;
+    current_state.ga_len--;
   }
   // after the end of a pattern, try matching a keyword or pattern
   next_match_idx = -1;
@@ -2613,7 +2613,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
      * Find end pattern that matches first after "matchcol".
      */
     best_idx = -1;
-    for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; ++idx) {
+    for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; idx++) {
       int lc_col = matchcol;
 
       spp = &(SYN_ITEMS(syn_block)[idx]);
@@ -2916,9 +2916,9 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
     if (profile_cmp(pt, st->slowest) < 0) {
       st->slowest = pt;
     }
-    ++st->count;
+    st->count++;
     if (r > 0) {
-      ++st->match;
+      st->match++;
     }
   }
   if (timed_out && !syn_win->w_s->b_syn_slow) {
@@ -3282,7 +3282,7 @@ static void syn_remove_pattern(synblock_T *block, int idx)
 
   spp = &(SYN_ITEMS(block)[idx]);
   if (spp->sp_flags & HL_FOLD) {
-    --block->b_syn_folditems;
+    block->b_syn_folditems--;
   }
   syn_clear_pattern(block, idx);
   memmove(spp, spp + 1, sizeof(synpat_T) * (size_t)(block->b_syn_patterns.ga_len - idx - 1));
@@ -3526,7 +3526,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
     for (int id = 1; id <= highlight_num_groups() && !got_int; id++) {
       syn_list_one(id, syncing, false);
     }
-    for (int id = 0; id < curwin->w_s->b_syn_clusters.ga_len && !got_int; ++id) {
+    for (int id = 0; id < curwin->w_s->b_syn_clusters.ga_len && !got_int; id++) {
       syn_list_cluster(id);
     }
   } else {
@@ -3702,7 +3702,7 @@ static void syn_list_flags(struct name_list *nlist, int flags, int attr)
 {
   int i;
 
-  for (i = 0; nlist[i].flag != 0; ++i) {
+  for (i = 0; nlist[i].flag != 0; i++) {
     if (flags & nlist[i].flag) {
       msg_puts_attr(nlist[i].name, attr);
       msg_putchar(' ');
@@ -3925,7 +3925,7 @@ static void syn_clear_keyword(int id, hashtab_T *ht)
 
   hash_lock(ht);
   todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0; ++hi) {
+  for (hi = ht->ht_array; todo > 0; hi++) {
     if (HASHITEM_EMPTY(hi)) {
       continue;
     }
@@ -3967,7 +3967,7 @@ static void clear_keywtab(hashtab_T *ht)
   keyentry_T *kp_next;
 
   todo = (int)ht->ht_used;
-  for (hi = ht->ht_array; todo > 0; ++hi) {
+  for (hi = ht->ht_array; todo > 0; hi++) {
     if (!HASHITEM_EMPTY(hi)) {
       todo--;
       for (kp = HI2KE(hi); kp != NULL; kp = kp_next) {
@@ -4120,7 +4120,7 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
     for (fidx = ARRAY_SIZE(flagtab); --fidx >= 0;) {
       p = flagtab[fidx].name;
       int i;
-      for (i = 0, len = 0; p[i] != NUL; i += 2, ++len) {
+      for (i = 0, len = 0; p[i] != NUL; i += 2, len++) {
         if (arg[len] != (char_u)p[i] && arg[len] != (char_u)p[i + 1]) {
           break;
         }
@@ -4499,7 +4499,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
           curwin->w_s->b_syn_sync_flags |= SF_MATCH;
         }
         if (syn_opt_arg.flags & HL_FOLD) {
-          ++curwin->w_s->b_syn_folditems;
+          curwin->w_s->b_syn_folditems++;
         }
 
         redraw_curbuf_later(UPD_SOME_VALID);
@@ -4686,7 +4686,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
          * Store the start/skip/end in the syn_items list
          */
         int idx = curwin->w_s->b_syn_patterns.ga_len;
-        for (item = ITEM_START; item <= ITEM_END; ++item) {
+        for (item = ITEM_START; item <= ITEM_END; item++) {
           for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next) {
             SYN_ITEMS(curwin->w_s)[idx] = *(ppp->pp_synp);
             SYN_ITEMS(curwin->w_s)[idx].sp_syncing = syncing;
@@ -4713,7 +4713,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
             curwin->w_s->b_syn_patterns.ga_len++;
             idx++;
             if (syn_opt_arg.flags & HL_FOLD) {
-              ++curwin->w_s->b_syn_folditems;
+              curwin->w_s->b_syn_folditems++;
             }
           }
         }
@@ -4728,7 +4728,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
   /*
    * Free the allocated memory.
    */
-  for (item = ITEM_START; item <= ITEM_END; ++item) {
+  for (item = ITEM_START; item <= ITEM_END; item++) {
     for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next) {
       if (!success && ppp->pp_synp != NULL) {
         vim_regfree(ppp->pp_synp->sp_prog);
@@ -5927,7 +5927,7 @@ static void syntime_clear(void)
     msg(_(msg_no_items));
     return;
   }
-  for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; ++idx) {
+  for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; idx++) {
     spp = &(SYN_ITEMS(curwin->w_s)[idx]);
     syn_clear_time(&spp->sp_time);
   }
@@ -5976,7 +5976,7 @@ static void syntime_report(void)
   proftime_T total_total = profile_zero();
   int total_count = 0;
   time_entry_T *p;
-  for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; ++idx) {
+  for (int idx = 0; idx < curwin->w_s->b_syn_patterns.ga_len; idx++) {
     synpat_T *spp = &(SYN_ITEMS(curwin->w_s)[idx]);
     if (spp->sp_time.count > 0) {
       p = GA_APPEND_VIA_PTR(time_entry_T, &ga);
@@ -6002,7 +6002,7 @@ static void syntime_report(void)
 
   msg_puts_title(_("  TOTAL      COUNT  MATCH   SLOWEST     AVERAGE   NAME               PATTERN"));
   msg_puts("\n");
-  for (int idx = 0; idx < ga.ga_len && !got_int; ++idx) {
+  for (int idx = 0; idx < ga.ga_len && !got_int; idx++) {
     p = ((time_entry_T *)ga.ga_data) + idx;
 
     msg_puts(profile_msg(p->total));
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 3c569ed7b8..7401e73e84 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1036,7 +1036,7 @@ void do_tags(exarg_T *eap)
 
   // Highlight title
   msg_puts_title(_("\n  # TO tag         FROM line  in file/text"));
-  for (i = 0; i < tagstacklen; ++i) {
+  for (i = 0; i < tagstacklen; i++) {
     if (tagstack[i].tagname != NULL) {
       name = fm_getname(&(tagstack[i].fmark), 30);
       if (name == NULL) {           // file name not available
@@ -1555,7 +1555,7 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
   }
   orgpat.regmatch.rm_ic = ((p_ic || !noic)
                            && (findall || orgpat.headlen == 0 || !p_tbs));
-  for (round = 1; round <= 2; ++round) {
+  for (round = 1; round <= 2; round++) {
     linear = (orgpat.headlen == 0 || !p_tbs || round == 2);
 
     // Try tag file names from tags option one by one.
@@ -1601,7 +1601,7 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
             help_pri = 0;
           } else {
             help_pri = 1;
-            for (s = p_hlg; *s != NUL; ++s) {
+            for (s = p_hlg; *s != NUL; s++) {
               if (STRNICMP(s, help_lang, 2) == 0) {
                 break;
               }
@@ -2366,7 +2366,7 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
       if (tnp->tn_hf_idx > tag_fnames.ga_len || *p_hf == NUL) {
         return FAIL;
       }
-      ++tnp->tn_hf_idx;
+      tnp->tn_hf_idx++;
       STRCPY(buf, p_hf);
       STRCPY(path_tail((char *)buf), "tags");
 #ifdef BACKSLASH_IN_FILENAME
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 9f3d5bd1e8..e2e0bb38a2 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -2305,7 +2305,7 @@ static void u_undoredo(int undo, bool do_buf_event)
       // delete backwards, it goes faster in most cases
       long i;
       linenr_T lnum;
-      for (lnum = bot - 1, i = oldsize; --i >= 0; --lnum) {
+      for (lnum = bot - 1, i = oldsize; --i >= 0; lnum--) {
         // what can we do when we run out of memory?
         newarray[i] = u_save_line(lnum);
         // remember we deleted the last line in the buffer, and a
diff --git a/src/nvim/version.c b/src/nvim/version.c
index 0667243bc3..34ded3460f 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2256,7 +2256,7 @@ void intro_message(int colon)
   row = blanklines / 2;
 
   if (((row >= 2) && (Columns >= 50)) || colon) {
-    for (i = 0; i < (int)ARRAY_SIZE(lines); ++i) {
+    for (i = 0; i < (int)ARRAY_SIZE(lines); i++) {
       p = lines[i];
 
       if (sponsor != 0) {
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 7ad5e49d2f..2a944e7d1d 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -1597,7 +1597,7 @@ static void win_init_some(win_T *newp, win_T *oldp)
 {
   // Use the same argument list.
   newp->w_alist = oldp->w_alist;
-  ++newp->w_alist->al_refcount;
+  newp->w_alist->al_refcount++;
   newp->w_arg_idx = oldp->w_arg_idx;
 
   // copy options from existing window
@@ -1723,7 +1723,7 @@ int make_windows(int count, bool vertical)
   block_autocmds();
 
   // todo is number of windows left to create
-  for (todo = count - 1; todo > 0; --todo) {
+  for (todo = count - 1; todo > 0; todo--) {
     if (vertical) {
       if (win_split(curwin->w_width - (curwin->w_width - todo)
                     / (todo + 1) - 1, WSP_VERT | WSP_ABOVE) == FAIL) {
@@ -2200,7 +2200,7 @@ static void win_equal_rec(win_T *next_curwin, bool current, frame_T *topfr, int
       }
 
       if (has_next_curwin) {
-        --totwincount;                  // don't count curwin
+        totwincount--;                  // don't count curwin
       }
     }
 
@@ -2330,7 +2330,7 @@ static void win_equal_rec(win_T *next_curwin, bool current, frame_T *topfr, int
       }
 
       if (has_next_curwin) {
-        --totwincount;                  // don't count curwin
+        totwincount--;                  // don't count curwin
       }
     }
 
@@ -3695,7 +3695,7 @@ static void frame_add_vsep(const frame_T *frp)
     wp = frp->fr_win;
     if (wp->w_vsep_width == 0) {
       if (wp->w_width > 0) {            // don't make it negative
-        --wp->w_width;
+        wp->w_width--;
       }
       wp->w_vsep_width = 1;
     }
@@ -4037,7 +4037,7 @@ void free_tabpage(tabpage_T *tp)
 
   pmap_del(handle_T)(&tabpage_handles, tp->handle);
   diff_clear(tp);
-  for (idx = 0; idx < SNAP_COUNT; ++idx) {
+  for (idx = 0; idx < SNAP_COUNT; idx++) {
     clear_snapshot(tp, idx);
   }
   vars_clear(&tp->tp_vars->dv_hashtab);         // free all t: variables
@@ -4173,7 +4173,7 @@ int make_tabpages(int maxcount)
    */
   block_autocmds();
 
-  for (todo = count - 1; todo > 0; --todo) {
+  for (todo = count - 1; todo > 0; todo--) {
     if (win_new_tabpage(0, NULL) == FAIL) {
       break;
     }
@@ -4440,7 +4440,7 @@ void goto_tabpage(int n)
     // "gT": go to previous tab page, wrap around end.  "N gT" repeats
     // this N times.
     ttp = curtab;
-    for (i = n; i < 0; ++i) {
+    for (i = n; i < 0; i++) {
       for (tp = first_tabpage; tp->tp_next != ttp && tp->tp_next != NULL;
            tp = tp->tp_next) {}
       ttp = tp;
@@ -5596,7 +5596,7 @@ static void frame_setheight(frame_T *curfrp, int height)
      * 2: compute the room available and adjust the height to it.
      * Try not to reduce the height of a window with 'winfixheight' set.
      */
-    for (run = 1; run <= 2; ++run) {
+    for (run = 1; run <= 2; run++) {
       room = 0;
       room_reserved = 0;
       FOR_ALL_FRAMES(frp, curfrp->fr_parent->fr_child) {
@@ -5669,7 +5669,7 @@ static void frame_setheight(frame_T *curfrp, int height)
      * that is not enough, takes lines from frames above the current
      * frame.
      */
-    for (run = 0; run < 2; ++run) {
+    for (run = 0; run < 2; run++) {
       if (run == 0) {
         frp = curfrp->fr_next;          // 1st run: start with next window
       } else {
@@ -5788,7 +5788,7 @@ static void frame_setwidth(frame_T *curfrp, int width)
      *    containing frame.
      * 2: compute the room available and adjust the width to it.
      */
-    for (run = 1; run <= 2; ++run) {
+    for (run = 1; run <= 2; run++) {
       room = 0;
       room_reserved = 0;
       FOR_ALL_FRAMES(frp, curfrp->fr_parent->fr_child) {
@@ -5841,7 +5841,7 @@ static void frame_setwidth(frame_T *curfrp, int width)
      * that is not enough, takes lines from frames left of the current
      * frame.
      */
-    for (run = 0; run < 2; ++run) {
+    for (run = 0; run < 2; run++) {
       if (run == 0) {
         frp = curfrp->fr_next;          // 1st run: start with next window
       } else {
-- 
cgit 


From cd2d3aa48f3531103a3a355d76394301e7b074df Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 20:23:29 +0800
Subject: vim-patch:9.0.0261: bufload() reads a file even if the name is not a
 file name (#19944)

Problem:    bufload() reads a file even if the name is not a file name. (Cyker
            Way)
Solution:   Do not read the file when the buffer name is not a file name.
            (closes vim/vim#10975)
https://github.com/vim/vim/commit/2eddbacd6dc17c84e4bdc41e60e81949a36bb973
---
 src/nvim/buffer.c                   | 3 ++-
 src/nvim/testdir/test_functions.vim | 7 +++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index cc7f650265..d0afaebad9 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -224,7 +224,8 @@ int open_buffer(int read_stdin, exarg_T *eap, int flags)
   // mark cursor position as being invalid
   curwin->w_valid = 0;
 
-  if (curbuf->b_ffname != NULL) {
+  // Read the file if there is one.
+  if (curbuf->b_ffname != NULL && !bt_quickfix(curbuf) && !bt_nofilename(curbuf)) {
 #ifdef UNIX
     int save_bin = curbuf->b_p_bin;
     int perm;
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index b024df5a45..b1f617ceda 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -1880,6 +1880,13 @@ func Test_bufadd_bufload()
   exe 'bwipe ' .. buf2
   call assert_equal(0, bufexists(buf2))
 
+  " when 'buftype' is "nofile" then bufload() does not read the file
+  bwipe! XotherName
+  let buf = bufadd('XotherName')
+  call setbufvar(buf, '&bt', 'nofile')
+  call bufload(buf)
+  call assert_equal([''], getbufline(buf, 1, '$'))
+
   bwipe someName
   bwipe XotherName
   call assert_equal(0, bufexists('someName'))
-- 
cgit 


From 4ecea0e001533d68f3032fe0512fc55360f295c0 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 19:35:17 +0800
Subject: vim-patch:8.2.0911: crash when opening a buffer for the cmdline
 window fails

Problem:    Crash when opening a buffer for the cmdline window fails. (Chris
            Barber)
Solution:   Check do_ecmd() succeeds.  Reset got_int if "q" was used at the
            more prompt. (closes vim/vim#6211)
https://github.com/vim/vim/commit/9b7cce28d568f0622d77c6c9878c2d4770c3b164

Make code match latest Vim instead.
---
 src/nvim/buffer.c                 |  9 +++++++--
 src/nvim/ex_getln.c               | 16 +++++++++++++---
 src/nvim/testdir/test_cmdline.vim | 27 +++++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index d0afaebad9..03b4c1bae8 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -4184,9 +4184,13 @@ void wipe_buffer(buf_T *buf, bool aucmd)
 /// @param bufnr     Buffer to switch to, or 0 to create a new buffer.
 ///
 /// @see curbufIsChanged()
-void buf_open_scratch(handle_T bufnr, char *bufname)
+///
+/// @return  FAIL for failure, OK otherwise
+int buf_open_scratch(handle_T bufnr, char *bufname)
 {
-  (void)do_ecmd((int)bufnr, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, NULL);
+  if (do_ecmd((int)bufnr, NULL, NULL, NULL, ECMD_ONE, ECMD_HIDE, NULL) == FAIL) {
+    return FAIL;
+  }
   apply_autocmds(EVENT_BUFFILEPRE, NULL, NULL, false, curbuf);
   (void)setfname(curbuf, bufname, NULL, true);
   apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, curbuf);
@@ -4194,4 +4198,5 @@ void buf_open_scratch(handle_T bufnr, char *bufname)
   set_option_value_give_err("bt", 0L, "nofile", OPT_LOCAL);
   set_option_value_give_err("swf", 0L, NULL, OPT_LOCAL);
   RESET_BINDING(curwin);
+  return OK;
 }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index afec21a86f..ce4930d33e 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -4073,17 +4073,27 @@ static int open_cmdwin(void)
     ga_clear(&winsizes);
     return K_IGNORE;
   }
+  // Don't let quitting the More prompt make this fail.
+  got_int = false;
+
+  // Set "cmdwin_type" before any autocommands may mess things up.
   cmdwin_type = get_cmdline_type();
   cmdwin_level = ccline.level;
 
   // Create empty command-line buffer.
-  buf_open_scratch(0, _("[Command Line]"));
+  if (buf_open_scratch(0, _("[Command Line]")) == FAIL) {
+    // Some autocommand messed it up?
+    win_close(curwin, true, false);
+    ga_clear(&winsizes);
+    cmdwin_type = 0;
+    return Ctrl_C;
+  }
   // Command-line buffer has bufhidden=wipe, unlike a true "scratch" buffer.
   set_option_value_give_err("bh", 0L, "wipe", OPT_LOCAL);
-  curwin->w_p_rl = cmdmsg_rl;
-  cmdmsg_rl = false;
   curbuf->b_p_ma = true;
   curwin->w_p_fen = false;
+  curwin->w_p_rl = cmdmsg_rl;
+  cmdmsg_rl = false;
 
   // Don't allow switching to another buffer.
   curbuf->b_ro_locked++;
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index b7c6c1e4d1..e136bd7af0 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -1453,6 +1453,33 @@ func Test_cmdwin_tabpage()
   tabclose!
 endfunc
 
+func Test_cmdwin_interrupted()
+  CheckScreendump
+
+  " aborting the :smile output caused the cmdline window to use the current
+  " buffer.
+  let lines =<< trim [SCRIPT]
+    au WinNew * smile
+  [SCRIPT]
+  call writefile(lines, 'XTest_cmdwin')
+
+  let buf = RunVimInTerminal('-S XTest_cmdwin', {'rows': 18})
+  call TermWait(buf, 1000)
+  " open cmdwin
+  call term_sendkeys(buf, "q:")
+  call TermWait(buf, 500)
+  " quit more prompt for :smile command
+  call term_sendkeys(buf, "q")
+  call TermWait(buf, 500)
+  " execute a simple command
+  call term_sendkeys(buf, "aecho 'done'\<CR>")
+  call VerifyScreenDump(buf, 'Test_cmdwin_interrupted', {})
+
+  " clean up
+  call StopVimInTerminal(buf)
+  call delete('XTest_cmdwin')
+endfunc
+
 " Test for backtick expression in the command line
 func Test_cmd_backtick()
   CheckNotMSWindows  " FIXME: see #19297
-- 
cgit 


From 22536eb527e4e42ce5dfbf562678ebd060ae6988 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 25 Aug 2022 20:44:18 +0800
Subject: vim-patch:8.2.0923: cmdline test is slow

Problem:    Cmdline test is slow.
Solution:   Use WaitForAssert().
https://github.com/vim/vim/commit/c82dd86084581afa5113b0dd9ade7a631b89b4fc
---
 src/nvim/testdir/test_cmdline.vim | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index e136bd7af0..84dc361529 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -3,6 +3,7 @@
 source check.vim
 source screendump.vim
 source view_util.vim
+source shared.vim
 
 func Test_complete_tab()
   call writefile(['testfile'], 'Xtestfile')
@@ -1464,13 +1465,12 @@ func Test_cmdwin_interrupted()
   call writefile(lines, 'XTest_cmdwin')
 
   let buf = RunVimInTerminal('-S XTest_cmdwin', {'rows': 18})
-  call TermWait(buf, 1000)
   " open cmdwin
   call term_sendkeys(buf, "q:")
-  call TermWait(buf, 500)
+  call WaitForAssert({-> assert_match('-- More --', term_getline(buf, 18))})
   " quit more prompt for :smile command
   call term_sendkeys(buf, "q")
-  call TermWait(buf, 500)
+  call WaitForAssert({-> assert_match('^$', term_getline(buf, 18))})
   " execute a simple command
   call term_sendkeys(buf, "aecho 'done'\<CR>")
   call VerifyScreenDump(buf, 'Test_cmdwin_interrupted', {})
-- 
cgit 


From a577fb778addb6eb305ade82a229b52673ced234 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sat, 30 Apr 2022 20:54:25 +0200
Subject: feat(treesitter): upstream get_named_children() as a node method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 954c3410d3..2ef4d6052c 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -88,6 +88,7 @@ static struct luaL_Reg node_meta[] = {
   { "prev_sibling", node_prev_sibling },
   { "next_named_sibling", node_next_named_sibling },
   { "prev_named_sibling", node_prev_named_sibling },
+  { "named_children", node_named_children },
   { NULL, NULL }
 };
 
@@ -1062,6 +1063,31 @@ static int node_prev_named_sibling(lua_State *L)
   return 1;
 }
 
+static int node_named_children(lua_State *L)
+{
+  TSNode source;
+  if (!node_check(L, 1, &source)) {
+    return 0;
+  }
+  TSTreeCursor cursor = ts_tree_cursor_new(source);
+
+  lua_newtable(L);
+  int curr_index = 0;
+
+  if (ts_tree_cursor_goto_first_child(&cursor)) {
+    do {
+      TSNode node = ts_tree_cursor_current_node(&cursor);
+      if (ts_node_is_named(node)) {
+        push_node(L, node, 1);
+        lua_rawseti(L, -2, ++curr_index);
+      }
+    } while (ts_tree_cursor_goto_next_sibling(&cursor));
+  }
+
+  ts_tree_cursor_delete(&cursor);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
-- 
cgit 


From baba43681e792db30318bdedc3e73e4fe12482a6 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sun, 1 May 2022 11:35:12 +0200
Subject: feat(treesitter): upstream get_root_for_node() as a node method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 2ef4d6052c..083042ad98 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -89,6 +89,8 @@ static struct luaL_Reg node_meta[] = {
   { "next_named_sibling", node_next_named_sibling },
   { "prev_named_sibling", node_prev_named_sibling },
   { "named_children", node_named_children },
+  { "root", node_root },
+
   { NULL, NULL }
 };
 
@@ -1088,6 +1090,27 @@ static int node_named_children(lua_State *L)
   return 1;
 }
 
+static int node_root(lua_State *L)
+{
+  TSNode parent;
+  TSNode result;
+
+  TSNode node;
+  if (!node_check(L, 1, &node)) {
+    return 0;
+  }
+  parent = node;
+  result = node;
+
+  while (!ts_node_is_null(parent)){
+    result = parent;
+    parent = ts_node_parent(result);
+  }
+
+  push_node(L, result, 1);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
-- 
cgit 


From f57341a4b69398ff0c58686e66c2f4138be164aa Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sun, 1 May 2022 21:13:47 +0200
Subject: feat(treesitter): upstream node_length() as a node method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 083042ad98..8803fd452c 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -90,6 +90,7 @@ static struct luaL_Reg node_meta[] = {
   { "prev_named_sibling", node_prev_named_sibling },
   { "named_children", node_named_children },
   { "root", node_root },
+  { "byte_length", node_byte_length },
 
   { NULL, NULL }
 };
@@ -1111,6 +1112,20 @@ static int node_root(lua_State *L)
   return 1;
 }
 
+static int node_byte_length(lua_State *L)
+{
+  TSNode node;
+  if (!node_check(L, 1, &node)) {
+    return 0;
+  }
+
+  uint32_t start_byte = ts_node_start_byte(node);
+  uint32_t end_byte = ts_node_end_byte(node);
+
+  lua_pushnumber(L, end_byte - start_byte);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
-- 
cgit 


From e5fe41198c57a746b282fdfcde5ccb7c5adad605 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 25 Aug 2022 18:24:56 +0200
Subject: fix(treesitter): more efficient node:root()

---
 src/nvim/lua/treesitter.c | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 8803fd452c..7ff4fbbff4 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -623,7 +623,7 @@ void push_tree(lua_State *L, TSTree *tree, bool do_copy)
   lua_setfenv(L, -2);  // [udata]
 }
 
-static TSTree **tree_check(lua_State *L, uint16_t index)
+static TSTree **tree_check(lua_State *L, int index)
 {
   TSTree **ud = luaL_checkudata(L, index, TS_META_TREE);
   return ud;
@@ -1093,22 +1093,13 @@ static int node_named_children(lua_State *L)
 
 static int node_root(lua_State *L)
 {
-  TSNode parent;
-  TSNode result;
-
   TSNode node;
   if (!node_check(L, 1, &node)) {
     return 0;
   }
-  parent = node;
-  result = node;
-
-  while (!ts_node_is_null(parent)){
-    result = parent;
-    parent = ts_node_parent(result);
-  }
 
-  push_node(L, result, 1);
+  TSNode root = ts_tree_root_node(node.tree);
+  push_node(L, root, 1);
   return 1;
 }
 
-- 
cgit 


From 40855b0143a864739a6037921e15699445dcf8a7 Mon Sep 17 00:00:00 2001
From: Dundar Goc <gocdundar@gmail.com>
Date: Sun, 31 Jul 2022 16:20:57 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/api/buffer.c         |   2 +-
 src/nvim/api/vim.c            |   4 +-
 src/nvim/arglist.c            |  22 ++---
 src/nvim/autocmd.c            |   4 +-
 src/nvim/buffer_defs.h        | 190 +++++++++++++++++++-------------------
 src/nvim/change.c             |  24 ++---
 src/nvim/charset.c            |   2 +-
 src/nvim/diff.c               |  18 ++--
 src/nvim/drawline.c           |   2 +-
 src/nvim/edit.c               |   8 +-
 src/nvim/eval.c               |   8 +-
 src/nvim/eval/funcs.c         |  18 ++--
 src/nvim/ex_cmds2.c           |   4 +-
 src/nvim/ex_docmd.c           |   6 +-
 src/nvim/ex_eval.c            |   2 +-
 src/nvim/ex_session.c         |   2 +-
 src/nvim/file_search.c        |   6 +-
 src/nvim/fileio.c             |   6 +-
 src/nvim/fold.c               |  24 ++---
 src/nvim/getchar.c            |  19 ++--
 src/nvim/globals.h            |   2 +-
 src/nvim/indent.c             |   8 +-
 src/nvim/indent_c.c           |   8 +-
 src/nvim/insexpand.c          |  28 +++---
 src/nvim/lua/executor.c       |   2 +-
 src/nvim/mapping.c            |  26 +++---
 src/nvim/mbyte.c              |   4 +-
 src/nvim/memline.c            |   2 +-
 src/nvim/msgpack_rpc/server.c |   2 +-
 src/nvim/normal.c             |  12 +--
 src/nvim/ops.c                |  25 +++--
 src/nvim/option.c             | 206 +++++++++++++++++++++---------------------
 src/nvim/optionstr.c          | 105 ++++++++++-----------
 src/nvim/os/shell.c           |   2 +-
 src/nvim/path.c               |  14 +--
 src/nvim/quickfix.c           |  22 ++---
 src/nvim/screen.c             |  20 ++--
 src/nvim/search.c             |  40 ++++----
 src/nvim/spell.c              |  16 ++--
 src/nvim/spellfile.c          |  16 ++--
 src/nvim/statusline.c         |   2 +-
 src/nvim/syntax.c             |  16 ++--
 src/nvim/tag.c                |  26 +++---
 src/nvim/terminal.c           |   4 +-
 src/nvim/testing.c            |   4 +-
 src/nvim/undo.c               |  10 +-
 src/nvim/version.c            |   6 +-
 src/nvim/window.c             |  28 +++---
 48 files changed, 504 insertions(+), 523 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 43027473a0..199650fc55 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -1031,7 +1031,7 @@ String nvim_buf_get_name(Buffer buffer, Arena *arena, Error *err)
     return rv;
   }
 
-  return cstr_as_string((char *)buf->b_ffname);
+  return cstr_as_string(buf->b_ffname);
 }
 
 /// Sets the full file name for a buffer
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 2fa0277df7..ca98aeb34a 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -2044,7 +2044,7 @@ Array nvim_get_mark(String name, Dictionary opts, Error *err)
   // Marks are from an open buffer it fnum is non zero
   if (mark->fmark.fnum != 0) {
     bufnr = mark->fmark.fnum;
-    filename = (char *)buflist_nr2name(bufnr, true, true);
+    filename = buflist_nr2name(bufnr, true, true);
     allocated = true;
     // Marks comes from shada
   } else {
@@ -2232,7 +2232,7 @@ Dictionary nvim_eval_statusline(String str, Dict(eval_statusline) *opts, Error *
 
     // If first character doesn't have a defined highlight,
     // add the default highlight at the beginning of the highlight list
-    if (hltab->start == NULL || ((char *)hltab->start - buf) != 0) {
+    if (hltab->start == NULL || (hltab->start - buf) != 0) {
       Dictionary hl_info = ARRAY_DICT_INIT;
       grpname = get_default_stl_hl(wp, use_winbar);
 
diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 4f940f2fa5..21aa5afbae 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -157,7 +157,7 @@ void alist_add(alist_T *al, char *fname, int set_fnum)
 #ifdef BACKSLASH_IN_FILENAME
   slash_adjust(fname);
 #endif
-  AARGLIST(al)[al->al_ga.ga_len].ae_fname = (char_u *)fname;
+  AARGLIST(al)[al->al_ga.ga_len].ae_fname = fname;
   if (set_fnum > 0) {
     AARGLIST(al)[al->al_ga.ga_len].ae_fnum =
       buflist_add(fname, BLN_LISTED | (set_fnum == 2 ? BLN_CURBUF : 0));
@@ -226,7 +226,7 @@ static char *do_one_arg(char *str)
 /// growarray "gap".
 static void get_arglist(garray_T *gap, char *str, int escaped)
 {
-  ga_init(gap, (int)sizeof(char_u *), 20);
+  ga_init(gap, (int)sizeof(char *), 20);
   while (*str != NUL) {
     GA_APPEND(char *, gap, str);
 
@@ -244,12 +244,12 @@ static void get_arglist(garray_T *gap, char *str, int escaped)
 /// "fnames[fcountp]".  When "wig" is true, removes files matching 'wildignore'.
 ///
 /// @return  FAIL or OK.
-int get_arglist_exp(char_u *str, int *fcountp, char ***fnamesp, bool wig)
+int get_arglist_exp(char *str, int *fcountp, char ***fnamesp, bool wig)
 {
   garray_T ga;
   int i;
 
-  get_arglist(&ga, (char *)str, true);
+  get_arglist(&ga, str, true);
 
   if (wig) {
     i = expand_wildcards(ga.ga_len, ga.ga_data,
@@ -297,7 +297,7 @@ static void alist_add_list(int count, char **files, int after, bool will_edit)
     }
     for (int i = 0; i < count; i++) {
       const int flags = BLN_LISTED | (will_edit ? BLN_CURBUF : 0);
-      ARGLIST[after + i].ae_fname = (char_u *)files[i];
+      ARGLIST[after + i].ae_fname = files[i];
       ARGLIST[after + i].ae_fnum = buflist_add(files[i], flags);
     }
     ALIST(curwin)->al_ga.ga_len += count;
@@ -377,7 +377,7 @@ static int do_arglist(char *str, int what, int after, bool will_edit)
       vim_regfree(regmatch.regprog);
       xfree(p);
       if (!didone) {
-        semsg(_(e_nomatch2), ((char_u **)new_ga.ga_data)[i]);
+        semsg(_(e_nomatch2), ((char **)new_ga.ga_data)[i]);
       }
     }
     ga_clear(&new_ga);
@@ -472,7 +472,7 @@ void ex_args(exarg_T *eap)
   } else if (eap->cmdidx == CMD_args) {
     // ":args": list arguments.
     if (ARGCOUNT > 0) {
-      char **items = xmalloc(sizeof(char_u *) * (size_t)ARGCOUNT);
+      char **items = xmalloc(sizeof(char *) * (size_t)ARGCOUNT);
       // Overwrite the command, for a short list there is no scrolling
       // required and no wait_return().
       gotocmdline(true);
@@ -489,10 +489,8 @@ void ex_args(exarg_T *eap)
     ga_grow(gap, GARGCOUNT);
     for (int i = 0; i < GARGCOUNT; i++) {
       if (GARGLIST[i].ae_fname != NULL) {
-        AARGLIST(curwin->w_alist)[gap->ga_len].ae_fname =
-          vim_strsave(GARGLIST[i].ae_fname);
-        AARGLIST(curwin->w_alist)[gap->ga_len].ae_fnum =
-          GARGLIST[i].ae_fnum;
+        AARGLIST(curwin->w_alist)[gap->ga_len].ae_fname = xstrdup(GARGLIST[i].ae_fname);
+        AARGLIST(curwin->w_alist)[gap->ga_len].ae_fnum = GARGLIST[i].ae_fnum;
         gap->ga_len++;
       }
     }
@@ -742,7 +740,7 @@ char *alist_name(aentry_T *aep)
   // Use the name from the associated buffer if it exists.
   bp = buflist_findnr(aep->ae_fnum);
   if (bp == NULL || bp->b_fname == NULL) {
-    return (char *)aep->ae_fname;
+    return aep->ae_fname;
   }
   return bp->b_fname;
 }
diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 50e873dc55..e970387456 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -1720,9 +1720,9 @@ bool apply_autocmds_group(event_T event, char *fname, char *fname_io, bool force
       fname = NULL;
     } else {
       if (event == EVENT_SYNTAX) {
-        fname = (char *)buf->b_p_syn;
+        fname = buf->b_p_syn;
       } else if (event == EVENT_FILETYPE) {
-        fname = (char *)buf->b_p_ft;
+        fname = buf->b_p_ft;
       } else {
         if (buf->b_sfname != NULL) {
           sfname = xstrdup(buf->b_sfname);
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index c56fd9e6a8..d7d680b0fd 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -116,11 +116,11 @@ typedef uint64_t disptick_T;  // display tick type
  * The taggy struct is used to store the information about a :tag command.
  */
 typedef struct taggy {
-  char_u *tagname;         // tag name
+  char *tagname;                // tag name
   fmark_T fmark;                // cursor position BEFORE ":tag"
   int cur_match;                // match number
   int cur_fnum;                 // buffer number used for cur_match
-  char_u *user_data;            // used with tagfunc
+  char *user_data;              // used with tagfunc
 } taggy_T;
 
 typedef struct buffblock buffblock_T;
@@ -131,7 +131,7 @@ typedef struct buffheader buffheader_T;
  */
 struct buffblock {
   buffblock_T *b_next;  // pointer to next buffblock
-  char_u b_str[1];      // contents (actually longer)
+  char b_str[1];        // contents (actually longer)
 };
 
 /*
@@ -159,39 +159,39 @@ typedef struct {
 #define w_p_arab w_onebuf_opt.wo_arab  // 'arabic'
   int wo_bri;
 #define w_p_bri w_onebuf_opt.wo_bri    // 'breakindent'
-  char_u *wo_briopt;
+  char *wo_briopt;
 #define w_p_briopt w_onebuf_opt.wo_briopt  // 'breakindentopt'
   int wo_diff;
 #define w_p_diff w_onebuf_opt.wo_diff  // 'diff'
-  char_u *wo_fdc;
+  char *wo_fdc;
 #define w_p_fdc w_onebuf_opt.wo_fdc    // 'foldcolumn'
-  char_u *wo_fdc_save;
+  char *wo_fdc_save;
 #define w_p_fdc_save w_onebuf_opt.wo_fdc_save  // 'fdc' saved for diff mode
   int wo_fen;
 #define w_p_fen w_onebuf_opt.wo_fen    // 'foldenable'
   int wo_fen_save;
   // 'foldenable' saved for diff mode
 #define w_p_fen_save w_onebuf_opt.wo_fen_save
-  char_u *wo_fdi;
+  char *wo_fdi;
 #define w_p_fdi w_onebuf_opt.wo_fdi    // 'foldignore'
   long wo_fdl;
 #define w_p_fdl w_onebuf_opt.wo_fdl    // 'foldlevel'
   long wo_fdl_save;
   // 'foldlevel' state saved for diff mode
 #define w_p_fdl_save w_onebuf_opt.wo_fdl_save
-  char_u *wo_fdm;
+  char *wo_fdm;
 #define w_p_fdm w_onebuf_opt.wo_fdm    // 'foldmethod'
-  char_u *wo_fdm_save;
+  char *wo_fdm_save;
 #define w_p_fdm_save w_onebuf_opt.wo_fdm_save  // 'fdm' saved for diff mode
   long wo_fml;
 #define w_p_fml w_onebuf_opt.wo_fml    // 'foldminlines'
   long wo_fdn;
 #define w_p_fdn w_onebuf_opt.wo_fdn    // 'foldnestmax'
-  char_u *wo_fde;
+  char *wo_fde;
 #define w_p_fde w_onebuf_opt.wo_fde    // 'foldexpr'
-  char_u *wo_fdt;
+  char *wo_fdt;
 #define w_p_fdt w_onebuf_opt.wo_fdt   // 'foldtext'
-  char_u *wo_fmr;
+  char *wo_fmr;
 #define w_p_fmr w_onebuf_opt.wo_fmr    // 'foldmarker'
   int wo_lbr;
 #define w_p_lbr w_onebuf_opt.wo_lbr    // 'linebreak'
@@ -201,7 +201,7 @@ typedef struct {
 #define w_p_nu w_onebuf_opt.wo_nu       // 'number'
   int wo_rnu;
 #define w_p_rnu w_onebuf_opt.wo_rnu     // 'relativenumber'
-  char_u *wo_ve;
+  char *wo_ve;
 #define w_p_ve w_onebuf_opt.wo_ve       // 'virtualedit'
   unsigned wo_ve_flags;
 #define w_ve_flags w_onebuf_opt.wo_ve_flags  // flags for 'virtualedit'
@@ -215,7 +215,7 @@ typedef struct {
 #define w_p_pvw w_onebuf_opt.wo_pvw    // 'previewwindow'
   int wo_rl;
 #define w_p_rl w_onebuf_opt.wo_rl      // 'rightleft'
-  char_u *wo_rlc;
+  char *wo_rlc;
 #define w_p_rlc w_onebuf_opt.wo_rlc    // 'rightleftcmd'
   long wo_scr;
 #define w_p_scr w_onebuf_opt.wo_scr     // 'scroll'
@@ -225,13 +225,13 @@ typedef struct {
 #define w_p_cuc w_onebuf_opt.wo_cuc    // 'cursorcolumn'
   int wo_cul;
 #define w_p_cul w_onebuf_opt.wo_cul    // 'cursorline'
-  char_u *wo_culopt;
+  char *wo_culopt;
 #define w_p_culopt w_onebuf_opt.wo_culopt  // 'cursorlineopt'
-  char_u *wo_cc;
+  char *wo_cc;
 #define w_p_cc w_onebuf_opt.wo_cc      // 'colorcolumn'
-  char_u *wo_sbr;
+  char *wo_sbr;
 #define w_p_sbr w_onebuf_opt.wo_sbr    // 'showbreak'
-  char_u *wo_stl;
+  char *wo_stl;
 #define w_p_stl w_onebuf_opt.wo_stl     // 'statusline'
   char *wo_wbr;
 #define w_p_wbr w_onebuf_opt.wo_wbr   // 'winbar'
@@ -245,7 +245,7 @@ typedef struct {
 #define w_p_wrap w_onebuf_opt.wo_wrap   // 'wrap'
   int wo_wrap_save;             // 'wrap' state saved for diff mode
 #define w_p_wrap_save w_onebuf_opt.wo_wrap_save
-  char_u *wo_cocu;                 // 'concealcursor'
+  char *wo_cocu;                 // 'concealcursor'
 #define w_p_cocu w_onebuf_opt.wo_cocu
   long wo_cole;                         // 'conceallevel'
 #define w_p_cole w_onebuf_opt.wo_cole
@@ -253,13 +253,13 @@ typedef struct {
 #define w_p_crb w_onebuf_opt.wo_crb    // 'cursorbind'
   int wo_crb_save;              // 'cursorbind' state saved for diff mode
 #define w_p_crb_save w_onebuf_opt.wo_crb_save
-  char_u *wo_scl;
+  char *wo_scl;
 #define w_p_scl w_onebuf_opt.wo_scl    // 'signcolumn'
-  char_u *wo_winhl;
+  char *wo_winhl;
 #define w_p_winhl w_onebuf_opt.wo_winhl    // 'winhighlight'
-  char_u *wo_fcs;
+  char *wo_fcs;
 #define w_p_fcs w_onebuf_opt.wo_fcs    // 'fillchars'
-  char_u *wo_lcs;
+  char *wo_lcs;
 #define w_p_lcs w_onebuf_opt.wo_lcs    // 'listchars'
   long wo_winbl;
 #define w_p_winbl w_onebuf_opt.wo_winbl  // 'winblend'
@@ -308,8 +308,8 @@ typedef struct arglist {
 //
 // TODO(Felipe): move aentry_T to another header
 typedef struct argentry {
-  char_u *ae_fname;        // file name as specified
-  int ae_fnum;                  // buffer number with expanded file name
+  char *ae_fname;        // file name as specified
+  int ae_fnum;           // buffer number with expanded file name
 } aentry_T;
 
 #define ALIST(win) (win)->w_alist
@@ -326,7 +326,7 @@ typedef struct argentry {
  */
 typedef struct {
   char_u *tb_buf;          // buffer for typed characters
-  char_u *tb_noremap;      // mapping flags for characters in tb_buf[]
+  uint8_t *tb_noremap;          // mapping flags for characters in tb_buf[]
   int tb_buflen;                // size of tb_buf[]
   int tb_off;                   // current position in tb_buf[]
   int tb_len;                   // number of valid bytes in tb_buf[]
@@ -352,11 +352,11 @@ typedef struct {
  */
 typedef struct mapblock mapblock_T;
 struct mapblock {
-  mapblock_T *m_next;          // next mapblock in list
-  char_u *m_keys;          // mapped from, lhs
-  char_u *m_str;           // mapped to, rhs
-  char_u *m_orig_str;      // rhs as entered by the user
-  LuaRef m_luaref;         // lua function reference as rhs
+  mapblock_T *m_next;           // next mapblock in list
+  char_u *m_keys;               // mapped from, lhs
+  char *m_str;                  // mapped to, rhs
+  char *m_orig_str;             // rhs as entered by the user
+  LuaRef m_luaref;              // lua function reference as rhs
   int m_keylen;                 // strlen(m_keys)
   int m_mode;                   // valid mode
   int m_simplified;             // m_keys was simplified, do no use this map
@@ -447,7 +447,7 @@ typedef struct {
   linenr_T b_syn_sync_minlines;         // minimal sync lines offset
   linenr_T b_syn_sync_maxlines;         // maximal sync lines offset
   linenr_T b_syn_sync_linebreaks;       // offset for multi-line pattern
-  char_u *b_syn_linecont_pat;           // line continuation pattern
+  char *b_syn_linecont_pat;             // line continuation pattern
   regprog_T *b_syn_linecont_prog;       // line continuation program
   syn_time_T b_syn_linecont_time;
   int b_syn_linecont_ic;                // ignore-case flag for above
@@ -476,17 +476,17 @@ typedef struct {
   disptick_T b_sst_lasttick;    // last display tick
 
   // for spell checking
-  garray_T b_langp;             // list of pointers to slang_T, see spell.c
-  bool b_spell_ismw[256];       // flags: is midword char
-  char_u *b_spell_ismw_mb;  // multi-byte midword chars
-  char_u *b_p_spc;         // 'spellcapcheck'
+  garray_T b_langp;           // list of pointers to slang_T, see spell.c
+  bool b_spell_ismw[256];     // flags: is midword char
+  char *b_spell_ismw_mb;      // multi-byte midword chars
+  char *b_p_spc;              // 'spellcapcheck'
   regprog_T *b_cap_prog;      // program for 'spellcapcheck'
-  char_u *b_p_spf;         // 'spellfile'
-  char_u *b_p_spl;         // 'spelllang'
-  char_u *b_p_spo;         // 'spelloptions'
-  int b_cjk;                    // all CJK letters as OK
-  char_u b_syn_chartab[32];     // syntax iskeyword option
-  char_u *b_syn_isk;            // iskeyword option
+  char *b_p_spf;              // 'spellfile'
+  char *b_p_spl;              // 'spelllang'
+  char *b_p_spo;              // 'spelloptions'
+  int b_cjk;                  // all CJK letters as OK
+  uint8_t b_syn_chartab[32];  // syntax iskeyword option
+  char *b_syn_isk;            // iskeyword option
 } synblock_T;
 
 /// Type used for changedtick_di member in buf_T
@@ -653,10 +653,8 @@ struct file_buffer {
   time_t b_u_time_cur;          // uh_time of header below which we are now
   long b_u_save_nr_cur;         // file write nr after which we are now
 
-  /*
-   * variables for "U" command in undo.c
-   */
-  char_u *b_u_line_ptr;    // saved line for "U" command
+  // variables for "U" command in undo.c
+  char *b_u_line_ptr;           // saved line for "U" command
   linenr_T b_u_line_lnum;       // line number of line in u_line
   colnr_T b_u_line_colnr;       // optional column number
 
@@ -686,72 +684,72 @@ struct file_buffer {
 
   int b_p_ai;                   ///< 'autoindent'
   int b_p_ai_nopaste;           ///< b_p_ai saved for paste mode
-  char_u *b_p_bkc;              ///< 'backupco
+  char *b_p_bkc;                ///< 'backupco
   unsigned int b_bkc_flags;     ///< flags for 'backupco
   int b_p_ci;                   ///< 'copyindent'
   int b_p_bin;                  ///< 'binary'
   int b_p_bomb;                 ///< 'bomb'
-  char_u *b_p_bh;               ///< 'bufhidden'
-  char_u *b_p_bt;               ///< 'buftype'
+  char *b_p_bh;                 ///< 'bufhidden'
+  char *b_p_bt;                 ///< 'buftype'
   int b_has_qf_entry;           ///< quickfix exists for buffer
   int b_p_bl;                   ///< 'buflisted'
   long b_p_channel;             ///< 'channel'
   int b_p_cin;                  ///< 'cindent'
-  char_u *b_p_cino;             ///< 'cinoptions'
-  char_u *b_p_cink;             ///< 'cinkeys'
-  char_u *b_p_cinw;             ///< 'cinwords'
-  char_u *b_p_cinsd;            ///< 'cinscopedecls'
-  char_u *b_p_com;              ///< 'comments'
-  char_u *b_p_cms;              ///< 'commentstring'
-  char_u *b_p_cpt;              ///< 'complete'
+  char *b_p_cino;               ///< 'cinoptions'
+  char *b_p_cink;               ///< 'cinkeys'
+  char *b_p_cinw;               ///< 'cinwords'
+  char *b_p_cinsd;              ///< 'cinscopedecls'
+  char *b_p_com;                ///< 'comments'
+  char *b_p_cms;                ///< 'commentstring'
+  char *b_p_cpt;                ///< 'complete'
 #ifdef BACKSLASH_IN_FILENAME
   char_u *b_p_csl;              ///< 'completeslash'
 #endif
-  char_u *b_p_cfu;              ///< 'completefunc'
-  char_u *b_p_ofu;              ///< 'omnifunc'
-  char_u *b_p_tfu;              ///< 'tagfunc'
+  char *b_p_cfu;                ///< 'completefunc'
+  char *b_p_ofu;                ///< 'omnifunc'
+  char *b_p_tfu;                ///< 'tagfunc'
   int b_p_eol;                  ///< 'endofline'
   int b_p_fixeol;               ///< 'fixendofline'
   int b_p_et;                   ///< 'expandtab'
   int b_p_et_nobin;             ///< b_p_et saved for binary mode
   int b_p_et_nopaste;           ///< b_p_et saved for paste mode
-  char_u *b_p_fenc;             ///< 'fileencoding'
-  char_u *b_p_ff;               ///< 'fileformat'
-  char_u *b_p_ft;               ///< 'filetype'
-  char_u *b_p_fo;               ///< 'formatoptions'
-  char_u *b_p_flp;              ///< 'formatlistpat'
+  char *b_p_fenc;               ///< 'fileencoding'
+  char *b_p_ff;                 ///< 'fileformat'
+  char *b_p_ft;                 ///< 'filetype'
+  char *b_p_fo;                 ///< 'formatoptions'
+  char *b_p_flp;                ///< 'formatlistpat'
   int b_p_inf;                  ///< 'infercase'
-  char_u *b_p_isk;              ///< 'iskeyword'
-  char_u *b_p_def;              ///< 'define' local value
-  char_u *b_p_inc;              ///< 'include'
-  char_u *b_p_inex;             ///< 'includeexpr'
+  char *b_p_isk;                ///< 'iskeyword'
+  char *b_p_def;                ///< 'define' local value
+  char *b_p_inc;                ///< 'include'
+  char *b_p_inex;               ///< 'includeexpr'
   uint32_t b_p_inex_flags;      ///< flags for 'includeexpr'
-  char_u *b_p_inde;             ///< 'indentexpr'
+  char *b_p_inde;               ///< 'indentexpr'
   uint32_t b_p_inde_flags;      ///< flags for 'indentexpr'
-  char_u *b_p_indk;             ///< 'indentkeys'
-  char_u *b_p_fp;               ///< 'formatprg'
-  char_u *b_p_fex;              ///< 'formatexpr'
+  char *b_p_indk;               ///< 'indentkeys'
+  char *b_p_fp;                 ///< 'formatprg'
+  char *b_p_fex;                ///< 'formatexpr'
   uint32_t b_p_fex_flags;       ///< flags for 'formatexpr'
-  char_u *b_p_kp;               ///< 'keywordprg'
+  char *b_p_kp;                 ///< 'keywordprg'
   int b_p_lisp;                 ///< 'lisp'
-  char_u *b_p_menc;             ///< 'makeencoding'
-  char_u *b_p_mps;              ///< 'matchpairs'
+  char *b_p_menc;               ///< 'makeencoding'
+  char *b_p_mps;                ///< 'matchpairs'
   int b_p_ml;                   ///< 'modeline'
   int b_p_ml_nobin;             ///< b_p_ml saved for binary mode
   int b_p_ma;                   ///< 'modifiable'
-  char_u *b_p_nf;               ///< 'nrformats'
+  char *b_p_nf;                 ///< 'nrformats'
   int b_p_pi;                   ///< 'preserveindent'
-  char_u *b_p_qe;               ///< 'quoteescape'
+  char *b_p_qe;                 ///< 'quoteescape'
   int b_p_ro;                   ///< 'readonly'
   long b_p_sw;                  ///< 'shiftwidth'
   long b_p_scbk;                ///< 'scrollback'
   int b_p_si;                   ///< 'smartindent'
   long b_p_sts;                 ///< 'softtabstop'
   long b_p_sts_nopaste;         ///< b_p_sts saved for paste mode
-  char_u *b_p_sua;              ///< 'suffixesadd'
+  char *b_p_sua;                ///< 'suffixesadd'
   int b_p_swf;                  ///< 'swapfile'
   long b_p_smc;                 ///< 'synmaxcol'
-  char_u *b_p_syn;              ///< 'syntax'
+  char *b_p_syn;                ///< 'syntax'
   long b_p_ts;                  ///< 'tabstop'
   long b_p_tw;                  ///< 'textwidth'
   long b_p_tw_nobin;            ///< b_p_tw saved for binary mode
@@ -759,29 +757,29 @@ struct file_buffer {
   long b_p_wm;                  ///< 'wrapmargin'
   long b_p_wm_nobin;            ///< b_p_wm saved for binary mode
   long b_p_wm_nopaste;          ///< b_p_wm saved for paste mode
-  char_u *b_p_vsts;             ///< 'varsofttabstop'
-  long *b_p_vsts_array;          ///< 'varsofttabstop' in internal format
-  char_u *b_p_vsts_nopaste;     ///< b_p_vsts saved for paste mode
-  char_u *b_p_vts;              ///< 'vartabstop'
-  long *b_p_vts_array;           ///< 'vartabstop' in internal format
-  char_u *b_p_keymap;           ///< 'keymap'
+  char *b_p_vsts;               ///< 'varsofttabstop'
+  long *b_p_vsts_array;         ///< 'varsofttabstop' in internal format
+  char *b_p_vsts_nopaste;       ///< b_p_vsts saved for paste mode
+  char *b_p_vts;                ///< 'vartabstop'
+  long *b_p_vts_array;          ///< 'vartabstop' in internal format
+  char *b_p_keymap;             ///< 'keymap'
 
   // local values for options which are normally global
-  char_u *b_p_gp;               ///< 'grepprg' local value
-  char_u *b_p_mp;               ///< 'makeprg' local value
-  char_u *b_p_efm;              ///< 'errorformat' local value
-  char_u *b_p_ep;               ///< 'equalprg' local value
-  char_u *b_p_path;             ///< 'path' local value
+  char *b_p_gp;                 ///< 'grepprg' local value
+  char *b_p_mp;                 ///< 'makeprg' local value
+  char *b_p_efm;                ///< 'errorformat' local value
+  char *b_p_ep;                 ///< 'equalprg' local value
+  char *b_p_path;               ///< 'path' local value
   int b_p_ar;                   ///< 'autoread' local value
-  char_u *b_p_tags;             ///< 'tags' local value
-  char_u *b_p_tc;               ///< 'tagcase' local value
+  char *b_p_tags;               ///< 'tags' local value
+  char *b_p_tc;                 ///< 'tagcase' local value
   unsigned b_tc_flags;          ///< flags for 'tagcase'
-  char_u *b_p_dict;             ///< 'dictionary' local value
-  char_u *b_p_tsr;              ///< 'thesaurus' local value
-  char_u *b_p_tsrfu;            ///< 'thesaurusfunc' local value
+  char *b_p_dict;               ///< 'dictionary' local value
+  char *b_p_tsr;                ///< 'thesaurus' local value
+  char *b_p_tsrfu;              ///< 'thesaurusfunc' local value
   long b_p_ul;                  ///< 'undolevels' local value
   int b_p_udf;                  ///< 'undofile'
-  char_u *b_p_lw;               ///< 'lispwords' local value
+  char *b_p_lw;                 ///< 'lispwords' local value
 
   // end of buffer options
 
diff --git a/src/nvim/change.c b/src/nvim/change.c
index ab54c3ea88..45ff2ceacb 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -536,9 +536,9 @@ void unchanged(buf_T *buf, int ff, bool always_inc_changedtick)
 
 /// Insert string "p" at the cursor position.  Stops at a NUL byte.
 /// Handles Replace mode and multi-byte characters.
-void ins_bytes(char_u *p)
+void ins_bytes(char *p)
 {
-  ins_bytes_len(p, STRLEN(p));
+  ins_bytes_len((char_u *)p, STRLEN(p));
 }
 
 /// Insert string "p" with length "len" at the cursor position.
@@ -1309,10 +1309,10 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
 
         // Doing "O" on the end of a comment inserts the middle leader.
         // Find the string for the middle leader, searching backwards.
-        while (p > (char *)curbuf->b_p_com && *p != ',') {
+        while (p > curbuf->b_p_com && *p != ',') {
           p--;
         }
-        for (lead_repl = p; lead_repl > (char *)curbuf->b_p_com
+        for (lead_repl = p; lead_repl > curbuf->b_p_com
              && lead_repl[-1] != ':'; lead_repl--) {}
         lead_repl_len = (int)(p - lead_repl);
 
@@ -1795,7 +1795,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     // Insert new stuff into line again
     curwin->w_cursor.col = 0;
     curwin->w_cursor.coladd = 0;
-    ins_bytes(p_extra);         // will call changed_bytes()
+    ins_bytes((char *)p_extra);         // will call changed_bytes()
     xfree(p_extra);
     next_line = NULL;
   }
@@ -1814,16 +1814,16 @@ theend:
 /// If "fixpos" is true fix the cursor position when done.
 void truncate_line(int fixpos)
 {
-  char_u *newp;
+  char *newp;
   linenr_T lnum = curwin->w_cursor.lnum;
   colnr_T col = curwin->w_cursor.col;
 
   if (col == 0) {
-    newp = vim_strsave((char_u *)"");
+    newp = xstrdup("");
   } else {
-    newp = vim_strnsave(ml_get(lnum), (size_t)col);
+    newp = (char *)vim_strnsave(ml_get(lnum), (size_t)col);
   }
-  ml_replace(lnum, (char *)newp, false);
+  ml_replace(lnum, newp, false);
 
   // mark the buffer as changed and prepare for displaying
   changed_bytes(lnum, curwin->w_cursor.col);
@@ -1900,7 +1900,7 @@ int get_leader_len(char *line, char **flags, bool backward, bool include_space)
   while (line[i] != NUL) {
     // scan through the 'comments' option for a match
     int found_one = false;
-    for (list = (char *)curbuf->b_p_com; *list;) {
+    for (list = curbuf->b_p_com; *list;) {
       // Get one option part into part_buf[].  Advance "list" to next
       // one.  Put "string" at start of string.
       if (!got_com && flags != NULL) {
@@ -2037,7 +2037,7 @@ int get_last_leader_offset(char *line, char **flags)
   while (--i >= lower_check_bound) {
     // scan through the 'comments' option for a match
     int found_one = false;
-    for (list = (char *)curbuf->b_p_com; *list;) {
+    for (list = curbuf->b_p_com; *list;) {
       char *flags_save = list;
 
       // Get one option part into part_buf[].  Advance list to next one.
@@ -2122,7 +2122,7 @@ int get_last_leader_offset(char *line, char **flags)
       }
       len1 = (int)STRLEN(com_leader);
 
-      for (list = (char *)curbuf->b_p_com; *list;) {
+      for (list = curbuf->b_p_com; *list;) {
         char *flags_save = list;
 
         (void)copy_option_part(&list, part_buf2, COM_MAX_LEN, ",");
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 6238d85b3a..ff58810ff0 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -149,7 +149,7 @@ int buf_init_chartab(buf_T *buf, int global)
       p = p_isf;
     } else {  // i == 3
       // fourth round: 'iskeyword'
-      p = buf->b_p_isk;
+      p = (char_u *)buf->b_p_isk;
     }
 
     while (*p) {
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 90d621ae1e..fa1c669aaf 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -797,8 +797,8 @@ static int diff_write(buf_T *buf, diffin_T *din)
   }
 
   // Always use 'fileformat' set to "unix".
-  char_u *save_ff = buf->b_p_ff;
-  buf->b_p_ff = vim_strsave((char_u *)FF_UNIX);
+  char *save_ff = buf->b_p_ff;
+  buf->b_p_ff = xstrdup(FF_UNIX);
   const bool save_cmod_flags = cmdmod.cmod_flags;
   // Writing the buffer is an implementation detail of performing the diff,
   // so it shouldn't update the '[ and '] marks.
@@ -1413,7 +1413,7 @@ void diff_win_options(win_T *wp, int addbuf)
     if (wp->w_p_diff_saved) {
       free_string_option(wp->w_p_fdm_save);
     }
-    wp->w_p_fdm_save = vim_strsave(wp->w_p_fdm);
+    wp->w_p_fdm_save = xstrdup(wp->w_p_fdm);
   }
   set_string_option_direct_in_win(wp, "fdm", -1, "diff", OPT_LOCAL | OPT_FREE, 0);
 
@@ -1424,12 +1424,12 @@ void diff_win_options(win_T *wp, int addbuf)
     if (wp->w_p_diff_saved) {
       free_string_option(wp->w_p_fdc_save);
     }
-    wp->w_p_fdc_save = vim_strsave(wp->w_p_fdc);
+    wp->w_p_fdc_save = xstrdup(wp->w_p_fdc);
   }
   free_string_option(wp->w_p_fdc);
-  wp->w_p_fdc = (char_u *)xstrdup("2");
+  wp->w_p_fdc = xstrdup("2");
   assert(diff_foldcolumn >= 0 && diff_foldcolumn <= 9);
-  snprintf((char *)wp->w_p_fdc, STRLEN(wp->w_p_fdc) + 1, "%d", diff_foldcolumn);
+  snprintf(wp->w_p_fdc, STRLEN(wp->w_p_fdc) + 1, "%d", diff_foldcolumn);
   wp->w_p_fen = true;
   wp->w_p_fdl = 0;
   foldUpdateAll(wp);
@@ -1480,11 +1480,9 @@ void ex_diffoff(exarg_T *eap)
           }
         }
         free_string_option(wp->w_p_fdm);
-        wp->w_p_fdm = vim_strsave(*wp->w_p_fdm_save
-                                  ? wp->w_p_fdm_save
-                                  : (char_u *)"manual");
+        wp->w_p_fdm = xstrdup(*wp->w_p_fdm_save ? wp->w_p_fdm_save : "manual");
         free_string_option(wp->w_p_fdc);
-        wp->w_p_fdc = vim_strsave(wp->w_p_fdc_save);
+        wp->w_p_fdc = xstrdup(wp->w_p_fdc_save);
 
         if (wp->w_p_fdl == 0) {
           wp->w_p_fdl = wp->w_p_fdl_save;
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 2b1b2607fb..f1a808e2bc 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -2082,7 +2082,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       if (wp->w_p_cole > 0
           && (wp != curwin || lnum != wp->w_cursor.lnum || conceal_cursor_line(wp))
           && ((syntax_flags & HL_CONCEAL) != 0 || has_match_conc > 0 || decor_conceal > 0)
-          && !(lnum_in_visual_area && vim_strchr((char *)wp->w_p_cocu, 'v') == NULL)) {
+          && !(lnum_in_visual_area && vim_strchr(wp->w_p_cocu, 'v') == NULL)) {
         char_attr = conceal_attr;
         if (((prev_syntax_id != syntax_seqnr && (syntax_flags & HL_CONCEAL) != 0)
              || has_match_conc > 1 || decor_conceal > 1)
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 79317d3df6..5fc19f9409 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1780,7 +1780,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     backspace_until_column(0);
 
     // Insert new stuff into line again
-    ins_bytes(new_line);
+    ins_bytes((char *)new_line);
 
     xfree(new_line);
 
@@ -2595,7 +2595,7 @@ static void internal_format(int textwidth, int second_indent, int flags, int for
     if (State & VREPLACE_FLAG) {
       // In MODE_VREPLACE state we have backspaced over the text to be
       // moved, now we re-insert it into the new line.
-      ins_bytes(saved_text);
+      ins_bytes((char *)saved_text);
       xfree(saved_text);
     } else {
       /*
@@ -3689,9 +3689,9 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
   }
 
   if (*curbuf->b_p_inde != NUL) {
-    look = curbuf->b_p_indk;            // 'indentexpr' set: use 'indentkeys'
+    look = (char_u *)curbuf->b_p_indk;            // 'indentexpr' set: use 'indentkeys'
   } else {
-    look = curbuf->b_p_cink;            // 'indentexpr' empty: use 'cinkeys'
+    look = (char_u *)curbuf->b_p_cink;            // 'indentexpr' empty: use 'cinkeys'
   }
   while (*look) {
     /*
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 1458d1ff36..6d37106143 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2192,7 +2192,7 @@ int pattern_match(char *pat, char *text, bool ic)
 
   // avoid 'l' flag in 'cpoptions'
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
   regmatch.regprog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
   if (regmatch.regprog != NULL) {
     regmatch.rm_ic = ic;
@@ -8326,7 +8326,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
 
   // Make 'cpoptions' empty, so that the 'l' flag doesn't work here
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   ga_init(&ga, 1, 200);
 
@@ -8386,7 +8386,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
 
   char *ret = xstrdup(ga.ga_data == NULL ? str : ga.ga_data);
   ga_clear(&ga);
-  if ((char_u *)p_cpo == empty_option) {
+  if (p_cpo == empty_option) {
     p_cpo = save_cpo;
   } else {
     // Darn, evaluating {sub} expression or {expr} changed the value.
@@ -8395,7 +8395,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
     if (*p_cpo == NUL) {
       set_option_value_give_err("cpo", 0L, save_cpo, 0);
     }
-    free_string_option((char_u *)save_cpo);
+    free_string_option(save_cpo);
   }
 
   return ret;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index fc926cf5a9..ff5d8a0a8f 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -591,7 +591,7 @@ buf_T *tv_get_buf(typval_T *tv, int curtab_only)
   int save_magic = p_magic;
   p_magic = true;
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   buf_T *buf = buflist_findnr(buflist_findpat((char *)name, (char *)name + STRLEN(name),
                                               true, false, curtab_only));
@@ -2224,7 +2224,7 @@ static void f_filewritable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
 static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
 {
   char_u *fresult = NULL;
-  char_u *path = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
+  char_u *path = *curbuf->b_p_path == NUL ? p_path : (char_u *)curbuf->b_p_path;
   int count = 1;
   bool first = true;
   bool error = false;
@@ -2265,7 +2265,7 @@ static void findfilendir(typval_T *argvars, typval_T *rettv, int find_what)
                                          find_what, (char_u *)curbuf->b_ffname,
                                          (find_what == FINDFILE_DIR
                                           ? (char_u *)""
-                                          : curbuf->b_p_sua));
+                                          : (char_u *)curbuf->b_p_sua));
       first = false;
 
       if (fresult != NULL && rettv->v_type == VAR_LIST) {
@@ -4903,7 +4903,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
 
   // Make 'cpoptions' empty, the 'l' flag should not be used here.
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   rettv->vval.v_number = -1;
   switch (type) {
@@ -6312,7 +6312,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       v = os_realpath(fname, v);
     }
   }
-  rettv->vval.v_string = (char_u *)(v == NULL ? xstrdup(fname) : v);
+  rettv->vval.v_string = (v == NULL ? xstrdup(fname) : v);
 #else
 # ifdef HAVE_READLINK
   {
@@ -7293,7 +7293,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
 
   // Make 'cpoptions' empty, the 'l' flag should not be used here.
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   // Set the time limit, if there is one.
   proftime_T tm = profile_setlimit(time_limit);
@@ -7419,7 +7419,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
 
   xfree(pat2);
   xfree(pat3);
-  if ((char_u *)p_cpo == empty_option) {
+  if (p_cpo == empty_option) {
     p_cpo = save_cpo;
   } else {
     // Darn, evaluating the {skip} expression changed the value.
@@ -7428,7 +7428,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
     if (*p_cpo == NUL) {
       set_option_value_give_err("cpo", 0L, save_cpo, 0);
     }
-    free_string_option((char_u *)save_cpo);
+    free_string_option(save_cpo);
   }
 
   return retval;
@@ -8182,7 +8182,7 @@ static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   // Make 'cpoptions' empty, the 'l' flag should not be used here.
   char *save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   const char *str = tv_get_string(&argvars[0]);
   const char *pat = NULL;
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 2ed45f7ab8..41512205dc 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -680,11 +680,11 @@ void ex_listdo(exarg_T *eap)
         // buffer was opened while Syntax autocommands were disabled,
         // need to trigger them now.
         if (buf == curbuf) {
-          apply_autocmds(EVENT_SYNTAX, (char *)curbuf->b_p_syn, curbuf->b_fname, true,
+          apply_autocmds(EVENT_SYNTAX, curbuf->b_p_syn, curbuf->b_fname, true,
                          curbuf);
         } else {
           aucmd_prepbuf(&aco, buf);
-          apply_autocmds(EVENT_SYNTAX, (char *)buf->b_p_syn, buf->b_fname, true, buf);
+          apply_autocmds(EVENT_SYNTAX, buf->b_p_syn, buf->b_fname, true, buf);
           aucmd_restbuf(&aco);
         }
 
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 8f2a98b401..29812dd8fe 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2602,7 +2602,7 @@ void undo_cmdmod(cmdmod_T *cmod)
   if (cmod->cmod_save_ei != NULL) {
     // Restore 'eventignore' to the value before ":noautocmd".
     set_string_option_direct("ei", -1, cmod->cmod_save_ei, OPT_FREE, SID_NONE);
-    free_string_option((char_u *)cmod->cmod_save_ei);
+    free_string_option(cmod->cmod_save_ei);
     cmod->cmod_save_ei = NULL;
   }
 
@@ -3646,8 +3646,8 @@ char *replace_makeprg(exarg_T *eap, char *arg, char **cmdlinep)
   // Don't do it when ":vimgrep" is used for ":grep".
   if ((eap->cmdidx == CMD_make || eap->cmdidx == CMD_lmake || isgrep)
       && !grep_internal(eap->cmdidx)) {
-    const char *program = isgrep ? (*curbuf->b_p_gp == NUL ? (char *)p_gp : (char *)curbuf->b_p_gp)
-                                 : (*curbuf->b_p_mp == NUL ? (char *)p_mp : (char *)curbuf->b_p_mp);
+    const char *program = isgrep ? (*curbuf->b_p_gp == NUL ? (char *)p_gp : curbuf->b_p_gp)
+                                 : (*curbuf->b_p_mp == NUL ? (char *)p_mp : curbuf->b_p_mp);
 
     arg = skipwhite(arg);
 
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 5ddcb0270b..8941921568 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -1376,7 +1376,7 @@ void ex_catch(exarg_T *eap)
           *end = NUL;
         }
         save_cpo = p_cpo;
-        p_cpo = (char *)empty_option;
+        p_cpo = empty_option;
         // Disable error messages, it will make current exception
         // invalid
         emsg_off++;
diff --git a/src/nvim/ex_session.c b/src/nvim/ex_session.c
index 9495ae1c4b..453de89aea 100644
--- a/src/nvim/ex_session.c
+++ b/src/nvim/ex_session.c
@@ -359,7 +359,7 @@ static int put_view(FILE *fd, win_T *wp, int add_edit, unsigned *flagp, int curr
       // Then ":help" will re-use both the buffer and the window and set
       // the options, even when "options" is not in 'sessionoptions'.
       if (0 < wp->w_tagstackidx && wp->w_tagstackidx <= wp->w_tagstacklen) {
-        curtag = (char *)wp->w_tagstack[wp->w_tagstackidx - 1].tagname;
+        curtag = wp->w_tagstack[wp->w_tagstackidx - 1].tagname;
       }
 
       if (put_line(fd, "enew | setl bt=help") == FAIL
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 53f87d0e42..2e86e3f7b0 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -827,7 +827,7 @@ char_u *vim_findfile(void *search_ctx_arg)
             if (search_ctx->ffsc_tagfile) {
               suf = "";
             } else {
-              suf = (char *)curbuf->b_p_sua;
+              suf = curbuf->b_p_sua;
             }
             for (;;) {
               // if file exists and we didn't already find it
@@ -1355,8 +1355,8 @@ char_u *find_file_in_path(char_u *ptr, size_t len, int options, int first, char_
   return find_file_in_path_option(ptr, len, options, first,
                                   (*curbuf->b_p_path == NUL
                                    ? p_path
-                                   : curbuf->b_p_path),
-                                  FINDFILE_BOTH, rel_fname, curbuf->b_p_sua);
+                                   : (char_u *)curbuf->b_p_path),
+                                  FINDFILE_BOTH, rel_fname, (char_u *)curbuf->b_p_sua);
 }
 
 static char_u *ff_file_to_find = NULL;
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 39bf1b3670..cc592c2430 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -708,7 +708,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
 
     fenc_alloced = false;
   } else if (*p_fencs == NUL) {
-    fenc = (char *)curbuf->b_p_fenc;            // use format from buffer
+    fenc = curbuf->b_p_fenc;            // use format from buffer
     fenc_alloced = false;
   } else {
     fenc_next = (char *)p_fencs;                // try items in 'fileencodings'
@@ -1948,7 +1948,7 @@ failed:
       if (!au_did_filetype && *curbuf->b_p_ft != NUL) {
         // EVENT_FILETYPE was not triggered but the buffer already has a
         // filetype.  Trigger EVENT_FILETYPE using the existing filetype.
-        apply_autocmds(EVENT_FILETYPE, (char *)curbuf->b_p_ft, curbuf->b_fname, true, curbuf);
+        apply_autocmds(EVENT_FILETYPE, curbuf->b_p_ft, curbuf->b_fname, true, curbuf);
       }
     } else {
       apply_autocmds_exarg(EVENT_FILEREADPOST, sfname, sfname,
@@ -3052,7 +3052,7 @@ nobackup:
     fenc = (char *)enc_canonize((char_u *)fenc);
     fenc_tofree = fenc;
   } else {
-    fenc = (char *)buf->b_p_fenc;
+    fenc = buf->b_p_fenc;
   }
 
   // Check if the file needs to be converted.
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 9cc17acb37..b4ddb3ec08 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -1556,7 +1556,7 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
   }
   parseMarker(wp);
 
-  foldAddMarker(buf, start, wp->w_p_fmr, foldstartmarkerlen);
+  foldAddMarker(buf, start, (char_u *)wp->w_p_fmr, foldstartmarkerlen);
   foldAddMarker(buf, end, foldendmarker, foldendmarkerlen);
 
   // Update both changes here, to avoid all folds after the start are
@@ -1575,9 +1575,9 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
 /// Add "marker[markerlen]" in 'commentstring' to position `pos`.
 static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t markerlen)
 {
-  char_u *cms = buf->b_p_cms;
+  char_u *cms = (char_u *)buf->b_p_cms;
   char_u *newline;
-  char_u *p = (char_u *)strstr((char *)buf->b_p_cms, "%s");
+  char_u *p = (char_u *)strstr(buf->b_p_cms, "%s");
   bool line_is_comment = false;
   linenr_T lnum = pos.lnum;
 
@@ -1621,7 +1621,7 @@ static void deleteFoldMarkers(win_T *wp, fold_T *fp, int recursive, linenr_T lnu
                         lnum_off + fp->fd_top);
     }
   }
-  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off, wp->w_p_fmr,
+  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off, (char_u *)wp->w_p_fmr,
                 foldstartmarkerlen);
   foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off + fp->fd_len - 1,
                 foldendmarker, foldendmarkerlen);
@@ -1639,7 +1639,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
     return;
   }
 
-  char_u *cms = buf->b_p_cms;
+  char_u *cms = (char_u *)buf->b_p_cms;
   char_u *line = ml_get_buf(buf, lnum, false);
   for (char_u *p = line; *p != NUL; p++) {
     if (STRNCMP(p, marker, markerlen) != 0) {
@@ -1729,7 +1729,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 
       emsg_silent++;       // handle exceptions, but don't display errors
       text =
-        (char_u *)eval_to_string_safe((char *)wp->w_p_fdt, NULL,
+        (char_u *)eval_to_string_safe(wp->w_p_fdt, NULL,
                                       was_set_insecurely(wp, "foldtext", OPT_LOCAL));
       emsg_silent--;
 
@@ -1790,7 +1790,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 static void foldtext_cleanup(char_u *str)
 {
   // Ignore leading and trailing white space in 'commentstring'.
-  char_u *cms_start = (char_u *)skipwhite((char *)curbuf->b_p_cms);
+  char_u *cms_start = (char_u *)skipwhite(curbuf->b_p_cms);
   size_t cms_slen = STRLEN(cms_start);
   while (cms_slen > 0 && ascii_iswhite(cms_start[cms_slen - 1])) {
     cms_slen--;
@@ -2854,7 +2854,7 @@ static void foldlevelIndent(fline_T *flp)
 
   // empty line or lines starting with a character in 'foldignore': level
   // depends on surrounding lines
-  if (*s == NUL || vim_strchr((char *)flp->wp->w_p_fdi, *s) != NULL) {
+  if (*s == NUL || vim_strchr(flp->wp->w_p_fdi, *s) != NULL) {
     // first and last line can't be undefined, use level 0
     if (lnum == 1 || lnum == buf->b_ml.ml_line_count) {
       flp->lvl = 0;
@@ -2907,7 +2907,7 @@ static void foldlevelExpr(fline_T *flp)
   const bool save_keytyped = KeyTyped;
 
   int c;
-  const int n = eval_foldexpr((char *)flp->wp->w_p_fde, &c);
+  const int n = eval_foldexpr(flp->wp->w_p_fde, &c);
   KeyTyped = save_keytyped;
 
   switch (c) {
@@ -2985,8 +2985,8 @@ static void foldlevelExpr(fline_T *flp)
 /// Relies on the option value to have been checked for correctness already.
 static void parseMarker(win_T *wp)
 {
-  foldendmarker = (char_u *)vim_strchr((char *)wp->w_p_fmr, ',');
-  foldstartmarkerlen = (size_t)(foldendmarker++ - wp->w_p_fmr);
+  foldendmarker = (char_u *)vim_strchr(wp->w_p_fmr, ',');
+  foldstartmarkerlen = (size_t)(foldendmarker++ - (char_u *)wp->w_p_fmr);
   foldendmarkerlen = STRLEN(foldendmarker);
 }
 
@@ -3003,7 +3003,7 @@ static void foldlevelMarker(fline_T *flp)
   int start_lvl = flp->lvl;
 
   // cache a few values for speed
-  char_u *startmarker = flp->wp->w_p_fmr;
+  char_u *startmarker = (char_u *)flp->wp->w_p_fmr;
   int cstart = *startmarker;
   startmarker++;
   int cend = *foldendmarker;
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 1f4d28bcd3..e858b9244b 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -162,7 +162,7 @@ static char_u *get_buffcont(buffheader_T *buffer, int dozero)
     p2 = p;
     for (const buffblock_T *bp = buffer->bh_first.b_next;
          bp != NULL; bp = bp->b_next) {
-      for (const char_u *str = bp->b_str; *str;) {
+      for (const char_u *str = (char_u *)bp->b_str; *str;) {
         *p2++ = *str++;
       }
     }
@@ -341,7 +341,7 @@ static int read_readbuf(buffheader_T *buf, int advance)
   }
 
   buffblock_T *const curr = buf->bh_first.b_next;
-  c = curr->b_str[buf->bh_index];
+  c = (char_u)curr->b_str[buf->bh_index];
 
   if (advance) {
     if (curr->b_str[++buf->bh_index] == NUL) {
@@ -649,7 +649,7 @@ static int read_redo(bool init, bool old_redo)
     if (bp == NULL) {
       return FAIL;
     }
-    p = bp->b_str;
+    p = (char_u *)bp->b_str;
     return OK;
   }
   if ((c = *p) == NUL) {
@@ -670,7 +670,7 @@ static int read_redo(bool init, bool old_redo)
     }
     if (*++p == NUL && bp->b_next != NULL) {
       bp = bp->b_next;
-      p = bp->b_str;
+      p = (char_u *)bp->b_str;
     }
     buf[i] = (char_u)c;
     if (i == n - 1) {         // last byte of a character
@@ -934,7 +934,7 @@ int ins_typebuf(char *str, int noremap, int offset, bool nottyped, bool silent)
   }
   for (i = 0; i < addlen; i++) {
     typebuf.tb_noremap[typebuf.tb_off + i + offset] =
-      (char_u)((--nrm >= 0) ? val : RM_YES);
+      (uint8_t)((--nrm >= 0) ? val : RM_YES);
   }
 
   // tb_maplen and tb_silent only remember the length of mapped and/or
@@ -2047,12 +2047,11 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
         // - Partly match: mlen == typebuf.tb_len
         keylen = mp->m_keylen;
         if (mlen == keylen || (mlen == typebuf.tb_len && typebuf.tb_len < keylen)) {
-          char_u *s;
           int n;
 
           // If only script-local mappings are allowed, check if the
           // mapping starts with K_SNR.
-          s = typebuf.tb_noremap + typebuf.tb_off;
+          uint8_t *s = typebuf.tb_noremap + typebuf.tb_off;
           if (*s == RM_SCRIPT
               && (mp->m_keys[0] != K_SPECIAL
                   || mp->m_keys[1] != KS_EXTRA
@@ -2248,7 +2247,7 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
 
       save_m_keys = vim_strsave(mp->m_keys);
       if (save_m_luaref == LUA_NOREF) {
-        save_m_str = vim_strsave(mp->m_str);
+        save_m_str = vim_strsave((char_u *)mp->m_str);
       }
       map_str = eval_map_expr(mp, NUL);
 
@@ -2280,7 +2279,7 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
       vgetc_busy = save_vgetc_busy;
       may_garbage_collect = save_may_garbage_collect;
     } else {
-      map_str = mp->m_str;
+      map_str = (char_u *)mp->m_str;
     }
 
     // Insert the 'to' part in the typebuf.tb_buf.
@@ -2501,7 +2500,7 @@ static int vgetorpeek(bool advance)
                 // write char to script file(s)
                 gotchars(typebuf.tb_buf + typebuf.tb_off, 1);
               }
-              KeyNoremap = typebuf.tb_noremap[typebuf.tb_off];
+              KeyNoremap = (unsigned char)typebuf.tb_noremap[typebuf.tb_off];
               del_typebuf(1, 0);
             }
             break;  // got character, break the for loop
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 67b113849c..37181d02bd 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -755,7 +755,7 @@ EXTERN int keep_help_flag INIT(= false);  // doing :ta from help file
 // When a string option is NULL (which only happens in out-of-memory
 // situations), it is set to empty_option, to avoid having to check for NULL
 // everywhere.
-EXTERN char_u *empty_option INIT(= (char_u *)"");
+EXTERN char *empty_option INIT(= "");
 
 EXTERN bool redir_off INIT(= false);        // no redirection for a moment
 EXTERN FILE *redir_fd INIT(= NULL);         // message redirection file
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index f18a6d7b32..12fad371ae 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -710,7 +710,7 @@ int get_number_indent(linenr_T lnum)
   if ((State & MODE_INSERT) || has_format_option(FO_Q_COMS)) {
     lead_len = get_leader_len((char *)ml_get(lnum), NULL, false, true);
   }
-  regmatch.regprog = vim_regcomp((char *)curbuf->b_p_flp, RE_MAGIC);
+  regmatch.regprog = vim_regcomp(curbuf->b_p_flp, RE_MAGIC);
 
   if (regmatch.regprog != NULL) {
     regmatch.rm_ic = false;
@@ -770,7 +770,7 @@ int get_breakindent_win(win_T *wp, char_u *line)
   // add additional indent for numbered lists
   if (wp->w_briopt_list != 0) {
     regmatch_T regmatch = {
-      .regprog = vim_regcomp((char *)curbuf->b_p_flp,
+      .regprog = vim_regcomp(curbuf->b_p_flp,
                              RE_MAGIC + RE_STRING + RE_AUTO + RE_STRICT),
     };
 
@@ -855,7 +855,7 @@ int get_expr_indent(void)
 
   // Need to make a copy, the 'indentexpr' option could be changed while
   // evaluating it.
-  char_u *inde_copy = vim_strsave(curbuf->b_p_inde);
+  char_u *inde_copy = vim_strsave((char_u *)curbuf->b_p_inde);
   indent = (int)eval_to_number((char *)inde_copy);
   xfree(inde_copy);
 
@@ -1077,7 +1077,7 @@ static int lisp_match(char_u *p)
 {
   char_u buf[LSIZE];
   int len;
-  char *word = (char *)(*curbuf->b_p_lw != NUL ? curbuf->b_p_lw : p_lispwords);
+  char *word = (char *)(*curbuf->b_p_lw != NUL ? (char_u *)curbuf->b_p_lw : p_lispwords);
 
   while (*word != NUL) {
     (void)copy_option_part(&word, (char *)buf, LSIZE, ",");
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index fe8c235cc1..df337125ca 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -223,7 +223,7 @@ bool cin_is_cinword(const char_u *line)
   char_u *cinw_buf = xmalloc(cinw_len);
   line = (char_u *)skipwhite((char *)line);
 
-  for (char *cinw = (char *)curbuf->b_p_cinw; *cinw;) {
+  for (char *cinw = curbuf->b_p_cinw; *cinw;) {
     size_t len = copy_option_part(&cinw, (char *)cinw_buf, cinw_len, ",");
     if (STRNCMP(line, cinw_buf, len) == 0
         && (!vim_iswordc(line[len]) || !vim_iswordc(line[len - 1]))) {
@@ -519,7 +519,7 @@ bool cin_isscopedecl(const char_u *p)
 
   bool found = false;
 
-  for (char *cinsd = (char *)curbuf->b_p_cinsd; *cinsd;) {
+  for (char *cinsd = curbuf->b_p_cinsd; *cinsd;) {
     const size_t len = copy_option_part(&cinsd, (char *)cinsd_buf, cinsd_len, ",");
     if (STRNCMP(s, cinsd_buf, len) == 0) {
       const char_u *skip = cin_skipcomment(s + len);
@@ -1740,7 +1740,7 @@ void parse_cino(buf_T *buf)
   // Handle C #pragma directives
   buf->b_ind_pragma = 0;
 
-  for (p = (char *)buf->b_p_cino; *p;) {
+  for (p = buf->b_p_cino; *p;) {
     l = p++;
     if (*p == '-') {
       p++;
@@ -2063,7 +2063,7 @@ int get_c_indent(void)
     *lead_start = NUL;
     *lead_middle = NUL;
 
-    p = (char *)curbuf->b_p_com;
+    p = curbuf->b_p_com;
     while (*p != NUL) {
       int align = 0;
       int off = 0;
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index c92183dc2a..a3b5e3df5c 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -901,7 +901,7 @@ static void ins_compl_longest_match(compl_T *match)
 
     had_match = (curwin->w_cursor.col > compl_col);
     ins_compl_delete();
-    ins_bytes(compl_leader + get_compl_len());
+    ins_bytes((char *)compl_leader + get_compl_len());
     ins_redraw(false);
 
     // When the match isn't there (to avoid matching itself) remove it
@@ -935,7 +935,7 @@ static void ins_compl_longest_match(compl_T *match)
     *p = NUL;
     had_match = (curwin->w_cursor.col > compl_col);
     ins_compl_delete();
-    ins_bytes(compl_leader + get_compl_len());
+    ins_bytes((char *)compl_leader + get_compl_len());
     ins_redraw(false);
 
     // When the match isn't there (to avoid matching itself) remove it
@@ -1677,7 +1677,7 @@ static void ins_compl_new_leader(void)
 {
   ins_compl_del_pum();
   ins_compl_delete();
-  ins_bytes(compl_leader + get_compl_len());
+  ins_bytes((char *)compl_leader + get_compl_len());
   compl_used_match = false;
 
   if (compl_started) {
@@ -2224,11 +2224,11 @@ static char_u *get_complete_funcname(int type)
 {
   switch (type) {
   case CTRL_X_FUNCTION:
-    return curbuf->b_p_cfu;
+    return (char_u *)curbuf->b_p_cfu;
   case CTRL_X_OMNI:
-    return curbuf->b_p_ofu;
+    return (char_u *)curbuf->b_p_ofu;
   case CTRL_X_THESAURUS:
-    return *curbuf->b_p_tsrfu == NUL ? p_tsrfu : curbuf->b_p_tsrfu;
+    return *curbuf->b_p_tsrfu == NUL ? p_tsrfu : (char_u *)curbuf->b_p_tsrfu;
   default:
     return (char_u *)"";
   }
@@ -2823,8 +2823,8 @@ static void get_next_dict_tsr_completion(int compl_type, char_u *dict, int dict_
   } else {
     ins_compl_dictionaries(dict != NULL ? dict
                            : (compl_type == CTRL_X_THESAURUS
-                              ? (*curbuf->b_p_tsr == NUL ? p_tsr : curbuf->b_p_tsr)
-                              : (*curbuf->b_p_dict == NUL ? p_dict : curbuf->b_p_dict)),
+                              ? (*curbuf->b_p_tsr == NUL ? p_tsr : (char_u *)curbuf->b_p_tsr)
+                              : (*curbuf->b_p_dict == NUL ? p_dict : (char_u *)curbuf->b_p_dict)),
                            (char_u *)compl_pattern,
                            dict != NULL ? dict_f : 0,
                            compl_type == CTRL_X_THESAURUS);
@@ -3174,7 +3174,7 @@ static int ins_compl_get_exp(pos_T *ini)
     }
     st.found_all = false;
     st.ins_buf = curbuf;
-    st.e_cpt = (compl_cont_status & CONT_LOCAL) ? "." : (char *)curbuf->b_p_cpt;
+    st.e_cpt = (compl_cont_status & CONT_LOCAL) ? "." : curbuf->b_p_cpt;
     st.last_match_pos = st.first_match_pos = *ini;
   } else if (st.ins_buf != curbuf && !buf_valid(st.ins_buf)) {
     st.ins_buf = curbuf;  // In case the buffer was wiped out.
@@ -3319,7 +3319,7 @@ void ins_compl_delete(void)
 /// "in_compl_func" is true when called from complete_check().
 void ins_compl_insert(bool in_compl_func)
 {
-  ins_bytes(compl_shown_match->cp_str + get_compl_len());
+  ins_bytes((char *)compl_shown_match->cp_str + get_compl_len());
   compl_used_match = !match_at_original_text(compl_shown_match);
 
   dict_T *dict = ins_compl_dict_alloc(compl_shown_match);
@@ -3511,13 +3511,13 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
 
   // Insert the text of the new completion, or the compl_leader.
   if (compl_no_insert && !started) {
-    ins_bytes(compl_orig_text + get_compl_len());
+    ins_bytes((char *)compl_orig_text + get_compl_len());
     compl_used_match = false;
   } else if (insert_match) {
     if (!compl_get_longest || compl_used_match) {
       ins_compl_insert(in_compl_func);
     } else {
-      ins_bytes(compl_leader + get_compl_len());
+      ins_bytes((char *)compl_leader + get_compl_len());
     }
   } else {
     compl_used_match = false;
@@ -4079,9 +4079,9 @@ static int ins_compl_start(void)
     edit_submode_pre = (char_u *)_(" Adding");
     if (ctrl_x_mode_line_or_eval()) {
       // Insert a new line, keep indentation but ignore 'comments'.
-      char_u *old = curbuf->b_p_com;
+      char *old = curbuf->b_p_com;
 
-      curbuf->b_p_com = (char_u *)"";
+      curbuf->b_p_com = "";
       compl_startpos.lnum = curwin->w_cursor.lnum;
       compl_startpos.col = compl_col;
       ins_eol('\r');
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 38bc187f4f..39585ac182 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -990,7 +990,7 @@ int nlua_in_fast_event(lua_State *lstate)
 
 static bool viml_func_is_fast(const char *name)
 {
-  const EvalFuncDef *const fdef = find_internal_func((const char *)name);
+  const EvalFuncDef *const fdef = find_internal_func(name);
   if (fdef) {
     return fdef->fast;
   }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 9da7e9a947..f7f1de13c4 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -150,7 +150,7 @@ static void showmap(mapblock_T *mp, bool local)
 {
   size_t len = 1;
 
-  if (message_filtered(mp->m_keys) && message_filtered(mp->m_str)
+  if (message_filtered(mp->m_keys) && message_filtered((char_u *)mp->m_str)
       && (mp->m_desc == NULL || message_filtered((char_u *)mp->m_desc))) {
     return;
   }
@@ -203,7 +203,7 @@ static void showmap(mapblock_T *mp, bool local)
   } else if (mp->m_str[0] == NUL) {
     msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
   } else {
-    msg_outtrans_special(mp->m_str, false, 0);
+    msg_outtrans_special((char_u *)mp->m_str, false, 0);
   }
 
   if (mp->m_desc != NULL) {
@@ -449,8 +449,8 @@ static void map_add(buf_T *buf, mapblock_T **map_table, mapblock_T **abbr_table,
   }
 
   mp->m_keys = vim_strsave(keys);
-  mp->m_str = args->rhs;
-  mp->m_orig_str = args->orig_rhs;
+  mp->m_str = (char *)args->rhs;
+  mp->m_orig_str = (char *)args->orig_rhs;
   mp->m_luaref = args->rhs_lua;
   if (!simplified) {
     args->rhs = NULL;
@@ -704,7 +704,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
           } else {                          // do we have a match?
             if (round) {              // second round: Try unmap "rhs" string
               n = (int)STRLEN(mp->m_str);
-              p = mp->m_str;
+              p = (char_u *)mp->m_str;
             } else {
               n = mp->m_keylen;
               p = mp->m_keys;
@@ -761,8 +761,8 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
                     XFREE_CLEAR(mp->m_str);
                     XFREE_CLEAR(mp->m_orig_str);
                   }
-                  mp->m_str = args->rhs;
-                  mp->m_orig_str = args->orig_rhs;
+                  mp->m_str = (char *)args->rhs;
+                  mp->m_orig_str = (char *)args->orig_rhs;
                   mp->m_luaref = args->rhs_lua;
                   if (!keyround1_simplified) {
                     args->rhs = NULL;
@@ -1113,7 +1113,7 @@ int map_to_exists_mode(const char *const rhs, const int mode, const bool abbr)
         mp = maphash[hash];
       }
       for (; mp; mp = mp->m_next) {
-        if ((mp->m_mode & mode) && strstr((char *)mp->m_str, rhs) != NULL) {
+        if ((mp->m_mode & mode) && strstr(mp->m_str, rhs) != NULL) {
           return true;
         }
       }
@@ -1506,7 +1506,7 @@ bool check_abbr(int c, char_u *ptr, int col, int mincol)
       if (mp->m_expr) {
         s = eval_map_expr(mp, c);
       } else {
-        s = mp->m_str;
+        s = (char_u *)mp->m_str;
       }
       if (s != NULL) {
         // insert the to string
@@ -1542,7 +1542,7 @@ char_u *eval_map_expr(mapblock_T *mp, int c)
   // Remove escaping of K_SPECIAL, because "str" is in a format to be used as
   // typeahead.
   if (mp->m_luaref == LUA_NOREF) {
-    expr = vim_strsave(mp->m_str);
+    expr = vim_strsave((char_u *)mp->m_str);
     vim_unescape_ks(expr);
   }
 
@@ -1639,7 +1639,7 @@ int makemap(FILE *fd, buf_T *buf)
         if (mp->m_luaref != LUA_NOREF) {
           continue;
         }
-        for (p = mp->m_str; *p != NUL; p++) {
+        for (p = (char_u *)mp->m_str; *p != NUL; p++) {
           if (p[0] == K_SPECIAL && p[1] == KS_EXTRA
               && p[2] == KE_SNR) {
             break;
@@ -1785,7 +1785,7 @@ int makemap(FILE *fd, buf_T *buf)
           if (putc(' ', fd) < 0
               || put_escstr(fd, mp->m_keys, 0) == FAIL
               || putc(' ', fd) < 0
-              || put_escstr(fd, mp->m_str, 1) == FAIL
+              || put_escstr(fd, (char_u *)mp->m_str, 1) == FAIL
               || put_eol(fd) < 0) {
             return FAIL;
           }
@@ -1956,7 +1956,7 @@ char_u *check_map(char_u *keys, int mode, int exact, int ign_mod, int abbr, mapb
               *local_ptr = local;
             }
             *rhs_lua = mp->m_luaref;
-            return mp->m_luaref == LUA_NOREF ? mp->m_str : NULL;
+            return mp->m_luaref == LUA_NOREF ? (char_u *)mp->m_str : NULL;
           }
         }
       }
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index f9d8422481..83044f209a 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1932,11 +1932,11 @@ void utf_find_illegal(void)
   char_u *tofree = NULL;
 
   vimconv.vc_type = CONV_NONE;
-  if (enc_canon_props(curbuf->b_p_fenc) & ENC_8BIT) {
+  if (enc_canon_props((char_u *)curbuf->b_p_fenc) & ENC_8BIT) {
     // 'encoding' is "utf-8" but we are editing a 8-bit encoded file,
     // possibly a utf-8 file with illegal bytes.  Setup for conversion
     // from utf-8 to 'fileencoding'.
-    convert_setup(&vimconv, p_enc, curbuf->b_p_fenc);
+    convert_setup(&vimconv, p_enc, (char_u *)curbuf->b_p_fenc);
   }
 
   curwin->w_cursor.coladd = 0;
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 980d6908f9..318bd64d88 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -721,7 +721,7 @@ static void add_b0_fenc(ZERO_BL *b0p, buf_T *buf)
     b0p->b0_flags &= (uint8_t) ~B0_HAS_FENC;
   } else {
     memmove((char *)b0p->b0_fname + size - n,
-            (char *)buf->b_p_fenc, (size_t)n);
+            buf->b_p_fenc, (size_t)n);
     *(b0p->b0_fname + size - n - 1) = NUL;
     b0p->b0_flags |= B0_HAS_FENC;
   }
diff --git a/src/nvim/msgpack_rpc/server.c b/src/nvim/msgpack_rpc/server.c
index b252f0998e..532e684f93 100644
--- a/src/nvim/msgpack_rpc/server.c
+++ b/src/nvim/msgpack_rpc/server.c
@@ -216,7 +216,7 @@ bool server_stop(char *endpoint)
   watchers.ga_len--;
 
   // Bump v:servername to the next available server, if any.
-  if (strequal(addr, (char *)get_vim_var_str(VV_SEND_SERVER))) {
+  if (strequal(addr, get_vim_var_str(VV_SEND_SERVER))) {
     set_vservername(&watchers);
   }
 
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 75900b735b..1bd780be0f 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2653,10 +2653,10 @@ void clear_showcmd(void)
 
     if (VIsual_mode == Ctrl_V) {
       char_u *const saved_sbr = p_sbr;
-      char_u *const saved_w_sbr = curwin->w_p_sbr;
+      char *const saved_w_sbr = curwin->w_p_sbr;
 
       // Make 'sbr' empty for a moment to get the correct size.
-      p_sbr = empty_option;
+      p_sbr = (char_u *)empty_option;
       curwin->w_p_sbr = empty_option;
       getvcols(curwin, &curwin->w_cursor, &VIsual, &leftcol, &rightcol);
       p_sbr = saved_sbr;
@@ -4275,7 +4275,7 @@ static void nv_ident(cmdarg_T *cap)
   // Allocate buffer to put the command in.  Inserting backslashes can
   // double the length of the word.  p_kp / curbuf->b_p_kp could be added
   // and some numbers.
-  char_u *kp = *curbuf->b_p_kp == NUL ? p_kp : curbuf->b_p_kp;  // 'keywordprg'
+  char_u *kp = *curbuf->b_p_kp == NUL ? p_kp : (char_u *)curbuf->b_p_kp;  // 'keywordprg'
   assert(*kp != NUL);  // option.c:do_set() should default to ":help" if empty.
   bool kp_ex = (*kp == ':');  // 'keywordprg' is an ex command
   bool kp_help = (STRCMP(kp, ":he") == 0 || STRCMP(kp, ":help") == 0);
@@ -7075,8 +7075,8 @@ static void nv_object(cmdarg_T *cap)
     include = true;         // "ax" = an object: include white space
   }
   // Make sure (), [], {} and <> are in 'matchpairs'
-  mps_save = curbuf->b_p_mps;
-  curbuf->b_p_mps = (char_u *)"(:),{:},[:],<:>";
+  mps_save = (char_u *)curbuf->b_p_mps;
+  curbuf->b_p_mps = "(:),{:},[:],<:>";
 
   switch (cap->nchar) {
   case 'w':       // "aw" = a word
@@ -7130,7 +7130,7 @@ static void nv_object(cmdarg_T *cap)
     break;
   }
 
-  curbuf->b_p_mps = mps_save;
+  curbuf->b_p_mps = (char *)mps_save;
   if (!flag) {
     clearopbeep(cap->oap);
   }
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 1f6b154eed..b30538a9dc 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -4385,23 +4385,20 @@ int fex_format(linenr_T lnum, long count, int c)
 {
   int use_sandbox = was_set_insecurely(curwin, "formatexpr", OPT_LOCAL);
   int r;
-  char_u *fex;
 
-  /*
-   * Set v:lnum to the first line number and v:count to the number of lines.
-   * Set v:char to the character to be inserted (can be NUL).
-   */
+  // Set v:lnum to the first line number and v:count to the number of lines.
+  // Set v:char to the character to be inserted (can be NUL).
   set_vim_var_nr(VV_LNUM, (varnumber_T)lnum);
   set_vim_var_nr(VV_COUNT, (varnumber_T)count);
   set_vim_var_char(c);
 
   // Make a copy, the option could be changed while calling it.
-  fex = vim_strsave(curbuf->b_p_fex);
+  char *fex = xstrdup(curbuf->b_p_fex);
   // Evaluate the function.
   if (use_sandbox) {
     sandbox++;
   }
-  r = (int)eval_to_number((char *)fex);
+  r = (int)eval_to_number(fex);
   if (use_sandbox) {
     sandbox--;
   }
@@ -5008,12 +5005,12 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
   pos_T endpos;
   colnr_T save_coladd = 0;
 
-  const bool do_hex = vim_strchr((char *)curbuf->b_p_nf, 'x') != NULL;    // "heX"
-  const bool do_oct = vim_strchr((char *)curbuf->b_p_nf, 'o') != NULL;    // "Octal"
-  const bool do_bin = vim_strchr((char *)curbuf->b_p_nf, 'b') != NULL;    // "Bin"
-  const bool do_alpha = vim_strchr((char *)curbuf->b_p_nf, 'p') != NULL;  // "alPha"
+  const bool do_hex = vim_strchr(curbuf->b_p_nf, 'x') != NULL;    // "heX"
+  const bool do_oct = vim_strchr(curbuf->b_p_nf, 'o') != NULL;    // "Octal"
+  const bool do_bin = vim_strchr(curbuf->b_p_nf, 'b') != NULL;    // "Bin"
+  const bool do_alpha = vim_strchr(curbuf->b_p_nf, 'p') != NULL;  // "alPha"
   // "Unsigned"
-  const bool do_unsigned = vim_strchr((char *)curbuf->b_p_nf, 'u') != NULL;
+  const bool do_unsigned = vim_strchr(curbuf->b_p_nf, 'u') != NULL;
 
   if (virtual_active()) {
     save_coladd = pos->coladd;
@@ -5886,10 +5883,10 @@ void cursor_pos_info(dict_T *dict)
 
       if (l_VIsual_mode == Ctrl_V) {
         char_u *const saved_sbr = p_sbr;
-        char_u *const saved_w_sbr = curwin->w_p_sbr;
+        char *const saved_w_sbr = curwin->w_p_sbr;
 
         // Make 'sbr' empty for a moment to get the correct size.
-        p_sbr = empty_option;
+        p_sbr = (char_u *)empty_option;
         curwin->w_p_sbr = empty_option;
         oparg.is_VIsual = true;
         oparg.motion_type = kMTBlockWise;
diff --git a/src/nvim/option.c b/src/nvim/option.c
index b1d5be8cb7..b2525b73a0 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -464,7 +464,7 @@ static void set_option_default(int opt_idx, int opt_flags)
                                  (char *)options[opt_idx].def_val, opt_flags, 0);
       } else {
         if ((opt_flags & OPT_FREE) && (flags & P_ALLOCED)) {
-          free_string_option(*(char_u **)(varp));
+          free_string_option(*(char **)(varp));
         }
         *(char_u **)varp = options[opt_idx].def_val;
         options[opt_idx].flags &= ~P_ALLOCED;
@@ -603,14 +603,14 @@ void free_all_options(void)
     if (options[i].indir == PV_NONE) {
       // global option: free value and default value.
       if ((options[i].flags & P_ALLOCED) && options[i].var != NULL) {
-        free_string_option(*(char_u **)options[i].var);
+        free_string_option(*(char **)options[i].var);
       }
       if (options[i].flags & P_DEF_ALLOCED) {
-        free_string_option(options[i].def_val);
+        free_string_option((char *)options[i].def_val);
       }
     } else if (options[i].var != VAR_WIN && (options[i].flags & P_STRING)) {
       // buffer-local option: free global value
-      clear_string_option((char_u **)options[i].var);
+      clear_string_option((char **)options[i].var);
     }
   }
   free_operatorfunc_option();
@@ -730,7 +730,7 @@ void set_helplang_default(const char *lang)
   int idx = findoption("hlg");
   if (idx >= 0 && !(options[idx].flags & P_WAS_SET)) {
     if (options[idx].flags & P_ALLOCED) {
-      free_string_option(p_hlg);
+      free_string_option((char *)p_hlg);
     }
     p_hlg = (char_u *)xmemdupz(lang, lang_len);
     // zh_CN becomes "cn", zh_TW becomes "tw".
@@ -1185,7 +1185,7 @@ int do_set(char *arg, int opt_flags)
               // A global-local string option might have an empty
               // option as value to indicate that the global
               // value should be used.
-              if (((int)options[opt_idx].indir & PV_BOTH) && origval_l == empty_option) {
+              if (((int)options[opt_idx].indir & PV_BOTH) && origval_l == (char_u *)empty_option) {
                 origval_l = origval_g;
               }
             }
@@ -1205,7 +1205,7 @@ int do_set(char *arg, int opt_flags)
               // required when an environment variable was set
               // later
               if (newval == NULL) {
-                newval = empty_option;
+                newval = (char_u *)empty_option;
               } else if (!(options[opt_idx].flags & P_NO_DEF_EXP)) {
                 s = option_expand(opt_idx, newval);
                 if (s == NULL) {
@@ -1233,7 +1233,7 @@ int do_set(char *arg, int opt_flags)
                 i = getdigits_int((char **)varp, true, 0);
                 switch (i) {
                 case 0:
-                  *(char_u **)varp = empty_option;
+                  *(char **)varp = empty_option;
                   break;
                 case 1:
                   *(char_u **)varp = vim_strsave((char_u *)"indent,eol");
@@ -1797,17 +1797,17 @@ static void didset_options2(void)
   highlight_changed();
 
   // Parse default for 'fillchars'.
-  (void)set_chars_option(curwin, &curwin->w_p_fcs, true);
+  (void)set_chars_option(curwin, (char_u **)&curwin->w_p_fcs, true);
 
   // Parse default for 'listchars'.
-  (void)set_chars_option(curwin, &curwin->w_p_lcs, true);
+  (void)set_chars_option(curwin, (char_u **)&curwin->w_p_lcs, true);
 
   // Parse default for 'wildmode'.
   check_opt_wim();
   xfree(curbuf->b_p_vsts_array);
-  (void)tabstop_set(curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
+  (void)tabstop_set((char_u *)curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
   xfree(curbuf->b_p_vts_array);
-  (void)tabstop_set(curbuf->b_p_vts,  &curbuf->b_p_vts_array);
+  (void)tabstop_set((char_u *)curbuf->b_p_vts,  &curbuf->b_p_vts_array);
 }
 
 /// Check for string options that are NULL (normally only termcap options).
@@ -1817,7 +1817,7 @@ void check_options(void)
 
   for (opt_idx = 0; options[opt_idx].fullname != NULL; opt_idx++) {
     if ((options[opt_idx].flags & P_STRING) && options[opt_idx].var != NULL) {
-      check_string_option((char_u **)get_varp(&(options[opt_idx])));
+      check_string_option((char **)get_varp(&(options[opt_idx])));
     }
   }
 }
@@ -3597,12 +3597,12 @@ int makeset(FILE *fd, int opt_flags, int local_only)
 /// 'sessionoptions' or 'viewoptions' contains "folds" but not "options".
 int makefoldset(FILE *fd)
 {
-  if (put_setstring(fd, "setlocal", "fdm", &curwin->w_p_fdm, 0) == FAIL
-      || put_setstring(fd, "setlocal", "fde", &curwin->w_p_fde, 0)
+  if (put_setstring(fd, "setlocal", "fdm", (char_u **)&curwin->w_p_fdm, 0) == FAIL
+      || put_setstring(fd, "setlocal", "fde", (char_u **)&curwin->w_p_fde, 0)
       == FAIL
-      || put_setstring(fd, "setlocal", "fmr", &curwin->w_p_fmr, 0)
+      || put_setstring(fd, "setlocal", "fmr", (char_u **)&curwin->w_p_fmr, 0)
       == FAIL
-      || put_setstring(fd, "setlocal", "fdi", &curwin->w_p_fdi, 0)
+      || put_setstring(fd, "setlocal", "fdi", (char_u **)&curwin->w_p_fdi, 0)
       == FAIL
       || put_setnum(fd, "setlocal", "fdl", &curwin->w_p_fdl) == FAIL
       || put_setnum(fd, "setlocal", "fml", &curwin->w_p_fml) == FAIL
@@ -3803,7 +3803,7 @@ void unset_global_local_option(char *name, void *from)
     clear_string_option(&((win_T *)from)->w_p_stl);
     break;
   case PV_WBR:
-    clear_string_option((char_u **)&((win_T *)from)->w_p_wbr);
+    clear_string_option(&((win_T *)from)->w_p_wbr);
     break;
   case PV_UL:
     buf->b_p_ul = NO_LOCAL_UNDOLEVEL;
@@ -3816,12 +3816,12 @@ void unset_global_local_option(char *name, void *from)
     break;
   case PV_LCS:
     clear_string_option(&((win_T *)from)->w_p_lcs);
-    set_chars_option((win_T *)from, &((win_T *)from)->w_p_lcs, true);
+    set_chars_option((win_T *)from, (char_u **)&((win_T *)from)->w_p_lcs, true);
     redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_FCS:
     clear_string_option(&((win_T *)from)->w_p_fcs);
-    set_chars_option((win_T *)from, &((win_T *)from)->w_p_fcs, true);
+    set_chars_option((win_T *)from, (char_u **)&((win_T *)from)->w_p_fcs, true);
     redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_VE:
@@ -4238,7 +4238,7 @@ char_u *get_equalprg(void)
   if (*curbuf->b_p_ep == NUL) {
     return p_ep;
   }
-  return curbuf->b_p_ep;
+  return (char_u *)curbuf->b_p_ep;
 }
 
 /// Copy options from one window to another.
@@ -4260,19 +4260,19 @@ void copy_winopt(winopt_T *from, winopt_T *to)
   to->wo_list = from->wo_list;
   to->wo_nu = from->wo_nu;
   to->wo_rnu = from->wo_rnu;
-  to->wo_ve = vim_strsave(from->wo_ve);
+  to->wo_ve = xstrdup(from->wo_ve);
   to->wo_ve_flags = from->wo_ve_flags;
   to->wo_nuw = from->wo_nuw;
   to->wo_rl  = from->wo_rl;
-  to->wo_rlc = vim_strsave(from->wo_rlc);
-  to->wo_sbr = vim_strsave(from->wo_sbr);
-  to->wo_stl = vim_strsave(from->wo_stl);
+  to->wo_rlc = xstrdup(from->wo_rlc);
+  to->wo_sbr = xstrdup(from->wo_sbr);
+  to->wo_stl = xstrdup(from->wo_stl);
   to->wo_wbr = xstrdup(from->wo_wbr);
   to->wo_wrap = from->wo_wrap;
   to->wo_wrap_save = from->wo_wrap_save;
   to->wo_lbr = from->wo_lbr;
   to->wo_bri = from->wo_bri;
-  to->wo_briopt = vim_strsave(from->wo_briopt);
+  to->wo_briopt = xstrdup(from->wo_briopt);
   to->wo_scb = from->wo_scb;
   to->wo_scb_save = from->wo_scb_save;
   to->wo_crb = from->wo_crb;
@@ -4280,32 +4280,30 @@ void copy_winopt(winopt_T *from, winopt_T *to)
   to->wo_spell = from->wo_spell;
   to->wo_cuc = from->wo_cuc;
   to->wo_cul = from->wo_cul;
-  to->wo_culopt = vim_strsave(from->wo_culopt);
-  to->wo_cc = vim_strsave(from->wo_cc);
+  to->wo_culopt = xstrdup(from->wo_culopt);
+  to->wo_cc = xstrdup(from->wo_cc);
   to->wo_diff = from->wo_diff;
   to->wo_diff_saved = from->wo_diff_saved;
-  to->wo_cocu = vim_strsave(from->wo_cocu);
+  to->wo_cocu = xstrdup(from->wo_cocu);
   to->wo_cole = from->wo_cole;
-  to->wo_fdc = vim_strsave(from->wo_fdc);
-  to->wo_fdc_save = from->wo_diff_saved
-                    ? vim_strsave(from->wo_fdc_save) : empty_option;
+  to->wo_fdc = xstrdup(from->wo_fdc);
+  to->wo_fdc_save = from->wo_diff_saved ? xstrdup(from->wo_fdc_save) : empty_option;
   to->wo_fen = from->wo_fen;
   to->wo_fen_save = from->wo_fen_save;
-  to->wo_fdi = vim_strsave(from->wo_fdi);
+  to->wo_fdi = xstrdup(from->wo_fdi);
   to->wo_fml = from->wo_fml;
   to->wo_fdl = from->wo_fdl;
   to->wo_fdl_save = from->wo_fdl_save;
-  to->wo_fdm = vim_strsave(from->wo_fdm);
-  to->wo_fdm_save = from->wo_diff_saved
-                    ? vim_strsave(from->wo_fdm_save) : empty_option;
+  to->wo_fdm = xstrdup(from->wo_fdm);
+  to->wo_fdm_save = from->wo_diff_saved ? xstrdup(from->wo_fdm_save) : empty_option;
   to->wo_fdn = from->wo_fdn;
-  to->wo_fde = vim_strsave(from->wo_fde);
-  to->wo_fdt = vim_strsave(from->wo_fdt);
-  to->wo_fmr = vim_strsave(from->wo_fmr);
-  to->wo_scl = vim_strsave(from->wo_scl);
-  to->wo_winhl = vim_strsave(from->wo_winhl);
-  to->wo_fcs = vim_strsave(from->wo_fcs);
-  to->wo_lcs = vim_strsave(from->wo_lcs);
+  to->wo_fde = xstrdup(from->wo_fde);
+  to->wo_fdt = xstrdup(from->wo_fdt);
+  to->wo_fmr = xstrdup(from->wo_fmr);
+  to->wo_scl = xstrdup(from->wo_scl);
+  to->wo_winhl = xstrdup(from->wo_winhl);
+  to->wo_fcs = xstrdup(from->wo_fcs);
+  to->wo_lcs = xstrdup(from->wo_lcs);
   to->wo_winbl = from->wo_winbl;
 
   // Copy the script context so that we know were the value was last set.
@@ -4343,7 +4341,7 @@ static void check_winopt(winopt_T *wop)
   check_string_option(&wop->wo_fcs);
   check_string_option(&wop->wo_lcs);
   check_string_option(&wop->wo_ve);
-  check_string_option((char_u **)&wop->wo_wbr);
+  check_string_option(&wop->wo_wbr);
 }
 
 /// Free the allocated memory inside a winopt_T.
@@ -4369,7 +4367,7 @@ void clear_winopt(winopt_T *wop)
   clear_string_option(&wop->wo_fcs);
   clear_string_option(&wop->wo_lcs);
   clear_string_option(&wop->wo_ve);
-  clear_string_option((char_u **)&wop->wo_wbr);
+  clear_string_option(&wop->wo_wbr);
 }
 
 void didset_window_options(win_T *wp, bool valid_cursor)
@@ -4377,8 +4375,8 @@ void didset_window_options(win_T *wp, bool valid_cursor)
   check_colorcolumn(wp);
   briopt_check(wp);
   fill_culopt_flags(NULL, wp);
-  set_chars_option(wp, &wp->w_p_fcs, true);
-  set_chars_option(wp, &wp->w_p_lcs, true);
+  set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
+  set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
   parse_winhl_opt(wp);  // sets w_hl_needs_update also for w_p_winbl
   check_blending(wp);
   set_winbar_win(wp, false, valid_cursor);
@@ -4451,7 +4449,7 @@ void buf_copy_options(buf_T *buf, int flags)
       // (jumping back to a help file with CTRL-T or CTRL-O)
       dont_do_help = ((flags & BCO_NOHELP) && buf->b_help) || buf->b_p_initialized;
       if (dont_do_help) {               // don't free b_p_isk
-        save_p_isk = buf->b_p_isk;
+        save_p_isk = (char_u *)buf->b_p_isk;
         buf->b_p_isk = NULL;
       }
       // Always free the allocated strings.  If not already initialized,
@@ -4459,19 +4457,19 @@ void buf_copy_options(buf_T *buf, int flags)
       if (!buf->b_p_initialized) {
         free_buf_options(buf, true);
         buf->b_p_ro = false;                    // don't copy readonly
-        buf->b_p_fenc = vim_strsave(p_fenc);
+        buf->b_p_fenc = (char *)vim_strsave(p_fenc);
         switch (*p_ffs) {
         case 'm':
-          buf->b_p_ff = vim_strsave((char_u *)FF_MAC);
+          buf->b_p_ff = xstrdup(FF_MAC);
           break;
         case 'd':
-          buf->b_p_ff = vim_strsave((char_u *)FF_DOS);
+          buf->b_p_ff = xstrdup(FF_DOS);
           break;
         case 'u':
-          buf->b_p_ff = vim_strsave((char_u *)FF_UNIX);
+          buf->b_p_ff = xstrdup(FF_UNIX);
           break;
         default:
-          buf->b_p_ff = vim_strsave(p_ff);
+          buf->b_p_ff = (char *)vim_strsave(p_ff);
           break;
         }
         buf->b_p_bh = empty_option;
@@ -4516,42 +4514,42 @@ void buf_copy_options(buf_T *buf, int flags)
         buf->b_p_swf = p_swf;
         COPY_OPT_SCTX(buf, BV_SWF);
       }
-      buf->b_p_cpt = vim_strsave(p_cpt);
+      buf->b_p_cpt = (char *)vim_strsave(p_cpt);
       COPY_OPT_SCTX(buf, BV_CPT);
 #ifdef BACKSLASH_IN_FILENAME
       buf->b_p_csl = vim_strsave(p_csl);
       COPY_OPT_SCTX(buf, BV_CSL);
 #endif
-      buf->b_p_cfu = vim_strsave(p_cfu);
+      buf->b_p_cfu = (char *)vim_strsave(p_cfu);
       COPY_OPT_SCTX(buf, BV_CFU);
-      buf->b_p_ofu = vim_strsave(p_ofu);
+      buf->b_p_ofu = (char *)vim_strsave(p_ofu);
       COPY_OPT_SCTX(buf, BV_OFU);
-      buf->b_p_tfu = vim_strsave(p_tfu);
+      buf->b_p_tfu = (char *)vim_strsave(p_tfu);
       COPY_OPT_SCTX(buf, BV_TFU);
       buf->b_p_sts = p_sts;
       COPY_OPT_SCTX(buf, BV_STS);
       buf->b_p_sts_nopaste = p_sts_nopaste;
-      buf->b_p_vsts = vim_strsave(p_vsts);
+      buf->b_p_vsts = (char *)vim_strsave(p_vsts);
       COPY_OPT_SCTX(buf, BV_VSTS);
-      if (p_vsts && p_vsts != empty_option) {
+      if (p_vsts && p_vsts != (char_u *)empty_option) {
         (void)tabstop_set(p_vsts, &buf->b_p_vsts_array);
       } else {
         buf->b_p_vsts_array = NULL;
       }
       buf->b_p_vsts_nopaste = p_vsts_nopaste
-                                ? vim_strsave(p_vsts_nopaste)
+                                ? (char *)vim_strsave(p_vsts_nopaste)
                                 : NULL;
-      buf->b_p_com = vim_strsave(p_com);
+      buf->b_p_com = (char *)vim_strsave(p_com);
       COPY_OPT_SCTX(buf, BV_COM);
-      buf->b_p_cms = vim_strsave(p_cms);
+      buf->b_p_cms = (char *)vim_strsave(p_cms);
       COPY_OPT_SCTX(buf, BV_CMS);
-      buf->b_p_fo = vim_strsave(p_fo);
+      buf->b_p_fo = (char *)vim_strsave(p_fo);
       COPY_OPT_SCTX(buf, BV_FO);
-      buf->b_p_flp = vim_strsave(p_flp);
+      buf->b_p_flp = (char *)vim_strsave(p_flp);
       COPY_OPT_SCTX(buf, BV_FLP);
-      buf->b_p_nf = vim_strsave(p_nf);
+      buf->b_p_nf = (char *)vim_strsave(p_nf);
       COPY_OPT_SCTX(buf, BV_NF);
-      buf->b_p_mps = vim_strsave(p_mps);
+      buf->b_p_mps = (char *)vim_strsave(p_mps);
       COPY_OPT_SCTX(buf, BV_MPS);
       buf->b_p_si = p_si;
       COPY_OPT_SCTX(buf, BV_SI);
@@ -4561,18 +4559,18 @@ void buf_copy_options(buf_T *buf, int flags)
       COPY_OPT_SCTX(buf, BV_CI);
       buf->b_p_cin = p_cin;
       COPY_OPT_SCTX(buf, BV_CIN);
-      buf->b_p_cink = vim_strsave(p_cink);
+      buf->b_p_cink = (char *)vim_strsave(p_cink);
       COPY_OPT_SCTX(buf, BV_CINK);
-      buf->b_p_cino = vim_strsave(p_cino);
+      buf->b_p_cino = (char *)vim_strsave(p_cino);
       COPY_OPT_SCTX(buf, BV_CINO);
-      buf->b_p_cinsd = vim_strsave(p_cinsd);
+      buf->b_p_cinsd = (char *)vim_strsave(p_cinsd);
       COPY_OPT_SCTX(buf, BV_CINSD);
 
       // Don't copy 'filetype', it must be detected
       buf->b_p_ft = empty_option;
       buf->b_p_pi = p_pi;
       COPY_OPT_SCTX(buf, BV_PI);
-      buf->b_p_cinw = vim_strsave(p_cinw);
+      buf->b_p_cinw = (char *)vim_strsave(p_cinw);
       COPY_OPT_SCTX(buf, BV_CINW);
       buf->b_p_lisp = p_lisp;
       COPY_OPT_SCTX(buf, BV_LISP);
@@ -4581,25 +4579,25 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_smc = p_smc;
       COPY_OPT_SCTX(buf, BV_SMC);
       buf->b_s.b_syn_isk = empty_option;
-      buf->b_s.b_p_spc = vim_strsave(p_spc);
+      buf->b_s.b_p_spc = (char *)vim_strsave(p_spc);
       COPY_OPT_SCTX(buf, BV_SPC);
       (void)compile_cap_prog(&buf->b_s);
-      buf->b_s.b_p_spf = vim_strsave(p_spf);
+      buf->b_s.b_p_spf = (char *)vim_strsave(p_spf);
       COPY_OPT_SCTX(buf, BV_SPF);
-      buf->b_s.b_p_spl = vim_strsave(p_spl);
+      buf->b_s.b_p_spl = (char *)vim_strsave(p_spl);
       COPY_OPT_SCTX(buf, BV_SPL);
-      buf->b_s.b_p_spo = vim_strsave(p_spo);
+      buf->b_s.b_p_spo = (char *)vim_strsave(p_spo);
       COPY_OPT_SCTX(buf, BV_SPO);
-      buf->b_p_inde = vim_strsave(p_inde);
+      buf->b_p_inde = (char *)vim_strsave(p_inde);
       COPY_OPT_SCTX(buf, BV_INDE);
-      buf->b_p_indk = vim_strsave(p_indk);
+      buf->b_p_indk = (char *)vim_strsave(p_indk);
       COPY_OPT_SCTX(buf, BV_INDK);
       buf->b_p_fp = empty_option;
-      buf->b_p_fex = vim_strsave(p_fex);
+      buf->b_p_fex = (char *)vim_strsave(p_fex);
       COPY_OPT_SCTX(buf, BV_FEX);
-      buf->b_p_sua = vim_strsave(p_sua);
+      buf->b_p_sua = (char *)vim_strsave(p_sua);
       COPY_OPT_SCTX(buf, BV_SUA);
-      buf->b_p_keymap = vim_strsave(p_keymap);
+      buf->b_p_keymap = (char *)vim_strsave(p_keymap);
       COPY_OPT_SCTX(buf, BV_KMAP);
       buf->b_kmap_state |= KEYMAP_INIT;
       // This isn't really an option, but copying the langmap and IME
@@ -4626,12 +4624,12 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_tc_flags = 0;
       buf->b_p_def = empty_option;
       buf->b_p_inc = empty_option;
-      buf->b_p_inex = vim_strsave(p_inex);
+      buf->b_p_inex = (char *)vim_strsave(p_inex);
       COPY_OPT_SCTX(buf, BV_INEX);
       buf->b_p_dict = empty_option;
       buf->b_p_tsr = empty_option;
       buf->b_p_tsrfu = empty_option;
-      buf->b_p_qe = vim_strsave(p_qe);
+      buf->b_p_qe = (char *)vim_strsave(p_qe);
       COPY_OPT_SCTX(buf, BV_QE);
       buf->b_p_udf = p_udf;
       COPY_OPT_SCTX(buf, BV_UDF);
@@ -4645,21 +4643,21 @@ void buf_copy_options(buf_T *buf, int flags)
        * or to a help buffer.
        */
       if (dont_do_help) {
-        buf->b_p_isk = save_p_isk;
-        if (p_vts && p_vts != empty_option && !buf->b_p_vts_array) {
+        buf->b_p_isk = (char *)save_p_isk;
+        if (p_vts && p_vts != (char_u *)empty_option && !buf->b_p_vts_array) {
           (void)tabstop_set(p_vts, &buf->b_p_vts_array);
         } else {
           buf->b_p_vts_array = NULL;
         }
       } else {
-        buf->b_p_isk = vim_strsave(p_isk);
+        buf->b_p_isk = (char *)vim_strsave(p_isk);
         COPY_OPT_SCTX(buf, BV_ISK);
         did_isk = true;
         buf->b_p_ts = p_ts;
         COPY_OPT_SCTX(buf, BV_TS);
-        buf->b_p_vts = vim_strsave(p_vts);
+        buf->b_p_vts = (char *)vim_strsave(p_vts);
         COPY_OPT_SCTX(buf, BV_VTS);
-        if (p_vts && p_vts != empty_option && !buf->b_p_vts_array) {
+        if (p_vts && p_vts != (char_u *)empty_option && !buf->b_p_vts_array) {
           (void)tabstop_set(p_vts, &buf->b_p_vts_array);
         } else {
           buf->b_p_vts_array = NULL;
@@ -5065,7 +5063,7 @@ bool has_format_option(int x)
   if (p_paste) {
     return false;
   }
-  return vim_strchr((char *)curbuf->b_p_fo, x) != NULL;
+  return vim_strchr(curbuf->b_p_fo, x) != NULL;
 }
 
 /// @returns true if "x" is present in 'shortmess' option, or
@@ -5105,7 +5103,7 @@ static void paste_option_changed(void)
           xfree(buf->b_p_vsts_nopaste);
         }
         buf->b_p_vsts_nopaste = buf->b_p_vsts && buf->b_p_vsts != empty_option
-                                    ? vim_strsave(buf->b_p_vsts)
+                                    ? xstrdup(buf->b_p_vsts)
                                     : NULL;
       }
 
@@ -5124,7 +5122,7 @@ static void paste_option_changed(void)
       if (p_vsts_nopaste) {
         xfree(p_vsts_nopaste);
       }
-      p_vsts_nopaste = p_vsts && p_vsts != empty_option
+      p_vsts_nopaste = p_vsts && p_vsts != (char_u *)empty_option
                           ? vim_strsave(p_vsts)
                           : NULL;
     }
@@ -5160,9 +5158,9 @@ static void paste_option_changed(void)
     p_sts = 0;
     p_ai = 0;
     if (p_vsts) {
-      free_string_option(p_vsts);
+      free_string_option((char *)p_vsts);
     }
-    p_vsts = empty_option;
+    p_vsts = (char_u *)empty_option;
   } else if (old_p_paste) {
     // Paste switched from on to off: Restore saved values.
 
@@ -5176,12 +5174,10 @@ static void paste_option_changed(void)
       if (buf->b_p_vsts) {
         free_string_option(buf->b_p_vsts);
       }
-      buf->b_p_vsts = buf->b_p_vsts_nopaste
-                        ? vim_strsave(buf->b_p_vsts_nopaste)
-                        : empty_option;
+      buf->b_p_vsts = buf->b_p_vsts_nopaste ? xstrdup(buf->b_p_vsts_nopaste) : empty_option;
       xfree(buf->b_p_vsts_array);
       if (buf->b_p_vsts && buf->b_p_vsts != empty_option) {
-        (void)tabstop_set(buf->b_p_vsts, &buf->b_p_vsts_array);
+        (void)tabstop_set((char_u *)buf->b_p_vsts, &buf->b_p_vsts_array);
       } else {
         buf->b_p_vsts_array = NULL;
       }
@@ -5203,9 +5199,9 @@ static void paste_option_changed(void)
     p_tw = p_tw_nopaste;
     p_wm = p_wm_nopaste;
     if (p_vsts) {
-      free_string_option(p_vsts);
+      free_string_option((char *)p_vsts);
     }
-    p_vsts = p_vsts_nopaste ? vim_strsave(p_vsts_nopaste) : empty_option;
+    p_vsts = p_vsts_nopaste ? vim_strsave(p_vsts_nopaste) : (char_u *)empty_option;
   }
 
   old_p_paste = p_paste;
@@ -5286,7 +5282,7 @@ int fill_culopt_flags(char_u *val, win_T *wp)
   char_u culopt_flags_new = 0;
 
   if (val == NULL) {
-    p = wp->w_p_culopt;
+    p = (char_u *)wp->w_p_culopt;
   } else {
     p = val;
   }
@@ -5437,7 +5433,7 @@ bool can_bs(int what)
 /// the file must be considered changed when the value is different.
 void save_file_ff(buf_T *buf)
 {
-  buf->b_start_ffc = *buf->b_p_ff;
+  buf->b_start_ffc = (unsigned char)(*buf->b_p_ff);
   buf->b_start_eol = buf->b_p_eol;
   buf->b_start_bomb = buf->b_p_bomb;
 
@@ -5445,7 +5441,7 @@ void save_file_ff(buf_T *buf)
   if (buf->b_start_fenc == NULL
       || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0) {
     xfree(buf->b_start_fenc);
-    buf->b_start_fenc = (char *)vim_strsave(buf->b_p_fenc);
+    buf->b_start_fenc = xstrdup(buf->b_p_fenc);
   }
 }
 
@@ -5493,7 +5489,7 @@ bool briopt_check(win_T *wp)
   bool bri_sbr = false;
   int bri_list = 0;
 
-  char *p = (char *)wp->w_p_briopt;
+  char *p = wp->w_p_briopt;
   while (*p != NUL) {
     if (STRNCMP(p, "shift:", 6) == 0
         && ((p[6] == '-' && ascii_isdigit(p[7])) || ascii_isdigit(p[6]))) {
@@ -5550,16 +5546,16 @@ char_u *get_showbreak_value(win_T *const win)
     return p_sbr;
   }
   if (STRCMP(win->w_p_sbr, "NONE") == 0) {
-    return empty_option;
+    return (char_u *)empty_option;
   }
-  return win->w_p_sbr;
+  return (char_u *)win->w_p_sbr;
 }
 
 /// Return the current end-of-line type: EOL_DOS, EOL_UNIX or EOL_MAC.
 int get_fileformat(const buf_T *buf)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  int c = *buf->b_p_ff;
+  int c = (unsigned char)(*buf->b_p_ff);
 
   if (buf->b_p_bin || c == 'u') {
     return EOL_UNIX;
@@ -5586,7 +5582,7 @@ int get_fileformat_force(const buf_T *buf, const exarg_T *eap)
         ? (eap->force_bin == FORCE_BIN) : buf->b_p_bin) {
       return EOL_UNIX;
     }
-    c = *buf->b_p_ff;
+    c = (unsigned char)(*buf->b_p_ff);
   }
   if (c == 'u') {
     return EOL_UNIX;
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 78ae7e41ab..e1538e0491 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -254,14 +254,14 @@ void check_buf_options(buf_T *buf)
 /// memory, vim_strsave() returned NULL, which was replaced by empty_option by
 /// check_options().
 /// Does NOT check for P_ALLOCED flag!
-void free_string_option(char_u *p)
+void free_string_option(char *p)
 {
   if (p != empty_option) {
     xfree(p);
   }
 }
 
-void clear_string_option(char_u **pp)
+void clear_string_option(char **pp)
 {
   if (*pp != empty_option) {
     xfree(*pp);
@@ -269,7 +269,7 @@ void clear_string_option(char_u **pp)
   *pp = empty_option;
 }
 
-void check_string_option(char_u **pp)
+void check_string_option(char **pp)
 {
   if (*pp == NULL) {
     *pp = empty_option;
@@ -292,7 +292,7 @@ static void set_string_option_global(int opt_idx, char_u **varp)
   }
   if (!is_global_option(opt_idx) && p != varp) {
     s = vim_strsave(*varp);
-    free_string_option(*p);
+    free_string_option((char *)(*p));
     *p = s;
   }
 }
@@ -332,7 +332,7 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
   {
     varp = (char **)get_option_varp_scope(idx, both ? OPT_LOCAL : opt_flags);
     if ((opt_flags & OPT_FREE) && (get_option_flags(idx) & P_ALLOCED)) {
-      free_string_option((char_u *)(*varp));
+      free_string_option(*varp);
     }
     *varp = s;
 
@@ -346,8 +346,8 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
     // When setting both values of a global option with a local value,
     // make the local value empty, so that the global value is used.
     if (is_global_local_option(idx) && both) {
-      free_string_option((char_u *)(*varp));
-      *varp = (char *)empty_option;
+      free_string_option(*varp);
+      *varp = empty_option;
     }
     if (set_sid != SID_NONE) {
       sctx_T script_ctx;
@@ -662,7 +662,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     unsigned int *flags = &bkc_flags;
 
     if (opt_flags & OPT_LOCAL) {
-      bkc   = curbuf->b_p_bkc;
+      bkc = (char_u *)curbuf->b_p_bkc;
       flags = &curbuf->b_bkc_flags;
     }
 
@@ -687,12 +687,12 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
                *p_pm == '.' ? p_pm + 1 : p_pm) == 0) {
       errmsg = e_backupext_and_patchmode_are_equal;
     }
-  } else if (varp == &curwin->w_p_briopt) {  // 'breakindentopt'
+  } else if (varp == (char_u **)&curwin->w_p_briopt) {  // 'breakindentopt'
     if (briopt_check(curwin) == FAIL) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_isi
-             || varp == &(curbuf->b_p_isk)
+             || varp == (char_u **)&(curbuf->b_p_isk)
              || varp == &p_isp
              || varp == &p_isf) {
     // 'isident', 'iskeyword', 'isprint or 'isfname' option: refill g_chartab[]
@@ -712,12 +712,12 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (varp == &p_rtp || varp == &p_pp) {  // 'runtimepath' 'packpath'
     runtime_search_path_invalidate();
-  } else if (varp == &curwin->w_p_culopt
-             || gvarp == &curwin->w_allbuf_opt.wo_culopt) {  // 'cursorlineopt'
+  } else if (varp == (char_u **)&curwin->w_p_culopt
+             || gvarp == (char_u **)&curwin->w_allbuf_opt.wo_culopt) {  // 'cursorlineopt'
     if (**varp == NUL || fill_culopt_flags(*varp, curwin) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == &curwin->w_p_cc) {  // 'colorcolumn'
+  } else if (varp == (char_u **)&curwin->w_p_cc) {  // 'colorcolumn'
     errmsg = check_colorcolumn(curwin);
   } else if (varp == &p_hlg) {  // 'helplang'
     // Check for "", "ab", "ab,cd", etc.
@@ -780,9 +780,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         // value, that's not what we want here.  Disable the color
         // scheme and set the colors again.
         do_unlet(S_LEN("g:colors_name"), true);
-        free_string_option(p_bg);
+        free_string_option((char *)p_bg);
         p_bg = vim_strsave((char_u *)(dark ? "dark" : "light"));
-        check_string_option(&p_bg);
+        check_string_option((char **)&p_bg);
         init_highlight(false, false);
       }
     } else {
@@ -841,7 +841,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     p = (char *)enc_canonize(p_penc);
     xfree(p_penc);
     p_penc = (char_u *)p;
-  } else if (varp == &curbuf->b_p_keymap) {
+  } else if (varp == (char_u **)&curbuf->b_p_keymap) {
     if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
@@ -960,11 +960,11 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       FOR_ALL_TAB_WINDOWS(tp, wp) {
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        (void)set_chars_option(wp, &wp->w_p_lcs, true);
+        (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
       }
       redraw_all_later(UPD_NOT_VALID);
     }
-  } else if (varp == &curwin->w_p_lcs) {  // local 'listchars'
+  } else if (varp == (char_u **)&curwin->w_p_lcs) {  // local 'listchars'
     errmsg = set_chars_option(curwin, varp, true);
   } else if (varp == &p_fcs) {  // global 'fillchars'
     errmsg = set_chars_option(curwin, varp, false);
@@ -977,11 +977,11 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       FOR_ALL_TAB_WINDOWS(tp, wp) {
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        (void)set_chars_option(wp, &wp->w_p_fcs, true);
+        (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
       }
       redraw_all_later(UPD_NOT_VALID);
     }
-  } else if (varp == &curwin->w_p_fcs) {  // local 'fillchars'
+  } else if (varp == (char_u **)&curwin->w_p_fcs) {  // local 'fillchars'
     errmsg = set_chars_option(curwin, varp, true);
   } else if (varp == &p_cedit) {  // 'cedit'
     errmsg = check_cedit();
@@ -1117,11 +1117,11 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     if (opt_strings_flags(p_cb, p_cb_values, &cb_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == &(curwin->w_s->b_p_spl)  // 'spell'
-             || varp == &(curwin->w_s->b_p_spf)) {
+  } else if (varp == (char_u **)&(curwin->w_s->b_p_spl)  // 'spell'
+             || varp == (char_u **)&(curwin->w_s->b_p_spf)) {
     // When 'spelllang' or 'spellfile' is set and there is a window for this
     // buffer in which 'spell' is set load the wordlists.
-    const bool is_spellfile = varp == &(curwin->w_s->b_p_spf);
+    const bool is_spellfile = varp == (char_u **)&(curwin->w_s->b_p_spf);
 
     if ((is_spellfile && !valid_spellfile(*varp))
         || (!is_spellfile && !valid_spelllang(*varp))) {
@@ -1129,10 +1129,10 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     } else {
       errmsg = did_set_spell_option(is_spellfile);
     }
-  } else if (varp == &(curwin->w_s->b_p_spc)) {
+  } else if (varp == (char_u **)&(curwin->w_s->b_p_spc)) {
     // When 'spellcapcheck' is set compile the regexp program.
     errmsg = compile_cap_prog(curwin->w_s);
-  } else if (varp == &(curwin->w_s->b_p_spo)) {  // 'spelloptions'
+  } else if (varp == (char_u **)&(curwin->w_s->b_p_spo)) {  // 'spelloptions'
     if (**varp != NUL && STRCMP("camel", *varp) != 0) {
       errmsg = e_invarg;
     }
@@ -1146,14 +1146,14 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (gvarp == &p_bh) {
     // When 'bufhidden' is set, check for valid value.
-    if (check_opt_strings(curbuf->b_p_bh, p_bufhidden_values, false) != OK) {
+    if (check_opt_strings((char_u *)curbuf->b_p_bh, p_bufhidden_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_bt) {
     // When 'buftype' is set, check for valid value.
     if ((curbuf->terminal && curbuf->b_p_bt[0] != 't')
         || (!curbuf->terminal && curbuf->b_p_bt[0] == 't')
-        || check_opt_strings(curbuf->b_p_bt, p_buftype_values, false) != OK) {
+        || check_opt_strings((char_u *)curbuf->b_p_bt, p_buftype_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       if (curwin->w_status_height || global_stl_height()) {
@@ -1241,7 +1241,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_invarg;
     }
 #endif
-  } else if (varp == &curwin->w_p_scl) {  // 'signcolumn'
+  } else if (varp == (char_u **)&curwin->w_p_scl) {  // 'signcolumn'
     if (check_signcolumn(*varp) != OK) {
       errmsg = e_invarg;
     }
@@ -1252,7 +1252,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         && (curwin->w_p_nu || curwin->w_p_rnu)) {
       curwin->w_nrwidth_line_count = 0;
     }
-  } else if (varp == &curwin->w_p_fdc || varp == &curwin->w_allbuf_opt.wo_fdc) {
+  } else if (varp == (char_u **)&curwin->w_p_fdc
+             || varp == (char_u **)&curwin->w_allbuf_opt.wo_fdc) {
     // 'foldcolumn'
     if (**varp == NUL || check_opt_strings(*varp, p_fdc_values, false) != OK) {
       errmsg = e_invarg;
@@ -1266,7 +1267,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
                               &p, REPTERM_FROM_PART | REPTERM_DO_LT, NULL,
                               CPO_TO_CPO_FLAGS);
       if (p != NULL) {
-        free_string_option(p_pt);
+        free_string_option((char *)p_pt);
         p_pt = (char_u *)p;
       }
     }
@@ -1286,7 +1287,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     unsigned int *flags;
 
     if (opt_flags & OPT_LOCAL) {
-      p = (char *)curbuf->b_p_tc;
+      p = curbuf->b_p_tc;
       flags = &curbuf->b_tc_flags;
     } else {
       p = (char *)p_tc;
@@ -1308,7 +1309,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     if (diffopt_changed() == FAIL) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == &curwin->w_allbuf_opt.wo_fdm) {  // 'foldmethod'
+  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdm) {  // 'foldmethod'
     if (check_opt_strings(*varp, p_fdm_values, false) != OK
         || *curwin->w_p_fdm == NUL) {
       errmsg = e_invarg;
@@ -1318,11 +1319,11 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         newFoldLevel();
       }
     }
-  } else if (varp == &curwin->w_p_fde) {  // 'foldexpr'
+  } else if (varp == (char_u **)&curwin->w_p_fde) {  // 'foldexpr'
     if (foldmethodIsExpr(curwin)) {
       foldUpdateAll(curwin);
     }
-  } else if (gvarp == &curwin->w_allbuf_opt.wo_fmr) {  // 'foldmarker'
+  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fmr) {  // 'foldmarker'
     p = vim_strchr((char *)(*varp), ',');
     if (p == NULL) {
       errmsg = N_("E536: comma required");
@@ -1343,7 +1344,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     if (check_opt_strings(p_fcl, p_fcl_values, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == &curwin->w_allbuf_opt.wo_fdi) {  // 'foldignore'
+  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdi) {  // 'foldignore'
     if (foldmethodIsIndent(curwin)) {
       foldUpdateAll(curwin);
     }
@@ -1352,7 +1353,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     unsigned int *flags = &ve_flags;
 
     if (opt_flags & OPT_LOCAL) {
-      ve = curwin->w_p_ve;
+      ve = (char_u *)curwin->w_p_ve;
       flags = &curwin->w_ve_flags;
     }
 
@@ -1413,7 +1414,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       // even when the value comes from a modeline.
       *value_checked = true;
     }
-  } else if (varp == &curwin->w_p_winhl) {
+  } else if (varp == (char_u **)&curwin->w_p_winhl) {
     if (!parse_winhl_opt(curwin)) {
       errmsg = e_invarg;
     }
@@ -1421,7 +1422,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     if (opt_strings_flags(p_tpf, p_tpf_values, &tpf_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == &(curbuf->b_p_vsts)) {  // 'varsofttabstop'
+  } else if (varp == (char_u **)&(curbuf->b_p_vsts)) {  // 'varsofttabstop'
     char_u *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
@@ -1446,7 +1447,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         }
       }
     }
-  } else if (varp == &(curbuf->b_p_vts)) {  // 'vartabstop'
+  } else if (varp == (char_u **)&(curbuf->b_p_vts)) {  // 'vartabstop'
     char_u *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
@@ -1492,9 +1493,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       p = (char *)SHM_ALL;
     } else if (varp == (char_u **)&(p_cpo)) {  // 'cpoptions'
       p = CPO_VI;
-    } else if (varp == &(curbuf->b_p_fo)) {  // 'formatoptions'
+    } else if (varp == (char_u **)&(curbuf->b_p_fo)) {  // 'formatoptions'
       p = FO_ALL;
-    } else if (varp == &curwin->w_p_cocu) {  // 'concealcursor'
+    } else if (varp == (char_u **)&curwin->w_p_cocu) {  // 'concealcursor'
       p = COCU_ALL;
     } else if (varp == &p_mouse) {  // 'mouse'
       p = MOUSE_ALL;
@@ -1511,7 +1512,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
 
   // If error detected, restore the previous value.
   if (errmsg != NULL) {
-    free_string_option(*varp);
+    free_string_option((char *)(*varp));
     *varp = oldval;
     // When resetting some values, need to act on it.
     if (did_chartab) {
@@ -1524,7 +1525,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     // Use "free_oldval", because recursiveness may change the flags under
     // our fingers (esp. init_highlight()).
     if (free_oldval) {
-      free_string_option(oldval);
+      free_string_option((char *)oldval);
     }
     set_option_flag(opt_idx, P_ALLOCED);
 
@@ -1533,8 +1534,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       // global option with local value set to use global value; free
       // the local value and make it empty
       p = (char *)get_option_varp_scope(opt_idx, OPT_LOCAL);
-      free_string_option(*(char_u **)p);
-      *(char_u **)p = empty_option;
+      free_string_option(*(char **)p);
+      *(char **)p = empty_option;
     } else if (!(opt_flags & OPT_LOCAL) && opt_flags != OPT_GLOBAL) {
       // May set global value for local option.
       set_string_option_global(opt_idx, varp);
@@ -1542,17 +1543,17 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
 
     // Trigger the autocommand only after setting the flags.
     // When 'syntax' is set, load the syntax of that name
-    if (varp == &(curbuf->b_p_syn)) {
+    if (varp == (char_u **)&(curbuf->b_p_syn)) {
       static int syn_recursive = 0;
 
       syn_recursive++;
       // Only pass true for "force" when the value changed or not used
       // recursively, to avoid endless recurrence.
-      apply_autocmds(EVENT_SYNTAX, (char *)curbuf->b_p_syn, curbuf->b_fname,
+      apply_autocmds(EVENT_SYNTAX, curbuf->b_p_syn, curbuf->b_fname,
                      value_changed || syn_recursive == 1, curbuf);
       curbuf->b_flags |= BF_SYN_SET;
       syn_recursive--;
-    } else if (varp == &(curbuf->b_p_ft)) {
+    } else if (varp == (char_u **)&(curbuf->b_p_ft)) {
       // 'filetype' is set, trigger the FileType autocommand
       // Skip this when called from a modeline and the filetype was
       // already set to this value.
@@ -1568,19 +1569,19 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         did_filetype = true;
         // Only pass true for "force" when the value changed or not
         // used recursively, to avoid endless recurrence.
-        apply_autocmds(EVENT_FILETYPE, (char *)curbuf->b_p_ft, curbuf->b_fname,
+        apply_autocmds(EVENT_FILETYPE, curbuf->b_p_ft, curbuf->b_fname,
                        value_changed || ft_recursive == 1, curbuf);
         ft_recursive--;
         // Just in case the old "curbuf" is now invalid
-        if (varp != &(curbuf->b_p_ft)) {
+        if (varp != (char_u **)&(curbuf->b_p_ft)) {
           varp = NULL;
         }
         secure = secure_save;
       }
     }
-    if (varp == &(curwin->w_s->b_p_spl)) {
+    if (varp == (char_u **)&(curwin->w_s->b_p_spl)) {
       char_u fname[200];
-      char_u *q = curwin->w_s->b_p_spl;
+      char_u *q = (char_u *)curwin->w_s->b_p_spl;
 
       // Skip the first name if it is "cjk".
       if (STRNCMP(q, "cjk,", 4) == 0) {
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index b793b8f9c6..574543b1a5 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -74,7 +74,7 @@ static bool have_wildcard(int num, char **file)
 static bool have_dollars(int num, char **file)
 {
   for (int i = 0; i < num; i++) {
-    if (vim_strchr((char *)file[i], '$') != NULL) {
+    if (vim_strchr(file[i], '$') != NULL) {
       return true;
     }
   }
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 3b3156bc73..e4215c89c2 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -376,16 +376,16 @@ int path_fnamencmp(const char *const fname1, const char *const fname2, size_t le
   const char *p1 = fname1;
   const char *p2 = fname2;
   while (len > 0) {
-    c1 = utf_ptr2char((const char_u *)p1);
-    c2 = utf_ptr2char((const char_u *)p2);
+    c1 = utf_ptr2char(p1);
+    c2 = utf_ptr2char(p2);
     if ((c1 == NUL || c2 == NUL
          || (!((c1 == '/' || c1 == '\\') && (c2 == '\\' || c2 == '/'))))
         && (p_fic ? (c1 != c2 && CH_FOLD(c1) != CH_FOLD(c2)) : c1 != c2)) {
       break;
     }
-    len -= (size_t)utfc_ptr2len((const char_u *)p1);
-    p1 += utfc_ptr2len((const char_u *)p1);
-    p2 += utfc_ptr2len((const char_u *)p2);
+    len -= (size_t)utfc_ptr2len(p1);
+    p1 += utfc_ptr2len(p1);
+    p2 += utfc_ptr2len(p2);
   }
   return p_fic ? CH_FOLD(c1) - CH_FOLD(c2) : c1 - c2;
 #else
@@ -843,7 +843,7 @@ static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
  */
 static void expand_path_option(char_u *curdir, garray_T *gap)
 {
-  char_u *path_option = *curbuf->b_p_path == NUL ? p_path : curbuf->b_p_path;
+  char_u *path_option = *curbuf->b_p_path == NUL ? p_path : (char_u *)curbuf->b_p_path;
   char_u *buf = xmalloc(MAXPATHL);
 
   while (*path_option != NUL) {
@@ -1684,7 +1684,7 @@ void simplify_filename(char_u *filename)
 static char *eval_includeexpr(const char *const ptr, const size_t len)
 {
   set_vim_var_string(VV_FNAME, ptr, (ptrdiff_t)len);
-  char *res = eval_to_string_safe((char *)curbuf->b_p_inex, NULL,
+  char *res = eval_to_string_safe(curbuf->b_p_inex, NULL,
                                   was_set_insecurely(curwin, "includeexpr", OPT_LOCAL));
   set_vim_var_string(VV_FNAME, NULL, 0);
   return res;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 6ce2b4d878..a6d5098a20 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1091,7 +1091,7 @@ static int qf_init_ext(qf_info_T *qi, int qf_idx, const char *restrict efile, bu
 
   // Use the local value of 'errorformat' if it's set.
   if (errorformat == p_efm && tv == NULL && buf && *buf->b_p_efm != NUL) {
-    efm = (char *)buf->b_p_efm;
+    efm = buf->b_p_efm;
   } else {
     efm = errorformat;
   }
@@ -2534,7 +2534,7 @@ static int qf_open_new_file_win(qf_info_T *ll_ref)
   if (win_split(0, flags) == FAIL) {
     return FAIL;  // not enough room for window
   }
-  p_swb = empty_option;  // don't split again
+  p_swb = (char_u *)empty_option;  // don't split again
   swb_flags = 0;
   RESET_BINDING(curwin);
   if (ll_ref != NULL) {
@@ -2994,7 +2994,7 @@ theend:
     qfl->qf_ptr = qf_ptr;
     qfl->qf_index = qf_index;
   }
-  if (p_swb != (char_u *)old_swb && p_swb == empty_option) {
+  if (p_swb != (char_u *)old_swb && p_swb == (char_u *)empty_option) {
     // Restore old 'switchbuf' value, but not when an autocommand or
     // modeline has changed the value.
     p_swb = (char_u *)old_swb;
@@ -4183,7 +4183,7 @@ int grep_internal(cmdidx_T cmdidx)
           || cmdidx == CMD_grepadd
           || cmdidx == CMD_lgrepadd)
          && STRCMP("internal",
-                   *curbuf->b_p_gp == NUL ? p_gp : curbuf->b_p_gp) == 0;
+                   *curbuf->b_p_gp == NUL ? p_gp : (char_u *)curbuf->b_p_gp) == 0;
 }
 
 // Return the make/grep autocmd name.
@@ -4241,7 +4241,7 @@ static char *make_get_fullcmd(const char *makecmd, const char *fname)
 // Used for ":make", ":lmake", ":grep", ":lgrep", ":grepadd", and ":lgrepadd"
 void ex_make(exarg_T *eap)
 {
-  char *enc = (*curbuf->b_p_menc != NUL) ? (char *)curbuf->b_p_menc : (char *)p_menc;
+  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : (char *)p_menc;
 
   // Redirect ":grep" to ":vimgrep" if 'grepprg' is "internal".
   if (grep_internal(eap->cmdidx)) {
@@ -4981,7 +4981,7 @@ void ex_cfile(exarg_T *eap)
     set_string_option_direct("ef", -1, eap->arg, OPT_FREE, 0);
   }
 
-  char *enc = (*curbuf->b_p_menc != NUL) ? (char *)curbuf->b_p_menc : (char *)p_menc;
+  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : (char *)p_menc;
 
   if (is_loclist_cmd(eap->cmdidx)) {
     wp = curwin;
@@ -5305,7 +5305,7 @@ static int vgr_process_args(exarg_T *eap, vgr_args_T *args)
   }
 
   // Parse the list of arguments, wildcards have already been expanded.
-  if (get_arglist_exp((char_u *)p, &args->fcount, &args->fnames, true) == FAIL) {
+  if (get_arglist_exp(p, &args->fcount, &args->fnames, true) == FAIL) {
     return FAIL;
   }
   if (args->fcount == 0) {
@@ -5429,7 +5429,7 @@ static int vgr_process_files(win_T *wp, qf_info_T *qi, vgr_args_T *cmd_args, boo
           // options!
           aco_save_T aco;
           aucmd_prepbuf(&aco, buf);
-          apply_autocmds(EVENT_FILETYPE, (char *)buf->b_p_ft, buf->b_fname, true, buf);
+          apply_autocmds(EVENT_FILETYPE, buf->b_p_ft, buf->b_fname, true, buf);
           do_modelines(OPT_NOWIN);
           aucmd_restbuf(&aco);
         }
@@ -7065,7 +7065,7 @@ void ex_helpgrep(exarg_T *eap)
   bool updated = false;
   // Make 'cpoptions' empty, the 'l' flag should not be used here.
   char *const save_cpo = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
 
   bool new_qi = false;
   if (is_loclist_cmd(eap->cmdidx)) {
@@ -7096,7 +7096,7 @@ void ex_helpgrep(exarg_T *eap)
     updated = true;
   }
 
-  if ((char_u *)p_cpo == empty_option) {
+  if (p_cpo == empty_option) {
     p_cpo = save_cpo;
   } else {
     // Darn, some plugin changed the value.  If it's still empty it was
@@ -7104,7 +7104,7 @@ void ex_helpgrep(exarg_T *eap)
     if (*p_cpo == NUL) {
       set_option_value_give_err("cpo", 0L, save_cpo, 0);
     }
-    free_string_option((char_u *)save_cpo);
+    free_string_option(save_cpo);
   }
 
   if (updated) {
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 58e195b745..2ed31ae8a9 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -69,7 +69,7 @@ bool conceal_cursor_line(const win_T *wp)
   } else {
     return false;
   }
-  return vim_strchr((char *)wp->w_p_cocu, c) != NULL;
+  return vim_strchr(wp->w_p_cocu, c) != NULL;
 }
 
 /// Whether cursorline is drawn in a special way
@@ -535,7 +535,7 @@ bool get_keymap_str(win_T *wp, char *fmt, char *buf, int len)
     curwin = old_curwin;
     if (p == NULL || *p == NUL) {
       if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED) {
-        p = (char *)wp->w_buffer->b_p_keymap;
+        p = wp->w_buffer->b_p_keymap;
       } else {
         p = "lang";
       }
@@ -1347,16 +1347,16 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
     { &wp->w_p_lcs_chars.conceal, "conceal",  NUL },
   };
 
-  if (varp == &p_lcs || varp == &wp->w_p_lcs) {
+  if (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs) {
     tab = lcs_tab;
     entries = ARRAY_SIZE(lcs_tab);
-    if (varp == &wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
+    if (varp == (char_u **)&wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
       varp = &p_lcs;
     }
   } else {
     tab = fcs_tab;
     entries = ARRAY_SIZE(fcs_tab);
-    if (varp == &wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
+    if (varp == (char_u **)&wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
       varp = &p_fcs;
     }
   }
@@ -1370,7 +1370,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
           *(tab[i].cp) = tab[i].def;
         }
       }
-      if (varp == &p_lcs || varp == &wp->w_p_lcs) {
+      if (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs) {
         wp->w_p_lcs_chars.tab1 = NUL;
         wp->w_p_lcs_chars.tab3 = NUL;
 
@@ -1439,7 +1439,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
       if (i == entries) {
         len = (int)STRLEN("multispace");
         len2 = (int)STRLEN("leadmultispace");
-        if ((varp == &p_lcs || varp == &wp->w_p_lcs)
+        if ((varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs)
             && STRNCMP(p, "multispace", len) == 0
             && p[len] == ':'
             && p[len + 1] != NUL) {
@@ -1470,7 +1470,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
             }
             p = s;
           }
-        } else if ((varp == &p_lcs || varp == &wp->w_p_lcs)
+        } else if ((varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs)
                    && STRNCMP(p, "leadmultispace", len2) == 0
                    && p[len2] == ':'
                    && p[len2 + 1] != NUL) {
@@ -1527,10 +1527,10 @@ char *check_chars_options(void)
     return e_conflicts_with_value_of_fillchars;
   }
   FOR_ALL_TAB_WINDOWS(tp, wp) {
-    if (set_chars_option(wp, &wp->w_p_lcs, true) != NULL) {
+    if (set_chars_option(wp, (char_u **)&wp->w_p_lcs, true) != NULL) {
       return e_conflicts_with_value_of_listchars;
     }
-    if (set_chars_option(wp, &wp->w_p_fcs, true) != NULL) {
+    if (set_chars_option(wp, (char_u **)&wp->w_p_fcs, true) != NULL) {
       return e_conflicts_with_value_of_fillchars;
     }
   }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 6e5e12dd17..34ff30a8da 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1696,34 +1696,34 @@ static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos)
 static void find_mps_values(int *initc, int *findc, bool *backwards, bool switchit)
   FUNC_ATTR_NONNULL_ALL
 {
-  char_u *ptr = curbuf->b_p_mps;
+  char *ptr = curbuf->b_p_mps;
 
   while (*ptr != NUL) {
-    if (utf_ptr2char((char *)ptr) == *initc) {
+    if (utf_ptr2char(ptr) == *initc) {
       if (switchit) {
         *findc = *initc;
-        *initc = utf_ptr2char((char *)ptr + utfc_ptr2len((char *)ptr) + 1);
+        *initc = utf_ptr2char(ptr + utfc_ptr2len(ptr) + 1);
         *backwards = true;
       } else {
-        *findc = utf_ptr2char((char *)ptr + utfc_ptr2len((char *)ptr) + 1);
+        *findc = utf_ptr2char(ptr + utfc_ptr2len(ptr) + 1);
         *backwards = false;
       }
       return;
     }
-    char_u *prev = ptr;
-    ptr += utfc_ptr2len((char *)ptr) + 1;
-    if (utf_ptr2char((char *)ptr) == *initc) {
+    char *prev = ptr;
+    ptr += utfc_ptr2len(ptr) + 1;
+    if (utf_ptr2char(ptr) == *initc) {
       if (switchit) {
         *findc = *initc;
-        *initc = utf_ptr2char((char *)prev);
+        *initc = utf_ptr2char(prev);
         *backwards = false;
       } else {
-        *findc = utf_ptr2char((char *)prev);
+        *findc = utf_ptr2char(prev);
         *backwards = true;
       }
       return;
     }
-    ptr += utfc_ptr2len((char *)ptr);
+    ptr += utfc_ptr2len(ptr);
     if (*ptr == ',') {
       ptr++;
     }
@@ -2376,7 +2376,7 @@ void showmatch(int c)
    * Only show match for chars in the 'matchpairs' option.
    */
   // 'matchpairs' is "x:y,x:y"
-  for (p = curbuf->b_p_mps; *p != NUL; p++) {
+  for (p = (char_u *)curbuf->b_p_mps; *p != NUL; p++) {
     if (utf_ptr2char((char *)p) == c && (curwin->w_p_rl ^ p_ri)) {
       break;
     }
@@ -4090,8 +4090,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
       if (col_start < 0) {
         goto abort_search;
       }
-      col_end = find_next_quote(line, col_start + 1, quotechar,
-                                curbuf->b_p_qe);
+      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
       if (col_end < 0) {
         // We were on a starting quote perhaps?
         col_end = col_start;
@@ -4102,8 +4101,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
       if (line[col_end] != quotechar) {
         goto abort_search;
       }
-      col_start = find_prev_quote(line, col_end, quotechar,
-                                  curbuf->b_p_qe);
+      col_start = find_prev_quote(line, col_end, quotechar, (char_u *)curbuf->b_p_qe);
       if (line[col_start] != quotechar) {
         // We were on an ending quote perhaps?
         col_start = col_end;
@@ -4132,8 +4130,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
         goto abort_search;
       }
       // Find close quote character.
-      col_end = find_next_quote(line, col_start + 1, quotechar,
-                                curbuf->b_p_qe);
+      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
       if (col_end < 0) {
         goto abort_search;
       }
@@ -4146,7 +4143,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
     }
   } else {
     // Search backward for a starting quote.
-    col_start = find_prev_quote(line, col_start, quotechar, curbuf->b_p_qe);
+    col_start = find_prev_quote(line, col_start, quotechar, (char_u *)curbuf->b_p_qe);
     if (line[col_start] != quotechar) {
       // No quote before the cursor, look after the cursor.
       col_start = find_next_quote(line, col_start, quotechar, NULL);
@@ -4156,8 +4153,7 @@ bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
     }
 
     // Find close quote character.
-    col_end = find_next_quote(line, col_start + 1, quotechar,
-                              curbuf->b_p_qe);
+    col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
     if (col_end < 0) {
       goto abort_search;
     }
@@ -5375,7 +5371,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
       goto fpip_end;
     }
   }
-  inc_opt = (*curbuf->b_p_inc == NUL) ? p_inc : curbuf->b_p_inc;
+  inc_opt = (*curbuf->b_p_inc == NUL) ? p_inc : (char_u *)curbuf->b_p_inc;
   if (*inc_opt != NUL) {
     incl_regmatch.regprog = vim_regcomp((char *)inc_opt, p_magic ? RE_MAGIC : 0);
     if (incl_regmatch.regprog == NULL) {
@@ -5385,7 +5381,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
   }
   if (type == FIND_DEFINE && (*curbuf->b_p_def != NUL || *p_def != NUL)) {
     def_regmatch.regprog = vim_regcomp(*curbuf->b_p_def == NUL
-                                       ? (char *)p_def : (char *)curbuf->b_p_def,
+                                       ? (char *)p_def : curbuf->b_p_def,
                                        p_magic ? RE_MAGIC : 0);
     if (def_regmatch.regprog == NULL) {
       goto fpip_end;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index ecb97afd02..439fcff8a0 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -1837,7 +1837,7 @@ char *did_set_spelllang(win_T *wp)
 
   // Make a copy of 'spelllang', the SpellFileMissing autocommands may change
   // it under our fingers.
-  spl_copy = vim_strsave(wp->w_s->b_p_spl);
+  spl_copy = vim_strsave((char_u *)wp->w_s->b_p_spl);
 
   wp->w_s->b_cjk = 0;
 
@@ -1966,7 +1966,7 @@ char *did_set_spelllang(win_T *wp)
   // round 1: load first name in 'spellfile'.
   // round 2: load second name in 'spellfile.
   // etc.
-  spf = (char *)curwin->w_s->b_p_spf;
+  spf = curwin->w_s->b_p_spf;
   for (round = 0; round == 0 || *spf != NUL; round++) {
     if (round == 0) {
       // Internal wordlist, if there is one.
@@ -2120,13 +2120,13 @@ static void use_midword(slang_T *lp, win_T *wp)
       wp->w_s->b_spell_ismw[c] = true;
     } else if (wp->w_s->b_spell_ismw_mb == NULL) {
       // First multi-byte char in "b_spell_ismw_mb".
-      wp->w_s->b_spell_ismw_mb = vim_strnsave(p, (size_t)l);
+      wp->w_s->b_spell_ismw_mb = (char *)vim_strnsave(p, (size_t)l);
     } else {
       // Append multi-byte chars to "b_spell_ismw_mb".
       const int n = (int)STRLEN(wp->w_s->b_spell_ismw_mb);
-      char_u *bp = vim_strnsave(wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
+      char_u *bp = vim_strnsave((char_u *)wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
       xfree(wp->w_s->b_spell_ismw_mb);
-      wp->w_s->b_spell_ismw_mb = bp;
+      wp->w_s->b_spell_ismw_mb = (char *)bp;
       STRLCPY(bp + n, p, l + 1);
     }
     p += l;
@@ -2359,7 +2359,7 @@ bool spell_iswordp(const char_u *p, const win_T *wp)
     if (c < 256
         ? wp->w_s->b_spell_ismw[c]
         : (wp->w_s->b_spell_ismw_mb != NULL
-           && vim_strchr((char *)wp->w_s->b_spell_ismw_mb, c) != NULL)) {
+           && vim_strchr(wp->w_s->b_spell_ismw_mb, c) != NULL)) {
       s = p + l;
     }
   }
@@ -2405,7 +2405,7 @@ static bool spell_iswordp_w(const int *p, const win_T *wp)
 
   if (*p <
       256 ? wp->w_s->b_spell_ismw[*p] : (wp->w_s->b_spell_ismw_mb != NULL
-                                         && vim_strchr((char *)wp->w_s->b_spell_ismw_mb,
+                                         && vim_strchr(wp->w_s->b_spell_ismw_mb,
                                                        *p) != NULL)) {
     s = p + 1;
   } else {
@@ -3599,7 +3599,7 @@ char *compile_cap_prog(synblock_T *synblock)
     synblock->b_cap_prog = NULL;
   } else {
     // Prepend a ^ so that we only match at one column
-    char_u *re = concat_str((char_u *)"^", synblock->b_p_spc);
+    char_u *re = concat_str((char_u *)"^", (char_u *)synblock->b_p_spc);
     synblock->b_cap_prog = vim_regcomp((char *)re, RE_MAGIC);
     xfree(re);
     if (synblock->b_cap_prog == NULL) {
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 676eff9f4a..0fd7351d26 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -4877,12 +4877,12 @@ void ex_mkspell(exarg_T *eap)
 {
   int fcount;
   char **fnames;
-  char_u *arg = (char_u *)eap->arg;
+  char *arg = eap->arg;
   bool ascii = false;
 
   if (STRNCMP(arg, "-ascii", 6) == 0) {
     ascii = true;
-    arg = (char_u *)skipwhite((char *)arg + 6);
+    arg = skipwhite(arg + 6);
   }
 
   // Expand all the remaining arguments (e.g., $VIMRUNTIME).
@@ -5552,7 +5552,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
     }
     fnamebuf = xmalloc(MAXPATHL);
 
-    for (spf = curwin->w_s->b_p_spf, i = 1; *spf != NUL; i++) {
+    for (spf = (char_u *)curwin->w_s->b_p_spf, i = 1; *spf != NUL; i++) {
       copy_option_part((char **)&spf, (char *)fnamebuf, MAXPATHL, ",");
       if (i == idx) {
         break;
@@ -5680,14 +5680,14 @@ static void init_spellfile(void)
   char_u *rtp;
   char_u *lend;
   bool aspath = false;
-  char_u *lstart = curbuf->b_s.b_p_spl;
+  char_u *lstart = (char_u *)curbuf->b_s.b_p_spl;
 
   if (*curwin->w_s->b_p_spl != NUL && !GA_EMPTY(&curwin->w_s->b_langp)) {
     buf = xmalloc(MAXPATHL);
 
     // Find the end of the language name.  Exclude the region.  If there
     // is a path separator remember the start of the tail.
-    for (lend = curwin->w_s->b_p_spl; *lend != NUL
+    for (lend = (char_u *)curwin->w_s->b_p_spl; *lend != NUL
          && vim_strchr(",._", *lend) == NULL; lend++) {
       if (vim_ispathsep(*lend)) {
         aspath = true;
@@ -5702,8 +5702,7 @@ static void init_spellfile(void)
       if (aspath) {
         // Use directory of an entry with path, e.g., for
         // "/dir/lg.utf-8.spl" use "/dir".
-        STRLCPY(buf, curbuf->b_s.b_p_spl,
-                lstart - curbuf->b_s.b_p_spl);
+        STRLCPY(buf, curbuf->b_s.b_p_spl, lstart - (char_u *)curbuf->b_s.b_p_spl);
       } else {
         // Copy the path from 'runtimepath' to buf[].
         copy_option_part((char **)&rtp, (char *)buf, MAXPATHL, ",");
@@ -5712,8 +5711,7 @@ static void init_spellfile(void)
         // Use the first language name from 'spelllang' and the
         // encoding used in the first loaded .spl file.
         if (aspath) {
-          STRLCPY(buf, curbuf->b_s.b_p_spl,
-                  lend - curbuf->b_s.b_p_spl + 1);
+          STRLCPY(buf, curbuf->b_s.b_p_spl, lend - (char_u *)curbuf->b_s.b_p_spl + 1);
         } else {
           // Create the "spell" directory if it doesn't exist yet.
           l = (int)STRLEN(buf);
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index e868a79b9a..d7277b38ae 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -522,7 +522,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
       use_sandbox = was_set_insecurely(wp, "rulerformat", 0);
     } else {
       if (*wp->w_p_stl != NUL) {
-        stl = wp->w_p_stl;
+        stl = (char_u *)wp->w_p_stl;
       } else {
         stl = p_stl;
       }
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 7794499582..69a5225edc 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -3162,7 +3162,7 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
     msg_puts("\n");
     if (curwin->w_s->b_syn_isk != empty_option) {
       msg_puts("syntax iskeyword ");
-      msg_outtrans((char *)curwin->w_s->b_syn_isk);
+      msg_outtrans(curwin->w_s->b_syn_isk);
     } else {
       msg_outtrans(_("syntax iskeyword not set"));
     }
@@ -3172,15 +3172,15 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
       clear_string_option(&curwin->w_s->b_syn_isk);
     } else {
       memmove(save_chartab, curbuf->b_chartab, (size_t)32);
-      save_isk = curbuf->b_p_isk;
-      curbuf->b_p_isk = vim_strsave(arg);
+      save_isk = (char_u *)curbuf->b_p_isk;
+      curbuf->b_p_isk = (char *)vim_strsave(arg);
 
       buf_init_chartab(curbuf, false);
       memmove(curwin->w_s->b_syn_chartab, curbuf->b_chartab, (size_t)32);
       memmove(curbuf->b_chartab, save_chartab, (size_t)32);
       clear_string_option(&curwin->w_s->b_syn_isk);
       curwin->w_s->b_syn_isk = curbuf->b_p_isk;
-      curbuf->b_p_isk = save_isk;
+      curbuf->b_p_isk = (char *)save_isk;
     }
   }
   redraw_later(curwin, UPD_NOT_VALID);
@@ -5070,7 +5070,7 @@ static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
 
   // Make 'cpoptions' empty, to avoid the 'l' flag
   cpo_save = p_cpo;
-  p_cpo = (char *)empty_option;
+  p_cpo = empty_option;
   ci->sp_prog = vim_regcomp((char *)ci->sp_pattern, RE_MAGIC);
   p_cpo = cpo_save;
 
@@ -5226,14 +5226,14 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
       if (!eap->skip) {
         // store the pattern and compiled regexp program
         curwin->w_s->b_syn_linecont_pat =
-          vim_strnsave(next_arg + 1, (size_t)(arg_end - (char *)next_arg) - 1);
+          (char *)vim_strnsave(next_arg + 1, (size_t)(arg_end - (char *)next_arg) - 1);
         curwin->w_s->b_syn_linecont_ic = curwin->w_s->b_syn_ic;
 
         // Make 'cpoptions' empty, to avoid the 'l' flag
         cpo_save = p_cpo;
-        p_cpo = (char *)empty_option;
+        p_cpo = empty_option;
         curwin->w_s->b_syn_linecont_prog =
-          vim_regcomp((char *)curwin->w_s->b_syn_linecont_pat, RE_MAGIC);
+          vim_regcomp(curwin->w_s->b_syn_linecont_pat, RE_MAGIC);
         p_cpo = cpo_save;
         syn_clear_time(&curwin->w_s->b_syn_linecont_time);
 
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 7401e73e84..ad00c3dafc 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -202,7 +202,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
   }
 
   prev_num_matches = num_matches;
-  free_string_option(nofile_fname);
+  free_string_option((char *)nofile_fname);
   nofile_fname = NULL;
 
   clearpos(&saved_fmark.mark);          // shutup gcc 4.0
@@ -215,7 +215,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
     new_tag = true;
     if (g_do_tagpreview != 0) {
       tagstack_clear_entry(&ptag_entry);
-      ptag_entry.tagname = vim_strsave(tag);
+      ptag_entry.tagname = (char *)vim_strsave(tag);
     }
   } else {
     if (g_do_tagpreview != 0) {
@@ -239,7 +239,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
           cur_fnum = ptag_entry.cur_fnum;
         } else {
           tagstack_clear_entry(&ptag_entry);
-          ptag_entry.tagname = vim_strsave(tag);
+          ptag_entry.tagname = (char *)vim_strsave(tag);
         }
       } else {
         /*
@@ -261,7 +261,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         }
 
         // put the tag name in the tag stack
-        tagstack[tagstackidx].tagname = vim_strsave(tag);
+        tagstack[tagstackidx].tagname = (char *)vim_strsave(tag);
 
         curwin->w_tagstacklen = tagstacklen;
 
@@ -440,9 +440,9 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
 
     // When desired match not found yet, try to find it (and others).
     if (use_tagstack) {
-      name = tagstack[tagstackidx].tagname;
+      name = (char_u *)tagstack[tagstackidx].tagname;
     } else if (g_do_tagpreview != 0) {
-      name = ptag_entry.tagname;
+      name = (char_u *)ptag_entry.tagname;
     } else {
       name = tag;
     }
@@ -587,9 +587,9 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         if (use_tfu && parse_match((char_u *)matches[cur_match], &tagp2) == OK
             && tagp2.user_data) {
           XFREE_CLEAR(tagstack[tagstackidx].user_data);
-          tagstack[tagstackidx].user_data = vim_strnsave(tagp2.user_data,
-                                                         (size_t)(tagp2.user_data_end -
-                                                                  tagp2.user_data));
+          tagstack[tagstackidx].user_data = (char *)vim_strnsave(tagp2.user_data,
+                                                                 (size_t)(tagp2.user_data_end -
+                                                                          tagp2.user_data));
         }
 
         tagstackidx++;
@@ -1184,7 +1184,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
                flags & TAG_REGEXP   ? "r": "");
 
   save_pos = curwin->w_cursor;
-  result = call_vim_function((char *)curbuf->b_p_tfu, 3, args, &rettv);
+  result = call_vim_function(curbuf->b_p_tfu, 3, args, &rettv);
   curwin->w_cursor = save_pos;  // restore the cursor position
   d->dv_refcount--;
 
@@ -2388,7 +2388,7 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
   if (first) {
     // Init.  We make a copy of 'tags', because autocommands may change
     // the value without notifying us.
-    tnp->tn_tags = vim_strsave((*curbuf->b_p_tags != NUL) ? curbuf->b_p_tags : p_tags);
+    tnp->tn_tags = vim_strsave((*curbuf->b_p_tags != NUL) ? (char_u *)curbuf->b_p_tags : p_tags);
     tnp->tn_np = (char *)tnp->tn_tags;
   }
 
@@ -3365,7 +3365,7 @@ static void tagstack_push_item(win_T *wp, char_u *tagname, int cur_fnum, int cur
   }
 
   wp->w_tagstacklen++;
-  tagstack[idx].tagname = tagname;
+  tagstack[idx].tagname = (char *)tagname;
   tagstack[idx].cur_fnum = cur_fnum;
   tagstack[idx].cur_match = cur_match;
   if (tagstack[idx].cur_match < 0) {
@@ -3373,7 +3373,7 @@ static void tagstack_push_item(win_T *wp, char_u *tagname, int cur_fnum, int cur
   }
   tagstack[idx].fmark.mark = mark;
   tagstack[idx].fmark.fnum = fnum;
-  tagstack[idx].user_data = user_data;
+  tagstack[idx].user_data = (char *)user_data;
 }
 
 // Add a list of items to the tag stack in the specified window
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 1b4ac12aa6..90966bcfad 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -418,7 +418,7 @@ bool terminal_enter(void)
   // placed at end of buffer to "follow" output. #11072
   handle_T save_curwin = curwin->handle;
   bool save_w_p_cul = curwin->w_p_cul;
-  char_u *save_w_p_culopt = NULL;
+  char *save_w_p_culopt = NULL;
   char_u save_w_p_culopt_flags = curwin->w_p_culopt_flags;
   int save_w_p_cuc = curwin->w_p_cuc;
   long save_w_p_so = curwin->w_p_so;
@@ -426,7 +426,7 @@ bool terminal_enter(void)
   if (curwin->w_p_cul && curwin->w_p_culopt_flags & CULOPT_NBR) {
     if (STRCMP(curwin->w_p_culopt, "number")) {
       save_w_p_culopt = curwin->w_p_culopt;
-      curwin->w_p_culopt = (char_u *)xstrdup("number");
+      curwin->w_p_culopt = xstrdup("number");
     }
     curwin->w_p_culopt_flags = CULOPT_NBR;
   } else {
diff --git a/src/nvim/testing.c b/src/nvim/testing.c
index e3ffe1c7d1..4a252dca3e 100644
--- a/src/nvim/testing.c
+++ b/src/nvim/testing.c
@@ -457,7 +457,7 @@ void f_assert_exception(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     ga_clear(&ga);
     rettv->vval.v_number = 1;
   } else if (error != NULL
-             && strstr((char *)get_vim_var_str(VV_EXCEPTION), error) == NULL) {
+             && strstr(get_vim_var_str(VV_EXCEPTION), error) == NULL) {
     prepare_assert_error(&ga);
     fill_assert_error(&ga, &argvars[1], NULL, &argvars[0],
                       get_vim_var_tv(VV_EXCEPTION), ASSERT_OTHER);
@@ -493,7 +493,7 @@ void f_assert_fails(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     const char *const error = tv_get_string_buf_chk(&argvars[1], buf);
 
     if (error == NULL
-        || strstr((char *)get_vim_var_str(VV_ERRMSG), error) == NULL) {
+        || strstr(get_vim_var_str(VV_ERRMSG), error) == NULL) {
       prepare_assert_error(&ga);
       fill_assert_error(&ga, &argvars[2], NULL, &argvars[1],
                         get_vim_var_tv(VV_ERRMSG), ASSERT_OTHER);
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index e2e0bb38a2..ac52bce2f9 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -773,7 +773,7 @@ static bool serialize_header(bufinfo_T *bi, char_u *hash)
   undo_write_bytes(bi, (uintmax_t)buf->b_ml.ml_line_count, 4);
   size_t len = buf->b_u_line_ptr ? STRLEN(buf->b_u_line_ptr) : 0;
   undo_write_bytes(bi, len, 4);
-  if (len > 0 && !undo_write(bi, buf->b_u_line_ptr, len)) {
+  if (len > 0 && !undo_write(bi, (char_u *)buf->b_u_line_ptr, len)) {
     return false;
   }
   undo_write_bytes(bi, (uintmax_t)buf->b_u_line_lnum, 4);
@@ -1593,7 +1593,7 @@ void u_read_undo(char *name, const char_u *hash, const char_u *orig_name FUNC_AT
   curbuf->b_u_oldhead = old_idx < 0 ? NULL : uhp_table[old_idx];
   curbuf->b_u_newhead = new_idx < 0 ? NULL : uhp_table[new_idx];
   curbuf->b_u_curhead = cur_idx < 0 ? NULL : uhp_table[cur_idx];
-  curbuf->b_u_line_ptr = line_ptr;
+  curbuf->b_u_line_ptr = (char *)line_ptr;
   curbuf->b_u_line_lnum = line_lnum;
   curbuf->b_u_line_colnr = line_colnr;
   curbuf->b_u_numhead = num_head;
@@ -2960,7 +2960,7 @@ void u_saveline(linenr_T lnum)
   } else {
     curbuf->b_u_line_colnr = 0;
   }
-  curbuf->b_u_line_ptr = u_save_line(lnum);
+  curbuf->b_u_line_ptr = (char *)u_save_line(lnum);
 }
 
 /// clear the line saved for the "U" command
@@ -2992,12 +2992,12 @@ void u_undoline(void)
   }
 
   char_u *oldp = u_save_line(curbuf->b_u_line_lnum);
-  ml_replace(curbuf->b_u_line_lnum, (char *)curbuf->b_u_line_ptr, true);
+  ml_replace(curbuf->b_u_line_lnum, curbuf->b_u_line_ptr, true);
   changed_bytes(curbuf->b_u_line_lnum, 0);
   extmark_splice_cols(curbuf, (int)curbuf->b_u_line_lnum - 1, 0, (colnr_T)STRLEN(oldp),
                       (colnr_T)STRLEN(curbuf->b_u_line_ptr), kExtmarkUndo);
   xfree(curbuf->b_u_line_ptr);
-  curbuf->b_u_line_ptr = oldp;
+  curbuf->b_u_line_ptr = (char *)oldp;
 
   colnr_T t = curbuf->b_u_line_colnr;
   if (curwin->w_cursor.lnum == curbuf->b_u_line_lnum) {
diff --git a/src/nvim/version.c b/src/nvim/version.c
index 34ded3460f..0e0aac0354 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2072,7 +2072,7 @@ void list_in_columns(char **items, int size, int current)
   // Find the length of the longest item, use that + 1 as the column width.
   int i;
   for (i = 0; size < 0 ? items[i] != NULL : i < size; i++) {
-    int l = vim_strsize((char *)items[i]) + (i == current ? 2 : 0);
+    int l = vim_strsize(items[i]) + (i == current ? 2 : 0);
 
     if (l > width) {
       width = l;
@@ -2084,7 +2084,7 @@ void list_in_columns(char **items, int size, int current)
   if (Columns < width) {
     // Not enough screen columns - show one per line
     for (i = 0; i < item_count; i++) {
-      version_msg_wrap((char *)items[i], i == current);
+      version_msg_wrap(items[i], i == current);
       if (msg_col > 0 && i < item_count - 1) {
         msg_putchar('\n');
       }
@@ -2106,7 +2106,7 @@ void list_in_columns(char **items, int size, int current)
       if (idx == current) {
         msg_putchar('[');
       }
-      msg_puts((char *)items[idx]);
+      msg_puts(items[idx]);
       if (idx == current) {
         msg_putchar(']');
       }
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 2a944e7d1d..aa275d1182 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -727,38 +727,38 @@ void win_set_minimal_style(win_T *wp)
 
   // Hide EOB region: use " " fillchar and cleared highlighting
   if (wp->w_p_fcs_chars.eob != ' ') {
-    char_u *old = wp->w_p_fcs;
+    char_u *old = (char_u *)wp->w_p_fcs;
     wp->w_p_fcs = ((*old == NUL)
-                   ? (char_u *)xstrdup("eob: ")
-                   : concat_str(old, (char_u *)",eob: "));
-    free_string_option(old);
+                   ? xstrdup("eob: ")
+                   : (char *)concat_str(old, (char_u *)",eob: "));
+    free_string_option((char *)old);
   }
 
   // TODO(bfredl): this could use a highlight namespace directly,
   // and avoid pecularities around window options
-  char_u *old = wp->w_p_winhl;
+  char_u *old = (char_u *)wp->w_p_winhl;
   wp->w_p_winhl = ((*old == NUL)
-                   ? (char_u *)xstrdup("EndOfBuffer:")
-                   : concat_str(old, (char_u *)",EndOfBuffer:"));
-  free_string_option(old);
+                   ? xstrdup("EndOfBuffer:")
+                   : (char *)concat_str(old, (char_u *)",EndOfBuffer:"));
+  free_string_option((char *)old);
   parse_winhl_opt(wp);
 
   // signcolumn: use 'auto'
   if (wp->w_p_scl[0] != 'a' || STRLEN(wp->w_p_scl) >= 8) {
     free_string_option(wp->w_p_scl);
-    wp->w_p_scl = (char_u *)xstrdup("auto");
+    wp->w_p_scl = xstrdup("auto");
   }
 
   // foldcolumn: use '0'
   if (wp->w_p_fdc[0] != '0') {
     free_string_option(wp->w_p_fdc);
-    wp->w_p_fdc = (char_u *)xstrdup("0");
+    wp->w_p_fdc = xstrdup("0");
   }
 
   // colorcolumn: cleared
   if (wp->w_p_cc != NULL && *wp->w_p_cc != NUL) {
     free_string_option(wp->w_p_cc);
-    wp->w_p_cc = (char_u *)xstrdup("");
+    wp->w_p_cc = xstrdup("");
   }
 }
 
@@ -1570,10 +1570,10 @@ static void win_init(win_T *newp, win_T *oldp, int flags)
     taggy_T *tag = &newp->w_tagstack[i];
     *tag = oldp->w_tagstack[i];
     if (tag->tagname != NULL) {
-      tag->tagname = vim_strsave(tag->tagname);
+      tag->tagname = xstrdup(tag->tagname);
     }
     if (tag->user_data != NULL) {
-      tag->user_data = vim_strsave(tag->user_data);
+      tag->user_data = xstrdup(tag->user_data);
     }
   }
   newp->w_tagstackidx = oldp->w_tagstackidx;
@@ -7291,7 +7291,7 @@ char *check_colorcolumn(win_T *wp)
     return NULL;      // buffer was closed
   }
 
-  for (s = (char *)wp->w_p_cc; *s != NUL && count < 255;) {
+  for (s = wp->w_p_cc; *s != NUL && count < 255;) {
     if (*s == '-' || *s == '+') {
       // -N and +N: add to 'textwidth'
       col = (*s == '-') ? -1 : 1;
-- 
cgit 


From 4dd34989cdd88fd75a38572b4bca9361d557943f Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 06:54:11 +0800
Subject: vim-patch:9.0.0263: too many #ifdefs

Problem:    Too many #ifdefs.
Solution:   Make some functions always available.
https://github.com/vim/vim/commit/6d4b2f54df5d533eb0794331f38445a6ca5d3a3f

N/A patches for version.c:

vim-patch:9.0.0262: build failure without the +quickfix feature

Problem:    Build failure without the +quickfix feature.
Solution:   Add #ifdef.
https://github.com/vim/vim/commit/2e6dcbc4450c98bd12faace5d77a65f2afddae44

vim-patch:9.0.0266: compiler warning for unused argument

Problem:    Compiler warning for unused argument.
Solution:   Add UNUSED.
https://github.com/vim/vim/commit/340dafd155222ac96304107542344faf3c56e12b

vim-patch:9.0.0268: build error without the +eval feature

Problem:    Build error without the +eval feature.
Solution:   Remove #ifdef.
https://github.com/vim/vim/commit/0166e398d11a09662d783fe5db62b414045880f8
---
 src/nvim/change.c  | 3 +--
 src/nvim/ex_cmds.c | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 45ff2ceacb..1d545927ad 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -96,8 +96,7 @@ void changed(void)
 
     // Create a swap file if that is wanted.
     // Don't do this for "nofile" and "nowrite" buffer types.
-    if (curbuf->b_may_swap
-        && !bt_dontwrite(curbuf)) {
+    if (curbuf->b_may_swap && !bt_dontwrite(curbuf)) {
       bool save_need_wait_return = need_wait_return;
 
       need_wait_return = false;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e08e977ff5..69208cff99 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1880,8 +1880,7 @@ int do_write(exarg_T *eap)
   // Writing to the current file is not allowed in readonly mode
   // and a file name is required.
   // "nofile" and "nowrite" buffers cannot be written implicitly either.
-  if (!other && (bt_dontwrite_msg(curbuf)
-                 || check_fname() == FAIL
+  if (!other && (bt_dontwrite_msg(curbuf) || check_fname() == FAIL
                  || check_readonly(&eap->forceit, curbuf))) {
     goto theend;
   }
-- 
cgit 


From 207fe4810e893bd4b777e4e3b212055e8dfb05ac Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 06:44:42 +0800
Subject: vim-patch:9.0.0270: some values of 'path' and 'tags' invalid in the
 tiny version

Problem:    Some values of 'path' and 'tags' do not work in the tiny version.
Solution:   Graduate the +path_extra feature.
https://github.com/vim/vim/commit/2bd9dbc19fc67395cfa1226dda7326071ab22464
---
 src/nvim/file_search.c | 39 +++++++++++++--------------------------
 1 file changed, 13 insertions(+), 26 deletions(-)

(limited to 'src')

diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 2e86e3f7b0..0eb6ad50ff 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -110,16 +110,15 @@ typedef struct ff_stack {
 typedef struct ff_visited {
   struct ff_visited *ffv_next;
 
-  /* Visited directories are different if the wildcard string are
-   * different. So we have to save it.
-   */
+  // Visited directories are different if the wildcard string are
+  // different. So we have to save it.
   char_u *ffv_wc_path;
+
   // use FileID for comparison (needed because of links), else use filename.
   bool file_id_valid;
   FileID file_id;
-  /* The memory for this struct is allocated according to the length of
-   * ffv_fname.
-   */
+  // The memory for this struct is allocated according to the length of
+  // ffv_fname.
   char_u ffv_fname[1];                  // actually longer
 } ff_visited_T;
 
@@ -510,9 +509,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     xfree(buf);
   }
 
-  sptr = ff_create_stack_element(ff_expand_buffer,
-                                 search_ctx->ffsc_wc_path,
-                                 level, 0);
+  sptr = ff_create_stack_element(ff_expand_buffer, search_ctx->ffsc_wc_path, level, 0);
 
   ff_push(search_ctx, sptr);
   search_ctx->ffsc_file_to_search = vim_strsave(filename);
@@ -641,11 +638,8 @@ char_u *vim_findfile(void *search_ctx_arg)
        * first time (hence stackp->ff_filearray == NULL)
        */
       if (stackp->ffs_filearray == NULL
-          && ff_check_visited(&search_ctx->ffsc_dir_visited_list
-                              ->ffvl_visited_list,
-                              stackp->ffs_fix_path,
-                              stackp->ffs_wc_path
-                              ) == FAIL) {
+          && ff_check_visited(&search_ctx->ffsc_dir_visited_list->ffvl_visited_list,
+                              stackp->ffs_fix_path, stackp->ffs_wc_path) == FAIL) {
 #ifdef FF_VERBOSE
         if (p_verbose >= 5) {
           verbose_enter_scroll();
@@ -790,8 +784,7 @@ char_u *vim_findfile(void *search_ctx_arg)
         stackp->ffs_filearray_cur = 0;
         stackp->ffs_stage = 0;
       } else {
-        rest_of_wildcards = &stackp->ffs_wc_path[
-                                                 STRLEN(stackp->ffs_wc_path)];
+        rest_of_wildcards = &stackp->ffs_wc_path[STRLEN(stackp->ffs_wc_path)];
       }
 
       if (stackp->ffs_stage == 0) {
@@ -833,23 +826,17 @@ char_u *vim_findfile(void *search_ctx_arg)
               // if file exists and we didn't already find it
               if ((path_with_url((char *)file_path)
                    || (os_path_exists(file_path)
-                       && (search_ctx->ffsc_find_what
-                           == FINDFILE_BOTH
-                           || ((search_ctx->ffsc_find_what
-                                == FINDFILE_DIR)
+                       && (search_ctx->ffsc_find_what == FINDFILE_BOTH
+                           || ((search_ctx->ffsc_find_what == FINDFILE_DIR)
                                == os_isdir(file_path)))))
 #ifndef FF_VERBOSE
                   && (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                       file_path,
-                                       (char_u *)""
-                                       ) == OK)
+                                       file_path, (char_u *)"") == OK)
 #endif
                   ) {
 #ifdef FF_VERBOSE
                 if (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                     file_path,
-                                     (char_u *)""
-                                     ) == FAIL) {
+                                     file_path, (char_u *)"") == FAIL) {
                   if (p_verbose >= 5) {
                     verbose_enter_scroll();
                     smsg("Already: %s", file_path);
-- 
cgit 


From 1ba3d5c712dcc2e2ee35c6bc27d9965f671f967a Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 08:52:13 +0800
Subject: vim-patch:8.2.2524: cannot change the characters displayed in the
 foldcolumn

Problem:    Cannot change the characters displayed in the foldcolumn.
Solution:   Add fields to 'fillchars'. (Yegappan Lakshmanan, Matthieu Coudron,
            closes vim/vim#7860)
https://github.com/vim/vim/commit/3aca5a6fbcfbf5f4492b9ea0c4308ac524d33606
---
 src/nvim/testdir/setup.vim        |  2 +-
 src/nvim/testdir/test_display.vim | 54 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 55 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/testdir/setup.vim b/src/nvim/testdir/setup.vim
index 6bc3607b69..472ed4ca14 100644
--- a/src/nvim/testdir/setup.vim
+++ b/src/nvim/testdir/setup.vim
@@ -5,7 +5,7 @@ if exists('s:did_load')
   set directory&
   set directory^=.
   set display=
-  set fillchars=vert:\|,fold:-
+  set fillchars=vert:\|,foldsep:\|,fold:-
   set formatoptions=tcq
   set fsync
   set laststatus=1
diff --git a/src/nvim/testdir/test_display.vim b/src/nvim/testdir/test_display.vim
index 6938abbc28..a30d57016a 100644
--- a/src/nvim/testdir/test_display.vim
+++ b/src/nvim/testdir/test_display.vim
@@ -309,6 +309,60 @@ func Test_eob_fillchars()
   close
 endfunc
 
+" Test for 'foldopen', 'foldclose' and 'foldsep' in 'fillchars'
+func Test_fold_fillchars()
+  new
+  set fdc=2 foldenable foldmethod=manual
+  call setline(1, ['one', 'two', 'three', 'four', 'five'])
+  2,4fold
+  " First check for the default setting for a closed fold
+  let lines = ScreenLines([1, 3], 8)
+  let expected = [
+        \ '  one   ',
+        \ '+ +--  3',
+        \ '  five  '
+        \ ]
+  call assert_equal(expected, lines)
+  normal 2Gzo
+  " check the characters for an open fold
+  let lines = ScreenLines([1, 5], 8)
+  let expected = [
+        \ '  one   ',
+        \ '- two   ',
+        \ '| three ',
+        \ '| four  ',
+        \ '  five  '
+        \ ]
+  call assert_equal(expected, lines)
+
+  " change the setting
+  set fillchars=vert:\|,fold:-,eob:~,foldopen:[,foldclose:],foldsep:-
+
+  " check the characters for an open fold
+  let lines = ScreenLines([1, 5], 8)
+  let expected = [
+        \ '  one   ',
+        \ '[ two   ',
+        \ '- three ',
+        \ '- four  ',
+        \ '  five  '
+        \ ]
+  call assert_equal(expected, lines)
+
+  " check the characters for a closed fold
+  normal 2Gzc
+  let lines = ScreenLines([1, 3], 8)
+  let expected = [
+        \ '  one   ',
+        \ '] +--  3',
+        \ '  five  '
+        \ ]
+  call assert_equal(expected, lines)
+
+  %bw!
+  set fillchars& fdc& foldmethod& foldenable&
+endfunc
+
 func Test_display_linebreak_breakat()
   new
   vert resize 25
-- 
cgit 


From fa1c761d62667c28e4d3a81f379abeddb878f3cd Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 08:25:36 +0800
Subject: vim-patch:9.0.0036: 'fillchars' cannot have window-local values

Problem:    'fillchars' cannot have window-local values.
Solution:   Make 'fillchars' global-local. (closes vim/vim#5206)
https://github.com/vim/vim/commit/96ba25ac01279f73c0ecb5d4aa4ff37aa359e5eb

Cherry-pick g:run_nr from patch 8.2.0454.

N/A patches for version.c:

vim-patch:9.0.0037: build error

Problem:    Build error.
Solution:   Add missing change.
https://github.com/vim/vim/commit/510f03738dfcadfe2099c5b6a58cb75f64dbaa82
---
 src/nvim/buffer_defs.h            |  4 ++--
 src/nvim/drawline.c               |  2 +-
 src/nvim/drawscreen.c             |  5 ++--
 src/nvim/mbyte.c                  |  3 +--
 src/nvim/option.c                 | 50 +++++++++++++++++++++++----------------
 src/nvim/option_defs.h            |  2 +-
 src/nvim/optionstr.c              |  8 +++++--
 src/nvim/testdir/runtest.vim      |  8 +++----
 src/nvim/testdir/test_display.vim | 28 ++++++++++++++++++++++
 9 files changed, 75 insertions(+), 35 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index d7d680b0fd..c0d7f8d066 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -257,10 +257,10 @@ typedef struct {
 #define w_p_scl w_onebuf_opt.wo_scl    // 'signcolumn'
   char *wo_winhl;
 #define w_p_winhl w_onebuf_opt.wo_winhl    // 'winhighlight'
-  char *wo_fcs;
-#define w_p_fcs w_onebuf_opt.wo_fcs    // 'fillchars'
   char *wo_lcs;
 #define w_p_lcs w_onebuf_opt.wo_lcs    // 'listchars'
+  char *wo_fcs;
+#define w_p_fcs w_onebuf_opt.wo_fcs    // 'fillchars'
   long wo_winbl;
 #define w_p_winbl w_onebuf_opt.wo_winbl  // 'winblend'
 
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index f1a808e2bc..22b0f26a1c 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -1247,7 +1247,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           }
           char_attr = 0;
         } else if (filler_todo > 0) {
-          // draw "deleted" diff line(s)
+          // Draw "deleted" diff line(s)
           if (char2cells(wp->w_p_fcs_chars.diff) > 1) {
             c_extra = '-';
             c_final = NUL;
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 012c4ecb19..cf8178a30f 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -1920,8 +1920,9 @@ win_update_start:
       wp->w_botline = lnum;
     }
 
-    // make sure the rest of the screen is blank
-    // write the 'eob' character to rows that aren't part of the file.
+    // Make sure the rest of the screen is blank.
+    // write the "eob" character from 'fillchars' to rows that aren't part
+    // of the file.
     win_draw_end(wp, wp->w_p_fcs_chars.eob, ' ', false, row, wp->w_grid.rows,
                  HLF_EOB);
   }
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 83044f209a..ad8718742f 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1989,8 +1989,7 @@ theend:
 }
 
 /// @return  true if string "s" is a valid utf-8 string.
-/// When "end" is NULL stop at the first NUL.
-/// When "end" is positive stop there.
+/// When "end" is NULL stop at the first NUL.  Otherwise stop at "end".
 bool utf_valid_string(const char_u *s, const char_u *end)
 {
   const char_u *p = s;
diff --git a/src/nvim/option.c b/src/nvim/option.c
index b2525b73a0..6912f93daa 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -4250,6 +4250,14 @@ void win_copy_options(win_T *wp_from, win_T *wp_to)
   didset_window_options(wp_to, true);
 }
 
+static char *copy_option_val(const char *val)
+{
+  if (val == empty_option) {
+    return empty_option;  // no need to allocate memory
+  }
+  return xstrdup(val);
+}
+
 /// Copy the options from one winopt_T to another.
 /// Doesn't free the old option values in "to", use clear_winopt() for that.
 /// The 'scroll' option is not copied, because it depends on the window height.
@@ -4258,21 +4266,23 @@ void copy_winopt(winopt_T *from, winopt_T *to)
 {
   to->wo_arab = from->wo_arab;
   to->wo_list = from->wo_list;
+  to->wo_lcs = copy_option_val(from->wo_lcs);
+  to->wo_fcs = copy_option_val(from->wo_fcs);
   to->wo_nu = from->wo_nu;
   to->wo_rnu = from->wo_rnu;
-  to->wo_ve = xstrdup(from->wo_ve);
+  to->wo_ve = copy_option_val(from->wo_ve);
   to->wo_ve_flags = from->wo_ve_flags;
   to->wo_nuw = from->wo_nuw;
   to->wo_rl  = from->wo_rl;
-  to->wo_rlc = xstrdup(from->wo_rlc);
-  to->wo_sbr = xstrdup(from->wo_sbr);
-  to->wo_stl = xstrdup(from->wo_stl);
-  to->wo_wbr = xstrdup(from->wo_wbr);
+  to->wo_rlc = copy_option_val(from->wo_rlc);
+  to->wo_sbr = copy_option_val(from->wo_sbr);
+  to->wo_stl = copy_option_val(from->wo_stl);
+  to->wo_wbr = copy_option_val(from->wo_wbr);
   to->wo_wrap = from->wo_wrap;
   to->wo_wrap_save = from->wo_wrap_save;
   to->wo_lbr = from->wo_lbr;
   to->wo_bri = from->wo_bri;
-  to->wo_briopt = xstrdup(from->wo_briopt);
+  to->wo_briopt = copy_option_val(from->wo_briopt);
   to->wo_scb = from->wo_scb;
   to->wo_scb_save = from->wo_scb_save;
   to->wo_crb = from->wo_crb;
@@ -4280,30 +4290,28 @@ void copy_winopt(winopt_T *from, winopt_T *to)
   to->wo_spell = from->wo_spell;
   to->wo_cuc = from->wo_cuc;
   to->wo_cul = from->wo_cul;
-  to->wo_culopt = xstrdup(from->wo_culopt);
-  to->wo_cc = xstrdup(from->wo_cc);
+  to->wo_culopt = copy_option_val(from->wo_culopt);
+  to->wo_cc = copy_option_val(from->wo_cc);
   to->wo_diff = from->wo_diff;
   to->wo_diff_saved = from->wo_diff_saved;
-  to->wo_cocu = xstrdup(from->wo_cocu);
+  to->wo_cocu = copy_option_val(from->wo_cocu);
   to->wo_cole = from->wo_cole;
-  to->wo_fdc = xstrdup(from->wo_fdc);
+  to->wo_fdc = copy_option_val(from->wo_fdc);
   to->wo_fdc_save = from->wo_diff_saved ? xstrdup(from->wo_fdc_save) : empty_option;
   to->wo_fen = from->wo_fen;
   to->wo_fen_save = from->wo_fen_save;
-  to->wo_fdi = xstrdup(from->wo_fdi);
+  to->wo_fdi = copy_option_val(from->wo_fdi);
   to->wo_fml = from->wo_fml;
   to->wo_fdl = from->wo_fdl;
   to->wo_fdl_save = from->wo_fdl_save;
-  to->wo_fdm = xstrdup(from->wo_fdm);
+  to->wo_fdm = copy_option_val(from->wo_fdm);
   to->wo_fdm_save = from->wo_diff_saved ? xstrdup(from->wo_fdm_save) : empty_option;
   to->wo_fdn = from->wo_fdn;
-  to->wo_fde = xstrdup(from->wo_fde);
-  to->wo_fdt = xstrdup(from->wo_fdt);
-  to->wo_fmr = xstrdup(from->wo_fmr);
-  to->wo_scl = xstrdup(from->wo_scl);
-  to->wo_winhl = xstrdup(from->wo_winhl);
-  to->wo_fcs = xstrdup(from->wo_fcs);
-  to->wo_lcs = xstrdup(from->wo_lcs);
+  to->wo_fde = copy_option_val(from->wo_fde);
+  to->wo_fdt = copy_option_val(from->wo_fdt);
+  to->wo_fmr = copy_option_val(from->wo_fmr);
+  to->wo_scl = copy_option_val(from->wo_scl);
+  to->wo_winhl = copy_option_val(from->wo_winhl);
   to->wo_winbl = from->wo_winbl;
 
   // Copy the script context so that we know were the value was last set.
@@ -4338,8 +4346,8 @@ static void check_winopt(winopt_T *wop)
   check_string_option(&wop->wo_cocu);
   check_string_option(&wop->wo_briopt);
   check_string_option(&wop->wo_winhl);
-  check_string_option(&wop->wo_fcs);
   check_string_option(&wop->wo_lcs);
+  check_string_option(&wop->wo_fcs);
   check_string_option(&wop->wo_ve);
   check_string_option(&wop->wo_wbr);
 }
@@ -4364,8 +4372,8 @@ void clear_winopt(winopt_T *wop)
   clear_string_option(&wop->wo_cocu);
   clear_string_option(&wop->wo_briopt);
   clear_string_option(&wop->wo_winhl);
-  clear_string_option(&wop->wo_fcs);
   clear_string_option(&wop->wo_lcs);
+  clear_string_option(&wop->wo_fcs);
   clear_string_option(&wop->wo_ve);
   clear_string_option(&wop->wo_wbr);
 }
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index ad8092add2..f9848cb792 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -972,8 +972,8 @@ enum {
   WV_WRAP,
   WV_SCL,
   WV_WINHL,
-  WV_FCS,
   WV_LCS,
+  WV_FCS,
   WV_WINBL,
   WV_WBR,
   WV_COUNT,  // must be the last one
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index e1538e0491..e6847c3ea5 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -960,7 +960,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       FOR_ALL_TAB_WINDOWS(tp, wp) {
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
+        if (*wp->w_p_lcs == NUL) {
+          (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
+        }
       }
       redraw_all_later(UPD_NOT_VALID);
     }
@@ -977,7 +979,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       FOR_ALL_TAB_WINDOWS(tp, wp) {
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
+        if (*wp->w_p_fcs == NUL) {
+          (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
+        }
       }
       redraw_all_later(UPD_NOT_VALID);
     }
diff --git a/src/nvim/testdir/runtest.vim b/src/nvim/testdir/runtest.vim
index 206f335751..ce23141c7a 100644
--- a/src/nvim/testdir/runtest.vim
+++ b/src/nvim/testdir/runtest.vim
@@ -425,7 +425,7 @@ for s:test in sort(s:tests)
   set belloff=all
   let prev_error = ''
   let total_errors = []
-  let run_nr = 1
+  let g:run_nr = 1
 
   " A test can set g:test_is_flaky to retry running the test.
   let g:test_is_flaky = 0
@@ -444,10 +444,10 @@ for s:test in sort(s:tests)
       call add(s:messages, 'Found errors in ' . s:test . ':')
       call extend(s:messages, v:errors)
 
-      call add(total_errors, 'Run ' . run_nr . ':')
+      call add(total_errors, 'Run ' . g:run_nr . ':')
       call extend(total_errors, v:errors)
 
-      if run_nr == 5 || prev_error == v:errors[0]
+      if g:run_nr >= 5 || prev_error == v:errors[0]
         call add(total_errors, 'Flaky test failed too often, giving up')
         let v:errors = total_errors
         break
@@ -462,7 +462,7 @@ for s:test in sort(s:tests)
 
       let prev_error = v:errors[0]
       let v:errors = []
-      let run_nr += 1
+      let g:run_nr += 1
 
       call RunTheTest(s:test)
 
diff --git a/src/nvim/testdir/test_display.vim b/src/nvim/testdir/test_display.vim
index a30d57016a..217bb5d781 100644
--- a/src/nvim/testdir/test_display.vim
+++ b/src/nvim/testdir/test_display.vim
@@ -363,6 +363,34 @@ func Test_fold_fillchars()
   set fillchars& fdc& foldmethod& foldenable&
 endfunc
 
+func Test_local_fillchars()
+  CheckScreendump
+
+  let lines =<< trim END
+      call setline(1, ['window 1']->repeat(3))
+      setlocal fillchars=stl:1,stlnc:a,vert:=,eob:x
+      vnew
+      call setline(1, ['window 2']->repeat(3))
+      setlocal fillchars=stl:2,stlnc:b,vert:+,eob:y
+      new
+      wincmd J
+      call setline(1, ['window 3']->repeat(3))
+      setlocal fillchars=stl:3,stlnc:c,vert:<,eob:z
+      vnew
+      call setline(1, ['window 4']->repeat(3))
+      setlocal fillchars=stl:4,stlnc:d,vert:>,eob:o
+  END
+  call writefile(lines, 'Xdisplayfillchars')
+  let buf = RunVimInTerminal('-S Xdisplayfillchars', #{rows: 12})
+  call VerifyScreenDump(buf, 'Test_display_fillchars_1', {})
+
+  call term_sendkeys(buf, ":wincmd k\r")
+  call VerifyScreenDump(buf, 'Test_display_fillchars_2', {})
+
+  call StopVimInTerminal(buf)
+  call delete('Xdisplayfillchars')
+endfunc
+
 func Test_display_linebreak_breakat()
   new
   vert resize 25
-- 
cgit 


From 752d397cae994e496cbfaad386f39d24d7fa8203 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 09:03:45 +0800
Subject: vim-patch:9.0.0038: 'listchars' test fails

Problem:    'listchars' test fails.
Solution:   Use window-local value after setting the global value
https://github.com/vim/vim/commit/5ed26faace574f6b36744f9e17075d7e806aa877
---
 src/nvim/optionstr.c | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index e6847c3ea5..604fc54f7c 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -952,17 +952,17 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
   } else if (varp == &p_lcs) {  // global 'listchars'
     errmsg = set_chars_option(curwin, varp, false);
     if (errmsg == NULL) {
-      // The current window is set to use the global 'listchars' value.
-      // So clear the window-local value.
+      // If the current window is set to use the global 'listchars'
+      // value, clear the window-local value.
       if (!(opt_flags & OPT_GLOBAL)) {
         clear_string_option(&curwin->w_p_lcs);
       }
       FOR_ALL_TAB_WINDOWS(tp, wp) {
+        // If the current window has a local value need to apply it
+        // again, it was changed when setting the global value.
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        if (*wp->w_p_lcs == NUL) {
-          (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
-        }
+        (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
       }
       redraw_all_later(UPD_NOT_VALID);
     }
@@ -971,17 +971,17 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
   } else if (varp == &p_fcs) {  // global 'fillchars'
     errmsg = set_chars_option(curwin, varp, false);
     if (errmsg == NULL) {
-      // The current window is set to use the global 'fillchars' value.
-      // So clear the window-local value.
+      // If the current window is set to use the global 'fillchars'
+      // value clear the window-local value.
       if (!(opt_flags & OPT_GLOBAL)) {
         clear_string_option(&curwin->w_p_fcs);
       }
       FOR_ALL_TAB_WINDOWS(tp, wp) {
+        // If the current window has a local value need to apply it
+        // again, it was changed when setting the global value.
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        if (*wp->w_p_fcs == NUL) {
-          (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
-        }
+        (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
       }
       redraw_all_later(UPD_NOT_VALID);
     }
-- 
cgit 


From db28c2ca2b6561bc65dd064ca5f45b0a9f3b4790 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 09:04:51 +0800
Subject: refactor: set_chars_option()

Rename "set" to "apply" and tidy up variable scopes.
---
 src/nvim/charset.c |  2 +-
 src/nvim/screen.c  | 82 +++++++++++++++++++++++++++---------------------------
 2 files changed, 42 insertions(+), 42 deletions(-)

(limited to 'src')

diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index ff58810ff0..d48cadf356 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -1655,7 +1655,7 @@ int hex2nr(int c)
 
 /// Convert two hex characters to a byte.
 /// Return -1 if one of the characters is not hex.
-int hexhex2nr(char_u *p)
+int hexhex2nr(const char_u *p)
   FUNC_ATTR_PURE
 {
   if (!ascii_isxdigit(p[0]) || !ascii_isxdigit(p[1])) {
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 2ed31ae8a9..43c85bedb5 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -1262,17 +1262,15 @@ int number_width(win_T *wp)
 /// Calls mb_cptr2char_adv(p) and returns the character.
 /// If "p" starts with "\x", "\u" or "\U" the hex or unicode value is used.
 /// Returns 0 for invalid hex or invalid UTF-8 byte.
-static int get_encoded_char_adv(char_u **p)
+static int get_encoded_char_adv(const char_u **p)
 {
-  char_u *s = *p;
+  const char_u *s = *p;
 
   if (s[0] == '\\' && (s[1] == 'x' || s[1] == 'u' || s[1] == 'U')) {
     int64_t num = 0;
-    int bytes;
-    int n;
-    for (bytes = s[1] == 'x' ? 1 : s[1] == 'u' ? 2 : 4; bytes > 0; bytes--) {
+    for (int bytes = s[1] == 'x' ? 1 : s[1] == 'u' ? 2 : 4; bytes > 0; bytes--) {
       *p += 2;
-      n = hexhex2nr(*p);
+      int n = hexhex2nr(*p);
       if (n < 0) {
         return 0;
       }
@@ -1283,8 +1281,8 @@ static int get_encoded_char_adv(char_u **p)
   }
 
   // TODO(bfredl): use schar_T representation and utfc_ptr2len
-  int clen = utf_ptr2len((char *)s);
-  int c = mb_cptr2char_adv((const char_u **)p);
+  int clen = utf_ptr2len((const char *)s);
+  int c = mb_cptr2char_adv(p);
   if (clen == 1 && c > 127) {  // Invalid UTF-8 byte
     return 0;
   }
@@ -1294,26 +1292,22 @@ static int get_encoded_char_adv(char_u **p)
 /// Handle setting 'listchars' or 'fillchars'.
 /// Assume monocell characters
 ///
-/// @param varp either &curwin->w_p_lcs or &curwin->w_p_fcs
+/// @param varp   either the global or the window-local value.
+/// @param apply  if false, do not store the flags, only check for errors.
 /// @return error message, NULL if it's OK.
-char *set_chars_option(win_T *wp, char_u **varp, bool set)
+char *set_chars_option(win_T *wp, char_u **varp, bool apply)
 {
-  int round, i, len, len2, entries;
-  char_u *p, *s;
-  int c1;
-  int c2 = 0;
-  int c3 = 0;
-  char_u *last_multispace = NULL;   // Last occurrence of "multispace:"
-  char_u *last_lmultispace = NULL;  // Last occurrence of "leadmultispace:"
+  const char_u *last_multispace = NULL;   // Last occurrence of "multispace:"
+  const char_u *last_lmultispace = NULL;  // Last occurrence of "leadmultispace:"
   int multispace_len = 0;           // Length of lcs-multispace string
   int lead_multispace_len = 0;      // Length of lcs-leadmultispace string
+  const bool is_listchars = (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs);
 
   struct chars_tab {
-    int *cp;    ///< char value
+    int *cp;     ///< char value
     char *name;  ///< char id
-    int def;    ///< default value
+    int def;     ///< default value
   };
-  struct chars_tab *tab;
 
   // XXX: Characters taking 2 columns is forbidden (TUI limitation?). Set old defaults in this case.
   struct chars_tab fcs_tab[] = {
@@ -1335,6 +1329,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
     { &wp->w_p_fcs_chars.msgsep,     "msgsep",    ' ' },
     { &wp->w_p_fcs_chars.eob,        "eob",       '~' },
   };
+
   struct chars_tab lcs_tab[] = {
     { &wp->w_p_lcs_chars.eol,     "eol",      NUL },
     { &wp->w_p_lcs_chars.ext,     "extends",  NUL },
@@ -1347,30 +1342,33 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
     { &wp->w_p_lcs_chars.conceal, "conceal",  NUL },
   };
 
-  if (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs) {
+  struct chars_tab *tab;
+  int entries;
+  const char_u *value = *varp;
+  if (is_listchars) {
     tab = lcs_tab;
     entries = ARRAY_SIZE(lcs_tab);
     if (varp == (char_u **)&wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
-      varp = &p_lcs;
+      value = p_lcs;  // local value is empty, use the global value
     }
   } else {
     tab = fcs_tab;
     entries = ARRAY_SIZE(fcs_tab);
     if (varp == (char_u **)&wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
-      varp = &p_fcs;
+      value = p_fcs;  // local value is empty, use the global value
     }
   }
 
   // first round: check for valid value, second round: assign values
-  for (round = 0; round <= (set ? 1 : 0); round++) {
+  for (int round = 0; round <= (apply ? 1 : 0); round++) {
     if (round > 0) {
       // After checking that the value is valid: set defaults
-      for (i = 0; i < entries; i++) {
+      for (int i = 0; i < entries; i++) {
         if (tab[i].cp != NULL) {
           *(tab[i].cp) = tab[i].def;
         }
       }
-      if (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs) {
+      if (is_listchars) {
         wp->w_p_lcs_chars.tab1 = NUL;
         wp->w_p_lcs_chars.tab3 = NUL;
 
@@ -1392,19 +1390,20 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
         }
       }
     }
-    p = *varp;
+    const char_u *p = value;
     while (*p) {
+      int i;
       for (i = 0; i < entries; i++) {
-        len = (int)STRLEN(tab[i].name);
+        const size_t len = STRLEN(tab[i].name);
         if (STRNCMP(p, tab[i].name, len) == 0
             && p[len] == ':'
             && p[len + 1] != NUL) {
-          c2 = c3 = 0;
-          s = p + len + 1;
-          c1 = get_encoded_char_adv(&s);
+          const char_u *s = p + len + 1;
+          int c1 = get_encoded_char_adv(&s);
           if (c1 == 0 || char2cells(c1) > 1) {
             return e_invarg;
           }
+          int c2 = 0, c3 = 0;
           if (tab[i].cp == &wp->w_p_lcs_chars.tab2) {
             if (*s == NUL) {
               return e_invarg;
@@ -1437,19 +1436,19 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
       }
 
       if (i == entries) {
-        len = (int)STRLEN("multispace");
-        len2 = (int)STRLEN("leadmultispace");
-        if ((varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs)
+        const size_t len = STRLEN("multispace");
+        const size_t len2 = STRLEN("leadmultispace");
+        if (is_listchars
             && STRNCMP(p, "multispace", len) == 0
             && p[len] == ':'
             && p[len + 1] != NUL) {
-          s = p + len + 1;
+          const char_u *s = p + len + 1;
           if (round == 0) {
             // Get length of lcs-multispace string in the first round
             last_multispace = p;
             multispace_len = 0;
             while (*s != NUL && *s != ',') {
-              c1 = get_encoded_char_adv(&s);
+              int c1 = get_encoded_char_adv(&s);
               if (c1 == 0 || char2cells(c1) > 1) {
                 return e_invarg;
               }
@@ -1463,24 +1462,24 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
           } else {
             int multispace_pos = 0;
             while (*s != NUL && *s != ',') {
-              c1 = get_encoded_char_adv(&s);
+              int c1 = get_encoded_char_adv(&s);
               if (p == last_multispace) {
                 wp->w_p_lcs_chars.multispace[multispace_pos++] = c1;
               }
             }
             p = s;
           }
-        } else if ((varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs)
+        } else if (is_listchars
                    && STRNCMP(p, "leadmultispace", len2) == 0
                    && p[len2] == ':'
                    && p[len2 + 1] != NUL) {
-          s = p + len2 + 1;
+          const char_u *s = p + len2 + 1;
           if (round == 0) {
             // get length of lcs-leadmultispace string in first round
             last_lmultispace = p;
             lead_multispace_len = 0;
             while (*s != NUL && *s != ',') {
-              c1 = get_encoded_char_adv(&s);
+              int c1 = get_encoded_char_adv(&s);
               if (c1 == 0 || char2cells(c1) > 1) {
                 return e_invarg;
               }
@@ -1494,7 +1493,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
           } else {
             int multispace_pos = 0;
             while (*s != NUL && *s != ',') {
-              c1 = get_encoded_char_adv(&s);
+              int c1 = get_encoded_char_adv(&s);
               if (p == last_lmultispace) {
                 wp->w_p_lcs_chars.leadmultispace[multispace_pos++] = c1;
               }
@@ -1505,6 +1504,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool set)
           return e_invarg;
         }
       }
+
       if (*p == ',') {
         p++;
       }
-- 
cgit 


From 36fdad557583216c93cf85d94400eaf6996dced7 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 09:25:17 +0800
Subject: vim-patch:9.0.0040: use of set_chars_option() is confusing

Problem:    Use of set_chars_option() is confusing.
Solution:   Add "apply" argument to store the result or not.  Merge similar
            code.
https://github.com/vim/vim/commit/b67f0c8e495cfbfc09d6c7ff670b8162faf07b01
---
 src/nvim/optionstr.c | 34 +++++++++++-----------------------
 1 file changed, 11 insertions(+), 23 deletions(-)

(limited to 'src')

diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 604fc54f7c..ec62c4b8ad 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -949,42 +949,30 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
       s = (char *)skip_to_option_part((char_u *)s);
     }
-  } else if (varp == &p_lcs) {  // global 'listchars'
-    errmsg = set_chars_option(curwin, varp, false);
+  } else if (varp == &p_lcs || varp == &p_fcs) {  // global 'listchars' or 'fillchars'
+    char **local_ptr = varp == &p_lcs ? &curwin->w_p_lcs : &curwin->w_p_fcs;
+    // only apply the global value to "curwin" when it does not have a local value
+    errmsg = set_chars_option(curwin, varp, **local_ptr == NUL || !(opt_flags & OPT_GLOBAL));
     if (errmsg == NULL) {
-      // If the current window is set to use the global 'listchars'
-      // value, clear the window-local value.
+      // If the current window is set to use the global
+      // 'listchars'/'fillchars' value, clear the window-local value.
       if (!(opt_flags & OPT_GLOBAL)) {
-        clear_string_option(&curwin->w_p_lcs);
+        clear_string_option(local_ptr);
       }
       FOR_ALL_TAB_WINDOWS(tp, wp) {
         // If the current window has a local value need to apply it
         // again, it was changed when setting the global value.
         // If no error was returned above, we don't expect an error
         // here, so ignore the return value.
-        (void)set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
+        local_ptr = varp == &p_lcs ? &wp->w_p_lcs : &wp->w_p_fcs;
+        if (**local_ptr == NUL) {
+          (void)set_chars_option(wp, (char_u **)local_ptr, true);
+        }
       }
       redraw_all_later(UPD_NOT_VALID);
     }
   } else if (varp == (char_u **)&curwin->w_p_lcs) {  // local 'listchars'
     errmsg = set_chars_option(curwin, varp, true);
-  } else if (varp == &p_fcs) {  // global 'fillchars'
-    errmsg = set_chars_option(curwin, varp, false);
-    if (errmsg == NULL) {
-      // If the current window is set to use the global 'fillchars'
-      // value clear the window-local value.
-      if (!(opt_flags & OPT_GLOBAL)) {
-        clear_string_option(&curwin->w_p_fcs);
-      }
-      FOR_ALL_TAB_WINDOWS(tp, wp) {
-        // If the current window has a local value need to apply it
-        // again, it was changed when setting the global value.
-        // If no error was returned above, we don't expect an error
-        // here, so ignore the return value.
-        (void)set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
-      }
-      redraw_all_later(UPD_NOT_VALID);
-    }
   } else if (varp == (char_u **)&curwin->w_p_fcs) {  // local 'fillchars'
     errmsg = set_chars_option(curwin, varp, true);
   } else if (varp == &p_cedit) {  // 'cedit'
-- 
cgit 


From 2498e9feb025361576603a0101c86393d211e31e Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Thu, 25 Aug 2022 14:41:02 +0100
Subject: refactor: change FALSE/TRUE to false/true

Co-authored-by: zeertzjq <zeertzjq@outlook.com>
---
 src/nvim/api/vim.c         |   4 +-
 src/nvim/buffer_defs.h     |  18 ++--
 src/nvim/drawline.c        |   2 +-
 src/nvim/edit.c            |  46 +++++-----
 src/nvim/eval.c            |  22 ++---
 src/nvim/eval/funcs.c      |   6 +-
 src/nvim/eval/userfunc.c   |  20 ++---
 src/nvim/eval/vars.c       |   2 +-
 src/nvim/ex_cmds.c         |  79 +++++++++--------
 src/nvim/ex_cmds_defs.h    |   8 +-
 src/nvim/ex_eval.c         |  88 +++++++++----------
 src/nvim/ex_getln.c        |  28 +++---
 src/nvim/file_search.c     |  34 +++----
 src/nvim/fileio.c          | 214 +++++++++++++++++++++++----------------------
 src/nvim/getchar.c         |  48 ++++------
 src/nvim/grid.c            |   6 +-
 src/nvim/hardcopy.c        |  95 ++++++++++----------
 src/nvim/highlight_group.c |   6 +-
 src/nvim/if_cscope.c       |  20 ++---
 src/nvim/indent_c.c        |  80 ++++++++---------
 src/nvim/macros.h          |   2 +-
 src/nvim/main.c            |  26 +++---
 src/nvim/memline.c         |  80 ++++++++---------
 src/nvim/menu.c            |  16 ++--
 src/nvim/message.c         |  74 ++++++++--------
 src/nvim/mouse.h           |   2 +-
 src/nvim/ops.c             |  82 ++++++++---------
 src/nvim/path.c            |  66 +++++---------
 src/nvim/quickfix.c        |  22 ++---
 src/nvim/search.c          | 144 ++++++++++++++----------------
 src/nvim/spellfile.c       |   8 +-
 src/nvim/syntax.c          |  96 ++++++++++----------
 src/nvim/tag.c             |  48 +++++-----
 src/nvim/usercmd.c         |   2 +-
 src/nvim/version.c         |   8 +-
 src/nvim/vim.h             |   9 --
 src/nvim/window.c          |  10 +--
 37 files changed, 727 insertions(+), 794 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index ca98aeb34a..b164106cef 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -2092,7 +2092,7 @@ Array nvim_get_mark(String name, Dictionary opts, Error *err)
 ///                                'fillchars'). Treated as single-width even if it isn't.
 ///           - highlights: (boolean) Return highlight information.
 ///           - use_winbar: (boolean) Evaluate winbar instead of statusline.
-///           - use_tabline: (boolean) Evaluate tabline instead of statusline. When |TRUE|, {winid}
+///           - use_tabline: (boolean) Evaluate tabline instead of statusline. When true, {winid}
 ///                                    is ignored. Mutually exclusive with {use_winbar}.
 ///
 /// @param[out] err Error details, if any.
@@ -2100,7 +2100,7 @@ Array nvim_get_mark(String name, Dictionary opts, Error *err)
 ///       - str: (string) Characters that will be displayed on the statusline.
 ///       - width: (number) Display width of the statusline.
 ///       - highlights: Array containing highlight information of the statusline. Only included when
-///                     the "highlights" key in {opts} is |TRUE|. Each element of the array is a
+///                     the "highlights" key in {opts} is true. Each element of the array is a
 ///                     |Dictionary| with these keys:
 ///           - start: (number) Byte index (0-based) of first character that uses the highlight.
 ///           - group: (string) Name of highlight group.
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index c0d7f8d066..d22ab266f8 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -440,7 +440,7 @@ typedef struct {
   garray_T b_syn_clusters;              // table for syntax clusters
   int b_spell_cluster_id;               // @Spell cluster ID or 0
   int b_nospell_cluster_id;             // @NoSpell cluster ID or 0
-  int b_syn_containedin;                // TRUE when there is an item with a
+  int b_syn_containedin;                // true when there is an item with a
                                         // "containedin" argument
   int b_syn_sync_flags;                 // flags about how to sync
   int16_t b_syn_sync_id;                // group to sync on
@@ -600,7 +600,7 @@ struct file_buffer {
 
   fmark_T b_namedm[NMARKS];     // current named marks (mark.c)
 
-  // These variables are set when VIsual_active becomes FALSE
+  // These variables are set when VIsual_active becomes false
   visualinfo_T b_visual;
   int b_visual_mode_eval;            // b_visual.vi_mode for visualmode()
 
@@ -847,7 +847,7 @@ struct file_buffer {
    * spell buffer - used for spell info, never displayed and doesn't have a
    *                file name.
    */
-  bool b_help;                  // TRUE for help file buffer (when set b_p_bt
+  bool b_help;                  // true for help file buffer (when set b_p_bt
                                 // is "help")
   bool b_spell;                 // True for a spell file buffer, most fields
                                 // are not used!  Use the B_SPELL macro to
@@ -972,15 +972,15 @@ struct tabpage_S {
  * When the display is changed (e.g., when clearing the screen) w_lines_valid
  * is changed to exclude invalid entries.
  * When making changes to the buffer, wl_valid is reset to indicate wl_size
- * may not reflect what is actually in the buffer.  When wl_valid is FALSE,
+ * may not reflect what is actually in the buffer.  When wl_valid is false,
  * the entries can only be used to count the number of displayed lines used.
  * wl_lnum and wl_lastlnum are invalid too.
  */
 typedef struct w_line {
   linenr_T wl_lnum;             // buffer line number for logical line
   uint16_t wl_size;             // height in screen lines
-  char wl_valid;                // TRUE values are valid for text in buffer
-  char wl_folded;               // TRUE when this is a range of folded lines
+  char wl_valid;                // true values are valid for text in buffer
+  char wl_folded;               // true when this is a range of folded lines
   linenr_T wl_lastlnum;         // last buffer line number for logical line
 } wline_T;
 
@@ -1227,8 +1227,8 @@ struct window_S {
    */
   linenr_T w_topline;               /* buffer line number of the line at the
                                        top of the window */
-  char w_topline_was_set;           /* flag set to TRUE when topline is set,
-                                       e.g. by winrestview() */
+  char w_topline_was_set;           // flag set to true when topline is set,
+                                    // e.g. by winrestview()
   int w_topfill;                    // number of filler lines above w_topline
   int w_old_topfill;                // w_topfill at last redraw
   bool w_botfill;                   // true when filler lines are actually
@@ -1363,7 +1363,7 @@ struct window_S {
   linenr_T w_ru_topline;            // topline shown in ruler
   linenr_T w_ru_line_count;         // line count used for ruler
   int w_ru_topfill;                 // topfill shown in ruler
-  char w_ru_empty;                  // TRUE if ruler shows 0-1 (empty line)
+  char w_ru_empty;                  // true if ruler shows 0-1 (empty line)
 
   int w_alt_fnum;                   // alternate file (for # and CTRL-^)
 
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 22b0f26a1c..9132d6666e 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -277,7 +277,7 @@ static bool use_cursor_line_sign(win_T *wp, linenr_T lnum)
 }
 
 // Get information needed to display the sign in line 'lnum' in window 'wp'.
-// If 'nrcol' is TRUE, the sign is going to be displayed in the number column.
+// If 'nrcol' is true, the sign is going to be displayed in the number column.
 // Otherwise the sign is going to be displayed in the sign column.
 //
 // @param count max number of signs
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 5fc19f9409..82429d6542 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1575,7 +1575,7 @@ static void undisplay_dollar(void)
 /// type == INDENT_DEC   decrease indent (for CTRL-D)
 /// type == INDENT_SET   set indent to "amount"
 ///
-/// @param round               if TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec).
+/// @param round               if true, round the indent to 'shiftwidth' (only with _INC and _Dec).
 /// @param replaced            replaced character, put on replace stack
 /// @param call_changed_bytes  call changed_bytes()
 void change_indent(int type, int amount, int round, int replaced, int call_changed_bytes)
@@ -1599,7 +1599,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 
   // for the following tricks we don't want list mode
   save_p_list = curwin->w_p_list;
-  curwin->w_p_list = FALSE;
+  curwin->w_p_list = false;
   vc = getvcol_nolist(&curwin->w_cursor);
   vcol = vc;
 
@@ -1718,7 +1718,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   } else {
     curwin->w_cursor.col = (colnr_T)new_cursor_col;
   }
-  curwin->w_set_curswant = TRUE;
+  curwin->w_set_curswant = true;
   changed_cline_bef_curs();
 
   /*
@@ -1978,7 +1978,7 @@ static void insert_special(int c, int allow_modmask, int ctrlv)
   // inserted with ins_str(), so as not to replace characters in replace
   // mode.
   // Only use mod_mask for special keys, to avoid things like <S-Space>,
-  // unless 'allow_modmask' is TRUE.
+  // unless 'allow_modmask' is true.
   if (mod_mask & MOD_MASK_CMD) {  // Command-key never produces a normal key.
     allow_modmask = true;
   }
@@ -3086,7 +3086,7 @@ void beginline(int flags)
         curwin->w_cursor.col++;
       }
     }
-    curwin->w_set_curswant = TRUE;
+    curwin->w_set_curswant = true;
   }
 }
 
@@ -3130,7 +3130,7 @@ int oneright(void)
   }
   curwin->w_cursor.col += l;
 
-  curwin->w_set_curswant = TRUE;
+  curwin->w_set_curswant = true;
   return OK;
 }
 
@@ -3165,7 +3165,7 @@ int oneleft(void)
       }
     }
 
-    curwin->w_set_curswant = TRUE;
+    curwin->w_set_curswant = true;
     return OK;
   }
 
@@ -3182,7 +3182,7 @@ int oneleft(void)
   return OK;
 }
 
-/// @oaram upd_topline  When TRUE: update topline
+/// @oaram upd_topline  When true: update topline
 int cursor_up(long n, int upd_topline)
 {
   linenr_T lnum;
@@ -3237,7 +3237,7 @@ int cursor_up(long n, int upd_topline)
 
 /// Cursor down a number of logical lines.
 ///
-/// @param upd_topline  When TRUE: update topline
+/// @param upd_topline  When true: update topline
 int cursor_down(long n, int upd_topline)
 {
   linenr_T lnum;
@@ -4007,13 +4007,13 @@ static void ins_reg(void)
   no_mapping++;
   allow_keys++;
   regname = plain_vgetc();
-  LANGMAP_ADJUST(regname, TRUE);
+  LANGMAP_ADJUST(regname, true);
   if (regname == Ctrl_R || regname == Ctrl_O || regname == Ctrl_P) {
     // Get a third key for literal register insertion
     literally = regname;
     add_to_showcmd_c(literally);
     regname = plain_vgetc();
-    LANGMAP_ADJUST(regname, TRUE);
+    LANGMAP_ADJUST(regname, true);
   }
   no_mapping--;
   allow_keys--;
@@ -4051,7 +4051,7 @@ static void ins_reg(void)
       need_redraw = true;  // remove the '"'
     } else if (stop_insert_mode) {
       // When the '=' register was used and a function was invoked that
-      // did ":stopinsert" then stuff_empty() returns FALSE but we won't
+      // did ":stopinsert" then stuff_empty() returns false but we won't
       // insert anything, need to remove the '"'
       need_redraw = true;
     }
@@ -4202,7 +4202,7 @@ static bool ins_esc(long *count, int cmdchar, bool nomove)
       // Repeat the insert
       return false;
     }
-    stop_insert(&curwin->w_cursor, TRUE, nomove);
+    stop_insert(&curwin->w_cursor, true, nomove);
     undisplay_dollar();
   }
 
@@ -4400,9 +4400,9 @@ static void ins_shift(int c, int lastc)
     if (lastc == '^') {
       old_indent = get_indent();        // remember curr. indent
     }
-    change_indent(INDENT_SET, 0, TRUE, 0, TRUE);
+    change_indent(INDENT_SET, 0, true, 0, true);
   } else {
-    change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, TRUE, 0, TRUE);
+    change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, true, 0, true);
   }
 
   if (did_ai && *skipwhite((char *)get_cursor_line_ptr()) != NUL) {
@@ -4574,7 +4574,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
           }
         }
 
-        do_join(2, FALSE, FALSE, FALSE, false);
+        do_join(2, false, false, false, false);
         if (temp == NUL && gchar_cursor() != NUL) {
           inc_cursor();
         }
@@ -4856,7 +4856,7 @@ static void ins_mousescroll(int dir)
     }
   }
 
-  curwin->w_redr_status = TRUE;
+  curwin->w_redr_status = true;
 
   curwin = old_curwin;
   curbuf = curwin->w_buffer;
@@ -5024,7 +5024,7 @@ static void ins_up(bool startcol)
 
   undisplay_dollar();
   tpos = curwin->w_cursor;
-  if (cursor_up(1L, TRUE) == OK) {
+  if (cursor_up(1L, true) == OK) {
     if (startcol) {
       coladvance(getvcol_nolist(&Insstart));
     }
@@ -5072,7 +5072,7 @@ static void ins_down(bool startcol)
 
   undisplay_dollar();
   tpos = curwin->w_cursor;
-  if (cursor_down(1L, TRUE) == OK) {
+  if (cursor_down(1L, true) == OK) {
     if (startcol) {
       coladvance(getvcol_nolist(&Insstart));
     }
@@ -5407,7 +5407,7 @@ static int ins_digraph(void)
 
   if (IS_SPECIAL(c) || mod_mask) {          // special key
     clear_showcmd();
-    insert_special(c, TRUE, FALSE);
+    insert_special(c, true, false);
     return NUL;
   }
   if (c != ESC) {
@@ -5508,7 +5508,7 @@ static int ins_ctrl_ey(int tc)
       }
       tw_save = curbuf->b_p_tw;
       curbuf->b_p_tw = -1;
-      insert_special(c, TRUE, FALSE);
+      insert_special(c, true, false);
       curbuf->b_p_tw = tw_save;
       revins_chars++;
       revins_legal++;
@@ -5557,7 +5557,7 @@ static void ins_try_si(int c)
       i = get_indent();
       curwin->w_cursor = old_pos;
       if (State & VREPLACE_FLAG) {
-        change_indent(INDENT_SET, i, FALSE, NUL, TRUE);
+        change_indent(INDENT_SET, i, false, NUL, true);
       } else {
         (void)set_indent(i, SIN_CHANGED);
       }
@@ -5582,7 +5582,7 @@ static void ins_try_si(int c)
         curwin->w_cursor = old_pos;
       }
       if (temp) {
-        shift_line(TRUE, FALSE, 1, TRUE);
+        shift_line(true, false, 1, true);
       }
     }
   }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 6d37106143..adcc173c71 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -101,7 +101,7 @@ static garray_T ga_loaded = { 0, 0, sizeof(char *), 4, NULL };
 
 /// Info used by a ":for" loop.
 typedef struct {
-  int fi_semicolon;             // TRUE if ending in '; var]'
+  int fi_semicolon;             // true if ending in '; var]'
   int fi_varcount;              // nr of variables in the list
   listwatch_T fi_lw;            // keep an eye on the item used.
   list_T *fi_list;              // list being used
@@ -691,11 +691,11 @@ void eval_patch(const char *const origfile, const char *const difffile, const ch
 }
 
 /// Top level evaluation function, returning a boolean.
-/// Sets "error" to TRUE if there was an error.
+/// Sets "error" to true if there was an error.
 ///
 /// @param skip  only parse, don't execute
 ///
-/// @return  TRUE or FALSE.
+/// @return  true or false.
 int eval_to_bool(char *arg, bool *error, char **nextcmd, int skip)
 {
   typval_T tv;
@@ -895,7 +895,7 @@ char *eval_to_string(char *arg, char **nextcmd, bool convert)
 /// Call eval_to_string() without using current local variables and using
 /// textlock.
 ///
-/// @param use_sandbox  when TRUE, use the sandbox.
+/// @param use_sandbox  when true, use the sandbox.
 char *eval_to_string_safe(char *arg, char **nextcmd, int use_sandbox)
 {
   char *retval;
@@ -1812,7 +1812,7 @@ notify:
 /// Evaluate the expression used in a ":for var in expr" command.
 /// "arg" points to "var".
 ///
-/// @param[out] *errp  set to TRUE for an error, FALSE otherwise;
+/// @param[out] *errp  set to true for an error, false otherwise;
 ///
 /// @return  a pointer that holds the info.  Null when there is an error.
 void *eval_for_line(const char *arg, bool *errp, char **nextcmdp, int skip)
@@ -2184,7 +2184,7 @@ char *get_user_var_name(expand_T *xp, int idx)
 
 /// Does not use 'cpo' and always uses 'magic'.
 ///
-/// @return  TRUE if "pat" matches "text".
+/// @return  true if "pat" matches "text".
 int pattern_match(char *pat, char *text, bool ic)
 {
   int matches = 0;
@@ -2263,13 +2263,13 @@ static int eval_func(char **const arg, char *const name, const int name_len, typ
 
 // TODO(ZyX-I): move to eval/expressions
 
-/// The "evaluate" argument: When FALSE, the argument is only parsed but not
+/// The "evaluate" argument: When false, the argument is only parsed but not
 /// executed.  The function may return OK, but the rettv will be of type
 /// VAR_UNKNOWN.  The function still returns FAIL for a syntax error.
 
 /// Handle zero level expression.
 /// This calls eval1() and handles error message and nextcmd.
-/// Put the result in "rettv" when returning OK and "evaluate" is TRUE.
+/// Put the result in "rettv" when returning OK and "evaluate" is true.
 /// Note: "rettv.v_lock" is not set.
 ///
 /// @return OK or FAIL.
@@ -6786,14 +6786,14 @@ static char *make_expanded_name(const char *in_start, char *expr_start, char *ex
   return retval;
 }
 
-/// @return  TRUE if character "c" can be used in a variable or function name.
+/// @return  true if character "c" can be used in a variable or function name.
 ///          Does not include '{' or '}' for magic braces.
 int eval_isnamec(int c)
 {
   return ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR;
 }
 
-/// @return  TRUE if character "c" can be used as the first character in a
+/// @return  true if character "c" can be used as the first character in a
 ///          variable or function name (excluding '{' and '}').
 int eval_isnamec1(int c)
 {
@@ -6846,7 +6846,7 @@ void set_vim_var_char(int c)
 
 /// Set v:count to "count" and v:count1 to "count1".
 ///
-/// @param set_prevcount  if TRUE, first set v:prevcount from v:count.
+/// @param set_prevcount  if true, first set v:prevcount from v:count.
 void set_vcount(long count, long count1, int set_prevcount)
 {
   if (set_prevcount) {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index ff5d8a0a8f..78298765a0 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -234,7 +234,7 @@ int call_internal_method(const char_u *const fname, const int argcount, typval_T
   return ERROR_NONE;
 }
 
-/// @return  TRUE for a non-zero Number and a non-empty String.
+/// @return  true for a non-zero Number and a non-empty String.
 static int non_zero_arg(typval_T *argvars)
 {
   return ((argvars[0].v_type == VAR_NUMBER
@@ -2548,7 +2548,7 @@ static void f_getbufinfo(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
 /// Get line or list of lines from buffer "buf" into "rettv".
 ///
-/// @param retlist  if TRUE, then the lines are returned as a Vim List.
+/// @param retlist  if true, then the lines are returned as a Vim List.
 ///
 /// @return  range (from start to end) of lines in rettv from the specified
 ///          buffer.
@@ -7549,7 +7549,7 @@ static void f_setbufline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 }
 
 /// Set the cursor or mark position.
-/// If 'charpos' is TRUE, then use the column number as a character offset.
+/// If 'charpos' is true, then use the column number as a character offset.
 /// Otherwise use the column number as a byte offset.
 static void set_position(typval_T *argvars, typval_T *rettv, bool charpos)
 {
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index bb2e2b19c2..8cb7a075cb 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1083,7 +1083,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
   const sctx_T save_current_sctx = current_sctx;
   current_sctx = fp->uf_script_ctx;
   save_did_emsg = did_emsg;
-  did_emsg = FALSE;
+  did_emsg = false;
 
   if (default_arg_err && (fp->uf_flags & FC_ABORT)) {
     did_emsg = true;
@@ -2012,14 +2012,14 @@ void ex_function(exarg_T *eap)
       xfree(fudi.fd_newkey);
       return;
     } else {
-      eap->skip = TRUE;
+      eap->skip = true;
     }
   }
 
   // An error in a function call during evaluation of an expression in magic
   // braces should not cause the function not to be defined.
   saved_did_emsg = did_emsg;
-  did_emsg = FALSE;
+  did_emsg = false;
 
   //
   // ":function func" with only function name: list function.
@@ -2853,7 +2853,7 @@ void ex_return(exarg_T *eap)
 {
   char_u *arg = (char_u *)eap->arg;
   typval_T rettv;
-  int returning = FALSE;
+  int returning = false;
 
   if (current_funccal == NULL) {
     emsg(_("E133: :return not inside a function"));
@@ -3035,8 +3035,8 @@ end:
 /// @param is_cmd     set when called due to a ":return" command.
 /// @param rettv      may point to a typval_T with the return rettv.
 ///
-/// @return  TRUE when the return can be carried out,
-///          FALSE when the return gets pending.
+/// @return  true when the return can be carried out,
+///          false when the return gets pending.
 int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
 {
   int idx;
@@ -3086,7 +3086,7 @@ int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
     }
     report_make_pending(CSTP_RETURN, rettv);
   } else {
-    current_funccal->returned = TRUE;
+    current_funccal->returned = true;
 
     // If the return is carried out now, store the return value.  For
     // a return immediately after reanimation, the value is already
@@ -3178,7 +3178,7 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
   return (char *)retval;
 }
 
-/// @return  TRUE if the currently active function should be ended, because a
+/// @return  true if the currently active function should be ended, because a
 ///          return was encountered or an error occurred.  Used inside a ":while".
 int func_has_ended(void *cookie)
 {
@@ -3190,7 +3190,7 @@ int func_has_ended(void *cookie)
          || fcp->returned;
 }
 
-/// @return  TRUE if cookie indicates a function which "abort"s on errors.
+/// @return  true if cookie indicates a function which "abort"s on errors.
 int func_has_abort(void *cookie)
 {
   return ((funccall_T *)cookie)->func->uf_flags & FC_ABORT;
@@ -3281,7 +3281,7 @@ int func_level(void *cookie)
   return ((funccall_T *)cookie)->level;
 }
 
-/// @return  TRUE when a function was ended by a ":return" command.
+/// @return  true when a function was ended by a ":return" command.
 int current_func_returned(void)
 {
   return current_funccal->returned;
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index d1336b4e28..0086cc41ca 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -1119,7 +1119,7 @@ void vars_clear(hashtab_T *ht)
   vars_clear_ext(ht, true);
 }
 
-/// Like vars_clear(), but only free the value if "free_val" is TRUE.
+/// Like vars_clear(), but only free the value if "free_val" is true.
 void vars_clear_ext(hashtab_T *ht, int free_val)
 {
   int todo;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 69208cff99..91df8c169a 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -274,7 +274,7 @@ void ex_align(exarg_T *eap)
     if (eap->cmdidx == CMD_left) {              // left align
       new_indent = indent;
     } else {
-      has_tab = FALSE;          // avoid uninit warnings
+      has_tab = false;          // avoid uninit warnings
       len = linelen(eap->cmdidx == CMD_right ? &has_tab
                                              : NULL) - get_indent();
 
@@ -404,7 +404,7 @@ static int sort_compare(const void *s1, const void *s2)
   }
   fast_breakcheck();
   if (got_int) {
-    sort_abort = TRUE;
+    sort_abort = true;
   }
 
   // When sorting numbers "start_col_nr" is the number, not the column
@@ -1150,7 +1150,7 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
   }
 
   if (addr_count == 0) {                // :!
-    msg_scroll = FALSE;             // don't scroll here
+    msg_scroll = false;             // don't scroll here
     autowrite_all();
     msg_scroll = scroll_save;
   }
@@ -1376,14 +1376,14 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
   call_shell((char_u *)cmd_buf, (ShellOpts)(kShellOptFilter | shell_flags), NULL);
   xfree(cmd_buf);
 
-  did_check_timestamps = FALSE;
-  need_check_timestamps = TRUE;
+  did_check_timestamps = false;
+  need_check_timestamps = true;
 
   // When interrupting the shell command, it may still have produced some
   // useful output.  Reset got_int here, so that readfile() won't cancel
   // reading.
   os_breakcheck();
-  got_int = FALSE;
+  got_int = false;
 
   if (do_out) {
     if (otmp != NULL) {
@@ -1714,7 +1714,7 @@ void print_line(linenr_T lnum, int use_number, int list)
   }
 
   msg_start();
-  silent_mode = FALSE;
+  silent_mode = false;
   info_message = true;  // use mch_msg(), not mch_errmsg()
   print_line_no_prefix(lnum, use_number, list);
   if (save_silent) {
@@ -1822,7 +1822,7 @@ void ex_write(exarg_T *eap)
 }
 
 /// write current buffer to file 'eap->arg'
-/// if 'eap->append' is TRUE, append to the file
+/// if 'eap->append' is true, append to the file
 ///
 /// if *eap->arg == NUL write to current file
 ///
@@ -1847,7 +1847,7 @@ int do_write(exarg_T *eap)
       emsg(_(e_argreq));
       goto theend;
     }
-    other = FALSE;
+    other = false;
   } else {
     fname = ffname;
     free_fname = fix_fname(ffname);
@@ -1899,7 +1899,7 @@ int do_write(exarg_T *eap)
                              (char_u *)_("Write partial file?"), 2) != VIM_YES) {
           goto theend;
         }
-        eap->forceit = TRUE;
+        eap->forceit = true;
       } else {
         emsg(_("E140: Use ! to write partial buffer"));
         goto theend;
@@ -1936,8 +1936,8 @@ int do_write(exarg_T *eap)
       apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, curbuf);
       apply_autocmds(EVENT_BUFFILEPOST, NULL, NULL, false, alt_buf);
       if (!alt_buf->b_p_bl) {
-        alt_buf->b_p_bl = TRUE;
-        apply_autocmds(EVENT_BUFADD, NULL, NULL, FALSE, alt_buf);
+        alt_buf->b_p_bl = true;
+        apply_autocmds(EVENT_BUFADD, NULL, NULL, false, alt_buf);
       }
       if (curbuf != was_curbuf || aborting()) {
         // buffer changed, don't write the file
@@ -1965,7 +1965,7 @@ int do_write(exarg_T *eap)
     // After ":saveas fname" reset 'readonly'.
     if (eap->cmdidx == CMD_saveas) {
       if (retval == OK) {
-        curbuf->b_p_ro = FALSE;
+        curbuf->b_p_ro = false;
         redraw_tabline = true;
       }
     }
@@ -2017,7 +2017,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
         if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) != VIM_YES) {
           return FAIL;
         }
-        eap->forceit = TRUE;
+        eap->forceit = true;
       } else {
         emsg(_(e_exists));
         return FAIL;
@@ -2057,7 +2057,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
             xfree(swapname);
             return FAIL;
           }
-          eap->forceit = TRUE;
+          eap->forceit = true;
         } else {
           semsg(_("E768: Swap file exists: %s (:silent! overrides)"),
                 swapname);
@@ -2158,7 +2158,7 @@ bool not_writing(void)
 }
 
 /// Check if a buffer is read-only (either 'readonly' option is set or file is
-/// read-only). Ask for overruling in a dialog. Return TRUE and give an error
+/// read-only). Ask for overruling in a dialog. Return true and give an error
 /// message when the buffer is readonly.
 static int check_readonly(int *forceit, buf_T *buf)
 {
@@ -2183,10 +2183,10 @@ static int check_readonly(int *forceit, buf_T *buf)
 
       if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) == VIM_YES) {
         // Set forceit, to force the writing of a readonly file
-        *forceit = TRUE;
-        return FALSE;
+        *forceit = true;
+        return false;
       } else {
-        return TRUE;
+        return true;
       }
     } else if (buf->b_p_ro) {
       emsg(_(e_readonly));
@@ -2194,10 +2194,10 @@ static int check_readonly(int *forceit, buf_T *buf)
       semsg(_("E505: \"%s\" is read-only (add ! to override)"),
             buf->b_fname);
     }
-    return TRUE;
+    return true;
   }
 
-  return FALSE;
+  return false;
 }
 
 /// Try to abandon the current file and edit a new or existing file.
@@ -2291,7 +2291,7 @@ theend:
 ///                 ECMD_LASTL: use last position in loaded file
 ///                 ECMD_LAST: use last position in all files
 ///                 ECMD_ONE: use first line
-/// @param flags    ECMD_HIDE: if TRUE don't free the current buffer
+/// @param flags    ECMD_HIDE: if true don't free the current buffer
 ///                 ECMD_SET_HELP: set b_help flag of (new) buffer before
 ///                 opening file
 ///                 ECMD_OLDBUF: use existing buffer if it exists
@@ -2309,7 +2309,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
             win_T *oldwin)
 {
   bool other_file;                      // true if editing another file
-  int oldbuf;                           // TRUE if using existing buffer
+  int oldbuf;                           // true if using existing buffer
   bool auto_buf = false;                // true if autocommands brought us
                                         // into the buffer unexpectedly
   char *new_name = NULL;
@@ -2385,7 +2385,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
 
   // If the file was changed we may not be allowed to abandon it:
   // - if we are going to re-edit the same file
-  // - or if we are the only window on this file and if ECMD_HIDE is FALSE
+  // - or if we are the only window on this file and if ECMD_HIDE is false
   if (((!other_file && !(flags & ECMD_OLDBUF))
        || (curbuf->b_nwindows == 1
            && !(flags & (ECMD_HIDE | ECMD_ADDBUF | ECMD_ALTBUF))))
@@ -2503,7 +2503,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
 
     /*
      * Make the (new) buffer the one used by the current window.
-     * If the old buffer becomes unused, free it if ECMD_HIDE is FALSE.
+     * If the old buffer becomes unused, free it if ECMD_HIDE is false.
      * If the current buffer was empty and has no file name, curbuf
      * is returned by buflist_new(), nothing to do here.
      */
@@ -2604,7 +2604,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
 
           // Set 'fileformat', 'binary' and 'fenc' when forced.
           if (!oldbuf && eap != NULL) {
-            set_file_options(TRUE, eap);
+            set_file_options(true, eap);
             set_forced_fenc(eap);
           }
         }
@@ -2640,7 +2640,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
   } else if (!curbuf->b_help) {
     // Don't make a buffer listed if it's a help buffer.  Useful when using
     // CTRL-O to go back to a help file.
-    set_buflisted(TRUE);
+    set_buflisted(true);
   }
 
   // If autocommands change buffers under our fingers, forget about
@@ -2659,10 +2659,10 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
 
   /*
    * other_file oldbuf
-   *  FALSE     FALSE       re-edit same file, buffer is re-used
-   *  FALSE     TRUE        re-edit same file, nothing changes
-   *  TRUE      FALSE       start editing new file, new buffer
-   *  TRUE      TRUE        start editing in existing buffer (nothing to do)
+   *  false     false       re-edit same file, buffer is re-used
+   *  false     true        re-edit same file, nothing changes
+   *  true      false       start editing new file, new buffer
+   *  true      true        start editing in existing buffer (nothing to do)
    */
   if (!other_file && !oldbuf) {         // re-use the buffer
     set_last_cursor(curwin);            // may set b_last_cursor
@@ -2789,7 +2789,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
       // changed by the user.
       do_modelines(OPT_WINONLY);
 
-      apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, FALSE, curbuf,
+      apply_autocmds_retval(EVENT_BUFENTER, NULL, NULL, false, curbuf,
                             &retval);
       if ((flags & ECMD_NOWINENTER) == 0) {
         apply_autocmds_retval(EVENT_BUFWINENTER, NULL, NULL, false, curbuf,
@@ -2847,7 +2847,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
         curwin->w_cursor.col = solcol;
         check_cursor_col();
         curwin->w_cursor.coladd = 0;
-        curwin->w_set_curswant = TRUE;
+        curwin->w_set_curswant = true;
       } else {
         beginline(BL_SOL | BL_FIX);
       }
@@ -2873,7 +2873,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     // Obey the 'O' flag in 'cpoptions': overwrite any previous file
     // message.
     if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0) {
-      msg_scroll = FALSE;
+      msg_scroll = false;
     }
     if (!msg_scroll) {          // wait a bit when overwriting an error msg
       check_for_delay(false);
@@ -3803,7 +3803,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
         // Save the line number of the last change for the final
         // cursor position (just like Vi).
         curwin->w_cursor.lnum = lnum;
-        do_again = FALSE;
+        do_again = false;
 
         /*
          * 1. Match empty string does not count, except for first
@@ -3954,7 +3954,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
                                    - regmatch.startpos[0].lnum;
               search_match_endcol = regmatch.endpos[0].col
                                     + len_change;
-              highlight_match = TRUE;
+              highlight_match = true;
 
               update_topline(curwin);
               validate_cursor();
@@ -4767,10 +4767,9 @@ bool prepare_tagpreview(bool undo_sync)
           == FAIL) {
         return false;
       }
-      curwin->w_p_pvw = TRUE;
-      curwin->w_p_wfh = TRUE;
-      RESET_BINDING(curwin);                /* don't take over 'scrollbind'
-                                               and 'cursorbind' */
+      curwin->w_p_pvw = true;
+      curwin->w_p_wfh = true;
+      RESET_BINDING(curwin);                // don't take over 'scrollbind' and 'cursorbind'
       curwin->w_p_diff = false;             // no 'diff'
       set_string_option_direct("fdc", -1,     // no 'foldcolumn'
                                "0", OPT_FREE, SID_NONE);
diff --git a/src/nvim/ex_cmds_defs.h b/src/nvim/ex_cmds_defs.h
index e80e47bcff..5d8ed64c60 100644
--- a/src/nvim/ex_cmds_defs.h
+++ b/src/nvim/ex_cmds_defs.h
@@ -188,7 +188,7 @@ struct exarg {
   cmdidx_T cmdidx;              ///< the index for the command
   uint32_t argt;                ///< flags for the command
   int skip;                     ///< don't execute the command, only parse it
-  int forceit;                  ///< TRUE if ! present
+  int forceit;                  ///< true if ! present
   int addr_count;               ///< the number of addresses given
   linenr_T line1;               ///< the first line number
   linenr_T line2;               ///< the second line number or count
@@ -196,8 +196,8 @@ struct exarg {
   int flags;                    ///< extra flags after count: EXFLAG_
   char *do_ecmd_cmd;            ///< +command arg to be used in edited file
   linenr_T do_ecmd_lnum;        ///< the line number in an edited file
-  int append;                   ///< TRUE with ":w >>file" command
-  int usefilter;                ///< TRUE with ":w !command" and ":r!command"
+  int append;                   ///< true with ":w >>file" command
+  int usefilter;                ///< true with ":w !command" and ":r!command"
   int amount;                   ///< number of '>' or '<' for shift command
   int regname;                  ///< register name (NUL if none)
   int force_bin;                ///< 0, FORCE_BIN or FORCE_NOBIN
@@ -230,7 +230,7 @@ struct expand {
   sctx_T xp_script_ctx;         // SCTX for completion function
   int xp_backslash;             // one of the XP_BS_ values
 #ifndef BACKSLASH_IN_FILENAME
-  int xp_shell;                 // TRUE for a shell command, more
+  int xp_shell;                 // true for a shell command, more
                                 // characters need to be escaped
 #endif
   int xp_numfiles;              // number of files found by file name completion
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 8941921568..19dcc06825 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -45,7 +45,7 @@
 // there or even outside the try conditional.  Try conditionals may be nested.
 
 // Configuration whether an exception is thrown on error or interrupt.  When
-// the preprocessor macros below evaluate to FALSE, an error (did_emsg) or
+// the preprocessor macros below evaluate to false, an error (did_emsg) or
 // interrupt (got_int) under an active try conditional terminates the script
 // after the non-active finally clauses of all active try conditionals have been
 // executed.  Otherwise, errors and/or interrupts are converted into catchable
@@ -82,14 +82,14 @@ static void discard_pending_return(typval_T *p)
 
 /*
  * When several errors appear in a row, setting "force_abort" is delayed until
- * the failing command returned.  "cause_abort" is set to TRUE meanwhile, in
+ * the failing command returned.  "cause_abort" is set to true meanwhile, in
  * order to indicate that situation.  This is useful when "force_abort" was set
  * during execution of a function call from an expression: the aborting of the
  * expression evaluation is done without producing any error messages, but all
  * error messages on parsing errors during the expression evaluation are given
  * (even if a try conditional is active).
  */
-static int cause_abort = FALSE;
+static int cause_abort = false;
 
 /// @return  true when immediately aborting on error, or when an interrupt
 ///          occurred or an exception was thrown but not caught.
@@ -114,11 +114,11 @@ int aborting(void)
 void update_force_abort(void)
 {
   if (cause_abort) {
-    force_abort = TRUE;
+    force_abort = true;
   }
 }
 
-/// @return  TRUE if a command with a subcommand resulting in "retcode" should
+/// @return  true if a command with a subcommand resulting in "retcode" should
 /// abort the script processing.  Can be used to suppress an autocommand after
 /// execution of a failing subcommand as long as the error message has not been
 /// displayed and actually caused the abortion.
@@ -127,7 +127,7 @@ int should_abort(int retcode)
   return (retcode == FAIL && trylevel != 0 && !emsg_silent) || aborting();
 }
 
-/// @return  TRUE if a function with the "abort" flag should not be considered
+/// @return  true if a function with the "abort" flag should not be considered
 /// ended on an error.  This means that parsing commands is continued in order
 /// to find finally clauses to be executed, and that some errors in skipped
 /// commands are still reported.
@@ -175,7 +175,7 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
    */
   if (!did_emsg) {
     cause_abort = force_abort;
-    force_abort = FALSE;
+    force_abort = false;
   }
 
   /*
@@ -206,7 +206,7 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
    * Ensure that all commands in nested function calls and sourced files
    * are aborted immediately.
    */
-  cause_abort = TRUE;
+  cause_abort = true;
 
   /*
    * When an exception is being thrown, some commands (like conditionals) are
@@ -318,8 +318,8 @@ void do_errthrow(cstack_T *cstack, char *cmdname)
    * are aborted immediately.
    */
   if (cause_abort) {
-    cause_abort = FALSE;
-    force_abort = TRUE;
+    cause_abort = false;
+    force_abort = true;
   }
 
   // If no exception is to be thrown or the conversion should be done after
@@ -334,7 +334,7 @@ void do_errthrow(cstack_T *cstack, char *cmdname)
     if (cstack != NULL) {
       do_throw(cstack);
     } else {
-      need_rethrow = TRUE;
+      need_rethrow = true;
     }
   }
   *msg_list = NULL;
@@ -343,8 +343,8 @@ void do_errthrow(cstack_T *cstack, char *cmdname)
 /// do_intthrow(): Replace the current exception by an interrupt or interrupt
 /// exception if appropriate.
 ///
-/// @return  TRUE if the current exception is discarded or,
-///          FALSE otherwise.
+/// @return  true if the current exception is discarded or,
+///          false otherwise.
 int do_intthrow(cstack_T *cstack)
 {
   // If no interrupt occurred or no try conditional is active and no exception
@@ -501,13 +501,13 @@ static int throw_exception(void *value, except_type_T type, char *cmdname)
     int save_msg_silent = msg_silent;
 
     if (debug_break_level > 0) {
-      msg_silent = FALSE;               // display messages
+      msg_silent = false;               // display messages
     } else {
       verbose_enter();
     }
     no_wait_return++;
     if (debug_break_level > 0 || *p_vfile == NUL) {
-      msg_scroll = TRUE;            // always scroll up, don't overwrite
+      msg_scroll = true;            // always scroll up, don't overwrite
     }
     smsg(_("Exception thrown: %s"), excp->value);
     msg_puts("\n");  // don't overwrite this either
@@ -554,13 +554,13 @@ static void discard_exception(except_T *excp, bool was_finished)
 
     saved_IObuff = (char *)vim_strsave(IObuff);
     if (debug_break_level > 0) {
-      msg_silent = FALSE;               // display messages
+      msg_silent = false;               // display messages
     } else {
       verbose_enter();
     }
     no_wait_return++;
     if (debug_break_level > 0 || *p_vfile == NUL) {
-      msg_scroll = TRUE;            // always scroll up, don't overwrite
+      msg_scroll = true;            // always scroll up, don't overwrite
     }
     smsg(was_finished ? _("Exception finished: %s")
                       : _("Exception discarded: %s"),
@@ -622,13 +622,13 @@ static void catch_exception(except_T *excp)
     int save_msg_silent = msg_silent;
 
     if (debug_break_level > 0) {
-      msg_silent = FALSE;               // display messages
+      msg_silent = false;               // display messages
     } else {
       verbose_enter();
     }
     no_wait_return++;
     if (debug_break_level > 0 || *p_vfile == NUL) {
-      msg_scroll = TRUE;            // always scroll up, don't overwrite
+      msg_scroll = true;            // always scroll up, don't overwrite
     }
     smsg(_("Exception caught: %s"), excp->value);
     msg_puts("\n");  // don't overwrite this either
@@ -746,7 +746,7 @@ static void report_pending(int action, int pending, void *value)
 
   save_msg_silent = msg_silent;
   if (debug_break_level > 0) {
-    msg_silent = FALSE;         // display messages
+    msg_silent = false;         // display messages
   }
   no_wait_return++;
   msg_scroll = true;            // always scroll up, don't overwrite
@@ -987,7 +987,7 @@ void ex_while(exarg_T *eap)
         // Jumping here from a ":continue" or ":endfor": use the
         // previously evaluated list.
         fi = cstack->cs_forinfo[cstack->cs_idx];
-        error = FALSE;
+        error = false;
       } else {
         // Evaluate the argument and get the info in a structure.
         fi = eval_for_line(eap->arg, &error, &eap->nextcmd, skip);
@@ -998,7 +998,7 @@ void ex_while(exarg_T *eap)
       if (!error && fi != NULL && !skip) {
         result = next_for_item(fi, eap->arg);
       } else {
-        result = FALSE;
+        result = false;
       }
 
       if (!result) {
@@ -1131,7 +1131,7 @@ void ex_endwhile(exarg_T *eap)
         }
       }
       // Cleanup and rewind all contained (and unclosed) conditionals.
-      (void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
+      (void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, false);
       rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
     } else if (cstack->cs_flags[cstack->cs_idx] & CSF_TRUE
                && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)
@@ -1186,7 +1186,7 @@ void ex_throw(exarg_T *eap)
 void do_throw(cstack_T *cstack)
 {
   int idx;
-  int inactivate_try = FALSE;
+  int inactivate_try = false;
 
   //
   // Cleanup and deactivate up to the next surrounding try conditional that
@@ -1199,14 +1199,14 @@ void do_throw(cstack_T *cstack)
   //
 #ifndef THROW_ON_ERROR_TRUE
   if (did_emsg && !THROW_ON_ERROR) {
-    inactivate_try = TRUE;
-    did_emsg = FALSE;
+    inactivate_try = true;
+    did_emsg = false;
   }
 #endif
 #ifndef THROW_ON_INTERRUPT_TRUE
   if (got_int && !THROW_ON_INTERRUPT) {
-    inactivate_try = TRUE;
-    got_int = FALSE;
+    inactivate_try = true;
+    got_int = false;
   }
 #endif
   idx = cleanup_conditionals(cstack, 0, inactivate_try);
@@ -1434,7 +1434,7 @@ void ex_catch(exarg_T *eap)
        * a ":continue", ":break", ":return", or ":finish", discard the
        * pending action.
        */
-      cleanup_conditionals(cstack, CSF_TRY, TRUE);
+      cleanup_conditionals(cstack, CSF_TRY, true);
     }
   }
 
@@ -1447,7 +1447,7 @@ void ex_catch(exarg_T *eap)
 void ex_finally(exarg_T *eap)
 {
   int idx;
-  int skip = FALSE;
+  int skip = false;
   int pending = CSTP_NONE;
   cstack_T *const cstack = eap->cstack;
 
@@ -1507,7 +1507,7 @@ void ex_finally(exarg_T *eap)
        * ":continue", ":break", ":finish", or ":return" from the preceding
        * try block or catch clause.
        */
-      cleanup_conditionals(cstack, CSF_TRY, FALSE);
+      cleanup_conditionals(cstack, CSF_TRY, false);
 
       /*
        * Make did_emsg, got_int, current_exception pending.  If set, they
@@ -1683,7 +1683,7 @@ void ex_endtry(exarg_T *eap)
      * after errors except when this ":endtry" is not within a ":try".
      * Restore "emsg_silent" if it has been reset by this try conditional.
      */
-    (void)cleanup_conditionals(cstack, CSF_TRY | CSF_SILENT, TRUE);
+    (void)cleanup_conditionals(cstack, CSF_TRY | CSF_SILENT, true);
 
     if (cstack->cs_idx >= 0 && (cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
       cstack->cs_idx--;
@@ -1712,10 +1712,10 @@ void ex_endtry(exarg_T *eap)
         ex_break(eap);
         break;
       case CSTP_RETURN:
-        do_return(eap, FALSE, FALSE, rettv);
+        do_return(eap, false, false, rettv);
         break;
       case CSTP_FINISH:
-        do_finish(eap, FALSE);
+        do_finish(eap, false);
         break;
 
       // When the finally clause was entered due to an error,
@@ -1792,7 +1792,7 @@ void enter_cleanup(cleanup_T *csp)
       csp->exception = NULL;
       if (did_emsg) {
         force_abort |= cause_abort;
-        cause_abort = FALSE;
+        cause_abort = false;
       }
     }
     did_emsg = got_int = need_rethrow = false;
@@ -1863,7 +1863,7 @@ void leave_cleanup(cleanup_T *csp)
       // enter_cleanup() was called, let "cause_abort" take the part of
       // "force_abort" (as done by cause_errthrow()).
       cause_abort = force_abort;
-      force_abort = FALSE;
+      force_abort = false;
     }
 
     // Restore the pending values of did_emsg, got_int, and current_exception.
@@ -1895,7 +1895,7 @@ void leave_cleanup(cleanup_T *csp)
 ///                       inactive itself (a try conditional not in its finally
 ///                       clause possibly find before is always made inactive).
 ///
-/// If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT, the saved
+/// If "inclusive" is true and "searched_cond" is CSF_TRY|CSF_SILENT, the saved
 /// former value of "emsg_silent", if reset when the try conditional finally
 /// reached was entered, is restored (used by ex_endtry()).  This is normally
 /// done only when such a try conditional is left.
@@ -1904,7 +1904,7 @@ void leave_cleanup(cleanup_T *csp)
 int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
 {
   int idx;
-  int stop = FALSE;
+  int stop = false;
 
   for (idx = cstack->cs_idx; idx >= 0; idx--) {
     if (cstack->cs_flags[idx] & CSF_TRY) {
@@ -1968,20 +1968,20 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
           if (searched_cond == 0 && !inclusive) {
             break;
           }
-          stop = TRUE;
+          stop = true;
         }
       }
     }
 
     // Stop on the searched conditional type (even when the surrounding
     // conditional is not active or something has been made pending).
-    // If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT,
+    // If "inclusive" is true and "searched_cond" is CSF_TRY|CSF_SILENT,
     // check first whether "emsg_silent" needs to be restored.
     if (cstack->cs_flags[idx] & searched_cond) {
       if (!inclusive) {
         break;
       }
-      stop = TRUE;
+      stop = true;
     }
     cstack->cs_flags[idx] &= ~CSF_ACTIVE;
     if (stop && searched_cond != (CSF_TRY | CSF_SILENT)) {
@@ -2046,7 +2046,7 @@ void ex_endfunction(exarg_T *eap)
   emsg(_("E193: :endfunction not inside a function"));
 }
 
-/// @return  TRUE if the string "p" looks like a ":while" or ":for" command.
+/// @return  true if the string "p" looks like a ":while" or ":for" command.
 int has_loop_cmd(char *p)
 {
   int len;
@@ -2064,7 +2064,7 @@ int has_loop_cmd(char *p)
   }
   if ((p[0] == 'w' && p[1] == 'h')
       || (p[0] == 'f' && p[1] == 'o' && p[2] == 'r')) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index ce4930d33e..6c45fb4ef1 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -105,8 +105,8 @@ typedef struct command_line_state {
   long count;
   int indent;
   int c;
-  int gotesc;                           // TRUE when <ESC> just typed
-  int do_abbr;                          // when TRUE check for abbr.
+  int gotesc;                           // true when <ESC> just typed
+  int do_abbr;                          // when true check for abbr.
   char_u *lookfor;                      // string to match
   int hiscnt;                           // current history line in use
   int save_hiscnt;                      // history line before attempting
@@ -3029,7 +3029,7 @@ color_cmdline_error:
 
 /*
  * Draw part of the cmdline at the current cursor position.  But draw stars
- * when cmdline_star is TRUE.
+ * when cmdline_star is true.
  */
 static void draw_cmdline(int start, int len)
 {
@@ -3283,7 +3283,7 @@ void cmdline_ui_flush(void)
 
 /*
  * Put a character on the command line.  Shifts the following text to the
- * right when "shift" is TRUE.  Used for CTRL-V, CTRL-K, etc.
+ * right when "shift" is true.  Used for CTRL-V, CTRL-K, etc.
  * "c" must be printable (fit in one display cell)!
  */
 void putcmdline(char c, int shift)
@@ -3309,7 +3309,7 @@ void putcmdline(char c, int shift)
   ui_cursor_shape();
 }
 
-/// Undo a putcmdline(c, FALSE).
+/// Undo a putcmdline(c, false).
 void unputcmdline(void)
 {
   if (cmd_silent) {
@@ -3330,9 +3330,9 @@ void unputcmdline(void)
 /*
  * Put the given string, of the given length, onto the command line.
  * If len is -1, then STRLEN() is used to calculate the length.
- * If 'redraw' is TRUE then the new part of the command line, and the remaining
+ * If 'redraw' is true then the new part of the command line, and the remaining
  * part will be redrawn, otherwise it will not.  If this function is called
- * twice in a row, then 'redraw' should be FALSE and redrawcmd() should be
+ * twice in a row, then 'redraw' should be false and redrawcmd() should be
  * called afterwards.
  */
 void put_on_cmdline(char_u *str, int len, int redraw)
@@ -3409,7 +3409,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
   }
 
   if (redraw && !cmd_silent) {
-    msg_no_more = TRUE;
+    msg_no_more = true;
     i = cmdline_row;
     cursorcmd();
     draw_cmdline(ccline.cmdpos, ccline.cmdlen - ccline.cmdpos);
@@ -3417,7 +3417,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     if (cmdline_row != i || ccline.overstrike) {
       msg_clr_eos();
     }
-    msg_no_more = FALSE;
+    msg_no_more = false;
   }
   if (KeyTyped) {
     m = Columns * Rows;
@@ -3544,8 +3544,8 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
 
 /*
  * Put a string on the command line.
- * When "literally" is TRUE, insert literally.
- * When "literally" is FALSE, insert as typed, but don't leave the command
+ * When "literally" is true, insert literally.
+ * When "literally" is false, insert as typed, but don't leave the command
  * line.
  */
 void cmdline_paste_str(char_u *s, int literally)
@@ -3553,7 +3553,7 @@ void cmdline_paste_str(char_u *s, int literally)
   int c, cv;
 
   if (literally) {
-    put_on_cmdline(s, -1, TRUE);
+    put_on_cmdline(s, -1, true);
   } else {
     while (*s != NUL) {
       cv = *s;
@@ -3642,7 +3642,7 @@ void redrawcmd(void)
   redrawcmdprompt();
 
   // Don't use more prompt, truncate the cmdline if it doesn't fit.
-  msg_no_more = TRUE;
+  msg_no_more = true;
   draw_cmdline(0, ccline.cmdlen);
   msg_clr_eos();
   msg_no_more = false;
@@ -3657,7 +3657,7 @@ void redrawcmd(void)
    * An emsg() before may have set msg_scroll. This is used in normal mode,
    * in cmdline mode we can reset them now.
    */
-  msg_scroll = FALSE;           // next message overwrites cmdline
+  msg_scroll = false;           // next message overwrites cmdline
 
   // Typing ':' at the more prompt may set skip_redraw.  We don't want this
   // in cmdline mode.
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 0eb6ad50ff..273fe12d31 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -220,8 +220,8 @@ static char_u e_pathtoolong[] = N_("E854: path too long for completion");
 ///
 /// Upward search is only done on the starting dir.
 ///
-/// If 'free_visited' is TRUE the list of already visited files/directories is
-/// cleared. Set this to FALSE if you just want to search from another
+/// If 'free_visited' is true the list of already visited files/directories is
+/// cleared. Set this to false if you just want to search from another
 /// directory, but want to be sure that no directory from a previous search is
 /// searched again. This is useful if you search for a file at different places.
 /// The list of visited files/dirs can also be cleared with the function
@@ -268,7 +268,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
   ff_clear(search_ctx);
 
   // clear visited list if wanted
-  if (free_visited == TRUE) {
+  if (free_visited == true) {
     vim_findfile_free_visited(search_ctx);
   } else {
     /* Reuse old visited lists. Get the visited list for the given
@@ -301,7 +301,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) {
       // Make the start dir an absolute path name.
       STRLCPY(ff_expand_buffer, rel_fname, len + 1);
-      search_ctx->ffsc_start_dir = (char_u *)FullName_save((char *)ff_expand_buffer, FALSE);
+      search_ctx->ffsc_start_dir = (char_u *)FullName_save((char *)ff_expand_buffer, false);
     } else {
       search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
     }
@@ -932,7 +932,7 @@ char_u *vim_findfile(void *search_ctx_arg)
       // is the last starting directory in the stop list?
       if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
                               (int)(path_end - search_ctx->ffsc_start_dir),
-                              search_ctx->ffsc_stopdirs_v) == TRUE) {
+                              search_ctx->ffsc_stopdirs_v) == true) {
         break;
       }
 
@@ -1276,7 +1276,7 @@ static void ff_clear(ff_search_ctx_T *search_ctx)
 
 /// check if the given path is in the stopdirs
 ///
-/// @return  TRUE if yes else FALSE
+/// @return  true if yes else false
 static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
 {
   int i = 0;
@@ -1288,7 +1288,7 @@ static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
 
   // if no path consider it as match
   if (path_len == 0) {
-    return TRUE;
+    return true;
   }
 
   for (i = 0; stopdirs_v[i] != NULL; i++) {
@@ -1299,7 +1299,7 @@ static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
        */
       if (FNAMENCMP(stopdirs_v[i], path, path_len) == 0
           && vim_ispathsep(stopdirs_v[i][path_len])) {
-        return TRUE;
+        return true;
       }
     } else {
       if (FNAMECMP(stopdirs_v[i], path) == 0) {
@@ -1307,13 +1307,13 @@ static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
       }
     }
   }
-  return FALSE;
+  return false;
 }
 
 /// Find the file name "ptr[len]" in the path.  Also finds directory names.
 ///
-/// On the first call set the parameter 'first' to TRUE to initialize
-/// the search.  For repeating calls to FALSE.
+/// On the first call set the parameter 'first' to true to initialize
+/// the search.  For repeating calls to false.
 ///
 /// Repeating calls will return other files called 'ptr[len]' from the path.
 ///
@@ -1374,7 +1374,7 @@ void free_findfile(void)
 /// @return  an allocated string for the file name.  NULL for error.
 char_u *find_directory_in_path(char_u *ptr, size_t len, int options, char_u *rel_fname)
 {
-  return find_file_in_path_option(ptr, len, options, TRUE, p_cdpath,
+  return find_file_in_path_option(ptr, len, options, true, p_cdpath,
                                   FINDFILE_DIR, rel_fname, (char_u *)"");
 }
 
@@ -1445,7 +1445,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
      * If this is not a first call, return NULL.  We already returned a
      * filename on the first call.
      */
-    if (first == TRUE) {
+    if (first == true) {
       if (path_with_url((char *)ff_file_to_find)) {
         file_name = vim_strsave(ff_file_to_find);
         goto theend;
@@ -1494,7 +1494,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
      * When "first" is set, first setup to the start of the option.
      * Otherwise continue to find the next match.
      */
-    if (first == TRUE) {
+    if (first == true) {
       // vim_findfile_free_visited can handle a possible NULL pointer
       vim_findfile_free_visited(fdip_search_ctx);
       dir = (char *)path_option;
@@ -1508,7 +1508,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
           break;
         }
 
-        did_findfile_init = FALSE;
+        did_findfile_init = false;
       } else {
         char_u *r_ptr;
 
@@ -1532,14 +1532,14 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
                                             r_ptr, 100, false, find_what,
                                             fdip_search_ctx, false, rel_fname);
         if (fdip_search_ctx != NULL) {
-          did_findfile_init = TRUE;
+          did_findfile_init = true;
         }
         xfree(buf);
       }
     }
   }
   if (file_name == NULL && (options & FNAME_MESS)) {
-    if (first == TRUE) {
+    if (first == true) {
       if (find_what == FINDFILE_DIR) {
         semsg(_("E344: Can't find directory \"%s\" in cdpath"),
               ff_file_to_find);
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index cc592c2430..206ef7c98d 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -134,7 +134,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   // calling filemess().
   msg_scroll_save = msg_scroll;
   if (shortmess(SHM_OVERALL) && !exiting && p_verbose == 0) {
-    msg_scroll = FALSE;
+    msg_scroll = false;
   }
   if (!msg_scroll) {    // wait a bit when overwriting an error msg
     check_for_delay(false);
@@ -143,7 +143,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   msg_scroll = msg_scroll_save;
   msg_scrolled_ign = true;
   // may truncate the message to avoid a hit-return prompt
-  msg_outtrans_attr(msg_may_trunc(FALSE, IObuff), attr);
+  msg_outtrans_attr(msg_may_trunc(false, IObuff), attr);
   msg_clr_eos();
   ui_flush();
   msg_scrolled_ign = false;
@@ -337,9 +337,9 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
   }
 
   if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0) {
-    msg_scroll = FALSE;         // overwrite previous file message
+    msg_scroll = false;         // overwrite previous file message
   } else {
-    msg_scroll = TRUE;          // don't overwrite previous file message
+    msg_scroll = true;          // don't overwrite previous file message
   }
   // If the name is too long we might crash further on, quit here.
   if (fname != NULL && *fname != NUL) {
@@ -402,7 +402,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
    */
   check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
   if (check_readonly && !readonlymode) {
-    curbuf->b_p_ro = FALSE;
+    curbuf->b_p_ro = false;
   }
 
   if (newfile && !read_stdin && !read_buffer && !read_fifo) {
@@ -518,18 +518,18 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
    * loaded.    Help files always get readonly mode
    */
   if ((check_readonly && file_readonly) || curbuf->b_help) {
-    curbuf->b_p_ro = TRUE;
+    curbuf->b_p_ro = true;
   }
 
   if (set_options) {
     // Don't change 'eol' if reading from buffer as it will already be
     // correctly set when reading stdin.
     if (!read_buffer) {
-      curbuf->b_p_eol = TRUE;
-      curbuf->b_start_eol = TRUE;
+      curbuf->b_p_eol = true;
+      curbuf->b_start_eol = true;
     }
-    curbuf->b_p_bomb = FALSE;
-    curbuf->b_start_bomb = FALSE;
+    curbuf->b_p_bomb = false;
+    curbuf->b_start_bomb = false;
   }
 
   // Create a swap file now, so that other Vims are warned that we are
@@ -635,7 +635,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     if (aborting()) {       // autocmds may abort script processing
       no_wait_return--;
       msg_scroll = msg_save;
-      curbuf->b_p_ro = TRUE;            // must use "w!" now
+      curbuf->b_p_ro = true;            // must use "w!" now
       return FAIL;
     }
     /*
@@ -656,7 +656,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
       } else {
         emsg(_("E201: *ReadPre autocommands must not change current buffer"));
       }
-      curbuf->b_p_ro = TRUE;            // must use "w!" now
+      curbuf->b_p_ro = true;            // must use "w!" now
       return FAIL;
     }
   }
@@ -670,7 +670,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     }
   }
 
-  msg_scroll = FALSE;                   // overwrite the file message
+  msg_scroll = false;                   // overwrite the file message
 
   /*
    * Set linecnt now, before the "retry" caused by a wrong guess for
@@ -751,8 +751,8 @@ retry:
     }
     file_rewind = false;
     if (set_options) {
-      curbuf->b_p_bomb = FALSE;
-      curbuf->b_start_bomb = FALSE;
+      curbuf->b_p_bomb = false;
+      curbuf->b_start_bomb = false;
     }
     conv_error = 0;
   }
@@ -766,7 +766,7 @@ retry:
   } else {
     if (eap != NULL && eap->force_ff != 0) {
       fileformat = get_fileformat_force(curbuf, eap);
-      try_unix = try_dos = try_mac = FALSE;
+      try_unix = try_dos = try_mac = false;
     } else if (curbuf->b_p_bin) {
       fileformat = EOL_UNIX;                    // binary: use Unix format
     } else if (*p_ffs ==
@@ -892,7 +892,7 @@ retry:
   }
 
   // Set "can_retry" when it's possible to rewind the file and try with
-  // another "fenc" value.  It's FALSE when no other "fenc" to try, reading
+  // another "fenc" value.  It's false when no other "fenc" to try, reading
   // stdin or fixed at a specific encoding.
   can_retry = (*fenc != NUL && !read_stdin && !keep_dest_enc && !read_fifo);
 
@@ -1138,8 +1138,8 @@ retry:
           size -= blen;
           memmove(ptr, ptr + blen, (size_t)size);
           if (set_options) {
-            curbuf->b_p_bomb = TRUE;
-            curbuf->b_start_bomb = TRUE;
+            curbuf->b_p_bomb = true;
+            curbuf->b_start_bomb = true;
           }
         }
 
@@ -1672,7 +1672,7 @@ failed:
            && ptr == line_start + 1)) {
     // remember for when writing
     if (set_options) {
-      curbuf->b_p_eol = FALSE;
+      curbuf->b_p_eol = false;
     }
     *ptr = NUL;
     len = (colnr_T)(ptr - line_start + 1);
@@ -1773,7 +1773,7 @@ failed:
       if (!(flags & READ_DUMMY)) {
         filemess(curbuf, (char_u *)sfname, (char_u *)_(e_interr), 0);
         if (newfile) {
-          curbuf->b_p_ro = TRUE;                // must use "w!" now
+          curbuf->b_p_ro = true;                // must use "w!" now
         }
       }
       msg_scroll = msg_save;
@@ -1788,30 +1788,30 @@ failed:
 #ifdef UNIX
       if (S_ISFIFO(perm)) {             // fifo
         STRCAT(IObuff, _("[fifo]"));
-        c = TRUE;
+        c = true;
       }
       if (S_ISSOCK(perm)) {            // or socket
         STRCAT(IObuff, _("[socket]"));
-        c = TRUE;
+        c = true;
       }
 # ifdef OPEN_CHR_FILES
       if (S_ISCHR(perm)) {                          // or character special
         STRCAT(IObuff, _("[character special]"));
-        c = TRUE;
+        c = true;
       }
 # endif
 #endif
       if (curbuf->b_p_ro) {
         STRCAT(IObuff, shortmess(SHM_RO) ? _("[RO]") : _("[readonly]"));
-        c = TRUE;
+        c = true;
       }
       if (read_no_eol_lnum) {
         msg_add_eol();
-        c = TRUE;
+        c = true;
       }
       if (ff_error == EOL_DOS) {
         STRCAT(IObuff, _("[CR missing]"));
-        c = TRUE;
+        c = true;
       }
       if (split) {
         STRCAT(IObuff, _("[long lines split]"));
@@ -1819,25 +1819,25 @@ failed:
       }
       if (notconverted) {
         STRCAT(IObuff, _("[NOT converted]"));
-        c = TRUE;
+        c = true;
       } else if (converted) {
         STRCAT(IObuff, _("[converted]"));
-        c = TRUE;
+        c = true;
       }
       if (conv_error != 0) {
         sprintf((char *)IObuff + STRLEN(IObuff),
                 _("[CONVERSION ERROR in line %" PRId64 "]"), (int64_t)conv_error);
-        c = TRUE;
+        c = true;
       } else if (illegal_byte > 0) {
         sprintf((char *)IObuff + STRLEN(IObuff),
                 _("[ILLEGAL BYTE in line %" PRId64 "]"), (int64_t)illegal_byte);
-        c = TRUE;
+        c = true;
       } else if (error) {
         STRCAT(IObuff, _("[READ ERRORS]"));
-        c = TRUE;
+        c = true;
       }
       if (msg_add_fileformat(fileformat)) {
-        c = TRUE;
+        c = true;
       }
 
       msg_add_lines(c, (long)linecnt, filesize);
@@ -1865,9 +1865,8 @@ failed:
     // with errors writing the file requires ":w!"
     if (newfile && (error
                     || conv_error != 0
-                    || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP)
-                    )) {
-      curbuf->b_p_ro = TRUE;
+                    || (illegal_byte > 0 && bad_char_behavior != BAD_KEEP))) {
+      curbuf->b_p_ro = true;
     }
 
     u_clearline();          // cannot use "U" command after adding lines
@@ -2021,8 +2020,8 @@ void prep_exarg(exarg_T *eap, const buf_T *buf)
   eap->force_ff = *buf->b_p_ff;
 
   eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
-  eap->read_edit = FALSE;
-  eap->forceit = FALSE;
+  eap->read_edit = false;
+  eap->forceit = false;
 }
 
 /// Set default or forced 'fileformat' and 'binary'.
@@ -2161,9 +2160,9 @@ char *new_file_message(void)
 ///
 /// If "forceit" is true, we don't care for errors when attempting backups.
 /// In case of an error everything possible is done to restore the original
-/// file.  But when "forceit" is TRUE, we risk losing it.
+/// file.  But when "forceit" is true, we risk losing it.
 ///
-/// When "reset_changed" is TRUE and "append" == FALSE and "start" == 1 and
+/// When "reset_changed" is true and "append" == false and "start" == 1 and
 /// "end" == curbuf->b_ml.ml_line_count, reset curbuf->b_changed.
 ///
 /// This function must NOT use NameBuff (because it's called by autowrite()).
@@ -2204,9 +2203,9 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   int bufsize;
   long perm;                                // file permissions
   int retval = OK;
-  int newfile = false;                      // TRUE if file doesn't exist yet
+  int newfile = false;                      // true if file doesn't exist yet
   int msg_save = msg_scroll;
-  int overwriting;                          // TRUE if writing over original
+  int overwriting;                          // true if writing over original
   int no_eol = false;                       // no end-of-line written
   int device = false;                       // writing to a device
   int prev_got_int = got_int;
@@ -2215,7 +2214,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   static char *err_readonly =
     "is read-only (cannot override: \"W\" in 'cpoptions')";
 #if defined(UNIX)
-  int made_writable = FALSE;                // 'w' bit has been set
+  int made_writable = false;                // 'w' bit has been set
 #endif
   // writing everything
   int whole = (start == 1 && end == buf->b_ml.ml_line_count);
@@ -2234,7 +2233,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   vim_acl_T acl = NULL;                 /* ACL copied from original file to
                                            backup or new file */
 #endif
-  int write_undo_file = FALSE;
+  int write_undo_file = false;
   context_sha256_T sha_ctx;
   unsigned int bkc = get_bkc_value(buf);
   const pos_T orig_start = buf->b_op_start;
@@ -2266,7 +2265,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
   // must init bw_conv_buf and bw_iconv_fd before jumping to "fail"
   write_info.bw_conv_buf = NULL;
-  write_info.bw_conv_error = FALSE;
+  write_info.bw_conv_error = false;
   write_info.bw_conv_error_lnum = 0;
   write_info.bw_restlen = 0;
 #ifdef HAVE_ICONV
@@ -2314,7 +2313,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   if (buf->b_ffname != NULL && FNAMECMP(ffname, buf->b_ffname) == 0) {
     overwriting = true;
   } else {
-    overwriting = FALSE;
+    overwriting = false;
   }
 
   no_wait_return++;                 // don't wait for return yet
@@ -2329,12 +2328,12 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
   {
     aco_save_T aco;
-    int buf_ffname = FALSE;
-    int buf_sfname = FALSE;
-    int buf_fname_f = FALSE;
-    int buf_fname_s = FALSE;
-    int did_cmd = FALSE;
-    int nofile_err = FALSE;
+    int buf_ffname = false;
+    int buf_sfname = false;
+    int buf_fname_f = false;
+    int buf_fname_s = false;
+    int did_cmd = false;
+    int nofile_err = false;
     int empty_memline = (buf->b_ml.ml_mfp == NULL);
     bufref_T bufref;
 
@@ -2512,9 +2511,9 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   }
 
   if (shortmess(SHM_OVER) && !exiting) {
-    msg_scroll = FALSE;             // overwrite previous file message
+    msg_scroll = false;             // overwrite previous file message
   } else {
-    msg_scroll = TRUE;              // don't overwrite previous file message
+    msg_scroll = true;              // don't overwrite previous file message
   }
   if (!filtering) {
     filemess(buf,
@@ -2525,7 +2524,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 #endif
              (char_u *)"", 0);               // show that we are busy
   }
-  msg_scroll = FALSE;               // always overwrite the file message now
+  msg_scroll = false;               // always overwrite the file message now
 
   buffer = verbose_try_malloc(BUFSIZE);
   // can't allocate big buffer, use small one (to be able to write when out of
@@ -2558,8 +2557,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       }
       /* It's a device of some kind (or a fifo) which we can write to
        * but for which we can't make a backup. */
-      device = TRUE;
-      newfile = TRUE;
+      device = true;
+      newfile = true;
       perm = -1;
     }
   }
@@ -2571,8 +2570,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     goto fail;
   }
   if (c == NODE_WRITABLE) {
-    device = TRUE;
-    newfile = TRUE;
+    device = true;
+    newfile = true;
     perm = -1;
   } else {
     perm = os_getperm((const char *)fname);
@@ -2638,7 +2637,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
    * abort it.
    */
   prev_got_int = got_int;
-  got_int = FALSE;
+  got_int = false;
 
   // Mark the buffer as 'being saved' to prevent changed buffer warnings
   buf->b_saving = true;
@@ -2656,7 +2655,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     const bool no_prepend_dot = false;
 
     if ((bkc & BKC_YES) || append) {       // "yes"
-      backup_copy = TRUE;
+      backup_copy = true;
     } else if ((bkc & BKC_AUTO)) {          // "auto"
       int i;
 
@@ -2669,7 +2668,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       if (os_fileinfo_hardlinks(&file_info_old) > 1
           || !os_fileinfo_link(fname, &file_info)
           || !os_fileinfo_id_equal(&file_info, &file_info_old)) {
-        backup_copy = TRUE;
+        backup_copy = true;
       } else {
         /*
          * Check if we can create a file and set the owner/group to
@@ -2689,7 +2688,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
         fd = os_open((char *)IObuff,
                      O_CREAT|O_WRONLY|O_EXCL|O_NOFOLLOW, (int)perm);
         if (fd < 0) {           // can't write in directory
-          backup_copy = TRUE;
+          backup_copy = true;
         } else {
 #ifdef UNIX
           os_fchown(fd, (uv_uid_t)file_info_old.stat.st_uid, (uv_gid_t)file_info_old.stat.st_gid);
@@ -2697,7 +2696,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
               || file_info.stat.st_uid != file_info_old.stat.st_uid
               || file_info.stat.st_gid != file_info_old.stat.st_gid
               || (long)file_info.stat.st_mode != perm) {
-            backup_copy = TRUE;
+            backup_copy = true;
           }
 #endif
           /* Close the file before removing it, on MS-Windows we
@@ -2719,7 +2718,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       if ((bkc & BKC_BREAKSYMLINK)
           && file_info_link_ok
           && !os_fileinfo_id_equal(&file_info, &file_info_old)) {
-        backup_copy = FALSE;
+        backup_copy = false;
       }
 
       // Hardlinks.
@@ -2727,7 +2726,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
           && os_fileinfo_hardlinks(&file_info_old) > 1
           && (!file_info_link_ok
               || os_fileinfo_id_equal(&file_info, &file_info_old))) {
-        backup_copy = FALSE;
+        backup_copy = false;
       }
 #endif
     }
@@ -2789,7 +2788,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
         rootname = (char *)get_file_in_dir((char_u *)fname, IObuff);
         if (rootname == NULL) {
-          some_error = TRUE;                // out of memory
+          some_error = true;                // out of memory
           goto nobackup;
         }
 
@@ -2804,7 +2803,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
           if (backup == NULL) {
             xfree(rootname);
-            some_error = TRUE;                          // out of memory
+            some_error = true;                          // out of memory
             goto nobackup;
           }
 
@@ -2889,7 +2888,7 @@ nobackup:
       if (backup == NULL && errmsg == NULL) {
         SET_ERRMSG(_("E509: Cannot create backup file (add ! to override)"));
       }
-      // Ignore errors when forceit is TRUE.
+      // Ignore errors when forceit is true.
       if ((some_error || errmsg != NULL) && !forceit) {
         retval = FAIL;
         goto fail;
@@ -3089,8 +3088,8 @@ nobackup:
       if (!write_info.bw_conv_buf) {
         end = 0;
       }
-      write_info.bw_first = TRUE;
-    } else
+      write_info.bw_first = true;
+    } else {
 #endif
 
     /*
@@ -3106,6 +3105,11 @@ nobackup:
       }
     }
   }
+
+#ifdef HAVE_ICONV
+}
+#endif
+
   if (converted && wb_flags == 0
 #ifdef HAVE_ICONV
       && write_info.bw_iconv_fd == (iconv_t)-1
@@ -3115,7 +3119,7 @@ nobackup:
       SET_ERRMSG(_("E213: Cannot convert (add ! to write without conversion)"));
       goto restore_backup;
     }
-    notconverted = TRUE;
+    notconverted = true;
   }
 
   // If conversion is taking place, we may first pretend to write and check
@@ -3137,12 +3141,12 @@ nobackup:
     } else {
       // Open the file "wfname" for writing.
       // We may try to open the file twice: If we can't write to the file
-      // and forceit is TRUE we delete the existing file and try to
+      // and forceit is true we delete the existing file and try to
       // create a new one. If this still fails we may have lost the
       // original file!  (this may happen when the user reached his
       // quotum for number of files).
       // Appending will fail if the file does not exist and forceit is
-      // FALSE.
+      // false.
       while ((fd = os_open(wfname,
                            O_WRONLY |
                            (append ?
@@ -3366,7 +3370,7 @@ restore_backup:
     // been written to disk and we don't lose it.
     // For a device do try the fsync() but don't complain if it does not work
     // (could be a pipe).
-    // If the 'fsync' option is FALSE, don't fsync().  Useful for laptops.
+    // If the 'fsync' option is false, don't fsync().  Useful for laptops.
     int error;
     if (p_fs && (error = os_fsync(fd)) != 0 && !device
         // fsync not supported on this storage.
@@ -3495,32 +3499,32 @@ restore_backup:
     c = false;
     if (write_info.bw_conv_error) {
       STRCAT(IObuff, _(" CONVERSION ERROR"));
-      c = TRUE;
+      c = true;
       if (write_info.bw_conv_error_lnum != 0) {
         vim_snprintf_add((char *)IObuff, IOSIZE, _(" in line %" PRId64 ";"),
                          (int64_t)write_info.bw_conv_error_lnum);
       }
     } else if (notconverted) {
       STRCAT(IObuff, _("[NOT converted]"));
-      c = TRUE;
+      c = true;
     } else if (converted) {
       STRCAT(IObuff, _("[converted]"));
-      c = TRUE;
+      c = true;
     }
     if (device) {
       STRCAT(IObuff, _("[Device]"));
-      c = TRUE;
+      c = true;
     } else if (newfile) {
       STRCAT(IObuff, new_file_message());
       c = true;
     }
     if (no_eol) {
       msg_add_eol();
-      c = TRUE;
+      c = true;
     }
     // may add [unix/dos/mac]
     if (msg_add_fileformat(fileformat)) {
-      c = TRUE;
+      c = true;
     }
     msg_add_lines(c, (long)lnum, nchars);       // add line/char count
     if (!shortmess(SHM_WRITE)) {
@@ -3711,23 +3715,23 @@ nofail:
 
     if (append) {
       apply_autocmds_exarg(EVENT_FILEAPPENDPOST, fname, fname,
-                           FALSE, curbuf, eap);
+                           false, curbuf, eap);
     } else if (filtering) {
       apply_autocmds_exarg(EVENT_FILTERWRITEPOST, NULL, fname,
-                           FALSE, curbuf, eap);
+                           false, curbuf, eap);
     } else if (reset_changed && whole) {
       apply_autocmds_exarg(EVENT_BUFWRITEPOST, fname, fname,
-                           FALSE, curbuf, eap);
+                           false, curbuf, eap);
     } else {
       apply_autocmds_exarg(EVENT_FILEWRITEPOST, fname, fname,
-                           FALSE, curbuf, eap);
+                           false, curbuf, eap);
     }
 
     // restore curwin/curbuf and a few other things
     aucmd_restbuf(&aco);
 
     if (aborting()) {       // autocmds may abort script processing
-      retval = FALSE;
+      retval = false;
     }
   }
 
@@ -3994,7 +3998,7 @@ static int buf_write_bytes(struct bw_info *ip)
         }
 
         if (ucs2bytes(c, &p, flags) && !ip->bw_conv_error) {
-          ip->bw_conv_error = TRUE;
+          ip->bw_conv_error = true;
           ip->bw_conv_error_lnum = ip->bw_start_lnum;
         }
         if (c == NL) {
@@ -4049,7 +4053,7 @@ static int buf_write_bytes(struct bw_info *ip)
           to = (char *)ip->bw_conv_buf;
           tolen = save_len;
         }
-        ip->bw_first = FALSE;
+        ip->bw_first = false;
       }
 
       /*
@@ -4058,7 +4062,7 @@ static int buf_write_bytes(struct bw_info *ip)
       if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
            == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
           || fromlen > CONV_RESTLEN) {
-        ip->bw_conv_error = TRUE;
+        ip->bw_conv_error = true;
         return FAIL;
       }
 
@@ -4163,7 +4167,7 @@ static bool need_conversion(const char_u *fenc)
   int fenc_flags;
 
   if (*fenc == NUL || STRCMP(p_enc, fenc) == 0) {
-    same_encoding = TRUE;
+    same_encoding = true;
     fenc_flags = 0;
   } else {
     // Ignore difference between "ansi" and "latin1", "ucs-4" and
@@ -4296,10 +4300,10 @@ static int make_bom(char_u *buf, char_u *name)
 
 /// Shorten filename of a buffer.
 ///
-/// @param force  when TRUE: Use full path from now on for files currently being
+/// @param force  when true: Use full path from now on for files currently being
 ///               edited, both for file name and swap file name.  Try to shorten the file
 ///               names a bit, if safe to do so.
-///               when FALSE: Only try to shorten absolute file names.
+///               when false: Only try to shorten absolute file names.
 ///
 /// For buffers that have buftype "nofile" or "scratch": never change the file
 /// name.
@@ -4386,7 +4390,7 @@ char *modname(const char *fname, const char *ext, bool prepend_dot)
     }
     add_pathsep(retval);
     fnamelen = strlen(retval);
-    prepend_dot = FALSE;  // nothing to prepend a dot to
+    prepend_dot = false;  // nothing to prepend a dot to
   } else {
     fnamelen = strlen(fname);
     retval = xmalloc(fnamelen + extlen + 3);
@@ -4769,7 +4773,7 @@ int vim_rename(const char_u *from, const char_u *to)
   return 0;
 }
 
-static int already_warned = FALSE;
+static int already_warned = false;
 
 /// Check if any not hidden buffer has been changed.
 /// Postpone the check if there are characters in the stuff buffer, a global
@@ -4778,7 +4782,7 @@ static int already_warned = FALSE;
 ///
 /// @param focus  called for GUI focus event
 ///
-/// @return       TRUE if some message was written (screen should be redrawn and cursor positioned).
+/// @return       true if some message was written (screen should be redrawn and cursor positioned).
 int check_timestamps(int focus)
 {
   int didit = 0;
@@ -4786,15 +4790,15 @@ int check_timestamps(int focus)
   // Don't check timestamps while system() or another low-level function may
   // cause us to lose and gain focus.
   if (no_check_timestamps > 0) {
-    return FALSE;
+    return false;
   }
 
   // Avoid doing a check twice.  The OK/Reload dialog can cause a focus
   // event and we would keep on checking if the file is steadily growing.
   // Do check again after typing something.
   if (focus && did_check_timestamps) {
-    need_check_timestamps = TRUE;
-    return FALSE;
+    need_check_timestamps = true;
+    return false;
   }
 
   if (!stuff_empty() || global_busy || !typebuf_typed()
@@ -5075,7 +5079,7 @@ int buf_check_timestamp(buf_T *buf)
           redraw_cmdline = false;
         }
       }
-      already_warned = TRUE;
+      already_warned = true;
     }
 
     xfree(path);
@@ -5606,8 +5610,8 @@ bool match_file_list(char_u *list, char_u *sfname, char_u *ffname)
 
 /// Convert the given pattern "pat" which has shell style wildcards in it, into
 /// a regular expression, and return the result in allocated memory.  If there
-/// is a directory path separator to be matched, then TRUE is put in
-/// allow_dirs, otherwise FALSE is put there -- webb.
+/// is a directory path separator to be matched, then true is put in
+/// allow_dirs, otherwise false is put there -- webb.
 /// Handle backslashes before special characters, like "\*" and "\ ".
 ///
 /// @param pat_end     first char after pattern or NULL
@@ -5625,7 +5629,7 @@ char *file_pat_to_reg_pat(const char *pat, const char *pat_end, char *allow_dirs
   bool add_dollar = true;
 
   if (allow_dirs != NULL) {
-    *allow_dirs = FALSE;
+    *allow_dirs = false;
   }
   if (pat_end == NULL) {
     pat_end = pat + STRLEN(pat);
@@ -5711,7 +5715,7 @@ char *file_pat_to_reg_pat(const char *pat, const char *pat_end, char *allow_dirs
           reg_pat[i++] = '/';
           reg_pat[i++] = ']';
           if (allow_dirs != NULL) {
-            *allow_dirs = TRUE;
+            *allow_dirs = true;
           }
           break;
         }
@@ -5745,7 +5749,7 @@ char *file_pat_to_reg_pat(const char *pat, const char *pat_end, char *allow_dirs
             && (!no_bslash || *p != '\\')
 #endif
             ) {
-          *allow_dirs = TRUE;
+          *allow_dirs = true;
         }
         reg_pat[i++] = '\\';
         reg_pat[i++] = *p;
@@ -5758,7 +5762,7 @@ char *file_pat_to_reg_pat(const char *pat, const char *pat_end, char *allow_dirs
       reg_pat[i++] = '/';
       reg_pat[i++] = ']';
       if (allow_dirs != NULL) {
-        *allow_dirs = TRUE;
+        *allow_dirs = true;
       }
       break;
 #endif
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index e858b9244b..f5f09f1394 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -81,11 +81,9 @@ static buffheader_T readbuf2 = { { NULL, { NUL } }, NULL, 0, 0 };
 
 static int typeahead_char = 0;          // typeahead char that's not flushed
 
-/*
- * when block_redo is TRUE redo buffer will not be changed
- * used by edit() to repeat insertions and 'V' command for redoing
- */
-static int block_redo = FALSE;
+// when block_redo is true redo buffer will not be changed
+// used by edit() to repeat insertions and 'V' command for redoing
+static int block_redo = false;
 
 static int KeyNoremap = 0;                  // remapping flags
 
@@ -179,7 +177,7 @@ char_u *get_recorded(void)
   char_u *p;
   size_t len;
 
-  p = get_buffcont(&recordbuff, TRUE);
+  p = get_buffcont(&recordbuff, true);
   free_buff(&recordbuff);
 
   /*
@@ -207,7 +205,7 @@ char_u *get_recorded(void)
 /// K_SPECIAL in the returned string is escaped.
 char_u *get_inserted(void)
 {
-  return get_buffcont(&redobuff, FALSE);
+  return get_buffcont(&redobuff, false);
 }
 
 /// Add string after the current block of the given buffer
@@ -319,7 +317,7 @@ static void add_char_buff(buffheader_T *buf, int c)
 
 /// Get one byte from the read buffers.  Use readbuf1 one first, use readbuf2
 /// if that one is empty.
-/// If advance == TRUE go to the next char.
+/// If advance == true go to the next char.
 /// No translation is done K_SPECIAL is escaped.
 static int read_readbuffers(int advance)
 {
@@ -368,19 +366,15 @@ static void start_stuff(void)
   }
 }
 
-/*
- * Return TRUE if the stuff buffer is empty.
- */
+/// Return true if the stuff buffer is empty.
 int stuff_empty(void)
   FUNC_ATTR_PURE
 {
   return (readbuf1.bh_first.b_next == NULL && readbuf2.bh_first.b_next == NULL);
 }
 
-/*
- * Return TRUE if readbuf1 is empty.  There may still be redo characters in
- * redbuf2.
- */
+/// Return true if readbuf1 is empty.  There may still be redo characters in
+/// redbuf2.
 int readbuf1_empty(void)
   FUNC_ATTR_PURE
 {
@@ -793,7 +787,7 @@ int start_redo_ins(void)
 
 void stop_redo_ins(void)
 {
-  block_redo = FALSE;
+  block_redo = false;
 }
 
 /*
@@ -970,7 +964,7 @@ int ins_char_typebuf(int c, int modifiers)
   return (int)len;
 }
 
-/// Return TRUE if the typeahead buffer was changed (while waiting for a
+/// Return true if the typeahead buffer was changed (while waiting for a
 /// character to arrive).  Happens when a message was received from a client or
 /// from feedkeys().
 /// But check in a more generic way to avoid trouble: When "typebuf.tb_buf"
@@ -986,10 +980,8 @@ bool typebuf_changed(int tb_change_cnt)
                                 || typebuf_was_filled);
 }
 
-/*
- * Return TRUE if there are no characters in the typeahead buffer that have
- * not been typed (result from a mapping or come from ":normal").
- */
+/// Return true if there are no characters in the typeahead buffer that have
+/// not been typed (result from a mapping or come from ":normal").
 int typebuf_typed(void)
   FUNC_ATTR_PURE
 {
@@ -1353,9 +1345,7 @@ void close_all_scripts(void)
 
 #endif
 
-/*
- * Return TRUE when reading keys from a script file.
- */
+/// Return true when reading keys from a script file.
 int using_script(void)
   FUNC_ATTR_PURE
 {
@@ -1686,7 +1676,7 @@ int vpeekc_any(void)
 
 /*
  * Call vpeekc() without causing anything to be mapped.
- * Return TRUE if a character is available, FALSE otherwise.
+ * Return true if a character is available, false otherwise.
  */
 int char_avail(void)
 {
@@ -2363,8 +2353,8 @@ void check_end_reg_executing(bool advance)
 ///
 /// if "advance" is true (vgetc()):
 ///    Really get the character.
-///    KeyTyped is set to TRUE in the case the user typed the key.
-///    KeyStuffed is TRUE if the character comes from the stuff buffer.
+///    KeyTyped is set to true in the case the user typed the key.
+///    KeyStuffed is true if the character comes from the stuff buffer.
 /// if "advance" is false (vpeekc()):
 ///    Just look whether there is a character available.
 ///    Return NUL if not.
@@ -2451,7 +2441,7 @@ static int vgetorpeek(bool advance)
           // flush all input
           c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0L);
 
-          // 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.
           // Otherwise we behave like having gotten a CTRL-C.
           // As a result typing CTRL-C in insert mode will
@@ -2865,7 +2855,7 @@ int inchar(char_u *buf, int maxlen, long wait_time)
 
   if (read_size <= 0) {  // Did not get a character from script.
     // If we got an interrupt, skip all previously typed characters and
-    // return TRUE if quit reading script file.
+    // return true if quit reading script file.
     // Stop reading typeahead when a single CTRL-C was read,
     // fill_input_buf() returns this when not able to read from stdin.
     // Don't use buf[] here, closescript() may have freed typebuf.tb_buf[]
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index f95ef3e705..c805c238c6 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -475,9 +475,9 @@ static int grid_char_needs_redraw(ScreenGrid *grid, size_t off_from, size_t off_
 /// "endcol" gives the columns where valid characters are.
 /// "clear_width" is the width of the window.  It's > 0 if the rest of the line
 /// needs to be cleared, negative otherwise.
-/// "rlflag" is TRUE in a rightleft window:
-///    When TRUE and "clear_width" > 0, clear columns 0 to "endcol"
-///    When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width"
+/// "rlflag" is true in a rightleft window:
+///    When true and "clear_width" > 0, clear columns 0 to "endcol"
+///    When false and "clear_width" > 0, clear columns "endcol" to "clear_width"
 /// If "wrap" is true, then hint to the UI that "row" contains a line
 /// which has wrapped into the next row.
 void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int clear_width,
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 6f45b4a03d..7d261b751c 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -51,20 +51,20 @@
  *
  * int mch_print_begin(prt_settings_T *settings)
  * Called to start the print job.
- * Return FALSE to abort.
+ * Return false to abort.
  *
  * int mch_print_begin_page(char_u *msg)
  * Called at the start of each page.
  * "msg" indicates the progress of the print job, can be NULL.
- * Return FALSE to abort.
+ * Return false to abort.
  *
  * int mch_print_end_page()
  * Called at the end of each page.
- * Return FALSE to abort.
+ * Return false to abort.
  *
  * int mch_print_blank_page()
  * Called to generate a blank page for collated, duplex, multiple copy
- * document.  Return FALSE to abort.
+ * document.  Return false to abort.
  *
  * void mch_print_end(prt_settings_T *psettings)
  * Called at normal end of print job.
@@ -87,36 +87,33 @@
  *
  * mch_print_start_line(int margin, int page_line)
  * Sets the current position at the start of line "page_line".
- * If margin is TRUE start in the left margin (for header and line number).
+ * If margin is true start in the left margin (for header and line number).
  *
  * int mch_print_text_out(char_u *p, size_t len);
  * Output one character of text p[len] at the current position.
- * Return TRUE if there is no room for another character in the same line.
+ * Return true if there is no room for another character in the same line.
  *
  * Note that the generic code has no idea of margins. The machine code should
  * simply make the page look smaller!  The header and the line numbers are
  * printed in the margin.
  */
 
-static option_table_T printer_opts[OPT_PRINT_NUM_OPTIONS]
-  =
-  {
-  { "top",     TRUE, 0, NULL, 0, FALSE },
-  { "bottom",  TRUE, 0, NULL, 0, FALSE },
-  { "left",    TRUE, 0, NULL, 0, FALSE },
-  { "right",   TRUE, 0, NULL, 0, FALSE },
-  { "header",  TRUE, 0, NULL, 0, FALSE },
-  { "syntax",  FALSE, 0, NULL, 0, FALSE },
-  { "number",  FALSE, 0, NULL, 0, FALSE },
-  { "wrap",    FALSE, 0, NULL, 0, FALSE },
-  { "duplex",  FALSE, 0, NULL, 0, FALSE },
-  { "portrait", FALSE, 0, NULL, 0, FALSE },
-  { "paper",   FALSE, 0, NULL, 0, FALSE },
-  { "collate", FALSE, 0, NULL, 0, FALSE },
-  { "jobsplit", FALSE, 0, NULL, 0, FALSE },
-  { "formfeed", FALSE, 0, NULL, 0, FALSE },
-  }
-;
+static option_table_T printer_opts[OPT_PRINT_NUM_OPTIONS] = {
+  { "top",     true, 0, NULL, 0, false },
+  { "bottom",  true, 0, NULL, 0, false },
+  { "left",    true, 0, NULL, 0, false },
+  { "right",   true, 0, NULL, 0, false },
+  { "header",  true, 0, NULL, 0, false },
+  { "syntax",  false, 0, NULL, 0, false },
+  { "number",  false, 0, NULL, 0, false },
+  { "wrap",    false, 0, NULL, 0, false },
+  { "duplex",  false, 0, NULL, 0, false },
+  { "portrait", false, 0, NULL, 0, false },
+  { "paper",   false, 0, NULL, 0, false },
+  { "collate", false, 0, NULL, 0, false },
+  { "jobsplit", false, 0, NULL, 0, false },
+  { "formfeed", false, 0, NULL, 0, false },
+};
 
 static const uint32_t cterm_color_8[8] = {
   0x000000, 0xff0000, 0x00ff00, 0xffff00,
@@ -152,12 +149,12 @@ static int page_count;
 
 static option_table_T mbfont_opts[OPT_MBFONT_NUM_OPTIONS] =
 {
-  { "c",       FALSE, 0, NULL, 0, FALSE },
-  { "a",       FALSE, 0, NULL, 0, FALSE },
-  { "r",       FALSE, 0, NULL, 0, FALSE },
-  { "b",       FALSE, 0, NULL, 0, FALSE },
-  { "i",       FALSE, 0, NULL, 0, FALSE },
-  { "o",       FALSE, 0, NULL, 0, FALSE },
+  { "c",       false, 0, NULL, 0, false },
+  { "a",       false, 0, NULL, 0, false },
+  { "r",       false, 0, NULL, 0, false },
+  { "b",       false, 0, NULL, 0, false },
+  { "i",       false, 0, NULL, 0, false },
+  { "o",       false, 0, NULL, 0, false },
 };
 
 /*
@@ -506,9 +503,7 @@ int prt_header_height(void)
   return 2;
 }
 
-/*
- * Return TRUE if using a line number for printing.
- */
+// Return true if using a line number for printing.
 int prt_use_number(void)
 {
   return printer_opts[OPT_PRINT_NUMBER].present
@@ -552,7 +547,7 @@ static void prt_header(prt_settings_T *const psettings, const int pagenum, const
 
   if (*p_header != NUL) {
     linenr_T tmp_lnum, tmp_topline, tmp_botline;
-    int use_sandbox = FALSE;
+    int use_sandbox = false;
 
     /*
      * Need to (temporarily) set current line number and first/last line
@@ -669,7 +664,7 @@ void ex_hardcopy(exarg_T *eap)
   settings.modec = 'c';
 
   if (!syntax_present(curwin)) {
-    settings.do_syntax = FALSE;
+    settings.do_syntax = false;
   } else if (printer_opts[OPT_PRINT_SYNTAX].present
              && TOLOWER_ASC(printer_opts[OPT_PRINT_SYNTAX].string[0]) != 'a') {
     settings.do_syntax =
@@ -866,7 +861,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
 {
   colnr_T col;
   char_u *line;
-  int need_break = FALSE;
+  int need_break = false;
   int outputlen;
   int tab_spaces;
   int print_pos;
@@ -879,7 +874,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
     if (!ppos->ff && prt_use_number()) {
       prt_line_number(psettings, page_line, ppos->file_line);
     }
-    ppos->ff = FALSE;
+    ppos->ff = false;
   } else {
     // left over from wrap halfway through a tab
     print_pos = ppos->print_pos;
@@ -942,7 +937,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
                && printer_opts[OPT_PRINT_FORMFEED].present
                && TOLOWER_ASC(printer_opts[OPT_PRINT_FORMFEED].string[0])
                == 'y') {
-      ppos->ff = TRUE;
+      ppos->ff = true;
       need_break = 1;
     } else {
       need_break = mch_print_text_out(line + col, (size_t)outputlen);
@@ -1984,7 +1979,7 @@ void mch_print_cleanup(void)
 
   if (prt_do_conv) {
     convert_setup(&prt_conv, NULL, NULL);
-    prt_do_conv = FALSE;
+    prt_do_conv = false;
   }
   if (prt_ps_fd != NULL) {
     fclose(prt_ps_fd);
@@ -2116,11 +2111,11 @@ static int prt_match_encoding(char *p_encoding, struct prt_ps_mbfont_S *p_cmap,
   for (mbenc = 0; mbenc < p_cmap->num_encodings; mbenc++) {
     if (STRNICMP(p_mbenc->encoding, p_encoding, enc_len) == 0) {
       *pp_mbenc = p_mbenc;
-      return TRUE;
+      return true;
     }
     p_mbenc++;
   }
-  return FALSE;
+  return false;
 }
 
 static int prt_match_charset(char *p_charset, struct prt_ps_mbfont_S *p_cmap,
@@ -2139,11 +2134,11 @@ static int prt_match_charset(char *p_charset, struct prt_ps_mbfont_S *p_cmap,
   for (mbchar = 0; mbchar < p_cmap->num_charsets; mbchar++) {
     if (STRNICMP(p_mbchar->charset, p_charset, char_len) == 0) {
       *pp_mbchar = p_mbchar;
-      return TRUE;
+      return true;
     }
     p_mbchar++;
   }
-  return FALSE;
+  return false;
 }
 
 int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
@@ -2277,7 +2272,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
 
     prt_ps_font = &prt_ps_mb_font;
   } else {
-    prt_use_courier = FALSE;
+    prt_use_courier = false;
     prt_ps_font = &prt_ps_courier_font;
   }
 
@@ -2379,16 +2374,16 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
    * Set up printer duplex and tumble based on Duplex option setting - default
    * is long sided duplex printing (i.e. no tumble).
    */
-  prt_duplex = TRUE;
-  prt_tumble = FALSE;
+  prt_duplex = true;
+  prt_tumble = false;
   psettings->duplex = 1;
   if (printer_opts[OPT_PRINT_DUPLEX].present) {
     if (STRNICMP(printer_opts[OPT_PRINT_DUPLEX].string, "off", 3) == 0) {
-      prt_duplex = FALSE;
+      prt_duplex = false;
       psettings->duplex = 0;
     } else if (STRNICMP(printer_opts[OPT_PRINT_DUPLEX].string, "short", 5)
                == 0) {
-      prt_tumble = TRUE;
+      prt_tumble = true;
     }
   }
 
@@ -2941,7 +2936,7 @@ int mch_print_begin_page(char_u *str)
 
 int mch_print_blank_page(void)
 {
-  return mch_print_begin_page(NULL) ? (mch_print_end_page()) : FALSE;
+  return mch_print_begin_page(NULL) ? (mch_print_end_page()) : false;
 }
 
 static double prt_pos_x = 0;
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 30c39a3158..3d5c95002a 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -640,7 +640,7 @@ static int color_numbers_8[28] = { 0, 4, 2, 6,
 
 // Lookup the "cterm" value to be used for color with index "idx" in
 // color_names[].
-// "boldp" will be set to TRUE or FALSE for a foreground color when using 8
+// "boldp" will be set to kTrue or kFalse for a foreground color when using 8
 // colors, otherwise it will be unchanged.
 int lookup_color(const int idx, const bool foreground, TriState *const boldp)
 {
@@ -1321,7 +1321,7 @@ void restore_cterm_colors(void)
 
 /// @param check_link  if true also check for an existing link.
 ///
-/// @return TRUE if highlight group "idx" has any settings.
+/// @return true if highlight group "idx" has any settings.
 static int hl_has_settings(int idx, bool check_link)
 {
   return hl_table[idx].sg_cleared == 0
@@ -1701,7 +1701,7 @@ int syn_name2attr(const char_u *name)
   return 0;
 }
 
-/// Return TRUE if highlight group "name" exists.
+/// Return true if highlight group "name" exists.
 int highlight_exists(const char *name)
 {
   return syn_name2id(name) > 0;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 9d3b2b0455..e32b58fbcb 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -203,19 +203,19 @@ static void do_cscope_general(exarg_T *eap, int make_split)
 /// Implementation of ":cscope" and ":lcscope"
 void ex_cscope(exarg_T *eap)
 {
-  do_cscope_general(eap, FALSE);
+  do_cscope_general(eap, false);
 }
 
 /// Implementation of ":scscope". Same as ex_cscope(), but splits window, too.
 void ex_scscope(exarg_T *eap)
 {
-  do_cscope_general(eap, TRUE);
+  do_cscope_general(eap, true);
 }
 
 /// Implementation of ":cstag"
 void ex_cstag(exarg_T *eap)
 {
-  int ret = FALSE;
+  int ret = false;
 
   if (*eap->arg == NUL) {
     (void)emsg(_("E562: Usage: cstag <ident>"));
@@ -278,7 +278,7 @@ void ex_cstag(exarg_T *eap)
 /// This simulates a vim_fgets(), but for cscope, returns the next line
 /// from the cscope output.  should only be called from find_tags()
 ///
-/// @return true if eof, FALSE otherwise
+/// @return true if eof, false otherwise
 bool cs_fgets(char_u *buf, int size)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -839,7 +839,7 @@ err_closing:
     si.hStdOutput = stdout_wr;
     si.hStdError  = stdout_wr;
     si.hStdInput  = stdin_rd;
-    created = CreateProcess(NULL, cmd, NULL, NULL, TRUE, CREATE_NEW_CONSOLE,
+    created = CreateProcess(NULL, cmd, NULL, NULL, true, CREATE_NEW_CONSOLE,
                             NULL, NULL, &si, &pi);
     xfree(prog);
     xfree(cmd);
@@ -875,7 +875,7 @@ err_closing:
 /// Query cscope using command line interface.  Parse the output and use tselect
 /// to allow choices.  Like Nvi, creates a pipe to send to/from query/cscope.
 ///
-/// @return TRUE if we jump to a tag or abort, FALSE if not.
+/// @return true if we jump to a tag or abort, false if not.
 static int cs_find(exarg_T *eap)
 {
   char *opt, *pat;
@@ -1106,7 +1106,7 @@ static int cs_help(exarg_T *eap)
     cmdp++;
   }
 
-  wait_return(TRUE);
+  wait_return(true);
   return CSCOPE_SUCCESS;
 }
 
@@ -1280,7 +1280,7 @@ static void cs_kill_execute(size_t i, char *cname)
     (void)smsg_attr(HL_ATTR(HLF_R) | MSG_HIST,
                     _("cscope connection %s closed"), cname);
   }
-  cs_release_csp(i, TRUE);
+  cs_release_csp(i, true);
 }
 
 /// Convert the cscope output into a ctags style entry (as might be found
@@ -1932,7 +1932,7 @@ static int cs_reset(exarg_T *eap)
     pplist[i] = csinfo[i].ppath;
     fllist[i] = csinfo[i].flags;
     if (csinfo[i].fname != NULL) {
-      cs_release_csp(i, FALSE);
+      cs_release_csp(i, false);
     }
   }
 
@@ -2035,7 +2035,7 @@ static int cs_show(exarg_T *eap)
     }
   }
 
-  wait_return(TRUE);
+  wait_return(true);
   return CSCOPE_SUCCESS;
 }
 
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index df337125ca..128eea915d 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -275,10 +275,8 @@ static const char_u *cin_skipcomment(const char_u *s)
   return s;
 }
 
-/*
- * Return TRUE if there is no code at *s.  White space and comments are
- * not considered code.
- */
+/// Return true if there is no code at *s.  White space and comments are
+/// not considered code.
 static int cin_nocode(const char_u *s)
 {
   return *cin_skipcomment(s) == NUL;
@@ -403,7 +401,7 @@ bool cin_islabel(void)  // XXX
     }
 
     curwin->w_cursor = cursor_save;
-    if (cin_isterminated(line, TRUE, FALSE)
+    if (cin_isterminated(line, true, false)
         || cin_isscopedecl(line)
         || cin_iscase(line, true)
         || (cin_islabel_skip(&line) && cin_nocode(line))) {
@@ -455,7 +453,7 @@ static int cin_isinit(void)
     return true;
   }
 
-  return FALSE;
+  return false;
 }
 
 /// Recognize a switch label: "case .*:" or "default:".
@@ -769,10 +767,10 @@ static int cin_ispreproc(const char_u *s)
   if (*skipwhite((char *)s) == '#') {
     return true;
   }
-  return FALSE;
+  return false;
 }
 
-/// Return TRUE if line "*pp" at "*lnump" is a preprocessor statement or a
+/// Return true if line "*pp" at "*lnump" is a preprocessor statement or a
 /// continuation line of a preprocessor statement.  Decrease "*lnump" to the
 /// start and return the line in "*pp".
 /// Put the amount of indent in "*amount".
@@ -789,7 +787,7 @@ static int cin_ispreproc_cont(const char_u **pp, linenr_T *lnump, int *amount)
 
   for (;;) {
     if (cin_ispreproc(line)) {
-      retval = TRUE;
+      retval = true;
       *lnump = lnum;
       break;
     }
@@ -842,7 +840,7 @@ static char_u cin_isterminated(const char_u *s, int incl_open, int incl_comma)
 {
   char_u found_start = 0;
   unsigned n_open = 0;
-  int is_else = FALSE;
+  int is_else = false;
 
   s = cin_skipcomment(s);
 
@@ -1095,14 +1093,12 @@ probablyFound:
   return 0;
 }
 
-/*
- * Return TRUE if we are at the end of a do-while.
- *    do
- *       nothing;
- *    while (foo
- *             && bar);  <-- here
- * Adjust the cursor to the line with "while".
- */
+/// Return true if we are at the end of a do-while.
+///    do
+///       nothing;
+///    while (foo
+///             && bar);  <-- here
+/// Adjust the cursor to the line with "while".
 static int cin_iswhileofdo_end(int terminated)
 {
   const char_u *line;
@@ -1133,7 +1129,7 @@ static int cin_iswhileofdo_end(int terminated)
           }
           if (cin_starts_with(s, "while")) {
             curwin->w_cursor.lnum = trypos->lnum;
-            return TRUE;
+            return true;
           }
         }
 
@@ -1146,7 +1142,7 @@ static int cin_iswhileofdo_end(int terminated)
       p++;
     }
   }
-  return FALSE;
+  return false;
 }
 
 static int cin_isbreak(const char_u *p)
@@ -1190,7 +1186,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
     return false;
   }
 
-  cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
+  cpp_base_class = lookfor_ctor_init = class_or_struct = false;
 
   /* Search for a line starting with '#', empty, ending in ';' or containing
    * '{' or '}' and start below it.  This handles the following situations:
@@ -1256,7 +1252,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
       if (s[1] == ':') {
         /* skip double colon. It can't be a constructor
          * initialization any more */
-        lookfor_ctor_init = FALSE;
+        lookfor_ctor_init = false;
         s = cin_skipcomment(s + 2);
       } else if (lookfor_ctor_init || class_or_struct) {
         /* we have something found, that looks like the start of
@@ -1270,8 +1266,8 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
       }
     } else if ((STRNCMP(s, "class", 5) == 0 && !vim_isIDc(s[5]))
                || (STRNCMP(s, "struct", 6) == 0 && !vim_isIDc(s[6]))) {
-      class_or_struct = TRUE;
-      lookfor_ctor_init = FALSE;
+      class_or_struct = true;
+      lookfor_ctor_init = false;
 
       if (*s == 'c') {
         s = cin_skipcomment(s + 5);
@@ -1280,12 +1276,12 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
       }
     } else {
       if (s[0] == '{' || s[0] == '}' || s[0] == ';') {
-        cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
+        cpp_base_class = lookfor_ctor_init = class_or_struct = false;
       } else if (s[0] == ')') {
         /* Constructor-initialization is assumed if we come across
          * something like "):" */
-        class_or_struct = FALSE;
-        lookfor_ctor_init = TRUE;
+        class_or_struct = false;
+        lookfor_ctor_init = true;
       } else if (s[0] == '?') {
         // Avoid seeing '() :' after '?' as constructor init.
         return false;
@@ -1345,11 +1341,9 @@ static int get_baseclass_amount(int col)
   return amount;
 }
 
-/*
- * Return TRUE if string "s" ends with the string "find", possibly followed by
- * white space and comments.  Skip strings and comments.
- * Ignore "ignore" after "find" if it's not NULL.
- */
+/// Return true if string "s" ends with the string "find", possibly followed by
+/// white space and comments.  Skip strings and comments.
+/// Ignore "ignore" after "find" if it's not NULL.
 static int cin_ends_in(const char_u *s, const char_u *find, const char_u *ignore)
 {
   const char_u *p = s;
@@ -1371,12 +1365,10 @@ static int cin_ends_in(const char_u *s, const char_u *find, const char_u *ignore
       p++;
     }
   }
-  return FALSE;
+  return false;
 }
 
-/*
- * Return TRUE when "s" starts with "word" and then a non-ID character.
- */
+/// Return true when "s" starts with "word" and then a non-ID character.
 static int cin_starts_with(const char_u *s, const char *word)
 {
   int l = (int)STRLEN(word);
@@ -1573,7 +1565,7 @@ static int corr_ind_maxparen(pos_T *startpos)
 static int find_last_paren(const char_u *l, int start, int end)
 {
   int i;
-  int retval = FALSE;
+  int retval = false;
   int open_count = 0;
 
   curwin->w_cursor.col = 0;                 // default is start of line
@@ -1588,7 +1580,7 @@ static int find_last_paren(const char_u *l, int start, int end)
         open_count--;
       } else {
         curwin->w_cursor.col = i;
-        retval = TRUE;
+        retval = true;
       }
     }
   }
@@ -2055,7 +2047,7 @@ int get_c_indent(void)
     char *p;
     int start_align = 0;
     int start_off = 0;
-    int done = FALSE;
+    int done = false;
 
     // find how indented the line beginning the comment is
     getvcol(curwin, comment_pos, &col, NULL, NULL);
@@ -2098,7 +2090,7 @@ int get_c_indent(void)
          * up with the comment opener per the 'comments' option. */
         if (STRNCMP(theline, lead_middle, lead_middle_len) == 0
             && STRNCMP(theline, lead_end, STRLEN(lead_end)) != 0) {
-          done = TRUE;
+          done = true;
           if (curwin->w_cursor.lnum > 1) {
             /* If the start comment string matches in the previous
              * line, use the indent of that line plus offset.  If
@@ -2562,7 +2554,7 @@ int get_c_indent(void)
           }
         }
 
-        lookfor_break = FALSE;
+        lookfor_break = false;
 
         if (cin_iscase(theline, false)) {       // it's a switch() label
           lookfor = LOOKFOR_CASE;       // find a previous switch() label
@@ -2646,7 +2638,7 @@ int get_c_indent(void)
                 continue;
               }
 
-              terminated = cin_isterminated(l, FALSE, TRUE);
+              terminated = cin_isterminated(l, false, true);
 
               /*
                * If we are at top level and the line looks like a
@@ -2660,7 +2652,7 @@ int get_c_indent(void)
                  * don't add extra indent.
                  * TODO: does not work, if  a function
                  * declaration is split over multiple lines:
-                 * cin_isfuncdecl returns FALSE then.
+                 * cin_isfuncdecl returns false then.
                  */
                 if (terminated == ',') {
                   break;
@@ -2971,7 +2963,7 @@ int get_c_indent(void)
            * initialisation (not indented) or a variable declaration
            * (indented).
            */
-          terminated = cin_isterminated(l, FALSE, TRUE);
+          terminated = cin_isterminated(l, false, true);
 
           if (js_cur_has_key) {
             js_cur_has_key = false;  // only check the first line
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index a896a406d1..5601db274b 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -31,7 +31,7 @@
 /// @return `s, sizeof(s) - 1`
 #define S_LEN(s) (s), (sizeof(s) - 1)
 
-/// LINEEMPTY() - return TRUE if the line is empty
+/// LINEEMPTY() - return true if the line is empty
 #define LINEEMPTY(p) (*ml_get(p) == NUL)
 
 // toupper() and tolower() that use the current locale.
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 12c51e8a85..6fc70dec2d 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -508,7 +508,7 @@ int main(int argc, char **argv)
 
   // When started with "-q errorfile" jump to first error now.
   if (params.edit_type == EDIT_QF) {
-    qf_jump(NULL, 0, 0, FALSE);
+    qf_jump(NULL, 0, 0, false);
     TIME_MSG("jump to first error");
   }
 
@@ -520,7 +520,7 @@ int main(int argc, char **argv)
   if (params.diff_mode) {
     // set options in each window for "nvim -d".
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-      diff_win_options(wp, TRUE);
+      diff_win_options(wp, true);
     }
   }
 
@@ -713,8 +713,8 @@ void getout(int exitval)
 
   if (did_emsg) {
     // give the user a chance to read the (error) message
-    no_wait_return = FALSE;
-    wait_return(FALSE);
+    no_wait_return = false;
+    wait_return(false);
   }
 
   // Position the cursor again, the autocommands may have moved it
@@ -1638,7 +1638,7 @@ static void create_windows(mparm_T *parmp)
         }
         curwin = curwin->w_next;
       }
-      dorewind = FALSE;
+      dorewind = false;
       curbuf = curwin->w_buffer;
       if (curbuf->b_ml.ml_mfp == NULL) {
         // Set 'foldlevel' to 'foldlevelstart' if it's not negative..
@@ -1647,15 +1647,15 @@ static void create_windows(mparm_T *parmp)
         }
         // When getting the ATTENTION prompt here, use a dialog.
         swap_exists_action = SEA_DIALOG;
-        set_buflisted(TRUE);
+        set_buflisted(true);
 
         // create memfile, read file
-        (void)open_buffer(FALSE, NULL, 0);
+        (void)open_buffer(false, NULL, 0);
 
         if (swap_exists_action == SEA_QUIT) {
           if (got_int || only_one_window()) {
             // abort selected or quit and only one window
-            did_emsg = FALSE;               // avoid hit-enter prompt
+            did_emsg = false;               // avoid hit-enter prompt
             getout(1);
           }
           // We can't close the window, it would disturb what
@@ -1667,7 +1667,7 @@ static void create_windows(mparm_T *parmp)
         } else {
           handle_swap_exists(NULL);
         }
-        dorewind = TRUE;                        // start again
+        dorewind = true;                        // start again
       }
       os_breakcheck();
       if (got_int) {
@@ -1760,7 +1760,7 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
         // abort or quit selected
         if (got_int || only_one_window()) {
           // abort selected and only one window
-          did_emsg = FALSE;             // avoid hit-enter prompt
+          did_emsg = false;             // avoid hit-enter prompt
           getout(1);
         }
         win_close(curwin, true, false);
@@ -1841,7 +1841,7 @@ static void exe_commands(mparm_T *parmp)
    * pattern on line 1.  But don't move the cursor when an autocommand
    * with g`" was used.
    */
-  msg_scroll = TRUE;
+  msg_scroll = true;
   if (parmp->tagname == NULL && curwin->w_cursor.lnum <= 1) {
     curwin->w_cursor.lnum = 0;
   }
@@ -1861,12 +1861,12 @@ static void exe_commands(mparm_T *parmp)
   }
 
   if (!exmode_active) {
-    msg_scroll = FALSE;
+    msg_scroll = false;
   }
 
   // When started with "-q errorfile" jump to first error again.
   if (parmp->edit_type == EDIT_QF) {
-    qf_jump(NULL, 0, 0, FALSE);
+    qf_jump(NULL, 0, 0, false);
   }
   TIME_MSG("executing command arguments");
 }
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 318bd64d88..014d9a1d18 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -552,7 +552,7 @@ void check_need_swap(bool newfile)
 
 /// Close memline for buffer 'buf'.
 ///
-/// @param del_file  if TRUE, delete the swap file
+/// @param del_file  if true, delete the swap file
 void ml_close(buf_T *buf, int del_file)
 {
   if (buf->b_ml.ml_mfp == NULL) {               // not open
@@ -590,7 +590,7 @@ void ml_close_notmod(void)
 {
   FOR_ALL_BUFFERS(buf) {
     if (!bufIsChanged(buf)) {
-      ml_close(buf, TRUE);          // close all not-modified buffers
+      ml_close(buf, true);          // close all not-modified buffers
     }
   }
 }
@@ -764,7 +764,7 @@ void ml_recover(bool checkext)
   int attr;
   int orig_file_status = NOTDONE;
 
-  recoverymode = TRUE;
+  recoverymode = true;
   called_from_main = (curbuf->b_ml.ml_mfp == NULL);
   attr = HL_ATTR(HLF_E);
 
@@ -785,7 +785,7 @@ void ml_recover(bool checkext)
     directly = false;
 
     // count the number of matching swap files
-    len = recover_names(fname, FALSE, 0, NULL);
+    len = recover_names(fname, false, 0, NULL);
     if (len == 0) {                 // no swap files found
       semsg(_("E305: No swap file found for %s"), fname);
       goto theend;
@@ -794,16 +794,16 @@ void ml_recover(bool checkext)
       i = 1;
     } else {                          // several swap files found, choose
       // list the names of the swap files
-      (void)recover_names(fname, TRUE, 0, NULL);
+      (void)recover_names(fname, true, 0, NULL);
       msg_putchar('\n');
       msg_puts(_("Enter number of swap file to use (0 to quit): "));
-      i = get_number(FALSE, NULL);
+      i = get_number(false, NULL);
       if (i < 1 || i > len) {
         goto theend;
       }
     }
     // get the swap file name that will be used
-    (void)recover_names(fname, FALSE, i, &fname_used);
+    (void)recover_names(fname, false, i, &fname_used);
   }
   if (fname_used == NULL) {
     goto theend;  // user chose invalid number.
@@ -1201,7 +1201,7 @@ void ml_recover(bool checkext)
   curbuf->b_flags |= BF_RECOVERED;
   check_cursor();
 
-  recoverymode = FALSE;
+  recoverymode = false;
   if (got_int) {
     emsg(_("E311: Recovery Interrupted"));
   } else if (error) {
@@ -1226,7 +1226,7 @@ void ml_recover(bool checkext)
 
 theend:
   xfree(fname_used);
-  recoverymode = FALSE;
+  recoverymode = false;
   if (mfp != NULL) {
     if (hp != NULL) {
       mf_put(mfp, hp, false, false);
@@ -1238,7 +1238,7 @@ theend:
     xfree(buf);
   }
   if (serious_error && called_from_main) {
-    ml_close(curbuf, TRUE);
+    ml_close(curbuf, true);
   } else {
     apply_autocmds(EVENT_BUFREADPOST, NULL, curbuf->b_fname, false, curbuf);
     apply_autocmds(EVENT_BUFWINENTER, NULL, curbuf->b_fname, false, curbuf);
@@ -1255,7 +1255,7 @@ theend:
 /// - find the name of the n'th swap file when recovering
 ///
 /// @param fname  base for swap file name
-/// @param list  when TRUE, list the swap file names
+/// @param list  when true, list the swap file names
 /// @param nr  when non-zero, return nr'th swap file name
 /// @param fname_out  result when "nr" > 0
 int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
@@ -1310,7 +1310,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
         names[2] = xstrdup(".sw?");
         num_names = 3;
       } else {
-        num_names = recov_file_names(names, fname_res, TRUE);
+        num_names = recov_file_names(names, fname_res, true);
       }
     } else {                      // check directory dir_name
       if (fname == NULL) {
@@ -1333,7 +1333,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
           tail = (char_u *)path_tail((char *)fname_res);
           tail = (char_u *)concat_fnames((char *)dir_name, (char *)tail, true);
         }
-        num_names = recov_file_names(names, tail, FALSE);
+        num_names = recov_file_names(names, tail, false);
         xfree(tail);
       }
     }
@@ -1447,7 +1447,7 @@ char *make_percent_swname(const char *dir, const char *name)
         *d = '%';
       }
     }
-    d = concat_fnames(dir, s, TRUE);
+    d = concat_fnames(dir, s, true);
     xfree(s);
     xfree(f);
   }
@@ -1668,8 +1668,8 @@ static int recov_file_names(char **names, char_u *path, int prepend_dot)
 
 /// sync all memlines
 ///
-/// @param check_file  if TRUE, check if original file exists and was not changed.
-/// @param check_char  if TRUE, stop syncing when character becomes available, but
+/// @param check_file  if true, check if original file exists and was not changed.
+/// @param check_char  if true, stop syncing when character becomes available, but
 ///
 /// always sync at least one block.
 void ml_sync_all(int check_file, int check_char, bool do_fsync)
@@ -1714,7 +1714,7 @@ void ml_sync_all(int check_file, int check_char, bool do_fsync)
 /// Used for the :preserve command and when the original file has been
 /// changed or deleted.
 ///
-/// @param message  if TRUE, the success of preserving is reported.
+/// @param message  if true, the success of preserving is reported.
 void ml_preserve(buf_T *buf, int message, bool do_fsync)
 {
   bhdr_T *hp;
@@ -1908,7 +1908,7 @@ int ml_line_alloced(void)
 /// "line" does not need to be allocated, but can't be another line in a
 /// buffer, unlocking may make it invalid.
 ///
-///   newfile: TRUE when starting to edit a new file, meaning that pe_old_lnum
+///   newfile: true when starting to edit a new file, meaning that pe_old_lnum
 ///              will be set for recovery
 /// Check: The caller of this function should probably also call
 /// appended_lines().
@@ -1922,7 +1922,7 @@ int ml_line_alloced(void)
 int ml_append(linenr_T lnum, char *line, colnr_T len, bool newfile)
 {
   // When starting up, we might still need to create the memfile
-  if (curbuf->b_ml.ml_mfp == NULL && open_buffer(FALSE, NULL, 0) == FAIL) {
+  if (curbuf->b_ml.ml_mfp == NULL && open_buffer(false, NULL, 0) == FAIL) {
     return FAIL;
   }
 
@@ -1949,7 +1949,7 @@ int ml_append_buf(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, bool new
   if (buf->b_ml.ml_line_lnum != 0) {
     ml_flush_line(buf);
   }
-  return ml_append_int(buf, lnum, line, len, newfile, FALSE);
+  return ml_append_int(buf, lnum, line, len, newfile, false);
 }
 
 /// @param lnum  append after this line (can be 0)
@@ -3040,7 +3040,7 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
           if (bnum != bnum2) {
             bnum = bnum2;
             pp->pb_pointer[idx].pe_bnum = bnum;
-            dirty = TRUE;
+            dirty = true;
           }
         }
 
@@ -3058,10 +3058,10 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
     }
     if (action == ML_DELETE) {
       pp->pb_pointer[idx].pe_line_count--;
-      dirty = TRUE;
+      dirty = true;
     } else if (action == ML_INSERT) {
       pp->pb_pointer[idx].pe_line_count++;
-      dirty = TRUE;
+      dirty = true;
     }
     mf_put(mfp, hp, dirty, false);
   }
@@ -3203,7 +3203,7 @@ int resolve_symlink(const char_u *fname, char_u *buf)
    * be consistent even when opening a relative symlink from different
    * working directories.
    */
-  return vim_FullName((char *)tmp, (char *)buf, MAXPATHL, TRUE);
+  return vim_FullName((char *)tmp, (char *)buf, MAXPATHL, true);
 }
 #endif
 
@@ -3275,7 +3275,7 @@ char_u *get_file_in_dir(char_u *fname, char_u *dname)
     retval = vim_strsave(fname);
   } else if (dname[0] == '.' && vim_ispathsep(dname[1])) {
     if (tail == fname) {            // no path before file name
-      retval = (char_u *)concat_fnames((char *)dname + 2, (char *)tail, TRUE);
+      retval = (char_u *)concat_fnames((char *)dname + 2, (char *)tail, true);
     } else {
       save_char = *tail;
       *tail = NUL;
@@ -3285,7 +3285,7 @@ char_u *get_file_in_dir(char_u *fname, char_u *dname)
       xfree(t);
     }
   } else {
-    retval = (char_u *)concat_fnames((char *)dname, (char *)tail, TRUE);
+    retval = (char_u *)concat_fnames((char *)dname, (char *)tail, true);
   }
 
   return retval;
@@ -3455,7 +3455,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
           && !buf->b_help && !(buf->b_flags & BF_DUMMY)) {
         int fd;
         struct block0 b0;
-        int differ = FALSE;
+        int differ = false;
 
         // Try to read block 0 from the swap file to get the original
         // file name (and inode number).
@@ -3475,7 +3475,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
                 expand_env(b0.b0_fname, NameBuff, MAXPATHL);
                 if (fnamecmp_ino((char_u *)buf->b_ffname, NameBuff,
                                  char_to_long(b0.b0_ino))) {
-                  differ = TRUE;
+                  differ = true;
                 }
               }
             } else {
@@ -3484,7 +3484,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
               expand_env(b0.b0_fname, NameBuff, MAXPATHL);
               if (fnamecmp_ino((char_u *)buf->b_ffname, NameBuff,
                                char_to_long(b0.b0_ino))) {
-                differ = TRUE;
+                differ = true;
               }
             }
           }
@@ -3564,7 +3564,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
           if (choice > 0) {
             switch (choice) {
             case 1:
-              buf->b_p_ro = TRUE;
+              buf->b_p_ro = true;
               break;
             case 2:
               break;
@@ -3579,7 +3579,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
               break;
             case 6:
               swap_exists_action = SEA_QUIT;
-              got_int = TRUE;
+              got_int = true;
               break;
             }
 
@@ -3667,18 +3667,18 @@ static int b0_magic_wrong(ZERO_BL *b0p)
 ///
 /// current file doesn't exist, file for swap file exist, file name(s) not
 /// available -> probably different
-///              == 0   != 0    FAIL      X      TRUE
-///              == 0   != 0     X       FAIL    TRUE
+///              == 0   != 0    FAIL      X      true
+///              == 0   != 0     X       FAIL    true
 ///
 /// current file exists, inode for swap unknown, file name(s) not
 /// available -> probably different
-///              != 0   == 0    FAIL      X      TRUE
-///              != 0   == 0     X       FAIL    TRUE
+///              != 0   == 0    FAIL      X      true
+///              != 0   == 0     X       FAIL    true
 ///
 /// current file doesn't exist, inode for swap unknown, one file name not
 /// available -> probably different
-///              == 0   == 0    FAIL      OK     TRUE
-///              == 0   == 0     OK      FAIL    TRUE
+///              == 0   == 0    FAIL      OK     true
+///              == 0   == 0     OK      FAIL    true
 ///
 /// current file doesn't exist, inode for swap unknown, both file names not
 /// available -> compare file names
@@ -3722,8 +3722,8 @@ static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0)
    * One of the inode numbers is unknown, try a forced vim_FullName() and
    * compare the file names.
    */
-  retval_c = vim_FullName((char *)fname_c, (char *)buf_c, MAXPATHL, TRUE);
-  retval_s = vim_FullName((char *)fname_s, (char *)buf_s, MAXPATHL, TRUE);
+  retval_c = vim_FullName((char *)fname_c, (char *)buf_c, MAXPATHL, true);
+  retval_s = vim_FullName((char *)fname_s, (char *)buf_s, MAXPATHL, true);
   if (retval_c == OK && retval_s == OK) {
     return STRCMP(buf_c, buf_s) != 0;
   }
@@ -4163,7 +4163,7 @@ void goto_byte(long cnt)
     curwin->w_cursor.lnum = lnum;
     curwin->w_cursor.col = (colnr_T)boff;
     curwin->w_cursor.coladd = 0;
-    curwin->w_set_curswant = TRUE;
+    curwin->w_set_curswant = true;
   }
   check_cursor();
 
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index b7665c2d82..b1d729f71d 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -914,7 +914,7 @@ static void show_menus_recursive(vimmenu_T *menu, int modes, int depth)
  */
 static vimmenu_T *expand_menu = NULL;
 static int expand_modes = 0x0;
-static int expand_emenu;                // TRUE for ":emenu" command
+static int expand_emenu;                // true for ":emenu" command
 
 /*
  * Work out what to complete when doing command line completion of menu names.
@@ -1056,7 +1056,7 @@ char *get_menu_name(expand_T *xp, int idx)
     } else {
       str = menu->dname;
       if (menu->en_dname == NULL) {
-        should_advance = TRUE;
+        should_advance = true;
       }
     }
   } else {
@@ -1163,10 +1163,8 @@ char *menu_name_skip(char *const name)
   return p;
 }
 
-/*
- * Return TRUE when "name" matches with menu "menu".  The name is compared in
- * two ways: raw menu name and menu name without '&'.  ignore part after a TAB.
- */
+/// Return true when "name" matches with menu "menu".  The name is compared in
+/// two ways: raw menu name and menu name without '&'.  ignore part after a TAB.
 static bool menu_name_equal(const char *const name, const vimmenu_T *const menu)
 {
   if (menu->en_name != NULL
@@ -1405,10 +1403,8 @@ bool menu_is_toolbar(const char *const name)
   return STRNCMP(name, "ToolBar", 7) == 0;
 }
 
-/*
- * Return TRUE if the name is a menu separator identifier: Starts and ends
- * with '-'
- */
+/// Return true if the name is a menu separator identifier: Starts and ends
+/// with '-'
 int menu_is_separator(char *name)
 {
   return name[0] == '-' && name[STRLEN(name) - 1] == '-';
diff --git a/src/nvim/message.c b/src/nvim/message.c
index e29bacbd17..aa5e556180 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -56,7 +56,7 @@ typedef struct msgchunk_S msgchunk_T;
 struct msgchunk_S {
   msgchunk_T *sb_next;
   msgchunk_T *sb_prev;
-  char sb_eol;                  // TRUE when line ends after this text
+  char sb_eol;                  // true when line ends after this text
   int sb_msg_col;               // column in which text starts
   int sb_attr;                  // text attributes
   char_u sb_text[1];            // text to be displayed, actually longer
@@ -66,7 +66,7 @@ struct msgchunk_S {
 #define DLG_BUTTON_SEP  '\n'
 #define DLG_HOTKEY_CHAR '&'
 
-static int confirm_msg_used = FALSE;            // displaying confirm_msg
+static int confirm_msg_used = false;            // displaying confirm_msg
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "message.c.generated.h"
 #endif
@@ -78,7 +78,7 @@ MessageHistoryEntry *last_msg_hist = NULL;
 static int msg_hist_len = 0;
 
 static FILE *verbose_fd = NULL;
-static int verbose_did_open = FALSE;
+static int verbose_did_open = false;
 
 bool keep_msg_more = false;    // keep_msg was set by msgmore()
 
@@ -102,7 +102,7 @@ bool keep_msg_more = false;    // keep_msg was set by msgmore()
  * msg_scrolled     How many lines the screen has been scrolled (because of
  *                  messages).  Used in update_screen() to scroll the screen
  *                  back.  Incremented each time the screen scrolls a line.
- * msg_scrolled_ign  TRUE when msg_scrolled is non-zero and msg_puts_attr()
+ * msg_scrolled_ign  true when msg_scrolled is non-zero and msg_puts_attr()
  *                  writes something without scrolling should not make
  *                  need_wait_return to be set.  This is a hack to make ":ts"
  *                  work without an extra prompt.
@@ -215,7 +215,7 @@ void msg_grid_validate(void)
 /// Displays the string 's' on the status line
 /// When terminal not initialized (yet) mch_errmsg(..) is used.
 ///
-/// @return  TRUE if wait_return not called
+/// @return  true if wait_return not called
 int msg(char *s)
 {
   return msg_attr_keep(s, 0, false, false);
@@ -319,7 +319,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
    * break this loop, limit the recursiveness to 3 levels.
    */
   if (entered >= 3) {
-    return TRUE;
+    return true;
   }
   entered++;
 
@@ -335,7 +335,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 
   // Truncate the message if needed.
   msg_start();
-  buf = msg_strtrunc((char_u *)s, FALSE);
+  buf = msg_strtrunc((char_u *)s, false);
   if (buf != NULL) {
     s = (const char *)buf;
   }
@@ -634,7 +634,7 @@ void msg_source(int attr)
   recursive = false;
 }
 
-/// @return  TRUE if not giving error messages right now:
+/// @return  true if not giving error messages right now:
 ///            If "emsg_off" is set: no error messages at the moment.
 ///            If "msg" is in 'debug': do error message but without side effects.
 ///            If "emsg_skip" is set: never do error messages.
@@ -643,9 +643,9 @@ int emsg_not_now(void)
   if ((emsg_off > 0 && vim_strchr((char *)p_debug, 'm') == NULL
        && vim_strchr((char *)p_debug, 't') == NULL)
       || emsg_skip > 0) {
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 static bool emsg_multiline(const char *s, bool multiline)
@@ -1177,12 +1177,12 @@ void wait_return(int redraw)
   oldState = State;
   if (quit_more) {
     c = CAR;                    // just pretend CR was hit
-    quit_more = FALSE;
-    got_int = FALSE;
+    quit_more = false;
+    got_int = false;
   } else if (exmode_active) {
     msg_puts(" ");              // make sure the cursor is on the right line
     c = CAR;                    // no need for a return in ex mode
-    got_int = FALSE;
+    got_int = false;
   } else {
     // Make sure the hit-return prompt is on screen when 'guioptions' was
     // just changed.
@@ -1247,8 +1247,8 @@ void wait_return(int redraw)
           }
           if (quit_more) {
             c = CAR;                            // just pretend CR was hit
-            quit_more = FALSE;
-            got_int = FALSE;
+            quit_more = false;
+            got_int = false;
           } else if (c != K_IGNORE) {
             c = K_IGNORE;
             hit_return_msg();
@@ -1653,7 +1653,7 @@ void msg_make(char_u *arg)
 /// If K_SPECIAL is encountered, then it is taken in conjunction with the
 /// following character and shown as <F1>, <S-Up> etc.  Any other character
 /// which is not printable shown in <> form.
-/// If 'from' is TRUE (lhs of a mapping), a space is shown as <Space>.
+/// If 'from' is true (lhs of a mapping), a space is shown as <Space>.
 /// If a character is displayed in one of these special ways, is also
 /// highlighted (its highlight name is '8' in the p_hl variable).
 /// Otherwise characters are not highlighted.
@@ -2557,7 +2557,7 @@ static void store_sb_text(char **sb_str, char *s, int attr, int *sb_col, int fin
     }
     mp->sb_next = NULL;
   } else if (finish && last_msgchunk != NULL) {
-    last_msgchunk->sb_eol = TRUE;
+    last_msgchunk->sb_eol = true;
   }
 
   *sb_str = s;
@@ -2614,7 +2614,7 @@ void sb_text_end_cmdline(void)
 }
 
 /// Clear any text remembered for scrolling back.
-/// When "all" is FALSE keep the last line.
+/// When "all" is false keep the last line.
 /// Called when redrawing the screen.
 void clear_sb_text(int all)
 {
@@ -2649,7 +2649,7 @@ void show_sb_text(void)
     vim_beep(BO_MESS);
   } else {
     do_more_prompt('G');
-    wait_return(FALSE);
+    wait_return(false);
   }
 }
 
@@ -2668,7 +2668,7 @@ static msgchunk_T *msg_sb_start(msgchunk_T *mps)
 void msg_sb_eol(void)
 {
   if (last_msgchunk != NULL) {
-    last_msgchunk->sb_eol = TRUE;
+    last_msgchunk->sb_eol = true;
   }
 }
 
@@ -2687,7 +2687,7 @@ static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp)
     if (*p == '\n') {       // don't display the line break
       p++;
     }
-    msg_puts_display(p, -1, mp->sb_attr, TRUE);
+    msg_puts_display(p, -1, mp->sb_attr, true);
     if (mp->sb_eol || mp->sb_next == NULL) {
       break;
     }
@@ -2718,7 +2718,7 @@ static void t_puts(int *t_col, const char_u *t_s, const char_u *s, int attr)
   }
 }
 
-/// @return  TRUE when messages should be printed to stdout/stderr:
+/// @return  true when messages should be printed to stdout/stderr:
 ///          - "batch mode" ("silent mode", -es/-Es)
 ///          - no UI and not embedded
 int msg_use_printf(void)
@@ -2786,14 +2786,14 @@ static void msg_puts_printf(const char *str, const ptrdiff_t maxlen)
 /// When at hit-enter prompt "typed_char" is the already typed character,
 /// otherwise it's NUL.
 ///
-/// @return  TRUE when jumping ahead to "confirm_msg_tail".
+/// @return  true when jumping ahead to "confirm_msg_tail".
 static int do_more_prompt(int typed_char)
 {
   static bool entered = false;
   int used_typed_char = typed_char;
   int oldState = State;
   int c;
-  int retval = FALSE;
+  int retval = false;
   int toscroll;
   bool to_redraw = false;
   msgchunk_T *mp_last = NULL;
@@ -2825,7 +2825,7 @@ static int do_more_prompt(int typed_char)
   State = MODE_ASKMORE;
   setmouse();
   if (typed_char == NUL) {
-    msg_moremsg(FALSE);
+    msg_moremsg(false);
   }
   for (;;) {
     /*
@@ -2898,10 +2898,10 @@ static int do_more_prompt(int typed_char)
     case ESC:
       if (confirm_msg_used) {
         // Jump to the choices of the dialog.
-        retval = TRUE;
+        retval = true;
       } else {
-        got_int = TRUE;
-        quit_more = TRUE;
+        got_int = true;
+        quit_more = true;
       }
       // When there is some more output (wrapping line) display that
       // without another prompt.
@@ -2917,7 +2917,7 @@ static int do_more_prompt(int typed_char)
       break;
 
     default:                    // no valid response
-      msg_moremsg(TRUE);
+      msg_moremsg(true);
       continue;
     }
 
@@ -3168,7 +3168,7 @@ void msg_clr_cmdline(void)
 /// end putting a message on the screen
 /// call wait_return if the message does not fit in the available space
 ///
-/// @return  TRUE if wait_return not called.
+/// @return  true if wait_return not called.
 int msg_end(void)
 {
   /*
@@ -3391,7 +3391,7 @@ void verbose_enter_scroll(void)
     msg_silent++;
   } else {
     // always scroll up, don't overwrite
-    msg_scroll = TRUE;
+    msg_scroll = true;
   }
 }
 
@@ -3414,7 +3414,7 @@ void verbose_stop(void)
     fclose(verbose_fd);
     verbose_fd = NULL;
   }
-  verbose_did_open = FALSE;
+  verbose_did_open = false;
 }
 
 /// Open the file 'verbosefile'.
@@ -3424,7 +3424,7 @@ int verbose_open(void)
 {
   if (verbose_fd == NULL && !verbose_did_open) {
     // Only give the error message once.
-    verbose_did_open = TRUE;
+    verbose_did_open = true;
 
     verbose_fd = os_fopen((char *)p_vfile, "a");
     if (verbose_fd == NULL) {
@@ -3523,7 +3523,7 @@ void msg_advance(int col)
 /// different letter.
 ///
 /// @param textfiel  IObuff for inputdialog(), NULL otherwise
-/// @param ex_cmd  when TRUE pressing : accepts default and starts Ex command
+/// @param ex_cmd  when true pressing : accepts default and starts Ex command
 /// @returns 0 if cancelled, otherwise the nth button (1-indexed).
 int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton,
               char_u *textfield, int ex_cmd)
@@ -3799,7 +3799,7 @@ int vim_dialog_yesno(int type, char_u *title, char_u *message, int dflt)
   if (do_dialog(type,
                 title == NULL ? (char_u *)_("Question") : title,
                 message,
-                (char_u *)_("&Yes\n&No"), dflt, NULL, FALSE) == 1) {
+                (char_u *)_("&Yes\n&No"), dflt, NULL, false) == 1) {
     return VIM_YES;
   }
   return VIM_NO;
@@ -3810,7 +3810,7 @@ int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt)
   switch (do_dialog(type,
                     title == NULL ? (char_u *)_("Question") : title,
                     message,
-                    (char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, FALSE)) {
+                    (char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, false)) {
   case 1:
     return VIM_YES;
   case 2:
@@ -3825,7 +3825,7 @@ int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message, int dflt
                     title == NULL ? (char_u *)"Question" : title,
                     message,
                     (char_u *)_("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
-                    dflt, NULL, FALSE)) {
+                    dflt, NULL, false)) {
   case 1:
     return VIM_YES;
   case 2:
diff --git a/src/nvim/mouse.h b/src/nvim/mouse.h
index 08261e4a30..21ff56bbbc 100644
--- a/src/nvim/mouse.h
+++ b/src/nvim/mouse.h
@@ -36,7 +36,7 @@
 #define MOUSE_X2       0x400  // Mouse-button X2
 
 // Direction for nv_mousescroll() and ins_mousescroll()
-#define MSCR_DOWN       0     // DOWN must be FALSE
+#define MSCR_DOWN       0     // DOWN must be false
 #define MSCR_UP         1
 #define MSCR_LEFT       (-1)
 #define MSCR_RIGHT      (-2)
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index b30538a9dc..a1f4149715 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -78,9 +78,9 @@ struct block_def {
   colnr_T textcol;              // index of chars (partially) in block
   colnr_T start_vcol;           // start col of 1st char wholly inside block
   colnr_T end_vcol;             // start col of 1st char wholly after block
-  int is_short;                 // TRUE if line is too short to fit in block
-  int is_MAX;                   // TRUE if curswant==MAXCOL when starting
-  int is_oneChar;               // TRUE if block within one character
+  int is_short;                 // true if line is too short to fit in block
+  int is_MAX;                   // true if curswant==MAXCOL when starting
+  int is_oneChar;               // true if block within one character
   int pre_whitesp;              // screen cols of ws before block
   int pre_whitesp_c;            // chars of ws before block
   colnr_T end_char_vcols;       // number of vcols of post-block char
@@ -181,13 +181,13 @@ int get_op_type(int char1, int char2)
   return i;
 }
 
-/// @return  TRUE if operator "op" always works on whole lines.
+/// @return  true if operator "op" always works on whole lines.
 int op_on_lines(int op)
 {
   return opchars[op][2] & OPF_LINES;
 }
 
-/// @return  TRUE if operator "op" changes text.
+/// @return  true if operator "op" changes text.
 int op_is_change(int op)
 {
   return opchars[op][2] & OPF_CHANGE;
@@ -2090,7 +2090,7 @@ void op_tilde(oparg_T *oap)
 {
   pos_T pos;
   struct block_def bd;
-  int did_change = FALSE;
+  int did_change = false;
 
   if (u_save((linenr_T)(oap->start.lnum - 1),
              (linenr_T)(oap->end.lnum + 1)) == FAIL) {
@@ -2165,7 +2165,7 @@ void op_tilde(oparg_T *oap)
 /// @param length  is rounded up to include the whole last multi-byte character.
 /// Also works correctly when the number of bytes changes.
 ///
-/// @return  TRUE if some character was changed.
+/// @return  true if some character was changed.
 static int swapchars(int op_type, pos_T *pos, int length)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -2303,7 +2303,7 @@ void op_insert(oparg_T *oap, long count1)
     if (oap->motion_type == kMTBlockWise
         && curwin->w_cursor.coladd == 0) {
       // Move the cursor to the character right of the block.
-      curwin->w_set_curswant = TRUE;
+      curwin->w_set_curswant = true;
       while (*get_cursor_pos_ptr() != NUL
              && (curwin->w_cursor.col < bd.textcol + bd.textlen)) {
         curwin->w_cursor.col++;
@@ -2463,7 +2463,7 @@ void op_insert(oparg_T *oap, long count1)
 
 /// handle a change operation
 ///
-/// @return  TRUE if edit() returns because of a CTRL-O command
+/// @return  true if edit() returns because of a CTRL-O command
 int op_change(oparg_T *oap)
 {
   colnr_T l;
@@ -2489,10 +2489,10 @@ int op_change(oparg_T *oap)
   // save for undo
   if (curbuf->b_ml.ml_flags & ML_EMPTY) {
     if (u_save_cursor() == FAIL) {
-      return FALSE;
+      return false;
     }
   } else if (op_delete(oap) == FAIL) {
-    return FALSE;
+    return false;
   }
 
   if ((l > curwin->w_cursor.col) && !LINEEMPTY(curwin->w_cursor.lnum)
@@ -2518,7 +2518,7 @@ int op_change(oparg_T *oap)
     fix_indent();
   }
 
-  retval = edit(NUL, FALSE, (linenr_T)1);
+  retval = edit(NUL, false, (linenr_T)1);
 
   /*
    * In Visual block mode, handle copying the new text to all lines of the
@@ -3708,7 +3708,7 @@ error:
   }
 
   msgmore(nr_lines);
-  curwin->w_set_curswant = TRUE;
+  curwin->w_set_curswant = true;
 
 end:
   if (cmdmod.cmod_flags & CMOD_LOCKMARKS) {
@@ -3722,7 +3722,7 @@ end:
     xfree(y_array);
   }
 
-  VIsual_active = FALSE;
+  VIsual_active = false;
 
   // If the cursor is past the end of the line put it at the end.
   adjust_cursor_eol();
@@ -3751,7 +3751,7 @@ void adjust_cursor_eol(void)
   }
 }
 
-/// @return  TRUE if lines starting with '#' should be left aligned.
+/// @return  true if lines starting with '#' should be left aligned.
 int preprocs_left(void)
 {
   return ((curbuf->b_p_si && !curbuf->b_p_cin)
@@ -4011,8 +4011,8 @@ char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_co
 }
 
 /// @param count              number of lines (minimal 2) to join at cursor position.
-/// @param save_undo          when TRUE, save lines for undo first.
-/// @param use_formatoptions  set to FALSE when e.g. processing backspace and comment
+/// @param save_undo          when true, save lines for undo first.
+/// @param use_formatoptions  set to false when e.g. processing backspace and comment
 ///                           leaders should not be removed.
 /// @param setmark            when true, sets the '[ and '] mark, else, the caller is expected
 ///                           to set those marks.
@@ -4033,7 +4033,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   colnr_T col = 0;
   int ret = OK;
   int *comments = NULL;
-  int remove_comments = (use_formatoptions == TRUE)
+  int remove_comments = (use_formatoptions == true)
                         && has_format_option(FO_REMOVE_COMS);
   bool prev_was_comment = false;
   assert(count >= 1);
@@ -4208,7 +4208,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   check_cursor_col();
 
   curwin->w_cursor.coladd = 0;
-  curwin->w_set_curswant = TRUE;
+  curwin->w_set_curswant = true;
 
 theend:
   xfree(spaces);
@@ -4218,7 +4218,7 @@ theend:
   return ret;
 }
 
-/// @return  TRUE if the two comment leaders given are the same.
+/// @return  true if the two comment leaders given are the same.
 ///
 /// @param lnum  The first line.  White-space is ignored.
 ///
@@ -4248,21 +4248,21 @@ static int same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, in
         return leader2_len == 0;
       }
       if (*p == COM_END) {
-        return FALSE;
+        return false;
       }
       if (*p == COM_START) {
         if (*(ml_get(lnum) + leader1_len) == NUL) {
-          return FALSE;
+          return false;
         }
         if (leader2_flags == NULL || leader2_len == 0) {
-          return FALSE;
+          return false;
         }
         for (p = leader2_flags; *p && *p != ':'; p++) {
           if (*p == COM_MIDDLE) {
-            return TRUE;
+            return true;
           }
         }
-        return FALSE;
+        return false;
       }
     }
   }
@@ -4588,7 +4588,7 @@ void format_lines(linenr_T line_count, int avoid_fex)
         // do the formatting, without 'showmode'
         State = MODE_INSERT;         // for open_line()
         smd_save = p_smd;
-        p_smd = FALSE;
+        p_smd = false;
         insertchar(NUL, INSCHAR_FORMAT
                    + (do_comments ? INSCHAR_DO_COM : 0)
                    + (do_comments && do_comments_list
@@ -4635,7 +4635,7 @@ void format_lines(linenr_T line_count, int avoid_fex)
           }
         }
         curwin->w_cursor.lnum--;
-        if (do_join(2, TRUE, FALSE, FALSE, false) == FAIL) {
+        if (do_join(2, true, false, false, false) == FAIL) {
           beep_flush();
           break;
         }
@@ -4652,22 +4652,22 @@ void format_lines(linenr_T line_count, int avoid_fex)
   }
 }
 
-/// @return  TRUE if line "lnum" ends in a white character.
+/// @return  true if line "lnum" ends in a white character.
 static int ends_in_white(linenr_T lnum)
 {
   char_u *s = ml_get(lnum);
   size_t l;
 
   if (*s == NUL) {
-    return FALSE;
+    return false;
   }
   l = STRLEN(s) - 1;
   return ascii_iswhite(s[l]);
 }
 
 /// Blank lines, and lines containing only the comment leader, are left
-/// untouched by the formatting.  The function returns TRUE in this
-/// case.  It also returns TRUE when a line starts with the end of a comment
+/// untouched by the formatting.  The function returns true in this
+/// case.  It also returns true when a line starts with the end of a comment
 /// ('e' in comment flags), so that this line is skipped, and not joined to the
 /// previous line.  A new paragraph starts after a blank line, or when the
 /// comment leader changes.
@@ -4695,13 +4695,13 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags,
 
   return *skipwhite((char *)ptr + *leader_len) == NUL
          || (*leader_len > 0 && *flags == COM_END)
-         || startPS(lnum, NUL, FALSE);
+         || startPS(lnum, NUL, false);
 }
 
 /// Used for auto-formatting.
 ///
-/// @return  TRUE when a paragraph starts in line "lnum".
-///          FALSE when the previous line is in the same paragraph.
+/// @return  true when a paragraph starts in line "lnum".
+///          false when the previous line is in the same paragraph.
 int paragraph_start(linenr_T lnum)
 {
   char_u *p;
@@ -4711,11 +4711,11 @@ int paragraph_start(linenr_T lnum)
   char_u *next_leader_flags = NULL;  // flags for leader of next line
 
   if (lnum <= 1) {
-    return TRUE;                // start of the file
+    return true;                // start of the file
   }
   p = ml_get(lnum - 1);
   if (*p == NUL) {
-    return TRUE;                // after empty line
+    return true;                // after empty line
   }
   const bool do_comments = has_format_option(FO_Q_COMS);  // format comments
   if (fmt_check_par(lnum - 1, &leader_len, &leader_flags, do_comments)) {
@@ -4727,16 +4727,16 @@ int paragraph_start(linenr_T lnum)
   }
 
   if (has_format_option(FO_WHITE_PAR) && !ends_in_white(lnum - 1)) {
-    return TRUE;                // missing trailing space in previous line.
+    return true;                // missing trailing space in previous line.
   }
   if (has_format_option(FO_Q_NUMBER) && (get_number_indent(lnum) > 0)) {
-    return TRUE;                // numbered item starts in "lnum".
+    return true;                // numbered item starts in "lnum".
   }
   if (!same_leader(lnum - 1, leader_len, leader_flags,
                    next_leader_len, next_leader_flags)) {
-    return TRUE;                // change of comment leader.
+    return true;                // change of comment leader.
   }
-  return FALSE;
+  return false;
 }
 
 /// prepare a few things for block mode yank/delete/tilde
@@ -5606,7 +5606,7 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
 
   // Special case: '/' search pattern
   if (name == '/') {
-    set_last_search_pat(str, RE_SEARCH, TRUE, TRUE);
+    set_last_search_pat(str, RE_SEARCH, true, true);
     return;
   }
 
diff --git a/src/nvim/path.c b/src/nvim/path.c
index e4215c89c2..8d3c556c7d 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -233,10 +233,8 @@ char_u *get_past_head(const char_u *path)
   return (char_u *)retval;
 }
 
-/*
- * Return TRUE if 'c' is a path separator.
- * Note that for MS-Windows this includes the colon.
- */
+/// Return true if 'c' is a path separator.
+/// Note that for MS-Windows this includes the colon.
 int vim_ispathsep(int c)
 {
 #ifdef UNIX
@@ -262,9 +260,7 @@ int vim_ispathsep_nocolon(int c)
   ;
 }
 
-/*
- * return TRUE if 'c' is a path list separator.
- */
+/// return true if 'c' is a path list separator.
 int vim_ispathlistsep(int c)
 {
 #ifdef UNIX
@@ -319,11 +315,9 @@ void shorten_dir(char_u *str)
   shorten_dir_len(str, 1);
 }
 
-/*
- * Return TRUE if the directory of "fname" exists, FALSE otherwise.
- * Also returns TRUE if there is no directory name.
- * "fname" must be writable!.
- */
+/// Return true if the directory of "fname" exists, false otherwise.
+/// Also returns true if there is no directory name.
+/// "fname" must be writable!.
 bool dir_of_file_exists(char_u *fname)
 {
   char *p = path_tail_with_sep((char *)fname);
@@ -806,10 +800,8 @@ static int find_previous_pathsep(char_u *path, char_u **psep)
   return FAIL;
 }
 
-/*
- * Returns TRUE if "maybe_unique" is unique wrt other_paths in "gap".
- * "maybe_unique" is the end portion of "((char_u **)gap->ga_data)[i]".
- */
+/// Returns true if "maybe_unique" is unique wrt other_paths in "gap".
+/// "maybe_unique" is the end portion of "((char_u **)gap->ga_data)[i]".
 static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
 {
   char_u **other_paths = (char_u **)gap->ga_data;
@@ -1149,10 +1141,8 @@ static int expand_in_path(garray_T *const gap, char_u *const pattern, const int
   return gap->ga_len;
 }
 
-/*
- * Return TRUE if "p" contains what looks like an environment variable.
- * Allowing for escaping.
- */
+/// Return true if "p" contains what looks like an environment variable.
+/// Allowing for escaping.
 static bool has_env_var(char_u *p)
 {
   for (; *p; MB_PTR_ADV(p)) {
@@ -1167,7 +1157,7 @@ static bool has_env_var(char_u *p)
 
 #ifdef SPECIAL_WILDCHAR
 
-// Return TRUE if "p" contains a special wildcard character, one that Vim
+// Return true if "p" contains a special wildcard character, one that Vim
 // cannot expand, requires using a shell.
 static bool has_special_wildchar(char_u *p)
 {
@@ -1365,9 +1355,7 @@ void FreeWild(int count, char **files)
   xfree(files);
 }
 
-/*
- * Return TRUE if we can expand this backtick thing here.
- */
+/// Return true if we can expand this backtick thing here.
 static int vim_backtick(char_u *p)
 {
   return *p == '`' && *(p + 1) != NUL && *(p + STRLEN(p) - 1) == '`';
@@ -1726,7 +1714,7 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
         ptr = tofree;
         len = STRLEN(ptr);
         file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS,
-                                      TRUE, rel_fname);
+                                      true, rel_fname);
       }
     }
     if (file_name == NULL && (options & FNAME_MESS)) {
@@ -1740,7 +1728,7 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
      * appears several times in the path. */
     while (file_name != NULL && --count > 0) {
       xfree(file_name);
-      file_name = find_file_in_path(ptr, len, options, FALSE, rel_fname);
+      file_name = find_file_in_path(ptr, len, options, false, rel_fname);
     }
   } else {
     file_name = vim_strnsave(ptr, len);
@@ -1820,9 +1808,7 @@ bool path_with_extension(const char *path, const char *extension)
   return strcmp(last_dot + 1, extension) == 0;
 }
 
-/*
- * Return TRUE if "name" is a full (absolute) path name or URL.
- */
+/// Return true if "name" is a full (absolute) path name or URL.
 bool vim_isAbsName(char_u *name)
 {
   return path_with_url((char *)name) != 0 || path_is_absolute(name);
@@ -1959,21 +1945,17 @@ void path_fix_case(char *name)
   os_closedir(&dir);
 }
 
-/*
- * Return TRUE if "p" points to just after a path separator.
- * Takes care of multi-byte characters.
- * "b" must point to the start of the file name
- */
+/// Return true if "p" points to just after a path separator.
+/// Takes care of multi-byte characters.
+/// "b" must point to the start of the file name
 int after_pathsep(const char *b, const char *p)
 {
   return p > b && vim_ispathsep(p[-1])
          && utf_head_off((char_u *)b, (char_u *)p - 1) == 0;
 }
 
-/*
- * Return TRUE if file names "f1" and "f2" are in the same directory.
- * "f1" may be a short name, "f2" must be a full path.
- */
+/// Return true if file names "f1" and "f2" are in the same directory.
+/// "f1" may be a short name, "f2" must be a full path.
 bool same_directory(char_u *f1, char_u *f2)
 {
   char ffname[MAXPATHL];
@@ -1985,7 +1967,7 @@ bool same_directory(char_u *f1, char_u *f2)
     return false;
   }
 
-  (void)vim_FullName((char *)f1, (char *)ffname, MAXPATHL, FALSE);
+  (void)vim_FullName((char *)f1, (char *)ffname, MAXPATHL, false);
   t1 = path_tail_with_sep(ffname);
   t2 = path_tail_with_sep((char *)f2);
   return t1 - ffname == (char_u *)t2 - f2
@@ -2252,9 +2234,7 @@ int expand_wildcards(int num_pat, char **pat, int *num_files, char ***files, int
   return retval;
 }
 
-/*
- * Return TRUE if "fname" matches with an entry in 'suffixes'.
- */
+/// Return true if "fname" matches with an entry in 'suffixes'.
 int match_suffix(char_u *fname)
 {
 #define MAXSUFLEN 30  // maximum length of a file suffix
@@ -2417,7 +2397,7 @@ static int path_to_absolute(const char_u *fname, char_u *buf, size_t len, int fo
 
 /// Check if file `fname` is a full (absolute) path.
 ///
-/// @return `TRUE` if "fname" is absolute.
+/// @return `true` if "fname" is absolute.
 int path_is_absolute(const char_u *fname)
 {
 #ifdef WIN32
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index a6d5098a20..7c914b0276 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -67,9 +67,9 @@ struct qfline_S {
   char *qf_module;      ///< module name for this error
   char *qf_pattern;     ///< search pattern for the error
   char *qf_text;        ///< description of the error
-  char qf_viscol;       ///< set to TRUE if qf_col and qf_end_col is
+  char qf_viscol;       ///< set to true if qf_col and qf_end_col is
   //   screen column
-  char qf_cleared;      ///< set to TRUE if line has been deleted
+  char qf_cleared;      ///< set to true if line has been deleted
   char qf_type;         ///< type of the error (mostly 'E'); 1 for :helpgrep
   char qf_valid;        ///< valid error message detected
 };
@@ -100,7 +100,7 @@ typedef struct qf_list_S {
   qfline_T *qf_ptr;          ///< pointer to the current error
   int qf_count;                 ///< number of errors (0 means empty list)
   int qf_index;                 ///< current index in the error list
-  int qf_nonevalid;             ///< TRUE if not a single valid entry found
+  int qf_nonevalid;             ///< true if not a single valid entry found
   char *qf_title;        ///< title derived from the command that created
                          ///< the error list or set by setqflist
   typval_T *qf_ctx;          ///< context set by setqflist/setloclist
@@ -1891,7 +1891,7 @@ static qf_info_T *ll_get_or_alloc_list(win_T *wp)
 /// Get the quickfix/location list stack to use for the specified Ex command.
 /// For a location list command, returns the stack for the current window.  If
 /// the location list is not found, then returns NULL and prints an error
-/// message if 'print_emsg' is TRUE.
+/// message if 'print_emsg' is true.
 static qf_info_T *qf_cmd_get_stack(exarg_T *eap, int print_emsg)
 {
   qf_info_T *qi = &ql_info;
@@ -2511,7 +2511,7 @@ static win_T *qf_find_win_with_normal_buf(void)
 }
 
 // Go to a window in any tabpage containing the specified file.  Returns true
-// if successfully jumped to the window. Otherwise returns FALSE.
+// if successfully jumped to the window. Otherwise returns false.
 static bool qf_goto_tabwin_with_file(int fnum)
 {
   FOR_ALL_TAB_WINDOWS(tp, wp) {
@@ -3393,7 +3393,7 @@ bool qf_mark_adjust(win_T *wp, linenr_T line1, linenr_T line2, linenr_T amount,
           found_one = true;
           if (qfp->qf_lnum >= line1 && qfp->qf_lnum <= line2) {
             if (amount == MAXLNUM) {
-              qfp->qf_cleared = TRUE;
+              qfp->qf_cleared = true;
             } else {
               qfp->qf_lnum += amount;
             }
@@ -3747,7 +3747,7 @@ linenr_T qf_current_entry(win_T *wp)
 }
 
 /// Update the cursor position in the quickfix window to the current error.
-/// Return TRUE if there is a quickfix window.
+/// Return true if there is a quickfix window.
 ///
 /// @param old_qf_index  previous qf_index or zero
 static bool qf_win_pos_update(qf_info_T *qi, int old_qf_index)
@@ -4175,7 +4175,7 @@ static void qf_jump_first(qf_info_T *qi, unsigned save_qfid, int forceit)
   }
 }
 
-// Return TRUE when using ":vimgrep" for ":grep".
+// Return true when using ":vimgrep" for ":grep".
 int grep_internal(cmdidx_T cmdidx)
 {
   return (cmdidx == CMD_grep
@@ -4832,7 +4832,7 @@ static void qf_get_nth_below_entry(qfline_T *entry_arg, linenr_T n, bool linewis
 }
 
 /// Get the nth quickfix entry above the specified entry.  Searches backwards in
-/// the list. If linewise is TRUE, then treat multiple entries on a single line
+/// the list. If linewise is true, then treat multiple entries on a single line
 /// as one.
 static void qf_get_nth_above_entry(qfline_T *entry, linenr_T n, bool linewise, int *errornr)
   FUNC_ATTR_NONNULL_ALL
@@ -5609,7 +5609,7 @@ static buf_T *load_dummy_buffer(char *fname, char *dirname_start, char *resultin
     if (readfile_result == OK
         && !got_int
         && !(curbuf->b_flags & BF_NEW)) {
-      failed = FALSE;
+      failed = false;
       if (curbuf != newbuf) {
         // Bloody autocommands changed the buffer!  Can happen when
         // using netrw and editing a remote file.  Use the current
@@ -5677,7 +5677,7 @@ static void wipe_dummy_buffer(buf_T *buf, char *dirname_start)
     cleanup_T cs;
 
     // Reset the error/interrupt/exception state here so that aborting()
-    // returns FALSE when wiping out the buffer.  Otherwise it doesn't
+    // returns false when wiping out the buffer.  Otherwise it doesn't
     // work when got_int is set.
     enter_cleanup(&cs);
 
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 34ff30a8da..3b6bcbeeb3 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -354,10 +354,8 @@ char_u *last_search_pattern(void)
   return spats[RE_SEARCH].pat;
 }
 
-/*
- * Return TRUE when case should be ignored for search pattern "pat".
- * Uses the 'ignorecase' and 'smartcase' options.
- */
+/// Return true when case should be ignored for search pattern "pat".
+/// Uses the 'ignorecase' and 'smartcase' options.
 int ignorecase(char_u *pat)
 {
   return ignorecase_opt(pat, p_ic, p_scs);
@@ -423,7 +421,7 @@ int last_csearch_forward(void)
 
 int last_csearch_until(void)
 {
-  return last_t_cmd == TRUE;
+  return last_t_cmd == true;
 }
 
 void set_last_csearch(int c, char_u *s, int len)
@@ -480,8 +478,8 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
   spats[idx].no_scs = false;
   spats[idx].off.dir = '/';
   set_vv_searchforward();
-  spats[idx].off.line = FALSE;
-  spats[idx].off.end = FALSE;
+  spats[idx].off.line = false;
+  spats[idx].off.end = false;
   spats[idx].off.off = 0;
   if (setlast) {
     last_idx = idx;
@@ -610,11 +608,11 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
 
     start_pos = *pos;           // remember start pos for detecting no match
     found = 0;                  // default: not found
-    at_first_line = TRUE;       // default: start in first line
+    at_first_line = true;       // default: start in first line
     if (pos->lnum == 0) {       // correct lnum for when starting in line 0
       pos->lnum = 1;
       pos->col = 0;
-      at_first_line = FALSE;        // not in first line now
+      at_first_line = false;        // not in first line now
     }
 
     /*
@@ -627,14 +625,14 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
     if (dir == BACKWARD && start_pos.col == 0
         && (options & SEARCH_START) == 0) {
       lnum = pos->lnum - 1;
-      at_first_line = FALSE;
+      at_first_line = false;
     } else {
       lnum = pos->lnum;
     }
 
     for (loop = 0; loop <= 1; loop++) {     // loop twice if 'wrapscan' set
       for (; lnum > 0 && lnum <= buf->b_ml.ml_line_count;
-           lnum += dir, at_first_line = FALSE) {
+           lnum += dir, at_first_line = false) {
         // Stop after checking "stop_lnum", if it's set.
         if (stop_lnum != 0 && (dir == FORWARD
                                ? lnum > stop_lnum : lnum < stop_lnum)) {
@@ -901,7 +899,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
           break;                    // if second loop, stop where started
         }
       }
-      at_first_line = FALSE;
+      at_first_line = false;
 
       // vim_regexec_multi() may clear "regprog"
       if (regmatch.regprog == NULL) {
@@ -1006,22 +1004,22 @@ static int first_submatch(regmmatch_T *rp)
 /// Highest level string search function.
 /// Search for the 'count'th occurrence of pattern 'pat' in direction 'dirc'
 ///
-/// Careful: If spats[0].off.line == TRUE and spats[0].off.off == 0 this
+/// Careful: If spats[0].off.line == true and spats[0].off.off == 0 this
 /// makes the movement linewise without moving the match position.
 ///
 /// @param dirc          if 0: use previous dir.
 /// @param pat           NULL or empty : use previous string.
-/// @param options       if TRUE and
-///                      SEARCH_REV   == TRUE : go in reverse of previous dir.
-///                      SEARCH_ECHO  == TRUE : echo the search command and handle options
-///                      SEARCH_MSG   == TRUE : may give error message
-///                      SEARCH_OPT   == TRUE : interpret optional flags
-///                      SEARCH_HIS   == TRUE : put search pattern in history
-///                      SEARCH_NOOF  == TRUE : don't add offset to position
-///                      SEARCH_MARK  == TRUE : set previous context mark
-///                      SEARCH_KEEP  == TRUE : keep previous search pattern
-///                      SEARCH_START == TRUE : accept match at curpos itself
-///                      SEARCH_PEEK  == TRUE : check for typed char, cancel search
+/// @param options       if true and
+///                      SEARCH_REV   == true : go in reverse of previous dir.
+///                      SEARCH_ECHO  == true : echo the search command and handle options
+///                      SEARCH_MSG   == true : may give error message
+///                      SEARCH_OPT   == true : interpret optional flags
+///                      SEARCH_HIS   == true : put search pattern in history
+///                      SEARCH_NOOF  == true : don't add offset to position
+///                      SEARCH_MARK  == true : set previous context mark
+///                      SEARCH_KEEP  == true : keep previous search pattern
+///                      SEARCH_START == true : accept match at curpos itself
+///                      SEARCH_PEEK  == true : check for typed char, cancel search
 /// @param oap           can be NULL
 /// @param dirc          '/' or '?'
 /// @param search_delim  delimiter for search, e.g. '%' in s%regex%replacement
@@ -1137,8 +1135,8 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
         dircp = p;              // remember where we put the NUL
         *p++ = NUL;
       }
-      spats[0].off.line = FALSE;
-      spats[0].off.end = FALSE;
+      spats[0].off.line = false;
+      spats[0].off.end = false;
       spats[0].off.off = 0;
       // Check for a line offset or a character offset.
       // For get_address (echo off) we don't check for a character
@@ -1435,7 +1433,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
     setpcmark();
   }
   curwin->w_cursor = pos;
-  curwin->w_set_curswant = TRUE;
+  curwin->w_set_curswant = true;
 
 end_do_search:
   if ((options & SEARCH_KEEP) || (cmdmod.cmod_flags & CMOD_KEEPPATTERNS)) {
@@ -1519,12 +1517,10 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
  * Character Searches
  */
 
-/*
- * Search for a character in a line.  If "t_cmd" is FALSE, move to the
- * position of the character, otherwise move to just before the char.
- * Do this "cap->count1" times.
- * Return FAIL or OK.
- */
+/// Search for a character in a line.  If "t_cmd" is false, move to the
+/// position of the character, otherwise move to just before the char.
+/// Do this "cap->count1" times.
+/// Return FAIL or OK.
 int searchc(cmdarg_T *cap, int t_cmd)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -2520,7 +2516,7 @@ int findsent(Direction dir, long count)
 
     for (;;) {                 // find end of sentence
       c = gchar_pos(&pos);
-      if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, FALSE))) {
+      if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, false))) {
         if (dir == BACKWARD && pos.lnum != startlnum) {
           pos.lnum++;
         }
@@ -2581,11 +2577,11 @@ found:
 /// Paragraphs are currently supposed to be separated by empty lines.
 /// If 'what' is NUL we go to the next paragraph.
 /// If 'what' is '{' or '}' we go to the next section.
-/// If 'both' is TRUE also stop at '}'.
+/// If 'both' is true also stop at '}'.
 ///
 /// @param pincl  Return: true if last char is to be included
 ///
-/// @return       TRUE if the next paragraph or section was found.
+/// @return       true if the next paragraph or section was found.
 bool findpar(bool *pincl, int dir, long count, int what, int both)
 {
   linenr_T curr;
@@ -2676,11 +2672,9 @@ static int inmacro(char_u *opt, char_u *s)
   return macro[0] != NUL;
 }
 
-/*
- * startPS: return TRUE if line 'lnum' is the start of a section or paragraph.
- * If 'para' is '{' or '}' only check for sections.
- * If 'both' is TRUE also stop at '}'
- */
+/// startPS: return true if line 'lnum' is the start of a section or paragraph.
+/// If 'para' is '{' or '}' only check for sections.
+/// If 'both' is true also stop at '}'
 int startPS(linenr_T lnum, int para, int both)
 {
   char_u *s;
@@ -2712,12 +2706,12 @@ int startPS(linenr_T lnum, int para, int both)
  * 2 or higher - keyword characters (letters, digits and underscore)
  */
 
-static int cls_bigword;         // TRUE for "W", "B" or "E"
+static int cls_bigword;         // true for "W", "B" or "E"
 
 /*
  * cls() - returns the class of character at curwin->w_cursor
  *
- * If a 'W', 'B', or 'E' motion is being done (cls_bigword == TRUE), chars
+ * If a 'W', 'B', or 'E' motion is being done (cls_bigword == true), chars
  * from class 2 and higher are reported as class 1 since only white space
  * boundaries are of interest.
  */
@@ -2732,7 +2726,7 @@ static int cls(void)
 
   c = utf_class(c);
 
-  // If cls_bigword is TRUE, report all non-blanks as class 1.
+  // If cls_bigword is true, report all non-blanks as class 1.
   if (c != 0 && cls_bigword) {
     return 1;
   }
@@ -2742,7 +2736,7 @@ static int cls(void)
 /// fwd_word(count, type, eol) - move forward one word
 ///
 /// @return  FAIL if the cursor was already at the end of the file.
-/// If eol is TRUE, last word stops at end of line (for operators).
+/// If eol is true, last word stops at end of line (for operators).
 ///
 /// @param bigword  "W", "E" or "B"
 int fwd_word(long count, int bigword, int eol)
@@ -2809,7 +2803,7 @@ int fwd_word(long count, int bigword, int eol)
 /*
  * bck_word() - move backward 'count' words
  *
- * If stop is TRUE and we are already on the start of a word, move one less.
+ * If stop is true and we are already on the start of a word, move one less.
  *
  * Returns FAIL if top of the file was reached.
  */
@@ -2855,7 +2849,7 @@ int bck_word(long count, int bigword, int stop)
 
     inc_cursor();                       // overshot - forward one
 finished:
-    stop = FALSE;
+    stop = false;
   }
   return OK;
 }
@@ -2872,8 +2866,8 @@ finished:
  *
  * Returns FAIL if end of the file was reached.
  *
- * If stop is TRUE and we are already on the end of a word, move one less.
- * If empty is TRUE stop on an empty line.
+ * If stop is true and we are already on the end of a word, move one less.
+ * If empty is true stop on an empty line.
  */
 int end_word(long count, int bigword, int stop, int empty)
 {
@@ -2906,7 +2900,7 @@ int end_word(long count, int bigword, int stop, int empty)
     } else if (!stop || sclass == 0) {
       /*
        * We were at the end of a word. Go to the end of the next word.
-       * First skip white space, if 'empty' is TRUE, stop at empty line.
+       * First skip white space, if 'empty' is true, stop at empty line.
        */
       while (cls() == 0) {
         if (empty && curwin->w_cursor.col == 0
@@ -2927,14 +2921,14 @@ int end_word(long count, int bigword, int stop, int empty)
     }
     dec_cursor();                       // overshot - one char backward
 finished:
-    stop = FALSE;                       // we move only one word less
+    stop = false;                       // we move only one word less
   }
   return OK;
 }
 
 /// Move back to the end of the word.
 ///
-/// @param bigword  TRUE for "B"
+/// @param bigword  true for "B"
 /// @param eol      if true, then stop at end of line.
 ///
 /// @return         FAIL if start of the file was reached.
@@ -3046,14 +3040,14 @@ static void findsent_forward(long count, bool at_start_sent)
 /// Find word under cursor, cursor at end.
 /// Used while an operator is pending, and in Visual mode.
 ///
-/// @param include  TRUE: include word and white space
-/// @param bigword  FALSE == word, TRUE == WORD
+/// @param include  true: include word and white space
+/// @param bigword  false == word, true == WORD
 int current_word(oparg_T *oap, long count, int include, int bigword)
 {
   pos_T start_pos;
   pos_T pos;
   bool inclusive = true;
-  int include_white = FALSE;
+  int include_white = false;
 
   cls_bigword = bigword;
   clearpos(&start_pos);
@@ -3080,7 +3074,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
      * not be included ("word"), find end of word.
      */
     if ((cls() == 0) == include) {
-      if (end_word(1L, bigword, TRUE, TRUE) == FAIL) {
+      if (end_word(1L, bigword, true, true) == FAIL) {
         return FAIL;
       }
     } else {
@@ -3091,7 +3085,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
        * If we end up in the first column of the next line (single char
        * word) back up to end of the line.
        */
-      fwd_word(1L, bigword, TRUE);
+      fwd_word(1L, bigword, true);
       if (curwin->w_cursor.col == 0) {
         decl(&curwin->w_cursor);
       } else {
@@ -3099,7 +3093,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
       }
 
       if (include) {
-        include_white = TRUE;
+        include_white = true;
       }
     }
 
@@ -3127,7 +3121,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
         return FAIL;
       }
       if (include != (cls() != 0)) {
-        if (bck_word(1L, bigword, TRUE) == FAIL) {
+        if (bck_word(1L, bigword, true) == FAIL) {
           return FAIL;
         }
       } else {
@@ -3144,7 +3138,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
         return FAIL;
       }
       if (include != (cls() == 0)) {
-        if (fwd_word(1L, bigword, TRUE) == FAIL && count > 1) {
+        if (fwd_word(1L, bigword, true) == FAIL && count > 1) {
           return FAIL;
         }
         /*
@@ -3156,7 +3150,7 @@ int current_word(oparg_T *oap, long count, int include, int bigword)
           inclusive = false;
         }
       } else {
-        if (end_word(1L, bigword, TRUE, TRUE) == FAIL) {
+        if (end_word(1L, bigword, true, true) == FAIL) {
           return FAIL;
         }
       }
@@ -3378,7 +3372,7 @@ extend:
 /// Find block under the cursor, cursor at end.
 /// "what" and "other" are two matching parenthesis/brace/etc.
 ///
-/// @param include  TRUE == include white space
+/// @param include  true == include white space
 /// @param what     '(', '{', etc.
 /// @param other    ')', '}', etc.
 int current_block(oparg_T *oap, long count, int include, int what, int other)
@@ -3453,7 +3447,7 @@ int current_block(oparg_T *oap, long count, int include, int what, int other)
   }
   curwin->w_cursor = *end_pos;
 
-  // Try to exclude the '(', '{', ')', '}', etc. when "include" is FALSE.
+  // Try to exclude the '(', '{', ')', '}', etc. when "include" is false.
   // If the ending '}', ')' or ']' is only preceded by indent, skip that
   // indent. But only if the resulting area is not smaller than what we
   // started with.
@@ -3764,7 +3758,7 @@ theend:
   return retval;
 }
 
-/// @param include  TRUE == include white space
+/// @param include  true == include white space
 /// @param type     'p' for paragraph, 'S' for section
 int current_par(oparg_T *oap, long count, int include, int type)
 {
@@ -3775,7 +3769,7 @@ int current_par(oparg_T *oap, long count, int include, int type)
   int start_is_white;
   int prev_start_is_white;
   int retval = OK;
-  int do_white = FALSE;
+  int do_white = false;
   int t;
   int i;
 
@@ -4394,7 +4388,7 @@ int current_search(long count, bool forward)
 /// If move is true, check from the beginning of the buffer,
 /// else from position "cur".
 /// "direction" is FORWARD or BACKWARD.
-/// Returns TRUE, FALSE or -1 for failure.
+/// Returns true, false or -1 for failure.
 static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direction)
 {
   regmmatch_T regmatch;
@@ -4451,9 +4445,7 @@ static int is_zero_width(char_u *pattern, int move, pos_T *cur, Direction direct
   return result;
 }
 
-/*
- * return TRUE if line 'lnum' is empty or has white chars only.
- */
+/// return true if line 'lnum' is empty or has white chars only.
 int linewhite(linenr_T lnum)
 {
   char_u *p;
@@ -5377,7 +5369,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
     if (incl_regmatch.regprog == NULL) {
       goto fpip_end;
     }
-    incl_regmatch.rm_ic = FALSE;        // don't ignore case in incl. pat.
+    incl_regmatch.rm_ic = false;        // don't ignore case in incl. pat.
   }
   if (type == FIND_DEFINE && (*curbuf->b_p_def != NUL || *p_def != NUL)) {
     def_regmatch.regprog = vim_regcomp(*curbuf->b_p_def == NUL
@@ -5386,7 +5378,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
     if (def_regmatch.regprog == NULL) {
       goto fpip_end;
     }
-    def_regmatch.rm_ic = FALSE;         // don't ignore case in define pat.
+    def_regmatch.rm_ic = false;         // don't ignore case in define pat.
   }
   files = xcalloc((size_t)max_path_depth, sizeof(SearchedFile));
   old_files = max_path_depth;
@@ -5419,7 +5411,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
         new_fname = file_name_in_line(incl_regmatch.endp[0], 0,
                                       FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, p_fname, NULL);
       }
-      already_searched = FALSE;
+      already_searched = false;
       if (new_fname != NULL) {
         // Check whether we have already searched in this file
         for (i = 0;; i++) {
@@ -5539,7 +5531,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
             bigger[i].fp = NULL;
             bigger[i].name = NULL;
             bigger[i].lnum = 0;
-            bigger[i].matched = FALSE;
+            bigger[i].matched = false;
           }
           for (i = old_files; i < max_path_depth; i++) {
             bigger[i + max_path_depth] = files[i];
@@ -5560,7 +5552,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
           }
           files[depth].name = curr_fname = new_fname;
           files[depth].lnum = 0;
-          files[depth].matched = FALSE;
+          files[depth].matched = false;
           if (action == ACTION_EXPAND) {
             msg_hist_off = true;                // reset in msg_trunc_attr()
             vim_snprintf((char *)IObuff, IOSIZE,
@@ -5814,7 +5806,7 @@ search_line:
         }
         if (action != ACTION_SHOW) {
           curwin->w_cursor.col = (colnr_T)(startp - line);
-          curwin->w_set_curswant = TRUE;
+          curwin->w_set_curswant = true;
         }
 
         if (l_g_do_tagpreview != 0
@@ -5957,7 +5949,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       msg_puts_attr((const char *)IObuff, HL_ATTR(HLF_N));
       msg_puts(" ");
     }
-    msg_prt_line(line, FALSE);
+    msg_prt_line(line, false);
     ui_flush();                        // show one line at a time
 
     // Definition continues until line that doesn't end with '\'
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 0fd7351d26..46249470d1 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -440,7 +440,7 @@ typedef struct spellinfo_S {
 
   sblock_T *si_blocks;       // memory blocks used
   long si_blocks_cnt;           // memory blocks allocated
-  int si_did_emsg;              // TRUE when ran out of memory
+  int si_did_emsg;              // true when ran out of memory
 
   long si_compress_cnt;         // words to add before lowering
                                 // compression limit
@@ -454,7 +454,7 @@ typedef struct spellinfo_S {
 
   int si_ascii;                 // handling only ASCII words
   int si_add;                   // addition file
-  int si_clear_chartab;             // when TRUE clear char tables
+  int si_clear_chartab;             // when true clear char tables
   int si_region;                // region mask
   vimconv_T si_conv;            // for conversion to 'encoding'
   int si_memtot;                // runtime memory used
@@ -1924,7 +1924,7 @@ static void spell_clear_flags(wordnode_T *node)
   wordnode_T *np;
 
   for (np = node; np != NULL; np = np->wn_sibling) {
-    np->wn_u1.index = FALSE;
+    np->wn_u1.index = false;
     spell_clear_flags(np->wn_child);
   }
 }
@@ -1940,7 +1940,7 @@ static void spell_print_node(wordnode_T *node, int depth)
     msg((char_u *)line2);
     msg((char_u *)line3);
   } else {
-    node->wn_u1.index = TRUE;
+    node->wn_u1.index = true;
 
     if (node->wn_byte != NUL) {
       if (node->wn_child != NULL) {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 69a5225edc..e9383e1bb3 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -812,9 +812,7 @@ static void restore_chartab(char_u *chartab)
   }
 }
 
-/*
- * Return TRUE if the line-continuation pattern matches in line "lnum".
- */
+/// Return true if the line-continuation pattern matches in line "lnum".
 static int syn_match_linecont(linenr_T lnum)
 {
   if (syn_block->b_syn_linecont_prog != NULL) {
@@ -832,7 +830,7 @@ static int syn_match_linecont(linenr_T lnum)
     restore_chartab(buf_chartab);
     return r;
   }
-  return FALSE;
+  return false;
 }
 
 /*
@@ -878,7 +876,7 @@ static void syn_update_ends(bool startofline)
         cur_si->si_m_endpos.lnum = 0;
         cur_si->si_m_endpos.col = 0;
         cur_si->si_h_endpos = cur_si->si_m_endpos;
-        cur_si->si_ends = TRUE;
+        cur_si->si_ends = true;
       }
     }
   }
@@ -1345,7 +1343,7 @@ static void load_current_state(synstate_T *from)
       if (keepend_level < 0 && (CUR_STATE(i).si_flags & HL_KEEPEND)) {
         keepend_level = i;
       }
-      CUR_STATE(i).si_ends = FALSE;
+      CUR_STATE(i).si_ends = false;
       CUR_STATE(i).si_m_lnum = 0;
       if (CUR_STATE(i).si_idx >= 0) {
         CUR_STATE(i).si_next_list =
@@ -1551,7 +1549,7 @@ static bool syn_finish_line(const bool syncing)
 /// "col" is normally 0 for the first use in a line, and increments by one each
 /// time.  It's allowed to skip characters and to stop before the end of the
 /// line.  But only a "col" after a previously used column is allowed.
-/// When "can_spell" is not NULL set it to TRUE when spell-checking should be
+/// When "can_spell" is not NULL set it to true when spell-checking should be
 /// done.
 ///
 /// @param keep_state  keep state of char at "col"
@@ -1732,7 +1730,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               cur_si->si_m_endpos.col = endcol;
               cur_si->si_h_endpos.lnum = current_lnum;
               cur_si->si_h_endpos.col = endcol;
-              cur_si->si_ends = TRUE;
+              cur_si->si_ends = true;
               cur_si->si_end_idx = 0;
               cur_si->si_flags = flags;
               cur_si->si_seqnr = next_seqnr++;
@@ -2046,10 +2044,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     if (can_spell != NULL) {
       struct sp_syn sps;
 
-      /*
-       * set "can_spell" to TRUE if spell checking is supposed to be
-       * done in the current item.
-       */
+      // set "can_spell" to true if spell checking is supposed to be
+      // done in the current item.
       if (syn_block->b_spell_cluster_id == 0) {
         // There is no @Spell cluster: Do spelling for items without
         // @NoSpell cluster.
@@ -2192,7 +2188,7 @@ static stateitem_T *push_next_match(void)
     } else {
       cur_si->si_m_endpos = next_match_m_endpos;
       cur_si->si_h_endpos = next_match_h_endpos;
-      cur_si->si_ends = TRUE;
+      cur_si->si_ends = true;
       cur_si->si_flags |= next_match_flags;
       cur_si->si_eoe_pos = next_match_eoe_pos;
       cur_si->si_end_idx = next_match_end_idx;
@@ -2216,7 +2212,7 @@ static stateitem_T *push_next_match(void)
       cur_si->si_m_lnum = current_lnum;
       cur_si->si_m_endpos = next_match_eos_pos;
       cur_si->si_h_endpos = next_match_eos_pos;
-      cur_si->si_ends = TRUE;
+      cur_si->si_ends = true;
       cur_si->si_end_idx = 0;
       cur_si->si_flags = HL_MATCH;
       cur_si->si_seqnr = next_seqnr++;
@@ -2422,7 +2418,7 @@ static void check_keepend(void)
       limit_pos_zero(&sip->si_m_endpos, &maxpos);
       limit_pos_zero(&sip->si_h_endpos, &maxpos_h);
       limit_pos_zero(&sip->si_eoe_pos, &maxpos);
-      sip->si_ends = TRUE;
+      sip->si_ends = true;
     }
     if (sip->si_ends && (sip->si_flags & HL_KEEPEND)) {
       if (maxpos.lnum == 0
@@ -2482,12 +2478,12 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     // No end pattern matched.
     if (SYN_ITEMS(syn_block)[sip->si_idx].sp_flags & HL_ONELINE) {
       // a "oneline" never continues in the next line
-      sip->si_ends = TRUE;
+      sip->si_ends = true;
       sip->si_m_endpos.lnum = current_lnum;
       sip->si_m_endpos.col = (colnr_T)STRLEN(syn_getcurline());
     } else {
       // continues in the next line
-      sip->si_ends = FALSE;
+      sip->si_ends = false;
       sip->si_m_endpos.lnum = 0;
     }
     sip->si_h_endpos = sip->si_m_endpos;
@@ -2496,7 +2492,7 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     sip->si_m_endpos = endpos;
     sip->si_h_endpos = hl_endpos;
     sip->si_eoe_pos = end_endpos;
-    sip->si_ends = TRUE;
+    sip->si_ends = true;
     sip->si_end_idx = end_idx;
   }
 }
@@ -2888,7 +2884,7 @@ static char_u *syn_getcurline(void)
 
 /*
  * Call vim_regexec() to find a match with "rmp" in "syn_buf".
- * Returns TRUE when there is a match.
+ * Returns true when there is a match.
  */
 static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T *st)
 {
@@ -2929,9 +2925,9 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
   if (r > 0) {
     rmp->startpos[0].lnum += lnum;
     rmp->endpos[0].lnum += lnum;
-    return TRUE;
+    return true;
   }
-  return FALSE;
+  return false;
 }
 
 /// Check one position in a line for a matching keyword.
@@ -3471,7 +3467,7 @@ void syn_maybe_enable(void)
 
 /// Handle ":syntax [list]" command: list current syntax words.
 ///
-/// @param syncing  when TRUE: list syncing items
+/// @param syncing  when true: list syncing items
 static void syn_cmd_list(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
@@ -4006,7 +4002,7 @@ static void add_keyword(char_u *const name, const int id, const int flags,
   kp->k_char = conceal_char;
   kp->k_syn.cont_in_list = copy_id_list(cont_in_list);
   if (cont_in_list != NULL) {
-    curwin->w_s->b_syn_containedin = TRUE;
+    curwin->w_s->b_syn_containedin = true;
   }
   kp->next_list = copy_id_list(next_list);
 
@@ -4063,7 +4059,7 @@ static char_u *get_group_name(char_u *arg, char_u **name_end)
 ///
 /// @param arg   next argument to be checked
 /// @param opt   various things
-/// @param skip  TRUE if skipping over command
+/// @param skip  true if skipping over command
 ///
 /// @return      a pointer to the next argument (which isn't an option).
 ///              Return NULL for any error;
@@ -4428,7 +4424,7 @@ error:
 ///
 /// Also ":syntax sync match {name} [[grouphere | groupthere] {group-name}] .."
 ///
-/// @param syncing  TRUE for ":syntax sync match .. "
+/// @param syncing  true for ":syntax sync match .. "
 static void syn_cmd_match(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
@@ -4490,7 +4486,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
         spp->sp_syn.cont_in_list = syn_opt_arg.cont_in_list;
         spp->sp_cchar = conceal_char;
         if (syn_opt_arg.cont_in_list != NULL) {
-          curwin->w_s->b_syn_containedin = TRUE;
+          curwin->w_s->b_syn_containedin = true;
         }
         spp->sp_next_list = syn_opt_arg.next_list;
 
@@ -4526,7 +4522,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
 /// Handle ":syntax region {group-name} [matchgroup={group-name}]
 ///              start {start} .. [skip {skip}] end {end} .. [{options}]".
 ///
-/// @param syncing  TRUE for ":syntax sync region .."
+/// @param syncing  true for ":syntax sync region .."
 static void syn_cmd_region(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
@@ -4705,7 +4701,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
               SYN_ITEMS(curwin->w_s)[idx].sp_syn.cont_in_list =
                 syn_opt_arg.cont_in_list;
               if (syn_opt_arg.cont_in_list != NULL) {
-                curwin->w_s->b_syn_containedin = TRUE;
+                curwin->w_s->b_syn_containedin = true;
               }
               SYN_ITEMS(curwin->w_s)[idx].sp_next_list =
                 syn_opt_arg.next_list;
@@ -5154,7 +5150,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
   char *cpo_save;
 
   if (ends_excmd(*arg_start)) {
-    syn_cmd_list(eap, TRUE);
+    syn_cmd_list(eap, true);
     return;
   }
 
@@ -5189,7 +5185,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
         arg_end = (char *)key + 9;
       }
       if (arg_end[-1] != '=' || !ascii_isdigit(*arg_end)) {
-        illegal = TRUE;
+        illegal = true;
         break;
       }
       linenr_T n = getdigits_int32(&arg_end, false, 0);
@@ -5214,7 +5210,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
       }
       if (curwin->w_s->b_syn_linecont_pat != NULL) {
         emsg(_("E403: syntax sync: line continuations pattern specified twice"));
-        finished = TRUE;
+        finished = true;
         break;
       }
       arg_end = (char *)skip_regexp(next_arg + 1, *next_arg, true, NULL);
@@ -5247,15 +5243,15 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
     } else {
       eap->arg = (char *)next_arg;
       if (STRCMP(key, "MATCH") == 0) {
-        syn_cmd_match(eap, TRUE);
+        syn_cmd_match(eap, true);
       } else if (STRCMP(key, "REGION") == 0) {
-        syn_cmd_region(eap, TRUE);
+        syn_cmd_region(eap, true);
       } else if (STRCMP(key, "CLEAR") == 0) {
-        syn_cmd_clear(eap, TRUE);
+        syn_cmd_clear(eap, true);
       } else {
-        illegal = TRUE;
+        illegal = true;
       }
-      finished = TRUE;
+      finished = true;
       break;
     }
     arg_start = next_arg;
@@ -5364,7 +5360,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
             break;
           }
 
-          regmatch.rm_ic = TRUE;
+          regmatch.rm_ic = true;
           id = 0;
           for (int i = highlight_num_groups(); --i >= 0;) {
             if (vim_regexec(&regmatch, (char *)highlight_group_name(i), (colnr_T)0)) {
@@ -5472,7 +5468,7 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
   static int depth = 0;
   int r;
 
-  // If ssp has a "containedin" list and "cur_si" is in it, return TRUE.
+  // If ssp has a "containedin" list and "cur_si" is in it, return true.
   if (cur_si != NULL && ssp->cont_in_list != NULL
       && !(cur_si->si_flags & HL_MATCH)) {
     // Ignore transparent items without a contains argument.  Double check
@@ -5486,12 +5482,12 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
                                           &(SYN_ITEMS(syn_block)[cur_si->si_idx].sp_syn),
                                           SYN_ITEMS(syn_block)[cur_si->si_idx].sp_flags &
                                           HL_CONTAINED)) {
-      return TRUE;
+      return true;
     }
   }
 
   if (list == NULL) {
-    return FALSE;
+    return false;
   }
 
   /*
@@ -5502,33 +5498,31 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
     return !contained;
   }
 
-  /*
-   * If the first item is "ALLBUT", return TRUE if "id" is NOT in the
-   * contains list.  We also require that "id" is at the same ":syn include"
-   * level as the list.
-   */
+  // If the first item is "ALLBUT", return true if "id" is NOT in the
+  // contains list.  We also require that "id" is at the same ":syn include"
+  // level as the list.
   item = *list;
   if (item >= SYNID_ALLBUT && item < SYNID_CLUSTER) {
     if (item < SYNID_TOP) {
       // ALL or ALLBUT: accept all groups in the same file
       if (item - SYNID_ALLBUT != ssp->inc_tag) {
-        return FALSE;
+        return false;
       }
     } else if (item < SYNID_CONTAINED) {
       // TOP: accept all not-contained groups in the same file
       if (item - SYNID_TOP != ssp->inc_tag || contained) {
-        return FALSE;
+        return false;
       }
     } else {
       // CONTAINED: accept all contained groups in the same file
       if (item - SYNID_CONTAINED != ssp->inc_tag || !contained) {
-        return FALSE;
+        return false;
       }
     }
     item = *++list;
-    retval = FALSE;
+    retval = false;
   } else {
-    retval = TRUE;
+    retval = true;
   }
 
   /*
@@ -5832,7 +5826,7 @@ int syn_get_stack_item(int i)
 {
   if (i >= current_state.ga_len) {
     // Need to invalidate the state, because we didn't properly finish it
-    // for the last character, "keep_state" was TRUE.
+    // for the last character, "keep_state" was true.
     invalidate_current_state();
     current_col = MAXCOL;
     return -1;
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index ad00c3dafc..7d3d0f7905 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1409,7 +1409,7 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
 
   int cmplen;
   int match;                    // matches
-  int match_no_ic = 0;          // matches with rm_ic == FALSE
+  int match_no_ic = 0;          // matches with rm_ic == false
   int match_re;                 // match with regexp
   int matchoff = 0;
   int save_emsg_off;
@@ -1441,7 +1441,7 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
   int help_only = (flags & TAG_HELP);
   int name_only = (flags & TAG_NAMES);
   int noic = (flags & TAG_NOIC);
-  int get_it_again = FALSE;
+  int get_it_again = false;
   int use_cscope = (flags & TAG_CSCOPE);
   int verbose = (flags & TAG_VERBOSE);
   int use_tfu = ((flags & TAG_NO_TAGFUNC) == 0);
@@ -1514,7 +1514,7 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
   }
 
   save_emsg_off = emsg_off;
-  emsg_off = TRUE;    // don't want error for invalid RE here
+  emsg_off = true;    // don't want error for invalid RE here
   prepare_pats(&orgpat, has_re);
   emsg_off = save_emsg_off;
   if (has_re && orgpat.regmatch.regprog == NULL) {
@@ -2009,7 +2009,7 @@ parse_line:
         }
         // if tag length does not match, don't try comparing
         if (orgpat.len != cmplen) {
-          match = FALSE;
+          match = false;
         } else {
           if (orgpat.regmatch.rm_ic) {
             assert(cmplen >= 0);
@@ -2026,7 +2026,7 @@ parse_line:
         /*
          * Has a regexp: Also find tags matching regexp.
          */
-        match_re = FALSE;
+        match_re = false;
         if (!match && orgpat.regmatch.regprog != NULL) {
           int cc;
 
@@ -2236,7 +2236,7 @@ parse_line:
     if (use_cscope) {
       break;
     }
-    orgpat.regmatch.rm_ic = TRUE;       // try another time while ignoring case
+    orgpat.regmatch.rm_ic = true;       // try another time while ignoring case
   }
 
   if (!stop_searching) {
@@ -2334,7 +2334,7 @@ void free_tag_stuff(void)
 /// For help files, use "tags" file only.
 ///
 /// @param tnp  holds status info
-/// @param first  TRUE when first file name is wanted
+/// @param first  true when first file name is wanted
 /// @param buf  pointer to buffer of MAXPATHL chars
 ///
 /// @return  FAIL if no more tag file names, OK otherwise.
@@ -2395,8 +2395,8 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
   /*
    * Loop until we have found a file name that can be used.
    * There are two states:
-   * tnp->tn_did_filefind_init == FALSE: setup for next part in 'tags'.
-   * tnp->tn_did_filefind_init == TRUE: find next file in this part.
+   * tnp->tn_did_filefind_init == false: setup for next part in 'tags'.
+   * tnp->tn_did_filefind_init == true: find next file in this part.
    */
   for (;;) {
     if (tnp->tn_did_filefind_init) {
@@ -2405,7 +2405,7 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
         break;
       }
 
-      tnp->tn_did_filefind_init = FALSE;
+      tnp->tn_did_filefind_init = false;
     } else {
       char_u *filename = NULL;
 
@@ -2431,11 +2431,11 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
 
       tnp->tn_search_ctx = vim_findfile_init(buf, filename,
                                              r_ptr, 100,
-                                             FALSE,                   // don't free visited list
+                                             false,                   // don't free visited list
                                              FINDFILE_FILE,           // we search for a file
                                              tnp->tn_search_ctx, true, (char_u *)curbuf->b_ffname);
       if (tnp->tn_search_ctx != NULL) {
-        tnp->tn_did_filefind_init = TRUE;
+        tnp->tn_did_filefind_init = true;
       }
     }
   }
@@ -2459,7 +2459,7 @@ void tagname_free(tagname_T *tnp)
 /// Parse one line from the tags file. Find start/end of tag name, start/end of
 /// file name and start of search pattern.
 ///
-/// If is_etag is TRUE, tagp->fname and tagp->fname_end are not set.
+/// If is_etag is true, tagp->fname and tagp->fname_end are not set.
 ///
 /// @param lbuf  line to be parsed
 ///
@@ -2510,8 +2510,8 @@ static int parse_tag_line(char_u *lbuf, tagptrs_T *tagp)
  * Static tags produced by the new ctags program have the format:
  *      'tag  file  /pattern/;"<Tab>file:'          "
  *
- * Return TRUE if it is a static tag and adjust *tagname to the real tag.
- * Return FALSE if it is not a static tag.
+ * Return true if it is a static tag and adjust *tagname to the real tag.
+ * Return false if it is not a static tag.
  */
 static bool test_for_static(tagptrs_T *tagp)
 {
@@ -2522,11 +2522,11 @@ static bool test_for_static(tagptrs_T *tagp)
   while ((p = (char_u *)vim_strchr((char *)p, '\t')) != NULL) {
     p++;
     if (STRNCMP(p, "file:", 5) == 0) {
-      return TRUE;
+      return true;
     }
   }
 
-  return FALSE;
+  return false;
 }
 
 // Returns the length of a matching tag line.
@@ -2640,7 +2640,7 @@ static char_u *tag_full_fname(tagptrs_T *tagp)
 ///
 /// @param lbuf_arg  line from the tags file for this tag
 /// @param forceit  :ta with !
-/// @param keep_help  keep help flag (FALSE for cscope)
+/// @param keep_help  keep help flag (false for cscope)
 ///
 /// @return  OK for success, NOTAGFILE when file not found, FAIL otherwise.
 static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
@@ -2732,7 +2732,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
      * into a fullpath
      */
     if (!curwin->w_p_pvw) {
-      full_fname = (char_u *)FullName_save((char *)fname, FALSE);
+      full_fname = (char_u *)FullName_save((char *)fname, false);
       fname = full_fname;
 
       /*
@@ -2825,15 +2825,15 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
      */
     str = pbuf;
     if (pbuf[0] == '/' || pbuf[0] == '?') {
-      str = skip_regexp(pbuf + 1, pbuf[0], FALSE, NULL) + 1;
+      str = skip_regexp(pbuf + 1, pbuf[0], false, NULL) + 1;
     }
     if (str > pbuf_end - 1) {   // search command with nothing following
       save_p_ws = p_ws;
       save_p_ic = p_ic;
       save_p_scs = p_scs;
       p_ws = true;              // need 'wrapscan' for backward searches
-      p_ic = FALSE;             // don't ignore case now
-      p_scs = FALSE;
+      p_ic = false;             // don't ignore case now
+      p_scs = false;
       save_lnum = curwin->w_cursor.lnum;
       if (tagp.tagline > 0) {
         // start search before line from "line:" field
@@ -3014,13 +3014,13 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
 /*
  * Check if we have a tag for the buffer with name "buf_ffname".
  * This is a bit slow, because of the full path compare in path_full_compare().
- * Return TRUE if tag for file "fname" if tag file "tag_fname" is for current
+ * Return true if tag for file "fname" if tag file "tag_fname" is for current
  * file.
  */
 static int test_for_current(char_u *fname, char_u *fname_end, char_u *tag_fname, char_u *buf_ffname)
 {
   int c;
-  int retval = FALSE;
+  int retval = false;
   char_u *fullname;
 
   if (buf_ffname != NULL) {     // if the buffer has a name
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index e130db69f2..834aad2872 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -106,7 +106,7 @@ static struct {
 /// Return NULL if there is no matching command.
 ///
 /// @param *p      end of the command (possibly including count)
-/// @param full    set to TRUE for a full match
+/// @param full    set to true for a full match
 /// @param xp      used for completion, NULL otherwise
 /// @param complp  completion flags or NULL
 char *find_ucmd(exarg_T *eap, char *p, int *full, expand_T *xp, int *complp)
diff --git a/src/nvim/version.c b/src/nvim/version.c
index 0e0aac0354..ac55066c7f 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2016,7 +2016,7 @@ void ex_version(exarg_T *eap)
 
 /// Output a string for the version message.  If it's going to wrap, output a
 /// newline, unless the message is too long to fit on the screen anyway.
-/// When "wrap" is TRUE wrap the string in [].
+/// When "wrap" is true wrap the string in [].
 /// @param s
 /// @param wrap
 static void version_msg_wrap(char *s, int wrap)
@@ -2209,7 +2209,7 @@ void maybe_intro_message(void)
 /// Only used when starting Vim on an empty file, without a file name.
 /// Or with the ":intro" command (for Sven :-).
 ///
-/// @param colon TRUE for ":intro"
+/// @param colon true for ":intro"
 void intro_message(int colon)
 {
   int i;
@@ -2326,6 +2326,6 @@ static void do_intro_line(long row, char_u *mesg, int attr)
 void ex_intro(exarg_T *eap)
 {
   screenclear();
-  intro_message(TRUE);
-  wait_return(TRUE);
+  intro_message(true);
+  wait_return(true);
 }
diff --git a/src/nvim/vim.h b/src/nvim/vim.h
index 09b949bb20..3e12d8b0b4 100644
--- a/src/nvim/vim.h
+++ b/src/nvim/vim.h
@@ -167,15 +167,6 @@ enum {
 #define MIN_SWAP_PAGE_SIZE 1048
 #define MAX_SWAP_PAGE_SIZE 50000
 
-// Boolean constants
-
-#ifndef TRUE
-# define FALSE  0           // note: this is an int, not a long!
-# define TRUE   1
-#endif
-
-#define MAYBE   2           // sometimes used for a variant on TRUE
-
 #define STATUS_HEIGHT   1       // height of a status line under a window
 #define QF_WINHEIGHT    10      // default height for quickfix window
 
diff --git a/src/nvim/window.c b/src/nvim/window.c
index aa275d1182..ffbb0fa27f 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -1299,9 +1299,9 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
   } else {
     curfrp = oldwin->w_frame;
     if (flags & WSP_BELOW) {
-      before = FALSE;
+      before = false;
     } else if (flags & WSP_ABOVE) {
-      before = TRUE;
+      before = true;
     } else if (flags & WSP_VERT) {
       before = !p_spr;
     } else {
@@ -3096,7 +3096,7 @@ void win_free_all(void)
   cmdwin_type = 0;
 
   while (first_tabpage->tp_next != NULL) {
-    tabpage_close(TRUE);
+    tabpage_close(true);
   }
 
   while (lastwin != NULL && lastwin->w_floating) {
@@ -4025,7 +4025,7 @@ static tabpage_T *alloc_tabpage(void)
   // Init t: variables.
   tp->tp_vars = tv_dict_alloc();
   init_var_dict(tp->tp_vars, &tp->tp_winvar, VAR_SCOPE);
-  tp->tp_diff_invalid = TRUE;
+  tp->tp_diff_invalid = true;
   tp->tp_ch_used = p_ch;
 
   return tp;
@@ -4836,7 +4836,7 @@ static void win_enter_ext(win_T *const wp, const int flags)
   }
   if (!curwin_invalid) {
     prevwin = curwin;           // remember for CTRL-W p
-    curwin->w_redr_status = TRUE;
+    curwin->w_redr_status = true;
   }
   curwin = wp;
   curbuf = wp->w_buffer;
-- 
cgit 


From 6547f4397fe643f194763306f8fcdfc6f6ce4b24 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 18:49:29 +0800
Subject: vim-patch:8.1.2331: the option.c file is still very big (#19954)

Problem:    The option.c file is still very big.
Solution:   Move a few functions to where they fit better. (Yegappan
            Lakshmanan, closes vim/vim#4895)
https://github.com/vim/vim/commit/7bae0b1bc84a95d565ffab38cf7f82ad21c656b6

vim-patch:9.0.0271: using INIT() in non-header files

Problem:    Using INIT() in non-header files.
Solution:   Remove INIT(). (closes vim/vim#10981)
https://github.com/vim/vim/commit/9b7d2a959646560f5770329f4428c4739eed4656
---
 src/nvim/change.c    |  51 ++++++++++++++++
 src/nvim/ex_getln.c  |  73 ++++++++++++++++++++++
 src/nvim/globals.h   |   1 -
 src/nvim/indent.c    |  41 +++++++++++++
 src/nvim/option.c    | 167 +--------------------------------------------------
 src/nvim/optionstr.c |   1 +
 6 files changed, 169 insertions(+), 165 deletions(-)

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 1d545927ad..9ea970edb5 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -533,6 +533,57 @@ void unchanged(buf_T *buf, int ff, bool always_inc_changedtick)
   }
 }
 
+/// Save the current values of 'fileformat' and 'fileencoding', so that we know
+/// the file must be considered changed when the value is different.
+void save_file_ff(buf_T *buf)
+{
+  buf->b_start_ffc = (unsigned char)(*buf->b_p_ff);
+  buf->b_start_eol = buf->b_p_eol;
+  buf->b_start_bomb = buf->b_p_bomb;
+
+  // Only use free/alloc when necessary, they take time.
+  if (buf->b_start_fenc == NULL
+      || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0) {
+    xfree(buf->b_start_fenc);
+    buf->b_start_fenc = xstrdup(buf->b_p_fenc);
+  }
+}
+
+/// Return true if 'fileformat' and/or 'fileencoding' has a different value
+/// from when editing started (save_file_ff() called).
+/// Also when 'endofline' was changed and 'binary' is set, or when 'bomb' was
+/// changed and 'binary' is not set.
+/// Also when 'endofline' was changed and 'fixeol' is not set.
+/// When "ignore_empty" is true don't consider a new, empty buffer to be
+/// changed.
+bool file_ff_differs(buf_T *buf, bool ignore_empty)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  // In a buffer that was never loaded the options are not valid.
+  if (buf->b_flags & BF_NEVERLOADED) {
+    return false;
+  }
+  if (ignore_empty
+      && (buf->b_flags & BF_NEW)
+      && buf->b_ml.ml_line_count == 1
+      && *ml_get_buf(buf, (linenr_T)1, false) == NUL) {
+    return false;
+  }
+  if (buf->b_start_ffc != *buf->b_p_ff) {
+    return true;
+  }
+  if ((buf->b_p_bin || !buf->b_p_fixeol) && buf->b_start_eol != buf->b_p_eol) {
+    return true;
+  }
+  if (!buf->b_p_bin && buf->b_start_bomb != buf->b_p_bomb) {
+    return true;
+  }
+  if (buf->b_start_fenc == NULL) {
+    return *buf->b_p_fenc != NUL;
+  }
+  return STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0;
+}
+
 /// Insert string "p" at the cursor position.  Stops at a NUL byte.
 /// Handles Replace mode and multi-byte characters.
 void ins_bytes(char *p)
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 6c45fb4ef1..26ed318c10 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -170,6 +170,8 @@ static Array cmdline_block = ARRAY_DICT_INIT;
 /// user interrupting highlight function to not interrupt command-line.
 static bool getln_interrupted_highlight = false;
 
+static int cedit_key = -1;  ///< key value of 'cedit' option
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ex_getln.c.generated.h"
 #endif
@@ -2532,6 +2534,59 @@ char_u *get_cmdprompt(void)
   return ccline.cmdprompt;
 }
 
+/// Read the 'wildmode' option, fill wim_flags[].
+int check_opt_wim(void)
+{
+  char_u new_wim_flags[4];
+  char_u *p;
+  int i;
+  int idx = 0;
+
+  for (i = 0; i < 4; i++) {
+    new_wim_flags[i] = 0;
+  }
+
+  for (p = p_wim; *p; p++) {
+    for (i = 0; ASCII_ISALPHA(p[i]); i++) {}
+    if (p[i] != NUL && p[i] != ',' && p[i] != ':') {
+      return FAIL;
+    }
+    if (i == 7 && STRNCMP(p, "longest", 7) == 0) {
+      new_wim_flags[idx] |= WIM_LONGEST;
+    } else if (i == 4 && STRNCMP(p, "full", 4) == 0) {
+      new_wim_flags[idx] |= WIM_FULL;
+    } else if (i == 4 && STRNCMP(p, "list", 4) == 0) {
+      new_wim_flags[idx] |= WIM_LIST;
+    } else if (i == 8 && STRNCMP(p, "lastused", 8) == 0) {
+      new_wim_flags[idx] |= WIM_BUFLASTUSED;
+    } else {
+      return FAIL;
+    }
+    p += i;
+    if (*p == NUL) {
+      break;
+    }
+    if (*p == ',') {
+      if (idx == 3) {
+        return FAIL;
+      }
+      idx++;
+    }
+  }
+
+  // fill remaining entries with last flag
+  while (idx < 3) {
+    new_wim_flags[idx + 1] = new_wim_flags[idx];
+    idx++;
+  }
+
+  // only when there are no errors, wim_flags[] is changed
+  for (i = 0; i < 4; i++) {
+    wim_flags[i] = new_wim_flags[i];
+  }
+  return OK;
+}
+
 /// Return true when the text must not be changed and we can't switch to
 /// another window or buffer.  True when editing the command line etc.
 bool text_locked(void)
@@ -4026,6 +4081,24 @@ void cmdline_init(void)
   CLEAR_FIELD(ccline);
 }
 
+/// Check value of 'cedit' and set cedit_key.
+/// Returns NULL if value is OK, error message otherwise.
+char *check_cedit(void)
+{
+  int n;
+
+  if (*p_cedit == NUL) {
+    cedit_key = -1;
+  } else {
+    n = string_to_key(p_cedit);
+    if (vim_isprintc(n)) {
+      return e_invarg;
+    }
+    cedit_key = n;
+  }
+  return NULL;
+}
+
 /// Open a window on the current command line and history.  Allow editing in
 /// the window.  Returns when the window is closed.
 /// Returns:
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 37181d02bd..6c83e2f3c3 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -795,7 +795,6 @@ EXTERN char *last_chdir_reason INIT(= NULL);
 EXTERN bool km_stopsel INIT(= false);
 EXTERN bool km_startsel INIT(= false);
 
-EXTERN int cedit_key INIT(= -1);     ///< key value of 'cedit' option
 EXTERN int cmdwin_type INIT(= 0);    ///< type of cmdline window or 0
 EXTERN int cmdwin_result INIT(= 0);  ///< result of cmdline window or 0
 EXTERN int cmdwin_level INIT(= 0);   ///< cmdline recursion level
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index 12fad371ae..c44cd06a2f 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -732,6 +732,47 @@ int get_number_indent(linenr_T lnum)
   return (int)col;
 }
 
+/// This is called when 'breakindentopt' is changed and when a window is
+/// initialized
+bool briopt_check(win_T *wp)
+{
+  int bri_shift = 0;
+  int bri_min = 20;
+  bool bri_sbr = false;
+  int bri_list = 0;
+
+  char *p = wp->w_p_briopt;
+  while (*p != NUL) {
+    if (STRNCMP(p, "shift:", 6) == 0
+        && ((p[6] == '-' && ascii_isdigit(p[7])) || ascii_isdigit(p[6]))) {
+      p += 6;
+      bri_shift = getdigits_int(&p, true, 0);
+    } else if (STRNCMP(p, "min:", 4) == 0 && ascii_isdigit(p[4])) {
+      p += 4;
+      bri_min = getdigits_int(&p, true, 0);
+    } else if (STRNCMP(p, "sbr", 3) == 0) {
+      p += 3;
+      bri_sbr = true;
+    } else if (STRNCMP(p, "list:", 5) == 0) {
+      p += 5;
+      bri_list = (int)getdigits(&p, false, 0);
+    }
+    if (*p != ',' && *p != NUL) {
+      return false;
+    }
+    if (*p == ',') {
+      p++;
+    }
+  }
+
+  wp->w_briopt_shift = bri_shift;
+  wp->w_briopt_min = bri_min;
+  wp->w_briopt_sbr = bri_sbr;
+  wp->w_briopt_list  = bri_list;
+
+  return true;
+}
+
 // Return appropriate space number for breakindent, taking influencing
 // parameters into account. Window must be specified, since it is not
 // necessarily always the current one.
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 6912f93daa..3f7c200928 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -30,6 +30,7 @@
 #include "nvim/arglist.h"
 #include "nvim/ascii.h"
 #include "nvim/buffer.h"
+#include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor_shape.h"
 #include "nvim/decoration_provider.h"
@@ -71,6 +72,7 @@
 #include "nvim/popupmenu.h"
 #include "nvim/regexp.h"
 #include "nvim/screen.h"
+#include "nvim/search.h"
 #include "nvim/spell.h"
 #include "nvim/spellfile.h"
 #include "nvim/spellsuggest.h"
@@ -1600,7 +1602,7 @@ void did_set_option(int opt_idx, int opt_flags, int new_value, int value_checked
 
 /// Convert a key name or string into a key value.
 /// Used for 'wildchar' and 'cedit' options.
-static int string_to_key(char_u *arg)
+int string_to_key(char_u *arg)
 {
   if (*arg == '<') {
     return find_key_option(arg + 1, true);
@@ -1611,24 +1613,6 @@ static int string_to_key(char_u *arg)
   return *arg;
 }
 
-/// Check value of 'cedit' and set cedit_key.
-/// Returns NULL if value is OK, error message otherwise.
-char *check_cedit(void)
-{
-  int n;
-
-  if (*p_cedit == NUL) {
-    cedit_key = -1;
-  } else {
-    n = string_to_key(p_cedit);
-    if (vim_isprintc(n)) {
-      return e_invarg;
-    }
-    cedit_key = n;
-  }
-  return NULL;
-}
-
 // When changing 'title', 'titlestring', 'icon' or 'iconstring', call
 // maketitle() to create and display it.
 // When switching the title or icon off, call ui_set_{icon,title}(NULL) to get
@@ -5364,59 +5348,6 @@ int option_set_callback_func(char_u *optval, Callback *optcb)
   return OK;
 }
 
-/// Read the 'wildmode' option, fill wim_flags[].
-int check_opt_wim(void)
-{
-  char_u new_wim_flags[4];
-  char_u *p;
-  int i;
-  int idx = 0;
-
-  for (i = 0; i < 4; i++) {
-    new_wim_flags[i] = 0;
-  }
-
-  for (p = p_wim; *p; p++) {
-    for (i = 0; ASCII_ISALPHA(p[i]); i++) {}
-    if (p[i] != NUL && p[i] != ',' && p[i] != ':') {
-      return FAIL;
-    }
-    if (i == 7 && STRNCMP(p, "longest", 7) == 0) {
-      new_wim_flags[idx] |= WIM_LONGEST;
-    } else if (i == 4 && STRNCMP(p, "full", 4) == 0) {
-      new_wim_flags[idx] |= WIM_FULL;
-    } else if (i == 4 && STRNCMP(p, "list", 4) == 0) {
-      new_wim_flags[idx] |= WIM_LIST;
-    } else if (i == 8 && STRNCMP(p, "lastused", 8) == 0) {
-      new_wim_flags[idx] |= WIM_BUFLASTUSED;
-    } else {
-      return FAIL;
-    }
-    p += i;
-    if (*p == NUL) {
-      break;
-    }
-    if (*p == ',') {
-      if (idx == 3) {
-        return FAIL;
-      }
-      idx++;
-    }
-  }
-
-  // fill remaining entries with last flag
-  while (idx < 3) {
-    new_wim_flags[idx + 1] = new_wim_flags[idx];
-    idx++;
-  }
-
-  // only when there are no errors, wim_flags[] is changed
-  for (i = 0; i < 4; i++) {
-    wim_flags[i] = new_wim_flags[i];
-  }
-  return OK;
-}
-
 /// Check if backspacing over something is allowed.
 /// @param  what  BS_INDENT, BS_EOL, BS_START, or BS_NOSTOP
 bool can_bs(int what)
@@ -5437,98 +5368,6 @@ bool can_bs(int what)
   return vim_strchr((char *)p_bs, what) != NULL;
 }
 
-/// Save the current values of 'fileformat' and 'fileencoding', so that we know
-/// the file must be considered changed when the value is different.
-void save_file_ff(buf_T *buf)
-{
-  buf->b_start_ffc = (unsigned char)(*buf->b_p_ff);
-  buf->b_start_eol = buf->b_p_eol;
-  buf->b_start_bomb = buf->b_p_bomb;
-
-  // Only use free/alloc when necessary, they take time.
-  if (buf->b_start_fenc == NULL
-      || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0) {
-    xfree(buf->b_start_fenc);
-    buf->b_start_fenc = xstrdup(buf->b_p_fenc);
-  }
-}
-
-/// Return true if 'fileformat' and/or 'fileencoding' has a different value
-/// from when editing started (save_file_ff() called).
-/// Also when 'endofline' was changed and 'binary' is set, or when 'bomb' was
-/// changed and 'binary' is not set.
-/// Also when 'endofline' was changed and 'fixeol' is not set.
-/// When "ignore_empty" is true don't consider a new, empty buffer to be
-/// changed.
-bool file_ff_differs(buf_T *buf, bool ignore_empty)
-  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
-{
-  // In a buffer that was never loaded the options are not valid.
-  if (buf->b_flags & BF_NEVERLOADED) {
-    return false;
-  }
-  if (ignore_empty
-      && (buf->b_flags & BF_NEW)
-      && buf->b_ml.ml_line_count == 1
-      && *ml_get_buf(buf, (linenr_T)1, false) == NUL) {
-    return false;
-  }
-  if (buf->b_start_ffc != *buf->b_p_ff) {
-    return true;
-  }
-  if ((buf->b_p_bin || !buf->b_p_fixeol) && buf->b_start_eol != buf->b_p_eol) {
-    return true;
-  }
-  if (!buf->b_p_bin && buf->b_start_bomb != buf->b_p_bomb) {
-    return true;
-  }
-  if (buf->b_start_fenc == NULL) {
-    return *buf->b_p_fenc != NUL;
-  }
-  return STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0;
-}
-
-/// This is called when 'breakindentopt' is changed and when a window is
-/// initialized
-bool briopt_check(win_T *wp)
-{
-  int bri_shift = 0;
-  int bri_min = 20;
-  bool bri_sbr = false;
-  int bri_list = 0;
-
-  char *p = wp->w_p_briopt;
-  while (*p != NUL) {
-    if (STRNCMP(p, "shift:", 6) == 0
-        && ((p[6] == '-' && ascii_isdigit(p[7])) || ascii_isdigit(p[6]))) {
-      p += 6;
-      bri_shift = getdigits_int(&p, true, 0);
-    } else if (STRNCMP(p, "min:", 4) == 0 && ascii_isdigit(p[4])) {
-      p += 4;
-      bri_min = getdigits_int(&p, true, 0);
-    } else if (STRNCMP(p, "sbr", 3) == 0) {
-      p += 3;
-      bri_sbr = true;
-    } else if (STRNCMP(p, "list:", 5) == 0) {
-      p += 5;
-      bri_list = (int)getdigits(&p, false, 0);
-    }
-    if (*p != ',' && *p != NUL) {
-      return false;
-    }
-    if (*p == ',') {
-      p++;
-    }
-  }
-
-  wp->w_briopt_shift = bri_shift;
-  wp->w_briopt_min = bri_min;
-  wp->w_briopt_sbr = bri_sbr;
-  wp->w_briopt_list  = bri_list;
-
-  return true;
-}
-
 /// Get the local or global value of 'backupcopy'.
 ///
 /// @param buf The buffer.
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index ec62c4b8ad..e4cdf883fe 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -18,6 +18,7 @@
 #include "nvim/drawscreen.h"
 #include "nvim/eval.h"
 #include "nvim/eval/vars.h"
+#include "nvim/ex_getln.h"
 #include "nvim/hardcopy.h"
 #include "nvim/highlight_group.h"
 #include "nvim/indent.h"
-- 
cgit 


From 914ba18a4969c7170bbaef6856b056e4212a1aa7 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Wed, 24 Aug 2022 22:16:37 +0200
Subject: feat(highlight): support scoped @spam.eggs.baked_beans groups

---
 src/nvim/cmdexpand.c             |  2 +-
 src/nvim/highlight_group.c       | 32 +++++++++++++++++++++++++++++---
 src/nvim/testdir/test_syntax.vim | 12 ++++++------
 3 files changed, 36 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index abf36734b9..c16ed37c9a 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -2059,7 +2059,7 @@ static int ExpandOther(expand_T *xp, regmatch_T *rmp, int *num_file, char ***fil
     { EXPAND_MENUNAMES, get_menu_names, false, true },
     { EXPAND_SYNTAX, get_syntax_name, true, true },
     { EXPAND_SYNTIME, get_syntime_arg, true, true },
-    { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, true },
+    { EXPAND_HIGHLIGHT, (ExpandFunc)get_highlight_name, true, false },
     { EXPAND_EVENTS, expand_get_event_name, true, false },
     { EXPAND_AUGROUP, expand_get_augroup_name, true, false },
     { EXPAND_CSCOPE, get_cscope_name, true, true },
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 30c39a3158..4c207fdb53 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -79,6 +79,8 @@ typedef struct {
   int sg_rgb_sp_idx;            ///< RGB special color index
 
   int sg_blend;                 ///< blend level (0-100 inclusive), -1 if unset
+
+  int sg_parent;                ///< parent of @nested.group
 } HlGroup;
 
 enum {
@@ -1375,6 +1377,11 @@ static void highlight_list_one(const int id)
     return;
   }
 
+  // don't list specialized groups if a parent is used instead
+  if (sgp->sg_parent && sgp->sg_cleared) {
+    return;
+  }
+
   didh = highlight_list_arg(id, didh, LIST_ATTR,
                             sgp->sg_cterm, NULL, "cterm");
   didh = highlight_list_arg(id, didh, LIST_INT,
@@ -1661,7 +1668,12 @@ static void set_hl_attr(int idx)
 int syn_name2id(const char *name)
   FUNC_ATTR_NONNULL_ALL
 {
-  return syn_name2id_len(name, STRLEN(name));
+  if (name[0] == '@') {
+    // if we look up @aaa.bbb, we have to consider @aaa as well
+    return syn_check_group(name, strlen(name));
+  } else {
+    return syn_name2id_len(name, STRLEN(name));
+  }
 }
 
 /// Lookup a highlight group name and return its ID.
@@ -1758,6 +1770,14 @@ static int syn_add_group(const char *name, size_t len)
     }
   }
 
+  int scoped_parent = 0;
+  if (len > 1 && name[0] == '@') {
+    char *delim = xmemrchr(name, '.', len);
+    if (delim) {
+      scoped_parent = syn_check_group(name, (size_t)(delim - name));
+    }
+  }
+
   // First call for this growarray: init growing array.
   if (highlight_ga.ga_data == NULL) {
     highlight_ga.ga_itemsize = sizeof(HlGroup);
@@ -1783,6 +1803,9 @@ static int syn_add_group(const char *name, size_t len)
   hlgp->sg_rgb_sp_idx = kColorIdxNone;
   hlgp->sg_blend = -1;
   hlgp->sg_name_u = arena_memdupz(&highlight_arena, name, len);
+  hlgp->sg_parent = scoped_parent;
+  // will get set to false by caller if settings are added
+  hlgp->sg_cleared = true;
   vim_strup((char_u *)hlgp->sg_name_u);
 
   int id = highlight_ga.ga_len;  // ID is index plus one
@@ -1844,10 +1867,13 @@ int syn_ns_get_final_id(int *ns_id, int hl_id)
       continue;
     }
 
-    if (sgp->sg_link == 0 || sgp->sg_link > highlight_ga.ga_len) {
+    if (sgp->sg_link > 0 && sgp->sg_link <= highlight_ga.ga_len) {
+      hl_id = sgp->sg_link;
+    } else if (sgp->sg_cleared && sgp->sg_parent > 0) {
+      hl_id = sgp->sg_parent;
+    } else {
       break;
     }
-    hl_id = sgp->sg_link;
   }
 
   return hl_id;
diff --git a/src/nvim/testdir/test_syntax.vim b/src/nvim/testdir/test_syntax.vim
index af93a37739..85f27dd043 100644
--- a/src/nvim/testdir/test_syntax.vim
+++ b/src/nvim/testdir/test_syntax.vim
@@ -188,22 +188,22 @@ func Test_syntax_completion()
   call assert_equal('"syn sync ccomment clear fromstart linebreaks= linecont lines= match maxlines= minlines= region', @:)
 
   " Check that clearing "Aap" avoids it showing up before Boolean.
-  hi Aap ctermfg=blue
+  hi @Aap ctermfg=blue
   call feedkeys(":syn list \<C-A>\<C-B>\"\<CR>", 'tx')
-  call assert_match('^"syn list Aap Boolean Character ', @:)
-  hi clear Aap
+  call assert_match('^"syn list @Aap @boolean @character ', @:)
+  hi clear @Aap
 
   call feedkeys(":syn list \<C-A>\<C-B>\"\<CR>", 'tx')
-  call assert_match('^"syn list Boolean Character ', @:)
+  call assert_match('^"syn list @boolean @character ', @:)
 
   call feedkeys(":syn match \<C-A>\<C-B>\"\<CR>", 'tx')
-  call assert_match('^"syn match Boolean Character ', @:)
+  call assert_match('^"syn match @boolean @character ', @:)
 endfunc
 
 func Test_echohl_completion()
   call feedkeys(":echohl no\<C-A>\<C-B>\"\<CR>", 'tx')
   " call assert_equal('"echohl NonText Normal none', @:)
-  call assert_equal('"echohl NonText Normal NormalFloat NormalNC none', @:)
+  call assert_equal('"echohl NonText Normal NormalFloat none', @:)
 endfunc
 
 func Test_syntax_arg_skipped()
-- 
cgit 


From 030b422d1e9517ed1b1c70fd8002b74881c80650 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Wed, 24 Aug 2022 23:48:52 +0200
Subject: feat(treesitter)!: use @foo.bar style highlight groups

This removes the support for defining links via
vim.treesitter.highlighter.hl_map (never documented, but plugins did
anyway), or the uppercase-only `@FooGroup.Bar` to `FooGroup` rule.

The fallback is now strictly `@foo.bar.lang` to `@foo.bar` to `@foo`,
and casing is irrelevant (as it already was outside of treesitter)

For compatibility, define default links to builting syntax groups
as defined by pre-existing color schemes
---
 src/nvim/highlight_group.c        | 48 +++++++++++++++++++++++++++++++++++++++
 src/nvim/testdir/test_cmdline.vim |  6 ++---
 2 files changed, 50 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 4c207fdb53..7a0c7ba395 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -185,6 +185,54 @@ static const char *highlight_init_both[] = {
   "default link DiagnosticSignWarn DiagnosticWarn",
   "default link DiagnosticSignInfo DiagnosticInfo",
   "default link DiagnosticSignHint DiagnosticHint",
+
+  "default link @error Error",
+  "default link @text.underline Underlined",
+  "default link @todo Todo",
+  "default link @debug Debug",
+
+  // Miscs
+  "default link @comment Comment",
+  "default link @punctuation Delimiter",
+
+  // Constants
+  "default link @constant Constant",
+  "default link @constant.builtin Special",
+  "default link @constant.macro Define",
+  "default link @define Define",
+  "default link @macro Macro",
+  "default link @string String",
+  "default link @string.escape SpecialChar",
+  "default link @character Character",
+  "default link @character.special SpecialChar",
+  "default link @number Number",
+  "default link @boolean Boolean",
+  "default link @float Float",
+
+  // Functions
+  "default link @function Function",
+  "default link @function.builtin Special",
+  "default link @function.macro Macro",
+  "default link @parameter Identifier",
+  "default link @method Function",
+  "default link @field Identifier",
+  "default link @property Identifier",
+  "default link @constructor Special",
+
+  // Keywords
+  "default link @conditional Conditional",
+  "default link @repeat Repeat",
+  "default link @label Label",
+  "default link @operator Operator",
+  "default link @keyword Keyword",
+  "default link @exception Exception",
+
+  "default link @type Type",
+  "default link @type.definition Typedef",
+  "default link @storageclass StorageClass",
+  "default link @structure Structure",
+  "default link @include Include",
+  "default link @preproc PreProc",
   NULL
 };
 
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index 84dc361529..517509004a 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -244,7 +244,7 @@ func Test_match_completion()
     return
   endif
   hi Aardig ctermfg=green
-  call feedkeys(":match \<Tab>\<Home>\"\<CR>", 'xt')
+  call feedkeys(":match A\<Tab>\<Home>\"\<CR>", 'xt')
   call assert_equal('"match Aardig', getreg(':'))
   call feedkeys(":match \<S-Tab>\<Home>\"\<CR>", 'xt')
   call assert_equal('"match none', getreg(':'))
@@ -255,9 +255,7 @@ func Test_highlight_completion()
     return
   endif
   hi Aardig ctermfg=green
-  call feedkeys(":hi \<Tab>\<Home>\"\<CR>", 'xt')
-  call assert_equal('"hi Aardig', getreg(':'))
-  call feedkeys(":hi default \<Tab>\<Home>\"\<CR>", 'xt')
+  call feedkeys(":hi default A\<Tab>\<Home>\"\<CR>", 'xt')
   call assert_equal('"hi default Aardig', getreg(':'))
   call feedkeys(":hi clear Aa\<Tab>\<Home>\"\<CR>", 'xt')
   call assert_equal('"hi clear Aardig', getreg(':'))
-- 
cgit 


From 0b72e23bf13ade1e76d11eae6990014098b3928d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 22:37:20 +0800
Subject: vim-patch:8.2.0674: some source files are too big (#19959)

Problem:    Some source files are too big.
Solution:   Move text formatting functions to a new file. (Yegappan
            Lakshmanan, closes vim/vim#6021)
https://github.com/vim/vim/commit/11abd095210fc84e5dcee87b9baed86061caefe4

Cherry-pick set_can_cindent() from patch 8.1.2062.
Cherry-pick global old_indent from patch 8.2.2127.
---
 src/nvim/change.c     |    1 +
 src/nvim/edit.c       |  606 +-------------------------
 src/nvim/getchar.c    |   28 ++
 src/nvim/globals.h    |    2 +
 src/nvim/indent.c     |    1 +
 src/nvim/insexpand.c  |    1 +
 src/nvim/normal.c     |    1 +
 src/nvim/ops.c        |  550 +-----------------------
 src/nvim/option.c     |   11 -
 src/nvim/textformat.c | 1122 +++++++++++++++++++++++++++++++++++++++++++++++++
 src/nvim/textformat.h |   12 +
 11 files changed, 1176 insertions(+), 1159 deletions(-)
 create mode 100644 src/nvim/textformat.c
 create mode 100644 src/nvim/textformat.h

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 9ea970edb5..04dfb20a1b 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -26,6 +26,7 @@
 #include "nvim/plines.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
+#include "nvim/textformat.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 82429d6542..d9aec2fbad 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -56,6 +56,7 @@
 #include "nvim/strings.h"
 #include "nvim/syntax.h"
 #include "nvim/terminal.h"
+#include "nvim/textformat.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
@@ -108,8 +109,6 @@ static int did_restart_edit;            // "restart_edit" when calling edit()
 
 static bool can_cindent;                // may do cindenting on this line
 
-static int old_indent = 0;              // for ^^D command in insert mode
-
 static int revins_on;                   // reverse insert mode on
 static int revins_chars;                // how much to skip after edit
 static int revins_legal;                // was the last char 'legal'?
@@ -119,8 +118,6 @@ static bool ins_need_undo;              // call u_save() before inserting a
                                         // char.  Set when edit() is called.
                                         // after that arrow_used is used.
 
-static bool did_add_space = false;      // auto_format() added an extra space
-                                        // under the cursor
 static TriState dont_sync_undo = kFalse;  // CTRL-G U prevents syncing undo
                                           // for the next left/right cursor key
 
@@ -1561,7 +1558,7 @@ void display_dollar(colnr_T col)
  * Call this function before moving the cursor from the normal insert position
  * in insert mode.
  */
-static void undisplay_dollar(void)
+void undisplay_dollar(void)
 {
   if (dollar_vcol >= 0) {
     dollar_vcol = -1;
@@ -2012,9 +2009,6 @@ static void insert_special(int c, int allow_modmask, int ctrlv)
  */
 #define ISSPECIAL(c)   ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^')
 
-#define WHITECHAR(cc) (ascii_iswhite(cc) \
-                       && !utf_iscomposing(utf_ptr2char((char *)get_cursor_pos_ptr() + 1)))
-
 ///
 /// "flags": INSCHAR_FORMAT - force formatting
 ///          INSCHAR_CTRLV  - char typed just after CTRL-V
@@ -2213,597 +2207,6 @@ void insertchar(int c, int flags, int second_indent)
   }
 }
 
-/// Format text at the current insert position.
-///
-/// If the INSCHAR_COM_LIST flag is present, then the value of second_indent
-/// will be the comment leader length sent to open_line().
-///
-/// @param c  character to be inserted (can be NUL)
-static void internal_format(int textwidth, int second_indent, int flags, int format_only, int c)
-{
-  int cc;
-  int save_char = NUL;
-  bool haveto_redraw = false;
-  const bool fo_ins_blank = has_format_option(FO_INS_BLANK);
-  const bool fo_multibyte = has_format_option(FO_MBYTE_BREAK);
-  const bool fo_rigor_tw  = has_format_option(FO_RIGOROUS_TW);
-  const bool fo_white_par = has_format_option(FO_WHITE_PAR);
-  bool first_line = true;
-  colnr_T leader_len;
-  bool no_leader = false;
-  int do_comments = (flags & INSCHAR_DO_COM);
-  int has_lbr = curwin->w_p_lbr;
-
-  // make sure win_lbr_chartabsize() counts correctly
-  curwin->w_p_lbr = false;
-
-  /*
-   * When 'ai' is off we don't want a space under the cursor to be
-   * deleted.  Replace it with an 'x' temporarily.
-   */
-  if (!curbuf->b_p_ai
-      && !(State & VREPLACE_FLAG)) {
-    cc = gchar_cursor();
-    if (ascii_iswhite(cc)) {
-      save_char = cc;
-      pchar_cursor('x');
-    }
-  }
-
-  /*
-   * Repeat breaking lines, until the current line is not too long.
-   */
-  while (!got_int) {
-    int startcol;                       // Cursor column at entry
-    int wantcol;                        // column at textwidth border
-    int foundcol;                       // column for start of spaces
-    int end_foundcol = 0;               // column for start of word
-    colnr_T len;
-    colnr_T virtcol;
-    int orig_col = 0;
-    char_u *saved_text = NULL;
-    colnr_T col;
-    colnr_T end_col;
-    bool did_do_comment = false;
-
-    virtcol = get_nolist_virtcol()
-              + char2cells(c != NUL ? c : gchar_cursor());
-    if (virtcol <= (colnr_T)textwidth) {
-      break;
-    }
-
-    if (no_leader) {
-      do_comments = false;
-    } else if (!(flags & INSCHAR_FORMAT)
-               && has_format_option(FO_WRAP_COMS)) {
-      do_comments = true;
-    }
-
-    // Don't break until after the comment leader
-    if (do_comments) {
-      char_u *line = get_cursor_line_ptr();
-      leader_len = get_leader_len((char *)line, NULL, false, true);
-      if (leader_len == 0 && curbuf->b_p_cin) {
-        // Check for a line comment after code.
-        int comment_start = check_linecomment(line);
-        if (comment_start != MAXCOL) {
-          leader_len = get_leader_len((char *)line + comment_start, NULL, false, true);
-          if (leader_len != 0) {
-            leader_len += comment_start;
-          }
-        }
-      }
-    } else {
-      leader_len = 0;
-    }
-
-    // If the line doesn't start with a comment leader, then don't
-    // start one in a following broken line.  Avoids that a %word
-    // moved to the start of the next line causes all following lines
-    // to start with %.
-    if (leader_len == 0) {
-      no_leader = true;
-    }
-    if (!(flags & INSCHAR_FORMAT)
-        && leader_len == 0
-        && !has_format_option(FO_WRAP)) {
-      break;
-    }
-    if ((startcol = curwin->w_cursor.col) == 0) {
-      break;
-    }
-
-    // find column of textwidth border
-    coladvance((colnr_T)textwidth);
-    wantcol = curwin->w_cursor.col;
-
-    curwin->w_cursor.col = startcol;
-    foundcol = 0;
-    int skip_pos = 0;
-
-    /*
-     * Find position to break at.
-     * Stop at first entered white when 'formatoptions' has 'v'
-     */
-    while ((!fo_ins_blank && !has_format_option(FO_INS_VI))
-           || (flags & INSCHAR_FORMAT)
-           || curwin->w_cursor.lnum != Insstart.lnum
-           || curwin->w_cursor.col >= Insstart.col) {
-      if (curwin->w_cursor.col == startcol && c != NUL) {
-        cc = c;
-      } else {
-        cc = gchar_cursor();
-      }
-      if (WHITECHAR(cc)) {
-        // remember position of blank just before text
-        end_col = curwin->w_cursor.col;
-
-        // find start of sequence of blanks
-        int wcc = 0;  // counter for whitespace chars
-        while (curwin->w_cursor.col > 0 && WHITECHAR(cc)) {
-          dec_cursor();
-          cc = gchar_cursor();
-
-          // Increment count of how many whitespace chars in this
-          // group; we only need to know if it's more than one.
-          if (wcc < 2) {
-            wcc++;
-          }
-        }
-        if (curwin->w_cursor.col == 0 && WHITECHAR(cc)) {
-          break;                        // only spaces in front of text
-        }
-
-        // Don't break after a period when 'formatoptions' has 'p' and
-        // there are less than two spaces.
-        if (has_format_option(FO_PERIOD_ABBR) && cc == '.' && wcc < 2) {
-          continue;
-        }
-
-        // Don't break until after the comment leader
-        if (curwin->w_cursor.col < leader_len) {
-          break;
-        }
-
-        if (has_format_option(FO_ONE_LETTER)) {
-          // do not break after one-letter words
-          if (curwin->w_cursor.col == 0) {
-            break;              // one-letter word at begin
-          }
-          // do not break "#a b" when 'tw' is 2
-          if (curwin->w_cursor.col <= leader_len) {
-            break;
-          }
-          col = curwin->w_cursor.col;
-          dec_cursor();
-          cc = gchar_cursor();
-
-          if (WHITECHAR(cc)) {
-            continue;                   // one-letter, continue
-          }
-          curwin->w_cursor.col = col;
-        }
-
-        inc_cursor();
-
-        end_foundcol = end_col + 1;
-        foundcol = curwin->w_cursor.col;
-        if (curwin->w_cursor.col <= (colnr_T)wantcol) {
-          break;
-        }
-      } else if ((cc >= 0x100 || !utf_allow_break_before(cc)) && fo_multibyte) {
-        int ncc;
-        bool allow_break;
-
-        // Break after or before a multi-byte character.
-        if (curwin->w_cursor.col != startcol) {
-          // Don't break until after the comment leader
-          if (curwin->w_cursor.col < leader_len) {
-            break;
-          }
-          col = curwin->w_cursor.col;
-          inc_cursor();
-          ncc = gchar_cursor();
-          allow_break = utf_allow_break(cc, ncc);
-
-          // If we have already checked this position, skip!
-          if (curwin->w_cursor.col != skip_pos && allow_break) {
-            foundcol = curwin->w_cursor.col;
-            end_foundcol = foundcol;
-            if (curwin->w_cursor.col <= (colnr_T)wantcol) {
-              break;
-            }
-          }
-          curwin->w_cursor.col = col;
-        }
-
-        if (curwin->w_cursor.col == 0) {
-          break;
-        }
-
-        ncc = cc;
-        col = curwin->w_cursor.col;
-
-        dec_cursor();
-        cc = gchar_cursor();
-
-        if (WHITECHAR(cc)) {
-          continue;                     // break with space
-        }
-        // Don't break until after the comment leader.
-        if (curwin->w_cursor.col < leader_len) {
-          break;
-        }
-
-        curwin->w_cursor.col = col;
-        skip_pos = curwin->w_cursor.col;
-
-        allow_break = utf_allow_break(cc, ncc);
-
-        // Must handle this to respect line break prohibition.
-        if (allow_break) {
-          foundcol = curwin->w_cursor.col;
-          end_foundcol = foundcol;
-        }
-        if (curwin->w_cursor.col <= (colnr_T)wantcol) {
-          const bool ncc_allow_break = utf_allow_break_before(ncc);
-
-          if (allow_break) {
-            break;
-          }
-          if (!ncc_allow_break && !fo_rigor_tw) {
-            // Enable at most 1 punct hang outside of textwidth.
-            if (curwin->w_cursor.col == startcol) {
-              // We are inserting a non-breakable char, postpone
-              // line break check to next insert.
-              end_foundcol = foundcol = 0;
-              break;
-            }
-
-            // Neither cc nor ncc is NUL if we are here, so
-            // it's safe to inc_cursor.
-            col = curwin->w_cursor.col;
-
-            inc_cursor();
-            cc  = ncc;
-            ncc = gchar_cursor();
-            // handle insert
-            ncc = (ncc != NUL) ? ncc : c;
-
-            allow_break = utf_allow_break(cc, ncc);
-
-            if (allow_break) {
-              // Break only when we are not at end of line.
-              end_foundcol = foundcol = ncc == NUL? 0 : curwin->w_cursor.col;
-              break;
-            }
-            curwin->w_cursor.col = col;
-          }
-        }
-      }
-      if (curwin->w_cursor.col == 0) {
-        break;
-      }
-      dec_cursor();
-    }
-
-    if (foundcol == 0) {                // no spaces, cannot break line
-      curwin->w_cursor.col = startcol;
-      break;
-    }
-
-    // Going to break the line, remove any "$" now.
-    undisplay_dollar();
-
-    // Offset between cursor position and line break is used by replace
-    // stack functions.  MODE_VREPLACE does not use this, and backspaces
-    // over the text instead.
-    if (State & VREPLACE_FLAG) {
-      orig_col = startcol;              // Will start backspacing from here
-    } else {
-      replace_offset = startcol - end_foundcol;
-    }
-
-    /*
-     * adjust startcol for spaces that will be deleted and
-     * characters that will remain on top line
-     */
-    curwin->w_cursor.col = foundcol;
-    while ((cc = gchar_cursor(), WHITECHAR(cc))
-           && (!fo_white_par || curwin->w_cursor.col < startcol)) {
-      inc_cursor();
-    }
-    startcol -= curwin->w_cursor.col;
-    if (startcol < 0) {
-      startcol = 0;
-    }
-
-    if (State & VREPLACE_FLAG) {
-      // In MODE_VREPLACE state, we will backspace over the text to be
-      // wrapped, so save a copy now to put on the next line.
-      saved_text = vim_strsave(get_cursor_pos_ptr());
-      curwin->w_cursor.col = orig_col;
-      saved_text[startcol] = NUL;
-
-      // Backspace over characters that will move to the next line
-      if (!fo_white_par) {
-        backspace_until_column(foundcol);
-      }
-    } else {
-      // put cursor after pos. to break line
-      if (!fo_white_par) {
-        curwin->w_cursor.col = foundcol;
-      }
-    }
-
-    /*
-     * Split the line just before the margin.
-     * Only insert/delete lines, but don't really redraw the window.
-     */
-    open_line(FORWARD, OPENLINE_DELSPACES + OPENLINE_MARKFIX
-              + (fo_white_par ? OPENLINE_KEEPTRAIL : 0)
-              + (do_comments ? OPENLINE_DO_COM : 0)
-              + OPENLINE_FORMAT
-              + ((flags & INSCHAR_COM_LIST) ? OPENLINE_COM_LIST : 0),
-              ((flags & INSCHAR_COM_LIST) ? second_indent : old_indent),
-              &did_do_comment);
-    if (!(flags & INSCHAR_COM_LIST)) {
-      old_indent = 0;
-    }
-
-    // If a comment leader was inserted, may also do this on a following
-    // line.
-    if (did_do_comment) {
-      no_leader = false;
-    }
-
-    replace_offset = 0;
-    if (first_line) {
-      if (!(flags & INSCHAR_COM_LIST)) {
-        // This section is for auto-wrap of numeric lists.  When not
-        // in insert mode (i.e. format_lines()), the INSCHAR_COM_LIST
-        // flag will be set and open_line() will handle it (as seen
-        // above).  The code here (and in get_number_indent()) will
-        // recognize comments if needed...
-        if (second_indent < 0 && has_format_option(FO_Q_NUMBER)) {
-          second_indent = get_number_indent(curwin->w_cursor.lnum - 1);
-        }
-        if (second_indent >= 0) {
-          if (State & VREPLACE_FLAG) {
-            change_indent(INDENT_SET, second_indent, false, NUL, true);
-          } else if (leader_len > 0 && second_indent - leader_len > 0) {
-            int padding = second_indent - leader_len;
-
-            // We started at the first_line of a numbered list
-            // that has a comment.  the open_line() function has
-            // inserted the proper comment leader and positioned
-            // the cursor at the end of the split line.  Now we
-            // add the additional whitespace needed after the
-            // comment leader for the numbered list.
-            for (int i = 0; i < padding; i++) {
-              ins_str((char_u *)" ");
-            }
-            changed_bytes(curwin->w_cursor.lnum, leader_len);
-          } else {
-            (void)set_indent(second_indent, SIN_CHANGED);
-          }
-        }
-      }
-      first_line = false;
-    }
-
-    if (State & VREPLACE_FLAG) {
-      // In MODE_VREPLACE state we have backspaced over the text to be
-      // moved, now we re-insert it into the new line.
-      ins_bytes((char *)saved_text);
-      xfree(saved_text);
-    } else {
-      /*
-       * Check if cursor is not past the NUL off the line, cindent
-       * may have added or removed indent.
-       */
-      curwin->w_cursor.col += startcol;
-      len = (colnr_T)STRLEN(get_cursor_line_ptr());
-      if (curwin->w_cursor.col > len) {
-        curwin->w_cursor.col = len;
-      }
-    }
-
-    haveto_redraw = true;
-    can_cindent = true;
-    // moved the cursor, don't autoindent or cindent now
-    did_ai = false;
-    did_si = false;
-    can_si = false;
-    can_si_back = false;
-    line_breakcheck();
-  }
-
-  if (save_char != NUL) {               // put back space after cursor
-    pchar_cursor((char_u)save_char);
-  }
-
-  curwin->w_p_lbr = has_lbr;
-
-  if (!format_only && haveto_redraw) {
-    update_topline(curwin);
-    redraw_curbuf_later(UPD_VALID);
-  }
-}
-
-/// Called after inserting or deleting text: When 'formatoptions' includes the
-/// 'a' flag format from the current line until the end of the paragraph.
-/// Keep the cursor at the same position relative to the text.
-/// The caller must have saved the cursor line for undo, following ones will be
-/// saved here.
-///
-/// @param trailblank  when true also format with trailing blank
-/// @param prev_line   may start in previous line
-void auto_format(bool trailblank, bool prev_line)
-{
-  pos_T pos;
-  colnr_T len;
-  char_u *old;
-  char_u *new, *pnew;
-  int wasatend;
-  int cc;
-
-  if (!has_format_option(FO_AUTO)) {
-    return;
-  }
-
-  pos = curwin->w_cursor;
-  old = get_cursor_line_ptr();
-
-  // may remove added space
-  check_auto_format(false);
-
-  // Don't format in Insert mode when the cursor is on a trailing blank, the
-  // user might insert normal text next.  Also skip formatting when "1" is
-  // in 'formatoptions' and there is a single character before the cursor.
-  // Otherwise the line would be broken and when typing another non-white
-  // next they are not joined back together.
-  wasatend = (pos.col == (colnr_T)STRLEN(old));
-  if (*old != NUL && !trailblank && wasatend) {
-    dec_cursor();
-    cc = gchar_cursor();
-    if (!WHITECHAR(cc) && curwin->w_cursor.col > 0
-        && has_format_option(FO_ONE_LETTER)) {
-      dec_cursor();
-    }
-    cc = gchar_cursor();
-    if (WHITECHAR(cc)) {
-      curwin->w_cursor = pos;
-      return;
-    }
-    curwin->w_cursor = pos;
-  }
-
-  // With the 'c' flag in 'formatoptions' and 't' missing: only format
-  // comments.
-  if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP)
-      && get_leader_len((char *)old, NULL, false, true) == 0) {
-    return;
-  }
-
-  /*
-   * May start formatting in a previous line, so that after "x" a word is
-   * moved to the previous line if it fits there now.  Only when this is not
-   * the start of a paragraph.
-   */
-  if (prev_line && !paragraph_start(curwin->w_cursor.lnum)) {
-    curwin->w_cursor.lnum--;
-    if (u_save_cursor() == FAIL) {
-      return;
-    }
-  }
-
-  /*
-   * Do the formatting and restore the cursor position.  "saved_cursor" will
-   * be adjusted for the text formatting.
-   */
-  saved_cursor = pos;
-  format_lines((linenr_T) - 1, false);
-  curwin->w_cursor = saved_cursor;
-  saved_cursor.lnum = 0;
-
-  if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
-    // "cannot happen"
-    curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
-    coladvance(MAXCOL);
-  } else {
-    check_cursor_col();
-  }
-
-  // Insert mode: If the cursor is now after the end of the line while it
-  // previously wasn't, the line was broken.  Because of the rule above we
-  // need to add a space when 'w' is in 'formatoptions' to keep a paragraph
-  // formatted.
-  if (!wasatend && has_format_option(FO_WHITE_PAR)) {
-    new = get_cursor_line_ptr();
-    len = (colnr_T)STRLEN(new);
-    if (curwin->w_cursor.col == len) {
-      pnew = vim_strnsave(new, (size_t)len + 2);
-      pnew[len] = ' ';
-      pnew[len + 1] = NUL;
-      ml_replace(curwin->w_cursor.lnum, (char *)pnew, false);
-      // remove the space later
-      did_add_space = true;
-    } else {
-      // may remove added space
-      check_auto_format(false);
-    }
-  }
-
-  check_cursor();
-}
-
-/// When an extra space was added to continue a paragraph for auto-formatting,
-/// delete it now.  The space must be under the cursor, just after the insert
-/// position.
-///
-/// @param end_insert  true when ending Insert mode
-static void check_auto_format(bool end_insert)
-{
-  int c = ' ';
-  int cc;
-
-  if (did_add_space) {
-    cc = gchar_cursor();
-    if (!WHITECHAR(cc)) {
-      // Somehow the space was removed already.
-      did_add_space = false;
-    } else {
-      if (!end_insert) {
-        inc_cursor();
-        c = gchar_cursor();
-        dec_cursor();
-      }
-      if (c != NUL) {
-        // The space is no longer at the end of the line, delete it.
-        del_char(false);
-        did_add_space = false;
-      }
-    }
-  }
-}
-
-/// Find out textwidth to be used for formatting:
-///      if 'textwidth' option is set, use it
-///      else if 'wrapmargin' option is set, use curwin->w_width_inner-'wrapmargin'
-///      if invalid value, use 0.
-///      Set default to window width (maximum 79) for "gq" operator.
-///
-/// @param ff  force formatting (for "gq" command)
-int comp_textwidth(bool ff)
-{
-  int textwidth = (int)curbuf->b_p_tw;
-  if (textwidth == 0 && curbuf->b_p_wm) {
-    // The width is the window width minus 'wrapmargin' minus all the
-    // things that add to the margin.
-    textwidth = curwin->w_width_inner - (int)curbuf->b_p_wm;
-    if (cmdwin_type != 0) {
-      textwidth -= 1;
-    }
-    textwidth -= win_fdccol_count(curwin);
-    textwidth -= win_signcol_count(curwin);
-
-    if (curwin->w_p_nu || curwin->w_p_rnu) {
-      textwidth -= 8;
-    }
-  }
-  if (textwidth < 0) {
-    textwidth = 0;
-  }
-  if (ff && textwidth == 0) {
-    textwidth = curwin->w_width_inner - 1;
-    if (textwidth > 79) {
-      textwidth = 79;
-    }
-  }
-  return textwidth;
-}
-
 /*
  * Put a character in the redo buffer, for when just after a CTRL-V.
  */
@@ -5665,6 +5068,11 @@ bool get_can_cindent(void)
   return can_cindent;
 }
 
+void set_can_cindent(bool val)
+{
+  can_cindent = val;
+}
+
 /// Trigger "event" and take care of fixing undo.
 int ins_apply_autocmds(event_T event)
 {
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index f5f09f1394..c1c5680cb0 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -623,6 +623,34 @@ void stuffnumReadbuff(long n)
   add_num_buff(&readbuf1, n);
 }
 
+/// Stuff a string into the typeahead buffer, such that edit() will insert it
+/// literally ("literally" true) or interpret is as typed characters.
+void stuffescaped(const char *arg, bool literally)
+{
+  while (*arg != NUL) {
+    // Stuff a sequence of normal ASCII characters, that's fast.  Also
+    // stuff K_SPECIAL to get the effect of a special key when "literally"
+    // is true.
+    const char *const start = arg;
+    while ((*arg >= ' ' && *arg < DEL) || ((uint8_t)(*arg) == K_SPECIAL
+                                           && !literally)) {
+      arg++;
+    }
+    if (arg > start) {
+      stuffReadbuffLen(start, (arg - start));
+    }
+
+    // stuff a single special character
+    if (*arg != NUL) {
+      const int c = mb_cptr2char_adv((const char_u **)&arg);
+      if (literally && ((c < ' ' && c != TAB) || c == DEL)) {
+        stuffcharReadbuff(Ctrl_V);
+      }
+      stuffcharReadbuff(c);
+    }
+  }
+}
+
 /// Read a character from the redo buffer.  Translates K_SPECIAL and
 /// multibyte characters.
 /// The redo buffer is left as it is.
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 6c83e2f3c3..7b93fbc852 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -559,6 +559,8 @@ EXTERN bool can_si INIT(= false);
 // one indent will be removed.
 EXTERN bool can_si_back INIT(= false);
 
+EXTERN int old_indent INIT(= 0);  ///< for ^^D command in insert mode
+
 // w_cursor before formatting text.
 EXTERN pos_T saved_cursor INIT(= { 0, 0, 0 });
 
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index c44cd06a2f..c4805283c2 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -25,6 +25,7 @@
 #include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
+#include "nvim/textformat.h"
 #include "nvim/undo.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index a3b5e3df5c..7d17a284e5 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -43,6 +43,7 @@
 #include "nvim/state.h"
 #include "nvim/strings.h"
 #include "nvim/tag.h"
+#include "nvim/textformat.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 1bd780be0f..743297eb9d 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -65,6 +65,7 @@
 #include "nvim/strings.h"
 #include "nvim/syntax.h"
 #include "nvim/tag.h"
+#include "nvim/textformat.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index a1f4149715..79450acbd6 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -51,6 +51,7 @@
 #include "nvim/state.h"
 #include "nvim/strings.h"
 #include "nvim/terminal.h"
+#include "nvim/textformat.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
@@ -1311,34 +1312,6 @@ int insert_reg(int regname, bool literally_arg)
   return retval;
 }
 
-/// Stuff a string into the typeahead buffer, such that edit() will insert it
-/// literally ("literally" true) or interpret is as typed characters.
-static void stuffescaped(const char *arg, bool literally)
-{
-  while (*arg != NUL) {
-    // Stuff a sequence of normal ASCII characters, that's fast.  Also
-    // stuff K_SPECIAL to get the effect of a special key when "literally"
-    // is true.
-    const char *const start = arg;
-    while ((*arg >= ' ' && *arg < DEL) || ((uint8_t)(*arg) == K_SPECIAL
-                                           && !literally)) {
-      arg++;
-    }
-    if (arg > start) {
-      stuffReadbuffLen(start, (arg - start));
-    }
-
-    // stuff a single special character
-    if (*arg != NUL) {
-      const int c = mb_cptr2char_adv((const char_u **)&arg);
-      if (literally && ((c < ' ' && c != TAB) || c == DEL)) {
-        stuffcharReadbuff(Ctrl_V);
-      }
-      stuffcharReadbuff(c);
-    }
-  }
-}
-
 /// If "regname" is a special register, return true and store a pointer to its
 /// value in "argp".
 ///
@@ -4218,527 +4191,6 @@ theend:
   return ret;
 }
 
-/// @return  true if the two comment leaders given are the same.
-///
-/// @param lnum  The first line.  White-space is ignored.
-///
-/// @note the whole of 'leader1' must match 'leader2_len' characters from 'leader2'.
-static int same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, int leader2_len,
-                       char_u *leader2_flags)
-{
-  int idx1 = 0, idx2 = 0;
-  char_u *p;
-  char_u *line1;
-  char_u *line2;
-
-  if (leader1_len == 0) {
-    return leader2_len == 0;
-  }
-
-  /*
-   * If first leader has 'f' flag, the lines can be joined only if the
-   * second line does not have a leader.
-   * If first leader has 'e' flag, the lines can never be joined.
-   * If first leader has 's' flag, the lines can only be joined if there is
-   * some text after it and the second line has the 'm' flag.
-   */
-  if (leader1_flags != NULL) {
-    for (p = leader1_flags; *p && *p != ':'; p++) {
-      if (*p == COM_FIRST) {
-        return leader2_len == 0;
-      }
-      if (*p == COM_END) {
-        return false;
-      }
-      if (*p == COM_START) {
-        if (*(ml_get(lnum) + leader1_len) == NUL) {
-          return false;
-        }
-        if (leader2_flags == NULL || leader2_len == 0) {
-          return false;
-        }
-        for (p = leader2_flags; *p && *p != ':'; p++) {
-          if (*p == COM_MIDDLE) {
-            return true;
-          }
-        }
-        return false;
-      }
-    }
-  }
-
-  /*
-   * Get current line and next line, compare the leaders.
-   * The first line has to be saved, only one line can be locked at a time.
-   */
-  line1 = vim_strsave(ml_get(lnum));
-  for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
-  line2 = ml_get(lnum + 1);
-  for (idx2 = 0; idx2 < leader2_len; idx2++) {
-    if (!ascii_iswhite(line2[idx2])) {
-      if (line1[idx1++] != line2[idx2]) {
-        break;
-      }
-    } else {
-      while (ascii_iswhite(line1[idx1])) {
-        idx1++;
-      }
-    }
-  }
-  xfree(line1);
-
-  return idx2 == leader2_len && idx1 == leader1_len;
-}
-
-/// Implementation of the format operator 'gq'.
-///
-/// @param keep_cursor  keep cursor on same text char
-static void op_format(oparg_T *oap, int keep_cursor)
-{
-  linenr_T old_line_count = curbuf->b_ml.ml_line_count;
-
-  // Place the cursor where the "gq" or "gw" command was given, so that "u"
-  // can put it back there.
-  curwin->w_cursor = oap->cursor_start;
-
-  if (u_save((linenr_T)(oap->start.lnum - 1),
-             (linenr_T)(oap->end.lnum + 1)) == FAIL) {
-    return;
-  }
-  curwin->w_cursor = oap->start;
-
-  if (oap->is_VIsual) {
-    // When there is no change: need to remove the Visual selection
-    redraw_curbuf_later(UPD_INVERTED);
-  }
-
-  if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
-    // Set '[ mark at the start of the formatted area
-    curbuf->b_op_start = oap->start;
-  }
-
-  // For "gw" remember the cursor position and put it back below (adjusted
-  // for joined and split lines).
-  if (keep_cursor) {
-    saved_cursor = oap->cursor_start;
-  }
-
-  format_lines((linenr_T)oap->line_count, keep_cursor);
-
-  /*
-   * Leave the cursor at the first non-blank of the last formatted line.
-   * If the cursor was moved one line back (e.g. with "Q}") go to the next
-   * line, so "." will do the next lines.
-   */
-  if (oap->end_adjusted && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
-    curwin->w_cursor.lnum++;
-  }
-  beginline(BL_WHITE | BL_FIX);
-  old_line_count = curbuf->b_ml.ml_line_count - old_line_count;
-  msgmore(old_line_count);
-
-  if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
-    // put '] mark on the end of the formatted area
-    curbuf->b_op_end = curwin->w_cursor;
-  }
-
-  if (keep_cursor) {
-    curwin->w_cursor = saved_cursor;
-    saved_cursor.lnum = 0;
-
-    // formatting may have made the cursor position invalid
-    check_cursor();
-  }
-
-  if (oap->is_VIsual) {
-    FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-      if (wp->w_old_cursor_lnum != 0) {
-        // When lines have been inserted or deleted, adjust the end of
-        // the Visual area to be redrawn.
-        if (wp->w_old_cursor_lnum > wp->w_old_visual_lnum) {
-          wp->w_old_cursor_lnum += old_line_count;
-        } else {
-          wp->w_old_visual_lnum += old_line_count;
-        }
-      }
-    }
-  }
-}
-
-/// Implementation of the format operator 'gq' for when using 'formatexpr'.
-static void op_formatexpr(oparg_T *oap)
-{
-  if (oap->is_VIsual) {
-    // When there is no change: need to remove the Visual selection
-    redraw_curbuf_later(UPD_INVERTED);
-  }
-
-  if (fex_format(oap->start.lnum, oap->line_count, NUL) != 0) {
-    // As documented: when 'formatexpr' returns non-zero fall back to
-    // internal formatting.
-    op_format(oap, false);
-  }
-}
-
-/// @param c  character to be inserted
-int fex_format(linenr_T lnum, long count, int c)
-{
-  int use_sandbox = was_set_insecurely(curwin, "formatexpr", OPT_LOCAL);
-  int r;
-
-  // Set v:lnum to the first line number and v:count to the number of lines.
-  // Set v:char to the character to be inserted (can be NUL).
-  set_vim_var_nr(VV_LNUM, (varnumber_T)lnum);
-  set_vim_var_nr(VV_COUNT, (varnumber_T)count);
-  set_vim_var_char(c);
-
-  // Make a copy, the option could be changed while calling it.
-  char *fex = xstrdup(curbuf->b_p_fex);
-  // Evaluate the function.
-  if (use_sandbox) {
-    sandbox++;
-  }
-  r = (int)eval_to_number(fex);
-  if (use_sandbox) {
-    sandbox--;
-  }
-
-  set_vim_var_string(VV_CHAR, NULL, -1);
-  xfree(fex);
-
-  return r;
-}
-
-/// @param line_count  number of lines to format, starting at the cursor position.
-///                    when negative, format until the end of the paragraph.
-///
-/// Lines after the cursor line are saved for undo, caller must have saved the
-/// first line.
-///
-/// @param avoid_fex  don't use 'formatexpr'
-void format_lines(linenr_T line_count, int avoid_fex)
-{
-  bool is_not_par;                  // current line not part of parag.
-  bool next_is_not_par;             // next line not part of paragraph
-  bool is_end_par;                  // at end of paragraph
-  bool prev_is_end_par = false;     // prev. line not part of parag.
-  bool next_is_start_par = false;
-  int leader_len = 0;               // leader len of current line
-  int next_leader_len;              // leader len of next line
-  char_u *leader_flags = NULL;      // flags for leader of current line
-  char_u *next_leader_flags = NULL;  // flags for leader of next line
-  bool advance = true;
-  int second_indent = -1;           // indent for second line (comment aware)
-  bool first_par_line = true;
-  int smd_save;
-  long count;
-  bool need_set_indent = true;      // set indent of next paragraph
-  linenr_T first_line = curwin->w_cursor.lnum;
-  bool force_format = false;
-  const int old_State = State;
-
-  // length of a line to force formatting: 3 * 'tw'
-  const int max_len = comp_textwidth(true) * 3;
-
-  // check for 'q', '2' and '1' in 'formatoptions'
-  const bool do_comments = has_format_option(FO_Q_COMS);  // format comments
-  int do_comments_list = 0;  // format comments with 'n' or '2'
-  const bool do_second_indent = has_format_option(FO_Q_SECOND);
-  const bool do_number_indent = has_format_option(FO_Q_NUMBER);
-  const bool do_trail_white = has_format_option(FO_WHITE_PAR);
-
-  // Get info about the previous and current line.
-  if (curwin->w_cursor.lnum > 1) {
-    is_not_par = fmt_check_par(curwin->w_cursor.lnum - 1,
-                               &leader_len, &leader_flags, do_comments);
-  } else {
-    is_not_par = true;
-  }
-  next_is_not_par = fmt_check_par(curwin->w_cursor.lnum,
-                                  &next_leader_len, &next_leader_flags, do_comments
-                                  );
-  is_end_par = (is_not_par || next_is_not_par);
-  if (!is_end_par && do_trail_white) {
-    is_end_par = !ends_in_white(curwin->w_cursor.lnum - 1);
-  }
-
-  curwin->w_cursor.lnum--;
-  for (count = line_count; count != 0 && !got_int; count--) {
-    // Advance to next paragraph.
-    if (advance) {
-      curwin->w_cursor.lnum++;
-      prev_is_end_par = is_end_par;
-      is_not_par = next_is_not_par;
-      leader_len = next_leader_len;
-      leader_flags = next_leader_flags;
-    }
-
-    /*
-     * The last line to be formatted.
-     */
-    if (count == 1 || curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) {
-      next_is_not_par = true;
-      next_leader_len = 0;
-      next_leader_flags = NULL;
-    } else {
-      next_is_not_par = fmt_check_par(curwin->w_cursor.lnum + 1,
-                                      &next_leader_len, &next_leader_flags, do_comments
-                                      );
-      if (do_number_indent) {
-        next_is_start_par =
-          (get_number_indent(curwin->w_cursor.lnum + 1) > 0);
-      }
-    }
-    advance = true;
-    is_end_par = (is_not_par || next_is_not_par || next_is_start_par);
-    if (!is_end_par && do_trail_white) {
-      is_end_par = !ends_in_white(curwin->w_cursor.lnum);
-    }
-
-    /*
-     * Skip lines that are not in a paragraph.
-     */
-    if (is_not_par) {
-      if (line_count < 0) {
-        break;
-      }
-    } else {
-      /*
-       * For the first line of a paragraph, check indent of second line.
-       * Don't do this for comments and empty lines.
-       */
-      if (first_par_line
-          && (do_second_indent || do_number_indent)
-          && prev_is_end_par
-          && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
-        if (do_second_indent && !LINEEMPTY(curwin->w_cursor.lnum + 1)) {
-          if (leader_len == 0 && next_leader_len == 0) {
-            // no comment found
-            second_indent =
-              get_indent_lnum(curwin->w_cursor.lnum + 1);
-          } else {
-            second_indent = next_leader_len;
-            do_comments_list = 1;
-          }
-        } else if (do_number_indent) {
-          if (leader_len == 0 && next_leader_len == 0) {
-            // no comment found
-            second_indent =
-              get_number_indent(curwin->w_cursor.lnum);
-          } else {
-            // get_number_indent() is now "comment aware"...
-            second_indent =
-              get_number_indent(curwin->w_cursor.lnum);
-            do_comments_list = 1;
-          }
-        }
-      }
-
-      /*
-       * When the comment leader changes, it's the end of the paragraph.
-       */
-      if (curwin->w_cursor.lnum >= curbuf->b_ml.ml_line_count
-          || !same_leader(curwin->w_cursor.lnum,
-                          leader_len, leader_flags,
-                          next_leader_len,
-                          next_leader_flags)) {
-        // Special case: If the next line starts with a line comment
-        // and this line has a line comment after some text, the
-        // paragraph doesn't really end.
-        if (next_leader_flags == NULL
-            || STRNCMP(next_leader_flags, "://", 3) != 0
-            || check_linecomment(get_cursor_line_ptr()) == MAXCOL) {
-          is_end_par = true;
-        }
-      }
-
-      /*
-       * If we have got to the end of a paragraph, or the line is
-       * getting long, format it.
-       */
-      if (is_end_par || force_format) {
-        if (need_set_indent) {
-          int indent = 0;  // amount of indent needed
-
-          // Replace indent in first line of a paragraph with minimal
-          // number of tabs and spaces, according to current options.
-          // For the very first formatted line keep the current
-          // indent.
-          if (curwin->w_cursor.lnum == first_line) {
-            indent = get_indent();
-          } else if (curbuf->b_p_lisp) {
-            indent = get_lisp_indent();
-          } else {
-            if (cindent_on()) {
-              indent = *curbuf->b_p_inde != NUL ? get_expr_indent() : get_c_indent();
-            } else {
-              indent = get_indent();
-            }
-          }
-          (void)set_indent(indent, SIN_CHANGED);
-        }
-
-        // put cursor on last non-space
-        State = MODE_NORMAL;  // don't go past end-of-line
-        coladvance(MAXCOL);
-        while (curwin->w_cursor.col && ascii_isspace(gchar_cursor())) {
-          dec_cursor();
-        }
-
-        // do the formatting, without 'showmode'
-        State = MODE_INSERT;         // for open_line()
-        smd_save = p_smd;
-        p_smd = false;
-        insertchar(NUL, INSCHAR_FORMAT
-                   + (do_comments ? INSCHAR_DO_COM : 0)
-                   + (do_comments && do_comments_list
-               ? INSCHAR_COM_LIST : 0)
-                   + (avoid_fex ? INSCHAR_NO_FEX : 0), second_indent);
-        State = old_State;
-        p_smd = smd_save;
-        second_indent = -1;
-        // at end of par.: need to set indent of next par.
-        need_set_indent = is_end_par;
-        if (is_end_par) {
-          // When called with a negative line count, break at the
-          // end of the paragraph.
-          if (line_count < 0) {
-            break;
-          }
-          first_par_line = true;
-        }
-        force_format = false;
-      }
-
-      /*
-       * When still in same paragraph, join the lines together.  But
-       * first delete the leader from the second line.
-       */
-      if (!is_end_par) {
-        advance = false;
-        curwin->w_cursor.lnum++;
-        curwin->w_cursor.col = 0;
-        if (line_count < 0 && u_save_cursor() == FAIL) {
-          break;
-        }
-        if (next_leader_len > 0) {
-          (void)del_bytes(next_leader_len, false, false);
-          mark_col_adjust(curwin->w_cursor.lnum, (colnr_T)0, 0L,
-                          (long)-next_leader_len, 0);
-        } else if (second_indent > 0) {   // the "leader" for FO_Q_SECOND
-          int indent = (int)getwhitecols_curline();
-
-          if (indent > 0) {
-            (void)del_bytes(indent, false, false);
-            mark_col_adjust(curwin->w_cursor.lnum,
-                            (colnr_T)0, 0L, (long)-indent, 0);
-          }
-        }
-        curwin->w_cursor.lnum--;
-        if (do_join(2, true, false, false, false) == FAIL) {
-          beep_flush();
-          break;
-        }
-        first_par_line = false;
-        // If the line is getting long, format it next time
-        if (STRLEN(get_cursor_line_ptr()) > (size_t)max_len) {
-          force_format = true;
-        } else {
-          force_format = false;
-        }
-      }
-    }
-    line_breakcheck();
-  }
-}
-
-/// @return  true if line "lnum" ends in a white character.
-static int ends_in_white(linenr_T lnum)
-{
-  char_u *s = ml_get(lnum);
-  size_t l;
-
-  if (*s == NUL) {
-    return false;
-  }
-  l = STRLEN(s) - 1;
-  return ascii_iswhite(s[l]);
-}
-
-/// Blank lines, and lines containing only the comment leader, are left
-/// untouched by the formatting.  The function returns true in this
-/// case.  It also returns true when a line starts with the end of a comment
-/// ('e' in comment flags), so that this line is skipped, and not joined to the
-/// previous line.  A new paragraph starts after a blank line, or when the
-/// comment leader changes.
-static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags, int do_comments)
-{
-  char_u *flags = NULL;        // init for GCC
-  char_u *ptr;
-
-  ptr = ml_get(lnum);
-  if (do_comments) {
-    *leader_len = get_leader_len((char *)ptr, (char **)leader_flags, false, true);
-  } else {
-    *leader_len = 0;
-  }
-
-  if (*leader_len > 0) {
-    /*
-     * Search for 'e' flag in comment leader flags.
-     */
-    flags = *leader_flags;
-    while (*flags && *flags != ':' && *flags != COM_END) {
-      flags++;
-    }
-  }
-
-  return *skipwhite((char *)ptr + *leader_len) == NUL
-         || (*leader_len > 0 && *flags == COM_END)
-         || startPS(lnum, NUL, false);
-}
-
-/// Used for auto-formatting.
-///
-/// @return  true when a paragraph starts in line "lnum".
-///          false when the previous line is in the same paragraph.
-int paragraph_start(linenr_T lnum)
-{
-  char_u *p;
-  int leader_len = 0;                // leader len of current line
-  char_u *leader_flags = NULL;       // flags for leader of current line
-  int next_leader_len = 0;           // leader len of next line
-  char_u *next_leader_flags = NULL;  // flags for leader of next line
-
-  if (lnum <= 1) {
-    return true;                // start of the file
-  }
-  p = ml_get(lnum - 1);
-  if (*p == NUL) {
-    return true;                // after empty line
-  }
-  const bool do_comments = has_format_option(FO_Q_COMS);  // format comments
-  if (fmt_check_par(lnum - 1, &leader_len, &leader_flags, do_comments)) {
-    return true;  // after non-paragraph line
-  }
-
-  if (fmt_check_par(lnum, &next_leader_len, &next_leader_flags, do_comments)) {
-    return true;  // "lnum" is not a paragraph line
-  }
-
-  if (has_format_option(FO_WHITE_PAR) && !ends_in_white(lnum - 1)) {
-    return true;                // missing trailing space in previous line.
-  }
-  if (has_format_option(FO_Q_NUMBER) && (get_number_indent(lnum) > 0)) {
-    return true;                // numbered item starts in "lnum".
-  }
-  if (!same_leader(lnum - 1, leader_len, leader_flags,
-                   next_leader_len, next_leader_flags)) {
-    return true;                // change of comment leader.
-  }
-  return false;
-}
-
 /// prepare a few things for block mode yank/delete/tilde
 ///
 /// for delete:
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 3f7c200928..95c3ccf71c 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -5047,17 +5047,6 @@ static int wc_use_keyname(char_u *varp, long *wcp)
   return false;
 }
 
-/// Return true if format option 'x' is in effect.
-/// Take care of no formatting when 'paste' is set.
-bool has_format_option(int x)
-  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
-{
-  if (p_paste) {
-    return false;
-  }
-  return vim_strchr(curbuf->b_p_fo, x) != NULL;
-}
-
 /// @returns true if "x" is present in 'shortmess' option, or
 /// 'shortmess' contains 'a' and "x" is present in SHM_ALL_ABBREVIATIONS.
 bool shortmess(int x)
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
new file mode 100644
index 0000000000..43afc08155
--- /dev/null
+++ b/src/nvim/textformat.c
@@ -0,0 +1,1122 @@
+// 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
+
+// textformat.c: text formatting functions
+
+#include <stdbool.h>
+
+#include "nvim/change.h"
+#include "nvim/charset.h"
+#include "nvim/cursor.h"
+#include "nvim/drawscreen.h"
+#include "nvim/edit.h"
+#include "nvim/eval.h"
+#include "nvim/getchar.h"
+#include "nvim/globals.h"
+#include "nvim/indent.h"
+#include "nvim/indent_c.h"
+#include "nvim/memline.h"
+#include "nvim/move.h"
+#include "nvim/ops.h"
+#include "nvim/option.h"
+#include "nvim/os/input.h"
+#include "nvim/search.h"
+#include "nvim/strings.h"
+#include "nvim/textformat.h"
+#include "nvim/undo.h"
+#include "nvim/vim.h"
+#include "nvim/window.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "textformat.c.generated.h"
+#endif
+
+static bool did_add_space = false;  ///< auto_format() added an extra space
+                                    ///< under the cursor
+
+#define WHITECHAR(cc) (ascii_iswhite(cc) \
+                       && !utf_iscomposing(utf_ptr2char((char *)get_cursor_pos_ptr() + 1)))
+
+/// Return true if format option 'x' is in effect.
+/// Take care of no formatting when 'paste' is set.
+bool has_format_option(int x)
+  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  if (p_paste) {
+    return false;
+  }
+  return vim_strchr(curbuf->b_p_fo, x) != NULL;
+}
+
+/// Format text at the current insert position.
+///
+/// If the INSCHAR_COM_LIST flag is present, then the value of second_indent
+/// will be the comment leader length sent to open_line().
+///
+/// @param c  character to be inserted (can be NUL)
+void internal_format(int textwidth, int second_indent, int flags, bool format_only, int c)
+{
+  int cc;
+  int save_char = NUL;
+  bool haveto_redraw = false;
+  const bool fo_ins_blank = has_format_option(FO_INS_BLANK);
+  const bool fo_multibyte = has_format_option(FO_MBYTE_BREAK);
+  const bool fo_rigor_tw  = has_format_option(FO_RIGOROUS_TW);
+  const bool fo_white_par = has_format_option(FO_WHITE_PAR);
+  bool first_line = true;
+  colnr_T leader_len;
+  bool no_leader = false;
+  int do_comments = (flags & INSCHAR_DO_COM);
+  int has_lbr = curwin->w_p_lbr;
+
+  // make sure win_lbr_chartabsize() counts correctly
+  curwin->w_p_lbr = false;
+
+  // When 'ai' is off we don't want a space under the cursor to be
+  // deleted.  Replace it with an 'x' temporarily.
+  if (!curbuf->b_p_ai
+      && !(State & VREPLACE_FLAG)) {
+    cc = gchar_cursor();
+    if (ascii_iswhite(cc)) {
+      save_char = cc;
+      pchar_cursor('x');
+    }
+  }
+
+  // Repeat breaking lines, until the current line is not too long.
+  while (!got_int) {
+    int startcol;                       // Cursor column at entry
+    int wantcol;                        // column at textwidth border
+    int foundcol;                       // column for start of spaces
+    int end_foundcol = 0;               // column for start of word
+    colnr_T len;
+    colnr_T virtcol;
+    int orig_col = 0;
+    char_u *saved_text = NULL;
+    colnr_T col;
+    colnr_T end_col;
+    bool did_do_comment = false;
+
+    virtcol = get_nolist_virtcol()
+              + char2cells(c != NUL ? c : gchar_cursor());
+    if (virtcol <= (colnr_T)textwidth) {
+      break;
+    }
+
+    if (no_leader) {
+      do_comments = false;
+    } else if (!(flags & INSCHAR_FORMAT)
+               && has_format_option(FO_WRAP_COMS)) {
+      do_comments = true;
+    }
+
+    // Don't break until after the comment leader
+    if (do_comments) {
+      char_u *line = get_cursor_line_ptr();
+      leader_len = get_leader_len((char *)line, NULL, false, true);
+      if (leader_len == 0 && curbuf->b_p_cin) {
+        // Check for a line comment after code.
+        int comment_start = check_linecomment(line);
+        if (comment_start != MAXCOL) {
+          leader_len = get_leader_len((char *)line + comment_start, NULL, false, true);
+          if (leader_len != 0) {
+            leader_len += comment_start;
+          }
+        }
+      }
+    } else {
+      leader_len = 0;
+    }
+
+    // If the line doesn't start with a comment leader, then don't
+    // start one in a following broken line.  Avoids that a %word
+    // moved to the start of the next line causes all following lines
+    // to start with %.
+    if (leader_len == 0) {
+      no_leader = true;
+    }
+    if (!(flags & INSCHAR_FORMAT)
+        && leader_len == 0
+        && !has_format_option(FO_WRAP)) {
+      break;
+    }
+    if ((startcol = curwin->w_cursor.col) == 0) {
+      break;
+    }
+
+    // find column of textwidth border
+    coladvance((colnr_T)textwidth);
+    wantcol = curwin->w_cursor.col;
+
+    curwin->w_cursor.col = startcol;
+    foundcol = 0;
+    int skip_pos = 0;
+
+    // Find position to break at.
+    // Stop at first entered white when 'formatoptions' has 'v'
+    while ((!fo_ins_blank && !has_format_option(FO_INS_VI))
+           || (flags & INSCHAR_FORMAT)
+           || curwin->w_cursor.lnum != Insstart.lnum
+           || curwin->w_cursor.col >= Insstart.col) {
+      if (curwin->w_cursor.col == startcol && c != NUL) {
+        cc = c;
+      } else {
+        cc = gchar_cursor();
+      }
+      if (WHITECHAR(cc)) {
+        // remember position of blank just before text
+        end_col = curwin->w_cursor.col;
+
+        // find start of sequence of blanks
+        int wcc = 0;  // counter for whitespace chars
+        while (curwin->w_cursor.col > 0 && WHITECHAR(cc)) {
+          dec_cursor();
+          cc = gchar_cursor();
+
+          // Increment count of how many whitespace chars in this
+          // group; we only need to know if it's more than one.
+          if (wcc < 2) {
+            wcc++;
+          }
+        }
+        if (curwin->w_cursor.col == 0 && WHITECHAR(cc)) {
+          break;                        // only spaces in front of text
+        }
+
+        // Don't break after a period when 'formatoptions' has 'p' and
+        // there are less than two spaces.
+        if (has_format_option(FO_PERIOD_ABBR) && cc == '.' && wcc < 2) {
+          continue;
+        }
+
+        // Don't break until after the comment leader
+        if (curwin->w_cursor.col < leader_len) {
+          break;
+        }
+
+        if (has_format_option(FO_ONE_LETTER)) {
+          // do not break after one-letter words
+          if (curwin->w_cursor.col == 0) {
+            break;              // one-letter word at begin
+          }
+          // do not break "#a b" when 'tw' is 2
+          if (curwin->w_cursor.col <= leader_len) {
+            break;
+          }
+          col = curwin->w_cursor.col;
+          dec_cursor();
+          cc = gchar_cursor();
+
+          if (WHITECHAR(cc)) {
+            continue;                   // one-letter, continue
+          }
+          curwin->w_cursor.col = col;
+        }
+
+        inc_cursor();
+
+        end_foundcol = end_col + 1;
+        foundcol = curwin->w_cursor.col;
+        if (curwin->w_cursor.col <= (colnr_T)wantcol) {
+          break;
+        }
+      } else if ((cc >= 0x100 || !utf_allow_break_before(cc)) && fo_multibyte) {
+        int ncc;
+        bool allow_break;
+
+        // Break after or before a multi-byte character.
+        if (curwin->w_cursor.col != startcol) {
+          // Don't break until after the comment leader
+          if (curwin->w_cursor.col < leader_len) {
+            break;
+          }
+          col = curwin->w_cursor.col;
+          inc_cursor();
+          ncc = gchar_cursor();
+          allow_break = utf_allow_break(cc, ncc);
+
+          // If we have already checked this position, skip!
+          if (curwin->w_cursor.col != skip_pos && allow_break) {
+            foundcol = curwin->w_cursor.col;
+            end_foundcol = foundcol;
+            if (curwin->w_cursor.col <= (colnr_T)wantcol) {
+              break;
+            }
+          }
+          curwin->w_cursor.col = col;
+        }
+
+        if (curwin->w_cursor.col == 0) {
+          break;
+        }
+
+        ncc = cc;
+        col = curwin->w_cursor.col;
+
+        dec_cursor();
+        cc = gchar_cursor();
+
+        if (WHITECHAR(cc)) {
+          continue;                     // break with space
+        }
+        // Don't break until after the comment leader.
+        if (curwin->w_cursor.col < leader_len) {
+          break;
+        }
+
+        curwin->w_cursor.col = col;
+        skip_pos = curwin->w_cursor.col;
+
+        allow_break = utf_allow_break(cc, ncc);
+
+        // Must handle this to respect line break prohibition.
+        if (allow_break) {
+          foundcol = curwin->w_cursor.col;
+          end_foundcol = foundcol;
+        }
+        if (curwin->w_cursor.col <= (colnr_T)wantcol) {
+          const bool ncc_allow_break = utf_allow_break_before(ncc);
+
+          if (allow_break) {
+            break;
+          }
+          if (!ncc_allow_break && !fo_rigor_tw) {
+            // Enable at most 1 punct hang outside of textwidth.
+            if (curwin->w_cursor.col == startcol) {
+              // We are inserting a non-breakable char, postpone
+              // line break check to next insert.
+              end_foundcol = foundcol = 0;
+              break;
+            }
+
+            // Neither cc nor ncc is NUL if we are here, so
+            // it's safe to inc_cursor.
+            col = curwin->w_cursor.col;
+
+            inc_cursor();
+            cc  = ncc;
+            ncc = gchar_cursor();
+            // handle insert
+            ncc = (ncc != NUL) ? ncc : c;
+
+            allow_break = utf_allow_break(cc, ncc);
+
+            if (allow_break) {
+              // Break only when we are not at end of line.
+              end_foundcol = foundcol = ncc == NUL? 0 : curwin->w_cursor.col;
+              break;
+            }
+            curwin->w_cursor.col = col;
+          }
+        }
+      }
+      if (curwin->w_cursor.col == 0) {
+        break;
+      }
+      dec_cursor();
+    }
+
+    if (foundcol == 0) {                // no spaces, cannot break line
+      curwin->w_cursor.col = startcol;
+      break;
+    }
+
+    // Going to break the line, remove any "$" now.
+    undisplay_dollar();
+
+    // Offset between cursor position and line break is used by replace
+    // stack functions.  MODE_VREPLACE does not use this, and backspaces
+    // over the text instead.
+    if (State & VREPLACE_FLAG) {
+      orig_col = startcol;              // Will start backspacing from here
+    } else {
+      replace_offset = startcol - end_foundcol;
+    }
+
+    // adjust startcol for spaces that will be deleted and
+    // characters that will remain on top line
+    curwin->w_cursor.col = foundcol;
+    while ((cc = gchar_cursor(), WHITECHAR(cc))
+           && (!fo_white_par || curwin->w_cursor.col < startcol)) {
+      inc_cursor();
+    }
+    startcol -= curwin->w_cursor.col;
+    if (startcol < 0) {
+      startcol = 0;
+    }
+
+    if (State & VREPLACE_FLAG) {
+      // In MODE_VREPLACE state, we will backspace over the text to be
+      // wrapped, so save a copy now to put on the next line.
+      saved_text = vim_strsave(get_cursor_pos_ptr());
+      curwin->w_cursor.col = orig_col;
+      saved_text[startcol] = NUL;
+
+      // Backspace over characters that will move to the next line
+      if (!fo_white_par) {
+        backspace_until_column(foundcol);
+      }
+    } else {
+      // put cursor after pos. to break line
+      if (!fo_white_par) {
+        curwin->w_cursor.col = foundcol;
+      }
+    }
+
+    // Split the line just before the margin.
+    // Only insert/delete lines, but don't really redraw the window.
+    open_line(FORWARD, OPENLINE_DELSPACES + OPENLINE_MARKFIX
+              + (fo_white_par ? OPENLINE_KEEPTRAIL : 0)
+              + (do_comments ? OPENLINE_DO_COM : 0)
+              + OPENLINE_FORMAT
+              + ((flags & INSCHAR_COM_LIST) ? OPENLINE_COM_LIST : 0),
+              ((flags & INSCHAR_COM_LIST) ? second_indent : old_indent),
+              &did_do_comment);
+    if (!(flags & INSCHAR_COM_LIST)) {
+      old_indent = 0;
+    }
+
+    // If a comment leader was inserted, may also do this on a following
+    // line.
+    if (did_do_comment) {
+      no_leader = false;
+    }
+
+    replace_offset = 0;
+    if (first_line) {
+      if (!(flags & INSCHAR_COM_LIST)) {
+        // This section is for auto-wrap of numeric lists.  When not
+        // in insert mode (i.e. format_lines()), the INSCHAR_COM_LIST
+        // flag will be set and open_line() will handle it (as seen
+        // above).  The code here (and in get_number_indent()) will
+        // recognize comments if needed...
+        if (second_indent < 0 && has_format_option(FO_Q_NUMBER)) {
+          second_indent = get_number_indent(curwin->w_cursor.lnum - 1);
+        }
+        if (second_indent >= 0) {
+          if (State & VREPLACE_FLAG) {
+            change_indent(INDENT_SET, second_indent, false, NUL, true);
+          } else if (leader_len > 0 && second_indent - leader_len > 0) {
+            int padding = second_indent - leader_len;
+
+            // We started at the first_line of a numbered list
+            // that has a comment.  the open_line() function has
+            // inserted the proper comment leader and positioned
+            // the cursor at the end of the split line.  Now we
+            // add the additional whitespace needed after the
+            // comment leader for the numbered list.
+            for (int i = 0; i < padding; i++) {
+              ins_str((char_u *)" ");
+            }
+            changed_bytes(curwin->w_cursor.lnum, leader_len);
+          } else {
+            (void)set_indent(second_indent, SIN_CHANGED);
+          }
+        }
+      }
+      first_line = false;
+    }
+
+    if (State & VREPLACE_FLAG) {
+      // In MODE_VREPLACE state we have backspaced over the text to be
+      // moved, now we re-insert it into the new line.
+      ins_bytes((char *)saved_text);
+      xfree(saved_text);
+    } else {
+      // Check if cursor is not past the NUL off the line, cindent
+      // may have added or removed indent.
+      curwin->w_cursor.col += startcol;
+      len = (colnr_T)STRLEN(get_cursor_line_ptr());
+      if (curwin->w_cursor.col > len) {
+        curwin->w_cursor.col = len;
+      }
+    }
+
+    haveto_redraw = true;
+    set_can_cindent(true);
+    // moved the cursor, don't autoindent or cindent now
+    did_ai = false;
+    did_si = false;
+    can_si = false;
+    can_si_back = false;
+    line_breakcheck();
+  }
+
+  if (save_char != NUL) {               // put back space after cursor
+    pchar_cursor((char_u)save_char);
+  }
+
+  curwin->w_p_lbr = has_lbr;
+
+  if (!format_only && haveto_redraw) {
+    update_topline(curwin);
+    redraw_curbuf_later(UPD_VALID);
+  }
+}
+
+/// Blank lines, and lines containing only the comment leader, are left
+/// untouched by the formatting.  The function returns true in this
+/// case.  It also returns true when a line starts with the end of a comment
+/// ('e' in comment flags), so that this line is skipped, and not joined to the
+/// previous line.  A new paragraph starts after a blank line, or when the
+/// comment leader changes.
+static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags, bool do_comments)
+{
+  char_u *flags = NULL;        // init for GCC
+  char_u *ptr;
+
+  ptr = ml_get(lnum);
+  if (do_comments) {
+    *leader_len = get_leader_len((char *)ptr, (char **)leader_flags, false, true);
+  } else {
+    *leader_len = 0;
+  }
+
+  if (*leader_len > 0) {
+    // Search for 'e' flag in comment leader flags.
+    flags = *leader_flags;
+    while (*flags && *flags != ':' && *flags != COM_END) {
+      flags++;
+    }
+  }
+
+  return *skipwhite((char *)ptr + *leader_len) == NUL
+         || (*leader_len > 0 && *flags == COM_END)
+         || startPS(lnum, NUL, false);
+}
+
+/// @return  true if line "lnum" ends in a white character.
+static bool ends_in_white(linenr_T lnum)
+{
+  char_u *s = ml_get(lnum);
+  size_t l;
+
+  if (*s == NUL) {
+    return false;
+  }
+  l = STRLEN(s) - 1;
+  return ascii_iswhite(s[l]);
+}
+
+/// @return  true if the two comment leaders given are the same.
+///
+/// @param lnum  The first line.  White-space is ignored.
+///
+/// @note the whole of 'leader1' must match 'leader2_len' characters from 'leader2'.
+static bool same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, int leader2_len,
+                        char_u *leader2_flags)
+{
+  int idx1 = 0, idx2 = 0;
+  char_u *p;
+  char_u *line1;
+  char_u *line2;
+
+  if (leader1_len == 0) {
+    return leader2_len == 0;
+  }
+
+  // If first leader has 'f' flag, the lines can be joined only if the
+  // second line does not have a leader.
+  // If first leader has 'e' flag, the lines can never be joined.
+  // If first leader has 's' flag, the lines can only be joined if there is
+  // some text after it and the second line has the 'm' flag.
+  if (leader1_flags != NULL) {
+    for (p = leader1_flags; *p && *p != ':'; p++) {
+      if (*p == COM_FIRST) {
+        return leader2_len == 0;
+      }
+      if (*p == COM_END) {
+        return false;
+      }
+      if (*p == COM_START) {
+        if (*(ml_get(lnum) + leader1_len) == NUL) {
+          return false;
+        }
+        if (leader2_flags == NULL || leader2_len == 0) {
+          return false;
+        }
+        for (p = leader2_flags; *p && *p != ':'; p++) {
+          if (*p == COM_MIDDLE) {
+            return true;
+          }
+        }
+        return false;
+      }
+    }
+  }
+
+  // Get current line and next line, compare the leaders.
+  // The first line has to be saved, only one line can be locked at a time.
+  line1 = vim_strsave(ml_get(lnum));
+  for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
+  line2 = ml_get(lnum + 1);
+  for (idx2 = 0; idx2 < leader2_len; idx2++) {
+    if (!ascii_iswhite(line2[idx2])) {
+      if (line1[idx1++] != line2[idx2]) {
+        break;
+      }
+    } else {
+      while (ascii_iswhite(line1[idx1])) {
+        idx1++;
+      }
+    }
+  }
+  xfree(line1);
+
+  return idx2 == leader2_len && idx1 == leader1_len;
+}
+
+/// Used for auto-formatting.
+///
+/// @return  true when a paragraph starts in line "lnum".
+///          false when the previous line is in the same paragraph.
+static bool paragraph_start(linenr_T lnum)
+{
+  char_u *p;
+  int leader_len = 0;                // leader len of current line
+  char_u *leader_flags = NULL;       // flags for leader of current line
+  int next_leader_len = 0;           // leader len of next line
+  char_u *next_leader_flags = NULL;  // flags for leader of next line
+
+  if (lnum <= 1) {
+    return true;                // start of the file
+  }
+  p = ml_get(lnum - 1);
+  if (*p == NUL) {
+    return true;                // after empty line
+  }
+  const bool do_comments = has_format_option(FO_Q_COMS);  // format comments
+  if (fmt_check_par(lnum - 1, &leader_len, &leader_flags, do_comments)) {
+    return true;  // after non-paragraph line
+  }
+
+  if (fmt_check_par(lnum, &next_leader_len, &next_leader_flags, do_comments)) {
+    return true;  // "lnum" is not a paragraph line
+  }
+
+  if (has_format_option(FO_WHITE_PAR) && !ends_in_white(lnum - 1)) {
+    return true;                // missing trailing space in previous line.
+  }
+  if (has_format_option(FO_Q_NUMBER) && (get_number_indent(lnum) > 0)) {
+    return true;                // numbered item starts in "lnum".
+  }
+  if (!same_leader(lnum - 1, leader_len, leader_flags,
+                   next_leader_len, next_leader_flags)) {
+    return true;                // change of comment leader.
+  }
+  return false;
+}
+
+/// Called after inserting or deleting text: When 'formatoptions' includes the
+/// 'a' flag format from the current line until the end of the paragraph.
+/// Keep the cursor at the same position relative to the text.
+/// The caller must have saved the cursor line for undo, following ones will be
+/// saved here.
+///
+/// @param trailblank  when true also format with trailing blank
+/// @param prev_line   may start in previous line
+void auto_format(bool trailblank, bool prev_line)
+{
+  pos_T pos;
+  colnr_T len;
+  char_u *old;
+  char_u *new, *pnew;
+  int wasatend;
+  int cc;
+
+  if (!has_format_option(FO_AUTO)) {
+    return;
+  }
+
+  pos = curwin->w_cursor;
+  old = get_cursor_line_ptr();
+
+  // may remove added space
+  check_auto_format(false);
+
+  // Don't format in Insert mode when the cursor is on a trailing blank, the
+  // user might insert normal text next.  Also skip formatting when "1" is
+  // in 'formatoptions' and there is a single character before the cursor.
+  // Otherwise the line would be broken and when typing another non-white
+  // next they are not joined back together.
+  wasatend = (pos.col == (colnr_T)STRLEN(old));
+  if (*old != NUL && !trailblank && wasatend) {
+    dec_cursor();
+    cc = gchar_cursor();
+    if (!WHITECHAR(cc) && curwin->w_cursor.col > 0
+        && has_format_option(FO_ONE_LETTER)) {
+      dec_cursor();
+    }
+    cc = gchar_cursor();
+    if (WHITECHAR(cc)) {
+      curwin->w_cursor = pos;
+      return;
+    }
+    curwin->w_cursor = pos;
+  }
+
+  // With the 'c' flag in 'formatoptions' and 't' missing: only format
+  // comments.
+  if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP)
+      && get_leader_len((char *)old, NULL, false, true) == 0) {
+    return;
+  }
+
+  // May start formatting in a previous line, so that after "x" a word is
+  // moved to the previous line if it fits there now.  Only when this is not
+  // the start of a paragraph.
+  if (prev_line && !paragraph_start(curwin->w_cursor.lnum)) {
+    curwin->w_cursor.lnum--;
+    if (u_save_cursor() == FAIL) {
+      return;
+    }
+  }
+
+  // Do the formatting and restore the cursor position.  "saved_cursor" will
+  // be adjusted for the text formatting.
+  saved_cursor = pos;
+  format_lines((linenr_T) - 1, false);
+  curwin->w_cursor = saved_cursor;
+  saved_cursor.lnum = 0;
+
+  if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
+    // "cannot happen"
+    curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
+    coladvance(MAXCOL);
+  } else {
+    check_cursor_col();
+  }
+
+  // Insert mode: If the cursor is now after the end of the line while it
+  // previously wasn't, the line was broken.  Because of the rule above we
+  // need to add a space when 'w' is in 'formatoptions' to keep a paragraph
+  // formatted.
+  if (!wasatend && has_format_option(FO_WHITE_PAR)) {
+    new = get_cursor_line_ptr();
+    len = (colnr_T)STRLEN(new);
+    if (curwin->w_cursor.col == len) {
+      pnew = vim_strnsave(new, (size_t)len + 2);
+      pnew[len] = ' ';
+      pnew[len + 1] = NUL;
+      ml_replace(curwin->w_cursor.lnum, (char *)pnew, false);
+      // remove the space later
+      did_add_space = true;
+    } else {
+      // may remove added space
+      check_auto_format(false);
+    }
+  }
+
+  check_cursor();
+}
+
+/// When an extra space was added to continue a paragraph for auto-formatting,
+/// delete it now.  The space must be under the cursor, just after the insert
+/// position.
+///
+/// @param end_insert  true when ending Insert mode
+void check_auto_format(bool end_insert)
+{
+  int c = ' ';
+  int cc;
+
+  if (did_add_space) {
+    cc = gchar_cursor();
+    if (!WHITECHAR(cc)) {
+      // Somehow the space was removed already.
+      did_add_space = false;
+    } else {
+      if (!end_insert) {
+        inc_cursor();
+        c = gchar_cursor();
+        dec_cursor();
+      }
+      if (c != NUL) {
+        // The space is no longer at the end of the line, delete it.
+        del_char(false);
+        did_add_space = false;
+      }
+    }
+  }
+}
+
+/// Find out textwidth to be used for formatting:
+///      if 'textwidth' option is set, use it
+///      else if 'wrapmargin' option is set, use curwin->w_width_inner-'wrapmargin'
+///      if invalid value, use 0.
+///      Set default to window width (maximum 79) for "gq" operator.
+///
+/// @param ff  force formatting (for "gq" command)
+int comp_textwidth(bool ff)
+{
+  int textwidth = (int)curbuf->b_p_tw;
+  if (textwidth == 0 && curbuf->b_p_wm) {
+    // The width is the window width minus 'wrapmargin' minus all the
+    // things that add to the margin.
+    textwidth = curwin->w_width_inner - (int)curbuf->b_p_wm;
+    if (cmdwin_type != 0) {
+      textwidth -= 1;
+    }
+    textwidth -= win_fdccol_count(curwin);
+    textwidth -= win_signcol_count(curwin);
+
+    if (curwin->w_p_nu || curwin->w_p_rnu) {
+      textwidth -= 8;
+    }
+  }
+  if (textwidth < 0) {
+    textwidth = 0;
+  }
+  if (ff && textwidth == 0) {
+    textwidth = curwin->w_width_inner - 1;
+    if (textwidth > 79) {
+      textwidth = 79;
+    }
+  }
+  return textwidth;
+}
+
+/// Implementation of the format operator 'gq'.
+///
+/// @param keep_cursor  keep cursor on same text char
+void op_format(oparg_T *oap, bool keep_cursor)
+{
+  linenr_T old_line_count = curbuf->b_ml.ml_line_count;
+
+  // Place the cursor where the "gq" or "gw" command was given, so that "u"
+  // can put it back there.
+  curwin->w_cursor = oap->cursor_start;
+
+  if (u_save((linenr_T)(oap->start.lnum - 1),
+             (linenr_T)(oap->end.lnum + 1)) == FAIL) {
+    return;
+  }
+  curwin->w_cursor = oap->start;
+
+  if (oap->is_VIsual) {
+    // When there is no change: need to remove the Visual selection
+    redraw_curbuf_later(UPD_INVERTED);
+  }
+
+  if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
+    // Set '[ mark at the start of the formatted area
+    curbuf->b_op_start = oap->start;
+  }
+
+  // For "gw" remember the cursor position and put it back below (adjusted
+  // for joined and split lines).
+  if (keep_cursor) {
+    saved_cursor = oap->cursor_start;
+  }
+
+  format_lines((linenr_T)oap->line_count, keep_cursor);
+
+  // Leave the cursor at the first non-blank of the last formatted line.
+  // If the cursor was moved one line back (e.g. with "Q}") go to the next
+  // line, so "." will do the next lines.
+  if (oap->end_adjusted && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
+    curwin->w_cursor.lnum++;
+  }
+  beginline(BL_WHITE | BL_FIX);
+  old_line_count = curbuf->b_ml.ml_line_count - old_line_count;
+  msgmore(old_line_count);
+
+  if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
+    // put '] mark on the end of the formatted area
+    curbuf->b_op_end = curwin->w_cursor;
+  }
+
+  if (keep_cursor) {
+    curwin->w_cursor = saved_cursor;
+    saved_cursor.lnum = 0;
+
+    // formatting may have made the cursor position invalid
+    check_cursor();
+  }
+
+  if (oap->is_VIsual) {
+    FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+      if (wp->w_old_cursor_lnum != 0) {
+        // When lines have been inserted or deleted, adjust the end of
+        // the Visual area to be redrawn.
+        if (wp->w_old_cursor_lnum > wp->w_old_visual_lnum) {
+          wp->w_old_cursor_lnum += old_line_count;
+        } else {
+          wp->w_old_visual_lnum += old_line_count;
+        }
+      }
+    }
+  }
+}
+
+/// Implementation of the format operator 'gq' for when using 'formatexpr'.
+void op_formatexpr(oparg_T *oap)
+{
+  if (oap->is_VIsual) {
+    // When there is no change: need to remove the Visual selection
+    redraw_curbuf_later(UPD_INVERTED);
+  }
+
+  if (fex_format(oap->start.lnum, oap->line_count, NUL) != 0) {
+    // As documented: when 'formatexpr' returns non-zero fall back to
+    // internal formatting.
+    op_format(oap, false);
+  }
+}
+
+/// @param c  character to be inserted
+int fex_format(linenr_T lnum, long count, int c)
+{
+  int use_sandbox = was_set_insecurely(curwin, "formatexpr", OPT_LOCAL);
+  int r;
+
+  // Set v:lnum to the first line number and v:count to the number of lines.
+  // Set v:char to the character to be inserted (can be NUL).
+  set_vim_var_nr(VV_LNUM, (varnumber_T)lnum);
+  set_vim_var_nr(VV_COUNT, (varnumber_T)count);
+  set_vim_var_char(c);
+
+  // Make a copy, the option could be changed while calling it.
+  char *fex = xstrdup(curbuf->b_p_fex);
+  // Evaluate the function.
+  if (use_sandbox) {
+    sandbox++;
+  }
+  r = (int)eval_to_number(fex);
+  if (use_sandbox) {
+    sandbox--;
+  }
+
+  set_vim_var_string(VV_CHAR, NULL, -1);
+  xfree(fex);
+
+  return r;
+}
+
+/// @param line_count  number of lines to format, starting at the cursor position.
+///                    when negative, format until the end of the paragraph.
+///
+/// Lines after the cursor line are saved for undo, caller must have saved the
+/// first line.
+///
+/// @param avoid_fex  don't use 'formatexpr'
+void format_lines(linenr_T line_count, bool avoid_fex)
+{
+  bool is_not_par;                  // current line not part of parag.
+  bool next_is_not_par;             // next line not part of paragraph
+  bool is_end_par;                  // at end of paragraph
+  bool prev_is_end_par = false;     // prev. line not part of parag.
+  bool next_is_start_par = false;
+  int leader_len = 0;               // leader len of current line
+  int next_leader_len;              // leader len of next line
+  char_u *leader_flags = NULL;      // flags for leader of current line
+  char_u *next_leader_flags = NULL;  // flags for leader of next line
+  bool advance = true;
+  int second_indent = -1;           // indent for second line (comment aware)
+  bool first_par_line = true;
+  int smd_save;
+  long count;
+  bool need_set_indent = true;      // set indent of next paragraph
+  linenr_T first_line = curwin->w_cursor.lnum;
+  bool force_format = false;
+  const int old_State = State;
+
+  // length of a line to force formatting: 3 * 'tw'
+  const int max_len = comp_textwidth(true) * 3;
+
+  // check for 'q', '2' and '1' in 'formatoptions'
+  const bool do_comments = has_format_option(FO_Q_COMS);  // format comments
+  int do_comments_list = 0;  // format comments with 'n' or '2'
+  const bool do_second_indent = has_format_option(FO_Q_SECOND);
+  const bool do_number_indent = has_format_option(FO_Q_NUMBER);
+  const bool do_trail_white = has_format_option(FO_WHITE_PAR);
+
+  // Get info about the previous and current line.
+  if (curwin->w_cursor.lnum > 1) {
+    is_not_par = fmt_check_par(curwin->w_cursor.lnum - 1,
+                               &leader_len, &leader_flags, do_comments);
+  } else {
+    is_not_par = true;
+  }
+  next_is_not_par = fmt_check_par(curwin->w_cursor.lnum,
+                                  &next_leader_len, &next_leader_flags, do_comments);
+  is_end_par = (is_not_par || next_is_not_par);
+  if (!is_end_par && do_trail_white) {
+    is_end_par = !ends_in_white(curwin->w_cursor.lnum - 1);
+  }
+
+  curwin->w_cursor.lnum--;
+  for (count = line_count; count != 0 && !got_int; count--) {
+    // Advance to next paragraph.
+    if (advance) {
+      curwin->w_cursor.lnum++;
+      prev_is_end_par = is_end_par;
+      is_not_par = next_is_not_par;
+      leader_len = next_leader_len;
+      leader_flags = next_leader_flags;
+    }
+
+    // The last line to be formatted.
+    if (count == 1 || curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count) {
+      next_is_not_par = true;
+      next_leader_len = 0;
+      next_leader_flags = NULL;
+    } else {
+      next_is_not_par = fmt_check_par(curwin->w_cursor.lnum + 1,
+                                      &next_leader_len, &next_leader_flags, do_comments);
+      if (do_number_indent) {
+        next_is_start_par =
+          (get_number_indent(curwin->w_cursor.lnum + 1) > 0);
+      }
+    }
+    advance = true;
+    is_end_par = (is_not_par || next_is_not_par || next_is_start_par);
+    if (!is_end_par && do_trail_white) {
+      is_end_par = !ends_in_white(curwin->w_cursor.lnum);
+    }
+
+    // Skip lines that are not in a paragraph.
+    if (is_not_par) {
+      if (line_count < 0) {
+        break;
+      }
+    } else {
+      // For the first line of a paragraph, check indent of second line.
+      // Don't do this for comments and empty lines.
+      if (first_par_line
+          && (do_second_indent || do_number_indent)
+          && prev_is_end_par
+          && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
+        if (do_second_indent && !LINEEMPTY(curwin->w_cursor.lnum + 1)) {
+          if (leader_len == 0 && next_leader_len == 0) {
+            // no comment found
+            second_indent =
+              get_indent_lnum(curwin->w_cursor.lnum + 1);
+          } else {
+            second_indent = next_leader_len;
+            do_comments_list = 1;
+          }
+        } else if (do_number_indent) {
+          if (leader_len == 0 && next_leader_len == 0) {
+            // no comment found
+            second_indent =
+              get_number_indent(curwin->w_cursor.lnum);
+          } else {
+            // get_number_indent() is now "comment aware"...
+            second_indent =
+              get_number_indent(curwin->w_cursor.lnum);
+            do_comments_list = 1;
+          }
+        }
+      }
+
+      // When the comment leader changes, it's the end of the paragraph.
+      if (curwin->w_cursor.lnum >= curbuf->b_ml.ml_line_count
+          || !same_leader(curwin->w_cursor.lnum,
+                          leader_len, leader_flags,
+                          next_leader_len,
+                          next_leader_flags)) {
+        // Special case: If the next line starts with a line comment
+        // and this line has a line comment after some text, the
+        // paragraph doesn't really end.
+        if (next_leader_flags == NULL
+            || STRNCMP(next_leader_flags, "://", 3) != 0
+            || check_linecomment(get_cursor_line_ptr()) == MAXCOL) {
+          is_end_par = true;
+        }
+      }
+
+      // If we have got to the end of a paragraph, or the line is
+      // getting long, format it.
+      if (is_end_par || force_format) {
+        if (need_set_indent) {
+          int indent = 0;  // amount of indent needed
+
+          // Replace indent in first line of a paragraph with minimal
+          // number of tabs and spaces, according to current options.
+          // For the very first formatted line keep the current
+          // indent.
+          if (curwin->w_cursor.lnum == first_line) {
+            indent = get_indent();
+          } else if (curbuf->b_p_lisp) {
+            indent = get_lisp_indent();
+          } else {
+            if (cindent_on()) {
+              indent = *curbuf->b_p_inde != NUL ? get_expr_indent() : get_c_indent();
+            } else {
+              indent = get_indent();
+            }
+          }
+          (void)set_indent(indent, SIN_CHANGED);
+        }
+
+        // put cursor on last non-space
+        State = MODE_NORMAL;  // don't go past end-of-line
+        coladvance(MAXCOL);
+        while (curwin->w_cursor.col && ascii_isspace(gchar_cursor())) {
+          dec_cursor();
+        }
+
+        // do the formatting, without 'showmode'
+        State = MODE_INSERT;         // for open_line()
+        smd_save = p_smd;
+        p_smd = false;
+        insertchar(NUL, INSCHAR_FORMAT
+                   + (do_comments ? INSCHAR_DO_COM : 0)
+                   + (do_comments && do_comments_list ? INSCHAR_COM_LIST : 0)
+                   + (avoid_fex ? INSCHAR_NO_FEX : 0), second_indent);
+        State = old_State;
+        p_smd = smd_save;
+        second_indent = -1;
+        // at end of par.: need to set indent of next par.
+        need_set_indent = is_end_par;
+        if (is_end_par) {
+          // When called with a negative line count, break at the
+          // end of the paragraph.
+          if (line_count < 0) {
+            break;
+          }
+          first_par_line = true;
+        }
+        force_format = false;
+      }
+
+      // When still in same paragraph, join the lines together.  But
+      // first delete the leader from the second line.
+      if (!is_end_par) {
+        advance = false;
+        curwin->w_cursor.lnum++;
+        curwin->w_cursor.col = 0;
+        if (line_count < 0 && u_save_cursor() == FAIL) {
+          break;
+        }
+        if (next_leader_len > 0) {
+          (void)del_bytes(next_leader_len, false, false);
+          mark_col_adjust(curwin->w_cursor.lnum, (colnr_T)0, 0L,
+                          (long)-next_leader_len, 0);
+        } else if (second_indent > 0) {   // the "leader" for FO_Q_SECOND
+          int indent = (int)getwhitecols_curline();
+
+          if (indent > 0) {
+            (void)del_bytes(indent, false, false);
+            mark_col_adjust(curwin->w_cursor.lnum,
+                            (colnr_T)0, 0L, (long)-indent, 0);
+          }
+        }
+        curwin->w_cursor.lnum--;
+        if (do_join(2, true, false, false, false) == FAIL) {
+          beep_flush();
+          break;
+        }
+        first_par_line = false;
+        // If the line is getting long, format it next time
+        if (STRLEN(get_cursor_line_ptr()) > (size_t)max_len) {
+          force_format = true;
+        } else {
+          force_format = false;
+        }
+      }
+    }
+    line_breakcheck();
+  }
+}
diff --git a/src/nvim/textformat.h b/src/nvim/textformat.h
new file mode 100644
index 0000000000..9d8327e6eb
--- /dev/null
+++ b/src/nvim/textformat.h
@@ -0,0 +1,12 @@
+#ifndef NVIM_TEXTFORMAT_H
+#define NVIM_TEXTFORMAT_H
+
+#include <stdbool.h>
+
+#include "nvim/normal.h"  // for oparg_T
+#include "nvim/pos.h"  // for linenr_T
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "textformat.h.generated.h"
+#endif
+#endif  // NVIM_TEXTFORMAT_H
-- 
cgit 


From 395277036014189c03b8969fc0a5cd2bdc5c8631 Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 10:36:35 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/autocmd.c      |   8 +-
 src/nvim/buffer.c       |   8 +-
 src/nvim/charset.c      |   6 +-
 src/nvim/cursor_shape.c |   2 +-
 src/nvim/diff.c         |   2 +-
 src/nvim/edit.c         |   4 +-
 src/nvim/eval.c         |   8 +-
 src/nvim/eval/funcs.c   |   6 +-
 src/nvim/ex_cmds.c      |   4 +-
 src/nvim/ex_cmds2.c     |   6 +-
 src/nvim/ex_docmd.c     |   8 +-
 src/nvim/ex_getln.c     |   7 +-
 src/nvim/fileio.c       |  14 +--
 src/nvim/hardcopy.c     |  24 ++--
 src/nvim/help.c         |   8 +-
 src/nvim/if_cscope.c    |   4 +-
 src/nvim/insexpand.c    |  15 +--
 src/nvim/main.c         |   2 +-
 src/nvim/mapping.c      |   2 +-
 src/nvim/mbyte.c        |   2 +-
 src/nvim/memline.c      |   8 +-
 src/nvim/message.c      |   6 +-
 src/nvim/normal.c       |  22 ++--
 src/nvim/ops.c          |  15 ++-
 src/nvim/option.c       |  46 ++++----
 src/nvim/option_defs.h  | 252 ++++++++++++++++++++---------------------
 src/nvim/optionstr.c    | 295 ++++++++++++++++++++++++------------------------
 src/nvim/os/env.c       |   6 +-
 src/nvim/path.c         |   2 +-
 src/nvim/popupmenu.c    |   2 +-
 src/nvim/quickfix.c     |  14 +--
 src/nvim/runtime.c      |  61 +++++-----
 src/nvim/screen.c       |  10 +-
 src/nvim/search.c       |   6 +-
 src/nvim/shada.c        |   2 +-
 src/nvim/spell.c        |   2 +-
 src/nvim/spellfile.c    |  10 +-
 src/nvim/spellsuggest.c |   4 +-
 src/nvim/statusline.c   |   8 +-
 src/nvim/syntax.c       | 141 +++++++++++------------
 src/nvim/tag.c          |   2 +-
 src/nvim/ui.c           |   4 +-
 src/nvim/version.c      |   2 +-
 43 files changed, 526 insertions(+), 534 deletions(-)

(limited to 'src')

diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index e970387456..2fe9df2206 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -686,7 +686,7 @@ const char *event_nr2name(event_T event)
 static bool event_ignored(event_T event)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  char *p = (char *)p_ei;
+  char *p = p_ei;
 
   while (*p != NUL) {
     if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ',')) {
@@ -703,7 +703,7 @@ static bool event_ignored(event_T event)
 // Return OK when the contents of p_ei is valid, FAIL otherwise.
 int check_ei(void)
 {
-  char *p = (char *)p_ei;
+  char *p = p_ei;
 
   while (*p) {
     if (STRNICMP(p, "all", 3) == 0 && (p[3] == NUL || p[3] == ',')) {
@@ -724,8 +724,8 @@ int check_ei(void)
 // Returns the old value of 'eventignore' in allocated memory.
 char *au_event_disable(char *what)
 {
-  char *save_ei = (char *)vim_strsave(p_ei);
-  char *new_ei = (char *)vim_strnsave(p_ei, STRLEN(p_ei) + STRLEN(what));
+  char *save_ei = xstrdup(p_ei);
+  char *new_ei = xstrnsave(p_ei, STRLEN(p_ei) + STRLEN(what));
   if (*what == ',' && *p_ei == NUL) {
     STRCPY(new_ei, what + 1);
   } else {
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 03b4c1bae8..24fd1b3022 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -3167,14 +3167,14 @@ void maketitle(void)
 
         use_sandbox = was_set_insecurely(curwin, "titlestring", 0);
         build_stl_str_hl(curwin, buf, sizeof(buf),
-                         (char *)p_titlestring, use_sandbox,
+                         p_titlestring, use_sandbox,
                          0, maxlen, NULL, NULL);
         title_str = buf;
         if (called_emsg > called_emsg_before) {
           set_string_option_direct("titlestring", -1, "", OPT_FREE, SID_ERROR);
         }
       } else {
-        title_str = (char *)p_titlestring;
+        title_str = p_titlestring;
       }
     } else {
       // Format: "fname + (path) (1 of 2) - VIM".
@@ -3281,13 +3281,13 @@ void maketitle(void)
 
         use_sandbox = was_set_insecurely(curwin, "iconstring", 0);
         build_stl_str_hl(curwin, icon_str, sizeof(buf),
-                         (char *)p_iconstring, use_sandbox,
+                         p_iconstring, use_sandbox,
                          0, 0, NULL, NULL);
         if (called_emsg > called_emsg_before) {
           set_string_option_direct("iconstring", -1, "", OPT_FREE, SID_ERROR);
         }
       } else {
-        icon_str = (char *)p_iconstring;
+        icon_str = p_iconstring;
       }
     } else {
       char *buf_p;
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index d48cadf356..dc62b85716 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -140,13 +140,13 @@ int buf_init_chartab(buf_T *buf, int global)
     const char_u *p;
     if (i == 0) {
       // first round: 'isident'
-      p = p_isi;
+      p = (char_u *)p_isi;
     } else if (i == 1) {
       // second round: 'isprint'
-      p = p_isp;
+      p = (char_u *)p_isp;
     } else if (i == 2) {
       // third round: 'isfname'
-      p = p_isf;
+      p = (char_u *)p_isf;
     } else {  // i == 3
       // fourth round: 'iskeyword'
       p = (char_u *)buf->b_p_isk;
diff --git a/src/nvim/cursor_shape.c b/src/nvim/cursor_shape.c
index 9c33b1a806..73ad99876a 100644
--- a/src/nvim/cursor_shape.c
+++ b/src/nvim/cursor_shape.c
@@ -120,7 +120,7 @@ char *parse_shape_opt(int what)
       }
     }
     // Repeat for all comma separated parts.
-    char *modep = (char *)p_guicursor;
+    char *modep = p_guicursor;
     while (modep != NULL && *modep != NUL) {
       colonp = vim_strchr(modep, ':');
       commap = vim_strchr(modep, ',');
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index fa1c669aaf..8107b64c83 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2139,7 +2139,7 @@ int diffopt_changed(void)
   long diff_algorithm_new = 0;
   long diff_indent_heuristic = 0;
 
-  char *p = (char *)p_dip;
+  char *p = p_dip;
   while (*p != NUL) {
     if (STRNCMP(p, "filler", 6) == 0) {
       p += 6;
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index d9aec2fbad..55f4d77feb 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -4290,7 +4290,7 @@ static void ins_left(void)
       revins_legal++;
     }
     revins_chars++;
-  } else if (vim_strchr((char *)p_ww, '[') != NULL && curwin->w_cursor.lnum > 1) {
+  } else if (vim_strchr(p_ww, '[') != NULL && curwin->w_cursor.lnum > 1) {
     // if 'whichwrap' set for cursor in insert mode may go to previous line.
     // always break undo when moving upwards/downwards, else undo may break
     start_arrow(&tpos);
@@ -4383,7 +4383,7 @@ static void ins_right(void)
     if (revins_chars) {
       revins_chars--;
     }
-  } else if (vim_strchr((char *)p_ww, ']') != NULL
+  } else if (vim_strchr(p_ww, ']') != NULL
              && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
     // if 'whichwrap' set for cursor in insert mode, may move the
     // cursor to the next line
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index adcc173c71..848b1dd2cd 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -631,7 +631,7 @@ int eval_charconvert(const char *const enc_from, const char *const enc_to,
   set_vim_var_string(VV_CC_TO, enc_to, -1);
   set_vim_var_string(VV_FNAME_IN, fname_from, -1);
   set_vim_var_string(VV_FNAME_OUT, fname_to, -1);
-  if (eval_to_bool((char *)p_ccv, &err, NULL, false)) {
+  if (eval_to_bool(p_ccv, &err, NULL, false)) {
     err = true;
   }
   set_vim_var_string(VV_CC_FROM, NULL, -1);
@@ -651,7 +651,7 @@ int eval_printexpr(const char *const fname, const char *const args)
 
   set_vim_var_string(VV_FNAME_IN, fname, -1);
   set_vim_var_string(VV_CMDARG, args, -1);
-  if (eval_to_bool((char *)p_pexpr, &err, NULL, false)) {
+  if (eval_to_bool(p_pexpr, &err, NULL, false)) {
     err = true;
   }
   set_vim_var_string(VV_FNAME_IN, NULL, -1);
@@ -671,7 +671,7 @@ void eval_diff(const char *const origfile, const char *const newfile, const char
   set_vim_var_string(VV_FNAME_IN, origfile, -1);
   set_vim_var_string(VV_FNAME_NEW, newfile, -1);
   set_vim_var_string(VV_FNAME_OUT, outfile, -1);
-  (void)eval_to_bool((char *)p_dex, &err, NULL, false);
+  (void)eval_to_bool(p_dex, &err, NULL, false);
   set_vim_var_string(VV_FNAME_IN, NULL, -1);
   set_vim_var_string(VV_FNAME_NEW, NULL, -1);
   set_vim_var_string(VV_FNAME_OUT, NULL, -1);
@@ -8601,7 +8601,7 @@ void ex_checkhealth(exarg_T *eap)
     if (vimruntime_env == NULL) {
       emsg(_("E5009: $VIMRUNTIME is empty or unset"));
     } else {
-      bool rtp_ok = NULL != strstr((char *)p_rtp, vimruntime_env);
+      bool rtp_ok = NULL != strstr(p_rtp, vimruntime_env);
       if (rtp_ok) {
         semsg(_("E5009: Invalid $VIMRUNTIME: %s"), vimruntime_env);
       } else {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 78298765a0..581f187140 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -8379,7 +8379,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
     conv.vc_type = CONV_NONE;
     enc = enc_locale();
-    convert_setup(&conv, p_enc, enc);
+    convert_setup(&conv, (char_u *)p_enc, enc);
     if (conv.vc_type != CONV_NONE) {
       p = (char *)string_convert(&conv, (char_u *)p, NULL);
     }
@@ -8393,7 +8393,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     if (conv.vc_type != CONV_NONE) {
       xfree(p);
     }
-    convert_setup(&conv, enc, p_enc);
+    convert_setup(&conv, enc, (char_u *)p_enc);
     if (conv.vc_type != CONV_NONE) {
       rettv->vval.v_string = (char *)string_convert(&conv, (char_u *)result_buf, NULL);
     } else {
@@ -8639,7 +8639,7 @@ static void f_strptime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     .vc_type = CONV_NONE,
   };
   char_u *enc = enc_locale();
-  convert_setup(&conv, p_enc, enc);
+  convert_setup(&conv, (char_u *)p_enc, enc);
   if (conv.vc_type != CONV_NONE) {
     fmt = (char *)string_convert(&conv, (char_u *)fmt, NULL);
   }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 91df8c169a..a72cddc0a9 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -2040,7 +2040,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
         STRCPY(dir, ".");
       } else {
         dir = xmalloc(MAXPATHL);
-        p = (char *)p_dir;
+        p = p_dir;
         copy_option_part(&p, dir, MAXPATHL, ",");
       }
       swapname = (char *)makeswapname((char_u *)fname, (char_u *)ffname, curbuf, (char_u *)dir);
@@ -4787,7 +4787,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
                     long cmdpreview_ns, handle_T cmdpreview_bufnr)
   FUNC_ATTR_NONNULL_ALL
 {
-  char *save_shm_p = (char *)vim_strsave(p_shm);
+  char *save_shm_p = xstrdup(p_shm);
   PreviewLines lines = *preview_lines;
   buf_T *orig_buf = curbuf;
   // We keep a special-purpose buffer around, but don't assume it exists.
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 41512205dc..dbdfc2b18a 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -543,7 +543,7 @@ void ex_listdo(exarg_T *eap)
         if (curwin->w_arg_idx != i || !editing_arg_idx(curwin)) {
           // Clear 'shm' to avoid that the file message overwrites
           // any output from the command.
-          p_shm_save = (char *)vim_strsave(p_shm);
+          p_shm_save = xstrdup(p_shm);
           set_option_value_give_err("shm", 0L, "", 0);
           do_argfile(eap, i);
           set_option_value_give_err("shm", 0L, p_shm_save, 0);
@@ -612,7 +612,7 @@ void ex_listdo(exarg_T *eap)
 
         // Go to the next buffer.  Clear 'shm' to avoid that the file
         // message overwrites any output from the command.
-        p_shm_save = (char *)vim_strsave(p_shm);
+        p_shm_save = xstrdup(p_shm);
         set_option_value_give_err("shm", 0L, "", 0);
         goto_buffer(eap, DOBUF_FIRST, FORWARD, next_fnum);
         set_option_value_give_err("shm", 0L, p_shm_save, 0);
@@ -635,7 +635,7 @@ void ex_listdo(exarg_T *eap)
 
         // Clear 'shm' to avoid that the file message overwrites
         // any output from the command.
-        p_shm_save = (char *)vim_strsave(p_shm);
+        p_shm_save = xstrdup(p_shm);
         set_option_value_give_err("shm", 0L, "", 0);
         ex_cnext(eap);
         set_option_value_give_err("shm", 0L, p_shm_save, 0);
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 29812dd8fe..12e2656996 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2580,7 +2580,7 @@ static void apply_cmdmod(cmdmod_T *cmod)
   if ((cmod->cmod_flags & CMOD_NOAUTOCMD) && cmod->cmod_save_ei == NULL) {
     // Set 'eventignore' to "all".
     // First save the existing option value for restoring it later.
-    cmod->cmod_save_ei = (char *)vim_strsave(p_ei);
+    cmod->cmod_save_ei = xstrdup(p_ei);
     set_string_option_direct("ei", -1, "all", OPT_FREE, SID_NONE);
   }
 }
@@ -6954,16 +6954,16 @@ char *expand_sfile(char *arg)
 /// ":rshada" and ":wshada".
 static void ex_shada(exarg_T *eap)
 {
-  char *save_shada = (char *)p_shada;
+  char *save_shada = p_shada;
   if (*p_shada == NUL) {
-    p_shada = (char_u *)"'100";
+    p_shada = "'100";
   }
   if (eap->cmdidx == CMD_rviminfo || eap->cmdidx == CMD_rshada) {
     (void)shada_read_everything(eap->arg, eap->forceit, false);
   } else {
     shada_write_file(eap->arg, eap->forceit);
   }
-  p_shada = (char_u *)save_shada;
+  p_shada = save_shada;
 }
 
 /// Make a dialog message in "buff[DIALOG_MSG_SIZE]".
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 26ed318c10..d73a57ad75 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -634,7 +634,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
     .ignore_drag_release = true,
   };
   CommandLineState *s = &state;
-  s->save_p_icm = vim_strsave(p_icm);
+  s->save_p_icm = vim_strsave((char_u *)p_icm);
   init_incsearch_state(&s->is_state);
   CmdlineInfo save_ccline;
   bool did_save_ccline = false;
@@ -2538,7 +2538,6 @@ char_u *get_cmdprompt(void)
 int check_opt_wim(void)
 {
   char_u new_wim_flags[4];
-  char_u *p;
   int i;
   int idx = 0;
 
@@ -2546,7 +2545,7 @@ int check_opt_wim(void)
     new_wim_flags[i] = 0;
   }
 
-  for (p = p_wim; *p; p++) {
+  for (char *p = p_wim; *p; p++) {
     for (i = 0; ASCII_ISALPHA(p[i]); i++) {}
     if (p[i] != NUL && p[i] != ',' && p[i] != ':') {
       return FAIL;
@@ -4090,7 +4089,7 @@ char *check_cedit(void)
   if (*p_cedit == NUL) {
     cedit_key = -1;
   } else {
-    n = string_to_key(p_cedit);
+    n = string_to_key((char_u *)p_cedit);
     if (vim_isprintc(n)) {
       return e_invarg;
     }
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 206ef7c98d..21c1549f42 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -711,7 +711,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     fenc = curbuf->b_p_fenc;            // use format from buffer
     fenc_alloced = false;
   } else {
-    fenc_next = (char *)p_fencs;                // try items in 'fileencodings'
+    fenc_next = p_fencs;                // try items in 'fileencodings'
     fenc = (char *)next_fenc(&fenc_next, &fenc_alloced);
   }
 
@@ -2735,7 +2735,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     if (*p_bex == NUL) {
       backup_ext = ".bak";
     } else {
-      backup_ext = (char *)p_bex;
+      backup_ext = p_bex;
     }
 
     if (backup_copy) {
@@ -2757,7 +2757,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
        * For these reasons, the existing writable file must be truncated
        * and reused. Creation of a backup COPY will be attempted.
        */
-      dirp = (char *)p_bdir;
+      dirp = p_bdir;
       while (*dirp) {
         /*
          * Isolate one directory name, using an entry in 'bdir'.
@@ -2918,7 +2918,7 @@ nobackup:
        * path/fo.o.h.bak Try all directories in 'backupdir', first one
        * that works is used.
        */
-      dirp = (char *)p_bdir;
+      dirp = p_bdir;
       while (*dirp) {
         /*
          * Isolate one directory name and make the backup file name.
@@ -3572,7 +3572,7 @@ restore_backup:
    * the backup file our 'original' file.
    */
   if (*p_pm && dobackup) {
-    char *const org = modname(fname, (char *)p_pm, false);
+    char *const org = modname(fname, p_pm, false);
 
     if (backup != NULL) {
       /*
@@ -4172,7 +4172,7 @@ static bool need_conversion(const char_u *fenc)
   } else {
     // Ignore difference between "ansi" and "latin1", "ucs-4" and
     // "ucs-4be", etc.
-    enc_flags = get_fio_flags(p_enc);
+    enc_flags = get_fio_flags((char_u *)p_enc);
     fenc_flags = get_fio_flags(fenc);
     same_encoding = (enc_flags != 0 && fenc_flags == enc_flags);
   }
@@ -4196,7 +4196,7 @@ static int get_fio_flags(const char_u *name)
   int prop;
 
   if (*name == NUL) {
-    name = p_enc;
+    name = (char_u *)p_enc;
   }
   prop = enc_canon_props(name);
   if (prop & ENC_UNICODE) {
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 7d261b751c..5451b4f4fd 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -264,7 +264,7 @@ struct prt_resfile_buffer_S {
  */
 char *parse_printoptions(void)
 {
-  return parse_list_options(p_popt, printer_opts, OPT_PRINT_NUM_OPTIONS);
+  return parse_list_options((char_u *)p_popt, printer_opts, OPT_PRINT_NUM_OPTIONS);
 }
 
 /*
@@ -273,7 +273,7 @@ char *parse_printoptions(void)
  */
 char *parse_printmbfont(void)
 {
-  return parse_list_options(p_pmfn, mbfont_opts, OPT_MBFONT_NUM_OPTIONS);
+  return parse_list_options((char_u *)p_pmfn, mbfont_opts, OPT_MBFONT_NUM_OPTIONS);
 }
 
 /*
@@ -2158,9 +2158,9 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
   /*
    * Set up font and encoding.
    */
-  p_encoding = enc_skip(p_penc);
+  p_encoding = enc_skip((char_u *)p_penc);
   if (*p_encoding == NUL) {
-    p_encoding = enc_skip(p_enc);
+    p_encoding = enc_skip((char_u *)p_enc);
   }
 
   // Look for a multi-byte font that matches the encoding and character set.
@@ -2179,7 +2179,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
           p_mbenc_first = p_mbenc;
           effective_cmap = cmap;
         }
-        if (prt_match_charset((char *)p_pmcs, &prt_ps_mbfonts[cmap], &p_mbchar)) {
+        if (prt_match_charset(p_pmcs, &prt_ps_mbfonts[cmap], &p_mbchar)) {
           break;
         }
       }
@@ -2330,7 +2330,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
    * Set up the font size.
    */
   fontsize = PRT_PS_DEFAULT_FONTSIZE;
-  for (p = p_pfn; (p = (char_u *)vim_strchr((char *)p, ':')) != NULL; p++) {
+  for (p = (char_u *)p_pfn; (p = (char_u *)vim_strchr((char *)p, ':')) != NULL; p++) {
     if (p[1] == 'h' && ascii_isdigit(p[2])) {
       fontsize = atoi((char *)p + 2);
     }
@@ -2594,13 +2594,13 @@ bool mch_print_begin(prt_settings_T *psettings)
   // that cannot be found then default to "latin1".
   // Note: VIM specific encoding header is always skipped.
   if (!prt_out_mbyte) {
-    p_encoding = (char *)enc_skip(p_penc);
+    p_encoding = (char *)enc_skip((char_u *)p_penc);
     if (*p_encoding == NUL
         || !prt_find_resource(p_encoding, &res_encoding)) {
       // 'printencoding' not set or not supported - find alternate
       int props;
 
-      p_encoding = (char *)enc_skip(p_enc);
+      p_encoding = (char *)enc_skip((char_u *)p_enc);
       props = enc_canon_props((char_u *)p_encoding);
       if (!(props & ENC_8BIT)
           || !prt_find_resource(p_encoding, &res_encoding)) {
@@ -2620,9 +2620,9 @@ bool mch_print_begin(prt_settings_T *psettings)
     // For the moment there are no checks on encoding resource files to
     // perform
   } else {
-    p_encoding = (char *)enc_skip(p_penc);
+    p_encoding = (char *)enc_skip((char_u *)p_penc);
     if (*p_encoding == NUL) {
-      p_encoding = (char *)enc_skip(p_enc);
+      p_encoding = (char *)enc_skip((char_u *)p_enc);
     }
     if (prt_use_courier) {
       // Include ASCII range encoding vector
@@ -2640,9 +2640,9 @@ bool mch_print_begin(prt_settings_T *psettings)
   }
 
   prt_conv.vc_type = CONV_NONE;
-  if (!(enc_canon_props(p_enc) & enc_canon_props((char_u *)p_encoding) & ENC_8BIT)) {
+  if (!(enc_canon_props((char_u *)p_enc) & enc_canon_props((char_u *)p_encoding) & ENC_8BIT)) {
     // Set up encoding conversion if required
-    if (convert_setup(&prt_conv, p_enc, (char_u *)p_encoding) == FAIL) {
+    if (convert_setup(&prt_conv, (char_u *)p_enc, (char_u *)p_encoding) == FAIL) {
       semsg(_("E620: Unable to convert to print encoding \"%s\""),
             p_encoding);
       return false;
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 5b2d3a17a3..19bf67c890 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -137,7 +137,7 @@ void ex_help(exarg_T *eap)
     } else {
       // There is no help window yet.
       // Try to open the file specified by the "helpfile" option.
-      if ((helpfd = os_fopen((char *)p_hf, READBIN)) == NULL) {
+      if ((helpfd = os_fopen(p_hf, READBIN)) == NULL) {
         smsg(_("Sorry, help file \"%s\" not found"), p_hf);
         goto erret;
       }
@@ -701,7 +701,7 @@ void fix_help_buffer(void)
 
       // Go through all directories in 'runtimepath', skipping
       // $VIMRUNTIME.
-      char *p = (char *)p_rtp;
+      char *p = p_rtp;
       while (*p != NUL) {
         copy_option_part(&p, (char *)NameBuff, MAXPATHL, ",");
         char *const rt = vim_getenv("VIMRUNTIME");
@@ -804,7 +804,7 @@ void fix_help_buffer(void)
                 vc.vc_type = CONV_NONE;
                 convert_setup(&vc,
                               (char_u *)(this_utf == kTrue ? "utf-8" : "latin1"),
-                              p_enc);
+                              (char_u *)p_enc);
                 if (vc.vc_type == CONV_NONE) {
                   // No conversion needed.
                   cp = (char *)IObuff;
@@ -1163,7 +1163,7 @@ void ex_helptags(exarg_T *eap)
   }
 
   if (STRCMP(eap->arg, "ALL") == 0) {
-    do_in_path(p_rtp, "doc", DIP_ALL + DIP_DIR, helptags_cb, &add_help_tags);
+    do_in_path((char_u *)p_rtp, "doc", DIP_ALL + DIP_DIR, helptags_cb, &add_help_tags);
   } else {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_DIRECTORIES;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index e32b58fbcb..50ec444d51 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -757,7 +757,7 @@ err_closing:
 #endif
     // expand the cscope exec for env var's
     prog = xmalloc(MAXPATHL + 1);
-    expand_env(p_csprg, (char_u *)prog, MAXPATHL);
+    expand_env((char_u *)p_csprg, (char_u *)prog, MAXPATHL);
 
     // alloc space to hold the cscope command
     size_t len = strlen(prog) + strlen(csinfo[i].fname) + 32;
@@ -953,7 +953,7 @@ static bool cs_find_common(char *opt, char *pat, int forceit, int verbose, bool
     cmdletter = opt[0];
   }
 
-  qfpos = vim_strchr((char *)p_csqf, cmdletter);
+  qfpos = vim_strchr(p_csqf, cmdletter);
   if (qfpos != NULL) {
     qfpos++;
     // next symbol must be + or -
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 7d17a284e5..e6c13f315e 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1008,10 +1008,10 @@ void completeopt_was_set(void)
 {
   compl_no_insert = false;
   compl_no_select = false;
-  if (strstr((char *)p_cot, "noselect") != NULL) {
+  if (strstr(p_cot, "noselect") != NULL) {
     compl_no_select = true;
   }
-  if (strstr((char *)p_cot, "noinsert") != NULL) {
+  if (strstr(p_cot, "noinsert") != NULL) {
     compl_no_insert = true;
   }
 }
@@ -1037,7 +1037,7 @@ bool pum_wanted(void)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   // "completeopt" must contain "menu" or "menuone"
-  return vim_strchr((char *)p_cot, 'm') != NULL;
+  return vim_strchr(p_cot, 'm') != NULL;
 }
 
 /// Check that there are two or more matches to be shown in the popup menu.
@@ -1056,7 +1056,7 @@ static bool pum_enough_matches(void)
     compl = compl->cp_next;
   } while (!is_first_match(compl));
 
-  if (strstr((char *)p_cot, "menuone") != NULL) {
+  if (strstr(p_cot, "menuone") != NULL) {
     return i >= 1;
   }
   return i >= 2;
@@ -2105,7 +2105,7 @@ bool ins_compl_prep(int c)
   // Set "compl_get_longest" when finding the first matches.
   if (ctrl_x_mode_not_defined_yet()
       || (ctrl_x_mode_normal() && !compl_started)) {
-    compl_get_longest = (strstr((char *)p_cot, "longest") != NULL);
+    compl_get_longest = (strstr(p_cot, "longest") != NULL);
     compl_used_match = true;
   }
 
@@ -2229,7 +2229,7 @@ static char_u *get_complete_funcname(int type)
   case CTRL_X_OMNI:
     return (char_u *)curbuf->b_p_ofu;
   case CTRL_X_THESAURUS:
-    return *curbuf->b_p_tsrfu == NUL ? p_tsrfu : (char_u *)curbuf->b_p_tsrfu;
+    return *curbuf->b_p_tsrfu == NUL ? (char_u *)p_tsrfu : (char_u *)curbuf->b_p_tsrfu;
   default:
     return (char_u *)"";
   }
@@ -2825,7 +2825,8 @@ static void get_next_dict_tsr_completion(int compl_type, char_u *dict, int dict_
     ins_compl_dictionaries(dict != NULL ? dict
                            : (compl_type == CTRL_X_THESAURUS
                               ? (*curbuf->b_p_tsr == NUL ? p_tsr : (char_u *)curbuf->b_p_tsr)
-                              : (*curbuf->b_p_dict == NUL ? p_dict : (char_u *)curbuf->b_p_dict)),
+                              : (*curbuf->b_p_dict ==
+                                 NUL ? (char_u *)p_dict : (char_u *)curbuf->b_p_dict)),
                            (char_u *)compl_pattern,
                            dict != NULL ? dict_f : 0,
                            compl_type == CTRL_X_THESAURUS);
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 6fc70dec2d..efa1f8e350 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1733,7 +1733,7 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
         if (i == 1) {
           char buf[100];
 
-          p_shm_save = xstrdup((char *)p_shm);
+          p_shm_save = xstrdup(p_shm);
           snprintf(buf, sizeof(buf), "F%s", p_shm);
           set_option_value_give_err("shm", 0L, buf, 0);
         }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index f7f1de13c4..ef44d71165 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -2322,7 +2322,7 @@ void langmap_set(void)
   ga_clear(&langmap_mapga);                 // clear the previous map first
   langmap_init();                           // back to one-to-one map
 
-  for (p = p_langmap; p[0] != NUL;) {
+  for (p = (char_u *)p_langmap; p[0] != NUL;) {
     for (p2 = p; p2[0] != NUL && p2[0] != ',' && p2[0] != ';';
          MB_PTR_ADV(p2)) {
       if (p2[0] == '\\' && p2[1] != NUL) {
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index ad8718742f..9213457608 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1936,7 +1936,7 @@ void utf_find_illegal(void)
     // 'encoding' is "utf-8" but we are editing a 8-bit encoded file,
     // possibly a utf-8 file with illegal bytes.  Setup for conversion
     // from utf-8 to 'fileencoding'.
-    convert_setup(&vimconv, p_enc, (char_u *)curbuf->b_p_fenc);
+    convert_setup(&vimconv, (char_u *)p_enc, (char_u *)curbuf->b_p_fenc);
   }
 
   curwin->w_cursor.coladd = 0;
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 014d9a1d18..2913d0d271 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -399,7 +399,7 @@ void ml_setname(buf_T *buf)
   }
 
   // Try all directories in the 'directory' option.
-  dirp = (char *)p_dir;
+  dirp = p_dir;
   bool found_existing_dir = false;
   for (;;) {
     if (*dirp == NUL) {             // tried all directories, fail
@@ -490,7 +490,7 @@ void ml_open_file(buf_T *buf)
   }
 
   // Try all directories in 'directory' option.
-  dirp = (char *)p_dir;
+  dirp = p_dir;
   bool found_existing_dir = false;
   for (;;) {
     if (*dirp == NUL) {
@@ -1294,7 +1294,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
   // Do the loop for every directory in 'directory'.
   // First allocate some memory to put the directory name in.
   dir_name = xmalloc(STRLEN(p_dir) + 1);
-  dirp = (char *)p_dir;
+  dirp = p_dir;
   while (*dirp) {
     // Isolate a directory name from *dirp and put it in dir_name (we know
     // it is large enough, so use 31000 for length).
@@ -3494,7 +3494,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
         // give the ATTENTION message when there is an old swap file
         // for the current file, and the buffer was not recovered.
         if (differ == false && !(curbuf->b_flags & BF_RECOVERED)
-            && vim_strchr((char *)p_shm, SHM_ATTENTION) == NULL) {
+            && vim_strchr(p_shm, SHM_ATTENTION) == NULL) {
           int choice = 0;
 
           process_still_running = false;
diff --git a/src/nvim/message.c b/src/nvim/message.c
index aa5e556180..40de8a2bc6 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -640,8 +640,8 @@ void msg_source(int attr)
 ///            If "emsg_skip" is set: never do error messages.
 int emsg_not_now(void)
 {
-  if ((emsg_off > 0 && vim_strchr((char *)p_debug, 'm') == NULL
-       && vim_strchr((char *)p_debug, 't') == NULL)
+  if ((emsg_off > 0 && vim_strchr(p_debug, 'm') == NULL
+       && vim_strchr(p_debug, 't') == NULL)
       || emsg_skip > 0) {
     return true;
   }
@@ -665,7 +665,7 @@ static bool emsg_multiline(const char *s, bool multiline)
   bool severe = emsg_severe;
   emsg_severe = false;
 
-  if (!emsg_off || vim_strchr((char *)p_debug, 't') != NULL) {
+  if (!emsg_off || vim_strchr(p_debug, 't') != NULL) {
     // Cause a throw of an error exception if appropriate.  Don't display
     // the error message in this case.  (If no matching catch clause will
     // be found, the message will be displayed later on.)  "ignore" is set
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 743297eb9d..93ee49b0a4 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2653,11 +2653,11 @@ void clear_showcmd(void)
     lines = bot - top + 1;
 
     if (VIsual_mode == Ctrl_V) {
-      char_u *const saved_sbr = p_sbr;
+      char *const saved_sbr = p_sbr;
       char *const saved_w_sbr = curwin->w_p_sbr;
 
       // Make 'sbr' empty for a moment to get the correct size.
-      p_sbr = (char_u *)empty_option;
+      p_sbr = empty_option;
       curwin->w_p_sbr = empty_option;
       getvcols(curwin, &curwin->w_cursor, &VIsual, &leftcol, &rightcol);
       p_sbr = saved_sbr;
@@ -4567,9 +4567,9 @@ static void nv_right(cmdarg_T *cap)
       //    <Space> wraps to next line if 'whichwrap' has 's'.
       //        'l' wraps to next line if 'whichwrap' has 'l'.
       // CURS_RIGHT wraps to next line if 'whichwrap' has '>'.
-      if (((cap->cmdchar == ' ' && vim_strchr((char *)p_ww, 's') != NULL)
-           || (cap->cmdchar == 'l' && vim_strchr((char *)p_ww, 'l') != NULL)
-           || (cap->cmdchar == K_RIGHT && vim_strchr((char *)p_ww, '>') != NULL))
+      if (((cap->cmdchar == ' ' && vim_strchr(p_ww, 's') != NULL)
+           || (cap->cmdchar == 'l' && vim_strchr(p_ww, 'l') != NULL)
+           || (cap->cmdchar == K_RIGHT && vim_strchr(p_ww, '>') != NULL))
           && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
         // When deleting we also count the NL as a character.
         // Set cap->oap->inclusive when last char in the line is
@@ -4637,9 +4637,9 @@ static void nv_left(cmdarg_T *cap)
       //                 'h' wraps to previous line if 'whichwrap' has 'h'.
       //           CURS_LEFT wraps to previous line if 'whichwrap' has '<'.
       if ((((cap->cmdchar == K_BS || cap->cmdchar == Ctrl_H)
-            && vim_strchr((char *)p_ww, 'b') != NULL)
-           || (cap->cmdchar == 'h' && vim_strchr((char *)p_ww, 'h') != NULL)
-           || (cap->cmdchar == K_LEFT && vim_strchr((char *)p_ww, '<') != NULL))
+            && vim_strchr(p_ww, 'b') != NULL)
+           || (cap->cmdchar == 'h' && vim_strchr(p_ww, 'h') != NULL)
+           || (cap->cmdchar == K_LEFT && vim_strchr(p_ww, '<') != NULL))
           && curwin->w_cursor.lnum > 1) {
         curwin->w_cursor.lnum--;
         coladvance(MAXCOL);
@@ -5553,7 +5553,7 @@ static void n_swapchar(cmdarg_T *cap)
     return;
   }
 
-  if (LINEEMPTY(curwin->w_cursor.lnum) && vim_strchr((char *)p_ww, '~') == NULL) {
+  if (LINEEMPTY(curwin->w_cursor.lnum) && vim_strchr(p_ww, '~') == NULL) {
     clearopbeep(cap->oap);
     return;
   }
@@ -5569,7 +5569,7 @@ static void n_swapchar(cmdarg_T *cap)
     did_change |= swapchar(cap->oap->op_type, &curwin->w_cursor);
     inc_cursor();
     if (gchar_cursor() == NUL) {
-      if (vim_strchr((char *)p_ww, '~') != NULL
+      if (vim_strchr(p_ww, '~') != NULL
           && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
         curwin->w_cursor.lnum++;
         curwin->w_cursor.col = 0;
@@ -5901,7 +5901,7 @@ void start_selection(void)
 void may_start_select(int c)
 {
   VIsual_select = (c == 'o' || (stuff_empty() && typebuf_typed()))
-                  && vim_strchr((char *)p_slm, c) != NULL;
+                  && vim_strchr(p_slm, c) != NULL;
 }
 
 /// Start Visual mode "c".
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 79450acbd6..0fc15b9382 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -5334,17 +5334,16 @@ void cursor_pos_info(dict_T *dict)
       }
 
       if (l_VIsual_mode == Ctrl_V) {
-        char_u *const saved_sbr = p_sbr;
+        char *const saved_sbr = p_sbr;
         char *const saved_w_sbr = curwin->w_p_sbr;
 
         // Make 'sbr' empty for a moment to get the correct size.
-        p_sbr = (char_u *)empty_option;
+        p_sbr = empty_option;
         curwin->w_p_sbr = empty_option;
         oparg.is_VIsual = true;
         oparg.motion_type = kMTBlockWise;
         oparg.op_type = OP_NOP;
-        getvcols(curwin, &min_pos, &max_pos,
-                 &oparg.start_vcol, &oparg.end_vcol);
+        getvcols(curwin, &min_pos, &max_pos, &oparg.start_vcol, &oparg.end_vcol);
         p_sbr = saved_sbr;
         curwin->w_p_sbr = saved_w_sbr;
         if (curwin->w_curswant == MAXCOL) {
@@ -5507,14 +5506,14 @@ void cursor_pos_info(dict_T *dict)
     }
     if (dict == NULL) {
       // Don't shorten this message, the user asked for it.
-      p = p_shm;
-      p_shm = (char_u *)"";
+      p = (char_u *)p_shm;
+      p_shm = "";
       if (p_ch < 1) {
         msg_start();
         msg_scroll = true;
       }
       msg((char *)IObuff);
-      p_shm = p;
+      p_shm = (char *)p;
     }
   }
 
@@ -5589,7 +5588,7 @@ static Callback opfunc_cb;
 /// @return  OK or FAIL
 int set_operatorfunc_option(void)
 {
-  return option_set_callback_func(p_opfunc, &opfunc_cb);
+  return option_set_callback_func((char_u *)p_opfunc, &opfunc_cb);
 }
 
 #if defined(EXITFREE)
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 95c3ccf71c..3a5550ffc0 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -439,7 +439,7 @@ void set_init_1(bool clean_arg)
 #ifdef HAVE_WORKING_LIBINTL
   // GNU gettext 0.10.37 supports this feature: set the codeset used for
   // translated messages independently from the current locale.
-  (void)bind_textdomain_codeset(PROJECT_NAME, (char *)p_enc);
+  (void)bind_textdomain_codeset(PROJECT_NAME, p_enc);
 #endif
 
   // Set the default for 'helplang'.
@@ -1483,7 +1483,7 @@ int do_set(char *arg, int opt_flags)
               // for ":set" on local options. Note: when setting
               // 'syntax' or 'filetype' autocommands may be
               // triggered that can cause havoc.
-              errmsg = did_set_string_option(opt_idx, (char_u **)varp, oldval,
+              errmsg = did_set_string_option(opt_idx, (char **)varp, (char *)oldval,
                                              errbuf, sizeof(errbuf),
                                              opt_flags, &value_checked);
 
@@ -1699,16 +1699,14 @@ int get_shada_parameter(int type)
 /// Return NULL if the parameter is not specified in the string.
 char_u *find_shada_parameter(int type)
 {
-  char_u *p;
-
-  for (p = p_shada; *p; p++) {
+  for (char *p = p_shada; *p; p++) {
     if (*p == type) {
-      return p + 1;
+      return (char_u *)p + 1;
     }
     if (*p == 'n') {                // 'n' is always the last one
       break;
     }
-    p = (char_u *)vim_strchr((char *)p, ',');         // skip until next ','
+    p = vim_strchr(p, ',');         // skip until next ','
     if (p == NULL) {                // hit the end without finding parameter
       break;
     }
@@ -1745,7 +1743,7 @@ static char_u *option_expand(int opt_idx, char_u *val)
    */
   expand_env_esc(val, NameBuff, MAXPATHL,
                  (char_u **)options[opt_idx].var == &p_tags, false,
-                 (char_u **)options[opt_idx].var == &p_sps ? (char_u *)"file:" :
+                 (char_u **)options[opt_idx].var == (char_u **)&p_sps ? (char_u *)"file:" :
                  NULL);
   if (STRCMP(NameBuff, val) == 0) {   // they are the same
     return NULL;
@@ -2883,7 +2881,7 @@ bool set_tty_option(const char *name, char *value)
 
 void set_tty_background(const char *value)
 {
-  if (option_was_set("bg") || strequal((char *)p_bg, value)) {
+  if (option_was_set("bg") || strequal(p_bg, value)) {
     // background is already set... ignore
     return;
   }
@@ -4449,7 +4447,7 @@ void buf_copy_options(buf_T *buf, int flags)
       if (!buf->b_p_initialized) {
         free_buf_options(buf, true);
         buf->b_p_ro = false;                    // don't copy readonly
-        buf->b_p_fenc = (char *)vim_strsave(p_fenc);
+        buf->b_p_fenc = xstrdup(p_fenc);
         switch (*p_ffs) {
         case 'm':
           buf->b_p_ff = xstrdup(FF_MAC);
@@ -4461,7 +4459,7 @@ void buf_copy_options(buf_T *buf, int flags)
           buf->b_p_ff = xstrdup(FF_UNIX);
           break;
         default:
-          buf->b_p_ff = (char *)vim_strsave(p_ff);
+          buf->b_p_ff = xstrdup(p_ff);
           break;
         }
         buf->b_p_bh = empty_option;
@@ -4512,9 +4510,9 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_csl = vim_strsave(p_csl);
       COPY_OPT_SCTX(buf, BV_CSL);
 #endif
-      buf->b_p_cfu = (char *)vim_strsave(p_cfu);
+      buf->b_p_cfu = xstrdup(p_cfu);
       COPY_OPT_SCTX(buf, BV_CFU);
-      buf->b_p_ofu = (char *)vim_strsave(p_ofu);
+      buf->b_p_ofu = xstrdup(p_ofu);
       COPY_OPT_SCTX(buf, BV_OFU);
       buf->b_p_tfu = (char *)vim_strsave(p_tfu);
       COPY_OPT_SCTX(buf, BV_TFU);
@@ -4531,7 +4529,7 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_vsts_nopaste = p_vsts_nopaste
                                 ? (char *)vim_strsave(p_vsts_nopaste)
                                 : NULL;
-      buf->b_p_com = (char *)vim_strsave(p_com);
+      buf->b_p_com = xstrdup(p_com);
       COPY_OPT_SCTX(buf, BV_COM);
       buf->b_p_cms = (char *)vim_strsave(p_cms);
       COPY_OPT_SCTX(buf, BV_CMS);
@@ -4551,18 +4549,18 @@ void buf_copy_options(buf_T *buf, int flags)
       COPY_OPT_SCTX(buf, BV_CI);
       buf->b_p_cin = p_cin;
       COPY_OPT_SCTX(buf, BV_CIN);
-      buf->b_p_cink = (char *)vim_strsave(p_cink);
+      buf->b_p_cink = xstrdup(p_cink);
       COPY_OPT_SCTX(buf, BV_CINK);
-      buf->b_p_cino = (char *)vim_strsave(p_cino);
+      buf->b_p_cino = xstrdup(p_cino);
       COPY_OPT_SCTX(buf, BV_CINO);
-      buf->b_p_cinsd = (char *)vim_strsave(p_cinsd);
+      buf->b_p_cinsd = xstrdup(p_cinsd);
       COPY_OPT_SCTX(buf, BV_CINSD);
 
       // Don't copy 'filetype', it must be detected
       buf->b_p_ft = empty_option;
       buf->b_p_pi = p_pi;
       COPY_OPT_SCTX(buf, BV_PI);
-      buf->b_p_cinw = (char *)vim_strsave(p_cinw);
+      buf->b_p_cinw = xstrdup(p_cinw);
       COPY_OPT_SCTX(buf, BV_CINW);
       buf->b_p_lisp = p_lisp;
       COPY_OPT_SCTX(buf, BV_LISP);
@@ -4587,7 +4585,7 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_fp = empty_option;
       buf->b_p_fex = (char *)vim_strsave(p_fex);
       COPY_OPT_SCTX(buf, BV_FEX);
-      buf->b_p_sua = (char *)vim_strsave(p_sua);
+      buf->b_p_sua = xstrdup(p_sua);
       COPY_OPT_SCTX(buf, BV_SUA);
       buf->b_p_keymap = (char *)vim_strsave(p_keymap);
       COPY_OPT_SCTX(buf, BV_KMAP);
@@ -4642,7 +4640,7 @@ void buf_copy_options(buf_T *buf, int flags)
           buf->b_p_vts_array = NULL;
         }
       } else {
-        buf->b_p_isk = (char *)vim_strsave(p_isk);
+        buf->b_p_isk = xstrdup(p_isk);
         COPY_OPT_SCTX(buf, BV_ISK);
         did_isk = true;
         buf->b_p_ts = p_ts;
@@ -5052,8 +5050,8 @@ static int wc_use_keyname(char_u *varp, long *wcp)
 bool shortmess(int x)
 {
   return (p_shm != NULL
-          && (vim_strchr((char *)p_shm, x) != NULL
-              || (vim_strchr((char *)p_shm, 'a') != NULL
+          && (vim_strchr(p_shm, x) != NULL
+              || (vim_strchr(p_shm, 'a') != NULL
                   && vim_strchr((char *)SHM_ALL_ABBREVIATIONS, x) != NULL)));
 }
 
@@ -5354,7 +5352,7 @@ bool can_bs(int what)
   case '0':
     return false;
   }
-  return vim_strchr((char *)p_bs, what) != NULL;
+  return vim_strchr(p_bs, what) != NULL;
 }
 
 /// Get the local or global value of 'backupcopy'.
@@ -5379,7 +5377,7 @@ char_u *get_showbreak_value(win_T *const win)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if (win->w_p_sbr == NULL || *win->w_p_sbr == NUL) {
-    return p_sbr;
+    return (char_u *)p_sbr;
   }
   if (STRCMP(win->w_p_sbr, "NONE") == 0) {
     return (char_u *)empty_option;
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index f9848cb792..59b8485272 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -384,7 +384,7 @@ enum {
  */
 
 EXTERN long p_aleph;            // 'aleph'
-EXTERN char_u *p_ambw;          ///< 'ambiwidth'
+EXTERN char *p_ambw;            ///< 'ambiwidth'
 EXTERN int p_acd;               ///< 'autochdir'
 EXTERN int p_ai;                ///< 'autoindent'
 EXTERN int p_bin;               ///< 'binary'
@@ -392,29 +392,29 @@ EXTERN int p_bomb;              ///< 'bomb'
 EXTERN int p_bl;                ///< 'buflisted'
 EXTERN int p_cin;               ///< 'cindent'
 EXTERN long p_channel;          ///< 'channel'
-EXTERN char_u *p_cink;          ///< 'cinkeys'
-EXTERN char_u *p_cinsd;         ///< 'cinscopedecls'
-EXTERN char_u *p_cinw;          ///< 'cinwords'
-EXTERN char_u *p_cfu;           ///< 'completefunc'
-EXTERN char_u *p_ofu;           ///< 'omnifunc'
-EXTERN char_u *p_tsrfu;         ///< 'thesaurusfunc'
+EXTERN char *p_cink;            ///< 'cinkeys'
+EXTERN char *p_cinsd;           ///< 'cinscopedecls'
+EXTERN char *p_cinw;            ///< 'cinwords'
+EXTERN char *p_cfu;             ///< 'completefunc'
+EXTERN char *p_ofu;             ///< 'omnifunc'
+EXTERN char *p_tsrfu;           ///< 'thesaurusfunc'
 EXTERN int p_ci;                ///< 'copyindent'
 EXTERN int p_ar;                // 'autoread'
 EXTERN int p_aw;                // 'autowrite'
 EXTERN int p_awa;               // 'autowriteall'
-EXTERN char_u *p_bs;          // 'backspace'
-EXTERN char_u *p_bg;          // 'background'
+EXTERN char *p_bs;              // 'backspace'
+EXTERN char *p_bg;              // 'background'
 EXTERN int p_bk;                // 'backup'
-EXTERN char_u *p_bkc;         // 'backupcopy'
+EXTERN char *p_bkc;             // 'backupcopy'
 EXTERN unsigned int bkc_flags;  ///< flags from 'backupcopy'
 #define BKC_YES                0x001
 #define BKC_AUTO               0x002
 #define BKC_NO                 0x004
 #define BKC_BREAKSYMLINK       0x008
 #define BKC_BREAKHARDLINK      0x010
-EXTERN char_u *p_bdir;            // 'backupdir'
-EXTERN char_u *p_bex;             // 'backupext'
-EXTERN char_u *p_bo;              // 'belloff'
+EXTERN char *p_bdir;              // 'backupdir'
+EXTERN char *p_bex;               // 'backupext'
+EXTERN char *p_bo;                // 'belloff'
 EXTERN char breakat_flags[256];   // which characters are in 'breakat'
 EXTERN unsigned bo_flags;
 
@@ -443,16 +443,16 @@ EXTERN char_u *p_bsk;         // 'backupskip'
 EXTERN char_u *p_breakat;     // 'breakat'
 EXTERN char_u *p_bh;          ///< 'bufhidden'
 EXTERN char_u *p_bt;          ///< 'buftype'
-EXTERN char_u *p_cmp;         // 'casemap'
+EXTERN char *p_cmp;           // 'casemap'
 EXTERN unsigned cmp_flags;
 #define CMP_INTERNAL           0x001
 #define CMP_KEEPASCII          0x002
-EXTERN char_u *p_enc;         // 'encoding'
-EXTERN int p_deco;              // 'delcombine'
-EXTERN char_u *p_ccv;         // 'charconvert'
-EXTERN char_u *p_cino;        ///< 'cinoptions'
-EXTERN char_u *p_cedit;       // 'cedit'
-EXTERN char_u *p_cb;          // 'clipboard'
+EXTERN char *p_enc;           // 'encoding'
+EXTERN int p_deco;            // 'delcombine'
+EXTERN char *p_ccv;           // 'charconvert'
+EXTERN char *p_cino;          ///< 'cinoptions'
+EXTERN char *p_cedit;         // 'cedit'
+EXTERN char *p_cb;            // 'clipboard'
 EXTERN unsigned cb_flags;
 #define CB_UNNAMED             0x001
 #define CB_UNNAMEDPLUS         0x002
@@ -463,33 +463,33 @@ EXTERN char_u *p_cms;           ///< 'commentstring'
 EXTERN char_u *p_cpt;           ///< 'complete'
 EXTERN long p_columns;          // 'columns'
 EXTERN int p_confirm;           // 'confirm'
-EXTERN char_u *p_cot;         // 'completeopt'
+EXTERN char *p_cot;             // 'completeopt'
 #ifdef BACKSLASH_IN_FILENAME
 EXTERN char_u *p_csl;         // 'completeslash'
 #endif
 EXTERN long p_pb;               // 'pumblend'
 EXTERN long p_ph;               // 'pumheight'
 EXTERN long p_pw;               // 'pumwidth'
-EXTERN char_u *p_com;           ///< 'comments'
+EXTERN char *p_com;             ///< 'comments'
 EXTERN char *p_cpo;             // 'cpoptions'
-EXTERN char_u *p_csprg;       // 'cscopeprg'
+EXTERN char *p_csprg;           // 'cscopeprg'
 EXTERN int p_csre;              // 'cscoperelative'
-EXTERN char_u *p_csqf;        // 'cscopequickfix'
+EXTERN char *p_csqf;            // 'cscopequickfix'
 #define       CSQF_CMDS   "sgdctefia"
 #define       CSQF_FLAGS  "+-0"
 EXTERN int p_cst;               // 'cscopetag'
 EXTERN long p_csto;             // 'cscopetagorder'
 EXTERN long p_cspc;             // 'cscopepathcomp'
 EXTERN int p_csverbose;         // 'cscopeverbose'
-EXTERN char_u *p_debug;       // 'debug'
-EXTERN char_u *p_def;         // 'define'
-EXTERN char_u *p_inc;
-EXTERN char_u *p_dip;         // 'diffopt'
-EXTERN char_u *p_dex;         // 'diffexpr'
-EXTERN char_u *p_dict;        // 'dictionary'
+EXTERN char *p_debug;           // 'debug'
+EXTERN char *p_def;             // 'define'
+EXTERN char *p_inc;
+EXTERN char *p_dip;             // 'diffopt'
+EXTERN char *p_dex;             // 'diffexpr'
+EXTERN char *p_dict;            // 'dictionary'
 EXTERN int p_dg;                // 'digraph'
-EXTERN char_u *p_dir;         // 'directory'
-EXTERN char_u *p_dy;          // 'display'
+EXTERN char *p_dir;             // 'directory'
+EXTERN char *p_dy;              // 'display'
 EXTERN unsigned dy_flags;
 #define DY_LASTLINE             0x001
 #define DY_TRUNCATE             0x002
@@ -497,30 +497,30 @@ EXTERN unsigned dy_flags;
 // code should use msg_use_msgsep() to check if msgsep is active
 #define DY_MSGSEP               0x008
 EXTERN int p_ed;                // 'edcompatible'
-EXTERN char_u *p_ead;         // 'eadirection'
+EXTERN char *p_ead;             // 'eadirection'
 EXTERN int p_emoji;             // 'emoji'
 EXTERN int p_ea;                // 'equalalways'
-EXTERN char_u *p_ep;          // 'equalprg'
+EXTERN char_u *p_ep;            // 'equalprg'
 EXTERN int p_eb;                // 'errorbells'
-EXTERN char_u *p_ef;          // 'errorfile'
-EXTERN char *p_efm;         // 'errorformat'
-EXTERN char *p_gefm;        // 'grepformat'
-EXTERN char_u *p_gp;          // 'grepprg'
+EXTERN char_u *p_ef;            // 'errorfile'
+EXTERN char *p_efm;             // 'errorformat'
+EXTERN char *p_gefm;            // 'grepformat'
+EXTERN char_u *p_gp;            // 'grepprg'
 EXTERN int p_eol;               ///< 'endofline'
-EXTERN char_u *p_ei;          // 'eventignore'
+EXTERN char *p_ei;              // 'eventignore'
 EXTERN int p_et;                ///< 'expandtab'
 EXTERN int p_exrc;              // 'exrc'
-EXTERN char_u *p_fenc;          ///< 'fileencoding'
-EXTERN char_u *p_fencs;       // 'fileencodings'
-EXTERN char_u *p_ff;            ///< 'fileformat'
-EXTERN char *p_ffs;           // 'fileformats'
+EXTERN char *p_fenc;            ///< 'fileencoding'
+EXTERN char *p_fencs;           // 'fileencodings'
+EXTERN char *p_ff;              ///< 'fileformat'
+EXTERN char *p_ffs;             // 'fileformats'
 EXTERN int p_fic;               // 'fileignorecase'
-EXTERN char_u *p_ft;            ///< 'filetype'
-EXTERN char_u *p_fcs;           ///< 'fillchar'
+EXTERN char *p_ft;              ///< 'filetype'
+EXTERN char *p_fcs;             ///< 'fillchar'
 EXTERN int p_fixeol;            ///< 'fixendofline'
-EXTERN char_u *p_fcl;         // 'foldclose'
+EXTERN char *p_fcl;             // 'foldclose'
 EXTERN long p_fdls;             // 'foldlevelstart'
-EXTERN char_u *p_fdo;         // 'foldopen'
+EXTERN char *p_fdo;             // 'foldopen'
 EXTERN unsigned fdo_flags;
 #define FDO_ALL                0x001
 #define FDO_BLOCK              0x002
@@ -536,32 +536,32 @@ EXTERN unsigned fdo_flags;
 EXTERN char_u *p_fex;           ///< 'formatexpr'
 EXTERN char_u *p_flp;           ///< 'formatlistpat'
 EXTERN char_u *p_fo;            ///< 'formatoptions'
-EXTERN char_u *p_fp;          // 'formatprg'
+EXTERN char_u *p_fp;            // 'formatprg'
 EXTERN int p_fs;                // 'fsync'
 EXTERN int p_gd;                // 'gdefault'
-EXTERN char_u *p_pdev;        // 'printdevice'
-EXTERN char_u *p_penc;        // 'printencoding'
-EXTERN char_u *p_pexpr;       // 'printexpr'
-EXTERN char_u *p_pmfn;        // 'printmbfont'
-EXTERN char_u *p_pmcs;        // 'printmbcharset'
-EXTERN char_u *p_pfn;         // 'printfont'
-EXTERN char_u *p_popt;        // 'printoptions'
-EXTERN char_u *p_header;      // 'printheader'
-EXTERN char_u *p_guicursor;   // 'guicursor'
-EXTERN char_u *p_guifont;     // 'guifont'
-EXTERN char_u *p_guifontwide;  // 'guifontwide'
-EXTERN char_u *p_hf;          // 'helpfile'
+EXTERN char_u *p_pdev;          // 'printdevice'
+EXTERN char *p_penc;            // 'printencoding'
+EXTERN char *p_pexpr;           // 'printexpr'
+EXTERN char *p_pmfn;            // 'printmbfont'
+EXTERN char *p_pmcs;            // 'printmbcharset'
+EXTERN char *p_pfn;             // 'printfont'
+EXTERN char *p_popt;            // 'printoptions'
+EXTERN char_u *p_header;        // 'printheader'
+EXTERN char *p_guicursor;       // 'guicursor'
+EXTERN char_u *p_guifont;       // 'guifont'
+EXTERN char_u *p_guifontwide;   // 'guifontwide'
+EXTERN char *p_hf;              // 'helpfile'
 EXTERN long p_hh;               // 'helpheight'
-EXTERN char_u *p_hlg;         // 'helplang'
+EXTERN char_u *p_hlg;           // 'helplang'
 EXTERN int p_hid;               // 'hidden'
-EXTERN char_u *p_hl;          // 'highlight'
+EXTERN char *p_hl;              // 'highlight'
 EXTERN int p_hls;               // 'hlsearch'
 EXTERN long p_hi;               // 'history'
 EXTERN int p_hkmap;             // 'hkmap'
 EXTERN int p_hkmapp;            // 'hkmapp'
 EXTERN int p_arshape;           // 'arabicshape'
 EXTERN int p_icon;              // 'icon'
-EXTERN char_u *p_iconstring;  // 'iconstring'
+EXTERN char *p_iconstring;      // 'iconstring'
 EXTERN int p_ic;                // 'ignorecase'
 EXTERN long p_iminsert;         ///< 'iminsert'
 EXTERN long p_imsearch;         ///< 'imsearch'
@@ -570,30 +570,30 @@ EXTERN char_u *p_inex;          ///< 'includeexpr'
 EXTERN int p_is;                // 'incsearch'
 EXTERN char_u *p_inde;          ///< 'indentexpr'
 EXTERN char_u *p_indk;          ///< 'indentkeys'
-EXTERN char_u *p_icm;         // 'inccommand'
-EXTERN char_u *p_isf;         // 'isfname'
-EXTERN char_u *p_isi;         // 'isident'
-EXTERN char_u *p_isk;           ///< 'iskeyword'
-EXTERN char_u *p_isp;         // 'isprint'
+EXTERN char *p_icm;             // 'inccommand'
+EXTERN char *p_isf;             // 'isfname'
+EXTERN char *p_isi;             // 'isident'
+EXTERN char *p_isk;             ///< 'iskeyword'
+EXTERN char *p_isp;             // 'isprint'
 EXTERN int p_js;                // 'joinspaces'
-EXTERN char_u *p_jop;           // 'jumpooptions'
+EXTERN char *p_jop;             // 'jumpooptions'
 EXTERN unsigned jop_flags;
 #define JOP_STACK               0x01
 #define JOP_VIEW                0x02
 EXTERN char_u *p_keymap;        ///< 'keymap'
-EXTERN char_u *p_kp;          // 'keywordprg'
-EXTERN char_u *p_km;          // 'keymodel'
-EXTERN char_u *p_langmap;     // 'langmap'
+EXTERN char_u *p_kp;            // 'keywordprg'
+EXTERN char *p_km;              // 'keymodel'
+EXTERN char *p_langmap;         // 'langmap'
 EXTERN int p_lnr;               // 'langnoremap'
 EXTERN int p_lrm;               // 'langremap'
-EXTERN char_u *p_lm;          // 'langmenu'
-EXTERN long p_lines;        // 'lines'
-EXTERN long p_linespace;    // 'linespace'
+EXTERN char_u *p_lm;            // 'langmenu'
+EXTERN long p_lines;            // 'lines'
+EXTERN long p_linespace;        // 'linespace'
 EXTERN int p_lisp;              ///< 'lisp'
-EXTERN char_u *p_lispwords;   // 'lispwords'
+EXTERN char_u *p_lispwords;     // 'lispwords'
 EXTERN long p_ls;               // 'laststatus'
 EXTERN long p_stal;             // 'showtabline'
-EXTERN char_u *p_lcs;         // 'listchars'
+EXTERN char *p_lcs;             // 'listchars'
 
 EXTERN int p_lz;                // 'lazyredraw'
 EXTERN int p_lpl;               // 'loadplugins'
@@ -610,60 +610,60 @@ EXTERN long p_mfd;              // 'maxfuncdepth'
 EXTERN long p_mmd;              // 'maxmapdepth'
 EXTERN long p_mmp;              // 'maxmempattern'
 EXTERN long p_mis;              // 'menuitems'
-EXTERN char_u *p_msm;         // 'mkspellmem'
+EXTERN char *p_msm;             // 'mkspellmem'
 EXTERN int p_ml;                ///< 'modeline'
-EXTERN int p_mle;              // 'modelineexpr'
+EXTERN int p_mle;               // 'modelineexpr'
 EXTERN long p_mls;              // 'modelines'
 EXTERN int p_ma;                ///< 'modifiable'
 EXTERN int p_mod;               ///< 'modified'
-EXTERN char_u *p_mouse;       // 'mouse'
-EXTERN char_u *p_mousem;      // 'mousemodel'
-EXTERN int p_mousef;           // 'mousefocus'
-EXTERN char_u *p_mousescroll;  // 'mousescroll'
+EXTERN char *p_mouse;           // 'mouse'
+EXTERN char *p_mousem;          // 'mousemodel'
+EXTERN int p_mousef;            // 'mousefocus'
+EXTERN char *p_mousescroll;     // 'mousescroll'
 EXTERN long p_mousescroll_vert INIT(= MOUSESCROLL_VERT_DFLT);
 EXTERN long p_mousescroll_hor INIT(= MOUSESCROLL_HOR_DFLT);
 EXTERN long p_mouset;           // 'mousetime'
 EXTERN int p_more;              // 'more'
 EXTERN char_u *p_nf;            ///< 'nrformats'
-EXTERN char_u *p_opfunc;      // 'operatorfunc'
+EXTERN char *p_opfunc;          // 'operatorfunc'
 EXTERN char_u *p_para;        // 'paragraphs'
 EXTERN int p_paste;             // 'paste'
 EXTERN char_u *p_pt;          // 'pastetoggle'
 EXTERN char_u *p_pex;         // 'patchexpr'
-EXTERN char_u *p_pm;          // 'patchmode'
+EXTERN char *p_pm;            // 'patchmode'
 EXTERN char_u *p_path;        // 'path'
 EXTERN char_u *p_cdpath;      // 'cdpath'
 EXTERN int p_pi;                ///< 'preserveindent'
 EXTERN long p_pyx;              // 'pyxversion'
 EXTERN char_u *p_qe;            ///< 'quoteescape'
 EXTERN int p_ro;                ///< 'readonly'
-EXTERN char_u *p_rdb;           // 'redrawdebug'
+EXTERN char *p_rdb;             // 'redrawdebug'
 EXTERN unsigned rdb_flags;
 #define RDB_COMPOSITOR         0x001
 #define RDB_NOTHROTTLE         0x002
 #define RDB_INVALID            0x004
 #define RDB_NODELTA            0x008
 
-EXTERN long p_rdt;              // 'redrawtime'
-EXTERN long p_re;               // 'regexpengine'
-EXTERN long p_report;           // 'report'
-EXTERN long p_pvh;              // 'previewheight'
-EXTERN int p_ari;               // 'allowrevins'
-EXTERN int p_ri;                // 'revins'
-EXTERN int p_ru;                // 'ruler'
-EXTERN char_u *p_ruf;         // 'rulerformat'
-EXTERN char_u *p_pp;          // 'packpath'
-EXTERN char_u *p_qftf;        // 'quickfixtextfunc'
-EXTERN char_u *p_rtp;         // 'runtimepath'
-EXTERN long p_scbk;             // 'scrollback'
-EXTERN long p_sj;               // 'scrolljump'
-EXTERN long p_so;               // 'scrolloff'
-EXTERN char *p_sbo;             // 'scrollopt'
-EXTERN char_u *p_sections;    // 'sections'
-EXTERN int p_secure;            // 'secure'
-EXTERN char_u *p_sel;         // 'selection'
-EXTERN char_u *p_slm;         // 'selectmode'
-EXTERN char_u *p_ssop;        // 'sessionoptions'
+EXTERN long p_rdt;            // 'redrawtime'
+EXTERN long p_re;             // 'regexpengine'
+EXTERN long p_report;         // 'report'
+EXTERN long p_pvh;            // 'previewheight'
+EXTERN int p_ari;             // 'allowrevins'
+EXTERN int p_ri;              // 'revins'
+EXTERN int p_ru;              // 'ruler'
+EXTERN char *p_ruf;           // 'rulerformat'
+EXTERN char *p_pp;            // 'packpath'
+EXTERN char *p_qftf;          // 'quickfixtextfunc'
+EXTERN char *p_rtp;           // 'runtimepath'
+EXTERN long p_scbk;           // 'scrollback'
+EXTERN long p_sj;             // 'scrolljump'
+EXTERN long p_so;             // 'scrolloff'
+EXTERN char *p_sbo;           // 'scrollopt'
+EXTERN char *p_sections;      // 'sections'
+EXTERN int p_secure;          // 'secure'
+EXTERN char *p_sel;           // 'selection'
+EXTERN char *p_slm;           // 'selectmode'
+EXTERN char *p_ssop;          // 'sessionoptions'
 EXTERN unsigned ssop_flags;
 
 #define SSOP_BUFFERS           0x001
@@ -696,12 +696,12 @@ EXTERN int p_stmp;              // 'shelltemp'
 #ifdef BACKSLASH_IN_FILENAME
 EXTERN int p_ssl;               // 'shellslash'
 #endif
-EXTERN char_u *p_stl;         // 'statusline'
-EXTERN char *p_wbr;         // 'winbar'
+EXTERN char *p_stl;             // 'statusline'
+EXTERN char *p_wbr;             // 'winbar'
 EXTERN int p_sr;                // 'shiftround'
 EXTERN long p_sw;               ///< 'shiftwidth'
-EXTERN char_u *p_shm;         // 'shortmess'
-EXTERN char_u *p_sbr;         // 'showbreak'
+EXTERN char *p_shm;             // 'shortmess'
+EXTERN char *p_sbr;             // 'showbreak'
 EXTERN int p_sc;                // 'showcmd'
 EXTERN int p_sft;               // 'showfulltag'
 EXTERN int p_sm;                // 'showmatch'
@@ -713,12 +713,12 @@ EXTERN int p_si;                ///< 'smartindent'
 EXTERN int p_sta;               // 'smarttab'
 EXTERN long p_sts;              ///< 'softtabstop'
 EXTERN int p_sb;                // 'splitbelow'
-EXTERN char_u *p_sua;           ///< 'suffixesadd'
+EXTERN char *p_sua;             ///< 'suffixesadd'
 EXTERN int p_swf;               ///< 'swapfile'
 EXTERN long p_smc;              ///< 'synmaxcol'
 EXTERN long p_tpm;              // 'tabpagemax'
-EXTERN char_u *p_tal;         // 'tabline'
-EXTERN char_u *p_tpf;         // 'termpastefilter'
+EXTERN char *p_tal;             // 'tabline'
+EXTERN char *p_tpf;             // 'termpastefilter'
 EXTERN unsigned int tpf_flags;  ///< flags from 'termpastefilter'
 #define TPF_BS                 0x001
 #define TPF_HT                 0x002
@@ -731,12 +731,12 @@ EXTERN char_u *p_tfu;           ///< 'tagfunc'
 EXTERN char_u *p_spc;           ///< 'spellcapcheck'
 EXTERN char_u *p_spf;           ///< 'spellfile'
 EXTERN char_u *p_spl;           ///< 'spelllang'
-EXTERN char_u *p_spo;         // 'spelloptions'
-EXTERN char_u *p_sps;         // 'spellsuggest'
+EXTERN char_u *p_spo;           // 'spelloptions'
+EXTERN char *p_sps;             // 'spellsuggest'
 EXTERN int p_spr;               // 'splitright'
 EXTERN int p_sol;               // 'startofline'
-EXTERN char_u *p_su;          // 'suffixes'
-EXTERN char_u *p_swb;         // 'switchbuf'
+EXTERN char_u *p_su;            // 'suffixes'
+EXTERN char *p_swb;             // 'switchbuf'
 EXTERN unsigned swb_flags;
 // Keep in sync with p_swb_values in optionstr.c
 #define SWB_USEOPEN             0x001
@@ -748,7 +748,7 @@ EXTERN unsigned swb_flags;
 EXTERN char_u *p_syn;           ///< 'syntax'
 EXTERN long p_ts;               ///< 'tabstop'
 EXTERN int p_tbs;               ///< 'tagbsearch'
-EXTERN char_u *p_tc;            ///< 'tagcase'
+EXTERN char *p_tc;              ///< 'tagcase'
 EXTERN unsigned tc_flags;       ///< flags from 'tagcase'
 #define TC_FOLLOWIC             0x01
 #define TC_IGNORE               0x02
@@ -767,7 +767,7 @@ EXTERN long p_tm;               ///< 'timeoutlen'
 EXTERN int p_title;             ///< 'title'
 EXTERN long p_titlelen;         ///< 'titlelen'
 EXTERN char_u *p_titleold;      ///< 'titleold'
-EXTERN char_u *p_titlestring;   ///< 'titlestring'
+EXTERN char *p_titlestring;     ///< 'titlestring'
 EXTERN char_u *p_tsr;           ///< 'thesaurus'
 EXTERN int p_tgc;               ///< 'termguicolors'
 EXTERN int p_ttimeout;          ///< 'ttimeout'
@@ -778,12 +778,12 @@ EXTERN long p_ul;               ///< 'undolevels'
 EXTERN long p_ur;               ///< 'undoreload'
 EXTERN long p_uc;               ///< 'updatecount'
 EXTERN long p_ut;               ///< 'updatetime'
-EXTERN char_u *p_shada;         ///< 'shada'
+EXTERN char *p_shada;           ///< 'shada'
 EXTERN char *p_shadafile;       ///< 'shadafile'
 EXTERN char_u *p_vsts;          ///< 'varsofttabstop'
 EXTERN char_u *p_vts;           ///< 'vartabstop'
 EXTERN char_u *p_vdir;          ///< 'viewdir'
-EXTERN char_u *p_vop;           ///< 'viewoptions'
+EXTERN char *p_vop;             ///< 'viewoptions'
 EXTERN unsigned vop_flags;      ///< uses SSOP_ flags
 EXTERN int p_vb;                ///< 'visualbell'
 EXTERN char_u *p_ve;            ///< 'virtualedit'
@@ -801,18 +801,18 @@ char_u *p_vfile = (char_u *)"";   // used before options are initialized
 extern char_u *p_vfile;       // 'verbosefile'
 #endif
 EXTERN int p_warn;              // 'warn'
-EXTERN char_u *p_wop;         // 'wildoptions'
+EXTERN char *p_wop;             // 'wildoptions'
 EXTERN unsigned wop_flags;
 #define WOP_TAGFILE             0x01
 #define WOP_PUM                 0x02
 EXTERN long p_window;           // 'window'
-EXTERN char_u *p_wak;         // 'winaltkeys'
-EXTERN char_u *p_wig;         // 'wildignore'
-EXTERN char_u *p_ww;          // 'whichwrap'
+EXTERN char *p_wak;             // 'winaltkeys'
+EXTERN char *p_wig;             // 'wildignore'
+EXTERN char *p_ww;              // 'whichwrap'
 EXTERN long p_wc;               // 'wildchar'
 EXTERN long p_wcm;              // 'wildcharm'
 EXTERN int p_wic;               // 'wildignorecase'
-EXTERN char_u *p_wim;         // 'wildmode'
+EXTERN char *p_wim;             // 'wildmode'
 EXTERN int p_wmnu;              // 'wildmenu'
 EXTERN long p_wh;               // 'winheight'
 EXTERN long p_wmh;              // 'winminheight'
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index e4cdf883fe..808a70c8cb 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -122,21 +122,21 @@ static char_u SHM_ALL[] = { SHM_RO, SHM_MOD, SHM_FILE, SHM_LAST, SHM_TEXT, SHM_L
 /// option values.
 void didset_string_options(void)
 {
-  (void)opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true);
-  (void)opt_strings_flags(p_bkc, p_bkc_values, &bkc_flags, true);
-  (void)opt_strings_flags(p_bo, p_bo_values, &bo_flags, true);
-  (void)opt_strings_flags(p_ssop, p_ssop_values, &ssop_flags, true);
-  (void)opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true);
-  (void)opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true);
-  (void)opt_strings_flags(p_dy, p_dy_values, &dy_flags, true);
-  (void)opt_strings_flags(p_rdb, p_rdb_values, &rdb_flags, true);
-  (void)opt_strings_flags(p_tc, p_tc_values, &tc_flags, false);
-  (void)opt_strings_flags(p_tpf, p_tpf_values, &tpf_flags, true);
+  (void)opt_strings_flags((char_u *)p_cmp, p_cmp_values, &cmp_flags, true);
+  (void)opt_strings_flags((char_u *)p_bkc, p_bkc_values, &bkc_flags, true);
+  (void)opt_strings_flags((char_u *)p_bo, p_bo_values, &bo_flags, true);
+  (void)opt_strings_flags((char_u *)p_ssop, p_ssop_values, &ssop_flags, true);
+  (void)opt_strings_flags((char_u *)p_vop, p_ssop_values, &vop_flags, true);
+  (void)opt_strings_flags((char_u *)p_fdo, p_fdo_values, &fdo_flags, true);
+  (void)opt_strings_flags((char_u *)p_dy, p_dy_values, &dy_flags, true);
+  (void)opt_strings_flags((char_u *)p_rdb, p_rdb_values, &rdb_flags, true);
+  (void)opt_strings_flags((char_u *)p_tc, p_tc_values, &tc_flags, false);
+  (void)opt_strings_flags((char_u *)p_tpf, p_tpf_values, &tpf_flags, true);
   (void)opt_strings_flags(p_ve, p_ve_values, &ve_flags, true);
-  (void)opt_strings_flags(p_swb, p_swb_values, &swb_flags, true);
-  (void)opt_strings_flags(p_wop, p_wop_values, &wop_flags, true);
-  (void)opt_strings_flags(p_jop, p_jop_values, &jop_flags, true);
-  (void)opt_strings_flags(p_cb, p_cb_values, &cb_flags, true);
+  (void)opt_strings_flags((char_u *)p_swb, p_swb_values, &swb_flags, true);
+  (void)opt_strings_flags((char_u *)p_wop, p_wop_values, &wop_flags, true);
+  (void)opt_strings_flags((char_u *)p_jop, p_jop_values, &jop_flags, true);
+  (void)opt_strings_flags((char_u *)p_cb, p_cb_values, &cb_flags, true);
 }
 
 /// Trigger the OptionSet autocommand.
@@ -281,19 +281,19 @@ void check_string_option(char **pp)
 ///
 /// @param opt_idx  option index
 /// @param varp  pointer to option variable
-static void set_string_option_global(int opt_idx, char_u **varp)
+static void set_string_option_global(int opt_idx, char **varp)
 {
-  char_u **p, *s;
+  char **p;
 
   // the global value is always allocated
   if (is_window_local_option(opt_idx)) {
-    p = (char_u **)GLOBAL_WO(varp);
+    p = (char **)GLOBAL_WO(varp);
   } else {
-    p = (char_u **)get_option_var(opt_idx);
+    p = (char **)get_option_var(opt_idx);
   }
   if (!is_global_option(opt_idx) && p != varp) {
-    s = vim_strsave(*varp);
-    free_string_option((char *)(*p));
+    char *s = xstrdup(*varp);
+    free_string_option(*p);
     *p = s;
   }
 }
@@ -339,7 +339,7 @@ void set_string_option_direct(const char *name, int opt_idx, const char *val, in
 
     // For buffer/window local option may also set the global value.
     if (both) {
-      set_string_option_global(idx, (char_u **)varp);
+      set_string_option_global(idx, varp);
     }
 
     set_option_flag(idx, P_ALLOCED);
@@ -420,7 +420,7 @@ char *set_string_option(const int opt_idx, const char *const value, const int op
   char *const saved_newval = xstrdup(s);
 
   int value_checked = false;
-  char *const errmsg = did_set_string_option(opt_idx, (char_u **)varp, (char_u *)oldval,
+  char *const errmsg = did_set_string_option(opt_idx, varp, oldval,
                                              NULL, 0,
                                              opt_flags, &value_checked);
   if (errmsg == NULL) {
@@ -631,8 +631,8 @@ static int shada_idx = -1;
 /// @param value_checked  value was checked to be safe, no need to set P_INSECURE
 ///
 /// @return  NULL for success, or an untranslated error message for an error
-char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *errbuf,
-                            size_t errbuflen, int opt_flags, int *value_checked)
+char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf, size_t errbuflen,
+                            int opt_flags, int *value_checked)
 {
   char *errmsg = NULL;
   char *s, *p;
@@ -650,20 +650,19 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       && (get_option_flags(opt_idx) & P_SECURE)) {
     errmsg = e_secure;
   } else if (((get_option_flags(opt_idx) & P_NFNAME)
-              && strpbrk((char *)(*varp),
-                         (secure ? "/\\*?[|;&<>\r\n" : "/\\*?[<>\r\n")) != NULL)
+              && strpbrk(*varp, (secure ? "/\\*?[|;&<>\r\n" : "/\\*?[<>\r\n")) != NULL)
              || ((get_option_flags(opt_idx) & P_NDNAME)
-                 && strpbrk((char *)(*varp), "*?[|;&<>\r\n") != NULL)) {
+                 && strpbrk(*varp, "*?[|;&<>\r\n") != NULL)) {
     // Check for a "normal" directory or file name in some options.  Disallow a
     // path separator (slash and/or backslash), wildcards and characters that
     // are often illegal in a file name. Be more permissive if "secure" is off.
     errmsg = e_invarg;
-  } else if (gvarp == &p_bkc) {  // 'backupcopy'
-    char_u *bkc   = p_bkc;
+  } else if (gvarp == (char_u **)&p_bkc) {  // 'backupcopy'
+    char *bkc = p_bkc;
     unsigned int *flags = &bkc_flags;
 
     if (opt_flags & OPT_LOCAL) {
-      bkc = (char_u *)curbuf->b_p_bkc;
+      bkc = curbuf->b_p_bkc;
       flags = &curbuf->b_bkc_flags;
     }
 
@@ -671,7 +670,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       // make the local value empty: use the global value
       *flags = 0;
     } else {
-      if (opt_strings_flags(bkc, p_bkc_values, flags, true) != OK) {
+      if (opt_strings_flags((char_u *)bkc, p_bkc_values, flags, true) != OK) {
         errmsg = e_invarg;
       }
 
@@ -679,7 +678,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
           + ((*flags & BKC_YES) != 0)
           + ((*flags & BKC_NO) != 0) != 1) {
         // Must have exactly one of "auto", "yes"  and "no".
-        (void)opt_strings_flags(oldval, p_bkc_values, flags, true);
+        (void)opt_strings_flags((char_u *)oldval, p_bkc_values, flags, true);
         errmsg = e_invarg;
       }
     }
@@ -688,12 +687,12 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
                *p_pm == '.' ? p_pm + 1 : p_pm) == 0) {
       errmsg = e_backupext_and_patchmode_are_equal;
     }
-  } else if (varp == (char_u **)&curwin->w_p_briopt) {  // 'breakindentopt'
+  } else if (varp == &curwin->w_p_briopt) {  // 'breakindentopt'
     if (briopt_check(curwin) == FAIL) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_isi
-             || varp == (char_u **)&(curbuf->b_p_isk)
+             || varp == &(curbuf->b_p_isk)
              || varp == &p_isp
              || varp == &p_isf) {
     // 'isident', 'iskeyword', 'isprint or 'isfname' option: refill g_chartab[]
@@ -713,14 +712,14 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (varp == &p_rtp || varp == &p_pp) {  // 'runtimepath' 'packpath'
     runtime_search_path_invalidate();
-  } else if (varp == (char_u **)&curwin->w_p_culopt
+  } else if (varp == &curwin->w_p_culopt
              || gvarp == (char_u **)&curwin->w_allbuf_opt.wo_culopt) {  // 'cursorlineopt'
-    if (**varp == NUL || fill_culopt_flags(*varp, curwin) != OK) {
+    if (**varp == NUL || fill_culopt_flags((char_u *)(*varp), curwin) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == (char_u **)&curwin->w_p_cc) {  // 'colorcolumn'
+  } else if (varp == &curwin->w_p_cc) {  // 'colorcolumn'
     errmsg = check_colorcolumn(curwin);
-  } else if (varp == &p_hlg) {  // 'helplang'
+  } else if (varp == (char **)&p_hlg) {  // 'helplang'
     // Check for "", "ab", "ab,cd", etc.
     for (s = (char *)p_hlg; *s != NUL; s += 3) {
       if (s[1] == NUL || ((s[2] != ',' || s[3] == NUL) && s[2] != NUL)) {
@@ -736,42 +735,42 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_unsupportedoption;
     }
   } else if (varp == &p_jop) {  // 'jumpoptions'
-    if (opt_strings_flags(p_jop, p_jop_values, &jop_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_jop, p_jop_values, &jop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_nf) {  // 'nrformats'
-    if (check_opt_strings(*varp, p_nf_values, true) != OK) {
+    if (check_opt_strings((char_u *)(*varp), p_nf_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ssop) {  // 'sessionoptions'
-    if (opt_strings_flags(p_ssop, p_ssop_values, &ssop_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_ssop, p_ssop_values, &ssop_flags, true) != OK) {
       errmsg = e_invarg;
     }
     if ((ssop_flags & SSOP_CURDIR) && (ssop_flags & SSOP_SESDIR)) {
       // Don't allow both "sesdir" and "curdir".
-      (void)opt_strings_flags(oldval, p_ssop_values, &ssop_flags, true);
+      (void)opt_strings_flags((char_u *)oldval, p_ssop_values, &ssop_flags, true);
       errmsg = e_invarg;
     }
   } else if (varp == &p_vop) {  // 'viewoptions'
-    if (opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_vop, p_ssop_values, &vop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_rdb) {  // 'redrawdebug'
-    if (opt_strings_flags(p_rdb, p_rdb_values, &rdb_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_rdb, p_rdb_values, &rdb_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == (char_u **)&p_sbo) {  // 'scrollopt'
+  } else if (varp == &p_sbo) {  // 'scrollopt'
     if (check_opt_strings((char_u *)p_sbo, p_scbopt_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ambw || (int *)varp == &p_emoji) {  // 'ambiwidth'
-    if (check_opt_strings(p_ambw, p_ambw_values, false) != OK) {
+    if (check_opt_strings((char_u *)p_ambw, p_ambw_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       errmsg = check_chars_options();
     }
   } else if (varp == &p_bg) {  // 'background'
-    if (check_opt_strings(p_bg, p_bg_values, false) == OK) {
+    if (check_opt_strings((char_u *)p_bg, p_bg_values, false) == OK) {
       int dark = (*p_bg == 'd');
 
       init_highlight(false, false);
@@ -781,9 +780,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         // value, that's not what we want here.  Disable the color
         // scheme and set the colors again.
         do_unlet(S_LEN("g:colors_name"), true);
-        free_string_option((char *)p_bg);
-        p_bg = vim_strsave((char_u *)(dark ? "dark" : "light"));
-        check_string_option((char **)&p_bg);
+        free_string_option(p_bg);
+        p_bg = xstrdup((dark ? "dark" : "light"));
+        check_string_option(&p_bg);
         init_highlight(false, false);
       }
     } else {
@@ -794,24 +793,24 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_invarg;
     }
   } else if (varp == &p_wop) {  // 'wildoptions'
-    if (opt_strings_flags(p_wop, p_wop_values, &wop_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_wop, p_wop_values, &wop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_wak) {  // 'winaltkeys'
     if (*p_wak == NUL
-        || check_opt_strings(p_wak, p_wak_values, false) != OK) {
+        || check_opt_strings((char_u *)p_wak, p_wak_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ei) {  // 'eventignore'
     if (check_ei() == FAIL) {
       errmsg = e_invarg;
     }
-  } else if (varp == &p_enc || gvarp == &p_fenc || gvarp == &p_menc) {
+  } else if (varp == &p_enc || gvarp == (char_u **)&p_fenc || gvarp == &p_menc) {
     // 'encoding', 'fileencoding' and 'makeencoding'
-    if (gvarp == &p_fenc) {
+    if (gvarp == (char_u **)&p_fenc) {
       if (!MODIFIABLE(curbuf) && opt_flags != OPT_GLOBAL) {
         errmsg = e_modifiable;
-      } else if (vim_strchr((char *)(*varp), ',') != NULL) {
+      } else if (vim_strchr(*varp, ',') != NULL) {
         // No comma allowed in 'fileencoding'; catches confusing it
         // with 'fileencodings'.
         errmsg = e_invarg;
@@ -825,9 +824,9 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
 
     if (errmsg == NULL) {
       // canonize the value, so that STRCMP() can be used on it
-      p = (char *)enc_canonize(*varp);
+      p = (char *)enc_canonize((char_u *)(*varp));
       xfree(*varp);
-      *varp = (char_u *)p;
+      *varp = p;
       if (varp == &p_enc) {
         // only encoding=utf-8 allowed
         if (STRCMP(p_enc, "utf-8") != 0) {
@@ -839,11 +838,11 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (varp == &p_penc) {
     // Canonize printencoding if VIM standard one
-    p = (char *)enc_canonize(p_penc);
+    p = (char *)enc_canonize((char_u *)p_penc);
     xfree(p_penc);
-    p_penc = (char_u *)p;
-  } else if (varp == (char_u **)&curbuf->b_p_keymap) {
-    if (!valid_filetype(*varp)) {
+    p_penc = p;
+  } else if (varp == &curbuf->b_p_keymap) {
+    if (!valid_filetype((char_u *)(*varp))) {
       errmsg = e_invarg;
     } else {
       int secure_save = secure;
@@ -884,10 +883,10 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
       status_redraw_curbuf();
     }
-  } else if (gvarp == &p_ff) {  // 'fileformat'
+  } else if (gvarp == (char_u **)&p_ff) {  // 'fileformat'
     if (!MODIFIABLE(curbuf) && !(opt_flags & OPT_GLOBAL)) {
       errmsg = e_modifiable;
-    } else if (check_opt_strings(*varp, p_ff_values, false) != OK) {
+    } else if (check_opt_strings((char_u *)(*varp), p_ff_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       redraw_titles();
@@ -899,12 +898,12 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         redraw_curbuf_later(UPD_NOT_VALID);
       }
     }
-  } else if (varp == (char_u **)&p_ffs) {  // 'fileformats'
+  } else if (varp == &p_ffs) {  // 'fileformats'
     if (check_opt_strings((char_u *)p_ffs, p_ff_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_mps) {  // 'matchpairs'
-    for (p = (char *)(*varp); *p != NUL; p++) {
+    for (p = *varp; *p != NUL; p++) {
       int x2 = -1;
       int x3 = -1;
 
@@ -924,8 +923,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         break;
       }
     }
-  } else if (gvarp == &p_com) {  // 'comments'
-    for (s = (char *)(*varp); *s;) {
+  } else if (gvarp == (char_u **)&p_com) {  // 'comments'
+    for (s = *varp; *s;) {
       while (*s && *s != ':') {
         if (vim_strchr(COM_ALL, *s) == NULL
             && !ascii_isdigit(*s) && *s != '-') {
@@ -953,7 +952,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
   } else if (varp == &p_lcs || varp == &p_fcs) {  // global 'listchars' or 'fillchars'
     char **local_ptr = varp == &p_lcs ? &curwin->w_p_lcs : &curwin->w_p_fcs;
     // only apply the global value to "curwin" when it does not have a local value
-    errmsg = set_chars_option(curwin, varp, **local_ptr == NUL || !(opt_flags & OPT_GLOBAL));
+    errmsg =
+      set_chars_option(curwin, (char_u **)varp, **local_ptr == NUL || !(opt_flags & OPT_GLOBAL));
     if (errmsg == NULL) {
       // If the current window is set to use the global
       // 'listchars'/'fillchars' value, clear the window-local value.
@@ -972,13 +972,13 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
       redraw_all_later(UPD_NOT_VALID);
     }
-  } else if (varp == (char_u **)&curwin->w_p_lcs) {  // local 'listchars'
-    errmsg = set_chars_option(curwin, varp, true);
-  } else if (varp == (char_u **)&curwin->w_p_fcs) {  // local 'fillchars'
-    errmsg = set_chars_option(curwin, varp, true);
+  } else if (varp == &curwin->w_p_lcs) {  // local 'listchars'
+    errmsg = set_chars_option(curwin, (char_u **)varp, true);
+  } else if (varp == &curwin->w_p_fcs) {  // local 'fillchars'
+    errmsg = set_chars_option(curwin, (char_u **)varp, true);
   } else if (varp == &p_cedit) {  // 'cedit'
     errmsg = check_cedit();
-  } else if (varp == &p_vfile) {  // 'verbosefile'
+  } else if (varp == (char **)&p_vfile) {  // 'verbosefile'
     verbose_stop();
     if (*p_vfile != NUL && verbose_open() == FAIL) {
       errmsg = e_invarg;
@@ -993,7 +993,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     // there would be a disconnect between the check for P_ALLOCED at the start
     // of the function and the set of P_ALLOCED at the end of the function.
     free_oldval = (get_option_flags(opt_idx) & P_ALLOCED);
-    for (s = (char *)p_shada; *s;) {
+    for (s = p_shada; *s;) {
       // Check it's a valid character
       if (vim_strchr("!\"%'/:<@cfhnrs", *s) == NULL) {
         errmsg = illegal_char(errbuf, errbuflen, *s);
@@ -1037,8 +1037,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     if (*p_shada && errmsg == NULL && get_shada_parameter('\'') < 0) {
       errmsg = N_("E528: Must specify a ' value");
     }
-  } else if (gvarp == &p_sbr) {  // 'showbreak'
-    for (s = (char *)(*varp); *s;) {
+  } else if (gvarp == (char_u **)&p_sbr) {  // 'showbreak'
+    for (s = *varp; *s;) {
       if (ptr2cells(s) != 1) {
         errmsg = e_showbreak_contains_unprintable_or_wide_character;
       }
@@ -1052,14 +1052,14 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     errmsg = parse_printmbfont();
   } else if (varp == &p_langmap) {  // 'langmap'
     langmap_set();
-  } else if (varp == &p_breakat) {  // 'breakat'
+  } else if (varp == (char **)&p_breakat) {  // 'breakat'
     fill_breakat_flags();
   } else if (varp == &p_titlestring || varp == &p_iconstring) {
     // 'titlestring' and 'iconstring'
     int flagval = (varp == &p_titlestring) ? STL_IN_TITLE : STL_IN_ICON;
 
     // NULL => statusline syntax
-    if (vim_strchr((char *)(*varp), '%') && check_stl_option((char *)(*varp)) == NULL) {
+    if (vim_strchr(*varp, '%') && check_stl_option(*varp) == NULL) {
       stl_syntax |= flagval;
     } else {
       stl_syntax &= ~flagval;
@@ -1067,65 +1067,65 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     did_set_title();
   } else if (varp == &p_sel) {  // 'selection'
     if (*p_sel == NUL
-        || check_opt_strings(p_sel, p_sel_values, false) != OK) {
+        || check_opt_strings((char_u *)p_sel, p_sel_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_slm) {  // 'selectmode'
-    if (check_opt_strings(p_slm, p_slm_values, true) != OK) {
+    if (check_opt_strings((char_u *)p_slm, p_slm_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_km) {  // 'keymodel'
-    if (check_opt_strings(p_km, p_km_values, true) != OK) {
+    if (check_opt_strings((char_u *)p_km, p_km_values, true) != OK) {
       errmsg = e_invarg;
     } else {
-      km_stopsel = (vim_strchr((char *)p_km, 'o') != NULL);
-      km_startsel = (vim_strchr((char *)p_km, 'a') != NULL);
+      km_stopsel = (vim_strchr(p_km, 'o') != NULL);
+      km_startsel = (vim_strchr(p_km, 'a') != NULL);
     }
   } else if (varp == &p_mousem) {  // 'mousemodel'
-    if (check_opt_strings(p_mousem, p_mousem_values, false) != OK) {
+    if (check_opt_strings((char_u *)p_mousem, p_mousem_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_mousescroll) {  // 'mousescroll'
-    errmsg = check_mousescroll((char *)p_mousescroll);
+    errmsg = check_mousescroll(p_mousescroll);
   } else if (varp == &p_swb) {  // 'switchbuf'
-    if (opt_strings_flags(p_swb, p_swb_values, &swb_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_swb, p_swb_values, &swb_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_debug) {  // 'debug'
-    if (check_opt_strings(p_debug, p_debug_values, true) != OK) {
+    if (check_opt_strings((char_u *)p_debug, p_debug_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_dy) {  // 'display'
-    if (opt_strings_flags(p_dy, p_dy_values, &dy_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_dy, p_dy_values, &dy_flags, true) != OK) {
       errmsg = e_invarg;
     } else {
       (void)init_chartab();
       msg_grid_validate();
     }
   } else if (varp == &p_ead) {  // 'eadirection'
-    if (check_opt_strings(p_ead, p_ead_values, false) != OK) {
+    if (check_opt_strings((char_u *)p_ead, p_ead_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_cb) {  // 'clipboard'
-    if (opt_strings_flags(p_cb, p_cb_values, &cb_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_cb, p_cb_values, &cb_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == (char_u **)&(curwin->w_s->b_p_spl)  // 'spell'
-             || varp == (char_u **)&(curwin->w_s->b_p_spf)) {
+  } else if (varp == &(curwin->w_s->b_p_spl)  // 'spell'
+             || varp == &(curwin->w_s->b_p_spf)) {
     // When 'spelllang' or 'spellfile' is set and there is a window for this
     // buffer in which 'spell' is set load the wordlists.
-    const bool is_spellfile = varp == (char_u **)&(curwin->w_s->b_p_spf);
+    const bool is_spellfile = varp == &(curwin->w_s->b_p_spf);
 
-    if ((is_spellfile && !valid_spellfile(*varp))
-        || (!is_spellfile && !valid_spelllang(*varp))) {
+    if ((is_spellfile && !valid_spellfile((char_u *)(*varp)))
+        || (!is_spellfile && !valid_spelllang((char_u *)(*varp)))) {
       errmsg = e_invarg;
     } else {
       errmsg = did_set_spell_option(is_spellfile);
     }
-  } else if (varp == (char_u **)&(curwin->w_s->b_p_spc)) {
+  } else if (varp == &(curwin->w_s->b_p_spc)) {
     // When 'spellcapcheck' is set compile the regexp program.
     errmsg = compile_cap_prog(curwin->w_s);
-  } else if (varp == (char_u **)&(curwin->w_s->b_p_spo)) {  // 'spelloptions'
+  } else if (varp == &(curwin->w_s->b_p_spo)) {  // 'spelloptions'
     if (**varp != NUL && STRCMP("camel", *varp) != 0) {
       errmsg = e_invarg;
     }
@@ -1156,24 +1156,25 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       curbuf->b_help = (curbuf->b_p_bt[0] == 'h');
       redraw_titles();
     }
-  } else if (gvarp == &p_stl || gvarp == (char_u **)&p_wbr || varp == &p_tal || varp == &p_ruf) {
+  } else if (gvarp == (char_u **)&p_stl || gvarp == (char_u **)&p_wbr || varp == &p_tal
+             || varp == &p_ruf) {
     // 'statusline', 'winbar', 'tabline' or 'rulerformat'
     int wid;
 
     if (varp == &p_ruf) {       // reset ru_wid first
       ru_wid = 0;
     }
-    s = (char *)(*varp);
+    s = *varp;
     if (varp == &p_ruf && *s == '%') {
       // set ru_wid if 'ruf' starts with "%99("
       if (*++s == '-') {        // ignore a '-'
         s++;
       }
       wid = getdigits_int(&s, true, 0);
-      if (wid && *s == '(' && (errmsg = check_stl_option((char *)p_ruf)) == NULL) {
+      if (wid && *s == '(' && (errmsg = check_stl_option(p_ruf)) == NULL) {
         ru_wid = wid;
       } else {
-        errmsg = check_stl_option((char *)p_ruf);
+        errmsg = check_stl_option(p_ruf);
       }
     } else if (varp == &p_ruf || s[0] != '%' || s[1] != '!') {
       // check 'statusline', 'winbar' or 'tabline' only if it doesn't start with "%!"
@@ -1188,7 +1189,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (gvarp == &p_cpt) {
     // check if it is a valid value for 'complete' -- Acevedo
-    for (s = (char *)(*varp); *s;) {
+    for (s = *varp; *s;) {
       while (*s == ',' || *s == ' ') {
         s++;
       }
@@ -1222,7 +1223,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
     }
   } else if (varp == &p_cot) {  // 'completeopt'
-    if (check_opt_strings(p_cot, p_cot_values, true) != OK) {
+    if (check_opt_strings((char_u *)p_cot, p_cot_values, true) != OK) {
       errmsg = e_invarg;
     } else {
       completeopt_was_set();
@@ -1234,8 +1235,8 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_invarg;
     }
 #endif
-  } else if (varp == (char_u **)&curwin->w_p_scl) {  // 'signcolumn'
-    if (check_signcolumn(*varp) != OK) {
+  } else if (varp == &curwin->w_p_scl) {  // 'signcolumn'
+    if (check_signcolumn((char_u *)(*varp)) != OK) {
       errmsg = e_invarg;
     }
     // When changing the 'signcolumn' to or from 'number', recompute the
@@ -1245,13 +1246,13 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         && (curwin->w_p_nu || curwin->w_p_rnu)) {
       curwin->w_nrwidth_line_count = 0;
     }
-  } else if (varp == (char_u **)&curwin->w_p_fdc
-             || varp == (char_u **)&curwin->w_allbuf_opt.wo_fdc) {
+  } else if (varp == &curwin->w_p_fdc
+             || varp == &curwin->w_allbuf_opt.wo_fdc) {
     // 'foldcolumn'
-    if (**varp == NUL || check_opt_strings(*varp, p_fdc_values, false) != OK) {
+    if (**varp == NUL || check_opt_strings((char_u *)(*varp), p_fdc_values, false) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == &p_pt) {
+  } else if (varp == (char **)&p_pt) {
     // 'pastetoggle': translate key codes like in a mapping
     if (*p_pt) {
       p = NULL;
@@ -1269,21 +1270,21 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       if (*p_bs > '3' || p_bs[1] != NUL) {
         errmsg = e_invarg;
       }
-    } else if (check_opt_strings(p_bs, p_bs_values, true) != OK) {
+    } else if (check_opt_strings((char_u *)p_bs, p_bs_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_bo) {
-    if (opt_strings_flags(p_bo, p_bo_values, &bo_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_bo, p_bo_values, &bo_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == &p_tc) {  // 'tagcase'
+  } else if (gvarp == (char_u **)&p_tc) {  // 'tagcase'
     unsigned int *flags;
 
     if (opt_flags & OPT_LOCAL) {
       p = curbuf->b_p_tc;
       flags = &curbuf->b_tc_flags;
     } else {
-      p = (char *)p_tc;
+      p = p_tc;
       flags = &tc_flags;
     }
 
@@ -1295,7 +1296,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_invarg;
     }
   } else if (varp == &p_cmp) {  // 'casemap'
-    if (opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_cmp, p_cmp_values, &cmp_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_dip) {  // 'diffopt'
@@ -1303,7 +1304,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       errmsg = e_invarg;
     }
   } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdm) {  // 'foldmethod'
-    if (check_opt_strings(*varp, p_fdm_values, false) != OK
+    if (check_opt_strings((char_u *)(*varp), p_fdm_values, false) != OK
         || *curwin->w_p_fdm == NUL) {
       errmsg = e_invarg;
     } else {
@@ -1312,29 +1313,29 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         newFoldLevel();
       }
     }
-  } else if (varp == (char_u **)&curwin->w_p_fde) {  // 'foldexpr'
+  } else if (varp == &curwin->w_p_fde) {  // 'foldexpr'
     if (foldmethodIsExpr(curwin)) {
       foldUpdateAll(curwin);
     }
   } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fmr) {  // 'foldmarker'
-    p = vim_strchr((char *)(*varp), ',');
+    p = vim_strchr(*varp, ',');
     if (p == NULL) {
       errmsg = N_("E536: comma required");
-    } else if ((char_u *)p == *varp || p[1] == NUL) {
+    } else if (p == *varp || p[1] == NUL) {
       errmsg = e_invarg;
     } else if (foldmethodIsMarker(curwin)) {
       foldUpdateAll(curwin);
     }
   } else if (gvarp == &p_cms) {  // 'commentstring'
-    if (**varp != NUL && strstr((char *)(*varp), "%s") == NULL) {
+    if (**varp != NUL && strstr(*varp, "%s") == NULL) {
       errmsg = N_("E537: 'commentstring' must be empty or contain %s");
     }
   } else if (varp == &p_fdo) {  // 'foldopen'
-    if (opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_fdo, p_fdo_values, &fdo_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_fcl) {  // 'foldclose'
-    if (check_opt_strings(p_fcl, p_fcl_values, true) != OK) {
+    if (check_opt_strings((char_u *)p_fcl, p_fcl_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdi) {  // 'foldignore'
@@ -1365,7 +1366,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
   } else if (varp == &p_csqf) {
     if (p_csqf != NULL) {
-      p = (char *)p_csqf;
+      p = p_csqf;
       while (*p != NUL) {
         if (vim_strchr(CSQF_CMDS, *p) == NULL
             || p[1] == NUL
@@ -1380,15 +1381,15 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
         }
       }
     }
-  } else if (gvarp == &p_cino) {  // 'cinoptions'
+  } else if (gvarp == (char_u **)&p_cino) {  // 'cinoptions'
     // TODO(vim): recognize errors
     parse_cino(curbuf);
   } else if (varp == &p_icm) {  // 'inccommand'
-    if (check_opt_strings(p_icm, p_icm_values, false) != OK) {
+    if (check_opt_strings((char_u *)p_icm, p_icm_values, false) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == &p_ft) {
-    if (!valid_filetype(*varp)) {
+  } else if (gvarp == (char_u **)&p_ft) {
+    if (!valid_filetype((char_u *)(*varp))) {
       errmsg = e_invarg;
     } else {
       value_changed = STRCMP(oldval, *varp) != 0;
@@ -1398,7 +1399,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       *value_checked = true;
     }
   } else if (gvarp == &p_syn) {
-    if (!valid_filetype(*varp)) {
+    if (!valid_filetype((char_u *)(*varp))) {
       errmsg = e_invarg;
     } else {
       value_changed = STRCMP(oldval, *varp) != 0;
@@ -1407,25 +1408,25 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       // even when the value comes from a modeline.
       *value_checked = true;
     }
-  } else if (varp == (char_u **)&curwin->w_p_winhl) {
+  } else if (varp == &curwin->w_p_winhl) {
     if (!parse_winhl_opt(curwin)) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_tpf) {
-    if (opt_strings_flags(p_tpf, p_tpf_values, &tpf_flags, true) != OK) {
+    if (opt_strings_flags((char_u *)p_tpf, p_tpf_values, &tpf_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == (char_u **)&(curbuf->b_p_vsts)) {  // 'varsofttabstop'
+  } else if (varp == &(curbuf->b_p_vsts)) {  // 'varsofttabstop'
     char_u *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
       XFREE_CLEAR(curbuf->b_p_vsts_array);
     } else {
-      for (cp = *varp; *cp; cp++) {
+      for (cp = (char_u *)(*varp); *cp; cp++) {
         if (ascii_isdigit(*cp)) {
           continue;
         }
-        if (*cp == ',' && cp > *varp && *(cp - 1) != ',') {
+        if (*cp == ',' && cp > (char_u *)(*varp) && *(cp - 1) != ',') {
           continue;
         }
         errmsg = e_invarg;
@@ -1433,24 +1434,24 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
       if (errmsg == NULL) {
         long *oldarray = curbuf->b_p_vsts_array;
-        if (tabstop_set(*varp, &(curbuf->b_p_vsts_array))) {
+        if (tabstop_set((char_u *)(*varp), &(curbuf->b_p_vsts_array))) {
           xfree(oldarray);
         } else {
           errmsg = e_invarg;
         }
       }
     }
-  } else if (varp == (char_u **)&(curbuf->b_p_vts)) {  // 'vartabstop'
+  } else if (varp == &(curbuf->b_p_vts)) {  // 'vartabstop'
     char_u *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
       XFREE_CLEAR(curbuf->b_p_vts_array);
     } else {
-      for (cp = *varp; *cp; cp++) {
+      for (cp = (char_u *)(*varp); *cp; cp++) {
         if (ascii_isdigit(*cp)) {
           continue;
         }
-        if (*cp == ',' && cp > *varp && *(cp - 1) != ',') {
+        if (*cp == ',' && cp > (char_u *)(*varp) && *(cp - 1) != ',') {
           continue;
         }
         errmsg = e_invarg;
@@ -1458,7 +1459,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
       }
       if (errmsg == NULL) {
         long *oldarray = curbuf->b_p_vts_array;
-        if (tabstop_set(*varp, &(curbuf->b_p_vts_array))) {
+        if (tabstop_set((char_u *)(*varp), &(curbuf->b_p_vts_array))) {
           xfree(oldarray);
           if (foldmethodIsIndent(curwin)) {
             foldUpdateAll(curwin);
@@ -1484,17 +1485,17 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     }
     if (varp == &p_shm) {  // 'shortmess'
       p = (char *)SHM_ALL;
-    } else if (varp == (char_u **)&(p_cpo)) {  // 'cpoptions'
+    } else if (varp == &(p_cpo)) {  // 'cpoptions'
       p = CPO_VI;
-    } else if (varp == (char_u **)&(curbuf->b_p_fo)) {  // 'formatoptions'
+    } else if (varp == &(curbuf->b_p_fo)) {  // 'formatoptions'
       p = FO_ALL;
-    } else if (varp == (char_u **)&curwin->w_p_cocu) {  // 'concealcursor'
+    } else if (varp == &curwin->w_p_cocu) {  // 'concealcursor'
       p = COCU_ALL;
     } else if (varp == &p_mouse) {  // 'mouse'
       p = MOUSE_ALL;
     }
     if (p != NULL) {
-      for (s = (char *)(*varp); *s; s++) {
+      for (s = *varp; *s; s++) {
         if (vim_strchr(p, *s) == NULL) {
           errmsg = illegal_char(errbuf, errbuflen, *s);
           break;
@@ -1505,7 +1506,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
 
   // If error detected, restore the previous value.
   if (errmsg != NULL) {
-    free_string_option((char *)(*varp));
+    free_string_option(*varp);
     *varp = oldval;
     // When resetting some values, need to act on it.
     if (did_chartab) {
@@ -1518,7 +1519,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
     // Use "free_oldval", because recursiveness may change the flags under
     // our fingers (esp. init_highlight()).
     if (free_oldval) {
-      free_string_option((char *)oldval);
+      free_string_option(oldval);
     }
     set_option_flag(opt_idx, P_ALLOCED);
 
@@ -1536,7 +1537,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
 
     // Trigger the autocommand only after setting the flags.
     // When 'syntax' is set, load the syntax of that name
-    if (varp == (char_u **)&(curbuf->b_p_syn)) {
+    if (varp == &(curbuf->b_p_syn)) {
       static int syn_recursive = 0;
 
       syn_recursive++;
@@ -1546,7 +1547,7 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
                      value_changed || syn_recursive == 1, curbuf);
       curbuf->b_flags |= BF_SYN_SET;
       syn_recursive--;
-    } else if (varp == (char_u **)&(curbuf->b_p_ft)) {
+    } else if (varp == &(curbuf->b_p_ft)) {
       // 'filetype' is set, trigger the FileType autocommand
       // Skip this when called from a modeline and the filetype was
       // already set to this value.
@@ -1566,13 +1567,13 @@ char *did_set_string_option(int opt_idx, char_u **varp, char_u *oldval, char *er
                        value_changed || ft_recursive == 1, curbuf);
         ft_recursive--;
         // Just in case the old "curbuf" is now invalid
-        if (varp != (char_u **)&(curbuf->b_p_ft)) {
+        if (varp != &(curbuf->b_p_ft)) {
           varp = NULL;
         }
         secure = secure_save;
       }
     }
-    if (varp == (char_u **)&(curwin->w_s->b_p_spl)) {
+    if (varp == &(curwin->w_s->b_p_spl)) {
       char_u fname[200];
       char_u *q = (char_u *)curwin->w_s->b_p_spl;
 
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index 795bff66cb..d46d51882e 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -937,8 +937,8 @@ char *vim_getenv(const char *name)
   // - the directory name from 'helpfile' (unless it contains '$')
   // - the executable name from argv[0]
   if (vim_path == NULL) {
-    if (p_hf != NULL && vim_strchr((char *)p_hf, '$') == NULL) {
-      vim_path = (char *)p_hf;
+    if (p_hf != NULL && vim_strchr(p_hf, '$') == NULL) {
+      vim_path = p_hf;
     }
 
     char exe_name[MAXPATHL];
@@ -957,7 +957,7 @@ char *vim_getenv(const char *name)
       char *vim_path_end = path_tail(vim_path);
 
       // remove "doc/" from 'helpfile', if present
-      if (vim_path == (char *)p_hf) {
+      if (vim_path == p_hf) {
         vim_path_end = remove_tail(vim_path, vim_path_end, "doc");
       }
 
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 8d3c556c7d..d786ccbf73 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -2195,7 +2195,7 @@ int expand_wildcards(int num_pat, char **pat, int *num_files, char ***files, int
       ffname = (char_u *)FullName_save((*files)[i], false);
       assert((*files)[i] != NULL);
       assert(ffname != NULL);
-      if (match_file_list(p_wig, (char_u *)(*files)[i], ffname)) {
+      if (match_file_list((char_u *)p_wig, (char_u *)(*files)[i], ffname)) {
         // remove this matching file from the list
         xfree((*files)[i]);
         for (j = i; j + 1 < *num_files; j++) {
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index 1f36e25433..529e351f33 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -703,7 +703,7 @@ static bool pum_set_selected(int n, int repeat)
     if ((pum_array[pum_selected].pum_info != NULL)
         && (Rows > 10)
         && (repeat <= 1)
-        && (vim_strchr((char *)p_cot, 'p') != NULL)) {
+        && (vim_strchr(p_cot, 'p') != NULL)) {
       win_T *curwin_save = curwin;
       tabpage_T *curtab_save = curtab;
       int res = OK;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 7c914b0276..f528bc651b 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1000,7 +1000,7 @@ static int qf_setup_state(qfstate_T *pstate, char *restrict enc, const char *res
 {
   pstate->vc.vc_type = CONV_NONE;
   if (enc != NULL && *enc != NUL) {
-    convert_setup(&pstate->vc, (char_u *)enc, p_enc);
+    convert_setup(&pstate->vc, (char_u *)enc, (char_u *)p_enc);
   }
 
   if (efile != NULL
@@ -2534,7 +2534,7 @@ static int qf_open_new_file_win(qf_info_T *ll_ref)
   if (win_split(0, flags) == FAIL) {
     return FAIL;  // not enough room for window
   }
-  p_swb = (char_u *)empty_option;  // don't split again
+  p_swb = empty_option;  // don't split again
   swb_flags = 0;
   RESET_BINDING(curwin);
   if (ll_ref != NULL) {
@@ -2923,7 +2923,7 @@ void qf_jump(qf_info_T *qi, int dir, int errornr, int forceit)
 // If 'newwin' is true, then open the file in a new window.
 static void qf_jump_newwin(qf_info_T *qi, int dir, int errornr, int forceit, bool newwin)
 {
-  char *old_swb = (char *)p_swb;
+  char *old_swb = p_swb;
   unsigned old_swb_flags = swb_flags;
   const bool old_KeyTyped = KeyTyped;           // getting file may reset it
 
@@ -2994,10 +2994,10 @@ theend:
     qfl->qf_ptr = qf_ptr;
     qfl->qf_index = qf_index;
   }
-  if (p_swb != (char_u *)old_swb && p_swb == (char_u *)empty_option) {
+  if (p_swb != old_swb && p_swb == empty_option) {
     // Restore old 'switchbuf' value, but not when an autocommand or
     // modeline has changed the value.
-    p_swb = (char_u *)old_swb;
+    p_swb = old_swb;
     swb_flags = old_swb_flags;
   }
   decr_quickfix_busy();
@@ -3834,7 +3834,7 @@ static buf_T *qf_find_buf(qf_info_T *qi)
 /// @return  OK or FAIL
 int qf_process_qftf_option(void)
 {
-  return option_set_callback_func(p_qftf, &qftf_cb);
+  return option_set_callback_func((char_u *)p_qftf, &qftf_cb);
 }
 
 /// Update the w:quickfix_title variable in the quickfix/location list window in
@@ -7033,7 +7033,7 @@ static void hgr_search_in_rtp(qf_list_T *qfl, regmatch_T *p_regmatch, const char
   FUNC_ATTR_NONNULL_ARG(1, 2)
 {
   // Go through all directories in 'runtimepath'
-  char *p = (char *)p_rtp;
+  char *p = p_rtp;
   while (*p != NUL && !got_int) {
     copy_option_part(&p, (char *)NameBuff, MAXPATHL, ",");
 
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index a04ae271e1..23606fdc77 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -303,7 +303,7 @@ int do_in_path(char_u *path, char *name, int flags, DoInRuntimepathCB callback,
   xfree(buf);
   xfree(rtp_copy);
   if (!did_one && name != NULL) {
-    char *basepath = path == p_rtp ? "runtimepath" : "packpath";
+    char *basepath = path == (char_u *)p_rtp ? "runtimepath" : "packpath";
 
     if (flags & DIP_ERR) {
       semsg(_(e_dirnotf), basepath, name);
@@ -550,7 +550,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
     char *suffix = (flags & DIP_AFTER) ? "after/" : "";
 
     vim_snprintf(s, len, start_dir, suffix, name);
-    done |= do_in_path(p_pp, s, flags & ~DIP_AFTER, callback, cookie);
+    done |= do_in_path((char_u *)p_pp, s, flags & ~DIP_AFTER, callback, cookie);
 
     xfree(s);
 
@@ -560,7 +560,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
       s = xmallocz(len);
 
       vim_snprintf(s, len, start_dir, suffix, name);
-      done |= do_in_path(p_pp, s, flags & ~DIP_AFTER, callback, cookie);
+      done |= do_in_path((char_u *)p_pp, s, flags & ~DIP_AFTER, callback, cookie);
 
       xfree(s);
     }
@@ -572,7 +572,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
     char *s = xmallocz(len);
 
     vim_snprintf(s, len, opt_dir, name);
-    done |= do_in_path(p_pp, s, flags, callback, cookie);
+    done |= do_in_path((char_u *)p_pp, s, flags, callback, cookie);
 
     xfree(s);
 
@@ -582,7 +582,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
       s = xmallocz(len);
 
       vim_snprintf(s, len, opt_dir, name);
-      done |= do_in_path(p_pp, s, flags, callback, cookie);
+      done |= do_in_path((char_u *)p_pp, s, flags, callback, cookie);
 
       xfree(s);
     }
@@ -665,7 +665,7 @@ RuntimeSearchPath runtime_search_path_build(void)
   CharVec after_path = KV_INITIAL_VALUE;
 
   static char_u buf[MAXPATHL];
-  for (char *entry = (char *)p_pp; *entry != NUL;) {
+  for (char *entry = p_pp; *entry != NUL;) {
     char *cur_entry = entry;
     copy_option_part(&entry, (char *)buf, MAXPATHL, ",");
 
@@ -676,7 +676,7 @@ RuntimeSearchPath runtime_search_path_build(void)
   }
 
   char *rtp_entry;
-  for (rtp_entry = (char *)p_rtp; *rtp_entry != NUL;) {
+  for (rtp_entry = p_rtp; *rtp_entry != NUL;) {
     char *cur_entry = rtp_entry;
     copy_option_part(&rtp_entry, (char *)buf, MAXPATHL, ",");
     size_t buflen = STRLEN(buf);
@@ -773,7 +773,7 @@ int do_in_runtimepath(char *name, int flags, DoInRuntimepathCB callback, void *c
   // TODO(bfredl): we could integrate disabled OPT dirs into the cached path
   // which would effectivize ":packadd myoptpack" as well
   if ((flags & (DIP_START|DIP_OPT)) && (success == FAIL || (flags & DIP_ALL))) {
-    success |= do_in_path_and_pp(p_rtp, (char_u *)name, flags, callback, cookie);
+    success |= do_in_path_and_pp((char_u *)p_rtp, (char_u *)name, flags, callback, cookie);
   }
   return success;
 }
@@ -1036,7 +1036,7 @@ static void add_opt_pack_plugin(char *fname, void *cookie)
 /// Add all packages in the "start" directory to 'runtimepath'.
 void add_pack_start_dirs(void)
 {
-  do_in_path(p_pp, NULL, DIP_ALL + DIP_DIR, add_pack_start_dir, NULL);
+  do_in_path((char_u *)p_pp, NULL, DIP_ALL + DIP_DIR, add_pack_start_dir, NULL);
 }
 
 static bool pack_has_entries(char_u *buf)
@@ -1070,9 +1070,9 @@ static void add_pack_start_dir(char *fname, void *cookie)
 void load_start_packages(void)
 {
   did_source_packages = true;
-  do_in_path(p_pp, "pack/*/start/*", DIP_ALL + DIP_DIR,  // NOLINT
+  do_in_path((char_u *)p_pp, "pack/*/start/*", DIP_ALL + DIP_DIR,  // NOLINT
              add_start_pack_plugin, &APP_LOAD);
-  do_in_path(p_pp, "start/*", DIP_ALL + DIP_DIR,  // NOLINT
+  do_in_path((char_u *)p_pp, "start/*", DIP_ALL + DIP_DIR,  // NOLINT
              add_start_pack_plugin, &APP_LOAD);
 }
 
@@ -1093,12 +1093,12 @@ void ex_packloadall(exarg_T *eap)
 void load_plugins(void)
 {
   if (p_lpl) {
-    char_u *rtp_copy = p_rtp;
+    char_u *rtp_copy = (char_u *)p_rtp;
     char_u *const plugin_pattern_vim = (char_u *)"plugin/**/*.vim";  // NOLINT
     char_u *const plugin_pattern_lua = (char_u *)"plugin/**/*.lua";  // NOLINT
 
     if (!did_source_packages) {
-      rtp_copy = vim_strsave(p_rtp);
+      rtp_copy = vim_strsave((char_u *)p_rtp);
       add_pack_start_dirs();
     }
 
@@ -1139,9 +1139,10 @@ void ex_packadd(exarg_T *eap)
     vim_snprintf(pat, len, plugpat, round == 1 ? "start" : "opt", eap->arg);
     // The first round don't give a "not found" error, in the second round
     // only when nothing was found in the first round.
-    res = do_in_path(p_pp, pat, DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0),
-                     round == 1 ? add_start_pack_plugin : add_opt_pack_plugin,
-                     eap->forceit ? &APP_ADD_DIR : &APP_BOTH);
+    res =
+      do_in_path((char_u *)p_pp, pat, DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0),
+                 round == 1 ? add_start_pack_plugin : add_opt_pack_plugin,
+                 eap->forceit ? &APP_ADD_DIR : &APP_BOTH);
     xfree(pat);
   }
 }
@@ -1169,10 +1170,10 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
     size_t size = STRLEN(dirnames[i]) + pat_len + 7;
     char_u *s = xmalloc(size);
     snprintf((char *)s, size, "%s/%s*.vim", dirnames[i], pat);
-    globpath((char *)p_rtp, s, &ga, 0);
+    globpath(p_rtp, s, &ga, 0);
     if (flags & DIP_LUA) {
       snprintf((char *)s, size, "%s/%s*.lua", dirnames[i], pat);
-      globpath((char *)p_rtp, s, &ga, 0);
+      globpath(p_rtp, s, &ga, 0);
     }
     xfree(s);
   }
@@ -1182,10 +1183,10 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
       size_t size = STRLEN(dirnames[i]) + pat_len + 22;
       char_u *s = xmalloc(size);
       snprintf((char *)s, size, "pack/*/start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
-      globpath((char *)p_pp, s, &ga, 0);
+      globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
         snprintf((char *)s, size, "pack/*/start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
-        globpath((char *)p_pp, s, &ga, 0);
+        globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
     }
@@ -1194,10 +1195,10 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
       size_t size = STRLEN(dirnames[i]) + pat_len + 22;
       char_u *s = xmalloc(size);
       snprintf((char *)s, size, "start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
-      globpath((char *)p_pp, s, &ga, 0);
+      globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
         snprintf((char *)s, size, "start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
-        globpath((char *)p_pp, s, &ga, 0);
+        globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
     }
@@ -1208,10 +1209,10 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
       size_t size = STRLEN(dirnames[i]) + pat_len + 20;
       char_u *s = xmalloc(size);
       snprintf((char *)s, size, "pack/*/opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
-      globpath((char *)p_pp, s, &ga, 0);
+      globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
         snprintf((char *)s, size, "pack/*/opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
-        globpath((char *)p_pp, s, &ga, 0);
+        globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
     }
@@ -1220,10 +1221,10 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
       size_t size = STRLEN(dirnames[i]) + pat_len + 20;
       char_u *s = xmalloc(size);
       snprintf((char *)s, size, "opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
-      globpath((char *)p_pp, s, &ga, 0);
+      globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
         snprintf((char *)s, size, "opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
-        globpath((char *)p_pp, s, &ga, 0);
+        globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
     }
@@ -1276,9 +1277,9 @@ int ExpandPackAddDir(char_u *pat, int *num_file, char ***file)
   size_t buflen = pat_len + 26;
   char_u *s = xmalloc(buflen);
   snprintf((char *)s, buflen, "pack/*/opt/%s*", pat);  // NOLINT
-  globpath((char *)p_pp, s, &ga, 0);
+  globpath(p_pp, s, &ga, 0);
   snprintf((char *)s, buflen, "opt/%s*", pat);  // NOLINT
-  globpath((char *)p_pp, s, &ga, 0);
+  globpath(p_pp, s, &ga, 0);
   xfree(s);
 
   for (int i = 0; i < ga.ga_len; i++) {
@@ -2017,7 +2018,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
     if (firstline != NULL && STRLEN(firstline) >= 3 && firstline[0] == 0xef
         && firstline[1] == 0xbb && firstline[2] == 0xbf) {
       // Found BOM; setup conversion, skip over BOM and recode the line.
-      convert_setup(&cookie.conv, (char_u *)"utf-8", p_enc);
+      convert_setup(&cookie.conv, (char_u *)"utf-8", (char_u *)p_enc);
       p = (char *)string_convert(&cookie.conv, (char_u *)firstline + 3, NULL);
       if (p == NULL) {
         p = xstrdup((char *)firstline + 3);
@@ -2438,7 +2439,7 @@ void ex_scriptencoding(exarg_T *eap)
 
   // Setup for conversion from the specified encoding to 'encoding'.
   sp = (struct source_cookie *)getline_cookie(eap->getline, eap->cookie);
-  convert_setup(&sp->conv, (char_u *)name, p_enc);
+  convert_setup(&sp->conv, (char_u *)name, (char_u *)p_enc);
 
   if (name != eap->arg) {
     xfree(name);
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 43c85bedb5..9c1064d608 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -1301,7 +1301,7 @@ char *set_chars_option(win_T *wp, char_u **varp, bool apply)
   const char_u *last_lmultispace = NULL;  // Last occurrence of "leadmultispace:"
   int multispace_len = 0;           // Length of lcs-multispace string
   int lead_multispace_len = 0;      // Length of lcs-leadmultispace string
-  const bool is_listchars = (varp == &p_lcs || varp == (char_u **)&wp->w_p_lcs);
+  const bool is_listchars = (varp == (char_u **)&p_lcs || varp == (char_u **)&wp->w_p_lcs);
 
   struct chars_tab {
     int *cp;     ///< char value
@@ -1349,13 +1349,13 @@ char *set_chars_option(win_T *wp, char_u **varp, bool apply)
     tab = lcs_tab;
     entries = ARRAY_SIZE(lcs_tab);
     if (varp == (char_u **)&wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
-      value = p_lcs;  // local value is empty, use the global value
+      value = (char_u *)p_lcs;  // local value is empty, use the global value
     }
   } else {
     tab = fcs_tab;
     entries = ARRAY_SIZE(fcs_tab);
     if (varp == (char_u **)&wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
-      value = p_fcs;  // local value is empty, use the global value
+      value = (char_u *)p_fcs;  // local value is empty, use the global value
     }
   }
 
@@ -1520,10 +1520,10 @@ char *set_chars_option(win_T *wp, char_u **varp, bool apply)
 /// @return  an untranslated error message if any of them is invalid, NULL otherwise.
 char *check_chars_options(void)
 {
-  if (set_chars_option(curwin, &p_lcs, false) != NULL) {
+  if (set_chars_option(curwin, (char_u **)&p_lcs, false) != NULL) {
     return e_conflicts_with_value_of_listchars;
   }
-  if (set_chars_option(curwin, &p_fcs, false) != NULL) {
+  if (set_chars_option(curwin, (char_u **)&p_fcs, false) != NULL) {
     return e_conflicts_with_value_of_fillchars;
   }
   FOR_ALL_TAB_WINDOWS(tp, wp) {
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 3b6bcbeeb3..190ad72a8f 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -2683,7 +2683,7 @@ int startPS(linenr_T lnum, int para, int both)
   if (*s == para || *s == '\f' || (both && *s == '}')) {
     return true;
   }
-  if (*s == '.' && (inmacro(p_sections, s + 1)
+  if (*s == '.' && (inmacro((char_u *)p_sections, s + 1)
                     || (!para && inmacro(p_para, s + 1)))) {
     return true;
   }
@@ -5363,7 +5363,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
       goto fpip_end;
     }
   }
-  inc_opt = (*curbuf->b_p_inc == NUL) ? p_inc : (char_u *)curbuf->b_p_inc;
+  inc_opt = (*curbuf->b_p_inc == NUL) ? (char_u *)p_inc : (char_u *)curbuf->b_p_inc;
   if (*inc_opt != NUL) {
     incl_regmatch.regprog = vim_regcomp((char *)inc_opt, p_magic ? RE_MAGIC : 0);
     if (incl_regmatch.regprog == NULL) {
@@ -5373,7 +5373,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
   }
   if (type == FIND_DEFINE && (*curbuf->b_p_def != NUL || *p_def != NUL)) {
     def_regmatch.regprog = vim_regcomp(*curbuf->b_p_def == NUL
-                                       ? (char *)p_def : curbuf->b_p_def,
+                                       ? p_def : curbuf->b_p_def,
                                        p_magic ? RE_MAGIC : 0);
     if (def_regmatch.regprog == NULL) {
       goto fpip_end;
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index daa8e99d31..3de16b3e69 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -3996,7 +3996,7 @@ static bool shada_removable(const char *name)
   bool retval = false;
 
   char *new_name = home_replace_save(NULL, (char *)name);
-  for (p = (char *)p_shada; *p;) {
+  for (p = p_shada; *p;) {
     (void)copy_option_part(&p, part, ARRAY_SIZE(part), ", ");
     if (part[0] == 'r') {
       home_replace(NULL, part + 1, (char *)NameBuff, MAXPATHL, true);
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 439fcff8a0..8fcb379bcf 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -1518,7 +1518,7 @@ static void spell_load_lang(char_u *lang)
 char_u *spell_enc(void)
 {
   if (STRLEN(p_enc) < 60 && STRCMP(p_enc, "iso-8859-15") != 0) {
-    return p_enc;
+    return (char_u *)p_enc;
   }
   return (char_u *)"latin1";
 }
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 46249470d1..c68dbd8e53 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -1863,7 +1863,7 @@ static long compress_added = 500000;    // word count
 // Sets "sps_flags".
 int spell_check_msm(void)
 {
-  char *p = (char *)p_msm;
+  char *p = p_msm;
   long start = 0;
   long incr = 0;
   long added = 0;
@@ -2123,8 +2123,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         // Setup for conversion from "ENC" to 'encoding'.
         aff->af_enc = enc_canonize(items[1]);
         if (!spin->si_ascii
-            && convert_setup(&spin->si_conv, aff->af_enc,
-                             p_enc) == FAIL) {
+            && convert_setup(&spin->si_conv, aff->af_enc, (char_u *)p_enc) == FAIL) {
           smsg(_("Conversion in %s not supported: from %s to %s"),
                fname, aff->af_enc, p_enc);
         }
@@ -3731,8 +3730,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
           line += 9;
           enc = enc_canonize(line);
           if (!spin->si_ascii
-              && convert_setup(&spin->si_conv, enc,
-                               p_enc) == FAIL) {
+              && convert_setup(&spin->si_conv, enc, (char_u *)p_enc) == FAIL) {
             smsg(_("Conversion in %s not supported: from %s to %s"),
                  fname, line, p_enc);
           }
@@ -5697,7 +5695,7 @@ static void init_spellfile(void)
 
     // Loop over all entries in 'runtimepath'.  Use the first one where we
     // are allowed to write.
-    rtp = p_rtp;
+    rtp = (char_u *)p_rtp;
     while (*rtp != NUL) {
       if (aspath) {
         // Use directory of an entry with path, e.g., for
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index ffce859ee8..fa46d94342 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -360,7 +360,7 @@ int spell_check_sps(void)
   sps_flags = 0;
   sps_limit = 9999;
 
-  for (p = (char *)p_sps; *p != NUL;) {
+  for (p = p_sps; *p != NUL;) {
     copy_option_part(&p, (char *)buf, MAXPATHL, ",");
 
     f = 0;
@@ -758,7 +758,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   }
 
   // Make a copy of 'spellsuggest', because the expression may change it.
-  sps_copy = vim_strsave(p_sps);
+  sps_copy = vim_strsave((char_u *)p_sps);
 
   // Loop over the items in 'spellsuggest'.
   for (p = (char *)sps_copy; *p != NUL;) {
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index d7277b38ae..8b56eaadf0 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -448,7 +448,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   // setup environment for the task at hand
   if (wp == NULL) {
     // Use 'tabline'.  Always at the first line of the screen.
-    stl = p_tal;
+    stl = (char_u *)p_tal;
     row = 0;
     fillchar = ' ';
     attr = HL_ATTR(HLF_TPF);
@@ -491,7 +491,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
     }
 
     if (draw_ruler) {
-      stl = p_ruf;
+      stl = (char_u *)p_ruf;
       // advance past any leading group spec - implicit in ru_col
       if (*stl == '%') {
         if (*++stl == '-') {
@@ -503,7 +503,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
           }
         }
         if (*stl++ != '(') {
-          stl = p_ruf;
+          stl = (char_u *)p_ruf;
         }
       }
       col = ru_col - (Columns - maxwidth);
@@ -524,7 +524,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
       if (*wp->w_p_stl != NUL) {
         stl = (char_u *)wp->w_p_stl;
       } else {
-        stl = p_stl;
+        stl = (char_u *)p_stl;
       }
       use_sandbox = was_set_insecurely(wp, "statusline", *wp->w_p_stl == NUL ? 0 : OPT_LOCAL);
     }
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index e9383e1bb3..fe37a79a5b 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -4035,17 +4035,13 @@ static void add_keyword(char_u *const name, const int id, const int flags,
 ///
 /// @return          a pointer to the first argument.
 ///                  Return NULL if the end of the command was found instead of further args.
-static char_u *get_group_name(char_u *arg, char_u **name_end)
+static char *get_group_name(char *arg, char **name_end)
 {
-  char_u *rest;
+  *name_end = (char *)skiptowhite((char_u *)arg);
+  char *rest = skipwhite(*name_end);
 
-  *name_end = skiptowhite(arg);
-  rest = (char_u *)skipwhite((char *)(*name_end));
-
-  /*
-   * Check if there are enough arguments.  The first argument may be a
-   * pattern, where '|' is allowed, so only check for NUL.
-   */
+  // Check if there are enough arguments.  The first argument may be a
+  // pattern, where '|' is allowed, so only check for NUL.
   if (ends_excmd(*arg) || *rest == NUL) {
     return NULL;
   }
@@ -4063,7 +4059,7 @@ static char_u *get_group_name(char_u *arg, char_u **name_end)
 ///
 /// @return      a pointer to the next argument (which isn't an option).
 ///              Return NULL for any error;
-static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
+static char_u *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
 {
   char_u *gname_start, *gname;
   int syn_id;
@@ -4117,7 +4113,7 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
       p = flagtab[fidx].name;
       int i;
       for (i = 0, len = 0; p[i] != NUL; i += 2, len++) {
-        if (arg[len] != (char_u)p[i] && arg[len] != (char_u)p[i + 1]) {
+        if (arg[len] != p[i] && arg[len] != p[i + 1]) {
           break;
         }
       }
@@ -4157,16 +4153,16 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
       }
     } else if (flagtab[fidx].argtype == 11 && arg[5] == '=') {
       // cchar=?
-      *conceal_char = utf_ptr2char((char *)arg + 6);
-      arg += utfc_ptr2len((char *)arg + 6) - 1;
+      *conceal_char = utf_ptr2char(arg + 6);
+      arg += utfc_ptr2len(arg + 6) - 1;
       if (!vim_isprintc_strict(*conceal_char)) {
         emsg(_("E844: invalid cchar value"));
         return NULL;
       }
-      arg = (char_u *)skipwhite((char *)arg + 7);
+      arg = skipwhite(arg + 7);
     } else {
       opt->flags |= flagtab[fidx].flags;
-      arg = (char_u *)skipwhite((char *)arg + len);
+      arg = skipwhite(arg + len);
 
       if (flagtab[fidx].flags == HL_SYNC_HERE
           || flagtab[fidx].flags == HL_SYNC_THERE) {
@@ -4174,12 +4170,12 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
           emsg(_("E393: group[t]here not accepted here"));
           return NULL;
         }
-        gname_start = arg;
-        arg = skiptowhite(arg);
-        if (gname_start == arg) {
+        gname_start = (char_u *)arg;
+        arg = (char *)skiptowhite((char_u *)arg);
+        if (gname_start == (char_u *)arg) {
           return NULL;
         }
-        gname = vim_strnsave(gname_start, (size_t)(arg - gname_start));
+        gname = vim_strnsave(gname_start, (size_t)((char_u *)arg - gname_start));
         if (STRCMP(gname, "NONE") == 0) {
           *opt->sync_idx = NONE_IDX;
         } else {
@@ -4200,7 +4196,7 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
         }
 
         xfree(gname);
-        arg = (char_u *)skipwhite((char *)arg);
+        arg = skipwhite(arg);
       } else if (flagtab[fidx].flags == HL_FOLD
                  && foldmethodIsSyntax(curwin)) {
         // Need to update folds later.
@@ -4209,7 +4205,7 @@ static char_u *get_syn_options(char_u *arg, syn_opt_arg_T *opt, int *conceal_cha
     }
   }
 
-  return arg;
+  return (char_u *)arg;
 }
 
 /*
@@ -4240,16 +4236,16 @@ static void syn_incl_toplevel(int id, int *flagsp)
  */
 static void syn_cmd_include(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
+  char *arg = eap->arg;
   int sgl_id = 1;
-  char_u *group_name_end;
-  char_u *rest;
+  char *group_name_end;
+  char *rest;
   char *errormsg = NULL;
   int prev_toplvl_grp;
   int prev_syn_inc_tag;
   bool source = false;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = (char *)find_nextcmd((char_u *)arg);
   if (eap->skip) {
     return;
   }
@@ -4261,12 +4257,12 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
       emsg(_("E397: Filename required"));
       return;
     }
-    sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
+    sgl_id = syn_check_cluster((char_u *)arg, (int)(group_name_end - arg));
     if (sgl_id == 0) {
       return;
     }
     // separate_nextcmd() and expand_filename() depend on this
-    eap->arg = (char *)rest;
+    eap->arg = rest;
   }
 
   /*
@@ -4314,13 +4310,13 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
  */
 static void syn_cmd_keyword(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
+  char *arg = eap->arg;
+  char *group_name_end;
   int syn_id;
-  char_u *rest;
-  char_u *keyword_copy = NULL;
-  char_u *p;
-  char_u *kw;
+  char *rest;
+  char *keyword_copy = NULL;
+  char *p;
+  char *kw;
   syn_opt_arg_T syn_opt_arg;
   int cnt;
   int conceal_char = NUL;
@@ -4331,7 +4327,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
     if (eap->skip) {
       syn_id = -1;
     } else {
-      syn_id = syn_check_group((char *)arg, (size_t)(group_name_end - arg));
+      syn_id = syn_check_group(arg, (size_t)(group_name_end - arg));
     }
     if (syn_id != 0) {
       // Allocate a buffer, for removing backslashes in the keyword.
@@ -4350,8 +4346,8 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
       // 1: collect the options and copy the keywords to keyword_copy.
       cnt = 0;
       p = keyword_copy;
-      for (; rest != NULL && !ends_excmd(*rest); rest = (char_u *)skipwhite((char *)rest)) {
-        rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+      for (; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) {
+        rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
         if (rest == NULL || ends_excmd(*rest)) {
           break;
         }
@@ -4372,11 +4368,11 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
 
         // 2: Add an entry for each keyword.
         for (kw = keyword_copy; --cnt >= 0; kw += STRLEN(kw) + 1) {
-          for (p = (char_u *)vim_strchr((char *)kw, '[');;) {
+          for (p = vim_strchr(kw, '[');;) {
             if (p != NULL) {
               *p = NUL;
             }
-            add_keyword(kw, syn_id, syn_opt_arg.flags,
+            add_keyword((char_u *)kw, syn_id, syn_opt_arg.flags,
                         syn_opt_arg.cont_in_list,
                         syn_opt_arg.next_list, conceal_char);
             if (p == NULL) {
@@ -4395,7 +4391,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
               kw = p + 1;
               break;   // skip over the "]"
             }
-            const int l = utfc_ptr2len((char *)p + 1);
+            const int l = utfc_ptr2len(p + 1);
 
             memmove(p, p + 1, (size_t)l);
             p += l;
@@ -4411,7 +4407,7 @@ error:
   }
 
   if (rest != NULL) {
-    eap->nextcmd = (char *)check_nextcmd(rest);
+    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
   } else {
     semsg(_(e_invarg2), arg);
   }
@@ -4427,9 +4423,8 @@ error:
 /// @param syncing  true for ":syntax sync match .. "
 static void syn_cmd_match(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
-  char_u *rest;
+  char *arg = eap->arg;
+  char *group_name_end;
   synpat_T item;                // the item found in the line
   int syn_id;
   syn_opt_arg_T syn_opt_arg;
@@ -4437,7 +4432,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   int conceal_char = NUL;
 
   // Isolate the group name, check for validity
-  rest = get_group_name(arg, &group_name_end);
+  char *rest = get_group_name(arg, &group_name_end);
 
   // Get options before the pattern
   syn_opt_arg.flags = 0;
@@ -4447,28 +4442,28 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   syn_opt_arg.cont_list = NULL;
   syn_opt_arg.cont_in_list = NULL;
   syn_opt_arg.next_list = NULL;
-  rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+  rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
 
   // get the pattern.
   init_syn_patterns();
   CLEAR_FIELD(item);
-  rest = get_syn_pattern(rest, &item);
+  rest = (char *)get_syn_pattern((char_u *)rest, &item);
   if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
     syn_opt_arg.flags |= HL_HAS_EOL;
   }
 
   // Get options after the pattern
-  rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+  rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
 
   if (rest != NULL) {           // all arguments are valid
     /*
      * Check for trailing command and illegal trailing arguments.
      */
-    eap->nextcmd = (char *)check_nextcmd(rest);
+    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
     } else {
-      if ((syn_id = syn_check_group((char *)arg, (size_t)(group_name_end - arg))) != 0) {
+      if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
         /*
          * Store the pattern in the syn_items list
@@ -4525,12 +4520,12 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
 /// @param syncing  true for ":syntax sync region .."
 static void syn_cmd_region(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
-  char_u *rest;                    // next arg, NULL on error
-  char_u *key_end;
-  char_u *key = NULL;
-  char_u *p;
+  char *arg = eap->arg;
+  char *group_name_end;
+  char *rest;                    // next arg, NULL on error
+  char *key_end;
+  char *key = NULL;
+  char *p;
   int item;
 #define ITEM_START          0
 #define ITEM_SKIP           1
@@ -4573,7 +4568,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
   // get the options, patterns and matchgroup.
   while (rest != NULL && !ends_excmd(*rest)) {
     // Check for option arguments
-    rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+    rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
     if (rest == NULL || ends_excmd(*rest)) {
       break;
     }
@@ -4584,7 +4579,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
       key_end++;
     }
     xfree(key);
-    key = vim_strnsave_up(rest, (size_t)(key_end - rest));
+    key = (char *)vim_strnsave_up((char_u *)rest, (size_t)(key_end - rest));
     if (STRCMP(key, "MATCHGROUP") == 0) {
       item = ITEM_MATCHGROUP;
     } else if (STRCMP(key, "START") == 0) {
@@ -4600,30 +4595,30 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     } else {
       break;
     }
-    rest = (char_u *)skipwhite((char *)key_end);
+    rest = skipwhite(key_end);
     if (*rest != '=') {
       rest = NULL;
       semsg(_("E398: Missing '=': %s"), arg);
       break;
     }
-    rest = (char_u *)skipwhite((char *)rest + 1);
+    rest = skipwhite(rest + 1);
     if (*rest == NUL) {
       not_enough = true;
       break;
     }
 
     if (item == ITEM_MATCHGROUP) {
-      p = skiptowhite(rest);
+      p = (char *)skiptowhite((char_u *)rest);
       if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip) {
         matchgroup_id = 0;
       } else {
-        matchgroup_id = syn_check_group((char *)rest, (size_t)(p - rest));
+        matchgroup_id = syn_check_group(rest, (size_t)(p - rest));
         if (matchgroup_id == 0) {
           illegal = true;
           break;
         }
       }
-      rest = (char_u *)skipwhite((char *)p);
+      rest = skipwhite(p);
     } else {
       /*
        * Allocate room for a syn_pattern, and link it in the list of
@@ -4644,7 +4639,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
         assert(item == ITEM_SKIP || item == ITEM_END);
         reg_do_extmatch = REX_USE;
       }
-      rest = get_syn_pattern(rest, ppp->pp_synp);
+      rest = (char *)get_syn_pattern((char_u *)rest, ppp->pp_synp);
       reg_do_extmatch = 0;
       if (item == ITEM_END && vim_regcomp_had_eol()
           && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
@@ -4671,12 +4666,12 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
      * Check for trailing garbage or command.
      * If OK, add the item.
      */
-    eap->nextcmd = (char *)check_nextcmd(rest);
+    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
     } else {
       ga_grow(&(curwin->w_s->b_syn_patterns), pat_count);
-      if ((syn_id = syn_check_group((char *)arg, (size_t)(group_name_end - arg))) != 0) {
+      if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
         /*
          * Store the start/skip/end in the syn_items list
@@ -4964,14 +4959,14 @@ static int syn_add_cluster(char_u *name)
  */
 static void syn_cmd_cluster(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *group_name_end;
-  char_u *rest;
+  char *arg = eap->arg;
+  char *group_name_end;
+  char *rest;
   bool got_clstr = false;
   int opt_len;
   int list_op;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = (char *)find_nextcmd((char_u *)arg);
   if (eap->skip) {
     return;
   }
@@ -4979,7 +4974,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
   rest = get_group_name(arg, &group_name_end);
 
   if (rest != NULL) {
-    int scl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
+    int scl_id = syn_check_cluster((char_u *)arg, (int)(group_name_end - arg));
     if (scl_id == 0) {
       return;
     }
@@ -5275,7 +5270,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
 /// @param list    where to store the resulting list, if not NULL, the list is silently skipped!
 ///
 /// @return        FAIL for some error, OK for success.
-static int get_id_list(char_u **const arg, const int keylen, int16_t **const list, const bool skip)
+static int get_id_list(char **const arg, const int keylen, int16_t **const list, const bool skip)
 {
   char *p = NULL;
   char *end;
@@ -5292,7 +5287,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
   // grow when a regexp is used.  In that case round 1 is done once again.
   for (int round = 1; round <= 2; round++) {
     // skip "contains"
-    p = skipwhite((char *)(*arg) + keylen);
+    p = skipwhite(*arg + keylen);
     if (*p != '=') {
       semsg(_("E405: Missing equal sign: %s"), *arg);
       break;
@@ -5417,7 +5412,7 @@ static int get_id_list(char_u **const arg, const int keylen, int16_t **const lis
     }
   }
 
-  *arg = (char_u *)p;
+  *arg = p;
   if (failed || retval == NULL) {
     xfree(retval);
     return FAIL;
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 7d3d0f7905..2e5ce972d8 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1780,7 +1780,7 @@ line_read_in:
               // encoding to 'encoding'.
               for (p = lbuf + 20; *p > ' ' && *p < 127; p++) {}
               *p = NUL;
-              convert_setup(&vimconv, lbuf + 20, p_enc);
+              convert_setup(&vimconv, lbuf + 20, (char_u *)p_enc);
             }
 
             // Read the next line.  Unrecognized flags are ignored.
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 0126ad62b5..46f4d137c4 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -336,7 +336,7 @@ void vim_beep(unsigned val)
     // When 'debug' contains "beep" produce a message.  If we are sourcing
     // a script or executing a function give the user a hint where the beep
     // comes from.
-    if (vim_strchr((char *)p_debug, 'e') != NULL) {
+    if (vim_strchr(p_debug, 'e') != NULL) {
       msg_source(HL_ATTR(HLF_W));
       msg_attr(_("Beep!"), HL_ATTR(HLF_W));
     }
@@ -565,7 +565,7 @@ void ui_check_mouse(void)
   // - 'a' is in 'mouse' and "c" is in MOUSE_A, or
   // - the current buffer is a help file and 'h' is in 'mouse' and we are in a
   //   normal editing mode (not at hit-return message).
-  for (char_u *p = p_mouse; *p; p++) {
+  for (char_u *p = (char_u *)p_mouse; *p; p++) {
     switch (*p) {
     case 'a':
       if (vim_strchr(MOUSE_A, checkfor) != NULL) {
diff --git a/src/nvim/version.c b/src/nvim/version.c
index ac55066c7f..46e3a67388 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2200,7 +2200,7 @@ void maybe_intro_message(void)
   if (buf_is_empty(curbuf)
       && (curbuf->b_fname == NULL)
       && (firstwin->w_next == NULL)
-      && (vim_strchr((char *)p_shm, SHM_INTRO) == NULL)) {
+      && (vim_strchr(p_shm, SHM_INTRO) == NULL)) {
     intro_message(false);
   }
 }
-- 
cgit 


From 900a151bf541c7fa77a56b4881c4836a1cabcde6 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 19:04:20 +0800
Subject: vim-patch:9.0.0272: BufReadCmd not triggered when loading a "nofile"
 buffer

Problem:    BufReadCmd not triggered when loading a "nofile" buffer. (Maxim
            Kim)
Solution:   Call readfile() but bail out before reading a file.
            (closes vim/vim#10983)
https://github.com/vim/vim/commit/b1d2c8116cb5577961ea109651fb888b5e58265f
---
 src/nvim/buffer.c                 | 13 ++++++++++---
 src/nvim/fileio.c                 |  5 +++++
 src/nvim/fileio.h                 |  1 +
 src/nvim/testdir/test_autocmd.vim | 12 ++++++++++++
 4 files changed, 28 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 24fd1b3022..3211b83dc7 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -165,11 +165,12 @@ static int read_buffer(int read_stdin, exarg_T *eap, int flags)
 ///
 /// @param read_stdin  read file from stdin
 /// @param eap  for forced 'ff' and 'fenc' or NULL
-/// @param flags  extra flags for readfile()
+/// @param flags_arg  extra flags for readfile()
 ///
 /// @return  FAIL for failure, OK otherwise.
-int open_buffer(int read_stdin, exarg_T *eap, int flags)
+int open_buffer(int read_stdin, exarg_T *eap, int flags_arg)
 {
+  int flags = flags_arg;
   int retval = OK;
   bufref_T old_curbuf;
   long old_tw = curbuf->b_p_tw;
@@ -224,8 +225,14 @@ int open_buffer(int read_stdin, exarg_T *eap, int flags)
   // mark cursor position as being invalid
   curwin->w_valid = 0;
 
+  // A buffer without an actual file should not use the buffer name to read a
+  // file.
+  if (bt_quickfix(curbuf) || bt_nofilename(curbuf)) {
+    flags |= READ_NOFILE;
+  }
+
   // Read the file if there is one.
-  if (curbuf->b_ffname != NULL && !bt_quickfix(curbuf) && !bt_nofilename(curbuf)) {
+  if (curbuf->b_ffname != NULL) {
 #ifdef UNIX
     int save_bin = curbuf->b_p_bin;
     int perm;
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 21c1549f42..fdba186200 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -167,6 +167,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
 /// READ_STDIN   read from stdin instead of a file
 /// READ_BUFFER  read from curbuf instead of a file (converting after reading
 ///              stdin)
+/// READ_NOFILE  do not read a file, only trigger BufReadCmd
 /// READ_DUMMY   read into a dummy buffer (to check if file contents changed)
 /// READ_KEEP_UNDO  don't clear undo info or read it from a file
 /// READ_FIFO    read from fifo/socket instead of a file
@@ -334,6 +335,10 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     }
 
     curbuf->b_op_start = orig_start;
+
+    if (flags & READ_NOFILE) {
+      return FAIL;
+    }
   }
 
   if ((shortmess(SHM_OVER) || curbuf->b_help) && p_verbose == 0) {
diff --git a/src/nvim/fileio.h b/src/nvim/fileio.h
index 650977deac..ae3c51f1bc 100644
--- a/src/nvim/fileio.h
+++ b/src/nvim/fileio.h
@@ -15,6 +15,7 @@
 #define READ_KEEP_UNDO  0x20    // keep undo info
 #define READ_FIFO       0x40    // read from fifo or socket
 #define READ_NOWINENTER 0x80    // do not trigger BufWinEnter
+#define READ_NOFILE     0x100   // do not read a file, do trigger BufReadCmd
 
 #define READ_STRING(x, y) (char_u *)read_string((x), (size_t)(y))
 
diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index 5451dcf241..f21b958f1a 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -493,6 +493,18 @@ func Test_BufReadCmdHelpJump()
   au! BufReadCmd
 endfunc
 
+" BufReadCmd is triggered for a "nofile" buffer
+func Test_BufReadCmdNofile()
+  new somefile
+  set buftype=nofile
+  au BufReadCmd somefile call setline(1, 'triggered')
+  edit
+  call assert_equal('triggered', getline(1))
+
+  au! BufReadCmd
+  bwipe!
+endfunc
+
 func Test_augroup_deleted()
   " This caused a crash before E936 was introduced
   augroup x
-- 
cgit 


From 52f00a6c4d84a13a85ff265a5c59c92795d1b333 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 20:03:08 +0800
Subject: vim-patch:9.0.0274: netrw plugin does not show remote files

Problem:    Netrw plugin does not show remote files.
Solution:   Do read a file when 'buftype' is "acwrite". (closes vim/vim#10983)
https://github.com/vim/vim/commit/c312619f7c0cf590d96e0b2ed891d1f6c43d769b
---
 src/nvim/buffer.c                   | 40 ++++++++++++++++++++++++-------------
 src/nvim/testdir/test_functions.vim |  7 +++++++
 2 files changed, 33 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 3211b83dc7..514be4c56b 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -227,7 +227,7 @@ int open_buffer(int read_stdin, exarg_T *eap, int flags_arg)
 
   // A buffer without an actual file should not use the buffer name to read a
   // file.
-  if (bt_quickfix(curbuf) || bt_nofilename(curbuf)) {
+  if (bt_nofileread(curbuf)) {
     flags |= READ_NOFILE;
   }
 
@@ -812,6 +812,18 @@ static void free_buffer(buf_T *buf)
   }
 }
 
+/// Free the b_wininfo list for buffer "buf".
+static void clear_wininfo(buf_T *buf)
+{
+  wininfo_T *wip;
+
+  while (buf->b_wininfo != NULL) {
+    wip = buf->b_wininfo;
+    buf->b_wininfo = wip->wi_next;
+    free_wininfo(wip, buf);
+  }
+}
+
 /// Free stuff in the buffer for ":bdel" and when wiping out the buffer.
 ///
 /// @param buf  Buffer pointer
@@ -846,18 +858,6 @@ static void free_buffer_stuff(buf_T *buf, int free_flags)
   buf_updates_unload(buf, false);
 }
 
-/// Free the b_wininfo list for buffer "buf".
-static void clear_wininfo(buf_T *buf)
-{
-  wininfo_T *wip;
-
-  while (buf->b_wininfo != NULL) {
-    wip = buf->b_wininfo;
-    buf->b_wininfo = wip->wi_next;
-    free_wininfo(wip, buf);
-  }
-}
-
 /// Go to another buffer.  Handles the result of the ATTENTION dialog.
 void goto_buffer(exarg_T *eap, int start, int dir, int count)
 {
@@ -3834,7 +3834,8 @@ bool bt_terminal(const buf_T *const buf)
 }
 
 /// @return  true if "buf" is a "nofile", "acwrite", "terminal" or "prompt"
-///          buffer.  This means the buffer name is not a file name.
+///          buffer.  This means the buffer name may not be a file name,
+///          at least not for writing the buffer.
 bool bt_nofilename(const buf_T *const buf)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
@@ -3844,6 +3845,17 @@ bool bt_nofilename(const buf_T *const buf)
                          || buf->b_p_bt[0] == 'p');
 }
 
+/// @return  true if "buf" is a "nofile", "quickfix", "terminal" or "prompt"
+///          buffer.  This means the buffer is not to be read from a file.
+static bool bt_nofileread(const buf_T *const buf)
+  FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
+{
+  return buf != NULL && ((buf->b_p_bt[0] == 'n' && buf->b_p_bt[2] == 'f')
+                         || buf->b_p_bt[0] == 't'
+                         || buf->b_p_bt[0] == 'q'
+                         || buf->b_p_bt[0] == 'p');
+}
+
 /// @return  true if "buf" has 'buftype' set to "nofile".
 bool bt_nofile(const buf_T *const buf)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index b1f617ceda..555c4f58b7 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -1887,6 +1887,13 @@ func Test_bufadd_bufload()
   call bufload(buf)
   call assert_equal([''], getbufline(buf, 1, '$'))
 
+  " when 'buftype' is "acwrite" then bufload() DOES read the file
+  bwipe! XotherName
+  let buf = bufadd('XotherName')
+  call setbufvar(buf, '&bt', 'acwrite')
+  call bufload(buf)
+  call assert_equal(['some', 'text'], getbufline(buf, 1, '$'))
+
   bwipe someName
   bwipe XotherName
   call assert_equal(0, bufexists('someName'))
-- 
cgit 


From 45c23a757c6fc601a76a92f052f55eb3ed469364 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 20:18:02 +0800
Subject: vim-patch:9.0.0275: BufEnter not triggered when using ":edit" in
 "nofile" buffer

Problem:    BufEnter not triggered when using ":edit" in "nofile" buffer.
Solution:   Let readfile() return NOTDONE. (closes vim/vim#10986)
https://github.com/vim/vim/commit/a9b5b85068b2fcb1c01ea20524e227bcad579ceb
---
 src/nvim/fileio.c                 |  2 +-
 src/nvim/testdir/test_autocmd.vim | 12 +++++++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index fdba186200..0b66878103 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -337,7 +337,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     curbuf->b_op_start = orig_start;
 
     if (flags & READ_NOFILE) {
-      return FAIL;
+      return NOTDONE;  // so that BufEnter can be triggered
     }
   }
 
diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index f21b958f1a..778e5f9b9f 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -599,9 +599,19 @@ func Test_BufEnter()
   " On MS-Windows we can't edit the directory, make sure we wipe the right
   " buffer.
   bwipe! Xdir
-
   call delete('Xdir', 'd')
   au! BufEnter
+
+  " Editing a "nofile" buffer doesn't read the file but does trigger BufEnter
+  " for historic reasons.
+  new somefile
+  set buftype=nofile
+  au BufEnter somefile call setline(1, 'some text')
+  edit
+  call assert_equal('some text', getline(1))
+
+  bwipe!
+  au! BufEnter
 endfunc
 
 " Closing a window might cause an endless loop
-- 
cgit 


From d813ef0097eb781baeba5d458dcb0507e2f61040 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Fri, 26 Aug 2022 22:39:13 +0800
Subject: vim-patch:9.0.0276: 'buftype' values not sufficiently tested

Problem:    'buftype' values not sufficiently tested.
Solution:   Add and extend tests with 'buftype' values. (closes vim/vim#10988)
https://github.com/vim/vim/commit/93f72cc119c796f1ccb75468ef9e446cbfb41e9b

"terminal" and "popup" buffer types cannot be tested, and commenting
them out causes an error, so just remove them.
---
 src/nvim/testdir/test_autocmd.vim   | 51 ++++++++++++++++++++++++-------------
 src/nvim/testdir/test_bufline.vim   | 20 +++++++++++++++
 src/nvim/testdir/test_functions.vim | 28 ++++++++++----------
 3 files changed, 68 insertions(+), 31 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index 778e5f9b9f..a249c2bf50 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -493,16 +493,24 @@ func Test_BufReadCmdHelpJump()
   au! BufReadCmd
 endfunc
 
-" BufReadCmd is triggered for a "nofile" buffer
+" BufReadCmd is triggered for a "nofile" buffer. Check all values.
 func Test_BufReadCmdNofile()
-  new somefile
-  set buftype=nofile
-  au BufReadCmd somefile call setline(1, 'triggered')
-  edit
-  call assert_equal('triggered', getline(1))
-
-  au! BufReadCmd
-  bwipe!
+  for val in ['nofile',
+            \ 'nowrite',
+            \ 'acwrite',
+            \ 'quickfix',
+            \ 'help',
+            \ 'prompt',
+            \ ]
+    new somefile
+    exe 'set buftype=' .. val
+    au BufReadCmd somefile call setline(1, 'triggered')
+    edit
+    call assert_equal('triggered', getline(1))
+
+    au! BufReadCmd
+    bwipe!
+  endfor
 endfunc
 
 func Test_augroup_deleted()
@@ -603,15 +611,22 @@ func Test_BufEnter()
   au! BufEnter
 
   " Editing a "nofile" buffer doesn't read the file but does trigger BufEnter
-  " for historic reasons.
-  new somefile
-  set buftype=nofile
-  au BufEnter somefile call setline(1, 'some text')
-  edit
-  call assert_equal('some text', getline(1))
-
-  bwipe!
-  au! BufEnter
+  " for historic reasons.  Also test other 'buftype' values.
+  for val in ['nofile',
+            \ 'nowrite',
+            \ 'acwrite',
+            \ 'quickfix',
+            \ 'help',
+            \ 'prompt',
+            \ ]
+    new somefile
+    exe 'set buftype=' .. val
+    au BufEnter somefile call setline(1, 'some text')
+    edit
+    call assert_equal('some text', getline(1))
+    bwipe!
+    au! BufEnter
+  endfor
 endfunc
 
 " Closing a window might cause an endless loop
diff --git a/src/nvim/testdir/test_bufline.vim b/src/nvim/testdir/test_bufline.vim
index 939147b83b..3b5bcbce89 100644
--- a/src/nvim/testdir/test_bufline.vim
+++ b/src/nvim/testdir/test_bufline.vim
@@ -187,4 +187,24 @@ func Test_deletebufline_select_mode()
   bwipe!
 endfunc
 
+func Test_setbufline_startup_nofile()
+  let before =<< trim [CODE]
+    set shortmess+=F
+    file Xresult
+    set buftype=nofile
+    call setbufline('', 1, 'success')
+  [CODE]
+  let after =<< trim [CODE]
+    set buftype=
+    write
+    quit
+  [CODE]
+
+  if !RunVim(before, after, '--clean')
+    return
+  endif
+  call assert_equal(['success'], readfile('Xresult'))
+  call delete('Xresult')
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index 555c4f58b7..147eda5b0a 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -1880,19 +1880,21 @@ func Test_bufadd_bufload()
   exe 'bwipe ' .. buf2
   call assert_equal(0, bufexists(buf2))
 
-  " when 'buftype' is "nofile" then bufload() does not read the file
-  bwipe! XotherName
-  let buf = bufadd('XotherName')
-  call setbufvar(buf, '&bt', 'nofile')
-  call bufload(buf)
-  call assert_equal([''], getbufline(buf, 1, '$'))
-
-  " when 'buftype' is "acwrite" then bufload() DOES read the file
-  bwipe! XotherName
-  let buf = bufadd('XotherName')
-  call setbufvar(buf, '&bt', 'acwrite')
-  call bufload(buf)
-  call assert_equal(['some', 'text'], getbufline(buf, 1, '$'))
+  " When 'buftype' is "nofile" then bufload() does not read the file.
+  " Other values too.
+  for val in [['nofile', 0],
+            \ ['nowrite', 1],
+            \ ['acwrite', 1],
+            \ ['quickfix', 0],
+            \ ['help', 1],
+            \ ['prompt', 0],
+            \ ]
+    bwipe! XotherName
+    let buf = bufadd('XotherName')
+    call setbufvar(buf, '&bt', val[0])
+    call bufload(buf)
+    call assert_equal(val[1] ? ['some', 'text'] : [''], getbufline(buf, 1, '$'), val[0])
+  endfor
 
   bwipe someName
   bwipe XotherName
-- 
cgit 


From e70ef80f7741905580d228927ca4f694e38777fe Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 06:34:40 +0800
Subject: vim-patch:9.0.0278: the +wildignore feature is nearly always
 available

Problem:    The +wildignore feature is nearly always available.
Solution:   Graduate +wildignore for consistency.
https://github.com/vim/vim/commit/074fbd413172edc6f4936296a28bf8fd5cdfa38b
---
 src/nvim/fileio.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 0b66878103..39b4eb4376 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -337,7 +337,9 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     curbuf->b_op_start = orig_start;
 
     if (flags & READ_NOFILE) {
-      return NOTDONE;  // so that BufEnter can be triggered
+      // Return NOTDONE instead of FAIL so that BufEnter can be triggered
+      // and other operations don't fail.
+      return NOTDONE;
     }
   }
 
-- 
cgit 


From cc2c8be481d3bb81ba8881097aa153bcbf64fa23 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 06:36:26 +0800
Subject: vim-patch:9.0.0279: the tiny version has the popup menu but not
 'wildmenu'

Problem:    The tiny version has the popup menu but not 'wildmenu'.
Solution:   Graduate the wildmenu feature.
https://github.com/vim/vim/commit/5416232707349d5f24294178f47544f2024b73ed

N/A patches for version.c:

vim-patch:9.0.0281: build failure without the +eval feature

Problem:    Build failure without the +eval feature.
Solution:   Add #ifdef.
https://github.com/vim/vim/commit/58dcbf1c6586d3873702e035b47829178a91250e
---
 src/nvim/ex_getln.c | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index d73a57ad75..081aa80778 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1808,6 +1808,7 @@ static int command_line_handle_key(CommandLineState *s)
       // menu (if present)
       cmdline_pum_cleanup(&ccline);
     }
+
     if (nextwild(&s->xpc, WILD_ALL, 0, s->firstc != '@') == FAIL) {
       break;
     }
-- 
cgit 


From 2676555b229feae462df32bf6dfce7f234b7be53 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 06:44:13 +0800
Subject: vim-patch:9.0.0283: cannot complete "syn list @cluster"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem:    Cannot complete "syn list @cluster".
Solution:   Recognize and handle "list @". (Björn Linse, closes vim/vim#10990)
https://github.com/vim/vim/commit/af9a6002e0761012cb7108cbfa179a880d3cb49b
---
 src/nvim/syntax.c                | 24 +++++++++++++++++++++---
 src/nvim/testdir/test_syntax.vim |  4 ++++
 2 files changed, 25 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index fe37a79a5b..de8d5ef638 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -5664,7 +5664,8 @@ static enum {
   EXP_SUBCMD,       // expand ":syn" sub-commands
   EXP_CASE,         // expand ":syn case" arguments
   EXP_SPELL,        // expand ":syn spell" arguments
-  EXP_SYNC,  // expand ":syn sync" arguments
+  EXP_SYNC,         // expand ":syn sync" arguments
+  EXP_CLUSTER,      // expand ":syn list @cluster" arguments
 } expand_what;
 
 /*
@@ -5712,10 +5713,16 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
         expand_what = EXP_SPELL;
       } else if (STRNICMP(arg, "sync", p - arg) == 0) {
         expand_what = EXP_SYNC;
+      } else if (STRNICMP(arg, "list", p - arg) == 0) {
+        p = skipwhite(p);
+        if (*p == '@') {
+          expand_what = EXP_CLUSTER;
+        } else {
+          xp->xp_context = EXPAND_HIGHLIGHT;
+        }
       } else if (STRNICMP(arg, "keyword", p - arg) == 0
                  || STRNICMP(arg, "region", p - arg) == 0
-                 || STRNICMP(arg, "match", p - arg) == 0
-                 || STRNICMP(arg, "list", p - arg) == 0) {
+                 || STRNICMP(arg, "match", p - arg) == 0) {
         xp->xp_context = EXPAND_HIGHLIGHT;
       } else {
         xp->xp_context = EXPAND_NOTHING;
@@ -5730,6 +5737,9 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
  */
 char *get_syntax_name(expand_T *xp, int idx)
 {
+#define CBUFFER_LEN 256
+  static char cbuffer[CBUFFER_LEN]; // TODO: better solution
+
   switch (expand_what) {
   case EXP_SUBCMD:
     return subcommands[idx].name;
@@ -5749,6 +5759,14 @@ char *get_syntax_name(expand_T *xp, int idx)
       "maxlines=", "minlines=", "region", NULL };
     return sync_args[idx];
   }
+  case EXP_CLUSTER:
+    if (idx < curwin->w_s->b_syn_clusters.ga_len) {
+      vim_snprintf(cbuffer, CBUFFER_LEN, "@%s",
+                   SYN_CLSTR(curwin->w_s)[idx].scl_name);
+      return cbuffer;
+    } else {
+      return NULL;
+    }
   }
   return NULL;
 }
diff --git a/src/nvim/testdir/test_syntax.vim b/src/nvim/testdir/test_syntax.vim
index 85f27dd043..ccff01486e 100644
--- a/src/nvim/testdir/test_syntax.vim
+++ b/src/nvim/testdir/test_syntax.vim
@@ -198,6 +198,10 @@ func Test_syntax_completion()
 
   call feedkeys(":syn match \<C-A>\<C-B>\"\<CR>", 'tx')
   call assert_match('^"syn match @boolean @character ', @:)
+
+  syn cluster Aax contains=Aap
+  call feedkeys(":syn list @A\<C-A>\<C-B>\"\<CR>", 'tx')
+  call assert_match('^"syn list @Aax', @:)
 endfunc
 
 func Test_echohl_completion()
-- 
cgit 


From 608134794d2a039358825396b860a7f432c1a4bd Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 06:50:55 +0800
Subject: vim-patch:9.0.0284: using static buffer for multiple completion
 functions

Problem:    Using static buffer for multiple completion functions.
Solution:   Use one buffer in expand_T.
https://github.com/vim/vim/commit/5ff595d9db2d9a33aa10cc9f18f256826226862f
---
 src/nvim/cmdhist.c      | 12 ++++++------
 src/nvim/ex_cmds_defs.h |  2 ++
 src/nvim/os/env.c       |  7 ++-----
 src/nvim/syntax.c       |  7 ++-----
 4 files changed, 12 insertions(+), 16 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index b078fc6570..1426054d0b 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -90,14 +90,14 @@ static char *(history_names[]) = {
 /// arguments of the ":history command.
 char *get_history_arg(expand_T *xp, int idx)
 {
-  static char_u compl[2] = { NUL, NUL };
-  char *short_names = ":=@>?/";
-  int short_names_count = (int)STRLEN(short_names);
-  int history_name_count = ARRAY_SIZE(history_names) - 1;
+  const char *short_names = ":=@>?/";
+  const int short_names_count = (int)STRLEN(short_names);
+  const int history_name_count = ARRAY_SIZE(history_names) - 1;
 
   if (idx < short_names_count) {
-    compl[0] = (char_u)short_names[idx];
-    return (char *)compl;
+    xp->xp_buf[0] = short_names[idx];
+    xp->xp_buf[1] = NUL;
+    return xp->xp_buf;
   }
   if (idx < short_names_count + history_name_count) {
     return history_names[idx - short_names_count];
diff --git a/src/nvim/ex_cmds_defs.h b/src/nvim/ex_cmds_defs.h
index 5d8ed64c60..71956b2246 100644
--- a/src/nvim/ex_cmds_defs.h
+++ b/src/nvim/ex_cmds_defs.h
@@ -237,6 +237,8 @@ struct expand {
   int xp_col;                   // cursor position in line
   char **xp_files;              // list of files
   char *xp_line;                // text being completed
+#define EXPAND_BUF_LEN 256
+  char xp_buf[EXPAND_BUF_LEN];  // buffer for returned match
 };
 
 // values for xp_backslash
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index d46d51882e..ea9a803a86 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -1156,15 +1156,12 @@ char *home_replace_save(buf_T *buf, const char *src)
 /// Function given to ExpandGeneric() to obtain an environment variable name.
 char *get_env_name(expand_T *xp, int idx)
 {
-#define ENVNAMELEN 100
-  // this static buffer is needed to avoid a memory leak in ExpandGeneric
-  static char_u name[ENVNAMELEN];
   assert(idx >= 0);
   char *envname = os_getenvname_at_index((size_t)idx);
   if (envname) {
-    STRLCPY(name, envname, ENVNAMELEN);
+    STRLCPY(xp->xp_buf, envname, EXPAND_BUF_LEN);
     xfree(envname);
-    return (char *)name;
+    return xp->xp_buf;
   }
   return NULL;
 }
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index de8d5ef638..20287089f7 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -5737,9 +5737,6 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
  */
 char *get_syntax_name(expand_T *xp, int idx)
 {
-#define CBUFFER_LEN 256
-  static char cbuffer[CBUFFER_LEN]; // TODO: better solution
-
   switch (expand_what) {
   case EXP_SUBCMD:
     return subcommands[idx].name;
@@ -5761,9 +5758,9 @@ char *get_syntax_name(expand_T *xp, int idx)
   }
   case EXP_CLUSTER:
     if (idx < curwin->w_s->b_syn_clusters.ga_len) {
-      vim_snprintf(cbuffer, CBUFFER_LEN, "@%s",
+      vim_snprintf(xp->xp_buf, EXPAND_BUF_LEN, "@%s",
                    SYN_CLSTR(curwin->w_s)[idx].scl_name);
-      return cbuffer;
+      return xp->xp_buf;
     } else {
       return NULL;
     }
-- 
cgit 


From 814c173b9d5182ca221b7c3c370cb453ce3526ed Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 09:58:25 +0800
Subject: vim-patch:8.2.0660: the search.c file is a bit big (#19963)

Problem:    The search.c file is a bit big.
Solution:   Split off the text object code to a separate file. (Yegappan
            Lakshmanan, closes vim/vim#6007)
https://github.com/vim/vim/commit/ed8ce057b7a2fcd89b5f55680ae8f85d62a992a5
---
 src/nvim/edit.c       |    1 +
 src/nvim/mark.c       |    2 +-
 src/nvim/normal.c     |    1 +
 src/nvim/search.c     | 1802 -------------------------------------------------
 src/nvim/textformat.c |    5 +
 src/nvim/textformat.h |    2 -
 src/nvim/textobject.c | 1742 +++++++++++++++++++++++++++++++++++++++++++++++
 src/nvim/textobject.h |   11 +
 8 files changed, 1761 insertions(+), 1805 deletions(-)
 create mode 100644 src/nvim/textobject.c
 create mode 100644 src/nvim/textobject.h

(limited to 'src')

diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 55f4d77feb..ed625e1d6e 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -57,6 +57,7 @@
 #include "nvim/syntax.h"
 #include "nvim/terminal.h"
 #include "nvim/textformat.h"
+#include "nvim/textobject.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index a15a27650b..c4b30ae600 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -33,9 +33,9 @@
 #include "nvim/os/time.h"
 #include "nvim/path.h"
 #include "nvim/quickfix.h"
-#include "nvim/search.h"
 #include "nvim/sign.h"
 #include "nvim/strings.h"
+#include "nvim/textobject.h"
 #include "nvim/ui.h"
 #include "nvim/vim.h"
 
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 93ee49b0a4..31646f686d 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -66,6 +66,7 @@
 #include "nvim/syntax.h"
 #include "nvim/tag.h"
 #include "nvim/textformat.h"
+#include "nvim/textobject.h"
 #include "nvim/ui.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 190ad72a8f..892d531633 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -2444,1808 +2444,6 @@ void showmatch(int c)
   }
 }
 
-// Find the start of the next sentence, searching in the direction specified
-// by the "dir" argument.  The cursor is positioned on the start of the next
-// sentence when found.  If the next sentence is found, return OK.  Return FAIL
-// otherwise.  See ":h sentence" for the precise definition of a "sentence"
-// text object.
-int findsent(Direction dir, long count)
-{
-  pos_T pos, tpos;
-  int c;
-  int (*func)(pos_T *);
-  bool noskip = false;              // do not skip blanks
-
-  pos = curwin->w_cursor;
-  if (dir == FORWARD) {
-    func = incl;
-  } else {
-    func = decl;
-  }
-
-  while (count--) {
-    const pos_T prev_pos = pos;
-
-    // if on an empty line, skip up to a non-empty line
-    if (gchar_pos(&pos) == NUL) {
-      do {
-        if ((*func)(&pos) == -1) {
-          break;
-        }
-      } while (gchar_pos(&pos) == NUL);
-      if (dir == FORWARD) {
-        goto found;
-      }
-      // if on the start of a paragraph or a section and searching forward,
-      // go to the next line
-    } else if (dir == FORWARD && pos.col == 0
-               && startPS(pos.lnum, NUL, false)) {
-      if (pos.lnum == curbuf->b_ml.ml_line_count) {
-        return FAIL;
-      }
-      pos.lnum++;
-      goto found;
-    } else if (dir == BACKWARD) {
-      decl(&pos);
-    }
-
-    // go back to the previous non-white non-punctuation character
-    bool found_dot = false;
-    while (c = gchar_pos(&pos), ascii_iswhite(c)
-           || vim_strchr(".!?)]\"'", c) != NULL) {
-      tpos = pos;
-      if (decl(&tpos) == -1 || (LINEEMPTY(tpos.lnum) && dir == FORWARD)) {
-        break;
-      }
-      if (found_dot) {
-        break;
-      }
-      if (vim_strchr(".!?", c) != NULL) {
-        found_dot = true;
-      }
-      if (vim_strchr(")]\"'", c) != NULL
-          && vim_strchr(".!?)]\"'", gchar_pos(&tpos)) == NULL) {
-        break;
-      }
-      decl(&pos);
-    }
-
-    // remember the line where the search started
-    const int startlnum = pos.lnum;
-    const bool cpo_J = vim_strchr(p_cpo, CPO_ENDOFSENT) != NULL;
-
-    for (;;) {                 // find end of sentence
-      c = gchar_pos(&pos);
-      if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, false))) {
-        if (dir == BACKWARD && pos.lnum != startlnum) {
-          pos.lnum++;
-        }
-        break;
-      }
-      if (c == '.' || c == '!' || c == '?') {
-        tpos = pos;
-        do {
-          if ((c = inc(&tpos)) == -1) {
-            break;
-          }
-        } while (vim_strchr(")]\"'", c = gchar_pos(&tpos))
-                 != NULL);
-        if (c == -1 || (!cpo_J && (c == ' ' || c == '\t')) || c == NUL
-            || (cpo_J && (c == ' ' && inc(&tpos) >= 0
-                          && gchar_pos(&tpos) == ' '))) {
-          pos = tpos;
-          if (gchar_pos(&pos) == NUL) {         // skip NUL at EOL
-            inc(&pos);
-          }
-          break;
-        }
-      }
-      if ((*func)(&pos) == -1) {
-        if (count) {
-          return FAIL;
-        }
-        noskip = true;
-        break;
-      }
-    }
-found:
-    // skip white space
-    while (!noskip && ((c = gchar_pos(&pos)) == ' ' || c == '\t')) {
-      if (incl(&pos) == -1) {
-        break;
-      }
-    }
-
-    if (equalpos(prev_pos, pos)) {
-      // didn't actually move, advance one character and try again
-      if ((*func)(&pos) == -1) {
-        if (count) {
-          return FAIL;
-        }
-        break;
-      }
-      count++;
-    }
-  }
-
-  setpcmark();
-  curwin->w_cursor = pos;
-  return OK;
-}
-
-/// Find the next paragraph or section in direction 'dir'.
-/// Paragraphs are currently supposed to be separated by empty lines.
-/// If 'what' is NUL we go to the next paragraph.
-/// If 'what' is '{' or '}' we go to the next section.
-/// If 'both' is true also stop at '}'.
-///
-/// @param pincl  Return: true if last char is to be included
-///
-/// @return       true if the next paragraph or section was found.
-bool findpar(bool *pincl, int dir, long count, int what, int both)
-{
-  linenr_T curr;
-  bool did_skip;            // true after separating lines have been skipped
-  bool first;               // true on first line
-  linenr_T fold_first;      // first line of a closed fold
-  linenr_T fold_last;       // last line of a closed fold
-  bool fold_skipped;        // true if a closed fold was skipped this
-                            // iteration
-
-  curr = curwin->w_cursor.lnum;
-
-  while (count--) {
-    did_skip = false;
-    for (first = true;; first = false) {
-      if (*ml_get(curr) != NUL) {
-        did_skip = true;
-      }
-
-      // skip folded lines
-      fold_skipped = false;
-      if (first && hasFolding(curr, &fold_first, &fold_last)) {
-        curr = ((dir > 0) ? fold_last : fold_first) + dir;
-        fold_skipped = true;
-      }
-
-      if (!first && did_skip && startPS(curr, what, both)) {
-        break;
-      }
-
-      if (fold_skipped) {
-        curr -= dir;
-      }
-      if ((curr += dir) < 1 || curr > curbuf->b_ml.ml_line_count) {
-        if (count) {
-          return false;
-        }
-        curr -= dir;
-        break;
-      }
-    }
-  }
-  setpcmark();
-  if (both && *ml_get(curr) == '}') {   // include line with '}'
-    curr++;
-  }
-  curwin->w_cursor.lnum = curr;
-  if (curr == curbuf->b_ml.ml_line_count && what != '}') {
-    char_u *line = ml_get(curr);
-
-    // Put the cursor on the last character in the last line and make the
-    // motion inclusive.
-    if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0) {
-      curwin->w_cursor.col--;
-      curwin->w_cursor.col -= utf_head_off(line, line + curwin->w_cursor.col);
-      *pincl = true;
-    }
-  } else {
-    curwin->w_cursor.col = 0;
-  }
-  return true;
-}
-
-/*
- * check if the string 's' is a nroff macro that is in option 'opt'
- */
-static int inmacro(char_u *opt, char_u *s)
-{
-  char_u *macro;
-
-  for (macro = opt; macro[0]; macro++) {
-    // Accept two characters in the option being equal to two characters
-    // in the line.  A space in the option matches with a space in the
-    // line or the line having ended.
-    if ((macro[0] == s[0]
-         || (macro[0] == ' '
-             && (s[0] == NUL || s[0] == ' ')))
-        && (macro[1] == s[1]
-            || ((macro[1] == NUL || macro[1] == ' ')
-                && (s[0] == NUL || s[1] == NUL || s[1] == ' ')))) {
-      break;
-    }
-    macro++;
-    if (macro[0] == NUL) {
-      break;
-    }
-  }
-  return macro[0] != NUL;
-}
-
-/// startPS: return true if line 'lnum' is the start of a section or paragraph.
-/// If 'para' is '{' or '}' only check for sections.
-/// If 'both' is true also stop at '}'
-int startPS(linenr_T lnum, int para, int both)
-{
-  char_u *s;
-
-  s = ml_get(lnum);
-  if (*s == para || *s == '\f' || (both && *s == '}')) {
-    return true;
-  }
-  if (*s == '.' && (inmacro((char_u *)p_sections, s + 1)
-                    || (!para && inmacro(p_para, s + 1)))) {
-    return true;
-  }
-  return false;
-}
-
-/*
- * The following routines do the word searches performed by the 'w', 'W',
- * 'b', 'B', 'e', and 'E' commands.
- */
-
-/*
- * To perform these searches, characters are placed into one of three
- * classes, and transitions between classes determine word boundaries.
- *
- * The classes are:
- *
- * 0 - white space
- * 1 - punctuation
- * 2 or higher - keyword characters (letters, digits and underscore)
- */
-
-static int cls_bigword;         // true for "W", "B" or "E"
-
-/*
- * cls() - returns the class of character at curwin->w_cursor
- *
- * If a 'W', 'B', or 'E' motion is being done (cls_bigword == true), chars
- * from class 2 and higher are reported as class 1 since only white space
- * boundaries are of interest.
- */
-static int cls(void)
-{
-  int c;
-
-  c = gchar_cursor();
-  if (c == ' ' || c == '\t' || c == NUL) {
-    return 0;
-  }
-
-  c = utf_class(c);
-
-  // If cls_bigword is true, report all non-blanks as class 1.
-  if (c != 0 && cls_bigword) {
-    return 1;
-  }
-  return c;
-}
-
-/// fwd_word(count, type, eol) - move forward one word
-///
-/// @return  FAIL if the cursor was already at the end of the file.
-/// If eol is true, last word stops at end of line (for operators).
-///
-/// @param bigword  "W", "E" or "B"
-int fwd_word(long count, int bigword, int eol)
-{
-  int sclass;               // starting class
-  int i;
-  int last_line;
-
-  curwin->w_cursor.coladd = 0;
-  cls_bigword = bigword;
-  while (--count >= 0) {
-    // When inside a range of folded lines, move to the last char of the
-    // last line.
-    if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) {
-      coladvance(MAXCOL);
-    }
-    sclass = cls();
-
-    /*
-     * We always move at least one character, unless on the last
-     * character in the buffer.
-     */
-    last_line = (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count);
-    i = inc_cursor();
-    if (i == -1 || (i >= 1 && last_line)) {   // started at last char in file
-      return FAIL;
-    }
-    if (i >= 1 && eol && count == 0) {        // started at last char in line
-      return OK;
-    }
-
-    /*
-     * Go one char past end of current word (if any)
-     */
-    if (sclass != 0) {
-      while (cls() == sclass) {
-        i = inc_cursor();
-        if (i == -1 || (i >= 1 && eol && count == 0)) {
-          return OK;
-        }
-      }
-    }
-
-    /*
-     * go to next non-white
-     */
-    while (cls() == 0) {
-      /*
-       * We'll stop if we land on a blank line
-       */
-      if (curwin->w_cursor.col == 0 && *get_cursor_line_ptr() == NUL) {
-        break;
-      }
-
-      i = inc_cursor();
-      if (i == -1 || (i >= 1 && eol && count == 0)) {
-        return OK;
-      }
-    }
-  }
-  return OK;
-}
-
-/*
- * bck_word() - move backward 'count' words
- *
- * If stop is true and we are already on the start of a word, move one less.
- *
- * Returns FAIL if top of the file was reached.
- */
-int bck_word(long count, int bigword, int stop)
-{
-  int sclass;               // starting class
-
-  curwin->w_cursor.coladd = 0;
-  cls_bigword = bigword;
-  while (--count >= 0) {
-    /* When inside a range of folded lines, move to the first char of the
-     * first line. */
-    if (hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum, NULL)) {
-      curwin->w_cursor.col = 0;
-    }
-    sclass = cls();
-    if (dec_cursor() == -1) {           // started at start of file
-      return FAIL;
-    }
-
-    if (!stop || sclass == cls() || sclass == 0) {
-      /*
-       * Skip white space before the word.
-       * Stop on an empty line.
-       */
-      while (cls() == 0) {
-        if (curwin->w_cursor.col == 0
-            && LINEEMPTY(curwin->w_cursor.lnum)) {
-          goto finished;
-        }
-        if (dec_cursor() == -1) {       // hit start of file, stop here
-          return OK;
-        }
-      }
-
-      /*
-       * Move backward to start of this word.
-       */
-      if (skip_chars(cls(), BACKWARD)) {
-        return OK;
-      }
-    }
-
-    inc_cursor();                       // overshot - forward one
-finished:
-    stop = false;
-  }
-  return OK;
-}
-
-/*
- * end_word() - move to the end of the word
- *
- * There is an apparent bug in the 'e' motion of the real vi. At least on the
- * System V Release 3 version for the 80386. Unlike 'b' and 'w', the 'e'
- * motion crosses blank lines. When the real vi crosses a blank line in an
- * 'e' motion, the cursor is placed on the FIRST character of the next
- * non-blank line. The 'E' command, however, works correctly. Since this
- * appears to be a bug, I have not duplicated it here.
- *
- * Returns FAIL if end of the file was reached.
- *
- * If stop is true and we are already on the end of a word, move one less.
- * If empty is true stop on an empty line.
- */
-int end_word(long count, int bigword, int stop, int empty)
-{
-  int sclass;               // starting class
-
-  curwin->w_cursor.coladd = 0;
-  cls_bigword = bigword;
-  while (--count >= 0) {
-    /* When inside a range of folded lines, move to the last char of the
-     * last line. */
-    if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) {
-      coladvance(MAXCOL);
-    }
-    sclass = cls();
-    if (inc_cursor() == -1) {
-      return FAIL;
-    }
-
-    /*
-     * If we're in the middle of a word, we just have to move to the end
-     * of it.
-     */
-    if (cls() == sclass && sclass != 0) {
-      /*
-       * Move forward to end of the current word
-       */
-      if (skip_chars(sclass, FORWARD)) {
-        return FAIL;
-      }
-    } else if (!stop || sclass == 0) {
-      /*
-       * We were at the end of a word. Go to the end of the next word.
-       * First skip white space, if 'empty' is true, stop at empty line.
-       */
-      while (cls() == 0) {
-        if (empty && curwin->w_cursor.col == 0
-            && LINEEMPTY(curwin->w_cursor.lnum)) {
-          goto finished;
-        }
-        if (inc_cursor() == -1) {           // hit end of file, stop here
-          return FAIL;
-        }
-      }
-
-      /*
-       * Move forward to the end of this word.
-       */
-      if (skip_chars(cls(), FORWARD)) {
-        return FAIL;
-      }
-    }
-    dec_cursor();                       // overshot - one char backward
-finished:
-    stop = false;                       // we move only one word less
-  }
-  return OK;
-}
-
-/// Move back to the end of the word.
-///
-/// @param bigword  true for "B"
-/// @param eol      if true, then stop at end of line.
-///
-/// @return         FAIL if start of the file was reached.
-int bckend_word(long count, int bigword, bool eol)
-{
-  int sclass;               // starting class
-  int i;
-
-  curwin->w_cursor.coladd = 0;
-  cls_bigword = bigword;
-  while (--count >= 0) {
-    sclass = cls();
-    if ((i = dec_cursor()) == -1) {
-      return FAIL;
-    }
-    if (eol && i == 1) {
-      return OK;
-    }
-
-    /*
-     * Move backward to before the start of this word.
-     */
-    if (sclass != 0) {
-      while (cls() == sclass) {
-        if ((i = dec_cursor()) == -1 || (eol && i == 1)) {
-          return OK;
-        }
-      }
-    }
-
-    /*
-     * Move backward to end of the previous word
-     */
-    while (cls() == 0) {
-      if (curwin->w_cursor.col == 0 && LINEEMPTY(curwin->w_cursor.lnum)) {
-        break;
-      }
-      if ((i = dec_cursor()) == -1 || (eol && i == 1)) {
-        return OK;
-      }
-    }
-  }
-  return OK;
-}
-
-/// Skip a row of characters of the same class.
-///
-/// @return  true when end-of-file reached, false otherwise.
-static bool skip_chars(int cclass, int dir)
-{
-  while (cls() == cclass) {
-    if ((dir == FORWARD ? inc_cursor() : dec_cursor()) == -1) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/*
- * Go back to the start of the word or the start of white space
- */
-static void back_in_line(void)
-{
-  int sclass;                       // starting class
-
-  sclass = cls();
-  for (;;) {
-    if (curwin->w_cursor.col == 0) {        // stop at start of line
-      break;
-    }
-    dec_cursor();
-    if (cls() != sclass) {                  // stop at start of word
-      inc_cursor();
-      break;
-    }
-  }
-}
-
-static void find_first_blank(pos_T *posp)
-{
-  int c;
-
-  while (decl(posp) != -1) {
-    c = gchar_pos(posp);
-    if (!ascii_iswhite(c)) {
-      incl(posp);
-      break;
-    }
-  }
-}
-
-/// Skip count/2 sentences and count/2 separating white spaces.
-///
-/// @param at_start_sent  cursor is at start of sentence
-static void findsent_forward(long count, bool at_start_sent)
-{
-  while (count--) {
-    findsent(FORWARD, 1L);
-    if (at_start_sent) {
-      find_first_blank(&curwin->w_cursor);
-    }
-    if (count == 0 || at_start_sent) {
-      decl(&curwin->w_cursor);
-    }
-    at_start_sent = !at_start_sent;
-  }
-}
-
-/// Find word under cursor, cursor at end.
-/// Used while an operator is pending, and in Visual mode.
-///
-/// @param include  true: include word and white space
-/// @param bigword  false == word, true == WORD
-int current_word(oparg_T *oap, long count, int include, int bigword)
-{
-  pos_T start_pos;
-  pos_T pos;
-  bool inclusive = true;
-  int include_white = false;
-
-  cls_bigword = bigword;
-  clearpos(&start_pos);
-
-  // Correct cursor when 'selection' is exclusive
-  if (VIsual_active && *p_sel == 'e' && lt(VIsual, curwin->w_cursor)) {
-    dec_cursor();
-  }
-
-  /*
-   * When Visual mode is not active, or when the VIsual area is only one
-   * character, select the word and/or white space under the cursor.
-   */
-  if (!VIsual_active || equalpos(curwin->w_cursor, VIsual)) {
-    /*
-     * Go to start of current word or white space.
-     */
-    back_in_line();
-    start_pos = curwin->w_cursor;
-
-    /*
-     * If the start is on white space, and white space should be included
-     * (" word"), or start is not on white space, and white space should
-     * not be included ("word"), find end of word.
-     */
-    if ((cls() == 0) == include) {
-      if (end_word(1L, bigword, true, true) == FAIL) {
-        return FAIL;
-      }
-    } else {
-      /*
-       * If the start is not on white space, and white space should be
-       * included ("word   "), or start is on white space and white
-       * space should not be included ("   "), find start of word.
-       * If we end up in the first column of the next line (single char
-       * word) back up to end of the line.
-       */
-      fwd_word(1L, bigword, true);
-      if (curwin->w_cursor.col == 0) {
-        decl(&curwin->w_cursor);
-      } else {
-        oneleft();
-      }
-
-      if (include) {
-        include_white = true;
-      }
-    }
-
-    if (VIsual_active) {
-      // should do something when inclusive == false !
-      VIsual = start_pos;
-      redraw_curbuf_later(UPD_INVERTED);  // update the inversion
-    } else {
-      oap->start = start_pos;
-      oap->motion_type = kMTCharWise;
-    }
-    count--;
-  }
-
-  /*
-   * When count is still > 0, extend with more objects.
-   */
-  while (count > 0) {
-    inclusive = true;
-    if (VIsual_active && lt(curwin->w_cursor, VIsual)) {
-      /*
-       * In Visual mode, with cursor at start: move cursor back.
-       */
-      if (decl(&curwin->w_cursor) == -1) {
-        return FAIL;
-      }
-      if (include != (cls() != 0)) {
-        if (bck_word(1L, bigword, true) == FAIL) {
-          return FAIL;
-        }
-      } else {
-        if (bckend_word(1L, bigword, true) == FAIL) {
-          return FAIL;
-        }
-        (void)incl(&curwin->w_cursor);
-      }
-    } else {
-      /*
-       * Move cursor forward one word and/or white area.
-       */
-      if (incl(&curwin->w_cursor) == -1) {
-        return FAIL;
-      }
-      if (include != (cls() == 0)) {
-        if (fwd_word(1L, bigword, true) == FAIL && count > 1) {
-          return FAIL;
-        }
-        /*
-         * If end is just past a new-line, we don't want to include
-         * the first character on the line.
-         * Put cursor on last char of white.
-         */
-        if (oneleft() == FAIL) {
-          inclusive = false;
-        }
-      } else {
-        if (end_word(1L, bigword, true, true) == FAIL) {
-          return FAIL;
-        }
-      }
-    }
-    count--;
-  }
-
-  if (include_white && (cls() != 0
-                        || (curwin->w_cursor.col == 0 && !inclusive))) {
-    /*
-     * If we don't include white space at the end, move the start
-     * to include some white space there. This makes "daw" work
-     * better on the last word in a sentence (and "2daw" on last-but-one
-     * word).  Also when "2daw" deletes "word." at the end of the line
-     * (cursor is at start of next line).
-     * But don't delete white space at start of line (indent).
-     */
-    pos = curwin->w_cursor;     // save cursor position
-    curwin->w_cursor = start_pos;
-    if (oneleft() == OK) {
-      back_in_line();
-      if (cls() == 0 && curwin->w_cursor.col > 0) {
-        if (VIsual_active) {
-          VIsual = curwin->w_cursor;
-        } else {
-          oap->start = curwin->w_cursor;
-        }
-      }
-    }
-    curwin->w_cursor = pos;     // put cursor back at end
-  }
-
-  if (VIsual_active) {
-    if (*p_sel == 'e' && inclusive && ltoreq(VIsual, curwin->w_cursor)) {
-      inc_cursor();
-    }
-    if (VIsual_mode == 'V') {
-      VIsual_mode = 'v';
-      redraw_cmdline = true;                    // show mode later
-    }
-  } else {
-    oap->inclusive = inclusive;
-  }
-
-  return OK;
-}
-
-/*
- * Find sentence(s) under the cursor, cursor at end.
- * When Visual active, extend it by one or more sentences.
- */
-int current_sent(oparg_T *oap, long count, int include)
-{
-  pos_T start_pos;
-  pos_T pos;
-  bool start_blank;
-  int c;
-  bool at_start_sent;
-  long ncount;
-
-  start_pos = curwin->w_cursor;
-  pos = start_pos;
-  findsent(FORWARD, 1L);        // Find start of next sentence.
-
-  /*
-   * When the Visual area is bigger than one character: Extend it.
-   */
-  if (VIsual_active && !equalpos(start_pos, VIsual)) {
-extend:
-    if (lt(start_pos, VIsual)) {
-      /*
-       * Cursor at start of Visual area.
-       * Find out where we are:
-       * - in the white space before a sentence
-       * - in a sentence or just after it
-       * - at the start of a sentence
-       */
-      at_start_sent = true;
-      decl(&pos);
-      while (lt(pos, curwin->w_cursor)) {
-        c = gchar_pos(&pos);
-        if (!ascii_iswhite(c)) {
-          at_start_sent = false;
-          break;
-        }
-        incl(&pos);
-      }
-      if (!at_start_sent) {
-        findsent(BACKWARD, 1L);
-        if (equalpos(curwin->w_cursor, start_pos)) {
-          at_start_sent = true;            // exactly at start of sentence
-        } else {
-          // inside a sentence, go to its end (start of next)
-          findsent(FORWARD, 1L);
-        }
-      }
-      if (include) {            // "as" gets twice as much as "is"
-        count *= 2;
-      }
-      while (count--) {
-        if (at_start_sent) {
-          find_first_blank(&curwin->w_cursor);
-        }
-        c = gchar_cursor();
-        if (!at_start_sent || (!include && !ascii_iswhite(c))) {
-          findsent(BACKWARD, 1L);
-        }
-        at_start_sent = !at_start_sent;
-      }
-    } else {
-      /*
-       * Cursor at end of Visual area.
-       * Find out where we are:
-       * - just before a sentence
-       * - just before or in the white space before a sentence
-       * - in a sentence
-       */
-      incl(&pos);
-      at_start_sent = true;
-      if (!equalpos(pos, curwin->w_cursor)) {     // not just before a sentence
-        at_start_sent = false;
-        while (lt(pos, curwin->w_cursor)) {
-          c = gchar_pos(&pos);
-          if (!ascii_iswhite(c)) {
-            at_start_sent = true;
-            break;
-          }
-          incl(&pos);
-        }
-        if (at_start_sent) {            // in the sentence
-          findsent(BACKWARD, 1L);
-        } else {  // in/before white before a sentence
-          curwin->w_cursor = start_pos;
-        }
-      }
-
-      if (include) {            // "as" gets twice as much as "is"
-        count *= 2;
-      }
-      findsent_forward(count, at_start_sent);
-      if (*p_sel == 'e') {
-        curwin->w_cursor.col++;
-      }
-    }
-    return OK;
-  }
-
-  /*
-   * If the cursor started on a blank, check if it is just before the start
-   * of the next sentence.
-   */
-  while (c = gchar_pos(&pos), ascii_iswhite(c)) {
-    incl(&pos);
-  }
-  if (equalpos(pos, curwin->w_cursor)) {
-    start_blank = true;
-    find_first_blank(&start_pos);       // go back to first blank
-  } else {
-    start_blank = false;
-    findsent(BACKWARD, 1L);
-    start_pos = curwin->w_cursor;
-  }
-  if (include) {
-    ncount = count * 2;
-  } else {
-    ncount = count;
-    if (start_blank) {
-      ncount--;
-    }
-  }
-  if (ncount > 0) {
-    findsent_forward(ncount, true);
-  } else {
-    decl(&curwin->w_cursor);
-  }
-
-  if (include) {
-    /*
-     * If the blank in front of the sentence is included, exclude the
-     * blanks at the end of the sentence, go back to the first blank.
-     * If there are no trailing blanks, try to include leading blanks.
-     */
-    if (start_blank) {
-      find_first_blank(&curwin->w_cursor);
-      c = gchar_pos(&curwin->w_cursor);
-      if (ascii_iswhite(c)) {
-        decl(&curwin->w_cursor);
-      }
-    } else if (c = gchar_cursor(), !ascii_iswhite(c)) {
-      find_first_blank(&start_pos);
-    }
-  }
-
-  if (VIsual_active) {
-    // Avoid getting stuck with "is" on a single space before a sentence.
-    if (equalpos(start_pos, curwin->w_cursor)) {
-      goto extend;
-    }
-    if (*p_sel == 'e') {
-      curwin->w_cursor.col++;
-    }
-    VIsual = start_pos;
-    VIsual_mode = 'v';
-    redraw_cmdline = true;    // show mode later
-    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
-  } else {
-    // include a newline after the sentence, if there is one
-    if (incl(&curwin->w_cursor) == -1) {
-      oap->inclusive = true;
-    } else {
-      oap->inclusive = false;
-    }
-    oap->start = start_pos;
-    oap->motion_type = kMTCharWise;
-  }
-  return OK;
-}
-
-/// Find block under the cursor, cursor at end.
-/// "what" and "other" are two matching parenthesis/brace/etc.
-///
-/// @param include  true == include white space
-/// @param what     '(', '{', etc.
-/// @param other    ')', '}', etc.
-int current_block(oparg_T *oap, long count, int include, int what, int other)
-{
-  pos_T old_pos;
-  pos_T *pos = NULL;
-  pos_T start_pos;
-  pos_T *end_pos;
-  pos_T old_start, old_end;
-  char *save_cpo;
-  bool sol = false;                      // '{' at start of line
-
-  old_pos = curwin->w_cursor;
-  old_end = curwin->w_cursor;           // remember where we started
-  old_start = old_end;
-
-  /*
-   * If we start on '(', '{', ')', '}', etc., use the whole block inclusive.
-   */
-  if (!VIsual_active || equalpos(VIsual, curwin->w_cursor)) {
-    setpcmark();
-    if (what == '{') {                  // ignore indent
-      while (inindent(1)) {
-        if (inc_cursor() != 0) {
-          break;
-        }
-      }
-    }
-    if (gchar_cursor() == what) {
-      // cursor on '(' or '{', move cursor just after it
-      curwin->w_cursor.col++;
-    }
-  } else if (lt(VIsual, curwin->w_cursor)) {
-    old_start = VIsual;
-    curwin->w_cursor = VIsual;              // cursor at low end of Visual
-  } else {
-    old_end = VIsual;
-  }
-
-  // Search backwards for unclosed '(', '{', etc..
-  // Put this position in start_pos.
-  // Ignore quotes here.  Keep the "M" flag in 'cpo', as that is what the
-  // user wants.
-  save_cpo = p_cpo;
-  p_cpo = vim_strchr(p_cpo, CPO_MATCHBSL) != NULL ? "%M" : "%";
-  if ((pos = findmatch(NULL, what)) != NULL) {
-    while (count-- > 0) {
-      if ((pos = findmatch(NULL, what)) == NULL) {
-        break;
-      }
-      curwin->w_cursor = *pos;
-      start_pos = *pos;   // the findmatch for end_pos will overwrite *pos
-    }
-  } else {
-    while (count-- > 0) {
-      if ((pos = findmatchlimit(NULL, what, FM_FORWARD, 0)) == NULL) {
-        break;
-      }
-      curwin->w_cursor = *pos;
-      start_pos = *pos;   // the findmatch for end_pos will overwrite *pos
-    }
-  }
-  p_cpo = save_cpo;
-
-  /*
-   * Search for matching ')', '}', etc.
-   * Put this position in curwin->w_cursor.
-   */
-  if (pos == NULL || (end_pos = findmatch(NULL, other)) == NULL) {
-    curwin->w_cursor = old_pos;
-    return FAIL;
-  }
-  curwin->w_cursor = *end_pos;
-
-  // Try to exclude the '(', '{', ')', '}', etc. when "include" is false.
-  // If the ending '}', ')' or ']' is only preceded by indent, skip that
-  // indent. But only if the resulting area is not smaller than what we
-  // started with.
-  while (!include) {
-    incl(&start_pos);
-    sol = (curwin->w_cursor.col == 0);
-    decl(&curwin->w_cursor);
-    while (inindent(1)) {
-      sol = true;
-      if (decl(&curwin->w_cursor) != 0) {
-        break;
-      }
-    }
-
-    // In Visual mode, when the resulting area is not bigger than what we
-    // started with, extend it to the next block, and then exclude again.
-    // Don't try to expand the area if the area is empty.
-    if (!lt(start_pos, old_start) && !lt(old_end, curwin->w_cursor)
-        && !equalpos(start_pos, curwin->w_cursor)
-        && VIsual_active) {
-      curwin->w_cursor = old_start;
-      decl(&curwin->w_cursor);
-      if ((pos = findmatch(NULL, what)) == NULL) {
-        curwin->w_cursor = old_pos;
-        return FAIL;
-      }
-      start_pos = *pos;
-      curwin->w_cursor = *pos;
-      if ((end_pos = findmatch(NULL, other)) == NULL) {
-        curwin->w_cursor = old_pos;
-        return FAIL;
-      }
-      curwin->w_cursor = *end_pos;
-    } else {
-      break;
-    }
-  }
-
-  if (VIsual_active) {
-    if (*p_sel == 'e') {
-      inc(&curwin->w_cursor);
-    }
-    if (sol && gchar_cursor() != NUL) {
-      inc(&curwin->w_cursor);  // include the line break
-    }
-    VIsual = start_pos;
-    VIsual_mode = 'v';
-    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
-    showmode();
-  } else {
-    oap->start = start_pos;
-    oap->motion_type = kMTCharWise;
-    oap->inclusive = false;
-    if (sol) {
-      incl(&curwin->w_cursor);
-    } else if (ltoreq(start_pos, curwin->w_cursor)) {
-      // Include the character under the cursor.
-      oap->inclusive = true;
-    } else {
-      // End is before the start (no text in between <>, [], etc.): don't
-      // operate on any text.
-      curwin->w_cursor = start_pos;
-    }
-  }
-
-  return OK;
-}
-
-/// @param end_tag  when true, return true if the cursor is on "</aaa>".
-///
-/// @return         true if the cursor is on a "<aaa>" tag.  Ignore "<aaa/>".
-static bool in_html_tag(bool end_tag)
-{
-  char_u *line = get_cursor_line_ptr();
-  char_u *p;
-  int c;
-  int lc = NUL;
-  pos_T pos;
-
-  for (p = line + curwin->w_cursor.col; p > line;) {
-    if (*p == '<') {           // find '<' under/before cursor
-      break;
-    }
-    MB_PTR_BACK(line, p);
-    if (*p == '>') {           // find '>' before cursor
-      break;
-    }
-  }
-  if (*p != '<') {
-    return false;
-  }
-
-  pos.lnum = curwin->w_cursor.lnum;
-  pos.col = (colnr_T)(p - line);
-
-  MB_PTR_ADV(p);
-  if (end_tag) {
-    // check that there is a '/' after the '<'
-    return *p == '/';
-  }
-
-  // check that there is no '/' after the '<'
-  if (*p == '/') {
-    return false;
-  }
-
-  // check that the matching '>' is not preceded by '/'
-  for (;;) {
-    if (inc(&pos) < 0) {
-      return false;
-    }
-    c = *ml_get_pos(&pos);
-    if (c == '>') {
-      break;
-    }
-    lc = c;
-  }
-  return lc != '/';
-}
-
-/// Find tag block under the cursor, cursor at end.
-///
-/// @param include  true == include white space
-int current_tagblock(oparg_T *oap, long count_arg, bool include)
-{
-  long count = count_arg;
-  pos_T old_pos;
-  pos_T start_pos;
-  pos_T end_pos;
-  pos_T old_start, old_end;
-  char_u *p;
-  char_u *cp;
-  int len;
-  bool do_include = include;
-  bool save_p_ws = p_ws;
-  int retval = FAIL;
-  int is_inclusive = true;
-
-  p_ws = false;
-
-  old_pos = curwin->w_cursor;
-  old_end = curwin->w_cursor;               // remember where we started
-  old_start = old_end;
-  if (!VIsual_active || *p_sel == 'e') {
-    decl(&old_end);                         // old_end is inclusive
-  }
-  /*
-   * If we start on "<aaa>" select that block.
-   */
-  if (!VIsual_active || equalpos(VIsual, curwin->w_cursor)) {
-    setpcmark();
-
-    // ignore indent
-    while (inindent(1)) {
-      if (inc_cursor() != 0) {
-        break;
-      }
-    }
-
-    if (in_html_tag(false)) {
-      // cursor on start tag, move to its '>'
-      while (*get_cursor_pos_ptr() != '>') {
-        if (inc_cursor() < 0) {
-          break;
-        }
-      }
-    } else if (in_html_tag(true)) {
-      // cursor on end tag, move to just before it
-      while (*get_cursor_pos_ptr() != '<') {
-        if (dec_cursor() < 0) {
-          break;
-        }
-      }
-      dec_cursor();
-      old_end = curwin->w_cursor;
-    }
-  } else if (lt(VIsual, curwin->w_cursor)) {
-    old_start = VIsual;
-    curwin->w_cursor = VIsual;              // cursor at low end of Visual
-  } else {
-    old_end = VIsual;
-  }
-
-again:
-  /*
-   * Search backwards for unclosed "<aaa>".
-   * Put this position in start_pos.
-   */
-  for (long n = 0; n < count; n++) {
-    if (do_searchpair("<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)",
-                      "",
-                      "</[^>]*>", BACKWARD, NULL, 0,
-                      NULL, (linenr_T)0, 0L) <= 0) {
-      curwin->w_cursor = old_pos;
-      goto theend;
-    }
-  }
-  start_pos = curwin->w_cursor;
-
-  /*
-   * Search for matching "</aaa>".  First isolate the "aaa".
-   */
-  inc_cursor();
-  p = get_cursor_pos_ptr();
-  for (cp = p;
-       *cp != NUL && *cp != '>' && !ascii_iswhite(*cp);
-       MB_PTR_ADV(cp)) {}
-  len = (int)(cp - p);
-  if (len == 0) {
-    curwin->w_cursor = old_pos;
-    goto theend;
-  }
-  const size_t spat_len = (size_t)len + 39;
-  char *const spat = xmalloc(spat_len);
-  const size_t epat_len = (size_t)len + 9;
-  char *const epat = xmalloc(epat_len);
-  snprintf(spat, spat_len,
-           "<%.*s\\>\\%%(\\_s\\_[^>]\\{-}\\_[^/]>\\|\\_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);
-
-  xfree(spat);
-  xfree(epat);
-
-  if (r < 1 || lt(curwin->w_cursor, old_end)) {
-    // Can't find other end or it's before the previous end.  Could be a
-    // HTML tag that doesn't have a matching end.  Search backwards for
-    // another starting tag.
-    count = 1;
-    curwin->w_cursor = start_pos;
-    goto again;
-  }
-
-  if (do_include) {
-    // Include up to the '>'.
-    while (*get_cursor_pos_ptr() != '>') {
-      if (inc_cursor() < 0) {
-        break;
-      }
-    }
-  } else {
-    char_u *c = get_cursor_pos_ptr();
-    // Exclude the '<' of the end tag.
-    // If the closing tag is on new line, do not decrement cursor, but make
-    // operation exclusive, so that the linefeed will be selected
-    if (*c == '<' && !VIsual_active && curwin->w_cursor.col == 0) {
-      // do not decrement cursor
-      is_inclusive = false;
-    } else if (*c == '<') {
-      dec_cursor();
-    }
-  }
-  end_pos = curwin->w_cursor;
-
-  if (!do_include) {
-    // Exclude the start tag.
-    curwin->w_cursor = start_pos;
-    while (inc_cursor() >= 0) {
-      if (*get_cursor_pos_ptr() == '>') {
-        inc_cursor();
-        start_pos = curwin->w_cursor;
-        break;
-      }
-    }
-    curwin->w_cursor = end_pos;
-
-    // If we are in Visual mode and now have the same text as before set
-    // "do_include" and try again.
-    if (VIsual_active
-        && equalpos(start_pos, old_start)
-        && equalpos(end_pos, old_end)) {
-      do_include = true;
-      curwin->w_cursor = old_start;
-      count = count_arg;
-      goto again;
-    }
-  }
-
-  if (VIsual_active) {
-    // If the end is before the start there is no text between tags, select
-    // the char under the cursor.
-    if (lt(end_pos, start_pos)) {
-      curwin->w_cursor = start_pos;
-    } else if (*p_sel == 'e') {
-      inc_cursor();
-    }
-    VIsual = start_pos;
-    VIsual_mode = 'v';
-    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
-    showmode();
-  } else {
-    oap->start = start_pos;
-    oap->motion_type = kMTCharWise;
-    if (lt(end_pos, start_pos)) {
-      // End is before the start: there is no text between tags; operate
-      // on an empty area.
-      curwin->w_cursor = start_pos;
-      oap->inclusive = false;
-    } else {
-      oap->inclusive = is_inclusive;
-    }
-  }
-  retval = OK;
-
-theend:
-  p_ws = save_p_ws;
-  return retval;
-}
-
-/// @param include  true == include white space
-/// @param type     'p' for paragraph, 'S' for section
-int current_par(oparg_T *oap, long count, int include, int type)
-{
-  linenr_T start_lnum;
-  linenr_T end_lnum;
-  int white_in_front;
-  int dir;
-  int start_is_white;
-  int prev_start_is_white;
-  int retval = OK;
-  int do_white = false;
-  int t;
-  int i;
-
-  if (type == 'S') {        // not implemented yet
-    return FAIL;
-  }
-
-  start_lnum = curwin->w_cursor.lnum;
-
-  /*
-   * When visual area is more than one line: extend it.
-   */
-  if (VIsual_active && start_lnum != VIsual.lnum) {
-extend:
-    if (start_lnum < VIsual.lnum) {
-      dir = BACKWARD;
-    } else {
-      dir = FORWARD;
-    }
-    for (i = (int)count; --i >= 0;) {
-      if (start_lnum ==
-          (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count)) {
-        retval = FAIL;
-        break;
-      }
-
-      prev_start_is_white = -1;
-      for (t = 0; t < 2; t++) {
-        start_lnum += dir;
-        start_is_white = linewhite(start_lnum);
-        if (prev_start_is_white == start_is_white) {
-          start_lnum -= dir;
-          break;
-        }
-        for (;;) {
-          if (start_lnum == (dir == BACKWARD
-                             ? 1 : curbuf->b_ml.ml_line_count)) {
-            break;
-          }
-          if (start_is_white != linewhite(start_lnum + dir)
-              || (!start_is_white
-                  && startPS(start_lnum + (dir > 0
-                                           ? 1 : 0), 0, 0))) {
-            break;
-          }
-          start_lnum += dir;
-        }
-        if (!include) {
-          break;
-        }
-        if (start_lnum == (dir == BACKWARD
-                           ? 1 : curbuf->b_ml.ml_line_count)) {
-          break;
-        }
-        prev_start_is_white = start_is_white;
-      }
-    }
-    curwin->w_cursor.lnum = start_lnum;
-    curwin->w_cursor.col = 0;
-    return retval;
-  }
-
-  /*
-   * First move back to the start_lnum of the paragraph or white lines
-   */
-  white_in_front = linewhite(start_lnum);
-  while (start_lnum > 1) {
-    if (white_in_front) {           // stop at first white line
-      if (!linewhite(start_lnum - 1)) {
-        break;
-      }
-    } else {          // stop at first non-white line of start of paragraph
-      if (linewhite(start_lnum - 1) || startPS(start_lnum, 0, 0)) {
-        break;
-      }
-    }
-    start_lnum--;
-  }
-
-  /*
-   * Move past the end of any white lines.
-   */
-  end_lnum = start_lnum;
-  while (end_lnum <= curbuf->b_ml.ml_line_count && linewhite(end_lnum)) {
-    end_lnum++;
-  }
-
-  end_lnum--;
-  i = (int)count;
-  if (!include && white_in_front) {
-    i--;
-  }
-  while (i--) {
-    if (end_lnum == curbuf->b_ml.ml_line_count) {
-      return FAIL;
-    }
-
-    if (!include) {
-      do_white = linewhite(end_lnum + 1);
-    }
-
-    if (include || !do_white) {
-      end_lnum++;
-      // skip to end of paragraph
-      while (end_lnum < curbuf->b_ml.ml_line_count
-             && !linewhite(end_lnum + 1)
-             && !startPS(end_lnum + 1, 0, 0)) {
-        end_lnum++;
-      }
-    }
-
-    if (i == 0 && white_in_front && include) {
-      break;
-    }
-
-    /*
-     * skip to end of white lines after paragraph
-     */
-    if (include || do_white) {
-      while (end_lnum < curbuf->b_ml.ml_line_count
-             && linewhite(end_lnum + 1)) {
-        end_lnum++;
-      }
-    }
-  }
-
-  /*
-   * If there are no empty lines at the end, try to find some empty lines at
-   * the start (unless that has been done already).
-   */
-  if (!white_in_front && !linewhite(end_lnum) && include) {
-    while (start_lnum > 1 && linewhite(start_lnum - 1)) {
-      start_lnum--;
-    }
-  }
-
-  if (VIsual_active) {
-    // Problem: when doing "Vipipip" nothing happens in a single white
-    // line, we get stuck there.  Trap this here.
-    if (VIsual_mode == 'V' && start_lnum == curwin->w_cursor.lnum) {
-      goto extend;
-    }
-    if (VIsual.lnum != start_lnum) {
-      VIsual.lnum = start_lnum;
-      VIsual.col = 0;
-    }
-    VIsual_mode = 'V';
-    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
-    showmode();
-  } else {
-    oap->start.lnum = start_lnum;
-    oap->start.col = 0;
-    oap->motion_type = kMTLineWise;
-  }
-  curwin->w_cursor.lnum = end_lnum;
-  curwin->w_cursor.col = 0;
-
-  return OK;
-}
-
-/// Search quote char from string line[col].
-/// Quote character escaped by one of the characters in "escape" is not counted
-/// as a quote.
-///
-/// @param escape  escape characters, can be NULL
-///
-/// @return        column number of "quotechar" or -1 when not found.
-static int find_next_quote(char_u *line, int col, int quotechar, char_u *escape)
-{
-  int c;
-
-  for (;;) {
-    c = line[col];
-    if (c == NUL) {
-      return -1;
-    } else if (escape != NULL && vim_strchr((char *)escape, c)) {
-      col++;
-      if (line[col] == NUL) {
-        return -1;
-      }
-    } else if (c == quotechar) {
-      break;
-    }
-    col += utfc_ptr2len((char *)line + col);
-  }
-  return col;
-}
-
-/// Search backwards in "line" from column "col_start" to find "quotechar".
-/// Quote character escaped by one of the characters in "escape" is not counted
-/// as a quote.
-///
-/// @param escape  escape characters, can be NULL
-///
-/// @return        the found column or zero.
-static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *escape)
-{
-  int n;
-
-  while (col_start > 0) {
-    col_start--;
-    col_start -= utf_head_off(line, line + col_start);
-    n = 0;
-    if (escape != NULL) {
-      while (col_start - n > 0 && vim_strchr((char *)escape,
-                                             line[col_start - n - 1]) != NULL) {
-        n++;
-      }
-    }
-    if (n & 1) {
-      col_start -= n;           // uneven number of escape chars, skip it
-    } else if (line[col_start] == quotechar) {
-      break;
-    }
-  }
-  return col_start;
-}
-
-/// Find quote under the cursor, cursor at end.
-///
-/// @param include    true == include quote char
-/// @param quotechar  Quote character
-///
-/// @return           true if found, else false.
-bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
-  FUNC_ATTR_NONNULL_ALL
-{
-  char_u *line = get_cursor_line_ptr();
-  int col_end;
-  int col_start = curwin->w_cursor.col;
-  bool inclusive = false;
-  bool vis_empty = true;                // Visual selection <= 1 char
-  bool vis_bef_curs = false;            // Visual starts before cursor
-  bool did_exclusive_adj = false;       // adjusted pos for 'selection'
-  bool inside_quotes = false;           // Looks like "i'" done before
-  bool selected_quote = false;          // Has quote inside selection
-  int i;
-  bool restore_vis_bef = false;         // resotre VIsual on abort
-
-  // When 'selection' is "exclusive" move the cursor to where it would be
-  // with 'selection' "inclusive", so that the logic is the same for both.
-  // The cursor then is moved forward after adjusting the area.
-  if (VIsual_active) {
-    // this only works within one line
-    if (VIsual.lnum != curwin->w_cursor.lnum) {
-      return false;
-    }
-
-    vis_bef_curs = lt(VIsual, curwin->w_cursor);
-    vis_empty = equalpos(VIsual, curwin->w_cursor);
-    if (*p_sel == 'e') {
-      if (vis_bef_curs) {
-        dec_cursor();
-        did_exclusive_adj = true;
-      } else if (!vis_empty) {
-        dec(&VIsual);
-        did_exclusive_adj = true;
-      }
-      vis_empty = equalpos(VIsual, curwin->w_cursor);
-      if (!vis_bef_curs && !vis_empty) {
-        // VIsual needs to be start of Visual selection.
-        pos_T t = curwin->w_cursor;
-
-        curwin->w_cursor = VIsual;
-        VIsual = t;
-        vis_bef_curs = true;
-        restore_vis_bef = true;
-      }
-    }
-  }
-
-  if (!vis_empty) {
-    // Check if the existing selection exactly spans the text inside
-    // quotes.
-    if (vis_bef_curs) {
-      inside_quotes = VIsual.col > 0
-                      && line[VIsual.col - 1] == quotechar
-                      && line[curwin->w_cursor.col] != NUL
-                      && line[curwin->w_cursor.col + 1] == quotechar;
-      i = VIsual.col;
-      col_end = curwin->w_cursor.col;
-    } else {
-      inside_quotes = curwin->w_cursor.col > 0
-                      && line[curwin->w_cursor.col - 1] == quotechar
-                      && line[VIsual.col] != NUL
-                      && line[VIsual.col + 1] == quotechar;
-      i = curwin->w_cursor.col;
-      col_end = VIsual.col;
-    }
-
-    // Find out if we have a quote in the selection.
-    while (i <= col_end) {
-      // check for going over the end of the line, which can happen if
-      // the line was changed after the Visual area was selected.
-      if (line[i] == NUL) {
-        break;
-      }
-      if (line[i++] == quotechar) {
-        selected_quote = true;
-        break;
-      }
-    }
-  }
-
-  if (!vis_empty && line[col_start] == quotechar) {
-    // Already selecting something and on a quote character.  Find the
-    // next quoted string.
-    if (vis_bef_curs) {
-      // Assume we are on a closing quote: move to after the next
-      // opening quote.
-      col_start = find_next_quote(line, col_start + 1, quotechar, NULL);
-      if (col_start < 0) {
-        goto abort_search;
-      }
-      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
-      if (col_end < 0) {
-        // We were on a starting quote perhaps?
-        col_end = col_start;
-        col_start = curwin->w_cursor.col;
-      }
-    } else {
-      col_end = find_prev_quote(line, col_start, quotechar, NULL);
-      if (line[col_end] != quotechar) {
-        goto abort_search;
-      }
-      col_start = find_prev_quote(line, col_end, quotechar, (char_u *)curbuf->b_p_qe);
-      if (line[col_start] != quotechar) {
-        // We were on an ending quote perhaps?
-        col_start = col_end;
-        col_end = curwin->w_cursor.col;
-      }
-    }
-  } else if (line[col_start] == quotechar || !vis_empty) {
-    int first_col = col_start;
-
-    if (!vis_empty) {
-      if (vis_bef_curs) {
-        first_col = find_next_quote(line, col_start, quotechar, NULL);
-      } else {
-        first_col = find_prev_quote(line, col_start, quotechar, NULL);
-      }
-    }
-    // The cursor is on a quote, we don't know if it's the opening or
-    // closing quote.  Search from the start of the line to find out.
-    // Also do this when there is a Visual area, a' may leave the cursor
-    // in between two strings.
-    col_start = 0;
-    for (;;) {
-      // Find open quote character.
-      col_start = find_next_quote(line, col_start, quotechar, NULL);
-      if (col_start < 0 || col_start > first_col) {
-        goto abort_search;
-      }
-      // Find close quote character.
-      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
-      if (col_end < 0) {
-        goto abort_search;
-      }
-      // If is cursor between start and end quote character, it is
-      // target text object.
-      if (col_start <= first_col && first_col <= col_end) {
-        break;
-      }
-      col_start = col_end + 1;
-    }
-  } else {
-    // Search backward for a starting quote.
-    col_start = find_prev_quote(line, col_start, quotechar, (char_u *)curbuf->b_p_qe);
-    if (line[col_start] != quotechar) {
-      // No quote before the cursor, look after the cursor.
-      col_start = find_next_quote(line, col_start, quotechar, NULL);
-      if (col_start < 0) {
-        goto abort_search;
-      }
-    }
-
-    // Find close quote character.
-    col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
-    if (col_end < 0) {
-      goto abort_search;
-    }
-  }
-
-  // When "include" is true, include spaces after closing quote or before
-  // the starting quote.
-  if (include) {
-    if (ascii_iswhite(line[col_end + 1])) {
-      while (ascii_iswhite(line[col_end + 1])) {
-        col_end++;
-      }
-    } else {
-      while (col_start > 0 && ascii_iswhite(line[col_start - 1])) {
-        col_start--;
-      }
-    }
-  }
-
-  // Set start position.  After vi" another i" must include the ".
-  // For v2i" include the quotes.
-  if (!include && count < 2 && (vis_empty || !inside_quotes)) {
-    col_start++;
-  }
-  curwin->w_cursor.col = col_start;
-  if (VIsual_active) {
-    // Set the start of the Visual area when the Visual area was empty, we
-    // were just inside quotes or the Visual area didn't start at a quote
-    // and didn't include a quote.
-    if (vis_empty
-        || (vis_bef_curs
-            && !selected_quote
-            && (inside_quotes
-                || (line[VIsual.col] != quotechar
-                    && (VIsual.col == 0
-                        || line[VIsual.col - 1] != quotechar))))) {
-      VIsual = curwin->w_cursor;
-      redraw_curbuf_later(UPD_INVERTED);
-    }
-  } else {
-    oap->start = curwin->w_cursor;
-    oap->motion_type = kMTCharWise;
-  }
-
-  // Set end position.
-  curwin->w_cursor.col = col_end;
-  if ((include || count > 1
-       // After vi" another i" must include the ".
-       || (!vis_empty && inside_quotes)
-       ) && inc_cursor() == 2) {
-    inclusive = true;
-  }
-  if (VIsual_active) {
-    if (vis_empty || vis_bef_curs) {
-      // decrement cursor when 'selection' is not exclusive
-      if (*p_sel != 'e') {
-        dec_cursor();
-      }
-    } else {
-      // Cursor is at start of Visual area.  Set the end of the Visual
-      // area when it was just inside quotes or it didn't end at a
-      // quote.
-      if (inside_quotes
-          || (!selected_quote
-              && line[VIsual.col] != quotechar
-              && (line[VIsual.col] == NUL
-                  || line[VIsual.col + 1] != quotechar))) {
-        dec_cursor();
-        VIsual = curwin->w_cursor;
-      }
-      curwin->w_cursor.col = col_start;
-    }
-    if (VIsual_mode == 'V') {
-      VIsual_mode = 'v';
-      redraw_cmdline = true;                    // show mode later
-    }
-  } else {
-    // Set inclusive and other oap's flags.
-    oap->inclusive = inclusive;
-  }
-
-  return true;
-
-abort_search:
-  if (VIsual_active && *p_sel == 'e') {
-    if (did_exclusive_adj) {
-      inc_cursor();
-    }
-    if (restore_vis_bef) {
-      pos_T t = curwin->w_cursor;
-
-      curwin->w_cursor = VIsual;
-      VIsual = t;
-    }
-  }
-  return false;
-}
-
 /// Find next search match under cursor, cursor at end.
 /// Used while an operator is pending, and in Visual mode.
 ///
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 43afc08155..b2bfca08ed 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -5,6 +5,7 @@
 
 #include <stdbool.h>
 
+#include "nvim/ascii.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
@@ -15,14 +16,18 @@
 #include "nvim/globals.h"
 #include "nvim/indent.h"
 #include "nvim/indent_c.h"
+#include "nvim/mbyte.h"
 #include "nvim/memline.h"
 #include "nvim/move.h"
+#include "nvim/normal.h"
 #include "nvim/ops.h"
 #include "nvim/option.h"
 #include "nvim/os/input.h"
+#include "nvim/pos.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
 #include "nvim/textformat.h"
+#include "nvim/textobject.h"
 #include "nvim/undo.h"
 #include "nvim/vim.h"
 #include "nvim/window.h"
diff --git a/src/nvim/textformat.h b/src/nvim/textformat.h
index 9d8327e6eb..3c918a028b 100644
--- a/src/nvim/textformat.h
+++ b/src/nvim/textformat.h
@@ -1,8 +1,6 @@
 #ifndef NVIM_TEXTFORMAT_H
 #define NVIM_TEXTFORMAT_H
 
-#include <stdbool.h>
-
 #include "nvim/normal.h"  // for oparg_T
 #include "nvim/pos.h"  // for linenr_T
 
diff --git a/src/nvim/textobject.c b/src/nvim/textobject.c
new file mode 100644
index 0000000000..02174edeb1
--- /dev/null
+++ b/src/nvim/textobject.c
@@ -0,0 +1,1742 @@
+// 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
+
+// textobject.c: functions for text objects
+
+#include <stdbool.h>
+
+#include "nvim/ascii.h"
+#include "nvim/cursor.h"
+#include "nvim/drawscreen.h"
+#include "nvim/edit.h"
+#include "nvim/eval/funcs.h"
+#include "nvim/fold.h"
+#include "nvim/globals.h"
+#include "nvim/indent.h"
+#include "nvim/mark.h"
+#include "nvim/mbyte.h"
+#include "nvim/memline.h"
+#include "nvim/normal.h"
+#include "nvim/pos.h"
+#include "nvim/search.h"
+#include "nvim/textformat.h"
+#include "nvim/textobject.h"
+#include "nvim/vim.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "textobject.c.generated.h"
+#endif
+
+/// Find the start of the next sentence, searching in the direction specified
+/// by the "dir" argument.  The cursor is positioned on the start of the next
+/// sentence when found.  If the next sentence is found, return OK.  Return FAIL
+/// otherwise.  See ":h sentence" for the precise definition of a "sentence"
+/// text object.
+int findsent(Direction dir, long count)
+{
+  pos_T pos, tpos;
+  int c;
+  int (*func)(pos_T *);
+  bool noskip = false;              // do not skip blanks
+
+  pos = curwin->w_cursor;
+  if (dir == FORWARD) {
+    func = incl;
+  } else {
+    func = decl;
+  }
+
+  while (count--) {
+    const pos_T prev_pos = pos;
+
+    // if on an empty line, skip up to a non-empty line
+    if (gchar_pos(&pos) == NUL) {
+      do {
+        if ((*func)(&pos) == -1) {
+          break;
+        }
+      } while (gchar_pos(&pos) == NUL);
+      if (dir == FORWARD) {
+        goto found;
+      }
+      // if on the start of a paragraph or a section and searching forward,
+      // go to the next line
+    } else if (dir == FORWARD && pos.col == 0
+               && startPS(pos.lnum, NUL, false)) {
+      if (pos.lnum == curbuf->b_ml.ml_line_count) {
+        return FAIL;
+      }
+      pos.lnum++;
+      goto found;
+    } else if (dir == BACKWARD) {
+      decl(&pos);
+    }
+
+    // go back to the previous non-white non-punctuation character
+    bool found_dot = false;
+    while (c = gchar_pos(&pos), ascii_iswhite(c)
+           || vim_strchr(".!?)]\"'", c) != NULL) {
+      tpos = pos;
+      if (decl(&tpos) == -1 || (LINEEMPTY(tpos.lnum) && dir == FORWARD)) {
+        break;
+      }
+      if (found_dot) {
+        break;
+      }
+      if (vim_strchr(".!?", c) != NULL) {
+        found_dot = true;
+      }
+      if (vim_strchr(")]\"'", c) != NULL
+          && vim_strchr(".!?)]\"'", gchar_pos(&tpos)) == NULL) {
+        break;
+      }
+      decl(&pos);
+    }
+
+    // remember the line where the search started
+    const int startlnum = pos.lnum;
+    const bool cpo_J = vim_strchr(p_cpo, CPO_ENDOFSENT) != NULL;
+
+    for (;;) {                 // find end of sentence
+      c = gchar_pos(&pos);
+      if (c == NUL || (pos.col == 0 && startPS(pos.lnum, NUL, false))) {
+        if (dir == BACKWARD && pos.lnum != startlnum) {
+          pos.lnum++;
+        }
+        break;
+      }
+      if (c == '.' || c == '!' || c == '?') {
+        tpos = pos;
+        do {
+          if ((c = inc(&tpos)) == -1) {
+            break;
+          }
+        } while (vim_strchr(")]\"'", c = gchar_pos(&tpos))
+                 != NULL);
+        if (c == -1 || (!cpo_J && (c == ' ' || c == '\t')) || c == NUL
+            || (cpo_J && (c == ' ' && inc(&tpos) >= 0
+                          && gchar_pos(&tpos) == ' '))) {
+          pos = tpos;
+          if (gchar_pos(&pos) == NUL) {         // skip NUL at EOL
+            inc(&pos);
+          }
+          break;
+        }
+      }
+      if ((*func)(&pos) == -1) {
+        if (count) {
+          return FAIL;
+        }
+        noskip = true;
+        break;
+      }
+    }
+found:
+    // skip white space
+    while (!noskip && ((c = gchar_pos(&pos)) == ' ' || c == '\t')) {
+      if (incl(&pos) == -1) {
+        break;
+      }
+    }
+
+    if (equalpos(prev_pos, pos)) {
+      // didn't actually move, advance one character and try again
+      if ((*func)(&pos) == -1) {
+        if (count) {
+          return FAIL;
+        }
+        break;
+      }
+      count++;
+    }
+  }
+
+  setpcmark();
+  curwin->w_cursor = pos;
+  return OK;
+}
+
+/// Find the next paragraph or section in direction 'dir'.
+/// Paragraphs are currently supposed to be separated by empty lines.
+/// If 'what' is NUL we go to the next paragraph.
+/// If 'what' is '{' or '}' we go to the next section.
+/// If 'both' is true also stop at '}'.
+///
+/// @param pincl  Return: true if last char is to be included
+///
+/// @return       true if the next paragraph or section was found.
+bool findpar(bool *pincl, int dir, long count, int what, bool both)
+{
+  linenr_T curr;
+  bool did_skip;            // true after separating lines have been skipped
+  bool first;               // true on first line
+  linenr_T fold_first;      // first line of a closed fold
+  linenr_T fold_last;       // last line of a closed fold
+  bool fold_skipped;        // true if a closed fold was skipped this
+                            // iteration
+
+  curr = curwin->w_cursor.lnum;
+
+  while (count--) {
+    did_skip = false;
+    for (first = true;; first = false) {
+      if (*ml_get(curr) != NUL) {
+        did_skip = true;
+      }
+
+      // skip folded lines
+      fold_skipped = false;
+      if (first && hasFolding(curr, &fold_first, &fold_last)) {
+        curr = ((dir > 0) ? fold_last : fold_first) + dir;
+        fold_skipped = true;
+      }
+
+      if (!first && did_skip && startPS(curr, what, both)) {
+        break;
+      }
+
+      if (fold_skipped) {
+        curr -= dir;
+      }
+      if ((curr += dir) < 1 || curr > curbuf->b_ml.ml_line_count) {
+        if (count) {
+          return false;
+        }
+        curr -= dir;
+        break;
+      }
+    }
+  }
+  setpcmark();
+  if (both && *ml_get(curr) == '}') {   // include line with '}'
+    curr++;
+  }
+  curwin->w_cursor.lnum = curr;
+  if (curr == curbuf->b_ml.ml_line_count && what != '}') {
+    char_u *line = ml_get(curr);
+
+    // Put the cursor on the last character in the last line and make the
+    // motion inclusive.
+    if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0) {
+      curwin->w_cursor.col--;
+      curwin->w_cursor.col -= utf_head_off(line, line + curwin->w_cursor.col);
+      *pincl = true;
+    }
+  } else {
+    curwin->w_cursor.col = 0;
+  }
+  return true;
+}
+
+/// check if the string 's' is a nroff macro that is in option 'opt'
+static bool inmacro(char_u *opt, char_u *s)
+{
+  char_u *macro;
+
+  for (macro = opt; macro[0]; macro++) {
+    // Accept two characters in the option being equal to two characters
+    // in the line.  A space in the option matches with a space in the
+    // line or the line having ended.
+    if ((macro[0] == s[0]
+         || (macro[0] == ' '
+             && (s[0] == NUL || s[0] == ' ')))
+        && (macro[1] == s[1]
+            || ((macro[1] == NUL || macro[1] == ' ')
+                && (s[0] == NUL || s[1] == NUL || s[1] == ' ')))) {
+      break;
+    }
+    macro++;
+    if (macro[0] == NUL) {
+      break;
+    }
+  }
+  return macro[0] != NUL;
+}
+
+/// startPS: return true if line 'lnum' is the start of a section or paragraph.
+/// If 'para' is '{' or '}' only check for sections.
+/// If 'both' is true also stop at '}'
+bool startPS(linenr_T lnum, int para, bool both)
+{
+  char_u *s;
+
+  s = ml_get(lnum);
+  if (*s == para || *s == '\f' || (both && *s == '}')) {
+    return true;
+  }
+  if (*s == '.' && (inmacro((char_u *)p_sections, s + 1)
+                    || (!para && inmacro(p_para, s + 1)))) {
+    return true;
+  }
+  return false;
+}
+
+// The following routines do the word searches performed by the 'w', 'W',
+// 'b', 'B', 'e', and 'E' commands.
+
+// To perform these searches, characters are placed into one of three
+// classes, and transitions between classes determine word boundaries.
+//
+// The classes are:
+//
+// 0 - white space
+// 1 - punctuation
+// 2 or higher - keyword characters (letters, digits and underscore)
+
+static bool cls_bigword;  ///< true for "W", "B" or "E"
+
+/// cls() - returns the class of character at curwin->w_cursor
+///
+/// If a 'W', 'B', or 'E' motion is being done (cls_bigword == true), chars
+/// from class 2 and higher are reported as class 1 since only white space
+/// boundaries are of interest.
+static int cls(void)
+{
+  int c;
+
+  c = gchar_cursor();
+  if (c == ' ' || c == '\t' || c == NUL) {
+    return 0;
+  }
+
+  c = utf_class(c);
+
+  // If cls_bigword is true, report all non-blanks as class 1.
+  if (c != 0 && cls_bigword) {
+    return 1;
+  }
+  return c;
+}
+
+/// fwd_word(count, type, eol) - move forward one word
+///
+/// @return  FAIL if the cursor was already at the end of the file.
+/// If eol is true, last word stops at end of line (for operators).
+///
+/// @param bigword  "W", "E" or "B"
+int fwd_word(long count, bool bigword, bool eol)
+{
+  int sclass;               // starting class
+  int i;
+  int last_line;
+
+  curwin->w_cursor.coladd = 0;
+  cls_bigword = bigword;
+  while (--count >= 0) {
+    // When inside a range of folded lines, move to the last char of the
+    // last line.
+    if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) {
+      coladvance(MAXCOL);
+    }
+    sclass = cls();
+
+    // We always move at least one character, unless on the last
+    // character in the buffer.
+    last_line = (curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count);
+    i = inc_cursor();
+    if (i == -1 || (i >= 1 && last_line)) {   // started at last char in file
+      return FAIL;
+    }
+    if (i >= 1 && eol && count == 0) {        // started at last char in line
+      return OK;
+    }
+
+    // Go one char past end of current word (if any)
+    if (sclass != 0) {
+      while (cls() == sclass) {
+        i = inc_cursor();
+        if (i == -1 || (i >= 1 && eol && count == 0)) {
+          return OK;
+        }
+      }
+    }
+
+    // go to next non-white
+    while (cls() == 0) {
+      // We'll stop if we land on a blank line
+      if (curwin->w_cursor.col == 0 && *get_cursor_line_ptr() == NUL) {
+        break;
+      }
+
+      i = inc_cursor();
+      if (i == -1 || (i >= 1 && eol && count == 0)) {
+        return OK;
+      }
+    }
+  }
+  return OK;
+}
+
+/// bck_word() - move backward 'count' words
+///
+/// If stop is true and we are already on the start of a word, move one less.
+///
+/// Returns FAIL if top of the file was reached.
+int bck_word(long count, bool bigword, bool stop)
+{
+  int sclass;               // starting class
+
+  curwin->w_cursor.coladd = 0;
+  cls_bigword = bigword;
+  while (--count >= 0) {
+    // When inside a range of folded lines, move to the first char of the
+    // first line.
+    if (hasFolding(curwin->w_cursor.lnum, &curwin->w_cursor.lnum, NULL)) {
+      curwin->w_cursor.col = 0;
+    }
+    sclass = cls();
+    if (dec_cursor() == -1) {           // started at start of file
+      return FAIL;
+    }
+
+    if (!stop || sclass == cls() || sclass == 0) {
+      // Skip white space before the word.
+      // Stop on an empty line.
+      while (cls() == 0) {
+        if (curwin->w_cursor.col == 0
+            && LINEEMPTY(curwin->w_cursor.lnum)) {
+          goto finished;
+        }
+        if (dec_cursor() == -1) {       // hit start of file, stop here
+          return OK;
+        }
+      }
+
+      // Move backward to start of this word.
+      if (skip_chars(cls(), BACKWARD)) {
+        return OK;
+      }
+    }
+
+    inc_cursor();                       // overshot - forward one
+finished:
+    stop = false;
+  }
+  return OK;
+}
+
+/// end_word() - move to the end of the word
+///
+/// There is an apparent bug in the 'e' motion of the real vi. At least on the
+/// System V Release 3 version for the 80386. Unlike 'b' and 'w', the 'e'
+/// motion crosses blank lines. When the real vi crosses a blank line in an
+/// 'e' motion, the cursor is placed on the FIRST character of the next
+/// non-blank line. The 'E' command, however, works correctly. Since this
+/// appears to be a bug, I have not duplicated it here.
+///
+/// Returns FAIL if end of the file was reached.
+///
+/// If stop is true and we are already on the end of a word, move one less.
+/// If empty is true stop on an empty line.
+int end_word(long count, bool bigword, bool stop, bool empty)
+{
+  int sclass;               // starting class
+
+  curwin->w_cursor.coladd = 0;
+  cls_bigword = bigword;
+  while (--count >= 0) {
+    // When inside a range of folded lines, move to the last char of the
+    // last line.
+    if (hasFolding(curwin->w_cursor.lnum, NULL, &curwin->w_cursor.lnum)) {
+      coladvance(MAXCOL);
+    }
+    sclass = cls();
+    if (inc_cursor() == -1) {
+      return FAIL;
+    }
+
+    // If we're in the middle of a word, we just have to move to the end
+    // of it.
+    if (cls() == sclass && sclass != 0) {
+      // Move forward to end of the current word
+      if (skip_chars(sclass, FORWARD)) {
+        return FAIL;
+      }
+    } else if (!stop || sclass == 0) {
+      // We were at the end of a word. Go to the end of the next word.
+      // First skip white space, if 'empty' is true, stop at empty line.
+      while (cls() == 0) {
+        if (empty && curwin->w_cursor.col == 0
+            && LINEEMPTY(curwin->w_cursor.lnum)) {
+          goto finished;
+        }
+        if (inc_cursor() == -1) {           // hit end of file, stop here
+          return FAIL;
+        }
+      }
+
+      // Move forward to the end of this word.
+      if (skip_chars(cls(), FORWARD)) {
+        return FAIL;
+      }
+    }
+    dec_cursor();                       // overshot - one char backward
+finished:
+    stop = false;                       // we move only one word less
+  }
+  return OK;
+}
+
+/// Move back to the end of the word.
+///
+/// @param bigword  true for "B"
+/// @param eol      if true, then stop at end of line.
+///
+/// @return         FAIL if start of the file was reached.
+int bckend_word(long count, bool bigword, bool eol)
+{
+  int sclass;               // starting class
+  int i;
+
+  curwin->w_cursor.coladd = 0;
+  cls_bigword = bigword;
+  while (--count >= 0) {
+    sclass = cls();
+    if ((i = dec_cursor()) == -1) {
+      return FAIL;
+    }
+    if (eol && i == 1) {
+      return OK;
+    }
+
+    // Move backward to before the start of this word.
+    if (sclass != 0) {
+      while (cls() == sclass) {
+        if ((i = dec_cursor()) == -1 || (eol && i == 1)) {
+          return OK;
+        }
+      }
+    }
+
+    // Move backward to end of the previous word
+    while (cls() == 0) {
+      if (curwin->w_cursor.col == 0 && LINEEMPTY(curwin->w_cursor.lnum)) {
+        break;
+      }
+      if ((i = dec_cursor()) == -1 || (eol && i == 1)) {
+        return OK;
+      }
+    }
+  }
+  return OK;
+}
+
+/// Skip a row of characters of the same class.
+///
+/// @return  true when end-of-file reached, false otherwise.
+static bool skip_chars(int cclass, int dir)
+{
+  while (cls() == cclass) {
+    if ((dir == FORWARD ? inc_cursor() : dec_cursor()) == -1) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/// Go back to the start of the word or the start of white space
+static void back_in_line(void)
+{
+  int sclass;                       // starting class
+
+  sclass = cls();
+  for (;;) {
+    if (curwin->w_cursor.col == 0) {        // stop at start of line
+      break;
+    }
+    dec_cursor();
+    if (cls() != sclass) {                  // stop at start of word
+      inc_cursor();
+      break;
+    }
+  }
+}
+
+static void find_first_blank(pos_T *posp)
+{
+  int c;
+
+  while (decl(posp) != -1) {
+    c = gchar_pos(posp);
+    if (!ascii_iswhite(c)) {
+      incl(posp);
+      break;
+    }
+  }
+}
+
+/// Skip count/2 sentences and count/2 separating white spaces.
+///
+/// @param at_start_sent  cursor is at start of sentence
+static void findsent_forward(long count, bool at_start_sent)
+{
+  while (count--) {
+    findsent(FORWARD, 1L);
+    if (at_start_sent) {
+      find_first_blank(&curwin->w_cursor);
+    }
+    if (count == 0 || at_start_sent) {
+      decl(&curwin->w_cursor);
+    }
+    at_start_sent = !at_start_sent;
+  }
+}
+
+/// Find word under cursor, cursor at end.
+/// Used while an operator is pending, and in Visual mode.
+///
+/// @param include  true: include word and white space
+/// @param bigword  false == word, true == WORD
+int current_word(oparg_T *oap, long count, bool include, bool bigword)
+{
+  pos_T start_pos;
+  pos_T pos;
+  bool inclusive = true;
+  int include_white = false;
+
+  cls_bigword = bigword;
+  clearpos(&start_pos);
+
+  // Correct cursor when 'selection' is exclusive
+  if (VIsual_active && *p_sel == 'e' && lt(VIsual, curwin->w_cursor)) {
+    dec_cursor();
+  }
+
+  // When Visual mode is not active, or when the VIsual area is only one
+  // character, select the word and/or white space under the cursor.
+  if (!VIsual_active || equalpos(curwin->w_cursor, VIsual)) {
+    // Go to start of current word or white space.
+    back_in_line();
+    start_pos = curwin->w_cursor;
+
+    // If the start is on white space, and white space should be included
+    // (" word"), or start is not on white space, and white space should
+    // not be included ("word"), find end of word.
+    if ((cls() == 0) == include) {
+      if (end_word(1L, bigword, true, true) == FAIL) {
+        return FAIL;
+      }
+    } else {
+      // If the start is not on white space, and white space should be
+      // included ("word   "), or start is on white space and white
+      // space should not be included ("   "), find start of word.
+      // If we end up in the first column of the next line (single char
+      // word) back up to end of the line.
+      fwd_word(1L, bigword, true);
+      if (curwin->w_cursor.col == 0) {
+        decl(&curwin->w_cursor);
+      } else {
+        oneleft();
+      }
+
+      if (include) {
+        include_white = true;
+      }
+    }
+
+    if (VIsual_active) {
+      // should do something when inclusive == false !
+      VIsual = start_pos;
+      redraw_curbuf_later(UPD_INVERTED);  // update the inversion
+    } else {
+      oap->start = start_pos;
+      oap->motion_type = kMTCharWise;
+    }
+    count--;
+  }
+
+  // When count is still > 0, extend with more objects.
+  while (count > 0) {
+    inclusive = true;
+    if (VIsual_active && lt(curwin->w_cursor, VIsual)) {
+      // In Visual mode, with cursor at start: move cursor back.
+      if (decl(&curwin->w_cursor) == -1) {
+        return FAIL;
+      }
+      if (include != (cls() != 0)) {
+        if (bck_word(1L, bigword, true) == FAIL) {
+          return FAIL;
+        }
+      } else {
+        if (bckend_word(1L, bigword, true) == FAIL) {
+          return FAIL;
+        }
+        (void)incl(&curwin->w_cursor);
+      }
+    } else {
+      // Move cursor forward one word and/or white area.
+      if (incl(&curwin->w_cursor) == -1) {
+        return FAIL;
+      }
+      if (include != (cls() == 0)) {
+        if (fwd_word(1L, bigword, true) == FAIL && count > 1) {
+          return FAIL;
+        }
+        // If end is just past a new-line, we don't want to include
+        // the first character on the line.
+        // Put cursor on last char of white.
+        if (oneleft() == FAIL) {
+          inclusive = false;
+        }
+      } else {
+        if (end_word(1L, bigword, true, true) == FAIL) {
+          return FAIL;
+        }
+      }
+    }
+    count--;
+  }
+
+  if (include_white && (cls() != 0
+                        || (curwin->w_cursor.col == 0 && !inclusive))) {
+    // If we don't include white space at the end, move the start
+    // to include some white space there. This makes "daw" work
+    // better on the last word in a sentence (and "2daw" on last-but-one
+    // word).  Also when "2daw" deletes "word." at the end of the line
+    // (cursor is at start of next line).
+    // But don't delete white space at start of line (indent).
+    pos = curwin->w_cursor;     // save cursor position
+    curwin->w_cursor = start_pos;
+    if (oneleft() == OK) {
+      back_in_line();
+      if (cls() == 0 && curwin->w_cursor.col > 0) {
+        if (VIsual_active) {
+          VIsual = curwin->w_cursor;
+        } else {
+          oap->start = curwin->w_cursor;
+        }
+      }
+    }
+    curwin->w_cursor = pos;     // put cursor back at end
+  }
+
+  if (VIsual_active) {
+    if (*p_sel == 'e' && inclusive && ltoreq(VIsual, curwin->w_cursor)) {
+      inc_cursor();
+    }
+    if (VIsual_mode == 'V') {
+      VIsual_mode = 'v';
+      redraw_cmdline = true;                    // show mode later
+    }
+  } else {
+    oap->inclusive = inclusive;
+  }
+
+  return OK;
+}
+
+/// Find sentence(s) under the cursor, cursor at end.
+/// When Visual active, extend it by one or more sentences.
+int current_sent(oparg_T *oap, long count, bool include)
+{
+  pos_T start_pos;
+  pos_T pos;
+  bool start_blank;
+  int c;
+  bool at_start_sent;
+  long ncount;
+
+  start_pos = curwin->w_cursor;
+  pos = start_pos;
+  findsent(FORWARD, 1L);        // Find start of next sentence.
+
+  // When the Visual area is bigger than one character: Extend it.
+  if (VIsual_active && !equalpos(start_pos, VIsual)) {
+extend:
+    if (lt(start_pos, VIsual)) {
+      // Cursor at start of Visual area.
+      // Find out where we are:
+      // - in the white space before a sentence
+      // - in a sentence or just after it
+      // - at the start of a sentence
+      at_start_sent = true;
+      decl(&pos);
+      while (lt(pos, curwin->w_cursor)) {
+        c = gchar_pos(&pos);
+        if (!ascii_iswhite(c)) {
+          at_start_sent = false;
+          break;
+        }
+        incl(&pos);
+      }
+      if (!at_start_sent) {
+        findsent(BACKWARD, 1L);
+        if (equalpos(curwin->w_cursor, start_pos)) {
+          at_start_sent = true;            // exactly at start of sentence
+        } else {
+          // inside a sentence, go to its end (start of next)
+          findsent(FORWARD, 1L);
+        }
+      }
+      if (include) {            // "as" gets twice as much as "is"
+        count *= 2;
+      }
+      while (count--) {
+        if (at_start_sent) {
+          find_first_blank(&curwin->w_cursor);
+        }
+        c = gchar_cursor();
+        if (!at_start_sent || (!include && !ascii_iswhite(c))) {
+          findsent(BACKWARD, 1L);
+        }
+        at_start_sent = !at_start_sent;
+      }
+    } else {
+      // Cursor at end of Visual area.
+      // Find out where we are:
+      // - just before a sentence
+      // - just before or in the white space before a sentence
+      // - in a sentence
+      incl(&pos);
+      at_start_sent = true;
+      if (!equalpos(pos, curwin->w_cursor)) {     // not just before a sentence
+        at_start_sent = false;
+        while (lt(pos, curwin->w_cursor)) {
+          c = gchar_pos(&pos);
+          if (!ascii_iswhite(c)) {
+            at_start_sent = true;
+            break;
+          }
+          incl(&pos);
+        }
+        if (at_start_sent) {            // in the sentence
+          findsent(BACKWARD, 1L);
+        } else {  // in/before white before a sentence
+          curwin->w_cursor = start_pos;
+        }
+      }
+
+      if (include) {            // "as" gets twice as much as "is"
+        count *= 2;
+      }
+      findsent_forward(count, at_start_sent);
+      if (*p_sel == 'e') {
+        curwin->w_cursor.col++;
+      }
+    }
+    return OK;
+  }
+
+  // If the cursor started on a blank, check if it is just before the start
+  // of the next sentence.
+  while (c = gchar_pos(&pos), ascii_iswhite(c)) {
+    incl(&pos);
+  }
+  if (equalpos(pos, curwin->w_cursor)) {
+    start_blank = true;
+    find_first_blank(&start_pos);       // go back to first blank
+  } else {
+    start_blank = false;
+    findsent(BACKWARD, 1L);
+    start_pos = curwin->w_cursor;
+  }
+  if (include) {
+    ncount = count * 2;
+  } else {
+    ncount = count;
+    if (start_blank) {
+      ncount--;
+    }
+  }
+  if (ncount > 0) {
+    findsent_forward(ncount, true);
+  } else {
+    decl(&curwin->w_cursor);
+  }
+
+  if (include) {
+    // If the blank in front of the sentence is included, exclude the
+    // blanks at the end of the sentence, go back to the first blank.
+    // If there are no trailing blanks, try to include leading blanks.
+    if (start_blank) {
+      find_first_blank(&curwin->w_cursor);
+      c = gchar_pos(&curwin->w_cursor);
+      if (ascii_iswhite(c)) {
+        decl(&curwin->w_cursor);
+      }
+    } else if (c = gchar_cursor(), !ascii_iswhite(c)) {
+      find_first_blank(&start_pos);
+    }
+  }
+
+  if (VIsual_active) {
+    // Avoid getting stuck with "is" on a single space before a sentence.
+    if (equalpos(start_pos, curwin->w_cursor)) {
+      goto extend;
+    }
+    if (*p_sel == 'e') {
+      curwin->w_cursor.col++;
+    }
+    VIsual = start_pos;
+    VIsual_mode = 'v';
+    redraw_cmdline = true;    // show mode later
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
+  } else {
+    // include a newline after the sentence, if there is one
+    if (incl(&curwin->w_cursor) == -1) {
+      oap->inclusive = true;
+    } else {
+      oap->inclusive = false;
+    }
+    oap->start = start_pos;
+    oap->motion_type = kMTCharWise;
+  }
+  return OK;
+}
+
+/// Find block under the cursor, cursor at end.
+/// "what" and "other" are two matching parenthesis/brace/etc.
+///
+/// @param include  true == include white space
+/// @param what     '(', '{', etc.
+/// @param other    ')', '}', etc.
+int current_block(oparg_T *oap, long count, bool include, int what, int other)
+{
+  pos_T old_pos;
+  pos_T *pos = NULL;
+  pos_T start_pos;
+  pos_T *end_pos;
+  pos_T old_start, old_end;
+  char *save_cpo;
+  bool sol = false;                      // '{' at start of line
+
+  old_pos = curwin->w_cursor;
+  old_end = curwin->w_cursor;           // remember where we started
+  old_start = old_end;
+
+  // If we start on '(', '{', ')', '}', etc., use the whole block inclusive.
+  if (!VIsual_active || equalpos(VIsual, curwin->w_cursor)) {
+    setpcmark();
+    if (what == '{') {                  // ignore indent
+      while (inindent(1)) {
+        if (inc_cursor() != 0) {
+          break;
+        }
+      }
+    }
+    if (gchar_cursor() == what) {
+      // cursor on '(' or '{', move cursor just after it
+      curwin->w_cursor.col++;
+    }
+  } else if (lt(VIsual, curwin->w_cursor)) {
+    old_start = VIsual;
+    curwin->w_cursor = VIsual;              // cursor at low end of Visual
+  } else {
+    old_end = VIsual;
+  }
+
+  // Search backwards for unclosed '(', '{', etc..
+  // Put this position in start_pos.
+  // Ignore quotes here.  Keep the "M" flag in 'cpo', as that is what the
+  // user wants.
+  save_cpo = p_cpo;
+  p_cpo = vim_strchr(p_cpo, CPO_MATCHBSL) != NULL ? "%M" : "%";
+  if ((pos = findmatch(NULL, what)) != NULL) {
+    while (count-- > 0) {
+      if ((pos = findmatch(NULL, what)) == NULL) {
+        break;
+      }
+      curwin->w_cursor = *pos;
+      start_pos = *pos;   // the findmatch for end_pos will overwrite *pos
+    }
+  } else {
+    while (count-- > 0) {
+      if ((pos = findmatchlimit(NULL, what, FM_FORWARD, 0)) == NULL) {
+        break;
+      }
+      curwin->w_cursor = *pos;
+      start_pos = *pos;   // the findmatch for end_pos will overwrite *pos
+    }
+  }
+  p_cpo = save_cpo;
+
+  // Search for matching ')', '}', etc.
+  // Put this position in curwin->w_cursor.
+  if (pos == NULL || (end_pos = findmatch(NULL, other)) == NULL) {
+    curwin->w_cursor = old_pos;
+    return FAIL;
+  }
+  curwin->w_cursor = *end_pos;
+
+  // Try to exclude the '(', '{', ')', '}', etc. when "include" is false.
+  // If the ending '}', ')' or ']' is only preceded by indent, skip that
+  // indent. But only if the resulting area is not smaller than what we
+  // started with.
+  while (!include) {
+    incl(&start_pos);
+    sol = (curwin->w_cursor.col == 0);
+    decl(&curwin->w_cursor);
+    while (inindent(1)) {
+      sol = true;
+      if (decl(&curwin->w_cursor) != 0) {
+        break;
+      }
+    }
+
+    // In Visual mode, when the resulting area is not bigger than what we
+    // started with, extend it to the next block, and then exclude again.
+    // Don't try to expand the area if the area is empty.
+    if (!lt(start_pos, old_start) && !lt(old_end, curwin->w_cursor)
+        && !equalpos(start_pos, curwin->w_cursor)
+        && VIsual_active) {
+      curwin->w_cursor = old_start;
+      decl(&curwin->w_cursor);
+      if ((pos = findmatch(NULL, what)) == NULL) {
+        curwin->w_cursor = old_pos;
+        return FAIL;
+      }
+      start_pos = *pos;
+      curwin->w_cursor = *pos;
+      if ((end_pos = findmatch(NULL, other)) == NULL) {
+        curwin->w_cursor = old_pos;
+        return FAIL;
+      }
+      curwin->w_cursor = *end_pos;
+    } else {
+      break;
+    }
+  }
+
+  if (VIsual_active) {
+    if (*p_sel == 'e') {
+      inc(&curwin->w_cursor);
+    }
+    if (sol && gchar_cursor() != NUL) {
+      inc(&curwin->w_cursor);  // include the line break
+    }
+    VIsual = start_pos;
+    VIsual_mode = 'v';
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
+    showmode();
+  } else {
+    oap->start = start_pos;
+    oap->motion_type = kMTCharWise;
+    oap->inclusive = false;
+    if (sol) {
+      incl(&curwin->w_cursor);
+    } else if (ltoreq(start_pos, curwin->w_cursor)) {
+      // Include the character under the cursor.
+      oap->inclusive = true;
+    } else {
+      // End is before the start (no text in between <>, [], etc.): don't
+      // operate on any text.
+      curwin->w_cursor = start_pos;
+    }
+  }
+
+  return OK;
+}
+
+/// @param end_tag  when true, return true if the cursor is on "</aaa>".
+///
+/// @return         true if the cursor is on a "<aaa>" tag.  Ignore "<aaa/>".
+static bool in_html_tag(bool end_tag)
+{
+  char_u *line = get_cursor_line_ptr();
+  char_u *p;
+  int c;
+  int lc = NUL;
+  pos_T pos;
+
+  for (p = line + curwin->w_cursor.col; p > line;) {
+    if (*p == '<') {           // find '<' under/before cursor
+      break;
+    }
+    MB_PTR_BACK(line, p);
+    if (*p == '>') {           // find '>' before cursor
+      break;
+    }
+  }
+  if (*p != '<') {
+    return false;
+  }
+
+  pos.lnum = curwin->w_cursor.lnum;
+  pos.col = (colnr_T)(p - line);
+
+  MB_PTR_ADV(p);
+  if (end_tag) {
+    // check that there is a '/' after the '<'
+    return *p == '/';
+  }
+
+  // check that there is no '/' after the '<'
+  if (*p == '/') {
+    return false;
+  }
+
+  // check that the matching '>' is not preceded by '/'
+  for (;;) {
+    if (inc(&pos) < 0) {
+      return false;
+    }
+    c = *ml_get_pos(&pos);
+    if (c == '>') {
+      break;
+    }
+    lc = c;
+  }
+  return lc != '/';
+}
+
+/// Find tag block under the cursor, cursor at end.
+///
+/// @param include  true == include white space
+int current_tagblock(oparg_T *oap, long count_arg, bool include)
+{
+  long count = count_arg;
+  pos_T old_pos;
+  pos_T start_pos;
+  pos_T end_pos;
+  pos_T old_start, old_end;
+  char_u *p;
+  char_u *cp;
+  int len;
+  bool do_include = include;
+  bool save_p_ws = p_ws;
+  int retval = FAIL;
+  int is_inclusive = true;
+
+  p_ws = false;
+
+  old_pos = curwin->w_cursor;
+  old_end = curwin->w_cursor;               // remember where we started
+  old_start = old_end;
+  if (!VIsual_active || *p_sel == 'e') {
+    decl(&old_end);                         // old_end is inclusive
+  }
+
+  // If we start on "<aaa>" select that block.
+  if (!VIsual_active || equalpos(VIsual, curwin->w_cursor)) {
+    setpcmark();
+
+    // ignore indent
+    while (inindent(1)) {
+      if (inc_cursor() != 0) {
+        break;
+      }
+    }
+
+    if (in_html_tag(false)) {
+      // cursor on start tag, move to its '>'
+      while (*get_cursor_pos_ptr() != '>') {
+        if (inc_cursor() < 0) {
+          break;
+        }
+      }
+    } else if (in_html_tag(true)) {
+      // cursor on end tag, move to just before it
+      while (*get_cursor_pos_ptr() != '<') {
+        if (dec_cursor() < 0) {
+          break;
+        }
+      }
+      dec_cursor();
+      old_end = curwin->w_cursor;
+    }
+  } else if (lt(VIsual, curwin->w_cursor)) {
+    old_start = VIsual;
+    curwin->w_cursor = VIsual;              // cursor at low end of Visual
+  } else {
+    old_end = VIsual;
+  }
+
+again:
+  // Search backwards for unclosed "<aaa>".
+  // Put this position in start_pos.
+  for (long n = 0; n < count; n++) {
+    if (do_searchpair("<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)",
+                      "",
+                      "</[^>]*>", BACKWARD, NULL, 0,
+                      NULL, (linenr_T)0, 0L) <= 0) {
+      curwin->w_cursor = old_pos;
+      goto theend;
+    }
+  }
+  start_pos = curwin->w_cursor;
+
+  // Search for matching "</aaa>".  First isolate the "aaa".
+  inc_cursor();
+  p = get_cursor_pos_ptr();
+  for (cp = p;
+       *cp != NUL && *cp != '>' && !ascii_iswhite(*cp);
+       MB_PTR_ADV(cp)) {}
+  len = (int)(cp - p);
+  if (len == 0) {
+    curwin->w_cursor = old_pos;
+    goto theend;
+  }
+  const size_t spat_len = (size_t)len + 39;
+  char *const spat = xmalloc(spat_len);
+  const size_t epat_len = (size_t)len + 9;
+  char *const epat = xmalloc(epat_len);
+  snprintf(spat, spat_len,
+           "<%.*s\\>\\%%(\\_s\\_[^>]\\{-}\\_[^/]>\\|\\_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);
+
+  xfree(spat);
+  xfree(epat);
+
+  if (r < 1 || lt(curwin->w_cursor, old_end)) {
+    // Can't find other end or it's before the previous end.  Could be a
+    // HTML tag that doesn't have a matching end.  Search backwards for
+    // another starting tag.
+    count = 1;
+    curwin->w_cursor = start_pos;
+    goto again;
+  }
+
+  if (do_include) {
+    // Include up to the '>'.
+    while (*get_cursor_pos_ptr() != '>') {
+      if (inc_cursor() < 0) {
+        break;
+      }
+    }
+  } else {
+    char_u *c = get_cursor_pos_ptr();
+    // Exclude the '<' of the end tag.
+    // If the closing tag is on new line, do not decrement cursor, but make
+    // operation exclusive, so that the linefeed will be selected
+    if (*c == '<' && !VIsual_active && curwin->w_cursor.col == 0) {
+      // do not decrement cursor
+      is_inclusive = false;
+    } else if (*c == '<') {
+      dec_cursor();
+    }
+  }
+  end_pos = curwin->w_cursor;
+
+  if (!do_include) {
+    // Exclude the start tag.
+    curwin->w_cursor = start_pos;
+    while (inc_cursor() >= 0) {
+      if (*get_cursor_pos_ptr() == '>') {
+        inc_cursor();
+        start_pos = curwin->w_cursor;
+        break;
+      }
+    }
+    curwin->w_cursor = end_pos;
+
+    // If we are in Visual mode and now have the same text as before set
+    // "do_include" and try again.
+    if (VIsual_active
+        && equalpos(start_pos, old_start)
+        && equalpos(end_pos, old_end)) {
+      do_include = true;
+      curwin->w_cursor = old_start;
+      count = count_arg;
+      goto again;
+    }
+  }
+
+  if (VIsual_active) {
+    // If the end is before the start there is no text between tags, select
+    // the char under the cursor.
+    if (lt(end_pos, start_pos)) {
+      curwin->w_cursor = start_pos;
+    } else if (*p_sel == 'e') {
+      inc_cursor();
+    }
+    VIsual = start_pos;
+    VIsual_mode = 'v';
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
+    showmode();
+  } else {
+    oap->start = start_pos;
+    oap->motion_type = kMTCharWise;
+    if (lt(end_pos, start_pos)) {
+      // End is before the start: there is no text between tags; operate
+      // on an empty area.
+      curwin->w_cursor = start_pos;
+      oap->inclusive = false;
+    } else {
+      oap->inclusive = is_inclusive;
+    }
+  }
+  retval = OK;
+
+theend:
+  p_ws = save_p_ws;
+  return retval;
+}
+
+/// @param include  true == include white space
+/// @param type     'p' for paragraph, 'S' for section
+int current_par(oparg_T *oap, long count, bool include, int type)
+{
+  linenr_T start_lnum;
+  linenr_T end_lnum;
+  int white_in_front;
+  int dir;
+  int start_is_white;
+  int prev_start_is_white;
+  int retval = OK;
+  int do_white = false;
+  int t;
+  int i;
+
+  if (type == 'S') {        // not implemented yet
+    return FAIL;
+  }
+
+  start_lnum = curwin->w_cursor.lnum;
+
+  // When visual area is more than one line: extend it.
+  if (VIsual_active && start_lnum != VIsual.lnum) {
+extend:
+    if (start_lnum < VIsual.lnum) {
+      dir = BACKWARD;
+    } else {
+      dir = FORWARD;
+    }
+    for (i = (int)count; --i >= 0;) {
+      if (start_lnum ==
+          (dir == BACKWARD ? 1 : curbuf->b_ml.ml_line_count)) {
+        retval = FAIL;
+        break;
+      }
+
+      prev_start_is_white = -1;
+      for (t = 0; t < 2; t++) {
+        start_lnum += dir;
+        start_is_white = linewhite(start_lnum);
+        if (prev_start_is_white == start_is_white) {
+          start_lnum -= dir;
+          break;
+        }
+        for (;;) {
+          if (start_lnum == (dir == BACKWARD
+                             ? 1 : curbuf->b_ml.ml_line_count)) {
+            break;
+          }
+          if (start_is_white != linewhite(start_lnum + dir)
+              || (!start_is_white
+                  && startPS(start_lnum + (dir > 0
+                                           ? 1 : 0), 0, 0))) {
+            break;
+          }
+          start_lnum += dir;
+        }
+        if (!include) {
+          break;
+        }
+        if (start_lnum == (dir == BACKWARD
+                           ? 1 : curbuf->b_ml.ml_line_count)) {
+          break;
+        }
+        prev_start_is_white = start_is_white;
+      }
+    }
+    curwin->w_cursor.lnum = start_lnum;
+    curwin->w_cursor.col = 0;
+    return retval;
+  }
+
+  // First move back to the start_lnum of the paragraph or white lines
+  white_in_front = linewhite(start_lnum);
+  while (start_lnum > 1) {
+    if (white_in_front) {           // stop at first white line
+      if (!linewhite(start_lnum - 1)) {
+        break;
+      }
+    } else {          // stop at first non-white line of start of paragraph
+      if (linewhite(start_lnum - 1) || startPS(start_lnum, 0, 0)) {
+        break;
+      }
+    }
+    start_lnum--;
+  }
+
+  // Move past the end of any white lines.
+  end_lnum = start_lnum;
+  while (end_lnum <= curbuf->b_ml.ml_line_count && linewhite(end_lnum)) {
+    end_lnum++;
+  }
+
+  end_lnum--;
+  i = (int)count;
+  if (!include && white_in_front) {
+    i--;
+  }
+  while (i--) {
+    if (end_lnum == curbuf->b_ml.ml_line_count) {
+      return FAIL;
+    }
+
+    if (!include) {
+      do_white = linewhite(end_lnum + 1);
+    }
+
+    if (include || !do_white) {
+      end_lnum++;
+      // skip to end of paragraph
+      while (end_lnum < curbuf->b_ml.ml_line_count
+             && !linewhite(end_lnum + 1)
+             && !startPS(end_lnum + 1, 0, 0)) {
+        end_lnum++;
+      }
+    }
+
+    if (i == 0 && white_in_front && include) {
+      break;
+    }
+
+    // skip to end of white lines after paragraph
+    if (include || do_white) {
+      while (end_lnum < curbuf->b_ml.ml_line_count
+             && linewhite(end_lnum + 1)) {
+        end_lnum++;
+      }
+    }
+  }
+
+  // If there are no empty lines at the end, try to find some empty lines at
+  // the start (unless that has been done already).
+  if (!white_in_front && !linewhite(end_lnum) && include) {
+    while (start_lnum > 1 && linewhite(start_lnum - 1)) {
+      start_lnum--;
+    }
+  }
+
+  if (VIsual_active) {
+    // Problem: when doing "Vipipip" nothing happens in a single white
+    // line, we get stuck there.  Trap this here.
+    if (VIsual_mode == 'V' && start_lnum == curwin->w_cursor.lnum) {
+      goto extend;
+    }
+    if (VIsual.lnum != start_lnum) {
+      VIsual.lnum = start_lnum;
+      VIsual.col = 0;
+    }
+    VIsual_mode = 'V';
+    redraw_curbuf_later(UPD_INVERTED);  // update the inversion
+    showmode();
+  } else {
+    oap->start.lnum = start_lnum;
+    oap->start.col = 0;
+    oap->motion_type = kMTLineWise;
+  }
+  curwin->w_cursor.lnum = end_lnum;
+  curwin->w_cursor.col = 0;
+
+  return OK;
+}
+
+/// Search quote char from string line[col].
+/// Quote character escaped by one of the characters in "escape" is not counted
+/// as a quote.
+///
+/// @param escape  escape characters, can be NULL
+///
+/// @return        column number of "quotechar" or -1 when not found.
+static int find_next_quote(char_u *line, int col, int quotechar, char_u *escape)
+{
+  int c;
+
+  for (;;) {
+    c = line[col];
+    if (c == NUL) {
+      return -1;
+    } else if (escape != NULL && vim_strchr((char *)escape, c)) {
+      col++;
+      if (line[col] == NUL) {
+        return -1;
+      }
+    } else if (c == quotechar) {
+      break;
+    }
+    col += utfc_ptr2len((char *)line + col);
+  }
+  return col;
+}
+
+/// Search backwards in "line" from column "col_start" to find "quotechar".
+/// Quote character escaped by one of the characters in "escape" is not counted
+/// as a quote.
+///
+/// @param escape  escape characters, can be NULL
+///
+/// @return        the found column or zero.
+static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *escape)
+{
+  int n;
+
+  while (col_start > 0) {
+    col_start--;
+    col_start -= utf_head_off(line, line + col_start);
+    n = 0;
+    if (escape != NULL) {
+      while (col_start - n > 0 && vim_strchr((char *)escape,
+                                             line[col_start - n - 1]) != NULL) {
+        n++;
+      }
+    }
+    if (n & 1) {
+      col_start -= n;           // uneven number of escape chars, skip it
+    } else if (line[col_start] == quotechar) {
+      break;
+    }
+  }
+  return col_start;
+}
+
+/// Find quote under the cursor, cursor at end.
+///
+/// @param include    true == include quote char
+/// @param quotechar  Quote character
+///
+/// @return           true if found, else false.
+bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
+  FUNC_ATTR_NONNULL_ALL
+{
+  char_u *line = get_cursor_line_ptr();
+  int col_end;
+  int col_start = curwin->w_cursor.col;
+  bool inclusive = false;
+  bool vis_empty = true;                // Visual selection <= 1 char
+  bool vis_bef_curs = false;            // Visual starts before cursor
+  bool did_exclusive_adj = false;       // adjusted pos for 'selection'
+  bool inside_quotes = false;           // Looks like "i'" done before
+  bool selected_quote = false;          // Has quote inside selection
+  int i;
+  bool restore_vis_bef = false;         // resotre VIsual on abort
+
+  // When 'selection' is "exclusive" move the cursor to where it would be
+  // with 'selection' "inclusive", so that the logic is the same for both.
+  // The cursor then is moved forward after adjusting the area.
+  if (VIsual_active) {
+    // this only works within one line
+    if (VIsual.lnum != curwin->w_cursor.lnum) {
+      return false;
+    }
+
+    vis_bef_curs = lt(VIsual, curwin->w_cursor);
+    vis_empty = equalpos(VIsual, curwin->w_cursor);
+    if (*p_sel == 'e') {
+      if (vis_bef_curs) {
+        dec_cursor();
+        did_exclusive_adj = true;
+      } else if (!vis_empty) {
+        dec(&VIsual);
+        did_exclusive_adj = true;
+      }
+      vis_empty = equalpos(VIsual, curwin->w_cursor);
+      if (!vis_bef_curs && !vis_empty) {
+        // VIsual needs to be start of Visual selection.
+        pos_T t = curwin->w_cursor;
+
+        curwin->w_cursor = VIsual;
+        VIsual = t;
+        vis_bef_curs = true;
+        restore_vis_bef = true;
+      }
+    }
+  }
+
+  if (!vis_empty) {
+    // Check if the existing selection exactly spans the text inside
+    // quotes.
+    if (vis_bef_curs) {
+      inside_quotes = VIsual.col > 0
+                      && line[VIsual.col - 1] == quotechar
+                      && line[curwin->w_cursor.col] != NUL
+                      && line[curwin->w_cursor.col + 1] == quotechar;
+      i = VIsual.col;
+      col_end = curwin->w_cursor.col;
+    } else {
+      inside_quotes = curwin->w_cursor.col > 0
+                      && line[curwin->w_cursor.col - 1] == quotechar
+                      && line[VIsual.col] != NUL
+                      && line[VIsual.col + 1] == quotechar;
+      i = curwin->w_cursor.col;
+      col_end = VIsual.col;
+    }
+
+    // Find out if we have a quote in the selection.
+    while (i <= col_end) {
+      // check for going over the end of the line, which can happen if
+      // the line was changed after the Visual area was selected.
+      if (line[i] == NUL) {
+        break;
+      }
+      if (line[i++] == quotechar) {
+        selected_quote = true;
+        break;
+      }
+    }
+  }
+
+  if (!vis_empty && line[col_start] == quotechar) {
+    // Already selecting something and on a quote character.  Find the
+    // next quoted string.
+    if (vis_bef_curs) {
+      // Assume we are on a closing quote: move to after the next
+      // opening quote.
+      col_start = find_next_quote(line, col_start + 1, quotechar, NULL);
+      if (col_start < 0) {
+        goto abort_search;
+      }
+      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
+      if (col_end < 0) {
+        // We were on a starting quote perhaps?
+        col_end = col_start;
+        col_start = curwin->w_cursor.col;
+      }
+    } else {
+      col_end = find_prev_quote(line, col_start, quotechar, NULL);
+      if (line[col_end] != quotechar) {
+        goto abort_search;
+      }
+      col_start = find_prev_quote(line, col_end, quotechar, (char_u *)curbuf->b_p_qe);
+      if (line[col_start] != quotechar) {
+        // We were on an ending quote perhaps?
+        col_start = col_end;
+        col_end = curwin->w_cursor.col;
+      }
+    }
+  } else if (line[col_start] == quotechar || !vis_empty) {
+    int first_col = col_start;
+
+    if (!vis_empty) {
+      if (vis_bef_curs) {
+        first_col = find_next_quote(line, col_start, quotechar, NULL);
+      } else {
+        first_col = find_prev_quote(line, col_start, quotechar, NULL);
+      }
+    }
+    // The cursor is on a quote, we don't know if it's the opening or
+    // closing quote.  Search from the start of the line to find out.
+    // Also do this when there is a Visual area, a' may leave the cursor
+    // in between two strings.
+    col_start = 0;
+    for (;;) {
+      // Find open quote character.
+      col_start = find_next_quote(line, col_start, quotechar, NULL);
+      if (col_start < 0 || col_start > first_col) {
+        goto abort_search;
+      }
+      // Find close quote character.
+      col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
+      if (col_end < 0) {
+        goto abort_search;
+      }
+      // If is cursor between start and end quote character, it is
+      // target text object.
+      if (col_start <= first_col && first_col <= col_end) {
+        break;
+      }
+      col_start = col_end + 1;
+    }
+  } else {
+    // Search backward for a starting quote.
+    col_start = find_prev_quote(line, col_start, quotechar, (char_u *)curbuf->b_p_qe);
+    if (line[col_start] != quotechar) {
+      // No quote before the cursor, look after the cursor.
+      col_start = find_next_quote(line, col_start, quotechar, NULL);
+      if (col_start < 0) {
+        goto abort_search;
+      }
+    }
+
+    // Find close quote character.
+    col_end = find_next_quote(line, col_start + 1, quotechar, (char_u *)curbuf->b_p_qe);
+    if (col_end < 0) {
+      goto abort_search;
+    }
+  }
+
+  // When "include" is true, include spaces after closing quote or before
+  // the starting quote.
+  if (include) {
+    if (ascii_iswhite(line[col_end + 1])) {
+      while (ascii_iswhite(line[col_end + 1])) {
+        col_end++;
+      }
+    } else {
+      while (col_start > 0 && ascii_iswhite(line[col_start - 1])) {
+        col_start--;
+      }
+    }
+  }
+
+  // Set start position.  After vi" another i" must include the ".
+  // For v2i" include the quotes.
+  if (!include && count < 2 && (vis_empty || !inside_quotes)) {
+    col_start++;
+  }
+  curwin->w_cursor.col = col_start;
+  if (VIsual_active) {
+    // Set the start of the Visual area when the Visual area was empty, we
+    // were just inside quotes or the Visual area didn't start at a quote
+    // and didn't include a quote.
+    if (vis_empty
+        || (vis_bef_curs
+            && !selected_quote
+            && (inside_quotes
+                || (line[VIsual.col] != quotechar
+                    && (VIsual.col == 0
+                        || line[VIsual.col - 1] != quotechar))))) {
+      VIsual = curwin->w_cursor;
+      redraw_curbuf_later(UPD_INVERTED);
+    }
+  } else {
+    oap->start = curwin->w_cursor;
+    oap->motion_type = kMTCharWise;
+  }
+
+  // Set end position.
+  curwin->w_cursor.col = col_end;
+  if ((include || count > 1
+       // After vi" another i" must include the ".
+       || (!vis_empty && inside_quotes)) && inc_cursor() == 2) {
+    inclusive = true;
+  }
+  if (VIsual_active) {
+    if (vis_empty || vis_bef_curs) {
+      // decrement cursor when 'selection' is not exclusive
+      if (*p_sel != 'e') {
+        dec_cursor();
+      }
+    } else {
+      // Cursor is at start of Visual area.  Set the end of the Visual
+      // area when it was just inside quotes or it didn't end at a
+      // quote.
+      if (inside_quotes
+          || (!selected_quote
+              && line[VIsual.col] != quotechar
+              && (line[VIsual.col] == NUL
+                  || line[VIsual.col + 1] != quotechar))) {
+        dec_cursor();
+        VIsual = curwin->w_cursor;
+      }
+      curwin->w_cursor.col = col_start;
+    }
+    if (VIsual_mode == 'V') {
+      VIsual_mode = 'v';
+      redraw_cmdline = true;                    // show mode later
+    }
+  } else {
+    // Set inclusive and other oap's flags.
+    oap->inclusive = inclusive;
+  }
+
+  return true;
+
+abort_search:
+  if (VIsual_active && *p_sel == 'e') {
+    if (did_exclusive_adj) {
+      inc_cursor();
+    }
+    if (restore_vis_bef) {
+      pos_T t = curwin->w_cursor;
+
+      curwin->w_cursor = VIsual;
+      VIsual = t;
+    }
+  }
+  return false;
+}
diff --git a/src/nvim/textobject.h b/src/nvim/textobject.h
new file mode 100644
index 0000000000..26f88613fd
--- /dev/null
+++ b/src/nvim/textobject.h
@@ -0,0 +1,11 @@
+#ifndef NVIM_TEXTOBJECT_H
+#define NVIM_TEXTOBJECT_H
+
+#include "nvim/normal.h"  // for oparg_T
+#include "nvim/pos.h"  // for linenr_T
+#include "nvim/vim.h"  // for Direction
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "textobject.h.generated.h"
+#endif
+#endif  // NVIM_TEXTOBJECT_H
-- 
cgit 


From 523600ea6cc1edb7b4d116fdf70437a6b7f226d1 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 27 Aug 2022 11:26:47 +0800
Subject: vim-patch:8.2.1269: language and locale code spread out (#19964)

Problem:    Language and locale code spread out.
Solution:   Move relevant code to src/locale.c. (Yegappan Lakshmanan,
            closes vim/vim#6509)
https://github.com/vim/vim/commit/054f14bbe58fece17f1a74ca63f0b37518f0b4de

Also remove redundant <locale.h> includes.
---
 src/nvim/cmdexpand.c |   1 +
 src/nvim/eval.c      |   7 +-
 src/nvim/ex_cmds2.c  | 326 +--------------------------------------------
 src/nvim/ex_cmds2.h  |   2 -
 src/nvim/ex_docmd.c  |   1 +
 src/nvim/hardcopy.c  |   5 +-
 src/nvim/locale.c    | 369 +++++++++++++++++++++++++++++++++++++++++++++++++++
 src/nvim/locale.h    |  10 ++
 src/nvim/main.c      |  38 +-----
 src/nvim/option.c    |   2 +-
 10 files changed, 392 insertions(+), 369 deletions(-)
 create mode 100644 src/nvim/locale.c
 create mode 100644 src/nvim/locale.h

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index c16ed37c9a..b55e885235 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -23,6 +23,7 @@
 #include "nvim/help.h"
 #include "nvim/highlight_group.h"
 #include "nvim/if_cscope.h"
+#include "nvim/locale.h"
 #include "nvim/lua/executor.h"
 #include "nvim/mapping.h"
 #include "nvim/menu.h"
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 848b1dd2cd..ecac7e75ae 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -6,12 +6,6 @@
 #include <math.h>
 #include <stdlib.h>
 
-#include "auto/config.h"
-
-#ifdef HAVE_LOCALE_H
-# include <locale.h>
-#endif
-
 #include "nvim/ascii.h"
 #include "nvim/autocmd.h"
 #include "nvim/buffer.h"
@@ -36,6 +30,7 @@
 #include "nvim/ex_session.h"
 #include "nvim/getchar.h"
 #include "nvim/highlight_group.h"
+#include "nvim/locale.h"
 #include "nvim/lua/executor.h"
 #include "nvim/mark.h"
 #include "nvim/memline.h"
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index dbdfc2b18a..2ed2b5519b 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -14,11 +14,6 @@
 #include "nvim/arglist.h"
 #include "nvim/ascii.h"
 #include "nvim/autocmd.h"
-#include "nvim/globals.h"
-#include "nvim/vim.h"
-#ifdef HAVE_LOCALE_H
-# include <locale.h>
-#endif
 #include "nvim/buffer.h"
 #include "nvim/change.h"
 #include "nvim/charset.h"
@@ -30,6 +25,7 @@
 #include "nvim/ex_eval.h"
 #include "nvim/ex_getln.h"
 #include "nvim/fileio.h"
+#include "nvim/globals.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
 #include "nvim/memory.h"
@@ -39,13 +35,13 @@
 #include "nvim/ops.h"
 #include "nvim/option.h"
 #include "nvim/os/fs_defs.h"
-#include "nvim/os/shell.h"
 #include "nvim/os_unix.h"
 #include "nvim/path.h"
 #include "nvim/quickfix.h"
 #include "nvim/runtime.h"
 #include "nvim/strings.h"
 #include "nvim/undo.h"
+#include "nvim/vim.h"
 #include "nvim/window.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
@@ -776,324 +772,6 @@ void ex_checktime(exarg_T *eap)
   no_check_timestamps = save_no_check_timestamps;
 }
 
-#if defined(HAVE_LOCALE_H)
-# define HAVE_GET_LOCALE_VAL
-
-static char *get_locale_val(int what)
-{
-  // Obtain the locale value from the libraries.
-  char *loc = setlocale(what, NULL);
-
-  return loc;
-}
-#endif
-
-/// @return  true when "lang" starts with a valid language name.
-///          Rejects NULL, empty string, "C", "C.UTF-8" and others.
-static bool is_valid_mess_lang(char *lang)
-{
-  return lang != NULL && ASCII_ISALPHA(lang[0]) && ASCII_ISALPHA(lang[1]);
-}
-
-/// Obtain the current messages language.  Used to set the default for
-/// 'helplang'.  May return NULL or an empty string.
-char *get_mess_lang(void)
-{
-  char *p;
-
-#ifdef HAVE_GET_LOCALE_VAL
-# if defined(LC_MESSAGES)
-  p = get_locale_val(LC_MESSAGES);
-# else
-  // This is necessary for Win32, where LC_MESSAGES is not defined and $LANG
-  // may be set to the LCID number.  LC_COLLATE is the best guess, LC_TIME
-  // and LC_MONETARY may be set differently for a Japanese working in the
-  // US.
-  p = get_locale_val(LC_COLLATE);
-# endif
-#else
-  p = os_getenv("LC_ALL");
-  if (!is_valid_mess_lang(p)) {
-    p = os_getenv("LC_MESSAGES");
-    if (!is_valid_mess_lang(p)) {
-      p = os_getenv("LANG");
-    }
-  }
-#endif
-  return is_valid_mess_lang(p) ? p : NULL;
-}
-
-// Complicated #if; matches with where get_mess_env() is used below.
-#ifdef HAVE_WORKING_LIBINTL
-/// Get the language used for messages from the environment.
-static char *get_mess_env(void)
-{
-  char *p;
-
-  p = (char *)os_getenv("LC_ALL");
-  if (p == NULL) {
-    p = (char *)os_getenv("LC_MESSAGES");
-    if (p == NULL) {
-      p = (char *)os_getenv("LANG");
-      if (p != NULL && ascii_isdigit(*p)) {
-        p = NULL;                       // ignore something like "1043"
-      }
-# ifdef HAVE_GET_LOCALE_VAL
-      if (p == NULL) {
-        p = get_locale_val(LC_CTYPE);
-      }
-# endif
-    }
-  }
-  return p;
-}
-
-#endif
-
-/// Set the "v:lang" variable according to the current locale setting.
-/// Also do "v:lc_time"and "v:ctype".
-void set_lang_var(void)
-{
-  const char *loc;
-
-#ifdef HAVE_GET_LOCALE_VAL
-  loc = get_locale_val(LC_CTYPE);
-#else
-  // setlocale() not supported: use the default value
-  loc = "C";
-#endif
-  set_vim_var_string(VV_CTYPE, loc, -1);
-
-  // When LC_MESSAGES isn't defined use the value from $LC_MESSAGES, fall
-  // back to LC_CTYPE if it's empty.
-#ifdef HAVE_WORKING_LIBINTL
-  loc = get_mess_env();
-#elif defined(LC_MESSAGES)
-  loc = get_locale_val(LC_MESSAGES);
-#else
-  // In Windows LC_MESSAGES is not defined fallback to LC_CTYPE
-  loc = get_locale_val(LC_CTYPE);
-#endif
-  set_vim_var_string(VV_LANG, loc, -1);
-
-#ifdef HAVE_GET_LOCALE_VAL
-  loc = get_locale_val(LC_TIME);
-#endif
-  set_vim_var_string(VV_LC_TIME, loc, -1);
-
-#ifdef HAVE_GET_LOCALE_VAL
-  loc = get_locale_val(LC_COLLATE);
-#else
-  // setlocale() not supported: use the default value
-  loc = "C";
-#endif
-  set_vim_var_string(VV_COLLATE, loc, -1);
-}
-
-#ifdef HAVE_WORKING_LIBINTL
-
-/// ":language":  Set the language (locale).
-///
-/// @param eap
-void ex_language(exarg_T *eap)
-{
-  char *loc;
-  char *p;
-  char *name;
-  int what = LC_ALL;
-  char *whatstr = "";
-# ifdef LC_MESSAGES
-#  define VIM_LC_MESSAGES LC_MESSAGES
-# else
-#  define VIM_LC_MESSAGES 6789
-# endif
-
-  name = eap->arg;
-
-  // Check for "messages {name}", "ctype {name}" or "time {name}" argument.
-  // Allow abbreviation, but require at least 3 characters to avoid
-  // confusion with a two letter language name "me" or "ct".
-  p = (char *)skiptowhite((char_u *)eap->arg);
-  if ((*p == NUL || ascii_iswhite(*p)) && p - eap->arg >= 3) {
-    if (STRNICMP(eap->arg, "messages", p - eap->arg) == 0) {
-      what = VIM_LC_MESSAGES;
-      name = skipwhite(p);
-      whatstr = "messages ";
-    } else if (STRNICMP(eap->arg, "ctype", p - eap->arg) == 0) {
-      what = LC_CTYPE;
-      name = skipwhite(p);
-      whatstr = "ctype ";
-    } else if (STRNICMP(eap->arg, "time", p - eap->arg) == 0) {
-      what = LC_TIME;
-      name = skipwhite(p);
-      whatstr = "time ";
-    } else if (STRNICMP(eap->arg, "collate", p - eap->arg) == 0) {
-      what = LC_COLLATE;
-      name = skipwhite(p);
-      whatstr = "collate ";
-    }
-  }
-
-  if (*name == NUL) {
-    if (what == VIM_LC_MESSAGES) {
-      p = get_mess_env();
-    } else {
-      p = setlocale(what, NULL);
-    }
-    if (p == NULL || *p == NUL) {
-      p = "Unknown";
-    }
-    smsg(_("Current %slanguage: \"%s\""), whatstr, p);
-  } else {
-# ifndef LC_MESSAGES
-    if (what == VIM_LC_MESSAGES) {
-      loc = "";
-    } else {
-# endif
-    loc = setlocale(what, name);
-# ifdef LC_NUMERIC
-    // Make sure strtod() uses a decimal point, not a comma.
-    setlocale(LC_NUMERIC, "C");
-# endif
-# ifndef LC_MESSAGES
-  }
-# endif
-    if (loc == NULL) {
-      semsg(_("E197: Cannot set language to \"%s\""), name);
-    } else {
-# ifdef HAVE_NL_MSG_CAT_CNTR
-      // Need to do this for GNU gettext, otherwise cached translations
-      // will be used again.
-      extern int _nl_msg_cat_cntr;
-
-      _nl_msg_cat_cntr++;
-# endif
-      // Reset $LC_ALL, otherwise it would overrule everything.
-      os_setenv("LC_ALL", "", 1);
-
-      if (what != LC_TIME && what != LC_COLLATE) {
-        // Tell gettext() what to translate to.  It apparently doesn't
-        // use the currently effective locale.
-        if (what == LC_ALL) {
-          os_setenv("LANG", name, 1);
-
-          // Clear $LANGUAGE because GNU gettext uses it.
-          os_setenv("LANGUAGE", "", 1);
-        }
-        if (what != LC_CTYPE) {
-          os_setenv("LC_MESSAGES", name, 1);
-          set_helplang_default(name);
-        }
-      }
-
-      // Set v:lang, v:lc_time, v:collate and v:ctype to the final result.
-      set_lang_var();
-      maketitle();
-    }
-  }
-}
-
-static char **locales = NULL;       // Array of all available locales
-
-# ifndef WIN32
-static bool did_init_locales = false;
-
-/// @return  an array of strings for all available locales + NULL for the
-///          last element or,
-///          NULL in case of error.
-static char **find_locales(void)
-{
-  garray_T locales_ga;
-  char *loc;
-  char *saveptr = NULL;
-
-  // Find all available locales by running command "locale -a".  If this
-  // doesn't work we won't have completion.
-  char *locale_a = (char *)get_cmd_output((char_u *)"locale -a", NULL,
-                                          kShellOptSilent, NULL);
-  if (locale_a == NULL) {
-    return NULL;
-  }
-  ga_init(&locales_ga, sizeof(char_u *), 20);
-
-  // Transform locale_a string where each locale is separated by "\n"
-  // into an array of locale strings.
-  loc = os_strtok(locale_a, "\n", &saveptr);
-
-  while (loc != NULL) {
-    loc = xstrdup(loc);
-    GA_APPEND(char *, &locales_ga, loc);
-    loc = os_strtok(NULL, "\n", &saveptr);
-  }
-  xfree(locale_a);
-  // Guarantee that .ga_data is NULL terminated
-  ga_grow(&locales_ga, 1);
-  ((char_u **)locales_ga.ga_data)[locales_ga.ga_len] = NULL;
-  return locales_ga.ga_data;
-}
-# endif
-
-/// Lazy initialization of all available locales.
-static void init_locales(void)
-{
-# ifndef WIN32
-  if (!did_init_locales) {
-    did_init_locales = true;
-    locales = find_locales();
-  }
-# endif
-}
-
-# if defined(EXITFREE)
-void free_locales(void)
-{
-  int i;
-  if (locales != NULL) {
-    for (i = 0; locales[i] != NULL; i++) {
-      xfree(locales[i]);
-    }
-    XFREE_CLEAR(locales);
-  }
-}
-
-# endif
-
-/// Function given to ExpandGeneric() to obtain the possible arguments of the
-/// ":language" command.
-char *get_lang_arg(expand_T *xp, int idx)
-{
-  if (idx == 0) {
-    return "messages";
-  }
-  if (idx == 1) {
-    return "ctype";
-  }
-  if (idx == 2) {
-    return "time";
-  }
-  if (idx == 3) {
-    return "collate";
-  }
-
-  init_locales();
-  if (locales == NULL) {
-    return NULL;
-  }
-  return locales[idx - 4];
-}
-
-/// Function given to ExpandGeneric() to obtain the available locales.
-char *get_locales(expand_T *xp, int idx)
-{
-  init_locales();
-  if (locales == NULL) {
-    return NULL;
-  }
-  return locales[idx];
-}
-
-#endif
-
 static void script_host_execute(char *name, exarg_T *eap)
 {
   size_t len;
diff --git a/src/nvim/ex_cmds2.h b/src/nvim/ex_cmds2.h
index e454a30028..3a41e105f3 100644
--- a/src/nvim/ex_cmds2.h
+++ b/src/nvim/ex_cmds2.h
@@ -1,8 +1,6 @@
 #ifndef NVIM_EX_CMDS2_H
 #define NVIM_EX_CMDS2_H
 
-#include <stdbool.h>
-
 #include "nvim/ex_cmds_defs.h"
 
 //
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 12e2656996..eadde7a725 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -47,6 +47,7 @@
 #include "nvim/if_cscope.h"
 #include "nvim/input.h"
 #include "nvim/keycodes.h"
+#include "nvim/locale.h"
 #include "nvim/lua/executor.h"
 #include "nvim/main.h"
 #include "nvim/mapping.h"
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 5451b4f4fd..6f98e25f56 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -10,10 +10,6 @@
 #include <string.h>
 
 #include "nvim/ascii.h"
-#include "nvim/vim.h"
-#ifdef HAVE_LOCALE_H
-# include <locale.h>
-#endif
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
 #include "nvim/eval.h"
@@ -38,6 +34,7 @@
 #include "nvim/syntax.h"
 #include "nvim/ui.h"
 #include "nvim/version.h"
+#include "nvim/vim.h"
 
 /*
  * To implement printing on a platform, the following functions must be
diff --git a/src/nvim/locale.c b/src/nvim/locale.c
new file mode 100644
index 0000000000..ba0566011c
--- /dev/null
+++ b/src/nvim/locale.c
@@ -0,0 +1,369 @@
+// 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
+
+// locale.c: functions for language/locale configuration
+
+#include "auto/config.h"
+
+#ifdef HAVE_LOCALE_H
+# include <locale.h>
+#endif
+
+#include "nvim/ascii.h"
+#include "nvim/buffer.h"
+#include "nvim/charset.h"
+#include "nvim/eval.h"
+#include "nvim/garray.h"
+#include "nvim/locale.h"
+#include "nvim/memory.h"
+#include "nvim/message.h"
+#include "nvim/option.h"
+#include "nvim/os/os.h"
+#include "nvim/os/shell.h"
+#include "nvim/path.h"
+#include "nvim/profile.h"
+#include "nvim/types.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "locale.c.generated.h"
+#endif
+
+#if defined(HAVE_LOCALE_H)
+# define HAVE_GET_LOCALE_VAL
+
+static char *get_locale_val(int what)
+{
+  // Obtain the locale value from the libraries.
+  char *loc = setlocale(what, NULL);
+
+  return loc;
+}
+#endif
+
+/// @return  true when "lang" starts with a valid language name.
+///          Rejects NULL, empty string, "C", "C.UTF-8" and others.
+static bool is_valid_mess_lang(char *lang)
+{
+  return lang != NULL && ASCII_ISALPHA(lang[0]) && ASCII_ISALPHA(lang[1]);
+}
+
+/// Obtain the current messages language.  Used to set the default for
+/// 'helplang'.  May return NULL or an empty string.
+char *get_mess_lang(void)
+{
+  char *p;
+
+#ifdef HAVE_GET_LOCALE_VAL
+# if defined(LC_MESSAGES)
+  p = get_locale_val(LC_MESSAGES);
+# else
+  // This is necessary for Win32, where LC_MESSAGES is not defined and $LANG
+  // may be set to the LCID number.  LC_COLLATE is the best guess, LC_TIME
+  // and LC_MONETARY may be set differently for a Japanese working in the
+  // US.
+  p = get_locale_val(LC_COLLATE);
+# endif
+#else
+  p = os_getenv("LC_ALL");
+  if (!is_valid_mess_lang(p)) {
+    p = os_getenv("LC_MESSAGES");
+    if (!is_valid_mess_lang(p)) {
+      p = os_getenv("LANG");
+    }
+  }
+#endif
+  return is_valid_mess_lang(p) ? p : NULL;
+}
+
+// Complicated #if; matches with where get_mess_env() is used below.
+#ifdef HAVE_WORKING_LIBINTL
+/// Get the language used for messages from the environment.
+static char *get_mess_env(void)
+{
+  char *p;
+
+  p = (char *)os_getenv("LC_ALL");
+  if (p == NULL) {
+    p = (char *)os_getenv("LC_MESSAGES");
+    if (p == NULL) {
+      p = (char *)os_getenv("LANG");
+      if (p != NULL && ascii_isdigit(*p)) {
+        p = NULL;                       // ignore something like "1043"
+      }
+# ifdef HAVE_GET_LOCALE_VAL
+      if (p == NULL) {
+        p = get_locale_val(LC_CTYPE);
+      }
+# endif
+    }
+  }
+  return p;
+}
+#endif
+
+/// Set the "v:lang" variable according to the current locale setting.
+/// Also do "v:lc_time"and "v:ctype".
+void set_lang_var(void)
+{
+  const char *loc;
+
+#ifdef HAVE_GET_LOCALE_VAL
+  loc = get_locale_val(LC_CTYPE);
+#else
+  // setlocale() not supported: use the default value
+  loc = "C";
+#endif
+  set_vim_var_string(VV_CTYPE, loc, -1);
+
+  // When LC_MESSAGES isn't defined use the value from $LC_MESSAGES, fall
+  // back to LC_CTYPE if it's empty.
+#ifdef HAVE_WORKING_LIBINTL
+  loc = get_mess_env();
+#elif defined(LC_MESSAGES)
+  loc = get_locale_val(LC_MESSAGES);
+#else
+  // In Windows LC_MESSAGES is not defined fallback to LC_CTYPE
+  loc = get_locale_val(LC_CTYPE);
+#endif
+  set_vim_var_string(VV_LANG, loc, -1);
+
+#ifdef HAVE_GET_LOCALE_VAL
+  loc = get_locale_val(LC_TIME);
+#endif
+  set_vim_var_string(VV_LC_TIME, loc, -1);
+
+#ifdef HAVE_GET_LOCALE_VAL
+  loc = get_locale_val(LC_COLLATE);
+#else
+  // setlocale() not supported: use the default value
+  loc = "C";
+#endif
+  set_vim_var_string(VV_COLLATE, loc, -1);
+}
+
+#if defined(HAVE_LOCALE_H)
+/// Setup to use the current locale (for ctype() and many other things).
+void init_locale(void)
+{
+  setlocale(LC_ALL, "");
+
+# ifdef LC_NUMERIC
+  // Make sure strtod() uses a decimal point, not a comma.
+  setlocale(LC_NUMERIC, "C");
+# endif
+
+  char localepath[MAXPATHL] = { 0 };
+  snprintf(localepath, sizeof(localepath), "%s", get_vim_var_str(VV_PROGPATH));
+  char *tail = path_tail_with_sep(localepath);
+  *tail = NUL;
+  tail = path_tail(localepath);
+  xstrlcpy(tail, "share/locale",
+           sizeof(localepath) - (size_t)(tail - localepath));
+  bindtextdomain(PROJECT_NAME, localepath);
+  textdomain(PROJECT_NAME);
+  TIME_MSG("locale set");
+}
+#endif
+
+#ifdef HAVE_WORKING_LIBINTL
+
+/// ":language":  Set the language (locale).
+///
+/// @param eap
+void ex_language(exarg_T *eap)
+{
+  char *loc;
+  char *p;
+  char *name;
+  int what = LC_ALL;
+  char *whatstr = "";
+# ifdef LC_MESSAGES
+#  define VIM_LC_MESSAGES LC_MESSAGES
+# else
+#  define VIM_LC_MESSAGES 6789
+# endif
+
+  name = eap->arg;
+
+  // Check for "messages {name}", "ctype {name}" or "time {name}" argument.
+  // Allow abbreviation, but require at least 3 characters to avoid
+  // confusion with a two letter language name "me" or "ct".
+  p = (char *)skiptowhite((char_u *)eap->arg);
+  if ((*p == NUL || ascii_iswhite(*p)) && p - eap->arg >= 3) {
+    if (STRNICMP(eap->arg, "messages", p - eap->arg) == 0) {
+      what = VIM_LC_MESSAGES;
+      name = skipwhite(p);
+      whatstr = "messages ";
+    } else if (STRNICMP(eap->arg, "ctype", p - eap->arg) == 0) {
+      what = LC_CTYPE;
+      name = skipwhite(p);
+      whatstr = "ctype ";
+    } else if (STRNICMP(eap->arg, "time", p - eap->arg) == 0) {
+      what = LC_TIME;
+      name = skipwhite(p);
+      whatstr = "time ";
+    } else if (STRNICMP(eap->arg, "collate", p - eap->arg) == 0) {
+      what = LC_COLLATE;
+      name = skipwhite(p);
+      whatstr = "collate ";
+    }
+  }
+
+  if (*name == NUL) {
+    if (what == VIM_LC_MESSAGES) {
+      p = get_mess_env();
+    } else {
+      p = setlocale(what, NULL);
+    }
+    if (p == NULL || *p == NUL) {
+      p = "Unknown";
+    }
+    smsg(_("Current %slanguage: \"%s\""), whatstr, p);
+  } else {
+# ifndef LC_MESSAGES
+    if (what == VIM_LC_MESSAGES) {
+      loc = "";
+    } else {
+# endif
+    loc = setlocale(what, name);
+# ifdef LC_NUMERIC
+    // Make sure strtod() uses a decimal point, not a comma.
+    setlocale(LC_NUMERIC, "C");
+# endif
+# ifndef LC_MESSAGES
+  }
+# endif
+    if (loc == NULL) {
+      semsg(_("E197: Cannot set language to \"%s\""), name);
+    } else {
+# ifdef HAVE_NL_MSG_CAT_CNTR
+      // Need to do this for GNU gettext, otherwise cached translations
+      // will be used again.
+      extern int _nl_msg_cat_cntr;
+
+      _nl_msg_cat_cntr++;
+# endif
+      // Reset $LC_ALL, otherwise it would overrule everything.
+      os_setenv("LC_ALL", "", 1);
+
+      if (what != LC_TIME && what != LC_COLLATE) {
+        // Tell gettext() what to translate to.  It apparently doesn't
+        // use the currently effective locale.
+        if (what == LC_ALL) {
+          os_setenv("LANG", name, 1);
+
+          // Clear $LANGUAGE because GNU gettext uses it.
+          os_setenv("LANGUAGE", "", 1);
+        }
+        if (what != LC_CTYPE) {
+          os_setenv("LC_MESSAGES", name, 1);
+          set_helplang_default(name);
+        }
+      }
+
+      // Set v:lang, v:lc_time, v:collate and v:ctype to the final result.
+      set_lang_var();
+      maketitle();
+    }
+  }
+}
+
+static char **locales = NULL;       // Array of all available locales
+
+# ifndef WIN32
+static bool did_init_locales = false;
+
+/// @return  an array of strings for all available locales + NULL for the
+///          last element or,
+///          NULL in case of error.
+static char **find_locales(void)
+{
+  garray_T locales_ga;
+  char *loc;
+  char *saveptr = NULL;
+
+  // Find all available locales by running command "locale -a".  If this
+  // doesn't work we won't have completion.
+  char *locale_a = (char *)get_cmd_output((char_u *)"locale -a", NULL,
+                                          kShellOptSilent, NULL);
+  if (locale_a == NULL) {
+    return NULL;
+  }
+  ga_init(&locales_ga, sizeof(char_u *), 20);
+
+  // Transform locale_a string where each locale is separated by "\n"
+  // into an array of locale strings.
+  loc = os_strtok(locale_a, "\n", &saveptr);
+
+  while (loc != NULL) {
+    loc = xstrdup(loc);
+    GA_APPEND(char *, &locales_ga, loc);
+    loc = os_strtok(NULL, "\n", &saveptr);
+  }
+  xfree(locale_a);
+  // Guarantee that .ga_data is NULL terminated
+  ga_grow(&locales_ga, 1);
+  ((char_u **)locales_ga.ga_data)[locales_ga.ga_len] = NULL;
+  return locales_ga.ga_data;
+}
+# endif
+
+/// Lazy initialization of all available locales.
+static void init_locales(void)
+{
+# ifndef WIN32
+  if (!did_init_locales) {
+    did_init_locales = true;
+    locales = find_locales();
+  }
+# endif
+}
+
+# if defined(EXITFREE)
+void free_locales(void)
+{
+  int i;
+  if (locales != NULL) {
+    for (i = 0; locales[i] != NULL; i++) {
+      xfree(locales[i]);
+    }
+    XFREE_CLEAR(locales);
+  }
+}
+# endif
+
+/// Function given to ExpandGeneric() to obtain the possible arguments of the
+/// ":language" command.
+char *get_lang_arg(expand_T *xp, int idx)
+{
+  if (idx == 0) {
+    return "messages";
+  }
+  if (idx == 1) {
+    return "ctype";
+  }
+  if (idx == 2) {
+    return "time";
+  }
+  if (idx == 3) {
+    return "collate";
+  }
+
+  init_locales();
+  if (locales == NULL) {
+    return NULL;
+  }
+  return locales[idx - 4];
+}
+
+/// Function given to ExpandGeneric() to obtain the available locales.
+char *get_locales(expand_T *xp, int idx)
+{
+  init_locales();
+  if (locales == NULL) {
+    return NULL;
+  }
+  return locales[idx];
+}
+
+#endif
diff --git a/src/nvim/locale.h b/src/nvim/locale.h
new file mode 100644
index 0000000000..39735d371f
--- /dev/null
+++ b/src/nvim/locale.h
@@ -0,0 +1,10 @@
+#ifndef NVIM_LOCALE_H
+#define NVIM_LOCALE_H
+
+#include "nvim/ex_cmds_defs.h"
+#include "nvim/types.h"
+
+#ifdef INCLUDE_GENERATED_DECLARATIONS
+# include "locale.h.generated.h"
+#endif
+#endif  // NVIM_LOCALE_H
diff --git a/src/nvim/main.c b/src/nvim/main.c
index efa1f8e350..e2e150a892 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -25,23 +25,19 @@
 #include "nvim/ex_getln.h"
 #include "nvim/fileio.h"
 #include "nvim/fold.h"
+#include "nvim/garray.h"
+#include "nvim/grid.h"
 #include "nvim/hashtab.h"
 #include "nvim/highlight.h"
 #include "nvim/highlight_group.h"
 #include "nvim/iconv.h"
 #include "nvim/if_cscope.h"
 #include "nvim/insexpand.h"
+#include "nvim/locale.h"
+#include "nvim/log.h"
 #include "nvim/lua/executor.h"
 #include "nvim/main.h"
 #include "nvim/mapping.h"
-#include "nvim/ui_client.h"
-#include "nvim/vim.h"
-#ifdef HAVE_LOCALE_H
-# include <locale.h>
-#endif
-#include "nvim/garray.h"
-#include "nvim/grid.h"
-#include "nvim/log.h"
 #include "nvim/mark.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
@@ -70,8 +66,10 @@
 #include "nvim/strings.h"
 #include "nvim/syntax.h"
 #include "nvim/ui.h"
+#include "nvim/ui_client.h"
 #include "nvim/ui_compositor.h"
 #include "nvim/version.h"
+#include "nvim/vim.h"
 #include "nvim/window.h"
 #ifdef WIN32
 # include "nvim/os/os_win_console.h"
@@ -801,30 +799,6 @@ static int get_number_arg(const char *p, int *idx, int def)
   return def;
 }
 
-#if defined(HAVE_LOCALE_H)
-/// Setup to use the current locale (for ctype() and many other things).
-static void init_locale(void)
-{
-  setlocale(LC_ALL, "");
-
-# ifdef LC_NUMERIC
-  // Make sure strtod() uses a decimal point, not a comma.
-  setlocale(LC_NUMERIC, "C");
-# endif
-
-  char localepath[MAXPATHL] = { 0 };
-  snprintf(localepath, sizeof(localepath), "%s", get_vim_var_str(VV_PROGPATH));
-  char *tail = path_tail_with_sep(localepath);
-  *tail = NUL;
-  tail = path_tail(localepath);
-  xstrlcpy(tail, "share/locale",
-           sizeof(localepath) - (size_t)(tail - localepath));
-  bindtextdomain(PROJECT_NAME, localepath);
-  textdomain(PROJECT_NAME);
-  TIME_MSG("locale set");
-}
-#endif
-
 static uint64_t server_connect(char *server_addr, const char **errmsg)
 {
   if (server_addr == NULL) {
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 3a5550ffc0..4bf978d2f6 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -39,7 +39,6 @@
 #include "nvim/edit.h"
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
-#include "nvim/ex_cmds2.h"
 #include "nvim/ex_docmd.h"
 #include "nvim/ex_getln.h"
 #include "nvim/ex_session.h"
@@ -53,6 +52,7 @@
 #include "nvim/indent.h"
 #include "nvim/indent_c.h"
 #include "nvim/keycodes.h"
+#include "nvim/locale.h"
 #include "nvim/macros.h"
 #include "nvim/mapping.h"
 #include "nvim/mbyte.h"
-- 
cgit 


From 09c6ce8c4e4c6415cca9b834539ed0df461373f6 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Sat, 27 Aug 2022 09:56:58 +0200
Subject: docs: fix typos (#19798)

Co-authored-by: adrian5 <adrian5@users.noreply.github.com>
Co-authored-by: Eisuke Kawashima <e-kwsm@users.noreply.github.com>
---
 src/nvim/buffer_defs.h | 4 ++--
 src/nvim/mapping.c     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index d22ab266f8..58bdd2c0a8 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -366,8 +366,8 @@ struct mapblock {
   char m_nowait;                // <nowait> used
   char m_expr;                  // <expr> used, m_str is an expression
   sctx_T m_script_ctx;          // SCTX where map was defined
-  char *m_desc;                 // description of keymap
-  bool m_replace_keycodes;      // replace termcodes in lua function
+  char *m_desc;                 // description of mapping
+  bool m_replace_keycodes;      // replace keycodes in result of expression
 };
 
 /// Used for highlighting in the status line.
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index ef44d71165..2364a388b3 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -293,7 +293,7 @@ static bool set_maparg_lhs_rhs(const char *const orig_lhs, const size_t orig_lhs
       replaced = replace_termcodes(orig_rhs, orig_rhs_len, &rhs_buf, REPTERM_DO_LT, NULL,
                                    cpo_flags);
       mapargs->rhs_len = STRLEN(replaced);
-      // XXX: replace_termcodes may produce an empty string even if orig_rhs is non-empty
+      // NB: replace_termcodes may produce an empty string even if orig_rhs is non-empty
       // (e.g. a single ^V, see :h map-empty-rhs)
       mapargs->rhs_is_noop = orig_rhs_len != 0 && mapargs->rhs_len == 0;
       mapargs->rhs = (char_u *)replaced;
-- 
cgit 


From 20305494f8189994a6dc39cd450837a8f9e58dee Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Sat, 27 Aug 2022 14:26:12 +0200
Subject: refactor: remove redundant casts

---
 src/nvim/decoration.c |   4 +-
 src/nvim/ex_docmd.c   |   2 +-
 src/nvim/extmark.c    |   4 +-
 src/nvim/highlight.c  |   4 +-
 src/nvim/keycodes.c   | 144 +++++++++++++++++++++++++-------------------------
 src/nvim/mouse.c      |   4 +-
 6 files changed, 81 insertions(+), 81 deletions(-)

(limited to 'src')

diff --git a/src/nvim/decoration.c b/src/nvim/decoration.c
index a93fb599c4..9f3e5a8638 100644
--- a/src/nvim/decoration.c
+++ b/src/nvim/decoration.c
@@ -547,7 +547,7 @@ int decor_virt_lines(win_T *wp, linenr_T lnum, VirtLines *lines)
   }
 
   int virt_lines = 0;
-  int row = (int)MAX(lnum - 2, 0);
+  int row = MAX(lnum - 2, 0);
   int end_row = (int)lnum;
   MarkTreeIter itr[1] = { 0 };
   marktree_itr_get(buf->b_marktree, row, 0,  itr);
@@ -558,7 +558,7 @@ int decor_virt_lines(win_T *wp, linenr_T lnum, VirtLines *lines)
     } else if (marktree_decor_level(mark) < kDecorLevelVirtLine) {
       goto next_mark;
     }
-    bool above = mark.pos.row > (int)(lnum - 2);
+    bool above = mark.pos.row > (lnum - 2);
     Decoration *decor = mark.decor_full;
     if (decor && decor->virt_lines_above == above) {
       virt_lines += (int)kv_size(decor->virt_lines);
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index eadde7a725..0d74ff6574 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3088,7 +3088,7 @@ cmdidx_T excmd_get_cmdidx(const char *cmd, size_t len)
 {
   cmdidx_T idx;
 
-  for (idx = (cmdidx_T)0; (int)idx < (int)CMD_SIZE; idx = (cmdidx_T)((int)idx + 1)) {
+  for (idx = (cmdidx_T)0; (int)idx < CMD_SIZE; idx = (cmdidx_T)((int)idx + 1)) {
     if (strncmp(cmdnames[(int)idx].cmd_name, cmd, len) == 0) {
       break;
     }
diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c
index 1639f72990..8e780f4aaa 100644
--- a/src/nvim/extmark.c
+++ b/src/nvim/extmark.c
@@ -510,11 +510,11 @@ void extmark_adjust(buf_T *buf, linenr_T line1, linenr_T line2, linenr_T amount,
   bcount_t old_byte = 0, new_byte = 0;
   int old_row, new_row;
   if (amount == MAXLNUM) {
-    old_row = (int)(line2 - line1 + 1);
+    old_row = line2 - line1 + 1;
     // TODO(bfredl): ej kasta?
     old_byte = (bcount_t)buf->deleted_bytes2;
 
-    new_row = (int)(amount_after + old_row);
+    new_row = amount_after + old_row;
   } else {
     // A region is either deleted (amount == MAXLNUM) or
     // added (line2 == MAXLNUM). The only other case is :move
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index c5a84c731d..4848668351 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -223,7 +223,7 @@ int ns_get_hl(NS *ns_hl, int hl_id, bool link, bool nodefault)
       }
     }
 
-    it.attr_id = fallback ? -1 : hl_get_syn_attr((int)ns_id, hl_id, attrs);
+    it.attr_id = fallback ? -1 : hl_get_syn_attr(ns_id, hl_id, attrs);
     it.version = p->hl_valid - tmp;
     it.is_default = attrs.rgb_ae_attr & HL_DEFAULT;
     it.link_global = attrs.rgb_ae_attr & HL_GLOBAL;
@@ -406,7 +406,7 @@ void update_ns_hl(int ns_id)
   }
   int *hl_attrs = **alloc;
 
-  for (int hlf = 0; hlf < (int)HLF_COUNT; hlf++) {
+  for (int hlf = 0; hlf < HLF_COUNT; hlf++) {
     int id = syn_check_group(hlf_names[hlf], STRLEN(hlf_names[hlf]));
     bool optional = (hlf == HLF_INACTIVE || hlf == HLF_NFLOAT);
     hl_attrs[hlf] = hl_get_ui_attr(ns_id, hlf, id, optional);
diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index 5a5257efb2..2b00d371f0 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -57,15 +57,15 @@ static char_u modifier_keys_table[] =
   MOD_MASK_SHIFT, '*', '4',                   'k', 'D',         // delete char
   MOD_MASK_SHIFT, '*', '5',                   'k', 'L',         // delete line
   MOD_MASK_SHIFT, '*', '7',                   '@', '7',         // end
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_END,    '@', '7',         // end
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_END,         '@', '7',         // end
   MOD_MASK_SHIFT, '*', '9',                   '@', '9',         // exit
   MOD_MASK_SHIFT, '*', '0',                   '@', '0',         // find
   MOD_MASK_SHIFT, '#', '1',                   '%', '1',         // help
   MOD_MASK_SHIFT, '#', '2',                   'k', 'h',         // home
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_HOME,   'k', 'h',         // home
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_HOME,        'k', 'h',         // home
   MOD_MASK_SHIFT, '#', '3',                   'k', 'I',         // insert
   MOD_MASK_SHIFT, '#', '4',                   'k', 'l',         // left arrow
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_LEFT,   'k', 'l',         // left arrow
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_LEFT,        'k', 'l',         // left arrow
   MOD_MASK_SHIFT, '%', 'a',                   '%', '3',         // message
   MOD_MASK_SHIFT, '%', 'b',                   '%', '4',         // move
   MOD_MASK_SHIFT, '%', 'c',                   '%', '5',         // next
@@ -75,63 +75,63 @@ static char_u modifier_keys_table[] =
   MOD_MASK_SHIFT, '%', 'g',                   '%', '0',         // redo
   MOD_MASK_SHIFT, '%', 'h',                   '&', '3',         // replace
   MOD_MASK_SHIFT, '%', 'i',                   'k', 'r',         // right arr.
-  MOD_MASK_CTRL,  KS_EXTRA, (int)KE_C_RIGHT,  'k', 'r',         // right arr.
+  MOD_MASK_CTRL,  KS_EXTRA, KE_C_RIGHT,       'k', 'r',         // right arr.
   MOD_MASK_SHIFT, '%', 'j',                   '&', '5',         // resume
   MOD_MASK_SHIFT, '!', '1',                   '&', '6',         // save
   MOD_MASK_SHIFT, '!', '2',                   '&', '7',         // suspend
   MOD_MASK_SHIFT, '!', '3',                   '&', '8',         // undo
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_UP,     'k', 'u',         // up arrow
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_DOWN,   'k', 'd',         // down arrow
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_UP,          'k', 'u',         // up arrow
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_DOWN,        'k', 'd',         // down arrow
 
   // vt100 F1
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF1,    KS_EXTRA, (int)KE_XF1,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF2,    KS_EXTRA, (int)KE_XF2,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF3,    KS_EXTRA, (int)KE_XF3,
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_XF4,    KS_EXTRA, (int)KE_XF4,
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F1,     'k', '1',         // F1
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F2,     'k', '2',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F3,     'k', '3',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F4,     'k', '4',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F5,     'k', '5',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F6,     'k', '6',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F7,     'k', '7',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F8,     'k', '8',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F9,     'k', '9',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F10,    'k', ';',         // F10
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F11,    'F', '1',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F12,    'F', '2',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F13,    'F', '3',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F14,    'F', '4',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F15,    'F', '5',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F16,    'F', '6',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F17,    'F', '7',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F18,    'F', '8',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F19,    'F', '9',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F20,    'F', 'A',
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F21,    'F', 'B',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F22,    'F', 'C',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F23,    'F', 'D',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F24,    'F', 'E',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F25,    'F', 'F',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F26,    'F', 'G',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F27,    'F', 'H',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F28,    'F', 'I',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F29,    'F', 'J',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F30,    'F', 'K',
-
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F31,    'F', 'L',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F32,    'F', 'M',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F33,    'F', 'N',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F34,    'F', 'O',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F35,    'F', 'P',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F36,    'F', 'Q',
-  MOD_MASK_SHIFT, KS_EXTRA, (int)KE_S_F37,    'F', 'R',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF1,         KS_EXTRA, KE_XF1,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF2,         KS_EXTRA, KE_XF2,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF3,         KS_EXTRA, KE_XF3,
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_XF4,         KS_EXTRA, KE_XF4,
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F1,          'k', '1',         // F1
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F2,          'k', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F3,          'k', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F4,          'k', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F5,          'k', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F6,          'k', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F7,          'k', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F8,          'k', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F9,          'k', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F10,         'k', ';',         // F10
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F11,         'F', '1',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F12,         'F', '2',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F13,         'F', '3',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F14,         'F', '4',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F15,         'F', '5',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F16,         'F', '6',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F17,         'F', '7',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F18,         'F', '8',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F19,         'F', '9',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F20,         'F', 'A',
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F21,         'F', 'B',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F22,         'F', 'C',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F23,         'F', 'D',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F24,         'F', 'E',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F25,         'F', 'F',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F26,         'F', 'G',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F27,         'F', 'H',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F28,         'F', 'I',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F29,         'F', 'J',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F30,         'F', 'K',
+
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F31,         'F', 'L',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F32,         'F', 'M',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F33,         'F', 'N',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F34,         'F', 'O',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F35,         'F', 'P',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F36,         'F', 'Q',
+  MOD_MASK_SHIFT, KS_EXTRA, KE_S_F37,         'F', 'R',
 
   // TAB pseudo code
-  MOD_MASK_SHIFT, 'k', 'B',                   KS_EXTRA, (int)KE_TAB,
+  MOD_MASK_SHIFT, 'k', 'B',                   KS_EXTRA, KE_TAB,
 
   NUL
 };
@@ -349,26 +349,26 @@ static struct mousetable {
   bool is_drag;               // Is it a mouse drag event?
 } mouse_table[] =
 {
-  { (int)KE_LEFTMOUSE,        MOUSE_LEFT,     true,   false },
-  { (int)KE_LEFTDRAG,         MOUSE_LEFT,     false,  true },
-  { (int)KE_LEFTRELEASE,      MOUSE_LEFT,     false,  false },
-  { (int)KE_MIDDLEMOUSE,      MOUSE_MIDDLE,   true,   false },
-  { (int)KE_MIDDLEDRAG,       MOUSE_MIDDLE,   false,  true },
-  { (int)KE_MIDDLERELEASE,    MOUSE_MIDDLE,   false,  false },
-  { (int)KE_RIGHTMOUSE,       MOUSE_RIGHT,    true,   false },
-  { (int)KE_RIGHTDRAG,        MOUSE_RIGHT,    false,  true },
-  { (int)KE_RIGHTRELEASE,     MOUSE_RIGHT,    false,  false },
-  { (int)KE_X1MOUSE,          MOUSE_X1,       true,   false },
-  { (int)KE_X1DRAG,           MOUSE_X1,       false,  true },
-  { (int)KE_X1RELEASE,        MOUSE_X1,       false,  false },
-  { (int)KE_X2MOUSE,          MOUSE_X2,       true,   false },
-  { (int)KE_X2DRAG,           MOUSE_X2,       false,  true },
-  { (int)KE_X2RELEASE,        MOUSE_X2,       false,  false },
+  { KE_LEFTMOUSE,        MOUSE_LEFT,     true,   false },
+  { KE_LEFTDRAG,         MOUSE_LEFT,     false,  true },
+  { KE_LEFTRELEASE,      MOUSE_LEFT,     false,  false },
+  { KE_MIDDLEMOUSE,      MOUSE_MIDDLE,   true,   false },
+  { KE_MIDDLEDRAG,       MOUSE_MIDDLE,   false,  true },
+  { KE_MIDDLERELEASE,    MOUSE_MIDDLE,   false,  false },
+  { KE_RIGHTMOUSE,       MOUSE_RIGHT,    true,   false },
+  { KE_RIGHTDRAG,        MOUSE_RIGHT,    false,  true },
+  { KE_RIGHTRELEASE,     MOUSE_RIGHT,    false,  false },
+  { KE_X1MOUSE,          MOUSE_X1,       true,   false },
+  { KE_X1DRAG,           MOUSE_X1,       false,  true },
+  { KE_X1RELEASE,        MOUSE_X1,       false,  false },
+  { KE_X2MOUSE,          MOUSE_X2,       true,   false },
+  { KE_X2DRAG,           MOUSE_X2,       false,  true },
+  { KE_X2RELEASE,        MOUSE_X2,       false,  false },
   // DRAG without CLICK
-  { (int)KE_MOUSEMOVE,        MOUSE_RELEASE,  false,  true },
+  { KE_MOUSEMOVE,        MOUSE_RELEASE,  false,  true },
   // RELEASE without CLICK
-  { (int)KE_IGNORE,           MOUSE_RELEASE,  false,  false },
-  { 0,                        0,              0,      0 },
+  { KE_IGNORE,           MOUSE_RELEASE,  false,  false },
+  { 0,                   0,              0,      0 },
 };
 
 /// Return the modifier mask bit (#MOD_MASK_*) corresponding to mod name
@@ -926,8 +926,8 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
         } else {
           src += 5;
           result[dlen++] = K_SPECIAL;
-          result[dlen++] = (int)KS_EXTRA;
-          result[dlen++] = (int)KE_SNR;
+          result[dlen++] = KS_EXTRA;
+          result[dlen++] = KE_SNR;
           snprintf((char *)result + dlen, buf_len - dlen, "%" PRId64,
                    (int64_t)current_sctx.sc_sid);
           dlen += STRLEN(result + dlen);
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 3dfbeec048..cc833dc3c0 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -702,8 +702,8 @@ static linenr_T find_longest_lnum(void)
         max = len;
         ret = lnum;
       } else if (len == (colnr_T)max
-                 && abs((int)(lnum - curwin->w_cursor.lnum))
-                 < abs((int)(ret - curwin->w_cursor.lnum))) {
+                 && abs(lnum - curwin->w_cursor.lnum)
+                 < abs(ret - curwin->w_cursor.lnum)) {
         ret = lnum;
       }
     }
-- 
cgit 


From 691f4715c0cf4bc11ea2280db8777e6dd174a8ac Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/buffer.c      |   2 +-
 src/nvim/charset.c     |   2 +-
 src/nvim/cmdexpand.c   |   2 +-
 src/nvim/debugger.c    |   2 +-
 src/nvim/diff.c        |   2 +-
 src/nvim/edit.c        |   6 +-
 src/nvim/eval/funcs.c  |   6 +-
 src/nvim/ex_cmds.c     |   4 +-
 src/nvim/ex_docmd.c    |  16 +--
 src/nvim/ex_getln.c    |   2 +-
 src/nvim/file_search.c |  12 +--
 src/nvim/fileio.c      |  12 +--
 src/nvim/garray.h      |   2 +-
 src/nvim/getchar.c     |   4 +-
 src/nvim/globals.h     |  16 +--
 src/nvim/help.c        |   2 +-
 src/nvim/highlight.c   |   2 +-
 src/nvim/indent.c      |  13 +--
 src/nvim/insexpand.c   |  29 +++---
 src/nvim/lua/stdlib.c  |   4 +-
 src/nvim/main.c        |   2 +-
 src/nvim/mark.c        |   4 +-
 src/nvim/mbyte.c       |  22 ++---
 src/nvim/memfile.c     |  10 +-
 src/nvim/memline.c     |  20 ++--
 src/nvim/message.c     |   2 +-
 src/nvim/normal.c      |   4 +-
 src/nvim/normal.h      |   4 +-
 src/nvim/ops.c         |  12 +--
 src/nvim/option.c      | 264 +++++++++++++++++++++++--------------------------
 src/nvim/option_defs.h |  86 ++++++++--------
 src/nvim/optionstr.c   | 230 +++++++++++++++++++++---------------------
 src/nvim/quickfix.c    |   8 +-
 src/nvim/runtime.c     |   2 +-
 src/nvim/screen.c      |  30 +++---
 src/nvim/shada.c       |   2 +-
 src/nvim/spell.c       |  12 +--
 src/nvim/spellfile.c   |  42 ++++----
 src/nvim/statusline.c  |   4 +-
 src/nvim/syntax.c      |  65 ++++++------
 src/nvim/tag.c         |  52 +++++-----
 41 files changed, 497 insertions(+), 520 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 514be4c56b..5dc7083a01 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -2701,7 +2701,7 @@ void buflist_list(exarg_T *eap)
       home_replace(buf, buf->b_fname, (char *)NameBuff, MAXPATHL, true);
     }
 
-    if (message_filtered(NameBuff)) {
+    if (message_filtered((char_u *)NameBuff)) {
       continue;
     }
 
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index dc62b85716..df951854e0 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -246,7 +246,7 @@ int buf_init_chartab(buf_T *buf, int global)
       }
 
       c = *p;
-      p = skip_to_option_part(p);
+      p = (char_u *)skip_to_option_part((char *)p);
 
       if ((c == ',') && (*p == NUL)) {
         // Trailing comma is not allowed.
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index b55e885235..7f9a8b2a5c 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -705,7 +705,7 @@ int showmatches(expand_T *xp, int wildmenu)
             p = (char_u *)L_SHOWFILE(k);
           } else {
             home_replace(NULL, files_found[k], (char *)NameBuff, MAXPATHL, true);
-            p = NameBuff;
+            p = (char_u *)NameBuff;
           }
         } else {
           j = false;
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index d2f4910e14..9aee023f0c 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -703,7 +703,7 @@ void ex_breaklist(exarg_T *eap)
         smsg(_("%3d  %s %s  line %" PRId64),
              bp->dbg_nr,
              bp->dbg_type == DBG_FUNC ? "func" : "file",
-             bp->dbg_type == DBG_FUNC ? bp->dbg_name : NameBuff,
+             bp->dbg_type == DBG_FUNC ? bp->dbg_name : (char_u *)NameBuff,
              (int64_t)bp->dbg_lnum);
       } else {
         smsg(_("%3d  expr %s"), bp->dbg_nr, bp->dbg_name);
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 8107b64c83..23fdc728f3 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -1148,7 +1148,7 @@ static int diff_file(diffio_T *dio)
                  (diff_flags & DIFF_IBLANK) ? "-B " : "",
                  (diff_flags & DIFF_ICASE) ? "-i " : "",
                  tmp_orig, tmp_new);
-    append_redir(cmd, len, (char *)p_srr, tmp_diff);
+    append_redir(cmd, len, p_srr, tmp_diff);
     block_autocmds();  // Avoid ShellCmdPost stuff
     (void)call_shell((char_u *)cmd,
                      kShellOptFilter | kShellOptSilent | kShellOptDoOut,
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index ed625e1d6e..adcf9cd075 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -3282,10 +3282,8 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
       }
     }
 
-    /*
-     * Skip over ", ".
-     */
-    look = skip_to_option_part(look);
+    // Skip over ", ".
+    look = (char_u *)skip_to_option_part((char *)look);
   }
   return false;
 }
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 581f187140..22447b933a 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -3895,9 +3895,11 @@ static void f_iconv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   const char *const str = tv_get_string(&argvars[0]);
   char buf1[NUMBUFLEN];
-  char_u *const from = enc_canonize(enc_skip((char_u *)tv_get_string_buf(&argvars[1], buf1)));
+  char_u *const from =
+    (char_u *)enc_canonize((char *)enc_skip((char_u *)tv_get_string_buf(&argvars[1], buf1)));
   char buf2[NUMBUFLEN];
-  char_u *const to = enc_canonize(enc_skip((char_u *)tv_get_string_buf(&argvars[2], buf2)));
+  char_u *const to =
+    (char_u *)enc_canonize((char *)enc_skip((char_u *)tv_get_string_buf(&argvars[2], buf2)));
   vimconv.vc_type = CONV_NONE;
   convert_setup(&vimconv, from, to);
 
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index a72cddc0a9..4a1cdb0fc5 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -743,7 +743,7 @@ void ex_retab(exarg_T *eap)
   curwin->w_p_list = 0;             // don't want list mode here
 
   new_ts_str = eap->arg;
-  if (!tabstop_set((char_u *)eap->arg, &new_vts_array)) {
+  if (!tabstop_set(eap->arg, &new_vts_array)) {
     return;
   }
   while (ascii_isdigit(*(eap->arg)) || *(eap->arg) == ',') {
@@ -1656,7 +1656,7 @@ char *make_filter_cmd(char *cmd, char *itmp, char *otmp)
   }
 #endif
   if (otmp != NULL) {
-    append_redir(buf, len, (char *)p_srr, otmp);
+    append_redir(buf, len, p_srr, otmp);
   }
   return buf;
 }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index eadde7a725..8ecc1e266b 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -531,7 +531,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       if (flags & DOCMD_KEEPLINE) {
         xfree(repeat_cmdline);
         if (count == 0) {
-          repeat_cmdline = vim_strsave((char_u *)next_cmdline);
+          repeat_cmdline = (char *)vim_strsave((char_u *)next_cmdline);
         } else {
           repeat_cmdline = NULL;
         }
@@ -3788,8 +3788,8 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
       // if there are still wildcards present.
       if (vim_strchr(eap->arg, '$') != NULL
           || vim_strchr(eap->arg, '~') != NULL) {
-        expand_env_esc((char_u *)eap->arg, NameBuff, MAXPATHL, true, true, NULL);
-        has_wildcards = path_has_wildcard(NameBuff);
+        expand_env_esc((char_u *)eap->arg, (char_u *)NameBuff, MAXPATHL, true, true, NULL);
+        has_wildcards = path_has_wildcard((char_u *)NameBuff);
         p = (char *)NameBuff;
       } else {
         p = NULL;
@@ -4058,7 +4058,7 @@ static int getargopt(exarg_T *eap)
   *arg = NUL;
 
   if (pp == &eap->force_ff) {
-    if (check_ff_value((char_u *)eap->cmd + eap->force_ff) == FAIL) {
+    if (check_ff_value(eap->cmd + eap->force_ff) == FAIL) {
       return FAIL;
     }
     eap->force_ff = (char_u)eap->cmd[eap->force_ff];
@@ -5482,8 +5482,8 @@ bool changedir_func(char *new_dir, CdScope scope)
     new_dir = pdir;
   }
 
-  if (os_dirname(NameBuff, MAXPATHL) == OK) {
-    pdir = (char *)vim_strsave(NameBuff);
+  if (os_dirname((char_u *)NameBuff, MAXPATHL) == OK) {
+    pdir = xstrdup(NameBuff);
   } else {
     pdir = NULL;
   }
@@ -5496,7 +5496,7 @@ bool changedir_func(char *new_dir, CdScope scope)
   if (*new_dir == NUL && p_cdh) {
 #endif
     // Use NameBuff for home directory name.
-    expand_env((char_u *)"$HOME", NameBuff, MAXPATHL);
+    expand_env((char_u *)"$HOME", (char_u *)NameBuff, MAXPATHL);
     new_dir = (char *)NameBuff;
   }
 
@@ -5565,7 +5565,7 @@ void ex_cd(exarg_T *eap)
 /// ":pwd".
 static void ex_pwd(exarg_T *eap)
 {
-  if (os_dirname(NameBuff, MAXPATHL) == OK) {
+  if (os_dirname((char_u *)NameBuff, MAXPATHL) == OK) {
 #ifdef BACKSLASH_IN_FILENAME
     slash_adjust(NameBuff);
 #endif
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 081aa80778..c509205a6c 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -854,7 +854,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
                      s->histype == HIST_SEARCH ? s->firstc : NUL);
       if (s->firstc == ':') {
         xfree(new_last_cmdline);
-        new_last_cmdline = vim_strsave(ccline.cmdbuff);
+        new_last_cmdline = (char *)vim_strsave(ccline.cmdbuff);
       }
     }
 
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 273fe12d31..a990043017 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -1409,11 +1409,11 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
     // copy file name into NameBuff, expanding environment variables
     save_char = ptr[len];
     ptr[len] = NUL;
-    expand_env_esc(ptr, NameBuff, MAXPATHL, false, true, NULL);
+    expand_env_esc(ptr, (char_u *)NameBuff, MAXPATHL, false, true, NULL);
     ptr[len] = save_char;
 
     xfree(ff_file_to_find);
-    ff_file_to_find = vim_strsave(NameBuff);
+    ff_file_to_find = vim_strsave((char_u *)NameBuff);
     if (options & FNAME_UNESC) {
       // Change all "\ " to " ".
       for (ptr = ff_file_to_find; *ptr != NUL; ptr++) {
@@ -1473,11 +1473,11 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
         buf = (char *)suffixes;
         for (;;) {
           if (
-              (os_path_exists(NameBuff)
+              (os_path_exists((char_u *)NameBuff)
                && (find_what == FINDFILE_BOTH
                    || ((find_what == FINDFILE_DIR)
-                       == os_isdir(NameBuff))))) {
-            file_name = vim_strsave(NameBuff);
+                       == os_isdir((char_u *)NameBuff))))) {
+            file_name = vim_strsave((char_u *)NameBuff);
             goto theend;
           }
           if (*buf == NUL) {
@@ -1641,7 +1641,7 @@ int vim_chdirfile(char *fname, CdCause cause)
   STRLCPY(dir, fname, MAXPATHL);
   *path_tail_with_sep(dir) = NUL;
 
-  if (os_dirname(NameBuff, sizeof(NameBuff)) != OK) {
+  if (os_dirname((char_u *)NameBuff, sizeof(NameBuff)) != OK) {
     NameBuff[0] = NUL;
   }
 
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 39b4eb4376..b873388473 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -699,7 +699,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
    * Decide which 'encoding' to use or use first.
    */
   if (eap != NULL && eap->force_enc != 0) {
-    fenc = (char *)enc_canonize((char_u *)eap->cmd + eap->force_enc);
+    fenc = enc_canonize(eap->cmd + eap->force_enc);
     fenc_alloced = true;
     keep_dest_enc = true;
   } else if (curbuf->b_p_bin) {
@@ -2056,8 +2056,8 @@ void set_file_options(int set_options, exarg_T *eap)
 void set_forced_fenc(exarg_T *eap)
 {
   if (eap->force_enc != 0) {
-    char_u *fenc = enc_canonize((char_u *)eap->cmd + eap->force_enc);
-    set_string_option_direct("fenc", -1, (char *)fenc, OPT_FREE|OPT_LOCAL, 0);
+    char *fenc = enc_canonize(eap->cmd + eap->force_enc);
+    set_string_option_direct("fenc", -1, fenc, OPT_FREE|OPT_LOCAL, 0);
     xfree(fenc);
   }
 }
@@ -2081,12 +2081,12 @@ static char_u *next_fenc(char **pp, bool *alloced)
   }
   p = (char_u *)vim_strchr((*pp), ',');
   if (p == NULL) {
-    r = enc_canonize((char_u *)(*pp));
+    r = (char_u *)enc_canonize(*pp);
     *pp += STRLEN(*pp);
   } else {
     r = vim_strnsave((char_u *)(*pp), (size_t)(p - (char_u *)(*pp)));
     *pp = (char *)p + 1;
-    p = enc_canonize(r);
+    p = (char_u *)enc_canonize((char *)r);
     xfree(r);
     r = p;
   }
@@ -3055,7 +3055,7 @@ nobackup:
   // Check for forced 'fileencoding' from "++opt=val" argument.
   if (eap != NULL && eap->force_enc != 0) {
     fenc = eap->cmd + eap->force_enc;
-    fenc = (char *)enc_canonize((char_u *)fenc);
+    fenc = enc_canonize(fenc);
     fenc_tofree = fenc;
   } else {
     fenc = buf->b_p_fenc;
diff --git a/src/nvim/garray.h b/src/nvim/garray.h
index 56bd5c9130..0281678925 100644
--- a/src/nvim/garray.h
+++ b/src/nvim/garray.h
@@ -4,7 +4,7 @@
 #include <stddef.h>  // for size_t
 
 #include "nvim/log.h"
-#include "nvim/types.h"  // for char_u
+#include "nvim/types.h"
 
 /// Structure used for growing arrays.
 /// This is used to store information that only grows, is deleted all at
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index c1c5680cb0..ebea4b7a9b 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1302,7 +1302,7 @@ void openscript(char_u *name, bool directly)
     curscript++;
   }
   // use NameBuff for expanded name
-  expand_env(name, NameBuff, MAXPATHL);
+  expand_env(name, (char_u *)NameBuff, MAXPATHL);
   int error;
   if ((scriptin[curscript] = file_open_new(&error, (char *)NameBuff,
                                            kFileReadOnly, 0)) == NULL) {
@@ -2120,7 +2120,7 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
 
   // Check for match with 'pastetoggle'
   if (*p_pt != NUL && mp == NULL && (State & (MODE_INSERT | MODE_NORMAL))) {
-    bool match = typebuf_match_len(p_pt, &mlen);
+    bool match = typebuf_match_len((char_u *)p_pt, &mlen);
     if (match) {
       // write chars to script file(s)
       if (mlen > typebuf.tb_maplen) {
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 7b93fbc852..8d62674a22 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -159,10 +159,10 @@ EXTERN colnr_T dollar_vcol INIT(= -1);
 
 // Variables for Insert mode completion.
 
-EXTERN char_u *edit_submode INIT(= NULL);        // msg for CTRL-X submode
-EXTERN char_u *edit_submode_pre INIT(= NULL);    // prepended to edit_submode
-EXTERN char_u *edit_submode_extra INIT(= NULL);  // appended to edit_submode
-EXTERN hlf_T edit_submode_highl;                 // highl. method for extra info
+EXTERN char *edit_submode INIT(= NULL);         // msg for CTRL-X submode
+EXTERN char *edit_submode_pre INIT(= NULL);     // prepended to edit_submode
+EXTERN char *edit_submode_extra INIT(= NULL);   // appended to edit_submode
+EXTERN hlf_T edit_submode_highl;                // highl. method for extra info
 
 // state for putting characters in the message area
 EXTERN int cmdmsg_rl INIT(= false);  // cmdline is drawn right to left
@@ -667,7 +667,7 @@ EXTERN int swap_exists_action INIT(= SEA_NONE);  ///< For dialog when swap file
 EXTERN bool swap_exists_did_quit INIT(= false);  ///< Selected "quit" at the dialog.
 
 EXTERN char_u IObuff[IOSIZE];               ///< Buffer for sprintf, I/O, etc.
-EXTERN char_u NameBuff[MAXPATHL];           ///< Buffer for expanding file names
+EXTERN char NameBuff[MAXPATHL];             ///< Buffer for expanding file names
 EXTERN char msg_buf[MSG_BUF_LEN];           ///< Small buffer for messages
 EXTERN char os_buf[                         ///< Buffer for the os/ layer
 #if MAXPATHL > IOSIZE
@@ -731,9 +731,9 @@ EXTERN bool need_start_insertmode INIT(= false);  ///< start insert mode soon
                                 // including the terminating NUL
 
 EXTERN char last_mode[MODE_MAX_LENGTH] INIT(= "n");
-EXTERN char_u *last_cmdline INIT(= NULL);      // last command line (for ":)
-EXTERN char_u *repeat_cmdline INIT(= NULL);    // command line for "."
-EXTERN char_u *new_last_cmdline INIT(= NULL);  // new value for last_cmdline
+EXTERN char *last_cmdline INIT(= NULL);        // last command line (for ":)
+EXTERN char *repeat_cmdline INIT(= NULL);      // command line for "."
+EXTERN char *new_last_cmdline INIT(= NULL);    // new value for last_cmdline
 EXTERN char *autocmd_fname INIT(= NULL);       // fname for <afile> on cmdline
 EXTERN int autocmd_bufnr INIT(= 0);            // fnum for <abuf> on cmdline
 EXTERN char *autocmd_match INIT(= NULL);       // name for <amatch> on cmdline
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 19bf67c890..4b2b113437 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -537,7 +537,7 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
   if (keep_lang) {
     flags |= TAG_KEEP_LANG;
   }
-  if (find_tags(IObuff, num_matches, matches, flags, MAXCOL, NULL) == OK
+  if (find_tags((char *)IObuff, num_matches, matches, flags, MAXCOL, NULL) == OK
       && *num_matches > 0) {
     // Sort the matches found on the heuristic number that is after the
     // tag name.
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index c5a84c731d..3e3d03fa9c 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -729,7 +729,7 @@ static int hl_cterm2rgb_color(int nr)
     0x08, 0x12, 0x1C, 0x26, 0x30, 0x3A, 0x44, 0x4E, 0x58, 0x62, 0x6C, 0x76,
     0x80, 0x8A, 0x94, 0x9E, 0xA8, 0xB2, 0xBC, 0xC6, 0xD0, 0xDA, 0xE4, 0xEE
   };
-  static char_u ansi_table[16][4] = {
+  static uint8_t ansi_table[16][4] = {
     //  R    G    B   idx
     {   0,   0,   0,  1 },  // black
     { 224,   0,   0,  2 },  // dark red
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index c4805283c2..7c5f291837 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -34,12 +34,13 @@
 
 /// Set the integer values corresponding to the string setting of 'vartabstop'.
 /// "array" will be set, caller must free it if needed.
-/// Return false for an error.
-bool tabstop_set(char_u *var, long **array)
+///
+/// @return  false for an error.
+bool tabstop_set(char *var, long **array)
 {
   long valcount = 1;
   int t;
-  char_u *cp;
+  char *cp;
 
   if (var[0] == NUL || (var[0] == '0' && var[1] == NUL)) {
     *array = NULL;
@@ -50,8 +51,8 @@ bool tabstop_set(char_u *var, long **array)
     if (cp == var || cp[-1] == ',') {
       char *end;
 
-      if (strtol((char *)cp, &end, 10) <= 0) {
-        if (cp != (char_u *)end) {
+      if (strtol(cp, &end, 10) <= 0) {
+        if (cp != end) {
           emsg(_(e_positive));
         } else {
           semsg(_(e_invarg2), cp);
@@ -76,7 +77,7 @@ bool tabstop_set(char_u *var, long **array)
 
   t = 1;
   for (cp = var; *cp != NUL;) {
-    int n = atoi((char *)cp);
+    int n = atoi(cp);
 
     // Catch negative values, overflow and ridiculous big values.
     if (n <= 0 || n > TABSTOP_MAX) {
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index e6c13f315e..981a8d42a6 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -268,7 +268,7 @@ void ins_ctrl_x(void)
     }
     // We're not sure which CTRL-X mode it will be yet
     ctrl_x_mode = CTRL_X_NOT_DEFINED_YET;
-    edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode));
+    edit_submode = _(CTRL_X_MSG(ctrl_x_mode));
     edit_submode_pre = NULL;
     showmode();
   } else {
@@ -1830,9 +1830,9 @@ static bool set_ctrl_x_mode(const int c)
     // scroll the window one line up or down
     ctrl_x_mode = CTRL_X_SCROLL;
     if (!(State & REPLACE_FLAG)) {
-      edit_submode = (char_u *)_(" (insert) Scroll (^E/^Y)");
+      edit_submode = _(" (insert) Scroll (^E/^Y)");
     } else {
-      edit_submode = (char_u *)_(" (replace) Scroll (^E/^Y)");
+      edit_submode = _(" (replace) Scroll (^E/^Y)");
     }
     edit_submode_pre = NULL;
     showmode();
@@ -2845,10 +2845,10 @@ static void get_next_tag_completion(void)
   g_tag_at_cursor = true;
   char **matches;
   int num_matches;
-  if (find_tags((char_u *)compl_pattern, &num_matches, &matches,
+  if (find_tags(compl_pattern, &num_matches, &matches,
                 TAG_REGEXP | TAG_NAMES | TAG_NOIC | TAG_INS_COMP
                 | (ctrl_x_mode_not_default() ? TAG_VERBOSE : 0),
-                TAG_MANY, (char_u *)curbuf->b_ffname) == OK && num_matches > 0) {
+                TAG_MANY, curbuf->b_ffname) == OK && num_matches > 0) {
     ins_compl_add_matches(num_matches, matches, p_ic);
   }
   g_tag_at_cursor = false;
@@ -4078,7 +4078,7 @@ static int ins_compl_start(void)
   }
 
   if (compl_status_adding()) {
-    edit_submode_pre = (char_u *)_(" Adding");
+    edit_submode_pre = _(" Adding");
     if (ctrl_x_mode_line_or_eval()) {
       // Insert a new line, keep indentation but ignore 'comments'.
       char *old = curbuf->b_p_com;
@@ -4097,9 +4097,9 @@ static int ins_compl_start(void)
   }
 
   if (compl_cont_status & CONT_LOCAL) {
-    edit_submode = (char_u *)_(ctrl_x_msgs[CTRL_X_LOCAL_MSG]);
+    edit_submode = _(ctrl_x_msgs[CTRL_X_LOCAL_MSG]);
   } else {
-    edit_submode = (char_u *)_(CTRL_X_MSG(ctrl_x_mode));
+    edit_submode = _(CTRL_X_MSG(ctrl_x_mode));
   }
 
   // If any of the original typed text has been changed we need to fix
@@ -4123,7 +4123,7 @@ static int ins_compl_start(void)
   // showmode might reset the internal line pointers, so it must
   // be called before line = ml_get(), or when this address is no
   // longer needed.  -- Acevedo.
-  edit_submode_extra = (char_u *)_("-- Searching...");
+  edit_submode_extra = _("-- Searching...");
   edit_submode_highl = HLF_COUNT;
   showmode();
   edit_submode_extra = NULL;
@@ -4137,20 +4137,19 @@ static void ins_compl_show_statusmsg(void)
 {
   // we found no match if the list has only the "compl_orig_text"-entry
   if (is_first_match(compl_first_match->cp_next)) {
-    edit_submode_extra = compl_status_adding() && compl_length > 1
-                         ? (char_u *)_(e_hitend) : (char_u *)_(e_patnotf);
+    edit_submode_extra = compl_status_adding() && compl_length > 1 ? _(e_hitend) : _(e_patnotf);
     edit_submode_highl = HLF_E;
   }
 
   if (edit_submode_extra == NULL) {
     if (match_at_original_text(compl_curr_match)) {
-      edit_submode_extra = (char_u *)_("Back at original");
+      edit_submode_extra = _("Back at original");
       edit_submode_highl = HLF_W;
     } else if (compl_cont_status & CONT_S_IPOS) {
-      edit_submode_extra = (char_u *)_("Word from other line");
+      edit_submode_extra = _("Word from other line");
       edit_submode_highl = HLF_COUNT;
     } else if (compl_curr_match->cp_next == compl_curr_match->cp_prev) {
-      edit_submode_extra = (char_u *)_("The only match");
+      edit_submode_extra = _("The only match");
       edit_submode_highl = HLF_COUNT;
       compl_curr_match->cp_number = 1;
     } else {
@@ -4175,7 +4174,7 @@ static void ins_compl_show_statusmsg(void)
                        _("match %d"),
                        compl_curr_match->cp_number);
         }
-        edit_submode_extra = match_ref;
+        edit_submode_extra = (char *)match_ref;
         edit_submode_highl = HLF_R;
         if (dollar_vcol >= 0) {
           curs_columns(curwin, false);
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 64e9abe0c9..0d08817285 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -494,8 +494,8 @@ static int nlua_iconv(lua_State *lstate)
   size_t str_len = 0;
   const char *str = lua_tolstring(lstate, 1, &str_len);
 
-  char_u *from = enc_canonize(enc_skip((char_u *)lua_tolstring(lstate, 2, NULL)));
-  char_u *to   = enc_canonize(enc_skip((char_u *)lua_tolstring(lstate, 3, NULL)));
+  char_u *from = (char_u *)enc_canonize((char *)enc_skip((char_u *)lua_tolstring(lstate, 2, NULL)));
+  char_u *to   = (char_u *)enc_canonize((char *)enc_skip((char_u *)lua_tolstring(lstate, 3, NULL)));
 
   vimconv_T vimconv;
   vimconv.vc_type = CONV_NONE;
diff --git a/src/nvim/main.c b/src/nvim/main.c
index e2e150a892..09a387262c 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1490,7 +1490,7 @@ static void handle_quickfix(mparm_T *paramp)
       set_string_option_direct("ef", -1, paramp->use_ef, OPT_FREE, SID_CARG);
     }
     vim_snprintf((char *)IObuff, IOSIZE, "cfile %s", p_ef);
-    if (qf_init(NULL, (char *)p_ef, p_efm, true, (char *)IObuff, (char *)p_menc) < 0) {
+    if (qf_init(NULL, (char *)p_ef, p_efm, true, (char *)IObuff, p_menc) < 0) {
       msg_putchar('\n');
       os_exit(3);
     }
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index c4b30ae600..883371c5fb 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -674,7 +674,7 @@ static void fname2fnum(xfmark_T *fm)
                                 )) {
       int len;
 
-      expand_env((char_u *)"~/", NameBuff, MAXPATHL);
+      expand_env((char_u *)"~/", (char_u *)NameBuff, MAXPATHL);
       len = (int)STRLEN(NameBuff);
       STRLCPY(NameBuff + len, fm->fname + 2, MAXPATHL - len);
     } else {
@@ -683,7 +683,7 @@ static void fname2fnum(xfmark_T *fm)
 
     // Try to shorten the file name.
     os_dirname(IObuff, IOSIZE);
-    p = path_shorten_fname(NameBuff, IObuff);
+    p = path_shorten_fname((char_u *)NameBuff, IObuff);
 
     // buflist_new() will call fmarks_check_names()
     (void)buflist_new((char *)NameBuff, (char *)p, (linenr_T)1, 0);
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 9213457608..dab6c8fbd3 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -2160,27 +2160,27 @@ char_u *enc_skip(char_u *p)
   return p;
 }
 
-/*
- * Find the canonical name for encoding "enc".
- * When the name isn't recognized, returns "enc" itself, but with all lower
- * case characters and '_' replaced with '-'.
- * Returns an allocated string.
- */
-char_u *enc_canonize(char_u *enc) FUNC_ATTR_NONNULL_RET
+/// Find the canonical name for encoding "enc".
+/// When the name isn't recognized, returns "enc" itself, but with all lower
+/// case characters and '_' replaced with '-'.
+///
+/// @return  an allocated string.
+char *enc_canonize(char *enc)
+  FUNC_ATTR_NONNULL_RET
 {
   char_u *p, *s;
   int i;
 
   if (STRCMP(enc, "default") == 0) {
     // Use the default encoding as found by set_init_1().
-    return vim_strsave(fenc_default);
+    return (char *)vim_strsave(fenc_default);
   }
 
   // copy "enc" to allocated memory, with room for two '-'
   char_u *r = xmalloc(STRLEN(enc) + 3);
   // Make it all lower case and replace '_' with '-'.
   p = r;
-  for (s = enc; *s != NUL; s++) {
+  for (s = (char_u *)enc; *s != NUL; s++) {
     if (*s == '_') {
       *p++ = '-';
     } else {
@@ -2224,7 +2224,7 @@ char_u *enc_canonize(char_u *enc) FUNC_ATTR_NONNULL_RET
     xfree(r);
     r = vim_strsave((char_u *)enc_canon_table[i].name);
   }
-  return r;
+  return (char *)r;
 }
 
 /// Search for an encoding alias of "name".
@@ -2309,7 +2309,7 @@ enc_locale_copy_enc:
     buf[i] = NUL;
   }
 
-  return enc_canonize((char_u *)buf);
+  return (char_u *)enc_canonize(buf);
 }
 
 #if defined(HAVE_ICONV)
diff --git a/src/nvim/memfile.c b/src/nvim/memfile.c
index 216ee26620..9446aaee4f 100644
--- a/src/nvim/memfile.c
+++ b/src/nvim/memfile.c
@@ -77,7 +77,7 @@
 ///
 /// @return - The open memory file, on success.
 ///         - NULL, on failure (e.g. file does not exist).
-memfile_T *mf_open(char_u *fname, int flags)
+memfile_T *mf_open(char *fname, int flags)
 {
   memfile_T *mfp = xmalloc(sizeof(memfile_T));
 
@@ -148,7 +148,7 @@ memfile_T *mf_open(char_u *fname, int flags)
 ///
 /// @return OK    On success.
 ///         FAIL  If file could not be opened.
-int mf_open_file(memfile_T *mfp, char_u *fname)
+int mf_open_file(memfile_T *mfp, char *fname)
 {
   if (mf_do_open(mfp, fname, O_RDWR | O_CREAT | O_EXCL)) {
     mfp->mf_dirty = true;
@@ -749,9 +749,9 @@ void mf_free_fnames(memfile_T *mfp)
 ///
 /// Only called when creating or renaming the swapfile. Either way it's a new
 /// name so we must work out the full path name.
-void mf_set_fnames(memfile_T *mfp, char_u *fname)
+void mf_set_fnames(memfile_T *mfp, char *fname)
 {
-  mfp->mf_fname = fname;
+  mfp->mf_fname = (char_u *)fname;
   mfp->mf_ffname = (char_u *)FullName_save((char *)mfp->mf_fname, false);
 }
 
@@ -779,7 +779,7 @@ bool mf_need_trans(memfile_T *mfp)
 ///
 /// @param  flags  Flags for open().
 /// @return A bool indicating success of the `open` call.
-static bool mf_do_open(memfile_T *mfp, char_u *fname, int flags)
+static bool mf_do_open(memfile_T *mfp, char *fname, int flags)
 {
   // fname cannot be NameBuff, because it must have been allocated.
   mf_set_fnames(mfp, fname);
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 2913d0d271..ee90ae6b15 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -430,7 +430,7 @@ void ml_setname(buf_T *buf)
     if (vim_rename(mfp->mf_fname, fname) == 0) {
       success = true;
       mf_free_fnames(mfp);
-      mf_set_fnames(mfp, fname);
+      mf_set_fnames(mfp, (char *)fname);
       ml_upd_block0(buf, UB_SAME_DIR);
       break;
     }
@@ -483,7 +483,7 @@ void ml_open_file(buf_T *buf)
   if (buf->b_spell) {
     fname = vim_tempname();
     if (fname != NULL) {
-      (void)mf_open_file(mfp, fname);           // consumes fname!
+      (void)mf_open_file(mfp, (char *)fname);           // consumes fname!
     }
     buf->b_may_swap = false;
     return;
@@ -506,7 +506,7 @@ void ml_open_file(buf_T *buf)
     if (fname == NULL) {
       continue;
     }
-    if (mf_open_file(mfp, fname) == OK) {       // consumes fname!
+    if (mf_open_file(mfp, (char *)fname) == OK) {       // consumes fname!
       ml_upd_block0(buf, UB_SAME_DIR);
 
       // Flush block zero, so others can read it
@@ -835,7 +835,7 @@ void ml_recover(bool checkext)
    */
   p = vim_strsave(fname_used);  // save "fname_used" for the message:
                                 // mf_open() will consume "fname_used"!
-  mfp = mf_open(fname_used, O_RDONLY);
+  mfp = mf_open((char *)fname_used, O_RDONLY);
   fname_used = p;
   if (mfp == NULL || mfp->mf_fd < 0) {
     semsg(_("E306: Cannot open %s"), fname_used);
@@ -926,7 +926,7 @@ void ml_recover(bool checkext)
    * If .swp file name given directly, use name from swap file for buffer.
    */
   if (directly) {
-    expand_env(b0p->b0_fname, NameBuff, MAXPATHL);
+    expand_env(b0p->b0_fname, (char_u *)NameBuff, MAXPATHL);
     if (setfname(curbuf, (char *)NameBuff, NULL, true) == FAIL) {
       goto theend;
     }
@@ -1873,7 +1873,7 @@ errorret:
         // when the GUI redraws part of the text.
         recursive++;
         get_trans_bufname(buf);
-        shorten_dir(NameBuff);
+        shorten_dir((char_u *)NameBuff);
         siemsg(_("E316: ml_get: cannot find line %" PRId64 " in buffer %d %s"),
                (int64_t)lnum, buf->b_fnum, NameBuff);
         recursive--;
@@ -3472,8 +3472,8 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
                 // Symlinks may point to the same file even
                 // when the name differs, need to check the
                 // inode too.
-                expand_env(b0.b0_fname, NameBuff, MAXPATHL);
-                if (fnamecmp_ino((char_u *)buf->b_ffname, NameBuff,
+                expand_env(b0.b0_fname, (char_u *)NameBuff, MAXPATHL);
+                if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
                                  char_to_long(b0.b0_ino))) {
                   differ = true;
                 }
@@ -3481,8 +3481,8 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             } else {
               // The name in the swap file may be
               // "~user/path/file".  Expand it first.
-              expand_env(b0.b0_fname, NameBuff, MAXPATHL);
-              if (fnamecmp_ino((char_u *)buf->b_ffname, NameBuff,
+              expand_env(b0.b0_fname, (char_u *)NameBuff, MAXPATHL);
+              if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
                                char_to_long(b0.b0_ino))) {
                 differ = true;
               }
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 40de8a2bc6..fbf9c9b603 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -3426,7 +3426,7 @@ int verbose_open(void)
     // Only give the error message once.
     verbose_did_open = true;
 
-    verbose_fd = os_fopen((char *)p_vfile, "a");
+    verbose_fd = os_fopen(p_vfile, "a");
     if (verbose_fd == NULL) {
       semsg(_(e_notopen), p_vfile);
       return FAIL;
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 31646f686d..5dd6742e2f 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -4807,14 +4807,14 @@ static void nv_search(cmdarg_T *cap)
 
   // When using 'incsearch' the cursor may be moved to set a different search
   // start position.
-  cap->searchbuf = getcmdline(cap->cmdchar, cap->count1, 0, true);
+  cap->searchbuf = (char *)getcmdline(cap->cmdchar, cap->count1, 0, true);
 
   if (cap->searchbuf == NULL) {
     clearop(oap);
     return;
   }
 
-  (void)normal_search(cap, cap->cmdchar, cap->searchbuf,
+  (void)normal_search(cap, cap->cmdchar, (char_u *)cap->searchbuf,
                       (cap->arg || !equalpos(save_cursor, curwin->w_cursor))
                       ? 0 : SEARCH_MARK, NULL);
 }
diff --git a/src/nvim/normal.h b/src/nvim/normal.h
index 9bda70eacd..13ea233658 100644
--- a/src/nvim/normal.h
+++ b/src/nvim/normal.h
@@ -57,7 +57,7 @@ typedef struct oparg_S {
  * Arguments for Normal mode commands.
  */
 typedef struct cmdarg_S {
-  oparg_T *oap;             // Operator arguments
+  oparg_T *oap;                 // Operator arguments
   int prechar;                  // prefix character (optional, always 'g')
   int cmdchar;                  // command character
   int nchar;                    // next command character (optional)
@@ -69,7 +69,7 @@ typedef struct cmdarg_S {
   long count1;                  // count before command, default 1
   int arg;                      // extra argument from nv_cmds[]
   int retval;                   // return: CA_* values
-  char_u *searchbuf;       // return: pointer to search pattern or NULL
+  char *searchbuf;              // return: pointer to search pattern or NULL
 } cmdarg_T;
 
 // values for retval:
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 0fc15b9382..1bf4c00633 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -1111,7 +1111,7 @@ int do_execreg(int regname, int colon, int addcr, int silent)
     // don't keep the cmdline containing @:
     XFREE_CLEAR(new_last_cmdline);
     // Escape all control characters with a CTRL-V
-    p = vim_strsave_escaped_ext(last_cmdline,
+    p = vim_strsave_escaped_ext((char_u *)last_cmdline,
                                 (char_u *)"\001\002\003\004\005\006\007"
                                 "\010\011\012\013\014\015\016\017"
                                 "\020\021\022\023\024\025\026\027"
@@ -1346,7 +1346,7 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
     if (last_cmdline == NULL && errmsg) {
       emsg(_(e_nolastcmd));
     }
-    *argp = (char *)last_cmdline;
+    *argp = last_cmdline;
     return true;
 
   case '/':                     // last search-pattern
@@ -3854,9 +3854,9 @@ void ex_display(exarg_T *eap)
 
   // display last command line
   if (last_cmdline != NULL && (arg == NULL || vim_strchr((char *)arg, ':') != NULL)
-      && !got_int && !message_filtered(last_cmdline)) {
+      && !got_int && !message_filtered((char_u *)last_cmdline)) {
     msg_puts("\n  c  \":   ");
-    dis_msg(last_cmdline, false);
+    dis_msg((char_u *)last_cmdline, false);
   }
 
   // display current file name
@@ -5799,7 +5799,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
         // If 'cpoptions' does not contain 'r', insert the search
         // pattern to really repeat the same command.
         if (vim_strchr(p_cpo, CPO_REDO) == NULL) {
-          AppendToRedobuffLit((char *)cap->searchbuf, -1);
+          AppendToRedobuffLit(cap->searchbuf, -1);
         }
         AppendToRedobuff(NL_STR);
       } else if (cap->cmdchar == ':' || cap->cmdchar == K_COMMAND) {
@@ -5809,7 +5809,7 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
         if (repeat_cmdline == NULL) {
           ResetRedobuff();
         } else {
-          AppendToRedobuffLit((char *)repeat_cmdline, -1);
+          AppendToRedobuffLit(repeat_cmdline, -1);
           AppendToRedobuff(NL_STR);
           XFREE_CLEAR(repeat_cmdline);
         }
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 4bf978d2f6..c3f803e543 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -149,7 +149,7 @@ static int p_et_nopaste;
 static long p_sts_nopaste;
 static long p_tw_nopaste;
 static long p_wm_nopaste;
-static char_u *p_vsts_nopaste;
+static char *p_vsts_nopaste;
 
 typedef struct vimoption {
   char *fullname;        // full option name
@@ -455,7 +455,7 @@ static void set_option_default(int opt_idx, int opt_flags)
   char_u *varp;            // pointer to variable for current option
   int both = (opt_flags & (OPT_LOCAL | OPT_GLOBAL)) == 0;
 
-  varp = get_varp_scope(&(options[opt_idx]), both ? OPT_LOCAL : opt_flags);
+  varp = (char_u *)get_varp_scope(&(options[opt_idx]), both ? OPT_LOCAL : opt_flags);
   uint32_t flags = options[opt_idx].flags;
   if (varp != NULL) {       // skip hidden option, nothing to do for it
     if (flags & P_STRING) {
@@ -675,12 +675,12 @@ void set_init_3(void)
     if (FNAMECMP(p, "csh") == 0
         || FNAMECMP(p, "tcsh") == 0) {
       if (do_sp) {
-        p_sp = (char_u *)"|& tee";
-        options[idx_sp].def_val = p_sp;
+        p_sp = "|& tee";
+        options[idx_sp].def_val = (char_u *)p_sp;
       }
       if (do_srr) {
-        p_srr = (char_u *)">&";
-        options[idx_srr].def_val = p_srr;
+        p_srr = ">&";
+        options[idx_srr].def_val = (char_u *)p_srr;
       }
     } else if (FNAMECMP(p, "sh") == 0
                || FNAMECMP(p, "ksh") == 0
@@ -694,12 +694,12 @@ void set_init_3(void)
                || FNAMECMP(p, "dash") == 0) {
       // Always use POSIX shell style redirection if we reach this
       if (do_sp) {
-        p_sp = (char_u *)"2>&1| tee";
-        options[idx_sp].def_val = p_sp;
+        p_sp = "2>&1| tee";
+        options[idx_sp].def_val = (char_u *)p_sp;
       }
       if (do_srr) {
-        p_srr = (char_u *)">%s 2>&1";
-        options[idx_srr].def_val = p_srr;
+        p_srr = ">%s 2>&1";
+        options[idx_srr].def_val = (char_u *)p_srr;
       }
     }
     xfree(p);
@@ -810,7 +810,7 @@ int do_set(char *arg, int opt_flags)
   int opt_idx;
   char *errmsg;
   char errbuf[80];
-  char_u *startarg;
+  char *startarg;
   int prefix;           // 1: nothing, 0: "no", 2: "inv" in front of name
   char_u nextchar;                  // next non-white char after option name
   int afterchar;                    // character just after option name
@@ -833,7 +833,7 @@ int do_set(char *arg, int opt_flags)
 
   while (*arg != NUL) {         // loop to process all options
     errmsg = NULL;
-    startarg = (char_u *)arg;             // remember for error message
+    startarg = arg;             // remember for error message
 
     if (STRNCMP(arg, "all", 3) == 0 && !isalpha(arg[3])
         && !(opt_flags & OPT_MODELINE)) {
@@ -947,7 +947,7 @@ int do_set(char *arg, int opt_flags)
         }
 
         flags = options[opt_idx].flags;
-        varp = (char *)get_varp_scope(&(options[opt_idx]), opt_flags);
+        varp = get_varp_scope(&(options[opt_idx]), opt_flags);
       } else {
         flags = P_STRING;
       }
@@ -1543,12 +1543,12 @@ skip:
     if (errmsg != NULL) {
       STRLCPY(IObuff, _(errmsg), IOSIZE);
       i = (int)STRLEN(IObuff) + 2;
-      if (i + ((char_u *)arg - startarg) < IOSIZE) {
+      if (i + (arg - startarg) < IOSIZE) {
         // append the argument with the error
         STRCAT(IObuff, ": ");
-        assert((char_u *)arg >= startarg);
-        memmove(IObuff + i, startarg, (size_t)((char_u *)arg - startarg));
-        IObuff[i + ((char_u *)arg - startarg)] = NUL;
+        assert(arg >= startarg);
+        memmove(IObuff + i, startarg, (size_t)(arg - startarg));
+        IObuff[i + (arg - startarg)] = NUL;
       }
       // make sure all characters are printable
       trans_characters((char *)IObuff, IOSIZE);
@@ -1741,7 +1741,7 @@ static char_u *option_expand(int opt_idx, char_u *val)
    * names.
    * For 'spellsuggest' expand after "file:".
    */
-  expand_env_esc(val, NameBuff, MAXPATHL,
+  expand_env_esc(val, (char_u *)NameBuff, MAXPATHL,
                  (char_u **)options[opt_idx].var == &p_tags, false,
                  (char_u **)options[opt_idx].var == (char_u **)&p_sps ? (char_u *)"file:" :
                  NULL);
@@ -1749,7 +1749,7 @@ static char_u *option_expand(int opt_idx, char_u *val)
     return NULL;
   }
 
-  return NameBuff;
+  return (char_u *)NameBuff;
 }
 
 /// After setting various option values: recompute variables that depend on
@@ -1779,17 +1779,17 @@ static void didset_options2(void)
   highlight_changed();
 
   // Parse default for 'fillchars'.
-  (void)set_chars_option(curwin, (char_u **)&curwin->w_p_fcs, true);
+  (void)set_chars_option(curwin, &curwin->w_p_fcs, true);
 
   // Parse default for 'listchars'.
-  (void)set_chars_option(curwin, (char_u **)&curwin->w_p_lcs, true);
+  (void)set_chars_option(curwin, &curwin->w_p_lcs, true);
 
   // Parse default for 'wildmode'.
   check_opt_wim();
   xfree(curbuf->b_p_vsts_array);
-  (void)tabstop_set((char_u *)curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
+  (void)tabstop_set(curbuf->b_p_vsts, &curbuf->b_p_vsts_array);
   xfree(curbuf->b_p_vts_array);
-  (void)tabstop_set((char_u *)curbuf->b_p_vts,  &curbuf->b_p_vts_array);
+  (void)tabstop_set(curbuf->b_p_vts,  &curbuf->b_p_vts_array);
 }
 
 /// Check for string options that are NULL (normally only termcap options).
@@ -1858,10 +1858,10 @@ void redraw_titles(void)
 
 /// Return true if "val" is a valid name: only consists of alphanumeric ASCII
 /// characters or characters in "allowed".
-bool valid_name(const char_u *val, const char *allowed)
+bool valid_name(const char *val, const char *allowed)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  for (const char_u *s = val; *s != NUL; s++) {
+  for (const char_u *s = (char_u *)val; *s != NUL; s++) {
     if (!ASCII_ISALNUM(*s)
         && vim_strchr(allowed, *s) == NULL) {
       return false;
@@ -2930,14 +2930,14 @@ getoption_T get_option_value(const char *name, long *numval, char **stringval, i
     return gov_unknown;
   }
 
-  char_u *varp = get_varp_scope(&(options[opt_idx]), opt_flags);
+  char_u *varp = (char_u *)get_varp_scope(&(options[opt_idx]), opt_flags);
 
   if (options[opt_idx].flags & P_STRING) {
     if (varp == NULL) {  // hidden option
       return gov_hidden_string;
     }
     if (stringval != NULL) {
-      if ((char_u **)varp == &p_pt) {  // 'pastetoggle'
+      if ((char **)varp == &p_pt) {  // 'pastetoggle'
         *stringval = str2special_save(*(char **)(varp), false, false);
       } else {
         *stringval = xstrdup(*(char **)(varp));
@@ -3056,7 +3056,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o
         // only getting a pointer, no need to use aucmd_prepbuf()
         curbuf = (buf_T *)from;
         curwin->w_buffer = curbuf;
-        varp = get_varp_scope(p, OPT_LOCAL);
+        varp = (char_u *)get_varp_scope(p, OPT_LOCAL);
         curbuf = save_curbuf;
         curwin->w_buffer = curbuf;
       }
@@ -3064,7 +3064,7 @@ int get_option_value_strict(char *name, int64_t *numval, char **stringval, int o
       win_T *save_curwin = curwin;
       curwin = (win_T *)from;
       curbuf = curwin->w_buffer;
-      varp = get_varp_scope(p, OPT_LOCAL);
+      varp = (char_u *)get_varp_scope(p, OPT_LOCAL);
       curwin = save_curwin;
       curbuf = curwin->w_buffer;
     }
@@ -3170,7 +3170,7 @@ char *set_option_value(const char *const name, const long number, const char *co
       return set_string_option(opt_idx, s, opt_flags);
     }
 
-    varp = get_varp_scope(&(options[opt_idx]), opt_flags);
+    varp = (char_u *)get_varp_scope(&(options[opt_idx]), opt_flags);
     if (varp != NULL) {       // hidden option is not changed
       if (number == 0 && string != NULL) {
         int idx;
@@ -3306,7 +3306,7 @@ static void showoptions(int all, int opt_flags)
       varp = NULL;
       if ((opt_flags & (OPT_LOCAL | OPT_GLOBAL)) != 0) {
         if (p->indir != PV_NONE) {
-          varp = get_varp_scope(p, opt_flags);
+          varp = (char_u *)get_varp_scope(p, opt_flags);
         }
       } else {
         varp = get_varp(p);
@@ -3410,13 +3410,12 @@ void ui_refresh_options(void)
 /// @param opt_flags  OPT_LOCAL or OPT_GLOBAL
 static void showoneopt(vimoption_T *p, int opt_flags)
 {
-  char_u *varp;
   int save_silent = silent_mode;
 
   silent_mode = false;
   info_message = true;          // use mch_msg(), not mch_errmsg()
 
-  varp = get_varp_scope(p, opt_flags);
+  char_u *varp = (char_u *)get_varp_scope(p, opt_flags);
 
   // for 'modified' we also need to check if 'ff' or 'fenc' changed.
   if ((p->flags & P_BOOL) && ((int *)varp == &curbuf->b_changed
@@ -3462,7 +3461,7 @@ static void showoneopt(vimoption_T *p, int opt_flags)
 int makeset(FILE *fd, int opt_flags, int local_only)
 {
   vimoption_T *p;
-  char_u *varp;                    // currently used value
+  char *varp;                      // currently used value
   char_u *varp_fresh;              // local value
   char_u *varp_local = NULL;       // fresh value
   char *cmd;
@@ -3499,7 +3498,7 @@ int makeset(FILE *fd, int opt_flags, int local_only)
           continue;
         }
         // Global values are only written when not at the default value.
-        if ((opt_flags & OPT_GLOBAL) && optval_default(p, varp)) {
+        if ((opt_flags & OPT_GLOBAL) && optval_default(p, (char_u *)varp)) {
           continue;
         }
 
@@ -3518,11 +3517,11 @@ int makeset(FILE *fd, int opt_flags, int local_only)
             // When fresh value of window-local option is not at the
             // default, need to write it too.
             if (!(opt_flags & OPT_GLOBAL) && !local_only) {
-              varp_fresh = get_varp_scope(p, OPT_GLOBAL);
+              varp_fresh = (char_u *)get_varp_scope(p, OPT_GLOBAL);
               if (!optval_default(p, varp_fresh)) {
                 round = 1;
-                varp_local = varp;
-                varp = varp_fresh;
+                varp_local = (char_u *)varp;
+                varp = (char *)varp_fresh;
               }
             }
           }
@@ -3530,7 +3529,7 @@ int makeset(FILE *fd, int opt_flags, int local_only)
 
         // Round 1: fresh value for window-local options.
         // Round 2: other values
-        for (; round <= 2; varp = varp_local, round++) {
+        for (; round <= 2; varp = (char *)varp_local, round++) {
           if (round == 1 || (opt_flags & OPT_GLOBAL)) {
             cmd = "set";
           } else {
@@ -3558,8 +3557,7 @@ int makeset(FILE *fd, int opt_flags, int local_only)
               }
               do_endif = true;
             }
-            if (put_setstring(fd, cmd, p->fullname, (char_u **)varp,
-                              p->flags) == FAIL) {
+            if (put_setstring(fd, cmd, p->fullname, (char **)varp, p->flags) == FAIL) {
               return FAIL;
             }
             if (do_endif) {
@@ -3579,25 +3577,21 @@ int makeset(FILE *fd, int opt_flags, int local_only)
 /// 'sessionoptions' or 'viewoptions' contains "folds" but not "options".
 int makefoldset(FILE *fd)
 {
-  if (put_setstring(fd, "setlocal", "fdm", (char_u **)&curwin->w_p_fdm, 0) == FAIL
-      || put_setstring(fd, "setlocal", "fde", (char_u **)&curwin->w_p_fde, 0)
-      == FAIL
-      || put_setstring(fd, "setlocal", "fmr", (char_u **)&curwin->w_p_fmr, 0)
-      == FAIL
-      || put_setstring(fd, "setlocal", "fdi", (char_u **)&curwin->w_p_fdi, 0)
-      == FAIL
+  if (put_setstring(fd, "setlocal", "fdm", &curwin->w_p_fdm, 0) == FAIL
+      || put_setstring(fd, "setlocal", "fde", &curwin->w_p_fde, 0) == FAIL
+      || put_setstring(fd, "setlocal", "fmr", &curwin->w_p_fmr, 0) == FAIL
+      || put_setstring(fd, "setlocal", "fdi", &curwin->w_p_fdi, 0) == FAIL
       || put_setnum(fd, "setlocal", "fdl", &curwin->w_p_fdl) == FAIL
       || put_setnum(fd, "setlocal", "fml", &curwin->w_p_fml) == FAIL
       || put_setnum(fd, "setlocal", "fdn", &curwin->w_p_fdn) == FAIL
-      || put_setbool(fd, "setlocal", "fen",
-                     curwin->w_p_fen) == FAIL) {
+      || put_setbool(fd, "setlocal", "fen", curwin->w_p_fen) == FAIL) {
     return FAIL;
   }
 
   return OK;
 }
 
-static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep, uint64_t flags)
+static int put_setstring(FILE *fd, char *cmd, char *name, char **valuep, uint64_t flags)
 {
   char_u *s;
   char_u *buf = NULL;
@@ -3612,7 +3606,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep, uint6
     // options some characters have to be escaped with
     // CTRL-V or backslash
     if (valuep == &p_pt) {
-      s = *valuep;
+      s = (char_u *)(*valuep);
       while (*s != NUL) {
         if (put_escstr(fd, (char_u *)str2special((const char **)&s, false,
                                                  false), 2)
@@ -3625,13 +3619,13 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep, uint6
 
       // replace home directory in the whole option value into "buf"
       buf = xmalloc(size);
-      home_replace(NULL, (char *)(*valuep), (char *)buf, size, false);
+      home_replace(NULL, *valuep, (char *)buf, size, false);
 
       // If the option value is longer than MAXPATHL, we need to append
       // each comma separated part of the option separately, so that it
       // can be expanded when read back.
       if (size >= MAXPATHL && (flags & P_COMMA) != 0
-          && vim_strchr((char *)(*valuep), ',') != NULL) {
+          && vim_strchr(*valuep, ',') != NULL) {
         part = xmalloc(size);
 
         // write line break to clear the option, e.g. ':set rtp='
@@ -3659,7 +3653,7 @@ static int put_setstring(FILE *fd, char *cmd, char *name, char_u **valuep, uint6
         return FAIL;
       }
       xfree(buf);
-    } else if (put_escstr(fd, *valuep, 2) == FAIL) {
+    } else if (put_escstr(fd, (char_u *)(*valuep), 2) == FAIL) {
       return FAIL;
     }
   }
@@ -3798,12 +3792,12 @@ void unset_global_local_option(char *name, void *from)
     break;
   case PV_LCS:
     clear_string_option(&((win_T *)from)->w_p_lcs);
-    set_chars_option((win_T *)from, (char_u **)&((win_T *)from)->w_p_lcs, true);
+    set_chars_option((win_T *)from, &((win_T *)from)->w_p_lcs, true);
     redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_FCS:
     clear_string_option(&((win_T *)from)->w_p_fcs);
-    set_chars_option((win_T *)from, (char_u **)&((win_T *)from)->w_p_fcs, true);
+    set_chars_option((win_T *)from, &((win_T *)from)->w_p_fcs, true);
     redraw_later((win_T *)from, UPD_NOT_VALID);
     break;
   case PV_VE:
@@ -3814,81 +3808,81 @@ void unset_global_local_option(char *name, void *from)
 }
 
 /// Get pointer to option variable, depending on local or global scope.
-static char_u *get_varp_scope(vimoption_T *p, int opt_flags)
+static char *get_varp_scope(vimoption_T *p, int opt_flags)
 {
   if ((opt_flags & OPT_GLOBAL) && p->indir != PV_NONE) {
     if (p->var == VAR_WIN) {
-      return (char_u *)GLOBAL_WO(get_varp(p));
+      return GLOBAL_WO(get_varp(p));
     }
-    return p->var;
+    return (char *)p->var;
   }
   if ((opt_flags & OPT_LOCAL) && ((int)p->indir & PV_BOTH)) {
     switch ((int)p->indir) {
     case PV_FP:
-      return (char_u *)&(curbuf->b_p_fp);
+      return (char *)&(curbuf->b_p_fp);
     case PV_EFM:
-      return (char_u *)&(curbuf->b_p_efm);
+      return (char *)&(curbuf->b_p_efm);
     case PV_GP:
-      return (char_u *)&(curbuf->b_p_gp);
+      return (char *)&(curbuf->b_p_gp);
     case PV_MP:
-      return (char_u *)&(curbuf->b_p_mp);
+      return (char *)&(curbuf->b_p_mp);
     case PV_EP:
-      return (char_u *)&(curbuf->b_p_ep);
+      return (char *)&(curbuf->b_p_ep);
     case PV_KP:
-      return (char_u *)&(curbuf->b_p_kp);
+      return (char *)&(curbuf->b_p_kp);
     case PV_PATH:
-      return (char_u *)&(curbuf->b_p_path);
+      return (char *)&(curbuf->b_p_path);
     case PV_AR:
-      return (char_u *)&(curbuf->b_p_ar);
+      return (char *)&(curbuf->b_p_ar);
     case PV_TAGS:
-      return (char_u *)&(curbuf->b_p_tags);
+      return (char *)&(curbuf->b_p_tags);
     case PV_TC:
-      return (char_u *)&(curbuf->b_p_tc);
+      return (char *)&(curbuf->b_p_tc);
     case PV_SISO:
-      return (char_u *)&(curwin->w_p_siso);
+      return (char *)&(curwin->w_p_siso);
     case PV_SO:
-      return (char_u *)&(curwin->w_p_so);
+      return (char *)&(curwin->w_p_so);
     case PV_DEF:
-      return (char_u *)&(curbuf->b_p_def);
+      return (char *)&(curbuf->b_p_def);
     case PV_INC:
-      return (char_u *)&(curbuf->b_p_inc);
+      return (char *)&(curbuf->b_p_inc);
     case PV_DICT:
-      return (char_u *)&(curbuf->b_p_dict);
+      return (char *)&(curbuf->b_p_dict);
     case PV_TSR:
-      return (char_u *)&(curbuf->b_p_tsr);
+      return (char *)&(curbuf->b_p_tsr);
     case PV_TSRFU:
-      return (char_u *)&(curbuf->b_p_tsrfu);
+      return (char *)&(curbuf->b_p_tsrfu);
     case PV_TFU:
-      return (char_u *)&(curbuf->b_p_tfu);
+      return (char *)&(curbuf->b_p_tfu);
     case PV_SBR:
-      return (char_u *)&(curwin->w_p_sbr);
+      return (char *)&(curwin->w_p_sbr);
     case PV_STL:
-      return (char_u *)&(curwin->w_p_stl);
+      return (char *)&(curwin->w_p_stl);
     case PV_WBR:
-      return (char_u *)&(curwin->w_p_wbr);
+      return (char *)&(curwin->w_p_wbr);
     case PV_UL:
-      return (char_u *)&(curbuf->b_p_ul);
+      return (char *)&(curbuf->b_p_ul);
     case PV_LW:
-      return (char_u *)&(curbuf->b_p_lw);
+      return (char *)&(curbuf->b_p_lw);
     case PV_BKC:
-      return (char_u *)&(curbuf->b_p_bkc);
+      return (char *)&(curbuf->b_p_bkc);
     case PV_MENC:
-      return (char_u *)&(curbuf->b_p_menc);
+      return (char *)&(curbuf->b_p_menc);
     case PV_FCS:
-      return (char_u *)&(curwin->w_p_fcs);
+      return (char *)&(curwin->w_p_fcs);
     case PV_LCS:
-      return (char_u *)&(curwin->w_p_lcs);
+      return (char *)&(curwin->w_p_lcs);
     case PV_VE:
-      return (char_u *)&(curwin->w_p_ve);
+      return (char *)&(curwin->w_p_ve);
     }
     return NULL;     // "cannot happen"
   }
-  return get_varp(p);
+  return (char *)get_varp(p);
 }
 
 /// Get pointer to option variable at 'opt_idx', depending on local or global
 /// scope.
-char_u *get_option_varp_scope(int opt_idx, int opt_flags)
+char *get_option_varp_scope(int opt_idx, int opt_flags)
 {
   return get_varp_scope(&(options[opt_idx]), opt_flags);
 }
@@ -4365,8 +4359,8 @@ void didset_window_options(win_T *wp, bool valid_cursor)
   check_colorcolumn(wp);
   briopt_check(wp);
   fill_culopt_flags(NULL, wp);
-  set_chars_option(wp, (char_u **)&wp->w_p_fcs, true);
-  set_chars_option(wp, (char_u **)&wp->w_p_lcs, true);
+  set_chars_option(wp, &wp->w_p_fcs, true);
+  set_chars_option(wp, &wp->w_p_lcs, true);
   parse_winhl_opt(wp);  // sets w_hl_needs_update also for w_p_winbl
   check_blending(wp);
   set_winbar_win(wp, false, valid_cursor);
@@ -4504,7 +4498,7 @@ void buf_copy_options(buf_T *buf, int flags)
         buf->b_p_swf = p_swf;
         COPY_OPT_SCTX(buf, BV_SWF);
       }
-      buf->b_p_cpt = (char *)vim_strsave(p_cpt);
+      buf->b_p_cpt = xstrdup(p_cpt);
       COPY_OPT_SCTX(buf, BV_CPT);
 #ifdef BACKSLASH_IN_FILENAME
       buf->b_p_csl = vim_strsave(p_csl);
@@ -4514,32 +4508,30 @@ void buf_copy_options(buf_T *buf, int flags)
       COPY_OPT_SCTX(buf, BV_CFU);
       buf->b_p_ofu = xstrdup(p_ofu);
       COPY_OPT_SCTX(buf, BV_OFU);
-      buf->b_p_tfu = (char *)vim_strsave(p_tfu);
+      buf->b_p_tfu = xstrdup(p_tfu);
       COPY_OPT_SCTX(buf, BV_TFU);
       buf->b_p_sts = p_sts;
       COPY_OPT_SCTX(buf, BV_STS);
       buf->b_p_sts_nopaste = p_sts_nopaste;
-      buf->b_p_vsts = (char *)vim_strsave(p_vsts);
+      buf->b_p_vsts = xstrdup(p_vsts);
       COPY_OPT_SCTX(buf, BV_VSTS);
-      if (p_vsts && p_vsts != (char_u *)empty_option) {
+      if (p_vsts && p_vsts != empty_option) {
         (void)tabstop_set(p_vsts, &buf->b_p_vsts_array);
       } else {
         buf->b_p_vsts_array = NULL;
       }
-      buf->b_p_vsts_nopaste = p_vsts_nopaste
-                                ? (char *)vim_strsave(p_vsts_nopaste)
-                                : NULL;
+      buf->b_p_vsts_nopaste = p_vsts_nopaste ? xstrdup(p_vsts_nopaste) : NULL;
       buf->b_p_com = xstrdup(p_com);
       COPY_OPT_SCTX(buf, BV_COM);
-      buf->b_p_cms = (char *)vim_strsave(p_cms);
+      buf->b_p_cms = xstrdup(p_cms);
       COPY_OPT_SCTX(buf, BV_CMS);
-      buf->b_p_fo = (char *)vim_strsave(p_fo);
+      buf->b_p_fo = xstrdup(p_fo);
       COPY_OPT_SCTX(buf, BV_FO);
-      buf->b_p_flp = (char *)vim_strsave(p_flp);
+      buf->b_p_flp = xstrdup(p_flp);
       COPY_OPT_SCTX(buf, BV_FLP);
-      buf->b_p_nf = (char *)vim_strsave(p_nf);
+      buf->b_p_nf = xstrdup(p_nf);
       COPY_OPT_SCTX(buf, BV_NF);
-      buf->b_p_mps = (char *)vim_strsave(p_mps);
+      buf->b_p_mps = xstrdup(p_mps);
       COPY_OPT_SCTX(buf, BV_MPS);
       buf->b_p_si = p_si;
       COPY_OPT_SCTX(buf, BV_SI);
@@ -4569,25 +4561,25 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_smc = p_smc;
       COPY_OPT_SCTX(buf, BV_SMC);
       buf->b_s.b_syn_isk = empty_option;
-      buf->b_s.b_p_spc = (char *)vim_strsave(p_spc);
+      buf->b_s.b_p_spc = xstrdup(p_spc);
       COPY_OPT_SCTX(buf, BV_SPC);
       (void)compile_cap_prog(&buf->b_s);
-      buf->b_s.b_p_spf = (char *)vim_strsave(p_spf);
+      buf->b_s.b_p_spf = xstrdup(p_spf);
       COPY_OPT_SCTX(buf, BV_SPF);
-      buf->b_s.b_p_spl = (char *)vim_strsave(p_spl);
+      buf->b_s.b_p_spl = xstrdup(p_spl);
       COPY_OPT_SCTX(buf, BV_SPL);
-      buf->b_s.b_p_spo = (char *)vim_strsave(p_spo);
+      buf->b_s.b_p_spo = xstrdup(p_spo);
       COPY_OPT_SCTX(buf, BV_SPO);
-      buf->b_p_inde = (char *)vim_strsave(p_inde);
+      buf->b_p_inde = xstrdup(p_inde);
       COPY_OPT_SCTX(buf, BV_INDE);
-      buf->b_p_indk = (char *)vim_strsave(p_indk);
+      buf->b_p_indk = xstrdup(p_indk);
       COPY_OPT_SCTX(buf, BV_INDK);
       buf->b_p_fp = empty_option;
-      buf->b_p_fex = (char *)vim_strsave(p_fex);
+      buf->b_p_fex = xstrdup(p_fex);
       COPY_OPT_SCTX(buf, BV_FEX);
       buf->b_p_sua = xstrdup(p_sua);
       COPY_OPT_SCTX(buf, BV_SUA);
-      buf->b_p_keymap = (char *)vim_strsave(p_keymap);
+      buf->b_p_keymap = xstrdup(p_keymap);
       COPY_OPT_SCTX(buf, BV_KMAP);
       buf->b_kmap_state |= KEYMAP_INIT;
       // This isn't really an option, but copying the langmap and IME
@@ -4614,12 +4606,12 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_tc_flags = 0;
       buf->b_p_def = empty_option;
       buf->b_p_inc = empty_option;
-      buf->b_p_inex = (char *)vim_strsave(p_inex);
+      buf->b_p_inex = xstrdup(p_inex);
       COPY_OPT_SCTX(buf, BV_INEX);
       buf->b_p_dict = empty_option;
       buf->b_p_tsr = empty_option;
       buf->b_p_tsrfu = empty_option;
-      buf->b_p_qe = (char *)vim_strsave(p_qe);
+      buf->b_p_qe = xstrdup(p_qe);
       COPY_OPT_SCTX(buf, BV_QE);
       buf->b_p_udf = p_udf;
       COPY_OPT_SCTX(buf, BV_UDF);
@@ -4634,7 +4626,7 @@ void buf_copy_options(buf_T *buf, int flags)
        */
       if (dont_do_help) {
         buf->b_p_isk = (char *)save_p_isk;
-        if (p_vts && p_vts != (char_u *)empty_option && !buf->b_p_vts_array) {
+        if (p_vts && p_vts != empty_option && !buf->b_p_vts_array) {
           (void)tabstop_set(p_vts, &buf->b_p_vts_array);
         } else {
           buf->b_p_vts_array = NULL;
@@ -4645,9 +4637,9 @@ void buf_copy_options(buf_T *buf, int flags)
         did_isk = true;
         buf->b_p_ts = p_ts;
         COPY_OPT_SCTX(buf, BV_TS);
-        buf->b_p_vts = (char *)vim_strsave(p_vts);
+        buf->b_p_vts = xstrdup(p_vts);
         COPY_OPT_SCTX(buf, BV_VTS);
-        if (p_vts && p_vts != (char_u *)empty_option && !buf->b_p_vts_array) {
+        if (p_vts && p_vts != empty_option && !buf->b_p_vts_array) {
           (void)tabstop_set(p_vts, &buf->b_p_vts_array);
         } else {
           buf->b_p_vts_array = NULL;
@@ -4966,7 +4958,7 @@ void ExpandOldSetting(int *num_file, char ***file)
   if (expand_option_idx >= 0) {
     // Put string of option value in NameBuff.
     option_value2string(&options[expand_option_idx], expand_option_flags);
-    var = NameBuff;
+    var = (char_u *)NameBuff;
   } else {
     var = (char_u *)"";
   }
@@ -4999,9 +4991,7 @@ void ExpandOldSetting(int *num_file, char ***file)
 /// @param opt_flags  OPT_GLOBAL and/or OPT_LOCAL
 static void option_value2string(vimoption_T *opp, int opt_flags)
 {
-  char_u *varp;
-
-  varp = get_varp_scope(opp, opt_flags);
+  char_u *varp = (char_u *)get_varp_scope(opp, opt_flags);
 
   if (opp->flags & P_NUM) {
     long wc = 0;
@@ -5023,7 +5013,7 @@ static void option_value2string(vimoption_T *opp, int opt_flags)
     } else if (opp->flags & P_EXPAND) {
       home_replace(NULL, (char *)varp, (char *)NameBuff, MAXPATHL, false);
       // Translate 'pastetoggle' into special key names.
-    } else if ((char_u **)opp->var == &p_pt) {
+    } else if ((char **)opp->var == &p_pt) {
       str2specialbuf((const char *)p_pt, (char *)NameBuff, MAXPATHL);
     } else {
       STRLCPY(NameBuff, varp, MAXPATHL);
@@ -5052,7 +5042,7 @@ bool shortmess(int x)
   return (p_shm != NULL
           && (vim_strchr(p_shm, x) != NULL
               || (vim_strchr(p_shm, 'a') != NULL
-                  && vim_strchr((char *)SHM_ALL_ABBREVIATIONS, x) != NULL)));
+                  && vim_strchr(SHM_ALL_ABBREVIATIONS, x) != NULL)));
 }
 
 /// paste_option_changed() - Called after p_paste was set or reset.
@@ -5101,9 +5091,7 @@ static void paste_option_changed(void)
       if (p_vsts_nopaste) {
         xfree(p_vsts_nopaste);
       }
-      p_vsts_nopaste = p_vsts && p_vsts != (char_u *)empty_option
-                          ? vim_strsave(p_vsts)
-                          : NULL;
+      p_vsts_nopaste = p_vsts && p_vsts != empty_option ? xstrdup(p_vsts) : NULL;
     }
 
     // Always set the option values, also when 'paste' is set when it is
@@ -5137,9 +5125,9 @@ static void paste_option_changed(void)
     p_sts = 0;
     p_ai = 0;
     if (p_vsts) {
-      free_string_option((char *)p_vsts);
+      free_string_option(p_vsts);
     }
-    p_vsts = (char_u *)empty_option;
+    p_vsts = empty_option;
   } else if (old_p_paste) {
     // Paste switched from on to off: Restore saved values.
 
@@ -5156,7 +5144,7 @@ static void paste_option_changed(void)
       buf->b_p_vsts = buf->b_p_vsts_nopaste ? xstrdup(buf->b_p_vsts_nopaste) : empty_option;
       xfree(buf->b_p_vsts_array);
       if (buf->b_p_vsts && buf->b_p_vsts != empty_option) {
-        (void)tabstop_set((char_u *)buf->b_p_vsts, &buf->b_p_vsts_array);
+        (void)tabstop_set(buf->b_p_vsts, &buf->b_p_vsts_array);
       } else {
         buf->b_p_vsts_array = NULL;
       }
@@ -5178,9 +5166,9 @@ static void paste_option_changed(void)
     p_tw = p_tw_nopaste;
     p_wm = p_wm_nopaste;
     if (p_vsts) {
-      free_string_option((char *)p_vsts);
+      free_string_option(p_vsts);
     }
-    p_vsts = p_vsts_nopaste ? vim_strsave(p_vsts_nopaste) : (char_u *)empty_option;
+    p_vsts = p_vsts_nopaste ? xstrdup(p_vsts_nopaste) : empty_option;
   }
 
   old_p_paste = p_paste;
@@ -5248,20 +5236,20 @@ void fill_breakat_flags(void)
   }
 
   if (p_breakat != NULL) {
-    for (p = p_breakat; *p; p++) {
+    for (p = (char_u *)p_breakat; *p; p++) {
       breakat_flags[*p] = true;
     }
   }
 }
 
 /// fill_culopt_flags() -- called when 'culopt' changes value
-int fill_culopt_flags(char_u *val, win_T *wp)
+int fill_culopt_flags(char *val, win_T *wp)
 {
-  char_u *p;
+  char *p;
   char_u culopt_flags_new = 0;
 
   if (val == NULL) {
-    p = (char_u *)wp->w_p_culopt;
+    p = wp->w_p_culopt;
   } else {
     p = val;
   }
@@ -5473,7 +5461,7 @@ void set_fileformat(int eol_style, int opt_flags)
 }
 
 /// Skip to next part of an option argument: skip space and comma
-char_u *skip_to_option_part(const char_u *p)
+char *skip_to_option_part(const char *p)
 {
   if (*p == ',') {
     p++;
@@ -5481,7 +5469,7 @@ char_u *skip_to_option_part(const char_u *p)
   while (*p == ' ') {
     p++;
   }
-  return (char_u *)p;
+  return (char *)p;
 }
 
 /// Isolate one part of a string option separated by `sep_chars`.
@@ -5516,7 +5504,7 @@ size_t copy_option_part(char **option, char *buf, size_t maxlen, char *sep_chars
   if (*p != NUL && *p != ',') {  // skip non-standard separator
     p++;
   }
-  p = (char *)skip_to_option_part((char_u *)p);    // p points to next file name
+  p = skip_to_option_part(p);    // p points to next file name
 
   *option = p;
   return len;
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 59b8485272..6af6b16e86 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -258,7 +258,7 @@ enum {
   SHM_SEARCHCOUNT    = 'S',  ///< Search sats: '[1/10]'
 };
 /// Represented by 'a' flag.
-#define SHM_ALL_ABBREVIATIONS ((char_u[]) { \
+#define SHM_ALL_ABBREVIATIONS ((char[]) { \
     SHM_RO, SHM_MOD, SHM_FILE, SHM_LAST, SHM_TEXT, SHM_LINES, SHM_NEW, SHM_WRI, \
     0, \
   })
@@ -440,9 +440,9 @@ EXTERN unsigned bo_flags;
 #define BO_WILD   0x40000
 
 EXTERN char_u *p_bsk;         // 'backupskip'
-EXTERN char_u *p_breakat;     // 'breakat'
-EXTERN char_u *p_bh;          ///< 'bufhidden'
-EXTERN char_u *p_bt;          ///< 'buftype'
+EXTERN char *p_breakat;       // 'breakat'
+EXTERN char *p_bh;            ///< 'bufhidden'
+EXTERN char *p_bt;            ///< 'buftype'
 EXTERN char *p_cmp;           // 'casemap'
 EXTERN unsigned cmp_flags;
 #define CMP_INTERNAL           0x001
@@ -459,8 +459,8 @@ EXTERN unsigned cb_flags;
 #define CB_UNNAMEDMASK         (CB_UNNAMED | CB_UNNAMEDPLUS)
 EXTERN long p_cwh;              // 'cmdwinheight'
 EXTERN long p_ch;               // 'cmdheight'
-EXTERN char_u *p_cms;           ///< 'commentstring'
-EXTERN char_u *p_cpt;           ///< 'complete'
+EXTERN char *p_cms;             ///< 'commentstring'
+EXTERN char *p_cpt;             ///< 'complete'
 EXTERN long p_columns;          // 'columns'
 EXTERN int p_confirm;           // 'confirm'
 EXTERN char *p_cot;             // 'completeopt'
@@ -533,9 +533,9 @@ EXTERN unsigned fdo_flags;
 #define FDO_INSERT             0x100
 #define FDO_UNDO               0x200
 #define FDO_JUMP               0x400
-EXTERN char_u *p_fex;           ///< 'formatexpr'
-EXTERN char_u *p_flp;           ///< 'formatlistpat'
-EXTERN char_u *p_fo;            ///< 'formatoptions'
+EXTERN char *p_fex;             ///< 'formatexpr'
+EXTERN char *p_flp;             ///< 'formatlistpat'
+EXTERN char *p_fo;              ///< 'formatoptions'
 EXTERN char_u *p_fp;            // 'formatprg'
 EXTERN int p_fs;                // 'fsync'
 EXTERN int p_gd;                // 'gdefault'
@@ -566,10 +566,10 @@ EXTERN int p_ic;                // 'ignorecase'
 EXTERN long p_iminsert;         ///< 'iminsert'
 EXTERN long p_imsearch;         ///< 'imsearch'
 EXTERN int p_inf;               ///< 'infercase'
-EXTERN char_u *p_inex;          ///< 'includeexpr'
+EXTERN char *p_inex;            ///< 'includeexpr'
 EXTERN int p_is;                // 'incsearch'
-EXTERN char_u *p_inde;          ///< 'indentexpr'
-EXTERN char_u *p_indk;          ///< 'indentkeys'
+EXTERN char *p_inde;            ///< 'indentexpr'
+EXTERN char *p_indk;            ///< 'indentkeys'
 EXTERN char *p_icm;             // 'inccommand'
 EXTERN char *p_isf;             // 'isfname'
 EXTERN char *p_isi;             // 'isident'
@@ -580,7 +580,7 @@ EXTERN char *p_jop;             // 'jumpooptions'
 EXTERN unsigned jop_flags;
 #define JOP_STACK               0x01
 #define JOP_VIEW                0x02
-EXTERN char_u *p_keymap;        ///< 'keymap'
+EXTERN char *p_keymap;          ///< 'keymap'
 EXTERN char_u *p_kp;            // 'keywordprg'
 EXTERN char *p_km;              // 'keymodel'
 EXTERN char *p_langmap;         // 'langmap'
@@ -598,11 +598,11 @@ EXTERN char *p_lcs;             // 'listchars'
 EXTERN int p_lz;                // 'lazyredraw'
 EXTERN int p_lpl;               // 'loadplugins'
 EXTERN int p_magic;             // 'magic'
-EXTERN char_u *p_menc;        // 'makeencoding'
-EXTERN char *p_mef;         // 'makeef'
-EXTERN char_u *p_mp;          // 'makeprg'
-EXTERN char_u *p_mps;           ///< 'matchpairs'
-EXTERN char_u *p_cc;          // 'colorcolumn'
+EXTERN char *p_menc;            // 'makeencoding'
+EXTERN char *p_mef;             // 'makeef'
+EXTERN char_u *p_mp;            // 'makeprg'
+EXTERN char *p_mps;             ///< 'matchpairs'
+EXTERN char_u *p_cc;            // 'colorcolumn'
 EXTERN int p_cc_cols[256];      // array for 'colorcolumn' columns
 EXTERN long p_mat;              // 'matchtime'
 EXTERN long p_mco;              // 'maxcombine'
@@ -624,18 +624,18 @@ EXTERN long p_mousescroll_vert INIT(= MOUSESCROLL_VERT_DFLT);
 EXTERN long p_mousescroll_hor INIT(= MOUSESCROLL_HOR_DFLT);
 EXTERN long p_mouset;           // 'mousetime'
 EXTERN int p_more;              // 'more'
-EXTERN char_u *p_nf;            ///< 'nrformats'
+EXTERN char *p_nf;              ///< 'nrformats'
 EXTERN char *p_opfunc;          // 'operatorfunc'
-EXTERN char_u *p_para;        // 'paragraphs'
+EXTERN char_u *p_para;          // 'paragraphs'
 EXTERN int p_paste;             // 'paste'
-EXTERN char_u *p_pt;          // 'pastetoggle'
-EXTERN char_u *p_pex;         // 'patchexpr'
-EXTERN char *p_pm;            // 'patchmode'
-EXTERN char_u *p_path;        // 'path'
-EXTERN char_u *p_cdpath;      // 'cdpath'
+EXTERN char *p_pt;              // 'pastetoggle'
+EXTERN char_u *p_pex;           // 'patchexpr'
+EXTERN char *p_pm;              // 'patchmode'
+EXTERN char_u *p_path;          // 'path'
+EXTERN char_u *p_cdpath;        // 'cdpath'
 EXTERN int p_pi;                ///< 'preserveindent'
 EXTERN long p_pyx;              // 'pyxversion'
-EXTERN char_u *p_qe;            ///< 'quoteescape'
+EXTERN char *p_qe;              ///< 'quoteescape'
 EXTERN int p_ro;                ///< 'readonly'
 EXTERN char *p_rdb;             // 'redrawdebug'
 EXTERN unsigned rdb_flags;
@@ -685,13 +685,13 @@ EXTERN unsigned ssop_flags;
 #define SSOP_TERMINAL          0x10000
 #define SSOP_SKIP_RTP          0x20000
 
-EXTERN char_u *p_sh;          // 'shell'
-EXTERN char_u *p_shcf;        // 'shellcmdflag'
-EXTERN char_u *p_sp;          // 'shellpipe'
-EXTERN char_u *p_shq;         // 'shellquote'
-EXTERN char_u *p_sxq;         // 'shellxquote'
-EXTERN char_u *p_sxe;         // 'shellxescape'
-EXTERN char_u *p_srr;         // 'shellredir'
+EXTERN char_u *p_sh;            // 'shell'
+EXTERN char_u *p_shcf;          // 'shellcmdflag'
+EXTERN char *p_sp;              // 'shellpipe'
+EXTERN char_u *p_shq;           // 'shellquote'
+EXTERN char_u *p_sxq;           // 'shellxquote'
+EXTERN char_u *p_sxe;           // 'shellxescape'
+EXTERN char *p_srr;             // 'shellredir'
 EXTERN int p_stmp;              // 'shelltemp'
 #ifdef BACKSLASH_IN_FILENAME
 EXTERN int p_ssl;               // 'shellslash'
@@ -727,11 +727,11 @@ EXTERN unsigned int tpf_flags;  ///< flags from 'termpastefilter'
 #define TPF_DEL                0x010
 #define TPF_C0                 0x020
 #define TPF_C1                 0x040
-EXTERN char_u *p_tfu;           ///< 'tagfunc'
-EXTERN char_u *p_spc;           ///< 'spellcapcheck'
-EXTERN char_u *p_spf;           ///< 'spellfile'
-EXTERN char_u *p_spl;           ///< 'spelllang'
-EXTERN char_u *p_spo;           // 'spelloptions'
+EXTERN char *p_tfu;             ///< 'tagfunc'
+EXTERN char *p_spc;             ///< 'spellcapcheck'
+EXTERN char *p_spf;             ///< 'spellfile'
+EXTERN char *p_spl;             ///< 'spelllang'
+EXTERN char *p_spo;             // 'spelloptions'
 EXTERN char *p_sps;             // 'spellsuggest'
 EXTERN int p_spr;               // 'splitright'
 EXTERN int p_sol;               // 'startofline'
@@ -745,7 +745,7 @@ EXTERN unsigned swb_flags;
 #define SWB_NEWTAB              0x008
 #define SWB_VSPLIT              0x010
 #define SWB_USELAST             0x020
-EXTERN char_u *p_syn;           ///< 'syntax'
+EXTERN char *p_syn;             ///< 'syntax'
 EXTERN long p_ts;               ///< 'tabstop'
 EXTERN int p_tbs;               ///< 'tagbsearch'
 EXTERN char *p_tc;              ///< 'tagcase'
@@ -780,13 +780,13 @@ EXTERN long p_uc;               ///< 'updatecount'
 EXTERN long p_ut;               ///< 'updatetime'
 EXTERN char *p_shada;           ///< 'shada'
 EXTERN char *p_shadafile;       ///< 'shadafile'
-EXTERN char_u *p_vsts;          ///< 'varsofttabstop'
-EXTERN char_u *p_vts;           ///< 'vartabstop'
+EXTERN char *p_vsts;            ///< 'varsofttabstop'
+EXTERN char *p_vts;             ///< 'vartabstop'
 EXTERN char_u *p_vdir;          ///< 'viewdir'
 EXTERN char *p_vop;             ///< 'viewoptions'
 EXTERN unsigned vop_flags;      ///< uses SSOP_ flags
 EXTERN int p_vb;                ///< 'visualbell'
-EXTERN char_u *p_ve;            ///< 'virtualedit'
+EXTERN char *p_ve;              ///< 'virtualedit'
 EXTERN unsigned ve_flags;
 #define VE_BLOCK       5U      // includes "all"
 #define VE_INSERT      6U      // includes "all"
@@ -798,7 +798,7 @@ EXTERN long p_verbose;          // 'verbose'
 #ifdef IN_OPTION_C
 char_u *p_vfile = (char_u *)"";   // used before options are initialized
 #else
-extern char_u *p_vfile;       // 'verbosefile'
+extern char *p_vfile;           // 'verbosefile'
 #endif
 EXTERN int p_warn;              // 'warn'
 EXTERN char *p_wop;             // 'wildoptions'
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 808a70c8cb..1bdfcbecb9 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -113,30 +113,30 @@ static char *(p_tpf_values[]) = { "BS", "HT", "FF", "ESC", "DEL", "C0", "C1", NU
 static char *(p_rdb_values[]) = { "compositor", "nothrottle", "invalid", "nodelta", NULL };
 
 /// All possible flags for 'shm'.
-static char_u SHM_ALL[] = { SHM_RO, SHM_MOD, SHM_FILE, SHM_LAST, SHM_TEXT, SHM_LINES, SHM_NEW,
-                            SHM_WRI, SHM_ABBREVIATIONS, SHM_WRITE, SHM_TRUNC, SHM_TRUNCALL,
-                            SHM_OVER, SHM_OVERALL, SHM_SEARCH, SHM_ATTENTION, SHM_INTRO,
-                            SHM_COMPLETIONMENU, SHM_RECORDING, SHM_FILEINFO, SHM_SEARCHCOUNT, 0, };
+static char SHM_ALL[] = { SHM_RO, SHM_MOD, SHM_FILE, SHM_LAST, SHM_TEXT, SHM_LINES, SHM_NEW,
+                          SHM_WRI, SHM_ABBREVIATIONS, SHM_WRITE, SHM_TRUNC, SHM_TRUNCALL,
+                          SHM_OVER, SHM_OVERALL, SHM_SEARCH, SHM_ATTENTION, SHM_INTRO,
+                          SHM_COMPLETIONMENU, SHM_RECORDING, SHM_FILEINFO, SHM_SEARCHCOUNT, 0, };
 
 /// After setting various option values: recompute variables that depend on
 /// option values.
 void didset_string_options(void)
 {
-  (void)opt_strings_flags((char_u *)p_cmp, p_cmp_values, &cmp_flags, true);
-  (void)opt_strings_flags((char_u *)p_bkc, p_bkc_values, &bkc_flags, true);
-  (void)opt_strings_flags((char_u *)p_bo, p_bo_values, &bo_flags, true);
-  (void)opt_strings_flags((char_u *)p_ssop, p_ssop_values, &ssop_flags, true);
-  (void)opt_strings_flags((char_u *)p_vop, p_ssop_values, &vop_flags, true);
-  (void)opt_strings_flags((char_u *)p_fdo, p_fdo_values, &fdo_flags, true);
-  (void)opt_strings_flags((char_u *)p_dy, p_dy_values, &dy_flags, true);
-  (void)opt_strings_flags((char_u *)p_rdb, p_rdb_values, &rdb_flags, true);
-  (void)opt_strings_flags((char_u *)p_tc, p_tc_values, &tc_flags, false);
-  (void)opt_strings_flags((char_u *)p_tpf, p_tpf_values, &tpf_flags, true);
+  (void)opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true);
+  (void)opt_strings_flags(p_bkc, p_bkc_values, &bkc_flags, true);
+  (void)opt_strings_flags(p_bo, p_bo_values, &bo_flags, true);
+  (void)opt_strings_flags(p_ssop, p_ssop_values, &ssop_flags, true);
+  (void)opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true);
+  (void)opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true);
+  (void)opt_strings_flags(p_dy, p_dy_values, &dy_flags, true);
+  (void)opt_strings_flags(p_rdb, p_rdb_values, &rdb_flags, true);
+  (void)opt_strings_flags(p_tc, p_tc_values, &tc_flags, false);
+  (void)opt_strings_flags(p_tpf, p_tpf_values, &tpf_flags, true);
   (void)opt_strings_flags(p_ve, p_ve_values, &ve_flags, true);
-  (void)opt_strings_flags((char_u *)p_swb, p_swb_values, &swb_flags, true);
-  (void)opt_strings_flags((char_u *)p_wop, p_wop_values, &wop_flags, true);
-  (void)opt_strings_flags((char_u *)p_jop, p_jop_values, &jop_flags, true);
-  (void)opt_strings_flags((char_u *)p_cb, p_cb_values, &cb_flags, true);
+  (void)opt_strings_flags(p_swb, p_swb_values, &swb_flags, true);
+  (void)opt_strings_flags(p_wop, p_wop_values, &wop_flags, true);
+  (void)opt_strings_flags(p_jop, p_jop_values, &jop_flags, true);
+  (void)opt_strings_flags(p_cb, p_cb_values, &cb_flags, true);
 }
 
 /// Trigger the OptionSet autocommand.
@@ -448,7 +448,7 @@ char *set_string_option(const int opt_idx, const char *const value, const int op
 
 /// Return true if "val" is a valid 'filetype' name.
 /// Also used for 'syntax' and 'keymap'.
-static bool valid_filetype(const char_u *val)
+static bool valid_filetype(const char *val)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   return valid_name(val, ".-_");
@@ -520,7 +520,7 @@ static char *check_mousescroll(char *string)
 /// Handle setting 'signcolumn' for value 'val'
 ///
 /// @return OK when the value is valid, FAIL otherwise
-static int check_signcolumn(char_u *val)
+static int check_signcolumn(char *val)
 {
   if (*val == NUL) {
     return FAIL;
@@ -637,13 +637,12 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
   char *errmsg = NULL;
   char *s, *p;
   int did_chartab = false;
-  char_u **gvarp;
   bool free_oldval = (get_option_flags(opt_idx) & P_ALLOCED);
   bool value_changed = false;
 
   // Get the global option to compare with, otherwise we would have to check
   // two values for all local options.
-  gvarp = (char_u **)get_option_varp_scope(opt_idx, OPT_GLOBAL);
+  char **gvarp = (char **)get_option_varp_scope(opt_idx, OPT_GLOBAL);
 
   // Disallow changing some options from secure mode
   if ((secure || sandbox != 0)
@@ -657,7 +656,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     // path separator (slash and/or backslash), wildcards and characters that
     // are often illegal in a file name. Be more permissive if "secure" is off.
     errmsg = e_invarg;
-  } else if (gvarp == (char_u **)&p_bkc) {  // 'backupcopy'
+  } else if (gvarp == &p_bkc) {  // 'backupcopy'
     char *bkc = p_bkc;
     unsigned int *flags = &bkc_flags;
 
@@ -670,7 +669,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       // make the local value empty: use the global value
       *flags = 0;
     } else {
-      if (opt_strings_flags((char_u *)bkc, p_bkc_values, flags, true) != OK) {
+      if (opt_strings_flags(bkc, p_bkc_values, flags, true) != OK) {
         errmsg = e_invarg;
       }
 
@@ -678,7 +677,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
           + ((*flags & BKC_YES) != 0)
           + ((*flags & BKC_NO) != 0) != 1) {
         // Must have exactly one of "auto", "yes"  and "no".
-        (void)opt_strings_flags((char_u *)oldval, p_bkc_values, flags, true);
+        (void)opt_strings_flags(oldval, p_bkc_values, flags, true);
         errmsg = e_invarg;
       }
     }
@@ -713,8 +712,8 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
   } else if (varp == &p_rtp || varp == &p_pp) {  // 'runtimepath' 'packpath'
     runtime_search_path_invalidate();
   } else if (varp == &curwin->w_p_culopt
-             || gvarp == (char_u **)&curwin->w_allbuf_opt.wo_culopt) {  // 'cursorlineopt'
-    if (**varp == NUL || fill_culopt_flags((char_u *)(*varp), curwin) != OK) {
+             || gvarp == &curwin->w_allbuf_opt.wo_culopt) {  // 'cursorlineopt'
+    if (**varp == NUL || fill_culopt_flags(*varp, curwin) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &curwin->w_p_cc) {  // 'colorcolumn'
@@ -735,42 +734,42 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       errmsg = e_unsupportedoption;
     }
   } else if (varp == &p_jop) {  // 'jumpoptions'
-    if (opt_strings_flags((char_u *)p_jop, p_jop_values, &jop_flags, true) != OK) {
+    if (opt_strings_flags(p_jop, p_jop_values, &jop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_nf) {  // 'nrformats'
-    if (check_opt_strings((char_u *)(*varp), p_nf_values, true) != OK) {
+    if (check_opt_strings(*varp, p_nf_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ssop) {  // 'sessionoptions'
-    if (opt_strings_flags((char_u *)p_ssop, p_ssop_values, &ssop_flags, true) != OK) {
+    if (opt_strings_flags(p_ssop, p_ssop_values, &ssop_flags, true) != OK) {
       errmsg = e_invarg;
     }
     if ((ssop_flags & SSOP_CURDIR) && (ssop_flags & SSOP_SESDIR)) {
       // Don't allow both "sesdir" and "curdir".
-      (void)opt_strings_flags((char_u *)oldval, p_ssop_values, &ssop_flags, true);
+      (void)opt_strings_flags(oldval, p_ssop_values, &ssop_flags, true);
       errmsg = e_invarg;
     }
   } else if (varp == &p_vop) {  // 'viewoptions'
-    if (opt_strings_flags((char_u *)p_vop, p_ssop_values, &vop_flags, true) != OK) {
+    if (opt_strings_flags(p_vop, p_ssop_values, &vop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_rdb) {  // 'redrawdebug'
-    if (opt_strings_flags((char_u *)p_rdb, p_rdb_values, &rdb_flags, true) != OK) {
+    if (opt_strings_flags(p_rdb, p_rdb_values, &rdb_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_sbo) {  // 'scrollopt'
-    if (check_opt_strings((char_u *)p_sbo, p_scbopt_values, true) != OK) {
+    if (check_opt_strings(p_sbo, p_scbopt_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ambw || (int *)varp == &p_emoji) {  // 'ambiwidth'
-    if (check_opt_strings((char_u *)p_ambw, p_ambw_values, false) != OK) {
+    if (check_opt_strings(p_ambw, p_ambw_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       errmsg = check_chars_options();
     }
   } else if (varp == &p_bg) {  // 'background'
-    if (check_opt_strings((char_u *)p_bg, p_bg_values, false) == OK) {
+    if (check_opt_strings(p_bg, p_bg_values, false) == OK) {
       int dark = (*p_bg == 'd');
 
       init_highlight(false, false);
@@ -793,21 +792,21 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       errmsg = e_invarg;
     }
   } else if (varp == &p_wop) {  // 'wildoptions'
-    if (opt_strings_flags((char_u *)p_wop, p_wop_values, &wop_flags, true) != OK) {
+    if (opt_strings_flags(p_wop, p_wop_values, &wop_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_wak) {  // 'winaltkeys'
     if (*p_wak == NUL
-        || check_opt_strings((char_u *)p_wak, p_wak_values, false) != OK) {
+        || check_opt_strings(p_wak, p_wak_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_ei) {  // 'eventignore'
     if (check_ei() == FAIL) {
       errmsg = e_invarg;
     }
-  } else if (varp == &p_enc || gvarp == (char_u **)&p_fenc || gvarp == &p_menc) {
+  } else if (varp == &p_enc || gvarp == &p_fenc || gvarp == &p_menc) {
     // 'encoding', 'fileencoding' and 'makeencoding'
-    if (gvarp == (char_u **)&p_fenc) {
+    if (gvarp == &p_fenc) {
       if (!MODIFIABLE(curbuf) && opt_flags != OPT_GLOBAL) {
         errmsg = e_modifiable;
       } else if (vim_strchr(*varp, ',') != NULL) {
@@ -824,7 +823,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
 
     if (errmsg == NULL) {
       // canonize the value, so that STRCMP() can be used on it
-      p = (char *)enc_canonize((char_u *)(*varp));
+      p = enc_canonize(*varp);
       xfree(*varp);
       *varp = p;
       if (varp == &p_enc) {
@@ -838,11 +837,11 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     }
   } else if (varp == &p_penc) {
     // Canonize printencoding if VIM standard one
-    p = (char *)enc_canonize((char_u *)p_penc);
+    p = enc_canonize(p_penc);
     xfree(p_penc);
     p_penc = p;
   } else if (varp == &curbuf->b_p_keymap) {
-    if (!valid_filetype((char_u *)(*varp))) {
+    if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
       int secure_save = secure;
@@ -883,10 +882,10 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
       status_redraw_curbuf();
     }
-  } else if (gvarp == (char_u **)&p_ff) {  // 'fileformat'
+  } else if (gvarp == &p_ff) {  // 'fileformat'
     if (!MODIFIABLE(curbuf) && !(opt_flags & OPT_GLOBAL)) {
       errmsg = e_modifiable;
-    } else if (check_opt_strings((char_u *)(*varp), p_ff_values, false) != OK) {
+    } else if (check_opt_strings(*varp, p_ff_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       redraw_titles();
@@ -899,7 +898,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
   } else if (varp == &p_ffs) {  // 'fileformats'
-    if (check_opt_strings((char_u *)p_ffs, p_ff_values, true) != OK) {
+    if (check_opt_strings(p_ffs, p_ff_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_mps) {  // 'matchpairs'
@@ -923,7 +922,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
         break;
       }
     }
-  } else if (gvarp == (char_u **)&p_com) {  // 'comments'
+  } else if (gvarp == &p_com) {  // 'comments'
     for (s = *varp; *s;) {
       while (*s && *s != ':') {
         if (vim_strchr(COM_ALL, *s) == NULL
@@ -947,13 +946,13 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
         }
         s++;
       }
-      s = (char *)skip_to_option_part((char_u *)s);
+      s = skip_to_option_part(s);
     }
   } else if (varp == &p_lcs || varp == &p_fcs) {  // global 'listchars' or 'fillchars'
     char **local_ptr = varp == &p_lcs ? &curwin->w_p_lcs : &curwin->w_p_fcs;
     // only apply the global value to "curwin" when it does not have a local value
     errmsg =
-      set_chars_option(curwin, (char_u **)varp, **local_ptr == NUL || !(opt_flags & OPT_GLOBAL));
+      set_chars_option(curwin, varp, **local_ptr == NUL || !(opt_flags & OPT_GLOBAL));
     if (errmsg == NULL) {
       // If the current window is set to use the global
       // 'listchars'/'fillchars' value, clear the window-local value.
@@ -967,18 +966,18 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
         // here, so ignore the return value.
         local_ptr = varp == &p_lcs ? &wp->w_p_lcs : &wp->w_p_fcs;
         if (**local_ptr == NUL) {
-          (void)set_chars_option(wp, (char_u **)local_ptr, true);
+          (void)set_chars_option(wp, local_ptr, true);
         }
       }
       redraw_all_later(UPD_NOT_VALID);
     }
   } else if (varp == &curwin->w_p_lcs) {  // local 'listchars'
-    errmsg = set_chars_option(curwin, (char_u **)varp, true);
+    errmsg = set_chars_option(curwin, varp, true);
   } else if (varp == &curwin->w_p_fcs) {  // local 'fillchars'
-    errmsg = set_chars_option(curwin, (char_u **)varp, true);
+    errmsg = set_chars_option(curwin, varp, true);
   } else if (varp == &p_cedit) {  // 'cedit'
     errmsg = check_cedit();
-  } else if (varp == (char **)&p_vfile) {  // 'verbosefile'
+  } else if (varp == &p_vfile) {  // 'verbosefile'
     verbose_stop();
     if (*p_vfile != NUL && verbose_open() == FAIL) {
       errmsg = e_invarg;
@@ -1037,7 +1036,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     if (*p_shada && errmsg == NULL && get_shada_parameter('\'') < 0) {
       errmsg = N_("E528: Must specify a ' value");
     }
-  } else if (gvarp == (char_u **)&p_sbr) {  // 'showbreak'
+  } else if (gvarp == &p_sbr) {  // 'showbreak'
     for (s = *varp; *s;) {
       if (ptr2cells(s) != 1) {
         errmsg = e_showbreak_contains_unprintable_or_wide_character;
@@ -1052,7 +1051,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     errmsg = parse_printmbfont();
   } else if (varp == &p_langmap) {  // 'langmap'
     langmap_set();
-  } else if (varp == (char **)&p_breakat) {  // 'breakat'
+  } else if (varp == &p_breakat) {  // 'breakat'
     fill_breakat_flags();
   } else if (varp == &p_titlestring || varp == &p_iconstring) {
     // 'titlestring' and 'iconstring'
@@ -1067,47 +1066,47 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     did_set_title();
   } else if (varp == &p_sel) {  // 'selection'
     if (*p_sel == NUL
-        || check_opt_strings((char_u *)p_sel, p_sel_values, false) != OK) {
+        || check_opt_strings(p_sel, p_sel_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_slm) {  // 'selectmode'
-    if (check_opt_strings((char_u *)p_slm, p_slm_values, true) != OK) {
+    if (check_opt_strings(p_slm, p_slm_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_km) {  // 'keymodel'
-    if (check_opt_strings((char_u *)p_km, p_km_values, true) != OK) {
+    if (check_opt_strings(p_km, p_km_values, true) != OK) {
       errmsg = e_invarg;
     } else {
       km_stopsel = (vim_strchr(p_km, 'o') != NULL);
       km_startsel = (vim_strchr(p_km, 'a') != NULL);
     }
   } else if (varp == &p_mousem) {  // 'mousemodel'
-    if (check_opt_strings((char_u *)p_mousem, p_mousem_values, false) != OK) {
+    if (check_opt_strings(p_mousem, p_mousem_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_mousescroll) {  // 'mousescroll'
     errmsg = check_mousescroll(p_mousescroll);
   } else if (varp == &p_swb) {  // 'switchbuf'
-    if (opt_strings_flags((char_u *)p_swb, p_swb_values, &swb_flags, true) != OK) {
+    if (opt_strings_flags(p_swb, p_swb_values, &swb_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_debug) {  // 'debug'
-    if (check_opt_strings((char_u *)p_debug, p_debug_values, true) != OK) {
+    if (check_opt_strings(p_debug, p_debug_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_dy) {  // 'display'
-    if (opt_strings_flags((char_u *)p_dy, p_dy_values, &dy_flags, true) != OK) {
+    if (opt_strings_flags(p_dy, p_dy_values, &dy_flags, true) != OK) {
       errmsg = e_invarg;
     } else {
       (void)init_chartab();
       msg_grid_validate();
     }
   } else if (varp == &p_ead) {  // 'eadirection'
-    if (check_opt_strings((char_u *)p_ead, p_ead_values, false) != OK) {
+    if (check_opt_strings(p_ead, p_ead_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_cb) {  // 'clipboard'
-    if (opt_strings_flags((char_u *)p_cb, p_cb_values, &cb_flags, true) != OK) {
+    if (opt_strings_flags(p_cb, p_cb_values, &cb_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &(curwin->w_s->b_p_spl)  // 'spell'
@@ -1116,8 +1115,8 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     // buffer in which 'spell' is set load the wordlists.
     const bool is_spellfile = varp == &(curwin->w_s->b_p_spf);
 
-    if ((is_spellfile && !valid_spellfile((char_u *)(*varp)))
-        || (!is_spellfile && !valid_spelllang((char_u *)(*varp)))) {
+    if ((is_spellfile && !valid_spellfile(*varp))
+        || (!is_spellfile && !valid_spelllang(*varp))) {
       errmsg = e_invarg;
     } else {
       errmsg = did_set_spell_option(is_spellfile);
@@ -1139,14 +1138,14 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     }
   } else if (gvarp == &p_bh) {
     // When 'bufhidden' is set, check for valid value.
-    if (check_opt_strings((char_u *)curbuf->b_p_bh, p_bufhidden_values, false) != OK) {
+    if (check_opt_strings(curbuf->b_p_bh, p_bufhidden_values, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (gvarp == &p_bt) {
     // When 'buftype' is set, check for valid value.
     if ((curbuf->terminal && curbuf->b_p_bt[0] != 't')
         || (!curbuf->terminal && curbuf->b_p_bt[0] == 't')
-        || check_opt_strings((char_u *)curbuf->b_p_bt, p_buftype_values, false) != OK) {
+        || check_opt_strings(curbuf->b_p_bt, p_buftype_values, false) != OK) {
       errmsg = e_invarg;
     } else {
       if (curwin->w_status_height || global_stl_height()) {
@@ -1156,7 +1155,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       curbuf->b_help = (curbuf->b_p_bt[0] == 'h');
       redraw_titles();
     }
-  } else if (gvarp == (char_u **)&p_stl || gvarp == (char_u **)&p_wbr || varp == &p_tal
+  } else if (gvarp == &p_stl || gvarp == &p_wbr || varp == &p_tal
              || varp == &p_ruf) {
     // 'statusline', 'winbar', 'tabline' or 'rulerformat'
     int wid;
@@ -1184,7 +1183,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       comp_col();
     }
     // add / remove window bars for 'winbar'
-    if (gvarp == (char_u **)&p_wbr) {
+    if (gvarp == &p_wbr) {
       set_winbar(true);
     }
   } else if (gvarp == &p_cpt) {
@@ -1223,7 +1222,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
   } else if (varp == &p_cot) {  // 'completeopt'
-    if (check_opt_strings((char_u *)p_cot, p_cot_values, true) != OK) {
+    if (check_opt_strings(p_cot, p_cot_values, true) != OK) {
       errmsg = e_invarg;
     } else {
       completeopt_was_set();
@@ -1236,7 +1235,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     }
 #endif
   } else if (varp == &curwin->w_p_scl) {  // 'signcolumn'
-    if (check_signcolumn((char_u *)(*varp)) != OK) {
+    if (check_signcolumn(*varp) != OK) {
       errmsg = e_invarg;
     }
     // When changing the 'signcolumn' to or from 'number', recompute the
@@ -1249,20 +1248,20 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
   } else if (varp == &curwin->w_p_fdc
              || varp == &curwin->w_allbuf_opt.wo_fdc) {
     // 'foldcolumn'
-    if (**varp == NUL || check_opt_strings((char_u *)(*varp), p_fdc_values, false) != OK) {
+    if (**varp == NUL || check_opt_strings(*varp, p_fdc_values, false) != OK) {
       errmsg = e_invarg;
     }
-  } else if (varp == (char **)&p_pt) {
+  } else if (varp == &p_pt) {
     // 'pastetoggle': translate key codes like in a mapping
     if (*p_pt) {
       p = NULL;
-      (void)replace_termcodes((char *)p_pt,
+      (void)replace_termcodes(p_pt,
                               STRLEN(p_pt),
                               &p, REPTERM_FROM_PART | REPTERM_DO_LT, NULL,
                               CPO_TO_CPO_FLAGS);
       if (p != NULL) {
-        free_string_option((char *)p_pt);
-        p_pt = (char_u *)p;
+        free_string_option(p_pt);
+        p_pt = p;
       }
     }
   } else if (varp == &p_bs) {  // 'backspace'
@@ -1270,14 +1269,14 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       if (*p_bs > '3' || p_bs[1] != NUL) {
         errmsg = e_invarg;
       }
-    } else if (check_opt_strings((char_u *)p_bs, p_bs_values, true) != OK) {
+    } else if (check_opt_strings(p_bs, p_bs_values, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_bo) {
-    if (opt_strings_flags((char_u *)p_bo, p_bo_values, &bo_flags, true) != OK) {
+    if (opt_strings_flags(p_bo, p_bo_values, &bo_flags, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == (char_u **)&p_tc) {  // 'tagcase'
+  } else if (gvarp == &p_tc) {  // 'tagcase'
     unsigned int *flags;
 
     if (opt_flags & OPT_LOCAL) {
@@ -1292,19 +1291,19 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       // make the local value empty: use the global value
       *flags = 0;
     } else if (*p == NUL
-               || opt_strings_flags((char_u *)p, p_tc_values, flags, false) != OK) {
+               || opt_strings_flags(p, p_tc_values, flags, false) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_cmp) {  // 'casemap'
-    if (opt_strings_flags((char_u *)p_cmp, p_cmp_values, &cmp_flags, true) != OK) {
+    if (opt_strings_flags(p_cmp, p_cmp_values, &cmp_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_dip) {  // 'diffopt'
     if (diffopt_changed() == FAIL) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdm) {  // 'foldmethod'
-    if (check_opt_strings((char_u *)(*varp), p_fdm_values, false) != OK
+  } else if (gvarp == &curwin->w_allbuf_opt.wo_fdm) {  // 'foldmethod'
+    if (check_opt_strings(*varp, p_fdm_values, false) != OK
         || *curwin->w_p_fdm == NUL) {
       errmsg = e_invarg;
     } else {
@@ -1317,7 +1316,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     if (foldmethodIsExpr(curwin)) {
       foldUpdateAll(curwin);
     }
-  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fmr) {  // 'foldmarker'
+  } else if (gvarp == &curwin->w_allbuf_opt.wo_fmr) {  // 'foldmarker'
     p = vim_strchr(*varp, ',');
     if (p == NULL) {
       errmsg = N_("E536: comma required");
@@ -1331,23 +1330,23 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       errmsg = N_("E537: 'commentstring' must be empty or contain %s");
     }
   } else if (varp == &p_fdo) {  // 'foldopen'
-    if (opt_strings_flags((char_u *)p_fdo, p_fdo_values, &fdo_flags, true) != OK) {
+    if (opt_strings_flags(p_fdo, p_fdo_values, &fdo_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_fcl) {  // 'foldclose'
-    if (check_opt_strings((char_u *)p_fcl, p_fcl_values, true) != OK) {
+    if (check_opt_strings(p_fcl, p_fcl_values, true) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == (char_u **)&curwin->w_allbuf_opt.wo_fdi) {  // 'foldignore'
+  } else if (gvarp == &curwin->w_allbuf_opt.wo_fdi) {  // 'foldignore'
     if (foldmethodIsIndent(curwin)) {
       foldUpdateAll(curwin);
     }
   } else if (gvarp == &p_ve) {  // 'virtualedit'
-    char_u *ve = p_ve;
+    char *ve = p_ve;
     unsigned int *flags = &ve_flags;
 
     if (opt_flags & OPT_LOCAL) {
-      ve = (char_u *)curwin->w_p_ve;
+      ve = curwin->w_p_ve;
       flags = &curwin->w_ve_flags;
     }
 
@@ -1381,15 +1380,15 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
         }
       }
     }
-  } else if (gvarp == (char_u **)&p_cino) {  // 'cinoptions'
+  } else if (gvarp == &p_cino) {  // 'cinoptions'
     // TODO(vim): recognize errors
     parse_cino(curbuf);
   } else if (varp == &p_icm) {  // 'inccommand'
-    if (check_opt_strings((char_u *)p_icm, p_icm_values, false) != OK) {
+    if (check_opt_strings(p_icm, p_icm_values, false) != OK) {
       errmsg = e_invarg;
     }
-  } else if (gvarp == (char_u **)&p_ft) {
-    if (!valid_filetype((char_u *)(*varp))) {
+  } else if (gvarp == &p_ft) {
+    if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
       value_changed = STRCMP(oldval, *varp) != 0;
@@ -1399,7 +1398,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       *value_checked = true;
     }
   } else if (gvarp == &p_syn) {
-    if (!valid_filetype((char_u *)(*varp))) {
+    if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
       value_changed = STRCMP(oldval, *varp) != 0;
@@ -1413,20 +1412,20 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       errmsg = e_invarg;
     }
   } else if (varp == &p_tpf) {
-    if (opt_strings_flags((char_u *)p_tpf, p_tpf_values, &tpf_flags, true) != OK) {
+    if (opt_strings_flags(p_tpf, p_tpf_values, &tpf_flags, true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &(curbuf->b_p_vsts)) {  // 'varsofttabstop'
-    char_u *cp;
+    char *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
       XFREE_CLEAR(curbuf->b_p_vsts_array);
     } else {
-      for (cp = (char_u *)(*varp); *cp; cp++) {
+      for (cp = *varp; *cp; cp++) {
         if (ascii_isdigit(*cp)) {
           continue;
         }
-        if (*cp == ',' && cp > (char_u *)(*varp) && *(cp - 1) != ',') {
+        if (*cp == ',' && cp > *varp && *(cp - 1) != ',') {
           continue;
         }
         errmsg = e_invarg;
@@ -1434,7 +1433,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
       if (errmsg == NULL) {
         long *oldarray = curbuf->b_p_vsts_array;
-        if (tabstop_set((char_u *)(*varp), &(curbuf->b_p_vsts_array))) {
+        if (tabstop_set(*varp, &(curbuf->b_p_vsts_array))) {
           xfree(oldarray);
         } else {
           errmsg = e_invarg;
@@ -1442,16 +1441,16 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
   } else if (varp == &(curbuf->b_p_vts)) {  // 'vartabstop'
-    char_u *cp;
+    char *cp;
 
     if (!(*varp)[0] || ((*varp)[0] == '0' && !(*varp)[1])) {
       XFREE_CLEAR(curbuf->b_p_vts_array);
     } else {
-      for (cp = (char_u *)(*varp); *cp; cp++) {
+      for (cp = *varp; *cp; cp++) {
         if (ascii_isdigit(*cp)) {
           continue;
         }
-        if (*cp == ',' && cp > (char_u *)(*varp) && *(cp - 1) != ',') {
+        if (*cp == ',' && cp > *varp && *(cp - 1) != ',') {
           continue;
         }
         errmsg = e_invarg;
@@ -1459,7 +1458,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
       if (errmsg == NULL) {
         long *oldarray = curbuf->b_p_vts_array;
-        if (tabstop_set((char_u *)(*varp), &(curbuf->b_p_vts_array))) {
+        if (tabstop_set(*varp, &(curbuf->b_p_vts_array))) {
           xfree(oldarray);
           if (foldmethodIsIndent(curwin)) {
             foldUpdateAll(curwin);
@@ -1484,7 +1483,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       p = WW_ALL;
     }
     if (varp == &p_shm) {  // 'shortmess'
-      p = (char *)SHM_ALL;
+      p = SHM_ALL;
     } else if (varp == &(p_cpo)) {  // 'cpoptions'
       p = CPO_VI;
     } else if (varp == &(curbuf->b_p_fo)) {  // 'formatoptions'
@@ -1527,7 +1526,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
         && is_global_local_option(opt_idx)) {
       // global option with local value set to use global value; free
       // the local value and make it empty
-      p = (char *)get_option_varp_scope(opt_idx, OPT_LOCAL);
+      p = get_option_varp_scope(opt_idx, OPT_LOCAL);
       free_string_option(*(char **)p);
       *(char **)p = empty_option;
     } else if (!(opt_flags & OPT_LOCAL) && opt_flags != OPT_GLOBAL) {
@@ -1574,8 +1573,8 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
     if (varp == &(curwin->w_s->b_p_spl)) {
-      char_u fname[200];
-      char_u *q = (char_u *)curwin->w_s->b_p_spl;
+      char fname[200];
+      char *q = curwin->w_s->b_p_spl;
 
       // Skip the first name if it is "cjk".
       if (STRNCMP(q, "cjk,", 4) == 0) {
@@ -1586,15 +1585,14 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       // They could set 'spellcapcheck' depending on the language.
       // Use the first name in 'spelllang' up to '_region' or
       // '.encoding'.
-      for (p = (char *)q; *p != NUL; p++) {
+      for (p = q; *p != NUL; p++) {
         if (!ASCII_ISALNUM(*p) && *p != '-') {
           break;
         }
       }
-      if (p > (char *)q) {
-        vim_snprintf((char *)fname, sizeof(fname), "spell/%.*s.vim",
-                     (int)(p - (char *)q), q);
-        source_runtime((char *)fname, DIP_ALL);
+      if (p > q) {
+        vim_snprintf(fname, sizeof(fname), "spell/%.*s.vim", (int)(p - q), q);
+        source_runtime(fname, DIP_ALL);
       }
     }
   }
@@ -1618,7 +1616,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
 /// @param list  when true: accept a list of values
 ///
 /// @return  OK for correct value, FAIL otherwise. Empty is always OK.
-static int check_opt_strings(char_u *val, char **values, int list)
+static int check_opt_strings(char *val, char **values, int list)
 {
   return opt_strings_flags(val, values, NULL, list);
 }
@@ -1631,7 +1629,7 @@ static int check_opt_strings(char_u *val, char **values, int list)
 /// @param list  when true: accept a list of values
 ///
 /// @return  OK for correct value, FAIL otherwise. Empty is always OK.
-static int opt_strings_flags(char_u *val, char **values, unsigned *flagp, bool list)
+static int opt_strings_flags(char *val, char **values, unsigned *flagp, bool list)
 {
   unsigned int new_flags = 0;
 
@@ -1659,7 +1657,7 @@ static int opt_strings_flags(char_u *val, char **values, unsigned *flagp, bool l
 }
 
 /// @return  OK if "p" is a valid fileformat name, FAIL otherwise.
-int check_ff_value(char_u *p)
+int check_ff_value(char *p)
 {
   return check_opt_strings(p, p_ff_values, false);
 }
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f528bc651b..1b548e1f1b 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -607,7 +607,7 @@ static efm_T *parse_efm_option(char *efm)
       goto parse_efm_error;
     }
     // Advance to next part
-    efm = (char *)skip_to_option_part((char_u *)efm + len);       // skip comma and spaces
+    efm = skip_to_option_part(efm + len);       // skip comma and spaces
   }
 
   if (fmt_first == NULL) {      // nothing found
@@ -4222,7 +4222,7 @@ static char *make_get_fullcmd(const char *makecmd, const char *fname)
 
   // If 'shellpipe' empty: don't redirect to 'errorfile'.
   if (*p_sp != NUL) {
-    append_redir(cmd, len, (char *)p_sp, (char *)fname);
+    append_redir(cmd, len, p_sp, (char *)fname);
   }
 
   // Display the fully formed command.  Output a newline if there's something
@@ -4241,7 +4241,7 @@ static char *make_get_fullcmd(const char *makecmd, const char *fname)
 // Used for ":make", ":lmake", ":grep", ":lgrep", ":grepadd", and ":lgrepadd"
 void ex_make(exarg_T *eap)
 {
-  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : (char *)p_menc;
+  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
 
   // Redirect ":grep" to ":vimgrep" if 'grepprg' is "internal".
   if (grep_internal(eap->cmdidx)) {
@@ -4981,7 +4981,7 @@ void ex_cfile(exarg_T *eap)
     set_string_option_direct("ef", -1, eap->arg, OPT_FREE, 0);
   }
 
-  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : (char *)p_menc;
+  char *enc = (*curbuf->b_p_menc != NUL) ? curbuf->b_p_menc : p_menc;
 
   if (is_loclist_cmd(eap->cmdidx)) {
     wp = curwin;
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 23606fdc77..25f85b6193 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -2432,7 +2432,7 @@ void ex_scriptencoding(exarg_T *eap)
   }
 
   if (*eap->arg != NUL) {
-    name = (char *)enc_canonize((char_u *)eap->arg);
+    name = enc_canonize(eap->arg);
   } else {
     name = eap->arg;
   }
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 9c1064d608..3258dc11d6 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -734,13 +734,13 @@ int showmode(void)
           length = (Rows - msg_row) * Columns - 3;
         }
         if (edit_submode_extra != NULL) {
-          length -= vim_strsize((char *)edit_submode_extra);
+          length -= vim_strsize(edit_submode_extra);
         }
         if (length > 0) {
           if (edit_submode_pre != NULL) {
-            length -= vim_strsize((char *)edit_submode_pre);
+            length -= vim_strsize(edit_submode_pre);
           }
-          if (length - vim_strsize((char *)edit_submode) > 0) {
+          if (length - vim_strsize(edit_submode) > 0) {
             if (edit_submode_pre != NULL) {
               msg_puts_attr((const char *)edit_submode_pre, attr);
             }
@@ -1026,7 +1026,7 @@ void draw_tabline(void)
           if (col + len >= Columns - 3) {
             break;
           }
-          grid_puts_len(&default_grid, NameBuff, len, 0, col,
+          grid_puts_len(&default_grid, (char_u *)NameBuff, len, 0, col,
                         hl_combine_attr(attr, win_hl_attr(cwp, HLF_T)));
           col += len;
         }
@@ -1040,9 +1040,9 @@ void draw_tabline(void)
       if (room > 0) {
         // Get buffer name in NameBuff[]
         get_trans_bufname(cwp->w_buffer);
-        shorten_dir(NameBuff);
+        shorten_dir((char_u *)NameBuff);
         len = vim_strsize((char *)NameBuff);
-        p = NameBuff;
+        p = (char_u *)NameBuff;
         while (len > room) {
           len -= ptr2cells((char *)p);
           MB_PTR_ADV(p);
@@ -1295,13 +1295,13 @@ static int get_encoded_char_adv(const char_u **p)
 /// @param varp   either the global or the window-local value.
 /// @param apply  if false, do not store the flags, only check for errors.
 /// @return error message, NULL if it's OK.
-char *set_chars_option(win_T *wp, char_u **varp, bool apply)
+char *set_chars_option(win_T *wp, char **varp, bool apply)
 {
   const char_u *last_multispace = NULL;   // Last occurrence of "multispace:"
   const char_u *last_lmultispace = NULL;  // Last occurrence of "leadmultispace:"
   int multispace_len = 0;           // Length of lcs-multispace string
   int lead_multispace_len = 0;      // Length of lcs-leadmultispace string
-  const bool is_listchars = (varp == (char_u **)&p_lcs || varp == (char_u **)&wp->w_p_lcs);
+  const bool is_listchars = (varp == &p_lcs || varp == &wp->w_p_lcs);
 
   struct chars_tab {
     int *cp;     ///< char value
@@ -1344,17 +1344,17 @@ char *set_chars_option(win_T *wp, char_u **varp, bool apply)
 
   struct chars_tab *tab;
   int entries;
-  const char_u *value = *varp;
+  const char_u *value = (char_u *)(*varp);
   if (is_listchars) {
     tab = lcs_tab;
     entries = ARRAY_SIZE(lcs_tab);
-    if (varp == (char_u **)&wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
+    if (varp == &wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
       value = (char_u *)p_lcs;  // local value is empty, use the global value
     }
   } else {
     tab = fcs_tab;
     entries = ARRAY_SIZE(fcs_tab);
-    if (varp == (char_u **)&wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
+    if (varp == &wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
       value = (char_u *)p_fcs;  // local value is empty, use the global value
     }
   }
@@ -1520,17 +1520,17 @@ char *set_chars_option(win_T *wp, char_u **varp, bool apply)
 /// @return  an untranslated error message if any of them is invalid, NULL otherwise.
 char *check_chars_options(void)
 {
-  if (set_chars_option(curwin, (char_u **)&p_lcs, false) != NULL) {
+  if (set_chars_option(curwin, &p_lcs, false) != NULL) {
     return e_conflicts_with_value_of_listchars;
   }
-  if (set_chars_option(curwin, (char_u **)&p_fcs, false) != NULL) {
+  if (set_chars_option(curwin, &p_fcs, false) != NULL) {
     return e_conflicts_with_value_of_fillchars;
   }
   FOR_ALL_TAB_WINDOWS(tp, wp) {
-    if (set_chars_option(wp, (char_u **)&wp->w_p_lcs, true) != NULL) {
+    if (set_chars_option(wp, &wp->w_p_lcs, true) != NULL) {
       return e_conflicts_with_value_of_listchars;
     }
-    if (set_chars_option(wp, (char_u **)&wp->w_p_fcs, true) != NULL) {
+    if (set_chars_option(wp, &wp->w_p_fcs, true) != NULL) {
       return e_conflicts_with_value_of_fillchars;
     }
   }
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 3de16b3e69..b45a041d96 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1477,7 +1477,7 @@ static char *shada_filename(const char *file)
       //     because various expansions must have already be done by the shell.
       //     If shell is not performing them then they should be done in main.c
       //     where arguments are parsed, *not here*.
-      expand_env((char_u *)file, &(NameBuff[0]), MAXPATHL);
+      expand_env((char_u *)file, (char_u *)&(NameBuff[0]), MAXPATHL);
       file = (const char *)&(NameBuff[0]);
     }
   }
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 8fcb379bcf..10923829c3 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -1848,7 +1848,7 @@ char *did_set_spelllang(win_T *wp)
     region = NULL;
     len = (int)STRLEN(lang);
 
-    if (!valid_spelllang(lang)) {
+    if (!valid_spelllang((char *)lang)) {
       continue;
     }
 
@@ -3545,18 +3545,18 @@ int expand_spelling(linenr_T lnum, char_u *pat, char ***matchp)
   return ga.ga_len;
 }
 
-/// Return true if "val" is a valid 'spelllang' value.
-bool valid_spelllang(const char_u *val)
+/// @return  true if "val" is a valid 'spelllang' value.
+bool valid_spelllang(const char *val)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   return valid_name(val, ".-_,@");
 }
 
-/// Return true if "val" is a valid 'spellfile' value.
-bool valid_spellfile(const char_u *val)
+/// @return  true if "val" is a valid 'spellfile' value.
+bool valid_spellfile(const char *val)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  for (const char_u *s = val; *s != NUL; s++) {
+  for (const char_u *s = (char_u *)val; *s != NUL; s++) {
     if (!vim_isfilec(*s) && *s != ',' && *s != ' ') {
       return false;
     }
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index c68dbd8e53..8d6307f123 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -2121,7 +2121,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     if (itemcnt > 0) {
       if (is_aff_rule(items, itemcnt, "SET", 2) && aff->af_enc == NULL) {
         // Setup for conversion from "ENC" to 'encoding'.
-        aff->af_enc = enc_canonize(items[1]);
+        aff->af_enc = (char_u *)enc_canonize((char *)items[1]);
         if (!spin->si_ascii
             && convert_setup(&spin->si_conv, aff->af_enc, (char_u *)p_enc) == FAIL) {
           smsg(_("Conversion in %s not supported: from %s to %s"),
@@ -2167,9 +2167,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         STRCAT(p, " ");
         STRCAT(p, items[1]);
         spin->si_info = p;
-      } else if (is_aff_rule(items, itemcnt, "MIDWORD", 2)
-                 && midword == NULL) {
-        midword = getroom_save(spin, items[1]);
+      } else if (is_aff_rule(items, itemcnt, "MIDWORD", 2) && midword == NULL) {
+        midword = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "TRY", 2)) {
         // ignored, we look in the tree for what chars may appear
       }
@@ -2307,12 +2306,12 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
         if (i >= gap->ga_len) {
           ga_grow(gap, 2);
-          ((char **)(gap->ga_data))[gap->ga_len++] = (char *)getroom_save(spin, items[1]);
-          ((char **)(gap->ga_data))[gap->ga_len++] = (char *)getroom_save(spin, items[2]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[1]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[2]);
         }
       } else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
                  && syllable == NULL) {
-        syllable = getroom_save(spin, items[1]);
+        syllable = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "NOBREAK", 1)) {
         spin->si_nobreak = true;
       } else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1)) {
@@ -2445,10 +2444,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         aff_entry = getroom(spin, sizeof(*aff_entry), true);
 
         if (STRCMP(items[2], "0") != 0) {
-          aff_entry->ae_chop = getroom_save(spin, items[2]);
+          aff_entry->ae_chop = (char_u *)getroom_save(spin, items[2]);
         }
         if (STRCMP(items[3], "0") != 0) {
-          aff_entry->ae_add = getroom_save(spin, items[3]);
+          aff_entry->ae_add = (char_u *)getroom_save(spin, items[3]);
 
           // Recognize flags on the affix: abcd/XYZ
           aff_entry->ae_flags = (char_u *)vim_strchr((char *)aff_entry->ae_add, '/');
@@ -2468,7 +2467,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           if (STRCMP(items[4], ".") != 0) {
             char_u buf[MAXLINELEN];
 
-            aff_entry->ae_cond = getroom_save(spin, items[4]);
+            aff_entry->ae_cond = (char_u *)getroom_save(spin, items[4]);
             if (*items[0] == 'P') {
               sprintf((char *)buf, "^%s", items[4]);
             } else {
@@ -2517,7 +2516,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                   if (aff_entry->ae_cond != NULL) {
                     char_u buf[MAXLINELEN];
                     onecap_copy(items[4], buf, true);
-                    aff_entry->ae_cond = getroom_save(spin, buf);
+                    aff_entry->ae_cond = (char_u *)getroom_save(spin, buf);
                     if (aff_entry->ae_cond != NULL) {
                       sprintf((char *)buf, "^%s",
                               aff_entry->ae_cond);
@@ -2547,7 +2546,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                 idx = spin->si_prefcond.ga_len;
                 pp = GA_APPEND_VIA_PTR(char_u *, &spin->si_prefcond);
                 *pp = (aff_entry->ae_cond == NULL) ?
-                      NULL : getroom_save(spin, aff_entry->ae_cond);
+                      NULL : (char_u *)getroom_save(spin, aff_entry->ae_cond);
               }
 
               // Add the prefix to the prefix tree.
@@ -2673,10 +2672,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
       } else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
                  && sofofrom == NULL) {
-        sofofrom = getroom_save(spin, items[1]);
+        sofofrom = (char_u *)getroom_save(spin, items[1]);
       } else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
                  && sofoto == NULL) {
-        sofoto = getroom_save(spin, items[1]);
+        sofoto = (char_u *)getroom_save(spin, items[1]);
       } else if (STRCMP(items[0], "COMMON") == 0) {
         int i;
 
@@ -3042,9 +3041,9 @@ static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from, char_u *t
 
   fromto_T *ftp = GA_APPEND_VIA_PTR(fromto_T, gap);
   (void)spell_casefold(curwin, from, (int)STRLEN(from), word, MAXWLEN);
-  ftp->ft_from = getroom_save(spin, word);
+  ftp->ft_from = (char_u *)getroom_save(spin, word);
   (void)spell_casefold(curwin, to, (int)STRLEN(to), word, MAXWLEN);
-  ftp->ft_to = getroom_save(spin, word);
+  ftp->ft_to = (char_u *)getroom_save(spin, word);
 }
 
 // Converts a boolean argument in a SAL line to true or false;
@@ -3207,7 +3206,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
     }
 
     // Store the word in the hashtable to be able to find duplicates.
-    dw = getroom_save(spin, w);
+    dw = (char_u *)getroom_save(spin, w);
     if (dw == NULL) {
       retval = FAIL;
       xfree(pc);
@@ -3728,7 +3727,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
 
           // Setup for conversion to 'encoding'.
           line += 9;
-          enc = enc_canonize(line);
+          enc = (char_u *)enc_canonize((char *)line);
           if (!spin->si_ascii
               && convert_setup(&spin->si_conv, enc, (char_u *)p_enc) == FAIL) {
             smsg(_("Conversion in %s not supported: from %s to %s"),
@@ -3864,9 +3863,10 @@ static void *getroom(spellinfo_T *spin, size_t len, bool align)
   return p;
 }
 
-// Make a copy of a string into memory allocated with getroom().
-// Returns NULL when out of memory.
-static char_u *getroom_save(spellinfo_T *spin, char_u *s)
+/// Make a copy of a string into memory allocated with getroom().
+///
+/// @return  NULL when out of memory.
+static char *getroom_save(spellinfo_T *spin, char_u *s)
 {
   const size_t s_size = STRLEN(s) + 1;
   return memcpy(getroom(spin, s_size, false), s, s_size);
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index 8b56eaadf0..b9cddb7b94 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -77,7 +77,7 @@ void win_redr_status(win_T *wp)
     width = is_stl_global ? Columns : wp->w_width;
 
     get_trans_bufname(wp->w_buffer);
-    p = NameBuff;
+    p = (char_u *)NameBuff;
     len = (int)STRLEN(p);
 
     if (bt_help(wp->w_buffer)
@@ -138,7 +138,7 @@ void win_redr_status(win_T *wp)
 
     if (get_keymap_str(wp, "<%s>", (char *)NameBuff, MAXPATHL)
         && this_ru_col - len > (int)(STRLEN(NameBuff) + 1)) {
-      grid_puts(&default_grid, NameBuff, row,
+      grid_puts(&default_grid, (char_u *)NameBuff, row,
                 (int)((size_t)this_ru_col - STRLEN(NameBuff) - 1), attr);
     }
 
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 20287089f7..187dc4eed4 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -1634,11 +1634,9 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   bool zero_width_next_list = false;
   garray_T zero_width_next_ga;
 
-  /*
-   * No character, no attributes!  Past end of line?
-   * Do try matching with an empty line (could be the start of a region).
-   */
-  line = syn_getcurline();
+  // No character, no attributes!  Past end of line?
+  // Do try matching with an empty line (could be the start of a region).
+  line = (char_u *)syn_getcurline();
   if (line[current_col] == NUL && current_col != 0) {
     /*
      * If we found a match after the last column, use it.
@@ -1706,12 +1704,10 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
 
     if (syn_block->b_syn_containedin || cur_si == NULL
         || cur_si->si_cont_list != NULL) {
-      /*
-       * 2. Check for keywords, if on a keyword char after a non-keyword
-       *          char.  Don't do this when syncing.
-       */
+      // 2. Check for keywords, if on a keyword char after a non-keyword
+      //          char.  Don't do this when syncing.
       if (do_keywords) {
-        line = syn_getcurline();
+        line = (char_u *)syn_getcurline();
         const char_u *cur_pos = line + current_col;
         if (vim_iswordp_buf(cur_pos, syn_buf)
             && (current_col == 0
@@ -1979,13 +1975,11 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
      * Handle searching for nextgroup match.
      */
     if (current_next_list != NULL && !keep_next_list) {
-      /*
-       * If a nextgroup was not found, continue looking for one if:
-       * - this is an empty line and the "skipempty" option was given
-       * - we are on white space and the "skipwhite" option was given
-       */
+      // If a nextgroup was not found, continue looking for one if:
+      // - this is an empty line and the "skipempty" option was given
+      // - we are on white space and the "skipwhite" option was given
       if (!found_match) {
-        line = syn_getcurline();
+        line = (char_u *)syn_getcurline();
         if (((current_next_flags & HL_SKIPWHITE)
              && ascii_iswhite(line[current_col]))
             || ((current_next_flags & HL_SKIPEMPTY)
@@ -2108,7 +2102,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
 
   // nextgroup ends at end of line, unless "skipnl" or "skipempty" present
   if (current_next_list != NULL
-      && (line = syn_getcurline())[current_col] != NUL
+      && (line = (char_u *)syn_getcurline())[current_col] != NUL
       && line[current_col + 1] == NUL
       && !(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))) {
     current_next_list = NULL;
@@ -2874,12 +2868,10 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
   result->col = col;
 }
 
-/*
- * Get current line in syntax buffer.
- */
-static char_u *syn_getcurline(void)
+/// Get current line in syntax buffer.
+static char *syn_getcurline(void)
 {
-  return ml_get_buf(syn_buf, current_lnum, false);
+  return (char *)ml_get_buf(syn_buf, current_lnum, false);
 }
 
 /*
@@ -4059,7 +4051,7 @@ static char *get_group_name(char *arg, char **name_end)
 ///
 /// @return      a pointer to the next argument (which isn't an option).
 ///              Return NULL for any error;
-static char_u *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
+static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
 {
   char_u *gname_start, *gname;
   int syn_id;
@@ -4205,7 +4197,7 @@ static char_u *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char,
     }
   }
 
-  return (char_u *)arg;
+  return arg;
 }
 
 /*
@@ -4347,7 +4339,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
       cnt = 0;
       p = keyword_copy;
       for (; rest != NULL && !ends_excmd(*rest); rest = skipwhite(rest)) {
-        rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+        rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
         if (rest == NULL || ends_excmd(*rest)) {
           break;
         }
@@ -4442,18 +4434,18 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   syn_opt_arg.cont_list = NULL;
   syn_opt_arg.cont_in_list = NULL;
   syn_opt_arg.next_list = NULL;
-  rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+  rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
 
   // get the pattern.
   init_syn_patterns();
   CLEAR_FIELD(item);
-  rest = (char *)get_syn_pattern((char_u *)rest, &item);
+  rest = get_syn_pattern((char_u *)rest, &item);
   if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
     syn_opt_arg.flags |= HL_HAS_EOL;
   }
 
   // Get options after the pattern
-  rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+  rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
 
   if (rest != NULL) {           // all arguments are valid
     /*
@@ -4568,7 +4560,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
   // get the options, patterns and matchgroup.
   while (rest != NULL && !ends_excmd(*rest)) {
     // Check for option arguments
-    rest = (char *)get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
+    rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
     if (rest == NULL || ends_excmd(*rest)) {
       break;
     }
@@ -4639,7 +4631,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
         assert(item == ITEM_SKIP || item == ITEM_END);
         reg_do_extmatch = REX_USE;
       }
-      rest = (char *)get_syn_pattern((char_u *)rest, ppp->pp_synp);
+      rest = get_syn_pattern((char_u *)rest, ppp->pp_synp);
       reg_do_extmatch = 0;
       if (item == ITEM_END && vim_regcomp_had_eol()
           && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
@@ -5034,12 +5026,11 @@ static void init_syn_patterns(void)
   ga_set_growsize(&curwin->w_s->b_syn_patterns, 10);
 }
 
-/*
- * Get one pattern for a ":syntax match" or ":syntax region" command.
- * Stores the pattern and program in a synpat_T.
- * Returns a pointer to the next argument, or NULL in case of an error.
- */
-static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
+/// Get one pattern for a ":syntax match" or ":syntax region" command.
+/// Stores the pattern and program in a synpat_T.
+///
+/// @return  a pointer to the next argument, or NULL in case of an error.
+static char *get_syn_pattern(char_u *arg, synpat_T *ci)
 {
   char *end;
   int *p;
@@ -5128,7 +5119,7 @@ static char_u *get_syn_pattern(char_u *arg, synpat_T *ci)
     semsg(_("E402: Garbage after pattern: %s"), arg);
     return NULL;
   }
-  return (char_u *)skipwhite(end);
+  return skipwhite(end);
 }
 
 /*
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 2e5ce972d8..50121832ba 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -57,6 +57,7 @@
 typedef struct tag_pointers {
   // filled in by parse_tag_line():
   char_u *tagname;  // start of tag name (skip "file:")
+                    //
   char_u *tagname_end;  // char after tag name
   char_u *fname;   // first char of file name
   char_u *fname_end;  // char after file name
@@ -483,8 +484,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         flags |= TAG_NO_TAGFUNC;
       }
 
-      if (find_tags(name, &new_num_matches, &new_matches, flags,
-                    max_num_matches, buf_ffname) == OK
+      if (find_tags((char *)name, &new_num_matches, &new_matches, flags,
+                    max_num_matches, (char *)buf_ffname) == OK
           && new_num_matches < max_num_matches) {
         max_num_matches = MAXCOL;  // If less than max_num_matches
                                    // found: all matches found.
@@ -1365,8 +1366,8 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
 /// @param matchesp  return: array of matches found
 /// @param mincount  MAXCOL: find all matches other: minimal number of matches */
 /// @param buf_ffname  name of buffer for priority
-int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mincount,
-              char_u *buf_ffname)
+int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int mincount,
+              char *buf_ffname)
 {
   FILE *fp;
   char_u *lbuf;                     // line buffer
@@ -1459,17 +1460,17 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
     p_ic = false;
     break;
   case TC_FOLLOWSCS:
-    p_ic = ignorecase(pat);
+    p_ic = ignorecase((char_u *)pat);
     break;
   case TC_SMART:
-    p_ic = ignorecase_opt(pat, true, true);
+    p_ic = ignorecase_opt((char_u *)pat, true, true);
     break;
   default:
     abort();
   }
 
   help_save = curbuf->b_help;
-  orgpat.pat = pat;
+  orgpat.pat = (char_u *)pat;
   orgpat.regmatch.regprog = NULL;
   vimconv.vc_type = CONV_NONE;
 
@@ -1503,8 +1504,8 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
     if (orgpat.len > 3 && pat[orgpat.len - 3] == '@'
         && ASCII_ISALPHA(pat[orgpat.len - 2])
         && ASCII_ISALPHA(pat[orgpat.len - 1])) {
-      saved_pat = vim_strnsave(pat, (size_t)orgpat.len - 3);
-      help_lang_find = &pat[orgpat.len - 2];
+      saved_pat = vim_strnsave((char_u *)pat, (size_t)orgpat.len - 3);
+      help_lang_find = (char_u *)&pat[orgpat.len - 2];
       orgpat.pat = saved_pat;
       orgpat.len -= 3;
     }
@@ -1527,8 +1528,8 @@ int find_tags(char_u *pat, int *num_matches, char ***matchesp, int flags, int mi
 
   if (*curbuf->b_p_tfu != NUL && use_tfu && !tfu_in_use) {
     tfu_in_use = true;
-    retval = find_tagfunc_tags(pat, &ga_match[0], &match_count,
-                               flags, buf_ffname);
+    retval = find_tagfunc_tags((char_u *)pat, &ga_match[0], &match_count, flags,
+                               (char_u *)buf_ffname);
     tfu_in_use = false;
     if (retval != NOTDONE) {
       goto findtag_end;
@@ -2055,7 +2056,7 @@ parse_line:
           } else {
             // Decide in which array to store this match.
             is_current = test_for_current(tagp.fname, tagp.fname_end, tag_fname,
-                                          buf_ffname);
+                                          (char_u *)buf_ffname);
             is_static = test_for_static(&tagp);
 
             // Decide in which of the sixteen tables to store this match.
@@ -3107,13 +3108,13 @@ int expand_tags(int tagnames, char_u *pat, int *num_file, char ***file)
     extra_flag = 0;
   }
   if (pat[0] == '/') {
-    ret = find_tags(pat + 1, num_file, file,
+    ret = find_tags((char *)pat + 1, num_file, file,
                     TAG_REGEXP | extra_flag | TAG_VERBOSE | TAG_NO_TAGFUNC,
-                    TAG_MANY, (char_u *)curbuf->b_ffname);
+                    TAG_MANY, curbuf->b_ffname);
   } else {
-    ret = find_tags(pat, num_file, file,
+    ret = find_tags((char *)pat, num_file, file,
                     TAG_REGEXP | extra_flag | TAG_VERBOSE | TAG_NO_TAGFUNC | TAG_NOIC,
-                    TAG_MANY, (char_u *)curbuf->b_ffname);
+                    TAG_MANY, curbuf->b_ffname);
   }
   if (ret == OK && !tagnames) {
     // Reorganize the tags for display and matching as strings of:
@@ -3150,8 +3151,7 @@ int expand_tags(int tagnames, char_u *pat, int *num_file, char ***file)
 ///
 /// @param start  start of the value
 /// @param end  after the value; can be NULL
-static int add_tag_field(dict_T *dict, const char *field_name, const char_u *start,
-                         const char_u *end)
+static int add_tag_field(dict_T *dict, const char *field_name, const char *start, const char *end)
   FUNC_ATTR_NONNULL_ARG(1, 2)
 {
   int len = 0;
@@ -3198,8 +3198,8 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
   tagptrs_T tp;
   bool is_static;
 
-  ret = find_tags(pat, &num_matches, &matches,
-                  TAG_REGEXP | TAG_NOIC, MAXCOL, buf_fname);
+  ret = find_tags((char *)pat, &num_matches, &matches,
+                  TAG_REGEXP | TAG_NOIC, MAXCOL, (char *)buf_fname);
   if (ret == OK && num_matches > 0) {
     for (i = 0; i < num_matches; i++) {
       int parse_result = parse_match((char_u *)matches[i], &tp);
@@ -3220,11 +3220,11 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
       tv_list_append_dict(list, dict);
 
       full_fname = tag_full_fname(&tp);
-      if (add_tag_field(dict, "name", tp.tagname, tp.tagname_end) == FAIL
-          || add_tag_field(dict, "filename", full_fname, NULL) == FAIL
-          || add_tag_field(dict, "cmd", tp.command, tp.command_end) == FAIL
-          || add_tag_field(dict, "kind", tp.tagkind,
-                           tp.tagkind ? tp.tagkind_end : NULL) == FAIL
+      if (add_tag_field(dict, "name", (char *)tp.tagname, (char *)tp.tagname_end) == FAIL
+          || add_tag_field(dict, "filename", (char *)full_fname, NULL) == FAIL
+          || add_tag_field(dict, "cmd", (char *)tp.command, (char *)tp.command_end) == FAIL
+          || add_tag_field(dict, "kind", (char *)tp.tagkind,
+                           tp.tagkind ? (char *)tp.tagkind_end : NULL) == FAIL
           || tv_dict_add_nr(dict, S_LEN("static"), is_static) == FAIL) {
         ret = FAIL;
       }
@@ -3259,7 +3259,7 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
                 p++;
               }
               n[len] = NUL;
-              if (add_tag_field(dict, (char *)n, s, p) == FAIL) {
+              if (add_tag_field(dict, (char *)n, (char *)s, (char *)p) == FAIL) {
                 ret = FAIL;
               }
               n[len] = ':';
-- 
cgit 


From 7a9b5937966d3db852c84b8eb232e77d92d3c355 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 28 Aug 2022 07:22:27 +0800
Subject: vim-patch:8.2.3813: confusing error when using :cc without error list
 (#19978)

Problem:    confusing error when using :cc without error list. (Gary Johnson)
Solution:   Give the "no errors" error.
https://github.com/vim/vim/commit/a5d78d1f1123d9ffccd5ba58f2d2dec44cc59e94

Cherry-pick e_quickfix -> e_no_errors rename from patch 8.2.3190.
---
 src/nvim/ex_docmd.c                |  3 +++
 src/nvim/globals.h                 |  2 +-
 src/nvim/quickfix.c                | 10 +++++-----
 src/nvim/testdir/test_quickfix.vim |  6 ++++++
 4 files changed, 15 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index eadde7a725..8cf5d56dd7 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3586,6 +3586,9 @@ char *invalid_range(exarg_T *eap)
       assert(eap->line2 >= 0);
       // No error for value that is too big, will use the last entry.
       if (eap->line2 <= 0) {
+        if (eap->addr_count == 0) {
+          return _(e_no_errors);
+        }
         return _(e_invrange);
       }
       break;
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 7b93fbc852..64a43a720e 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -920,7 +920,7 @@ EXTERN char e_patnotf2[] INIT(= N_("E486: Pattern not found: %s"));
 EXTERN char e_positive[] INIT(= N_("E487: Argument must be positive"));
 EXTERN char e_prev_dir[] INIT(= N_("E459: Cannot go back to previous directory"));
 
-EXTERN char e_quickfix[] INIT(= N_("E42: No Errors"));
+EXTERN char e_no_errors[] INIT(= N_("E42: No Errors"));
 EXTERN char e_loclist[] INIT(= N_("E776: No location list"));
 EXTERN char e_re_damg[] INIT(= N_("E43: Damaged match string"));
 EXTERN char e_re_corr[] INIT(= N_("E44: Corrupted regexp program"));
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f528bc651b..16415e0f57 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -2932,7 +2932,7 @@ static void qf_jump_newwin(qf_info_T *qi, int dir, int errornr, int forceit, boo
   }
 
   if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi))) {
-    emsg(_(e_quickfix));
+    emsg(_(e_no_errors));
     return;
   }
 
@@ -3111,7 +3111,7 @@ void qf_list(exarg_T *eap)
   }
 
   if (qf_stack_empty(qi) || qf_list_empty(qf_get_curlist(qi))) {
-    emsg(_(e_quickfix));
+    emsg(_(e_no_errors));
     return;
   }
 
@@ -3467,7 +3467,7 @@ void qf_view_result(bool split)
     qi = GET_LOC_LIST(curwin);
   }
   if (qf_list_empty(qf_get_curlist(qi))) {
-    emsg(_(e_quickfix));
+    emsg(_(e_no_errors));
     return;
   }
 
@@ -4898,7 +4898,7 @@ void ex_cbelow(exarg_T *eap)
                       || eap->cmdidx == CMD_cafter) ? BUF_HAS_QF_ENTRY : BUF_HAS_LL_ENTRY;
 
   if (!(curbuf->b_has_qf_entry & buf_has_flag)) {
-    emsg(_(e_quickfix));
+    emsg(_(e_no_errors));
     return;
   }
 
@@ -4910,7 +4910,7 @@ void ex_cbelow(exarg_T *eap)
   qf_list_T *qfl = qf_get_curlist(qi);
   // check if the list has valid errors
   if (!qf_list_has_valid_entries(qfl)) {
-    emsg(_(e_quickfix));
+    emsg(_(e_no_errors));
     return;
   }
 
diff --git a/src/nvim/testdir/test_quickfix.vim b/src/nvim/testdir/test_quickfix.vim
index f6d573d76b..8c9e39570f 100644
--- a/src/nvim/testdir/test_quickfix.vim
+++ b/src/nvim/testdir/test_quickfix.vim
@@ -85,6 +85,12 @@ func s:setup_commands(cchar)
   endif
 endfunc
 
+" This must be run before any error lists are created.
+func Test_AA_cc_no_errors()
+  call assert_fails('cc', 'E42:')
+  call assert_fails('ll', 'E42:')
+endfunc
+
 " Tests for the :clist and :llist commands
 func XlistTests(cchar)
   call s:setup_commands(a:cchar)
-- 
cgit 


From 88c32b5eba9fa7072bb4a76a8dbb73c6603165be Mon Sep 17 00:00:00 2001
From: Raphael <glephunter@gmail.com>
Date: Sun, 28 Aug 2022 17:07:24 +0800
Subject: fix(l10n): improve zh_CN and zh_TW translations (#19969)

---
 src/nvim/po/zh_CN.UTF-8.po |  52 +++----
 src/nvim/po/zh_TW.UTF-8.po | 360 +++++++++++++++++++++++----------------------
 2 files changed, 211 insertions(+), 201 deletions(-)

(limited to 'src')

diff --git a/src/nvim/po/zh_CN.UTF-8.po b/src/nvim/po/zh_CN.UTF-8.po
index 373833fa80..afa2f29029 100644
--- a/src/nvim/po/zh_CN.UTF-8.po
+++ b/src/nvim/po/zh_CN.UTF-8.po
@@ -734,9 +734,9 @@ msgid "E120: Using <SID> not in a script context: %s"
 msgstr "E120: <SID> 不能在 script 上下文外使用: %s"
 
 #: ../eval.c:7391
-#, fuzzy, c-format
+#, c-format
 msgid "E725: Calling dict function without Dictionary: %s"
-msgstr "E720: Dictionary 中缺少冒号: %s"
+msgstr "E725: 调用字典函数但是没有字典：%s"
 
 #: ../eval.c:7453
 #, fuzzy
@@ -766,19 +766,16 @@ msgid "E737: Key already exists: %s"
 msgstr "E737: 键已存在: %s"
 
 #: ../eval.c:8692
-#, fuzzy
 msgid "extend() argument"
-msgstr "--cmd 参数"
+msgstr "extend() 参数"
 
 #: ../eval.c:8915
-#, fuzzy
 msgid "map() argument"
-msgstr "-c 参数"
+msgstr "map() 参数"
 
 #: ../eval.c:8916
-#, fuzzy
 msgid "filter() argument"
-msgstr "-c 参数"
+msgstr "filter() 参数"
 
 #: ../eval.c:9229
 #, c-format
@@ -849,9 +846,8 @@ msgid "E702: Sort compare function failed"
 msgstr "E702: Sort 比较函数失败"
 
 #: ../eval.c:13806
-#, fuzzy
 msgid "E882: Uniq compare function failed"
-msgstr "E702: Sort 比较函数失败"
+msgstr "E882: Uniq 比较函数失败"
 
 #: ../eval.c:14085
 msgid "(Invalid)"
@@ -864,31 +860,31 @@ msgstr "E677: 写临时文件出错"
 #: ../eval.c:16159
 #, fuzzy
 msgid "E805: Using a Float as a Number"
-msgstr "E745: 将 List 作数字使用"
+msgstr "E805: 将浮点数当做数字使用"
 
 #: ../eval.c:16162
 msgid "E703: Using a Funcref as a Number"
-msgstr "E703: 将 Funcref 作数字使用"
+msgstr "E703: 将函数当做数字使用"
 
 #: ../eval.c:16170
 msgid "E745: Using a List as a Number"
-msgstr "E745: 将 List 作数字使用"
+msgstr "E745: 将列表当做数字使用"
 
 #: ../eval.c:16173
 msgid "E728: Using a Dictionary as a Number"
-msgstr "E728: 将 Dictionary 作数字使用"
+msgstr "E728: 将字典当做数字使用"
 
 #: ../eval.c:16259
 msgid "E729: using Funcref as a String"
-msgstr "E729: 将 Funcref 作 String 使用"
+msgstr "E729: 将函数当做字符串使用"
 
 #: ../eval.c:16262
 msgid "E730: using List as a String"
-msgstr "E730: 将 List 作 String 使用"
+msgstr "E730: 将列表当做字符串使用"
 
 #: ../eval.c:16265
 msgid "E731: using Dictionary as a String"
-msgstr "E731: 将 Dictionary 作 String 使用"
+msgstr "E731: 将字典当做字符串使用"
 
 #: ../eval.c:16619
 #, c-format
@@ -3053,11 +3049,11 @@ msgstr "E673: 不兼容的多字节编码和字符集。"
 
 #: ../hardcopy.c:2238
 msgid "E674: printmbcharset cannot be empty with multi-byte encoding."
-msgstr "E674: printmbcharset 在多字节编码下不能为空。"
+msgstr "E674: printmbcharset 在多字节编码下不能为空"
 
 #: ../hardcopy.c:2254
 msgid "E675: No default font specified for multi-byte printing."
-msgstr "E675: 没有指定多字节打印的默认字体。"
+msgstr "E675: 没有指定多字节打印的默认字体"
 
 #: ../hardcopy.c:2426
 msgid "E324: Can't open PostScript output file"
@@ -4204,9 +4200,8 @@ msgstr "E329: 没有菜单 \"%s\""
 
 #. Only a mnemonic or accelerator is not valid.
 #: ../menu.c:329
-#, fuzzy
 msgid "E792: Empty menu name"
-msgstr "E749: 空的缓冲区"
+msgstr "E792: 空的菜单名称"
 
 #: ../menu.c:340
 msgid "E330: Menu path must not lead to a sub-menu"
@@ -4329,9 +4324,8 @@ msgid "E766: Insufficient arguments for printf()"
 msgstr "E766: printf() 的参数不足"
 
 #: ../message.c:3119
-#, fuzzy
 msgid "E807: Expected Float argument for printf()"
-msgstr "E766: printf() 的参数不足"
+msgstr "E807: 期盼浮点数作为printf()参数"
 
 #: ../message.c:3873
 msgid "E767: Too many arguments to printf()"
@@ -5675,9 +5669,9 @@ msgid "E781: .sug file doesn't match .spl file: %s"
 msgstr "E781: .sug 文件不能匹配 .spl 文件: %s"
 
 #: ../spell.c:9305
-#, fuzzy, c-format
+#,  c-format
 msgid "E782: error while reading .sug file: %s"
-msgstr "E47: 读取错误文件失败"
+msgstr "E782: 当读取.sug 文件时错误"
 
 #. This should have been checked when generating the .spl
 #. file.
@@ -5867,6 +5861,7 @@ msgstr "E410: 不正确的 :syntax 子命令: %s"
 msgid ""
 "  TOTAL      COUNT  MATCH   SLOWEST     AVERAGE   NAME               PATTERN"
 msgstr ""
+"  总 计      计 数  匹 配   最 慢 的     平  均   名 字              模   式"
 
 #: ../syntax.c:6146
 msgid "E679: recursive loop loading syncolor.vim"
@@ -6103,14 +6098,13 @@ msgstr "Vim: 读错误，退出中...\n"
 #. This happens when the FileChangedRO autocommand changes the
 #. * file in a way it becomes shorter.
 #: ../undo.c:379
-#, fuzzy
 msgid "E881: Line count changed unexpectedly"
-msgstr "E787: 意外地改变了缓冲区"
+msgstr "E881: 行数意外地改变了"
 
 #: ../undo.c:627
-#, fuzzy, c-format
+#, c-format
 msgid "E828: Cannot open undo file for writing: %s"
-msgstr "E212: 无法打开并写入文件"
+msgstr "E828: 无法打开撤销文件去写入"
 
 #: ../undo.c:717
 #, c-format
diff --git a/src/nvim/po/zh_TW.UTF-8.po b/src/nvim/po/zh_TW.UTF-8.po
index 5da69dfe69..e95b1e2cad 100644
--- a/src/nvim/po/zh_TW.UTF-8.po
+++ b/src/nvim/po/zh_TW.UTF-8.po
@@ -59,19 +59,19 @@ msgstr "無法傳送回應訊息"
 
 #: ../api/private/helpers.c:204
 msgid "internal error: unknown option type"
-msgstr ""
+msgstr "內部錯誤: 未知的選項類型"
 
 #: ../buffer.c:92
 msgid "[Location List]"
-msgstr ""
+msgstr "[Location 列表]"
 
 #: ../buffer.c:93
 msgid "[Quickfix List]"
-msgstr ""
+msgstr "[Quickfix 列表]"
 
 #: ../buffer.c:94
 msgid "E855: Autocommands caused command to abort"
-msgstr ""
+msgstr "E855: 自動命令導致命令被停止"
 
 #: ../buffer.c:135
 msgid "E82: Cannot allocate any buffer, exiting..."
@@ -349,7 +349,7 @@ msgstr "E103: 緩衝區 \"%s\" 不是在 diff 模式"
 
 #: ../diff.c:2193
 msgid "E787: Buffer changed unexpectedly"
-msgstr ""
+msgstr "E787: 意外地改變了緩衝區"
 
 #: ../digraph.c:1598
 msgid "E104: Escape not allowed in digraph"
@@ -365,7 +365,7 @@ msgstr "E105: 使用 :loadkeymap "
 
 #: ../digraph.c:1821
 msgid "E791: Empty keymap entry"
-msgstr ""
+msgstr "E791: 空的鍵位映射項"
 
 #: ../edit.c:82
 msgid " Keyword completion (^N^P)"
@@ -434,11 +434,11 @@ msgstr "已到段落結尾"
 
 #: ../edit.c:101
 msgid "E839: Completion function changed window"
-msgstr ""
+msgstr "E839: 補全函式更改了窗口"
 
 #: ../edit.c:102
 msgid "E840: Completion function deleted text"
-msgstr ""
+msgstr "E840: 補全函式刪除了文本"
 
 #: ../edit.c:1847
 msgid "'dictionary' option is empty"
@@ -556,7 +556,7 @@ msgstr "E118: 函式 %s 的引數過多"
 #: ../eval.c:148
 #, c-format
 msgid "E716: Key not present in Dictionary: %s"
-msgstr ""
+msgstr "E716: 鍵在字典中不存在: %s"
 
 #: ../eval.c:150
 #, c-format
@@ -581,7 +581,7 @@ msgstr "E360: 不能用 -f 選項執行 shell"
 #: ../eval.c:154
 #, c-format
 msgid "E734: Wrong variable type for %s="
-msgstr ""
+msgstr "E734: 錯誤的變數類型: %s="
 
 #: ../eval.c:155
 #, fuzzy, c-format
@@ -595,19 +595,19 @@ msgstr "E461: 不合法的變數名稱: %s"
 
 #: ../eval.c:157
 msgid "E806: using Float as a String"
-msgstr ""
+msgstr "E806: 使用浮點數作為字串"
 
 #: ../eval.c:1830
 msgid "E687: Less targets than List items"
-msgstr ""
+msgstr "E687: 目標比列表項數少"
 
 #: ../eval.c:1834
 msgid "E688: More targets than List items"
-msgstr ""
+msgstr "E688: 目標比列表項數多"
 
 #: ../eval.c:1906
 msgid "Double ; in list of variables"
-msgstr ""
+msgstr "變數列表出現兩個 ;"
 
 #: ../eval.c:2078
 #, fuzzy, c-format
@@ -616,23 +616,23 @@ msgstr "E138: 無法寫入 viminfo 檔案 %s !"
 
 #: ../eval.c:2391
 msgid "E689: Can only index a List or Dictionary"
-msgstr ""
+msgstr "E689: 只能索引一個列表或者字典"
 
 #: ../eval.c:2396
 msgid "E708: [:] must come last"
-msgstr ""
+msgstr "E708: [:] 必須在最後"
 
 #: ../eval.c:2439
 msgid "E709: [:] requires a List value"
-msgstr ""
+msgstr "E709: [:] 需要一個列表值"
 
 #: ../eval.c:2674
 msgid "E710: List value has more items than target"
-msgstr ""
+msgstr "E710: 列表值的項比目標多"
 
 #: ../eval.c:2678
 msgid "E711: List value has not enough items"
-msgstr ""
+msgstr "E711: 列表值沒有足夠多的項"
 
 #: ../eval.c:2867
 #, fuzzy
@@ -651,7 +651,7 @@ msgstr "E108: 無此變數: \"%s\""
 
 #: ../eval.c:3333
 msgid "E743: variable nested too deep for (un)lock"
-msgstr ""
+msgstr "E743: (un)lock 的變數嵌套過深"
 
 #: ../eval.c:3630
 msgid "E109: Missing ':' after '?'"
@@ -659,7 +659,7 @@ msgstr "E109: '?' 後缺少 ':'"
 
 #: ../eval.c:3893
 msgid "E691: Can only compare List with List"
-msgstr ""
+msgstr "E691: 只能比較列表和列表"
 
 #: ../eval.c:3895
 #, fuzzy
@@ -668,7 +668,7 @@ msgstr "E449: 收到不正確的運算式"
 
 #: ../eval.c:3915
 msgid "E735: Can only compare Dictionary with Dictionary"
-msgstr ""
+msgstr "E735: 只能比較字典和字典"
 
 #: ../eval.c:3917
 #, fuzzy
@@ -677,7 +677,7 @@ msgstr "E116: 函式 %s 的引數不正確"
 
 #: ../eval.c:3932
 msgid "E693: Can only compare Funcref with Funcref"
-msgstr ""
+msgstr "E693: 只能比較Funcref 和 Funcref"
 
 #: ../eval.c:3934
 #, fuzzy
@@ -736,7 +736,7 @@ msgstr "E242: 找不到顏色: %s"
 #: ../eval.c:6499
 #, c-format
 msgid "E721: Duplicate key in Dictionary: \"%s\""
-msgstr ""
+msgstr "E721: Dictionary 中出現重複的鍵: \"%s\""
 
 #: ../eval.c:6517
 #, fuzzy, c-format
@@ -781,7 +781,7 @@ msgstr "E120: <SID> 不能在 script 本文外使用: %s"
 #: ../eval.c:7391
 #, c-format
 msgid "E725: Calling dict function without Dictionary: %s"
-msgstr ""
+msgstr "E725: 調用字典函式但是沒有字典: %s"
 
 #: ../eval.c:7453
 #, fuzzy
@@ -814,16 +814,15 @@ msgstr "E227: %s 的 mapping 已經存在"
 
 #: ../eval.c:8692
 msgid "extend() argument"
-msgstr ""
+msgstr "extend() 參數"
 
 #: ../eval.c:8915
-#, fuzzy
 msgid "map() argument"
-msgstr "vim [參數] "
+msgstr "map() 參數"
 
 #: ../eval.c:8916
 msgid "filter() argument"
-msgstr ""
+msgstr "filter() 參數"
 
 #: ../eval.c:9229
 #, c-format
@@ -857,19 +856,19 @@ msgstr "E596: 不正確的字型"
 
 #: ../eval.c:11980
 msgid "E726: Stride is zero"
-msgstr ""
+msgstr "E726: 步長為零"
 
 #: ../eval.c:11982
 msgid "E727: Start past end"
-msgstr ""
+msgstr "E727: 起始值在終止值後"
 
 #: ../eval.c:12024 ../eval.c:15297
 msgid "<empty>"
-msgstr ""
+msgstr "<空>"
 
 #: ../eval.c:12282
 msgid "remove() argument"
-msgstr ""
+msgstr "remove() 參數"
 
 #: ../eval.c:12466
 msgid "E655: Too many symbolic links (cycle?)"
@@ -877,11 +876,11 @@ msgstr "E655: 太多層的符號鏈結(symlink) (循環?)"
 
 #: ../eval.c:12593
 msgid "reverse() argument"
-msgstr ""
+msgstr "reverse() 參數"
 
 #: ../eval.c:13721
 msgid "sort() argument"
-msgstr ""
+msgstr "sort() 參數"
 
 #: ../eval.c:13721
 #, fuzzy
@@ -895,7 +894,7 @@ msgstr "E237: 無法選擇此印表機"
 
 #: ../eval.c:13806
 msgid "E882: Uniq compare function failed"
-msgstr ""
+msgstr "E882: Uniq 比較函式失敗"
 
 #: ../eval.c:14085
 msgid "(Invalid)"
@@ -908,32 +907,31 @@ msgstr "E208: 寫入檔案 \"%s\" 錯誤"
 
 #: ../eval.c:16159
 msgid "E805: Using a Float as a Number"
-msgstr ""
+msgstr "E805: 將浮點數當做數字使用"
 
 #: ../eval.c:16162
 msgid "E703: Using a Funcref as a Number"
-msgstr ""
+msgstr "E703: 將函式當做數字使用"
 
 #: ../eval.c:16170
 msgid "E745: Using a List as a Number"
-msgstr ""
+msgstr "E745: 將列表當做數字使用"
 
 #: ../eval.c:16173
 msgid "E728: Using a Dictionary as a Number"
-msgstr ""
+msgstr "E728: 將字典當做數字使用"
 
 #: ../eval.c:16259
 msgid "E729: using Funcref as a String"
-msgstr ""
+msgstr "E729: 將函式當做字串使用"
 
 #: ../eval.c:16262
-#, fuzzy
 msgid "E730: using List as a String"
-msgstr "E374: 格式化字串裡少了 ]"
+msgstr "E730: 將列表當做字串使用"
 
 #: ../eval.c:16265
 msgid "E731: using Dictionary as a String"
-msgstr ""
+msgstr "E731: 將字典當做字串使用"
 
 #: ../eval.c:16619
 #, fuzzy, c-format
@@ -953,12 +951,12 @@ msgstr "E128: 函式名稱第一個字母必須大寫: %s"
 #: ../eval.c:16732
 #, c-format
 msgid "E705: Variable name conflicts with existing function: %s"
-msgstr ""
+msgstr "E705: 變數名與已有函式名衝突: %s"
 
 #: ../eval.c:16763
 #, c-format
 msgid "E741: Value is locked: %s"
-msgstr ""
+msgstr "E741: 值已鎖定: %s"
 
 #: ../eval.c:16764 ../eval.c:16769 ../message.c:1839
 msgid "Unknown"
@@ -971,7 +969,7 @@ msgstr "E284: 不能設定 IC 數值"
 
 #: ../eval.c:16838
 msgid "E698: variable nested too deep for making a copy"
-msgstr ""
+msgstr "E698: 變數嵌套過深無法複製"
 
 #: ../eval.c:17249
 #, c-format
@@ -1216,7 +1214,7 @@ msgstr "要覆寫已存在的檔案 \"%.*s\"？"
 #: ../ex_cmds.c:2317
 #, c-format
 msgid "Swap file \"%s\" exists, overwrite anyway?"
-msgstr ""
+msgstr "交換文件 \"%s\" 已存在，確實需要覆蓋嗎？"
 
 #: ../ex_cmds.c:2326
 #, fuzzy, c-format
@@ -1456,7 +1454,7 @@ msgstr "%3d  %s %s  第 %<PRId64> 行 "
 
 #: ../ex_cmds2.c:942
 msgid "E750: First use \":profile start {fname}\""
-msgstr ""
+msgstr "E750: 請先使用 :profile start <fname>"
 
 #: ../ex_cmds2.c:1269
 #, fuzzy, c-format
@@ -1555,7 +1553,7 @@ msgstr "vim [參數] "
 
 #: ../ex_cmds2.c:2771
 msgid "environment variable"
-msgstr ""
+msgstr "環境變數"
 
 #: ../ex_cmds2.c:2773
 #, fuzzy
@@ -2047,7 +2045,7 @@ msgstr "E199: 已刪除掉作用中的視窗或暫存區"
 
 #: ../file_search.c:203
 msgid "E854: path too long for completion"
-msgstr ""
+msgstr "E854: 補全用的路徑太長了"
 
 #: ../file_search.c:446
 #, c-format
@@ -2099,11 +2097,11 @@ msgstr "[未命名]"
 
 #: ../fileio.c:511
 msgid "[New DIRECTORY]"
-msgstr ""
+msgstr "[新目錄]"
 
 #: ../fileio.c:529 ../fileio.c:532
 msgid "[File too big]"
-msgstr ""
+msgstr "[文件太大]"
 
 #: ../fileio.c:534
 msgid "[Permission Denied]"
@@ -2265,7 +2263,7 @@ msgstr "E513: 無法寫入 -- 轉換失敗"
 msgid ""
 "E513: write error, conversion failed in line %<PRId64> (make 'fenc' empty to "
 "override)"
-msgstr ""
+msgstr "E513: 寫入錯誤，轉換失敗 (請將 'fenc' 置空以強制執行)"
 
 #: ../fileio.c:3448
 msgid "E514: write error (file system full?)"
@@ -2720,7 +2718,7 @@ msgstr "E49: 錯誤的捲動大小"
 
 #: ../globals.h:1021
 msgid "E901: Job table is full"
-msgstr ""
+msgstr "E901: 任務表已經滿"
 
 #: ../globals.h:1024
 #, c-format
@@ -2877,7 +2875,7 @@ msgstr "E42: 沒有錯誤"
 
 #: ../globals.h:1067
 msgid "E776: No location list"
-msgstr ""
+msgstr "E776: 沒有位置列表"
 
 #: ../globals.h:1068
 msgid "E43: Damaged match string"
@@ -2992,7 +2990,7 @@ msgstr "E473: 內部錯誤"
 
 #: ../globals.h:1104
 msgid "E363: pattern uses more memory than 'maxmempattern'"
-msgstr ""
+msgstr "E363: 表達式的內存超出 'maxmempattern'"
 
 #: ../globals.h:1105
 #, fuzzy
@@ -3097,15 +3095,15 @@ msgstr "E621: \"%s\" 資源檔版本錯誤"
 
 #: ../hardcopy.c:2225
 msgid "E673: Incompatible multi-byte encoding and character set."
-msgstr ""
+msgstr "E673: 不兼容的多字節編碼和字元集"
 
 #: ../hardcopy.c:2238
 msgid "E674: printmbcharset cannot be empty with multi-byte encoding."
-msgstr ""
+msgstr "E674: printmbcharset 在多字節編碼下不能為空"
 
 #: ../hardcopy.c:2254
 msgid "E675: No default font specified for multi-byte printing."
-msgstr ""
+msgstr "E675: 沒有指定多字節打印的默認字型"
 
 #: ../hardcopy.c:2426
 msgid "E324: Can't open PostScript output file"
@@ -3267,6 +3265,7 @@ msgstr "%-5s: %-30s (用法: %s)"
 #: ../if_cscope.c:1155
 msgid ""
 "\n"
+"       a: Find assignments to this symbol\n"
 "       c: Find functions calling this function\n"
 "       d: Find functions called by this function\n"
 "       e: Find this egrep pattern\n"
@@ -3276,6 +3275,16 @@ msgid ""
 "       s: Find this C symbol\n"
 "       t: Find this text string\n"
 msgstr ""
+"\n"
+"       a: 搜索對此符號的賦值\n"
+"       c: 搜索調用此函式的函式\n"
+"       d: 搜索此函式調用的函式\n"
+"       e: 搜索此 egrep 模式\n"
+"       f: 搜索此文件\n"
+"       g: 搜索此定義\n"
+"       i: 搜索包含此文件的文件\n"
+"       s: 搜索此 C 符号\n"
+"       t: 搜索此文本字串\n"
 
 #: ../if_cscope.c:1226
 msgid "E568: duplicate cscope database not added"
@@ -3509,7 +3518,7 @@ msgstr "-N\t\t\t'nocompatible' 不完全與傳統 Vi 相容，可使用 Vim 加
 
 #: ../main.c:2215
 msgid "-V[N][fname]\t\tBe verbose [level N] [log messages to fname]"
-msgstr ""
+msgstr "-V[N][fname]\t\t詳細 [level N] [log messages to fname]"
 
 #: ../main.c:2216
 msgid "-D\t\t\tDebugging mode"
@@ -3602,7 +3611,7 @@ msgstr "-W <scriptout>\t對檔案 <scriptout> 寫入所有輸入的命令"
 
 #: ../main.c:2240
 msgid "--startuptime <file>\tWrite startup timing messages to <file>"
-msgstr ""
+msgstr "--startuptime <file>\t將啟動時間寫入到文件 <file>"
 
 #: ../main.c:2242
 msgid "-i <viminfo>\t\tUse <viminfo> instead of .viminfo"
@@ -3794,7 +3803,7 @@ msgstr ""
 
 #: ../memline.c:945
 msgid " has been damaged (page size is smaller than minimum value).\n"
-msgstr ""
+msgstr "已损坏（頁面大小小於最小值）。\n"
 
 #: ../memline.c:974
 #, c-format
@@ -4082,7 +4091,7 @@ msgstr "E317: 指標區塊 id 錯 2"
 #: ../memline.c:3070
 #, c-format
 msgid "E773: Symlink loop for \"%s\""
-msgstr ""
+msgstr "E773: \"%s\" 符號鏈接出現循環"
 
 #: ../memline.c:3221
 msgid "E325: ATTENTION"
@@ -4231,7 +4240,7 @@ msgstr "E329: 沒有那樣的選單"
 #. Only a mnemonic or accelerator is not valid.
 #: ../menu.c:329
 msgid "E792: Empty menu name"
-msgstr ""
+msgstr "E792: 空的菜單名稱"
 
 #: ../menu.c:340
 msgid "E330: Menu path must not lead to a sub-menu"
@@ -4312,7 +4321,7 @@ msgstr "-- 尚有 --"
 
 #: ../message.c:2398
 msgid " SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "
-msgstr ""
+msgstr " 空格/d/j: 屏幕/頁/行 下翻，b/u/k: 上翻，q: 退出 "
 
 #: ../message.c:3021 ../message.c:3031
 msgid "Question"
@@ -4357,7 +4366,7 @@ msgstr "E116: 函式 %s 的引數不正確"
 
 #: ../message.c:3119
 msgid "E807: Expected Float argument for printf()"
-msgstr ""
+msgstr "E807: 期盼浮點數作為printf()參數"
 
 #: ../message.c:3873
 #, fuzzy
@@ -4370,11 +4379,11 @@ msgstr "W10: 注意: 你正在修改一個唯讀檔"
 
 #: ../misc1.c:2537
 msgid "Type number and <Enter> or click with mouse (empty cancels): "
-msgstr ""
+msgstr "請輸入數字並<Enter>或點擊鼠標（空白取消）: "
 
 #: ../misc1.c:2539
 msgid "Type number and <Enter> (empty cancels): "
-msgstr ""
+msgstr "請選擇數字並(<Enter> 取消): "
 
 #: ../misc1.c:2585
 msgid "1 more line"
@@ -4400,7 +4409,7 @@ msgstr " (已中斷)"
 
 #: ../misc1.c:2635
 msgid "Beep!"
-msgstr ""
+msgstr "Beep!"
 
 #: ../misc2.c:738
 #, c-format
@@ -4617,7 +4626,7 @@ msgstr "E520: 不能在 Modeline 裡出現"
 
 #: ../option.c:2815
 msgid "E846: Key code not set"
-msgstr ""
+msgstr "E846: 未設置鍵位代碼"
 
 #: ../option.c:2924
 msgid "E521: Number required after ="
@@ -4642,11 +4651,11 @@ msgstr "E589: 'backupext' 跟 'patchmode' 是一樣的"
 
 #: ../option.c:3964
 msgid "E834: Conflicts with value of 'listchars'"
-msgstr ""
+msgstr "E834: 與'listchars'中的值發生衝突"
 
 #: ../option.c:3966
 msgid "E835: Conflicts with value of 'fillchars'"
-msgstr ""
+msgstr "E835: 與'fillchars'中的值發生衝突"
 
 #: ../option.c:4163
 msgid "E524: Missing colon"
@@ -4884,7 +4893,7 @@ msgstr "E382: 無法寫入，'buftype' 選項已設定"
 
 #: ../quickfix.c:2812
 msgid "E683: File name missing or invalid pattern"
-msgstr ""
+msgstr "E683: 缺少文件名或模式無效"
 
 #: ../quickfix.c:2911
 #, fuzzy, c-format
@@ -5022,25 +5031,26 @@ msgid ""
 "E864: \\%#= can only be followed by 0, 1, or 2. The automatic engine will be "
 "used "
 msgstr ""
+"E864: \\%#= 後面只能是0，1，或者2。自動引擎將會被使用"
 
 #: ../regexp_nfa.c:239
 msgid "E865: (NFA) Regexp end encountered prematurely"
-msgstr ""
+msgstr "E865: (NFA) 過早的遇到了正則表達式的結尾"
 
 #: ../regexp_nfa.c:240
 #, c-format
 msgid "E866: (NFA regexp) Misplaced %c"
-msgstr ""
+msgstr "E866: (NFA regexp) %c 放錯了位置"
 
 #: ../regexp_nfa.c:242
 #, c-format
 msgid "E877: (NFA regexp) Invalid character class: %<PRId64>"
-msgstr ""
+msgstr "E877: (NFA regexp) 不可用的字元類: %<PRId64>"
 
 #: ../regexp_nfa.c:1261
 #, c-format
 msgid "E867: (NFA) Unknown operator '\\z%c'"
-msgstr ""
+msgstr "E867: (NFA) 未知的操作符 '\\z%c'"
 
 #: ../regexp_nfa.c:1387
 #, c-format
@@ -5050,21 +5060,21 @@ msgstr ""
 #: ../regexp_nfa.c:1802
 #, c-format
 msgid "E869: (NFA) Unknown operator '\\@%c'"
-msgstr ""
+msgstr "E869: (NFA) 未知的操作符 '\\%%%c'"
 
 #: ../regexp_nfa.c:1831
 msgid "E870: (NFA regexp) Error reading repetition limits"
-msgstr ""
+msgstr "E870: (NFA regexp) 读取重复限制时出错"
 
 #. Can't have a multi follow a multi.
 #: ../regexp_nfa.c:1895
 msgid "E871: (NFA regexp) Can't have a multi follow a multi !"
-msgstr ""
+msgstr "E871: (NFA regexp) 不能多个跟多个！"
 
 #. Too many `('
 #: ../regexp_nfa.c:2037
 msgid "E872: (NFA regexp) Too many '('"
-msgstr ""
+msgstr "E872: (NFA regexp) 太多 '('"
 
 #: ../regexp_nfa.c:2042
 #, fuzzy
@@ -5073,31 +5083,32 @@ msgstr "E50: 太多 \\z("
 
 #: ../regexp_nfa.c:2066
 msgid "E873: (NFA regexp) proper termination error"
-msgstr ""
+msgstr "E873: (NFA regexp) 未適當終止"
 
 #: ../regexp_nfa.c:2599
 msgid "E874: (NFA) Could not pop the stack !"
-msgstr ""
+msgstr "E874: (NFA) 無法出棧！"
 
 #: ../regexp_nfa.c:3298
 msgid ""
 "E875: (NFA regexp) (While converting from postfix to NFA), too many states "
 "left on stack"
-msgstr ""
+msgstr "E875: (NFA regexp) （從後綴轉到 NFA 时），棧上遺留了太多狀態"
 
 #: ../regexp_nfa.c:3302
 msgid "E876: (NFA regexp) Not enough space to store the whole NFA "
-msgstr ""
+msgstr "E876: (NFA regexp) 沒有足夠的空間存儲NFA "
 
 #: ../regexp_nfa.c:4571 ../regexp_nfa.c:4869
 msgid ""
 "Could not open temporary log file for writing, displaying on stderr ... "
 msgstr ""
+"無法打開臨時日志文件進行寫入，顯示在stderr中..."
 
 #: ../regexp_nfa.c:4840
 #, c-format
 msgid "(NFA) COULD NOT OPEN %s !"
-msgstr ""
+msgstr "(NFA) 不能打开 %s !"
 
 #: ../regexp_nfa.c:6049
 #, fuzzy
@@ -5270,17 +5281,17 @@ msgstr "E297: 暫存檔寫入錯誤"
 
 #: ../spell.c:952
 msgid "E758: Truncated spell file"
-msgstr ""
+msgstr "E758: 已截斷的拼寫文件"
 
 #: ../spell.c:953
 #, c-format
 msgid "Trailing text in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，多餘的後續文本: %s"
 
 #: ../spell.c:954
 #, c-format
 msgid "Affix name too long in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，附加項名字太長: %s"
 
 #: ../spell.c:955
 #, fuzzy
@@ -5289,20 +5300,20 @@ msgstr "E431: Tag 檔 \"%s\" 格式錯誤"
 
 #: ../spell.c:957
 msgid "E762: Character in FOL, LOW or UPP is out of range"
-msgstr ""
+msgstr "E762: FOL、LOW 或 UPP 中字元超出範圍"
 
 #: ../spell.c:958
 msgid "Compressing word tree..."
-msgstr ""
+msgstr "壓縮單詞樹……"
 
 #: ../spell.c:1951
 msgid "E756: Spell checking is not enabled"
-msgstr ""
+msgstr "E756: 拼寫檢查未啟用"
 
 #: ../spell.c:2249
 #, c-format
 msgid "Warning: Cannot find word list \"%s.%s.spl\" or \"%s.ascii.spl\""
-msgstr ""
+msgstr "警告: 找不到單詞列表 \"%s.%s.spl\" or \"%s.ascii.spl\""
 
 #: ../spell.c:2473
 #, fuzzy, c-format
@@ -5316,11 +5327,11 @@ msgstr "E307: %s 看起來不像是 Vim 暫存檔"
 
 #: ../spell.c:2501
 msgid "E771: Old spell file, needs to be updated"
-msgstr ""
+msgstr "E771: 舊的拼寫文件，需要更新"
 
 #: ../spell.c:2504
 msgid "E772: Spell file is for newer version of Vim"
-msgstr ""
+msgstr "E772: 為更高版本的 Vim 所使用的拼寫文件"
 
 #: ../spell.c:2602
 #, fuzzy
@@ -5340,66 +5351,68 @@ msgstr "搜尋 tag 檔案 \"%s\""
 #: ../spell.c:4589 ../spell.c:5635 ../spell.c:6140
 #, c-format
 msgid "Conversion failure for word in %s line %d: %s"
-msgstr ""
+msgstr "單詞 %s 轉換失敗，第 %d 行: %s"
 
 #: ../spell.c:4630 ../spell.c:6170
 #, c-format
 msgid "Conversion in %s not supported: from %s to %s"
-msgstr ""
+msgstr "不支持 %s 中的轉換: 从 %s 到 %s"
 
 #: ../spell.c:4642
 #, c-format
 msgid "Invalid value for FLAG in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，FLAG 的值无效: %s"
 
 #: ../spell.c:4655
 #, c-format
 msgid "FLAG after using flags in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，在使用標志後出現 FLAG: %s"
 
 #: ../spell.c:4723
 #, c-format
 msgid ""
 "Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line "
 "%d"
-msgstr ""
+msgstr "在 PFX 項之後定義 COMPOUNDFORBIDFLAG （%s 第%d行）可能會給出的錯誤結果"
+"%d"
 
 #: ../spell.c:4731
 #, c-format
 msgid ""
 "Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line "
 "%d"
-msgstr ""
+msgstr "在 PFX 項之後定義 COMPOUNDFORBIDFLAG （%s 第%d行）可能會給出的錯誤結果"
+"%d"
 
 #: ../spell.c:4747
 #, c-format
 msgid "Wrong COMPOUNDRULES value in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，错误的 COMPOUNDMIN 值: %s"
 
 #: ../spell.c:4771
 #, c-format
 msgid "Wrong COMPOUNDWORDMAX value in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，错误的 COMPOUNDWORDMAX 值: %s"
 
 #: ../spell.c:4777
 #, c-format
 msgid "Wrong COMPOUNDMIN value in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，错误的 COMPOUNDMIN 值: %s"
 
 #: ../spell.c:4783
 #, c-format
 msgid "Wrong COMPOUNDSYLMAX value in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，错误的 COMPOUNDSYLMAX 值: %s"
 
 #: ../spell.c:4795
 #, c-format
 msgid "Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，错误的 CHECKCOMPOUNDPATTERN 值: %s"
 
 #: ../spell.c:4847
 #, c-format
 msgid "Different combining flag in continued affix block in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，在連續的附加塊種出現不同的組合標誌: %s"
 
 #: ../spell.c:4850
 #, fuzzy, c-format
@@ -5412,45 +5425,47 @@ msgid ""
 "Affix also used for BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST in %s "
 "line %d: %s"
 msgstr ""
+"%s 第 %d 行，附加項被 BAD/RARE/KEEPCASE/NEEDAFFIX/NEEDCOMPOUND/NOSUGGEST 使"
+"用: %s"
 
 #: ../spell.c:4893
 #, c-format
 msgid "Expected Y or N in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，此處需要 Y 或 N: %s"
 
 #: ../spell.c:4968
 #, c-format
 msgid "Broken condition in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，錯誤的條件: %s"
 
 #: ../spell.c:5091
 #, c-format
 msgid "Expected REP(SAL) count in %s line %d"
-msgstr ""
+msgstr "%s 第 %d 行，此處需要 REP(SAL) 計數"
 
 #: ../spell.c:5120
 #, c-format
 msgid "Expected MAP count in %s line %d"
-msgstr ""
+msgstr "%s 第 %d 行，此處需要 MAP 計數"
 
 #: ../spell.c:5132
 #, c-format
 msgid "Duplicate character in MAP in %s line %d"
-msgstr ""
+msgstr "%s 第 %d 行，MAP 中存在重複的字元"
 
 #: ../spell.c:5176
 #, c-format
 msgid "Unrecognized or duplicate item in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，無法識別或重複的項: %s"
 
 #: ../spell.c:5197
 #, c-format
 msgid "Missing FOL/LOW/UPP line in %s"
-msgstr ""
+msgstr "%s 中缺少 FOL/LOW/UPP 行"
 
 #: ../spell.c:5220
 msgid "COMPOUNDSYLMAX used without SYLLABLE"
-msgstr ""
+msgstr "在没有 SYLLABLE 的情況下使用了 COMPOUNDSYLMAX"
 
 #: ../spell.c:5236
 #, fuzzy
@@ -5464,32 +5479,32 @@ msgstr "太多編輯參數"
 
 #: ../spell.c:5240
 msgid "Too many postponed prefixes and/or compound flags"
-msgstr ""
+msgstr "太多延遲前綴和/或組合標誌"
 
 #: ../spell.c:5250
 #, c-format
 msgid "Missing SOFO%s line in %s"
-msgstr ""
+msgstr "%s 中缺少 SOFO%s 行"
 
 #: ../spell.c:5253
 #, c-format
 msgid "Both SAL and SOFO lines in %s"
-msgstr ""
+msgstr "%s 同時出現 SAL 和 SOFO 行"
 
 #: ../spell.c:5331
 #, c-format
 msgid "Flag is not a number in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，標誌不是數字: %s"
 
 #: ../spell.c:5334
 #, c-format
 msgid "Illegal flag in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，無效的標誌: %s"
 
 #: ../spell.c:5493 ../spell.c:5501
 #, c-format
 msgid "%s value differs from what is used in another .aff file"
-msgstr ""
+msgstr "%s 的值與另一個 .aff 文件中使用的值不相同"
 
 #: ../spell.c:5602
 #, fuzzy, c-format
@@ -5499,12 +5514,12 @@ msgstr "掃瞄字典: %s"
 #: ../spell.c:5611
 #, c-format
 msgid "E760: No word count in %s"
-msgstr ""
+msgstr "E760: %s 中没有單詞計數"
 
 #: ../spell.c:5669
 #, c-format
 msgid "line %6d, word %6d - %s"
-msgstr ""
+msgstr "第 %6d 行，第 %6d 个單詞 - %s"
 
 #: ../spell.c:5691
 #, fuzzy, c-format
@@ -5514,17 +5529,17 @@ msgstr "每一行都找不到: %s"
 #: ../spell.c:5694
 #, c-format
 msgid "First duplicate word in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，首次出現重複的單詞: %s"
 
 #: ../spell.c:5746
 #, c-format
 msgid "%d duplicate word(s) in %s"
-msgstr ""
+msgstr "存在 %d 个重複的單詞，在 %s 中"
 
 #: ../spell.c:5748
 #, c-format
 msgid "Ignored %d word(s) with non-ASCII characters in %s"
-msgstr ""
+msgstr "忽略了含有非 ASCII 字元的 %d 个單詞，在 %s 中"
 
 #: ../spell.c:6115
 #, fuzzy, c-format
@@ -5534,42 +5549,42 @@ msgstr "從標準輸入讀取..."
 #: ../spell.c:6155
 #, c-format
 msgid "Duplicate /encoding= line ignored in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %ld 行，重复的 /encoding= 行已被忽略: %s"
 
 #: ../spell.c:6159
 #, c-format
 msgid "/encoding= line after word ignored in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，单词后的 /encoding= 行已被忽略: %s"
 
 #: ../spell.c:6180
 #, c-format
 msgid "Duplicate /regions= line ignored in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，重复的 /regions= 行已被忽略: %s"
 
 #: ../spell.c:6185
 #, c-format
 msgid "Too many regions in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，太多區域: %s"
 
 #: ../spell.c:6198
 #, c-format
 msgid "/ line ignored in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，/ 行已被忽略: %s"
 
 #: ../spell.c:6224
 #, fuzzy, c-format
 msgid "Invalid region nr in %s line %d: %s"
-msgstr "E573: 不正確的伺服器 id : %s"
+msgstr "%s 第 %d 行，無效的區域號: %s"
 
 #: ../spell.c:6230
 #, c-format
 msgid "Unrecognized flags in %s line %d: %s"
-msgstr ""
+msgstr "%s 第 %d 行，不可識別的標誌: %s"
 
 #: ../spell.c:6257
 #, c-format
 msgid "Ignored %d words with non-ASCII characters"
-msgstr ""
+msgstr "忽略了含有非 ASCII 字元的 %d 个單詞"
 
 #: ../spell.c:6656
 #, c-format
@@ -5578,23 +5593,23 @@ msgstr ""
 
 #: ../spell.c:7340
 msgid "Reading back spell file..."
-msgstr ""
+msgstr "读取拼寫文件……"
 
 #. Go through the trie of good words, soundfold each word and add it to
 #. the soundfold trie.
 #: ../spell.c:7357
 msgid "Performing soundfolding..."
-msgstr ""
+msgstr "正在 soundfolding……"
 
 #: ../spell.c:7368
 #, c-format
 msgid "Number of words after soundfolding: %<PRId64>"
-msgstr ""
+msgstr "soundfolding 后的單詞数: %<PRId64>"
 
 #: ../spell.c:7476
 #, c-format
 msgid "Total number of words: %d"
-msgstr ""
+msgstr "單詞总数: %d"
 
 #: ../spell.c:7655
 #, fuzzy, c-format
@@ -5604,11 +5619,11 @@ msgstr "寫入 viminfo 檔案 \"%s\" 中"
 #: ../spell.c:7707 ../spell.c:7927
 #, c-format
 msgid "Estimated runtime memory use: %d bytes"
-msgstr ""
+msgstr "估計運行時的內存用量: %d 位元"
 
 #: ../spell.c:7820
 msgid "E751: Output file name must not have region name"
-msgstr ""
+msgstr "E751: 輸出文件不能含有區域名"
 
 #: ../spell.c:7822
 #, fuzzy
@@ -5622,7 +5637,7 @@ msgstr "E15: 不正確的運算式: %s"
 
 #: ../spell.c:7907
 msgid "Warning: both compounding and NOBREAK specified"
-msgstr ""
+msgstr "警告: 同時指定了 compounding 和 NOBREAK"
 
 #: ../spell.c:7920
 #, fuzzy, c-format
@@ -5631,30 +5646,30 @@ msgstr "寫入 viminfo 檔案 \"%s\" 中"
 
 #: ../spell.c:7925
 msgid "Done!"
-msgstr ""
+msgstr "完成！"
 
 #: ../spell.c:8034
 #, c-format
 msgid "E765: 'spellfile' does not have %<PRId64> entries"
-msgstr ""
+msgstr "E765: 'spellfile' 没有 %<PRId64> 項"
 
 #: ../spell.c:8074
 #, c-format
 msgid "Word '%.*s' removed from %s"
-msgstr ""
+msgstr "从 %s 中删除了單詞"
 
 #: ../spell.c:8117
 #, c-format
 msgid "Word '%.*s' added to %s"
-msgstr ""
+msgstr "向 %s 中添加了單詞"
 
 #: ../spell.c:8381
 msgid "E763: Word characters differ between spell files"
-msgstr ""
+msgstr "E763: 拼寫文件之間的字元不相同"
 
 #: ../spell.c:8684
 msgid "Sorry, no suggestions"
-msgstr ""
+msgstr "抱歉，没有建议"
 
 #: ../spell.c:8687
 #, fuzzy, c-format
@@ -5671,7 +5686,7 @@ msgstr "將變動存儲至 \"%.*s\"?"
 #: ../spell.c:8737
 #, c-format
 msgid " < \"%.*s\""
-msgstr ""
+msgstr " < \"%.*s\""
 
 #: ../spell.c:8882
 #, fuzzy
@@ -5691,28 +5706,28 @@ msgstr "E307: %s 看起來不像是 Vim 暫存檔"
 #: ../spell.c:9282
 #, c-format
 msgid "E779: Old .sug file, needs to be updated: %s"
-msgstr ""
+msgstr "E779: 舊的.sug 文件，需要更新: %s"
 
 #: ../spell.c:9286
 #, c-format
 msgid "E780: .sug file is for newer version of Vim: %s"
-msgstr ""
+msgstr "E780: .sug 文件適用於較新的 Vim 版本: %s"
 
 #: ../spell.c:9295
 #, c-format
 msgid "E781: .sug file doesn't match .spl file: %s"
-msgstr ""
+msgstr "E781: .sug 文件不能匹配 .spl 文件: %s"
 
 #: ../spell.c:9305
 #, fuzzy, c-format
 msgid "E782: error while reading .sug file: %s"
-msgstr "E47: 讀取錯誤檔案失敗"
+msgstr "E782: 當讀取.sug 文件時錯誤"
 
 #. This should have been checked when generating the .spl
 #. file.
 #: ../spell.c:11575
 msgid "E783: duplicate char in MAP entry"
-msgstr ""
+msgstr "E783: MAP 條目中有重複的字元"
 
 #: ../syntax.c:266
 msgid "No Syntax items defined for this buffer"
@@ -5894,10 +5909,11 @@ msgstr "E410: 不正確的 :syntax 子命令: %s"
 msgid ""
 "  TOTAL      COUNT  MATCH   SLOWEST     AVERAGE   NAME               PATTERN"
 msgstr ""
+"  總 計      計 數  匹 配   最 慢 的    平   均   名 字              模   式"
 
 #: ../syntax.c:6146
 msgid "E679: recursive loop loading syncolor.vim"
-msgstr ""
+msgstr "E679: 加載 syncolor.vim 时出現嵌套循環"
 
 #: ../syntax.c:6256
 #, c-format
@@ -5975,7 +5991,7 @@ msgstr "E5248: 群組名稱中有不正確的字元"
 
 #: ../syntax.c:7448
 msgid "E849: Too many highlight and syntax groups"
-msgstr ""
+msgstr "E849: 高亮和語法組過多"
 
 #: ../tag.c:104
 msgid "E555: at bottom of tag stack"
@@ -6083,7 +6099,7 @@ msgstr "E435: 找不到 tag, 用猜的!"
 #: ../tag.c:2797
 #, c-format
 msgid "Duplicate field name: %s"
-msgstr ""
+msgstr "重複的字段名: %s"
 
 #: ../term.c:1442
 msgid "' not known. Available builtin terminals are:"
@@ -6131,35 +6147,35 @@ msgstr "Vim: 讀取輸入錯誤，離開中...\n"
 #. * file in a way it becomes shorter.
 #: ../undo.c:379
 msgid "E881: Line count changed unexpectedly"
-msgstr ""
+msgstr "E881: 行數意外地改變了"
 
 #: ../undo.c:627
-#, fuzzy, c-format
+#, c-format
 msgid "E828: Cannot open undo file for writing: %s"
-msgstr "E212: 無法以寫入模式開啟"
+msgstr "E828: 無法打開撤銷文件去寫入"
 
 #: ../undo.c:717
 #, c-format
 msgid "E825: Corrupted undo file (%s): %s"
-msgstr ""
+msgstr "E825: 已損壞的撤銷文件 (%s): %s"
 
 #: ../undo.c:1039
 msgid "Cannot write undo file in any directory in 'undodir'"
-msgstr ""
+msgstr "不能寫入撤銷文件到 'undodir' 中的任何文件夾"
 
 #: ../undo.c:1074
 #, c-format
 msgid "Will not overwrite with undo file, cannot read: %s"
-msgstr ""
+msgstr "不能寫入撤銷文件，不可讀取: %s"
 
 #: ../undo.c:1092
 #, c-format
 msgid "Will not overwrite, this is not an undo file: %s"
-msgstr ""
+msgstr "不會覆蓋，這不是撤銷文件: %s"
 
 #: ../undo.c:1108
 msgid "Skipping undo file write, nothing to undo"
-msgstr ""
+msgstr "跳過撤消文件寫入，沒有可撤消的內容"
 
 #: ../undo.c:1121
 #, fuzzy, c-format
@@ -6174,7 +6190,7 @@ msgstr "E297: 暫存檔寫入錯誤"
 #: ../undo.c:1280
 #, c-format
 msgid "Not reading undo file, owner differs: %s"
-msgstr ""
+msgstr "不能讀取撤銷文件，擁有者不同: %s"
 
 #: ../undo.c:1292
 #, fuzzy, c-format
@@ -6198,7 +6214,7 @@ msgstr "E484: 無法開啟檔案 %s"
 
 #: ../undo.c:1328
 msgid "File contents changed, cannot use undo info"
-msgstr ""
+msgstr "文件內容已經改變，不能使用撤銷信息"
 
 #: ../undo.c:1497
 #, fuzzy, c-format
@@ -6207,11 +6223,11 @@ msgstr "結束執行 %s"
 
 #: ../undo.c:1586 ../undo.c:1812
 msgid "Already at oldest change"
-msgstr ""
+msgstr "已經在最早的改變"
 
 #: ../undo.c:1597 ../undo.c:1814
 msgid "Already at newest change"
-msgstr ""
+msgstr "已經在最新的改變"
 
 #: ../undo.c:1806
 #, fuzzy, c-format
@@ -6259,11 +6275,11 @@ msgstr "%<PRId64> 行 %s 過 %d 次"
 
 #: ../undo.c:2228
 msgid "before"
-msgstr ""
+msgstr "之前"
 
 #: ../undo.c:2228
 msgid "after"
-msgstr ""
+msgstr "之後"
 
 #: ../undo.c:2325
 #, fuzzy
@@ -6272,7 +6288,7 @@ msgstr "沒有這個 mapping 對應"
 
 #: ../undo.c:2330
 msgid "number changes  when               saved"
-msgstr ""
+msgstr " 編號    改變  時間                 保存"
 
 #: ../undo.c:2360
 #, fuzzy, c-format
-- 
cgit 


From b21980bd607e952fe52957aec3214367bd48527b Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 29 Aug 2022 05:58:32 +0800
Subject: fix(keywordprg): default to :help if set to empty string (#19983)

---
 src/nvim/normal.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 31646f686d..cab380003d 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -4278,13 +4278,12 @@ static void nv_ident(cmdarg_T *cap)
   // double the length of the word.  p_kp / curbuf->b_p_kp could be added
   // and some numbers.
   char_u *kp = *curbuf->b_p_kp == NUL ? p_kp : (char_u *)curbuf->b_p_kp;  // 'keywordprg'
-  assert(*kp != NUL);  // option.c:do_set() should default to ":help" if empty.
-  bool kp_ex = (*kp == ':');  // 'keywordprg' is an ex command
-  bool kp_help = (STRCMP(kp, ":he") == 0 || STRCMP(kp, ":help") == 0);
+  bool kp_help = (*kp == NUL || STRCMP(kp, ":he") == 0 || STRCMP(kp, ":help") == 0);
   if (kp_help && *skipwhite(ptr) == NUL) {
     emsg(_(e_noident));   // found white space only
     return;
   }
+  bool kp_ex = (*kp == ':');  // 'keywordprg' is an ex command
   size_t buf_size = n * 2 + 30 + STRLEN(kp);
   char *buf = xmalloc(buf_size);
   buf[0] = NUL;
-- 
cgit 


From 1dcaa75a6564b8a90e74a96e242803c6aa3f59cf Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 29 Aug 2022 06:16:20 +0800
Subject: fix(events): triggered WinScrolled when only skipcol changed (#19972)

fix(events): trigger WinScrolled when only skipcol changed

vim-patch:9.0.0304: WinScrolled is not triggered when only skipcol changes

Problem:    WinScrolled is not triggered when only skipcol changes.
Solution:   Add w_last_skipcol and use it. (closes vim/vim#10998)
https://github.com/vim/vim/commit/670ab0334b536e12d84810de88e73b7bcb01346d
---
 src/nvim/autocmd.c                |  1 +
 src/nvim/buffer_defs.h            |  3 ++-
 src/nvim/testdir/test_autocmd.vim | 33 +++++++++++++++++++++++++++++++++
 src/nvim/window.c                 |  2 ++
 4 files changed, 38 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 2fe9df2206..1c1de214cd 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -1119,6 +1119,7 @@ int autocmd_register(int64_t id, event_T event, char *pat, int patlen, int group
     if (event == EVENT_WINSCROLLED && !has_event(EVENT_WINSCROLLED)) {
       curwin->w_last_topline = curwin->w_topline;
       curwin->w_last_leftcol = curwin->w_leftcol;
+      curwin->w_last_skipcol = curwin->w_skipcol;
       curwin->w_last_width = curwin->w_width;
       curwin->w_last_height = curwin->w_height;
     }
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 58bdd2c0a8..319c2addba 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -1240,9 +1240,10 @@ struct window_S {
   colnr_T w_skipcol;                // starting column when a single line
                                     // doesn't fit in the window
 
-  // four fields that are only used when there is a WinScrolled autocommand
+  // five fields that are only used when there is a WinScrolled autocommand
   linenr_T w_last_topline;          ///< last known value for w_topline
   colnr_T w_last_leftcol;           ///< last known value for w_leftcol
+  colnr_T w_last_skipcol;           ///< last known value for w_skipcol
   int w_last_width;                 ///< last known value for w_width
   int w_last_height;                ///< last known value for w_height
 
diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index a249c2bf50..27bc6303cf 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -341,6 +341,39 @@ func Test_WinScrolled_close_curwin()
   call delete('Xtestout')
 endfunc
 
+func Test_WinScrolled_long_wrapped()
+  CheckRunVimInTerminal
+
+  let lines =<< trim END
+    set scrolloff=0
+    let height = winheight(0)
+    let width = winwidth(0)
+    let g:scrolled = 0
+    au WinScrolled * let g:scrolled += 1
+    call setline(1, repeat('foo', height * width))
+    call cursor(1, height * width)
+  END
+  call writefile(lines, 'Xtest_winscrolled_long_wrapped')
+  let buf = RunVimInTerminal('-S Xtest_winscrolled_long_wrapped', {'rows': 6})
+
+  call term_sendkeys(buf, ":echo g:scrolled\<CR>")
+  call WaitForAssert({-> assert_match('^0 ', term_getline(buf, 6))}, 1000)
+
+  call term_sendkeys(buf, 'gj')
+  call term_sendkeys(buf, ":echo g:scrolled\<CR>")
+  call WaitForAssert({-> assert_match('^1 ', term_getline(buf, 6))}, 1000)
+
+  call term_sendkeys(buf, '0')
+  call term_sendkeys(buf, ":echo g:scrolled\<CR>")
+  call WaitForAssert({-> assert_match('^2 ', term_getline(buf, 6))}, 1000)
+
+  call term_sendkeys(buf, '$')
+  call term_sendkeys(buf, ":echo g:scrolled\<CR>")
+  call WaitForAssert({-> assert_match('^3 ', term_getline(buf, 6))}, 1000)
+
+  call delete('Xtest_winscrolled_long_wrapped')
+endfunc
+
 func Test_WinClosed()
   " Test that the pattern is matched against the closed window's ID, and both
   " <amatch> and <afile> are set to it.
diff --git a/src/nvim/window.c b/src/nvim/window.c
index ffbb0fa27f..5b8a69f6eb 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -5362,6 +5362,7 @@ void may_trigger_winscrolled(void)
   win_T *wp = curwin;
   if (wp->w_last_topline != wp->w_topline
       || wp->w_last_leftcol != wp->w_leftcol
+      || wp->w_last_skipcol != wp->w_skipcol
       || wp->w_last_width != wp->w_width
       || wp->w_last_height != wp->w_height) {
     char winid[NUMBUFLEN];
@@ -5375,6 +5376,7 @@ void may_trigger_winscrolled(void)
     if (win_valid_any_tab(wp)) {
       wp->w_last_topline = wp->w_topline;
       wp->w_last_leftcol = wp->w_leftcol;
+      wp->w_last_skipcol = wp->w_skipcol;
       wp->w_last_width = wp->w_width;
       wp->w_last_height = wp->w_height;
     }
-- 
cgit 


From 253f0ffd8d4784b7fca03f8f6c2455b9ee83ff9b Mon Sep 17 00:00:00 2001
From: Shougo <Shougo.Matsu@gmail.com>
Date: Mon, 29 Aug 2022 14:11:52 +0900
Subject: vim-patch:9.0.0285: it is not easy to change the command line from a
 plugin (#19979)

vim-patch:9.0.0285: it is not easy to change the command line from a plugin

Problem:    It is not easy to change the command line from a plugin.
Solution:   Add setcmdline(). (Shougo Matsushita, closes vim/vim#10869)
https://github.com/vim/vim/commit/07ea5f1509fe8dafe3262ed2702b4d0fc99e288b
---
 src/nvim/eval.lua                 |  1 +
 src/nvim/eval/funcs.c             | 25 ++++++++++++++++++++++++
 src/nvim/ex_getln.c               | 38 ++++++++++++++++++++++++++++++++++---
 src/nvim/testdir/test_cmdline.vim | 40 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 101 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index 4863d8013d..3e89489459 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -332,6 +332,7 @@ return {
     setcharpos={args=2, base=2},
     setcharsearch={args=1, base=1},
     setcmdpos={args=1, base=1},
+    setcmdline={args={1, 2}, base=1},
     setcursorcharpos={args={1, 3}, base=1},
     setenv={args=2, base=2},
     setfperm={args=2, base=1},
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 581f187140..2ed9ed34f4 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -7619,6 +7619,31 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
   }
 }
 
+/// "setcmdline()" function
+static void f_setcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  if (argvars[0].v_type != VAR_STRING || argvars[0].vval.v_string == NULL) {
+    emsg(_(e_stringreq));
+    return;
+  }
+
+  int pos = -1;
+  if (argvars[1].v_type != VAR_UNKNOWN) {
+    bool error = false;
+
+    pos = (int)tv_get_number_chk(&argvars[1], &error) - 1;
+    if (error) {
+      return;
+    }
+    if (pos < 0) {
+      emsg(_(e_positive));
+      return;
+    }
+  }
+
+  rettv->vval.v_number = set_cmdline_str(argvars[0].vval.v_string, pos);
+}
+
 /// "setcmdpos()" function
 static void f_setcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 081aa80778..84eacf3997 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -2373,9 +2373,9 @@ end:
   return cmdpreview_type != 0;
 }
 
-static int command_line_changed(CommandLineState *s)
+/// Trigger CmdlineChanged autocommands.
+static void do_autocmd_cmdlinechanged(int firstc)
 {
-  // Trigger CmdlineChanged autocommands.
   if (has_event(EVENT_CMDLINECHANGED)) {
     TryState tstate;
     Error err = ERROR_INIT;
@@ -2383,7 +2383,7 @@ static int command_line_changed(CommandLineState *s)
     dict_T *dict = get_v_event(&save_v_event);
 
     char firstcbuf[2];
-    firstcbuf[0] = (char)(s->firstc > 0 ? s->firstc : '-');
+    firstcbuf[0] = (char)firstc;
     firstcbuf[1] = 0;
 
     // set v:event to a dictionary with information about the commandline
@@ -2403,6 +2403,12 @@ static int command_line_changed(CommandLineState *s)
       redrawcmd();
     }
   }
+}
+
+static int command_line_changed(CommandLineState *s)
+{
+  // Trigger CmdlineChanged autocommands.
+  do_autocmd_cmdlinechanged(s->firstc > 0 ? s->firstc : '-');
 
   if (s->firstc == ':'
       && current_sctx.sc_sid == 0    // only if interactive
@@ -3991,6 +3997,32 @@ int get_cmdline_screen_pos(void)
   return p->cmdspos;
 }
 
+/// Set the command line str to "str".
+/// @return  1 when failed, 0 when OK.
+int set_cmdline_str(const char *str, int pos)
+{
+  CmdlineInfo *p = get_ccline_ptr();
+
+  if (p == NULL) {
+    return 1;
+  }
+
+  int len = (int)STRLEN(str);
+  realloc_cmdbuff(len + 1);
+  p->cmdlen = len;
+  STRCPY(p->cmdbuff, str);
+
+  p->cmdpos = pos < 0 || pos > p->cmdlen ? p->cmdlen : pos;
+  new_cmdpos = p->cmdpos;
+
+  redrawcmd();
+
+  // Trigger CmdlineChanged autocommands.
+  do_autocmd_cmdlinechanged(ccline.cmdfirstc == NUL ? '-' : ccline.cmdfirstc);
+
+  return 0;
+}
+
 /*
  * Set the command line byte position to "pos".  Zero is the first position.
  * Only works when the command line is being edited.
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index 517509004a..a5a30b7953 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -2185,4 +2185,44 @@ func Test_wildmenu_pum_disable_while_shown()
   set wildoptions& wildmenu&
 endfunc
 
+func Test_setcmdline()
+  func SetText(text, pos)
+    call assert_equal(0, setcmdline(a:text))
+    call assert_equal(a:text, getcmdline())
+    call assert_equal(len(a:text) + 1, getcmdpos())
+
+    call assert_equal(0, setcmdline(a:text, a:pos))
+    call assert_equal(a:text, getcmdline())
+    call assert_equal(a:pos, getcmdpos())
+
+    call assert_fails('call setcmdline("' .. a:text .. '", -1)', 'E487:')
+    call assert_fails('call setcmdline({}, 0)', 'E928:')
+    call assert_fails('call setcmdline("' .. a:text .. '", {})', 'E728:')
+
+    return ''
+  endfunc
+
+  call feedkeys(":\<C-R>=SetText('set rtp?', 2)\<CR>\<CR>", 'xt')
+  call assert_equal('set rtp?', @:)
+
+  " setcmdline() returns 1 when not editing the command line.
+  call assert_equal(1, 'foo'->setcmdline())
+
+  " Called in custom function
+  func CustomComplete(A, L, P)
+    call assert_equal(0, setcmdline("DoCmd "))
+    return "January\nFebruary\nMars\n"
+  endfunc
+
+  com! -nargs=* -complete=custom,CustomComplete DoCmd :
+  call feedkeys(":DoCmd \<C-A>\<C-B>\"\<CR>", 'tx')
+  call assert_equal('"DoCmd January February Mars', @:)
+
+  " Called in <expr>
+  cnoremap <expr>a setcmdline('let foo=')
+  call feedkeys(":a\<CR>", 'tx')
+  call assert_equal('let foo=0', @:)
+  cunmap a
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From ea4e9c71ccaf406fe7aa6b47d461cdab2d6c01e9 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Sat, 27 Aug 2022 11:28:11 +0200
Subject: refactor(plines): use a struct for chartabsize state

This is a refactor extracted from vim-patch 9.0.0067: cannot show virtual text

The logic for inline virtual text is going to be different in nvim than
text property based text in vim, but this refactor is still useful,
as calculation of displayed linesize is going to be stateful in a
similar way.
---
 src/nvim/change.c     |   4 +-
 src/nvim/charset.c    |  24 +++++--
 src/nvim/cursor.c     |  16 +++--
 src/nvim/drawline.c   |  28 +++++---
 src/nvim/edit.c       |  80 +++++++++++++---------
 src/nvim/eval/funcs.c |   6 +-
 src/nvim/ex_cmds.c    |   2 +-
 src/nvim/getchar.c    |  19 ++++--
 src/nvim/indent.c     |  52 +++++++++------
 src/nvim/mouse.c      |  26 ++++----
 src/nvim/ops.c        | 101 +++++++++++++++++++---------
 src/nvim/plines.c     | 182 ++++++++++++++++++++++++++++++--------------------
 src/nvim/plines.h     |  14 ++++
 src/nvim/regexp.c     |   2 +-
 src/nvim/regexp_bt.c  |   1 +
 src/nvim/regexp_nfa.c |   2 +-
 16 files changed, 354 insertions(+), 205 deletions(-)

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 04dfb20a1b..074700f4df 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -653,9 +653,9 @@ void ins_char_bytes(char_u *buf, size_t charlen)
       // cells.  May result in adding spaces to fill a gap.
       colnr_T vcol;
       getvcol(curwin, &curwin->w_cursor, NULL, &vcol, NULL);
-      colnr_T new_vcol = vcol + win_chartabsize(curwin, buf, vcol);
+      colnr_T new_vcol = vcol + win_chartabsize(curwin, (char *)buf, vcol);
       while (oldp[col + oldlen] != NUL && vcol < new_vcol) {
-        vcol += win_chartabsize(curwin, oldp + col + oldlen, vcol);
+        vcol += win_chartabsize(curwin, (char *)oldp + col + oldlen, vcol);
         // Don't need to remove a TAB that takes us to the right
         // position.
         if (vcol > new_vcol && oldp[col + oldlen] == TAB) {
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index dc62b85716..3632c3d70b 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -930,14 +930,18 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
     posptr -= utf_head_off(line, posptr);
   }
 
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
+
   // This function is used very often, do some speed optimizations.
   // When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
-  // use a simple loop.
+  // and there are no virtual text use a simple loop.
   // Also use this when 'list' is set but tabs take their normal size.
   if ((!wp->w_p_list || (wp->w_p_lcs_chars.tab1 != NUL))
       && !wp->w_p_lbr
       && *get_showbreak_value(wp) == NUL
-      && !wp->w_p_bri) {
+      && !wp->w_p_bri
+      && !cts.cts_has_virt_text) {
     for (;;) {
       head = 0;
       int c = *ptr;
@@ -984,25 +988,29 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
   } else {
     for (;;) {
       // A tab gets expanded, depending on the current column
+      // Other things also take up space.
       head = 0;
-      incr = win_lbr_chartabsize(wp, line, ptr, vcol, &head);
+      incr = win_lbr_chartabsize(&cts, &head);
 
       // make sure we don't go past the end of the line
-      if (*ptr == NUL) {
+      if (*cts.cts_ptr == NUL) {
         // NUL at end of line only takes one column
         incr = 1;
         break;
       }
 
-      if ((posptr != NULL) && (ptr >= posptr)) {
+      if ((posptr != NULL) && ((char_u *)cts.cts_ptr >= posptr)) {
         // character at pos->col
         break;
       }
 
-      vcol += incr;
-      MB_PTR_ADV(ptr);
+      cts.cts_vcol += incr;
+      MB_PTR_ADV(cts.cts_ptr);
     }
+    vcol = cts.cts_vcol;
+    ptr = (char_u *)cts.cts_ptr;
   }
+  clear_chartabsize_arg(&cts);
 
   if (start != NULL) {
     *start = vcol + head;
@@ -1013,6 +1021,8 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
   }
 
   if (cursor != NULL) {
+    // cursor is after inserted text
+    vcol += cts.cts_cur_text_width;
     if ((*ptr == TAB)
         && (State & MODE_NORMAL)
         && !wp->w_p_list
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index 14ebc11cbf..ed0488cf76 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -137,14 +137,18 @@ static int coladvance2(pos_T *pos, bool addspaces, bool finetune, colnr_T wcol_a
       }
     }
 
-    char_u *ptr = line;
-    while (col <= wcol && *ptr != NUL) {
+    chartabsize_T cts;
+    init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+    while (cts.cts_vcol <= wcol && *cts.cts_ptr != NUL) {
       // Count a tab for what it's worth (if list mode not on)
-      csize = win_lbr_chartabsize(curwin, line, ptr, col, &head);
-      MB_PTR_ADV(ptr);
-      col += csize;
+      csize = win_lbr_chartabsize(&cts, &head);
+      MB_PTR_ADV(cts.cts_ptr);
+      cts.cts_vcol += csize;
     }
-    idx = (int)(ptr - line);
+    col = cts.cts_vcol;
+    idx = (int)(cts.cts_ptr - (char *)line);
+    clear_chartabsize_arg(&cts);
+
     // Handle all the special cases.  The virtual_active() check
     // is needed to ensure that a virtual position off the end of
     // a line has the correct indexing.  The one_more comparison
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 9132d6666e..4b5f6c6c06 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -940,12 +940,19 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
   }
   if (v > 0 && !number_only) {
     char_u *prev_ptr = ptr;
-    while (vcol < v && *ptr != NUL) {
-      c = win_lbr_chartabsize(wp, line, ptr, (colnr_T)vcol, NULL);
-      vcol += c;
-      prev_ptr = ptr;
-      MB_PTR_ADV(ptr);
+    chartabsize_T cts;
+    int charsize;
+
+    init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, ptr);
+    while (cts.cts_vcol < v && *cts.cts_ptr != NUL) {
+      charsize = win_lbr_chartabsize(&cts, NULL);
+      cts.cts_vcol += charsize;
+      prev_ptr = (char_u *)cts.cts_ptr;
+      MB_PTR_ADV(cts.cts_ptr);
     }
+    vcol = cts.cts_vcol;
+    ptr = (char_u *)cts.cts_ptr;
+    clear_chartabsize_arg(&cts);
 
     // When:
     // - 'cuc' is set, or
@@ -963,11 +970,11 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
     // Handle a character that's not completely on the screen: Put ptr at
     // that character but skip the first few screen characters.
     if (vcol > v) {
-      vcol -= c;
+      vcol -= charsize;
       ptr = prev_ptr;
       // If the character fits on the screen, don't need to skip it.
       // Except for a TAB.
-      if (utf_ptr2cells((char *)ptr) >= c || *ptr == TAB) {
+      if (utf_ptr2cells((char *)ptr) >= charsize || *ptr == TAB) {
         n_skip = (int)(v - vcol);
       }
     }
@@ -1798,8 +1805,10 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
             && !vim_isbreak((int)(*ptr))) {
           int mb_off = utf_head_off(line, ptr - 1);
           char_u *p = ptr - (mb_off + 1);
-          // TODO(neovim): is passing p for start of the line OK?
-          n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol, NULL) - 1;
+          chartabsize_T cts;
+
+          init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, p);
+          n_extra = win_lbr_chartabsize(&cts, NULL) - 1;
 
           // We have just drawn the showbreak value, no need to add
           // space for it again.
@@ -1825,6 +1834,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
               c = ' ';
             }
           }
+          clear_chartabsize_arg(&cts);
         }
 
         in_multispace = c == ' ' && ((ptr > line + 1 && ptr[-2] == ' ') || *ptr == ' ');
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index ed625e1d6e..e785a46dae 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1665,28 +1665,28 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   } else if (!(State & MODE_INSERT)) {
     new_cursor_col = curwin->w_cursor.col;
   } else {
-    /*
-     * Compute the screen column where the cursor should be.
-     */
+    // Compute the screen column where the cursor should be.
     vcol = get_indent() - vcol;
     curwin->w_virtcol = (colnr_T)((vcol < 0) ? 0 : vcol);
 
-    /*
-     * Advance the cursor until we reach the right screen column.
-     */
-    vcol = last_vcol = 0;
-    new_cursor_col = -1;
+    // Advance the cursor until we reach the right screen column.
+    last_vcol = 0;
     ptr = get_cursor_line_ptr();
-    while (vcol <= (int)curwin->w_virtcol) {
-      last_vcol = vcol;
-      if (new_cursor_col >= 0) {
-        new_cursor_col += utfc_ptr2len((char *)ptr + new_cursor_col);
-      } else {
-        new_cursor_col++;
+    chartabsize_T cts;
+    init_chartabsize_arg(&cts, curwin, 0, 0, ptr, ptr);
+    while (cts.cts_vcol <= (int)curwin->w_virtcol) {
+      last_vcol = cts.cts_vcol;
+      if (cts.cts_vcol > 0) {
+        MB_PTR_ADV(cts.cts_ptr);
+      }
+      if (*cts.cts_ptr == NUL) {
+        break;
       }
-      vcol += lbr_chartabsize(ptr, ptr + new_cursor_col, (colnr_T)vcol);
+      cts.cts_vcol += lbr_chartabsize(&cts);
     }
     vcol = last_vcol;
+    new_cursor_col = (int)(cts.cts_ptr - cts.cts_line);
+    clear_chartabsize_arg(&cts);
 
     /*
      * May need to insert spaces to be able to position the cursor on
@@ -2991,7 +2991,7 @@ static void replace_do_bs(int limit_col)
       // Get the number of screen cells used by the character we are
       // going to delete.
       getvcol(curwin, &curwin->w_cursor, NULL, &start_vcol, NULL);
-      orig_vcols = win_chartabsize(curwin, get_cursor_pos_ptr(), start_vcol);
+      orig_vcols = win_chartabsize(curwin, (char *)get_cursor_pos_ptr(), start_vcol);
     }
     (void)del_char_after_col(limit_col);
     if (l_State & VREPLACE_FLAG) {
@@ -3006,7 +3006,7 @@ static void replace_do_bs(int limit_col)
       ins_len = (int)STRLEN(p) - orig_len;
       vcol = start_vcol;
       for (i = 0; i < ins_len; i++) {
-        vcol += win_chartabsize(curwin, p + i, vcol);
+        vcol += win_chartabsize(curwin, (char *)p + i, vcol);
         i += utfc_ptr2len((char *)p) - 1;
       }
       vcol -= start_vcol;
@@ -4644,11 +4644,15 @@ static bool ins_tab(void)
     getvcol(curwin, &fpos, &vcol, NULL, NULL);
     getvcol(curwin, cursor, &want_vcol, NULL, NULL);
 
+    char_u *tab = (char_u *)"\t";
+    chartabsize_T cts;
+    init_chartabsize_arg(&cts, curwin, 0, vcol, tab, tab);
+
     // Use as many TABs as possible.  Beware of 'breakindent', 'showbreak'
     // and 'linebreak' adding extra virtual columns.
     while (ascii_iswhite(*ptr)) {
-      i = lbr_chartabsize(NULL, (char_u *)"\t", vcol);
-      if (vcol + i > want_vcol) {
+      i = lbr_chartabsize(&cts);
+      if (cts.cts_vcol + i > want_vcol) {
         break;
       }
       if (*ptr != TAB) {
@@ -4663,19 +4667,24 @@ static bool ins_tab(void)
       }
       fpos.col++;
       ptr++;
-      vcol += i;
+      cts.cts_vcol += i;
     }
+    vcol = cts.cts_vcol;
+    clear_chartabsize_arg(&cts);
 
     if (change_col >= 0) {
       int repl_off = 0;
-      char_u *line = ptr;
-
       // Skip over the spaces we need.
-      while (vcol < want_vcol && *ptr == ' ') {
-        vcol += lbr_chartabsize(line, ptr, vcol);
-        ptr++;
+      init_chartabsize_arg(&cts, curwin, 0, vcol, ptr, ptr);
+      while (cts.cts_vcol < want_vcol && *cts.cts_ptr == ' ') {
+        cts.cts_vcol += lbr_chartabsize(&cts);
+        cts.cts_ptr++;
         repl_off++;
       }
+      ptr = (char_u *)cts.cts_ptr;
+      vcol = cts.cts_vcol;
+      clear_chartabsize_arg(&cts);
+
       if (vcol > want_vcol) {
         // Must have a char with 'showbreak' just before it.
         ptr--;
@@ -4855,7 +4864,6 @@ static int ins_digraph(void)
 int ins_copychar(linenr_T lnum)
 {
   int c;
-  int temp;
   char_u *ptr, *prev_ptr;
   char_u *line;
 
@@ -4865,17 +4873,23 @@ int ins_copychar(linenr_T lnum)
   }
 
   // try to advance to the cursor column
-  temp = 0;
-  line = ptr = ml_get(lnum);
-  prev_ptr = ptr;
+  line = ml_get(lnum);
+  prev_ptr = line;
   validate_virtcol();
-  while ((colnr_T)temp < curwin->w_virtcol && *ptr != NUL) {
-    prev_ptr = ptr;
-    temp += lbr_chartabsize_adv(line, &ptr, (colnr_T)temp);
+
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, curwin, lnum, 0, line, line);
+  while (cts.cts_vcol < curwin->w_virtcol && *cts.cts_ptr != NUL) {
+    prev_ptr = (char_u *)cts.cts_ptr;
+    cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
-  if ((colnr_T)temp > curwin->w_virtcol) {
+
+  if (cts.cts_vcol > curwin->w_virtcol) {
     ptr = prev_ptr;
+  } else {
+    ptr = (char_u *)cts.cts_ptr;
   }
+  clear_chartabsize_arg(&cts);
 
   c = utf_ptr2char((char *)ptr);
   if (c == NUL) {
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 581f187140..f3a00ffeb2 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -849,11 +849,11 @@ static void get_col(typval_T *argvars, typval_T *rettv, bool charcol)
       // col(".") when the cursor is on the NUL at the end of the line
       // because of "coladd" can be seen as an extra column.
       if (virtual_active() && fp == &curwin->w_cursor) {
-        char_u *p = get_cursor_pos_ptr();
+        char *p = (char *)get_cursor_pos_ptr();
         if (curwin->w_cursor.coladd >=
             (colnr_T)win_chartabsize(curwin, p, curwin->w_virtcol - curwin->w_cursor.coladd)) {
           int l;
-          if (*p != NUL && p[(l = utfc_ptr2len((char *)p))] == NUL) {
+          if (*p != NUL && p[(l = utfc_ptr2len(p))] == NUL) {
             col += l;
           }
         }
@@ -8512,7 +8512,7 @@ static void f_strdisplaywidth(typval_T *argvars, typval_T *rettv, EvalFuncData f
     col = (int)tv_get_number(&argvars[1]);
   }
 
-  rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, (char_u *)s) - col);
+  rettv->vval.v_number = (varnumber_T)(linetabsize_col(col, (char *)s) - col);
 }
 
 /// "strwidth()" function
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index a72cddc0a9..3bb900b57f 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -841,7 +841,7 @@ void ex_retab(exarg_T *eap)
       if (ptr[col] == NUL) {
         break;
       }
-      vcol += win_chartabsize(curwin, (char_u *)ptr + col, (colnr_T)vcol);
+      vcol += win_chartabsize(curwin, ptr + col, (colnr_T)vcol);
       if (vcol >= MAXCOL) {
         emsg(_(e_resulting_text_too_long));
         break;
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index c1c5680cb0..f875fda13d 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -2547,7 +2547,7 @@ static int vgetorpeek(bool advance)
             && (State & MODE_INSERT)
             && (p_timeout || (keylen == KEYLEN_PART_KEY && p_ttimeout))
             && (c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len, 3, 25L)) == 0) {
-          colnr_T col = 0, vcol;
+          colnr_T col = 0;
           char_u *ptr;
 
           if (mode_displayed) {
@@ -2565,15 +2565,20 @@ static int vgetorpeek(bool advance)
                 // We are expecting to truncate the trailing
                 // white-space, so find the last non-white
                 // character -- webb
-                col = vcol = curwin->w_wcol = 0;
+                curwin->w_wcol = 0;
                 ptr = get_cursor_line_ptr();
-                while (col < curwin->w_cursor.col) {
-                  if (!ascii_iswhite(ptr[col])) {
-                    curwin->w_wcol = vcol;
+                chartabsize_T cts;
+                init_chartabsize_arg(&cts, curwin,
+                                     curwin->w_cursor.lnum, 0, ptr, ptr);
+                while ((char_u *)cts.cts_ptr < ptr + curwin->w_cursor.col) {
+                  if (!ascii_iswhite(*cts.cts_ptr)) {
+                    curwin->w_wcol = cts.cts_vcol;
                   }
-                  vcol += lbr_chartabsize(ptr, ptr + col, vcol);
-                  col += utfc_ptr2len((char *)ptr + col);
+                  cts.cts_vcol += lbr_chartabsize(&cts);
+                  cts.cts_ptr += utfc_ptr2len(cts.cts_ptr);
                 }
+                clear_chartabsize_arg(&cts);
+
                 curwin->w_wrow = curwin->w_cline_row
                                  + curwin->w_wcol / curwin->w_width_inner;
                 curwin->w_wcol %= curwin->w_width_inner;
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index c4805283c2..8aa8492dae 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -1034,13 +1034,15 @@ int get_lisp_indent(void)
         amount = 2;
       } else {
         char_u *line = that;
-
-        amount = 0;
-
-        while (*that && col) {
-          amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
+        chartabsize_T cts;
+        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+        while (*cts.cts_ptr != NUL && col > 0) {
+          cts.cts_vcol += lbr_chartabsize_adv(&cts);
           col--;
         }
+        amount = cts.cts_vcol;
+        that = (char_u *)cts.cts_ptr;
+        clear_chartabsize_arg(&cts);
 
         // Some keywords require "body" indenting rules (the
         // non-standard-lisp ones are Scheme special forms):
@@ -1056,10 +1058,15 @@ int get_lisp_indent(void)
           }
           firsttry = amount;
 
-          while (ascii_iswhite(*that)) {
-            amount += lbr_chartabsize(line, that, (colnr_T)amount);
-            that++;
+          init_chartabsize_arg(&cts, curwin, (colnr_T)(that - line),
+                               amount, line, that);
+          while (ascii_iswhite(*cts.cts_ptr)) {
+            cts.cts_vcol += lbr_chartabsize(&cts);
+            cts.cts_ptr++;
           }
+          that = (char_u *)cts.cts_ptr;
+          amount = cts.cts_vcol;
+          clear_chartabsize_arg(&cts);
 
           if (*that && (*that != ';')) {
             // Not a comment line.
@@ -1072,33 +1079,38 @@ int get_lisp_indent(void)
             parencount = 0;
             quotecount = 0;
 
+            init_chartabsize_arg(&cts, curwin,
+                                 (colnr_T)(that - line), amount, line, that);
             if (vi_lisp || ((*that != '"') && (*that != '\'')
                             && (*that != '#') && ((*that < '0') || (*that > '9')))) {
-              while (*that
-                     && (!ascii_iswhite(*that) || quotecount || parencount)
-                     && (!((*that == '(' || *that == '[')
+              while (*cts.cts_ptr
+                     && (!ascii_iswhite(*cts.cts_ptr) || quotecount || parencount)
+                     && (!((*cts.cts_ptr == '(' || *cts.cts_ptr == '[')
                            && !quotecount && !parencount && vi_lisp))) {
-                if (*that == '"') {
+                if (*cts.cts_ptr == '"') {
                   quotecount = !quotecount;
                 }
-                if (((*that == '(') || (*that == '[')) && !quotecount) {
+                if (((*cts.cts_ptr == '(') || (*cts.cts_ptr == '[')) && !quotecount) {
                   parencount++;
                 }
-                if (((*that == ')') || (*that == ']')) && !quotecount) {
+                if (((*cts.cts_ptr == ')') || (*cts.cts_ptr == ']')) && !quotecount) {
                   parencount--;
                 }
-                if ((*that == '\\') && (*(that + 1) != NUL)) {
-                  amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
+                if ((*cts.cts_ptr == '\\') && (*(cts.cts_ptr + 1) != NUL)) {
+                  cts.cts_vcol += lbr_chartabsize_adv(&cts);
                 }
 
-                amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
+                cts.cts_vcol += lbr_chartabsize_adv(&cts);
               }
             }
 
-            while (ascii_iswhite(*that)) {
-              amount += lbr_chartabsize(line, that, (colnr_T)amount);
-              that++;
+            while (ascii_iswhite(*cts.cts_ptr)) {
+              cts.cts_vcol += lbr_chartabsize(&cts);
+              cts.cts_ptr++;
             }
+            that = (char_u *)cts.cts_ptr;
+            amount = cts.cts_vcol;
+            clear_chartabsize_arg(&cts);
 
             if (!*that || (*that == ';')) {
               amount = firsttry;
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 3dfbeec048..5ebe97aa61 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -631,14 +631,16 @@ colnr_T vcol2col(win_T *const wp, const linenr_T lnum, const colnr_T vcol)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
   // try to advance to the specified column
-  char_u *ptr = ml_get_buf(wp->w_buffer, lnum, false);
-  char_u *const line = ptr;
-  colnr_T count = 0;
-  while (count < vcol && *ptr != NUL) {
-    count += win_lbr_chartabsize(wp, line, ptr, count, NULL);
-    MB_PTR_ADV(ptr);
-  }
-  return (colnr_T)(ptr - line);
+  char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  while (cts.cts_vcol < vcol && *cts.cts_ptr != NUL) {
+    cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
+    MB_PTR_ADV(cts.cts_ptr);
+  }
+  clear_chartabsize_arg(&cts);
+
+  return (colnr_T)((char_u *)cts.cts_ptr - line);
 }
 
 /// Set UI mouse depending on current mode and 'mouse'.
@@ -667,7 +669,7 @@ static colnr_T scroll_line_len(linenr_T lnum)
   char_u *line = ml_get(lnum);
   if (*line != NUL) {
     for (;;) {
-      int numchar = win_chartabsize(curwin, line, col);
+      int numchar = win_chartabsize(curwin, (char *)line, col);
       MB_PTR_ADV(line);
       if (*line == NUL) {    // don't count the last character
         break;
@@ -790,7 +792,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
     // checked for concealed characters.
     vcol = 0;
     while (vcol < offset && *ptr != NUL) {
-      vcol += win_chartabsize(curwin, ptr, vcol);
+      vcol += win_chartabsize(curwin, (char *)ptr, vcol);
       ptr += utfc_ptr2len((char *)ptr);
     }
 
@@ -801,7 +803,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
   vcol = offset;
   ptr_end = ptr_row_offset;
   while (vcol < col && *ptr_end != NUL) {
-    vcol += win_chartabsize(curwin, ptr_end, vcol);
+    vcol += win_chartabsize(curwin, (char *)ptr_end, vcol);
     ptr_end += utfc_ptr2len((char *)ptr_end);
   }
 
@@ -816,7 +818,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
 #define DECR() nudge--; ptr_end -= utfc_ptr2len((char *)ptr_end)
 
   while (ptr < ptr_end && *ptr != NUL) {
-    cwidth = win_chartabsize(curwin, ptr, vcol);
+    cwidth = win_chartabsize(curwin, (char *)ptr, vcol);
     vcol += cwidth;
     if (cwidth > 1 && *ptr == '\t' && nudge > 0) {
       // A tab will "absorb" any previous adjustments.
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 0fc15b9382..896cfa6098 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -378,12 +378,20 @@ static void shift_block(oparg_T *oap, int amount)
         bd.startspaces = 0;
       }
     }
-    for (; ascii_iswhite(*bd.textstart);) {
-      // TODO(fmoralesc): is passing bd.textstart for start of the line OK?
-      incr = lbr_chartabsize_adv(bd.textstart, &bd.textstart, bd.start_vcol);
+
+    // TODO(vim): is passing bd.textstart for start of the line OK?
+    chartabsize_T cts;
+    init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
+                         bd.start_vcol, bd.textstart, bd.textstart);
+    while (ascii_iswhite(*cts.cts_ptr)) {
+      incr = lbr_chartabsize_adv(&cts);
       total += incr;
-      bd.start_vcol += incr;
+      cts.cts_vcol += incr;
     }
+    bd.textstart = (char_u *)cts.cts_ptr;
+    bd.start_vcol = cts.cts_vcol;
+    clear_chartabsize_arg(&cts);
+
     // OK, now total=all the VWS reqd, and textstart points at the 1st
     // non-ws char in the block.
     if (!curbuf->b_p_et) {
@@ -438,10 +446,16 @@ static void shift_block(oparg_T *oap, int amount)
     // The character's column is in "bd.start_vcol".
     colnr_T non_white_col = bd.start_vcol;
 
-    while (ascii_iswhite(*non_white)) {
-      incr = lbr_chartabsize_adv(bd.textstart, &non_white, non_white_col);
-      non_white_col += incr;
+    chartabsize_T cts;
+    init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
+                         non_white_col, bd.textstart, non_white);
+    while (ascii_iswhite(*cts.cts_ptr)) {
+      incr = lbr_chartabsize_adv(&cts);
+      cts.cts_vcol += incr;
     }
+    non_white_col = cts.cts_vcol;
+    non_white = (char_u *)cts.cts_ptr;
+    clear_chartabsize_arg(&cts);
 
     const colnr_T block_space_width = non_white_col - oap->start_vcol;
     // We will shift by "total" or "block_space_width", whichever is less.
@@ -462,17 +476,19 @@ static void shift_block(oparg_T *oap, int amount)
     if (bd.startspaces) {
       verbatim_copy_width -= bd.start_char_vcols;
     }
-    while (verbatim_copy_width < destination_col) {
-      char_u *line = verbatim_copy_end;
-
-      // TODO: is passing verbatim_copy_end for start of the line OK?
-      incr = lbr_chartabsize(line, verbatim_copy_end, verbatim_copy_width);
-      if (verbatim_copy_width + incr > destination_col) {
+    init_chartabsize_arg(&cts, curwin, 0, verbatim_copy_width,
+                         bd.textstart, verbatim_copy_end);
+    while (cts.cts_vcol < destination_col) {
+      incr = lbr_chartabsize(&cts);
+      if (cts.cts_vcol + incr > destination_col) {
         break;
       }
-      verbatim_copy_width += incr;
-      MB_PTR_ADV(verbatim_copy_end);
+      cts.cts_vcol += incr;
+      MB_PTR_ADV(cts.cts_ptr);
     }
+    verbatim_copy_width = cts.cts_vcol;
+    verbatim_copy_end = (char_u *)cts.cts_ptr;
+    clear_chartabsize_arg(&cts);
 
     // If "destination_col" is different from the width of the initial
     // part of the line that will be copied, it means we encountered a tab
@@ -1550,6 +1566,7 @@ int op_delete(oparg_T *oap)
     // Put deleted text into register 1 and shift number registers if the
     // delete contains a line break, or when using a specific operator (Vi
     // compatible)
+
     if (oap->motion_type == kMTLineWise || oap->line_count > 1 || oap->use_reg_one) {
       shift_delete_registers(is_append_register(oap->regname));
       reg = &y_regs[1];
@@ -3280,12 +3297,19 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       // get the old line and advance to the position to insert at
       oldp = get_cursor_line_ptr();
       oldlen = STRLEN(oldp);
-      for (ptr = oldp; vcol < col && *ptr;) {
+      chartabsize_T cts;
+      init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0,
+                           oldp, oldp);
+
+      while (cts.cts_vcol < col && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
-        incr = lbr_chartabsize_adv(oldp, &ptr, vcol);
-        vcol += incr;
+        incr = lbr_chartabsize_adv(&cts);
+        cts.cts_vcol += incr;
       }
+      vcol = cts.cts_vcol;
+      ptr = (char_u *)cts.cts_ptr;
       bd.textcol = (colnr_T)(ptr - oldp);
+      clear_chartabsize_arg(&cts);
 
       shortline = (vcol < col) || (vcol == col && !*ptr);
 
@@ -3312,9 +3336,14 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         // calculate number of spaces required to fill right side of
         // block
         spaces = y_width + 1;
+        init_chartabsize_arg(&cts, curwin, 0, 0,
+                             (char_u *)y_array[i], (char_u *)y_array[i]);
         for (int j = 0; j < yanklen; j++) {
-          spaces -= lbr_chartabsize(NULL, (char_u *)(&y_array[i][j]), 0);
+          spaces -= lbr_chartabsize(&cts);
+          cts.cts_ptr++;
+          cts.cts_vcol = 0;
         }
+        clear_chartabsize_arg(&cts);
         if (spaces < 0) {
           spaces = 0;
         }
@@ -4227,22 +4256,28 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
   bdp->start_char_vcols = 0;
 
   line = ml_get(lnum);
-  pstart = line;
   prev_pstart = line;
-  while (bdp->start_vcol < oap->start_vcol && *pstart) {
+
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, curwin, lnum, bdp->start_vcol, line, line);
+  while (cts.cts_vcol < oap->start_vcol && *cts.cts_ptr != NUL) {
     // Count a tab for what it's worth (if list mode not on)
-    incr = lbr_chartabsize(line, pstart, bdp->start_vcol);
-    bdp->start_vcol += incr;
-    if (ascii_iswhite(*pstart)) {
+    incr = lbr_chartabsize(&cts);
+    cts.cts_vcol += incr;
+    if (ascii_iswhite(*cts.cts_ptr)) {
       bdp->pre_whitesp += incr;
       bdp->pre_whitesp_c++;
     } else {
       bdp->pre_whitesp = 0;
       bdp->pre_whitesp_c = 0;
     }
-    prev_pstart = pstart;
-    MB_PTR_ADV(pstart);
+    prev_pstart = (char_u *)cts.cts_ptr;
+    MB_PTR_ADV(cts.cts_ptr);
   }
+  bdp->start_vcol = cts.cts_vcol;
+  pstart = (char_u *)cts.cts_ptr;
+  clear_chartabsize_arg(&cts);
+
   bdp->start_char_vcols = incr;
   if (bdp->start_vcol < oap->start_vcol) {      // line too short
     bdp->end_vcol = bdp->start_vcol;
@@ -4278,13 +4313,19 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
         }
       }
     } else {
+      init_chartabsize_arg(&cts, curwin, lnum, bdp->end_vcol,
+                           line, pend);
       prev_pend = pend;
-      while (bdp->end_vcol <= oap->end_vcol && *pend != NUL) {
+      while (cts.cts_vcol <= oap->end_vcol && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
-        prev_pend = pend;
-        incr = lbr_chartabsize_adv(line, &pend, bdp->end_vcol);
-        bdp->end_vcol += incr;
+        prev_pend = (char_u *)cts.cts_ptr;
+        incr = lbr_chartabsize_adv(&cts);
+        cts.cts_vcol += incr;
       }
+      bdp->end_vcol = cts.cts_vcol;
+      pend = (char_u *)cts.cts_ptr;
+      clear_chartabsize_arg(&cts);
+
       if (bdp->end_vcol <= oap->end_vcol
           && (!is_del
               || oap->op_type == OP_APPEND
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index 70bdbd8b1d..f13e83ca9b 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -98,15 +98,15 @@ int plines_win_nofill(win_T *wp, linenr_T lnum, bool winheight)
 /// "wp".  Does not care about folding, 'wrap' or 'diff'.
 int plines_win_nofold(win_T *wp, linenr_T lnum)
 {
-  char_u *s;
+  char *s;
   unsigned int col;
   int width;
 
-  s = ml_get_buf(wp->w_buffer, lnum, false);
+  s = (char *)ml_get_buf(wp->w_buffer, lnum, false);
   if (*s == NUL) {  // empty line
     return 1;
   }
-  col = win_linetabsize(wp, s, MAXCOL);
+  col = win_linetabsize(wp, lnum, (char_u *)s, MAXCOL);
 
   // If list mode is on, then the '$' at the end of the line may take up one
   // extra column.
@@ -145,23 +145,27 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
   }
 
   char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
-  char_u *s = line;
 
   colnr_T col = 0;
-  while (*s != NUL && --column >= 0) {
-    col += win_lbr_chartabsize(wp, line, s, col, NULL);
-    MB_PTR_ADV(s);
+  chartabsize_T cts;
+
+  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  while (*cts.cts_ptr != NUL && --column >= 0) {
+    cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
+    MB_PTR_ADV(cts.cts_ptr);
   }
 
-  // If *s is a TAB, and the TAB is not displayed as ^I, and we're not in
-  // MODE_INSERT state, then col must be adjusted so that it represents the
+  // If *cts.cts_ptr is a TAB, and the TAB is not displayed as ^I, and we're not
+  // in MODE_INSERT state, then col must be adjusted so that it represents the
   // last screen position of the TAB.  This only fixes an error when the TAB
   // wraps from one screen line to the next (when 'columns' is not a multiple
   // of 'ts') -- webb.
-  if (*s == TAB && (State & MODE_NORMAL)
+  col = cts.cts_vcol;
+  if (*cts.cts_ptr == TAB && (State & MODE_NORMAL)
       && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
-    col += win_lbr_chartabsize(wp, line, s, col, NULL) - 1;
+    col += win_lbr_chartabsize(&cts, NULL) - 1;
   }
+  clear_chartabsize_arg(&cts);
 
   // Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.
   int width = wp->w_width_inner - win_col_off(wp);
@@ -223,7 +227,7 @@ int plines_m_win(win_T *wp, linenr_T first, linenr_T last)
 /// @param col
 ///
 /// @return Number of characters.
-int win_chartabsize(win_T *wp, char_u *p, colnr_T col)
+int win_chartabsize(win_T *wp, char *p, colnr_T col)
 {
   buf_T *buf = wp->w_buffer;
   if (*p == TAB && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
@@ -241,24 +245,24 @@ int win_chartabsize(win_T *wp, char_u *p, colnr_T col)
 /// @return Number of characters the string will take on the screen.
 int linetabsize(char_u *s)
 {
-  return linetabsize_col(0, s);
+  return linetabsize_col(0, (char *)s);
 }
 
-/// Like linetabsize(), but starting at column "startcol".
+/// Like linetabsize(), but "s" starts at column "startcol".
 ///
 /// @param startcol
 /// @param s
 ///
 /// @return Number of characters the string will take on the screen.
-int linetabsize_col(int startcol, char_u *s)
+int linetabsize_col(int startcol, char *s)
 {
-  colnr_T col = startcol;
-  char_u *line = s;  // pointer to start of line, for breakindent
-
-  while (*s != NUL) {
-    col += lbr_chartabsize_adv(line, &s, col);
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, curwin, 0, startcol, (char_u *)s, (char_u *)s);
+  while (*cts.cts_ptr != NUL) {
+    cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
-  return (int)col;
+  clear_chartabsize_arg(&cts);
+  return (int)cts.cts_vcol;
 }
 
 /// Like linetabsize(), but for a given window instead of the current one.
@@ -268,19 +272,39 @@ int linetabsize_col(int startcol, char_u *s)
 /// @param len
 ///
 /// @return Number of characters the string will take on the screen.
-unsigned int win_linetabsize(win_T *wp, char_u *line, colnr_T len)
+unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len)
 {
-  colnr_T col = 0;
-
-  for (char_u *s = line;
-       *s != NUL && (len == MAXCOL || s < line + len);
-       MB_PTR_ADV(s)) {
-    col += win_lbr_chartabsize(wp, line, s, col, NULL);
+  chartabsize_T cts;
+  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  for (; *cts.cts_ptr != NUL && (len == MAXCOL || cts.cts_ptr < (char *)line + len);
+       MB_PTR_ADV(cts.cts_ptr)) {
+    cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
   }
+  clear_chartabsize_arg(&cts);
+  return (unsigned int)cts.cts_vcol;
+}
 
-  return (unsigned int)col;
+/// Prepare the structure passed to chartabsize functions.
+///
+/// "line" is the start of the line, "ptr" is the first relevant character.
+/// When "lnum" is zero do not use text properties that insert text.
+void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char_u *line,
+                          char_u *ptr)
+{
+  cts->cts_win = wp;
+  cts->cts_lnum = lnum;
+  cts->cts_vcol = col;
+  cts->cts_line = (char *)line;
+  cts->cts_ptr = (char *)ptr;
+  cts->cts_cur_text_width = 0;
+  // TODO(bfredl): actually lookup inline virtual text here
+  cts->cts_has_virt_text = false;
 }
 
+/// Free any allocated item in "cts".
+void clear_chartabsize_arg(chartabsize_T *cts)
+{}
+
 /// like win_chartabsize(), but also check for line breaks on the screen
 ///
 /// @param line
@@ -288,16 +312,16 @@ unsigned int win_linetabsize(win_T *wp, char_u *line, colnr_T len)
 /// @param col
 ///
 /// @return The number of characters taken up on the screen.
-int lbr_chartabsize(char_u *line, unsigned char *s, colnr_T col)
+int lbr_chartabsize(chartabsize_T *cts)
 {
   if (!curwin->w_p_lbr && *get_showbreak_value(curwin) == NUL
-      && !curwin->w_p_bri) {
+      && !curwin->w_p_bri && !cts->cts_has_virt_text) {
     if (curwin->w_p_wrap) {
-      return win_nolbr_chartabsize(curwin, s, col, NULL);
+      return win_nolbr_chartabsize(cts, NULL);
     }
-    return win_chartabsize(curwin, s, col);
+    return win_chartabsize(curwin, cts->cts_ptr, cts->cts_vcol);
   }
-  return win_lbr_chartabsize(curwin, line == NULL ? s: line, s, col, NULL);
+  return win_lbr_chartabsize(cts, NULL);
 }
 
 /// Call lbr_chartabsize() and advance the pointer.
@@ -307,12 +331,12 @@ int lbr_chartabsize(char_u *line, unsigned char *s, colnr_T col)
 /// @param col
 ///
 /// @return The number of characters take up on the screen.
-int lbr_chartabsize_adv(char_u *line, char_u **s, colnr_T col)
+int lbr_chartabsize_adv(chartabsize_T *cts)
 {
   int retval;
 
-  retval = lbr_chartabsize(line, *s, col);
-  MB_PTR_ADV(*s);
+  retval = lbr_chartabsize(cts);
+  MB_PTR_ADV(cts->cts_ptr);
   return retval;
 }
 
@@ -322,17 +346,19 @@ int lbr_chartabsize_adv(char_u *line, char_u **s, colnr_T col)
 /// string at start of line.  Warning: *headp is only set if it's a non-zero
 /// value, init to 0 before calling.
 ///
-/// @param wp
-/// @param line
-/// @param s
-/// @param col
+/// @param cts
 /// @param headp
 ///
 /// @return The number of characters taken up on the screen.
-int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *headp)
+int win_lbr_chartabsize(chartabsize_T *cts, int *headp)
 {
+  win_T *wp = cts->cts_win;
+  char *line = cts->cts_line;  // start of the line
+  char_u *s = (char_u *)cts->cts_ptr;
+  colnr_T vcol = cts->cts_vcol;
+
   colnr_T col2;
-  colnr_T col_adj = 0;  // col + screen size of tab
+  colnr_T col_adj = 0;  // vcol + screen size of tab
   colnr_T colmax;
   int added;
   int mb_added = 0;
@@ -340,16 +366,23 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
   char_u *ps;
   int n;
 
+  cts->cts_cur_text_width = 0;
+
   // No 'linebreak', 'showbreak' and 'breakindent': return quickly.
-  if (!wp->w_p_lbr && !wp->w_p_bri && *get_showbreak_value(wp) == NUL) {
+  if (!wp->w_p_lbr && !wp->w_p_bri && *get_showbreak_value(wp) == NUL
+      && !cts->cts_has_virt_text) {
     if (wp->w_p_wrap) {
-      return win_nolbr_chartabsize(wp, s, col, headp);
+      return win_nolbr_chartabsize(cts, headp);
     }
-    return win_chartabsize(wp, s, col);
+    return win_chartabsize(wp, (char *)s, vcol);
+  }
+
+  // First get normal size, without 'linebreak' or virtual text
+  int size = win_chartabsize(wp, (char *)s, vcol);
+  if (cts->cts_has_virt_text) {
+    // TODO(bfredl): inline virtual text
   }
 
-  // First get normal size, without 'linebreak'
-  int size = win_chartabsize(wp, s, col);
   int c = *s;
   if (*s == TAB) {
     col_adj = size - 1;
@@ -365,15 +398,15 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
     // Count all characters from first non-blank after a blank up to next
     // non-blank after a blank.
     numberextra = win_col_off(wp);
-    col2 = col;
+    col2 = vcol;
     colmax = (colnr_T)(wp->w_width_inner - numberextra - col_adj);
 
-    if (col >= colmax) {
+    if (vcol >= colmax) {
       colmax += col_adj;
       n = colmax + win_col_off2(wp);
 
       if (n > 0) {
-        colmax += (((col - colmax) / n) + 1) * n - col_adj;
+        colmax += (((vcol - colmax) / n) + 1) * n - col_adj;
       }
     }
 
@@ -383,21 +416,21 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
       c = *s;
 
       if (!(c != NUL
-            && (vim_isbreak(c) || col2 == col || !vim_isbreak((int)(*ps))))) {
+            && (vim_isbreak(c) || col2 == vcol || !vim_isbreak((int)(*ps))))) {
         break;
       }
 
-      col2 += win_chartabsize(wp, s, col2);
+      col2 += win_chartabsize(wp, (char *)s, col2);
 
       if (col2 >= colmax) {  // doesn't fit
-        size = colmax - col + col_adj;
+        size = colmax - vcol + col_adj;
         break;
       }
     }
   } else if ((size == 2)
              && (MB_BYTE2LEN(*s) > 1)
              && wp->w_p_wrap
-             && in_win_border(wp, col)) {
+             && in_win_border(wp, vcol)) {
     // Count the ">" in the last column.
     size++;
     mb_added = 1;
@@ -409,40 +442,40 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
   added = 0;
 
   char *const sbr = (char *)get_showbreak_value(wp);
-  if ((*sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && col != 0) {
+  if ((*sbr != NUL || wp->w_p_bri) && wp->w_p_wrap && vcol != 0) {
     colnr_T sbrlen = 0;
     int numberwidth = win_col_off(wp);
 
     numberextra = numberwidth;
-    col += numberextra + mb_added;
+    vcol += numberextra + mb_added;
 
-    if (col >= (colnr_T)wp->w_width_inner) {
-      col -= wp->w_width_inner;
+    if (vcol >= (colnr_T)wp->w_width_inner) {
+      vcol -= wp->w_width_inner;
       numberextra = wp->w_width_inner - (numberextra - win_col_off2(wp));
-      if (col >= numberextra && numberextra > 0) {
-        col %= numberextra;
+      if (vcol >= numberextra && numberextra > 0) {
+        vcol %= numberextra;
       }
       if (*sbr != NUL) {
         sbrlen = (colnr_T)mb_charlen((char_u *)sbr);
-        if (col >= sbrlen) {
-          col -= sbrlen;
+        if (vcol >= sbrlen) {
+          vcol -= sbrlen;
         }
       }
-      if (col >= numberextra && numberextra > 0) {
-        col %= numberextra;
-      } else if (col > 0 && numberextra > 0) {
-        col += numberwidth - win_col_off2(wp);
+      if (vcol >= numberextra && numberextra > 0) {
+        vcol %= numberextra;
+      } else if (vcol > 0 && numberextra > 0) {
+        vcol += numberwidth - win_col_off2(wp);
       }
 
       numberwidth -= win_col_off2(wp);
     }
 
-    if (col == 0 || (col + size + sbrlen > (colnr_T)wp->w_width_inner)) {
+    if (vcol == 0 || (vcol + size + sbrlen > (colnr_T)wp->w_width_inner)) {
       if (*sbr != NUL) {
         if (size + sbrlen + numberwidth > (colnr_T)wp->w_width_inner) {
           // Calculate effective window width.
           int width = (colnr_T)wp->w_width_inner - sbrlen - numberwidth;
-          int prev_width = col ? ((colnr_T)wp->w_width_inner - (sbrlen + col))
+          int prev_width = vcol ? ((colnr_T)wp->w_width_inner - (sbrlen + vcol))
                                : 0;
 
           if (width <= 0) {
@@ -459,11 +492,11 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
       }
 
       if (wp->w_p_bri) {
-        added += get_breakindent_win(wp, line);
+        added += get_breakindent_win(wp, (char_u *)line);
       }
 
       size += added;
-      if (col != 0) {
+      if (vcol != 0) {
         added = 0;
       }
     }
@@ -485,8 +518,11 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
 /// @param headp
 ///
 /// @return The number of characters take up on the screen.
-static int win_nolbr_chartabsize(win_T *wp, char_u *s, colnr_T col, int *headp)
+static int win_nolbr_chartabsize(chartabsize_T *cts, int *headp)
 {
+  win_T *wp = cts->cts_win;
+  char *s = cts->cts_ptr;
+  colnr_T col = cts->cts_vcol;
   int n;
 
   if ((*s == TAB) && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
@@ -498,7 +534,7 @@ static int win_nolbr_chartabsize(win_T *wp, char_u *s, colnr_T col, int *headp)
 
   // Add one cell for a double-width character in the last column of the
   // window, displayed with a ">".
-  if ((n == 2) && (MB_BYTE2LEN(*s) > 1) && in_win_border(wp, col)) {
+  if ((n == 2) && (MB_BYTE2LEN((uint8_t)(*s)) > 1) && in_win_border(wp, col)) {
     if (headp != NULL) {
       *headp = 1;
     }
diff --git a/src/nvim/plines.h b/src/nvim/plines.h
index 32778b69f1..7b228f3e91 100644
--- a/src/nvim/plines.h
+++ b/src/nvim/plines.h
@@ -3,6 +3,20 @@
 
 #include "nvim/vim.h"
 
+// Argument for lbr_chartabsize().
+typedef struct {
+  win_T *cts_win;
+  linenr_T cts_lnum;   // zero when not using text properties
+  char *cts_line;    // start of the line
+  char *cts_ptr;     // current position in line
+
+  bool cts_has_virt_text;  // true if if a property inserts text
+  int cts_cur_text_width;     // width of current inserted text
+  // TODO(bfredl): iterator in to the marktree for scanning virt text
+
+  int cts_vcol;    // virtual column at current position
+} chartabsize_T;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "plines.h.generated.h"
 #endif
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index b7ec4bf94e..75bd7b4cc1 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1165,7 +1165,7 @@ static bool reg_match_visual(void)
     rex.line = reg_getline(rex.lnum);
     rex.input = rex.line + col;
 
-    unsigned int cols_u = win_linetabsize(wp, rex.line, col);
+    unsigned int cols_u = win_linetabsize(wp, rex.reg_firstlnum + rex.lnum, rex.line, col);
     assert(cols_u <= MAXCOL);
     colnr_T cols = (colnr_T)cols_u;
     if (cols < start || cols > end - (*p_sel == 'e')) {
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index d7a4f40ecf..88f0d781af 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -3764,6 +3764,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
         case RE_VCOL:
           if (!re_num_cmp(win_linetabsize(rex.reg_win == NULL
                                           ? curwin : rex.reg_win,
+                                          rex.reg_firstlnum + rex.lnum,
                                           rex.line,
                                           (colnr_T)(rex.input - rex.line)) + 1,
                           scan)) {
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index 554def5b8a..d4db710d93 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -6910,7 +6910,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *subm
           result = col > t->state->val * ts;
         }
         if (!result) {
-          uintmax_t lts = win_linetabsize(wp, rex.line, col);
+          uintmax_t lts = win_linetabsize(wp, rex.reg_firstlnum + rex.lnum, rex.line, col);
           assert(t->state->val >= 0);
           result = nfa_re_num_cmp((uintmax_t)t->state->val, op, lts + 1);
         }
-- 
cgit 


From 92bc11a891538e5c306915bffef437f097572d09 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 29 Aug 2022 20:22:15 +0800
Subject: vim-patch:9.0.0316: screen flickers when 'cmdheight' is zero (#19991)

Problem:    Screen flickers when 'cmdheight' is zero.
Solution:   Redraw over existing text instead of clearing.
https://github.com/vim/vim/commit/f73e5ba56f4aca1cd6e38f1c8ea24e941bf6b33f
---
 src/nvim/drawscreen.c | 50 ++++++++++++++++++++++++++------------------------
 src/nvim/ex_getln.c   |  2 +-
 2 files changed, 27 insertions(+), 25 deletions(-)

(limited to 'src')

diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index cf8178a30f..a601a82495 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -469,35 +469,37 @@ int update_screen(int type)
       }
       msg_grid_set_pos(Rows - (int)p_ch, false);
       msg_grid_invalid = false;
-    } else if (msg_scrolled > Rows - 5) {  // clearing is faster
-      type = UPD_CLEAR;
     } else if (type != UPD_CLEAR) {
-      check_for_delay(false);
-      grid_ins_lines(&default_grid, 0, msg_scrolled, Rows, 0, Columns);
-      FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-        if (wp->w_floating) {
-          continue;
-        }
-        if (wp->w_winrow < msg_scrolled) {
-          if (W_ENDROW(wp) > msg_scrolled
-              && wp->w_redr_type < UPD_REDRAW_TOP
-              && wp->w_lines_valid > 0
-              && wp->w_topline == wp->w_lines[0].wl_lnum) {
-            wp->w_upd_rows = msg_scrolled - wp->w_winrow;
-            wp->w_redr_type = UPD_REDRAW_TOP;
-          } else {
-            wp->w_redr_type = UPD_NOT_VALID;
-            if (wp->w_winrow + wp->w_winbar_height <= msg_scrolled) {
-              wp->w_redr_status = true;
+      if (msg_scrolled > Rows - 5) {  // redrawing is faster
+        type = UPD_NOT_VALID;
+      } else {
+        check_for_delay(false);
+        grid_ins_lines(&default_grid, 0, msg_scrolled, Rows, 0, Columns);
+        FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
+          if (wp->w_floating) {
+            continue;
+          }
+          if (wp->w_winrow < msg_scrolled) {
+            if (W_ENDROW(wp) > msg_scrolled
+                && wp->w_redr_type < UPD_REDRAW_TOP
+                && wp->w_lines_valid > 0
+                && wp->w_topline == wp->w_lines[0].wl_lnum) {
+              wp->w_upd_rows = msg_scrolled - wp->w_winrow;
+              wp->w_redr_type = UPD_REDRAW_TOP;
+            } else {
+              wp->w_redr_type = UPD_NOT_VALID;
+              if (wp->w_winrow + wp->w_winbar_height <= msg_scrolled) {
+                wp->w_redr_status = true;
+              }
             }
           }
         }
+        if (is_stl_global && Rows - p_ch - 1 <= msg_scrolled) {
+          curwin->w_redr_status = true;
+        }
+        redraw_cmdline = true;
+        redraw_tabline = true;
       }
-      if (is_stl_global && Rows - p_ch - 1 <= msg_scrolled) {
-        curwin->w_redr_status = true;
-      }
-      redraw_cmdline = true;
-      redraw_tabline = true;
     }
     msg_scrolled = 0;
     msg_scrolled_at_flush = 0;
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 3d991996d6..0cca4b69e8 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -918,7 +918,7 @@ theend:
     // Restore cmdheight
     set_option_value("ch", 0L, NULL, 0);
     // Redraw is needed for command line completion
-    redraw_all_later(UPD_CLEAR);
+    redraw_all_later(UPD_NOT_VALID);
 
     made_cmdheight_nonzero = false;
   }
-- 
cgit 


From 58f30a326f34319801e7921f32c83e8320d85f6c Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/arglist.c         |   2 +-
 src/nvim/buffer.c          |   2 +-
 src/nvim/buffer_defs.h     |   6 +-
 src/nvim/change.c          | 140 ++++++++++++++++++++++-----------------------
 src/nvim/charset.c         |  18 +++---
 src/nvim/cmdexpand.c       |   9 ++-
 src/nvim/debugger.c        |  10 ++--
 src/nvim/diff.c            |  78 ++++++++++++-------------
 src/nvim/drawline.c        |  10 ++--
 src/nvim/drawscreen.c      |   2 +-
 src/nvim/edit.c            |  40 ++++++-------
 src/nvim/eval.c            |   2 +-
 src/nvim/eval/funcs.c      |  24 ++++----
 src/nvim/eval/userfunc.c   |   4 +-
 src/nvim/eval/vars.c       |   2 +-
 src/nvim/ex_cmds.c         |  14 ++---
 src/nvim/ex_docmd.c        |  14 ++---
 src/nvim/ex_eval.c         |   6 +-
 src/nvim/ex_getln.c        |   2 +-
 src/nvim/fileio.c          |   4 +-
 src/nvim/getchar.c         |   2 +-
 src/nvim/grid.c            |  25 ++++----
 src/nvim/hardcopy.c        |  21 +++----
 src/nvim/help.c            |   4 +-
 src/nvim/highlight_group.c |   2 +-
 src/nvim/if_cscope.c       |   8 +--
 src/nvim/indent.c          |  10 ++--
 src/nvim/indent_c.c        |  14 ++---
 src/nvim/insexpand.c       |   4 +-
 src/nvim/log.c             |   2 +-
 src/nvim/lua/stdlib.c      |   4 +-
 src/nvim/mapping.c         |   4 +-
 src/nvim/mark.c            |   6 +-
 src/nvim/match.c           |   4 +-
 src/nvim/mbyte.c           |  48 +++++++---------
 src/nvim/memline.c         |  12 ++--
 src/nvim/message.c         |  16 +++---
 src/nvim/normal.c          |  26 ++++-----
 src/nvim/ops.c             |  16 +++---
 src/nvim/option.c          |   2 +-
 src/nvim/os/env.c          |   4 +-
 src/nvim/os/fs.c           |   2 +-
 src/nvim/path.c            |  24 ++++----
 src/nvim/plines.c          |   2 +-
 src/nvim/popupmenu.c       |   9 ++-
 src/nvim/quickfix.c        |  12 ++--
 src/nvim/regexp.c          |  10 ++--
 src/nvim/runtime.c         |  30 ++++++----
 src/nvim/screen.c          |  14 ++---
 src/nvim/search.c          |  29 +++++-----
 src/nvim/shada.c           |   2 +-
 src/nvim/spellfile.c       |  88 ++++++++++++++--------------
 src/nvim/statusline.c      |  15 +++--
 src/nvim/strings.c         |   4 +-
 src/nvim/syntax.c          |  20 +++----
 src/nvim/tag.c             |  33 ++++++-----
 src/nvim/textformat.c      |   6 +-
 src/nvim/usercmd.c         |  24 ++++----
 src/nvim/usercmd.h         |   6 +-
 src/nvim/version.c         |  13 ++---
 src/nvim/window.c          |  12 ++--
 61 files changed, 479 insertions(+), 499 deletions(-)

(limited to 'src')

diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 21aa5afbae..70b2e71949 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -202,7 +202,7 @@ static char *do_one_arg(char *str)
   for (p = str; *str; str++) {
     // When the backslash is used for escaping the special meaning of a
     // character we need to keep it until wildcard expansion.
-    if (rem_backslash((char_u *)str)) {
+    if (rem_backslash(str)) {
       *p++ = *str++;
       *p++ = *str;
     } else {
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 5dc7083a01..514be4c56b 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -2701,7 +2701,7 @@ void buflist_list(exarg_T *eap)
       home_replace(buf, buf->b_fname, (char *)NameBuff, MAXPATHL, true);
     }
 
-    if (message_filtered((char_u *)NameBuff)) {
+    if (message_filtered(NameBuff)) {
       continue;
     }
 
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 319c2addba..c1ac20fd98 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -325,7 +325,7 @@ typedef struct argentry {
  * Used for the typeahead buffer: typebuf.
  */
 typedef struct {
-  char_u *tb_buf;          // buffer for typed characters
+  uint8_t *tb_buf;              // buffer for typed characters
   uint8_t *tb_noremap;          // mapping flags for characters in tb_buf[]
   int tb_buflen;                // size of tb_buf[]
   int tb_off;                   // current position in tb_buf[]
@@ -353,7 +353,7 @@ typedef struct {
 typedef struct mapblock mapblock_T;
 struct mapblock {
   mapblock_T *m_next;           // next mapblock in list
-  char_u *m_keys;               // mapped from, lhs
+  uint8_t *m_keys;              // mapped from, lhs
   char *m_str;                  // mapped to, rhs
   char *m_orig_str;             // rhs as entered by the user
   LuaRef m_luaref;              // lua function reference as rhs
@@ -703,7 +703,7 @@ struct file_buffer {
   char *b_p_cms;                ///< 'commentstring'
   char *b_p_cpt;                ///< 'complete'
 #ifdef BACKSLASH_IN_FILENAME
-  char_u *b_p_csl;              ///< 'completeslash'
+  char *b_p_csl;                ///< 'completeslash'
 #endif
   char *b_p_cfu;                ///< 'completefunc'
   char *b_p_ofu;                ///< 'omnifunc'
diff --git a/src/nvim/change.c b/src/nvim/change.c
index 074700f4df..fd079f8eef 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -589,17 +589,17 @@ bool file_ff_differs(buf_T *buf, bool ignore_empty)
 /// Handles Replace mode and multi-byte characters.
 void ins_bytes(char *p)
 {
-  ins_bytes_len((char_u *)p, STRLEN(p));
+  ins_bytes_len(p, STRLEN(p));
 }
 
 /// Insert string "p" with length "len" at the cursor position.
 /// Handles Replace mode and multi-byte characters.
-void ins_bytes_len(char_u *p, size_t len)
+void ins_bytes_len(char *p, size_t len)
 {
   size_t n;
   for (size_t i = 0; i < len; i += n) {
     // avoid reading past p[len]
-    n = (size_t)utfc_ptr2len_len(p + i, (int)(len - i));
+    n = (size_t)utfc_ptr2len_len((char_u *)p + i, (int)(len - i));
     ins_char_bytes(p + i, n);
   }
 }
@@ -611,18 +611,18 @@ void ins_bytes_len(char_u *p, size_t len)
 /// convert bytes to a character.
 void ins_char(int c)
 {
-  char_u buf[MB_MAXBYTES + 1];
-  size_t n = (size_t)utf_char2bytes(c, (char *)buf);
+  char buf[MB_MAXBYTES + 1];
+  size_t n = (size_t)utf_char2bytes(c, buf);
 
   // When "c" is 0x100, 0x200, etc. we don't want to insert a NUL byte.
   // Happens for CTRL-Vu9900.
   if (buf[0] == 0) {
     buf[0] = '\n';
   }
-  ins_char_bytes((char_u *)buf, n);
+  ins_char_bytes(buf, n);
 }
 
-void ins_char_bytes(char_u *buf, size_t charlen)
+void ins_char_bytes(char *buf, size_t charlen)
 {
   // Break tabs if needed.
   if (virtual_active() && curwin->w_cursor.coladd > 0) {
@@ -631,7 +631,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
 
   size_t col = (size_t)curwin->w_cursor.col;
   linenr_T lnum = curwin->w_cursor.lnum;
-  char_u *oldp = ml_get(lnum);
+  char *oldp = (char *)ml_get(lnum);
   size_t linelen = STRLEN(oldp) + 1;  // length of old line including NUL
 
   // The lengths default to the values for when not replacing.
@@ -661,7 +661,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
         if (vcol > new_vcol && oldp[col + oldlen] == TAB) {
           break;
         }
-        oldlen += (size_t)utfc_ptr2len((char *)oldp + col + oldlen);
+        oldlen += (size_t)utfc_ptr2len(oldp + col + oldlen);
         // Deleted a bit too much, insert spaces.
         if (vcol > new_vcol) {
           newlen += (size_t)(vcol - new_vcol);
@@ -670,7 +670,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
       curwin->w_p_list = old_list;
     } else if (oldp[col] != NUL) {
       // normal replace
-      oldlen = (size_t)utfc_ptr2len((char *)oldp + col);
+      oldlen = (size_t)utfc_ptr2len(oldp + col);
     }
 
     // Push the replaced bytes onto the replace stack, so that they can be
@@ -683,7 +683,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
     }
   }
 
-  char_u *newp = xmalloc(linelen + newlen - oldlen);
+  char *newp = xmalloc(linelen + newlen - oldlen);
 
   // Copy bytes before the cursor.
   if (col > 0) {
@@ -691,7 +691,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
   }
 
   // Copy bytes after the changed character(s).
-  char_u *p = newp + col;
+  char *p = newp + col;
   if (linelen > col + oldlen) {
     memmove(p + newlen, oldp + col + oldlen,
             (size_t)(linelen - col - oldlen));
@@ -706,7 +706,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
   }
 
   // Replace the line in the buffer.
-  ml_replace(lnum, (char *)newp, false);
+  ml_replace(lnum, newp, false);
 
   // mark the buffer as changed and prepare for displaying
   inserted_bytes(lnum, (colnr_T)col, (int)oldlen, (int)newlen);
@@ -716,7 +716,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
   if (p_sm && (State & MODE_INSERT)
       && msg_silent == 0
       && !ins_compl_active()) {
-    showmatch(utf_ptr2char((char *)buf));
+    showmatch(utf_ptr2char(buf));
   }
 
   if (!p_ri || (State & REPLACE_FLAG)) {
@@ -729,7 +729,7 @@ void ins_char_bytes(char_u *buf, size_t charlen)
 /// Insert a string at the cursor position.
 /// Note: Does NOT handle Replace mode.
 /// Caller must have prepared for undo.
-void ins_str(char_u *s)
+void ins_str(char *s)
 {
   int newlen = (int)STRLEN(s);
   linenr_T lnum = curwin->w_cursor.lnum;
@@ -739,10 +739,10 @@ void ins_str(char_u *s)
   }
 
   colnr_T col = curwin->w_cursor.col;
-  char_u *oldp = ml_get(lnum);
+  char *oldp = (char *)ml_get(lnum);
   int oldlen = (int)STRLEN(oldp);
 
-  char_u *newp = (char_u *)xmalloc((size_t)oldlen + (size_t)newlen + 1);
+  char *newp = xmalloc((size_t)oldlen + (size_t)newlen + 1);
   if (col > 0) {
     memmove(newp, oldp, (size_t)col);
   }
@@ -750,7 +750,7 @@ void ins_str(char_u *s)
   int bytes = oldlen - col + 1;
   assert(bytes >= 0);
   memmove(newp + col + newlen, oldp + col, (size_t)bytes);
-  ml_replace(lnum, (char *)newp, false);
+  ml_replace(lnum, newp, false);
   inserted_bytes(lnum, col, 0, newlen);
   curwin->w_cursor.col += newlen;
 }
@@ -774,9 +774,9 @@ int del_char(bool fixpos)
 int del_chars(long count, int fixpos)
 {
   int bytes = 0;
-  char_u *p = get_cursor_pos_ptr();
+  char *p = (char *)get_cursor_pos_ptr();
   for (long i = 0; i < count && *p != NUL; i++) {
-    int l = utfc_ptr2len((char *)p);
+    int l = utfc_ptr2len(p);
     bytes += l;
     p += l;
   }
@@ -797,7 +797,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   linenr_T lnum = curwin->w_cursor.lnum;
   colnr_T col = curwin->w_cursor.col;
   bool fixpos = fixpos_arg;
-  char_u *oldp = ml_get(lnum);
+  char *oldp = (char *)ml_get(lnum);
   colnr_T oldlen = (colnr_T)STRLEN(oldp);
 
   // Can't do anything when the cursor is on the NUL after the line.
@@ -817,7 +817,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   // If 'delcombine' is set and deleting (less than) one character, only
   // delete the last combining character.
   if (p_deco && use_delcombine
-      && utfc_ptr2len((char *)oldp + col) >= count) {
+      && utfc_ptr2len(oldp + col) >= count) {
     int cc[MAX_MCO];
 
     (void)utfc_ptr2char(oldp + col, cc);
@@ -826,9 +826,9 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
       int n = col;
       do {
         col = n;
-        count = utf_ptr2len((char *)oldp + n);
+        count = utf_ptr2len(oldp + n);
         n += count;
-      } while (utf_composinglike(oldp + col, oldp + n));
+      } while (utf_composinglike((char_u *)oldp + col, (char_u *)oldp + n));
       fixpos = false;
     }
   }
@@ -843,7 +843,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
         && (get_ve_flags() & VE_ONEMORE) == 0) {
       curwin->w_cursor.col--;
       curwin->w_cursor.coladd = 0;
-      curwin->w_cursor.col -= utf_head_off(oldp, oldp + curwin->w_cursor.col);
+      curwin->w_cursor.col -= utf_head_off((char_u *)oldp, (char_u *)oldp + curwin->w_cursor.col);
     }
     count = oldlen - col;
     movelen = 1;
@@ -852,7 +852,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   // If the old line has been allocated the deletion can be done in the
   // existing line. Otherwise a new line has to be allocated.
   bool was_alloced = ml_line_alloced();     // check if oldp was allocated
-  char_u *newp;
+  char *newp;
   if (was_alloced) {
     ml_add_deleted_len(curbuf->b_ml.ml_line_ptr, oldlen);
     newp = oldp;                            // use same allocated memory
@@ -862,7 +862,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   }
   memmove(newp + col, oldp + col + count, (size_t)movelen);
   if (!was_alloced) {
-    ml_replace(lnum, (char *)newp, false);
+    ml_replace(lnum, newp, false);
   }
 
   // mark the buffer as changed and prepare for displaying
@@ -874,10 +874,10 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
 /// Copy the indent from ptr to the current line (and fill to size).
 /// Leaves the cursor on the first non-blank in the line.
 /// @return true if the line was changed.
-int copy_indent(int size, char_u *src)
+int copy_indent(int size, char *src)
 {
-  char_u *p = NULL;
-  char_u *line = NULL;
+  char *p = NULL;
+  char *line = NULL;
   int ind_len;
   int line_len = 0;
   int tab_pad;
@@ -889,7 +889,7 @@ int copy_indent(int size, char_u *src)
     ind_len = 0;
     int ind_done = 0;
     int ind_col = 0;
-    char_u *s = src;
+    char *s = src;
 
     // Count/copy the usable portion of the source line.
     while (todo > 0 && ascii_iswhite(*s)) {
@@ -975,7 +975,7 @@ int copy_indent(int size, char_u *src)
   memmove(p, get_cursor_line_ptr(), (size_t)line_len);
 
   // Replace the line
-  ml_replace(curwin->w_cursor.lnum, (char *)line, false);
+  ml_replace(curwin->w_cursor.lnum, line, false);
 
   // Put the cursor after the indent.
   curwin->w_cursor.col = ind_len;
@@ -1006,8 +1006,8 @@ int copy_indent(int size, char_u *src)
 /// @return true on success, false on failure
 int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
 {
-  char_u *next_line = NULL;       // copy of the next line
-  char_u *p_extra = NULL;         // what goes to next line
+  char *next_line = NULL;         // copy of the next line
+  char *p_extra = NULL;           // what goes to next line
   colnr_T less_cols = 0;          // less columns for mark in new line
   colnr_T less_cols_off = 0;      // columns to skip for mark adjust
   pos_T old_cursor;               // old cursor position
@@ -1020,9 +1020,9 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   int comment_start = 0;          // start index of the comment leader
   char *lead_flags;               // position in 'comments' for comment leader
   char *leader = NULL;            // copy of comment leader
-  char_u *allocated = NULL;       // allocated memory
+  char *allocated = NULL;         // allocated memory
   char *p;
-  char_u saved_char = NUL;        // init for GCC
+  char saved_char = NUL;          // init for GCC
   pos_T *pos;
   bool do_si = may_do_si();
   bool do_cindent;
@@ -1036,7 +1036,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   colnr_T mincol = curwin->w_cursor.col + 1;
 
   // make a copy of the current line so we can mess with it
-  char_u *saved_line = vim_strsave(get_cursor_line_ptr());
+  char *saved_line = (char *)vim_strsave(get_cursor_line_ptr());
 
   if (State & VREPLACE_FLAG) {
     // With MODE_VREPLACE we make a copy of the next line, which we will be
@@ -1047,9 +1047,9 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     // the line, replacing what was there before and pushing the right
     // stuff onto the replace stack.  -- webb.
     if (curwin->w_cursor.lnum < orig_line_count) {
-      next_line = vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
+      next_line = (char *)vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
     } else {
-      next_line = vim_strsave((char_u *)"");
+      next_line = xstrdup("");
     }
 
     // In MODE_VREPLACE state, a NL replaces the rest of the line, and
@@ -1059,9 +1059,9 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     // autoindent etc) a bit later.
     replace_push(NUL);      // Call twice because BS over NL expects it
     replace_push(NUL);
-    p = (char *)saved_line + curwin->w_cursor.col;
+    p = saved_line + curwin->w_cursor.col;
     while (*p != NUL) {
-      p += replace_push_mb((char_u *)p);
+      p += replace_push_mb(p);
     }
     saved_line[curwin->w_cursor.col] = NUL;
   }
@@ -1069,7 +1069,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   if ((State & MODE_INSERT) && (State & VREPLACE_FLAG) == 0) {
     p_extra = saved_line + curwin->w_cursor.col;
     if (do_si) {  // need first char after new line break
-      p = skipwhite((char *)p_extra);
+      p = skipwhite(p_extra);
       first_char = (unsigned char)(*p);
     }
     extra_len = (int)STRLEN(p_extra);
@@ -1109,7 +1109,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
       char *ptr;
 
       old_cursor = curwin->w_cursor;
-      ptr = (char *)saved_line;
+      ptr = saved_line;
       if (flags & OPENLINE_DO_COM) {
         lead_len = get_leader_len(ptr, NULL, false, true);
       } else {
@@ -1193,7 +1193,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
             // Don't do this if the previous line ended in ';' or
             // '}'.
           } else if (last_char != ';' && last_char != '}'
-                     && cin_is_cinword((char_u *)ptr)) {
+                     && cin_is_cinword(ptr)) {
             did_si = true;
           }
         }
@@ -1243,13 +1243,13 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   // This may then be inserted in front of the new line.
   end_comment_pending = NUL;
   if (flags & OPENLINE_DO_COM) {
-    lead_len = get_leader_len((char *)saved_line, &lead_flags, dir == BACKWARD, true);
+    lead_len = get_leader_len(saved_line, &lead_flags, dir == BACKWARD, true);
     if (lead_len == 0 && curbuf->b_p_cin && do_cindent && dir == FORWARD
         && (!has_format_option(FO_NO_OPEN_COMS) || (flags & OPENLINE_FORMAT))) {
       // Check for a line comment after code.
       comment_start = check_linecomment(saved_line);
       if (comment_start != MAXCOL) {
-        lead_len = get_leader_len((char *)saved_line + comment_start, &lead_flags, false, true);
+        lead_len = get_leader_len(saved_line + comment_start, &lead_flags, false, true);
         if (lead_len != 0) {
           lead_len += comment_start;
           if (did_do_comment != NULL) {
@@ -1264,13 +1264,13 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   if (lead_len > 0) {
     char *lead_repl = NULL;                 // replaces comment leader
     int lead_repl_len = 0;                  // length of *lead_repl
-    char_u lead_middle[COM_MAX_LEN];        // middle-comment string
-    char_u lead_end[COM_MAX_LEN];           // end-comment string
-    char_u *comment_end = NULL;             // where lead_end has been found
+    char lead_middle[COM_MAX_LEN];          // middle-comment string
+    char lead_end[COM_MAX_LEN];             // end-comment string
+    char *comment_end = NULL;               // where lead_end has been found
     int extra_space = false;                // append extra space
     int current_flag;
     int require_blank = false;              // requires blank after middle
-    char_u *p2;
+    char *p2;
 
     // If the comment leader has the start, middle or end flag, it may not
     // be used or may be replaced with the middle leader.
@@ -1312,15 +1312,15 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
         size_t n = copy_option_part(&p, (char *)lead_end, COM_MAX_LEN, ",");
 
         if (end_comment_pending == -1) {  // we can set it now
-          end_comment_pending = lead_end[n - 1];
+          end_comment_pending = (unsigned char)lead_end[n - 1];
         }
 
         // If the end of the comment is in the same line, don't use
         // the comment leader.
         if (dir == FORWARD) {
-          for (p = (char *)saved_line + lead_len; *p; p++) {
+          for (p = saved_line + lead_len; *p; p++) {
             if (STRNCMP(p, lead_end, n) == 0) {
-              comment_end = (char_u *)p;
+              comment_end = p;
               lead_len = 0;
               break;
             }
@@ -1353,7 +1353,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
         // Remember where the end is, might want to use it to find the
         // start (for C-comments).
         if (dir == FORWARD) {
-          comment_end = (char_u *)skipwhite((char *)saved_line);
+          comment_end = skipwhite(saved_line);
           lead_len = 0;
           break;
         }
@@ -1372,7 +1372,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
         extra_space = true;
 
         // Check whether we allow automatic ending of comments
-        for (p2 = (char_u *)p; *p2 && *p2 != ':'; p2++) {
+        for (p2 = p; *p2 && *p2 != ':'; p2++) {
           if (*p2 == COM_AUTO_END) {
             end_comment_pending = -1;  // means we want to set it
           }
@@ -1382,7 +1382,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
           while (*p2 && *p2 != ',') {
             p2++;
           }
-          end_comment_pending = p2[-1];
+          end_comment_pending = (unsigned char)p2[-1];
         }
         break;
       }
@@ -1408,7 +1408,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
                   + 1;
       assert(bytes >= 0);
       leader = xmalloc((size_t)bytes);
-      allocated = (char_u *)leader;  // remember to free it later
+      allocated = leader;  // remember to free it later
 
       STRLCPY(leader, saved_line, lead_len + 1);
 
@@ -1442,7 +1442,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
           // Compute the length of the replaced characters in
           // screen characters, not bytes.
           {
-            int repl_size = vim_strnsize((char_u *)lead_repl, lead_repl_len);
+            int repl_size = vim_strnsize(lead_repl, lead_repl_len);
             int old_size = 0;
             char *endp = p;
             int l;
@@ -1487,13 +1487,13 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
           // screen characters, not bytes. Move the part that is
           // not to be overwritten.
           {
-            int repl_size = vim_strnsize((char_u *)lead_repl, lead_repl_len);
+            int repl_size = vim_strnsize(lead_repl, lead_repl_len);
             int i;
             int l;
 
             for (i = 0; i < lead_len && p[i] != NUL; i += l) {
               l = utfc_ptr2len(p + i);
-              if (vim_strnsize((char_u *)p, i + l) > repl_size) {
+              if (vim_strnsize(p, i + l) > repl_size) {
                 break;
               }
             }
@@ -1536,7 +1536,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
 
         // Recompute the indent, it may have changed.
         if (curbuf->b_p_ai || do_si) {
-          newindent = get_indent_str_vtab((char_u *)leader,
+          newindent = get_indent_str_vtab(leader,
                                           curbuf->b_p_ts,
                                           curbuf->b_p_vts_array, false);
         }
@@ -1619,7 +1619,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     }
     if (curbuf->b_p_ai || (flags & OPENLINE_DELSPACES)) {
       while ((*p_extra == ' ' || *p_extra == '\t')
-             && !utf_iscomposing(utf_ptr2char((char *)p_extra + 1))) {
+             && !utf_iscomposing(utf_ptr2char(p_extra + 1))) {
         if (REPLACE_NORMAL(State)) {
           replace_push(*p_extra);
         }
@@ -1633,7 +1633,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   }
 
   if (p_extra == NULL) {
-    p_extra = (char_u *)"";                 // append empty line
+    p_extra = "";                 // append empty line
   }
 
   // concatenate leader and p_extra, if there is a leader
@@ -1653,7 +1653,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
       }
     }
     STRCAT(leader, p_extra);
-    p_extra = (char_u *)leader;
+    p_extra = leader;
     did_ai = true;          // So truncating blanks works with comments
     less_cols -= lead_len;
   } else {
@@ -1666,7 +1666,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     curwin->w_cursor.lnum--;
   }
   if ((State & VREPLACE_FLAG) == 0 || old_cursor.lnum >= orig_line_count) {
-    if (ml_append(curwin->w_cursor.lnum, (char *)p_extra, (colnr_T)0, false) == FAIL) {
+    if (ml_append(curwin->w_cursor.lnum, p_extra, (colnr_T)0, false) == FAIL) {
       goto theend;
     }
     // Postpone calling changed_lines(), because it would mess up folding
@@ -1688,7 +1688,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
       (void)u_save_cursor();  // errors are ignored!
       vr_lines_changed++;
     }
-    ml_replace(curwin->w_cursor.lnum, (char *)p_extra, true);
+    ml_replace(curwin->w_cursor.lnum, p_extra, true);
     changed_bytes(curwin->w_cursor.lnum, 0);
     // TODO(vigoux): extmark_splice_cols here??
     curwin->w_cursor.lnum--;
@@ -1753,7 +1753,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
       if (trunc_line && !(flags & OPENLINE_KEEPTRAIL)) {
         truncate_spaces(saved_line);
       }
-      ml_replace(curwin->w_cursor.lnum, (char *)saved_line, false);
+      ml_replace(curwin->w_cursor.lnum, saved_line, false);
 
       int new_len = (int)STRLEN(saved_line);
 
@@ -1838,15 +1838,15 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   // stuff onto the replace stack (via ins_char()).
   if (State & VREPLACE_FLAG) {
     // Put new line in p_extra
-    p_extra = vim_strsave(get_cursor_line_ptr());
+    p_extra = (char *)vim_strsave(get_cursor_line_ptr());
 
     // Put back original line
-    ml_replace(curwin->w_cursor.lnum, (char *)next_line, false);
+    ml_replace(curwin->w_cursor.lnum, next_line, false);
 
     // Insert new stuff into line again
     curwin->w_cursor.col = 0;
     curwin->w_cursor.coladd = 0;
-    ins_bytes((char *)p_extra);         // will call changed_bytes()
+    ins_bytes(p_extra);         // will call changed_bytes()
     xfree(p_extra);
     next_line = NULL;
   }
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index e0f798121a..2632279565 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -313,7 +313,7 @@ size_t transstr_len(const char *const s, bool untab)
     const size_t l = (size_t)utfc_ptr2len(p);
     if (l > 1) {
       int pcc[MAX_MCO + 1];
-      pcc[0] = utfc_ptr2char((const char_u *)p, &pcc[1]);
+      pcc[0] = utfc_ptr2char(p, &pcc[1]);
 
       if (vim_isprintc(pcc[0])) {
         len += l;
@@ -359,7 +359,7 @@ size_t transstr_buf(const char *const s, char *const buf, const size_t len, bool
         break;  // Exceeded `buf` size.
       }
       int pcc[MAX_MCO + 1];
-      pcc[0] = utfc_ptr2char((const char_u *)p, &pcc[1]);
+      pcc[0] = utfc_ptr2char(p, &pcc[1]);
 
       if (vim_isprintc(pcc[0])) {
         memmove(buf_p, p, l);
@@ -709,7 +709,7 @@ int ptr2cells(const char *p_in)
 /// @return number of character cells.
 int vim_strsize(char *s)
 {
-  return vim_strnsize((char_u *)s, MAXCOL);
+  return vim_strnsize(s, MAXCOL);
 }
 
 /// Return the number of character cells string "s[len]" will take on the
@@ -721,13 +721,13 @@ int vim_strsize(char *s)
 /// @param len
 ///
 /// @return Number of character cells.
-int vim_strnsize(char_u *s, int len)
+int vim_strnsize(char *s, int len)
 {
   assert(s != NULL);
   int size = 0;
   while (*s != NUL && --len >= 0) {
-    int l = utfc_ptr2len((char *)s);
-    size += ptr2cells((char *)s);
+    int l = utfc_ptr2len(s);
+    size += ptr2cells(s);
     s += l;
     len -= l - 1;
   }
@@ -1687,12 +1687,12 @@ int hexhex2nr(const char_u *p)
 /// characters.
 ///
 /// @param  str  file path string to check
-bool rem_backslash(const char_u *str)
+bool rem_backslash(const char *str)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
 #ifdef BACKSLASH_IN_FILENAME
   return str[0] == '\\'
-         && str[1] < 0x80
+         && (uint8_t)str[1] < 0x80
          && (str[1] == ' '
              || (str[1] != NUL
                  && str[1] != '*'
@@ -1710,7 +1710,7 @@ bool rem_backslash(const char_u *str)
 void backslash_halve(char_u *p)
 {
   for (; *p; p++) {
-    if (rem_backslash(p)) {
+    if (rem_backslash((char *)p)) {
       STRMOVE(p, p + 1);
     }
   }
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 7f9a8b2a5c..dbf169c801 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -787,7 +787,7 @@ static bool expand_showtail(expand_T *xp)
   for (s = (char_u *)xp->xp_pattern; s < end; s++) {
     // Skip escaped wildcards.  Only when the backslash is not a path
     // separator, on DOS the '*' "path\*\file" must not be skipped.
-    if (rem_backslash(s)) {
+    if (rem_backslash((char *)s)) {
       s++;
     } else if (vim_strchr("*?[", *s) != NULL) {
       return false;
@@ -1242,11 +1242,10 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
       arg = (const char *)skipwhite((char *)skiptowhite((const char_u *)arg));
       if (*arg != NUL) {
         xp->xp_context = EXPAND_NOTHING;
-        arg = (const char *)skip_regexp((char_u *)arg + 1, (uint8_t)(*arg),
-                                        p_magic, NULL);
+        arg = (const char *)skip_regexp((char *)arg + 1, (uint8_t)(*arg), p_magic, NULL);
       }
     }
-    return (const char *)find_nextcmd((char_u *)arg);
+    return (const char *)find_nextcmd(arg);
 
   // All completion for the +cmdline_compl feature goes here.
 
@@ -1282,7 +1281,7 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
     if (delim) {
       // Skip "from" part.
       arg++;
-      arg = (const char *)skip_regexp((char_u *)arg, delim, p_magic, NULL);
+      arg = (const char *)skip_regexp((char *)arg, delim, p_magic, NULL);
     }
     // Skip "to" part.
     while (arg[0] != NUL && (uint8_t)arg[0] != delim) {
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index 9aee023f0c..9fdeebf68a 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -47,7 +47,7 @@ struct debuggy {
 
 /// Debug mode. Repeatedly get Ex commands, until told to continue normal
 /// execution.
-void do_debug(char_u *cmd)
+void do_debug(char *cmd)
 {
   int save_msg_scroll = msg_scroll;
   int save_State = State;
@@ -239,11 +239,11 @@ void do_debug(char_u *cmd)
           last_cmd = CMD_STEP;
           break;
         case CMD_BACKTRACE:
-          do_showbacktrace(cmd);
+          do_showbacktrace((char_u *)cmd);
           continue;
         case CMD_FRAME:
           if (*p == NUL) {
-            do_showbacktrace(cmd);
+            do_showbacktrace((char_u *)cmd);
           } else {
             p = skipwhite(p);
             do_setdebugtracelevel((char_u *)p);
@@ -414,7 +414,7 @@ void dbg_check_breakpoint(exarg_T *eap)
            debug_breakpoint_name + (*p == NUL ? 0 : 3),
            (int64_t)debug_breakpoint_lnum);
       debug_breakpoint_name = NULL;
-      do_debug((char_u *)eap->cmd);
+      do_debug(eap->cmd);
     } else {
       debug_skipped = true;
       debug_skipped_name = debug_breakpoint_name;
@@ -422,7 +422,7 @@ void dbg_check_breakpoint(exarg_T *eap)
     }
   } else if (ex_nesting_level <= debug_break_level) {
     if (!eap->skip) {
-      do_debug((char_u *)eap->cmd);
+      do_debug(eap->cmd);
     } else {
       debug_skipped = true;
       debug_skipped_name = NULL;
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 23fdc728f3..1cfb535fe8 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -573,9 +573,9 @@ static void diff_check_unchanged(tabpage_T *tp, diff_T *dp)
       if (dir == BACKWARD) {
         off_org = dp->df_count[i_org] - 1;
       }
-      char_u *line_org = vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org],
-                                                dp->df_lnum[i_org] + off_org,
-                                                false));
+      char *line_org = (char *)vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org],
+                                                      dp->df_lnum[i_org] + off_org,
+                                                      false));
 
       int i_new;
       for (i_new = i_org + 1; i_new < DB_COUNT; i_new++) {
@@ -592,9 +592,9 @@ static void diff_check_unchanged(tabpage_T *tp, diff_T *dp)
           break;
         }
 
-        if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new],
-                                          dp->df_lnum[i_new] + off_new,
-                                          false)) != 0) {
+        if (diff_cmp((char_u *)line_org, ml_get_buf(tp->tp_diffbuf[i_new],
+                                                    dp->df_lnum[i_new] + off_new,
+                                                    false)) != 0) {
           break;
         }
       }
@@ -1539,8 +1539,8 @@ static void diff_read(int idx_orig, int idx_new, diffio_T *dio)
   diff_T *dp = curtab->tp_first_diff;
   diff_T *dn, *dpl;
   diffout_T *dout = &dio->dio_diff;
-  char_u linebuf[LBUFLEN];  // only need to hold the diff line
-  char_u *line;
+  char linebuf[LBUFLEN];  // only need to hold the diff line
+  char *line;
   linenr_T off;
   int i;
   int notset = true;  // block "*dp" not set yet
@@ -1576,9 +1576,9 @@ static void diff_read(int idx_orig, int idx_new, diffio_T *dio)
         if (line_idx >= dout->dout_ga.ga_len) {
           break;      // did last line
         }
-        line = ((char_u **)dout->dout_ga.ga_data)[line_idx++];
+        line = ((char **)dout->dout_ga.ga_data)[line_idx++];
       } else {
-        if (vim_fgets(linebuf, LBUFLEN, fd)) {
+        if (vim_fgets((char_u *)linebuf, LBUFLEN, fd)) {
           break;      // end of file
         }
         line = linebuf;
@@ -1600,9 +1600,9 @@ static void diff_read(int idx_orig, int idx_new, diffio_T *dio)
         } else if ((STRNCMP(line, "@@ ", 3) == 0)) {
           diffstyle = DIFF_UNIFIED;
         } else if ((STRNCMP(line, "--- ", 4) == 0)  // -V501
-                   && (vim_fgets(linebuf, LBUFLEN, fd) == 0)  // -V501
+                   && (vim_fgets((char_u *)linebuf, LBUFLEN, fd) == 0)  // -V501
                    && (STRNCMP(line, "+++ ", 4) == 0)
-                   && (vim_fgets(linebuf, LBUFLEN, fd) == 0)  // -V501
+                   && (vim_fgets((char_u *)linebuf, LBUFLEN, fd) == 0)  // -V501
                    && (STRNCMP(line, "@@ ", 3) == 0)) {
           diffstyle = DIFF_UNIFIED;
         } else {
@@ -1616,7 +1616,7 @@ static void diff_read(int idx_orig, int idx_new, diffio_T *dio)
         if (!isdigit(*line)) {
           continue;   // not the start of a diff block
         }
-        if (parse_diff_ed(line, hunk) == FAIL) {
+        if (parse_diff_ed((char_u *)line, hunk) == FAIL) {
           continue;
         }
       } else {
@@ -1624,7 +1624,7 @@ static void diff_read(int idx_orig, int idx_new, diffio_T *dio)
         if (STRNCMP(line, "@@ ", 3) != 0) {
           continue;   // not the start of a diff block
         }
-        if (parse_diff_unified(line, hunk) == FAIL) {
+        if (parse_diff_unified((char_u *)line, hunk) == FAIL) {
           continue;
         }
       }
@@ -1920,11 +1920,11 @@ static bool diff_equal_entry(diff_T *dp, int idx1, int idx2)
   }
 
   for (int i = 0; i < dp->df_count[idx1]; i++) {
-    char_u *line = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1],
-                                          dp->df_lnum[idx1] + i, false));
+    char *line = (char *)vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1],
+                                                dp->df_lnum[idx1] + i, false));
 
-    int cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2],
-                                        dp->df_lnum[idx2] + i, false));
+    int cmp = diff_cmp((char_u *)line, ml_get_buf(curtab->tp_diffbuf[idx2],
+                                                  dp->df_lnum[idx2] + i, false));
     xfree(line);
 
     if (cmp != 0) {
@@ -2281,7 +2281,7 @@ bool diffopt_filler(void)
 bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  char_u *line_new;
+  char *line_new;
   int si_org;
   int si_new;
   int ei_org;
@@ -2290,7 +2290,7 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
   int l;
 
   // Make a copy of the line, the next ml_get() will invalidate it.
-  char_u *line_org = vim_strsave(ml_get_buf(wp->w_buffer, lnum, false));
+  char *line_org = (char *)vim_strsave(ml_get_buf(wp->w_buffer, lnum, false));
 
   int idx = diff_buf_idx(wp->w_buffer);
   if (idx == DB_COUNT) {
@@ -2322,8 +2322,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
         continue;
       }
       added = false;
-      line_new = ml_get_buf(curtab->tp_diffbuf[i],
-                            dp->df_lnum[i] + off, false);
+      line_new = (char *)ml_get_buf(curtab->tp_diffbuf[i],
+                                    dp->df_lnum[i] + off, false);
 
       // Search for start of difference
       si_org = si_new = 0;
@@ -2335,10 +2335,10 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
             || ((diff_flags & DIFF_IWHITEALL)
                 && (ascii_iswhite(line_org[si_org])
                     || ascii_iswhite(line_new[si_new])))) {
-          si_org = (int)((char_u *)skipwhite((char *)line_org + si_org) - line_org);
-          si_new = (int)((char_u *)skipwhite((char *)line_new + si_new) - line_new);
+          si_org = (int)(skipwhite(line_org + si_org) - line_org);
+          si_new = (int)(skipwhite(line_new + si_new) - line_new);
         } else {
-          if (!diff_equal_char(line_org + si_org, line_new + si_new, &l)) {
+          if (!diff_equal_char((char_u *)line_org + si_org, (char_u *)line_new + si_new, &l)) {
             break;
           }
           si_org += l;
@@ -2348,8 +2348,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
 
       // Move back to first byte of character in both lines (may
       // have "nn^" in line_org and "n^ in line_new).
-      si_org -= utf_head_off(line_org, line_org + si_org);
-      si_new -= utf_head_off(line_new, line_new + si_new);
+      si_org -= utf_head_off((char_u *)line_org, (char_u *)line_org + si_org);
+      si_new -= utf_head_off((char_u *)line_new, (char_u *)line_new + si_new);
 
       if (*startp > si_org) {
         *startp = si_org;
@@ -2378,11 +2378,11 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
               ei_new--;
             }
           } else {
-            const char_u *p1 = line_org + ei_org;
-            const char_u *p2 = line_new + ei_new;
+            const char_u *p1 = (char_u *)line_org + ei_org;
+            const char_u *p2 = (char_u *)line_new + ei_new;
 
-            p1 -= utf_head_off(line_org, p1);
-            p2 -= utf_head_off(line_new, p2);
+            p1 -= utf_head_off((char_u *)line_org, p1);
+            p2 -= utf_head_off((char_u *)line_new, p2);
 
             if (!diff_equal_char(p1, p2, &l)) {
               break;
@@ -2511,7 +2511,7 @@ void ex_diffgetput(exarg_T *eap)
   diff_T *dfree;
   int i;
   int added;
-  char_u *p;
+  char *p;
   aco_save_T aco;
   buf_T *buf;
   linenr_T start_skip;
@@ -2565,18 +2565,18 @@ void ex_diffgetput(exarg_T *eap)
     }
   } else {
     // Buffer number or pattern given. Ignore trailing white space.
-    p = (char_u *)eap->arg + STRLEN(eap->arg);
-    while (p > (char_u *)eap->arg && ascii_iswhite(p[-1])) {
+    p = eap->arg + STRLEN(eap->arg);
+    while (p > eap->arg && ascii_iswhite(p[-1])) {
       p--;
     }
 
-    for (i = 0; ascii_isdigit(eap->arg[i]) && (char_u *)eap->arg + i < p; i++) {}
+    for (i = 0; ascii_isdigit(eap->arg[i]) && eap->arg + i < p; i++) {}
 
-    if ((char_u *)eap->arg + i == p) {
+    if (eap->arg + i == p) {
       // digits only
       i = (int)atol(eap->arg);
     } else {
-      i = buflist_findpat(eap->arg, (char *)p, false, true, false);
+      i = buflist_findpat(eap->arg, p, false, true, false);
 
       if (i < 0) {
         // error message already given
@@ -2718,8 +2718,8 @@ void ex_diffgetput(exarg_T *eap)
         if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) {
           break;
         }
-        p = vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, false));
-        ml_append(lnum + i - 1, (char *)p, 0, false);
+        p = (char *)vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, false));
+        ml_append(lnum + i - 1, p, 0, false);
         xfree(p);
         added++;
         if (buf_empty && (curbuf->b_ml.ml_line_count == 2)) {
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 4b5f6c6c06..b6654699d8 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -116,7 +116,7 @@ static int line_putchar(buf_T *buf, LineState *s, schar_T *dest, int maxcells, b
   if (cells > maxcells) {
     return -1;
   }
-  u8c = utfc_ptr2char(p, u8cc);
+  u8c = utfc_ptr2char((char *)p, u8cc);
   if (*p == TAB) {
     cells = MIN(tabstop_padding(vcol, buf->b_p_ts, buf->b_p_vts_array), maxcells);
     for (int c = 0; c < cells; c++) {
@@ -141,7 +141,7 @@ static int line_putchar(buf_T *buf, LineState *s, schar_T *dest, int maxcells, b
         nc = utf_ptr2char((char *)p + c_len);
         s->prev_c1 = u8cc[0];
       } else {
-        pc = utfc_ptr2char(p + c_len, pcc);
+        pc = utfc_ptr2char((char *)p + c_len, pcc);
         nc = s->prev_c;
         pc1 = pcc[0];
       }
@@ -1489,7 +1489,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         if (mb_l > n_extra) {
           mb_l = 1;
         } else if (mb_l > 1) {
-          mb_c = utfc_ptr2char(p_extra, u8cc);
+          mb_c = utfc_ptr2char((char *)p_extra, u8cc);
           mb_utf8 = true;
           c = 0xc0;
         }
@@ -1540,7 +1540,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       mb_l = utfc_ptr2len((char *)ptr);
       mb_utf8 = false;
       if (mb_l > 1) {
-        mb_c = utfc_ptr2char(ptr, u8cc);
+        mb_c = utfc_ptr2char((char *)ptr, u8cc);
         // Overlong encoded ASCII or ASCII with composing char
         // is displayed normally, except a NUL.
         if (mb_c < 0x80) {
@@ -1598,7 +1598,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           nc = utf_ptr2char((char *)ptr + mb_l);
           prev_c1 = u8cc[0];
         } else {
-          pc = utfc_ptr2char(ptr + mb_l, pcc);
+          pc = utfc_ptr2char((char *)ptr + mb_l, pcc);
           nc = prev_c;
           pc1 = pcc[0];
         }
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index a601a82495..40dbec8a5b 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -1889,7 +1889,7 @@ win_update_start:
       int scr_row = wp->w_grid.rows - 1;
 
       // Last line isn't finished: Display "@@@" in the last screen line.
-      grid_puts_len(&wp->w_grid, (char_u *)"@@", MIN(wp->w_grid.cols, 2), scr_row, 0, at_attr);
+      grid_puts_len(&wp->w_grid, "@@", MIN(wp->w_grid.cols, 2), scr_row, 0, at_attr);
 
       grid_fill(&wp->w_grid, scr_row, scr_row + 1, 2, wp->w_grid.cols,
                 '@', ' ', at_attr);
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index b9432ca362..b0174de01f 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1523,8 +1523,7 @@ void edit_unputchar(void)
     if (pc_status == PC_STATUS_RIGHT || pc_status == PC_STATUS_LEFT) {
       redrawWinline(curwin, curwin->w_cursor.lnum);
     } else {
-      grid_puts(&curwin->w_grid, pc_bytes, pc_row - msg_scrolled, pc_col,
-                pc_attr);
+      grid_puts(&curwin->w_grid, (char *)pc_bytes, pc_row - msg_scrolled, pc_col, pc_attr);
     }
   }
 }
@@ -1698,7 +1697,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
       ptr = xmallocz(i);
       memset(ptr, ' ', i);
       new_cursor_col += (int)i;
-      ins_str(ptr);
+      ins_str((char *)ptr);
       xfree(ptr);
     }
 
@@ -1797,7 +1796,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 /// Truncate the space at the end of a line.  This is to be used only in an
 /// insert mode.  It handles fixing the replace stack for MODE_REPLACE and
 /// MODE_VREPLACE modes.
-void truncate_spaces(char_u *line)
+void truncate_spaces(char *line)
 {
   int i;
 
@@ -1989,7 +1988,7 @@ static void insert_special(int c, int allow_modmask, int ctrlv)
         return;
       }
       p[len - 1] = NUL;
-      ins_str(p);
+      ins_str((char *)p);
       AppendToRedobuffLit((char *)p, -1);
       ctrlv = false;
     }
@@ -2117,7 +2116,7 @@ void insertchar(int c, int flags, int second_indent)
 
         // Insert the end-comment string, except for the last
         // character, which will get inserted as normal later.
-        ins_bytes_len(lead_end, (size_t)(end_len - 1));
+        ins_bytes_len((char *)lead_end, (size_t)(end_len - 1));
       }
     }
   }
@@ -2177,7 +2176,7 @@ void insertchar(int c, int flags, int second_indent)
     do_digraph(-1);                     // clear digraphs
     do_digraph(buf[i - 1]);               // may be the start of a digraph
     buf[i] = NUL;
-    ins_str(buf);
+    ins_str((char *)buf);
     if (flags & INSCHAR_CTRLV) {
       redo_literal(*buf);
       i = 1;
@@ -2195,7 +2194,7 @@ void insertchar(int c, int flags, int second_indent)
 
       utf_char2bytes(c, (char *)buf);
       buf[cc] = NUL;
-      ins_char_bytes((char_u *)buf, (size_t)cc);
+      ins_char_bytes(buf, (size_t)cc);
       AppendCharToRedobuff(c);
     } else {
       ins_char(c);
@@ -2848,14 +2847,13 @@ void replace_push(int c)
   replace_stack_nr++;
 }
 
-/*
- * Push a character onto the replace stack.  Handles a multi-byte character in
- * reverse byte order, so that the first byte is popped off first.
- * Return the number of bytes done (includes composing characters).
- */
-int replace_push_mb(char_u *p)
+/// Push a character onto the replace stack.  Handles a multi-byte character in
+/// reverse byte order, so that the first byte is popped off first.
+///
+/// @return  the number of bytes done (includes composing characters).
+int replace_push_mb(char *p)
 {
-  int l = utfc_ptr2len((char *)p);
+  int l = utfc_ptr2len(p);
   int j;
 
   for (j = l - 1; j >= 0; j--) {
@@ -2919,7 +2917,7 @@ static void mb_replace_pop_ins(int cc)
     for (i = 1; i < n; i++) {
       buf[i] = (char_u)replace_pop();
     }
-    ins_bytes_len(buf, (size_t)n);
+    ins_bytes_len((char *)buf, (size_t)n);
   } else {
     ins_char(cc);
   }
@@ -2942,7 +2940,7 @@ static void mb_replace_pop_ins(int cc)
       buf[i] = (char_u)replace_pop();
     }
     if (utf_iscomposing(utf_ptr2char((char *)buf))) {
-      ins_bytes_len(buf, (size_t)n);
+      ins_bytes_len((char *)buf, (size_t)n);
     } else {
       // Not a composing char, put it back.
       for (i = n - 1; i >= 0; i--) {
@@ -4078,7 +4076,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
         if (State & VREPLACE_FLAG) {
           ins_char(' ');
         } else {
-          ins_str((char_u *)" ");
+          ins_str(" ");
           if ((State & REPLACE_FLAG)) {
             replace_push(NUL);
           }
@@ -4122,7 +4120,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
         } else {
           const int l_p_deco = p_deco;
           if (l_p_deco) {
-            (void)utfc_ptr2char(get_cursor_pos_ptr(), cpc);
+            (void)utfc_ptr2char((char *)get_cursor_pos_ptr(), cpc);
           }
           (void)del_char(false);
           // If there are combining characters and 'delcombine' is set
@@ -4584,7 +4582,7 @@ static bool ins_tab(void)
     if (State & VREPLACE_FLAG) {
       ins_char(' ');
     } else {
-      ins_str((char_u *)" ");
+      ins_str(" ");
       if (State & REPLACE_FLAG) {            // no char replaced
         replace_push(NUL);
       }
@@ -4718,7 +4716,7 @@ static bool ins_tab(void)
 
         // Insert each char in saved_line from changed_col to
         // ptr-cursor
-        ins_bytes_len(saved_line + change_col, (size_t)(cursor->col - change_col));
+        ins_bytes_len((char *)saved_line + change_col, (size_t)(cursor->col - change_col));
       }
     }
 
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index ecac7e75ae..f89b06843a 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -8162,7 +8162,7 @@ repeat:
   while (src[*usedlen] == ':' && src[*usedlen + 1] == 'h') {
     valid |= VALID_HEAD;
     *usedlen += 2;
-    s = (char *)get_past_head((char_u *)(*fnamep));
+    s = get_past_head(*fnamep);
     while (tail > s && after_pathsep(s, tail)) {
       MB_PTR_BACK(*fnamep, tail);
     }
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 0c3d2d6935..0bf3ad6901 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -851,7 +851,8 @@ static void get_col(typval_T *argvars, typval_T *rettv, bool charcol)
       if (virtual_active() && fp == &curwin->w_cursor) {
         char *p = (char *)get_cursor_pos_ptr();
         if (curwin->w_cursor.coladd >=
-            (colnr_T)win_chartabsize(curwin, p, curwin->w_virtcol - curwin->w_cursor.coladd)) {
+            (colnr_T)win_chartabsize(curwin, p,
+                                     curwin->w_virtcol - curwin->w_cursor.coladd)) {
           int l;
           if (*p != NUL && p[(l = utfc_ptr2len(p))] == NUL) {
             col += l;
@@ -3896,12 +3897,12 @@ static void f_iconv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   const char *const str = tv_get_string(&argvars[0]);
   char buf1[NUMBUFLEN];
   char_u *const from =
-    (char_u *)enc_canonize((char *)enc_skip((char_u *)tv_get_string_buf(&argvars[1], buf1)));
+    (char_u *)enc_canonize(enc_skip((char *)tv_get_string_buf(&argvars[1], buf1)));
   char buf2[NUMBUFLEN];
   char_u *const to =
-    (char_u *)enc_canonize((char *)enc_skip((char_u *)tv_get_string_buf(&argvars[2], buf2)));
+    (char_u *)enc_canonize(enc_skip((char *)tv_get_string_buf(&argvars[2], buf2)));
   vimconv.vc_type = CONV_NONE;
-  convert_setup(&vimconv, from, to);
+  convert_setup(&vimconv, (char *)from, (char *)to);
 
   // If the encodings are equal, no conversion needed.
   if (vimconv.vc_type == CONV_NONE) {
@@ -7072,7 +7073,7 @@ static void f_screenchars(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
   int pcc[MAX_MCO];
-  int c = utfc_ptr2char(grid->chars[grid->line_offset[row] + (size_t)col], pcc);
+  int c = utfc_ptr2char((char *)grid->chars[grid->line_offset[row] + (size_t)col], pcc);
   int composing_len = 0;
   while (pcc[composing_len] != 0) {
     composing_len++;
@@ -7605,7 +7606,7 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
     char_u *const csearch = (char_u *)tv_dict_get_string(d, "char", false);
     if (csearch != NULL) {
       int pcc[MAX_MCO];
-      const int c = utfc_ptr2char(csearch, pcc);
+      const int c = utfc_ptr2char((char *)csearch, pcc);
       set_last_csearch(c, csearch, utfc_ptr2len((char *)csearch));
     }
 
@@ -8402,11 +8403,10 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     rettv->vval.v_string = xstrdup(_("(Invalid)"));
   } else {
     vimconv_T conv;
-    char_u *enc;
 
     conv.vc_type = CONV_NONE;
-    enc = enc_locale();
-    convert_setup(&conv, (char_u *)p_enc, enc);
+    char *enc = (char *)enc_locale();
+    convert_setup(&conv, p_enc, enc);
     if (conv.vc_type != CONV_NONE) {
       p = (char *)string_convert(&conv, (char_u *)p, NULL);
     }
@@ -8420,7 +8420,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     if (conv.vc_type != CONV_NONE) {
       xfree(p);
     }
-    convert_setup(&conv, enc, (char_u *)p_enc);
+    convert_setup(&conv, enc, p_enc);
     if (conv.vc_type != CONV_NONE) {
       rettv->vval.v_string = (char *)string_convert(&conv, (char_u *)result_buf, NULL);
     } else {
@@ -8665,8 +8665,8 @@ static void f_strptime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   vimconv_T conv = {
     .vc_type = CONV_NONE,
   };
-  char_u *enc = enc_locale();
-  convert_setup(&conv, (char_u *)p_enc, enc);
+  char *enc = (char *)enc_locale();
+  convert_setup(&conv, p_enc, enc);
   if (conv.vc_type != CONV_NONE) {
     fmt = (char *)string_convert(&conv, (char_u *)fmt, NULL);
   }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 8cb7a075cb..2a48de5e41 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1933,7 +1933,7 @@ void ex_function(exarg_T *eap)
         if (!HASHITEM_EMPTY(hi)) {
           todo--;
           fp = HI2UF(hi);
-          if (message_filtered(fp->uf_name)) {
+          if (message_filtered((char *)fp->uf_name)) {
             continue;
           }
           if (!func_name_refcount(fp->uf_name)) {
@@ -1950,7 +1950,7 @@ void ex_function(exarg_T *eap)
    * ":function /pat": list functions matching pattern.
    */
   if (*eap->arg == '/') {
-    p = skip_regexp((char_u *)eap->arg + 1, '/', true, NULL);
+    p = (char_u *)skip_regexp(eap->arg + 1, '/', true, NULL);
     if (!eap->skip) {
       regmatch_T regmatch;
 
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 0086cc41ca..e73bba16e2 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -413,7 +413,7 @@ void list_hashtable_vars(hashtab_T *ht, const char *prefix, int empty, int *firs
       // apply :filter /pat/ to variable name
       xstrlcpy(buf, prefix, IOSIZE);
       xstrlcat(buf, (char *)di->di_key, IOSIZE);
-      if (message_filtered((char_u *)buf)) {
+      if (message_filtered(buf)) {
         continue;
       }
 
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 6886ce0987..57eb2f526f 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -120,7 +120,7 @@ void do_ascii(const exarg_T *const eap)
 {
   char *dig;
   int cc[MAX_MCO];
-  int c = utfc_ptr2char(get_cursor_pos_ptr(), cc);
+  int c = utfc_ptr2char((char *)get_cursor_pos_ptr(), cc);
   if (c == NUL) {
     msg("NUL");
     return;
@@ -513,7 +513,7 @@ void ex_sort(exarg_T *eap)
       eap->nextcmd = (char *)check_nextcmd((char_u *)p);
       break;
     } else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL) {
-      s = (char *)skip_regexp((char_u *)p + 1, *p, true, NULL);
+      s = skip_regexp(p + 1, *p, true, NULL);
       if (*s != *p) {
         emsg(_(e_invalpat));
         goto sortend;
@@ -1709,7 +1709,7 @@ void print_line(linenr_T lnum, int use_number, int list)
   int save_silent = silent_mode;
 
   // apply :filter /pat/
-  if (message_filtered(ml_get(lnum))) {
+  if (message_filtered((char *)ml_get(lnum))) {
     return;
   }
 
@@ -3546,7 +3546,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
       which_pat = RE_LAST;                  // use last used regexp
       delimiter = (char_u)(*cmd++);                   // remember delimiter character
       pat = cmd;                            // remember start of search pat
-      cmd = (char *)skip_regexp((char_u *)cmd, delimiter, p_magic, &eap->arg);
+      cmd = skip_regexp(cmd, delimiter, p_magic, &eap->arg);
       if (cmd[0] == delimiter) {            // end delimiter found
         *cmd++ = NUL;                       // replace it with a NUL
         has_second_delim = true;
@@ -4631,7 +4631,7 @@ void ex_global(exarg_T *eap)
     delim = *cmd;               // get the delimiter
     cmd++;                      // skip delimiter if there is one
     pat = cmd;                  // remember start of pattern
-    cmd = (char *)skip_regexp((char_u *)cmd, delim, p_magic, &eap->arg);
+    cmd = skip_regexp(cmd, delim, p_magic, &eap->arg);
     if (cmd[0] == delim) {                  // end delimiter found
       *cmd++ = NUL;                         // replace it with a NUL
     }
@@ -4948,7 +4948,7 @@ char *skip_vimgrep_pat(char *p, char **s, int *flags)
       *s = p + 1;
     }
     c = (char_u)(*p);
-    p = (char *)skip_regexp((char_u *)p + 1, c, true, NULL);
+    p = skip_regexp(p + 1, c, true, NULL);
     if (*p != c) {
       return NULL;
     }
@@ -4993,7 +4993,7 @@ void ex_oldfiles(exarg_T *eap)
       }
       nr++;
       const char *fname = tv_get_string(TV_LIST_ITEM_TV(li));
-      if (!message_filtered((char_u *)fname)) {
+      if (!message_filtered((char *)fname)) {
         msg_outnum(nr);
         msg_puts(": ");
         msg_outtrans((char *)tv_get_string(TV_LIST_ITEM_TV(li)));
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 206fd515e3..3cd4369107 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -851,8 +851,8 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
          || getline_equal(fgetline, cookie, get_func_line))
         && ex_nesting_level + 1 <= debug_break_level) {
       do_debug(getline_equal(fgetline, cookie, getsourceline)
-               ? (char_u *)_("End of sourced file")
-               : (char_u *)_("End of function"));
+               ? _("End of sourced file")
+               : _("End of function"));
     }
   }
 
@@ -3310,7 +3310,7 @@ static linenr_T get_address(exarg_T *eap, char **ptr, cmd_addr_T addr_type, int
         goto error;
       }
       if (skip) {                       // skip "/pat/"
-        cmd = (char *)skip_regexp((char_u *)cmd, c, p_magic, NULL);
+        cmd = skip_regexp(cmd, c, p_magic, NULL);
         if (*cmd == c) {
           cmd++;
         }
@@ -4295,7 +4295,7 @@ int ends_excmd(int c) FUNC_ATTR_CONST
 
 /// @return  the next command, after the first '|' or '\n' or,
 ///          NULL if not found.
-char_u *find_nextcmd(const char_u *p)
+char *find_nextcmd(const char *p)
 {
   while (*p != '|' && *p != '\n') {
     if (*p == NUL) {
@@ -4303,7 +4303,7 @@ char_u *find_nextcmd(const char_u *p)
     }
     p++;
   }
-  return (char_u *)p + 1;
+  return (char *)p + 1;
 }
 
 /// Check if *p is a separator between Ex commands, skipping over white space.
@@ -5499,7 +5499,7 @@ bool changedir_func(char *new_dir, CdScope scope)
   if (*new_dir == NUL && p_cdh) {
 #endif
     // Use NameBuff for home directory name.
-    expand_env((char_u *)"$HOME", (char_u *)NameBuff, MAXPATHL);
+    expand_env("$HOME", NameBuff, MAXPATHL);
     new_dir = (char *)NameBuff;
   }
 
@@ -6454,7 +6454,7 @@ static void ex_findpat(exarg_T *eap)
   if (*eap->arg == '/') {   // Match regexp, not just whole words
     whole = false;
     eap->arg++;
-    char *p = (char *)skip_regexp((char_u *)eap->arg, '/', p_magic, NULL);
+    char *p = skip_regexp(eap->arg, '/', p_magic, NULL);
     if (*p) {
       *p++ = NUL;
       p = skipwhite(p);
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 19dcc06825..e2b02929d2 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -1333,10 +1333,10 @@ void ex_catch(exarg_T *eap)
   if (ends_excmd(*eap->arg)) {  // no argument, catch all errors
     pat = ".*";
     end = NULL;
-    eap->nextcmd = (char *)find_nextcmd((char_u *)eap->arg);
+    eap->nextcmd = find_nextcmd(eap->arg);
   } else {
     pat = eap->arg + 1;
-    end = (char *)skip_regexp((char_u *)pat, *eap->arg, true, NULL);
+    end = skip_regexp(pat, *eap->arg, true, NULL);
   }
 
   if (!give_up) {
@@ -1439,7 +1439,7 @@ void ex_catch(exarg_T *eap)
   }
 
   if (end != NULL) {
-    eap->nextcmd = (char *)find_nextcmd((char_u *)end);
+    eap->nextcmd = find_nextcmd(end);
   }
 }
 
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 0cca4b69e8..ec2672c675 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -315,7 +315,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
   p = skipwhite(p);
   delim = (delim_optional && vim_isIDc(*p)) ? ' ' : *p++;
   *search_delim = delim;
-  end = (char *)skip_regexp((char_u *)p, delim, p_magic, NULL);
+  end = skip_regexp(p, delim, p_magic, NULL);
 
   use_last_pat = end == p && *end == delim;
   if (end == p && !use_last_pat) {
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index b873388473..450c608fad 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -2024,7 +2024,7 @@ void prep_exarg(exarg_T *eap, const buf_T *buf)
   snprintf(eap->cmd, cmd_len, "e ++enc=%s", buf->b_p_fenc);
   eap->force_enc = 8;
   eap->bad_char = buf->b_bad_char;
-  eap->force_ff = *buf->b_p_ff;
+  eap->force_ff = (unsigned char)(*buf->b_p_ff);
 
   eap->force_bin = buf->b_p_bin ? FORCE_BIN : FORCE_NOBIN;
   eap->read_edit = false;
@@ -5317,7 +5317,7 @@ static void vim_mktempdir(void)
   mode_t umask_save = umask(0077);
   for (size_t i = 0; i < ARRAY_SIZE(temp_dirs); i++) {
     // Expand environment variables, leave room for "/tmp/nvim.<user>/XXXXXX/999999999".
-    expand_env((char_u *)temp_dirs[i], (char_u *)tmp, TEMP_FILE_PATH_MAXLEN - 64);
+    expand_env((char *)temp_dirs[i], tmp, TEMP_FILE_PATH_MAXLEN - 64);
     if (!os_isdir((char_u *)tmp)) {
       continue;
     }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 574eba9bdd..af3895b793 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1302,7 +1302,7 @@ void openscript(char_u *name, bool directly)
     curscript++;
   }
   // use NameBuff for expanded name
-  expand_env(name, (char_u *)NameBuff, MAXPATHL);
+  expand_env((char *)name, NameBuff, MAXPATHL);
   int error;
   if ((scriptin[curscript] = file_open_new(&error, (char *)NameBuff,
                                            kFileReadOnly, 0)) == NULL) {
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index c805c238c6..329adfda12 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -125,7 +125,7 @@ void grid_putchar(ScreenGrid *grid, int c, int row, int col, int attr)
   char buf[MB_MAXBYTES + 1];
 
   buf[utf_char2bytes(c, buf)] = NUL;
-  grid_puts(grid, (char_u *)buf, row, col, attr);
+  grid_puts(grid, buf, row, col, attr);
 }
 
 /// get a single character directly from grid.chars into "bytes[]".
@@ -148,7 +148,7 @@ void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes, int *attrp
 /// attributes 'attr', and update chars[] and attrs[].
 /// Note: only outputs within one row, message is truncated at grid boundary!
 /// Note: if grid, row and/or col is invalid, nothing is done.
-void grid_puts(ScreenGrid *grid, char_u *text, int row, int col, int attr)
+void grid_puts(ScreenGrid *grid, char *text, int row, int col, int attr)
 {
   grid_puts_len(grid, text, -1, row, col, attr);
 }
@@ -187,10 +187,10 @@ void grid_put_schar(ScreenGrid *grid, int row, int col, char_u *schar, int attr)
 
 /// like grid_puts(), but output "text[len]".  When "len" is -1 output up to
 /// a NUL.
-void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col, int attr)
+void grid_puts_len(ScreenGrid *grid, char *text, int textlen, int row, int col, int attr)
 {
   size_t off;
-  char_u *ptr = text;
+  char *ptr = text;
   int len = textlen;
   int c;
   size_t max_off;
@@ -237,13 +237,13 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
   while (col < grid->cols
          && (len < 0 || (int)(ptr - text) < len)
          && *ptr != NUL) {
-    c = *ptr;
+    c = (unsigned char)(*ptr);
     // check if this is the first byte of a multibyte
     mbyte_blen = len > 0
-      ? utfc_ptr2len_len(ptr, (int)((text + len) - ptr))
-      : utfc_ptr2len((char *)ptr);
+      ? utfc_ptr2len_len((char_u *)ptr, (int)((text + len) - ptr))
+      : utfc_ptr2len(ptr);
     u8c = len >= 0
-      ? utfc_ptr2char_len(ptr, u8cc, (int)((text + len) - ptr))
+      ? utfc_ptr2char_len((char_u *)ptr, u8cc, (int)((text + len) - ptr))
       : utfc_ptr2char(ptr, u8cc);
     mbyte_cells = utf_char2cells(u8c);
     if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c)) {
@@ -254,7 +254,8 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
         nc1 = NUL;
       } else {
         nc = len >= 0
-          ? utfc_ptr2char_len(ptr + mbyte_blen, pcc, (int)((text + len) - ptr - mbyte_blen))
+          ? utfc_ptr2char_len((char_u *)ptr + mbyte_blen, pcc,
+                              (int)((text + len) - ptr - mbyte_blen))
           : utfc_ptr2char(ptr + mbyte_blen, pcc);
         nc1 = pcc[0];
       }
@@ -320,7 +321,7 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
     ptr += mbyte_blen;
     if (clear_next_cell) {
       // This only happens at the end, display one space next.
-      ptr = (char_u *)" ";
+      ptr = " ";
       len = -1;
     }
   }
@@ -393,11 +394,11 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int
     // double wide-char clear out the right half.  Only needed in a
     // terminal.
     if (start_col > 0 && grid_fix_col(grid, start_col, row) != start_col) {
-      grid_puts_len(grid, (char_u *)" ", 1, row, start_col - 1, 0);
+      grid_puts_len(grid, " ", 1, row, start_col - 1, 0);
     }
     if (end_col < grid->cols
         && grid_fix_col(grid, end_col, row) != end_col) {
-      grid_puts_len(grid, (char_u *)" ", 1, row, end_col, 0);
+      grid_puts_len(grid, " ", 1, row, end_col, 0);
     }
 
     // if grid was resized (in ext_multigrid mode), the UI has no redraw updates
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 6f98e25f56..6e424f2fd6 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -613,7 +613,7 @@ static void prt_message(char_u *s)
 {
   // TODO(bfredl): delete this
   grid_fill(&default_grid, Rows - 1, Rows, 0, Columns, ' ', ' ', 0);
-  grid_puts(&default_grid, s, Rows - 1, 0, HL_ATTR(HLF_R));
+  grid_puts(&default_grid, (char *)s, Rows - 1, 0, HL_ATTR(HLF_R));
   ui_flush();
 }
 
@@ -2147,17 +2147,14 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
   char_u *p;
   int props;
   int cmap = 0;
-  char_u *p_encoding;
   struct prt_ps_encoding_S *p_mbenc;
   struct prt_ps_encoding_S *p_mbenc_first;
   struct prt_ps_charset_S *p_mbchar = NULL;
 
-  /*
-   * Set up font and encoding.
-   */
-  p_encoding = enc_skip((char_u *)p_penc);
+  // Set up font and encoding.
+  char_u *p_encoding = (char_u *)enc_skip(p_penc);
   if (*p_encoding == NUL) {
-    p_encoding = enc_skip((char_u *)p_enc);
+    p_encoding = (char_u *)enc_skip(p_enc);
   }
 
   // Look for a multi-byte font that matches the encoding and character set.
@@ -2591,13 +2588,13 @@ bool mch_print_begin(prt_settings_T *psettings)
   // that cannot be found then default to "latin1".
   // Note: VIM specific encoding header is always skipped.
   if (!prt_out_mbyte) {
-    p_encoding = (char *)enc_skip((char_u *)p_penc);
+    p_encoding = enc_skip(p_penc);
     if (*p_encoding == NUL
         || !prt_find_resource(p_encoding, &res_encoding)) {
       // 'printencoding' not set or not supported - find alternate
       int props;
 
-      p_encoding = (char *)enc_skip((char_u *)p_enc);
+      p_encoding = enc_skip(p_enc);
       props = enc_canon_props((char_u *)p_encoding);
       if (!(props & ENC_8BIT)
           || !prt_find_resource(p_encoding, &res_encoding)) {
@@ -2617,9 +2614,9 @@ bool mch_print_begin(prt_settings_T *psettings)
     // For the moment there are no checks on encoding resource files to
     // perform
   } else {
-    p_encoding = (char *)enc_skip((char_u *)p_penc);
+    p_encoding = enc_skip(p_penc);
     if (*p_encoding == NUL) {
-      p_encoding = (char *)enc_skip((char_u *)p_enc);
+      p_encoding = enc_skip(p_enc);
     }
     if (prt_use_courier) {
       // Include ASCII range encoding vector
@@ -2639,7 +2636,7 @@ bool mch_print_begin(prt_settings_T *psettings)
   prt_conv.vc_type = CONV_NONE;
   if (!(enc_canon_props((char_u *)p_enc) & enc_canon_props((char_u *)p_encoding) & ENC_8BIT)) {
     // Set up encoding conversion if required
-    if (convert_setup(&prt_conv, (char_u *)p_enc, (char_u *)p_encoding) == FAIL) {
+    if (convert_setup(&prt_conv, p_enc, p_encoding) == FAIL) {
       semsg(_("E620: Unable to convert to print encoding \"%s\""),
             p_encoding);
       return false;
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 4b2b113437..b25fabca48 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -803,8 +803,8 @@ void fix_help_buffer(void)
                 // 'encoding' may be required.
                 vc.vc_type = CONV_NONE;
                 convert_setup(&vc,
-                              (char_u *)(this_utf == kTrue ? "utf-8" : "latin1"),
-                              (char_u *)p_enc);
+                              (this_utf == kTrue ? "utf-8" : "latin1"),
+                              p_enc);
                 if (vc.vc_type == CONV_NONE) {
                   // No conversion needed.
                   cp = (char *)IObuff;
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index a63768a8e3..e2d4a81345 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -1421,7 +1421,7 @@ static void highlight_list_one(const int id)
   const HlGroup *sgp = &hl_table[id - 1];  // index is ID minus one
   bool didh = false;
 
-  if (message_filtered(sgp->sg_name)) {
+  if (message_filtered((char *)sgp->sg_name)) {
     return;
   }
 
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 50ec444d51..975fa0ca92 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -423,7 +423,7 @@ static int cs_add_common(char *arg1, char *arg2, char *flags)
   // get the filename (arg1), expand it, and try to stat it
   fname = xmalloc(MAXPATHL + 1);
 
-  expand_env((char_u *)arg1, (char_u *)fname, MAXPATHL);
+  expand_env(arg1, fname, MAXPATHL);
   size_t len = STRLEN(fname);
   fbuf = fname;
   (void)modify_fname(":p", false, &usedlen, &fname, &fbuf, &len);
@@ -445,7 +445,7 @@ staterr:
   // get the prepend path (arg2), expand it, and see if it exists
   if (arg2 != NULL) {
     ppath = xmalloc(MAXPATHL + 1);
-    expand_env((char_u *)arg2, (char_u *)ppath, MAXPATHL);
+    expand_env(arg2, ppath, MAXPATHL);
     if (!os_path_exists((char_u *)ppath)) {
       goto staterr;
     }
@@ -757,14 +757,14 @@ err_closing:
 #endif
     // expand the cscope exec for env var's
     prog = xmalloc(MAXPATHL + 1);
-    expand_env((char_u *)p_csprg, (char_u *)prog, MAXPATHL);
+    expand_env(p_csprg, prog, MAXPATHL);
 
     // alloc space to hold the cscope command
     size_t len = strlen(prog) + strlen(csinfo[i].fname) + 32;
     if (csinfo[i].ppath) {
       // expand the prepend path for env var's
       ppath = xmalloc(MAXPATHL + 1);
-      expand_env((char_u *)csinfo[i].ppath, (char_u *)ppath, MAXPATHL);
+      expand_env(csinfo[i].ppath, ppath, MAXPATHL);
 
       len += strlen(ppath);
     }
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index c983de6d5e..792f4d93c4 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -343,7 +343,7 @@ int get_sts_value(void)
 // Count the size (in window cells) of the indent in the current line.
 int get_indent(void)
 {
-  return get_indent_str_vtab(get_cursor_line_ptr(),
+  return get_indent_str_vtab((char *)get_cursor_line_ptr(),
                              curbuf->b_p_ts,
                              curbuf->b_p_vts_array,
                              false);
@@ -352,7 +352,7 @@ int get_indent(void)
 // Count the size (in window cells) of the indent in line "lnum".
 int get_indent_lnum(linenr_T lnum)
 {
-  return get_indent_str_vtab(ml_get(lnum),
+  return get_indent_str_vtab((char *)ml_get(lnum),
                              curbuf->b_p_ts,
                              curbuf->b_p_vts_array,
                              false);
@@ -362,7 +362,7 @@ int get_indent_lnum(linenr_T lnum)
 // "buf".
 int get_indent_buf(buf_T *buf, linenr_T lnum)
 {
-  return get_indent_str_vtab(ml_get_buf(buf, lnum, false),
+  return get_indent_str_vtab((char *)ml_get_buf(buf, lnum, false),
                              curbuf->b_p_ts,
                              buf->b_p_vts_array,
                              false);
@@ -400,7 +400,7 @@ int get_indent_str(const char_u *ptr, int ts, bool list)
 /// Count the size (in window cells) of the indent in line "ptr", using
 /// variable tabstops.
 /// if "list" is true, count only screen size for tabs.
-int get_indent_str_vtab(const char_u *ptr, long ts, long *vts, bool list)
+int get_indent_str_vtab(const char *ptr, long ts, long *vts, bool list)
 {
   int count = 0;
 
@@ -800,7 +800,7 @@ int get_breakindent_win(win_T *wp, char_u *line)
     prev_ts = wp->w_buffer->b_p_ts;
     prev_tick = buf_get_changedtick(wp->w_buffer);
     prev_vts = wp->w_buffer->b_p_vts_array;
-    prev_indent = get_indent_str_vtab(line,
+    prev_indent = get_indent_str_vtab((char *)line,
                                       wp->w_buffer->b_p_ts,
                                       wp->w_buffer->b_p_vts_array,
                                       wp->w_p_list);
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 128eea915d..8ef6667374 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -212,16 +212,14 @@ int is_pos_in_string(const char_u *line, colnr_T col)
  * Below "XXX" means that this function may unlock the current line.
  */
 
-/*
- * Return true if the string "line" starts with a word from 'cinwords'.
- */
-bool cin_is_cinword(const char_u *line)
+/// @return  true if the string "line" starts with a word from 'cinwords'.
+bool cin_is_cinword(const char *line)
 {
   bool retval = false;
 
   size_t cinw_len = STRLEN(curbuf->b_p_cinw) + 1;
   char_u *cinw_buf = xmalloc(cinw_len);
-  line = (char_u *)skipwhite((char *)line);
+  line = skipwhite((char *)line);
 
   for (char *cinw = curbuf->b_p_cinw; *cinw;) {
     size_t len = copy_option_part(&cinw, (char *)cinw_buf, cinw_len, ",");
@@ -2021,7 +2019,7 @@ int get_c_indent(void)
     if (trypos == NULL && curwin->w_cursor.lnum > 1) {
       // There may be a statement before the comment, search from the end
       // of the line for a comment start.
-      linecomment_pos.col = check_linecomment(ml_get(curwin->w_cursor.lnum - 1));
+      linecomment_pos.col = check_linecomment((char *)ml_get(curwin->w_cursor.lnum - 1));
       if (linecomment_pos.col != MAXCOL) {
         trypos = &linecomment_pos;
         trypos->lnum = curwin->w_cursor.lnum - 1;
@@ -2854,7 +2852,7 @@ int get_c_indent(void)
             if (n) {
               amount = n;
               l = after_label(get_cursor_line_ptr());
-              if (l != NULL && cin_is_cinword(l)) {
+              if (l != NULL && cin_is_cinword((char *)l)) {
                 if (theline[0] == '{') {
                   amount += curbuf->b_ind_open_extra;
                 } else {
@@ -3108,7 +3106,7 @@ int get_c_indent(void)
              * Check if we are after an "if", "while", etc.
              * Also allow "   } else".
              */
-            if (cin_is_cinword(l) || cin_iselse((char_u *)skipwhite((char *)l))) {
+            if (cin_is_cinword((char *)l) || cin_iselse((char_u *)skipwhite((char *)l))) {
               // Found an unterminated line after an if (), line up
               // with the last one.
               //   if (cond)
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 981a8d42a6..3c32d0755e 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -1732,7 +1732,7 @@ void ins_compl_addleader(int c)
 
     utf_char2bytes(c, (char *)buf);
     buf[cc] = NUL;
-    ins_char_bytes((char_u *)buf, (size_t)cc);
+    ins_char_bytes(buf, (size_t)cc);
   } else {
     ins_char(c);
   }
@@ -2014,7 +2014,7 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
       const int compl_len = get_compl_len();
       const int len = (int)STRLEN(p);
       if (len > compl_len) {
-        ins_bytes_len(p + compl_len, (size_t)(len - compl_len));
+        ins_bytes_len((char *)p + compl_len, (size_t)(len - compl_len));
       }
     }
     retval = true;
diff --git a/src/nvim/log.c b/src/nvim/log.c
index 99b17a612b..9f25543be7 100644
--- a/src/nvim/log.c
+++ b/src/nvim/log.c
@@ -60,7 +60,7 @@ static bool log_try_create(char *fname)
 static void log_path_init(void)
 {
   size_t size = sizeof(log_file_path);
-  expand_env((char_u *)"$" ENV_LOGFILE, (char_u *)log_file_path, (int)size - 1);
+  expand_env("$" ENV_LOGFILE, log_file_path, (int)size - 1);
   if (strequal("$" ENV_LOGFILE, log_file_path)
       || log_file_path[0] == '\0'
       || os_isdir((char_u *)log_file_path)
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 0d08817285..7e8dda6ca1 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -494,8 +494,8 @@ static int nlua_iconv(lua_State *lstate)
   size_t str_len = 0;
   const char *str = lua_tolstring(lstate, 1, &str_len);
 
-  char_u *from = (char_u *)enc_canonize((char *)enc_skip((char_u *)lua_tolstring(lstate, 2, NULL)));
-  char_u *to   = (char_u *)enc_canonize((char *)enc_skip((char_u *)lua_tolstring(lstate, 3, NULL)));
+  char_u *from = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 2, NULL)));
+  char_u *to   = (char_u *)enc_canonize(enc_skip((char *)lua_tolstring(lstate, 3, NULL)));
 
   vimconv_T vimconv;
   vimconv.vc_type = CONV_NONE;
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 2364a388b3..333fb847f6 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -150,8 +150,8 @@ static void showmap(mapblock_T *mp, bool local)
 {
   size_t len = 1;
 
-  if (message_filtered(mp->m_keys) && message_filtered((char_u *)mp->m_str)
-      && (mp->m_desc == NULL || message_filtered((char_u *)mp->m_desc))) {
+  if (message_filtered((char *)mp->m_keys) && message_filtered(mp->m_str)
+      && (mp->m_desc == NULL || message_filtered(mp->m_desc))) {
     return;
   }
 
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 883371c5fb..92a7c7c4b0 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -674,7 +674,7 @@ static void fname2fnum(xfmark_T *fm)
                                 )) {
       int len;
 
-      expand_env((char_u *)"~/", (char_u *)NameBuff, MAXPATHL);
+      expand_env("~/", NameBuff, MAXPATHL);
       len = (int)STRLEN(NameBuff);
       STRLCPY(NameBuff + len, fm->fname + 2, MAXPATHL - len);
     } else {
@@ -911,7 +911,7 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
       name = mark_line(p, 15);
       mustfree = true;
     }
-    if (!message_filtered(name)) {
+    if (!message_filtered((char *)name)) {
       if (!did_title) {
         // Highlight title
         msg_puts_title(_("\nmark line  col file/text"));
@@ -1037,7 +1037,7 @@ void ex_jumps(exarg_T *eap)
         name = vim_strsave((char_u *)"-invalid-");
       }
       // apply :filter /pat/ or file name not available
-      if (name == NULL || message_filtered(name)) {
+      if (name == NULL || message_filtered((char *)name)) {
         xfree(name);
         continue;
       }
diff --git a/src/nvim/match.c b/src/nvim/match.c
index 31fa35d84b..cabd008591 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -1194,7 +1194,7 @@ void ex_match(exarg_T *eap)
       semsg(_(e_invarg2), eap->arg);
       return;
     }
-    end = skip_regexp(p + 1, *p, true, NULL);
+    end = (char_u *)skip_regexp((char *)p + 1, *p, true, NULL);
     if (!eap->skip) {
       if (*end != NUL && !ends_excmd(*skipwhite((char *)end + 1))) {
         xfree(g);
@@ -1215,5 +1215,5 @@ void ex_match(exarg_T *eap)
       *end = (char_u)c;
     }
   }
-  eap->nextcmd = (char *)find_nextcmd(end);
+  eap->nextcmd = find_nextcmd((char *)end);
 }
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index dab6c8fbd3..e703280032 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -754,21 +754,19 @@ bool utf_composinglike(const char_u *p1, const char_u *p2)
 ///                   space at least for #MAX_MCO + 1 elements.
 ///
 /// @return leading character.
-int utfc_ptr2char(const char_u *p, int *pcc)
+int utfc_ptr2char(const char *p_in, int *pcc)
 {
-  int len;
-  int c;
-  int cc;
+  uint8_t *p = (uint8_t *)p_in;
   int i = 0;
 
-  c = utf_ptr2char((char *)p);
-  len = utf_ptr2len((char *)p);
+  int c = utf_ptr2char((char *)p);
+  int len = utf_ptr2len((char *)p);
 
   // Only accept a composing char when the first char isn't illegal.
   if ((len > 1 || *p < 0x80)
       && p[len] >= 0x80
       && utf_composinglike(p, p + len)) {
-    cc = utf_ptr2char((char *)p + len);
+    int cc = utf_ptr2char((char *)p + len);
     for (;;) {
       pcc[i++] = cc;
       if (i == MAX_MCO) {
@@ -1936,7 +1934,7 @@ void utf_find_illegal(void)
     // 'encoding' is "utf-8" but we are editing a 8-bit encoded file,
     // possibly a utf-8 file with illegal bytes.  Setup for conversion
     // from utf-8 to 'fileencoding'.
-    convert_setup(&vimconv, (char_u *)p_enc, (char_u *)curbuf->b_p_fenc);
+    convert_setup(&vimconv, p_enc, curbuf->b_p_fenc);
   }
 
   curwin->w_cursor.coladd = 0;
@@ -2146,10 +2144,8 @@ const char *mb_unescape(const char **const pp)
   return NULL;
 }
 
-/*
- * Skip the Vim specific head of a 'encoding' name.
- */
-char_u *enc_skip(char_u *p)
+/// Skip the Vim specific head of a 'encoding' name.
+char *enc_skip(char *p)
 {
   if (STRNCMP(p, "2byte-", 6) == 0) {
     return p + 6;
@@ -2169,8 +2165,6 @@ char *enc_canonize(char *enc)
   FUNC_ATTR_NONNULL_RET
 {
   char_u *p, *s;
-  int i;
-
   if (STRCMP(enc, "default") == 0) {
     // Use the default encoding as found by set_init_1().
     return (char *)vim_strsave(fenc_default);
@@ -2190,7 +2184,7 @@ char *enc_canonize(char *enc)
   *p = NUL;
 
   // Skip "2byte-" and "8bit-".
-  p = enc_skip(r);
+  p = (char_u *)enc_skip((char *)r);
 
   // Change "microsoft-cp" to "cp".  Used in some spell files.
   if (STRNCMP(p, "microsoft-cp", 12) == 0) {
@@ -2214,6 +2208,7 @@ char *enc_canonize(char *enc)
     STRMOVE(p + 5, p + 6);
   }
 
+  int i;
   if (enc_canon_search(p) >= 0) {
     // canonical name can be used unmodified
     if (p != r) {
@@ -2332,7 +2327,7 @@ void *my_iconv_open(char_u *to, char_u *from)
   if (iconv_working == kBroken) {
     return (void *)-1;          // detected a broken iconv() previously
   }
-  fd = iconv_open((char *)enc_skip(to), (char *)enc_skip(from));
+  fd = iconv_open(enc_skip((char *)to), enc_skip((char *)from));
 
   if (fd != (iconv_t)-1 && iconv_working == kUnknown) {
     /*
@@ -2443,18 +2438,17 @@ static char_u *iconv_string(const vimconv_T *const vcp, char_u *str, size_t slen
 
 #endif  // HAVE_ICONV
 
-/*
- * Setup "vcp" for conversion from "from" to "to".
- * The names must have been made canonical with enc_canonize().
- * vcp->vc_type must have been initialized to CONV_NONE.
- * Note: cannot be used for conversion from/to ucs-2 and ucs-4 (will use utf-8
- * instead).
- * Afterwards invoke with "from" and "to" equal to NULL to cleanup.
- * Return FAIL when conversion is not supported, OK otherwise.
- */
-int convert_setup(vimconv_T *vcp, char_u *from, char_u *to)
+/// Setup "vcp" for conversion from "from" to "to".
+/// The names must have been made canonical with enc_canonize().
+/// vcp->vc_type must have been initialized to CONV_NONE.
+/// Note: cannot be used for conversion from/to ucs-2 and ucs-4 (will use utf-8
+/// instead).
+/// Afterwards invoke with "from" and "to" equal to NULL to cleanup.
+///
+/// @return  FAIL when conversion is not supported, OK otherwise.
+int convert_setup(vimconv_T *vcp, char *from, char *to)
 {
-  return convert_setup_ext(vcp, from, true, to, true);
+  return convert_setup_ext(vcp, (char_u *)from, true, (char_u *)to, true);
 }
 
 /// As convert_setup(), but only when from_unicode_is_utf8 is true will all
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index ee90ae6b15..b940040c45 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -922,11 +922,9 @@ void ml_recover(bool checkext)
     b0p = hp->bh_data;
   }
 
-  /*
-   * If .swp file name given directly, use name from swap file for buffer.
-   */
+  // If .swp file name given directly, use name from swap file for buffer.
   if (directly) {
-    expand_env(b0p->b0_fname, (char_u *)NameBuff, MAXPATHL);
+    expand_env((char *)b0p->b0_fname, NameBuff, MAXPATHL);
     if (setfname(curbuf, (char *)NameBuff, NULL, true) == FAIL) {
       goto theend;
     }
@@ -1873,7 +1871,7 @@ errorret:
         // when the GUI redraws part of the text.
         recursive++;
         get_trans_bufname(buf);
-        shorten_dir((char_u *)NameBuff);
+        shorten_dir(NameBuff);
         siemsg(_("E316: ml_get: cannot find line %" PRId64 " in buffer %d %s"),
                (int64_t)lnum, buf->b_fnum, NameBuff);
         recursive--;
@@ -3472,7 +3470,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
                 // Symlinks may point to the same file even
                 // when the name differs, need to check the
                 // inode too.
-                expand_env(b0.b0_fname, (char_u *)NameBuff, MAXPATHL);
+                expand_env((char *)b0.b0_fname, NameBuff, MAXPATHL);
                 if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
                                  char_to_long(b0.b0_ino))) {
                   differ = true;
@@ -3481,7 +3479,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             } else {
               // The name in the swap file may be
               // "~user/path/file".  Expand it first.
-              expand_env(b0.b0_fname, (char_u *)NameBuff, MAXPATHL);
+              expand_env((char *)b0.b0_fname, NameBuff, MAXPATHL);
               if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
                                char_to_long(b0.b0_ino))) {
                 differ = true;
diff --git a/src/nvim/message.c b/src/nvim/message.c
index fbf9c9b603..7b198371c5 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -305,7 +305,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 
   // Skip messages not match ":filter pattern".
   // Don't filter when there is an error.
-  if (!emsg_on_display && message_filtered((char_u *)s)) {
+  if (!emsg_on_display && message_filtered((char *)s)) {
     return true;
   }
 
@@ -1990,7 +1990,7 @@ static char_u *screen_puts_mbyte(char_u *s, int l, int attr)
     return s;
   }
 
-  grid_puts_len(&msg_grid_adj, s, l, msg_row, msg_col, attr);
+  grid_puts_len(&msg_grid_adj, (char *)s, l, msg_row, msg_col, attr);
   if (cmdmsg_rl) {
     msg_col -= cw;
     if (msg_col == 0) {
@@ -2353,13 +2353,13 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
 /// @return  true when ":filter pattern" was used and "msg" does not match
 ///          "pattern".
-bool message_filtered(char_u *msg)
+bool message_filtered(char *msg)
 {
   if (cmdmod.cmod_filter_regmatch.regprog == NULL) {
     return false;
   }
 
-  bool match = vim_regexec(&cmdmod.cmod_filter_regmatch, (char *)msg, (colnr_T)0);
+  bool match = vim_regexec(&cmdmod.cmod_filter_regmatch, msg, (colnr_T)0);
   return cmdmod.cmod_filter_force ? match : !match;
 }
 
@@ -2703,8 +2703,7 @@ static void t_puts(int *t_col, const char_u *t_s, const char_u *s, int attr)
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), attr);
   // Output postponed text.
   msg_didout = true;  // Remember that line is not empty.
-  grid_puts_len(&msg_grid_adj, (char_u *)t_s, (int)(s - t_s), msg_row, msg_col,
-                attr);
+  grid_puts_len(&msg_grid_adj, (char *)t_s, (int)(s - t_s), msg_row, msg_col, attr);
   msg_col += *t_col;
   *t_col = 0;
   // If the string starts with a composing character don't increment the
@@ -3083,10 +3082,9 @@ void msg_moremsg(int full)
   char_u *s = (char_u *)_("-- More --");
 
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), HL_ATTR(HLF_M));
-  grid_puts(&msg_grid_adj, s, Rows - 1, 0, attr);
+  grid_puts(&msg_grid_adj, (char *)s, Rows - 1, 0, attr);
   if (full) {
-    grid_puts(&msg_grid_adj, (char_u *)
-              _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
+    grid_puts(&msg_grid_adj, _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
               Rows - 1, vim_strsize((char *)s), attr);
   }
 }
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 8c5b1a033c..6430070f1b 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2718,8 +2718,6 @@ void clear_showcmd(void)
 /// @return  true if output has been written (and setcursor() has been called).
 bool add_to_showcmd(int c)
 {
-  char_u *p;
-  int i;
   static int ignore[] = {
     K_IGNORE,
     K_LEFTMOUSE, K_LEFTDRAG, K_LEFTRELEASE, K_MOUSEMOVE,
@@ -2742,14 +2740,14 @@ bool add_to_showcmd(int c)
 
   // Ignore keys that are scrollbar updates and mouse clicks
   if (IS_SPECIAL(c)) {
-    for (i = 0; ignore[i] != 0; i++) {
+    for (int i = 0; ignore[i] != 0; i++) {
       if (ignore[i] == c) {
         return false;
       }
     }
   }
 
-  p = transchar(c);
+  char *p = (char *)transchar(c);
   if (*p == ' ') {
     STRCPY(p, "<20>");
   }
@@ -2845,12 +2843,12 @@ static void display_showcmd(void)
   grid_puts_line_start(&msg_grid_adj, showcmd_row);
 
   if (!showcmd_is_clear) {
-    grid_puts(&msg_grid_adj, showcmd_buf, showcmd_row, sc_col,
+    grid_puts(&msg_grid_adj, (char *)showcmd_buf, showcmd_row, sc_col,
               HL_ATTR(HLF_MSG));
   }
 
   // clear the rest of an old message by outputting up to SHOWCMD_COLS spaces
-  grid_puts(&msg_grid_adj, (char_u *)"          " + len, showcmd_row,
+  grid_puts(&msg_grid_adj, (char *)"          " + len, showcmd_row,
             sc_col + len, HL_ATTR(HLF_MSG));
 
   grid_puts_line_flush(false);
@@ -4392,8 +4390,7 @@ static void nv_ident(cmdarg_T *cap)
     init_history();
     add_to_history(HIST_SEARCH, (char_u *)buf, true, NUL);
 
-    (void)normal_search(cap, cmdchar == '*' ? '/' : '?', (char_u *)buf, 0,
-                        NULL);
+    (void)normal_search(cap, cmdchar == '*' ? '/' : '?', buf, 0, NULL);
   } else {
     g_tag_at_cursor = true;
     do_cmdline_cmd(buf);
@@ -4813,7 +4810,7 @@ static void nv_search(cmdarg_T *cap)
     return;
   }
 
-  (void)normal_search(cap, cap->cmdchar, (char_u *)cap->searchbuf,
+  (void)normal_search(cap, cap->cmdchar, cap->searchbuf,
                       (cap->arg || !equalpos(save_cursor, curwin->w_cursor))
                       ? 0 : SEARCH_MARK, NULL);
 }
@@ -4842,9 +4839,8 @@ static void nv_next(cmdarg_T *cap)
 /// @param opt  extra flags for do_search()
 ///
 /// @return 0 for failure, 1 for found, 2 for found and line offset added.
-static int normal_search(cmdarg_T *cap, int dir, char_u *pat, int opt, int *wrapped)
+static int normal_search(cmdarg_T *cap, int dir, char *pat, int opt, int *wrapped)
 {
-  int i;
   searchit_arg_T sia;
 
   cap->oap->motion_type = kMTCharWise;
@@ -4853,8 +4849,8 @@ static int normal_search(cmdarg_T *cap, int dir, char_u *pat, int opt, int *wrap
   curwin->w_set_curswant = true;
 
   CLEAR_FIELD(sia);
-  i = do_search(cap->oap, dir, dir, pat, cap->count1,
-                opt | SEARCH_OPT | SEARCH_ECHO | SEARCH_MSG, &sia);
+  int i = do_search(cap->oap, dir, dir, (char_u *)pat, cap->count1,
+                    opt | SEARCH_OPT | SEARCH_ECHO | SEARCH_MSG, &sia);
   if (wrapped != NULL) {
     *wrapped = sia.sa_wrapped;
   }
@@ -5625,7 +5621,7 @@ static MarkMoveRes nv_mark_move_to(cmdarg_T *cap, MarkMove flags, fmark_T *fm)
 /// Handle commands that are operators in Visual mode.
 static void v_visop(cmdarg_T *cap)
 {
-  static char_u trans[] = "YyDdCcxdXdAAIIrr";
+  static char trans[] = "YyDdCcxdXdAAIIrr";
 
   // Uppercase means linewise, except in block mode, then "D" deletes till
   // the end of the line, and "C" replaces till EOL
@@ -5637,7 +5633,7 @@ static void v_visop(cmdarg_T *cap)
       curwin->w_curswant = MAXCOL;
     }
   }
-  cap->cmdchar = (uint8_t)(*(vim_strchr((char *)trans, cap->cmdchar) + 1));
+  cap->cmdchar = (uint8_t)(*(vim_strchr(trans, cap->cmdchar) + 1));
   nv_operator(cap);
 }
 
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 092487fd3e..7b6f9e6370 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -3839,7 +3839,7 @@ void ex_display(exarg_T *eap)
       bool do_show = false;
 
       for (size_t j = 0; !do_show && j < yb->y_size; j++) {
-        do_show = !message_filtered((char_u *)yb->y_array[j]);
+        do_show = !message_filtered(yb->y_array[j]);
       }
 
       if (do_show || yb->y_size == 0) {
@@ -3876,14 +3876,14 @@ void ex_display(exarg_T *eap)
   // display last inserted text
   if ((p = get_last_insert()) != NULL
       && (arg == NULL || vim_strchr((char *)arg, '.') != NULL) && !got_int
-      && !message_filtered(p)) {
+      && !message_filtered((char *)p)) {
     msg_puts("\n  c  \".   ");
     dis_msg(p, true);
   }
 
   // display last command line
   if (last_cmdline != NULL && (arg == NULL || vim_strchr((char *)arg, ':') != NULL)
-      && !got_int && !message_filtered((char_u *)last_cmdline)) {
+      && !got_int && !message_filtered(last_cmdline)) {
     msg_puts("\n  c  \":   ");
     dis_msg((char_u *)last_cmdline, false);
   }
@@ -3891,7 +3891,7 @@ void ex_display(exarg_T *eap)
   // display current file name
   if (curbuf->b_fname != NULL
       && (arg == NULL || vim_strchr((char *)arg, '%') != NULL) && !got_int
-      && !message_filtered((char_u *)curbuf->b_fname)) {
+      && !message_filtered(curbuf->b_fname)) {
     msg_puts("\n  c  \"%   ");
     dis_msg((char_u *)curbuf->b_fname, false);
   }
@@ -3901,7 +3901,7 @@ void ex_display(exarg_T *eap)
     char *fname;
     linenr_T dummy;
 
-    if (buflist_name_nr(0, &fname, &dummy) != FAIL && !message_filtered((char_u *)fname)) {
+    if (buflist_name_nr(0, &fname, &dummy) != FAIL && !message_filtered(fname)) {
       msg_puts("\n  c  \"#   ");
       dis_msg((char_u *)fname, false);
     }
@@ -3910,14 +3910,14 @@ void ex_display(exarg_T *eap)
   // display last search pattern
   if (last_search_pat() != NULL
       && (arg == NULL || vim_strchr((char *)arg, '/') != NULL) && !got_int
-      && !message_filtered(last_search_pat())) {
+      && !message_filtered((char *)last_search_pat())) {
     msg_puts("\n  c  \"/   ");
     dis_msg(last_search_pat(), false);
   }
 
   // display last used expression
   if (expr_line != NULL && (arg == NULL || vim_strchr((char *)arg, '=') != NULL)
-      && !got_int && !message_filtered(expr_line)) {
+      && !got_int && !message_filtered((char *)expr_line)) {
     msg_puts("\n  c  \"=   ");
     dis_msg(expr_line, false);
   }
@@ -4802,7 +4802,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     }
     *ptr = NUL;
     STRCAT(buf1, buf2);
-    ins_str(buf1);              // insert the new number
+    ins_str((char *)buf1);              // insert the new number
     endpos = curwin->w_cursor;
     if (curwin->w_cursor.col) {
       curwin->w_cursor.col--;
diff --git a/src/nvim/option.c b/src/nvim/option.c
index c3f803e543..f9b32d50af 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -3299,7 +3299,7 @@ static void showoptions(int all, int opt_flags)
     item_count = 0;
     for (p = &options[0]; p->fullname != NULL; p++) {
       // apply :filter /pat/
-      if (message_filtered((char_u *)p->fullname)) {
+      if (message_filtered(p->fullname)) {
         continue;
       }
 
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index ea9a803a86..274e13e3c6 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -553,9 +553,9 @@ char_u *expand_env_save_opt(char_u *src, bool one)
 /// @param src        Input string e.g. "$HOME/vim.hlp"
 /// @param dst[out]   Where to put the result
 /// @param dstlen     Maximum length of the result
-void expand_env(char_u *src, char_u *dst, int dstlen)
+void expand_env(char *src, char *dst, int dstlen)
 {
-  expand_env_esc(src, dst, dstlen, false, false, NULL);
+  expand_env_esc((char_u *)src, (char_u *)dst, dstlen, false, false, NULL);
 }
 
 /// Expand environment variable with path name and escaping.
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index 0d62a5f5f9..dc96c39d25 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -911,7 +911,7 @@ int os_mkdir_recurse(const char *const dir, int32_t mode, char **const failed_di
   // We're done when it's "/" or "c:/".
   const size_t dirlen = strlen(dir);
   char *const curdir = xmemdupz(dir, dirlen);
-  char *const past_head = (char *)get_past_head((char_u *)curdir);
+  char *const past_head = get_past_head(curdir);
   char *e = curdir + dirlen;
   const char *const real_end = e;
   const char past_head_save = *past_head;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index d786ccbf73..e40729b114 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -62,7 +62,7 @@ FileComparison path_full_compare(char *const s1, char *const s2, const bool chec
   FileID file_id_1, file_id_2;
 
   if (expandenv) {
-    expand_env((char_u *)s1, (char_u *)exp1, MAXPATHL);
+    expand_env(s1, exp1, MAXPATHL);
   } else {
     STRLCPY(exp1, s1, MAXPATHL);
   }
@@ -104,7 +104,7 @@ char *path_tail(const char *fname)
     return "";
   }
 
-  const char *tail = (char *)get_past_head((char_u *)fname);
+  const char *tail = get_past_head(fname);
   const char *p = tail;
   // Find last part of path.
   while (*p != NUL) {
@@ -130,7 +130,7 @@ char *path_tail_with_sep(char *fname)
   assert(fname != NULL);
 
   // Don't remove the '/' from "c:/file".
-  char *past_head = (char *)get_past_head((char_u *)fname);
+  char *past_head = get_past_head(fname);
   char *tail = path_tail(fname);
   while (tail > past_head && after_pathsep(fname, tail)) {
     tail--;
@@ -150,7 +150,7 @@ char *path_tail_with_sep(char *fname)
 const char_u *invocation_path_tail(const char_u *invocation, size_t *len)
     FUNC_ATTR_NONNULL_RET FUNC_ATTR_NONNULL_ARG(1)
 {
-  const char_u *tail = get_past_head((char_u *)invocation);
+  const char_u *tail = (char_u *)get_past_head((char *)invocation);
   const char_u *p = tail;
   while (*p != NUL && *p != ' ') {
     bool was_sep = vim_ispathsep_nocolon(*p);
@@ -215,13 +215,13 @@ bool is_path_head(const char_u *path)
 /// Get a pointer to one character past the head of a path name.
 /// Unix: after "/"; Win: after "c:\"
 /// If there is no head, path is returned.
-char_u *get_past_head(const char_u *path)
+char *get_past_head(const char *path)
 {
-  const char_u *retval = path;
+  const char *retval = path;
 
 #ifdef WIN32
   // May skip "c:"
-  if (is_path_head(path)) {
+  if (is_path_head((char_u *)path)) {
     retval = path + 2;
   }
 #endif
@@ -230,7 +230,7 @@ char_u *get_past_head(const char_u *path)
     retval++;
   }
 
-  return (char_u *)retval;
+  return (char *)retval;
 }
 
 /// Return true if 'c' is a path separator.
@@ -310,9 +310,9 @@ void shorten_dir_len(char_u *str, int trim_len)
 
 /// Shorten the path of a file from "~/foo/../.bar/fname" to "~/f/../.b/fname"
 /// It's done in-place.
-void shorten_dir(char_u *str)
+void shorten_dir(char *str)
 {
-  shorten_dir_len(str, 1);
+  shorten_dir_len((char_u *)str, 1);
 }
 
 /// Return true if the directory of "fname" exists, false otherwise.
@@ -631,7 +631,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   while (*path_end != NUL) {
     /* May ignore a wildcard that has a backslash before it; it will
      * be removed by rem_backslash() or file_pat_to_reg_pat() below. */
-    if (path_end >= path + wildoff && rem_backslash(path_end)) {
+    if (path_end >= path + wildoff && rem_backslash((char *)path_end)) {
       *p++ = *path_end++;
     } else if (vim_ispathsep_nocolon(*path_end)) {
       if (e != NULL) {
@@ -658,7 +658,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   /* Remove backslashes between "wildoff" and the start of the wildcard
    * component. */
   for (p = buf + wildoff; p < s; p++) {
-    if (rem_backslash(p)) {
+    if (rem_backslash((char *)p)) {
       STRMOVE(p, p + 1);
       e--;
       s--;
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index f13e83ca9b..11b6951edd 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -233,7 +233,7 @@ int win_chartabsize(win_T *wp, char *p, colnr_T col)
   if (*p == TAB && (!wp->w_p_list || wp->w_p_lcs_chars.tab1)) {
     return tabstop_padding(col, buf->b_p_ts, buf->b_p_vts_array);
   } else {
-    return ptr2cells((char *)p);
+    return ptr2cells(p);
   }
 }
 
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index 529e351f33..b144348188 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -542,14 +542,13 @@ void pum_redraw(void)
                   size++;
                 }
               }
-              grid_puts_len(&pum_grid, (char_u *)rt, (int)STRLEN(rt), row,
-                            grid_col - size + 1, attr);
+              grid_puts_len(&pum_grid, rt, (int)STRLEN(rt), row, grid_col - size + 1, attr);
               xfree(rt_start);
               xfree(st);
               grid_col -= width;
             } else {
               // use grid_puts_len() to truncate the text
-              grid_puts(&pum_grid, st, row, grid_col, attr);
+              grid_puts(&pum_grid, (char *)st, row, grid_col, attr);
               xfree(st);
               grid_col += width;
             }
@@ -560,11 +559,11 @@ void pum_redraw(void)
 
             // Display two spaces for a Tab.
             if (pum_rl) {
-              grid_puts_len(&pum_grid, (char_u *)"  ", 2, row, grid_col - 1,
+              grid_puts_len(&pum_grid, "  ", 2, row, grid_col - 1,
                             attr);
               grid_col -= 2;
             } else {
-              grid_puts_len(&pum_grid, (char_u *)"  ", 2, row, grid_col, attr);
+              grid_puts_len(&pum_grid, "  ", 2, row, grid_col, attr);
               grid_col += 2;
             }
             totwidth += 2;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 53bb17364e..20e6893ea5 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1000,7 +1000,7 @@ static int qf_setup_state(qfstate_T *pstate, char *restrict enc, const char *res
 {
   pstate->vc.vc_type = CONV_NONE;
   if (enc != NULL && *enc != NUL) {
-    convert_setup(&pstate->vc, (char_u *)enc, (char_u *)p_enc);
+    convert_setup(&pstate->vc, enc, p_enc);
   }
 
   if (efile != NULL
@@ -1244,7 +1244,7 @@ static int qf_parse_fmt_f(regmatch_T *rmp, int midx, qffields_T *fields, int pre
   // Expand ~/file and $HOME/file to full path.
   char c = (char)(*rmp->endp[midx]);
   *rmp->endp[midx] = NUL;
-  expand_env(rmp->startp[midx], (char_u *)fields->namebuf, CMDBUFFSIZE);
+  expand_env((char *)rmp->startp[midx], fields->namebuf, CMDBUFFSIZE);
   *rmp->endp[midx] = (char_u)c;
 
   // For separate filename patterns (%O, %P and %Q), the specified file
@@ -3038,16 +3038,16 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   // text of the entry.
   bool filter_entry = true;
   if (qfp->qf_module != NULL && *qfp->qf_module != NUL) {
-    filter_entry &= message_filtered((char_u *)qfp->qf_module);
+    filter_entry &= message_filtered(qfp->qf_module);
   }
   if (filter_entry && fname != NULL) {
-    filter_entry &= message_filtered((char_u *)fname);
+    filter_entry &= message_filtered(fname);
   }
   if (filter_entry && qfp->qf_pattern != NULL) {
-    filter_entry &= message_filtered((char_u *)qfp->qf_pattern);
+    filter_entry &= message_filtered(qfp->qf_pattern);
   }
   if (filter_entry) {
-    filter_entry &= message_filtered((char_u *)qfp->qf_text);
+    filter_entry &= message_filtered(qfp->qf_text);
   }
   if (filter_entry) {
     return;
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index 75bd7b4cc1..a52343e28b 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -488,10 +488,10 @@ static char_u *skip_anyof(char *p)
 /// When "newp" is not NULL and "dirc" is '?', make an allocated copy of the
 /// expression and change "\?" to "?".  If "*newp" is not NULL the expression
 /// is changed in-place.
-char_u *skip_regexp(char_u *startp, int dirc, int magic, char **newp)
+char *skip_regexp(char *startp, int dirc, int magic, char **newp)
 {
   int mymagic;
-  char_u *p = startp;
+  char *p = startp;
 
   if (magic) {
     mymagic = MAGIC_ON;
@@ -506,7 +506,7 @@ char_u *skip_regexp(char_u *startp, int dirc, int magic, char **newp)
     }
     if ((p[0] == '[' && mymagic >= MAGIC_ON)
         || (p[0] == '\\' && p[1] == '[' && mymagic <= MAGIC_OFF)) {
-      p = skip_anyof((char *)p + 1);
+      p = (char *)skip_anyof(p + 1);
       if (p[0] == NUL) {
         break;
       }
@@ -514,8 +514,8 @@ char_u *skip_regexp(char_u *startp, int dirc, int magic, char **newp)
       if (dirc == '?' && newp != NULL && p[1] == '?') {
         // change "\?" to "?", make a copy first.
         if (*newp == NULL) {
-          *newp = (char *)vim_strsave(startp);
-          p = (char_u *)(*newp) + (p - startp);
+          *newp = xstrdup(startp);
+          p = *newp + (p - startp);
         }
         STRMOVE(p, p + 1);
       } else {
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 25f85b6193..41056a2773 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -815,15 +815,21 @@ static void source_all_matches(char *pat)
 /// @param is_pack whether the added dir is a "pack/*/start/*/" style package
 static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
 {
-  char_u *p4, *p3, *p2, *p1, *p;
-  char_u *buf = NULL;
+  char *p;
+  char *buf = NULL;
   char *afterdir = NULL;
   int retval = FAIL;
 
-  p4 = p3 = p2 = p1 = get_past_head(fname);
+  char *p1 = get_past_head((char *)fname);
+  char *p2 = p1;
+  char *p3 = p1;
+  char *p4 = p1;
   for (p = p1; *p; MB_PTR_ADV(p)) {
     if (vim_ispathsep_nocolon(*p)) {
-      p4 = p3; p3 = p2; p2 = p1; p1 = p;
+      p4 = p3;
+      p3 = p2;
+      p2 = p1;
+      p1 = p;
     }
   }
 
@@ -833,7 +839,7 @@ static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
   //
   // find the part up to "pack" in 'runtimepath'
   p4++;  // append pathsep in order to expand symlink
-  char_u c = *p4;
+  char c = *p4;
   *p4 = NUL;
   char *const ffname = fix_fname((char *)fname);
   *p4 = c;
@@ -854,10 +860,10 @@ static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
   for (const char *entry = (const char *)p_rtp; *entry != NUL;) {
     const char *cur_entry = entry;
 
-    copy_option_part((char **)&entry, (char *)buf, MAXPATHL, ",");
+    copy_option_part((char **)&entry, buf, MAXPATHL, ",");
     if (insp == NULL) {
-      add_pathsep((char *)buf);
-      char *const rtp_ffname = fix_fname((char *)buf);
+      add_pathsep(buf);
+      char *const rtp_ffname = fix_fname(buf);
       if (rtp_ffname == NULL) {
         goto theend;
       }
@@ -869,7 +875,7 @@ static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
       }
     }
 
-    if ((p = (char_u *)strstr((char *)buf, "after")) != NULL
+    if ((p = strstr(buf, "after")) != NULL
         && p > buf
         && vim_ispathsep(p[-1])
         && (vim_ispathsep(p[5]) || p[5] == NUL || p[5] == ',')) {
@@ -2018,7 +2024,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
     if (firstline != NULL && STRLEN(firstline) >= 3 && firstline[0] == 0xef
         && firstline[1] == 0xbb && firstline[2] == 0xbf) {
       // Found BOM; setup conversion, skip over BOM and recode the line.
-      convert_setup(&cookie.conv, (char_u *)"utf-8", (char_u *)p_enc);
+      convert_setup(&cookie.conv, "utf-8", p_enc);
       p = (char *)string_convert(&cookie.conv, (char_u *)firstline + 3, NULL);
       if (p == NULL) {
         p = xstrdup((char *)firstline + 3);
@@ -2149,7 +2155,7 @@ void ex_scriptnames(exarg_T *eap)
     if (SCRIPT_ITEM(i).sn_name != NULL) {
       home_replace(NULL, (char *)SCRIPT_ITEM(i).sn_name, (char *)NameBuff, MAXPATHL, true);
       vim_snprintf((char *)IObuff, IOSIZE, "%3d: %s", i, NameBuff);
-      if (!message_filtered(IObuff)) {
+      if (!message_filtered((char *)IObuff)) {
         msg_putchar('\n');
         msg_outtrans((char *)IObuff);
         line_breakcheck();
@@ -2439,7 +2445,7 @@ void ex_scriptencoding(exarg_T *eap)
 
   // Setup for conversion from the specified encoding to 'encoding'.
   sp = (struct source_cookie *)getline_cookie(eap->getline, eap->cookie);
-  convert_setup(&sp->conv, (char_u *)name, (char_u *)p_enc);
+  convert_setup(&sp->conv, name, p_enc);
 
   if (name != eap->arg) {
     xfree(name);
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 3258dc11d6..6efaae3725 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -277,7 +277,7 @@ static int wildmenu_match_len(expand_T *xp, char_u *s)
 /// These are backslashes used for escaping.  Do show backslashes in help tags.
 static int skip_wildmenu_char(expand_T *xp, char_u *s)
 {
-  if ((rem_backslash(s) && xp->xp_context != EXPAND_HELP)
+  if ((rem_backslash((char *)s) && xp->xp_context != EXPAND_HELP)
       || ((xp->xp_context == EXPAND_MENUS
            || xp->xp_context == EXPAND_MENUNAMES)
           && (s[0] == '\t'
@@ -469,10 +469,10 @@ void redraw_wildmenu(expand_T *xp, int num_matches, char **matches, int match, i
     ScreenGrid *grid = (wild_menu_showing == WM_SCROLLED)
                         ? &msg_grid_adj : &default_grid;
 
-    grid_puts(grid, buf, row, 0, attr);
+    grid_puts(grid, (char *)buf, row, 0, attr);
     if (selstart != NULL && highlight) {
       *selend = NUL;
-      grid_puts(grid, selstart, row, selstart_col, HL_ATTR(HLF_WM));
+      grid_puts(grid, (char *)selstart, row, selstart_col, HL_ATTR(HLF_WM));
     }
 
     grid_fill(grid, row, row + 1, clen, Columns,
@@ -1026,12 +1026,12 @@ void draw_tabline(void)
           if (col + len >= Columns - 3) {
             break;
           }
-          grid_puts_len(&default_grid, (char_u *)NameBuff, len, 0, col,
+          grid_puts_len(&default_grid, NameBuff, len, 0, col,
                         hl_combine_attr(attr, win_hl_attr(cwp, HLF_T)));
           col += len;
         }
         if (modified) {
-          grid_puts_len(&default_grid, (char_u *)"+", 1, 0, col++, attr);
+          grid_puts_len(&default_grid, "+", 1, 0, col++, attr);
         }
         grid_putchar(&default_grid, ' ', 0, col++, attr);
       }
@@ -1040,7 +1040,7 @@ void draw_tabline(void)
       if (room > 0) {
         // Get buffer name in NameBuff[]
         get_trans_bufname(cwp->w_buffer);
-        shorten_dir((char_u *)NameBuff);
+        shorten_dir(NameBuff);
         len = vim_strsize((char *)NameBuff);
         p = (char_u *)NameBuff;
         while (len > room) {
@@ -1051,7 +1051,7 @@ void draw_tabline(void)
           len = Columns - col - 1;
         }
 
-        grid_puts_len(&default_grid, p, (int)STRLEN(p), 0, col, attr);
+        grid_puts_len(&default_grid, (char *)p, (int)STRLEN(p), 0, col, attr);
         col += len;
       }
       grid_putchar(&default_grid, ' ', 0, col++, attr);
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 892d531633..c1c2f0dbe9 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1124,7 +1124,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
        * If there is a matching '/' or '?', toss it.
        */
       ps = (char_u *)strcopy;
-      p = skip_regexp(pat, search_delim, p_magic, &strcopy);
+      p = (char_u *)skip_regexp((char *)pat, search_delim, p_magic, &strcopy);
       if (strcopy != (char *)ps) {
         // made a copy of "pat" to change "\?" to "?"
         searchcmdlen += (int)(STRLEN(pat) - STRLEN(strcopy));
@@ -1977,7 +1977,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 
   // backward search: Check if this line contains a single-line comment
   if ((backwards && comment_dir) || lisp) {
-    comment_col = check_linecomment(linep);
+    comment_col = check_linecomment((char *)linep);
   }
   if (lisp && comment_col != MAXCOL && pos.col > (colnr_T)comment_col) {
     lispcomm = true;        // find match inside this comment
@@ -2010,7 +2010,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 
         // Check if this line contains a single-line comment
         if (comment_dir || lisp) {
-          comment_col = check_linecomment(linep);
+          comment_col = check_linecomment((char *)linep);
         }
         // skip comment
         if (lisp && comment_col != MAXCOL) {
@@ -2043,7 +2043,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
         do_quotes = -1;
         line_breakcheck();
         if (lisp) {         // find comment pos in new line
-          comment_col = check_linecomment(linep);
+          comment_col = check_linecomment((char *)linep);
         }
       } else {
         pos.col += utfc_ptr2len((char *)linep + pos.col);
@@ -2301,15 +2301,15 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 
 /// Check if line[] contains a / / comment.
 /// @returns MAXCOL if not, otherwise return the column.
-int check_linecomment(const char_u *line)
+int check_linecomment(const char *line)
 {
-  const char_u *p = line;  // scan from start
+  const char *p = line;  // scan from start
   // skip Lispish one-line comments
   if (curbuf->b_p_lisp) {
     if (vim_strchr((char *)p, ';') != NULL) {   // there may be comments
       bool in_str = false;       // inside of string
 
-      while ((p = (char_u *)strpbrk((char *)p, "\";")) != NULL) {
+      while ((p = strpbrk((char *)p, "\";")) != NULL) {
         if (*p == '"') {
           if (in_str) {
             if (*(p - 1) != '\\') {             // skip escaped quote
@@ -2322,7 +2322,7 @@ int check_linecomment(const char_u *line)
           }
         } else if (!in_str && ((p - line) < 2
                                || (*(p - 1) != '\\' && *(p - 2) != '#'))
-                   && !is_pos_in_string(line, (colnr_T)(p - line))) {
+                   && !is_pos_in_string((char_u *)line, (colnr_T)(p - line))) {
           break;                // found!
         }
         p++;
@@ -2331,12 +2331,12 @@ int check_linecomment(const char_u *line)
       p = NULL;
     }
   } else {
-    while ((p = (char_u *)vim_strchr((char *)p, '/')) != NULL) {
+    while ((p = vim_strchr((char *)p, '/')) != NULL) {
       // Accept a double /, unless it's preceded with * and followed by *,
       // because * / / * is an end and start of a C comment.  Only
       // accept the position if it is not inside a string.
       if (p[1] == '/' && (p == line || p[-1] != '*' || p[2] != '*')
-          && !is_pos_in_string(line, (colnr_T)(p - line))) {
+          && !is_pos_in_string((char_u *)line, (colnr_T)(p - line))) {
         break;
       }
       p++;
@@ -3536,7 +3536,6 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
   int i;
   char_u *already = NULL;
   char_u *startp = NULL;
-  char_u *inc_opt = NULL;
   win_T *curwin_save = NULL;
   const int l_g_do_tagpreview = g_do_tagpreview;
 
@@ -3561,9 +3560,9 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
       goto fpip_end;
     }
   }
-  inc_opt = (*curbuf->b_p_inc == NUL) ? (char_u *)p_inc : (char_u *)curbuf->b_p_inc;
+  char *inc_opt = (*curbuf->b_p_inc == NUL) ? p_inc : curbuf->b_p_inc;
   if (*inc_opt != NUL) {
-    incl_regmatch.regprog = vim_regcomp((char *)inc_opt, p_magic ? RE_MAGIC : 0);
+    incl_regmatch.regprog = vim_regcomp(inc_opt, p_magic ? RE_MAGIC : 0);
     if (incl_regmatch.regprog == NULL) {
       goto fpip_end;
     }
@@ -3597,7 +3596,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
       char_u *p_fname = (curr_fname == (char_u *)curbuf->b_fname)
                         ? (char_u *)curbuf->b_ffname : curr_fname;
 
-      if (inc_opt != NULL && strstr((char *)inc_opt, "\\zs") != NULL) {
+      if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) {
         // Use text from '\zs' to '\ze' (or end) of 'include'.
         new_fname = find_file_name_in_path(incl_regmatch.startp[0],
                                            (size_t)(incl_regmatch.endp[0]
@@ -3674,7 +3673,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
              * Include the surrounding "" or <> if present.
              */
             if (inc_opt != NULL
-                && strstr((char *)inc_opt, "\\zs") != NULL) {
+                && strstr(inc_opt, "\\zs") != NULL) {
               // pattern contains \zs, use the match
               p = incl_regmatch.startp[0];
               i = (int)(incl_regmatch.endp[0]
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index b45a041d96..88ad7d519a 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1477,7 +1477,7 @@ static char *shada_filename(const char *file)
       //     because various expansions must have already be done by the shell.
       //     If shell is not performing them then they should be done in main.c
       //     where arguments are parsed, *not here*.
-      expand_env((char_u *)file, (char_u *)&(NameBuff[0]), MAXPATHL);
+      expand_env((char *)file, &(NameBuff[0]), MAXPATHL);
       file = (const char *)&(NameBuff[0]);
     }
   }
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 8d6307f123..33e8c5c099 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -2042,7 +2042,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   }
 
   vim_snprintf((char *)IObuff, IOSIZE, _("Reading affix file %s..."), fname);
-  spell_message(spin, IObuff);
+  spell_message(spin, (char *)IObuff);
 
   // Only do REP lines when not done in another .aff file already.
   do_rep = GA_EMPTY(&spin->si_rep);
@@ -2123,7 +2123,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         // Setup for conversion from "ENC" to 'encoding'.
         aff->af_enc = (char_u *)enc_canonize((char *)items[1]);
         if (!spin->si_ascii
-            && convert_setup(&spin->si_conv, aff->af_enc, (char_u *)p_enc) == FAIL) {
+            && convert_setup(&spin->si_conv, (char *)aff->af_enc, p_enc) == FAIL) {
           smsg(_("Conversion in %s not supported: from %s to %s"),
                fname, aff->af_enc, p_enc);
         }
@@ -3123,7 +3123,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
 
   vim_snprintf((char *)IObuff, IOSIZE,
                _("Reading dictionary file %s..."), fname);
-  spell_message(spin, IObuff);
+  spell_message(spin, (char *)IObuff);
 
   // start with a message for the first line
   spin->si_msg_count = 999999;
@@ -3676,7 +3676,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
   }
 
   vim_snprintf((char *)IObuff, IOSIZE, _("Reading word file %s..."), fname);
-  spell_message(spin, IObuff);
+  spell_message(spin, (char *)IObuff);
 
   // Read all the lines in the file one by one.
   while (!vim_fgets(rline, MAXLINELEN, fd) && !got_int) {
@@ -3723,13 +3723,13 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
           smsg(_("/encoding= line after word ignored in %s line %ld: %s"),
                fname, lnum, line - 1);
         } else {
-          char_u *enc;
+          char *enc;
 
           // Setup for conversion to 'encoding'.
           line += 9;
-          enc = (char_u *)enc_canonize((char *)line);
+          enc = enc_canonize((char *)line);
           if (!spin->si_ascii
-              && convert_setup(&spin->si_conv, enc, (char_u *)p_enc) == FAIL) {
+              && convert_setup(&spin->si_conv, enc, p_enc) == FAIL) {
             smsg(_("Conversion in %s not supported: from %s to %s"),
                  fname, line, p_enc);
           }
@@ -3820,7 +3820,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
   if (spin->si_ascii && non_ascii > 0) {
     vim_snprintf((char *)IObuff, IOSIZE,
                  _("Ignored %d words with non-ASCII characters"), non_ascii);
-    spell_message(spin, IObuff);
+    spell_message(spin, (char *)IObuff);
   }
 
   return retval;
@@ -3894,13 +3894,13 @@ static wordnode_T *wordtree_alloc(spellinfo_T *spin)
 
 /// Return true if "word" contains valid word characters.
 /// Control characters and trailing '/' are invalid.  Space is OK.
-static bool valid_spell_word(const char_u *word, const char_u *end)
+static bool valid_spell_word(const char *word, const char *end)
 {
-  if (!utf_valid_string(word, end)) {
+  if (!utf_valid_string((char_u *)word, (char_u *)end)) {
     return false;
   }
-  for (const char_u *p = word; *p != NUL && p < end; p += utfc_ptr2len((const char *)p)) {
-    if (*p < ' ' || (p[0] == '/' && p[1] == NUL)) {
+  for (const char *p = word; *p != NUL && p < end; p += utfc_ptr2len(p)) {
+    if ((uint8_t)(*p) < ' ' || (p[0] == '/' && p[1] == NUL)) {
       return false;
     }
   }
@@ -3928,7 +3928,7 @@ static int store_word(spellinfo_T *spin, char_u *word, int flags, int region, co
   int res = OK;
 
   // Avoid adding illegal bytes to the word tree.
-  if (!valid_spell_word(word, word + len)) {
+  if (!valid_spell_word((char *)word, (char *)word + len)) {
     return FAIL;
   }
 
@@ -4213,7 +4213,7 @@ static void wordtree_compress(spellinfo_T *spin, wordnode_T *root, const char *n
       vim_snprintf((char *)IObuff, IOSIZE,
                    _("Compressed %s of %ld nodes; %ld (%ld%%) remaining"),
                    name, tot, tot - n, perc);
-      spell_message(spin, IObuff);
+      spell_message(spin, (char *)IObuff);
     }
 #ifdef SPELL_PRINTTREE
     spell_print_tree(root->wn_sibling);
@@ -4347,14 +4347,15 @@ static int rep_compare(const void *s1, const void *s2)
   return STRCMP(p1->ft_from, p2->ft_from);
 }
 
-// Write the Vim .spl file "fname".
-// Return OK/FAIL.
-static int write_vim_spell(spellinfo_T *spin, char_u *fname)
+/// Write the Vim .spl file "fname".
+///
+/// @return  OK/FAIL.
+static int write_vim_spell(spellinfo_T *spin, char *fname)
 {
   int retval = OK;
   int regionmask;
 
-  FILE *fd = os_fopen((char *)fname, "w");
+  FILE *fd = os_fopen(fname, "w");
   if (fd == NULL) {
     semsg(_(e_notopen), fname);
     return FAIL;
@@ -4893,7 +4894,7 @@ void ex_mkspell(exarg_T *eap)
 // Create the .sug file.
 // Uses the soundfold info in "spin".
 // Writes the file with the name "wfname", with ".spl" changed to ".sug".
-static void spell_make_sugfile(spellinfo_T *spin, char_u *wfname)
+static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
 {
   char_u *fname = NULL;
   int len;
@@ -4906,14 +4907,14 @@ static void spell_make_sugfile(spellinfo_T *spin, char_u *wfname)
   // of the code for the soundfolding stuff.
   // It might have been done already by spell_reload_one().
   for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-    if (path_full_compare((char *)wfname, (char *)slang->sl_fname, false, true)
+    if (path_full_compare(wfname, (char *)slang->sl_fname, false, true)
         == kEqualFiles) {
       break;
     }
   }
   if (slang == NULL) {
-    spell_message(spin, (char_u *)_("Reading back spell file..."));
-    slang = spell_load_file(wfname, NULL, NULL, false);
+    spell_message(spin, _("Reading back spell file..."));
+    slang = spell_load_file((char_u *)wfname, NULL, NULL, false);
     if (slang == NULL) {
       return;
     }
@@ -4930,7 +4931,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char_u *wfname)
 
   // Go through the trie of good words, soundfold each word and add it to
   // the soundfold trie.
-  spell_message(spin, (char_u *)_("Performing soundfolding..."));
+  spell_message(spin, _("Performing soundfolding..."));
   if (sug_filltree(spin, slang) == FAIL) {
     goto theend;
   }
@@ -4947,7 +4948,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char_u *wfname)
        (int64_t)spin->si_spellbuf->b_ml.ml_line_count);
 
   // Compress the soundfold trie.
-  spell_message(spin, (char_u *)_(msg_compressing));
+  spell_message(spin, _(msg_compressing));
   wordtree_compress(spin, spin->si_foldroot, "case-folded");
 
   // Write the .sug file.
@@ -5193,7 +5194,7 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
 
   vim_snprintf((char *)IObuff, IOSIZE,
                _("Writing suggestion file %s..."), fname);
-  spell_message(spin, IObuff);
+  spell_message(spin, (char *)IObuff);
 
   // <SUGHEADER>: <fileID> <versionnr> <timestamp>
   if (fwrite(VIMSUGMAGIC, VIMSUGMAGICL, (size_t)1, fd) != 1) {  // <fileID>
@@ -5249,7 +5250,7 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
 
   vim_snprintf((char *)IObuff, IOSIZE,
                _("Estimated runtime memory use: %d bytes"), spin->si_memtot);
-  spell_message(spin, IObuff);
+  spell_message(spin, (char *)IObuff);
 
 theend:
   // close the file
@@ -5268,7 +5269,6 @@ theend:
 static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool added_word)
 {
   char_u *fname = NULL;
-  char_u *wfname;
   char **innames;
   int incount;
   afffile_T *(afile[MAXREGIONS]);
@@ -5296,7 +5296,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
   innames = &fnames[fcount == 1 ? 0 : 1];
   incount = fcount - 1;
 
-  wfname = xmalloc(MAXPATHL);
+  char *wfname = xmalloc(MAXPATHL);
 
   if (fcount >= 1) {
     len = (int)STRLEN(fnames[0]);
@@ -5304,46 +5304,46 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       // For ":mkspell path/en.latin1.add" output file is
       // "path/en.latin1.add.spl".
       incount = 1;
-      vim_snprintf((char *)wfname, MAXPATHL, "%s.spl", fnames[0]);
+      vim_snprintf(wfname, MAXPATHL, "%s.spl", fnames[0]);
     } else if (fcount == 1) {
       // For ":mkspell path/vim" output file is "path/vim.latin1.spl".
       incount = 1;
-      vim_snprintf((char *)wfname, MAXPATHL, SPL_FNAME_TMPL,
+      vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
                    fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
     } else if (len > 4 && STRCMP(fnames[0] + len - 4, ".spl") == 0) {
       // Name ends in ".spl", use as the file name.
       STRLCPY(wfname, fnames[0], MAXPATHL);
     } else {
       // Name should be language, make the file name from it.
-      vim_snprintf((char *)wfname, MAXPATHL, SPL_FNAME_TMPL,
+      vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
                    fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
     }
 
     // Check for .ascii.spl.
-    if (strstr(path_tail((char *)wfname), SPL_FNAME_ASCII) != NULL) {
+    if (strstr(path_tail(wfname), SPL_FNAME_ASCII) != NULL) {
       spin.si_ascii = true;
     }
 
     // Check for .add.spl.
-    if (strstr(path_tail((char *)wfname), SPL_FNAME_ADD) != NULL) {
+    if (strstr(path_tail(wfname), SPL_FNAME_ADD) != NULL) {
       spin.si_add = true;
     }
   }
 
   if (incount <= 0) {
     emsg(_(e_invarg));          // need at least output and input names
-  } else if (vim_strchr(path_tail((char *)wfname), '_') != NULL) {
+  } else if (vim_strchr(path_tail(wfname), '_') != NULL) {
     emsg(_("E751: Output file name must not have region name"));
   } else if (incount > MAXREGIONS) {
     semsg(_("E754: Only up to %d regions supported"), MAXREGIONS);
   } else {
     // Check for overwriting before doing things that may take a lot of
     // time.
-    if (!over_write && os_path_exists(wfname)) {
+    if (!over_write && os_path_exists((char_u *)wfname)) {
       emsg(_(e_exists));
       goto theend;
     }
-    if (os_isdir(wfname)) {
+    if (os_isdir((char_u *)wfname)) {
       semsg(_(e_isadir2), wfname);
       goto theend;
     }
@@ -5421,7 +5421,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
     if (!error && !got_int) {
       // Combine tails in the tree.
-      spell_message(&spin, (char_u *)_(msg_compressing));
+      spell_message(&spin, _(msg_compressing));
       wordtree_compress(&spin, spin.si_foldroot, "case-folded");
       wordtree_compress(&spin, spin.si_keeproot, "keep-case");
       wordtree_compress(&spin, spin.si_prefroot, "prefixes");
@@ -5431,18 +5431,18 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       // Write the info in the spell file.
       vim_snprintf((char *)IObuff, IOSIZE,
                    _("Writing spell file %s..."), wfname);
-      spell_message(&spin, IObuff);
+      spell_message(&spin, (char *)IObuff);
 
       error = write_vim_spell(&spin, wfname) == FAIL;
 
-      spell_message(&spin, (char_u *)_("Done!"));
+      spell_message(&spin, _("Done!"));
       vim_snprintf((char *)IObuff, IOSIZE,
                    _("Estimated runtime memory use: %d bytes"), spin.si_memtot);
-      spell_message(&spin, IObuff);
+      spell_message(&spin, (char *)IObuff);
 
       // If the file is loaded need to reload it.
       if (!error) {
-        spell_reload_one(wfname, added_word);
+        spell_reload_one((char_u *)wfname, added_word);
       }
     }
 
@@ -5479,14 +5479,14 @@ theend:
 
 // Display a message for spell file processing when 'verbose' is set or using
 // ":mkspell".  "str" can be IObuff.
-static void spell_message(const spellinfo_T *spin, char_u *str)
+static void spell_message(const spellinfo_T *spin, char *str)
   FUNC_ATTR_NONNULL_ALL
 {
   if (spin->si_verbose || p_verbose > 2) {
     if (!spin->si_verbose) {
       verbose_enter();
     }
-    msg((char *)str);
+    msg(str);
     ui_flush();
     if (!spin->si_verbose) {
       verbose_leave();
@@ -5524,7 +5524,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
   int i;
   char_u *spf;
 
-  if (!valid_spell_word(word, word + len)) {
+  if (!valid_spell_word((char *)word, (char *)word + len)) {
     emsg(_(e_illegal_character_in_word));
     return;
   }
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index b9cddb7b94..9b441ba0a9 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -132,13 +132,13 @@ void win_redr_status(win_T *wp)
 
     row = is_stl_global ? (Rows - (int)p_ch - 1) : W_ENDROW(wp);
     col = is_stl_global ? 0 : wp->w_wincol;
-    grid_puts(&default_grid, p, row, col, attr);
+    grid_puts(&default_grid, (char *)p, row, col, attr);
     grid_fill(&default_grid, row, row + 1, len + col,
               this_ru_col + col, fillchar, fillchar, attr);
 
     if (get_keymap_str(wp, "<%s>", (char *)NameBuff, MAXPATHL)
         && this_ru_col - len > (int)(STRLEN(NameBuff) + 1)) {
-      grid_puts(&default_grid, (char_u *)NameBuff, row,
+      grid_puts(&default_grid, NameBuff, row,
                 (int)((size_t)this_ru_col - STRLEN(NameBuff) - 1), attr);
     }
 
@@ -342,7 +342,7 @@ void win_redr_ruler(win_T *wp, bool always)
       }
 
       ScreenGrid *grid = part_of_status ? &default_grid : &msg_grid_adj;
-      grid_puts(grid, (char_u *)buffer, row, this_ru_col + off, attr);
+      grid_puts(grid, buffer, row, this_ru_col + off, attr);
       grid_fill(grid, row, row + 1,
                 this_ru_col + off + (int)STRLEN(buffer), off + width, fillchar,
                 fillchar, attr);
@@ -571,8 +571,8 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   p = buf;
   for (n = 0; hltab[n].start != NULL; n++) {
     int textlen = (int)(hltab[n].start - p);
-    grid_puts_len(grid, (char_u *)p, textlen, row, col, curattr);
-    col += vim_strnsize((char_u *)p, textlen);
+    grid_puts_len(grid, p, textlen, row, col, curattr);
+    col += vim_strnsize(p, textlen);
     p = hltab[n].start;
 
     if (hltab[n].userhl == 0) {
@@ -586,8 +586,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
     }
   }
   // Make sure to use an empty string instead of p, if p is beyond buf + len.
-  grid_puts(grid, p >= buf + len ? (char_u *)"" : (char_u *)p, row, col,
-            curattr);
+  grid_puts(grid, p >= buf + len ? "" : p, row, col, curattr);
 
   grid_puts_line_flush(false);
 
@@ -608,7 +607,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
     .type = kStlClickDisabled,
   };
   for (n = 0; tabtab[n].start != NULL; n++) {
-    len += vim_strnsize((char_u *)p, (int)(tabtab[n].start - p));
+    len += vim_strnsize(p, (int)(tabtab[n].start - p));
     while (col < len) {
       click_defs[col++] = cur_click_def;
     }
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index ac9d414be2..bd0f122f99 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -104,7 +104,7 @@ char_u *vim_strsave_escaped_ext(const char_u *string, const char_u *esc_chars, c
       p += l - 1;
       continue;
     }
-    if (vim_strchr((char *)esc_chars, *p) != NULL || (bsl && rem_backslash(p))) {
+    if (vim_strchr((char *)esc_chars, *p) != NULL || (bsl && rem_backslash((char *)p))) {
       length++;                         // count a backslash
     }
     length++;                           // count an ordinary char
@@ -120,7 +120,7 @@ char_u *vim_strsave_escaped_ext(const char_u *string, const char_u *esc_chars, c
       p += l - 1;                     // skip multibyte char
       continue;
     }
-    if (vim_strchr((char *)esc_chars, *p) != NULL || (bsl && rem_backslash(p))) {
+    if (vim_strchr((char *)esc_chars, *p) != NULL || (bsl && rem_backslash((char *)p))) {
       *p2++ = cc;
     }
     *p2++ = *p;
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 187dc4eed4..e88b1b17f6 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -3008,7 +3008,7 @@ static void syn_cmd_conceal(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3037,7 +3037,7 @@ static void syn_cmd_case(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3064,7 +3064,7 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *arg_end;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3105,7 +3105,7 @@ static void syn_cmd_spell(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *next;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3312,7 +3312,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
   char_u *arg_end;
   int id;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -3465,7 +3465,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
   char_u *arg = (char_u *)eap->arg;
   char_u *arg_end;
 
-  eap->nextcmd = (char *)find_nextcmd(arg);
+  eap->nextcmd = find_nextcmd((char *)arg);
   if (eap->skip) {
     return;
   }
@@ -4237,7 +4237,7 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
   int prev_syn_inc_tag;
   bool source = false;
 
-  eap->nextcmd = (char *)find_nextcmd((char_u *)arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -4958,7 +4958,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
   int opt_len;
   int list_op;
 
-  eap->nextcmd = (char *)find_nextcmd((char_u *)arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -5042,7 +5042,7 @@ static char *get_syn_pattern(char_u *arg, synpat_T *ci)
     return NULL;
   }
 
-  end = (char *)skip_regexp(arg + 1, *arg, true, NULL);
+  end = skip_regexp((char *)arg + 1, *arg, true, NULL);
   if (*end != (char)(*arg)) {                       // end delimiter not found
     semsg(_("E401: Pattern delimiter not found: %s"), arg);
     return NULL;
@@ -5199,7 +5199,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
         finished = true;
         break;
       }
-      arg_end = (char *)skip_regexp(next_arg + 1, *next_arg, true, NULL);
+      arg_end = skip_regexp((char *)next_arg + 1, *next_arg, true, NULL);
       if (*arg_end != (char)(*next_arg)) {          // end delimiter not found
         illegal = true;
         break;
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 50121832ba..11825ce1c4 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1781,7 +1781,7 @@ line_read_in:
               // encoding to 'encoding'.
               for (p = lbuf + 20; *p > ' ' && *p < 127; p++) {}
               *p = NUL;
-              convert_setup(&vimconv, lbuf + 20, (char_u *)p_enc);
+              convert_setup(&vimconv, (char *)lbuf + 20, p_enc);
             }
 
             // Read the next line.  Unrecognized flags are ignored.
@@ -2055,8 +2055,9 @@ parse_line:
             mtt = MT_GL_OTH;
           } else {
             // Decide in which array to store this match.
-            is_current = test_for_current(tagp.fname, tagp.fname_end, tag_fname,
-                                          (char_u *)buf_ffname);
+            is_current = test_for_current((char *)tagp.fname, (char *)tagp.fname_end,
+                                          (char *)tag_fname,
+                                          buf_ffname);
             is_static = test_for_static(&tagp);
 
             // Decide in which of the sixteen tables to store this match.
@@ -2826,7 +2827,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
      */
     str = pbuf;
     if (pbuf[0] == '/' || pbuf[0] == '?') {
-      str = skip_regexp(pbuf + 1, pbuf[0], false, NULL) + 1;
+      str = (char_u *)skip_regexp((char *)pbuf + 1, pbuf[0], false, NULL) + 1;
     }
     if (str > pbuf_end - 1) {   // search command with nothing following
       save_p_ws = p_ws;
@@ -3012,27 +3013,25 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
   return retval;
 }
 
-/*
- * Check if we have a tag for the buffer with name "buf_ffname".
- * This is a bit slow, because of the full path compare in path_full_compare().
- * Return true if tag for file "fname" if tag file "tag_fname" is for current
- * file.
- */
-static int test_for_current(char_u *fname, char_u *fname_end, char_u *tag_fname, char_u *buf_ffname)
+/// Check if we have a tag for the buffer with name "buf_ffname".
+/// This is a bit slow, because of the full path compare in path_full_compare().
+///
+/// @return  true if tag for file "fname" if tag file "tag_fname" is for current
+///          file.
+static int test_for_current(char *fname, char *fname_end, char *tag_fname, char *buf_ffname)
 {
   int c;
   int retval = false;
-  char_u *fullname;
 
   if (buf_ffname != NULL) {     // if the buffer has a name
     {
-      c = *fname_end;
+      c = (unsigned char)(*fname_end);
       *fname_end = NUL;
     }
-    fullname = expand_tag_fname(fname, tag_fname, true);
-    retval = (path_full_compare((char *)fullname, (char *)buf_ffname, true, true) & kEqualFiles);
+    char *fullname = (char *)expand_tag_fname((char_u *)fname, (char_u *)tag_fname, true);
+    retval = (path_full_compare(fullname, buf_ffname, true, true) & kEqualFiles);
     xfree(fullname);
-    *fname_end = (char_u)c;
+    *fname_end = (char)c;
   }
 
   return retval;
@@ -3052,7 +3051,7 @@ static int find_extra(char_u **pp)
     if (ascii_isdigit(*str)) {
       str = (char_u *)skipdigits((char *)str + 1);
     } else if (*str == '/' || *str == '?') {
-      str = skip_regexp(str + 1, *str, false, NULL);
+      str = (char_u *)skip_regexp((char *)str + 1, *str, false, NULL);
       if (*str != first_char) {
         str = NULL;
       } else {
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index b2bfca08ed..125146f712 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -121,7 +121,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
       leader_len = get_leader_len((char *)line, NULL, false, true);
       if (leader_len == 0 && curbuf->b_p_cin) {
         // Check for a line comment after code.
-        int comment_start = check_linecomment(line);
+        int comment_start = check_linecomment((char *)line);
         if (comment_start != MAXCOL) {
           leader_len = get_leader_len((char *)line + comment_start, NULL, false, true);
           if (leader_len != 0) {
@@ -411,7 +411,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
             // add the additional whitespace needed after the
             // comment leader for the numbered list.
             for (int i = 0; i < padding; i++) {
-              ins_str((char_u *)" ");
+              ins_str(" ");
             }
             changed_bytes(curwin->w_cursor.lnum, leader_len);
           } else {
@@ -1026,7 +1026,7 @@ void format_lines(linenr_T line_count, bool avoid_fex)
         // paragraph doesn't really end.
         if (next_leader_flags == NULL
             || STRNCMP(next_leader_flags, "://", 3) != 0
-            || check_linecomment(get_cursor_line_ptr()) == MAXCOL) {
+            || check_linecomment((char *)get_cursor_line_ptr()) == MAXCOL) {
           is_end_par = true;
         }
       }
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 834aad2872..ae312de61a 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -127,7 +127,7 @@ char *find_ucmd(exarg_T *eap, char *p, int *full, expand_T *xp, int *complp)
     for (j = 0; j < gap->ga_len; j++) {
       uc = USER_CMD_GA(gap, j);
       cp = eap->cmd;
-      np = (char *)uc->uc_name;
+      np = uc->uc_name;
       k = 0;
       while (k < len && *np != NUL && *cp++ == *np++) {
         k++;
@@ -167,7 +167,7 @@ char *find_ucmd(exarg_T *eap, char *p, int *full, expand_T *xp, int *complp)
           }
           if (xp != NULL) {
             xp->xp_luaref = uc->uc_compl_luaref;
-            xp->xp_arg = (char *)uc->uc_compl_arg;
+            xp->xp_arg = uc->uc_compl_arg;
             xp->xp_script_ctx = uc->uc_script_ctx;
             xp->xp_script_ctx.sc_lnum += SOURCING_LNUM;
           }
@@ -272,12 +272,12 @@ char *get_user_commands(expand_T *xp FUNC_ATTR_UNUSED, int idx)
   const buf_T *const buf = prevwin_curwin()->w_buffer;
 
   if (idx < buf->b_ucmds.ga_len) {
-    return (char *)USER_CMD_GA(&buf->b_ucmds, idx)->uc_name;
+    return USER_CMD_GA(&buf->b_ucmds, idx)->uc_name;
   }
 
   idx -= buf->b_ucmds.ga_len;
   if (idx < ucmds.ga_len) {
-    char *name = (char *)USER_CMD(idx)->uc_name;
+    char *name = USER_CMD(idx)->uc_name;
 
     for (int i = 0; i < buf->b_ucmds.ga_len; i++) {
       if (STRCMP(name, USER_CMD_GA(&buf->b_ucmds, i)->uc_name) == 0) {
@@ -297,14 +297,14 @@ char *get_user_commands(expand_T *xp FUNC_ATTR_UNUSED, int idx)
 char *get_user_command_name(int idx, int cmdidx)
 {
   if (cmdidx == CMD_USER && idx < ucmds.ga_len) {
-    return (char *)USER_CMD(idx)->uc_name;
+    return USER_CMD(idx)->uc_name;
   }
   if (cmdidx == CMD_USER_BUF) {
     // In cmdwin, the alternative buffer should be used.
     const buf_T *const buf = prevwin_curwin()->w_buffer;
 
     if (idx < buf->b_ucmds.ga_len) {
-      return (char *)USER_CMD_GA(&buf->b_ucmds, idx)->uc_name;
+      return USER_CMD_GA(&buf->b_ucmds, idx)->uc_name;
     }
   }
   return NULL;
@@ -434,7 +434,7 @@ static void uc_list(char *name, size_t name_len)
         msg_putchar(' ');
       }
 
-      msg_outtrans_attr(cmd->uc_name, HL_ATTR(HLF_D));
+      msg_outtrans_attr((char_u *)cmd->uc_name, HL_ATTR(HLF_D));
       len = (int)STRLEN(cmd->uc_name) + 4;
 
       do {
@@ -531,7 +531,7 @@ static void uc_list(char *name, size_t name_len)
         }
       }
 
-      msg_outtrans_special(cmd->uc_rep, false,
+      msg_outtrans_special((char_u *)cmd->uc_rep, false,
                            name_len == 0 ? Columns - 47 : 0);
       if (p_verbose > 0) {
         last_set_msg(cmd->uc_script_ctx);
@@ -883,17 +883,17 @@ int uc_add_command(char *name, size_t name_len, const char *rep, uint32_t argt,
 
     gap->ga_len++;
 
-    cmd->uc_name = (char_u *)p;
+    cmd->uc_name = p;
   }
 
-  cmd->uc_rep = (char_u *)rep_buf;
+  cmd->uc_rep = rep_buf;
   cmd->uc_argt = argt;
   cmd->uc_def = def;
   cmd->uc_compl = compl;
   cmd->uc_script_ctx = current_sctx;
   cmd->uc_script_ctx.sc_lnum += SOURCING_LNUM;
   nlua_set_sctx(&cmd->uc_script_ctx);
-  cmd->uc_compl_arg = (char_u *)compl_arg;
+  cmd->uc_compl_arg = compl_arg;
   cmd->uc_compl_luaref = compl_luaref;
   cmd->uc_preview_luaref = preview_luaref;
   cmd->uc_addr_type = addr_type;
@@ -1569,7 +1569,7 @@ int do_ucmd(exarg_T *eap, bool preview)
   // Second round: copy result into "buf".
   buf = NULL;
   for (;;) {
-    p = (char *)cmd->uc_rep;        // source
+    p = cmd->uc_rep;        // source
     q = buf;                // destination
     totlen = 0;
 
diff --git a/src/nvim/usercmd.h b/src/nvim/usercmd.h
index 637862b216..4d2cf0d9de 100644
--- a/src/nvim/usercmd.h
+++ b/src/nvim/usercmd.h
@@ -4,14 +4,14 @@
 #include "nvim/ex_cmds_defs.h"
 
 typedef struct ucmd {
-  char_u *uc_name;              // The command name
+  char *uc_name;                // The command name
   uint32_t uc_argt;             // The argument type
-  char_u *uc_rep;               // The command's replacement string
+  char *uc_rep;                 // The command's replacement string
   long uc_def;                  // The default value for a range/count
   int uc_compl;                 // completion type
   cmd_addr_T uc_addr_type;      // The command's address type
   sctx_T uc_script_ctx;         // SCTX where the command was defined
-  char_u *uc_compl_arg;         // completion argument if any
+  char *uc_compl_arg;           // completion argument if any
   LuaRef uc_compl_luaref;       // Reference to Lua completion function
   LuaRef uc_preview_luaref;     // Reference to Lua preview function
   LuaRef uc_luaref;             // Reference to Lua function
diff --git a/src/nvim/version.c b/src/nvim/version.c
index 46e3a67388..5888d4614e 100644
--- a/src/nvim/version.c
+++ b/src/nvim/version.c
@@ -2274,7 +2274,7 @@ void intro_message(int colon)
       }
 
       if (*p != NUL) {
-        do_intro_line(row, (char_u *)_(p), 0);
+        do_intro_line(row, _(p), 0);
       }
       row++;
     }
@@ -2287,15 +2287,14 @@ void intro_message(int colon)
   }
 }
 
-static void do_intro_line(long row, char_u *mesg, int attr)
+static void do_intro_line(long row, char *mesg, int attr)
 {
-  long col;
-  char_u *p;
+  char *p;
   int l;
   int clen;
 
   // Center the message horizontally.
-  col = vim_strsize((char *)mesg);
+  long col = vim_strsize(mesg);
 
   col = (Columns - col) / 2;
 
@@ -2310,8 +2309,8 @@ static void do_intro_line(long row, char_u *mesg, int attr)
     for (l = 0;
          p[l] != NUL && (l == 0 || (p[l] != '<' && p[l - 1] != '>'));
          l++) {
-      clen += ptr2cells((char *)p + l);
-      l += utfc_ptr2len((char *)p + l) - 1;
+      clen += ptr2cells(p + l);
+      l += utfc_ptr2len(p + l) - 1;
     }
     assert(row <= INT_MAX && col <= INT_MAX);
     grid_puts_len(&default_grid, p, l, (int)row, (int)col,
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 5b8a69f6eb..29b1b05ade 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -215,7 +215,7 @@ newwindow:
   case Ctrl_Q:
   case 'q':
     reset_VIsual_and_resel();                   // stop Visual mode
-    cmd_with_count("quit", (char_u *)cbuf, sizeof(cbuf), Prenum);
+    cmd_with_count("quit", cbuf, sizeof(cbuf), Prenum);
     do_cmdline_cmd(cbuf);
     break;
 
@@ -223,7 +223,7 @@ newwindow:
   case Ctrl_C:
   case 'c':
     reset_VIsual_and_resel();                   // stop Visual mode
-    cmd_with_count("close", (char_u *)cbuf, sizeof(cbuf), Prenum);
+    cmd_with_count("close", cbuf, sizeof(cbuf), Prenum);
     do_cmdline_cmd(cbuf);
     break;
 
@@ -256,7 +256,7 @@ newwindow:
   case 'o':
     CHECK_CMDWIN;
     reset_VIsual_and_resel();  // stop Visual mode
-    cmd_with_count("only", (char_u *)cbuf, sizeof(cbuf), Prenum);
+    cmd_with_count("only", cbuf, sizeof(cbuf), Prenum);
     do_cmdline_cmd(cbuf);
     break;
 
@@ -622,12 +622,12 @@ wingotofile:
   }
 }
 
-static void cmd_with_count(char *cmd, char_u *bufp, size_t bufsize, int64_t Prenum)
+static void cmd_with_count(char *cmd, char *bufp, size_t bufsize, int64_t Prenum)
 {
   size_t len = STRLCPY(bufp, cmd, bufsize);
 
   if (Prenum > 0 && len < bufsize) {
-    vim_snprintf((char *)bufp + len, bufsize - len, "%" PRId64, Prenum);
+    vim_snprintf(bufp + len, bufsize - len, "%" PRId64, Prenum);
   }
 }
 
@@ -2082,7 +2082,7 @@ static int get_maximum_wincount(frame_T *fr, int height)
 void win_equal(win_T *next_curwin, bool current, int dir)
 {
   if (dir == 0) {
-    dir = *p_ead;
+    dir = (unsigned char)(*p_ead);
   }
   win_equal_rec(next_curwin == NULL ? curwin : next_curwin, current,
                 topframe, dir, 0, tabline_height(),
-- 
cgit 


From 8fd66ff5c57d29a4349c80d3ae769cde12357ac0 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Mon, 29 Aug 2022 21:58:07 +0200
Subject: fix(redraw): handle switching to a tabpage with larger p_ch value

---
 src/nvim/window.c | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src')

diff --git a/src/nvim/window.c b/src/nvim/window.c
index 29b1b05ade..832cb82bda 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -4343,6 +4343,11 @@ static void enter_tabpage(tabpage_T *tp, buf_T *old_curbuf, bool trigger_enter_a
   // Use the stored value of p_ch, so that it can be different for each tab page.
   if (p_ch != curtab->tp_ch_used) {
     clear_cmdline = true;
+    if (msg_grid.chars && p_ch < curtab->tp_ch_used) {
+      // TODO(bfredl): a bit expensive, should be enough to invalidate the
+      // region between the old and the new p_ch.
+      grid_invalidate(&msg_grid);
+    }
   }
   p_ch = curtab->tp_ch_used;
 
-- 
cgit 


From f58a9795990a3b324f66912e4ae33dae7eb7474d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 30 Aug 2022 06:26:06 +0800
Subject: vim-patch:9.0.0318: clearing screen causes flicker (#19993)

Problem:    Clearing screen causes flicker.
Solution:   Do not clear but redraw in more cases.  Add () to "wait_return".
https://github.com/vim/vim/commit/13608d851a0470ced30921428b3313c023d395d8

Only 2 lines of actual code change.
---
 src/nvim/ex_cmds.c   |  3 ++-
 src/nvim/ex_cmds2.c  |  2 +-
 src/nvim/ex_docmd.c  |  4 ++--
 src/nvim/getchar.c   |  2 +-
 src/nvim/if_cscope.c |  2 +-
 src/nvim/input.c     |  2 +-
 src/nvim/memline.c   |  2 +-
 src/nvim/message.c   | 12 ++++++------
 src/nvim/option.c    |  2 +-
 src/nvim/os/shell.c  |  2 +-
 10 files changed, 17 insertions(+), 16 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 57eb2f526f..ba6594fd7a 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1347,7 +1347,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
     msg_putchar('\n');  // Keep message from buf_write().
     no_wait_return--;
     if (!aborting()) {
-      semsg(_("E482: Can't create file %s"), itmp);  // Will call wait_return.
+      // will call wait_return()
+      semsg(_("E482: Can't create file %s"), itmp);
     }
     goto filterend;
   }
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 2ed2b5519b..11280eecbb 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -364,7 +364,7 @@ bool check_changed_any(bool hidden, bool unload)
   exiting = false;
   // When ":confirm" used, don't give an error message.
   if (!(p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM))) {
-    // There must be a wait_return for this message, do_buffer()
+    // There must be a wait_return() for this message, do_buffer()
     // may cause a redraw.  But wait_return() is a no-op when vgetc()
     // is busy (Quit used from window menu), then make sure we don't
     // cause a scroll up.
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 3cd4369107..08709ec228 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -516,7 +516,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
                                       cstack.cs_idx <
                                       0 ? 0 : (cstack.cs_idx + 1) * 2,
                                       true)) == NULL) {
-        // Don't call wait_return for aborted command line.  The NULL
+        // Don't call wait_return() for aborted command line.  The NULL
         // returned for the end of a sourced file or executed function
         // doesn't do this.
         if (KeyTyped && !(flags & DOCMD_REPEAT)) {
@@ -888,7 +888,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       need_wait_return = false;
       msg_didany = false;               // don't wait when restarting edit
     } else if (need_wait_return) {
-      // The msg_start() above clears msg_didout. The wait_return we do
+      // The msg_start() above clears msg_didout. The wait_return() we do
       // here should not overwrite the command that may be shown before
       // doing that.
       msg_didout |= msg_didout_before_start;
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index af3895b793..bb8cd5a1eb 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1768,7 +1768,7 @@ static void getchar_common(typval_T *argvars, typval_T *rettv)
 
   if (!ui_has_messages()) {
     // redraw the screen after getchar()
-    update_screen(UPD_CLEAR);
+    update_screen(UPD_NOT_VALID);
   }
 
   set_vim_var_nr(VV_MOUSE_WIN, 0);
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 975fa0ca92..2a9d2c357e 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -2035,7 +2035,7 @@ static int cs_show(exarg_T *eap)
     }
   }
 
-  wait_return(true);
+  wait_return(false);
   return CSCOPE_SUCCESS;
 }
 
diff --git a/src/nvim/input.c b/src/nvim/input.c
index 37c2903cfd..0aa9feaca3 100644
--- a/src/nvim/input.c
+++ b/src/nvim/input.c
@@ -46,7 +46,7 @@ int ask_yesno(const char *const str, const bool direct)
 
   int r = ' ';
   while (r != 'y' && r != 'n') {
-    // Same highlighting as for wait_return.
+    // same highlighting as for wait_return()
     smsg_attr(HL_ATTR(HLF_R), "%s (y/n)?", str);
     if (direct) {
       r = get_keystroke(NULL);
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index b940040c45..044655ef2b 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -523,7 +523,7 @@ void ml_open_file(buf_T *buf)
   }
 
   if (*p_dir != NUL && mfp->mf_fname == NULL) {
-    need_wait_return = true;  // call wait_return later
+    need_wait_return = true;  // call wait_return() later
     no_wait_return++;
     (void)semsg(_("E303: Unable to open swap file for \"%s\", recovery impossible"),
                 buf_spname(buf) != NULL ? buf_spname(buf) : buf->b_fname);
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 7b198371c5..4fba78feca 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -215,7 +215,7 @@ void msg_grid_validate(void)
 /// Displays the string 's' on the status line
 /// When terminal not initialized (yet) mch_errmsg(..) is used.
 ///
-/// @return  true if wait_return not called
+/// @return  true if wait_return() not called
 int msg(char *s)
 {
   return msg_attr_keep(s, 0, false, false);
@@ -745,7 +745,7 @@ static bool emsg_multiline(const char *s, bool multiline)
   attr = HL_ATTR(HLF_E);      // set highlight mode for error messages
   if (msg_scrolled != 0) {
     need_wait_return = true;  // needed in case emsg() is called after
-  }                           // wait_return has reset need_wait_return
+  }                           // wait_return() has reset need_wait_return
                               // and a redraw is expected because
                               // msg_scrolled is non-zero
   if (msg_ext_kind == NULL) {
@@ -766,7 +766,7 @@ static bool emsg_multiline(const char *s, bool multiline)
 /// Rings the bell, if appropriate, and calls message() to do the real work
 /// When terminal not initialized (yet) mch_errmsg(..) is used.
 ///
-/// @return true if wait_return not called
+/// @return true if wait_return() not called
 bool emsg(const char *s)
 {
   return emsg_multiline(s, false);
@@ -2243,7 +2243,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       }
 
       inc_msg_scrolled();
-      need_wait_return = true;       // may need wait_return in main()
+      need_wait_return = true;       // may need wait_return() in main()
       redraw_cmdline = true;
       if (cmdline_row > 0 && !exmode_active) {
         cmdline_row--;
@@ -3164,9 +3164,9 @@ void msg_clr_cmdline(void)
 }
 
 /// end putting a message on the screen
-/// call wait_return if the message does not fit in the available space
+/// call wait_return() if the message does not fit in the available space
 ///
-/// @return  true if wait_return not called.
+/// @return  true if wait_return() not called.
 int msg_end(void)
 {
   /*
diff --git a/src/nvim/option.c b/src/nvim/option.c
index f9b32d50af..455070c742 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -1553,7 +1553,7 @@ skip:
       // make sure all characters are printable
       trans_characters((char *)IObuff, IOSIZE);
 
-      no_wait_return++;         // wait_return done later
+      no_wait_return++;         // wait_return() done later
       emsg((char *)IObuff);     // show error highlighted
       no_wait_return--;
 
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 574543b1a5..c8267ede14 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -911,7 +911,7 @@ static int do_os_system(char **argv, const char *input, size_t len, char **outpu
     out_data_ring(NULL, SIZE_MAX);
   }
   if (forward_output) {
-    // caller should decide if wait_return is invoked
+    // caller should decide if wait_return() is invoked
     no_wait_return++;
     msg_end();
     no_wait_return--;
-- 
cgit 


From 2c83d7b2ddf74966777e3bb72230a3605b92ffe2 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 29 Aug 2022 15:12:30 +0800
Subject: refactor: move cmdline functions to ex_getln.c

---
 src/nvim/eval/funcs.c |  69 ------------------------
 src/nvim/ex_getln.c   | 144 +++++++++++++++++++++++++++++++-------------------
 2 files changed, 91 insertions(+), 122 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 0bf3ad6901..c442f5c465 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -2721,40 +2721,6 @@ static void f_getcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
   tv_dict_add_nr(dict, S_LEN("until"), last_csearch_until());
 }
 
-/// "getcmdcompltype()" function
-static void f_getcmdcompltype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)get_cmdline_completion();
-}
-
-/// "getcmdline()" function
-static void f_getcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)get_cmdline_str();
-}
-
-/// "getcmdpos()" function
-static void f_getcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  rettv->vval.v_number = get_cmdline_pos() + 1;
-}
-
-/// "getcmdscreenpos()" function
-static void f_getcmdscreenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  rettv->vval.v_number = get_cmdline_screen_pos() + 1;
-}
-
-/// "getcmdtype()" function
-static void f_getcmdtype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = xmallocz(1);
-  rettv->vval.v_string[0] = (char)get_cmdline_type();
-}
-
 /// "getcmdwintype()" function
 static void f_getcmdwintype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
@@ -7622,41 +7588,6 @@ static void f_setcharsearch(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
   }
 }
 
-/// "setcmdline()" function
-static void f_setcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  if (argvars[0].v_type != VAR_STRING || argvars[0].vval.v_string == NULL) {
-    emsg(_(e_stringreq));
-    return;
-  }
-
-  int pos = -1;
-  if (argvars[1].v_type != VAR_UNKNOWN) {
-    bool error = false;
-
-    pos = (int)tv_get_number_chk(&argvars[1], &error) - 1;
-    if (error) {
-      return;
-    }
-    if (pos < 0) {
-      emsg(_(e_positive));
-      return;
-    }
-  }
-
-  rettv->vval.v_number = set_cmdline_str(argvars[0].vval.v_string, pos);
-}
-
-/// "setcmdpos()" function
-static void f_setcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  const int pos = (int)tv_get_number(&argvars[0]) - 1;
-
-  if (pos >= 0) {
-    rettv->vval.v_number = set_cmdline_pos(pos);
-  }
-}
-
 /// "setcursorcharpos" function
 static void f_setcursorcharpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index ec2672c675..7dac5fbe7e 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -3933,8 +3933,41 @@ static CmdlineInfo *get_ccline_ptr(void)
   }
 }
 
+/// Get the current command-line type.
+/// Returns ':' or '/' or '?' or '@' or '>' or '-'
+/// Only works when the command line is being edited.
+/// Returns NUL when something is wrong.
+static int get_cmdline_type(void)
+{
+  CmdlineInfo *p = get_ccline_ptr();
+
+  if (p == NULL) {
+    return NUL;
+  }
+  if (p->cmdfirstc == NUL) {
+    return (p->input_fn) ? '@' : '-';
+  }
+  return p->cmdfirstc;
+}
+
+/// Get the current command line in allocated memory.
+/// Only works when the command line is being edited.
+/// Returns NULL when something is wrong.
+static char_u *get_cmdline_str(void)
+{
+  if (cmdline_star > 0) {
+    return NULL;
+  }
+  CmdlineInfo *p = get_ccline_ptr();
+
+  if (p == NULL) {
+    return NULL;
+  }
+  return vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
+}
+
 /// Get the current command-line completion type.
-char_u *get_cmdline_completion(void)
+static char_u *get_cmdline_completion(void)
 {
   if (cmdline_star > 0) {
     return NULL;
@@ -3952,54 +3985,45 @@ char_u *get_cmdline_completion(void)
   return NULL;
 }
 
-/*
- * Get the current command line in allocated memory.
- * Only works when the command line is being edited.
- * Returns NULL when something is wrong.
- */
-char_u *get_cmdline_str(void)
+/// "getcmdcompltype()" function
+void f_getcmdcompltype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (cmdline_star > 0) {
-    return NULL;
-  }
-  CmdlineInfo *p = get_ccline_ptr();
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = (char *)get_cmdline_completion();
+}
 
-  if (p == NULL) {
-    return NULL;
-  }
-  return vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
+/// "getcmdline()" function
+void f_getcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = (char *)get_cmdline_str();
 }
 
-/*
- * Get the current command line position, counted in bytes.
- * Zero is the first position.
- * Only works when the command line is being edited.
- * Returns -1 when something is wrong.
- */
-int get_cmdline_pos(void)
+/// "getcmdpos()" function
+void f_getcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   CmdlineInfo *p = get_ccline_ptr();
-
-  if (p == NULL) {
-    return -1;
-  }
-  return p->cmdpos;
+  rettv->vval.v_number = p != NULL ? p->cmdpos + 1 : 0;
 }
 
-/// Get the command line cursor screen position.
-int get_cmdline_screen_pos(void)
+/// "getcmdscreenpos()" function
+void f_getcmdscreenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   CmdlineInfo *p = get_ccline_ptr();
+  rettv->vval.v_number = p != NULL ? p->cmdspos + 1 : 0;
+}
 
-  if (p == NULL) {
-    return -1;
-  }
-  return p->cmdspos;
+/// "getcmdtype()" function
+void f_getcmdtype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = xmallocz(1);
+  rettv->vval.v_string[0] = (char)get_cmdline_type();
 }
 
 /// Set the command line str to "str".
 /// @return  1 when failed, 0 when OK.
-int set_cmdline_str(const char *str, int pos)
+static int set_cmdline_str(const char *str, int pos)
 {
   CmdlineInfo *p = get_ccline_ptr();
 
@@ -4023,12 +4047,10 @@ int set_cmdline_str(const char *str, int pos)
   return 0;
 }
 
-/*
- * Set the command line byte position to "pos".  Zero is the first position.
- * Only works when the command line is being edited.
- * Returns 1 when failed, 0 when OK.
- */
-int set_cmdline_pos(int pos)
+/// Set the command line byte position to "pos".  Zero is the first position.
+/// Only works when the command line is being edited.
+/// @return  1 when failed, 0 when OK.
+static int set_cmdline_pos(int pos)
 {
   CmdlineInfo *p = get_ccline_ptr();
 
@@ -4046,23 +4068,39 @@ int set_cmdline_pos(int pos)
   return 0;
 }
 
-/*
- * Get the current command-line type.
- * Returns ':' or '/' or '?' or '@' or '>' or '-'
- * Only works when the command line is being edited.
- * Returns NUL when something is wrong.
- */
-int get_cmdline_type(void)
+/// "setcmdline()" function
+void f_setcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  CmdlineInfo *p = get_ccline_ptr();
+  if (argvars[0].v_type != VAR_STRING || argvars[0].vval.v_string == NULL) {
+    emsg(_(e_stringreq));
+    return;
+  }
 
-  if (p == NULL) {
-    return NUL;
+  int pos = -1;
+  if (argvars[1].v_type != VAR_UNKNOWN) {
+    bool error = false;
+
+    pos = (int)tv_get_number_chk(&argvars[1], &error) - 1;
+    if (error) {
+      return;
+    }
+    if (pos < 0) {
+      emsg(_(e_positive));
+      return;
+    }
   }
-  if (p->cmdfirstc == NUL) {
-    return (p->input_fn) ? '@' : '-';
+
+  rettv->vval.v_number = set_cmdline_str(argvars[0].vval.v_string, pos);
+}
+
+/// "setcmdpos()" function
+void f_setcmdpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  const int pos = (int)tv_get_number(&argvars[0]) - 1;
+
+  if (pos >= 0) {
+    rettv->vval.v_number = set_cmdline_pos(pos);
   }
-  return p->cmdfirstc;
 }
 
 /// Return the first character of the current command line.
-- 
cgit 


From e6e9879cb3eecf9d5c3f3964259a89dc36f60d52 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 30 Aug 2022 06:32:14 +0800
Subject: vim-patch:9.0.0320: command line type of CmdlineChange differs from
 getcmdtype()

Problem:    Command line type of CmdlineChange differs from getcmdtype().
Solution:   Use the same type. (closes vim/vim#11005)
https://github.com/vim/vim/commit/54acb90d9e672315e3bd13f8dc71f828df97c868
---
 src/nvim/ex_getln.c               |  2 +-
 src/nvim/testdir/test_cmdline.vim | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 7dac5fbe7e..66c3327ce3 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -4042,7 +4042,7 @@ static int set_cmdline_str(const char *str, int pos)
   redrawcmd();
 
   // Trigger CmdlineChanged autocommands.
-  do_autocmd_cmdlinechanged(ccline.cmdfirstc == NUL ? '-' : ccline.cmdfirstc);
+  do_autocmd_cmdlinechanged(get_cmdline_type());
 
   return 0;
 }
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index a5a30b7953..045504b8bf 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -2187,9 +2187,13 @@ endfunc
 
 func Test_setcmdline()
   func SetText(text, pos)
+    autocmd CmdlineChanged * let g:cmdtype = expand('<afile>')
     call assert_equal(0, setcmdline(a:text))
     call assert_equal(a:text, getcmdline())
     call assert_equal(len(a:text) + 1, getcmdpos())
+    call assert_equal(getcmdtype(), g:cmdtype)
+    unlet g:cmdtype
+    autocmd! CmdlineChanged
 
     call assert_equal(0, setcmdline(a:text, a:pos))
     call assert_equal(a:text, getcmdline())
@@ -2205,6 +2209,13 @@ func Test_setcmdline()
   call feedkeys(":\<C-R>=SetText('set rtp?', 2)\<CR>\<CR>", 'xt')
   call assert_equal('set rtp?', @:)
 
+  call feedkeys(":let g:str = input('? ')\<CR>", 't')
+  call feedkeys("\<C-R>=SetText('foo', 4)\<CR>\<CR>", 'xt')
+  call assert_equal('foo', g:str)
+  unlet g:str
+
+  delfunc SetText
+
   " setcmdline() returns 1 when not editing the command line.
   call assert_equal(1, 'foo'->setcmdline())
 
@@ -2217,6 +2228,8 @@ func Test_setcmdline()
   com! -nargs=* -complete=custom,CustomComplete DoCmd :
   call feedkeys(":DoCmd \<C-A>\<C-B>\"\<CR>", 'tx')
   call assert_equal('"DoCmd January February Mars', @:)
+  delcom DoCmd
+  delfunc CustomComplete
 
   " Called in <expr>
   cnoremap <expr>a setcmdline('let foo=')
-- 
cgit 


From 568737d5b39a4b58cab05d4edc2599653979770c Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Tue, 30 Aug 2022 10:55:00 +0800
Subject: feat(tui): recognize sidescroll events (#19992)

Ref https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-Other-buttons
This works in xterm and kitty.
CSI < 66 ; x ; y M sequence is for ScrollWheelLeft.
CSI < 67 ; x ; y M sequence is for ScrollWheelRight.
---
 src/nvim/tui/input.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index 03cfb830e6..d269878f46 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -398,6 +398,14 @@ static void forward_mouse_event(TermInput *input, TermKeyKey *key)
     button = last_pressed_button;
   }
 
+  if (ev == TERMKEY_MOUSE_UNKNOWN && !(key->code.mouse[0] & 0x20)) {
+    int code = key->code.mouse[0] & ~0x3c;
+    if (code == 66 || code == 67) {
+      ev = TERMKEY_MOUSE_PRESS;
+      button = code - 60;
+    }
+  }
+
   if (button == 0 || (ev != TERMKEY_MOUSE_PRESS && ev != TERMKEY_MOUSE_DRAG
                       && ev != TERMKEY_MOUSE_RELEASE)) {
     return;
@@ -431,8 +439,11 @@ static void forward_mouse_event(TermInput *input, TermKeyKey *key)
     if (button == 4) {
       len += (size_t)snprintf(buf + len, sizeof(buf) - len, "ScrollWheelUp");
     } else if (button == 5) {
-      len += (size_t)snprintf(buf + len, sizeof(buf) - len,
-                              "ScrollWheelDown");
+      len += (size_t)snprintf(buf + len, sizeof(buf) - len, "ScrollWheelDown");
+    } else if (button == 6) {
+      len += (size_t)snprintf(buf + len, sizeof(buf) - len, "ScrollWheelLeft");
+    } else if (button == 7) {
+      len += (size_t)snprintf(buf + len, sizeof(buf) - len, "ScrollWheelRight");
     } else {
       len += (size_t)snprintf(buf + len, sizeof(buf) - len, "Mouse");
       last_pressed_button = button;
-- 
cgit 


From 6ab2bf68196292721b71e096f45bfa3dd0192ee0 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Mon, 22 Aug 2022 17:29:26 +0200
Subject: fix(highlight): set the window namespace when redrawing statusline

---
 src/nvim/drawscreen.c | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'src')

diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 40dbec8a5b..29ff261461 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -748,6 +748,8 @@ void show_cursor_info(bool always)
   if (!always && !redrawing()) {
     return;
   }
+
+  win_check_ns_hl(curwin);
   if ((*p_stl != NUL || *curwin->w_p_stl != NUL)
       && (curwin->w_status_height || global_stl_height())) {
     redraw_custom_statusline(curwin);
@@ -764,6 +766,7 @@ void show_cursor_info(bool always)
     maketitle();
   }
 
+  win_check_ns_hl(NULL);
   // Redraw the tab pages line if needed.
   if (redraw_tabline) {
     draw_tabline();
@@ -2119,10 +2122,13 @@ void redraw_statuslines(void)
 {
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
     if (wp->w_redr_status) {
+      win_check_ns_hl(wp);
       win_redr_winbar(wp);
       win_redr_status(wp);
     }
   }
+
+  win_check_ns_hl(NULL);
   if (redraw_tabline) {
     draw_tabline();
   }
-- 
cgit 


From 2828aae7b49921380f229ebf4d7432f39c6c2c2b Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Tue, 30 Aug 2022 14:52:09 +0200
Subject: refactor: replace char_u with char 4 (#19987)

* refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/change.c             |   4 +-
 src/nvim/charset.c            |  49 ++++----
 src/nvim/cmdexpand.c          |  32 ++---
 src/nvim/debugger.c           |  12 +-
 src/nvim/digraph.c            |   8 +-
 src/nvim/drawline.c           |   4 +-
 src/nvim/edit.c               |  12 +-
 src/nvim/eval.c               |  16 +--
 src/nvim/eval/executor.c      |   3 +-
 src/nvim/eval/funcs.c         |  28 ++---
 src/nvim/eval/typval.c        |   2 +-
 src/nvim/eval/userfunc.c      |  39 +++---
 src/nvim/eval/vars.c          |   9 +-
 src/nvim/ex_cmds.c            |  11 +-
 src/nvim/ex_docmd.c           |  19 ++-
 src/nvim/ex_eval.c            |   4 +-
 src/nvim/ex_getln.c           |   4 +-
 src/nvim/ex_session.c         |   2 +-
 src/nvim/file_search.c        |  12 +-
 src/nvim/fileio.c             |  12 +-
 src/nvim/getchar.c            |   4 +-
 src/nvim/globals.h            |   2 +-
 src/nvim/hardcopy.c           |   3 +-
 src/nvim/help.c               |  10 +-
 src/nvim/highlight_group.c    |  20 +--
 src/nvim/if_cscope.c          |   4 +-
 src/nvim/indent_c.c           |   4 +-
 src/nvim/insexpand.c          |   4 +-
 src/nvim/locale.c             |   2 +-
 src/nvim/log.c                |   4 +-
 src/nvim/lua/stdlib.c         |   2 +-
 src/nvim/main.c               |   4 +-
 src/nvim/mark.c               |   6 +-
 src/nvim/match.c              |   2 +-
 src/nvim/mbyte.c              |  18 ++-
 src/nvim/memline.c            |  10 +-
 src/nvim/menu.c               |   2 +-
 src/nvim/message.c            |  55 +++++----
 src/nvim/normal.c             |   8 +-
 src/nvim/ops.c                |  10 +-
 src/nvim/os/env.c             |   6 +-
 src/nvim/os/fs.c              |   8 +-
 src/nvim/os/shell.c           |   4 +-
 src/nvim/path.c               |  32 ++---
 src/nvim/plines.c             |   4 +-
 src/nvim/popupmenu.c          |   2 +-
 src/nvim/profile.c            |   8 +-
 src/nvim/quickfix.c           |   6 +-
 src/nvim/runtime.c            | 277 +++++++++++++++++++++---------------------
 src/nvim/runtime.h            |   2 +-
 src/nvim/screen.c             |   2 +-
 src/nvim/search.c             |   8 +-
 src/nvim/shada.c              |   2 +-
 src/nvim/sign.c               |  20 +--
 src/nvim/spell.c              |  22 ++--
 src/nvim/spell_defs.h         |   6 +-
 src/nvim/spellfile.c          |  24 ++--
 src/nvim/spellsuggest.c       |  14 +--
 src/nvim/strings.c            |  16 ++-
 src/nvim/syntax.c             |  28 ++---
 src/nvim/tag.c                |  38 +++---
 src/nvim/undo.c               |   2 +-
 src/nvim/usercmd.c            |   8 +-
 src/nvim/vim.h                |   5 +-
 src/nvim/viml/parser/parser.h |   4 +-
 src/nvim/window.c             |   4 +-
 66 files changed, 499 insertions(+), 509 deletions(-)

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index fd079f8eef..85ab92e49b 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -653,9 +653,9 @@ void ins_char_bytes(char *buf, size_t charlen)
       // cells.  May result in adding spaces to fill a gap.
       colnr_T vcol;
       getvcol(curwin, &curwin->w_cursor, NULL, &vcol, NULL);
-      colnr_T new_vcol = vcol + win_chartabsize(curwin, (char *)buf, vcol);
+      colnr_T new_vcol = vcol + win_chartabsize(curwin, buf, vcol);
       while (oldp[col + oldlen] != NUL && vcol < new_vcol) {
-        vcol += win_chartabsize(curwin, (char *)oldp + col + oldlen, vcol);
+        vcol += win_chartabsize(curwin, oldp + col + oldlen, vcol);
         // Don't need to remove a TAB that takes us to the right
         // position.
         if (vcol > new_vcol && oldp[col + oldlen] == TAB) {
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 2632279565..4efd8a4ad1 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -1157,7 +1157,7 @@ char *skipwhite(const char *const p)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
   FUNC_ATTR_NONNULL_RET
 {
-  return (char *)skipwhite_len((char_u *)p, STRLEN(p));
+  return skipwhite_len(p, STRLEN(p));
 }
 
 /// Like `skipwhite`, but skip up to `len` characters.
@@ -1168,27 +1168,27 @@ char *skipwhite(const char *const p)
 ///
 /// @return Pointer to character after the skipped whitespace, or the `len`-th
 ///         character in the string.
-char_u *skipwhite_len(const char_u *p, size_t len)
+char *skipwhite_len(const char *p, size_t len)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
   FUNC_ATTR_NONNULL_RET
 {
   for (; len > 0 && ascii_iswhite(*p); len--) {
     p++;
   }
-  return (char_u *)p;
+  return (char *)p;
 }
 
 // getwhitecols: return the number of whitespace
 // columns (bytes) at the start of a given line
 intptr_t getwhitecols_curline(void)
 {
-  return getwhitecols(get_cursor_line_ptr());
+  return getwhitecols((char *)get_cursor_line_ptr());
 }
 
-intptr_t getwhitecols(const char_u *p)
+intptr_t getwhitecols(const char *p)
   FUNC_ATTR_PURE
 {
-  return (char_u *)skipwhite((char *)p) - p;
+  return skipwhite(p) - p;
 }
 
 /// Skip over digits
@@ -1232,10 +1232,10 @@ const char *skipbin(const char *q)
 ///
 /// @return Pointer to the character after the skipped digits and hex
 ///         characters.
-char_u *skiphex(char_u *q)
+char *skiphex(char *q)
   FUNC_ATTR_PURE
 {
-  char_u *p = q;
+  char *p = q;
   while (ascii_isxdigit(*p)) {
     // skip to next non-digit
     p++;
@@ -1248,10 +1248,10 @@ char_u *skiphex(char_u *q)
 /// @param q
 ///
 /// @return Pointer to the digit or (NUL after the string).
-char_u *skiptodigit(char_u *q)
+char *skiptodigit(char *q)
   FUNC_ATTR_PURE
 {
-  char_u *p = q;
+  char *p = q;
   while (*p != NUL && !ascii_isdigit(*p)) {
     // skip to next digit
     p++;
@@ -1282,10 +1282,10 @@ const char *skiptobin(const char *q)
 /// @param q
 ///
 /// @return Pointer to the hex character or (NUL after the string).
-char_u *skiptohex(char_u *q)
+char *skiptohex(char *q)
   FUNC_ATTR_PURE
 {
-  char_u *p = q;
+  char *p = q;
   while (*p != NUL && !ascii_isxdigit(*p)) {
     // skip to next digit
     p++;
@@ -1298,13 +1298,13 @@ char_u *skiptohex(char_u *q)
 /// @param[in]  p  Text to skip over.
 ///
 /// @return Pointer to the next whitespace or NUL character.
-char_u *skiptowhite(const char_u *p)
+char *skiptowhite(const char *p)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
 {
   while (*p != ' ' && *p != '\t' && *p != NUL) {
     p++;
   }
-  return (char_u *)p;
+  return (char *)p;
 }
 
 /// skiptowhite_esc: Like skiptowhite(), but also skip escaped chars
@@ -1329,11 +1329,11 @@ char *skiptowhite_esc(char *p)
 /// @param[in]  p  Text to skip over.
 ///
 /// @return Pointer to the next '\n' or NUL character.
-char_u *skip_to_newline(const char_u *const p)
+char *skip_to_newline(const char *const p)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
   FUNC_ATTR_NONNULL_RET
 {
-  return (char_u *)xstrchrnul((const char *)p, NL);
+  return xstrchrnul(p, NL);
 }
 
 /// Gets a number from a string and skips over it, signalling overflow.
@@ -1422,10 +1422,10 @@ int32_t getdigits_int32(char **pp, bool strict, long def)
 /// Check that "lbuf" is empty or only contains blanks.
 ///
 /// @param  lbuf  line buffer to check
-bool vim_isblankline(char_u *lbuf)
+bool vim_isblankline(char *lbuf)
   FUNC_ATTR_PURE
 {
-  char_u *p = (char_u *)skipwhite((char *)lbuf);
+  char *p = skipwhite(lbuf);
   return *p == NUL || *p == '\r' || *p == '\n';
 }
 
@@ -1664,8 +1664,9 @@ int hex2nr(int c)
 }
 
 /// Convert two hex characters to a byte.
-/// Return -1 if one of the characters is not hex.
-int hexhex2nr(const char_u *p)
+///
+/// @return  -1 if one of the characters is not hex.
+int hexhex2nr(const char *p)
   FUNC_ATTR_PURE
 {
   if (!ascii_isxdigit(p[0]) || !ascii_isxdigit(p[1])) {
@@ -1707,10 +1708,10 @@ bool rem_backslash(const char *str)
 /// Halve the number of backslashes in a file name argument.
 ///
 /// @param p
-void backslash_halve(char_u *p)
+void backslash_halve(char *p)
 {
   for (; *p; p++) {
-    if (rem_backslash((char *)p)) {
+    if (rem_backslash(p)) {
       STRMOVE(p, p + 1);
     }
   }
@@ -1721,11 +1722,11 @@ void backslash_halve(char_u *p)
 /// @param p
 ///
 /// @return String with the number of backslashes halved.
-char_u *backslash_halve_save(const char_u *p)
+char *backslash_halve_save(const char *p)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET
 {
   // TODO(philix): simplify and improve backslash_halve_save algorithm
-  char_u *res = vim_strsave(p);
+  char *res = xstrdup(p);
   backslash_halve(res);
   return res;
 }
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index dbf169c801..5c54404aab 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -387,7 +387,7 @@ static char_u *ExpandOne_start(int mode, expand_T *xp, char_u *str, int options)
 }
 
 /// Return the longest common part in the list of cmdline completion matches.
-static char_u *find_longest_match(expand_T *xp, int options)
+static char *find_longest_match(expand_T *xp, int options)
 {
   size_t len = 0;
 
@@ -417,7 +417,7 @@ static char_u *find_longest_match(expand_T *xp, int options)
     }
   }
 
-  return (char_u *)xstrndup(xp->xp_files[0], len);
+  return xstrndup(xp->xp_files[0], len);
 }
 
 /// Do wildcard expansion on the string 'str'.
@@ -500,7 +500,7 @@ char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode
 
   // Find longest common part
   if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
-    ss = find_longest_match(xp, options);
+    ss = (char_u *)find_longest_match(xp, options);
     findex = -1;  // next p_wc gets first one
   }
 
@@ -670,7 +670,7 @@ int showmatches(expand_T *xp, int wildmenu)
       lastlen = 999;
       for (k = i; k < num_files; k += lines) {
         if (xp->xp_context == EXPAND_TAGS_LISTFILES) {
-          msg_outtrans_attr((char_u *)files_found[k], HL_ATTR(HLF_D));
+          msg_outtrans_attr(files_found[k], HL_ATTR(HLF_D));
           p = (char_u *)files_found[k] + STRLEN(files_found[k]) + 1;
           msg_advance(maxlen + 1);
           msg_puts((const char *)p);
@@ -691,15 +691,15 @@ int showmatches(expand_T *xp, int wildmenu)
             // $HOME has been replaced with ~/.
             char_u *exp_path = expand_env_save_opt((char_u *)files_found[k], true);
             char_u *path = exp_path != NULL ? exp_path : (char_u *)files_found[k];
-            char_u *halved_slash = backslash_halve_save(path);
-            j = os_isdir(halved_slash);
+            char_u *halved_slash = (char_u *)backslash_halve_save((char *)path);
+            j = os_isdir((char *)halved_slash);
             xfree(exp_path);
             if (halved_slash != path) {
               xfree(halved_slash);
             }
           } else {
             // Expansion was done here, file names are literal.
-            j = os_isdir((char_u *)files_found[k]);
+            j = os_isdir(files_found[k]);
           }
           if (showtail) {
             p = (char_u *)L_SHOWFILE(k);
@@ -711,7 +711,7 @@ int showmatches(expand_T *xp, int wildmenu)
           j = false;
           p = (char_u *)L_SHOWFILE(k);
         }
-        lastlen = msg_outtrans_attr(p, j ? attr : 0);
+        lastlen = msg_outtrans_attr((char *)p, j ? attr : 0);
       }
       if (msg_col > 0) {        // when not wrapped around
         msg_clr_eos();
@@ -1239,7 +1239,7 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
     if (*arg == NUL || !ends_excmd(*arg)) {
       // also complete "None"
       set_context_in_echohl_cmd(xp, arg);
-      arg = (const char *)skipwhite((char *)skiptowhite((const char_u *)arg));
+      arg = (const char *)skipwhite(skiptowhite(arg));
       if (*arg != NUL) {
         xp->xp_context = EXPAND_NOTHING;
         arg = (const char *)skip_regexp((char *)arg + 1, (uint8_t)(*arg), p_magic, NULL);
@@ -1592,7 +1592,7 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
 
 #ifdef HAVE_WORKING_LIBINTL
   case CMD_language:
-    p = (const char *)skiptowhite((const char_u *)arg);
+    p = (const char *)skiptowhite(arg);
     if (*p == NUL) {
       xp->xp_context = EXPAND_LANGUAGE;
       xp->xp_pattern = (char *)arg;
@@ -2161,19 +2161,19 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
   }
   if (xp->xp_context == EXPAND_COLORS) {
     char *directories[] = { "colors", NULL };
-    return ExpandRTDir(pat, DIP_START + DIP_OPT + DIP_LUA, num_file, file, directories);
+    return ExpandRTDir((char *)pat, DIP_START + DIP_OPT + DIP_LUA, num_file, file, directories);
   }
   if (xp->xp_context == EXPAND_COMPILER) {
     char *directories[] = { "compiler", NULL };
-    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
+    return ExpandRTDir((char *)pat, DIP_LUA, num_file, file, directories);
   }
   if (xp->xp_context == EXPAND_OWNSYNTAX) {
     char *directories[] = { "syntax", NULL };
-    return ExpandRTDir(pat, 0, num_file, file, directories);
+    return ExpandRTDir((char *)pat, 0, num_file, file, directories);
   }
   if (xp->xp_context == EXPAND_FILETYPE) {
     char *directories[] = { "syntax", "indent", "ftplugin", NULL };
-    return ExpandRTDir(pat, DIP_LUA, num_file, file, directories);
+    return ExpandRTDir((char *)pat, DIP_LUA, num_file, file, directories);
   }
   if (xp->xp_context == EXPAND_USER_LIST) {
     return ExpandUserList(xp, num_file, file);
@@ -2182,7 +2182,7 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
     return ExpandUserLua(xp, num_file, file);
   }
   if (xp->xp_context == EXPAND_PACKADD) {
-    return ExpandPackAddDir(pat, num_file, file);
+    return ExpandPackAddDir((char *)pat, num_file, file);
   }
 
   // When expanding a function name starting with s:, match the <SNR>nr_
@@ -2573,7 +2573,7 @@ static int ExpandUserLua(expand_T *xp, int *num_file, char ***file)
 
 /// Expand `file` for all comma-separated directories in `path`.
 /// Adds matches to `ga`.
-void globpath(char *path, char_u *file, garray_T *ga, int expand_options)
+void globpath(char *path, char *file, garray_T *ga, int expand_options)
 {
   expand_T xpc;
   ExpandInit(&xpc);
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index 9fdeebf68a..36df62b502 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -718,9 +718,9 @@ void ex_breaklist(exarg_T *eap)
 /// @param file  true for a file, false for a function
 /// @param fname  file or function name
 /// @param after  after this line number
-linenr_T dbg_find_breakpoint(bool file, char_u *fname, linenr_T after)
+linenr_T dbg_find_breakpoint(bool file, char *fname, linenr_T after)
 {
-  return debuggy_find(file, fname, after, &dbg_breakp, NULL);
+  return debuggy_find(file, (char_u *)fname, after, &dbg_breakp, NULL);
 }
 
 /// @param file     true for a file, false for a function
@@ -728,9 +728,9 @@ linenr_T dbg_find_breakpoint(bool file, char_u *fname, linenr_T after)
 /// @param fp[out]  forceit
 ///
 /// @returns true if profiling is on for a function or sourced file.
-bool has_profiling(bool file, char_u *fname, bool *fp)
+bool has_profiling(bool file, char *fname, bool *fp)
 {
-  return debuggy_find(file, fname, (linenr_T)0, &prof_ga, fp)
+  return debuggy_find(file, (char_u *)fname, (linenr_T)0, &prof_ga, fp)
          != (linenr_T)0;
 }
 
@@ -825,9 +825,9 @@ static linenr_T debuggy_find(bool file, char_u *fname, linenr_T after, garray_T
 }
 
 /// Called when a breakpoint was encountered.
-void dbg_breakpoint(char_u *name, linenr_T lnum)
+void dbg_breakpoint(char *name, linenr_T lnum)
 {
   // We need to check if this line is actually executed in do_one_cmd()
-  debug_breakpoint_name = name;
+  debug_breakpoint_name = (char_u *)name;
   debug_breakpoint_lnum = lnum;
 }
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index de2dd09d1c..e4528f9038 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1695,7 +1695,7 @@ static void digraph_header(const char *msg)
   if (msg_col > 0) {
     msg_putchar('\n');
   }
-  msg_outtrans_attr((const char_u *)msg, HL_ATTR(HLF_CM));
+  msg_outtrans_attr(msg, HL_ATTR(HLF_CM));
   msg_putchar('\n');
 }
 
@@ -1856,7 +1856,7 @@ static void printdigraph(const digr_T *dp, result_T *previous)
     p += utf_char2bytes(dp->result, (char *)p);
 
     *p = NUL;
-    msg_outtrans_attr(buf, HL_ATTR(HLF_8));
+    msg_outtrans_attr((char *)buf, HL_ATTR(HLF_8));
     p = buf;
     if (char2cells(dp->result) == 1) {
       *p++ = ' ';
@@ -2096,10 +2096,10 @@ void ex_loadkeymap(exarg_T *eap)
 
     if ((*p != '"') && (*p != NUL)) {
       kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga);
-      s = skiptowhite(p);
+      s = (char_u *)skiptowhite((char *)p);
       kp->from = vim_strnsave(p, (size_t)(s - p));
       p = (char_u *)skipwhite((char *)s);
-      s = skiptowhite(p);
+      s = (char_u *)skiptowhite((char *)p);
       kp->to = vim_strnsave(p, (size_t)(s - p));
 
       if ((STRLEN(kp->from) + STRLEN(kp->to) >= KMAP_LLEN)
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index b6654699d8..b6c4400c60 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -870,7 +870,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
   if (has_spell && !number_only) {
     // For checking first word with a capital skip white space.
     if (cap_col == 0) {
-      cap_col = (int)getwhitecols(line);
+      cap_col = (int)getwhitecols((char *)line);
     }
 
     // To be able to spell-check over line boundaries copy the end of the
@@ -1171,7 +1171,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
               if (wp->w_p_rl) {                       // reverse line numbers
                 // like rl_mirror(), but keep the space at the end
                 char_u *p2 = (char_u *)skipwhite((char *)extra);
-                p2 = skiptowhite(p2) - 1;
+                p2 = (char_u *)skiptowhite((char *)p2) - 1;
                 for (char_u *p1 = (char_u *)skipwhite((char *)extra); p1 < p2; p1++, p2--) {
                   const char_u t = *p1;
                   *p1 = *p2;
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index b0174de01f..aee8389900 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -2698,12 +2698,12 @@ int cursor_down(long n, int upd_topline)
 /// @param no_esc  Don't add an ESC at the end
 int stuff_inserted(int c, long count, int no_esc)
 {
-  char_u *esc_ptr;
-  char_u *ptr;
-  char_u *last_ptr;
-  char_u last = NUL;
+  char *esc_ptr;
+  char *ptr;
+  char *last_ptr;
+  char last = NUL;
 
-  ptr = get_last_insert();
+  ptr = (char *)get_last_insert();
   if (ptr == NULL) {
     emsg(_(e_noinstext));
     return FAIL;
@@ -2713,7 +2713,7 @@ int stuff_inserted(int c, long count, int no_esc)
   if (c != NUL) {
     stuffcharReadbuff(c);
   }
-  if ((esc_ptr = STRRCHR(ptr, ESC)) != NULL) {
+  if ((esc_ptr = strrchr(ptr, ESC)) != NULL) {
     // remove the ESC.
     *esc_ptr = NUL;
   }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index f89b06843a..508d7cf491 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2042,7 +2042,7 @@ void set_context_for_expression(expand_T *xp, char *arg, cmdidx_T cmdidx)
        || cmdidx == CMD_echomsg)
       && xp->xp_context == EXPAND_EXPRESSION) {
     for (;;) {
-      char *const n = (char *)skiptowhite((char_u *)arg);
+      char *const n = skiptowhite(arg);
 
       if (n == arg || ascii_iswhite_or_nul(*skipwhite(n))) {
         break;
@@ -2658,7 +2658,7 @@ static int eval5(char **arg, typval_T *rettv, int evaluate)
           tv_clear(&var2);
           return FAIL;
         }
-        p = (char *)concat_str((const char_u *)s1, (const char_u *)s2);
+        p = concat_str(s1, s2);
         tv_clear(rettv);
         rettv->v_type = VAR_STRING;
         rettv->vval.v_string = p;
@@ -7400,7 +7400,7 @@ hashtab_T *find_var_ht_dict(const char *name, const size_t name_len, const char
         bool should_free;
         // should_free is ignored as script_sctx will be resolved to a fnmae
         // & new_script_item will consume it.
-        char *sc_name = (char *)get_scriptname(last_set, &should_free);
+        char *sc_name = get_scriptname(last_set, &should_free);
         new_script_item(sc_name, &current_sctx.sc_sid);
       }
     }
@@ -7527,9 +7527,9 @@ int var_item_copy(const vimconv_T *const conv, typval_T *const from, typval_T *c
     } else {
       to->v_type = VAR_STRING;
       to->v_lock = VAR_UNLOCKED;
-      if ((to->vval.v_string = (char *)string_convert((vimconv_T *)conv,
-                                                      (char_u *)from->vval.v_string,
-                                                      NULL))
+      if ((to->vval.v_string = string_convert((vimconv_T *)conv,
+                                              from->vval.v_string,
+                                              NULL))
           == NULL) {
         to->vval.v_string = xstrdup(from->vval.v_string);
       }
@@ -7980,7 +7980,7 @@ void option_last_set_msg(LastSet last_set)
 {
   if (last_set.script_ctx.sc_sid != 0) {
     bool should_free;
-    char *p = (char *)get_scriptname(last_set, &should_free);
+    char *p = get_scriptname(last_set, &should_free);
     verbose_enter();
     msg_puts(_("\n\tLast set from "));
     msg_puts(p);
@@ -8077,7 +8077,7 @@ repeat:
     }
 
     // Append a path separator to a directory.
-    if (os_isdir((char_u *)(*fnamep))) {
+    if (os_isdir(*fnamep)) {
       // Make room for one or two extra characters.
       *fnamep = xstrnsave(*fnamep, STRLEN(*fnamep) + 2);
       xfree(*bufp);          // free any allocated file name
diff --git a/src/nvim/eval/executor.c b/src/nvim/eval/executor.c
index b461456a3a..0e0d0fe696 100644
--- a/src/nvim/eval/executor.c
+++ b/src/nvim/eval/executor.c
@@ -108,8 +108,7 @@ int eexe_mod_op(typval_T *const tv1, const typval_T *const tv2, const char *cons
         const char *tvs = tv_get_string(tv1);
         char numbuf[NUMBUFLEN];
         char *const s =
-          (char *)concat_str((const char_u *)tvs, (const char_u *)tv_get_string_buf(tv2,
-                                                                                    numbuf));
+          concat_str(tvs, tv_get_string_buf(tv2, numbuf));
         tv_clear(tv1);
         tv1->v_type = VAR_STRING;
         tv1->vval.v_string = s;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index c442f5c465..f21011d22b 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -2210,7 +2210,7 @@ static void f_filereadable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
 {
   const char *const p = tv_get_string(&argvars[0]);
   rettv->vval.v_number =
-    (*p && !os_isdir((const char_u *)p) && os_file_is_readable(p));
+    (*p && !os_isdir(p) && os_file_is_readable(p));
 }
 
 /// @return  0 for not writable
@@ -2888,7 +2888,7 @@ static void f_getfsize(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   FileInfo file_info;
   if (os_fileinfo(fname, &file_info)) {
     uint64_t filesize = os_fileinfo_size(&file_info);
-    if (os_isdir((const char_u *)fname)) {
+    if (os_isdir(fname)) {
       rettv->vval.v_number = 0;
     } else {
       rettv->vval.v_number = (varnumber_T)filesize;
@@ -3491,7 +3491,7 @@ static void f_globpath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   if (file != NULL && !error) {
     garray_T ga;
     ga_init(&ga, (int)sizeof(char_u *), 10);
-    globpath((char *)tv_get_string(&argvars[0]), (char_u *)file, &ga, flags);
+    globpath((char *)tv_get_string(&argvars[0]), (char *)file, &ga, flags);
 
     if (rettv->v_type == VAR_STRING) {
       rettv->vval.v_string = ga_concat_strings_sep(&ga, "\n");
@@ -3874,7 +3874,7 @@ static void f_iconv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   if (vimconv.vc_type == CONV_NONE) {
     rettv->vval.v_string = xstrdup(str);
   } else {
-    rettv->vval.v_string = (char *)string_convert(&vimconv, (char_u *)str, NULL);
+    rettv->vval.v_string = string_convert(&vimconv, (char *)str, NULL);
   }
 
   convert_setup(&vimconv, NULL, NULL);
@@ -4131,7 +4131,7 @@ static void f_invert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "isdirectory()" function
 static void f_isdirectory(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  rettv->vval.v_number = os_isdir((const char_u *)tv_get_string(&argvars[0]));
+  rettv->vval.v_number = os_isdir(tv_get_string(&argvars[0]));
 }
 
 /// "islocked()" function
@@ -4458,7 +4458,7 @@ static void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     if (new_cwd && *new_cwd != NUL) {
       cwd = new_cwd;
       // The new cwd must be a directory.
-      if (!os_isdir((const char_u *)cwd)) {
+      if (!os_isdir(cwd)) {
         semsg(_(e_invarg2), "expected valid directory");
         shell_free_argv(argv);
         return;
@@ -5891,7 +5891,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   // their own about CR-LF conversion.
   const char *const fname = tv_get_string(&argvars[0]);
 
-  if (os_isdir((const char_u *)fname)) {
+  if (os_isdir(fname)) {
     semsg(_(e_isadir2), fname);
     return;
   }
@@ -6343,7 +6343,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         if (*q != NUL) {
           cpy = remain;
           remain = (remain
-                    ? (char *)concat_str((char_u *)q - 1, (char_u *)remain)
+                    ? concat_str(q - 1, remain)
                     : xstrdup(q - 1));
           xfree(cpy);
           q[-1] = NUL;
@@ -6402,7 +6402,7 @@ static void f_resolve(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
                        && (p[2] == NUL
                            || vim_ispathsep(p[2])))))) {
         // Prepend "./".
-        cpy = (char *)concat_str((const char_u *)"./", (const char_u *)p);
+        cpy = concat_str("./", p);
         xfree(p);
         p = cpy;
       } else if (!is_relative_to_current) {
@@ -8339,7 +8339,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     char *enc = (char *)enc_locale();
     convert_setup(&conv, p_enc, enc);
     if (conv.vc_type != CONV_NONE) {
-      p = (char *)string_convert(&conv, (char_u *)p, NULL);
+      p = string_convert(&conv, p, NULL);
     }
     char result_buf[256];
     if (p != NULL) {
@@ -8353,7 +8353,7 @@ static void f_strftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
     convert_setup(&conv, enc, p_enc);
     if (conv.vc_type != CONV_NONE) {
-      rettv->vval.v_string = (char *)string_convert(&conv, (char_u *)result_buf, NULL);
+      rettv->vval.v_string = string_convert(&conv, result_buf, NULL);
     } else {
       rettv->vval.v_string = xstrdup(result_buf);
     }
@@ -8599,7 +8599,7 @@ static void f_strptime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   char *enc = (char *)enc_locale();
   convert_setup(&conv, p_enc, enc);
   if (conv.vc_type != CONV_NONE) {
-    fmt = (char *)string_convert(&conv, (char_u *)fmt, NULL);
+    fmt = string_convert(&conv, fmt, NULL);
   }
   if (fmt == NULL
       || os_strptime(str, fmt, &tmval) == NULL
@@ -9070,7 +9070,7 @@ static void f_tagfiles(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   bool first = true;
   tagname_T tn;
-  while (get_tagfname(&tn, first, (char_u *)fname) == OK) {
+  while (get_tagfname(&tn, first, fname) == OK) {
     tv_list_append_string(rettv->vval.v_list, fname, -1);
     first = false;
   }
@@ -9148,7 +9148,7 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     if (new_cwd && *new_cwd != NUL) {
       cwd = new_cwd;
       // The new cwd must be a directory.
-      if (!os_isdir((const char_u *)cwd)) {
+      if (!os_isdir(cwd)) {
         semsg(_(e_invarg2), "expected valid directory");
         shell_free_argv(argv);
         return;
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 152c2eff8f..d5b2b1f2ae 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -2533,7 +2533,7 @@ dict_T *tv_dict_copy(const vimconv_T *const conv, dict_T *const orig, const bool
       new_di = tv_dict_item_alloc((const char *)di->di_key);
     } else {
       size_t len = STRLEN(di->di_key);
-      char *const key = (char *)string_convert(conv, di->di_key, &len);
+      char *const key = (char *)string_convert(conv, (char *)di->di_key, &len);
       if (key == NULL) {
         new_di = tv_dict_item_alloc_len((const char *)di->di_key, len);
       } else {
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 2a48de5e41..b9a94a971b 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -409,7 +409,7 @@ void emsg_funcname(char *ermsg, const char_u *name)
   char_u *p;
 
   if (*name == K_SPECIAL) {
-    p = concat_str((char_u *)"<SNR>", name + 3);
+    p = (char_u *)concat_str("<SNR>", (char *)name + 3);
   } else {
     p = (char_u *)name;
   }
@@ -863,7 +863,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
   fc->rettv = rettv;
   fc->level = ex_nesting_level;
   // Check if this function has a breakpoint.
-  fc->breakpoint = dbg_find_breakpoint(false, fp->uf_name, (linenr_T)0);
+  fc->breakpoint = dbg_find_breakpoint(false, (char *)fp->uf_name, (linenr_T)0);
   fc->dbg_tick = debug_tick;
 
   // Set up fields for closure.
@@ -1058,7 +1058,7 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
 
   bool func_not_yet_profiling_but_should =
     do_profiling_yes
-    && !fp->uf_profiling && has_profiling(false, fp->uf_name, NULL);
+    && !fp->uf_profiling && has_profiling(false, (char *)fp->uf_name, NULL);
 
   if (func_not_yet_profiling_but_should) {
     started_profiling = true;
@@ -2332,7 +2332,7 @@ void ex_function(exarg_T *eap)
       }
 
       // heredoc: Check for ":python <<EOF", ":lua <<EOF", etc.
-      arg = (char_u *)skipwhite((char *)skiptowhite(p));
+      arg = (char_u *)skipwhite(skiptowhite((char *)p));
       if (arg[0] == '<' && arg[1] == '<'
           && ((p[0] == 'p' && p[1] == 'y'
                && (!ASCII_ISALNUM(p[2]) || p[2] == 't'
@@ -2359,12 +2359,12 @@ void ex_function(exarg_T *eap)
 
       // Check for ":let v =<< [trim] EOF"
       //       and ":let [a, b] =<< [trim] EOF"
-      arg = (char_u *)skipwhite((char *)skiptowhite(p));
+      arg = (char_u *)skipwhite(skiptowhite((char *)p));
       if (*arg == '[') {
         arg = (char_u *)vim_strchr((char *)arg, ']');
       }
       if (arg != NULL) {
-        arg = (char_u *)skipwhite((char *)skiptowhite(arg));
+        arg = (char_u *)skipwhite(skiptowhite((char *)arg));
         if (arg[0] == '='
             && arg[1] == '<'
             && arg[2] == '<'
@@ -2379,7 +2379,7 @@ void ex_function(exarg_T *eap)
             heredoc_trimmed =
               vim_strnsave(theline, (size_t)((char_u *)skipwhite((char *)theline) - theline));
           }
-          skip_until = vim_strnsave(p, (size_t)(skiptowhite(p) - p));
+          skip_until = vim_strnsave(p, (size_t)((char_u *)skiptowhite((char *)p) - p));
           do_concat = false;
           is_heredoc = true;
         }
@@ -3105,16 +3105,17 @@ int do_return(exarg_T *eap, int reanimate, int is_cmd, void *rettv)
 
 /// Generate a return command for producing the value of "rettv".  The result
 /// is an allocated string.  Used by report_pending() for verbose messages.
-char_u *get_return_cmd(void *rettv)
+char *get_return_cmd(void *rettv)
 {
-  char_u *s = NULL;
-  char_u *tofree = NULL;
+  char *s = NULL;
+  char *tofree = NULL;
 
   if (rettv != NULL) {
-    tofree = s = (char_u *)encode_tv2echo((typval_T *)rettv, NULL);
+    tofree = encode_tv2echo((typval_T *)rettv, NULL);
+    s = encode_tv2echo((typval_T *)rettv, NULL);
   }
   if (s == NULL) {
-    s = (char_u *)"";
+    s = "";
   }
 
   STRCPY(IObuff, ":return ");
@@ -3123,7 +3124,7 @@ char_u *get_return_cmd(void *rettv)
     STRCPY(IObuff + IOSIZE - 4, "...");
   }
   xfree(tofree);
-  return vim_strsave(IObuff);
+  return (char *)vim_strsave(IObuff);
 }
 
 /// Get next function line.
@@ -3134,12 +3135,12 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
 {
   funccall_T *fcp = (funccall_T *)cookie;
   ufunc_T *fp = fcp->func;
-  char_u *retval;
+  char *retval;
   garray_T *gap;    // growarray with function lines
 
   // If breakpoints have been added/deleted need to check for it.
   if (fcp->dbg_tick != debug_tick) {
-    fcp->breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM);
+    fcp->breakpoint = dbg_find_breakpoint(false, (char *)fp->uf_name, SOURCING_LNUM);
     fcp->dbg_tick = debug_tick;
   }
   if (do_profiling == PROF_YES) {
@@ -3159,7 +3160,7 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
     if (fcp->linenr >= gap->ga_len) {
       retval = NULL;
     } else {
-      retval = (char_u *)xstrdup(((char **)(gap->ga_data))[fcp->linenr++]);
+      retval = xstrdup(((char **)(gap->ga_data))[fcp->linenr++]);
       SOURCING_LNUM = fcp->linenr;
       if (do_profiling == PROF_YES) {
         func_line_start(cookie);
@@ -3169,13 +3170,13 @@ char *get_func_line(int c, void *cookie, int indent, bool do_concat)
 
   // Did we encounter a breakpoint?
   if (fcp->breakpoint != 0 && fcp->breakpoint <= SOURCING_LNUM) {
-    dbg_breakpoint(fp->uf_name, SOURCING_LNUM);
+    dbg_breakpoint((char *)fp->uf_name, SOURCING_LNUM);
     // Find next breakpoint.
-    fcp->breakpoint = dbg_find_breakpoint(false, fp->uf_name, SOURCING_LNUM);
+    fcp->breakpoint = dbg_find_breakpoint(false, (char *)fp->uf_name, SOURCING_LNUM);
     fcp->dbg_tick = debug_tick;
   }
 
-  return (char *)retval;
+  return retval;
 }
 
 /// @return  true if the currently active function should be ended, because a
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index e73bba16e2..75410d40d8 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -81,7 +81,7 @@ static list_T *heredoc_get(exarg_T *eap, char *cmd)
   // The marker is the next word.
   if (*cmd != NUL && *cmd != '"') {
     marker = skipwhite(cmd);
-    p = (char *)skiptowhite((char_u *)marker);
+    p = skiptowhite(marker);
     if (*skipwhite(p) != NUL && *skipwhite(p) != '"') {
       semsg(_(e_trailing_arg), p);
       return NULL;
@@ -587,7 +587,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
           char *s = vim_getenv(name);
 
           if (s != NULL) {
-            tofree = (char *)concat_str((const char_u *)s, (const char_u *)p);
+            tofree = concat_str(s, p);
             p = (const char *)tofree;
             xfree(s);
           }
@@ -663,8 +663,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
           } else if (opt_type == gov_string && stringval != NULL && s != NULL) {
             // string
             char *const oldstringval = stringval;
-            stringval = (char *)concat_str((const char_u *)stringval,
-                                           (const char_u *)s);
+            stringval = concat_str(stringval, s);
             xfree(oldstringval);
             s = stringval;
           }
@@ -705,7 +704,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
       if (p != NULL && op != NULL && *op == '.') {
         s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
         if (s != NULL) {
-          ptofree = (char *)concat_str((char_u *)s, (const char_u *)p);
+          ptofree = concat_str(s, p);
           p = (const char *)ptofree;
           xfree(s);
         }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index ba6594fd7a..fc753cf65c 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -586,11 +586,11 @@ void ex_sort(exarg_T *eap)
       p = s + start_col;
       if (sort_nr) {
         if (sort_what & STR2NR_HEX) {
-          s = (char *)skiptohex((char_u *)p);
+          s = skiptohex(p);
         } else if (sort_what & STR2NR_BIN) {
           s = (char *)skiptobin(p);
         } else {
-          s = (char *)skiptodigit((char_u *)p);
+          s = skiptodigit(p);
         }
         if (s > p && s[-1] == '-') {
           s--;  // include preceding negative sign
@@ -2006,7 +2006,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
     if (!eap->forceit && !eap->append) {
 #ifdef UNIX
       // It is possible to open a directory on Unix.
-      if (os_isdir((char_u *)ffname)) {
+      if (os_isdir(ffname)) {
         semsg(_(e_isadir2), ffname);
         return FAIL;
       }
@@ -3940,8 +3940,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
                 // what matches.  Temporarily replace the line
                 // and change it back afterwards.
                 orig_line = (char *)vim_strsave(ml_get(lnum));
-                char *new_line = (char *)concat_str((char_u *)new_start,
-                                                    (char_u *)sub_firstline + copycol);
+                char *new_line = concat_str(new_start, sub_firstline + copycol);
 
                 // Position the cursor relative to the end of the line, the
                 // previous substitute may have inserted or deleted characters
@@ -4939,7 +4938,7 @@ char *skip_vimgrep_pat(char *p, char **s, int *flags)
     if (s != NULL) {
       *s = p;
     }
-    p = (char *)skiptowhite((char_u *)p);
+    p = skiptowhite(p);
     if (s != NULL && *p != NUL) {
       *p++ = NUL;
     }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 08709ec228..1fa14f4e4f 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -462,7 +462,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       if (breakpoint != NULL && dbg_tick != NULL
           && *dbg_tick != debug_tick) {
         *breakpoint = dbg_find_breakpoint(getline_equal(fgetline, cookie, getsourceline),
-                                          (char_u *)fname, SOURCING_LNUM);
+                                          fname, SOURCING_LNUM);
         *dbg_tick = debug_tick;
       }
 
@@ -471,10 +471,10 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
 
       // Did we encounter a breakpoint?
       if (breakpoint != NULL && *breakpoint != 0 && *breakpoint <= SOURCING_LNUM) {
-        dbg_breakpoint((char_u *)fname, SOURCING_LNUM);
+        dbg_breakpoint(fname, SOURCING_LNUM);
         // Find next breakpoint.
         *breakpoint = dbg_find_breakpoint(getline_equal(fgetline, cookie, getsourceline),
-                                          (char_u *)fname, SOURCING_LNUM);
+                                          fname, SOURCING_LNUM);
         *dbg_tick = debug_tick;
       }
       if (do_profiling == PROF_YES) {
@@ -639,8 +639,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
           // Check for the next breakpoint at or after the ":while"
           // or ":for".
           if (breakpoint != NULL) {
-            *breakpoint = dbg_find_breakpoint(getline_equal(fgetline, cookie, getsourceline),
-                                              (char_u *)fname,
+            *breakpoint = dbg_find_breakpoint(getline_equal(fgetline, cookie, getsourceline), fname,
                                               ((wcmd_T *)lines_ga.ga_data)[current_line].lnum - 1);
             *dbg_tick = debug_tick;
           }
@@ -3665,7 +3664,7 @@ char *replace_makeprg(exarg_T *eap, char *arg, char **cmdlinep)
       STRCAT(new_cmdline, arg);
     }
 
-    msg_make((char_u *)arg);
+    msg_make(arg);
 
     // 'eap->cmd' is not set here, because it is not used at CMD_make
     xfree(*cmdlinep);
@@ -3807,7 +3806,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
     // done by ExpandOne() below.
 #ifdef UNIX
     if (!has_wildcards) {
-      backslash_halve((char_u *)eap->arg);
+      backslash_halve(eap->arg);
     }
 #else
     backslash_halve((char_u *)eap->arg);
@@ -5032,7 +5031,7 @@ static void ex_tabs(exarg_T *eap)
 
     msg_putchar('\n');
     vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
-    msg_outtrans_attr(IObuff, HL_ATTR(HLF_T));
+    msg_outtrans_attr((char *)IObuff, HL_ATTR(HLF_T));
     ui_flush();            // output one line at a time
     os_breakcheck();
 
@@ -6154,7 +6153,7 @@ FILE *open_exfile(char_u *fname, int forceit, char *mode)
 {
 #ifdef UNIX
   // with Unix it is possible to open a directory
-  if (os_isdir(fname)) {
+  if (os_isdir((char *)fname)) {
     semsg(_(e_isadir2), fname);
     return NULL;
   }
@@ -6881,7 +6880,7 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
     if (src[*usedlen] == '<') {
       (*usedlen)++;
       char *s;
-      if ((s = (char *)STRRCHR(result, '.')) != NULL
+      if ((s = strrchr(result, '.')) != NULL
           && s >= path_tail(result)) {
         resultlen = (size_t)(s - result);
       }
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index e2b02929d2..11795684cf 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -726,14 +726,14 @@ static void report_pending(int action, int pending, void *value)
     break;
   case CSTP_RETURN:
     // ":return" command producing value, allocated
-    s = (char *)get_return_cmd(value);
+    s = get_return_cmd(value);
     break;
 
   default:
     if (pending & CSTP_THROW) {
       vim_snprintf((char *)IObuff, IOSIZE,
                    mesg, _("Exception"));
-      mesg = (char *)concat_str(IObuff, (char_u *)": %s");
+      mesg = concat_str((char *)IObuff, ": %s");
       s = ((except_T *)value)->value;
     } else if ((pending & CSTP_ERROR) && (pending & CSTP_INTERRUPT)) {
       s = _("Error and interrupt");
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 66c3327ce3..0998bdd867 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -3198,7 +3198,7 @@ static void draw_cmdline(int start, int len)
       }
     }
 
-    msg_outtrans_len((char_u *)arshape_buf, newlen);
+    msg_outtrans_len(arshape_buf, newlen);
   } else {
 draw_cmdline_no_arabicshape:
     if (kv_size(ccline.last_colors.colors)) {
@@ -3213,7 +3213,7 @@ draw_cmdline_no_arabicshape:
                               chunk.attr);
       }
     } else {
-      msg_outtrans_len(ccline.cmdbuff + start, len);
+      msg_outtrans_len((char *)ccline.cmdbuff + start, len);
     }
   }
 }
diff --git a/src/nvim/ex_session.c b/src/nvim/ex_session.c
index 453de89aea..e907c45e79 100644
--- a/src/nvim/ex_session.c
+++ b/src/nvim/ex_session.c
@@ -956,7 +956,7 @@ void ex_mkrc(exarg_T *eap)
   }
 
   // When using 'viewdir' may have to create the directory.
-  if (using_vdir && !os_isdir(p_vdir)) {
+  if (using_vdir && !os_isdir((char *)p_vdir)) {
     vim_mkdir_emsg((const char *)p_vdir, 0755);
   }
 
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index a990043017..bbc6e53aa8 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -471,7 +471,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
 
     STRCPY(buf, ff_expand_buffer);
     STRCPY(buf + eb_len, search_ctx->ffsc_fix_path);
-    if (os_isdir(buf)) {
+    if (os_isdir((char *)buf)) {
       STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
       add_pathsep((char *)ff_expand_buffer);
     } else {
@@ -796,7 +796,7 @@ char_u *vim_findfile(void *search_ctx_arg)
            */
           for (int i = stackp->ffs_filearray_cur; i < stackp->ffs_filearray_size; i++) {
             if (!path_with_url(stackp->ffs_filearray[i])
-                && !os_isdir((char_u *)stackp->ffs_filearray[i])) {
+                && !os_isdir(stackp->ffs_filearray[i])) {
               continue;                 // not a directory
             }
             // prepare the filename to be checked for existence below
@@ -828,7 +828,7 @@ char_u *vim_findfile(void *search_ctx_arg)
                    || (os_path_exists(file_path)
                        && (search_ctx->ffsc_find_what == FINDFILE_BOTH
                            || ((search_ctx->ffsc_find_what == FINDFILE_DIR)
-                               == os_isdir(file_path)))))
+                               == os_isdir((char *)file_path)))))
 #ifndef FF_VERBOSE
                   && (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
                                        file_path, (char_u *)"") == OK)
@@ -885,7 +885,7 @@ char_u *vim_findfile(void *search_ctx_arg)
         } else {
           // still wildcards left, push the directories for further search
           for (int i = stackp->ffs_filearray_cur; i < stackp->ffs_filearray_size; i++) {
-            if (!os_isdir((char_u *)stackp->ffs_filearray[i])) {
+            if (!os_isdir(stackp->ffs_filearray[i])) {
               continue;                 // not a directory
             }
             ff_push(search_ctx,
@@ -909,7 +909,7 @@ char_u *vim_findfile(void *search_ctx_arg)
                        stackp->ffs_fix_path) == 0) {
             continue;             // don't repush same directory
           }
-          if (!os_isdir((char_u *)stackp->ffs_filearray[i])) {
+          if (!os_isdir(stackp->ffs_filearray[i])) {
             continue;               // not a directory
           }
           ff_push(search_ctx,
@@ -1476,7 +1476,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
               (os_path_exists((char_u *)NameBuff)
                && (find_what == FINDFILE_BOTH
                    || ((find_what == FINDFILE_DIR)
-                       == os_isdir((char_u *)NameBuff))))) {
+                       == os_isdir(NameBuff))))) {
             file_name = vim_strsave((char_u *)NameBuff);
             goto theend;
           }
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 450c608fad..d67cd36a85 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -143,7 +143,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   msg_scroll = msg_scroll_save;
   msg_scrolled_ign = true;
   // may truncate the message to avoid a hit-return prompt
-  msg_outtrans_attr(msg_may_trunc(false, IObuff), attr);
+  msg_outtrans_attr((char *)msg_may_trunc(false, IObuff), attr);
   msg_clr_eos();
   ui_flush();
   msg_scrolled_ign = false;
@@ -2775,7 +2775,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
         if (trailing_pathseps) {
           IObuff[dir_len - 2] = NUL;
         }
-        if (*dirp == NUL && !os_isdir(IObuff)) {
+        if (*dirp == NUL && !os_isdir((char *)IObuff)) {
           int ret;
           char *failed_dir;
           if ((ret = os_mkdir_recurse((char *)IObuff, 0755, &failed_dir)) != 0) {
@@ -2936,7 +2936,7 @@ nobackup:
         if (trailing_pathseps) {
           IObuff[dir_len - 2] = NUL;
         }
-        if (*dirp == NUL && !os_isdir(IObuff)) {
+        if (*dirp == NUL && !os_isdir((char *)IObuff)) {
           int ret;
           char *failed_dir;
           if ((ret = os_mkdir_recurse((char *)IObuff, 0755, &failed_dir)) != 0) {
@@ -4948,7 +4948,7 @@ int buf_check_timestamp(buf_T *buf)
       buf_store_file_info(buf, &file_info);
     }
 
-    if (os_isdir((char_u *)buf->b_fname)) {
+    if (os_isdir(buf->b_fname)) {
       // Don't do anything for a directory.  Might contain the file explorer.
     } else if ((buf->b_p_ar >= 0 ? buf->b_p_ar : p_ar)
                && !bufIsChanged(buf) && file_info_ok) {
@@ -5318,7 +5318,7 @@ static void vim_mktempdir(void)
   for (size_t i = 0; i < ARRAY_SIZE(temp_dirs); i++) {
     // Expand environment variables, leave room for "/tmp/nvim.<user>/XXXXXX/999999999".
     expand_env((char *)temp_dirs[i], tmp, TEMP_FILE_PATH_MAXLEN - 64);
-    if (!os_isdir((char_u *)tmp)) {
+    if (!os_isdir(tmp)) {
       continue;
     }
 
@@ -5328,7 +5328,7 @@ static void vim_mktempdir(void)
     xstrlcat(tmp, user, sizeof(tmp));
     (void)os_mkdir(tmp, 0700);  // Always create, to avoid a race.
     bool owned = os_file_owned(tmp);
-    bool isdir = os_isdir((char_u *)tmp);
+    bool isdir = os_isdir(tmp);
 #ifdef UNIX
     int perm = os_getperm(tmp);  // XDG_RUNTIME_DIR must be owned by the user, mode 0700.
     bool valid = isdir && owned && 0700 == (perm & 0777);
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index bb8cd5a1eb..0a9457ef35 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1280,7 +1280,7 @@ void restore_typeahead(tasave_T *tp)
 /// Open a new script file for the ":source!" command.
 ///
 /// @param directly  when true execute directly
-void openscript(char_u *name, bool directly)
+void openscript(char *name, bool directly)
 {
   if (curscript + 1 == NSCRIPT) {
     emsg(_(e_nesting));
@@ -1302,7 +1302,7 @@ void openscript(char_u *name, bool directly)
     curscript++;
   }
   // use NameBuff for expanded name
-  expand_env((char *)name, NameBuff, MAXPATHL);
+  expand_env(name, NameBuff, MAXPATHL);
   int error;
   if ((scriptin[curscript] = file_open_new(&error, (char *)NameBuff,
                                            kFileReadOnly, 0)) == NULL) {
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 77784defd1..ddbe727db9 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -177,7 +177,7 @@ EXTERN bool msg_scrolled_ign INIT(= false);
 // is reset before the screen is redrawn, so we need to keep track of this.
 EXTERN bool msg_did_scroll INIT(= false);
 
-EXTERN char_u *keep_msg INIT(= NULL);       // msg to be shown after redraw
+EXTERN char *keep_msg INIT(= NULL);         // msg to be shown after redraw
 EXTERN int keep_msg_attr INIT(= 0);         // highlight attr for keep_msg
 EXTERN bool need_fileinfo INIT(= false);    // do fileinfo() after redraw
 EXTERN int msg_scroll INIT(= false);        // msg_start() will scroll
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 6e424f2fd6..602fa8b71d 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -3062,7 +3062,8 @@ int mch_print_text_out(char_u *const textp, size_t len)
 
   if (prt_do_conv) {
     // Convert from multi-byte to 8-bit encoding
-    tofree = p = string_convert(&prt_conv, p, &len);
+    p = (char_u *)string_convert(&prt_conv, (char *)p, &len);
+    tofree = p;
     if (p == NULL) {
       p = (char_u *)"";
       len = 0;
diff --git a/src/nvim/help.c b/src/nvim/help.c
index b25fabca48..245d80489f 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -741,8 +741,8 @@ void fix_help_buffer(void)
                 const char *const f2 = fnames[i2];
                 const char *const t1 = path_tail(f1);
                 const char *const t2 = path_tail(f2);
-                const char *const e1 = (char *)STRRCHR(t1, '.');
-                const char *const e2 = (char *)STRRCHR(t2, '.');
+                const char *const e1 = strrchr(t1, '.');
+                const char *const e2 = strrchr(t2, '.');
                 if (e1 == NULL || e2 == NULL) {
                   continue;
                 }
@@ -811,7 +811,7 @@ void fix_help_buffer(void)
                 } else {
                   // Do the conversion.  If it fails
                   // use the unconverted text.
-                  cp = (char *)string_convert(&vc, IObuff, NULL);
+                  cp = string_convert(&vc, (char *)IObuff, NULL);
                   if (cp == NULL) {
                     cp = (char *)IObuff;
                   }
@@ -1163,13 +1163,13 @@ void ex_helptags(exarg_T *eap)
   }
 
   if (STRCMP(eap->arg, "ALL") == 0) {
-    do_in_path((char_u *)p_rtp, "doc", DIP_ALL + DIP_DIR, helptags_cb, &add_help_tags);
+    do_in_path(p_rtp, "doc", DIP_ALL + DIP_DIR, helptags_cb, &add_help_tags);
   } else {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_DIRECTORIES;
     dirname = (char *)ExpandOne(&xpc, (char_u *)eap->arg, NULL,
                                 WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
-    if (dirname == NULL || !os_isdir((char_u *)dirname)) {
+    if (dirname == NULL || !os_isdir(dirname)) {
       semsg(_("E150: Not a directory: %s"), eap->arg);
     } else {
       do_helptags(dirname, add_help_tags, false);
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index e2d4a81345..ed1f0185b7 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -852,14 +852,14 @@ void do_highlight(const char *line, const bool forceit, const bool init)
   }
 
   // Isolate the name.
-  name_end = (const char *)skiptowhite((const char_u *)line);
+  name_end = (const char *)skiptowhite(line);
   linep = (const char *)skipwhite(name_end);
 
   // Check for "default" argument.
   if (strncmp(line, "default", (size_t)(name_end - line)) == 0) {
     dodefault = true;
     line = linep;
-    name_end = (const char *)skiptowhite((const char_u *)line);
+    name_end = (const char *)skiptowhite(line);
     linep = (const char *)skipwhite(name_end);
   }
 
@@ -891,9 +891,9 @@ void do_highlight(const char *line, const bool forceit, const bool init)
     int to_id;
     HlGroup *hlgroup = NULL;
 
-    from_end = (const char *)skiptowhite((const char_u *)from_start);
+    from_end = (const char *)skiptowhite(from_start);
     to_start = (const char *)skipwhite(from_end);
-    to_end   = (const char *)skiptowhite((const char_u *)to_start);
+    to_end   = (const char *)skiptowhite(to_start);
 
     if (ends_excmd((uint8_t)(*from_start))
         || ends_excmd((uint8_t)(*to_start))) {
@@ -969,7 +969,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
       redraw_all_later(UPD_NOT_VALID);
       return;
     }
-    name_end = (const char *)skiptowhite((const char_u *)line);
+    name_end = (const char *)skiptowhite(line);
     linep = (const char *)skipwhite(name_end);
   }
 
@@ -1054,7 +1054,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
         }
       } else {
         arg_start = linep;
-        linep = (const char *)skiptowhite((const char_u *)linep);
+        linep = (const char *)skiptowhite(linep);
       }
       if (linep == arg_start) {
         semsg(_("E417: missing argument: %s"), key_start);
@@ -2074,13 +2074,13 @@ void set_context_in_highlight_cmd(expand_T *xp, const char *arg)
 
   // (part of) subcommand already typed
   if (*arg != NUL) {
-    const char *p = (const char *)skiptowhite((const char_u *)arg);
+    const char *p = (const char *)skiptowhite(arg);
     if (*p != NUL) {  // Past "default" or group name.
       include_default = 0;
       if (strncmp("default", arg, (unsigned)(p - arg)) == 0) {
         arg = (const char *)skipwhite(p);
         xp->xp_pattern = (char *)arg;
-        p = (const char *)skiptowhite((const char_u *)arg);
+        p = (const char *)skiptowhite(arg);
       }
       if (*p != NUL) {                          // past group name
         include_link = 0;
@@ -2090,10 +2090,10 @@ void set_context_in_highlight_cmd(expand_T *xp, const char *arg)
         if (strncmp("link", arg, (unsigned)(p - arg)) == 0
             || strncmp("clear", arg, (unsigned)(p - arg)) == 0) {
           xp->xp_pattern = skipwhite(p);
-          p = (const char *)skiptowhite((char_u *)xp->xp_pattern);
+          p = (const char *)skiptowhite(xp->xp_pattern);
           if (*p != NUL) {  // Past first group name.
             xp->xp_pattern = skipwhite(p);
-            p = (const char *)skiptowhite((char_u *)xp->xp_pattern);
+            p = (const char *)skiptowhite(xp->xp_pattern);
           }
         }
         if (*p != NUL) {  // Past group name(s).
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 2a9d2c357e..9413abb2e1 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -153,10 +153,10 @@ void set_context_in_cscope_cmd(expand_T *xp, const char *arg, cmdidx_T cmdidx)
 
   // (part of) subcommand already typed
   if (*arg != NUL) {
-    const char *p = (const char *)skiptowhite((const char_u *)arg);
+    const char *p = (const char *)skiptowhite(arg);
     if (*p != NUL) {  // Past first word.
       xp->xp_pattern = skipwhite(p);
-      if (*skiptowhite((char_u *)xp->xp_pattern) != NUL) {
+      if (*skiptowhite(xp->xp_pattern) != NUL) {
         xp->xp_context = EXPAND_NOTHING;
       } else if (STRNICMP(arg, "add", p - arg) == 0) {
         xp->xp_context = EXPAND_FILES;
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 8ef6667374..166695ef5b 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -676,10 +676,10 @@ static int cin_first_id_amount(void)
 
   line = get_cursor_line_ptr();
   p = (char_u *)skipwhite((char *)line);
-  len = (int)(skiptowhite(p) - p);
+  len = (int)((char_u *)skiptowhite((char *)p) - p);
   if (len == 6 && STRNCMP(p, "static", 6) == 0) {
     p = (char_u *)skipwhite((char *)p + 6);
-    len = (int)(skiptowhite(p) - p);
+    len = (int)((char_u *)skiptowhite((char *)p) - p);
   }
   if (len == 6 && STRNCMP(p, "struct", 6) == 0) {
     p = (char_u *)skipwhite((char *)p + 6);
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 3c32d0755e..ba0a36cafe 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -3767,7 +3767,7 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
 /// Sets the global variables: compl_col, compl_length and compl_pattern.
 static int get_wholeline_compl_info(char_u *line, colnr_T curs_col)
 {
-  compl_col = (colnr_T)getwhitecols(line);
+  compl_col = (colnr_T)getwhitecols((char *)line);
   compl_length = (int)curs_col - (int)compl_col;
   if (compl_length < 0) {  // cursor in indent: empty pattern
     compl_length = 0;
@@ -3985,7 +3985,7 @@ static void ins_compl_continue_search(char_u *line)
       // first non_blank in the line, if it is not a wordchar
       // include it to get a better pattern, but then we don't
       // want the "\\<" prefix, check it below.
-      compl_col = (colnr_T)getwhitecols(line);
+      compl_col = (colnr_T)getwhitecols((char *)line);
       compl_startpos.col = compl_col;
       compl_startpos.lnum = curwin->w_cursor.lnum;
       compl_cont_status &= ~CONT_SOL;  // clear SOL if present
diff --git a/src/nvim/locale.c b/src/nvim/locale.c
index ba0566011c..3e0774c096 100644
--- a/src/nvim/locale.c
+++ b/src/nvim/locale.c
@@ -188,7 +188,7 @@ void ex_language(exarg_T *eap)
   // Check for "messages {name}", "ctype {name}" or "time {name}" argument.
   // Allow abbreviation, but require at least 3 characters to avoid
   // confusion with a two letter language name "me" or "ct".
-  p = (char *)skiptowhite((char_u *)eap->arg);
+  p = skiptowhite(eap->arg);
   if ((*p == NUL || ascii_iswhite(*p)) && p - eap->arg >= 3) {
     if (STRNICMP(eap->arg, "messages", p - eap->arg) == 0) {
       what = VIM_LC_MESSAGES;
diff --git a/src/nvim/log.c b/src/nvim/log.c
index 9f25543be7..9bdf327430 100644
--- a/src/nvim/log.c
+++ b/src/nvim/log.c
@@ -63,13 +63,13 @@ static void log_path_init(void)
   expand_env("$" ENV_LOGFILE, log_file_path, (int)size - 1);
   if (strequal("$" ENV_LOGFILE, log_file_path)
       || log_file_path[0] == '\0'
-      || os_isdir((char_u *)log_file_path)
+      || os_isdir(log_file_path)
       || !log_try_create(log_file_path)) {
     // Make $XDG_STATE_HOME if it does not exist.
     char *loghome = get_xdg_home(kXDGStateHome);
     char *failed_dir = NULL;
     bool log_dir_failure = false;
-    if (!os_isdir((char_u *)loghome)) {
+    if (!os_isdir(loghome)) {
       log_dir_failure = (os_mkdir_recurse(loghome, 0700, &failed_dir) != 0);
     }
     XFREE_CLEAR(loghome);
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 7e8dda6ca1..1b874e673a 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -501,7 +501,7 @@ static int nlua_iconv(lua_State *lstate)
   vimconv.vc_type = CONV_NONE;
   convert_setup_ext(&vimconv, from, false, to, false);
 
-  char_u *ret = string_convert(&vimconv, (char_u *)str, &str_len);
+  char_u *ret = (char_u *)string_convert(&vimconv, (char *)str, &str_len);
 
   convert_setup(&vimconv, NULL, NULL);
 
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 09a387262c..883f946cad 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1342,8 +1342,8 @@ scripterror:
       ga_grow(&global_alist.al_ga, 1);
       char *p = xstrdup(argv[0]);
 
-      if (parmp->diff_mode && os_isdir((char_u *)p) && GARGCOUNT > 0
-          && !os_isdir((char_u *)alist_name(&GARGLIST[0]))) {
+      if (parmp->diff_mode && os_isdir(p) && GARGCOUNT > 0
+          && !os_isdir(alist_name(&GARGLIST[0]))) {
         char *r = concat_fnames(p, path_tail(alist_name(&GARGLIST[0])), true);
         xfree(p);
         p = r;
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 92a7c7c4b0..9df4d416ff 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -922,7 +922,7 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
         snprintf((char *)IObuff, IOSIZE, " %c %6" PRIdLINENR " %4d ", c, p->lnum, p->col);
         msg_outtrans((char *)IObuff);
         if (name != NULL) {
-          msg_outtrans_attr(name, current ? HL_ATTR(HLF_D) : 0);
+          msg_outtrans_attr((char *)name, current ? HL_ATTR(HLF_D) : 0);
         }
       }
       ui_flush();  // show one line at a time
@@ -1052,7 +1052,7 @@ void ex_jumps(exarg_T *eap)
                i > curwin->w_jumplistidx ? i - curwin->w_jumplistidx : curwin->w_jumplistidx - i,
                curwin->w_jumplist[i].fmark.mark.lnum, curwin->w_jumplist[i].fmark.mark.col);
       msg_outtrans((char *)IObuff);
-      msg_outtrans_attr(name,
+      msg_outtrans_attr((char *)name,
                         curwin->w_jumplist[i].fmark.fnum == curbuf->b_fnum
                         ? HL_ATTR(HLF_D) : 0);
       xfree(name);
@@ -1097,7 +1097,7 @@ void ex_changes(exarg_T *eap)
               curbuf->b_changelist[i].mark.col);
       msg_outtrans((char *)IObuff);
       name = mark_line(&curbuf->b_changelist[i].mark, 17);
-      msg_outtrans_attr(name, HL_ATTR(HLF_D));
+      msg_outtrans_attr((char *)name, HL_ATTR(HLF_D));
       xfree(name);
       os_breakcheck();
     }
diff --git a/src/nvim/match.c b/src/nvim/match.c
index cabd008591..48f0d0fc05 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -1183,7 +1183,7 @@ void ex_match(exarg_T *eap)
               && (ascii_iswhite(eap->arg[4]) || ends_excmd(eap->arg[4])))) {
     end = (char_u *)eap->arg + 4;
   } else {
-    p = skiptowhite((char_u *)eap->arg);
+    p = (char_u *)skiptowhite(eap->arg);
     if (!eap->skip) {
       g = vim_strnsave((char_u *)eap->arg, (size_t)(p - (char_u *)eap->arg));
     }
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index e703280032..b874f0dc94 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1942,7 +1942,7 @@ void utf_find_illegal(void)
     p = get_cursor_pos_ptr();
     if (vimconv.vc_type != CONV_NONE) {
       xfree(tofree);
-      tofree = string_convert(&vimconv, p, NULL);
+      tofree = (char_u *)string_convert(&vimconv, (char *)p, NULL);
       if (tofree == NULL) {
         break;
       }
@@ -2521,16 +2521,14 @@ int convert_setup_ext(vimconv_T *vcp, char_u *from, bool from_unicode_is_utf8, c
   return OK;
 }
 
-/*
- * Convert text "ptr[*lenp]" according to "vcp".
- * Returns the result in allocated memory and sets "*lenp".
- * When "lenp" is NULL, use NUL terminated strings.
- * Illegal chars are often changed to "?", unless vcp->vc_fail is set.
- * When something goes wrong, NULL is returned and "*lenp" is unchanged.
- */
-char_u *string_convert(const vimconv_T *const vcp, char_u *ptr, size_t *lenp)
+/// Convert text "ptr[*lenp]" according to "vcp".
+/// Returns the result in allocated memory and sets "*lenp".
+/// When "lenp" is NULL, use NUL terminated strings.
+/// Illegal chars are often changed to "?", unless vcp->vc_fail is set.
+/// When something goes wrong, NULL is returned and "*lenp" is unchanged.
+char *string_convert(const vimconv_T *const vcp, char *ptr, size_t *lenp)
 {
-  return string_convert_ext(vcp, ptr, lenp, NULL);
+  return (char *)string_convert_ext(vcp, (char_u *)ptr, lenp, NULL);
 }
 
 /*
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 044655ef2b..b0b6b675cb 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -857,7 +857,7 @@ void ml_recover(bool checkext)
   if ((hp = mf_get(mfp, 0, 1)) == NULL) {
     msg_start();
     msg_puts_attr(_("Unable to read block 0 from "), attr | MSG_HIST);
-    msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
+    msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
     msg_puts_attr(_("\nMaybe no changes were made or Vim did not update the swap file."),
                   attr | MSG_HIST);
     msg_end();
@@ -866,7 +866,7 @@ void ml_recover(bool checkext)
   b0p = hp->bh_data;
   if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0) {
     msg_start();
-    msg_outtrans_attr(mfp->mf_fname, MSG_HIST);
+    msg_outtrans_attr((char *)mfp->mf_fname, MSG_HIST);
     msg_puts_attr(_(" cannot be used with this version of Vim.\n"),
                   MSG_HIST);
     msg_puts_attr(_("Use Vim version 3.0.\n"), MSG_HIST);
@@ -879,7 +879,7 @@ void ml_recover(bool checkext)
   }
   if (b0_magic_wrong(b0p)) {
     msg_start();
-    msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
+    msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
     msg_puts_attr(_(" cannot be used on this computer.\n"),
                   attr | MSG_HIST);
     msg_puts_attr(_("The file was created on "), attr | MSG_HIST);
@@ -901,7 +901,7 @@ void ml_recover(bool checkext)
     mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size));
     if (mfp->mf_page_size < previous_page_size) {
       msg_start();
-      msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
+      msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
       msg_puts_attr(_(" has been damaged (page size is smaller than minimum value).\n"),
                     attr | MSG_HIST);
       msg_end();
@@ -3614,7 +3614,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
     fname[n - 1]--;                     // ".swo", ".swn", etc.
   }
 
-  if (os_isdir((char_u *)dir_name)) {
+  if (os_isdir(dir_name)) {
     *found_existing_dir = true;
   } else if (!*found_existing_dir && **dirp == NUL) {
     int ret;
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index b1d729f71d..cb6918cd27 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -853,7 +853,7 @@ static void show_menus_recursive(vimmenu_T *menu, int modes, int depth)
       msg_puts(" ");
     }
     // Same highlighting as for directories!?
-    msg_outtrans_attr((char_u *)menu->name, HL_ATTR(HLF_D));
+    msg_outtrans_attr(menu->name, HL_ATTR(HLF_D));
   }
 
   if (menu != NULL && menu->children == NULL) {
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 4fba78feca..80b5f53f4e 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -265,7 +265,7 @@ void msg_multiline_attr(const char *s, int attr, bool check_int, bool *need_clea
   // Print the rest of the message. We know there is no special
   // character because strpbrk returned NULL
   if (*s != NUL) {
-    msg_outtrans_attr((char_u *)s, attr);
+    msg_outtrans_attr(s, attr);
   }
 }
 
@@ -325,7 +325,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 
   // Add message to history (unless it's a repeated kept message or a
   // truncated message)
-  if ((const char_u *)s != keep_msg
+  if (s != keep_msg
       || (*s != '<'
           && last_msg_hist != NULL
           && last_msg_hist->msg != NULL
@@ -344,7 +344,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
   if (multiline) {
     msg_multiline_attr(s, attr, false, &need_clear);
   } else {
-    msg_outtrans_attr((char_u *)s, attr);
+    msg_outtrans_attr(s, attr);
   }
   if (need_clear) {
     msg_clr_eos();
@@ -1307,7 +1307,7 @@ void wait_return(int redraw)
   emsg_on_display = false;      // can delete error message now
   lines_left = -1;              // reset lines_left at next msg_start()
   reset_last_sourcing();
-  if (keep_msg != NULL && vim_strsize((char *)keep_msg) >=
+  if (keep_msg != NULL && vim_strsize(keep_msg) >=
       (Rows - cmdline_row - 1) * Columns + sc_col) {
     XFREE_CLEAR(keep_msg);          // don't redisplay message, it's too long
   }
@@ -1350,7 +1350,7 @@ void set_keep_msg(char *s, int attr)
 {
   xfree(keep_msg);
   if (s != NULL && msg_silent == 0) {
-    keep_msg = vim_strsave((char_u *)s);
+    keep_msg = xstrdup(s);
   } else {
     keep_msg = NULL;
   }
@@ -1510,7 +1510,7 @@ void msg_home_replace_hl(char_u *fname)
 static void msg_home_replace_attr(char_u *fname, int attr)
 {
   char *name = home_replace_save(NULL, (char *)fname);
-  msg_outtrans_attr((char_u *)name, attr);
+  msg_outtrans_attr(name, attr);
   xfree(name);
 }
 
@@ -1521,29 +1521,29 @@ static void msg_home_replace_attr(char_u *fname, int attr)
 /// @return  the number of characters it takes on the screen.
 int msg_outtrans(char *str)
 {
-  return msg_outtrans_attr((char_u *)str, 0);
+  return msg_outtrans_attr(str, 0);
 }
 
-int msg_outtrans_attr(const char_u *str, int attr)
+int msg_outtrans_attr(const char *str, int attr)
 {
-  return msg_outtrans_len_attr(str, (int)STRLEN(str), attr);
+  return msg_outtrans_len_attr((char_u *)str, (int)STRLEN(str), attr);
 }
 
-int msg_outtrans_len(const char_u *str, int len)
+int msg_outtrans_len(const char *str, int len)
 {
-  return msg_outtrans_len_attr(str, len, 0);
+  return msg_outtrans_len_attr((char_u *)str, len, 0);
 }
 
 /// Output one character at "p".
 /// Handles multi-byte characters.
 ///
 /// @return  pointer to the next character.
-char_u *msg_outtrans_one(char_u *p, int attr)
+char *msg_outtrans_one(char *p, int attr)
 {
   int l;
 
-  if ((l = utfc_ptr2len((char *)p)) > 1) {
-    msg_outtrans_len_attr(p, l, attr);
+  if ((l = utfc_ptr2len(p)) > 1) {
+    msg_outtrans_len_attr((char_u *)p, l, attr);
     return p + l;
   }
   msg_puts_attr((const char *)transchar_byte(*p), attr);
@@ -1628,12 +1628,13 @@ int msg_outtrans_len_attr(const char_u *msgstr, int len, int attr)
   return retval;
 }
 
-void msg_make(char_u *arg)
+void msg_make(char *arg)
 {
   int i;
-  static char_u *str = (char_u *)"eeffoc", *rs = (char_u *)"Plon#dqg#vxjduB";
+  static char *str = "eeffoc";
+  static char *rs = "Plon#dqg#vxjduB";
 
-  arg = (char_u *)skipwhite((char *)arg);
+  arg = skipwhite(arg);
   for (i = 5; *arg && i >= 0; i--) {
     if (*arg++ != str[i]) {
       break;
@@ -1976,13 +1977,13 @@ void msg_prt_line(char_u *s, int list)
 /// Use grid_puts() to output one multi-byte character.
 ///
 /// @return  the pointer "s" advanced to the next character.
-static char_u *screen_puts_mbyte(char_u *s, int l, int attr)
+static char *screen_puts_mbyte(char *s, int l, int attr)
 {
   int cw;
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), attr);
 
   msg_didout = true;            // remember that line is not empty
-  cw = utf_ptr2cells((char *)s);
+  cw = utf_ptr2cells(s);
   if (cw > 1
       && (cmdmsg_rl ? msg_col <= 1 : msg_col == Columns - 1)) {
     // Doesn't fit, print a highlighted '>' to fill it up.
@@ -1990,7 +1991,7 @@ static char_u *screen_puts_mbyte(char_u *s, int l, int attr)
     return s;
   }
 
-  grid_puts_len(&msg_grid_adj, (char *)s, l, msg_row, msg_col, attr);
+  grid_puts_len(&msg_grid_adj, s, l, msg_row, msg_col, attr);
   if (cmdmsg_rl) {
     msg_col -= cw;
     if (msg_col == 0) {
@@ -2197,7 +2198,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       // ourselves).
       if (t_col > 0) {
         // output postponed text
-        t_puts(&t_col, t_s, s, attr);
+        t_puts(&t_col, (char *)t_s, (char *)s, attr);
       }
 
       // When no more prompt and no more room, truncate here
@@ -2222,7 +2223,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
         } else {
           l = utfc_ptr2len((char *)s);
         }
-        s = screen_puts_mbyte((char_u *)s, l, attr);
+        s = (char_u *)screen_puts_mbyte((char *)s, l, attr);
         did_last_char = true;
       } else {
         did_last_char = false;
@@ -2281,7 +2282,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
     if (t_col > 0 && (wrap || *s == '\r' || *s == '\b'
                       || *s == '\t' || *s == BELL)) {
       // Output any postponed text.
-      t_puts(&t_col, t_s, s, attr);
+      t_puts(&t_col, (char *)t_s, (char *)s, attr);
     }
 
     if (wrap && p_more && !recurse) {
@@ -2324,7 +2325,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       // characters and draw them all at once later.
       if (cmdmsg_rl || (cw > 1 && msg_col + t_col >= Columns - 1)) {
         if (l > 1) {
-          s = screen_puts_mbyte((char_u *)s, l, attr) - 1;
+          s = (char_u *)screen_puts_mbyte((char *)s, l, attr) - 1;
         } else {
           msg_screen_putchar(*s, attr);
         }
@@ -2342,7 +2343,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
   // Output any postponed text.
   if (t_col > 0) {
-    t_puts(&t_col, t_s, s, attr);
+    t_puts(&t_col, (char *)t_s, (char *)s, attr);
   }
   if (p_more && !recurse) {
     store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, false);
@@ -2698,7 +2699,7 @@ static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp)
 }
 
 /// Output any postponed text for msg_puts_attr_len().
-static void t_puts(int *t_col, const char_u *t_s, const char_u *s, int attr)
+static void t_puts(int *t_col, const char *t_s, const char *s, int attr)
 {
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), attr);
   // Output postponed text.
@@ -2708,7 +2709,7 @@ static void t_puts(int *t_col, const char_u *t_s, const char_u *s, int attr)
   *t_col = 0;
   // If the string starts with a composing character don't increment the
   // column position for it.
-  if (utf_iscomposing(utf_ptr2char((char *)t_s))) {
+  if (utf_iscomposing(utf_ptr2char(t_s))) {
     msg_col--;
   }
   if (msg_col >= Columns) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 6430070f1b..47ad000385 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -631,16 +631,16 @@ static void normal_redraw_mode_message(NormalState *s)
   if (must_redraw && keep_msg != NULL && !emsg_on_display) {
     char_u *kmsg;
 
-    kmsg = keep_msg;
+    kmsg = (char_u *)keep_msg;
     keep_msg = NULL;
     // Showmode() will clear keep_msg, but we want to use it anyway.
     // First update w_topline.
     setcursor();
     update_screen(0);
     // now reset it, otherwise it's put in the history again
-    keep_msg = kmsg;
+    keep_msg = (char *)kmsg;
 
-    kmsg = vim_strsave(keep_msg);
+    kmsg = vim_strsave((char_u *)keep_msg);
     msg_attr((const char *)kmsg, keep_msg_attr);
     xfree(kmsg);
   }
@@ -1302,7 +1302,7 @@ static void normal_redraw(NormalState *s)
   // Display message after redraw. If an external message is still visible,
   // it contains the kept message already.
   if (keep_msg != NULL && !msg_ext_is_visible()) {
-    char_u *const p = vim_strsave(keep_msg);
+    char *const p = xstrdup(keep_msg);
 
     // msg_start() will set keep_msg to NULL, make a copy
     // first.  Don't reset keep_msg, msg_attr_keep() uses it to
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 7b6f9e6370..4f2b84d20f 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -2500,7 +2500,7 @@ int op_change(oparg_T *oap)
     }
     firstline = ml_get(oap->start.lnum);
     pre_textlen = (long)STRLEN(firstline);
-    pre_indent = (long)getwhitecols(firstline);
+    pre_indent = (long)getwhitecols((char *)firstline);
     bd.textcol = curwin->w_cursor.col;
   }
 
@@ -2521,7 +2521,7 @@ int op_change(oparg_T *oap)
     // the indent, exclude that indent change from the inserted text.
     firstline = ml_get(oap->start.lnum);
     if (bd.textcol > (colnr_T)pre_indent) {
-      long new_indent = (long)getwhitecols(firstline);
+      long new_indent = (long)getwhitecols((char *)firstline);
 
       pre_textlen += new_indent - pre_indent;
       bd.textcol += (colnr_T)(new_indent - pre_indent);
@@ -3860,7 +3860,7 @@ void ex_display(exarg_T *eap)
           for (p = (char_u *)yb->y_array[j];
                *p != NUL && (n -= ptr2cells((char *)p)) >= 0; p++) {  // -V1019
             clen = utfc_ptr2len((char *)p);
-            msg_outtrans_len(p, clen);
+            msg_outtrans_len((char *)p, clen);
             p += clen - 1;
           }
         }
@@ -3938,10 +3938,10 @@ static void dis_msg(const char_u *p, bool skip_esc)
          && !(*p == ESC && skip_esc && *(p + 1) == NUL)
          && (n -= ptr2cells((char *)p)) >= 0) {
     if ((l = utfc_ptr2len((char *)p)) > 1) {
-      msg_outtrans_len(p, l);
+      msg_outtrans_len((char *)p, l);
       p += l;
     } else {
-      msg_outtrans_len(p++, 1);
+      msg_outtrans_len((char *)p++, 1);
     }
   }
   os_breakcheck();
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index 274e13e3c6..c940c86675 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -765,12 +765,12 @@ static char *vim_version_dir(const char *vimdir)
     return NULL;
   }
   char *p = concat_fnames(vimdir, VIM_VERSION_NODOT, true);
-  if (os_isdir((char_u *)p)) {
+  if (os_isdir(p)) {
     return p;
   }
   xfree(p);
   p = concat_fnames(vimdir, RUNTIME_DIRNAME, true);
-  if (os_isdir((char_u *)p)) {
+  if (os_isdir(p)) {
     return p;
   }
   xfree(p);
@@ -976,7 +976,7 @@ char *vim_getenv(const char *name)
       assert(vim_path_end >= vim_path);
       vim_path = xstrndup(vim_path, (size_t)(vim_path_end - vim_path));
 
-      if (!os_isdir((char_u *)vim_path)) {
+      if (!os_isdir(vim_path)) {
         xfree(vim_path);
         vim_path = NULL;
       }
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index dc96c39d25..c0d5616666 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -129,10 +129,10 @@ bool os_isrealdir(const char *name)
 /// Check if the given path exists and is a directory.
 ///
 /// @return `true` if `name` is a directory.
-bool os_isdir(const char_u *name)
+bool os_isdir(const char *name)
   FUNC_ATTR_NONNULL_ALL
 {
-  int32_t mode = os_getperm((const char *)name);
+  int32_t mode = os_getperm(name);
   if (mode < 0) {
     return false;
   }
@@ -865,7 +865,7 @@ int os_file_is_writable(const char *name)
   int r;
   RUN_UV_FS_FUNC(r, uv_fs_access, name, W_OK, NULL);
   if (r == 0) {
-    return os_isdir((char_u *)name) ? 2 : 1;
+    return os_isdir(name) ? 2 : 1;
   }
   return 0;
 }
@@ -915,7 +915,7 @@ int os_mkdir_recurse(const char *const dir, int32_t mode, char **const failed_di
   char *e = curdir + dirlen;
   const char *const real_end = e;
   const char past_head_save = *past_head;
-  while (!os_isdir((char_u *)curdir)) {
+  while (!os_isdir(curdir)) {
     e = path_tail_with_sep(curdir);
     if (e <= past_head) {
       *past_head = NUL;
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index c8267ede14..461a79c37b 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -55,7 +55,7 @@ static void save_patterns(int num_pat, char **pat, int *num_file, char ***file)
     char_u *s = vim_strsave((char_u *)pat[i]);
     // Be compatible with expand_filename(): halve the number of
     // backslashes.
-    backslash_halve(s);
+    backslash_halve((char *)s);
     (*file)[i] = (char *)s;
   }
   *num_file = num_pat;
@@ -508,7 +508,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
     }
 
     // check if this entry should be included
-    dir = (os_isdir((char_u *)(*file)[i]));
+    dir = (os_isdir((*file)[i]));
     if ((dir && !(flags & EW_DIR)) || (!dir && !(flags & EW_FILE))) {
       continue;
     }
diff --git a/src/nvim/path.c b/src/nvim/path.c
index e40729b114..a5cec6772f 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -326,7 +326,7 @@ bool dir_of_file_exists(char_u *fname)
   }
   char c = *p;
   *p = NUL;
-  bool retval = os_isdir(fname);
+  bool retval = os_isdir((char *)fname);
   *p = c;
   return retval;
 }
@@ -752,7 +752,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
           // no more wildcards, check if there is a match
           // remove backslashes for the remaining components only
           if (*path_end != NUL) {
-            backslash_halve(buf + len + 1);
+            backslash_halve((char *)buf + len + 1);
           }
           // add existing file or symbolic link
           if ((flags & EW_ALLLINKS) ? os_fileinfo_link((char *)buf, &file_info)
@@ -1135,7 +1135,7 @@ static int expand_in_path(garray_T *const gap, char_u *const pattern, const int
   if (flags & EW_ADDSLASH) {
     glob_flags |= WILD_ADD_SLASH;
   }
-  globpath((char *)paths, pattern, gap, glob_flags);
+  globpath((char *)paths, (char *)pattern, gap, glob_flags);
   xfree(paths);
 
   return gap->ga_len;
@@ -1312,7 +1312,7 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
     }
 
     if (add_pat == -1 || (add_pat == 0 && (flags & EW_NOTFOUND))) {
-      char_u *t = backslash_halve_save(p);
+      char_u *t = (char_u *)backslash_halve_save((char *)p);
 
       /* When EW_NOTFOUND is used, always add files and dirs.  Makes
        * "vim c:/" work. */
@@ -1472,7 +1472,7 @@ void addfile(garray_T *gap, char_u *f, int flags)
   }
 #endif
 
-  isdir = os_isdir(f);
+  isdir = os_isdir((char *)f);
   if ((isdir && !(flags & EW_DIR)) || (!isdir && !(flags & EW_FILE))) {
     return;
   }
@@ -1845,7 +1845,7 @@ int vim_FullName(const char *fname, char *buf, size_t len, bool force)
     return OK;
   }
 
-  int rv = path_to_absolute((char_u *)fname, (char_u *)buf, len, force);
+  int rv = path_to_absolute(fname, buf, len, force);
   if (rv == FAIL) {
     xstrlcpy(buf, fname, len);  // something failed; use the filename
   }
@@ -1904,7 +1904,7 @@ void path_fix_case(char *name)
   }
 
   // Open the directory where the file is located.
-  char *slash = (char *)STRRCHR(name, '/');
+  char *slash = strrchr(name, '/');
   char *tail;
   Directory dir;
   bool ok;
@@ -2139,7 +2139,7 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
                          true);
     emsg_off--;
     if (eval_pat != NULL) {
-      exp_pat = (char *)concat_str(eval_pat, (char_u *)exp_pat + usedlen);
+      exp_pat = concat_str((char *)eval_pat, exp_pat + usedlen);
     }
   }
 
@@ -2353,20 +2353,20 @@ int append_path(char *path, const char *to_append, size_t max_len)
 /// @param  force  also expand when "fname" is already absolute.
 ///
 /// @return FAIL for failure, OK for success.
-static int path_to_absolute(const char_u *fname, char_u *buf, size_t len, int force)
+static int path_to_absolute(const char *fname, char *buf, size_t len, int force)
 {
-  char_u *p;
+  char *p;
   *buf = NUL;
 
   char *relative_directory = xmalloc(len);
   char *end_of_path = (char *)fname;
 
   // expand it if forced or not an absolute path
-  if (force || !path_is_absolute(fname)) {
-    p = STRRCHR(fname, '/');
+  if (force || !path_is_absolute((char_u *)fname)) {
+    p = strrchr(fname, '/');
 #ifdef WIN32
     if (p == NULL) {
-      p = STRRCHR(fname, '\\');
+      p = strrchr(fname, '\\');
     }
 #endif
     if (p != NULL) {
@@ -2380,19 +2380,19 @@ static int path_to_absolute(const char_u *fname, char_u *buf, size_t len, int fo
         memcpy(relative_directory, fname, (size_t)(p - fname));
         relative_directory[p - fname] = NUL;
       }
-      end_of_path = (char *)(p + 1);
+      end_of_path = p + 1;
     } else {
       relative_directory[0] = NUL;
       end_of_path = (char *)fname;
     }
 
-    if (FAIL == path_full_dir_name(relative_directory, (char *)buf, len)) {
+    if (FAIL == path_full_dir_name(relative_directory, buf, len)) {
       xfree(relative_directory);
       return FAIL;
     }
   }
   xfree(relative_directory);
-  return append_path((char *)buf, end_of_path, len);
+  return append_path(buf, end_of_path, len);
 }
 
 /// Check if file `fname` is a full (absolute) path.
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index 11b6951edd..cc730ba307 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -262,7 +262,7 @@ int linetabsize_col(int startcol, char *s)
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
   clear_chartabsize_arg(&cts);
-  return (int)cts.cts_vcol;
+  return cts.cts_vcol;
 }
 
 /// Like linetabsize(), but for a given window instead of the current one.
@@ -530,7 +530,7 @@ static int win_nolbr_chartabsize(chartabsize_T *cts, int *headp)
                            wp->w_buffer->b_p_ts,
                            wp->w_buffer->b_p_vts_array);
   }
-  n = ptr2cells((char *)s);
+  n = ptr2cells(s);
 
   // Add one cell for a double-width character in the last column of the
   // window, displayed with a ">".
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index b144348188..0d9080ceb7 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -524,7 +524,7 @@ void pum_redraw(void)
             }
 
             if (pum_rl) {
-              char *rt = (char *)reverse_text(st);
+              char *rt = reverse_text((char *)st);
               char *rt_start = rt;
               int size = vim_strsize(rt);
 
diff --git a/src/nvim/profile.c b/src/nvim/profile.c
index d4f3756f4d..cded231c85 100644
--- a/src/nvim/profile.c
+++ b/src/nvim/profile.c
@@ -279,7 +279,7 @@ void ex_profile(exarg_T *eap)
   char *e;
   int len;
 
-  e = (char *)skiptowhite((char_u *)eap->arg);
+  e = skiptowhite(eap->arg);
   len = (int)(e - eap->arg);
   e = skipwhite(e);
 
@@ -354,7 +354,7 @@ void set_context_in_profile_cmd(expand_T *xp, const char *arg)
   pexpand_what = PEXP_SUBCMD;
   xp->xp_pattern = (char *)arg;
 
-  char_u *const end_subcmd = skiptowhite((const char_u *)arg);
+  char_u *const end_subcmd = (char_u *)skiptowhite(arg);
   if (*end_subcmd == NUL) {
     return;
   }
@@ -612,7 +612,7 @@ static void func_dump_profile(FILE *fd)
             .script_ctx = fp->uf_script_ctx,
             .channel_id = 0,
           };
-          char *p = (char *)get_scriptname(last_set, &should_free);
+          char *p = get_scriptname(last_set, &should_free);
           fprintf(fd, "    Defined: %s:%" PRIdLINENR "\n",
                   p, fp->uf_script_ctx.sc_lnum);
           if (should_free) {
@@ -721,7 +721,7 @@ static void script_dump_profile(FILE *fd)
       fprintf(fd, "\n");
       fprintf(fd, "count  total (s)   self (s)\n");
 
-      sfd = os_fopen((char *)si->sn_name, "r");
+      sfd = os_fopen(si->sn_name, "r");
       if (sfd == NULL) {
         fprintf(fd, "Cannot open file!\n");
       } else {
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 20e6893ea5..f9c4892b91 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -799,7 +799,7 @@ retry:
 
   // Convert a line if it contains a non-ASCII character
   if (state->vc.vc_type != CONV_NONE && has_non_ascii((char_u *)state->linebuf)) {
-    char *line = (char *)string_convert(&state->vc, (char_u *)state->linebuf, &state->linelen);
+    char *line = string_convert(&state->vc, state->linebuf, &state->linelen);
     if (line != NULL) {
       if (state->linelen < IOSIZE) {
         STRLCPY(state->linebuf, line, state->linelen + 1);
@@ -2129,7 +2129,7 @@ static char *qf_push_dir(char *dirbuf, struct dir_stack_T **stackptr, bool is_fi
     while (ds_new) {
       xfree((*stackptr)->dirname);
       (*stackptr)->dirname = concat_fnames(ds_new->dirname, dirbuf, true);
-      if (os_isdir((char_u *)(*stackptr)->dirname)) {
+      if (os_isdir((*stackptr)->dirname)) {
         break;
       }
 
@@ -3054,7 +3054,7 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   }
 
   msg_putchar('\n');
-  msg_outtrans_attr(IObuff, cursel ? HL_ATTR(HLF_QFL) : qfFileAttr);
+  msg_outtrans_attr((char *)IObuff, cursel ? HL_ATTR(HLF_QFL) : qfFileAttr);
 
   if (qfp->qf_lnum != 0) {
     msg_puts_attr(":", qfSepAttr);
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index 41056a2773..e85167f8fd 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -123,7 +123,7 @@ char *estack_sfile(estack_arg_T which)
                                        ? &entry->es_info.ufunc->uf_script_ctx
                                        : &entry->es_info.aucmd->script_ctx);
         return def_ctx->sc_sid > 0
-                ? xstrdup((char *)(SCRIPT_ITEM(def_ctx->sc_sid).sn_name))
+                ? xstrdup((SCRIPT_ITEM(def_ctx->sc_sid).sn_name))
                 : NULL;
       } else if (entry->es_type == ETYPE_SCRIPT) {
         return xstrdup(entry->es_name);
@@ -192,7 +192,7 @@ void runtime_init(void)
 void ex_runtime(exarg_T *eap)
 {
   char *arg = eap->arg;
-  char *p = (char *)skiptowhite((char_u *)arg);
+  char *p = skiptowhite(arg);
   ptrdiff_t len = p - arg;
   int flags = eap->forceit ? DIP_ALL : 0;
 
@@ -226,9 +226,9 @@ static void source_callback(char *fname, void *cookie)
 /// When "flags" has DIP_ERR: give an error message if there is no match.
 ///
 /// return FAIL when no file could be sourced, OK otherwise.
-int do_in_path(char_u *path, char *name, int flags, DoInRuntimepathCB callback, void *cookie)
+int do_in_path(char *path, char *name, int flags, DoInRuntimepathCB callback, void *cookie)
 {
-  char_u *tail;
+  char *tail;
   int num_files;
   char **files;
   int i;
@@ -236,17 +236,17 @@ int do_in_path(char_u *path, char *name, int flags, DoInRuntimepathCB callback,
 
   // Make a copy of 'runtimepath'.  Invoking the callback may change the
   // value.
-  char_u *rtp_copy = vim_strsave(path);
+  char *rtp_copy = xstrdup(path);
   char *buf = xmallocz(MAXPATHL);
   {
     if (p_verbose > 10 && name != NULL) {
       verbose_enter();
-      smsg(_("Searching for \"%s\" in \"%s\""), name, (char *)path);
+      smsg(_("Searching for \"%s\" in \"%s\""), name, path);
       verbose_leave();
     }
 
     // Loop over all entries in 'runtimepath'.
-    char *rtp = (char *)rtp_copy;
+    char *rtp = rtp_copy;
     while (*rtp != NUL && ((flags & DIP_ALL) || !did_one)) {
       // Copy the path from 'runtimepath' to buf[].
       copy_option_part(&rtp, buf, MAXPATHL, ",");
@@ -267,14 +267,14 @@ int do_in_path(char_u *path, char *name, int flags, DoInRuntimepathCB callback,
         did_one = true;
       } else if (buflen + STRLEN(name) + 2 < MAXPATHL) {
         add_pathsep(buf);
-        tail = (char_u *)buf + STRLEN(buf);
+        tail = buf + STRLEN(buf);
 
         // Loop over all patterns in "name"
         char *np = name;
         while (*np != NUL && ((flags & DIP_ALL) || !did_one)) {
           // Append the pattern from "name" to buf[].
-          assert(MAXPATHL >= (tail - (char_u *)buf));
-          copy_option_part(&np, (char *)tail, (size_t)(MAXPATHL - (tail - (char_u *)buf)), "\t ");
+          assert(MAXPATHL >= (tail - buf));
+          copy_option_part(&np, tail, (size_t)(MAXPATHL - (tail - buf)), "\t ");
 
           if (p_verbose > 10) {
             verbose_enter();
@@ -303,7 +303,7 @@ int do_in_path(char_u *path, char *name, int flags, DoInRuntimepathCB callback,
   xfree(buf);
   xfree(rtp_copy);
   if (!did_one && name != NULL) {
-    char *basepath = path == (char_u *)p_rtp ? "runtimepath" : "packpath";
+    char *basepath = path == p_rtp ? "runtimepath" : "packpath";
 
     if (flags & DIP_ERR) {
       semsg(_(e_dirnotf), basepath, name);
@@ -363,19 +363,19 @@ void runtime_search_path_unref(RuntimeSearchPath path, int *ref)
 /// When "flags" has DIP_ERR: give an error message if there is no match.
 ///
 /// return FAIL when no file could be sourced, OK otherwise.
-int do_in_cached_path(char_u *name, int flags, DoInRuntimepathCB callback, void *cookie)
+int do_in_cached_path(char *name, int flags, DoInRuntimepathCB callback, void *cookie)
 {
-  char_u *tail;
+  char *tail;
   int num_files;
   char **files;
   int i;
   bool did_one = false;
 
-  char_u buf[MAXPATHL];
+  char buf[MAXPATHL];
 
   if (p_verbose > 10 && name != NULL) {
     verbose_enter();
-    smsg(_("Searching for \"%s\" in runtime path"), (char *)name);
+    smsg(_("Searching for \"%s\" in runtime path"), name);
     verbose_leave();
   }
 
@@ -399,15 +399,15 @@ int do_in_cached_path(char_u *name, int flags, DoInRuntimepathCB callback, void
       (*callback)(item.path, cookie);
     } else if (buflen + STRLEN(name) + 2 < MAXPATHL) {
       STRCPY(buf, item.path);
-      add_pathsep((char *)buf);
+      add_pathsep(buf);
       tail = buf + STRLEN(buf);
 
       // Loop over all patterns in "name"
-      char *np = (char *)name;
+      char *np = name;
       while (*np != NUL && ((flags & DIP_ALL) || !did_one)) {
         // Append the pattern from "name" to buf[].
         assert(MAXPATHL >= (tail - buf));
-        copy_option_part(&np, (char *)tail, (size_t)(MAXPATHL - (tail - buf)), "\t ");
+        copy_option_part(&np, tail, (size_t)(MAXPATHL - (tail - buf)), "\t ");
 
         if (p_verbose > 10) {
           verbose_enter();
@@ -419,7 +419,7 @@ int do_in_cached_path(char_u *name, int flags, DoInRuntimepathCB callback, void
                        | (flags & DIP_DIRFILE) ? (EW_DIR|EW_FILE) : 0;
 
         // Expand wildcards, invoke the callback for each match.
-        char *(pat[]) = { (char *)buf };
+        char *(pat[]) = { buf };
         if (gen_expand_wildcards(1, pat, &num_files, &files, ew_flags) == OK) {
           for (i = 0; i < num_files; i++) {
             (*callback)(files[i], cookie);
@@ -499,7 +499,7 @@ ArrayOf(String) runtime_get_named_common(bool lua, Array pat, bool all,
     if (lua) {
       if (item->has_lua == kNone) {
         size_t size = (size_t)snprintf(buf, buf_len, "%s/lua/", item->path);
-        item->has_lua = (size < buf_len && os_isdir((char_u *)buf));
+        item->has_lua = (size < buf_len && os_isdir(buf));
       }
       if (item->has_lua == kFalse) {
         continue;
@@ -534,13 +534,13 @@ done:
 /// If "name" is NULL calls callback for each entry in "path". Cookie is
 /// passed by reference in this case, setting it to NULL indicates that callback
 /// has done its job.
-int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB callback,
-                      void *cookie)
+int do_in_path_and_pp(char *path, char *name, int flags, DoInRuntimepathCB callback, void *cookie)
 {
   int done = FAIL;
 
   if ((flags & DIP_NORTP) == 0) {
-    done |= do_in_path(path, (char *)((name && !*name) ? NULL : name), flags, callback, cookie);
+    done |= do_in_path(path, (name && !*name) ? NULL : name, flags, callback,
+                       cookie);
   }
 
   if ((done == FAIL || (flags & DIP_ALL)) && (flags & DIP_START)) {
@@ -550,7 +550,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
     char *suffix = (flags & DIP_AFTER) ? "after/" : "";
 
     vim_snprintf(s, len, start_dir, suffix, name);
-    done |= do_in_path((char_u *)p_pp, s, flags & ~DIP_AFTER, callback, cookie);
+    done |= do_in_path(p_pp, s, flags & ~DIP_AFTER, callback, cookie);
 
     xfree(s);
 
@@ -560,7 +560,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
       s = xmallocz(len);
 
       vim_snprintf(s, len, start_dir, suffix, name);
-      done |= do_in_path((char_u *)p_pp, s, flags & ~DIP_AFTER, callback, cookie);
+      done |= do_in_path(p_pp, s, flags & ~DIP_AFTER, callback, cookie);
 
       xfree(s);
     }
@@ -572,7 +572,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
     char *s = xmallocz(len);
 
     vim_snprintf(s, len, opt_dir, name);
-    done |= do_in_path((char_u *)p_pp, s, flags, callback, cookie);
+    done |= do_in_path(p_pp, s, flags, callback, cookie);
 
     xfree(s);
 
@@ -582,7 +582,7 @@ int do_in_path_and_pp(char_u *path, char_u *name, int flags, DoInRuntimepathCB c
       s = xmallocz(len);
 
       vim_snprintf(s, len, opt_dir, name);
-      done |= do_in_path((char_u *)p_pp, s, flags, callback, cookie);
+      done |= do_in_path(p_pp, s, flags, callback, cookie);
 
       xfree(s);
     }
@@ -625,7 +625,7 @@ static void expand_rtp_entry(RuntimeSearchPath *search_path, Map(String, handle_
 }
 
 static void expand_pack_entry(RuntimeSearchPath *search_path, Map(String, handle_T) *rtp_used,
-                              CharVec *after_path, char_u *pack_entry, size_t pack_entry_len)
+                              CharVec *after_path, char *pack_entry, size_t pack_entry_len)
 {
   static char buf[MAXPATHL];
   char *(start_pat[]) = { "/pack/*/start/*", "/start/*" };  // NOLINT
@@ -664,10 +664,10 @@ RuntimeSearchPath runtime_search_path_build(void)
   RuntimeSearchPath search_path = KV_INITIAL_VALUE;
   CharVec after_path = KV_INITIAL_VALUE;
 
-  static char_u buf[MAXPATHL];
+  static char buf[MAXPATHL];
   for (char *entry = p_pp; *entry != NUL;) {
     char *cur_entry = entry;
-    copy_option_part(&entry, (char *)buf, MAXPATHL, ",");
+    copy_option_part(&entry, buf, MAXPATHL, ",");
 
     String the_entry = { .data = cur_entry, .size = STRLEN(buf) };
 
@@ -678,18 +678,18 @@ RuntimeSearchPath runtime_search_path_build(void)
   char *rtp_entry;
   for (rtp_entry = p_rtp; *rtp_entry != NUL;) {
     char *cur_entry = rtp_entry;
-    copy_option_part(&rtp_entry, (char *)buf, MAXPATHL, ",");
+    copy_option_part(&rtp_entry, buf, MAXPATHL, ",");
     size_t buflen = STRLEN(buf);
 
-    if (path_is_after((char *)buf, buflen)) {
+    if (path_is_after(buf, buflen)) {
       rtp_entry = cur_entry;
       break;
     }
 
     // fact: &rtp entries can contain wild chars
-    expand_rtp_entry(&search_path, &rtp_used, (char *)buf, false);
+    expand_rtp_entry(&search_path, &rtp_used, buf, false);
 
-    handle_T *h = map_ref(String, handle_T)(&pack_used, cstr_as_string((char *)buf), false);
+    handle_T *h = map_ref(String, handle_T)(&pack_used, cstr_as_string(buf), false);
     if (h) {
       (*h)++;
       expand_pack_entry(&search_path, &rtp_used, &after_path, buf, buflen);
@@ -700,7 +700,7 @@ RuntimeSearchPath runtime_search_path_build(void)
     String item = kv_A(pack_entries, i);
     handle_T h = map_get(String, handle_T)(&pack_used, item);
     if (h == 0) {
-      expand_pack_entry(&search_path, &rtp_used, &after_path, (char_u *)item.data, item.size);
+      expand_pack_entry(&search_path, &rtp_used, &after_path, item.data, item.size);
     }
   }
 
@@ -712,8 +712,8 @@ RuntimeSearchPath runtime_search_path_build(void)
 
   // "after" dirs in rtp
   for (; *rtp_entry != NUL;) {
-    copy_option_part(&rtp_entry, (char *)buf, MAXPATHL, ",");
-    expand_rtp_entry(&search_path, &rtp_used, (char *)buf, path_is_after((char *)buf, STRLEN(buf)));
+    copy_option_part(&rtp_entry, buf, MAXPATHL, ",");
+    expand_rtp_entry(&search_path, &rtp_used, buf, path_is_after(buf, STRLEN(buf)));
   }
 
   // strings are not owned
@@ -767,13 +767,13 @@ int do_in_runtimepath(char *name, int flags, DoInRuntimepathCB callback, void *c
 {
   int success = FAIL;
   if (!(flags & DIP_NORTP)) {
-    success |= do_in_cached_path((name && !*name) ? NULL : (char_u *)name, flags, callback, cookie);
+    success |= do_in_cached_path((name && !*name) ? NULL : name, flags, callback, cookie);
     flags = (flags & ~DIP_START) | DIP_NORTP;
   }
   // TODO(bfredl): we could integrate disabled OPT dirs into the cached path
   // which would effectivize ":packadd myoptpack" as well
   if ((flags & (DIP_START|DIP_OPT)) && (success == FAIL || (flags & DIP_ALL))) {
-    success |= do_in_path_and_pp((char_u *)p_rtp, (char_u *)name, flags, callback, cookie);
+    success |= do_in_path_and_pp(p_rtp, name, flags, callback, cookie);
   }
   return success;
 }
@@ -789,7 +789,7 @@ int source_runtime(char *name, int flags)
 }
 
 /// Just like source_runtime(), but use "path" instead of 'runtimepath'.
-int source_in_path(char_u *path, char_u *name, int flags)
+int source_in_path(char *path, char *name, int flags)
 {
   return do_in_path_and_pp(path, name, flags, source_callback, NULL);
 }
@@ -813,14 +813,14 @@ static void source_all_matches(char *pat)
 ///
 /// @param fname the package path
 /// @param is_pack whether the added dir is a "pack/*/start/*/" style package
-static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
+static int add_pack_dir_to_rtp(char *fname, bool is_pack)
 {
   char *p;
   char *buf = NULL;
   char *afterdir = NULL;
   int retval = FAIL;
 
-  char *p1 = get_past_head((char *)fname);
+  char *p1 = get_past_head(fname);
   char *p2 = p1;
   char *p3 = p1;
   char *p4 = p1;
@@ -841,7 +841,7 @@ static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
   p4++;  // append pathsep in order to expand symlink
   char c = *p4;
   *p4 = NUL;
-  char *const ffname = fix_fname((char *)fname);
+  char *const ffname = fix_fname(fname);
   *p4 = c;
 
   if (ffname == NULL) {
@@ -895,9 +895,9 @@ static int add_pack_dir_to_rtp(char_u *fname, bool is_pack)
   }
 
   // check if rtp/pack/name/start/name/after exists
-  afterdir = concat_fnames((char *)fname, "after", true);
+  afterdir = concat_fnames(fname, "after", true);
   size_t afterlen = 0;
-  if (is_pack ? pack_has_entries((char_u *)afterdir) : os_isdir((char_u *)afterdir)) {
+  if (is_pack ? pack_has_entries(afterdir) : os_isdir(afterdir)) {
     afterlen = strlen(afterdir) + 1;  // add one for comma
   }
 
@@ -964,29 +964,29 @@ theend:
 /// Load scripts in "plugin" directory of the package.
 /// For opt packages, also load scripts in "ftdetect" (start packages already
 /// load these from filetype.vim)
-static int load_pack_plugin(bool opt, char_u *fname)
+static int load_pack_plugin(bool opt, char *fname)
 {
   static const char *ftpat = "%s/ftdetect/*.vim";  // NOLINT
 
-  char *const ffname = fix_fname((char *)fname);
+  char *const ffname = fix_fname(fname);
   size_t len = strlen(ffname) + STRLEN(ftpat);
-  char_u *pat = xmallocz(len);
+  char *pat = xmallocz(len);
 
-  vim_snprintf((char *)pat, len, "%s/plugin/**/*.vim", ffname);  // NOLINT
-  source_all_matches((char *)pat);
-  vim_snprintf((char *)pat, len, "%s/plugin/**/*.lua", ffname);  // NOLINT
-  source_all_matches((char *)pat);
+  vim_snprintf(pat, len, "%s/plugin/**/*.vim", ffname);  // NOLINT
+  source_all_matches(pat);
+  vim_snprintf(pat, len, "%s/plugin/**/*.lua", ffname);  // NOLINT
+  source_all_matches(pat);
 
-  char_u *cmd = vim_strsave((char_u *)"g:did_load_filetypes");
+  char *cmd = xstrdup("g:did_load_filetypes");
 
   // If runtime/filetype.vim wasn't loaded yet, the scripts will be
   // found when it loads.
-  if (opt && eval_to_number((char *)cmd) > 0) {
+  if (opt && eval_to_number(cmd) > 0) {
     do_cmdline_cmd("augroup filetypedetect");
-    vim_snprintf((char *)pat, len, ftpat, ffname);
-    source_all_matches((char *)pat);
+    vim_snprintf(pat, len, ftpat, ffname);
+    source_all_matches(pat);
     vim_snprintf((char *)pat, len, "%s/ftdetect/*.lua", ffname);  // NOLINT
-    source_all_matches((char *)pat);
+    source_all_matches(pat);
     do_cmdline_cmd("augroup END");
   }
   xfree(cmd);
@@ -1001,7 +1001,7 @@ static int APP_ADD_DIR;
 static int APP_LOAD;
 static int APP_BOTH;
 
-static void add_pack_plugin(bool opt, char_u *fname, void *cookie)
+static void add_pack_plugin(bool opt, char *fname, void *cookie)
 {
   if (cookie != &APP_LOAD) {
     char *buf = xmalloc(MAXPATHL);
@@ -1010,7 +1010,7 @@ static void add_pack_plugin(bool opt, char_u *fname, void *cookie)
     const char *p = (const char *)p_rtp;
     while (*p != NUL) {
       copy_option_part((char **)&p, buf, MAXPATHL, ",");
-      if (path_fnamecmp(buf, (char *)fname) == 0) {
+      if (path_fnamecmp(buf, fname) == 0) {
         found = true;
         break;
       }
@@ -1031,25 +1031,25 @@ static void add_pack_plugin(bool opt, char_u *fname, void *cookie)
 
 static void add_start_pack_plugin(char *fname, void *cookie)
 {
-  add_pack_plugin(false, (char_u *)fname, cookie);
+  add_pack_plugin(false, fname, cookie);
 }
 
 static void add_opt_pack_plugin(char *fname, void *cookie)
 {
-  add_pack_plugin(true, (char_u *)fname, cookie);
+  add_pack_plugin(true, fname, cookie);
 }
 
 /// Add all packages in the "start" directory to 'runtimepath'.
 void add_pack_start_dirs(void)
 {
-  do_in_path((char_u *)p_pp, NULL, DIP_ALL + DIP_DIR, add_pack_start_dir, NULL);
+  do_in_path(p_pp, NULL, DIP_ALL + DIP_DIR, add_pack_start_dir, NULL);
 }
 
-static bool pack_has_entries(char_u *buf)
+static bool pack_has_entries(char *buf)
 {
   int num_files;
   char **files;
-  char *(pat[]) = { (char *)buf };
+  char *(pat[]) = { buf };
   if (gen_expand_wildcards(1, pat, &num_files, &files, EW_DIR) == OK) {
     FreeWild(num_files, files);
   }
@@ -1058,7 +1058,7 @@ static bool pack_has_entries(char_u *buf)
 
 static void add_pack_start_dir(char *fname, void *cookie)
 {
-  static char_u buf[MAXPATHL];
+  static char buf[MAXPATHL];
   char *(start_pat[]) = { "/start/*", "/pack/*/start/*" };  // NOLINT
   for (int i = 0; i < 2; i++) {
     if (STRLEN(fname) + STRLEN(start_pat[i]) + 1 > MAXPATHL) {
@@ -1076,9 +1076,9 @@ static void add_pack_start_dir(char *fname, void *cookie)
 void load_start_packages(void)
 {
   did_source_packages = true;
-  do_in_path((char_u *)p_pp, "pack/*/start/*", DIP_ALL + DIP_DIR,  // NOLINT
+  do_in_path(p_pp, "pack/*/start/*", DIP_ALL + DIP_DIR,  // NOLINT
              add_start_pack_plugin, &APP_LOAD);
-  do_in_path((char_u *)p_pp, "start/*", DIP_ALL + DIP_DIR,  // NOLINT
+  do_in_path(p_pp, "start/*", DIP_ALL + DIP_DIR,  // NOLINT
              add_start_pack_plugin, &APP_LOAD);
 }
 
@@ -1099,12 +1099,12 @@ void ex_packloadall(exarg_T *eap)
 void load_plugins(void)
 {
   if (p_lpl) {
-    char_u *rtp_copy = (char_u *)p_rtp;
-    char_u *const plugin_pattern_vim = (char_u *)"plugin/**/*.vim";  // NOLINT
-    char_u *const plugin_pattern_lua = (char_u *)"plugin/**/*.lua";  // NOLINT
+    char *rtp_copy = p_rtp;
+    char *const plugin_pattern_vim = "plugin/**/*.vim";  // NOLINT
+    char *const plugin_pattern_lua = "plugin/**/*.lua";  // NOLINT
 
     if (!did_source_packages) {
-      rtp_copy = vim_strsave((char_u *)p_rtp);
+      rtp_copy = xstrdup(p_rtp);
       add_pack_start_dirs();
     }
 
@@ -1121,8 +1121,8 @@ void load_plugins(void)
     }
     TIME_MSG("loading packages");
 
-    source_runtime((char *)plugin_pattern_vim, DIP_ALL | DIP_AFTER);
-    source_runtime((char *)plugin_pattern_lua, DIP_ALL | DIP_AFTER);
+    source_runtime(plugin_pattern_vim, DIP_ALL | DIP_AFTER);
+    source_runtime(plugin_pattern_lua, DIP_ALL | DIP_AFTER);
     TIME_MSG("loading after plugins");
   }
 }
@@ -1146,7 +1146,7 @@ void ex_packadd(exarg_T *eap)
     // The first round don't give a "not found" error, in the second round
     // only when nothing was found in the first round.
     res =
-      do_in_path((char_u *)p_pp, pat, DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0),
+      do_in_path(p_pp, pat, DIP_ALL + DIP_DIR + (round == 2 && res == FAIL ? DIP_ERR : 0),
                  round == 1 ? add_start_pack_plugin : add_opt_pack_plugin,
                  eap->forceit ? &APP_ADD_DIR : &APP_BOTH);
     xfree(pat);
@@ -1162,7 +1162,7 @@ void ex_packadd(exarg_T *eap)
 ///   'packpath'/pack/ * /opt/ * /{dirnames}/{pat}.vim
 /// When "flags" has DIP_LUA: search also performed for .lua files
 /// "dirnames" is an array with one or more directory names.
-int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirnames[])
+int ExpandRTDir(char *pat, int flags, int *num_file, char ***file, char *dirnames[])
 {
   *num_file = 0;
   *file = NULL;
@@ -1174,11 +1174,11 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
   // TODO(bfredl): this is bullshit, exandpath should not reinvent path logic.
   for (int i = 0; dirnames[i] != NULL; i++) {
     size_t size = STRLEN(dirnames[i]) + pat_len + 7;
-    char_u *s = xmalloc(size);
-    snprintf((char *)s, size, "%s/%s*.vim", dirnames[i], pat);
+    char *s = xmalloc(size);
+    snprintf(s, size, "%s/%s*.vim", dirnames[i], pat);
     globpath(p_rtp, s, &ga, 0);
     if (flags & DIP_LUA) {
-      snprintf((char *)s, size, "%s/%s*.lua", dirnames[i], pat);
+      snprintf(s, size, "%s/%s*.lua", dirnames[i], pat);
       globpath(p_rtp, s, &ga, 0);
     }
     xfree(s);
@@ -1187,11 +1187,11 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
   if (flags & DIP_START) {
     for (int i = 0; dirnames[i] != NULL; i++) {
       size_t size = STRLEN(dirnames[i]) + pat_len + 22;
-      char_u *s = xmalloc(size);
-      snprintf((char *)s, size, "pack/*/start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
+      char *s = xmalloc(size);
+      snprintf(s, size, "pack/*/start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
       globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
-        snprintf((char *)s, size, "pack/*/start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
+        snprintf(s, size, "pack/*/start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
         globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
@@ -1199,11 +1199,11 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
 
     for (int i = 0; dirnames[i] != NULL; i++) {
       size_t size = STRLEN(dirnames[i]) + pat_len + 22;
-      char_u *s = xmalloc(size);
-      snprintf((char *)s, size, "start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
+      char *s = xmalloc(size);
+      snprintf(s, size, "start/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
       globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
-        snprintf((char *)s, size, "start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
+        snprintf(s, size, "start/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
         globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
@@ -1213,11 +1213,11 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
   if (flags & DIP_OPT) {
     for (int i = 0; dirnames[i] != NULL; i++) {
       size_t size = STRLEN(dirnames[i]) + pat_len + 20;
-      char_u *s = xmalloc(size);
-      snprintf((char *)s, size, "pack/*/opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
+      char *s = xmalloc(size);
+      snprintf(s, size, "pack/*/opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
       globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
-        snprintf((char *)s, size, "pack/*/opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
+        snprintf(s, size, "pack/*/opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
         globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
@@ -1225,11 +1225,11 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
 
     for (int i = 0; dirnames[i] != NULL; i++) {
       size_t size = STRLEN(dirnames[i]) + pat_len + 20;
-      char_u *s = xmalloc(size);
-      snprintf((char *)s, size, "opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
+      char *s = xmalloc(size);
+      snprintf(s, size, "opt/*/%s/%s*.vim", dirnames[i], pat);  // NOLINT
       globpath(p_pp, s, &ga, 0);
       if (flags & DIP_LUA) {
-        snprintf((char *)s, size, "opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
+        snprintf(s, size, "opt/*/%s/%s*.lua", dirnames[i], pat);  // NOLINT
         globpath(p_pp, s, &ga, 0);
       }
       xfree(s);
@@ -1237,9 +1237,9 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
   }
 
   for (int i = 0; i < ga.ga_len; i++) {
-    char_u *match = ((char_u **)ga.ga_data)[i];
-    char_u *s = match;
-    char_u *e = s + STRLEN(s);
+    char *match = ((char **)ga.ga_data)[i];
+    char *s = match;
+    char *e = s + STRLEN(s);
     if (e - s > 4 && (STRNICMP(e - 4, ".vim", 4) == 0
                       || ((flags & DIP_LUA)
                           && STRNICMP(e - 4, ".lua", 4) == 0))) {
@@ -1271,7 +1271,7 @@ int ExpandRTDir(char_u *pat, int flags, int *num_file, char ***file, char *dirna
 
 /// Expand loadplugin names:
 /// 'packpath'/pack/ * /opt/{pat}
-int ExpandPackAddDir(char_u *pat, int *num_file, char ***file)
+int ExpandPackAddDir(char *pat, int *num_file, char ***file)
 {
   garray_T ga;
 
@@ -1281,16 +1281,16 @@ int ExpandPackAddDir(char_u *pat, int *num_file, char ***file)
   ga_init(&ga, (int)sizeof(char *), 10);
 
   size_t buflen = pat_len + 26;
-  char_u *s = xmalloc(buflen);
-  snprintf((char *)s, buflen, "pack/*/opt/%s*", pat);  // NOLINT
+  char *s = xmalloc(buflen);
+  snprintf(s, buflen, "pack/*/opt/%s*", pat);  // NOLINT
   globpath(p_pp, s, &ga, 0);
-  snprintf((char *)s, buflen, "opt/%s*", pat);  // NOLINT
+  snprintf(s, buflen, "opt/%s*", pat);  // NOLINT
   globpath(p_pp, s, &ga, 0);
   xfree(s);
 
   for (int i = 0; i < ga.ga_len; i++) {
-    char_u *match = ((char_u **)ga.ga_data)[i];
-    s = (char_u *)path_tail((char *)match);
+    char *match = ((char **)ga.ga_data)[i];
+    s = path_tail(match);
     memmove(match, s, STRLEN(s) + 1);
   }
 
@@ -1479,7 +1479,7 @@ char *get_lib_dir(void)
   // TODO(bfredl): too fragile? Ideally default_lib_dir would be made empty
   // in an appimage build
   if (strlen(default_lib_dir) != 0
-      && os_isdir((const char_u *)default_lib_dir)) {
+      && os_isdir(default_lib_dir)) {
     return xstrdup(default_lib_dir);
   }
 
@@ -1611,7 +1611,7 @@ static void cmd_source(char *fname, exarg_T *eap)
     // - after ":argdo", ":windo" or ":bufdo"
     // - another command follows
     // - inside a loop
-    openscript((char_u *)fname, global_busy || listcmd_busy || eap->nextcmd != NULL
+    openscript(fname, global_busy || listcmd_busy || eap->nextcmd != NULL
                || eap->cstack->cs_idx >= 0);
 
     // ":source" read ex commands
@@ -1691,12 +1691,12 @@ static FILE *fopen_noinh_readbin(char *filename)
 ///
 /// @return true if this line did begin with a continuation (the next line
 ///         should also be considered, if it exists); false otherwise
-static bool concat_continued_line(garray_T *const ga, const int init_growsize,
-                                  const char_u *const p, size_t len)
+static bool concat_continued_line(garray_T *const ga, const int init_growsize, const char *const p,
+                                  size_t len)
   FUNC_ATTR_NONNULL_ALL
 {
-  const char *const line = (char *)skipwhite_len(p, len);
-  len -= (size_t)((char_u *)line - p);
+  const char *const line = skipwhite_len((char *)p, len);
+  len -= (size_t)(line - p);
   // Skip lines starting with '\" ', concat lines starting with '\'
   if (len >= 3 && STRNCMP(line, "\"\\ ", 3) == 0) {
     return true;
@@ -1732,15 +1732,15 @@ static char *get_str_line(int c, void *cookie, int indent, bool do_concat)
     return NULL;
   }
   const char *line = p->buf + p->offset;
-  const char *eol = (char *)skip_to_newline((char_u *)line);
+  const char *eol = skip_to_newline(line);
   garray_T ga;
-  ga_init(&ga, sizeof(char_u), 400);
+  ga_init(&ga, sizeof(char), 400);
   ga_concat_len(&ga, line, (size_t)(eol - line));
   if (do_concat && vim_strchr(p_cpo, CPO_CONCAT) == NULL) {
     while (eol[0] != NUL) {
       line = eol + 1;
-      const char_u *const next_eol = skip_to_newline((char_u *)line);
-      if (!concat_continued_line(&ga, 400, (char_u *)line, (size_t)(next_eol - (char_u *)line))) {
+      const char *const next_eol = skip_to_newline(line);
+      if (!concat_continued_line(&ga, 400, line, (size_t)(next_eol - line))) {
         break;
       }
       eol = (char *)next_eol;
@@ -1770,7 +1770,7 @@ scriptitem_T *new_script_item(char *const name, scid_T *const sid_out)
     SCRIPT_ITEM(script_items.ga_len).sn_name = NULL;
     SCRIPT_ITEM(script_items.ga_len).sn_prof_on = false;
   }
-  SCRIPT_ITEM(sid).sn_name = (char_u *)name;
+  SCRIPT_ITEM(sid).sn_name = name;
   new_script_vars(sid);  // Allocate the local script variables to use for this script.
   return &SCRIPT_ITEM(sid);
 }
@@ -1814,7 +1814,7 @@ static void cmd_source_buffer(const exarg_T *const eap)
     return;
   }
   garray_T ga;
-  ga_init(&ga, sizeof(char_u), 400);
+  ga_init(&ga, sizeof(char), 400);
   const linenr_T final_lnum = eap->line2;
   // Copy the contents to be executed.
   for (linenr_T curr_lnum = eap->line1; curr_lnum <= final_lnum; curr_lnum++) {
@@ -1825,7 +1825,7 @@ static void cmd_source_buffer(const exarg_T *const eap)
     ga_concat(&ga, (char *)ml_get(curr_lnum));
     ga_append(&ga, NL);
   }
-  ((char_u *)ga.ga_data)[ga.ga_len - 1] = NUL;
+  ((char *)ga.ga_data)[ga.ga_len - 1] = NUL;
   const GetStrLineCookie cookie = {
     .buf = ga.ga_data,
     .offset = 0,
@@ -1886,7 +1886,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
   if (fname_exp == NULL) {
     return retval;
   }
-  if (os_isdir((char_u *)fname_exp)) {
+  if (os_isdir(fname_exp)) {
     smsg(_("Cannot source a directory: \"%s\""), fname);
     goto theend;
   }
@@ -1963,7 +1963,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
   cookie.finished = false;
 
   // Check if this script has a breakpoint.
-  cookie.breakpoint = dbg_find_breakpoint(true, (char_u *)fname_exp, (linenr_T)0);
+  cookie.breakpoint = dbg_find_breakpoint(true, fname_exp, (linenr_T)0);
   cookie.fname = fname_exp;
   cookie.dbg_tick = debug_tick;
 
@@ -1992,7 +1992,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
   si = get_current_script_id(&fname_exp, &current_sctx);
 
   // Keep the sourcing name/lnum, for recursive calls.
-  estack_push(ETYPE_SCRIPT, (char *)si->sn_name, 0);
+  estack_push(ETYPE_SCRIPT, si->sn_name, 0);
 
   if (l_do_profiling == PROF_YES) {
     bool forceit = false;
@@ -2025,7 +2025,7 @@ int do_source(char *fname, int check_other, int is_vimrc)
         && firstline[1] == 0xbb && firstline[2] == 0xbf) {
       // Found BOM; setup conversion, skip over BOM and recode the line.
       convert_setup(&cookie.conv, "utf-8", p_enc);
-      p = (char *)string_convert(&cookie.conv, (char_u *)firstline + 3, NULL);
+      p = string_convert(&cookie.conv, (char *)firstline + 3, NULL);
       if (p == NULL) {
         p = xstrdup((char *)firstline + 3);
       }
@@ -2128,7 +2128,7 @@ scriptitem_T *get_current_script_id(char **fnamep, sctx_T *ret_sctx)
   }
   if (script_sctx.sc_sid == 0) {
     si = new_script_item(*fnamep, &script_sctx.sc_sid);
-    *fnamep = xstrdup((char *)si->sn_name);
+    *fnamep = xstrdup(si->sn_name);
   }
   if (ret_sctx != NULL) {
     *ret_sctx = script_sctx;
@@ -2145,7 +2145,7 @@ void ex_scriptnames(exarg_T *eap)
     if (eap->line2 < 1 || eap->line2 > script_items.ga_len) {
       emsg(_(e_invarg));
     } else {
-      eap->arg = (char *)SCRIPT_ITEM(eap->line2).sn_name;
+      eap->arg = SCRIPT_ITEM(eap->line2).sn_name;
       do_exedit(eap, NULL);
     }
     return;
@@ -2153,7 +2153,7 @@ void ex_scriptnames(exarg_T *eap)
 
   for (int i = 1; i <= script_items.ga_len && !got_int; i++) {
     if (SCRIPT_ITEM(i).sn_name != NULL) {
-      home_replace(NULL, (char *)SCRIPT_ITEM(i).sn_name, (char *)NameBuff, MAXPATHL, true);
+      home_replace(NULL, SCRIPT_ITEM(i).sn_name, (char *)NameBuff, MAXPATHL, true);
       vim_snprintf((char *)IObuff, IOSIZE, "%3d: %s", i, NameBuff);
       if (!message_filtered((char *)IObuff)) {
         msg_putchar('\n');
@@ -2179,40 +2179,40 @@ void scriptnames_slash_adjust(void)
 
 /// Get a pointer to a script name.  Used for ":verbose set".
 /// Message appended to "Last set from "
-char_u *get_scriptname(LastSet last_set, bool *should_free)
+char *get_scriptname(LastSet last_set, bool *should_free)
 {
   *should_free = false;
 
   switch (last_set.script_ctx.sc_sid) {
   case SID_MODELINE:
-    return (char_u *)_("modeline");
+    return _("modeline");
   case SID_CMDARG:
-    return (char_u *)_("--cmd argument");
+    return _("--cmd argument");
   case SID_CARG:
-    return (char_u *)_("-c argument");
+    return _("-c argument");
   case SID_ENV:
-    return (char_u *)_("environment variable");
+    return _("environment variable");
   case SID_ERROR:
-    return (char_u *)_("error handler");
+    return _("error handler");
   case SID_WINLAYOUT:
-    return (char_u *)_("changed window size");
+    return _("changed window size");
   case SID_LUA:
-    return (char_u *)_("Lua");
+    return _("Lua");
   case SID_API_CLIENT:
     snprintf((char *)IObuff, IOSIZE, _("API client (channel id %" PRIu64 ")"), last_set.channel_id);
-    return IObuff;
+    return (char *)IObuff;
   case SID_STR:
-    return (char_u *)_("anonymous :source");
+    return _("anonymous :source");
   default: {
-    char *const sname = (char *)SCRIPT_ITEM(last_set.script_ctx.sc_sid).sn_name;
+    char *const sname = SCRIPT_ITEM(last_set.script_ctx.sc_sid).sn_name;
     if (sname == NULL) {
       snprintf((char *)IObuff, IOSIZE, _("anonymous :source (script id %d)"),
                last_set.script_ctx.sc_sid);
-      return IObuff;
+      return (char *)IObuff;
     }
 
     *should_free = true;
-    return (char_u *)home_replace_save(NULL, sname);
+    return home_replace_save(NULL, sname);
   }
   }
 }
@@ -2248,7 +2248,7 @@ char *getsourceline(int c, void *cookie, int indent, bool do_concat)
 
   // If breakpoints have been added/deleted need to check for it.
   if (sp->dbg_tick < debug_tick) {
-    sp->breakpoint = dbg_find_breakpoint(true, (char_u *)sp->fname, SOURCING_LNUM);
+    sp->breakpoint = dbg_find_breakpoint(true, sp->fname, SOURCING_LNUM);
     sp->dbg_tick = debug_tick;
   }
   if (do_profiling == PROF_YES) {
@@ -2287,11 +2287,10 @@ char *getsourceline(int c, void *cookie, int indent, bool do_concat)
             || (p[0] == '"' && p[1] == '\\' && p[2] == ' '))) {
       garray_T ga;
 
-      ga_init(&ga, (int)sizeof(char_u), 400);
+      ga_init(&ga, (int)sizeof(char), 400);
       ga_concat(&ga, line);
       while (sp->nextline != NULL
-             && concat_continued_line(&ga, 400, (char_u *)sp->nextline,
-                                      STRLEN(sp->nextline))) {
+             && concat_continued_line(&ga, 400, sp->nextline, STRLEN(sp->nextline))) {
         xfree(sp->nextline);
         sp->nextline = get_one_sourceline(sp);
       }
@@ -2305,7 +2304,7 @@ char *getsourceline(int c, void *cookie, int indent, bool do_concat)
     char *s;
 
     // Convert the encoding of the script line.
-    s = (char *)string_convert(&sp->conv, (char_u *)line, NULL);
+    s = string_convert(&sp->conv, line, NULL);
     if (s != NULL) {
       xfree(line);
       line = s;
@@ -2314,9 +2313,9 @@ char *getsourceline(int c, void *cookie, int indent, bool do_concat)
 
   // Did we encounter a breakpoint?
   if (sp->breakpoint != 0 && sp->breakpoint <= SOURCING_LNUM) {
-    dbg_breakpoint((char_u *)sp->fname, SOURCING_LNUM);
+    dbg_breakpoint(sp->fname, SOURCING_LNUM);
     // Find next breakpoint.
-    sp->breakpoint = dbg_find_breakpoint(true, (char_u *)sp->fname, SOURCING_LNUM);
+    sp->breakpoint = dbg_find_breakpoint(true, sp->fname, SOURCING_LNUM);
     sp->dbg_tick = debug_tick;
   }
 
diff --git a/src/nvim/runtime.h b/src/nvim/runtime.h
index 03c426c79b..053c71212e 100644
--- a/src/nvim/runtime.h
+++ b/src/nvim/runtime.h
@@ -51,7 +51,7 @@ typedef enum {
 } estack_arg_T;
 
 typedef struct scriptitem_S {
-  char_u *sn_name;
+  char *sn_name;
   bool sn_prof_on;              ///< true when script is/was profiled
   bool sn_pr_force;             ///< forceit: profile functions in this script
   proftime_T sn_pr_child;       ///< time set when going into first child
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 6efaae3725..d268dde845 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -1270,7 +1270,7 @@ static int get_encoded_char_adv(const char_u **p)
     int64_t num = 0;
     for (int bytes = s[1] == 'x' ? 1 : s[1] == 'u' ? 2 : 4; bytes > 0; bytes--) {
       *p += 2;
-      int n = hexhex2nr(*p);
+      int n = hexhex2nr((char *)(*p));
       if (n < 0) {
         return 0;
       }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index c1c2f0dbe9..e995081df8 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -170,7 +170,7 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
   }
 
   if (curwin->w_p_rl && *curwin->w_p_rlc == 's') {
-    mr_pattern = reverse_text(pat);
+    mr_pattern = (char_u *)reverse_text((char *)pat);
     mr_pattern_alloced = true;
   } else {
     mr_pattern = pat;
@@ -1261,7 +1261,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
         // it would be blanked out again very soon.  Show it on the
         // left, but do reverse the text.
         if (curwin->w_p_rl && *curwin->w_p_rlc == 's') {
-          char_u *r = reverse_text(trunc != NULL ? trunc : msgbuf);
+          char_u *r = (char_u *)reverse_text(trunc != NULL ? (char *)trunc : (char *)msgbuf);
           xfree(msgbuf);
           msgbuf = r;
           // move reversed text to beginning of buffer
@@ -3666,7 +3666,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
           if (new_fname != NULL) {
             // using "new_fname" is more reliable, e.g., when
             // 'includeexpr' is set.
-            msg_outtrans_attr(new_fname, HL_ATTR(HLF_D));
+            msg_outtrans_attr((char *)new_fname, HL_ATTR(HLF_D));
           } else {
             /*
              * Isolate the file name.
@@ -3702,7 +3702,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
             }
             save_char = p[i];
             p[i] = NUL;
-            msg_outtrans_attr(p, HL_ATTR(HLF_D));
+            msg_outtrans_attr((char *)p, HL_ATTR(HLF_D));
             p[i] = save_char;
           }
 
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 88ad7d519a..d2f1b39ca4 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -3023,7 +3023,7 @@ shada_write_file_nomerge: {}
     if (tail != fname) {
       const char tail_save = *tail;
       *tail = NUL;
-      if (!os_isdir((char_u *)fname)) {
+      if (!os_isdir(fname)) {
         int ret;
         char *failed_dir;
         if ((ret = os_mkdir_recurse(fname, 0700, &failed_dir)) != 0) {
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index a9640eacda..ed7f53d3ba 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -858,7 +858,7 @@ static void sign_define_init_icon(sign_T *sp, char_u *icon)
 {
   xfree(sp->sn_icon);
   sp->sn_icon = vim_strsave(icon);
-  backslash_halve(sp->sn_icon);
+  backslash_halve((char *)sp->sn_icon);
 }
 
 /// Initialize the text for a new sign
@@ -1353,7 +1353,7 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
     if (STRNCMP(arg, "line=", 5) == 0) {
       arg += 5;
       *lnum = atoi((char *)arg);
-      arg = skiptowhite(arg);
+      arg = (char_u *)skiptowhite((char *)arg);
       lnum_arg = true;
     } else if (STRNCMP(arg, "*", 1) == 0 && cmd == SIGNCMD_UNPLACE) {
       if (*signid != -1) {
@@ -1361,11 +1361,11 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
         return FAIL;
       }
       *signid = -2;
-      arg = skiptowhite(arg + 1);
+      arg = (char_u *)skiptowhite((char *)arg + 1);
     } else if (STRNCMP(arg, "name=", 5) == 0) {
       arg += 5;
       name = arg;
-      arg = skiptowhite(arg);
+      arg = (char_u *)skiptowhite((char *)arg);
       if (*arg != NUL) {
         *arg++ = NUL;
       }
@@ -1376,14 +1376,14 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
     } else if (STRNCMP(arg, "group=", 6) == 0) {
       arg += 6;
       *group = arg;
-      arg = skiptowhite(arg);
+      arg = (char_u *)skiptowhite((char *)arg);
       if (*arg != NUL) {
         *arg++ = NUL;
       }
     } else if (STRNCMP(arg, "priority=", 9) == 0) {
       arg += 9;
       *prio = atoi((char *)arg);
-      arg = skiptowhite(arg);
+      arg = (char_u *)skiptowhite((char *)arg);
     } else if (STRNCMP(arg, "file=", 5) == 0) {
       arg += 5;
       filename = arg;
@@ -1427,7 +1427,7 @@ void ex_sign(exarg_T *eap)
   sign_T *sp;
 
   // Parse the subcommand.
-  p = skiptowhite(arg);
+  p = (char_u *)skiptowhite((char *)arg);
   idx = sign_cmd_idx(arg, p);
   if (idx == SIGNCMD_LAST) {
     semsg(_("E160: Unknown sign command: %s"), arg);
@@ -1449,7 +1449,7 @@ void ex_sign(exarg_T *eap)
 
       // Isolate the sign name.  If it's a number skip leading zeroes,
       // so that "099" and "99" are the same sign.  But keep "0".
-      p = skiptowhite(arg);
+      p = (char_u *)skiptowhite((char *)arg);
       if (*p != NUL) {
         *p++ = NUL;
       }
@@ -1789,7 +1789,7 @@ void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
   expand_what = EXP_SUBCMD;
   xp->xp_pattern = (char *)arg;
 
-  end_subcmd = skiptowhite(arg);
+  end_subcmd = (char_u *)skiptowhite((char *)arg);
   if (*end_subcmd == NUL) {
     // expand subcmd name
     // :sign {subcmd}<CTRL-D>
@@ -1814,7 +1814,7 @@ void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
   do {
     p = (char_u *)skipwhite((char *)p);
     last = p;
-    p = skiptowhite(p);
+    p = (char_u *)skiptowhite((char *)p);
   } while (*p != NUL);
 
   p = (char_u *)vim_strchr((char *)last, '=');
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 10923829c3..1259736e0e 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -243,7 +243,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
     if (*ptr == '0' && (ptr[1] == 'b' || ptr[1] == 'B')) {
       mi.mi_end = (char_u *)skipbin((char *)ptr + 2);
     } else if (*ptr == '0' && (ptr[1] == 'x' || ptr[1] == 'X')) {
-      mi.mi_end = skiphex(ptr + 2);
+      mi.mi_end = (char_u *)skiphex((char *)ptr + 2);
     } else {
       mi.mi_end = (char_u *)skipdigits((char *)ptr);
     }
@@ -1258,10 +1258,10 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
 
     // For checking first word with a capital skip white space.
     if (capcol == 0) {
-      capcol = (int)getwhitecols(line);
+      capcol = (int)getwhitecols((char *)line);
     } else if (curline && wp == curwin) {
       // For spellbadword(): check if first word needs a capital.
-      col = (int)getwhitecols(line);
+      col = (int)getwhitecols((char *)line);
       if (check_need_cap(lnum, col)) {
         capcol = col;
       }
@@ -1876,7 +1876,7 @@ char *did_set_spelllang(win_T *wp)
 
       // Check if we loaded this language before.
       for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-        if (path_full_compare((char *)lang, (char *)slang->sl_fname, false, true)
+        if (path_full_compare((char *)lang, slang->sl_fname, false, true)
             == kEqualFiles) {
           break;
         }
@@ -1925,7 +1925,7 @@ char *did_set_spelllang(win_T *wp)
     // Loop over the languages, there can be several files for "lang".
     for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
       if (filename
-          ? path_full_compare((char *)lang, (char *)slang->sl_fname, false, true) == kEqualFiles
+          ? path_full_compare((char *)lang, slang->sl_fname, false, true) == kEqualFiles
           : STRICMP(lang, slang->sl_name) == 0) {
         region_mask = REGION_ALL;
         if (!filename && region != NULL) {
@@ -1981,7 +1981,7 @@ char *did_set_spelllang(win_T *wp)
 
       // If it was already found above then skip it.
       for (c = 0; c < ga.ga_len; c++) {
-        p = LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
+        p = (char_u *)LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
         if (p != NULL
             && path_full_compare((char *)spf_name, (char *)p, false, true) == kEqualFiles) {
           break;
@@ -1994,7 +1994,7 @@ char *did_set_spelllang(win_T *wp)
 
     // Check if it was loaded already.
     for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-      if (path_full_compare((char *)spf_name, (char *)slang->sl_fname, false, true)
+      if (path_full_compare((char *)spf_name, slang->sl_fname, false, true)
           == kEqualFiles) {
         break;
       }
@@ -2473,7 +2473,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
   char_u *line = get_cursor_line_ptr();
   char_u *line_copy = NULL;
   colnr_T endcol = 0;
-  if (getwhitecols(line) >= (int)col) {
+  if (getwhitecols((char *)line) >= (int)col) {
     // At start of line, check if previous line is empty or sentence
     // ends there.
     if (lnum == 1) {
@@ -2484,7 +2484,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
         need_cap = true;
       } else {
         // Append a space in place of the line break.
-        line_copy = concat_str(line, (char_u *)" ");
+        line_copy = (char_u *)concat_str((char *)line, " ");
         line = line_copy;
         endcol = (colnr_T)STRLEN(line);
       }
@@ -3599,8 +3599,8 @@ char *compile_cap_prog(synblock_T *synblock)
     synblock->b_cap_prog = NULL;
   } else {
     // Prepend a ^ so that we only match at one column
-    char_u *re = concat_str((char_u *)"^", (char_u *)synblock->b_p_spc);
-    synblock->b_cap_prog = vim_regcomp((char *)re, RE_MAGIC);
+    char *re = concat_str("^", synblock->b_p_spc);
+    synblock->b_cap_prog = vim_regcomp(re, RE_MAGIC);
     xfree(re);
     if (synblock->b_cap_prog == NULL) {
       synblock->b_cap_prog = rp;         // restore the previous program
diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h
index 61f722b9ee..27b9777dc2 100644
--- a/src/nvim/spell_defs.h
+++ b/src/nvim/spell_defs.h
@@ -115,9 +115,9 @@ typedef struct slang_S slang_T;
 
 struct slang_S {
   slang_T *sl_next;         // next language
-  char_u *sl_name;         // language name "en", "en.rare", "nl", etc.
-  char_u *sl_fname;        // name of .spl file
-  bool sl_add;                  // true if it's a .add file.
+  char_u *sl_name;          // language name "en", "en.rare", "nl", etc.
+  char *sl_fname;           // name of .spl file
+  bool sl_add;              // true if it's a .add file.
 
   char_u *sl_fbyts;        // case-folded word bytes
   long sl_fbyts_len;     // length of sl_fbyts
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 33e8c5c099..0f8034312e 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -604,7 +604,7 @@ slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, bool sile
     lp = slang_alloc(lang);
 
     // Remember the file name, used to reload the file when it's updated.
-    lp->sl_fname = vim_strsave(fname);
+    lp->sl_fname = (char *)vim_strsave(fname);
 
     // Check for .add.spl.
     lp->sl_add = strstr(path_tail((char *)fname), SPL_FNAME_ADD) != NULL;
@@ -869,12 +869,12 @@ static void tree_count_words(char_u *byts, idx_T *idxs)
   }
 }
 
-// Load the .sug files for languages that have one and weren't loaded yet.
+/// Load the .sug files for languages that have one and weren't loaded yet.
 void suggest_load_files(void)
 {
   langp_T *lp;
   slang_T *slang;
-  char_u *dotp;
+  char *dotp;
   FILE *fd;
   char_u buf[MAXWLEN];
   int i;
@@ -894,12 +894,12 @@ void suggest_load_files(void)
       // don't try again and again.
       slang->sl_sugloaded = true;
 
-      dotp = STRRCHR(slang->sl_fname, '.');
+      dotp = strrchr(slang->sl_fname, '.');
       if (dotp == NULL || FNAMECMP(dotp, ".spl") != 0) {
         continue;
       }
       STRCPY(dotp, ".sug");
-      fd = os_fopen((char *)slang->sl_fname, "r");
+      fd = os_fopen(slang->sl_fname, "r");
       if (fd == NULL) {
         goto nextone;
       }
@@ -1822,7 +1822,7 @@ static void spell_reload_one(char_u *fname, bool added_word)
   bool didit = false;
 
   for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-    if (path_full_compare((char *)fname, (char *)slang->sl_fname, false, true) == kEqualFiles) {
+    if (path_full_compare((char *)fname, slang->sl_fname, false, true) == kEqualFiles) {
       slang_clear(slang);
       if (spell_load_file(fname, NULL, slang, false) == NULL) {
         // reloading failed, clear the language
@@ -2075,7 +2075,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     // Convert from "SET" to 'encoding' when needed.
     xfree(pc);
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = string_convert(&spin->si_conv, rline, NULL);
+      pc = (char_u *)string_convert(&spin->si_conv, (char *)rline, NULL);
       if (pc == NULL) {
         smsg(_("Conversion failure for word in %s line %d: %s"),
              fname, lnum, rline);
@@ -3155,7 +3155,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
 
     // Convert from "SET" to 'encoding' when needed.
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = string_convert(&spin->si_conv, line, NULL);
+      pc = (char_u *)string_convert(&spin->si_conv, (char *)line, NULL);
       if (pc == NULL) {
         smsg(_("Conversion failure for word in %s line %d: %s"),
              fname, lnum, line);
@@ -3701,7 +3701,7 @@ static int spell_read_wordfile(spellinfo_T *spin, char_u *fname)
     // Convert from "/encoding={encoding}" to 'encoding' when needed.
     xfree(pc);
     if (spin->si_conv.vc_type != CONV_NONE) {
-      pc = string_convert(&spin->si_conv, rline, NULL);
+      pc = (char_u *)string_convert(&spin->si_conv, (char *)rline, NULL);
       if (pc == NULL) {
         smsg(_("Conversion failure for word in %s line %ld: %s"),
              fname, lnum, rline);
@@ -4907,7 +4907,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
   // of the code for the soundfolding stuff.
   // It might have been done already by spell_reload_one().
   for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
-    if (path_full_compare(wfname, (char *)slang->sl_fname, false, true)
+    if (path_full_compare(wfname, slang->sl_fname, false, true)
         == kEqualFiles) {
       break;
     }
@@ -5343,7 +5343,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       emsg(_(e_exists));
       goto theend;
     }
-    if (os_isdir((char_u *)wfname)) {
+    if (os_isdir(wfname)) {
       semsg(_(e_isadir2), wfname);
       goto theend;
     }
@@ -5723,7 +5723,7 @@ static void init_spellfile(void)
                        "/%.*s", (int)(lend - lstart), lstart);
         }
         l = (int)STRLEN(buf);
-        fname = LANGP_ENTRY(curwin->w_s->b_langp, 0)
+        fname = (char_u *)LANGP_ENTRY(curwin->w_s->b_langp, 0)
                 ->lp_slang->sl_fname;
         vim_snprintf((char *)buf + l, MAXPATHL - (size_t)l, ".%s.add",
                      ((fname != NULL
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index fa46d94342..23c8c621b5 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -972,7 +972,7 @@ static void suggest_try_special(suginfo_T *su)
   char_u word[MAXWLEN];
 
   // Recognize a word that is repeated: "the the".
-  char_u *p = skiptowhite(su->su_fbadword);
+  char_u *p = (char_u *)skiptowhite((char *)su->su_fbadword);
   size_t len = (size_t)(p - su->su_fbadword);
   p = (char_u *)skipwhite((char *)p);
   if (STRLEN(p) == len && STRNCMP(su->su_fbadword, p, len) == 0) {
@@ -1369,8 +1369,8 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
 
           if (compound_ok) {
             p = preword;
-            while (*skiptowhite(p) != NUL) {
-              p = (char_u *)skipwhite((char *)skiptowhite(p));
+            while (*skiptowhite((char *)p) != NUL) {
+              p = (char_u *)skipwhite(skiptowhite((char *)p));
             }
             if (fword_ends && !can_compound(slang, p,
                                             compflags + sp->ts_compsplit)) {
@@ -1590,8 +1590,8 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
               break;
             }
             p = preword;
-            while (*skiptowhite(p) != NUL) {
-              p = (char_u *)skipwhite((char *)skiptowhite(p));
+            while (*skiptowhite((char *)p) != NUL) {
+              p = (char_u *)skipwhite(skiptowhite((char *)p));
             }
             if (sp->ts_complen > sp->ts_compsplit
                 && !can_compound(slang, p,
@@ -2636,8 +2636,8 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
     // removing the space.  Don't do it when the good word also contains a
     // space.
     if (ascii_iswhite(su->su_badptr[su->su_badlen])
-        && *skiptowhite(stp->st_word) == NUL) {
-      for (p = fword; *(p = skiptowhite(p)) != NUL;) {
+        && *skiptowhite((char *)stp->st_word) == NUL) {
+      for (p = fword; *(p = (char_u *)skiptowhite((char *)p)) != NUL;) {
         STRMOVE(p, p + 1);
       }
     }
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index bd0f122f99..16691d0ded 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -503,7 +503,7 @@ static int sort_compare(const void *s1, const void *s2)
 
 void sort_strings(char **files, int count)
 {
-  qsort((void *)files, (size_t)count, sizeof(char_u *), sort_compare);
+  qsort((void *)files, (size_t)count, sizeof(char *), sort_compare);
 }
 
 /*
@@ -540,14 +540,12 @@ bool has_non_ascii_len(const char *const s, const size_t len)
   return false;
 }
 
-/*
- * Concatenate two strings and return the result in allocated memory.
- */
-char_u *concat_str(const char_u *restrict str1, const char_u *restrict str2)
+/// Concatenate two strings and return the result in allocated memory.
+char *concat_str(const char *restrict str1, const char *restrict str2)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
   size_t l = STRLEN(str1);
-  char_u *dest = xmalloc(l + STRLEN(str2) + 1);
+  char *dest = xmalloc(l + STRLEN(str2) + 1);
   STRCPY(dest, str1);
   STRCPY(dest + l, str2);
   return dest;
@@ -1511,15 +1509,15 @@ int kv_do_printf(StringBuilder *str, const char *fmt, ...)
 /// Reverse text into allocated memory.
 ///
 /// @return  the allocated string.
-char_u *reverse_text(char_u *s)
+char *reverse_text(char *s)
   FUNC_ATTR_NONNULL_RET
 {
   // Reverse the pattern.
   size_t len = STRLEN(s);
-  char_u *rev = xmalloc(len + 1);
+  char *rev = xmalloc(len + 1);
   size_t rev_i = len;
   for (size_t s_i = 0; s_i < len; s_i++) {
-    const int mb_len = utfc_ptr2len((char *)s + s_i);
+    const int mb_len = utfc_ptr2len(s + s_i);
     rev_i -= (size_t)mb_len;
     memmove(rev + rev_i, s + s_i, (size_t)mb_len);
     s_i += (size_t)mb_len - 1;
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index e88b1b17f6..f055cc9b0e 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -3013,7 +3013,7 @@ static void syn_cmd_conceal(exarg_T *eap, int syncing)
     return;
   }
 
-  next = skiptowhite(arg);
+  next = (char_u *)skiptowhite((char *)arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_conceal) {
       msg("syntax conceal on");
@@ -3042,7 +3042,7 @@ static void syn_cmd_case(exarg_T *eap, int syncing)
     return;
   }
 
-  next = skiptowhite(arg);
+  next = (char_u *)skiptowhite((char *)arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_ic) {
       msg("syntax case ignore");
@@ -3081,7 +3081,7 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
     return;
   }
 
-  arg_end = skiptowhite(arg);
+  arg_end = (char_u *)skiptowhite((char *)arg);
   if (STRNICMP(arg, "start", 5) == 0 && arg_end - arg == 5) {
     curwin->w_s->b_syn_foldlevel = SYNFLD_START;
   } else if (STRNICMP(arg, "minimum", 7) == 0 && arg_end - arg == 7) {
@@ -3110,7 +3110,7 @@ static void syn_cmd_spell(exarg_T *eap, int syncing)
     return;
   }
 
-  next = skiptowhite(arg);
+  next = (char_u *)skiptowhite((char *)arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_spell == SYNSPL_TOP) {
       msg("syntax spell toplevel");
@@ -3345,7 +3345,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
      * Clear the group IDs that are in the argument.
      */
     while (!ends_excmd(*arg)) {
-      arg_end = skiptowhite(arg);
+      arg_end = (char_u *)skiptowhite((char *)arg);
       if (*arg == '@') {
         id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
         if (id == 0) {
@@ -3522,7 +3522,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
      * List the group IDs and syntax clusters that are in the argument.
      */
     while (!ends_excmd(*arg) && !got_int) {
-      arg_end = skiptowhite(arg);
+      arg_end = (char_u *)skiptowhite((char *)arg);
       if (*arg == '@') {
         int id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
         if (id == 0) {
@@ -4029,7 +4029,7 @@ static void add_keyword(char_u *const name, const int id, const int flags,
 ///                  Return NULL if the end of the command was found instead of further args.
 static char *get_group_name(char *arg, char **name_end)
 {
-  *name_end = (char *)skiptowhite((char_u *)arg);
+  *name_end = skiptowhite(arg);
   char *rest = skipwhite(*name_end);
 
   // Check if there are enough arguments.  The first argument may be a
@@ -4163,7 +4163,7 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
           return NULL;
         }
         gname_start = (char_u *)arg;
-        arg = (char *)skiptowhite((char_u *)arg);
+        arg = skiptowhite(arg);
         if (gname_start == (char_u *)arg) {
           return NULL;
         }
@@ -4600,7 +4600,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     }
 
     if (item == ITEM_MATCHGROUP) {
-      p = (char *)skiptowhite((char_u *)rest);
+      p = skiptowhite(rest);
       if ((p - rest == 4 && STRNCMP(rest, "NONE", 4) == 0) || eap->skip) {
         matchgroup_id = 0;
       } else {
@@ -5141,7 +5141,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
   }
 
   while (!ends_excmd(*arg_start)) {
-    arg_end = (char *)skiptowhite(arg_start);
+    arg_end = skiptowhite((char *)arg_start);
     next_arg = (char_u *)skipwhite(arg_end);
     xfree(key);
     key = vim_strnsave_up(arg_start, (size_t)(arg_end - (char *)arg_start));
@@ -5150,7 +5150,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
         curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
       }
       if (!ends_excmd(*next_arg)) {
-        arg_end = (char *)skiptowhite(next_arg);
+        arg_end = skiptowhite((char *)next_arg);
         if (!eap->skip) {
           curwin->w_s->b_syn_sync_id =
             (int16_t)syn_check_group((char *)next_arg, (size_t)(arg_end - (char *)next_arg));
@@ -5693,10 +5693,10 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
 
   // (part of) subcommand already typed
   if (*arg != NUL) {
-    const char *p = (const char *)skiptowhite((const char_u *)arg);
+    const char *p = (const char *)skiptowhite(arg);
     if (*p != NUL) {  // Past first word.
       xp->xp_pattern = skipwhite(p);
-      if (*skiptowhite((char_u *)xp->xp_pattern) != NUL) {
+      if (*skiptowhite(xp->xp_pattern) != NUL) {
         xp->xp_context = EXPAND_NOTHING;
       } else if (STRNICMP(arg, "case", p - arg) == 0) {
         expand_what = EXP_CASE;
@@ -6028,7 +6028,7 @@ static void syntime_report(void)
     if (len > (int)STRLEN(p->pattern)) {
       len = (int)STRLEN(p->pattern);
     }
-    msg_outtrans_len(p->pattern, len);
+    msg_outtrans_len((char *)p->pattern, len);
     msg_puts("\n");
   }
   ga_clear(&ga);
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 11825ce1c4..5270412382 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -738,7 +738,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
                  mt_names[matches[i][0] & MT_MASK]);
     msg_puts((char *)IObuff);
     if (tagp.tagkind != NULL) {
-      msg_outtrans_len(tagp.tagkind,
+      msg_outtrans_len((char *)tagp.tagkind,
                        (int)(tagp.tagkind_end - tagp.tagkind));
     }
     msg_advance(13);
@@ -752,7 +752,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
     // it and put "..." in the middle
     p = tag_full_fname(&tagp);
     if (p != NULL) {
-      msg_outtrans_attr(p, HL_ATTR(HLF_D));
+      msg_outtrans_attr((char *)p, HL_ATTR(HLF_D));
       XFREE_CLEAR(p);
     }
     if (msg_col > 0) {
@@ -794,7 +794,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
             }
             msg_advance(15);
           }
-          p = msg_outtrans_one(p, attr);
+          p = (char_u *)msg_outtrans_one((char *)p, attr);
           if (*p == TAB) {
             msg_puts_attr(" ", attr);
             break;
@@ -852,7 +852,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
         msg_putchar(' ');
         p++;
       } else {
-        p = msg_outtrans_one(p, 0);
+        p = (char_u *)msg_outtrans_one((char *)p, 0);
       }
 
       // don't display the "$/;\"" and "$?;\""
@@ -1052,7 +1052,7 @@ void do_tags(exarg_T *eap)
                    tagstack[i].tagname,
                    tagstack[i].fmark.mark.lnum);
       msg_outtrans((char *)IObuff);
-      msg_outtrans_attr(name, tagstack[i].fmark.fnum == curbuf->b_fnum
+      msg_outtrans_attr((char *)name, tagstack[i].fmark.fnum == curbuf->b_fnum
                         ? HL_ATTR(HLF_D) : 0);
       xfree(name);
     }
@@ -1561,7 +1561,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
 
     // Try tag file names from tags option one by one.
     for (first_file = true;
-         use_cscope || get_tagfname(&tn, first_file, tag_fname) == OK;
+         use_cscope || get_tagfname(&tn, first_file, (char *)tag_fname) == OK;
          first_file = false) {
       // A file that doesn't exist is silently ignored.  Only when not a
       // single file is found, an error message is given (further on).
@@ -1705,7 +1705,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
             eof = vim_fgets(lbuf, lbuf_size, fp);
           }
           // skip empty and blank lines
-          while (!eof && vim_isblankline(lbuf)) {
+          while (!eof && vim_isblankline((char *)lbuf)) {
             search_info.curr_offset = vim_ftell(fp);
             eof = vim_fgets(lbuf, lbuf_size, fp);
           }
@@ -1726,7 +1726,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
             eof = use_cscope
               ? cs_fgets(lbuf, lbuf_size)
               : vim_fgets(lbuf, lbuf_size, fp);
-          } while (!eof && vim_isblankline(lbuf));
+          } while (!eof && vim_isblankline((char *)lbuf));
 
           if (eof) {
             break;                                  // end of file
@@ -1741,7 +1741,7 @@ line_read_in:
           // Convert every line.  Converting the pattern from 'enc' to
           // the tags file encoding doesn't work, because characters are
           // not recognized.
-          conv_line = string_convert(&vimconv, lbuf, NULL);
+          conv_line = (char_u *)string_convert(&vimconv, (char *)lbuf, NULL);
           if (conv_line != NULL) {
             // Copy or swap lbuf and conv_line.
             len = (int)STRLEN(conv_line) + 1;
@@ -2340,10 +2340,10 @@ void free_tag_stuff(void)
 /// @param buf  pointer to buffer of MAXPATHL chars
 ///
 /// @return  FAIL if no more tag file names, OK otherwise.
-int get_tagfname(tagname_T *tnp, int first, char_u *buf)
+int get_tagfname(tagname_T *tnp, int first, char *buf)
 {
-  char_u *fname = NULL;
-  char_u *r_ptr;
+  char *fname = NULL;
+  char *r_ptr;
 
   if (first) {
     CLEAR_POINTER(tnp);
@@ -2374,7 +2374,7 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
 #ifdef BACKSLASH_IN_FILENAME
       slash_adjust(buf);
 #endif
-      simplify_filename(buf);
+      simplify_filename((char_u *)buf);
 
       for (int i = 0; i < tag_fnames.ga_len; i++) {
         if (STRCMP(buf, ((char **)(tag_fnames.ga_data))[i]) == 0) {
@@ -2402,7 +2402,7 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
    */
   for (;;) {
     if (tnp->tn_did_filefind_init) {
-      fname = vim_findfile(tnp->tn_search_ctx);
+      fname = (char *)vim_findfile(tnp->tn_search_ctx);
       if (fname != NULL) {
         break;
       }
@@ -2422,17 +2422,17 @@ int get_tagfname(tagname_T *tnp, int first, char_u *buf)
        * Copy next file name into buf.
        */
       buf[0] = NUL;
-      (void)copy_option_part(&tnp->tn_np, (char *)buf, MAXPATHL - 1, " ,");
+      (void)copy_option_part(&tnp->tn_np, buf, MAXPATHL - 1, " ,");
 
-      r_ptr = vim_findfile_stopdir(buf);
+      r_ptr = (char *)vim_findfile_stopdir((char_u *)buf);
       // move the filename one char forward and truncate the
       // filepath with a NUL
-      filename = (char_u *)path_tail((char *)buf);
+      filename = (char_u *)path_tail(buf);
       STRMOVE(filename + 1, filename);
       *filename++ = NUL;
 
-      tnp->tn_search_ctx = vim_findfile_init(buf, filename,
-                                             r_ptr, 100,
+      tnp->tn_search_ctx = vim_findfile_init((char_u *)buf, filename,
+                                             (char_u *)r_ptr, 100,
                                              false,                   // don't free visited list
                                              FINDFILE_FILE,           // we search for a file
                                              tnp->tn_search_ctx, true, (char_u *)curbuf->b_ffname);
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index ac52bce2f9..97a925f3ad 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -685,7 +685,7 @@ char *u_get_undo_file_name(const char *const buf_ffname, const bool reading)
         *p-- = NUL;
       }
 
-      bool has_directory = os_isdir((char_u *)dir_name);
+      bool has_directory = os_isdir(dir_name);
       if (!has_directory && *dirp == NUL && !reading) {
         // Last directory in the list does not exist, create it.
         int ret;
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index ae312de61a..5b2101587f 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -216,7 +216,7 @@ const char *set_context_in_user_cmd(expand_T *xp, const char *arg_in)
   // Check for attributes
   while (*arg == '-') {
     arg++;  // Skip "-".
-    p = (const char *)skiptowhite((const char_u *)arg);
+    p = (const char *)skiptowhite(arg);
     if (*p == NUL) {
       // Cursor is still in the attribute.
       p = strchr(arg, '=');
@@ -248,7 +248,7 @@ const char *set_context_in_user_cmd(expand_T *xp, const char *arg_in)
   }
 
   // After the attributes comes the new command name.
-  p = (const char *)skiptowhite((const char_u *)arg);
+  p = (const char *)skiptowhite(arg);
   if (*p == NUL) {
     xp->xp_context = EXPAND_USER_COMMANDS;
     xp->xp_pattern = (char *)arg;
@@ -434,7 +434,7 @@ static void uc_list(char *name, size_t name_len)
         msg_putchar(' ');
       }
 
-      msg_outtrans_attr((char_u *)cmd->uc_name, HL_ATTR(HLF_D));
+      msg_outtrans_attr(cmd->uc_name, HL_ATTR(HLF_D));
       len = (int)STRLEN(cmd->uc_name) + 4;
 
       do {
@@ -930,7 +930,7 @@ void ex_command(exarg_T *eap)
   // Check for attributes
   while (*p == '-') {
     p++;
-    end = (char *)skiptowhite((char_u *)p);
+    end = skiptowhite(p);
     if (uc_scan_attr(p, (size_t)(end - p), &argt, &def, &flags, &compl, (char_u **)&compl_arg,
                      &addr_type_arg) == FAIL) {
       return;
diff --git a/src/nvim/vim.h b/src/nvim/vim.h
index 3e12d8b0b4..ec8d6ab153 100644
--- a/src/nvim/vim.h
+++ b/src/nvim/vim.h
@@ -230,10 +230,7 @@ enum { FOLD_TEXT_LEN = 51, };  //!< buffer size for get_foldtext()
 # endif
 #endif
 
-#define STRRCHR(s, c)       (char_u *)strrchr((const char *)(s), (c))
-
-#define STRCAT(d, s)        strcat((char *)(d), (char *)(s))
-#define STRNCAT(d, s, n)    strncat((char *)(d), (char *)(s), (size_t)(n))
+#define STRCAT(d, s)        strcat((char *)(d), (char *)(s))  // NOLINT(runtime/printf)
 #define STRLCAT(d, s, n)    xstrlcat((char *)(d), (char *)(s), (size_t)(n))
 
 // Character used as separated in autoload function/variable names.
diff --git a/src/nvim/viml/parser/parser.h b/src/nvim/viml/parser/parser.h
index b8835127e7..55f54cedbe 100644
--- a/src/nvim/viml/parser/parser.h
+++ b/src/nvim/viml/parser/parser.h
@@ -142,9 +142,7 @@ static inline void viml_preader_get_line(ParserInputReader *const preader,
       .allocated = true,
       .size = pline.size,
     };
-    cpline.data = (char *)string_convert(&preader->conv,
-                                         (char_u *)pline.data,
-                                         &cpline.size);
+    cpline.data = string_convert(&preader->conv, (char *)pline.data, &cpline.size);
     if (pline.allocated) {
       xfree((void *)pline.data);
     }
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 832cb82bda..5adc8db088 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -730,7 +730,7 @@ void win_set_minimal_style(win_T *wp)
     char_u *old = (char_u *)wp->w_p_fcs;
     wp->w_p_fcs = ((*old == NUL)
                    ? xstrdup("eob: ")
-                   : (char *)concat_str(old, (char_u *)",eob: "));
+                   : concat_str((char *)old, ",eob: "));
     free_string_option((char *)old);
   }
 
@@ -739,7 +739,7 @@ void win_set_minimal_style(win_T *wp)
   char_u *old = (char_u *)wp->w_p_winhl;
   wp->w_p_winhl = ((*old == NUL)
                    ? xstrdup("EndOfBuffer:")
-                   : (char *)concat_str(old, (char_u *)",EndOfBuffer:"));
+                   : concat_str((char *)old, ",EndOfBuffer:"));
   free_string_option((char *)old);
   parse_winhl_opt(wp);
 
-- 
cgit 


From 6b7eed1884c3b022cc15568c39f80f8f4da0780b Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Tue, 30 Aug 2022 21:16:03 +0200
Subject: Vim 9.0.{0314,0319}: some filetypes are not recognized (#20005)

* vim-patch:9.0.0314: VDM files are not recognized

Problem:    VDM files are not recognized.
Solution:   Add patterns for VDM files. (Alessandro Pezzoni, closes vim/vim#11004)
https://github.com/vim/vim/commit/bf26941f40923d331169a4ecb7341608f5d1ca38

* vim-patch:9.0.0319: Godot shader files are not recognized

Problem:    Godot shader files are not recognized.
Solution:   Add patterns for "gdshader". (Maxim Kim, closes vim/vim#11006)
https://github.com/vim/vim/commit/d5c8f11905abc1bdf3b8864dbc40187855ed9374
---
 src/nvim/testdir/test_filetype.vim | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index e3a8370661..68ce9148a4 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -209,6 +209,7 @@ let s:filename_checks = {
     \ 'gdmo': ['file.mo', 'file.gdmo'],
     \ 'gdresource': ['file.tscn', 'file.tres'],
     \ 'gdscript': ['file.gd'],
+    \ 'gdshader': ['file.gdshader', 'file.shader'],
     \ 'gedcom': ['file.ged', 'lltxxxxx.txt', '/tmp/lltmp', '/tmp/lltmp-file', 'any/tmp/lltmp', 'any/tmp/lltmp-file'],
     \ 'gemtext': ['file.gmi', 'file.gemini'],
     \ 'gift': ['file.gift'],
@@ -588,6 +589,9 @@ let s:filename_checks = {
     \ 'usw2kagtlog': ['usw2kagt.log', 'USW2KAGT.LOG', 'usw2kagt.file.log', 'USW2KAGT.FILE.LOG', 'file.usw2kagt.log', 'FILE.USW2KAGT.LOG'],
     \ 'vala': ['file.vala'],
     \ 'vb': ['file.sba', 'file.vb', 'file.vbs', 'file.dsm', 'file.ctl'],
+    \ 'vdmpp': ['file.vpp', 'file.vdmpp'],
+    \ 'vdmrt': ['file.vdmrt'],
+    \ 'vdmsl': ['file.vdm', 'file.vdmsl'],
     \ 'vera': ['file.vr', 'file.vri', 'file.vrh'],
     \ 'verilog': ['file.v'],
     \ 'verilogams': ['file.va', 'file.vams'],
-- 
cgit 


From 813476bf7291dfaf9fc0ef77c9f53a07258a3801 Mon Sep 17 00:00:00 2001
From: Sean Dewar <seandewar@users.noreply.github.com>
Date: Tue, 30 Aug 2022 23:13:52 +0100
Subject: fix(exceptions): restore `did_throw` (#20000)

`!did_throw` doesn't exactly imply `!current_exception`, as `did_throw = false`
is sometimes used to defer exception handling for later (without forgetting the
exception). E.g: uncaught exception handling in `do_cmdline()` may be deferred
to a different call (e.g: when `try_level > 0`).

In #7881, `current_exception = NULL` in `do_cmdline()` is used as an analogue of
`did_throw = false`, but also causes the pending exception to be lost, which
also leaks as `discard_exception()` wasn't used.

It may be possible to fix this by saving/restoring `current_exception`, but
handling all of `did_throw`'s edge cases seems messier. Maybe not worth
diverging over.

This fix also uncovers a `man_spec.lua` bug on Windows: exceptions are thrown
due to Windows missing `man`, but they're lost; skip these tests if `man` isn't
executable.
---
 src/nvim/api/private/helpers.c |   8 +-
 src/nvim/api/private/helpers.h |   1 +
 src/nvim/api/vimscript.c       |   4 +-
 src/nvim/eval.c                |   2 +-
 src/nvim/eval/userfunc.c       |   2 +-
 src/nvim/ex_docmd.c            |  32 ++++----
 src/nvim/ex_eval.c             | 163 +++++++++++++++++++----------------------
 src/nvim/globals.h             |   6 +-
 src/nvim/lua/executor.c        |   2 +-
 9 files changed, 109 insertions(+), 111 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index e35c58bf1b..ebcf6cca6d 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -58,6 +58,7 @@ void try_enter(TryState *const tstate)
     .private_msg_list = NULL,
     .trylevel = trylevel,
     .got_int = got_int,
+    .did_throw = did_throw,
     .need_rethrow = need_rethrow,
     .did_emsg = did_emsg,
   };
@@ -65,6 +66,7 @@ void try_enter(TryState *const tstate)
   current_exception = NULL;
   trylevel = 1;
   got_int = false;
+  did_throw = false;
   need_rethrow = false;
   did_emsg = false;
 }
@@ -85,6 +87,7 @@ bool try_leave(const TryState *const tstate, Error *const err)
   assert(trylevel == 0);
   assert(!need_rethrow);
   assert(!got_int);
+  assert(!did_throw);
   assert(!did_emsg);
   assert(msg_list == &tstate->private_msg_list);
   assert(*msg_list == NULL);
@@ -93,6 +96,7 @@ bool try_leave(const TryState *const tstate, Error *const err)
   current_exception = tstate->current_exception;
   trylevel = tstate->trylevel;
   got_int = tstate->got_int;
+  did_throw = tstate->did_throw;
   need_rethrow = tstate->need_rethrow;
   did_emsg = tstate->did_emsg;
   return ret;
@@ -127,7 +131,7 @@ bool try_end(Error *err)
   force_abort = false;
 
   if (got_int) {
-    if (current_exception) {
+    if (did_throw) {
       // If we got an interrupt, discard the current exception
       discard_current_exception();
     }
@@ -146,7 +150,7 @@ bool try_end(Error *err)
     if (should_free) {
       xfree(msg);
     }
-  } else if (current_exception) {
+  } else if (did_throw) {
     api_set_error(err, kErrorTypeException, "%s", current_exception->value);
     discard_current_exception();
   }
diff --git a/src/nvim/api/private/helpers.h b/src/nvim/api/private/helpers.h
index 4608554448..2157ad0ec2 100644
--- a/src/nvim/api/private/helpers.h
+++ b/src/nvim/api/private/helpers.h
@@ -134,6 +134,7 @@ typedef struct {
   const msglist_T *const *msg_list;
   int trylevel;
   int got_int;
+  bool did_throw;
   int need_rethrow;
   int did_emsg;
 } TryState;
diff --git a/src/nvim/api/vimscript.c b/src/nvim/api/vimscript.c
index a28bfd2ab9..f6d0e39327 100644
--- a/src/nvim/api/vimscript.c
+++ b/src/nvim/api/vimscript.c
@@ -137,7 +137,7 @@ Object nvim_eval(String expr, Error *err)
     if (!recursive) {
       force_abort = false;
       suppress_errthrow = false;
-      current_exception = NULL;
+      did_throw = false;
       // `did_emsg` is set by emsg(), which cancels execution.
       did_emsg = false;
     }
@@ -196,7 +196,7 @@ static Object _call_function(String fn, Array args, dict_T *self, Error *err)
     if (!recursive) {
       force_abort = false;
       suppress_errthrow = false;
-      current_exception = NULL;
+      did_throw = false;
       // `did_emsg` is set by emsg(), which cancels execution.
       did_emsg = false;
     }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 508d7cf491..2dbaa2f8ac 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -5985,7 +5985,7 @@ void timer_due_cb(TimeWatcher *tw, void *data)
   // Handle error message
   if (called_emsg > called_emsg_before && did_emsg) {
     timer->emsg_count++;
-    if (current_exception != NULL) {
+    if (did_throw) {
       discard_current_exception();
     }
   }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index b9a94a971b..1f94f9c2b7 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -3010,7 +3010,7 @@ void ex_call(exarg_T *eap)
 
   // When inside :try we need to check for following "| catch" or "| endtry".
   // Not when there was an error, but do check if an exception was thrown.
-  if ((!aborting() || current_exception != NULL) && (!failed || eap->cstack->cs_trylevel > 0)) {
+  if ((!aborting() || did_throw) && (!failed || eap->cstack->cs_trylevel > 0)) {
     // Check for trailing illegal characters and a following command.
     if (!ends_excmd(*arg)) {
       if (!failed && !aborting()) {
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 1fa14f4e4f..bf518f3849 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -134,6 +134,7 @@ struct dbg_stuff {
   char *vv_throwpoint;
   int did_emsg;
   int got_int;
+  bool did_throw;
   int need_rethrow;
   int check_cstack;
   except_T *current_exception;
@@ -165,6 +166,7 @@ static void save_dbg_stuff(struct dbg_stuff *dsp)
   // Necessary for debugging an inactive ":catch", ":finally", ":endtry".
   dsp->did_emsg       = did_emsg;             did_emsg     = false;
   dsp->got_int        = got_int;              got_int      = false;
+  dsp->did_throw      = did_throw;            did_throw    = false;
   dsp->need_rethrow   = need_rethrow;         need_rethrow = false;
   dsp->check_cstack   = check_cstack;         check_cstack = false;
   dsp->current_exception = current_exception; current_exception = NULL;
@@ -180,6 +182,7 @@ static void restore_dbg_stuff(struct dbg_stuff *dsp)
   (void)v_throwpoint(dsp->vv_throwpoint);
   did_emsg = dsp->did_emsg;
   got_int = dsp->got_int;
+  did_throw = dsp->did_throw;
   need_rethrow = dsp->need_rethrow;
   check_cstack = dsp->check_cstack;
   current_exception = dsp->current_exception;
@@ -397,7 +400,8 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
 
   initial_trylevel = trylevel;
 
-  current_exception = NULL;
+  // "did_throw" will be set to true when an exception is being thrown.
+  did_throw = false;
   // "did_emsg" will be set to true when emsg() is used, in which case we
   // cancel the whole command line, and any if/endif or loop.
   // If force_abort is set, we cancel everything.
@@ -625,7 +629,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
         // not to use a cs_line[] from an entry that isn't a ":while"
         // or ":for": It would make "current_line" invalid and can
         // cause a crash.
-        if (!did_emsg && !got_int && !current_exception
+        if (!did_emsg && !got_int && !did_throw
             && cstack.cs_idx >= 0
             && (cstack.cs_flags[cstack.cs_idx]
                 & (CSF_WHILE | CSF_FOR))
@@ -666,7 +670,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       current_line = 0;
     }
 
-    // A ":finally" makes did_emsg, got_int and current_exception pending for
+    // A ":finally" makes did_emsg, got_int and did_throw pending for
     // being restored at the ":endtry".  Reset them here and set the
     // ACTIVE and FINALLY flags, so that the finally clause gets executed.
     // This includes the case where a missing ":endif", ":endwhile" or
@@ -675,9 +679,8 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       cstack.cs_lflags &= ~CSL_HAD_FINA;
       report_make_pending((cstack.cs_pending[cstack.cs_idx]
                            & (CSTP_ERROR | CSTP_INTERRUPT | CSTP_THROW)),
-                          current_exception);
-      did_emsg = got_int = false;
-      current_exception = NULL;
+                          did_throw ? current_exception : NULL);
+      did_emsg = got_int = did_throw = false;
       cstack.cs_flags[cstack.cs_idx] |= CSF_ACTIVE | CSF_FINALLY;
     }
 
@@ -690,7 +693,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
     // exception, cancel everything.  If it is left normally, reset
     // force_abort to get the non-EH compatible abortion behavior for
     // the rest of the script.
-    if (trylevel == 0 && !did_emsg && !got_int && !current_exception) {
+    if (trylevel == 0 && !did_emsg && !got_int && !did_throw) {
       force_abort = false;
     }
 
@@ -704,7 +707,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
     // - didn't get an error message or lines are not typed
     // - there is a command after '|', inside a :if, :while, :for or :try, or
     //   looping for ":source" command or function call.
-  } while (!((got_int || (did_emsg && force_abort) || current_exception)
+  } while (!((got_int || (did_emsg && force_abort) || did_throw)
              && cstack.cs_trylevel == 0)
            && !(did_emsg
                 // Keep going when inside try/catch, so that the error can be
@@ -724,7 +727,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
   if (cstack.cs_idx >= 0) {
     // If a sourced file or executed function ran to its end, report the
     // unclosed conditional.
-    if (!got_int && !current_exception
+    if (!got_int && !did_throw
         && ((getline_equal(fgetline, cookie, getsourceline)
              && !source_finished(fgetline, cookie))
             || (getline_equal(fgetline, cookie, get_func_line)
@@ -767,7 +770,8 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
     // conditional, discard the uncaught exception, disable the conversion
     // of interrupts or errors to exceptions, and ensure that no more
     // commands are executed.
-    if (current_exception) {
+    if (did_throw) {
+      assert(current_exception != NULL);
       char *p = NULL;
       msglist_T *messages = NULL;
       msglist_T *next;
@@ -829,14 +833,14 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
   // cstack belongs to the same function or, respectively, script file, it
   // will have to be checked for finally clauses to be executed due to the
   // ":return" or ":finish".  This is done in do_one_cmd().
-  if (current_exception) {
+  if (did_throw) {
     need_rethrow = true;
   }
   if ((getline_equal(fgetline, cookie, getsourceline)
        && ex_nesting_level > source_level(real_cookie))
       || (getline_equal(fgetline, cookie, get_func_line)
           && ex_nesting_level > func_level(real_cookie) + 1)) {
-    if (!current_exception) {
+    if (!did_throw) {
       check_cstack = true;
     }
   } else {
@@ -1675,7 +1679,7 @@ static void profile_cmd(const exarg_T *eap, cstack_T *cstack, LineGetter fgetlin
       && (!eap->skip || cstack->cs_idx == 0
           || (cstack->cs_idx > 0
               && (cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE)))) {
-    int skip = did_emsg || got_int || current_exception;
+    bool skip = did_emsg || got_int || did_throw;
 
     if (eap->cmdidx == CMD_catch) {
       skip = !skip && !(cstack->cs_idx >= 0
@@ -1872,7 +1876,7 @@ static char *do_one_cmd(char **cmdlinep, int flags, cstack_T *cstack, LineGetter
 
   ea.skip = (did_emsg
              || got_int
-             || current_exception
+             || did_throw
              || (cstack->cs_idx >= 0
                  && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)));
 
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 11795684cf..6dddafcfcb 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -49,16 +49,15 @@
 // interrupt (got_int) under an active try conditional terminates the script
 // after the non-active finally clauses of all active try conditionals have been
 // executed.  Otherwise, errors and/or interrupts are converted into catchable
-// exceptions, which terminate the script only if not caught.  For user
-// exceptions, only current_exception is set.  (Note: got_int can be set
-// asynchronously afterwards by a SIGINT, so current_exception && got_int is not
+// exceptions (did_throw additionally set), which terminate the script only if
+// not caught.  For user exceptions, only did_throw is set.  (Note: got_int can
+// be set asynchronously afterwards by a SIGINT, so did_throw && got_int is not
 // a reliant test that the exception currently being thrown is an interrupt
 // exception.  Similarly, did_emsg can be set afterwards on an error in an
-// (unskipped) conditional command inside an inactive conditional, so
-// current_exception && did_emsg is not a reliant test that the exception
-// currently being thrown is an error exception.)  -  The macros can be defined
-// as expressions checking for a variable that is allowed to be changed during
-// execution of a script.
+// (unskipped) conditional command inside an inactive conditional, so did_throw
+// && did_emsg is not a reliant test that the exception currently being thrown
+// is an error exception.)  -  The macros can be defined as expressions checking
+// for a variable that is allowed to be changed during execution of a script.
 
 // Values used for the Vim release.
 #define THROW_ON_ERROR true
@@ -71,7 +70,7 @@
 #define CHECK_SKIP \
   (did_emsg \
    || got_int \
-   || current_exception \
+   || did_throw \
    || (cstack->cs_idx > 0 \
        && !(cstack->cs_flags[cstack->cs_idx - 1] & CSF_ACTIVE)))
 
@@ -104,7 +103,7 @@ static int cause_abort = false;
 /// value. "got_int" is also set by calling interrupt().
 int aborting(void)
 {
-  return (did_emsg && force_abort) || got_int || current_exception;
+  return (did_emsg && force_abort) || got_int || did_throw;
 }
 
 /// The value of "force_abort" is temporarily reset by the first emsg() call
@@ -186,7 +185,7 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
    * currently throwing an exception, do nothing.  The message text will
    * then be stored to v:errmsg by emsg() without displaying it.
    */
-  if (((trylevel == 0 && !cause_abort) || emsg_silent) && !current_exception) {
+  if (((trylevel == 0 && !cause_abort) || emsg_silent) && !did_throw) {
     return false;
   }
 
@@ -217,7 +216,7 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
    * exception currently being thrown to prevent it from being caught.  Just
    * execute finally clauses and terminate.
    */
-  if (current_exception) {
+  if (did_throw) {
     // When discarding an interrupt exception, reset got_int to prevent the
     // same interrupt being converted to an exception again and discarding
     // the error exception we are about to throw here.
@@ -349,7 +348,7 @@ int do_intthrow(cstack_T *cstack)
 {
   // If no interrupt occurred or no try conditional is active and no exception
   // is being thrown, do nothing (for compatibility of non-EH scripts).
-  if (!got_int || (trylevel == 0 && !current_exception)) {
+  if (!got_int || (trylevel == 0 && !did_throw)) {
     return false;
   }
 
@@ -358,7 +357,7 @@ int do_intthrow(cstack_T *cstack)
     // The interrupt aborts everything except for executing finally clauses.
     // Discard any user or error or interrupt exception currently being
     // thrown.
-    if (current_exception) {
+    if (did_throw) {
       discard_current_exception();
     }
   } else {
@@ -369,7 +368,7 @@ int do_intthrow(cstack_T *cstack)
   // will be terminated then.  -  If an interrupt exception is already
   // being thrown, do nothing.
 
-  if (current_exception) {
+  if (did_throw) {
     if (current_exception->type == ET_INTERRUPT) {
       return false;
     }
@@ -596,6 +595,7 @@ void discard_current_exception(void)
   }
   // Note: all globals manipulated here should be saved/restored in
   // try_enter/try_leave.
+  did_throw = false;
   need_rethrow = false;
 }
 
@@ -1237,6 +1237,8 @@ void do_throw(cstack_T *cstack)
     cstack->cs_flags[idx] &= ~CSF_ACTIVE;
     cstack->cs_exception[idx] = current_exception;
   }
+
+  did_throw = true;
 }
 
 /// Handle ":try"
@@ -1345,7 +1347,7 @@ void ex_catch(exarg_T *eap)
      * corresponding try block never got active (because of an inactive
      * surrounding conditional or after an error or interrupt or throw).
      */
-    if (!current_exception || !(cstack->cs_flags[idx] & CSF_TRUE)) {
+    if (!did_throw || !(cstack->cs_flags[idx] & CSF_TRUE)) {
       skip = true;
     }
 
@@ -1406,10 +1408,10 @@ void ex_catch(exarg_T *eap)
     }
 
     if (caught) {
-      // Make this ":catch" clause active and reset did_emsg and got_int.
-      // Put the exception on the caught stack.
+      // Make this ":catch" clause active and reset did_emsg, got_int,
+      // and did_throw.  Put the exception on the caught stack.
       cstack->cs_flags[idx] |= CSF_ACTIVE | CSF_CAUGHT;
-      did_emsg = got_int = false;
+      did_emsg = got_int = did_throw = false;
       catch_exception((except_T *)cstack->cs_exception[idx]);
       // It's mandatory that the current exception is stored in the cstack
       // so that it can be discarded at the next ":catch", ":finally", or
@@ -1419,10 +1421,6 @@ void ex_catch(exarg_T *eap)
       if (cstack->cs_exception[cstack->cs_idx] != current_exception) {
         internal_error("ex_catch()");
       }
-      // Discarding current_exceptions happens based on what is stored in
-      // cstack->cs_exception, *all* calls to discard_current_exception() are
-      // (and must be) guarded by current_exception check.
-      current_exception = NULL;
     } else {
       /*
        * If there is a preceding catch clause and it caught the exception,
@@ -1477,14 +1475,12 @@ void ex_finally(exarg_T *eap)
     rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
                         &cstack->cs_looplevel);
 
-    /*
-     * Don't do something when the corresponding try block never got active
-     * (because of an inactive surrounding conditional or after an error or
-     * interrupt or throw) or for a ":finally" without ":try" or a multiple
-     * ":finally".  After every other error (did_emsg or the conditional
-     * errors detected above) or after an interrupt (got_int) or an
-     * exception (current_exception), the finally clause must be executed.
-     */
+    // Don't do something when the corresponding try block never got active
+    // (because of an inactive surrounding conditional or after an error or
+    // interrupt or throw) or for a ":finally" without ":try" or a multiple
+    // ":finally".  After every other error (did_emsg or the conditional
+    // errors detected above) or after an interrupt (got_int) or an
+    // exception (did_throw), the finally clause must be executed.
     skip = !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
 
     if (!skip) {
@@ -1509,22 +1505,20 @@ void ex_finally(exarg_T *eap)
        */
       cleanup_conditionals(cstack, CSF_TRY, false);
 
-      /*
-       * Make did_emsg, got_int, current_exception pending.  If set, they
-       * overrule a pending ":continue", ":break", ":return", or ":finish".
-       * Then we have particularly to discard a pending return value (as done
-       * by the call to cleanup_conditionals() above when did_emsg or
-       * got_int is set).  The pending values are restored by the
-       * ":endtry", except if there is a new error, interrupt, exception,
-       * ":continue", ":break", ":return", or ":finish" in the following
-       * finally clause.  A missing ":endwhile", ":endfor" or ":endif"
-       * detected here is treated as if did_emsg and current_exception had
-       * already been set, respectively in case that the error is not
-       * converted to an exception, current_exception had already been unset.
-       * We must not set did_emsg here since that would suppress the
-       * error message.
-       */
-      if (pending == CSTP_ERROR || did_emsg || got_int || current_exception) {
+      // Make did_emsg, got_int, did_throw pending.  If set, they overrule
+      // a pending ":continue", ":break", ":return", or ":finish".  Then
+      // we have particularly to discard a pending return value (as done
+      // by the call to cleanup_conditionals() above when did_emsg or
+      // got_int is set).  The pending values are restored by the
+      // ":endtry", except if there is a new error, interrupt, exception,
+      // ":continue", ":break", ":return", or ":finish" in the following
+      // finally clause.  A missing ":endwhile", ":endfor" or ":endif"
+      // detected here is treated as if did_emsg and did_throw had
+      // already been set, respectively in case that the error is not
+      // converted to an exception, did_throw had already been unset.
+      // We must not set did_emsg here since that would suppress the
+      // error message.
+      if (pending == CSTP_ERROR || did_emsg || got_int || did_throw) {
         if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN) {
           report_discard_pending(CSTP_RETURN,
                                  cstack->cs_rettv[cstack->cs_idx]);
@@ -1533,7 +1527,7 @@ void ex_finally(exarg_T *eap)
         if (pending == CSTP_ERROR && !did_emsg) {
           pending |= (THROW_ON_ERROR ? CSTP_THROW : 0);
         } else {
-          pending |= (current_exception ? CSTP_THROW : 0);
+          pending |= (did_throw ? CSTP_THROW : 0);
         }
         pending |= did_emsg  ? CSTP_ERROR     : 0;
         pending |= got_int   ? CSTP_INTERRUPT : 0;
@@ -1547,19 +1541,16 @@ void ex_finally(exarg_T *eap)
         // exception.  When emsg() is called for a missing ":endif" or
         // a missing ":endwhile"/":endfor" detected here, the
         // exception will be discarded.
-        if (current_exception
-            && cstack->cs_exception[cstack->cs_idx] != current_exception) {
+        if (did_throw && cstack->cs_exception[cstack->cs_idx] != current_exception) {
           internal_error("ex_finally()");
         }
       }
 
-      /*
-       * Set CSL_HAD_FINA, so do_cmdline() will reset did_emsg,
-       * got_int, and current_exception and make the finally clause active.
-       * This will happen after emsg() has been called for a missing
-       * ":endif" or a missing ":endwhile"/":endfor" detected here, so
-       * that the following finally clause will be executed even then.
-       */
+      // Set CSL_HAD_FINA, so do_cmdline() will reset did_emsg,
+      // got_int, and did_throw and make the finally clause active.
+      // This will happen after emsg() has been called for a missing
+      // ":endif" or a missing ":endwhile"/":endfor" detected here, so
+      // that the following finally clause will be executed even then.
       cstack->cs_lflags |= CSL_HAD_FINA;
     }
   }
@@ -1587,8 +1578,7 @@ void ex_endtry(exarg_T *eap)
     // made inactive by a ":continue", ":break", ":return", or ":finish" in
     // the finally clause.  The latter case need not be tested since then
     // anything pending has already been discarded.
-    bool skip = did_emsg || got_int || current_exception
-                || !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
+    bool skip = did_emsg || got_int || did_throw || !(cstack->cs_flags[cstack->cs_idx] & CSF_TRUE);
 
     if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
       eap->errmsg = get_end_emsg(cstack);
@@ -1602,14 +1592,12 @@ void ex_endtry(exarg_T *eap)
                           &cstack->cs_looplevel);
       skip = true;
 
-      /*
-       * If an exception is being thrown, discard it to prevent it from
-       * being rethrown at the end of this function.  It would be
-       * discarded by the error message, anyway.  Resets current_exception.
-       * This does not affect the script termination due to the error
-       * since "trylevel" is decremented after emsg() has been called.
-       */
-      if (current_exception) {
+      // If an exception is being thrown, discard it to prevent it from
+      // being rethrown at the end of this function.  It would be
+      // discarded by the error message, anyway.  Resets did_throw.
+      // This does not affect the script termination due to the error
+      // since "trylevel" is decremented after emsg() has been called.
+      if (did_throw) {
         discard_current_exception();
       }
 
@@ -1624,7 +1612,7 @@ void ex_endtry(exarg_T *eap)
        * a finally clause, we need to rethrow it after closing the try
        * conditional.
        */
-      if (current_exception
+      if (did_throw
           && (cstack->cs_flags[idx] & CSF_TRUE)
           && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
         rethrow = true;
@@ -1648,10 +1636,10 @@ void ex_endtry(exarg_T *eap)
       if (got_int) {
         skip = true;
         (void)do_intthrow(cstack);
-        // The do_intthrow() call may have reset current_exception or
+        // The do_intthrow() call may have reset did_throw or
         // cstack->cs_pending[idx].
         rethrow = false;
-        if (current_exception && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
+        if (did_throw && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
           rethrow = true;
         }
       }
@@ -1721,7 +1709,7 @@ void ex_endtry(exarg_T *eap)
       // When the finally clause was entered due to an error,
       // interrupt or throw (as opposed to a ":continue", ":break",
       // ":return", or ":finish"), restore the pending values of
-      // did_emsg, got_int, and current_exception.  This is skipped, if there
+      // did_emsg, got_int, and did_throw.  This is skipped, if there
       // was a new error, interrupt, throw, ":continue", ":break",
       // ":return", or ":finish".  in the finally clause.
       default:
@@ -1768,24 +1756,22 @@ void enter_cleanup(cleanup_T *csp)
 {
   int pending = CSTP_NONE;
 
-  /*
-   * Postpone did_emsg, got_int, current_exception.  The pending values will be
-   * restored by leave_cleanup() except if there was an aborting error,
-   * interrupt, or uncaught exception after this function ends.
-   */
-  if (did_emsg || got_int || current_exception || need_rethrow) {
+  // Postpone did_emsg, got_int, did_throw.  The pending values will be
+  // restored by leave_cleanup() except if there was an aborting error,
+  // interrupt, or uncaught exception after this function ends.
+  if (did_emsg || got_int || did_throw || need_rethrow) {
     csp->pending = (did_emsg ? CSTP_ERROR : 0)
                    | (got_int ? CSTP_INTERRUPT : 0)
-                   | (current_exception ? CSTP_THROW : 0)
+                   | (did_throw ? CSTP_THROW : 0)
                    | (need_rethrow ? CSTP_THROW : 0);
 
-    // If we are currently throwing an exception, save it as well.  On an error
-    // not yet converted to an exception, update "force_abort" and reset
-    // "cause_abort" (as do_errthrow() would do).  This is needed for the
-    // do_cmdline() call that is going to be made for autocommand execution.  We
-    // need not save *msg_list because there is an extra instance for every call
-    // of do_cmdline(), anyway.
-    if (current_exception || need_rethrow) {
+    // If we are currently throwing an exception (did_throw), save it as
+    // well.  On an error not yet converted to an exception, update
+    // "force_abort" and reset "cause_abort" (as do_errthrow() would do).
+    // This is needed for the do_cmdline() call that is going to be made
+    // for autocommand execution.  We need not save *msg_list because
+    // there is an extra instance for every call of do_cmdline(), anyway.
+    if (did_throw || need_rethrow) {
       csp->exception = current_exception;
       current_exception = NULL;
     } else {
@@ -1795,8 +1781,7 @@ void enter_cleanup(cleanup_T *csp)
         cause_abort = false;
       }
     }
-    did_emsg = got_int = need_rethrow = false;
-    current_exception = NULL;
+    did_emsg = got_int = did_throw = need_rethrow = false;
 
     // Report if required by the 'verbose' option or when debugging.
     report_make_pending(pending, csp->exception);
@@ -1866,7 +1851,7 @@ void leave_cleanup(cleanup_T *csp)
       force_abort = false;
     }
 
-    // Restore the pending values of did_emsg, got_int, and current_exception.
+    // Restore the pending values of did_emsg, got_int, and did_throw.
     if (pending & CSTP_ERROR) {
       did_emsg = true;
     }
@@ -1874,7 +1859,7 @@ void leave_cleanup(cleanup_T *csp)
       got_int = true;
     }
     if (pending & CSTP_THROW) {
-      need_rethrow = true;  // current_exception will be set by do_one_cmd()
+      need_rethrow = true;  // did_throw will be set by do_one_cmd()
     }
 
     // Report if required by the 'verbose' option or when debugging.
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index ddbe727db9..060db3b3b1 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -241,9 +241,13 @@ EXTERN int do_profiling INIT(= PROF_NONE);      ///< PROF_ values
 
 /// Exception currently being thrown.  Used to pass an exception to a different
 /// cstack.  Also used for discarding an exception before it is caught or made
-/// pending.
+/// pending.  Only valid when did_throw is true.
 EXTERN except_T *current_exception;
 
+/// An exception is being thrown.  Reset when the exception is caught or as
+/// long as it is pending in a finally clause.
+EXTERN bool did_throw INIT(= false);
+
 /// Set when a throw that cannot be handled in do_cmdline() must be propagated
 /// to the cstack of the previously called do_cmdline().
 EXTERN bool need_rethrow INIT(= false);
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 39585ac182..42aa13cfc1 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1027,7 +1027,7 @@ int nlua_call(lua_State *lstate)
     // TODO(bfredl): this should be simplified in error handling refactor
     force_abort = false;
     suppress_errthrow = false;
-    current_exception = NULL;
+    did_throw = false;
     did_emsg = false;
 
     try_start();
-- 
cgit 


From 94a2bc594020f2bb1f41d5e2e92d05ce9c293254 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 06:27:39 +0800
Subject: vim-patch:9.0.0332: overwrite check may block BufWriteCmd (#20014)

Problem:    Overwrite check may block BufWriteCmd.
Solution:   Do not use overwrite check when 'buftype' is "acwrite".
            (closes vim/vim#11011)
https://github.com/vim/vim/commit/9c8f94636b3610b898ffbbd07f6b75866d16cbca
---
 src/nvim/ex_cmds.c                | 13 +++++++++----
 src/nvim/testdir/test_autocmd.vim | 15 +++++++++++++++
 2 files changed, 24 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index fc753cf65c..e672b80d69 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1996,11 +1996,16 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
 {
   // Write to another file or b_flags set or not writing the whole file:
   // overwriting only allowed with '!'
+  // If "other" is false and bt_nofilename(buf) is true, this must be
+  // writing an "acwrite" buffer to the same file as its b_ffname, and
+  // buf_write() will only allow writing with BufWriteCmd autocommands,
+  // so there is no need for an overwrite check.
   if ((other
-       || (buf->b_flags & BF_NOTEDITED)
-       || ((buf->b_flags & BF_NEW)
-           && vim_strchr(p_cpo, CPO_OVERNEW) == NULL)
-       || (buf->b_flags & BF_READERR))
+       || (!bt_nofilename(buf)
+           && ((buf->b_flags & BF_NOTEDITED)
+               || ((buf->b_flags & BF_NEW)
+                   && vim_strchr(p_cpo, CPO_OVERNEW) == NULL)
+               || (buf->b_flags & BF_READERR))))
       && !p_wa
       && os_path_exists((char_u *)ffname)) {
     if (!eap->forceit && !eap->append) {
diff --git a/src/nvim/testdir/test_autocmd.vim b/src/nvim/testdir/test_autocmd.vim
index 27bc6303cf..3064b199d9 100644
--- a/src/nvim/testdir/test_autocmd.vim
+++ b/src/nvim/testdir/test_autocmd.vim
@@ -1836,6 +1836,21 @@ func Test_BufReadCmd()
   au! BufWriteCmd
 endfunc
 
+func Test_BufWriteCmd()
+  autocmd BufWriteCmd Xbufwritecmd let g:written = 1
+  new
+  file Xbufwritecmd
+  set buftype=acwrite
+  call mkdir('Xbufwritecmd')
+  write
+  " BufWriteCmd should be triggered even if a directory has the same name
+  call assert_equal(1, g:written)
+  call delete('Xbufwritecmd', 'd')
+  unlet g:written
+  au! BufWriteCmd
+  bwipe!
+endfunc
+
 func SetChangeMarks(start, end)
   exe a:start .. 'mark ['
   exe a:end .. 'mark ]'
-- 
cgit 


From 518b5c65b0c6f5ee75718048fc661e629a01429b Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 06:58:28 +0800
Subject: vim-patch:8.1.2037: can call win_gotoid() in cmdline window (#20015)

Problem:    Can call win_gotoid() in cmdline window.
Solution:   Disallow switching windows. (Yasuhiro Matsumoto, closes vim/vim#4940)
https://github.com/vim/vim/commit/a046b37c22bcabdea5f0fd6d21ca4bd0aa4c768e
---
 src/nvim/eval/funcs.c             | 14 +++++++++++++-
 src/nvim/testdir/test_cmdline.vim | 10 ++++++++++
 src/nvim/window.c                 | 13 -------------
 3 files changed, 23 insertions(+), 14 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index f21011d22b..aa328d50ef 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -9659,7 +9659,19 @@ static void f_win_gettype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "win_gotoid()" function
 static void f_win_gotoid(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  rettv->vval.v_number = win_gotoid(argvars);
+  int id = (int)tv_get_number(&argvars[0]);
+
+  if (cmdwin_type != 0) {
+    emsg(_(e_cmdwin));
+    return;
+  }
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    if (wp->handle == id) {
+      goto_tabpage_win(tp, wp);
+      rettv->vval.v_number = 1;
+      return;
+    }
+  }
 }
 
 /// "win_id2tabwin()" function
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index 045504b8bf..4bfd22cb6c 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -1260,6 +1260,16 @@ func Test_cmdline_overstrike()
   let &encoding = encoding_save
 endfunc
 
+func Test_cmdwin_bug()
+  let winid = win_getid()
+  sp
+  try
+    call feedkeys("q::call win_gotoid(" .. winid .. ")\<CR>:q\<CR>", 'x!')
+  catch /^Vim\%((\a\+)\)\=:E11/
+  endtry
+  bw!
+endfunc
+
 func Test_cmdwin_restore()
   CheckScreendump
 
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 5adc8db088..74ea1172ee 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -7396,19 +7396,6 @@ int win_getid(typval_T *argvars)
   return 0;
 }
 
-int win_gotoid(typval_T *argvars)
-{
-  int id = (int)tv_get_number(&argvars[0]);
-
-  FOR_ALL_TAB_WINDOWS(tp, wp) {
-    if (wp->handle == id) {
-      goto_tabpage_win(tp, wp);
-      return 1;
-    }
-  }
-  return 0;
-}
-
 void win_get_tabwin(handle_T id, int *tabnr, int *winnr)
 {
   *tabnr = 0;
-- 
cgit 


From 5ff2ea66873dc0bcd1921158a93e363f009b245d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 07:24:16 +0800
Subject: vim-patch:8.2.0301: insufficient testing for exception handling
 (#20016)

Problem:    Insufficient testing for exception handling and the "attention"
            prompt.
Solution:   Add test cases. (Yegappan Lakshmanan, closes vim/vim#5681)
https://github.com/vim/vim/commit/b654103ad1e379348616f354272db86804ab4bdb

Fix memory leak from last char_u refactor.
---
 src/nvim/eval/userfunc.c           |   3 +-
 src/nvim/testdir/test_swap.vim     |   1 +
 src/nvim/testdir/test_trycatch.vim | 175 +++++++++++++++++++++++++++++++++++--
 3 files changed, 171 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 1f94f9c2b7..4be922a055 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -3111,8 +3111,7 @@ char *get_return_cmd(void *rettv)
   char *tofree = NULL;
 
   if (rettv != NULL) {
-    tofree = encode_tv2echo((typval_T *)rettv, NULL);
-    s = encode_tv2echo((typval_T *)rettv, NULL);
+    tofree = s = encode_tv2echo((typval_T *)rettv, NULL);
   }
   if (s == NULL) {
     s = "";
diff --git a/src/nvim/testdir/test_swap.vim b/src/nvim/testdir/test_swap.vim
index 923e1cbf50..5c9e39f1f4 100644
--- a/src/nvim/testdir/test_swap.vim
+++ b/src/nvim/testdir/test_swap.vim
@@ -2,6 +2,7 @@
 
 source check.vim
 source shared.vim
+source term_util.vim
 
 func s:swapname()
   return trim(execute('swapname'))
diff --git a/src/nvim/testdir/test_trycatch.vim b/src/nvim/testdir/test_trycatch.vim
index 646594e482..d71bb5bbb8 100644
--- a/src/nvim/testdir/test_trycatch.vim
+++ b/src/nvim/testdir/test_trycatch.vim
@@ -2027,16 +2027,179 @@ func Test_try_catch_verbose()
   endtry
   redir END
   let expected = [
-        \ 'Exception thrown: Vim(echo):E121: Undefined variable: i',
-        \ '',
-        \ 'Exception caught: Vim(echo):E121: Undefined variable: i',
-        \ '',
-        \ 'Exception finished: Vim(echo):E121: Undefined variable: i'
-        \ ]
+        \ 'Exception thrown: Vim(echo):E121: Undefined variable: i', '',
+        \ 'Exception caught: Vim(echo):E121: Undefined variable: i', '',
+        \ 'Exception finished: Vim(echo):E121: Undefined variable: i']
   call assert_equal(expected, split(msg, "\n"))
+
+  " Test for verbose messages displayed when an exception is discarded
+  redir => msg
+  try
+    try
+      throw 'abc'
+    finally
+      throw 'xyz'
+    endtry
+  catch
+  endtry
+  redir END
+  let expected = [
+        \ 'Exception thrown: abc', '',
+        \ 'Exception made pending: abc', '',
+        \ 'Exception thrown: xyz', '',
+        \ 'Exception discarded: abc', '',
+        \ 'Exception caught: xyz', '',
+        \ 'Exception finished: xyz']
+  call assert_equal(expected, split(msg, "\n"))
+
+  " Test for messages displayed when :throw is resumed after :finally
+  redir => msg
+  try
+    try
+      throw 'abc'
+    finally
+    endtry
+  catch
+  endtry
+  redir END
+  let expected = [
+        \ 'Exception thrown: abc', '',
+        \ 'Exception made pending: abc', '',
+        \ 'Exception resumed: abc', '',
+        \ 'Exception caught: abc', '',
+        \ 'Exception finished: abc']
+  call assert_equal(expected, split(msg, "\n"))
+
+  " Test for messages displayed when :break is resumed after :finally
+  redir => msg
+  for i in range(1)
+    try
+      break
+    finally
+    endtry
+  endfor
+  redir END
+  let expected = [':break made pending', '', ':break resumed']
+  call assert_equal(expected, split(msg, "\n"))
+
+  " Test for messages displayed when :continue is resumed after :finally
+  redir => msg
+  for i in range(1)
+    try
+      continue
+    finally
+    endtry
+  endfor
+  redir END
+  let expected = [':continue made pending', '', ':continue resumed']
+  call assert_equal(expected, split(msg, "\n"))
+
+  " Test for messages displayed when :return is resumed after :finally
+  func Xtest()
+    try
+      return 'vim'
+    finally
+    endtry
+  endfunc
+  redir => msg
+  call Xtest()
+  redir END
+  let expected = [
+        \ 'calling Xtest()', '',
+        \ ':return vim made pending', '',
+        \ ':return vim resumed', '',
+        \ 'Xtest returning ''vim''', '',
+        \ 'continuing in Test_try_catch_verbose']
+  call assert_equal(expected, split(msg, "\n"))
+  delfunc Xtest
+
+  " Test for messages displayed when :finish is resumed after :finally
+  call writefile(['try', 'finish', 'finally', 'endtry'], 'Xscript')
+  redir => msg
+  source Xscript
+  redir END
+  let expected = [
+        \ ':finish made pending', '',
+        \ ':finish resumed', '',
+        \ 'finished sourcing Xscript',
+        \ 'continuing in Test_try_catch_verbose']
+  call assert_equal(expected, split(msg, "\n")[1:])
+  call delete('Xscript')
+
+  " Test for messages displayed when a pending :continue is discarded by an
+  " exception in a finally handler
+  redir => msg
+  try
+    for i in range(1)
+      try
+        continue
+      finally
+        throw 'abc'
+      endtry
+    endfor
+  catch
+  endtry
+  redir END
+  let expected = [
+        \ ':continue made pending', '',
+        \ 'Exception thrown: abc', '',
+        \ ':continue discarded', '',
+        \ 'Exception caught: abc', '',
+        \ 'Exception finished: abc']
+  call assert_equal(expected, split(msg, "\n"))
+
   set verbose&
 endfunc
 
+" Test for throwing an exception from a BufEnter autocmd                   {{{1
+func Test_BufEnter_exception()
+  augroup bufenter_exception
+    au!
+    autocmd BufEnter Xfile1 throw 'abc'
+  augroup END
+
+  let caught_abc = 0
+  try
+    sp Xfile1
+  catch /^abc/
+    let caught_abc = 1
+  endtry
+  call assert_equal(1, caught_abc)
+  call assert_equal(1, winnr('$'))
+
+  augroup bufenter_exception
+    au!
+  augroup END
+  augroup! bufenter_exception
+  %bwipe!
+
+  " Test for recursively throwing exceptions in autocmds
+  augroup bufenter_exception
+    au!
+    autocmd BufEnter Xfile1 throw 'bufenter'
+    autocmd BufLeave Xfile1 throw 'bufleave'
+  augroup END
+
+  let ex_count = 0
+  try
+    try
+      sp Xfile1
+    catch /^bufenter/
+      let ex_count += 1
+    endtry
+  catch /^bufleave/
+      let ex_count += 10
+  endtry
+  call assert_equal(10, ex_count)
+  call assert_equal(2, winnr('$'))
+
+  augroup bufenter_exception
+    au!
+  augroup END
+  augroup! bufenter_exception
+  %bwipe!
+endfunc
+
 " Test for using throw in a called function with following error    {{{1
 func Test_user_command_throw_in_function_call()
   let lines =<< trim END
-- 
cgit 


From f4274d0f62625683486d3912dcd6e8e45877c6a4 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 09:41:00 +0800
Subject: vim-patch:8.2.3102: test for crash fix does not fail without the fix
 (#20018)

Problem:    Test for crash fix does not fail without the fix.
Solution:   Adjust the test sequence. (closes vim/vim#8506)
https://github.com/vim/vim/commit/3777d6e32b22f0a70b774760c24160079e303bad

Cherry-pick CheckUnix from patch 8.2.1432.
---
 src/nvim/testdir/test_swap.vim | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_swap.vim b/src/nvim/testdir/test_swap.vim
index 5c9e39f1f4..34d1d585ce 100644
--- a/src/nvim/testdir/test_swap.vim
+++ b/src/nvim/testdir/test_swap.vim
@@ -375,24 +375,26 @@ func Test_swap_prompt_splitwin()
   call WaitForAssert({-> assert_match('^1$', term_getline(buf, 20))})
   call StopVimInTerminal(buf)
 
-  " This caused Vim to crash when typing "q".
-  " TODO: it does not actually reproduce the crash.
-  call writefile(['au BufAdd * set virtualedit=all'], 'Xvimrc')
-
-  let buf = RunVimInTerminal('-u Xvimrc Xfile1', {'rows': 20, 'wait_for_ruler': 0})
-  call TermWait(buf)
-  call WaitForAssert({-> assert_match('^\[O\]pen Read-Only, (E)dit anyway, (R)ecover, (Q)uit, (A)bort:', term_getline(buf, 20))})
+  " This caused Vim to crash when typing "q" at the swap file prompt.
+  let buf = RunVimInTerminal('-c "au bufadd * let foo_w = wincol()"', {'rows': 18})
+  call term_sendkeys(buf, ":e Xfile1\<CR>")
+  call WaitForAssert({-> assert_match('More', term_getline(buf, 18))})
+  call term_sendkeys(buf, " ")
+  call WaitForAssert({-> assert_match('^\[O\]pen Read-Only, (E)dit anyway, (R)ecover, (Q)uit, (A)bort:', term_getline(buf, 18))})
   call term_sendkeys(buf, "q")
+  call TermWait(buf)
+  " check that Vim is still running
+  call term_sendkeys(buf, ":echo 'hello'\<CR>")
+  call WaitForAssert({-> assert_match('^hello', term_getline(buf, 18))})
+  call term_sendkeys(buf, ":%bwipe!\<CR>")
+  call StopVimInTerminal(buf)
 
   %bwipe!
   call delete('Xfile1')
-  call delete('Xvimrc')
 endfunc
 
 func Test_swap_symlink()
-  if !has("unix")
-    return
-  endif
+  CheckUnix
 
   call writefile(['text'], 'Xtestfile')
   silent !ln -s -f Xtestfile Xtestlink
-- 
cgit 


From fa747d004a1e91b30066020f2f592e4dc5d94084 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 19:47:10 +0800
Subject: fix(api): nvim_set_hl bail out on invalid group name (#20021)

---
 src/nvim/api/vim.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index b164106cef..a1721d433f 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -86,8 +86,7 @@ Dictionary nvim_get_hl_by_name(String name, Boolean rgb, Error *err)
   int id = syn_name2id(name.data);
 
   if (id == 0) {
-    api_set_error(err, kErrorTypeException, "Invalid highlight name: %s",
-                  name.data);
+    api_set_error(err, kErrorTypeException, "Invalid highlight name: %s", name.data);
     return result;
   }
   result = nvim_get_hl_by_id(id, rgb, err);
@@ -105,8 +104,7 @@ Dictionary nvim_get_hl_by_id(Integer hl_id, Boolean rgb, Error *err)
 {
   Dictionary dic = ARRAY_DICT_INIT;
   if (syn_get_final_id((int)hl_id) == 0) {
-    api_set_error(err, kErrorTypeException,
-                  "Invalid highlight id: %" PRId64, hl_id);
+    api_set_error(err, kErrorTypeException, "Invalid highlight id: %" PRId64, hl_id);
     return dic;
   }
   int attrcode = syn_id2attr((int)hl_id);
@@ -175,6 +173,10 @@ void nvim_set_hl(Integer ns_id, String name, Dict(highlight) *val, Error *err)
   FUNC_API_SINCE(7)
 {
   int hl_id = syn_check_group(name.data, name.size);
+  if (hl_id == 0) {
+    api_set_error(err, kErrorTypeException, "Invalid highlight name: %s", name.data);
+    return;
+  }
   int link_id = -1;
 
   HlAttrs attrs = dict2hlattrs(val, true, &link_id, err);
-- 
cgit 


From fb1edb2f5728d74ae811c6ab32395598cea5609b Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/buffer.c        |   2 +-
 src/nvim/change.c        |  20 ++---
 src/nvim/charset.c       |   4 +-
 src/nvim/cmdexpand.c     |   6 +-
 src/nvim/cursor.c        |   2 +-
 src/nvim/diff.c          |   8 +-
 src/nvim/drawline.c      |   6 +-
 src/nvim/edit.c          |  16 ++--
 src/nvim/eval.c          |   4 +-
 src/nvim/eval/funcs.c    |  12 +--
 src/nvim/eval/userfunc.c |  14 ++--
 src/nvim/eval/vars.c     |   3 +-
 src/nvim/event/socket.c  |   2 +-
 src/nvim/ex_cmds.c       |  36 ++++-----
 src/nvim/ex_cmds2.c      |   6 +-
 src/nvim/ex_docmd.c      |  17 ++--
 src/nvim/ex_getln.c      |  12 +--
 src/nvim/file_search.c   |   4 +-
 src/nvim/fileio.c        |  26 +++---
 src/nvim/fold.c          |  12 +--
 src/nvim/getchar.c       |   4 +-
 src/nvim/hardcopy.c      |   4 +-
 src/nvim/if_cscope.c     |   8 +-
 src/nvim/indent.c        |  14 ++--
 src/nvim/indent_c.c      |  66 +++++++--------
 src/nvim/insexpand.c     |  16 ++--
 src/nvim/macros.h        |   2 +-
 src/nvim/main.c          |   4 +-
 src/nvim/mapping.c       |   4 +-
 src/nvim/mark.c          |   4 +-
 src/nvim/mbyte.c         |  15 ++--
 src/nvim/memline.c       |  68 ++++++++--------
 src/nvim/menu.c          |   2 +-
 src/nvim/message.c       | 204 +++++++++++++++++++++++------------------------
 src/nvim/mouse.c         |   6 +-
 src/nvim/normal.c        |  10 +--
 src/nvim/ops.c           | 203 +++++++++++++++++++++++-----------------------
 src/nvim/os/fs.c         |   4 +-
 src/nvim/os/shell.c      |   8 +-
 src/nvim/path.c          |  13 +--
 src/nvim/plines.c        |  14 ++--
 src/nvim/quickfix.c      |  12 +--
 src/nvim/regexp.c        |   2 +-
 src/nvim/regexp_bt.c     |   4 +-
 src/nvim/regexp_nfa.c    |   2 +-
 src/nvim/runtime.c       |   2 +-
 src/nvim/search.c        |  42 +++++-----
 src/nvim/spell.c         |   4 +-
 src/nvim/spellfile.c     |  12 +--
 src/nvim/syntax.c        |   4 +-
 src/nvim/tag.c           |  18 ++---
 src/nvim/textformat.c    |  10 +--
 src/nvim/textobject.c    |   8 +-
 src/nvim/tui/terminfo.c  |   4 +-
 src/nvim/undo.c          |   6 +-
 src/nvim/usercmd.c       |   2 +-
 src/nvim/window.c        |   2 +-
 57 files changed, 511 insertions(+), 508 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 514be4c56b..8f23102e2e 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -3701,7 +3701,7 @@ static int chk_modeline(linenr_T lnum, int flags)
   int retval = OK;
 
   prev = -1;
-  for (s = (char *)ml_get(lnum); *s != NUL; s++) {
+  for (s = ml_get(lnum); *s != NUL; s++) {
     if (prev == -1 || ascii_isspace(prev)) {
       if ((prev != -1 && STRNCMP(s, "ex:", (size_t)3) == 0)
           || STRNCMP(s, "vi:", (size_t)3) == 0) {
diff --git a/src/nvim/change.c b/src/nvim/change.c
index 85ab92e49b..5bea388f28 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -631,7 +631,7 @@ void ins_char_bytes(char *buf, size_t charlen)
 
   size_t col = (size_t)curwin->w_cursor.col;
   linenr_T lnum = curwin->w_cursor.lnum;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   size_t linelen = STRLEN(oldp) + 1;  // length of old line including NUL
 
   // The lengths default to the values for when not replacing.
@@ -739,7 +739,7 @@ void ins_str(char *s)
   }
 
   colnr_T col = curwin->w_cursor.col;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   int oldlen = (int)STRLEN(oldp);
 
   char *newp = xmalloc((size_t)oldlen + (size_t)newlen + 1);
@@ -797,7 +797,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   linenr_T lnum = curwin->w_cursor.lnum;
   colnr_T col = curwin->w_cursor.col;
   bool fixpos = fixpos_arg;
-  char *oldp = (char *)ml_get(lnum);
+  char *oldp = ml_get(lnum);
   colnr_T oldlen = (colnr_T)STRLEN(oldp);
 
   // Can't do anything when the cursor is on the NUL after the line.
@@ -843,7 +843,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
         && (get_ve_flags() & VE_ONEMORE) == 0) {
       curwin->w_cursor.col--;
       curwin->w_cursor.coladd = 0;
-      curwin->w_cursor.col -= utf_head_off((char_u *)oldp, (char_u *)oldp + curwin->w_cursor.col);
+      curwin->w_cursor.col -= utf_head_off(oldp, oldp + curwin->w_cursor.col);
     }
     count = oldlen - col;
     movelen = 1;
@@ -854,7 +854,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
   bool was_alloced = ml_line_alloced();     // check if oldp was allocated
   char *newp;
   if (was_alloced) {
-    ml_add_deleted_len(curbuf->b_ml.ml_line_ptr, oldlen);
+    ml_add_deleted_len((char *)curbuf->b_ml.ml_line_ptr, oldlen);
     newp = oldp;                            // use same allocated memory
   } else {                                  // need to allocate a new line
     newp = xmalloc((size_t)(oldlen + 1 - count));
@@ -1047,7 +1047,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
     // the line, replacing what was there before and pushing the right
     // stuff onto the replace stack.  -- webb.
     if (curwin->w_cursor.lnum < orig_line_count) {
-      next_line = (char *)vim_strsave(ml_get(curwin->w_cursor.lnum + 1));
+      next_line = xstrdup(ml_get(curwin->w_cursor.lnum + 1));
     } else {
       next_line = xstrdup("");
     }
@@ -1119,7 +1119,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
         // Skip preprocessor directives, unless they are recognised as comments.
         if (lead_len == 0 && ptr[0] == '#') {
           while (ptr[0] == '#' && curwin->w_cursor.lnum > 1) {
-            ptr = (char *)ml_get(--curwin->w_cursor.lnum);
+            ptr = ml_get(--curwin->w_cursor.lnum);
           }
           newindent = get_indent();
         }
@@ -1210,7 +1210,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
             } else {
               was_backslashed = false;
             }
-            ptr = (char *)ml_get(++curwin->w_cursor.lnum);
+            ptr = ml_get(++curwin->w_cursor.lnum);
           }
           if (was_backslashed) {
             newindent = 0;  // Got to end of file
@@ -1465,7 +1465,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
 
           // blank-out any other chars from the old leader.
           while (--p >= leader) {
-            int l = utf_head_off((char_u *)leader, (char_u *)p);
+            int l = utf_head_off(leader, p);
 
             if (l > 1) {
               p -= l;
@@ -1872,7 +1872,7 @@ void truncate_line(int fixpos)
   if (col == 0) {
     newp = xstrdup("");
   } else {
-    newp = (char *)vim_strnsave(ml_get(lnum), (size_t)col);
+    newp = xstrnsave(ml_get(lnum), (size_t)col);
   }
   ml_replace(lnum, newp, false);
 
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 4efd8a4ad1..4604bf7716 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -927,11 +927,11 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
       }
     }
     posptr = ptr + pos->col;
-    posptr -= utf_head_off(line, posptr);
+    posptr -= utf_head_off((char *)line, (char *)posptr);
   }
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, pos->lnum, 0, (char *)line, (char *)line);
 
   // This function is used very often, do some speed optimizations.
   // When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 5c54404aab..1c35f28301 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -675,7 +675,7 @@ int showmatches(expand_T *xp, int wildmenu)
           msg_advance(maxlen + 1);
           msg_puts((const char *)p);
           msg_advance(maxlen + 3);
-          msg_outtrans_long_attr(p + 2, HL_ATTR(HLF_D));
+          msg_outtrans_long_attr((char *)p + 2, HL_ATTR(HLF_D));
           break;
         }
         for (j = maxlen - lastlen; --j >= 0;) {
@@ -2720,7 +2720,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int j = cclp->cmdpos;
       int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
+        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])) {
           found = true;
           break;
@@ -2741,7 +2741,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int j = cclp->cmdpos - 1;
       int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
+        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])
 #ifdef BACKSLASH_IN_FILENAME
             && vim_strchr((const char_u *)" *?[{`$%#", cclp->cmdbuff[j + 1])
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index ed0488cf76..54e5ffff37 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -138,7 +138,7 @@ static int coladvance2(pos_T *pos, bool addspaces, bool finetune, colnr_T wcol_a
     }
 
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+    init_chartabsize_arg(&cts, curwin, pos->lnum, 0, (char *)line, (char *)line);
     while (cts.cts_vcol <= wcol && *cts.cts_ptr != NUL) {
       // Count a tab for what it's worth (if list mode not on)
       csize = win_lbr_chartabsize(&cts, &head);
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 1cfb535fe8..a3046bb7d7 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -2348,8 +2348,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
 
       // Move back to first byte of character in both lines (may
       // have "nn^" in line_org and "n^ in line_new).
-      si_org -= utf_head_off((char_u *)line_org, (char_u *)line_org + si_org);
-      si_new -= utf_head_off((char_u *)line_new, (char_u *)line_new + si_new);
+      si_org -= utf_head_off(line_org, line_org + si_org);
+      si_new -= utf_head_off(line_new, line_new + si_new);
 
       if (*startp > si_org) {
         *startp = si_org;
@@ -2381,8 +2381,8 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
             const char_u *p1 = (char_u *)line_org + ei_org;
             const char_u *p2 = (char_u *)line_new + ei_new;
 
-            p1 -= utf_head_off((char_u *)line_org, p1);
-            p2 -= utf_head_off((char_u *)line_new, p2);
+            p1 -= utf_head_off(line_org, (char *)p1);
+            p2 -= utf_head_off(line_new, (char *)p2);
 
             if (!diff_equal_char(p1, p2, &l)) {
               break;
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index b6c4400c60..66d8a1fb32 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -943,7 +943,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
     chartabsize_T cts;
     int charsize;
 
-    init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, ptr);
+    init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, (char *)line, (char *)ptr);
     while (cts.cts_vcol < v && *cts.cts_ptr != NUL) {
       charsize = win_lbr_chartabsize(&cts, NULL);
       cts.cts_vcol += charsize;
@@ -1803,11 +1803,11 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         // Found last space before word: check for line break.
         if (wp->w_p_lbr && c0 == c && vim_isbreak(c)
             && !vim_isbreak((int)(*ptr))) {
-          int mb_off = utf_head_off(line, ptr - 1);
+          int mb_off = utf_head_off((char *)line, (char *)ptr - 1);
           char_u *p = ptr - (mb_off + 1);
           chartabsize_T cts;
 
-          init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, line, p);
+          init_chartabsize_arg(&cts, wp, lnum, (colnr_T)vcol, (char *)line, (char *)p);
           n_extra = win_lbr_chartabsize(&cts, NULL) - 1;
 
           // We have just drawn the showbreak value, no need to add
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index aee8389900..642162284c 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1545,7 +1545,7 @@ void display_dollar(colnr_T col)
 
   // If on the last byte of a multi-byte move to the first byte.
   char_u *p = get_cursor_line_ptr();
-  curwin->w_cursor.col -= utf_head_off(p, p + col);
+  curwin->w_cursor.col -= utf_head_off((char *)p, (char *)p + col);
   curs_columns(curwin, false);              // Recompute w_wrow and w_wcol
   if (curwin->w_wcol < curwin->w_grid.cols) {
     edit_putchar('$', false);
@@ -1672,7 +1672,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     last_vcol = 0;
     ptr = get_cursor_line_ptr();
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, 0, ptr, ptr);
+    init_chartabsize_arg(&cts, curwin, 0, 0, (char *)ptr, (char *)ptr);
     while (cts.cts_vcol <= (int)curwin->w_virtcol) {
       last_vcol = cts.cts_vcol;
       if (cts.cts_vcol > 0) {
@@ -4642,7 +4642,7 @@ static bool ins_tab(void)
 
     char_u *tab = (char_u *)"\t";
     chartabsize_T cts;
-    init_chartabsize_arg(&cts, curwin, 0, vcol, tab, tab);
+    init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)tab, (char *)tab);
 
     // Use as many TABs as possible.  Beware of 'breakindent', 'showbreak'
     // and 'linebreak' adding extra virtual columns.
@@ -4671,7 +4671,7 @@ static bool ins_tab(void)
     if (change_col >= 0) {
       int repl_off = 0;
       // Skip over the spaces we need.
-      init_chartabsize_arg(&cts, curwin, 0, vcol, ptr, ptr);
+      init_chartabsize_arg(&cts, curwin, 0, vcol, (char *)ptr, (char *)ptr);
       while (cts.cts_vcol < want_vcol && *cts.cts_ptr == ' ') {
         cts.cts_vcol += lbr_chartabsize(&cts);
         cts.cts_ptr++;
@@ -4869,12 +4869,12 @@ int ins_copychar(linenr_T lnum)
   }
 
   // try to advance to the cursor column
-  line = ml_get(lnum);
+  line = (char_u *)ml_get(lnum);
   prev_ptr = line;
   validate_virtcol();
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, curwin, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, curwin, lnum, 0, (char *)line, (char *)line);
   while (cts.cts_vcol < curwin->w_virtcol && *cts.cts_ptr != NUL) {
     prev_ptr = (char_u *)cts.cts_ptr;
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
@@ -4958,7 +4958,7 @@ static void ins_try_si(int c)
        * case where an "if (..\n..) {" statement continues over multiple
        * lines -- webb
        */
-      ptr = ml_get(pos->lnum);
+      ptr = (char_u *)ml_get(pos->lnum);
       i = pos->col;
       if (i > 0) {              // skip blanks before '{'
         while (--i > 0 && ascii_iswhite(ptr[i])) {}
@@ -4983,7 +4983,7 @@ static void ins_try_si(int c)
         old_pos = curwin->w_cursor;
         i = get_indent();
         while (curwin->w_cursor.lnum > 1) {
-          ptr = (char_u *)skipwhite((char *)ml_get(--(curwin->w_cursor.lnum)));
+          ptr = (char_u *)skipwhite(ml_get(--(curwin->w_cursor.lnum)));
 
           // ignore empty lines and lines starting with '#'.
           if (*ptr != '#' && *ptr != NUL) {
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 2dbaa2f8ac..2ade64df3f 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -6369,7 +6369,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
     }
     int len;
     if (charcol) {
-      len = mb_charlen(ml_get(pos.lnum));
+      len = mb_charlen((char_u *)ml_get(pos.lnum));
     } else {
       len = (int)STRLEN(ml_get(pos.lnum));
     }
@@ -8630,7 +8630,7 @@ void invoke_prompt_callback(void)
   if (curbuf->b_prompt_callback.type == kCallbackNone) {
     return;
   }
-  char *text = (char *)ml_get(lnum);
+  char *text = ml_get(lnum);
   char *prompt = (char *)prompt_text();
   if (STRLEN(text) >= STRLEN(prompt)) {
     text += STRLEN(prompt);
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index aa328d50ef..6593a34f4a 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1034,7 +1034,7 @@ static void f_confirm(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   if (!error) {
-    rettv->vval.v_number = do_dialog(type, NULL, (char_u *)message, (char_u *)buttons, def, NULL,
+    rettv->vval.v_number = do_dialog(type, NULL, (char *)message, (char *)buttons, def, NULL,
                                      false);
   }
 }
@@ -3849,7 +3849,7 @@ static void f_hostname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   os_get_hostname(hostname, 256);
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)vim_strsave((char_u *)hostname);
+  rettv->vval.v_string = xstrdup(hostname);
 }
 
 /// iconv() function
@@ -5385,7 +5385,7 @@ static void f_nextnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
       lnum = 0;
       break;
     }
-    if (*skipwhite((char *)ml_get(lnum)) != NUL) {
+    if (*skipwhite(ml_get(lnum)) != NUL) {
       break;
     }
   }
@@ -5473,7 +5473,7 @@ static void f_prevnonblank(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
   if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count) {
     lnum = 0;
   } else {
-    while (lnum >= 1 && *skipwhite((char *)ml_get(lnum)) == NUL) {
+    while (lnum >= 1 && *skipwhite(ml_get(lnum)) == NUL) {
       lnum--;
     }
   }
@@ -7810,7 +7810,7 @@ free_lstval:
     if (strval == NULL) {
       return;
     }
-    write_reg_contents_ex(regname, (const char_u *)strval, (ssize_t)STRLEN(strval),
+    write_reg_contents_ex(regname, strval, (ssize_t)STRLEN(strval),
                           append, yank_type, (colnr_T)block_len);
   }
   if (pointreg != 0) {
@@ -9639,7 +9639,7 @@ static void f_win_gettype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   if (argvars[0].v_type != VAR_UNKNOWN) {
     wp = find_win_by_nr_or_id(&argvars[0]);
     if (wp == NULL) {
-      rettv->vval.v_string = (char *)vim_strsave((char_u *)"unknown");
+      rettv->vval.v_string = xstrdup("unknown");
       return;
     }
   }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 4be922a055..21bd662db5 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -378,7 +378,7 @@ char_u *deref_func_name(const char *name, int *lenp, partial_T **const partialp,
       *lenp = 0;
       return (char_u *)"";
     }
-    *lenp = (int)STRLEN(v->di_tv.vval.v_string);
+    *lenp = (int)strlen(v->di_tv.vval.v_string);
     return (char_u *)v->di_tv.vval.v_string;
   }
 
@@ -970,11 +970,11 @@ void call_user_func(ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rett
       snprintf((char *)numbuf, sizeof(numbuf), "%d", ai + 1);
       name = (char *)numbuf;
     }
-    if (fixvar_idx < FIXVAR_CNT && STRLEN(name) <= VAR_SHORT_LEN) {
+    if (fixvar_idx < FIXVAR_CNT && strlen(name) <= VAR_SHORT_LEN) {
       v = (dictitem_T *)&fc->fixvar[fixvar_idx++];
       v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX;
     } else {
-      v = xmalloc(sizeof(dictitem_T) + STRLEN(name));
+      v = xmalloc(sizeof(dictitem_T) + strlen(name));
       v->di_flags = DI_FLAGS_RO | DI_FLAGS_FIX | DI_FLAGS_ALLOC;
     }
     STRCPY(v->di_key, name);
@@ -1455,7 +1455,7 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
   rettv->v_type = VAR_UNKNOWN;
 
   if (len <= 0) {
-    len = (int)STRLEN(funcname);
+    len = (int)strlen(funcname);
   }
   if (partial != NULL) {
     fp = partial->pt_func;
@@ -2054,7 +2054,7 @@ void ex_function(exarg_T *eap)
               msg_putchar(' ');
             }
           }
-          msg_prt_line((char_u *)FUNCLINE(fp, j), false);
+          msg_prt_line(FUNCLINE(fp, j), false);
           ui_flush();                  // show a line at a time
           os_breakcheck();
         }
@@ -2270,8 +2270,8 @@ void ex_function(exarg_T *eap)
         } else if (line_arg != NULL && *skipwhite((char *)line_arg) != NUL) {
           nextcmd = line_arg;
         } else if (*p != NUL && *p != '"' && p_verbose > 0) {
-          give_warning2((char_u *)_("W22: Text found after :endfunction: %s"),
-                        p, true);
+          give_warning2(_("W22: Text found after :endfunction: %s"),
+                        (char *)p, true);
         }
         if (nextcmd != NULL) {
           // Another command follows. If the line came from "eap" we
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index 75410d40d8..dbbb03b1b8 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -710,8 +710,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg,
-                           (const char_u *)p, (ssize_t)STRLEN(p), false);
+        write_reg_contents(*arg == '@' ? '"' : *arg, p, (ssize_t)STRLEN(p), false);
         arg_end = arg + 1;
       }
       xfree(ptofree);
diff --git a/src/nvim/event/socket.c b/src/nvim/event/socket.c
index 9496a568b9..9ca3dcc276 100644
--- a/src/nvim/event/socket.c
+++ b/src/nvim/event/socket.c
@@ -125,7 +125,7 @@ int socket_watcher_start(SocketWatcher *watcher, int backlog, socket_cb cb)
       // Libuv converts ENOENT to EACCES for Windows compatibility, but if
       // the parent directory does not exist, ENOENT would be more accurate.
       *path_tail(watcher->addr) = NUL;
-      if (!os_path_exists((char_u *)watcher->addr)) {
+      if (!os_path_exists(watcher->addr)) {
         result = UV_ENOENT;
       }
     }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index e672b80d69..17d45f207e 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -557,7 +557,7 @@ void ex_sort(exarg_T *eap)
   // matching and number conversion only has to be done once per line.
   // Also get the longest line length for allocating "sortbuf".
   for (lnum = eap->line1; lnum <= eap->line2; lnum++) {
-    s = (char *)ml_get(lnum);
+    s = ml_get(lnum);
     len = (int)STRLEN(s);
     if (maxlen < len) {
       maxlen = len;
@@ -658,7 +658,7 @@ void ex_sort(exarg_T *eap)
       change_occurred = true;
     }
 
-    s = (char *)ml_get(get_lnum);
+    s = ml_get(get_lnum);
     size_t bytelen = STRLEN(s) + 1;  // include EOL in bytelen
     old_count += (bcount_t)bytelen;
     if (!unique || i == 0 || string_compare(s, sortbuf1) != 0) {
@@ -760,7 +760,7 @@ void ex_retab(exarg_T *eap)
     new_ts_str = xstrnsave(new_ts_str, (size_t)(eap->arg - new_ts_str));
   }
   for (lnum = eap->line1; !got_int && lnum <= eap->line2; lnum++) {
-    ptr = (char *)ml_get(lnum);
+    ptr = ml_get(lnum);
     col = 0;
     vcol = 0;
     did_undo = false;
@@ -941,7 +941,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     return FAIL;
   }
   for (extra = 0, l = line1; l <= line2; l++) {
-    str = (char *)vim_strsave(ml_get(l + extra));
+    str = xstrdup(ml_get(l + extra));
     ml_append(dest + l - line1, str, (colnr_T)0, false);
     xfree(str);
     if (dest < line1) {
@@ -1088,7 +1088,7 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
   while (line1 <= line2) {
     // need to use vim_strsave() because the line will be unlocked within
     // ml_append()
-    p = (char *)vim_strsave(ml_get(line1));
+    p = xstrdup(ml_get(line1));
     ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, false);
     xfree(p);
 
@@ -1710,7 +1710,7 @@ void print_line(linenr_T lnum, int use_number, int list)
   int save_silent = silent_mode;
 
   // apply :filter /pat/
-  if (message_filtered((char *)ml_get(lnum))) {
+  if (message_filtered(ml_get(lnum))) {
     return;
   }
 
@@ -1897,7 +1897,7 @@ int do_write(exarg_T *eap)
         && !p_wa) {
       if (p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) {
         if (vim_dialog_yesno(VIM_QUESTION, NULL,
-                             (char_u *)_("Write partial file?"), 2) != VIM_YES) {
+                             _("Write partial file?"), 2) != VIM_YES) {
           goto theend;
         }
         eap->forceit = true;
@@ -2007,7 +2007,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
                    && vim_strchr(p_cpo, CPO_OVERNEW) == NULL)
                || (buf->b_flags & BF_READERR))))
       && !p_wa
-      && os_path_exists((char_u *)ffname)) {
+      && os_path_exists(ffname)) {
     if (!eap->forceit && !eap->append) {
 #ifdef UNIX
       // It is possible to open a directory on Unix.
@@ -2020,7 +2020,7 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
         char buff[DIALOG_MSG_SIZE];
 
         dialog_msg((char *)buff, _("Overwrite existing file \"%s\"?"), fname);
-        if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) != VIM_YES) {
+        if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) != VIM_YES) {
           return FAIL;
         }
         eap->forceit = true;
@@ -2051,14 +2051,14 @@ int check_overwrite(exarg_T *eap, buf_T *buf, char *fname, char *ffname, int oth
       }
       swapname = (char *)makeswapname((char_u *)fname, (char_u *)ffname, curbuf, (char_u *)dir);
       xfree(dir);
-      if (os_path_exists((char_u *)swapname)) {
+      if (os_path_exists(swapname)) {
         if (p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) {
           char buff[DIALOG_MSG_SIZE];
 
           dialog_msg((char *)buff,
                      _("Swap file \"%s\" exists, overwrite anyway?"),
                      swapname);
-          if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2)
+          if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2)
               != VIM_YES) {
             xfree(swapname);
             return FAIL;
@@ -2171,7 +2171,7 @@ static int check_readonly(int *forceit, buf_T *buf)
   // Handle a file being readonly when the 'readonly' option is set or when
   // the file exists and permissions are read-only.
   if (!*forceit && (buf->b_p_ro
-                    || (os_path_exists((char_u *)buf->b_ffname)
+                    || (os_path_exists(buf->b_ffname)
                         && !os_file_is_writable(buf->b_ffname)))) {
     if ((p_confirm || (cmdmod.cmod_flags & CMOD_CONFIRM)) && buf->b_fname != NULL) {
       char buff[DIALOG_MSG_SIZE];
@@ -2187,7 +2187,7 @@ static int check_readonly(int *forceit, buf_T *buf)
                    buf->b_fname);
       }
 
-      if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 2) == VIM_YES) {
+      if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 2) == VIM_YES) {
         // Set forceit, to force the writing of a readonly file
         *forceit = true;
         return false;
@@ -2678,7 +2678,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     }
     buf = curbuf;
     if (buf->b_fname != NULL) {
-      new_name = (char *)vim_strsave((char_u *)buf->b_fname);
+      new_name = xstrdup(buf->b_fname);
     } else {
       new_name = NULL;
     }
@@ -3803,7 +3803,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           break;
         }
         if (sub_firstline == NULL) {
-          sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum));
+          sub_firstline = xstrdup(ml_get(sub_firstlnum));
         }
 
         // Save the line number of the last change for the final
@@ -3944,7 +3944,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
                 // really update the line, it would change
                 // what matches.  Temporarily replace the line
                 // and change it back afterwards.
-                orig_line = (char *)vim_strsave(ml_get(lnum));
+                orig_line = xstrdup(ml_get(lnum));
                 char *new_line = concat_str(new_start, sub_firstline + copycol);
 
                 // Position the cursor relative to the end of the line, the
@@ -4072,7 +4072,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
     if (nmatch > 1) { \
       sub_firstlnum += (linenr_T)nmatch - 1; \
       xfree(sub_firstline); \
-      sub_firstline = (char *)vim_strsave(ml_get(sub_firstlnum)); \
+      sub_firstline = xstrdup(ml_get(sub_firstlnum)); \
       /* When going beyond the last line, stop substituting. */ \
       if (sub_firstlnum <= line2) { \
         do_again = true; \
@@ -4148,7 +4148,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
           if (nmatch == 1) {
             p1 = sub_firstline;
           } else {
-            p1 = (char *)ml_get(sub_firstlnum + (linenr_T)nmatch - 1);
+            p1 = ml_get(sub_firstlnum + (linenr_T)nmatch - 1);
             nmatch_tl += nmatch - 1;
           }
           size_t copy_len = (size_t)(regmatch.startpos[0].col - copycol);
diff --git a/src/nvim/ex_cmds2.c b/src/nvim/ex_cmds2.c
index 11280eecbb..e551cbee0b 100644
--- a/src/nvim/ex_cmds2.c
+++ b/src/nvim/ex_cmds2.c
@@ -200,9 +200,9 @@ void dialog_changed(buf_T *buf, bool checkall)
 
   dialog_msg((char *)buff, _("Save changes to \"%s\"?"), buf->b_fname);
   if (checkall) {
-    ret = vim_dialog_yesnoallcancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+    ret = vim_dialog_yesnoallcancel(VIM_QUESTION, NULL, buff, 1);
   } else {
-    ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+    ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, buff, 1);
   }
 
   if (ret == VIM_YES) {
@@ -252,7 +252,7 @@ bool dialog_close_terminal(buf_T *buf)
   dialog_msg(buff, _("Close \"%s\"?"),
              (buf->b_fname != NULL) ? buf->b_fname : "?");
 
-  int ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, (char_u *)buff, 1);
+  int ret = vim_dialog_yesnocancel(VIM_QUESTION, NULL, buff, 1);
 
   return ret == VIM_YES;
 }
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index bf518f3849..8f72ba0e23 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -535,7 +535,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
       if (flags & DOCMD_KEEPLINE) {
         xfree(repeat_cmdline);
         if (count == 0) {
-          repeat_cmdline = (char *)vim_strsave((char_u *)next_cmdline);
+          repeat_cmdline = xstrdup(next_cmdline);
         } else {
           repeat_cmdline = NULL;
         }
@@ -2826,7 +2826,7 @@ static void append_command(char *cmd)
   if (len > IOSIZE - 100) {
     // Not enough space, truncate and put in "...".
     d = (char *)IObuff + IOSIZE - 100;
-    d -= utf_head_off(IObuff, (const char_u *)d);
+    d -= utf_head_off((char *)IObuff, d);
     STRCPY(d, "...");
   }
   STRCAT(IObuff, ": ");
@@ -3081,10 +3081,9 @@ void f_fullcommand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     return;
   }
 
-  rettv->vval.v_string = (char *)vim_strsave(IS_USER_CMDIDX(ea.cmdidx)
-                                             ? (char_u *)get_user_command_name(ea.useridx,
-                                                                               ea.cmdidx)
-                                             : (char_u *)cmdnames[ea.cmdidx].cmd_name);
+  rettv->vval.v_string = xstrdup(IS_USER_CMDIDX(ea.cmdidx)
+                                 ? get_user_command_name(ea.useridx, ea.cmdidx)
+                                 : cmdnames[ea.cmdidx].cmd_name);
 }
 
 cmdidx_T excmd_get_cmdidx(const char *cmd, size_t len)
@@ -4344,7 +4343,7 @@ static int check_more(int message, bool forceit)
         vim_snprintf((char *)buff, DIALOG_MSG_SIZE,
                      NGETTEXT("%d more file to edit.  Quit anyway?",
                               "%d more files to edit.  Quit anyway?", (unsigned long)n), n);
-        if (vim_dialog_yesno(VIM_QUESTION, NULL, (char_u *)buff, 1) == VIM_YES) {
+        if (vim_dialog_yesno(VIM_QUESTION, NULL, buff, 1) == VIM_YES) {
           return OK;
         }
         return FAIL;
@@ -6007,7 +6006,7 @@ static void ex_redir(exarg_T *eap)
           // Make register empty when not using @A-@Z and the
           // command is valid.
           if (*arg == NUL && !isupper(redir_reg)) {
-            write_reg_contents(redir_reg, (char_u *)"", 0, false);
+            write_reg_contents(redir_reg, "", 0, false);
           }
         }
       }
@@ -6162,7 +6161,7 @@ FILE *open_exfile(char_u *fname, int forceit, char *mode)
     return NULL;
   }
 #endif
-  if (!forceit && *mode != 'a' && os_path_exists(fname)) {
+  if (!forceit && *mode != 'a' && os_path_exists((char *)fname)) {
     semsg(_("E189: \"%s\" exists (add ! to override)"), fname);
     return NULL;
   }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 0998bdd867..e8af99805d 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1704,8 +1704,8 @@ static int command_line_handle_key(CommandLineState *s)
     do {
       ccline.cmdpos--;
       // Move to first byte of possibly multibyte char.
-      ccline.cmdpos -= utf_head_off(ccline.cmdbuff,
-                                    ccline.cmdbuff + ccline.cmdpos);
+      ccline.cmdpos -= utf_head_off((char *)ccline.cmdbuff,
+                                    (char *)ccline.cmdbuff + ccline.cmdpos);
       ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
     } while (ccline.cmdpos > 0
              && (s->c == K_S_LEFT || s->c == K_C_LEFT
@@ -3208,7 +3208,7 @@ draw_cmdline_no_arabicshape:
           continue;
         }
         const int chunk_start = MAX(chunk.start, start);
-        msg_outtrans_len_attr(ccline.cmdbuff + chunk_start,
+        msg_outtrans_len_attr((char *)ccline.cmdbuff + chunk_start,
                               chunk.end - chunk_start,
                               chunk.attr);
       }
@@ -3442,14 +3442,14 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     i = 0;
     c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
     while (ccline.cmdpos > 0 && utf_iscomposing(c)) {
-      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
       ccline.cmdpos -= i;
       len += i;
       c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
     }
     if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c)) {
       // Check the previous character for Arabic combining pair.
-      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
       if (arabic_combine(utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos - i), c)) {
         ccline.cmdpos -= i;
         len += i;
@@ -3581,7 +3581,7 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
 
       // Locate start of last word in the cmd buffer.
       for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff;) {
-        len = utf_head_off(ccline.cmdbuff, w - 1) + 1;
+        len = utf_head_off((char *)ccline.cmdbuff, (char *)w - 1) + 1;
         if (!vim_iswordc(utf_ptr2char((char *)w - len))) {
           break;
         }
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index bbc6e53aa8..e87e0853f3 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -825,7 +825,7 @@ char_u *vim_findfile(void *search_ctx_arg)
             for (;;) {
               // if file exists and we didn't already find it
               if ((path_with_url((char *)file_path)
-                   || (os_path_exists(file_path)
+                   || (os_path_exists((char *)file_path)
                        && (search_ctx->ffsc_find_what == FINDFILE_BOTH
                            || ((search_ctx->ffsc_find_what == FINDFILE_DIR)
                                == os_isdir((char *)file_path)))))
@@ -1473,7 +1473,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
         buf = (char *)suffixes;
         for (;;) {
           if (
-              (os_path_exists((char_u *)NameBuff)
+              (os_path_exists(NameBuff)
                && (find_what == FINDFILE_BOTH
                    || ((find_what == FINDFILE_DIR)
                        == os_isdir(NameBuff))))) {
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index d67cd36a85..517424f4c1 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -143,7 +143,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   msg_scroll = msg_scroll_save;
   msg_scrolled_ign = true;
   // may truncate the message to avoid a hit-return prompt
-  msg_outtrans_attr((char *)msg_may_trunc(false, IObuff), attr);
+  msg_outtrans_attr(msg_may_trunc(false, (char *)IObuff), attr);
   msg_clr_eos();
   ui_flush();
   msg_scrolled_ign = false;
@@ -1011,7 +1011,7 @@ retry:
 
             tlen = 0;
             for (;;) {
-              p = ml_get(read_buf_lnum) + read_buf_col;
+              p = (char_u *)ml_get(read_buf_lnum) + read_buf_col;
               n = (int)STRLEN(p);
               if ((int)tlen + n + 1 > size) {
                 // Filled up to "size", append partial line.
@@ -1371,7 +1371,7 @@ retry:
             if (*--p < 0x80) {
               u8c = *p;
             } else {
-              len = utf_head_off((char_u *)ptr, p);
+              len = utf_head_off(ptr, (char *)p);
               p -= len;
               u8c = (unsigned)utf_ptr2char((char *)p);
               if (len == 0) {
@@ -2970,13 +2970,13 @@ nobackup:
            * delete an existing one, try to use another name.
            * Change one character, just before the extension.
            */
-          if (!p_bk && os_path_exists((char_u *)backup)) {
+          if (!p_bk && os_path_exists(backup)) {
             p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
             if (p < backup) {           // empty file name ???
               p = backup;
             }
             *p = 'z';
-            while (*p > 'a' && os_path_exists((char_u *)backup)) {
+            while (*p > 'a' && os_path_exists(backup)) {
               (*p)--;
             }
             // They all exist??? Must be something wrong!
@@ -3211,11 +3211,11 @@ restore_backup:
               // This may not work if the vim_rename() fails.
               // In that case we leave the copy around.
               // If file does not exist, put the copy in its place
-              if (!os_path_exists((char_u *)fname)) {
+              if (!os_path_exists(fname)) {
                 vim_rename((char_u *)backup, (char_u *)fname);
               }
               // if original file does exist throw away the copy
-              if (os_path_exists((char_u *)fname)) {
+              if (os_path_exists(fname)) {
                 os_remove(backup);
               }
             } else {
@@ -3225,7 +3225,7 @@ restore_backup:
           }
 
           // if original file no longer exists give an extra warning
-          if (!newfile && !os_path_exists((char_u *)fname)) {
+          if (!newfile && !os_path_exists(fname)) {
             end = 0;
           }
         }
@@ -3588,7 +3588,7 @@ restore_backup:
        */
       if (org == NULL) {
         emsg(_("E205: Patchmode: can't save original file"));
-      } else if (!os_path_exists((char_u *)org)) {
+      } else if (!os_path_exists(org)) {
         vim_rename((char_u *)backup, (char_u *)org);
         XFREE_CLEAR(backup);                   // don't delete the file
 #ifdef UNIX
@@ -4677,7 +4677,7 @@ int vim_rename(const char_u *from, const char_u *to)
       char *tail = path_tail((char *)tempname);
       snprintf(tail, (size_t)((MAXPATHL + 1) - (tail - (char *)tempname - 1)), "%d", n);
 
-      if (!os_path_exists(tempname)) {
+      if (!os_path_exists((char *)tempname)) {
         if (os_rename(from, tempname) == OK) {
           if (os_rename(tempname, to) == OK) {
             return 0;
@@ -5028,7 +5028,7 @@ int buf_check_timestamp(buf_T *buf)
       }
     }
   } else if ((buf->b_flags & BF_NEW) && !(buf->b_flags & BF_NEW_W)
-             && os_path_exists((char_u *)buf->b_ffname)) {
+             && os_path_exists(buf->b_ffname)) {
     retval = 1;
     mesg = _("W13: Warning: File \"%s\" has been created after editing started");
     buf->b_flags |= BF_NEW_W;
@@ -5051,8 +5051,8 @@ int buf_check_timestamp(buf_T *buf)
         xstrlcat(tbuf, "\n", tbuf_len - 1);
         xstrlcat(tbuf, mesg2, tbuf_len - 1);
       }
-      switch (do_dialog(VIM_WARNING, (char_u *)_("Warning"), (char_u *)tbuf,
-                        (char_u *)_("&OK\n&Load File\nLoad File &and Options"),
+      switch (do_dialog(VIM_WARNING, _("Warning"), tbuf,
+                        _("&OK\n&Load File\nLoad File &and Options"),
                         1, NULL, true)) {
       case 2:
         reload = RELOAD_NORMAL;
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index b4ddb3ec08..d8c864df5b 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -995,7 +995,7 @@ void foldAdjustVisual(void)
     start->col = 0;
   }
   if (hasFolding(end->lnum, NULL, &end->lnum)) {
-    ptr = ml_get(end->lnum);
+    ptr = (char_u *)ml_get(end->lnum);
     end->col = (colnr_T)STRLEN(ptr);
     if (end->col > 0 && *p_sel == 'o') {
       end->col--;
@@ -1588,7 +1588,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t ma
 
   if (u_save(lnum - 1, lnum + 1) == OK) {
     // Check if the line ends with an unclosed comment
-    skip_comment(line, false, false, &line_is_comment);
+    skip_comment((char *)line, false, false, &line_is_comment);
     newline = xmalloc(line_len + markerlen + STRLEN(cms) + 1);
     STRCPY(newline, line);
     // Append the marker to the end of the line
@@ -1601,7 +1601,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t ma
       STRCPY(newline + line_len + (p - cms) + markerlen, p + 2);
       added = markerlen + STRLEN(cms) - 2;
     }
-    ml_replace_buf(buf, lnum, newline, false);
+    ml_replace_buf(buf, lnum, (char *)newline, false);
     if (added) {
       extmark_splice_cols(buf, (int)lnum - 1, (int)line_len,
                           0, (int)added, kExtmarkUndo);
@@ -1666,7 +1666,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
       assert(p >= line);
       memcpy(newline, line, (size_t)(p - line));
       STRCPY(newline + (p - line), p + len);
-      ml_replace_buf(buf, lnum, newline, false);
+      ml_replace_buf(buf, lnum, (char *)newline, false);
       extmark_splice_cols(buf, (int)lnum - 1, (int)(p - line),
                           (int)len, 0, kExtmarkUndo);
     }
@@ -3251,12 +3251,12 @@ void f_foldtext(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
 
     // Find interesting text in this line.
-    char_u *s = (char_u *)skipwhite((char *)ml_get(lnum));
+    char_u *s = (char_u *)skipwhite(ml_get(lnum));
     // skip C comment-start
     if (s[0] == '/' && (s[1] == '*' || s[1] == '/')) {
       s = (char_u *)skipwhite((char *)s + 2);
       if (*skipwhite((char *)s) == NUL && lnum + 1 < foldend) {
-        s = (char_u *)skipwhite((char *)ml_get(lnum + 1));
+        s = (char_u *)skipwhite(ml_get(lnum + 1));
         if (*s == '*') {
           s = (char_u *)skipwhite((char *)s + 1);
         }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 0a9457ef35..4d7339f3b5 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -2569,7 +2569,7 @@ static int vgetorpeek(bool advance)
                 ptr = get_cursor_line_ptr();
                 chartabsize_T cts;
                 init_chartabsize_arg(&cts, curwin,
-                                     curwin->w_cursor.lnum, 0, ptr, ptr);
+                                     curwin->w_cursor.lnum, 0, (char *)ptr, (char *)ptr);
                 while ((char_u *)cts.cts_ptr < ptr + curwin->w_cursor.col) {
                   if (!ascii_iswhite(*cts.cts_ptr)) {
                     curwin->w_wcol = cts.cts_vcol;
@@ -2597,7 +2597,7 @@ static int vgetorpeek(bool advance)
               // Correct when the cursor is on the right halve
               // of a double-wide character.
               ptr = get_cursor_line_ptr();
-              col -= utf_head_off(ptr, ptr + col);
+              col -= utf_head_off((char *)ptr, (char *)ptr + col);
               if (utf_ptr2cells((char *)ptr + col) > 1) {
                 curwin->w_wcol--;
               }
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 602fa8b71d..d7f5730943 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -879,7 +879,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
   }
 
   mch_print_start_line(false, page_line);
-  line = ml_get(ppos->file_line);
+  line = (char_u *)ml_get(ppos->file_line);
 
   /*
    * Loop over the columns until the end of the file line or right margin.
@@ -897,7 +897,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
         id = 0;
       }
       // Get the line again, a multi-line regexp may invalidate it.
-      line = ml_get(ppos->file_line);
+      line = (char_u *)ml_get(ppos->file_line);
 
       if (id != current_syn_id) {
         current_syn_id = id;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 9413abb2e1..e54bffb587 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -446,7 +446,7 @@ staterr:
   if (arg2 != NULL) {
     ppath = xmalloc(MAXPATHL + 1);
     expand_env(arg2, ppath, MAXPATHL);
-    if (!os_path_exists((char_u *)ppath)) {
+    if (!os_path_exists(ppath)) {
       goto staterr;
     }
   }
@@ -1651,7 +1651,7 @@ static void cs_print_tags_priv(char **matches, char **cntxts,
     }
     (void)snprintf(buf, bufsize, csfmt_str, i + 1, lno);
     msg_puts_attr(buf, HL_ATTR(HLF_CM));
-    msg_outtrans_long_attr((char_u *)cs_pathcomponents(fname), HL_ATTR(HLF_CM));
+    msg_outtrans_long_attr(cs_pathcomponents(fname), HL_ATTR(HLF_CM));
 
     // compute the required space for the context
     char *context = cntxts[i] ? cntxts[i] : globalcntx;
@@ -1673,11 +1673,11 @@ static void cs_print_tags_priv(char **matches, char **cntxts,
       msg_putchar('\n');
     }
     msg_advance(12);
-    msg_outtrans_long_attr((char_u *)buf, 0);
+    msg_outtrans_long_attr(buf, 0);
     msg_putchar('\n');
     if (extra != NULL) {
       msg_advance(13);
-      msg_outtrans_long_attr((char_u *)extra, 0);
+      msg_outtrans_long_attr(extra, 0);
     }
 
     // restore matches[i]
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index 792f4d93c4..da4bcf6934 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -352,7 +352,7 @@ int get_indent(void)
 // Count the size (in window cells) of the indent in line "lnum".
 int get_indent_lnum(linenr_T lnum)
 {
-  return get_indent_str_vtab((char *)ml_get(lnum),
+  return get_indent_str_vtab(ml_get(lnum),
                              curbuf->b_p_ts,
                              curbuf->b_p_vts_array,
                              false);
@@ -710,7 +710,7 @@ int get_number_indent(linenr_T lnum)
 
   // In format_lines() (i.e. not insert mode), fo+=q is needed too...
   if ((State & MODE_INSERT) || has_format_option(FO_Q_COMS)) {
-    lead_len = get_leader_len((char *)ml_get(lnum), NULL, false, true);
+    lead_len = get_leader_len(ml_get(lnum), NULL, false, true);
   }
   regmatch.regprog = vim_regcomp(curbuf->b_p_flp, RE_MAGIC);
 
@@ -719,9 +719,9 @@ int get_number_indent(linenr_T lnum)
 
     // vim_regexec() expects a pointer to a line.  This lets us
     // start matching for the flp beyond any comment leader...
-    if (vim_regexec(&regmatch, (char *)ml_get(lnum) + lead_len, (colnr_T)0)) {
+    if (vim_regexec(&regmatch, ml_get(lnum) + lead_len, (colnr_T)0)) {
       pos.lnum = lnum;
-      pos.col = (colnr_T)(*regmatch.endp - ml_get(lnum));
+      pos.col = (colnr_T)(*regmatch.endp - (char_u *)ml_get(lnum));
       pos.coladd = 0;
     }
     vim_regfree(regmatch.regprog);
@@ -1036,7 +1036,7 @@ int get_lisp_indent(void)
       } else {
         char_u *line = that;
         chartabsize_T cts;
-        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, line, line);
+        init_chartabsize_arg(&cts, curwin, pos->lnum, 0, (char *)line, (char *)line);
         while (*cts.cts_ptr != NUL && col > 0) {
           cts.cts_vcol += lbr_chartabsize_adv(&cts);
           col--;
@@ -1060,7 +1060,7 @@ int get_lisp_indent(void)
           firsttry = amount;
 
           init_chartabsize_arg(&cts, curwin, (colnr_T)(that - line),
-                               amount, line, that);
+                               amount, (char *)line, (char *)that);
           while (ascii_iswhite(*cts.cts_ptr)) {
             cts.cts_vcol += lbr_chartabsize(&cts);
             cts.cts_ptr++;
@@ -1081,7 +1081,7 @@ int get_lisp_indent(void)
             quotecount = 0;
 
             init_chartabsize_arg(&cts, curwin,
-                                 (colnr_T)(that - line), amount, line, that);
+                                 (colnr_T)(that - line), amount, (char *)line, (char *)that);
             if (vi_lisp || ((*that != '"') && (*that != '\'')
                             && (*that != '#') && ((*that < '0') || (*that > '9')))) {
               while (*cts.cts_ptr
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 166695ef5b..ccee4dd48a 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -52,7 +52,7 @@ pos_T *find_start_comment(int ind_maxcomment)  // XXX
      * Check if the comment start we found is inside a string.
      * If it is then restrict the search to below this line and try again.
      */
-    if (!is_pos_in_string(ml_get(pos->lnum), pos->col)) {
+    if (!is_pos_in_string((char_u *)ml_get(pos->lnum), pos->col)) {
       break;
     }
     cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
@@ -115,7 +115,7 @@ static pos_T *find_start_rawstring(int ind_maxcomment)  // XXX
 
     // Check if the raw string start we found is inside a string.
     // If it is then restrict the search to below this line and try again.
-    if (!is_pos_in_string(ml_get(pos->lnum), pos->col)) {
+    if (!is_pos_in_string((char_u *)ml_get(pos->lnum), pos->col)) {
       break;
     }
     cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
@@ -291,7 +291,7 @@ static pos_T *find_line_comment(void)  // XXX
 
   pos = curwin->w_cursor;
   while (--pos.lnum > 0) {
-    line = ml_get(pos.lnum);
+    line = (char_u *)ml_get(pos.lnum);
     p = (char_u *)skipwhite((char *)line);
     if (cin_islinecomment(p)) {
       pos.col = (int)(p - line);
@@ -616,7 +616,7 @@ static int get_indent_nolabel(linenr_T lnum)  // XXX
   colnr_T col;
   const char_u *p;
 
-  l = ml_get(lnum);
+  l = (char_u *)ml_get(lnum);
   p = after_label(l);
   if (p == NULL) {
     return 0;
@@ -724,13 +724,14 @@ static int cin_get_equal_amount(linenr_T lnum)
   pos_T fp;
 
   if (lnum > 1) {
-    line = ml_get(lnum - 1);
+    line = (char_u *)ml_get(lnum - 1);
     if (*line != NUL && line[STRLEN(line) - 1] == '\\') {
       return -1;
     }
   }
 
-  line = s = ml_get(lnum);
+  s = (char_u *)ml_get(lnum);
+  line = s;
   while (*s != NUL && vim_strchr("=;{}\"'", *s) == NULL) {
     if (cin_iscomment(s)) {     // ignore comments
       s = cin_skipcomment(s);
@@ -792,14 +793,14 @@ static int cin_ispreproc_cont(const char_u **pp, linenr_T *lnump, int *amount)
     if (lnum == 1) {
       break;
     }
-    line = ml_get(--lnum);
+    line = (char_u *)ml_get(--lnum);
     if (*line == NUL || line[STRLEN(line) - 1] != '\\') {
       break;
     }
   }
 
   if (lnum != *lnump) {
-    *pp = ml_get(*lnump);
+    *pp = (char_u *)ml_get(*lnump);
   }
   if (retval) {
     *amount = candidate_amount;
@@ -895,7 +896,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
   int just_started = true;
 
   if (sp == NULL) {
-    s = ml_get(lnum);
+    s = (char_u *)ml_get(lnum);
   } else {
     s = *sp;
   }
@@ -908,7 +909,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
       curwin->w_cursor.lnum = save_lnum;
       return false;
     }
-    s = ml_get(lnum);
+    s = (char_u *)ml_get(lnum);
   }
 
   curwin->w_cursor.lnum = save_lnum;
@@ -947,7 +948,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
       //       #if defined(x) && {backslash}
       //           defined(y)
       lnum = first_lnum - 1;
-      s = ml_get(lnum);
+      s = (char_u *)ml_get(lnum);
       if (*s == NUL || s[STRLEN(s) - 1] != '\\') {
         retval = true;
       }
@@ -964,7 +965,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
         if (lnum >= curbuf->b_ml.ml_line_count) {
           break;
         }
-        s = ml_get(++lnum);
+        s = (char_u *)ml_get(++lnum);
         if (!cin_ispreproc(s)) {
           break;
         }
@@ -989,7 +990,7 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
 
 done:
   if (lnum != first_lnum && sp != NULL) {
-    *sp = ml_get(first_lnum);
+    *sp = (char_u *)ml_get(first_lnum);
   }
 
   return retval;
@@ -1121,7 +1122,7 @@ static int cin_iswhileofdo_end(int terminated)
         curwin->w_cursor.col = i;
         trypos = find_match_paren(curbuf->b_ind_maxparen);
         if (trypos != NULL) {
-          s = cin_skipcomment(ml_get(trypos->lnum));
+          s = cin_skipcomment((char_u *)ml_get(trypos->lnum));
           if (*s == '}') {                      // accept "} while (cond);"
             s = cin_skipcomment(s + 1);
           }
@@ -1200,7 +1201,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
    *    {}
    */
   while (lnum > 1) {
-    line = ml_get(lnum - 1);
+    line = (char_u *)ml_get(lnum - 1);
     s = (char_u *)skipwhite((char *)line);
     if (*s == '#' || *s == NUL) {
       break;
@@ -1222,7 +1223,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
   }
 
   pos->lnum = lnum;
-  line = ml_get(lnum);
+  line = (char_u *)ml_get(lnum);
   s = line;
   for (;;) {
     if (*s == NUL) {
@@ -1230,7 +1231,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
         break;
       }
       // Continue in the cursor line.
-      line = ml_get(++lnum);
+      line = (char_u *)ml_get(++lnum);
       s = line;
     }
     if (s == line) {
@@ -1420,7 +1421,8 @@ static int cin_skip2pos(pos_T *trypos)
   const char_u *p;
   const char_u *new_p;
 
-  p = line = ml_get(trypos->lnum);
+  line = (char_u *)ml_get(trypos->lnum);
+  p = line;
   while (*p && (colnr_T)(p - line) < trypos->col) {
     if (cin_iscomment(p)) {
       p = cin_skipcomment(p);
@@ -1952,7 +1954,7 @@ int get_c_indent(void)
   /* Get a copy of the current contents of the line.
    * This is required, because only the most recent line obtained with
    * ml_get is valid! */
-  linecopy = vim_strsave(ml_get(cur_curpos.lnum));
+  linecopy = vim_strsave((char_u *)ml_get(cur_curpos.lnum));
 
   /*
    * In insert mode and the cursor is on a ')' truncate the line at the
@@ -2019,7 +2021,7 @@ int get_c_indent(void)
     if (trypos == NULL && curwin->w_cursor.lnum > 1) {
       // There may be a statement before the comment, search from the end
       // of the line for a comment start.
-      linecomment_pos.col = check_linecomment((char *)ml_get(curwin->w_cursor.lnum - 1));
+      linecomment_pos.col = check_linecomment(ml_get(curwin->w_cursor.lnum - 1));
       if (linecomment_pos.col != MAXCOL) {
         trypos = &linecomment_pos;
         trypos->lnum = curwin->w_cursor.lnum - 1;
@@ -2094,7 +2096,7 @@ int get_c_indent(void)
              * line, use the indent of that line plus offset.  If
              * the middle comment string matches in the previous
              * line, use the indent of that line.  XXX */
-            look = (char_u *)skipwhite((char *)ml_get(curwin->w_cursor.lnum - 1));
+            look = (char_u *)skipwhite(ml_get(curwin->w_cursor.lnum - 1));
             if (STRNCMP(look, lead_start, lead_start_len) == 0) {
               amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
             } else if (STRNCMP(look, lead_middle, lead_middle_len) == 0) {
@@ -2156,7 +2158,7 @@ int get_c_indent(void)
       }
       if (amount == -1) {                           // use the comment opener
         if (!curbuf->b_ind_in_comment2) {
-          start = ml_get(comment_pos->lnum);
+          start = (char_u *)ml_get(comment_pos->lnum);
           look = start + comment_pos->col + 2;  // skip / and *
           if (*look != NUL) {                   // if something after it
             comment_pos->col = (colnr_T)((char_u *)skipwhite((char *)look) - start);
@@ -2208,7 +2210,7 @@ int get_c_indent(void)
       } else {
         amount = -1;
         for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; lnum--) {
-          l = (char_u *)skipwhite((char *)ml_get(lnum));
+          l = (char_u *)skipwhite(ml_get(lnum));
           if (cin_nocode(l)) {                   // skip comment lines
             continue;
           }
@@ -2269,7 +2271,7 @@ int get_c_indent(void)
 
           curwin->w_cursor = cursor_save;
 
-          line = ml_get(outermost.lnum);
+          line = (char_u *)ml_get(outermost.lnum);
 
           is_if_for_while =
             cin_is_if_for_while_before_offset(line, &outermost.col);
@@ -2297,7 +2299,7 @@ int get_c_indent(void)
           }
 
           curwin->w_cursor.lnum = save_lnum;
-          look = ml_get(our_paren_pos.lnum) + look_col;
+          look = (char_u *)ml_get(our_paren_pos.lnum) + look_col;
         }
         if (theline[0] == ')' || (curbuf->b_ind_unclosed == 0
                                   && is_if_for_while == 0)
@@ -2314,7 +2316,7 @@ int get_c_indent(void)
            */
           if (theline[0] != ')') {
             cur_amount = MAXCOL;
-            l = ml_get(our_paren_pos.lnum);
+            l = (char_u *)ml_get(our_paren_pos.lnum);
             if (curbuf->b_ind_unclosed_wrapped
                 && cin_ends_in(l, (char_u *)"(", NULL)) {
               /* look for opening unmatched paren, indent one level
@@ -2435,7 +2437,7 @@ int get_c_indent(void)
       tryposBrace = &tryposCopy;
       trypos = tryposBrace;
       ourscope = trypos->lnum;
-      start = ml_get(ourscope);
+      start = (char_u *)ml_get(ourscope);
 
       /*
        * Now figure out how indented the line is in general.
@@ -3054,7 +3056,7 @@ int get_c_indent(void)
              */
             if (terminated == ',') {
               while (curwin->w_cursor.lnum > 1) {
-                l = ml_get(curwin->w_cursor.lnum - 1);
+                l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
                 if (*l == NUL || l[STRLEN(l) - 1] != '\\') {
                   break;
                 }
@@ -3607,7 +3609,7 @@ term_again:
        *      here;
        */
       while (n == 0 && curwin->w_cursor.lnum > 1) {
-        l = ml_get(curwin->w_cursor.lnum - 1);
+        l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
         if (*l == NUL || l[STRLEN(l) - 1] != '\\') {
           break;
         }
@@ -3670,7 +3672,7 @@ term_again:
       pos_T curpos_save = curwin->w_cursor;
 
       while (curwin->w_cursor.lnum > 1) {
-        look = ml_get(--curwin->w_cursor.lnum);
+        look = (char_u *)ml_get(--curwin->w_cursor.lnum);
         if (!(cin_nocode(look)
               || cin_ispreproc_cont(&look, &curwin->w_cursor.lnum, &amount))) {
           break;
@@ -3702,7 +3704,7 @@ term_again:
      * indent_to_0 here;
      */
     if (cin_ends_in(l, (char_u *)";", NULL)) {
-      l = ml_get(curwin->w_cursor.lnum - 1);
+      l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
       if (cin_ends_in(l, (char_u *)",", NULL)
           || (*l != NUL && l[STRLEN(l) - 1] == '\\')) {
         break;
@@ -3737,7 +3739,7 @@ term_again:
   //        char *foo = "asdf{backslash}
   //                     here";
   if (cur_curpos.lnum > 1) {
-    l = ml_get(cur_curpos.lnum - 1);
+    l = (char_u *)ml_get(cur_curpos.lnum - 1);
     if (*l != NUL && l[STRLEN(l) - 1] == '\\') {
       cur_amount = cin_get_equal_amount(cur_curpos.lnum - 1);
       if (cur_amount > 0) {
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index ba0a36cafe..a530061280 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -2177,7 +2177,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
     p = compl_orig_text;
     for (len = 0; p[len] != NUL && p[len] == ptr[len]; len++) {}
     if (len > 0) {
-      len -= utf_head_off(p, p + len);
+      len -= utf_head_off((char *)p, (char *)p + len);
     }
     for (p += len; *p != NUL; MB_PTR_ADV(p)) {
       AppendCharToRedobuff(K_BS);
@@ -3726,16 +3726,16 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
   } else if (--startcol < 0
              || !vim_iswordp(mb_prevptr(line, line + startcol + 1))) {
     // Match any word of at least two chars
-    compl_pattern = (char *)vim_strsave((char_u *)"\\<\\k\\k");
+    compl_pattern = xstrdup("\\<\\k\\k");
     compl_col += curs_col;
     compl_length = 0;
   } else {
     // Search the point of change class of multibyte character
     // or not a word single byte character backward.
-    startcol -= utf_head_off(line, line + startcol);
+    startcol -= utf_head_off((char *)line, (char *)line + startcol);
     int base_class = mb_get_class(line + startcol);
     while (--startcol >= 0) {
-      int head_off = utf_head_off(line, line + startcol);
+      int head_off = utf_head_off((char *)line, (char *)line + startcol);
       if (base_class != mb_get_class(line + startcol - head_off)) {
         break;
       }
@@ -3893,7 +3893,7 @@ static int get_userdefined_compl_info(colnr_T curs_col)
 
   // Setup variables for completion.  Need to obtain "line" again,
   // it may have become invalid.
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   compl_length = curs_col - compl_col;
   compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
 
@@ -3919,7 +3919,7 @@ static int get_spell_compl_info(int startcol, colnr_T curs_col)
     compl_length = (int)curs_col - compl_col;
   }
   // Need to obtain "line" again, it may have become invalid.
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
 
   return OK;
@@ -4036,7 +4036,7 @@ static int ins_compl_start(void)
     return FAIL;
   }
 
-  char_u *line = ml_get(curwin->w_cursor.lnum);
+  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
   colnr_T curs_col = curwin->w_cursor.col;
   compl_pending = 0;
 
@@ -4074,7 +4074,7 @@ static int ins_compl_start(void)
   }
   // If "line" was changed while getting completion info get it again.
   if (line_invalid) {
-    line = ml_get(curwin->w_cursor.lnum);
+    line = (char_u *)ml_get(curwin->w_cursor.lnum);
   }
 
   if (compl_status_adding()) {
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index 5601db274b..b84539852f 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -104,7 +104,7 @@
 // MB_PTR_BACK(): backup a pointer to the previous character, taking care of
 // multi-byte characters if needed. Only use with "p" > "s" !
 #define MB_PTR_BACK(s, p) \
-  (p -= utf_head_off((char_u *)(s), (char_u *)(p) - 1) + 1)
+  (p -= utf_head_off((char *)(s), (char *)(p) - 1) + 1)
 
 // MB_CHAR2BYTES(): convert character to bytes and advance pointer to bytes
 #define MB_CHAR2BYTES(c, b) ((b) += utf_char2bytes((c), ((char *)b)))
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 883f946cad..1c7cfea768 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1914,9 +1914,9 @@ static bool do_user_initialization(void)
   char_u *user_vimrc = (char_u *)stdpaths_user_conf_subpath("init.vim");
 
   // init.lua
-  if (os_path_exists(init_lua_path)
+  if (os_path_exists((char *)init_lua_path)
       && do_source((char *)init_lua_path, true, DOSO_VIMRC)) {
-    if (os_path_exists(user_vimrc)) {
+    if (os_path_exists((char *)user_vimrc)) {
       semsg(_("E5422: Conflicting configs: \"%s\" \"%s\""), init_lua_path,
             user_vimrc);
     }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 333fb847f6..d740a0eb77 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -174,7 +174,7 @@ static void showmap(mapblock_T *mp, bool local)
   }
 
   // Display the LHS.  Get length of what we write.
-  len = (size_t)msg_outtrans_special(mp->m_keys, true, 0);
+  len = (size_t)msg_outtrans_special((char *)mp->m_keys, true, 0);
   do {
     msg_putchar(' ');                   // padd with blanks
     len++;
@@ -203,7 +203,7 @@ static void showmap(mapblock_T *mp, bool local)
   } else if (mp->m_str[0] == NUL) {
     msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
   } else {
-    msg_outtrans_special((char_u *)mp->m_str, false, 0);
+    msg_outtrans_special(mp->m_str, false, 0);
   }
 
   if (mp->m_desc != NULL) {
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 9df4d416ff..816599271d 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -819,7 +819,7 @@ static char_u *mark_line(pos_T *mp, int lead_len)
   }
   assert(Columns >= 0);
   // Allow for up to 5 bytes per character.
-  s = vim_strnsave((char_u *)skipwhite((char *)ml_get(mp->lnum)), (size_t)Columns * 5);
+  s = vim_strnsave((char_u *)skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
 
   // Truncate the line to fit it in the window
   len = 0;
@@ -1758,7 +1758,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
     if (*p == NUL || (int)STRLEN(p) < lp->col) {
       lp->col = 0;
     } else {
-      lp->col -= utf_head_off(p, p + lp->col);
+      lp->col -= utf_head_off((char *)p, (char *)p + lp->col);
     }
     // Reset "coladd" when the cursor would be on the right half of a
     // double-wide character.
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index b874f0dc94..f592b54f67 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1618,21 +1618,24 @@ void show_utf8(void)
 /// "base" must be the start of the string, which must be NUL terminated.
 /// If "p" points to the NUL at the end of the string return 0.
 /// Returns 0 when already at the first byte of a character.
-int utf_head_off(const char_u *base, const char_u *p)
+int utf_head_off(const char *base_in, const char *p_in)
 {
   int c;
   int len;
 
-  if (*p < 0x80) {              // be quick for ASCII
+  if ((uint8_t)(*p_in) < 0x80) {              // be quick for ASCII
     return 0;
   }
 
+  const uint8_t *base = (uint8_t *)base_in;
+  const uint8_t *p = (uint8_t *)p_in;
+
   // Skip backwards over trailing bytes: 10xx.xxxx
   // Skip backwards again if on a composing char.
-  const char_u *q;
+  const uint8_t *q;
   for (q = p;; q--) {
     // Move s to the last byte of this char.
-    const char_u *s;
+    const uint8_t *s;
     for (s = q; (s[1] & 0xc0) == 0x80; s++) {}
 
     // Move q to the first byte of this char.
@@ -1657,7 +1660,7 @@ int utf_head_off(const char_u *base, const char_u *p)
 
     if (arabic_maycombine(c)) {
       // Advance to get a sneak-peak at the next char
-      const char_u *j = q;
+      const uint8_t *j = q;
       j--;
       // Move j to the first byte of this char.
       while (j > base && (*j & 0xc0) == 0x80) {
@@ -2042,7 +2045,7 @@ void mb_check_adjust_col(void *win_)
         win->w_cursor.col = len - 1;
       }
       // Move the cursor to the head byte.
-      win->w_cursor.col -= utf_head_off((char_u *)p, (char_u *)p + win->w_cursor.col);
+      win->w_cursor.col -= utf_head_off(p, p + win->w_cursor.col);
     }
 
     // Reset `coladd` when the cursor would be on the right half of a
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index b0b6b675cb..a30a98d6e9 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1177,7 +1177,7 @@ void ml_recover(bool checkext)
   } else {
     for (idx = 1; idx <= lnum; idx++) {
       // Need to copy one line, fetching the other one may flush it.
-      p = vim_strsave(ml_get(idx));
+      p = vim_strsave((char_u *)ml_get(idx));
       i = STRCMP(p, ml_get(idx + lnum));
       xfree(p);
       if (i != 0) {
@@ -1276,7 +1276,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
 #ifdef HAVE_READLINK
     // Expand symlink in the file name, because the swap file is created
     // with the actual file instead of with the symlink.
-    if (resolve_symlink(fname, fname_buf) == OK) {
+    if (resolve_symlink((char *)fname, (char *)fname_buf) == OK) {
       fname_res = fname_buf;
     } else
 #endif
@@ -1351,7 +1351,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
     if (*dirp == NUL && file_count + num_files == 0 && fname != NULL) {
       char_u *swapname = (char_u *)modname((char *)fname_res, ".swp", true);
       if (swapname != NULL) {
-        if (os_path_exists(swapname)) {
+        if (os_path_exists((char *)swapname)) {
           files = xmalloc(sizeof(char_u *));
           files[0] = (char *)swapname;
           swapname = NULL;
@@ -1399,7 +1399,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
         }
       } else {
         msg_puts(_("   In directory "));
-        msg_home_replace(dir_name);
+        msg_home_replace((char *)dir_name);
         msg_puts(":\n");
       }
 
@@ -1592,7 +1592,7 @@ static bool swapfile_unchanged(char *fname)
   int ret = true;
 
   // Swap file must exist.
-  if (!os_path_exists((char_u *)fname)) {
+  if (!os_path_exists(fname)) {
     return false;
   }
 
@@ -1793,9 +1793,9 @@ theend:
 ///
 /// On failure an error message is given and IObuff is returned (to avoid
 /// having to check for error everywhere).
-char_u *ml_get(linenr_T lnum)
+char *ml_get(linenr_T lnum)
 {
-  return ml_get_buf(curbuf, lnum, false);
+  return (char *)ml_get_buf(curbuf, lnum, false);
 }
 
 /// @return  pointer to position "pos".
@@ -2414,9 +2414,9 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
   return OK;
 }
 
-void ml_add_deleted_len(char_u *ptr, ssize_t len)
+void ml_add_deleted_len(char *ptr, ssize_t len)
 {
-  ml_add_deleted_len_buf(curbuf, ptr, len);
+  ml_add_deleted_len_buf(curbuf, (char_u *)ptr, len);
 }
 
 void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len)
@@ -2439,7 +2439,7 @@ void ml_add_deleted_len_buf(buf_T *buf, char_u *ptr, ssize_t len)
 
 int ml_replace(linenr_T lnum, char *line, bool copy)
 {
-  return ml_replace_buf(curbuf, lnum, (char_u *)line, copy);
+  return ml_replace_buf(curbuf, lnum, line, copy);
 }
 
 /// Replace line "lnum", with buffering, in current buffer.
@@ -2454,7 +2454,7 @@ int ml_replace(linenr_T lnum, char *line, bool copy)
 /// changed_lines(), unless update_screen(UPD_NOT_VALID) is used.
 ///
 /// @return  FAIL for failure, OK otherwise
-int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
+int ml_replace_buf(buf_T *buf, linenr_T lnum, char *line, bool copy)
 {
   if (line == NULL) {           // just checking...
     return FAIL;
@@ -2468,7 +2468,7 @@ int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
   bool readlen = true;
 
   if (copy) {
-    line = vim_strsave(line);
+    line = xstrdup(line);
   }
   if (buf->b_ml.ml_line_lnum != lnum) {  // other line buffered
     ml_flush_line(buf);  // flush it
@@ -2483,7 +2483,7 @@ int ml_replace_buf(buf_T *buf, linenr_T lnum, char_u *line, bool copy)
     ml_add_deleted_len_buf(buf, ml_get_buf(buf, lnum, false), -1);
   }
 
-  buf->b_ml.ml_line_ptr = line;
+  buf->b_ml.ml_line_ptr = (char_u *)line;
   buf->b_ml.ml_line_lnum = lnum;
   buf->b_ml.ml_flags = (buf->b_ml.ml_flags | ML_LINE_DIRTY) & ~ML_EMPTY;
 
@@ -3142,9 +3142,9 @@ static void ml_lineadd(buf_T *buf, int count)
 ///
 /// @return  OK if it worked and the resolved link in "buf[MAXPATHL]",
 ///          FAIL otherwise
-int resolve_symlink(const char_u *fname, char_u *buf)
+int resolve_symlink(const char *fname, char *buf)
 {
-  char_u tmp[MAXPATHL];
+  char tmp[MAXPATHL];
   int ret;
   int depth = 0;
 
@@ -3162,7 +3162,7 @@ int resolve_symlink(const char_u *fname, char_u *buf)
       return FAIL;
     }
 
-    ret = (int)readlink((char *)tmp, (char *)buf, MAXPATHL - 1);
+    ret = (int)readlink(tmp, buf, MAXPATHL - 1);
     if (ret <= 0) {
       if (errno == EINVAL || errno == ENOENT) {
         // Found non-symlink or not existing file, stop here.
@@ -3185,10 +3185,10 @@ int resolve_symlink(const char_u *fname, char_u *buf)
     // If it's relative, build a new path based on the directory
     // portion of the filename (if any) and the path the symlink
     // points to.
-    if (path_is_absolute(buf)) {
+    if (path_is_absolute((char_u *)buf)) {
       STRCPY(tmp, buf);
     } else {
-      char_u *tail = (char_u *)path_tail((char *)tmp);
+      char_u *tail = (char_u *)path_tail(tmp);
       if (STRLEN(tail) + STRLEN(buf) >= MAXPATHL) {
         return FAIL;
       }
@@ -3201,7 +3201,7 @@ int resolve_symlink(const char_u *fname, char_u *buf)
    * be consistent even when opening a relative symlink from different
    * working directories.
    */
-  return vim_FullName((char *)tmp, (char *)buf, MAXPATHL, true);
+  return vim_FullName(tmp, buf, MAXPATHL, true);
 }
 #endif
 
@@ -3217,7 +3217,7 @@ char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name
 
   // Expand symlink in the file name, so that we put the swap file with the
   // actual file instead of with the symlink.
-  if (resolve_symlink(fname, fname_buf) == OK) {
+  if (resolve_symlink((char *)fname, (char *)fname_buf) == OK) {
     fname_res = fname_buf;
   }
 #endif
@@ -3300,7 +3300,7 @@ static void attention_message(buf_T *buf, char_u *fname)
   no_wait_return++;
   (void)emsg(_("E325: ATTENTION"));
   msg_puts(_("\nFound a swap file by the name \""));
-  msg_home_replace(fname);
+  msg_home_replace((char *)fname);
   msg_puts("\"\n");
   const time_t swap_mtime = swapfile_info(fname);
   msg_puts(_("While opening file \""));
@@ -3499,7 +3499,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
           // It's safe to delete the swap file if all these are true:
           // - the edited file exists
           // - the swap file has no changes and looks OK
-          if (os_path_exists((char_u *)buf->b_fname) && swapfile_unchanged(fname)) {
+          if (os_path_exists(buf->b_fname) && swapfile_unchanged(fname)) {
             choice = 4;
             if (p_verbose > 0) {
               verb_msg(_("Found a swap file that is not useful, deleting it"));
@@ -3541,13 +3541,13 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             memcpy(name, sw_msg_1, sw_msg_1_len + 1);
             home_replace(NULL, fname, &name[sw_msg_1_len], fname_len, true);
             xstrlcat(name, sw_msg_2, name_len);
-            choice = do_dialog(VIM_WARNING, (char_u *)_("VIM - ATTENTION"),
-                               (char_u *)name,
+            choice = do_dialog(VIM_WARNING, _("VIM - ATTENTION"),
+                               name,
                                process_still_running
-                               ? (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover"
-                                             "\n&Quit\n&Abort") :
-                               (char_u *)_("&Open Read-Only\n&Edit anyway\n&Recover"
-                                           "\n&Delete it\n&Quit\n&Abort"),
+                               ? _("&Open Read-Only\n&Edit anyway\n&Recover"
+                                   "\n&Quit\n&Abort") :
+                               _("&Open Read-Only\n&Edit anyway\n&Recover"
+                                 "\n&Delete it\n&Quit\n&Abort"),
                                1, NULL, false);
 
             if (process_still_running && choice >= 4) {
@@ -3582,7 +3582,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             }
 
             // If the file was deleted this fname can be used.
-            if (!os_path_exists((char_u *)fname)) {
+            if (!os_path_exists(fname)) {
               break;
             }
           } else {
@@ -4212,8 +4212,8 @@ int dec(pos_T *lp)
   lp->coladd = 0;
   if (lp->col == MAXCOL) {
     // past end of line
-    char_u *p = ml_get(lp->lnum);
-    lp->col = (colnr_T)STRLEN(p);
+    char *p = ml_get(lp->lnum);
+    lp->col = (colnr_T)strlen(p);
     lp->col -= utf_head_off(p, p + lp->col);
     return 0;
   }
@@ -4221,15 +4221,15 @@ int dec(pos_T *lp)
   if (lp->col > 0) {
     // still within line
     lp->col--;
-    char_u *p = ml_get(lp->lnum);
+    char *p = ml_get(lp->lnum);
     lp->col -= utf_head_off(p, p + lp->col);
     return 0;
   }
   if (lp->lnum > 1) {
     // there is a prior line
     lp->lnum--;
-    char_u *p = ml_get(lp->lnum);
-    lp->col = (colnr_T)STRLEN(p);
+    char *p = ml_get(lp->lnum);
+    lp->col = (colnr_T)strlen(p);
     lp->col -= utf_head_off(p, p + lp->col);
     return 1;
   }
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index cb6918cd27..84a1defbe0 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -888,7 +888,7 @@ static void show_menus_recursive(vimmenu_T *menu, int modes, int depth)
         if (*menu->strings[bit] == NUL) {
           msg_puts_attr("<Nop>", HL_ATTR(HLF_8));
         } else {
-          msg_outtrans_special((char_u *)menu->strings[bit], false, 0);
+          msg_outtrans_special(menu->strings[bit], false, 0);
         }
       }
     }
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 80b5f53f4e..e7959c73c6 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -59,7 +59,7 @@ struct msgchunk_S {
   char sb_eol;                  // true when line ends after this text
   int sb_msg_col;               // column in which text starts
   int sb_attr;                  // text attributes
-  char_u sb_text[1];            // text to be displayed, actually longer
+  char sb_text[1];              // text to be displayed, actually longer
 };
 
 // Magic chars used in confirm dialog strings
@@ -70,8 +70,8 @@ static int confirm_msg_used = false;            // displaying confirm_msg
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "message.c.generated.h"
 #endif
-static char_u *confirm_msg = NULL;            // ":confirm" message
-static char_u *confirm_msg_tail;              // tail of confirm_msg
+static char *confirm_msg = NULL;            // ":confirm" message
+static char *confirm_msg_tail;              // tail of confirm_msg
 
 MessageHistoryEntry *first_msg_hist = NULL;
 MessageHistoryEntry *last_msg_hist = NULL;
@@ -251,7 +251,7 @@ void msg_multiline_attr(const char *s, int attr, bool check_int, bool *need_clea
 
     if (next_spec != NULL) {
       // Printing all char that are before the char found by strpbrk
-      msg_outtrans_len_attr((const char_u *)s, (int)(next_spec - s), attr);
+      msg_outtrans_len_attr(s, (int)(next_spec - s), attr);
 
       if (*next_spec != TAB && *need_clear) {
         msg_clr_eos();
@@ -294,7 +294,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 {
   static int entered = 0;
   int retval;
-  char_u *buf = NULL;
+  char *buf = NULL;
 
   if (keep && multiline) {
     // Not implemented. 'multiline' is only used by nvim-added messages,
@@ -335,9 +335,9 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 
   // Truncate the message if needed.
   msg_start();
-  buf = msg_strtrunc((char_u *)s, false);
+  buf = msg_strtrunc((char *)s, false);
   if (buf != NULL) {
-    s = (const char *)buf;
+    s = buf;
   }
 
   bool need_clear = true;
@@ -367,9 +367,9 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
 /// @return  an allocated string or NULL when no truncating is done.
 ///
 /// @param force  always truncate
-char_u *msg_strtrunc(char_u *s, int force)
+char *msg_strtrunc(char *s, int force)
 {
-  char_u *buf = NULL;
+  char *buf = NULL;
   int len;
   int room;
 
@@ -377,7 +377,7 @@ char_u *msg_strtrunc(char_u *s, int force)
   if ((!msg_scroll && !need_wait_return && shortmess(SHM_TRUNCALL)
        && !exmode_active && msg_silent == 0 && !ui_has(kUIMessages))
       || force) {
-    len = vim_strsize((char *)s);
+    len = vim_strsize(s);
     if (msg_scrolled != 0) {
       // Use all the columns.
       room = (Rows - msg_row) * Columns - 1;
@@ -390,7 +390,7 @@ char_u *msg_strtrunc(char_u *s, int force)
       // composing chars)
       len = (room + 2) * 18;
       buf = xmalloc((size_t)len);
-      trunc_string((char *)s, (char *)buf, room, len);
+      trunc_string(s, buf, room, len);
     }
   }
   return buf;
@@ -444,7 +444,7 @@ void trunc_string(char *s, char *buf, int room_in, int buflen)
   half = i = (int)STRLEN(s);
   for (;;) {
     do {
-      half = half - utf_head_off((char_u *)s, (char_u *)s + half - 1) - 1;
+      half = half - utf_head_off(s, s + half - 1) - 1;
     } while (half > 0 && utf_iscomposing(utf_ptr2char(s + half)));
     n = ptr2cells(s + half);
     if (len + n > room || half == 0) {
@@ -900,7 +900,7 @@ char *msg_trunc_attr(char *s, bool force, int attr)
   // Add message to history before truncating.
   add_msg_hist(s, -1, attr, false);
 
-  char *ts = (char *)msg_may_trunc(force, (char_u *)s);
+  char *ts = msg_may_trunc(force, s);
 
   msg_hist_off = true;
   n = msg_attr(ts, attr);
@@ -917,14 +917,14 @@ char *msg_trunc_attr(char *s, bool force, int attr)
 /// @return  a pointer to where the truncated message starts.
 ///
 /// @note: May change the message by replacing a character with '<'.
-char_u *msg_may_trunc(bool force, char_u *s)
+char *msg_may_trunc(bool force, char *s)
 {
   int room;
 
   room = (Rows - cmdline_row - 1) * Columns + sc_col - 1;
   if ((force || (shortmess(SHM_TRUNC) && !exmode_active))
       && (int)STRLEN(s) - room > 0 && p_ch > 0) {
-    int size = vim_strsize((char *)s);
+    int size = vim_strsize(s);
 
     // There may be room anyway when there are multibyte chars.
     if (size <= room) {
@@ -932,8 +932,8 @@ char_u *msg_may_trunc(bool force, char_u *s)
     }
     int n;
     for (n = 0; size >= room;) {
-      size -= utf_ptr2cells((char *)s + n);
-      n += utfc_ptr2len((char *)s + n);
+      size -= utf_ptr2cells(s + n);
+      n += utfc_ptr2len(s + n);
     }
     n--;
     s += n;
@@ -1497,19 +1497,19 @@ void msg_outnum(long n)
   msg_puts(buf);
 }
 
-void msg_home_replace(char_u *fname)
+void msg_home_replace(char *fname)
 {
   msg_home_replace_attr(fname, 0);
 }
 
-void msg_home_replace_hl(char_u *fname)
+void msg_home_replace_hl(char *fname)
 {
   msg_home_replace_attr(fname, HL_ATTR(HLF_D));
 }
 
-static void msg_home_replace_attr(char_u *fname, int attr)
+static void msg_home_replace_attr(char *fname, int attr)
 {
-  char *name = home_replace_save(NULL, (char *)fname);
+  char *name = home_replace_save(NULL, fname);
   msg_outtrans_attr(name, attr);
   xfree(name);
 }
@@ -1526,12 +1526,12 @@ int msg_outtrans(char *str)
 
 int msg_outtrans_attr(const char *str, int attr)
 {
-  return msg_outtrans_len_attr((char_u *)str, (int)STRLEN(str), attr);
+  return msg_outtrans_len_attr(str, (int)STRLEN(str), attr);
 }
 
 int msg_outtrans_len(const char *str, int len)
 {
-  return msg_outtrans_len_attr((char_u *)str, len, 0);
+  return msg_outtrans_len_attr(str, len, 0);
 }
 
 /// Output one character at "p".
@@ -1543,19 +1543,19 @@ char *msg_outtrans_one(char *p, int attr)
   int l;
 
   if ((l = utfc_ptr2len(p)) > 1) {
-    msg_outtrans_len_attr((char_u *)p, l, attr);
+    msg_outtrans_len_attr(p, l, attr);
     return p + l;
   }
   msg_puts_attr((const char *)transchar_byte(*p), attr);
   return p + 1;
 }
 
-int msg_outtrans_len_attr(const char_u *msgstr, int len, int attr)
+int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
 {
   int retval = 0;
-  const char *str = (const char *)msgstr;
-  const char *plain_start = (const char *)msgstr;
-  char_u *s;
+  const char *str = msgstr;
+  const char *plain_start = msgstr;
+  char *s;
   int mb_l;
   int c;
   int save_got_int = got_int;
@@ -1601,7 +1601,7 @@ int msg_outtrans_len_attr(const char_u *msgstr, int len, int attr)
       len -= mb_l - 1;
       str += mb_l;
     } else {
-      s = transchar_byte((uint8_t)(*str));
+      s = (char *)transchar_byte((uint8_t)(*str));
       if (s[1] != NUL) {
         // Unprintable char: print the printable chars so far and the
         // translation of the unprintable char.
@@ -1663,12 +1663,12 @@ void msg_make(char *arg)
 ///
 /// @param from  true for LHS of a mapping
 /// @param maxlen  screen columns, 0 for unlimited
-int msg_outtrans_special(const char_u *strstart, bool from, int maxlen)
+int msg_outtrans_special(const char *strstart, bool from, int maxlen)
 {
   if (strstart == NULL) {
     return 0;  // Do nothing.
   }
-  const char_u *str = strstart;
+  const char *str = strstart;
   int retval = 0;
   int attr = HL_ATTR(HLF_8);
 
@@ -1679,7 +1679,7 @@ int msg_outtrans_special(const char_u *strstart, bool from, int maxlen)
       text = "<Space>";
       str++;
     } else {
-      text = str2special((const char **)&str, from, false);
+      text = str2special(&str, from, false);
     }
     if (text[0] != NUL && text[1] == NUL) {
       // single-byte character or illegal byte
@@ -1818,20 +1818,20 @@ void str2specialbuf(const char *sp, char *buf, size_t len)
 }
 
 /// print line for :print or :list command
-void msg_prt_line(char_u *s, int list)
+void msg_prt_line(char *s, int list)
 {
   int c;
   int col = 0;
   int n_extra = 0;
   int c_extra = 0;
   int c_final = 0;
-  char_u *p_extra = NULL;  // init to make SASC shut up
+  char *p_extra = NULL;  // init to make SASC shut up
   int n;
   int attr = 0;
-  char_u *lead = NULL;
+  char *lead = NULL;
   bool in_multispace = false;
   int multispace_pos = 0;
-  char_u *trail = NULL;
+  char *trail = NULL;
   int l;
 
   if (curwin->w_p_list) {
@@ -1873,16 +1873,16 @@ void msg_prt_line(char_u *s, int list)
         c = c_extra;
       } else {
         assert(p_extra != NULL);
-        c = *p_extra++;
+        c = (unsigned char)(*p_extra++);
       }
-    } else if ((l = utfc_ptr2len((char *)s)) > 1) {
-      col += utf_ptr2cells((char *)s);
+    } else if ((l = utfc_ptr2len(s)) > 1) {
+      col += utf_ptr2cells(s);
       char buf[MB_MAXBYTES + 1];
       if (l >= MB_MAXBYTES) {
         xstrlcpy(buf, "?", sizeof(buf));
       } else if (curwin->w_p_lcs_chars.nbsp != NUL && list
-                 && (utf_ptr2char((char *)s) == 160
-                     || utf_ptr2char((char *)s) == 0x202f)) {
+                 && (utf_ptr2char(s) == 160
+                     || utf_ptr2char(s) == 0x202f)) {
         int len = utf_char2bytes(curwin->w_p_lcs_chars.nbsp, buf);
         buf[len] = NUL;
       } else {
@@ -1894,7 +1894,7 @@ void msg_prt_line(char_u *s, int list)
       continue;
     } else {
       attr = 0;
-      c = *s++;
+      c = (unsigned char)(*s++);
       in_multispace = c == ' ' && ((col > 0 && s[-2] == ' ') || *s == ' ');
       if (!in_multispace) {
         multispace_pos = 0;
@@ -1920,7 +1920,7 @@ void msg_prt_line(char_u *s, int list)
         c = curwin->w_p_lcs_chars.nbsp;
         attr = HL_ATTR(HLF_0);
       } else if (c == NUL && list && curwin->w_p_lcs_chars.eol != NUL) {
-        p_extra = (char_u *)"";
+        p_extra = "";
         c_extra = NUL;
         c_final = NUL;
         n_extra = 1;
@@ -1929,10 +1929,10 @@ void msg_prt_line(char_u *s, int list)
         s--;
       } else if (c != NUL && (n = byte2cells(c)) > 1) {
         n_extra = n - 1;
-        p_extra = transchar_byte(c);
+        p_extra = (char *)transchar_byte(c);
         c_extra = NUL;
         c_final = NUL;
-        c = *p_extra++;
+        c = (unsigned char)(*p_extra++);
         // Use special coloring to be able to distinguish <hex> from
         // the same in plain text.
         attr = HL_ATTR(HLF_0);
@@ -2023,12 +2023,12 @@ void msg_puts_title(const char *s)
 /// Show a message in such a way that it always fits in the line.  Cut out a
 /// part in the middle and replace it with "..." when necessary.
 /// Does not handle multi-byte characters!
-void msg_outtrans_long_attr(char_u *longstr, int attr)
+void msg_outtrans_long_attr(char *longstr, int attr)
 {
   msg_outtrans_long_len_attr(longstr, (int)STRLEN(longstr), attr);
 }
 
-void msg_outtrans_long_len_attr(char_u *longstr, int len, int attr)
+void msg_outtrans_long_len_attr(char *longstr, int len, int attr)
 {
   int slen = len;
   int room;
@@ -2105,7 +2105,7 @@ void msg_puts_attr_len(const char *const str, const ptrdiff_t len, int attr)
     }
   }
   if (!msg_use_printf() || (headless_mode && default_grid.chars)) {
-    msg_puts_display((const char_u *)str, (int)len, attr, false);
+    msg_puts_display(str, (int)len, attr, false);
   }
 
   need_fileinfo = false;
@@ -2148,10 +2148,10 @@ static void msg_ext_emit_chunk(void)
 
 /// The display part of msg_puts_attr_len().
 /// May be called recursively to display scroll-back text.
-static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurse)
+static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
 {
-  const char_u *s = str;
-  const char_u *t_s = str;  // String from "t_s" to "s" is still todo.
+  const char *s = str;
+  const char *t_s = str;  // String from "t_s" to "s" is still todo.
   int t_col = 0;  // Screen cells todo, 0 when "t_s" not used.
   int l;
   int cw;
@@ -2186,19 +2186,19 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
         && (*s == '\n' || (cmdmsg_rl
                            ? (msg_col <= 1
                               || (*s == TAB && msg_col <= 7)
-                              || (utf_ptr2cells((char *)s) > 1
+                              || (utf_ptr2cells(s) > 1
                                   && msg_col <= 2))
                            : ((*s != '\r' && msg_col + t_col >= Columns - 1)
                               || (*s == TAB
                                   && msg_col + t_col >= ((Columns - 1) & ~7))
-                              || (utf_ptr2cells((char *)s) > 1
+                              || (utf_ptr2cells(s) > 1
                                   && msg_col + t_col >= Columns - 2))))) {
       // The screen is scrolled up when at the last row (some terminals
       // scroll automatically, some don't.  To avoid problems we scroll
       // ourselves).
       if (t_col > 0) {
         // output postponed text
-        t_puts(&t_col, (char *)t_s, (char *)s, attr);
+        t_puts(&t_col, t_s, s, attr);
       }
 
       // When no more prompt and no more room, truncate here
@@ -2207,7 +2207,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       }
 
       // Scroll the screen up one line.
-      bool has_last_char = (*s >= ' ' && !cmdmsg_rl);
+      bool has_last_char = ((uint8_t)(*s) >= ' ' && !cmdmsg_rl);
       msg_scroll_up(!has_last_char);
 
       msg_row = Rows - 2;
@@ -2219,11 +2219,11 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       if (has_last_char) {
         if (maxlen >= 0) {
           // Avoid including composing chars after the end.
-          l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
+          l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
         } else {
-          l = utfc_ptr2len((char *)s);
+          l = utfc_ptr2len(s);
         }
-        s = (char_u *)screen_puts_mbyte((char *)s, l, attr);
+        s = screen_puts_mbyte((char *)s, l, attr);
         did_last_char = true;
       } else {
         did_last_char = false;
@@ -2276,13 +2276,13 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
     wrap = *s == '\n'
            || msg_col + t_col >= Columns
-           || (utf_ptr2cells((char *)s) > 1
+           || (utf_ptr2cells(s) > 1
                && msg_col + t_col >= Columns - 1)
     ;
     if (t_col > 0 && (wrap || *s == '\r' || *s == '\b'
                       || *s == '\t' || *s == BELL)) {
       // Output any postponed text.
-      t_puts(&t_col, (char *)t_s, (char *)s, attr);
+      t_puts(&t_col, t_s, s, attr);
     }
 
     if (wrap && p_more && !recurse) {
@@ -2312,20 +2312,20 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
       } while (msg_col & 7);
     } else if (*s == BELL) {  // beep (from ":sh")
       vim_beep(BO_SH);
-    } else if (*s >= 0x20) {  // printable char
-      cw = utf_ptr2cells((char *)s);
+    } else if ((uint8_t)(*s) >= 0x20) {  // printable char
+      cw = utf_ptr2cells(s);
       if (maxlen >= 0) {
         // avoid including composing chars after the end
-        l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
+        l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
       } else {
-        l = utfc_ptr2len((char *)s);
+        l = utfc_ptr2len(s);
       }
       // When drawing from right to left or when a double-wide character
       // doesn't fit, draw a single character here.  Otherwise collect
       // characters and draw them all at once later.
       if (cmdmsg_rl || (cw > 1 && msg_col + t_col >= Columns - 1)) {
         if (l > 1) {
-          s = (char_u *)screen_puts_mbyte((char *)s, l, attr) - 1;
+          s = screen_puts_mbyte((char *)s, l, attr) - 1;
         } else {
           msg_screen_putchar(*s, attr);
         }
@@ -2343,7 +2343,7 @@ static void msg_puts_display(const char_u *str, int maxlen, int attr, int recurs
 
   // Output any postponed text.
   if (t_col > 0) {
-    t_puts(&t_col, (char *)t_s, (char *)s, attr);
+    t_puts(&t_col, t_s, s, attr);
   }
   if (p_more && !recurse) {
     store_sb_text((char **)&sb_str, (char *)s, attr, &sb_col, false);
@@ -2679,7 +2679,7 @@ void msg_sb_eol(void)
 static msgchunk_T *disp_sb_line(int row, msgchunk_T *smp)
 {
   msgchunk_T *mp = smp;
-  char_u *p;
+  char *p;
 
   for (;;) {
     msg_row = row;
@@ -3080,13 +3080,13 @@ static void msg_screen_putchar(int c, int attr)
 void msg_moremsg(int full)
 {
   int attr;
-  char_u *s = (char_u *)_("-- More --");
+  char *s = _("-- More --");
 
   attr = hl_combine_attr(HL_ATTR(HLF_MSG), HL_ATTR(HLF_M));
-  grid_puts(&msg_grid_adj, (char *)s, Rows - 1, 0, attr);
+  grid_puts(&msg_grid_adj, s, Rows - 1, 0, attr);
   if (full) {
     grid_puts(&msg_grid_adj, _(" SPACE/d/j: screen/page/line down, b/u/k: up, q: quit "),
-              Rows - 1, vim_strsize((char *)s), attr);
+              Rows - 1, vim_strsize(s), attr);
   }
 }
 
@@ -3281,7 +3281,7 @@ void msg_check(void)
 /// @param maxlen  if -1, write the whole string, otherwise up to "maxlen" bytes.
 static void redir_write(const char *const str, const ptrdiff_t maxlen)
 {
-  const char_u *s = (char_u *)str;
+  const char *s = str;
   static int cur_col = 0;
 
   if (maxlen == 0) {
@@ -3306,7 +3306,7 @@ static void redir_write(const char *const str, const ptrdiff_t maxlen)
           ga_concat_len(capture_ga, " ", 1);
         }
         if (redir_reg) {
-          write_reg_contents(redir_reg, (char_u *)" ", 1, true);
+          write_reg_contents(redir_reg, " ", 1, true);
         } else if (redir_vname) {
           var_redir_str(" ", -1);
         } else if (redir_fd != NULL) {
@@ -3332,7 +3332,7 @@ static void redir_write(const char *const str, const ptrdiff_t maxlen)
 
     // Write and adjust the current column.
     while (*s != NUL
-           && (maxlen < 0 || (int)(s - (const char_u *)str) < maxlen)) {
+           && (maxlen < 0 || (int)(s - str) < maxlen)) {
       if (!redir_reg && !redir_vname && !capture_ga) {
         if (redir_fd != NULL) {
           putc(*s, redir_fd);
@@ -3469,9 +3469,9 @@ void give_warning(char *message, bool hl)
   no_wait_return--;
 }
 
-void give_warning2(char_u *const message, char_u *const a1, bool hl)
+void give_warning2(char *const message, char *const a1, bool hl)
 {
-  vim_snprintf((char *)IObuff, IOSIZE, (char *)message, a1);
+  vim_snprintf((char *)IObuff, IOSIZE, message, a1);
   give_warning((char *)IObuff, hl);
 }
 
@@ -3524,11 +3524,11 @@ void msg_advance(int col)
 /// @param textfiel  IObuff for inputdialog(), NULL otherwise
 /// @param ex_cmd  when true pressing : accepts default and starts Ex command
 /// @returns 0 if cancelled, otherwise the nth button (1-indexed).
-int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton,
-              char_u *textfield, int ex_cmd)
+int do_dialog(int type, char *title, char *message, char *buttons, int dfltbutton, char *textfield,
+              int ex_cmd)
 {
   int retval = 0;
-  char_u *hotkeys;
+  char *hotkeys;
   int c;
   int i;
 
@@ -3578,10 +3578,10 @@ int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfl
       c = mb_tolower(c);
       retval = 1;
       for (i = 0; hotkeys[i]; i++) {
-        if (utf_ptr2char((char *)hotkeys + i) == c) {
+        if (utf_ptr2char(hotkeys + i) == c) {
           break;
         }
-        i += utfc_ptr2len((char *)hotkeys + i) - 1;
+        i += utfc_ptr2len(hotkeys + i) - 1;
         retval++;
       }
       if (hotkeys[i]) {
@@ -3608,14 +3608,14 @@ int do_dialog(int type, char_u *title, char_u *message, char_u *buttons, int dfl
 /// characters.  Return the length of the character in bytes.
 ///
 /// @param lowercase  make character lower case
-static int copy_char(const char_u *from, char_u *to, bool lowercase)
+static int copy_char(const char *from, char *to, bool lowercase)
   FUNC_ATTR_NONNULL_ALL
 {
   if (lowercase) {
-    int c = mb_tolower(utf_ptr2char((char *)from));
-    return utf_char2bytes(c, (char *)to);
+    int c = mb_tolower(utf_ptr2char(from));
+    return utf_char2bytes(c, to);
   }
-  int len = utfc_ptr2len((char *)from);
+  int len = utfc_ptr2len(from);
   memmove(to, from, (size_t)len);
   return len;
 }
@@ -3635,7 +3635,7 @@ static int copy_char(const char_u *from, char_u *to, bool lowercase)
 ///                        corresponding button has a hotkey
 ///
 /// @return Pointer to memory allocated for storing hotkeys
-static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool has_hotkey[])
+static char *console_dialog_alloc(const char *message, char *buttons, bool has_hotkey[])
 {
   int lenhotkey = HOTK_LEN;  // count first button
   has_hotkey[0] = false;
@@ -3643,7 +3643,7 @@ static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool
   // Compute the size of memory to allocate.
   int len = 0;
   int idx = 0;
-  char_u *r = buttons;
+  char *r = buttons;
   while (*r) {
     if (*r == DLG_BUTTON_SEP) {
       len += 3;                         // '\n' -> ', '; 'x' -> '(x)'
@@ -3689,11 +3689,11 @@ static char_u *console_dialog_alloc(const char_u *message, char_u *buttons, bool
 /// The hotkeys can be multi-byte characters, but without combining chars.
 ///
 /// @return  an allocated string with hotkeys.
-static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfltbutton)
+static char *msg_show_console_dialog(char *message, char *buttons, int dfltbutton)
   FUNC_ATTR_NONNULL_RET
 {
   bool has_hotkey[HAS_HOTKEY_LEN] = { false };
-  char_u *hotk = console_dialog_alloc(message, buttons, has_hotkey);
+  char *hotk = console_dialog_alloc(message, buttons, has_hotkey);
 
   copy_hotkeys_and_msg(message, buttons, dfltbutton, has_hotkey, hotk);
 
@@ -3709,13 +3709,13 @@ static char_u *msg_show_console_dialog(char_u *message, char_u *buttons, int dfl
 /// @param has_hotkey An element in this array is true if corresponding button
 ///                   has a hotkey
 /// @param[out] hotkeys_ptr Pointer to the memory location where hotkeys will be copied
-static void copy_hotkeys_and_msg(const char_u *message, char_u *buttons, int default_button_idx,
-                                 const bool has_hotkey[], char_u *hotkeys_ptr)
+static void copy_hotkeys_and_msg(const char *message, char *buttons, int default_button_idx,
+                                 const bool has_hotkey[], char *hotkeys_ptr)
 {
   *confirm_msg = '\n';
   STRCPY(confirm_msg + 1, message);
 
-  char_u *msgp = confirm_msg + 1 + STRLEN(message);
+  char *msgp = confirm_msg + 1 + STRLEN(message);
 
   // Define first default hotkey. Keep the hotkey string NUL
   // terminated to avoid reading past the end.
@@ -3732,7 +3732,7 @@ static void copy_hotkeys_and_msg(const char_u *message, char_u *buttons, int def
   }
 
   int idx = 0;
-  char_u *r = buttons;
+  char *r = buttons;
   while (*r) {
     if (*r == DLG_BUTTON_SEP) {
       *msgp++ = ',';
@@ -3788,28 +3788,28 @@ void display_confirm_msg(void)
   confirm_msg_used++;
   if (confirm_msg != NULL) {
     msg_ext_set_kind("confirm");
-    msg_puts_attr((const char *)confirm_msg, HL_ATTR(HLF_M));
+    msg_puts_attr(confirm_msg, HL_ATTR(HLF_M));
   }
   confirm_msg_used--;
 }
 
-int vim_dialog_yesno(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesno(int type, char *title, char *message, int dflt)
 {
   if (do_dialog(type,
-                title == NULL ? (char_u *)_("Question") : title,
+                title == NULL ? _("Question") : title,
                 message,
-                (char_u *)_("&Yes\n&No"), dflt, NULL, false) == 1) {
+                _("&Yes\n&No"), dflt, NULL, false) == 1) {
     return VIM_YES;
   }
   return VIM_NO;
 }
 
-int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesnocancel(int type, char *title, char *message, int dflt)
 {
   switch (do_dialog(type,
-                    title == NULL ? (char_u *)_("Question") : title,
+                    title == NULL ? _("Question") : title,
                     message,
-                    (char_u *)_("&Yes\n&No\n&Cancel"), dflt, NULL, false)) {
+                    _("&Yes\n&No\n&Cancel"), dflt, NULL, false)) {
   case 1:
     return VIM_YES;
   case 2:
@@ -3818,12 +3818,12 @@ int vim_dialog_yesnocancel(int type, char_u *title, char_u *message, int dflt)
   return VIM_CANCEL;
 }
 
-int vim_dialog_yesnoallcancel(int type, char_u *title, char_u *message, int dflt)
+int vim_dialog_yesnoallcancel(int type, char *title, char *message, int dflt)
 {
   switch (do_dialog(type,
-                    title == NULL ? (char_u *)"Question" : title,
+                    title == NULL ? "Question" : title,
                     message,
-                    (char_u *)_("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
+                    _("&Yes\n&No\nSave &All\n&Discard All\n&Cancel"),
                     dflt, NULL, false)) {
   case 1:
     return VIM_YES;
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 73147204a1..90084bde17 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -633,7 +633,7 @@ colnr_T vcol2col(win_T *const wp, const linenr_T lnum, const colnr_T vcol)
   // try to advance to the specified column
   char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   while (cts.cts_vcol < vcol && *cts.cts_ptr != NUL) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
     MB_PTR_ADV(cts.cts_ptr);
@@ -666,7 +666,7 @@ void set_mouse_topline(win_T *wp)
 static colnr_T scroll_line_len(linenr_T lnum)
 {
   colnr_T col = 0;
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   if (*line != NUL) {
     for (;;) {
       int numchar = win_chartabsize(curwin, (char *)line, col);
@@ -771,7 +771,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
   // highlighting the second byte, not the ninth.
 
   linenr_T lnum = wp->w_cursor.lnum;
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   char_u *ptr = line;
   char_u *ptr_end;
   char_u *ptr_row_offset = line;  // Where we begin adjusting `ptr_end`
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 47ad000385..17b79e27c1 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -2215,12 +2215,12 @@ static void find_start_of_word(pos_T *pos)
   int cclass;
   int col;
 
-  line = ml_get(pos->lnum);
+  line = (char_u *)ml_get(pos->lnum);
   cclass = get_mouse_class(line + pos->col);
 
   while (pos->col > 0) {
     col = pos->col - 1;
-    col -= utf_head_off(line, line + col);
+    col -= utf_head_off((char *)line, (char *)line + col);
     if (get_mouse_class(line + col) != cclass) {
       break;
     }
@@ -2236,10 +2236,10 @@ static void find_end_of_word(pos_T *pos)
   int cclass;
   int col;
 
-  line = ml_get(pos->lnum);
+  line = (char_u *)ml_get(pos->lnum);
   if (*p_sel == 'e' && pos->col > 0) {
     pos->col--;
-    pos->col -= utf_head_off(line, line + pos->col);
+    pos->col -= utf_head_off((char *)line, (char *)line + pos->col);
   }
   cclass = get_mouse_class(line + pos->col);
   while (line[pos->col] != NUL) {
@@ -2445,7 +2445,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
       this_class = mb_get_class(ptr + col);
     }
     while (col > 0 && this_class != 0) {
-      prevcol = col - 1 - utf_head_off(ptr, ptr + col - 1);
+      prevcol = col - 1 - utf_head_off((char *)ptr, (char *)ptr + col - 1);
       prev_class = mb_get_class(ptr + prevcol);
       if (this_class != prev_class
           && (i == 0
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 4f2b84d20f..adb071b754 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -272,7 +272,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
     // Set "'[" and "']" marks.
     curbuf->b_op_start = oap->start;
     curbuf->b_op_end.lnum = oap->end.lnum;
-    curbuf->b_op_end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+    curbuf->b_op_end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
     if (curbuf->b_op_end.col > 0) {
       curbuf->b_op_end.col--;
     }
@@ -382,7 +382,7 @@ static void shift_block(oparg_T *oap, int amount)
     // TODO(vim): is passing bd.textstart for start of the line OK?
     chartabsize_T cts;
     init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
-                         bd.start_vcol, bd.textstart, bd.textstart);
+                         bd.start_vcol, (char *)bd.textstart, (char *)bd.textstart);
     while (ascii_iswhite(*cts.cts_ptr)) {
       incr = lbr_chartabsize_adv(&cts);
       total += incr;
@@ -448,7 +448,7 @@ static void shift_block(oparg_T *oap, int amount)
 
     chartabsize_T cts;
     init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum,
-                         non_white_col, bd.textstart, non_white);
+                         non_white_col, (char *)bd.textstart, (char *)non_white);
     while (ascii_iswhite(*cts.cts_ptr)) {
       incr = lbr_chartabsize_adv(&cts);
       cts.cts_vcol += incr;
@@ -477,7 +477,7 @@ static void shift_block(oparg_T *oap, int amount)
       verbatim_copy_width -= bd.start_char_vcols;
     }
     init_chartabsize_arg(&cts, curwin, 0, verbatim_copy_width,
-                         bd.textstart, verbatim_copy_end);
+                         (char *)bd.textstart, (char *)verbatim_copy_end);
     while (cts.cts_vcol < destination_col) {
       incr = lbr_chartabsize(&cts);
       if (cts.cts_vcol + incr > destination_col) {
@@ -543,7 +543,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
       continue;  // OP_INSERT, line ends before block start
     }
 
-    oldp = ml_get(lnum);
+    oldp = (char_u *)ml_get(lnum);
 
     if (b_insert) {
       ts_val = bdp->start_char_vcols;
@@ -572,7 +572,7 @@ static void block_insert(oparg_T *oap, char_u *s, int b_insert, struct block_def
 
     if (spaces > 0) {
       // avoid copying part of a multi-byte character
-      offset -= utf_head_off(oldp, oldp + offset);
+      offset -= utf_head_off((char *)oldp, (char *)oldp + offset);
     }
     if (spaces < 0) {  // can happen when the cursor was moved
       spaces = 0;
@@ -1014,7 +1014,7 @@ static int stuff_yank(int regname, char_u *p)
   yankreg_T *reg = get_yank_register(regname, YREG_YANK);
   if (is_append_register(regname) && reg->y_array != NULL) {
     char **pp = &(reg->y_array[reg->y_size - 1]);
-    char_u *lp = xmalloc(STRLEN(*pp) + STRLEN(p) + 1);
+    char_u *lp = xmalloc(strlen(*pp) + STRLEN(p) + 1);
     STRCPY(lp, *pp);
     // TODO(philix): use xstpcpy() in stuff_yank()
     STRCAT(lp, p);
@@ -1513,7 +1513,7 @@ int op_delete(oparg_T *oap)
       && oap->line_count > 1
       && oap->motion_force == NUL
       && oap->op_type == OP_DELETE) {
-    ptr = ml_get(oap->end.lnum) + oap->end.col;
+    ptr = (char_u *)ml_get(oap->end.lnum) + oap->end.col;
     if (*ptr != NUL) {
       ptr += oap->inclusive;
     }
@@ -1617,7 +1617,7 @@ int op_delete(oparg_T *oap)
       // If we delete a TAB, it may be replaced by several characters.
       // Thus the number of characters may increase!
       n = bd.textlen - bd.startspaces - bd.endspaces;
-      oldp = ml_get(lnum);
+      oldp = (char_u *)ml_get(lnum);
       newp = (char_u *)xmalloc(STRLEN(oldp) - (size_t)n + 1);
       // copy up to deleted part
       memmove(newp, oldp, (size_t)bd.textcol);
@@ -1662,7 +1662,7 @@ int op_delete(oparg_T *oap)
         beginline(0);                       // cursor in column 0
       }
 
-      int old_len = (int)STRLEN(ml_get(curwin->w_cursor.lnum));
+      int old_len = (int)strlen(ml_get(curwin->w_cursor.lnum));
       truncate_line(false);         // delete the rest of the line
 
       extmark_splice_cols(curbuf,
@@ -1816,7 +1816,7 @@ setmarks:
 static void mb_adjust_opend(oparg_T *oap)
 {
   if (oap->inclusive) {
-    char *p = (char *)ml_get(oap->end.lnum);
+    char *p = ml_get(oap->end.lnum);
     oap->end.col += utf_cp_tail_off(p, p + oap->end.col);
   }
 }
@@ -1990,7 +1990,7 @@ static int op_replace(oparg_T *oap, int c)
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
       curwin->w_cursor.col = 0;
-      oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+      oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
       if (oap->end.col) {
         oap->end.col--;
       }
@@ -2104,7 +2104,7 @@ void op_tilde(oparg_T *oap)
     if (oap->motion_type == kMTLineWise) {
       oap->start.col = 0;
       pos.col = 0;
-      oap->end.col = (colnr_T)STRLEN(ml_get(oap->end.lnum));
+      oap->end.col = (colnr_T)strlen(ml_get(oap->end.lnum));
       if (oap->end.col) {
         oap->end.col--;
       }
@@ -2281,7 +2281,7 @@ void op_insert(oparg_T *oap, long count1)
     // Get indent information
     ind_pre_col = (colnr_T)getwhitecols_curline();
     ind_pre_vcol = get_indent();
-    firstline = ml_get(oap->start.lnum) + bd.textcol;
+    firstline = (char_u *)ml_get(oap->start.lnum) + bd.textcol;
 
     if (oap->op_type == OP_APPEND) {
       firstline += bd.textlen;
@@ -2413,7 +2413,7 @@ void op_insert(oparg_T *oap, long count1)
      * Subsequent calls to ml_get() flush the firstline data - take a
      * copy of the required string.
      */
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     const size_t len = STRLEN(firstline);
     colnr_T add = bd.textcol;
     colnr_T offset = 0;  // offset when cursor was moved in insert mode
@@ -2498,7 +2498,7 @@ int op_change(oparg_T *oap)
                        || gchar_cursor() == NUL)) {
       coladvance_force(getviscol());
     }
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     pre_textlen = (long)STRLEN(firstline);
     pre_indent = (long)getwhitecols((char *)firstline);
     bd.textcol = curwin->w_cursor.col;
@@ -2519,7 +2519,7 @@ int op_change(oparg_T *oap)
       && oap->start.lnum != oap->end.lnum && !got_int) {
     // Auto-indenting may have changed the indent.  If the cursor was past
     // the indent, exclude that indent change from the inserted text.
-    firstline = ml_get(oap->start.lnum);
+    firstline = (char_u *)ml_get(oap->start.lnum);
     if (bd.textcol > (colnr_T)pre_indent) {
       long new_indent = (long)getwhitecols((char *)firstline);
 
@@ -2547,7 +2547,7 @@ int op_change(oparg_T *oap)
           } else {
             vpos.coladd = 0;
           }
-          oldp = ml_get(linenr);
+          oldp = (char_u *)ml_get(linenr);
           newp = xmalloc(STRLEN(oldp) + (size_t)vpos.coladd
                          + (size_t)ins_len + 1);
           // copy up to block start
@@ -2691,14 +2691,14 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
       break;
 
     case kMTLineWise:
-      reg->y_array[y_idx] = (char *)vim_strsave(ml_get(lnum));
+      reg->y_array[y_idx] = xstrdup(ml_get(lnum));
       break;
 
     case kMTCharWise: {
       colnr_T startcol = 0, endcol = MAXCOL;
       int is_oneChar = false;
       colnr_T cs, ce;
-      p = ml_get(lnum);
+      p = (char_u *)ml_get(lnum);
       bd.startspaces = 0;
       bd.endspaces = 0;
 
@@ -2724,7 +2724,7 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
                                    // Don't add space for double-wide
                                    // char; endcol will be on last byte
                                    // of multi-byte char.
-                                   && utf_head_off(p, p + endcol) == 0)) {
+                                   && utf_head_off((char *)p, (char *)p + endcol) == 0)) {
             if (oap->start.lnum == oap->end.lnum
                 && oap->start.col == oap->end.col) {
               // Special case: inside a single char
@@ -2776,8 +2776,8 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
     // the new block, unless being Vi compatible.
     if (curr->y_type == kMTCharWise
         && vim_strchr(p_cpo, CPO_REGAPPEND) == NULL) {
-      pnew = xmalloc(STRLEN(curr->y_array[curr->y_size - 1])
-                     + STRLEN(reg->y_array[0]) + 1);
+      pnew = xmalloc(strlen(curr->y_array[curr->y_size - 1])
+                     + strlen(reg->y_array[0]) + 1);
       STRCPY(pnew, curr->y_array[--j]);
       STRCAT(pnew, reg->y_array[0]);
       xfree(curr->y_array[j]);
@@ -2857,7 +2857,7 @@ static void yank_copy_line(yankreg_T *reg, struct block_def *bd, size_t y_idx,
     int s = bd->textlen + bd->endspaces;
 
     while (s > 0 && ascii_iswhite(*(bd->textstart + s - 1))) {
-      s = s - utf_head_off(bd->textstart, bd->textstart + s - 1) - 1;
+      s = s - utf_head_off((char *)bd->textstart, (char *)bd->textstart + s - 1) - 1;
       pnew--;
     }
   }
@@ -3299,7 +3299,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       oldlen = STRLEN(oldp);
       chartabsize_T cts;
       init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0,
-                           oldp, oldp);
+                           (char *)oldp, (char *)oldp);
 
       while (cts.cts_vcol < col && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
@@ -3320,7 +3320,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         bd.startspaces = incr - bd.endspaces;
         bd.textcol--;
         delcount = 1;
-        bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
+        bd.textcol -= utf_head_off((char *)oldp, (char *)oldp + bd.textcol);
         if (oldp[bd.textcol] != TAB) {
           /* Only a Tab can be split into spaces.  Other
            * characters will have to be moved to after the
@@ -3336,8 +3336,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         // calculate number of spaces required to fill right side of
         // block
         spaces = y_width + 1;
-        init_chartabsize_arg(&cts, curwin, 0, 0,
-                             (char_u *)y_array[i], (char_u *)y_array[i]);
+        init_chartabsize_arg(&cts, curwin, 0, 0, y_array[i], y_array[i]);
         for (int j = 0; j < yanklen; j++) {
           spaces -= lbr_chartabsize(&cts);
           cts.cts_ptr++;
@@ -3483,7 +3482,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       } else {
         totlen = (size_t)(count * yanklen);
         do {
-          oldp = ml_get(lnum);
+          oldp = (char_u *)ml_get(lnum);
           oldlen = STRLEN(oldp);
           if (lnum > start_lnum) {
             pos_T pos = {
@@ -3510,7 +3509,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           ml_replace(lnum, (char *)newp, false);
 
           // compute the byte offset for the last character
-          first_byte_off = utf_head_off(newp, ptr - 1);
+          first_byte_off = utf_head_off((char *)newp, (char *)ptr - 1);
 
           // Place cursor on last putted char.
           if (lnum == curwin->w_cursor.lnum) {
@@ -3554,7 +3553,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           // First insert y_array[size - 1] in front of second line.
           // Then append y_array[0] to first line.
           lnum = new_cursor.lnum;
-          ptr = ml_get(lnum) + col;
+          ptr = (char_u *)ml_get(lnum) + col;
           totlen = STRLEN(y_array[y_size - 1]);
           newp = (char_u *)xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
           STRCPY(newp, y_array[y_size - 1]);
@@ -3564,7 +3563,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           new_lnum++;
           xfree(newp);
 
-          oldp = ml_get(lnum);
+          oldp = (char_u *)ml_get(lnum);
           newp = (char_u *)xmalloc((size_t)col + (size_t)yanklen + 1);
           // copy first part of line
           memmove(newp, oldp, (size_t)col);
@@ -3588,7 +3587,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           if (flags & PUT_FIXINDENT) {
             old_pos = curwin->w_cursor;
             curwin->w_cursor.lnum = lnum;
-            ptr = ml_get(lnum);
+            ptr = (char_u *)ml_get(lnum);
             if (cnt == count && i == y_size - 1) {
               lendiff = (int)STRLEN(ptr);
             }
@@ -3668,8 +3667,8 @@ error:
       if (col > 1) {
         curbuf->b_op_end.col = col - 1;
         if (len > 0) {
-          curbuf->b_op_end.col -= utf_head_off((char_u *)y_array[y_size - 1],
-                                               (char_u *)y_array[y_size - 1] + len - 1);
+          curbuf->b_op_end.col -= utf_head_off(y_array[y_size - 1],
+                                               y_array[y_size - 1] + len - 1);
         }
       } else {
         curbuf->b_op_end.col = 0;
@@ -3878,14 +3877,14 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '.') != NULL) && !got_int
       && !message_filtered((char *)p)) {
     msg_puts("\n  c  \".   ");
-    dis_msg(p, true);
+    dis_msg((char *)p, true);
   }
 
   // display last command line
   if (last_cmdline != NULL && (arg == NULL || vim_strchr((char *)arg, ':') != NULL)
       && !got_int && !message_filtered(last_cmdline)) {
     msg_puts("\n  c  \":   ");
-    dis_msg((char_u *)last_cmdline, false);
+    dis_msg(last_cmdline, false);
   }
 
   // display current file name
@@ -3893,7 +3892,7 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '%') != NULL) && !got_int
       && !message_filtered(curbuf->b_fname)) {
     msg_puts("\n  c  \"%   ");
-    dis_msg((char_u *)curbuf->b_fname, false);
+    dis_msg(curbuf->b_fname, false);
   }
 
   // display alternate file name
@@ -3903,7 +3902,7 @@ void ex_display(exarg_T *eap)
 
     if (buflist_name_nr(0, &fname, &dummy) != FAIL && !message_filtered(fname)) {
       msg_puts("\n  c  \"#   ");
-      dis_msg((char_u *)fname, false);
+      dis_msg(fname, false);
     }
   }
 
@@ -3912,14 +3911,14 @@ void ex_display(exarg_T *eap)
       && (arg == NULL || vim_strchr((char *)arg, '/') != NULL) && !got_int
       && !message_filtered((char *)last_search_pat())) {
     msg_puts("\n  c  \"/   ");
-    dis_msg(last_search_pat(), false);
+    dis_msg((char *)last_search_pat(), false);
   }
 
   // display last used expression
   if (expr_line != NULL && (arg == NULL || vim_strchr((char *)arg, '=') != NULL)
       && !got_int && !message_filtered((char *)expr_line)) {
     msg_puts("\n  c  \"=   ");
-    dis_msg(expr_line, false);
+    dis_msg((char *)expr_line, false);
   }
 }
 
@@ -3927,7 +3926,7 @@ void ex_display(exarg_T *eap)
 /// truncate at end of screen line
 ///
 /// @param skip_esc  if true, ignore trailing ESC
-static void dis_msg(const char_u *p, bool skip_esc)
+static void dis_msg(const char *p, bool skip_esc)
   FUNC_ATTR_NONNULL_ALL
 {
   int n;
@@ -3936,12 +3935,12 @@ static void dis_msg(const char_u *p, bool skip_esc)
   n = Columns - 6;
   while (*p != NUL
          && !(*p == ESC && skip_esc && *(p + 1) == NUL)
-         && (n -= ptr2cells((char *)p)) >= 0) {
-    if ((l = utfc_ptr2len((char *)p)) > 1) {
-      msg_outtrans_len((char *)p, l);
+         && (n -= ptr2cells(p)) >= 0) {
+    if ((l = utfc_ptr2len(p)) > 1) {
+      msg_outtrans_len(p, l);
       p += l;
     } else {
-      msg_outtrans_len((char *)p++, 1);
+      msg_outtrans_len(p++, 1);
     }
   }
   os_breakcheck();
@@ -3958,11 +3957,11 @@ static void dis_msg(const char_u *p, bool skip_esc)
 /// @param include_space - whether to skip space following the comment leader
 /// @param[out] is_comment - whether the current line ends with an unclosed
 ///  comment.
-char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_comment)
+char *skip_comment(char *line, bool process, bool include_space, bool *is_comment)
 {
   char *comment_flags = NULL;
   int lead_len;
-  int leader_offset = get_last_leader_offset((char *)line, &comment_flags);
+  int leader_offset = get_last_leader_offset(line, &comment_flags);
 
   *is_comment = false;
   if (leader_offset != -1) {
@@ -3984,7 +3983,7 @@ char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_co
     return line;
   }
 
-  lead_len = get_leader_len((char *)line, &comment_flags, false, include_space);
+  lead_len = get_leader_len(line, &comment_flags, false, include_space);
 
   if (lead_len == 0) {
     return line;
@@ -4022,11 +4021,11 @@ char_u *skip_comment(char_u *line, bool process, bool include_space, bool *is_co
 /// @return  FAIL for failure, OK otherwise
 int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions, bool setmark)
 {
-  char_u *curr = NULL;
-  char_u *curr_start = NULL;
-  char_u *cend;
-  char_u *newp;
-  char_u *spaces;          // number of spaces inserted before a line
+  char *curr = NULL;
+  char *curr_start = NULL;
+  char *cend;
+  char *newp;
+  char *spaces;          // number of spaces inserted before a line
   int endcurr1 = NUL;
   int endcurr2 = NUL;
   int currsize = 0;             // size of the current line
@@ -4055,7 +4054,8 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   // Don't move anything, just compute the final line length
   // and setup the array of space strings lengths
   for (t = 0; t < (linenr_T)count; t++) {
-    curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
+    curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t));
+    curr = curr_start;
     if (t == 0 && setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
       // Set the '[ mark.
       curwin->w_buffer->b_op_start.lnum = curwin->w_cursor.lnum;
@@ -4065,8 +4065,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
       // We don't want to remove the comment leader if the
       // previous line is not a comment.
       if (t > 0 && prev_was_comment) {
-        char_u *new_curr = skip_comment(curr, true, insert_space,
-                                        &prev_was_comment);
+        char *new_curr = skip_comment(curr, true, insert_space, &prev_was_comment);
         comments[t] = (int)(new_curr - curr);
         curr = new_curr;
       } else {
@@ -4075,17 +4074,17 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
     }
 
     if (insert_space && t > 0) {
-      curr = (char_u *)skipwhite((char *)curr);
+      curr = skipwhite(curr);
       if (*curr != NUL
           && *curr != ')'
           && sumsize != 0
           && endcurr1 != TAB
           && (!has_format_option(FO_MBYTE_JOIN)
-              || (utf_ptr2char((char *)curr) < 0x100 && endcurr1 < 0x100))
+              || (utf_ptr2char(curr) < 0x100 && endcurr1 < 0x100))
           && (!has_format_option(FO_MBYTE_JOIN2)
-              || (utf_ptr2char((char *)curr) < 0x100 && !utf_eat_space(endcurr1))
+              || (utf_ptr2char(curr) < 0x100 && !utf_eat_space(endcurr1))
               || (endcurr1 < 0x100
-                  && !utf_eat_space(utf_ptr2char((char *)curr))))) {
+                  && !utf_eat_space(utf_ptr2char(curr))))) {
         // don't add a space if the line is ending in a space
         if (endcurr1 == ' ') {
           endcurr1 = endcurr2;
@@ -4112,10 +4111,10 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
     if (insert_space && currsize > 0) {
       cend = curr + currsize;
       MB_PTR_BACK(curr, cend);
-      endcurr1 = utf_ptr2char((char *)cend);
+      endcurr1 = utf_ptr2char(cend);
       if (cend > curr) {
         MB_PTR_BACK(curr, cend);
-        endcurr2 = utf_ptr2char((char *)cend);
+        endcurr2 = utf_ptr2char(cend);
       }
     }
     line_breakcheck();
@@ -4129,7 +4128,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   col = sumsize - currsize - spaces[count - 1];
 
   // allocate the space for the new line
-  newp = (char_u *)xmalloc((size_t)sumsize + 1);
+  newp = xmalloc((size_t)sumsize + 1);
   cend = newp + sumsize;
   *cend = 0;
 
@@ -4165,17 +4164,18 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
       break;
     }
 
-    curr = curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1));
+    curr_start = ml_get((linenr_T)(curwin->w_cursor.lnum + t - 1));
+    curr = curr_start;
     if (remove_comments) {
       curr += comments[t - 1];
     }
     if (insert_space && t > 1) {
-      curr = (char_u *)skipwhite((char *)curr);
+      curr = skipwhite(curr);
     }
     currsize = (int)STRLEN(curr);
   }
 
-  ml_replace(curwin->w_cursor.lnum, (char *)newp, false);
+  ml_replace(curwin->w_cursor.lnum, newp, false);
 
   if (setmark && (cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
     // Set the '] mark.
@@ -4234,11 +4234,11 @@ theend:
 static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool is_del)
 {
   int incr = 0;
-  char_u *pend;
-  char_u *pstart;
-  char_u *line;
-  char_u *prev_pstart;
-  char_u *prev_pend;
+  char *pend;
+  char *pstart;
+  char *line;
+  char *prev_pstart;
+  char *prev_pend;
   const int lbr_saved = curwin->w_p_lbr;
 
   // Avoid a problem with unwanted linebreaks in block mode.
@@ -4271,11 +4271,11 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
       bdp->pre_whitesp = 0;
       bdp->pre_whitesp_c = 0;
     }
-    prev_pstart = (char_u *)cts.cts_ptr;
+    prev_pstart = cts.cts_ptr;
     MB_PTR_ADV(cts.cts_ptr);
   }
   bdp->start_vcol = cts.cts_vcol;
-  pstart = (char_u *)cts.cts_ptr;
+  pstart = cts.cts_ptr;
   clear_chartabsize_arg(&cts);
 
   bdp->start_char_vcols = incr;
@@ -4313,17 +4313,16 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
         }
       }
     } else {
-      init_chartabsize_arg(&cts, curwin, lnum, bdp->end_vcol,
-                           line, pend);
+      init_chartabsize_arg(&cts, curwin, lnum, bdp->end_vcol, line, pend);
       prev_pend = pend;
       while (cts.cts_vcol <= oap->end_vcol && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
-        prev_pend = (char_u *)cts.cts_ptr;
+        prev_pend = cts.cts_ptr;
         incr = lbr_chartabsize_adv(&cts);
         cts.cts_vcol += incr;
       }
       bdp->end_vcol = cts.cts_vcol;
-      pend = (char_u *)cts.cts_ptr;
+      pend = cts.cts_ptr;
       clear_chartabsize_arg(&cts);
 
       if (bdp->end_vcol <= oap->end_vcol
@@ -4356,7 +4355,7 @@ static void block_prep(oparg_T *oap, struct block_def *bdp, linenr_T lnum, bool
     bdp->textlen = (int)(pend - pstart);
   }
   bdp->textcol = (colnr_T)(pstart - line);
-  bdp->textstart = pstart;
+  bdp->textstart = (char_u *)pstart;
   curwin->w_p_lbr = lbr_saved;
 }
 
@@ -4511,7 +4510,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
   }
 
   curwin->w_cursor = *pos;
-  ptr = ml_get(pos->lnum);
+  ptr = (char_u *)ml_get(pos->lnum);
   col = pos->col;
 
   if (*ptr == NUL || col + !!save_coladd >= (int)STRLEN(ptr)) {
@@ -4523,14 +4522,14 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     if (do_bin) {
       while (col > 0 && ascii_isbdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
 
     if (do_hex) {
       while (col > 0 && ascii_isxdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
     if (do_bin
@@ -4538,7 +4537,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
         && !((col > 0
               && (ptr[col] == 'X' || ptr[col] == 'x')
               && ptr[col - 1] == '0'
-              && !utf_head_off(ptr, ptr + col - 1)
+              && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
               && ascii_isxdigit(ptr[col + 1])))) {
       // In case of binary/hexadecimal pattern overlap match, rescan
 
@@ -4546,7 +4545,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
 
       while (col > 0 && ascii_isdigit(ptr[col])) {
         col--;
-        col -= utf_head_off(ptr, ptr + col);
+        col -= utf_head_off((char *)ptr, (char *)ptr + col);
       }
     }
 
@@ -4554,17 +4553,17 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
          && col > 0
          && (ptr[col] == 'X' || ptr[col] == 'x')
          && ptr[col - 1] == '0'
-         && !utf_head_off(ptr, ptr + col - 1)
+         && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
          && ascii_isxdigit(ptr[col + 1]))
         || (do_bin
             && col > 0
             && (ptr[col] == 'B' || ptr[col] == 'b')
             && ptr[col - 1] == '0'
-            && !utf_head_off(ptr, ptr + col - 1)
+            && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
             && ascii_isbdigit(ptr[col + 1]))) {
       // Found hexadecimal or binary number, move to its start.
       col--;
-      col -= utf_head_off(ptr, ptr + col);
+      col -= utf_head_off((char *)ptr, (char *)ptr + col);
     } else {
       // Search forward and then backward to find the start of number.
       col = pos->col;
@@ -4597,7 +4596,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     }
 
     if (col > pos->col && ptr[col - 1] == '-'
-        && !utf_head_off(ptr, ptr + col - 1)
+        && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
         && !do_unsigned) {
       negative = true;
       was_positive = false;
@@ -4643,7 +4642,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
     curwin->w_cursor.col = col;
   } else {
     if (col > 0 && ptr[col - 1] == '-'
-        && !utf_head_off(ptr, ptr + col - 1)
+        && !utf_head_off((char *)ptr, (char *)ptr + col - 1)
         && !visual
         && !do_unsigned) {
       // negative number
@@ -5036,7 +5035,7 @@ static void finish_write_reg(int name, yankreg_T *reg, yankreg_T *old_y_previous
 /// store `str` in register `name`
 ///
 /// @see write_reg_contents_ex
-void write_reg_contents(int name, const char_u *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);
 }
@@ -5045,9 +5044,9 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
                             colnr_T block_len)
 {
   if (name == '/' || name == '=') {
-    char_u *s = (char_u *)strings[0];
+    char *s = strings[0];
     if (strings[0] == NULL) {
-      s = (char_u *)"";
+      s = "";
     } else if (strings[1] != NULL) {
       emsg(_("E883: search pattern and expression register may not "
              "contain two or more lines"));
@@ -5067,7 +5066,7 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
     return;
   }
 
-  str_to_reg(reg, yank_type, (char *)strings, STRLEN((char_u *)strings),
+  str_to_reg(reg, yank_type, (char *)strings, STRLEN(strings),
              block_len, true);
   finish_write_reg(name, reg, old_y_previous);
 }
@@ -5090,7 +5089,7 @@ void write_reg_contents_lst(int name, char **strings, bool must_append, MotionTy
 ///                    is an uppercase letter.
 /// @param yank_type The motion type (kMTUnknown to auto detect)
 /// @param block_len width of visual block
-void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_append,
+void write_reg_contents_ex(int name, const char *str, ssize_t len, bool must_append,
                            MotionType yank_type, colnr_T block_len)
 {
   if (len < 0) {
@@ -5099,7 +5098,7 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
 
   // Special case: '/' search pattern
   if (name == '/') {
-    set_last_search_pat(str, RE_SEARCH, true, true);
+    set_last_search_pat((char_u *)str, RE_SEARCH, true, true);
     return;
   }
 
@@ -5107,14 +5106,14 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
     buf_T *buf;
 
     if (ascii_isdigit(*str)) {
-      int num = atoi((char *)str);
+      int num = atoi(str);
 
       buf = buflist_findnr(num);
       if (buf == NULL) {
         semsg(_(e_nobufnr), (int64_t)num);
       }
     } else {
-      buf = buflist_findnr(buflist_findpat((char *)str, (char *)str + STRLEN(str),
+      buf = buflist_findnr(buflist_findpat(str, str + STRLEN(str),
                                            true, false, false));
     }
     if (buf == NULL) {
@@ -5155,7 +5154,7 @@ void write_reg_contents_ex(int name, const char_u *str, ssize_t len, bool must_a
   if (!(reg = init_write_reg(name, &old_y_previous, must_append))) {
     return;
   }
-  str_to_reg(reg, yank_type, (char *)str, (size_t)len, block_len, false);
+  str_to_reg(reg, yank_type, str, (size_t)len, block_len, false);
   finish_write_reg(name, reg, old_y_previous);
 }
 
@@ -5425,7 +5424,7 @@ void cursor_pos_info(dict_T *dict)
           len = (long)bd.textlen;
           break;
         case 'V':
-          s = ml_get(lnum);
+          s = (char_u *)ml_get(lnum);
           len = MAXCOL;
           break;
         case 'v': {
@@ -5434,7 +5433,7 @@ void cursor_pos_info(dict_T *dict)
           colnr_T end_col = (lnum == max_pos.lnum)
                             ? max_pos.col - start_col + 1 : MAXCOL;
 
-          s = ml_get(lnum) + start_col;
+          s = (char_u *)ml_get(lnum) + start_col;
           len = end_col;
         }
         break;
@@ -5455,14 +5454,14 @@ void cursor_pos_info(dict_T *dict)
           word_count_cursor += word_count;
           char_count_cursor += char_count;
           byte_count_cursor = byte_count
-                              + line_count_info(ml_get(lnum), &word_count_cursor,
+                              + line_count_info((char_u *)ml_get(lnum), &word_count_cursor,
                                                 &char_count_cursor,
                                                 (varnumber_T)curwin->w_cursor.col + 1,
                                                 eol_size);
         }
       }
       // Add to the running totals
-      byte_count += line_count_info(ml_get(lnum), &word_count, &char_count,
+      byte_count += line_count_info((char_u *)ml_get(lnum), &word_count, &char_count,
                                     (varnumber_T)MAXCOL, eol_size);
     }
 
diff --git a/src/nvim/os/fs.c b/src/nvim/os/fs.c
index c0d5616666..158c22efaf 100644
--- a/src/nvim/os/fs.c
+++ b/src/nvim/os/fs.c
@@ -821,10 +821,10 @@ int os_fchown(int fd, uv_uid_t owner, uv_gid_t group)
 /// Check if a path exists.
 ///
 /// @return `true` if `path` exists
-bool os_path_exists(const char_u *path)
+bool os_path_exists(const char *path)
 {
   uv_stat_t statbuf;
-  return os_stat((char *)path, &statbuf) == kLibuvSuccess;
+  return os_stat(path, &statbuf) == kLibuvSuccess;
 }
 
 /// Sets file access and modification times.
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 461a79c37b..35390e3dc1 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -503,7 +503,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
   // Move the file names to allocated memory.
   for (j = 0, i = 0; i < *num_file; i++) {
     // Require the files to exist. Helps when using /bin/sh
-    if (!(flags & EW_NOTFOUND) && !os_path_exists((char_u *)(*file)[i])) {
+    if (!(flags & EW_NOTFOUND) && !os_path_exists((*file)[i])) {
       continue;
     }
 
@@ -1112,7 +1112,7 @@ static void out_data_append_to_screen(char *output, size_t *count, bool eof)
         goto end;
       }
 
-      (void)msg_outtrans_len_attr((char_u *)p, i, 0);
+      (void)msg_outtrans_len_attr(p, i, 0);
       p += i;
     }
   }
@@ -1208,7 +1208,7 @@ static void read_input(DynamicBuffer *buf)
 {
   size_t written = 0, l = 0, len = 0;
   linenr_T lnum = curbuf->b_op_start.lnum;
-  char_u *lp = ml_get(lnum);
+  char_u *lp = (char_u *)ml_get(lnum);
 
   for (;;) {
     l = strlen((char *)lp + written);
@@ -1240,7 +1240,7 @@ static void read_input(DynamicBuffer *buf)
       if (lnum > curbuf->b_op_end.lnum) {
         break;
       }
-      lp = ml_get(lnum);
+      lp = (char_u *)ml_get(lnum);
       written = 0;
     } else if (len > 0) {
       written += len;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index a5cec6772f..5bbcbc7144 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -755,8 +755,9 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
             backslash_halve((char *)buf + len + 1);
           }
           // add existing file or symbolic link
-          if ((flags & EW_ALLLINKS) ? os_fileinfo_link((char *)buf, &file_info)
-                                    : os_path_exists(buf)) {
+          if ((flags & EW_ALLLINKS)
+              ? os_fileinfo_link((char *)buf, &file_info)
+              : os_path_exists((char *)buf)) {
             addfile(gap, buf, flags);
           }
         }
@@ -1461,7 +1462,7 @@ void addfile(garray_T *gap, char_u *f, int flags)
   if (!(flags & EW_NOTFOUND)
       && ((flags & EW_ALLLINKS)
           ? !os_fileinfo_link((char *)f, &file_info)
-          : !os_path_exists(f))) {
+          : !os_path_exists((char *)f))) {
     return;
   }
 
@@ -1926,7 +1927,7 @@ void path_fix_case(char *name)
   while ((entry = (char *)os_scandir_next(&dir))) {
     // Only accept names that differ in case and are the same byte
     // length. TODO: accept different length name.
-    if (STRICMP(tail, entry) == 0 && STRLEN(tail) == STRLEN(entry)) {
+    if (STRICMP(tail, entry) == 0 && strlen(tail) == strlen(entry)) {
       char_u newname[MAXPATHL + 1];
 
       // Verify the inode is equal.
@@ -1951,7 +1952,7 @@ void path_fix_case(char *name)
 int after_pathsep(const char *b, const char *p)
 {
   return p > b && vim_ispathsep(p[-1])
-         && utf_head_off((char_u *)b, (char_u *)p - 1) == 0;
+         && utf_head_off(b, p - 1) == 0;
 }
 
 /// Return true if file names "f1" and "f2" are in the same directory.
@@ -2272,7 +2273,7 @@ int path_full_dir_name(char *directory, char *buffer, size_t len)
   int SUCCESS = 0;
   int retval = OK;
 
-  if (STRLEN(directory) == 0) {
+  if (strlen(directory) == 0) {
     return os_dirname((char_u *)buffer, len);
   }
 
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index cc730ba307..3ba09b45a1 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -149,7 +149,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
   colnr_T col = 0;
   chartabsize_T cts;
 
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   while (*cts.cts_ptr != NUL && --column >= 0) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
     MB_PTR_ADV(cts.cts_ptr);
@@ -257,7 +257,7 @@ int linetabsize(char_u *s)
 int linetabsize_col(int startcol, char *s)
 {
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, curwin, 0, startcol, (char_u *)s, (char_u *)s);
+  init_chartabsize_arg(&cts, curwin, 0, startcol, s, s);
   while (*cts.cts_ptr != NUL) {
     cts.cts_vcol += lbr_chartabsize_adv(&cts);
   }
@@ -275,7 +275,7 @@ int linetabsize_col(int startcol, char *s)
 unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len)
 {
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, lnum, 0, line, line);
+  init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   for (; *cts.cts_ptr != NUL && (len == MAXCOL || cts.cts_ptr < (char *)line + len);
        MB_PTR_ADV(cts.cts_ptr)) {
     cts.cts_vcol += win_lbr_chartabsize(&cts, NULL);
@@ -288,14 +288,14 @@ unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len
 ///
 /// "line" is the start of the line, "ptr" is the first relevant character.
 /// When "lnum" is zero do not use text properties that insert text.
-void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char_u *line,
-                          char_u *ptr)
+void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char *line,
+                          char *ptr)
 {
   cts->cts_win = wp;
   cts->cts_lnum = lnum;
   cts->cts_vcol = col;
-  cts->cts_line = (char *)line;
-  cts->cts_ptr = (char *)ptr;
+  cts->cts_line = line;
+  cts->cts_ptr = ptr;
   cts->cts_cur_text_width = 0;
   // TODO(bfredl): actually lookup inline virtual text here
   cts->cts_has_virt_text = false;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f9c4892b91..f1fc48ef40 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1250,7 +1250,7 @@ static int qf_parse_fmt_f(regmatch_T *rmp, int midx, qffields_T *fields, int pre
   // For separate filename patterns (%O, %P and %Q), the specified file
   // should exist.
   if (vim_strchr("OPQ", prefix) != NULL
-      && !os_path_exists((char_u *)fields->namebuf)) {
+      && !os_path_exists(fields->namebuf)) {
     return QF_FAIL;
   }
 
@@ -1564,7 +1564,7 @@ static int qf_parse_dir_pfx(int idx, qffields_T *fields, qf_list_T *qfl)
 static int qf_parse_file_pfx(int idx, qffields_T *fields, qf_list_T *qfl, char *tail)
 {
   fields->valid = false;
-  if (*fields->namebuf == NUL || os_path_exists((char_u *)fields->namebuf)) {
+  if (*fields->namebuf == NUL || os_path_exists(fields->namebuf)) {
     if (*fields->namebuf && idx == 'P') {
       qfl->qf_currfile = qf_push_dir(fields->namebuf, &qfl->qf_file_stack, true);
     } else if (idx == 'Q') {
@@ -2069,7 +2069,7 @@ static int qf_get_fnum(qf_list_T *qfl, char *directory, char *fname)
     // This should normally be true, but if make works without
     // "leaving directory"-messages we might have missed a
     // directory change.
-    if (!os_path_exists((char_u *)ptr)) {
+    if (!os_path_exists(ptr)) {
       xfree(ptr);
       directory = qf_guess_filepath(qfl, fname);
       if (directory) {
@@ -2223,7 +2223,7 @@ static char *qf_guess_filepath(qf_list_T *qfl, char *filename)
     xfree(fullname);
     fullname = concat_fnames(ds_ptr->dirname, filename, true);
 
-    if (os_path_exists((char_u *)fullname)) {
+    if (os_path_exists(fullname)) {
       break;
     }
 
@@ -3089,7 +3089,7 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   qf_fmt_text((fname != NULL || qfp->qf_lnum != 0)
               ? skipwhite(qfp->qf_text) : qfp->qf_text,
               (char *)tbuf, (int)tbuflen);
-  msg_prt_line(tbuf, false);
+  msg_prt_line((char *)tbuf, false);
 
   if (tbuf != IObuff) {
     xfree(tbuf);
@@ -5075,7 +5075,7 @@ static void vgr_init_regmatch(regmmatch_T *regmatch, char *s)
 static void vgr_display_fname(char *fname)
 {
   msg_start();
-  char *p = (char *)msg_strtrunc((char_u *)fname, true);
+  char *p = msg_strtrunc(fname, true);
   if (p == NULL) {
     msg_outtrans(fname);
   } else {
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index a52343e28b..f471f1c8e0 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1093,7 +1093,7 @@ void unref_extmatch(reg_extmatch_T *em)
 static int reg_prev_class(void)
 {
   if (rex.input > rex.line) {
-    return mb_get_class_tab(rex.input - 1 - utf_head_off(rex.line, rex.input - 1),
+    return mb_get_class_tab(rex.input - 1 - utf_head_off((char *)rex.line, (char *)rex.input - 1),
                             rex.reg_buf->b_chartab);
   }
   return -1;
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index 88f0d781af..b951df69d6 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -4765,8 +4765,8 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
                 reg_getline(rp->rs_un.regsave.rs_u.pos.lnum);
 
               rp->rs_un.regsave.rs_u.pos.col -=
-                utf_head_off(line,
-                             line + rp->rs_un.regsave.rs_u.pos.col - 1)
+                utf_head_off((char *)line,
+                             (char *)line + rp->rs_un.regsave.rs_u.pos.col - 1)
                 + 1;
             }
           } else {
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index d4db710d93..e1327ce155 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -5595,7 +5595,7 @@ static int recursive_regmatch(nfa_state_T *state, nfa_pim_T *pim, nfa_regprog_T
       }
       if ((int)(rex.input - rex.line) >= state->val) {
         rex.input -= state->val;
-        rex.input -= utf_head_off(rex.line, rex.input);
+        rex.input -= utf_head_off((char *)rex.line, (char *)rex.input);
       } else {
         rex.input = rex.line;
       }
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index e85167f8fd..a38f743081 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -1822,7 +1822,7 @@ static void cmd_source_buffer(const exarg_T *const eap)
     if (ga.ga_len > 400) {
       ga_set_growsize(&ga, MIN(ga.ga_len, 8000));
     }
-    ga_concat(&ga, (char *)ml_get(curr_lnum));
+    ga_concat(&ga, ml_get(curr_lnum));
     ga_append(&ga, NL);
   }
   ((char *)ga.ga_data)[ga.ga_len - 1] = NUL;
diff --git a/src/nvim/search.c b/src/nvim/search.c
index e995081df8..d7f8d4e1cd 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -853,7 +853,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
               pos->col--;
               if (pos->lnum <= buf->b_ml.ml_line_count) {
                 ptr = ml_get_buf(buf, pos->lnum, false);
-                pos->col -= utf_head_off(ptr, ptr + pos->col);
+                pos->col -= utf_head_off((char *)ptr, (char *)ptr + pos->col);
               }
             }
             if (end_pos != NULL) {
@@ -1250,7 +1250,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
           memmove(msgbuf + STRLEN(p) + 1, off_buf, off_len);
         }
 
-        trunc = msg_strtrunc(msgbuf, true);
+        trunc = (char_u *)msg_strtrunc((char *)msgbuf, true);
         if (trunc != NULL) {
           xfree(msgbuf);
           msgbuf = trunc;
@@ -1589,7 +1589,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
         if (col == 0) {
           return FAIL;
         }
-        col -= utf_head_off(p, p + col - 1) + 1;
+        col -= utf_head_off((char *)p, (char *)p + col - 1) + 1;
       }
       if (lastc_bytelen == 1) {
         if (p[col] == c && stop) {
@@ -1610,7 +1610,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
       col += lastc_bytelen - 1;
     } else {
       // To previous char, which may be multi-byte.
-      col -= utf_head_off(p, p + col);
+      col -= utf_head_off((char *)p, (char *)p + col);
     }
   }
   curwin->w_cursor.col = col;
@@ -1641,7 +1641,7 @@ static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol)
 {
   col--;
   if (col > 0) {
-    col -= utf_head_off(linep, linep + col);
+    col -= utf_head_off((char *)linep, (char *)linep + col);
   }
   if (prevcol) {
     *prevcol = col;
@@ -1664,7 +1664,7 @@ static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos)
   char_u *delim_copy = vim_strnsave(linep + startpos->col + 1, delim_len);
   bool found = false;
   for (lnum = startpos->lnum; lnum <= endpos->lnum; lnum++) {
-    char_u *line = ml_get(lnum);
+    char_u *line = (char_u *)ml_get(lnum);
 
     for (p = line + (lnum == startpos->lnum ? startpos->col + 1 : 0); *p; p++) {
       if (lnum == endpos->lnum && (colnr_T)(p - line) >= endpos->col) {
@@ -1768,7 +1768,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 
   pos = curwin->w_cursor;
   pos.coladd = 0;
-  char_u *linep = ml_get(pos.lnum);     // pointer to current line
+  char_u *linep = (char_u *)ml_get(pos.lnum);     // pointer to current line
 
   // vi compatible matching
   bool cpo_match = (vim_strchr(p_cpo, CPO_MATCH) != NULL);
@@ -1923,7 +1923,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
         pos.lnum += hash_dir;
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         line_breakcheck();              // check for CTRL-C typed
         ptr = (char_u *)skipwhite((char *)linep);
         if (*ptr != '#') {
@@ -2003,7 +2003,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
 
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         pos.col = (colnr_T)STRLEN(linep);         // pos.col on trailing NUL
         do_quotes = -1;
         line_breakcheck();
@@ -2018,7 +2018,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
         }
       } else {
         pos.col--;
-        pos.col -= utf_head_off(linep, linep + pos.col);
+        pos.col -= utf_head_off((char *)linep, (char *)linep + pos.col);
       }
     } else {                          // forward search
       if (linep[pos.col] == NUL
@@ -2038,7 +2038,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           break;
         }
 
-        linep = ml_get(pos.lnum);
+        linep = (char_u *)ml_get(pos.lnum);
         pos.col = 0;
         do_quotes = -1;
         line_breakcheck();
@@ -2088,7 +2088,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
               match_pos = pos;
               match_pos.col--;
             }
-            linep = ml_get(pos.lnum);  // may have been released
+            linep = (char_u *)ml_get(pos.lnum);  // may have been released
           }
         } else if (linep[pos.col - 1] == '/'
                    && linep[pos.col] == '*'
@@ -2158,7 +2158,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           }
         }
         if (pos.lnum > 1) {
-          ptr = ml_get(pos.lnum - 1);
+          ptr = (char_u *)ml_get(pos.lnum - 1);
           if (*ptr && *(ptr + STRLEN(ptr) - 1) == '\\') {
             do_quotes = 1;
             if (start_in_quotes == kNone) {
@@ -2172,7 +2172,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           }
 
           // ml_get() only keeps one line, need to get linep again
-          linep = ml_get(pos.lnum);
+          linep = (char_u *)ml_get(pos.lnum);
         }
       }
     }
@@ -2648,7 +2648,7 @@ int linewhite(linenr_T lnum)
 {
   char_u *p;
 
-  p = (char_u *)skipwhite((char *)ml_get(lnum));
+  p = (char_u *)skipwhite(ml_get(lnum));
   return *p == NUL;
 }
 
@@ -3488,7 +3488,7 @@ void f_matchfuzzypos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// mark.
 static char_u *get_line_and_copy(linenr_T lnum, char_u *buf)
 {
-  char_u *line = ml_get(lnum);
+  char_u *line = (char_u *)ml_get(lnum);
   STRLCPY(buf, line, LSIZE);
   return buf;
 }
@@ -3625,7 +3625,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
               msg_putchar('\n');  // cursor below last one */
               if (!got_int) {  // don't display if 'q' typed at "--more--"
                                // message
-                msg_home_replace_hl(new_fname);
+                msg_home_replace_hl((char *)new_fname);
                 msg_puts(_(" (includes previously listed match)"));
                 prev_fname = NULL;
               }
@@ -3655,7 +3655,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
           for (i = 0; i < depth_displayed; i++) {
             msg_puts("  ");
           }
-          msg_home_replace(files[depth_displayed].name);
+          msg_home_replace((char *)files[depth_displayed].name);
           msg_puts(" -->\n");
         }
         if (!got_int) {                     // don't display if 'q' typed
@@ -3937,7 +3937,7 @@ search_line:
           }
           if (!got_int) {             // don't display if 'q' typed
                                       // at "--more--" message
-            msg_home_replace_hl(curr_fname);
+            msg_home_replace_hl((char *)curr_fname);
           }
           prev_fname = curr_fname;
         }
@@ -4146,7 +4146,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       msg_puts_attr((const char *)IObuff, HL_ATTR(HLF_N));
       msg_puts(" ");
     }
-    msg_prt_line(line, false);
+    msg_prt_line((char *)line, false);
     ui_flush();                        // show one line at a time
 
     // Definition continues until line that doesn't end with '\'
@@ -4163,7 +4163,7 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       if (++*lnum > curbuf->b_ml.ml_line_count) {
         break;
       }
-      line = ml_get(*lnum);
+      line = (char_u *)ml_get(*lnum);
     }
     msg_putchar('\n');
   }
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 1259736e0e..d8bc4b22c2 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -571,7 +571,7 @@ static void find_word(matchinf_T *mip, int mode)
     arridx = endidx[endidxcnt];
     wlen = endlen[endidxcnt];
 
-    if (utf_head_off(ptr, ptr + wlen) > 0) {
+    if (utf_head_off((char *)ptr, (char *)ptr + wlen) > 0) {
       continue;             // not at first byte of character
     }
     if (spell_iswordp(ptr + wlen, mip->mi_win)) {
@@ -2479,7 +2479,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
     if (lnum == 1) {
       need_cap = true;
     } else {
-      line = ml_get(lnum - 1);
+      line = (char_u *)ml_get(lnum - 1);
       if (*skipwhite((char *)line) == NUL) {
         need_cap = true;
       } else {
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 0f8034312e..c472cac27d 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -3197,7 +3197,7 @@ static int spell_read_dic(spellinfo_T *spin, char_u *fname, afffile_T *affile)
                      _("line %6d, word %6ld - %s"),
                      lnum, spin->si_foldwcount + spin->si_keepwcount, w);
         msg_start();
-        msg_outtrans_long_attr(message, 0);
+        msg_outtrans_long_attr((char *)message, 0);
         msg_clr_eos();
         msg_didout = false;
         msg_col = 0;
@@ -5339,7 +5339,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
   } else {
     // Check for overwriting before doing things that may take a lot of
     // time.
-    if (!over_write && os_path_exists((char_u *)wfname)) {
+    if (!over_write && os_path_exists(wfname)) {
       emsg(_(e_exists));
       goto theend;
     }
@@ -5389,7 +5389,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       spin.si_region = 1 << i;
 
       vim_snprintf((char *)fname, MAXPATHL, "%s.aff", innames[i]);
-      if (os_path_exists(fname)) {
+      if (os_path_exists((char *)fname)) {
         // Read the .aff file.  Will init "spin->si_conv" based on the
         // "SET" line.
         afile[i] = spell_read_aff(&spin, fname);
@@ -5500,7 +5500,7 @@ static void spell_message(const spellinfo_T *spin, char *str)
 // ":[count]spellrare  {word}"
 void ex_spell(exarg_T *eap)
 {
-  spell_add_word((char_u *)eap->arg, (int)STRLEN(eap->arg),
+  spell_add_word((char_u *)eap->arg, (int)strlen(eap->arg),
                  eap->cmdidx == CMD_spellwrong ? SPELL_ADD_BAD :
                  eap->cmdidx == CMD_spellrare ? SPELL_ADD_RARE : SPELL_ADD_GOOD,
                  eap->forceit ? 0 : (int)eap->line2,
@@ -5810,7 +5810,7 @@ static int write_spell_prefcond(FILE *fd, garray_T *gap, size_t *fwv)
     // <prefcond> : <condlen> <condstr>
     char *p = ((char **)gap->ga_data)[i];
     if (p != NULL) {
-      size_t len = STRLEN(p);
+      size_t len = strlen(p);
       if (fd != NULL) {
         assert(len <= INT_MAX);
         fputc((int)len, fd);
@@ -5873,7 +5873,7 @@ static void set_map_str(slang_T *lp, char_u *map)
         utf_char2bytes(headc, b + cl + 1);
         b[cl + 1 + headcl] = NUL;
         hash = hash_hash((char_u *)b);
-        hi = hash_lookup(&lp->sl_map_hash, (const char *)b, STRLEN(b), hash);
+        hi = hash_lookup(&lp->sl_map_hash, (const char *)b, strlen(b), hash);
         if (HASHITEM_EMPTY(hi)) {
           hash_add_item(&lp->sl_map_hash, hi, (char_u *)b, hash);
         } else {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index f055cc9b0e..1319894226 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -610,7 +610,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
      * Skip lines that end in a backslash.
      */
     for (; start_lnum > 1; start_lnum--) {
-      line = ml_get(start_lnum - 1);
+      line = (char_u *)ml_get(start_lnum - 1);
       if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
         break;
       }
@@ -1711,7 +1711,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         const char_u *cur_pos = line + current_col;
         if (vim_iswordp_buf(cur_pos, syn_buf)
             && (current_col == 0
-                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off(line, cur_pos - 1),
+                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off((char *)line, (char *)cur_pos - 1),
                                     syn_buf))) {
           syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
                                     &next_list, cur_si, &cchar);
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 5270412382..4fd99b058b 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -742,7 +742,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
                        (int)(tagp.tagkind_end - tagp.tagkind));
     }
     msg_advance(13);
-    msg_outtrans_len_attr(tagp.tagname,
+    msg_outtrans_len_attr((char *)tagp.tagname,
                           (int)(tagp.tagname_end - tagp.tagname),
                           HL_ATTR(HLF_T));
     msg_putchar(' ');
@@ -1230,7 +1230,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
         continue;
       }
 
-      len += STRLEN(tv->vval.v_string) + 1;   // Space for "\tVALUE"
+      len += strlen(tv->vval.v_string) + 1;   // Space for "\tVALUE"
       if (!STRCMP(dict_key, "name")) {
         res_name = (char_u *)tv->vval.v_string;
         continue;
@@ -1497,7 +1497,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
     curbuf->b_help = false;
   }
 
-  orgpat.len = (int)STRLEN(pat);
+  orgpat.len = (int)strlen(pat);
   if (curbuf->b_help) {
     // When "@ab" is specified use only the "ab" language, otherwise
     // search all languages.
@@ -1550,7 +1550,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
   if ((flags & TAG_KEEP_LANG)
       && help_lang_find == NULL
       && curbuf->b_fname != NULL
-      && (i = (int)STRLEN(curbuf->b_fname)) > 4
+      && (i = (int)strlen(curbuf->b_fname)) > 4
       && STRICMP(curbuf->b_fname + i - 4, ".txt") == 0) {
     is_txt = true;
   }
@@ -1595,7 +1595,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
           if ((flags & TAG_KEEP_LANG)
               && help_lang_find == NULL
               && curbuf->b_fname != NULL
-              && (i = (int)STRLEN(curbuf->b_fname)) > 4
+              && (i = (int)strlen(curbuf->b_fname)) > 4
               && curbuf->b_fname[i - 1] == 'x'
               && curbuf->b_fname[i - 4] == '.'
               && STRNICMP(curbuf->b_fname + i - 3, help_lang, 2) == 0) {
@@ -2174,7 +2174,7 @@ parse_line:
               hash = hash_hash((char_u *)mfp);
             }
             hi = hash_lookup(&ht_match[mtt], (const char *)mfp,
-                             STRLEN(mfp), hash);
+                             strlen(mfp), hash);
             if (HASHITEM_EMPTY(hi)) {
               hash_add_item(&ht_match[mtt], hi, (char_u *)mfp, hash);
               ga_grow(&ga_match[mtt], 1);
@@ -2713,7 +2713,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
    * file.  Also accept a file name for which there is a matching BufReadCmd
    * autocommand event (e.g., http://sys/file).
    */
-  if (!os_path_exists(fname)
+  if (!os_path_exists((char *)fname)
       && !has_autocmd(EVENT_BUFREADCMD, (char *)fname,
                       NULL)) {
     retval = NOTAGFILE;
@@ -3168,7 +3168,7 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
   char_u *buf = xmalloc(MAXPATHL);
   if (start != NULL) {
     if (end == NULL) {
-      end = start + STRLEN(start);
+      end = start + strlen(start);
       while (end > start && (end[-1] == '\r' || end[-1] == '\n')) {
         end--;
       }
@@ -3180,7 +3180,7 @@ static int add_tag_field(dict_T *dict, const char *field_name, const char *start
     STRLCPY(buf, start, len + 1);
   }
   buf[len] = NUL;
-  retval = tv_dict_add_str(dict, field_name, STRLEN(field_name),
+  retval = tv_dict_add_str(dict, field_name, strlen(field_name),
                            (const char *)buf);
   xfree(buf);
   return retval;
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 125146f712..5ded0c9ab2 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -470,7 +470,7 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags,
   char_u *flags = NULL;        // init for GCC
   char_u *ptr;
 
-  ptr = ml_get(lnum);
+  ptr = (char_u *)ml_get(lnum);
   if (do_comments) {
     *leader_len = get_leader_len((char *)ptr, (char **)leader_flags, false, true);
   } else {
@@ -493,7 +493,7 @@ static int fmt_check_par(linenr_T lnum, int *leader_len, char_u **leader_flags,
 /// @return  true if line "lnum" ends in a white character.
 static bool ends_in_white(linenr_T lnum)
 {
-  char_u *s = ml_get(lnum);
+  char_u *s = (char_u *)ml_get(lnum);
   size_t l;
 
   if (*s == NUL) {
@@ -552,9 +552,9 @@ static bool same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, i
 
   // Get current line and next line, compare the leaders.
   // The first line has to be saved, only one line can be locked at a time.
-  line1 = vim_strsave(ml_get(lnum));
+  line1 = vim_strsave((char_u *)ml_get(lnum));
   for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
-  line2 = ml_get(lnum + 1);
+  line2 = (char_u *)ml_get(lnum + 1);
   for (idx2 = 0; idx2 < leader2_len; idx2++) {
     if (!ascii_iswhite(line2[idx2])) {
       if (line1[idx1++] != line2[idx2]) {
@@ -586,7 +586,7 @@ static bool paragraph_start(linenr_T lnum)
   if (lnum <= 1) {
     return true;                // start of the file
   }
-  p = ml_get(lnum - 1);
+  p = (char_u *)ml_get(lnum - 1);
   if (*p == NUL) {
     return true;                // after empty line
   }
diff --git a/src/nvim/textobject.c b/src/nvim/textobject.c
index 02174edeb1..a8f4cc7aeb 100644
--- a/src/nvim/textobject.c
+++ b/src/nvim/textobject.c
@@ -213,13 +213,13 @@ bool findpar(bool *pincl, int dir, long count, int what, bool both)
   }
   curwin->w_cursor.lnum = curr;
   if (curr == curbuf->b_ml.ml_line_count && what != '}') {
-    char_u *line = ml_get(curr);
+    char_u *line = (char_u *)ml_get(curr);
 
     // Put the cursor on the last character in the last line and make the
     // motion inclusive.
     if ((curwin->w_cursor.col = (colnr_T)STRLEN(line)) != 0) {
       curwin->w_cursor.col--;
-      curwin->w_cursor.col -= utf_head_off(line, line + curwin->w_cursor.col);
+      curwin->w_cursor.col -= utf_head_off((char *)line, (char *)line + curwin->w_cursor.col);
       *pincl = true;
     }
   } else {
@@ -260,7 +260,7 @@ bool startPS(linenr_T lnum, int para, bool both)
 {
   char_u *s;
 
-  s = ml_get(lnum);
+  s = (char_u *)ml_get(lnum);
   if (*s == para || *s == '\f' || (both && *s == '}')) {
     return true;
   }
@@ -1467,7 +1467,7 @@ static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *e
 
   while (col_start > 0) {
     col_start--;
-    col_start -= utf_head_off(line, line + col_start);
+    col_start -= utf_head_off((char *)line, (char *)line + col_start);
     n = 0;
     if (escape != NULL) {
       while (col_start - n > 0 && vim_strchr((char *)escape,
diff --git a/src/nvim/tui/terminfo.c b/src/nvim/tui/terminfo.c
index ce48059b94..229e340dc3 100644
--- a/src/nvim/tui/terminfo.c
+++ b/src/nvim/tui/terminfo.c
@@ -189,7 +189,7 @@ void terminfo_info_msg(const unibi_term *const ut)
       msg_printf_attr(0, "  %-25s %-10s = ", unibi_name_str(i),
                       unibi_short_name_str(i));
       // Most of these strings will contain escape sequences.
-      msg_outtrans_special((char_u *)s, false, 0);
+      msg_outtrans_special(s, false, 0);
       msg_putchar('\n');
     }
   }
@@ -216,7 +216,7 @@ void terminfo_info_msg(const unibi_term *const ut)
     msg_puts("Extended string capabilities:\n");
     for (size_t i = 0; i < unibi_count_ext_str(ut); i++) {
       msg_printf_attr(0, "  %-25s = ", unibi_get_ext_str_name(ut, i));
-      msg_outtrans_special((char_u *)unibi_get_ext_str(ut, i), false, 0);
+      msg_outtrans_special(unibi_get_ext_str(ut, i), false, 0);
       msg_putchar('\n');
     }
   }
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 97a925f3ad..5f086df4e9 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -651,7 +651,7 @@ char *u_get_undo_file_name(const char *const buf_ffname, const bool reading)
   char fname_buf[MAXPATHL];
   // Expand symlink in the file name, so that we put the undo file with the
   // actual file instead of with the symlink.
-  if (resolve_symlink((const char_u *)ffname, (char_u *)fname_buf) == OK) {
+  if (resolve_symlink(ffname, fname_buf) == OK) {
     ffname = fname_buf;
   }
 #endif
@@ -713,7 +713,7 @@ char *u_get_undo_file_name(const char *const buf_ffname, const bool reading)
 
     // When reading check if the file exists.
     if (undo_file_name != NULL
-        && (!reading || os_path_exists((char_u *)undo_file_name))) {
+        && (!reading || os_path_exists(undo_file_name))) {
       break;
     }
     XFREE_CLEAR(undo_file_name);
@@ -1177,7 +1177,7 @@ void u_write_undo(const char *const name, const bool forceit, buf_T *const buf,
 
   // If the undo file already exists, verify that it actually is an undo
   // file, and delete it.
-  if (os_path_exists((char_u *)file_name)) {
+  if (os_path_exists(file_name)) {
     if (name == NULL || !forceit) {
       // Check we can read it and it's an undo file.
       fd = os_open(file_name, O_RDONLY, 0);
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 5b2101587f..9cc9fb5588 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -531,7 +531,7 @@ static void uc_list(char *name, size_t name_len)
         }
       }
 
-      msg_outtrans_special((char_u *)cmd->uc_rep, false,
+      msg_outtrans_special(cmd->uc_rep, false,
                            name_len == 0 ? Columns - 47 : 0);
       if (p_verbose > 0) {
         last_set_msg(cmd->uc_script_ctx);
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 74ea1172ee..c11484d1b8 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6578,7 +6578,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
    * Go one char back to ":" before "//" even when ':' is not in 'isfname'.
    */
   while ((char_u *)ptr > line) {
-    if ((len = (size_t)(utf_head_off(line, (char_u *)ptr - 1))) > 0) {
+    if ((len = (size_t)(utf_head_off((char *)line, ptr - 1))) > 0) {
       ptr -= len + 1;
     } else if (vim_isfilec(ptr[-1]) || ((options & FNAME_HYP) && path_is_url(ptr - 1))) {
       ptr--;
-- 
cgit 


From 933c80e8f9d7ff4ab634c14d370440702c7c8ed7 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Wed, 31 Aug 2022 21:14:14 +0800
Subject: refactor(mappings)!: mapblock_fill_dict() use API Dictionary (#20020)

This introduces the following breaking changes:
- nvim_get_keymap now always returns a LuaRef object as "callback" for a
  Lua mapping regardless of how it is called. The LuaRef object can be
  called from Lua and Vim script, but is lost over RPC.
- maparg() now returns a Funcref instead of a ref number as "callback"
  for a Lua mapping. The Funcref can be called from Lua and Vim script,
  but is lost over RPC.

This may also make nvim_get_keymap faster, but make maparg() slower.
---
 src/nvim/api/buffer.c |  4 +--
 src/nvim/api/vim.c    |  4 +--
 src/nvim/mapping.c    | 87 ++++++++++++++++++++++-----------------------------
 3 files changed, 41 insertions(+), 54 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 199650fc55..16f574f46d 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -945,7 +945,7 @@ Integer nvim_buf_get_changedtick(Buffer buffer, Error *err)
 /// @param[out]  err   Error details, if any
 /// @returns Array of |maparg()|-like dictionaries describing mappings.
 ///          The "buffer" key holds the associated buffer handle.
-ArrayOf(Dictionary) nvim_buf_get_keymap(uint64_t channel_id, Buffer buffer, String mode, Error *err)
+ArrayOf(Dictionary) nvim_buf_get_keymap(Buffer buffer, String mode, Error *err)
   FUNC_API_SINCE(3)
 {
   buf_T *buf = find_buffer_by_handle(buffer, err);
@@ -954,7 +954,7 @@ ArrayOf(Dictionary) nvim_buf_get_keymap(uint64_t channel_id, Buffer buffer, Stri
     return (Array)ARRAY_DICT_INIT;
   }
 
-  return keymap_array(mode, buf, channel_id == LUA_INTERNAL_CALL);
+  return keymap_array(mode, buf);
 }
 
 /// Sets a buffer-local |mapping| for the given mode.
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index a1721d433f..9e1f2dd631 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -1421,10 +1421,10 @@ Dictionary nvim_get_mode(void)
 /// @param  mode       Mode short-name ("n", "i", "v", ...)
 /// @returns Array of |maparg()|-like dictionaries describing mappings.
 ///          The "buffer" key is always zero.
-ArrayOf(Dictionary) nvim_get_keymap(uint64_t channel_id, String mode)
+ArrayOf(Dictionary) nvim_get_keymap(String mode)
   FUNC_API_SINCE(3)
 {
-  return keymap_array(mode, NULL, channel_id == LUA_INTERNAL_CALL);
+  return keymap_array(mode, NULL);
 }
 
 /// Sets a global |mapping| for the given mode.
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 333fb847f6..caa040e79b 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -1989,16 +1989,18 @@ void f_hasmapto(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 }
 
-/// Fill a dictionary with all applicable maparg() like dictionaries
+/// Fill a Dictionary with all applicable maparg() like dictionaries
 ///
-/// @param dict          The dictionary to be filled
 /// @param mp            The maphash that contains the mapping information
 /// @param buffer_value  The "buffer" value
 /// @param compatible    True for compatible with old maparg() dict
-static void mapblock_fill_dict(dict_T *const dict, const mapblock_T *const mp,
-                               const char *lhsrawalt, long buffer_value, bool compatible)
-  FUNC_ATTR_NONNULL_ARG(1, 2)
+///
+/// @return  A Dictionary.
+static Dictionary mapblock_fill_dict(const mapblock_T *const mp, const char *lhsrawalt,
+                                     const long buffer_value, const bool compatible)
+  FUNC_ATTR_NONNULL_ARG(1)
 {
+  Dictionary dict = ARRAY_DICT_INIT;
   char *const lhs = str2special_save((const char *)mp->m_keys,
                                      compatible, !compatible);
   char *const mapmode = map_mode_to_chars(mp->m_mode);
@@ -2015,37 +2017,35 @@ static void mapblock_fill_dict(dict_T *const dict, const mapblock_T *const mp,
   }
 
   if (mp->m_luaref != LUA_NOREF) {
-    tv_dict_add_nr(dict, S_LEN("callback"), mp->m_luaref);
+    PUT(dict, "callback", LUAREF_OBJ(api_new_luaref(mp->m_luaref)));
   } else {
-    if (compatible) {
-      tv_dict_add_str(dict, S_LEN("rhs"), (const char *)mp->m_orig_str);
-    } else {
-      tv_dict_add_allocated_str(dict, S_LEN("rhs"),
-                                str2special_save((const char *)mp->m_str, false,
-                                                 true));
-    }
+    PUT(dict, "rhs", STRING_OBJ(compatible
+                                ? cstr_to_string(mp->m_orig_str)
+                                : cstr_as_string(str2special_save(mp->m_str, false, true))));
   }
   if (mp->m_desc != NULL) {
-    tv_dict_add_allocated_str(dict, S_LEN("desc"), xstrdup(mp->m_desc));
+    PUT(dict, "desc", STRING_OBJ(cstr_to_string(mp->m_desc)));
   }
-  tv_dict_add_allocated_str(dict, S_LEN("lhs"), lhs);
-  tv_dict_add_str(dict, S_LEN("lhsraw"), (const char *)mp->m_keys);
+  PUT(dict, "lhs", STRING_OBJ(cstr_as_string(lhs)));
+  PUT(dict, "lhsraw", STRING_OBJ(cstr_to_string((const char *)mp->m_keys)));
   if (lhsrawalt != NULL) {
     // Also add the value for the simplified entry.
-    tv_dict_add_str(dict, S_LEN("lhsrawalt"), lhsrawalt);
-  }
-  tv_dict_add_nr(dict, S_LEN("noremap"), noremap_value);
-  tv_dict_add_nr(dict, S_LEN("script"), mp->m_noremap == REMAP_SCRIPT ? 1 : 0);
-  tv_dict_add_nr(dict, S_LEN("expr"),  mp->m_expr ? 1 : 0);
-  tv_dict_add_nr(dict, S_LEN("silent"), mp->m_silent ? 1 : 0);
-  tv_dict_add_nr(dict, S_LEN("sid"), (varnumber_T)mp->m_script_ctx.sc_sid);
-  tv_dict_add_nr(dict, S_LEN("lnum"), (varnumber_T)mp->m_script_ctx.sc_lnum);
-  tv_dict_add_nr(dict, S_LEN("buffer"), (varnumber_T)buffer_value);
-  tv_dict_add_nr(dict, S_LEN("nowait"), mp->m_nowait ? 1 : 0);
+    PUT(dict, "lhsrawalt", STRING_OBJ(cstr_to_string(lhsrawalt)));
+  }
+  PUT(dict, "noremap", INTEGER_OBJ(noremap_value));
+  PUT(dict, "script", INTEGER_OBJ(mp->m_noremap == REMAP_SCRIPT ? 1 : 0));
+  PUT(dict, "expr", INTEGER_OBJ(mp->m_expr ? 1 : 0));
+  PUT(dict, "silent", INTEGER_OBJ(mp->m_silent ? 1 : 0));
+  PUT(dict, "sid", INTEGER_OBJ((varnumber_T)mp->m_script_ctx.sc_sid));
+  PUT(dict, "lnum", INTEGER_OBJ((varnumber_T)mp->m_script_ctx.sc_lnum));
+  PUT(dict, "buffer", INTEGER_OBJ((varnumber_T)buffer_value));
+  PUT(dict, "nowait", INTEGER_OBJ(mp->m_nowait ? 1 : 0));
   if (mp->m_replace_keycodes) {
-    tv_dict_add_nr(dict, S_LEN("replace_keycodes"), 1);
+    PUT(dict, "replace_keycodes", INTEGER_OBJ(1));
   }
-  tv_dict_add_allocated_str(dict, S_LEN("mode"), mapmode);
+  PUT(dict, "mode", STRING_OBJ(cstr_as_string(mapmode)));
+
+  return dict;
 }
 
 static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
@@ -2114,11 +2114,14 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
       rettv->vval.v_string = nlua_funcref_str(mp->m_luaref);
     }
   } else {
+    // Return a dictionary.
     tv_dict_alloc_ret(rettv);
     if (mp != NULL && (rhs != NULL || rhs_lua != LUA_NOREF)) {
-      // Return a dictionary.
-      mapblock_fill_dict(rettv->vval.v_dict, mp, did_simplify ? (char *)keys_simplified : NULL,
-                         buffer_local, true);
+      Dictionary dict = mapblock_fill_dict(mp,
+                                           did_simplify ? (char *)keys_simplified : NULL,
+                                           buffer_local, true);
+      (void)object_to_vim(DICTIONARY_OBJ(dict), rettv, NULL);
+      api_free_dictionary(dict);
     }
   }
 
@@ -2599,12 +2602,10 @@ fail_and_free:
 ///
 /// @param  mode  The abbreviation for the mode
 /// @param  buf  The buffer to get the mapping array. NULL for global
-/// @param  from_lua  Whether it is called from internal Lua api.
 /// @returns Array of maparg()-like dictionaries describing mappings
-ArrayOf(Dictionary) keymap_array(String mode, buf_T *buf, bool from_lua)
+ArrayOf(Dictionary) keymap_array(String mode, buf_T *buf)
 {
   Array mappings = ARRAY_DICT_INIT;
-  dict_T *const dict = tv_dict_alloc();
 
   // Convert the string mode to the integer mode
   // that is stored within each mapblock
@@ -2623,25 +2624,11 @@ ArrayOf(Dictionary) keymap_array(String mode, buf_T *buf, bool from_lua)
       }
       // Check for correct mode
       if (int_mode & current_maphash->m_mode) {
-        mapblock_fill_dict(dict, current_maphash, NULL, buffer_value, false);
-        Object api_dict = vim_to_object((typval_T[]) { { .v_type = VAR_DICT,
-                                                         .vval.v_dict = dict } });
-        if (from_lua) {
-          Dictionary d = api_dict.data.dictionary;
-          for (size_t j = 0; j < d.size; j++) {
-            if (strequal("callback", d.items[j].key.data)) {
-              d.items[j].value.type = kObjectTypeLuaRef;
-              d.items[j].value.data.luaref = api_new_luaref((LuaRef)d.items[j].value.data.integer);
-              break;
-            }
-          }
-        }
-        ADD(mappings, api_dict);
-        tv_dict_clear(dict);
+        ADD(mappings,
+            DICTIONARY_OBJ(mapblock_fill_dict(current_maphash, NULL, buffer_value, false)));
       }
     }
   }
-  tv_dict_free(dict);
 
   return mappings;
 }
-- 
cgit 


From f31db30975479cb6b57247f124a65f4362f80bfe Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 30 Jun 2022 13:26:31 +0600
Subject: feat(lua): vim.ui_attach to get ui events from lua

Co-authored-by: Famiu Haque <famiuhaque@protonmail.com>
---
 src/nvim/api/extmark.c                    |  2 +-
 src/nvim/api/ui.c                         |  1 +
 src/nvim/api/ui_events.in.h               |  4 +-
 src/nvim/buffer_updates.c                 |  8 ++-
 src/nvim/eval.c                           |  9 +---
 src/nvim/generators/gen_api_ui_events.lua |  2 +
 src/nvim/lua/executor.c                   | 89 +++++++++++++++++++++++++++++--
 src/nvim/map.c                            |  1 +
 src/nvim/map.h                            |  1 +
 src/nvim/memory.c                         |  2 +
 src/nvim/ui.c                             |  7 ++-
 src/nvim/ui.h                             |  5 ++
 src/nvim/ui_compositor.c                  | 87 +++++++++++++++++++++++++++++-
 13 files changed, 196 insertions(+), 22 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index 09b004637f..6ff0a2ed21 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -87,7 +87,7 @@ const char *describe_ns(NS ns_id)
 }
 
 // Is the Namespace in use?
-static bool ns_initialized(uint32_t ns)
+bool ns_initialized(uint32_t ns)
 {
   if (ns < 1) {
     return false;
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index e34dcbdb46..654eb19bec 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -223,6 +223,7 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height, Dictiona
   ui->msg_set_pos = remote_ui_msg_set_pos;
   ui->event = remote_ui_event;
   ui->inspect = remote_ui_inspect;
+  ui->win_viewport = remote_ui_win_viewport;
 
   CLEAR_FIELD(ui->ui_ext);
 
diff --git a/src/nvim/api/ui_events.in.h b/src/nvim/api/ui_events.in.h
index 8b7e01e1c3..17930dca85 100644
--- a/src/nvim/api/ui_events.in.h
+++ b/src/nvim/api/ui_events.in.h
@@ -100,7 +100,7 @@ void raw_line(Integer grid, Integer row, Integer startcol,
   FUNC_API_NOEXPORT FUNC_API_COMPOSITOR_IMPL;
 
 void event(char *name, Array args)
-  FUNC_API_NOEXPORT;
+  FUNC_API_NOEXPORT FUNC_API_COMPOSITOR_IMPL;
 
 void win_pos(Integer grid, Window win, Integer startrow,
              Integer startcol, Integer width, Integer height)
@@ -121,7 +121,7 @@ void msg_set_pos(Integer grid, Integer row, Boolean scrolled, String sep_char)
 void win_viewport(Integer grid, Window win, Integer topline,
                   Integer botline, Integer curline, Integer curcol,
                   Integer line_count)
-  FUNC_API_SINCE(7) FUNC_API_REMOTE_ONLY;
+  FUNC_API_SINCE(7) FUNC_API_BRIDGE_IMPL;
 
 void win_extmark(Integer grid, Window win, Integer ns_id, Integer mark_id,
                  Integer row, Integer col)
diff --git a/src/nvim/buffer_updates.c b/src/nvim/buffer_updates.c
index 14973502ab..1b3c0bc28f 100644
--- a/src/nvim/buffer_updates.c
+++ b/src/nvim/buffer_updates.c
@@ -285,14 +285,13 @@ void buf_updates_send_changes(buf_T *buf, linenr_T firstline, int64_t num_added,
         args.items[7] = INTEGER_OBJ((Integer)deleted_codeunits);
       }
       textlock++;
-      Object res = nlua_call_ref(cb.on_lines, "lines", args, true, NULL);
+      Object res = nlua_call_ref(cb.on_lines, "lines", args, false, NULL);
       textlock--;
 
       if (res.type == kObjectTypeBoolean && res.data.boolean == true) {
         buffer_update_callbacks_free(cb);
         keep = false;
       }
-      api_free_object(res);
     }
     if (keep) {
       kv_A(buf->update_callbacks, j++) = kv_A(buf->update_callbacks, i);
@@ -335,7 +334,7 @@ void buf_updates_send_splice(buf_T *buf, int start_row, colnr_T start_col, bcoun
       ADD_C(args, INTEGER_OBJ(new_byte));
 
       textlock++;
-      Object res = nlua_call_ref(cb.on_bytes, "bytes", args, true, NULL);
+      Object res = nlua_call_ref(cb.on_bytes, "bytes", args, false, NULL);
       textlock--;
 
       if (res.type == kObjectTypeBoolean && res.data.boolean == true) {
@@ -371,14 +370,13 @@ void buf_updates_changedtick(buf_T *buf)
 
       textlock++;
       Object res = nlua_call_ref(cb.on_changedtick, "changedtick",
-                                 args, true, NULL);
+                                 args, false, NULL);
       textlock--;
 
       if (res.type == kObjectTypeBoolean && res.data.boolean == true) {
         buffer_update_callbacks_free(cb);
         keep = false;
       }
-      api_free_object(res);
     }
     if (keep) {
       kv_A(buf->update_callbacks, j++) = kv_A(buf->update_callbacks, i);
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 2dbaa2f8ac..92082772e1 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -5858,13 +5858,8 @@ bool callback_call(Callback *const callback, const int argcount_in, typval_T *co
     break;
 
   case kCallbackLua:
-    rv = nlua_call_ref(callback->data.luaref, NULL, args, true, NULL);
-    switch (rv.type) {
-    case kObjectTypeBoolean:
-      return rv.data.boolean;
-    default:
-      return false;
-    }
+    rv = nlua_call_ref(callback->data.luaref, NULL, args, false, NULL);
+    return (rv.type == kObjectTypeBoolean && rv.data.boolean == true);
 
   case kCallbackNone:
     return false;
diff --git a/src/nvim/generators/gen_api_ui_events.lua b/src/nvim/generators/gen_api_ui_events.lua
index f9e888c20d..ea66be7ee8 100755
--- a/src/nvim/generators/gen_api_ui_events.lua
+++ b/src/nvim/generators/gen_api_ui_events.lua
@@ -75,6 +75,8 @@ local function call_ui_event_method(output, ev)
       hlattrs_args_count = hlattrs_args_count + 1
     elseif kind == 'Object' then
       output:write('args.items['..(j-1)..'];\n')
+    elseif kind == 'Window' then
+      output:write('(Window)args.items['..(j-1)..'].data.integer;\n')
     else
       output:write('args.items['..(j-1)..'].data.'..string.lower(kind)..';\n')
     end
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 42aa13cfc1..f144e47c3a 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -7,6 +7,7 @@
 #include <tree_sitter/api.h>
 
 #include "luv/luv.h"
+#include "nvim/api/extmark.h"
 #include "nvim/api/private/defs.h"
 #include "nvim/api/private/helpers.h"
 #include "nvim/api/vim.h"
@@ -40,6 +41,9 @@
 #include "nvim/os/os.h"
 #include "nvim/profile.h"
 #include "nvim/runtime.h"
+#include "nvim/screen.h"
+#include "nvim/ui.h"
+#include "nvim/ui_compositor.h"
 #include "nvim/undo.h"
 #include "nvim/usercmd.h"
 #include "nvim/version.h"
@@ -589,6 +593,71 @@ static bool nlua_init_packages(lua_State *lstate)
   return true;
 }
 
+/// "vim.ui_attach(ns_id, {ext_foo=true}, cb)" function
+static int nlua_ui_attach(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  uint32_t ns_id = (uint32_t)luaL_checkinteger(lstate, 1);
+
+  if (!ns_initialized(ns_id)) {
+    return luaL_error(lstate, "invalid ns_id");
+  }
+  if (!lua_istable(lstate, 2)) {
+    return luaL_error(lstate, "ext_widgets must be a table");
+  }
+  if (!lua_isfunction(lstate, 3)) {
+    return luaL_error(lstate, "callback must be a Lua function");
+  }
+
+  bool ext_widgets[kUIGlobalCount] = { false };
+  bool tbl_has_true_val = false;
+
+  lua_pushvalue(lstate, 2);
+  lua_pushnil(lstate);
+  while (lua_next(lstate, -2)) {
+    // [dict, key, val]
+    size_t len;
+    const char *s = lua_tolstring(lstate, -2, &len);
+    bool val = lua_toboolean(lstate, -1);
+
+    for (size_t i = 0; i < kUIGlobalCount; i++) {
+      if (strequal(s, ui_ext_names[i])) {
+        if (val) {
+          tbl_has_true_val = true;
+        }
+        ext_widgets[i] = val;
+        goto ok;
+      }
+    }
+
+    return luaL_error(lstate, "Unexpected key: %s", s);
+ok:
+    lua_pop(lstate, 1);
+  }
+
+  if (!tbl_has_true_val) {
+    return luaL_error(lstate, "ext_widgets table must contain at least one 'true' value");
+  }
+
+  LuaRef ui_event_cb = nlua_ref_global(lstate, 3);
+  ui_comp_add_cb(ns_id, ui_event_cb, ext_widgets);
+  return 0;
+}
+
+/// "vim.ui_detach(ns_id)" function
+static int nlua_ui_detach(lua_State *lstate)
+  FUNC_ATTR_NONNULL_ALL
+{
+  uint32_t ns_id = (uint32_t)luaL_checkinteger(lstate, 1);
+
+  if (!ns_initialized(ns_id)) {
+    return luaL_error(lstate, "invalid ns_id");
+  }
+
+  ui_comp_remove_cb(ns_id);
+  return 0;
+}
+
 /// Initialize lua interpreter state
 ///
 /// Called by lua interpreter itself to initialize state.
@@ -649,6 +718,14 @@ static bool nlua_state_init(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
   lua_pushcfunction(lstate, &nlua_wait);
   lua_setfield(lstate, -2, "wait");
 
+  // ui_attach
+  lua_pushcfunction(lstate, &nlua_ui_attach);
+  lua_setfield(lstate, -2, "ui_attach");
+
+  // ui_detach
+  lua_pushcfunction(lstate, &nlua_ui_detach);
+  lua_setfield(lstate, -2, "ui_detach");
+
   nlua_common_vim_init(lstate, false);
 
   // patch require() (only for --startuptime)
@@ -1422,9 +1499,10 @@ bool nlua_ref_is_function(LuaRef ref)
 /// @param name    if non-NULL, sent to callback as first arg
 ///                if NULL, only args are used
 /// @param retval  if true, convert return value to Object
-///                if false, discard return value
+///                if false, only check if return value is truthy
 /// @param err     Error details, if any (if NULL, errors are echoed)
-/// @return        Return value of function, if retval was set. Otherwise NIL.
+/// @return        Return value of function, if retval was set. Otherwise
+/// BOOLEAN_OBJ(true) or NIL.
 Object nlua_call_ref(LuaRef ref, const char *name, Array args, bool retval, Error *err)
 {
   lua_State *const lstate = global_lstate;
@@ -1438,7 +1516,7 @@ Object nlua_call_ref(LuaRef ref, const char *name, Array args, bool retval, Erro
     nlua_push_Object(lstate, args.items[i], false);
   }
 
-  if (nlua_pcall(lstate, nargs, retval ? 1 : 0)) {
+  if (nlua_pcall(lstate, nargs, 1)) {
     // if err is passed, the caller will deal with the error.
     if (err) {
       size_t len;
@@ -1458,7 +1536,10 @@ Object nlua_call_ref(LuaRef ref, const char *name, Array args, bool retval, Erro
     }
     return nlua_pop_Object(lstate, false, err);
   } else {
-    return NIL;
+    bool value = lua_toboolean(lstate, -1);
+    lua_pop(lstate, 1);
+
+    return value ? BOOLEAN_OBJ(true) : NIL;
   }
 }
 
diff --git a/src/nvim/map.c b/src/nvim/map.c
index d3058a5d52..1561b089a7 100644
--- a/src/nvim/map.c
+++ b/src/nvim/map.c
@@ -168,6 +168,7 @@ MAP_IMPL(int, cstr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(cstr_t, ptr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(cstr_t, int, DEFAULT_INITIALIZER)
 MAP_IMPL(ptr_t, ptr_t, DEFAULT_INITIALIZER)
+MAP_IMPL(uint32_t, ptr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(uint64_t, ptr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(uint64_t, ssize_t, SSIZE_INITIALIZER)
 MAP_IMPL(uint64_t, uint64_t, DEFAULT_INITIALIZER)
diff --git a/src/nvim/map.h b/src/nvim/map.h
index 845daac3f7..f5f30f5a85 100644
--- a/src/nvim/map.h
+++ b/src/nvim/map.h
@@ -39,6 +39,7 @@ MAP_DECLS(int, cstr_t)
 MAP_DECLS(cstr_t, ptr_t)
 MAP_DECLS(cstr_t, int)
 MAP_DECLS(ptr_t, ptr_t)
+MAP_DECLS(uint32_t, ptr_t)
 MAP_DECLS(uint64_t, ptr_t)
 MAP_DECLS(uint64_t, ssize_t)
 MAP_DECLS(uint64_t, uint64_t)
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index a9785fcb7c..acd2478c81 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -23,6 +23,7 @@
 #include "nvim/message.h"
 #include "nvim/sign.h"
 #include "nvim/ui.h"
+#include "nvim/ui_compositor.h"
 #include "nvim/vim.h"
 
 #ifdef UNIT_TESTING
@@ -824,6 +825,7 @@ void free_all_mem(void)
 
   nlua_free_all_mem();
   ui_free_all_mem();
+  ui_comp_free_all_mem();
 
   // should be last, in case earlier free functions deallocates arenas
   arena_free_reuse_blks();
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 46f4d137c4..06be5676c7 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -198,13 +198,16 @@ void ui_refresh(void)
     ext_widgets[i] = true;
   }
 
+  UI *compositor = uis[0];
+
   bool inclusive = ui_override();
-  for (size_t i = 0; i < ui_count; i++) {
+  for (size_t i = 1; i < ui_count; i++) {
     UI *ui = uis[i];
     width = MIN(ui->width, width);
     height = MIN(ui->height, height);
     for (UIExtension j = 0; (int)j < kUIExtCount; j++) {
-      ext_widgets[j] &= (ui->ui_ext[j] || inclusive);
+      bool in_compositor = ui->composed && compositor->ui_ext[j];
+      ext_widgets[j] &= (ui->ui_ext[j] || in_compositor || inclusive);
     }
   }
 
diff --git a/src/nvim/ui.h b/src/nvim/ui.h
index 996b3467a6..9034e7b764 100644
--- a/src/nvim/ui.h
+++ b/src/nvim/ui.h
@@ -69,6 +69,11 @@ struct ui_t {
   void (*inspect)(UI *ui, Dictionary *info);
 };
 
+typedef struct ui_event_callback {
+  LuaRef cb;
+  bool ext_widgets[kUIGlobalCount];
+} UIEventCallback;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ui.h.generated.h"
 
diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c
index 2216e25db9..5167f291c3 100644
--- a/src/nvim/ui_compositor.c
+++ b/src/nvim/ui_compositor.c
@@ -20,6 +20,7 @@
 #include "nvim/log.h"
 #include "nvim/lua/executor.h"
 #include "nvim/main.h"
+#include "nvim/map.h"
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/os/os.h"
@@ -54,6 +55,8 @@ static bool msg_was_scrolled = false;
 static int msg_sep_row = -1;
 static schar_T msg_sep_char = { ' ', NUL };
 
+static PMap(uint32_t) ui_event_cbs = MAP_INIT;
+
 static int dbghl_normal, dbghl_clear, dbghl_composed, dbghl_recompose;
 
 void ui_comp_init(void)
@@ -69,14 +72,18 @@ void ui_comp_init(void)
   compositor->grid_cursor_goto = ui_comp_grid_cursor_goto;
   compositor->raw_line = ui_comp_raw_line;
   compositor->msg_set_pos = ui_comp_msg_set_pos;
+  compositor->event = ui_comp_event;
 
   // Be unopinionated: will be attached together with a "real" ui anyway
   compositor->width = INT_MAX;
   compositor->height = INT_MAX;
-  for (UIExtension i = 0; (int)i < kUIExtCount; i++) {
+  for (UIExtension i = kUIGlobalCount; (int)i < kUIExtCount; i++) {
     compositor->ui_ext[i] = true;
   }
 
+  // TODO(bfredl): one day. in the future.
+  compositor->ui_ext[kUIMultigrid] = false;
+
   // TODO(bfredl): this will be more complicated if we implement
   // hlstate per UI (i e reduce hl ids for non-hlstate UIs)
   compositor->ui_ext[kUIHlState] = false;
@@ -87,6 +94,15 @@ void ui_comp_init(void)
   ui_attach_impl(compositor, 0);
 }
 
+void ui_comp_free_all_mem(void)
+{
+  UIEventCallback *event_cb;
+  map_foreach_value(&ui_event_cbs, event_cb, {
+    xfree(event_cb);
+  })
+  pmap_destroy(uint32_t)(&ui_event_cbs);
+}
+
 void ui_comp_syn_init(void)
 {
   dbghl_normal = syn_check_group(S_LEN("RedrawDebugNormal"));
@@ -676,3 +692,72 @@ static void ui_comp_grid_resize(UI *ui, Integer grid, Integer width, Integer hei
     }
   }
 }
+
+static void ui_comp_event(UI *ui, char *name, Array args)
+{
+  Error err = ERROR_INIT;
+  UIEventCallback *event_cb;
+  bool handled = false;
+
+  map_foreach_value(&ui_event_cbs, event_cb, {
+    Object res = nlua_call_ref(event_cb->cb, name, args, false, &err);
+    if (res.type == kObjectTypeBoolean && res.data.boolean == true) {
+      handled = true;
+    }
+  })
+
+  if (!handled) {
+    ui_composed_call_event(name, args);
+  }
+}
+
+static void ui_comp_update_ext(void)
+{
+  memset(compositor->ui_ext, 0, ARRAY_SIZE(compositor->ui_ext));
+
+  for (size_t i = 0; i < kUIGlobalCount; i++) {
+    UIEventCallback *event_cb;
+
+    map_foreach_value(&ui_event_cbs, event_cb, {
+      if (event_cb->ext_widgets[i]) {
+        compositor->ui_ext[i] = true;
+        break;
+      }
+    })
+  }
+}
+
+void free_ui_event_callback(UIEventCallback *event_cb)
+{
+  api_free_luaref(event_cb->cb);
+  xfree(event_cb);
+}
+
+void ui_comp_add_cb(uint32_t ns_id, LuaRef cb, bool *ext_widgets)
+{
+  UIEventCallback *event_cb = xcalloc(1, sizeof(UIEventCallback));
+  event_cb->cb = cb;
+  memcpy(event_cb->ext_widgets, ext_widgets, ARRAY_SIZE(event_cb->ext_widgets));
+  if (event_cb->ext_widgets[kUIMessages]) {
+    event_cb->ext_widgets[kUICmdline] = true;
+  }
+
+  UIEventCallback **item = (UIEventCallback **)pmap_ref(uint32_t)(&ui_event_cbs, ns_id, true);
+  if (*item) {
+    free_ui_event_callback(*item);
+  }
+  *item = event_cb;
+
+  ui_comp_update_ext();
+  ui_schedule_refresh();
+}
+
+void ui_comp_remove_cb(uint32_t ns_id)
+{
+  if (pmap_has(uint32_t)(&ui_event_cbs, ns_id)) {
+    free_ui_event_callback(pmap_get(uint32_t)(&ui_event_cbs, ns_id));
+    pmap_del(uint32_t)(&ui_event_cbs, ns_id);
+  }
+  ui_comp_update_ext();
+  ui_schedule_refresh();
+}
-- 
cgit 


From ba8be7446d440053b24358046e8e4033e3447633 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Wed, 31 Aug 2022 14:49:15 +0200
Subject: refactor(highlight): make hlattrs2dict always use pre-allocated dict

hlattrs2dict used to work with both allocated and unallocated
dicts which was quite messy. Now always delegate allocation to caller.
---
 src/nvim/api/ui.c          | 64 ++++++++++++++++++++++++----------------------
 src/nvim/api/vim.c         | 22 ++++++++--------
 src/nvim/highlight.c       | 30 ++++++++--------------
 src/nvim/highlight.h       |  2 ++
 src/nvim/highlight_group.c | 16 +++++++-----
 5 files changed, 66 insertions(+), 68 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index e34dcbdb46..110bd6920e 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -748,10 +748,12 @@ static void remote_ui_hl_attr_define(UI *ui, Integer id, HlAttrs rgb_attrs, HlAt
   UIData *data = ui->data;
   Array args = data->call_buf;
   ADD_C(args, INTEGER_OBJ(id));
-  MAXSIZE_TEMP_DICT(rgb, 16);
-  MAXSIZE_TEMP_DICT(cterm, 16);
-  ADD_C(args, DICTIONARY_OBJ(hlattrs2dict(&rgb, rgb_attrs, true)));
-  ADD_C(args, DICTIONARY_OBJ(hlattrs2dict(&cterm, cterm_attrs, false)));
+  MAXSIZE_TEMP_DICT(rgb, HLATTRS_DICT_SIZE);
+  MAXSIZE_TEMP_DICT(cterm, HLATTRS_DICT_SIZE);
+  hlattrs2dict(&rgb, rgb_attrs, true);
+  hlattrs2dict(&cterm, rgb_attrs, false);
+  ADD_C(args, DICTIONARY_OBJ(rgb));
+  ADD_C(args, DICTIONARY_OBJ(cterm));
 
   if (ui->ui_ext[kUIHlState]) {
     ADD_C(args, ARRAY_OBJ(info));
@@ -771,8 +773,9 @@ static void remote_ui_highlight_set(UI *ui, int id)
     return;
   }
   data->hl_id = id;
-  MAXSIZE_TEMP_DICT(dict, 16);
-  ADD_C(args, DICTIONARY_OBJ(hlattrs2dict(&dict, syn_attr2entry(id), ui->rgb)));
+  MAXSIZE_TEMP_DICT(dict, HLATTRS_DICT_SIZE);
+  hlattrs2dict(&dict, syn_attr2entry(id), ui->rgb);
+  ADD_C(args, DICTIONARY_OBJ(dict));
   push_call(ui, "highlight_set", args);
 }
 
@@ -952,65 +955,63 @@ static void remote_ui_flush(UI *ui)
   }
 }
 
-static Array translate_contents(UI *ui, Array contents)
+static Array translate_contents(UI *ui, Array contents, Arena *arena)
 {
-  Array new_contents = ARRAY_DICT_INIT;
+  Array new_contents = arena_array(arena, contents.size);
   for (size_t i = 0; i < contents.size; i++) {
     Array item = contents.items[i].data.array;
-    Array new_item = ARRAY_DICT_INIT;
+    Array new_item = arena_array(arena, 2);
     int attr = (int)item.items[0].data.integer;
     if (attr) {
-      Dictionary rgb_attrs = hlattrs2dict(NULL, syn_attr2entry(attr), ui->rgb);
+      Dictionary rgb_attrs = arena_dict(arena, HLATTRS_DICT_SIZE);
+      hlattrs2dict(&rgb_attrs, syn_attr2entry(attr), ui->rgb);
       ADD(new_item, DICTIONARY_OBJ(rgb_attrs));
     } else {
       ADD(new_item, DICTIONARY_OBJ((Dictionary)ARRAY_DICT_INIT));
     }
-    ADD(new_item, copy_object(item.items[1], NULL));
+    ADD(new_item, item.items[1]);
     ADD(new_contents, ARRAY_OBJ(new_item));
   }
   return new_contents;
 }
 
-static Array translate_firstarg(UI *ui, Array args)
+static Array translate_firstarg(UI *ui, Array args, Arena *arena)
 {
-  Array new_args = ARRAY_DICT_INIT;
+  Array new_args = arena_array(arena, args.size);
   Array contents = args.items[0].data.array;
 
-  ADD(new_args, ARRAY_OBJ(translate_contents(ui, contents)));
+  ADD_C(new_args, ARRAY_OBJ(translate_contents(ui, contents, arena)));
   for (size_t i = 1; i < args.size; i++) {
-    ADD(new_args, copy_object(args.items[i], NULL));
+    ADD(new_args, args.items[i]);
   }
   return new_args;
 }
 
 static void remote_ui_event(UI *ui, char *name, Array args)
 {
+  Arena arena = ARENA_EMPTY;
   UIData *data = ui->data;
   if (!ui->ui_ext[kUILinegrid]) {
     // the representation of highlights in cmdline changed, translate back
     // never consumes args
     if (strequal(name, "cmdline_show")) {
-      Array new_args = translate_firstarg(ui, args);
+      Array new_args = translate_firstarg(ui, args, &arena);
       push_call(ui, name, new_args);
-      api_free_array(new_args);
-      return;
+      goto free_ret;
     } else if (strequal(name, "cmdline_block_show")) {
       Array new_args = data->call_buf;
       Array block = args.items[0].data.array;
-      Array new_block = ARRAY_DICT_INIT;
+      Array new_block = arena_array(&arena, block.size);
       for (size_t i = 0; i < block.size; i++) {
-        ADD(new_block,
-            ARRAY_OBJ(translate_contents(ui, block.items[i].data.array)));
+        ADD_C(new_block, ARRAY_OBJ(translate_contents(ui, block.items[i].data.array, &arena)));
       }
       ADD_C(new_args, ARRAY_OBJ(new_block));
       push_call(ui, name, new_args);
-      api_free_array(new_block);
-      return;
+      goto free_ret;
     } else if (strequal(name, "cmdline_block_append")) {
-      Array new_args = translate_firstarg(ui, args);
+      Array new_args = translate_firstarg(ui, args, &arena);
       push_call(ui, name, new_args);
-      api_free_array(new_args);
-      return;
+      goto free_ret;
     }
   }
 
@@ -1022,19 +1023,18 @@ static void remote_ui_event(UI *ui, char *name, Array args)
       if (data->wildmenu_active) {
         Array new_args = data->call_buf;
         Array items = args.items[0].data.array;
-        Array new_items = ARRAY_DICT_INIT;
+        Array new_items = arena_array(&arena, items.size);
         for (size_t i = 0; i < items.size; i++) {
-          ADD(new_items, copy_object(items.items[i].data.array.items[0], NULL));
+          ADD_C(new_items, items.items[i].data.array.items[0]);
         }
         ADD_C(new_args, ARRAY_OBJ(new_items));
         push_call(ui, "wildmenu_show", new_args);
-        api_free_array(new_items);
         if (args.items[1].data.integer != -1) {
           Array new_args2 = data->call_buf;
           ADD_C(new_args2, args.items[1]);
           push_call(ui, "wildmenu_select", new_args2);
         }
-        return;
+        goto free_ret;
       }
     } else if (strequal(name, "popupmenu_select")) {
       if (data->wildmenu_active) {
@@ -1048,6 +1048,10 @@ static void remote_ui_event(UI *ui, char *name, Array args)
   }
 
   push_call(ui, name, args);
+  return;
+
+free_ret:
+  arena_mem_free(arena_finish(&arena));
 }
 
 static void remote_ui_inspect(UI *ui, Dictionary *info)
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 9e1f2dd631..83d6ba8dc7 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -79,7 +79,7 @@
 /// @param[out] err Error details, if any
 /// @return Highlight definition map
 /// @see nvim_get_hl_by_id
-Dictionary nvim_get_hl_by_name(String name, Boolean rgb, Error *err)
+Dictionary nvim_get_hl_by_name(String name, Boolean rgb, Arena *arena, Error *err)
   FUNC_API_SINCE(3)
 {
   Dictionary result = ARRAY_DICT_INIT;
@@ -89,8 +89,7 @@ Dictionary nvim_get_hl_by_name(String name, Boolean rgb, Error *err)
     api_set_error(err, kErrorTypeException, "Invalid highlight name: %s", name.data);
     return result;
   }
-  result = nvim_get_hl_by_id(id, rgb, err);
-  return result;
+  return nvim_get_hl_by_id(id, rgb, arena, err);
 }
 
 /// Gets a highlight definition by id. |hlID()|
@@ -99,7 +98,7 @@ Dictionary nvim_get_hl_by_name(String name, Boolean rgb, Error *err)
 /// @param[out] err Error details, if any
 /// @return Highlight definition map
 /// @see nvim_get_hl_by_name
-Dictionary nvim_get_hl_by_id(Integer hl_id, Boolean rgb, Error *err)
+Dictionary nvim_get_hl_by_id(Integer hl_id, Boolean rgb, Arena *arena, Error *err)
   FUNC_API_SINCE(3)
 {
   Dictionary dic = ARRAY_DICT_INIT;
@@ -108,7 +107,7 @@ Dictionary nvim_get_hl_by_id(Integer hl_id, Boolean rgb, Error *err)
     return dic;
   }
   int attrcode = syn_id2attr((int)hl_id);
-  return hl_get_attr_by_id(attrcode, rgb, err);
+  return hl_get_attr_by_id(attrcode, rgb, arena, err);
 }
 
 /// Gets a highlight group by name
@@ -120,10 +119,10 @@ Integer nvim_get_hl_id_by_name(String name)
   return syn_check_group(name.data, name.size);
 }
 
-Dictionary nvim__get_hl_defs(Integer ns_id, Error *err)
+Dictionary nvim__get_hl_defs(Integer ns_id, Arena *arena, Error *err)
 {
   if (ns_id == 0) {
-    return get_global_hl_defs();
+    return get_global_hl_defs(arena);
   }
   abort();
 }
@@ -1934,7 +1933,7 @@ void nvim_select_popupmenu_item(Integer item, Boolean insert, Boolean finish, Di
 }
 
 /// NB: if your UI doesn't use hlstate, this will not return hlstate first time
-Array nvim__inspect_cell(Integer grid, Integer row, Integer col, Error *err)
+Array nvim__inspect_cell(Integer grid, Integer row, Integer col, Arena *arena, Error *err)
 {
   Array ret = ARRAY_DICT_INIT;
 
@@ -1958,13 +1957,14 @@ Array nvim__inspect_cell(Integer grid, Integer row, Integer col, Error *err)
       || col < 0 || col >= g->cols) {
     return ret;
   }
+  ret = arena_array(arena, 3);
   size_t off = g->line_offset[(size_t)row] + (size_t)col;
-  ADD(ret, STRING_OBJ(cstr_to_string((char *)g->chars[off])));
+  ADD_C(ret, STRING_OBJ(cstr_as_string((char *)g->chars[off])));
   int attr = g->attrs[off];
-  ADD(ret, DICTIONARY_OBJ(hl_get_attr_by_id(attr, true, err)));
+  ADD_C(ret, DICTIONARY_OBJ(hl_get_attr_by_id(attr, true, arena, err)));
   // will not work first time
   if (!highlight_use_hlstate()) {
-    ADD(ret, ARRAY_OBJ(hl_inspect(attr)));
+    ADD_C(ret, ARRAY_OBJ(hl_inspect(attr)));
   }
   return ret;
 }
diff --git a/src/nvim/highlight.c b/src/nvim/highlight.c
index a78b933108..e42cb66422 100644
--- a/src/nvim/highlight.c
+++ b/src/nvim/highlight.c
@@ -788,7 +788,7 @@ HlAttrs syn_attr2entry(int attr)
 }
 
 /// Gets highlight description for id `attr_id` as a map.
-Dictionary hl_get_attr_by_id(Integer attr_id, Boolean rgb, Error *err)
+Dictionary hl_get_attr_by_id(Integer attr_id, Boolean rgb, Arena *arena, Error *err)
 {
   Dictionary dic = ARRAY_DICT_INIT;
 
@@ -801,25 +801,21 @@ Dictionary hl_get_attr_by_id(Integer attr_id, Boolean rgb, Error *err)
                   "Invalid attribute id: %" PRId64, attr_id);
     return dic;
   }
-
-  return hlattrs2dict(NULL, syn_attr2entry((int)attr_id), rgb);
+  Dictionary retval = arena_dict(arena, HLATTRS_DICT_SIZE);
+  hlattrs2dict(&retval, syn_attr2entry((int)attr_id), rgb);
+  return retval;
 }
 
 /// Converts an HlAttrs into Dictionary
 ///
-/// @param[out] hl optional pre-allocated dictionary for return value
-///                if present, must be allocated with at least 16 elements!
+/// @param[in/out] hl Dictionary with pre-allocated space for HLATTRS_DICT_SIZE elements
 /// @param[in] aep data to convert
 /// @param use_rgb use 'gui*' settings if true, else resorts to 'cterm*'
-Dictionary hlattrs2dict(Dictionary *hl_alloc, HlAttrs ae, bool use_rgb)
+void hlattrs2dict(Dictionary *dict, HlAttrs ae, bool use_rgb)
 {
+  assert(dict->capacity >= HLATTRS_DICT_SIZE);  // at most 16 items
+  Dictionary hl = *dict;
   int mask  = use_rgb ? ae.rgb_ae_attr : ae.cterm_ae_attr;
-  Dictionary hl = ARRAY_DICT_INIT;
-  if (hl_alloc) {
-    hl = *hl_alloc;
-  } else {
-    kv_ensure_space(hl, 16);
-  }
 
   if (mask & HL_BOLD) {
     PUT_C(hl, "bold", BOOLEAN_OBJ(true));
@@ -899,14 +895,7 @@ Dictionary hlattrs2dict(Dictionary *hl_alloc, HlAttrs ae, bool use_rgb)
     PUT_C(hl, "blend", INTEGER_OBJ(ae.hl_blend));
   }
 
-  if (hl_alloc) {
-    *hl_alloc = hl;
-    return hl;
-  } else {
-    Dictionary allocated = copy_dictionary(hl, NULL);
-    kv_destroy(hl);
-    return allocated;
-  }
+  *dict = hl;
 }
 
 HlAttrs dict2hlattrs(Dict(highlight) *dict, bool use_rgb, int *link_id, Error *err)
@@ -1086,6 +1075,7 @@ int object_to_color(Object val, char *key, bool rgb, Error *err)
 
 Array hl_inspect(int attr)
 {
+  // TODO(bfredl): use arena allocation
   Array ret = ARRAY_DICT_INIT;
   if (hlstate_active) {
     hl_inspect_impl(&ret, attr);
diff --git a/src/nvim/highlight.h b/src/nvim/highlight.h
index 50299bb91c..e85e3859e2 100644
--- a/src/nvim/highlight.h
+++ b/src/nvim/highlight.h
@@ -19,6 +19,8 @@ static inline int win_hl_attr(win_T *wp, int hlf)
   return ((wp->w_ns_hl_attr && ns_hl_fast < 0) ? wp->w_ns_hl_attr : hl_attr_active)[hlf];
 }
 
+#define HLATTRS_DICT_SIZE 16
+
 #define HL_SET_DEFAULT_COLORS(rgb_fg, rgb_bg, rgb_sp) \
   do { \
     bool dark_ = (*p_bg == 'd'); \
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index ed1f0185b7..97d4b421fe 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -1466,19 +1466,21 @@ static void highlight_list_one(const int id)
   }
 }
 
-Dictionary get_global_hl_defs(void)
+Dictionary get_global_hl_defs(Arena *arena)
 {
-  Dictionary rv = ARRAY_DICT_INIT;
-  for (int i = 1; i <= highlight_ga.ga_len && !got_int; i++) {
+  Dictionary rv = arena_dict(arena, (size_t)highlight_ga.ga_len);
+  for (int i = 1; i <= highlight_ga.ga_len; i++) {
     Dictionary attrs = ARRAY_DICT_INIT;
     HlGroup *h = &hl_table[i - 1];
     if (h->sg_attr > 0) {
-      attrs = hlattrs2dict(NULL, syn_attr2entry(h->sg_attr), true);
+      attrs = arena_dict(arena, HLATTRS_DICT_SIZE);
+      hlattrs2dict(&attrs, syn_attr2entry(h->sg_attr), true);
     } else if (h->sg_link > 0) {
-      const char *link = (const char *)hl_table[h->sg_link - 1].sg_name;
-      PUT(attrs, "link", STRING_OBJ(cstr_to_string(link)));
+      attrs = arena_dict(arena, 1);
+      char *link = (char *)hl_table[h->sg_link - 1].sg_name;
+      PUT_C(attrs, "link", STRING_OBJ(cstr_as_string(link)));
     }
-    PUT(rv, (const char *)h->sg_name, DICTIONARY_OBJ(attrs));
+    PUT_C(rv, (char *)h->sg_name, DICTIONARY_OBJ(attrs));
   }
 
   return rv;
-- 
cgit 


From bd51ac2a347c0a3efb64e4b09400b7314286844c Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/cmdexpand.c     |   4 +-
 src/nvim/debugger.c      |  50 ++++----
 src/nvim/decoration.c    |   2 +-
 src/nvim/drawline.c      |   4 +-
 src/nvim/edit.c          |   4 +-
 src/nvim/eval.c          |   6 +-
 src/nvim/eval/funcs.c    |   4 +-
 src/nvim/eval/userfunc.c |  16 +--
 src/nvim/eval/vars.c     |   4 +-
 src/nvim/ex_cmds.c       |   6 +-
 src/nvim/ex_docmd.c      |  14 +--
 src/nvim/ex_getln.c      |  21 ++--
 src/nvim/fold.c          | 104 ++++++++--------
 src/nvim/mbyte.c         |  21 ++--
 src/nvim/path.c          |   2 +-
 src/nvim/regexp.c        |  53 ++++----
 src/nvim/regexp_bt.c     |  14 +--
 src/nvim/regexp_nfa.c    |   8 +-
 src/nvim/search.c        |   4 +-
 src/nvim/shada.c         |   2 +-
 src/nvim/sign.c          | 317 +++++++++++++++++++++++------------------------
 src/nvim/sign_defs.h     |   2 +-
 src/nvim/spell.c         |   4 +-
 src/nvim/syntax.c        | 247 ++++++++++++++++++------------------
 src/nvim/tag.c           |  88 +++++++------
 src/nvim/ui.c            |   2 +-
 26 files changed, 493 insertions(+), 510 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 1c35f28301..7e2adf7f29 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -1424,7 +1424,7 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
     set_context_in_cscope_cmd(xp, arg, cmdidx);
     break;
   case CMD_sign:
-    set_context_in_sign_cmd(xp, (char_u *)arg);
+    set_context_in_sign_cmd(xp, (char *)arg);
     break;
   case CMD_bdelete:
   case CMD_bwipeout:
@@ -2890,7 +2890,7 @@ void f_getcompletion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   if (xpc.xp_context == EXPAND_SIGN) {
-    set_context_in_sign_cmd(&xpc, (char_u *)xpc.xp_pattern);
+    set_context_in_sign_cmd(&xpc, xpc.xp_pattern);
     xpc.xp_pattern_len = STRLEN(xpc.xp_pattern);
   }
 
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index 36df62b502..b720628e33 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -33,7 +33,7 @@ static char *debug_newval = NULL;
 struct debuggy {
   int dbg_nr;                   ///< breakpoint number
   int dbg_type;                 ///< DBG_FUNC or DBG_FILE or DBG_EXPR
-  char_u *dbg_name;             ///< function, expression or file name
+  char *dbg_name;               ///< function, expression or file name
   regprog_T *dbg_prog;          ///< regexp program
   linenr_T dbg_lnum;            ///< line number in function or file
   int dbg_forceit;              ///< ! used
@@ -60,7 +60,7 @@ void do_debug(char *cmd)
   bool typeahead_saved = false;
   int save_ignore_script = 0;
   int n;
-  char_u *cmdline = NULL;
+  char *cmdline = NULL;
   char *p;
   char *tail = NULL;
   static int last_cmd = 0;
@@ -129,8 +129,8 @@ void do_debug(char *cmd)
     }
 
     xfree(cmdline);
-    cmdline = (char_u *)getcmdline_prompt('>', NULL, 0, EXPAND_NOTHING, NULL,
-                                          CALLBACK_NONE);
+    cmdline = getcmdline_prompt('>', NULL, 0, EXPAND_NOTHING, NULL,
+                                CALLBACK_NONE);
 
     if (typeahead_saved) {
       restore_typeahead(&typeaheadbuf);
@@ -144,7 +144,7 @@ void do_debug(char *cmd)
       // If this is a debug command, set "last_cmd".
       // If not, reset "last_cmd".
       // For a blank line use previous command.
-      p = skipwhite((char *)cmdline);
+      p = skipwhite(cmdline);
       if (*p != NUL) {
         switch (*p) {
         case 'c':
@@ -239,14 +239,14 @@ void do_debug(char *cmd)
           last_cmd = CMD_STEP;
           break;
         case CMD_BACKTRACE:
-          do_showbacktrace((char_u *)cmd);
+          do_showbacktrace(cmd);
           continue;
         case CMD_FRAME:
           if (*p == NUL) {
-            do_showbacktrace((char_u *)cmd);
+            do_showbacktrace(cmd);
           } else {
             p = skipwhite(p);
-            do_setdebugtracelevel((char_u *)p);
+            do_setdebugtracelevel(p);
           }
           continue;
         case CMD_UP:
@@ -266,7 +266,7 @@ void do_debug(char *cmd)
       // don't debug this command
       n = debug_break_level;
       debug_break_level = -1;
-      (void)do_cmdline((char *)cmdline, getexline, NULL, DOCMD_VERBOSE|DOCMD_EXCRESET);
+      (void)do_cmdline(cmdline, getexline, NULL, DOCMD_VERBOSE|DOCMD_EXCRESET);
       debug_break_level = n;
     }
     lines_left = Rows - 1;
@@ -306,9 +306,9 @@ static int get_maxbacktrace_level(char *sname)
   return maxbacktrace;
 }
 
-static void do_setdebugtracelevel(char_u *arg)
+static void do_setdebugtracelevel(char *arg)
 {
-  int level = atoi((char *)arg);
+  int level = atoi(arg);
   if (*arg == '+' || level < 0) {
     debug_backtrace_level += level;
   } else {
@@ -335,7 +335,7 @@ static void do_checkbacktracelevel(void)
   }
 }
 
-static void do_showbacktrace(char_u *cmd)
+static void do_showbacktrace(char *cmd)
 {
   char *sname = estack_sfile(ESTACK_NONE);
   int max = get_maxbacktrace_level(sname);
@@ -470,7 +470,7 @@ static typval_T *eval_expr_no_emsg(struct debuggy *const bp)
 {
   // Disable error messages, a bad expression would make Vim unusable.
   emsg_off++;
-  typval_T *const tv = eval_expr((char *)bp->dbg_name);
+  typval_T *const tv = eval_expr(bp->dbg_name);
   emsg_off--;
   return tv;
 }
@@ -482,9 +482,9 @@ static typval_T *eval_expr_no_emsg(struct debuggy *const bp)
 ///
 /// @param arg
 /// @param gap  either &dbg_breakp or &prof_ga
-static int dbg_parsearg(char_u *arg, garray_T *gap)
+static int dbg_parsearg(char *arg, garray_T *gap)
 {
-  char *p = (char *)arg;
+  char *p = arg;
   char *q;
   bool here = false;
 
@@ -531,11 +531,11 @@ static int dbg_parsearg(char_u *arg, garray_T *gap)
   }
 
   if (bp->dbg_type == DBG_FUNC) {
-    bp->dbg_name = vim_strsave((char_u *)p);
+    bp->dbg_name = xstrdup(p);
   } else if (here) {
-    bp->dbg_name = vim_strsave((char_u *)curbuf->b_ffname);
+    bp->dbg_name = xstrdup(curbuf->b_ffname);
   } else if (bp->dbg_type == DBG_EXPR) {
-    bp->dbg_name = vim_strsave((char_u *)p);
+    bp->dbg_name = xstrdup(p);
     bp->dbg_val = eval_expr_no_emsg(bp);
   } else {
     // Expand the file name in the same way as do_source().  This means
@@ -551,10 +551,10 @@ static int dbg_parsearg(char_u *arg, garray_T *gap)
       return FAIL;
     }
     if (*p != '*') {
-      bp->dbg_name = (char_u *)fix_fname(p);
+      bp->dbg_name = fix_fname(p);
       xfree(p);
     } else {
-      bp->dbg_name = (char_u *)p;
+      bp->dbg_name = p;
     }
   }
 
@@ -572,12 +572,12 @@ void ex_breakadd(exarg_T *eap)
     gap = &prof_ga;
   }
 
-  if (dbg_parsearg((char_u *)eap->arg, gap) == OK) {
+  if (dbg_parsearg(eap->arg, gap) == OK) {
     struct debuggy *bp = &DEBUGGY(gap, gap->ga_len);
     bp->dbg_forceit = eap->forceit;
 
     if (bp->dbg_type != DBG_EXPR) {
-      char *pat = file_pat_to_reg_pat((char *)bp->dbg_name, NULL, NULL, false);
+      char *pat = file_pat_to_reg_pat(bp->dbg_name, NULL, NULL, false);
       if (pat != NULL) {
         bp->dbg_prog = vim_regcomp(pat, RE_MAGIC + RE_STRING);
         xfree(pat);
@@ -639,7 +639,7 @@ void ex_breakdel(exarg_T *eap)
     del_all = true;
   } else {
     // ":breakdel {func|file|expr} [lnum] {name}"
-    if (dbg_parsearg((char_u *)eap->arg, gap) == FAIL) {
+    if (dbg_parsearg(eap->arg, gap) == FAIL) {
       return;
     }
     bp = &DEBUGGY(gap, gap->ga_len);
@@ -697,13 +697,13 @@ void ex_breaklist(exarg_T *eap)
     for (int i = 0; i < dbg_breakp.ga_len; i++) {
       struct debuggy *bp = &BREAKP(i);
       if (bp->dbg_type == DBG_FILE) {
-        home_replace(NULL, (char *)bp->dbg_name, (char *)NameBuff, MAXPATHL, true);
+        home_replace(NULL, bp->dbg_name, (char *)NameBuff, MAXPATHL, true);
       }
       if (bp->dbg_type != DBG_EXPR) {
         smsg(_("%3d  %s %s  line %" PRId64),
              bp->dbg_nr,
              bp->dbg_type == DBG_FUNC ? "func" : "file",
-             bp->dbg_type == DBG_FUNC ? bp->dbg_name : (char_u *)NameBuff,
+             bp->dbg_type == DBG_FUNC ? bp->dbg_name : NameBuff,
              (int64_t)bp->dbg_lnum);
       } else {
         smsg(_("%3d  expr %s"), bp->dbg_nr, bp->dbg_name);
diff --git a/src/nvim/decoration.c b/src/nvim/decoration.c
index 9f3e5a8638..8955048f45 100644
--- a/src/nvim/decoration.c
+++ b/src/nvim/decoration.c
@@ -394,7 +394,7 @@ void decor_redraw_signs(buf_T *buf, int row, int *num_signs, SignTextAttrs sattr
       }
       if (j < SIGN_SHOW_MAX) {
         sattrs[j] = (SignTextAttrs) {
-          .text = decor->sign_text,
+          .text = (char *)decor->sign_text,
           .hl_attr_id = decor->sign_hl_id == 0 ? 0 : syn_id2attr(decor->sign_hl_id),
           .priority = decor->priority
         };
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 66d8a1fb32..85a0bf2f5f 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -306,7 +306,7 @@ static void get_sign_display_info(bool nrcol, win_T *wp, linenr_T lnum, SignText
   if (row == startrow + filler_lines && filler_todo <= 0) {
     SignTextAttrs *sattr = sign_get_attr(sign_idx, sattrs, wp->w_scwidth);
     if (sattr != NULL) {
-      *pp_extra = sattr->text;
+      *pp_extra = (char_u *)sattr->text;
       if (*pp_extra != NULL) {
         *c_extrap = NUL;
         *c_finalp = NUL;
@@ -1349,7 +1349,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
 
       linenr_T lnume = lnum + foldinfo.fi_lines - 1;
       memset(buf_fold, ' ', FOLD_TEXT_LEN);
-      p_extra = get_foldtext(wp, lnum, lnume, foldinfo, buf_fold);
+      p_extra = (char_u *)get_foldtext(wp, lnum, lnume, foldinfo, (char *)buf_fold);
       n_extra = (int)STRLEN(p_extra);
 
       if (p_extra != buf_fold) {
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 642162284c..9144d055f7 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -3236,7 +3236,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           assert(p >= look && (uintmax_t)(p - look) <= SIZE_MAX);
           if (s + (p - look) <= line + curwin->w_cursor.col
               && (icase
-                  ? mb_strnicmp(s, look, (size_t)(p - look))
+                  ? mb_strnicmp((char *)s, (char *)look, (size_t)(p - look))
                   : STRNCMP(s, look, p - look)) == 0) {
             match = true;
           }
@@ -3250,7 +3250,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
             if ((curwin->w_cursor.col == (colnr_T)(p - look)
                  || !vim_iswordc(line[-(p - look) - 1]))
                 && (icase
-                    ? mb_strnicmp(line - (p - look), look, (size_t)(p - look))
+                    ? mb_strnicmp((char *)line - (p - look), (char *)look, (size_t)(p - look))
                     : STRNCMP(line - (p - look), look, p - look)) == 0) {
               match = true;
             }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 2ade64df3f..0b03cf3011 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2292,7 +2292,7 @@ int eval0(char *arg, typval_T *rettv, char **nextcmd, int evaluate)
     ret = FAIL;
   }
   if (nextcmd != NULL) {
-    *nextcmd = (char *)check_nextcmd((char_u *)p);
+    *nextcmd = check_nextcmd(p);
   }
 
   return ret;
@@ -7639,7 +7639,7 @@ void ex_echo(exarg_T *eap)
     tv_clear(&rettv);
     arg = skipwhite(arg);
   }
-  eap->nextcmd = (char *)check_nextcmd((char_u *)arg);
+  eap->nextcmd = check_nextcmd(arg);
 
   if (eap->skip) {
     emsg_skip--;
@@ -7736,7 +7736,7 @@ void ex_execute(exarg_T *eap)
     emsg_skip--;
   }
 
-  eap->nextcmd = (char *)check_nextcmd((char_u *)arg);
+  eap->nextcmd = check_nextcmd(arg);
 }
 
 /// Skip over the name of an option: "&option", "&g:option" or "&l:option".
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 6593a34f4a..5a5293780d 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1065,7 +1065,7 @@ static void f_count(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         const size_t len = STRLEN(expr);
 
         while (*p != NUL) {
-          if (mb_strnicmp(p, expr, len) == 0) {
+          if (mb_strnicmp((char *)p, (char *)expr, len) == 0) {
             n++;
             p += len;
           } else {
@@ -8687,7 +8687,7 @@ static void f_submatch(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   if (retList == 0) {
     rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = (char *)reg_submatch(no);
+    rettv->vval.v_string = reg_submatch(no);
   } else {
     rettv->v_type = VAR_LIST;
     rettv->vval.v_list = reg_submatch_list(no);
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 21bd662db5..bcaca0ca13 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1942,7 +1942,7 @@ void ex_function(exarg_T *eap)
         }
       }
     }
-    eap->nextcmd = (char *)check_nextcmd((char_u *)eap->arg);
+    eap->nextcmd = check_nextcmd(eap->arg);
     return;
   }
 
@@ -1978,7 +1978,7 @@ void ex_function(exarg_T *eap)
     if (*p == '/') {
       p++;
     }
-    eap->nextcmd = (char *)check_nextcmd(p);
+    eap->nextcmd = check_nextcmd((char *)p);
     return;
   }
 
@@ -2032,7 +2032,7 @@ void ex_function(exarg_T *eap)
       semsg(_(e_trailing_arg), p);
       goto ret_free;
     }
-    eap->nextcmd = (char *)check_nextcmd(p);
+    eap->nextcmd = check_nextcmd((char *)p);
     if (eap->nextcmd != NULL) {
       *p = NUL;
     }
@@ -2590,8 +2590,8 @@ int eval_fname_script(const char *const p)
   // Use mb_strnicmp() because in Turkish comparing the "I" may not work with
   // the standard library function.
   if (p[0] == '<'
-      && (mb_strnicmp((char_u *)p + 1, (char_u *)"SID>", 4) == 0
-          || mb_strnicmp((char_u *)p + 1, (char_u *)"SNR>", 4) == 0)) {
+      && (mb_strnicmp(p + 1, "SID>", 4) == 0
+          || mb_strnicmp(p + 1, "SNR>", 4) == 0)) {
     return 5;
   }
   if (p[0] == 's' && p[1] == ':') {
@@ -2700,7 +2700,7 @@ void ex_delfunction(exarg_T *eap)
     semsg(_(e_trailing_arg), p);
     return;
   }
-  eap->nextcmd = (char *)check_nextcmd(p);
+  eap->nextcmd = check_nextcmd((char *)p);
   if (eap->nextcmd != NULL) {
     *p = NUL;
   }
@@ -2889,7 +2889,7 @@ void ex_return(exarg_T *eap)
   if (returning) {
     eap->nextcmd = NULL;
   } else if (eap->nextcmd == NULL) {          // no argument
-    eap->nextcmd = (char *)check_nextcmd(arg);
+    eap->nextcmd = check_nextcmd((char *)arg);
   }
 
   if (eap->skip) {
@@ -3018,7 +3018,7 @@ void ex_call(exarg_T *eap)
         semsg(_(e_trailing_arg), arg);
       }
     } else {
-      eap->nextcmd = (char *)check_nextcmd(arg);
+      eap->nextcmd = check_nextcmd((char *)arg);
     }
   }
 
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index dbbb03b1b8..ba58254bdd 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -207,7 +207,7 @@ static void ex_let_const(exarg_T *eap, const bool is_const)
       list_func_vars(&first);
       list_vim_vars(&first);
     }
-    eap->nextcmd = (char *)check_nextcmd((char_u *)arg);
+    eap->nextcmd = check_nextcmd(arg);
   } else if (expr[0] == '=' && expr[1] == '<' && expr[2] == '<') {
     // HERE document
     list_T *l = heredoc_get(eap, expr + 3);
@@ -824,7 +824,7 @@ static void ex_unletlock(exarg_T *eap, char *argstart, int deep, ex_unletlock_ca
     arg = skipwhite(name_end);
   } while (!ends_excmd(*arg));
 
-  eap->nextcmd = (char *)check_nextcmd((char_u *)arg);
+  eap->nextcmd = check_nextcmd(arg);
 }
 
 // TODO(ZyX-I): move to eval/ex_cmds
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 17d45f207e..d050562e4c 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -509,8 +509,8 @@ void ex_sort(exarg_T *eap)
     } else if (*p == '"') {
       // comment start
       break;
-    } else if (check_nextcmd((char_u *)p) != NULL) {
-      eap->nextcmd = (char *)check_nextcmd((char_u *)p);
+    } else if (check_nextcmd(p) != NULL) {
+      eap->nextcmd = check_nextcmd(p);
       break;
     } else if (!ASCII_ISALPHA(*p) && regmatch.regprog == NULL) {
       s = skip_regexp(p + 1, *p, true, NULL);
@@ -3625,7 +3625,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
    */
   cmd = skipwhite(cmd);
   if (*cmd && *cmd != '"') {        // if not end-of-line or comment
-    eap->nextcmd = (char *)check_nextcmd((char_u *)cmd);
+    eap->nextcmd = check_nextcmd(cmd);
     if (eap->nextcmd == NULL) {
       semsg(_(e_trailing_arg), cmd);
       return 0;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 8f72ba0e23..01d141e557 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -1929,7 +1929,7 @@ static char *do_one_cmd(char **cmdlinep, int flags, cstack_T *cstack, LineGetter
   // If we got a line, but no command, then go to the line.
   // If we find a '|' or '\n' we set ea.nextcmd.
   if (*ea.cmd == NUL || *ea.cmd == '"'
-      || (ea.nextcmd = (char *)check_nextcmd((char_u *)ea.cmd)) != NULL) {
+      || (ea.nextcmd = check_nextcmd(ea.cmd)) != NULL) {
     // strange vi behaviour:
     // ":3"     jumps to line 3
     // ":3|..." prints line 3
@@ -3934,7 +3934,7 @@ void separate_nextcmd(exarg_T *eap)
         STRMOVE(p - 1, p);  // remove the '\'
         p--;
       } else {
-        eap->nextcmd = (char *)check_nextcmd((char_u *)p);
+        eap->nextcmd = check_nextcmd(p);
         *p = NUL;
         break;
       }
@@ -4311,12 +4311,12 @@ char *find_nextcmd(const char *p)
 /// Check if *p is a separator between Ex commands, skipping over white space.
 ///
 /// @return  NULL if it isn't, the following character if it is.
-char_u *check_nextcmd(char_u *p)
+char *check_nextcmd(char *p)
 {
-  char *s = skipwhite((char *)p);
+  char *s = skipwhite(p);
 
   if (*s == '|' || *s == '\n') {
-    return (char_u *)(s + 1);
+    return s + 1;
   } else {
     return NULL;
   }
@@ -5674,7 +5674,7 @@ static void ex_wincmd(exarg_T *eap)
     p = eap->arg + 1;
   }
 
-  eap->nextcmd = (char *)check_nextcmd((char_u *)p);
+  eap->nextcmd = check_nextcmd(p);
   p = skipwhite(p);
   if (*p != NUL && *p != '"' && eap->nextcmd == NULL) {
     emsg(_(e_invarg));
@@ -6465,7 +6465,7 @@ static void ex_findpat(exarg_T *eap)
       if (!ends_excmd(*p)) {
         eap->errmsg = ex_errmsg(e_trailing_arg, p);
       } else {
-        eap->nextcmd = (char *)check_nextcmd((char_u *)p);
+        eap->nextcmd = check_nextcmd(p);
       }
     }
   }
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index e8af99805d..9d1cebd43e 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -328,7 +328,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
     int empty;
 
     *end = NUL;
-    empty = empty_pattern((char_u *)p);
+    empty = empty_pattern(p);
     *end = c;
     if (empty) {
       goto theend;
@@ -489,7 +489,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
   if (!use_last_pat) {
     next_char = ccline.cmdbuff[skiplen + patlen];
     ccline.cmdbuff[skiplen + patlen] = NUL;
-    if (empty_pattern(ccline.cmdbuff) && !no_hlsearch) {
+    if (empty_pattern((char *)ccline.cmdbuff) && !no_hlsearch) {
       redraw_all_later(UPD_SOME_VALID);
       set_no_hlsearch(true);
     }
@@ -2027,7 +2027,7 @@ static int command_line_not_changed(CommandLineState *s)
 
 /// Guess that the pattern matches everything.  Only finds specific cases, such
 /// as a trailing \|, which can happen while typing a pattern.
-static int empty_pattern(char_u *p)
+static int empty_pattern(char *p)
 {
   size_t n = STRLEN(p);
 
@@ -3952,8 +3952,9 @@ static int get_cmdline_type(void)
 
 /// Get the current command line in allocated memory.
 /// Only works when the command line is being edited.
-/// Returns NULL when something is wrong.
-static char_u *get_cmdline_str(void)
+///
+/// @return  NULL when something is wrong.
+static char *get_cmdline_str(void)
 {
   if (cmdline_star > 0) {
     return NULL;
@@ -3963,11 +3964,11 @@ static char_u *get_cmdline_str(void)
   if (p == NULL) {
     return NULL;
   }
-  return vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
+  return (char *)vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
 }
 
 /// Get the current command-line completion type.
-static char_u *get_cmdline_completion(void)
+static char *get_cmdline_completion(void)
 {
   if (cmdline_star > 0) {
     return NULL;
@@ -3978,7 +3979,7 @@ static char_u *get_cmdline_completion(void)
     set_expand_context(p->xpc);
     char *cmd_compl = get_user_cmd_complete(p->xpc, p->xpc->xp_context);
     if (cmd_compl != NULL) {
-      return vim_strsave((char_u *)cmd_compl);
+      return xstrdup(cmd_compl);
     }
   }
 
@@ -3989,14 +3990,14 @@ static char_u *get_cmdline_completion(void)
 void f_getcmdcompltype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)get_cmdline_completion();
+  rettv->vval.v_string = get_cmdline_completion();
 }
 
 /// "getcmdline()" function
 void f_getcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)get_cmdline_str();
+  rettv->vval.v_string = get_cmdline_str();
 }
 
 /// "getcmdpos()" function
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index d8c864df5b..0f085df3d0 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -111,7 +111,7 @@ static int prev_lnum_lvl = -1;
 #define DONE_FOLD       2       // did find a fold
 
 static size_t foldstartmarkerlen;
-static char_u *foldendmarker;
+static char *foldendmarker;
 static size_t foldendmarkerlen;
 
 // Exported folding functions. {{{1
@@ -982,7 +982,7 @@ void foldAdjustVisual(void)
   }
 
   pos_T *start, *end;
-  char_u *ptr;
+  char *ptr;
 
   if (ltoreq(VIsual, curwin->w_cursor)) {
     start = &VIsual;
@@ -995,7 +995,7 @@ void foldAdjustVisual(void)
     start->col = 0;
   }
   if (hasFolding(end->lnum, NULL, &end->lnum)) {
-    ptr = (char_u *)ml_get(end->lnum);
+    ptr = ml_get(end->lnum);
     end->col = (colnr_T)STRLEN(ptr);
     if (end->col > 0 && *p_sel == 'o') {
       end->col--;
@@ -1556,7 +1556,7 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
   }
   parseMarker(wp);
 
-  foldAddMarker(buf, start, (char_u *)wp->w_p_fmr, foldstartmarkerlen);
+  foldAddMarker(buf, start, wp->w_p_fmr, foldstartmarkerlen);
   foldAddMarker(buf, end, foldendmarker, foldendmarkerlen);
 
   // Update both changes here, to avoid all folds after the start are
@@ -1573,22 +1573,22 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
 
 // foldAddMarker() {{{2
 /// Add "marker[markerlen]" in 'commentstring' to position `pos`.
-static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t markerlen)
+static void foldAddMarker(buf_T *buf, pos_T pos, const char *marker, size_t markerlen)
 {
-  char_u *cms = (char_u *)buf->b_p_cms;
-  char_u *newline;
-  char_u *p = (char_u *)strstr(buf->b_p_cms, "%s");
+  char *cms = buf->b_p_cms;
+  char *newline;
+  char *p = strstr(buf->b_p_cms, "%s");
   bool line_is_comment = false;
   linenr_T lnum = pos.lnum;
 
   // Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end
-  char_u *line = ml_get_buf(buf, lnum, false);
+  char *line = (char *)ml_get_buf(buf, lnum, false);
   size_t line_len = STRLEN(line);
   size_t added = 0;
 
   if (u_save(lnum - 1, lnum + 1) == OK) {
     // Check if the line ends with an unclosed comment
-    skip_comment((char *)line, false, false, &line_is_comment);
+    skip_comment(line, false, false, &line_is_comment);
     newline = xmalloc(line_len + markerlen + STRLEN(cms) + 1);
     STRCPY(newline, line);
     // Append the marker to the end of the line
@@ -1601,7 +1601,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char_u *marker, size_t ma
       STRCPY(newline + line_len + (p - cms) + markerlen, p + 2);
       added = markerlen + STRLEN(cms) - 2;
     }
-    ml_replace_buf(buf, lnum, (char *)newline, false);
+    ml_replace_buf(buf, lnum, newline, false);
     if (added) {
       extmark_splice_cols(buf, (int)lnum - 1, (int)line_len,
                           0, (int)added, kExtmarkUndo);
@@ -1621,7 +1621,7 @@ static void deleteFoldMarkers(win_T *wp, fold_T *fp, int recursive, linenr_T lnu
                         lnum_off + fp->fd_top);
     }
   }
-  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off, (char_u *)wp->w_p_fmr,
+  foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off, wp->w_p_fmr,
                 foldstartmarkerlen);
   foldDelMarker(wp->w_buffer, fp->fd_top + lnum_off + fp->fd_len - 1,
                 foldendmarker, foldendmarkerlen);
@@ -1632,16 +1632,16 @@ static void deleteFoldMarkers(win_T *wp, fold_T *fp, int recursive, linenr_T lnu
 /// Delete 'commentstring' if it matches.
 /// If the marker is not found, there is no error message.  Could be a missing
 /// close-marker.
-static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t markerlen)
+static void foldDelMarker(buf_T *buf, linenr_T lnum, char *marker, size_t markerlen)
 {
   // end marker may be missing and fold extends below the last line
   if (lnum > buf->b_ml.ml_line_count) {
     return;
   }
 
-  char_u *cms = (char_u *)buf->b_p_cms;
-  char_u *line = ml_get_buf(buf, lnum, false);
-  for (char_u *p = line; *p != NUL; p++) {
+  char *cms = buf->b_p_cms;
+  char *line = (char *)ml_get_buf(buf, lnum, false);
+  for (char *p = line; *p != NUL; p++) {
     if (STRNCMP(p, marker, markerlen) != 0) {
       continue;
     }
@@ -1652,7 +1652,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
     }
     if (*cms != NUL) {
       // Also delete 'commentstring' if it matches.
-      char_u *cms2 = (char_u *)strstr((char *)cms, "%s");
+      char *cms2 = strstr(cms, "%s");
       if (p - line >= cms2 - cms
           && STRNCMP(p - (cms2 - cms), cms, cms2 - cms) == 0
           && STRNCMP(p + len, cms2 + 2, STRLEN(cms2 + 2)) == 0) {
@@ -1662,11 +1662,11 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
     }
     if (u_save(lnum - 1, lnum + 1) == OK) {
       // Make new line: text-before-marker + text-after-marker
-      char_u *newline = xmalloc(STRLEN(line) - len + 1);
+      char *newline = xmalloc(STRLEN(line) - len + 1);
       assert(p >= line);
       memcpy(newline, line, (size_t)(p - line));
       STRCPY(newline + (p - line), p + len);
-      ml_replace_buf(buf, lnum, (char *)newline, false);
+      ml_replace_buf(buf, lnum, newline, false);
       extmark_splice_cols(buf, (int)lnum - 1, (int)(p - line),
                           (int)len, 0, kExtmarkUndo);
     }
@@ -1683,10 +1683,10 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char_u *marker, size_t mark
 /// @return the text for a closed fold
 ///
 /// Otherwise the result is in allocated memory.
-char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldinfo, char_u *buf)
+char *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldinfo, char *buf)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  char_u *text = NULL;
+  char *text = NULL;
   // an error occurred when evaluating 'fdt' setting
   static bool got_fdt_error = false;
   int save_did_emsg = did_emsg;
@@ -1728,9 +1728,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
       curbuf = wp->w_buffer;
 
       emsg_silent++;       // handle exceptions, but don't display errors
-      text =
-        (char_u *)eval_to_string_safe(wp->w_p_fdt, NULL,
-                                      was_set_insecurely(wp, "foldtext", OPT_LOCAL));
+      text = eval_to_string_safe(wp->w_p_fdt, NULL, was_set_insecurely(wp, "foldtext", OPT_LOCAL));
       emsg_silent--;
 
       if (text == NULL || did_emsg) {
@@ -1751,23 +1749,23 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
     if (text != NULL) {
       // Replace unprintable characters, if there are any.  But
       // replace a TAB with a space.
-      char_u *p;
+      char *p;
       for (p = text; *p != NUL; p++) {
-        int len = utfc_ptr2len((char *)p);
+        int len = utfc_ptr2len(p);
 
         if (len > 1) {
-          if (!vim_isprintc(utf_ptr2char((char *)p))) {
+          if (!vim_isprintc(utf_ptr2char(p))) {
             break;
           }
           p += len - 1;
         } else if (*p == TAB) {
           *p = ' ';
-        } else if (ptr2cells((char *)p) > 1) {
+        } else if (ptr2cells(p) > 1) {
           break;
         }
       }
       if (*p != NUL) {
-        p = (char_u *)transstr((const char *)text, true);
+        p = transstr((const char *)text, true);
         xfree(text);
         text = p;
       }
@@ -1776,7 +1774,7 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
   if (text == NULL) {
     unsigned long count = (unsigned long)(lnume - lnum + 1);
 
-    vim_snprintf((char *)buf, FOLD_TEXT_LEN,
+    vim_snprintf(buf, FOLD_TEXT_LEN,
                  NGETTEXT("+--%3ld line folded",
                           "+--%3ld lines folded ", count),
                  count);
@@ -1787,17 +1785,17 @@ char_u *get_foldtext(win_T *wp, linenr_T lnum, linenr_T lnume, foldinfo_T foldin
 
 // foldtext_cleanup() {{{2
 /// Remove 'foldmarker' and 'commentstring' from "str" (in-place).
-static void foldtext_cleanup(char_u *str)
+static void foldtext_cleanup(char *str)
 {
   // Ignore leading and trailing white space in 'commentstring'.
-  char_u *cms_start = (char_u *)skipwhite(curbuf->b_p_cms);
+  char *cms_start = skipwhite(curbuf->b_p_cms);
   size_t cms_slen = STRLEN(cms_start);
   while (cms_slen > 0 && ascii_iswhite(cms_start[cms_slen - 1])) {
     cms_slen--;
   }
 
   // locate "%s" in 'commentstring', use the part before and after it.
-  char_u *cms_end = (char_u *)strstr((char *)cms_start, "%s");
+  char *cms_end = strstr(cms_start, "%s");
   size_t cms_elen = 0;
   if (cms_end != NULL) {
     cms_elen = cms_slen - (size_t)(cms_end - cms_start);
@@ -1809,7 +1807,7 @@ static void foldtext_cleanup(char_u *str)
     }
 
     // skip "%s" and white space after it
-    char_u *s = (char_u *)skipwhite((char *)cms_end + 2);
+    char *s = skipwhite(cms_end + 2);
     cms_elen -= (size_t)(s - cms_end);
     cms_end = s;
   }
@@ -1818,7 +1816,7 @@ static void foldtext_cleanup(char_u *str)
   bool did1 = false;
   bool did2 = false;
 
-  for (char_u *s = str; *s != NUL;) {
+  for (char *s = str; *s != NUL;) {
     size_t len = 0;
     if (STRNCMP(s, curwin->w_p_fmr, foldstartmarkerlen) == 0) {
       len = foldstartmarkerlen;
@@ -1832,7 +1830,7 @@ static void foldtext_cleanup(char_u *str)
 
       // May remove 'commentstring' start.  Useful when it's a double
       // quote and we already removed a double quote.
-      char_u *p;
+      char *p;
       for (p = s; p > str && ascii_iswhite(p[-1]); p--) {}
       if (p >= str + cms_slen
           && STRNCMP(p - cms_slen, cms_start, cms_slen) == 0) {
@@ -2850,7 +2848,7 @@ static void foldlevelIndent(fline_T *flp)
   linenr_T lnum = flp->lnum + flp->off;
 
   buf_T *buf = flp->wp->w_buffer;
-  char_u *s = (char_u *)skipwhite((char *)ml_get_buf(buf, lnum, false));
+  char *s = skipwhite((char *)ml_get_buf(buf, lnum, false));
 
   // empty line or lines starting with a character in 'foldignore': level
   // depends on surrounding lines
@@ -2985,8 +2983,8 @@ static void foldlevelExpr(fline_T *flp)
 /// Relies on the option value to have been checked for correctness already.
 static void parseMarker(win_T *wp)
 {
-  foldendmarker = (char_u *)vim_strchr(wp->w_p_fmr, ',');
-  foldstartmarkerlen = (size_t)(foldendmarker++ - (char_u *)wp->w_p_fmr);
+  foldendmarker = vim_strchr(wp->w_p_fmr, ',');
+  foldstartmarkerlen = (size_t)(foldendmarker++ - wp->w_p_fmr);
   foldendmarkerlen = STRLEN(foldendmarker);
 }
 
@@ -3003,23 +3001,23 @@ static void foldlevelMarker(fline_T *flp)
   int start_lvl = flp->lvl;
 
   // cache a few values for speed
-  char_u *startmarker = (char_u *)flp->wp->w_p_fmr;
-  int cstart = *startmarker;
+  char *startmarker = flp->wp->w_p_fmr;
+  int cstart = (unsigned char)(*startmarker);
   startmarker++;
-  int cend = *foldendmarker;
+  int cend = (unsigned char)(*foldendmarker);
 
   // Default: no start found, next level is same as current level
   flp->start = 0;
   flp->lvl_next = flp->lvl;
 
-  char_u *s = ml_get_buf(flp->wp->w_buffer, flp->lnum + flp->off, false);
+  char *s = (char *)ml_get_buf(flp->wp->w_buffer, flp->lnum + flp->off, false);
   while (*s) {
     if (*s == cstart
         && STRNCMP(s + 1, startmarker, foldstartmarkerlen - 1) == 0) {
       // found startmarker: set flp->lvl
       s += foldstartmarkerlen;
       if (ascii_isdigit(*s)) {
-        int n = atoi((char *)s);
+        int n = atoi(s);
         if (n > 0) {
           flp->lvl = n;
           flp->lvl_next = n;
@@ -3039,7 +3037,7 @@ static void foldlevelMarker(fline_T *flp)
       // found endmarker: set flp->lvl_next
       s += foldendmarkerlen;
       if (ascii_isdigit(*s)) {
-        int n = atoi((char *)s);
+        int n = atoi(s);
         if (n > 0) {
           flp->lvl = n;
           flp->lvl_next = n - 1;
@@ -3240,7 +3238,7 @@ void f_foldtext(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   linenr_T foldstart = (linenr_T)get_vim_var_nr(VV_FOLDSTART);
   linenr_T foldend = (linenr_T)get_vim_var_nr(VV_FOLDEND);
-  char_u *dashes = (char_u *)get_vim_var_str(VV_FOLDDASHES);
+  char *dashes = get_vim_var_str(VV_FOLDDASHES);
   if (foldstart > 0 && foldend <= curbuf->b_ml.ml_line_count) {
     // Find first non-empty line in the fold.
     linenr_T lnum;
@@ -3268,20 +3266,20 @@ void f_foldtext(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
                  + STRLEN(dashes)  // for %s
                  + 20              // for %3ld
                  + STRLEN(s);      // concatenated
-    char_u *r = xmalloc(len);
-    snprintf((char *)r, len, txt, dashes, count);
+    char *r = xmalloc(len);
+    snprintf(r, len, txt, dashes, count);
     len = STRLEN(r);
     STRCAT(r, s);
     // remove 'foldmarker' and 'commentstring'
     foldtext_cleanup(r + len);
-    rettv->vval.v_string = (char *)r;
+    rettv->vval.v_string = r;
   }
 }
 
 /// "foldtextresult(lnum)" function
 void f_foldtextresult(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  char_u buf[FOLD_TEXT_LEN];
+  char buf[FOLD_TEXT_LEN];
   static bool entered = false;
 
   rettv->v_type = VAR_STRING;
@@ -3298,11 +3296,11 @@ void f_foldtextresult(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   foldinfo_T info = fold_info(curwin, lnum);
   if (info.fi_lines > 0) {
-    char_u *text = get_foldtext(curwin, lnum, lnum + info.fi_lines - 1, info, buf);
+    char *text = get_foldtext(curwin, lnum, lnum + info.fi_lines - 1, info, buf);
     if (text == buf) {
-      text = vim_strsave(text);
+      text = xstrdup(text);
     }
-    rettv->vval.v_string = (char *)text;
+    rettv->vval.v_string = text;
   }
 
   entered = false;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index f592b54f67..947594be4f 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1541,17 +1541,16 @@ ssize_t mb_utf_index_to_bytes(const char_u *s, size_t len, size_t index, bool us
   return -1;
 }
 
-/*
- * Version of strnicmp() that handles multi-byte characters.
- * Needed for Big5, Shift-JIS and UTF-8 encoding.  Other DBCS encodings can
- * probably use strnicmp(), because there are no ASCII characters in the
- * second byte.
- * Returns zero if s1 and s2 are equal (ignoring case), the difference between
- * two characters otherwise.
- */
-int mb_strnicmp(const char_u *s1, const char_u *s2, const size_t nn)
+/// Version of strnicmp() that handles multi-byte characters.
+/// Needed for Big5, Shift-JIS and UTF-8 encoding.  Other DBCS encodings can
+/// probably use strnicmp(), because there are no ASCII characters in the
+/// second byte.
+///
+/// @return  zero if s1 and s2 are equal (ignoring case), the difference between
+///          two characters otherwise.
+int mb_strnicmp(const char *s1, const char *s2, const size_t nn)
 {
-  return utf_strnicmp(s1, s2, nn, nn);
+  return utf_strnicmp((char_u *)s1, (char_u *)s2, nn, nn);
 }
 
 /// Compare strings case-insensitively
@@ -1568,7 +1567,7 @@ int mb_strnicmp(const char_u *s1, const char_u *s2, const size_t nn)
 /// @return 0 if strings are equal, <0 if s1 < s2, >0 if s1 > s2.
 int mb_stricmp(const char *s1, const char *s2)
 {
-  return mb_strnicmp((const char_u *)s1, (const char_u *)s2, MAXCOL);
+  return mb_strnicmp(s1, s2, MAXCOL);
 }
 
 /*
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 5bbcbc7144..8973d4dfdb 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -384,7 +384,7 @@ int path_fnamencmp(const char *const fname1, const char *const fname2, size_t le
   return p_fic ? CH_FOLD(c1) - CH_FOLD(c2) : c1 - c2;
 #else
   if (p_fic) {
-    return mb_strnicmp((const char_u *)fname1, (const char_u *)fname2, len);
+    return mb_strnicmp(fname1, fname2, len);
   }
   return strncmp(fname1, fname2, len);
 #endif
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index f471f1c8e0..563d85964c 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1282,7 +1282,7 @@ static int match_with_backref(linenr_T start_lnum, colnr_T start_col, linenr_T e
       len = (int)STRLEN(p + ccol);
     }
 
-    if (cstrncmp(p + ccol, rex.input, &len) != 0) {
+    if (cstrncmp((char *)p + ccol, (char *)rex.input, &len) != 0) {
       return RA_NOMATCH;  // doesn't match
     }
     if (bytelen != NULL) {
@@ -1395,10 +1395,10 @@ static void mb_decompose(int c, int *c1, int *c2, int *c3)
   }
 }
 
-// Compare two strings, ignore case if rex.reg_ic set.
-// Return 0 if strings match, non-zero otherwise.
-// Correct the length "*n" when composing characters are ignored.
-static int cstrncmp(char_u *s1, char_u *s2, int *n)
+/// Compare two strings, ignore case if rex.reg_ic set.
+/// Return 0 if strings match, non-zero otherwise.
+/// Correct the length "*n" when composing characters are ignored.
+static int cstrncmp(char *s1, char *s2, int *n)
 {
   int result;
 
@@ -1406,12 +1406,12 @@ static int cstrncmp(char_u *s1, char_u *s2, int *n)
     result = STRNCMP(s1, s2, *n);
   } else {
     assert(*n >= 0);
-    result = mb_strnicmp(s1, s2, (size_t)*n);
+    result = mb_strnicmp(s1, s2, (size_t)(*n));
   }
 
   // if it failed and it's utf8 and we want to combineignore:
   if (result != 0 && rex.reg_icombine) {
-    char_u *str1, *str2;
+    char *str1, *str2;
     int c1, c2, c11, c12;
     int junk;
 
@@ -2112,36 +2112,33 @@ exit:
   return (int)((dst - dest) + 1);
 }
 
-/*
- * Call reg_getline() with the line numbers from the submatch.  If a
- * substitute() was used the reg_maxline and other values have been
- * overwritten.
- */
-static char_u *reg_getline_submatch(linenr_T lnum)
+/// Call reg_getline() with the line numbers from the submatch.  If a
+/// substitute() was used the reg_maxline and other values have been
+/// overwritten.
+static char *reg_getline_submatch(linenr_T lnum)
 {
-  char_u *s;
+  char *s;
   linenr_T save_first = rex.reg_firstlnum;
   linenr_T save_max = rex.reg_maxline;
 
   rex.reg_firstlnum = rsm.sm_firstlnum;
   rex.reg_maxline = rsm.sm_maxline;
 
-  s = reg_getline(lnum);
+  s = (char *)reg_getline(lnum);
 
   rex.reg_firstlnum = save_first;
   rex.reg_maxline = save_max;
   return s;
 }
 
-/*
- * Used for the submatch() function: get the string from the n'th submatch in
- * allocated memory.
- * Returns NULL when not in a ":s" command and for a non-existing submatch.
- */
-char_u *reg_submatch(int no)
+/// Used for the submatch() function: get the string from the n'th submatch in
+/// allocated memory.
+///
+/// @return  NULL when not in a ":s" command and for a non-existing submatch.
+char *reg_submatch(int no)
 {
-  char_u *retval = NULL;
-  char_u *s;
+  char *retval = NULL;
+  char *s;
   int round;
   linenr_T lnum;
 
@@ -2211,11 +2208,11 @@ char_u *reg_submatch(int no)
       }
     }
   } else {
-    s = rsm.sm_match->startp[no];
+    s = (char *)rsm.sm_match->startp[no];
     if (s == NULL || rsm.sm_match->endp[no] == NULL) {
       retval = NULL;
     } else {
-      retval = vim_strnsave(s, (size_t)(rsm.sm_match->endp[no] - s));
+      retval = xstrnsave(s, (size_t)(rsm.sm_match->endp[no] - (char_u *)s));
     }
   }
 
@@ -2250,16 +2247,16 @@ list_T *reg_submatch_list(int no)
 
     list = tv_list_alloc(elnum - slnum + 1);
 
-    s = (const char *)reg_getline_submatch(slnum) + scol;
+    s = reg_getline_submatch(slnum) + scol;
     if (slnum == elnum) {
       tv_list_append_string(list, s, ecol - scol);
     } else {
       tv_list_append_string(list, s, -1);
       for (int i = 1; i < elnum - slnum; i++) {
-        s = (const char *)reg_getline_submatch(slnum + i);
+        s = reg_getline_submatch(slnum + i);
         tv_list_append_string(list, s, -1);
       }
-      s = (const char *)reg_getline_submatch(elnum);
+      s = reg_getline_submatch(elnum);
       tv_list_append_string(list, s, ecol);
     }
   } else {
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index b951df69d6..9b9b33b09f 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -4039,7 +4039,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
             } else {
               // Need to match first byte again for multi-byte.
               len = (int)STRLEN(opnd);
-              if (cstrncmp(opnd, rex.input, &len) != 0) {
+              if (cstrncmp((char *)opnd, (char *)rex.input, &len) != 0) {
                 status = RA_NOMATCH;
               }
             }
@@ -4270,7 +4270,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
             } else {
               // Compare current input with back-ref in the same line.
               len = (int)(rex.reg_endp[no] - rex.reg_startp[no]);
-              if (cstrncmp(rex.reg_startp[no], rex.input, &len) != 0) {
+              if (cstrncmp((char *)rex.reg_startp[no], (char *)rex.input, &len) != 0) {
                 status = RA_NOMATCH;
               }
             }
@@ -4283,8 +4283,8 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
                   && rex.reg_endpos[no].lnum == rex.lnum) {
                 // Compare back-ref within the current line.
                 len = rex.reg_endpos[no].col - rex.reg_startpos[no].col;
-                if (cstrncmp(rex.line + rex.reg_startpos[no].col,
-                             rex.input, &len) != 0) {
+                if (cstrncmp((char *)rex.line + rex.reg_startpos[no].col,
+                             (char *)rex.input, &len) != 0) {
                   status = RA_NOMATCH;
                 }
               } else {
@@ -4320,7 +4320,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
           if (re_extmatch_in != NULL
               && re_extmatch_in->matches[no] != NULL) {
             int len = (int)STRLEN(re_extmatch_in->matches[no]);
-            if (cstrncmp(re_extmatch_in->matches[no], rex.input, &len) != 0) {
+            if (cstrncmp((char *)re_extmatch_in->matches[no], (char *)rex.input, &len) != 0) {
               status = RA_NOMATCH;
             } else {
               rex.input += len;
@@ -5069,14 +5069,14 @@ static long bt_regexec_both(char_u *line, colnr_T col, proftime_T *tm, int *time
     // the loop to avoid overhead of conditions.
     if (!rex.reg_ic) {
       while ((s = (char_u *)vim_strchr((char *)s, c)) != NULL) {
-        if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0) {
+        if (cstrncmp((char *)s, (char *)prog->regmust, &prog->regmlen) == 0) {
           break;  // Found it.
         }
         MB_PTR_ADV(s);
       }
     } else {
       while ((s = cstrchr(s, c)) != NULL) {
-        if (cstrncmp(s, prog->regmust, &prog->regmlen) == 0) {
+        if (cstrncmp((char *)s, (char *)prog->regmust, &prog->regmlen) == 0) {
           break;  // Found it.
         }
         MB_PTR_ADV(s);
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index e1327ce155..d01404b5c2 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -5421,8 +5421,8 @@ retempty:
         && sub->list.multi[subidx].end_lnum == rex.lnum) {
       len = sub->list.multi[subidx].end_col
             - sub->list.multi[subidx].start_col;
-      if (cstrncmp(rex.line + sub->list.multi[subidx].start_col,
-                   rex.input, &len) == 0) {
+      if (cstrncmp((char *)rex.line + sub->list.multi[subidx].start_col,
+                   (char *)rex.input, &len) == 0) {
         *bytelen = len;
         return true;
       }
@@ -5441,7 +5441,7 @@ retempty:
       goto retempty;
     }
     len = (int)(sub->list.line[subidx].end - sub->list.line[subidx].start);
-    if (cstrncmp(sub->list.line[subidx].start, rex.input, &len) == 0) {
+    if (cstrncmp((char *)sub->list.line[subidx].start, (char *)rex.input, &len) == 0) {
       *bytelen = len;
       return true;
     }
@@ -5466,7 +5466,7 @@ static int match_zref(int subidx, int *bytelen)
   }
 
   len = (int)STRLEN(re_extmatch_in->matches[subidx]);
-  if (cstrncmp(re_extmatch_in->matches[subidx], rex.input, &len) == 0) {
+  if (cstrncmp((char *)re_extmatch_in->matches[subidx], (char *)rex.input, &len) == 0) {
     *bytelen = len;
     return true;
   }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index d7f8d4e1cd..226d949825 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1504,7 +1504,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
     } else if (*p != NUL) {  // Ignore empty lines.
       // Expanding lines or words.
       assert(ins_compl_len() >= 0);
-      if ((p_ic ? mb_strnicmp(p, pat, (size_t)ins_compl_len())
+      if ((p_ic ? mb_strnicmp((char *)p, (char *)pat, (size_t)ins_compl_len())
            : STRNCMP(p, pat, ins_compl_len())) == 0) {
         return OK;
       }
@@ -3792,7 +3792,7 @@ search_line:
           // compare the first "len" chars from "ptr"
           startp = (char_u *)skipwhite((char *)p);
           if (p_ic) {
-            matched = !mb_strnicmp(startp, ptr, len);
+            matched = !mb_strnicmp((char *)startp, (char *)ptr, len);
           } else {
             matched = !STRNCMP(startp, ptr, len);
           }
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index d2f1b39ca4..e20bce5b34 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -4001,7 +4001,7 @@ static bool shada_removable(const char *name)
     if (part[0] == 'r') {
       home_replace(NULL, part + 1, (char *)NameBuff, MAXPATHL, true);
       size_t n = STRLEN(NameBuff);
-      if (mb_strnicmp((char_u *)NameBuff, (char_u *)new_name, n) == 0) {
+      if (mb_strnicmp(NameBuff, new_name, n) == 0) {
         retval = true;
         break;
       }
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index ed7f53d3ba..7d931a853b 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -26,11 +26,11 @@
 typedef struct sign sign_T;
 
 struct sign {
-  sign_T *sn_next;       // next sign in list
+  sign_T *sn_next;    // next sign in list
   int sn_typenr;      // type number of sign
-  char_u *sn_name;       // name of sign
-  char_u *sn_icon;       // name of pixmap
-  char_u *sn_text;       // text used instead of pixmap
+  char *sn_name;      // name of sign
+  char *sn_icon;      // name of pixmap
+  char *sn_text;      // text used instead of pixmap
   int sn_line_hl;     // highlight ID for line
   int sn_text_hl;     // highlight ID for text
   int sn_cul_hl;      // highlight ID for text on current line when 'cursorline' is set
@@ -71,14 +71,13 @@ void init_signs(void)
 
 /// A new sign in group 'groupname' is added. If the group is not present,
 /// create it. Otherwise reference the group.
-///
-static signgroup_T *sign_group_ref(const char_u *groupname)
+static signgroup_T *sign_group_ref(const char *groupname)
 {
   hash_T hash;
   hashitem_T *hi;
   signgroup_T *group;
 
-  hash = hash_hash(groupname);
+  hash = hash_hash((char_u *)groupname);
   hi = hash_lookup(&sg_table, (char *)groupname, STRLEN(groupname), hash);
   if (HASHITEM_EMPTY(hi)) {
     // new group
@@ -99,11 +98,11 @@ static signgroup_T *sign_group_ref(const char_u *groupname)
 
 /// A sign in group 'groupname' is removed. If all the signs in this group are
 /// removed, then remove the group.
-static void sign_group_unref(char_u *groupname)
+static void sign_group_unref(char *groupname)
 {
   signgroup_T *group;
 
-  hashitem_T *hi = hash_find(&sg_table, (char *)groupname);
+  hashitem_T *hi = hash_find(&sg_table, groupname);
   if (!HASHITEM_EMPTY(hi)) {
     group = HI2SG(hi);
     group->sg_refcount--;
@@ -118,7 +117,7 @@ static void sign_group_unref(char_u *groupname)
 /// @return true if 'sign' is in 'group'.
 /// A sign can either be in the global group (sign->group == NULL)
 /// or in a named group. If 'group' is '*', then the sign is part of the group.
-static bool sign_in_group(sign_entry_T *sign, const char_u *group)
+static bool sign_in_group(sign_entry_T *sign, const char *group)
 {
   return ((group != NULL && STRCMP(group, "*") == 0)
           || (group == NULL && sign->se_group == NULL)
@@ -127,7 +126,7 @@ static bool sign_in_group(sign_entry_T *sign, const char_u *group)
 }
 
 /// Get the next free sign identifier in the specified group
-static int sign_group_get_next_signid(buf_T *buf, const char_u *groupname)
+static int sign_group_get_next_signid(buf_T *buf, const char *groupname)
 {
   int id = 1;
   signgroup_T *group = NULL;
@@ -154,7 +153,7 @@ static int sign_group_get_next_signid(buf_T *buf, const char_u *groupname)
     // Check whether this sign is already placed in the buffer
     found = true;
     FOR_ALL_SIGNS_IN_BUF(buf, sign) {
-      if (id == sign->se_id && sign_in_group(sign, groupname)) {
+      if (id == sign->se_id && sign_in_group(sign, (char *)groupname)) {
         found = false;    // sign identifier is in use
         break;
       }
@@ -177,7 +176,7 @@ static int sign_group_get_next_signid(buf_T *buf, const char_u *groupname)
 /// @param typenr  typenr of sign we are adding
 /// @param has_text_or_icon  sign has text or icon
 static void insert_sign(buf_T *buf, sign_entry_T *prev, sign_entry_T *next, int id,
-                        const char_u *group, int prio, linenr_T lnum, int typenr,
+                        const char *group, int prio, linenr_T lnum, int typenr,
                         bool has_text_or_icon)
 {
   sign_entry_T *newsign = xmalloc(sizeof(sign_entry_T));
@@ -224,7 +223,7 @@ static void insert_sign(buf_T *buf, sign_entry_T *prev, sign_entry_T *next, int
 /// @param lnum  line number which gets the mark
 /// @param typenr  typenr of sign we are adding
 /// @param has_text_or_icon  sign has text or icon
-static void insert_sign_by_lnum_prio(buf_T *buf, sign_entry_T *prev, int id, const char_u *group,
+static void insert_sign_by_lnum_prio(buf_T *buf, sign_entry_T *prev, int id, const char *group,
                                      int prio, linenr_T lnum, int typenr, bool has_text_or_icon)
 {
   sign_entry_T *sign;
@@ -259,7 +258,7 @@ static sign_T *find_sign_by_typenr(int typenr)
 }
 
 /// Get the name of a sign by its typenr.
-static char_u *sign_typenr2name(int typenr)
+static char *sign_typenr2name(int typenr)
 {
   sign_T *sp;
 
@@ -268,7 +267,7 @@ static char_u *sign_typenr2name(int typenr)
       return sp->sn_name;
     }
   }
-  return (char_u *)_("[Deleted]");
+  return _("[Deleted]");
 }
 
 /// Return information about a sign in a Dict
@@ -280,7 +279,7 @@ static dict_T *sign_get_info(sign_entry_T *sign)
                                       ? (char *)""
                                       : (char *)sign->se_group->sg_name));
   tv_dict_add_nr(d,  S_LEN("lnum"), sign->se_lnum);
-  tv_dict_add_str(d, S_LEN("name"), (char *)sign_typenr2name(sign->se_typenr));
+  tv_dict_add_str(d, S_LEN("name"), sign_typenr2name(sign->se_typenr));
   tv_dict_add_nr(d,  S_LEN("priority"), sign->se_priority);
 
   return d;
@@ -369,7 +368,7 @@ static void sign_sort_by_prio_on_line(buf_T *buf, sign_entry_T *sign)
 /// @param lnum  line number which gets the mark
 /// @param typenr  typenr of sign we are adding
 /// @param has_text_or_icon  sign has text or icon
-static void buf_addsign(buf_T *buf, int id, const char_u *groupname, int prio, linenr_T lnum,
+static void buf_addsign(buf_T *buf, int id, const char *groupname, int prio, linenr_T lnum,
                         int typenr, bool has_text_or_icon)
 {
   sign_entry_T *sign;    // a sign in the signlist
@@ -416,13 +415,13 @@ static void buf_addsign(buf_T *buf, int id, const char_u *groupname, int prio, l
 /// @param group  sign group
 /// @param typenr  typenr of sign we are adding
 /// @param prio  sign priority
-static linenr_T buf_change_sign_type(buf_T *buf, int markId, const char_u *group, int typenr,
+static linenr_T buf_change_sign_type(buf_T *buf, int markId, const char *group, int typenr,
                                      int prio)
 {
   sign_entry_T *sign;  // a sign in the signlist
 
   FOR_ALL_SIGNS_IN_BUF(buf, sign) {
-    if (sign->se_id == markId && sign_in_group(sign, group)) {
+    if (sign->se_id == markId && sign_in_group(sign, (char *)group)) {
       sign->se_typenr = typenr;
       sign->se_priority = prio;
       sign_sort_by_prio_on_line(buf, sign);
@@ -534,7 +533,7 @@ int buf_get_signattrs(buf_T *buf, linenr_T lnum, SignTextAttrs sattrs[], HlPriAt
 ///
 /// @return  the line number of the deleted sign. If multiple signs are deleted,
 /// then returns the line number of the last sign deleted.
-static linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char_u *group)
+static linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char *group)
 {
   sign_entry_T **lastp;  // pointer to pointer to current sign
   sign_entry_T *sign;    // a sign in a b_signlist
@@ -555,7 +554,7 @@ static linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char_u *group)
       lnum = sign->se_lnum;
       buf_signcols_del_check(buf, lnum, lnum);
       if (sign->se_group != NULL) {
-        sign_group_unref(sign->se_group->sg_name);
+        sign_group_unref((char *)sign->se_group->sg_name);
       }
       xfree(sign);
       redraw_buf_line_later(buf, lnum);
@@ -590,7 +589,7 @@ static linenr_T buf_delsign(buf_T *buf, linenr_T atlnum, int id, char_u *group)
 /// @param buf  buffer to store sign in
 /// @param id  sign ID
 /// @param group  sign group
-static int buf_findsign(buf_T *buf, int id, char_u *group)
+static int buf_findsign(buf_T *buf, int id, char *group)
 {
   sign_entry_T *sign;  // a sign in the signlist
 
@@ -609,7 +608,7 @@ static int buf_findsign(buf_T *buf, int id, char_u *group)
 /// @param buf  buffer whose sign we are searching for
 /// @param lnum  line number of sign
 /// @param groupname  sign group name
-static sign_entry_T *buf_getsign_at_line(buf_T *buf, linenr_T lnum, char_u *groupname)
+static sign_entry_T *buf_getsign_at_line(buf_T *buf, linenr_T lnum, char *groupname)
 {
   sign_entry_T *sign;    // a sign in the signlist
 
@@ -633,7 +632,7 @@ static sign_entry_T *buf_getsign_at_line(buf_T *buf, linenr_T lnum, char_u *grou
 /// @param buf  buffer whose sign we are searching for
 /// @param lnum  line number of sign
 /// @param groupname  sign group name
-static int buf_findsign_id(buf_T *buf, linenr_T lnum, char_u *groupname)
+static int buf_findsign_id(buf_T *buf, linenr_T lnum, char *groupname)
 {
   sign_entry_T *sign;   // a sign in the signlist
 
@@ -661,13 +660,13 @@ void buf_delete_signs(buf_T *buf, char *group)
   lastp = &buf->b_signlist;
   for (sign = buf->b_signlist; sign != NULL; sign = next) {
     next = sign->se_next;
-    if (sign_in_group(sign, (char_u *)group)) {
+    if (sign_in_group(sign, group)) {
       *lastp = next;
       if (next != NULL) {
         next->se_prev = sign->se_prev;
       }
       if (sign->se_group != NULL) {
-        sign_group_unref(sign->se_group->sg_name);
+        sign_group_unref((char *)sign->se_group->sg_name);
       }
       xfree(sign);
     } else {
@@ -678,7 +677,7 @@ void buf_delete_signs(buf_T *buf, char *group)
 }
 
 /// List placed signs for "rbuf".  If "rbuf" is NULL do it for all buffers.
-static void sign_list_placed(buf_T *rbuf, char_u *sign_group)
+static void sign_list_placed(buf_T *rbuf, char *sign_group)
 {
   buf_T *buf;
   sign_entry_T *sign;
@@ -778,12 +777,12 @@ void sign_mark_adjust(linenr_T line1, linenr_T line2, linenr_T amount, linenr_T
 ///
 /// @param begin_cmd  begin of sign subcmd
 /// @param end_cmd  just after sign subcmd
-static int sign_cmd_idx(char_u *begin_cmd, char_u *end_cmd)
+static int sign_cmd_idx(char *begin_cmd, char *end_cmd)
 {
   int idx;
-  char_u save = *end_cmd;
+  char save = *end_cmd;
 
-  *end_cmd = (char_u)NUL;
+  *end_cmd = NUL;
   for (idx = 0;; idx++) {
     if (cmds[idx] == NULL || STRCMP(begin_cmd, cmds[idx]) == 0) {
       break;
@@ -794,7 +793,7 @@ static int sign_cmd_idx(char_u *begin_cmd, char_u *end_cmd)
 }
 
 /// Find a sign by name. Also returns pointer to the previous sign.
-static sign_T *sign_find(const char_u *name, sign_T **sp_prev)
+static sign_T *sign_find(const char *name, sign_T **sp_prev)
 {
   sign_T *sp;
 
@@ -814,7 +813,7 @@ static sign_T *sign_find(const char_u *name, sign_T **sp_prev)
 }
 
 /// Allocate a new sign
-static sign_T *alloc_new_sign(char_u *name)
+static sign_T *alloc_new_sign(char *name)
 {
   sign_T *sp;
   sign_T *lp;
@@ -848,24 +847,24 @@ static sign_T *alloc_new_sign(char_u *name)
     next_sign_typenr = 1;  // wrap around
   }
 
-  sp->sn_name = vim_strsave(name);
+  sp->sn_name = xstrdup(name);
 
   return sp;
 }
 
 /// Initialize the icon information for a new sign
-static void sign_define_init_icon(sign_T *sp, char_u *icon)
+static void sign_define_init_icon(sign_T *sp, char *icon)
 {
   xfree(sp->sn_icon);
-  sp->sn_icon = vim_strsave(icon);
-  backslash_halve((char *)sp->sn_icon);
+  sp->sn_icon = xstrdup(icon);
+  backslash_halve(sp->sn_icon);
 }
 
 /// Initialize the text for a new sign
-static int sign_define_init_text(sign_T *sp, char_u *text)
+static int sign_define_init_text(sign_T *sp, char *text)
 {
-  char_u *s;
-  char_u *endp;
+  char *s;
+  char *endp;
   int cells;
   size_t len;
 
@@ -880,11 +879,11 @@ static int sign_define_init_text(sign_T *sp, char_u *text)
   }
   // Count cells and check for non-printable chars
   cells = 0;
-  for (s = text; s < endp; s += utfc_ptr2len((char *)s)) {
-    if (!vim_isprintc(utf_ptr2char((char *)s))) {
+  for (s = text; s < endp; s += utfc_ptr2len(s)) {
+    if (!vim_isprintc(utf_ptr2char(s))) {
       break;
     }
-    cells += utf_ptr2cells((char *)s);
+    cells += utf_ptr2cells(s);
   }
   // Currently must be empty, one or two display cells
   if (s != endp || cells > 2) {
@@ -900,7 +899,7 @@ static int sign_define_init_text(sign_T *sp, char_u *text)
   // Allocate one byte more if we need to pad up
   // with a space.
   len = (size_t)(endp - text + ((cells == 1) ? 1 : 0));
-  sp->sn_text = vim_strnsave(text, len);
+  sp->sn_text = xstrnsave(text, len);
 
   if (cells == 1) {
     STRCPY(sp->sn_text + len - 1, " ");
@@ -910,8 +909,8 @@ static int sign_define_init_text(sign_T *sp, char_u *text)
 }
 
 /// Define a new sign or update an existing sign
-static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_u *text,
-                               char_u *texthl, char_u *culhl, char *numhl)
+static int sign_define_by_name(char *name, char *icon, char *linehl, char *text, char *texthl,
+                               char *culhl, char *numhl)
 {
   sign_T *sp_prev;
   sign_T *sp;
@@ -952,7 +951,7 @@ static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_
     if (*linehl == NUL) {
       sp->sn_line_hl = 0;
     } else {
-      sp->sn_line_hl = syn_check_group((char *)linehl, STRLEN(linehl));
+      sp->sn_line_hl = syn_check_group(linehl, STRLEN(linehl));
     }
   }
 
@@ -960,7 +959,7 @@ static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_
     if (*texthl == NUL) {
       sp->sn_text_hl = 0;
     } else {
-      sp->sn_text_hl = syn_check_group((char *)texthl, STRLEN(texthl));
+      sp->sn_text_hl = syn_check_group(texthl, STRLEN(texthl));
     }
   }
 
@@ -968,7 +967,7 @@ static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_
     if (*culhl == NUL) {
       sp->sn_cul_hl = 0;
     } else {
-      sp->sn_cul_hl = syn_check_group((char *)culhl, STRLEN(culhl));
+      sp->sn_cul_hl = syn_check_group(culhl, STRLEN(culhl));
     }
   }
 
@@ -984,7 +983,7 @@ static int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_
 }
 
 /// Free the sign specified by 'name'.
-static int sign_undefine_by_name(const char_u *name)
+static int sign_undefine_by_name(const char *name)
 {
   sign_T *sp_prev;
   sign_T *sp;
@@ -1000,7 +999,7 @@ static int sign_undefine_by_name(const char_u *name)
 }
 
 /// List the signs matching 'name'
-static void sign_list_by_name(char_u *name)
+static void sign_list_by_name(char *name)
 {
   sign_T *sp;
 
@@ -1024,7 +1023,7 @@ static void may_force_numberwidth_recompute(buf_T *buf, int unplace)
 }
 
 /// Place a sign at the specified file location or update a sign.
-static int sign_place(int *sign_id, const char_u *sign_group, const char_u *sign_name, buf_T *buf,
+static int sign_place(int *sign_id, const char *sign_group, const char *sign_name, buf_T *buf,
                       linenr_T lnum, int prio)
 {
   sign_T *sp;
@@ -1044,7 +1043,7 @@ static int sign_place(int *sign_id, const char_u *sign_group, const char_u *sign
     return FAIL;
   }
   if (*sign_id == 0) {
-    *sign_id = sign_group_get_next_signid(buf, sign_group);
+    *sign_id = sign_group_get_next_signid(buf, (char *)sign_group);
   }
 
   if (lnum > 0) {
@@ -1053,14 +1052,14 @@ static int sign_place(int *sign_id, const char_u *sign_group, const char_u *sign
     bool has_text_or_icon = sp->sn_text != NULL || sp->sn_icon != NULL;
     buf_addsign(buf,
                 *sign_id,
-                sign_group,
+                (char *)sign_group,
                 prio,
                 lnum,
                 sp->sn_typenr,
                 has_text_or_icon);
   } else {
     // ":sign place {id} file={fname}": change sign type and/or priority
-    lnum = buf_change_sign_type(buf, *sign_id, sign_group, sp->sn_typenr, prio);
+    lnum = buf_change_sign_type(buf, *sign_id, (char *)sign_group, sp->sn_typenr, prio);
   }
   if (lnum > 0) {
     redraw_buf_line_later(buf, lnum);
@@ -1077,7 +1076,7 @@ static int sign_place(int *sign_id, const char_u *sign_group, const char_u *sign
 }
 
 /// Unplace the specified sign
-static int sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T atlnum)
+static int sign_unplace(int sign_id, char *sign_group, buf_T *buf, linenr_T atlnum)
 {
   if (buf->b_signlist == NULL) {  // No signs in the buffer
     return OK;
@@ -1085,7 +1084,7 @@ static int sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T at
   if (sign_id == 0) {
     // Delete all the signs in the specified buffer
     redraw_buf_later(buf, UPD_NOT_VALID);
-    buf_delete_signs(buf, (char *)sign_group);
+    buf_delete_signs(buf, sign_group);
   } else {
     linenr_T lnum;
 
@@ -1108,7 +1107,7 @@ static int sign_unplace(int sign_id, char_u *sign_group, buf_T *buf, linenr_T at
 }
 
 /// Unplace the sign at the current cursor line.
-static void sign_unplace_at_cursor(char_u *groupname)
+static void sign_unplace_at_cursor(char *groupname)
 {
   int id = -1;
 
@@ -1121,7 +1120,7 @@ static void sign_unplace_at_cursor(char_u *groupname)
 }
 
 /// Jump to a sign.
-static linenr_T sign_jump(int sign_id, char_u *sign_group, buf_T *buf)
+static linenr_T sign_jump(int sign_id, char *sign_group, buf_T *buf)
 {
   linenr_T lnum;
 
@@ -1154,49 +1153,49 @@ static linenr_T sign_jump(int sign_id, char_u *sign_group, buf_T *buf)
 }
 
 /// ":sign define {name} ..." command
-static void sign_define_cmd(char_u *sign_name, char_u *cmdline)
-{
-  char_u *arg;
-  char_u *p = cmdline;
-  char_u *icon = NULL;
-  char_u *text = NULL;
-  char_u *linehl = NULL;
-  char_u *texthl = NULL;
-  char_u *culhl = NULL;
-  char_u *numhl = NULL;
+static void sign_define_cmd(char *sign_name, char *cmdline)
+{
+  char *arg;
+  char *p = cmdline;
+  char *icon = NULL;
+  char *text = NULL;
+  char *linehl = NULL;
+  char *texthl = NULL;
+  char *culhl = NULL;
+  char *numhl = NULL;
   int failed = false;
 
   // set values for a defined sign.
   for (;;) {
-    arg = (char_u *)skipwhite((char *)p);
+    arg = skipwhite(p);
     if (*arg == NUL) {
       break;
     }
-    p = (char_u *)skiptowhite_esc((char *)arg);
+    p = skiptowhite_esc(arg);
     if (STRNCMP(arg, "icon=", 5) == 0) {
       arg += 5;
       XFREE_CLEAR(icon);
-      icon = vim_strnsave(arg, (size_t)(p - arg));
+      icon = xstrnsave(arg, (size_t)(p - arg));
     } else if (STRNCMP(arg, "text=", 5) == 0) {
       arg += 5;
       XFREE_CLEAR(text);
-      text = vim_strnsave(arg, (size_t)(p - arg));
+      text = xstrnsave(arg, (size_t)(p - arg));
     } else if (STRNCMP(arg, "linehl=", 7) == 0) {
       arg += 7;
       XFREE_CLEAR(linehl);
-      linehl = vim_strnsave(arg, (size_t)(p - arg));
+      linehl = xstrnsave(arg, (size_t)(p - arg));
     } else if (STRNCMP(arg, "texthl=", 7) == 0) {
       arg += 7;
       XFREE_CLEAR(texthl);
-      texthl = vim_strnsave(arg, (size_t)(p - arg));
+      texthl = xstrnsave(arg, (size_t)(p - arg));
     } else if (STRNCMP(arg, "culhl=", 6) == 0) {
       arg += 6;
       XFREE_CLEAR(culhl);
-      culhl = vim_strnsave(arg, (size_t)(p - arg));
+      culhl = xstrnsave(arg, (size_t)(p - arg));
     } else if (STRNCMP(arg, "numhl=", 6) == 0) {
       arg += 6;
       XFREE_CLEAR(numhl);
-      numhl = vim_strnsave(arg, (size_t)(p - arg));
+      numhl = xstrnsave(arg, (size_t)(p - arg));
     } else {
       semsg(_(e_invarg2), arg);
       failed = true;
@@ -1205,7 +1204,8 @@ static void sign_define_cmd(char_u *sign_name, char_u *cmdline)
   }
 
   if (!failed) {
-    sign_define_by_name(sign_name, icon, linehl, text, texthl, culhl, (char *)numhl);
+    sign_define_by_name(sign_name, icon, linehl, text,
+                        texthl, culhl, numhl);
   }
 
   xfree(icon);
@@ -1217,7 +1217,7 @@ static void sign_define_cmd(char_u *sign_name, char_u *cmdline)
 }
 
 /// ":sign place" command
-static void sign_place_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int id, char_u *group,
+static void sign_place_cmd(buf_T *buf, linenr_T lnum, char *sign_name, int id, char *group,
                            int prio)
 {
   if (id <= 0) {
@@ -1250,7 +1250,7 @@ static void sign_place_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int id,
 }
 
 /// ":sign unplace" command
-static void sign_unplace_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int id, char_u *group)
+static void sign_unplace_cmd(buf_T *buf, linenr_T lnum, char *sign_name, int id, char *group)
 {
   if (lnum >= 0 || sign_name != NULL || (group != NULL && *group == '\0')) {
     emsg(_(e_invarg));
@@ -1272,7 +1272,7 @@ static void sign_unplace_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int i
       // :sign unplace * group=*
       FOR_ALL_BUFFERS(cbuf) {
         if (cbuf->b_signlist != NULL) {
-          buf_delete_signs(cbuf, (char *)group);
+          buf_delete_signs(cbuf, group);
         }
       }
     }
@@ -1307,7 +1307,7 @@ static void sign_unplace_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int i
 ///   :sign jump {id} buffer={nr}
 ///   :sign jump {id} group={group} file={fname}
 ///   :sign jump {id} group={group} buffer={nr}
-static void sign_jump_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int id, char_u *group)
+static void sign_jump_cmd(buf_T *buf, linenr_T lnum, char *sign_name, int id, char *group)
 {
   if (sign_name == NULL && group == NULL && id == -1) {
     emsg(_(e_argreq));
@@ -1329,31 +1329,31 @@ static void sign_jump_cmd(buf_T *buf, linenr_T lnum, char_u *sign_name, int id,
 /// ":sign jump" commands.
 /// The supported arguments are: line={lnum} name={name} group={group}
 /// priority={prio} and file={fname} or buffer={nr}.
-static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *signid,
-                               char_u **group, int *prio, buf_T **buf, linenr_T *lnum)
+static int parse_sign_cmd_args(int cmd, char *arg, char **sign_name, int *signid, char **group,
+                               int *prio, buf_T **buf, linenr_T *lnum)
 {
-  char_u *arg1;
-  char_u *name;
-  char_u *filename = NULL;
+  char *arg1;
+  char *name;
+  char *filename = NULL;
   int lnum_arg = false;
 
   // first arg could be placed sign id
   arg1 = arg;
   if (ascii_isdigit(*arg)) {
-    *signid = getdigits_int((char **)&arg, true, 0);
+    *signid = getdigits_int(&arg, true, 0);
     if (!ascii_iswhite(*arg) && *arg != NUL) {
       *signid = -1;
       arg = arg1;
     } else {
-      arg = (char_u *)skipwhite((char *)arg);
+      arg = skipwhite(arg);
     }
   }
 
   while (*arg != NUL) {
     if (STRNCMP(arg, "line=", 5) == 0) {
       arg += 5;
-      *lnum = atoi((char *)arg);
-      arg = (char_u *)skiptowhite((char *)arg);
+      *lnum = atoi(arg);
+      arg = skiptowhite(arg);
       lnum_arg = true;
     } else if (STRNCMP(arg, "*", 1) == 0 && cmd == SIGNCMD_UNPLACE) {
       if (*signid != -1) {
@@ -1361,11 +1361,11 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
         return FAIL;
       }
       *signid = -2;
-      arg = (char_u *)skiptowhite((char *)arg + 1);
+      arg = skiptowhite(arg + 1);
     } else if (STRNCMP(arg, "name=", 5) == 0) {
       arg += 5;
       name = arg;
-      arg = (char_u *)skiptowhite((char *)arg);
+      arg = skiptowhite(arg);
       if (*arg != NUL) {
         *arg++ = NUL;
       }
@@ -1376,24 +1376,24 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
     } else if (STRNCMP(arg, "group=", 6) == 0) {
       arg += 6;
       *group = arg;
-      arg = (char_u *)skiptowhite((char *)arg);
+      arg = skiptowhite(arg);
       if (*arg != NUL) {
         *arg++ = NUL;
       }
     } else if (STRNCMP(arg, "priority=", 9) == 0) {
       arg += 9;
-      *prio = atoi((char *)arg);
-      arg = (char_u *)skiptowhite((char *)arg);
+      *prio = atoi(arg);
+      arg = skiptowhite(arg);
     } else if (STRNCMP(arg, "file=", 5) == 0) {
       arg += 5;
       filename = arg;
-      *buf = buflist_findname_exp((char *)arg);
+      *buf = buflist_findname_exp(arg);
       break;
     } else if (STRNCMP(arg, "buffer=", 7) == 0) {
       arg += 7;
       filename = arg;
-      *buf = buflist_findnr(getdigits_int((char **)&arg, true, 0));
-      if (*skipwhite((char *)arg) != NUL) {
+      *buf = buflist_findnr(getdigits_int(&arg, true, 0));
+      if (*skipwhite(arg) != NUL) {
         semsg(_(e_trailing_arg), arg);
       }
       break;
@@ -1401,7 +1401,7 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
       emsg(_(e_invarg));
       return FAIL;
     }
-    arg = (char_u *)skipwhite((char *)arg);
+    arg = skipwhite(arg);
   }
 
   if (filename != NULL && *buf == NULL) {
@@ -1421,19 +1421,19 @@ static int parse_sign_cmd_args(int cmd, char_u *arg, char_u **sign_name, int *si
 /// ":sign" command
 void ex_sign(exarg_T *eap)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *p;
+  char *arg = eap->arg;
+  char *p;
   int idx;
   sign_T *sp;
 
   // Parse the subcommand.
-  p = (char_u *)skiptowhite((char *)arg);
+  p = skiptowhite(arg);
   idx = sign_cmd_idx(arg, p);
   if (idx == SIGNCMD_LAST) {
     semsg(_("E160: Unknown sign command: %s"), arg);
     return;
   }
-  arg = (char_u *)skipwhite((char *)p);
+  arg = skipwhite(p);
 
   if (idx <= SIGNCMD_LIST) {
     // Define, undefine or list signs.
@@ -1445,18 +1445,18 @@ void ex_sign(exarg_T *eap)
     } else if (*arg == NUL) {
       emsg(_("E156: Missing sign name"));
     } else {
-      char_u *name;
+      char *name;
 
       // Isolate the sign name.  If it's a number skip leading zeroes,
       // so that "099" and "99" are the same sign.  But keep "0".
-      p = (char_u *)skiptowhite((char *)arg);
+      p = skiptowhite(arg);
       if (*p != NUL) {
         *p++ = NUL;
       }
       while (arg[0] == '0' && arg[1] != NUL) {
         arg++;
       }
-      name = vim_strsave(arg);
+      name = xstrdup(arg);
 
       if (idx == SIGNCMD_DEFINE) {
         sign_define_cmd(name, p);
@@ -1474,8 +1474,8 @@ void ex_sign(exarg_T *eap)
   } else {
     int id = -1;
     linenr_T lnum = -1;
-    char_u *sign_name = NULL;
-    char_u *group = NULL;
+    char *sign_name = NULL;
+    char *group = NULL;
     int prio = SIGN_DEF_PRIO;
     buf_T *buf = NULL;
 
@@ -1500,12 +1500,12 @@ static void sign_getinfo(sign_T *sp, dict_T *retdict)
 {
   const char *p;
 
-  tv_dict_add_str(retdict, S_LEN("name"), (char *)sp->sn_name);
+  tv_dict_add_str(retdict, S_LEN("name"), sp->sn_name);
   if (sp->sn_icon != NULL) {
-    tv_dict_add_str(retdict, S_LEN("icon"), (char *)sp->sn_icon);
+    tv_dict_add_str(retdict, S_LEN("icon"), sp->sn_icon);
   }
   if (sp->sn_text != NULL) {
-    tv_dict_add_str(retdict, S_LEN("text"), (char *)sp->sn_text);
+    tv_dict_add_str(retdict, S_LEN("text"), sp->sn_text);
   }
   if (sp->sn_line_hl > 0) {
     p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, false);
@@ -1539,13 +1539,13 @@ static void sign_getinfo(sign_T *sp, dict_T *retdict)
 
 /// If 'name' is NULL, return a list of all the defined signs.
 /// Otherwise, return information about the specified sign.
-static void sign_getlist(const char_u *name, list_T *retlist)
+static void sign_getlist(const char *name, list_T *retlist)
 {
   sign_T *sp = first_sign;
   dict_T *dict;
 
   if (name != NULL) {
-    sp = sign_find(name, NULL);
+    sp = sign_find((char *)name, NULL);
     if (sp == NULL) {
       return;
     }
@@ -1577,8 +1577,8 @@ list_T *get_buffer_signs(buf_T *buf)
   return l;
 }
 
-/// Return information about all the signs placed in a buffer
-static void sign_get_placed_in_buf(buf_T *buf, linenr_T lnum, int sign_id, const char_u *sign_group,
+/// @return  information about all the signs placed in a buffer
+static void sign_get_placed_in_buf(buf_T *buf, linenr_T lnum, int sign_id, const char *sign_group,
                                    list_T *retlist)
 {
   dict_T *d;
@@ -1594,7 +1594,7 @@ static void sign_get_placed_in_buf(buf_T *buf, linenr_T lnum, int sign_id, const
   tv_dict_add_list(d, S_LEN("signs"), l);
 
   FOR_ALL_SIGNS_IN_BUF(buf, sign) {
-    if (!sign_in_group(sign, sign_group)) {
+    if (!sign_in_group(sign, (char *)sign_group)) {
       continue;
     }
     if ((lnum == 0 && sign_id == 0)
@@ -1609,7 +1609,7 @@ static void sign_get_placed_in_buf(buf_T *buf, linenr_T lnum, int sign_id, const
 /// Get a list of signs placed in buffer 'buf'. If 'num' is non-zero, return the
 /// sign placed at the line number. If 'lnum' is zero, return all the signs
 /// placed in 'buf'. If 'buf' is NULL, return signs placed in all the buffers.
-static void sign_get_placed(buf_T *buf, linenr_T lnum, int sign_id, const char_u *sign_group,
+static void sign_get_placed(buf_T *buf, linenr_T lnum, int sign_id, const char *sign_group,
                             list_T *retlist)
 {
   if (buf != NULL) {
@@ -1629,12 +1629,12 @@ static void sign_list_defined(sign_T *sp)
   smsg("sign %s", sp->sn_name);
   if (sp->sn_icon != NULL) {
     msg_puts(" icon=");
-    msg_outtrans((char *)sp->sn_icon);
+    msg_outtrans(sp->sn_icon);
     msg_puts(_(" (not supported)"));
   }
   if (sp->sn_text != NULL) {
     msg_puts(" text=");
-    msg_outtrans((char *)sp->sn_text);
+    msg_outtrans(sp->sn_text);
   }
   if (sp->sn_line_hl > 0) {
     msg_puts(" linehl=");
@@ -1710,8 +1710,8 @@ static enum {
   EXP_SIGN_GROUPS,  // expand with name of placed sign groups
 } expand_what;
 
-// Return the n'th sign name (used for command line completion)
-static char_u *get_nth_sign_name(int idx)
+/// @return  the n'th sign name (used for command line completion)
+static char *get_nth_sign_name(int idx)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   // Complete with name of signs already defined
@@ -1724,8 +1724,8 @@ static char_u *get_nth_sign_name(int idx)
   return NULL;
 }
 
-// Return the n'th sign group name (used for command line completion)
-static char_u *get_nth_sign_group_name(int idx)
+/// @return  the n'th sign group name (used for command line completion)
+static char *get_nth_sign_group_name(int idx)
 {
   // Complete with name of sign groups already defined
   int current_idx = 0;
@@ -1735,7 +1735,7 @@ static char_u *get_nth_sign_group_name(int idx)
       todo--;
       if (current_idx++ == idx) {
         signgroup_T *const group = HI2SG(hi);
-        return group->sg_name;
+        return (char *)group->sg_name;
       }
     }
   }
@@ -1768,28 +1768,28 @@ char *get_sign_name(expand_T *xp, int idx)
     return unplace_arg[idx];
   }
   case EXP_SIGN_NAMES:
-    return (char *)get_nth_sign_name(idx);
+    return get_nth_sign_name(idx);
   case EXP_SIGN_GROUPS:
-    return (char *)get_nth_sign_group_name(idx);
+    return get_nth_sign_group_name(idx);
   default:
     return NULL;
   }
 }
 
 /// Handle command line completion for :sign command.
-void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
+void set_context_in_sign_cmd(expand_T *xp, char *arg)
 {
-  char_u *end_subcmd;
-  char_u *last;
+  char *end_subcmd;
+  char *last;
   int cmd_idx;
-  char_u *begin_subcmd_args;
+  char *begin_subcmd_args;
 
   // Default: expand subcommands.
   xp->xp_context = EXPAND_SIGN;
   expand_what = EXP_SUBCMD;
-  xp->xp_pattern = (char *)arg;
+  xp->xp_pattern = arg;
 
-  end_subcmd = (char_u *)skiptowhite((char *)arg);
+  end_subcmd = skiptowhite(arg);
   if (*end_subcmd == NUL) {
     // expand subcmd name
     // :sign {subcmd}<CTRL-D>
@@ -1801,7 +1801,7 @@ void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
   // :sign {subcmd} {subcmd_args}
   //                |
   //                begin_subcmd_args
-  begin_subcmd_args = (char_u *)skipwhite((char *)end_subcmd);
+  begin_subcmd_args = skipwhite(end_subcmd);
 
   // Expand last argument of subcmd.
   //
@@ -1810,21 +1810,21 @@ void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
   //              p
 
   // Loop until reaching last argument.
-  char_u *p = begin_subcmd_args;
+  char *p = begin_subcmd_args;
   do {
-    p = (char_u *)skipwhite((char *)p);
+    p = skipwhite(p);
     last = p;
-    p = (char_u *)skiptowhite((char *)p);
+    p = skiptowhite(p);
   } while (*p != NUL);
 
-  p = (char_u *)vim_strchr((char *)last, '=');
+  p = vim_strchr(last, '=');
 
   // :sign define {name} {args}... {last}=
   //                               |     |
   //                            last     p
   if (p == NULL) {
     // Expand last argument name (before equal sign).
-    xp->xp_pattern = (char *)last;
+    xp->xp_pattern = last;
     switch (cmd_idx) {
     case SIGNCMD_DEFINE:
       expand_what = EXP_DEFINE;
@@ -1854,7 +1854,7 @@ void set_context_in_sign_cmd(expand_T *xp, char_u *arg)
     }
   } else {
     // Expand last argument value (after equal sign).
-    xp->xp_pattern = (char *)p + 1;
+    xp->xp_pattern = p + 1;
     switch (cmd_idx) {
     case SIGNCMD_DEFINE:
       if (STRNCMP(last, "texthl", 6) == 0
@@ -1928,8 +1928,8 @@ static int sign_define_from_dict(const char *name_arg, dict_T *dict)
     numhl  = tv_dict_get_string(dict, "numhl", true);
   }
 
-  if (sign_define_by_name((char_u *)name, (char_u *)icon, (char_u *)linehl,
-                          (char_u *)text, (char_u *)texthl, (char_u *)culhl, numhl)
+  if (sign_define_by_name(name, icon, linehl,
+                          text, texthl, culhl, numhl)
       == OK) {
     retval = 0;
   }
@@ -2005,7 +2005,7 @@ void f_sign_getdefined(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     name = tv_get_string(&argvars[0]);
   }
 
-  sign_getlist((const char_u *)name, rettv->vval.v_list);
+  sign_getlist(name, rettv->vval.v_list);
 }
 
 /// "sign_getplaced()" function
@@ -2062,8 +2062,7 @@ void f_sign_getplaced(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
   }
 
-  sign_get_placed(buf, lnum, sign_id, (const char_u *)group,
-                  rettv->vval.v_list);
+  sign_get_placed(buf, lnum, sign_id, group, rettv->vval.v_list);
 }
 
 /// "sign_jump()" function
@@ -2103,7 +2102,7 @@ void f_sign_jump(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     goto cleanup;
   }
 
-  rettv->vval.v_number = sign_jump(sign_id, (char_u *)sign_group, buf);
+  rettv->vval.v_number = sign_jump(sign_id, sign_group, buf);
 
 cleanup:
   xfree(sign_group);
@@ -2115,8 +2114,8 @@ static int sign_place_from_dict(typval_T *id_tv, typval_T *group_tv, typval_T *n
                                 typval_T *buf_tv, dict_T *dict)
 {
   int sign_id = 0;
-  char_u *group = NULL;
-  char_u *sign_name = NULL;
+  char *group = NULL;
+  char *sign_name = NULL;
   buf_T *buf = NULL;
   dictitem_T *di;
   linenr_T lnum = 0;
@@ -2154,14 +2153,14 @@ static int sign_place_from_dict(typval_T *id_tv, typval_T *group_tv, typval_T *n
   if (group_tv == NULL) {
     group = NULL;  // global group
   } else {
-    group = (char_u *)tv_get_string_chk(group_tv);
+    group = (char *)tv_get_string_chk(group_tv);
     if (group == NULL) {
       goto cleanup;
     }
     if (group[0] == '\0') {  // global sign group
       group = NULL;
     } else {
-      group = vim_strsave(group);
+      group = xstrdup(group);
     }
   }
 
@@ -2175,7 +2174,7 @@ static int sign_place_from_dict(typval_T *id_tv, typval_T *group_tv, typval_T *n
   if (name_tv == NULL) {
     goto cleanup;
   }
-  sign_name = (char_u *)tv_get_string_chk(name_tv);
+  sign_name = (char *)tv_get_string_chk(name_tv);
   if (sign_name == NULL) {
     goto cleanup;
   }
@@ -2269,13 +2268,13 @@ void f_sign_placelist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// Undefine multiple signs
 static void sign_undefine_multiple(list_T *l, list_T *retlist)
 {
-  char_u *name;
+  char *name;
   int retval;
 
   TV_LIST_ITER_CONST(l, li, {
     retval = -1;
-    name = (char_u *)tv_get_string_chk(TV_LIST_ITEM_TV(li));
-    if (name != NULL && (sign_undefine_by_name(name) == OK)) {
+    name = (char *)tv_get_string_chk(TV_LIST_ITEM_TV(li));
+    if (name != NULL && (sign_undefine_by_name((char *)name) == OK)) {
       retval = 0;
     }
     tv_list_append_number(retlist, retval);
@@ -2308,7 +2307,7 @@ void f_sign_undefine(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       return;
     }
 
-    if (sign_undefine_by_name((const char_u *)name) == OK) {
+    if (sign_undefine_by_name(name) == OK) {
       rettv->vval.v_number = 0;
     }
   }
@@ -2321,20 +2320,20 @@ static int sign_unplace_from_dict(typval_T *group_tv, dict_T *dict)
   dictitem_T *di;
   int sign_id = 0;
   buf_T *buf = NULL;
-  char_u *group = NULL;
+  char *group = NULL;
   int retval = -1;
 
   // sign group
   if (group_tv != NULL) {
-    group = (char_u *)tv_get_string(group_tv);
+    group = (char *)tv_get_string(group_tv);
   } else {
-    group = (char_u *)tv_dict_get_string(dict, "group", false);
+    group = tv_dict_get_string(dict, "group", false);
   }
   if (group != NULL) {
     if (group[0] == '\0') {  // global sign group
       group = NULL;
     } else {
-      group = vim_strsave(group);
+      group = xstrdup(group);
     }
   }
 
diff --git a/src/nvim/sign_defs.h b/src/nvim/sign_defs.h
index a4fb325ec8..1efde30008 100644
--- a/src/nvim/sign_defs.h
+++ b/src/nvim/sign_defs.h
@@ -34,7 +34,7 @@ struct sign_entry {
 
 /// Sign attributes. Used by the screen refresh routines.
 typedef struct {
-  char_u *text;
+  char *text;
   int hl_attr_id;
   int priority;
 } SignTextAttrs;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index d8bc4b22c2..7c05c9fe53 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -3289,7 +3289,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
             // ignore case...
             assert(depth >= 0);
             if (depth <= patlen
-                && mb_strnicmp(word, pat, (size_t)depth) != 0) {
+                && mb_strnicmp((char *)word, (char *)pat, (size_t)depth) != 0) {
               depth--;
             }
           }
@@ -3371,7 +3371,7 @@ static void dump_word(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
 
     ml_append(lnum, (char *)p, (colnr_T)0, false);
   } else if (((dumpflags & DUMPFLAG_ICASE)
-              ? mb_strnicmp(p, pat, STRLEN(pat)) == 0
+              ? mb_strnicmp((char *)p, (char *)pat, STRLEN(pat)) == 0
               : STRNCMP(p, pat, STRLEN(pat)) == 0)
              && ins_compl_add_infercase(p, (int)STRLEN(p),
                                         p_ic, NULL, *dir, false) == OK) {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 1319894226..d8de23182c 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -797,7 +797,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   validate_current_state();
 }
 
-static void save_chartab(char_u *chartab)
+static void save_chartab(char *chartab)
 {
   if (syn_block->b_syn_isk != empty_option) {
     memmove(chartab, syn_buf->b_chartab, (size_t)32);
@@ -805,7 +805,7 @@ static void save_chartab(char_u *chartab)
   }
 }
 
-static void restore_chartab(char_u *chartab)
+static void restore_chartab(char *chartab)
 {
   if (syn_win->w_s->b_syn_isk != empty_option) {
     memmove(syn_buf->b_chartab, chartab, (size_t)32);
@@ -819,7 +819,7 @@ static int syn_match_linecont(linenr_T lnum)
     regmmatch_T regmatch;
     // chartab array for syn iskeyword
     char_u buf_chartab[32];
-    save_chartab(buf_chartab);
+    save_chartab((char *)buf_chartab);
 
     regmatch.rmm_ic = syn_block->b_syn_linecont_ic;
     regmatch.regprog = syn_block->b_syn_linecont_prog;
@@ -827,7 +827,7 @@ static int syn_match_linecont(linenr_T lnum)
                         IF_SYN_TIME(&syn_block->b_syn_linecont_time));
     syn_block->b_syn_linecont_prog = regmatch.regprog;
 
-    restore_chartab(buf_chartab);
+    restore_chartab((char *)buf_chartab);
     return r;
   }
   return false;
@@ -1677,7 +1677,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   ga_init(&zero_width_next_ga, (int)sizeof(int), 10);
 
   // use syntax iskeyword option
-  save_chartab(buf_chartab);
+  save_chartab((char *)buf_chartab);
 
   /*
    * Repeat matching keywords and patterns, to find contained items at the
@@ -1713,7 +1713,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
             && (current_col == 0
                 || !vim_iswordp_buf(cur_pos - 1 - utf_head_off((char *)line, (char *)cur_pos - 1),
                                     syn_buf))) {
-          syn_id = check_keyword_id(line, (int)current_col, &endcol, &flags,
+          syn_id = check_keyword_id((char *)line, (int)current_col, &endcol, &flags,
                                     &next_list, cur_si, &cchar);
           if (syn_id != 0) {
             push_current_state(KEYWORD_IDX);
@@ -2004,7 +2004,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     }
   } while (found_match);
 
-  restore_chartab(buf_chartab);
+  restore_chartab((char *)buf_chartab);
 
   /*
    * Use attributes from the current state, if within its highlighting.
@@ -2596,7 +2596,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
   best_regmatch.startpos[0].col = 0;            // avoid compiler warning
 
   // use syntax iskeyword option
-  save_chartab(buf_chartab);
+  save_chartab((char *)buf_chartab);
 
   for (;;) {
     /*
@@ -2747,7 +2747,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     m_endpos->lnum = 0;
   }
 
-  restore_chartab(buf_chartab);
+  restore_chartab((char *)buf_chartab);
 
   // Remove external matches.
   unref_extmatch(re_extmatch_in);
@@ -2932,17 +2932,17 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
 /// @param next_listp  return: next_list of matching keyword
 /// @param cur_si      item at the top of the stack
 /// @param ccharp      conceal substitution char
-static int check_keyword_id(char_u *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,
                             stateitem_T *const cur_si, int *const ccharp)
 {
   // Find first character after the keyword.  First character was already
   // checked.
-  char_u *const kwp = line + startcol;
+  char *const kwp = line + startcol;
   int kwlen = 0;
   do {
-    kwlen += utfc_ptr2len((char *)kwp + kwlen);
-  } while (vim_iswordp_buf(kwp + kwlen, syn_buf));
+    kwlen += utfc_ptr2len(kwp + kwlen);
+  } while (vim_iswordp_buf((char_u *)kwp + kwlen, syn_buf));
 
   if (kwlen > MAXKEYWLEN) {
     return 0;
@@ -2957,13 +2957,13 @@ static int check_keyword_id(char_u *const line, const int startcol, int *const e
 
   // matching case
   if (syn_block->b_keywtab.ht_used != 0) {
-    kp = match_keyword(keyword, &syn_block->b_keywtab, cur_si);
+    kp = match_keyword((char *)keyword, &syn_block->b_keywtab, cur_si);
   }
 
   // ignoring case
   if (kp == NULL && syn_block->b_keywtab_ic.ht_used != 0) {
-    str_foldcase(kwp, kwlen, keyword, MAXKEYWLEN + 1);
-    kp = match_keyword(keyword, &syn_block->b_keywtab_ic, cur_si);
+    str_foldcase((char_u *)kwp, kwlen, keyword, MAXKEYWLEN + 1);
+    kp = match_keyword((char *)keyword, &syn_block->b_keywtab_ic, cur_si);
   }
 
   if (kp != NULL) {
@@ -2982,9 +2982,9 @@ static int check_keyword_id(char_u *const line, const int startcol, int *const e
 /// When current_next_list is non-zero accept only that group, otherwise:
 ///  Accept a not-contained keyword at toplevel.
 ///  Accept a keyword at other levels only if it is in the contains list.
-static keyentry_T *match_keyword(char_u *keyword, hashtab_T *ht, stateitem_T *cur_si)
+static keyentry_T *match_keyword(char *keyword, hashtab_T *ht, stateitem_T *cur_si)
 {
-  hashitem_T *hi = hash_find(ht, (char *)keyword);
+  hashitem_T *hi = hash_find(ht, keyword);
   if (!HASHITEM_EMPTY(hi)) {
     for (keyentry_T *kp = HI2KE(hi); kp != NULL; kp = kp->ke_next) {
       if (current_next_list != 0
@@ -3029,20 +3029,18 @@ static void syn_cmd_conceal(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * Handle ":syntax case" command.
- */
+/// Handle ":syntax case" command.
 static void syn_cmd_case(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *next;
+  char *arg = eap->arg;
+  char *next;
 
-  eap->nextcmd = find_nextcmd((char *)arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
 
-  next = (char_u *)skiptowhite((char *)arg);
+  next = skiptowhite(arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_ic) {
       msg("syntax case ignore");
@@ -3097,20 +3095,18 @@ static void syn_cmd_foldlevel(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * Handle ":syntax spell" command.
- */
+/// Handle ":syntax spell" command.
 static void syn_cmd_spell(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *next;
+  char *arg = eap->arg;
+  char *next;
 
-  eap->nextcmd = find_nextcmd((char *)arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
 
-  next = (char_u *)skiptowhite((char *)arg);
+  next = skiptowhite(arg);
   if (*arg == NUL) {
     if (curwin->w_s->b_syn_spell == SYNSPL_TOP) {
       msg("syntax spell toplevel");
@@ -3137,15 +3133,15 @@ static void syn_cmd_spell(exarg_T *eap, int syncing)
 /// Handle ":syntax iskeyword" command.
 static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u save_chartab[32];
-  char_u *save_isk;
+  char *arg = eap->arg;
+  char save_chartab[32];
+  char *save_isk;
 
   if (eap->skip) {
     return;
   }
 
-  arg = (char_u *)skipwhite((char *)arg);
+  arg = skipwhite(arg);
   if (*arg == NUL) {
     msg_puts("\n");
     if (curwin->w_s->b_syn_isk != empty_option) {
@@ -3160,15 +3156,15 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
       clear_string_option(&curwin->w_s->b_syn_isk);
     } else {
       memmove(save_chartab, curbuf->b_chartab, (size_t)32);
-      save_isk = (char_u *)curbuf->b_p_isk;
-      curbuf->b_p_isk = (char *)vim_strsave(arg);
+      save_isk = curbuf->b_p_isk;
+      curbuf->b_p_isk = xstrdup(arg);
 
       buf_init_chartab(curbuf, false);
       memmove(curwin->w_s->b_syn_chartab, curbuf->b_chartab, (size_t)32);
       memmove(curbuf->b_chartab, save_chartab, (size_t)32);
       clear_string_option(&curwin->w_s->b_syn_isk);
       curwin->w_s->b_syn_isk = curbuf->b_p_isk;
-      curbuf->b_p_isk = (char *)save_isk;
+      curbuf->b_p_isk = save_isk;
     }
   }
   redraw_later(curwin, UPD_NOT_VALID);
@@ -3303,16 +3299,14 @@ static void syn_clear_cluster(synblock_T *block, int i)
   xfree(SYN_CLSTR(block)[i].scl_list);
 }
 
-/*
- * Handle ":syntax clear" command.
- */
+/// Handle ":syntax clear" command.
 static void syn_cmd_clear(exarg_T *eap, int syncing)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *arg_end;
+  char *arg = eap->arg;
+  char *arg_end;
   int id;
 
-  eap->nextcmd = find_nextcmd((char *)arg);
+  eap->nextcmd = find_nextcmd(arg);
   if (eap->skip) {
     return;
   }
@@ -3345,7 +3339,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
      * Clear the group IDs that are in the argument.
      */
     while (!ends_excmd(*arg)) {
-      arg_end = (char_u *)skiptowhite((char *)arg);
+      arg_end = skiptowhite(arg);
       if (*arg == '@') {
         id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
         if (id == 0) {
@@ -3360,7 +3354,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
           XFREE_CLEAR(SYN_CLSTR(curwin->w_s)[scl_id].scl_list);
         }
       } else {
-        id = syn_name2id_len((char *)arg, (size_t)(arg_end - arg));
+        id = syn_name2id_len(arg, (size_t)(arg_end - arg));
         if (id == 0) {
           semsg(_(e_nogroup), arg);
           break;
@@ -3368,7 +3362,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
           syn_clear_one(id, syncing);
         }
       }
-      arg = (char_u *)skipwhite((char *)arg_end);
+      arg = skipwhite(arg_end);
     }
   }
   redraw_curbuf_later(UPD_SOME_VALID);
@@ -3412,7 +3406,7 @@ static void syn_cmd_on(exarg_T *eap, int syncing)
  */
 static void syn_cmd_reset(exarg_T *eap, int syncing)
 {
-  eap->nextcmd = (char *)check_nextcmd((char_u *)eap->arg);
+  eap->nextcmd = check_nextcmd(eap->arg);
   if (!eap->skip) {
     init_highlight(true, true);
   }
@@ -3437,7 +3431,7 @@ static void syn_cmd_off(exarg_T *eap, int syncing)
 static void syn_cmd_onoff(exarg_T *eap, char *name)
   FUNC_ATTR_NONNULL_ALL
 {
-  eap->nextcmd = (char *)check_nextcmd((char_u *)eap->arg);
+  eap->nextcmd = check_nextcmd(eap->arg);
   if (!eap->skip) {
     did_syntax_onoff = true;
     char buf[100];
@@ -3524,7 +3518,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
     while (!ends_excmd(*arg) && !got_int) {
       arg_end = (char_u *)skiptowhite((char *)arg);
       if (*arg == '@') {
-        int id = syn_scl_namen2id(arg + 1, (int)(arg_end - arg - 1));
+        int id = syn_scl_namen2id((char *)arg + 1, (int)(arg_end - arg - 1));
         if (id == 0) {
           semsg(_("E392: No such syntax cluster: %s"), arg);
         } else {
@@ -3541,7 +3535,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
       arg = (char_u *)skipwhite((char *)arg_end);
     }
   }
-  eap->nextcmd = (char *)check_nextcmd(arg);
+  eap->nextcmd = check_nextcmd((char *)arg);
 }
 
 static void syn_lines_msg(void)
@@ -3977,13 +3971,14 @@ static void clear_keywtab(hashtab_T *ht)
 /// @param flags flags for this keyword
 /// @param cont_in_list containedin for this keyword
 /// @param next_list nextgroup for this keyword
-static void add_keyword(char_u *const name, const int id, const int flags,
+static void add_keyword(char *const name, const int id, const int flags,
                         int16_t *const cont_in_list, int16_t *const next_list,
                         const int conceal_char)
 {
-  char_u name_folded[MAXKEYWLEN + 1];
-  const char_u *const name_ic = (curwin->w_s->b_syn_ic)
-      ? str_foldcase(name, (int)STRLEN(name), name_folded, sizeof(name_folded))
+  char name_folded[MAXKEYWLEN + 1];
+  const char *const name_ic = (curwin->w_s->b_syn_ic)
+      ? (char *)str_foldcase((char_u *)name, (int)STRLEN(name), (char_u *)name_folded,
+                             sizeof(name_folded))
       : name;
 
   keyentry_T *const kp = xmalloc(sizeof(keyentry_T) + STRLEN(name_ic));
@@ -4249,7 +4244,7 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
       emsg(_("E397: Filename required"));
       return;
     }
-    sgl_id = syn_check_cluster((char_u *)arg, (int)(group_name_end - arg));
+    sgl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
     if (sgl_id == 0) {
       return;
     }
@@ -4364,7 +4359,7 @@ static void syn_cmd_keyword(exarg_T *eap, int syncing)
             if (p != NULL) {
               *p = NUL;
             }
-            add_keyword((char_u *)kw, syn_id, syn_opt_arg.flags,
+            add_keyword(kw, syn_id, syn_opt_arg.flags,
                         syn_opt_arg.cont_in_list,
                         syn_opt_arg.next_list, conceal_char);
             if (p == NULL) {
@@ -4399,7 +4394,7 @@ error:
   }
 
   if (rest != NULL) {
-    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
+    eap->nextcmd = check_nextcmd(rest);
   } else {
     semsg(_(e_invarg2), arg);
   }
@@ -4439,7 +4434,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   // get the pattern.
   init_syn_patterns();
   CLEAR_FIELD(item);
-  rest = get_syn_pattern((char_u *)rest, &item);
+  rest = get_syn_pattern(rest, &item);
   if (vim_regcomp_had_eol() && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
     syn_opt_arg.flags |= HL_HAS_EOL;
   }
@@ -4451,7 +4446,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
     /*
      * Check for trailing command and illegal trailing arguments.
      */
-    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
+    eap->nextcmd = check_nextcmd(rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
     } else {
@@ -4631,7 +4626,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
         assert(item == ITEM_SKIP || item == ITEM_END);
         reg_do_extmatch = REX_USE;
       }
-      rest = get_syn_pattern((char_u *)rest, ppp->pp_synp);
+      rest = get_syn_pattern(rest, ppp->pp_synp);
       reg_do_extmatch = 0;
       if (item == ITEM_END && vim_regcomp_had_eol()
           && !(syn_opt_arg.flags & HL_EXCLUDENL)) {
@@ -4658,7 +4653,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
      * Check for trailing garbage or command.
      * If OK, add the item.
      */
-    eap->nextcmd = (char *)check_nextcmd((char_u *)rest);
+    eap->nextcmd = check_nextcmd(rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
     } else {
@@ -4863,12 +4858,12 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
   *clstr1 = clstr;
 }
 
-// Lookup a syntax cluster name and return its ID.
-// If it is not found, 0 is returned.
-static int syn_scl_name2id(char_u *name)
+/// Lookup a syntax cluster name and return its ID.
+/// If it is not found, 0 is returned.
+static int syn_scl_name2id(char *name)
 {
   // Avoid using stricmp() too much, it's slow on some systems
-  char_u *name_u = vim_strsave_up(name);
+  char *name_u = (char *)vim_strsave_up((char_u *)name);
   int i;
   for (i = curwin->w_s->b_syn_clusters.ga_len; --i >= 0;) {
     if (SYN_CLSTR(curwin->w_s)[i].scl_name_u != NULL
@@ -4880,25 +4875,24 @@ static int syn_scl_name2id(char_u *name)
   return i < 0 ? 0 : i + SYNID_CLUSTER;
 }
 
-/*
- * Like syn_scl_name2id(), but take a pointer + length argument.
- */
-static int syn_scl_namen2id(char_u *linep, int len)
+/// Like syn_scl_name2id(), but take a pointer + length argument.
+static int syn_scl_namen2id(char *linep, int len)
 {
-  char_u *name = vim_strnsave(linep, (size_t)len);
+  char *name = xstrnsave(linep, (size_t)len);
   int id = syn_scl_name2id(name);
   xfree(name);
 
   return id;
 }
 
-// Find syntax cluster name in the table and return its ID.
-// The argument is a pointer to the name and the length of the name.
-// If it doesn't exist yet, a new entry is created.
-// Return 0 for failure.
-static int syn_check_cluster(char_u *pp, int len)
+/// Find syntax cluster name in the table and return its ID.
+/// The argument is a pointer to the name and the length of the name.
+/// If it doesn't exist yet, a new entry is created.
+///
+/// @return  0 for failure.
+static int syn_check_cluster(char *pp, int len)
 {
-  char_u *name = vim_strnsave(pp, (size_t)len);
+  char *name = xstrnsave(pp, (size_t)len);
   int id = syn_scl_name2id(name);
   if (id == 0) {                        // doesn't exist yet
     id = syn_add_cluster(name);
@@ -4908,10 +4902,11 @@ static int syn_check_cluster(char_u *pp, int len)
   return id;
 }
 
-// Add new syntax cluster and return its ID.
-// "name" must be an allocated string, it will be consumed.
-// Return 0 for failure.
-static int syn_add_cluster(char_u *name)
+/// Add new syntax cluster and return its ID.
+/// "name" must be an allocated string, it will be consumed.
+///
+/// @return  0 for failure.
+static int syn_add_cluster(char *name)
 {
   /*
    * First call for this growarray: init growing array.
@@ -4931,8 +4926,8 @@ static int syn_add_cluster(char_u *name)
   syn_cluster_T *scp = GA_APPEND_VIA_PTR(syn_cluster_T,
                                          &curwin->w_s->b_syn_clusters);
   CLEAR_POINTER(scp);
-  scp->scl_name = name;
-  scp->scl_name_u = vim_strsave_up(name);
+  scp->scl_name = (char_u *)name;
+  scp->scl_name_u = vim_strsave_up((char_u *)name);
   scp->scl_list = NULL;
 
   if (STRICMP(name, "Spell") == 0) {
@@ -4966,7 +4961,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
   rest = get_group_name(arg, &group_name_end);
 
   if (rest != NULL) {
-    int scl_id = syn_check_cluster((char_u *)arg, (int)(group_name_end - arg));
+    int scl_id = syn_check_cluster(arg, (int)(group_name_end - arg));
     if (scl_id == 0) {
       return;
     }
@@ -5030,7 +5025,7 @@ static void init_syn_patterns(void)
 /// Stores the pattern and program in a synpat_T.
 ///
 /// @return  a pointer to the next argument, or NULL in case of an error.
-static char *get_syn_pattern(char_u *arg, synpat_T *ci)
+static char *get_syn_pattern(char *arg, synpat_T *ci)
 {
   char *end;
   int *p;
@@ -5042,13 +5037,13 @@ static char *get_syn_pattern(char_u *arg, synpat_T *ci)
     return NULL;
   }
 
-  end = skip_regexp((char *)arg + 1, *arg, true, NULL);
-  if (*end != (char)(*arg)) {                       // end delimiter not found
+  end = skip_regexp(arg + 1, *arg, true, NULL);
+  if (*end != *arg) {                       // end delimiter not found
     semsg(_("E401: Pattern delimiter not found: %s"), arg);
     return NULL;
   }
   // store the pattern and compiled regexp program
-  ci->sp_pattern = vim_strnsave(arg + 1, (size_t)(end - (char *)arg) - 1);
+  ci->sp_pattern = vim_strnsave((char_u *)arg + 1, (size_t)(end - arg) - 1);
 
   // Make 'cpoptions' empty, to avoid the 'l' flag
   cpo_save = p_cpo;
@@ -5122,15 +5117,13 @@ static char *get_syn_pattern(char_u *arg, synpat_T *ci)
   return skipwhite(end);
 }
 
-/*
- * Handle ":syntax sync .." command.
- */
+/// Handle ":syntax sync .." command.
 static void syn_cmd_sync(exarg_T *eap, int syncing)
 {
-  char_u *arg_start = (char_u *)eap->arg;
+  char *arg_start = eap->arg;
   char *arg_end;
-  char_u *key = NULL;
-  char_u *next_arg;
+  char *key = NULL;
+  char *next_arg;
   int illegal = false;
   int finished = false;
   char *cpo_save;
@@ -5141,21 +5134,21 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
   }
 
   while (!ends_excmd(*arg_start)) {
-    arg_end = skiptowhite((char *)arg_start);
-    next_arg = (char_u *)skipwhite(arg_end);
+    arg_end = skiptowhite(arg_start);
+    next_arg = skipwhite(arg_end);
     xfree(key);
-    key = vim_strnsave_up(arg_start, (size_t)(arg_end - (char *)arg_start));
+    key = (char *)vim_strnsave_up((char_u *)arg_start, (size_t)(arg_end - arg_start));
     if (STRCMP(key, "CCOMMENT") == 0) {
       if (!eap->skip) {
         curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
       }
       if (!ends_excmd(*next_arg)) {
-        arg_end = skiptowhite((char *)next_arg);
+        arg_end = skiptowhite(next_arg);
         if (!eap->skip) {
           curwin->w_s->b_syn_sync_id =
-            (int16_t)syn_check_group((char *)next_arg, (size_t)(arg_end - (char *)next_arg));
+            (int16_t)syn_check_group(next_arg, (size_t)(arg_end - next_arg));
         }
-        next_arg = (char_u *)skipwhite(arg_end);
+        next_arg = skipwhite(arg_end);
       } else if (!eap->skip) {
         curwin->w_s->b_syn_sync_id = (int16_t)syn_name2id("Comment");
       }
@@ -5164,11 +5157,11 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
                || STRNCMP(key, "MAXLINES", 8) == 0
                || STRNCMP(key, "LINEBREAKS", 10) == 0) {
       if (key[4] == 'S') {
-        arg_end = (char *)key + 6;
+        arg_end = key + 6;
       } else if (key[0] == 'L') {
-        arg_end = (char *)key + 11;
+        arg_end = key + 11;
       } else {
-        arg_end = (char *)key + 9;
+        arg_end = key + 9;
       }
       if (arg_end[-1] != '=' || !ascii_isdigit(*arg_end)) {
         illegal = true;
@@ -5199,8 +5192,8 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
         finished = true;
         break;
       }
-      arg_end = skip_regexp((char *)next_arg + 1, *next_arg, true, NULL);
-      if (*arg_end != (char)(*next_arg)) {          // end delimiter not found
+      arg_end = skip_regexp(next_arg + 1, *next_arg, true, NULL);
+      if (*arg_end != *next_arg) {          // end delimiter not found
         illegal = true;
         break;
       }
@@ -5208,7 +5201,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
       if (!eap->skip) {
         // store the pattern and compiled regexp program
         curwin->w_s->b_syn_linecont_pat =
-          (char *)vim_strnsave(next_arg + 1, (size_t)(arg_end - (char *)next_arg) - 1);
+          xstrnsave(next_arg + 1, (size_t)(arg_end - next_arg) - 1);
         curwin->w_s->b_syn_linecont_ic = curwin->w_s->b_syn_ic;
 
         // Make 'cpoptions' empty, to avoid the 'l' flag
@@ -5225,9 +5218,9 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
           break;
         }
       }
-      next_arg = (char_u *)skipwhite(arg_end + 1);
+      next_arg = skipwhite(arg_end + 1);
     } else {
-      eap->arg = (char *)next_arg;
+      eap->arg = next_arg;
       if (STRCMP(key, "MATCH") == 0) {
         syn_cmd_match(eap, true);
       } else if (STRCMP(key, "REGION") == 0) {
@@ -5246,7 +5239,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
   if (illegal) {
     semsg(_("E404: Illegal arguments: %s"), arg_start);
   } else if (!finished) {
-    eap->nextcmd = (char *)check_nextcmd(arg_start);
+    eap->nextcmd = check_nextcmd(arg_start);
     redraw_curbuf_later(UPD_SOME_VALID);
     syn_stack_free_all(curwin->w_s);            // Need to recompute all syntax.
   }
@@ -5327,7 +5320,7 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
         if (skip) {
           id = -1;
         } else {
-          id = syn_check_cluster((char_u *)name + 2, (int)(end - p - 1));
+          id = syn_check_cluster(name + 2, (int)(end - p - 1));
         }
       } else {
         /*
@@ -5565,21 +5558,19 @@ static struct subcommand subcommands[] =
   { NULL, NULL }
 };
 
-/*
- * ":syntax".
- * This searches the subcommands[] table for the subcommand name, and calls a
- * syntax_subcommand() function to do the rest.
- */
+/// ":syntax".
+/// This searches the subcommands[] table for the subcommand name, and calls a
+/// syntax_subcommand() function to do the rest.
 void ex_syntax(exarg_T *eap)
 {
-  char_u *arg = (char_u *)eap->arg;
-  char_u *subcmd_end;
+  char *arg = eap->arg;
+  char *subcmd_end;
 
   syn_cmdlinep = eap->cmdlinep;
 
   // isolate subcommand name
   for (subcmd_end = arg; ASCII_ISALPHA(*subcmd_end); subcmd_end++) {}
-  char_u *const subcmd_name = vim_strnsave(arg, (size_t)(subcmd_end - arg));
+  char *const subcmd_name = xstrnsave(arg, (size_t)(subcmd_end - arg));
   if (eap->skip) {  // skip error messages for all subcommands
     emsg_skip++;
   }
@@ -5588,8 +5579,8 @@ void ex_syntax(exarg_T *eap)
       semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
       break;
     }
-    if (STRCMP(subcmd_name, (char_u *)subcommands[i].name) == 0) {
-      eap->arg = skipwhite((char *)subcmd_end);
+    if (STRCMP(subcmd_name, subcommands[i].name) == 0) {
+      eap->arg = skipwhite(subcmd_end);
       (subcommands[i].func)(eap, false);
       break;
     }
@@ -5602,8 +5593,8 @@ void ex_syntax(exarg_T *eap)
 
 void ex_ownsyntax(exarg_T *eap)
 {
-  char_u *old_value;
-  char_u *new_value;
+  char *old_value;
+  char *new_value;
 
   if (curwin->w_s == &curwin->w_buffer->b_s) {
     curwin->w_s = xcalloc(1, sizeof(synblock_T));
@@ -5620,25 +5611,25 @@ void ex_ownsyntax(exarg_T *eap)
   }
 
   // Save value of b:current_syntax.
-  old_value = get_var_value("b:current_syntax");
+  old_value = (char *)get_var_value("b:current_syntax");
   if (old_value != NULL) {
-    old_value = vim_strsave(old_value);
+    old_value = xstrdup(old_value);
   }
 
   // Apply the "syntax" autocommand event, this finds and loads the syntax file.
   apply_autocmds(EVENT_SYNTAX, eap->arg, curbuf->b_fname, true, curbuf);
 
   // Move value of b:current_syntax to w:current_syntax.
-  new_value = get_var_value("b:current_syntax");
+  new_value = (char *)get_var_value("b:current_syntax");
   if (new_value != NULL) {
-    set_internal_string_var("w:current_syntax", (char *)new_value);
+    set_internal_string_var("w:current_syntax", new_value);
   }
 
   // Restore value of b:current_syntax.
   if (old_value == NULL) {
     do_unlet(S_LEN("b:current_syntax"), true);
   } else {
-    set_internal_string_var("b:current_syntax", (char *)old_value);
+    set_internal_string_var("b:current_syntax", old_value);
     xfree(old_value);
   }
 }
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 4fd99b058b..54c1dc7741 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -502,9 +502,9 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         // Find the position of each old match in the new list.  Need
         // to use parse_match() to find the tag line.
         for (j = 0; j < num_matches; j++) {
-          parse_match((char_u *)matches[j], &tagp);
+          parse_match(matches[j], &tagp);
           for (i = idx; i < new_num_matches; i++) {
-            parse_match((char_u *)new_matches[i], &tagp2);
+            parse_match(new_matches[i], &tagp2);
             if (STRCMP(tagp.tagname, tagp2.tagname) == 0) {
               char_u *p = (char_u *)new_matches[i];
               for (k = i; k > idx; k--) {
@@ -585,7 +585,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         tagstack[tagstackidx].cur_fnum = cur_fnum;
 
         // store user-provided data originating from tagfunc
-        if (use_tfu && parse_match((char_u *)matches[cur_match], &tagp2) == OK
+        if (use_tfu && parse_match(matches[cur_match], &tagp2) == OK
             && tagp2.user_data) {
           XFREE_CLEAR(tagstack[tagstackidx].user_data);
           tagstack[tagstackidx].user_data = (char *)vim_strnsave(tagp2.user_data,
@@ -705,7 +705,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
 
   // Assume that the first match indicates how long the tags can
   // be, and align the file names to that.
-  parse_match((char_u *)matches[0], &tagp);
+  parse_match(matches[0], &tagp);
   taglen = (int)(tagp.tagname_end - tagp.tagname + 2);
   if (taglen < 18) {
     taglen = 18;
@@ -723,7 +723,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
   msg_puts_attr(_("file\n"), HL_ATTR(HLF_T));
 
   for (i = 0; i < num_matches && !got_int; i++) {
-    parse_match((char_u *)matches[i], &tagp);
+    parse_match(matches[i], &tagp);
     if (!new_tag && (
                      (g_do_tagpreview != 0
                       && i == ptag_entry.cur_match)
@@ -897,7 +897,7 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
     long lnum;
     dict_T *dict;
 
-    parse_match((char_u *)matches[i], &tagp);
+    parse_match(matches[i], &tagp);
 
     // Save the tag name
     len = (int)(tagp.tagname_end - tagp.tagname);
@@ -1957,7 +1957,7 @@ parse_line:
             break;
           } else if (state == TS_SKIP_BACK) {
             assert(cmplen >= 0);
-            if (mb_strnicmp(tagp.tagname, orgpat.head, (size_t)cmplen) != 0) {
+            if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
               state = TS_STEP_FORWARD;
             } else {
               // Have to skip back more.  Restore the curr_offset
@@ -1967,7 +1967,7 @@ parse_line:
             continue;
           } else if (state == TS_STEP_FORWARD) {
             assert(cmplen >= 0);
-            if (mb_strnicmp(tagp.tagname, orgpat.head, (size_t)cmplen) != 0) {
+            if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
               if ((off_T)vim_ftell(fp) > search_info.match_offset) {
                 break;                  // past last match
               } else {
@@ -1978,7 +1978,7 @@ parse_line:
             // skip this match if it can't match
             assert(cmplen >= 0);
           }
-          if (mb_strnicmp(tagp.tagname, orgpat.head, (size_t)cmplen) != 0) {
+          if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
             continue;
           }
 
@@ -2014,7 +2014,7 @@ parse_line:
         } else {
           if (orgpat.regmatch.rm_ic) {
             assert(cmplen >= 0);
-            match = mb_strnicmp(tagp.tagname, orgpat.pat, (size_t)cmplen) == 0;
+            match = mb_strnicmp((char *)tagp.tagname, (char *)orgpat.pat, (size_t)cmplen) == 0;
             if (match) {
               match_no_ic = (STRNCMP(tagp.tagname, orgpat.pat,
                                      cmplen) == 0);
@@ -2552,18 +2552,17 @@ static size_t matching_line_len(const char_u *const lbuf)
 /// @param tagp  output: pointers into the line
 ///
 /// @return  OK or FAIL.
-static int parse_match(char_u *lbuf, tagptrs_T *tagp)
+static int parse_match(char *lbuf, tagptrs_T *tagp)
 {
   int retval;
-  char_u *p;
-  char_u *pc, *pt;
+  char *p;
+  char *pc, *pt;
 
-  tagp->tag_fname = lbuf + 1;
+  tagp->tag_fname = (char_u *)lbuf + 1;
   lbuf += STRLEN(tagp->tag_fname) + 2;
 
   // Find search pattern and the file name for non-etags.
-  retval = parse_tag_line(lbuf,
-                          tagp);
+  retval = parse_tag_line((char_u *)lbuf, tagp);
 
   tagp->tagkind = NULL;
   tagp->user_data = NULL;
@@ -2572,32 +2571,32 @@ static int parse_match(char_u *lbuf, tagptrs_T *tagp)
 
   if (retval == OK) {
     // Try to find a kind field: "kind:<kind>" or just "<kind>"
-    p = tagp->command;
-    if (find_extra(&p) == OK) {
-      tagp->command_end = p;
-      if (p > tagp->command && p[-1] == '|') {
-        tagp->command_end = p - 1;  // drop trailing bar
+    p = (char *)tagp->command;
+    if (find_extra((char_u **)&p) == OK) {
+      tagp->command_end = (char_u *)p;
+      if (p > (char *)tagp->command && p[-1] == '|') {
+        tagp->command_end = (char_u *)p - 1;  // drop trailing bar
       }
       p += 2;  // skip ";\""
       if (*p++ == TAB) {
         // Accept ASCII alphabetic kind characters and any multi-byte
         // character.
-        while (ASCII_ISALPHA(*p) || utfc_ptr2len((char *)p) > 1) {
+        while (ASCII_ISALPHA(*p) || utfc_ptr2len(p) > 1) {
           if (STRNCMP(p, "kind:", 5) == 0) {
-            tagp->tagkind = p + 5;
+            tagp->tagkind = (char_u *)p + 5;
           } else if (STRNCMP(p, "user_data:", 10) == 0) {
-            tagp->user_data = p + 10;
+            tagp->user_data = (char_u *)p + 10;
           } else if (STRNCMP(p, "line:", 5) == 0) {
-            tagp->tagline = atoi((char *)p + 5);
+            tagp->tagline = atoi(p + 5);
           }
           if (tagp->tagkind != NULL && tagp->user_data != NULL) {
             break;
           }
 
-          pc = (char_u *)vim_strchr((char *)p, ':');
-          pt = (char_u *)vim_strchr((char *)p, '\t');
+          pc = vim_strchr(p, ':');
+          pt = vim_strchr(p, '\t');
           if (pc == NULL || (pt != NULL && pc > pt)) {
-            tagp->tagkind = p;
+            tagp->tagkind = (char_u *)p;
           }
           if (pt == NULL) {
             break;
@@ -2608,16 +2607,16 @@ static int parse_match(char_u *lbuf, tagptrs_T *tagp)
       }
     }
     if (tagp->tagkind != NULL) {
-      for (p = tagp->tagkind;
+      for (p = (char *)tagp->tagkind;
            *p && *p != '\t' && *p != '\r' && *p != '\n';
            MB_PTR_ADV(p)) {}
-      tagp->tagkind_end = p;
+      tagp->tagkind_end = (char_u *)p;
     }
     if (tagp->user_data != NULL) {
-      for (p = tagp->user_data;
+      for (p = (char *)tagp->user_data;
            *p && *p != '\t' && *p != '\r' && *p != '\n';
            MB_PTR_ADV(p)) {}
-      tagp->user_data_end = p;
+      tagp->user_data_end = (char_u *)p;
     }
   }
   return retval;
@@ -2671,7 +2670,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   pbuf = xmalloc(LSIZE);
 
   // parse the match line into the tagp structure
-  if (parse_match(lbuf, &tagp) == FAIL) {
+  if (parse_match((char *)lbuf, &tagp) == FAIL) {
     tagp.fname_end = NULL;
     goto erret;
   }
@@ -3121,7 +3120,7 @@ int expand_tags(int tagnames, char_u *pat, int *num_file, char ***file)
     for (i = 0; i < *num_file; i++) {
       size_t len;
 
-      parse_match((char_u *)(*file)[i], &t_p);
+      parse_match((*file)[i], &t_p);
       len = (size_t)(t_p.tagname_end - t_p.tagname);
       if (len > name_buf_size - 3) {
         char_u *buf;
@@ -3201,7 +3200,7 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
                   TAG_REGEXP | TAG_NOIC, MAXCOL, (char *)buf_fname);
   if (ret == OK && num_matches > 0) {
     for (i = 0; i < num_matches; i++) {
-      int parse_result = parse_match((char_u *)matches[i], &tp);
+      int parse_result = parse_match(matches[i], &tp);
 
       // Avoid an unused variable warning in release builds.
       (void)parse_result;
@@ -3350,9 +3349,9 @@ static void tagstack_shift(win_T *wp)
   wp->w_tagstacklen--;
 }
 
-// Push a new item to the tag stack
-static void tagstack_push_item(win_T *wp, char_u *tagname, int cur_fnum, int cur_match, pos_T mark,
-                               int fnum, char_u *user_data)
+/// Push a new item to the tag stack
+static void tagstack_push_item(win_T *wp, char *tagname, int cur_fnum, int cur_match, pos_T mark,
+                               int fnum, char *user_data)
 {
   taggy_T *tagstack = wp->w_tagstack;
   int idx = wp->w_tagstacklen;  // top of the stack
@@ -3364,7 +3363,7 @@ static void tagstack_push_item(win_T *wp, char_u *tagname, int cur_fnum, int cur
   }
 
   wp->w_tagstacklen++;
-  tagstack[idx].tagname = (char *)tagname;
+  tagstack[idx].tagname = tagname;
   tagstack[idx].cur_fnum = cur_fnum;
   tagstack[idx].cur_match = cur_match;
   if (tagstack[idx].cur_match < 0) {
@@ -3372,16 +3371,16 @@ static void tagstack_push_item(win_T *wp, char_u *tagname, int cur_fnum, int cur
   }
   tagstack[idx].fmark.mark = mark;
   tagstack[idx].fmark.fnum = fnum;
-  tagstack[idx].user_data = (char *)user_data;
+  tagstack[idx].user_data = user_data;
 }
 
-// Add a list of items to the tag stack in the specified window
+/// Add a list of items to the tag stack in the specified window
 static void tagstack_push_items(win_T *wp, list_T *l)
 {
   listitem_T *li;
   dictitem_T *di;
   dict_T *itemdict;
-  char_u *tagname;
+  char *tagname;
   pos_T mark;
   int fnum;
 
@@ -3400,8 +3399,7 @@ static void tagstack_push_items(win_T *wp, list_T *l)
     if (list2fpos(&di->di_tv, &mark, &fnum, NULL, false) != OK) {
       continue;
     }
-    if ((tagname = (char_u *)tv_dict_get_string(itemdict, "tagname", true))
-        == NULL) {
+    if ((tagname = tv_dict_get_string(itemdict, "tagname", true)) == NULL) {
       continue;
     }
 
@@ -3413,7 +3411,7 @@ static void tagstack_push_items(win_T *wp, list_T *l)
                        (int)tv_dict_get_number(itemdict, "bufnr"),
                        (int)tv_dict_get_number(itemdict, "matchnr") - 1,
                        mark, fnum,
-                       (char_u *)tv_dict_get_string(itemdict, "user_data", true));
+                       tv_dict_get_string(itemdict, "user_data", true));
   }
 }
 
diff --git a/src/nvim/ui.c b/src/nvim/ui.c
index 46f4d137c4..08c1946e13 100644
--- a/src/nvim/ui.c
+++ b/src/nvim/ui.c
@@ -565,7 +565,7 @@ void ui_check_mouse(void)
   // - 'a' is in 'mouse' and "c" is in MOUSE_A, or
   // - the current buffer is a help file and 'h' is in 'mouse' and we are in a
   //   normal editing mode (not at hit-return message).
-  for (char_u *p = (char_u *)p_mouse; *p; p++) {
+  for (char *p = p_mouse; *p; p++) {
     switch (*p) {
     case 'a':
       if (vim_strchr(MOUSE_A, checkfor) != NULL) {
-- 
cgit 


From 0c6b39894f4cac99c3d81857986e4eae533fb59a Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 06:19:49 +0800
Subject: feat(mapset): support restoring Lua callback (#20024)

vim-patch:9.0.0341: mapset() does not restore <Nop> mapping properly

Problem:    mapset() does not restore <Nop> mapping properly.
Solution:   Use an empty string for <Nop>. (closes vim/vim#11022)
https://github.com/vim/vim/commit/92a3d20682d46359bb50a452b4f831659e799155
---
 src/nvim/mapping.c               | 46 ++++++++++++++++++++++++++--------------
 src/nvim/testdir/test_maparg.vim | 33 ++++++++++++++++++++++------
 2 files changed, 57 insertions(+), 22 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index ae37141eac..5c9903aa6b 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -277,21 +277,29 @@ static bool set_maparg_lhs_rhs(const char *const orig_lhs, const size_t orig_lhs
     mapargs->alt_lhs_len = 0;
   }
 
+  set_maparg_rhs(orig_rhs, orig_rhs_len, rhs_lua, cpo_flags, mapargs);
+
+  return true;
+}
+
+/// @see set_maparg_lhs_rhs
+static void set_maparg_rhs(const char *const orig_rhs, const size_t orig_rhs_len,
+                           const LuaRef rhs_lua, const int cpo_flags, MapArguments *const mapargs)
+{
   mapargs->rhs_lua = rhs_lua;
 
   if (rhs_lua == LUA_NOREF) {
     mapargs->orig_rhs_len = orig_rhs_len;
     mapargs->orig_rhs = xcalloc(mapargs->orig_rhs_len + 1, sizeof(char_u));
     STRLCPY(mapargs->orig_rhs, orig_rhs, mapargs->orig_rhs_len + 1);
-
     if (STRICMP(orig_rhs, "<nop>") == 0) {  // "<Nop>" means nothing
-      mapargs->rhs = xcalloc(1, sizeof(char_u));  // single null-char
+      mapargs->rhs = xcalloc(1, sizeof(char_u));  // single NUL-char
       mapargs->rhs_len = 0;
       mapargs->rhs_is_noop = true;
     } else {
       char *rhs_buf = NULL;
-      replaced = replace_termcodes(orig_rhs, orig_rhs_len, &rhs_buf, REPTERM_DO_LT, NULL,
-                                   cpo_flags);
+      char *replaced = replace_termcodes(orig_rhs, orig_rhs_len, &rhs_buf, REPTERM_DO_LT, NULL,
+                                         cpo_flags);
       mapargs->rhs_len = STRLEN(replaced);
       // NB: replace_termcodes may produce an empty string even if orig_rhs is non-empty
       // (e.g. a single ^V, see :h map-empty-rhs)
@@ -308,7 +316,6 @@ static bool set_maparg_lhs_rhs(const char *const orig_lhs, const size_t orig_lhs
                                             (char_u)KS_EXTRA, KE_LUA, rhs_lua);
     mapargs->rhs = vim_strsave((char_u *)tmp_buf);
   }
-  return true;
 }
 
 /// Parse a string of |:map-arguments| into a @ref MapArguments struct.
@@ -2150,29 +2157,36 @@ void f_mapset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   char *lhs = tv_dict_get_string(d, "lhs", false);
   char *lhsraw = tv_dict_get_string(d, "lhsraw", false);
   char *lhsrawalt = tv_dict_get_string(d, "lhsrawalt", false);
-  char *rhs = tv_dict_get_string(d, "rhs", false);
-  if (lhs == NULL || lhsraw == NULL || rhs == NULL) {
+  char *orig_rhs = tv_dict_get_string(d, "rhs", false);
+  LuaRef rhs_lua = LUA_NOREF;
+  dictitem_T *callback_di = tv_dict_find(d, S_LEN("callback"));
+  if (callback_di != NULL) {
+    Object callback_obj = vim_to_object(&callback_di->di_tv);
+    if (callback_obj.type == kObjectTypeLuaRef && callback_obj.data.luaref != LUA_NOREF) {
+      rhs_lua = callback_obj.data.luaref;
+      orig_rhs = "";  // need non-NULL for strlen()
+      callback_obj.data.luaref = LUA_NOREF;
+    }
+    api_free_object(callback_obj);
+  }
+  if (lhs == NULL || lhsraw == NULL || (orig_rhs == NULL && rhs_lua == LUA_NOREF)) {
     emsg(_("E460: entries missing in mapset() dict argument"));
+    api_free_luaref(rhs_lua);
     return;
   }
-  char *orig_rhs = rhs;
-  char *arg_buf = NULL;
-  rhs = replace_termcodes(rhs, STRLEN(rhs), &arg_buf, REPTERM_DO_LT, NULL, CPO_TO_CPO_FLAGS);
 
-  int noremap = tv_dict_get_number(d, "noremap") ? REMAP_NONE : 0;
+  int noremap = tv_dict_get_number(d, "noremap") != 0 ? REMAP_NONE : 0;
   if (tv_dict_get_number(d, "script") != 0) {
     noremap = REMAP_SCRIPT;
   }
-  MapArguments args = {  // TODO(zeertzjq): support restoring "callback"?
-    .rhs = (char_u *)rhs,
-    .rhs_lua = LUA_NOREF,
-    .orig_rhs = vim_strsave((char_u *)orig_rhs),
+  MapArguments args = {
     .expr = tv_dict_get_number(d, "expr") != 0,
     .silent = tv_dict_get_number(d, "silent") != 0,
     .nowait = tv_dict_get_number(d, "nowait") != 0,
     .replace_keycodes = tv_dict_get_number(d, "replace_keycodes") != 0,
     .desc = tv_dict_get_string(d, "desc", false),
   };
+  set_maparg_rhs(orig_rhs, strlen(orig_rhs), rhs_lua, CPO_TO_CPO_FLAGS, &args);
   scid_T sid = (scid_T)tv_dict_get_number(d, "sid");
   linenr_T lnum = (linenr_T)tv_dict_get_number(d, "lnum");
   bool buffer = tv_dict_get_number(d, "buffer") != 0;
@@ -2183,7 +2197,7 @@ void f_mapset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
   // Delete any existing mapping for this lhs and mode.
   MapArguments unmap_args = MAP_ARGUMENTS_INIT;
-  set_maparg_lhs_rhs(lhs, strlen(lhs), rhs, strlen(rhs), LUA_NOREF, 0, &unmap_args);
+  set_maparg_lhs_rhs(lhs, strlen(lhs), "", 0, LUA_NOREF, 0, &unmap_args);
   unmap_args.buffer = buffer;
   buf_do_map(MAPTYPE_UNMAP, &unmap_args, mode, false, curbuf);
   xfree(unmap_args.rhs);
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index 17c5f433ac..f903f5b934 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -158,11 +158,11 @@ func Test_range_map()
   call assert_equal("abcd", getline(1))
 endfunc
 
-func One_mapset_test(keys)
-  exe 'nnoremap ' .. a:keys .. ' original<CR>'
+func One_mapset_test(keys, rhs)
+  exe 'nnoremap ' .. a:keys .. ' ' .. a:rhs
   let orig = maparg(a:keys, 'n', 0, 1)
   call assert_equal(a:keys, orig.lhs)
-  call assert_equal('original<CR>', orig.rhs)
+  call assert_equal(a:rhs, orig.rhs)
   call assert_equal('n', orig.mode)
 
   exe 'nunmap ' .. a:keys
@@ -172,15 +172,16 @@ func One_mapset_test(keys)
   call mapset('n', 0, orig)
   let d = maparg(a:keys, 'n', 0, 1)
   call assert_equal(a:keys, d.lhs)
-  call assert_equal('original<CR>', d.rhs)
+  call assert_equal(a:rhs, d.rhs)
   call assert_equal('n', d.mode)
 
   exe 'nunmap ' .. a:keys
 endfunc
 
 func Test_mapset()
-  call One_mapset_test('K')
-  call One_mapset_test('<F3>')
+  call One_mapset_test('K', 'original<CR>')
+  call One_mapset_test('<F3>', 'original<CR>')
+  call One_mapset_test('<F3>', '<lt>Nop>')
 
   " Check <> key conversion
   new
@@ -203,6 +204,26 @@ func Test_mapset()
 
   iunmap K
 
+  " Test that <Nop> is restored properly
+  inoremap K <Nop>
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('', getline(1))
+
+  let orig = maparg('K', 'i', 0, 1)
+  call assert_equal('K', orig.lhs)
+  call assert_equal('<Nop>', orig.rhs)
+  call assert_equal('i', orig.mode)
+
+  inoremap K foo
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('foo', getline(1))
+
+  call mapset('i', 0, orig)
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('', getline(1))
+
+  iunmap K
+
   " Test literal <CR> using a backslash
   let cpo_save = &cpo
   set cpo-=B
-- 
cgit 


From 8740e0bd58c7311826e781591db5d29b4b3ffa73 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 09:12:20 +0800
Subject: vim-patch:9.0.0343: ColorScheme autocommand triggered when
 colorscheme not found (#20032)

Problem:    ColorScheme autocommand triggered when colorscheme is not found.
            (Romain Lafourcade)
Solution:   Only trigger ColorScheme when loading the colorscheme succeeds.
            (closes vim/vim#11024)
https://github.com/vim/vim/commit/5d09a401ec393dc930e1104ceb38eab34681de64

Most of Test_colorscheme() is applicable to Nvim.
---
 src/nvim/highlight_group.c    |  4 +++-
 src/nvim/testdir/test_gui.vim | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)
 create mode 100644 src/nvim/testdir/test_gui.vim

(limited to 'src')

diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index ed1f0185b7..da842e9f84 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -632,7 +632,9 @@ int load_colors(char_u *name)
     retval = source_runtime((char *)buf, DIP_START + DIP_OPT);
   }
   xfree(buf);
-  apply_autocmds(EVENT_COLORSCHEME, (char *)name, curbuf->b_fname, false, curbuf);
+  if (retval == OK) {
+    apply_autocmds(EVENT_COLORSCHEME, (char *)name, curbuf->b_fname, false, curbuf);
+  }
 
   recursive = false;
 
diff --git a/src/nvim/testdir/test_gui.vim b/src/nvim/testdir/test_gui.vim
new file mode 100644
index 0000000000..c3f1f3163a
--- /dev/null
+++ b/src/nvim/testdir/test_gui.vim
@@ -0,0 +1,43 @@
+
+func Test_colorscheme()
+  " call assert_equal('16777216', &t_Co)
+
+  let colorscheme_saved = exists('g:colors_name') ? g:colors_name : 'default'
+  let g:color_count = 0
+  augroup TestColors
+    au!
+    au ColorScheme * let g:color_count += 1
+                 \ | let g:after_colors = g:color_count
+                 \ | let g:color_after = expand('<amatch>')
+    au ColorSchemePre * let g:color_count += 1
+                    \ | let g:before_colors = g:color_count
+                    \ | let g:color_pre = expand('<amatch>')
+  augroup END
+
+  colorscheme torte
+  redraw!
+  call assert_equal('dark', &background)
+  call assert_equal(1, g:before_colors)
+  call assert_equal(2, g:after_colors)
+  call assert_equal('torte', g:color_pre)
+  call assert_equal('torte', g:color_after)
+  call assert_equal("\ntorte", execute('colorscheme'))
+
+  let a = substitute(execute('hi Search'), "\n\\s\\+", ' ', 'g')
+  " FIXME: temporarily check less while the colorscheme changes
+  " call assert_match("\nSearch         xxx term=reverse cterm=reverse ctermfg=196 ctermbg=16 gui=reverse guifg=#ff0000 guibg=#000000", a)
+  " call assert_match("\nSearch         xxx term=reverse ", a)
+
+  call assert_fails('colorscheme does_not_exist', 'E185:')
+  call assert_equal('does_not_exist', g:color_pre)
+  call assert_equal('torte', g:color_after)
+
+  exec 'colorscheme' colorscheme_saved
+  augroup TestColors
+    au!
+  augroup END
+  unlet g:color_count g:after_colors g:before_colors
+  redraw!
+endfunc
+
+" vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From a62cb406b16c53dcfbcc74c164f5ebe888ddcd89 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 10:22:28 +0800
Subject: fix(maparg): remove double allocation (#20033)

ASAN doesn't catch this, as it is referenced by the garbage collector.
Also remove a condition that is always true.
---
 src/nvim/mapping.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 5c9903aa6b..50360ee084 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -2008,8 +2008,7 @@ static Dictionary mapblock_fill_dict(const mapblock_T *const mp, const char *lhs
   FUNC_ATTR_NONNULL_ARG(1)
 {
   Dictionary dict = ARRAY_DICT_INIT;
-  char *const lhs = str2special_save((const char *)mp->m_keys,
-                                     compatible, !compatible);
+  char *const lhs = str2special_save((const char *)mp->m_keys, compatible, !compatible);
   char *const mapmode = map_mode_to_chars(mp->m_mode);
   varnumber_T noremap_value;
 
@@ -2122,13 +2121,15 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     }
   } else {
     // Return a dictionary.
-    tv_dict_alloc_ret(rettv);
     if (mp != NULL && (rhs != NULL || rhs_lua != LUA_NOREF)) {
       Dictionary dict = mapblock_fill_dict(mp,
                                            did_simplify ? (char *)keys_simplified : NULL,
                                            buffer_local, true);
       (void)object_to_vim(DICTIONARY_OBJ(dict), rettv, NULL);
       api_free_dictionary(dict);
+    } else {
+      // Return an empty dictionary.
+      tv_dict_alloc_ret(rettv);
     }
   }
 
@@ -2164,12 +2165,12 @@ void f_mapset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     Object callback_obj = vim_to_object(&callback_di->di_tv);
     if (callback_obj.type == kObjectTypeLuaRef && callback_obj.data.luaref != LUA_NOREF) {
       rhs_lua = callback_obj.data.luaref;
-      orig_rhs = "";  // need non-NULL for strlen()
+      orig_rhs = "";
       callback_obj.data.luaref = LUA_NOREF;
     }
     api_free_object(callback_obj);
   }
-  if (lhs == NULL || lhsraw == NULL || (orig_rhs == NULL && rhs_lua == LUA_NOREF)) {
+  if (lhs == NULL || lhsraw == NULL || orig_rhs == NULL) {
     emsg(_("E460: entries missing in mapset() dict argument"));
     api_free_luaref(rhs_lua);
     return;
-- 
cgit 


From 5f92d9b345e11adb73df33dc22a8e656aca73b6c Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 1 Sep 2022 09:44:01 +0200
Subject: perf(messages): don't call ui_flush() per message line in various
 places

When msgsep is used, message scrolling is emulated. To make message
output fast, inhibit emulated scrolling until the full message text
is known
---
 src/nvim/cmdexpand.c | 1 -
 src/nvim/cmdhist.c   | 1 -
 src/nvim/ex_cmds.c   | 1 -
 src/nvim/ex_docmd.c  | 3 ---
 src/nvim/mapping.c   | 1 -
 src/nvim/mark.c      | 3 ---
 src/nvim/ops.c       | 1 -
 src/nvim/option.c    | 1 -
 src/nvim/quickfix.c  | 2 --
 src/nvim/search.c    | 2 --
 src/nvim/tag.c       | 1 -
 11 files changed, 17 deletions(-)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 1c35f28301..7180a8de46 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -717,7 +717,6 @@ int showmatches(expand_T *xp, int wildmenu)
         msg_clr_eos();
         msg_putchar('\n');
       }
-      ui_flush();                          // show one line at a time
       if (got_int) {
         got_int = false;
         break;
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 1426054d0b..2057b0db9e 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -650,7 +650,6 @@ void ex_history(exarg_T *eap)
             STRCAT(IObuff, hist[i].hisstr);
           }
           msg_outtrans((char *)IObuff);
-          ui_flush();
         }
         if (i == idx) {
           break;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 17d45f207e..2c82436a25 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -5004,7 +5004,6 @@ void ex_oldfiles(exarg_T *eap)
         msg_outtrans((char *)tv_get_string(TV_LIST_ITEM_TV(li)));
         msg_clr_eos();
         msg_putchar('\n');
-        ui_flush();                  // output one line at a time
         os_breakcheck();
       }
     });
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 8f72ba0e23..9e196e9516 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -4833,7 +4833,6 @@ static void ex_print(exarg_T *eap)
       if (++eap->line1 > eap->line2) {
         break;
       }
-      ui_flush();                  // show one line at a time
     }
     setpcmark();
     // put cursor at last line
@@ -5035,7 +5034,6 @@ static void ex_tabs(exarg_T *eap)
     msg_putchar('\n');
     vim_snprintf((char *)IObuff, IOSIZE, _("Tab page %d"), tabcount++);
     msg_outtrans_attr((char *)IObuff, HL_ATTR(HLF_T));
-    ui_flush();            // output one line at a time
     os_breakcheck();
 
     FOR_ALL_WINDOWS_IN_TAB(wp, tp) {
@@ -5054,7 +5052,6 @@ static void ex_tabs(exarg_T *eap)
         home_replace(wp->w_buffer, wp->w_buffer->b_fname, (char *)IObuff, IOSIZE, true);
       }
       msg_outtrans((char *)IObuff);
-      ui_flush();                  // output one line at a time
       os_breakcheck();
     }
   }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index ae37141eac..a3705d5c6f 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -214,7 +214,6 @@ static void showmap(mapblock_T *mp, bool local)
     last_set_msg(mp->m_script_ctx);
   }
   msg_clr_eos();
-  ui_flush();                          // show one line at a time
 }
 
 /// Replace termcodes in the given LHS and RHS and store the results into the
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 816599271d..7eab37e797 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -925,7 +925,6 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
           msg_outtrans_attr((char *)name, current ? HL_ATTR(HLF_D) : 0);
         }
       }
-      ui_flush();  // show one line at a time
     }
     if (mustfree) {
       xfree(name);
@@ -1058,7 +1057,6 @@ void ex_jumps(exarg_T *eap)
       xfree(name);
       os_breakcheck();
     }
-    ui_flush();
   }
   if (curwin->w_jumplistidx == curwin->w_jumplistlen) {
     msg_puts("\n>");
@@ -1101,7 +1099,6 @@ void ex_changes(exarg_T *eap)
       xfree(name);
       os_breakcheck();
     }
-    ui_flush();
   }
   if (curwin->w_changelistidx == curbuf->b_changelistlen) {
     msg_puts("\n>");
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index adb071b754..d2321be4a4 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -3866,7 +3866,6 @@ void ex_display(exarg_T *eap)
         if (n > 1 && yb->y_type == kMTLineWise) {
           msg_puts_attr("^J", attr);
         }
-        ui_flush();  // show one line at a time
       }
       os_breakcheck();
     }
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 455070c742..269a21b512 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -3355,7 +3355,6 @@ static void showoptions(int all, int opt_flags)
         showoneopt(items[i], opt_flags);
         col += INC;
       }
-      ui_flush();
       os_breakcheck();
     }
   }
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index f1fc48ef40..86f60cb57e 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -3094,8 +3094,6 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   if (tbuf != IObuff) {
     xfree(tbuf);
   }
-
-  ui_flush();  // show one line at a time
 }
 
 // ":clist": list all errors
diff --git a/src/nvim/search.c b/src/nvim/search.c
index d7f8d4e1cd..e9ac9ecf2b 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -3714,7 +3714,6 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
             }
           }
         }
-        ui_flush();                // output each line directly
       }
 
       if (new_fname != NULL) {
@@ -4147,7 +4146,6 @@ static void show_pat_in_path(char_u *line, int type, bool did_show, int action,
       msg_puts(" ");
     }
     msg_prt_line((char *)line, false);
-    ui_flush();                        // show one line at a time
 
     // Definition continues until line that doesn't end with '\'
     if (got_int || type != FIND_DEFINE || p < line || *p != '\\') {
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 4fd99b058b..b694297d63 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1056,7 +1056,6 @@ void do_tags(exarg_T *eap)
                         ? HL_ATTR(HLF_D) : 0);
       xfree(name);
     }
-    ui_flush();                    // show one line at a time
   }
   if (tagstackidx == tagstacklen) {     // idx at top of stack
     msg_puts("\n>");
-- 
cgit 


From db2e5f46f5aa5a6300395eaa9c4923835683c770 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 16:37:29 +0800
Subject: fix(lua): make ui_attach()/ui_detach() take effect immediately
 (#20037)

---
 src/nvim/ui_compositor.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c
index 5167f291c3..b8c7834e2b 100644
--- a/src/nvim/ui_compositor.c
+++ b/src/nvim/ui_compositor.c
@@ -749,7 +749,7 @@ void ui_comp_add_cb(uint32_t ns_id, LuaRef cb, bool *ext_widgets)
   *item = event_cb;
 
   ui_comp_update_ext();
-  ui_schedule_refresh();
+  ui_refresh();
 }
 
 void ui_comp_remove_cb(uint32_t ns_id)
@@ -759,5 +759,5 @@ void ui_comp_remove_cb(uint32_t ns_id)
     pmap_del(uint32_t)(&ui_event_cbs, ns_id);
   }
   ui_comp_update_ext();
-  ui_schedule_refresh();
+  ui_refresh();
 }
-- 
cgit 


From 49e893f296bca9eef5ff45a3d746c261d055bf10 Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/change.c                  |  10 +-
 src/nvim/charset.c                 |  54 +++++-----
 src/nvim/cmdexpand.c               |  71 +++++++------
 src/nvim/cmdhist.c                 |  24 ++---
 src/nvim/cmdhist.h                 |   2 +-
 src/nvim/cursor.c                  |   4 +-
 src/nvim/digraph.c                 |  24 ++---
 src/nvim/edit.c                    |  36 +++----
 src/nvim/eval.c                    |   4 +-
 src/nvim/eval/decode.c             |   4 +-
 src/nvim/eval/funcs.c              |  42 ++++----
 src/nvim/eval/typval.c             |   3 +-
 src/nvim/eval/userfunc.c           | 197 ++++++++++++++++++-------------------
 src/nvim/ex_cmds.c                 |   8 +-
 src/nvim/ex_docmd.c                |   4 +-
 src/nvim/ex_getln.c                | 134 ++++++++++++-------------
 src/nvim/ex_getln.h                |   2 +-
 src/nvim/file_search.c             | 104 +++++++++-----------
 src/nvim/fileio.c                  |  22 ++---
 src/nvim/getchar.c                 |   4 +-
 src/nvim/grid.c                    |   2 +-
 src/nvim/indent.c                  |  10 +-
 src/nvim/indent_c.c                |  82 +++++++--------
 src/nvim/insexpand.c               | 120 +++++++++++-----------
 src/nvim/keycodes.c                |   8 +-
 src/nvim/mark.c                    |  22 ++---
 src/nvim/match.c                   |  26 ++---
 src/nvim/mbyte.c                   |  42 ++++----
 src/nvim/memline.c                 |  40 ++++----
 src/nvim/message.c                 |   6 +-
 src/nvim/normal.c                  |  24 ++---
 src/nvim/ops.c                     |  82 ++++++++-------
 src/nvim/option.c                  |   6 +-
 src/nvim/os/shell.c                |   4 +-
 src/nvim/path.c                    |  33 ++++---
 src/nvim/regexp.c                  |   6 +-
 src/nvim/regexp_bt.c               |  16 +--
 src/nvim/regexp_nfa.c              |  10 +-
 src/nvim/search.c                  |  31 +++---
 src/nvim/shada.c                   |   8 +-
 src/nvim/spell.c                   |  22 ++---
 src/nvim/spellsuggest.c            |  47 +++++----
 src/nvim/strings.c                 |  21 +---
 src/nvim/syntax.c                  |  33 ++++---
 src/nvim/tag.c                     |  31 +++---
 src/nvim/textformat.c              |  14 +--
 src/nvim/textobject.c              |   4 +-
 src/nvim/viml/parser/expressions.c |   9 +-
 src/nvim/window.c                  |   6 +-
 49 files changed, 742 insertions(+), 776 deletions(-)

(limited to 'src')

diff --git a/src/nvim/change.c b/src/nvim/change.c
index 5bea388f28..5e9edac4f2 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -599,7 +599,7 @@ void ins_bytes_len(char *p, size_t len)
   size_t n;
   for (size_t i = 0; i < len; i += n) {
     // avoid reading past p[len]
-    n = (size_t)utfc_ptr2len_len((char_u *)p + i, (int)(len - i));
+    n = (size_t)utfc_ptr2len_len(p + i, (int)(len - i));
     ins_char_bytes(p + i, n);
   }
 }
@@ -828,7 +828,7 @@ int del_bytes(colnr_T count, bool fixpos_arg, bool use_delcombine)
         col = n;
         count = utf_ptr2len(oldp + n);
         n += count;
-      } while (utf_composinglike((char_u *)oldp + col, (char_u *)oldp + n));
+      } while (utf_composinglike(oldp + col, oldp + n));
       fixpos = false;
     }
   }
@@ -1036,7 +1036,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   colnr_T mincol = curwin->w_cursor.col + 1;
 
   // make a copy of the current line so we can mess with it
-  char *saved_line = (char *)vim_strsave(get_cursor_line_ptr());
+  char *saved_line = (char *)vim_strsave((char_u *)get_cursor_line_ptr());
 
   if (State & VREPLACE_FLAG) {
     // With MODE_VREPLACE we make a copy of the next line, which we will be
@@ -1181,7 +1181,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
             if ((pos = findmatch(NULL, '(')) != NULL) {
               curwin->w_cursor.lnum = pos->lnum;
               newindent = get_indent();
-              ptr = (char *)get_cursor_line_ptr();
+              ptr = get_cursor_line_ptr();
             }
           }
           // If last character is '{' do indent, without
@@ -1838,7 +1838,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   // stuff onto the replace stack (via ins_char()).
   if (State & VREPLACE_FLAG) {
     // Put new line in p_extra
-    p_extra = (char *)vim_strsave(get_cursor_line_ptr());
+    p_extra = xstrdup(get_cursor_line_ptr());
 
     // Put back original line
     ml_replace(curwin->w_cursor.lnum, next_line, false);
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 4604bf7716..3396e2de41 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -789,7 +789,7 @@ bool vim_iswordc_buf(const int c, buf_T *const buf)
 bool vim_iswordp(const char_u *const p)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  return vim_iswordp_buf(p, curbuf);
+  return vim_iswordp_buf((char *)p, curbuf);
 }
 
 /// Just like vim_iswordc_buf() but uses a pointer to the (multi-byte)
@@ -799,13 +799,13 @@ bool vim_iswordp(const char_u *const p)
 /// @param  buf  buffer whose keywords to use
 ///
 /// @return true if "p" points to a keyword character.
-bool vim_iswordp_buf(const char_u *const p, buf_T *const buf)
+bool vim_iswordp_buf(const char *const p, buf_T *const buf)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ALL
 {
-  int c = *p;
+  int c = (uint8_t)(*p);
 
   if (MB_BYTE2LEN(c) > 1) {
-    c = utf_ptr2char((char *)p);
+    c = utf_ptr2char(p);
   }
   return vim_iswordc_buf(c, buf);
 }
@@ -829,8 +829,8 @@ bool vim_isfilec(int c)
 bool vim_isfilec_or_wc(int c)
   FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  char_u buf[2];
-  buf[0] = (char_u)c;
+  char buf[2];
+  buf[0] = (char)c;
   buf[1] = NUL;
   return vim_isfilec(c) || c == ']' || path_has_wildcard(buf);
 }
@@ -905,15 +905,15 @@ bool in_win_border(win_T *wp, colnr_T vcol)
 /// @param end
 void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *end)
 {
-  char_u *ptr;    // points to current char
-  char_u *posptr;  // points to char at pos->col
+  char *ptr;     // points to current char
+  char *posptr;  // points to char at pos->col
   int incr;
   int head;
   long *vts = wp->w_buffer->b_p_vts_array;
   int ts = (int)wp->w_buffer->b_p_ts;
 
   colnr_T vcol = 0;
-  char_u *line = ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);  // start of the line
+  char *line = ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false);  // start of the line
 
   if (pos->col == MAXCOL) {
     // continue until the NUL
@@ -927,11 +927,11 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
       }
     }
     posptr = ptr + pos->col;
-    posptr -= utf_head_off((char *)line, (char *)posptr);
+    posptr -= utf_head_off(line, posptr);
   }
 
   chartabsize_T cts;
-  init_chartabsize_arg(&cts, wp, pos->lnum, 0, (char *)line, (char *)line);
+  init_chartabsize_arg(&cts, wp, pos->lnum, 0, line, line);
 
   // This function is used very often, do some speed optimizations.
   // When 'list', 'linebreak', 'showbreak' and 'breakindent' are not set
@@ -944,7 +944,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
       && !cts.cts_has_virt_text) {
     for (;;) {
       head = 0;
-      int c = *ptr;
+      int c = (uint8_t)(*ptr);
 
       // make sure we don't go past the end of the line
       if (c == NUL) {
@@ -960,7 +960,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
         // For utf-8, if the byte is >= 0x80, need to look at
         // further bytes to find the cell width.
         if (c >= 0x80) {
-          incr = utf_ptr2cells((char *)ptr);
+          incr = utf_ptr2cells(ptr);
         } else {
           incr = g_chartab[c] & CT_CELL_MASK;
         }
@@ -970,7 +970,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
         // cells wide.
         if ((incr == 2)
             && wp->w_p_wrap
-            && (MB_BYTE2LEN(*ptr) > 1)
+            && (MB_BYTE2LEN((uint8_t)(*ptr)) > 1)
             && in_win_border(wp, vcol)) {
           incr++;
           head = 1;
@@ -999,7 +999,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
         break;
       }
 
-      if ((posptr != NULL) && ((char_u *)cts.cts_ptr >= posptr)) {
+      if ((posptr != NULL) && (cts.cts_ptr >= posptr)) {
         // character at pos->col
         break;
       }
@@ -1008,7 +1008,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
       MB_PTR_ADV(cts.cts_ptr);
     }
     vcol = cts.cts_vcol;
-    ptr = (char_u *)cts.cts_ptr;
+    ptr = cts.cts_ptr;
   }
   clear_chartabsize_arg(&cts);
 
@@ -1076,10 +1076,10 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *e
     colnr_T endadd = 0;
 
     // Cannot put the cursor on part of a wide character.
-    char_u *ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);
+    char *ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false);
 
     if (pos->col < (colnr_T)STRLEN(ptr)) {
-      int c = utf_ptr2char((char *)ptr + pos->col);
+      int c = utf_ptr2char(ptr + pos->col);
       if ((c != TAB) && vim_isprintc(c)) {
         endadd = (colnr_T)(char2cells(c) - 1);
         if (coladd > endadd) {
@@ -1182,7 +1182,7 @@ char *skipwhite_len(const char *p, size_t len)
 // columns (bytes) at the start of a given line
 intptr_t getwhitecols_curline(void)
 {
-  return getwhitecols((char *)get_cursor_line_ptr());
+  return getwhitecols(get_cursor_line_ptr());
 }
 
 intptr_t getwhitecols(const char *p)
@@ -1338,7 +1338,7 @@ char *skip_to_newline(const char *const p)
 
 /// Gets a number from a string and skips over it, signalling overflow.
 ///
-/// @param[out]  pp  A pointer to a pointer to char_u.
+/// @param[out]  pp  A pointer to a pointer to char.
 ///                  It will be advanced past the read number.
 /// @param[out]  nr  Number read from the string.
 ///
@@ -1355,7 +1355,7 @@ bool try_getdigits(char **pp, intmax_t *nr)
 
 /// Gets a number from a string and skips over it.
 ///
-/// @param[out]  pp  Pointer to a pointer to char_u.
+/// @param[out]  pp  Pointer to a pointer to char.
 ///                  It will be advanced past the read number.
 /// @param strict    Abort on overflow.
 /// @param def       Default value, if parsing fails or overflow occurs.
@@ -1463,14 +1463,14 @@ bool vim_isblankline(char *lbuf)
 /// @param strict If true, fail if the number has unexpected trailing
 ///               alphanumeric chars: *len is set to 0 and nothing else is
 ///               returned.
-void vim_str2nr(const char_u *const start, int *const prep, int *const len, const int what,
+void vim_str2nr(const char *const start, int *const prep, int *const len, const int what,
                 varnumber_T *const nptr, uvarnumber_T *const unptr, const int maxlen,
                 const bool strict)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  const char *ptr = (const char *)start;
+  const char *ptr = start;
 #define STRING_ENDED(ptr) \
-  (!(maxlen == 0 || (int)((ptr) - (const char *)start) < maxlen))
+  (!(maxlen == 0 || (int)((ptr) - start) < maxlen))
   int pre = 0;  // default is decimal
   const bool negative = (ptr[0] == '-');
   uvarnumber_T un = 0;
@@ -1522,7 +1522,7 @@ void vim_str2nr(const char_u *const start, int *const prep, int *const len, cons
   } else if ((what & (STR2NR_HEX | STR2NR_OCT | STR2NR_OOCT | STR2NR_BIN))
              && !STRING_ENDED(ptr + 1) && ptr[0] == '0' && ptr[1] != '8'
              && ptr[1] != '9') {
-    pre = (char_u)ptr[1];
+    pre = (uint8_t)ptr[1];
     // Detect hexadecimal: 0x or 0X followed by hex digit.
     if ((what & STR2NR_HEX)
         && !STRING_ENDED(ptr + 2)
@@ -1610,7 +1610,7 @@ vim_str2nr_hex:
 vim_str2nr_proceed:
   // Check for an alphanumeric character immediately following, that is
   // most likely a typo.
-  if (strict && ptr - (const char *)start != maxlen && ASCII_ISALNUM(*ptr)) {
+  if (strict && ptr - start != maxlen && ASCII_ISALNUM(*ptr)) {
     return;
   }
 
@@ -1619,7 +1619,7 @@ vim_str2nr_proceed:
   }
 
   if (len != NULL) {
-    *len = (int)(ptr - (const char *)start);
+    *len = (int)(ptr - start);
   }
 
   if (nptr != NULL) {
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 6fc63f72a1..0d3aefc83e 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -177,7 +177,7 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
     ui_flush();
   }
 
-  i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
+  i = (int)(xp->xp_pattern - ccline->cmdbuff);
   assert(ccline->cmdpos >= i);
   xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
 
@@ -186,20 +186,20 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
     p2 = ExpandOne(xp, NULL, NULL, 0, type);
   } else {
     // Translate string into pattern and expand it.
-    p1 = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
+    p1 = (char_u *)addstar(xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
     const int use_options = (options
                              | WILD_HOME_REPLACE
                              | WILD_ADD_SLASH
                              | WILD_SILENT
                              | (escape ? WILD_ESCAPE : 0)
                              | (p_wic ? WILD_ICASE : 0));
-    p2 = ExpandOne(xp, p1, vim_strnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
+    p2 = ExpandOne(xp, p1, (char_u *)xstrnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
                    use_options, type);
     xfree(p1);
 
     // xp->xp_pattern might have been modified by ExpandOne (for example,
     // in lua completion), so recompute the pattern index and length
-    i = (int)((char_u *)xp->xp_pattern - ccline->cmdbuff);
+    i = (int)(xp->xp_pattern - ccline->cmdbuff);
     xp->xp_pattern_len = (size_t)ccline->cmdpos - (size_t)i;
 
     // Longest match: make sure it is not shorter, happens with :help.
@@ -220,7 +220,7 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
     difflen = (int)STRLEN(p2) - (int)(xp->xp_pattern_len);
     if (ccline->cmdlen + difflen + 4 > ccline->cmdbufflen) {
       realloc_cmdbuff(ccline->cmdlen + difflen + 4);
-      xp->xp_pattern = (char *)ccline->cmdbuff + i;
+      xp->xp_pattern = ccline->cmdbuff + i;
     }
     assert(ccline->cmdpos <= ccline->cmdlen);
     memmove(&ccline->cmdbuff[ccline->cmdpos + difflen],
@@ -573,7 +573,7 @@ int showmatches(expand_T *xp, int wildmenu)
 
   if (xp->xp_numfiles == -1) {
     set_expand_context(xp);
-    i = expand_cmdline(xp, ccline->cmdbuff, ccline->cmdpos,
+    i = expand_cmdline(xp, (char_u *)ccline->cmdbuff, ccline->cmdpos,
                        &num_files, &files_found);
     showtail = expand_showtail(xp);
     if (i != EXPAND_OK) {
@@ -602,7 +602,7 @@ int showmatches(expand_T *xp, int wildmenu)
         .pum_kind = NULL,
       };
     }
-    char_u *endpos = (char_u *)(showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
+    char *endpos = (showtail ? sm_gettail(xp->xp_pattern, true) : xp->xp_pattern);
     if (ui_has(kUICmdline)) {
       compl_startcol = (int)(endpos - ccline->cmdbuff);
     } else {
@@ -803,13 +803,13 @@ static bool expand_showtail(expand_T *xp)
 /// the name into allocated memory and prepend "^".
 ///
 /// @param context EXPAND_FILES etc.
-char_u *addstar(char_u *fname, size_t len, int context)
+char *addstar(char *fname, size_t len, int context)
   FUNC_ATTR_NONNULL_RET
 {
-  char_u *retval;
+  char *retval;
   size_t i, j;
   size_t new_len;
-  char_u *tail;
+  char *tail;
   int ends_in_star;
 
   if (context != EXPAND_FILES
@@ -831,7 +831,7 @@ char_u *addstar(char_u *fname, size_t len, int context)
         || context == EXPAND_PACKADD
         || ((context == EXPAND_TAGS_LISTFILES || context == EXPAND_TAGS)
             && fname[0] == '/')) {
-      retval = vim_strnsave(fname, len);
+      retval = xstrnsave(fname, len);
     } else {
       new_len = len + 2;                // +2 for '^' at start, NUL at end
       for (i = 0; i < len; i++) {
@@ -901,7 +901,7 @@ char_u *addstar(char_u *fname, size_t len, int context)
     // $ could be anywhere in the tail.
     // ` could be anywhere in the file name.
     // When the name ends in '$' don't add a star, remove the '$'.
-    tail = (char_u *)path_tail((char *)retval);
+    tail = path_tail(retval);
     ends_in_star = (len > 0 && retval[len - 1] == '*');
 #ifndef BACKSLASH_IN_FILENAME
     for (ssize_t k = (ssize_t)len - 2; k >= 0; k--) {
@@ -913,8 +913,8 @@ char_u *addstar(char_u *fname, size_t len, int context)
 #endif
     if ((*retval != '~' || tail != retval)
         && !ends_in_star
-        && vim_strchr((char *)tail, '$') == NULL
-        && vim_strchr((char *)retval, '`') == NULL) {
+        && vim_strchr(tail, '$') == NULL
+        && vim_strchr(retval, '`') == NULL) {
       retval[len++] = '*';
     } else if (len > 0 && retval[len - 1] == '$') {
       len--;
@@ -976,7 +976,7 @@ void set_expand_context(expand_T *xp)
     xp->xp_context = EXPAND_NOTHING;
     return;
   }
-  set_cmd_context(xp, ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
+  set_cmd_context(xp, (char_u *)ccline->cmdbuff, ccline->cmdlen, ccline->cmdpos, true);
 }
 
 /// Sets the index of a built-in or user defined command "cmd" in eap->cmdidx.
@@ -1850,7 +1850,7 @@ void set_cmd_context(expand_T *xp, char_u *str, int len, int col, int use_ccline
     set_context_for_expression(xp, (char *)str, CMD_SIZE);
   } else if (use_ccline && ccline->input_fn) {
     xp->xp_context = ccline->xp_context;
-    xp->xp_pattern = (char *)ccline->cmdbuff;
+    xp->xp_pattern = ccline->cmdbuff;
     xp->xp_arg = (char *)ccline->xp_arg;
   } else {
     while (nextcomm != NULL) {
@@ -1897,7 +1897,7 @@ int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***
   // add star to file name, or convert to regexp if not exp. files.
   assert((str + col) - (char_u *)xp->xp_pattern >= 0);
   xp->xp_pattern_len = (size_t)((str + col) - (char_u *)xp->xp_pattern);
-  file_str = addstar((char_u *)xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
+  file_str = (char_u *)addstar(xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
 
   if (p_wic) {
     options += WILD_ICASE;
@@ -2437,9 +2437,9 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
   FUNC_ATTR_NONNULL_ALL
 {
   CmdlineInfo *const ccline = get_cmdline_info();
-  char_u keep = 0;
+  char keep = 0;
   typval_T args[4];
-  char_u *pat = NULL;
+  char *pat = NULL;
   const sctx_T save_current_sctx = current_sctx;
 
   if (xp->xp_arg == NULL || xp->xp_arg[0] == '\0' || xp->xp_line == NULL) {
@@ -2453,12 +2453,12 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
     ccline->cmdbuff[ccline->cmdlen] = 0;
   }
 
-  pat = vim_strnsave((char_u *)xp->xp_pattern, xp->xp_pattern_len);
+  pat = xstrnsave(xp->xp_pattern, xp->xp_pattern_len);
   args[0].v_type = VAR_STRING;
   args[1].v_type = VAR_STRING;
   args[2].v_type = VAR_NUMBER;
   args[3].v_type = VAR_UNKNOWN;
-  args[0].vval.v_string = (char *)pat;
+  args[0].vval.v_string = pat;
   args[1].vval.v_string = xp->xp_line;
   args[2].vval.v_number = xp->xp_col;
 
@@ -2478,30 +2478,29 @@ static void *call_user_expand_func(user_expand_func_T user_expand_func, expand_T
 /// Expand names with a function defined by the user.
 static int ExpandUserDefined(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***file)
 {
-  char_u *e;
+  char *e;
   garray_T ga;
 
-  char_u *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
-                                               file);
+  char *const retstr = call_user_expand_func((user_expand_func_T)call_func_retstr, xp, num_file,
+                                             file);
 
   if (retstr == NULL) {
     return FAIL;
   }
 
   ga_init(&ga, (int)sizeof(char *), 3);
-  for (char_u *s = retstr; *s != NUL; s = e) {
-    e = (char_u *)vim_strchr((char *)s, '\n');
+  for (char *s = retstr; *s != NUL; s = e) {
+    e = vim_strchr(s, '\n');
     if (e == NULL) {
       e = s + STRLEN(s);
     }
-    const char_u keep = *e;
+    const char keep = *e;
     *e = NUL;
 
-    const bool skip = xp->xp_pattern[0]
-                      && vim_regexec(regmatch, (char *)s, (colnr_T)0) == 0;
+    const bool skip = xp->xp_pattern[0] && vim_regexec(regmatch, s, (colnr_T)0) == 0;
     *e = keep;
     if (!skip) {
-      GA_APPEND(char_u *, &ga, vim_strnsave(s, (size_t)(e - s)));
+      GA_APPEND(char *, &ga, xstrnsave(s, (size_t)(e - s)));
     }
 
     if (*e != NUL) {
@@ -2662,7 +2661,7 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       // cursor
       int found = false;
 
-      int j = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
+      int j = (int)(xp->xp_pattern - cclp->cmdbuff);
       int i = 0;
       while (--j > 0) {
         // check for start of menu name
@@ -2717,9 +2716,9 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int found = false;
 
       int j = cclp->cmdpos;
-      int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
+      int i = (int)(xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
+        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])) {
           found = true;
           break;
@@ -2738,9 +2737,9 @@ int wildmenu_process_key(CmdlineInfo *cclp, int key, expand_T *xp)
       int found = false;
 
       int j = cclp->cmdpos - 1;
-      int i = (int)((char_u *)xp->xp_pattern - cclp->cmdbuff);
+      int i = (int)(xp->xp_pattern - cclp->cmdbuff);
       while (--j > i) {
-        j -= utf_head_off((char *)cclp->cmdbuff, (char *)cclp->cmdbuff + j);
+        j -= utf_head_off(cclp->cmdbuff, cclp->cmdbuff + j);
         if (vim_ispathsep(cclp->cmdbuff[j])
 #ifdef BACKSLASH_IN_FILENAME
             && vim_strchr((const char_u *)" *?[{`$%#", cclp->cmdbuff[j + 1])
@@ -2894,7 +2893,7 @@ void f_getcompletion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
 theend:
-  pat = addstar((char_u *)xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
+  pat = (char_u *)addstar(xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
   ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
   tv_list_alloc_ret(rettv, xpc.xp_numfiles);
 
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 2057b0db9e..629c47f24a 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -201,7 +201,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
 
     // For search history, check that the separator character matches as
     // well.
-    char_u *p = history[type][i].hisstr;
+    char_u *p = (char_u *)history[type][i].hisstr;
     if (STRCMP(str, p) == 0
         && (type != HIST_SEARCH || sep == p[STRLEN(p) + 1])) {
       if (!move_to_front) {
@@ -217,7 +217,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
 
   if (last_i >= 0) {
     list_T *const list = history[type][i].additional_elements;
-    str = history[type][i].hisstr;
+    str = (char_u *)history[type][i].hisstr;
     while (i != hisidx[type]) {
       if (++i >= hislen) {
         i = 0;
@@ -227,7 +227,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
     }
     tv_list_unref(list);
     history[type][i].hisnum = ++hisnum[type];
-    history[type][i].hisstr = str;
+    history[type][i].hisstr = (char *)str;
     history[type][i].timestamp = os_time();
     history[type][i].additional_elements = NULL;
     return true;
@@ -276,7 +276,7 @@ static int last_maptick = -1;           // last seen maptick
 /// @param histype  may be one of the HIST_ values.
 /// @param in_map   consider maptick when inside a mapping
 /// @param sep      separator character used (search hist)
-void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
+void add_to_history(int histype, char *new_entry, int in_map, int sep)
 {
   histentry_T *hisptr;
 
@@ -304,7 +304,7 @@ void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
     }
     last_maptick = -1;
   }
-  if (!in_history(histype, new_entry, true, sep)) {
+  if (!in_history(histype, (char_u *)new_entry, true, sep)) {
     if (++hisidx[histype] == hislen) {
       hisidx[histype] = 0;
     }
@@ -313,10 +313,10 @@ void add_to_history(int histype, char_u *new_entry, int in_map, int sep)
 
     // Store the separator after the NUL of the string.
     size_t len = STRLEN(new_entry);
-    hisptr->hisstr = vim_strnsave(new_entry, len + 2);
+    hisptr->hisstr = xstrnsave(new_entry, len + 2);
     hisptr->timestamp = os_time();
     hisptr->additional_elements = NULL;
-    hisptr->hisstr[len + 1] = (char_u)sep;
+    hisptr->hisstr[len + 1] = (char)sep;
 
     hisptr->hisnum = ++hisnum[histype];
     if (histype == HIST_SEARCH && in_map) {
@@ -386,7 +386,7 @@ static char_u *get_history_entry(int histype, int idx)
 {
   idx = calc_hist_idx(histype, idx);
   if (idx >= 0) {
-    return history[histype][idx].hisstr;
+    return (char_u *)history[histype][idx].hisstr;
   } else {
     return (char_u *)"";
   }
@@ -438,7 +438,7 @@ static int del_history_entry(int histype, char_u *str)
       if (hisptr->hisstr == NULL) {
         break;
       }
-      if (vim_regexec(&regmatch, (char *)hisptr->hisstr, (colnr_T)0)) {
+      if (vim_regexec(&regmatch, hisptr->hisstr, (colnr_T)0)) {
         found = true;
         hist_free_entry(hisptr);
       } else {
@@ -509,7 +509,7 @@ void f_histadd(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     str = tv_get_string_buf(&argvars[1], buf);
     if (*str != NUL) {
       init_history();
-      add_to_history(histype, (char_u *)str, false, NUL);
+      add_to_history(histype, (char *)str, false, NUL);
       rettv->vval.v_number = true;
       return;
     }
@@ -643,8 +643,8 @@ void ex_history(exarg_T *eap)
           msg_putchar('\n');
           snprintf((char *)IObuff, IOSIZE, "%c%6d  ", i == idx ? '>' : ' ',
                    hist[i].hisnum);
-          if (vim_strsize((char *)hist[i].hisstr) > Columns - 10) {
-            trunc_string((char *)hist[i].hisstr, (char *)IObuff + STRLEN(IObuff),
+          if (vim_strsize(hist[i].hisstr) > Columns - 10) {
+            trunc_string(hist[i].hisstr, (char *)IObuff + STRLEN(IObuff),
                          Columns - 10, IOSIZE - (int)STRLEN(IObuff));
           } else {
             STRCAT(IObuff, hist[i].hisstr);
diff --git a/src/nvim/cmdhist.h b/src/nvim/cmdhist.h
index 797b79a5f0..8b7bb7ac24 100644
--- a/src/nvim/cmdhist.h
+++ b/src/nvim/cmdhist.h
@@ -22,7 +22,7 @@ typedef enum {
 /// History entry definition
 typedef struct hist_entry {
   int hisnum;           ///< Entry identifier number.
-  char_u *hisstr;       ///< Actual entry, separator char after the NUL.
+  char *hisstr;         ///< Actual entry, separator char after the NUL.
   Timestamp timestamp;  ///< Time when entry was added.
   list_T *additional_elements;  ///< Additional entries from ShaDa file.
 } histentry_T;
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index 54e5ffff37..2a3fe9701c 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -493,9 +493,9 @@ void pchar_cursor(char_u c)
 }
 
 /// @return  pointer to cursor line.
-char_u *get_cursor_line_ptr(void)
+char *get_cursor_line_ptr(void)
 {
-  return ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
+  return (char *)ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
 }
 
 /// @return  pointer to cursor position.
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index e4528f9038..53b6c66c46 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -2010,8 +2010,8 @@ void f_digraph_setlist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
 /// structure used for b_kmap_ga.ga_data
 typedef struct {
-  char_u *from;
-  char_u *to;
+  char *from;
+  char *to;
 } kmap_T;
 
 #define KMAP_MAXLEN 20  // maximum length of "from" or "to"
@@ -2064,10 +2064,10 @@ char *keymap_init(void)
 /// @param eap
 void ex_loadkeymap(exarg_T *eap)
 {
-  char_u *s;
+  char *s;
 
 #define KMAP_LLEN 200  // max length of "to" and "from" together
-  char_u buf[KMAP_LLEN + 11];
+  char buf[KMAP_LLEN + 11];
   char *save_cpo = p_cpo;
 
   if (!getline_equal(eap->getline, eap->cookie, getsourceline)) {
@@ -2092,15 +2092,15 @@ void ex_loadkeymap(exarg_T *eap)
       break;
     }
 
-    char_u *p = (char_u *)skipwhite(line);
+    char *p = skipwhite(line);
 
     if ((*p != '"') && (*p != NUL)) {
       kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga);
-      s = (char_u *)skiptowhite((char *)p);
-      kp->from = vim_strnsave(p, (size_t)(s - p));
-      p = (char_u *)skipwhite((char *)s);
-      s = (char_u *)skiptowhite((char *)p);
-      kp->to = vim_strnsave(p, (size_t)(s - p));
+      s = skiptowhite(p);
+      kp->from = xstrnsave(p, (size_t)(s - p));
+      p = skipwhite(s);
+      s = skiptowhite(p);
+      kp->to = xstrnsave(p, (size_t)(s - p));
 
       if ((STRLEN(kp->from) + STRLEN(kp->to) >= KMAP_LLEN)
           || (*kp->from == NUL)
@@ -2118,10 +2118,10 @@ void ex_loadkeymap(exarg_T *eap)
 
   // setup ":lmap" to map the keys
   for (int i = 0; i < curbuf->b_kmap_ga.ga_len; i++) {
-    vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s %s",
+    vim_snprintf(buf, sizeof(buf), "<buffer> %s %s",
                  ((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].from,
                  ((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].to);
-    (void)do_map(MAPTYPE_MAP, buf, MODE_LANGMAP, false);
+    (void)do_map(MAPTYPE_MAP, (char_u *)buf, MODE_LANGMAP, false);
   }
 
   p_cpo = save_cpo;
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 9144d055f7..eac184c096 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -190,7 +190,7 @@ static void insert_enter(InsertState *s)
     }
   }
 
-  Insstart_textlen = (colnr_T)linetabsize(get_cursor_line_ptr());
+  Insstart_textlen = (colnr_T)linetabsize((char_u *)get_cursor_line_ptr());
   Insstart_blank_vcol = MAXCOL;
 
   if (!did_ai) {
@@ -274,7 +274,7 @@ static void insert_enter(InsertState *s)
     update_curswant();
     if (((ins_at_eol && curwin->w_cursor.lnum == o_lnum)
          || curwin->w_curswant > curwin->w_virtcol)
-        && *(s->ptr = get_cursor_line_ptr() + curwin->w_cursor.col) != NUL) {
+        && *(s->ptr = (char_u *)get_cursor_line_ptr() + curwin->w_cursor.col) != NUL) {
       if (s->ptr[1] == NUL) {
         curwin->w_cursor.col++;
       } else {
@@ -1470,7 +1470,7 @@ static void init_prompt(int cmdchar_todo)
   char_u *text;
 
   curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
-  text = get_cursor_line_ptr();
+  text = (char_u *)get_cursor_line_ptr();
   if (STRNCMP(text, prompt, STRLEN(prompt)) != 0) {
     // prompt is missing, insert it or append a line with it
     if (*text == NUL) {
@@ -1544,7 +1544,7 @@ void display_dollar(colnr_T col)
   curwin->w_cursor.col = col;
 
   // If on the last byte of a multi-byte move to the first byte.
-  char_u *p = get_cursor_line_ptr();
+  char_u *p = (char_u *)get_cursor_line_ptr();
   curwin->w_cursor.col -= utf_head_off((char *)p, (char *)p + col);
   curs_columns(curwin, false);              // Recompute w_wrow and w_wcol
   if (curwin->w_wcol < curwin->w_grid.cols) {
@@ -1590,7 +1590,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 
   // MODE_VREPLACE state needs to know what the line was like before changing
   if (State & VREPLACE_FLAG) {
-    orig_line = vim_strsave(get_cursor_line_ptr());   // Deal with NULL below
+    orig_line = vim_strsave((char_u *)get_cursor_line_ptr());   // Deal with NULL below
     orig_col = curwin->w_cursor.col;
   }
 
@@ -1670,7 +1670,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 
     // Advance the cursor until we reach the right screen column.
     last_vcol = 0;
-    ptr = get_cursor_line_ptr();
+    ptr = (char_u *)get_cursor_line_ptr();
     chartabsize_T cts;
     init_chartabsize_arg(&cts, curwin, 0, 0, (char *)ptr, (char *)ptr);
     while (cts.cts_vcol <= (int)curwin->w_virtcol) {
@@ -1761,7 +1761,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   // then put it back again the way we wanted it.
   if (State & VREPLACE_FLAG) {
     // Save new line
-    new_line = vim_strsave(get_cursor_line_ptr());
+    new_line = vim_strsave((char_u *)get_cursor_line_ptr());
 
     // We only put back the new line up to the cursor
     new_line[curwin->w_cursor.col] = NUL;
@@ -2082,7 +2082,7 @@ void insertchar(int c, int flags, int second_indent)
 
     // Need to remove existing (middle) comment leader and insert end
     // comment leader.  First, check what comment leader we can find.
-    char_u *line = get_cursor_line_ptr();
+    char_u *line = (char_u *)get_cursor_line_ptr();
     int i = get_leader_len((char *)line, &p, false, true);
     if (i > 0 && vim_strchr(p, COM_MIDDLE) != NULL) {  // Just checking
       // Skip middle-comment string
@@ -2287,7 +2287,7 @@ int stop_arrow(void)
       // right, except when nothing was inserted yet.
       update_Insstart_orig = false;
     }
-    Insstart_textlen = (colnr_T)linetabsize(get_cursor_line_ptr());
+    Insstart_textlen = (colnr_T)linetabsize((char_u *)get_cursor_line_ptr());
 
     if (u_save_cursor() == OK) {
       arrow_used = false;
@@ -2484,7 +2484,7 @@ void beginline(int flags)
     if (flags & (BL_WHITE | BL_SOL)) {
       char_u *ptr;
 
-      for (ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr)
+      for (ptr = (char_u *)get_cursor_line_ptr(); ascii_iswhite(*ptr)
            && !((flags & BL_FIX) && ptr[1] == NUL); ptr++) {
         curwin->w_cursor.col++;
       }
@@ -2799,7 +2799,7 @@ static bool echeck_abbr(int c)
     return false;
   }
 
-  return check_abbr(c, get_cursor_line_ptr(), curwin->w_cursor.col,
+  return check_abbr(c, (char_u *)get_cursor_line_ptr(), curwin->w_cursor.col,
                     curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
 }
 
@@ -3148,7 +3148,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
       // cursor.
     } else if (*look == 'e') {
       if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4) {
-        p = get_cursor_line_ptr();
+        p = (char_u *)get_cursor_line_ptr();
         if ((char_u *)skipwhite((char *)p) == p + curwin->w_cursor.col - 4
             && STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0) {
           return true;
@@ -3161,12 +3161,12 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
       // class::method for C++).
     } else if (*look == ':') {
       if (try_match && keytyped == ':') {
-        p = get_cursor_line_ptr();
+        p = (char_u *)get_cursor_line_ptr();
         if (cin_iscase(p, false) || cin_isscopedecl(p) || cin_islabel()) {
           return true;
         }
         // Need to get the line again after cin_islabel().
-        p = get_cursor_line_ptr();
+        p = (char_u *)get_cursor_line_ptr();
         if (curwin->w_cursor.col > 2
             && p[curwin->w_cursor.col - 1] == ':'
             && p[curwin->w_cursor.col - 2] == ':') {
@@ -3174,7 +3174,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           const bool i = cin_iscase(p, false)
                          || cin_isscopedecl(p)
                          || cin_islabel();
-          p = get_cursor_line_ptr();
+          p = (char_u *)get_cursor_line_ptr();
           p[curwin->w_cursor.col - 1] = ':';
           if (i) {
             return true;
@@ -3226,7 +3226,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
 
           /* Just completed a word, check if it starts with "look".
            * search back for the start of a word. */
-          line = get_cursor_line_ptr();
+          line = (char_u *)get_cursor_line_ptr();
           for (s = line + curwin->w_cursor.col; s > line; s = n) {
             n = mb_prevptr(line, s);
             if (!vim_iswordp(n)) {
@@ -3805,7 +3805,7 @@ static void ins_shift(int c, int lastc)
     change_indent(c == Ctrl_D ? INDENT_DEC : INDENT_INC, 0, true, 0, true);
   }
 
-  if (did_ai && *skipwhite((char *)get_cursor_line_ptr()) != NUL) {
+  if (did_ai && *skipwhite(get_cursor_line_ptr()) != NUL) {
     did_ai = false;
   }
   did_si = false;
@@ -4609,7 +4609,7 @@ static bool ins_tab(void)
     if (State & VREPLACE_FLAG) {
       pos = curwin->w_cursor;
       cursor = &pos;
-      saved_line = vim_strsave(get_cursor_line_ptr());
+      saved_line = vim_strsave((char_u *)get_cursor_line_ptr());
       ptr = saved_line + pos.col;
     } else {
       ptr = get_cursor_pos_ptr();
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 8927e52349..06ee4c8d81 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2995,7 +2995,7 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
       *arg = bp;
     } else {
       // decimal, hex or octal number
-      vim_str2nr((char_u *)(*arg), NULL, &len, STR2NR_ALL, &n, NULL, 0, true);
+      vim_str2nr(*arg, NULL, &len, STR2NR_ALL, &n, NULL, 0, true);
       if (len == 0) {
         semsg(_(e_invexpr2), *arg);
         ret = FAIL;
@@ -6450,7 +6450,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
     } else {
       pos.lnum = curwin->w_cursor.lnum;
       if (charcol) {
-        pos.col = (colnr_T)mb_charlen(get_cursor_line_ptr());
+        pos.col = (colnr_T)mb_charlen((char_u *)get_cursor_line_ptr());
       } else {
         pos.col = (colnr_T)STRLEN(get_cursor_line_ptr());
       }
diff --git a/src/nvim/eval/decode.c b/src/nvim/eval/decode.c
index 7b975ce775..d585509df4 100644
--- a/src/nvim/eval/decode.c
+++ b/src/nvim/eval/decode.c
@@ -430,7 +430,7 @@ static inline int parse_json_string(const char *const buf, const size_t buf_len,
         const char ubuf[] = { t[1], t[2], t[3], t[4] };
         t += 4;
         uvarnumber_T ch;
-        vim_str2nr((char_u *)ubuf, NULL, NULL,
+        vim_str2nr(ubuf, NULL, NULL,
                    STR2NR_HEX | STR2NR_FORCE, NULL, &ch, 4, true);
         if (ch == 0) {
           hasnul = true;
@@ -600,7 +600,7 @@ parse_json_number_check:
     // Convert integer
     varnumber_T nr;
     int num_len;
-    vim_str2nr((char_u *)s, NULL, &num_len, 0, &nr, NULL, (int)(p - s), true);
+    vim_str2nr(s, NULL, &num_len, 0, &nr, NULL, (int)(p - s), true);
     if ((int)exp_num_len != num_len) {
       semsg(_("E685: internal error: while converting number \"%.*s\" "
               "to integer vim_str2nr consumed %i bytes in place of %zu"),
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 5a5293780d..60a6ec6201 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -5869,9 +5869,9 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   bool binary = false;
   bool blob = false;
   FILE *fd;
-  char_u buf[(IOSIZE/256) * 256];  // rounded to avoid odd + 1
+  char buf[(IOSIZE/256) * 256];    // rounded to avoid odd + 1
   int io_size = sizeof(buf);
-  char_u *prev = NULL;             // previously read bytes, if any
+  char *prev = NULL;               // previously read bytes, if any
   long prevlen  = 0;               // length of data in prev
   long prevsize = 0;               // size of prev buffer
   long maxline  = MAXLNUM;
@@ -5922,13 +5922,13 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     // - an incomplete line gets written
     // - a "binary" file gets an empty line at the end if it ends in a
     //   newline.
-    char_u *p;  // Position in buf.
-    char_u *start;  // Start of current line.
+    char *p;  // Position in buf.
+    char *start;  // Start of current line.
     for (p = buf, start = buf;
          p < buf + readlen || (readlen <= 0 && (prevlen > 0 || binary));
          p++) {
       if (*p == '\n' || readlen <= 0) {
-        char_u *s  = NULL;
+        char *s  = NULL;
         size_t len = (size_t)(p - start);
 
         // Finished a line.  Remove CRs before NL.
@@ -5945,7 +5945,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         }
         if (prevlen == 0) {
           assert(len < INT_MAX);
-          s = vim_strnsave(start, len);
+          s = xstrnsave(start, len);
         } else {
           // Change "prev" buffer to be the right size.  This way
           // the bytes are only copied once, and very long lines are
@@ -5960,7 +5960,7 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         tv_list_append_owned_tv(l, (typval_T) {
           .v_type = VAR_STRING,
           .v_lock = VAR_UNLOCKED,
-          .vval.v_string = (char *)s,
+          .vval.v_string = s,
         });
 
         start = p + 1;  // Step over newline.
@@ -5980,18 +5980,18 @@ static void f_readfile(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         *p = '\n';
         // Check for utf8 "bom"; U+FEFF is encoded as EF BB BF.  Do this
         // when finding the BF and check the previous two bytes.
-      } else if (*p == 0xbf && !binary) {
+      } else if ((uint8_t)(*p) == 0xbf && !binary) {
         // Find the two bytes before the 0xbf.  If p is at buf, or buf + 1,
         // these may be in the "prev" string.
-        char_u back1 = p >= buf + 1 ? p[-1]
+        char back1 = p >= buf + 1 ? p[-1]
                                     : prevlen >= 1 ? prev[prevlen - 1] : NUL;
-        char_u back2 = p >= buf + 2 ? p[-2]
+        char back2 = p >= buf + 2 ? p[-2]
                                     : p == buf + 1 && prevlen >= 1 ? prev[prevlen - 1]
                                                                    : prevlen >=
-                       2 ? prev[prevlen - 2] : NUL;
+                     2 ? prev[prevlen - 2] : NUL;
 
-        if (back2 == 0xef && back1 == 0xbb) {
-          char_u *dest = p - 2;
+        if ((uint8_t)back2 == 0xef && (uint8_t)back1 == 0xbb) {
+          char *dest = p - 2;
 
           // Usually a BOM is at the beginning of a file, and so at
           // the beginning of a line; then we can just step over it.
@@ -8304,7 +8304,7 @@ static void f_str2nr(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     break;
   }
   varnumber_T n;
-  vim_str2nr(p, NULL, NULL, what, &n, NULL, 0, false);
+  vim_str2nr((char *)p, NULL, NULL, what, &n, NULL, 0, false);
   // Text after the number is silently ignored.
   if (isneg) {
     rettv->vval.v_number = -n;
@@ -9416,10 +9416,10 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   char buf1[NUMBUFLEN];
   char buf2[NUMBUFLEN];
-  const char_u *head = (const char_u *)tv_get_string_buf_chk(&argvars[0], buf1);
-  const char_u *mask = NULL;
-  const char_u *prev;
-  const char_u *p;
+  const char *head = tv_get_string_buf_chk(&argvars[0], buf1);
+  const char *mask = NULL;
+  const char *prev;
+  const char *p;
   int dir = 0;
 
   rettv->v_type = VAR_STRING;
@@ -9434,7 +9434,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   if (argvars[1].v_type == VAR_STRING) {
-    mask = (const char_u *)tv_get_string_buf_chk(&argvars[1], buf2);
+    mask = tv_get_string_buf_chk(&argvars[1], buf2);
     if (argvars[2].v_type != VAR_UNKNOWN) {
       bool error = false;
       // leading or trailing characters to trim
@@ -9472,7 +9472,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     }
   }
 
-  const char_u *tail = head + STRLEN(head);
+  const char *tail = head + STRLEN(head);
   if (dir == 0 || dir == 2) {
     // Trim trailing characters
     for (; tail > head; tail = prev) {
@@ -9495,7 +9495,7 @@ static void f_trim(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       }
     }
   }
-  rettv->vval.v_string = (char *)vim_strnsave(head, (size_t)(tail - head));
+  rettv->vval.v_string = xstrnsave(head, (size_t)(tail - head));
 }
 
 /// "type(expr)" function
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index d5b2b1f2ae..a409271596 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -3717,8 +3717,7 @@ varnumber_T tv_get_number_chk(const typval_T *const tv, bool *const ret_error)
   case VAR_STRING: {
     varnumber_T n = 0;
     if (tv->vval.v_string != NULL) {
-      vim_str2nr((char_u *)tv->vval.v_string, NULL, NULL, STR2NR_ALL, &n, NULL, 0,
-                 false);
+      vim_str2nr(tv->vval.v_string, NULL, NULL, STR2NR_ALL, &n, NULL, 0, false);
     }
     return n;
   }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index bcaca0ca13..6611133ea4 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -525,22 +525,22 @@ static inline bool eval_fname_sid(const char *const name)
 ///
 /// @return transformed name: either `fname_buf` or a pointer to an allocated
 ///         memory.
-static char_u *fname_trans_sid(const char_u *const name, char_u *const fname_buf,
-                               char_u **const tofree, int *const error)
+static char *fname_trans_sid(const char *const name, char *const fname_buf, char **const tofree,
+                             int *const error)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  char_u *fname;
-  const int llen = eval_fname_script((const char *)name);
+  char *fname;
+  const int llen = eval_fname_script(name);
   if (llen > 0) {
-    fname_buf[0] = K_SPECIAL;
-    fname_buf[1] = KS_EXTRA;
+    fname_buf[0] = (char)K_SPECIAL;
+    fname_buf[1] = (char)KS_EXTRA;
     fname_buf[2] = KE_SNR;
     int i = 3;
-    if (eval_fname_sid((const char *)name)) {  // "<SID>" or "s:"
+    if (eval_fname_sid(name)) {  // "<SID>" or "s:"
       if (current_sctx.sc_sid <= 0) {
         *error = ERROR_SCRIPT;
       } else {
-        snprintf((char *)fname_buf + i, (size_t)(FLEN_FIXED + 1 - i), "%" PRId64 "_",
+        snprintf(fname_buf + i, (size_t)(FLEN_FIXED + 1 - i), "%" PRId64 "_",
                  (int64_t)current_sctx.sc_sid);
         i = (int)STRLEN(fname_buf);
       }
@@ -555,7 +555,7 @@ static char_u *fname_trans_sid(const char_u *const name, char_u *const fname_buf
       STRCPY(fname + i, name + llen);
     }
   } else {
-    fname = (char_u *)name;
+    fname = (char *)name;
   }
 
   return fname;
@@ -1437,10 +1437,10 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
   int ret = FAIL;
   int error = ERROR_NONE;
   ufunc_T *fp = NULL;
-  char_u fname_buf[FLEN_FIXED + 1];
-  char_u *tofree = NULL;
-  char_u *fname = NULL;
-  char_u *name = NULL;
+  char fname_buf[FLEN_FIXED + 1];
+  char *tofree = NULL;
+  char *fname = NULL;
+  char *name = NULL;
   int argcount = argcount_in;
   typval_T *argvars = argvars_in;
   dict_T *selfdict = funcexe->selfdict;
@@ -1463,8 +1463,8 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
   if (fp == NULL) {
     // Make a copy of the name, if it comes from a funcref variable it could
     // be changed or deleted in the called function.
-    name = vim_strnsave((char_u *)funcname, (size_t)len);
-    fname = fname_trans_sid(name, fname_buf, &tofree, &error);
+    name = xstrnsave(funcname, (size_t)len);
+    fname = fname_trans_sid(name, (char *)fname_buf, &tofree, &error);
   }
 
   if (funcexe->doesrange != NULL) {
@@ -1495,7 +1495,7 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
   }
 
   if (error == ERROR_NONE && funcexe->evaluate) {
-    char_u *rfname = fname;
+    char *rfname = fname;
 
     // Ignore "g:" before a function name.
     if (fp == NULL && fname[0] == 'g' && fname[1] == ':') {
@@ -1519,21 +1519,21 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
     } else if (fp != NULL || !builtin_function((const char *)rfname, -1)) {
       // User defined function.
       if (fp == NULL) {
-        fp = find_func(rfname);
+        fp = find_func((char_u *)rfname);
       }
 
       // Trigger FuncUndefined event, may load the function.
       if (fp == NULL
-          && apply_autocmds(EVENT_FUNCUNDEFINED, (char *)rfname, (char *)rfname, true, NULL)
+          && apply_autocmds(EVENT_FUNCUNDEFINED, rfname, rfname, true, NULL)
           && !aborting()) {
         // executed an autocommand, search for the function again
-        fp = find_func(rfname);
+        fp = find_func((char_u *)rfname);
       }
       // Try loading a package.
       if (fp == NULL && script_autoload((const char *)rfname, STRLEN(rfname),
                                         true) && !aborting()) {
         // Loaded a package, search for the function again.
-        fp = find_func(rfname);
+        fp = find_func((char_u *)rfname);
       }
 
       if (fp != NULL && (fp->uf_flags & FC_DELETED)) {
@@ -1570,11 +1570,11 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
     } else if (funcexe->basetv != NULL) {
       // expr->method(): Find the method name in the table, call its
       // implementation with the base as one of the arguments.
-      error = call_internal_method(fname, argcount, argvars, rettv,
+      error = call_internal_method((char_u *)fname, argcount, argvars, rettv,
                                    funcexe->basetv);
     } else {
       // Find the function name in the table, call its implementation.
-      error = call_internal_func(fname, argcount, argvars, rettv);
+      error = call_internal_func((char_u *)fname, argcount, argvars, rettv);
     }
     /*
      * The function call (or "FuncUndefined" autocommand sequence) might
@@ -1596,7 +1596,7 @@ theend:
   // Report an error unless the argument evaluation or function call has been
   // cancelled due to an aborting error, an interrupt, or an exception.
   if (!aborting()) {
-    user_func_error(error, (name != NULL) ? name : (char_u *)funcname);
+    user_func_error(error, (name != NULL) ? (char_u *)name : (char_u *)funcname);
   }
 
   // clear the copies made from the partial
@@ -1890,15 +1890,15 @@ theend:
 /// ":function"
 void ex_function(exarg_T *eap)
 {
-  char_u *theline;
-  char_u *line_to_free = NULL;
-  char_u c;
+  char *theline;
+  char *line_to_free = NULL;
+  char c;
   int saved_did_emsg;
   bool saved_wait_return = need_wait_return;
-  char_u *name = NULL;
-  char_u *p;
-  char_u *arg;
-  char_u *line_arg = NULL;
+  char *name = NULL;
+  char *p;
+  char *arg;
+  char *line_arg = NULL;
   garray_T newargs;
   garray_T default_args;
   garray_T newlines;
@@ -1918,8 +1918,8 @@ void ex_function(exarg_T *eap)
   linenr_T sourcing_lnum_off;
   linenr_T sourcing_lnum_top;
   bool is_heredoc = false;
-  char_u *skip_until = NULL;
-  char_u *heredoc_trimmed = NULL;
+  char *skip_until = NULL;
+  char *heredoc_trimmed = NULL;
   bool show_block = false;
   bool do_concat = true;
 
@@ -1950,7 +1950,7 @@ void ex_function(exarg_T *eap)
    * ":function /pat": list functions matching pattern.
    */
   if (*eap->arg == '/') {
-    p = (char_u *)skip_regexp(eap->arg + 1, '/', true, NULL);
+    p = skip_regexp(eap->arg + 1, '/', true, NULL);
     if (!eap->skip) {
       regmatch_T regmatch;
 
@@ -1978,7 +1978,7 @@ void ex_function(exarg_T *eap)
     if (*p == '/') {
       p++;
     }
-    eap->nextcmd = check_nextcmd((char *)p);
+    eap->nextcmd = check_nextcmd(p);
     return;
   }
 
@@ -1996,9 +1996,9 @@ void ex_function(exarg_T *eap)
   //             "fudi.fd_di" set, "fudi.fd_newkey" == NULL
   // s:func      script-local function name
   // g:func      global function name, same as "func"
-  p = (char_u *)eap->arg;
-  name = trans_function_name((char **)&p, eap->skip, TFN_NO_AUTOLOAD, &fudi, NULL);
-  paren = (vim_strchr((char *)p, '(') != NULL);
+  p = eap->arg;
+  name = (char *)trans_function_name(&p, eap->skip, TFN_NO_AUTOLOAD, &fudi, NULL);
+  paren = (vim_strchr(p, '(') != NULL);
   if (name == NULL && (fudi.fd_dict == NULL || !paren) && !eap->skip) {
     /*
      * Return on an invalid expression in braces, unless the expression
@@ -2028,16 +2028,16 @@ void ex_function(exarg_T *eap)
   //  - exclude line numbers from function body
   //
   if (!paren) {
-    if (!ends_excmd(*skipwhite((char *)p))) {
+    if (!ends_excmd(*skipwhite(p))) {
       semsg(_(e_trailing_arg), p);
       goto ret_free;
     }
-    eap->nextcmd = check_nextcmd((char *)p);
+    eap->nextcmd = check_nextcmd(p);
     if (eap->nextcmd != NULL) {
       *p = NUL;
     }
     if (!eap->skip && !got_int) {
-      fp = find_func(name);
+      fp = find_func((char_u *)name);
       if (fp != NULL) {
         list_func_head(fp, !eap->forceit, eap->forceit);
         for (int j = 0; j < fp->uf_lines.ga_len && !got_int; j++) {
@@ -2063,7 +2063,7 @@ void ex_function(exarg_T *eap)
           msg_puts(eap->forceit ? "endfunction" : "   endfunction");
         }
       } else {
-        emsg_funcname(N_("E123: Undefined function: %s"), name);
+        emsg_funcname(N_("E123: Undefined function: %s"), (char_u *)name);
       }
     }
     goto ret_free;
@@ -2072,18 +2072,18 @@ void ex_function(exarg_T *eap)
   /*
    * ":function name(arg1, arg2)" Define function.
    */
-  p = (char_u *)skipwhite((char *)p);
+  p = skipwhite(p);
   if (*p != '(') {
     if (!eap->skip) {
       semsg(_("E124: Missing '(': %s"), eap->arg);
       goto ret_free;
     }
     // attempt to continue by skipping some text
-    if (vim_strchr((char *)p, '(') != NULL) {
-      p = (char_u *)vim_strchr((char *)p, '(');
+    if (vim_strchr(p, '(') != NULL) {
+      p = vim_strchr(p, '(');
     }
   }
-  p = (char_u *)skipwhite((char *)p + 1);
+  p = skipwhite(p + 1);
 
   ga_init(&newargs, (int)sizeof(char_u *), 3);
   ga_init(&newlines, (int)sizeof(char_u *), 3);
@@ -2094,15 +2094,15 @@ void ex_function(exarg_T *eap)
     if (name != NULL) {
       arg = name;
     } else {
-      arg = fudi.fd_newkey;
+      arg = (char *)fudi.fd_newkey;
     }
     if (arg != NULL && (fudi.fd_di == NULL || !tv_is_func(fudi.fd_di->di_tv))) {
-      int j = (*arg == K_SPECIAL) ? 3 : 0;
+      int j = ((uint8_t)(*arg) == K_SPECIAL) ? 3 : 0;
       while (arg[j] != NUL && (j == 0 ? eval_isnamec1(arg[j]) : eval_isnamec(arg[j]))) {
         j++;
       }
       if (arg[j] != NUL) {
-        emsg_funcname((char *)e_invarg2, arg);
+        emsg_funcname((char *)e_invarg2, (char_u *)arg);
       }
     }
     // Disallow using the g: dict.
@@ -2111,7 +2111,7 @@ void ex_function(exarg_T *eap)
     }
   }
 
-  if (get_function_args((char **)&p, ')', &newargs, &varargs,
+  if (get_function_args(&p, ')', &newargs, &varargs,
                         &default_args, eap->skip) == FAIL) {
     goto errret_2;
   }
@@ -2123,7 +2123,7 @@ void ex_function(exarg_T *eap)
 
   // find extra arguments "range", "dict", "abort" and "closure"
   for (;;) {
-    p = (char_u *)skipwhite((char *)p);
+    p = skipwhite(p);
     if (STRNCMP(p, "range", 5) == 0) {
       flags |= FC_RANGE;
       p += 5;
@@ -2137,9 +2137,8 @@ void ex_function(exarg_T *eap)
       flags |= FC_CLOSURE;
       p += 7;
       if (current_funccal == NULL) {
-        emsg_funcname(N_
-                        ("E932: Closure function should not be at top level: %s"),
-                      name == NULL ? (char_u *)"" : name);
+        emsg_funcname(N_("E932: Closure function should not be at top level: %s"),
+                      name == NULL ? (char_u *)"" : (char_u *)name);
         goto erret;
       }
     } else {
@@ -2165,8 +2164,8 @@ void ex_function(exarg_T *eap)
     if (!eap->skip && !eap->forceit) {
       if (fudi.fd_dict != NULL && fudi.fd_newkey == NULL) {
         emsg(_(e_funcdict));
-      } else if (name != NULL && find_func(name) != NULL) {
-        emsg_funcname(e_funcexts, name);
+      } else if (name != NULL && find_func((char_u *)name) != NULL) {
+        emsg_funcname(e_funcexts, (char_u *)name);
       }
     }
 
@@ -2195,7 +2194,7 @@ void ex_function(exarg_T *eap)
     if (line_arg != NULL) {
       // Use eap->arg, split up in parts by line breaks.
       theline = line_arg;
-      p = (char_u *)vim_strchr((char *)theline, '\n');
+      p = vim_strchr(theline, '\n');
       if (p == NULL) {
         line_arg += STRLEN(line_arg);
       } else {
@@ -2205,9 +2204,9 @@ void ex_function(exarg_T *eap)
     } else {
       xfree(line_to_free);
       if (eap->getline == NULL) {
-        theline = getcmdline(':', 0L, indent, do_concat);
+        theline = (char *)getcmdline(':', 0L, indent, do_concat);
       } else {
-        theline = (char_u *)eap->getline(':', eap->cookie, indent, do_concat);
+        theline = eap->getline(':', eap->cookie, indent, do_concat);
       }
       line_to_free = theline;
     }
@@ -2237,13 +2236,13 @@ void ex_function(exarg_T *eap)
       // * ":python <<EOF" and "EOF"
       // * ":let {var-name} =<< [trim] {marker}" and "{marker}"
       if (heredoc_trimmed == NULL
-          || (is_heredoc && (char_u *)skipwhite((char *)theline) == theline)
+          || (is_heredoc && skipwhite(theline) == theline)
           || STRNCMP(theline, heredoc_trimmed,
                      STRLEN(heredoc_trimmed)) == 0) {
         if (heredoc_trimmed == NULL) {
           p = theline;
         } else if (is_heredoc) {
-          p = (char_u *)skipwhite((char *)theline) == theline
+          p = skipwhite(theline) == theline
             ? theline : theline + STRLEN(heredoc_trimmed);
         } else {
           p = theline + STRLEN(heredoc_trimmed);
@@ -2260,27 +2259,26 @@ void ex_function(exarg_T *eap)
       for (p = theline; ascii_iswhite(*p) || *p == ':'; p++) {}
 
       // Check for "endfunction".
-      if (checkforcmd((char **)&p, "endfunction", 4) && nesting-- == 0) {
+      if (checkforcmd(&p, "endfunction", 4) && nesting-- == 0) {
         if (*p == '!') {
           p++;
         }
-        char_u *nextcmd = NULL;
+        char *nextcmd = NULL;
         if (*p == '|') {
           nextcmd = p + 1;
-        } else if (line_arg != NULL && *skipwhite((char *)line_arg) != NUL) {
+        } else if (line_arg != NULL && *skipwhite(line_arg) != NUL) {
           nextcmd = line_arg;
         } else if (*p != NUL && *p != '"' && p_verbose > 0) {
-          give_warning2(_("W22: Text found after :endfunction: %s"),
-                        (char *)p, true);
+          give_warning2(_("W22: Text found after :endfunction: %s"), p, true);
         }
         if (nextcmd != NULL) {
           // Another command follows. If the line came from "eap" we
           // can simply point into it, otherwise we need to change
           // "eap->cmdlinep".
-          eap->nextcmd = (char *)nextcmd;
+          eap->nextcmd = nextcmd;
           if (line_to_free != NULL) {
             xfree(*eap->cmdlinep);
-            *eap->cmdlinep = (char *)line_to_free;
+            *eap->cmdlinep = line_to_free;
             line_to_free = NULL;
           }
         }
@@ -2299,13 +2297,13 @@ void ex_function(exarg_T *eap)
       }
 
       // Check for defining a function inside this function.
-      if (checkforcmd((char **)&p, "function", 2)) {
+      if (checkforcmd(&p, "function", 2)) {
         if (*p == '!') {
-          p = (char_u *)skipwhite((char *)p + 1);
+          p = skipwhite(p + 1);
         }
         p += eval_fname_script((const char *)p);
-        xfree(trans_function_name((char **)&p, true, 0, NULL, NULL));
-        if (*skipwhite((char *)p) == '(') {
+        xfree(trans_function_name(&p, true, 0, NULL, NULL));
+        if (*skipwhite(p) == '(') {
           if (nesting == MAX_FUNC_NESTING - 1) {
             emsg(_("E1058: function nesting too deep"));
           } else {
@@ -2316,7 +2314,7 @@ void ex_function(exarg_T *eap)
       }
 
       // Check for ":append", ":change", ":insert".
-      p = (char_u *)skip_range((char *)p, NULL);
+      p = skip_range(p, NULL);
       if ((p[0] == 'a' && (!ASCII_ISALPHA(p[1]) || p[1] == 'p'))
           || (p[0] == 'c'
               && (!ASCII_ISALPHA(p[1])
@@ -2328,11 +2326,11 @@ void ex_function(exarg_T *eap)
               && (!ASCII_ISALPHA(p[1]) || (p[1] == 'n'
                                            && (!ASCII_ISALPHA(p[2])
                                                || (p[2] == 's')))))) {
-        skip_until = vim_strsave((char_u *)".");
+        skip_until = xstrdup(".");
       }
 
       // heredoc: Check for ":python <<EOF", ":lua <<EOF", etc.
-      arg = (char_u *)skipwhite(skiptowhite((char *)p));
+      arg = skipwhite(skiptowhite(p));
       if (arg[0] == '<' && arg[1] == '<'
           && ((p[0] == 'p' && p[1] == 'y'
                && (!ASCII_ISALNUM(p[2]) || p[2] == 't'
@@ -2349,22 +2347,22 @@ void ex_function(exarg_T *eap)
               || (p[0] == 'm' && p[1] == 'z'
                   && (!ASCII_ISALPHA(p[2]) || p[2] == 's')))) {
         // ":python <<" continues until a dot, like ":append"
-        p = (char_u *)skipwhite((char *)arg + 2);
+        p = skipwhite(arg + 2);
         if (*p == NUL) {
-          skip_until = vim_strsave((char_u *)".");
+          skip_until = xstrdup(".");
         } else {
-          skip_until = vim_strsave(p);
+          skip_until = xstrdup(p);
         }
       }
 
       // Check for ":let v =<< [trim] EOF"
       //       and ":let [a, b] =<< [trim] EOF"
-      arg = (char_u *)skipwhite(skiptowhite((char *)p));
+      arg = skipwhite(skiptowhite(p));
       if (*arg == '[') {
-        arg = (char_u *)vim_strchr((char *)arg, ']');
+        arg = vim_strchr(arg, ']');
       }
       if (arg != NULL) {
-        arg = (char_u *)skipwhite(skiptowhite((char *)arg));
+        arg = skipwhite(skiptowhite(arg));
         if (arg[0] == '='
             && arg[1] == '<'
             && arg[2] == '<'
@@ -2372,14 +2370,13 @@ void ex_function(exarg_T *eap)
                 && p[1] == 'e'
                 && (!ASCII_ISALNUM(p[2])
                     || (p[2] == 't' && !ASCII_ISALNUM(p[3]))))) {
-          p = (char_u *)skipwhite((char *)arg + 3);
+          p = skipwhite(arg + 3);
           if (STRNCMP(p, "trim", 4) == 0) {
             // Ignore leading white space.
-            p = (char_u *)skipwhite((char *)p + 4);
-            heredoc_trimmed =
-              vim_strnsave(theline, (size_t)((char_u *)skipwhite((char *)theline) - theline));
+            p = skipwhite(p + 4);
+            heredoc_trimmed = xstrnsave(theline, (size_t)(skipwhite(theline) - theline));
           }
-          skip_until = vim_strnsave(p, (size_t)((char_u *)skiptowhite((char *)p) - p));
+          skip_until = xstrnsave(p, (size_t)(skiptowhite(p) - p));
           do_concat = false;
           is_heredoc = true;
         }
@@ -2392,8 +2389,8 @@ void ex_function(exarg_T *eap)
     // Copy the line to newly allocated memory.  get_one_sourceline()
     // allocates 250 bytes per line, this saves 80% on average.  The cost
     // is an extra alloc/free.
-    p = vim_strsave(theline);
-    ((char **)(newlines.ga_data))[newlines.ga_len++] = (char *)p;
+    p = xstrdup(theline);
+    ((char **)(newlines.ga_data))[newlines.ga_len++] = p;
 
     // Add NULL lines for continuation lines, so that the line count is
     // equal to the index in the growarray.
@@ -2420,23 +2417,23 @@ void ex_function(exarg_T *eap)
     v = find_var((const char *)name, STRLEN(name), &ht, false);
     if (v != NULL && v->di_tv.v_type == VAR_FUNC) {
       emsg_funcname(N_("E707: Function name conflicts with variable: %s"),
-                    name);
+                    (char_u *)name);
       goto erret;
     }
 
-    fp = find_func(name);
+    fp = find_func((char_u *)name);
     if (fp != NULL) {
       // Function can be replaced with "function!" and when sourcing the
       // same script again, but only once.
       if (!eap->forceit
           && (fp->uf_script_ctx.sc_sid != current_sctx.sc_sid
               || fp->uf_script_ctx.sc_seq == current_sctx.sc_seq)) {
-        emsg_funcname(e_funcexts, name);
+        emsg_funcname(e_funcexts, (char_u *)name);
         goto erret;
       }
       if (fp->uf_calls > 0) {
         emsg_funcname(N_("E127: Cannot redefine function %s: It is in use"),
-                      name);
+                      (char_u *)name);
         goto erret;
       }
       if (fp->uf_refcount > 1) {
@@ -2480,12 +2477,12 @@ void ex_function(exarg_T *eap)
     // Give the function a sequential number.  Can only be used with a
     // Funcref!
     xfree(name);
-    sprintf(numbuf, "%d", ++func_nr);
-    name = vim_strsave((char_u *)numbuf);
+    sprintf(numbuf, "%d", ++func_nr);  // NOLINT(runtime/printf)
+    name = xstrdup(numbuf);
   }
 
   if (fp == NULL) {
-    if (fudi.fd_dict == NULL && vim_strchr((char *)name, AUTOLOAD_CHAR) != NULL) {
+    if (fudi.fd_dict == NULL && vim_strchr(name, AUTOLOAD_CHAR) != NULL) {
       int slen, plen;
       char_u *scriptname;
 
@@ -2493,7 +2490,7 @@ void ex_function(exarg_T *eap)
       int j = FAIL;
       if (SOURCING_NAME != NULL) {
         scriptname = (char_u *)autoload_name((const char *)name, STRLEN(name));
-        p = (char_u *)vim_strchr((char *)scriptname, '/');
+        p = vim_strchr((char *)scriptname, '/');
         plen = (int)STRLEN(p);
         slen = (int)STRLEN(SOURCING_NAME);
         if (slen > plen && FNAMECMP(p, SOURCING_NAME + slen - plen) == 0) {
@@ -2524,16 +2521,16 @@ void ex_function(exarg_T *eap)
         tv_clear(&fudi.fd_di->di_tv);
       }
       fudi.fd_di->di_tv.v_type = VAR_FUNC;
-      fudi.fd_di->di_tv.vval.v_string = (char *)vim_strsave(name);
+      fudi.fd_di->di_tv.vval.v_string = xstrdup(name);
 
       // behave like "dict" was used
       flags |= FC_DICT;
     }
 
     // insert the new function in the function list
-    set_ufunc_name(fp, name);
+    set_ufunc_name(fp, (char_u *)name);
     if (overwrite) {
-      hi = hash_find(&func_hashtab, (char *)name);
+      hi = hash_find(&func_hashtab, name);
       hi->hi_key = UF2HIKEY(fp);
     } else if (hash_add(&func_hashtab, UF2HIKEY(fp)) == FAIL) {
       xfree(fp);
@@ -3213,7 +3210,7 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
                                       ? (char_u *)rettv->vval.v_string
                                       : rettv->vval.v_partial->pt_name;
     // Translate "s:func" to the stored function name.
-    fname = fname_trans_sid(fname, fname_buf, &tofree, &error);
+    fname = (char_u *)fname_trans_sid((char *)fname, (char *)fname_buf, (char **)&tofree, &error);
     fp = find_func(fname);
     xfree(tofree);
   }
@@ -3559,7 +3556,7 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
   }
 
   if (fp_in == NULL) {
-    fname = fname_trans_sid(name, fname_buf, &tofree, &error);
+    fname = (char_u *)fname_trans_sid((char *)name, (char *)fname_buf, (char **)&tofree, &error);
     fp = find_func(fname);
   }
   if (fp != NULL) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index db79187b7d..126129b24d 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -330,7 +330,7 @@ static int linelen(int *has_tab)
 
   // Get the line.  If it's empty bail out early (could be the empty string
   // for an unloaded buffer).
-  line = (char *)get_cursor_line_ptr();
+  line = get_cursor_line_ptr();
   if (*line == NUL) {
     return 0;
   }
@@ -601,7 +601,7 @@ void ex_sort(exarg_T *eap)
           nrs[lnum - eap->line1].st_u.num.value = 0;
         } else {
           nrs[lnum - eap->line1].st_u.num.is_number = true;
-          vim_str2nr((char_u *)s, NULL, NULL, sort_what,
+          vim_str2nr(s, NULL, NULL, sort_what,
                      &nrs[lnum - eap->line1].st_u.num.value, NULL, 0, false);
         }
       } else {
@@ -2808,7 +2808,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     // keep it.  Also when it moves within a line. But not when it moves
     // to the first non-blank.
     if (!equalpos(curwin->w_cursor, orig_pos)) {
-      const char *text = (char *)get_cursor_line_ptr();
+      const char *text = get_cursor_line_ptr();
 
       if (curwin->w_cursor.lnum != orig_pos.lnum
           || curwin->w_cursor.col != (int)(skipwhite(text) - text)) {
@@ -3354,7 +3354,7 @@ static bool sub_joining_lines(exarg_T *eap, char *pat, char *sub, char *cmd, boo
         save_re_pat(RE_SUBST, (char_u *)pat, p_magic);
       }
       // put pattern in history
-      add_to_history(HIST_SEARCH, (char_u *)pat, true, NUL);
+      add_to_history(HIST_SEARCH, pat, true, NUL);
     }
 
     return true;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 0af737ff50..8ef7903db5 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3689,7 +3689,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
   // Decide to expand wildcards *before* replacing '%', '#', etc.  If
   // the file name contains a wildcard it should not cause expanding.
   // (it will be expanded anyway if there is a wildcard before replacing).
-  int has_wildcards = path_has_wildcard((char_u *)p);
+  int has_wildcards = path_has_wildcard(p);
   while (*p != NUL) {
     // Skip over `=expr`, wildcards in it are not expanded.
     if (p[0] == '`' && p[1] == '=') {
@@ -3794,7 +3794,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
       if (vim_strchr(eap->arg, '$') != NULL
           || vim_strchr(eap->arg, '~') != NULL) {
         expand_env_esc((char_u *)eap->arg, (char_u *)NameBuff, MAXPATHL, true, true, NULL);
-        has_wildcards = path_has_wildcard((char_u *)NameBuff);
+        has_wildcards = path_has_wildcard(NameBuff);
         p = (char *)NameBuff;
       } else {
         p = NULL;
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 9d1cebd43e..2112385533 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -255,7 +255,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
   exarg_T ea = {
     .line1 = 1,
     .line2 = 1,
-    .cmd = (char *)ccline.cmdbuff,
+    .cmd = ccline.cmdbuff,
     .addr_type = ADDR_LINES,
   };
 
@@ -336,7 +336,7 @@ static bool do_incsearch_highlighting(int firstc, int *search_delim, incsearch_s
   }
 
   // found a non-empty pattern or //
-  *skiplen = (int)((char_u *)p - ccline.cmdbuff);
+  *skiplen = (int)(p - ccline.cmdbuff);
   *patlen = (int)(end - p);
 
   // parse the address range
@@ -409,7 +409,7 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
   int found;  // do_search() result
 
   // Use the previous pattern for ":s//".
-  next_char = ccline.cmdbuff[skiplen + patlen];
+  next_char = (char_u)ccline.cmdbuff[skiplen + patlen];
   use_last_pat = patlen == 0 && skiplen > 0
                  && ccline.cmdbuff[skiplen - 1] == next_char;
 
@@ -436,9 +436,9 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
       .sa_tm = &tm,
     };
     found = do_search(NULL, firstc == ':' ? '/' : firstc, search_delim,
-                      ccline.cmdbuff + skiplen, count,
+                      (char_u *)ccline.cmdbuff + skiplen, count,
                       search_flags, &sia);
-    ccline.cmdbuff[skiplen + patlen] = next_char;
+    ccline.cmdbuff[skiplen + patlen] = (char)next_char;
     emsg_off--;
     if (curwin->w_cursor.lnum < search_first_line
         || curwin->w_cursor.lnum > search_last_line) {
@@ -487,13 +487,13 @@ static void may_do_incsearch_highlighting(int firstc, long count, incsearch_stat
   // Disable 'hlsearch' highlighting if the pattern matches
   // everything. Avoids a flash when typing "foo\|".
   if (!use_last_pat) {
-    next_char = ccline.cmdbuff[skiplen + patlen];
+    next_char = (char_u)ccline.cmdbuff[skiplen + patlen];
     ccline.cmdbuff[skiplen + patlen] = NUL;
-    if (empty_pattern((char *)ccline.cmdbuff) && !no_hlsearch) {
+    if (empty_pattern(ccline.cmdbuff) && !no_hlsearch) {
       redraw_all_later(UPD_SOME_VALID);
       set_no_hlsearch(true);
     }
-    ccline.cmdbuff[skiplen + patlen] = next_char;
+    ccline.cmdbuff[skiplen + patlen] = (char)next_char;
   }
 
   validate_cursor();
@@ -548,7 +548,7 @@ static int may_add_char_to_search(int firstc, int *c, incsearch_state_T *s)
       // command line has no uppercase characters, convert
       // the character to lowercase
       if (p_ic && p_scs
-          && !pat_has_uppercase(ccline.cmdbuff + skiplen)) {
+          && !pat_has_uppercase((char_u *)ccline.cmdbuff + skiplen)) {
         *c = mb_tolower(*c);
       }
       if (*c == search_delim
@@ -724,7 +724,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
 
   if (ccline.input_fn) {
     s->xpc.xp_context = ccline.xp_context;
-    s->xpc.xp_pattern = (char *)ccline.cmdbuff;
+    s->xpc.xp_pattern = ccline.cmdbuff;
     s->xpc.xp_arg = (char *)ccline.xp_arg;
   }
 
@@ -854,7 +854,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
                      s->histype == HIST_SEARCH ? s->firstc : NUL);
       if (s->firstc == ':') {
         xfree(new_last_cmdline);
-        new_last_cmdline = (char *)vim_strsave(ccline.cmdbuff);
+        new_last_cmdline = xstrdup(ccline.cmdbuff);
       }
     }
 
@@ -897,7 +897,7 @@ theend:
   xfree(ccline.last_colors.cmdbuff);
   kv_destroy(ccline.last_colors.colors);
 
-  char_u *p = ccline.cmdbuff;
+  char_u *p = (char_u *)ccline.cmdbuff;
 
   if (ui_has(kUICmdline)) {
     ui_call_cmdline_hide(ccline.level);
@@ -1339,7 +1339,7 @@ static int may_do_command_line_next_incsearch(int firstc, long count, incsearch_
     skiplen = 0;
     patlen = (int)STRLEN(pat);
   } else {
-    pat = ccline.cmdbuff + skiplen;
+    pat = (char_u *)ccline.cmdbuff + skiplen;
   }
 
   if (next_match) {
@@ -1483,24 +1483,24 @@ static int command_line_handle_key(CommandLineState *s)
     }
 
     if (s->c == K_DEL) {
-      ccline.cmdpos += mb_off_next(ccline.cmdbuff,
-                                   ccline.cmdbuff + ccline.cmdpos);
+      ccline.cmdpos += mb_off_next((char_u *)ccline.cmdbuff,
+                                   (char_u *)ccline.cmdbuff + ccline.cmdpos);
     }
 
     if (ccline.cmdpos > 0) {
       char_u *p;
 
       int j = ccline.cmdpos;
-      p = mb_prevptr(ccline.cmdbuff, ccline.cmdbuff + j);
+      p = mb_prevptr((char_u *)ccline.cmdbuff, (char_u *)ccline.cmdbuff + j);
 
       if (s->c == Ctrl_W) {
-        while (p > ccline.cmdbuff && ascii_isspace(*p)) {
-          p = mb_prevptr(ccline.cmdbuff, p);
+        while (p > (char_u *)ccline.cmdbuff && ascii_isspace(*p)) {
+          p = mb_prevptr((char_u *)ccline.cmdbuff, p);
         }
 
         int i = mb_get_class(p);
-        while (p > ccline.cmdbuff && mb_get_class(p) == i) {
-          p = mb_prevptr(ccline.cmdbuff, p);
+        while (p > (char_u *)ccline.cmdbuff && mb_get_class(p) == i) {
+          p = mb_prevptr((char_u *)ccline.cmdbuff, p);
         }
 
         if (mb_get_class(p) != i) {
@@ -1508,7 +1508,7 @@ static int command_line_handle_key(CommandLineState *s)
         }
       }
 
-      ccline.cmdpos = (int)(p - ccline.cmdbuff);
+      ccline.cmdpos = (int)(p - (char_u *)ccline.cmdbuff);
       ccline.cmdlen -= j - ccline.cmdpos;
       int i = ccline.cmdpos;
 
@@ -1688,7 +1688,7 @@ static int command_line_handle_key(CommandLineState *s)
       }
 
       ccline.cmdspos += cells;
-      ccline.cmdpos += utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos);
+      ccline.cmdpos += utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos);
     } while ((s->c == K_S_RIGHT || s->c == K_C_RIGHT
               || (mod_mask & (MOD_MASK_SHIFT|MOD_MASK_CTRL)))
              && ccline.cmdbuff[ccline.cmdpos] != ' ');
@@ -1704,8 +1704,8 @@ static int command_line_handle_key(CommandLineState *s)
     do {
       ccline.cmdpos--;
       // Move to first byte of possibly multibyte char.
-      ccline.cmdpos -= utf_head_off((char *)ccline.cmdbuff,
-                                    (char *)ccline.cmdbuff + ccline.cmdpos);
+      ccline.cmdpos -= utf_head_off(ccline.cmdbuff,
+                                    ccline.cmdbuff + ccline.cmdpos);
       ccline.cmdspos -= cmdline_charsize(ccline.cmdpos);
     } while (ccline.cmdpos > 0
              && (s->c == K_S_LEFT || s->c == K_C_LEFT
@@ -1761,7 +1761,7 @@ static int command_line_handle_key(CommandLineState *s)
 
       // Count ">" for double-wide char that doesn't fit.
       correct_screencol(ccline.cmdpos, cells, &ccline.cmdspos);
-      ccline.cmdpos += utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos) - 1;
+      ccline.cmdpos += utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos) - 1;
       ccline.cmdspos += cells;
     }
     return command_line_not_changed(s);
@@ -1855,7 +1855,7 @@ static int command_line_handle_key(CommandLineState *s)
 
     // save current command string so it can be restored later
     if (s->lookfor == NULL) {
-      s->lookfor = vim_strsave(ccline.cmdbuff);
+      s->lookfor = vim_strsave((char_u *)ccline.cmdbuff);
       s->lookfor[ccline.cmdpos] = NUL;
     }
 
@@ -1874,7 +1874,7 @@ static int command_line_handle_key(CommandLineState *s)
       if (s->hiscnt == get_hislen()) {
         p = s->lookfor;                  // back to the old one
       } else {
-        p = get_histentry(s->histype)[s->hiscnt].hisstr;
+        p = (char_u *)get_histentry(s->histype)[s->hiscnt].hisstr;
       }
 
       if (s->histype == HIST_SEARCH
@@ -1892,7 +1892,7 @@ static int command_line_handle_key(CommandLineState *s)
             if (p[j] == old_firstc
                 && (j == 0 || p[j - 1] != '\\')) {
               if (i > 0) {
-                ccline.cmdbuff[len] = (char_u)s->firstc;
+                ccline.cmdbuff[len] = (char)s->firstc;
               }
             } else {
               // Escape new sep, unless it is already
@@ -1906,7 +1906,7 @@ static int command_line_handle_key(CommandLineState *s)
               }
 
               if (i > 0) {
-                ccline.cmdbuff[len] = p[j];
+                ccline.cmdbuff[len] = (char)p[j];
               }
             }
             len++;
@@ -2281,7 +2281,7 @@ static bool cmdpreview_may_show(CommandLineState *s)
   CmdParseInfo cmdinfo;
   // Copy the command line so we can modify it.
   int cmdpreview_type = 0;
-  char *cmdline = xstrdup((char *)ccline.cmdbuff);
+  char *cmdline = xstrdup(ccline.cmdbuff);
   char *errormsg = NULL;
   emsg_off++;  // Block errors when parsing the command line, and don't update v:errmsg
   if (!parse_cmdline(cmdline, &ea, &cmdinfo, &errormsg)) {
@@ -2659,7 +2659,7 @@ static int cmdline_charsize(int idx)
   if (cmdline_star > 0) {           // showing '*', always 1 position
     return 1;
   }
-  return ptr2cells((char *)ccline.cmdbuff + idx);
+  return ptr2cells(ccline.cmdbuff + idx);
 }
 
 /// Compute the offset of the cursor on the command line for the prompt and
@@ -2685,7 +2685,7 @@ int cmd_screencol(int bytepos)
   }
 
   for (int i = 0; i < ccline.cmdlen && i < bytepos;
-       i += utfc_ptr2len((char *)ccline.cmdbuff + i)) {
+       i += utfc_ptr2len(ccline.cmdbuff + i)) {
     int c = cmdline_charsize(i);
     // Count ">" for double-wide multi-byte char that doesn't fit.
     correct_screencol(i, c, &col);
@@ -2704,8 +2704,8 @@ int cmd_screencol(int bytepos)
 /// character that doesn't fit, so that a ">" must be displayed.
 static void correct_screencol(int idx, int cells, int *col)
 {
-  if (utfc_ptr2len((char *)ccline.cmdbuff + idx) > 1
-      && utf_ptr2cells((char *)ccline.cmdbuff + idx) > 1
+  if (utfc_ptr2len(ccline.cmdbuff + idx) > 1
+      && utf_ptr2cells(ccline.cmdbuff + idx) > 1
       && (*col) % Columns + cells > Columns) {
     (*col)++;
   }
@@ -2764,7 +2764,7 @@ void realloc_cmdbuff(int len)
     return;  // no need to resize
   }
 
-  char_u *p = ccline.cmdbuff;
+  char_u *p = (char_u *)ccline.cmdbuff;
   alloc_cmdbuff(len);                   // will get some more
   // There isn't always a NUL after the command, but it may need to be
   // there, thus copy up to the NUL and add a NUL.
@@ -2781,7 +2781,7 @@ void realloc_cmdbuff(int len)
     // If xp_pattern points inside the old cmdbuff it needs to be adjusted
     // to point into the newly allocated memory.
     if (i >= 0 && i <= ccline.cmdlen) {
-      ccline.xpc->xp_pattern = (char *)ccline.cmdbuff + i;
+      ccline.xpc->xp_pattern = ccline.cmdbuff + i;
     }
   }
 }
@@ -2904,7 +2904,7 @@ static bool color_cmdline(CmdlineInfo *colored_ccline)
   bool arg_allocated = false;
   typval_T arg = {
     .v_type = VAR_STRING,
-    .vval.v_string = (char *)colored_ccline->cmdbuff,
+    .vval.v_string = colored_ccline->cmdbuff,
   };
   typval_T tv = { .v_type = VAR_UNKNOWN };
 
@@ -3107,16 +3107,16 @@ static void draw_cmdline(int start, int len)
   if (cmdline_star > 0) {
     for (int i = 0; i < len; i++) {
       msg_putchar('*');
-      i += utfc_ptr2len((char *)ccline.cmdbuff + start + i) - 1;
+      i += utfc_ptr2len(ccline.cmdbuff + start + i) - 1;
     }
   } else if (p_arshape && !p_tbidi && len > 0) {
     bool do_arabicshape = false;
     int mb_l;
     for (int i = start; i < start + len; i += mb_l) {
-      char_u *p = ccline.cmdbuff + i;
+      char_u *p = (char_u *)ccline.cmdbuff + i;
       int u8cc[MAX_MCO];
       int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
-      mb_l = utfc_ptr2len_len(p, start + len - i);
+      mb_l = utfc_ptr2len_len((char *)p, start + len - i);
       if (ARABIC_CHAR(u8c)) {
         do_arabicshape = true;
         break;
@@ -3140,7 +3140,7 @@ static void draw_cmdline(int start, int len)
     }
 
     int newlen = 0;
-    if (utf_iscomposing(utf_ptr2char((char *)ccline.cmdbuff + start))) {
+    if (utf_iscomposing(utf_ptr2char(ccline.cmdbuff + start))) {
       // Prepend a space to draw the leading composing char on.
       arshape_buf[0] = ' ';
       newlen = 1;
@@ -3149,10 +3149,10 @@ static void draw_cmdline(int start, int len)
     int prev_c = 0;
     int prev_c1 = 0;
     for (int i = start; i < start + len; i += mb_l) {
-      char_u *p = ccline.cmdbuff + i;
+      char_u *p = (char_u *)ccline.cmdbuff + i;
       int u8cc[MAX_MCO];
       int u8c = utfc_ptr2char_len(p, u8cc, start + len - i);
-      mb_l = utfc_ptr2len_len(p, start + len - i);
+      mb_l = utfc_ptr2len_len((char *)p, start + len - i);
       if (ARABIC_CHAR(u8c)) {
         int pc;
         int pc1 = 0;
@@ -3208,12 +3208,12 @@ draw_cmdline_no_arabicshape:
           continue;
         }
         const int chunk_start = MAX(chunk.start, start);
-        msg_outtrans_len_attr((char *)ccline.cmdbuff + chunk_start,
+        msg_outtrans_len_attr(ccline.cmdbuff + chunk_start,
                               chunk.end - chunk_start,
                               chunk.attr);
       }
     } else {
-      msg_outtrans_len((char *)ccline.cmdbuff + start, len);
+      msg_outtrans_len(ccline.cmdbuff + start, len);
     }
   }
 }
@@ -3225,7 +3225,7 @@ static void ui_ext_cmdline_show(CmdlineInfo *line)
   if (cmdline_star) {
     content = arena_array(&arena, 1);
     size_t len = 0;
-    for (char_u *p = ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
+    for (char_u *p = (char_u *)ccline.cmdbuff; *p; MB_PTR_ADV(p)) {
       len++;
     }
     char *buf = arena_alloc(&arena, len, false);
@@ -3380,7 +3380,7 @@ void unputcmdline(void)
   if (ccline.cmdlen == ccline.cmdpos && !ui_has(kUICmdline)) {
     msg_putchar(' ');
   } else {
-    draw_cmdline(ccline.cmdpos, utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos));
+    draw_cmdline(ccline.cmdpos, utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos));
   }
   msg_no_more = false;
   cursorcmd();
@@ -3422,7 +3422,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     // Count nr of bytes in cmdline that are overwritten by these
     // characters.
     for (i = ccline.cmdpos; i < ccline.cmdlen && m > 0;
-         i += utfc_ptr2len((char *)ccline.cmdbuff + i)) {
+         i += utfc_ptr2len(ccline.cmdbuff + i)) {
       m--;
     }
     if (i < ccline.cmdlen) {
@@ -3440,17 +3440,17 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     // When the inserted text starts with a composing character,
     // backup to the character before it.  There could be two of them.
     i = 0;
-    c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
+    c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
     while (ccline.cmdpos > 0 && utf_iscomposing(c)) {
-      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
       ccline.cmdpos -= i;
       len += i;
-      c = utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos);
+      c = utf_ptr2char(ccline.cmdbuff + ccline.cmdpos);
     }
     if (i == 0 && ccline.cmdpos > 0 && arabic_maycombine(c)) {
       // Check the previous character for Arabic combining pair.
-      i = utf_head_off((char *)ccline.cmdbuff, (char *)ccline.cmdbuff + ccline.cmdpos - 1) + 1;
-      if (arabic_combine(utf_ptr2char((char *)ccline.cmdbuff + ccline.cmdpos - i), c)) {
+      i = utf_head_off(ccline.cmdbuff, ccline.cmdbuff + ccline.cmdpos - 1) + 1;
+      if (arabic_combine(utf_ptr2char(ccline.cmdbuff + ccline.cmdpos - i), c)) {
         ccline.cmdpos -= i;
         len += i;
       } else {
@@ -3459,7 +3459,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     }
     if (i != 0) {
       // Also backup the cursor position.
-      i = ptr2cells((char *)ccline.cmdbuff + ccline.cmdpos);
+      i = ptr2cells(ccline.cmdbuff + ccline.cmdpos);
       ccline.cmdspos -= i;
       msg_col -= i;
       if (msg_col < 0) {
@@ -3498,7 +3498,7 @@ void put_on_cmdline(char_u *str, int len, int redraw)
     if (ccline.cmdspos + c < m) {
       ccline.cmdspos += c;
     }
-    c = utfc_ptr2len((char *)ccline.cmdbuff + ccline.cmdpos) - 1;
+    c = utfc_ptr2len(ccline.cmdbuff + ccline.cmdpos) - 1;
     if (c > len - i - 1) {
       c = len - i - 1;
     }
@@ -3580,14 +3580,14 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
       int len;
 
       // Locate start of last word in the cmd buffer.
-      for (w = ccline.cmdbuff + ccline.cmdpos; w > ccline.cmdbuff;) {
-        len = utf_head_off((char *)ccline.cmdbuff, (char *)w - 1) + 1;
+      for (w = (char_u *)ccline.cmdbuff + ccline.cmdpos; w > (char_u *)ccline.cmdbuff;) {
+        len = utf_head_off(ccline.cmdbuff, (char *)w - 1) + 1;
         if (!vim_iswordc(utf_ptr2char((char *)w - len))) {
           break;
         }
         w -= len;
       }
-      len = (int)((ccline.cmdbuff + ccline.cmdpos) - w);
+      len = (int)(((char_u *)ccline.cmdbuff + ccline.cmdpos) - w);
       if (p_ic ? STRNICMP(w, arg, len) == 0 : STRNCMP(w, arg, len) == 0) {
         p += len;
       }
@@ -3823,7 +3823,7 @@ static int ccheck_abbr(int c)
     spos = 0;
   }
 
-  return check_abbr(c, ccline.cmdbuff, ccline.cmdpos, spos);
+  return check_abbr(c, (char_u *)ccline.cmdbuff, ccline.cmdpos, spos);
 }
 
 /// Escape special characters in "fname", depending on "what":
@@ -3964,7 +3964,7 @@ static char *get_cmdline_str(void)
   if (p == NULL) {
     return NULL;
   }
-  return (char *)vim_strnsave(p->cmdbuff, (size_t)p->cmdlen);
+  return xstrnsave(p->cmdbuff, (size_t)p->cmdlen);
 }
 
 /// Get the current command-line completion type.
@@ -4126,7 +4126,7 @@ int get_list_range(char **str, int *num1, int *num2)
 
   *str = skipwhite((*str));
   if (**str == '-' || ascii_isdigit(**str)) {  // parse "from" part of range
-    vim_str2nr((char_u *)(*str), NULL, &len, 0, &num, NULL, 0, false);
+    vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, false);
     *str += len;
     *num1 = (int)num;
     first = true;
@@ -4134,7 +4134,7 @@ int get_list_range(char **str, int *num1, int *num2)
   *str = skipwhite((*str));
   if (**str == ',') {                   // parse "to" part of range
     *str = skipwhite((*str) + 1);
-    vim_str2nr((char_u *)(*str), NULL, &len, 0, &num, NULL, 0, false);
+    vim_str2nr(*str, NULL, &len, 0, &num, NULL, 0, false);
     if (len > 0) {
       *num2 = (int)num;
       *str = skipwhite((*str) + len);
@@ -4270,7 +4270,7 @@ static int open_cmdwin(void)
           i = 0;
         }
         if (get_histentry(histtype)[i].hisstr != NULL) {
-          ml_append(lnum++, (char *)get_histentry(histtype)[i].hisstr, (colnr_T)0, false);
+          ml_append(lnum++, get_histentry(histtype)[i].hisstr, (colnr_T)0, false);
         }
       } while (i != *get_hisidx(histtype));
     }
@@ -4278,7 +4278,7 @@ static int open_cmdwin(void)
 
   // Replace the empty last line with the current command-line and put the
   // cursor there.
-  ml_replace(curbuf->b_ml.ml_line_count, (char *)ccline.cmdbuff, true);
+  ml_replace(curbuf->b_ml.ml_line_count, ccline.cmdbuff, true);
   curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
   curwin->w_cursor.col = ccline.cmdpos;
   changed_line_abv_curs();
@@ -4348,7 +4348,7 @@ static int open_cmdwin(void)
 
       if (histtype == HIST_CMD) {
         // Execute the command directly.
-        ccline.cmdbuff = (char_u *)xstrdup(p);
+        ccline.cmdbuff = xstrdup(p);
         cmdwin_result = CAR;
       } else {
         // First need to cancel what we were doing.
@@ -4362,10 +4362,10 @@ static int open_cmdwin(void)
       // and don't modify the cmd window.
       ccline.cmdbuff = NULL;
     } else {
-      ccline.cmdbuff = vim_strsave(get_cursor_line_ptr());
+      ccline.cmdbuff = xstrdup(get_cursor_line_ptr());
     }
     if (ccline.cmdbuff == NULL) {
-      ccline.cmdbuff = vim_strsave((char_u *)"");
+      ccline.cmdbuff = xstrdup("");
       ccline.cmdlen = 0;
       ccline.cmdbufflen = 1;
       ccline.cmdpos = 0;
diff --git a/src/nvim/ex_getln.h b/src/nvim/ex_getln.h
index 5e3ad20a31..919a6c8f11 100644
--- a/src/nvim/ex_getln.h
+++ b/src/nvim/ex_getln.h
@@ -41,7 +41,7 @@ typedef enum {
 /// structure.
 typedef struct cmdline_info CmdlineInfo;
 struct cmdline_info {
-  char_u *cmdbuff;              ///< pointer to command line buffer
+  char *cmdbuff;                ///< pointer to command line buffer
   int cmdbufflen;               ///< length of cmdbuff
   int cmdlen;                   ///< number of chars in command line
   int cmdpos;                   ///< current cursor position
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index e87e0853f3..f75dc51ca5 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -174,12 +174,12 @@ typedef struct ff_search_ctx_T {
   ff_visited_list_hdr_T *ffsc_dir_visited_list;
   ff_visited_list_hdr_T *ffsc_visited_lists_list;
   ff_visited_list_hdr_T *ffsc_dir_visited_lists_list;
-  char_u *ffsc_file_to_search;
-  char_u *ffsc_start_dir;
-  char_u *ffsc_fix_path;
-  char_u *ffsc_wc_path;
+  char *ffsc_file_to_search;
+  char *ffsc_start_dir;
+  char *ffsc_fix_path;
+  char *ffsc_wc_path;
   int ffsc_level;
-  char_u **ffsc_stopdirs_v;
+  char **ffsc_stopdirs_v;
   int ffsc_find_what;
   int ffsc_tagfile;
 } ff_search_ctx_T;
@@ -245,11 +245,10 @@ static char_u e_pathtoolong[] = N_("E854: path too long for completion");
 ///
 /// @param tagfile  expanding names of tags files
 /// @param rel_fname  file name to use for "."
-void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int level,
-                        int free_visited, int find_what, void *search_ctx_arg, int tagfile,
-                        char_u *rel_fname)
+void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, int free_visited,
+                        int find_what, void *search_ctx_arg, int tagfile, char *rel_fname)
 {
-  char_u *wc_part;
+  char *wc_part;
   ff_stack_T *sptr;
   ff_search_ctx_T *search_ctx;
 
@@ -274,12 +273,12 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     /* Reuse old visited lists. Get the visited list for the given
      * filename. If no list for the current filename exists, creates a new
      * one. */
-    search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
+    search_ctx->ffsc_visited_list = ff_get_visited_list((char_u *)filename,
                                                         &search_ctx->ffsc_visited_lists_list);
     if (search_ctx->ffsc_visited_list == NULL) {
       goto error_return;
     }
-    search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
+    search_ctx->ffsc_dir_visited_list = ff_get_visited_list((char_u *)filename,
                                                             &search_ctx->ffsc_dir_visited_lists_list);
     if (search_ctx->ffsc_dir_visited_list == NULL) {
       goto error_return;
@@ -296,19 +295,19 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       && (vim_ispathsep(path[1]) || path[1] == NUL)
       && (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL)
       && rel_fname != NULL) {
-    size_t len = (size_t)((char_u *)path_tail((char *)rel_fname) - rel_fname);
+    size_t len = (size_t)(path_tail(rel_fname) - rel_fname);
 
-    if (!vim_isAbsName(rel_fname) && len + 1 < MAXPATHL) {
+    if (!vim_isAbsName((char_u *)rel_fname) && len + 1 < MAXPATHL) {
       // Make the start dir an absolute path name.
       STRLCPY(ff_expand_buffer, rel_fname, len + 1);
-      search_ctx->ffsc_start_dir = (char_u *)FullName_save((char *)ff_expand_buffer, false);
+      search_ctx->ffsc_start_dir = FullName_save((char *)ff_expand_buffer, false);
     } else {
-      search_ctx->ffsc_start_dir = vim_strnsave(rel_fname, len);
+      search_ctx->ffsc_start_dir = xstrnsave(rel_fname, len);
     }
     if (*++path != NUL) {
       path++;
     }
-  } else if (*path == NUL || !vim_isAbsName(path)) {
+  } else if (*path == NUL || !vim_isAbsName((char_u *)path)) {
 #ifdef BACKSLASH_IN_FILENAME
     // "c:dir" needs "c:" to be expanded, otherwise use current dir
     if (*path != NUL && path[1] == ':') {
@@ -329,7 +328,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       goto error_return;
     }
 
-    search_ctx->ffsc_start_dir = vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_start_dir = (char *)vim_strsave(ff_expand_buffer);
 
 #ifdef BACKSLASH_IN_FILENAME
     /* A path that starts with "/dir" is relative to the drive, not to the
@@ -352,7 +351,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
    * ff_path_in_stoplist() for details.
    */
   if (stopdirs != NULL) {
-    char_u *walker = stopdirs;
+    char *walker = stopdirs;
 
     while (*walker == ';') {
       walker++;
@@ -362,25 +361,23 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     search_ctx->ffsc_stopdirs_v = xmalloc(sizeof(char_u *));
 
     do {
-      char_u *helper;
+      char *helper;
       void *ptr;
 
       helper = walker;
       ptr = xrealloc(search_ctx->ffsc_stopdirs_v,
                      (dircount + 1) * sizeof(char_u *));
       search_ctx->ffsc_stopdirs_v = ptr;
-      walker = (char_u *)vim_strchr((char *)walker, ';');
+      walker = vim_strchr(walker, ';');
       if (walker) {
         assert(walker - helper >= 0);
-        search_ctx->ffsc_stopdirs_v[dircount - 1] =
-          vim_strnsave(helper, (size_t)(walker - helper));
+        search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrnsave(helper, (size_t)(walker - helper));
         walker++;
       } else {
         /* this might be "", which means ascent till top
          * of directory tree.
          */
-        search_ctx->ffsc_stopdirs_v[dircount - 1] =
-          vim_strsave(helper);
+        search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrdup(helper);
       }
 
       dircount++;
@@ -394,7 +391,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
    *  -fix path
    *  -wildcard_stuff (might be NULL)
    */
-  wc_part = (char_u *)vim_strchr((char *)path, '*');
+  wc_part = vim_strchr(path, '*');
   if (wc_part != NULL) {
     int64_t llevel;
     int len;
@@ -402,7 +399,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
 
     // save the fix part of the path
     assert(wc_part - path >= 0);
-    search_ctx->ffsc_fix_path = vim_strnsave(path, (size_t)(wc_part - path));
+    search_ctx->ffsc_fix_path = xstrnsave(path, (size_t)(wc_part - path));
 
     /*
      * copy wc_path and add restricts to the '**' wildcard.
@@ -420,19 +417,19 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
         break;
       }
       if (STRNCMP(wc_part, "**", 2) == 0) {
-        ff_expand_buffer[len++] = *wc_part++;
-        ff_expand_buffer[len++] = *wc_part++;
+        ff_expand_buffer[len++] = (char_u)(*wc_part++);
+        ff_expand_buffer[len++] = (char_u)(*wc_part++);
 
-        llevel = strtol((char *)wc_part, &errpt, 10);
-        if ((char_u *)errpt != wc_part && llevel > 0 && llevel < 255) {
+        llevel = strtol(wc_part, &errpt, 10);
+        if (errpt != wc_part && llevel > 0 && llevel < 255) {
           ff_expand_buffer[len++] = (char_u)llevel;
-        } else if ((char_u *)errpt != wc_part && llevel == 0) {
+        } else if (errpt != wc_part && llevel == 0) {
           // restrict is 0 -> remove already added '**'
           len -= 2;
         } else {
           ff_expand_buffer[len++] = FF_MAX_STAR_STAR_EXPAND;
         }
-        wc_part = (char_u *)errpt;
+        wc_part = errpt;
         if (*wc_part != NUL && !vim_ispathsep(*wc_part)) {
           semsg(_(
                  "E343: Invalid path: '**[number]' must be at the end of the path or be followed by '%s'."),
@@ -440,20 +437,20 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
           goto error_return;
         }
       } else {
-        ff_expand_buffer[len++] = *wc_part++;
+        ff_expand_buffer[len++] = (char_u)(*wc_part++);
       }
     }
     ff_expand_buffer[len] = NUL;
-    search_ctx->ffsc_wc_path = vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_wc_path = (char *)vim_strsave(ff_expand_buffer);
   } else {
-    search_ctx->ffsc_fix_path = vim_strsave(path);
+    search_ctx->ffsc_fix_path = xstrdup(path);
   }
 
   if (search_ctx->ffsc_start_dir == NULL) {
     /* store the fix part as startdir.
      * This is needed if the parameter path is fully qualified.
      */
-    search_ctx->ffsc_start_dir = vim_strsave(search_ctx->ffsc_fix_path);
+    search_ctx->ffsc_start_dir = xstrdup(search_ctx->ffsc_fix_path);
     search_ctx->ffsc_fix_path[0] = NUL;
   }
 
@@ -475,9 +472,9 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
       add_pathsep((char *)ff_expand_buffer);
     } else {
-      char_u *p = (char_u *)path_tail((char *)search_ctx->ffsc_fix_path);
-      char_u *wc_path = NULL;
-      char_u *temp = NULL;
+      char *p = path_tail(search_ctx->ffsc_fix_path);
+      char *wc_path = NULL;
+      char *temp = NULL;
       int len = 0;
 
       if (p > search_ctx->ffsc_fix_path) {
@@ -495,7 +492,7 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
       }
 
       if (search_ctx->ffsc_wc_path != NULL) {
-        wc_path = vim_strsave(search_ctx->ffsc_wc_path);
+        wc_path = xstrdup(search_ctx->ffsc_wc_path);
         temp = xmalloc(STRLEN(search_ctx->ffsc_wc_path)
                        + STRLEN(search_ctx->ffsc_fix_path + len)
                        + 1);
@@ -509,10 +506,10 @@ void *vim_findfile_init(char_u *path, char_u *filename, char_u *stopdirs, int le
     xfree(buf);
   }
 
-  sptr = ff_create_stack_element(ff_expand_buffer, search_ctx->ffsc_wc_path, level, 0);
+  sptr = ff_create_stack_element(ff_expand_buffer, (char_u *)search_ctx->ffsc_wc_path, level, 0);
 
   ff_push(search_ctx, sptr);
-  search_ctx->ffsc_file_to_search = vim_strsave(filename);
+  search_ctx->ffsc_file_to_search = xstrdup(filename);
   return search_ctx;
 
 error_return:
@@ -598,8 +595,7 @@ char_u *vim_findfile(void *search_ctx_arg)
 
   // store the end of the start dir -- needed for upward search
   if (search_ctx->ffsc_start_dir != NULL) {
-    path_end = &search_ctx->ffsc_start_dir[
-                                           STRLEN(search_ctx->ffsc_start_dir)];
+    path_end = (char_u *)&search_ctx->ffsc_start_dir[STRLEN(search_ctx->ffsc_start_dir)];
   }
 
   // upward search loop
@@ -930,19 +926,17 @@ char_u *vim_findfile(void *search_ctx_arg)
       ff_stack_T *sptr;
 
       // is the last starting directory in the stop list?
-      if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
-                              (int)(path_end - search_ctx->ffsc_start_dir),
-                              search_ctx->ffsc_stopdirs_v) == true) {
+      if (ff_path_in_stoplist((char_u *)search_ctx->ffsc_start_dir,
+                              (int)(path_end - (char_u *)search_ctx->ffsc_start_dir),
+                              (char_u **)search_ctx->ffsc_stopdirs_v) == true) {
         break;
       }
 
       // cut of last dir
-      while (path_end > search_ctx->ffsc_start_dir
-             && vim_ispathsep(*path_end)) {
+      while (path_end > (char_u *)search_ctx->ffsc_start_dir && vim_ispathsep(*path_end)) {
         path_end--;
       }
-      while (path_end > search_ctx->ffsc_start_dir
-             && !vim_ispathsep(path_end[-1])) {
+      while (path_end > (char_u *)search_ctx->ffsc_start_dir && !vim_ispathsep(path_end[-1])) {
         path_end--;
       }
       *path_end = 0;
@@ -964,7 +958,7 @@ char_u *vim_findfile(void *search_ctx_arg)
 
       // create a new stack entry
       sptr = ff_create_stack_element(file_path,
-                                     search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
+                                     (char_u *)search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
       ff_push(search_ctx, sptr);
     } else {
       break;
@@ -1528,9 +1522,9 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
 
         // get the stopdir string
         r_ptr = vim_findfile_stopdir((char_u *)buf);
-        fdip_search_ctx = vim_findfile_init((char_u *)buf, ff_file_to_find,
-                                            r_ptr, 100, false, find_what,
-                                            fdip_search_ctx, false, rel_fname);
+        fdip_search_ctx = vim_findfile_init(buf, (char *)ff_file_to_find,
+                                            (char *)r_ptr, 100, false, find_what,
+                                            fdip_search_ctx, false, (char *)rel_fname);
         if (fdip_search_ctx != NULL) {
           did_findfile_init = true;
         }
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 517424f4c1..889e569672 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -719,7 +719,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     fenc_alloced = false;
   } else {
     fenc_next = p_fencs;                // try items in 'fileencodings'
-    fenc = (char *)next_fenc(&fenc_next, &fenc_alloced);
+    fenc = next_fenc(&fenc_next, &fenc_alloced);
   }
 
   /*
@@ -813,7 +813,7 @@ retry:
         xfree(fenc);
       }
       if (fenc_next != NULL) {
-        fenc = (char *)next_fenc(&fenc_next, &fenc_alloced);
+        fenc = next_fenc(&fenc_next, &fenc_alloced);
       } else {
         fenc = "";
         fenc_alloced = false;
@@ -2068,25 +2068,25 @@ void set_forced_fenc(exarg_T *eap)
 /// NULL.
 /// When *pp is not set to NULL, the result is in allocated memory and "alloced"
 /// is set to true.
-static char_u *next_fenc(char **pp, bool *alloced)
+static char *next_fenc(char **pp, bool *alloced)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_RET
 {
-  char_u *p;
-  char_u *r;
+  char *p;
+  char *r;
 
   *alloced = false;
   if (**pp == NUL) {
     *pp = NULL;
-    return (char_u *)"";
+    return "";
   }
-  p = (char_u *)vim_strchr((*pp), ',');
+  p = vim_strchr((*pp), ',');
   if (p == NULL) {
-    r = (char_u *)enc_canonize(*pp);
+    r = enc_canonize(*pp);
     *pp += STRLEN(*pp);
   } else {
-    r = vim_strnsave((char_u *)(*pp), (size_t)(p - (char_u *)(*pp)));
-    *pp = (char *)p + 1;
-    p = (char_u *)enc_canonize((char *)r);
+    r = xstrnsave(*pp, (size_t)(p - *pp));
+    *pp = p + 1;
+    p = enc_canonize(r);
     xfree(r);
     r = p;
   }
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 4d7339f3b5..97c3b1c61f 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -2566,7 +2566,7 @@ static int vgetorpeek(bool advance)
                 // white-space, so find the last non-white
                 // character -- webb
                 curwin->w_wcol = 0;
-                ptr = get_cursor_line_ptr();
+                ptr = (char_u *)get_cursor_line_ptr();
                 chartabsize_T cts;
                 init_chartabsize_arg(&cts, curwin,
                                      curwin->w_cursor.lnum, 0, (char *)ptr, (char *)ptr);
@@ -2596,7 +2596,7 @@ static int vgetorpeek(bool advance)
             if (col > 0 && curwin->w_wcol > 0) {
               // Correct when the cursor is on the right halve
               // of a double-wide character.
-              ptr = get_cursor_line_ptr();
+              ptr = (char_u *)get_cursor_line_ptr();
               col -= utf_head_off((char *)ptr, (char *)ptr + col);
               if (utf_ptr2cells((char *)ptr + col) > 1) {
                 curwin->w_wcol--;
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index 329adfda12..22445b9ec7 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -240,7 +240,7 @@ void grid_puts_len(ScreenGrid *grid, char *text, int textlen, int row, int col,
     c = (unsigned char)(*ptr);
     // check if this is the first byte of a multibyte
     mbyte_blen = len > 0
-      ? utfc_ptr2len_len((char_u *)ptr, (int)((text + len) - ptr))
+      ? utfc_ptr2len_len(ptr, (int)((text + len) - ptr))
       : utfc_ptr2len(ptr);
     u8c = len >= 0
       ? utfc_ptr2char_len((char_u *)ptr, u8cc, (int)((text + len) - ptr))
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index da4bcf6934..a41a396abc 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -343,7 +343,7 @@ int get_sts_value(void)
 // Count the size (in window cells) of the indent in the current line.
 int get_indent(void)
 {
-  return get_indent_str_vtab((char *)get_cursor_line_ptr(),
+  return get_indent_str_vtab(get_cursor_line_ptr(),
                              curbuf->b_p_ts,
                              curbuf->b_p_vts_array,
                              false);
@@ -454,7 +454,7 @@ int set_indent(int size, int flags)
   // characters needed for the indent.
   todo = size;
   ind_len = 0;
-  p = oldline = get_cursor_line_ptr();
+  p = oldline = (char_u *)get_cursor_line_ptr();
 
   // Calculate the buffer size for the new indent, and check to see if it
   // isn't already set.
@@ -857,7 +857,7 @@ int inindent(int extra)
   char_u *ptr;
   colnr_T col;
 
-  for (col = 0, ptr = get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
+  for (col = 0, ptr = (char_u *)get_cursor_line_ptr(); ascii_iswhite(*ptr); col++) {
     ptr++;
   }
 
@@ -979,7 +979,7 @@ int get_lisp_indent(void)
         continue;
       }
 
-      for (that = get_cursor_line_ptr(); *that != NUL; that++) {
+      for (that = (char_u *)get_cursor_line_ptr(); *that != NUL; that++) {
         if (*that == ';') {
           while (*(that + 1) != NUL) {
             that++;
@@ -1029,7 +1029,7 @@ int get_lisp_indent(void)
       curwin->w_cursor.col = pos->col;
       col = pos->col;
 
-      that = get_cursor_line_ptr();
+      that = (char_u *)get_cursor_line_ptr();
 
       if (vi_lisp && (get_indent() == 0)) {
         amount = 2;
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index ccee4dd48a..7dcc9e3c27 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -355,7 +355,7 @@ static bool cin_islabel_skip(const char_u **s)
 // Note: curwin->w_cursor must be where we are looking for the label.
 bool cin_islabel(void)  // XXX
 {
-  const char_u *s = cin_skipcomment(get_cursor_line_ptr());
+  const char_u *s = cin_skipcomment((char_u *)get_cursor_line_ptr());
 
   // Exclude "default" from labels, since it should be indented
   // like a switch label.  Same for C++ scope declarations.
@@ -390,7 +390,7 @@ bool cin_islabel(void)  // XXX
       curwin->w_cursor = *trypos;
     }
 
-    line = get_cursor_line_ptr();
+    line = (char_u *)get_cursor_line_ptr();
     if (cin_ispreproc(line)) {        // ignore #defines, #if, etc.
       continue;
     }
@@ -421,7 +421,7 @@ static int cin_isinit(void)
   const char_u *s;
   static char *skip[] = { "static", "public", "protected", "private" };
 
-  s = cin_skipcomment(get_cursor_line_ptr());
+  s = cin_skipcomment((char_u *)get_cursor_line_ptr());
 
   if (cin_starts_with(s, "typedef")) {
     s = cin_skipcomment(s + 7);
@@ -642,17 +642,17 @@ static int skip_label(linenr_T lnum, const char_u **pp)
 
   cursor_save = curwin->w_cursor;
   curwin->w_cursor.lnum = lnum;
-  l = get_cursor_line_ptr();
+  l = (char_u *)get_cursor_line_ptr();
   // XXX
   if (cin_iscase(l, false) || cin_isscopedecl(l) || cin_islabel()) {
     amount = get_indent_nolabel(lnum);
-    l = after_label(get_cursor_line_ptr());
+    l = after_label((char_u *)get_cursor_line_ptr());
     if (l == NULL) {            // just in case
-      l = get_cursor_line_ptr();
+      l = (char_u *)get_cursor_line_ptr();
     }
   } else {
     amount = get_indent();
-    l = get_cursor_line_ptr();
+    l = (char_u *)get_cursor_line_ptr();
   }
   *pp = l;
 
@@ -674,7 +674,7 @@ static int cin_first_id_amount(void)
   pos_T fp;
   colnr_T col;
 
-  line = get_cursor_line_ptr();
+  line = (char_u *)get_cursor_line_ptr();
   p = (char_u *)skipwhite((char *)line);
   len = (int)((char_u *)skiptowhite((char *)p) - p);
   if (len == 6 && STRNCMP(p, "static", 6) == 0) {
@@ -1033,7 +1033,7 @@ static int cin_iswhileofdo(const char_u *p, linenr_T lnum)  // XXX
     cursor_save = curwin->w_cursor;
     curwin->w_cursor.lnum = lnum;
     curwin->w_cursor.col = 0;
-    p = get_cursor_line_ptr();
+    p = (char_u *)get_cursor_line_ptr();
     while (*p && *p != 'w') {   // skip any '}', until the 'w' of the "while"
       p++;
       curwin->w_cursor.col++;
@@ -1110,7 +1110,7 @@ static int cin_iswhileofdo_end(int terminated)
     return false;
   }
 
-  p = line = get_cursor_line_ptr();
+  p = line = (char_u *)get_cursor_line_ptr();
   while (*p != NUL) {
     p = cin_skipcomment(p);
     if (*p == ')') {
@@ -1133,7 +1133,7 @@ static int cin_iswhileofdo_end(int terminated)
         }
 
         // Searching may have made "line" invalid, get it again.
-        line = get_cursor_line_ptr();
+        line = (char_u *)get_cursor_line_ptr();
         p = line + i;
       }
     }
@@ -1168,7 +1168,7 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
   const char_u *s;
   int class_or_struct, lookfor_ctor_init, cpp_base_class;
   linenr_T lnum = curwin->w_cursor.lnum;
-  const char_u *line = get_cursor_line_ptr();
+  const char_u *line = (char_u *)get_cursor_line_ptr();
 
   if (pos->lnum <= lnum) {
     return cached->found;  // Use the cached result
@@ -1322,11 +1322,11 @@ static int get_baseclass_amount(int col)
 
   if (col == 0) {
     amount = get_indent();
-    if (find_last_paren(get_cursor_line_ptr(), '(', ')')
+    if (find_last_paren((char_u *)get_cursor_line_ptr(), '(', ')')
         && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL) {
       amount = get_indent_lnum(trypos->lnum);       // XXX
     }
-    if (!cin_ends_in(get_cursor_line_ptr(), (char_u *)",", NULL)) {
+    if (!cin_ends_in((char_u *)get_cursor_line_ptr(), (char_u *)",", NULL)) {
       amount += curbuf->b_ind_cpp_baseclass;
     }
   } else {
@@ -2287,7 +2287,7 @@ int get_c_indent(void)
           /* Ignore a '(' in front of the line that has a match before
            * our matching '('. */
           curwin->w_cursor.lnum = our_paren_pos.lnum;
-          line = get_cursor_line_ptr();
+          line = (char_u *)get_cursor_line_ptr();
           look_col = (int)(look - line);
           curwin->w_cursor.col = look_col + 1;
           if ((trypos = findmatchlimit(NULL, ')', 0,
@@ -2472,7 +2472,7 @@ int get_c_indent(void)
         //                      ldfd) {
         //                  }
         if ((curbuf->b_ind_js || curbuf->b_ind_keep_case_label)
-            && cin_iscase((char_u *)skipwhite((char *)get_cursor_line_ptr()), false)) {
+            && cin_iscase((char_u *)skipwhite(get_cursor_line_ptr()), false)) {
           amount = get_indent();
         } else if (curbuf->b_ind_js) {
           amount = get_indent_lnum(lnum);
@@ -2539,7 +2539,7 @@ int get_c_indent(void)
           if (start_brace == BRACE_AT_END) {    // '{' is at end of line
             amount += curbuf->b_ind_open_imag;
 
-            l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
+            l = (char_u *)skipwhite(get_cursor_line_ptr());
             if (cin_is_cpp_namespace(l)) {
               amount += curbuf->b_ind_cpp_namespace;
             } else if (cin_is_cpp_extern_c(l)) {
@@ -2614,7 +2614,7 @@ int get_c_indent(void)
                 break;
               }
 
-              l = get_cursor_line_ptr();
+              l = (char_u *)get_cursor_line_ptr();
 
               /*
                * If we're in a comment or raw string now, skip to
@@ -2734,7 +2734,7 @@ int get_c_indent(void)
                   break;
                 }
 
-                l = get_cursor_line_ptr();
+                l = (char_u *)get_cursor_line_ptr();
 
                 /* If we're in a comment or raw string now, skip
                  * to the start of it. */
@@ -2777,7 +2777,7 @@ int get_c_indent(void)
             continue;
           }
 
-          l = get_cursor_line_ptr();
+          l = (char_u *)get_cursor_line_ptr();
 
           /*
            * If this is a switch() label, may line up relative to that.
@@ -2853,7 +2853,7 @@ int get_c_indent(void)
             // ->              y = y + 1;
             if (n) {
               amount = n;
-              l = after_label(get_cursor_line_ptr());
+              l = after_label((char_u *)get_cursor_line_ptr());
               if (l != NULL && cin_is_cinword((char *)l)) {
                 if (theline[0] == '{') {
                   amount += curbuf->b_ind_open_extra;
@@ -2898,7 +2898,7 @@ int get_c_indent(void)
            * Ignore jump labels with nothing after them.
            */
           if (!curbuf->b_ind_js && cin_islabel()) {
-            l = after_label(get_cursor_line_ptr());
+            l = after_label((char_u *)get_cursor_line_ptr());
             if (l == NULL || cin_nocode(l)) {
               continue;
             }
@@ -2910,7 +2910,7 @@ int get_c_indent(void)
            * (need to get the line again, cin_islabel() may have
            * unlocked it)
            */
-          l = get_cursor_line_ptr();
+          l = (char_u *)get_cursor_line_ptr();
           if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount)
               || cin_nocode(l)) {
             continue;
@@ -2922,7 +2922,7 @@ int get_c_indent(void)
           n = 0;
           if (lookfor != LOOKFOR_TERM && curbuf->b_ind_cpp_baseclass > 0) {
             n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
-            l = get_cursor_line_ptr();
+            l = (char_u *)get_cursor_line_ptr();
           }
           if (n) {
             if (lookfor == LOOKFOR_UNTERM) {
@@ -3039,7 +3039,7 @@ int get_c_indent(void)
                *                        asdf)
                */
               curwin->w_cursor = *trypos;
-              l = get_cursor_line_ptr();
+              l = (char_u *)get_cursor_line_ptr();
               if (cin_iscase(l, false) || cin_isscopedecl(l)) {
                 curwin->w_cursor.lnum++;
                 curwin->w_cursor.col = 0;
@@ -3154,7 +3154,7 @@ int get_c_indent(void)
                *            x = 1;
                * ->  here
                */
-              l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
+              l = (char_u *)skipwhite(get_cursor_line_ptr());
               if (cin_isdo(l)) {
                 if (whilelevel == 0) {
                   break;
@@ -3174,7 +3174,7 @@ int get_c_indent(void)
                  * not the one from "if () {". */
                 if (*l == '}') {
                   curwin->w_cursor.col =
-                    (colnr_T)(l - get_cursor_line_ptr()) + 1;
+                    (colnr_T)(l - (char_u *)get_cursor_line_ptr()) + 1;
                 }
 
                 if ((trypos = find_start_brace()) == NULL
@@ -3231,7 +3231,7 @@ int get_c_indent(void)
                 // line up with this line, remember its indent
                 //          100 +  //  NOLINT(whitespace/tab)
                 // ->       here;  //  NOLINT(whitespace/tab)
-                l = get_cursor_line_ptr();
+                l = (char_u *)get_cursor_line_ptr();
                 amount = cur_amount;
 
                 n = (int)STRLEN(l);
@@ -3341,7 +3341,7 @@ int get_c_indent(void)
              * may be lined up with the case label.
              */
             if (lookfor == LOOKFOR_NOBREAK
-                && cin_isbreak((char_u *)skipwhite((char *)get_cursor_line_ptr()))) {
+                && cin_isbreak((char_u *)skipwhite(get_cursor_line_ptr()))) {
               lookfor = LOOKFOR_ANY;
               continue;
             }
@@ -3350,7 +3350,7 @@ int get_c_indent(void)
              * Handle "do {" line.
              */
             if (whilelevel > 0) {
-              l = cin_skipcomment(get_cursor_line_ptr());
+              l = cin_skipcomment((char_u *)get_cursor_line_ptr());
               if (cin_isdo(l)) {
                 amount = get_indent();                  // XXX
                 whilelevel--;
@@ -3408,7 +3408,7 @@ int get_c_indent(void)
                *     here;
                */
 term_again:
-              l = get_cursor_line_ptr();
+              l = (char_u *)get_cursor_line_ptr();
               if (find_last_paren(l, '(', ')')
                   && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL) {
                 // Check if we are on a case label now.  This is
@@ -3416,7 +3416,7 @@ term_again:
                 //         case xx:  if ( asdf &&
                 //                          asdf)
                 curwin->w_cursor = *trypos;
-                l = get_cursor_line_ptr();
+                l = (char_u *)get_cursor_line_ptr();
                 if (cin_iscase(l, false) || cin_isscopedecl(l)) {
                   curwin->w_cursor.lnum++;
                   curwin->w_cursor.col = 0;
@@ -3475,13 +3475,13 @@ term_again:
                * If we're at the end of a block, skip to the start of
                * that block.
                */
-              l = get_cursor_line_ptr();
+              l = (char_u *)get_cursor_line_ptr();
               if (find_last_paren(l, '{', '}')           // XXX
                   && (trypos = find_start_brace()) != NULL) {
                 curwin->w_cursor = *trypos;
                 // if not "else {" check for terminated again
                 // but skip block for "} else {"
-                l = cin_skipcomment(get_cursor_line_ptr());
+                l = cin_skipcomment((char_u *)get_cursor_line_ptr());
                 if (*l == '}' || !cin_iselse(l)) {
                   goto term_again;
                 }
@@ -3547,7 +3547,7 @@ term_again:
     curwin->w_cursor.lnum--;
     curwin->w_cursor.col = 0;
 
-    l = get_cursor_line_ptr();
+    l = (char_u *)get_cursor_line_ptr();
 
     // If we're in a comment or raw string now, skip to the start
     // of it.
@@ -3563,7 +3563,7 @@ term_again:
     n = 0;
     if (curbuf->b_ind_cpp_baseclass != 0) {
       n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
-      l = get_cursor_line_ptr();
+      l = (char_u *)get_cursor_line_ptr();
     }
     if (n) {
       // XXX
@@ -3635,7 +3635,7 @@ term_again:
     if (cin_isfuncdecl(NULL, cur_curpos.lnum, 0)) {        // XXX
       break;
     }
-    l = get_cursor_line_ptr();
+    l = (char_u *)get_cursor_line_ptr();
 
     /*
      * Finding the closing '}' of a previous function.  Put
@@ -3709,7 +3709,7 @@ term_again:
           || (*l != NUL && l[STRLEN(l) - 1] == '\\')) {
         break;
       }
-      l = get_cursor_line_ptr();
+      l = (char_u *)get_cursor_line_ptr();
     }
 
     /*
@@ -3786,7 +3786,7 @@ static int find_match(int lookfor, linenr_T ourscope)
     curwin->w_cursor.lnum--;
     curwin->w_cursor.col = 0;
 
-    look = cin_skipcomment(get_cursor_line_ptr());
+    look = cin_skipcomment((char_u *)get_cursor_line_ptr());
     if (!cin_iselse(look)
         && !cin_isif(look)
         && !cin_isdo(look)                                   // XXX
@@ -3826,7 +3826,7 @@ static int find_match(int lookfor, linenr_T ourscope)
      * then we need to go back to another if, so
      * increment elselevel
      */
-    look = cin_skipcomment(get_cursor_line_ptr());
+    look = cin_skipcomment((char_u *)get_cursor_line_ptr());
     if (cin_iselse(look)) {
       mightbeif = cin_skipcomment(look + 4);
       if (!cin_isif(mightbeif)) {
@@ -3845,7 +3845,7 @@ static int find_match(int lookfor, linenr_T ourscope)
     }
 
     // If it's an "if" decrement elselevel
-    look = cin_skipcomment(get_cursor_line_ptr());
+    look = cin_skipcomment((char_u *)get_cursor_line_ptr());
     if (cin_isif(look)) {
       elselevel--;
       /*
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index a530061280..dce72a2611 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -231,7 +231,7 @@ static pos_T compl_startpos;
 static int compl_length = 0;
 static colnr_T compl_col = 0;           ///< column where the text starts
                                         ///< that is being completed
-static char_u *compl_orig_text = NULL;  ///< text as it was before
+static char *compl_orig_text = NULL;    ///< text as it was before
                                         ///< completion started
 static int compl_cont_mode = 0;
 static expand_T compl_xp;
@@ -587,7 +587,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
 
   // Rule 1: Were any chars converted to lower?
   {
-    const char_u *p = compl_orig_text;
+    const char_u *p = (char_u *)compl_orig_text;
     for (int i = 0; i < min_len; i++) {
       const int c = mb_ptr2char_adv(&p);
       if (mb_islower(c)) {
@@ -606,7 +606,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
   // Rule 2: No lower case, 2nd consecutive letter converted to
   // upper case.
   if (!has_lower) {
-    const char_u *p = compl_orig_text;
+    const char_u *p = (char_u *)compl_orig_text;
     for (int i = 0; i < min_len; i++) {
       const int c = mb_ptr2char_adv(&p);
       if (was_letter && mb_isupper(c) && mb_islower(wca[i])) {
@@ -622,7 +622,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
 
   // Copy the original case of the part we typed.
   {
-    const char_u *p = compl_orig_text;
+    const char_u *p = (char_u *)compl_orig_text;
     for (int i = 0; i < min_len; i++) {
       const int c = mb_ptr2char_adv(&p);
       if (mb_islower(c)) {
@@ -699,7 +699,7 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
 
     // Find actual length of original text.
     {
-      const char_u *p = compl_orig_text;
+      const char_u *p = (char_u *)compl_orig_text;
       compl_char_len = 0;
       while (*p != NUL) {
         MB_PTR_ADV(p);
@@ -720,7 +720,7 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
     flags |= CP_ICASE;
   }
 
-  int res = ins_compl_add(str, len, fname, NULL, false, NULL, dir, flags, false);
+  int res = ins_compl_add((char *)str, len, (char *)fname, NULL, false, NULL, dir, flags, false);
   xfree(tofree);
   return res;
 }
@@ -748,9 +748,9 @@ int ins_compl_add_infercase(char_u *str_arg, int len, bool icase, char_u *fname,
 /// @return NOTDONE if the given string is already in the list of completions,
 ///         otherwise it is added to the list and  OK is returned. FAIL will be
 ///         returned in case of error.
-static int ins_compl_add(char_u *const str, int len, char_u *const fname,
-                         char_u *const *const cptext, const bool cptext_allocated,
-                         typval_T *user_data, const Direction cdir, int flags_arg, const bool adup)
+static int ins_compl_add(char *const str, int len, char *const fname, char *const *const cptext,
+                         const bool cptext_allocated, typval_T *user_data, const Direction cdir,
+                         int flags_arg, const bool adup)
   FUNC_ATTR_NONNULL_ARG(1)
 {
   compl_T *match;
@@ -802,7 +802,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
   if (flags & CP_ORIGINAL_TEXT) {
     match->cp_number = 0;
   }
-  match->cp_str = vim_strnsave(str, (size_t)len);
+  match->cp_str = (char_u *)xstrnsave(str, (size_t)len);
 
   // match-fname is:
   // - compl_curr_match->cp_fname if it is a string equal to fname.
@@ -814,7 +814,7 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
       && STRCMP(fname, compl_curr_match->cp_fname) == 0) {
     match->cp_fname = compl_curr_match->cp_fname;
   } else if (fname != NULL) {
-    match->cp_fname = vim_strsave(fname);
+    match->cp_fname = vim_strsave((char_u *)fname);
     flags |= CP_FREE_FNAME;
   } else {
     match->cp_fname = NULL;
@@ -830,8 +830,8 @@ static int ins_compl_add(char_u *const str, int len, char_u *const fname,
       }
       if (*cptext[i] != NUL) {
         match->cp_text[i] = (cptext_allocated
-                             ? cptext[i]
-                             : (char_u *)xstrdup((char *)cptext[i]));
+                             ? (char_u *)cptext[i]
+                             : (char_u *)xstrdup(cptext[i]));
       } else if (cptext_allocated) {
         xfree(cptext[i]);
       }
@@ -957,7 +957,7 @@ static void ins_compl_add_matches(int num_matches, char **matches, int icase)
   Direction dir = compl_direction;
 
   for (int i = 0; i < num_matches && add_r != FAIL; i++) {
-    if ((add_r = ins_compl_add((char_u *)matches[i], -1, NULL, NULL, false, NULL, dir,
+    if ((add_r = ins_compl_add(matches[i], -1, NULL, NULL, false, NULL, dir,
                                CP_FAST | (icase ? CP_ICASE : 0),
                                false)) == OK) {
       // If dir was BACKWARD then honor it just once.
@@ -1621,8 +1621,8 @@ int ins_compl_len(void)
 /// to be got from the user.
 int ins_compl_bs(void)
 {
-  char_u *line = get_cursor_line_ptr();
-  char_u *p = line + curwin->w_cursor.col;
+  char *line = get_cursor_line_ptr();
+  char *p = line + curwin->w_cursor.col;
   MB_PTR_BACK(line, p);
   ptrdiff_t p_off = p - line;
 
@@ -1649,7 +1649,7 @@ int ins_compl_bs(void)
   line = get_cursor_line_ptr();
 
   xfree(compl_leader);
-  compl_leader = vim_strnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
+  compl_leader = (char_u *)xstrnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
 
   ins_compl_new_leader();
   if (compl_shown_match != NULL) {
@@ -1743,8 +1743,8 @@ void ins_compl_addleader(int c)
   }
 
   xfree(compl_leader);
-  compl_leader = vim_strnsave(get_cursor_line_ptr() + compl_col,
-                              (size_t)(curwin->w_cursor.col - compl_col));
+  compl_leader = (char_u *)xstrnsave(get_cursor_line_ptr() + compl_col,
+                                     (size_t)(curwin->w_cursor.col - compl_col));
   ins_compl_new_leader();
 }
 
@@ -2008,7 +2008,7 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
     if (compl_leader != NULL) {
       p = compl_leader;
     } else if (compl_first_match != NULL) {
-      p = compl_orig_text;
+      p = (char_u *)compl_orig_text;
     }
     if (p != NULL) {
       const int compl_len = get_compl_len();
@@ -2174,7 +2174,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
     }
   }
   if (compl_orig_text != NULL) {
-    p = compl_orig_text;
+    p = (char_u *)compl_orig_text;
     for (len = 0; p[len] != NUL && p[len] == ptr[len]; len++) {}
     if (len > 0) {
       len -= utf_head_off((char *)p, (char *)p + len);
@@ -2360,7 +2360,7 @@ static int ins_compl_add_tv(typval_T *const tv, const Direction dir, bool fast)
     tv_clear(&user_data);
     return FAIL;
   }
-  int status = ins_compl_add((char_u *)word, -1, NULL, (char_u **)cptext, true,
+  int status = ins_compl_add((char *)word, -1, NULL, cptext, true,
                              &user_data, dir, flags, dup);
   if (status != OK) {
     tv_clear(&user_data);
@@ -2430,8 +2430,8 @@ static void set_completion(colnr_T startcol, list_T *list)
   compl_col = startcol;
   compl_length = (int)curwin->w_cursor.col - (int)startcol;
   // compl_pattern doesn't need to be set
-  compl_orig_text = vim_strnsave(get_cursor_line_ptr() + compl_col,
-                                 (size_t)compl_length);
+  compl_orig_text = xstrnsave(get_cursor_line_ptr() + compl_col,
+                              (size_t)compl_length);
   if (p_ic) {
     flags |= CP_ICASE;
   }
@@ -3513,7 +3513,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
 
   // Insert the text of the new completion, or the compl_leader.
   if (compl_no_insert && !started) {
-    ins_bytes((char *)compl_orig_text + get_compl_len());
+    ins_bytes(compl_orig_text + get_compl_len());
     compl_used_match = false;
   } else if (insert_match) {
     if (!compl_get_longest || compl_used_match) {
@@ -3697,7 +3697,7 @@ static bool ins_compl_use_match(int c)
 /// completion)
 /// Sets the global variables: compl_col, compl_length and compl_pattern.
 /// Uses the global variables: compl_cont_status and ctrl_x_mode
-static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
+static int get_normal_compl_info(char *line, int startcol, colnr_T curs_col)
 {
   if ((compl_cont_status & CONT_SOL) || ctrl_x_mode_path_defines()) {
     if (!compl_status_adding()) {
@@ -3706,25 +3706,25 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
       compl_length = curs_col - startcol;
     }
     if (p_ic) {
-      compl_pattern = (char *)str_foldcase(line + compl_col, compl_length, NULL, 0);
+      compl_pattern = (char *)str_foldcase((char_u *)line + compl_col, compl_length, NULL, 0);
     } else {
-      compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
+      compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
     }
   } else if (compl_status_adding()) {
     char_u *prefix = (char_u *)"\\<";
 
     // we need up to 2 extra chars for the prefix
-    compl_pattern = xmalloc(quote_meta(NULL, line + compl_col,
-                                       compl_length) + 2);
-    if (!vim_iswordp(line + compl_col)
-        || (compl_col > 0 && (vim_iswordp(mb_prevptr(line, line + compl_col))))) {
+    compl_pattern = xmalloc(quote_meta(NULL, (char_u *)line + compl_col, compl_length) + 2);
+    if (!vim_iswordp((char_u *)line + compl_col)
+        || (compl_col > 0
+            && (vim_iswordp(mb_prevptr((char_u *)line, (char_u *)line + compl_col))))) {
       prefix = (char_u *)"";
     }
     STRCPY(compl_pattern, prefix);
     (void)quote_meta((char_u *)compl_pattern + STRLEN(prefix),
-                     line + compl_col, compl_length);
+                     (char_u *)line + compl_col, compl_length);
   } else if (--startcol < 0
-             || !vim_iswordp(mb_prevptr(line, line + startcol + 1))) {
+             || !vim_iswordp(mb_prevptr((char_u *)line, (char_u *)line + startcol + 1))) {
     // Match any word of at least two chars
     compl_pattern = xstrdup("\\<\\k\\k");
     compl_col += curs_col;
@@ -3732,11 +3732,11 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
   } else {
     // Search the point of change class of multibyte character
     // or not a word single byte character backward.
-    startcol -= utf_head_off((char *)line, (char *)line + startcol);
-    int base_class = mb_get_class(line + startcol);
+    startcol -= utf_head_off(line, line + startcol);
+    int base_class = mb_get_class((char_u *)line + startcol);
     while (--startcol >= 0) {
-      int head_off = utf_head_off((char *)line, (char *)line + startcol);
-      if (base_class != mb_get_class(line + startcol - head_off)) {
+      int head_off = utf_head_off(line, line + startcol);
+      if (base_class != mb_get_class((char_u *)line + startcol - head_off)) {
         break;
       }
       startcol -= head_off;
@@ -3749,13 +3749,13 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
       // xmalloc(7) is enough  -- Acevedo
       compl_pattern = xmalloc(7);
       STRCPY(compl_pattern, "\\<");
-      (void)quote_meta((char_u *)compl_pattern + 2, line + compl_col, 1);
+      (void)quote_meta((char_u *)compl_pattern + 2, (char_u *)line + compl_col, 1);
       STRCAT(compl_pattern, "\\k");
     } else {
-      compl_pattern = xmalloc(quote_meta(NULL, line + compl_col,
+      compl_pattern = xmalloc(quote_meta(NULL, (char_u *)line + compl_col,
                                          compl_length) + 2);
       STRCPY(compl_pattern, "\\<");
-      (void)quote_meta((char_u *)compl_pattern + 2, line + compl_col, compl_length);
+      (void)quote_meta((char_u *)compl_pattern + 2, (char_u *)line + compl_col, compl_length);
     }
   }
 
@@ -3765,17 +3765,17 @@ static int get_normal_compl_info(char_u *line, int startcol, colnr_T curs_col)
 /// Get the pattern, column and length for whole line completion or for the
 /// complete() function.
 /// Sets the global variables: compl_col, compl_length and compl_pattern.
-static int get_wholeline_compl_info(char_u *line, colnr_T curs_col)
+static int get_wholeline_compl_info(char *line, colnr_T curs_col)
 {
-  compl_col = (colnr_T)getwhitecols((char *)line);
+  compl_col = (colnr_T)getwhitecols(line);
   compl_length = (int)curs_col - (int)compl_col;
   if (compl_length < 0) {  // cursor in indent: empty pattern
     compl_length = 0;
   }
   if (p_ic) {
-    compl_pattern = (char *)str_foldcase(line + compl_col, compl_length, NULL, 0);
+    compl_pattern = (char *)str_foldcase((char_u *)line + compl_col, compl_length, NULL, 0);
   } else {
-    compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
+    compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
   }
 
   return OK;
@@ -3802,16 +3802,16 @@ static int get_filename_compl_info(char_u *line, int startcol, colnr_T curs_col)
 
   compl_col += startcol;
   compl_length = (int)curs_col - startcol;
-  compl_pattern = (char *)addstar(line + compl_col, (size_t)compl_length, EXPAND_FILES);
+  compl_pattern = addstar((char *)line + compl_col, (size_t)compl_length, EXPAND_FILES);
 
   return OK;
 }
 
 /// Get the pattern, column and length for command-line completion.
 /// Sets the global variables: compl_col, compl_length and compl_pattern.
-static int get_cmdline_compl_info(char_u *line, colnr_T curs_col)
+static int get_cmdline_compl_info(char *line, colnr_T curs_col)
 {
-  compl_pattern = (char *)vim_strnsave(line, (size_t)curs_col);
+  compl_pattern = xstrnsave(line, (size_t)curs_col);
   set_cmd_context(&compl_xp, (char_u *)compl_pattern, (int)STRLEN(compl_pattern), curs_col, false);
   if (compl_xp.xp_context == EXPAND_UNSUCCESSFUL
       || compl_xp.xp_context == EXPAND_NOTHING) {
@@ -3893,9 +3893,9 @@ static int get_userdefined_compl_info(colnr_T curs_col)
 
   // Setup variables for completion.  Need to obtain "line" again,
   // it may have become invalid.
-  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
+  char *line = ml_get(curwin->w_cursor.lnum);
   compl_length = curs_col - compl_col;
-  compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
+  compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
 
   return OK;
 }
@@ -3919,8 +3919,8 @@ static int get_spell_compl_info(int startcol, colnr_T curs_col)
     compl_length = (int)curs_col - compl_col;
   }
   // Need to obtain "line" again, it may have become invalid.
-  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
-  compl_pattern = (char *)vim_strnsave(line + compl_col, (size_t)compl_length);
+  char *line = ml_get(curwin->w_cursor.lnum);
+  compl_pattern = xstrnsave(line + compl_col, (size_t)compl_length);
 
   return OK;
 }
@@ -3939,13 +3939,13 @@ static int compl_get_info(char_u *line, int startcol, colnr_T curs_col, bool *li
   if (ctrl_x_mode_normal()
       || ((ctrl_x_mode & CTRL_X_WANT_IDENT)
           && !thesaurus_func_complete(ctrl_x_mode))) {
-    return get_normal_compl_info(line, startcol, curs_col);
+    return get_normal_compl_info((char *)line, startcol, curs_col);
   } else if (ctrl_x_mode_line_or_eval()) {
-    return get_wholeline_compl_info(line, curs_col);
+    return get_wholeline_compl_info((char *)line, curs_col);
   } else if (ctrl_x_mode_files()) {
     return get_filename_compl_info(line, startcol, curs_col);
   } else if (ctrl_x_mode == CTRL_X_CMDLINE) {
-    return get_cmdline_compl_info(line, curs_col);
+    return get_cmdline_compl_info((char *)line, curs_col);
   } else if (ctrl_x_mode_function() || ctrl_x_mode_omni()
              || thesaurus_func_complete(ctrl_x_mode)) {
     if (get_userdefined_compl_info(curs_col) == FAIL) {
@@ -4036,7 +4036,7 @@ static int ins_compl_start(void)
     return FAIL;
   }
 
-  char_u *line = (char_u *)ml_get(curwin->w_cursor.lnum);
+  char *line = ml_get(curwin->w_cursor.lnum);
   colnr_T curs_col = curwin->w_cursor.col;
   compl_pending = 0;
 
@@ -4044,7 +4044,7 @@ static int ins_compl_start(void)
       && compl_cont_mode == ctrl_x_mode) {
     // this same ctrl-x_mode was interrupted previously. Continue the
     // completion.
-    ins_compl_continue_search(line);
+    ins_compl_continue_search((char_u *)line);
   } else {
     compl_cont_status &= CONT_LOCAL;
   }
@@ -4064,7 +4064,7 @@ static int ins_compl_start(void)
 
   // Work out completion pattern and original text -- webb
   bool line_invalid = false;
-  if (compl_get_info(line, startcol, curs_col, &line_invalid) == FAIL) {
+  if (compl_get_info((char_u *)line, startcol, curs_col, &line_invalid) == FAIL) {
     if (ctrl_x_mode_function() || ctrl_x_mode_omni()
         || thesaurus_func_complete(ctrl_x_mode)) {
       // restore did_ai, so that adding comment leader works
@@ -4074,7 +4074,7 @@ static int ins_compl_start(void)
   }
   // If "line" was changed while getting completion info get it again.
   if (line_invalid) {
-    line = (char_u *)ml_get(curwin->w_cursor.lnum);
+    line = ml_get(curwin->w_cursor.lnum);
   }
 
   if (compl_status_adding()) {
@@ -4108,7 +4108,7 @@ static int ins_compl_start(void)
 
   // Always add completion for the original text.
   xfree(compl_orig_text);
-  compl_orig_text = vim_strnsave(line + compl_col, (size_t)compl_length);
+  compl_orig_text = xstrnsave(line + compl_col, (size_t)compl_length);
   int flags = CP_ORIGINAL_TEXT;
   if (p_ic) {
     flags |= CP_ICASE;
diff --git a/src/nvim/keycodes.c b/src/nvim/keycodes.c
index 2b00d371f0..a3763ea9bb 100644
--- a/src/nvim/keycodes.c
+++ b/src/nvim/keycodes.c
@@ -650,7 +650,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
     if (*bp == '-') {
       last_dash = bp;
       if (bp + 1 <= end) {
-        l = utfc_ptr2len_len(bp + 1, (int)(end - bp) + 1);
+        l = utfc_ptr2len_len((char *)bp + 1, (int)(end - bp) + 1);
         // Anything accepted, like <C-?>.
         // <C-"> or <M-"> are not special in strings as " is
         // the string delimiter. With a backslash it works: <M-\">
@@ -665,7 +665,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
     if (end - bp > 3 && bp[0] == 't' && bp[1] == '_') {
       bp += 3;  // skip t_xx, xx may be '-' or '>'
     } else if (end - bp > 4 && STRNICMP(bp, "char-", 5) == 0) {
-      vim_str2nr(bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, true);
+      vim_str2nr((char *)bp + 5, NULL, &l, STR2NR_ALL, NULL, NULL, 0, true);
       if (l == 0) {
         emsg(_(e_invarg));
         return 0;
@@ -695,7 +695,7 @@ int find_special_key(const char_u **const srcp, const size_t src_len, int *const
       if (STRNICMP(last_dash + 1, "char-", 5) == 0
           && ascii_isdigit(last_dash[6])) {
         // <Char-123> or <Char-033> or <Char-0x33>
-        vim_str2nr(last_dash + 6, NULL, &l, STR2NR_ALL, NULL, &n, 0, true);
+        vim_str2nr((char *)last_dash + 6, NULL, &l, STR2NR_ALL, NULL, &n, 0, true);
         if (l == 0) {
           emsg(_(e_invarg));
           return 0;
@@ -993,7 +993,7 @@ char *replace_termcodes(const char *const from, const size_t from_len, char **co
     }
 
     // skip multibyte char correctly
-    for (i = utfc_ptr2len_len(src, (int)(end - src) + 1); i > 0; i--) {
+    for (i = utfc_ptr2len_len((char *)src, (int)(end - src) + 1); i > 0; i--) {
       // If the character is K_SPECIAL, replace it with K_SPECIAL
       // KS_SPECIAL KE_FILLER.
       if (*src == K_SPECIAL) {
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 7eab37e797..c6d08eb689 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -800,31 +800,29 @@ void clrallmarks(buf_T *const buf)
 char_u *fm_getname(fmark_T *fmark, int lead_len)
 {
   if (fmark->fnum == curbuf->b_fnum) {              // current buffer
-    return mark_line(&(fmark->mark), lead_len);
+    return (char_u *)mark_line(&(fmark->mark), lead_len);
   }
   return (char_u *)buflist_nr2name(fmark->fnum, false, true);
 }
 
-/*
- * Return the line at mark "mp".  Truncate to fit in window.
- * The returned string has been allocated.
- */
-static char_u *mark_line(pos_T *mp, int lead_len)
+/// Return the line at mark "mp".  Truncate to fit in window.
+/// The returned string has been allocated.
+static char *mark_line(pos_T *mp, int lead_len)
 {
-  char_u *s, *p;
+  char *s, *p;
   int len;
 
   if (mp->lnum == 0 || mp->lnum > curbuf->b_ml.ml_line_count) {
-    return vim_strsave((char_u *)"-invalid-");
+    return xstrdup("-invalid-");
   }
   assert(Columns >= 0);
   // Allow for up to 5 bytes per character.
-  s = vim_strnsave((char_u *)skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
+  s = xstrnsave(skipwhite(ml_get(mp->lnum)), (size_t)Columns * 5);
 
   // Truncate the line to fit it in the window
   len = 0;
   for (p = s; *p != NUL; MB_PTR_ADV(p)) {
-    len += ptr2cells((char *)p);
+    len += ptr2cells(p);
     if (len >= Columns - lead_len) {
       break;
     }
@@ -908,7 +906,7 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
              && p->lnum != 0) {
     // don't output anything if 'q' typed at --more-- prompt
     if (name == NULL && current) {
-      name = mark_line(p, 15);
+      name = (char_u *)mark_line(p, 15);
       mustfree = true;
     }
     if (!message_filtered((char *)name)) {
@@ -1094,7 +1092,7 @@ void ex_changes(exarg_T *eap)
               (long)curbuf->b_changelist[i].mark.lnum,
               curbuf->b_changelist[i].mark.col);
       msg_outtrans((char *)IObuff);
-      name = mark_line(&curbuf->b_changelist[i].mark, 17);
+      name = (char_u *)mark_line(&curbuf->b_changelist[i].mark, 17);
       msg_outtrans_attr((char *)name, HL_ATTR(HLF_D));
       xfree(name);
       os_breakcheck();
diff --git a/src/nvim/match.c b/src/nvim/match.c
index 48f0d0fc05..b6d700b148 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -1159,9 +1159,9 @@ void f_matchdelete(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// skipping commands to find the next command.
 void ex_match(exarg_T *eap)
 {
-  char_u *p;
-  char_u *g = NULL;
-  char_u *end;
+  char *p;
+  char *g = NULL;
+  char *end;
   int c;
   int id;
 
@@ -1178,25 +1178,25 @@ void ex_match(exarg_T *eap)
   }
 
   if (ends_excmd(*eap->arg)) {
-    end = (char_u *)eap->arg;
+    end = eap->arg;
   } else if ((STRNICMP(eap->arg, "none", 4) == 0
               && (ascii_iswhite(eap->arg[4]) || ends_excmd(eap->arg[4])))) {
-    end = (char_u *)eap->arg + 4;
+    end = eap->arg + 4;
   } else {
-    p = (char_u *)skiptowhite(eap->arg);
+    p = skiptowhite(eap->arg);
     if (!eap->skip) {
-      g = vim_strnsave((char_u *)eap->arg, (size_t)(p - (char_u *)eap->arg));
+      g = xstrnsave(eap->arg, (size_t)(p - eap->arg));
     }
-    p = (char_u *)skipwhite((char *)p);
+    p = skipwhite(p);
     if (*p == NUL) {
       // There must be two arguments.
       xfree(g);
       semsg(_(e_invarg2), eap->arg);
       return;
     }
-    end = (char_u *)skip_regexp((char *)p + 1, *p, true, NULL);
+    end = skip_regexp(p + 1, *p, true, NULL);
     if (!eap->skip) {
-      if (*end != NUL && !ends_excmd(*skipwhite((char *)end + 1))) {
+      if (*end != NUL && !ends_excmd(*skipwhite(end + 1))) {
         xfree(g);
         eap->errmsg = ex_errmsg(e_trailing_arg, (const char *)end);
         return;
@@ -1207,13 +1207,13 @@ void ex_match(exarg_T *eap)
         return;
       }
 
-      c = *end;
+      c = (uint8_t)(*end);
       *end = NUL;
       match_add(curwin, (const char *)g, (const char *)p + 1, 10, id,
                 NULL, NULL);
       xfree(g);
-      *end = (char_u)c;
+      *end = (char)c;
     }
   }
-  eap->nextcmd = find_nextcmd((char *)end);
+  eap->nextcmd = find_nextcmd(end);
 }
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 947594be4f..0a4182a892 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -587,7 +587,7 @@ size_t mb_string2cells_len(const char *str, size_t size)
   size_t clen = 0;
 
   for (const char_u *p = (char_u *)str; *p != NUL && p < (char_u *)str + size;
-       p += utfc_ptr2len_len(p, (int)size + (int)(p - (char_u *)str))) {
+       p += utfc_ptr2len_len((char *)p, (int)size + (int)(p - (char_u *)str))) {
     clen += (size_t)utf_ptr2cells((char *)p);
   }
 
@@ -727,12 +727,10 @@ int mb_cptr2char_adv(const char_u **pp)
   return c;
 }
 
-/*
- * Check if the character pointed to by "p2" is a composing character when it
- * comes after "p1".  For Arabic sometimes "ab" is replaced with "c", which
- * behaves like a composing character.
- */
-bool utf_composinglike(const char_u *p1, const char_u *p2)
+/// Check if the character pointed to by "p2" is a composing character when it
+/// comes after "p1".  For Arabic sometimes "ab" is replaced with "c", which
+/// behaves like a composing character.
+bool utf_composinglike(const char *p1, const char *p2)
 {
   int c2;
 
@@ -765,7 +763,7 @@ int utfc_ptr2char(const char *p_in, int *pcc)
   // Only accept a composing char when the first char isn't illegal.
   if ((len > 1 || *p < 0x80)
       && p[len] >= 0x80
-      && utf_composinglike(p, p + len)) {
+      && utf_composinglike((char *)p, (char *)p + len)) {
     int cc = utf_ptr2char((char *)p + len);
     for (;;) {
       pcc[i++] = cc;
@@ -809,7 +807,7 @@ int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
       int len_cc = utf_ptr2len_len(p + len, maxlen - len);
       safe = len_cc > 1 && len_cc <= maxlen - len;
       if (!safe || (pcc[i] = utf_ptr2char((char *)p + len)) < 0x80
-          || !(i == 0 ? utf_composinglike(p, p + len) : utf_iscomposing(pcc[i]))) {
+          || !(i == 0 ? utf_composinglike((char *)p, (char *)p + len) : utf_iscomposing(pcc[i]))) {
         break;
       }
       len += len_cc;
@@ -916,7 +914,7 @@ int utfc_ptr2len(const char *const p_in)
   // skip all of them (otherwise the cursor would get stuck).
   int prevlen = 0;
   for (;;) {
-    if (p[len] < 0x80 || !utf_composinglike(p + prevlen, p + len)) {
+    if (p[len] < 0x80 || !utf_composinglike((char *)p + prevlen, (char *)p + len)) {
       return len;
     }
 
@@ -926,13 +924,11 @@ int utfc_ptr2len(const char *const p_in)
   }
 }
 
-/*
- * Return the number of bytes the UTF-8 encoding of the character at "p[size]"
- * takes.  This includes following composing characters.
- * Returns 0 for an empty string.
- * Returns 1 for an illegal char or an incomplete byte sequence.
- */
-int utfc_ptr2len_len(const char_u *p, int size)
+/// Return the number of bytes the UTF-8 encoding of the character at "p[size]"
+/// takes.  This includes following composing characters.
+/// Returns 0 for an empty string.
+/// Returns 1 for an illegal char or an incomplete byte sequence.
+int utfc_ptr2len_len(const char *p, int size)
 {
   int len;
   int prevlen;
@@ -940,15 +936,15 @@ int utfc_ptr2len_len(const char_u *p, int size)
   if (size < 1 || *p == NUL) {
     return 0;
   }
-  if (p[0] < 0x80 && (size == 1 || p[1] < 0x80)) {  // be quick for ASCII
+  if ((uint8_t)p[0] < 0x80 && (size == 1 || (uint8_t)p[1] < 0x80)) {  // be quick for ASCII
     return 1;
   }
 
   // Skip over first UTF-8 char, stopping at a NUL byte.
-  len = utf_ptr2len_len(p, size);
+  len = utf_ptr2len_len((char_u *)p, size);
 
   // Check for illegal byte and incomplete byte sequence.
-  if ((len == 1 && p[0] >= 0x80) || len > size) {
+  if ((len == 1 && (uint8_t)p[0] >= 0x80) || len > size) {
     return 1;
   }
 
@@ -960,7 +956,7 @@ int utfc_ptr2len_len(const char_u *p, int size)
   while (len < size) {
     int len_next_char;
 
-    if (p[len] < 0x80) {
+    if ((uint8_t)p[len] < 0x80) {
       break;
     }
 
@@ -968,7 +964,7 @@ int utfc_ptr2len_len(const char_u *p, int size)
      * Next character length should not go beyond size to ensure that
      * utf_composinglike(...) does not read beyond size.
      */
-    len_next_char = utf_ptr2len_len(p + len, size - len);
+    len_next_char = utf_ptr2len_len((char_u *)p + len, size - len);
     if (len_next_char > size - len) {
       break;
     }
@@ -2420,7 +2416,7 @@ static char_u *iconv_string(const vimconv_T *const vcp, char_u *str, size_t slen
       if (utf_ptr2cells(from) > 1) {
         *to++ = '?';
       }
-      l = utfc_ptr2len_len((const char_u *)from, (int)fromlen);
+      l = utfc_ptr2len_len(from, (int)fromlen);
       from += l;
       fromlen -= (size_t)l;
     } else if (ICONV_ERRNO != ICONV_E2BIG) {
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index a30a98d6e9..cd143bd52c 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -735,12 +735,12 @@ void ml_recover(bool checkext)
 {
   buf_T *buf = NULL;
   memfile_T *mfp = NULL;
-  char_u *fname;
-  char_u *fname_used = NULL;
+  char *fname;
+  char *fname_used = NULL;
   bhdr_T *hp = NULL;
   ZERO_BL *b0p;
   int b0_ff;
-  char_u *b0_fenc = NULL;
+  char *b0_fenc = NULL;
   PTR_BL *pp;
   DATA_BL *dp;
   infoptr_T *ip;
@@ -748,7 +748,7 @@ void ml_recover(bool checkext)
   int len;
   bool directly;
   linenr_T lnum;
-  char_u *p;
+  char *p;
   int i;
   long error;
   bool cannot_open;
@@ -770,9 +770,9 @@ void ml_recover(bool checkext)
 
   // If the file name ends in ".s[a-w][a-z]" we assume this is the swap file.
   // Otherwise a search is done to find the swap file(s).
-  fname = (char_u *)curbuf->b_fname;
+  fname = curbuf->b_fname;
   if (fname == NULL) {              // When there is no file name
-    fname = (char_u *)"";
+    fname = "";
   }
   len = (int)STRLEN(fname);
   if (checkext && len >= 4
@@ -780,12 +780,12 @@ void ml_recover(bool checkext)
       && vim_strchr("abcdefghijklmnopqrstuvw", TOLOWER_ASC(fname[len - 2])) != NULL
       && ASCII_ISALPHA(fname[len - 1])) {
     directly = true;
-    fname_used = vim_strsave(fname);     // make a copy for mf_open()
+    fname_used = xstrdup(fname);     // make a copy for mf_open()
   } else {
     directly = false;
 
     // count the number of matching swap files
-    len = recover_names(fname, false, 0, NULL);
+    len = recover_names((char_u *)fname, false, 0, NULL);
     if (len == 0) {                 // no swap files found
       semsg(_("E305: No swap file found for %s"), fname);
       goto theend;
@@ -794,7 +794,7 @@ void ml_recover(bool checkext)
       i = 1;
     } else {                          // several swap files found, choose
       // list the names of the swap files
-      (void)recover_names(fname, true, 0, NULL);
+      (void)recover_names((char_u *)fname, true, 0, NULL);
       msg_putchar('\n');
       msg_puts(_("Enter number of swap file to use (0 to quit): "));
       i = get_number(false, NULL);
@@ -803,7 +803,7 @@ void ml_recover(bool checkext)
       }
     }
     // get the swap file name that will be used
-    (void)recover_names(fname, false, i, &fname_used);
+    (void)recover_names((char_u *)fname, false, i, (char_u **)&fname_used);
   }
   if (fname_used == NULL) {
     goto theend;  // user chose invalid number.
@@ -833,9 +833,9 @@ void ml_recover(bool checkext)
   /*
    * open the memfile from the old swap file
    */
-  p = vim_strsave(fname_used);  // save "fname_used" for the message:
-                                // mf_open() will consume "fname_used"!
-  mfp = mf_open((char *)fname_used, O_RDONLY);
+  p = xstrdup(fname_used);  // save "fname_used" for the message:
+  // mf_open() will consume "fname_used"!
+  mfp = mf_open(fname_used, O_RDONLY);
   fname_used = p;
   if (mfp == NULL || mfp->mf_fd < 0) {
     semsg(_("E306: Cannot open %s"), fname_used);
@@ -962,8 +962,8 @@ void ml_recover(bool checkext)
   if (b0p->b0_flags & B0_HAS_FENC) {
     int fnsize = B0_FNAME_SIZE_NOCRYPT;
 
-    for (p = b0p->b0_fname + fnsize; p > b0p->b0_fname && p[-1] != NUL; p--) {}
-    b0_fenc = vim_strnsave(p, (size_t)(b0p->b0_fname + fnsize - p));
+    for (p = (char *)b0p->b0_fname + fnsize; (char_u *)p > b0p->b0_fname && p[-1] != NUL; p--) {}
+    b0_fenc = xstrnsave(p, (size_t)(b0p->b0_fname + fnsize - (char_u *)p));
   }
 
   mf_put(mfp, hp, false, false);        // release block 0
@@ -991,7 +991,7 @@ void ml_recover(bool checkext)
     set_fileformat(b0_ff - 1, OPT_LOCAL);
   }
   if (b0_fenc != NULL) {
-    set_option_value_give_err("fenc", 0L, (char *)b0_fenc, OPT_LOCAL);
+    set_option_value_give_err("fenc", 0L, b0_fenc, OPT_LOCAL);
     xfree(b0_fenc);
   }
   unchanged(curbuf, true, true);
@@ -1133,12 +1133,12 @@ void ml_recover(bool checkext)
             txt_start = (dp->db_index[i] & DB_INDEX_MASK);
             if (txt_start <= (int)HEADER_SIZE
                 || txt_start >= (int)dp->db_txt_end) {
-              p = (char_u *)"???";
+              p = "???";
               error++;
             } else {
-              p = (char_u *)dp + txt_start;
+              p = (char *)dp + txt_start;
             }
-            ml_append(lnum++, (char *)p, (colnr_T)0, true);
+            ml_append(lnum++, p, (colnr_T)0, true);
           }
           if (has_error) {
             ml_append(lnum++, _("???END"), (colnr_T)0, true);
@@ -1177,7 +1177,7 @@ void ml_recover(bool checkext)
   } else {
     for (idx = 1; idx <= lnum; idx++) {
       // Need to copy one line, fetching the other one may flush it.
-      p = vim_strsave((char_u *)ml_get(idx));
+      p = xstrdup(ml_get(idx));
       i = STRCMP(p, ml_get(idx + lnum));
       xfree(p);
       if (i != 0) {
diff --git a/src/nvim/message.c b/src/nvim/message.c
index e7959c73c6..87cfe06edc 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1581,7 +1581,7 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
    */
   while (--len >= 0 && !got_int) {
     // Don't include composing chars after the end.
-    mb_l = utfc_ptr2len_len((char_u *)str, len + 1);
+    mb_l = utfc_ptr2len_len(str, len + 1);
     if (mb_l > 1) {
       c = utf_ptr2char(str);
       if (vim_isprintc(c)) {
@@ -2219,7 +2219,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
       if (has_last_char) {
         if (maxlen >= 0) {
           // Avoid including composing chars after the end.
-          l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
+          l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
         } else {
           l = utfc_ptr2len(s);
         }
@@ -2316,7 +2316,7 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
       cw = utf_ptr2cells(s);
       if (maxlen >= 0) {
         // avoid including composing chars after the end
-        l = utfc_ptr2len_len((char_u *)s, (int)((str + maxlen) - s));
+        l = utfc_ptr2len_len(s, (int)((str + maxlen) - s));
       } else {
         l = utfc_ptr2len(s);
       }
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 17b79e27c1..66038d0c3c 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -3134,7 +3134,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
   } else {
     par_pos = curwin->w_cursor;
     while (curwin->w_cursor.lnum > 1
-           && *skipwhite((char *)get_cursor_line_ptr()) != NUL) {
+           && *skipwhite(get_cursor_line_ptr()) != NUL) {
       curwin->w_cursor.lnum--;
     }
   }
@@ -3171,13 +3171,13 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
       }
       break;
     }
-    if (get_leader_len((char *)get_cursor_line_ptr(), NULL, false, true) > 0) {
+    if (get_leader_len(get_cursor_line_ptr(), NULL, false, true) > 0) {
       // Ignore this line, continue at start of next line.
       curwin->w_cursor.lnum++;
       curwin->w_cursor.col = 0;
       continue;
     }
-    bool valid = is_ident(get_cursor_line_ptr(), curwin->w_cursor.col);
+    bool valid = is_ident((char_u *)get_cursor_line_ptr(), curwin->w_cursor.col);
 
     // If the current position is not a valid identifier and a previous match is
     // present, favor that one instead.
@@ -3232,7 +3232,7 @@ bool find_decl(char_u *ptr, size_t len, bool locally, bool thisblock, int flags_
 /// @return  true if able to move cursor, false otherwise.
 static bool nv_screengo(oparg_T *oap, int dir, long dist)
 {
-  int linelen = linetabsize(get_cursor_line_ptr());
+  int linelen = linetabsize((char_u *)get_cursor_line_ptr());
   bool retval = true;
   bool atend = false;
   int n;
@@ -3303,7 +3303,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
           }
           curwin->w_cursor.lnum--;
 
-          linelen = linetabsize(get_cursor_line_ptr());
+          linelen = linetabsize((char_u *)get_cursor_line_ptr());
           if (linelen > width1) {
             int w = (((linelen - width1 - 1) / width2) + 1) * width2;
             assert(curwin->w_curswant <= INT_MAX - w);
@@ -3339,7 +3339,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
           if (curwin->w_curswant >= width1) {
             curwin->w_curswant -= width2;
           }
-          linelen = linetabsize(get_cursor_line_ptr());
+          linelen = linetabsize((char_u *)get_cursor_line_ptr());
         }
       }
     }
@@ -4294,7 +4294,7 @@ static void nv_ident(cmdarg_T *cap)
     // Call setpcmark() first, so "*``" puts the cursor back where
     // it was.
     setpcmark();
-    curwin->w_cursor.col = (colnr_T)(ptr - (char *)get_cursor_line_ptr());
+    curwin->w_cursor.col = (colnr_T)(ptr - get_cursor_line_ptr());
 
     if (!g_cmd && vim_iswordp((char_u *)ptr)) {
       STRCPY(buf, "\\<");
@@ -4382,13 +4382,13 @@ static void nv_ident(cmdarg_T *cap)
   // Execute the command.
   if (cmdchar == '*' || cmdchar == '#') {
     if (!g_cmd
-        && vim_iswordp(mb_prevptr(get_cursor_line_ptr(), (char_u *)ptr))) {
+        && vim_iswordp(mb_prevptr((char_u *)get_cursor_line_ptr(), (char_u *)ptr))) {
       STRCAT(buf, "\\>");
     }
 
     // put pattern in search history
     init_history();
-    add_to_history(HIST_SEARCH, (char_u *)buf, true, NUL);
+    add_to_history(HIST_SEARCH, buf, true, NUL);
 
     (void)normal_search(cap, cmdchar == '*' ? '/' : '?', buf, 0, NULL);
   } else {
@@ -4425,7 +4425,7 @@ bool get_visual_text(cmdarg_T *cap, char **pp, size_t *lenp)
     return false;
   }
   if (VIsual_mode == 'V') {
-    *pp = (char *)get_cursor_line_ptr();
+    *pp = get_cursor_line_ptr();
     *lenp = STRLEN(*pp);
   } else {
     if (lt(curwin->w_cursor, VIsual)) {
@@ -6068,7 +6068,7 @@ static void nv_g_underscore_cmd(cmdarg_T *cap)
     return;
   }
 
-  char_u *ptr = get_cursor_line_ptr();
+  char_u *ptr = (char_u *)get_cursor_line_ptr();
 
   // In Visual mode we may end up after the line.
   if (curwin->w_cursor.col > 0 && ptr[curwin->w_cursor.col] == NUL) {
@@ -6279,7 +6279,7 @@ static void nv_g_cmd(cmdarg_T *cap)
   case 'M':
     oap->motion_type = kMTCharWise;
     oap->inclusive = false;
-    i = linetabsize(get_cursor_line_ptr());
+    i = linetabsize((char_u *)get_cursor_line_ptr());
     if (cap->count0 > 0 && cap->count0 <= 100) {
       coladvance((colnr_T)(i * cap->count0 / 100));
     } else {
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index d2321be4a4..01fd4bb9a7 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -225,7 +225,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
   }
 
   for (i = oap->line_count - 1; i >= 0; i--) {
-    first_char = *get_cursor_line_ptr();
+    first_char = (uint8_t)(*get_cursor_line_ptr());
     if (first_char == NUL) {  // empty line
       curwin->w_cursor.col = 0;
     } else if (oap->motion_type == kMTBlockWise) {
@@ -356,7 +356,7 @@ static void shift_block(oparg_T *oap, int amount)
     return;   // multiplication overflow
   }
 
-  char_u *const oldp = get_cursor_line_ptr();
+  char_u *const oldp = (char_u *)get_cursor_line_ptr();
 
   int startcol, oldlen, newlen;
 
@@ -668,7 +668,7 @@ void op_reindent(oparg_T *oap, Indenter how)
       // indented, unless there is only one line.
       if (i != oap->line_count - 1 || oap->line_count == 1
           || how != get_lisp_indent) {
-        l = (char_u *)skipwhite((char *)get_cursor_line_ptr());
+        l = (char_u *)skipwhite(get_cursor_line_ptr());
         if (*l == NUL) {                      // empty or blank line
           amount = 0;
         } else {
@@ -1735,7 +1735,7 @@ int op_delete(oparg_T *oap)
       if (virtual_op) {
         // fix up things for virtualedit-delete:
         // break the tabs which are going to get in our way
-        char_u *curline = get_cursor_line_ptr();
+        char_u *curline = (char_u *)get_cursor_line_ptr();
         int len = (int)STRLEN(curline);
 
         if (oap->end.coladd != 0
@@ -1926,7 +1926,7 @@ static int op_replace(oparg_T *oap, int c)
       num_chars = numc;
       numc *= utf_char2len(c);
 
-      oldp = get_cursor_line_ptr();
+      oldp = (char_u *)get_cursor_line_ptr();
       oldlen = (int)STRLEN(oldp);
 
       size_t newp_size = (size_t)bd.textcol + (size_t)bd.startspaces;
@@ -2240,7 +2240,7 @@ bool swapchar(int op_type, pos_T *pos)
 void op_insert(oparg_T *oap, long count1)
 {
   long ins_len, pre_textlen = 0;
-  char_u *firstline, *ins_text;
+  char *firstline, *ins_text;
   colnr_T ind_pre_col = 0, ind_post_col;
   int ind_pre_vcol = 0, ind_post_vcol = 0;
   struct block_def bd;
@@ -2281,7 +2281,7 @@ void op_insert(oparg_T *oap, long count1)
     // Get indent information
     ind_pre_col = (colnr_T)getwhitecols_curline();
     ind_pre_vcol = get_indent();
-    firstline = (char_u *)ml_get(oap->start.lnum) + bd.textcol;
+    firstline = ml_get(oap->start.lnum) + bd.textcol;
 
     if (oap->op_type == OP_APPEND) {
       firstline += bd.textlen;
@@ -2413,7 +2413,7 @@ void op_insert(oparg_T *oap, long count1)
      * Subsequent calls to ml_get() flush the firstline data - take a
      * copy of the required string.
      */
-    firstline = (char_u *)ml_get(oap->start.lnum);
+    firstline = ml_get(oap->start.lnum);
     const size_t len = STRLEN(firstline);
     colnr_T add = bd.textcol;
     colnr_T offset = 0;  // offset when cursor was moved in insert mode
@@ -2438,10 +2438,10 @@ void op_insert(oparg_T *oap, long count1)
     }
     ins_len = (long)STRLEN(firstline) - pre_textlen - offset;
     if (pre_textlen >= 0 && ins_len > 0) {
-      ins_text = vim_strnsave(firstline, (size_t)ins_len);
+      ins_text = xstrnsave(firstline, (size_t)ins_len);
       // block handled here
       if (u_save(oap->start.lnum, (linenr_T)(oap->end.lnum + 1)) == OK) {
-        block_insert(oap, ins_text, (oap->op_type == OP_INSERT), &bd);
+        block_insert(oap, (char_u *)ins_text, (oap->op_type == OP_INSERT), &bd);
       }
 
       curwin->w_cursor.col = oap->start.col;
@@ -2934,9 +2934,9 @@ static void do_autocmd_textyankpost(oparg_T *oap, yankreg_T *reg)
 /// @param dir    BACKWARD for 'P', FORWARD for 'p'
 void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
 {
-  char_u *ptr;
-  char_u *newp;
-  char_u *oldp;
+  char *ptr;
+  char *newp;
+  char *oldp;
   int yanklen;
   size_t totlen = 0;  // init for gcc
   linenr_T lnum = 0;
@@ -3082,13 +3082,13 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
        * Loop twice: count the number of lines and save them. */
       for (;;) {
         y_size = 0;
-        ptr = (char_u *)insert_string;
+        ptr = insert_string;
         while (ptr != NULL) {
           if (y_array != NULL) {
-            y_array[y_size] = (char *)ptr;
+            y_array[y_size] = ptr;
           }
           y_size++;
-          ptr = (char_u *)vim_strchr((char *)ptr, '\n');
+          ptr = vim_strchr(ptr, '\n');
           if (ptr != NULL) {
             if (y_array != NULL) {
               *ptr = NUL;
@@ -3136,12 +3136,12 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       if (u_save_cursor() == FAIL) {
         goto end;
       }
-      char_u *p = get_cursor_pos_ptr();
+      char *p = (char *)get_cursor_pos_ptr();
       if (dir == FORWARD && *p != NUL) {
         MB_PTR_ADV(p);
       }
-      ptr = vim_strsave(p);
-      ml_append(curwin->w_cursor.lnum, (char *)ptr, (colnr_T)0, false);
+      ptr = xstrdup(p);
+      ml_append(curwin->w_cursor.lnum, ptr, (colnr_T)0, false);
       xfree(ptr);
 
       oldp = get_cursor_line_ptr();
@@ -3149,8 +3149,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       if (dir == FORWARD && *p != NUL) {
         MB_PTR_ADV(p);
       }
-      ptr = vim_strnsave(oldp, (size_t)(p - oldp));
-      ml_replace(curwin->w_cursor.lnum, (char *)ptr, false);
+      ptr = xstrnsave(oldp, (size_t)(p - oldp));
+      ml_replace(curwin->w_cursor.lnum, ptr, false);
       nr_lines++;
       dir = FORWARD;
     }
@@ -3298,8 +3298,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       oldp = get_cursor_line_ptr();
       oldlen = STRLEN(oldp);
       chartabsize_T cts;
-      init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0,
-                           (char *)oldp, (char *)oldp);
+      init_chartabsize_arg(&cts, curwin, curwin->w_cursor.lnum, 0, oldp, oldp);
 
       while (cts.cts_vcol < col && *cts.cts_ptr != NUL) {
         // Count a tab for what it's worth (if list mode not on)
@@ -3307,7 +3306,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         cts.cts_vcol += incr;
       }
       vcol = cts.cts_vcol;
-      ptr = (char_u *)cts.cts_ptr;
+      ptr = cts.cts_ptr;
       bd.textcol = (colnr_T)(ptr - oldp);
       clear_chartabsize_arg(&cts);
 
@@ -3320,7 +3319,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         bd.startspaces = incr - bd.endspaces;
         bd.textcol--;
         delcount = 1;
-        bd.textcol -= utf_head_off((char *)oldp, (char *)oldp + bd.textcol);
+        bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
         if (oldp[bd.textcol] != TAB) {
           /* Only a Tab can be split into spaces.  Other
            * characters will have to be moved to after the
@@ -3356,9 +3355,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         break;
       }
 
-      totlen = (size_t)(count * (yanklen + spaces)
-                        + bd.startspaces + bd.endspaces);
-      newp = (char_u *)xmalloc(totlen + oldlen + 1);
+      totlen = (size_t)(count * (yanklen + spaces) + bd.startspaces + bd.endspaces);
+      newp = xmalloc(totlen + oldlen + 1);
 
       // copy part up to cursor to new line
       ptr = newp;
@@ -3391,7 +3389,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       int columns = (int)oldlen - bd.textcol - delcount + 1;
       assert(columns >= 0);
       memmove(ptr, oldp + bd.textcol + delcount, (size_t)columns);
-      ml_replace(curwin->w_cursor.lnum, (char *)newp, false);
+      ml_replace(curwin->w_cursor.lnum, newp, false);
       extmark_splice_cols(curbuf, (int)curwin->w_cursor.lnum - 1, bd.textcol,
                           delcount, (int)totlen + lines_appended, kExtmarkUndo);
 
@@ -3482,7 +3480,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       } else {
         totlen = (size_t)(count * yanklen);
         do {
-          oldp = (char_u *)ml_get(lnum);
+          oldp = ml_get(lnum);
           oldlen = STRLEN(oldp);
           if (lnum > start_lnum) {
             pos_T pos = {
@@ -3498,7 +3496,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
             lnum++;
             continue;
           }
-          newp = (char_u *)xmalloc(totlen + oldlen + 1);
+          newp = xmalloc(totlen + oldlen + 1);
           memmove(newp, oldp, (size_t)col);
           ptr = newp + col;
           for (i = 0; i < (size_t)count; i++) {
@@ -3506,10 +3504,10 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
             ptr += yanklen;
           }
           STRMOVE(ptr, oldp + col);
-          ml_replace(lnum, (char *)newp, false);
+          ml_replace(lnum, newp, false);
 
           // compute the byte offset for the last character
-          first_byte_off = utf_head_off((char *)newp, (char *)ptr - 1);
+          first_byte_off = utf_head_off(newp, ptr - 1);
 
           // Place cursor on last putted char.
           if (lnum == curwin->w_cursor.lnum) {
@@ -3553,23 +3551,23 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           // First insert y_array[size - 1] in front of second line.
           // Then append y_array[0] to first line.
           lnum = new_cursor.lnum;
-          ptr = (char_u *)ml_get(lnum) + col;
+          ptr = ml_get(lnum) + col;
           totlen = STRLEN(y_array[y_size - 1]);
-          newp = (char_u *)xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
+          newp = xmalloc((size_t)(STRLEN(ptr) + totlen + 1));
           STRCPY(newp, y_array[y_size - 1]);
           STRCAT(newp, ptr);
           // insert second line
-          ml_append(lnum, (char *)newp, (colnr_T)0, false);
+          ml_append(lnum, newp, (colnr_T)0, false);
           new_lnum++;
           xfree(newp);
 
-          oldp = (char_u *)ml_get(lnum);
-          newp = (char_u *)xmalloc((size_t)col + (size_t)yanklen + 1);
+          oldp = ml_get(lnum);
+          newp = xmalloc((size_t)col + (size_t)yanklen + 1);
           // copy first part of line
           memmove(newp, oldp, (size_t)col);
           // append to first line
           memmove(newp + col, y_array[0], (size_t)yanklen + 1);
-          ml_replace(lnum, (char *)newp, false);
+          ml_replace(lnum, newp, false);
 
           curwin->w_cursor.lnum = lnum;
           i = 1;
@@ -3587,7 +3585,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
           if (flags & PUT_FIXINDENT) {
             old_pos = curwin->w_cursor;
             curwin->w_cursor.lnum = lnum;
-            ptr = (char_u *)ml_get(lnum);
+            ptr = ml_get(lnum);
             if (cnt == count && i == y_size - 1) {
               lendiff = (int)STRLEN(ptr);
             }
@@ -4656,7 +4654,7 @@ int do_addsub(int op_type, pos_T *pos, int length, linenr_T Prenum1)
                 : length);
     }
 
-    vim_str2nr(ptr + col, &pre, &length,
+    vim_str2nr((char *)ptr + col, &pre, &length,
                0 + (do_bin ? STR2NR_BIN : 0)
                + (do_oct ? STR2NR_OCT : 0)
                + (do_hex ? STR2NR_HEX : 0),
@@ -5504,7 +5502,7 @@ void cursor_pos_info(dict_T *dict)
                        (int64_t)byte_count_cursor, (int64_t)byte_count);
         }
       } else {
-        p = get_cursor_line_ptr();
+        p = (char_u *)get_cursor_line_ptr();
         validate_virtcol();
         col_print((char *)buf1, sizeof(buf1), (int)curwin->w_cursor.col + 1,
                   (int)curwin->w_virtcol + 1);
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 269a21b512..f8b7d96305 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -664,8 +664,8 @@ void set_init_3(void)
     : !(options[idx_sp].flags & P_WAS_SET);
 
   size_t len = 0;
-  char_u *p = (char_u *)invocation_path_tail(p_sh, &len);
-  p = vim_strnsave(p, len);
+  char *p = (char *)invocation_path_tail(p_sh, &len);
+  p = xstrnsave(p, len);
 
   {
     //
@@ -1131,7 +1131,7 @@ int do_set(char *arg, int opt_flags)
               }
             } else if (*arg == '-' || ascii_isdigit(*arg)) {
               // Allow negative, octal and hex numbers.
-              vim_str2nr((char_u *)arg, NULL, &i, STR2NR_ALL, &value, NULL, 0, true);
+              vim_str2nr(arg, NULL, &i, STR2NR_ALL, &value, NULL, 0, true);
               if (i == 0 || (arg[i] != NUL && !ascii_iswhite(arg[i]))) {
                 errmsg = e_number_required_after_equal;
                 goto skip;
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 35390e3dc1..f3b3c1dfbf 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -64,7 +64,7 @@ static void save_patterns(int num_pat, char **pat, int *num_file, char ***file)
 static bool have_wildcard(int num, char **file)
 {
   for (int i = 0; i < num; i++) {
-    if (path_has_wildcard((char_u *)file[i])) {
+    if (path_has_wildcard(file[i])) {
       return true;
     }
   }
@@ -1106,7 +1106,7 @@ static void out_data_append_to_screen(char *output, size_t *count, bool eof)
       //    incomplete UTF-8 sequence that could be composing with the last
       //    complete sequence.
       // This will be corrected when we switch to vterm based implementation
-      int i = *p ? utfc_ptr2len_len((char_u *)p, (int)(end - p)) : 1;
+      int i = *p ? utfc_ptr2len_len(p, (int)(end - p)) : 1;
       if (!eof && i == 1 && utf8len_tab_zero[*(uint8_t *)p] > (end - p)) {
         *count = (size_t)(p - output);
         goto end;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 8973d4dfdb..e6de5388e0 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -509,7 +509,7 @@ char *save_abs_path(const char *name)
 /// @param p  The path to expand.
 /// @returns Unix: True if it contains one of "?[{`'$".
 /// @returns Windows: True if it contains one of "*?$[".
-bool path_has_wildcard(const char_u *p)
+bool path_has_wildcard(const char *p)
   FUNC_ATTR_NONNULL_ALL
 {
   for (; *p; MB_PTR_ADV(p)) {
@@ -1252,7 +1252,7 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
     p = (char_u *)pat[i];
 
     if (vim_backtick(p)) {
-      add_pat = expand_backtick(&ga, p, flags);
+      add_pat = expand_backtick(&ga, (char *)p, flags);
       if (add_pat == -1) {
         recursive = false;
         FreeWild(ga.ga_len, ga.ga_data);
@@ -1367,14 +1367,14 @@ static int vim_backtick(char_u *p)
 /// Returns number of file names found, -1 if an error is encountered.
 ///
 /// @param flags  EW_* flags
-static int expand_backtick(garray_T *gap, char_u *pat, int flags)
+static int expand_backtick(garray_T *gap, char *pat, int flags)
 {
   char *p;
   char *buffer;
   int cnt = 0;
 
   // Create the command: lop off the backticks.
-  char *cmd = (char *)vim_strnsave(pat + 1, STRLEN(pat) - 2);
+  char *cmd = xstrnsave(pat + 1, STRLEN(pat) - 2);
 
   if (*cmd == '=') {          // `={expr}`: Expand expression
     buffer = eval_to_string(cmd + 1, &p, true);
@@ -1683,17 +1683,17 @@ static char *eval_includeexpr(const char *const ptr, const size_t len)
 /// Otherwise like file_name_at_cursor().
 ///
 /// @param rel_fname  file we are searching relative to
-char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count, char_u *rel_fname)
+char *find_file_name_in_path(char *ptr, size_t len, int options, long count, char *rel_fname)
 {
-  char_u *file_name;
-  char_u *tofree = NULL;
+  char *file_name;
+  char *tofree = NULL;
 
   if (len == 0) {
     return NULL;
   }
 
   if ((options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
-    tofree = (char_u *)eval_includeexpr((char *)ptr, len);
+    tofree = eval_includeexpr(ptr, len);
     if (tofree != NULL) {
       ptr = tofree;
       len = STRLEN(ptr);
@@ -1701,8 +1701,8 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
   }
 
   if (options & FNAME_EXP) {
-    file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS, true,
-                                  rel_fname);
+    file_name = (char *)find_file_in_path((char_u *)ptr, len, options & ~FNAME_MESS, true,
+                                          (char_u *)rel_fname);
 
     /*
      * If the file could not be found in a normal way, try applying
@@ -1710,16 +1710,16 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
      */
     if (file_name == NULL
         && !(options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
-      tofree = (char_u *)eval_includeexpr((char *)ptr, len);
+      tofree = eval_includeexpr(ptr, len);
       if (tofree != NULL) {
         ptr = tofree;
         len = STRLEN(ptr);
-        file_name = find_file_in_path(ptr, len, options & ~FNAME_MESS,
-                                      true, rel_fname);
+        file_name = (char *)find_file_in_path((char_u *)ptr, len, options & ~FNAME_MESS,
+                                              true, (char_u *)rel_fname);
       }
     }
     if (file_name == NULL && (options & FNAME_MESS)) {
-      char_u c = ptr[len];
+      char c = ptr[len];
       ptr[len] = NUL;
       semsg(_("E447: Can't find file \"%s\" in path"), ptr);
       ptr[len] = c;
@@ -1729,10 +1729,11 @@ char_u *find_file_name_in_path(char_u *ptr, size_t len, int options, long count,
      * appears several times in the path. */
     while (file_name != NULL && --count > 0) {
       xfree(file_name);
-      file_name = find_file_in_path(ptr, len, options, false, rel_fname);
+      file_name =
+        (char *)find_file_in_path((char_u *)ptr, len, options, false, (char_u *)rel_fname);
     }
   } else {
-    file_name = vim_strnsave(ptr, len);
+    file_name = xstrnsave(ptr, len);
   }
 
   xfree(tofree);
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index 563d85964c..ffa68c56b2 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1623,14 +1623,14 @@ static int fill_submatch_list(int argc FUNC_ATTR_UNUSED, typval_T *argv, int arg
   // There are always 10 list items in staticList10_T.
   listitem_T *li = tv_list_first(listarg->vval.v_list);
   for (int i = 0; i < 10; i++) {
-    char_u *s = rsm.sm_match->startp[i];
+    char *s = (char *)rsm.sm_match->startp[i];
     if (s == NULL || rsm.sm_match->endp[i] == NULL) {
       s = NULL;
     } else {
-      s = vim_strnsave(s, (size_t)(rsm.sm_match->endp[i] - s));
+      s = xstrnsave(s, (size_t)(rsm.sm_match->endp[i] - (char_u *)s));
     }
     TV_LIST_ITEM_TV(li)->v_type = VAR_STRING;
-    TV_LIST_ITEM_TV(li)->vval.v_string = (char *)s;
+    TV_LIST_ITEM_TV(li)->vval.v_string = s;
     li = TV_LIST_ITEM_NEXT(argv->vval.v_list, li);
   }
   return argskip + 1;
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index 9b9b33b09f..ccf2b60da2 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -2469,7 +2469,7 @@ do_multibyte:
           // Need to get composing character too.
           for (;;) {
             l = utf_ptr2len((char *)regparse);
-            if (!utf_composinglike((char_u *)regparse, (char_u *)regparse + l)) {
+            if (!utf_composinglike(regparse, regparse + l)) {
               break;
             }
             regmbc(utf_ptr2char((char *)regparse));
@@ -3192,7 +3192,7 @@ static int regrepeat(char_u *p, long maxcount)
   case SKWORD:
   case SKWORD + ADD_NL:
     while (count < maxcount) {
-      if (vim_iswordp_buf(scan, rex.reg_buf)
+      if (vim_iswordp_buf((char *)scan, rex.reg_buf)
           && (testval || !ascii_isdigit(*scan))) {
         MB_PTR_ADV(scan);
       } else if (*scan == NUL) {
@@ -3829,7 +3829,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
           break;
 
         case KWORD:
-          if (!vim_iswordp_buf(rex.input, rex.reg_buf)) {
+          if (!vim_iswordp_buf((char *)rex.input, rex.reg_buf)) {
             status = RA_NOMATCH;
           } else {
             ADVANCE_REGINPUT();
@@ -3838,7 +3838,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
 
         case SKWORD:
           if (ascii_isdigit(*rex.input)
-              || !vim_iswordp_buf(rex.input, rex.reg_buf)) {
+              || !vim_iswordp_buf((char *)rex.input, rex.reg_buf)) {
             status = RA_NOMATCH;
           } else {
             ADVANCE_REGINPUT();
@@ -4046,7 +4046,7 @@ static bool regmatch(char_u *scan, proftime_T *tm, int *timed_out)
             // Check for following composing character, unless %C
             // follows (skips over all composing chars).
             if (status != RA_NOMATCH
-                && utf_composinglike(rex.input, rex.input + len)
+                && utf_composinglike((char *)rex.input, (char *)rex.input + len)
                 && !rex.reg_icombine
                 && OP(next) != RE_COMPOSING) {
               // raaron: This code makes a composing character get
@@ -4975,13 +4975,13 @@ static long regtry(bt_regprog_T *prog, colnr_T col, proftime_T *tm, int *timed_o
             && reg_endzpos[i].lnum == reg_startzpos[i].lnum
             && reg_endzpos[i].col >= reg_startzpos[i].col) {
           re_extmatch_out->matches[i] =
-            vim_strnsave(reg_getline(reg_startzpos[i].lnum) + reg_startzpos[i].col,
-                         (size_t)(reg_endzpos[i].col - reg_startzpos[i].col));
+            (char_u *)xstrnsave((char *)reg_getline(reg_startzpos[i].lnum) + reg_startzpos[i].col,
+                                (size_t)(reg_endzpos[i].col - reg_startzpos[i].col));
         }
       } else {
         if (reg_startzp[i] != NULL && reg_endzp[i] != NULL) {
           re_extmatch_out->matches[i] =
-            vim_strnsave(reg_startzp[i], (size_t)(reg_endzp[i] - reg_startzp[i]));
+            (char_u *)xstrnsave((char *)reg_startzp[i], (size_t)(reg_endzp[i] - reg_startzp[i]));
         }
       }
     }
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index d01404b5c2..4c1058ba36 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -6643,13 +6643,13 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *subm
         break;
 
       case NFA_KWORD:           //  \k
-        result = vim_iswordp_buf(rex.input, rex.reg_buf);
+        result = vim_iswordp_buf((char *)rex.input, rex.reg_buf);
         ADD_STATE_IF_MATCH(t->state);
         break;
 
       case NFA_SKWORD:          //  \K
         result = !ascii_isdigit(curc)
-                 && vim_iswordp_buf(rex.input, rex.reg_buf);
+                 && vim_iswordp_buf((char *)rex.input, rex.reg_buf);
         ADD_STATE_IF_MATCH(t->state);
         break;
 
@@ -7362,15 +7362,15 @@ static long nfa_regtry(nfa_regprog_T *prog, colnr_T col, proftime_T *tm, int *ti
             && mpos->start_lnum == mpos->end_lnum
             && mpos->end_col >= mpos->start_col) {
           re_extmatch_out->matches[i] =
-            vim_strnsave(reg_getline(mpos->start_lnum) + mpos->start_col,
-                         (size_t)(mpos->end_col - mpos->start_col));
+            (char_u *)xstrnsave((char *)reg_getline(mpos->start_lnum) + mpos->start_col,
+                                (size_t)(mpos->end_col - mpos->start_col));
         }
       } else {
         struct linepos *lpos = &subs.synt.list.line[i];
 
         if (lpos->start != NULL && lpos->end != NULL) {
           re_extmatch_out->matches[i] =
-            vim_strnsave(lpos->start, (size_t)(lpos->end - lpos->start));
+            (char_u *)xstrnsave((char *)lpos->start, (size_t)(lpos->end - lpos->start));
         }
       }
     }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index db1c766eb2..5c1fe3a657 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -161,7 +161,7 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
     magic = spats[i].magic;
     no_smartcase = spats[i].no_scs;
   } else if (options & SEARCH_HIS) {      // put new pattern in history
-    add_to_history(HIST_SEARCH, pat, true, NUL);
+    add_to_history(HIST_SEARCH, (char *)pat, true, NUL);
   }
 
   if (mr_pattern_alloced) {
@@ -1574,7 +1574,7 @@ int searchc(cmdarg_T *cap, int t_cmd)
     cap->oap->inclusive = true;
   }
 
-  p = get_cursor_line_ptr();
+  p = (char_u *)get_cursor_line_ptr();
   col = curwin->w_cursor.col;
   len = (int)STRLEN(p);
 
@@ -1649,22 +1649,21 @@ static bool check_prevcol(char_u *linep, int col, int ch, int *prevcol)
   return col >= 0 && linep[col] == ch;
 }
 
-/*
- * Raw string start is found at linep[startpos.col - 1].
- * Return true if the matching end can be found between startpos and endpos.
- */
-static bool find_rawstring_end(char_u *linep, pos_T *startpos, pos_T *endpos)
+/// Raw string start is found at linep[startpos.col - 1].
+///
+/// @return  true if the matching end can be found between startpos and endpos.
+static bool find_rawstring_end(char *linep, pos_T *startpos, pos_T *endpos)
 {
-  char_u *p;
+  char *p;
   linenr_T lnum;
 
   for (p = linep + startpos->col + 1; *p && *p != '('; p++) {}
 
   size_t delim_len = (size_t)((p - linep) - startpos->col - 1);
-  char_u *delim_copy = vim_strnsave(linep + startpos->col + 1, delim_len);
+  char *delim_copy = xstrnsave(linep + startpos->col + 1, delim_len);
   bool found = false;
   for (lnum = startpos->lnum; lnum <= endpos->lnum; lnum++) {
-    char_u *line = (char_u *)ml_get(lnum);
+    char *line = ml_get(lnum);
 
     for (p = line + (lnum == startpos->lnum ? startpos->col + 1 : 0); *p; p++) {
       if (lnum == endpos->lnum && (colnr_T)(p - line) >= endpos->col) {
@@ -2082,7 +2081,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
             // delimiter we can check if it ends before where we
             // started searching, or before the previously found
             // raw string start.
-            if (!find_rawstring_end(linep, &pos,
+            if (!find_rawstring_end((char *)linep, &pos,
                                     count > 0 ? &match_pos : &curwin->w_cursor)) {
               count++;
               match_pos = pos;
@@ -3598,11 +3597,11 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
 
       if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) {
         // Use text from '\zs' to '\ze' (or end) of 'include'.
-        new_fname = find_file_name_in_path(incl_regmatch.startp[0],
-                                           (size_t)(incl_regmatch.endp[0]
-                                                    - incl_regmatch.startp[0]),
-                                           FNAME_EXP|FNAME_INCL|FNAME_REL,
-                                           1L, p_fname);
+        new_fname = (char_u *)find_file_name_in_path((char *)incl_regmatch.startp[0],
+                                                     (size_t)(incl_regmatch.endp[0]
+                                                              - incl_regmatch.startp[0]),
+                                                     FNAME_EXP|FNAME_INCL|FNAME_REL,
+                                                     1L, (char *)p_fname);
       } else {
         // Use text after match with 'include'.
         new_fname = file_name_in_line(incl_regmatch.endp[0], 0,
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index e20bce5b34..1a70b77053 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -882,10 +882,10 @@ static const void *shada_hist_iter(const void *const iter, const uint8_t history
       .data = {
         .history_item = {
           .histtype = history_type,
-          .string = (char *)hist_he.hisstr,
+          .string = hist_he.hisstr,
           .sep = (char)(history_type == HIST_SEARCH
-                         ? (char)hist_he.hisstr[STRLEN(hist_he.hisstr) + 1]
-                         : 0),
+                        ? hist_he.hisstr[STRLEN(hist_he.hisstr) + 1]
+                        : 0),
           .additional_elements = hist_he.additional_elements,
         }
       }
@@ -1008,7 +1008,7 @@ static inline void hms_to_he_array(const HistoryMergerState *const hms_p,
   HMLL_FORALL(&hms_p->hmll, cur_entry,  {
     hist->timestamp = cur_entry->data.timestamp;
     hist->hisnum = (int)(hist - hist_array) + 1;
-    hist->hisstr = (char_u *)cur_entry->data.data.history_item.string;
+    hist->hisstr = cur_entry->data.data.history_item.string;
     hist->additional_elements =
       cur_entry->data.data.history_item.additional_elements;
     hist++;
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 7c05c9fe53..c0d05eb799 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -2104,8 +2104,8 @@ static void clear_midword(win_T *wp)
   XFREE_CLEAR(wp->w_s->b_spell_ismw_mb);
 }
 
-// Use the "sl_midword" field of language "lp" for buffer "buf".
-// They add up to any currently used midword characters.
+/// Use the "sl_midword" field of language "lp" for buffer "buf".
+/// They add up to any currently used midword characters.
 static void use_midword(slang_T *lp, win_T *wp)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -2113,20 +2113,20 @@ static void use_midword(slang_T *lp, win_T *wp)
     return;
   }
 
-  for (char_u *p = lp->sl_midword; *p != NUL;) {
-    const int c = utf_ptr2char((char *)p);
-    const int l = utfc_ptr2len((char *)p);
+  for (char *p = (char *)lp->sl_midword; *p != NUL;) {
+    const int c = utf_ptr2char(p);
+    const int l = utfc_ptr2len(p);
     if (c < 256 && l <= 2) {
       wp->w_s->b_spell_ismw[c] = true;
     } else if (wp->w_s->b_spell_ismw_mb == NULL) {
       // First multi-byte char in "b_spell_ismw_mb".
-      wp->w_s->b_spell_ismw_mb = (char *)vim_strnsave(p, (size_t)l);
+      wp->w_s->b_spell_ismw_mb = xstrnsave(p, (size_t)l);
     } else {
       // Append multi-byte chars to "b_spell_ismw_mb".
       const int n = (int)STRLEN(wp->w_s->b_spell_ismw_mb);
-      char_u *bp = vim_strnsave((char_u *)wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
+      char *bp = xstrnsave(wp->w_s->b_spell_ismw_mb, (size_t)n + (size_t)l);
       xfree(wp->w_s->b_spell_ismw_mb);
-      wp->w_s->b_spell_ismw_mb = (char *)bp;
+      wp->w_s->b_spell_ismw_mb = bp;
       STRLCPY(bp + n, p, l + 1);
     }
     p += l;
@@ -2470,7 +2470,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
     return false;
   }
 
-  char_u *line = get_cursor_line_ptr();
+  char_u *line = (char_u *)get_cursor_line_ptr();
   char_u *line_copy = NULL;
   colnr_T endcol = 0;
   if (getwhitecols((char *)line) >= (int)col) {
@@ -2548,7 +2548,7 @@ void ex_spellrepall(exarg_T *eap)
 
     // Only replace when the right word isn't there yet.  This happens
     // when changing "etc" to "etc.".
-    char_u *line = get_cursor_line_ptr();
+    char_u *line = (char_u *)get_cursor_line_ptr();
     if (addlen <= 0 || STRNCMP(line + curwin->w_cursor.col,
                                repl_to, STRLEN(repl_to)) != 0) {
       char_u *p = xmalloc(STRLEN(line) + (size_t)addlen + 1);
@@ -3497,7 +3497,7 @@ int spell_word_start(int startcol)
     return startcol;
   }
 
-  char_u *line = get_cursor_line_ptr();
+  char_u *line = (char_u *)get_cursor_line_ptr();
   char_u *p;
 
   // Find a word character before "startcol".
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index 23c8c621b5..c07e460ea8 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -65,7 +65,7 @@ typedef struct suginfo_S {
 
 /// One word suggestion.  Used in "si_ga".
 typedef struct {
-  char_u *st_word;    ///< suggested word, allocated string
+  char *st_word;      ///< suggested word, allocated string
   int st_wordlen;     ///< STRLEN(st_word)
   int st_orglen;      ///< length of replaced text
   int st_score;       ///< lower is better
@@ -453,7 +453,7 @@ void spell_suggest(int count)
     // No bad word or it starts after the cursor: use the word under the
     // cursor.
     curwin->w_cursor = prev_cursor;
-    line = get_cursor_line_ptr();
+    line = (char_u *)get_cursor_line_ptr();
     p = line + curwin->w_cursor.col;
     // Backup to before start of word.
     while (p > line && spell_iswordp_nmw(p, curwin)) {
@@ -477,7 +477,7 @@ void spell_suggest(int count)
   need_cap = check_need_cap(curwin->w_cursor.lnum, curwin->w_cursor.col);
 
   // Make a copy of current line since autocommands may free the line.
-  line = vim_strsave(get_cursor_line_ptr());
+  line = vim_strsave((char_u *)get_cursor_line_ptr());
   spell_suggest_timeout = 5000;
 
   // Get the list of suggestions.  Limit to 'lines' - 2 or the number in
@@ -593,15 +593,15 @@ void spell_suggest(int count)
     if (sug.su_badlen > stp->st_orglen) {
       // Replacing less than "su_badlen", append the remainder to
       // repl_to.
-      repl_from = vim_strnsave(sug.su_badptr, (size_t)sug.su_badlen);
+      repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)sug.su_badlen);
       vim_snprintf((char *)IObuff, IOSIZE, "%s%.*s", stp->st_word,
                    sug.su_badlen - stp->st_orglen,
                    sug.su_badptr + stp->st_orglen);
       repl_to = vim_strsave(IObuff);
     } else {
       // Replacing su_badlen or more, use the whole word.
-      repl_from = vim_strnsave(sug.su_badptr, (size_t)stp->st_orglen);
-      repl_to = vim_strsave(stp->st_word);
+      repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)stp->st_orglen);
+      repl_to = vim_strsave((char_u *)stp->st_word);
     }
 
     // Replace the word.
@@ -748,7 +748,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   c = utf_ptr2char((char *)su->su_badptr);
   if (!SPELL_ISUPPER(c) && attr == HLF_COUNT) {
     make_case_word(su->su_badword, buf, WF_ONECAP);
-    add_suggestion(su, &su->su_ga, buf, su->su_badlen, SCORE_ICASE,
+    add_suggestion(su, &su->su_ga, (char *)buf, su->su_badlen, SCORE_ICASE,
                    0, true, su->su_sallang, false);
   }
 
@@ -814,7 +814,7 @@ static void spell_suggest_expr(suginfo_T *su, char_u *expr)
         // Get the word and the score from the items.
         score = get_spellword(TV_LIST_ITEM_TV(li)->vval.v_list, &p);
         if (score >= 0 && score <= su->su_maxscore) {
-          add_suggestion(su, &su->su_ga, (const char_u *)p, su->su_badlen,
+          add_suggestion(su, &su->su_ga, p, su->su_badlen,
                          score, 0, true, su->su_sallang, false);
         }
       }
@@ -864,7 +864,7 @@ static void spell_suggest_file(suginfo_T *su, char_u *fname)
         p = cword;
       }
 
-      add_suggestion(su, &su->su_ga, p, su->su_badlen,
+      add_suggestion(su, &su->su_ga, (char *)p, su->su_badlen,
                      SCORE_FILE, 0, true, su->su_sallang, false);
     }
   }
@@ -985,7 +985,7 @@ static void suggest_try_special(suginfo_T *su)
 
     // Give a soundalike score of 0, compute the score as if deleting one
     // character.
-    add_suggestion(su, &su->su_ga, word, su->su_badlen,
+    add_suggestion(su, &su->su_ga, (char *)word, su->su_badlen,
                    RESCORE(SCORE_REP, 0), 0, true, su->su_sallang, false);
   }
 }
@@ -1330,7 +1330,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                                            sp->ts_prewordlen > 0);
             // Add the suggestion if the score isn't too bad.
             if (newscore <= su->su_maxscore) {
-              add_suggestion(su, &su->su_ga, preword,
+              add_suggestion(su, &su->su_ga, (char *)preword,
                              sp->ts_splitfidx - repextra,
                              newscore, 0, false,
                              lp->lp_sallang, false);
@@ -1492,7 +1492,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
 
           // Add the suggestion if the score isn't too bad.
           if (score <= su->su_maxscore) {
-            add_suggestion(su, &su->su_ga, preword,
+            add_suggestion(su, &su->su_ga, (char *)preword,
                            sp->ts_fidx - repextra,
                            score, 0, false, lp->lp_sallang, false);
 
@@ -1505,7 +1505,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                                preword + sp->ts_prewordlen,
                                c == 0 ? WF_ALLCAP : 0);
 
-                add_suggestion(su, &su->su_ga, preword,
+                add_suggestion(su, &su->su_ga, (char *)preword,
                                sp->ts_fidx - repextra,
                                score + SCORE_ICASE, 0, false,
                                lp->lp_sallang, false);
@@ -2494,7 +2494,7 @@ static void score_comp_sal(suginfo_T *su)
         if (score < SCORE_MAXMAX) {
           // Add the suggestion.
           sstp = &SUG(su->su_sga, su->su_sga.ga_len);
-          sstp->st_word = vim_strsave(stp->st_word);
+          sstp->st_word = xstrdup(stp->st_word);
           sstp->st_wordlen = stp->st_wordlen;
           sstp->st_score = score;
           sstp->st_altscore = 0;
@@ -2551,8 +2551,7 @@ static void score_combine(suginfo_T *su)
   // Add the alternate score to su_sga.
   for (int i = 0; i < su->su_sga.ga_len; i++) {
     stp = &SUG(su->su_sga, i);
-    stp->st_altscore = spell_edit_score(slang,
-                                        su->su_badword, stp->st_word);
+    stp->st_altscore = spell_edit_score(slang, su->su_badword, (char_u *)stp->st_word);
     if (stp->st_score == SCORE_MAXMAX) {
       stp->st_score = (SCORE_BIG * 7 + stp->st_altscore) / 8;
     } else {
@@ -2579,7 +2578,7 @@ static void score_combine(suginfo_T *su)
       gap = round == 1 ? &su->su_ga : &su->su_sga;
       if (i < gap->ga_len) {
         // Don't add a word if it's already there.
-        p = SUG(*gap, i).st_word;
+        p = (char_u *)SUG(*gap, i).st_word;
         int j;
         for (j = 0; j < ga.ga_len; j++) {
           if (STRCMP(stp[j].st_word, p) == 0) {
@@ -2636,7 +2635,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
     // removing the space.  Don't do it when the good word also contains a
     // space.
     if (ascii_iswhite(su->su_badptr[su->su_badlen])
-        && *skiptowhite((char *)stp->st_word) == NUL) {
+        && *skiptowhite(stp->st_word) == NUL) {
       for (p = fword; *(p = (char_u *)skiptowhite((char *)p)) != NUL;) {
         STRMOVE(p, p + 1);
       }
@@ -2654,7 +2653,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
             su->su_badptr + su->su_badlen - lendiff, lendiff + 1);
     pgood = goodword;
   } else {
-    pgood = stp->st_word;
+    pgood = (char_u *)stp->st_word;
   }
 
   // Sound-fold the word and compute the score for the difference.
@@ -2883,7 +2882,7 @@ badword:
       if (sps_flags & SPS_DOUBLE) {
         // Add the suggestion if the score isn't too bad.
         if (score <= su->su_maxscore) {
-          add_suggestion(su, &su->su_sga, p, su->su_badlen,
+          add_suggestion(su, &su->su_sga, (char *)p, su->su_badlen,
                          score, 0, false, slang, false);
         }
       } else {
@@ -2931,7 +2930,7 @@ badword:
           // Add the suggestion if the score isn't too bad.
           goodscore = RESCORE(goodscore, score);
           if (goodscore <= su->su_sfmaxscore) {
-            add_suggestion(su, &su->su_ga, p, su->su_badlen,
+            add_suggestion(su, &su->su_ga, (char *)p, su->su_badlen,
                            goodscore, score, true, slang, true);
           }
         }
@@ -3061,7 +3060,7 @@ static bool similar_chars(slang_T *slang, int c1, int c2)
 /// @param had_bonus  value for st_had_bonus
 /// @param slang  language for sound folding
 /// @param maxsf  su_maxscore applies to soundfold score, su_sfmaxscore to the total score.
-static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword, int badlenarg,
+static void add_suggestion(suginfo_T *su, garray_T *gap, const char *goodword, int badlenarg,
                            int score, int altscore, bool had_bonus, slang_T *slang, bool maxsf)
 {
   int goodlen;                  // len of goodword changed
@@ -3071,7 +3070,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword,
 
   // Minimize "badlen" for consistency.  Avoids that changing "the the" to
   // "thee the" is added next to changing the first "the" the "thee".
-  const char_u *pgood = goodword + STRLEN(goodword);
+  const char *pgood = goodword + STRLEN(goodword);
   char_u *pbad = su->su_badptr + badlenarg;
   for (;;) {
     goodlen = (int)(pgood - goodword);
@@ -3144,7 +3143,7 @@ static void add_suggestion(suginfo_T *su, garray_T *gap, const char_u *goodword,
   if (i < 0) {
     // Add a suggestion.
     stp = GA_APPEND_VIA_PTR(suggest_T, gap);
-    stp->st_word = vim_strnsave(goodword, (size_t)goodlen);
+    stp->st_word = xstrnsave(goodword, (size_t)goodlen);
     stp->st_wordlen = goodlen;
     stp->st_score = score;
     stp->st_altscore = altscore;
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 16691d0ded..423436eccc 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -59,15 +59,6 @@ char_u *vim_strsave(const char_u *string)
 /// Copy up to `len` bytes of `string` into newly allocated memory and
 /// terminate with a NUL. The allocated memory always has size `len + 1`, even
 /// when `string` is shorter.
-char_u *vim_strnsave(const char_u *string, size_t len)
-  FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
-{
-  // strncpy is intentional: some parts of Vim use `string` shorter than `len`
-  // and expect the remainder to be zeroed out.
-  return (char_u *)strncpy(xmallocz(len), (char *)string, len);
-}
-
-/// A clone of vim_strnsave() that uses char* instead of char_u*
 char *xstrnsave(const char *string, size_t len)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
@@ -318,15 +309,13 @@ char_u *vim_strsave_up(const char_u *string)
   return p1;
 }
 
-/*
- * Like vim_strnsave(), but make all characters uppercase.
- * This uses ASCII lower-to-upper case translation, language independent.
- */
-char_u *vim_strnsave_up(const char_u *string, size_t len)
+/// Like xstrnsave(), but make all characters uppercase.
+/// This uses ASCII lower-to-upper case translation, language independent.
+char *vim_strnsave_up(const char *string, size_t len)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
-  char_u *p1 = vim_strnsave(string, len);
-  vim_strup(p1);
+  char *p1 = xstrnsave(string, len);
+  vim_strup((char_u *)p1);
   return p1;
 }
 
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index d8de23182c..9eb412b803 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -93,7 +93,7 @@ typedef struct syn_pattern {
   int16_t *sp_cont_list;                // cont. group IDs, if non-zero
   int16_t *sp_next_list;                // next group IDs, if non-zero
   struct sp_syn sp_syn;                 // struct passed to in_id_list()
-  char_u *sp_pattern;                   // regexp to match, pattern
+  char *sp_pattern;                     // regexp to match, pattern
   regprog_T *sp_prog;                   // regexp to match, program
   syn_time_T sp_time;
 } synpat_T;
@@ -1709,9 +1709,10 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
       if (do_keywords) {
         line = (char_u *)syn_getcurline();
         const char_u *cur_pos = line + current_col;
-        if (vim_iswordp_buf(cur_pos, syn_buf)
+        if (vim_iswordp_buf((char *)cur_pos, syn_buf)
             && (current_col == 0
-                || !vim_iswordp_buf(cur_pos - 1 - utf_head_off((char *)line, (char *)cur_pos - 1),
+                || !vim_iswordp_buf((char *)cur_pos - 1 -
+                                    utf_head_off((char *)line, (char *)cur_pos - 1),
                                     syn_buf))) {
           syn_id = check_keyword_id((char *)line, (int)current_col, &endcol, &flags,
                                     &next_list, cur_si, &cchar);
@@ -2942,7 +2943,7 @@ static int check_keyword_id(char *const line, const int startcol, int *const end
   int kwlen = 0;
   do {
     kwlen += utfc_ptr2len(kwp + kwlen);
-  } while (vim_iswordp_buf((char_u *)kwp + kwlen, syn_buf));
+  } while (vim_iswordp_buf(kwp + kwlen, syn_buf));
 
   if (kwlen > MAXKEYWLEN) {
     return 0;
@@ -3772,14 +3773,14 @@ static void put_pattern(const char *const s, const int c, const synpat_T *const
   msg_putchar(c);
 
   // output the pattern, in between a char that is not in the pattern
-  for (i = 0; vim_strchr((char *)spp->sp_pattern, sepchars[i]) != NULL;) {
+  for (i = 0; vim_strchr(spp->sp_pattern, sepchars[i]) != NULL;) {
     if (sepchars[++i] == NUL) {
       i = 0;            // no good char found, just use the first one
       break;
     }
   }
   msg_putchar(sepchars[i]);
-  msg_outtrans((char *)spp->sp_pattern);
+  msg_outtrans(spp->sp_pattern);
   msg_putchar(sepchars[i]);
 
   // output any pattern options
@@ -4048,7 +4049,7 @@ static char *get_group_name(char *arg, char **name_end)
 ///              Return NULL for any error;
 static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, int skip)
 {
-  char_u *gname_start, *gname;
+  char *gname_start, *gname;
   int syn_id;
   int len = 0;
   char *p;
@@ -4157,16 +4158,16 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
           emsg(_("E393: group[t]here not accepted here"));
           return NULL;
         }
-        gname_start = (char_u *)arg;
+        gname_start = arg;
         arg = skiptowhite(arg);
-        if (gname_start == (char_u *)arg) {
+        if (gname_start == arg) {
           return NULL;
         }
-        gname = vim_strnsave(gname_start, (size_t)((char_u *)arg - gname_start));
+        gname = xstrnsave(gname_start, (size_t)(arg - gname_start));
         if (STRCMP(gname, "NONE") == 0) {
           *opt->sync_idx = NONE_IDX;
         } else {
-          syn_id = syn_name2id((char *)gname);
+          syn_id = syn_name2id(gname);
           int i;
           for (i = curwin->w_s->b_syn_patterns.ga_len; --i >= 0;) {
             if (SYN_ITEMS(curwin->w_s)[i].sp_syn.id == syn_id
@@ -4566,7 +4567,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
       key_end++;
     }
     xfree(key);
-    key = (char *)vim_strnsave_up((char_u *)rest, (size_t)(key_end - rest));
+    key = vim_strnsave_up(rest, (size_t)(key_end - rest));
     if (STRCMP(key, "MATCHGROUP") == 0) {
       item = ITEM_MATCHGROUP;
     } else if (STRCMP(key, "START") == 0) {
@@ -5043,12 +5044,12 @@ static char *get_syn_pattern(char *arg, synpat_T *ci)
     return NULL;
   }
   // store the pattern and compiled regexp program
-  ci->sp_pattern = vim_strnsave((char_u *)arg + 1, (size_t)(end - arg) - 1);
+  ci->sp_pattern = xstrnsave(arg + 1, (size_t)(end - arg) - 1);
 
   // Make 'cpoptions' empty, to avoid the 'l' flag
   cpo_save = p_cpo;
   p_cpo = empty_option;
-  ci->sp_prog = vim_regcomp((char *)ci->sp_pattern, RE_MAGIC);
+  ci->sp_prog = vim_regcomp(ci->sp_pattern, RE_MAGIC);
   p_cpo = cpo_save;
 
   if (ci->sp_prog == NULL) {
@@ -5137,7 +5138,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
     arg_end = skiptowhite(arg_start);
     next_arg = skipwhite(arg_end);
     xfree(key);
-    key = (char *)vim_strnsave_up((char_u *)arg_start, (size_t)(arg_end - arg_start));
+    key = vim_strnsave_up(arg_start, (size_t)(arg_end - arg_start));
     if (STRCMP(key, "CCOMMENT") == 0) {
       if (!eap->skip) {
         curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
@@ -5975,7 +5976,7 @@ static void syntime_report(void)
       proftime_T tm = profile_divide(spp->sp_time.total, (int)spp->sp_time.count);
       p->average = tm;
       p->id = spp->sp_syn.id;
-      p->pattern = spp->sp_pattern;
+      p->pattern = (char_u *)spp->sp_pattern;
     }
   }
 
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 648eb751fe..d1d5514648 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -66,11 +66,11 @@ typedef struct tag_pointers {
   char_u *command_end;  // first char after command
   char_u *tag_fname;  // file name of the tags file. This is used
   // when 'tr' is set.
-  char_u *tagkind;  // "kind:" value
-  char_u *tagkind_end;  // end of tagkind
-  char_u *user_data;  // user_data string
+  char_u *tagkind;        // "kind:" value
+  char_u *tagkind_end;    // end of tagkind
+  char *user_data;        // user_data string
   char_u *user_data_end;  // end of user_data
-  linenr_T tagline;        // "line:" value
+  linenr_T tagline;       // "line:" value
 } tagptrs_T;
 
 /*
@@ -588,9 +588,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         if (use_tfu && parse_match(matches[cur_match], &tagp2) == OK
             && tagp2.user_data) {
           XFREE_CLEAR(tagstack[tagstackidx].user_data);
-          tagstack[tagstackidx].user_data = (char *)vim_strnsave(tagp2.user_data,
-                                                                 (size_t)(tagp2.user_data_end -
-                                                                          tagp2.user_data));
+          tagstack[tagstackidx].user_data =
+            xstrnsave(tagp2.user_data, (size_t)(tagp2.user_data_end - (char_u *)tagp2.user_data));
         }
 
         tagstackidx++;
@@ -1425,7 +1424,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
   int help_pri = 0;
   char_u *help_lang_find = NULL;           // lang to be found
   char_u help_lang[3];                          // lang of current tags file
-  char_u *saved_pat = NULL;                // copy of pat[]
+  char *saved_pat = NULL;                // copy of pat[]
   bool is_txt = false;
 
   pat_T orgpat;                         // holds unconverted pattern info
@@ -1503,9 +1502,9 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
     if (orgpat.len > 3 && pat[orgpat.len - 3] == '@'
         && ASCII_ISALPHA(pat[orgpat.len - 2])
         && ASCII_ISALPHA(pat[orgpat.len - 1])) {
-      saved_pat = vim_strnsave((char_u *)pat, (size_t)orgpat.len - 3);
+      saved_pat = xstrnsave(pat, (size_t)orgpat.len - 3);
       help_lang_find = (char_u *)&pat[orgpat.len - 2];
-      orgpat.pat = saved_pat;
+      orgpat.pat = (char_u *)saved_pat;
       orgpat.len -= 3;
     }
   }
@@ -2430,11 +2429,11 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
       STRMOVE(filename + 1, filename);
       *filename++ = NUL;
 
-      tnp->tn_search_ctx = vim_findfile_init((char_u *)buf, filename,
-                                             (char_u *)r_ptr, 100,
+      tnp->tn_search_ctx = vim_findfile_init(buf, (char *)filename,
+                                             r_ptr, 100,
                                              false,                   // don't free visited list
                                              FINDFILE_FILE,           // we search for a file
-                                             tnp->tn_search_ctx, true, (char_u *)curbuf->b_ffname);
+                                             tnp->tn_search_ctx, true, curbuf->b_ffname);
       if (tnp->tn_search_ctx != NULL) {
         tnp->tn_did_filefind_init = true;
       }
@@ -2584,7 +2583,7 @@ static int parse_match(char *lbuf, tagptrs_T *tagp)
           if (STRNCMP(p, "kind:", 5) == 0) {
             tagp->tagkind = (char_u *)p + 5;
           } else if (STRNCMP(p, "user_data:", 10) == 0) {
-            tagp->user_data = (char_u *)p + 10;
+            tagp->user_data = p + 10;
           } else if (STRNCMP(p, "line:", 5) == 0) {
             tagp->tagline = atoi(p + 5);
           }
@@ -2612,7 +2611,7 @@ static int parse_match(char *lbuf, tagptrs_T *tagp)
       tagp->tagkind_end = (char_u *)p;
     }
     if (tagp->user_data != NULL) {
-      for (p = (char *)tagp->user_data;
+      for (p = tagp->user_data;
            *p && *p != '\t' && *p != '\r' && *p != '\n';
            MB_PTR_ADV(p)) {}
       tagp->user_data_end = (char_u *)p;
@@ -2980,7 +2979,7 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
   /*
    * Expand file name (for environment variables) when needed.
    */
-  if (expand && path_has_wildcard(fname)) {
+  if (expand && path_has_wildcard((char *)fname)) {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_FILES;
     expanded_fname = ExpandOne(&xpc, fname, NULL,
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 5ded0c9ab2..6e69fb95c8 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -117,7 +117,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
 
     // Don't break until after the comment leader
     if (do_comments) {
-      char_u *line = get_cursor_line_ptr();
+      char_u *line = (char_u *)get_cursor_line_ptr();
       leader_len = get_leader_len((char *)line, NULL, false, true);
       if (leader_len == 0 && curbuf->b_p_cin) {
         // Check for a line comment after code.
@@ -624,8 +624,8 @@ void auto_format(bool trailblank, bool prev_line)
 {
   pos_T pos;
   colnr_T len;
-  char_u *old;
-  char_u *new, *pnew;
+  char *old;
+  char *new, *pnew;
   int wasatend;
   int cc;
 
@@ -663,7 +663,7 @@ void auto_format(bool trailblank, bool prev_line)
   // With the 'c' flag in 'formatoptions' and 't' missing: only format
   // comments.
   if (has_format_option(FO_WRAP_COMS) && !has_format_option(FO_WRAP)
-      && get_leader_len((char *)old, NULL, false, true) == 0) {
+      && get_leader_len(old, NULL, false, true) == 0) {
     return;
   }
 
@@ -700,10 +700,10 @@ void auto_format(bool trailblank, bool prev_line)
     new = get_cursor_line_ptr();
     len = (colnr_T)STRLEN(new);
     if (curwin->w_cursor.col == len) {
-      pnew = vim_strnsave(new, (size_t)len + 2);
+      pnew = xstrnsave(new, (size_t)len + 2);
       pnew[len] = ' ';
       pnew[len + 1] = NUL;
-      ml_replace(curwin->w_cursor.lnum, (char *)pnew, false);
+      ml_replace(curwin->w_cursor.lnum, pnew, false);
       // remove the space later
       did_add_space = true;
     } else {
@@ -1026,7 +1026,7 @@ void format_lines(linenr_T line_count, bool avoid_fex)
         // paragraph doesn't really end.
         if (next_leader_flags == NULL
             || STRNCMP(next_leader_flags, "://", 3) != 0
-            || check_linecomment((char *)get_cursor_line_ptr()) == MAXCOL) {
+            || check_linecomment(get_cursor_line_ptr()) == MAXCOL) {
           is_end_par = true;
         }
       }
diff --git a/src/nvim/textobject.c b/src/nvim/textobject.c
index a8f4cc7aeb..6863b40599 100644
--- a/src/nvim/textobject.c
+++ b/src/nvim/textobject.c
@@ -1032,7 +1032,7 @@ int current_block(oparg_T *oap, long count, bool include, int what, int other)
 /// @return         true if the cursor is on a "<aaa>" tag.  Ignore "<aaa/>".
 static bool in_html_tag(bool end_tag)
 {
-  char_u *line = get_cursor_line_ptr();
+  char_u *line = (char_u *)get_cursor_line_ptr();
   char_u *p;
   int c;
   int lc = NUL;
@@ -1493,7 +1493,7 @@ static int find_prev_quote(char_u *line, int col_start, int quotechar, char_u *e
 bool current_quote(oparg_T *oap, long count, bool include, int quotechar)
   FUNC_ATTR_NONNULL_ALL
 {
-  char_u *line = get_cursor_line_ptr();
+  char_u *line = (char_u *)get_cursor_line_ptr();
   int col_end;
   int col_start = curwin->w_cursor.col;
   bool inclusive = false;
diff --git a/src/nvim/viml/parser/expressions.c b/src/nvim/viml/parser/expressions.c
index 387b9d61f2..d12a690b83 100644
--- a/src/nvim/viml/parser/expressions.c
+++ b/src/nvim/viml/parser/expressions.c
@@ -66,8 +66,6 @@
 #include "nvim/viml/parser/expressions.h"
 #include "nvim/viml/parser/parser.h"
 
-#define VIM_STR2NR(s, ...) vim_str2nr((const char_u *)(s), __VA_ARGS__)
-
 typedef kvec_withinit_t(ExprASTNode **, 16) ExprASTStack;
 
 /// Which nodes may be wanted
@@ -371,7 +369,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
         significand_part = significand_part * 10 + (pline.data[i] - '0');
       }
       if (exp_start) {
-        VIM_STR2NR(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
+        vim_str2nr(pline.data + exp_start, NULL, NULL, 0, NULL, &exp_part,
                    (int)(ret.len - exp_start), false);
       }
       if (exp_negative) {
@@ -389,7 +387,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
     } else {
       int len;
       int prep;
-      VIM_STR2NR(pline.data, &prep, &len, STR2NR_ALL, NULL,
+      vim_str2nr(pline.data, &prep, &len, STR2NR_ALL, NULL,
                  &ret.data.num.val.integer, (int)pline.size, false);
       ret.len = (size_t)len;
       const uint8_t bases[] = {
@@ -696,8 +694,7 @@ LexExprToken viml_pexpr_next_token(ParserState *const pstate, const int flags)
 
   // Everything else is not valid.
   default:
-    ret.len = (size_t)utfc_ptr2len_len((const char_u *)pline.data,
-                                       (int)pline.size);
+    ret.len = (size_t)utfc_ptr2len_len(pline.data, (int)pline.size);
     ret.type = kExprLexInvalid;
     ret.data.err.type = kExprLexPlainIdentifier;
     ret.data.err.msg = _("E15: Unidentified character: %.*s");
diff --git a/src/nvim/window.c b/src/nvim/window.c
index c11484d1b8..8ca40cdd35 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6522,7 +6522,7 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
 
       *file_lnum = (linenr_T)getdigits_long(&p, false, 0);
     }
-    return find_file_name_in_path((char_u *)ptr, len, options, count, (char_u *)curbuf->b_ffname);
+    return (char_u *)find_file_name_in_path(ptr, len, options, count, curbuf->b_ffname);
   }
   return file_name_at_cursor(options | FNAME_HYP, count, file_lnum);
 }
@@ -6542,7 +6542,7 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
  */
 char_u *file_name_at_cursor(int options, long count, linenr_T *file_lnum)
 {
-  return file_name_in_line(get_cursor_line_ptr(),
+  return file_name_in_line((char_u *)get_cursor_line_ptr(),
                            curwin->w_cursor.col, options, count, (char_u *)curbuf->b_ffname,
                            file_lnum);
 }
@@ -6649,7 +6649,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
     }
   }
 
-  return find_file_name_in_path((char_u *)ptr, len, options, count, rel_fname);
+  return (char_u *)find_file_name_in_path(ptr, len, options, count, (char *)rel_fname);
 }
 
 /// Add or remove a status line from window(s), according to the
-- 
cgit 


From c65b1f3e15662cd14c443e34862237d3dee30977 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 20:18:17 +0800
Subject: vim-patch:9.0.0342: ":wincmd =" equalizes in two directions

Problem:    ":wincmd =" equalizes in two directions.
Solution:   Make ":vertical wincmd =" equalize vertically only and
            ":horizontal wincmd =" equalize horizontally only.
https://github.com/vim/vim/commit/21c3a80a7fd6b7fc250ce5dc287963511f54b86f
---
 src/nvim/ex_cmds.lua                 |  6 ++++++
 src/nvim/ex_docmd.c                  |  6 +++++-
 src/nvim/testdir/test_window_cmd.vim | 40 ++++++++++++++++++++++++++++++++++++
 src/nvim/window.c                    |  8 +++++---
 src/nvim/window.h                    | 17 +++++++--------
 5 files changed, 65 insertions(+), 12 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_cmds.lua b/src/nvim/ex_cmds.lua
index 4bed1e94b9..04b8832428 100644
--- a/src/nvim/ex_cmds.lua
+++ b/src/nvim/ex_cmds.lua
@@ -1140,6 +1140,12 @@ module.cmds = {
     addr_type='ADDR_NONE',
     func='ex_history',
   },
+  {
+    command='horizontal',
+    flags=bit.bor(NEEDARG, EXTRA, NOTRLCOM),
+    addr_type='ADDR_NONE',
+    func='ex_wrongmodifier',
+  },
   {
     command='insert',
     flags=bit.bor(BANG, RANGE, TRLBAR, CMDWIN, LOCK_OK, MODIFY),
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 0af737ff50..f99253ea75 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2438,8 +2438,12 @@ int parse_command_modifiers(exarg_T *eap, char **errormsg, cmdmod_T *cmod, bool
       continue;
     }
 
-    // ":hide" and ":hide | cmd" are not modifiers
     case 'h':
+      if (checkforcmd(&eap->cmd, "horizontal", 3)) {
+        cmod->cmod_split |= WSP_HOR;
+        continue;
+      }
+      // ":hide" and ":hide | cmd" are not modifiers
       if (p != eap->cmd || !checkforcmd(&p, "hide", 3)
           || *p == NUL || ends_excmd(*p)) {
         break;
diff --git a/src/nvim/testdir/test_window_cmd.vim b/src/nvim/testdir/test_window_cmd.vim
index 83a3216534..1f4b9b77c6 100644
--- a/src/nvim/testdir/test_window_cmd.vim
+++ b/src/nvim/testdir/test_window_cmd.vim
@@ -343,6 +343,46 @@ func Test_window_height()
   bw Xa Xb Xc
 endfunc
 
+func Test_wincmd_equal()
+  edit Xone
+  below split Xtwo
+  rightbelow vsplit Xthree
+  call assert_equal('Xone', bufname(winbufnr(1)))
+  call assert_equal('Xtwo', bufname(winbufnr(2)))
+  call assert_equal('Xthree', bufname(winbufnr(3)))
+
+  " Xone and Xtwo should be about the same height
+  let [wh1, wh2] = [winheight(1), winheight(2)]
+  call assert_inrange(wh1 - 1, wh1 + 1, wh2)
+  " Xtwo and Xthree should be about the same width
+  let [ww2, ww3] = [winwidth(2), winwidth(3)]
+  call assert_inrange(ww2 - 1, ww2 + 1, ww3)
+
+  1wincmd w
+  10wincmd _
+  2wincmd w
+  20wincmd |
+  call assert_equal(10, winheight(1))
+  call assert_equal(20, winwidth(2))
+
+  " equalizing horizontally doesn't change the heights
+  hor wincmd =
+  call assert_equal(10, winheight(1))
+  let [ww2, ww3] = [winwidth(2), winwidth(3)]
+  call assert_inrange(ww2 - 1, ww2 + 1, ww3)
+
+  2wincmd w
+  20wincmd |
+  call assert_equal(20, winwidth(2))
+  " equalizing vertically doesn't change the widths
+  vert wincmd =
+  call assert_equal(20, winwidth(2))
+  let [wh1, wh2] = [winheight(1), winheight(2)]
+  call assert_inrange(wh1 - 1, wh1 + 1, wh2)
+
+  bwipe Xone Xtwo Xthree
+endfunc
+
 func Test_window_width()
   e Xa
   vsplit Xb
diff --git a/src/nvim/window.c b/src/nvim/window.c
index c11484d1b8..c0b73ff837 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -417,10 +417,12 @@ newwindow:
               | ((nchar == 'H' || nchar == 'K') ? WSP_TOP : WSP_BOT));
     break;
 
-  // make all windows the same height
-  case '=':
-    win_equal(NULL, false, 'b');
+  // make all windows the same width and/or height
+  case '=': {
+    int mod = cmdmod.cmod_split & (WSP_VERT | WSP_HOR);
+    win_equal(NULL, false, mod == WSP_VERT ? 'v' : mod == WSP_HOR ? 'h' : 'b');
     break;
+  }
 
   // increase current window height
   case '+':
diff --git a/src/nvim/window.h b/src/nvim/window.h
index b75b8abd9b..3137035b25 100644
--- a/src/nvim/window.h
+++ b/src/nvim/window.h
@@ -17,14 +17,15 @@
 #define FNAME_UNESC     32      // remove backslashes used for escaping
 
 // arguments for win_split()
-#define WSP_ROOM        1       // require enough room
-#define WSP_VERT        2       // split vertically
-#define WSP_TOP         4       // window at top-left of shell
-#define WSP_BOT         8       // window at bottom-right of shell
-#define WSP_HELP        16      // creating the help window
-#define WSP_BELOW       32      // put new window below/right
-#define WSP_ABOVE       64      // put new window above/left
-#define WSP_NEWLOC      128     // don't copy location list
+#define WSP_ROOM        0x01    // require enough room
+#define WSP_VERT        0x02    // split/equalize vertically
+#define WSP_HOR         0x04    // equalize horizontally
+#define WSP_TOP         0x08    // window at top-left of shell
+#define WSP_BOT         0x10    // window at bottom-right of shell
+#define WSP_HELP        0x20    // creating the help window
+#define WSP_BELOW       0x40    // put new window below/right
+#define WSP_ABOVE       0x80    // put new window above/left
+#define WSP_NEWLOC      0x100   // don't copy location list
 
 // Minimum screen size
 #define MIN_COLUMNS     12      // minimal columns for screen
-- 
cgit 


From 56bf026deac8eddb1abc8e1d46fde992cfc67ac2 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 20:25:34 +0800
Subject: vim-patch:9.0.0346: :horizontal modifier not fully supported

Problem:    :horizontal modifier not fully supported.
Solution:   Also use :horizontal for completion and user commands.
            (closes vim/vim#11025)
https://github.com/vim/vim/commit/d3de178e5352fedf0f30b979f46a2fcbca24ea40
---
 src/nvim/cmdexpand.c                   | 1 +
 src/nvim/ex_docmd.c                    | 1 +
 src/nvim/testdir/test_cmdline.vim      | 4 ++++
 src/nvim/testdir/test_usercommands.vim | 4 ++++
 src/nvim/usercmd.c                     | 4 ++++
 5 files changed, 14 insertions(+)

(limited to 'src')

diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 6fc63f72a1..9d8dd197bd 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -1203,6 +1203,7 @@ static const char *set_context_by_cmdname(const char *cmd, cmdidx_T cmdidx, cons
   case CMD_folddoclosed:
   case CMD_folddoopen:
   case CMD_hide:
+  case CMD_horizontal:
   case CMD_keepalt:
   case CMD_keepjumps:
   case CMD_keepmarks:
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index f99253ea75..ea21dc8ae7 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -1757,6 +1757,7 @@ static bool skip_cmd(const exarg_T *eap)
     case CMD_filter:
     case CMD_help:
     case CMD_hide:
+    case CMD_horizontal:
     case CMD_ijump:
     case CMD_ilist:
     case CMD_isearch:
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index 4bfd22cb6c..bc06e70ff4 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -926,6 +926,10 @@ func Test_cmdline_complete_various()
   call feedkeys(":all abc\<C-A>\<C-B>\"\<CR>", 'xt')
   call assert_equal("\"all abc\<C-A>", @:)
 
+  " completion for :wincmd with :horizontal modifier
+  call feedkeys(":horizontal wincm\<C-A>\<C-B>\"\<CR>", 'xt')
+  call assert_equal("\"horizontal wincmd", @:)
+
   " completion for a command with a command modifier
   call feedkeys(":topleft new\<C-A>\<C-B>\"\<CR>", 'xt')
   call assert_equal("\"topleft new", @:)
diff --git a/src/nvim/testdir/test_usercommands.vim b/src/nvim/testdir/test_usercommands.vim
index e37fe43b22..1065dd16e2 100644
--- a/src/nvim/testdir/test_usercommands.vim
+++ b/src/nvim/testdir/test_usercommands.vim
@@ -101,6 +101,10 @@ function Test_cmdmods()
   call assert_equal('vertical', g:mods)
   vert MyCmd
   call assert_equal('vertical', g:mods)
+  horizontal MyCmd
+  call assert_equal('horizontal', g:mods)
+  hor MyCmd
+  call assert_equal('horizontal', g:mods)
 
   aboveleft belowright botright browse confirm hide keepalt keepjumps
 	      \ keepmarks keeppatterns lockmarks noautocmd noswapfile silent
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 9cc9fb5588..3726273d28 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -1247,6 +1247,10 @@ size_t add_win_cmd_modifers(char *buf, const cmdmod_T *cmod, bool *multi_mods)
   if (cmod->cmod_split & WSP_VERT) {
     result += add_cmd_modifier(buf, "vertical", multi_mods);
   }
+  // :horizontal
+  if (cmod->cmod_split & WSP_HOR) {
+    result += add_cmd_modifier(buf, "horizontal", multi_mods);
+  }
   return result;
 }
 
-- 
cgit 


From 689f5d604e59eba1ddab6f91b458a8163dc6629d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 20:32:59 +0800
Subject: feat(api): add support for :horizontal modifier

---
 src/nvim/api/command.c   | 7 +++++++
 src/nvim/api/keysets.lua | 1 +
 src/nvim/lua/executor.c  | 2 ++
 3 files changed, 10 insertions(+)

(limited to 'src')

diff --git a/src/nvim/api/command.c b/src/nvim/api/command.c
index 1323fc347b..b821e07d60 100644
--- a/src/nvim/api/command.c
+++ b/src/nvim/api/command.c
@@ -62,6 +62,7 @@
 ///             - browse: (boolean) |:browse|.
 ///             - confirm: (boolean) |:confirm|.
 ///             - hide: (boolean) |:hide|.
+///             - horizontal: (boolean) |:horizontal|.
 ///             - keepalt: (boolean) |:keepalt|.
 ///             - keepjumps: (boolean) |:keepjumps|.
 ///             - keepmarks: (boolean) |:keepmarks|.
@@ -250,6 +251,7 @@ Dictionary nvim_parse_cmd(String str, Dictionary opts, Error *err)
   PUT(mods, "lockmarks", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_LOCKMARKS));
   PUT(mods, "noswapfile", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_NOSWAPFILE));
   PUT(mods, "vertical", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_split & WSP_VERT));
+  PUT(mods, "horizontal", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_split & WSP_HOR));
 
   const char *split;
   if (cmdinfo.cmdmod.cmod_split & WSP_BOT) {
@@ -576,6 +578,10 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     OBJ_TO_BOOL(vertical, mods.vertical, false, "'mods.vertical'");
     cmdinfo.cmdmod.cmod_split |= (vertical ? WSP_VERT : 0);
 
+    bool horizontal;
+    OBJ_TO_BOOL(horizontal, mods.horizontal, false, "'mods.horizontal'");
+    cmdinfo.cmdmod.cmod_split |= (horizontal ? WSP_HOR : 0);
+
     if (HAS_KEY(mods.split)) {
       if (mods.split.type != kObjectTypeString) {
         VALIDATION_ERROR("'mods.split' must be a String");
@@ -753,6 +759,7 @@ static void build_cmdline_str(char **cmdlinep, exarg_T *eap, CmdParseInfo *cmdin
   } while (0)
 
   CMDLINE_APPEND_IF(cmdinfo->cmdmod.cmod_split & WSP_VERT, "vertical ");
+  CMDLINE_APPEND_IF(cmdinfo->cmdmod.cmod_split & WSP_HOR, "horizontal ");
   CMDLINE_APPEND_IF(cmdinfo->cmdmod.cmod_flags & CMOD_SANDBOX, "sandbox ");
   CMDLINE_APPEND_IF(cmdinfo->cmdmod.cmod_flags & CMOD_NOAUTOCMD, "noautocmd ");
   CMDLINE_APPEND_IF(cmdinfo->cmdmod.cmod_flags & CMOD_BROWSE, "browse ");
diff --git a/src/nvim/api/keysets.lua b/src/nvim/api/keysets.lua
index 6fad52ba75..af3dc24f51 100644
--- a/src/nvim/api/keysets.lua
+++ b/src/nvim/api/keysets.lua
@@ -188,6 +188,7 @@ return {
     "browse";
     "confirm";
     "hide";
+    "horizontal";
     "keepalt";
     "keepjumps";
     "keepmarks";
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index f144e47c3a..2315ecd874 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -2103,6 +2103,8 @@ int nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap, bool preview)
 
   lua_pushboolean(lstate, cmdmod.cmod_split & WSP_VERT);
   lua_setfield(lstate, -2, "vertical");
+  lua_pushboolean(lstate, cmdmod.cmod_split & WSP_HOR);
+  lua_setfield(lstate, -2, "horizontal");
   lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_SILENT);
   lua_setfield(lstate, -2, "silent");
   lua_pushboolean(lstate, cmdmod.cmod_flags & CMOD_ERRSILENT);
-- 
cgit 


From ce80b8f50d7d56ac12aa06a64a65799ec18b69af Mon Sep 17 00:00:00 2001
From: Jonas Strittmatter <40792180+smjonas@users.noreply.github.com>
Date: Fri, 2 Sep 2022 08:16:17 +0200
Subject: vim-patch:9.0.0349: filetype of *.sil files not well detected
 (#20050)

Problem:    Filetype of *.sil files not well detected.
Solution:   Inspect the file contents to guess the filetype.
https://github.com/vim/vim/commit/be807d582499acbe314ead3891481cba6ca136df
---
 src/nvim/testdir/test_filetype.vim | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 68ce9148a4..4f5ae830b7 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -1824,6 +1824,44 @@ func Test_sig_file()
   filetype off
 endfunc
 
+" Test dist#ft#FTsil()
+func Test_sil_file()
+  filetype on
+
+  split Xfile.sil
+  call assert_equal('sil', &filetype)
+  bwipe!
+
+  let lines =<< trim END
+  // valid
+  let protoErasedPathA = \ABCProtocol.a
+
+  // also valid
+  let protoErasedPathA =
+          \ABCProtocol.a
+  END
+  call writefile(lines, 'Xfile.sil')
+
+  split Xfile.sil
+  call assert_equal('sil', &filetype)
+  bwipe!
+
+  " SILE
+
+  call writefile(['% some comment'], 'Xfile.sil')
+  split Xfile.sil
+  call assert_equal('sile', &filetype)
+  bwipe!
+
+  call writefile(['\begin[papersize=a6]{document}foo\end{document}'], 'Xfile.sil')
+  split Xfile.sil
+  call assert_equal('sile', &filetype)
+  bwipe!
+
+  call delete('Xfile.sil')
+  filetype off
+endfunc
+
 func Test_inc_file()
   filetype on
 
-- 
cgit 


From 2dd55f81f736d5fe9697cd0e15c96f763eb90458 Mon Sep 17 00:00:00 2001
From: Famiu Haque <famiuhaque@protonmail.com>
Date: Fri, 2 Sep 2022 17:44:14 +0600
Subject: fix(ui): ui compositor does not correctly free event callbacks

Prior to this PR, when freeing event callbacks, UI compositor did not
free the luarefs which could cause potential memory leaks. This PR fixes
that by freeing the luarefs properly.
---
 src/nvim/ui_compositor.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/ui_compositor.c b/src/nvim/ui_compositor.c
index b8c7834e2b..2fb70eae8a 100644
--- a/src/nvim/ui_compositor.c
+++ b/src/nvim/ui_compositor.c
@@ -98,7 +98,7 @@ void ui_comp_free_all_mem(void)
 {
   UIEventCallback *event_cb;
   map_foreach_value(&ui_event_cbs, event_cb, {
-    xfree(event_cb);
+    free_ui_event_callback(event_cb);
   })
   pmap_destroy(uint32_t)(&ui_event_cbs);
 }
-- 
cgit 


From 2afcdbd63a5b0cbeaad9d83b096a3af5201c67a9 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 2 Sep 2022 15:20:29 +0100
Subject: feat(Man): port to Lua (#19912)

Co-authored-by: zeertzjq <zeertzjq@outlook.com>
---
 src/nvim/testdir/test_profile.vim | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_profile.vim b/src/nvim/testdir/test_profile.vim
index fdb6f13e2b..4225b91bc4 100644
--- a/src/nvim/testdir/test_profile.vim
+++ b/src/nvim/testdir/test_profile.vim
@@ -40,8 +40,8 @@ func Test_profile_func()
   call writefile(lines, 'Xprofile_func.vim')
   call system(GetVimCommand()
     \ . ' -es --clean'
-    \ . ' -c "so Xprofile_func.vim"'
-    \ . ' -c "qall!"')
+    \ . ' --cmd "so Xprofile_func.vim"'
+    \ . ' --cmd "qall!"')
   call assert_equal(0, v:shell_error)
 
   let lines = readfile('Xprofile_func.log')
@@ -475,7 +475,7 @@ func Test_profdel_func()
     call Foo3()
   [CODE]
   call writefile(lines, 'Xprofile_file.vim')
-  call system(GetVimCommandClean() . ' -es -c "so Xprofile_file.vim" -c q')
+  call system(GetVimCommandClean() . ' -es --cmd "so Xprofile_file.vim" --cmd q')
   call assert_equal(0, v:shell_error)
 
   let lines = readfile('Xprofile_file.log')
-- 
cgit 


From 1ef7720567b08caec0c077605fb2a01a9d6eafbc Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 1 Sep 2022 18:46:34 +0800
Subject: fix(api)!: correctly deal with number before :tab

Now nvim_parse_cmd and nvim_create_user_command use a "tab" value which
is the same as the number passed before :tab modifier instead of the
number plus 1, and "tab" value is -1 if :tab modifier is not used.
---
 src/nvim/api/command.c  | 14 ++++++++------
 src/nvim/lua/executor.c |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/command.c b/src/nvim/api/command.c
index b821e07d60..11715a49dc 100644
--- a/src/nvim/api/command.c
+++ b/src/nvim/api/command.c
@@ -69,7 +69,7 @@
 ///             - keeppatterns: (boolean) |:keeppatterns|.
 ///             - lockmarks: (boolean) |:lockmarks|.
 ///             - noswapfile: (boolean) |:noswapfile|.
-///             - tab: (integer) |:tab|.
+///             - tab: (integer) |:tab|. -1 when omitted.
 ///             - verbose: (integer) |:verbose|. -1 when omitted.
 ///             - vertical: (boolean) |:vertical|.
 ///             - split: (string) Split modifier string, is an empty string when there's no split
@@ -239,7 +239,7 @@ Dictionary nvim_parse_cmd(String str, Dictionary opts, Error *err)
   PUT(mods, "unsilent", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_UNSILENT));
   PUT(mods, "sandbox", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_SANDBOX));
   PUT(mods, "noautocmd", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_NOAUTOCMD));
-  PUT(mods, "tab", INTEGER_OBJ(cmdinfo.cmdmod.cmod_tab));
+  PUT(mods, "tab", INTEGER_OBJ(cmdinfo.cmdmod.cmod_tab - 1));
   PUT(mods, "verbose", INTEGER_OBJ(cmdinfo.cmdmod.cmod_verbose - 1));
   PUT(mods, "browse", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_BROWSE));
   PUT(mods, "confirm", BOOLEAN_OBJ(cmdinfo.cmdmod.cmod_flags & CMOD_CONFIRM));
@@ -559,15 +559,17 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
     }
 
     if (HAS_KEY(mods.tab)) {
-      if (mods.tab.type != kObjectTypeInteger || mods.tab.data.integer < 0) {
-        VALIDATION_ERROR("'mods.tab' must be a non-negative Integer");
+      if (mods.tab.type != kObjectTypeInteger) {
+        VALIDATION_ERROR("'mods.tab' must be an Integer");
+      } else if ((int)mods.tab.data.integer >= 0) {
+        // Silently ignore negative integers to allow mods.tab to be set to -1.
+        cmdinfo.cmdmod.cmod_tab = (int)mods.tab.data.integer + 1;
       }
-      cmdinfo.cmdmod.cmod_tab = (int)mods.tab.data.integer + 1;
     }
 
     if (HAS_KEY(mods.verbose)) {
       if (mods.verbose.type != kObjectTypeInteger) {
-        VALIDATION_ERROR("'mods.verbose' must be a Integer");
+        VALIDATION_ERROR("'mods.verbose' must be an Integer");
       } else if ((int)mods.verbose.data.integer >= 0) {
         // Silently ignore negative integers to allow mods.verbose to be set to -1.
         cmdinfo.cmdmod.cmod_verbose = (int)mods.verbose.data.integer + 1;
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 2315ecd874..1013cf76f9 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -2082,7 +2082,7 @@ int nlua_do_ucmd(ucmd_T *cmd, exarg_T *eap, bool preview)
 
   lua_newtable(lstate);  // smods table
 
-  lua_pushinteger(lstate, cmdmod.cmod_tab);
+  lua_pushinteger(lstate, cmdmod.cmod_tab - 1);
   lua_setfield(lstate, -2, "tab");
 
   lua_pushinteger(lstate, cmdmod.cmod_verbose - 1);
-- 
cgit 


From 1ffd527c837fb2465c9659273bbe5447a1352db2 Mon Sep 17 00:00:00 2001
From: Lewis Russell <lewis6991@gmail.com>
Date: Fri, 2 Sep 2022 17:39:49 +0100
Subject: refactor: migrate comment style (#20012)

Done automatically using the following perl command:

  perl -pi -0777pe 's#\n\K */\*\n(.+?)\s*\*/\n#join("\n", map { $_ =~ s:^\s*\K \*://:; $_ } split("\n", $1)) . "\n"#sge' src/nvim/**/*.c

Co-authored-by: zeertzjq <zeertzjq@outlook.com>

Co-authored-by: zeertzjq <zeertzjq@outlook.com>
---
 src/nvim/buffer_defs.h   |  337 ++++++--------
 src/nvim/edit.c          |  385 ++++++----------
 src/nvim/eval.h          |   52 ++-
 src/nvim/eval/userfunc.c |   54 +--
 src/nvim/ex_cmds.c       |  430 +++++++-----------
 src/nvim/ex_eval.c       |  378 +++++++---------
 src/nvim/ex_getln.c      |   82 ++--
 src/nvim/file_search.c   |  224 ++++-----
 src/nvim/fileio.c        |  535 ++++++++--------------
 src/nvim/fold.h          |    6 +-
 src/nvim/getchar.c       |  257 ++++-------
 src/nvim/hardcopy.c      |  442 +++++++-----------
 src/nvim/hardcopy.h      |   12 +-
 src/nvim/if_cscope.c     |  141 +++---
 src/nvim/indent_c.c      | 1121 +++++++++++++++++++---------------------------
 src/nvim/main.c          |   61 +--
 src/nvim/mark.c          |  133 ++----
 src/nvim/mark_defs.h     |    6 +-
 src/nvim/mbyte.c         |  242 ++++------
 src/nvim/mbyte.h         |   10 +-
 src/nvim/memline.c       |  686 +++++++++++-----------------
 src/nvim/memory.c        |   18 +-
 src/nvim/menu.c          |  148 ++----
 src/nvim/message.c       |  160 +++----
 src/nvim/message.h       |    8 +-
 src/nvim/move.c          |  384 ++++++----------
 src/nvim/normal.h        |    8 +-
 src/nvim/ops.c           |  166 +++----
 src/nvim/ops.h           |   16 +-
 src/nvim/option.c        |  227 ++++------
 src/nvim/option_defs.h   |   12 +-
 src/nvim/path.c          |  154 +++----
 src/nvim/path.h          |    4 +-
 src/nvim/search.c        |  369 ++++++---------
 src/nvim/strings.c       |   78 ++--
 src/nvim/syntax.c        | 1046 +++++++++++++++---------------------------
 src/nvim/tag.c           |  341 +++++---------
 src/nvim/window.c        |  599 +++++++++----------------
 38 files changed, 3494 insertions(+), 5838 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index c1ac20fd98..c26b18a7e7 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -48,25 +48,23 @@ typedef struct {
 #define GETFILE_SUCCESS(x)    ((x) <= 0)
 #define MODIFIABLE(buf) (buf->b_p_ma)
 
-/*
- * Flags for w_valid.
- * These are set when something in a window structure becomes invalid, except
- * when the cursor is moved.  Call check_cursor_moved() before testing one of
- * the flags.
- * These are reset when that thing has been updated and is valid again.
- *
- * Every function that invalidates one of these must call one of the
- * invalidate_* functions.
- *
- * w_valid is supposed to be used only in screen.c.  From other files, use the
- * functions that set or reset the flags.
- *
- * VALID_BOTLINE    VALID_BOTLINE_AP
- *     on       on      w_botline valid
- *     off      on      w_botline approximated
- *     off      off     w_botline not valid
- *     on       off     not possible
- */
+// Flags for w_valid.
+// These are set when something in a window structure becomes invalid, except
+// when the cursor is moved.  Call check_cursor_moved() before testing one of
+// the flags.
+// These are reset when that thing has been updated and is valid again.
+//
+// Every function that invalidates one of these must call one of the
+// invalidate_* functions.
+//
+// w_valid is supposed to be used only in screen.c.  From other files, use the
+// functions that set or reset the flags.
+//
+// VALID_BOTLINE    VALID_BOTLINE_AP
+//     on       on      w_botline valid
+//     off      on      w_botline approximated
+//     off      off     w_botline not valid
+//     on       off     not possible
 #define VALID_WROW      0x01    // w_wrow (window row) is valid
 #define VALID_WCOL      0x02    // w_wcol (window col) is valid
 #define VALID_VIRTCOL   0x04    // w_virtcol (file col) is valid
@@ -112,9 +110,7 @@ typedef uint64_t disptick_T;  // display tick type
 #include "nvim/sign_defs.h"
 #include "nvim/terminal.h"      // for Terminal
 
-/*
- * The taggy struct is used to store the information about a :tag command.
- */
+// The taggy struct is used to store the information about a :tag command.
 typedef struct taggy {
   char *tagname;                // tag name
   fmark_T fmark;                // cursor position BEFORE ":tag"
@@ -126,17 +122,13 @@ typedef struct taggy {
 typedef struct buffblock buffblock_T;
 typedef struct buffheader buffheader_T;
 
-/*
- * structure used to store one block of the stuff/redo/recording buffers
- */
+// structure used to store one block of the stuff/redo/recording buffers
 struct buffblock {
   buffblock_T *b_next;  // pointer to next buffblock
   char b_str[1];        // contents (actually longer)
 };
 
-/*
- * header used for the stuff buffer and the redo buffer
- */
+// header used for the stuff buffer and the redo buffer
 struct buffheader {
   buffblock_T bh_first;  // first (dummy) block of list
   buffblock_T *bh_curr;  // buffblock for appending
@@ -149,11 +141,9 @@ typedef struct {
   buffheader_T sr_old_redobuff;
 } save_redo_T;
 
-/*
- * Structure that contains all options that are local to a window.
- * Used twice in a window: for the current buffer and for all buffers.
- * Also used in wininfo_T.
- */
+// Structure that contains all options that are local to a window.
+// Used twice in a window: for the current buffer and for all buffers.
+// Also used in wininfo_T.
 typedef struct {
   int wo_arab;
 #define w_p_arab w_onebuf_opt.wo_arab  // 'arabic'
@@ -268,16 +258,14 @@ typedef struct {
 #define w_p_script_ctx w_onebuf_opt.wo_script_ctx
 } winopt_T;
 
-/*
- * Window info stored with a buffer.
- *
- * Two types of info are kept for a buffer which are associated with a
- * specific window:
- * 1. Each window can have a different line number associated with a buffer.
- * 2. The window-local options for a buffer work in a similar way.
- * The window-info is kept in a list at b_wininfo.  It is kept in
- * most-recently-used order.
- */
+// Window info stored with a buffer.
+//
+// Two types of info are kept for a buffer which are associated with a
+// specific window:
+// 1. Each window can have a different line number associated with a buffer.
+// 2. The window-local options for a buffer work in a similar way.
+// The window-info is kept in a list at b_wininfo.  It is kept in
+// most-recently-used order.
 struct wininfo_S {
   wininfo_T *wi_next;         // next entry or NULL for last entry
   wininfo_T *wi_prev;         // previous entry or NULL for first entry
@@ -290,12 +278,10 @@ struct wininfo_S {
   int wi_changelistidx;         // copy of w_changelistidx
 };
 
-/*
- * Argument list: Array of file names.
- * Used for the global argument list and the argument lists local to a window.
- *
- * TODO: move struct arglist to another header
- */
+// Argument list: Array of file names.
+// Used for the global argument list and the argument lists local to a window.
+//
+// TODO(neovim): move struct arglist to another header
 typedef struct arglist {
   garray_T al_ga;               // growarray with the array of file names
   int al_refcount;              // number of windows using this arglist
@@ -321,9 +307,7 @@ typedef struct argentry {
 #define ARGCOUNT        (ALIST(curwin)->al_ga.ga_len)
 #define WARGCOUNT(wp)   (ALIST(wp)->al_ga.ga_len)
 
-/*
- * Used for the typeahead buffer: typebuf.
- */
+// Used for the typeahead buffer: typebuf.
 typedef struct {
   uint8_t *tb_buf;              // buffer for typed characters
   uint8_t *tb_noremap;          // mapping flags for characters in tb_buf[]
@@ -347,9 +331,7 @@ typedef struct {
   String save_inputbuf;
 } tasave_T;
 
-/*
- * Structure used for mappings and abbreviations.
- */
+// Structure used for mappings and abbreviations.
 typedef struct mapblock mapblock_T;
 struct mapblock {
   mapblock_T *m_next;           // next mapblock in list
@@ -414,9 +396,7 @@ struct stl_item {
 
 typedef struct qf_info_S qf_info_T;
 
-/*
- * Used for :syntime: timing of executing a syntax pattern.
- */
+// Used for :syntime: timing of executing a syntax pattern.
 typedef struct {
   proftime_T total;             // total time used
   proftime_T slowest;           // time of slowest call
@@ -424,10 +404,8 @@ typedef struct {
   long match;                   // nr of times matched
 } syn_time_T;
 
-/*
- * These are items normally related to a buffer.  But when using ":ownsyntax"
- * a window may have its own instance.
- */
+// These are items normally related to a buffer.  But when using ":ownsyntax"
+// a window may have its own instance.
 typedef struct {
   hashtab_T b_keywtab;                  // syntax keywords hash table
   hashtab_T b_keywtab_ic;               // idem, ignore case
@@ -514,13 +492,11 @@ EXTERN int curbuf_splice_pending INIT(= 0);
 // Maximum number of maphash blocks we will have
 #define MAX_MAPHASH 256
 
-/*
- * buffer: structure that holds information about one file
- *
- * Several windows can share a single Buffer
- * A buffer is unallocated if there is no memfile for it.
- * A buffer is new if the associated file has never been loaded yet.
- */
+// buffer: structure that holds information about one file
+//
+// Several windows can share a single Buffer
+// A buffer is unallocated if there is no memfile for it.
+// A buffer is new if the associated file has never been loaded yet.
 
 struct file_buffer {
   handle_T handle;              // unique id for the buffer (buffer number)
@@ -570,15 +546,13 @@ struct file_buffer {
   varnumber_T b_last_changedtick_pum;   // b:changedtick when TextChangedP was
                                         // last triggered.
 
-  bool b_saving;                /* Set to true if we are in the middle of
-                                   saving the buffer. */
+  bool b_saving;                // Set to true if we are in the middle of
+                                // saving the buffer.
 
-  /*
-   * Changes to a buffer require updating of the display.  To minimize the
-   * work, remember changes made and update everything at once.
-   */
-  bool b_mod_set;               /* true when there are changes since the last
-                                   time the display was updated */
+  // Changes to a buffer require updating of the display.  To minimize the
+  // work, remember changes made and update everything at once.
+  bool b_mod_set;               // true when there are changes since the last
+                                // time the display was updated
   linenr_T b_mod_top;           // topmost lnum that was changed
   linenr_T b_mod_bot;           // lnum below last changed line, AFTER the
                                 // change
@@ -609,17 +583,13 @@ struct file_buffer {
   fmark_T b_last_insert;        // where Insert mode was left
   fmark_T b_last_change;        // position of last change: '. mark
 
-  /*
-   * the changelist contains old change positions
-   */
+  // the changelist contains old change positions
   fmark_T b_changelist[JUMPLISTSIZE];
   int b_changelistlen;                  // number of active entries
   bool b_new_change;                    // set by u_savecommon()
 
-  /*
-   * Character table, only used in charset.c for 'iskeyword'
-   * bitset with 4*64=256 bits: 1 bit per character 0-255.
-   */
+  // Character table, only used in charset.c for 'iskeyword'
+  // bitset with 4*64=256 bits: 1 bit per character 0-255.
   uint64_t b_chartab[4];
 
   // Table used for mappings local to a buffer.
@@ -629,18 +599,14 @@ struct file_buffer {
   mapblock_T *b_first_abbr;
   // User commands local to the buffer.
   garray_T b_ucmds;
-  /*
-   * start and end of an operator, also used for '[ and ']
-   */
+  // start and end of an operator, also used for '[ and ']
   pos_T b_op_start;
   pos_T b_op_start_orig;  // used for Insstart_orig
   pos_T b_op_end;
 
   bool b_marks_read;            // Have we read ShaDa marks yet?
 
-  /*
-   * The following only used in undo.c.
-   */
+  // The following only used in undo.c.
   u_header_T *b_u_oldhead;     // pointer to oldest header
   u_header_T *b_u_newhead;     // pointer to newest header; may not be valid
                                // if b_u_curhead is not NULL
@@ -673,11 +639,9 @@ struct file_buffer {
 #define KEYMAP_LOADED  2       // 'keymap' mappings have been loaded
   garray_T b_kmap_ga;           // the keymap table
 
-  /*
-   * Options local to a buffer.
-   * They are here because their value depends on the type of file
-   * or contents of the file being edited.
-   */
+  // Options local to a buffer.
+  // They are here because their value depends on the type of file
+  // or contents of the file being edited.
   bool b_p_initialized;                 // set when options initialized
 
   LastSet b_p_script_ctx[BV_COUNT];     // SCTXs for buffer-local options
@@ -834,19 +798,17 @@ struct file_buffer {
   ScopeDictDictItem b_bufvar;  ///< Variable for "b:" Dictionary.
   dict_T *b_vars;  ///< b: scope dictionary.
 
-  /* When a buffer is created, it starts without a swap file.  b_may_swap is
-   * then set to indicate that a swap file may be opened later.  It is reset
-   * if a swap file could not be opened.
-   */
+  // When a buffer is created, it starts without a swap file.  b_may_swap is
+  // then set to indicate that a swap file may be opened later.  It is reset
+  // if a swap file could not be opened.
   bool b_may_swap;
   bool b_did_warn;              /* Set to true if user has been warned on first
                                    change of a read-only file */
 
-  /* Two special kinds of buffers:
-   * help buffer  - used for help files, won't use a swap file.
-   * spell buffer - used for spell info, never displayed and doesn't have a
-   *                file name.
-   */
+  // Two special kinds of buffers:
+  // help buffer  - used for help files, won't use a swap file.
+  // spell buffer - used for spell info, never displayed and doesn't have a
+  //                file name.
   bool b_help;                  // true for help file buffer (when set b_p_bt
                                 // is "help")
   bool b_spell;                 // True for a spell file buffer, most fields
@@ -906,25 +868,21 @@ struct file_buffer {
   int b_diff_failed;    // internal diff failed for this buffer
 };
 
-/*
- * Stuff for diff mode.
- */
+// Stuff for diff mode.
 #define DB_COUNT 8     // up to four buffers can be diff'ed
 
-/*
- * Each diffblock defines where a block of lines starts in each of the buffers
- * and how many lines it occupies in that buffer.  When the lines are missing
- * in the buffer the df_count[] is zero.  This is all counted in
- * buffer lines.
- * There is always at least one unchanged line in between the diffs.
- * Otherwise it would have been included in the diff above or below it.
- * df_lnum[] + df_count[] is the lnum below the change.  When in one buffer
- * lines have been inserted, in the other buffer df_lnum[] is the line below
- * the insertion and df_count[] is zero.  When appending lines at the end of
- * the buffer, df_lnum[] is one beyond the end!
- * This is using a linked list, because the number of differences is expected
- * to be reasonable small.  The list is sorted on lnum.
- */
+// Each diffblock defines where a block of lines starts in each of the buffers
+// and how many lines it occupies in that buffer.  When the lines are missing
+// in the buffer the df_count[] is zero.  This is all counted in
+// buffer lines.
+// There is always at least one unchanged line in between the diffs.
+// Otherwise it would have been included in the diff above or below it.
+// df_lnum[] + df_count[] is the lnum below the change.  When in one buffer
+// lines have been inserted, in the other buffer df_lnum[] is the line below
+// the insertion and df_count[] is zero.  When appending lines at the end of
+// the buffer, df_lnum[] is one beyond the end!
+// This is using a linked list, because the number of differences is expected
+// to be reasonable small.  The list is sorted on lnum.
 typedef struct diffblock_S diff_T;
 struct diffblock_S {
   diff_T *df_next;
@@ -964,18 +922,16 @@ struct tabpage_S {
   char *tp_prevdir;        ///< Previous directory.
 };
 
-/*
- * Structure to cache info for displayed lines in w_lines[].
- * Each logical line has one entry.
- * The entry tells how the logical line is currently displayed in the window.
- * This is updated when displaying the window.
- * When the display is changed (e.g., when clearing the screen) w_lines_valid
- * is changed to exclude invalid entries.
- * When making changes to the buffer, wl_valid is reset to indicate wl_size
- * may not reflect what is actually in the buffer.  When wl_valid is false,
- * the entries can only be used to count the number of displayed lines used.
- * wl_lnum and wl_lastlnum are invalid too.
- */
+// Structure to cache info for displayed lines in w_lines[].
+// Each logical line has one entry.
+// The entry tells how the logical line is currently displayed in the window.
+// This is updated when displaying the window.
+// When the display is changed (e.g., when clearing the screen) w_lines_valid
+// is changed to exclude invalid entries.
+// When making changes to the buffer, wl_valid is reset to indicate wl_size
+// may not reflect what is actually in the buffer.  When wl_valid is false,
+// the entries can only be used to count the number of displayed lines used.
+// wl_lnum and wl_lastlnum are invalid too.
 typedef struct w_line {
   linenr_T wl_lnum;             // buffer line number for logical line
   uint16_t wl_size;             // height in screen lines
@@ -984,10 +940,8 @@ typedef struct w_line {
   linenr_T wl_lastlnum;         // last buffer line number for logical line
 } wline_T;
 
-/*
- * Windows are kept in a tree of frames.  Each frame has a column (FR_COL)
- * or row (FR_ROW) layout or is a leaf, which has a window.
- */
+// Windows are kept in a tree of frames.  Each frame has a column (FR_COL)
+// or row (FR_ROW) layout or is a leaf, which has a window.
 struct frame_S {
   char fr_layout;               // FR_LEAF, FR_COL or FR_ROW
   int fr_width;
@@ -1008,12 +962,10 @@ struct frame_S {
 #define FR_ROW  1       // frame with a row of windows
 #define FR_COL  2       // frame with a column of windows
 
-/*
- * Struct used for highlighting 'hlsearch' matches, matches defined by
- * ":match" and matches defined by match functions.
- * For 'hlsearch' there is one pattern for all windows.  For ":match" and the
- * match functions there is a different pattern for each window.
- */
+// Struct used for highlighting 'hlsearch' matches, matches defined by
+// ":match" and matches defined by match functions.
+// For 'hlsearch' there is one pattern for all windows.  For ":match" and the
+// match functions there is a different pattern for each window.
 typedef struct {
   regmmatch_T rm;       // points to the regexp program; contains last found
                         // match (may continue in next line)
@@ -1049,10 +1001,8 @@ struct posmatch {
   linenr_T botlnum;            ///< bottom buffer line
 };
 
-/*
- * matchitem_T provides a linked list for storing match items for ":match" and
- * the match functions.
- */
+// matchitem_T provides a linked list for storing match items for ":match" and
+// the match functions.
 typedef struct matchitem matchitem_T;
 struct matchitem {
   matchitem_T *next;
@@ -1221,12 +1171,10 @@ struct window_S {
     int eob;
   } w_p_fcs_chars;
 
-  /*
-   * "w_topline", "w_leftcol" and "w_skipcol" specify the offsets for
-   * displaying the buffer.
-   */
-  linenr_T w_topline;               /* buffer line number of the line at the
-                                       top of the window */
+  // "w_topline", "w_leftcol" and "w_skipcol" specify the offsets for
+  // displaying the buffer.
+  linenr_T w_topline;               // buffer line number of the line at the
+                                    // top of the window
   char w_topline_was_set;           // flag set to true when topline is set,
                                     // e.g. by winrestview()
   int w_topfill;                    // number of filler lines above w_topline
@@ -1279,15 +1227,12 @@ struct window_S {
   int w_height_outer;
   int w_width_outer;
 
-  /*
-   * === start of cached values ====
-   */
-  /*
-   * Recomputing is minimized by storing the result of computations.
-   * Use functions in screen.c to check if they are valid and to update.
-   * w_valid is a bitfield of flags, which indicate if specific values are
-   * valid or need to be recomputed.
-   */
+  // === start of cached values ====
+
+  // Recomputing is minimized by storing the result of computations.
+  // Use functions in screen.c to check if they are valid and to update.
+  // w_valid is a bitfield of flags, which indicate if specific values are
+  // valid or need to be recomputed.
   int w_valid;
   pos_T w_valid_cursor;             /* last known position of w_cursor, used
                                        to adjust w_valid */
@@ -1295,10 +1240,8 @@ struct window_S {
 
   bool w_viewport_invalid;
 
-  /*
-   * w_cline_height is the number of physical lines taken by the buffer line
-   * that the cursor is on.  We use this to avoid extra calls to plines_win().
-   */
+  // w_cline_height is the number of physical lines taken by the buffer line
+  // that the cursor is on.  We use this to avoid extra calls to plines_win().
   int w_cline_height;               // current size of cursor line
   bool w_cline_folded;              // cursor line is folded
 
@@ -1311,11 +1254,9 @@ struct window_S {
                                     // more than one screen line or when
                                     // w_leftcol is non-zero
 
-  /*
-   * w_wrow and w_wcol specify the cursor position in the window.
-   * This is related to positions in the window, not in the display or
-   * buffer, thus w_wrow is relative to w_winrow.
-   */
+  // w_wrow and w_wcol specify the cursor position in the window.
+  // This is related to positions in the window, not in the display or
+  // buffer, thus w_wrow is relative to w_winrow.
   int w_wrow, w_wcol;               // cursor position in window
 
   linenr_T w_botline;               // number of the line below the bottom of
@@ -1324,16 +1265,14 @@ struct window_S {
   int w_filler_rows;                // number of filler rows at the end of the
                                     // window
 
-  /*
-   * Info about the lines currently in the window is remembered to avoid
-   * recomputing it every time.  The allocated size of w_lines[] is Rows.
-   * Only the w_lines_valid entries are actually valid.
-   * When the display is up-to-date w_lines[0].wl_lnum is equal to w_topline
-   * and w_lines[w_lines_valid - 1].wl_lnum is equal to w_botline.
-   * Between changing text and updating the display w_lines[] represents
-   * what is currently displayed.  wl_valid is reset to indicated this.
-   * This is used for efficient redrawing.
-   */
+  // Info about the lines currently in the window is remembered to avoid
+  // recomputing it every time.  The allocated size of w_lines[] is Rows.
+  // Only the w_lines_valid entries are actually valid.
+  // When the display is up-to-date w_lines[0].wl_lnum is equal to w_topline
+  // and w_lines[w_lines_valid - 1].wl_lnum is equal to w_botline.
+  // Between changing text and updating the display w_lines[] represents
+  // what is currently displayed.  wl_valid is reset to indicated this.
+  // This is used for efficient redrawing.
   int w_lines_valid;                // number of valid entries
   wline_T *w_lines;
 
@@ -1346,9 +1285,7 @@ struct window_S {
                                     // column being used
   int w_scwidth;                    // width of 'signcolumn'
 
-  /*
-   * === end of cached values ===
-   */
+  // === end of cached values ===
 
   int w_redr_type;                  // type of redraw to be performed on win
   int w_upd_rows;                   // number of window lines to update when
@@ -1406,17 +1343,13 @@ struct window_S {
   ScopeDictDictItem w_winvar;  ///< Variable for "w:" dictionary.
   dict_T *w_vars;  ///< Dictionary with w: variables.
 
-  /*
-   * The w_prev_pcmark field is used to check whether we really did jump to
-   * a new line after setting the w_pcmark.  If not, then we revert to
-   * using the previous w_pcmark.
-   */
+  // The w_prev_pcmark field is used to check whether we really did jump to
+  // a new line after setting the w_pcmark.  If not, then we revert to
+  // using the previous w_pcmark.
   pos_T w_pcmark;               // previous context mark
   pos_T w_prev_pcmark;          // previous w_pcmark
 
-  /*
-   * the jumplist contains old cursor positions
-   */
+  // the jumplist contains old cursor positions
   xfmark_T w_jumplist[JUMPLISTSIZE];
   int w_jumplistlen;                    // number of active entries
   int w_jumplistidx;                    // current position
@@ -1426,12 +1359,10 @@ struct window_S {
   matchitem_T *w_match_head;            // head of match list
   int w_next_match_id;                  // next match ID
 
-  /*
-   * the tagstack grows from 0 upwards:
-   * entry 0: older
-   * entry 1: newer
-   * entry 2: newest
-   */
+  // the tagstack grows from 0 upwards:
+  // entry 0: older
+  // entry 1: newer
+  // entry 2: newest
   taggy_T w_tagstack[TAGSTACKSIZE];     // the tag stack
   int w_tagstackidx;                    // idx just below active entry
   int w_tagstacklen;                    // number of tags on stack
@@ -1442,12 +1373,10 @@ struct window_S {
   bool w_floating;                       ///< whether the window is floating
   FloatConfig w_float_config;
 
-  /*
-   * w_fraction is the fractional row of the cursor within the window, from
-   * 0 at the top row to FRACTION_MULT at the last row.
-   * w_prev_fraction_row was the actual cursor row when w_fraction was last
-   * calculated.
-   */
+  // w_fraction is the fractional row of the cursor within the window, from
+  // 0 at the top row to FRACTION_MULT at the last row.
+  // w_prev_fraction_row was the actual cursor row when w_fraction was last
+  // calculated.
   int w_fraction;
   int w_prev_fraction_row;
 
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index eac184c096..b85d349726 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * edit.c: functions for Insert mode
- */
+// edit.c: functions for Insert mode
 
 #include <assert.h>
 #include <inttypes.h>
@@ -1359,9 +1357,7 @@ void ins_redraw(bool ready)
   emsg_on_display = false;      // may remove error message now
 }
 
-/*
- * Handle a CTRL-V or CTRL-Q typed in Insert mode.
- */
+// Handle a CTRL-V or CTRL-Q typed in Insert mode.
 static void ins_ctrl_v(void)
 {
   int c;
@@ -1391,10 +1387,8 @@ static void ins_ctrl_v(void)
   revins_legal++;
 }
 
-/*
- * Put a character directly onto the screen.  It's not stored in a buffer.
- * Used while handling CTRL-K, CTRL-V, etc. in Insert mode.
- */
+// Put a character directly onto the screen.  It's not stored in a buffer.
+// Used while handling CTRL-K, CTRL-V, etc. in Insert mode.
 static int pc_status;
 #define PC_STATUS_UNSET 0       // pc_bytes was not set
 #define PC_STATUS_RIGHT 1       // right half of double-wide char
@@ -1511,9 +1505,7 @@ bool prompt_curpos_editable(void)
          && curwin->w_cursor.col >= (int)STRLEN(prompt_text());
 }
 
-/*
- * Undo the previous edit_putchar().
- */
+// Undo the previous edit_putchar().
 void edit_unputchar(void)
 {
   if (pc_status != PC_STATUS_UNSET && pc_row >= msg_scrolled) {
@@ -1528,10 +1520,8 @@ void edit_unputchar(void)
   }
 }
 
-/*
- * Called when p_dollar is set: display a '$' at the end of the changed text
- * Only works when cursor is in the line that changes.
- */
+// Called when p_dollar is set: display a '$' at the end of the changed text
+// Only works when cursor is in the line that changes.
 void display_dollar(colnr_T col)
 {
   colnr_T save_col;
@@ -1554,10 +1544,8 @@ void display_dollar(colnr_T col)
   curwin->w_cursor.col = save_col;
 }
 
-/*
- * Call this function before moving the cursor from the normal insert position
- * in insert mode.
- */
+// Call this function before moving the cursor from the normal insert position
+// in insert mode.
 void undisplay_dollar(void)
 {
   if (dollar_vcol >= 0) {
@@ -1600,11 +1588,9 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   vc = getvcol_nolist(&curwin->w_cursor);
   vcol = vc;
 
-  /*
-   * For Replace mode we need to fix the replace stack later, which is only
-   * possible when the cursor is in the indent.  Remember the number of
-   * characters before the cursor if it's possible.
-   */
+  // For Replace mode we need to fix the replace stack later, which is only
+  // possible when the cursor is in the indent.  Remember the number of
+  // characters before the cursor if it's possible.
   start_col = curwin->w_cursor.col;
 
   // determine offset from first non-blank
@@ -1614,10 +1600,8 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
 
   insstart_less = curwin->w_cursor.col;
 
-  /*
-   * If the cursor is in the indent, compute how many screen columns the
-   * cursor is to the left of the first non-blank.
-   */
+  // If the cursor is in the indent, compute how many screen columns the
+  // cursor is to the left of the first non-blank.
   if (new_cursor_col < 0) {
     vcol = get_indent() - vcol;
   }
@@ -1626,9 +1610,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     start_col = -1;
   }
 
-  /*
-   * Set the new indent.  The cursor will be put on the first non-blank.
-   */
+  // Set the new indent.  The cursor will be put on the first non-blank.
   if (type == INDENT_SET) {
     (void)set_indent(amount, call_changed_bytes ? SIN_CHANGED : 0);
   } else {
@@ -1643,20 +1625,16 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   }
   insstart_less -= curwin->w_cursor.col;
 
-  /*
-   * Try to put cursor on same character.
-   * If the cursor is at or after the first non-blank in the line,
-   * compute the cursor column relative to the column of the first
-   * non-blank character.
-   * If we are not in insert mode, leave the cursor on the first non-blank.
-   * If the cursor is before the first non-blank, position it relative
-   * to the first non-blank, counted in screen columns.
-   */
+  // Try to put cursor on same character.
+  // If the cursor is at or after the first non-blank in the line,
+  // compute the cursor column relative to the column of the first
+  // non-blank character.
+  // If we are not in insert mode, leave the cursor on the first non-blank.
+  // If the cursor is before the first non-blank, position it relative
+  // to the first non-blank, counted in screen columns.
   if (new_cursor_col >= 0) {
-    /*
-     * When changing the indent while the cursor is touching it, reset
-     * Insstart_col to 0.
-     */
+    // When changing the indent while the cursor is touching it, reset
+    // Insstart_col to 0.
     if (new_cursor_col == 0) {
       insstart_less = MAXCOL;
     }
@@ -1687,10 +1665,8 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     new_cursor_col = (int)(cts.cts_ptr - cts.cts_line);
     clear_chartabsize_arg(&cts);
 
-    /*
-     * May need to insert spaces to be able to position the cursor on
-     * the right screen column.
-     */
+    // May need to insert spaces to be able to position the cursor on
+    // the right screen column.
     if (vcol != (int)curwin->w_virtcol) {
       curwin->w_cursor.col = (colnr_T)new_cursor_col;
       size_t i = (size_t)(curwin->w_virtcol - vcol);
@@ -1701,10 +1677,8 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
       xfree(ptr);
     }
 
-    /*
-     * When changing the indent while the cursor is in it, reset
-     * Insstart_col to 0.
-     */
+    // When changing the indent while the cursor is in it, reset
+    // Insstart_col to 0.
     insstart_less = MAXCOL;
   }
 
@@ -1718,9 +1692,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   curwin->w_set_curswant = true;
   changed_cline_bef_curs();
 
-  /*
-   * May have to adjust the start of the insert.
-   */
+  // May have to adjust the start of the insert.
   if (State & MODE_INSERT) {
     if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0) {
       if ((int)Insstart.col <= insstart_less) {
@@ -1998,15 +1970,13 @@ static void insert_special(int c, int allow_modmask, int ctrlv)
   }
 }
 
-/*
- * Special characters in this context are those that need processing other
- * than the simple insertion that can be performed here. This includes ESC
- * which terminates the insert, and CR/NL which need special processing to
- * open up a new line. This routine tries to optimize insertions performed by
- * the "redo", "undo" or "put" commands, so it needs to know when it should
- * stop and defer processing to the "normal" mechanism.
- * '0' and '^' are special, because they can be followed by CTRL-D.
- */
+// Special characters in this context are those that need processing other
+// than the simple insertion that can be performed here. This includes ESC
+// which terminates the insert, and CR/NL which need special processing to
+// open up a new line. This routine tries to optimize insertions performed by
+// the "redo", "undo" or "put" commands, so it needs to know when it should
+// stop and defer processing to the "normal" mechanism.
+// '0' and '^' are special, because they can be followed by CTRL-D.
 #define ISSPECIAL(c)   ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^')
 
 ///
@@ -2207,9 +2177,7 @@ void insertchar(int c, int flags, int second_indent)
   }
 }
 
-/*
- * Put a character in the redo buffer, for when just after a CTRL-V.
- */
+// Put a character in the redo buffer, for when just after a CTRL-V.
 static void redo_literal(int c)
 {
   char buf[10];
@@ -2259,10 +2227,8 @@ static void start_arrow_common(pos_T *end_insert_pos, bool end_change)
   check_spell_redraw();
 }
 
-/*
- * If we skipped highlighting word at cursor, do it now.
- * It may be skipped again, thus reset spell_redraw_lnum first.
- */
+// If we skipped highlighting word at cursor, do it now.
+// It may be skipped again, thus reset spell_redraw_lnum first.
 static void check_spell_redraw(void)
 {
   if (spell_redraw_lnum != 0) {
@@ -2273,11 +2239,9 @@ static void check_spell_redraw(void)
   }
 }
 
-/*
- * stop_arrow() is called before a change is made in insert mode.
- * If an arrow key has been used, start a new insertion.
- * Returns FAIL if undo is impossible, shouldn't insert then.
- */
+// stop_arrow() is called before a change is made in insert mode.
+// If an arrow key has been used, start a new insertion.
+// Returns FAIL if undo is impossible, shouldn't insert then.
 int stop_arrow(void)
 {
   if (arrow_used) {
@@ -2327,11 +2291,9 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
   stop_redo_ins();
   replace_flush();              // abandon replace stack
 
-  /*
-   * Save the inserted text for later redo with ^@ and CTRL-A.
-   * Don't do it when "restart_edit" was set and nothing was inserted,
-   * otherwise CTRL-O w and then <Left> will clear "last_insert".
-   */
+  // Save the inserted text for later redo with ^@ and CTRL-A.
+  // Don't do it when "restart_edit" was set and nothing was inserted,
+  // otherwise CTRL-O w and then <Left> will clear "last_insert".
   ptr = get_inserted();
   if (did_restart_edit == 0 || (ptr != NULL
                                 && (int)STRLEN(ptr) > new_insert_skip)) {
@@ -2438,10 +2400,8 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
   }
 }
 
-/*
- * Set the last inserted text to a single character.
- * Used for the replace command.
- */
+// Set the last inserted text to a single character.
+// Used for the replace command.
 void set_last_insert(int c)
 {
   char_u *s;
@@ -2466,13 +2426,11 @@ void free_last_insert(void)
 }
 #endif
 
-/*
- * move cursor to start of line
- * if flags & BL_WHITE  move to first non-white
- * if flags & BL_SOL    move to first non-white if startofline is set,
- *                          otherwise keep "curswant" column
- * if flags & BL_FIX    don't leave the cursor on a NUL.
- */
+// move cursor to start of line
+// if flags & BL_WHITE  move to first non-white
+// if flags & BL_SOL    move to first non-white if startofline is set,
+//                          otherwise keep "curswant" column
+// if flags & BL_FIX    don't leave the cursor on a NUL.
 void beginline(int flags)
 {
   if ((flags & BL_SOL) && !p_sol) {
@@ -2493,13 +2451,11 @@ void beginline(int flags)
   }
 }
 
-/*
- * oneright oneleft cursor_down cursor_up
- *
- * Move one char {right,left,down,up}.
- * Doesn't move onto the NUL past the end of the line, unless it is allowed.
- * Return OK when successful, FAIL when we hit a line of file boundary.
- */
+// oneright oneleft cursor_down cursor_up
+//
+// Move one char {right,left,down,up}.
+// Doesn't move onto the NUL past the end of the line, unless it is allowed.
+// Return OK when successful, FAIL when we hit a line of file boundary.
 
 int oneright(void)
 {
@@ -2600,9 +2556,8 @@ int cursor_up(long n, int upd_topline)
     if (n >= lnum) {
       lnum = 1;
     } else if (hasAnyFolding(curwin)) {
-      /*
-       * Count each sequence of folded lines as one logical line.
-       */
+      // Count each sequence of folded lines as one logical line.
+
       // go to the start of the current fold
       (void)hasFolding(lnum, &lnum, NULL);
 
@@ -2761,10 +2716,8 @@ char_u *get_last_insert(void)
   return last_insert + last_insert_skip;
 }
 
-/*
- * Get last inserted string, and remove trailing <Esc>.
- * Returns pointer to allocated memory (must be freed) or NULL.
- */
+// Get last inserted string, and remove trailing <Esc>.
+// Returns pointer to allocated memory (must be freed) or NULL.
 char_u *get_last_insert_save(void)
 {
   char_u *s;
@@ -2803,20 +2756,18 @@ static bool echeck_abbr(int c)
                     curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
 }
 
-/*
- * replace-stack functions
- *
- * When replacing characters, the replaced characters are remembered for each
- * new character.  This is used to re-insert the old text when backspacing.
- *
- * There is a NUL headed list of characters for each character that is
- * currently in the file after the insertion point.  When BS is used, one NUL
- * headed list is put back for the deleted character.
- *
- * For a newline, there are two NUL headed lists.  One contains the characters
- * that the NL replaced.  The extra one stores the characters after the cursor
- * that were deleted (always white space).
- */
+// replace-stack functions
+//
+// When replacing characters, the replaced characters are remembered for each
+// new character.  This is used to re-insert the old text when backspacing.
+//
+// There is a NUL headed list of characters for each character that is
+// currently in the file after the insertion point.  When BS is used, one NUL
+// headed list is put back for the deleted character.
+//
+// For a newline, there are two NUL headed lists.  One contains the characters
+// that the NL replaced.  The extra one stores the characters after the cursor
+// that were deleted (always white space).
 
 static char_u *replace_stack = NULL;
 static ssize_t replace_stack_nr = 0;           // next entry in replace stack
@@ -2901,10 +2852,8 @@ static void replace_pop_ins(void)
   State = oldState;
 }
 
-/*
- * Insert bytes popped from the replace stack. "cc" is the first byte.  If it
- * indicates a multi-byte char, pop the other bytes too.
- */
+// Insert bytes popped from the replace stack. "cc" is the first byte.  If it
+// indicates a multi-byte char, pop the other bytes too.
 static void mb_replace_pop_ins(int cc)
 {
   int n;
@@ -2951,10 +2900,8 @@ static void mb_replace_pop_ins(int cc)
   }
 }
 
-/*
- * make the replace stack empty
- * (called when exiting replace mode)
- */
+// make the replace stack empty
+// (called when exiting replace mode)
 static void replace_flush(void)
 {
   XFREE_CLEAR(replace_stack);
@@ -2962,15 +2909,13 @@ static void replace_flush(void)
   replace_stack_nr = 0;
 }
 
-/*
- * Handle doing a BS for one character.
- * cc < 0: replace stack empty, just move cursor
- * cc == 0: character was inserted, delete it
- * cc > 0: character was replaced, put cc (first byte of original char) back
- * and check for more characters to be put back
- * When "limit_col" is >= 0, don't delete before this column.  Matters when
- * using composing characters, use del_char_after_col() instead of del_char().
- */
+// Handle doing a BS for one character.
+// cc < 0: replace stack empty, just move cursor
+// cc == 0: character was inserted, delete it
+// cc > 0: character was replaced, put cc (first byte of original char) back
+// and check for more characters to be put back
+// When "limit_col" is >= 0, don't delete before this column.  Matters when
+// using composing characters, use del_char_after_col() instead of del_char().
 static void replace_do_bs(int limit_col)
 {
   int cc;
@@ -3033,12 +2978,10 @@ bool cindent_on(void)
   return !p_paste && (curbuf->b_p_cin || *curbuf->b_p_inde != NUL);
 }
 
-/*
- * Re-indent the current line, based on the current contents of it and the
- * surrounding lines. Fixing the cursor position seems really easy -- I'm very
- * confused what all the part that handles Control-T is doing that I'm not.
- * "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent.
- */
+// Re-indent the current line, based on the current contents of it and the
+// surrounding lines. Fixing the cursor position seems really easy -- I'm very
+// confused what all the part that handles Control-T is doing that I'm not.
+// "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent.
 void fixthisline(IndentGetter get_the_indent)
 {
   int amount = get_the_indent();
@@ -3096,10 +3039,8 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
     look = (char_u *)curbuf->b_p_cink;            // 'indentexpr' empty: use 'cinkeys'
   }
   while (*look) {
-    /*
-     * Find out if we want to try a match with this key, depending on
-     * 'when' and a '*' or '!' before the key.
-     */
+    // Find out if we want to try a match with this key, depending on
+    // 'when' and a '*' or '!' before the key.
     switch (when) {
     case '*':
       try_match = (*look == '*'); break;
@@ -3286,9 +3227,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
   return false;
 }
 
-/*
- * Map Hebrew keyboard when in hkmap mode.
- */
+// Map Hebrew keyboard when in hkmap mode.
 int hkmap(int c)
   FUNC_ATTR_PURE
 {
@@ -3390,9 +3329,7 @@ static void ins_reg(void)
   int literally = 0;
   int vis_active = VIsual_active;
 
-  /*
-   * If we are going to wait for a character, show a '"'.
-   */
+  // If we are going to wait for a character, show a '"'.
   pc_status = PC_STATUS_UNSET;
   if (redrawing() && !char_avail()) {
     // may need to redraw when no more chars available now
@@ -3474,9 +3411,7 @@ static void ins_reg(void)
   }
 }
 
-/*
- * CTRL-G commands in Insert mode.
- */
+// CTRL-G commands in Insert mode.
 static void ins_ctrl_g(void)
 {
   int c;
@@ -3530,9 +3465,7 @@ static void ins_ctrl_g(void)
   }
 }
 
-/*
- * CTRL-^ in Insert mode.
- */
+// CTRL-^ in Insert mode.
 static void ins_ctrl_hat(void)
 {
   if (map_to_exists_mode("", MODE_LANGMAP, false)) {
@@ -3576,10 +3509,8 @@ static bool ins_esc(long *count, int cmdchar, bool nomove)
       AppendToRedobuff(ESC_STR);
     }
 
-    /*
-     * Repeating insert may take a long time.  Check for
-     * interrupt now and then.
-     */
+    // Repeating insert may take a long time.  Check for
+    // interrupt now and then.
     if (*count > 0) {
       line_breakcheck();
       if (got_int) {
@@ -3622,10 +3553,8 @@ static bool ins_esc(long *count, int cmdchar, bool nomove)
     RESET_FMARK(&curbuf->b_last_insert, curwin->w_cursor, curbuf->b_fnum, view);
   }
 
-  /*
-   * The cursor should end up on the last inserted character.
-   * Don't do it for CTRL-O, unless past the end of the line.
-   */
+  // The cursor should end up on the last inserted character.
+  // Don't do it for CTRL-O, unless past the end of the line.
   if (!nomove
       && (curwin->w_cursor.col != 0 || curwin->w_cursor.coladd > 0)
       && (restart_edit == NUL || (gchar_cursor() == NUL && !VIsual_active))
@@ -3663,10 +3592,8 @@ static bool ins_esc(long *count, int cmdchar, bool nomove)
   return true;
 }
 
-/*
- * Toggle language: hkmap and revins_on.
- * Move to end of reverse inserted text.
- */
+// Toggle language: hkmap and revins_on.
+// Move to end of reverse inserted text.
 static void ins_ctrl_(void)
 {
   if (revins_on && revins_chars && revins_scol >= 0) {
@@ -3733,9 +3660,7 @@ static bool ins_start_select(int c)
   return false;
 }
 
-/*
- * <Insert> key in Insert mode: toggle insert/replace mode.
- */
+// <Insert> key in Insert mode: toggle insert/replace mode.
 static void ins_insert(int replaceState)
 {
   set_vim_var_string(VV_INSERTMODE, ((State & REPLACE_FLAG) ? "i" :
@@ -3753,9 +3678,7 @@ static void ins_insert(int replaceState)
   ui_cursor_shape();            // may show different cursor shape
 }
 
-/*
- * Pressed CTRL-O in Insert mode.
- */
+// Pressed CTRL-O in Insert mode.
 static void ins_ctrl_o(void)
 {
   if (State & VREPLACE_FLAG) {
@@ -3772,13 +3695,11 @@ static void ins_ctrl_o(void)
   }
 }
 
-/*
- * If the cursor is on an indent, ^T/^D insert/delete one
- * shiftwidth.  Otherwise ^T/^D behave like a "<<" or ">>".
- * Always round the indent to 'shiftwidth', this is compatible
- * with vi.  But vi only supports ^T and ^D after an
- * autoindent, we support it everywhere.
- */
+// If the cursor is on an indent, ^T/^D insert/delete one
+// shiftwidth.  Otherwise ^T/^D behave like a "<<" or ">>".
+// Always round the indent to 'shiftwidth', this is compatible
+// with vi.  But vi only supports ^T and ^D after an
+// autoindent, we support it everywhere.
 static void ins_shift(int c, int lastc)
 {
   if (stop_arrow() == FAIL) {
@@ -3786,9 +3707,7 @@ static void ins_shift(int c, int lastc)
   }
   AppendCharToRedobuff(c);
 
-  /*
-   * 0^D and ^^D: remove all indent.
-   */
+  // 0^D and ^^D: remove all indent.
   if (c == Ctrl_D && (lastc == '0' || lastc == '^')
       && curwin->w_cursor.col > 0) {
     curwin->w_cursor.col--;
@@ -3844,9 +3763,7 @@ static void ins_del(void)
   AppendCharToRedobuff(K_DEL);
 }
 
-/*
- * Delete one character for ins_bs().
- */
+// Delete one character for ins_bs().
 static void ins_bs_one(colnr_T *vcolp)
 {
   dec_cursor();
@@ -3941,11 +3858,9 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
       Insstart.lnum--;
       Insstart.col = (colnr_T)STRLEN(ml_get(Insstart.lnum));
     }
-    /*
-     * In replace mode:
-     * cc < 0: NL was inserted, delete it
-     * cc >= 0: NL was replaced, put original characters back
-     */
+    // In replace mode:
+    // cc < 0: NL was inserted, delete it
+    // cc >= 0: NL was replaced, put original characters back
     cc = -1;
     if (State & REPLACE_FLAG) {
       cc = replace_pop();           // returns -1 if NL was inserted
@@ -4025,9 +3940,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
       curwin->w_cursor.col = save_col;
     }
 
-    /*
-     * Handle deleting one 'shiftwidth' or 'softtabstop'.
-     */
+    // Handle deleting one 'shiftwidth' or 'softtabstop'.
     if (mode == BACKSPACE_CHAR
         && ((p_sta && in_indent)
             || ((get_sts_value() != 0
@@ -4589,9 +4502,7 @@ static bool ins_tab(void)
     }
   }
 
-  /*
-   * When 'expandtab' not set: Replace spaces by TABs where possible.
-   */
+  // When 'expandtab' not set: Replace spaces by TABs where possible.
   if (!curbuf->b_p_et && (tabstop_count(curbuf->b_p_vsts_array) > 0
                           || get_sts_value() > 0
                           || (p_sta && ind))) {
@@ -4742,11 +4653,9 @@ bool ins_eol(int c)
   }
   undisplay_dollar();
 
-  /*
-   * Strange Vi behaviour: In Replace mode, typing a NL will not delete the
-   * character under the cursor.  Only push a NUL on the replace stack,
-   * nothing to put back when the NL is deleted.
-   */
+  // Strange Vi behaviour: In Replace mode, typing a NL will not delete the
+  // character under the cursor.  Only push a NUL on the replace stack,
+  // nothing to put back when the NL is deleted.
   if ((State & REPLACE_FLAG)
       && !(State & VREPLACE_FLAG)) {
     replace_push(NUL);
@@ -4780,11 +4689,9 @@ bool ins_eol(int c)
   return i;
 }
 
-/*
- * Handle digraph in insert mode.
- * Returns character still to be inserted, or NUL when nothing remaining to be
- * done.
- */
+// Handle digraph in insert mode.
+// Returns character still to be inserted, or NUL when nothing remaining to be
+// done.
 static int ins_digraph(void)
 {
   int c;
@@ -4853,10 +4760,8 @@ static int ins_digraph(void)
   return NUL;
 }
 
-/*
- * Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line.
- * Returns the char to be inserted, or NUL if none found.
- */
+// Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line.
+// Returns the char to be inserted, or NUL if none found.
 int ins_copychar(linenr_T lnum)
 {
   int c;
@@ -4894,9 +4799,7 @@ int ins_copychar(linenr_T lnum)
   return c;
 }
 
-/*
- * CTRL-Y or CTRL-E typed in Insert mode.
- */
+// CTRL-Y or CTRL-E typed in Insert mode.
 static int ins_ctrl_ey(int tc)
 {
   int c = tc;
@@ -4933,10 +4836,8 @@ static int ins_ctrl_ey(int tc)
   return c;
 }
 
-/*
- * Try to do some very smart auto-indenting.
- * Used when inserting a "normal" character.
- */
+// Try to do some very smart auto-indenting.
+// Used when inserting a "normal" character.
 static void ins_try_si(int c)
 {
   pos_T *pos, old_pos;
@@ -4944,20 +4845,16 @@ static void ins_try_si(int c)
   int i;
   bool temp;
 
-  /*
-   * do some very smart indenting when entering '{' or '}'
-   */
+  // do some very smart indenting when entering '{' or '}'
   if (((did_si || can_si_back) && c == '{') || (can_si && c == '}' && inindent(0))) {
     // for '}' set indent equal to indent of line containing matching '{'
     if (c == '}' && (pos = findmatch(NULL, '{')) != NULL) {
       old_pos = curwin->w_cursor;
-      /*
-       * If the matching '{' has a ')' immediately before it (ignoring
-       * white-space), then line up with the start of the line
-       * containing the matching '(' if there is one.  This handles the
-       * case where an "if (..\n..) {" statement continues over multiple
-       * lines -- webb
-       */
+      // If the matching '{' has a ')' immediately before it (ignoring
+      // white-space), then line up with the start of the line
+      // containing the matching '(' if there is one.  This handles the
+      // case where an "if (..\n..) {" statement continues over multiple
+      // lines -- webb
       ptr = (char_u *)ml_get(pos->lnum);
       i = pos->col;
       if (i > 0) {              // skip blanks before '{'
@@ -5001,9 +4898,7 @@ static void ins_try_si(int c)
     }
   }
 
-  /*
-   * set indent of '#' always to 0
-   */
+  // set indent of '#' always to 0
   if (curwin->w_cursor.col > 0 && can_si && c == '#' && inindent(0)) {
     // remember current indent for next line
     old_indent = get_indent();
@@ -5016,10 +4911,8 @@ static void ins_try_si(int c)
   }
 }
 
-/*
- * Get the value that w_virtcol would have when 'list' is off.
- * Unless 'cpo' contains the 'L' flag.
- */
+// Get the value that w_virtcol would have when 'list' is off.
+// Unless 'cpo' contains the 'L' flag.
 colnr_T get_nolist_virtcol(void)
 {
   // check validity of cursor in current buffer
@@ -5034,12 +4927,10 @@ colnr_T get_nolist_virtcol(void)
   return curwin->w_virtcol;
 }
 
-/*
- * Handle the InsertCharPre autocommand.
- * "c" is the character that was typed.
- * Return a pointer to allocated memory with the replacement string.
- * Return NULL to continue inserting "c".
- */
+// Handle the InsertCharPre autocommand.
+// "c" is the character that was typed.
+// Return a pointer to allocated memory with the replacement string.
+// Return NULL to continue inserting "c".
 static char_u *do_insert_char_pre(int c)
 {
   char buf[MB_MAXBYTES + 1];
diff --git a/src/nvim/eval.h b/src/nvim/eval.h
index b0cb5fd8c1..afebdf5acb 100644
--- a/src/nvim/eval.h
+++ b/src/nvim/eval.h
@@ -11,33 +11,31 @@
 #define COPYID_INC 2
 #define COPYID_MASK (~0x1)
 
-/*
- * Structure returned by get_lval() and used by set_var_lval().
- * For a plain name:
- *      "name"      points to the variable name.
- *      "exp_name"  is NULL.
- *      "tv"        is NULL
- * For a magic braces name:
- *      "name"      points to the expanded variable name.
- *      "exp_name"  is non-NULL, to be freed later.
- *      "tv"        is NULL
- * For an index in a list:
- *      "name"      points to the (expanded) variable name.
- *      "exp_name"  NULL or non-NULL, to be freed later.
- *      "tv"        points to the (first) list item value
- *      "li"        points to the (first) list item
- *      "range", "n1", "n2" and "empty2" indicate what items are used.
- * For an existing Dict item:
- *      "name"      points to the (expanded) variable name.
- *      "exp_name"  NULL or non-NULL, to be freed later.
- *      "tv"        points to the dict item value
- *      "newkey"    is NULL
- * For a non-existing Dict item:
- *      "name"      points to the (expanded) variable name.
- *      "exp_name"  NULL or non-NULL, to be freed later.
- *      "tv"        points to the Dictionary typval_T
- *      "newkey"    is the key for the new item.
- */
+// Structure returned by get_lval() and used by set_var_lval().
+// For a plain name:
+//      "name"      points to the variable name.
+//      "exp_name"  is NULL.
+//      "tv"        is NULL
+// For a magic braces name:
+//      "name"      points to the expanded variable name.
+//      "exp_name"  is non-NULL, to be freed later.
+//      "tv"        is NULL
+// For an index in a list:
+//      "name"      points to the (expanded) variable name.
+//      "exp_name"  NULL or non-NULL, to be freed later.
+//      "tv"        points to the (first) list item value
+//      "li"        points to the (first) list item
+//      "range", "n1", "n2" and "empty2" indicate what items are used.
+// For an existing Dict item:
+//      "name"      points to the (expanded) variable name.
+//      "exp_name"  NULL or non-NULL, to be freed later.
+//      "tv"        points to the dict item value
+//      "newkey"    is NULL
+// For a non-existing Dict item:
+//      "name"      points to the (expanded) variable name.
+//      "exp_name"  NULL or non-NULL, to be freed later.
+//      "tv"        points to the Dictionary typval_T
+//      "newkey"    is the key for the new item.
 typedef struct lval_S {
   const char *ll_name;  ///< Start of variable name (can be NULL).
   size_t ll_name_len;   ///< Length of the .ll_name.
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 6611133ea4..3ab66c319f 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -1576,16 +1576,14 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
       // Find the function name in the table, call its implementation.
       error = call_internal_func((char_u *)fname, argcount, argvars, rettv);
     }
-    /*
-     * The function call (or "FuncUndefined" autocommand sequence) might
-     * have been aborted by an error, an interrupt, or an explicitly thrown
-     * exception that has not been caught so far.  This situation can be
-     * tested for by calling aborting().  For an error in an internal
-     * function or for the "E132" error in call_user_func(), however, the
-     * throw point at which the "force_abort" flag (temporarily reset by
-     * emsg()) is normally updated has not been reached yet. We need to
-     * update that flag first to make aborting() reliable.
-     */
+    // The function call (or "FuncUndefined" autocommand sequence) might
+    // have been aborted by an error, an interrupt, or an explicitly thrown
+    // exception that has not been caught so far.  This situation can be
+    // tested for by calling aborting().  For an error in an internal
+    // function or for the "E132" error in call_user_func(), however, the
+    // throw point at which the "force_abort" flag (temporarily reset by
+    // emsg()) is normally updated has not been reached yet. We need to
+    // update that flag first to make aborting() reliable.
     update_force_abort();
   }
   if (error == ERROR_NONE) {
@@ -1720,11 +1718,9 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
     goto theend;
   }
   if (end == NULL || (lv.ll_tv != NULL && (lead > 2 || lv.ll_range))) {
-    /*
-     * Report an invalid expression in braces, unless the expression
-     * evaluation has been cancelled due to an aborting error, an
-     * interrupt, or an exception.
-     */
+    // Report an invalid expression in braces, unless the expression
+    // evaluation has been cancelled due to an aborting error, an
+    // interrupt, or an exception.
     if (!aborting()) {
       if (end != NULL) {
         semsg(_(e_invarg2), start);
@@ -1923,9 +1919,7 @@ void ex_function(exarg_T *eap)
   bool show_block = false;
   bool do_concat = true;
 
-  /*
-   * ":function" without argument: list functions.
-   */
+  // ":function" without argument: list functions.
   if (ends_excmd(*eap->arg)) {
     if (!eap->skip) {
       todo = (int)func_hashtab.ht_used;
@@ -1946,9 +1940,7 @@ void ex_function(exarg_T *eap)
     return;
   }
 
-  /*
-   * ":function /pat": list functions matching pattern.
-   */
+  // ":function /pat": list functions matching pattern.
   if (*eap->arg == '/') {
     p = skip_regexp(eap->arg + 1, '/', true, NULL);
     if (!eap->skip) {
@@ -2000,11 +1992,9 @@ void ex_function(exarg_T *eap)
   name = (char *)trans_function_name(&p, eap->skip, TFN_NO_AUTOLOAD, &fudi, NULL);
   paren = (vim_strchr(p, '(') != NULL);
   if (name == NULL && (fudi.fd_dict == NULL || !paren) && !eap->skip) {
-    /*
-     * Return on an invalid expression in braces, unless the expression
-     * evaluation has been cancelled due to an aborting error, an
-     * interrupt, or an exception.
-     */
+    // Return on an invalid expression in braces, unless the expression
+    // evaluation has been cancelled due to an aborting error, an
+    // interrupt, or an exception.
     if (!aborting()) {
       if (fudi.fd_newkey != NULL) {
         semsg(_(e_dictkey), fudi.fd_newkey);
@@ -2069,9 +2059,7 @@ void ex_function(exarg_T *eap)
     goto ret_free;
   }
 
-  /*
-   * ":function name(arg1, arg2)" Define function.
-   */
+  // ":function name(arg1, arg2)" Define function.
   p = skipwhite(p);
   if (*p != '(') {
     if (!eap->skip) {
@@ -2154,9 +2142,7 @@ void ex_function(exarg_T *eap)
     semsg(_(e_trailing_arg), p);
   }
 
-  /*
-   * Read the body of the function, until ":endfunction" is found.
-   */
+  // Read the body of the function, until ":endfunction" is found.
   if (KeyTyped) {
     // Check if the function already exists, don't let the user type the
     // whole function before telling him it doesn't work!  For a script we
@@ -2410,9 +2396,7 @@ void ex_function(exarg_T *eap)
     goto erret;
   }
 
-  /*
-   * If there are no errors, add the function
-   */
+  // If there are no errors, add the function
   if (fudi.fd_dict == NULL) {
     v = find_var((const char *)name, STRLEN(name), &ht, false);
     if (v != NULL && v->di_tv.v_type == VAR_FUNC) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 126129b24d..8f256728e3 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * ex_cmds.c: some functions for command line commands
- */
+// ex_cmds.c: some functions for command line commands
 
 #include <assert.h>
 #include <float.h>
@@ -249,11 +247,9 @@ void ex_align(exarg_T *eap)
       indent = width;
     }
   } else {
-    /*
-     * if 'textwidth' set, use it
-     * else if 'wrapmargin' set, use it
-     * if invalid value, use 80
-     */
+    // if 'textwidth' set, use it
+    // else if 'wrapmargin' set, use it
+    // if invalid value, use 80
     if (width <= 0) {
       width = (int)curbuf->b_p_tw;
     }
@@ -287,18 +283,14 @@ void ex_align(exarg_T *eap)
       } else {
         new_indent = width - len;               // right align
 
-        /*
-         * Make sure that embedded TABs don't make the text go too far
-         * to the right.
-         */
+        // Make sure that embedded TABs don't make the text go too far
+        // to the right.
         if (has_tab) {
           while (new_indent > 0) {
             (void)set_indent(new_indent, 0);
             if (linelen(NULL) <= width) {
-              /*
-               * Now try to move the line as much as possible to
-               * the right.  Stop when it moves too far.
-               */
+              // Now try to move the line as much as possible to
+              // the right.  Stop when it moves too far.
               do {
                 (void)set_indent(++new_indent, 0);
               } while (linelen(NULL) <= width);
@@ -933,10 +925,8 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
 
   num_lines = line2 - line1 + 1;
 
-  /*
-   * First we copy the old text to its new location -- webb
-   * Also copy the flag that ":global" command uses.
-   */
+  // First we copy the old text to its new location -- webb
+  // Also copy the flag that ":global" command uses.
   if (u_save(dest, dest + 1) == FAIL) {
     return FAIL;
   }
@@ -949,21 +939,19 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
     }
   }
 
-  /*
-   * Now we must be careful adjusting our marks so that we don't overlap our
-   * mark_adjust() calls.
-   *
-   * We adjust the marks within the old text so that they refer to the
-   * last lines of the file (temporarily), because we know no other marks
-   * will be set there since these line numbers did not exist until we added
-   * our new lines.
-   *
-   * Then we adjust the marks on lines between the old and new text positions
-   * (either forwards or backwards).
-   *
-   * 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
-   */
+  // Now we must be careful adjusting our marks so that we don't overlap our
+  // mark_adjust() calls.
+  //
+  // We adjust the marks within the old text so that they refer to the
+  // last lines of the file (temporarily), because we know no other marks
+  // will be set there since these line numbers did not exist until we added
+  // our new lines.
+  //
+  // Then we adjust the marks on lines between the old and new text positions
+  // (either forwards or backwards).
+  //
+  // 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
   last_line = curbuf->b_ml.ml_line_count;
   mark_adjust_nofold(line1, line2, last_line - line2, 0L, kExtmarkNOOP);
 
@@ -1011,9 +999,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
   // send update regarding the new lines that were added
   buf_updates_send_changes(curbuf, dest + 1, num_lines, 0);
 
-  /*
-   * Now we delete the original text -- webb
-   */
+  // Now we delete the original text -- webb
   if (u_save(line1 + extra - 1, line2 + extra + 1) == FAIL) {
     return FAIL;
   }
@@ -1030,9 +1016,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
                       dest + line_off, 0, dest_byte + byte_off,
                       kExtmarkUndo);
 
-  /*
-   * Leave the cursor on the last of the moved lines.
-   */
+  // Leave the cursor on the last of the moved lines.
   if (dest >= line1) {
     curwin->w_cursor.lnum = dest;
   } else {
@@ -1069,17 +1053,15 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
     curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
   }
 
-  /*
-   * there are three situations:
-   * 1. destination is above line1
-   * 2. destination is between line1 and line2
-   * 3. destination is below line2
-   *
-   * n = destination (when starting)
-   * curwin->w_cursor.lnum = destination (while copying)
-   * line1 = start of source (while copying)
-   * line2 = end of source (while copying)
-   */
+  // there are three situations:
+  // 1. destination is above line1
+  // 2. destination is between line1 and line2
+  // 3. destination is below line2
+  //
+  // n = destination (when starting)
+  // curwin->w_cursor.lnum = destination (while copying)
+  // line1 = start of source (while copying)
+  // line2 = end of source (while copying)
   if (u_save(n, n + 1) == FAIL) {
     return;
   }
@@ -1155,10 +1137,8 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
     msg_scroll = scroll_save;
   }
 
-  /*
-   * Try to find an embedded bang, like in :!<cmd> ! [args]
-   * (:!! is indicated by the 'forceit' variable)
-   */
+  // Try to find an embedded bang, like in :!<cmd> ! [args]
+  // (:!! is indicated by the 'forceit' variable)
   bool ins_prevcmd = forceit;
   trailarg = arg;
   do {
@@ -1187,10 +1167,8 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
     xfree(newcmd);
     newcmd = t;
 
-    /*
-     * Scan the rest of the argument for '!', which is replaced by the
-     * previous command.  "\!" is replaced by "!" (this is vi compatible).
-     */
+    // Scan the rest of the argument for '!', which is replaced by the
+    // previous command.  "\!" is replaced by "!" (this is vi compatible).
     trailarg = NULL;
     while (*p) {
       if (*p == '!') {
@@ -1221,9 +1199,7 @@ void do_bang(int addr_count, exarg_T *eap, bool forceit, bool do_in, bool do_out
     AppendToRedobuff("\n");
     bangredo = false;
   }
-  /*
-   * Add quotes around the command, for shells that need them.
-   */
+  // Add quotes around the command, for shells that need them.
   if (*p_shq != NUL) {
     newcmd = xmalloc(STRLEN(prevcmd) + 2 * STRLEN(p_shq) + 1);
     STRCPY(newcmd, p_shq);
@@ -1298,18 +1274,16 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
   changed_line_abv_curs();
   invalidate_botline();
 
-  /*
-   * When using temp files:
-   * 1. * Form temp file names
-   * 2. * Write the lines to a temp file
-   * 3.   Run the filter command on the temp file
-   * 4. * Read the output of the command into the buffer
-   * 5. * Delete the original lines to be filtered
-   * 6. * Remove the temp files
-   *
-   * When writing the input with a pipe or when catching the output with a
-   * pipe only need to do 3.
-   */
+  // When using temp files:
+  // 1. * Form temp file names
+  // 2. * Write the lines to a temp file
+  // 3.   Run the filter command on the temp file
+  // 4. * Read the output of the command into the buffer
+  // 5. * Delete the original lines to be filtered
+  // 6. * Remove the temp files
+  //
+  // When writing the input with a pipe or when catching the output with a
+  // pipe only need to do 3.
 
   if (do_out) {
     shell_flags |= kShellOptDoOut;
@@ -1337,10 +1311,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
     goto filterend;
   }
 
-  /*
-   * The writing and reading of temp files will not be shown.
-   * Vi also doesn't do this and the messages are not very informative.
-   */
+  // The writing and reading of temp files will not be shown.
+  // Vi also doesn't do this and the messages are not very informative.
   no_wait_return++;             // don't call wait_return() while busy
   if (itmp != NULL && buf_write(curbuf, itmp, NULL, line1, line2, eap,
                                 false, false, false, true) == FAIL) {
@@ -1428,10 +1400,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
         }
       }
 
-      /*
-       * Put cursor on first filtered line for ":range!cmd".
-       * Adjust '[ and '] (set by buf_write()).
-       */
+      // Put cursor on first filtered line for ":range!cmd".
+      // Adjust '[ and '] (set by buf_write()).
       curwin->w_cursor.lnum = line1;
       del_lines(linecount, true);
       curbuf->b_op_start.lnum -= linecount;             // adjust '[
@@ -1440,9 +1410,7 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
                                                         // for next write
       foldUpdate(curwin, curbuf->b_op_start.lnum, curbuf->b_op_end.lnum);
     } else {
-      /*
-       * Put cursor on last new line for ":r !cmd".
-       */
+      // Put cursor on last new line for ":r !cmd".
       linecount = curbuf->b_op_end.lnum - curbuf->b_op_start.lnum + 1;
       curwin->w_cursor.lnum = curbuf->b_op_end.lnum;
     }
@@ -1504,10 +1472,8 @@ void do_shell(char *cmd, int flags)
     return;
   }
 
-  /*
-   * For autocommands we want to get the output on the current screen, to
-   * avoid having to type return below.
-   */
+  // For autocommands we want to get the output on the current screen, to
+  // avoid having to type return below.
   msg_putchar('\r');                    // put cursor at start of line
   msg_putchar('\n');                    // may shift screen one line up
 
@@ -1740,13 +1706,11 @@ int rename_buffer(char *new_fname)
   if (aborting()) {         // autocmds may abort script processing
     return FAIL;
   }
-  /*
-   * The name of the current buffer will be changed.
-   * A new (unlisted) buffer entry needs to be made to hold the old file
-   * name, which will become the alternate file name.
-   * But don't set the alternate file name if the buffer didn't have a
-   * name.
-   */
+  // The name of the current buffer will be changed.
+  // A new (unlisted) buffer entry needs to be made to hold the old file
+  // name, which will become the alternate file name.
+  // But don't set the alternate file name if the buffer didn't have a
+  // name.
   fname = curbuf->b_ffname;
   sfname = curbuf->b_sfname;
   xfname = curbuf->b_fname;
@@ -1860,9 +1824,7 @@ int do_write(exarg_T *eap)
     other = otherfile(ffname);
   }
 
-  /*
-   * If we have a new file, put its name in the list of alternate file names.
-   */
+  // If we have a new file, put its name in the list of alternate file names.
   if (other) {
     if (vim_strchr(p_cpo, CPO_ALTWRITE) != NULL
         || eap->cmdidx == CMD_saveas) {
@@ -2113,13 +2075,11 @@ void do_wqall(exarg_T *eap)
     } else if (!bufIsChanged(buf) || bt_dontwrite(buf)) {
       continue;
     }
-    /*
-     * Check if there is a reason the buffer cannot be written:
-     * 1. if the 'write' option is set
-     * 2. if there is no file name (even after browsing)
-     * 3. if the 'readonly' is set (even after a dialog)
-     * 4. if overwriting is allowed (even after a dialog)
-     */
+    // Check if there is a reason the buffer cannot be written:
+    // 1. if the 'write' option is set
+    // 2. if there is no file name (even after browsing)
+    // 3. if the 'readonly' is set (even after a dialog)
+    // 4. if overwriting is allowed (even after a dialog)
     if (not_writing()) {
       error++;
       break;
@@ -2405,10 +2365,8 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     goto theend;
   }
 
-  /*
-   * End Visual mode before switching to another buffer, so the text can be
-   * copied into the GUI selection buffer.
-   */
+  // End Visual mode before switching to another buffer, so the text can be
+  // copied into the GUI selection buffer.
   reset_VIsual();
 
   if ((command != NULL || newlnum > (linenr_T)0)
@@ -2426,10 +2384,8 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     xfree(p);
   }
 
-  /*
-   * If we are starting to edit another file, open a (new) buffer.
-   * Otherwise we re-use the current buffer.
-   */
+  // If we are starting to edit another file, open a (new) buffer.
+  // Otherwise we re-use the current buffer.
   if (other_file) {
     const int prev_alt_fnum = curwin->w_alt_fnum;
 
@@ -2507,12 +2463,10 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
       solcol = pos->col;
     }
 
-    /*
-     * Make the (new) buffer the one used by the current window.
-     * If the old buffer becomes unused, free it if ECMD_HIDE is false.
-     * If the current buffer was empty and has no file name, curbuf
-     * is returned by buflist_new(), nothing to do here.
-     */
+    // Make the (new) buffer the one used by the current window.
+    // If the old buffer becomes unused, free it if ECMD_HIDE is false.
+    // If the current buffer was empty and has no file name, curbuf
+    // is returned by buflist_new(), nothing to do here.
     if (buf != curbuf) {
       const int save_cmdwin_type = cmdwin_type;
 
@@ -2663,13 +2617,11 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
   // highlighting to work in the other file.
   did_filetype = false;
 
-  /*
-   * other_file oldbuf
-   *  false     false       re-edit same file, buffer is re-used
-   *  false     true        re-edit same file, nothing changes
-   *  true      false       start editing new file, new buffer
-   *  true      true        start editing in existing buffer (nothing to do)
-   */
+  // other_file oldbuf
+  //  false     false       re-edit same file, buffer is re-used
+  //  false     true        re-edit same file, nothing changes
+  //  true      false       start editing new file, new buffer
+  //  true      true        start editing in existing buffer (nothing to do)
   if (!other_file && !oldbuf) {         // re-use the buffer
     set_last_cursor(curwin);            // may set b_last_cursor
     if (newlnum == ECMD_LAST || newlnum == ECMD_LASTL) {
@@ -2728,9 +2680,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     curbuf->b_op_end.lnum = 0;
   }
 
-  /*
-   * If we get here we are sure to start editing
-   */
+  // If we get here we are sure to start editing
 
   // Assume success now
   retval = OK;
@@ -2741,17 +2691,13 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     curbuf->b_flags &= ~BF_NOTEDITED;
   }
 
-  /*
-   * Check if we are editing the w_arg_idx file in the argument list.
-   */
+  // Check if we are editing the w_arg_idx file in the argument list.
   check_arg_idx(curwin);
 
   if (!auto_buf) {
-    /*
-     * Set cursor and init window before reading the file and executing
-     * autocommands.  This allows for the autocommands to position the
-     * cursor.
-     */
+    // Set cursor and init window before reading the file and executing
+    // autocommands.  This allows for the autocommands to position the
+    // cursor.
     curwin_init();
 
     // It's possible that all lines in the buffer changed.  Need to update
@@ -2765,19 +2711,15 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
     // Change directories when the 'acd' option is set.
     do_autochdir();
 
-    /*
-     * Careful: open_buffer() and apply_autocmds() may change the current
-     * buffer and window.
-     */
+    // Careful: open_buffer() and apply_autocmds() may change the current
+    // buffer and window.
     orig_pos = curwin->w_cursor;
     topline = curwin->w_topline;
     if (!oldbuf) {                          // need to read the file
       swap_exists_action = SEA_DIALOG;
       curbuf->b_flags |= BF_CHECK_RO;       // set/reset 'ro' flag
 
-      /*
-       * Open the buffer and read the file.
-       */
+      // Open the buffer and read the file.
       if (flags & ECMD_NOWINENTER) {
         readfile_flags |= READ_NOWINENTER;
       }
@@ -2868,10 +2810,8 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
   // Check if cursors in other windows on the same buffer are still valid
   check_lnums(false);
 
-  /*
-   * Did not read the file, need to show some info about the file.
-   * Do this after setting the cursor.
-   */
+  // Did not read the file, need to show some info about the file.
+  // Do this after setting the cursor.
   if (oldbuf
       && !auto_buf) {
     int msg_scroll_save = msg_scroll;
@@ -3559,10 +3499,8 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
       }
     }
 
-    /*
-     * Small incompatibility: vi sees '\n' as end of the command, but in
-     * Vim we want to use '\n' to find/substitute a NUL.
-     */
+    // Small incompatibility: vi sees '\n' as end of the command, but in
+    // Vim we want to use '\n' to find/substitute a NUL.
     sub = cmd;              // remember the start of the substitution
 
     while (cmd[0]) {
@@ -3620,9 +3558,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
     }
   }
 
-  /*
-   * check for trailing command or garbage
-   */
+  // check for trailing command or garbage
   cmd = skipwhite(cmd);
   if (*cmd && *cmd != '"') {        // if not end-of-line or comment
     eap->nextcmd = check_nextcmd(cmd);
@@ -3711,50 +3647,48 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
       bool skip_match = false;
       linenr_T sub_firstlnum;           // nr of first sub line
 
-      /*
-       * The new text is build up step by step, to avoid too much
-       * copying.  There are these pieces:
-       * sub_firstline  The old text, unmodified.
-       * copycol                Column in the old text where we started
-       *                        looking for a match; from here old text still
-       *                        needs to be copied to the new text.
-       * matchcol               Column number of the old text where to look
-       *                        for the next match.  It's just after the
-       *                        previous match or one further.
-       * prev_matchcol  Column just after the previous match (if any).
-       *                        Mostly equal to matchcol, except for the first
-       *                        match and after skipping an empty match.
-       * regmatch.*pos  Where the pattern matched in the old text.
-       * new_start      The new text, all that has been produced so
-       *                        far.
-       * new_end                The new text, where to append new text.
-       *
-       * lnum           The line number where we found the start of
-       *                        the match.  Can be below the line we searched
-       *                        when there is a \n before a \zs in the
-       *                        pattern.
-       * sub_firstlnum  The line number in the buffer where to look
-       *                        for a match.  Can be different from "lnum"
-       *                        when the pattern or substitute string contains
-       *                        line breaks.
-       *
-       * Special situations:
-       * - When the substitute string contains a line break, the part up
-       *   to the line break is inserted in the text, but the copy of
-       *   the original line is kept.  "sub_firstlnum" is adjusted for
-       *   the inserted lines.
-       * - When the matched pattern contains a line break, the old line
-       *   is taken from the line at the end of the pattern.  The lines
-       *   in the match are deleted later, "sub_firstlnum" is adjusted
-       *   accordingly.
-       *
-       * The new text is built up in new_start[].  It has some extra
-       * room to avoid using xmalloc()/free() too often.
-       *
-       * Make a copy of the old line, so it won't be taken away when
-       * updating the screen or handling a multi-line match.  The "old_"
-       * pointers point into this copy.
-       */
+      // The new text is build up step by step, to avoid too much
+      // copying.  There are these pieces:
+      // sub_firstline  The old text, unmodified.
+      // copycol                Column in the old text where we started
+      //                        looking for a match; from here old text still
+      //                        needs to be copied to the new text.
+      // matchcol               Column number of the old text where to look
+      //                        for the next match.  It's just after the
+      //                        previous match or one further.
+      // prev_matchcol  Column just after the previous match (if any).
+      //                        Mostly equal to matchcol, except for the first
+      //                        match and after skipping an empty match.
+      // regmatch.*pos  Where the pattern matched in the old text.
+      // new_start      The new text, all that has been produced so
+      //                        far.
+      // new_end                The new text, where to append new text.
+      //
+      // lnum           The line number where we found the start of
+      //                        the match.  Can be below the line we searched
+      //                        when there is a \n before a \zs in the
+      //                        pattern.
+      // sub_firstlnum  The line number in the buffer where to look
+      //                        for a match.  Can be different from "lnum"
+      //                        when the pattern or substitute string contains
+      //                        line breaks.
+      //
+      // Special situations:
+      // - When the substitute string contains a line break, the part up
+      //   to the line break is inserted in the text, but the copy of
+      //   the original line is kept.  "sub_firstlnum" is adjusted for
+      //   the inserted lines.
+      // - When the matched pattern contains a line break, the old line
+      //   is taken from the line at the end of the pattern.  The lines
+      //   in the match are deleted later, "sub_firstlnum" is adjusted
+      //   accordingly.
+      //
+      // The new text is built up in new_start[].  It has some extra
+      // room to avoid using xmalloc()/free() too often.
+      //
+      // Make a copy of the old line, so it won't be taken away when
+      // updating the screen or handling a multi-line match.  The "old_"
+      // pointers point into this copy.
       sub_firstlnum = lnum;
       copycol = 0;
       matchcol = 0;
@@ -3765,14 +3699,12 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
         got_match = true;
       }
 
-      /*
-       * Loop until nothing more to replace in this line.
-       * 1. Handle match with empty string.
-       * 2. If subflags.do_ask is set, ask for confirmation.
-       * 3. substitute the string.
-       * 4. if subflags.do_all is set, find next match
-       * 5. break if there isn't another match in this line
-       */
+      // Loop until nothing more to replace in this line.
+      // 1. Handle match with empty string.
+      // 2. If subflags.do_ask is set, ask for confirmation.
+      // 3. substitute the string.
+      // 4. if subflags.do_all is set, find next match
+      // 5. break if there isn't another match in this line
       for (;;) {
         SubResult current_match = {
           .start = { 0, 0 },
@@ -3811,11 +3743,9 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
         curwin->w_cursor.lnum = lnum;
         do_again = false;
 
-        /*
-         * 1. Match empty string does not count, except for first
-         * match.  This reproduces the strange vi behaviour.
-         * This also catches endless loops.
-         */
+        // 1. Match empty string does not count, except for first
+        // match.  This reproduces the strange vi behaviour.
+        // This also catches endless loops.
         if (matchcol == prev_matchcol
             && regmatch.endpos[0].lnum == 0
             && matchcol == regmatch.endpos[0].col) {
@@ -3880,9 +3810,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
             no_u_sync++;
           }
 
-          /*
-           * Loop until 'y', 'n', 'q', CTRL-E or CTRL-Y typed.
-           */
+          // Loop until 'y', 'n', 'q', CTRL-E or CTRL-Y typed.
           while (subflags.do_ask) {
             if (exmode_active) {
               char *prompt;
@@ -4266,15 +4194,13 @@ skip:
                        && !re_multiline(regmatch.regprog)));
         nmatch = -1;
 
-        /*
-         * Replace the line in the buffer when needed.  This is
-         * skipped when there are more matches.
-         * The check for nmatch_tl is needed for when multi-line
-         * matching must replace the lines before trying to do another
-         * match, otherwise "\@<=" won't work.
-         * When the match starts below where we start searching also
-         * need to replace the line first (using \zs after \n).
-         */
+        // Replace the line in the buffer when needed.  This is
+        // skipped when there are more matches.
+        // The check for nmatch_tl is needed for when multi-line
+        // matching must replace the lines before trying to do another
+        // match, otherwise "\@<=" won't work.
+        // When the match starts below where we start searching also
+        // need to replace the line first (using \zs after \n).
         if (lastone
             || nmatch_tl > 0
             || (nmatch = vim_regexec_multi(&regmatch, curwin,
@@ -4282,13 +4208,11 @@ skip:
                                            matchcol, NULL, NULL)) == 0
             || regmatch.startpos[0].lnum > 0) {
           if (new_start != NULL) {
-            /*
-             * Copy the rest of the line, that didn't match.
-             * "matchcol" has to be adjusted, we use the end of
-             * the line as reference, because the substitute may
-             * have changed the number of characters.  Same for
-             * "prev_matchcol".
-             */
+            // Copy the rest of the line, that didn't match.
+            // "matchcol" has to be adjusted, we use the end of
+            // the line as reference, because the substitute may
+            // have changed the number of characters.  Same for
+            // "prev_matchcol".
             STRCAT(new_start, sub_firstline + copycol);
             matchcol = (colnr_T)STRLEN(sub_firstline) - matchcol;
             prev_matchcol = (colnr_T)STRLEN(sub_firstline)
@@ -4300,12 +4224,10 @@ skip:
             ml_replace(lnum, new_start, true);
 
             if (nmatch_tl > 0) {
-              /*
-               * Matched lines have now been substituted and are
-               * useless, delete them.  The part after the match
-               * has been appended to new_start, we don't need
-               * it in the buffer.
-               */
+              // Matched lines have now been substituted and are
+              // useless, delete them.  The part after the match
+              // has been appended to new_start, we don't need
+              // it in the buffer.
               lnum++;
               if (u_savedel(lnum, nmatch_tl) != OK) {
                 break;
@@ -4348,9 +4270,7 @@ skip:
                                        sub_firstlnum, matchcol, NULL, NULL);
           }
 
-          /*
-           * 5. break if there isn't another match in this line
-           */
+          // 5. break if there isn't another match in this line
           if (nmatch <= 0) {
             // If the match found didn't start where we were
             // searching, do the next search in the line where we
@@ -4513,12 +4433,10 @@ skip:
 /// @return            true if a message was given.
 bool do_sub_msg(bool count_only)
 {
-  /*
-   * Only report substitutions when:
-   * - more than 'report' substitutions
-   * - command was typed by user, or number of changed lines > 'report'
-   * - giving messages is not disabled by 'lazyredraw'
-   */
+  // Only report substitutions when:
+  // - more than 'report' substitutions
+  // - command was typed by user, or number of changed lines > 'report'
+  // - giving messages is not disabled by 'lazyredraw'
   if (((sub_nsubs > p_report && (KeyTyped || sub_nlines > 1 || p_report < 1))
        || count_only)
       && messaging()) {
@@ -4609,11 +4527,9 @@ void ex_global(exarg_T *eap)
   cmd = eap->arg;
   which_pat = RE_LAST;              // default: use last used regexp
 
-  /*
-   * undocumented vi feature:
-   *    "\/" and "\?": use previous search pattern.
-   *             "\&": use previous substitute pattern.
-   */
+  // undocumented vi feature:
+  //    "\/" and "\?": use previous search pattern.
+  //             "\&": use previous substitute pattern.
   if (*cmd == '\\') {
     cmd++;
     if (vim_strchr("/?&", *cmd) == NULL) {
@@ -4752,9 +4668,7 @@ void free_old_sub(void)
 /// @return           true when it was created.
 bool prepare_tagpreview(bool undo_sync)
 {
-  /*
-   * If there is already a preview window open, use that one.
-   */
+  // If there is already a preview window open, use that one.
   if (!curwin->w_p_pvw) {
     bool found_win = false;
     FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
@@ -4765,9 +4679,7 @@ bool prepare_tagpreview(bool undo_sync)
       }
     }
     if (!found_win) {
-      /*
-       * There is no preview window open yet.  Create one.
-       */
+      // There is no preview window open yet.  Create one.
       if (win_split(g_do_tagpreview > 0 ? g_do_tagpreview : 0, 0)
           == FAIL) {
         return false;
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 6dddafcfcb..20725b81ee 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -79,15 +79,13 @@ static void discard_pending_return(typval_T *p)
   tv_free(p);
 }
 
-/*
- * When several errors appear in a row, setting "force_abort" is delayed until
- * the failing command returned.  "cause_abort" is set to true meanwhile, in
- * order to indicate that situation.  This is useful when "force_abort" was set
- * during execution of a function call from an expression: the aborting of the
- * expression evaluation is done without producing any error messages, but all
- * error messages on parsing errors during the expression evaluation are given
- * (even if a try conditional is active).
- */
+// When several errors appear in a row, setting "force_abort" is delayed until
+// the failing command returned.  "cause_abort" is set to true meanwhile, in
+// order to indicate that situation.  This is useful when "force_abort" was set
+// during execution of a function call from an expression: the aborting of the
+// expression evaluation is done without producing any error messages, but all
+// error messages on parsing errors during the expression evaluation are given
+// (even if a try conditional is active).
 static int cause_abort = false;
 
 /// @return  true when immediately aborting on error, or when an interrupt
@@ -153,69 +151,57 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
   msglist_T *elem;
   msglist_T **plist;
 
-  /*
-   * Do nothing when displaying the interrupt message or reporting an
-   * uncaught exception (which has already been discarded then) at the top
-   * level.  Also when no exception can be thrown.  The message will be
-   * displayed by emsg().
-   */
+  // Do nothing when displaying the interrupt message or reporting an
+  // uncaught exception (which has already been discarded then) at the top
+  // level.  Also when no exception can be thrown.  The message will be
+  // displayed by emsg().
   if (suppress_errthrow) {
     return false;
   }
 
-  /*
-   * If emsg() has not been called previously, temporarily reset
-   * "force_abort" until the throw point for error messages has been
-   * reached.  This ensures that aborting() returns the same value for all
-   * errors that appear in the same command.  This means particularly that
-   * for parsing errors during expression evaluation emsg() will be called
-   * multiply, even when the expression is evaluated from a finally clause
-   * that was activated due to an aborting error, interrupt, or exception.
-   */
+  // If emsg() has not been called previously, temporarily reset
+  // "force_abort" until the throw point for error messages has been
+  // reached.  This ensures that aborting() returns the same value for all
+  // errors that appear in the same command.  This means particularly that
+  // for parsing errors during expression evaluation emsg() will be called
+  // multiply, even when the expression is evaluated from a finally clause
+  // that was activated due to an aborting error, interrupt, or exception.
   if (!did_emsg) {
     cause_abort = force_abort;
     force_abort = false;
   }
 
-  /*
-   * If no try conditional is active and no exception is being thrown and
-   * there has not been an error in a try conditional or a throw so far, do
-   * nothing (for compatibility of non-EH scripts).  The message will then
-   * be displayed by emsg().  When ":silent!" was used and we are not
-   * currently throwing an exception, do nothing.  The message text will
-   * then be stored to v:errmsg by emsg() without displaying it.
-   */
+  // If no try conditional is active and no exception is being thrown and
+  // there has not been an error in a try conditional or a throw so far, do
+  // nothing (for compatibility of non-EH scripts).  The message will then
+  // be displayed by emsg().  When ":silent!" was used and we are not
+  // currently throwing an exception, do nothing.  The message text will
+  // then be stored to v:errmsg by emsg() without displaying it.
   if (((trylevel == 0 && !cause_abort) || emsg_silent) && !did_throw) {
     return false;
   }
 
-  /*
-   * Ignore an interrupt message when inside a try conditional or when an
-   * exception is being thrown or when an error in a try conditional or
-   * throw has been detected previously.  This is important in order that an
-   * interrupt exception is catchable by the innermost try conditional and
-   * not replaced by an interrupt message error exception.
-   */
+  // Ignore an interrupt message when inside a try conditional or when an
+  // exception is being thrown or when an error in a try conditional or
+  // throw has been detected previously.  This is important in order that an
+  // interrupt exception is catchable by the innermost try conditional and
+  // not replaced by an interrupt message error exception.
   if (mesg == _(e_interr)) {
     *ignore = true;
     return true;
   }
 
-  /*
-   * Ensure that all commands in nested function calls and sourced files
-   * are aborted immediately.
-   */
+  // Ensure that all commands in nested function calls and sourced files
+  // are aborted immediately.
   cause_abort = true;
 
-  /*
-   * When an exception is being thrown, some commands (like conditionals) are
-   * not skipped.  Errors in those commands may affect what of the subsequent
-   * commands are regarded part of catch and finally clauses.  Catching the
-   * exception would then cause execution of commands not intended by the
-   * user, who wouldn't even get aware of the problem.  Therefore, discard the
-   * exception currently being thrown to prevent it from being caught.  Just
-   * execute finally clauses and terminate.
-   */
+  // When an exception is being thrown, some commands (like conditionals) are
+  // not skipped.  Errors in those commands may affect what of the subsequent
+  // commands are regarded part of catch and finally clauses.  Catching the
+  // exception would then cause execution of commands not intended by the
+  // user, who wouldn't even get aware of the problem.  Therefore, discard the
+  // exception currently being thrown to prevent it from being caught.  Just
+  // execute finally clauses and terminate.
   if (did_throw) {
     // When discarding an interrupt exception, reset got_int to prevent the
     // same interrupt being converted to an exception again and discarding
@@ -228,25 +214,21 @@ bool cause_errthrow(const char *mesg, bool severe, bool *ignore)
 
 #ifdef THROW_TEST
   if (!THROW_ON_ERROR) {
-    /*
-     * Print error message immediately without searching for a matching
-     * catch clause; just finally clauses are executed before the script
-     * is terminated.
-     */
+    // Print error message immediately without searching for a matching
+    // catch clause; just finally clauses are executed before the script
+    // is terminated.
     return false;
   } else  // NOLINT(readability/braces)
 #endif
   {
-    /*
-     * Prepare the throw of an error exception, so that everything will
-     * be aborted (except for executing finally clauses), until the error
-     * exception is caught; if still uncaught at the top level, the error
-     * message will be displayed and the script processing terminated
-     * then.  -  This function has no access to the conditional stack.
-     * Thus, the actual throw is made after the failing command has
-     * returned.  -  Throw only the first of several errors in a row, except
-     * a severe error is following.
-     */
+    // Prepare the throw of an error exception, so that everything will
+    // be aborted (except for executing finally clauses), until the error
+    // exception is caught; if still uncaught at the top level, the error
+    // message will be displayed and the script processing terminated
+    // then.  -  This function has no access to the conditional stack.
+    // Thus, the actual throw is made after the failing command has
+    // returned.  -  Throw only the first of several errors in a row, except
+    // a severe error is following.
     if (msg_list != NULL) {
       plist = msg_list;
       while (*plist != NULL) {
@@ -312,10 +294,8 @@ void free_global_msglist(void)
 /// has returned (see do_one_cmd()).
 void do_errthrow(cstack_T *cstack, char *cmdname)
 {
-  /*
-   * Ensure that all commands in nested function calls and sourced files
-   * are aborted immediately.
-   */
+  // Ensure that all commands in nested function calls and sourced files
+  // are aborted immediately.
   if (cause_abort) {
     cause_abort = false;
     force_abort = true;
@@ -455,11 +435,9 @@ static int throw_exception(void *value, except_type_T type, char *cmdname)
   except_T *excp;
   int should_free;
 
-  /*
-   * Disallow faking Interrupt or error exceptions as user exceptions.  They
-   * would be treated differently from real interrupt or error exceptions
-   * when no active try block is found, see do_cmdline().
-   */
+  // Disallow faking Interrupt or error exceptions as user exceptions.  They
+  // would be treated differently from real interrupt or error exceptions
+  // when no active try block is found, see do_cmdline().
   if (type == ET_USER) {
     if (STRNCMP((char_u *)value, "Vim", 3) == 0
         && (((char_u *)value)[3] == NUL || ((char_u *)value)[3] == ':'
@@ -678,9 +656,7 @@ static void finish_exception(except_T *excp)
   discard_exception(excp, true);
 }
 
-/*
- * Flags specifying the message displayed by report_pending.
- */
+// Flags specifying the message displayed by report_pending.
 #define RP_MAKE         0
 #define RP_RESUME       1
 #define RP_DISCARD      2
@@ -958,11 +934,9 @@ void ex_while(exarg_T *eap)
   if (cstack->cs_idx == CSTACK_LEN - 1) {
     eap->errmsg = _("E585: :while/:for nesting too deep");
   } else {
-    /*
-     * The loop flag is set when we have jumped back from the matching
-     * ":endwhile" or ":endfor".  When not set, need to initialise this
-     * cstack entry.
-     */
+    // The loop flag is set when we have jumped back from the matching
+    // ":endwhile" or ":endfor".  When not set, need to initialise this
+    // cstack entry.
     if ((cstack->cs_lflags & CSL_HAD_LOOP) == 0) {
       cstack->cs_idx++;
       cstack->cs_looplevel++;
@@ -973,16 +947,12 @@ void ex_while(exarg_T *eap)
 
     skip = CHECK_SKIP;
     if (eap->cmdidx == CMD_while) {
-      /*
-       * ":while bool-expr"
-       */
+      // ":while bool-expr"
       result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip);
     } else {
       void *fi;
 
-      /*
-       * ":for var in list-expr"
-       */
+      // ":for var in list-expr"
       if ((cstack->cs_lflags & CSL_HAD_LOOP) != 0) {
         // Jumping here from a ":continue" or ":endfor": use the
         // previously evaluated list.
@@ -1007,11 +977,9 @@ void ex_while(exarg_T *eap)
       }
     }
 
-    /*
-     * If this cstack entry was just initialised and is active, set the
-     * loop flag, so do_cmdline() will set the line number in cs_line[].
-     * If executing the command a second time, clear the loop flag.
-     */
+    // If this cstack entry was just initialised and is active, set the
+    // loop flag, so do_cmdline() will set the line number in cs_line[].
+    // If executing the command a second time, clear the loop flag.
     if (!skip && !error && result) {
       cstack->cs_flags[cstack->cs_idx] |= (CSF_ACTIVE | CSF_TRUE);
       cstack->cs_lflags ^= CSL_HAD_LOOP;
@@ -1046,10 +1014,8 @@ void ex_continue(exarg_T *eap)
     if (cstack->cs_flags[idx] & (CSF_WHILE | CSF_FOR)) {
       rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
 
-      /*
-       * Set CSL_HAD_CONT, so do_cmdline() will jump back to the
-       * matching ":while".
-       */
+      // Set CSL_HAD_CONT, so do_cmdline() will jump back to the
+      // matching ":while".
       cstack->cs_lflags |= CSL_HAD_CONT;        // let do_cmdline() handle it
     } else {
       // If a try conditional not in its finally clause is reached first,
@@ -1147,10 +1113,8 @@ void ex_endwhile(exarg_T *eap)
       (void)do_intthrow(cstack);
     }
 
-    /*
-     * Set loop flag, so do_cmdline() will jump back to the matching
-     * ":while" or ":for".
-     */
+    // Set loop flag, so do_cmdline() will jump back to the matching
+    // ":while" or ":for".
     cstack->cs_lflags |= CSL_HAD_ENDLOOP;
   }
 }
@@ -1211,19 +1175,17 @@ void do_throw(cstack_T *cstack)
 #endif
   idx = cleanup_conditionals(cstack, 0, inactivate_try);
   if (idx >= 0) {
-    /*
-     * If this try conditional is active and we are before its first
-     * ":catch", set THROWN so that the ":catch" commands will check
-     * whether the exception matches.  When the exception came from any of
-     * the catch clauses, it will be made pending at the ":finally" (if
-     * present) and rethrown at the ":endtry".  This will also happen if
-     * the try conditional is inactive.  This is the case when we are
-     * throwing an exception due to an error or interrupt on the way from
-     * a preceding ":continue", ":break", ":return", ":finish", error or
-     * interrupt (not converted to an exception) to the finally clause or
-     * from a preceding throw of a user or error or interrupt exception to
-     * the matching catch clause or the finally clause.
-     */
+    // If this try conditional is active and we are before its first
+    // ":catch", set THROWN so that the ":catch" commands will check
+    // whether the exception matches.  When the exception came from any of
+    // the catch clauses, it will be made pending at the ":finally" (if
+    // present) and rethrown at the ":endtry".  This will also happen if
+    // the try conditional is inactive.  This is the case when we are
+    // throwing an exception due to an error or interrupt on the way from
+    // a preceding ":continue", ":break", ":return", ":finish", error or
+    // interrupt (not converted to an exception) to the finally clause or
+    // from a preceding throw of a user or error or interrupt exception to
+    // the matching catch clause or the finally clause.
     if (!(cstack->cs_flags[idx] & CSF_CAUGHT)) {
       if (cstack->cs_flags[idx] & CSF_ACTIVE) {
         cstack->cs_flags[idx] |= CSF_THROWN;
@@ -1263,22 +1225,20 @@ void ex_try(exarg_T *eap)
       // that the finally clause needs to be executed.
       cstack->cs_flags[cstack->cs_idx] |= CSF_ACTIVE | CSF_TRUE;
 
-      /*
-       * ":silent!", even when used in a try conditional, disables
-       * displaying of error messages and conversion of errors to
-       * exceptions.  When the silent commands again open a try
-       * conditional, save "emsg_silent" and reset it so that errors are
-       * again converted to exceptions.  The value is restored when that
-       * try conditional is left.  If it is left normally, the commands
-       * following the ":endtry" are again silent.  If it is left by
-       * a ":continue", ":break", ":return", or ":finish", the commands
-       * executed next are again silent.  If it is left due to an
-       * aborting error, an interrupt, or an exception, restoring
-       * "emsg_silent" does not matter since we are already in the
-       * aborting state and/or the exception has already been thrown.
-       * The effect is then just freeing the memory that was allocated
-       * to save the value.
-       */
+      // ":silent!", even when used in a try conditional, disables
+      // displaying of error messages and conversion of errors to
+      // exceptions.  When the silent commands again open a try
+      // conditional, save "emsg_silent" and reset it so that errors are
+      // again converted to exceptions.  The value is restored when that
+      // try conditional is left.  If it is left normally, the commands
+      // following the ":endtry" are again silent.  If it is left by
+      // a ":continue", ":break", ":return", or ":finish", the commands
+      // executed next are again silent.  If it is left due to an
+      // aborting error, an interrupt, or an exception, restoring
+      // "emsg_silent" does not matter since we are already in the
+      // aborting state and/or the exception has already been thrown.
+      // The effect is then just freeing the memory that was allocated
+      // to save the value.
       if (emsg_silent) {
         eslist_T *elem = xmalloc(sizeof(*elem));
         elem->saved_emsg_silent = emsg_silent;
@@ -1342,20 +1302,16 @@ void ex_catch(exarg_T *eap)
   }
 
   if (!give_up) {
-    /*
-     * Don't do something when no exception has been thrown or when the
-     * corresponding try block never got active (because of an inactive
-     * surrounding conditional or after an error or interrupt or throw).
-     */
+    // Don't do something when no exception has been thrown or when the
+    // corresponding try block never got active (because of an inactive
+    // surrounding conditional or after an error or interrupt or throw).
     if (!did_throw || !(cstack->cs_flags[idx] & CSF_TRUE)) {
       skip = true;
     }
 
-    /*
-     * Check for a match only if an exception is thrown but not caught by
-     * a previous ":catch".  An exception that has replaced a discarded
-     * exception is not checked (THROWN is not set then).
-     */
+    // Check for a match only if an exception is thrown but not caught by
+    // a previous ":catch".  An exception that has replaced a discarded
+    // exception is not checked (THROWN is not set then).
     if (!skip && (cstack->cs_flags[idx] & CSF_THROWN)
         && !(cstack->cs_flags[idx] & CSF_CAUGHT)) {
       if (end != NULL && *end != NUL && !ends_excmd(*skipwhite(end + 1))) {
@@ -1422,16 +1378,14 @@ void ex_catch(exarg_T *eap)
         internal_error("ex_catch()");
       }
     } else {
-      /*
-       * If there is a preceding catch clause and it caught the exception,
-       * finish the exception now.  This happens also after errors except
-       * when this ":catch" was after the ":finally" or not within
-       * a ":try".  Make the try conditional inactive so that the
-       * following catch clauses are skipped.  On an error or interrupt
-       * after the preceding try block or catch clause was left by
-       * a ":continue", ":break", ":return", or ":finish", discard the
-       * pending action.
-       */
+      // If there is a preceding catch clause and it caught the exception,
+      // finish the exception now.  This happens also after errors except
+      // when this ":catch" was after the ":finally" or not within
+      // a ":try".  Make the try conditional inactive so that the
+      // following catch clauses are skipped.  On an error or interrupt
+      // after the preceding try block or catch clause was left by
+      // a ":continue", ":break", ":return", or ":finish", discard the
+      // pending action.
       cleanup_conditionals(cstack, CSF_TRY, true);
     }
   }
@@ -1495,14 +1449,12 @@ void ex_finally(exarg_T *eap)
         (void)do_intthrow(cstack);
       }
 
-      /*
-       * If there is a preceding catch clause and it caught the exception,
-       * finish the exception now.  This happens also after errors except
-       * when this is a multiple ":finally" or one not within a ":try".
-       * After an error or interrupt, this also discards a pending
-       * ":continue", ":break", ":finish", or ":return" from the preceding
-       * try block or catch clause.
-       */
+      // If there is a preceding catch clause and it caught the exception,
+      // finish the exception now.  This happens also after errors except
+      // when this is a multiple ":finally" or one not within a ":try".
+      // After an error or interrupt, this also discards a pending
+      // ":continue", ":break", ":finish", or ":return" from the preceding
+      // try block or catch clause.
       cleanup_conditionals(cstack, CSF_TRY, false);
 
       // Make did_emsg, got_int, did_throw pending.  If set, they overrule
@@ -1606,12 +1558,10 @@ void ex_endtry(exarg_T *eap)
     } else {
       idx = cstack->cs_idx;
 
-      /*
-       * If we stopped with the exception currently being thrown at this
-       * try conditional since we didn't know that it doesn't have
-       * a finally clause, we need to rethrow it after closing the try
-       * conditional.
-       */
+      // If we stopped with the exception currently being thrown at this
+      // try conditional since we didn't know that it doesn't have
+      // a finally clause, we need to rethrow it after closing the try
+      // conditional.
       if (did_throw
           && (cstack->cs_flags[idx] & CSF_TRUE)
           && !(cstack->cs_flags[idx] & CSF_FINALLY)) {
@@ -1645,12 +1595,10 @@ void ex_endtry(exarg_T *eap)
       }
     }
 
-    /*
-     * If a ":return" is pending, we need to resume it after closing the
-     * try conditional; remember the return value.  If there was a finally
-     * clause making an exception pending, we need to rethrow it.  Make it
-     * the exception currently being thrown.
-     */
+    // If a ":return" is pending, we need to resume it after closing the
+    // try conditional; remember the return value.  If there was a finally
+    // clause making an exception pending, we need to rethrow it.  Make it
+    // the exception currently being thrown.
     if (!skip) {
       pending = cstack->cs_pending[idx];
       cstack->cs_pending[idx] = CSTP_NONE;
@@ -1661,16 +1609,14 @@ void ex_endtry(exarg_T *eap)
       }
     }
 
-    /*
-     * Discard anything pending on an error, interrupt, or throw in the
-     * finally clause.  If there was no ":finally", discard a pending
-     * ":continue", ":break", ":return", or ":finish" if an error or
-     * interrupt occurred afterwards, but before the ":endtry" was reached.
-     * If an exception was caught by the last of the catch clauses and there
-     * was no finally clause, finish the exception now.  This happens also
-     * after errors except when this ":endtry" is not within a ":try".
-     * Restore "emsg_silent" if it has been reset by this try conditional.
-     */
+    // Discard anything pending on an error, interrupt, or throw in the
+    // finally clause.  If there was no ":finally", discard a pending
+    // ":continue", ":break", ":return", or ":finish" if an error or
+    // interrupt occurred afterwards, but before the ":endtry" was reached.
+    // If an exception was caught by the last of the catch clauses and there
+    // was no finally clause, finish the exception now.  This happens also
+    // after errors except when this ":endtry" is not within a ":try".
+    // Restore "emsg_silent" if it has been reset by this try conditional.
     (void)cleanup_conditionals(cstack, CSF_TRY | CSF_SILENT, true);
 
     if (cstack->cs_idx >= 0 && (cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
@@ -1733,18 +1679,16 @@ void ex_endtry(exarg_T *eap)
   }
 }
 
-/*
- * enter_cleanup() and leave_cleanup()
- *
- * Functions to be called before/after invoking a sequence of autocommands for
- * cleanup for a failed command.  (Failure means here that a call to emsg()
- * has been made, an interrupt occurred, or there is an uncaught exception
- * from a previous autocommand execution of the same command.)
- *
- * Call enter_cleanup() with a pointer to a cleanup_T and pass the same
- * pointer to leave_cleanup().  The cleanup_T structure stores the pending
- * error/interrupt/exception state.
- */
+// enter_cleanup() and leave_cleanup()
+//
+// Functions to be called before/after invoking a sequence of autocommands for
+// cleanup for a failed command.  (Failure means here that a call to emsg()
+// has been made, an interrupt occurred, or there is an uncaught exception
+// from a previous autocommand execution of the same command.)
+//
+// Call enter_cleanup() with a pointer to a cleanup_T and pass the same
+// pointer to leave_cleanup().  The cleanup_T structure stores the pending
+// error/interrupt/exception state.
 
 /// This function works a bit like ex_finally() except that there was not
 /// actually an extra try block around the part that failed and an error or
@@ -1829,18 +1773,14 @@ void leave_cleanup(cleanup_T *csp)
     if (msg_list != NULL) {
       free_global_msglist();
     }
-  }
-  /*
-   * If there was no new error, interrupt, or throw between the calls
-   * to enter_cleanup() and leave_cleanup(), restore the pending
-   * error/interrupt/exception state.
-   */
-  else {
-    /*
-     * If there was an exception being thrown when enter_cleanup() was
-     * called, we need to rethrow it.  Make it the exception currently
-     * being thrown.
-     */
+  } else {
+    // If there was no new error, interrupt, or throw between the calls
+    // to enter_cleanup() and leave_cleanup(), restore the pending
+    // error/interrupt/exception state.
+
+    // If there was an exception being thrown when enter_cleanup() was
+    // called, we need to rethrow it.  Make it the exception currently
+    // being thrown.
     if (pending & CSTP_THROW) {
       current_exception = csp->exception;
     } else if (pending & CSTP_ERROR) {
@@ -1893,12 +1833,10 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
 
   for (idx = cstack->cs_idx; idx >= 0; idx--) {
     if (cstack->cs_flags[idx] & CSF_TRY) {
-      /*
-       * Discard anything pending in a finally clause and continue the
-       * search.  There may also be a pending ":continue", ":break",
-       * ":return", or ":finish" before the finally clause.  We must not
-       * discard it, unless an error or interrupt occurred afterwards.
-       */
+      // Discard anything pending in a finally clause and continue the
+      // search.  There may also be a pending ":continue", ":break",
+      // ":return", or ":finish" before the finally clause.  We must not
+      // discard it, unless an error or interrupt occurred afterwards.
       if (did_emsg || got_int || (cstack->cs_flags[idx] & CSF_FINALLY)) {
         switch (cstack->cs_pending[idx]) {
         case CSTP_NONE:
@@ -1934,11 +1872,9 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
         }
       }
 
-      /*
-       * Stop at a try conditional not in its finally clause.  If this try
-       * conditional is in an active catch clause, finish the caught
-       * exception.
-       */
+      // Stop at a try conditional not in its finally clause.  If this try
+      // conditional is in an active catch clause, finish the caught
+      // exception.
       if (!(cstack->cs_flags[idx] & CSF_FINALLY)) {
         if ((cstack->cs_flags[idx] & CSF_ACTIVE)
             && (cstack->cs_flags[idx] & CSF_CAUGHT) && !(cstack->cs_flags[idx] & CSF_FINISHED)) {
@@ -1973,11 +1909,9 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
       break;
     }
 
-    /*
-     * When leaving a try conditional that reset "emsg_silent" on its
-     * entry after saving the original value, restore that value here and
-     * free the memory used to store it.
-     */
+    // When leaving a try conditional that reset "emsg_silent" on its
+    // entry after saving the original value, restore that value here and
+    // free the memory used to store it.
     if ((cstack->cs_flags[idx] & CSF_TRY)
         && (cstack->cs_flags[idx] & CSF_SILENT)) {
       eslist_T *elem;
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 2112385533..da99a03c38 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * ex_getln.c: Functions for entering and editing an Ex command line.
- */
+// ex_getln.c: Functions for entering and editing an Ex command line.
 
 #include <assert.h>
 #include <inttypes.h>
@@ -2603,10 +2601,8 @@ bool text_locked(void)
   return textlock != 0;
 }
 
-/*
- * Give an error message for a command that isn't allowed while the cmdline
- * window is open or editing the cmdline in another way.
- */
+// Give an error message for a command that isn't allowed while the cmdline
+// window is open or editing the cmdline in another way.
 void text_locked_msg(void)
 {
   emsg(_(get_text_locked_msg()));
@@ -2738,15 +2734,11 @@ bool cmdline_at_end(void)
   return (ccline.cmdpos >= ccline.cmdlen);
 }
 
-/*
- * Allocate a new command line buffer.
- * Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
- */
+// Allocate a new command line buffer.
+// Assigns the new buffer to ccline.cmdbuff and ccline.cmdbufflen.
 static void alloc_cmdbuff(int len)
 {
-  /*
-   * give some extra space to avoid having to allocate all the time
-   */
+  // give some extra space to avoid having to allocate all the time
   if (len < 80) {
     len = 100;
   } else {
@@ -3088,10 +3080,8 @@ color_cmdline_error:
 #undef PRINT_ERRMSG
 }
 
-/*
- * Draw part of the cmdline at the current cursor position.  But draw stars
- * when cmdline_star is true.
- */
+// Draw part of the cmdline at the current cursor position.  But draw stars
+// when cmdline_star is true.
 static void draw_cmdline(int start, int len)
 {
   if (!color_cmdline(&ccline)) {
@@ -3342,11 +3332,9 @@ void cmdline_ui_flush(void)
   }
 }
 
-/*
- * Put a character on the command line.  Shifts the following text to the
- * right when "shift" is true.  Used for CTRL-V, CTRL-K, etc.
- * "c" must be printable (fit in one display cell)!
- */
+// Put a character on the command line.  Shifts the following text to the
+// right when "shift" is true.  Used for CTRL-V, CTRL-K, etc.
+// "c" must be printable (fit in one display cell)!
 void putcmdline(char c, int shift)
 {
   if (cmd_silent) {
@@ -3388,14 +3376,12 @@ void unputcmdline(void)
   ui_cursor_shape();
 }
 
-/*
- * Put the given string, of the given length, onto the command line.
- * If len is -1, then STRLEN() is used to calculate the length.
- * If 'redraw' is true then the new part of the command line, and the remaining
- * part will be redrawn, otherwise it will not.  If this function is called
- * twice in a row, then 'redraw' should be false and redrawcmd() should be
- * called afterwards.
- */
+// Put the given string, of the given length, onto the command line.
+// If len is -1, then STRLEN() is used to calculate the length.
+// If 'redraw' is true then the new part of the command line, and the remaining
+// part will be redrawn, otherwise it will not.  If this function is called
+// twice in a row, then 'redraw' should be false and redrawcmd() should be
+// called afterwards.
 void put_on_cmdline(char_u *str, int len, int redraw)
 {
   int i;
@@ -3603,12 +3589,10 @@ static bool cmdline_paste(int regname, bool literally, bool remcr)
   return cmdline_paste_reg(regname, literally, remcr);
 }
 
-/*
- * Put a string on the command line.
- * When "literally" is true, insert literally.
- * When "literally" is false, insert as typed, but don't leave the command
- * line.
- */
+// Put a string on the command line.
+// When "literally" is true, insert literally.
+// When "literally" is false, insert as typed, but don't leave the command
+// line.
 void cmdline_paste_str(char_u *s, int literally)
 {
   int c, cv;
@@ -3675,9 +3659,7 @@ static void redrawcmdprompt(void)
   }
 }
 
-/*
- * Redraw what is currently on the command line.
- */
+// Redraw what is currently on the command line.
 void redrawcmd(void)
 {
   if (cmd_silent) {
@@ -3714,10 +3696,8 @@ void redrawcmd(void)
     putcmdline(ccline.special_char, ccline.special_shift);
   }
 
-  /*
-   * An emsg() before may have set msg_scroll. This is used in normal mode,
-   * in cmdline mode we can reset them now.
-   */
+  // An emsg() before may have set msg_scroll. This is used in normal mode,
+  // in cmdline mode we can reset them now.
   msg_scroll = false;           // next message overwrites cmdline
 
   // Typing ':' at the more prompt may set skip_redraw.  We don't want this
@@ -3794,12 +3774,10 @@ void gotocmdline(bool clr)
   cmd_cursor_goto(cmdline_row, 0);
 }
 
-/*
- * Check the word in front of the cursor for an abbreviation.
- * Called when the non-id character "c" has been entered.
- * When an abbreviation is recognized it is removed from the text with
- * backspaces and the replacement string is inserted, followed by "c".
- */
+// Check the word in front of the cursor for an abbreviation.
+// Called when the non-id character "c" has been entered.
+// When an abbreviation is recognized it is removed from the text with
+// backspaces and the replacement string is inserted, followed by "c".
 static int ccheck_abbr(int c)
 {
   int spos = 0;
@@ -4310,9 +4288,7 @@ static int open_cmdwin(void)
   RedrawingDisabled = 0;
   int save_count = save_batch_count();
 
-  /*
-   * Call the main loop until <CR> or CTRL-C is typed.
-   */
+  // Call the main loop until <CR> or CTRL-C is typed.
   normal_enter(true, false);
 
   RedrawingDisabled = i;
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index f75dc51ca5..a604c5ff3e 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -71,9 +71,7 @@
 
 static char_u *ff_expand_buffer = NULL;  // used for expanding filenames
 
-/*
- * type for the directory search stack
- */
+// type for the directory search stack
 typedef struct ff_stack {
   struct ff_stack *ffs_prev;
 
@@ -104,9 +102,7 @@ typedef struct ff_stack {
   int ffs_star_star_empty;
 } ff_stack_T;
 
-/*
- * type for already visited directories or files.
- */
+// type for already visited directories or files.
 typedef struct ff_visited {
   struct ff_visited *ffv_next;
 
@@ -122,20 +118,18 @@ typedef struct ff_visited {
   char_u ffv_fname[1];                  // actually longer
 } ff_visited_T;
 
-/*
- * We might have to manage several visited lists during a search.
- * This is especially needed for the tags option. If tags is set to:
- *      "./++/tags,./++/TAGS,++/tags"  (replace + with *)
- * So we have to do 3 searches:
- *   1) search from the current files directory downward for the file "tags"
- *   2) search from the current files directory downward for the file "TAGS"
- *   3) search from Vims current directory downwards for the file "tags"
- * As you can see, the first and the third search are for the same file, so for
- * the third search we can use the visited list of the first search. For the
- * second search we must start from an empty visited list.
- * The struct ff_visited_list_hdr is used to manage a linked list of already
- * visited lists.
- */
+// We might have to manage several visited lists during a search.
+// This is especially needed for the tags option. If tags is set to:
+//      "./++/tags,./++/TAGS,++/tags"  (replace + with *)
+// So we have to do 3 searches:
+//   1) search from the current files directory downward for the file "tags"
+//   2) search from the current files directory downward for the file "TAGS"
+//   3) search from Vims current directory downwards for the file "tags"
+// As you can see, the first and the third search are for the same file, so for
+// the third search we can use the visited list of the first search. For the
+// second search we must start from an empty visited list.
+// The struct ff_visited_list_hdr is used to manage a linked list of already
+// visited lists.
 typedef struct ff_visited_list_hdr {
   struct ff_visited_list_hdr *ffvl_next;
 
@@ -145,29 +139,25 @@ typedef struct ff_visited_list_hdr {
   ff_visited_T *ffvl_visited_list;
 } ff_visited_list_hdr_T;
 
-/*
- * '**' can be expanded to several directory levels.
- * Set the default maximum depth.
- */
+// '**' can be expanded to several directory levels.
+// Set the default maximum depth.
 #define FF_MAX_STAR_STAR_EXPAND ((char_u)30)
 
-/*
- * The search context:
- *   ffsc_stack_ptr:    the stack for the dirs to search
- *   ffsc_visited_list: the currently active visited list
- *   ffsc_dir_visited_list: the currently active visited list for search dirs
- *   ffsc_visited_lists_list: the list of all visited lists
- *   ffsc_dir_visited_lists_list: the list of all visited lists for search dirs
- *   ffsc_file_to_search:     the file to search for
- *   ffsc_start_dir:    the starting directory, if search path was relative
- *   ffsc_fix_path:     the fix part of the given path (without wildcards)
- *                      Needed for upward search.
- *   ffsc_wc_path:      the part of the given path containing wildcards
- *   ffsc_level:        how many levels of dirs to search downwards
- *   ffsc_stopdirs_v:   array of stop directories for upward search
- *   ffsc_find_what:    FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
- *   ffsc_tagfile:      searching for tags file, don't use 'suffixesadd'
- */
+// The search context:
+//   ffsc_stack_ptr:    the stack for the dirs to search
+//   ffsc_visited_list: the currently active visited list
+//   ffsc_dir_visited_list: the currently active visited list for search dirs
+//   ffsc_visited_lists_list: the list of all visited lists
+//   ffsc_dir_visited_lists_list: the list of all visited lists for search dirs
+//   ffsc_file_to_search:     the file to search for
+//   ffsc_start_dir:    the starting directory, if search path was relative
+//   ffsc_fix_path:     the fix part of the given path (without wildcards)
+//                      Needed for upward search.
+//   ffsc_wc_path:      the part of the given path containing wildcards
+//   ffsc_level:        how many levels of dirs to search downwards
+//   ffsc_stopdirs_v:   array of stop directories for upward search
+//   ffsc_find_what:    FINDFILE_BOTH, FINDFILE_DIR or FINDFILE_FILE
+//   ffsc_tagfile:      searching for tags file, don't use 'suffixesadd'
 typedef struct ff_search_ctx_T {
   ff_stack_T *ffsc_stack_ptr;
   ff_visited_list_hdr_T *ffsc_visited_list;
@@ -341,15 +331,13 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
 #endif
   }
 
-  /*
-   * If stopdirs are given, split them into an array of pointers.
-   * If this fails (mem allocation), there is no upward search at all or a
-   * stop directory is not recognized -> continue silently.
-   * If stopdirs just contains a ";" or is empty,
-   * search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
-   * is handled as unlimited upward search.  See function
-   * ff_path_in_stoplist() for details.
-   */
+  // If stopdirs are given, split them into an array of pointers.
+  // If this fails (mem allocation), there is no upward search at all or a
+  // stop directory is not recognized -> continue silently.
+  // If stopdirs just contains a ";" or is empty,
+  // search_ctx->ffsc_stopdirs_v will only contain a  NULL pointer. This
+  // is handled as unlimited upward search.  See function
+  // ff_path_in_stoplist() for details.
   if (stopdirs != NULL) {
     char *walker = stopdirs;
 
@@ -401,15 +389,13 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     assert(wc_part - path >= 0);
     search_ctx->ffsc_fix_path = xstrnsave(path, (size_t)(wc_part - path));
 
-    /*
-     * copy wc_path and add restricts to the '**' wildcard.
-     * The octet after a '**' is used as a (binary) counter.
-     * So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
-     * or '**76' is transposed to '**N'( 'N' is ASCII value 76).
-     * If no restrict is given after '**' the default is used.
-     * Due to this technique the path looks awful if you print it as a
-     * string.
-     */
+    // copy wc_path and add restricts to the '**' wildcard.
+    // The octet after a '**' is used as a (binary) counter.
+    // So '**3' is transposed to '**^C' ('^C' is ASCII value 3)
+    // or '**76' is transposed to '**N'( 'N' is ASCII value 76).
+    // If no restrict is given after '**' the default is used.
+    // Due to this technique the path looks awful if you print it as a
+    // string.
     len = 0;
     while (*wc_part != NUL) {
       if (len + 5 >= MAXPATHL) {
@@ -513,11 +499,9 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
   return search_ctx;
 
 error_return:
-  /*
-   * We clear the search context now!
-   * Even when the caller gave us a (perhaps valid) context we free it here,
-   * as we might have already destroyed it.
-   */
+  // We clear the search context now!
+  // Even when the caller gave us a (perhaps valid) context we free it here,
+  // as we might have already destroyed it.
   vim_findfile_cleanup(search_ctx);
   return NULL;
 }
@@ -587,10 +571,8 @@ char_u *vim_findfile(void *search_ctx_arg)
 
   search_ctx = (ff_search_ctx_T *)search_ctx_arg;
 
-  /*
-   * filepath is used as buffer for various actions and as the storage to
-   * return a found filename.
-   */
+  // filepath is used as buffer for various actions and as the storage to
+  // return a found filename.
   file_path = xmalloc(MAXPATHL);
 
   // store the end of the start dir -- needed for upward search
@@ -614,25 +596,23 @@ char_u *vim_findfile(void *search_ctx_arg)
         break;
       }
 
-      /*
-       * TODO: decide if we leave this test in
-       *
-       * GOOD: don't search a directory(-tree) twice.
-       * BAD:  - check linked list for every new directory entered.
-       *       - check for double files also done below
-       *
-       * Here we check if we already searched this directory.
-       * We already searched a directory if:
-       * 1) The directory is the same.
-       * 2) We would use the same wildcard string.
-       *
-       * Good if you have links on same directory via several ways
-       *  or you have selfreferences in directories (e.g. SuSE Linux 6.3:
-       *  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
-       *
-       * This check is only needed for directories we work on for the
-       * first time (hence stackp->ff_filearray == NULL)
-       */
+      // TODO(vim): decide if we leave this test in
+      //
+      // GOOD: don't search a directory(-tree) twice.
+      // BAD:  - check linked list for every new directory entered.
+      //       - check for double files also done below
+      //
+      // Here we check if we already searched this directory.
+      // We already searched a directory if:
+      // 1) The directory is the same.
+      // 2) We would use the same wildcard string.
+      //
+      // Good if you have links on same directory via several ways
+      //  or you have selfreferences in directories (e.g. SuSE Linux 6.3:
+      //  /etc/rc.d/init.d is linked to /etc/rc.d -> endless loop)
+      //
+      // This check is only needed for directories we work on for the
+      // first time (hence stackp->ff_filearray == NULL)
       if (stackp->ffs_filearray == NULL
           && ff_check_visited(&search_ctx->ffsc_dir_visited_list->ffvl_visited_list,
                               stackp->ffs_fix_path, stackp->ffs_wc_path) == FAIL) {
@@ -666,12 +646,10 @@ char_u *vim_findfile(void *search_ctx_arg)
 
       file_path[0] = NUL;
 
-      /*
-       * If no filearray till now expand wildcards
-       * The function expand_wildcards() can handle an array of paths
-       * and all possible expands are returned in one array. We use this
-       * to handle the expansion of '**' into an empty string.
-       */
+      // If no filearray till now expand wildcards
+      // The function expand_wildcards() can handle an array of paths
+      // and all possible expands are returned in one array. We use this
+      // to handle the expansion of '**' into an empty string.
       if (stackp->ffs_filearray == NULL) {
         char *dirptrs[2];
 
@@ -737,13 +715,11 @@ char_u *vim_findfile(void *search_ctx_arg)
             }
           }
 
-          /*
-           * Here we copy until the next path separator or the end of
-           * the path. If we stop at a path separator, there is
-           * still something else left. This is handled below by
-           * pushing every directory returned from expand_wildcards()
-           * on the stack again for further search.
-           */
+          // Here we copy until the next path separator or the end of
+          // the path. If we stop at a path separator, there is
+          // still something else left. This is handled below by
+          // pushing every directory returned from expand_wildcards()
+          // on the stack again for further search.
           while (*rest_of_wildcards
                  && !vim_ispathsep(*rest_of_wildcards)) {
             if (len + 1 >= MAXPATHL) {
@@ -759,10 +735,8 @@ char_u *vim_findfile(void *search_ctx_arg)
           }
         }
 
-        /*
-         * Expand wildcards like "*" and "$VAR".
-         * If the path is a URL don't try this.
-         */
+        // Expand wildcards like "*" and "$VAR".
+        // If the path is a URL don't try this.
         if (path_with_url(dirptrs[0])) {
           stackp->ffs_filearray = xmalloc(sizeof(char *));
           stackp->ffs_filearray[0] = xstrdup(dirptrs[0]);
@@ -786,10 +760,8 @@ char_u *vim_findfile(void *search_ctx_arg)
       if (stackp->ffs_stage == 0) {
         // this is the first time we work on this directory
         if (*rest_of_wildcards == NUL) {
-          /*
-           * We don't have further wildcards to expand, so we have to
-           * check for the final file now.
-           */
+          // We don't have further wildcards to expand, so we have to
+          // check for the final file now.
           for (int i = stackp->ffs_filearray_cur; i < stackp->ffs_filearray_size; i++) {
             if (!path_with_url(stackp->ffs_filearray[i])
                 && !os_isdir(stackp->ffs_filearray[i])) {
@@ -808,10 +780,8 @@ char_u *vim_findfile(void *search_ctx_arg)
             }
             STRCAT(file_path, search_ctx->ffsc_file_to_search);
 
-            /*
-             * Try without extra suffix and then with suffixes
-             * from 'suffixesadd'.
-             */
+            // Try without extra suffix and then with suffixes
+            // from 'suffixesadd'.
             len = STRLEN(file_path);
             if (search_ctx->ffsc_tagfile) {
               suf = "";
@@ -894,10 +864,8 @@ char_u *vim_findfile(void *search_ctx_arg)
         stackp->ffs_stage = 1;
       }
 
-      /*
-       * if wildcards contains '**' we have to descent till we reach the
-       * leaves of the directory tree.
-       */
+      // if wildcards contains '**' we have to descent till we reach the
+      // leaves of the directory tree.
       if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) {
         for (int i = stackp->ffs_filearray_cur;
              i < stackp->ffs_filearray_size; i++) {
@@ -1048,9 +1016,7 @@ static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename,
   }
 #endif
 
-  /*
-   * if we reach this we didn't find a list and we have to allocate new list
-   */
+  // if we reach this we didn't find a list and we have to allocate new list
   retptr = xmalloc(sizeof(*retptr));
 
   retptr->ffvl_visited_list = NULL;
@@ -1136,9 +1102,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *
     }
   }
 
-  /*
-   * New file/dir.  Add it to the list of visited files/dirs.
-   */
+  // New file/dir.  Add it to the list of visited files/dirs.
   vp = xmalloc(sizeof(ff_visited_T) + STRLEN(ff_expand_buffer));
 
   if (!url) {
@@ -1434,11 +1398,9 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
       || (ff_file_to_find[0] != NUL && ff_file_to_find[1] == ':')
 #endif
       ) {
-    /*
-     * Absolute path, no need to use "path_option".
-     * If this is not a first call, return NULL.  We already returned a
-     * filename on the first call.
-     */
+    // Absolute path, no need to use "path_option".
+    // If this is not a first call, return NULL.  We already returned a
+    // filename on the first call.
     if (first == true) {
       if (path_with_url((char *)ff_file_to_find)) {
         file_name = vim_strsave(ff_file_to_find);
@@ -1483,11 +1445,9 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
       }
     }
   } else {
-    /*
-     * Loop over all paths in the 'path' or 'cdpath' option.
-     * When "first" is set, first setup to the start of the option.
-     * Otherwise continue to find the next match.
-     */
+    // Loop over all paths in the 'path' or 'cdpath' option.
+    // When "first" is set, first setup to the start of the option.
+    // Otherwise continue to find the next match.
     if (first == true) {
       // vim_findfile_free_visited can handle a possible NULL pointer
       vim_findfile_free_visited(fdip_search_ctx);
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 889e569672..a29a0efe40 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -90,9 +90,7 @@
  * with iconv() to be able to allocate a buffer. */
 #define ICONV_MULT 8
 
-/*
- * Structure to pass arguments from buf_write() to buf_write_bytes().
- */
+// Structure to pass arguments from buf_write() to buf_write_bytes().
 struct bw_info {
   int bw_fd;                     // file descriptor
   char_u *bw_buf;           // buffer with data to be written
@@ -257,12 +255,10 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
 
   curbuf->b_no_eol_lnum = 0;    // in case it was set by the previous read
 
-  /*
-   * If there is no file name yet, use the one for the read file.
-   * BF_NOTEDITED is set to reflect this.
-   * Don't do this for a read from a filter.
-   * Only do this when 'cpoptions' contains the 'f' flag.
-   */
+  // If there is no file name yet, use the one for the read file.
+  // BF_NOTEDITED is set to reflect this.
+  // Don't do this for a read from a filter.
+  // Only do this when 'cpoptions' contains the 'f' flag.
   if (curbuf->b_ffname == NULL
       && !filtering
       && fname != NULL
@@ -401,12 +397,10 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
   // Set default or forced 'fileformat' and 'binary'.
   set_file_options(set_options, eap);
 
-  /*
-   * When opening a new file we take the readonly flag from the file.
-   * Default is r/w, can be set to r/o below.
-   * Don't reset it when in readonly mode
-   * Only set/reset b_p_ro when BF_CHECK_RO is set.
-   */
+  // When opening a new file we take the readonly flag from the file.
+  // Default is r/w, can be set to r/o below.
+  // Don't reset it when in readonly mode
+  // Only set/reset b_p_ro when BF_CHECK_RO is set.
   check_readonly = (newfile && (curbuf->b_flags & BF_CHECK_RO));
   if (check_readonly && !readonlymode) {
     curbuf->b_p_ro = false;
@@ -419,17 +413,15 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
       curbuf->b_mtime_read = curbuf->b_mtime;
       curbuf->b_mtime_read_ns = curbuf->b_mtime_ns;
 #ifdef UNIX
-      /*
-       * Use the protection bits of the original file for the swap file.
-       * This makes it possible for others to read the name of the
-       * edited file from the swapfile, but only if they can read the
-       * edited file.
-       * Remove the "write" and "execute" bits for group and others
-       * (they must not write the swapfile).
-       * Add the "read" and "write" bits for the user, otherwise we may
-       * not be able to write to the file ourselves.
-       * Setting the bits is done below, after creating the swap file.
-       */
+      // Use the protection bits of the original file for the swap file.
+      // This makes it possible for others to read the name of the
+      // edited file from the swapfile, but only if they can read the
+      // edited file.
+      // Remove the "write" and "execute" bits for group and others
+      // (they must not write the swapfile).
+      // Add the "read" and "write" bits for the user, otherwise we may
+      // not be able to write to the file ourselves.
+      // Setting the bits is done below, after creating the swap file.
       swap_mode = ((int)file_info.stat.st_mode & 0644) | 0600;
 #endif
     } else {
@@ -520,10 +512,8 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     return FAIL;
   }
 
-  /*
-   * Only set the 'ro' flag for readonly files the first time they are
-   * loaded.    Help files always get readonly mode
-   */
+  // Only set the 'ro' flag for readonly files the first time they are
+  // loaded.    Help files always get readonly mode
   if ((check_readonly && file_readonly) || curbuf->b_help) {
     curbuf->b_p_ro = true;
   }
@@ -645,13 +635,11 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
       curbuf->b_p_ro = true;            // must use "w!" now
       return FAIL;
     }
-    /*
-     * Don't allow the autocommands to change the current buffer.
-     * Try to re-open the file.
-     *
-     * Don't allow the autocommands to change the buffer name either
-     * (cd for example) if it invalidates fname or sfname.
-     */
+    // Don't allow the autocommands to change the current buffer.
+    // Try to re-open the file.
+    //
+    // Don't allow the autocommands to change the buffer name either
+    // (cd for example) if it invalidates fname or sfname.
     if (!read_stdin && (curbuf != old_curbuf
                         || (using_b_ffname && (old_b_ffname != curbuf->b_ffname))
                         || (using_b_fname && (old_b_fname != curbuf->b_fname))
@@ -679,10 +667,8 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
 
   msg_scroll = false;                   // overwrite the file message
 
-  /*
-   * Set linecnt now, before the "retry" caused by a wrong guess for
-   * fileformat, and after the autocommands, which may change them.
-   */
+  // Set linecnt now, before the "retry" caused by a wrong guess for
+  // fileformat, and after the autocommands, which may change them.
   linecnt = curbuf->b_ml.ml_line_count;
 
   // "++bad=" argument.
@@ -695,9 +681,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     curbuf->b_bad_char = 0;
   }
 
-  /*
-   * Decide which 'encoding' to use or use first.
-   */
+  // Decide which 'encoding' to use or use first.
   if (eap != NULL && eap->force_enc != 0) {
     fenc = enc_canonize(eap->cmd + eap->force_enc);
     fenc_alloced = true;
@@ -722,25 +706,23 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     fenc = next_fenc(&fenc_next, &fenc_alloced);
   }
 
-  /*
-   * Jump back here to retry reading the file in different ways.
-   * Reasons to retry:
-   * - encoding conversion failed: try another one from "fenc_next"
-   * - BOM detected and fenc was set, need to setup conversion
-   * - "fileformat" check failed: try another
-   *
-   * Variables set for special retry actions:
-   * "file_rewind"      Rewind the file to start reading it again.
-   * "advance_fenc"     Advance "fenc" using "fenc_next".
-   * "skip_read"        Re-use already read bytes (BOM detected).
-   * "did_iconv"        iconv() conversion failed, try 'charconvert'.
-   * "keep_fileformat" Don't reset "fileformat".
-   *
-   * Other status indicators:
-   * "tmpname"  When != NULL did conversion with 'charconvert'.
-   *                    Output file has to be deleted afterwards.
-   * "iconv_fd" When != -1 did conversion with iconv().
-   */
+  // Jump back here to retry reading the file in different ways.
+  // Reasons to retry:
+  // - encoding conversion failed: try another one from "fenc_next"
+  // - BOM detected and fenc was set, need to setup conversion
+  // - "fileformat" check failed: try another
+  //
+  // Variables set for special retry actions:
+  // "file_rewind"      Rewind the file to start reading it again.
+  // "advance_fenc"     Advance "fenc" using "fenc_next".
+  // "skip_read"        Re-use already read bytes (BOM detected).
+  // "did_iconv"        iconv() conversion failed, try 'charconvert'.
+  // "keep_fileformat" Don't reset "fileformat".
+  //
+  // Other status indicators:
+  // "tmpname"  When != NULL did conversion with 'charconvert'.
+  //                    Output file has to be deleted afterwards.
+  // "iconv_fd" When != -1 did conversion with iconv().
 retry:
 
   if (file_rewind) {
@@ -764,10 +746,8 @@ retry:
     conv_error = 0;
   }
 
-  /*
-   * When retrying with another "fenc" and the first time "fileformat"
-   * will be reset.
-   */
+  // When retrying with another "fenc" and the first time "fileformat"
+  // will be reset.
   if (keep_fileformat) {
     keep_fileformat = false;
   } else {
@@ -793,9 +773,7 @@ retry:
 #endif
 
   if (advance_fenc) {
-    /*
-     * Try the next entry in 'fileencodings'.
-     */
+    // Try the next entry in 'fileencodings'.
     advance_fenc = false;
 
     if (eap != NULL && eap->force_enc != 0) {
@@ -825,10 +803,8 @@ retry:
     }
   }
 
-  /*
-   * Conversion may be required when the encoding of the file is different
-   * from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4.
-   */
+  // Conversion may be required when the encoding of the file is different
+  // from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4.
   fio_flags = 0;
   converted = need_conversion((char_u *)fenc);
   if (converted) {
@@ -855,10 +831,8 @@ retry:
     }
 #endif
 
-    /*
-     * Use the 'charconvert' expression when conversion is required
-     * and we can't do it internally or with iconv().
-     */
+    // Use the 'charconvert' expression when conversion is required
+    // and we can't do it internally or with iconv().
     if (fio_flags == 0 && !read_stdin && !read_buffer && *p_ccv != NUL
         && !read_fifo
 #ifdef HAVE_ICONV
@@ -922,12 +896,10 @@ retry:
   }
 
   while (!error && !got_int) {
-    /*
-     * We allocate as much space for the file as we can get, plus
-     * space for the old line plus room for one terminating NUL.
-     * The amount is limited by the fact that read() only can read
-     * up to max_unsigned characters (and other things).
-     */
+    // We allocate as much space for the file as we can get, plus
+    // space for the old line plus room for one terminating NUL.
+    // The amount is limited by the fact that read() only can read
+    // up to max_unsigned characters (and other things).
     {
       if (!skip_read) {
         // Use buffer >= 64K.  Add linerest to double the size if the
@@ -999,10 +971,8 @@ retry:
         }
 
         if (read_buffer) {
-          /*
-           * Read bytes from curbuf.  Used for converting text read
-           * from stdin.
-           */
+          // Read bytes from curbuf.  Used for converting text read
+          // from stdin.
           if (read_buf_lnum > from) {
             size = 0;
           } else {
@@ -1052,9 +1022,7 @@ retry:
             }
           }
         } else {
-          /*
-           * Read bytes from the file.
-           */
+          // Read bytes from the file.
           size = read_eintr(fd, ptr, (size_t)size);
         }
 
@@ -1062,10 +1030,8 @@ retry:
           if (size < 0) {                           // read error
             error = true;
           } else if (conv_restlen > 0) {
-            /*
-             * Reached end-of-file but some trailing bytes could
-             * not be converted.  Truncated file?
-             */
+            // Reached end-of-file but some trailing bytes could
+            // not be converted.  Truncated file?
 
             // When we did a conversion report an error.
             if (fio_flags != 0
@@ -1118,12 +1084,10 @@ retry:
 
       skip_read = false;
 
-      /*
-       * At start of file: Check for BOM.
-       * Also check for a BOM for other Unicode encodings, but not after
-       * converting with 'charconvert' or when a BOM has already been
-       * found.
-       */
+      // At start of file: Check for BOM.
+      // Also check for a BOM for other Unicode encodings, but not after
+      // converting with 'charconvert' or when a BOM has already been
+      // found.
       if ((filesize == 0)
           && (fio_flags == FIO_UCSBOM
               || (!curbuf->b_p_bomb
@@ -1172,9 +1136,7 @@ retry:
       ptr -= conv_restlen;
       size += conv_restlen;
       conv_restlen = 0;
-      /*
-       * Break here for a read error or end-of-file.
-       */
+      // Break here for a read error or end-of-file.
       if (size <= 0) {
         break;
       }
@@ -1188,11 +1150,9 @@ retry:
         char *top = ptr;
         size_t to_size = (size_t)(real_size - size);
 
-        /*
-         * If there is conversion error or not enough room try using
-         * another conversion.  Except for when there is no
-         * alternative (help files).
-         */
+        // If there is conversion error or not enough room try using
+        // another conversion.  Except for when there is no
+        // alternative (help files).
         while ((iconv(iconv_fd, (void *)&fromp, &from_size,
                       &top, &to_size)
                 == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
@@ -1493,9 +1453,7 @@ rewind_retry:
       // count the number of characters (after conversion!)
       filesize += size;
 
-      /*
-       * when reading the first part of a file: guess EOL type
-       */
+      // when reading the first part of a file: guess EOL type
       if (fileformat == EOL_UNKNOWN) {
         // First try finding a NL, for Dos and Unix
         if (try_dos || try_unix) {
@@ -1560,10 +1518,8 @@ rewind_retry:
       }
     }
 
-    /*
-     * This loop is executed once for every character read.
-     * Keep it fast!
-     */
+    // This loop is executed once for every character read.
+    // Keep it fast!
     if (fileformat == EOL_MAC) {
       ptr--;
       while (++ptr, --size >= 0) {
@@ -1665,11 +1621,9 @@ failed:
     error = false;
   }
 
-  /*
-   * If we get EOF in the middle of a line, note the fact and
-   * complete the line ourselves.
-   * In Dos format ignore a trailing CTRL-Z, unless 'binary' set.
-   */
+  // If we get EOF in the middle of a line, note the fact and
+  // complete the line ourselves.
+  // In Dos format ignore a trailing CTRL-Z, unless 'binary' set.
   if (!error
       && !got_int
       && linerest != 0
@@ -1738,9 +1692,7 @@ failed:
   }
   no_wait_return--;                     // may wait for return now
 
-  /*
-   * In recovery mode everything but autocommands is skipped.
-   */
+  // In recovery mode everything but autocommands is skipped.
   if (!recoverymode) {
     // need to delete the last line, which comes from the empty buffer
     if (newfile && wasempty && !(curbuf->b_ml.ml_flags & ML_EMPTY)) {
@@ -1767,11 +1719,9 @@ failed:
       appended_lines_mark(from, linecnt);
     }
 
-    /*
-     * If we were reading from the same terminal as where messages go,
-     * the screen will have been messed up.
-     * Switch on raw mode now and clear the screen.
-     */
+    // If we were reading from the same terminal as where messages go,
+    // the screen will have been messed up.
+    // Switch on raw mode now and clear the screen.
     if (read_stdin) {
       screenclear();
     }
@@ -1878,10 +1828,8 @@ failed:
 
     u_clearline();          // cannot use "U" command after adding lines
 
-    /*
-     * In Ex mode: cursor at last new line.
-     * Otherwise: cursor at first new line.
-     */
+    // In Ex mode: cursor at last new line.
+    // Otherwise: cursor at first new line.
     if (exmode_active) {
       curwin->w_cursor.lnum = from + linecnt;
     } else {
@@ -1900,17 +1848,13 @@ failed:
   }
   msg_scroll = msg_save;
 
-  /*
-   * Get the marks before executing autocommands, so they can be used there.
-   */
+  // Get the marks before executing autocommands, so they can be used there.
   check_marks_read();
 
-  /*
-   * We remember if the last line of the read didn't have
-   * an eol even when 'binary' is off, to support turning 'fixeol' off,
-   * or writing the read again with 'binary' on.  The latter is required
-   * for ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
-   */
+  // We remember if the last line of the read didn't have
+  // an eol even when 'binary' is off, to support turning 'fixeol' off,
+  // or writing the read again with 'binary' on.  The latter is required
+  // for ":autocmd FileReadPost *.gz set bin|'[,']!gunzip" to work.
   curbuf->b_no_eol_lnum = read_no_eol_lnum;
 
   // When reloading a buffer put the cursor at the first line that is
@@ -1919,9 +1863,7 @@ failed:
     u_find_first_changed();
   }
 
-  /*
-   * When opening a new file locate undo info and read it.
-   */
+  // When opening a new file locate undo info and read it.
   if (read_undo_file) {
     char_u hash[UNDO_HASH_SIZE];
 
@@ -1939,11 +1881,9 @@ failed:
       save_file_ff(curbuf);
     }
 
-    /*
-     * The output from the autocommands should not overwrite anything and
-     * should not be overwritten: Set msg_scroll, restore its value if no
-     * output was done.
-     */
+    // The output from the autocommands should not overwrite anything and
+    // should not be overwritten: Set msg_scroll, restore its value if no
+    // output was done.
     msg_scroll = true;
     if (filtering) {
       apply_autocmds_exarg(EVENT_FILTERREADPOST, NULL, sfname,
@@ -2256,10 +2196,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     return FAIL;
   }
 
-  /*
-   * Disallow writing from .exrc and .vimrc in current directory for
-   * security reasons.
-   */
+  // Disallow writing from .exrc and .vimrc in current directory for
+  // security reasons.
   if (check_secure()) {
     return FAIL;
   }
@@ -2283,13 +2221,11 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
    * the line. */
   ex_no_reprint = true;
 
-  /*
-   * If there is no file name yet, use the one for the written file.
-   * BF_NOTEDITED is set to reflect this (in case the write fails).
-   * Don't do this when the write is for a filter command.
-   * Don't do this when appending.
-   * Only do this when 'cpoptions' contains the 'F' flag.
-   */
+  // If there is no file name yet, use the one for the written file.
+  // BF_NOTEDITED is set to reflect this (in case the write fails).
+  // Don't do this when the write is for a filter command.
+  // Don't do this when appending.
+  // Only do this when 'cpoptions' contains the 'F' flag.
   if (buf->b_ffname == NULL
       && reset_changed
       && whole
@@ -2325,9 +2261,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
   no_wait_return++;                 // don't wait for return yet
 
-  /*
-   * Set '[ and '] marks to the lines to be written.
-   */
+  // Set '[ and '] marks to the lines to be written.
   buf->b_op_start.lnum = start;
   buf->b_op_start.col = 0;
   buf->b_op_end.lnum = end;
@@ -2344,11 +2278,9 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     int empty_memline = (buf->b_ml.ml_mfp == NULL);
     bufref_T bufref;
 
-    /*
-     * Apply PRE autocommands.
-     * Set curbuf to the buffer to be written.
-     * Careful: The autocommands may call buf_write() recursively!
-     */
+    // Apply PRE autocommands.
+    // Set curbuf to the buffer to be written.
+    // Careful: The autocommands may call buf_write() recursively!
     if (ffname == buf->b_ffname) {
       buf_ffname = true;
     }
@@ -2471,12 +2403,10 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       return FAIL;
     }
 
-    /*
-     * The autocommands may have changed the number of lines in the file.
-     * When writing the whole file, adjust the end.
-     * When writing part of the file, assume that the autocommands only
-     * changed the number of lines that are to be written (tricky!).
-     */
+    // The autocommands may have changed the number of lines in the file.
+    // When writing the whole file, adjust the end.
+    // When writing part of the file, assume that the autocommands only
+    // changed the number of lines that are to be written (tricky!).
     if (buf->b_ml.ml_line_count != old_line_count) {
       if (whole) {                                              // write all
         end = buf->b_ml.ml_line_count;
@@ -2493,10 +2423,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       }
     }
 
-    /*
-     * The autocommands may have changed the name of the buffer, which may
-     * be kept in fname, ffname and sfname.
-     */
+    // The autocommands may have changed the name of the buffer, which may
+    // be kept in fname, ffname and sfname.
     if (buf_ffname) {
       ffname = buf->b_ffname;
     }
@@ -2543,9 +2471,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     bufsize = BUFSIZE;
   }
 
-  /*
-   * Get information about original file (if there is one).
-   */
+  // Get information about original file (if there is one).
   FileInfo file_info_old;
 #if defined(UNIX)
   perm = -1;
@@ -2595,10 +2521,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 #endif  // !UNIX
 
   if (!device && !newfile) {
-    /*
-     * Check if the file is really writable (when renaming the file to
-     * make a backup we won't discover it later).
-     */
+    // Check if the file is really writable (when renaming the file to
+    // make a backup we won't discover it later).
     file_readonly = !os_file_is_writable(fname);
 
     if (!forceit && file_readonly) {
@@ -2610,9 +2534,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       goto fail;
     }
 
-    /*
-     * Check if the timestamp hasn't changed since reading the file.
-     */
+    // Check if the timestamp hasn't changed since reading the file.
     if (overwriting) {
       retval = check_mtime(buf, &file_info_old);
       if (retval == FAIL) {
@@ -2622,41 +2544,33 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   }
 
 #ifdef HAVE_ACL
-  /*
-   * For systems that support ACL: get the ACL from the original file.
-   */
+  // For systems that support ACL: get the ACL from the original file.
   if (!newfile) {
     acl = mch_get_acl((char_u *)fname);
   }
 #endif
 
-  /*
-   * If 'backupskip' is not empty, don't make a backup for some files.
-   */
+  // If 'backupskip' is not empty, don't make a backup for some files.
   dobackup = (p_wb || p_bk || *p_pm != NUL);
   if (dobackup && *p_bsk != NUL && match_file_list(p_bsk, (char_u *)sfname, (char_u *)ffname)) {
     dobackup = false;
   }
 
-  /*
-   * Save the value of got_int and reset it.  We don't want a previous
-   * interruption cancel writing, only hitting CTRL-C while writing should
-   * abort it.
-   */
+  // Save the value of got_int and reset it.  We don't want a previous
+  // interruption cancel writing, only hitting CTRL-C while writing should
+  // abort it.
   prev_got_int = got_int;
   got_int = false;
 
   // Mark the buffer as 'being saved' to prevent changed buffer warnings
   buf->b_saving = true;
 
-  /*
-   * If we are not appending or filtering, the file exists, and the
-   * 'writebackup', 'backup' or 'patchmode' option is set, need a backup.
-   * When 'patchmode' is set also make a backup when appending.
-   *
-   * Do not make any backup, if 'writebackup' and 'backup' are both switched
-   * off.  This helps when editing large files on almost-full disks.
-   */
+  // If we are not appending or filtering, the file exists, and the
+  // 'writebackup', 'backup' or 'patchmode' option is set, need a backup.
+  // When 'patchmode' is set also make a backup when appending.
+  //
+  // Do not make any backup, if 'writebackup' and 'backup' are both switched
+  // off.  This helps when editing large files on almost-full disks.
   if (!(append && *p_pm == NUL) && !filtering && perm >= 0 && dobackup) {
     FileInfo file_info;
     const bool no_prepend_dot = false;
@@ -2666,23 +2580,19 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     } else if ((bkc & BKC_AUTO)) {          // "auto"
       int i;
 
-      /*
-       * Don't rename the file when:
-       * - it's a hard link
-       * - it's a symbolic link
-       * - we don't have write permission in the directory
-       */
+      // Don't rename the file when:
+      // - it's a hard link
+      // - it's a symbolic link
+      // - we don't have write permission in the directory
       if (os_fileinfo_hardlinks(&file_info_old) > 1
           || !os_fileinfo_link(fname, &file_info)
           || !os_fileinfo_id_equal(&file_info, &file_info_old)) {
         backup_copy = true;
       } else {
-        /*
-         * Check if we can create a file and set the owner/group to
-         * the ones from the original file.
-         * First find a file name that doesn't exist yet (use some
-         * arbitrary numbers).
-         */
+        // Check if we can create a file and set the owner/group to
+        // the ones from the original file.
+        // First find a file name that doesn't exist yet (use some
+        // arbitrary numbers).
         STRCPY(IObuff, fname);
         for (i = 4913;; i += 123) {
           char *tail = path_tail((char *)IObuff);
@@ -2714,9 +2624,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       }
     }
 
-    /*
-     * Break symlinks and/or hardlinks if we've been asked to.
-     */
+    // Break symlinks and/or hardlinks if we've been asked to.
     if ((bkc & BKC_BREAKSYMLINK) || (bkc & BKC_BREAKHARDLINK)) {
 #ifdef UNIX
       bool file_info_link_ok = os_fileinfo_link(fname, &file_info);
@@ -2752,23 +2660,19 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
       char *rootname;
       char *p;
 
-      /*
-       * Try to make the backup in each directory in the 'bdir' option.
-       *
-       * Unix semantics has it, that we may have a writable file,
-       * that cannot be recreated with a simple open(..., O_CREAT, ) e.g:
-       *  - the directory is not writable,
-       *  - the file may be a symbolic link,
-       *  - the file may belong to another user/group, etc.
-       *
-       * For these reasons, the existing writable file must be truncated
-       * and reused. Creation of a backup COPY will be attempted.
-       */
+      // Try to make the backup in each directory in the 'bdir' option.
+      //
+      // Unix semantics has it, that we may have a writable file,
+      // that cannot be recreated with a simple open(..., O_CREAT, ) e.g:
+      //  - the directory is not writable,
+      //  - the file may be a symbolic link,
+      //  - the file may belong to another user/group, etc.
+      //
+      // For these reasons, the existing writable file must be truncated
+      // and reused. Creation of a backup COPY will be attempted.
       dirp = p_bdir;
       while (*dirp) {
-        /*
-         * Isolate one directory name, using an entry in 'bdir'.
-         */
+        // Isolate one directory name, using an entry in 'bdir'.
         size_t dir_len = copy_option_part(&dirp, (char *)IObuff, IOSIZE, ",");
         p = (char *)IObuff + dir_len;
         bool trailing_pathseps = after_pathsep((char *)IObuff, p) && p[-1] == p[-2];
@@ -2814,9 +2718,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
             goto nobackup;
           }
 
-          /*
-           * Check if backup file already exists.
-           */
+          // Check if backup file already exists.
           if (os_fileinfo(backup, &file_info_new)) {
             if (os_fileinfo_id_equal(&file_info_new, &file_info_old)) {
               //
@@ -2848,9 +2750,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
         }
         xfree(rootname);
 
-        /*
-         * Try to create the backup file
-         */
+        // Try to create the backup file
         if (backup != NULL) {
           // remove old backup, if present
           os_remove(backup);
@@ -2906,30 +2806,22 @@ nobackup:
       char *p;
       char *rootname;
 
-      /*
-       * Make a backup by renaming the original file.
-       */
-      /*
-       * If 'cpoptions' includes the "W" flag, we don't want to
-       * overwrite a read-only file.  But rename may be possible
-       * anyway, thus we need an extra check here.
-       */
+      // Make a backup by renaming the original file.
+
+      // If 'cpoptions' includes the "W" flag, we don't want to
+      // overwrite a read-only file.  But rename may be possible
+      // anyway, thus we need an extra check here.
       if (file_readonly && vim_strchr(p_cpo, CPO_FWRITE) != NULL) {
         SET_ERRMSG_NUM("E504", _(err_readonly));
         goto fail;
       }
 
-      /*
-       *
-       * Form the backup file name - change path/fo.o.h to
-       * path/fo.o.h.bak Try all directories in 'backupdir', first one
-       * that works is used.
-       */
+      // Form the backup file name - change path/fo.o.h to
+      // path/fo.o.h.bak Try all directories in 'backupdir', first one
+      // that works is used.
       dirp = p_bdir;
       while (*dirp) {
-        /*
-         * Isolate one directory name and make the backup file name.
-         */
+        // Isolate one directory name and make the backup file name.
         size_t dir_len = copy_option_part(&dirp, (char *)IObuff, IOSIZE, ",");
         p = (char *)IObuff + dir_len;
         bool trailing_pathseps = after_pathsep((char *)IObuff, p) && p[-1] == p[-2];
@@ -2965,11 +2857,9 @@ nobackup:
         }
 
         if (backup != NULL) {
-          /*
-           * If we are not going to keep the backup file, don't
-           * delete an existing one, try to use another name.
-           * Change one character, just before the extension.
-           */
+          // If we are not going to keep the backup file, don't
+          // delete an existing one, try to use another name.
+          // Change one character, just before the extension.
           if (!p_bk && os_path_exists(backup)) {
             p = backup + STRLEN(backup) - 1 - STRLEN(backup_ext);
             if (p < backup) {           // empty file name ???
@@ -3099,11 +2989,9 @@ nobackup:
     } else {
 #endif
 
-    /*
-     * When the file needs to be converted with 'charconvert' after
-     * writing, write to a temp file instead and let the conversion
-     * overwrite the original file.
-     */
+    // When the file needs to be converted with 'charconvert' after
+    // writing, write to a temp file instead and let the conversion
+    // overwrite the original file.
     if (*p_ccv != NUL) {
       wfname = (char *)vim_tempname();
       if (wfname == NULL) {  // Can't write without a tempfile!
@@ -3561,10 +3449,8 @@ restore_backup:
     u_update_save_nr(buf);
   }
 
-  /*
-   * If written to the current file, update the timestamp of the swap file
-   * and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime.
-   */
+  // If written to the current file, update the timestamp of the swap file
+  // and reset the BF_WRITE_MASK flags. Also sets buf->b_mtime.
   if (overwriting) {
     ml_timestamp(buf);
     if (append) {
@@ -3574,18 +3460,14 @@ restore_backup:
     }
   }
 
-  /*
-   * If we kept a backup until now, and we are in patch mode, then we make
-   * the backup file our 'original' file.
-   */
+  // If we kept a backup until now, and we are in patch mode, then we make
+  // the backup file our 'original' file.
   if (*p_pm && dobackup) {
     char *const org = modname(fname, p_pm, false);
 
     if (backup != NULL) {
-      /*
-       * If the original file does not exist yet
-       * the current backup file becomes the original file
-       */
+      // If the original file does not exist yet
+      // the current backup file becomes the original file
       if (org == NULL) {
         emsg(_("E205: Patchmode: can't save original file"));
       } else if (!os_path_exists(org)) {
@@ -3597,12 +3479,9 @@ restore_backup:
                         (double)file_info_old.stat.st_mtim.tv_sec);
 #endif
       }
-    }
-    /*
-     * If there is no backup file, remember that a (new) file was
-     * created.
-     */
-    else {
+    } else {
+      // If there is no backup file, remember that a (new) file was
+      // created.
       int empty_fd;
 
       if (org == NULL
@@ -3620,9 +3499,7 @@ restore_backup:
     }
   }
 
-  /*
-   * Remove the backup unless 'backup' option is set
-   */
+  // Remove the backup unless 'backup' option is set
   if (!p_bk && backup != NULL
       && !write_info.bw_conv_error
       && os_remove(backup) != 0) {
@@ -3631,9 +3508,7 @@ restore_backup:
 
   goto nofail;
 
-  /*
-   * Finish up.  We get here either after failure or success.
-   */
+  // Finish up.  We get here either after failure or success.
 fail:
   no_wait_return--;             // may wait for return now
 nofail:
@@ -3698,10 +3573,8 @@ nofail:
   }
   msg_scroll = msg_save;
 
-  /*
-   * When writing the whole file and 'undofile' is set, also write the undo
-   * file.
-   */
+  // When writing the whole file and 'undofile' is set, also write the undo
+  // file.
   if (retval == OK && write_undo_file) {
     char hash[UNDO_HASH_SIZE];
 
@@ -3714,10 +3587,8 @@ nofail:
 
     curbuf->b_no_eol_lnum = 0;      // in case it was set by the previous read
 
-    /*
-     * Apply POST autocommands.
-     * Careful: The autocommands may call buf_write() recursively!
-     */
+    // Apply POST autocommands.
+    // Careful: The autocommands may call buf_write() recursively!
     aucmd_prepbuf(&aco, buf);
 
     if (append) {
@@ -3918,18 +3789,14 @@ static int buf_write_bytes(struct bw_info *ip)
   int flags = ip->bw_flags;             // extra flags
 #endif
 
-  /*
-   * Skip conversion when writing the BOM.
-   */
+  // Skip conversion when writing the BOM.
   if (!(flags & FIO_NOCONVERT)) {
     char_u *p;
     unsigned c;
     int n;
 
     if (flags & FIO_UTF8) {
-      /*
-       * Convert latin1 in the buffer to UTF-8 in the file.
-       */
+      // Convert latin1 in the buffer to UTF-8 in the file.
       p = ip->bw_conv_buf;              // translate to buffer
       for (wlen = 0; wlen < len; wlen++) {
         p += utf_char2bytes(buf[wlen], (char *)p);
@@ -3937,10 +3804,8 @@ static int buf_write_bytes(struct bw_info *ip)
       buf = ip->bw_conv_buf;
       len = (int)(p - ip->bw_conv_buf);
     } else if (flags & (FIO_UCS4 | FIO_UTF16 | FIO_UCS2 | FIO_LATIN1)) {
-      /*
-       * Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
-       * Latin1 chars in the file.
-       */
+      // Convert UTF-8 bytes in the buffer to UCS-2, UCS-4, UTF-16 or
+      // Latin1 chars in the file.
       if (flags & FIO_LATIN1) {
         p = buf;                // translate in-place (can only get shorter)
       } else {
@@ -4063,9 +3928,7 @@ static int buf_write_bytes(struct bw_info *ip)
         ip->bw_first = false;
       }
 
-      /*
-       * If iconv() has an error or there is not enough room, fail.
-       */
+      // If iconv() has an error or there is not enough room, fail.
       if ((iconv(ip->bw_iconv_fd, (void *)&from, &fromlen, &to, &tolen)
            == (size_t)-1 && ICONV_ERRNO != ICONV_EINVAL)
           || fromlen > CONV_RESTLEN) {
@@ -4633,11 +4496,9 @@ int vim_rename(const char_u *from, const char_u *to)
 #endif
   bool use_tmp_file = false;
 
-  /*
-   * When the names are identical, there is nothing to do.  When they refer
-   * to the same file (ignoring case and slash/backslash differences) but
-   * the file name differs we need to go through a temp file.
-   */
+  // When the names are identical, there is nothing to do.  When they refer
+  // to the same file (ignoring case and slash/backslash differences) but
+  // the file name differs we need to go through a temp file.
   if (FNAMECMP(from, to) == 0) {
     if (p_fic && (STRCMP(path_tail((char *)from), path_tail((char *)to))
                   != 0)) {
@@ -4665,10 +4526,8 @@ int vim_rename(const char_u *from, const char_u *to)
   if (use_tmp_file) {
     char_u tempname[MAXPATHL + 1];
 
-    /*
-     * Find a name that doesn't exist and is in the same directory.
-     * Rename "from" to "tempname" and then rename "tempname" to "to".
-     */
+    // Find a name that doesn't exist and is in the same directory.
+    // Rename "from" to "tempname" and then rename "tempname" to "to".
     if (STRLEN(from) >= MAXPATHL - 5) {
       return -1;
     }
@@ -4695,24 +4554,18 @@ int vim_rename(const char_u *from, const char_u *to)
     return -1;
   }
 
-  /*
-   * Delete the "to" file, this is required on some systems to make the
-   * os_rename() work, on other systems it makes sure that we don't have
-   * two files when the os_rename() fails.
-   */
+  // Delete the "to" file, this is required on some systems to make the
+  // os_rename() work, on other systems it makes sure that we don't have
+  // two files when the os_rename() fails.
 
   os_remove((char *)to);
 
-  /*
-   * First try a normal rename, return if it works.
-   */
+  // First try a normal rename, return if it works.
   if (os_rename(from, to) == OK) {
     return 0;
   }
 
-  /*
-   * Rename() failed, try copying the file.
-   */
+  // Rename() failed, try copying the file.
   perm = os_getperm((const char *)from);
 #ifdef HAVE_ACL
   // For systems that support ACL: get the ACL from the original file.
@@ -5553,12 +5406,10 @@ bool match_file_pat(char *pattern, regprog_T **prog, char *fname, char *sfname,
     }
   }
 
-  /*
-   * Try for a match with the pattern with:
-   * 1. the full file name, when the pattern has a '/'.
-   * 2. the short file name, when the pattern has a '/'.
-   * 3. the tail of the file name, when the pattern has no '/'.
-   */
+  // Try for a match with the pattern with:
+  // 1. the full file name, when the pattern has a '/'.
+  // 2. the short file name, when the pattern has a '/'.
+  // 3. the tail of the file name, when the pattern has no '/'.
   if (regmatch.regprog != NULL
       && ((allow_dirs
            && (vim_regexec(&regmatch, fname, (colnr_T)0)
diff --git a/src/nvim/fold.h b/src/nvim/fold.h
index f34e6d43c3..395cd8e30a 100644
--- a/src/nvim/fold.h
+++ b/src/nvim/fold.h
@@ -8,10 +8,8 @@
 #include "nvim/pos.h"
 #include "nvim/types.h"
 
-/*
- * Info used to pass info about a fold from the fold-detection code to the
- * code that displays the foldcolumn.
- */
+// Info used to pass info about a fold from the fold-detection code to the
+// code that displays the foldcolumn.
 typedef struct foldinfo {
   linenr_T fi_lnum;             // line number where fold starts
   int fi_level;                 // level of the fold; when this is zero the
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 97c3b1c61f..22c350d36b 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -87,25 +87,23 @@ static int block_redo = false;
 
 static int KeyNoremap = 0;                  // remapping flags
 
-/*
- * Variables used by vgetorpeek() and flush_buffers()
- *
- * typebuf.tb_buf[] contains all characters that are not consumed yet.
- * typebuf.tb_buf[typebuf.tb_off] is the first valid character.
- * typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1] is the last valid char.
- * typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] must be NUL.
- * The head of the buffer may contain the result of mappings, abbreviations
- * and @a commands.  The length of this part is typebuf.tb_maplen.
- * typebuf.tb_silent is the part where <silent> applies.
- * After the head are characters that come from the terminal.
- * typebuf.tb_no_abbr_cnt is the number of characters in typebuf.tb_buf that
- * should not be considered for abbreviations.
- * Some parts of typebuf.tb_buf may not be mapped. These parts are remembered
- * in typebuf.tb_noremap[], which is the same length as typebuf.tb_buf and
- * contains RM_NONE for the characters that are not to be remapped.
- * typebuf.tb_noremap[typebuf.tb_off] is the first valid flag.
- * (typebuf has been put in globals.h, because check_termcode() needs it).
- */
+// Variables used by vgetorpeek() and flush_buffers()
+//
+// typebuf.tb_buf[] contains all characters that are not consumed yet.
+// typebuf.tb_buf[typebuf.tb_off] is the first valid character.
+// typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len - 1] is the last valid char.
+// typebuf.tb_buf[typebuf.tb_off + typebuf.tb_len] must be NUL.
+// The head of the buffer may contain the result of mappings, abbreviations
+// and @a commands.  The length of this part is typebuf.tb_maplen.
+// typebuf.tb_silent is the part where <silent> applies.
+// After the head are characters that come from the terminal.
+// typebuf.tb_no_abbr_cnt is the number of characters in typebuf.tb_buf that
+// should not be considered for abbreviations.
+// Some parts of typebuf.tb_buf may not be mapped. These parts are remembered
+// in typebuf.tb_noremap[], which is the same length as typebuf.tb_buf and
+// contains RM_NONE for the characters that are not to be remapped.
+// typebuf.tb_noremap[typebuf.tb_off] is the first valid flag.
+// (typebuf has been put in globals.h, because check_termcode() needs it).
 #define RM_YES          0       // tb_noremap: remap
 #define RM_NONE         1       // tb_noremap: don't remap
 #define RM_SCRIPT       2       // tb_noremap: remap local script mappings
@@ -124,9 +122,7 @@ static size_t last_recorded_len = 0;      // number of last recorded chars
 # include "getchar.c.generated.h"
 #endif
 
-/*
- * Free and clear a buffer.
- */
+// Free and clear a buffer.
 void free_buff(buffheader_T *buf)
 {
   buffblock_T *p, *np;
@@ -180,20 +176,16 @@ char_u *get_recorded(void)
   p = get_buffcont(&recordbuff, true);
   free_buff(&recordbuff);
 
-  /*
-   * Remove the characters that were added the last time, these must be the
-   * (possibly mapped) characters that stopped the recording.
-   */
+  // Remove the characters that were added the last time, these must be the
+  // (possibly mapped) characters that stopped the recording.
   len = STRLEN(p);
   if (len >= last_recorded_len) {
     len -= last_recorded_len;
     p[len] = NUL;
   }
 
-  /*
-   * When stopping recording from Insert mode with CTRL-O q, also remove the
-   * CTRL-O.
-   */
+  // When stopping recording from Insert mode with CTRL-O q, also remove the
+  // CTRL-O.
   if (len > 0 && restart_edit != 0 && p[len - 1] == Ctrl_O) {
     p[len - 1] = NUL;
   }
@@ -351,9 +343,7 @@ static int read_readbuf(buffheader_T *buf, int advance)
   return c;
 }
 
-/*
- * Prepare the read buffers for reading (if they contain something).
- */
+// Prepare the read buffers for reading (if they contain something).
 static void start_stuff(void)
 {
   if (readbuf1.bh_first.b_next != NULL) {
@@ -381,19 +371,15 @@ int readbuf1_empty(void)
   return (readbuf1.bh_first.b_next == NULL);
 }
 
-/*
- * Set a typeahead character that won't be flushed.
- */
+// Set a typeahead character that won't be flushed.
 void typeahead_noflush(int c)
 {
   typeahead_char = c;
 }
 
-/*
- * Remove the contents of the stuff buffer and the mapped characters in the
- * typeahead buffer (used in case of an error).  If "flush_typeahead" is true,
- * flush all typeahead characters (used when interrupted by a CTRL-C).
- */
+// Remove the contents of the stuff buffer and the mapped characters in the
+// typeahead buffer (used in case of an error).  If "flush_typeahead" is true,
+// flush all typeahead characters (used when interrupted by a CTRL-C).
 void flush_buffers(flush_buffers_T flush_typeahead)
 {
   init_typebuf();
@@ -437,10 +423,8 @@ void beep_flush(void)
   }
 }
 
-/*
- * The previous contents of the redo buffer is kept in old_redobuffer.
- * This is used for the CTRL-O <.> command in insert mode.
- */
+// The previous contents of the redo buffer is kept in old_redobuffer.
+// This is used for the CTRL-O <.> command in insert mode.
 void ResetRedobuff(void)
 {
   if (!block_redo) {
@@ -450,10 +434,8 @@ void ResetRedobuff(void)
   }
 }
 
-/*
- * Discard the contents of the redo buffer and restore the previous redo
- * buffer.
- */
+// Discard the contents of the redo buffer and restore the previous redo
+// buffer.
 void CancelRedo(void)
 {
   if (!block_redo) {
@@ -559,9 +541,7 @@ void AppendCharToRedobuff(int c)
   }
 }
 
-/*
- * Append a number to the redo buffer.
- */
+// Append a number to the redo buffer.
 void AppendNumberToRedobuff(long n)
 {
   if (!block_redo) {
@@ -615,9 +595,7 @@ void stuffcharReadbuff(int c)
   add_char_buff(&readbuf1, c);
 }
 
-/*
- * Append a number to the stuff buffer.
- */
+// Append a number to the stuff buffer.
 void stuffnumReadbuff(long n)
 {
   add_num_buff(&readbuf1, n);
@@ -783,11 +761,9 @@ int start_redo(long count, bool old_redo)
   return OK;
 }
 
-/*
- * Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
- * the redo buffer into readbuf2.
- * return FAIL for failure, OK otherwise
- */
+// Repeat the last insert (R, o, O, a, A, i or I command) by stuffing
+// the redo buffer into readbuf2.
+// return FAIL for failure, OK otherwise
 int start_redo_ins(void)
 {
   int c;
@@ -818,11 +794,9 @@ void stop_redo_ins(void)
   block_redo = false;
 }
 
-/*
- * Initialize typebuf.tb_buf to point to typebuf_init.
- * alloc() cannot be used here: In out-of-memory situations it would
- * be impossible to type anything.
- */
+// Initialize typebuf.tb_buf to point to typebuf_init.
+// alloc() cannot be used here: In out-of-memory situations it would
+// be impossible to type anything.
 static void init_typebuf(void)
 {
   if (typebuf.tb_buf == NULL) {
@@ -939,14 +913,12 @@ int ins_typebuf(char *str, int noremap, int offset, bool nottyped, bool silent)
     val = RM_NONE;
   }
 
-  /*
-   * Adjust typebuf.tb_noremap[] for the new characters:
-   * If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
-   *                    (sometimes) not remappable
-   * If noremap == REMAP_YES: all the new characters are mappable
-   * If noremap  > 0: "noremap" characters are not remappable, the rest
-   *                    mappable
-   */
+  // Adjust typebuf.tb_noremap[] for the new characters:
+  // If noremap == REMAP_NONE or REMAP_SCRIPT: new characters are
+  //                    (sometimes) not remappable
+  // If noremap == REMAP_YES: all the new characters are mappable
+  // If noremap  > 0: "noremap" characters are not remappable, the rest
+  //                    mappable
   if (noremap == REMAP_SKIP) {
     nrm = 1;
   } else if (noremap < 0) {
@@ -1016,18 +988,14 @@ int typebuf_typed(void)
   return typebuf.tb_maplen == 0;
 }
 
-/*
- * Return the number of characters that are mapped (or not typed).
- */
+// Return the number of characters that are mapped (or not typed).
 int typebuf_maplen(void)
   FUNC_ATTR_PURE
 {
   return typebuf.tb_maplen;
 }
 
-/*
- * remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
- */
+// remove "len" characters from typebuf.tb_buf[typebuf.tb_off + offset]
 void del_typebuf(int len, int offset)
 {
   int i;
@@ -1038,21 +1006,14 @@ void del_typebuf(int len, int offset)
 
   typebuf.tb_len -= len;
 
-  /*
-   * Easy case: Just increase typebuf.tb_off.
-   */
+  // Easy case: Just increase typebuf.tb_off.
   if (offset == 0 && typebuf.tb_buflen - (typebuf.tb_off + len)
       >= 3 * MAXMAPLEN + 3) {
     typebuf.tb_off += len;
-  }
-  /*
-   * Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
-   */
-  else {
+  } else {
+    // Have to move the characters in typebuf.tb_buf[] and typebuf.tb_noremap[]
     i = typebuf.tb_off + offset;
-    /*
-     * Leave some extra room at the end to avoid reallocation.
-     */
+    // Leave some extra room at the end to avoid reallocation.
     if (typebuf.tb_off > MAXMAPLEN) {
       memmove(typebuf.tb_buf + MAXMAPLEN,
               typebuf.tb_buf + typebuf.tb_off, (size_t)offset);
@@ -1101,10 +1062,8 @@ void del_typebuf(int len, int offset)
   }
 }
 
-/*
- * Write typed characters to script file.
- * If recording is on put the character in the recordbuffer.
- */
+// Write typed characters to script file.
+// If recording is on put the character in the recordbuffer.
 static void gotchars(const char_u *chars, size_t len)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -1161,14 +1120,12 @@ void ungetchars(int len)
   }
 }
 
-/*
- * Sync undo.  Called when typed characters are obtained from the typeahead
- * buffer, or when a menu is used.
- * Do not sync:
- * - In Insert mode, unless cursor key has been used.
- * - While reading a script file.
- * - When no_u_sync is non-zero.
- */
+// Sync undo.  Called when typed characters are obtained from the typeahead
+// buffer, or when a menu is used.
+// Do not sync:
+// - In Insert mode, unless cursor key has been used.
+// - While reading a script file.
+// - When no_u_sync is non-zero.
 void may_sync_undo(void)
 {
   if ((!(State & (MODE_INSERT | MODE_CMDLINE)) || arrow_used)
@@ -1177,9 +1134,7 @@ void may_sync_undo(void)
   }
 }
 
-/*
- * Make "typebuf" empty and allocate new buffers.
- */
+// Make "typebuf" empty and allocate new buffers.
 void alloc_typebuf(void)
 {
   typebuf.tb_buf = xmalloc(TYPELEN_INIT);
@@ -1195,9 +1150,7 @@ void alloc_typebuf(void)
   }
 }
 
-/*
- * Free the buffers of "typebuf".
- */
+// Free the buffers of "typebuf".
 void free_typebuf(void)
 {
   if (typebuf.tb_buf == typebuf_init) {
@@ -1212,10 +1165,8 @@ void free_typebuf(void)
   }
 }
 
-/*
- * When doing ":so! file", the current typeahead needs to be saved, and
- * restored when "file" has been read completely.
- */
+// When doing ":so! file", the current typeahead needs to be saved, and
+// restored when "file" has been read completely.
 static typebuf_T saved_typebuf[NSCRIPT];
 
 void save_typebuf(void)
@@ -1239,9 +1190,7 @@ static bool can_get_old_char(void)
   return old_char != -1 && (old_KeyStuffed || stuff_empty());
 }
 
-/*
- * Save all three kinds of typeahead, so that the user must type at a prompt.
- */
+// Save all three kinds of typeahead, so that the user must type at a prompt.
 void save_typeahead(tasave_T *tp)
 {
   tp->save_typebuf = typebuf;
@@ -1257,10 +1206,8 @@ void save_typeahead(tasave_T *tp)
   readbuf2.bh_first.b_next = NULL;
 }
 
-/*
- * Restore the typeahead to what it was before calling save_typeahead().
- * The allocated memory is freed, can only be called once!
- */
+// Restore the typeahead to what it was before calling save_typeahead().
+// The allocated memory is freed, can only be called once!
 void restore_typeahead(tasave_T *tp)
 {
   if (tp->typebuf_valid) {
@@ -1314,12 +1261,10 @@ void openscript(char *name, bool directly)
   }
   save_typebuf();
 
-  /*
-   * Execute the commands from the file right now when using ":source!"
-   * after ":global" or ":argdo" or in a loop.  Also when another command
-   * follows.  This means the display won't be updated.  Don't do this
-   * always, "make test" would fail.
-   */
+  // Execute the commands from the file right now when using ":source!"
+  // after ":global" or ":argdo" or in a loop.  Also when another command
+  // follows.  This means the display won't be updated.  Don't do this
+  // always, "make test" would fail.
   if (directly) {
     oparg_T oa;
     int oldcurscript;
@@ -1348,9 +1293,7 @@ void openscript(char *name, bool directly)
   }
 }
 
-/*
- * Close the currently active input script.
- */
+// Close the currently active input script.
 static void closescript(void)
 {
   free_typebuf();
@@ -1452,10 +1395,8 @@ int vgetc(void)
     garbage_collect(false);
   }
 
-  /*
-   * If a character was put back with vungetc, it was already processed.
-   * Return it directly.
-   */
+  // If a character was put back with vungetc, it was already processed.
+  // Return it directly.
   if (can_get_old_char()) {
     c = old_char;
     old_char = -1;
@@ -1628,11 +1569,9 @@ int vgetc(void)
     last_vgetc_recorded_len = last_recorded_len;
   }
 
-  /*
-   * In the main loop "may_garbage_collect" can be set to do garbage
-   * collection in the first next vgetc().  It's disabled after that to
-   * avoid internally used Lists and Dicts to be freed.
-   */
+  // In the main loop "may_garbage_collect" can be set to do garbage
+  // collection in the first next vgetc().  It's disabled after that to
+  // avoid internally used Lists and Dicts to be freed.
   may_garbage_collect = false;
 
   // Execute Lua on_key callbacks.
@@ -1641,10 +1580,8 @@ int vgetc(void)
   return c;
 }
 
-/*
- * Like vgetc(), but never return a NUL when called recursively, get a key
- * directly from the user (ignoring typeahead).
- */
+// Like vgetc(), but never return a NUL when called recursively, get a key
+// directly from the user (ignoring typeahead).
 int safe_vgetc(void)
 {
   int c;
@@ -1656,10 +1593,8 @@ int safe_vgetc(void)
   return c;
 }
 
-/*
- * Like safe_vgetc(), but loop to handle K_IGNORE.
- * Also ignore scrollbar events.
- */
+// Like safe_vgetc(), but loop to handle K_IGNORE.
+// Also ignore scrollbar events.
 int plain_vgetc(void)
 {
   int c;
@@ -1672,12 +1607,10 @@ int plain_vgetc(void)
   return c;
 }
 
-/*
- * Check if a character is available, such that vgetc() will not block.
- * If the next character is a special character or multi-byte, the returned
- * character is not valid!.
- * Returns NUL if no character is available.
- */
+// Check if a character is available, such that vgetc() will not block.
+// If the next character is a special character or multi-byte, the returned
+// character is not valid!.
+// Returns NUL if no character is available.
 int vpeekc(void)
 {
   if (can_get_old_char()) {
@@ -1686,11 +1619,9 @@ int vpeekc(void)
   return vgetorpeek(false);
 }
 
-/*
- * Check if any character is available, also half an escape sequence.
- * Trick: when no typeahead found, but there is something in the typeahead
- * buffer, it must be an ESC that is recognized as the start of a key code.
- */
+// Check if any character is available, also half an escape sequence.
+// Trick: when no typeahead found, but there is something in the typeahead
+// buffer, it must be an ESC that is recognized as the start of a key code.
 int vpeekc_any(void)
 {
   int c;
@@ -1702,10 +1633,8 @@ int vpeekc_any(void)
   return c;
 }
 
-/*
- * Call vpeekc() without causing anything to be mapped.
- * Return true if a character is available, false otherwise.
- */
+// Call vpeekc() without causing anything to be mapped.
+// Return true if a character is available, false otherwise.
 int char_avail(void)
 {
   int retval;
@@ -2851,11 +2780,9 @@ int inchar(char_u *buf, int maxlen, long wait_time)
     ui_flush();
   }
 
-  /*
-   * Don't reset these when at the hit-return prompt, otherwise an endless
-   * recursive loop may result (write error in swapfile, hit-return, timeout
-   * on char wait, flush swapfile, write error....).
-   */
+  // Don't reset these when at the hit-return prompt, otherwise an endless
+  // recursive loop may result (write error in swapfile, hit-return, timeout
+  // on char wait, flush swapfile, write error....).
   if (State != MODE_HITRETURN) {
     did_outofmem_msg = false;       // display out of memory message (again)
     did_swapwrite_msg = false;      // display swap file write error again
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index d7f5730943..e280648fd2 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * hardcopy.c: printing to paper
- */
+// hardcopy.c: printing to paper
 
 #include <assert.h>
 #include <inttypes.h>
@@ -36,64 +34,62 @@
 #include "nvim/version.h"
 #include "nvim/vim.h"
 
-/*
- * To implement printing on a platform, the following functions must be
- * defined:
- *
- * int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
- * Called once.  Code should display printer dialogue (if appropriate) and
- * determine printer font and margin settings.  Reset has_color if the printer
- * doesn't support colors at all.
- * Returns FAIL to abort.
- *
- * int mch_print_begin(prt_settings_T *settings)
- * Called to start the print job.
- * Return false to abort.
- *
- * int mch_print_begin_page(char_u *msg)
- * Called at the start of each page.
- * "msg" indicates the progress of the print job, can be NULL.
- * Return false to abort.
- *
- * int mch_print_end_page()
- * Called at the end of each page.
- * Return false to abort.
- *
- * int mch_print_blank_page()
- * Called to generate a blank page for collated, duplex, multiple copy
- * document.  Return false to abort.
- *
- * void mch_print_end(prt_settings_T *psettings)
- * Called at normal end of print job.
- *
- * void mch_print_cleanup()
- * Called if print job ends normally or is abandoned. Free any memory, close
- * devices and handles.  Also called when mch_print_begin() fails, but not
- * when mch_print_init() fails.
- *
- * void mch_print_set_font(int Bold, int Italic, int Underline);
- * Called whenever the font style changes.
- *
- * void mch_print_set_bg(uint32_t bgcol);
- * Called to set the background color for the following text. Parameter is an
- * RGB value.
- *
- * void mch_print_set_fg(uint32_t fgcol);
- * Called to set the foreground color for the following text. Parameter is an
- * RGB value.
- *
- * mch_print_start_line(int margin, int page_line)
- * Sets the current position at the start of line "page_line".
- * If margin is true start in the left margin (for header and line number).
- *
- * int mch_print_text_out(char_u *p, size_t len);
- * Output one character of text p[len] at the current position.
- * Return true if there is no room for another character in the same line.
- *
- * Note that the generic code has no idea of margins. The machine code should
- * simply make the page look smaller!  The header and the line numbers are
- * printed in the margin.
- */
+// To implement printing on a platform, the following functions must be
+// defined:
+//
+// int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
+// Called once.  Code should display printer dialogue (if appropriate) and
+// determine printer font and margin settings.  Reset has_color if the printer
+// doesn't support colors at all.
+// Returns FAIL to abort.
+//
+// int mch_print_begin(prt_settings_T *settings)
+// Called to start the print job.
+// Return false to abort.
+//
+// int mch_print_begin_page(char_u *msg)
+// Called at the start of each page.
+// "msg" indicates the progress of the print job, can be NULL.
+// Return false to abort.
+//
+// int mch_print_end_page()
+// Called at the end of each page.
+// Return false to abort.
+//
+// int mch_print_blank_page()
+// Called to generate a blank page for collated, duplex, multiple copy
+// document.  Return false to abort.
+//
+// void mch_print_end(prt_settings_T *psettings)
+// Called at normal end of print job.
+//
+// void mch_print_cleanup()
+// Called if print job ends normally or is abandoned. Free any memory, close
+// devices and handles.  Also called when mch_print_begin() fails, but not
+// when mch_print_init() fails.
+//
+// void mch_print_set_font(int Bold, int Italic, int Underline);
+// Called whenever the font style changes.
+//
+// void mch_print_set_bg(uint32_t bgcol);
+// Called to set the background color for the following text. Parameter is an
+// RGB value.
+//
+// void mch_print_set_fg(uint32_t fgcol);
+// Called to set the foreground color for the following text. Parameter is an
+// RGB value.
+//
+// mch_print_start_line(int margin, int page_line)
+// Sets the current position at the start of line "page_line".
+// If margin is true start in the left margin (for header and line number).
+//
+// int mch_print_text_out(char_u *p, size_t len);
+// Output one character of text p[len] at the current position.
+// Return true if there is no room for another character in the same line.
+//
+// Note that the generic code has no idea of margins. The machine code should
+// simply make the page look smaller!  The header and the line numbers are
+// printed in the margin.
 
 static option_table_T printer_opts[OPT_PRINT_NUM_OPTIONS] = {
   { "top",     true, 0, NULL, 0, false },
@@ -154,9 +150,7 @@ static option_table_T mbfont_opts[OPT_MBFONT_NUM_OPTIONS] =
   { "o",       false, 0, NULL, 0, false },
 };
 
-/*
- * These values determine the print position on a page.
- */
+// These values determine the print position on a page.
 typedef struct {
   int lead_spaces;                  // remaining spaces for a TAB
   int print_pos;                    // virtual column for computing TABs
@@ -255,33 +249,27 @@ struct prt_resfile_buffer_S {
 # include "hardcopy.c.generated.h"
 #endif
 
-/*
- * Parse 'printoptions' and set the flags in "printer_opts".
- * Returns an error message or NULL;
- */
+// Parse 'printoptions' and set the flags in "printer_opts".
+// Returns an error message or NULL;
 char *parse_printoptions(void)
 {
   return parse_list_options((char_u *)p_popt, printer_opts, OPT_PRINT_NUM_OPTIONS);
 }
 
-/*
- * Parse 'printoptions' and set the flags in "printer_opts".
- * Returns an error message or NULL;
- */
+// Parse 'printoptions' and set the flags in "printer_opts".
+// Returns an error message or NULL;
 char *parse_printmbfont(void)
 {
   return parse_list_options((char_u *)p_pmfn, mbfont_opts, OPT_MBFONT_NUM_OPTIONS);
 }
 
-/*
- * Parse a list of options in the form
- * option:value,option:value,option:value
- *
- * "value" can start with a number which is parsed out, e.g.  margin:12mm
- *
- * Returns an error message for an illegal option, NULL otherwise.
- * Only used for the printer at the moment...
- */
+// Parse a list of options in the form
+// option:value,option:value,option:value
+//
+// "value" can start with a number which is parsed out, e.g.  margin:12mm
+//
+// Returns an error message for an illegal option, NULL otherwise.
+// Only used for the printer at the moment...
 static char *parse_list_options(char_u *option_str, option_table_T *table, size_t table_size)
 {
   option_table_T *old_opts;
@@ -301,9 +289,7 @@ static char *parse_list_options(char_u *option_str, option_table_T *table, size_
     table[idx].present = false;
   }
 
-  /*
-   * Repeat for all comma separated parts.
-   */
+  // Repeat for all comma separated parts.
   stringp = option_str;
   while (*stringp) {
     colonp = (char_u *)vim_strchr((char *)stringp, ':');
@@ -361,10 +347,8 @@ static char *parse_list_options(char_u *option_str, option_table_T *table, size_
   return ret;
 }
 
-/*
- * If using a dark background, the colors will probably be too bright to show
- * up well on white paper, so reduce their brightness.
- */
+// If using a dark background, the colors will probably be too bright to show
+// up well on white paper, so reduce their brightness.
 static uint32_t darken_rgb(uint32_t rgb)
 {
   return ((rgb >> 17) << 16)
@@ -489,9 +473,7 @@ static void prt_line_number(prt_settings_T *const psettings, const int page_line
   }
 }
 
-/*
- * Get the currently effective header height.
- */
+// Get the currently effective header height.
 int prt_header_height(void)
 {
   if (printer_opts[OPT_PRINT_HEADERHEIGHT].present) {
@@ -507,10 +489,8 @@ int prt_use_number(void)
          && TOLOWER_ASC(printer_opts[OPT_PRINT_NUMBER].string[0]) == 'y';
 }
 
-/*
- * Return the unit used in a margin item in 'printoptions'.
- * Returns PRT_UNIT_NONE if not recognized.
- */
+// Return the unit used in a margin item in 'printoptions'.
+// Returns PRT_UNIT_NONE if not recognized.
 int prt_get_unit(int idx)
 {
   int u = PRT_UNIT_NONE;
@@ -546,12 +526,10 @@ static void prt_header(prt_settings_T *const psettings, const int pagenum, const
     linenr_T tmp_lnum, tmp_topline, tmp_botline;
     int use_sandbox = false;
 
-    /*
-     * Need to (temporarily) set current line number and first/last line
-     * number on the 'window'.  Since we don't know how long the page is,
-     * set the first and current line number to the top line, and guess
-     * that the page length is 64.
-     */
+    // Need to (temporarily) set current line number and first/last line
+    // number on the 'window'.  Since we don't know how long the page is,
+    // set the first and current line number to the top line, and guess
+    // that the page length is 64.
     tmp_lnum = curwin->w_cursor.lnum;
     tmp_topline = curwin->w_topline;
     tmp_botline = curwin->w_botline;
@@ -606,9 +584,7 @@ static void prt_header(prt_settings_T *const psettings, const int pagenum, const
   }
 }
 
-/*
- * Display a print status message.
- */
+// Display a print status message.
 static void prt_message(char_u *s)
 {
   // TODO(bfredl): delete this
@@ -644,13 +620,11 @@ void ex_hardcopy(exarg_T *eap)
     settings.arguments = (char_u *)eap->arg;
   }
 
-  /*
-   * Initialise for printing.  Ask the user for settings, unless forceit is
-   * set.
-   * The mch_print_init() code should set up margins if applicable. (It may
-   * not be a real printer - for example the engine might generate HTML or
-   * PS.)
-   */
+  // Initialise for printing.  Ask the user for settings, unless forceit is
+  // set.
+  // The mch_print_init() code should set up margins if applicable. (It may
+  // not be a real printer - for example the engine might generate HTML or
+  // PS.)
   if (mch_print_init(&settings,
                      curbuf->b_fname == NULL ? (char_u *)buf_spname(curbuf) : curbuf->b_sfname ==
                      NULL ? (char_u *)curbuf->b_fname : (char_u *)curbuf->b_sfname,
@@ -687,9 +661,7 @@ void ex_hardcopy(exarg_T *eap)
     prt_get_attr(id, &settings.number, settings.modec);
   }
 
-  /*
-   * Estimate the total lines to be printed
-   */
+  // Estimate the total lines to be printed
   for (lnum = eap->line1; lnum <= eap->line2; lnum++) {
     bytes_to_print += STRLEN(skipwhite((char *)ml_get(lnum)));
   }
@@ -717,9 +689,7 @@ void ex_hardcopy(exarg_T *eap)
     goto print_fail_no_begin;
   }
 
-  /*
-   * Loop over collated copies: 1 2 3, 1 2 3, ...
-   */
+  // Loop over collated copies: 1 2 3, 1 2 3, ...
   page_count = 0;
   for (collated_copies = 0;
        collated_copies < settings.n_collated_copies;
@@ -740,9 +710,7 @@ void ex_hardcopy(exarg_T *eap)
       }
     }
 
-    /*
-     * Loop over all pages in the print job: 1 2 3 ...
-     */
+    // Loop over all pages in the print job: 1 2 3 ...
     for (page_count = 0; prtpos.file_line <= eap->line2; page_count++) {
       // Loop over uncollated copies: 1 1 1, 2 2 2, 3 3 3, ...
       // For duplex: 12 12 12 34 34 34, ...
@@ -752,9 +720,7 @@ void ex_hardcopy(exarg_T *eap)
         // Set the print position to the start of this page.
         prtpos = page_prtpos;
 
-        /*
-         * Do front and rear side of a page.
-         */
+        // Do front and rear side of a page.
         for (side = 0; side <= settings.duplex; side++) {
           // Print one page.
 
@@ -780,9 +746,7 @@ void ex_hardcopy(exarg_T *eap)
           }
           prt_message(IObuff);
 
-          /*
-           * Output header if required
-           */
+          // Output header if required
           if (prt_header_height() > 0) {
             prt_header(&settings, page_count + 1 + side,
                        prtpos.file_line);
@@ -814,10 +778,8 @@ void ex_hardcopy(exarg_T *eap)
           }
         }
 
-        /*
-         * Extra blank page for duplexing with odd number of pages and
-         * more copies to come.
-         */
+        // Extra blank page for duplexing with odd number of pages and
+        // more copies to come.
         if (prtpos.file_line > eap->line2 && settings.duplex
             && side == 0
             && uncollated_copies + 1 < settings.n_uncollated_copies) {
@@ -850,10 +812,8 @@ print_fail_no_begin:
   mch_print_cleanup();
 }
 
-/*
- * Print one page line.
- * Return the next column to print, or zero if the line is finished.
- */
+// Print one page line.
+// Return the next column to print, or zero if the line is finished.
 static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T *ppos)
 {
   colnr_T col;
@@ -881,9 +841,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
   mch_print_start_line(false, page_line);
   line = (char_u *)ml_get(ppos->file_line);
 
-  /*
-   * Loop over the columns until the end of the file line or right margin.
-   */
+  // Loop over the columns until the end of the file line or right margin.
   for (col = ppos->column; line[col] != NUL && !need_break; col += outputlen) {
     if ((outputlen = utfc_ptr2len((char *)line + col)) < 1) {
       outputlen = 1;
@@ -908,9 +866,7 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
       }
     }
 
-    /*
-     * Appropriately expand any tabs to spaces.
-     */
+    // Appropriately expand any tabs to spaces.
     if (line[col] == TAB || tab_spaces != 0) {
       if (tab_spaces == 0) {
         tab_spaces = tabstop_padding(print_pos,
@@ -945,10 +901,8 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
   ppos->lead_spaces = tab_spaces;
   ppos->print_pos = print_pos;
 
-  /*
-   * Start next line of file if we clip lines, or have reached end of the
-   * line, unless we are doing a formfeed.
-   */
+  // Start next line of file if we clip lines, or have reached end of the
+  // line, unless we are doing a formfeed.
   if (!ppos->ff
       && (line[col] == NUL
           || (printer_opts[OPT_PRINT_WRAP].present
@@ -959,34 +913,32 @@ static colnr_T hardcopy_line(prt_settings_T *psettings, int page_line, prt_pos_T
   return col;
 }
 
-/*
- * PS printer stuff.
- *
- * Sources of information to help maintain the PS printing code:
- *
- * 1. PostScript Language Reference, 3rd Edition,
- *      Addison-Wesley, 1999, ISBN 0-201-37922-8
- * 2. PostScript Language Program Design,
- *      Addison-Wesley, 1988, ISBN 0-201-14396-8
- * 3. PostScript Tutorial and Cookbook,
- *      Addison Wesley, 1985, ISBN 0-201-10179-3
- * 4. PostScript Language Document Structuring Conventions Specification,
- *    version 3.0,
- *      Adobe Technote 5001, 25th September 1992
- * 5. PostScript Printer Description File Format Specification, Version 4.3,
- *      Adobe technote 5003, 9th February 1996
- * 6. Adobe Font Metrics File Format Specification, Version 4.1,
- *      Adobe Technote 5007, 7th October 1998
- * 7. Adobe CMap and CIDFont Files Specification, Version 1.0,
- *      Adobe Technote 5014, 8th October 1996
- * 8. Adobe CJKV Character Collections and CMaps for CID-Keyed Fonts,
- *      Adoboe Technote 5094, 8th September, 2001
- * 9. CJKV Information Processing, 2nd Edition,
- *      O'Reilly, 2002, ISBN 1-56592-224-7
- *
- * Some of these documents can be found in PDF form on Adobe's web site -
- * http://www.adobe.com
- */
+// PS printer stuff.
+//
+// Sources of information to help maintain the PS printing code:
+//
+// 1. PostScript Language Reference, 3rd Edition,
+//      Addison-Wesley, 1999, ISBN 0-201-37922-8
+// 2. PostScript Language Program Design,
+//      Addison-Wesley, 1988, ISBN 0-201-14396-8
+// 3. PostScript Tutorial and Cookbook,
+//      Addison Wesley, 1985, ISBN 0-201-10179-3
+// 4. PostScript Language Document Structuring Conventions Specification,
+//    version 3.0,
+//      Adobe Technote 5001, 25th September 1992
+// 5. PostScript Printer Description File Format Specification, Version 4.3,
+//      Adobe technote 5003, 9th February 1996
+// 6. Adobe Font Metrics File Format Specification, Version 4.1,
+//      Adobe Technote 5007, 7th October 1998
+// 7. Adobe CMap and CIDFont Files Specification, Version 1.0,
+//      Adobe Technote 5014, 8th October 1996
+// 8. Adobe CJKV Character Collections and CMaps for CID-Keyed Fonts,
+//      Adoboe Technote 5094, 8th September, 2001
+// 9. CJKV Information Processing, 2nd Edition,
+//      O'Reilly, 2002, ISBN 1-56592-224-7
+//
+// Some of these documents can be found in PDF form on Adobe's web site -
+// http://www.adobe.com
 
 #define PRT_PS_DEFAULT_DPI          (72)    // Default user space resolution
 #define PRT_PS_DEFAULT_FONTSIZE     (10)
@@ -1251,17 +1203,13 @@ static struct prt_dsc_comment_S prt_dsc_table[] =
     PRT_DSC_ENDCOMMENTS_TYPE }
 };
 
-/*
- * Variables for the output PostScript file.
- */
+// Variables for the output PostScript file.
 static FILE *prt_ps_fd;
 static bool prt_file_error;
 static char_u *prt_ps_file_name = NULL;
 
-/*
- * Various offsets and dimensions in default PostScript user space (points).
- * Used for text positioning calculations
- */
+// Various offsets and dimensions in default PostScript user space (points).
+// Used for text positioning calculations
 static double prt_page_width;
 static double prt_page_height;
 static double prt_left_margin;
@@ -1276,10 +1224,8 @@ static double prt_bgcol_offset;
 static double prt_pos_x_moveto = 0.0;
 static double prt_pos_y_moveto = 0.0;
 
-/*
- * Various control variables used to decide when and how to change the
- * PostScript graphics state.
- */
+// Various control variables used to decide when and how to change the
+// PostScript graphics state.
 static bool prt_need_moveto;
 static bool prt_do_moveto;
 static bool prt_need_font;
@@ -1298,9 +1244,7 @@ static double prt_text_run;
 static int prt_page_num;
 static int prt_bufsiz;
 
-/*
- * Variables controlling physical printing.
- */
+// Variables controlling physical printing.
 static int prt_media;
 static int prt_portrait;
 static int prt_num_copies;
@@ -1308,9 +1252,7 @@ static int prt_duplex;
 static int prt_tumble;
 static int prt_collate;
 
-/*
- * Buffers used when generating PostScript output
- */
+// Buffers used when generating PostScript output
 static char prt_line_buffer[257];
 static garray_T prt_ps_buffer = GA_EMPTY_INIT_VALUE;
 
@@ -1345,36 +1287,28 @@ static void prt_write_file_len(char_u *buffer, size_t bytes)
   prt_write_file_raw_len(buffer, bytes);
 }
 
-/*
- * Write a string.
- */
+// Write a string.
 static void prt_write_string(char *s)
 {
   vim_snprintf(prt_line_buffer, sizeof(prt_line_buffer), "%s", s);
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write an int and a space.
- */
+// Write an int and a space.
 static void prt_write_int(int i)
 {
   snprintf(prt_line_buffer, sizeof(prt_line_buffer), "%d ", i);
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write a boolean and a space.
- */
+// Write a boolean and a space.
 static void prt_write_boolean(int b)
 {
   snprintf(prt_line_buffer, sizeof(prt_line_buffer), "%s ", (b ? "T" : "F"));
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write PostScript to re-encode and define the font.
- */
+// Write PostScript to re-encode and define the font.
 static void prt_def_font(char *new_name, char *encoding, int height, char *font)
 {
   vim_snprintf(prt_line_buffer, sizeof(prt_line_buffer),
@@ -1390,9 +1324,7 @@ static void prt_def_font(char *new_name, char *encoding, int height, char *font)
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write a line to define the CID font.
- */
+// Write a line to define the CID font.
 static void prt_def_cidfont(char *new_name, int height, char *cidfont)
 {
   vim_snprintf(prt_line_buffer, sizeof(prt_line_buffer),
@@ -1403,9 +1335,7 @@ static void prt_def_cidfont(char *new_name, int height, char *cidfont)
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write a line to define a duplicate of a CID font
- */
+// Write a line to define a duplicate of a CID font
 static void prt_dup_cidfont(char *original_name, char *new_name)
 {
   vim_snprintf(prt_line_buffer, sizeof(prt_line_buffer),
@@ -1413,11 +1343,9 @@ static void prt_dup_cidfont(char *original_name, char *new_name)
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Convert a real value into an integer and fractional part as integers, with
- * the fractional part being in the range [0,10^precision).  The fractional part
- * is also rounded based on the precision + 1'th fractional digit.
- */
+// Convert a real value into an integer and fractional part as integers, with
+// the fractional part being in the range [0,10^precision).  The fractional part
+// is also rounded based on the precision + 1'th fractional digit.
 static void prt_real_bits(double real, int precision, int *pinteger, int *pfraction)
 {
   int integer = (int)real;
@@ -1433,11 +1361,9 @@ static void prt_real_bits(double real, int precision, int *pinteger, int *pfract
   *pfraction = (int)(fraction + 0.5);
 }
 
-/*
- * Write a real and a space.  Save bytes if real value has no fractional part!
- * We use prt_real_bits() as %f in sprintf uses the locale setting to decide
- * what decimal point character to use, but PS always requires a '.'.
- */
+// Write a real and a space.  Save bytes if real value has no fractional part!
+// We use prt_real_bits() as %f in sprintf uses the locale setting to decide
+// what decimal point character to use, but PS always requires a '.'.
 static void prt_write_real(double val, int prec)
 {
   int integer;
@@ -1463,9 +1389,7 @@ static void prt_write_real(double val, int prec)
   prt_write_file(prt_line_buffer);
 }
 
-/*
- * Write a line to define a numeric variable.
- */
+// Write a line to define a numeric variable.
 static void prt_def_var(char *name, double value, int prec)
 {
   vim_snprintf(prt_line_buffer, sizeof(prt_line_buffer),
@@ -2020,9 +1944,7 @@ static double to_device_units(int idx, double physsize, int def_number)
   return ret;
 }
 
-/*
- * Calculate margins for given width and height from printoptions settings.
- */
+// Calculate margins for given width and height from printoptions settings.
 static void prt_page_margins(double width, double height, double *left, double *right, double *top,
                              double *bottom)
 {
@@ -2062,18 +1984,14 @@ static void prt_build_cid_fontname(int font, char_u *name, int name_len)
   prt_ps_mb_font.ps_fontname[font] = fontname;
 }
 
-/*
- * Get number of lines of text that fit on a page (excluding the header).
- */
+// Get number of lines of text that fit on a page (excluding the header).
 static int prt_get_lpp(void)
 {
   int lpp;
 
-  /*
-   * Calculate offset to lower left corner of background rect based on actual
-   * font height (based on its bounding box) and the line height, handling the
-   * case where the font height can exceed the line height.
-   */
+  // Calculate offset to lower left corner of background rect based on actual
+  // font height (based on its bounding box) and the line height, handling the
+  // case where the font height can exceed the line height.
   prt_bgcol_offset = PRT_PS_FONT_TO_USER(prt_line_height,
                                          prt_ps_font->bbox_min_y);
   if ((prt_ps_font->bbox_max_y - prt_ps_font->bbox_min_y) < 1000.0) {
@@ -2270,9 +2188,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
     prt_ps_font = &prt_ps_courier_font;
   }
 
-  /*
-   * Find the size of the paper and set the margins.
-   */
+  // Find the size of the paper and set the margins.
   prt_portrait = (!printer_opts[OPT_PRINT_PORTRAIT].present
                   || TOLOWER_ASC(printer_opts[OPT_PRINT_PORTRAIT].string[0]) ==
                   'y');
@@ -2295,13 +2211,11 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
   }
   prt_media = i;
 
-  /*
-   * Set PS pagesize based on media dimensions and print orientation.
-   * Note: Media and page sizes have defined meanings in PostScript and should
-   * be kept distinct.  Media is the paper (or transparency, or ...) that is
-   * printed on, whereas the page size is the area that the PostScript
-   * interpreter renders into.
-   */
+  // Set PS pagesize based on media dimensions and print orientation.
+  // Note: Media and page sizes have defined meanings in PostScript and should
+  // be kept distinct.  Media is the paper (or transparency, or ...) that is
+  // printed on, whereas the page size is the area that the PostScript
+  // interpreter renders into.
   if (prt_portrait) {
     prt_page_width = prt_mediasize[i].width;
     prt_page_height = prt_mediasize[i].height;
@@ -2320,9 +2234,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
   prt_top_margin = top;
   prt_bottom_margin = bottom;
 
-  /*
-   * Set up the font size.
-   */
+  // Set up the font size.
   fontsize = PRT_PS_DEFAULT_FONTSIZE;
   for (p = (char_u *)p_pfn; (p = (char_u *)vim_strchr((char *)p, ':')) != NULL; p++) {
     if (p[1] == 'h' && ascii_isdigit(p[2])) {
@@ -2331,10 +2243,8 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
   }
   prt_font_metrics(fontsize);
 
-  /*
-   * Return the number of characters per line, and lines per page for the
-   * generic print code.
-   */
+  // Return the number of characters per line, and lines per page for the
+  // generic print code.
   psettings->chars_per_line = prt_get_cpl();
   psettings->lines_per_page = prt_get_lpp();
 
@@ -2343,12 +2253,10 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
     return FAIL;
   }
 
-  /*
-   * Sort out the number of copies to be printed.  PS by default will do
-   * uncollated copies for you, so once we know how many uncollated copies are
-   * wanted cache it away and lie to the generic code that we only want one
-   * uncollated copy.
-   */
+  // Sort out the number of copies to be printed.  PS by default will do
+  // uncollated copies for you, so once we know how many uncollated copies are
+  // wanted cache it away and lie to the generic code that we only want one
+  // uncollated copy.
   psettings->n_collated_copies = 1;
   psettings->n_uncollated_copies = 1;
   prt_num_copies = 1;
@@ -2364,10 +2272,8 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
 
   psettings->jobname = jobname;
 
-  /*
-   * Set up printer duplex and tumble based on Duplex option setting - default
-   * is long sided duplex printing (i.e. no tumble).
-   */
+  // Set up printer duplex and tumble based on Duplex option setting - default
+  // is long sided duplex printing (i.e. no tumble).
   prt_duplex = true;
   prt_tumble = false;
   psettings->duplex = 1;
@@ -2491,9 +2397,7 @@ bool mch_print_begin(prt_settings_T *psettings)
   struct prt_ps_resource_S res_cidfont;
   struct prt_ps_resource_S res_cmap;
 
-  /*
-   * PS DSC Header comments - no PS code!
-   */
+  // PS DSC Header comments - no PS code!
   prt_dsc_start();
   prt_dsc_textline("Title", (char *)psettings->jobname);
   if (os_get_username(buffer, 256) == FAIL) {
@@ -2685,9 +2589,7 @@ bool mch_print_begin(prt_settings_T *psettings)
                        prt_num_copies);
   prt_dsc_noarg("EndComments");
 
-  /*
-   * PS Document page defaults
-   */
+  // PS Document page defaults
   prt_dsc_noarg("BeginDefaults");
 
   // List font resources most likely common to all pages
@@ -2707,9 +2609,7 @@ bool mch_print_begin(prt_settings_T *psettings)
 
   prt_dsc_noarg("EndDefaults");
 
-  /*
-   * PS Document prolog inclusion - all required procsets.
-   */
+  // PS Document prolog inclusion - all required procsets.
   prt_dsc_noarg("BeginProlog");
 
   // Add required procsets - NOTE: order is important!
@@ -2736,9 +2636,7 @@ bool mch_print_begin(prt_settings_T *psettings)
 
   prt_dsc_noarg("EndProlog");
 
-  /*
-   * PS Document setup - must appear after the prolog
-   */
+  // PS Document setup - must appear after the prolog
   prt_dsc_noarg("BeginSetup");
 
   // Device setup - page size and number of uncollated copies
@@ -2847,9 +2745,7 @@ void mch_print_end(prt_settings_T *psettings)
 {
   prt_dsc_noarg("Trailer");
 
-  /*
-   * Output any info we don't know in toto until we finish
-   */
+  // Output any info we don't know in toto until we finish
   prt_dsc_ints("Pages", 1, &prt_page_num);
 
   prt_dsc_noarg("EOF");
diff --git a/src/nvim/hardcopy.h b/src/nvim/hardcopy.h
index 9ef4eb0074..ce562cd3e6 100644
--- a/src/nvim/hardcopy.h
+++ b/src/nvim/hardcopy.h
@@ -8,9 +8,7 @@
 #include "nvim/globals.h"  // for TriState
 #include "nvim/types.h"  // for char_u
 
-/*
- * Structure to hold printing color and font attributes.
- */
+// Structure to hold printing color and font attributes.
 typedef struct {
   uint32_t fg_color;
   uint32_t bg_color;
@@ -23,9 +21,7 @@ typedef struct {
   int underdashed;
 } prt_text_attr_T;
 
-/*
- * Structure passed back to the generic printer code.
- */
+// Structure passed back to the generic printer code.
 typedef struct {
   int n_collated_copies;
   int n_uncollated_copies;
@@ -42,9 +38,7 @@ typedef struct {
   char_u *arguments;
 } prt_settings_T;
 
-/*
- * Generic option table item, only used for printer at the moment.
- */
+// Generic option table item, only used for printer at the moment.
 typedef struct {
   const char *name;
   int hasnum;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index e54bffb587..85534ebcff 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -1,13 +1,11 @@
 // 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
 
-/*
- * CSCOPE support for Vim added by Andy Kahn <kahn@zk3.dec.com>
- * Ported to Win32 by Sergey Khorev <sergey.khorev@gmail.com>
- *
- * The basic idea/structure of cscope for Vim was borrowed from Nvi.  There
- * might be a few lines of code that look similar to what Nvi has.
- */
+// CSCOPE support for Vim added by Andy Kahn <kahn@zk3.dec.com>
+// Ported to Win32 by Sergey Khorev <sergey.khorev@gmail.com>
+//
+// The basic idea/structure of cscope for Vim was borrowed from Nvi.  There
+// might be a few lines of code that look similar to what Nvi has.
 
 #include <assert.h>
 #include <errno.h>
@@ -78,10 +76,8 @@ static enum {
   EXP_CSCOPE_KILL,  // expand ":cscope kill" arguments
 } expand_what;
 
-/*
- * Function given to ExpandGeneric() to obtain the cscope command
- * expansion.
- */
+// Function given to ExpandGeneric() to obtain the cscope command
+// expansion.
 char *get_cscope_name(expand_T *xp, int idx)
 {
   int current_idx;
@@ -140,9 +136,7 @@ char *get_cscope_name(expand_T *xp, int idx)
   }
 }
 
-/*
- * Handle command line completion for :cscope command.
- */
+// Handle command line completion for :cscope command.
 void set_context_in_cscope_cmd(expand_T *xp, const char *arg, cmdidx_T cmdidx)
 {
   // Default: expand subcommands.
@@ -304,33 +298,31 @@ void cs_print_tags(void)
   cs_manage_matches(NULL, NULL, 0, Print);
 }
 
-/*
- * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
- *
- *              Checks for the existence of a |cscope| connection.  If no
- *              parameters are specified, then the function returns:
- *
- *              0, if cscope was not available (not compiled in), or if there
- *              are no cscope connections; or
- *              1, if there is at least one cscope connection.
- *
- *              If parameters are specified, then the value of {num}
- *              determines how existence of a cscope connection is checked:
- *
- *              {num}   Description of existence check
- *              -----   ------------------------------
- *              0       Same as no parameters (e.g., "cscope_connection()").
- *              1       Ignore {prepend}, and use partial string matches for
- *                      {dbpath}.
- *              2       Ignore {prepend}, and use exact string matches for
- *                      {dbpath}.
- *              3       Use {prepend}, use partial string matches for both
- *                      {dbpath} and {prepend}.
- *              4       Use {prepend}, use exact string matches for both
- *                      {dbpath} and {prepend}.
- *
- *              Note: All string comparisons are case sensitive!
- */
+// "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
+//
+//              Checks for the existence of a |cscope| connection.  If no
+//              parameters are specified, then the function returns:
+//
+//              0, if cscope was not available (not compiled in), or if there
+//              are no cscope connections; or
+//              1, if there is at least one cscope connection.
+//
+//              If parameters are specified, then the value of {num}
+//              determines how existence of a cscope connection is checked:
+//
+//              {num}   Description of existence check
+//              -----   ------------------------------
+//              0       Same as no parameters (e.g., "cscope_connection()").
+//              1       Ignore {prepend}, and use partial string matches for
+//                      {dbpath}.
+//              2       Ignore {prepend}, and use exact string matches for
+//                      {dbpath}.
+//              3       Use {prepend}, use partial string matches for both
+//                      {dbpath} and {prepend}.
+//              4       Use {prepend}, use exact string matches for both
+//                      {dbpath} and {prepend}.
+//
+//              Note: All string comparisons are case sensitive!
 bool cs_connection(int num, char_u *dbpath, char_u *ppath)
 {
   if (num < 0 || num > 4 || (num > 0 && !dbpath)) {
@@ -379,9 +371,8 @@ bool cs_connection(int num, char_u *dbpath, char_u *ppath)
   return false;
 }  // cs_connection
 
-/*
- * PRIVATE functions
- ****************************************************************************/
+// PRIVATE functions
+// **************************************************************************
 
 /// Add cscope database or a directory name (to look for cscope.out)
 /// to the cscope connection list.
@@ -684,10 +675,8 @@ static int cs_create_connection(size_t i)
   char *prog, *cmd, *ppath = NULL;
 
 #if defined(UNIX)
-  /*
-   * Cscope reads from to_cs[0] and writes to from_cs[1]; vi reads from
-   * from_cs[0] and writes to to_cs[1].
-   */
+  // Cscope reads from to_cs[0] and writes to from_cs[1]; vi reads from
+  // from_cs[0] and writes to to_cs[1].
   to_cs[0] = to_cs[1] = from_cs[0] = from_cs[1] = -1;
   if (pipe(to_cs) < 0 || pipe(from_cs) < 0) {
     (void)emsg(_("E566: Could not create cscope pipes"));
@@ -896,10 +885,8 @@ static int cs_find(exarg_T *eap)
     return false;
   }
 
-  /*
-   * Let's replace the NULs written by strtok() with spaces - we need the
-   * spaces to correctly display the quickfix/location list window's title.
-   */
+  // Let's replace the NULs written by strtok() with spaces - we need the
+  // spaces to correctly display the quickfix/location list window's title.
   for (int i = 0; i < eap_arg_len; i++) {
     if (NUL == eap->arg[i]) {
       eap->arg[i] = ' ';
@@ -1041,10 +1028,8 @@ static bool cs_find_common(char *opt, char *pat, int forceit, int verbose, bool
 
         apply_autocmds(EVENT_QUICKFIXCMDPOST, "cscope", curbuf->b_fname, true, curbuf);
         if (use_ll) {
-          /*
-           * In the location list window, use the displayed location
-           * list. Otherwise, use the location list for the window.
-           */
+          // In the location list window, use the displayed location
+          // list. Otherwise, use the location list for the window.
           qi = (bt_quickfix(wp->w_buffer) && wp->w_llist_ref != NULL)
                ?  wp->w_llist_ref : wp->w_llist;
         }
@@ -1431,11 +1416,9 @@ retry:
   }
   *p = '\0';
 
-  /*
-   * cscope output is in the following format:
-   *
-   *    <filename> <context> <line number> <pattern>
-   */
+  // cscope output is in the following format:
+  //
+  //    <filename> <context> <line number> <pattern>
   char *saveptr = NULL;
   if ((name = os_strtok(buf, (const char *)" ", &saveptr)) == NULL) {
     return NULL;
@@ -1786,9 +1769,7 @@ static int cs_read_prompt(size_t i)
 }
 
 #if defined(UNIX) && defined(SIGALRM)
-/*
- * Used to catch and ignore SIGALRM below.
- */
+// Used to catch and ignore SIGALRM below.
 static void sig_handler(int s)
 {
   // do nothing
@@ -1847,25 +1828,21 @@ static void cs_release_csp(size_t i, bool freefnpp)
       os_delay(50L, false);       // sleep 50 ms
     }
 # endif
-    /*
-     * If the cscope process is still running: kill it.
-     * Safety check: If the PID would be zero here, the entire X session
-     * would be killed.  -1 and 1 are dangerous as well.
-     */
+    // If the cscope process is still running: kill it.
+    // Safety check: If the PID would be zero here, the entire X session
+    // would be killed.  -1 and 1 are dangerous as well.
     if (pid < 0 && csinfo[i].pid > 1) {
 # ifdef ECHILD
       bool alive = true;
 
       if (waitpid_errno == ECHILD) {
-        /*
-         * When using 'vim -g', vim is forked and cscope process is
-         * no longer a child process but a sibling.  So waitpid()
-         * fails with errno being ECHILD (No child processes).
-         * Don't send SIGKILL to cscope immediately but wait
-         * (polling) for it to exit normally as result of sending
-         * the "q" command, hence giving it a chance to clean up
-         * its temporary files.
-         */
+        // When using 'vim -g', vim is forked and cscope process is
+        // no longer a child process but a sibling.  So waitpid()
+        // fails with errno being ECHILD (No child processes).
+        // Don't send SIGKILL to cscope immediately but wait
+        // (polling) for it to exit normally as result of sending
+        // the "q" command, hence giving it a chance to clean up
+        // its temporary files.
         int waited;
 
         sleep(0);
@@ -1974,11 +1951,9 @@ static char *cs_resolve_file(size_t i, char *name)
   char *fullname;
   char_u *csdir = NULL;
 
-  /*
-   * Ppath is freed when we destroy the cscope connection.
-   * Fullname is freed after cs_make_vim_style_matches, after it's been
-   * copied into the tag buffer used by Vim.
-   */
+  // Ppath is freed when we destroy the cscope connection.
+  // Fullname is freed after cs_make_vim_style_matches, after it's been
+  // copied into the tag buffer used by Vim.
   size_t len = strlen(name) + 2;
   if (csinfo[i].ppath != NULL) {
     len += strlen(csinfo[i].ppath);
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 7dcc9e3c27..5941473825 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -27,11 +27,9 @@ typedef struct {
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "indent_c.c.generated.h"
 #endif
-/*
- * Find the start of a comment, not knowing if we are in a comment right now.
- * Search starts at w_cursor.lnum and goes backwards.
- * Return NULL when not inside a comment.
- */
+// Find the start of a comment, not knowing if we are in a comment right now.
+// Search starts at w_cursor.lnum and goes backwards.
+// Return NULL when not inside a comment.
 static pos_T *ind_find_start_comment(void)  // XXX
 {
   return find_start_comment(curbuf->b_ind_maxcomment);
@@ -48,10 +46,8 @@ pos_T *find_start_comment(int ind_maxcomment)  // XXX
       break;
     }
 
-    /*
-     * Check if the comment start we found is inside a string.
-     * If it is then restrict the search to below this line and try again.
-     */
+    // Check if the comment start we found is inside a string.
+    // If it is then restrict the search to below this line and try again.
     if (!is_pos_in_string((char_u *)ml_get(pos->lnum), pos->col)) {
       break;
     }
@@ -97,11 +93,9 @@ static pos_T *ind_find_start_CORS(linenr_T *is_raw)
   return comment_pos;
 }
 
-/*
- * Find the start of a raw string, not knowing if we are in one right now.
- * Search starts at w_cursor.lnum and goes backwards.
- * Return NULL when not inside a raw string.
- */
+// Find the start of a raw string, not knowing if we are in one right now.
+// Search starts at w_cursor.lnum and goes backwards.
+// Return NULL when not inside a raw string.
 static pos_T *find_start_rawstring(int ind_maxcomment)  // XXX
 {
   pos_T *pos;
@@ -127,17 +121,13 @@ static pos_T *find_start_rawstring(int ind_maxcomment)  // XXX
   return pos;
 }
 
-/*
- * Skip to the end of a "string" and a 'c' character.
- * If there is no string or character, return argument unmodified.
- */
+// Skip to the end of a "string" and a 'c' character.
+// If there is no string or character, return argument unmodified.
 static const char_u *skip_string(const char_u *p)
 {
   int i;
 
-  /*
-   * We loop, because strings may be concatenated: "date""time".
-   */
+  // We loop, because strings may be concatenated: "date""time".
   for (;; p++) {
     if (p[0] == '\'') {                     // 'c' or '\n' or '\000'
       if (p[1] == NUL) {                    // ' at end of line
@@ -204,13 +194,10 @@ int is_pos_in_string(const char_u *line, colnr_T col)
   return !((colnr_T)(p - line) <= col);
 }
 
-/*
- * Functions for C-indenting.
- * Most of this originally comes from Eric Fischer.
- */
-/*
- * Below "XXX" means that this function may unlock the current line.
- */
+// Functions for C-indenting.
+// Most of this originally comes from Eric Fischer.
+
+// Below "XXX" means that this function may unlock the current line.
 
 /// @return  true if the string "line" starts with a word from 'cinwords'.
 bool cin_is_cinword(const char *line)
@@ -235,10 +222,8 @@ bool cin_is_cinword(const char *line)
   return retval;
 }
 
-/*
- * Skip over white space and C comments within the line.
- * Also skip over Perl/shell comments if desired.
- */
+// Skip over white space and C comments within the line.
+// Also skip over Perl/shell comments if desired.
 static const char_u *cin_skipcomment(const char_u *s)
 {
   while (*s) {
@@ -246,8 +231,8 @@ static const char_u *cin_skipcomment(const char_u *s)
 
     s = (char_u *)skipwhite((char *)s);
 
-    /* Perl/shell # comment comment continues until eol.  Require a space
-     * before # to avoid recognizing $#array. */
+    // Perl/shell # comment comment continues until eol.  Require a space
+    // before # to avoid recognizing $#array.
     if (curbuf->b_ind_hash_comment != 0 && s != prev_s && *s == '#') {
       s += STRLEN(s);
       break;
@@ -280,9 +265,7 @@ static int cin_nocode(const char_u *s)
   return *cin_skipcomment(s) == NUL;
 }
 
-/*
- * Check previous lines for a "//" line comment, skipping over blank lines.
- */
+// Check previous lines for a "//" line comment, skipping over blank lines.
 static pos_T *find_line_comment(void)  // XXX
 {
   static pos_T pos;
@@ -369,10 +352,8 @@ bool cin_islabel(void)  // XXX
     return false;
   }
 
-  /*
-   * Only accept a label if the previous line is terminated or is a case
-   * label.
-   */
+  // Only accept a label if the previous line is terminated or is a case
+  // label.
   pos_T cursor_save;
   pos_T *trypos;
   const char_u *line;
@@ -381,10 +362,8 @@ bool cin_islabel(void)  // XXX
   while (curwin->w_cursor.lnum > 1) {
     curwin->w_cursor.lnum--;
 
-    /*
-     * If we're in a comment or raw string now, skip to the start of
-     * it.
-     */
+    // If we're in a comment or raw string now, skip to the start of
+    // it.
     curwin->w_cursor.col = 0;
     if ((trypos = ind_find_start_CORS(NULL)) != NULL) {   // XXX
       curwin->w_cursor = *trypos;
@@ -411,11 +390,9 @@ bool cin_islabel(void)  // XXX
   return true;  // label at start of file???
 }
 
-/*
- * Recognize structure initialization and enumerations:
- * "[typedef] [static|public|protected|private] enum"
- * "[typedef] [static|public|protected|private] = {"
- */
+// Recognize structure initialization and enumerations:
+// "[typedef] [static|public|protected|private] enum"
+// "[typedef] [static|public|protected|private] = {"
 static int cin_isinit(void)
 {
   const char_u *s;
@@ -495,9 +472,7 @@ bool cin_iscase(const char_u *s, bool strict)
   return false;
 }
 
-/*
- * Recognize a "default" switch label.
- */
+// Recognize a "default" switch label.
 static int cin_isdefault(const char_u *s)
 {
   return STRNCMP(s, "default", 7) == 0
@@ -576,12 +551,10 @@ static bool cin_is_cpp_namespace(const char_u *s)
   return false;
 }
 
-/*
- * Return a pointer to the first non-empty non-comment character after a ':'.
- * Return NULL if not found.
- *        case 234:    a = b;
- *                     ^
- */
+// Return a pointer to the first non-empty non-comment character after a ':'.
+// Return NULL if not found.
+//        case 234:    a = b;
+//                     ^
 static const char_u *after_label(const char_u *l)
 {
   for (; *l; l++) {
@@ -605,10 +578,8 @@ static const char_u *after_label(const char_u *l)
   return l;
 }
 
-/*
- * Get indent of line "lnum", skipping a label.
- * Return 0 if there is nothing after the label.
- */
+// Get indent of line "lnum", skipping a label.
+// Return 0 if there is nothing after the label.
 static int get_indent_nolabel(linenr_T lnum)  // XXX
 {
   const char_u *l;
@@ -628,12 +599,10 @@ static int get_indent_nolabel(linenr_T lnum)  // XXX
   return (int)col;
 }
 
-/*
- * Find indent for line "lnum", ignoring any case or jump label.
- * Also return a pointer to the text (after the label) in "pp".
- *   label:     if (asdf && asdfasdf)
- *              ^
- */
+// Find indent for line "lnum", ignoring any case or jump label.
+// Also return a pointer to the text (after the label) in "pp".
+//   label:     if (asdf && asdfasdf)
+//              ^
 static int skip_label(linenr_T lnum, const char_u **pp)
 {
   const char_u *l;
@@ -660,13 +629,11 @@ static int skip_label(linenr_T lnum, const char_u **pp)
   return amount;
 }
 
-/*
- * Return the indent of the first variable name after a type in a declaration.
- *  int     a,                  indent of "a"
- *  static struct foo    b,     indent of "b"
- *  enum bla    c,              indent of "c"
- * Returns zero when it doesn't look like a declaration.
- */
+// Return the indent of the first variable name after a type in a declaration.
+//  int     a,                  indent of "a"
+//  static struct foo    b,     indent of "b"
+//  enum bla    c,              indent of "c"
+// Returns zero when it doesn't look like a declaration.
 static int cin_first_id_amount(void)
 {
   char_u *line, *p, *s;
@@ -707,15 +674,13 @@ static int cin_first_id_amount(void)
   return (int)col;
 }
 
-/*
- * Return the indent of the first non-blank after an equal sign.
- *       char *foo = "here";
- * Return zero if no (useful) equal sign found.
- * Return -1 if the line above "lnum" ends in a backslash.
- *      foo = "asdf\
- *             asdf\
- *             here";
- */
+// Return the indent of the first non-blank after an equal sign.
+//       char *foo = "here";
+// Return zero if no (useful) equal sign found.
+// Return -1 if the line above "lnum" ends in a backslash.
+//      foo = "asdf{backslash}
+//             asdf{backslash}
+//             here";
 static int cin_get_equal_amount(linenr_T lnum)
 {
   const char_u *line;
@@ -758,9 +723,7 @@ static int cin_get_equal_amount(linenr_T lnum)
   return (int)col;
 }
 
-/*
- * Recognize a preprocessor statement: Any line that starts with '#'.
- */
+// Recognize a preprocessor statement: Any line that starts with '#'.
 static int cin_ispreproc(const char_u *s)
 {
   if (*skipwhite((char *)s) == '#') {
@@ -808,17 +771,13 @@ static int cin_ispreproc_cont(const char_u **pp, linenr_T *lnump, int *amount)
   return retval;
 }
 
-/*
- * Recognize the start of a C or C++ comment.
- */
+// Recognize the start of a C or C++ comment.
 static int cin_iscomment(const char_u *p)
 {
   return p[0] == '/' && (p[1] == '*' || p[1] == '/');
 }
 
-/*
- * Recognize the start of a "//" comment.
- */
+// Recognize the start of a "//" comment.
 static int cin_islinecomment(const char_u *p)
 {
   return p[0] == '/' && p[1] == '/';
@@ -957,10 +916,10 @@ static int cin_isfuncdecl(const char_u **sp, linenr_T first_lnum, linenr_T min_l
     if ((*s == ',' && cin_nocode(s + 1)) || s[1] == NUL || cin_nocode(s)) {
       int comma = (*s == ',');
 
-      /* ',' at the end: continue looking in the next line.
-       * At the end: check for ',' in the next line, for this style:
-       * func(arg1
-       *       , arg2) */
+      // ',' at the end: continue looking in the next line.
+      // At the end: check for ',' in the next line, for this style:
+      // func(arg1
+      //       , arg2)
       for (;;) {
         if (lnum >= curbuf->b_ml.ml_line_count) {
           break;
@@ -1014,11 +973,9 @@ static int cin_isdo(const char_u *p)
   return STRNCMP(p, "do", 2) == 0 && !vim_isIDc(p[2]);
 }
 
-/*
- * Check if this is a "while" that should have a matching "do".
- * We only accept a "while (condition) ;", with only white space between the
- * ')' and ';'. The condition may be spread over several lines.
- */
+// Check if this is a "while" that should have a matching "do".
+// We only accept a "while (condition) ;", with only white space between the
+// ')' and ';'. The condition may be spread over several lines.
 static int cin_iswhileofdo(const char_u *p, linenr_T lnum)  // XXX
 {
   pos_T cursor_save;
@@ -1047,12 +1004,10 @@ static int cin_iswhileofdo(const char_u *p, linenr_T lnum)  // XXX
   return retval;
 }
 
-/*
- * Check whether in "p" there is an "if", "for" or "while" before "*poffset".
- * Return 0 if there is none.
- * Otherwise return !0 and update "*poffset" to point to the place where the
- * string was found.
- */
+// Check whether in "p" there is an "if", "for" or "while" before "*poffset".
+// Return 0 if there is none.
+// Otherwise return !0 and update "*poffset" to point to the place where the
+// string was found.
 static int cin_is_if_for_while_before_offset(const char_u *line, int *poffset)
 {
   int offset = *poffset;
@@ -1116,8 +1071,8 @@ static int cin_iswhileofdo_end(int terminated)
     if (*p == ')') {
       s = (char_u *)skipwhite((char *)p + 1);
       if (*s == ';' && cin_nocode(s + 1)) {
-        /* Found ");" at end of the line, now check there is "while"
-         * before the matching '('.  XXX */
+        // Found ");" at end of the line, now check there is "while"
+        // before the matching '('.  XXX
         i = (int)(p - line);
         curwin->w_cursor.col = i;
         trypos = find_match_paren(curbuf->b_ind_maxparen);
@@ -1149,19 +1104,17 @@ static int cin_isbreak(const char_u *p)
   return STRNCMP(p, "break", 5) == 0 && !vim_isIDc(p[5]);
 }
 
-/*
- * Find the position of a C++ base-class declaration or
- * constructor-initialization. eg:
- *
- * class MyClass :
- *      baseClass               <-- here
- * class MyClass : public baseClass,
- *      anotherBaseClass        <-- here (should probably lineup ??)
- * MyClass::MyClass(...) :
- *      baseClass(...)          <-- here (constructor-initialization)
- *
- * This is a lot of guessing.  Watch out for "cond ? func() : foo".
- */
+// Find the position of a C++ base-class declaration or
+// constructor-initialization. eg:
+//
+// class MyClass :
+//      baseClass               <-- here
+// class MyClass : public baseClass,
+//      anotherBaseClass        <-- here (should probably lineup ??)
+// MyClass::MyClass(...) :
+//      baseClass(...)          <-- here (constructor-initialization)
+//
+// This is a lot of guessing.  Watch out for "cond ? func() : foo".
 static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
 {
   lpos_T *pos = &cached->lpos;  // find position
@@ -1187,19 +1140,18 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
 
   cpp_base_class = lookfor_ctor_init = class_or_struct = false;
 
-  /* Search for a line starting with '#', empty, ending in ';' or containing
-   * '{' or '}' and start below it.  This handles the following situations:
-   *    a = cond ?
-   *          func() :
-   *               asdf;
-   *    func::foo()
-   *          : something
-   *    {}
-   *    Foo::Foo (int one, int two)
-   *            : something(4),
-   *            somethingelse(3)
-   *    {}
-   */
+  // Search for a line starting with '#', empty, ending in ';' or containing
+  // '{' or '}' and start below it.  This handles the following situations:
+  //    a = cond ?
+  //          func() :
+  //               asdf;
+  //    func::foo()
+  //          : something
+  //    {}
+  //    Foo::Foo (int one, int two)
+  //            : something(4),
+  //            somethingelse(3)
+  //    {}
   while (lnum > 1) {
     line = (char_u *)ml_get(lnum - 1);
     s = (char_u *)skipwhite((char *)line);
@@ -1249,13 +1201,13 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
       s = skip_string(s) + 1;
     } else if (s[0] == ':') {
       if (s[1] == ':') {
-        /* skip double colon. It can't be a constructor
-         * initialization any more */
+        // skip double colon. It can't be a constructor
+        // initialization any more
         lookfor_ctor_init = false;
         s = cin_skipcomment(s + 2);
       } else if (lookfor_ctor_init || class_or_struct) {
-        /* we have something found, that looks like the start of
-         * cpp-base-class-declaration or constructor-initialization */
+        // we have something found, that looks like the start of
+        // cpp-base-class-declaration or constructor-initialization
         cpp_base_class = true;
         lookfor_ctor_init = class_or_struct = false;
         pos->col = 0;
@@ -1277,8 +1229,8 @@ static int cin_is_cpp_baseclass(cpp_baseclass_cache_T *cached)
       if (s[0] == '{' || s[0] == '}' || s[0] == ';') {
         cpp_base_class = lookfor_ctor_init = class_or_struct = false;
       } else if (s[0] == ')') {
-        /* Constructor-initialization is assumed if we come across
-         * something like "):" */
+        // Constructor-initialization is assumed if we come across
+        // something like "):"
         class_or_struct = false;
         lookfor_ctor_init = true;
       } else if (s[0] == '?') {
@@ -1411,10 +1363,8 @@ static int cin_is_cpp_extern_c(const char_u *s)
   return false;
 }
 
-/*
- * Skip strings, chars and comments until at or past "trypos".
- * Return the column found.
- */
+// Skip strings, chars and comments until at or past "trypos".
+// Return the column found.
 static int cin_skip2pos(pos_T *trypos)
 {
   const char_u *line;
@@ -1438,11 +1388,10 @@ static int cin_skip2pos(pos_T *trypos)
   return (int)(p - line);
 }
 
-/*
- * Find the '{' at the start of the block we are in.
- * Return NULL if no match found.
- * Ignore a '{' that is in a comment, makes indenting the next three lines
- * work. */
+// Find the '{' at the start of the block we are in.
+// Return NULL if no match found.
+// Ignore a '{' that is in a comment, makes indenting the next three lines
+// work.
 // foo()
 // {
 // }
@@ -1542,12 +1491,10 @@ static pos_T *find_match_paren_after_brace(int ind_maxparen)
   return trypos;
 }
 
-/*
- * Return ind_maxparen corrected for the difference in line number between the
- * cursor position and "startpos".  This makes sure that searching for a
- * matching paren above the cursor line doesn't find a match because of
- * looking a few lines further.
- */
+// Return ind_maxparen corrected for the difference in line number between the
+// cursor position and "startpos".  This makes sure that searching for a
+// matching paren above the cursor line doesn't find a match because of
+// looking a few lines further.
 static int corr_ind_maxparen(pos_T *startpos)
 {
   long n = (long)startpos->lnum - (long)curwin->w_cursor.lnum;
@@ -1558,10 +1505,8 @@ static int corr_ind_maxparen(pos_T *startpos)
   return curbuf->b_ind_maxparen;
 }
 
-/*
- * Set w_cursor.col to the column number of the last unmatched ')' or '{' in
- * line "l".  "l" must point to the start of the line.
- */
+// Set w_cursor.col to the column number of the last unmatched ')' or '{' in
+// line "l".  "l" must point to the start of the line.
 static int find_last_paren(const char_u *l, int start, int end)
 {
   int i;
@@ -1587,10 +1532,8 @@ static int find_last_paren(const char_u *l, int start, int end)
   return retval;
 }
 
-/*
- * Parse 'cinoptions' and set the values in "curbuf".
- * Must be called when 'cinoptions', 'shiftwidth' and/or 'tabstop' changes.
- */
+// Parse 'cinoptions' and set the values in "curbuf".
+// Must be called when 'cinoptions', 'shiftwidth' and/or 'tabstop' changes.
 void parse_cino(buf_T *buf)
 {
   char *p;
@@ -1599,39 +1542,37 @@ void parse_cino(buf_T *buf)
   int fraction = 0;
   int sw = get_sw_value(buf);
 
-  /*
-   * Set the default values.
-   */
-  /* Spaces from a block's opening brace the prevailing indent for that
-   * block should be. */
+  // Set the default values.
+  // Spaces from a block's opening brace the prevailing indent for that
+  // block should be.
   buf->b_ind_level = sw;
 
-  /* Spaces from the edge of the line an open brace that's at the end of a
-   * line is imagined to be. */
+  // Spaces from the edge of the line an open brace that's at the end of a
+  // line is imagined to be.
   buf->b_ind_open_imag = 0;
 
-  /* Spaces from the prevailing indent for a line that is not preceded by
-   * an opening brace. */
+  // Spaces from the prevailing indent for a line that is not preceded by
+  // an opening brace.
   buf->b_ind_no_brace = 0;
 
   // Column where the first { of a function should be located }.
   buf->b_ind_first_open = 0;
 
-  /* Spaces from the prevailing indent a leftmost open brace should be
-   * located. */
+  // Spaces from the prevailing indent a leftmost open brace should be
+  // located.
   buf->b_ind_open_extra = 0;
 
-  /* Spaces from the matching open brace (real location for one at the left
-   * edge; imaginary location from one that ends a line) the matching close
-   * brace should be located. */
+  // Spaces from the matching open brace (real location for one at the left
+  // edge; imaginary location from one that ends a line) the matching close
+  // brace should be located.
   buf->b_ind_close_extra = 0;
 
-  /* Spaces from the edge of the line an open brace sitting in the leftmost
-   * column is imagined to be. */
+  // Spaces from the edge of the line an open brace sitting in the leftmost
+  // column is imagined to be.
   buf->b_ind_open_left_imag = 0;
 
-  /* Spaces jump labels should be shifted to the left if N is non-negative,
-   * otherwise the jump label will be put to column 1. */
+  // Spaces jump labels should be shifted to the left if N is non-negative,
+  // otherwise the jump label will be put to column 1.
   buf->b_ind_jump_label = -1;
 
   // Spaces from the switch() indent a "case xx" label should be located.
@@ -1643,8 +1584,8 @@ void parse_cino(buf_T *buf)
   // Lineup break at end of case in switch() with case label.
   buf->b_ind_case_break = 0;
 
-  /* Spaces from the class declaration indent a scope declaration label
-   * should be located. */
+  // Spaces from the class declaration indent a scope declaration label
+  // should be located.
   buf->b_ind_scopedecl = sw;
 
   // Spaces from the scope declaration label code should be located.
@@ -1656,32 +1597,32 @@ void parse_cino(buf_T *buf)
   // Amount a function type spec should be indented.
   buf->b_ind_func_type = sw;
 
-  /* Amount a cpp base class declaration or constructor initialization
-   * should be indented. */
+  // Amount a cpp base class declaration or constructor initialization
+  // should be indented.
   buf->b_ind_cpp_baseclass = sw;
 
-  /* additional spaces beyond the prevailing indent a continuation line
-   * should be located. */
+  // additional spaces beyond the prevailing indent a continuation line
+  // should be located.
   buf->b_ind_continuation = sw;
 
   // Spaces from the indent of the line with an unclosed parentheses.
   buf->b_ind_unclosed = sw * 2;
 
-  /* Spaces from the indent of the line with an unclosed parentheses, which
-   * itself is also unclosed. */
+  // Spaces from the indent of the line with an unclosed parentheses, which
+  // itself is also unclosed.
   buf->b_ind_unclosed2 = sw;
 
   // Suppress ignoring spaces from the indent of a line starting with an
   // unclosed parenthesis.
   buf->b_ind_unclosed_noignore = 0;
 
-  /* If the opening paren is the last nonwhite character on the line, and
-   * b_ind_unclosed_wrapped is nonzero, use this indent relative to the outer
-   * context (for very long lines). */
+  // If the opening paren is the last nonwhite character on the line, and
+  // b_ind_unclosed_wrapped is nonzero, use this indent relative to the outer
+  // context (for very long lines).
   buf->b_ind_unclosed_wrapped = 0;
 
-  /* Suppress ignoring white space when lining up with the character after
-   * an unclosed parentheses. */
+  // Suppress ignoring white space when lining up with the character after
+  // an unclosed parentheses.
   buf->b_ind_unclosed_whiteok = 0;
 
   // Indent a closing parenthesis under the line start of the matching
@@ -1697,8 +1638,8 @@ void parse_cino(buf_T *buf)
   // Spaces from the comment opener when there is nothing after it.
   buf->b_ind_in_comment = 3;
 
-  /* Boolean: if non-zero, use b_ind_in_comment even if there is something
-   * after the comment opener. */
+  // Boolean: if non-zero, use b_ind_in_comment even if there is something
+  // after the comment opener.
   buf->b_ind_in_comment2 = 0;
 
   // Max lines to search for an open paren.
@@ -1719,8 +1660,8 @@ void parse_cino(buf_T *buf)
   // Handle C++ namespace.
   buf->b_ind_cpp_namespace = 0;
 
-  /* Handle continuation lines containing conditions of if(), for() and
-   * while(). */
+  // Handle continuation lines containing conditions of if(), for() and
+  // while().
   buf->b_ind_if_for_while = 0;
 
   // indentation for # comments
@@ -1766,8 +1707,8 @@ void parse_cino(buf_T *buf)
       n = -n;
     }
 
-    /* When adding an entry here, also update the default 'cinoptions' in
-     * doc/indent.txt, and add explanation for it! */
+    // When adding an entry here, also update the default 'cinoptions' in
+    // doc/indent.txt, and add explanation for it!
     switch (*l) {
     case '>':
       buf->b_ind_level = n;
@@ -1887,10 +1828,8 @@ void parse_cino(buf_T *buf)
   }
 }
 
-/*
- * Return the desired indent for C code.
- * Return -1 if the indent should be left alone (inside a raw string).
- */
+// Return the desired indent for C code.
+// Return -1 if the indent should be left alone (inside a raw string).
 int get_c_indent(void)
 {
   pos_T cur_curpos;
@@ -1951,18 +1890,16 @@ int get_c_indent(void)
     return 0;
   }
 
-  /* Get a copy of the current contents of the line.
-   * This is required, because only the most recent line obtained with
-   * ml_get is valid! */
+  // Get a copy of the current contents of the line.
+  // This is required, because only the most recent line obtained with
+  // ml_get is valid!
   linecopy = vim_strsave((char_u *)ml_get(cur_curpos.lnum));
 
-  /*
-   * In insert mode and the cursor is on a ')' truncate the line at the
-   * cursor position.  We don't want to line up with the matching '(' when
-   * inserting new stuff.
-   * For unknown reasons the cursor might be past the end of the line, thus
-   * check for that.
-   */
+  // In insert mode and the cursor is on a ')' truncate the line at the
+  // cursor position.  We don't want to line up with the matching '(' when
+  // inserting new stuff.
+  // For unknown reasons the cursor might be past the end of the line, thus
+  // check for that.
   if ((State & MODE_INSERT)
       && curwin->w_cursor.col < (colnr_T)STRLEN(linecopy)
       && linecopy[curwin->w_cursor.col] == ')') {
@@ -1977,10 +1914,8 @@ int get_c_indent(void)
 
   original_line_islabel = cin_islabel();    // XXX
 
-  /*
-   * If we are inside a raw string don't change the indent.
-   * Ignore a raw string inside a comment.
-   */
+  // If we are inside a raw string don't change the indent.
+  // Ignore a raw string inside a comment.
   comment_pos = ind_find_start_comment();
   if (comment_pos != NULL) {
     // findmatchlimit() static pos is overwritten, make a copy
@@ -2010,10 +1945,8 @@ int get_c_indent(void)
     amount = 0;
     goto theend;
   }
-  /*
-   * If we're inside a "//" comment and there is a "//" comment in a
-   * previous line, lineup with that one.
-   */
+  // If we're inside a "//" comment and there is a "//" comment in a
+  // previous line, lineup with that one.
   if (cin_islinecomment(theline)) {
     pos_T linecomment_pos;
 
@@ -2034,10 +1967,8 @@ int get_c_indent(void)
       goto theend;
     }
   }
-  /*
-   * If we're inside a comment and not looking at the start of the
-   * comment, try using the 'comments' option.
-   */
+  // If we're inside a comment and not looking at the start of the
+  // comment, try using the 'comments' option.
   if (!cin_iscomment(theline) && comment_pos != NULL) {  // XXX
     int lead_start_len = 2;
     int lead_middle_len = 1;
@@ -2086,16 +2017,16 @@ int get_c_indent(void)
         STRCPY(lead_middle, lead_end);
         lead_middle_len = (int)STRLEN(lead_middle);
       } else if (what == COM_END) {
-        /* If our line starts with the middle comment string, line it
-         * up with the comment opener per the 'comments' option. */
+        // If our line starts with the middle comment string, line it
+        // up with the comment opener per the 'comments' option.
         if (STRNCMP(theline, lead_middle, lead_middle_len) == 0
             && STRNCMP(theline, lead_end, STRLEN(lead_end)) != 0) {
           done = true;
           if (curwin->w_cursor.lnum > 1) {
-            /* If the start comment string matches in the previous
-             * line, use the indent of that line plus offset.  If
-             * the middle comment string matches in the previous
-             * line, use the indent of that line.  XXX */
+            // If the start comment string matches in the previous
+            // line, use the indent of that line plus offset.  If
+            // the middle comment string matches in the previous
+            // line, use the indent of that line.  XXX
             look = (char_u *)skipwhite(ml_get(curwin->w_cursor.lnum - 1));
             if (STRNCMP(look, lead_start, lead_start_len) == 0) {
               amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
@@ -2117,8 +2048,8 @@ int get_c_indent(void)
           break;
         }
 
-        /* If our line starts with the end comment string, line it up
-         * with the middle comment */
+        // If our line starts with the end comment string, line it up
+        // with the middle comment
         if (STRNCMP(theline, lead_middle, lead_middle_len) != 0
             && STRNCMP(theline, lead_end, STRLEN(lead_end)) == 0) {
           amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
@@ -2134,10 +2065,9 @@ int get_c_indent(void)
       }
     }
 
-    /* If our line starts with an asterisk, line up with the
-     * asterisk in the comment opener; otherwise, line up
-     * with the first character of the comment text.
-     */
+    // If our line starts with an asterisk, line up with the
+    // asterisk in the comment opener; otherwise, line up
+    // with the first character of the comment text.
     if (done) {
       // skip
     } else if (theline[0] == '*') {
@@ -2187,8 +2117,8 @@ int get_c_indent(void)
       || (tryposBrace = find_start_brace()) != NULL
       || trypos != NULL) {
     if (trypos != NULL && tryposBrace != NULL) {
-      /* Both an unmatched '(' and '{' is found.  Use the one which is
-       * closer to the current cursor position, set the other to NULL. */
+      // Both an unmatched '(' and '{' is found.  Use the one which is
+      // closer to the current cursor position, set the other to NULL.
       if (trypos->lnum != tryposBrace->lnum
           ? trypos->lnum < tryposBrace->lnum
           : trypos->col < tryposBrace->col) {
@@ -2200,10 +2130,8 @@ int get_c_indent(void)
 
     if (trypos != NULL) {
       our_paren_pos = *trypos;
-      /*
-       * If the matching paren is more than one line away, use the indent of
-       * a previous non-empty line that matches the same paren.
-       */
+      // If the matching paren is more than one line away, use the indent of
+      // a previous non-empty line that matches the same paren.
       if (theline[0] == ')' && curbuf->b_ind_paren_prev) {
         // Line up with the start of the matching paren line.
         amount = get_indent_lnum(curwin->w_cursor.lnum - 1);      // XXX
@@ -2243,18 +2171,16 @@ int get_c_indent(void)
         }
       }
 
-      /*
-       * Line up with line where the matching paren is. XXX
-       * If the line starts with a '(' or the indent for unclosed
-       * parentheses is zero, line up with the unclosed parentheses.
-       */
+      // Line up with line where the matching paren is. XXX
+      // If the line starts with a '(' or the indent for unclosed
+      // parentheses is zero, line up with the unclosed parentheses.
       if (amount == -1) {
         int ignore_paren_col = 0;
         int is_if_for_while = 0;
 
         if (curbuf->b_ind_if_for_while) {
-          /* Look for the outermost opening parenthesis on this line
-           * and check whether it belongs to an "if", "for" or "while". */
+          // Look for the outermost opening parenthesis on this line
+          // and check whether it belongs to an "if", "for" or "while".
 
           pos_T cursor_save = curwin->w_cursor;
           pos_T outermost;
@@ -2284,8 +2210,8 @@ int get_c_indent(void)
           char_u *line;
           int look_col;
 
-          /* Ignore a '(' in front of the line that has a match before
-           * our matching '('. */
+          // Ignore a '(' in front of the line that has a match before
+          // our matching '('.
           curwin->w_cursor.lnum = our_paren_pos.lnum;
           line = (char_u *)get_cursor_line_ptr();
           look_col = (int)(look - line);
@@ -2305,22 +2231,20 @@ int get_c_indent(void)
                                   && is_if_for_while == 0)
             || (!curbuf->b_ind_unclosed_noignore && *look == '('
                 && ignore_paren_col == 0)) {
-          /*
-           * If we're looking at a close paren, line up right there;
-           * otherwise, line up with the next (non-white) character.
-           * When b_ind_unclosed_wrapped is set and the matching paren is
-           * the last nonwhite character of the line, use either the
-           * indent of the current line or the indentation of the next
-           * outer paren and add b_ind_unclosed_wrapped (for very long
-           * lines).
-           */
+          // If we're looking at a close paren, line up right there;
+          // otherwise, line up with the next (non-white) character.
+          // When b_ind_unclosed_wrapped is set and the matching paren is
+          // the last nonwhite character of the line, use either the
+          // indent of the current line or the indentation of the next
+          // outer paren and add b_ind_unclosed_wrapped (for very long
+          // lines).
           if (theline[0] != ')') {
             cur_amount = MAXCOL;
             l = (char_u *)ml_get(our_paren_pos.lnum);
             if (curbuf->b_ind_unclosed_wrapped
                 && cin_ends_in(l, (char_u *)"(", NULL)) {
-              /* look for opening unmatched paren, indent one level
-               * for each additional level */
+              // look for opening unmatched paren, indent one level
+              // for each additional level
               n = 1;
               for (col = 0; col < our_paren_pos.col; col++) {
                 switch (l[col]) {
@@ -2355,10 +2279,8 @@ int get_c_indent(void)
             }
           }
 
-          /*
-           * Find how indented the paren is, or the character after it
-           * if we did the above "if".
-           */
+          // Find how indented the paren is, or the character after it
+          // if we did the above "if".
           if (our_paren_pos.col > 0) {
             getvcol(curwin, &our_paren_pos, &col, NULL, NULL);
             if (cur_amount > (int)col) {
@@ -2376,8 +2298,8 @@ int get_c_indent(void)
             amount = cur_amount;
           }
         } else {
-          /* Add b_ind_unclosed2 for each '(' before our matching one,
-           * but ignore (void) before the line (ignore_paren_col). */
+          // Add b_ind_unclosed2 for each '(' before our matching one,
+          // but ignore (void) before the line (ignore_paren_col).
           col = our_paren_pos.col;
           while ((int)our_paren_pos.col > ignore_paren_col) {
             our_paren_pos.col--;
@@ -2393,8 +2315,8 @@ int get_c_indent(void)
             }
           }
 
-          /* Use b_ind_unclosed once, when the first '(' is not inside
-           * braces */
+          // Use b_ind_unclosed once, when the first '(' is not inside
+          // braces
           if (col == MAXCOL) {
             amount += curbuf->b_ind_unclosed;
           } else {
@@ -2410,14 +2332,12 @@ int get_c_indent(void)
               }
             }
           }
-          /*
-           * For a line starting with ')' use the minimum of the two
-           * positions, to avoid giving it more indent than the previous
-           * lines:
-           *  func_long_name(               if (x
-           *    arg                                 && yy
-           *    )         ^ not here           )    ^ not here
-           */
+          // For a line starting with ')' use the minimum of the two
+          // positions, to avoid giving it more indent than the previous
+          // lines:
+          //  func_long_name(               if (x
+          //    arg                                 && yy
+          //    )         ^ not here           )    ^ not here
           if (cur_amount < amount) {
             amount = cur_amount;
           }
@@ -2439,12 +2359,10 @@ int get_c_indent(void)
       ourscope = trypos->lnum;
       start = (char_u *)ml_get(ourscope);
 
-      /*
-       * Now figure out how indented the line is in general.
-       * If the brace was at the start of the line, we use that;
-       * otherwise, check out the indentation of the line as
-       * a whole and then add the "imaginary indent" to that.
-       */
+      // Now figure out how indented the line is in general.
+      // If the brace was at the start of the line, we use that;
+      // otherwise, check out the indentation of the line as
+      // a whole and then add the "imaginary indent" to that.
       look = (char_u *)skipwhite((char *)start);
       if (*look == '{') {
         getvcol(curwin, trypos, &col, NULL, NULL);
@@ -2490,18 +2408,14 @@ int get_c_indent(void)
       // we want to be.  Otherwise, add the amount of room
       // that an indent is supposed to be.
       if (theline[0] == '}') {
-        /*
-         * they may want closing braces to line up with something
-         * other than the open brace.  indulge them, if so.
-         */
+        // they may want closing braces to line up with something
+        // other than the open brace.  indulge them, if so.
         amount += curbuf->b_ind_close_extra;
       } else {
-        /*
-         * If we're looking at an "else", try to find an "if"
-         * to match it with.
-         * If we're looking at a "while", try to find a "do"
-         * to match it with.
-         */
+        // If we're looking at an "else", try to find an "if"
+        // to match it with.
+        // If we're looking at a "while", try to find a "do"
+        // to match it with.
         lookfor = LOOKFOR_INITIAL;
         if (cin_iselse(theline)) {
           lookfor = LOOKFOR_IF;
@@ -2516,18 +2430,14 @@ int get_c_indent(void)
           }
         }
 
-        /*
-         * We get here if we are not on an "while-of-do" or "else" (or
-         * failed to find a matching "if").
-         * Search backwards for something to line up with.
-         * First set amount for when we don't find anything.
-         */
+        // We get here if we are not on an "while-of-do" or "else" (or
+        // failed to find a matching "if").
+        // Search backwards for something to line up with.
+        // First set amount for when we don't find anything.
 
-        /*
-         * if the '{' is  _really_ at the left margin, use the imaginary
-         * location of a left-margin brace.  Otherwise, correct the
-         * location for b_ind_open_extra.
-         */
+        // if the '{' is  _really_ at the left margin, use the imaginary
+        // location of a left-margin brace.  Otherwise, correct the
+        // location for b_ind_open_extra.
 
         if (start_brace == BRACE_IN_COL0) {     // '{' is in column 0
           amount = curbuf->b_ind_open_left_imag;
@@ -2586,10 +2496,8 @@ int get_c_indent(void)
           curwin->w_cursor.lnum--;
           curwin->w_cursor.col = 0;
 
-          /*
-           * If we went all the way back to the start of our scope, line
-           * up with it.
-           */
+          // If we went all the way back to the start of our scope, line
+          // up with it.
           if (curwin->w_cursor.lnum <= ourscope) {
             // We reached end of scope:
             // If looking for a enum or structure initialization
@@ -2603,9 +2511,9 @@ int get_c_indent(void)
               if (curwin->w_cursor.lnum == 0
                   || curwin->w_cursor.lnum
                   < ourscope - curbuf->b_ind_maxparen) {
-                /* nothing found (abuse curbuf->b_ind_maxparen as
-                 * limit) assume terminated line (i.e. a variable
-                 * initialization) */
+                // nothing found (abuse curbuf->b_ind_maxparen as
+                // limit) assume terminated line (i.e. a variable
+                // initialization)
                 if (cont_amount > 0) {
                   amount = cont_amount;
                 } else if (!curbuf->b_ind_js) {
@@ -2616,10 +2524,8 @@ int get_c_indent(void)
 
               l = (char_u *)get_cursor_line_ptr();
 
-              /*
-               * If we're in a comment or raw string now, skip to
-               * the start of it.
-               */
+              // If we're in a comment or raw string now, skip to
+              // the start of it.
               trypos = ind_find_start_CORS(NULL);
               if (trypos != NULL) {
                 curwin->w_cursor.lnum = trypos->lnum + 1;
@@ -2640,27 +2546,23 @@ int get_c_indent(void)
 
               terminated = cin_isterminated(l, false, true);
 
-              /*
-               * If we are at top level and the line looks like a
-               * function declaration, we are done
-               * (it's a variable declaration).
-               */
+              // If we are at top level and the line looks like a
+              // function declaration, we are done
+              // (it's a variable declaration).
               if (start_brace != BRACE_IN_COL0
                   || !cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0)) {
-                /* if the line is terminated with another ','
-                 * it is a continued variable initialization.
-                 * don't add extra indent.
-                 * TODO: does not work, if  a function
-                 * declaration is split over multiple lines:
-                 * cin_isfuncdecl returns false then.
-                 */
+                // if the line is terminated with another ','
+                // it is a continued variable initialization.
+                // don't add extra indent.
+                // TODO(vim): does not work, if  a function
+                // declaration is split over multiple lines:
+                // cin_isfuncdecl returns false then.
                 if (terminated == ',') {
                   break;
                 }
 
-                /* if it is an enum declaration or an assignment,
-                 * we are done.
-                 */
+                // if it is an enum declaration or an assignment,
+                // we are done.
                 if (terminated != ';' && cin_isinit()) {
                   break;
                 }
@@ -2692,11 +2594,10 @@ int get_c_indent(void)
                 }
               }
 
-              /* it's a variable declaration, add indentation
-               * like in
-               * int a,
-               *    b;
-               */
+              // it's a variable declaration, add indentation
+              // like in
+              // int a,
+              //    b;
               if (cont_amount > 0) {
                 amount = cont_amount;
               } else {
@@ -2720,10 +2621,8 @@ int get_c_indent(void)
               }
 
               if (lookfor_cpp_namespace) {
-                /*
-                 * Looking for C++ namespace, need to look further
-                 * back.
-                 */
+                // Looking for C++ namespace, need to look further
+                // back.
                 if (curwin->w_cursor.lnum == ourscope) {
                   continue;
                 }
@@ -2736,8 +2635,8 @@ int get_c_indent(void)
 
                 l = (char_u *)get_cursor_line_ptr();
 
-                /* If we're in a comment or raw string now, skip
-                 * to the start of it. */
+                // If we're in a comment or raw string now, skip
+                // to the start of it.
                 trypos = ind_find_start_CORS(NULL);
                 if (trypos != NULL) {
                   curwin->w_cursor.lnum = trypos->lnum + 1;
@@ -2779,20 +2678,18 @@ int get_c_indent(void)
 
           l = (char_u *)get_cursor_line_ptr();
 
-          /*
-           * If this is a switch() label, may line up relative to that.
-           * If this is a C++ scope declaration, do the same.
-           */
+          // If this is a switch() label, may line up relative to that.
+          // If this is a C++ scope declaration, do the same.
           bool iscase = cin_iscase(l, false);
           if (iscase || cin_isscopedecl(l)) {
-            /* we are only looking for cpp base class
-             * declaration/initialization any longer */
+            // we are only looking for cpp base class
+            // declaration/initialization any longer
             if (lookfor == LOOKFOR_CPP_BASECLASS) {
               break;
             }
 
-            /* When looking for a "do" we are not interested in
-             * labels. */
+            // When looking for a "do" we are not interested in
+            // labels.
             if (whilelevel > 0) {
               continue;
             }
@@ -2865,14 +2762,12 @@ int get_c_indent(void)
               break;
             }
 
-            /*
-             * Try to get the indent of a statement before the switch
-             * label.  If nothing is found, line up relative to the
-             * switch label.
-             *      break;              <- may line up with this line
-             *   case xx:
-             * ->   y = 1;
-             */
+            // Try to get the indent of a statement before the switch
+            // label.  If nothing is found, line up relative to the
+            // switch label.
+            //      break;              <- may line up with this line
+            //   case xx:
+            // ->   y = 1;
             scope_amount = get_indent() + (iscase            // XXX
                                            ? curbuf->b_ind_case_code
                                            : curbuf->b_ind_scopedecl_code);
@@ -2881,10 +2776,8 @@ int get_c_indent(void)
             continue;
           }
 
-          /*
-           * Looking for a switch() label or C++ scope declaration,
-           * ignore other lines, skip {}-blocks.
-           */
+          // Looking for a switch() label or C++ scope declaration,
+          // ignore other lines, skip {}-blocks.
           if (lookfor == LOOKFOR_CASE || lookfor == LOOKFOR_SCOPEDECL) {
             if (find_last_paren(l, '{', '}')
                 && (trypos = find_start_brace()) != NULL) {
@@ -2894,9 +2787,7 @@ int get_c_indent(void)
             continue;
           }
 
-          /*
-           * Ignore jump labels with nothing after them.
-           */
+          // Ignore jump labels with nothing after them.
           if (!curbuf->b_ind_js && cin_islabel()) {
             l = after_label((char_u *)get_cursor_line_ptr());
             if (l == NULL || cin_nocode(l)) {
@@ -2904,12 +2795,10 @@ int get_c_indent(void)
             }
           }
 
-          /*
-           * Ignore #defines, #if, etc.
-           * Ignore comment and empty lines.
-           * (need to get the line again, cin_islabel() may have
-           * unlocked it)
-           */
+          // Ignore #defines, #if, etc.
+          // Ignore comment and empty lines.
+          // (need to get the line again, cin_islabel() may have
+          // unlocked it)
           l = (char_u *)get_cursor_line_ptr();
           if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount)
               || cin_nocode(l)) {
@@ -2942,9 +2831,8 @@ int get_c_indent(void)
             }
             break;
           } else if (lookfor == LOOKFOR_CPP_BASECLASS) {
-            /* only look, whether there is a cpp base class
-             * declaration or initialization before the opening brace.
-             */
+            // only look, whether there is a cpp base class
+            // declaration or initialization before the opening brace.
             if (cin_isterminated(l, true, false)) {
               break;
             } else {
@@ -2952,17 +2840,15 @@ int get_c_indent(void)
             }
           }
 
-          /*
-           * What happens next depends on the line being terminated.
-           * If terminated with a ',' only consider it terminating if
-           * there is another unterminated statement behind, eg:
-           *   123,
-           *   sizeof
-           *      here
-           * Otherwise check whether it is an enumeration or structure
-           * initialisation (not indented) or a variable declaration
-           * (indented).
-           */
+          // What happens next depends on the line being terminated.
+          // If terminated with a ',' only consider it terminating if
+          // there is another unterminated statement behind, eg:
+          //   123,
+          //   sizeof
+          //      here
+          // Otherwise check whether it is an enumeration or structure
+          // initialisation (not indented) or a variable declaration
+          // (indented).
           terminated = cin_isterminated(l, false, true);
 
           if (js_cur_has_key) {
@@ -3032,12 +2918,10 @@ int get_c_indent(void)
             }
 
             if (trypos != NULL) {
-              /*
-               * Check if we are on a case label now.  This is
-               * handled above.
-               *     case xx:  if ( asdf &&
-               *                        asdf)
-               */
+              // Check if we are on a case label now.  This is
+              // handled above.
+              //     case xx:  if ( asdf &&
+              //                        asdf)
               curwin->w_cursor = *trypos;
               l = (char_u *)get_cursor_line_ptr();
               if (cin_iscase(l, false) || cin_isscopedecl(l)) {
@@ -3047,13 +2931,11 @@ int get_c_indent(void)
               }
             }
 
-            /*
-             * Skip over continuation lines to find the one to get the
-             * indent from
-             * char *usethis = "bla\
-             *           bla",
-             *      here;
-             */
+            // Skip over continuation lines to find the one to get the
+            // indent from
+            // char *usethis = "bla{backslash}
+            //           bla",
+            //      here;
             if (terminated == ',') {
               while (curwin->w_cursor.lnum > 1) {
                 l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
@@ -3065,49 +2947,41 @@ int get_c_indent(void)
               }
             }
 
-            /*
-             * Get indent and pointer to text for current line,
-             * ignoring any jump label.     XXX
-             */
+            // Get indent and pointer to text for current line,
+            // ignoring any jump label.     XXX
             if (curbuf->b_ind_js) {
               cur_amount = get_indent();
             } else {
               cur_amount = skip_label(curwin->w_cursor.lnum, &l);
             }
-            /*
-             * If this is just above the line we are indenting, and it
-             * starts with a '{', line it up with this line.
-             *          while (not)
-             * ->       {
-             *          }
-             */
+            // If this is just above the line we are indenting, and it
+            // starts with a '{', line it up with this line.
+            //          while (not)
+            // ->       {
+            //          }
             if (terminated != ',' && lookfor != LOOKFOR_TERM
                 && theline[0] == '{') {
               amount = cur_amount;
-              /*
-               * Only add b_ind_open_extra when the current line
-               * doesn't start with a '{', which must have a match
-               * in the same line (scope is the same).  Probably:
-               *        { 1, 2 },
-               * ->     { 3, 4 }
-               */
+              // Only add b_ind_open_extra when the current line
+              // doesn't start with a '{', which must have a match
+              // in the same line (scope is the same).  Probably:
+              //        { 1, 2 },
+              // ->     { 3, 4 }
               if (*skipwhite((char *)l) != '{') {
                 amount += curbuf->b_ind_open_extra;
               }
 
               if (curbuf->b_ind_cpp_baseclass && !curbuf->b_ind_js) {
-                /* have to look back, whether it is a cpp base
-                 * class declaration or initialization */
+                // have to look back, whether it is a cpp base
+                // class declaration or initialization
                 lookfor = LOOKFOR_CPP_BASECLASS;
                 continue;
               }
               break;
             }
 
-            /*
-             * Check if we are after an "if", "while", etc.
-             * Also allow "   } else".
-             */
+            // Check if we are after an "if", "while", etc.
+            // Also allow "   } else".
             if (cin_is_cinword((char *)l) || cin_iselse((char_u *)skipwhite((char *)l))) {
               // Found an unterminated line after an if (), line up
               // with the last one.
@@ -3124,19 +2998,17 @@ int get_c_indent(void)
                 break;
               }
 
-              /*
-               * If this is just above the line we are indenting, we
-               * are finished.
-               *            while (not)
-               * ->             here;
-               * Otherwise this indent can be used when the line
-               * before this is terminated.
-               *        yyy;
-               *        if (stat)
-               *            while (not)
-               *                xxx;
-               * ->     here;
-               */
+              // If this is just above the line we are indenting, we
+              // are finished.
+              //            while (not)
+              // ->             here;
+              // Otherwise this indent can be used when the line
+              // before this is terminated.
+              //        yyy;
+              //        if (stat)
+              //            while (not)
+              //                xxx;
+              // ->     here;
               amount = cur_amount;
               if (theline[0] == '{') {
                 amount += curbuf->b_ind_open_extra;
@@ -3147,13 +3019,11 @@ int get_c_indent(void)
                 break;
               }
 
-              /*
-               * Special trick: when expecting the while () after a
-               * do, line up with the while()
-               *     do
-               *            x = 1;
-               * ->  here
-               */
+              // Special trick: when expecting the while () after a
+              // do, line up with the while()
+              //     do
+              //            x = 1;
+              // ->  here
               l = (char_u *)skipwhite(get_cursor_line_ptr());
               if (cin_isdo(l)) {
                 if (whilelevel == 0) {
@@ -3162,16 +3032,14 @@ int get_c_indent(void)
                 whilelevel--;
               }
 
-              /*
-               * When searching for a terminated line, don't use the
-               * one between the "if" and the matching "else".
-               * Need to use the scope of this "else".  XXX
-               * If whilelevel != 0 continue looking for a "do {".
-               */
+              // When searching for a terminated line, don't use the
+              // one between the "if" and the matching "else".
+              // Need to use the scope of this "else".  XXX
+              // If whilelevel != 0 continue looking for a "do {".
               if (cin_iselse(l) && whilelevel == 0) {
-                /* If we're looking at "} else", let's make sure we
-                 * find the opening brace of the enclosing scope,
-                 * not the one from "if () {". */
+                // If we're looking at "} else", let's make sure we
+                // find the opening brace of the enclosing scope,
+                // not the one from "if () {".
                 if (*l == '}') {
                   curwin->w_cursor.col =
                     (colnr_T)(l - (char_u *)get_cursor_line_ptr()) + 1;
@@ -3183,21 +3051,17 @@ int get_c_indent(void)
                   break;
                 }
               }
-            }
-            /*
-             * If we're below an unterminated line that is not an
-             * "if" or something, we may line up with this line or
-             * add something for a continuation line, depending on
-             * the line before this one.
-             */
-            else {
-              /*
-               * Found two unterminated lines on a row, line up with
-               * the last one.
-               *   c = 99 +
-               *            100 +
-               * ->         here;
-               */
+            } else {
+              // If we're below an unterminated line that is not an
+              // "if" or something, we may line up with this line or
+              // add something for a continuation line, depending on
+              // the line before this one.
+
+              // Found two unterminated lines on a row, line up with
+              // the last one.
+              //   c = 99 +
+              //            100 +
+              // ->         here;
               if (lookfor == LOOKFOR_UNTERM) {
                 // When line ends in a comma add extra indent
                 if (terminated == ',') {
@@ -3207,11 +3071,11 @@ int get_c_indent(void)
               }
 
               if (lookfor == LOOKFOR_ENUM_OR_INIT) {
-                /* Found two lines ending in ',', lineup with the
-                 * lowest one, but check for cpp base class
-                 * declaration/initialization, if it is an
-                 * opening brace or we are looking just for
-                 * enumerations/initializations. */
+                // Found two lines ending in ',', lineup with the
+                // lowest one, but check for cpp base class
+                // declaration/initialization, if it is an
+                // opening brace or we are looking just for
+                // enumerations/initializations.
                 if (terminated == ',') {
                   if (curbuf->b_ind_cpp_baseclass == 0) {
                     break;
@@ -3296,19 +3160,14 @@ int get_c_indent(void)
                 }
               }
             }
-          }
-          /*
-           * Check if we are after a while (cond);
-           * If so: Ignore until the matching "do".
-           */
-          else if (cin_iswhileofdo_end(terminated)) {  // XXX
-            /*
-             * Found an unterminated line after a while ();, line up
-             * with the last one.
-             *      while (cond);
-             *      100 +               <- line up with this one
-             * ->           here;
-             */
+            // Check if we are after a while (cond);
+            // If so: Ignore until the matching "do".
+          } else if (cin_iswhileofdo_end(terminated)) {  // XXX
+            // Found an unterminated line after a while ();, line up
+            // with the last one.
+            //      while (cond);
+            //      100 +               <- line up with this one
+            // ->           here;
             if (lookfor == LOOKFOR_UNTERM
                 || lookfor == LOOKFOR_ENUM_OR_INIT) {
               if (cont_amount > 0) {
@@ -3327,28 +3186,22 @@ int get_c_indent(void)
               }
             }
             whilelevel++;
-          }
-          /*
-           * We are after a "normal" statement.
-           * If we had another statement we can stop now and use the
-           * indent of that other statement.
-           * Otherwise the indent of the current statement may be used,
-           * search backwards for the next "normal" statement.
-           */
-          else {
-            /*
-             * Skip single break line, if before a switch label. It
-             * may be lined up with the case label.
-             */
+          } else {
+            // We are after a "normal" statement.
+            // If we had another statement we can stop now and use the
+            // indent of that other statement.
+            // Otherwise the indent of the current statement may be used,
+            // search backwards for the next "normal" statement.
+
+            // Skip single break line, if before a switch label. It
+            // may be lined up with the case label.
             if (lookfor == LOOKFOR_NOBREAK
                 && cin_isbreak((char_u *)skipwhite(get_cursor_line_ptr()))) {
               lookfor = LOOKFOR_ANY;
               continue;
             }
 
-            /*
-             * Handle "do {" line.
-             */
+            // Handle "do {" line.
             if (whilelevel > 0) {
               l = cin_skipcomment((char_u *)get_cursor_line_ptr());
               if (cin_isdo(l)) {
@@ -3358,17 +3211,15 @@ int get_c_indent(void)
               }
             }
 
-            /*
-             * Found a terminated line above an unterminated line. Add
-             * the amount for a continuation line.
-             *   x = 1;
-             *   y = foo +
-             * ->       here;
-             * or
-             *   int x = 1;
-             *   int foo,
-             * ->       here;
-             */
+            // Found a terminated line above an unterminated line. Add
+            // the amount for a continuation line.
+            //   x = 1;
+            //   y = foo +
+            // ->       here;
+            // or
+            //   int x = 1;
+            //   int foo,
+            // ->       here;
             if (lookfor == LOOKFOR_UNTERM
                 || lookfor == LOOKFOR_ENUM_OR_INIT) {
               if (cont_amount > 0) {
@@ -3379,34 +3230,28 @@ int get_c_indent(void)
               break;
             }
 
-            /*
-             * Found a terminated line above a terminated line or "if"
-             * etc. line. Use the amount of the line below us.
-             *   x = 1;                         x = 1;
-             *   if (asdf)                  y = 2;
-             *       while (asdf)         ->here;
-             *          here;
-             * ->foo;
-             */
+            // Found a terminated line above a terminated line or "if"
+            // etc. line. Use the amount of the line below us.
+            //   x = 1;                         x = 1;
+            //   if (asdf)                  y = 2;
+            //       while (asdf)         ->here;
+            //          here;
+            // ->foo;
             if (lookfor == LOOKFOR_TERM) {
               if (!lookfor_break && whilelevel == 0) {
                 break;
               }
-            }
-            /*
-             * First line above the one we're indenting is terminated.
-             * To know what needs to be done look further backward for
-             * a terminated line.
-             */
-            else {
-              /*
-               * position the cursor over the rightmost paren, so
-               * that matching it will take us back to the start of
-               * the line.  Helps for:
-               *     func(asdr,
-               *              asdfasdf);
-               *     here;
-               */
+            } else {
+              // First line above the one we're indenting is terminated.
+              // To know what needs to be done look further backward for
+              // a terminated line.
+
+              // position the cursor over the rightmost paren, so
+              // that matching it will take us back to the start of
+              // the line.  Helps for:
+              //     func(asdr,
+              //              asdfasdf);
+              //     here;
 term_again:
               l = (char_u *)get_cursor_line_ptr();
               if (find_last_paren(l, '(', ')')
@@ -3424,21 +3269,18 @@ term_again:
                 }
               }
 
-              /* When aligning with the case statement, don't align
-               * with a statement after it.
-               *  case 1: {   <-- don't use this { position
-               *        stat;
-               *  }
-               *  case 2:
-               *        stat;
-               * }
-               */
+              // When aligning with the case statement, don't align
+              // with a statement after it.
+              //  case 1: {   <-- don't use this { position
+              //        stat;
+              //  }
+              //  case 2:
+              //        stat;
+              // }
               iscase = curbuf->b_ind_keep_case_label && cin_iscase(l, false);
 
-              /*
-               * Get indent and pointer to text for current line,
-               * ignoring any jump label.
-               */
+              // Get indent and pointer to text for current line,
+              // ignoring any jump label.
               amount = skip_label(curwin->w_cursor.lnum, &l);
 
               if (theline[0] == '{') {
@@ -3451,14 +3293,12 @@ term_again:
               }
               lookfor = iscase ? LOOKFOR_ANY : LOOKFOR_TERM;
 
-              /*
-               * When a terminated line starts with "else" skip to
-               * the matching "if":
-               *       else 3;
-               *             indent this;
-               * Need to use the scope of this "else".  XXX
-               * If whilelevel != 0 continue looking for a "do {".
-               */
+              // When a terminated line starts with "else" skip to
+              // the matching "if":
+              //       else 3;
+              //             indent this;
+              // Need to use the scope of this "else".  XXX
+              // If whilelevel != 0 continue looking for a "do {".
               if (lookfor == LOOKFOR_TERM
                   && *l != '}'
                   && cin_iselse(l)
@@ -3471,10 +3311,8 @@ term_again:
                 continue;
               }
 
-              /*
-               * If we're at the end of a block, skip to the start of
-               * that block.
-               */
+              // If we're at the end of a block, skip to the start of
+              // that block.
               l = (char_u *)get_cursor_line_ptr();
               if (find_last_paren(l, '{', '}')           // XXX
                   && (trypos = find_start_brace()) != NULL) {
@@ -3521,13 +3359,11 @@ term_again:
     amount = curbuf->b_ind_first_open;
     goto theend;
   }
-  /*
-   * If the NEXT line is a function declaration, the current
-   * line needs to be indented as a function type spec.
-   * Don't do this if the current line looks like a comment or if the
-   * current line is terminated, ie. ends in ';', or if the current line
-   * contains { or }: "void f() {\n if (1)"
-   */
+  // If the NEXT line is a function declaration, the current
+  // line needs to be indented as a function type spec.
+  // Don't do this if the current line looks like a comment or if the
+  // current line is terminated, ie. ends in ';', or if the current line
+  // contains { or }: "void f() {\n if (1)"
   if (cur_curpos.lnum < curbuf->b_ml.ml_line_count
       && !cin_nocode(theline)
       && vim_strchr((char *)theline, '{') == NULL
@@ -3582,18 +3418,16 @@ term_again:
       continue;
     }
 
-    /*
-     * If the previous line ends in ',', use one level of
-     * indentation:
-     * int foo,
-     *     bar;
-     * do this before checking for '}' in case of eg.
-     * enum foobar
-     * {
-     *   ...
-     * } foo,
-     *   bar;
-     */
+    // If the previous line ends in ',', use one level of
+    // indentation:
+    // int foo,
+    //     bar;
+    // do this before checking for '}' in case of eg.
+    // enum foobar
+    // {
+    //   ...
+    // } foo,
+    //   bar;
     if (cin_ends_in(l, (char_u *)",", NULL)
         || (*l != NUL && (n = l[STRLEN(l) - 1]) == '\\')) {
       // take us back to opening paren
@@ -3602,12 +3436,11 @@ term_again:
         curwin->w_cursor = *trypos;
       }
 
-      /* For a line ending in ',' that is a continuation line go
-       * back to the first line with a backslash:
-       * char *foo = "bla\
-       *                 bla",
-       *      here;
-       */
+      // For a line ending in ',' that is a continuation line go
+      // back to the first line with a backslash:
+      // char *foo = "bla{backslash}
+      //           bla",
+      //      here;
       while (n == 0 && curwin->w_cursor.lnum > 1) {
         l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
         if (*l == NUL || l[STRLEN(l) - 1] != '\\') {
@@ -3628,19 +3461,15 @@ term_again:
       break;
     }
 
-    /*
-     * If the line looks like a function declaration, and we're
-     * not in a comment, put it the left margin.
-     */
+    // If the line looks like a function declaration, and we're
+    // not in a comment, put it the left margin.
     if (cin_isfuncdecl(NULL, cur_curpos.lnum, 0)) {        // XXX
       break;
     }
     l = (char_u *)get_cursor_line_ptr();
 
-    /*
-     * Finding the closing '}' of a previous function.  Put
-     * current line at the left margin.  For when 'cino' has "fs".
-     */
+    // Finding the closing '}' of a previous function.  Put
+    // current line at the left margin.  For when 'cino' has "fs".
     if (*skipwhite((char *)l) == '}') {
       break;
     }
@@ -3663,11 +3492,9 @@ term_again:
       break;
     }
 
-    /*
-     * Find a line only has a semicolon that belongs to a previous
-     * line ending in '}', e.g. before an #endif.  Don't increase
-     * indent then.
-     */
+    // Find a line only has a semicolon that belongs to a previous
+    // line ending in '}', e.g. before an #endif.  Don't increase
+    // indent then.
     if (*(look = (char_u *)skipwhite((char *)l)) == ';' && cin_nocode(look + 1)) {
       pos_T curpos_save = curwin->w_cursor;
 
@@ -3686,23 +3513,19 @@ term_again:
       curwin->w_cursor = curpos_save;
     }
 
-    /*
-     * If the PREVIOUS line is a function declaration, the current
-     * line (and the ones that follow) needs to be indented as
-     * parameters.
-     */
+    // If the PREVIOUS line is a function declaration, the current
+    // line (and the ones that follow) needs to be indented as
+    // parameters.
     if (cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0)) {
       amount = curbuf->b_ind_param;
       break;
     }
 
-    /*
-     * If the previous line ends in ';' and the line before the
-     * previous line ends in ',' or '\', ident to column zero:
-     * int foo,
-     *     bar;
-     * indent_to_0 here;
-     */
+    // If the previous line ends in ';' and the line before the
+    // previous line ends in ',' or '\', ident to column zero:
+    // int foo,
+    //     bar;
+    // indent_to_0 here;
     if (cin_ends_in(l, (char_u *)";", NULL)) {
       l = (char_u *)ml_get(curwin->w_cursor.lnum - 1);
       if (cin_ends_in(l, (char_u *)",", NULL)
@@ -3712,13 +3535,11 @@ term_again:
       l = (char_u *)get_cursor_line_ptr();
     }
 
-    /*
-     * Doesn't look like anything interesting -- so just
-     * use the indent of this line.
-     *
-     * Position the cursor over the rightmost paren, so that
-     * matching it will take us back to the start of the line.
-     */
+    // Doesn't look like anything interesting -- so just
+    // use the indent of this line.
+    //
+    // Position the cursor over the rightmost paren, so that
+    // matching it will take us back to the start of the line.
     (void)find_last_paren(l, '(', ')');
 
     if ((trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL) {
@@ -3794,38 +3615,30 @@ static int find_match(int lookfor, linenr_T ourscope)
       continue;
     }
 
-    /*
-     * if we've gone outside the braces entirely,
-     * we must be out of scope...
-     */
+    // if we've gone outside the braces entirely,
+    // we must be out of scope...
     theirscope = find_start_brace();        // XXX
     if (theirscope == NULL) {
       break;
     }
 
-    /*
-     * and if the brace enclosing this is further
-     * back than the one enclosing the else, we're
-     * out of luck too.
-     */
+    // and if the brace enclosing this is further
+    // back than the one enclosing the else, we're
+    // out of luck too.
     if (theirscope->lnum < ourscope) {
       break;
     }
 
-    /*
-     * and if they're enclosed in a *deeper* brace,
-     * then we can ignore it because it's in a
-     * different scope...
-     */
+    // and if they're enclosed in a *deeper* brace,
+    // then we can ignore it because it's in a
+    // different scope...
     if (theirscope->lnum > ourscope) {
       continue;
     }
 
-    /*
-     * if it was an "else" (that's not an "else if")
-     * then we need to go back to another if, so
-     * increment elselevel
-     */
+    // if it was an "else" (that's not an "else if")
+    // then we need to go back to another if, so
+    // increment elselevel
     look = cin_skipcomment((char_u *)get_cursor_line_ptr());
     if (cin_iselse(look)) {
       mightbeif = cin_skipcomment(look + 4);
@@ -3835,10 +3648,8 @@ static int find_match(int lookfor, linenr_T ourscope)
       continue;
     }
 
-    /*
-     * if it was a "while" then we need to go back to
-     * another "do", so increment whilelevel.  XXX
-     */
+    // if it was a "while" then we need to go back to
+    // another "do", so increment whilelevel.  XXX
     if (cin_iswhileofdo(look, curwin->w_cursor.lnum)) {
       whilelevel++;
       continue;
@@ -3847,11 +3658,9 @@ static int find_match(int lookfor, linenr_T ourscope)
     // If it's an "if" decrement elselevel
     look = cin_skipcomment((char_u *)get_cursor_line_ptr());
     if (cin_isif(look)) {
-      elselevel--;
-      /*
-       * When looking for an "if" ignore "while"s that
-       * get in the way.
-       */
+      elselevel--;  // NOLINT(readability/braces)
+      // When looking for an "if" ignore "while"s that
+      // get in the way.
       if (elselevel == 0 && lookfor == LOOKFOR_IF) {
         whilelevel = 0;
       }
@@ -3862,11 +3671,9 @@ static int find_match(int lookfor, linenr_T ourscope)
       whilelevel--;
     }
 
-    /*
-     * if we've used up all the elses, then
-     * this must be the if that we want!
-     * match the indent level of that if.
-     */
+    // if we've used up all the elses, then
+    // this must be the if that we want!
+    // match the indent level of that if.
     if (elselevel <= 0 && whilelevel <= 0) {
       return OK;
     }
@@ -3874,9 +3681,7 @@ static int find_match(int lookfor, linenr_T ourscope)
   return FAIL;
 }
 
-/*
- * Do C or expression indenting on the current line.
- */
+// Do C or expression indenting on the current line.
 void do_c_expr_indent(void)
 {
   if (*curbuf->b_p_inde != NUL) {
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 1c7cfea768..a73c465042 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -1390,10 +1390,9 @@ scripterror:
   TIME_MSG("parsing arguments");
 }
 
-/*
- * Many variables are in "params" so that we can pass them to invoked
- * functions without a lot of arguments.  "argc" and "argv" are also
- * copied, so that they can be changed. */
+// Many variables are in "params" so that we can pass them to invoked
+// functions without a lot of arguments.  "argc" and "argv" are also
+// copied, so that they can be changed.
 static void init_params(mparm_T *paramp, int argc, char **argv)
 {
   CLEAR_POINTER(paramp);
@@ -1465,9 +1464,7 @@ static char_u *get_fname(mparm_T *parmp, char_u *cwd)
   return (char_u *)alist_name(&GARGLIST[0]);
 }
 
-/*
- * Decide about window layout for diff mode after reading vimrc.
- */
+// Decide about window layout for diff mode after reading vimrc.
 static void set_window_layout(mparm_T *paramp)
 {
   if (paramp->diff_mode && paramp->window_layout == 0) {
@@ -1479,10 +1476,8 @@ static void set_window_layout(mparm_T *paramp)
   }
 }
 
-/*
- * "-q errorfile": Load the error file now.
- * If the error file can't be read, exit before doing anything else.
- */
+// "-q errorfile": Load the error file now.
+// If the error file can't be read, exit before doing anything else.
 static void handle_quickfix(mparm_T *paramp)
 {
   if (paramp->edit_type == EDIT_QF) {
@@ -1498,10 +1493,8 @@ static void handle_quickfix(mparm_T *paramp)
   }
 }
 
-/*
- * Need to jump to the tag before executing the '-c command'.
- * Makes "vim -c '/return' -t main" work.
- */
+// Need to jump to the tag before executing the '-c command'.
+// Makes "vim -c '/return' -t main" work.
 static void handle_tag(char_u *tagname)
 {
   if (tagname != NULL) {
@@ -1540,18 +1533,14 @@ static void read_stdin(void)
   check_swap_exists_action();
 }
 
-/*
- * Create the requested number of windows and edit buffers in them.
- * Also does recovery if "recoverymode" set.
- */
+// Create the requested number of windows and edit buffers in them.
+// Also does recovery if "recoverymode" set.
 static void create_windows(mparm_T *parmp)
 {
   int dorewind;
   int done = 0;
 
-  /*
-   * Create the number of windows that was requested.
-   */
+  // Create the number of windows that was requested.
   if (parmp->window_count == -1) {      // was not set
     parmp->window_count = 1;
   }
@@ -1670,9 +1659,7 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
   win_T *win;
   char *p_shm_save = NULL;
 
-  /*
-   * Don't execute Win/Buf Enter/Leave autocommands here
-   */
+  // Don't execute Win/Buf Enter/Leave autocommands here
   autocmd_no_enter++;
   autocmd_no_leave++;
 
@@ -1781,9 +1768,7 @@ static void edit_buffers(mparm_T *parmp, char_u *cwd)
   }
 }
 
-/*
- * Execute the commands from --cmd arguments "cmds[cnt]".
- */
+// Execute the commands from --cmd arguments "cmds[cnt]".
 static void exe_pre_commands(mparm_T *parmp)
 {
   char **cmds = parmp->pre_commands;
@@ -1803,18 +1788,14 @@ static void exe_pre_commands(mparm_T *parmp)
   }
 }
 
-/*
- * Execute "+", "-c" and "-S" arguments.
- */
+// Execute "+", "-c" and "-S" arguments.
 static void exe_commands(mparm_T *parmp)
 {
   int i;
 
-  /*
-   * We start commands on line 0, make "vim +/pat file" match a
-   * pattern on line 1.  But don't move the cursor when an autocommand
-   * with g`" was used.
-   */
+  // We start commands on line 0, make "vim +/pat file" match a
+  // pattern on line 1.  But don't move the cursor when an autocommand
+  // with g`" was used.
   msg_scroll = true;
   if (parmp->tagname == NULL && curwin->w_cursor.lnum <= 1) {
     curwin->w_cursor.lnum = 0;
@@ -2137,11 +2118,9 @@ static void usage(void)
   mch_msg(_("\nSee \":help startup-options\" for all options.\n"));
 }
 
-/*
- * Check the result of the ATTENTION dialog:
- * When "Quit" selected, exit Vim.
- * When "Recover" selected, recover the file.
- */
+// Check the result of the ATTENTION dialog:
+// When "Quit" selected, exit Vim.
+// When "Recover" selected, recover the file.
 static void check_swap_exists_action(void)
 {
   if (swap_exists_action == SEA_QUIT) {
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index c6d08eb689..7838986edd 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * mark.c: functions for setting marks and jumping to them
- */
+// mark.c: functions for setting marks and jumping to them
 
 #include <assert.h>
 #include <inttypes.h>
@@ -39,17 +37,13 @@
 #include "nvim/ui.h"
 #include "nvim/vim.h"
 
-/*
- * This file contains routines to maintain and manipulate marks.
- */
+// This file contains routines to maintain and manipulate marks.
 
-/*
- * If a named file mark's lnum is non-zero, it is valid.
- * If a named file mark's fnum is non-zero, it is for an existing buffer,
- * otherwise it is from .shada and namedfm[n].fname is the file name.
- * There are marks 'A - 'Z (set by user) and '0 to '9 (set when writing
- * shada).
- */
+// If a named file mark's lnum is non-zero, it is valid.
+// If a named file mark's fnum is non-zero, it is for an existing buffer,
+// otherwise it is from .shada and namedfm[n].fname is the file name.
+// There are marks 'A - 'Z (set by user) and '0 to '9 (set when writing
+// shada).
 
 /// Global marks (marks with file number or name)
 static xfmark_T namedfm[NGLOBALMARKS];
@@ -57,10 +51,9 @@ static xfmark_T namedfm[NGLOBALMARKS];
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "mark.c.generated.h"
 #endif
-/*
- * Set named mark "c" at current cursor position.
- * Returns OK on success, FAIL if bad name given.
- */
+
+// Set named mark "c" at current cursor position.
+// Returns OK on success, FAIL if bad name given.
 int setmark(int c)
 {
   fmarkv_T view = mark_view_make(curwin->w_topline, curwin->w_cursor);
@@ -88,11 +81,9 @@ void clear_fmark(fmark_T *fm)
   CLEAR_POINTER(fm);
 }
 
-/*
- * Set named mark "c" to position "pos".
- * When "c" is upper case use file "fnum".
- * Returns OK on success, FAIL if bad name given.
- */
+// Set named mark "c" to position "pos".
+// When "c" is upper case use file "fnum".
+// Returns OK on success, FAIL if bad name given.
 int setmark_pos(int c, pos_T *pos, int fnum, fmarkv_T *view_pt)
 {
   int i;
@@ -166,10 +157,8 @@ int setmark_pos(int c, pos_T *pos, int fnum, fmarkv_T *view_pt)
   return FAIL;
 }
 
-/*
- * Set the previous context mark to the current position and add it to the
- * jump list.
- */
+// Set the previous context mark to the current position and add it to the
+// jump list.
 void setpcmark(void)
 {
   xfmark_T *fm;
@@ -210,12 +199,10 @@ void setpcmark(void)
   SET_XFMARK(fm, curwin->w_pcmark, curbuf->b_fnum, view, NULL);
 }
 
-/*
- * To change context, call setpcmark(), then move the current position to
- * where ever, then call checkpcmark().  This ensures that the previous
- * context will only be changed if the cursor moved to a different line.
- * If pcmark was deleted (with "dG") the previous mark is restored.
- */
+// To change context, call setpcmark(), then move the current position to
+// where ever, then call checkpcmark().  This ensures that the previous
+// context will only be changed if the cursor moved to a different line.
+// If pcmark was deleted (with "dG") the previous mark is restored.
 void checkpcmark(void)
 {
   if (curwin->w_prev_pcmark.lnum != 0
@@ -653,20 +640,16 @@ fmark_T *getnextmark(pos_T *startpos, int dir, int begin_line)
   return result;
 }
 
-/*
- * For an xtended filemark: set the fnum from the fname.
- * This is used for marks obtained from the .shada file.  It's postponed
- * until the mark is used to avoid a long startup delay.
- */
+// For an xtended filemark: set the fnum from the fname.
+// This is used for marks obtained from the .shada file.  It's postponed
+// until the mark is used to avoid a long startup delay.
 static void fname2fnum(xfmark_T *fm)
 {
   char_u *p;
 
   if (fm->fname != NULL) {
-    /*
-     * First expand "~/" in the file name to the home directory.
-     * Don't expand the whole name, it may contain other '~' chars.
-     */
+    // First expand "~/" in the file name to the home directory.
+    // Don't expand the whole name, it may contain other '~' chars.
     if (fm->fname[0] == '~' && (fm->fname[1] == '/'
 #ifdef BACKSLASH_IN_FILENAME
                                 || fm->fname[1] == '\\'
@@ -690,11 +673,9 @@ static void fname2fnum(xfmark_T *fm)
   }
 }
 
-/*
- * Check all file marks for a name that matches the file name in buf.
- * May replace the name with an fnum.
- * Used for marks that come from the .shada file.
- */
+// Check all file marks for a name that matches the file name in buf.
+// May replace the name with an fnum.
+// Used for marks that come from the .shada file.
 void fmarks_check_names(buf_T *buf)
 {
   char_u *name = (char_u *)buf->b_ffname;
@@ -792,11 +773,9 @@ void clrallmarks(buf_T *const buf)
   buf->b_changelistlen = 0;
 }
 
-/*
- * Get name of file from a filemark.
- * When it's in the current buffer, return the text at the mark.
- * Returns an allocated string.
- */
+// Get name of file from a filemark.
+// When it's in the current buffer, return the text at the mark.
+// Returns an allocated string.
 char_u *fm_getname(fmark_T *fmark, int lead_len)
 {
   if (fmark->fnum == curbuf->b_fnum) {              // current buffer
@@ -831,9 +810,7 @@ static char *mark_line(pos_T *mp, int lead_len)
   return s;
 }
 
-/*
- * print the marks
- */
+// print the marks
 void ex_marks(exarg_T *eap)
 {
   char_u *arg = (char_u *)eap->arg;
@@ -930,9 +907,7 @@ static void show_one_mark(int c, char_u *arg, pos_T *p, char_u *name_arg, int cu
   }
 }
 
-/*
- * ":delmarks[!] [marks]"
- */
+// ":delmarks[!] [marks]"
 void ex_delmarks(exarg_T *eap)
 {
   char_u *p;
@@ -1013,9 +988,7 @@ void ex_delmarks(exarg_T *eap)
   }
 }
 
-/*
- * print the jumplist
- */
+// print the jumplist
 void ex_jumps(exarg_T *eap)
 {
   int i;
@@ -1068,9 +1041,7 @@ void ex_clearjumps(exarg_T *eap)
   curwin->w_jumplistidx = 0;
 }
 
-/*
- * print the changelist
- */
+// print the changelist
 void ex_changes(exarg_T *eap)
 {
   int i;
@@ -1132,17 +1103,15 @@ void ex_changes(exarg_T *eap)
     *lp += amount_after; \
   }
 
-/*
- * Adjust marks between line1 and line2 (inclusive) to move 'amount' lines.
- * Must be called before changed_*(), appended_lines() or deleted_lines().
- * May be called before or after changing the text.
- * When deleting lines line1 to line2, use an 'amount' of MAXLNUM: The marks
- * within this range are made invalid.
- * If 'amount_after' is non-zero adjust marks after line2.
- * Example: Delete lines 34 and 35: mark_adjust(34, 35, MAXLNUM, -2);
- * Example: Insert two lines below 55: mark_adjust(56, MAXLNUM, 2, 0);
- *                                 or: mark_adjust(56, 55, MAXLNUM, 2);
- */
+// Adjust marks between line1 and line2 (inclusive) to move 'amount' lines.
+// Must be called before changed_*(), appended_lines() or deleted_lines().
+// May be called before or after changing the text.
+// When deleting lines line1 to line2, use an 'amount' of MAXLNUM: The marks
+// within this range are made invalid.
+// If 'amount_after' is non-zero adjust marks after line2.
+// Example: Delete lines 34 and 35: mark_adjust(34, 35, MAXLNUM, -2);
+// Example: Insert two lines below 55: mark_adjust(56, MAXLNUM, 2, 0);
+//                                 or: mark_adjust(56, 55, MAXLNUM, 2);
 void mark_adjust(linenr_T line1, linenr_T line2, linenr_T amount, linenr_T amount_after,
                  ExtmarkOp op)
 {
@@ -1237,9 +1206,7 @@ static void mark_adjust_internal(linenr_T line1, linenr_T line2, linenr_T amount
     ONE_ADJUST_NODEL(&(saved_cursor.lnum));
   }
 
-  /*
-   * Adjust items in all windows related to the current buffer.
-   */
+  // Adjust items in all windows related to the current buffer.
   FOR_ALL_TAB_WINDOWS(tab, win) {
     if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
       // Marks in the jumplist.  When deleting lines, this may create
@@ -1381,9 +1348,7 @@ void mark_col_adjust(linenr_T lnum, colnr_T mincol, linenr_T lnum_amount, long c
   // saved cursor for formatting
   COL_ADJUST(&saved_cursor);
 
-  /*
-   * Adjust items in all windows related to the current buffer.
-   */
+  // Adjust items in all windows related to the current buffer.
   FOR_ALL_WINDOWS_IN_TAB(win, curtab) {
     // marks in the jumplist
     for (i = 0; i < win->w_jumplistlen; i++) {
@@ -1481,9 +1446,7 @@ void cleanup_jumplist(win_T *wp, bool checktail)
   }
 }
 
-/*
- * Copy the jumplist from window "from" to window "to".
- */
+// Copy the jumplist from window "from" to window "to".
 void copy_jumplist(win_T *from, win_T *to)
 {
   int i;
@@ -1705,9 +1668,7 @@ bool mark_set_local(const char name, buf_T *const buf, const fmark_T fm, const b
   return true;
 }
 
-/*
- * Free items in the jumplist of window "wp".
- */
+// Free items in the jumplist of window "wp".
 void free_jumplist(win_T *wp)
 {
   int i;
diff --git a/src/nvim/mark_defs.h b/src/nvim/mark_defs.h
index a78056c5f9..3e3a46cd20 100644
--- a/src/nvim/mark_defs.h
+++ b/src/nvim/mark_defs.h
@@ -5,10 +5,8 @@
 #include "nvim/os/time.h"
 #include "nvim/pos.h"
 
-/*
- * marks: positions in a file
- * (a normal mark is a lnum/col pair, the same as a file position)
- */
+// marks: positions in a file
+// (a normal mark is a lnum/col pair, the same as a file position)
 
 /// Flags for outcomes when moving to a mark.
 typedef enum {
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 0a4182a892..116a66e773 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -132,10 +132,8 @@ const uint8_t utf8len_tab_zero[] = {
   4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 0, 0,  // F?
 };
 
-/*
- * Canonical encoding names and their properties.
- * "iso-8859-n" is handled by enc_canonize() directly.
- */
+// Canonical encoding names and their properties.
+// "iso-8859-n" is handled by enc_canonize() directly.
 static struct
 {   const char *name;   int prop;              int codepage; }
 enc_canon_table[] =
@@ -269,9 +267,7 @@ enc_canon_table[] =
 #define IDX_COUNT       59
 };
 
-/*
- * Aliases for encoding names.
- */
+// Aliases for encoding names.
 static struct
 {   const char *name; int canon; }
 enc_alias_table[] =
@@ -342,10 +338,8 @@ enc_alias_table[] =
   { NULL,              0 }
 };
 
-/*
- * Find encoding "name" in the list of canonical encoding names.
- * Returns -1 if not found.
- */
+// Find encoding "name" in the list of canonical encoding names.
+// Returns -1 if not found.
 static int enc_canon_search(const char_u *name)
   FUNC_ATTR_PURE
 {
@@ -357,10 +351,8 @@ static int enc_canon_search(const char_u *name)
   return -1;
 }
 
-/*
- * Find canonical encoding "name" in the list and return its properties.
- * Returns 0 if not found.
- */
+// Find canonical encoding "name" in the list and return its properties.
+// Returns 0 if not found.
 int enc_canon_props(const char_u *name)
   FUNC_ATTR_PURE
 {
@@ -375,13 +367,11 @@ int enc_canon_props(const char_u *name)
   return 0;
 }
 
-/*
- * Return the size of the BOM for the current buffer:
- * 0 - no BOM
- * 2 - UCS-2 or UTF-16 BOM
- * 4 - UCS-4 BOM
- * 3 - UTF-8 BOM
- */
+// Return the size of the BOM for the current buffer:
+// 0 - no BOM
+// 2 - UCS-2 or UTF-16 BOM
+// 4 - UCS-4 BOM
+// 3 - UTF-8 BOM
 int bomb_size(void)
   FUNC_ATTR_PURE
 {
@@ -401,9 +391,7 @@ int bomb_size(void)
   return n;
 }
 
-/*
- * Remove all BOM from "s" by moving remaining text.
- */
+// Remove all BOM from "s" by moving remaining text.
 void remove_bom(char_u *s)
 {
   char *p = (char *)s;
@@ -417,13 +405,11 @@ void remove_bom(char_u *s)
   }
 }
 
-/*
- * Get class of pointer:
- * 0 for blank or NUL
- * 1 for punctuation
- * 2 for an (ASCII) word character
- * >2 for other word characters
- */
+// Get class of pointer:
+// 0 for blank or NUL
+// 1 for punctuation
+// 2 for an (ASCII) word character
+// >2 for other word characters
 int mb_get_class(const char_u *p)
   FUNC_ATTR_PURE
 {
@@ -445,9 +431,7 @@ int mb_get_class_tab(const char_u *p, const uint64_t *const chartab)
   return utf_class_tab(utf_ptr2char((char *)p), chartab);
 }
 
-/*
- * Return true if "c" is in "table".
- */
+// Return true if "c" is in "table".
 static bool intable(const struct interval *table, size_t n_items, int c)
   FUNC_ATTR_PURE
 {
@@ -646,22 +630,20 @@ int utf_ptr2char(const char *const p_in)
   return p[0];
 }
 
-/*
- * Convert a UTF-8 byte sequence to a wide character.
- * String is assumed to be terminated by NUL or after "n" bytes, whichever
- * comes first.
- * The function is safe in the sense that it never accesses memory beyond the
- * first "n" bytes of "s".
- *
- * On success, returns decoded codepoint, advances "s" to the beginning of
- * next character and decreases "n" accordingly.
- *
- * If end of string was reached, returns 0 and, if "n" > 0, advances "s" past
- * NUL byte.
- *
- * If byte sequence is illegal or incomplete, returns -1 and does not advance
- * "s".
- */
+// Convert a UTF-8 byte sequence to a wide character.
+// String is assumed to be terminated by NUL or after "n" bytes, whichever
+// comes first.
+// The function is safe in the sense that it never accesses memory beyond the
+// first "n" bytes of "s".
+//
+// On success, returns decoded codepoint, advances "s" to the beginning of
+// next character and decreases "n" accordingly.
+//
+// If end of string was reached, returns 0 and, if "n" > 0, advances "s" past
+// NUL byte.
+//
+// If byte sequence is illegal or incomplete, returns -1 and does not advance
+// "s".
 static int utf_safe_read_char_adv(const char_u **s, size_t *n)
 {
   int c;
@@ -701,10 +683,8 @@ static int utf_safe_read_char_adv(const char_u **s, size_t *n)
   return -1;
 }
 
-/*
- * Get character at **pp and advance *pp to the next character.
- * Note: composing characters are skipped!
- */
+// Get character at **pp and advance *pp to the next character.
+// Note: composing characters are skipped!
 int mb_ptr2char_adv(const char_u **const pp)
 {
   int c;
@@ -714,10 +694,8 @@ int mb_ptr2char_adv(const char_u **const pp)
   return c;
 }
 
-/*
- * Get character at **pp and advance *pp to the next character.
- * Note: composing characters are returned as separate characters.
- */
+// Get character at **pp and advance *pp to the next character.
+// Note: composing characters are returned as separate characters.
 int mb_cptr2char_adv(const char_u **pp)
 {
   int c;
@@ -784,12 +762,10 @@ int utfc_ptr2char(const char *p_in, int *pcc)
   return c;
 }
 
-/*
- * Convert a UTF-8 byte string to a wide character.  Also get up to MAX_MCO
- * composing characters.  Use no more than p[maxlen].
- *
- * @param [out] pcc: composing chars, last one is 0
- */
+// Convert a UTF-8 byte string to a wide character.  Also get up to MAX_MCO
+// composing characters.  Use no more than p[maxlen].
+//
+// @param [out] pcc: composing chars, last one is 0
 int utfc_ptr2char_len(const char_u *p, int *pcc, int maxlen)
 {
   assert(maxlen > 0);
@@ -845,24 +821,20 @@ int utf_ptr2len(const char *const p_in)
   return len;
 }
 
-/*
- * Return length of UTF-8 character, obtained from the first byte.
- * "b" must be between 0 and 255!
- * Returns 1 for an invalid first byte value.
- */
+// Return length of UTF-8 character, obtained from the first byte.
+// "b" must be between 0 and 255!
+// Returns 1 for an invalid first byte value.
 int utf_byte2len(int b)
 {
   return utf8len_tab[b];
 }
 
-/*
- * Get the length of UTF-8 byte sequence "p[size]".  Does not include any
- * following composing characters.
- * Returns 1 for "".
- * Returns 1 for an illegal byte sequence (also in incomplete byte seq.).
- * Returns number > "size" for an incomplete byte sequence.
- * Never returns zero.
- */
+// Get the length of UTF-8 byte sequence "p[size]".  Does not include any
+// following composing characters.
+// Returns 1 for "".
+// Returns 1 for an illegal byte sequence (also in incomplete byte seq.).
+// Returns number > "size" for an incomplete byte sequence.
+// Never returns zero.
 int utf_ptr2len_len(const char_u *p, int size)
 {
   int len;
@@ -948,10 +920,8 @@ int utfc_ptr2len_len(const char *p, int size)
     return 1;
   }
 
-  /*
-   * Check for composing characters.  We can handle only the first six, but
-   * skip all of them (otherwise the cursor would get stuck).
-   */
+  // Check for composing characters.  We can handle only the first six, but
+  // skip all of them (otherwise the cursor would get stuck).
   prevlen = 0;
   while (len < size) {
     int len_next_char;
@@ -960,10 +930,8 @@ int utfc_ptr2len_len(const char *p, int size)
       break;
     }
 
-    /*
-     * Next character length should not go beyond size to ensure that
-     * utf_composinglike(...) does not read beyond size.
-     */
+    // Next character length should not go beyond size to ensure that
+    // utf_composinglike(...) does not read beyond size.
     len_next_char = utf_ptr2len_len((char_u *)p + len, size - len);
     if (len_next_char > size - len) {
       break;
@@ -1042,20 +1010,16 @@ int utf_char2bytes(const int c, char *const buf)
   }
 }
 
-/*
- * Return true if "c" is a composing UTF-8 character.  This means it will be
- * drawn on top of the preceding character.
- * Based on code from Markus Kuhn.
- */
+// Return true if "c" is a composing UTF-8 character.  This means it will be
+// drawn on top of the preceding character.
+// Based on code from Markus Kuhn.
 bool utf_iscomposing(int c)
 {
   return intable(combining, ARRAY_SIZE(combining), c);
 }
 
-/*
- * Return true for characters that can be displayed in a normal way.
- * Only for characters of 0x100 and above!
- */
+// Return true for characters that can be displayed in a normal way.
+// Only for characters of 0x100 and above!
 bool utf_printable(int c)
 {
   // Sorted list of non-overlapping intervals.
@@ -1070,12 +1034,10 @@ bool utf_printable(int c)
   return !intable(nonprint, ARRAY_SIZE(nonprint), c);
 }
 
-/*
- * Get class of a Unicode character.
- * 0: white space
- * 1: punctuation
- * 2 or bigger: some class of word character.
- */
+// Get class of a Unicode character.
+// 0: white space
+// 1: punctuation
+// 2 or bigger: some class of word character.
 int utf_class(const int c)
 {
   return utf_class_tab(c, curbuf->b_chartab);
@@ -1204,11 +1166,9 @@ bool utf_ambiguous_width(int c)
                        || intable(emoji_all, ARRAY_SIZE(emoji_all), c));
 }
 
-/*
- * Generic conversion function for case operations.
- * Return the converted equivalent of "a", which is a UCS-4 character.  Use
- * the given conversion "table".  Uses binary search on "table".
- */
+// Generic conversion function for case operations.
+// Return the converted equivalent of "a", which is a UCS-4 character.  Use
+// the given conversion "table".  Uses binary search on "table".
 static int utf_convert(int a, const convertStruct *const table, size_t n_items)
 {
   size_t start, mid, end;   // indices into table
@@ -1234,10 +1194,8 @@ static int utf_convert(int a, const convertStruct *const table, size_t n_items)
   }
 }
 
-/*
- * Return the folded-case equivalent of "a", which is a UCS-4 character.  Uses
- * simple case folding.
- */
+// Return the folded-case equivalent of "a", which is a UCS-4 character.  Uses
+// simple case folding.
 int utf_fold(int a)
 {
   if (a < 0x80) {
@@ -1566,10 +1524,8 @@ int mb_stricmp(const char *s1, const char *s2)
   return mb_strnicmp(s1, s2, MAXCOL);
 }
 
-/*
- * "g8": show bytes of the UTF-8 char under the cursor.  Doesn't matter what
- * 'encoding' has been set to.
- */
+// "g8": show bytes of the UTF-8 char under the cursor.  Doesn't matter what
+// 'encoding' has been set to.
 void show_utf8(void)
 {
   int len;
@@ -1916,9 +1872,7 @@ int utf_cp_head_off(const char_u *base, const char_u *p)
   return i;
 }
 
-/*
- * Find the next illegal byte sequence.
- */
+// Find the next illegal byte sequence.
 void utf_find_illegal(void)
 {
   pos_T pos = curwin->w_cursor;
@@ -2008,10 +1962,8 @@ bool utf_valid_string(const char_u *s, const char_u *end)
   return true;
 }
 
-/*
- * If the cursor moves on an trail byte, set the cursor on the lead byte.
- * Thus it moves left if necessary.
- */
+// If the cursor moves on an trail byte, set the cursor on the lead byte.
+// Thus it moves left if necessary.
 void mb_adjust_cursor(void)
 {
   mark_mb_adjustpos(curbuf, &curwin->w_cursor);
@@ -2238,10 +2190,8 @@ static int enc_alias_search(const char_u *name)
 # include <langinfo.h>
 #endif
 
-/*
- * Get the canonicalized encoding of the current locale.
- * Returns an allocated string when successful, NULL when not.
- */
+// Get the canonicalized encoding of the current locale.
+// Returns an allocated string when successful, NULL when not.
 char_u *enc_locale(void)
 {
   int i;
@@ -2307,12 +2257,10 @@ enc_locale_copy_enc:
 
 #if defined(HAVE_ICONV)
 
-/*
- * Call iconv_open() with a check if iconv() works properly (there are broken
- * versions).
- * Returns (void *)-1 if failed.
- * (should return iconv_t, but that causes problems with prototypes).
- */
+// Call iconv_open() with a check if iconv() works properly (there are broken
+// versions).
+// Returns (void *)-1 if failed.
+// (should return iconv_t, but that causes problems with prototypes).
 void *my_iconv_open(char_u *to, char_u *from)
 {
   iconv_t fd;
@@ -2328,13 +2276,11 @@ void *my_iconv_open(char_u *to, char_u *from)
   fd = iconv_open(enc_skip((char *)to), enc_skip((char *)from));
 
   if (fd != (iconv_t)-1 && iconv_working == kUnknown) {
-    /*
-     * Do a dummy iconv() call to check if it actually works.  There is a
-     * version of iconv() on Linux that is broken.  We can't ignore it,
-     * because it's wide-spread.  The symptoms are that after outputting
-     * the initial shift state the "to" pointer is NULL and conversion
-     * stops for no apparent reason after about 8160 characters.
-     */
+    // Do a dummy iconv() call to check if it actually works.  There is a
+    // version of iconv() on Linux that is broken.  We can't ignore it,
+    // because it's wide-spread.  The symptoms are that after outputting
+    // the initial shift state the "to" pointer is NULL and conversion
+    // stops for no apparent reason after about 8160 characters.
     p = (char *)tobuf;
     tolen = ICONV_TESTLEN;
     (void)iconv(fd, NULL, NULL, &p, &tolen);
@@ -2350,13 +2296,11 @@ void *my_iconv_open(char_u *to, char_u *from)
   return (void *)fd;
 }
 
-/*
- * Convert the string "str[slen]" with iconv().
- * If "unconvlenp" is not NULL handle the string ending in an incomplete
- * sequence and set "*unconvlenp" to the length of it.
- * Returns the converted string in allocated memory.  NULL for an error.
- * If resultlenp is not NULL, sets it to the result length in bytes.
- */
+// Convert the string "str[slen]" with iconv().
+// If "unconvlenp" is not NULL handle the string ending in an incomplete
+// sequence and set "*unconvlenp" to the length of it.
+// Returns the converted string in allocated memory.  NULL for an error.
+// If resultlenp is not NULL, sets it to the result length in bytes.
 static char_u *iconv_string(const vimconv_T *const vcp, char_u *str, size_t slen,
                             size_t *unconvlenp, size_t *resultlenp)
 {
@@ -2529,11 +2473,9 @@ char *string_convert(const vimconv_T *const vcp, char *ptr, size_t *lenp)
   return (char *)string_convert_ext(vcp, (char_u *)ptr, lenp, NULL);
 }
 
-/*
- * Like string_convert(), but when "unconvlenp" is not NULL and there are is
- * an incomplete sequence at the end it is not converted and "*unconvlenp" is
- * set to the number of remaining bytes.
- */
+// Like string_convert(), but when "unconvlenp" is not NULL and there are is
+// an incomplete sequence at the end it is not converted and "*unconvlenp" is
+// set to the number of remaining bytes.
 char_u *string_convert_ext(const vimconv_T *const vcp, char_u *ptr, size_t *lenp,
                            size_t *unconvlenp)
 {
diff --git a/src/nvim/mbyte.h b/src/nvim/mbyte.h
index 2a9afcbd03..b499f33cc6 100644
--- a/src/nvim/mbyte.h
+++ b/src/nvim/mbyte.h
@@ -11,12 +11,10 @@
 #include "nvim/os/os_defs.h"  // For indirect
 #include "nvim/types.h"  // for char_u
 
-/*
- * Return byte length of character that starts with byte "b".
- * Returns 1 for a single-byte character.
- * MB_BYTE2LEN_CHECK() can be used to count a special key as one byte.
- * Don't call MB_BYTE2LEN(b) with b < 0 or b > 255!
- */
+// Return byte length of character that starts with byte "b".
+// Returns 1 for a single-byte character.
+// MB_BYTE2LEN_CHECK() can be used to count a special key as one byte.
+// Don't call MB_BYTE2LEN(b) with b < 0 or b > 255!
 #define MB_BYTE2LEN(b)         utf8len_tab[b]
 #define MB_BYTE2LEN_CHECK(b)   (((b) < 0 || (b) > 255) ? 1 : utf8len_tab[b])
 
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index cd143bd52c..35650755b4 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -5,36 +5,34 @@
 // #define CHECK(c, s) do { if (c) emsg(s); } while (0)
 #define CHECK(c, s) do {} while (0)
 
-/*
- * memline.c: Contains the functions for appending, deleting and changing the
- * text lines. The memfile functions are used to store the information in
- * blocks of memory, backed up by a file. The structure of the information is
- * a tree.  The root of the tree is a pointer block. The leaves of the tree
- * are data blocks. In between may be several layers of pointer blocks,
- * forming branches.
- *
- * Three types of blocks are used:
- * - Block nr 0 contains information for recovery
- * - Pointer blocks contain list of pointers to other blocks.
- * - Data blocks contain the actual text.
- *
- * Block nr 0 contains the block0 structure (see below).
- *
- * Block nr 1 is the first pointer block. It is the root of the tree.
- * Other pointer blocks are branches.
- *
- *  If a line is too big to fit in a single page, the block containing that
- *  line is made big enough to hold the line. It may span several pages.
- *  Otherwise all blocks are one page.
- *
- *  A data block that was filled when starting to edit a file and was not
- *  changed since then, can have a negative block number. This means that it
- *  has not yet been assigned a place in the file. When recovering, the lines
- *  in this data block can be read from the original file. When the block is
- *  changed (lines appended/deleted/changed) or when it is flushed it gets a
- *  positive number. Use mf_trans_del() to get the new number, before calling
- *  mf_get().
- */
+// memline.c: Contains the functions for appending, deleting and changing the
+// text lines. The memfile functions are used to store the information in
+// blocks of memory, backed up by a file. The structure of the information is
+// a tree.  The root of the tree is a pointer block. The leaves of the tree
+// are data blocks. In between may be several layers of pointer blocks,
+// forming branches.
+//
+// Three types of blocks are used:
+// - Block nr 0 contains information for recovery
+// - Pointer blocks contain list of pointers to other blocks.
+// - Data blocks contain the actual text.
+//
+// Block nr 0 contains the block0 structure (see below).
+//
+// Block nr 1 is the first pointer block. It is the root of the tree.
+// Other pointer blocks are branches.
+//
+//  If a line is too big to fit in a single page, the block containing that
+//  line is made big enough to hold the line. It may span several pages.
+//  Otherwise all blocks are one page.
+//
+//  A data block that was filled when starting to edit a file and was not
+//  changed since then, can have a negative block number. This means that it
+//  has not yet been assigned a place in the file. When recovering, the lines
+//  in this data block can be read from the original file. When the block is
+//  changed (lines appended/deleted/changed) or when it is flushed it gets a
+//  positive number. Use mf_trans_del() to get the new number, before calling
+//  mf_get().
 
 #include <assert.h>
 #include <errno.h>
@@ -90,9 +88,7 @@ typedef struct pointer_entry PTR_EN;        // block/line-count pair
 #define BLOCK0_ID0     'b'                  // block 0 id 0
 #define BLOCK0_ID1     '0'                  // block 0 id 1
 
-/*
- * pointer to a block, used in a pointer block
- */
+// pointer to a block, used in a pointer block
 struct pointer_entry {
   blocknr_T pe_bnum;            // block number
   linenr_T pe_line_count;       // number of lines in this branch
@@ -100,9 +96,7 @@ struct pointer_entry {
   int pe_page_count;            // number of pages in block pe_bnum
 };
 
-/*
- * A pointer block contains a list of branches in the tree.
- */
+// A pointer block contains a list of branches in the tree.
 struct pointer_block {
   uint16_t pb_id;               // ID for pointer block: PTR_ID
   uint16_t pb_count;            // number of pointers in this block
@@ -111,13 +105,11 @@ struct pointer_block {
                                 // followed by empty space until end of page
 };
 
-/*
- * A data block is a leaf in the tree.
- *
- * The text of the lines is at the end of the block. The text of the first line
- * in the block is put at the end, the text of the second line in front of it,
- * etc. Thus the order of the lines is the opposite of the line number.
- */
+// A data block is a leaf in the tree.
+//
+// The text of the lines is at the end of the block. The text of the first line
+// in the block is put at the end, the text of the second line in front of it,
+// etc. Thus the order of the lines is the opposite of the line number.
 struct data_block {
   uint16_t db_id;               // ID for data block: DATA_ID
   unsigned db_free;             // free space available
@@ -130,14 +122,12 @@ struct data_block {
                                 // end of page
 };
 
-/*
- * The low bits of db_index hold the actual index. The topmost bit is
- * used for the global command to be able to mark a line.
- * This method is not clean, but otherwise there would be at least one extra
- * byte used for each line.
- * The mark has to be in this place to keep it with the correct line when other
- * lines are inserted or deleted.
- */
+// The low bits of db_index hold the actual index. The topmost bit is
+// used for the global command to be able to mark a line.
+// This method is not clean, but otherwise there would be at least one extra
+// byte used for each line.
+// The mark has to be in this place to keep it with the correct line when other
+// lines are inserted or deleted.
 #define DB_MARKED       ((unsigned)1 << ((sizeof(unsigned) * 8) - 1))
 #define DB_INDEX_MASK   (~DB_MARKED)
 
@@ -149,28 +139,24 @@ struct data_block {
 #define B0_FNAME_SIZE_CRYPT     890     // 10 bytes used for other things
 #define B0_UNAME_SIZE           40
 #define B0_HNAME_SIZE           40
-/*
- * Restrict the numbers to 32 bits, otherwise most compilers will complain.
- * This won't detect a 64 bit machine that only swaps a byte in the top 32
- * bits, but that is crazy anyway.
- */
+// Restrict the numbers to 32 bits, otherwise most compilers will complain.
+// This won't detect a 64 bit machine that only swaps a byte in the top 32
+// bits, but that is crazy anyway.
 #define B0_MAGIC_LONG   0x30313233L
 #define B0_MAGIC_INT    0x20212223L
 #define B0_MAGIC_SHORT  0x10111213L
 #define B0_MAGIC_CHAR   0x55
 
-/*
- * Block zero holds all info about the swap file.
- *
- * NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing
- * swap files unusable!
- *
- * If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!!
- *
- * This block is built up of single bytes, to make it portable across
- * different machines. b0_magic_* is used to check the byte order and size of
- * variables, because the rest of the swap file is not portable.
- */
+// Block zero holds all info about the swap file.
+//
+// NOTE: DEFINITION OF BLOCK 0 SHOULD NOT CHANGE! It would make all existing
+// swap files unusable!
+//
+// If size of block0 changes anyway, adjust MIN_SWAP_PAGE_SIZE in vim.h!!
+//
+// This block is built up of single bytes, to make it portable across
+// different machines. b0_magic_* is used to check the byte order and size of
+// variables, because the rest of the swap file is not portable.
 struct block0 {
   char_u b0_id[2];              ///< ID for block 0: BLOCK0_ID0 and BLOCK0_ID1.
   char_u b0_version[10];        // Vim version string
@@ -187,18 +173,14 @@ struct block0 {
   char_u b0_magic_char;         // check for last char
 };
 
-/*
- * Note: b0_dirty and b0_flags are put at the end of the file name.  For very
- * long file names in older versions of Vim they are invalid.
- * The 'fileencoding' comes before b0_flags, with a NUL in front.  But only
- * when there is room, for very long file names it's omitted.
- */
+// Note: b0_dirty and b0_flags are put at the end of the file name.  For very
+// long file names in older versions of Vim they are invalid.
+// The 'fileencoding' comes before b0_flags, with a NUL in front.  But only
+// when there is room, for very long file names it's omitted.
 #define B0_DIRTY        0x55
 #define b0_dirty        b0_fname[B0_FNAME_SIZE_ORG - 1]
 
-/*
- * The b0_flags field is new in Vim 7.0.
- */
+// The b0_flags field is new in Vim 7.0.
 #define b0_flags        b0_fname[B0_FNAME_SIZE_ORG - 2]
 
 // The lowest two bits contain the fileformat.  Zero means it's not set
@@ -216,17 +198,13 @@ struct block0 {
 
 #define STACK_INCR      5       // nr of entries added to ml_stack at a time
 
-/*
- * The line number where the first mark may be is remembered.
- * If it is 0 there are no marks at all.
- * (always used for the current buffer only, no buffer change possible while
- * executing a global command).
- */
+// The line number where the first mark may be is remembered.
+// If it is 0 there are no marks at all.
+// (always used for the current buffer only, no buffer change possible while
+// executing a global command).
 static linenr_T lowest_marked = 0;
 
-/*
- * arguments for ml_find_line()
- */
+// arguments for ml_find_line()
 #define ML_DELETE       0x11        // delete line
 #define ML_INSERT       0x12        // insert line
 #define ML_FIND         0x13        // just find the line
@@ -253,9 +231,7 @@ int ml_open(buf_T *buf)
   PTR_BL *pp;
   DATA_BL *dp;
 
-  /*
-   * init fields in memline struct
-   */
+  // init fields in memline struct
   buf->b_ml.ml_stack_size = 0;   // no stack yet
   buf->b_ml.ml_stack = NULL;    // no stack yet
   buf->b_ml.ml_stack_top = 0;   // nothing in the stack
@@ -269,9 +245,7 @@ int ml_open(buf_T *buf)
     buf->b_p_swf = false;
   }
 
-  /*
-   * When 'updatecount' is non-zero swap file may be opened later.
-   */
+  // When 'updatecount' is non-zero swap file may be opened later.
   if (!buf->terminal && p_uc && buf->b_p_swf) {
     buf->b_may_swap = true;
   } else {
@@ -289,9 +263,7 @@ int ml_open(buf_T *buf)
   buf->b_ml.ml_line_count = 1;
   curwin->w_nrwidth_line_count = 0;
 
-  /*
-   * fill block0 struct and write page 0
-   */
+  // fill block0 struct and write page 0
   hp = mf_new(mfp, false, 1);
   if (hp->bh_bnum != 0) {
     iemsg(_("E298: Didn't get block nr 0?"));
@@ -319,21 +291,17 @@ int ml_open(buf_T *buf)
     long_to_char(os_get_pid(), b0p->b0_pid);
   }
 
-  /*
-   * Always sync block number 0 to disk, so we can check the file name in
-   * the swap file in findswapname(). Don't do this for a help files or
-   * a spell buffer though.
-   * Only works when there's a swapfile, otherwise it's done when the file
-   * is created.
-   */
+  // Always sync block number 0 to disk, so we can check the file name in
+  // the swap file in findswapname(). Don't do this for a help files or
+  // a spell buffer though.
+  // Only works when there's a swapfile, otherwise it's done when the file
+  // is created.
   mf_put(mfp, hp, true, false);
   if (!buf->b_help && !B_SPELL(buf)) {
     (void)mf_sync(mfp, 0);
   }
 
-  /*
-   * Fill in root pointer block and write page 1.
-   */
+  // Fill in root pointer block and write page 1.
   if ((hp = ml_new_ptr(mfp)) == NULL) {
     goto error;
   }
@@ -349,9 +317,7 @@ int ml_open(buf_T *buf)
   pp->pb_pointer[0].pe_line_count = 1;      // line count after insertion
   mf_put(mfp, hp, true, false);
 
-  /*
-   * Allocate first data block and create an empty line 1.
-   */
+  // Allocate first data block and create an empty line 1.
   hp = ml_new_data(mfp, false, 1);
   if (hp->bh_bnum != 2) {
     iemsg(_("E298: Didn't get block nr 2?"));
@@ -388,10 +354,8 @@ void ml_setname(buf_T *buf)
 
   mfp = buf->b_ml.ml_mfp;
   if (mfp->mf_fd < 0) {             // there is no swap file yet
-    /*
-     * When 'updatecount' is 0 and 'noswapfile' there is no swap file.
-     * For help files we will make a swap file now.
-     */
+    // When 'updatecount' is 0 and 'noswapfile' there is no swap file.
+    // For help files we will make a swap file now.
     if (p_uc != 0 && (cmdmod.cmod_flags & CMOD_NOSWAPFILE) == 0) {
       ml_open_file(buf);  // create a swap file
     }
@@ -653,13 +617,11 @@ static void set_b0_fname(ZERO_BL *b0p, buf_T *buf)
   } else {
     char uname[B0_UNAME_SIZE];
 
-    /*
-     * For a file under the home directory of the current user, we try to
-     * replace the home directory path with "~user". This helps when
-     * editing the same file on different machines over a network.
-     * First replace home dir path with "~/" with home_replace().
-     * Then insert the user name to get "~user/".
-     */
+    // For a file under the home directory of the current user, we try to
+    // replace the home directory path with "~user". This helps when
+    // editing the same file on different machines over a network.
+    // First replace home dir path with "~/" with home_replace().
+    // Then insert the user name to get "~user/".
     home_replace(NULL, buf->b_ffname, (char *)b0p->b0_fname,
                  B0_FNAME_SIZE_CRYPT, true);
     if (b0p->b0_fname[0] == '~') {
@@ -813,15 +775,11 @@ void ml_recover(bool checkext)
     getout(1);
   }
 
-  /*
-   * Allocate a buffer structure for the swap file that is used for recovery.
-   * Only the memline in it is really used.
-   */
+  // Allocate a buffer structure for the swap file that is used for recovery.
+  // Only the memline in it is really used.
   buf = xmalloc(sizeof(buf_T));
 
-  /*
-   * init fields in memline struct
-   */
+  // init fields in memline struct
   buf->b_ml.ml_stack_size = 0;          // no stack yet
   buf->b_ml.ml_stack = NULL;            // no stack yet
   buf->b_ml.ml_stack_top = 0;           // nothing in the stack
@@ -830,9 +788,7 @@ void ml_recover(bool checkext)
   buf->b_ml.ml_locked = NULL;           // no locked block
   buf->b_ml.ml_flags = 0;
 
-  /*
-   * open the memfile from the old swap file
-   */
+  // open the memfile from the old swap file
   p = xstrdup(fname_used);  // save "fname_used" for the message:
   // mf_open() will consume "fname_used"!
   mfp = mf_open(fname_used, O_RDONLY);
@@ -843,17 +799,13 @@ void ml_recover(bool checkext)
   }
   buf->b_ml.ml_mfp = mfp;
 
-  /*
-   * The page size set in mf_open() might be different from the page size
-   * used in the swap file, we must get it from block 0.  But to read block
-   * 0 we need a page size.  Use the minimal size for block 0 here, it will
-   * be set to the real value below.
-   */
+  // The page size set in mf_open() might be different from the page size
+  // used in the swap file, we must get it from block 0.  But to read block
+  // 0 we need a page size.  Use the minimal size for block 0 here, it will
+  // be set to the real value below.
   mfp->mf_page_size = MIN_SWAP_PAGE_SIZE;
 
-  /*
-   * try to read block 0
-   */
+  // try to read block 0
   if ((hp = mf_get(mfp, 0, 1)) == NULL) {
     msg_start();
     msg_puts_attr(_("Unable to read block 0 from "), attr | MSG_HIST);
@@ -891,10 +843,8 @@ void ml_recover(bool checkext)
     goto theend;
   }
 
-  /*
-   * If we guessed the wrong page size, we have to recalculate the
-   * highest block number in the file.
-   */
+  // If we guessed the wrong page size, we have to recalculate the
+  // highest block number in the file.
   if (mfp->mf_page_size != (unsigned)char_to_long(b0p->b0_page_size)) {
     unsigned previous_page_size = mfp->mf_page_size;
 
@@ -941,9 +891,7 @@ void ml_recover(bool checkext)
   smsg(_("Original file \"%s\""), NameBuff);
   msg_putchar('\n');
 
-  /*
-   * check date of swap file and original file
-   */
+  // check date of swap file and original file
   FileInfo org_file_info;
   FileInfo swp_file_info;
   mtime = char_to_long(b0p->b0_mtime);
@@ -969,18 +917,14 @@ void ml_recover(bool checkext)
   mf_put(mfp, hp, false, false);        // release block 0
   hp = NULL;
 
-  /*
-   * Now that we are sure that the file is going to be recovered, clear the
-   * contents of the current buffer.
-   */
+  // Now that we are sure that the file is going to be recovered, clear the
+  // contents of the current buffer.
   while (!(curbuf->b_ml.ml_flags & ML_EMPTY)) {
     ml_delete((linenr_T)1, false);
   }
 
-  /*
-   * Try reading the original file to obtain the values of 'fileformat',
-   * 'fileencoding', etc.  Ignore errors.  The text itself is not used.
-   */
+  // Try reading the original file to obtain the values of 'fileformat',
+  // 'fileencoding', etc.  Ignore errors.  The text itself is not used.
   if (curbuf->b_ffname != NULL) {
     orig_file_status = readfile(curbuf->b_ffname, NULL, (linenr_T)0,
                                 (linenr_T)0, (linenr_T)MAXLNUM, NULL, READ_NEW, false);
@@ -1017,9 +961,7 @@ void ml_recover(bool checkext)
     if (hp != NULL) {
       mf_put(mfp, hp, false, false);            // release previous block
     }
-    /*
-     * get block
-     */
+    // get block
     if ((hp = mf_get(mfp, bnum, page_count)) == NULL) {
       if (bnum == 1) {
         semsg(_("E309: Unable to read block 1 from %s"), mfp->mf_fname);
@@ -1049,11 +991,9 @@ void ml_recover(bool checkext)
           error++;
         } else if (idx < (int)pp->pb_count) {         // go a block deeper
           if (pp->pb_pointer[idx].pe_bnum < 0) {
-            /*
-             * Data block with negative block number.
-             * Try to read lines from the original file.
-             * This is slow, but it works.
-             */
+            // Data block with negative block number.
+            // Try to read lines from the original file.
+            // This is slow, but it works.
             if (!cannot_open) {
               line_count = pp->pb_pointer[idx].pe_line_count;
               if (readfile(curbuf->b_ffname, NULL, lnum,
@@ -1073,9 +1013,7 @@ void ml_recover(bool checkext)
             continue;
           }
 
-          /*
-           * going one block deeper in the tree
-           */
+          // going one block deeper in the tree
           top = ml_add_stack(buf);  // new entry in stack
           ip = &(buf->b_ml.ml_stack[top]);
           ip->ip_bnum = bnum;
@@ -1116,10 +1054,8 @@ void ml_recover(bool checkext)
           // make sure there is a NUL at the end of the block
           *((char_u *)dp + dp->db_txt_end - 1) = NUL;
 
-          /*
-           * check number of lines in block
-           * if wrong, use count in data block
-           */
+          // check number of lines in block
+          // if wrong, use count in data block
           if (line_count != dp->db_line_count) {
             ml_append(lnum++,
                       _("??? from here until ???END lines"
@@ -1151,22 +1087,18 @@ void ml_recover(bool checkext)
       break;
     }
 
-    /*
-     * go one block up in the tree
-     */
+    // go one block up in the tree
     ip = &(buf->b_ml.ml_stack[--(buf->b_ml.ml_stack_top)]);
     bnum = ip->ip_bnum;
     idx = ip->ip_index + 1;         // go to next index
     page_count = 1;
   }
 
-  /*
-   * Compare the buffer contents with the original file.  When they differ
-   * set the 'modified' flag.
-   * Lines 1 - lnum are the new contents.
-   * Lines lnum + 1 to ml_line_count are the original contents.
-   * Line ml_line_count + 1 in the dummy empty line.
-   */
+  // Compare the buffer contents with the original file.  When they differ
+  // set the 'modified' flag.
+  // Lines 1 - lnum are the new contents.
+  // Lines lnum + 1 to ml_line_count are the original contents.
+  // Line ml_line_count + 1 in the dummy empty line.
   if (orig_file_status != OK || curbuf->b_ml.ml_line_count != lnum * 2 + 1) {
     // Recovering an empty file results in two lines and the first line is
     // empty.  Don't set the modified flag then.
@@ -1188,10 +1120,8 @@ void ml_recover(bool checkext)
     }
   }
 
-  /*
-   * Delete the lines from the original file and the dummy line from the
-   * empty buffer.  These will now be after the last line in the buffer.
-   */
+  // Delete the lines from the original file and the dummy line from the
+  // empty buffer.  These will now be after the last line in the buffer.
   while (curbuf->b_ml.ml_line_count > lnum
          && !(curbuf->b_ml.ml_flags & ML_EMPTY)) {
     ml_delete(curbuf->b_ml.ml_line_count, false);
@@ -1343,11 +1273,9 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
       num_files = 0;
     }
 
-    /*
-     * When no swap file found, wildcard expansion might have failed (e.g.
-     * not able to execute the shell).
-     * Try finding a swap file by simply adding ".swp" to the file name.
-     */
+    // When no swap file found, wildcard expansion might have failed (e.g.
+    // not able to execute the shell).
+    // Try finding a swap file by simply adding ".swp" to the file name.
     if (*dirp == NUL && file_count + num_files == 0 && fname != NULL) {
       char_u *swapname = (char_u *)modname((char *)fname_res, ".swp", true);
       if (swapname != NULL) {
@@ -1361,9 +1289,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
       }
     }
 
-    /*
-     * remove swapfile name of the current buffer, it must be ignored
-     */
+    // remove swapfile name of the current buffer, it must be ignored
     if (curbuf->b_ml.ml_mfp != NULL
         && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL) {
       for (int i = 0; i < num_files; i++) {
@@ -1522,9 +1448,7 @@ static time_t swapfile_info(char_u *fname)
     msg_puts(os_ctime_r(&x, ctime_buf, sizeof(ctime_buf)));
   }
 
-  /*
-   * print the original file name
-   */
+  // print the original file name
   fd = os_open((char *)fname, O_RDONLY, 0);
   if (fd >= 0) {
     if (read_eintr(fd, &b0, sizeof(b0)) == sizeof(b0)) {
@@ -1681,10 +1605,8 @@ void ml_sync_all(int check_file, int check_char, bool do_fsync)
     (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);
     if (bufIsChanged(buf) && check_file && mf_need_trans(buf->b_ml.ml_mfp)
         && buf->b_ffname != NULL) {
-      /*
-       * If the original file does not exist anymore or has been changed
-       * call ml_preserve() to get rid of all negative numbered blocks.
-       */
+      // If the original file does not exist anymore or has been changed
+      // call ml_preserve() to get rid of all negative numbered blocks.
       FileInfo file_info;
       if (!os_fileinfo(buf->b_ffname, &file_info)
           || file_info.stat.st_mtim.tv_sec != buf->b_mtime_read
@@ -1739,18 +1661,16 @@ void ml_preserve(buf_T *buf, int message, bool do_fsync)
   // stack is invalid after mf_sync(.., MFS_ALL)
   buf->b_ml.ml_stack_top = 0;
 
-  /*
-   * Some of the data blocks may have been changed from negative to
-   * positive block number. In that case the pointer blocks need to be
-   * updated.
-   *
-   * We don't know in which pointer block the references are, so we visit
-   * all data blocks until there are no more translations to be done (or
-   * we hit the end of the file, which can only happen in case a write fails,
-   * e.g. when file system if full).
-   * ml_find_line() does the work by translating the negative block numbers
-   * when getting the first line of each data block.
-   */
+  // Some of the data blocks may have been changed from negative to
+  // positive block number. In that case the pointer blocks need to be
+  // updated.
+  //
+  // We don't know in which pointer block the references are, so we visit
+  // all data blocks until there are no more translations to be done (or
+  // we hit the end of the file, which can only happen in case a write fails,
+  // e.g. when file system if full).
+  // ml_find_line() does the work by translating the negative block numbers
+  // when getting the first line of each data block.
   if (mf_need_trans(mfp) && !got_int) {
     lnum = 1;
     while (mf_need_trans(mfp) && lnum <= buf->b_ml.ml_line_count) {
@@ -1781,13 +1701,11 @@ theend:
   }
 }
 
-/*
- * NOTE: The pointer returned by the ml_get_*() functions only remains valid
- * until the next call!
- *  line1 = ml_get(1);
- *  line2 = ml_get(2);  // line1 is now invalid!
- * Make a copy of the line if necessary.
- */
+// NOTE: The pointer returned by the ml_get_*() functions only remains valid
+// until the next call!
+//  line1 = ml_get(1);
+//  line2 = ml_get(2);  // line1 is now invalid!
+// Make a copy of the line if necessary.
 
 /// @return  a pointer to a (read-only copy of a) line.
 ///
@@ -1851,20 +1769,16 @@ errorret:
     return (char_u *)"";
   }
 
-  /*
-   * See if it is the same line as requested last time.
-   * Otherwise may need to flush last used line.
-   * Don't use the last used line when 'swapfile' is reset, need to load all
-   * blocks.
-   */
+  // See if it is the same line as requested last time.
+  // Otherwise may need to flush last used line.
+  // Don't use the last used line when 'swapfile' is reset, need to load all
+  // blocks.
   if (buf->b_ml.ml_line_lnum != lnum) {
     ml_flush_line(buf);
 
-    /*
-     * Find the data block containing the line.
-     * This also fills the stack with the blocks from the root to the data
-     * block and releases any locked block.
-     */
+    // Find the data block containing the line.
+    // This also fills the stack with the blocks from the root to the data
+    // block and releases any locked block.
     if ((hp = ml_find_line(buf, lnum, ML_FIND)) == NULL) {
       if (recursive == 0) {
         // Avoid giving this message for a recursive call, may happen
@@ -1986,11 +1900,9 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
   memfile_T *mfp = buf->b_ml.ml_mfp;
   int page_size = (int)mfp->mf_page_size;
 
-  /*
-   * find the data block containing the previous line
-   * This also fills the stack with the blocks from the root to the data block
-   * This also releases any locked block.
-   */
+  // find the data block containing the previous line
+  // This also fills the stack with the blocks from the root to the data block
+  // This also releases any locked block.
   if ((hp = ml_find_line(buf, lnum == 0 ? (linenr_T)1 : lnum,
                          ML_INSERT)) == NULL) {
     return FAIL;
@@ -2008,22 +1920,18 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
 
   dp = hp->bh_data;
 
-  /*
-   * If
-   * - there is not enough room in the current block
-   * - appending to the last line in the block
-   * - not appending to the last line in the file
-   * insert in front of the next block.
-   */
+  // If
+  // - there is not enough room in the current block
+  // - appending to the last line in the block
+  // - not appending to the last line in the file
+  // insert in front of the next block.
   if ((int)dp->db_free < space_needed && db_idx == line_count - 1
       && lnum < buf->b_ml.ml_line_count) {
-    /*
-     * Now that the line is not going to be inserted in the block that we
-     * expected, the line count has to be adjusted in the pointer blocks
-     * by using ml_locked_lineadd.
-     */
-    --(buf->b_ml.ml_locked_lineadd);
-    --(buf->b_ml.ml_locked_high);
+    // Now that the line is not going to be inserted in the block that we
+    // expected, the line count has to be adjusted in the pointer blocks
+    // by using ml_locked_lineadd.
+    (buf->b_ml.ml_locked_lineadd)--;
+    (buf->b_ml.ml_locked_high)--;
     if ((hp = ml_find_line(buf, lnum + 1, ML_INSERT)) == NULL) {
       return FAIL;
     }
@@ -2039,22 +1947,16 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
   buf->b_ml.ml_line_count++;
 
   if ((int)dp->db_free >= space_needed) {       // enough room in data block
-    /*
-     * Insert new line in existing data block, or in data block allocated above.
-     */
+    // Insert new line in existing data block, or in data block allocated above.
     dp->db_txt_start -= (unsigned)len;
     dp->db_free -= (unsigned)space_needed;
     dp->db_line_count++;
 
-    /*
-     * move the text of the lines that follow to the front
-     * adjust the indexes of the lines that follow
-     */
+    // move the text of the lines that follow to the front
+    // adjust the indexes of the lines that follow
     if (line_count > db_idx + 1) {          // if there are following lines
-      /*
-       * Offset is the start of the previous line.
-       * This will become the character just after the new line.
-       */
+      // Offset is the start of the previous line.
+      // This will become the character just after the new line.
       if (db_idx < 0) {
         offset = (int)dp->db_txt_end;
       } else {
@@ -2071,31 +1973,25 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
       dp->db_index[db_idx + 1] = dp->db_txt_start;
     }
 
-    /*
-     * copy the text into the block
-     */
+    // copy the text into the block
     memmove((char *)dp + dp->db_index[db_idx + 1], line, (size_t)len);
     if (mark) {
       dp->db_index[db_idx + 1] |= DB_MARKED;
     }
 
-    /*
-     * Mark the block dirty.
-     */
+    // Mark the block dirty.
     buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
     if (!newfile) {
       buf->b_ml.ml_flags |= ML_LOCKED_POS;
     }
   } else {        // not enough space in data block
-    /*
-     * If there is not enough room we have to create a new data block and copy some
-     * lines into it.
-     * Then we have to insert an entry in the pointer block.
-     * If this pointer block also is full, we go up another block, and so on, up
-     * to the root if necessary.
-     * The line counts in the pointer blocks have already been adjusted by
-     * ml_find_line().
-     */
+    // If there is not enough room we have to create a new data block and copy some
+    // lines into it.
+    // Then we have to insert an entry in the pointer block.
+    // If this pointer block also is full, we go up another block, and so on, up
+    // to the root if necessary.
+    // The line counts in the pointer blocks have already been adjusted by
+    // ml_find_line().
     int line_count_left, line_count_right;
     int page_count_left, page_count_right;
     bhdr_T *hp_left;
@@ -2113,14 +2009,12 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
     int pb_idx;
     PTR_BL *pp_new;
 
-    /*
-     * We are going to allocate a new data block. Depending on the
-     * situation it will be put to the left or right of the existing
-     * block.  If possible we put the new line in the left block and move
-     * the lines after it to the right block. Otherwise the new line is
-     * also put in the right block. This method is more efficient when
-     * inserting a lot of lines at one place.
-     */
+    // We are going to allocate a new data block. Depending on the
+    // situation it will be put to the left or right of the existing
+    // block.  If possible we put the new line in the left block and move
+    // the lines after it to the right block. Otherwise the new line is
+    // also put in the right block. This method is more efficient when
+    // inserting a lot of lines at one place.
     if (db_idx < 0) {           // left block is new, right block is existing
       lines_moved = 0;
       in_left = true;
@@ -2164,9 +2058,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
     page_count_left = (int)hp_left->bh_page_count;
     page_count_right = (int)hp_right->bh_page_count;
 
-    /*
-     * May move the new line into the right/new block.
-     */
+    // May move the new line into the right/new block.
     if (!in_left) {
       dp_right->db_txt_start -= (unsigned)len;
       dp_right->db_free -= (unsigned)len + (unsigned)INDEX_SIZE;
@@ -2179,12 +2071,8 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
               line, (size_t)len);
       line_count_right++;
     }
-    /*
-     * may move lines from the left/old block to the right/new one.
-     */
+    // may move lines from the left/old block to the right/new one.
     if (lines_moved) {
-      /*
-       */
       dp_right->db_txt_start -= (unsigned)data_moved;
       dp_right->db_free -= (unsigned)total_moved;
       memmove((char *)dp_right + dp_right->db_txt_start,
@@ -2194,9 +2082,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
       dp_left->db_txt_start += (unsigned)data_moved;
       dp_left->db_free += (unsigned)total_moved;
 
-      /*
-       * update indexes in the new block
-       */
+      // update indexes in the new block
       for (to = line_count_right, from = db_idx + 1;
            from < line_count_left; from++, to++) {
         dp_right->db_index[to] = dp->db_index[from] + (unsigned)offset;
@@ -2205,9 +2091,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
       line_count_left -= lines_moved;
     }
 
-    /*
-     * May move the new line into the left (old or new) block.
-     */
+    // May move the new line into the left (old or new) block.
     if (in_left) {
       dp_left->db_txt_start -= (unsigned)len;
       dp_left->db_free -= (unsigned)len + (unsigned)INDEX_SIZE;
@@ -2234,12 +2118,10 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
     dp_left->db_line_count = line_count_left;
     dp_right->db_line_count = line_count_right;
 
-    /*
-     * release the two data blocks
-     * The new one (hp_new) already has a correct blocknumber.
-     * The old one (hp, in ml_locked) gets a positive blocknumber if
-     * we changed it and we are not editing a new file.
-     */
+    // release the two data blocks
+    // The new one (hp_new) already has a correct blocknumber.
+    // The old one (hp, in ml_locked) gets a positive blocknumber if
+    // we changed it and we are not editing a new file.
     if (lines_moved || in_left) {
       buf->b_ml.ml_flags |= ML_LOCKED_DIRTY;
     }
@@ -2248,18 +2130,14 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
     }
     mf_put(mfp, hp_new, true, false);
 
-    /*
-     * flush the old data block
-     * set ml_locked_lineadd to 0, because the updating of the
-     * pointer blocks is done below
-     */
+    // flush the old data block
+    // set ml_locked_lineadd to 0, because the updating of the
+    // pointer blocks is done below
     lineadd = buf->b_ml.ml_locked_lineadd;
     buf->b_ml.ml_locked_lineadd = 0;
     (void)ml_find_line(buf, (linenr_T)0, ML_FLUSH);  // flush data block
 
-    /*
-     * update pointer blocks for the new data block
-     */
+    // update pointer blocks for the new data block
     for (stack_idx = buf->b_ml.ml_stack_top - 1; stack_idx >= 0;
          --stack_idx) {
       ip = &(buf->b_ml.ml_stack[stack_idx]);
@@ -2273,10 +2151,8 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
         mf_put(mfp, hp, false, false);
         return FAIL;
       }
-      /*
-       * TODO: If the pointer block is full and we are adding at the end
-       * try to insert in front of the next block
-       */
+      // TODO(vim): If the pointer block is full and we are adding at the end
+      // try to insert in front of the next block
       // block not full, add one entry
       if (pp->pb_count < pp->pb_count_max) {
         if (pb_idx + 1 < (int)pp->pb_count) {
@@ -2312,9 +2188,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
           ++(buf->b_ml.ml_stack_top);
         }
 
-        /*
-         * We are finished, break the loop here.
-         */
+        // We are finished, break the loop here.
         break;
       }
       // pointer block full
@@ -2400,9 +2274,7 @@ static int ml_append_int(buf_T *buf, linenr_T lnum, char_u *line, colnr_T len, b
       mf_put(mfp, hp_new, true, false);
     }
 
-    /*
-     * Safety check: fallen out of for loop?
-     */
+    // Safety check: fallen out of for loop?
     if (stack_idx < 0) {
       iemsg(_("E318: Updated too many blocks?"));
       buf->b_ml.ml_stack_top = 0;       // invalidate stack
@@ -2526,9 +2398,7 @@ static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message)
     lowest_marked--;
   }
 
-  /*
-   * If the file becomes empty the last line is replaced by an empty line.
-   */
+  // If the file becomes empty the last line is replaced by an empty line.
   if (buf->b_ml.ml_line_count == 1) {       // file becomes empty
     if (message) {
       set_keep_msg(_(no_lines_msg), 0);
@@ -2540,11 +2410,9 @@ static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message)
     return i;
   }
 
-  /*
-   * find the data block containing the line
-   * This also fills the stack with the blocks from the root to the data block
-   * This also releases any locked block.
-   */
+  // find the data block containing the line
+  // This also fills the stack with the blocks from the root to the data block
+  // This also releases any locked block.
   mfp = buf->b_ml.ml_mfp;
   if (mfp == NULL) {
     return FAIL;
@@ -2573,14 +2441,12 @@ static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message)
   assert(line_size >= 1);
   ml_add_deleted_len_buf(buf, (char_u *)dp + line_start, line_size - 1);
 
-  /*
-   * special case: If there is only one line in the data block it becomes empty.
-   * Then we have to remove the entry, pointing to this data block, from the
-   * pointer block. If this pointer block also becomes empty, we go up another
-   * block, and so on, up to the root if necessary.
-   * The line counts in the pointer blocks have already been adjusted by
-   * ml_find_line().
-   */
+  // special case: If there is only one line in the data block it becomes empty.
+  // Then we have to remove the entry, pointing to this data block, from the
+  // pointer block. If this pointer block also becomes empty, we go up another
+  // block, and so on, up to the root if necessary.
+  // The line counts in the pointer blocks have already been adjusted by
+  // ml_find_line().
   if (count == 1) {
     mf_free(mfp, hp);           // free the data block
     buf->b_ml.ml_locked = NULL;
@@ -2638,9 +2504,7 @@ static int ml_delete_int(buf_T *buf, linenr_T lnum, bool message)
     dp->db_txt_start += (unsigned)line_size;
     dp->db_line_count--;
 
-    /*
-     * mark the block dirty and make sure it is in the file (for recovery)
-     */
+    // mark the block dirty and make sure it is in the file (for recovery)
     buf->b_ml.ml_flags |= (ML_LOCKED_DIRTY | ML_LOCKED_POS);
   }
 
@@ -2662,11 +2526,9 @@ void ml_setmarked(linenr_T lnum)
     lowest_marked = lnum;
   }
 
-  /*
-   * find the data block containing the line
-   * This also fills the stack with the blocks from the root to the data block
-   * This also releases any locked block.
-   */
+  // find the data block containing the line
+  // This also fills the stack with the blocks from the root to the data block
+  // This also releases any locked block.
   if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) {
     return;                 // give error message?
   }
@@ -2687,16 +2549,12 @@ linenr_T ml_firstmarked(void)
     return (linenr_T)0;
   }
 
-  /*
-   * The search starts with lowest_marked line. This is the last line where
-   * a mark was found, adjusted by inserting/deleting lines.
-   */
+  // The search starts with lowest_marked line. This is the last line where
+  // a mark was found, adjusted by inserting/deleting lines.
   for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count;) {
-    /*
-     * Find the data block containing the line.
-     * This also fills the stack with the blocks from the root to the data
-     * block This also releases any locked block.
-     */
+    // Find the data block containing the line.
+    // This also fills the stack with the blocks from the root to the data
+    // block This also releases any locked block.
     if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) {
       return (linenr_T)0;                   // give error message?
     }
@@ -2728,15 +2586,11 @@ void ml_clearmarked(void)
     return;
   }
 
-  /*
-   * The search starts with line lowest_marked.
-   */
+  // The search starts with line lowest_marked.
   for (lnum = lowest_marked; lnum <= curbuf->b_ml.ml_line_count;) {
-    /*
-     * Find the data block containing the line.
-     * This also fills the stack with the blocks from the root to the data
-     * block and releases any locked block.
-     */
+    // Find the data block containing the line.
+    // This also fills the stack with the blocks from the root to the data
+    // block and releases any locked block.
     if ((hp = ml_find_line(curbuf, lnum, ML_FIND)) == NULL) {
       return;                   // give error message?
     }
@@ -2813,9 +2667,7 @@ static void ml_flush_line(buf_T *buf)
       new_len = (colnr_T)STRLEN(new_line) + 1;
       extra = new_len - old_len;            // negative if lines gets smaller
 
-      /*
-       * if new line fits in data block, replace directly
-       */
+      // if new line fits in data block, replace directly
       if ((int)dp->db_free >= extra) {
         // if the length changes and there are following lines
         count = buf->b_ml.ml_locked_high - buf->b_ml.ml_locked_low + 1;
@@ -2918,13 +2770,11 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
 
   mfp = buf->b_ml.ml_mfp;
 
-  /*
-   * If there is a locked block check if the wanted line is in it.
-   * If not, flush and release the locked block.
-   * Don't do this for ML_INSERT_SAME, because the stack need to be updated.
-   * Don't do this for ML_FLUSH, because we want to flush the locked block.
-   * Don't do this when 'swapfile' is reset, we want to load all the blocks.
-   */
+  // If there is a locked block check if the wanted line is in it.
+  // If not, flush and release the locked block.
+  // Don't do this for ML_INSERT_SAME, because the stack need to be updated.
+  // Don't do this for ML_FLUSH, because we want to flush the locked block.
+  // Don't do this when 'swapfile' is reset, we want to load all the blocks.
   if (buf->b_ml.ml_locked) {
     if (ML_SIMPLE(action)
         && buf->b_ml.ml_locked_low <= lnum
@@ -2944,10 +2794,8 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
            buf->b_ml.ml_flags & ML_LOCKED_POS);
     buf->b_ml.ml_locked = NULL;
 
-    /*
-     * If lines have been added or deleted in the locked block, need to
-     * update the line count in pointer blocks.
-     */
+    // If lines have been added or deleted in the locked block, need to
+    // update the line count in pointer blocks.
     if (buf->b_ml.ml_locked_lineadd != 0) {
       ml_lineadd(buf, buf->b_ml.ml_locked_lineadd);
     }
@@ -2979,17 +2827,13 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
   } else {  // ML_DELETE or ML_INSERT
     buf->b_ml.ml_stack_top = 0;         // start at the root
   }
-  /*
-   * search downwards in the tree until a data block is found
-   */
+  // search downwards in the tree until a data block is found
   for (;;) {
     if ((hp = mf_get(mfp, bnum, (unsigned)page_count)) == NULL) {
       goto error_noblock;
     }
 
-    /*
-     * update high for insert/delete
-     */
+    // update high for insert/delete
     if (action == ML_INSERT) {
       high++;
     } else if (action == ML_DELETE) {
@@ -3030,9 +2874,7 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
         high = low - 1;
         low -= t;
 
-        /*
-         * a negative block number may have been changed
-         */
+        // a negative block number may have been changed
         if (bnum < 0) {
           bnum2 = mf_trans_del(mfp, bnum);
           if (bnum != bnum2) {
@@ -3067,11 +2909,9 @@ static bhdr_T *ml_find_line(buf_T *buf, linenr_T lnum, int action)
 error_block:
   mf_put(mfp, hp, false, false);
 error_noblock:
-  /*
-   * If action is ML_DELETE or ML_INSERT we have to correct the tree for
-   * the incremented/decremented line counts, because there won't be a line
-   * inserted/deleted after all.
-   */
+  // If action is ML_DELETE or ML_INSERT we have to correct the tree for
+  // the incremented/decremented line counts, because there won't be a line
+  // inserted/deleted after all.
   if (action == ML_DELETE) {
     ml_lineadd(buf, 1);
   } else if (action == ML_INSERT) {
@@ -3196,11 +3036,9 @@ int resolve_symlink(const char *fname, char *buf)
     }
   }
 
-  /*
-   * Try to resolve the full name of the file so that the swapfile name will
-   * be consistent even when opening a relative symlink from different
-   * working directories.
-   */
+  // Try to resolve the full name of the file so that the swapfile name will
+  // be consistent even when opening a relative symlink from different
+  // working directories.
   return vim_FullName(tmp, buf, MAXPATHL, true);
 }
 #endif
@@ -3407,17 +3245,13 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
   char *dir_name;
   char *buf_fname = buf->b_fname;
 
-  /*
-   * Isolate a directory name from *dirp and put it in dir_name.
-   * First allocate some memory to put the directory name in.
-   */
+  // Isolate a directory name from *dirp and put it in dir_name.
+  // First allocate some memory to put the directory name in.
   const size_t dir_len = strlen(*dirp) + 1;
   dir_name = xmalloc(dir_len);
   (void)copy_option_part(dirp, dir_name, dir_len, ",");
 
-  /*
-   * we try different names until we find one that does not exist yet
-   */
+  // we try different names until we find one that does not exist yet
   fname = (char *)makeswapname((char_u *)buf_fname, (char_u *)buf->b_ffname, buf,
                                (char_u *)dir_name);
 
@@ -3596,12 +3430,10 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
       }
     }
 
-    /*
-     * Change the ".swp" extension to find another file that can be used.
-     * First decrement the last char: ".swo", ".swn", etc.
-     * If that still isn't enough decrement the last but one char: ".svz"
-     * Can happen when editing many "No Name" buffers.
-     */
+    // Change the ".swp" extension to find another file that can be used.
+    // First decrement the last char: ".swo", ".swn", etc.
+    // If that still isn't enough decrement the last but one char: ".svz"
+    // Can happen when editing many "No Name" buffers.
     if (fname[n - 1] == 'a') {          // ".s?a"
       if (fname[n - 2] == 'a') {        // ".saa": tried enough, give up
         emsg(_("E326: Too many swap files found"));
@@ -3701,11 +3533,9 @@ static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0)
     ino_c = os_fileinfo_inode(&file_info);
   }
 
-  /*
-   * First we try to get the inode from the file name, because the inode in
-   * the swap file may be outdated.  If that fails (e.g. this path is not
-   * valid on this machine), use the inode from block 0.
-   */
+  // First we try to get the inode from the file name, because the inode in
+  // the swap file may be outdated.  If that fails (e.g. this path is not
+  // valid on this machine), use the inode from block 0.
   if (os_fileinfo((char *)fname_s, &file_info)) {
     ino_s = os_fileinfo_inode(&file_info);
   } else {
@@ -3716,21 +3546,17 @@ static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0)
     return ino_c != ino_s;
   }
 
-  /*
-   * One of the inode numbers is unknown, try a forced vim_FullName() and
-   * compare the file names.
-   */
+  // One of the inode numbers is unknown, try a forced vim_FullName() and
+  // compare the file names.
   retval_c = vim_FullName((char *)fname_c, (char *)buf_c, MAXPATHL, true);
   retval_s = vim_FullName((char *)fname_s, (char *)buf_s, MAXPATHL, true);
   if (retval_c == OK && retval_s == OK) {
     return STRCMP(buf_c, buf_s) != 0;
   }
 
-  /*
-   * Can't compare inodes or file names, guess that the files are different,
-   * unless both appear not to exist at all, then compare with the file name
-   * in the swap file.
-   */
+  // Can't compare inodes or file names, guess that the files are different,
+  // unless both appear not to exist at all, then compare with the file name
+  // in the swap file.
   if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL) {
     return STRCMP(fname_c, fname_s) != 0;
   }
@@ -3827,9 +3653,7 @@ static void ml_updatechunk(buf_T *buf, linenr_T line, long len, int updtype)
   }
 
   if (updtype == ML_CHNK_UPDLINE && buf->b_ml.ml_line_count == 1) {
-    /*
-     * First line in empty buffer from ml_flush_line() -- reset
-     */
+    // First line in empty buffer from ml_flush_line() -- reset
     buf->b_ml.ml_usedchunks = 1;
     buf->b_ml.ml_chunksize[0].mlcs_numlines = 1;
     buf->b_ml.ml_chunksize[0].mlcs_totalsize =
@@ -3837,10 +3661,8 @@ static void ml_updatechunk(buf_T *buf, linenr_T line, long len, int updtype)
     return;
   }
 
-  /*
-   * Find chunk that our line belongs to, curline will be at start of the
-   * chunk.
-   */
+  // Find chunk that our line belongs to, curline will be at start of the
+  // chunk.
   if (buf != ml_upd_lastbuf || line != ml_upd_lastline + 1
       || updtype != ML_CHNK_ADDLINE) {
     for (curline = 1, curix = 0;
@@ -3928,10 +3750,8 @@ static void ml_updatechunk(buf_T *buf, linenr_T line, long len, int updtype)
         curchnk->mlcs_numlines = 0;
         curchnk->mlcs_totalsize = 0;
       } else {
-        /*
-         * Line is just prior to last, move count for last
-         * This is the common case  when loading a new file
-         */
+        // Line is just prior to last, move count for last
+        // This is the common case  when loading a new file
         hp = ml_find_line(buf, buf->b_ml.ml_line_count, ML_FIND);
         if (hp == NULL) {
           buf->b_ml.ml_usedchunks = -1;
@@ -4044,10 +3864,8 @@ long ml_find_line_or_offset(buf_T *buf, linenr_T lnum, long *offp, bool no_ff)
   if (lnum == 0 && offset <= 0) {
     return 1;       // Not a "find offset" and offset 0 _must_ be in line 1
   }
-  /*
-   * Find the last chunk before the one containing our line. Last chunk is
-   * special because it will never qualify
-   */
+  // Find the last chunk before the one containing our line. Last chunk is
+  // special because it will never qualify
   curline = 1;
   curix = 0;
   size = 0;
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index acd2478c81..e5fea027cb 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -502,10 +502,8 @@ bool striequal(const char *a, const char *b)
   return (a == NULL && b == NULL) || (a && b && STRICMP(a, b) == 0);
 }
 
-/*
- * Avoid repeating the error message many times (they take 1 second each).
- * Did_outofmem_msg is reset when a character is read.
- */
+// Avoid repeating the error message many times (they take 1 second each).
+// Did_outofmem_msg is reset when a character is read.
 void do_outofmem_msg(size_t size)
 {
   if (!did_outofmem_msg) {
@@ -675,13 +673,11 @@ char *arena_memdupz(Arena *arena, const char *buf, size_t size)
 # include "nvim/tag.h"
 # include "nvim/window.h"
 
-/*
- * Free everything that we allocated.
- * Can be used to detect memory leaks, e.g., with ccmalloc.
- * NOTE: This is tricky!  Things are freed that functions depend on.  Don't be
- * surprised if Vim crashes...
- * Some things can't be freed, esp. things local to a library function.
- */
+// Free everything that we allocated.
+// Can be used to detect memory leaks, e.g., with ccmalloc.
+// NOTE: This is tricky!  Things are freed that functions depend on.  Don't be
+// surprised if Vim crashes...
+// Some things can't be freed, esp. things local to a library function.
 void free_all_mem(void)
 {
   buf_T *buf, *nextbuf;
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index 84a1defbe0..7a08a4d6f6 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -1,10 +1,8 @@
 // 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
 
-/*
- * Code for menus.  Used for the GUI and 'wildmenu'.
- * GUI/Motif support by Robert Webb
- */
+// Code for menus.  Used for the GUI and 'wildmenu'.
+// GUI/Motif support by Robert Webb
 
 #include <assert.h>
 #include <inttypes.h>
@@ -141,9 +139,7 @@ void ex_menu(exarg_T *eap)
   }
   pri_tab[MENUDEPTH] = -1;              // mark end of the table
 
-  /*
-   * Check for "disable" or "enable" argument.
-   */
+  // Check for "disable" or "enable" argument.
   if (STRNCMP(arg, "enable", 6) == 0 && ascii_iswhite(arg[6])) {
     enable = kTrue;
     arg = skipwhite(arg + 6);
@@ -152,9 +148,7 @@ void ex_menu(exarg_T *eap)
     arg = skipwhite(arg + 7);
   }
 
-  /*
-   * If there is no argument, display all menus.
-   */
+  // If there is no argument, display all menus.
   if (*arg == NUL) {
     show_menus(arg, modes);
     return;
@@ -168,9 +162,7 @@ void ex_menu(exarg_T *eap)
 
   map_to = menu_translate_tab_and_shift(arg);
 
-  /*
-   * If there is only a menu name, display menus with that name.
-   */
+  // If there is only a menu name, display menus with that name.
   if (*map_to == NUL && !unmenu && enable == kNone) {
     show_menus(menu_path, modes);
     goto theend;
@@ -200,16 +192,12 @@ void ex_menu(exarg_T *eap)
     }
     menu_enable_recurse(*root_menu_ptr, menu_path, modes, enable);
   } else if (unmenu) {
-    /*
-     * Delete menu(s).
-     */
+    // Delete menu(s).
     if (STRCMP(menu_path, "*") == 0) {          // meaning: remove all menus
       menu_path = "";
     }
 
-    /*
-     * For the PopUp menu, remove a menu for each mode separately.
-     */
+    // For the PopUp menu, remove a menu for each mode separately.
     if (menu_is_popup(menu_path)) {
       for (i = 0; i < MENU_INDEX_TIP; i++) {
         if (modes & (1 << i)) {
@@ -223,10 +211,8 @@ void ex_menu(exarg_T *eap)
     // Careful: remove_menu() changes menu_path
     remove_menu(root_menu_ptr, menu_path, modes, false);
   } else {
-    /*
-     * Add menu(s).
-     * Replace special key codes.
-     */
+    // Add menu(s).
+    // Replace special key codes.
     if (STRICMP(map_to, "<nop>") == 0) {        // "<Nop>" means nothing
       map_to = "";
       map_buf = NULL;
@@ -242,9 +228,7 @@ void ex_menu(exarg_T *eap)
     menuarg.silent[0] = silent;
     add_menu_path(menu_path, &menuarg, pri_tab, map_to);
 
-    /*
-     * For the PopUp menu, add a menu for each mode separately.
-     */
+    // For the PopUp menu, add a menu for each mode separately.
     if (menu_is_popup(menu_path)) {
       for (i = 0; i < MENU_INDEX_TIP; i++) {
         if (modes & (1 << i)) {
@@ -384,11 +368,9 @@ static int add_menu_path(const char *const menu_path, vimmenu_T *menuarg, const
     } else {
       old_modes = menu->modes;
 
-      /*
-       * If this menu option was previously only available in other
-       * modes, then make sure it's available for this one now
-       * Also enable a menu when it's created or changed.
-       */
+      // If this menu option was previously only available in other
+      // modes, then make sure it's available for this one now
+      // Also enable a menu when it's created or changed.
       {
         menu->modes |= modes;
         menu->enabled |= modes;
@@ -405,10 +387,8 @@ static int add_menu_path(const char *const menu_path, vimmenu_T *menuarg, const
   }
   xfree(path_name);
 
-  /*
-   * Only add system menu items which have not been defined yet.
-   * First check if this was an ":amenu".
-   */
+  // Only add system menu items which have not been defined yet.
+  // First check if this was an ":amenu".
   amenu = ((modes & (MENU_NORMAL_MODE | MENU_INSERT_MODE)) ==
            (MENU_NORMAL_MODE | MENU_INSERT_MODE));
   if (sys_menu) {
@@ -491,10 +471,8 @@ erret:
   return FAIL;
 }
 
-/*
- * Set the (sub)menu with the given name to enabled or disabled.
- * Called recursively.
- */
+// Set the (sub)menu with the given name to enabled or disabled.
+// Called recursively.
 static int menu_enable_recurse(vimmenu_T *menu, char *name, int modes, int enable)
 {
   char *p;
@@ -522,11 +500,9 @@ static int menu_enable_recurse(vimmenu_T *menu, char *name, int modes, int enabl
         menu->enabled &= ~modes;
       }
 
-      /*
-       * When name is empty, we are doing all menu items for the given
-       * modes, so keep looping, otherwise we are just doing the named
-       * menu item (which has been found) so break here.
-       */
+      // When name is empty, we are doing all menu items for the given
+      // modes, so keep looping, otherwise we are just doing the named
+      // menu item (which has been found) so break here.
       if (*name != NUL && *name != '*') {
         break;
       }
@@ -577,11 +553,9 @@ static int remove_menu(vimmenu_T **menup, char *name, int modes, bool silent)
         return FAIL;
       }
 
-      /*
-       * When name is empty, we are removing all menu items for the given
-       * modes, so keep looping, otherwise we are just removing the named
-       * menu item (which has been found) so break here.
-       */
+      // When name is empty, we are removing all menu items for the given
+      // modes, so keep looping, otherwise we are just removing the named
+      // menu item (which has been found) so break here.
       if (*name != NUL) {
         break;
       }
@@ -628,9 +602,7 @@ static int remove_menu(vimmenu_T **menup, char *name, int modes, bool silent)
   return OK;
 }
 
-/*
- * Free the given menu structure and remove it from the linked list.
- */
+// Free the given menu structure and remove it from the linked list.
 static void free_menu(vimmenu_T **menup)
 {
   int i;
@@ -652,9 +624,7 @@ static void free_menu(vimmenu_T **menup)
   xfree(menu);
 }
 
-/*
- * Free the menu->string with the given index.
- */
+// Free the menu->string with the given index.
 static void free_menu_string(vimmenu_T *menu, int idx)
 {
   int count = 0;
@@ -909,16 +879,12 @@ static void show_menus_recursive(vimmenu_T *menu, int modes, int depth)
   }
 }
 
-/*
- * Used when expanding menu names.
- */
+// Used when expanding menu names.
 static vimmenu_T *expand_menu = NULL;
 static int expand_modes = 0x0;
 static int expand_emenu;                // true for ":emenu" command
 
-/*
- * Work out what to complete when doing command line completion of menu names.
- */
+// Work out what to complete when doing command line completion of menu names.
 char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool forceit)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -994,10 +960,8 @@ char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool for
           // Found menu
           if ((*p != NUL && menu->children == NULL)
               || ((menu->modes & expand_modes) == 0x0)) {
-            /*
-             * Menu path continues, but we have reached a leaf.
-             * Or menu exists only in another mode.
-             */
+            // Menu path continues, but we have reached a leaf.
+            // Or menu exists only in another mode.
             xfree(path_name);
             return NULL;
           }
@@ -1024,10 +988,8 @@ char *set_context_in_menu_cmd(expand_T *xp, const char *cmd, char *arg, bool for
   return NULL;
 }
 
-/*
- * Function given to ExpandGeneric() to obtain the list of (sub)menus (not
- * entries).
- */
+// Function given to ExpandGeneric() to obtain the list of (sub)menus (not
+// entries).
 char *get_menu_name(expand_T *xp, int idx)
 {
   static vimmenu_T *menu = NULL;
@@ -1073,10 +1035,8 @@ char *get_menu_name(expand_T *xp, int idx)
   return str;
 }
 
-/*
- * Function given to ExpandGeneric() to obtain the list of menus and menu
- * entries.
- */
+// Function given to ExpandGeneric() to obtain the list of menus and menu
+// entries.
 char *get_menu_names(expand_T *xp, int idx)
 {
   static vimmenu_T *menu = NULL;
@@ -1312,10 +1272,8 @@ static char *get_menu_mode_str(int modes)
   return "";
 }
 
-/*
- * Modify a menu name starting with "PopUp" to include the mode character.
- * Returns the name in allocated memory.
- */
+// Modify a menu name starting with "PopUp" to include the mode character.
+// Returns the name in allocated memory.
 static char *popup_mode_name(char *name, int idx)
 {
   size_t len = STRLEN(name);
@@ -1730,9 +1688,7 @@ theend:
   return menu;
 }
 
-/*
- * Translation of menu names.  Just a simple lookup table.
- */
+// Translation of menu names.  Just a simple lookup table.
 
 typedef struct {
   char *from;            // English name
@@ -1748,11 +1704,9 @@ static garray_T menutrans_ga = GA_EMPTY_INIT_VALUE;
   xfree(_mt->from_noamp); \
   xfree(_mt->to)
 
-/*
- * ":menutrans".
- * This function is also defined without the +multi_lang feature, in which
- * case the commands are ignored.
- */
+// ":menutrans".
+// This function is also defined without the +multi_lang feature, in which
+// case the commands are ignored.
 void ex_menutranslate(exarg_T *eap)
 {
   char *arg = eap->arg;
@@ -1762,9 +1716,7 @@ void ex_menutranslate(exarg_T *eap)
     ga_init(&menutrans_ga, (int)sizeof(menutrans_T), 5);
   }
 
-  /*
-   * ":menutrans clear": clear all translations.
-   */
+  // ":menutrans clear": clear all translations.
   if (STRNCMP(arg, "clear", 5) == 0 && ends_excmd(*skipwhite(arg + 5))) {
     GA_DEEP_CLEAR(&menutrans_ga, menutrans_T, FREE_MENUTRANS);
 
@@ -1796,9 +1748,7 @@ void ex_menutranslate(exarg_T *eap)
   }
 }
 
-/*
- * Find the character just after one part of a menu name.
- */
+// Find the character just after one part of a menu name.
 static char *menu_skip_part(char *p)
 {
   while (*p != NUL && *p != '.' && !ascii_iswhite(*p)) {
@@ -1810,10 +1760,8 @@ static char *menu_skip_part(char *p)
   return p;
 }
 
-/*
- * Lookup part of a menu name in the translations.
- * Return a pointer to the translation or NULL if not found.
- */
+// Lookup part of a menu name in the translations.
+// Return a pointer to the translation or NULL if not found.
 static char *menutrans_lookup(char *name, int len)
 {
   menutrans_T *tp = (menutrans_T *)menutrans_ga.ga_data;
@@ -1841,9 +1789,7 @@ static char *menutrans_lookup(char *name, int len)
   return NULL;
 }
 
-/*
- * Unescape the name in the translate dictionary table.
- */
+// Unescape the name in the translate dictionary table.
 static void menu_unescape_name(char *name)
 {
   char *p;
@@ -1855,10 +1801,8 @@ static void menu_unescape_name(char *name)
   }
 }
 
-/*
- * Isolate the menu name.
- * Skip the menu name, and translate <Tab> into a real TAB.
- */
+// Isolate the menu name.
+// Skip the menu name, and translate <Tab> into a real TAB.
 static char *menu_translate_tab_and_shift(char *arg_start)
 {
   char *arg = arg_start;
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 87cfe06edc..d43c04b652 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * message.c: functions for displaying messages on the command line
- */
+// message.c: functions for displaying messages on the command line
 
 #include <assert.h>
 #include <inttypes.h>
@@ -48,10 +46,8 @@
 #include "nvim/ui_compositor.h"
 #include "nvim/vim.h"
 
-/*
- * To be able to scroll back at the "more" and "hit-enter" prompts we need to
- * store the displayed text and remember where screen lines start.
- */
+// To be able to scroll back at the "more" and "hit-enter" prompts we need to
+// store the displayed text and remember where screen lines start.
 typedef struct msgchunk_S msgchunk_T;
 struct msgchunk_S {
   msgchunk_T *sb_next;
@@ -82,41 +78,39 @@ static int verbose_did_open = false;
 
 bool keep_msg_more = false;    // keep_msg was set by msgmore()
 
-/*
- * When writing messages to the screen, there are many different situations.
- * A number of variables is used to remember the current state:
- * msg_didany       true when messages were written since the last time the
- *                  user reacted to a prompt.
- *                  Reset: After hitting a key for the hit-return prompt,
- *                  hitting <CR> for the command line or input().
- *                  Set: When any message is written to the screen.
- * msg_didout       true when something was written to the current line.
- *                  Reset: When advancing to the next line, when the current
- *                  text can be overwritten.
- *                  Set: When any message is written to the screen.
- * msg_nowait       No extra delay for the last drawn message.
- *                  Used in normal_cmd() before the mode message is drawn.
- * emsg_on_display  There was an error message recently.  Indicates that there
- *                  should be a delay before redrawing.
- * msg_scroll       The next message should not overwrite the current one.
- * msg_scrolled     How many lines the screen has been scrolled (because of
- *                  messages).  Used in update_screen() to scroll the screen
- *                  back.  Incremented each time the screen scrolls a line.
- * msg_scrolled_ign  true when msg_scrolled is non-zero and msg_puts_attr()
- *                  writes something without scrolling should not make
- *                  need_wait_return to be set.  This is a hack to make ":ts"
- *                  work without an extra prompt.
- * lines_left       Number of lines available for messages before the
- *                  more-prompt is to be given.  -1 when not set.
- * need_wait_return true when the hit-return prompt is needed.
- *                  Reset: After giving the hit-return prompt, when the user
- *                  has answered some other prompt.
- *                  Set: When the ruler or typeahead display is overwritten,
- *                  scrolling the screen for some message.
- * keep_msg         Message to be displayed after redrawing the screen, in
- *                  main_loop().
- *                  This is an allocated string or NULL when not used.
- */
+// When writing messages to the screen, there are many different situations.
+// A number of variables is used to remember the current state:
+// msg_didany       true when messages were written since the last time the
+//                  user reacted to a prompt.
+//                  Reset: After hitting a key for the hit-return prompt,
+//                  hitting <CR> for the command line or input().
+//                  Set: When any message is written to the screen.
+// msg_didout       true when something was written to the current line.
+//                  Reset: When advancing to the next line, when the current
+//                  text can be overwritten.
+//                  Set: When any message is written to the screen.
+// msg_nowait       No extra delay for the last drawn message.
+//                  Used in normal_cmd() before the mode message is drawn.
+// emsg_on_display  There was an error message recently.  Indicates that there
+//                  should be a delay before redrawing.
+// msg_scroll       The next message should not overwrite the current one.
+// msg_scrolled     How many lines the screen has been scrolled (because of
+//                  messages).  Used in update_screen() to scroll the screen
+//                  back.  Incremented each time the screen scrolls a line.
+// msg_scrolled_ign  true when msg_scrolled is non-zero and msg_puts_attr()
+//                  writes something without scrolling should not make
+//                  need_wait_return to be set.  This is a hack to make ":ts"
+//                  work without an extra prompt.
+// lines_left       Number of lines available for messages before the
+//                  more-prompt is to be given.  -1 when not set.
+// need_wait_return true when the hit-return prompt is needed.
+//                  Reset: After giving the hit-return prompt, when the user
+//                  has answered some other prompt.
+//                  Set: When the ruler or typeahead display is overwritten,
+//                  scrolling the screen for some message.
+// keep_msg         Message to be displayed after redrawing the screen, in
+//                  main_loop().
+//                  This is an allocated string or NULL when not used.
 
 // Extended msg state, currently used for external UIs with ext_messages
 static const char *msg_ext_kind = NULL;
@@ -313,11 +307,9 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
     set_vim_var_string(VV_STATUSMSG, s, -1);
   }
 
-  /*
-   * It is possible that displaying a messages causes a problem (e.g.,
-   * when redrawing the window), which causes another message, etc..    To
-   * break this loop, limit the recursiveness to 3 levels.
-   */
+  // It is possible that displaying a messages causes a problem (e.g.,
+  // when redrawing the window), which causes another message, etc..    To
+  // break this loop, limit the recursiveness to 3 levels.
   if (entered >= 3) {
     return true;
   }
@@ -483,10 +475,8 @@ void trunc_string(char *s, char *buf, int room_in, int buflen)
   }
 }
 
-/*
- * Note: Caller of smsg() and smsg_attr() must check the resulting string is
- * shorter than IOSIZE!!!
- */
+// Note: Caller of smsg() and smsg_attr() must check the resulting string is
+// shorter than IOSIZE!!!
 
 int smsg(const char *s, ...)
   FUNC_ATTR_PRINTF(1, 2)
@@ -522,10 +512,8 @@ int smsg_attr_keep(int attr, const char *s, ...)
   return msg_attr_keep((const char *)IObuff, attr, true, false);
 }
 
-/*
- * Remember the last sourcing name/lnum used in an error message, so that it
- * isn't printed each time when it didn't change.
- */
+// Remember the last sourcing name/lnum used in an error message, so that it
+// isn't printed each time when it didn't change.
 static int last_sourcing_lnum = 0;
 static char *last_sourcing_name = NULL;
 
@@ -681,10 +669,8 @@ static bool emsg_multiline(const char *s, bool multiline)
     // set "v:errmsg", also when using ":silent! cmd"
     set_vim_var_string(VV_ERRMSG, s, -1);
 
-    /*
-     * When using ":silent! cmd" ignore error messages.
-     * But do write it to the redirection file.
-     */
+    // When using ":silent! cmd" ignore error messages.
+    // But do write it to the redirection file.
     if (emsg_silent != 0) {
       if (!emsg_noredir) {
         msg_start();
@@ -1156,12 +1142,10 @@ void wait_return(int redraw)
     return;
   }
 
-  /*
-   * When inside vgetc(), we can't wait for a typed character at all.
-   * With the global command (and some others) we only need one return at
-   * the end. Adjust cmdline_row to avoid the next message overwriting the
-   * last one.
-   */
+  // When inside vgetc(), we can't wait for a typed character at all.
+  // With the global command (and some others) we only need one return at
+  // the end. Adjust cmdline_row to avoid the next message overwriting the
+  // last one.
   if (vgetc_busy > 0) {
     return;
   }
@@ -1226,12 +1210,10 @@ void wait_return(int redraw)
       reg_recording = save_reg_recording;
       scriptout = save_scriptout;
 
-      /*
-       * Allow scrolling back in the messages.
-       * Also accept scroll-down commands when messages fill the screen,
-       * to avoid that typing one 'j' too many makes the messages
-       * disappear.
-       */
+      // Allow scrolling back in the messages.
+      // Also accept scroll-down commands when messages fill the screen,
+      // to avoid that typing one 'j' too many makes the messages
+      // disappear.
       if (p_more) {
         if (c == 'b' || c == 'k' || c == 'u' || c == 'g'
             || c == K_UP || c == K_PAGEUP) {
@@ -1268,9 +1250,7 @@ void wait_return(int redraw)
              || c == K_MOUSEDOWN || c == K_MOUSEUP
              || c == K_MOUSEMOVE);
     os_breakcheck();
-    /*
-     * Avoid that the mouse-up event causes visual mode to start.
-     */
+    // Avoid that the mouse-up event causes visual mode to start.
     if (c == K_LEFTMOUSE || c == K_MIDDLEMOUSE || c == K_RIGHTMOUSE
         || c == K_X1MOUSE || c == K_X2MOUSE) {
       (void)jump_to_mouse(MOUSE_SETPOS, NULL, 0);
@@ -1575,10 +1555,8 @@ int msg_outtrans_len_attr(const char *msgstr, int len, int attr)
     msg_puts_attr(" ", attr);
   }
 
-  /*
-   * Go over the string.  Special characters are translated and printed.
-   * Normal characters are printed several at a time.
-   */
+  // Go over the string.  Special characters are translated and printed.
+  // Normal characters are printed several at a time.
   while (--len >= 0 && !got_int) {
     // Don't include composing chars after the end.
     mb_l = utfc_ptr2len_len(str, len + 1);
@@ -2250,10 +2228,8 @@ static void msg_puts_display(const char *str, int maxlen, int attr, int recurse)
         cmdline_row--;
       }
 
-      /*
-       * If screen is completely filled and 'more' is set then wait
-       * for a character.
-       */
+      // If screen is completely filled and 'more' is set then wait
+      // for a character.
       if (lines_left > 0) {
         lines_left--;
       }
@@ -2828,9 +2804,7 @@ static int do_more_prompt(int typed_char)
     msg_moremsg(false);
   }
   for (;;) {
-    /*
-     * Get a typed character directly from the user.
-     */
+    // Get a typed character directly from the user.
     if (used_typed_char != NUL) {
       c = used_typed_char;              // was typed at hit-enter prompt
       used_typed_char = NUL;
@@ -3170,12 +3144,10 @@ void msg_clr_cmdline(void)
 /// @return  true if wait_return() not called.
 int msg_end(void)
 {
-  /*
-   * If the string is larger than the window,
-   * or the ruler option is set and we run into it,
-   * we have to redraw the window.
-   * Do not do this if we are abandoning the file or editing the command line.
-   */
+  // If the string is larger than the window,
+  // or the ruler option is set and we run into it,
+  // we have to redraw the window.
+  // Do not do this if we are abandoning the file or editing the command line.
   if (!exiting && need_wait_return && !(State & MODE_CMDLINE)) {
     wait_return(false);
     return false;
@@ -3545,10 +3517,8 @@ int do_dialog(int type, char *title, char *message, char *buttons, int dfltbutto
   State = MODE_CONFIRM;
   setmouse();
 
-  /*
-   * Since we wait for a keypress, don't make the
-   * user press RETURN as well afterwards.
-   */
+  // Since we wait for a keypress, don't make the
+  // user press RETURN as well afterwards.
   no_wait_return++;
   hotkeys = msg_show_console_dialog(message, buttons, dfltbutton);
 
diff --git a/src/nvim/message.h b/src/nvim/message.h
index 2de2890213..4dba26f958 100644
--- a/src/nvim/message.h
+++ b/src/nvim/message.h
@@ -11,9 +11,7 @@
 #include "nvim/macros.h"
 #include "nvim/types.h"
 
-/*
- * Types of dialogs passed to do_dialog().
- */
+// Types of dialogs passed to do_dialog().
 #define VIM_GENERIC     0
 #define VIM_ERROR       1
 #define VIM_WARNING     2
@@ -21,9 +19,7 @@
 #define VIM_QUESTION    4
 #define VIM_LAST_TYPE   4       // sentinel value
 
-/*
- * Return values for functions like vim_dialogyesno()
- */
+// Return values for functions like vim_dialogyesno()
 #define VIM_YES         2
 #define VIM_NO          3
 #define VIM_CANCEL      4
diff --git a/src/nvim/move.c b/src/nvim/move.c
index b3ec3a8e7a..0e2550352d 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -1,16 +1,14 @@
 // 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
 
-/*
- * move.c: Functions for moving the cursor and scrolling text.
- *
- * There are two ways to move the cursor:
- * 1. Move the cursor directly, the text is scrolled to keep the cursor in the
- *    window.
- * 2. Scroll the text, the cursor is moved into the text visible in the
- *    window.
- * The 'scrolloff' option makes this a bit complicated.
- */
+// move.c: Functions for moving the cursor and scrolling text.
+//
+// There are two ways to move the cursor:
+// 1. Move the cursor directly, the text is scrolled to keep the cursor in the
+//    window.
+// 2. Scroll the text, the cursor is moved into the text visible in the
+//    window.
+// The 'scrolloff' option makes this a bit complicated.
 
 #include <assert.h>
 #include <inttypes.h>
@@ -47,19 +45,15 @@ typedef struct {
 # include "move.c.generated.h"
 #endif
 
-/*
- * Compute wp->w_botline for the current wp->w_topline.  Can be called after
- * wp->w_topline changed.
- */
+// Compute wp->w_botline for the current wp->w_topline.  Can be called after
+// wp->w_topline changed.
 static void comp_botline(win_T *wp)
 {
   linenr_T lnum;
   int done;
 
-  /*
-   * If w_cline_row is valid, start there.
-   * Otherwise have to start at w_topline.
-   */
+  // If w_cline_row is valid, start there.
+  // Otherwise have to start at w_topline.
   check_cursor_moved(wp);
   if (wp->w_valid & VALID_CROW) {
     lnum = wp->w_cursor.lnum;
@@ -133,10 +127,8 @@ static void redraw_for_cursorcolumn(win_T *wp)
   }
 }
 
-/*
- * Update curwin->w_topline and redraw if necessary.
- * Used to update the screen before printing a message.
- */
+// Update curwin->w_topline and redraw if necessary.
+// Used to update the screen before printing a message.
 void update_topline_redraw(void)
 {
   update_topline(curwin);
@@ -145,9 +137,7 @@ void update_topline_redraw(void)
   }
 }
 
-/*
- * Update curwin->w_topline to move the cursor onto the screen.
- */
+// Update curwin->w_topline to move the cursor onto the screen.
 void update_topline(win_T *wp)
 {
   linenr_T old_topline;
@@ -250,14 +240,12 @@ void update_topline(win_T *wp)
     }
   }
 
-  /*
-   * If the cursor is below the bottom of the window, scroll the window
-   * to put the cursor on the window.
-   * When w_botline is invalid, recompute it first, to avoid a redraw later.
-   * If w_botline was approximated, we might need a redraw later in a few
-   * cases, but we don't want to spend (a lot of) time recomputing w_botline
-   * for every small change.
-   */
+  // If the cursor is below the bottom of the window, scroll the window
+  // to put the cursor on the window.
+  // When w_botline is invalid, recompute it first, to avoid a redraw later.
+  // If w_botline was approximated, we might need a redraw later in a few
+  // cases, but we don't want to spend (a lot of) time recomputing w_botline
+  // for every small change.
   if (check_botline) {
     if (!(wp->w_valid & VALID_BOTLINE_AP)) {
       validate_botline(wp);
@@ -328,9 +316,7 @@ void update_topline(win_T *wp)
   wp->w_viewport_invalid = true;
   win_check_anchored_floats(wp);
 
-  /*
-   * Need to redraw when topline changed.
-   */
+  // Need to redraw when topline changed.
   if (wp->w_topline != old_topline
       || wp->w_topfill != old_topfill) {
     dollar_vcol = -1;
@@ -349,9 +335,7 @@ void update_topline(win_T *wp)
   *so_ptr = save_so;
 }
 
-/*
- * Update win->w_topline to move the cursor onto the screen.
- */
+// Update win->w_topline to move the cursor onto the screen.
 void update_topline_win(win_T *win)
 {
   switchwin_T switchwin;
@@ -360,11 +344,9 @@ void update_topline_win(win_T *win)
   restore_win(&switchwin, true);
 }
 
-/*
- * Return the scrolljump value to use for the current window.
- * When 'scrolljump' is positive use it as-is.
- * When 'scrolljump' is negative use it as a percentage of the window height.
- */
+// Return the scrolljump value to use for the current window.
+// When 'scrolljump' is positive use it as-is.
+// When 'scrolljump' is negative use it as a percentage of the window height.
 static int scrolljump_value(void)
 {
   long result = p_sj >= 0 ? p_sj : (curwin->w_height_inner * -p_sj) / 100;
@@ -372,10 +354,8 @@ static int scrolljump_value(void)
   return (int)result;
 }
 
-/*
- * Return true when there are not 'scrolloff' lines above the cursor for the
- * current window.
- */
+// Return true when there are not 'scrolloff' lines above the cursor for the
+// current window.
 static bool check_top_offset(void)
 {
   long so = get_scrolloff_value(curwin);
@@ -412,9 +392,7 @@ void update_curswant(void)
   }
 }
 
-/*
- * Check if the cursor has moved.  Set the w_valid flag accordingly.
- */
+// Check if the cursor has moved.  Set the w_valid flag accordingly.
 void check_cursor_moved(win_T *wp)
 {
   if (wp->w_cursor.lnum != wp->w_valid_cursor.lnum) {
@@ -435,11 +413,9 @@ void check_cursor_moved(win_T *wp)
   }
 }
 
-/*
- * Call this function when some window settings have changed, which require
- * the cursor position, botline and topline to be recomputed and the window to
- * be redrawn.  E.g, when changing the 'wrap' option or folding.
- */
+// Call this function when some window settings have changed, which require
+// the cursor position, botline and topline to be recomputed and the window to
+// be redrawn.  E.g, when changing the 'wrap' option or folding.
 void changed_window_setting(void)
 {
   changed_window_setting_win(curwin);
@@ -453,9 +429,7 @@ void changed_window_setting_win(win_T *wp)
   redraw_later(wp, UPD_NOT_VALID);
 }
 
-/*
- * Set wp->w_topline to a certain number.
- */
+// Set wp->w_topline to a certain number.
 void set_topline(win_T *wp, linenr_T lnum)
 {
   linenr_T prev_topline = wp->w_topline;
@@ -475,11 +449,9 @@ void set_topline(win_T *wp, linenr_T lnum)
   redraw_later(wp, UPD_VALID);
 }
 
-/*
- * Call this function when the length of the cursor line (in screen
- * characters) has changed, and the change is before the cursor.
- * Need to take care of w_botline separately!
- */
+// Call this function when the length of the cursor line (in screen
+// characters) has changed, and the change is before the cursor.
+// Need to take care of w_botline separately!
 void changed_cline_bef_curs(void)
 {
   curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
@@ -492,11 +464,9 @@ void changed_cline_bef_curs_win(win_T *wp)
                    |VALID_CHEIGHT|VALID_TOPLINE);
 }
 
-/*
- * Call this function when the length of a line (in screen characters) above
- * the cursor have changed.
- * Need to take care of w_botline separately!
- */
+// Call this function when the length of a line (in screen characters) above
+// the cursor have changed.
+// Need to take care of w_botline separately!
 void changed_line_abv_curs(void)
 {
   curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL|VALID_CROW
@@ -509,9 +479,7 @@ void changed_line_abv_curs_win(win_T *wp)
                    |VALID_CHEIGHT|VALID_TOPLINE);
 }
 
-/*
- * Make sure the value of curwin->w_botline is valid.
- */
+// Make sure the value of curwin->w_botline is valid.
 void validate_botline(win_T *wp)
 {
   if (!(wp->w_valid & VALID_BOTLINE)) {
@@ -519,9 +487,7 @@ void validate_botline(win_T *wp)
   }
 }
 
-/*
- * Mark curwin->w_botline as invalid (because of some change in the buffer).
- */
+// Mark curwin->w_botline as invalid (because of some change in the buffer).
 void invalidate_botline(void)
 {
   curwin->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP);
@@ -537,9 +503,7 @@ void approximate_botline_win(win_T *wp)
   wp->w_valid &= ~VALID_BOTLINE;
 }
 
-/*
- * Return true if curwin->w_wrow and curwin->w_wcol are valid.
- */
+// Return true if curwin->w_wrow and curwin->w_wcol are valid.
 int cursor_valid(void)
 {
   check_cursor_moved(curwin);
@@ -547,10 +511,8 @@ int cursor_valid(void)
          (VALID_WROW|VALID_WCOL);
 }
 
-/*
- * Validate cursor position.  Makes sure w_wrow and w_wcol are valid.
- * w_topline must be valid, you may need to call update_topline() first!
- */
+// Validate cursor position.  Makes sure w_wrow and w_wcol are valid.
+// w_topline must be valid, you may need to call update_topline() first!
 void validate_cursor(void)
 {
   check_cursor_moved(curwin);
@@ -559,10 +521,8 @@ void validate_cursor(void)
   }
 }
 
-/*
- * Compute wp->w_cline_row and wp->w_cline_height, based on the current value
- * of wp->w_topline.
- */
+// Compute wp->w_cline_row and wp->w_cline_height, based on the current value
+// of wp->w_topline.
 static void curs_rows(win_T *wp)
 {
   // Check if wp->w_lines[].wl_size is invalid
@@ -633,17 +593,13 @@ static void curs_rows(win_T *wp)
   wp->w_valid |= VALID_CROW|VALID_CHEIGHT;
 }
 
-/*
- * Validate curwin->w_virtcol only.
- */
+// Validate curwin->w_virtcol only.
 void validate_virtcol(void)
 {
   validate_virtcol_win(curwin);
 }
 
-/*
- * Validate wp->w_virtcol only.
- */
+// Validate wp->w_virtcol only.
 void validate_virtcol_win(win_T *wp)
 {
   check_cursor_moved(wp);
@@ -654,9 +610,7 @@ void validate_virtcol_win(win_T *wp)
   }
 }
 
-/*
- * Validate curwin->w_cline_height only.
- */
+// Validate curwin->w_cline_height only.
 void validate_cheight(void)
 {
   check_cursor_moved(curwin);
@@ -668,9 +622,7 @@ void validate_cheight(void)
   }
 }
 
-/*
- * Validate w_wcol and w_virtcol only.
- */
+// Validate w_wcol and w_virtcol only.
 void validate_cursor_col(void)
 {
   validate_virtcol();
@@ -697,10 +649,8 @@ void validate_cursor_col(void)
   }
 }
 
-/*
- * Compute offset of a window, occupied by absolute or relative line number,
- * fold column and sign column (these don't move when scrolling horizontally).
- */
+// Compute offset of a window, occupied by absolute or relative line number,
+// fold column and sign column (these don't move when scrolling horizontally).
 int win_col_off(win_T *wp)
 {
   return ((wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) + 1 : 0)
@@ -714,11 +664,9 @@ int curwin_col_off(void)
   return win_col_off(curwin);
 }
 
-/*
- * Return the difference in column offset for the second screen line of a
- * wrapped line.  It's 8 if 'number' or 'relativenumber' is on and 'n' is in
- * 'cpoptions'.
- */
+// Return the difference in column offset for the second screen line of a
+// wrapped line.  It's 8 if 'number' or 'relativenumber' is on and 'n' is in
+// 'cpoptions'.
 int win_col_off2(win_T *wp)
 {
   if ((wp->w_p_nu || wp->w_p_rnu) && vim_strchr(p_cpo, CPO_NUMCOL) != NULL) {
@@ -746,9 +694,7 @@ void curs_columns(win_T *wp, int may_scroll)
   long so = get_scrolloff_value(wp);
   long siso = get_sidescrolloff_value(wp);
 
-  /*
-   * First make sure that w_topline is valid (after moving the cursor).
-   */
+  // First make sure that w_topline is valid (after moving the cursor).
   update_topline(wp);
 
   // Next make sure that w_cline_row is valid.
@@ -756,9 +702,7 @@ void curs_columns(win_T *wp, int may_scroll)
     curs_rows(wp);
   }
 
-  /*
-   * Compute the number of virtual columns.
-   */
+  // Compute the number of virtual columns.
   if (wp->w_cline_folded) {
     // In a folded line the cursor is always in the first column
     startcol = wp->w_virtcol = endcol = wp->w_leftcol;
@@ -1079,10 +1023,8 @@ bool scrolldown(long line_count, int byfold)
   }
   check_topfill(curwin, true);
 
-  /*
-   * Compute the row number of the last row of the cursor line
-   * and move the cursor onto the displayed part of the window.
-   */
+  // Compute the row number of the last row of the cursor line
+  // and move the cursor onto the displayed part of the window.
   int wrow = curwin->w_wrow;
   if (curwin->w_p_wrap && curwin->w_width_inner != 0) {
     validate_virtcol();
@@ -1200,10 +1142,8 @@ void check_topfill(win_T *wp, bool down)
   win_check_anchored_floats(curwin);
 }
 
-/*
- * Use as many filler lines as possible for w_topline.  Make sure w_topline
- * is still visible.
- */
+// Use as many filler lines as possible for w_topline.  Make sure w_topline
+// is still visible.
 static void max_topfill(void)
 {
   int n = plines_win_nofill(curwin, curwin->w_topline, true);
@@ -1217,10 +1157,8 @@ static void max_topfill(void)
   }
 }
 
-/*
- * Scroll the screen one line down, but don't do it if it would move the
- * cursor off the screen.
- */
+// Scroll the screen one line down, but don't do it if it would move the
+// cursor off the screen.
 void scrolldown_clamp(void)
 {
   int can_fill = (curwin->w_topfill < win_get_fill(curwin, curwin->w_topline));
@@ -1261,10 +1199,8 @@ void scrolldown_clamp(void)
   }
 }
 
-/*
- * Scroll the screen one line up, but don't do it if it would move the cursor
- * off the screen.
- */
+// Scroll the screen one line up, but don't do it if it would move the cursor
+// off the screen.
 void scrollup_clamp(void)
 {
   if (curwin->w_topline == curbuf->b_ml.ml_line_count
@@ -1296,12 +1232,10 @@ void scrollup_clamp(void)
   }
 }
 
-/*
- * Add one line above "lp->lnum".  This can be a filler line, a closed fold or
- * a (wrapped) text line.  Uses and sets "lp->fill".
- * Returns the height of the added line in "lp->height".
- * Lines above the first one are incredibly high: MAXCOL.
- */
+// Add one line above "lp->lnum".  This can be a filler line, a closed fold or
+// a (wrapped) text line.  Uses and sets "lp->fill".
+// Returns the height of the added line in "lp->height".
+// Lines above the first one are incredibly high: MAXCOL.
 static void topline_back(win_T *wp, lineoff_T *lp)
 {
   if (lp->fill < win_get_fill(wp, lp->lnum)) {
@@ -1322,12 +1256,10 @@ static void topline_back(win_T *wp, lineoff_T *lp)
   }
 }
 
-/*
- * Add one line below "lp->lnum".  This can be a filler line, a closed fold or
- * a (wrapped) text line.  Uses and sets "lp->fill".
- * Returns the height of the added line in "lp->height".
- * Lines below the last one are incredibly high.
- */
+// Add one line below "lp->lnum".  This can be a filler line, a closed fold or
+// a (wrapped) text line.  Uses and sets "lp->fill".
+// Returns the height of the added line in "lp->height".
+// Lines below the last one are incredibly high.
 static void botline_forw(win_T *wp, lineoff_T *lp)
 {
   if (lp->fill < win_get_fill(wp, lp->lnum + 1)) {
@@ -1349,11 +1281,9 @@ static void botline_forw(win_T *wp, lineoff_T *lp)
   }
 }
 
-/*
- * Switch from including filler lines below lp->lnum to including filler
- * lines above loff.lnum + 1.  This keeps pointing to the same line.
- * When there are no filler lines nothing changes.
- */
+// Switch from including filler lines below lp->lnum to including filler
+// lines above loff.lnum + 1.  This keeps pointing to the same line.
+// When there are no filler lines nothing changes.
 static void botline_topline(lineoff_T *lp)
 {
   if (lp->fill > 0) {
@@ -1362,11 +1292,9 @@ static void botline_topline(lineoff_T *lp)
   }
 }
 
-/*
- * Switch from including filler lines above lp->lnum to including filler
- * lines below loff.lnum - 1.  This keeps pointing to the same line.
- * When there are no filler lines nothing changes.
- */
+// Switch from including filler lines above lp->lnum to including filler
+// lines below loff.lnum - 1.  This keeps pointing to the same line.
+// When there are no filler lines nothing changes.
 static void topline_botline(lineoff_T *lp)
 {
   if (lp->fill > 0) {
@@ -1375,11 +1303,9 @@ static void topline_botline(lineoff_T *lp)
   }
 }
 
-/*
- * Recompute topline to put the cursor at the top of the window.
- * Scroll at least "min_scroll" lines.
- * If "always" is true, always set topline (for "zt").
- */
+// Recompute topline to put the cursor at the top of the window.
+// Scroll at least "min_scroll" lines.
+// If "always" is true, always set topline (for "zt").
 void scroll_cursor_top(int min_scroll, int always)
 {
   int scrolled = 0;
@@ -1394,13 +1320,11 @@ void scroll_cursor_top(int min_scroll, int always)
     off = mouse_dragging - 1;
   }
 
-  /*
-   * Decrease topline until:
-   * - it has become 1
-   * - (part of) the cursor line is moved off the screen or
-   * - moved at least 'scrolljump' lines and
-   * - at least 'scrolloff' lines above and below the cursor
-   */
+  // Decrease topline until:
+  // - it has become 1
+  // - (part of) the cursor line is moved off the screen or
+  // - moved at least 'scrolljump' lines and
+  // - at least 'scrolloff' lines above and below the cursor
   validate_cheight();
   int used = curwin->w_cline_height;  // includes filler lines above
   if (curwin->w_cursor.lnum < curwin->w_topline) {
@@ -1421,10 +1345,8 @@ void scroll_cursor_top(int min_scroll, int always)
   // Hide filler lines above cursor line by adding them to "extra".
   int extra = win_get_fill(curwin, curwin->w_cursor.lnum);
 
-  /*
-   * Check if the lines from "top" to "bot" fit in the window.  If they do,
-   * set new_topline and advance "top" and "bot" to include more lines.
-   */
+  // Check if the lines from "top" to "bot" fit in the window.  If they do,
+  // set new_topline and advance "top" and "bot" to include more lines.
   while (top > 0) {
     int i = hasFolding(top, &top, NULL)
             ? 1  // count one logical line for a sequence of folded lines
@@ -1445,9 +1367,7 @@ void scroll_cursor_top(int min_scroll, int always)
       scrolled += i;
     }
 
-    /*
-     * If scrolling is needed, scroll at least 'sj' lines.
-     */
+    // If scrolling is needed, scroll at least 'sj' lines.
     if ((new_topline >= curwin->w_topline || scrolled > min_scroll)
         && extra >= off) {
       break;
@@ -1459,18 +1379,14 @@ void scroll_cursor_top(int min_scroll, int always)
     bot++;
   }
 
-  /*
-   * If we don't have enough space, put cursor in the middle.
-   * This makes sure we get the same position when using "k" and "j"
-   * in a small window.
-   */
+  // If we don't have enough space, put cursor in the middle.
+  // This makes sure we get the same position when using "k" and "j"
+  // in a small window.
   if (used > curwin->w_height_inner) {
     scroll_cursor_halfway(false);
   } else {
-    /*
-     * If "always" is false, only adjust topline to a lower value, higher
-     * value may happen with wrapping lines
-     */
+    // If "always" is false, only adjust topline to a lower value, higher
+    // value may happen with wrapping lines
     if (new_topline < curwin->w_topline || always) {
       curwin->w_topline = new_topline;
     }
@@ -1495,10 +1411,8 @@ void scroll_cursor_top(int min_scroll, int always)
   }
 }
 
-/*
- * Set w_empty_rows and w_filler_rows for window "wp", having used up "used"
- * screen lines for text lines.
- */
+// Set w_empty_rows and w_filler_rows for window "wp", having used up "used"
+// screen lines for text lines.
 void set_empty_rows(win_T *wp, int used)
 {
   wp->w_filler_rows = 0;
@@ -1577,13 +1491,11 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
     }
   }
 
-  /*
-   * Stop counting lines to scroll when
-   * - hitting start of the file
-   * - scrolled nothing or at least 'sj' lines
-   * - at least 'so' lines below the cursor
-   * - lines between botline and cursor have been counted
-   */
+  // Stop counting lines to scroll when
+  // - hitting start of the file
+  // - scrolled nothing or at least 'sj' lines
+  // - at least 'so' lines below the cursor
+  // - lines between botline and cursor have been counted
   if (!hasFolding(curwin->w_cursor.lnum, &loff.lnum, &boff.lnum)) {
     loff.lnum = cln;
     boff.lnum = cln;
@@ -1673,21 +1585,17 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
     }
   }
 
-  /*
-   * Scroll up if the cursor is off the bottom of the screen a bit.
-   * Otherwise put it at 1/2 of the screen.
-   */
+  // Scroll up if the cursor is off the bottom of the screen a bit.
+  // Otherwise put it at 1/2 of the screen.
   if (line_count >= curwin->w_height_inner && line_count > min_scroll) {
     scroll_cursor_halfway(false);
   } else {
     scrollup(line_count, true);
   }
 
-  /*
-   * If topline didn't change we need to restore w_botline and w_empty_rows
-   * (we changed them).
-   * If topline did change, update_screen() will set botline.
-   */
+  // If topline didn't change we need to restore w_botline and w_empty_rows
+  // (we changed them).
+  // If topline did change, update_screen() will set botline.
   if (curwin->w_topline == old_topline && set_topbot) {
     curwin->w_botline = old_botline;
     curwin->w_empty_rows = old_empty_rows;
@@ -1760,18 +1668,14 @@ void scroll_cursor_halfway(int atend)
   curwin->w_valid |= VALID_TOPLINE;
 }
 
-/*
- * Correct the cursor position so that it is in a part of the screen at least
- * 'so' lines from the top and bottom, if possible.
- * If not possible, put it at the same position as scroll_cursor_halfway().
- * When called topline must be valid!
- */
+// Correct the cursor position so that it is in a part of the screen at least
+// 'so' lines from the top and bottom, if possible.
+// If not possible, put it at the same position as scroll_cursor_halfway().
+// When called topline must be valid!
 void cursor_correct(void)
 {
-  /*
-   * How many lines we would like to have above/below the cursor depends on
-   * whether the first/last line of the file is on screen.
-   */
+  // How many lines we would like to have above/below the cursor depends on
+  // whether the first/last line of the file is on screen.
   int above_wanted = (int)get_scrolloff_value(curwin);
   int below_wanted = (int)get_scrolloff_value(curwin);
   if (mouse_dragging > 0) {
@@ -1795,10 +1699,8 @@ void cursor_correct(void)
     }
   }
 
-  /*
-   * If there are sufficient file-lines above and below the cursor, we can
-   * return now.
-   */
+  // If there are sufficient file-lines above and below the cursor, we can
+  // return now.
   linenr_T cln = curwin->w_cursor.lnum;  // Cursor Line Number
   if (cln >= curwin->w_topline + above_wanted
       && cln < curwin->w_botline - below_wanted
@@ -1806,12 +1708,10 @@ void cursor_correct(void)
     return;
   }
 
-  /*
-   * Narrow down the area where the cursor can be put by taking lines from
-   * the top and the bottom until:
-   * - the desired context lines are found
-   * - the lines from the top is past the lines from the bottom
-   */
+  // Narrow down the area where the cursor can be put by taking lines from
+  // the top and the bottom until:
+  // - the desired context lines are found
+  // - the lines from the top is past the lines from the bottom
   linenr_T topline = curwin->w_topline;
   linenr_T botline = curwin->w_botline - 1;
   // count filler lines as context
@@ -1860,11 +1760,9 @@ void cursor_correct(void)
   curwin->w_viewport_invalid = true;
 }
 
-/*
- * move screen 'count' pages up or down and update screen
- *
- * return FAIL for failure, OK otherwise
- */
+// move screen 'count' pages up or down and update screen
+//
+// return FAIL for failure, OK otherwise
 int onepage(Direction dir, long count)
 {
   long n;
@@ -2044,18 +1942,16 @@ int onepage(Direction dir, long count)
   return retval;
 }
 
-/*
- * Decide how much overlap to use for page-up or page-down scrolling.
- * This is symmetric, so that doing both keeps the same lines displayed.
- * Three lines are examined:
- *
- *  before CTRL-F           after CTRL-F / before CTRL-B
- *     etc.                     l1
- *  l1 last but one line        ------------
- *  l2 last text line           l2 top text line
- *  -------------               l3 second text line
- *  l3                             etc.
- */
+// Decide how much overlap to use for page-up or page-down scrolling.
+// This is symmetric, so that doing both keeps the same lines displayed.
+// Three lines are examined:
+//
+//  before CTRL-F           after CTRL-F / before CTRL-B
+//     etc.                     l1
+//  l1 last but one line        ------------
+//  l2 last text line           l2 top text line
+//  -------------               l3 second text line
+//  l3                             etc.
 static void get_scroll_overlap(lineoff_T *lp, int dir)
 {
   int min_height = curwin->w_height_inner - 2;
@@ -2125,9 +2021,7 @@ void halfpage(bool flag, linenr_T Prenum)
   validate_botline(curwin);
   int room = curwin->w_empty_rows + curwin->w_filler_rows;
   if (flag) {
-    /*
-     * scroll the text up
-     */
+    // scroll the text up
     while (n > 0 && curwin->w_botline <= curbuf->b_ml.ml_line_count) {
       if (curwin->w_topfill > 0) {
         i = 1;
@@ -2185,9 +2079,7 @@ void halfpage(bool flag, linenr_T Prenum)
       check_cursor_lnum();
     }
   } else {
-    /*
-     * scroll the text down
-     */
+    // scroll the text down
     while (n > 0 && curwin->w_topline > 1) {
       if (curwin->w_topfill < win_get_fill(curwin, curwin->w_topline)) {
         i = 1;
@@ -2247,9 +2139,7 @@ void do_check_cursorbind(void)
   int old_VIsual_select = VIsual_select;
   int old_VIsual_active = VIsual_active;
 
-  /*
-   * loop through the cursorbound windows
-   */
+  // loop through the cursorbound windows
   VIsual_select = VIsual_active = 0;
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
     curwin = wp;
@@ -2294,9 +2184,7 @@ void do_check_cursorbind(void)
     }
   }
 
-  /*
-   * reset current-window
-   */
+  // reset current-window
   VIsual_select = old_VIsual_select;
   VIsual_active = old_VIsual_active;
   curwin = old_curwin;
diff --git a/src/nvim/normal.h b/src/nvim/normal.h
index 13ea233658..0317080f4f 100644
--- a/src/nvim/normal.h
+++ b/src/nvim/normal.h
@@ -22,9 +22,7 @@ typedef enum {
   kMTUnknown = -1,  ///< Unknown or invalid motion type
 } MotionType;
 
-/*
- * Arguments for operators.
- */
+// Arguments for operators.
 typedef struct oparg_S {
   int op_type;                  // current pending operator type
   int regname;                  // register to use for the operator
@@ -53,9 +51,7 @@ typedef struct oparg_S {
                                 // block
 } oparg_T;
 
-/*
- * Arguments for Normal mode commands.
- */
+// Arguments for Normal mode commands.
 typedef struct cmdarg_S {
   oparg_T *oap;                 // Operator arguments
   int prechar;                  // prefix character (optional, always 'g')
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 01fd4bb9a7..25b957e3b9 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -1,10 +1,8 @@
 // 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
 
-/*
- * ops.c: implementation of various operators: op_shift, op_delete, op_tilde,
- *        op_change, op_yank, do_put, do_join
- */
+// ops.c: implementation of various operators: op_shift, op_delete, op_tilde,
+//        op_change, op_yank, do_put, do_join
 
 #include <assert.h>
 #include <inttypes.h>
@@ -67,10 +65,8 @@ static bool clipboard_delay_update = false;  // delay clipboard update
 static bool clipboard_needs_update = false;  // clipboard was updated
 static bool clipboard_didwarn = false;
 
-/*
- * structure used by block_prep, op_delete and op_yank for blockwise operators
- * also op_change, op_shift, op_insert, op_replace - AKelly
- */
+// structure used by block_prep, op_delete and op_yank for blockwise operators
+// also op_change, op_shift, op_insert, op_replace - AKelly
 struct block_def {
   int startspaces;              // 'extra' cols before first char
   int endspaces;                // 'extra' cols after last char
@@ -96,11 +92,9 @@ struct block_def {
 #define OPF_LINES  1  // operator always works on lines
 #define OPF_CHANGE 2  // operator changes text
 
-/*
- * The names of operators.
- * IMPORTANT: Index must correspond with defines in vim.h!!!
- * The third field indicates whether the operator always works on lines.
- */
+// The names of operators.
+// IMPORTANT: Index must correspond with defines in vim.h!!!
+// The third field indicates whether the operator always works on lines.
 static char opchars[][3] =
 {
   { NUL, NUL, 0 },                       // OP_NOP
@@ -361,12 +355,10 @@ static void shift_block(oparg_T *oap, int amount)
   int startcol, oldlen, newlen;
 
   if (!left) {
-    /*
-     *  1. Get start vcol
-     *  2. Total ws vcols
-     *  3. Divvy into TABs & spp
-     *  4. Construct new string
-     */
+    //  1. Get start vcol
+    //  2. Total ws vcols
+    //  3. Divvy into TABs & spp
+    //  4. Construct new string
     total += bd.pre_whitesp;    // all virtual WS up to & incl a split TAB
     colnr_T ws_vcol = bd.start_vcol - bd.pre_whitesp;
     char_u *old_textstart = bd.textstart;
@@ -428,13 +420,11 @@ static void shift_block(oparg_T *oap, int amount)
                                   // block shift
     char_u *non_white = bd.textstart;
 
-    /*
-     * Firstly, let's find the first non-whitespace character that is
-     * displayed after the block's start column and the character's column
-     * number. Also, let's calculate the width of all the whitespace
-     * characters that are displayed in the block and precede the searched
-     * non-whitespace character.
-     */
+    // Firstly, let's find the first non-whitespace character that is
+    // displayed after the block's start column and the character's column
+    // number. Also, let's calculate the width of all the whitespace
+    // characters that are displayed in the block and precede the searched
+    // non-whitespace character.
 
     // If "bd.startspaces" is set, "bd.textstart" points to the character,
     // the part of which is displayed at the block's beginning. Let's start
@@ -715,9 +705,7 @@ void op_reindent(oparg_T *oap, Indenter how)
   }
 }
 
-/*
- * Keep the last expression line here, for repeating.
- */
+// Keep the last expression line here, for repeating.
 static char_u *expr_line = NULL;
 
 /// Get an expression for the "\"=expr1" or "CTRL-R =expr1"
@@ -1165,9 +1153,7 @@ int do_execreg(int regname, int colon, int addcr, int silent)
     // Disallow remapping for ":@r".
     int remap = colon ? REMAP_NONE : REMAP_YES;
 
-    /*
-     * Insert lines into typeahead buffer, from last one to first one.
-     */
+    // Insert lines into typeahead buffer, from last one to first one.
     put_reedit_in_typebuf(silent);
     char *escaped;
     for (size_t i = reg->y_size; i-- > 0;) {  // from y_size - 1 to 0 included
@@ -1277,11 +1263,9 @@ int insert_reg(int regname, bool literally_arg)
   bool allocated;
   const bool literally = literally_arg || is_literal_register(regname);
 
-  /*
-   * It is possible to get into an endless loop by having CTRL-R a in
-   * register a and then, in insert mode, doing CTRL-R a.
-   * If you hit CTRL-C, the loop will be broken here.
-   */
+  // It is possible to get into an endless loop by having CTRL-R a in
+  // register a and then, in insert mode, doing CTRL-R a.
+  // If you hit CTRL-C, the loop will be broken here.
   os_breakcheck();
   if (got_int) {
     return FAIL;
@@ -1503,11 +1487,9 @@ int op_delete(oparg_T *oap)
 
   mb_adjust_opend(oap);
 
-  /*
-   * Imitate the strange Vi behaviour: If the delete spans more than one
-   * line and motion_type == kMTCharWise and the result is a blank line, make the
-   * delete linewise.  Don't do this for the change command or Visual mode.
-   */
+  // Imitate the strange Vi behaviour: If the delete spans more than one
+  // line and motion_type == kMTCharWise and the result is a blank line, make the
+  // delete linewise.  Don't do this for the change command or Visual mode.
   if (oap->motion_type == kMTCharWise
       && !oap->is_VIsual
       && oap->line_count > 1
@@ -1523,10 +1505,8 @@ int op_delete(oparg_T *oap)
     }
   }
 
-  /*
-   * Check for trying to delete (e.g. "D") in an empty line.
-   * Note: For the change operator it is ok.
-   */
+  // Check for trying to delete (e.g. "D") in an empty line.
+  // Note: For the change operator it is ok.
   if (oap->motion_type != kMTLineWise
       && oap->line_count == 1
       && oap->op_type == OP_DELETE
@@ -1544,11 +1524,9 @@ int op_delete(oparg_T *oap)
     return OK;
   }
 
-  /*
-   * Do a yank of whatever we're about to delete.
-   * If a yank register was specified, put the deleted text into that
-   * register.  For the black hole register '_' don't yank anything.
-   */
+  // Do a yank of whatever we're about to delete.
+  // If a yank register was specified, put the deleted text into that
+  // register.  For the black hole register '_' don't yank anything.
   if (oap->regname != '_') {
     yankreg_T *reg = NULL;
     int did_yank = false;
@@ -1592,9 +1570,7 @@ int op_delete(oparg_T *oap)
     }
   }
 
-  /*
-   * block mode delete
-   */
+  // block mode delete
   if (oap->motion_type == kMTBlockWise) {
     if (u_save((linenr_T)(oap->start.lnum - 1),
                (linenr_T)(oap->end.lnum + 1)) == FAIL) {
@@ -1873,9 +1849,7 @@ static int op_replace(oparg_T *oap, int c)
     return FAIL;
   }
 
-  /*
-   * block mode replace
-   */
+  // block mode replace
   if (oap->motion_type == kMTBlockWise) {
     bd.is_MAX = (curwin->w_curswant == MAXCOL);
     for (; curwin->w_cursor.lnum <= oap->end.lnum; curwin->w_cursor.lnum++) {
@@ -2409,10 +2383,8 @@ void op_insert(oparg_T *oap, long count1)
       bd.textlen = bd2.textlen;
     }
 
-    /*
-     * Subsequent calls to ml_get() flush the firstline data - take a
-     * copy of the required string.
-     */
+    // Subsequent calls to ml_get() flush the firstline data - take a
+    // copy of the required string.
     firstline = ml_get(oap->start.lnum);
     const size_t len = STRLEN(firstline);
     colnr_T add = bd.textcol;
@@ -2510,11 +2482,9 @@ int op_change(oparg_T *oap)
 
   retval = edit(NUL, false, (linenr_T)1);
 
-  /*
-   * In Visual block mode, handle copying the new text to all lines of the
-   * block.
-   * Don't repeat the insert when Insert mode ended with CTRL-C.
-   */
+  // In Visual block mode, handle copying the new text to all lines of the
+  // block.
+  // Don't repeat the insert when Insert mode ended with CTRL-C.
   if (oap->motion_type == kMTBlockWise
       && oap->start.lnum != oap->end.lnum && !got_int) {
     // Auto-indenting may have changed the indent.  If the cursor was past
@@ -2973,10 +2943,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
   curbuf->b_op_start = curwin->w_cursor;        // default for '[ mark
   curbuf->b_op_end = curwin->w_cursor;          // default for '] mark
 
-  /*
-   * Using inserted text works differently, because the register includes
-   * special characters (newlines, etc.).
-   */
+  // Using inserted text works differently, because the register includes
+  // special characters (newlines, etc.).
   if (regname == '.' && !reg) {
     bool non_linewise_vis = (VIsual_active && VIsual_mode != 'V');
 
@@ -3056,10 +3024,8 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
     return;
   }
 
-  /*
-   * For special registers '%' (file name), '#' (alternate file name) and
-   * ':' (last command line), etc. we have to create a fake yank register.
-   */
+  // For special registers '%' (file name), '#' (alternate file name) and
+  // ':' (last command line), etc. we have to create a fake yank register.
   if (!reg && get_spec_reg(regname, &insert_string, &allocated, true)) {
     if (insert_string == NULL) {
       return;
@@ -3232,9 +3198,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
   lnum = curwin->w_cursor.lnum;
   col = curwin->w_cursor.col;
 
-  /*
-   * Block mode
-   */
+  // Block mode
   if (y_type == kMTBlockWise) {
     int c = gchar_cursor();
     colnr_T endcol2 = 0;
@@ -4129,13 +4093,11 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   cend = newp + sumsize;
   *cend = 0;
 
-  /*
-   * Move affected lines to the new long one.
-   *
-   * Move marks from each deleted line to the joined line, adjusting the
-   * column.  This is not Vi compatible, but Vi deletes the marks, thus that
-   * should not really be a problem.
-   */
+  // Move affected lines to the new long one.
+  //
+  // Move marks from each deleted line to the joined line, adjusting the
+  // column.  This is not Vi compatible, but Vi deletes the marks, thus that
+  // should not really be a problem.
 
   curbuf_splice_pending++;
 
@@ -4185,11 +4147,9 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   changed_lines(curwin->w_cursor.lnum, currsize,
                 curwin->w_cursor.lnum + 1, 0L, true);
 
-  /*
-   * Delete following lines. To do this we move the cursor there
-   * briefly, and then move it back. After del_lines() the cursor may
-   * have moved up (last line deleted), so the current lnum is kept in t.
-   */
+  // Delete following lines. To do this we move the cursor there
+  // briefly, and then move it back. After del_lines() the cursor may
+  // have moved up (last line deleted), so the current lnum is kept in t.
   t = curwin->w_cursor.lnum;
   curwin->w_cursor.lnum++;
   del_lines((long)count - 1, false);
@@ -4197,11 +4157,9 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
   curbuf_splice_pending--;
   curbuf->deleted_bytes2 = 0;
 
-  /*
-   * Set the cursor column:
-   * Vi compatible: use the column of the first join
-   * vim:             use the column of the last join
-   */
+  // Set the cursor column:
+  // Vi compatible: use the column of the first join
+  // vim:             use the column of the last join
   curwin->w_cursor.col =
     (vim_strchr(p_cpo, CPO_JOINCOL) != NULL ? currsize : col);
   check_cursor_col();
@@ -4963,16 +4921,12 @@ void *get_reg_contents(int regname, int flags)
     return list;
   }
 
-  /*
-   * Compute length of resulting string.
-   */
+  // Compute length of resulting string.
   size_t len = 0;
   for (size_t i = 0; i < reg->y_size; i++) {
     len += STRLEN(reg->y_array[i]);
-    /*
-     * Insert a newline between lines and after last line if
-     * y_type is kMTLineWise.
-     */
+    // Insert a newline between lines and after last line if
+    // y_type is kMTLineWise.
     if (reg->y_type == kMTLineWise || i < reg->y_size - 1) {
       len++;
     }
@@ -4980,18 +4934,14 @@ void *get_reg_contents(int regname, int flags)
 
   retval = xmalloc(len + 1);
 
-  /*
-   * Copy the lines of the yank register into the string.
-   */
+  // Copy the lines of the yank register into the string.
   len = 0;
   for (size_t i = 0; i < reg->y_size; i++) {
     STRCPY(retval + len, reg->y_array[i]);
     len += STRLEN(retval + len);
 
-    /*
-     * Insert a NL between lines and after the last line if y_type is
-     * kMTLineWise.
-     */
+    // Insert a NL between lines and after the last line if y_type is
+    // kMTLineWise.
     if (reg->y_type == kMTLineWise || i < reg->y_size - 1) {
       retval[len++] = '\n';
     }
diff --git a/src/nvim/ops.h b/src/nvim/ops.h
index 05893c9940..840e33a48c 100644
--- a/src/nvim/ops.h
+++ b/src/nvim/ops.h
@@ -23,15 +23,13 @@ typedef int (*Indenter)(void);
 #define PUT_LINE_FORWARD 32     // put linewise register below Visual sel.
 #define PUT_BLOCK_INNER  64     // in block mode, do not add trailing spaces
 
-/*
- * Registers:
- *      0 = register for latest (unnamed) yank
- *   1..9 = registers '1' to '9', for deletes
- * 10..35 = registers 'a' to 'z'
- *     36 = delete register '-'
- *     37 = selection register '*'
- *     38 = clipboard register '+'
- */
+// Registers:
+//      0 = register for latest (unnamed) yank
+//   1..9 = registers '1' to '9', for deletes
+// 10..35 = registers 'a' to 'z'
+//     36 = delete register '-'
+//     37 = selection register '*'
+//     38 = clipboard register '+'
 #define DELETION_REGISTER 36
 #define NUM_SAVED_REGISTERS 37
 // The following registers should not be saved in ShaDa file:
diff --git a/src/nvim/option.c b/src/nvim/option.c
index f8b7d96305..12c2888f5c 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -106,14 +106,12 @@ static char e_number_required_after_equal[]
 static char e_preview_window_already_exists[]
   = N_("E590: A preview window already exists");
 
-/*
- * The options that are local to a window or buffer have "indir" set to one of
- * these values.  Special values:
- * PV_NONE: global option.
- * PV_WIN is added: window-local option
- * PV_BUF is added: buffer-local option
- * PV_BOTH is added: global option which also has a local value.
- */
+// The options that are local to a window or buffer have "indir" set to one of
+// these values.  Special values:
+// PV_NONE: global option.
+// PV_WIN is added: window-local option
+// PV_BUF is added: buffer-local option
+// PV_BOTH is added: global option which also has a local value.
 #define PV_BOTH 0x1000
 #define PV_WIN  0x2000
 #define PV_BUF  0x4000
@@ -128,10 +126,8 @@ typedef enum {
   PV_MAXVAL = 0xffff,  // to avoid warnings for value out of range
 } idopt_T;
 
-/*
- * Options local to a window have a value local to a buffer and global to all
- * buffers.  Indicate this by setting "var" to VAR_WIN.
- */
+// Options local to a window have a value local to a buffer and global to all
+// buffers.  Indicate this by setting "var" to VAR_WIN.
 #define VAR_WIN ((char_u *)-1)
 
 static char *p_term = NULL;
@@ -164,14 +160,12 @@ typedef struct vimoption {
   LastSet last_set;             // script in which the option was last set
 } vimoption_T;
 
-/*
- * options[] is initialized here.
- * The order of the options MUST be alphabetic for ":set all" and findoption().
- * All option names MUST start with a lowercase letter (for findoption()).
- * Exception: "t_" options are at the end.
- * The options with a NULL variable are 'hidden': a set command for them is
- * ignored and they are not printed.
- */
+// options[] is initialized here.
+// The order of the options MUST be alphabetic for ":set all" and findoption().
+// All option names MUST start with a lowercase letter (for findoption()).
+// Exception: "t_" options are at the end.
+// The options with a NULL variable are 'hidden': a set command for them is
+// ignored and they are not printed.
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "options.generated.h"
@@ -197,10 +191,8 @@ void set_init_1(bool clean_arg)
 
   langmap_init();
 
-  /*
-   * Find default value for 'shell' option.
-   * Don't use it if it is empty.
-   */
+  // Find default value for 'shell' option.
+  // Don't use it if it is empty.
   {
     const char *shell = os_getenv("SHELL");
     if (shell != NULL) {
@@ -215,10 +207,8 @@ void set_init_1(bool clean_arg)
     }
   }
 
-  /*
-   * Set the default for 'backupskip' to include environment variables for
-   * temp files.
-   */
+  // Set the default for 'backupskip' to include environment variables for
+  // temp files.
   {
 #ifdef UNIX
     static char *(names[4]) = { "", "TMPDIR", "TEMP", "TMP" };
@@ -354,10 +344,8 @@ void set_init_1(bool clean_arg)
     rtp = NULL;  // ownership taken
   }
 
-  /*
-   * Set all the options (except the terminal options) to their default
-   * value.  Also set the global value for local options.
-   */
+  // Set all the options (except the terminal options) to their default
+  // value.  Also set the global value for local options.
   set_options_default(0);
 
   curbuf->b_p_initialized = true;
@@ -380,15 +368,13 @@ void set_init_1(bool clean_arg)
   // didset_options() because it only depends on 'encoding'.
   init_spell_chartab();
 
-  /*
-   * Expand environment variables and things like "~" for the defaults.
-   * If option_expand() returns non-NULL the variable is expanded.  This can
-   * only happen for non-indirect options.
-   * Also set the default to the expanded value, so ":set" does not list
-   * them.
-   * Don't set the P_ALLOCED flag, because we don't want to free the
-   * default.
-   */
+  // Expand environment variables and things like "~" for the defaults.
+  // If option_expand() returns non-NULL the variable is expanded.  This can
+  // only happen for non-indirect options.
+  // Also set the default to the expanded value, so ":set" does not list
+  // them.
+  // Don't set the P_ALLOCED flag, because we don't want to free the
+  // default.
   for (opt_idx = 0; options[opt_idx].fullname; opt_idx++) {
     if (options[opt_idx].flags & P_NO_DEF_EXP) {
       continue;
@@ -635,10 +621,8 @@ void set_init_2(bool headless)
   }
   comp_col();
 
-  /*
-   * 'window' is only for backwards compatibility with Vi.
-   * Default is Rows - 1.
-   */
+  // 'window' is only for backwards compatibility with Vi.
+  // Default is Rows - 1.
   if (!option_was_set("window")) {
     p_window = Rows - 1;
   }
@@ -758,11 +742,9 @@ void set_title_defaults(void)
 {
   int idx1;
 
-  /*
-   * If GUI is (going to be) used, we can always set the window title and
-   * icon name.  Saves a bit of time, because the X11 display server does
-   * not need to be contacted.
-   */
+  // If GUI is (going to be) used, we can always set the window title and
+  // icon name.  Saves a bit of time, because the X11 display server does
+  // not need to be contacted.
   idx1 = findoption("title");
   if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
     options[idx1].def_val = (char_u *)(intptr_t)0;
@@ -837,10 +819,8 @@ int do_set(char *arg, int opt_flags)
 
     if (STRNCMP(arg, "all", 3) == 0 && !isalpha(arg[3])
         && !(opt_flags & OPT_MODELINE)) {
-      /*
-       * ":set all"  show all options.
-       * ":set all&" set all options to their default value.
-       */
+      // ":set all"  show all options.
+      // ":set all&" set all options to their default value.
       arg += 3;
       if (*arg == '&') {
         arg++;
@@ -1016,9 +996,7 @@ int do_set(char *arg, int opt_flags)
           || (prefix == 1
               && vim_strchr("=:&<", nextchar) == NULL
               && !(flags & P_BOOL))) {
-        /*
-         * print value
-         */
+        // print value
         if (did_show) {
           msg_putchar('\n');                // cursor below last one
         } else {
@@ -1057,11 +1035,9 @@ int do_set(char *arg, int opt_flags)
             goto skip;
           }
 
-          /*
-           * ":set opt!": invert
-           * ":set opt&": reset to default value
-           * ":set opt<": reset to global value
-           */
+          // ":set opt!": invert
+          // ":set opt&": reset to default value
+          // ":set opt<": reset to global value
           if (nextchar == '!') {
             value = *(int *)(varp) ^ 1;
           } else if (nextchar == '&') {
@@ -1076,10 +1052,8 @@ int do_set(char *arg, int opt_flags)
                                              OPT_GLOBAL);
             }
           } else {
-            /*
-             * ":set invopt": invert
-             * ":set opt" or ":set noopt": set or reset
-             */
+            // ":set invopt": invert
+            // ":set opt" or ":set noopt": set or reset
             if (nextchar != NUL && !ascii_iswhite(afterchar)) {
               errmsg = e_trailing;
               goto skip;
@@ -1289,11 +1263,10 @@ int do_set(char *arg, int opt_flags)
                 arg++;
               }
 
-              /*
-               * Copy the new string into allocated memory.
-               * Can't use set_string_option_direct(), because
-               * we need to remove the backslashes.
-               */
+              // Copy the new string into allocated memory.
+              // Can't use set_string_option_direct(), because
+              // we need to remove the backslashes.
+
               // get a bit too much
               newlen = (unsigned)STRLEN(arg) + 1;
               if (adding || prepending || removing) {
@@ -1302,14 +1275,12 @@ int do_set(char *arg, int opt_flags)
               newval = xmalloc(newlen);
               s = newval;
 
-              /*
-               * Copy the string, skip over escaped chars.
-               * For WIN32 backslashes before normal
-               * file name characters are not removed, and keep
-               * backslash at start, for "\\machine\path", but
-               * do remove it for "\\\\machine\\path".
-               * The reverse is found in ExpandOldSetting().
-               */
+              // Copy the string, skip over escaped chars.
+              // For WIN32 backslashes before normal
+              // file name characters are not removed, and keep
+              // backslash at start, for "\\machine\path", but
+              // do remove it for "\\\\machine\\path".
+              // The reverse is found in ExpandOldSetting().
               while (*arg && !ascii_iswhite(*arg)) {
                 if (*arg == '\\' && arg[1] != NUL
 #ifdef BACKSLASH_IN_FILENAME
@@ -1335,11 +1306,9 @@ int do_set(char *arg, int opt_flags)
               }
               *s = NUL;
 
-              /*
-               * Expand environment variables and ~.
-               * Don't do it when adding without inserting a
-               * comma.
-               */
+              // Expand environment variables and ~.
+              // Don't do it when adding without inserting a
+              // comma.
               if (!(adding || prepending || removing)
                   || (flags & P_COMMA)) {
                 s = option_expand(opt_idx, newval);
@@ -1521,12 +1490,10 @@ int do_set(char *arg, int opt_flags)
       }
 
 skip:
-      /*
-       * Advance to next argument.
-       * - skip until a blank found, taking care of backslashes
-       * - skip blanks
-       * - skip one "=val" argument (for hidden options ":set gfn =xx")
-       */
+      // Advance to next argument.
+      // - skip until a blank found, taking care of backslashes
+      // - skip blanks
+      // - skip one "=val" argument (for hidden options ":set gfn =xx")
       for (i = 0; i < 2; i++) {
         while (*arg != NUL && !ascii_iswhite(*arg)) {
           if (*arg++ == '\\' && *arg != NUL) {
@@ -1629,10 +1596,8 @@ void did_set_title(void)
 /// @param opt_flags  OPT_LOCAL and/or OPT_GLOBAL
 void set_options_bin(int oldval, int newval, int opt_flags)
 {
-  /*
-   * The option values that are changed when 'bin' changes are
-   * copied when 'bin is set and restored when 'bin' is reset.
-   */
+  // The option values that are changed when 'bin' changes are
+  // copied when 'bin is set and restored when 'bin' is reset.
   if (newval) {
     if (!oldval) {              // switched on
       if (!(opt_flags & OPT_GLOBAL)) {
@@ -1735,12 +1700,10 @@ static char_u *option_expand(int opt_idx, char_u *val)
     return NULL;
   }
 
-  /*
-   * Expanding this with NameBuff, expand_env() must not be passed IObuff.
-   * Escape spaces when expanding 'tags', they are used to separate file
-   * names.
-   * For 'spellsuggest' expand after "file:".
-   */
+  // Expanding this with NameBuff, expand_env() must not be passed IObuff.
+  // Escape spaces when expanding 'tags', they are used to separate file
+  // names.
+  // For 'spellsuggest' expand after "file:".
   expand_env_esc(val, (char_u *)NameBuff, MAXPATHL,
                  (char_u **)options[opt_idx].var == &p_tags, false,
                  (char_u **)options[opt_idx].var == (char_u **)&p_sps ? (char_u *)"file:" :
@@ -2153,9 +2116,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
 
   if ((int *)varp == &curwin->w_p_arab) {
     if (curwin->w_p_arab) {
-      /*
-       * 'arabic' is set, handle various sub-settings.
-       */
+      // 'arabic' is set, handle various sub-settings.
       if (!p_tbidi) {
         // set rightleft mode
         if (!curwin->w_p_rl) {
@@ -2186,9 +2147,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
       // Force-set the necessary keymap for arabic.
       errmsg = set_option_value("keymap", 0L, "arabic", OPT_LOCAL);
     } else {
-      /*
-       * 'arabic' is reset, handle various sub-settings.
-       */
+      // 'arabic' is reset, handle various sub-settings.
       if (!p_tbidi) {
         // reset rightleft mode
         if (curwin->w_p_rl) {
@@ -2209,9 +2168,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
     }
   }
 
-  /*
-   * End of handling side effects for bool options.
-   */
+  // End of handling side effects for bool options.
 
   // after handling side effects, call autocommand
 
@@ -3328,9 +3285,7 @@ static void showoptions(int all, int opt_flags)
       }
     }
 
-    /*
-     * display the items
-     */
+    // display the items
     if (run == 1) {
       assert(Columns <= INT_MAX - GAP
              && Columns + GAP >= INT_MIN + 3
@@ -3467,15 +3422,13 @@ int makeset(FILE *fd, int opt_flags, int local_only)
   int round;
   int pri;
 
-  /*
-   * Some options are never written:
-   * - Options that don't have a default (terminal name, columns, lines).
-   * - Terminal options.
-   * - Hidden options.
-   *
-   * Do the loop over "options[]" twice: once for options with the
-   * P_PRI_MKRC flag and once without.
-   */
+  // Some options are never written:
+  // - Options that don't have a default (terminal name, columns, lines).
+  // - Terminal options.
+  // - Hidden options.
+  //
+  // Do the loop over "options[]" twice: once for options with the
+  // P_PRI_MKRC flag and once without.
   for (pri = 1; pri >= 0; pri--) {
     for (p = &options[0]; p->fullname; p++) {
       if (!(p->flags & P_NO_MKRC)
@@ -4400,10 +4353,8 @@ void buf_copy_options(buf_T *buf, int flags)
   int dont_do_help;
   int did_isk = false;
 
-  /*
-   * Skip this when the option defaults have not been set yet.  Happens when
-   * main() allocates the first buffer.
-   */
+  // Skip this when the option defaults have not been set yet.  Happens when
+  // main() allocates the first buffer.
   if (p_cpo != NULL) {
     //
     // Always copy when entering and 'cpo' contains 'S'.
@@ -4617,12 +4568,10 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_lw = empty_option;
       buf->b_p_menc = empty_option;
 
-      /*
-       * Don't copy the options set by ex_help(), use the saved values,
-       * when going from a help buffer to a non-help buffer.
-       * Don't touch these at all when BCO_NOHELP is used and going from
-       * or to a help buffer.
-       */
+      // Don't copy the options set by ex_help(), use the saved values,
+      // when going from a help buffer to a non-help buffer.
+      // Don't touch these at all when BCO_NOHELP is used and going from
+      // or to a help buffer.
       if (dont_do_help) {
         buf->b_p_isk = (char *)save_p_isk;
         if (p_vts && p_vts != empty_option && !buf->b_p_vts_array) {
@@ -4652,10 +4601,8 @@ void buf_copy_options(buf_T *buf, int flags)
       }
     }
 
-    /*
-     * When the options should be copied (ignoring BCO_ALWAYS), set the
-     * flag that indicates that the options have been initialized.
-     */
+    // When the options should be copied (ignoring BCO_ALWAYS), set the
+    // flag that indicates that the options have been initialized.
     if (should_copy) {
       buf->b_p_initialized = true;
     }
@@ -4947,9 +4894,7 @@ void ExpandOldSetting(int *num_file, char ***file)
   *num_file = 0;
   *file = xmalloc(sizeof(char_u *));
 
-  /*
-   * For a terminal key code expand_option_idx is < 0.
-   */
+  // For a terminal key code expand_option_idx is < 0.
   if (expand_option_idx < 0) {
     expand_option_idx = findoption((const char *)expand_option_name);
   }
@@ -5055,10 +5000,8 @@ static void paste_option_changed(void)
   static int save_hkmap = 0;
 
   if (p_paste) {
-    /*
-     * Paste switched from off to on.
-     * Save the current values, so they can be restored later.
-     */
+    // Paste switched from off to on.
+    // Save the current values, so they can be restored later.
     if (!old_p_paste) {
       // save options for each buffer
       FOR_ALL_BUFFERS(buf) {
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 6af6b16e86..bfac0cff87 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -379,9 +379,7 @@ enum {
 #define LISPWORD_VALUE \
   "defun,define,defmacro,set!,lambda,if,case,let,flet,let*,letrec,do,do*,define-syntax,let-syntax,letrec-syntax,destructuring-bind,defpackage,defparameter,defstruct,deftype,defvar,do-all-symbols,do-external-symbols,do-symbols,dolist,dotimes,ecase,etypecase,eval-when,labels,macrolet,multiple-value-bind,multiple-value-call,multiple-value-prog1,multiple-value-setq,prog1,progv,typecase,unless,unwind-protect,when,with-input-from-string,with-open-file,with-open-stream,with-output-to-string,with-package-iterator,define-condition,handler-bind,handler-case,restart-bind,restart-case,with-simple-restart,store-value,use-value,muffle-warning,abort,continue,with-slots,with-slots*,with-accessors,with-accessors*,defclass,defmethod,print-unreadable-object"
 
-/*
- * The following are actual variables for the options
- */
+// The following are actual variables for the options
 
 EXTERN long p_aleph;            // 'aleph'
 EXTERN char *p_ambw;            ///< 'ambiwidth'
@@ -924,11 +922,9 @@ enum {
   BV_COUNT,  // must be the last one
 };
 
-/*
- * "indir" values for window-local options.
- * These need to be defined globally, so that the WV_COUNT can be used in the
- * window structure.
- */
+// "indir" values for window-local options.
+// These need to be defined globally, so that the WV_COUNT can be used in the
+// window structure.
 enum {
   WV_LIST = 0,
   WV_ARAB,
diff --git a/src/nvim/path.c b/src/nvim/path.c
index e6de5388e0..607f1fc09a 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -248,9 +248,7 @@ int vim_ispathsep(int c)
 #endif
 }
 
-/*
- * Like vim_ispathsep(c), but exclude the colon for MS-Windows.
- */
+// Like vim_ispathsep(c), but exclude the colon for MS-Windows.
 int vim_ispathsep_nocolon(int c)
 {
   return vim_ispathsep(c)
@@ -532,9 +530,7 @@ bool path_has_wildcard(const char *p)
   return false;
 }
 
-/*
- * Unix style wildcard expansion code.
- */
+// Unix style wildcard expansion code.
 static int pstrcmp(const void *a, const void *b)
 {
   return pathcmp(*(char **)a, *(char **)b, -1);
@@ -779,10 +775,8 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   return matches;
 }
 
-/*
- * Moves "*psep" back to the previous path separator in "path".
- * Returns FAIL is "*psep" ends up at the beginning of "path".
- */
+// Moves "*psep" back to the previous path separator in "path".
+// Returns FAIL is "*psep" ends up at the beginning of "path".
 static int find_previous_pathsep(char_u *path, char_u **psep)
 {
   // skip the current separator
@@ -825,15 +819,13 @@ static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
   return true;  // no match found
 }
 
-/*
- * Split the 'path' option into an array of strings in garray_T.  Relative
- * paths are expanded to their equivalent fullpath.  This includes the "."
- * (relative to current buffer directory) and empty path (relative to current
- * directory) notations.
- *
- * TODO: handle upward search (;) and path limiter (**N) notations by
- * expanding each into their equivalent path(s).
- */
+// Split the 'path' option into an array of strings in garray_T.  Relative
+// paths are expanded to their equivalent fullpath.  This includes the "."
+// (relative to current buffer directory) and empty path (relative to current
+// directory) notations.
+//
+// TODO(vim): handle upward search (;) and path limiter (**N) notations by
+// expanding each into their equivalent path(s).
 static void expand_path_option(char_u *curdir, garray_T *gap)
 {
   char_u *path_option = *curbuf->b_p_path == NUL ? p_path : (char_u *)curbuf->b_p_path;
@@ -883,14 +875,12 @@ static void expand_path_option(char_u *curdir, garray_T *gap)
   xfree(buf);
 }
 
-/*
- * Returns a pointer to the file or directory name in "fname" that matches the
- * longest path in "ga"p, or NULL if there is no match. For example:
- *
- *    path: /foo/bar/baz
- *   fname: /foo/bar/baz/quux.txt
- * returns:              ^this
- */
+// Returns a pointer to the file or directory name in "fname" that matches the
+// longest path in "ga"p, or NULL if there is no match. For example:
+//
+//    path: /foo/bar/baz
+//   fname: /foo/bar/baz/quux.txt
+// returns:              ^this
 static char_u *get_path_cutoff(char_u *fname, garray_T *gap)
 {
   int maxlen = 0;
@@ -924,11 +914,9 @@ static char_u *get_path_cutoff(char_u *fname, garray_T *gap)
   return cutoff;
 }
 
-/*
- * Sorts, removes duplicates and modifies all the fullpath names in "gap" so
- * that they are unique with respect to each other while conserving the part
- * that matches the pattern. Beware, this is at least O(n^2) wrt "gap->ga_len".
- */
+// Sorts, removes duplicates and modifies all the fullpath names in "gap" so
+// that they are unique with respect to each other while conserving the part
+// that matches the pattern. Beware, this is at least O(n^2) wrt "gap->ga_len".
 static void uniquefy_paths(garray_T *gap, char_u *pattern)
 {
   char_u **fnames = (char_u **)gap->ga_data;
@@ -1212,26 +1200,23 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
   int add_pat;
   bool did_expand_in_path = false;
 
-  /*
-   * expand_env() is called to expand things like "~user".  If this fails,
-   * it calls ExpandOne(), which brings us back here.  In this case, always
-   * call the machine specific expansion function, if possible.  Otherwise,
-   * return FAIL.
-   */
-  if (recursive)
+  // expand_env() is called to expand things like "~user".  If this fails,
+  // it calls ExpandOne(), which brings us back here.  In this case, always
+  // call the machine specific expansion function, if possible.  Otherwise,
+  // return FAIL.
+  if (recursive) {
 #ifdef SPECIAL_WILDCHAR
-  { return os_expand_wildcards(num_pat, pat, num_file, file, flags); }
+    return os_expand_wildcards(num_pat, pat, num_file, file, flags);
 #else
-  { return FAIL; }
+    return FAIL;
 #endif
+  }
 
 #ifdef SPECIAL_WILDCHAR
-  /*
-   * If there are any special wildcard characters which we cannot handle
-   * here, call machine specific function for all the expansion.  This
-   * avoids starting the shell for each argument separately.
-   * For `=expr` do use the internal function.
-   */
+  // If there are any special wildcard characters which we cannot handle
+  // here, call machine specific function for all the expansion.  This
+  // avoids starting the shell for each argument separately.
+  // For `=expr` do use the internal function.
   for (int i = 0; i < num_pat; i++) {
     if (has_special_wildchar((char_u *)pat[i])
         && !(vim_backtick((char_u *)pat[i]) && pat[i][1] == '=')) {
@@ -1242,9 +1227,7 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
 
   recursive = true;
 
-  /*
-   * The matching file names are stored in a growarray.  Init it empty.
-   */
+  // The matching file names are stored in a growarray.  Init it empty.
   ga_init(&ga, (int)sizeof(char_u *), 30);
 
   for (int i = 0; i < num_pat && !got_int; i++) {
@@ -1266,31 +1249,28 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
         p = expand_env_save_opt(p, true);
         if (p == NULL) {
           p = (char_u *)pat[i];
-        }
+        } else {
 #ifdef UNIX
-        /*
-         * On Unix, if expand_env() can't expand an environment
-         * variable, use the shell to do that.  Discard previously
-         * found file names and start all over again.
-         */
-        else if (has_env_var(p) || *p == '~') {
-          xfree(p);
-          ga_clear_strings(&ga);
-          i = os_expand_wildcards(num_pat, pat, num_file, file,
-                                  flags | EW_KEEPDOLLAR);
-          recursive = false;
-          return i;
-        }
+          // On Unix, if expand_env() can't expand an environment
+          // variable, use the shell to do that.  Discard previously
+          // found file names and start all over again.
+          if (has_env_var(p) || *p == '~') {
+            xfree(p);
+            ga_clear_strings(&ga);
+            i = os_expand_wildcards(num_pat, pat, num_file, file,
+                                    flags | EW_KEEPDOLLAR);
+            recursive = false;
+            return i;
+          }
 #endif
+        }
       }
 
-      /*
-       * If there are wildcards: Expand file names and add each match to
-       * the list.  If there is no match, and EW_NOTFOUND is given, add
-       * the pattern.
-       * If there are no wildcards: Add the file name if it exists or
-       * when EW_NOTFOUND is given.
-       */
+      // If there are wildcards: Expand file names and add each match to
+      // the list.  If there is no match, and EW_NOTFOUND is given, add
+      // the pattern.
+      // If there are no wildcards: Add the file name if it exists or
+      // when EW_NOTFOUND is given.
       if (path_has_exp_wildcard(p)) {
         if ((flags & EW_PATH)
             && !path_is_absolute(p)
@@ -1491,21 +1471,17 @@ void addfile(garray_T *gap, char_u *f, int flags)
 #ifdef BACKSLASH_IN_FILENAME
   slash_adjust(p);
 #endif
-  /*
-   * Append a slash or backslash after directory names if none is present.
-   */
+  // Append a slash or backslash after directory names if none is present.
   if (isdir && (flags & EW_ADDSLASH)) {
     add_pathsep((char *)p);
   }
   GA_APPEND(char_u *, gap, p);
 }
 
-/*
- * Converts a file name into a canonical form. It simplifies a file name into
- * its simplest form by stripping out unneeded components, if any.  The
- * resulting file name is simplified in place and will either be the same
- * length as that supplied, or shorter.
- */
+// Converts a file name into a canonical form. It simplifies a file name into
+// its simplest form by stripping out unneeded components, if any.  The
+// resulting file name is simplified in place and will either be the same
+// length as that supplied, or shorter.
 void simplify_filename(char_u *filename)
 {
   int components = 0;
@@ -1704,10 +1680,8 @@ char *find_file_name_in_path(char *ptr, size_t len, int options, long count, cha
     file_name = (char *)find_file_in_path((char_u *)ptr, len, options & ~FNAME_MESS, true,
                                           (char_u *)rel_fname);
 
-    /*
-     * If the file could not be found in a normal way, try applying
-     * 'includeexpr' (unless done already).
-     */
+    // If the file could not be found in a normal way, try applying
+    // 'includeexpr' (unless done already).
     if (file_name == NULL
         && !(options & FNAME_INCL) && *curbuf->b_p_inex != NUL) {
       tofree = eval_includeexpr(ptr, len);
@@ -1976,11 +1950,9 @@ bool same_directory(char_u *f1, char_u *f2)
          && pathcmp((char *)ffname, (char *)f2, (int)(t1 - ffname)) == 0;
 }
 
-/*
- * Compare path "p[]" to "q[]".
- * If "maxlen" >= 0 compare "p[maxlen]" to "q[maxlen]"
- * Return value like strcmp(p, q), but consider path separators.
- */
+// Compare path "p[]" to "q[]".
+// If "maxlen" >= 0 compare "p[maxlen]" to "q[maxlen]"
+// Return value like strcmp(p, q), but consider path separators.
 int pathcmp(const char *p, const char *q, int maxlen)
 {
   int i, j;
@@ -2185,9 +2157,7 @@ int expand_wildcards(int num_pat, char **pat, int *num_files, char ***files, int
     return retval;
   }
 
-  /*
-   * Remove names that match 'wildignore'.
-   */
+  // Remove names that match 'wildignore'.
   if (*p_wig) {
     char_u *ffname;
 
diff --git a/src/nvim/path.h b/src/nvim/path.h
index 1006ef9ffb..37a0883c7f 100644
--- a/src/nvim/path.h
+++ b/src/nvim/path.h
@@ -18,8 +18,8 @@
 #define EW_NOERROR      0x200   // no error for bad regexp
 #define EW_NOTWILD      0x400   // add match with literal name if exists
 #define EW_KEEPDOLLAR   0x800   // do not escape $, $var is expanded
-/* Note: mostly EW_NOTFOUND and EW_SILENT are mutually exclusive: EW_NOTFOUND
-* is used when executing commands and EW_SILENT for interactive expanding. */
+// Note: mostly EW_NOTFOUND and EW_SILENT are mutually exclusive: EW_NOTFOUND
+// is used when executing commands and EW_SILENT for interactive expanding.
 #define EW_ALLLINKS     0x1000   // also links not pointing to existing file
 #define EW_SHELLCMD     0x2000   // called from expand_shellcmd(), don't check
                                  //  if executable is in $PATH
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 5c1fe3a657..490e79ebb0 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * search.c: code for normal mode searching commands
- */
+// search.c: code for normal mode searching commands
 
 #include <assert.h>
 #include <inttypes.h>
@@ -106,10 +104,8 @@ static bool saved_spats_no_hlsearch = false;
 static char_u *mr_pattern = NULL;    // pattern used by search_regcomp()
 static bool mr_pattern_alloced = false;    // mr_pattern was allocated
 
-/*
- * Type used by find_pattern_in_path() to remember which included files have
- * been searched already.
- */
+// Type used by find_pattern_in_path() to remember which included files have
+// been searched already.
 typedef struct SearchedFile {
   FILE *fp;              // File pointer
   char_u *name;            // Full name of file
@@ -139,9 +135,7 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
   rc_did_emsg = false;
   magic = p_magic;
 
-  /*
-   * If no pattern given, use a previously defined pattern.
-   */
+  // If no pattern given, use a previously defined pattern.
   if (pat == NULL || *pat == NUL) {
     if (pat_use == RE_LAST) {
       i = last_idx;
@@ -176,10 +170,8 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
     mr_pattern = pat;
   }
 
-  /*
-   * Save the currently used pattern in the appropriate place,
-   * unless the pattern should not be remembered.
-   */
+  // Save the currently used pattern in the appropriate place,
+  // unless the pattern should not be remembered.
   if (!(options & SEARCH_KEEP) && (cmdmod.cmod_flags & CMOD_KEEPPATTERNS) == 0) {
     // search or global command
     if (pat_save == RE_SEARCH || pat_save == RE_BOTH) {
@@ -200,9 +192,7 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
   return OK;
 }
 
-/*
- * Get search pattern used by search_regcomp().
- */
+// Get search pattern used by search_regcomp().
 char_u *get_search_pat(void)
 {
   return mr_pattern;
@@ -226,10 +216,8 @@ void save_re_pat(int idx, char_u *pat, int magic)
   }
 }
 
-/*
- * Save the search patterns, so they can be restored later.
- * Used before/after executing autocommands and user functions.
- */
+// Save the search patterns, so they can be restored later.
+// Used before/after executing autocommands and user functions.
 static int save_level = 0;
 
 void save_search_patterns(void)
@@ -450,19 +438,15 @@ char_u *last_search_pat(void)
   return spats[last_idx].pat;
 }
 
-/*
- * Reset search direction to forward.  For "gd" and "gD" commands.
- */
+// Reset search direction to forward.  For "gd" and "gD" commands.
 void reset_search_dir(void)
 {
   spats[0].off.dir = '/';
   set_vv_searchforward();
 }
 
-/*
- * Set the last search pattern.  For ":let @/ =" and ShaDa file.
- * Also set the saved search pattern, so that this works in an autocommand.
- */
+// Set the last search pattern.  For ":let @/ =" and ShaDa file.
+// Also set the saved search pattern, so that this works in an autocommand.
 void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
 {
   free_spat(&spats[idx]);
@@ -500,11 +484,9 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
   }
 }
 
-/*
- * Get a regexp program for the last used search pattern.
- * This is used for highlighting all matches in a window.
- * Values returned in regmatch->regprog and regmatch->rmm_ic.
- */
+// Get a regexp program for the last used search pattern.
+// This is used for highlighting all matches in a window.
+// Values returned in regmatch->regprog and regmatch->rmm_ic.
 void last_pat_prog(regmmatch_T *regmatch)
 {
   if (spats[last_idx].pat == NULL) {
@@ -578,9 +560,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
     return FAIL;
   }
 
-  /*
-   * find the string
-   */
+  // find the string
   do {  // loop for count
     // When not accepting a match at the start position set "extra_col" to a
     // non-zero value.  Don't do that when starting at MAXCOL, since MAXCOL + 1
@@ -615,13 +595,11 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
       at_first_line = false;        // not in first line now
     }
 
-    /*
-     * Start searching in current line, unless searching backwards and
-     * we're in column 0.
-     * If we are searching backwards, in column 0, and not including the
-     * current position, gain some efficiency by skipping back a line.
-     * Otherwise begin the search in the current line.
-     */
+    // Start searching in current line, unless searching backwards and
+    // we're in column 0.
+    // If we are searching backwards, in column 0, and not including the
+    // current position, gain some efficiency by skipping back a line.
+    // Otherwise begin the search in the current line.
     if (dir == BACKWARD && start_pos.col == 0
         && (options & SEARCH_START) == 0) {
       lnum = pos->lnum - 1;
@@ -667,11 +645,9 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
             ptr = ml_get_buf(buf, lnum + matchpos.lnum, false);
           }
 
-          /*
-           * Forward search in the first line: match should be after
-           * the start position. If not, continue at the end of the
-           * match (this is vi compatible) or on the next char.
-           */
+          // Forward search in the first line: match should be after
+          // the start position. If not, continue at the end of the
+          // match (this is vi compatible) or on the next char.
           if (dir == FORWARD && at_first_line) {
             match_ok = true;
             // When the match starts in a next line it's certainly
@@ -687,11 +663,9 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
                        : ((int)matchpos.col
                           - (ptr[matchpos.col] == NUL)
                           < (int)start_pos.col + extra_col))) {
-              /*
-               * If vi-compatible searching, continue at the end
-               * of the match, otherwise continue one position
-               * forward.
-               */
+              // If vi-compatible searching, continue at the end
+              // of the match, otherwise continue one position
+              // forward.
               if (vim_strchr(p_cpo, CPO_SEARCH) != NULL) {
                 if (nmatched > 1) {
                   // end is in next line, thus no match in
@@ -744,13 +718,11 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
             }
           }
           if (dir == BACKWARD) {
-            /*
-             * Now, if there are multiple matches on this line,
-             * we have to get the last one. Or the last one before
-             * the cursor, if we're on that line.
-             * When putting the new cursor at the end, compare
-             * relative to the end of the match.
-             */
+            // Now, if there are multiple matches on this line,
+            // we have to get the last one. Or the last one before
+            // the cursor, if we're on that line.
+            // When putting the new cursor at the end, compare
+            // relative to the end of the match.
             match_ok = false;
             for (;;) {
               // Remember a position that is before the start
@@ -825,10 +797,8 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
               ptr = ml_get_buf(buf, lnum + matchpos.lnum, false);
             }
 
-            /*
-             * If there is only a match after the cursor, skip
-             * this match.
-             */
+            // If there is only a match after the cursor, skip
+            // this match.
             if (!match_ok) {
               continue;
             }
@@ -1042,25 +1012,19 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
   size_t len;
   bool has_offset = false;
 
-  /*
-   * A line offset is not remembered, this is vi compatible.
-   */
+  // A line offset is not remembered, this is vi compatible.
   if (spats[0].off.line && vim_strchr(p_cpo, CPO_LINEOFF) != NULL) {
     spats[0].off.line = false;
     spats[0].off.off = 0;
   }
 
-  /*
-   * Save the values for when (options & SEARCH_KEEP) is used.
-   * (there is no "if ()" around this because gcc wants them initialized)
-   */
+  // Save the values for when (options & SEARCH_KEEP) is used.
+  // (there is no "if ()" around this because gcc wants them initialized)
   old_off = spats[0].off;
 
   pos = curwin->w_cursor;       // start searching at the cursor position
 
-  /*
-   * Find out the direction of the search.
-   */
+  // Find out the direction of the search.
   if (dirc == 0) {
     dirc = (char_u)spats[0].off.dir;
   } else {
@@ -1087,17 +1051,13 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
     }
   }
 
-  /*
-   * Turn 'hlsearch' highlighting back on.
-   */
+  // Turn 'hlsearch' highlighting back on.
   if (no_hlsearch && !(options & SEARCH_KEEP)) {
     redraw_all_later(UPD_SOME_VALID);
     set_no_hlsearch(false);
   }
 
-  /*
-   * Repeat the search when pattern followed by ';', e.g. "/foo/;?bar".
-   */
+  // Repeat the search when pattern followed by ';', e.g. "/foo/;?bar".
   for (;;) {
     bool show_top_bot_msg = false;
 
@@ -1119,10 +1079,8 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
     }
 
     if (pat != NULL && *pat != NUL) {   // look for (new) offset
-      /*
-       * Find end of regular expression.
-       * If there is a matching '/' or '?', toss it.
-       */
+      // Find end of regular expression.
+      // If there is a matching '/' or '?', toss it.
       ps = (char_u *)strcopy;
       p = (char_u *)skip_regexp((char *)pat, search_delim, p_magic, &strcopy);
       if (strcopy != (char *)ps) {
@@ -1287,13 +1245,11 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
       }
     }
 
-    /*
-     * If there is a character offset, subtract it from the current
-     * position, so we don't get stuck at "?pat?e+2" or "/pat/s-2".
-     * Skip this if pos.col is near MAXCOL (closed fold).
-     * This is not done for a line offset, because then we would not be vi
-     * compatible.
-     */
+    // If there is a character offset, subtract it from the current
+    // position, so we don't get stuck at "?pat?e+2" or "/pat/s-2".
+    // Skip this if pos.col is near MAXCOL (closed fold).
+    // This is not done for a line offset, because then we would not be vi
+    // compatible.
     if (!spats[0].off.line && spats[0].off.off && pos.col < MAXCOL - 2) {
       if (spats[0].off.off > 0) {
         for (c = spats[0].off.off; c; c--) {
@@ -1350,9 +1306,7 @@ int do_search(oparg_T *oap, int dirc, int search_delim, char_u *pat, long count,
       apply_autocmds(EVENT_SEARCHWRAPPED, NULL, NULL, false, NULL);
     }
 
-    /*
-     * Add character and/or line offset
-     */
+    // Add character and/or line offset
     if (!(options & SEARCH_NOOF) || (pat != NULL && *pat == ';')) {
       pos_T org_pos = pos;
 
@@ -1444,15 +1398,13 @@ end_do_search:
   return retval;
 }
 
-/*
- * search_for_exact_line(buf, pos, dir, pat)
- *
- * Search for a line starting with the given pattern (ignoring leading
- * white-space), starting from pos and going in direction "dir". "pos" will
- * contain the position of the match found.    Blank lines match only if
- * ADDING is set.  If p_ic is set then the pattern must be in lowercase.
- * Return OK for success, or FAIL if no line found.
- */
+// search_for_exact_line(buf, pos, dir, pat)
+//
+// Search for a line starting with the given pattern (ignoring leading
+// white-space), starting from pos and going in direction "dir". "pos" will
+// contain the position of the match found.    Blank lines match only if
+// ADDING is set.  If p_ic is set then the pattern must be in lowercase.
+// Return OK for success, or FAIL if no line found.
 int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
 {
   linenr_T start = 0;
@@ -1513,9 +1465,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
   return FAIL;
 }
 
-/*
- * Character Searches
- */
+// Character Searches
 
 /// Search for a character in a line.  If "t_cmd" is false, move to the
 /// position of the character, otherwise move to just before the char.
@@ -1618,15 +1568,11 @@ int searchc(cmdarg_T *cap, int t_cmd)
   return OK;
 }
 
-/*
- * "Other" Searches
- */
+// "Other" Searches
 
-/*
- * findmatch - find the matching paren or brace
- *
- * Improvement over vi: Braces inside quotes are ignored.
- */
+// findmatch - find the matching paren or brace
+//
+// Improvement over vi: Braces inside quotes are ignored.
 pos_T *findmatch(oparg_T *oap, int initc)
 {
   return findmatchlimit(oap, initc, 0, 0);
@@ -1725,27 +1671,24 @@ static void find_mps_values(int *initc, int *findc, bool *backwards, bool switch
   }
 }
 
-/*
- * findmatchlimit -- find the matching paren or brace, if it exists within
- * maxtravel lines of the cursor.  A maxtravel of 0 means search until falling
- * off the edge of the file.
- *
- * "initc" is the character to find a match for.  NUL means to find the
- * character at or after the cursor. Special values:
- * '*'  look for C-style comment / *
- * '/'  look for C-style comment / *, ignoring comment-end
- * '#'  look for preprocessor directives
- * 'R'  look for raw string start: R"delim(text)delim" (only backwards)
- *
- * flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#')
- *    FM_FORWARD  search forwards (when initc is '/', '*' or '#')
- *    FM_BLOCKSTOP  stop at start/end of block ({ or } in column 0)
- *    FM_SKIPCOMM skip comments (not implemented yet!)
- *
- * "oap" is only used to set oap->motion_type for a linewise motion, it can be
- * NULL
- */
-
+// findmatchlimit -- find the matching paren or brace, if it exists within
+// maxtravel lines of the cursor.  A maxtravel of 0 means search until falling
+// off the edge of the file.
+//
+// "initc" is the character to find a match for.  NUL means to find the
+// character at or after the cursor. Special values:
+// '*'  look for C-style comment / *
+// '/'  look for C-style comment / *, ignoring comment-end
+// '#'  look for preprocessor directives
+// 'R'  look for raw string start: R"delim(text)delim" (only backwards)
+//
+// flags: FM_BACKWARD search backwards (when initc is '/', '*' or '#')
+//    FM_FORWARD  search forwards (when initc is '/', '*' or '#')
+//    FM_BLOCKSTOP  stop at start/end of block ({ or } in column 0)
+//    FM_SKIPCOMM skip comments (not implemented yet!)
+//
+// "oap" is only used to set oap->motion_type for a linewise motion, it can be
+// NULL
 pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
 {
   static pos_T pos;                     // current search position
@@ -1783,12 +1726,10 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
     dir = 0;
   }
 
-  /*
-   * if initc given, look in the table for the matching character
-   * '/' and '*' are special cases: look for start or end of comment.
-   * When '/' is used, we ignore running backwards into a star-slash, for
-   * "[*" command, we just want to find any comment.
-   */
+  // if initc given, look in the table for the matching character
+  // '/' and '*' are special cases: look for start or end of comment.
+  // When '/' is used, we ignore running backwards into a star-slash, for
+  // "[*" command, we just want to find any comment.
   if (initc == '/' || initc == '*' || initc == 'R') {
     comment_dir = dir;
     if (initc == '/') {
@@ -1806,18 +1747,14 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       return NULL;
     }
   } else {
-    /*
-     * Either initc is '#', or no initc was given and we need to look
-     * under the cursor.
-     */
+    // Either initc is '#', or no initc was given and we need to look
+    // under the cursor.
     if (initc == '#') {
       hash_dir = dir;
     } else {
-      /*
-       * initc was not given, must look for something to match under
-       * or near the cursor.
-       * Only check for special things when 'cpo' doesn't have '%'.
-       */
+      // initc was not given, must look for something to match under
+      // or near the cursor.
+      // Only check for special things when 'cpo' doesn't have '%'.
       if (!cpo_match) {
         // Are we before or at #if, #else etc.?
         ptr = (char_u *)skipwhite((char *)linep);
@@ -1851,16 +1788,12 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
         }
       }
 
-      /*
-       * If we are not on a comment or the # at the start of a line, then
-       * look for brace anywhere on this line after the cursor.
-       */
+      // If we are not on a comment or the # at the start of a line, then
+      // look for brace anywhere on this line after the cursor.
       if (!hash_dir && !comment_dir) {
-        /*
-         * Find the brace under or after the cursor.
-         * If beyond the end of the line, use the last character in
-         * the line.
-         */
+        // Find the brace under or after the cursor.
+        // If beyond the end of the line, use the last character in
+        // the line.
         if (linep[pos.col] == NUL && pos.col) {
           pos.col--;
         }
@@ -1896,9 +1829,7 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       }
     }
     if (hash_dir) {
-      /*
-       * Look for matching #if, #else, #elif, or #endif
-       */
+      // Look for matching #if, #else, #elif, or #endif
       if (oap != NULL) {
         oap->motion_type = kMTLineWise;  // Linewise for this case only
       }
@@ -1983,10 +1914,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
   }
 
   while (!got_int) {
-    /*
-     * Go to the next position, forward or backward. We could use
-     * inc() and dec() here, but that is much slower
-     */
+    // Go to the next position, forward or backward. We could use
+    // inc() and dec() here, but that is much slower
     if (backwards) {
       // char to match is inside of comment, don't search outside
       if (lispcomm && pos.col < (colnr_T)comment_col) {
@@ -2067,10 +1996,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
           return &pos;
         }
       } else {    // Searching backwards
-        /*
-         * A comment may contain / * or / /, it may also start or end
-         * with / * /. Ignore a / * after / / and after *.
-         */
+        // A comment may contain / * or / /, it may also start or end
+        // with / * /. Ignore a / * after / / and after *.
         if (pos.col == 0) {
           continue;
         } else if (raw_string) {
@@ -2113,18 +2040,14 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       continue;
     }
 
-    /*
-     * If smart matching ('cpoptions' does not contain '%'), braces inside
-     * of quotes are ignored, but only if there is an even number of
-     * quotes in the line.
-     */
+    // If smart matching ('cpoptions' does not contain '%'), braces inside
+    // of quotes are ignored, but only if there is an even number of
+    // quotes in the line.
     if (cpo_match) {
       do_quotes = 0;
     } else if (do_quotes == -1) {
-      /*
-       * Count the number of quotes in the line, skipping \" and '"'.
-       * Watch out for "\\".
-       */
+      // Count the number of quotes in the line, skipping \" and '"'.
+      // Watch out for "\\".
       at_start = do_quotes;
       for (ptr = linep; *ptr; ptr++) {
         if (ptr == linep + pos.col + backwards) {
@@ -2140,10 +2063,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       }
       do_quotes &= 1;               // result is 1 with even number of quotes
 
-      /*
-       * If we find an uneven count, check current line and previous
-       * one for a '\' at the end.
-       */
+      // If we find an uneven count, check current line and previous
+      // one for a '\' at the end.
       if (!do_quotes) {
         inquote = false;
         if (ptr[-1] == '\\') {
@@ -2179,17 +2100,15 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       start_in_quotes = kFalse;
     }
 
-    /*
-     * If 'smartmatch' is set:
-     *   Things inside quotes are ignored by setting 'inquote'.  If we
-     *   find a quote without a preceding '\' invert 'inquote'.  At the
-     *   end of a line not ending in '\' we reset 'inquote'.
-     *
-     *   In lines with an uneven number of quotes (without preceding '\')
-     *   we do not know which part to ignore. Therefore we only set
-     *   inquote if the number of quotes in a line is even, unless this
-     *   line or the previous one ends in a '\'.  Complicated, isn't it?
-     */
+    // If 'smartmatch' is set:
+    //   Things inside quotes are ignored by setting 'inquote'.  If we
+    //   find a quote without a preceding '\' invert 'inquote'.  At the
+    //   end of a line not ending in '\' we reset 'inquote'.
+    //
+    //   In lines with an uneven number of quotes (without preceding '\')
+    //   we do not know which part to ignore. Therefore we only set
+    //   inquote if the number of quotes in a line is even, unless this
+    //   line or the previous one ends in a '\'.  Complicated, isn't it?
     const int c = utf_ptr2char((char *)linep + pos.col);
     switch (c) {
     case NUL:
@@ -2218,13 +2137,11 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       }
       break;
 
-    /*
-     * If smart matching ('cpoptions' does not contain '%'):
-     *   Skip things in single quotes: 'x' or '\x'.  Be careful for single
-     *   single quotes, eg jon's.  Things like '\233' or '\x3f' are not
-     *   skipped, there is never a brace in them.
-     *   Ignore this when finding matches for `'.
-     */
+    // If smart matching ('cpoptions' does not contain '%'):
+    //   Skip things in single quotes: 'x' or '\x'.  Be careful for single
+    //   single quotes, eg jon's.  Things like '\233' or '\x3f' are not
+    //   skipped, there is never a brace in them.
+    //   Ignore this when finding matches for `'.
     case '\'':
       if (!cpo_match && initc != '\'' && findc != '\'') {
         if (backwards) {
@@ -2252,10 +2169,8 @@ pos_T *findmatchlimit(oparg_T *oap, int initc, int flags, int64_t maxtravel)
       FALLTHROUGH;
 
     default:
-      /*
-       * For Lisp skip over backslashed (), {} and [].
-       * (actually, we skip #\( et al)
-       */
+      // For Lisp skip over backslashed (), {} and [].
+      // (actually, we skip #\( et al)
       if (curbuf->b_p_lisp
           && vim_strchr("(){}[]", c) != NULL
           && pos.col > 1
@@ -2367,9 +2282,7 @@ void showmatch(int c)
   colnr_T save_dollar_vcol;
   char_u *p;
 
-  /*
-   * Only show match for chars in the 'matchpairs' option.
-   */
+  // Only show match for chars in the 'matchpairs' option.
   // 'matchpairs' is "x:y,x:y"
   for (p = (char_u *)curbuf->b_p_mps; *p != NUL; p++) {
     if (utf_ptr2char((char *)p) == c && (curwin->w_p_rl ^ p_ri)) {
@@ -2425,10 +2338,8 @@ void showmatch(int c)
       // and has a higher column number.
       dollar_vcol = save_dollar_vcol;
 
-      /*
-       * brief pause, unless 'm' is present in 'cpo' and a character is
-       * available.
-       */
+      // brief pause, unless 'm' is present in 'cpo' and a character is
+      // available.
       if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL) {
         os_delay((uint64_t)p_mat * 100L + 8, true);
       } else if (!char_avail()) {
@@ -3667,10 +3578,8 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
             // 'includeexpr' is set.
             msg_outtrans_attr((char *)new_fname, HL_ATTR(HLF_D));
           } else {
-            /*
-             * Isolate the file name.
-             * Include the surrounding "" or <> if present.
-             */
+            // Isolate the file name.
+            // Include the surrounding "" or <> if present.
             if (inc_opt != NULL
                 && strstr(inc_opt, "\\zs") != NULL) {
               // pattern contains \zs, use the match
@@ -3763,9 +3672,7 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
         }
       }
     } else {
-      /*
-       * Check if the line is a define (type == FIND_DEFINE)
-       */
+      // Check if the line is a define (type == FIND_DEFINE)
       p = line;
 search_line:
       define_matched = false;
@@ -3781,10 +3688,8 @@ search_line:
         define_matched = true;
       }
 
-      /*
-       * Look for a match.  Don't do this if we are looking for a
-       * define and this line didn't match define_prog above.
-       */
+      // Look for a match.  Don't do this if we are looking for a
+      // define and this line didn't match define_prog above.
       if (def_regmatch.regprog == NULL || define_matched) {
         if (define_matched || compl_status_sol()) {
           // compare the first "len" chars from "ptr"
@@ -3812,12 +3717,10 @@ search_line:
               matched = false;
             }
 
-            /*
-             * Also check for a "/ *" or "/ /" before the match.
-             * Skips lines like "int backwards;  / * normal index
-             * * /" when looking for "normal".
-             * Note: Doesn't skip "/ *" in comments.
-             */
+            // Also check for a "/ *" or "/ /" before the match.
+            // Skips lines like "int backwards;  / * normal index
+            // * /" when looking for "normal".
+            // Note: Doesn't skip "/ *" in comments.
             p = (char_u *)skipwhite((char *)line);
             if (matched
                 || (p[0] == '/' && p[1] == '*') || p[0] == '*') {
@@ -4033,11 +3936,9 @@ exit_matched:
       break;
     }
 
-    /*
-     * Read the next line.  When reading an included file and encountering
-     * end-of-file, close the file and continue in the file that included
-     * it.
-     */
+    // Read the next line.  When reading an included file and encountering
+    // end-of-file, close the file and continue in the file that included
+    // it.
     while (depth >= 0 && !already
            && vim_fgets(line = file_line, LSIZE, files[depth].fp)) {
       fclose(files[depth].fp);
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 423436eccc..12bfa35dd6 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -65,28 +65,22 @@ char *xstrnsave(const char *string, size_t len)
   return strncpy(xmallocz(len), string, len);  // NOLINT(runtime/printf)
 }
 
-/*
- * Same as vim_strsave(), but any characters found in esc_chars are preceded
- * by a backslash.
- */
+// Same as vim_strsave(), but any characters found in esc_chars are preceded
+// by a backslash.
 char_u *vim_strsave_escaped(const char_u *string, const char_u *esc_chars)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
   return vim_strsave_escaped_ext(string, esc_chars, '\\', false);
 }
 
-/*
- * Same as vim_strsave_escaped(), but when "bsl" is true also escape
- * characters where rem_backslash() would remove the backslash.
- * Escape the characters with "cc".
- */
+// Same as vim_strsave_escaped(), but when "bsl" is true also escape
+// characters where rem_backslash() would remove the backslash.
+// Escape the characters with "cc".
 char_u *vim_strsave_escaped_ext(const char_u *string, const char_u *esc_chars, char_u cc, bool bsl)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
-  /*
-   * First count the number of backslashes required.
-   * Then allocate the memory and insert them.
-   */
+  // First count the number of backslashes required.
+  // Then allocate the memory and insert them.
   size_t length = 1;                    // count the trailing NUL
   for (const char_u *p = string; *p; p++) {
     const size_t l = (size_t)(utfc_ptr2len((char *)p));
@@ -169,16 +163,14 @@ char *vim_strnsave_unquoted(const char *const string, const size_t length)
   return ret;
 }
 
-/*
- * Escape "string" for use as a shell argument with system().
- * This uses single quotes, except when we know we need to use double quotes
- * (MS-Windows without 'shellslash' set).
- * Escape a newline, depending on the 'shell' option.
- * When "do_special" is true also replace "!", "%", "#" and things starting
- * with "<" like "<cfile>".
- * When "do_newline" is false do not escape newline unless it is csh shell.
- * Returns the result in allocated memory.
- */
+// Escape "string" for use as a shell argument with system().
+// This uses single quotes, except when we know we need to use double quotes
+// (MS-Windows without 'shellslash' set).
+// Escape a newline, depending on the 'shell' option.
+// When "do_special" is true also replace "!", "%", "#" and things starting
+// with "<" like "<cfile>".
+// When "do_newline" is false do not escape newline unless it is csh shell.
+// Returns the result in allocated memory.
 char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_newline)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
@@ -295,10 +287,8 @@ char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_n
   return escaped_string;
 }
 
-/*
- * Like vim_strsave(), but make all characters uppercase.
- * This uses ASCII lower-to-upper case translation, language independent.
- */
+// Like vim_strsave(), but make all characters uppercase.
+// This uses ASCII lower-to-upper case translation, language independent.
 char_u *vim_strsave_up(const char_u *string)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
@@ -319,9 +309,7 @@ char *vim_strnsave_up(const char *string, size_t len)
   return p1;
 }
 
-/*
- * ASCII lower-to-upper case translation, language independent.
- */
+// ASCII lower-to-upper case translation, language independent.
 void vim_strup(char_u *p)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -375,9 +363,7 @@ char *strcase_save(const char *const orig, bool upper)
   return res;
 }
 
-/*
- * delete spaces at the end of a string
- */
+// delete spaces at the end of a string
 void del_trailing_spaces(char_u *ptr)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -402,11 +388,9 @@ size_t xstrnlen(const char *s, size_t n)
 #endif
 
 #if (!defined(HAVE_STRCASECMP) && !defined(HAVE_STRICMP))
-/*
- * Compare two strings, ignoring case, using current locale.
- * Doesn't work for multi-byte characters.
- * return 0 for match, < 0 for smaller, > 0 for bigger
- */
+// Compare two strings, ignoring case, using current locale.
+// Doesn't work for multi-byte characters.
+// return 0 for match, < 0 for smaller, > 0 for bigger
 int vim_stricmp(const char *s1, const char *s2)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
 {
@@ -428,11 +412,9 @@ int vim_stricmp(const char *s1, const char *s2)
 #endif
 
 #if (!defined(HAVE_STRNCASECMP) && !defined(HAVE_STRNICMP))
-/*
- * Compare two strings, for length "len", ignoring case, using current locale.
- * Doesn't work for multi-byte characters.
- * return 0 for match, < 0 for smaller, > 0 for bigger
- */
+// Compare two strings, for length "len", ignoring case, using current locale.
+// Doesn't work for multi-byte characters.
+// return 0 for match, < 0 for smaller, > 0 for bigger
 int vim_strnicmp(const char *s1, const char *s2, size_t len)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE
 {
@@ -477,9 +459,7 @@ char *vim_strchr(const char *const string, const int c)
   }
 }
 
-/*
- * Sort an array of strings.
- */
+// Sort an array of strings.
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "strings.c.generated.h"
@@ -495,10 +475,8 @@ void sort_strings(char **files, int count)
   qsort((void *)files, (size_t)count, sizeof(char *), sort_compare);
 }
 
-/*
- * Return true if string "s" contains a non-ASCII character (128 or higher).
- * When "s" is NULL false is returned.
- */
+// Return true if string "s" contains a non-ASCII character (128 or higher).
+// When "s" is NULL false is returned.
 bool has_non_ascii(const char_u *s)
   FUNC_ATTR_PURE
 {
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 9eb412b803..fedd053e88 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * syntax.c: code for syntax highlighting
- */
+// syntax.c: code for syntax highlighting
 
 #include <assert.h>
 #include <ctype.h>
@@ -104,11 +102,9 @@ typedef struct syn_cluster_S {
   int16_t *scl_list;        // IDs in this syntax cluster
 } syn_cluster_T;
 
-/*
- * For the current state we need to remember more than just the idx.
- * When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
- * (The end positions have the column number of the next char)
- */
+// For the current state we need to remember more than just the idx.
+// When si_m_endpos.lnum is 0, the items other than si_idx are unknown.
+// (The end positions have the column number of the next char)
 typedef struct state_item {
   int si_idx;                           // index of syntax pattern or
                                         // KEYWORD_IDX
@@ -133,10 +129,8 @@ typedef struct state_item {
                                         // pattern
 } stateitem_T;
 
-/*
- * Struct to reduce the number of arguments to get_syn_options(), it's used
- * very often.
- */
+// Struct to reduce the number of arguments to get_syn_options(), it's used
+// very often.
 typedef struct {
   int flags;                   // flags for contained and transparent
   bool keyword;                // true for ":syn keyword"
@@ -184,9 +178,7 @@ static char *(spo_name_tab[SPO_COUNT]) =
 
 #define NONE_IDX        (-2)    // value of sp_sync_idx for "NONE"
 
-/*
- * Flags for b_syn_sync_flags:
- */
+// Flags for b_syn_sync_flags:
 #define SF_CCOMMENT     0x01    // sync on a C-style comment
 #define SF_MATCH        0x02    // sync by matching a pattern
 
@@ -194,9 +186,7 @@ static char *(spo_name_tab[SPO_COUNT]) =
 
 #define MAXKEYWLEN      80          // maximum length of a keyword
 
-/*
- * The attributes of the syntax item that has been recognized.
- */
+// The attributes of the syntax item that has been recognized.
 static int current_attr = 0;        // attr of current syntax word
 static int current_id = 0;          // ID of current char for syn_get_id()
 static int current_trans_id = 0;    // idem, transparency removed
@@ -204,23 +194,19 @@ static int current_flags = 0;
 static int current_seqnr = 0;
 static int current_sub_char = 0;
 
-/*
- * Methods of combining two clusters
- */
+// Methods of combining two clusters
 #define CLUSTER_REPLACE     1   // replace first list with second
 #define CLUSTER_ADD         2   // add second list to first
 #define CLUSTER_SUBTRACT    3   // subtract second list from first
 
 #define SYN_CLSTR(buf)  ((syn_cluster_T *)((buf)->b_syn_clusters.ga_data))
 
-/*
- * Syntax group IDs have different types:
- *     0 - 19999  normal syntax groups
- * 20000 - 20999  ALLBUT indicator (current_syn_inc_tag added)
- * 21000 - 21999  TOP indicator (current_syn_inc_tag added)
- * 22000 - 22999  CONTAINED indicator (current_syn_inc_tag added)
- * 23000 - 32767  cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
- */
+// Syntax group IDs have different types:
+//     0 - 19999  normal syntax groups
+// 20000 - 20999  ALLBUT indicator (current_syn_inc_tag added)
+// 21000 - 21999  TOP indicator (current_syn_inc_tag added)
+// 22000 - 22999  CONTAINED indicator (current_syn_inc_tag added)
+// 23000 - 32767  cluster IDs (subtract SYNID_CLUSTER for the cluster ID)
 #define SYNID_ALLBUT    MAX_HL_ID   // syntax group ID for contains=ALLBUT
 #define SYNID_TOP       21000       // syntax group ID for contains=TOP
 #define SYNID_CONTAINED 22000       // syntax group ID for contains=CONTAINED
@@ -234,21 +220,17 @@ static int current_sub_char = 0;
 // instead of passing it to them, we stow it here.
 static char **syn_cmdlinep;
 
-/*
- * Another Annoying Hack(TM):  To prevent rules from other ":syn include"'d
- * files from leaking into ALLBUT lists, we assign a unique ID to the
- * rules in each ":syn include"'d file.
- */
+// Another Annoying Hack(TM):  To prevent rules from other ":syn include"'d
+// files from leaking into ALLBUT lists, we assign a unique ID to the
+// rules in each ":syn include"'d file.
 static int current_syn_inc_tag = 0;
 static int running_syn_inc_tag = 0;
 
-/*
- * In a hashtable item "hi_key" points to "keyword" in a keyentry.
- * This avoids adding a pointer to the hashtable item.
- * KE2HIKEY() converts a var pointer to a hashitem key pointer.
- * HIKEY2KE() converts a hashitem key pointer to a var pointer.
- * HI2KE() converts a hashitem pointer to a var pointer.
- */
+// In a hashtable item "hi_key" points to "keyword" in a keyentry.
+// This avoids adding a pointer to the hashtable item.
+// KE2HIKEY() converts a var pointer to a hashitem key pointer.
+// HIKEY2KE() converts a hashitem key pointer to a var pointer.
+// HI2KE() converts a hashitem pointer to a var pointer.
 static keyentry_T dumkey;
 #define KE2HIKEY(kp)  ((kp)->keyword)
 #define HIKEY2KE(p)   ((keyentry_T *)((p) - (dumkey.keyword - (char_u *)&dumkey)))
@@ -256,11 +238,9 @@ static keyentry_T dumkey;
 
 // -V:HI2KE:782
 
-/*
- * To reduce the time spent in keepend(), remember at which level in the state
- * stack the first item with "keepend" is present.  When "-1", there is no
- * "keepend" on the stack.
- */
+// To reduce the time spent in keepend(), remember at which level in the state
+// stack the first item with "keepend" is present.  When "-1", there is no
+// "keepend" on the stack.
 static int keepend_level = -1;
 
 static char msg_no_items[] = N_("No Syntax items defined for this buffer");
@@ -272,13 +252,11 @@ static char msg_no_items[] = N_("No Syntax items defined for this buffer");
 
 static int next_seqnr = 1;              // value to use for si_seqnr
 
-/*
- * The next possible match in the current line for any pattern is remembered,
- * to avoid having to try for a match in each column.
- * If next_match_idx == -1, not tried (in this line) yet.
- * If next_match_col == MAXCOL, no match found in this line.
- * (All end positions have the column of the char after the end)
- */
+// The next possible match in the current line for any pattern is remembered,
+// to avoid having to try for a match in each column.
+// If next_match_idx == -1, not tried (in this line) yet.
+// If next_match_col == MAXCOL, no match found in this line.
+// (All end positions have the column of the char after the end)
 static int next_match_col;              // column for start of next match
 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
@@ -290,17 +268,13 @@ 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 reg_extmatch_T *next_match_extmatch = NULL;
 
-/*
- * A state stack is an array of integers or stateitem_T, stored in a
- * garray_T.  A state stack is invalid if its itemsize entry is zero.
- */
+// A state stack is an array of integers or stateitem_T, stored in a
+// garray_T.  A state stack is invalid if its itemsize entry is zero.
 #define INVALID_STATE(ssp)  ((ssp)->ga_itemsize == 0)
 #define VALID_STATE(ssp)    ((ssp)->ga_itemsize != 0)
 
-/*
- * The current state (within the line) of the recognition engine.
- * When current_state.ga_itemsize is 0 the current state is invalid.
- */
+// The current state (within the line) of the recognition engine.
+// When current_state.ga_itemsize is 0 the current state is invalid.
 static win_T *syn_win;                  // current window for highlighting
 static buf_T *syn_buf;                  // current buffer for highlighting
 static synblock_T *syn_block;              // current buffer for highlighting
@@ -328,13 +302,11 @@ void syn_set_timeout(proftime_T *tm)
   syn_tm = tm;
 }
 
-/*
- * Start the syntax recognition for a line.  This function is normally called
- * from the screen updating, once for each displayed line.
- * The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
- * it.  Careful: curbuf and curwin are likely to point to another buffer and
- * window.
- */
+// Start the syntax recognition for a line.  This function is normally called
+// from the screen updating, once for each displayed line.
+// The buffer is remembered in syn_buf, because get_syntax_attr() doesn't get
+// it.  Careful: curbuf and curwin are likely to point to another buffer and
+// window.
 void syntax_start(win_T *wp, linenr_T lnum)
 {
   synstate_T *p;
@@ -348,11 +320,9 @@ void syntax_start(win_T *wp, linenr_T lnum)
 
   current_sub_char = NUL;
 
-  /*
-   * After switching buffers, invalidate current_state.
-   * Also do this when a change was made, the current state may be invalid
-   * then.
-   */
+  // After switching buffers, invalidate current_state.
+  // Also do this when a change was made, the current state may be invalid
+  // then.
   if (syn_block != wp->w_s
       || syn_buf != wp->w_buffer
       || changedtick != buf_get_changedtick(syn_buf)) {
@@ -363,18 +333,14 @@ void syntax_start(win_T *wp, linenr_T lnum)
   changedtick = buf_get_changedtick(syn_buf);
   syn_win = wp;
 
-  /*
-   * Allocate syntax stack when needed.
-   */
+  // Allocate syntax stack when needed.
   syn_stack_alloc();
   if (syn_block->b_sst_array == NULL) {
     return;             // out of memory
   }
   syn_block->b_sst_lasttick = display_tick;
 
-  /*
-   * If the state of the end of the previous line is useful, store it.
-   */
+  // If the state of the end of the previous line is useful, store it.
   if (VALID_STATE(&current_state)
       && current_lnum < lnum
       && current_lnum < syn_buf->b_ml.ml_line_count) {
@@ -384,11 +350,9 @@ void syntax_start(win_T *wp, linenr_T lnum)
       (void)store_current_state();
     }
 
-    /*
-     * If the current_lnum is now the same as "lnum", keep the current
-     * state (this happens very often!).  Otherwise invalidate
-     * current_state and figure it out below.
-     */
+    // If the current_lnum is now the same as "lnum", keep the current
+    // state (this happens very often!).  Otherwise invalidate
+    // current_state and figure it out below.
     if (current_lnum != lnum) {
       invalidate_current_state();
     }
@@ -396,10 +360,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     invalidate_current_state();
   }
 
-  /*
-   * Try to synchronize from a saved state in b_sst_array[].
-   * Only do this if lnum is not before and not to far beyond a saved state.
-   */
+  // Try to synchronize from a saved state in b_sst_array[].
+  // Only do this if lnum is not before and not to far beyond a saved state.
   if (INVALID_STATE(&current_state) && syn_block->b_sst_array != NULL) {
     // Find last valid saved state before start_lnum.
     for (p = syn_block->b_sst_first; p != NULL; p = p->sst_next) {
@@ -418,10 +380,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     }
   }
 
-  /*
-   * If "lnum" is before or far beyond a line with a saved state, need to
-   * re-synchronize.
-   */
+  // If "lnum" is before or far beyond a line with a saved state, need to
+  // re-synchronize.
   if (INVALID_STATE(&current_state)) {
     syn_sync(wp, lnum, last_valid);
     if (current_lnum == 1) {
@@ -436,10 +396,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
     first_stored = current_lnum;
   }
 
-  /*
-   * Advance from the sync point or saved state until the current line.
-   * Save some entries for syncing with later on.
-   */
+  // Advance from the sync point or saved state until the current line.
+  // Save some entries for syncing with later on.
   if (syn_block->b_sst_len <= Rows) {
     dist = 999999;
   } else {
@@ -506,10 +464,8 @@ void syntax_start(win_T *wp, linenr_T lnum)
   syn_start_line();
 }
 
-/*
- * We cannot simply discard growarrays full of state_items or buf_states; we
- * have to manually release their extmatch pointers first.
- */
+// We cannot simply discard growarrays full of state_items or buf_states; we
+// have to manually release their extmatch pointers first.
 static void clear_syn_state(synstate_T *p)
 {
   if (p->sst_stacksize > SST_FIX_STATES) {
@@ -522,24 +478,20 @@ static void clear_syn_state(synstate_T *p)
   }
 }
 
-/*
- * Cleanup the current_state stack.
- */
+// Cleanup the current_state stack.
 static void clear_current_state(void)
 {
 #define UNREF_STATEITEM_EXTMATCH(si) unref_extmatch((si)->si_extmatch)
   GA_DEEP_CLEAR(&current_state, stateitem_T, UNREF_STATEITEM_EXTMATCH);
 }
 
-/*
- * Try to find a synchronisation point for line "lnum".
- *
- * This sets current_lnum and the current state.  One of three methods is
- * used:
- * 1. Search backwards for the end of a C-comment.
- * 2. Search backwards for given sync patterns.
- * 3. Simply start on a given number of lines above "lnum".
- */
+// Try to find a synchronisation point for line "lnum".
+//
+// This sets current_lnum and the current state.  One of three methods is
+// used:
+// 1. Search backwards for the end of a C-comment.
+// 2. Search backwards for given sync patterns.
+// 3. Simply start on a given number of lines above "lnum".
 static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
 {
   buf_T *curbuf_save;
@@ -560,19 +512,15 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   lpos_T found_m_endpos;
   colnr_T prev_current_col;
 
-  /*
-   * Clear any current state that might be hanging around.
-   */
+  // Clear any current state that might be hanging around.
   invalidate_current_state();
 
-  /*
-   * Start at least "minlines" back.  Default starting point for parsing is
-   * there.
-   * Start further back, to avoid that scrolling backwards will result in
-   * resyncing for every line.  Now it resyncs only one out of N lines,
-   * where N is minlines * 1.5, or minlines * 2 if minlines is small.
-   * Watch out for overflow when minlines is MAXLNUM.
-   */
+  // Start at least "minlines" back.  Default starting point for parsing is
+  // there.
+  // Start further back, to avoid that scrolling backwards will result in
+  // resyncing for every line.  Now it resyncs only one out of N lines,
+  // where N is minlines * 1.5, or minlines * 2 if minlines is small.
+  // Watch out for overflow when minlines is MAXLNUM.
   if (syn_block->b_syn_sync_minlines > start_lnum) {
     start_lnum = 1;
   } else {
@@ -595,9 +543,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
   }
   current_lnum = start_lnum;
 
-  /*
-   * 1. Search backwards for the end of a C-style comment.
-   */
+  // 1. Search backwards for the end of a C-style comment.
   if (syn_block->b_syn_sync_flags & SF_CCOMMENT) {
     // Need to make syn_buf the current buffer for a moment, to be able to
     // use find_start_comment().
@@ -606,9 +552,7 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     curbuf_save = curbuf;
     curbuf = syn_buf;
 
-    /*
-     * Skip lines that end in a backslash.
-     */
+    // Skip lines that end in a backslash.
     for (; start_lnum > 1; start_lnum--) {
       line = (char_u *)ml_get(start_lnum - 1);
       if (*line == NUL || *(line + STRLEN(line) - 1) != '\\') {
@@ -622,11 +566,9 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     wp->w_cursor.lnum = start_lnum;
     wp->w_cursor.col = 0;
 
-    /*
-     * If the line is inside a comment, need to find the syntax item that
-     * defines the comment.
-     * Restrict the search for the end of a comment to b_syn_sync_maxlines.
-     */
+    // If the line is inside a comment, need to find the syntax item that
+    // defines the comment.
+    // Restrict the search for the end of a comment to b_syn_sync_maxlines.
     if (find_start_comment((int)syn_block->b_syn_sync_maxlines) != NULL) {
       for (idx = syn_block->b_syn_patterns.ga_len; --idx >= 0;) {
         if (SYN_ITEMS(syn_block)[idx].sp_syn.id
@@ -644,11 +586,8 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
     wp->w_cursor = cursor_save;
     curwin = curwin_save;
     curbuf = curbuf_save;
-  }
-  /*
-   * 2. Search backwards for given sync patterns.
-   */
-  else if (syn_block->b_syn_sync_flags & SF_MATCH) {
+  } else if (syn_block->b_syn_sync_flags & SF_MATCH) {
+    // 2. Search backwards for given sync patterns.
     if (syn_block->b_syn_sync_maxlines != 0
         && start_lnum > syn_block->b_syn_sync_maxlines) {
       break_lnum = start_lnum - syn_block->b_syn_sync_maxlines;
@@ -675,16 +614,12 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
         break;
       }
 
-      /*
-       * Check if the previous line has the line-continuation pattern.
-       */
+      // Check if the previous line has the line-continuation pattern.
       if (lnum > 1 && syn_match_linecont(lnum - 1)) {
         continue;
       }
 
-      /*
-       * Start with nothing on the state stack
-       */
+      // Start with nothing on the state stack
       validate_current_state();
 
       for (current_lnum = lnum; current_lnum < end_lnum; current_lnum++) {
@@ -712,10 +647,8 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
             found_current_lnum = current_lnum;
             found_current_col = current_col;
             found_m_endpos = cur_si->si_m_endpos;
-            /*
-             * Continue after the match (be aware of a zero-length
-             * match).
-             */
+            // Continue after the match (be aware of a zero-length
+            // match).
             if (found_m_endpos.lnum > current_lnum) {
               current_lnum = found_m_endpos.lnum;
               current_col = found_m_endpos.col;
@@ -743,27 +676,21 @@ static void syn_sync(win_T *wp, linenr_T start_lnum, synstate_T *last_valid)
         }
       }
 
-      /*
-       * If a sync point was encountered, break here.
-       */
+      // If a sync point was encountered, break here.
       if (found_flags) {
-        /*
-         * Put the item that was specified by the sync point on the
-         * state stack.  If there was no item specified, make the
-         * state stack empty.
-         */
+        // Put the item that was specified by the sync point on the
+        // state stack.  If there was no item specified, make the
+        // state stack empty.
         clear_current_state();
         if (found_match_idx >= 0) {
           push_current_state(found_match_idx);
           update_si_attr(current_state.ga_len - 1);
         }
 
-        /*
-         * When using "grouphere", continue from the sync point
-         * match, until the end of the line.  Parsing starts at
-         * the next line.
-         * For "groupthere" the parsing starts at start_lnum.
-         */
+        // When using "grouphere", continue from the sync point
+        // match, until the end of the line.  Parsing starts at
+        // the next line.
+        // For "groupthere" the parsing starts at start_lnum.
         if (found_flags & HL_SYNC_HERE) {
           if (!GA_EMPTY(&current_state)) {
             cur_si = &CUR_STATE(current_state.ga_len - 1);
@@ -833,18 +760,14 @@ static int syn_match_linecont(linenr_T lnum)
   return false;
 }
 
-/*
- * Prepare the current state for the start of a line.
- */
+// Prepare the current state for the start of a line.
 static void syn_start_line(void)
 {
   current_finished = false;
   current_col = 0;
 
-  /*
-   * Need to update the end of a start/skip/end that continues from the
-   * previous line and regions that have "keepend".
-   */
+  // Need to update the end of a start/skip/end that continues from the
+  // previous line and regions that have "keepend".
   if (!GA_EMPTY(&current_state)) {
     syn_update_ends(true);
     check_state_ends();
@@ -881,15 +804,13 @@ static void syn_update_ends(bool startofline)
     }
   }
 
-  /*
-   * Need to update the end of a start/skip/end that continues from the
-   * previous line.  And regions that have "keepend", because they may
-   * influence contained items.  If we've just removed "extend"
-   * (startofline == 0) then we should update ends of normal regions
-   * contained inside "keepend" because "extend" could have extended
-   * these "keepend" regions as well as contained normal regions.
-   * Then check for items ending in column 0.
-   */
+  // Need to update the end of a start/skip/end that continues from the
+  // previous line.  And regions that have "keepend", because they may
+  // influence contained items.  If we've just removed "extend"
+  // (startofline == 0) then we should update ends of normal regions
+  // contained inside "keepend" because "extend" could have extended
+  // these "keepend" regions as well as contained normal regions.
+  // Then check for items ending in column 0.
   int i = current_state.ga_len - 1;
   if (keepend_level >= 0) {
     for (; i > keepend_level; i--) {
@@ -923,37 +844,35 @@ static void syn_update_ends(bool startofline)
 /////////////////////////////////////////
 // Handling of the state stack cache.
 
-/*
- * EXPLANATION OF THE SYNTAX STATE STACK CACHE
- *
- * To speed up syntax highlighting, the state stack for the start of some
- * lines is cached.  These entries can be used to start parsing at that point.
- *
- * The stack is kept in b_sst_array[] for each buffer.  There is a list of
- * valid entries.  b_sst_first points to the first one, then follow sst_next.
- * The entries are sorted on line number.  The first entry is often for line 2
- * (line 1 always starts with an empty stack).
- * There is also a list for free entries.  This construction is used to avoid
- * having to allocate and free memory blocks too often.
- *
- * When making changes to the buffer, this is logged in b_mod_*.  When calling
- * update_screen() to update the display, it will call
- * syn_stack_apply_changes() for each displayed buffer to adjust the cached
- * entries.  The entries which are inside the changed area are removed,
- * because they must be recomputed.  Entries below the changed have their line
- * number adjusted for deleted/inserted lines, and have their sst_change_lnum
- * set to indicate that a check must be made if the changed lines would change
- * the cached entry.
- *
- * When later displaying lines, an entry is stored for each line.  Displayed
- * lines are likely to be displayed again, in which case the state at the
- * start of the line is needed.
- * For not displayed lines, an entry is stored for every so many lines.  These
- * entries will be used e.g., when scrolling backwards.  The distance between
- * entries depends on the number of lines in the buffer.  For small buffers
- * the distance is fixed at SST_DIST, for large buffers there is a fixed
- * number of entries SST_MAX_ENTRIES, and the distance is computed.
- */
+// EXPLANATION OF THE SYNTAX STATE STACK CACHE
+//
+// To speed up syntax highlighting, the state stack for the start of some
+// lines is cached.  These entries can be used to start parsing at that point.
+//
+// The stack is kept in b_sst_array[] for each buffer.  There is a list of
+// valid entries.  b_sst_first points to the first one, then follow sst_next.
+// The entries are sorted on line number.  The first entry is often for line 2
+// (line 1 always starts with an empty stack).
+// There is also a list for free entries.  This construction is used to avoid
+// having to allocate and free memory blocks too often.
+//
+// When making changes to the buffer, this is logged in b_mod_*.  When calling
+// update_screen() to update the display, it will call
+// syn_stack_apply_changes() for each displayed buffer to adjust the cached
+// entries.  The entries which are inside the changed area are removed,
+// because they must be recomputed.  Entries below the changed have their line
+// number adjusted for deleted/inserted lines, and have their sst_change_lnum
+// set to indicate that a check must be made if the changed lines would change
+// the cached entry.
+//
+// When later displaying lines, an entry is stored for each line.  Displayed
+// lines are likely to be displayed again, in which case the state at the
+// start of the line is needed.
+// For not displayed lines, an entry is stored for every so many lines.  These
+// entries will be used e.g., when scrolling backwards.  The distance between
+// entries depends on the number of lines in the buffer.  For small buffers
+// the distance is fixed at SST_DIST, for large buffers there is a fixed
+// number of entries SST_MAX_ENTRIES, and the distance is computed.
 
 static void syn_stack_free_block(synblock_T *block)
 {
@@ -968,10 +887,8 @@ static void syn_stack_free_block(synblock_T *block)
     block->b_sst_len = 0;
   }
 }
-/*
- * Free b_sst_array[] for buffer "buf".
- * Used when syntax items changed to force resyncing everywhere.
- */
+// Free b_sst_array[] for buffer "buf".
+// Used when syntax items changed to force resyncing everywhere.
 void syn_stack_free_all(synblock_T *block)
 {
   syn_stack_free_block(block);
@@ -984,12 +901,10 @@ void syn_stack_free_all(synblock_T *block)
   }
 }
 
-/*
- * Allocate the syntax state stack for syn_buf when needed.
- * If the number of entries in b_sst_array[] is much too big or a bit too
- * small, reallocate it.
- * Also used to allocate b_sst_array[] for the first time.
- */
+// Allocate the syntax state stack for syn_buf when needed.
+// If the number of entries in b_sst_array[] is much too big or a bit too
+// small, reallocate it.
+// Also used to allocate b_sst_array[] for the first time.
 static void syn_stack_alloc(void)
 {
   synstate_T *to, *from;
@@ -1056,12 +971,10 @@ static void syn_stack_alloc(void)
   }
 }
 
-/*
- * Check for changes in a buffer to affect stored syntax states.  Uses the
- * b_mod_* fields.
- * Called from update_screen(), before screen is being updated, once for each
- * displayed buffer.
- */
+// Check for changes in a buffer to affect stored syntax states.  Uses the
+// b_mod_* fields.
+// Called from update_screen(), before screen is being updated, once for each
+// displayed buffer.
 void syn_stack_apply_changes(buf_T *buf)
 {
   syn_stack_apply_changes_block(&buf->b_s, buf);
@@ -1137,11 +1050,9 @@ static bool syn_stack_cleanup(void)
     dist = syn_buf->b_ml.ml_line_count / (syn_block->b_sst_len - Rows) + 1;
   }
 
-  /*
-   * Go through the list to find the "tick" for the oldest entry that can
-   * be removed.  Set "above" when the "tick" for the oldest entry is above
-   * "b_sst_lasttick" (the display tick wraps around).
-   */
+  // Go through the list to find the "tick" for the oldest entry that can
+  // be removed.  Set "above" when the "tick" for the oldest entry is above
+  // "b_sst_lasttick" (the display tick wraps around).
   tick = syn_block->b_sst_lasttick;
   bool above = false;
   prev = syn_block->b_sst_first;
@@ -1158,10 +1069,8 @@ static bool syn_stack_cleanup(void)
     }
   }
 
-  /*
-   * Go through the list to make the entries for the oldest tick at an
-   * interval of several lines.
-   */
+  // Go through the list to make the entries for the oldest tick at an
+  // interval of several lines.
   prev = syn_block->b_sst_first;
   for (p = prev->sst_next; p != NULL; prev = p, p = p->sst_next) {
     if (p->sst_tick == tick && prev->sst_lnum + dist > p->sst_lnum) {
@@ -1175,10 +1084,8 @@ static bool syn_stack_cleanup(void)
   return retval;
 }
 
-/*
- * Free the allocated memory for a syn_state item.
- * Move the entry into the free list.
- */
+// Free the allocated memory for a syn_state item.
+// Move the entry into the free list.
 static void syn_stack_free_entry(synblock_T *block, synstate_T *p)
 {
   clear_syn_state(p);
@@ -1187,10 +1094,8 @@ static void syn_stack_free_entry(synblock_T *block, synstate_T *p)
   block->b_sst_freecount++;
 }
 
-/*
- * Find an entry in the list of state stacks at or before "lnum".
- * Returns NULL when there is no entry or the first entry is after "lnum".
- */
+// Find an entry in the list of state stacks at or before "lnum".
+// Returns NULL when there is no entry or the first entry is after "lnum".
 static synstate_T *syn_stack_find_entry(linenr_T lnum)
 {
   synstate_T *p, *prev;
@@ -1207,10 +1112,8 @@ static synstate_T *syn_stack_find_entry(linenr_T lnum)
   return prev;
 }
 
-/*
- * Try saving the current state in b_sst_array[].
- * The current state must be valid for the start of the current_lnum line!
- */
+// Try saving the current state in b_sst_array[].
+// The current state must be valid for the start of the current_lnum line!
 static synstate_T *store_current_state(void)
 {
   int i;
@@ -1219,10 +1122,8 @@ static synstate_T *store_current_state(void)
   stateitem_T *cur_si;
   synstate_T *sp = syn_stack_find_entry(current_lnum);
 
-  /*
-   * If the current state contains a start or end pattern that continues
-   * from the previous line, we can't use it.  Don't store it then.
-   */
+  // If the current state contains a start or end pattern that continues
+  // from the previous line, we can't use it.  Don't store it then.
   for (i = current_state.ga_len - 1; i >= 0; i--) {
     cur_si = &CUR_STATE(i);
     if (cur_si->si_h_startpos.lnum >= current_lnum
@@ -1254,9 +1155,7 @@ static synstate_T *store_current_state(void)
       sp = NULL;
     }
   } else if (sp == NULL || sp->sst_lnum != current_lnum) {
-    /*
-     * Add a new entry
-     */
+    // Add a new entry
     // If no free items, cleanup the array first.
     if (syn_block->b_sst_freecount == 0) {
       (void)syn_stack_cleanup();
@@ -1316,9 +1215,7 @@ static synstate_T *store_current_state(void)
   return sp;
 }
 
-/*
- * Copy a state stack from "from" in b_sst_array[] to current_state;
- */
+// Copy a state stack from "from" in b_sst_array[] to current_state;
 static void load_current_state(synstate_T *from)
 {
   int i;
@@ -1422,16 +1319,14 @@ static bool syn_stack_equal(synstate_T *sp)
   return i < 0 ? true : false;
 }
 
-/*
- * We stop parsing syntax above line "lnum".  If the stored state at or below
- * this line depended on a change before it, it now depends on the line below
- * the last parsed line.
- * The window looks like this:
- *          line which changed
- *          displayed line
- *          displayed line
- * lnum ->  line below window
- */
+// We stop parsing syntax above line "lnum".  If the stored state at or below
+// this line depended on a change before it, it now depends on the line below
+// the last parsed line.
+// The window looks like this:
+//          line which changed
+//          displayed line
+//          displayed line
+// lnum ->  line below window
 void syntax_end_parsing(linenr_T lnum)
 {
   synstate_T *sp;
@@ -1446,9 +1341,8 @@ void syntax_end_parsing(linenr_T lnum)
   }
 }
 
-/*
- * End of handling of the state stack.
- ****************************************/
+// End of handling of the state stack.
+// **************************************
 
 static void invalidate_current_state(void)
 {
@@ -1473,33 +1367,25 @@ bool syntax_check_changed(linenr_T lnum)
   bool retval = true;
   synstate_T *sp;
 
-  /*
-   * Check the state stack when:
-   * - lnum is just below the previously syntaxed line.
-   * - lnum is not before the lines with saved states.
-   * - lnum is not past the lines with saved states.
-   * - lnum is at or before the last changed line.
-   */
+  // Check the state stack when:
+  // - lnum is just below the previously syntaxed line.
+  // - lnum is not before the lines with saved states.
+  // - lnum is not past the lines with saved states.
+  // - lnum is at or before the last changed line.
   if (VALID_STATE(&current_state) && lnum == current_lnum + 1) {
     sp = syn_stack_find_entry(lnum);
     if (sp != NULL && sp->sst_lnum == lnum) {
-      /*
-       * finish the previous line (needed when not all of the line was
-       * drawn)
-       */
+      // finish the previous line (needed when not all of the line was
+      // drawn)
       (void)syn_finish_line(false);
 
-      /*
-       * Compare the current state with the previously saved state of
-       * the line.
-       */
+      // Compare the current state with the previously saved state of
+      // the line.
       if (syn_stack_equal(sp)) {
         retval = false;
       }
 
-      /*
-       * Store the current state in b_sst_array[] for later use.
-       */
+      // Store the current state in b_sst_array[] for later use.
       current_lnum++;
       (void)store_current_state();
     }
@@ -1587,9 +1473,7 @@ int get_syntax_attr(const colnr_T col, bool *const can_spell, const bool keep_st
     validate_current_state();
   }
 
-  /*
-   * Skip from the current column to "col", get the attributes for "col".
-   */
+  // Skip from the current column to "col", get the attributes for "col".
   while (current_col <= col) {
     attr = syn_current_attr(false, true, can_spell,
                             current_col == col ? keep_state : false);
@@ -1638,9 +1522,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   // Do try matching with an empty line (could be the start of a region).
   line = (char_u *)syn_getcurline();
   if (line[current_col] == NUL && current_col != 0) {
-    /*
-     * If we found a match after the last column, use it.
-     */
+    // If we found a match after the last column, use it.
     if (next_match_idx >= 0 && next_match_col >= (int)current_col
         && next_match_col != MAXCOL) {
       (void)push_next_match();
@@ -1657,11 +1539,9 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
     current_state_stored = false;
   }
 
-  /*
-   * When in the previous column there was a match but it could not be used
-   * (empty match or already matched in this column) need to try again in
-   * the next column.
-   */
+  // When in the previous column there was a match but it could not be used
+  // (empty match or already matched in this column) need to try again in
+  // the next column.
   if (try_next_column) {
     next_match_idx = -1;
     try_next_column = false;
@@ -1679,23 +1559,19 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
   // use syntax iskeyword option
   save_chartab((char *)buf_chartab);
 
-  /*
-   * Repeat matching keywords and patterns, to find contained items at the
-   * same column.  This stops when there are no extra matches at the current
-   * column.
-   */
+  // Repeat matching keywords and patterns, to find contained items at the
+  // same column.  This stops when there are no extra matches at the current
+  // column.
   do {
     found_match = false;
     keep_next_list = false;
     int syn_id = 0;
 
-    /*
-     * 1. Check for a current state.
-     *    Only when there is no current state, or if the current state may
-     *    contain other things, we need to check for keywords and patterns.
-     *    Always need to check for contained items if some item has the
-     *    "containedin" argument (takes extra time!).
-     */
+    // 1. Check for a current state.
+    //    Only when there is no current state, or if the current state may
+    //    contain other things, we need to check for keywords and patterns.
+    //    Always need to check for contained items if some item has the
+    //    "containedin" argument (takes extra time!).
     if (current_state.ga_len) {
       cur_si = &CUR_STATE(current_state.ga_len - 1);
     } else {
@@ -1758,21 +1634,15 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         }
       }
 
-      /*
-       * 3. Check for patterns (only if no keyword found).
-       */
+      // 3. Check for patterns (only if no keyword found).
       if (syn_id == 0 && syn_block->b_syn_patterns.ga_len) {
-        /*
-         * If we didn't check for a match yet, or we are past it, check
-         * for any match with a pattern.
-         */
+        // If we didn't check for a match yet, or we are past it, check
+        // for any match with a pattern.
         if (next_match_idx < 0 || next_match_col < (int)current_col) {
-          /*
-           * Check all relevant patterns for a match at this
-           * position.  This is complicated, because matching with a
-           * pattern takes quite a bit of time, thus we want to
-           * avoid doing it when it's not needed.
-           */
+          // Check all relevant patterns for a match at this
+          // position.  This is complicated, because matching with a
+          // pattern takes quite a bit of time, thus we want to
+          // avoid doing it when it's not needed.
           next_match_idx = 0;                   // no match in this line yet
           next_match_col = MAXCOL;
           for (int idx = syn_block->b_syn_patterns.ga_len; --idx >= 0;) {
@@ -1814,9 +1684,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 continue;
               }
 
-              /*
-               * Compute the first column of the match.
-               */
+              // Compute the first column of the match.
               syn_add_start_off(&pos, &regmatch,
                                 spp, SPO_MS_OFF, -1);
               if (pos.lnum > current_lnum) {
@@ -1831,19 +1699,15 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               // matches in the current line
               spp->sp_startcol = startcol;
 
-              /*
-               * If a previously found match starts at a lower
-               * column number, don't use this one.
-               */
+              // If a previously found match starts at a lower
+              // column number, don't use this one.
               if (startcol >= next_match_col) {
                 continue;
               }
 
-              /*
-               * If we matched this pattern at this position
-               * before, skip it.  Must retry in the next
-               * column, because it may match from there.
-               */
+              // If we matched this pattern at this position
+              // before, skip it.  Must retry in the next
+              // column, because it may match from there.
               if (did_match_already(idx, &zero_width_next_ga)) {
                 try_next_column = true;
                 continue;
@@ -1861,10 +1725,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               syn_add_end_off(&eos_pos, &regmatch,
                               spp, SPO_RS_OFF, 0);
 
-              /*
-               * Grab the external submatches before they get
-               * overwritten.  Reference count doesn't change.
-               */
+              // Grab the external submatches before they get
+              // overwritten.  Reference count doesn't change.
               unref_extmatch(cur_extmatch);
               cur_extmatch = re_extmatch_out;
               re_extmatch_out = NULL;
@@ -1875,12 +1737,10 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
               end_idx = 0;
               hl_endpos.lnum = 0;
 
-              /*
-               * For a "oneline" the end must be found in the
-               * same line too.  Search for it after the end of
-               * the match with the start pattern.  Set the
-               * resulting end positions at the same time.
-               */
+              // For a "oneline" the end must be found in the
+              // same line too.  Search for it after the end of
+              // the match with the start pattern.  Set the
+              // resulting end positions at the same time.
               if (spp->sp_type == SPTYPE_START
                   && (spp->sp_flags & HL_ONELINE)) {
                 lpos_T startpos;
@@ -1891,23 +1751,18 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 if (endpos.lnum == 0) {
                   continue;                         // not found
                 }
-              }
-              /*
-               * For a "match" the size must be > 0 after the
-               * end offset needs has been added.  Except when
-               * syncing.
-               */
-              else if (spp->sp_type == SPTYPE_MATCH) {
+              } else if (spp->sp_type == SPTYPE_MATCH) {
+                // For a "match" the size must be > 0 after the
+                // end offset needs has been added.  Except when
+                // syncing.
                 syn_add_end_off(&hl_endpos, &regmatch, spp,
                                 SPO_HE_OFF, 0);
                 syn_add_end_off(&endpos, &regmatch, spp,
                                 SPO_ME_OFF, 0);
                 if (endpos.lnum == current_lnum
                     && (int)endpos.col + syncing < startcol) {
-                  /*
-                   * If an empty string is matched, may need
-                   * to try matching again at next column.
-                   */
+                  // If an empty string is matched, may need
+                  // to try matching again at next column.
                   if (regmatch.startpos[0].col == regmatch.endpos[0].col) {
                     try_next_column = true;
                   }
@@ -1915,9 +1770,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
                 }
               }
 
-              /*
-               * keep the best match so far in next_match_*
-               */
+              // keep the best match so far in next_match_*
+
               // Highlighting must start after startpos and end
               // before endpos.
               if (hl_startpos.lnum == current_lnum
@@ -1942,9 +1796,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
           }
         }
 
-        /*
-         * If we found a match at the current column, use it.
-         */
+        // If we found a match at the current column, use it.
         if (next_match_idx >= 0 && next_match_col == (int)current_col) {
           synpat_T *lspp;
 
@@ -1972,9 +1824,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
       }
     }
 
-    /*
-     * Handle searching for nextgroup match.
-     */
+    // Handle searching for nextgroup match.
     if (current_next_list != NULL && !keep_next_list) {
       // If a nextgroup was not found, continue looking for one if:
       // - this is an empty line and the "skipempty" option was given
@@ -1989,14 +1839,12 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
         }
       }
 
-      /*
-       * If a nextgroup was found: Use it, and continue looking for
-       * contained matches.
-       * If a nextgroup was not found: Continue looking for a normal
-       * match.
-       * When did set current_next_list for a zero-width item and no
-       * match was found don't loop (would get stuck).
-       */
+      // If a nextgroup was found: Use it, and continue looking for
+      // contained matches.
+      // If a nextgroup was not found: Continue looking for a normal
+      // match.
+      // When did set current_next_list for a zero-width item and no
+      // match was found don't loop (would get stuck).
       current_next_list = NULL;
       next_match_idx = -1;
       if (!zero_width_next_list) {
@@ -2007,10 +1855,8 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
 
   restore_chartab((char *)buf_chartab);
 
-  /*
-   * Use attributes from the current state, if within its highlighting.
-   * If not, use attributes from the current-but-one state, etc.
-   */
+  // Use attributes from the current state, if within its highlighting.
+  // If not, use attributes from the current-but-one state, etc.
   current_attr = 0;
   current_id = 0;
   current_trans_id = 0;
@@ -2076,14 +1922,12 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
       }
     }
 
-    /*
-     * Check for end of current state (and the states before it) at the
-     * next column.  Don't do this for syncing, because we would miss a
-     * single character match.
-     * First check if the current state ends at the current column.  It
-     * may be for an empty match and a containing item might end in the
-     * current column.
-     */
+    // Check for end of current state (and the states before it) at the
+    // next column.  Don't do this for syncing, because we would miss a
+    // single character match.
+    // First check if the current state ends at the current column.  It
+    // may be for an empty match and a containing item might end in the
+    // current column.
     if (!syncing && !keep_state) {
       check_state_ends();
       if (!GA_EMPTY(&current_state)
@@ -2143,9 +1987,7 @@ static bool did_match_already(int idx, garray_T *gap)
   return false;
 }
 
-/*
- * Push the next match onto the stack.
- */
+// Push the next match onto the stack.
 static stateitem_T *push_next_match(void)
 {
   stateitem_T *cur_si;
@@ -2154,15 +1996,11 @@ static stateitem_T *push_next_match(void)
 
   spp = &(SYN_ITEMS(syn_block)[next_match_idx]);
 
-  /*
-   * Push the item in current_state stack;
-   */
+  // Push the item in current_state stack;
   push_current_state(next_match_idx);
   {
-    /*
-     * If it's a start-skip-end type that crosses lines, figure out how
-     * much it continues in this line.  Otherwise just fill in the length.
-     */
+    // If it's a start-skip-end type that crosses lines, figure out how
+    // much it continues in this line.  Otherwise just fill in the length.
     cur_si = &CUR_STATE(current_state.ga_len - 1);
     cur_si->si_h_startpos = next_match_h_startpos;
     cur_si->si_m_startcol = current_col;
@@ -2195,10 +2033,8 @@ static stateitem_T *push_next_match(void)
     update_si_attr(current_state.ga_len - 1);
 
     save_flags = cur_si->si_flags & (HL_CONCEAL | HL_CONCEALENDS);
-    /*
-     * If the start pattern has another highlight group, push another item
-     * on the stack for the start pattern.
-     */
+    // If the start pattern has another highlight group, push another item
+    // on the stack for the start pattern.
     if (spp->sp_type == SPTYPE_START && spp->sp_syn_match_id != 0) {
       push_current_state(next_match_idx);
       cur_si = &CUR_STATE(current_state.ga_len - 1);
@@ -2226,9 +2062,7 @@ static stateitem_T *push_next_match(void)
   return cur_si;
 }
 
-/*
- * Check for end of current state (and the states before it).
- */
+// Check for end of current state (and the states before it).
 static void check_state_ends(void)
 {
   stateitem_T *cur_si;
@@ -2240,12 +2074,10 @@ static void check_state_ends(void)
         && (cur_si->si_m_endpos.lnum < current_lnum
             || (cur_si->si_m_endpos.lnum == current_lnum
                 && cur_si->si_m_endpos.col <= current_col))) {
-      /*
-       * If there is an end pattern group ID, highlight the end pattern
-       * now.  No need to pop the current item from the stack.
-       * Only do this if the end pattern continues beyond the current
-       * position.
-       */
+      // If there is an end pattern group ID, highlight the end pattern
+      // now.  No need to pop the current item from the stack.
+      // Only do this if the end pattern continues beyond the current
+      // position.
       if (cur_si->si_end_idx
           && (cur_si->si_eoe_pos.lnum > current_lnum
               || (cur_si->si_eoe_pos.lnum == current_lnum
@@ -2322,10 +2154,8 @@ static void check_state_ends(void)
   }
 }
 
-/*
- * Update an entry in the current_state stack for a match or region.  This
- * fills in si_attr, si_next_list and si_cont_list.
- */
+// Update an entry in the current_state stack for a match or region.  This
+// fills in si_attr, si_next_list and si_cont_list.
 static void update_si_attr(int idx)
 {
   stateitem_T *sip = &CUR_STATE(idx);
@@ -2350,11 +2180,9 @@ static void update_si_attr(int idx)
     sip->si_cont_list = spp->sp_cont_list;
   }
 
-  /*
-   * For transparent items, take attr from outer item.
-   * Also take cont_list, if there is none.
-   * Don't do this for the matchgroup of a start or end pattern.
-   */
+  // For transparent items, take attr from outer item.
+  // Also take cont_list, if there is none.
+  // Don't do this for the matchgroup of a start or end pattern.
   if ((spp->sp_flags & HL_TRANSP) && !(sip->si_flags & HL_MATCH)) {
     if (idx == 0) {
       sip->si_attr = 0;
@@ -2373,10 +2201,8 @@ static void update_si_attr(int idx)
   }
 }
 
-/*
- * Check the current stack for patterns with "keepend" flag.
- * Propagate the match-end to contained items, until a "skipend" item is found.
- */
+// Check the current stack for patterns with "keepend" flag.
+// Propagate the match-end to contained items, until a "skipend" item is found.
 static void check_keepend(void)
 {
   int i;
@@ -2384,19 +2210,15 @@ static void check_keepend(void)
   lpos_T maxpos_h;
   stateitem_T *sip;
 
-  /*
-   * This check can consume a lot of time; only do it from the level where
-   * there really is a keepend.
-   */
+  // This check can consume a lot of time; only do it from the level where
+  // there really is a keepend.
   if (keepend_level < 0) {
     return;
   }
 
-  /*
-   * Find the last index of an "extend" item.  "keepend" items before that
-   * won't do anything.  If there is no "extend" item "i" will be
-   * "keepend_level" and all "keepend" items will work normally.
-   */
+  // Find the last index of an "extend" item.  "keepend" items before that
+  // won't do anything.  If there is no "extend" item "i" will be
+  // "keepend_level" and all "keepend" items will work normally.
   for (i = current_state.ga_len - 1; i > keepend_level; i--) {
     if (CUR_STATE(i).si_flags & HL_EXTEND) {
       break;
@@ -2456,10 +2278,8 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
     return;
   }
 
-  /*
-   * We need to find the end of the region.  It may continue in the next
-   * line.
-   */
+  // We need to find the end of the region.  It may continue in the next
+  // line.
   int end_idx = 0;
   lpos_T startpos = {
     .lnum = current_lnum,
@@ -2492,10 +2312,8 @@ static void update_si_end(stateitem_T *sip, int startcol, bool force)
   }
 }
 
-/*
- * Add a new state to the current state stack.
- * It is cleared and the index set to "idx".
- */
+// Add a new state to the current state stack.
+// It is cleared and the index set to "idx".
 static void push_current_state(int idx)
 {
   stateitem_T *p = GA_APPEND_VIA_PTR(stateitem_T, &current_state);
@@ -2503,9 +2321,7 @@ static void push_current_state(int idx)
   p->si_idx = idx;
 }
 
-/*
- * Remove a state from the current_state stack.
- */
+// Remove a state from the current_state stack.
 static void pop_current_state(void)
 {
   if (!GA_EMPTY(&current_state)) {
@@ -2556,20 +2372,16 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     return;
   }
 
-  /*
-   * Check for being called with a START pattern.
-   * Can happen with a match that continues to the next line, because it
-   * contained a region.
-   */
+  // Check for being called with a START pattern.
+  // Can happen with a match that continues to the next line, because it
+  // contained a region.
   spp = &(SYN_ITEMS(syn_block)[idx]);
   if (spp->sp_type != SPTYPE_START) {
     *hl_endpos = *startpos;
     return;
   }
 
-  /*
-   * Find the SKIP or first END pattern after the last START pattern.
-   */
+  // Find the SKIP or first END pattern after the last START pattern.
   for (;;) {
     spp = &(SYN_ITEMS(syn_block)[idx]);
     if (spp->sp_type != SPTYPE_START) {
@@ -2578,9 +2390,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     idx++;
   }
 
-  /*
-   *    Lookup the SKIP pattern (if present)
-   */
+  //    Lookup the SKIP pattern (if present)
   if (spp->sp_type == SPTYPE_SKIP) {
     spp_skip = spp;
     idx++;
@@ -2600,9 +2410,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
   save_chartab((char *)buf_chartab);
 
   for (;;) {
-    /*
-     * Find end pattern that matches first after "matchcol".
-     */
+    // Find end pattern that matches first after "matchcol".
     best_idx = -1;
     for (idx = start_idx; idx < syn_block->b_syn_patterns.ga_len; idx++) {
       int lc_col = matchcol;
@@ -2631,18 +2439,14 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
       }
     }
 
-    /*
-     * If all end patterns have been tried, and there is no match, the
-     * item continues until end-of-line.
-     */
+    // If all end patterns have been tried, and there is no match, the
+    // item continues until end-of-line.
     if (best_idx == -1) {
       break;
     }
 
-    /*
-     * If the skip pattern matches before the end pattern,
-     * continue searching after the skip pattern.
-     */
+    // If the skip pattern matches before the end pattern,
+    // continue searching after the skip pattern.
     if (spp_skip != NULL) {
       int lc_col = matchcol - spp_skip->sp_offsets[SPO_LC_OFF];
 
@@ -2688,10 +2492,8 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
       }
     }
 
-    /*
-     * Match from start pattern to end pattern.
-     * Correct for match and highlight offset of end pattern.
-     */
+    // Match from start pattern to end pattern.
+    // Correct for match and highlight offset of end pattern.
     spp = &(SYN_ITEMS(syn_block)[best_idx]);
     syn_add_end_off(m_endpos, &best_regmatch, spp, SPO_ME_OFF, 1);
     // can't end before the start
@@ -2708,9 +2510,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
     // can't end after the match
     limit_pos(end_endpos, m_endpos);
 
-    /*
-     * If the end group is highlighted differently, adjust the pointers.
-     */
+    // If the end group is highlighted differently, adjust the pointers.
     if (spp->sp_syn_match_id != spp->sp_syn.id && spp->sp_syn_match_id != 0) {
       *end_idx = best_idx;
       if (spp->sp_off_flags & (1 << (SPO_RE_OFF + SPO_COUNT))) {
@@ -2755,9 +2555,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
   re_extmatch_in = NULL;
 }
 
-/*
- * Limit "pos" not to be after "limit".
- */
+// Limit "pos" not to be after "limit".
 static void limit_pos(lpos_T *pos, lpos_T *limit)
 {
   if (pos->lnum > limit->lnum) {
@@ -2767,9 +2565,7 @@ static void limit_pos(lpos_T *pos, lpos_T *limit)
   }
 }
 
-/*
- * Limit "pos" not to be after "limit", unless pos->lnum is zero.
- */
+// Limit "pos" not to be after "limit", unless pos->lnum is zero.
 static void limit_pos_zero(lpos_T *pos, lpos_T *limit)
 {
   if (pos->lnum == 0) {
@@ -2875,10 +2671,8 @@ static char *syn_getcurline(void)
   return (char *)ml_get_buf(syn_buf, current_lnum, false);
 }
 
-/*
- * Call vim_regexec() to find a match with "rmp" in "syn_buf".
- * Returns true when there is a match.
- */
+// Call vim_regexec() to find a match with "rmp" in "syn_buf".
+// Returns true when there is a match.
 static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T *st)
 {
   int timed_out = 0;
@@ -3001,9 +2795,7 @@ static keyentry_T *match_keyword(char *keyword, hashtab_T *ht, stateitem_T *cur_
   return NULL;
 }
 
-/*
- * Handle ":syntax conceal" command.
- */
+// Handle ":syntax conceal" command.
 static void syn_cmd_conceal(exarg_T *eap, int syncing)
 {
   char_u *arg = (char_u *)eap->arg;
@@ -3171,9 +2963,7 @@ static void syn_cmd_iskeyword(exarg_T *eap, int syncing)
   redraw_later(curwin, UPD_NOT_VALID);
 }
 
-/*
- * Clear all syntax info for one buffer.
- */
+// Clear all syntax info for one buffer.
 void syntax_clear(synblock_T *block)
 {
   block->b_syn_error = false;           // clear previous error
@@ -3221,9 +3011,7 @@ void syntax_clear(synblock_T *block)
   running_syn_inc_tag = 0;
 }
 
-/*
- * Get rid of ownsyntax for window "wp".
- */
+// Get rid of ownsyntax for window "wp".
 void reset_synblock(win_T *wp)
 {
   if (wp->w_s != &wp->w_buffer->b_s) {
@@ -3233,9 +3021,7 @@ void reset_synblock(win_T *wp)
   }
 }
 
-/*
- * Clear syncing info for one buffer.
- */
+// Clear syncing info for one buffer.
 static void syntax_sync_clear(void)
 {
   // free the syntax patterns
@@ -3258,9 +3044,7 @@ static void syntax_sync_clear(void)
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
-/*
- * Remove one pattern from the buffer's pattern list.
- */
+// Remove one pattern from the buffer's pattern list.
 static void syn_remove_pattern(synblock_T *block, int idx)
 {
   synpat_T *spp;
@@ -3274,10 +3058,8 @@ static void syn_remove_pattern(synblock_T *block, int idx)
   block->b_syn_patterns.ga_len--;
 }
 
-/*
- * Clear and free one syntax pattern.  When clearing all, must be called from
- * last to first!
- */
+// Clear and free one syntax pattern.  When clearing all, must be called from
+// last to first!
 static void syn_clear_pattern(synblock_T *block, int i)
 {
   xfree(SYN_ITEMS(block)[i].sp_pattern);
@@ -3290,9 +3072,7 @@ static void syn_clear_pattern(synblock_T *block, int i)
   }
 }
 
-/*
- * Clear and free one syntax cluster.
- */
+// Clear and free one syntax cluster.
 static void syn_clear_cluster(synblock_T *block, int i)
 {
   xfree(SYN_CLSTR(block)[i].scl_name);
@@ -3312,20 +3092,16 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
     return;
   }
 
-  /*
-   * We have to disable this within ":syn include @group filename",
-   * because otherwise @group would get deleted.
-   * Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
-   * clear".
-   */
+  // We have to disable this within ":syn include @group filename",
+  // because otherwise @group would get deleted.
+  // Only required for Vim 5.x syntax files, 6.0 ones don't contain ":syn
+  // clear".
   if (curwin->w_s->b_syn_topgrp != 0) {
     return;
   }
 
   if (ends_excmd(*arg)) {
-    /*
-     * No argument: Clear all syntax items.
-     */
+    // No argument: Clear all syntax items.
     if (syncing) {
       syntax_sync_clear();
     } else {
@@ -3336,9 +3112,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
       do_unlet(S_LEN("w:current_syntax"), true);
     }
   } else {
-    /*
-     * Clear the group IDs that are in the argument.
-     */
+    // Clear the group IDs that are in the argument.
     while (!ends_excmd(*arg)) {
       arg_end = skiptowhite(arg);
       if (*arg == '@') {
@@ -3370,9 +3144,7 @@ static void syn_cmd_clear(exarg_T *eap, int syncing)
   syn_stack_free_all(curwin->w_s);              // Need to recompute all syntax.
 }
 
-/*
- * Clear one syntax group for the current buffer.
- */
+// Clear one syntax group for the current buffer.
 static void syn_clear_one(const int id, const bool syncing)
 {
   synpat_T *spp;
@@ -3393,18 +3165,14 @@ static void syn_clear_one(const int id, const bool syncing)
   }
 }
 
-/*
- * Handle ":syntax on" command.
- */
+// Handle ":syntax on" command.
 static void syn_cmd_on(exarg_T *eap, int syncing)
 {
   syn_cmd_onoff(eap, "syntax");
 }
 
-/*
- * Handle ":syntax reset" command.
- * It actually resets highlighting, not syntax.
- */
+// Handle ":syntax reset" command.
+// It actually resets highlighting, not syntax.
 static void syn_cmd_reset(exarg_T *eap, int syncing)
 {
   eap->nextcmd = check_nextcmd(eap->arg);
@@ -3413,17 +3181,13 @@ static void syn_cmd_reset(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * Handle ":syntax manual" command.
- */
+// Handle ":syntax manual" command.
 static void syn_cmd_manual(exarg_T *eap, int syncing)
 {
   syn_cmd_onoff(eap, "manual");
 }
 
-/*
- * Handle ":syntax off" command.
- */
+// Handle ":syntax off" command.
 static void syn_cmd_off(exarg_T *eap, int syncing)
 {
   syn_cmd_onoff(eap, "nosyntax");
@@ -3503,9 +3267,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
     msg_puts_title(_("\n--- Syntax items ---"));
   }
   if (ends_excmd(*arg)) {
-    /*
-     * No argument: List all group IDs and all syntax clusters.
-     */
+    // No argument: List all group IDs and all syntax clusters.
     for (int id = 1; id <= highlight_num_groups() && !got_int; id++) {
       syn_list_one(id, syncing, false);
     }
@@ -3513,9 +3275,7 @@ static void syn_cmd_list(exarg_T *eap, int syncing)
       syn_list_cluster(id);
     }
   } else {
-    /*
-     * List the group IDs and syntax clusters that are in the argument.
-     */
+    // List the group IDs and syntax clusters that are in the argument.
     while (!ends_excmd(*arg) && !got_int) {
       arg_end = (char_u *)skiptowhite((char *)arg);
       if (*arg == '@') {
@@ -3693,9 +3453,7 @@ static void syn_list_flags(struct name_list *nlist, int flags, int attr)
   }
 }
 
-/*
- * List one syntax cluster, for ":syntax" or "syntax list syntax_name".
- */
+// List one syntax cluster, for ":syntax" or "syntax list syntax_name".
 static void syn_list_cluster(int id)
 {
   int endcol = 15;
@@ -3939,9 +3697,7 @@ static void syn_clear_keyword(int id, hashtab_T *ht)
   hash_unlock(ht);
 }
 
-/*
- * Clear a whole keyword table.
- */
+// Clear a whole keyword table.
 static void clear_keywtab(hashtab_T *ht)
 {
   hashitem_T *hi;
@@ -4088,11 +3844,9 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
   }
 
   for (;;) {
-    /*
-     * This is used very often when a large number of keywords is defined.
-     * Need to skip quickly when no option name is found.
-     * Also avoid tolower(), it's slow.
-     */
+    // This is used very often when a large number of keywords is defined.
+    // Need to skip quickly when no option name is found.
+    // Also avoid tolower(), it's slow.
     if (strchr(first_letters, *arg) == NULL) {
       break;
     }
@@ -4196,11 +3950,9 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
   return arg;
 }
 
-/*
- * Adjustments to syntax item when declared in a ":syn include"'d file.
- * Set the contained flag, and if the item is not already contained, add it
- * to the specified top-level group, if any.
- */
+// Adjustments to syntax item when declared in a ":syn include"'d file.
+// Set the contained flag, and if the item is not already contained, add it
+// to the specified top-level group, if any.
 static void syn_incl_toplevel(int id, int *flagsp)
 {
   if ((*flagsp & HL_CONTAINED) || curwin->w_s->b_syn_topgrp == 0) {
@@ -4219,9 +3971,7 @@ static void syn_incl_toplevel(int id, int *flagsp)
   }
 }
 
-/*
- * Handle ":syntax include [@{group-name}] filename" command.
- */
+// Handle ":syntax include [@{group-name}] filename" command.
 static void syn_cmd_include(exarg_T *eap, int syncing)
 {
   char *arg = eap->arg;
@@ -4253,10 +4003,8 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
     eap->arg = rest;
   }
 
-  /*
-   * Everything that's left, up to the next command, should be the
-   * filename to include.
-   */
+  // Everything that's left, up to the next command, should be the
+  // filename to include.
   eap->argt |= (EX_XFILE | EX_NOSPC);
   separate_nextcmd(eap);
   if (*eap->arg == '<' || *eap->arg == '$' || path_is_absolute((char_u *)eap->arg)) {
@@ -4272,10 +4020,8 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
     }
   }
 
-  /*
-   * Save and restore the existing top-level grouplist id and ":syn
-   * include" tag around the actual inclusion.
-   */
+  // Save and restore the existing top-level grouplist id and ":syn
+  // include" tag around the actual inclusion.
   if (running_syn_inc_tag >= MAX_SYN_INC_TAG) {
     emsg(_("E847: Too many syntax includes"));
     return;
@@ -4293,9 +4039,7 @@ static void syn_cmd_include(exarg_T *eap, int syncing)
   current_syn_inc_tag = prev_syn_inc_tag;
 }
 
-/*
- * Handle ":syntax keyword {group-name} [{option}] keyword .." command.
- */
+// Handle ":syntax keyword {group-name} [{option}] keyword .." command.
 static void syn_cmd_keyword(exarg_T *eap, int syncing)
 {
   char *arg = eap->arg;
@@ -4444,18 +4188,14 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
   rest = get_syn_options(rest, &syn_opt_arg, &conceal_char, eap->skip);
 
   if (rest != NULL) {           // all arguments are valid
-    /*
-     * Check for trailing command and illegal trailing arguments.
-     */
+    // Check for trailing command and illegal trailing arguments.
     eap->nextcmd = check_nextcmd(rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
     } else {
       if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
-        /*
-         * Store the pattern in the syn_items list
-         */
+        // Store the pattern in the syn_items list
         synpat_T *spp = GA_APPEND_VIA_PTR(synpat_T,
                                           &curwin->w_s->b_syn_patterns);
         *spp = item;
@@ -4488,9 +4228,7 @@ static void syn_cmd_match(exarg_T *eap, int syncing)
     }
   }
 
-  /*
-   * Something failed, free the allocated memory.
-   */
+  // Something failed, free the allocated memory.
   vim_regfree(item.sp_prog);
   xfree(item.sp_pattern);
   xfree(syn_opt_arg.cont_list);
@@ -4608,11 +4346,9 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
       }
       rest = skipwhite(p);
     } else {
-      /*
-       * Allocate room for a syn_pattern, and link it in the list of
-       * syn_patterns for this item, at the start (because the list is
-       * used from end to start).
-       */
+      // Allocate room for a syn_pattern, and link it in the list of
+      // syn_patterns for this item, at the start (because the list is
+      // used from end to start).
       ppp = xmalloc(sizeof(struct pat_ptr));
       ppp->pp_next = pat_ptrs[item];
       pat_ptrs[item] = ppp;
@@ -4650,10 +4386,8 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
   }
 
   if (rest != NULL) {
-    /*
-     * Check for trailing garbage or command.
-     * If OK, add the item.
-     */
+    // Check for trailing garbage or command.
+    // If OK, add the item.
     eap->nextcmd = check_nextcmd(rest);
     if (!ends_excmd(*rest) || eap->skip) {
       rest = NULL;
@@ -4661,9 +4395,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
       ga_grow(&(curwin->w_s->b_syn_patterns), pat_count);
       if ((syn_id = syn_check_group(arg, (size_t)(group_name_end - arg))) != 0) {
         syn_incl_toplevel(syn_id, &syn_opt_arg.flags);
-        /*
-         * Store the start/skip/end in the syn_items list
-         */
+        // Store the start/skip/end in the syn_items list
         int idx = curwin->w_s->b_syn_patterns.ga_len;
         for (item = ITEM_START; item <= ITEM_END; item++) {
           for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp->pp_next) {
@@ -4704,9 +4436,7 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     }
   }
 
-  /*
-   * Free the allocated memory.
-   */
+  // Free the allocated memory.
   for (item = ITEM_START; item <= ITEM_END; item++) {
     for (ppp = pat_ptrs[item]; ppp != NULL; ppp = ppp_next) {
       if (!success && ppp->pp_synp != NULL) {
@@ -4750,9 +4480,7 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
   const int16_t *g2;
   int16_t *clstr = NULL;
 
-  /*
-   * Handle degenerate cases.
-   */
+  // Handle degenerate cases.
   if (*clstr2 == NULL) {
     return;
   }
@@ -4788,13 +4516,9 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     g2 = *clstr2;
     int count = 0;
 
-    /*
-     * First, loop through the lists until one of them is empty.
-     */
+    // First, loop through the lists until one of them is empty.
     while (*g1 && *g2) {
-      /*
-       * We always want to add from the first list.
-       */
+      // We always want to add from the first list.
       if (*g1 < *g2) {
         if (round == 2) {
           clstr[count] = *g1;
@@ -4803,10 +4527,8 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
         g1++;
         continue;
       }
-      /*
-       * We only want to add from the second list if we're adding the
-       * lists.
-       */
+      // We only want to add from the second list if we're adding the
+      // lists.
       if (list_op == CLUSTER_ADD) {
         if (round == 2) {
           clstr[count] = *g2;
@@ -4819,11 +4541,9 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
       g2++;
     }
 
-    /*
-     * Now add the leftovers from whichever list didn't get finished
-     * first.  As before, we only want to add from the second list if
-     * we're adding the lists.
-     */
+    // Now add the leftovers from whichever list didn't get finished
+    // first.  As before, we only want to add from the second list if
+    // we're adding the lists.
     for (; *g1; g1++, count++) {
       if (round == 2) {
         clstr[count] = *g1;
@@ -4838,10 +4558,8 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     }
 
     if (round == 1) {
-      /*
-       * If the group ended up empty, we don't need to allocate any
-       * space for it.
-       */
+      // If the group ended up empty, we don't need to allocate any
+      // space for it.
       if (count == 0) {
         clstr = NULL;
         break;
@@ -4851,9 +4569,7 @@ static void syn_combine_list(int16_t **const clstr1, int16_t **const clstr2, con
     }
   }
 
-  /*
-   * Finally, put the new list in place.
-   */
+  // Finally, put the new list in place.
   xfree(*clstr1);
   xfree(*clstr2);
   *clstr1 = clstr;
@@ -4909,9 +4625,7 @@ static int syn_check_cluster(char *pp, int len)
 /// @return  0 for failure.
 static int syn_add_cluster(char *name)
 {
-  /*
-   * First call for this growarray: init growing array.
-   */
+  // First call for this growarray: init growing array.
   if (curwin->w_s->b_syn_clusters.ga_data == NULL) {
     curwin->w_s->b_syn_clusters.ga_itemsize = sizeof(syn_cluster_T);
     ga_set_growsize(&curwin->w_s->b_syn_clusters, 10);
@@ -4941,10 +4655,8 @@ static int syn_add_cluster(char *name)
   return len + SYNID_CLUSTER;
 }
 
-/*
- * Handle ":syntax cluster {cluster-name} [contains={groupname},..]
- *              [add={groupname},..] [remove={groupname},..]".
- */
+// Handle ":syntax cluster {cluster-name} [contains={groupname},..]
+//              [add={groupname},..] [remove={groupname},..]".
 static void syn_cmd_cluster(exarg_T *eap, int syncing)
 {
   char *arg = eap->arg;
@@ -5013,9 +4725,7 @@ static void syn_cmd_cluster(exarg_T *eap, int syncing)
   }
 }
 
-/*
- * On first call for current buffer: Init growing array.
- */
+// On first call for current buffer: Init growing array.
 static void init_syn_patterns(void)
 {
   curwin->w_s->b_syn_patterns.ga_itemsize = sizeof(synpat_T);
@@ -5058,9 +4768,7 @@ static char *get_syn_pattern(char *arg, synpat_T *ci)
   ci->sp_ic = curwin->w_s->b_syn_ic;
   syn_clear_time(&ci->sp_time);
 
-  /*
-   * Check for a match, highlight or region offset.
-   */
+  // Check for a match, highlight or region offset.
   end++;
   do {
     for (idx = SPO_COUNT; --idx >= 0;) {
@@ -5324,9 +5032,7 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
           id = syn_check_cluster(name + 2, (int)(end - p - 1));
         }
       } else {
-        /*
-         * Handle full group name.
-         */
+        // Handle full group name.
         if (strpbrk(name + 1, "\\.*^$~[") == NULL) {
           id = syn_check_group((name + 1), (size_t)(end - p));
         } else {
@@ -5411,9 +5117,7 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
   return OK;
 }
 
-/*
- * Make a copy of an ID list.
- */
+// Make a copy of an ID list.
 static int16_t *copy_id_list(const int16_t *const list)
 {
   if (list == NULL) {
@@ -5470,10 +5174,8 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
     return false;
   }
 
-  /*
-   * If list is ID_LIST_ALL, we are in a transparent item that isn't
-   * inside anything.  Only allow not-contained groups.
-   */
+  // If list is ID_LIST_ALL, we are in a transparent item that isn't
+  // inside anything.  Only allow not-contained groups.
   if (list == ID_LIST_ALL) {
     return !contained;
   }
@@ -5505,9 +5207,7 @@ static int in_id_list(stateitem_T *cur_si, int16_t *list, struct sp_syn *ssp, in
     retval = true;
   }
 
-  /*
-   * Return "retval" if id is in the contains list.
-   */
+  // Return "retval" if id is in the contains list.
   while (item != 0) {
     if (item == id) {
       return retval;
@@ -5651,19 +5351,15 @@ static enum {
   EXP_CLUSTER,      // expand ":syn list @cluster" arguments
 } expand_what;
 
-/*
- * Reset include_link, include_default, include_none to 0.
- * Called when we are done expanding.
- */
+// Reset include_link, include_default, include_none to 0.
+// Called when we are done expanding.
 void reset_expand_highlight(void)
 {
   include_link = include_default = include_none = 0;
 }
 
-/*
- * Handle command line completion for :match and :echohl command: Add "None"
- * as highlight group.
- */
+// Handle command line completion for :match and :echohl command: Add "None"
+// as highlight group.
 void set_context_in_echohl_cmd(expand_T *xp, const char *arg)
 {
   xp->xp_context = EXPAND_HIGHLIGHT;
@@ -5671,9 +5367,7 @@ void set_context_in_echohl_cmd(expand_T *xp, const char *arg)
   include_none = 1;
 }
 
-/*
- * Handle command line completion for :syntax command.
- */
+// Handle command line completion for :syntax command.
 void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
 {
   // Default: expand subcommands.
@@ -5714,10 +5408,8 @@ void set_context_in_syntax_cmd(expand_T *xp, const char *arg)
   }
 }
 
-/*
- * Function given to ExpandGeneric() to obtain the list syntax names for
- * expansion.
- */
+// Function given to ExpandGeneric() to obtain the list syntax names for
+// expansion.
 char *get_syntax_name(expand_T *xp, int idx)
 {
   switch (expand_what) {
@@ -5773,12 +5465,10 @@ int syn_get_id(win_T *wp, linenr_T lnum, colnr_T col, int trans, bool *spellp, i
   return trans ? current_trans_id : current_id;
 }
 
-/*
- * Get extra information about the syntax item.  Must be called right after
- * get_syntax_attr().
- * Stores the current item sequence nr in "*seqnrp".
- * Returns the current flags.
- */
+// Get extra information about the syntax item.  Must be called right after
+// get_syntax_attr().
+// Stores the current item sequence nr in "*seqnrp".
+// Returns the current flags.
 int get_syntax_info(int *seqnrp)
 {
   *seqnrp = current_seqnr;
@@ -5802,19 +5492,15 @@ int syn_get_concealed_id(win_T *wp, linenr_T lnum, colnr_T col)
   return 0;
 }
 
-/*
- * Return conceal substitution character
- */
+// Return conceal substitution character
 int syn_get_sub_char(void)
 {
   return current_sub_char;
 }
 
-/*
- * Return the syntax ID at position "i" in the current stack.
- * The caller must have called syn_get_id() before to fill the stack.
- * Returns -1 when "i" is out of range.
- */
+// Return the syntax ID at position "i" in the current stack.
+// The caller must have called syn_get_id() before to fill the stack.
+// Returns -1 when "i" is out of range.
 int syn_get_stack_item(int i)
 {
   if (i >= current_state.ga_len) {
@@ -5877,9 +5563,7 @@ int syn_get_foldlevel(win_T *wp, linenr_T lnum)
   return level;
 }
 
-/*
- * ":syntime".
- */
+// ":syntime".
 void ex_syntime(exarg_T *eap)
 {
   if (STRCMP(eap->arg, "on") == 0) {
@@ -5903,9 +5587,7 @@ static void syn_clear_time(syn_time_T *st)
   st->match = 0;
 }
 
-/*
- * Clear the syntax timing for the current buffer.
- */
+// Clear the syntax timing for the current buffer.
 static void syntime_clear(void)
 {
   synpat_T *spp;
@@ -5920,10 +5602,8 @@ static void syntime_clear(void)
   }
 }
 
-/*
- * Function given to ExpandGeneric() to obtain the possible arguments of the
- * ":syntime {on,off,clear,report}" command.
- */
+// Function given to ExpandGeneric() to obtain the possible arguments of the
+// ":syntime {on,off,clear,report}" command.
 char *get_syntime_arg(expand_T *xp, int idx)
 {
   switch (idx) {
@@ -5947,9 +5627,7 @@ static int syn_compare_syntime(const void *v1, const void *v2)
   return profile_cmp(s1->total, s2->total);
 }
 
-/*
- * Clear the syntax timing for the current buffer.
- */
+// Clear the syntax timing for the current buffer.
 static void syntime_report(void)
 {
   if (!syntax_present(curwin)) {
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index d1d5514648..04154384af 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1,9 +1,7 @@
 // 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
 
-/*
- * Code to handle tags and the tag stack
- */
+// Code to handle tags and the tag stack
 
 #include <assert.h>
 #include <inttypes.h>
@@ -51,9 +49,7 @@
 #include "nvim/vim.h"
 #include "nvim/window.h"
 
-/*
- * Structure to hold pointers to various items in a tag line.
- */
+// Structure to hold pointers to various items in a tag line.
 typedef struct tag_pointers {
   // filled in by parse_tag_line():
   char_u *tagname;  // start of tag name (skip "file:")
@@ -73,9 +69,7 @@ typedef struct tag_pointers {
   linenr_T tagline;       // "line:" value
 } tagptrs_T;
 
-/*
- * Structure to hold info about the tag pattern being used.
- */
+// Structure to hold info about the tag pattern being used.
 typedef struct {
   char_u *pat;             // the pattern
   int len;                      // length of pat[]
@@ -117,10 +111,8 @@ static char_u *tfu_inv_ret_msg
 
 static char_u *tagmatchname = NULL;   // name of last used tag
 
-/*
- * Tag for preview window is remembered separately, to avoid messing up the
- * normal tagstack.
- */
+// Tag for preview window is remembered separately, to avoid messing up the
+// normal tagstack.
 static taggy_T ptag_entry = { NULL, INIT_FMARK, 0, 0, NULL };
 
 static int tfu_in_use = false;  // disallow recursive call of tagfunc
@@ -243,10 +235,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
           ptag_entry.tagname = (char *)vim_strsave(tag);
         }
       } else {
-        /*
-         * If the last used entry is not at the top, delete all tag
-         * stack entries above it.
-         */
+        // If the last used entry is not at the top, delete all tag
+        // stack entries above it.
         while (tagstackidx < tagstacklen) {
           tagstack_clear_entry(&tagstack[--tagstacklen]);
         }
@@ -300,10 +290,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         // tagstack before it's used.
         saved_fmark = tagstack[tagstackidx].fmark;
         if (saved_fmark.fnum != curbuf->b_fnum) {
-          /*
-           * Jump to other file. If this fails (e.g. because the
-           * file was changed) keep original position in tag stack.
-           */
+          // Jump to other file. If this fails (e.g. because the
+          // file was changed) keep original position in tag stack.
           if (buflist_getfile(saved_fmark.fnum, saved_fmark.mark.lnum,
                               GETF_SETMARK, forceit) == FAIL) {
             tagstackidx = oldtagstackidx;              // back to old posn
@@ -340,11 +328,9 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
           // ":tag" (no argument): go to newer pattern
           save_pos = true;              // save the cursor position below
           if ((tagstackidx += count - 1) >= tagstacklen) {
-            /*
-             * Beyond the last one, just give an error message and
-             * go to the last one.  Don't store the cursor
-             * position.
-             */
+            // Beyond the last one, just give an error message and
+            // go to the last one.  Don't store the cursor
+            // position.
             tagstackidx = tagstacklen - 1;
             emsg(_(topmsg));
             save_pos = false;
@@ -401,9 +387,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         ptag_entry.cur_fnum = cur_fnum;
       }
     } else {
-      /*
-       * For ":tag [arg]" or ":tselect" remember position before the jump.
-       */
+      // For ":tag [arg]" or ":tselect" remember position before the jump.
       saved_fmark = tagstack[tagstackidx].fmark;
       if (save_pos) {
         tagstack[tagstackidx].fmark.mark = curwin->w_cursor;
@@ -432,9 +416,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
     }
   }
 
-  /*
-   * Repeat searching for tags, when a file has not been found.
-   */
+  // Repeat searching for tags, when a file has not been found.
   for (;;) {
     int other_name;
     char_u *name;
@@ -598,10 +580,8 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         ptag_entry.cur_fnum = cur_fnum;
       }
 
-      /*
-       * Only when going to try the next match, report that the previous
-       * file didn't exist.  Otherwise an emsg() is given below.
-       */
+      // Only when going to try the next match, report that the previous
+      // file didn't exist.  Otherwise an emsg() is given below.
       if (nofile_fname != NULL && error_cur_match != cur_match) {
         smsg(_("File \"%s\" does not exist"), nofile_fname);
       }
@@ -640,9 +620,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
       vim_snprintf((char *)IObuff, IOSIZE, ":ta %s\r", name);
       set_vim_var_string(VV_SWAPCOMMAND, (char *)IObuff, -1);
 
-      /*
-       * Jump to the desired match.
-       */
+      // Jump to the desired match.
       i = jumpto_tag((char_u *)matches[cur_match], forceit, type != DT_CSCOPE);
 
       set_vim_var_string(VV_SWAPCOMMAND, NULL, -1);
@@ -1005,9 +983,7 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
   return OK;
 }
 
-/*
- * Free cached tags.
- */
+// Free cached tags.
 void tag_freematch(void)
 {
   XFREE_CLEAR(tagmatchname);
@@ -1023,9 +999,7 @@ static void taglen_advance(int l)
   }
 }
 
-/*
- * Print the tag stack
- */
+// Print the tag stack
 void do_tags(exarg_T *eap)
 {
   int i;
@@ -1061,11 +1035,9 @@ void do_tags(exarg_T *eap)
   }
 }
 
-/*
- * Compare two strings, for length "len", ignoring case the ASCII way.
- * return 0 for match, < 0 for smaller, > 0 for bigger
- * Make sure case is folded to uppercase in comparison (like for 'sort -f')
- */
+// Compare two strings, for length "len", ignoring case the ASCII way.
+// return 0 for match, < 0 for smaller, > 0 for bigger
+// Make sure case is folded to uppercase in comparison (like for 'sort -f')
 static int tag_strnicmp(char_u *s1, char_u *s2, size_t len)
 {
   int i;
@@ -1085,9 +1057,7 @@ static int tag_strnicmp(char_u *s1, char_u *s2, size_t len)
   return 0;                             // strings match
 }
 
-/*
- * Extract info from the tag search pattern "pats->pat".
- */
+// Extract info from the tag search pattern "pats->pat".
 static void prepare_pats(pat_T *pats, int has_re)
 {
   pats->head = pats->pat;
@@ -1472,9 +1442,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
   orgpat.regmatch.regprog = NULL;
   vimconv.vc_type = CONV_NONE;
 
-  /*
-   * Allocate memory for the buffers that are used
-   */
+  // Allocate memory for the buffers that are used
   lbuf = xmalloc((size_t)lbuf_size);
   tag_fname = xmalloc(MAXPATHL + 1);
   for (mtt = 0; mtt < MT_COUNT; mtt++) {
@@ -1484,9 +1452,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
 
   STRCPY(tag_fname, "from cscope");             // for error messages
 
-  /*
-   * Initialize a few variables
-   */
+  // Initialize a few variables
   if (help_only) {                              // want tags from help file
     curbuf->b_help = true;                      // will be restored later
   } else if (use_cscope) {
@@ -1534,16 +1500,15 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
     }
   }
 
-  /*
-   * When finding a specified number of matches, first try with matching
-   * case, so binary search can be used, and try ignore-case matches in a
-   * second loop.
-   * When finding all matches, 'tagbsearch' is off, or there is no fixed
-   * string to look for, ignore case right away to avoid going though the
-   * tags files twice.
-   * When the tag file is case-fold sorted, it is either one or the other.
-   * Only ignore case when TAG_NOIC not used or 'ignorecase' set.
-   */
+  // When finding a specified number of matches, first try with matching
+  // case, so binary search can be used, and try ignore-case matches in a
+  // second loop.
+  // When finding all matches, 'tagbsearch' is off, or there is no fixed
+  // string to look for, ignore case right away to avoid going though the
+  // tags files twice.
+  // When the tag file is case-fold sorted, it is either one or the other.
+  // Only ignore case when TAG_NOIC not used or 'ignorecase' set.
+
   // Set a flag if the file extension is .txt
   if ((flags & TAG_KEEP_LANG)
       && help_lang_find == NULL
@@ -1634,9 +1599,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
 
       state = TS_START;     // we're at the start of the file
 
-      /*
-       * Read and parse the lines in the file one by one
-       */
+      // Read and parse the lines in the file one by one
       for (;;) {
         // check for CTRL-C typed, more often when jumping around
         if (state == TS_BINARY || state == TS_SKIP_BACK) {
@@ -1661,9 +1624,7 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
         if (get_it_again) {
           goto line_read_in;
         }
-        /*
-         * For binary search: compute the next offset to use.
-         */
+        // For binary search: compute the next offset to use.
         if (state == TS_BINARY) {
           offset = search_info.low_offset + ((search_info.high_offset
                                               - search_info.low_offset) / 2);
@@ -1682,10 +1643,8 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
           }
         }
 
-        /*
-         * When jumping around in the file, first read a line to find the
-         * start of the next line.
-         */
+        // When jumping around in the file, first read a line to find the
+        // start of the next line.
         if (state == TS_BINARY || state == TS_SKIP_BACK) {
           // Adjust the search file offset to the correct position
           search_info.curr_offset_used = search_info.curr_offset;
@@ -1714,11 +1673,9 @@ int find_tags(char *pat, int *num_matches, char ***matchesp, int flags, int minc
             search_info.curr_offset = search_info.curr_offset_used;
             continue;
           }
-        }
-        /*
-         * Not jumping around in the file: Read the next line.
-         */
-        else {
+        } else {
+          // Not jumping around in the file: Read the next line.
+
           // skip empty and blank lines
           do {
             eof = use_cscope
@@ -1754,10 +1711,8 @@ line_read_in:
           }
         }
 
-        /*
-         * When still at the start of the file, check for Emacs tags file
-         * format, and for "not sorted" flag.
-         */
+        // When still at the start of the file, check for Emacs tags file
+        // format, and for "not sorted" flag.
         if (state == TS_START) {
           // The header ends when the line sorts below "!_TAG_".  When
           // case is folded lower case letters sort before "_".
@@ -1768,9 +1723,7 @@ line_read_in:
               goto parse_line;
             }
 
-            /*
-             * Read header line.
-             */
+            // Read header line.
             if (STRNCMP(lbuf, "!_TAG_FILE_SORTED\t", 18) == 0) {
               tag_file_sorted = lbuf[18];
             }
@@ -1788,15 +1741,13 @@ line_read_in:
 
           // Headers ends.
 
-          /*
-           * When there is no tag head, or ignoring case, need to do a
-           * linear search.
-           * When no "!_TAG_" is found, default to binary search.  If
-           * the tag file isn't sorted, the second loop will find it.
-           * When "!_TAG_FILE_SORTED" found: start binary search if
-           * flag set.
-           * For cscope, it's always linear.
-           */
+          // When there is no tag head, or ignoring case, need to do a
+          // linear search.
+          // When no "!_TAG_" is found, default to binary search.  If
+          // the tag file isn't sorted, the second loop will find it.
+          // When "!_TAG_FILE_SORTED" found: start binary search if
+          // flag set.
+          // For cscope, it's always linear.
           if (linear || use_cscope) {
             state = TS_LINEAR;
           } else if (tag_file_sorted == NUL) {
@@ -1871,10 +1822,8 @@ parse_line:
             break;
           }
 
-          /*
-           * Skip this line if the length of the tag is different and
-           * there is no regexp, or the tag is too short.
-           */
+          // Skip this line if the length of the tag is different and
+          // there is no regexp, or the tag is too short.
           cmplen = (int)(tagp.tagname_end - tagp.tagname);
           if (p_tl != 0 && cmplen > p_tl) {         // adjust for 'taglength'
             cmplen = (int)p_tl;
@@ -1886,9 +1835,7 @@ parse_line:
           }
 
           if (state == TS_BINARY) {
-            /*
-             * Simplistic check for unsorted tags file.
-             */
+            // Simplistic check for unsorted tags file.
             i = (int)tagp.tagname[0];
             if (sortic) {
               i = TOUPPER_ASC(tagp.tagname[0]);
@@ -1897,9 +1844,7 @@ parse_line:
               sort_error = true;
             }
 
-            /*
-             * Compare the current tag with the searched tag.
-             */
+            // Compare the current tag with the searched tag.
             if (sortic) {
               tagcmp = tag_strnicmp(tagp.tagname, orgpat.head,
                                     (size_t)cmplen);
@@ -1907,10 +1852,8 @@ parse_line:
               tagcmp = STRNCMP(tagp.tagname, orgpat.head, cmplen);
             }
 
-            /*
-             * A match with a shorter tag means to search forward.
-             * A match with a longer tag means to search backward.
-             */
+            // A match with a shorter tag means to search forward.
+            // A match with a longer tag means to search backward.
             if (tagcmp == 0) {
               if (cmplen < orgpat.headlen) {
                 tagcmp = -1;
@@ -1998,10 +1941,8 @@ parse_line:
           break;
         }
 
-        /*
-         * First try matching with the pattern literally (also when it is
-         * a regexp).
-         */
+        // First try matching with the pattern literally (also when it is
+        // a regexp).
         cmplen = (int)(tagp.tagname_end - tagp.tagname);
         if (p_tl != 0 && cmplen > p_tl) {           // adjust for 'taglength'
           cmplen = (int)p_tl;
@@ -2022,9 +1963,7 @@ parse_line:
           }
         }
 
-        /*
-         * Has a regexp: Also find tags matching regexp.
-         */
+        // Has a regexp: Also find tags matching regexp.
         match_re = false;
         if (!match && orgpat.regmatch.regprog != NULL) {
           int cc;
@@ -2211,9 +2150,7 @@ parse_line:
         sort_error = false;
       }
 
-      /*
-       * Stop searching if sufficient tags have been found.
-       */
+      // Stop searching if sufficient tags have been found.
       if (match_count >= mincount) {
         retval = OK;
         stop_searching = true;
@@ -2251,10 +2188,8 @@ findtag_end:
   vim_regfree(orgpat.regmatch.regprog);
   xfree(tag_fname);
 
-  /*
-   * Move the matches from the ga_match[] arrays into one list of
-   * matches.  When retval == FAIL, free the matches.
-   */
+  // Move the matches from the ga_match[] arrays into one list of
+  // matches.  When retval == FAIL, free the matches.
   if (retval == FAIL) {
     match_count = 0;
   }
@@ -2303,10 +2238,8 @@ findtag_end:
 
 static garray_T tag_fnames = GA_EMPTY_INIT_VALUE;
 
-/*
- * Callback function for finding all "tags" and "tags-??" files in
- * 'runtimepath' doc directories.
- */
+// Callback function for finding all "tags" and "tags-??" files in
+// 'runtimepath' doc directories.
 static void found_tagfile_cb(char *fname, void *cookie)
 {
   char_u *const tag_fname = vim_strsave((char_u *)fname);
@@ -2348,11 +2281,9 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
   }
 
   if (curbuf->b_help) {
-    /*
-     * For help files it's done in a completely different way:
-     * Find "doc/tags" and "doc/tags-??" in all directories in
-     * 'runtimepath'.
-     */
+    // For help files it's done in a completely different way:
+    // Find "doc/tags" and "doc/tags-??" in all directories in
+    // 'runtimepath'.
     if (first) {
       ga_clear_strings(&tag_fnames);
       ga_init(&tag_fnames, (int)sizeof(char *), 10);
@@ -2392,12 +2323,10 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
     tnp->tn_np = (char *)tnp->tn_tags;
   }
 
-  /*
-   * Loop until we have found a file name that can be used.
-   * There are two states:
-   * tnp->tn_did_filefind_init == false: setup for next part in 'tags'.
-   * tnp->tn_did_filefind_init == true: find next file in this part.
-   */
+  // Loop until we have found a file name that can be used.
+  // There are two states:
+  // tnp->tn_did_filefind_init == false: setup for next part in 'tags'.
+  // tnp->tn_did_filefind_init == true: find next file in this part.
   for (;;) {
     if (tnp->tn_did_filefind_init) {
       fname = (char *)vim_findfile(tnp->tn_search_ctx);
@@ -2416,9 +2345,7 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
         return FAIL;
       }
 
-      /*
-       * Copy next file name into buf.
-       */
+      // Copy next file name into buf.
       buf[0] = NUL;
       (void)copy_option_part(&tnp->tn_np, buf, MAXPATHL - 1, " ,");
 
@@ -2445,9 +2372,7 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
   return OK;
 }
 
-/*
- * Free the contents of a tagname_T that was filled by get_tagfname().
- */
+// Free the contents of a tagname_T that was filled by get_tagfname().
 void tagname_free(tagname_T *tnp)
 {
   xfree(tnp->tn_tags);
@@ -2499,20 +2424,18 @@ static int parse_tag_line(char_u *lbuf, tagptrs_T *tagp)
   return OK;
 }
 
-/*
- * Check if tagname is a static tag
- *
- * Static tags produced by the older ctags program have the format:
- *      'file:tag  file  /pattern'.
- * This is only recognized when both occurrence of 'file' are the same, to
- * avoid recognizing "string::string" or ":exit".
- *
- * Static tags produced by the new ctags program have the format:
- *      'tag  file  /pattern/;"<Tab>file:'          "
- *
- * Return true if it is a static tag and adjust *tagname to the real tag.
- * Return false if it is not a static tag.
- */
+// Check if tagname is a static tag
+//
+// Static tags produced by the older ctags program have the format:
+//      'file:tag  file  /pattern'.
+// This is only recognized when both occurrence of 'file' are the same, to
+// avoid recognizing "string::string" or ":exit".
+//
+// Static tags produced by the new ctags program have the format:
+//      'tag  file  /pattern/;"<Tab>file:'          "
+//
+// Return true if it is a static tag and adjust *tagname to the real tag.
+// Return false if it is not a static tag.
 static bool test_for_static(tagptrs_T *tagp)
 {
   char_u *p;
@@ -2620,11 +2543,9 @@ static int parse_match(char *lbuf, tagptrs_T *tagp)
   return retval;
 }
 
-/*
- * Find out the actual file name of a tag.  Concatenate the tags file name
- * with the matching tag file name.
- * Returns an allocated string.
- */
+// Find out the actual file name of a tag.  Concatenate the tags file name
+// with the matching tag file name.
+// Returns an allocated string.
 static char_u *tag_full_fname(tagptrs_T *tagp)
 {
   int c = *tagp->fname_end;
@@ -2688,9 +2609,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   *pbuf_end = NUL;
 
   {
-    /*
-     * Remove the "<Tab>fieldname:value" stuff; we don't need it here.
-     */
+    // Remove the "<Tab>fieldname:value" stuff; we don't need it here.
     str = pbuf;
     if (find_extra(&str) == OK) {
       pbuf_end = str;
@@ -2698,18 +2617,14 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
     }
   }
 
-  /*
-   * Expand file name, when needed (for environment variables).
-   * If 'tagrelative' option set, may change file name.
-   */
+  // Expand file name, when needed (for environment variables).
+  // If 'tagrelative' option set, may change file name.
   fname = expand_tag_fname(fname, tagp.tag_fname, true);
   tofree_fname = fname;         // free() it later
 
-  /*
-   * Check if the file with the tag exists before abandoning the current
-   * file.  Also accept a file name for which there is a matching BufReadCmd
-   * autocommand event (e.g., http://sys/file).
-   */
+  // Check if the file with the tag exists before abandoning the current
+  // file.  Also accept a file name for which there is a matching BufReadCmd
+  // autocommand event (e.g., http://sys/file).
   if (!os_path_exists((char *)fname)
       && !has_autocmd(EVENT_BUFREADCMD, (char *)fname,
                       NULL)) {
@@ -2725,19 +2640,15 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
     postponed_split = 0;        // don't split again below
     curwin_save = curwin;       // Save current window
 
-    /*
-     * If we are reusing a window, we may change dir when
-     * entering it (autocommands) so turn the tag filename
-     * into a fullpath
-     */
+    // If we are reusing a window, we may change dir when
+    // entering it (autocommands) so turn the tag filename
+    // into a fullpath
     if (!curwin->w_p_pvw) {
       full_fname = (char_u *)FullName_save((char *)fname, false);
       fname = full_fname;
 
-      /*
-       * Make the preview window the current window.
-       * Open a preview window when needed.
-       */
+      // Make the preview window the current window.
+      // Open a preview window when needed.
       prepare_tagpreview(true);
     }
   }
@@ -2803,25 +2714,21 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
     // Save value of no_hlsearch, jumping to a tag is not a real search
     const bool save_no_hlsearch = no_hlsearch;
 
-    /*
-     * If 'cpoptions' contains 't', store the search pattern for the "n"
-     * command.  If 'cpoptions' does not contain 't', the search pattern
-     * is not stored.
-     */
+    // If 'cpoptions' contains 't', store the search pattern for the "n"
+    // command.  If 'cpoptions' does not contain 't', the search pattern
+    // is not stored.
     if (vim_strchr(p_cpo, CPO_TAGPAT) != NULL) {
       search_options = 0;
     } else {
       search_options = SEARCH_KEEP;
     }
 
-    /*
-     * If the command is a search, try here.
-     *
-     * Reset 'smartcase' for the search, since the search pattern was not
-     * typed by the user.
-     * Only use do_search() when there is a full search command, without
-     * anything following.
-     */
+    // If the command is a search, try here.
+    //
+    // Reset 'smartcase' for the search, since the search pattern was not
+    // typed by the user.
+    // Only use do_search() when there is a full search command, without
+    // anything following.
     str = pbuf;
     if (pbuf[0] == '/' || pbuf[0] == '?') {
       str = (char_u *)skip_regexp((char *)pbuf + 1, pbuf[0], false, NULL) + 1;
@@ -2848,9 +2755,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
         int found = 1;
         int cc;
 
-        /*
-         * try again, ignore case now
-         */
+        // try again, ignore case now
         p_ic = true;
         if (!do_search(NULL, pbuf[0], pbuf[0], pbuf + 1, (long)1,
                        search_options, NULL)) {
@@ -2875,10 +2780,8 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
           emsg(_("E434: Can't find tag pattern"));
           curwin->w_cursor.lnum = save_lnum;
         } else {
-          /*
-           * Only give a message when really guessed, not when 'ic'
-           * is set and match found while ignoring case.
-           */
+          // Only give a message when really guessed, not when 'ic'
+          // is set and match found while ignoring case.
           if (found == 2 || !save_p_ic) {
             msg(_("E435: Couldn't find tag, just guessing!"));
             if (!msg_scrolled && msg_silent == 0) {
@@ -2927,10 +2830,8 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
     }
 
     if (retval == OK) {
-      /*
-       * For a help buffer: Put the cursor line at the top of the window,
-       * the help subject will be below it.
-       */
+      // For a help buffer: Put the cursor line at the top of the window,
+      // the help subject will be below it.
       if (curbuf->b_help) {
         set_topline(curwin, curwin->w_cursor.lnum);
       }
@@ -2976,9 +2877,7 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
   char_u *expanded_fname = NULL;
   expand_T xpc;
 
-  /*
-   * Expand file name (for environment variables) when needed.
-   */
+  // Expand file name (for environment variables) when needed.
   if (expand && path_has_wildcard((char *)fname)) {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_FILES;
@@ -2997,9 +2896,7 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
     STRCPY(retval, tag_fname);
     STRLCPY(retval + (p - tag_fname), fname,
             MAXPATHL - (p - tag_fname));
-    /*
-     * Translate names like "src/a/../b/file.c" into "src/b/file.c".
-     */
+    // Translate names like "src/a/../b/file.c" into "src/b/file.c".
     simplify_filename(retval);
   } else {
     retval = vim_strsave(fname);
@@ -3034,10 +2931,8 @@ static int test_for_current(char *fname, char *fname_end, char *tag_fname, char
   return retval;
 }
 
-/*
- * Find the end of the tagaddress.
- * Return OK if ";\"" is following, FAIL otherwise.
- */
+// Find the end of the tagaddress.
+// Return OK if ";\"" is following, FAIL otherwise.
 static int find_extra(char_u **pp)
 {
   char_u *str = *pp;
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 6ee3820d95..530cbc0c7b 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -970,21 +970,19 @@ static int check_split_disallowed(void)
   return OK;
 }
 
-/*
- * split the current window, implements CTRL-W s and :split
- *
- * "size" is the height or width for the new window, 0 to use half of current
- * height or width.
- *
- * "flags":
- * WSP_ROOM: require enough room for new window
- * WSP_VERT: vertical split.
- * WSP_TOP:  open window at the top-left of the screen (help window).
- * WSP_BOT:  open window at the bottom-right of the screen (quickfix window).
- * WSP_HELP: creating the help window, keep layout snapshot
- *
- * return FAIL for failure, OK otherwise
- */
+// split the current window, implements CTRL-W s and :split
+//
+// "size" is the height or width for the new window, 0 to use half of current
+// height or width.
+//
+// "flags":
+// WSP_ROOM: require enough room for new window
+// WSP_VERT: vertical split.
+// WSP_TOP:  open window at the top-left of the screen (help window).
+// WSP_BOT:  open window at the bottom-right of the screen (quickfix window).
+// WSP_HELP: creating the help window, keep layout snapshot
+//
+// return FAIL for failure, OK otherwise
 int win_split(int size, int flags)
 {
   if (check_split_disallowed() == FAIL) {
@@ -1014,12 +1012,10 @@ int win_split(int size, int flags)
   return win_split_ins(size, flags, NULL, 0);
 }
 
-/*
- * When "new_wp" is NULL: split the current window in two.
- * When "new_wp" is not NULL: insert this window at the far
- * top/left/right/bottom.
- * return FAIL for failure, OK otherwise
- */
+// When "new_wp" is NULL: split the current window in two.
+// When "new_wp" is not NULL: insert this window at the far
+// top/left/right/bottom.
+// return FAIL for failure, OK otherwise
 int win_split_ins(int size, int flags, win_T *new_wp, int dir)
 {
   win_T *wp = new_wp;
@@ -1069,10 +1065,8 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
 
     layout = FR_ROW;
 
-    /*
-     * Check if we are able to split the current window and compute its
-     * width.
-     */
+    // Check if we are able to split the current window and compute its
+    // width.
     // Current window requires at least 1 space.
     wmw1 = (p_wmw == 0 ? 1 : (int)p_wmw);
     needed = wmw1 + 1;
@@ -1243,9 +1237,7 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
     }
   }
 
-  /*
-   * allocate new window structure and link it in the window list
-   */
+  // allocate new window structure and link it in the window list
   if ((flags & WSP_TOP) == 0
       && ((flags & WSP_BOT)
           || (flags & WSP_BELOW)
@@ -1282,9 +1274,7 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
     CLEAR_FIELD(wp->w_border_adj);
   }
 
-  /*
-   * Reorganise the tree of frames to insert the new window.
-   */
+  // Reorganise the tree of frames to insert the new window.
   if (flags & (WSP_TOP | WSP_BOT)) {
     if ((topframe->fr_layout == FR_COL && (flags & WSP_VERT) == 0)
         || (topframe->fr_layout == FR_ROW && (flags & WSP_VERT) != 0)) {
@@ -1489,9 +1479,7 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
     msg_col = 0;        // put position back at start of line
   }
 
-  /*
-   * equalize the window sizes.
-   */
+  // equalize the window sizes.
   if (do_equal || dir != 0) {
     win_equal(wp, true, (flags & WSP_VERT) ? (dir == 'v' ? 'b' : 'h') : (dir == 'h' ? 'b' : 'v'));
   }
@@ -1527,13 +1515,11 @@ int win_split_ins(int size, int flags, win_T *new_wp, int dir)
   return OK;
 }
 
-/*
- * Initialize window "newp" from window "oldp".
- * Used when splitting a window and when creating a new tab page.
- * The windows will both edit the same buffer.
- * WSP_NEWLOC may be specified in flags to prevent the location list from
- * being copied.
- */
+// Initialize window "newp" from window "oldp".
+// Used when splitting a window and when creating a new tab page.
+// The windows will both edit the same buffer.
+// WSP_NEWLOC may be specified in flags to prevent the location list from
+// being copied.
 static void win_init(win_T *newp, win_T *oldp, int flags)
 {
   int i;
@@ -1591,10 +1577,8 @@ static void win_init(win_T *newp, win_T *oldp, int flags)
   newp->w_winbar_height = oldp->w_winbar_height;
 }
 
-/*
- * Initialize window "newp" from window "old".
- * Only the essential things are copied.
- */
+// Initialize window "newp" from window "old".
+// Only the essential things are copied.
 static void win_init_some(win_T *newp, win_T *oldp)
 {
   // Use the same argument list.
@@ -1671,9 +1655,7 @@ bool win_valid_any_tab(win_T *win) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
   return false;
 }
 
-/*
- * Return the number of windows.
- */
+// Return the number of windows.
 int win_count(void)
 {
   int count = 0;
@@ -1746,9 +1728,7 @@ int make_windows(int count, bool vertical)
   return count - todo;
 }
 
-/*
- * Exchange current and next window
- */
+// Exchange current and next window
 static void win_exchange(long Prenum)
 {
   frame_T *frp;
@@ -1768,9 +1748,7 @@ static void win_exchange(long Prenum)
     return;
   }
 
-  /*
-   * find window to exchange with
-   */
+  // find window to exchange with
   if (Prenum) {
     frp = curwin->w_frame->fr_parent->fr_child;
     while (frp != NULL && --Prenum > 0) {
@@ -1789,14 +1767,12 @@ static void win_exchange(long Prenum)
   }
   wp = frp->fr_win;
 
-  /*
-   * 1. remove curwin from the list. Remember after which window it was in wp2
-   * 2. insert curwin before wp in the list
-   * if wp != wp2
-   *    3. remove wp from the list
-   *    4. insert wp after wp2
-   * 5. exchange the status line height, winbar height, hsep height and vsep width.
-   */
+  // 1. remove curwin from the list. Remember after which window it was in wp2
+  // 2. insert curwin before wp in the list
+  // if wp != wp2
+  //    3. remove wp from the list
+  //    4. insert wp after wp2
+  // 5. exchange the status line height, winbar height, hsep height and vsep width.
   wp2 = curwin->w_prev;
   frp2 = curwin->w_frame->fr_prev;
   if (wp->w_prev != curwin) {
@@ -1927,9 +1903,7 @@ static void win_rotate(bool upwards, int count)
   redraw_all_later(UPD_NOT_VALID);
 }
 
-/*
- * Move the current window to the very top/bottom/left/right of the screen.
- */
+// Move the current window to the very top/bottom/left/right of the screen.
 static void win_totop(int size, int flags)
 {
   int dir = 0;
@@ -1973,10 +1947,8 @@ static void win_totop(int size, int flags)
   }
 }
 
-/*
- * Move window "win1" to below/right of "win2" and make "win1" the current
- * window.  Only works within the same frame!
- */
+// Move window "win1" to below/right of "win2" and make "win1" the current
+// window.  Only works within the same frame!
 void win_move_after(win_T *win1, win_T *win2)
 {
   int height;
@@ -2146,11 +2118,9 @@ static void win_equal_rec(win_T *next_curwin, bool current, frame_T *topfr, int
       totwincount = (n + extra_sep) / ((int)p_wmw + 1);
       has_next_curwin = frame_has_win(topfr, next_curwin);
 
-      /*
-       * Compute width for "next_curwin" window and room available for
-       * other windows.
-       * "m" is the minimal width when counting p_wiw for "next_curwin".
-       */
+      // Compute width for "next_curwin" window and room available for
+      // other windows.
+      // "m" is the minimal width when counting p_wiw for "next_curwin".
       m = frame_minwidth(topfr, next_curwin);
       room = width - m;
       if (room < 0) {
@@ -2274,11 +2244,9 @@ static void win_equal_rec(win_T *next_curwin, bool current, frame_T *topfr, int
       totwincount = get_maximum_wincount(topfr, n + extra_sep);
       has_next_curwin = frame_has_win(topfr, next_curwin);
 
-      /*
-       * Compute height for "next_curwin" window and room available for
-       * other windows.
-       * "m" is the minimal height when counting p_wh for "next_curwin".
-       */
+      // Compute height for "next_curwin" window and room available for
+      // other windows.
+      // "m" is the minimal height when counting p_wh for "next_curwin".
       m = frame_minheight(topfr, next_curwin);
       room = height - m;
       if (room < 0) {
@@ -2594,14 +2562,12 @@ static bool close_last_window_tabpage(win_T *win, bool free_buf, tabpage_T *prev
     free_buf = false;
   }
 
-  /*
-   * Closing the last window in a tab page.  First go to another tab
-   * page and then close the window and the tab page.  This avoids that
-   * curwin and curtab are invalid while we are freeing memory, they may
-   * be used in GUI events.
-   * Don't trigger autocommands yet, they may use wrong values, so do
-   * that below.
-   */
+  // Closing the last window in a tab page.  First go to another tab
+  // page and then close the window and the tab page.  This avoids that
+  // curwin and curtab are invalid while we are freeing memory, they may
+  // be used in GUI events.
+  // Don't trigger autocommands yet, they may use wrong values, so do
+  // that below.
   goto_tabpage_tp(alt_tabpage(), false, true);
   redraw_tabline = true;
 
@@ -2745,10 +2711,8 @@ int win_close(win_T *win, bool free_buf, bool force)
       }
     }
 
-    /*
-     * Be careful: If autocommands delete the window or cause this window
-     * to be the last one left, return now.
-     */
+    // Be careful: If autocommands delete the window or cause this window
+    // to be the last one left, return now.
     if (wp->w_buffer != curbuf) {
       reset_VIsual_and_resel();  // stop Visual mode
 
@@ -2860,10 +2824,8 @@ int win_close(win_T *win, bool free_buf, bool force)
   if (win == curwin) {
     curwin = wp;
     if (wp->w_p_pvw || bt_quickfix(wp->w_buffer)) {
-      /*
-       * If the cursor goes to the preview or the quickfix window, try
-       * finding another window to go to.
-       */
+      // If the cursor goes to the preview or the quickfix window, try
+      // finding another window to go to.
       for (;;) {
         if (wp->w_next == NULL) {
           wp = firstwin;
@@ -2908,10 +2870,8 @@ int win_close(win_T *win, bool free_buf, bool force)
 
   split_disallowed--;
 
-  /*
-   * If last window has a status line now and we don't want one,
-   * remove the status line.
-   */
+  // If last window has a status line now and we don't want one,
+  // remove the status line.
   last_status(false);
 
   // After closing the help window, try restoring the window layout from
@@ -2955,13 +2915,11 @@ static void do_autocmd_winclosed(win_T *win)
   recursive = false;
 }
 
-/*
- * Close window "win" in tab page "tp", which is not the current tab page.
- * This may be the last window in that tab page and result in closing the tab,
- * thus "tp" may become invalid!
- * Caller must check if buffer is hidden and whether the tabline needs to be
- * updated.
- */
+// Close window "win" in tab page "tp", which is not the current tab page.
+// This may be the last window in that tab page and result in closing the tab,
+// thus "tp" may become invalid!
+// Caller must check if buffer is hidden and whether the tabline needs to be
+// updated.
 void win_close_othertab(win_T *win, int free_buf, tabpage_T *tp)
 {
   int dir;
@@ -3138,16 +3096,12 @@ win_T *winframe_remove(win_T *win, int *dirp, tabpage_T *tp)
   frame_T *frp_close = win->w_frame;
   win_T *wp;
 
-  /*
-   * If there is only one window there is nothing to remove.
-   */
+  // If there is only one window there is nothing to remove.
   if (tp == NULL ? ONE_WINDOW : tp->tp_firstwin == tp->tp_lastwin) {
     return NULL;
   }
 
-  /*
-   * Remove the window from its frame.
-   */
+  // Remove the window from its frame.
   frp2 = win_altframe(win, tp);
   wp = frame2win(frp2);
 
@@ -3334,9 +3288,7 @@ static frame_T *win_altframe(win_T *win, tabpage_T *tp)
   return target_fr;
 }
 
-/*
- * Return the tabpage that will be used if the current one is closed.
- */
+// Return the tabpage that will be used if the current one is closed.
 static tabpage_T *alt_tabpage(void)
 {
   tabpage_T *tp;
@@ -3351,9 +3303,7 @@ static tabpage_T *alt_tabpage(void)
   return tp;
 }
 
-/*
- * Find the left-upper window in frame "frp".
- */
+// Find the left-upper window in frame "frp".
 win_T *frame2win(frame_T *frp)
 {
   while (frp->fr_win == NULL) {
@@ -3557,10 +3507,8 @@ static bool frame_fixed_width(frame_T *frp)
   return true;
 }
 
-/*
- * Add a status line to windows at the bottom of "frp".
- * Note: Does not check if there is room!
- */
+// Add a status line to windows at the bottom of "frp".
+// Note: Does not check if there is room!
 static void frame_add_statusline(frame_T *frp)
 {
   win_T *wp;
@@ -3748,17 +3696,13 @@ static void frame_add_hsep(const frame_T *frp)
   }
 }
 
-/*
- * Set frame width from the window it contains.
- */
+// Set frame width from the window it contains.
 static void frame_fix_width(win_T *wp)
 {
   wp->w_frame->fr_width = wp->w_width + wp->w_vsep_width;
 }
 
-/*
- * Set frame height from the window it contains.
- */
+// Set frame height from the window it contains.
 static void frame_fix_height(win_T *wp)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -3913,12 +3857,10 @@ void close_others(int message, int forceit)
   }
 }
 
-/*
- * Allocate the first window and put an empty buffer in it.
- * Called from main().
- *
- * Return FAIL when something goes wrong.
- */
+// Allocate the first window and put an empty buffer in it.
+// Called from main().
+//
+// Return FAIL when something goes wrong.
 int win_alloc_first(void)
 {
   if (win_alloc_firstwin(NULL) == FAIL) {
@@ -3949,12 +3891,10 @@ void win_alloc_aucmd_win(void)
   RESET_BINDING(aucmd_win);
 }
 
-/*
- * Allocate the first window or the first window in a new tab page.
- * When "oldwin" is NULL create an empty buffer for it.
- * When "oldwin" is not NULL copy info from it to the new window.
- * Return FAIL when something goes wrong (out of memory).
- */
+// Allocate the first window or the first window in a new tab page.
+// When "oldwin" is NULL create an empty buffer for it.
+// When "oldwin" is not NULL copy info from it to the new window.
+// Return FAIL when something goes wrong (out of memory).
 static int win_alloc_firstwin(win_T *oldwin)
 {
   curwin = win_alloc(NULL, false);
@@ -3986,9 +3926,7 @@ static int win_alloc_firstwin(win_T *oldwin)
   return OK;
 }
 
-/*
- * Create a frame for window "wp".
- */
+// Create a frame for window "wp".
 static void new_frame(win_T *wp)
 {
   frame_T *frp = xcalloc(1, sizeof(frame_T));
@@ -3998,9 +3936,7 @@ static void new_frame(win_T *wp)
   frp->fr_win = wp;
 }
 
-/*
- * Initialize the window and frame size to the maximum.
- */
+// Initialize the window and frame size to the maximum.
 void win_init_size(void)
 {
   firstwin->w_height = (int)ROWS_AVAIL;
@@ -4014,9 +3950,7 @@ void win_init_size(void)
   topframe->fr_width = Columns;
 }
 
-/*
- * Allocate a new tabpage_T and init the values.
- */
+// Allocate a new tabpage_T and init the values.
 static tabpage_T *alloc_tabpage(void)
 {
   static int last_tp_handle = 0;
@@ -4138,11 +4072,9 @@ int win_new_tabpage(int after, char_u *filename)
   return FAIL;
 }
 
-/*
- * Open a new tab page if ":tab cmd" was used.  It will edit the same buffer,
- * like with ":split".
- * Returns OK if a new tab page was created, FAIL otherwise.
- */
+// Open a new tab page if ":tab cmd" was used.  It will edit the same buffer,
+// like with ":split".
+// Returns OK if a new tab page was created, FAIL otherwise.
 int may_open_tabpage(void)
 {
   int n = (cmdmod.cmod_tab == 0) ? postponed_split_tab : cmdmod.cmod_tab;
@@ -4155,10 +4087,8 @@ int may_open_tabpage(void)
   return FAIL;
 }
 
-/*
- * Create up to "maxcount" tabpages with empty windows.
- * Returns the number of resulting tab pages.
- */
+// Create up to "maxcount" tabpages with empty windows.
+// Returns the number of resulting tab pages.
 int make_tabpages(int maxcount)
 {
   int count = maxcount;
@@ -4169,10 +4099,8 @@ int make_tabpages(int maxcount)
     count = (int)p_tpm;
   }
 
-  /*
-   * Don't execute autocommands while creating the tab pages.  Must do that
-   * when putting the buffers in the windows.
-   */
+  // Don't execute autocommands while creating the tab pages.  Must do that
+  // when putting the buffers in the windows.
   block_autocmds();
 
   for (todo = count - 1; todo > 0; todo--) {
@@ -4239,9 +4167,7 @@ void close_tabpage(tabpage_T *tab)
   free_tabpage(tab);
 }
 
-/*
- * Find tab page "n" (first one is 1).  Returns NULL when not found.
- */
+// Find tab page "n" (first one is 1).  Returns NULL when not found.
 tabpage_T *find_tabpage(int n)
 {
   tabpage_T *tp;
@@ -4253,10 +4179,8 @@ tabpage_T *find_tabpage(int n)
   return tp;
 }
 
-/*
- * Get index of tab page "tp".  First one has index 1.
- * When not found returns number of tab pages plus one.
- */
+// Get index of tab page "tp".  First one has index 1.
+// When not found returns number of tab pages plus one.
 int tabpage_index(tabpage_T *ftp)
 {
   int i = 1;
@@ -4412,10 +4336,8 @@ static void tabpage_check_windows(tabpage_T *old_curtab)
   }
 }
 
-/*
- * Go to tab page "n".  For ":tab N" and "Ngt".
- * When "n" is 9999 go to the last tab page.
- */
+// Go to tab page "n".  For ":tab N" and "Ngt".
+// When "n" is 9999 go to the last tab page.
 void goto_tabpage(int n)
 {
   tabpage_T *tp = NULL;  // shut up compiler
@@ -4504,10 +4426,8 @@ bool goto_tabpage_lastused(void)
   return false;
 }
 
-/*
- * Enter window "wp" in tab page "tp".
- * Also updates the GUI tab.
- */
+// Enter window "wp" in tab page "tp".
+// Also updates the GUI tab.
 void goto_tabpage_win(tabpage_T *tp, win_T *wp)
 {
   goto_tabpage_tp(tp, true, true);
@@ -4570,13 +4490,11 @@ void tabpage_move(int nr)
   redraw_tabline = true;
 }
 
-/*
- * Go to another window.
- * When jumping to another buffer, stop Visual mode.  Do this before
- * changing windows so we can yank the selection into the '*' register.
- * When jumping to another window on the same buffer, adjust its cursor
- * position to keep the same Visual area.
- */
+// Go to another window.
+// When jumping to another buffer, stop Visual mode.  Do this before
+// changing windows so we can yank the selection into the '*' register.
+// When jumping to another window on the same buffer, adjust its cursor
+// position to keep the same Visual area.
 void win_goto(win_T *wp)
 {
   win_T *owp = curwin;
@@ -4603,9 +4521,7 @@ void win_goto(win_T *wp)
   }
 }
 
-/*
- * Find the tabpage for window "win".
- */
+// Find the tabpage for window "win".
 tabpage_T *win_find_tabpage(win_T *win)
 {
   FOR_ALL_TAB_WINDOWS(tp, wp) {
@@ -4638,10 +4554,8 @@ win_T *win_vert_neighbor(tabpage_T *tp, win_T *wp, bool up, long count)
   }
 
   while (count--) {
-    /*
-     * First go upwards in the tree of frames until we find an upwards or
-     * downwards neighbor.
-     */
+    // First go upwards in the tree of frames until we find an upwards or
+    // downwards neighbor.
     fr = foundfr;
     for (;;) {
       if (fr == tp->tp_topframe) {
@@ -4658,9 +4572,7 @@ win_T *win_vert_neighbor(tabpage_T *tp, win_T *wp, bool up, long count)
       fr = fr->fr_parent;
     }
 
-    /*
-     * Now go downwards to find the bottom or top frame in it.
-     */
+    // Now go downwards to find the bottom or top frame in it.
     for (;;) {
       if (nfr->fr_layout == FR_LEAF) {
         foundfr = nfr;
@@ -4721,10 +4633,8 @@ win_T *win_horz_neighbor(tabpage_T *tp, win_T *wp, bool left, long count)
   }
 
   while (count--) {
-    /*
-     * First go upwards in the tree of frames until we find a left or
-     * right neighbor.
-     */
+    // First go upwards in the tree of frames until we find a left or
+    // right neighbor.
     fr = foundfr;
     for (;;) {
       if (fr == tp->tp_topframe) {
@@ -4741,9 +4651,7 @@ win_T *win_horz_neighbor(tabpage_T *tp, win_T *wp, bool left, long count)
       fr = fr->fr_parent;
     }
 
-    /*
-     * Now go downwards to find the leftmost or rightmost frame in it.
-     */
+    // Now go downwards to find the leftmost or rightmost frame in it.
     for (;;) {
       if (nfr->fr_layout == FR_LEAF) {
         foundfr = nfr;
@@ -5036,9 +4944,7 @@ static win_T *win_alloc(win_T *after, bool hidden)
   // initialized yet.  gui_create_scrollbar() may trigger a FocusGained
   // event.
   block_autocmds();
-  /*
-   * link the window in the window list
-   */
+  // link the window in the window list
   if (!hidden) {
     win_append(after, new_wp);
   }
@@ -5202,9 +5108,7 @@ void win_free_grid(win_T *wp, bool reinit)
   }
 }
 
-/*
- * Append window "wp" in the window list after window "after".
- */
+// Append window "wp" in the window list after window "after".
 void win_append(win_T *after, win_T *wp)
 {
   win_T *before;
@@ -5250,9 +5154,7 @@ void win_remove(win_T *wp, tabpage_T *tp)
   }
 }
 
-/*
- * Append frame "frp" in a frame list after frame "after".
- */
+// Append frame "frp" in a frame list after frame "after".
 static void frame_append(frame_T *after, frame_T *frp)
 {
   frp->fr_next = after->fr_next;
@@ -5263,9 +5165,7 @@ static void frame_append(frame_T *after, frame_T *frp)
   frp->fr_prev = after;
 }
 
-/*
- * Insert frame "frp" in a frame list before frame "before".
- */
+// Insert frame "frp" in a frame list before frame "before".
 static void frame_insert(frame_T *before, frame_T *frp)
 {
   frp->fr_next = before;
@@ -5278,9 +5178,7 @@ static void frame_insert(frame_T *before, frame_T *frp)
   }
 }
 
-/*
- * Remove a frame from a frame list.
- */
+// Remove a frame from a frame list.
 static void frame_remove(frame_T *frp)
 {
   if (frp->fr_prev != NULL) {
@@ -5390,9 +5288,7 @@ void may_trigger_winscrolled(void)
   }
 }
 
-/*
- * Save the size of all windows in "gap".
- */
+// Save the size of all windows in "gap".
 void win_size_save(garray_T *gap)
 {
   ga_init(gap, (int)sizeof(int), 1);
@@ -5459,12 +5355,10 @@ void win_reconfig_floats(void)
   }
 }
 
-/*
- * Update the position of the windows in frame "topfrp", using the width and
- * height of the frames.
- * "*row" and "*col" are the top-left position of the frame.  They are updated
- * to the bottom-right position plus one.
- */
+// Update the position of the windows in frame "topfrp", using the width and
+// height of the frames.
+// "*row" and "*col" are the top-left position of the frame.  They are updated
+// to the bottom-right position plus one.
 static void frame_comp_pos(frame_T *topfrp, int *row, int *col)
 {
   win_T *wp;
@@ -5500,19 +5394,15 @@ static void frame_comp_pos(frame_T *topfrp, int *row, int *col)
   }
 }
 
-/*
- * Set current window height and take care of repositioning other windows to
- * fit around it.
- */
+// Set current window height and take care of repositioning other windows to
+// fit around it.
 void win_setheight(int height)
 {
   win_setheight_win(height, curwin);
 }
 
-/*
- * Set the window height of window "win" and take care of repositioning other
- * windows to fit around it.
- */
+// Set the window height of window "win" and take care of repositioning other
+// windows to fit around it.
 void win_setheight_win(int height, win_T *win)
 {
   // Always keep current window at least one line high, even when 'winminheight' is zero.
@@ -5547,19 +5437,17 @@ void win_setheight_win(int height, win_T *win)
   }
 }
 
-/*
- * Set the height of a frame to "height" and take care that all frames and
- * windows inside it are resized.  Also resize frames on the left and right if
- * the are in the same FR_ROW frame.
- *
- * Strategy:
- * If the frame is part of a FR_COL frame, try fitting the frame in that
- * frame.  If that doesn't work (the FR_COL frame is too small), recursively
- * go to containing frames to resize them and make room.
- * If the frame is part of a FR_ROW frame, all frames must be resized as well.
- * Check for the minimal height of the FR_ROW frame.
- * At the top level we can also use change the command line height.
- */
+// Set the height of a frame to "height" and take care that all frames and
+// windows inside it are resized.  Also resize frames on the left and right if
+// the are in the same FR_ROW frame.
+//
+// Strategy:
+// If the frame is part of a FR_COL frame, try fitting the frame in that
+// frame.  If that doesn't work (the FR_COL frame is too small), recursively
+// go to containing frames to resize them and make room.
+// If the frame is part of a FR_ROW frame, all frames must be resized as well.
+// Check for the minimal height of the FR_ROW frame.
+// At the top level we can also use change the command line height.
 static void frame_setheight(frame_T *curfrp, int height)
 {
   int room;                     // total number of lines available
@@ -5595,16 +5483,13 @@ static void frame_setheight(frame_T *curfrp, int height)
     }
     frame_setheight(curfrp->fr_parent, height);
   } else {
-    /*
-     * Column of frames: try to change only frames in this column.
-     */
-    /*
-     * Do this twice:
-     * 1: compute room available, if it's not enough try resizing the
-     *    containing frame.
-     * 2: compute the room available and adjust the height to it.
-     * Try not to reduce the height of a window with 'winfixheight' set.
-     */
+    // Column of frames: try to change only frames in this column.
+
+    // Do this twice:
+    // 1: compute room available, if it's not enough try resizing the
+    //    containing frame.
+    // 2: compute the room available and adjust the height to it.
+    // Try not to reduce the height of a window with 'winfixheight' set.
     for (run = 1; run <= 2; run++) {
       room = 0;
       room_reserved = 0;
@@ -5642,10 +5527,8 @@ static void frame_setheight(frame_T *curfrp, int height)
       //NOTREACHED
     }
 
-    /*
-     * Compute the number of lines we will take from others frames (can be
-     * negative!).
-     */
+    // Compute the number of lines we will take from others frames (can be
+    // negative!).
     take = height - curfrp->fr_height;
 
     // If there is not enough room, also reduce the height of a window
@@ -5668,16 +5551,12 @@ static void frame_setheight(frame_T *curfrp, int height)
       topframe->fr_height += room_cmdline;
     }
 
-    /*
-     * set the current frame to the new height
-     */
+    // set the current frame to the new height
     frame_new_height(curfrp, height, false, false);
 
-    /*
-     * First take lines from the frames after the current frame.  If
-     * that is not enough, takes lines from frames above the current
-     * frame.
-     */
+    // First take lines from the frames after the current frame.  If
+    // that is not enough, takes lines from frames above the current
+    // frame.
     for (run = 0; run < 2; run++) {
       if (run == 0) {
         frp = curfrp->fr_next;          // 1st run: start with next window
@@ -5718,10 +5597,8 @@ static void frame_setheight(frame_T *curfrp, int height)
   }
 }
 
-/*
- * Set current window width and take care of repositioning other windows to
- * fit around it.
- */
+// Set current window width and take care of repositioning other windows to
+// fit around it.
 void win_setwidth(int width)
 {
   win_setwidth_win(width, curwin);
@@ -5754,13 +5631,11 @@ void win_setwidth_win(int width, win_T *wp)
   }
 }
 
-/*
- * Set the width of a frame to "width" and take care that all frames and
- * windows inside it are resized.  Also resize frames above and below if the
- * are in the same FR_ROW frame.
- *
- * Strategy is similar to frame_setheight().
- */
+// Set the width of a frame to "width" and take care that all frames and
+// windows inside it are resized.  Also resize frames above and below if the
+// are in the same FR_ROW frame.
+//
+// Strategy is similar to frame_setheight().
 static void frame_setwidth(frame_T *curfrp, int width)
 {
   int room;                     // total number of lines available
@@ -5789,14 +5664,12 @@ static void frame_setwidth(frame_T *curfrp, int width)
     }
     frame_setwidth(curfrp->fr_parent, width);
   } else {
-    /*
-     * Row of frames: try to change only frames in this row.
-     *
-     * Do this twice:
-     * 1: compute room available, if it's not enough try resizing the
-     *    containing frame.
-     * 2: compute the room available and adjust the width to it.
-     */
+    // Row of frames: try to change only frames in this row.
+    //
+    // Do this twice:
+    // 1: compute room available, if it's not enough try resizing the
+    //    containing frame.
+    // 2: compute the room available and adjust the width to it.
     for (run = 1; run <= 2; run++) {
       room = 0;
       room_reserved = 0;
@@ -5823,10 +5696,8 @@ static void frame_setwidth(frame_T *curfrp, int width)
                      + frame_minwidth(curfrp->fr_parent, NOWIN) - (int)p_wmw - 1);
     }
 
-    /*
-     * Compute the number of lines we will take from others frames (can be
-     * negative!).
-     */
+    // Compute the number of lines we will take from others frames (can be
+    // negative!).
     take = width - curfrp->fr_width;
 
     // If there is not enough room, also reduce the width of a window
@@ -5840,16 +5711,12 @@ static void frame_setwidth(frame_T *curfrp, int width)
       room_reserved = 0;
     }
 
-    /*
-     * set the current frame to the new width
-     */
+    // set the current frame to the new width
     frame_new_width(curfrp, width, false, false);
 
-    /*
-     * First take lines from the frames right of the current frame.  If
-     * that is not enough, takes lines from frames left of the current
-     * frame.
-     */
+    // First take lines from the frames right of the current frame.  If
+    // that is not enough, takes lines from frames left of the current
+    // frame.
     for (run = 0; run < 2; run++) {
       if (run == 0) {
         frp = curfrp->fr_next;          // 1st run: start with next window
@@ -6016,10 +5883,8 @@ void win_drag_status_line(win_T *dragwin, int offset)
     return;
   }
 
-  /*
-   * Grow frame fr by "offset" lines.
-   * Doesn't happen when dragging the last status line up.
-   */
+  // Grow frame fr by "offset" lines.
+  // Doesn't happen when dragging the last status line up.
   if (fr != NULL) {
     frame_new_height(fr, fr->fr_height + offset, up, false);
   }
@@ -6029,9 +5894,7 @@ void win_drag_status_line(win_T *dragwin, int offset)
   } else {
     fr = curfr->fr_next;        // next frame gets smaller
   }
-  /*
-   * Now make the other frames smaller.
-   */
+  // Now make the other frames smaller.
   while (fr != NULL && offset > 0) {
     n = frame_minheight(fr, NULL);
     if (fr->fr_height - offset <= n) {
@@ -6059,9 +5922,7 @@ void win_drag_status_line(win_T *dragwin, int offset)
   showmode();
 }
 
-/*
- * Separator line of dragwin is dragged "offset" lines right (negative is left).
- */
+// Separator line of dragwin is dragged "offset" lines right (negative is left).
 void win_drag_vsep_line(win_T *dragwin, int offset)
 {
   frame_T *curfr;
@@ -6214,10 +6075,8 @@ void scroll_to_fraction(win_T *wp, int prev_height)
       && (!wp->w_p_scb || wp == curwin)
       && (height < wp->w_buffer->b_ml.ml_line_count
           || wp->w_topline > 1)) {
-    /*
-     * Find a value for w_topline that shows the cursor at the same
-     * relative position in the window as before (more or less).
-     */
+    // Find a value for w_topline that shows the cursor at the same
+    // relative position in the window as before (more or less).
     lnum = wp->w_cursor.lnum;
     if (lnum < 1) {             // can happen when starting up
       lnum = 1;
@@ -6237,11 +6096,9 @@ void scroll_to_fraction(win_T *wp, int prev_height)
     }
 
     if (sline < 0) {
-      /*
-       * Cursor line would go off top of screen if w_wrow was this high.
-       * Make cursor line the first line in the window.  If not enough
-       * room use w_skipcol;
-       */
+      // Cursor line would go off top of screen if w_wrow was this high.
+      // Make cursor line the first line in the window.  If not enough
+      // room use w_skipcol;
       wp->w_wrow = line_size;
       if (wp->w_wrow >= wp->w_height_inner
           && (wp->w_width_inner - win_col_off(wp)) > 0) {
@@ -6273,10 +6130,8 @@ void scroll_to_fraction(win_T *wp, int prev_height)
       }
 
       if (sline < 0) {
-        /*
-         * Line we want at top would go off top of screen.  Use next
-         * line instead.
-         */
+        // Line we want at top would go off top of screen.  Use next
+        // line instead.
         (void)hasFoldingWin(wp, lnum, NULL, &lnum, true, NULL);
         lnum++;
         wp->w_wrow -= line_size + sline;
@@ -6403,9 +6258,7 @@ void win_comp_scroll(win_T *wp)
   }
 }
 
-/*
- * command_height: called whenever p_ch has been changed
- */
+// command_height: called whenever p_ch has been changed
 void command_height(void)
 {
   int h;
@@ -6488,10 +6341,8 @@ void command_height(void)
   }
 }
 
-/*
- * Resize frame "frp" to be "n" lines higher (negative for less high).
- * Also resize the frames it is contained in.
- */
+// Resize frame "frp" to be "n" lines higher (negative for less high).
+// Also resize the frames it is contained in.
 static void frame_add_height(frame_T *frp, int n)
 {
   frame_new_height(frp, frp->fr_height + n, false, false);
@@ -6504,11 +6355,9 @@ static void frame_add_height(frame_T *frp, int n)
   }
 }
 
-/*
- * Get the file name at the cursor.
- * If Visual mode is active, use the selected text if it's in one line.
- * Returns the name in allocated memory, NULL for failure.
- */
+// Get the file name at the cursor.
+// If Visual mode is active, use the selected text if it's in one line.
+// Returns the name in allocated memory, NULL for failure.
 char_u *grab_file_name(long count, linenr_T *file_lnum)
 {
   int options = FNAME_MESS | FNAME_EXP | FNAME_REL | FNAME_UNESC;
@@ -6529,19 +6378,17 @@ char_u *grab_file_name(long count, linenr_T *file_lnum)
   return file_name_at_cursor(options | FNAME_HYP, count, file_lnum);
 }
 
-/*
- * Return the file name under or after the cursor.
- *
- * The 'path' option is searched if the file name is not absolute.
- * The string returned has been alloc'ed and should be freed by the caller.
- * NULL is returned if the file name or file is not found.
- *
- * options:
- * FNAME_MESS       give error messages
- * FNAME_EXP        expand to path
- * FNAME_HYP        check for hypertext link
- * FNAME_INCL       apply "includeexpr"
- */
+// Return the file name under or after the cursor.
+//
+// The 'path' option is searched if the file name is not absolute.
+// The string returned has been alloc'ed and should be freed by the caller.
+// NULL is returned if the file name or file is not found.
+//
+// options:
+// FNAME_MESS       give error messages
+// FNAME_EXP        expand to path
+// FNAME_HYP        check for hypertext link
+// FNAME_INCL       apply "includeexpr"
 char_u *file_name_at_cursor(int options, long count, linenr_T *file_lnum)
 {
   return file_name_in_line((char_u *)get_cursor_line_ptr(),
@@ -6561,9 +6408,7 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
   bool in_type = true;
   bool is_url = false;
 
-  /*
-   * search forward for what could be the start of a file name
-   */
+  // search forward for what could be the start of a file name
   ptr = (char *)line + col;
   while (*ptr != NUL && !vim_isfilec(*ptr)) {
     MB_PTR_ADV(ptr);
@@ -6575,10 +6420,8 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
     return NULL;
   }
 
-  /*
-   * Search backward for first char of the file name.
-   * Go one char back to ":" before "//" even when ':' is not in 'isfname'.
-   */
+  // Search backward for first char of the file name.
+  // Go one char back to ":" before "//" even when ':' is not in 'isfname'.
   while ((char_u *)ptr > line) {
     if ((len = (size_t)(utf_head_off((char *)line, ptr - 1))) > 0) {
       ptr -= len + 1;
@@ -6589,10 +6432,8 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
     }
   }
 
-  /*
-   * Search forward for the last char of the file name.
-   * Also allow ":/" when ':' is not in 'isfname'.
-   */
+  // Search forward for the last char of the file name.
+  // Also allow ":/" when ':' is not in 'isfname'.
   len = 0;
   while (vim_isfilec(ptr[len]) || (ptr[len] == '\\' && ptr[len + 1] == ' ')
          || ((options & FNAME_HYP) && path_is_url(ptr + len))
@@ -6615,10 +6456,8 @@ char_u *file_name_in_line(char_u *line, int col, int options, long count, char_u
     len += (size_t)(utfc_ptr2len(ptr + len));
   }
 
-  /*
-   * If there is trailing punctuation, remove it.
-   * But don't remove "..", could be a directory name.
-   */
+  // If there is trailing punctuation, remove it.
+  // But don't remove "..", could be a directory name.
   if (len > 2 && vim_strchr(".,:;!", ptr[len - 1]) != NULL
       && ptr[len - 2] != '.') {
     len--;
@@ -6972,21 +6811,17 @@ void reset_lnums(void)
   }
 }
 
-/*
- * A snapshot of the window sizes, to restore them after closing the help
- * window.
- * Only these fields are used:
- * fr_layout
- * fr_width
- * fr_height
- * fr_next
- * fr_child
- * fr_win (only valid for the old curwin, NULL otherwise)
- */
+// A snapshot of the window sizes, to restore them after closing the help
+// window.
+// Only these fields are used:
+// fr_layout
+// fr_width
+// fr_height
+// fr_next
+// fr_child
+// fr_win (only valid for the old curwin, NULL otherwise)
 
-/*
- * Create a snapshot of the current frame sizes.
- */
+// Create a snapshot of the current frame sizes.
 void make_snapshot(int idx)
 {
   clear_snapshot(curtab, idx);
@@ -7010,9 +6845,7 @@ static void make_snapshot_rec(frame_T *fr, frame_T **frp)
   }
 }
 
-/*
- * Remove any existing snapshot.
- */
+// Remove any existing snapshot.
 static void clear_snapshot(tabpage_T *tp, int idx)
 {
   clear_snapshot_rec(tp->tp_snapshot[idx]);
@@ -7097,11 +6930,9 @@ static int check_snapshot_rec(frame_T *sn, frame_T *fr)
   return OK;
 }
 
-/*
- * Copy the size of snapshot frame "sn" to frame "fr".  Do the same for all
- * following frames and children.
- * Returns a pointer to the old current window, or NULL.
- */
+// Copy the size of snapshot frame "sn" to frame "fr".  Do the same for all
+// following frames and children.
+// Returns a pointer to the old current window, or NULL.
 static win_T *restore_snapshot_rec(frame_T *sn, frame_T *fr)
 {
   win_T *wp = NULL;
-- 
cgit 


From 05b49ef975664ccdfea4e7b5a0fc09c8ed2cf11a Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 3 Sep 2022 06:50:11 +0800
Subject: vim-patch:8.2.1505: not all file read and writecode is tested
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem:    Not all file read and writecode is tested.
Solution:   Add a few tests. (Dominique Pellé, closes vim/vim#6764)
https://github.com/vim/vim/commit/1b04ce2d400fda97410a961288c496bd8f445a9c

Cherry-pick Test_glob() from patch 8.2.0634.
---
 src/nvim/testdir/test_eval_stuff.vim  | 25 +++++++++++++++++++------
 src/nvim/testdir/test_fnamemodify.vim |  6 ++++++
 src/nvim/testdir/test_functions.vim   | 19 +++++++++++++++++++
 3 files changed, 44 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_eval_stuff.vim b/src/nvim/testdir/test_eval_stuff.vim
index eff1376d3c..351120bf11 100644
--- a/src/nvim/testdir/test_eval_stuff.vim
+++ b/src/nvim/testdir/test_eval_stuff.vim
@@ -91,18 +91,31 @@ func Test_readfile_binary()
   new
   call setline(1, ['one', 'two', 'three'])
   setlocal ff=dos
-  silent write XReadfile
-  let lines = readfile('XReadfile')
+  silent write XReadfile_bin
+  let lines = 'XReadfile_bin'->readfile()
   call assert_equal(['one', 'two', 'three'], lines)
-  let lines = readfile('XReadfile', '', 2)
+  let lines = readfile('XReadfile_bin', '', 2)
   call assert_equal(['one', 'two'], lines)
-  let lines = readfile('XReadfile', 'b')
+  let lines = readfile('XReadfile_bin', 'b')
   call assert_equal(["one\r", "two\r", "three\r", ""], lines)
-  let lines = readfile('XReadfile', 'b', 2)
+  let lines = readfile('XReadfile_bin', 'b', 2)
   call assert_equal(["one\r", "two\r"], lines)
 
   bwipe!
-  call delete('XReadfile')
+  call delete('XReadfile_bin')
+endfunc
+
+func Test_readfile_bom()
+  call writefile(["\ufeffFOO", "FOO\ufeffBAR"], 'XReadfile_bom')
+  call assert_equal(['FOO', 'FOOBAR'], readfile('XReadfile_bom'))
+  call delete('XReadfile_bom')
+endfunc
+
+func Test_readfile_max()
+  call writefile(range(1, 4), 'XReadfile_max')
+  call assert_equal(['1', '2'], readfile('XReadfile_max', '', 2))
+  call assert_equal(['3', '4'], readfile('XReadfile_max', '', -2))
+  call delete('XReadfile_max')
 endfunc
 
 func Test_let_errmsg()
diff --git a/src/nvim/testdir/test_fnamemodify.vim b/src/nvim/testdir/test_fnamemodify.vim
index 5ae2a5ee17..258a2093bd 100644
--- a/src/nvim/testdir/test_fnamemodify.vim
+++ b/src/nvim/testdir/test_fnamemodify.vim
@@ -11,6 +11,7 @@ func Test_fnamemodify()
   call assert_equal('/', fnamemodify('.', ':p')[-1:])
   call assert_equal('r', fnamemodify('.', ':p:h')[-1:])
   call assert_equal('t', fnamemodify('test.out', ':p')[-1:])
+  call assert_equal($HOME .. "/foo" , fnamemodify('~/foo', ':p'))
   call assert_equal('test.out', fnamemodify('test.out', ':.'))
   call assert_equal('a', fnamemodify('../testdir/a', ':.'))
   call assert_equal('~/testdir/test.out', fnamemodify('test.out', ':~'))
@@ -95,4 +96,9 @@ func Test_fnamemodify_er()
   call assert_equal('', fnamemodify(v:_null_string, v:_null_string))
 endfunc
 
+func Test_fnamemodify_fail()
+  call assert_fails('call fnamemodify({}, ":p")', 'E731:')
+  call assert_fails('call fnamemodify("x", {})', 'E731:')
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index 147eda5b0a..99ac6ae32c 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -2015,6 +2015,25 @@ func Test_getmousepos()
   bwipe!
 endfunc
 
+" Test for glob()
+func Test_glob()
+  call assert_equal('', glob(v:_null_string))
+  call assert_equal('', globpath(v:_null_string, v:_null_string))
+
+  call writefile([], 'Xglob1')
+  call writefile([], 'XGLOB2')
+  set wildignorecase
+  " Sort output of glob() otherwise we end up with different
+  " ordering depending on whether file system is case-sensitive.
+  call assert_equal(['XGLOB2', 'Xglob1'], sort(glob('Xglob[12]', 0, 1)))
+  set wildignorecase&
+
+  call delete('Xglob1')
+  call delete('XGLOB2')
+
+  call assert_fails("call glob('*', 0, {})", 'E728:')
+endfunc
+
 func HasDefault(msg = 'msg')
   return a:msg
 endfunc
-- 
cgit 


From 7243b1cbde8a08deab6bf29b452b3383fa4f6d8d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 3 Sep 2022 06:46:30 +0800
Subject: vim-patch:9.0.0360: crash when invalid line number on :for is ignored

Problem:    Crash when invalid line number on :for is ignored.
Solution:   Do not check breakpoint for non-existing line.
https://github.com/vim/vim/commit/35d21c6830fc2d68aca838424a0e786821c5891c

Test does not fail without the fix in Nvim as Nvim uses 0 when line
number overflows. If it is changed to MAXLNUM then the test does fail
without the fix, but using 0 seems better as E481 is still given.
---
 src/nvim/ex_docmd.c                  |  2 +-
 src/nvim/testdir/test_eval_stuff.vim | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index c2c5bb90ce..6517ebd081 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -642,7 +642,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
 
           // Check for the next breakpoint at or after the ":while"
           // or ":for".
-          if (breakpoint != NULL) {
+          if (breakpoint != NULL && lines_ga.ga_len > current_line) {
             *breakpoint = dbg_find_breakpoint(getline_equal(fgetline, cookie, getsourceline), fname,
                                               ((wcmd_T *)lines_ga.ga_data)[current_line].lnum - 1);
             *dbg_tick = debug_tick;
diff --git a/src/nvim/testdir/test_eval_stuff.vim b/src/nvim/testdir/test_eval_stuff.vim
index 351120bf11..dc110af356 100644
--- a/src/nvim/testdir/test_eval_stuff.vim
+++ b/src/nvim/testdir/test_eval_stuff.vim
@@ -1,5 +1,8 @@
 " Tests for various eval things.
 
+source view_util.vim
+source shared.vim
+
 function s:foo() abort
   try
     return [] == 0
@@ -87,6 +90,18 @@ func Test_for_over_null_string()
   let &enc = save_enc
 endfunc
 
+func Test_for_invalid_line_count()
+  let lines =<< trim END
+      111111111111111111111111 for line in ['one']
+      endfor
+  END
+  call writefile(lines, 'XinvalidFor')
+  " only test that this doesn't crash
+  call RunVim([], [], '-u NONE -e -s -S XinvalidFor -c qa')
+
+  call delete('XinvalidFor')
+endfunc
+
 func Test_readfile_binary()
   new
   call setline(1, ['one', 'two', 'three'])
-- 
cgit 


From c62e5b50795d38db68f198a3d1230c047fc0ccfa Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sat, 3 Sep 2022 07:51:51 +0800
Subject: vim-patch:9.0.0362: expanding ":e %" does not work for remote files

Problem:    Expanding ":e %" does not work for remote files.
Solution:   If the "%" or "#" file does not exist add the expansion anyway.
https://github.com/vim/vim/commit/f5724376ab7362b5a98eaa8a331d663ef722c2a2
---
 src/nvim/path.c                   | 15 ++++++++++++++-
 src/nvim/testdir/test_cmdline.vim | 12 ++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/path.c b/src/nvim/path.c
index 607f1fc09a..1e5fa49ad6 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -2106,13 +2106,16 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
   char *exp_pat = (char *)(*pat);
   char *ignored_msg;
   size_t usedlen;
+  const bool is_cur_alt_file = *exp_pat == '%' || *exp_pat == '#';
+  bool star_follows = false;
 
-  if (*exp_pat == '%' || *exp_pat == '#' || *exp_pat == '<') {
+  if (is_cur_alt_file || *exp_pat == '<') {
     emsg_off++;
     eval_pat = eval_vars((char_u *)exp_pat, (char_u *)exp_pat, &usedlen, NULL, &ignored_msg, NULL,
                          true);
     emsg_off--;
     if (eval_pat != NULL) {
+      star_follows = strcmp(exp_pat + usedlen, "*") == 0;
       exp_pat = concat_str((char *)eval_pat, exp_pat + usedlen);
     }
   }
@@ -2122,6 +2125,16 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
   }
 
   if (eval_pat != NULL) {
+    if (*num_file == 0 && is_cur_alt_file && star_follows) {
+      // Expanding "%" or "#" and the file does not exist: Add the
+      // pattern anyway (without the star) so that this works for remote
+      // files and non-file buffer names.
+      *file = xmalloc(sizeof(char *));
+      **file = (char *)eval_pat;
+      eval_pat = NULL;
+      *num_file = 1;
+      ret = OK;
+    }
     xfree(exp_pat);
     xfree(eval_pat);
   }
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index bc06e70ff4..e40ff65051 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -1055,6 +1055,18 @@ func Test_cmdline_write_alternatefile()
   bw!
 endfunc
 
+func Test_cmdline_expand_cur_alt_file()
+  enew
+  file http://some.com/file.txt
+  call feedkeys(":e %\<Tab>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"e http://some.com/file.txt', @:)
+  edit another
+  call feedkeys(":e #\<Tab>\<C-B>\"\<CR>", 'xt')
+  call assert_equal('"e http://some.com/file.txt', @:)
+  bwipe
+  bwipe http://some.com/file.txt
+endfunc
+
 " using a leading backslash here
 set cpo+=C
 
-- 
cgit 


From ea611c7122470af0e03f4b0a5ae99c0878da2712 Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Sat, 3 Sep 2022 12:00:00 +0200
Subject: ci(clint): remove "Inner expression indentation should be 4" rule
 (#20047)

It completely breaks down in shada.c and is generally useless.
---
 src/clint.py | 7 -------
 1 file changed, 7 deletions(-)

(limited to 'src')

diff --git a/src/clint.py b/src/clint.py
index 28f6031a57..0556f53372 100755
--- a/src/clint.py
+++ b/src/clint.py
@@ -1941,13 +1941,6 @@ def CheckExpressionAlignment(filename, clean_lines, linenum, error, startpos=0):
                             error(filename, linenum, 'whitespace/indent', 2,
                                   'End of the inner expression should have '
                                   'the same indent as start')
-                else:
-                    if (pos != depth_line_starts[depth][0] + 4
-                        and not (depth_line_starts[depth][1] == '{'
-                                 and pos == depth_line_starts[depth][0] + 2)):
-                        if depth not in ignore_error_levels:
-                            error(filename, linenum, 'whitespace/indent', 2,
-                                  'Inner expression indentation should be 4')
             else:
                 if (pos != level_starts[depth][0] + 1
                         + (level_starts[depth][2] == '{')):
-- 
cgit 


From c50460cf3b02f8e684d038a1ea37e6fdc2d13a09 Mon Sep 17 00:00:00 2001
From: Stephan Seitz <stephan.seitz@fau.de>
Date: Sat, 3 Sep 2022 07:02:58 -0700
Subject: feat(treesitter): include language in invalid query error (#14053)

---
 src/nvim/lua/treesitter.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 7ff4fbbff4..65e024b707 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -1276,8 +1276,8 @@ int tslua_parse_query(lua_State *L)
   TSQuery *query = ts_query_new(lang, src, (uint32_t)len, &error_offset, &error_type);
 
   if (!query) {
-    return luaL_error(L, "query: %s at position %d",
-                      query_err_string(error_type), (int)error_offset);
+    return luaL_error(L, "query: %s at position %d for language %s",
+                      query_err_string(error_type), (int)error_offset, lang_name);
   }
 
   TSQuery **ud = lua_newuserdata(L, sizeof(TSQuery *));  // [udata]
-- 
cgit 


From 00b49dd8dd638c5fe1b664273aea5c843d69f36d Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 24 Jul 2022 11:20:23 +0800
Subject: vim-patch:8.2.4674: cannot force getting MouseMove events

Problem:    Cannot force getting MouseMove events.
Solution:   Add the 'mousemoveevent' option with implementaiton for the GUI.
            (Ernie Rael, closes vim/vim#10044)
https://github.com/vim/vim/commit/c4cb544cd5beaa864b3893e4b8d0085393c7dbce

This only ports the docs and the option variable.
The following commits will actually implement it as a UI option.
---
 src/nvim/option_defs.h | 1 +
 src/nvim/options.lua   | 7 +++++++
 2 files changed, 8 insertions(+)

(limited to 'src')

diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index bfac0cff87..64b3f69df4 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -616,6 +616,7 @@ EXTERN int p_ma;                ///< 'modifiable'
 EXTERN int p_mod;               ///< 'modified'
 EXTERN char *p_mouse;           // 'mouse'
 EXTERN char *p_mousem;          // 'mousemodel'
+EXTERN int p_mousemev;          ///< 'mousemoveevent'
 EXTERN int p_mousef;            // 'mousefocus'
 EXTERN char *p_mousescroll;     // 'mousescroll'
 EXTERN long p_mousescroll_vert INIT(= MOUSESCROLL_VERT_DFLT);
diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 2f941f5d0c..9f540e6005 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -1621,6 +1621,13 @@ return {
       varname='p_mousem',
       defaults={if_true="popup_setpos"}
     },
+    {
+      full_name='mousemoveevent', abbreviation='mousemev',
+      short_desc=N_("deliver mouse move events to input queue"),
+      type='bool', scope={'global'},
+      varname='p_mousemev',
+      defaults={if_true=false}
+    },
     {
       full_name='mousescroll',
       short_desc=N_("amount to scroll by when scrolling with a mouse"),
-- 
cgit 


From a5fe7940c8b9436b78ae408eae8345266423f2c8 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 24 Jul 2022 11:32:56 +0800
Subject: feat(ui-ext): make 'mousemoveevent' a ui_option

---
 src/nvim/options.lua | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 9f540e6005..717ca6747b 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -1625,6 +1625,7 @@ return {
       full_name='mousemoveevent', abbreviation='mousemev',
       short_desc=N_("deliver mouse move events to input queue"),
       type='bool', scope={'global'},
+      redraw={'ui_option'},
       varname='p_mousemev',
       defaults={if_true=false}
     },
-- 
cgit 


From 04bd700ac3bc2bdea0e0d8747de95dab2034aa11 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 24 Jul 2022 11:26:54 +0800
Subject: feat(tui): support 'mousemoveevent'

---
 src/nvim/os/input.c  |  6 ++++--
 src/nvim/tui/input.c |  7 ++++---
 src/nvim/tui/tui.c   | 27 +++++++++++++++++++++++++--
 3 files changed, 33 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index bfe6d59dc6..ea9f31d776 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -293,7 +293,8 @@ static uint8_t check_multiclick(int code, int grid, int row, int col)
       || code == KE_MOUSEDOWN
       || code == KE_MOUSEUP
       || code == KE_MOUSELEFT
-      || code == KE_MOUSERIGHT) {
+      || code == KE_MOUSERIGHT
+      || code == KE_MOUSEMOVE) {
     return 0;
   }
   uint64_t mouse_time = os_hrtime();    // time of current mouse click (ns)
@@ -347,7 +348,8 @@ static unsigned int handle_mouse_event(char **ptr, uint8_t *buf, unsigned int bu
 
   if (type != KS_EXTRA
       || !((mouse_code >= KE_LEFTMOUSE && mouse_code <= KE_RIGHTRELEASE)
-           || (mouse_code >= KE_MOUSEDOWN && mouse_code <= KE_MOUSERIGHT))) {
+           || (mouse_code >= KE_MOUSEDOWN && mouse_code <= KE_MOUSERIGHT)
+           || mouse_code == KE_MOUSEMOVE)) {
     return bufsize;
   }
 
diff --git a/src/nvim/tui/input.c b/src/nvim/tui/input.c
index d269878f46..728520c20c 100644
--- a/src/nvim/tui/input.c
+++ b/src/nvim/tui/input.c
@@ -406,8 +406,8 @@ static void forward_mouse_event(TermInput *input, TermKeyKey *key)
     }
   }
 
-  if (button == 0 || (ev != TERMKEY_MOUSE_PRESS && ev != TERMKEY_MOUSE_DRAG
-                      && ev != TERMKEY_MOUSE_RELEASE)) {
+  if ((button == 0 && ev != TERMKEY_MOUSE_RELEASE)
+      || (ev != TERMKEY_MOUSE_PRESS && ev != TERMKEY_MOUSE_DRAG && ev != TERMKEY_MOUSE_RELEASE)) {
     return;
   }
 
@@ -453,7 +453,8 @@ static void forward_mouse_event(TermInput *input, TermKeyKey *key)
     len += (size_t)snprintf(buf + len, sizeof(buf) - len, "Drag");
     break;
   case TERMKEY_MOUSE_RELEASE:
-    len += (size_t)snprintf(buf + len, sizeof(buf) - len, "Release");
+    len += (size_t)snprintf(buf + len, sizeof(buf) - len, button ? "Release" : "MouseMove");
+    last_pressed_button = 0;
     break;
   case TERMKEY_MOUSE_UNKNOWN:
     abort();
diff --git a/src/nvim/tui/tui.c b/src/nvim/tui/tui.c
index 38e8c15762..471a3fb859 100644
--- a/src/nvim/tui/tui.c
+++ b/src/nvim/tui/tui.c
@@ -103,6 +103,7 @@ struct TUIData {
   bool immediate_wrap_after_last_column;
   bool bce;
   bool mouse_enabled;
+  bool mouse_move_enabled;
   bool busy, is_invisible, want_invisible;
   bool cork, overflow;
   bool cursor_color_changed;
@@ -117,6 +118,7 @@ struct TUIData {
   ModeShape showing_mode;
   struct {
     int enable_mouse, disable_mouse;
+    int enable_mouse_move, disable_mouse_move;
     int enable_bracketed_paste, disable_bracketed_paste;
     int enable_lr_margin, disable_lr_margin;
     int enter_strikethrough_mode;
@@ -236,6 +238,8 @@ static void terminfo_start(UI *ui)
   data->showing_mode = SHAPE_IDX_N;
   data->unibi_ext.enable_mouse = -1;
   data->unibi_ext.disable_mouse = -1;
+  data->unibi_ext.enable_mouse_move = -1;
+  data->unibi_ext.disable_mouse_move = -1;
   data->unibi_ext.set_cursor_color = -1;
   data->unibi_ext.reset_cursor_color = -1;
   data->unibi_ext.enable_bracketed_paste = -1;
@@ -1138,6 +1142,9 @@ static void tui_mouse_on(UI *ui)
   TUIData *data = ui->data;
   if (!data->mouse_enabled) {
     unibi_out_ext(ui, data->unibi_ext.enable_mouse);
+    if (data->mouse_move_enabled) {
+      unibi_out_ext(ui, data->unibi_ext.enable_mouse_move);
+    }
     data->mouse_enabled = true;
   }
 }
@@ -1146,6 +1153,9 @@ static void tui_mouse_off(UI *ui)
 {
   TUIData *data = ui->data;
   if (data->mouse_enabled) {
+    if (data->mouse_move_enabled) {
+      unibi_out_ext(ui, data->unibi_ext.disable_mouse_move);
+    }
     unibi_out_ext(ui, data->unibi_ext.disable_mouse);
     data->mouse_enabled = false;
   }
@@ -1457,9 +1467,18 @@ static void tui_screenshot(UI *ui, String path)
 static void tui_option_set(UI *ui, String name, Object value)
 {
   TUIData *data = ui->data;
-  if (strequal(name.data, "termguicolors")) {
+  if (strequal(name.data, "mousemoveevent")) {
+    if (data->mouse_move_enabled != value.data.boolean) {
+      if (data->mouse_enabled) {
+        tui_mouse_off(ui);
+        data->mouse_move_enabled = value.data.boolean;
+        tui_mouse_on(ui);
+      } else {
+        data->mouse_move_enabled = value.data.boolean;
+      }
+    }
+  } else if (strequal(name.data, "termguicolors")) {
     ui->rgb = value.data.boolean;
-
     data->print_attr_id = -1;
     invalidate(ui, 0, data->grid.height, 0, data->grid.width);
   } else if (strequal(name.data, "ttimeout")) {
@@ -2135,6 +2154,10 @@ static void augment_terminfo(TUIData *data, const char *term, long vte_version,
                                                         "\x1b[?1002h\x1b[?1006h");
   data->unibi_ext.disable_mouse = (int)unibi_add_ext_str(ut, "ext.disable_mouse",
                                                          "\x1b[?1002l\x1b[?1006l");
+  data->unibi_ext.enable_mouse_move = (int)unibi_add_ext_str(ut, "ext.enable_mouse_move",
+                                                             "\x1b[?1003h");
+  data->unibi_ext.disable_mouse_move = (int)unibi_add_ext_str(ut, "ext.disable_mouse_move",
+                                                              "\x1b[?1003l");
 
   // Extended underline.
   // terminfo will have Smulx for this (but no support for colors yet).
-- 
cgit 


From ceb09701f29dcabcf219f458fffbb64f5adced9b Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 24 Jul 2022 13:58:29 +0800
Subject: feat(api): add "move" to nvim_input_mouse

---
 src/nvim/api/vim.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 83d6ba8dc7..95c9919522 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -336,9 +336,9 @@ Integer nvim_input(String keys)
 ///       mouse input in a GUI. The deprecated pseudokey form
 ///       ("<LeftMouse><col,row>") of |nvim_input()| has the same limitation.
 ///
-/// @param button Mouse button: one of "left", "right", "middle", "wheel".
+/// @param button Mouse button: one of "left", "right", "middle", "wheel", "move".
 /// @param action For ordinary buttons, one of "press", "drag", "release".
-///               For the wheel, one of "up", "down", "left", "right".
+///               For the wheel, one of "up", "down", "left", "right". Ignored for "move".
 /// @param modifier String of modifiers each represented by a single char.
 ///                 The same specifiers are used as for a key press, except
 ///                 that the "-" separator is optional, so "C-A-", "c-a"
@@ -365,6 +365,8 @@ void nvim_input_mouse(String button, String action, String modifier, Integer gri
     code = KE_RIGHTMOUSE;
   } else if (strequal(button.data, "wheel")) {
     code = KE_MOUSEDOWN;
+  } else if (strequal(button.data, "move")) {
+    code = KE_MOUSEMOVE;
   } else {
     goto error;
   }
@@ -381,7 +383,7 @@ void nvim_input_mouse(String button, String action, String modifier, Integer gri
     } else {
       goto error;
     }
-  } else {
+  } else if (code != KE_MOUSEMOVE) {
     if (strequal(action.data, "press")) {
       // pass
     } else if (strequal(action.data, "drag")) {
-- 
cgit 


From 82d128405aaeb619a0c04353449f5717da126249 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Sun, 24 Jul 2022 15:24:15 +0800
Subject: feat(pum): pretend 'mousemoveevent' is set when showing right-click
 menu

---
 src/nvim/popupmenu.c | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'src')

diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index 0d9080ceb7..2265334a45 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -1042,6 +1042,10 @@ void pum_show_popupmenu(vimmenu_T *menu)
   pum_scrollbar = 0;
   pum_height = pum_size;
   pum_position_at_mouse(20);
+  if (!p_mousemev) {
+    // Pretend 'mousemoveevent' is set.
+    ui_call_option_set(STATIC_CSTR_AS_STRING("mousemoveevent"), BOOLEAN_OBJ(true));
+  }
 
   pum_selected = -1;
   pum_first = 0;
@@ -1102,6 +1106,9 @@ void pum_show_popupmenu(vimmenu_T *menu)
 
   xfree(array);
   pum_undisplay(true);
+  if (!p_mousemev) {
+    ui_call_option_set(STATIC_CSTR_AS_STRING("mousemoveevent"), BOOLEAN_OBJ(false));
+  }
 }
 
 void pum_make_popup(const char *path_name, int use_mouse_pos)
-- 
cgit 


From fc7a64291a5ed074eafff47b21b411bfe9d4a19e Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 5 Sep 2022 21:54:23 +0800
Subject: vim-patch:9.0.0386: some code blocks are nested too deep

Problem:    Some code blocks are nested too deep.
Solution:   Bail out earlier. (Yegappan Lakshmanan, closes vim/vim#11058)
https://github.com/vim/vim/commit/b1f471ee20b0fa783ecd6e29aa69067e6c821376
---
 src/nvim/arglist.c | 167 ++++++++++++++++++++++++++++-------------------------
 src/nvim/memory.c  |  18 +++---
 2 files changed, 99 insertions(+), 86 deletions(-)

(limited to 'src')

diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 70b2e71949..e6ac1f6247 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -79,11 +79,12 @@ void alist_expand(int *fnum_list, int fnum_len)
 {
   char *save_p_su = p_su;
 
+  char **old_arg_files = xmalloc(sizeof(*old_arg_files) * GARGCOUNT);
+
   // Don't use 'suffixes' here.  This should work like the shell did the
   // expansion.  Also, the vimrc file isn't read yet, thus the user
   // can't set the options.
   p_su = empty_option;
-  char **old_arg_files = xmalloc(sizeof(*old_arg_files) * GARGCOUNT);
   for (int i = 0; i < GARGCOUNT; i++) {
     old_arg_files[i] = vim_strsave(GARGLIST[i].ae_fname);
   }
@@ -308,6 +309,50 @@ static void alist_add_list(int count, char **files, int after, bool will_edit)
   }
 }
 
+/// Delete the file names in "alist_ga" from the argument list.
+static void arglist_del_files(garray_T *alist_ga)
+{
+  regmatch_T regmatch;
+
+  // Delete the items: use each item as a regexp and find a match in the
+  // argument list.
+  regmatch.rm_ic = p_fic;     // ignore case when 'fileignorecase' is set
+  for (int i = 0; i < alist_ga->ga_len && !got_int; i++) {
+    char *p = ((char **)alist_ga->ga_data)[i];
+    p = file_pat_to_reg_pat(p, NULL, NULL, false);
+    if (p == NULL) {
+      break;
+    }
+    regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0);
+    if (regmatch.regprog == NULL) {
+      xfree(p);
+      break;
+    }
+
+    bool didone = false;
+    for (int match = 0; match < ARGCOUNT; match++) {
+      if (vim_regexec(&regmatch, alist_name(&ARGLIST[match]), (colnr_T)0)) {
+        didone = true;
+        xfree(ARGLIST[match].ae_fname);
+        memmove(ARGLIST + match, ARGLIST + match + 1,
+                (size_t)(ARGCOUNT - match - 1) * sizeof(aentry_T));
+        ALIST(curwin)->al_ga.ga_len--;
+        if (curwin->w_arg_idx > match) {
+          curwin->w_arg_idx--;
+        }
+        match--;
+      }
+    }
+
+    vim_regfree(regmatch.regprog);
+    xfree(p);
+    if (!didone) {
+      semsg(_(e_nomatch2), ((char **)alist_ga->ga_data)[i]);
+    }
+  }
+  ga_clear(alist_ga);
+}
+
 /// @param str
 /// @param what
 ///         AL_SET: Redefine the argument list to 'str'.
@@ -324,8 +369,6 @@ static int do_arglist(char *str, int what, int after, bool will_edit)
   garray_T new_ga;
   int exp_count;
   char **exp_files;
-  char *p;
-  int match;
   int arg_escaped = true;
 
   // Set default argument for ":argadd" command.
@@ -341,46 +384,7 @@ static int do_arglist(char *str, int what, int after, bool will_edit)
   get_arglist(&new_ga, str, arg_escaped);
 
   if (what == AL_DEL) {
-    regmatch_T regmatch;
-    bool didone;
-
-    // Delete the items: use each item as a regexp and find a match in the
-    // argument list.
-    regmatch.rm_ic = p_fic;     // ignore case when 'fileignorecase' is set
-    for (int i = 0; i < new_ga.ga_len && !got_int; i++) {
-      p = ((char **)new_ga.ga_data)[i];
-      p = file_pat_to_reg_pat(p, NULL, NULL, false);
-      if (p == NULL) {
-        break;
-      }
-      regmatch.regprog = vim_regcomp(p, p_magic ? RE_MAGIC : 0);
-      if (regmatch.regprog == NULL) {
-        xfree(p);
-        break;
-      }
-
-      didone = false;
-      for (match = 0; match < ARGCOUNT; match++) {
-        if (vim_regexec(&regmatch, alist_name(&ARGLIST[match]), (colnr_T)0)) {
-          didone = true;
-          xfree(ARGLIST[match].ae_fname);
-          memmove(ARGLIST + match, ARGLIST + match + 1,
-                  (size_t)(ARGCOUNT - match - 1) * sizeof(aentry_T));
-          ALIST(curwin)->al_ga.ga_len--;
-          if (curwin->w_arg_idx > match) {
-            curwin->w_arg_idx--;
-          }
-          match--;
-        }
-      }
-
-      vim_regfree(regmatch.regprog);
-      xfree(p);
-      if (!didone) {
-        semsg(_(e_nomatch2), ((char **)new_ga.ga_data)[i]);
-      }
-    }
-    ga_clear(&new_ga);
+    arglist_del_files(&new_ga);
   } else {
     int i = expand_wildcards(new_ga.ga_len, new_ga.ga_data,
                              &exp_count, &exp_files,
@@ -471,22 +475,27 @@ void ex_args(exarg_T *eap)
     ex_next(eap);
   } else if (eap->cmdidx == CMD_args) {
     // ":args": list arguments.
-    if (ARGCOUNT > 0) {
-      char **items = xmalloc(sizeof(char *) * (size_t)ARGCOUNT);
-      // Overwrite the command, for a short list there is no scrolling
-      // required and no wait_return().
-      gotocmdline(true);
-      for (int i = 0; i < ARGCOUNT; i++) {
-        items[i] = alist_name(&ARGLIST[i]);
-      }
-      list_in_columns(items, ARGCOUNT, curwin->w_arg_idx);
-      xfree(items);
+    if (ARGCOUNT <= 0) {
+      return;
     }
+
+    char **items = xmalloc(sizeof(char *) * (size_t)ARGCOUNT);
+
+    // Overwrite the command, for a short list there is no scrolling
+    // required and no wait_return().
+    gotocmdline(true);
+
+    for (int i = 0; i < ARGCOUNT; i++) {
+      items[i] = alist_name(&ARGLIST[i]);
+    }
+    list_in_columns(items, ARGCOUNT, curwin->w_arg_idx);
+    xfree(items);
   } else if (eap->cmdidx == CMD_arglocal) {
     garray_T *gap = &curwin->w_alist->al_ga;
 
     // ":argslocal": make a local copy of the global argument list.
     ga_grow(gap, GARGCOUNT);
+
     for (int i = 0; i < GARGCOUNT; i++) {
       if (GARGLIST[i].ae_fname != NULL) {
         AARGLIST(curwin->w_alist)[gap->ga_len].ae_fname = xstrdup(GARGLIST[i].ae_fname);
@@ -1126,31 +1135,33 @@ void f_argv(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   aentry_T *arglist = NULL;
   int argcount = -1;
 
-  if (argvars[0].v_type != VAR_UNKNOWN) {
-    if (argvars[1].v_type == VAR_UNKNOWN) {
-      arglist = ARGLIST;
-      argcount = ARGCOUNT;
-    } else if (argvars[1].v_type == VAR_NUMBER
-               && tv_get_number(&argvars[1]) == -1) {
-      arglist = GARGLIST;
-      argcount = GARGCOUNT;
-    } else {
-      win_T *wp = find_win_by_nr_or_id(&argvars[1]);
-      if (wp != NULL) {
-        // Use the argument list of the specified window
-        arglist = WARGLIST(wp);
-        argcount = WARGCOUNT(wp);
-      }
-    }
-    rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = NULL;
-    int idx = (int)tv_get_number_chk(&argvars[0], NULL);
-    if (arglist != NULL && idx >= 0 && idx < argcount) {
-      rettv->vval.v_string = xstrdup((const char *)alist_name(&arglist[idx]));
-    } else if (idx == -1) {
-      get_arglist_as_rettv(arglist, argcount, rettv);
-    }
-  } else {
+  if (argvars[0].v_type == VAR_UNKNOWN) {
     get_arglist_as_rettv(ARGLIST, ARGCOUNT, rettv);
+    return;
+  }
+
+  if (argvars[1].v_type == VAR_UNKNOWN) {
+    arglist = ARGLIST;
+    argcount = ARGCOUNT;
+  } else if (argvars[1].v_type == VAR_NUMBER
+             && tv_get_number(&argvars[1]) == -1) {
+    arglist = GARGLIST;
+    argcount = GARGCOUNT;
+  } else {
+    win_T *wp = find_win_by_nr_or_id(&argvars[1]);
+    if (wp != NULL) {
+      // Use the argument list of the specified window
+      arglist = WARGLIST(wp);
+      argcount = WARGCOUNT(wp);
+    }
+  }
+
+  rettv->v_type = VAR_STRING;
+  rettv->vval.v_string = NULL;
+  int idx = (int)tv_get_number_chk(&argvars[0], NULL);
+  if (arglist != NULL && idx >= 0 && idx < argcount) {
+    rettv->vval.v_string = xstrdup((const char *)alist_name(&arglist[idx]));
+  } else if (idx == -1) {
+    get_arglist_as_rettv(arglist, argcount, rettv);
   }
 }
diff --git a/src/nvim/memory.c b/src/nvim/memory.c
index e5fea027cb..03cfde6160 100644
--- a/src/nvim/memory.c
+++ b/src/nvim/memory.c
@@ -506,16 +506,18 @@ bool striequal(const char *a, const char *b)
 // Did_outofmem_msg is reset when a character is read.
 void do_outofmem_msg(size_t size)
 {
-  if (!did_outofmem_msg) {
-    // Don't hide this message
-    emsg_silent = 0;
+  if (did_outofmem_msg) {
+    return;
+  }
 
-    /* Must come first to avoid coming back here when printing the error
-     * message fails, e.g. when setting v:errmsg. */
-    did_outofmem_msg = true;
+  // Don't hide this message
+  emsg_silent = 0;
 
-    semsg(_("E342: Out of memory!  (allocating %" PRIu64 " bytes)"), (uint64_t)size);
-  }
+  // Must come first to avoid coming back here when printing the error
+  // message fails, e.g. when setting v:errmsg.
+  did_outofmem_msg = true;
+
+  semsg(_("E342: Out of memory!  (allocating %" PRIu64 " bytes)"), (uint64_t)size);
 }
 
 /// Writes time_t to "buf[8]".
-- 
cgit 


From f6a8d395a72da61c9305cd242f38bd8137c4f5b0 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 5 Sep 2022 22:10:14 +0800
Subject: refactor(ex_cd): add an early return to fix clint warning

The popupmenu.c change is unrelated.
---
 src/nvim/ex_docmd.c  | 39 +++++++++++++++++++--------------------
 src/nvim/popupmenu.c |  6 +++---
 2 files changed, 22 insertions(+), 23 deletions(-)

(limited to 'src')

diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 6517ebd081..8fb166d2c9 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -5544,27 +5544,26 @@ void ex_cd(exarg_T *eap)
   // for non-UNIX ":cd" means: print current directory unless 'cdhome' is set
   if (*new_dir == NUL && !p_cdh) {
     ex_pwd(NULL);
-  } else
+    return;
+  }
 #endif
-  {
-    CdScope scope = kCdScopeGlobal;
-    switch (eap->cmdidx) {
-    case CMD_tcd:
-    case CMD_tchdir:
-      scope = kCdScopeTabpage;
-      break;
-    case CMD_lcd:
-    case CMD_lchdir:
-      scope = kCdScopeWindow;
-      break;
-    default:
-      break;
-    }
-    if (changedir_func(new_dir, scope)) {
-      // Echo the new current directory if the command was typed.
-      if (KeyTyped || p_verbose >= 5) {
-        ex_pwd(eap);
-      }
+  CdScope scope = kCdScopeGlobal;
+  switch (eap->cmdidx) {
+  case CMD_tcd:
+  case CMD_tchdir:
+    scope = kCdScopeTabpage;
+    break;
+  case CMD_lcd:
+  case CMD_lchdir:
+    scope = kCdScopeWindow;
+    break;
+  default:
+    break;
+  }
+  if (changedir_func(new_dir, scope)) {
+    // Echo the new current directory if the command was typed.
+    if (KeyTyped || p_verbose >= 5) {
+      ex_pwd(eap);
     }
   }
 }
diff --git a/src/nvim/popupmenu.c b/src/nvim/popupmenu.c
index 2265334a45..4de3713f4f 100644
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -1042,14 +1042,14 @@ void pum_show_popupmenu(vimmenu_T *menu)
   pum_scrollbar = 0;
   pum_height = pum_size;
   pum_position_at_mouse(20);
+
+  pum_selected = -1;
+  pum_first = 0;
   if (!p_mousemev) {
     // Pretend 'mousemoveevent' is set.
     ui_call_option_set(STATIC_CSTR_AS_STRING("mousemoveevent"), BOOLEAN_OBJ(true));
   }
 
-  pum_selected = -1;
-  pum_first = 0;
-
   for (;;) {
     pum_is_visible = true;
     pum_is_drawn = true;
-- 
cgit 


From 97f38f0a9bbae4969f672746a62caa6cba136b45 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Sun, 4 Sep 2022 17:58:33 +0200
Subject: fix(treesitter): do not link @error by default

The @error capture is used for tree-sitter's ERROR node, which indicates
a parsing error -- which can be quite frequent (and jarring) while typing.

Users can still manually `hi link @error Error` in their config.
---
 src/nvim/highlight_group.c | 1 -
 1 file changed, 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 5c07784db3..412fe3509d 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -186,7 +186,6 @@ static const char *highlight_init_both[] = {
   "default link DiagnosticSignInfo DiagnosticInfo",
   "default link DiagnosticSignHint DiagnosticHint",
 
-  "default link @error Error",
   "default link @text.underline Underlined",
   "default link @todo Todo",
   "default link @debug Debug",
-- 
cgit 


From 75adfefc85bcf0d62d2c0f51a951e6003b595cea Mon Sep 17 00:00:00 2001
From: Thomas Vigouroux <thomas.vigouroux@protonmail.com>
Date: Mon, 18 Jul 2022 14:21:40 +0200
Subject: feat(extmarks,ts,spell): full support for spelling
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- Added 'spell' option to extmarks:

  Extmarks with this set will have the region spellchecked.

- Added 'noplainbuffer' option to 'spelloptions':

  This is used to tell Neovim not to spellcheck the buffer. The old
  behaviour was to spell check the whole buffer unless :syntax was set.

- Added spelling support to the treesitter highlighter:

  @spell captures in highlights.scm are used to define regions which
  should be spell checked.

- Added support for navigating spell errors for extmarks:

  Works for both ephemeral and static extmarks

- Added '_on_spell_nav' callback for decoration providers:

  Since ephemeral callbacks are only drawn for the visible screen,
  providers must implement this callback to instruct Neovim which
  regions in the buffer need can be spell checked.

  The callback takes a start position and an end position.

  Note: this callback is subject to change hence the _ prefix.

- Added spell captures for built-in support languages

Co-authored-by: Lewis Russell <lewis6991@gmail.com>
Co-authored-by: Björn Linse <bjorn.linse@gmail.com>
---
 src/nvim/api/extmark.c         | 65 ++++++++++++++++----------------
 src/nvim/api/keysets.lua       | 10 +++++
 src/nvim/buffer_defs.h         |  3 ++
 src/nvim/decoration.c          | 12 +++++-
 src/nvim/decoration.h          |  7 +++-
 src/nvim/decoration_provider.c | 33 ++++++++++++++---
 src/nvim/decoration_provider.h |  1 +
 src/nvim/drawline.c            | 53 ++++++++++++++------------
 src/nvim/drawscreen.c          |  2 +-
 src/nvim/extmark.c             |  3 +-
 src/nvim/option_defs.h         |  1 +
 src/nvim/options.lua           |  1 +
 src/nvim/optionstr.c           |  4 +-
 src/nvim/spell.c               | 84 +++++++++++++++++++++++++++++++-----------
 14 files changed, 193 insertions(+), 86 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/extmark.c b/src/nvim/api/extmark.c
index 6ff0a2ed21..ae051d8cab 100644
--- a/src/nvim/api/extmark.c
+++ b/src/nvim/api/extmark.c
@@ -473,6 +473,8 @@ Array nvim_buf_get_extmarks(Buffer buffer, Integer ns_id, Object start, Object e
 ///                   When a character is supplied it is used as |:syn-cchar|.
 ///                   "hl_group" is used as highlight for the cchar if provided,
 ///                   otherwise it defaults to |hl-Conceal|.
+///               - spell: boolean indicating that spell checking should be
+///                   performed within this extmark
 ///               - ui_watched: boolean that indicates the mark should be drawn
 ///                   by a UI. When set, the UI will receive win_extmark events.
 ///                   Note: the mark is positioned by virt_text attributes. Can be
@@ -719,6 +721,11 @@ Integer nvim_buf_set_extmark(Buffer buffer, Integer ns_id, Integer line, Integer
   bool ephemeral = false;
   OPTION_TO_BOOL(ephemeral, ephemeral, false);
 
+  OPTION_TO_BOOL(decor.spell, spell, false);
+  if (decor.spell) {
+    has_decor = true;
+  }
+
   OPTION_TO_BOOL(decor.ui_watched, ui_watched, false);
   if (decor.ui_watched) {
     has_decor = true;
@@ -972,20 +979,21 @@ void nvim_buf_clear_namespace(Buffer buffer, Integer ns_id, Integer line_start,
 /// for the moment.
 ///
 /// @param ns_id  Namespace id from |nvim_create_namespace()|
-/// @param opts   Callbacks invoked during redraw:
+/// @param opts  Table of callbacks:
 ///             - on_start: called first on each screen redraw
 ///                 ["start", tick]
-///             - on_buf: called for each buffer being redrawn (before window
-///                 callbacks)
+///             - on_buf: called for each buffer being redrawn (before
+///                 window callbacks)
 ///                 ["buf", bufnr, tick]
-///             - on_win: called when starting to redraw a specific window.
+///             - on_win: called when starting to redraw a
+///                 specific window.
 ///                 ["win", winid, bufnr, topline, botline_guess]
-///             - on_line: called for each buffer line being redrawn. (The
-///                 interaction with fold lines is subject to change)
+///             - on_line: called for each buffer line being redrawn.
+///                 (The interaction with fold lines is subject to change)
 ///                 ["win", winid, bufnr, row]
 ///             - on_end: called at the end of a redraw cycle
 ///                 ["end", tick]
-void nvim_set_decoration_provider(Integer ns_id, DictionaryOf(LuaRef) opts, Error *err)
+void nvim_set_decoration_provider(Integer ns_id, Dict(set_decoration_provider) *opts, Error *err)
   FUNC_API_SINCE(7) FUNC_API_LUA_ONLY
 {
   DecorProvider *p = get_decor_provider((NS)ns_id, true);
@@ -997,37 +1005,32 @@ void nvim_set_decoration_provider(Integer ns_id, DictionaryOf(LuaRef) opts, Erro
 
   struct {
     const char *name;
+    Object *source;
     LuaRef *dest;
   } cbs[] = {
-    { "on_start", &p->redraw_start },
-    { "on_buf", &p->redraw_buf },
-    { "on_win", &p->redraw_win },
-    { "on_line", &p->redraw_line },
-    { "on_end", &p->redraw_end },
-    { "_on_hl_def", &p->hl_def },
-    { NULL, NULL },
+    { "on_start", &opts->on_start, &p->redraw_start },
+    { "on_buf", &opts->on_buf, &p->redraw_buf },
+    { "on_win", &opts->on_win, &p->redraw_win },
+    { "on_line", &opts->on_line, &p->redraw_line },
+    { "on_end", &opts->on_end, &p->redraw_end },
+    { "_on_hl_def", &opts->_on_hl_def, &p->hl_def },
+    { "_on_spell_nav", &opts->_on_spell_nav, &p->spell_nav },
+    { NULL, NULL, NULL },
   };
 
-  for (size_t i = 0; i < opts.size; i++) {
-    String k = opts.items[i].key;
-    Object *v = &opts.items[i].value;
-    size_t j;
-    for (j = 0; cbs[j].name && cbs[j].dest; j++) {
-      if (strequal(cbs[j].name, k.data)) {
-        if (v->type != kObjectTypeLuaRef) {
-          api_set_error(err, kErrorTypeValidation,
-                        "%s is not a function", cbs[j].name);
-          goto error;
-        }
-        *(cbs[j].dest) = v->data.luaref;
-        v->data.luaref = LUA_NOREF;
-        break;
-      }
+  for (size_t i = 0; cbs[i].source && cbs[i].dest && cbs[i].name; i++) {
+    Object *v = cbs[i].source;
+    if (v->type == kObjectTypeNil) {
+      continue;
     }
-    if (!cbs[j].name) {
-      api_set_error(err, kErrorTypeValidation, "unexpected key: %s", k.data);
+
+    if (v->type != kObjectTypeLuaRef) {
+      api_set_error(err, kErrorTypeValidation,
+                    "%s is not a function", cbs[i].name);
       goto error;
     }
+    *(cbs[i].dest) = v->data.luaref;
+    v->data.luaref = LUA_NOREF;
   }
 
   p->active = true;
diff --git a/src/nvim/api/keysets.lua b/src/nvim/api/keysets.lua
index af3dc24f51..ea8949bd2c 100644
--- a/src/nvim/api/keysets.lua
+++ b/src/nvim/api/keysets.lua
@@ -2,6 +2,15 @@ return {
   context = {
     "types";
   };
+  set_decoration_provider = {
+    "on_start";
+    "on_buf";
+    "on_win";
+    "on_line";
+    "on_end";
+    "_on_hl_def";
+    "_on_spell_nav";
+  };
   set_extmark = {
     "id";
     "end_line";
@@ -28,6 +37,7 @@ return {
     "line_hl_group";
     "cursorline_hl_group";
     "conceal";
+    "spell";
     "ui_watched";
   };
   keymap = {
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index c26b18a7e7..a520f3c0e7 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -462,6 +462,9 @@ typedef struct {
   char *b_p_spf;              // 'spellfile'
   char *b_p_spl;              // 'spelllang'
   char *b_p_spo;              // 'spelloptions'
+#define SPO_CAMEL  0x1
+#define SPO_NPBUFFER 0x2
+  unsigned b_p_spo_flags;      // 'spelloptions' flags
   int b_cjk;                  // all CJK letters as OK
   uint8_t b_syn_chartab[32];  // syntax iskeyword option
   char *b_syn_isk;            // iskeyword option
diff --git a/src/nvim/decoration.c b/src/nvim/decoration.c
index 8955048f45..778f9293fb 100644
--- a/src/nvim/decoration.c
+++ b/src/nvim/decoration.c
@@ -69,7 +69,7 @@ void bufhl_add_hl_pos_offset(buf_T *buf, int src_id, int hl_id, lpos_T pos_start
 void decor_redraw(buf_T *buf, int row1, int row2, Decoration *decor)
 {
   if (row2 >= row1) {
-    if (!decor || decor->hl_id || decor_has_sign(decor) || decor->conceal) {
+    if (!decor || decor->hl_id || decor_has_sign(decor) || decor->conceal || decor->spell) {
       redraw_buf_range_later(buf, row1 + 1, row2 + 1);
     }
   }
@@ -116,6 +116,11 @@ void decor_free(Decoration *decor)
   }
 }
 
+void decor_state_free(DecorState *state)
+{
+  xfree(state->active.items);
+}
+
 void clear_virttext(VirtText *text)
 {
   for (size_t i = 0; i < kv_size(*text); i++) {
@@ -306,6 +311,7 @@ next_mark:
   bool conceal = 0;
   int conceal_char = 0;
   int conceal_attr = 0;
+  bool spell = false;
 
   for (size_t i = 0; i < kv_size(state->active); i++) {
     DecorRange item = kv_A(state->active, i);
@@ -339,6 +345,9 @@ next_mark:
         conceal_attr = item.attr_id;
       }
     }
+    if (active && item.decor.spell) {
+      spell = true;
+    }
     if ((item.start_row == state->row && item.start_col <= col)
         && decor_virt_pos(item.decor)
         && item.decor.virt_text_pos == kVTOverlay && item.win_col == -1) {
@@ -355,6 +364,7 @@ next_mark:
   state->conceal = conceal;
   state->conceal_char = conceal_char;
   state->conceal_attr = conceal_attr;
+  state->spell = spell;
   return attr;
 }
 
diff --git a/src/nvim/decoration.h b/src/nvim/decoration.h
index 8f28442d41..bdbfd72a81 100644
--- a/src/nvim/decoration.h
+++ b/src/nvim/decoration.h
@@ -46,6 +46,7 @@ struct Decoration {
   bool hl_eol;
   bool virt_lines_above;
   bool conceal;
+  bool spell;
   // TODO(bfredl): style, etc
   DecorPriority priority;
   int col;  // fixed col value, like win_col
@@ -61,8 +62,8 @@ struct Decoration {
   bool ui_watched;  // watched for win_extmark
 };
 #define DECORATION_INIT { KV_INITIAL_VALUE, KV_INITIAL_VALUE, 0, kVTEndOfLine, \
-                          kHlModeUnknown, false, false, false, false, DECOR_PRIORITY_BASE, \
-                          0, 0, NULL, 0, 0, 0, 0, 0, false }
+                          kHlModeUnknown, false, false, false, false, false, \
+                          DECOR_PRIORITY_BASE, 0, 0, NULL, 0, 0, 0, 0, 0, false }
 
 typedef struct {
   int start_row;
@@ -90,6 +91,8 @@ typedef struct {
   bool conceal;
   int conceal_char;
   int conceal_attr;
+
+  bool spell;
 } DecorState;
 
 EXTERN DecorState decor_state INIT(= { 0 });
diff --git a/src/nvim/decoration_provider.c b/src/nvim/decoration_provider.c
index 14c1238fa4..a11a4d2b04 100644
--- a/src/nvim/decoration_provider.c
+++ b/src/nvim/decoration_provider.c
@@ -7,6 +7,7 @@
 #include "nvim/decoration.h"
 #include "nvim/decoration_provider.h"
 #include "nvim/highlight.h"
+#include "nvim/lib/kvec.h"
 #include "nvim/lua/executor.h"
 
 static kvec_t(DecorProvider) decor_providers = KV_INITIAL_VALUE;
@@ -14,7 +15,7 @@ static kvec_t(DecorProvider) decor_providers = KV_INITIAL_VALUE;
 #define DECORATION_PROVIDER_INIT(ns_id) (DecorProvider) \
   { ns_id, false, LUA_NOREF, LUA_NOREF, \
     LUA_NOREF, LUA_NOREF, LUA_NOREF, \
-    LUA_NOREF, -1, false }
+    LUA_NOREF, -1, false, false }
 
 static bool decor_provider_invoke(NS ns_id, const char *name, LuaRef ref, Array args,
                                   bool default_true, char **perr)
@@ -47,11 +48,33 @@ static bool decor_provider_invoke(NS ns_id, const char *name, LuaRef ref, Array
   return false;
 }
 
+void decor_providers_invoke_spell(win_T *wp, int start_row, int start_col, int end_row, int end_col,
+                                  char **err)
+{
+  for (size_t i = 0; i < kv_size(decor_providers); i++) {
+    DecorProvider *p = &kv_A(decor_providers, i);
+    if (!p->active) {
+      continue;
+    }
+
+    if (p->spell_nav != LUA_NOREF) {
+      MAXSIZE_TEMP_ARRAY(args, 6);
+      ADD_C(args, INTEGER_OBJ(wp->handle));
+      ADD_C(args, INTEGER_OBJ(wp->w_buffer->handle));
+      ADD_C(args, INTEGER_OBJ(start_row));
+      ADD_C(args, INTEGER_OBJ(start_col));
+      ADD_C(args, INTEGER_OBJ(end_row));
+      ADD_C(args, INTEGER_OBJ(end_col));
+      decor_provider_invoke(p->ns_id, "spell", p->spell_nav, args, true, err);
+    }
+  }
+}
+
 /// For each provider invoke the 'start' callback
 ///
 /// @param[out] providers Decoration providers
 /// @param[out] err       Provider err
-void decor_providers_start(DecorProviders *providers, int type, char **err)
+void decor_providers_start(DecorProviders *providers, char **err)
 {
   kvi_init(*providers);
 
@@ -65,7 +88,6 @@ void decor_providers_start(DecorProviders *providers, int type, char **err)
     if (p->redraw_start != LUA_NOREF) {
       MAXSIZE_TEMP_ARRAY(args, 2);
       ADD_C(args, INTEGER_OBJ((int)display_tick));
-      ADD_C(args, INTEGER_OBJ(type));
       active = decor_provider_invoke(p->ns_id, "start", p->redraw_start, args, true, err);
     } else {
       active = true;
@@ -116,8 +138,8 @@ void decor_providers_invoke_win(win_T *wp, DecorProviders *providers,
 /// @param      row       Row to invoke line callback for
 /// @param[out] has_decor Set when at least one provider invokes a line callback
 /// @param[out] err       Provider error
-void providers_invoke_line(win_T *wp, DecorProviders *providers, int row, bool *has_decor,
-                           char **err)
+void decor_providers_invoke_line(win_T *wp, DecorProviders *providers, int row, bool *has_decor,
+                                 char **err)
 {
   for (size_t k = 0; k < kv_size(*providers); k++) {
     DecorProvider *p = kv_A(*providers, k);
@@ -215,6 +237,7 @@ void decor_provider_clear(DecorProvider *p)
   NLUA_CLEAR_REF(p->redraw_win);
   NLUA_CLEAR_REF(p->redraw_line);
   NLUA_CLEAR_REF(p->redraw_end);
+  NLUA_CLEAR_REF(p->spell_nav);
   p->active = false;
 }
 
diff --git a/src/nvim/decoration_provider.h b/src/nvim/decoration_provider.h
index dd1ed6c581..852b1583b9 100644
--- a/src/nvim/decoration_provider.h
+++ b/src/nvim/decoration_provider.h
@@ -12,6 +12,7 @@ typedef struct {
   LuaRef redraw_line;
   LuaRef redraw_end;
   LuaRef hl_def;
+  LuaRef spell_nav;
   int hl_valid;
   bool hl_cached;
 } DecorProvider;
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 85a0bf2f5f..7846510ad9 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -11,9 +11,11 @@
 
 #include "nvim/arabic.h"
 #include "nvim/buffer.h"
+#include "nvim/buffer_defs.h"
 #include "nvim/charset.h"
 #include "nvim/cursor.h"
 #include "nvim/cursor_shape.h"
+#include "nvim/decoration.h"
 #include "nvim/diff.h"
 #include "nvim/drawline.h"
 #include "nvim/fold.h"
@@ -654,7 +656,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
 
     has_decor = decor_redraw_line(buf, lnum - 1, &decor_state);
 
-    providers_invoke_line(wp, providers, lnum - 1, &has_decor, provider_err);
+    decor_providers_invoke_line(wp, providers, lnum - 1, &has_decor, provider_err);
 
     if (*provider_err) {
       provider_err_virt_text(lnum, *provider_err);
@@ -1646,7 +1648,8 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       ptr++;
 
       if (extra_check) {
-        bool can_spell = true;
+        bool no_plain_buffer = (wp->w_s->b_p_spo_flags & SPO_NPBUFFER) != 0;
+        bool can_spell = !no_plain_buffer;
 
         // Get syntax attribute, unless still at the start of the line
         // (double-wide char that doesn't fit).
@@ -1698,6 +1701,29 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           char_attr = 0;
         }
 
+        if (has_decor && v > 0) {
+          bool selected = (area_active || (area_highlighting && noinvcur
+                                           && (colnr_T)vcol == wp->w_virtcol));
+          int extmark_attr = decor_redraw_col(wp->w_buffer, (colnr_T)v - 1, off,
+                                              selected, &decor_state);
+          if (extmark_attr != 0) {
+            if (!attr_pri) {
+              char_attr = hl_combine_attr(char_attr, extmark_attr);
+            } else {
+              char_attr = hl_combine_attr(extmark_attr, char_attr);
+            }
+          }
+
+          decor_conceal = decor_state.conceal;
+          if (decor_conceal && decor_state.conceal_char) {
+            decor_conceal = 2;  // really??
+          }
+
+          if (decor_state.spell) {
+            can_spell = true;
+          }
+        }
+
         // Check spelling (unless at the end of the line).
         // Only do this when there is no syntax highlighting, the
         // @Spell cluster is not used or the current syntax item
@@ -1706,9 +1732,9 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
         if (has_spell && v >= word_end && v > cur_checked_col) {
           spell_attr = 0;
           if (!attr_pri) {
-            char_attr = syntax_attr;
+            char_attr = hl_combine_attr(char_attr, syntax_attr);
           }
-          if (c != 0 && (!has_syntax || can_spell)) {
+          if (c != 0 && ((!has_syntax && !no_plain_buffer) || can_spell)) {
             char_u *prev_ptr;
             char_u *p;
             int len;
@@ -1781,25 +1807,6 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           char_attr = hl_combine_attr(term_attrs[vcol], char_attr);
         }
 
-        if (has_decor && v > 0) {
-          bool selected = (area_active || (area_highlighting && noinvcur
-                                           && (colnr_T)vcol == wp->w_virtcol));
-          int extmark_attr = decor_redraw_col(wp->w_buffer, (colnr_T)v - 1, off,
-                                              selected, &decor_state);
-          if (extmark_attr != 0) {
-            if (!attr_pri) {
-              char_attr = hl_combine_attr(char_attr, extmark_attr);
-            } else {
-              char_attr = hl_combine_attr(extmark_attr, char_attr);
-            }
-          }
-
-          decor_conceal = decor_state.conceal;
-          if (decor_conceal && decor_state.conceal_char) {
-            decor_conceal = 2;  // really??
-          }
-        }
-
         // Found last space before word: check for line break.
         if (wp->w_p_lbr && c0 == c && vim_isbreak(c)
             && !vim_isbreak((int)(*ptr))) {
diff --git a/src/nvim/drawscreen.c b/src/nvim/drawscreen.c
index 29ff261461..5b83821927 100644
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -539,7 +539,7 @@ int update_screen(int type)
   ui_comp_set_screen_valid(true);
 
   DecorProviders providers;
-  decor_providers_start(&providers, type, &provider_err);
+  decor_providers_start(&providers, &provider_err);
 
   // "start" callback could have changed highlights for global elements
   if (win_check_ns_hl(NULL)) {
diff --git a/src/nvim/extmark.c b/src/nvim/extmark.c
index 8e780f4aaa..290d20b749 100644
--- a/src/nvim/extmark.c
+++ b/src/nvim/extmark.c
@@ -70,7 +70,8 @@ void extmark_set(buf_T *buf, uint32_t ns_id, uint32_t *idp, int row, colnr_T col
         || kv_size(decor->virt_lines)
         || decor->conceal
         || decor_has_sign(decor)
-        || decor->ui_watched) {
+        || decor->ui_watched
+        || decor->spell) {
       decor_full = true;
       decor = xmemdup(decor, sizeof *decor);
     }
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 64b3f69df4..0684db39ba 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -731,6 +731,7 @@ EXTERN char *p_spc;             ///< 'spellcapcheck'
 EXTERN char *p_spf;             ///< 'spellfile'
 EXTERN char *p_spl;             ///< 'spelllang'
 EXTERN char *p_spo;             // 'spelloptions'
+EXTERN unsigned int spo_flags;
 EXTERN char *p_sps;             // 'spellsuggest'
 EXTERN int p_spr;               // 'splitright'
 EXTERN int p_sol;               // 'startofline'
diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 717ca6747b..49adf03aa0 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -2355,6 +2355,7 @@ return {
       secure=true,
       expand=true,
       varname='p_spo',
+      redraw={'current_buffer'},
       defaults={if_true=""}
     },
     {
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 1bdfcbecb9..c226966ef6 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -107,6 +107,7 @@ static char *(p_fdc_values[]) = { "auto", "auto:1", "auto:2", "auto:3", "auto:4"
                                   "auto:6", "auto:7", "auto:8", "auto:9", "0", "1", "2", "3", "4",
                                   "5", "6", "7", "8", "9", NULL };
 static char *(p_cb_values[]) = { "unnamed", "unnamedplus", NULL };
+static char *(p_spo_values[]) = { "camel", "noplainbuffer", NULL };
 static char *(p_icm_values[]) = { "nosplit", "split", NULL };
 static char *(p_jop_values[]) = { "stack", "view", NULL };
 static char *(p_tpf_values[]) = { "BS", "HT", "FF", "ESC", "DEL", "C0", "C1", NULL };
@@ -1125,7 +1126,8 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     // When 'spellcapcheck' is set compile the regexp program.
     errmsg = compile_cap_prog(curwin->w_s);
   } else if (varp == &(curwin->w_s->b_p_spo)) {  // 'spelloptions'
-    if (**varp != NUL && STRCMP("camel", *varp) != 0) {
+    if (opt_strings_flags(curwin->w_s->b_p_spo, p_spo_values, &(curwin->w_s->b_p_spo_flags),
+                          true) != OK) {
       errmsg = e_invarg;
     }
   } else if (varp == &p_sps) {  // 'spellsuggest'
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index c0d05eb799..30e256b37a 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -71,6 +71,7 @@
 #include "nvim/change.h"          // for changed_bytes
 #include "nvim/charset.h"         // for skipwhite, getwhitecols, skipbin
 #include "nvim/cursor.h"          // for get_cursor_line_ptr
+#include "nvim/decoration.h"
 #include "nvim/drawscreen.h"      // for NOT_VALID, redraw_later
 #include "nvim/eval/typval.h"     // for semsg
 #include "nvim/ex_cmds.h"         // for do_sub_msg
@@ -220,7 +221,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
   size_t nrlen = 0;              // found a number first
   size_t wrongcaplen = 0;
   bool count_word = docount;
-  bool use_camel_case = *wp->w_s->b_p_spo != NUL;
+  bool use_camel_case = (wp->w_s->b_p_spo_flags & SPO_CAMEL) != 0;
   bool camel_case = false;
 
   // A word never starts at a space or a control character. Return quickly
@@ -1198,6 +1199,24 @@ bool no_spell_checking(win_T *wp)
   return false;
 }
 
+static void decor_spell_nav_start(win_T *wp)
+{
+  decor_state = (DecorState){ 0 };
+  decor_redraw_reset(wp->w_buffer, &decor_state);
+}
+
+static bool decor_spell_nav_col(win_T *wp, linenr_T lnum, linenr_T *decor_lnum, int col,
+                                char **decor_error)
+{
+  if (*decor_lnum != lnum) {
+    decor_providers_invoke_spell(wp, lnum - 1, col, lnum - 1, -1, decor_error);
+    decor_redraw_line(wp->w_buffer, lnum - 1, &decor_state);
+    *decor_lnum = lnum;
+  }
+  decor_redraw_col(wp->w_buffer, col, col, false, &decor_state);
+  return decor_state.spell;
+}
+
 /// Moves to the next spell error.
 /// "curline" is false for "[s", "]s", "[S" and "]S".
 /// "curline" is true to find word under/after cursor in the same line.
@@ -1216,11 +1235,11 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
   hlf_T attr = HLF_COUNT;
   size_t len;
   int has_syntax = syntax_present(wp);
-  int col;
+  colnr_T col;
   char_u *buf = NULL;
   size_t buflen = 0;
   int skip = 0;
-  int capcol = -1;
+  colnr_T capcol = -1;
   bool found_one = false;
   bool wrapped = false;
 
@@ -1228,6 +1247,8 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
     return 0;
   }
 
+  size_t ret = 0;
+
   // Start looking for bad word at the start of the line, because we can't
   // start halfway through a word, we don't know where it starts or ends.
   //
@@ -1240,6 +1261,19 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
   linenr_T lnum = wp->w_cursor.lnum;
   clearpos(&found_pos);
 
+  char *decor_error = NULL;
+  // Ephemeral extmarks are currently stored in the global decor_state.
+  // When looking for spell errors, we need to:
+  //  - temporarily reset decor_state
+  //  - run the _on_spell_nav decor callback for each line we look at
+  //  - detect if any spell marks are present
+  //  - restore decor_state to the value saved here.
+  // TODO(lewis6991): un-globalize decor_state and allow ephemeral marks to be stored into a
+  // temporary DecorState.
+  DecorState saved_decor_start = decor_state;
+  linenr_T decor_lnum = -1;
+  decor_spell_nav_start(wp);
+
   while (!got_int) {
     char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
 
@@ -1258,10 +1292,10 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
 
     // For checking first word with a capital skip white space.
     if (capcol == 0) {
-      capcol = (int)getwhitecols((char *)line);
+      capcol = (colnr_T)getwhitecols((char *)line);
     } else if (curline && wp == curwin) {
       // For spellbadword(): check if first word needs a capital.
-      col = (int)getwhitecols((char *)line);
+      col = (colnr_T)getwhitecols((char *)line);
       if (check_need_cap(lnum, col)) {
         capcol = col;
       }
@@ -1308,33 +1342,37 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
               || ((colnr_T)(curline
                             ? p - buf + (ptrdiff_t)len
                             : p - buf) > wp->w_cursor.col)) {
-            bool can_spell;
-            if (has_syntax) {
-              col = (int)(p - buf);
-              (void)syn_get_id(wp, lnum, (colnr_T)col,
-                               false, &can_spell, false);
-              if (!can_spell) {
-                attr = HLF_COUNT;
-              }
-            } else {
-              can_spell = true;
+            col = (colnr_T)(p - buf);
+
+            bool can_spell = (wp->w_s->b_p_spo_flags & SPO_NPBUFFER) == 0;
+
+            if (!can_spell) {
+              can_spell = decor_spell_nav_col(wp, lnum, &decor_lnum, col, &decor_error);
+            }
+
+            if (!can_spell && has_syntax) {
+              (void)syn_get_id(wp, lnum, col, false, &can_spell, false);
+            }
+
+            if (!can_spell) {
+              attr = HLF_COUNT;
             }
 
             if (can_spell) {
               found_one = true;
               found_pos = (pos_T) {
                 .lnum = lnum,
-                .col = (int)(p - buf),
+                .col = col,
                 .coladd = 0
               };
               if (dir == FORWARD) {
                 // No need to search further.
                 wp->w_cursor = found_pos;
-                xfree(buf);
                 if (attrp != NULL) {
                   *attrp = attr;
                 }
-                return len;
+                ret = len;
+                goto theend;
               } else if (curline) {
                 // Insert mode completion: put cursor after
                 // the bad word.
@@ -1358,8 +1396,8 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
     if (dir == BACKWARD && found_pos.lnum != 0) {
       // Use the last match in the line (before the cursor).
       wp->w_cursor = found_pos;
-      xfree(buf);
-      return found_len;
+      ret = found_len;
+      goto theend;
     }
 
     if (curline) {
@@ -1429,8 +1467,12 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
     line_breakcheck();
   }
 
+theend:
+  decor_state_free(&decor_state);
+  xfree(decor_error);
+  decor_state = saved_decor_start;
   xfree(buf);
-  return 0;
+  return ret;
 }
 
 // For spell checking: concatenate the start of the following line "line" into
-- 
cgit 


From 74db632c978cc391c70d13673b468f80c452d932 Mon Sep 17 00:00:00 2001
From: Andreas Schneider <asn@cryptomilk.org>
Date: Tue, 8 Feb 2022 18:58:36 +0100
Subject: refactor(term): use const for title and add len to
 buf_set_term_title()

---
 src/nvim/terminal.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 90966bcfad..125e4cb586 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -230,7 +230,7 @@ Terminal *terminal_open(buf_T *buf, TerminalOptions opts)
   set_option_value("wrap", false, NULL, OPT_LOCAL);
   set_option_value("list", false, NULL, OPT_LOCAL);
   if (buf->b_ffname != NULL) {
-    buf_set_term_title(buf, buf->b_ffname);
+    buf_set_term_title(buf, buf->b_ffname, strlen((char *)buf->b_ffname));
   }
   RESET_BINDING(curwin);
   // Reset cursor in current window.
@@ -858,13 +858,13 @@ static int term_movecursor(VTermPos new, VTermPos old, int visible, void *data)
   return 1;
 }
 
-static void buf_set_term_title(buf_T *buf, char *title)
+static void buf_set_term_title(buf_T *buf, const char *title, size_t len)
   FUNC_ATTR_NONNULL_ALL
 {
   Error err = ERROR_INIT;
   dict_set_var(buf->b_vars,
                STATIC_CSTR_AS_STRING("term_title"),
-               STRING_OBJ(cstr_as_string(title)),
+               STRING_OBJ(((String){ .data = (char *)title, .size = len })),
                false,
                false,
                &err);
@@ -887,7 +887,7 @@ static int term_settermprop(VTermProp prop, VTermValue *val, void *data)
 
   case VTERM_PROP_TITLE: {
     buf_T *buf = handle_get_buffer(term->buf_handle);
-    buf_set_term_title(buf, val->string);
+    buf_set_term_title(buf, val->string, strlen(val->string));
     break;
   }
 
-- 
cgit 


From 12afc344deb2df3973904fe55813d700da985dbf Mon Sep 17 00:00:00 2001
From: dundargoc <33953936+dundargoc@users.noreply.github.com>
Date: Tue, 6 Sep 2022 16:23:00 +0200
Subject: refactor: migrate comment style 2 #20080

---
 src/nvim/buffer_defs.h  |  16 +++----
 src/nvim/edit.c         |  12 ++---
 src/nvim/file_search.c  |  92 +++++++++++++++++---------------------
 src/nvim/fileio.c       |  83 +++++++++++++++++------------------
 src/nvim/hardcopy.c     |  36 +++++++--------
 src/nvim/mark_defs.h    |   2 +-
 src/nvim/memline.c      |   2 +-
 src/nvim/memline_defs.h |   2 +-
 src/nvim/ops.c          |  33 +++++++-------
 src/nvim/option_defs.h  |   2 +-
 src/nvim/path.c         | 114 ++++++++++++++++++++++++------------------------
 src/nvim/sign_defs.h    |   2 +-
 src/nvim/spellfile.c    |   2 +-
 src/nvim/strings.c      |   8 ++--
 src/nvim/window.c       |   4 +-
 15 files changed, 196 insertions(+), 214 deletions(-)

(limited to 'src')

diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index a520f3c0e7..3019a1323c 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -789,8 +789,8 @@ struct file_buffer {
   int b_ind_cpp_extern_c;
   int b_ind_pragma;
 
-  linenr_T b_no_eol_lnum;       /* non-zero lnum when last line of next binary
-                                 * write should not have an end-of-line */
+  linenr_T b_no_eol_lnum;       // non-zero lnum when last line of next binary
+                                // write should not have an end-of-line
 
   int b_start_eol;              // last line had eol when it was read
   int b_start_ffc;              // first char of 'ff' when edit started
@@ -805,8 +805,8 @@ struct file_buffer {
   // then set to indicate that a swap file may be opened later.  It is reset
   // if a swap file could not be opened.
   bool b_may_swap;
-  bool b_did_warn;              /* Set to true if user has been warned on first
-                                   change of a read-only file */
+  bool b_did_warn;              // Set to true if user has been warned on first
+                                // change of a read-only file
 
   // Two special kinds of buffers:
   // help buffer  - used for help files, won't use a swap file.
@@ -1237,8 +1237,7 @@ struct window_S {
   // w_valid is a bitfield of flags, which indicate if specific values are
   // valid or need to be recomputed.
   int w_valid;
-  pos_T w_valid_cursor;             /* last known position of w_cursor, used
-                                       to adjust w_valid */
+  pos_T w_valid_cursor;             // last known position of w_cursor, used to adjust w_valid
   colnr_T w_valid_leftcol;          // last known w_leftcol
 
   bool w_viewport_invalid;
@@ -1383,8 +1382,7 @@ struct window_S {
   int w_fraction;
   int w_prev_fraction_row;
 
-  linenr_T w_nrwidth_line_count;        /* line count when ml_nrwidth_width
-                                         * was computed. */
+  linenr_T w_nrwidth_line_count;        // line count when ml_nrwidth_width was computed.
   int w_nrwidth_width;                  // nr of chars to print line count.
 
   qf_info_T *w_llist;                 // Location list for this window
@@ -1407,4 +1405,4 @@ struct window_S {
 #define CHANGEDTICK(buf) \
   (=== Include buffer.h & use buf_(get|set|inc) _changedtick ===)
 
-#endif // NVIM_BUFFER_DEFS_H
+#endif  // NVIM_BUFFER_DEFS_H
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index b85d349726..b20fc7d44a 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -2330,8 +2330,8 @@ static void stop_insert(pos_T *end_insert_pos, int esc, int nomove)
         if (gchar_cursor() != NUL) {
           inc_cursor();
         }
-        /* If the cursor is still at the same character, also keep
-         * the "coladd". */
+        // If the cursor is still at the same character, also keep
+        // the "coladd".
         if (gchar_cursor() == NUL
             && curwin->w_cursor.lnum == tpos.lnum
             && curwin->w_cursor.col == tpos.col) {
@@ -3165,8 +3165,8 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
         if (keytyped == KEY_COMPLETE) {
           char_u *n, *s;
 
-          /* Just completed a word, check if it starts with "look".
-           * search back for the start of a word. */
+          // Just completed a word, check if it starts with "look".
+          // search back for the start of a word.
           line = (char_u *)get_cursor_line_ptr();
           for (s = line + curwin->w_cursor.col; s > line; s = n) {
             n = mb_prevptr(line, s);
@@ -3198,8 +3198,8 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           }
         }
         if (match && try_match_word && !try_match) {
-          /* "0=word": Check if there are only blanks before the
-           * word. */
+          // "0=word": Check if there are only blanks before the
+          // word.
           if (getwhitecols_curline() !=
               (int)(curwin->w_cursor.col - (p - look))) {
             match = false;
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index a604c5ff3e..76a429b5ef 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -75,9 +75,8 @@ static char_u *ff_expand_buffer = NULL;  // used for expanding filenames
 typedef struct ff_stack {
   struct ff_stack *ffs_prev;
 
-  /* the fix part (no wildcards) and the part containing the wildcards
-   * of the search path
-   */
+  // the fix part (no wildcards) and the part containing the wildcards
+  // of the search path
   char_u *ffs_fix_path;
   char_u *ffs_wc_path;
 
@@ -87,15 +86,13 @@ typedef struct ff_stack {
   int ffs_filearray_size;
   int ffs_filearray_cur;                  // needed for partly handled dirs
 
-  /* to store status of partly handled directories
-   * 0: we work on this directory for the first time
-   * 1: this directory was partly searched in an earlier step
-   */
+  // to store status of partly handled directories
+  // 0: we work on this directory for the first time
+  // 1: this directory was partly searched in an earlier step
   int ffs_stage;
 
-  /* How deep are we in the directory tree?
-   * Counts backward from value of level parameter to vim_findfile_init
-   */
+  // How deep are we in the directory tree?
+  // Counts backward from value of level parameter to vim_findfile_init
   int ffs_level;
 
   // Did we already expand '**' to an empty string?
@@ -242,9 +239,8 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
   ff_stack_T *sptr;
   ff_search_ctx_T *search_ctx;
 
-  /* If a search context is given by the caller, reuse it, else allocate a
-   * new one.
-   */
+  // If a search context is given by the caller, reuse it, else allocate a
+  // new one.
   if (search_ctx_arg != NULL) {
     search_ctx = search_ctx_arg;
   } else {
@@ -260,9 +256,9 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
   if (free_visited == true) {
     vim_findfile_free_visited(search_ctx);
   } else {
-    /* Reuse old visited lists. Get the visited list for the given
-     * filename. If no list for the current filename exists, creates a new
-     * one. */
+    // Reuse old visited lists. Get the visited list for the given
+    // filename. If no list for the current filename exists, creates a new
+    // one.
     search_ctx->ffsc_visited_list = ff_get_visited_list((char_u *)filename,
                                                         &search_ctx->ffsc_visited_lists_list);
     if (search_ctx->ffsc_visited_list == NULL) {
@@ -279,8 +275,8 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     ff_expand_buffer = xmalloc(MAXPATHL);
   }
 
-  /* Store information on starting dir now if path is relative.
-   * If path is absolute, we do that later.  */
+  // Store information on starting dir now if path is relative.
+  // If path is absolute, we do that later.
   if (path[0] == '.'
       && (vim_ispathsep(path[1]) || path[1] == NUL)
       && (!tagfile || vim_strchr(p_cpo, CPO_DOTTAG) == NULL)
@@ -321,8 +317,8 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     search_ctx->ffsc_start_dir = (char *)vim_strsave(ff_expand_buffer);
 
 #ifdef BACKSLASH_IN_FILENAME
-    /* A path that starts with "/dir" is relative to the drive, not to the
-     * directory (but not for "//machine/dir").  Only use the drive name. */
+    // A path that starts with "/dir" is relative to the drive, not to the
+    // directory (but not for "//machine/dir").  Only use the drive name.
     if ((*path == '/' || *path == '\\')
         && path[1] != path[0]
         && search_ctx->ffsc_start_dir[1] == ':') {
@@ -362,9 +358,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
         search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrnsave(helper, (size_t)(walker - helper));
         walker++;
       } else {
-        /* this might be "", which means ascent till top
-         * of directory tree.
-         */
+        // this might be "", which means ascent till top of directory tree.
         search_ctx->ffsc_stopdirs_v[dircount - 1] = xstrdup(helper);
       }
 
@@ -375,10 +369,9 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
 
   search_ctx->ffsc_level = level;
 
-  /* split into:
-   *  -fix path
-   *  -wildcard_stuff (might be NULL)
-   */
+  // split into:
+  //  -fix path
+  //  -wildcard_stuff (might be NULL)
   wc_part = vim_strchr(path, '*');
   if (wc_part != NULL) {
     int64_t llevel;
@@ -433,9 +426,8 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
   }
 
   if (search_ctx->ffsc_start_dir == NULL) {
-    /* store the fix part as startdir.
-     * This is needed if the parameter path is fully qualified.
-     */
+    // store the fix part as startdir.
+    // This is needed if the parameter path is fully qualified.
     search_ctx->ffsc_start_dir = xstrdup(search_ctx->ffsc_fix_path);
     search_ctx->ffsc_fix_path[0] = NUL;
   }
@@ -513,8 +505,8 @@ char_u *vim_findfile_stopdir(char_u *buf)
 
   while (*r_ptr != NUL && *r_ptr != ';') {
     if (r_ptr[0] == '\\' && r_ptr[1] == ';') {
-      /* Overwrite the escape char,
-       * use STRLEN(r_ptr) to move the trailing '\0'. */
+      // Overwrite the escape char,
+      // use STRLEN(r_ptr) to move the trailing '\0'.
       STRMOVE(r_ptr, r_ptr + 1);
       r_ptr++;
     }
@@ -653,9 +645,7 @@ char_u *vim_findfile(void *search_ctx_arg)
       if (stackp->ffs_filearray == NULL) {
         char *dirptrs[2];
 
-        /* we use filepath to build the path expand_wildcards() should
-         * expand.
-         */
+        // we use filepath to build the path expand_wildcards() should expand.
         dirptrs[0] = (char *)file_path;
         dirptrs[1] = NULL;
 
@@ -742,9 +732,9 @@ char_u *vim_findfile(void *search_ctx_arg)
           stackp->ffs_filearray[0] = xstrdup(dirptrs[0]);
           stackp->ffs_filearray_size = 1;
         } else {
-          /* Add EW_NOTWILD because the expanded path may contain
-           * wildcard characters that are to be taken literally.
-           * This is a bit of a hack. */
+          // Add EW_NOTWILD because the expanded path may contain
+          // wildcard characters that are to be taken literally.
+          // This is a bit of a hack.
           expand_wildcards((dirptrs[1] == NULL) ? 1 : 2, dirptrs,
                            &stackp->ffs_filearray_size,
                            &stackp->ffs_filearray,
@@ -886,9 +876,8 @@ char_u *vim_findfile(void *search_ctx_arg)
       ff_free_stack_element(stackp);
     }
 
-    /* If we reached this, we didn't find anything downwards.
-     * Let's check if we should do an upward search.
-     */
+    // If we reached this, we didn't find anything downwards.
+    // Let's check if we should do an upward search.
     if (search_ctx->ffsc_start_dir
         && search_ctx->ffsc_stopdirs_v != NULL && !got_int) {
       ff_stack_T *sptr;
@@ -1157,8 +1146,8 @@ static ff_stack_T *ff_create_stack_element(char_u *fix_part, char_u *wc_part, in
 /// Push a dir on the directory stack.
 static void ff_push(ff_search_ctx_T *search_ctx, ff_stack_T *stack_ptr)
 {
-  /* check for NULL pointer, not to return an error to the user, but
-   * to prevent a crash */
+  // check for NULL pointer, not to return an error to the user, but
+  // to prevent a crash
   if (stack_ptr != NULL) {
     stack_ptr->ffs_prev = search_ctx->ffsc_stack_ptr;
     search_ctx->ffsc_stack_ptr = stack_ptr;
@@ -1251,10 +1240,9 @@ static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
 
   for (i = 0; stopdirs_v[i] != NULL; i++) {
     if ((int)STRLEN(stopdirs_v[i]) > path_len) {
-      /* match for parent directory. So '/home' also matches
-       * '/home/rks'. Check for PATHSEP in stopdirs_v[i], else
-       * '/home/r' would also match '/home/rks'
-       */
+      // match for parent directory. So '/home' also matches
+      // '/home/rks'. Check for PATHSEP in stopdirs_v[i], else
+      // '/home/r' would also match '/home/rks'
       if (FNAMENCMP(stopdirs_v[i], path, path_len) == 0
           && vim_ispathsep(stopdirs_v[i][path_len])) {
         return true;
@@ -1407,8 +1395,8 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
         goto theend;
       }
 
-      /* When FNAME_REL flag given first use the directory of the file.
-       * Otherwise or when this fails use the current directory. */
+      // When FNAME_REL flag given first use the directory of the file.
+      // Otherwise or when this fails use the current directory.
       for (int run = 1; run <= 2; run++) {
         size_t l = STRLEN(ff_file_to_find);
         if (run == 1
@@ -1424,8 +1412,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
           run = 2;
         }
 
-        /* When the file doesn't exist, try adding parts of
-         * 'suffixesadd'. */
+        // When the file doesn't exist, try adding parts of 'suffixesadd'.
         buf = (char *)suffixes;
         for (;;) {
           if (
@@ -1467,8 +1454,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
         char_u *r_ptr;
 
         if (dir == NULL || *dir == NUL) {
-          /* We searched all paths of the option, now we can
-           * free the search context. */
+          // We searched all paths of the option, now we can free the search context.
           vim_findfile_cleanup(fdip_search_ctx);
           fdip_search_ctx = NULL;
           break;
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index a29a0efe40..b399885095 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -82,12 +82,12 @@
 #define FIO_UCSBOM     0x4000  // check for BOM at start of file
 #define FIO_ALL        (-1)    // allow all formats
 
-/* When converting, a read() or write() may leave some bytes to be converted
- * for the next call.  The value is guessed... */
+// When converting, a read() or write() may leave some bytes to be converted
+// for the next call.  The value is guessed...
 #define CONV_RESTLEN 30
 
-/* We have to guess how much a sequence of bytes may expand when converting
- * with iconv() to be able to allocate a buffer. */
+// We have to guess how much a sequence of bytes may expand when converting
+// with iconv() to be able to allocate a buffer.
 #define ICONV_MULT 8
 
 // Structure to pass arguments from buf_write() to buf_write_bytes().
@@ -2091,8 +2091,8 @@ static void check_marks_read(void)
     shada_read_marks();
   }
 
-  /* Always set b_marks_read; needed when 'shada' is changed to include
-   * the ' parameter after opening a buffer. */
+  // Always set b_marks_read; needed when 'shada' is changed to include
+  // the ' parameter after opening a buffer.
   curbuf->b_marks_read = true;
 }
 
@@ -2177,8 +2177,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   int wb_flags = 0;
 #endif
 #ifdef HAVE_ACL
-  vim_acl_T acl = NULL;                 /* ACL copied from original file to
-                                           backup or new file */
+  vim_acl_T acl = NULL;                 // ACL copied from original file to
+                                        // backup or new file
 #endif
   int write_undo_file = false;
   context_sha256_T sha_ctx;
@@ -2190,8 +2190,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
     return FAIL;
   }
   if (buf->b_ml.ml_mfp == NULL) {
-    /* This can happen during startup when there is a stray "w" in the
-     * vimrc file. */
+    // This can happen during startup when there is a stray "w" in the
+    // vimrc file.
     emsg(_(e_emptybuf));
     return FAIL;
   }
@@ -2217,8 +2217,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   write_info.bw_iconv_fd = (iconv_t)-1;
 #endif
 
-  /* After writing a file changedtick changes but we don't want to display
-   * the line. */
+  // After writing a file changedtick changes but we don't want to display
+  // the line.
   ex_no_reprint = true;
 
   // If there is no file name yet, use the one for the written file.
@@ -2318,9 +2318,9 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
                                      sfname, sfname, false, curbuf, eap);
       if (did_cmd) {
         if (was_changed && !curbufIsChanged()) {
-          /* Written everything correctly and BufWriteCmd has reset
-           * 'modified': Correct the undo information so that an
-           * undo now sets 'modified'. */
+          // Written everything correctly and BufWriteCmd has reset
+          // 'modified': Correct the undo information so that an
+          // undo now sets 'modified'.
           u_unchanged(curbuf);
           u_update_save_nr(curbuf);
         }
@@ -2371,14 +2371,14 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 
       if (nofile_err
           || aborting()) {
-        /* An aborting error, interrupt or exception in the
-         * autocommands. */
+        // An aborting error, interrupt or exception in the
+        // autocommands.
         return FAIL;
       }
       if (did_cmd) {
         if (buf == NULL) {
-          /* The buffer was deleted.  We assume it was written
-           * (can't retry anyway). */
+          // The buffer was deleted.  We assume it was written
+          // (can't retry anyway).
           return OK;
         }
         if (overwriting) {
@@ -2488,8 +2488,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
         SET_ERRMSG_NUM("E503", _("is not a file or writable device"));
         goto fail;
       }
-      /* It's a device of some kind (or a fifo) which we can write to
-       * but for which we can't make a backup. */
+      // It's a device of some kind (or a fifo) which we can write to
+      // but for which we can't make a backup.
       device = true;
       newfile = true;
       perm = -1;
@@ -2616,8 +2616,8 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
             backup_copy = true;
           }
 #endif
-          /* Close the file before removing it, on MS-Windows we
-           * can't delete an open file. */
+          // Close the file before removing it, on MS-Windows we
+          // can't delete an open file.
           close(fd);
           os_remove((char *)IObuff);
         }
@@ -3433,8 +3433,8 @@ restore_backup:
     set_keep_msg(msg_trunc_attr((char *)IObuff, false, 0), 0);
   }
 
-  /* When written everything correctly: reset 'modified'.  Unless not
-   * writing to the original file and '+' is not in 'cpoptions'. */
+  // When written everything correctly: reset 'modified'.  Unless not
+  // writing to the original file and '+' is not in 'cpoptions'.
   if (reset_changed && whole && !append
       && !write_info.bw_conv_error
       && (overwriting || vim_strchr(p_cpo, CPO_PLUS) != NULL)) {
@@ -3815,9 +3815,9 @@ static int buf_write_bytes(struct bw_info *ip)
         if (wlen == 0 && ip->bw_restlen != 0) {
           int l;
 
-          /* Use remainder of previous call.  Append the start of
-           * buf[] to get a full sequence.  Might still be too
-           * short! */
+          // Use remainder of previous call.  Append the start of
+          // buf[] to get a full sequence.  Might still be too
+          // short!
           l = CONV_RESTLEN - ip->bw_restlen;
           if (l > len) {
             l = len;
@@ -3825,9 +3825,9 @@ static int buf_write_bytes(struct bw_info *ip)
           memmove(ip->bw_rest + ip->bw_restlen, buf, (size_t)l);
           n = utf_ptr2len_len(ip->bw_rest, ip->bw_restlen + l);
           if (n > ip->bw_restlen + len) {
-            /* We have an incomplete byte sequence at the end to
-             * be written.  We can't convert it without the
-             * remaining bytes.  Keep them for the next call. */
+            // We have an incomplete byte sequence at the end to
+            // be written.  We can't convert it without the
+            // remaining bytes.  Keep them for the next call.
             if (ip->bw_restlen + len > CONV_RESTLEN) {
               return FAIL;
             }
@@ -3851,9 +3851,9 @@ static int buf_write_bytes(struct bw_info *ip)
         } else {
           n = utf_ptr2len_len(buf + wlen, len - wlen);
           if (n > len - wlen) {
-            /* We have an incomplete byte sequence at the end to
-             * be written.  We can't convert it without the
-             * remaining bytes.  Keep them for the next call. */
+            // We have an incomplete byte sequence at the end to
+            // be written.  We can't convert it without the
+            // remaining bytes.  Keep them for the next call.
             if (len - wlen > CONV_RESTLEN) {
               return FAIL;
             }
@@ -3896,9 +3896,9 @@ static int buf_write_bytes(struct bw_info *ip)
       if (ip->bw_restlen > 0) {
         char *fp;
 
-        /* Need to concatenate the remainder of the previous call and
-         * the bytes of the current call.  Use the end of the
-         * conversion buffer for this. */
+        // Need to concatenate the remainder of the previous call and
+        // the bytes of the current call.  Use the end of the
+        // conversion buffer for this.
         fromlen = (size_t)len + (size_t)ip->bw_restlen;
         fp = (char *)ip->bw_conv_buf + ip->bw_conv_buflen - fromlen;
         memmove(fp, ip->bw_rest, (size_t)ip->bw_restlen);
@@ -3918,9 +3918,8 @@ static int buf_write_bytes(struct bw_info *ip)
         // output the initial shift state sequence
         (void)iconv(ip->bw_iconv_fd, NULL, NULL, &to, &tolen);
 
-        /* There is a bug in iconv() on Linux (which appears to be
-         * wide-spread) which sets "to" to NULL and messes up "tolen".
-         */
+        // There is a bug in iconv() on Linux (which appears to be
+        // wide-spread) which sets "to" to NULL and messes up "tolen".
         if (to == NULL) {
           to = (char *)ip->bw_conv_buf;
           tolen = save_len;
@@ -3984,8 +3983,8 @@ static bool ucs2bytes(unsigned c, char_u **pp, int flags) FUNC_ATTR_NONNULL_ALL
   } else if (flags & (FIO_UCS2 | FIO_UTF16)) {
     if (c >= 0x10000) {
       if (flags & FIO_UTF16) {
-        /* Make two words, ten bits of the character in each.  First
-         * word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff */
+        // Make two words, ten bits of the character in each.  First
+        // word is 0xd800 - 0xdbff, second one 0xdc00 - 0xdfff
         c -= 0x10000;
         if (c >= 0x100000) {
           error = true;
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index e280648fd2..85f59f39de 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -176,8 +176,8 @@ struct prt_ps_font_S {
   char *(ps_fontname[4]);
 };
 
-/* Structures to map user named encoding and mapping to PS equivalents for
- * building CID font name */
+// Structures to map user named encoding and mapping to PS equivalents for
+// building CID font name
 struct prt_ps_encoding_S {
   char *encoding;
   char *cmap_encoding;
@@ -235,8 +235,8 @@ struct prt_dsc_line_S {
   int len;
 };
 
-/* Static buffer to read initial comments in a resource file, some can have a
- * couple of KB of comments! */
+// Static buffer to read initial comments in a resource file, some can have a
+// couple of KB of comments!
 #define PRT_FILE_BUFFER_LEN (2048)
 struct prt_resfile_buffer_S {
   char_u buffer[PRT_FILE_BUFFER_LEN];
@@ -1162,16 +1162,15 @@ static struct prt_ps_mbfont_S prt_ps_mbfonts[] =
   }
 };
 
-/* The PS prolog file version number has to match - if the prolog file is
- * updated, increment the number in the file and here.  Version checking was
- * added as of VIM 6.2.
- * The CID prolog file version number behaves as per PS prolog.
- * Table of VIM and prolog versions:
- *
- * VIM      Prolog  CIDProlog
- * 6.2      1.3
- * 7.0      1.4     1.0
- */
+// The PS prolog file version number has to match - if the prolog file is
+// updated, increment the number in the file and here.  Version checking was
+// added as of VIM 6.2.
+// The CID prolog file version number behaves as per PS prolog.
+// Table of VIM and prolog versions:
+//
+// VIM      Prolog  CIDProlog
+// 6.2      1.3
+// 7.0      1.4     1.0
 #define PRT_PROLOG_VERSION  ((char_u *)"1.4")
 #define PRT_CID_PROLOG_VERSION  ((char_u *)"1.0")
 
@@ -1182,8 +1181,8 @@ static struct prt_ps_mbfont_S prt_ps_mbfonts[] =
 #define PRT_RESOURCE_ENCODING       "Encoding"
 #define PRT_RESOURCE_CMAP           "CMap"
 
-/* Data for table based DSC comment recognition, easy to extend if VIM needs to
- * read more comments. */
+// Data for table based DSC comment recognition, easy to extend if VIM needs to
+// read more comments.
 #define PRT_DSC_MISC_TYPE           (-1)
 #define PRT_DSC_TITLE_TYPE          (1)
 #define PRT_DSC_VERSION_TYPE        (2)
@@ -1573,8 +1572,9 @@ static int prt_resfile_skip_ws(int offset)
   return -1;
 }
 
-/* prt_next_dsc() - returns detail on next DSC comment line found.  Returns true
- * if a DSC comment is found, else false */
+/// Returns detail on next DSC comment line found.
+///
+/// @return  true if a DSC comment is found, else false
 static bool prt_next_dsc(struct prt_dsc_line_S *p_dsc_line)
   FUNC_ATTR_NONNULL_ALL
 {
diff --git a/src/nvim/mark_defs.h b/src/nvim/mark_defs.h
index 3e3a46cd20..f9df0028db 100644
--- a/src/nvim/mark_defs.h
+++ b/src/nvim/mark_defs.h
@@ -86,4 +86,4 @@ typedef struct xfilemark {
 
 #define INIT_XFMARK { INIT_FMARK, NULL }
 
-#endif // NVIM_MARK_DEFS_H
+#endif  // NVIM_MARK_DEFS_H
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index 35650755b4..c5e8e3da07 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1161,7 +1161,7 @@ theend:
     }
     mf_close(mfp, false);           // will also xfree(mfp->mf_fname)
   }
-  if (buf != NULL) {  //may be NULL if swap file not found.
+  if (buf != NULL) {  // may be NULL if swap file not found.
     xfree(buf->b_ml.ml_stack);
     xfree(buf);
   }
diff --git a/src/nvim/memline_defs.h b/src/nvim/memline_defs.h
index 922a2c98d1..552ec1e3a9 100644
--- a/src/nvim/memline_defs.h
+++ b/src/nvim/memline_defs.h
@@ -69,4 +69,4 @@ typedef struct memline {
   int ml_usedchunks;
 } memline_T;
 
-#endif // NVIM_MEMLINE_DEFS_H
+#endif  // NVIM_MEMLINE_DEFS_H
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 25b957e3b9..5d505f41a2 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -681,9 +681,9 @@ void op_reindent(oparg_T *oap, Indenter how)
   curwin->w_cursor.lnum = start_lnum;
   beginline(BL_SOL | BL_FIX);
 
-  /* Mark changed lines so that they will be redrawn.  When Visual
-   * highlighting was present, need to continue until the last line.  When
-   * there is no change still need to remove the Visual highlighting. */
+  // Mark changed lines so that they will be redrawn.  When Visual
+  // highlighting was present, need to continue until the last line.  When
+  // there is no change still need to remove the Visual highlighting.
   if (last_changed != 0) {
     changed_lines(first_changed, 0,
                   oap->is_VIsual ? start_lnum + (linenr_T)oap->line_count :
@@ -748,12 +748,12 @@ char_u *get_expr_line(void)
     return NULL;
   }
 
-  /* Make a copy of the expression, because evaluating it may cause it to be
-   * changed. */
+  // Make a copy of the expression, because evaluating it may cause it to be
+  // changed.
   expr_copy = vim_strsave(expr_line);
 
-  /* When we are invoked recursively limit the evaluation to 10 levels.
-   * Then return the string as-is. */
+  // When we are invoked recursively limit the evaluation to 10 levels.
+  // Then return the string as-is.
   if (nested >= 10) {
     return expr_copy;
   }
@@ -1431,8 +1431,8 @@ bool cmdline_paste_reg(int regname, bool literally_arg, bool remcr)
       cmdline_paste_str((char_u *)"\r", literally);
     }
 
-    /* Check for CTRL-C, in case someone tries to paste a few thousand
-     * lines and gets bored. */
+    // Check for CTRL-C, in case someone tries to paste a few thousand
+    // lines and gets bored.
     os_breakcheck();
     if (got_int) {
       return FAIL;
@@ -2677,8 +2677,7 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
         if (virtual_op) {
           getvcol(curwin, &oap->start, &cs, NULL, &ce);
           if (ce != cs && oap->start.coladd > 0) {
-            /* Part of a tab selected -- but don't
-             * double-count it. */
+            // Part of a tab selected -- but don't double-count it.
             bd.startspaces = (ce - cs + 1)
                              - oap->start.coladd;
             startcol++;
@@ -3043,9 +3042,9 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
   if (insert_string != NULL) {
     y_type = kMTCharWise;
     if (regname == '=') {
-      /* For the = register we need to split the string at NL
-       * characters.
-       * Loop twice: count the number of lines and save them. */
+      // For the = register we need to split the string at NL
+      // characters.
+      // Loop twice: count the number of lines and save them.
       for (;;) {
         y_size = 0;
         ptr = insert_string;
@@ -3285,9 +3284,9 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         delcount = 1;
         bd.textcol -= utf_head_off(oldp, oldp + bd.textcol);
         if (oldp[bd.textcol] != TAB) {
-          /* Only a Tab can be split into spaces.  Other
-           * characters will have to be moved to after the
-           * block, causing misalignment. */
+          // Only a Tab can be split into spaces.  Other
+          // characters will have to be moved to after the
+          // block, causing misalignment.
           delcount = 0;
           bd.endspaces = 0;
         }
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 0684db39ba..031a853c0c 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -990,4 +990,4 @@ typedef struct {
   uint64_t channel_id;     /// Only used when script_id is SID_API_CLIENT.
 } LastSet;
 
-#endif // NVIM_OPTION_DEFS_H
+#endif  // NVIM_OPTION_DEFS_H
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 1e5fa49ad6..2646b9e75e 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -625,8 +625,8 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   char_u *e = NULL;
   const char_u *path_end = path;
   while (*path_end != NUL) {
-    /* May ignore a wildcard that has a backslash before it; it will
-     * be removed by rem_backslash() or file_pat_to_reg_pat() below. */
+    // May ignore a wildcard that has a backslash before it; it will
+    // be removed by rem_backslash() or file_pat_to_reg_pat() below.
     if (path_end >= path + wildoff && rem_backslash((char *)path_end)) {
       *p++ = *path_end++;
     } else if (vim_ispathsep_nocolon(*path_end)) {
@@ -651,8 +651,8 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   *e = NUL;
 
   // Now we have one wildcard component between "s" and "e".
-  /* Remove backslashes between "wildoff" and the start of the wildcard
-   * component. */
+  // Remove backslashes between "wildoff" and the start of the wildcard
+  // component.
   for (p = buf + wildoff; p < s; p++) {
     if (rem_backslash((char *)p)) {
       STRMOVE(p, p + 1);
@@ -698,8 +698,8 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
     return 0;
   }
 
-  /* If "**" is by itself, this is the first time we encounter it and more
-   * is following then find matches without any directory. */
+  // If "**" is by itself, this is the first time we encounter it and more
+  // is following then find matches without any directory.
   if (!didstar && stardepth < 100 && starstar && e - s == 2
       && *path_end == '/') {
     STRCPY(s, path_end + 1);
@@ -728,9 +728,9 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
         len = STRLEN(buf);
 
         if (starstar && stardepth < 100) {
-          /* For "**" in the pattern first go deeper in the tree to
-           * find matches. */
-          STRCPY(buf + len, "/**");
+          // For "**" in the pattern first go deeper in the tree to
+          // find matches.
+          STRCPY(buf + len, "/**");  // NOLINT
           STRCPY(buf + len + 3, path_end);
           stardepth++;
           (void)do_path_expand(gap, buf, len + 1, flags, true);
@@ -835,9 +835,9 @@ static void expand_path_option(char_u *curdir, garray_T *gap)
     copy_option_part((char **)&path_option, (char *)buf, MAXPATHL, " ,");
 
     if (buf[0] == '.' && (buf[1] == NUL || vim_ispathsep(buf[1]))) {
-      /* Relative to current buffer:
-       * "/path/file" + "." -> "/path/"
-       * "/path/file"  + "./subdir" -> "/path/subdir" */
+      // Relative to current buffer:
+      // "/path/file" + "." -> "/path/"
+      // "/path/file"  + "./subdir" -> "/path/subdir"
       if (curbuf->b_ffname == NULL) {
         continue;
       }
@@ -1028,8 +1028,8 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
       continue;
     }
 
-    /* If the {filename} is not unique, change it to ./{filename}.
-     * Else reduce it to {filename} */
+    // If the {filename} is not unique, change it to ./{filename}.
+    // Else reduce it to {filename}
     short_name = path_shorten_fname(path, curdir);
     if (short_name == NULL) {
       short_name = path;
@@ -1278,8 +1278,8 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
                  && (vim_ispathsep(p[1])
                      || (p[1] == '.'
                          && vim_ispathsep(p[2]))))) {
-          /* :find completion where 'path' is used.
-           * Recursiveness is OK here. */
+          // :find completion where 'path' is used.
+          // Recursiveness is OK here.
           recursive = false;
           add_pat = expand_in_path(&ga, p, flags);
           recursive = true;
@@ -1295,8 +1295,8 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
     if (add_pat == -1 || (add_pat == 0 && (flags & EW_NOTFOUND))) {
       char_u *t = (char_u *)backslash_halve_save((char *)p);
 
-      /* When EW_NOTFOUND is used, always add files and dirs.  Makes
-       * "vim c:/" work. */
+      // When EW_NOTFOUND is used, always add files and dirs.  Makes
+      // "vim c:/" work.
       if (flags & EW_NOTFOUND) {
         addfile(&ga, t, flags | EW_DIR | EW_FILE);
       } else {
@@ -1505,8 +1505,8 @@ void simplify_filename(char_u *filename)
   start = p;        // remember start after "c:/" or "/" or "///"
 
   do {
-    /* At this point "p" is pointing to the char following a single "/"
-     * or "p" is at the "start" of the (absolute or relative) path name. */
+    // At this point "p" is pointing to the char following a single "/"
+    // or "p" is at the "start" of the (absolute or relative) path name.
     if (vim_ispathsep(*p)) {
       STRMOVE(p, p + 1);                // remove duplicate "/"
     } else if (p[0] == '.'
@@ -1514,10 +1514,10 @@ void simplify_filename(char_u *filename)
       if (p == start && relative) {
         p += 1 + (p[1] != NUL);         // keep single "." or leading "./"
       } else {
-        /* Strip "./" or ".///".  If we are at the end of the file name
-         * and there is no trailing path separator, either strip "/." if
-         * we are after "start", or strip "." if we are at the beginning
-         * of an absolute path name . */
+        // Strip "./" or ".///".  If we are at the end of the file name
+        // and there is no trailing path separator, either strip "/." if
+        // we are after "start", or strip "." if we are at the beginning
+        // of an absolute path name.
         tail = p + 1;
         if (p[1] != NUL) {
           while (vim_ispathsep(*tail)) {
@@ -1542,9 +1542,9 @@ void simplify_filename(char_u *filename)
 
         // Don't strip for an erroneous file name.
         if (!stripping_disabled) {
-          /* If the preceding component does not exist in the file
-           * system, we strip it.  On Unix, we don't accept a symbolic
-           * link that refers to a non-existent file. */
+          // If the preceding component does not exist in the file
+          // system, we strip it.  On Unix, we don't accept a symbolic
+          // link that refers to a non-existent file.
           saved_char = p[-1];
           p[-1] = NUL;
           FileInfo file_info;
@@ -1560,16 +1560,16 @@ void simplify_filename(char_u *filename)
           }
 
           if (!do_strip) {
-            /* If the component exists in the file system, check
-             * that stripping it won't change the meaning of the
-             * file name.  First get information about the
-             * unstripped file name.  This may fail if the component
-             * to strip is not a searchable directory (but a regular
-             * file, for instance), since the trailing "/.." cannot
-             * be applied then.  We don't strip it then since we
-             * don't want to replace an erroneous file name by
-             * a valid one, and we disable stripping of later
-             * components. */
+            // If the component exists in the file system, check
+            // that stripping it won't change the meaning of the
+            // file name.  First get information about the
+            // unstripped file name.  This may fail if the component
+            // to strip is not a searchable directory (but a regular
+            // file, for instance), since the trailing "/.." cannot
+            // be applied then.  We don't strip it then since we
+            // don't want to replace an erroneous file name by
+            // a valid one, and we disable stripping of later
+            // components.
             saved_char = *tail;
             *tail = NUL;
             if (os_fileinfo((char *)filename, &file_info)) {
@@ -1579,13 +1579,13 @@ void simplify_filename(char_u *filename)
             }
             *tail = saved_char;
             if (do_strip) {
-              /* The check for the unstripped file name
-               * above works also for a symbolic link pointing to
-               * a searchable directory.  But then the parent of
-               * the directory pointed to by the link must be the
-               * same as the stripped file name.  (The latter
-               * exists in the file system since it is the
-               * component's parent directory.) */
+              // The check for the unstripped file name
+              // above works also for a symbolic link pointing to
+              // a searchable directory.  But then the parent of
+              // the directory pointed to by the link must be the
+              // same as the stripped file name.  (The latter
+              // exists in the file system since it is the
+              // component's parent directory.)
               FileInfo new_file_info;
               if (p == start && relative) {
                 os_fileinfo(".", &new_file_info);
@@ -1598,26 +1598,26 @@ void simplify_filename(char_u *filename)
 
               if (!os_fileinfo_id_equal(&file_info, &new_file_info)) {
                 do_strip = false;
-                /* We don't disable stripping of later
-                 * components since the unstripped path name is
-                 * still valid. */
+                // We don't disable stripping of later
+                // components since the unstripped path name is
+                // still valid.
               }
             }
           }
         }
 
         if (!do_strip) {
-          /* Skip the ".." or "../" and reset the counter for the
-           * components that might be stripped later on. */
+          // Skip the ".." or "../" and reset the counter for the
+          // components that might be stripped later on.
           p = tail;
           components = 0;
         } else {
-          /* Strip previous component.  If the result would get empty
-           * and there is no trailing path separator, leave a single
-           * "." instead.  If we are at the end of the file name and
-           * there is no trailing path separator and a preceding
-           * component is left after stripping, strip its trailing
-           * path separator as well. */
+          // Strip previous component.  If the result would get empty
+          // and there is no trailing path separator, leave a single
+          // "." instead.  If we are at the end of the file name and
+          // there is no trailing path separator and a preceding
+          // component is left after stripping, strip its trailing
+          // path separator as well.
           if (p == start && relative && tail[-1] == '.') {
             *p++ = '.';
             *p = NUL;
@@ -1699,8 +1699,8 @@ char *find_file_name_in_path(char *ptr, size_t len, int options, long count, cha
       ptr[len] = c;
     }
 
-    /* Repeat finding the file "count" times.  This matters when it
-     * appears several times in the path. */
+    // Repeat finding the file "count" times.  This matters when it
+    // appears several times in the path.
     while (file_name != NULL && --count > 0) {
       xfree(file_name);
       file_name =
diff --git a/src/nvim/sign_defs.h b/src/nvim/sign_defs.h
index 1efde30008..f1184202e7 100644
--- a/src/nvim/sign_defs.h
+++ b/src/nvim/sign_defs.h
@@ -51,4 +51,4 @@ typedef enum {
   SIGN_TEXT,
 } SignType;
 
-#endif // NVIM_SIGN_DEFS_H
+#endif  // NVIM_SIGN_DEFS_H
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index c472cac27d..661ca54fad 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -1994,7 +1994,7 @@ static void spell_print_tree(wordnode_T *root)
   }
 }
 
-#endif // SPELL_PRINTTREE
+#endif  // SPELL_PRINTTREE
 
 // Reads the affix file "fname".
 // Returns an afffile_T, NULL for complete failure.
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 12bfa35dd6..d7a0472cbf 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -180,10 +180,10 @@ char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_n
   int csh_like;
   bool fish_like;
 
-  /* Only csh and similar shells expand '!' within single quotes.  For sh and
-   * the like we must not put a backslash before it, it will be taken
-   * literally.  If do_special is set the '!' will be escaped twice.
-   * Csh also needs to have "\n" escaped twice when do_special is set. */
+  // Only csh and similar shells expand '!' within single quotes.  For sh and
+  // the like we must not put a backslash before it, it will be taken
+  // literally.  If do_special is set the '!' will be escaped twice.
+  // Csh also needs to have "\n" escaped twice when do_special is set.
   csh_like = csh_like_shell();
 
   // Fish shell uses '\' as an escape character within single quotes, so '\'
diff --git a/src/nvim/window.c b/src/nvim/window.c
index 530cbc0c7b..ca97ae6184 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -2048,7 +2048,7 @@ static int get_maximum_wincount(frame_T *fr, int height)
 }
 
 /// Make all windows the same height.
-///'next_curwin' will soon be the current window, make sure it has enough rows.
+/// 'next_curwin' will soon be the current window, make sure it has enough rows.
 ///
 /// @param next_curwin  pointer to current window to be or NULL
 /// @param current  do only frame with current window
@@ -5524,7 +5524,7 @@ static void frame_setheight(frame_T *curfrp, int height)
       }
       frame_setheight(curfrp->fr_parent, height
                       + frame_minheight(curfrp->fr_parent, NOWIN) - (int)p_wmh - 1);
-      //NOTREACHED
+      // NOTREACHED
     }
 
     // Compute the number of lines we will take from others frames (can be
-- 
cgit 


From 87e037e26cfd53c3c34ac9029a8833023af60a56 Mon Sep 17 00:00:00 2001
From: Shougo <Shougo.Matsu@gmail.com>
Date: Tue, 6 Sep 2022 23:33:25 +0900
Subject: fix(cmdheight=0): various issues part3 #19816

And fixed in https://github.com/neovim/neovim/pull/19801 regression.

Fix #19834
Fix #19184
---
 src/nvim/getchar.c | 1 +
 src/nvim/message.c | 2 +-
 src/nvim/window.c  | 6 ------
 3 files changed, 2 insertions(+), 7 deletions(-)

(limited to 'src')

diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index 22c350d36b..e125d88395 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1698,6 +1698,7 @@ static void getchar_common(typval_T *argvars, typval_T *rettv)
   if (!ui_has_messages()) {
     // redraw the screen after getchar()
     update_screen(UPD_NOT_VALID);
+    clear_cmdline = true;
   }
 
   set_vim_var_nr(VV_MOUSE_WIN, 0);
diff --git a/src/nvim/message.c b/src/nvim/message.c
index d43c04b652..63012900df 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -2350,7 +2350,7 @@ bool msg_use_msgsep(void)
 {
   // the full-screen scroll behavior doesn't really make sense with
   // 'ext_multigrid'
-  return ((dy_flags & DY_MSGSEP) || ui_has(kUIMultigrid));
+  return (dy_flags & DY_MSGSEP) || ui_has(kUIMultigrid);
 }
 
 bool msg_do_throttle(void)
diff --git a/src/nvim/window.c b/src/nvim/window.c
index ca97ae6184..a6cc53080b 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -6270,12 +6270,6 @@ void command_height(void)
   // p_ch was changed in another tab page.
   curtab->tp_ch_used = p_ch;
 
-  // If the space for the command line is already more than 'cmdheight' there
-  // is nothing to do (window size must have decreased).
-  if (p_ch > old_p_ch && cmdline_row <= Rows - p_ch) {
-    return;
-  }
-
   // If cmdline_row is smaller than what it is supposed to be for 'cmdheight'
   // then set old_p_ch to what it would be, so that the windows get resized
   // properly for the new value.
-- 
cgit 


From 73207cae611a1efb8cd17139e8228772daeb9866 Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/api/buffer.c          |   6 +-
 src/nvim/api/private/helpers.c |   4 +-
 src/nvim/arglist.c             |   2 +-
 src/nvim/autocmd.c             |   2 +-
 src/nvim/change.c              |   4 +-
 src/nvim/charset.c             |   4 +-
 src/nvim/cmdexpand.c           |  81 +++++++++++------------
 src/nvim/cmdhist.c             |   8 +--
 src/nvim/cursor.c              |  15 ++---
 src/nvim/diff.c                |  39 ++++++-----
 src/nvim/digraph.c             |   6 +-
 src/nvim/drawline.c            |  10 +--
 src/nvim/edit.c                |  68 ++++++++++----------
 src/nvim/eval.c                |  18 +++---
 src/nvim/eval/funcs.c          |  54 ++++++++--------
 src/nvim/eval/typval.c         |   2 +-
 src/nvim/eval/typval.h         |  15 ++---
 src/nvim/eval/userfunc.c       |  48 +++++++-------
 src/nvim/ex_cmds.c             |  14 ++--
 src/nvim/ex_docmd.c            |  10 +--
 src/nvim/ex_eval.c             |   2 +-
 src/nvim/ex_getln.c            |  16 ++---
 src/nvim/file_search.c         | 100 ++++++++++++++--------------
 src/nvim/fileio.c              |  24 +++----
 src/nvim/fold.c                |   8 +--
 src/nvim/getchar.c             |  44 ++++++-------
 src/nvim/globals.h             |   2 +-
 src/nvim/hardcopy.c            |   2 +-
 src/nvim/help.c                |  15 ++---
 src/nvim/highlight_group.c     |   6 +-
 src/nvim/if_cscope.c           |  10 +--
 src/nvim/indent.c              |   8 +--
 src/nvim/indent_c.c            |   6 +-
 src/nvim/insexpand.c           |  94 +++++++++++++--------------
 src/nvim/lua/converter.c       |   8 +--
 src/nvim/lua/stdlib.c          |   2 +-
 src/nvim/lua/treesitter.c      |   2 +-
 src/nvim/macros.h              |   2 +-
 src/nvim/mapping.c             |  74 ++++++++++-----------
 src/nvim/mapping.h             |   2 +-
 src/nvim/mark.c                |  12 ++--
 src/nvim/match.c               |   6 +-
 src/nvim/mbyte.c               |  32 ++++-----
 src/nvim/memfile.c             |  12 ++--
 src/nvim/memfile_defs.h        |   2 +-
 src/nvim/memline.c             |  76 +++++++++++-----------
 src/nvim/mouse.c               |   2 +-
 src/nvim/normal.c              |  26 ++++----
 src/nvim/ops.c                 |  54 ++++++++--------
 src/nvim/option.c              |  62 +++++++++---------
 src/nvim/optionstr.c           |   2 +-
 src/nvim/os/env.c              |   6 +-
 src/nvim/os/shell.c            |  10 +--
 src/nvim/path.c                |  77 +++++++++++-----------
 src/nvim/plines.c              |   4 +-
 src/nvim/quickfix.c            |  12 ++--
 src/nvim/regexp.c              |  64 +++++++++---------
 src/nvim/regexp_bt.c           |   4 +-
 src/nvim/regexp_defs.h         |   2 +-
 src/nvim/regexp_nfa.c          |   6 +-
 src/nvim/screen.c              |   2 +-
 src/nvim/search.c              |  36 +++++------
 src/nvim/shada.c               |   2 +-
 src/nvim/spell.c               |  30 ++++-----
 src/nvim/spell_defs.h          |   6 +-
 src/nvim/spellfile.c           | 143 ++++++++++++++++++++---------------------
 src/nvim/spellsuggest.c        |  32 ++++-----
 src/nvim/statusline.c          |  22 +++----
 src/nvim/strings.c             |  15 ++---
 src/nvim/syntax.c              |   8 +--
 src/nvim/tag.c                 |  99 ++++++++++++++--------------
 src/nvim/tag.h                 |   2 +-
 src/nvim/textformat.c          |  28 ++++----
 src/nvim/textobject.c          |   4 +-
 src/nvim/undo.c                |  12 ++--
 75 files changed, 867 insertions(+), 882 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/buffer.c b/src/nvim/api/buffer.c
index 16f574f46d..6f8cad3e33 100644
--- a/src/nvim/api/buffer.c
+++ b/src/nvim/api/buffer.c
@@ -570,7 +570,7 @@ void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, Integer start_row, In
   char *str_at_end = NULL;
 
   // Another call to ml_get_buf() may free the line, so make a copy.
-  str_at_start = xstrdup((char *)ml_get_buf(buf, (linenr_T)start_row, false));
+  str_at_start = xstrdup(ml_get_buf(buf, (linenr_T)start_row, false));
   size_t len_at_start = strlen(str_at_start);
   if (start_col < 0 || (size_t)start_col > len_at_start) {
     api_set_error(err, kErrorTypeValidation, "start_col out of bounds");
@@ -578,7 +578,7 @@ void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, Integer start_row, In
   }
 
   // Another call to ml_get_buf() may free the line, so make a copy.
-  str_at_end = xstrdup((char *)ml_get_buf(buf, (linenr_T)end_row, false));
+  str_at_end = xstrdup(ml_get_buf(buf, (linenr_T)end_row, false));
   size_t len_at_end = strlen(str_at_end);
   if (end_col < 0 || (size_t)end_col > len_at_end) {
     api_set_error(err, kErrorTypeValidation, "end_col out of bounds");
@@ -608,7 +608,7 @@ void nvim_buf_set_text(uint64_t channel_id, Buffer buffer, Integer start_row, In
     for (int64_t i = 1; i < end_row - start_row; i++) {
       int64_t lnum = start_row + i;
 
-      const char *bufline = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
+      const char *bufline = ml_get_buf(buf, (linenr_T)lnum, false);
       old_byte += (bcount_t)(strlen(bufline)) + 1;
     }
     old_byte += (bcount_t)end_col + 1;
diff --git a/src/nvim/api/private/helpers.c b/src/nvim/api/private/helpers.c
index ebcf6cca6d..22d2ffbaf1 100644
--- a/src/nvim/api/private/helpers.c
+++ b/src/nvim/api/private/helpers.c
@@ -466,7 +466,7 @@ bool buf_collect_lines(buf_T *buf, size_t n, int64_t start, bool replace_nl, Arr
       return false;
     }
 
-    const char *bufstr = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
+    const char *bufstr = ml_get_buf(buf, (linenr_T)lnum, false);
     Object str = STRING_OBJ(cstr_to_string(bufstr));
 
     if (replace_nl) {
@@ -499,7 +499,7 @@ String buf_get_text(buf_T *buf, int64_t lnum, int64_t start_col, int64_t end_col
     return rv;
   }
 
-  const char *bufstr = (char *)ml_get_buf(buf, (linenr_T)lnum, false);
+  const char *bufstr = ml_get_buf(buf, (linenr_T)lnum, false);
   size_t line_length = strlen(bufstr);
 
   start_col = start_col < 0 ? (int64_t)line_length + start_col + 1 : start_col;
diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index e6ac1f6247..0000636417 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -86,7 +86,7 @@ void alist_expand(int *fnum_list, int fnum_len)
   // can't set the options.
   p_su = empty_option;
   for (int i = 0; i < GARGCOUNT; i++) {
-    old_arg_files[i] = vim_strsave(GARGLIST[i].ae_fname);
+    old_arg_files[i] = xstrdup(GARGLIST[i].ae_fname);
   }
   int old_arg_count = GARGCOUNT;
   char **new_arg_files;
diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 1c1de214cd..635875b16f 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -2214,7 +2214,7 @@ bool has_autocmd(event_T event, char *sfname, buf_T *buf)
 #ifdef BACKSLASH_IN_FILENAME
   // Replace all backslashes with forward slashes. This makes the
   // autocommand patterns portable between Unix and Windows.
-  sfname = vim_strsave(sfname);
+  sfname = xstrdup(sfname);
   forward_slash(sfname);
   forward_slash(fname);
 #endif
diff --git a/src/nvim/change.c b/src/nvim/change.c
index 5e9edac4f2..f4568fc617 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -774,7 +774,7 @@ int del_char(bool fixpos)
 int del_chars(long count, int fixpos)
 {
   int bytes = 0;
-  char *p = (char *)get_cursor_pos_ptr();
+  char *p = get_cursor_pos_ptr();
   for (long i = 0; i < count && *p != NUL; i++) {
     int l = utfc_ptr2len(p);
     bytes += l;
@@ -1036,7 +1036,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
   colnr_T mincol = curwin->w_cursor.col + 1;
 
   // make a copy of the current line so we can mess with it
-  char *saved_line = (char *)vim_strsave((char_u *)get_cursor_line_ptr());
+  char *saved_line = xstrdup(get_cursor_line_ptr());
 
   if (State & VREPLACE_FLAG) {
     // With MODE_VREPLACE we make a copy of the next line, which we will be
diff --git a/src/nvim/charset.c b/src/nvim/charset.c
index 3396e2de41..693ff90179 100644
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -913,7 +913,7 @@ void getvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *en
   int ts = (int)wp->w_buffer->b_p_ts;
 
   colnr_T vcol = 0;
-  char *line = ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false);  // start of the line
+  char *line = ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);  // start of the line
 
   if (pos->col == MAXCOL) {
     // continue until the NUL
@@ -1076,7 +1076,7 @@ void getvvcol(win_T *wp, pos_T *pos, colnr_T *start, colnr_T *cursor, colnr_T *e
     colnr_T endadd = 0;
 
     // Cannot put the cursor on part of a wide character.
-    char *ptr = (char *)ml_get_buf(wp->w_buffer, pos->lnum, false);
+    char *ptr = ml_get_buf(wp->w_buffer, pos->lnum, false);
 
     if (pos->col < (colnr_T)STRLEN(ptr)) {
       int c = utf_ptr2char(ptr + pos->col);
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 30e734b93f..3f624c77f3 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -183,7 +183,7 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
 
   if (type == WILD_NEXT || type == WILD_PREV) {
     // Get next/previous match for a previous expanded pattern.
-    p2 = ExpandOne(xp, NULL, NULL, 0, type);
+    p2 = (char_u *)ExpandOne(xp, NULL, NULL, 0, type);
   } else {
     // Translate string into pattern and expand it.
     p1 = (char_u *)addstar(xp->xp_pattern, xp->xp_pattern_len, xp->xp_context);
@@ -193,8 +193,8 @@ int nextwild(expand_T *xp, int type, int options, bool escape)
                              | WILD_SILENT
                              | (escape ? WILD_ESCAPE : 0)
                              | (p_wic ? WILD_ICASE : 0));
-    p2 = ExpandOne(xp, p1, (char_u *)xstrnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
-                   use_options, type);
+    p2 = (char_u *)ExpandOne(xp, (char *)p1, xstrnsave(&ccline->cmdbuff[i], xp->xp_pattern_len),
+                             use_options, type);
     xfree(p1);
 
     // xp->xp_pattern might have been modified by ExpandOne (for example,
@@ -278,7 +278,7 @@ void cmdline_pum_cleanup(CmdlineInfo *cclp)
 
 /// Get the next or prev cmdline completion match. The index of the match is set
 /// in "p_findex"
-static char_u *get_next_or_prev_match(int mode, expand_T *xp, int *p_findex, char_u *orig_save)
+static char *get_next_or_prev_match(int mode, expand_T *xp, int *p_findex, char *orig_save)
 {
   if (xp->xp_numfiles <= 0) {
     return NULL;
@@ -318,17 +318,17 @@ static char_u *get_next_or_prev_match(int mode, expand_T *xp, int *p_findex, cha
   }
   *p_findex = findex;
 
-  return vim_strsave(findex == -1 ? orig_save : (char_u *)xp->xp_files[findex]);
+  return xstrdup(findex == -1 ? orig_save : xp->xp_files[findex]);
 }
 
 /// Start the command-line expansion and get the matches.
-static char_u *ExpandOne_start(int mode, expand_T *xp, char_u *str, int options)
+static char *ExpandOne_start(int mode, expand_T *xp, char *str, int options)
 {
   int non_suf_match;  // number without matching suffix
-  char_u *ss = NULL;
+  char *ss = NULL;
 
   // Do the expansion.
-  if (ExpandFromContext(xp, str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
+  if (ExpandFromContext(xp, (char_u *)str, &xp->xp_numfiles, &xp->xp_files, options) == FAIL) {
 #ifdef FNAME_ILLEGAL
     // Illegal file name has been silently skipped.  But when there
     // are wildcards, the real problem is that there was no match,
@@ -343,7 +343,7 @@ static char_u *ExpandOne_start(int mode, expand_T *xp, char_u *str, int options)
     }
   } else {
     // Escape the matches for use on the command line.
-    ExpandEscape(xp, str, xp->xp_numfiles, xp->xp_files, options);
+    ExpandEscape(xp, (char_u *)str, xp->xp_numfiles, xp->xp_files, options);
 
     // Check for matching suffixes in file names.
     if (mode != WILD_ALL && mode != WILD_ALL_KEEP
@@ -378,7 +378,7 @@ static char_u *ExpandOne_start(int mode, expand_T *xp, char_u *str, int options)
         }
       }
       if (!(non_suf_match != 1 && mode == WILD_EXPAND_FREE)) {
-        ss = vim_strsave((char_u *)xp->xp_files[0]);
+        ss = xstrdup(xp->xp_files[0]);
       }
     }
   }
@@ -458,11 +458,11 @@ static char *find_longest_match(expand_T *xp, int options)
 /// The variables xp->xp_context and xp->xp_backslash must have been set!
 ///
 /// @param orig  allocated copy of original of expanded string
-char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode)
+char *ExpandOne(expand_T *xp, char *str, char *orig, int options, int mode)
 {
-  char_u *ss = NULL;
+  char *ss = NULL;
   static int findex;
-  static char_u *orig_save = NULL;      // kept value of orig
+  static char *orig_save = NULL;      // kept value of orig
   int orig_saved = false;
   int i;
 
@@ -472,10 +472,11 @@ char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode
   }
 
   if (mode == WILD_CANCEL) {
-    ss = vim_strsave(orig_save ? orig_save : (char_u *)"");
+    ss = xstrdup(orig_save ? orig_save : "");
   } else if (mode == WILD_APPLY) {
-    ss = vim_strsave(findex == -1 ? (orig_save ? orig_save : (char_u *)"")
-                     : (char_u *)xp->xp_files[findex]);
+    ss = xstrdup(findex == -1
+                 ? (orig_save ? orig_save : "")
+                 : xp->xp_files[findex]);
   }
 
   // free old names
@@ -500,7 +501,7 @@ char_u *ExpandOne(expand_T *xp, char_u *str, char_u *orig, int options, int mode
 
   // Find longest common part
   if (mode == WILD_LONGEST && xp->xp_numfiles > 0) {
-    ss = (char_u *)find_longest_match(xp, options);
+    ss = find_longest_match(xp, options);
     findex = -1;  // next p_wc gets first one
   }
 
@@ -1915,7 +1916,7 @@ int expand_cmdline(expand_T *xp, char_u *str, int col, int *matchcount, char ***
 }
 
 /// Expand file or directory names.
-static int expand_files_and_dirs(expand_T *xp, char_u *pat, char ***file, int *num_file, int flags,
+static int expand_files_and_dirs(expand_T *xp, char *pat, char ***file, int *num_file, int flags,
                                  int options)
 {
   bool free_pat = false;
@@ -1923,7 +1924,7 @@ static int expand_files_and_dirs(expand_T *xp, char_u *pat, char ***file, int *n
   // for ":set path=" and ":set tags=" halve backslashes for escaped space
   if (xp->xp_backslash != XP_BS_NONE) {
     free_pat = true;
-    pat = vim_strsave(pat);
+    pat = xstrdup(pat);
     for (int i = 0; pat[i]; i++) {
       if (pat[i] == '\\') {
         if (xp->xp_backslash == XP_BS_THREE
@@ -2124,7 +2125,7 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
   if (xp->xp_context == EXPAND_FILES
       || xp->xp_context == EXPAND_DIRECTORIES
       || xp->xp_context == EXPAND_FILES_IN_PATH) {
-    return expand_files_and_dirs(xp, pat, file, num_file, flags, options);
+    return expand_files_and_dirs(xp, (char *)pat, file, num_file, flags, options);
   }
 
   *file = NULL;
@@ -2142,7 +2143,7 @@ static int ExpandFromContext(expand_T *xp, char_u *pat, int *num_file, char ***f
 
   if (xp->xp_context == EXPAND_SHELLCMD) {
     *file = NULL;
-    expand_shellcmd(pat, num_file, file, flags);
+    expand_shellcmd((char *)pat, num_file, file, flags);
     return OK;
   }
   if (xp->xp_context == EXPAND_OLD_SETTING) {
@@ -2238,18 +2239,18 @@ static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, cha
 {
   int i;
   size_t count = 0;
-  char_u *str;
+  char *str;
 
   // count the number of matching names
   for (i = 0;; i++) {
-    str = (char_u *)(*func)(xp, i);
+    str = (*func)(xp, i);
     if (str == NULL) {  // end of list
       break;
     }
     if (*str == NUL) {  // skip empty strings
       continue;
     }
-    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
+    if (vim_regexec(regmatch, str, (colnr_T)0)) {
       count++;
     }
   }
@@ -2263,20 +2264,20 @@ static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, cha
   // copy the matching names into allocated memory
   count = 0;
   for (i = 0;; i++) {
-    str = (char_u *)(*func)(xp, i);
+    str = (*func)(xp, i);
     if (str == NULL) {  // End of list.
       break;
     }
     if (*str == NUL) {  // Skip empty strings.
       continue;
     }
-    if (vim_regexec(regmatch, (char *)str, (colnr_T)0)) {
+    if (vim_regexec(regmatch, str, (colnr_T)0)) {
       if (escaped) {
-        str = vim_strsave_escaped(str, (char_u *)" \t\\.");
+        str = (char *)vim_strsave_escaped((char_u *)str, (char_u *)" \t\\.");
       } else {
-        str = vim_strsave(str);
+        str = xstrdup(str);
       }
-      (*file)[count++] = (char *)str;
+      (*file)[count++] = str;
       if (func == get_menu_names) {
         // Test for separator added by get_menu_names().
         str += STRLEN(str) - 1;
@@ -2313,22 +2314,22 @@ static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, cha
 ///                      *file will either be set to NULL or point to
 ///                      allocated memory.
 /// @param      flagsarg is a combination of EW_* flags.
-static void expand_shellcmd(char_u *filepat, int *num_file, char ***file, int flagsarg)
+static void expand_shellcmd(char *filepat, int *num_file, char ***file, int flagsarg)
   FUNC_ATTR_NONNULL_ALL
 {
-  char_u *pat;
+  char *pat;
   int i;
-  char_u *path = NULL;
+  char *path = NULL;
   garray_T ga;
   char *buf = xmalloc(MAXPATHL);
   size_t l;
-  char_u *s, *e;
+  char *s, *e;
   int flags = flagsarg;
   int ret;
   bool did_curdir = false;
 
   // for ":set path=" and ":set tags=" halve backslashes for escaped space
-  pat = vim_strsave(filepat);
+  pat = xstrdup(filepat);
   for (i = 0; pat[i]; i++) {
     if (pat[i] == '\\' && pat[i + 1] == ' ') {
       STRMOVE(pat + i, pat + i + 1);
@@ -2340,14 +2341,14 @@ static void expand_shellcmd(char_u *filepat, int *num_file, char ***file, int fl
   bool mustfree = false;  // Track memory allocation for *path.
   if (pat[0] == '.' && (vim_ispathsep(pat[1])
                         || (pat[1] == '.' && vim_ispathsep(pat[2])))) {
-    path = (char_u *)".";
+    path = ".";
   } else {
     // For an absolute name we don't use $PATH.
-    if (!path_is_absolute(pat)) {
-      path = (char_u *)vim_getenv("PATH");
+    if (!path_is_absolute((char_u *)pat)) {
+      path = vim_getenv("PATH");
     }
     if (path == NULL) {
-      path = (char_u *)"";
+      path = "";
     } else {
       mustfree = true;
     }
@@ -2360,7 +2361,7 @@ static void expand_shellcmd(char_u *filepat, int *num_file, char ***file, int fl
   hashtab_T found_ht;
   hash_init(&found_ht);
   for (s = path;; s = e) {
-    e = (char_u *)vim_strchr((char *)s, ENV_SEPCHAR);
+    e = vim_strchr(s, ENV_SEPCHAR);
     if (e == NULL) {
       e = s + STRLEN(s);
     }
@@ -2895,7 +2896,7 @@ void f_getcompletion(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
 theend:
   pat = (char_u *)addstar(xpc.xp_pattern, xpc.xp_pattern_len, xpc.xp_context);
-  ExpandOne(&xpc, pat, NULL, options, WILD_ALL_KEEP);
+  ExpandOne(&xpc, (char *)pat, NULL, options, WILD_ALL_KEEP);
   tv_list_alloc_ret(rettv, xpc.xp_numfiles);
 
   for (int i = 0; i < xpc.xp_numfiles; i++) {
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 629c47f24a..38353f44b5 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -382,13 +382,13 @@ static int calc_hist_idx(int histype, int num)
 /// Get a history entry by its index.
 ///
 /// @param histype  may be one of the HIST_ values.
-static char_u *get_history_entry(int histype, int idx)
+static char *get_history_entry(int histype, int idx)
 {
   idx = calc_hist_idx(histype, idx);
   if (idx >= 0) {
-    return (char_u *)history[histype][idx].hisstr;
+    return history[histype][idx].hisstr;
   } else {
-    return (char_u *)"";
+    return "";
   }
 }
 
@@ -556,7 +556,7 @@ void f_histget(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       idx = (int)tv_get_number_chk(&argvars[1], NULL);
     }
     // -1 on type error
-    rettv->vval.v_string = (char *)vim_strsave(get_history_entry(type, idx));
+    rettv->vval.v_string = xstrdup(get_history_entry(type, idx));
   }
   rettv->v_type = VAR_STRING;
 }
diff --git a/src/nvim/cursor.c b/src/nvim/cursor.c
index 2a3fe9701c..cd651fcf4c 100644
--- a/src/nvim/cursor.c
+++ b/src/nvim/cursor.c
@@ -101,7 +101,7 @@ static int coladvance2(pos_T *pos, bool addspaces, bool finetune, colnr_T wcol_a
                  || (VIsual_active && *p_sel != 'o')
                  || ((get_ve_flags() & VE_ONEMORE) && wcol < MAXCOL);
 
-  char_u *line = ml_get_buf(curbuf, pos->lnum, false);
+  char_u *line = (char_u *)ml_get_buf(curbuf, pos->lnum, false);
 
   if (wcol >= MAXCOL) {
     idx = (int)STRLEN(line) - 1 + one_more;
@@ -308,7 +308,7 @@ void check_pos(buf_T *buf, pos_T *pos)
   }
 
   if (pos->col > 0) {
-    char_u *line = ml_get_buf(buf, pos->lnum, false);
+    char_u *line = (char_u *)ml_get_buf(buf, pos->lnum, false);
     colnr_T len = (colnr_T)STRLEN(line);
     if (pos->col > len) {
       pos->col = len;
@@ -481,7 +481,7 @@ bool leftcol_changed(void)
 
 int gchar_cursor(void)
 {
-  return utf_ptr2char((char *)get_cursor_pos_ptr());
+  return utf_ptr2char(get_cursor_pos_ptr());
 }
 
 /// Write a character at the current cursor position.
@@ -489,18 +489,17 @@ int gchar_cursor(void)
 void pchar_cursor(char_u c)
 {
   *(ml_get_buf(curbuf, curwin->w_cursor.lnum, true)
-    + curwin->w_cursor.col) = c;
+    + curwin->w_cursor.col) = (char)c;
 }
 
 /// @return  pointer to cursor line.
 char *get_cursor_line_ptr(void)
 {
-  return (char *)ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
+  return ml_get_buf(curbuf, curwin->w_cursor.lnum, false);
 }
 
 /// @return  pointer to cursor position.
-char_u *get_cursor_pos_ptr(void)
+char *get_cursor_pos_ptr(void)
 {
-  return ml_get_buf(curbuf, curwin->w_cursor.lnum, false) +
-         curwin->w_cursor.col;
+  return ml_get_buf(curbuf, curwin->w_cursor.lnum, false) + curwin->w_cursor.col;
 }
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index a3046bb7d7..69883966ab 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -573,9 +573,9 @@ static void diff_check_unchanged(tabpage_T *tp, diff_T *dp)
       if (dir == BACKWARD) {
         off_org = dp->df_count[i_org] - 1;
       }
-      char *line_org = (char *)vim_strsave(ml_get_buf(tp->tp_diffbuf[i_org],
-                                                      dp->df_lnum[i_org] + off_org,
-                                                      false));
+      char *line_org = xstrdup(ml_get_buf(tp->tp_diffbuf[i_org],
+                                          dp->df_lnum[i_org] + off_org,
+                                          false));
 
       int i_new;
       for (i_new = i_org + 1; i_new < DB_COUNT; i_new++) {
@@ -592,9 +592,9 @@ static void diff_check_unchanged(tabpage_T *tp, diff_T *dp)
           break;
         }
 
-        if (diff_cmp((char_u *)line_org, ml_get_buf(tp->tp_diffbuf[i_new],
-                                                    dp->df_lnum[i_new] + off_new,
-                                                    false)) != 0) {
+        if (diff_cmp((char_u *)line_org, (char_u *)ml_get_buf(tp->tp_diffbuf[i_new],
+                                                              dp->df_lnum[i_new] + off_new,
+                                                              false)) != 0) {
           break;
         }
       }
@@ -750,7 +750,7 @@ static int diff_write_buffer(buf_T *buf, diffin_T *din)
 
   len = 0;
   for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
-    for (char_u *s = ml_get_buf(buf, lnum, false); *s != NUL;) {
+    for (char_u *s = (char_u *)ml_get_buf(buf, lnum, false); *s != NUL;) {
       if (diff_flags & DIFF_ICASE) {
         int c;
         char cbuf[MB_MAXBYTES + 1];
@@ -824,9 +824,9 @@ static void diff_try_update(diffio_T *dio, int idx_orig, exarg_T *eap)
     ga_init(&dio->dio_diff.dout_ga, sizeof(char *), 1000);
   } else {
     // We need three temp file names.
-    dio->dio_orig.din_fname = vim_tempname();
-    dio->dio_new.din_fname = vim_tempname();
-    dio->dio_diff.dout_fname = vim_tempname();
+    dio->dio_orig.din_fname = (char_u *)vim_tempname();
+    dio->dio_new.din_fname = (char_u *)vim_tempname();
+    dio->dio_diff.dout_fname = (char_u *)vim_tempname();
     if (dio->dio_orig.din_fname == NULL
         || dio->dio_new.din_fname == NULL
         || dio->dio_diff.dout_fname == NULL) {
@@ -1178,9 +1178,9 @@ void ex_diffpatch(exarg_T *eap)
 
   // We need two temp file names.
   // Name of original temp file.
-  char_u *tmp_orig = vim_tempname();
+  char_u *tmp_orig = (char_u *)vim_tempname();
   // Name of patched temp file.
-  char_u *tmp_new = vim_tempname();
+  char_u *tmp_new = (char_u *)vim_tempname();
 
   if ((tmp_orig == NULL) || (tmp_new == NULL)) {
     goto theend;
@@ -1920,11 +1920,11 @@ static bool diff_equal_entry(diff_T *dp, int idx1, int idx2)
   }
 
   for (int i = 0; i < dp->df_count[idx1]; i++) {
-    char *line = (char *)vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx1],
-                                                dp->df_lnum[idx1] + i, false));
+    char *line = xstrdup(ml_get_buf(curtab->tp_diffbuf[idx1],
+                                    dp->df_lnum[idx1] + i, false));
 
-    int cmp = diff_cmp((char_u *)line, ml_get_buf(curtab->tp_diffbuf[idx2],
-                                                  dp->df_lnum[idx2] + i, false));
+    int cmp = diff_cmp((char_u *)line, (char_u *)ml_get_buf(curtab->tp_diffbuf[idx2],
+                                                            dp->df_lnum[idx2] + i, false));
     xfree(line);
 
     if (cmp != 0) {
@@ -2290,7 +2290,7 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
   int l;
 
   // Make a copy of the line, the next ml_get() will invalidate it.
-  char *line_org = (char *)vim_strsave(ml_get_buf(wp->w_buffer, lnum, false));
+  char *line_org = xstrdup(ml_get_buf(wp->w_buffer, lnum, false));
 
   int idx = diff_buf_idx(wp->w_buffer);
   if (idx == DB_COUNT) {
@@ -2322,8 +2322,7 @@ bool diff_find_change(win_T *wp, linenr_T lnum, int *startp, int *endp)
         continue;
       }
       added = false;
-      line_new = (char *)ml_get_buf(curtab->tp_diffbuf[i],
-                                    dp->df_lnum[i] + off, false);
+      line_new = ml_get_buf(curtab->tp_diffbuf[i], dp->df_lnum[i] + off, false);
 
       // Search for start of difference
       si_org = si_new = 0;
@@ -2718,7 +2717,7 @@ void ex_diffgetput(exarg_T *eap)
         if (nr > curtab->tp_diffbuf[idx_from]->b_ml.ml_line_count) {
           break;
         }
-        p = (char *)vim_strsave(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, false));
+        p = xstrdup(ml_get_buf(curtab->tp_diffbuf[idx_from], nr, false));
         ml_append(lnum + i - 1, p, 0, false);
         xfree(p);
         added++;
diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 53b6c66c46..8e31d3feab 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -1932,9 +1932,9 @@ void f_digraph_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
   int code = digraph_get(digraphs[0], digraphs[1], false);
 
-  char_u buf[NUMBUFLEN];
-  buf[utf_char2bytes(code, (char *)buf)] = NUL;
-  rettv->vval.v_string = (char *)vim_strsave(buf);
+  char buf[NUMBUFLEN];
+  buf[utf_char2bytes(code, buf)] = NUL;
+  rettv->vval.v_string = xstrdup(buf);
 }
 
 /// "digraph_getlist()" function
diff --git a/src/nvim/drawline.c b/src/nvim/drawline.c
index 7846510ad9..9de8b9996a 100644
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -689,7 +689,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       // Trick: skip a few chars for C/shell/Vim comments
       nextline[SPWORDLEN] = NUL;
       if (lnum < wp->w_buffer->b_ml.ml_line_count) {
-        line = ml_get_buf(wp->w_buffer, lnum + 1, false);
+        line = (char_u *)ml_get_buf(wp->w_buffer, lnum + 1, false);
         spell_cat_line(nextline + SPWORDLEN, line, SPWORDLEN);
       }
 
@@ -866,7 +866,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
     line_attr_lowprio_save = line_attr_lowprio;
   }
 
-  line = end_fill ? (char_u *)"" : ml_get_buf(wp->w_buffer, lnum, false);
+  line = end_fill ? (char_u *)"" : (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
   ptr = line;
 
   if (has_spell && !number_only) {
@@ -1006,7 +1006,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
       len = spell_move_to(wp, FORWARD, true, true, &spell_hlf);
 
       // spell_move_to() may call ml_get() and make "line" invalid
-      line = ml_get_buf(wp->w_buffer, lnum, false);
+      line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
       ptr = line + linecol;
 
       if (len == 0 || (int)wp->w_cursor.col > ptr - line) {
@@ -1224,7 +1224,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
           c_extra = ' ';
           c_final = NUL;
           n_extra =
-            get_breakindent_win(wp, ml_get_buf(wp->w_buffer, lnum, false));
+            get_breakindent_win(wp, (char_u *)ml_get_buf(wp->w_buffer, lnum, false));
           if (row == startrow) {
             n_extra -= win_col_off2(wp);
             if (n_extra < 0) {
@@ -1676,7 +1676,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
 
           // Need to get the line again, a multi-line regexp may
           // have made it invalid.
-          line = ml_get_buf(wp->w_buffer, lnum, false);
+          line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
           ptr = line + v;
 
           if (!attr_pri) {
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index b20fc7d44a..f7a16abfb2 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1439,21 +1439,21 @@ void edit_putchar(int c, bool highlight)
   }
 }
 
-/// Return the effective prompt for the specified buffer.
-char_u *buf_prompt_text(const buf_T *const buf)
+/// @return    the effective prompt for the specified buffer.
+char *buf_prompt_text(const buf_T *const buf)
     FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
   if (buf->b_prompt_text == NULL) {
-    return (char_u *)"% ";
+    return "% ";
   }
-  return (char_u *)buf->b_prompt_text;
+  return buf->b_prompt_text;
 }
 
 // Return the effective prompt for the current buffer.
 char_u *prompt_text(void)
   FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
-  return buf_prompt_text(curbuf);
+  return (char_u *)buf_prompt_text(curbuf);
 }
 
 // Prepare for prompt mode: Make sure the last line has the prompt text.
@@ -1574,11 +1574,11 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   int start_col;
   colnr_T vc;
   colnr_T orig_col = 0;                 // init for GCC
-  char_u *new_line, *orig_line = NULL;     // init for GCC
+  char *new_line, *orig_line = NULL;     // init for GCC
 
   // MODE_VREPLACE state needs to know what the line was like before changing
   if (State & VREPLACE_FLAG) {
-    orig_line = vim_strsave((char_u *)get_cursor_line_ptr());   // Deal with NULL below
+    orig_line = xstrdup(get_cursor_line_ptr());   // Deal with NULL below
     orig_col = curwin->w_cursor.col;
   }
 
@@ -1733,14 +1733,14 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
   // then put it back again the way we wanted it.
   if (State & VREPLACE_FLAG) {
     // Save new line
-    new_line = vim_strsave((char_u *)get_cursor_line_ptr());
+    new_line = xstrdup(get_cursor_line_ptr());
 
     // We only put back the new line up to the cursor
     new_line[curwin->w_cursor.col] = NUL;
     int new_col = curwin->w_cursor.col;
 
     // Put back original line
-    ml_replace(curwin->w_cursor.lnum, (char *)orig_line, false);
+    ml_replace(curwin->w_cursor.lnum, orig_line, false);
     curwin->w_cursor.col = orig_col;
 
     curbuf_splice_pending++;
@@ -1749,7 +1749,7 @@ void change_indent(int type, int amount, int round, int replaced, int call_chang
     backspace_until_column(0);
 
     // Insert new stuff into line again
-    ins_bytes((char *)new_line);
+    ins_bytes(new_line);
 
     xfree(new_line);
 
@@ -1813,7 +1813,7 @@ static bool del_char_after_col(int limit_col)
     // composing character.
     mb_adjust_cursor();
     while (curwin->w_cursor.col < (colnr_T)limit_col) {
-      int l = utf_ptr2len((char *)get_cursor_pos_ptr());
+      int l = utf_ptr2len(get_cursor_pos_ptr());
 
       if (l == 0) {  // end of line
         break;
@@ -2466,7 +2466,7 @@ int oneright(void)
     pos_T prevpos = curwin->w_cursor;
 
     // Adjust for multi-wide char (excluding TAB)
-    ptr = (char *)get_cursor_pos_ptr();
+    ptr = get_cursor_pos_ptr();
     coladvance(getviscol() + ((*ptr != TAB && vim_isprintc(utf_ptr2char(ptr))) ?
                               ptr2cells(ptr) : 1));
     curwin->w_set_curswant = true;
@@ -2475,7 +2475,7 @@ int oneright(void)
             || prevpos.coladd != curwin->w_cursor.coladd) ? OK : FAIL;
   }
 
-  ptr = (char *)get_cursor_pos_ptr();
+  ptr = get_cursor_pos_ptr();
   if (*ptr == NUL) {
     return FAIL;            // already at the very end
   }
@@ -2518,7 +2518,7 @@ int oneleft(void)
 
     if (curwin->w_cursor.coladd == 1) {
       // Adjust for multi-wide char (not a TAB)
-      char *ptr = (char *)get_cursor_pos_ptr();
+      char *ptr = get_cursor_pos_ptr();
       if (*ptr != TAB && vim_isprintc(utf_ptr2char(ptr)) && ptr2cells(ptr) > 1) {
         curwin->w_cursor.coladd = 0;
       }
@@ -2720,19 +2720,19 @@ char_u *get_last_insert(void)
 // Returns pointer to allocated memory (must be freed) or NULL.
 char_u *get_last_insert_save(void)
 {
-  char_u *s;
+  char *s;
   int len;
 
   if (last_insert == NULL) {
     return NULL;
   }
-  s = vim_strsave(last_insert + last_insert_skip);
+  s = xstrdup((char *)last_insert + last_insert_skip);
   len = (int)STRLEN(s);
   if (len > 0 && s[len - 1] == ESC) {         // remove trailing ESC
     s[len - 1] = NUL;
   }
 
-  return s;
+  return (char_u *)s;
 }
 
 /// Check the word in front of the cursor for an abbreviation.
@@ -2934,7 +2934,7 @@ static void replace_do_bs(int limit_col)
       // Get the number of screen cells used by the character we are
       // going to delete.
       getvcol(curwin, &curwin->w_cursor, NULL, &start_vcol, NULL);
-      orig_vcols = win_chartabsize(curwin, (char *)get_cursor_pos_ptr(), start_vcol);
+      orig_vcols = win_chartabsize(curwin, get_cursor_pos_ptr(), start_vcol);
     }
     (void)del_char_after_col(limit_col);
     if (l_State & VREPLACE_FLAG) {
@@ -2945,7 +2945,7 @@ static void replace_do_bs(int limit_col)
 
     if (l_State & VREPLACE_FLAG) {
       // Get the number of screen cells used by the inserted characters
-      p = get_cursor_pos_ptr();
+      p = (char_u *)get_cursor_pos_ptr();
       ins_len = (int)STRLEN(p) - orig_len;
       vcol = start_vcol;
       for (i = 0; i < ins_len; i++) {
@@ -3186,7 +3186,7 @@ bool in_cinkeys(int keytyped, int when, bool line_is_empty)
           if (keytyped == (int)p[-1]
               || (icase && keytyped < 256
                   && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1]))) {
-            line = get_cursor_pos_ptr();
+            line = (char_u *)get_cursor_pos_ptr();
             assert(p >= look && (uintmax_t)(p - look) <= SIZE_MAX);
             if ((curwin->w_cursor.col == (colnr_T)(p - look)
                  || !vim_iswordc(line[-(p - look) - 1]))
@@ -3880,7 +3880,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
         // again when auto-formatting.
         if (has_format_option(FO_AUTO)
             && has_format_option(FO_WHITE_PAR)) {
-          char_u *ptr = ml_get_buf(curbuf, curwin->w_cursor.lnum, true);
+          char_u *ptr = (char_u *)ml_get_buf(curbuf, curwin->w_cursor.lnum, true);
           int len;
 
           len = (int)STRLEN(ptr);
@@ -3974,7 +3974,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
 
       // delete characters until we are at or before want_vcol
       while (vcol > want_vcol && curwin->w_cursor.col > 0
-             && (cc = *(get_cursor_pos_ptr() - 1), ascii_iswhite(cc))) {
+             && (cc = (uint8_t)(*(get_cursor_pos_ptr() - 1)), ascii_iswhite(cc))) {
         ins_bs_one(&vcol);
       }
 
@@ -4006,7 +4006,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
       // Delete up to starting point, start of line or previous word.
       int prev_cclass = 0;
 
-      int cclass = mb_get_class(get_cursor_pos_ptr());
+      int cclass = mb_get_class((char_u *)get_cursor_pos_ptr());
       do {
         if (!revins_on) {   // put cursor on char to be deleted
           dec_cursor();
@@ -4014,7 +4014,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
         cc = gchar_cursor();
         // look multi-byte character class
         prev_cclass = cclass;
-        cclass = mb_get_class(get_cursor_pos_ptr());
+        cclass = mb_get_class((char_u *)get_cursor_pos_ptr());
         if (mode == BACKSPACE_WORD && !ascii_isspace(cc)) {   // start of word?
           mode = BACKSPACE_WORD_NOT_SPACE;
           temp = vim_iswordc(cc);
@@ -4033,7 +4033,7 @@ static bool ins_bs(int c, int mode, int *inserted_space_p)
         } else {
           const int l_p_deco = p_deco;
           if (l_p_deco) {
-            (void)utfc_ptr2char((char *)get_cursor_pos_ptr(), cpc);
+            (void)utfc_ptr2char(get_cursor_pos_ptr(), cpc);
           }
           (void)del_char(false);
           // If there are combining characters and 'delcombine' is set
@@ -4286,7 +4286,7 @@ static void ins_right(void)
     if (virtual_active()) {
       oneright();
     } else {
-      curwin->w_cursor.col += utfc_ptr2len((char *)get_cursor_pos_ptr());
+      curwin->w_cursor.col += utfc_ptr2len(get_cursor_pos_ptr());
     }
 
     revins_legal++;
@@ -4507,7 +4507,7 @@ static bool ins_tab(void)
                           || get_sts_value() > 0
                           || (p_sta && ind))) {
     char_u *ptr;
-    char_u *saved_line = NULL;         // init for GCC
+    char *saved_line = NULL;         // init for GCC
     pos_T pos;
     pos_T fpos;
     pos_T *cursor;
@@ -4520,10 +4520,10 @@ static bool ins_tab(void)
     if (State & VREPLACE_FLAG) {
       pos = curwin->w_cursor;
       cursor = &pos;
-      saved_line = vim_strsave((char_u *)get_cursor_line_ptr());
-      ptr = saved_line + pos.col;
+      saved_line = xstrdup(get_cursor_line_ptr());
+      ptr = (char_u *)saved_line + pos.col;
     } else {
-      ptr = get_cursor_pos_ptr();
+      ptr = (char_u *)get_cursor_pos_ptr();
       cursor = &curwin->w_cursor;
     }
 
@@ -4627,7 +4627,7 @@ static bool ins_tab(void)
 
         // Insert each char in saved_line from changed_col to
         // ptr-cursor
-        ins_bytes_len((char *)saved_line + change_col, (size_t)(cursor->col - change_col));
+        ins_bytes_len(saved_line + change_col, (size_t)(cursor->col - change_col));
       }
     }
 
@@ -4946,13 +4946,13 @@ static char_u *do_insert_char_pre(int c)
   textlock++;
   set_vim_var_string(VV_CHAR, buf, -1);
 
-  char_u *res = NULL;
+  char *res = NULL;
   if (ins_apply_autocmds(EVENT_INSERTCHARPRE)) {
     // Get the value of v:char.  It may be empty or more than one
     // character.  Only use it when changed, otherwise continue with the
     // original character to avoid breaking autoindent.
     if (STRCMP(buf, get_vim_var_str(VV_CHAR)) != 0) {
-      res = vim_strsave((char_u *)get_vim_var_str(VV_CHAR));
+      res = xstrdup(get_vim_var_str(VV_CHAR));
     }
   }
 
@@ -4962,7 +4962,7 @@ static char_u *do_insert_char_pre(int c)
   // Restore the State, it may have been changed.
   State = save_State;
 
-  return res;
+  return (char_u *)res;
 }
 
 bool get_can_cindent(void)
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 06ee4c8d81..0c41381313 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -3909,7 +3909,7 @@ char *partial_name(partial_T *pt)
   FUNC_ATTR_PURE
 {
   if (pt->pt_name != NULL) {
-    return (char *)pt->pt_name;
+    return pt->pt_name;
   }
   return (char *)pt->pt_func->uf_name;
 }
@@ -3924,7 +3924,7 @@ static void partial_free(partial_T *pt)
   xfree(pt->pt_argv);
   tv_dict_unref(pt->pt_dict);
   if (pt->pt_name != NULL) {
-    func_unref(pt->pt_name);
+    func_unref((char_u *)pt->pt_name);
     xfree(pt->pt_name);
   } else {
     func_ptr_unref(pt->pt_func);
@@ -4478,7 +4478,7 @@ bool set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack
 
     // A partial does not have a copyID, because it cannot contain itself.
     if (pt != NULL) {
-      abort = set_ref_in_func(pt->pt_name, pt->pt_func, copyID);
+      abort = set_ref_in_func((char_u *)pt->pt_name, pt->pt_func, copyID);
       if (pt->pt_dict != NULL) {
         typval_T dtv;
 
@@ -4846,7 +4846,7 @@ void filter_map(typval_T *argvars, typval_T *rettv, int map)
             break;
           }
 
-          vimvars[VV_KEY].vv_str = (char *)vim_strsave(di->di_key);
+          vimvars[VV_KEY].vv_str = xstrdup((char *)di->di_key);
           int r = filter_map_one(&di->di_tv, expr, map, &rem);
           tv_clear(&vimvars[VV_KEY].vv_tv);
           if (r == FAIL || did_emsg) {
@@ -5113,7 +5113,7 @@ void common_function(typval_T *argvars, typval_T *rettv, bool is_funcref)
         func_ptr_ref(pt->pt_func);
         xfree(name);
       } else {
-        pt->pt_name = (char_u *)name;
+        pt->pt_name = name;
         func_ref((char_u *)name);
       }
 
@@ -6208,7 +6208,7 @@ char *save_tv_as_string(typval_T *tv, ptrdiff_t *const len, bool endnl)
     buf_T *buf = buflist_findnr((int)tv->vval.v_number);
     if (buf) {
       for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
-        for (char *p = (char *)ml_get_buf(buf, lnum, false); *p != NUL; p++) {
+        for (char *p = ml_get_buf(buf, lnum, false); *p != NUL; p++) {
           *len += 1;
         }
         *len += 1;
@@ -6226,7 +6226,7 @@ char *save_tv_as_string(typval_T *tv, ptrdiff_t *const len, bool endnl)
     char *ret = xmalloc((size_t)(*len) + 1);
     char *end = ret;
     for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
-      for (char *p = (char *)ml_get_buf(buf, lnum, false); *p != NUL; p++) {
+      for (char *p = ml_get_buf(buf, lnum, false); *p != NUL; p++) {
         *end++ = (*p == '\n') ? NUL : *p;
       }
       *end++ = '\n';
@@ -6275,7 +6275,7 @@ int buf_byteidx_to_charidx(buf_T *buf, linenr_T lnum, int byteidx)
     lnum = buf->b_ml.ml_line_count;
   }
 
-  char *str = (char *)ml_get_buf(buf, lnum, false);
+  char *str = ml_get_buf(buf, lnum, false);
 
   if (*str == NUL) {
     return 0;
@@ -6313,7 +6313,7 @@ int buf_charidx_to_byteidx(buf_T *buf, linenr_T lnum, int charidx)
     lnum = buf->b_ml.ml_line_count;
   }
 
-  char *str = (char *)ml_get_buf(buf, lnum, false);
+  char *str = ml_get_buf(buf, lnum, false);
 
   // Convert the character offset to a byte offset
   char *t = str;
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 60a6ec6201..408b6e6cb5 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -849,7 +849,7 @@ static void get_col(typval_T *argvars, typval_T *rettv, bool charcol)
       // col(".") when the cursor is on the NUL at the end of the line
       // because of "coladd" can be seen as an extra column.
       if (virtual_active() && fp == &curwin->w_cursor) {
-        char *p = (char *)get_cursor_pos_ptr();
+        char *p = get_cursor_pos_ptr();
         if (curwin->w_cursor.coladd >=
             (colnr_T)win_chartabsize(curwin, p,
                                      curwin->w_virtcol - curwin->w_cursor.coladd)) {
@@ -930,12 +930,12 @@ static void f_chdir(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   // Return the current directory
-  char_u *cwd = xmalloc(MAXPATHL);
-  if (os_dirname(cwd, MAXPATHL) != FAIL) {
+  char *cwd = xmalloc(MAXPATHL);
+  if (os_dirname((char_u *)cwd, MAXPATHL) != FAIL) {
 #ifdef BACKSLASH_IN_FILENAME
     slash_adjust(cwd);
 #endif
-    rettv->vval.v_string = (char *)vim_strsave(cwd);
+    rettv->vval.v_string = xstrdup(cwd);
   }
   xfree(cwd);
 
@@ -2016,10 +2016,9 @@ static void f_expand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         options += WILD_ICASE;
       }
       if (rettv->v_type == VAR_STRING) {
-        rettv->vval.v_string = (char *)ExpandOne(&xpc, (char_u *)s, NULL, options,
-                                                 WILD_ALL);
+        rettv->vval.v_string = ExpandOne(&xpc, (char *)s, NULL, options, WILD_ALL);
       } else {
-        ExpandOne(&xpc, (char_u *)s, NULL, options, WILD_ALL_KEEP);
+        ExpandOne(&xpc, (char *)s, NULL, options, WILD_ALL_KEEP);
         tv_list_alloc_ret(rettv, xpc.xp_numfiles);
         for (int i = 0; i < xpc.xp_numfiles; i++) {
           tv_list_append_string(rettv->vval.v_list,
@@ -2437,7 +2436,7 @@ static void f_get(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       pt = argvars[0].vval.v_partial;
     } else {
       CLEAR_FIELD(fref_pt);
-      fref_pt.pt_name = (char_u *)argvars[0].vval.v_string;
+      fref_pt.pt_name = argvars[0].vval.v_string;
       pt = &fref_pt;
     }
 
@@ -2579,9 +2578,8 @@ static void get_buffer_lines(buf_T *buf, linenr_T start, linenr_T end, int retli
     }
   } else {
     rettv->v_type = VAR_STRING;
-    rettv->vval.v_string =
-      (char *)((start >= 1 && start <= buf->b_ml.ml_line_count)
-               ? vim_strsave(ml_get_buf(buf, start, false)) : NULL);
+    rettv->vval.v_string = ((start >= 1 && start <= buf->b_ml.ml_line_count)
+                            ? xstrdup(ml_get_buf(buf, start, false)) : NULL);
   }
 }
 
@@ -2919,7 +2917,7 @@ static void f_getftime(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "getftype({fname})" function
 static void f_getftype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  char_u *type = NULL;
+  char *type = NULL;
   char *t;
 
   const char *fname = tv_get_string(&argvars[0]);
@@ -2945,9 +2943,9 @@ static void f_getftype(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     } else {
       t = "other";
     }
-    type = vim_strsave((char_u *)t);
+    type = xstrdup(t);
   }
-  rettv->vval.v_string = (char *)type;
+  rettv->vval.v_string = type;
 }
 
 /// "getjumplist()" function
@@ -3441,11 +3439,11 @@ static void f_glob(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       options += WILD_ICASE;
     }
     if (rettv->v_type == VAR_STRING) {
-      rettv->vval.v_string = (char *)ExpandOne(&xpc, (char_u *)
-                                               tv_get_string(&argvars[0]), NULL, options,
-                                               WILD_ALL);
+      rettv->vval.v_string = ExpandOne(&xpc, (char *)
+                                       tv_get_string(&argvars[0]), NULL, options,
+                                       WILD_ALL);
     } else {
-      ExpandOne(&xpc, (char_u *)tv_get_string(&argvars[0]), NULL, options,
+      ExpandOne(&xpc, (char *)tv_get_string(&argvars[0]), NULL, options,
                 WILD_ALL_KEEP);
       tv_list_alloc_ret(rettv, xpc.xp_numfiles);
       for (int i = 0; i < xpc.xp_numfiles; i++) {
@@ -5443,11 +5441,11 @@ static void f_pathshorten(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   }
 
   rettv->v_type = VAR_STRING;
-  const char_u *p = (char_u *)tv_get_string_chk(&argvars[0]);
+  const char *p = tv_get_string_chk(&argvars[0]);
   if (p == NULL) {
     rettv->vval.v_string = NULL;
   } else {
-    rettv->vval.v_string = (char *)vim_strsave(p);
+    rettv->vval.v_string = xstrdup(p);
     shorten_dir_len((char_u *)rettv->vval.v_string, trim_len);
   }
 }
@@ -5565,7 +5563,7 @@ static void f_prompt_getprompt(typval_T *argvars, typval_T *rettv, EvalFuncData
     return;
   }
 
-  rettv->vval.v_string = (char *)vim_strsave(buf_prompt_text(buf));
+  rettv->vval.v_string = xstrdup(buf_prompt_text(buf));
 }
 
 /// "prompt_setprompt({buffer}, {text})" function
@@ -7107,7 +7105,7 @@ static void f_screenstring(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
     return;
   }
 
-  rettv->vval.v_string = (char *)vim_strsave(grid->chars[grid->line_offset[row] + (size_t)col]);
+  rettv->vval.v_string = xstrdup((char *)grid->chars[grid->line_offset[row] + (size_t)col]);
 }
 
 /// "search()" function
@@ -8052,7 +8050,7 @@ static void f_spellbadword(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
     // Find the start and length of the badly spelled word.
     len = spell_move_to(curwin, FORWARD, true, true, &attr);
     if (len != 0) {
-      word = (char *)get_cursor_pos_ptr();
+      word = get_cursor_pos_ptr();
       curwin->w_set_curswant = true;
     }
   } else if (*curbuf->b_s.b_p_spl != NUL) {
@@ -8740,7 +8738,7 @@ static void f_swapname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       || buf->b_ml.ml_mfp->mf_fname == NULL) {
     rettv->vval.v_string = NULL;
   } else {
-    rettv->vval.v_string = (char *)vim_strsave(buf->b_ml.ml_mfp->mf_fname);
+    rettv->vval.v_string = xstrdup(buf->b_ml.ml_mfp->mf_fname);
   }
 }
 
@@ -9101,7 +9099,7 @@ static void f_taglist(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 static void f_tempname(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
   rettv->v_type = VAR_STRING;
-  rettv->vval.v_string = (char *)vim_tempname();
+  rettv->vval.v_string = vim_tempname();
 }
 
 /// "termopen(cmd[, cwd])" function
@@ -9595,12 +9593,12 @@ static void f_virtcol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "visualmode()" function
 static void f_visualmode(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  char_u str[2];
+  char str[2];
 
   rettv->v_type = VAR_STRING;
-  str[0] = (char_u)curbuf->b_visual_mode_eval;
+  str[0] = (char)curbuf->b_visual_mode_eval;
   str[1] = NUL;
-  rettv->vval.v_string = (char *)vim_strsave(str);
+  rettv->vval.v_string = xstrdup(str);
 
   // A non-zero number or non-empty string argument: reset mode.
   if (non_zero_arg(&argvars[0])) {
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index a409271596..f6b97fe05b 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -2777,7 +2777,7 @@ static void tv_dict_list(typval_T *const tv, typval_T *const rettv, const DictLi
     switch (what) {
       case kDictListKeys:
         tv_item.v_type = VAR_STRING;
-        tv_item.vval.v_string = (char *)vim_strsave(di->di_key);
+        tv_item.vval.v_string = xstrdup((char *)di->di_key);
         break;
       case kDictListValues:
         tv_copy(&di->di_tv, &tv_item);
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index 8177d01f90..cf7b04c8ce 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -360,15 +360,14 @@ struct ufunc {
 };
 
 struct partial_S {
-  int pt_refcount;  ///< Reference count.
-  char_u *pt_name;  ///< Function name; when NULL use pt_func->name.
-  ufunc_T *pt_func;  ///< Function pointer; when NULL lookup function with
-                     ///< pt_name.
-  bool pt_auto;  ///< When true the partial was created by using dict.member
-                 ///< in handle_subscript().
-  int pt_argc;  ///< Number of arguments.
+  int pt_refcount;    ///< Reference count.
+  char *pt_name;      ///< Function name; when NULL use pt_func->name.
+  ufunc_T *pt_func;   ///< Function pointer; when NULL lookup function with pt_name.
+  bool pt_auto;       ///< When true the partial was created by using dict.member
+                      ///< in handle_subscript().
+  int pt_argc;        ///< Number of arguments.
   typval_T *pt_argv;  ///< Arguments in allocated array.
-  dict_T *pt_dict;  ///< Dict for "self".
+  dict_T *pt_dict;    ///< Dict for "self".
 };
 
 /// Structure used for explicit stack while garbage collecting hash tables
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 3ab66c319f..36bc51179c 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -142,18 +142,18 @@ static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int
         any_default = true;
         p = skipwhite(p) + 1;
         p = skipwhite(p);
-        char_u *expr = (char_u *)p;
+        char *expr = p;
         if (eval1(&p, &rettv, false) != FAIL) {
           ga_grow(default_args, 1);
 
           // trim trailing whitespace
-          while (p > (char *)expr && ascii_iswhite(p[-1])) {
+          while (p > expr && ascii_iswhite(p[-1])) {
             p--;
           }
           c = (char_u)(*p);
           *p = NUL;
-          expr = vim_strsave(expr);
-          ((char **)(default_args->ga_data))[default_args->ga_len] = (char *)expr;
+          expr = xstrdup(expr);
+          ((char **)(default_args->ga_data))[default_args->ga_len] = expr;
           default_args->ga_len++;
           *p = (char)c;
         } else {
@@ -1680,7 +1680,7 @@ static void list_func_head(ufunc_T *fp, int indent, bool force)
 char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, partial_T **partial)
   FUNC_ATTR_NONNULL_ARG(1)
 {
-  char_u *name = NULL;
+  char *name = NULL;
   const char_u *start;
   const char_u *end;
   int lead;
@@ -1739,7 +1739,7 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
       fdp->fd_di = lv.ll_di;
     }
     if (lv.ll_tv->v_type == VAR_FUNC && lv.ll_tv->vval.v_string != NULL) {
-      name = vim_strsave((char_u *)lv.ll_tv->vval.v_string);
+      name = xstrdup(lv.ll_tv->vval.v_string);
       *pp = (char *)end;
     } else if (lv.ll_tv->v_type == VAR_PARTIAL
                && lv.ll_tv->vval.v_partial != NULL) {
@@ -1753,7 +1753,7 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
         memcpy(name, end + 1, (size_t)len);
         *pp = (char *)end + 1 + len;
       } else {
-        name = vim_strsave((char_u *)partial_name(lv.ll_tv->vval.v_partial));
+        name = xstrdup(partial_name(lv.ll_tv->vval.v_partial));
         *pp = (char *)end;
       }
       if (partial != NULL) {
@@ -1781,28 +1781,28 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
   // Check if the name is a Funcref.  If so, use the value.
   if (lv.ll_exp_name != NULL) {
     len = (int)strlen(lv.ll_exp_name);
-    name = deref_func_name(lv.ll_exp_name, &len, partial,
-                           flags & TFN_NO_AUTOLOAD);
+    name = (char *)deref_func_name(lv.ll_exp_name, &len, partial,
+                                   flags & TFN_NO_AUTOLOAD);
     if ((const char *)name == lv.ll_exp_name) {
       name = NULL;
     }
   } else if (!(flags & TFN_NO_DEREF)) {
     len = (int)(end - (char_u *)(*pp));
-    name = deref_func_name((const char *)(*pp), &len, partial,
-                           flags & TFN_NO_AUTOLOAD);
-    if (name == (char_u *)(*pp)) {
+    name = (char *)deref_func_name((const char *)(*pp), &len, partial,
+                                   flags & TFN_NO_AUTOLOAD);
+    if (name == *pp) {
       name = NULL;
     }
   }
   if (name != NULL) {
-    name = vim_strsave(name);
+    name = xstrdup(name);
     *pp = (char *)end;
     if (STRNCMP(name, "<SNR>", 5) == 0) {
       // Change "<SNR>" to the byte sequence.
-      name[0] = K_SPECIAL;
-      name[1] = KS_EXTRA;
+      name[0] = (char)K_SPECIAL;
+      name[1] = (char)KS_EXTRA;
       name[2] = KE_SNR;
-      memmove(name + 3, name + 5, strlen((char *)name + 5) + 1);
+      memmove(name + 3, name + 5, strlen(name + 5) + 1);
     }
     goto theend;
   }
@@ -1865,8 +1865,8 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
 
   name = xmalloc((size_t)len + (size_t)lead + 1);
   if (!skip && lead > 0) {
-    name[0] = K_SPECIAL;
-    name[1] = KS_EXTRA;
+    name[0] = (char)K_SPECIAL;
+    name[1] = (char)KS_EXTRA;
     name[2] = KE_SNR;
     if (sid_buf_len > 0) {  // If it's "<SID>"
       memcpy(name + 3, sid_buf, sid_buf_len);
@@ -1878,7 +1878,7 @@ char_u *trans_function_name(char **pp, bool skip, int flags, funcdict_T *fdp, pa
 
 theend:
   clear_lval(&lv);
-  return name;
+  return (char_u *)name;
 }
 
 #define MAX_FUNC_NESTING 50
@@ -3104,7 +3104,7 @@ char *get_return_cmd(void *rettv)
     STRCPY(IObuff + IOSIZE - 4, "...");
   }
   xfree(tofree);
-  return (char *)vim_strsave(IObuff);
+  return xstrdup((char *)IObuff);
 }
 
 /// Get next function line.
@@ -3192,7 +3192,7 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
   } else {
     fname = rettv->v_type == VAR_FUNC || rettv->v_type == VAR_STRING
                                       ? (char_u *)rettv->vval.v_string
-                                      : rettv->vval.v_partial->pt_name;
+                                      : (char_u *)rettv->vval.v_partial->pt_name;
     // Translate "s:func" to the stored function name.
     fname = (char_u *)fname_trans_sid((char *)fname, (char *)fname_buf, (char **)&tofree, &error);
     fp = find_func(fname);
@@ -3208,7 +3208,7 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
     pt->pt_auto = true;
     if (rettv->v_type == VAR_FUNC || rettv->v_type == VAR_STRING) {
       // Just a function: Take over the function name and use selfdict.
-      pt->pt_name = (char_u *)rettv->vval.v_string;
+      pt->pt_name = rettv->vval.v_string;
     } else {
       partial_T *ret_pt = rettv->vval.v_partial;
       int i;
@@ -3217,8 +3217,8 @@ void make_partial(dict_T *const selfdict, typval_T *const rettv)
       // args. Can't take over name or args, the partial might
       // be referenced elsewhere.
       if (ret_pt->pt_name != NULL) {
-        pt->pt_name = vim_strsave(ret_pt->pt_name);
-        func_ref(pt->pt_name);
+        pt->pt_name = xstrdup(ret_pt->pt_name);
+        func_ref((char_u *)pt->pt_name);
       } else {
         pt->pt_func = ret_pt->pt_func;
         func_ptr_ref(pt->pt_func);
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 8f256728e3..12920d932d 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -118,7 +118,7 @@ void do_ascii(const exarg_T *const eap)
 {
   char *dig;
   int cc[MAX_MCO];
-  int c = utfc_ptr2char((char *)get_cursor_pos_ptr(), cc);
+  int c = utfc_ptr2char(get_cursor_pos_ptr(), cc);
   if (c == NUL) {
     msg("NUL");
     return;
@@ -1068,7 +1068,7 @@ void ex_copy(linenr_T line1, linenr_T line2, linenr_T n)
 
   curwin->w_cursor.lnum = n;
   while (line1 <= line2) {
-    // need to use vim_strsave() because the line will be unlocked within
+    // need to use xstrdup() because the line will be unlocked within
     // ml_append()
     p = xstrdup(ml_get(line1));
     ml_append(curwin->w_cursor.lnum, p, (colnr_T)0, false);
@@ -1305,8 +1305,8 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
     curbuf->b_op_start.lnum = line1;
     curbuf->b_op_end.lnum = line2;
     curwin->w_cursor.lnum = line2;
-  } else if ((do_in && (itmp = (char *)vim_tempname()) == NULL)
-             || (do_out && (otmp = (char *)vim_tempname()) == NULL)) {
+  } else if ((do_in && (itmp = vim_tempname()) == NULL)
+             || (do_out && (otmp = vim_tempname()) == NULL)) {
     emsg(_(e_notmp));
     goto filterend;
   }
@@ -3291,7 +3291,7 @@ static bool sub_joining_lines(exarg_T *eap, char *pat, char *sub, char *cmd, boo
 
     if (save) {
       if ((cmdmod.cmod_flags & CMOD_KEEPPATTERNS) == 0) {
-        save_re_pat(RE_SUBST, (char_u *)pat, p_magic);
+        save_re_pat(RE_SUBST, pat, p_magic);
       }
       // put pattern in history
       add_to_history(HIST_SEARCH, pat, true, NUL);
@@ -3608,7 +3608,7 @@ static int do_sub(exarg_T *eap, proftime_T timeout, long cmdpreview_ns, handle_T
     sub = xstrdup(sub);
     sub_copy = sub;
   } else {
-    char *newsub = (char *)regtilde((char_u *)sub, p_magic, cmdpreview);
+    char *newsub = regtilde(sub, p_magic, cmdpreview);
     if (newsub != sub) {
       // newsub was allocated, free it later.
       sub_copy = newsub;
@@ -4782,7 +4782,7 @@ static int show_sub(exarg_T *eap, pos_T old_cusr, PreviewLines *preview_lines, i
         if (next_linenr == orig_buf->b_ml.ml_line_count + 1) {
           line = "";
         } else {
-          line = (char *)ml_get_buf(orig_buf, next_linenr, false);
+          line = ml_get_buf(orig_buf, next_linenr, false);
           line_size = strlen(line) + (size_t)col_width + 1;
 
           // Reallocate if line not long enough
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 8fb166d2c9..e32eb860ce 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -785,7 +785,7 @@ int do_cmdline(char *cmdline, LineGetter fgetline, void *cookie, int flags)
         vim_snprintf((char *)IObuff, IOSIZE,
                      _("E605: Exception not caught: %s"),
                      current_exception->value);
-        p = (char *)vim_strsave(IObuff);
+        p = xstrdup((char *)IObuff);
         break;
       case ET_ERROR:
         messages = current_exception->messages;
@@ -1300,7 +1300,7 @@ static void parse_register(exarg_T *eap)
       // for '=' register: accept the rest of the line as an expression
       if (eap->arg[-1] == '=' && eap->arg[0] != NUL) {
         if (!eap->skip) {
-          set_expr_line(vim_strsave((char_u *)eap->arg));
+          set_expr_line(xstrdup(eap->arg));
         }
         eap->arg += STRLEN(eap->arg);
       }
@@ -3829,7 +3829,7 @@ int expand_filename(exarg_T *eap, char **cmdlinep, char **errormsgp)
       if (p_wic) {
         options += WILD_ICASE;
       }
-      p = (char *)ExpandOne(&xpc, (char_u *)eap->arg, NULL, options, WILD_EXPAND_FREE);
+      p = ExpandOne(&xpc, eap->arg, NULL, options, WILD_EXPAND_FREE);
       if (p == NULL) {
         return FAIL;
       }
@@ -5274,7 +5274,7 @@ static void ex_swapname(exarg_T *eap)
   if (curbuf->b_ml.ml_mfp == NULL || curbuf->b_ml.ml_mfp->mf_fname == NULL) {
     msg(_("No swap file"));
   } else {
-    msg((char *)curbuf->b_ml.ml_mfp->mf_fname);
+    msg(curbuf->b_ml.ml_mfp->mf_fname);
   }
 }
 
@@ -6563,7 +6563,7 @@ static void ex_tag_cmd(exarg_T *eap, char *name)
     cmd = DT_LTAG;
   }
 
-  do_tag((char_u *)eap->arg, cmd, eap->addr_count > 0 ? (int)eap->line2 : 1,
+  do_tag(eap->arg, cmd, eap->addr_count > 0 ? (int)eap->line2 : 1,
          eap->forceit, true);
 }
 
diff --git a/src/nvim/ex_eval.c b/src/nvim/ex_eval.c
index 20725b81ee..f40149d07a 100644
--- a/src/nvim/ex_eval.c
+++ b/src/nvim/ex_eval.c
@@ -529,7 +529,7 @@ static void discard_exception(except_T *excp, bool was_finished)
   if (p_verbose >= 13 || debug_break_level > 0) {
     int save_msg_silent = msg_silent;
 
-    saved_IObuff = (char *)vim_strsave(IObuff);
+    saved_IObuff = xstrdup((char *)IObuff);
     if (debug_break_level > 0) {
       msg_silent = false;               // display messages
     } else {
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index da99a03c38..cf95287d61 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -105,7 +105,7 @@ typedef struct command_line_state {
   int c;
   int gotesc;                           // true when <ESC> just typed
   int do_abbr;                          // when true check for abbr.
-  char_u *lookfor;                      // string to match
+  char *lookfor;                        // string to match
   int hiscnt;                           // current history line in use
   int save_hiscnt;                      // history line before attempting
                                         // to jump to next match
@@ -116,7 +116,7 @@ typedef struct command_line_state {
   int res;
   int save_msg_scroll;
   int save_State;                 // remember State when called
-  char_u *save_p_icm;
+  char *save_p_icm;
   int some_key_typed;                   // one of the keys was typed
   // mouse drag and release events are ignored, unless they are
   // preceded with a mouse down event
@@ -632,7 +632,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
     .ignore_drag_release = true,
   };
   CommandLineState *s = &state;
-  s->save_p_icm = vim_strsave((char_u *)p_icm);
+  s->save_p_icm = xstrdup(p_icm);
   init_incsearch_state(&s->is_state);
   CmdlineInfo save_ccline;
   bool did_save_ccline = false;
@@ -879,7 +879,7 @@ static uint8_t *command_line_enter(int firstc, long count, int indent, bool init
     need_wait_return = false;
   }
 
-  set_string_option_direct("icm", -1, (char *)s->save_p_icm, OPT_FREE, SID_NONE);
+  set_string_option_direct("icm", -1, s->save_p_icm, OPT_FREE, SID_NONE);
   State = s->save_State;
   if (cmdpreview != save_cmdpreview) {
     cmdpreview = save_cmdpreview;  // restore preview state
@@ -1087,7 +1087,7 @@ static int command_line_execute(VimState *state, int key)
       s->c = get_expr_register();
       if (s->c == '=') {
         textlock++;
-        p = get_expr_line();
+        p = (char_u *)get_expr_line();
         textlock--;
 
         if (p != NULL) {
@@ -1853,7 +1853,7 @@ static int command_line_handle_key(CommandLineState *s)
 
     // save current command string so it can be restored later
     if (s->lookfor == NULL) {
-      s->lookfor = vim_strsave((char_u *)ccline.cmdbuff);
+      s->lookfor = xstrdup(ccline.cmdbuff);
       s->lookfor[ccline.cmdpos] = NUL;
     }
 
@@ -1870,13 +1870,13 @@ static int command_line_handle_key(CommandLineState *s)
       XFREE_CLEAR(ccline.cmdbuff);
       s->xpc.xp_context = EXPAND_NOTHING;
       if (s->hiscnt == get_hislen()) {
-        p = s->lookfor;                  // back to the old one
+        p = (char_u *)s->lookfor;                  // back to the old one
       } else {
         p = (char_u *)get_histentry(s->histype)[s->hiscnt].hisstr;
       }
 
       if (s->histype == HIST_SEARCH
-          && p != s->lookfor
+          && p != (char_u *)s->lookfor
           && (old_firstc = p[STRLEN(p) + 1]) != s->firstc) {
         // Correct for the separator character used when
         // adding the history entry vs the one used now.
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 76a429b5ef..5416be651d 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -69,7 +69,7 @@
 #include "nvim/vim.h"
 #include "nvim/window.h"
 
-static char_u *ff_expand_buffer = NULL;  // used for expanding filenames
+static char *ff_expand_buffer = NULL;  // used for expanding filenames
 
 // type for the directory search stack
 typedef struct ff_stack {
@@ -105,7 +105,7 @@ typedef struct ff_visited {
 
   // Visited directories are different if the wildcard string are
   // different. So we have to save it.
-  char_u *ffv_wc_path;
+  char *ffv_wc_path;
 
   // use FileID for comparison (needed because of links), else use filename.
   bool file_id_valid;
@@ -131,7 +131,7 @@ typedef struct ff_visited_list_hdr {
   struct ff_visited_list_hdr *ffvl_next;
 
   // the filename the attached visited list is for
-  char_u *ffvl_filename;
+  char *ffvl_filename;
 
   ff_visited_T *ffvl_visited_list;
 } ff_visited_list_hdr_T;
@@ -259,12 +259,12 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     // Reuse old visited lists. Get the visited list for the given
     // filename. If no list for the current filename exists, creates a new
     // one.
-    search_ctx->ffsc_visited_list = ff_get_visited_list((char_u *)filename,
+    search_ctx->ffsc_visited_list = ff_get_visited_list(filename,
                                                         &search_ctx->ffsc_visited_lists_list);
     if (search_ctx->ffsc_visited_list == NULL) {
       goto error_return;
     }
-    search_ctx->ffsc_dir_visited_list = ff_get_visited_list((char_u *)filename,
+    search_ctx->ffsc_dir_visited_list = ff_get_visited_list(filename,
                                                             &search_ctx->ffsc_dir_visited_lists_list);
     if (search_ctx->ffsc_dir_visited_list == NULL) {
       goto error_return;
@@ -286,7 +286,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     if (!vim_isAbsName((char_u *)rel_fname) && len + 1 < MAXPATHL) {
       // Make the start dir an absolute path name.
       STRLCPY(ff_expand_buffer, rel_fname, len + 1);
-      search_ctx->ffsc_start_dir = FullName_save((char *)ff_expand_buffer, false);
+      search_ctx->ffsc_start_dir = FullName_save(ff_expand_buffer, false);
     } else {
       search_ctx->ffsc_start_dir = xstrnsave(rel_fname, len);
     }
@@ -310,11 +310,11 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
       path += 2;
     } else
 #endif
-    if (os_dirname(ff_expand_buffer, MAXPATHL) == FAIL) {
+    if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL) == FAIL) {
       goto error_return;
     }
 
-    search_ctx->ffsc_start_dir = (char *)vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_start_dir = xstrdup(ff_expand_buffer);
 
 #ifdef BACKSLASH_IN_FILENAME
     // A path that starts with "/dir" is relative to the drive, not to the
@@ -396,12 +396,12 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
         break;
       }
       if (STRNCMP(wc_part, "**", 2) == 0) {
-        ff_expand_buffer[len++] = (char_u)(*wc_part++);
-        ff_expand_buffer[len++] = (char_u)(*wc_part++);
+        ff_expand_buffer[len++] = *wc_part++;
+        ff_expand_buffer[len++] = *wc_part++;
 
         llevel = strtol(wc_part, &errpt, 10);
         if (errpt != wc_part && llevel > 0 && llevel < 255) {
-          ff_expand_buffer[len++] = (char_u)llevel;
+          ff_expand_buffer[len++] = (char)llevel;
         } else if (errpt != wc_part && llevel == 0) {
           // restrict is 0 -> remove already added '**'
           len -= 2;
@@ -416,11 +416,11 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
           goto error_return;
         }
       } else {
-        ff_expand_buffer[len++] = (char_u)(*wc_part++);
+        ff_expand_buffer[len++] = *wc_part++;
       }
     }
     ff_expand_buffer[len] = NUL;
-    search_ctx->ffsc_wc_path = (char *)vim_strsave(ff_expand_buffer);
+    search_ctx->ffsc_wc_path = xstrdup(ff_expand_buffer);
   } else {
     search_ctx->ffsc_fix_path = xstrdup(path);
   }
@@ -439,7 +439,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     goto error_return;
   }
   STRCPY(ff_expand_buffer, search_ctx->ffsc_start_dir);
-  add_pathsep((char *)ff_expand_buffer);
+  add_pathsep(ff_expand_buffer);
   {
     size_t eb_len = STRLEN(ff_expand_buffer);
     char_u *buf = xmalloc(eb_len + STRLEN(search_ctx->ffsc_fix_path) + 1);
@@ -448,7 +448,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     STRCPY(buf + eb_len, search_ctx->ffsc_fix_path);
     if (os_isdir((char *)buf)) {
       STRCAT(ff_expand_buffer, search_ctx->ffsc_fix_path);
-      add_pathsep((char *)ff_expand_buffer);
+      add_pathsep(ff_expand_buffer);
     } else {
       char *p = path_tail(search_ctx->ffsc_fix_path);
       char *wc_path = NULL;
@@ -464,7 +464,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
           goto error_return;
         }
         STRLCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, eb_len + (size_t)len + 1);
-        add_pathsep((char *)ff_expand_buffer);
+        add_pathsep(ff_expand_buffer);
       } else {
         len = (int)STRLEN(search_ctx->ffsc_fix_path);
       }
@@ -484,7 +484,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
     xfree(buf);
   }
 
-  sptr = ff_create_stack_element(ff_expand_buffer, (char_u *)search_ctx->ffsc_wc_path, level, 0);
+  sptr = ff_create_stack_element(ff_expand_buffer, search_ctx->ffsc_wc_path, level, 0);
 
   ff_push(search_ctx, sptr);
   search_ctx->ffsc_file_to_search = xstrdup(filename);
@@ -607,7 +607,7 @@ char_u *vim_findfile(void *search_ctx_arg)
       // first time (hence stackp->ff_filearray == NULL)
       if (stackp->ffs_filearray == NULL
           && ff_check_visited(&search_ctx->ffsc_dir_visited_list->ffvl_visited_list,
-                              stackp->ffs_fix_path, stackp->ffs_wc_path) == FAIL) {
+                              (char *)stackp->ffs_fix_path, (char *)stackp->ffs_wc_path) == FAIL) {
 #ifdef FF_VERBOSE
         if (p_verbose >= 5) {
           verbose_enter_scroll();
@@ -787,7 +787,7 @@ char_u *vim_findfile(void *search_ctx_arg)
                                == os_isdir((char *)file_path)))))
 #ifndef FF_VERBOSE
                   && (ff_check_visited(&search_ctx->ffsc_visited_list->ffvl_visited_list,
-                                       file_path, (char_u *)"") == OK)
+                                       (char *)file_path, "") == OK)
 #endif
                   ) {
 #ifdef FF_VERBOSE
@@ -811,10 +811,10 @@ char_u *vim_findfile(void *search_ctx_arg)
                 if (!path_with_url((char *)file_path)) {
                   simplify_filename(file_path);
                 }
-                if (os_dirname(ff_expand_buffer, MAXPATHL)
+                if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL)
                     == OK) {
                   p = path_shorten_fname(file_path,
-                                         ff_expand_buffer);
+                                         (char_u *)ff_expand_buffer);
                   if (p != NULL) {
                     STRMOVE(file_path, p);
                   }
@@ -845,8 +845,8 @@ char_u *vim_findfile(void *search_ctx_arg)
               continue;                 // not a directory
             }
             ff_push(search_ctx,
-                    ff_create_stack_element((char_u *)stackp->ffs_filearray[i],
-                                            rest_of_wildcards,
+                    ff_create_stack_element(stackp->ffs_filearray[i],
+                                            (char *)rest_of_wildcards,
                                             stackp->ffs_level - 1, 0));
           }
         }
@@ -867,8 +867,8 @@ char_u *vim_findfile(void *search_ctx_arg)
             continue;               // not a directory
           }
           ff_push(search_ctx,
-                  ff_create_stack_element((char_u *)stackp->ffs_filearray[i],
-                                          stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
+                  ff_create_stack_element(stackp->ffs_filearray[i],
+                                          (char *)stackp->ffs_wc_path, stackp->ffs_level - 1, 1));
         }
       }
 
@@ -914,8 +914,8 @@ char_u *vim_findfile(void *search_ctx_arg)
       STRCAT(file_path, search_ctx->ffsc_fix_path);
 
       // create a new stack entry
-      sptr = ff_create_stack_element(file_path,
-                                     (char_u *)search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
+      sptr = ff_create_stack_element((char *)file_path,
+                                     search_ctx->ffsc_wc_path, search_ctx->ffsc_level, 0);
       ff_push(search_ctx, sptr);
     } else {
       break;
@@ -972,7 +972,7 @@ static void ff_free_visited_list(ff_visited_T *vl)
 
 /// @return  the already visited list for the given filename. If none is found it
 ///          allocates a new one.
-static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename,
+static ff_visited_list_hdr_T *ff_get_visited_list(char *filename,
                                                   ff_visited_list_hdr_T **list_headp)
 {
   ff_visited_list_hdr_T *retptr = NULL;
@@ -1009,7 +1009,7 @@ static ff_visited_list_hdr_T *ff_get_visited_list(char_u *filename,
   retptr = xmalloc(sizeof(*retptr));
 
   retptr->ffvl_visited_list = NULL;
-  retptr->ffvl_filename = vim_strsave(filename);
+  retptr->ffvl_filename = xstrdup(filename);
   retptr->ffvl_next = *list_headp;
   *list_headp = retptr;
 
@@ -1060,7 +1060,7 @@ static bool ff_wc_equal(char_u *s1, char_u *s2)
 ///
 /// @return  FAIL if the given file/dir is already in the list or,
 ///          OK if it is newly added
-static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *wc_path)
+static int ff_check_visited(ff_visited_T **visited_list, char *fname, char *wc_path)
 {
   ff_visited_T *vp;
   bool url = false;
@@ -1068,12 +1068,12 @@ static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *
   FileID file_id;
   // For a URL we only compare the name, otherwise we compare the
   // device/inode.
-  if (path_with_url((char *)fname)) {
+  if (path_with_url(fname)) {
     STRLCPY(ff_expand_buffer, fname, MAXPATHL);
     url = true;
   } else {
     ff_expand_buffer[0] = NUL;
-    if (!os_fileid((char *)fname, &file_id)) {
+    if (!os_fileid(fname, &file_id)) {
       return FAIL;
     }
   }
@@ -1084,7 +1084,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *
         || (!url && vp->file_id_valid
             && os_fileid_equal(&(vp->file_id), &file_id))) {
       // are the wildcard parts equal
-      if (ff_wc_equal(vp->ffv_wc_path, wc_path)) {
+      if (ff_wc_equal((char_u *)vp->ffv_wc_path, (char_u *)wc_path)) {
         // already visited
         return FAIL;
       }
@@ -1104,7 +1104,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *
   }
 
   if (wc_path != NULL) {
-    vp->ffv_wc_path = vim_strsave(wc_path);
+    vp->ffv_wc_path = xstrdup(wc_path);
   } else {
     vp->ffv_wc_path = NULL;
   }
@@ -1116,7 +1116,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char_u *fname, char_u *
 }
 
 /// create stack element from given path pieces
-static ff_stack_T *ff_create_stack_element(char_u *fix_part, char_u *wc_part, int level,
+static ff_stack_T *ff_create_stack_element(char *fix_part, char *wc_part, int level,
                                            int star_star_empty)
 {
   ff_stack_T *new = xmalloc(sizeof(ff_stack_T));
@@ -1131,14 +1131,14 @@ static ff_stack_T *ff_create_stack_element(char_u *fix_part, char_u *wc_part, in
 
   // the following saves NULL pointer checks in vim_findfile
   if (fix_part == NULL) {
-    fix_part = (char_u *)"";
+    fix_part = "";
   }
-  new->ffs_fix_path = vim_strsave(fix_part);
+  new->ffs_fix_path = (char_u *)xstrdup(fix_part);
 
   if (wc_part == NULL) {
-    wc_part  = (char_u *)"";
+    wc_part = "";
   }
-  new->ffs_wc_path = vim_strsave(wc_part);
+  new->ffs_wc_path = (char_u *)xstrdup(wc_part);
 
   return new;
 }
@@ -1292,7 +1292,7 @@ char_u *find_file_in_path(char_u *ptr, size_t len, int options, int first, char_
                                   FINDFILE_BOTH, rel_fname, (char_u *)curbuf->b_p_sua);
 }
 
-static char_u *ff_file_to_find = NULL;
+static char *ff_file_to_find = NULL;
 static void *fdip_search_ctx = NULL;
 
 #if defined(EXITFREE)
@@ -1338,7 +1338,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
   static char *dir;
   static int did_findfile_init = false;
   char_u save_char;
-  char_u *file_name = NULL;
+  char *file_name = NULL;
   char *buf = NULL;
   int rel_to_curdir;
 
@@ -1359,10 +1359,10 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
     ptr[len] = save_char;
 
     xfree(ff_file_to_find);
-    ff_file_to_find = vim_strsave((char_u *)NameBuff);
+    ff_file_to_find = xstrdup(NameBuff);
     if (options & FNAME_UNESC) {
       // Change all "\ " to " ".
-      for (ptr = ff_file_to_find; *ptr != NUL; ptr++) {
+      for (ptr = (char_u *)ff_file_to_find; *ptr != NUL; ptr++) {
         if (ptr[0] == '\\' && ptr[1] == ' ') {
           memmove(ptr, ptr + 1, STRLEN(ptr));
         }
@@ -1376,7 +1376,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
                        || (ff_file_to_find[1] == '.'
                            && (ff_file_to_find[2] == NUL
                                || vim_ispathsep(ff_file_to_find[2])))));
-  if (vim_isAbsName(ff_file_to_find)
+  if (vim_isAbsName((char_u *)ff_file_to_find)
       // "..", "../path", "." and "./path": don't use the path_option
       || rel_to_curdir
 #if defined(WIN32)
@@ -1390,8 +1390,8 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
     // If this is not a first call, return NULL.  We already returned a
     // filename on the first call.
     if (first == true) {
-      if (path_with_url((char *)ff_file_to_find)) {
-        file_name = vim_strsave(ff_file_to_find);
+      if (path_with_url(ff_file_to_find)) {
+        file_name = xstrdup(ff_file_to_find);
         goto theend;
       }
 
@@ -1420,7 +1420,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
                && (find_what == FINDFILE_BOTH
                    || ((find_what == FINDFILE_DIR)
                        == os_isdir(NameBuff))))) {
-            file_name = vim_strsave((char_u *)NameBuff);
+            file_name = xstrdup(NameBuff);
             goto theend;
           }
           if (*buf == NUL) {
@@ -1444,7 +1444,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
 
     for (;;) {
       if (did_findfile_init) {
-        file_name = vim_findfile(fdip_search_ctx);
+        file_name = (char *)vim_findfile(fdip_search_ctx);
         if (file_name != NULL) {
           break;
         }
@@ -1468,7 +1468,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
 
         // get the stopdir string
         r_ptr = vim_findfile_stopdir((char_u *)buf);
-        fdip_search_ctx = vim_findfile_init(buf, (char *)ff_file_to_find,
+        fdip_search_ctx = vim_findfile_init(buf, ff_file_to_find,
                                             (char *)r_ptr, 100, false, find_what,
                                             fdip_search_ctx, false, (char *)rel_fname);
         if (fdip_search_ctx != NULL) {
@@ -1499,7 +1499,7 @@ char_u *find_file_in_path_option(char_u *ptr, size_t len, int options, int first
   }
 
 theend:
-  return file_name;
+  return (char_u *)file_name;
 }
 
 void do_autocmd_dirchanged(char *new_dir, CdScope scope, CdCause cause, bool pre)
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index b399885095..0d8eec1023 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -2049,7 +2049,7 @@ static char_u *readfile_charconvert(char_u *fname, char_u *fenc, int *fdp)
   char_u *tmpname;
   char *errmsg = NULL;
 
-  tmpname = vim_tempname();
+  tmpname = (char_u *)vim_tempname();
   if (tmpname == NULL) {
     errmsg = _("Can't find temp file for conversion");
   } else {
@@ -2697,7 +2697,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
           }
         }
 
-        rootname = (char *)get_file_in_dir((char_u *)fname, IObuff);
+        rootname = get_file_in_dir(fname, (char *)IObuff);
         if (rootname == NULL) {
           some_error = true;                // out of memory
           goto nobackup;
@@ -2847,7 +2847,7 @@ nobackup:
         }
 
         if (backup == NULL) {
-          rootname = (char *)get_file_in_dir((char_u *)fname, IObuff);
+          rootname = get_file_in_dir(fname, (char *)IObuff);
           if (rootname == NULL) {
             backup = NULL;
           } else {
@@ -2993,7 +2993,7 @@ nobackup:
     // writing, write to a temp file instead and let the conversion
     // overwrite the original file.
     if (*p_ccv != NUL) {
-      wfname = (char *)vim_tempname();
+      wfname = vim_tempname();
       if (wfname == NULL) {  // Can't write without a tempfile!
         SET_ERRMSG(_("E214: Can't find temp file for writing"));
         goto restore_backup;
@@ -3170,7 +3170,7 @@ restore_backup:
     for (lnum = start; lnum <= end; lnum++) {
       // The next while loop is done once for each character written.
       // Keep it fast!
-      ptr = (char *)ml_get_buf(buf, lnum, false) - 1;
+      ptr = ml_get_buf(buf, lnum, false) - 1;
       if (write_undo_file) {
         sha256_update(&sha_ctx, (char_u *)ptr + 1, (uint32_t)(STRLEN(ptr + 1) + 1));
       }
@@ -4704,13 +4704,13 @@ static int move_lines(buf_T *frombuf, buf_T *tobuf)
   buf_T *tbuf = curbuf;
   int retval = OK;
   linenr_T lnum;
-  char_u *p;
+  char *p;
 
   // Copy the lines in "frombuf" to "tobuf".
   curbuf = tobuf;
   for (lnum = 1; lnum <= frombuf->b_ml.ml_line_count; lnum++) {
-    p = vim_strsave(ml_get_buf(frombuf, lnum, false));
-    if (ml_append(lnum - 1, (char *)p, 0, false) == FAIL) {
+    p = xstrdup(ml_get_buf(frombuf, lnum, false));
+    if (ml_append(lnum - 1, p, 0, false) == FAIL) {
       xfree(p);
       retval = FAIL;
       break;
@@ -5358,7 +5358,7 @@ static bool vim_settempdir(char *tempdir)
 ///
 /// @return  pointer to the temp file name or NULL if Nvim can't create
 ///          temporary directory for its own temporary files.
-char_u *vim_tempname(void)
+char *vim_tempname(void)
 {
   // Temp filename counter.
   static uint64_t temp_count;
@@ -5370,10 +5370,10 @@ char_u *vim_tempname(void)
 
   // There is no need to check if the file exists, because we own the directory
   // and nobody else creates a file in it.
-  char_u template[TEMP_FILE_PATH_MAXLEN];
-  snprintf((char *)template, TEMP_FILE_PATH_MAXLEN,
+  char template[TEMP_FILE_PATH_MAXLEN];
+  snprintf(template, TEMP_FILE_PATH_MAXLEN,
            "%s%" PRIu64, tempdir, temp_count++);
-  return vim_strsave(template);
+  return xstrdup(template);
 }
 
 /// Tries matching a filename with a "pattern" ("prog" is NULL), or use the
diff --git a/src/nvim/fold.c b/src/nvim/fold.c
index 0f085df3d0..2e8d282ede 100644
--- a/src/nvim/fold.c
+++ b/src/nvim/fold.c
@@ -1582,7 +1582,7 @@ static void foldAddMarker(buf_T *buf, pos_T pos, const char *marker, size_t mark
   linenr_T lnum = pos.lnum;
 
   // Allocate a new line: old-line + 'cms'-start + marker + 'cms'-end
-  char *line = (char *)ml_get_buf(buf, lnum, false);
+  char *line = ml_get_buf(buf, lnum, false);
   size_t line_len = STRLEN(line);
   size_t added = 0;
 
@@ -1640,7 +1640,7 @@ static void foldDelMarker(buf_T *buf, linenr_T lnum, char *marker, size_t marker
   }
 
   char *cms = buf->b_p_cms;
-  char *line = (char *)ml_get_buf(buf, lnum, false);
+  char *line = ml_get_buf(buf, lnum, false);
   for (char *p = line; *p != NUL; p++) {
     if (STRNCMP(p, marker, markerlen) != 0) {
       continue;
@@ -2848,7 +2848,7 @@ static void foldlevelIndent(fline_T *flp)
   linenr_T lnum = flp->lnum + flp->off;
 
   buf_T *buf = flp->wp->w_buffer;
-  char *s = skipwhite((char *)ml_get_buf(buf, lnum, false));
+  char *s = skipwhite(ml_get_buf(buf, lnum, false));
 
   // empty line or lines starting with a character in 'foldignore': level
   // depends on surrounding lines
@@ -3010,7 +3010,7 @@ static void foldlevelMarker(fline_T *flp)
   flp->start = 0;
   flp->lvl_next = flp->lvl;
 
-  char *s = (char *)ml_get_buf(flp->wp->w_buffer, flp->lnum + flp->off, false);
+  char *s = ml_get_buf(flp->wp->w_buffer, flp->lnum + flp->off, false);
   while (*s) {
     if (*s == cstart
         && STRNCMP(s + 1, startmarker, foldstartmarkerlen - 1) == 0) {
diff --git a/src/nvim/getchar.c b/src/nvim/getchar.c
index e125d88395..0f0e3aece1 100644
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -1708,26 +1708,26 @@ static void getchar_common(typval_T *argvars, typval_T *rettv)
 
   rettv->vval.v_number = n;
   if (n != 0 && (IS_SPECIAL(n) || mod_mask != 0)) {
-    char_u temp[10];                // modifier: 3, mbyte-char: 6, NUL: 1
+    char temp[10];                // modifier: 3, mbyte-char: 6, NUL: 1
     int i = 0;
 
     // Turn a special key into three bytes, plus modifier.
     if (mod_mask != 0) {
-      temp[i++] = K_SPECIAL;
-      temp[i++] = KS_MODIFIER;
-      temp[i++] = (char_u)mod_mask;
+      temp[i++] = (char)K_SPECIAL;
+      temp[i++] = (char)KS_MODIFIER;
+      temp[i++] = (char)mod_mask;
     }
     if (IS_SPECIAL(n)) {
-      temp[i++] = K_SPECIAL;
-      temp[i++] = (char_u)K_SECOND(n);
-      temp[i++] = K_THIRD(n);
+      temp[i++] = (char)K_SPECIAL;
+      temp[i++] = (char)K_SECOND(n);
+      temp[i++] = (char)K_THIRD(n);
     } else {
-      i += utf_char2bytes((int)n, (char *)temp + i);
+      i += utf_char2bytes((int)n, temp + i);
     }
     assert(i < 10);
     temp[i++] = NUL;
     rettv->v_type = VAR_STRING;
-    rettv->vval.v_string = (char *)vim_strsave(temp);
+    rettv->vval.v_string = xstrdup(temp);
 
     if (is_mouse_key((int)n)) {
       int row = mouse_row;
@@ -2135,7 +2135,7 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
 
   // complete match
   if (keylen >= 0 && keylen <= typebuf.tb_len) {
-    char_u *map_str = NULL;
+    char *map_str = NULL;
 
     // Write chars to script file(s).
     // Note: :lmap mappings are written *after* being applied. #5658
@@ -2175,8 +2175,8 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
     char save_m_expr = mp->m_expr;
     int save_m_noremap = mp->m_noremap;
     char save_m_silent = mp->m_silent;
-    char_u *save_m_keys = NULL;  // only saved when needed
-    char_u *save_m_str = NULL;  // only saved when needed
+    char *save_m_keys = NULL;  // only saved when needed
+    char *save_m_str = NULL;  // only saved when needed
     LuaRef save_m_luaref = mp->m_luaref;
 
     // Handle ":map <expr>": evaluate the {rhs} as an
@@ -2193,9 +2193,9 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
       vgetc_busy = 0;
       may_garbage_collect = false;
 
-      save_m_keys = vim_strsave(mp->m_keys);
+      save_m_keys = xstrdup((char *)mp->m_keys);
       if (save_m_luaref == LUA_NOREF) {
-        save_m_str = vim_strsave((char_u *)mp->m_str);
+        save_m_str = xstrdup(mp->m_str);
       }
       map_str = eval_map_expr(mp, NUL);
 
@@ -2207,13 +2207,13 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
       // If an error was displayed and the expression returns an empty
       // string, generate a <Nop> to allow for a redraw.
       if (prev_did_emsg != did_emsg && (map_str == NULL || *map_str == NUL)) {
-        char_u buf[4];
+        char buf[4];
         xfree(map_str);
-        buf[0] = K_SPECIAL;
-        buf[1] = KS_EXTRA;
+        buf[0] = (char)K_SPECIAL;
+        buf[1] = (char)KS_EXTRA;
         buf[2] = KE_IGNORE;
         buf[3] = NUL;
-        map_str = vim_strsave(buf);
+        map_str = xstrdup(buf);
         if (State & MODE_CMDLINE) {
           // redraw the command below the error
           msg_didout = true;
@@ -2227,7 +2227,7 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
       vgetc_busy = save_vgetc_busy;
       may_garbage_collect = save_may_garbage_collect;
     } else {
-      map_str = (char_u *)mp->m_str;
+      map_str = mp->m_str;
     }
 
     // Insert the 'to' part in the typebuf.tb_buf.
@@ -2242,18 +2242,18 @@ static int handle_mapping(int *keylenp, bool *timedout, int *mapdepth)
       // If this is a LANGMAP mapping, then we didn't record the keys
       // at the start of the function and have to record them now.
       if (keylen > typebuf.tb_maplen && (mp->m_mode & MODE_LANGMAP) != 0) {
-        gotchars(map_str, STRLEN(map_str));
+        gotchars((char_u *)map_str, STRLEN(map_str));
       }
 
       if (save_m_noremap != REMAP_YES) {
         noremap = save_m_noremap;
-      } else if (STRNCMP(map_str, save_m_keys != NULL ? save_m_keys : mp->m_keys,
+      } else if (STRNCMP(map_str, save_m_keys != NULL ? save_m_keys : (char *)mp->m_keys,
                          (size_t)keylen) != 0) {
         noremap = REMAP_YES;
       } else {
         noremap = REMAP_SKIP;
       }
-      i = ins_typebuf((char *)map_str, noremap, 0, true, cmd_silent || save_m_silent);
+      i = ins_typebuf(map_str, noremap, 0, true, cmd_silent || save_m_silent);
       if (save_m_expr) {
         xfree(map_str);
       }
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 060db3b3b1..84c01e0140 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -599,7 +599,7 @@ EXTERN int inhibit_delete_count INIT(= 0);
 #define DBCS_DEBUG     (-1)
 
 /// Encoding used when 'fencs' is set to "default"
-EXTERN char_u *fenc_default INIT(= NULL);
+EXTERN char *fenc_default INIT(= NULL);
 
 /// "State" is the main state of Vim.
 /// There are other variables that modify the state:
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 85f59f39de..903349dcae 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -2292,7 +2292,7 @@ int mch_print_init(prt_settings_T *psettings, char_u *jobname, int forceit)
 
   // If the user didn't specify a file name, use a temp file.
   if (psettings->outfile == NULL) {
-    prt_ps_file_name = vim_tempname();
+    prt_ps_file_name = (char_u *)vim_tempname();
     if (prt_ps_file_name == NULL) {
       emsg(_(e_notmp));
       return FAIL;
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 245d80489f..235f64744a 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -180,7 +180,7 @@ void ex_help(exarg_T *eap)
   // It is needed for do_tag top open folds under the cursor.
   KeyTyped = old_KeyTyped;
 
-  do_tag((char_u *)tag, DT_HELP, 1, false, true);
+  do_tag(tag, DT_HELP, 1, false, true);
 
   // Delete the empty buffer if we're not using it.  Careful: autocommands
   // may have jumped to another window, check that the buffer is not in a
@@ -658,13 +658,13 @@ void fix_help_buffer(void)
 
   if (!syntax_present(curwin)) {
     for (lnum = 1; lnum <= curbuf->b_ml.ml_line_count; lnum++) {
-      line = (char *)ml_get_buf(curbuf, lnum, false);
+      line = ml_get_buf(curbuf, lnum, false);
       const size_t len = STRLEN(line);
       if (in_example && len > 0 && !ascii_iswhite(line[0])) {
         // End of example: non-white or '<' in first column.
         if (line[0] == '<') {
           // blank-out a '<' in the first column
-          line = (char *)ml_get_buf(curbuf, lnum, true);
+          line = ml_get_buf(curbuf, lnum, true);
           line[0] = ' ';
         }
         in_example = false;
@@ -672,12 +672,12 @@ void fix_help_buffer(void)
       if (!in_example && len > 0) {
         if (line[len - 1] == '>' && (len == 1 || line[len - 2] == ' ')) {
           // blank-out a '>' in the last column (start of example)
-          line = (char *)ml_get_buf(curbuf, lnum, true);
+          line = ml_get_buf(curbuf, lnum, true);
           line[len - 1] = ' ';
           in_example = true;
         } else if (line[len - 1] == '~') {
           // blank-out a '~' at the end of line (header marker)
-          line = (char *)ml_get_buf(curbuf, lnum, true);
+          line = ml_get_buf(curbuf, lnum, true);
           line[len - 1] = ' ';
         }
       }
@@ -694,7 +694,7 @@ void fix_help_buffer(void)
           && TOLOWER_ASC(fname[7]) == 'x'
           && fname[8] == NUL)) {
     for (lnum = 1; lnum < curbuf->b_ml.ml_line_count; lnum++) {
-      line = (char *)ml_get_buf(curbuf, lnum, false);
+      line = ml_get_buf(curbuf, lnum, false);
       if (strstr(line, "*local-additions*") == NULL) {
         continue;
       }
@@ -1167,8 +1167,7 @@ void ex_helptags(exarg_T *eap)
   } else {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_DIRECTORIES;
-    dirname = (char *)ExpandOne(&xpc, (char_u *)eap->arg, NULL,
-                                WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
+    dirname = ExpandOne(&xpc, eap->arg, NULL, WILD_LIST_NOTFOUND|WILD_SILENT, WILD_EXPAND_FREE);
     if (dirname == NULL || !os_isdir(dirname)) {
       semsg(_("E150: Not a directory: %s"), eap->arg);
     } else {
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 412fe3509d..7e5fd52243 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -553,12 +553,12 @@ void init_highlight(bool both, bool reset)
 
   // Try finding the color scheme file.  Used when a color file was loaded
   // and 'background' or 't_Co' is changed.
-  char_u *p = get_var_value("g:colors_name");
+  char *p = (char *)get_var_value("g:colors_name");
   if (p != NULL) {
     // Value of g:colors_name could be freed in load_colors() and make
     // p invalid, so copy it.
-    char_u *copy_p = vim_strsave(p);
-    bool okay = load_colors(copy_p);
+    char *copy_p = xstrdup(p);
+    bool okay = load_colors((char_u *)copy_p);
     xfree(copy_p);
     if (okay) {
       return;
diff --git a/src/nvim/if_cscope.c b/src/nvim/if_cscope.c
index 85534ebcff..719899d0b8 100644
--- a/src/nvim/if_cscope.c
+++ b/src/nvim/if_cscope.c
@@ -228,16 +228,16 @@ void ex_cstag(exarg_T *eap)
         }
 
         if (cs_check_for_tags()) {
-          ret = do_tag((char_u *)eap->arg, DT_JUMP, 0, eap->forceit, false);
+          ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, false);
         }
       }
     } else if (cs_check_for_tags()) {
-      ret = do_tag((char_u *)eap->arg, DT_JUMP, 0, eap->forceit, false);
+      ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, false);
     }
     break;
   case 1:
     if (cs_check_for_tags()) {
-      ret = do_tag((char_u *)eap->arg, DT_JUMP, 0, eap->forceit, false);
+      ret = do_tag(eap->arg, DT_JUMP, 0, eap->forceit, false);
       if (ret == false) {
         if (msg_col) {
           msg_putchar('\n');
@@ -1003,7 +1003,7 @@ static bool cs_find_common(char *opt, char *pat, int forceit, int verbose, bool
   if (qfpos != NULL && *qfpos != '0') {
     // Fill error list.
     FILE *f;
-    char_u *tmp = vim_tempname();
+    char_u *tmp = (char_u *)vim_tempname();
     qf_info_T *qi = NULL;
     win_T *wp = NULL;
 
@@ -1053,7 +1053,7 @@ static bool cs_find_common(char *opt, char *pat, int forceit, int verbose, bool
 
     (void)cs_manage_matches(matches, contexts, matched, Store);
 
-    return do_tag((char_u *)pat, DT_CSCOPE, 0, forceit, verbose);
+    return do_tag(pat, DT_CSCOPE, 0, forceit, verbose);
   }
 }
 
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index a41a396abc..af5bcd7d2a 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -362,7 +362,7 @@ int get_indent_lnum(linenr_T lnum)
 // "buf".
 int get_indent_buf(buf_T *buf, linenr_T lnum)
 {
-  return get_indent_str_vtab((char *)ml_get_buf(buf, lnum, false),
+  return get_indent_str_vtab(ml_get_buf(buf, lnum, false),
                              curbuf->b_p_ts,
                              buf->b_p_vts_array,
                              false);
@@ -874,7 +874,7 @@ bool may_do_si(void)
   return curbuf->b_p_si && !curbuf->b_p_cin && *curbuf->b_p_inde == NUL && !p_paste;
 }
 
-// Get indent level from 'indentexpr'.
+/// Get indent level from 'indentexpr'.
 int get_expr_indent(void)
 {
   int indent = -1;
@@ -898,8 +898,8 @@ int get_expr_indent(void)
 
   // Need to make a copy, the 'indentexpr' option could be changed while
   // evaluating it.
-  char_u *inde_copy = vim_strsave((char_u *)curbuf->b_p_inde);
-  indent = (int)eval_to_number((char *)inde_copy);
+  char *inde_copy = xstrdup(curbuf->b_p_inde);
+  indent = (int)eval_to_number(inde_copy);
   xfree(inde_copy);
 
   if (use_sandbox) {
diff --git a/src/nvim/indent_c.c b/src/nvim/indent_c.c
index 5941473825..c7f37790b6 100644
--- a/src/nvim/indent_c.c
+++ b/src/nvim/indent_c.c
@@ -1838,7 +1838,7 @@ int get_c_indent(void)
   int cur_amount = MAXCOL;
   colnr_T col;
   char_u *theline;
-  char_u *linecopy;
+  char *linecopy;
   pos_T *trypos;
   pos_T *comment_pos;
   pos_T *tryposBrace = NULL;
@@ -1893,7 +1893,7 @@ int get_c_indent(void)
   // Get a copy of the current contents of the line.
   // This is required, because only the most recent line obtained with
   // ml_get is valid!
-  linecopy = vim_strsave((char_u *)ml_get(cur_curpos.lnum));
+  linecopy = xstrdup(ml_get(cur_curpos.lnum));
 
   // In insert mode and the cursor is on a ')' truncate the line at the
   // cursor position.  We don't want to line up with the matching '(' when
@@ -1906,7 +1906,7 @@ int get_c_indent(void)
     linecopy[curwin->w_cursor.col] = NUL;
   }
 
-  theline = (char_u *)skipwhite((char *)linecopy);
+  theline = (char_u *)skipwhite(linecopy);
 
   // move the cursor to the start of the line
 
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index dce72a2611..686461ce60 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -132,10 +132,10 @@ typedef struct compl_S compl_T;
 struct compl_S {
   compl_T *cp_next;
   compl_T *cp_prev;
-  char_u *cp_str;                ///< matched text
-  char_u *(cp_text[CPT_COUNT]);  ///< text for the menu
+  char *cp_str;                  ///< matched text
+  char *(cp_text[CPT_COUNT]);    ///< text for the menu
   typval_T cp_user_data;
-  char_u *cp_fname;              ///< file containing the match, allocated when
+  char *cp_fname;                ///< file containing the match, allocated when
                                  ///< cp_flags has CP_FREE_FNAME
   int cp_flags;                  ///< CP_ values
   int cp_number;                 ///< sequence number
@@ -191,7 +191,7 @@ static bool compl_enter_selects = false;
 
 /// When "compl_leader" is not NULL only matches that start with this string
 /// are used.
-static char_u *compl_leader = NULL;
+static char *compl_leader = NULL;
 
 static bool compl_get_longest = false;  ///< put longest common string in compl_leader
 
@@ -802,7 +802,7 @@ static int ins_compl_add(char *const str, int len, char *const fname, char *cons
   if (flags & CP_ORIGINAL_TEXT) {
     match->cp_number = 0;
   }
-  match->cp_str = (char_u *)xstrnsave(str, (size_t)len);
+  match->cp_str = xstrnsave(str, (size_t)len);
 
   // match-fname is:
   // - compl_curr_match->cp_fname if it is a string equal to fname.
@@ -814,7 +814,7 @@ static int ins_compl_add(char *const str, int len, char *const fname, char *cons
       && STRCMP(fname, compl_curr_match->cp_fname) == 0) {
     match->cp_fname = compl_curr_match->cp_fname;
   } else if (fname != NULL) {
-    match->cp_fname = vim_strsave((char_u *)fname);
+    match->cp_fname = xstrdup(fname);
     flags |= CP_FREE_FNAME;
   } else {
     match->cp_fname = NULL;
@@ -829,9 +829,7 @@ static int ins_compl_add(char *const str, int len, char *const fname, char *cons
         continue;
       }
       if (*cptext[i] != NUL) {
-        match->cp_text[i] = (cptext_allocated
-                             ? (char_u *)cptext[i]
-                             : (char_u *)xstrdup(cptext[i]));
+        match->cp_text[i] = (cptext_allocated ? cptext[i] : xstrdup(cptext[i]));
       } else if (cptext_allocated) {
         xfree(cptext[i]);
       }
@@ -898,11 +896,11 @@ static void ins_compl_longest_match(compl_T *match)
 
   if (compl_leader == NULL) {
     // First match, use it as a whole.
-    compl_leader = vim_strsave(match->cp_str);
+    compl_leader = xstrdup(match->cp_str);
 
     had_match = (curwin->w_cursor.col > compl_col);
     ins_compl_delete();
-    ins_bytes((char *)compl_leader + get_compl_len());
+    ins_bytes(compl_leader + get_compl_len());
     ins_redraw(false);
 
     // When the match isn't there (to avoid matching itself) remove it
@@ -916,8 +914,8 @@ static void ins_compl_longest_match(compl_T *match)
   }
 
   // Reduce the text if this match differs from compl_leader.
-  p = compl_leader;
-  s = match->cp_str;
+  p = (char_u *)compl_leader;
+  s = (char_u *)match->cp_str;
   while (*p != NUL) {
     c1 = utf_ptr2char((char *)p);
     c2 = utf_ptr2char((char *)s);
@@ -936,7 +934,7 @@ static void ins_compl_longest_match(compl_T *match)
     *p = NUL;
     had_match = (curwin->w_cursor.col > compl_col);
     ins_compl_delete();
-    ins_bytes((char *)compl_leader + get_compl_len());
+    ins_bytes(compl_leader + get_compl_len());
     ins_redraw(false);
 
     // When the match isn't there (to avoid matching itself) remove it
@@ -1131,7 +1129,7 @@ static int ins_compl_build_pum(void)
   do {
     if (!match_at_original_text(compl)
         && (compl_leader == NULL
-            || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
+            || ins_compl_equal(compl, (char_u *)compl_leader, (size_t)lead_len))) {
       compl_match_arraysize++;
     }
     compl = compl->cp_next;
@@ -1156,7 +1154,7 @@ static int ins_compl_build_pum(void)
   do {
     if (!match_at_original_text(compl)
         && (compl_leader == NULL
-            || ins_compl_equal(compl, compl_leader, (size_t)lead_len))) {
+            || ins_compl_equal(compl, (char_u *)compl_leader, (size_t)lead_len))) {
       if (!shown_match_ok) {
         if (compl == compl_shown_match || did_find_shown_match) {
           // This item is the shown match or this is the
@@ -1173,16 +1171,16 @@ static int ins_compl_build_pum(void)
       }
 
       if (compl->cp_text[CPT_ABBR] != NULL) {
-        compl_match_array[i].pum_text = compl->cp_text[CPT_ABBR];
+        compl_match_array[i].pum_text = (char_u *)compl->cp_text[CPT_ABBR];
       } else {
-        compl_match_array[i].pum_text = compl->cp_str;
+        compl_match_array[i].pum_text = (char_u *)compl->cp_str;
       }
-      compl_match_array[i].pum_kind = compl->cp_text[CPT_KIND];
-      compl_match_array[i].pum_info = compl->cp_text[CPT_INFO];
+      compl_match_array[i].pum_kind = (char_u *)compl->cp_text[CPT_KIND];
+      compl_match_array[i].pum_info = (char_u *)compl->cp_text[CPT_INFO];
       if (compl->cp_text[CPT_MENU] != NULL) {
-        compl_match_array[i++].pum_extra = compl->cp_text[CPT_MENU];
+        compl_match_array[i++].pum_extra = (char_u *)compl->cp_text[CPT_MENU];
       } else {
-        compl_match_array[i++].pum_extra = compl->cp_fname;
+        compl_match_array[i++].pum_extra = (char_u *)compl->cp_fname;
       }
     }
 
@@ -1236,8 +1234,8 @@ void ins_compl_show_pum(void)
   } else {
     // popup menu already exists, only need to find the current item.
     for (int i = 0; i < compl_match_arraysize; i++) {
-      if (compl_match_array[i].pum_text == compl_shown_match->cp_str
-          || compl_match_array[i].pum_text == compl_shown_match->cp_text[CPT_ABBR]) {
+      if (compl_match_array[i].pum_text == (char_u *)compl_shown_match->cp_str
+          || compl_match_array[i].pum_text == (char_u *)compl_shown_match->cp_text[CPT_ABBR]) {
         cur = i;
         break;
       }
@@ -1649,7 +1647,7 @@ int ins_compl_bs(void)
   line = get_cursor_line_ptr();
 
   xfree(compl_leader);
-  compl_leader = (char_u *)xstrnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
+  compl_leader = xstrnsave(line + compl_col, (size_t)(p_off - (ptrdiff_t)compl_col));
 
   ins_compl_new_leader();
   if (compl_shown_match != NULL) {
@@ -1678,7 +1676,7 @@ static void ins_compl_new_leader(void)
 {
   ins_compl_del_pum();
   ins_compl_delete();
-  ins_bytes((char *)compl_leader + get_compl_len());
+  ins_bytes(compl_leader + get_compl_len());
   compl_used_match = false;
 
   if (compl_started) {
@@ -1743,8 +1741,8 @@ void ins_compl_addleader(int c)
   }
 
   xfree(compl_leader);
-  compl_leader = (char_u *)xstrnsave(get_cursor_line_ptr() + compl_col,
-                                     (size_t)(curwin->w_cursor.col - compl_col));
+  compl_leader = xstrnsave(get_cursor_line_ptr() + compl_col,
+                           (size_t)(curwin->w_cursor.col - compl_col));
   ins_compl_new_leader();
 }
 
@@ -1764,7 +1762,7 @@ static void ins_compl_restart(void)
 }
 
 /// Set the first match, the original text.
-static void ins_compl_set_original_text(char_u *str)
+static void ins_compl_set_original_text(char *str)
   FUNC_ATTR_NONNULL_ALL
 {
   // Replace the original text entry.
@@ -1772,11 +1770,11 @@ static void ins_compl_set_original_text(char_u *str)
   // be at the last item for backward completion
   if (match_at_original_text(compl_first_match)) {  // safety check
     xfree(compl_first_match->cp_str);
-    compl_first_match->cp_str = vim_strsave(str);
+    compl_first_match->cp_str = xstrdup(str);
   } else if (compl_first_match->cp_prev != NULL
              && match_at_original_text(compl_first_match->cp_prev)) {
     xfree(compl_first_match->cp_prev->cp_str);
-    compl_first_match->cp_prev->cp_str = vim_strsave(str);
+    compl_first_match->cp_prev->cp_str = xstrdup(str);
   }
 }
 
@@ -1789,7 +1787,7 @@ void ins_compl_addfrommatch(void)
   int c;
   compl_T *cp;
   assert(compl_shown_match != NULL);
-  p = compl_shown_match->cp_str;
+  p = (char_u *)compl_shown_match->cp_str;
   if ((int)STRLEN(p) <= len) {   // the match is too short
     // When still at the original match use the first entry that matches
     // the leader.
@@ -1801,8 +1799,8 @@ void ins_compl_addfrommatch(void)
     for (cp = compl_shown_match->cp_next; cp != NULL
          && !is_first_match(cp); cp = cp->cp_next) {
       if (compl_leader == NULL
-          || ins_compl_equal(cp, compl_leader, STRLEN(compl_leader))) {
-        p = cp->cp_str;
+          || ins_compl_equal(cp, (char_u *)compl_leader, STRLEN(compl_leader))) {
+        p = (char_u *)cp->cp_str;
         break;
       }
     }
@@ -1955,7 +1953,7 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
     // CTRL-E then don't use the current match.
     char_u *ptr;
     if (compl_curr_match != NULL && compl_used_match && c != Ctrl_E) {
-      ptr = compl_curr_match->cp_str;
+      ptr = (char_u *)compl_curr_match->cp_str;
     } else {
       ptr = NULL;
     }
@@ -2006,7 +2004,7 @@ static bool ins_compl_stop(const int c, const int prev_mode, bool retval)
     ins_compl_delete();
     char_u *p = NULL;
     if (compl_leader != NULL) {
-      p = compl_leader;
+      p = (char_u *)compl_leader;
     } else if (compl_first_match != NULL) {
       p = (char_u *)compl_orig_text;
     }
@@ -2168,7 +2166,7 @@ static void ins_compl_fixRedoBufForLeader(char_u *ptr_arg)
 
   if (ptr == NULL) {
     if (compl_leader != NULL) {
-      ptr = compl_leader;
+      ptr = (char_u *)compl_leader;
     } else {
       return;        // nothing to do
     }
@@ -2919,14 +2917,14 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
                                               bool *cont_s_ipos)
 {
   *match_len = 0;
-  char_u *ptr = ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
+  char_u *ptr = (char_u *)ml_get_buf(ins_buf, cur_match_pos->lnum, false) + cur_match_pos->col;
   int len;
   if (ctrl_x_mode_line_or_eval()) {
     if (compl_status_adding()) {
       if (cur_match_pos->lnum >= ins_buf->b_ml.ml_line_count) {
         return NULL;
       }
-      ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+      ptr = (char_u *)ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
       if (!p_paste) {
         ptr = (char_u *)skipwhite((char *)ptr);
       }
@@ -2954,7 +2952,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
         // normal command "J" was used. IOSIZE is always greater than
         // compl_length, so the next STRNCPY always works -- Acevedo
         STRNCPY(IObuff, ptr, len);  // NOLINT(runtime/printf)
-        ptr = ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
+        ptr = (char_u *)ml_get_buf(ins_buf, cur_match_pos->lnum + 1, false);
         tmp_ptr = ptr = (char_u *)skipwhite((char *)ptr);
         // Find start of next word.
         tmp_ptr = find_word_start(tmp_ptr);
@@ -3275,7 +3273,7 @@ static int ins_compl_get_exp(pos_T *ini)
 static void ins_compl_update_shown_match(void)
 {
   while (!ins_compl_equal(compl_shown_match,
-                          compl_leader, STRLEN(compl_leader))
+                          (char_u *)compl_leader, STRLEN(compl_leader))
          && compl_shown_match->cp_next != NULL
          && !is_first_match(compl_shown_match->cp_next)) {
     compl_shown_match = compl_shown_match->cp_next;
@@ -3284,10 +3282,10 @@ static void ins_compl_update_shown_match(void)
   // If we didn't find it searching forward, and compl_shows_dir is
   // backward, find the last match.
   if (compl_shows_dir_backward()
-      && !ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
+      && !ins_compl_equal(compl_shown_match, (char_u *)compl_leader, STRLEN(compl_leader))
       && (compl_shown_match->cp_next == NULL
           || is_first_match(compl_shown_match->cp_next))) {
-    while (!ins_compl_equal(compl_shown_match, compl_leader, STRLEN(compl_leader))
+    while (!ins_compl_equal(compl_shown_match, (char_u *)compl_leader, STRLEN(compl_leader))
            && compl_shown_match->cp_prev != NULL
            && !is_first_match(compl_shown_match->cp_prev)) {
       compl_shown_match = compl_shown_match->cp_prev;
@@ -3321,7 +3319,7 @@ void ins_compl_delete(void)
 /// "in_compl_func" is true when called from complete_check().
 void ins_compl_insert(bool in_compl_func)
 {
-  ins_bytes((char *)compl_shown_match->cp_str + get_compl_len());
+  ins_bytes(compl_shown_match->cp_str + get_compl_len());
   compl_used_match = !match_at_original_text(compl_shown_match);
 
   dict_T *dict = ins_compl_dict_alloc(compl_shown_match);
@@ -3346,7 +3344,7 @@ static void ins_compl_show_filename(void)
   // the text that fits in "space" between "s" and "e".
   char *s;
   char *e;
-  for (s = e = (char *)compl_shown_match->cp_fname; *e != NUL; MB_PTR_ADV(e)) {
+  for (s = e = compl_shown_match->cp_fname; *e != NUL; MB_PTR_ADV(e)) {
     space -= ptr2cells(e);
     while (space < 0) {
       space += ptr2cells(s);
@@ -3355,7 +3353,7 @@ static void ins_compl_show_filename(void)
   }
   msg_hist_off = true;
   vim_snprintf((char *)IObuff, IOSIZE, "%s %s%s", lead,
-               (char_u *)s > compl_shown_match->cp_fname ? "<" : "", s);
+               s > compl_shown_match->cp_fname ? "<" : "", s);
   msg((char *)IObuff);
   msg_hist_off = false;
   redraw_cmdline = false;  // don't overwrite!
@@ -3432,7 +3430,7 @@ static int find_next_completion_match(bool allow_get_expansion, int todo, bool a
     if (!match_at_original_text(compl_shown_match)
         && compl_leader != NULL
         && !ins_compl_equal(compl_shown_match,
-                            compl_leader, STRLEN(compl_leader))) {
+                            (char_u *)compl_leader, STRLEN(compl_leader))) {
       todo++;
     } else {
       // Remember a matching item.
@@ -3519,7 +3517,7 @@ static int ins_compl_next(bool allow_get_expansion, int count, bool insert_match
     if (!compl_get_longest || compl_used_match) {
       ins_compl_insert(in_compl_func);
     } else {
-      ins_bytes((char *)compl_leader + get_compl_len());
+      ins_bytes(compl_leader + get_compl_len());
     }
   } else {
     compl_used_match = false;
diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index 49d49f76b9..21dd5139d7 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -388,12 +388,12 @@ nlua_pop_typval_table_processing_end:
       LuaCFunctionState *state = xmalloc(sizeof(LuaCFunctionState));
       state->lua_callable.func_ref = nlua_ref_global(lstate, -1);
 
-      char_u *name = register_cfunc(&nlua_CFunction_func_call,
-                                    &nlua_CFunction_func_free,
-                                    state);
+      char *name = (char *)register_cfunc(&nlua_CFunction_func_call,
+                                          &nlua_CFunction_func_free,
+                                          state);
 
       cur.tv->v_type = VAR_FUNC;
-      cur.tv->vval.v_string = (char *)vim_strsave(name);
+      cur.tv->vval.v_string = xstrdup(name);
       break;
     }
     case LUA_TUSERDATA: {
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 1b874e673a..e3d6a7eec8 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -111,7 +111,7 @@ static int regex_match_line(lua_State *lstate)
     return luaL_error(lstate, "invalid row");
   }
 
-  char_u *line = ml_get_buf(buf, rownr + 1, false);
+  char_u *line = (char_u *)ml_get_buf(buf, rownr + 1, false);
   size_t len = STRLEN(line);
 
   if (start < 0 || (size_t)start > len) {
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 65e024b707..971a47f8c9 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -332,7 +332,7 @@ static const char *input_cb(void *payload, uint32_t byte_index, TSPoint position
     *bytes_read = 0;
     return "";
   }
-  char *line = (char *)ml_get_buf(bp, (linenr_T)position.row + 1, false);
+  char *line = ml_get_buf(bp, (linenr_T)position.row + 1, false);
   size_t len = STRLEN(line);
   if (position.column > len) {
     *bytes_read = 0;
diff --git a/src/nvim/macros.h b/src/nvim/macros.h
index b84539852f..1024ca5015 100644
--- a/src/nvim/macros.h
+++ b/src/nvim/macros.h
@@ -54,7 +54,7 @@
 #define ASCII_ISALNUM(c) (ASCII_ISALPHA(c) || ascii_isdigit(c))
 
 // Returns empty string if it is NULL.
-#define EMPTY_IF_NULL(x) (char *)((x) ? (x) : (char_u *)"")
+#define EMPTY_IF_NULL(x) ((x) ? (x) : "")
 
 /// Adjust chars in a language according to 'langmap' option.
 /// NOTE that there is no noticeable overhead if 'langmap' is not set.
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 923eea145c..94b432a553 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -303,7 +303,7 @@ static void set_maparg_rhs(const char *const orig_rhs, const size_t orig_rhs_len
       // NB: replace_termcodes may produce an empty string even if orig_rhs is non-empty
       // (e.g. a single ^V, see :h map-empty-rhs)
       mapargs->rhs_is_noop = orig_rhs_len != 0 && mapargs->rhs_len == 0;
-      mapargs->rhs = (char_u *)replaced;
+      mapargs->rhs = replaced;
     }
   } else {
     char tmp_buf[64];
@@ -313,7 +313,7 @@ static void set_maparg_rhs(const char *const orig_rhs, const size_t orig_rhs_len
     // stores <lua>ref_no<cr> in map_str
     mapargs->rhs_len = (size_t)vim_snprintf(S_LEN(tmp_buf), "%c%c%c%d\r", K_SPECIAL,
                                             (char_u)KS_EXTRA, KE_LUA, rhs_lua);
-    mapargs->rhs = vim_strsave((char_u *)tmp_buf);
+    mapargs->rhs = xstrdup(tmp_buf);
   }
 }
 
@@ -439,7 +439,7 @@ static int str_to_mapargs(const char_u *strargs, bool is_unmap, MapArguments *ma
 ///              and "desc" fields are used.
 ///              "rhs", "rhs_lua", "orig_rhs" fields are cleared if "simplified" is false.
 /// @param sid  -1 to use current_sctx
-static void map_add(buf_T *buf, mapblock_T **map_table, mapblock_T **abbr_table, const char_u *keys,
+static void map_add(buf_T *buf, mapblock_T **map_table, mapblock_T **abbr_table, const char *keys,
                     MapArguments *args, int noremap, int mode, bool is_abbr, scid_T sid,
                     linenr_T lnum, bool simplified)
 {
@@ -454,8 +454,8 @@ static void map_add(buf_T *buf, mapblock_T **map_table, mapblock_T **abbr_table,
     }
   }
 
-  mp->m_keys = vim_strsave(keys);
-  mp->m_str = (char *)args->rhs;
+  mp->m_keys = (uint8_t *)xstrdup(keys);
+  mp->m_str = args->rhs;
   mp->m_orig_str = (char *)args->orig_rhs;
   mp->m_luaref = args->rhs_lua;
   if (!simplified) {
@@ -767,7 +767,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
                     XFREE_CLEAR(mp->m_str);
                     XFREE_CLEAR(mp->m_orig_str);
                   }
-                  mp->m_str = (char *)args->rhs;
+                  mp->m_str = args->rhs;
                   mp->m_orig_str = (char *)args->orig_rhs;
                   mp->m_luaref = args->rhs_lua;
                   if (!keyround1_simplified) {
@@ -846,7 +846,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
     }
 
     // Get here when adding a new entry to the maphash[] list or abbrlist.
-    map_add(buf, map_table, abbr_table, lhs, args, noremap, mode, is_abbrev,
+    map_add(buf, map_table, abbr_table, (char *)lhs, args, noremap, mode, is_abbrev,
             -1,  // sid
             0,   // lnum
             keyround1_simplified);
@@ -1265,7 +1265,7 @@ int ExpandMappings(regmatch_T *regmatch, int *num_file, char ***file)
   int hash;
   int count;
   int round;
-  char_u *p;
+  char *p;
   int i;
 
   *num_file = 0;                    // return values in case of FAIL
@@ -1278,28 +1278,28 @@ int ExpandMappings(regmatch_T *regmatch, int *num_file, char ***file)
 
     for (i = 0; i < 7; i++) {
       if (i == 0) {
-        p = (char_u *)"<silent>";
+        p = "<silent>";
       } else if (i == 1) {
-        p = (char_u *)"<unique>";
+        p = "<unique>";
       } else if (i == 2) {
-        p = (char_u *)"<script>";
+        p = "<script>";
       } else if (i == 3) {
-        p = (char_u *)"<expr>";
+        p = "<expr>";
       } else if (i == 4 && !expand_buffer) {
-        p = (char_u *)"<buffer>";
+        p = "<buffer>";
       } else if (i == 5) {
-        p = (char_u *)"<nowait>";
+        p = "<nowait>";
       } else if (i == 6) {
-        p = (char_u *)"<special>";
+        p = "<special>";
       } else {
         continue;
       }
 
-      if (vim_regexec(regmatch, (char *)p, (colnr_T)0)) {
+      if (vim_regexec(regmatch, p, (colnr_T)0)) {
         if (round == 1) {
           count++;
         } else {
-          (*file)[count++] = (char *)vim_strsave(p);
+          (*file)[count++] = xstrdup(p);
         }
       }
     }
@@ -1317,12 +1317,12 @@ int ExpandMappings(regmatch_T *regmatch, int *num_file, char ***file)
       }
       for (; mp; mp = mp->m_next) {
         if (mp->m_mode & expand_mapmodes) {
-          p = translate_mapping(mp->m_keys, CPO_TO_CPO_FLAGS);
-          if (p != NULL && vim_regexec(regmatch, (char *)p, (colnr_T)0)) {
+          p = (char *)translate_mapping(mp->m_keys, CPO_TO_CPO_FLAGS);
+          if (p != NULL && vim_regexec(regmatch, p, (colnr_T)0)) {
             if (round == 1) {
               count++;
             } else {
-              (*file)[count++] = (char *)p;
+              (*file)[count++] = p;
               p = NULL;
             }
           }
@@ -1447,20 +1447,20 @@ bool check_abbr(int c, char_u *ptr, int col, int mincol)
          mp->m_next == NULL ? (mp = mp2, mp2 = NULL) :
          (mp = mp->m_next)) {
       int qlen = mp->m_keylen;
-      char_u *q = mp->m_keys;
+      char *q = (char *)mp->m_keys;
       int match;
 
       if (strchr((const char *)mp->m_keys, K_SPECIAL) != NULL) {
         // Might have K_SPECIAL escaped mp->m_keys.
-        q = vim_strsave(mp->m_keys);
-        vim_unescape_ks(q);
+        q = xstrdup((char *)mp->m_keys);
+        vim_unescape_ks((char_u *)q);
         qlen = (int)STRLEN(q);
       }
       // find entries with right mode and keys
       match = (mp->m_mode & State)
               && qlen == len
               && !STRNCMP(q, ptr, (size_t)len);
-      if (q != mp->m_keys) {
+      if (q != (char *)mp->m_keys) {
         xfree(q);
       }
       if (match) {
@@ -1510,7 +1510,7 @@ bool check_abbr(int c, char_u *ptr, int col, int mincol)
         (void)ins_typebuf((char *)tb, 1, 0, true, mp->m_silent);
       }
       if (mp->m_expr) {
-        s = eval_map_expr(mp, c);
+        s = (char_u *)eval_map_expr(mp, c);
       } else {
         s = (char_u *)mp->m_str;
       }
@@ -1540,16 +1540,16 @@ bool check_abbr(int c, char_u *ptr, int col, int mincol)
 /// special characters.
 ///
 /// @param c  NUL or typed character for abbreviation
-char_u *eval_map_expr(mapblock_T *mp, int c)
+char *eval_map_expr(mapblock_T *mp, int c)
 {
-  char_u *p = NULL;
-  char_u *expr = NULL;
+  char *p = NULL;
+  char *expr = NULL;
 
   // Remove escaping of K_SPECIAL, because "str" is in a format to be used as
   // typeahead.
   if (mp->m_luaref == LUA_NOREF) {
-    expr = vim_strsave((char_u *)mp->m_str);
-    vim_unescape_ks(expr);
+    expr = xstrdup(mp->m_str);
+    vim_unescape_ks((char_u *)expr);
   }
 
   // Forbid changing text or using ":normal" to avoid most of the bad side
@@ -1565,7 +1565,7 @@ char_u *eval_map_expr(mapblock_T *mp, int c)
     Array args = ARRAY_DICT_INIT;
     Object ret = nlua_call_ref(mp->m_luaref, NULL, args, true, &err);
     if (ret.type == kObjectTypeString) {
-      p = (char_u *)xstrndup(ret.data.string.data, ret.data.string.size);
+      p = xstrndup(ret.data.string.data, ret.data.string.size);
     }
     api_free_object(ret);
     if (err.type != kErrorTypeNone) {
@@ -1573,7 +1573,7 @@ char_u *eval_map_expr(mapblock_T *mp, int c)
       api_clear_error(&err);
     }
   } else {
-    p = (char_u *)eval_to_string((char *)expr, NULL, false);
+    p = eval_to_string(expr, NULL, false);
     xfree(expr);
   }
   textlock--;
@@ -1586,13 +1586,13 @@ char_u *eval_map_expr(mapblock_T *mp, int c)
     return NULL;
   }
 
-  char_u *res = NULL;
+  char *res = NULL;
 
   if (mp->m_replace_keycodes) {
-    replace_termcodes((char *)p, STRLEN(p), (char **)&res, REPTERM_DO_LT, NULL, CPO_TO_CPO_FLAGS);
+    replace_termcodes(p, STRLEN(p), &res, REPTERM_DO_LT, NULL, CPO_TO_CPO_FLAGS);
   } else {
     // Escape K_SPECIAL in the result to be able to use the string as typeahead.
-    res = (char_u *)vim_strsave_escape_ks((char *)p);
+    res = vim_strsave_escape_ks(p);
   }
   xfree(p);
 
@@ -2204,10 +2204,10 @@ void f_mapset(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   xfree(unmap_args.orig_rhs);
 
   if (lhsrawalt != NULL) {
-    map_add(curbuf, map_table, abbr_table, (char_u *)lhsrawalt, &args, noremap, mode, is_abbr,
+    map_add(curbuf, map_table, abbr_table, lhsrawalt, &args, noremap, mode, is_abbr,
             sid, lnum, true);
   }
-  map_add(curbuf, map_table, abbr_table, (char_u *)lhsraw, &args, noremap, mode, is_abbr,
+  map_add(curbuf, map_table, abbr_table, lhsraw, &args, noremap, mode, is_abbr,
           sid, lnum, false);
 }
 
diff --git a/src/nvim/mapping.h b/src/nvim/mapping.h
index 7c48c3bce2..182d1a48cb 100644
--- a/src/nvim/mapping.h
+++ b/src/nvim/mapping.h
@@ -35,7 +35,7 @@ struct map_arguments {
   char_u alt_lhs[MAXMAPLEN + 1];
   size_t alt_lhs_len;
 
-  char_u *rhs;  /// The {rhs} of the mapping.
+  char *rhs;  /// The {rhs} of the mapping.
   size_t rhs_len;
   LuaRef rhs_lua;  /// lua function as {rhs}
   bool rhs_is_noop;  /// True when the {rhs} should be <Nop>.
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index 7838986edd..a6d0a68323 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -992,22 +992,22 @@ void ex_delmarks(exarg_T *eap)
 void ex_jumps(exarg_T *eap)
 {
   int i;
-  char_u *name;
+  char *name;
 
   cleanup_jumplist(curwin, true);
   // Highlight title
   msg_puts_title(_("\n jump line  col file/text"));
   for (i = 0; i < curwin->w_jumplistlen && !got_int; i++) {
     if (curwin->w_jumplist[i].fmark.mark.lnum != 0) {
-      name = fm_getname(&curwin->w_jumplist[i].fmark, 16);
+      name = (char *)fm_getname(&curwin->w_jumplist[i].fmark, 16);
 
       // Make sure to output the current indicator, even when on an wiped
       // out buffer.  ":filter" may still skip it.
       if (name == NULL && i == curwin->w_jumplistidx) {
-        name = vim_strsave((char_u *)"-invalid-");
+        name = xstrdup("-invalid-");
       }
       // apply :filter /pat/ or file name not available
-      if (name == NULL || message_filtered((char *)name)) {
+      if (name == NULL || message_filtered(name)) {
         xfree(name);
         continue;
       }
@@ -1022,7 +1022,7 @@ void ex_jumps(exarg_T *eap)
                i > curwin->w_jumplistidx ? i - curwin->w_jumplistidx : curwin->w_jumplistidx - i,
                curwin->w_jumplist[i].fmark.mark.lnum, curwin->w_jumplist[i].fmark.mark.col);
       msg_outtrans((char *)IObuff);
-      msg_outtrans_attr((char *)name,
+      msg_outtrans_attr(name,
                         curwin->w_jumplist[i].fmark.fnum == curbuf->b_fnum
                         ? HL_ATTR(HLF_D) : 0);
       xfree(name);
@@ -1710,7 +1710,7 @@ void mark_mb_adjustpos(buf_T *buf, pos_T *lp)
   FUNC_ATTR_NONNULL_ALL
 {
   if (lp->col > 0 || lp->coladd > 1) {
-    const char_u *const p = ml_get_buf(buf, lp->lnum, false);
+    const char_u *const p = (char_u *)ml_get_buf(buf, lp->lnum, false);
     if (*p == NUL || (int)STRLEN(p) < lp->col) {
       lp->col = 0;
     } else {
diff --git a/src/nvim/match.c b/src/nvim/match.c
index b6d700b148..cd8c65cc02 100644
--- a/src/nvim/match.c
+++ b/src/nvim/match.c
@@ -446,7 +446,7 @@ static void next_search_hl(win_T *win, match_T *search_hl, match_T *shl, linenr_
       char_u *ml;
 
       matchcol = shl->rm.startpos[0].col;
-      ml = ml_get_buf(shl->buf, lnum, false) + matchcol;
+      ml = (char_u *)ml_get_buf(shl->buf, lnum, false) + matchcol;
       if (*ml == NUL) {
         matchcol++;
         shl->lnum = 0;
@@ -613,7 +613,7 @@ bool prepare_search_hl_line(win_T *wp, linenr_T lnum, colnr_T mincol, char_u **l
 
     // Need to get the line again, a multi-line regexp may have made it
     // invalid.
-    *line = ml_get_buf(wp->w_buffer, lnum, false);
+    *line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
 
     if (shl->lnum != 0 && shl->lnum <= lnum) {
       if (shl->lnum == lnum) {
@@ -721,7 +721,7 @@ int update_search_hl(win_T *wp, linenr_T lnum, colnr_T col, char_u **line, match
 
         // Need to get the line again, a multi-line regexp
         // may have made it invalid.
-        *line = ml_get_buf(wp->w_buffer, lnum, false);
+        *line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
 
         if (shl->lnum == lnum) {
           shl->startcol = shl->rm.startpos[0].col;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 116a66e773..83b0609052 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -1536,7 +1536,7 @@ void show_utf8(void)
 
   // Get the byte length of the char under the cursor, including composing
   // characters.
-  line = get_cursor_pos_ptr();
+  line = (char_u *)get_cursor_pos_ptr();
   len = utfc_ptr2len((char *)line);
   if (len == 0) {
     msg("NUL");
@@ -1891,7 +1891,7 @@ void utf_find_illegal(void)
 
   curwin->w_cursor.coladd = 0;
   for (;;) {
-    p = get_cursor_pos_ptr();
+    p = (char_u *)get_cursor_pos_ptr();
     if (vimconv.vc_type != CONV_NONE) {
       xfree(tofree);
       tofree = (char_u *)string_convert(&vimconv, (char *)p, NULL);
@@ -1908,12 +1908,12 @@ void utf_find_illegal(void)
       if (*p >= 0x80 && (len == 1
                          || utf_char2len(utf_ptr2char((char *)p)) != len)) {
         if (vimconv.vc_type == CONV_NONE) {
-          curwin->w_cursor.col += (colnr_T)(p - get_cursor_pos_ptr());
+          curwin->w_cursor.col += (colnr_T)(p - (char_u *)get_cursor_pos_ptr());
         } else {
           int l;
 
           len = (int)(p - tofree);
-          for (p = get_cursor_pos_ptr(); *p != NUL && len-- > 0; p += l) {
+          for (p = (char_u *)get_cursor_pos_ptr(); *p != NUL && len-- > 0; p += l) {
             l = utf_ptr2len((char *)p);
             curwin->w_cursor.col += l;
           }
@@ -1980,7 +1980,7 @@ void mb_check_adjust_col(void *win_)
 
   // Column 0 is always valid.
   if (oldcol != 0) {
-    char *p = (char *)ml_get_buf(win->w_buffer, win->w_cursor.lnum, false);
+    char *p = ml_get_buf(win->w_buffer, win->w_cursor.lnum, false);
     colnr_T len = (colnr_T)STRLEN(p);
 
     // Empty line or invalid column?
@@ -2114,27 +2114,27 @@ char *enc_skip(char *p)
 char *enc_canonize(char *enc)
   FUNC_ATTR_NONNULL_RET
 {
-  char_u *p, *s;
+  char *p, *s;
   if (STRCMP(enc, "default") == 0) {
     // Use the default encoding as found by set_init_1().
-    return (char *)vim_strsave(fenc_default);
+    return xstrdup(fenc_default);
   }
 
   // copy "enc" to allocated memory, with room for two '-'
-  char_u *r = xmalloc(STRLEN(enc) + 3);
+  char *r = xmalloc(STRLEN(enc) + 3);
   // Make it all lower case and replace '_' with '-'.
   p = r;
-  for (s = (char_u *)enc; *s != NUL; s++) {
+  for (s = enc; *s != NUL; s++) {
     if (*s == '_') {
       *p++ = '-';
     } else {
-      *p++ = (char_u)TOLOWER_ASC(*s);
+      *p++ = (char)TOLOWER_ASC(*s);
     }
   }
   *p = NUL;
 
   // Skip "2byte-" and "8bit-".
-  p = (char_u *)enc_skip((char *)r);
+  p = enc_skip(r);
 
   // Change "microsoft-cp" to "cp".  Used in some spell files.
   if (STRNCMP(p, "microsoft-cp", 12) == 0) {
@@ -2159,17 +2159,17 @@ char *enc_canonize(char *enc)
   }
 
   int i;
-  if (enc_canon_search(p) >= 0) {
+  if (enc_canon_search((char_u *)p) >= 0) {
     // canonical name can be used unmodified
     if (p != r) {
       STRMOVE(r, p);
     }
-  } else if ((i = enc_alias_search(p)) >= 0) {
+  } else if ((i = enc_alias_search((char_u *)p)) >= 0) {
     // alias recognized, get canonical name
     xfree(r);
-    r = vim_strsave((char_u *)enc_canon_table[i].name);
+    r = xstrdup(enc_canon_table[i].name);
   }
-  return (char *)r;
+  return r;
 }
 
 /// Search for an encoding alias of "name".
@@ -2491,7 +2491,7 @@ char_u *string_convert_ext(const vimconv_T *const vcp, char_u *ptr, size_t *lenp
     len = *lenp;
   }
   if (len == 0) {
-    return vim_strsave((char_u *)"");
+    return (char_u *)xstrdup("");
   }
 
   switch (vcp->vc_type) {
diff --git a/src/nvim/memfile.c b/src/nvim/memfile.c
index 9446aaee4f..bb9be0766e 100644
--- a/src/nvim/memfile.c
+++ b/src/nvim/memfile.c
@@ -170,7 +170,7 @@ void mf_close(memfile_T *mfp, bool del_file)
     emsg(_(e_swapclose));
   }
   if (del_file && mfp->mf_fname != NULL) {
-    os_remove((char *)mfp->mf_fname);
+    os_remove(mfp->mf_fname);
   }
 
   // free entries in used list
@@ -210,7 +210,7 @@ void mf_close_file(buf_T *buf, bool getlines)
   mfp->mf_fd = -1;
 
   if (mfp->mf_fname != NULL) {
-    os_remove((char *)mfp->mf_fname);    // delete the swap file
+    os_remove(mfp->mf_fname);    // delete the swap file
     mf_free_fnames(mfp);
   }
 }
@@ -751,8 +751,8 @@ void mf_free_fnames(memfile_T *mfp)
 /// name so we must work out the full path name.
 void mf_set_fnames(memfile_T *mfp, char *fname)
 {
-  mfp->mf_fname = (char_u *)fname;
-  mfp->mf_ffname = (char_u *)FullName_save((char *)mfp->mf_fname, false);
+  mfp->mf_fname = fname;
+  mfp->mf_ffname = (char_u *)FullName_save(mfp->mf_fname, false);
 }
 
 /// Make name of memfile's swapfile a full path.
@@ -762,7 +762,7 @@ void mf_fullname(memfile_T *mfp)
 {
   if (mfp != NULL && mfp->mf_fname != NULL && mfp->mf_ffname != NULL) {
     xfree(mfp->mf_fname);
-    mfp->mf_fname = mfp->mf_ffname;
+    mfp->mf_fname = (char *)mfp->mf_ffname;
     mfp->mf_ffname = NULL;
   }
 }
@@ -789,7 +789,7 @@ static bool mf_do_open(memfile_T *mfp, char *fname, int flags)
   /// exist yet. If there is a symbolic link, this is most likely an attack.
   FileInfo file_info;
   if ((flags & O_CREAT)
-      && os_fileinfo_link((char *)mfp->mf_fname, &file_info)) {
+      && os_fileinfo_link(mfp->mf_fname, &file_info)) {
     mfp->mf_fd = -1;
     emsg(_("E300: Swap file already exists (symlink attack?)"));
   } else {
diff --git a/src/nvim/memfile_defs.h b/src/nvim/memfile_defs.h
index 537d3e5f65..d1e8fd0fb4 100644
--- a/src/nvim/memfile_defs.h
+++ b/src/nvim/memfile_defs.h
@@ -88,7 +88,7 @@ typedef struct mf_blocknr_trans_item {
 
 /// A memory file.
 typedef struct memfile {
-  char_u *mf_fname;                  /// name of the file
+  char *mf_fname;                    /// name of the file
   char_u *mf_ffname;                 /// idem, full path
   int mf_fd;                         /// file descriptor
   bhdr_T *mf_free_first;             /// first block header in free list
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index c5e8e3da07..e6cb1b79fc 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -369,7 +369,7 @@ void ml_setname(buf_T *buf)
     if (*dirp == NUL) {             // tried all directories, fail
       break;
     }
-    fname = (char_u *)findswapname(buf, &dirp, (char *)mfp->mf_fname, &found_existing_dir);
+    fname = (char_u *)findswapname(buf, &dirp, mfp->mf_fname, &found_existing_dir);
     // alloc's fname
     if (dirp == NULL) {             // out of memory
       break;
@@ -391,7 +391,7 @@ void ml_setname(buf_T *buf)
     }
 
     // try to rename the swap file
-    if (vim_rename(mfp->mf_fname, fname) == 0) {
+    if (vim_rename((char_u *)mfp->mf_fname, fname) == 0) {
       success = true;
       mf_free_fnames(mfp);
       mf_set_fnames(mfp, (char *)fname);
@@ -402,7 +402,7 @@ void ml_setname(buf_T *buf)
   }
 
   if (mfp->mf_fd == -1) {           // need to (re)open the swap file
-    mfp->mf_fd = os_open((char *)mfp->mf_fname, O_RDWR, 0);
+    mfp->mf_fd = os_open(mfp->mf_fname, O_RDWR, 0);
     if (mfp->mf_fd < 0) {
       // could not (re)open the swap file, what can we do????
       emsg(_("E301: Oops, lost the swap file!!!"));
@@ -445,7 +445,7 @@ void ml_open_file(buf_T *buf)
 
   // For a spell buffer use a temp file name.
   if (buf->b_spell) {
-    fname = vim_tempname();
+    fname = (char_u *)vim_tempname();
     if (fname != NULL) {
       (void)mf_open_file(mfp, (char *)fname);           // consumes fname!
     }
@@ -665,7 +665,7 @@ static void set_b0_fname(ZERO_BL *b0p, buf_T *buf)
 /// not set.
 static void set_b0_dir_flag(ZERO_BL *b0p, buf_T *buf)
 {
-  if (same_directory(buf->b_ml.ml_mfp->mf_fname, (char_u *)buf->b_ffname)) {
+  if (same_directory((char_u *)buf->b_ml.ml_mfp->mf_fname, (char_u *)buf->b_ffname)) {
     b0p->b0_flags |= B0_SAME_DIR;
   } else {
     b0p->b0_flags &= (uint8_t) ~B0_SAME_DIR;
@@ -765,7 +765,7 @@ void ml_recover(bool checkext)
       }
     }
     // get the swap file name that will be used
-    (void)recover_names((char_u *)fname, false, i, (char_u **)&fname_used);
+    (void)recover_names((char_u *)fname, false, i, &fname_used);
   }
   if (fname_used == NULL) {
     goto theend;  // user chose invalid number.
@@ -809,7 +809,7 @@ void ml_recover(bool checkext)
   if ((hp = mf_get(mfp, 0, 1)) == NULL) {
     msg_start();
     msg_puts_attr(_("Unable to read block 0 from "), attr | MSG_HIST);
-    msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
+    msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
     msg_puts_attr(_("\nMaybe no changes were made or Vim did not update the swap file."),
                   attr | MSG_HIST);
     msg_end();
@@ -818,7 +818,7 @@ void ml_recover(bool checkext)
   b0p = hp->bh_data;
   if (STRNCMP(b0p->b0_version, "VIM 3.0", 7) == 0) {
     msg_start();
-    msg_outtrans_attr((char *)mfp->mf_fname, MSG_HIST);
+    msg_outtrans_attr(mfp->mf_fname, MSG_HIST);
     msg_puts_attr(_(" cannot be used with this version of Vim.\n"),
                   MSG_HIST);
     msg_puts_attr(_("Use Vim version 3.0.\n"), MSG_HIST);
@@ -831,7 +831,7 @@ void ml_recover(bool checkext)
   }
   if (b0_magic_wrong(b0p)) {
     msg_start();
-    msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
+    msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
     msg_puts_attr(_(" cannot be used on this computer.\n"),
                   attr | MSG_HIST);
     msg_puts_attr(_("The file was created on "), attr | MSG_HIST);
@@ -851,7 +851,7 @@ void ml_recover(bool checkext)
     mf_new_page_size(mfp, (unsigned)char_to_long(b0p->b0_page_size));
     if (mfp->mf_page_size < previous_page_size) {
       msg_start();
-      msg_outtrans_attr((char *)mfp->mf_fname, attr | MSG_HIST);
+      msg_outtrans_attr(mfp->mf_fname, attr | MSG_HIST);
       msg_puts_attr(_(" has been damaged (page size is smaller than minimum value).\n"),
                     attr | MSG_HIST);
       msg_end();
@@ -880,7 +880,7 @@ void ml_recover(bool checkext)
     }
   }
 
-  home_replace(NULL, (char *)mfp->mf_fname, (char *)NameBuff, MAXPATHL, true);
+  home_replace(NULL, mfp->mf_fname, (char *)NameBuff, MAXPATHL, true);
   smsg(_("Using swap file \"%s\""), NameBuff);
 
   if (buf_spname(curbuf) != NULL) {
@@ -897,7 +897,7 @@ void ml_recover(bool checkext)
   mtime = char_to_long(b0p->b0_mtime);
   if (curbuf->b_ffname != NULL
       && os_fileinfo(curbuf->b_ffname, &org_file_info)
-      && ((os_fileinfo((char *)mfp->mf_fname, &swp_file_info)
+      && ((os_fileinfo(mfp->mf_fname, &swp_file_info)
            && org_file_info.stat.st_mtim.tv_sec
            > swp_file_info.stat.st_mtim.tv_sec)
           || org_file_info.stat.st_mtim.tv_sec != mtime)) {
@@ -1186,7 +1186,7 @@ theend:
 /// @param list  when true, list the swap file names
 /// @param nr  when non-zero, return nr'th swap file name
 /// @param fname_out  result when "nr" > 0
-int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
+int recover_names(char_u *fname, int list, int nr, char **fname_out)
 {
   int num_names;
   char *(names[6]);
@@ -1291,7 +1291,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
 
     // remove swapfile name of the current buffer, it must be ignored
     if (curbuf->b_ml.ml_mfp != NULL
-        && (p = curbuf->b_ml.ml_mfp->mf_fname) != NULL) {
+        && (p = (char_u *)curbuf->b_ml.ml_mfp->mf_fname) != NULL) {
       for (int i = 0; i < num_files; i++) {
         // Do not expand wildcards, on Windows would try to expand
         // "%tmp%" in "%tmp%file"
@@ -1313,7 +1313,7 @@ int recover_names(char_u *fname, int list, int nr, char_u **fname_out)
     if (nr > 0) {
       file_count += num_files;
       if (nr <= file_count) {
-        *fname_out = vim_strsave((char_u *)files[nr - 1 + num_files - file_count]);
+        *fname_out = xstrdup(files[nr - 1 + num_files - file_count]);
         dirp = "";                        // stop searching
       }
     } else if (list) {
@@ -1713,14 +1713,14 @@ theend:
 /// having to check for error everywhere).
 char *ml_get(linenr_T lnum)
 {
-  return (char *)ml_get_buf(curbuf, lnum, false);
+  return ml_get_buf(curbuf, lnum, false);
 }
 
 /// @return  pointer to position "pos".
 char_u *ml_get_pos(const pos_T *pos)
   FUNC_ATTR_NONNULL_ALL
 {
-  return ml_get_buf(curbuf, pos->lnum, false) + pos->col;
+  return (char_u *)ml_get_buf(curbuf, pos->lnum, false) + pos->col;
 }
 
 /// @return  codepoint at pos. pos must be either valid or have col set to MAXCOL!
@@ -1737,14 +1737,14 @@ int gchar_pos(pos_T *pos)
 /// @param will_change  true mark the buffer dirty (chars in the line will be changed)
 ///
 /// @return  a pointer to a line in a specific buffer
-char_u *ml_get_buf(buf_T *buf, linenr_T lnum, bool will_change)
+char *ml_get_buf(buf_T *buf, linenr_T lnum, bool will_change)
   FUNC_ATTR_NONNULL_ALL
 {
   bhdr_T *hp;
   DATA_BL *dp;
-  char_u *ptr;
+  char *ptr;
   static int recursive = 0;
-  static char_u questions[4];
+  static char questions[4];
 
   if (lnum > buf->b_ml.ml_line_count) {  // invalid line number
     if (recursive == 0) {
@@ -1766,7 +1766,7 @@ errorret:
   }
 
   if (buf->b_ml.ml_mfp == NULL) {       // there are no lines
-    return (char_u *)"";
+    return "";
   }
 
   // See if it is the same line as requested last time.
@@ -1795,9 +1795,9 @@ errorret:
 
     dp = hp->bh_data;
 
-    ptr = (char_u *)dp +
+    ptr = (char *)dp +
           ((dp->db_index[lnum - buf->b_ml.ml_locked_low]) & DB_INDEX_MASK);
-    buf->b_ml.ml_line_ptr = ptr;
+    buf->b_ml.ml_line_ptr = (char_u *)ptr;
     buf->b_ml.ml_line_lnum = lnum;
     buf->b_ml.ml_flags &= ~ML_LINE_DIRTY;
   }
@@ -1806,7 +1806,7 @@ errorret:
     ml_add_deleted_len_buf(buf, buf->b_ml.ml_line_ptr, -1);
   }
 
-  return buf->b_ml.ml_line_ptr;
+  return (char *)buf->b_ml.ml_line_ptr;
 }
 
 /// Check if a line that was just obtained by a call to ml_get
@@ -2352,7 +2352,7 @@ int ml_replace_buf(buf_T *buf, linenr_T lnum, char *line, bool copy)
   }
 
   if (readlen && kv_size(buf->update_callbacks)) {
-    ml_add_deleted_len_buf(buf, ml_get_buf(buf, lnum, false), -1);
+    ml_add_deleted_len_buf(buf, (char_u *)ml_get_buf(buf, lnum, false), -1);
   }
 
   buf->b_ml.ml_line_ptr = (char_u *)line;
@@ -3081,7 +3081,7 @@ char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name
     return NULL;
   }
 
-  s = get_file_in_dir(r, dir_name);
+  s = (char_u *)get_file_in_dir((char *)r, (char *)dir_name);
   xfree(r);
   return s;
 }
@@ -3098,30 +3098,30 @@ char_u *makeswapname(char_u *fname, char_u *ffname, buf_T *buf, char_u *dir_name
 /// The return value is an allocated string and can be NULL.
 ///
 /// @param dname  don't use "dirname", it is a global for Alpha
-char_u *get_file_in_dir(char_u *fname, char_u *dname)
+char *get_file_in_dir(char *fname, char *dname)
 {
-  char_u *t;
-  char_u *tail;
-  char_u *retval;
+  char *t;
+  char *tail;
+  char *retval;
   int save_char;
 
-  tail = (char_u *)path_tail((char *)fname);
+  tail = path_tail(fname);
 
   if (dname[0] == '.' && dname[1] == NUL) {
-    retval = vim_strsave(fname);
+    retval = xstrdup(fname);
   } else if (dname[0] == '.' && vim_ispathsep(dname[1])) {
     if (tail == fname) {            // no path before file name
-      retval = (char_u *)concat_fnames((char *)dname + 2, (char *)tail, true);
+      retval = concat_fnames(dname + 2, tail, true);
     } else {
-      save_char = *tail;
+      save_char = (uint8_t)(*tail);
       *tail = NUL;
-      t = (char_u *)concat_fnames((char *)fname, (char *)dname + 2, true);
-      *tail = (uint8_t)save_char;
-      retval = (char_u *)concat_fnames((char *)t, (char *)tail, true);
+      t = concat_fnames(fname, dname + 2, true);
+      *tail = (char)save_char;
+      retval = concat_fnames(t, tail, true);
       xfree(t);
     }
   } else {
-    retval = (char_u *)concat_fnames((char *)dname, (char *)tail, true);
+    retval = concat_fnames(dname, tail, true);
   }
 
   return retval;
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index 90084bde17..7b267d6ce4 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -631,7 +631,7 @@ colnr_T vcol2col(win_T *const wp, const linenr_T lnum, const colnr_T vcol)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
   // try to advance to the specified column
-  char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
+  char_u *line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
   chartabsize_T cts;
   init_chartabsize_arg(&cts, wp, lnum, 0, (char *)line, (char *)line);
   while (cts.cts_vcol < vcol && *cts.cts_ptr != NUL) {
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 66038d0c3c..2fe482d8aa 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -629,18 +629,18 @@ static void normal_redraw_mode_message(NormalState *s)
   // If need to redraw, and there is a "keep_msg", redraw before the
   // delay
   if (must_redraw && keep_msg != NULL && !emsg_on_display) {
-    char_u *kmsg;
+    char *kmsg;
 
-    kmsg = (char_u *)keep_msg;
+    kmsg = keep_msg;
     keep_msg = NULL;
     // Showmode() will clear keep_msg, but we want to use it anyway.
     // First update w_topline.
     setcursor();
     update_screen(0);
     // now reset it, otherwise it's put in the history again
-    keep_msg = (char *)kmsg;
+    keep_msg = kmsg;
 
-    kmsg = vim_strsave((char_u *)keep_msg);
+    kmsg = xstrdup(keep_msg);
     msg_attr((const char *)kmsg, keep_msg_attr);
     xfree(kmsg);
   }
@@ -2180,7 +2180,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, long count, bool fixindent)
           find_start_of_word(&VIsual);
           if (*p_sel == 'e' && *get_cursor_pos_ptr() != NUL) {
             curwin->w_cursor.col +=
-              utfc_ptr2len((char *)get_cursor_pos_ptr());
+              utfc_ptr2len(get_cursor_pos_ptr());
           }
           find_end_of_word(&curwin->w_cursor);
         }
@@ -2416,7 +2416,7 @@ size_t find_ident_at_pos(win_T *wp, linenr_T lnum, colnr_T startcol, char **text
 
   // if i == 0: try to find an identifier
   // if i == 1: try to find any non-white text
-  char_u *ptr = ml_get_buf(wp->w_buffer, lnum, false);
+  char_u *ptr = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
   for (i = (find_type & FIND_IDENT) ? 0 : 1; i < 2; i++) {
     // 1. skip to start of identifier/text
     col = startcol;
@@ -2675,9 +2675,9 @@ void clear_showcmd(void)
 
       if (cursor_bot) {
         s = ml_get_pos(&VIsual);
-        e = get_cursor_pos_ptr();
+        e = (char_u *)get_cursor_pos_ptr();
       } else {
-        s = get_cursor_pos_ptr();
+        s = (char_u *)get_cursor_pos_ptr();
         e = ml_get_pos(&VIsual);
       }
       while ((*p_sel != 'e') ? s <= e : s < e) {
@@ -3361,7 +3361,7 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
       virtcol -= vim_strsize((char *)get_showbreak_value(curwin));
     }
 
-    int c = utf_ptr2char((char *)get_cursor_pos_ptr());
+    int c = utf_ptr2char(get_cursor_pos_ptr());
     if (dir == FORWARD && virtcol < curwin->w_curswant
         && (curwin->w_curswant <= (colnr_T)width1)
         && !vim_isprintc(c) && c > 255) {
@@ -4451,7 +4451,7 @@ bool get_visual_text(cmdarg_T *cap, char **pp, size_t *lenp)
 static void nv_tagpop(cmdarg_T *cap)
 {
   if (!checkclearopq(cap->oap)) {
-    do_tag((char_u *)"", DT_POP, (int)cap->count1, false, true);
+    do_tag("", DT_POP, (int)cap->count1, false, true);
   }
 }
 
@@ -4600,7 +4600,7 @@ static void nv_right(cmdarg_T *cap)
       if (virtual_active()) {
         oneright();
       } else {
-        curwin->w_cursor.col += utfc_ptr2len((char *)get_cursor_pos_ptr());
+        curwin->w_cursor.col += utfc_ptr2len(get_cursor_pos_ptr());
       }
     }
   }
@@ -4648,7 +4648,7 @@ static void nv_left(cmdarg_T *cap)
         // Don't adjust op_end now, otherwise it won't work.
         if ((cap->oap->op_type == OP_DELETE || cap->oap->op_type == OP_CHANGE)
             && !LINEEMPTY(curwin->w_cursor.lnum)) {
-          char_u *cp = get_cursor_pos_ptr();
+          char_u *cp = (char_u *)get_cursor_pos_ptr();
 
           if (*cp != NUL) {
             curwin->w_cursor.col += utfc_ptr2len((char *)cp);
@@ -5360,7 +5360,7 @@ static void nv_replace(cmdarg_T *cap)
   }
 
   // Abort if not enough characters to replace.
-  ptr = get_cursor_pos_ptr();
+  ptr = (char_u *)get_cursor_pos_ptr();
   if (STRLEN(ptr) < (unsigned)cap->count1
       || (mb_charlen(ptr) < cap->count1)) {
     clearopbeep(cap->oap);
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 5d505f41a2..10e957287e 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -722,26 +722,26 @@ int get_expr_register(void)
   if (*new_line == NUL) {  // use previous line
     xfree(new_line);
   } else {
-    set_expr_line(new_line);
+    set_expr_line((char *)new_line);
   }
   return '=';
 }
 
 /// Set the expression for the '=' register.
 /// Argument must be an allocated string.
-void set_expr_line(char_u *new_line)
+void set_expr_line(char *new_line)
 {
   xfree(expr_line);
-  expr_line = new_line;
+  expr_line = (char_u *)new_line;
 }
 
 /// Get the result of the '=' register expression.
 ///
 /// @return  a pointer to allocated memory, or NULL for failure.
-char_u *get_expr_line(void)
+char *get_expr_line(void)
 {
-  char_u *expr_copy;
-  char_u *rv;
+  char *expr_copy;
+  char *rv;
   static int nested = 0;
 
   if (expr_line == NULL) {
@@ -750,7 +750,7 @@ char_u *get_expr_line(void)
 
   // Make a copy of the expression, because evaluating it may cause it to be
   // changed.
-  expr_copy = vim_strsave(expr_line);
+  expr_copy = xstrdup((char *)expr_line);
 
   // When we are invoked recursively limit the evaluation to 10 levels.
   // Then return the string as-is.
@@ -759,19 +759,19 @@ char_u *get_expr_line(void)
   }
 
   nested++;
-  rv = (char_u *)eval_to_string((char *)expr_copy, NULL, true);
+  rv = eval_to_string(expr_copy, NULL, true);
   nested--;
   xfree(expr_copy);
   return rv;
 }
 
 /// Get the '=' register expression itself, without evaluating it.
-char_u *get_expr_line_src(void)
+char *get_expr_line_src(void)
 {
   if (expr_line == NULL) {
     return NULL;
   }
-  return vim_strsave(expr_line);
+  return xstrdup((char *)expr_line);
 }
 
 /// @return  whether `regname` is a valid name of a yank register.
@@ -1070,11 +1070,11 @@ static char_u *execreg_line_continuation(char **lines, size_t *idx)
     }
   }
   ga_append(&ga, NUL);
-  char_u *str = vim_strsave(ga.ga_data);
+  char *str = xstrdup(ga.ga_data);
   ga_clear(&ga);
 
   *idx = i;
-  return str;
+  return (char_u *)str;
 }
 
 /// Execute a yank register: copy it into the stuff buffer
@@ -1130,7 +1130,7 @@ int do_execreg(int regname, int colon, int addcr, int silent)
     }
     xfree(p);
   } else if (regname == '=') {
-    p = get_expr_line();
+    p = (char_u *)get_expr_line();
     if (p == NULL) {
       return FAIL;
     }
@@ -1338,7 +1338,7 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
     return true;
 
   case '=':                     // result of expression
-    *argp = (char *)get_expr_line();
+    *argp = get_expr_line();
     *allocated = true;
     return true;
 
@@ -1392,7 +1392,7 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
       return false;
     }
 
-    *argp = (char *)ml_get_buf(curwin->w_buffer, curwin->w_cursor.lnum, false);
+    *argp = ml_get_buf(curwin->w_buffer, curwin->w_cursor.lnum, false);
     return true;
 
   case '_':                     // black hole: always empty
@@ -1801,7 +1801,7 @@ static void mb_adjust_opend(oparg_T *oap)
 static inline void pbyte(pos_T lp, int c)
 {
   assert(c <= UCHAR_MAX);
-  *(ml_get_buf(curbuf, lp.lnum, true) + lp.col) = (char_u)c;
+  *(ml_get_buf(curbuf, lp.lnum, true) + lp.col) = (char)c;
   if (!curbuf_splice_pending) {
     extmark_splice_cols(curbuf, (int)lp.lnum - 1, lp.col, 1, 1, kExtmarkUndo);
   }
@@ -1978,7 +1978,7 @@ static int op_replace(oparg_T *oap, int c)
       n = gchar_cursor();
       if (n != NUL) {
         int new_byte_len = utf_char2len(c);
-        int old_byte_len = utfc_ptr2len((char *)get_cursor_pos_ptr());
+        int old_byte_len = utfc_ptr2len(get_cursor_pos_ptr());
 
         if (new_byte_len > 1 || old_byte_len > 1) {
           // This is slow, but it handles replacing a single-byte
@@ -2199,7 +2199,7 @@ bool swapchar(int op_type, pos_T *pos)
 
       curwin->w_cursor = *pos;
       // don't use del_char(), it also removes composing chars
-      del_bytes(utf_ptr2len((char *)get_cursor_pos_ptr()), false, false);
+      del_bytes(utf_ptr2len(get_cursor_pos_ptr()), false, false);
       ins_char(nc);
       curwin->w_cursor = sp;
     } else {
@@ -2995,7 +2995,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
         // STRLEN(ml_get(curwin->w_cursor.lnum)). With 'virtualedit' and the
         // cursor past the end of the line, curwin->w_cursor.coladd is
         // incremented instead of curwin->w_cursor.col.
-        char_u *cursor_pos = get_cursor_pos_ptr();
+        char_u *cursor_pos = (char_u *)get_cursor_pos_ptr();
         bool one_past_line = (*cursor_pos == NUL);
         bool eol = false;
         if (!one_past_line) {
@@ -3101,7 +3101,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       if (u_save_cursor() == FAIL) {
         goto end;
       }
-      char *p = (char *)get_cursor_pos_ptr();
+      char *p = get_cursor_pos_ptr();
       if (dir == FORWARD && *p != NUL) {
         MB_PTR_ADV(p);
       }
@@ -3210,7 +3210,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       }
 
       // move to start of next multi-byte character
-      curwin->w_cursor.col += utfc_ptr2len((char *)get_cursor_pos_ptr());
+      curwin->w_cursor.col += utfc_ptr2len(get_cursor_pos_ptr());
       col++;
     } else {
       getvcol(curwin, &curwin->w_cursor, &col, NULL, &endcol2);
@@ -3393,7 +3393,7 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       // if type is kMTCharWise, FORWARD is the same as BACKWARD on the next
       // char
       if (dir == FORWARD && gchar_cursor() != NUL) {
-        int bytelen = utfc_ptr2len((char *)get_cursor_pos_ptr());
+        int bytelen = utfc_ptr2len(get_cursor_pos_ptr());
 
         // put it on the next of the multi-byte character.
         col += bytelen;
@@ -4853,13 +4853,13 @@ void format_reg_type(MotionType reg_type, colnr_T reg_width, char *buf, size_t b
 /// Otherwise just return `s`.
 ///
 /// @return  a void * for use in get_reg_contents().
-static void *get_reg_wrap_one_line(char_u *s, int flags)
+static void *get_reg_wrap_one_line(char *s, int flags)
 {
   if (!(flags & kGRegList)) {
     return s;
   }
   list_T *const list = tv_list_alloc(1);
-  tv_list_append_allocated_string(list, (char *)s);
+  tv_list_append_allocated_string(list, s);
   return list;
 }
 
@@ -4901,9 +4901,9 @@ void *get_reg_contents(int regname, int flags)
       return NULL;
     }
     if (allocated) {
-      return get_reg_wrap_one_line((char_u *)retval, flags);
+      return get_reg_wrap_one_line(retval, flags);
     }
-    return get_reg_wrap_one_line(vim_strsave((char_u *)retval), flags);
+    return get_reg_wrap_one_line(xstrdup(retval), flags);
   }
 
   yankreg_T *reg = get_yank_register(regname, YREG_PASTE);
@@ -5574,7 +5574,7 @@ static Callback opfunc_cb;
 /// @return  OK or FAIL
 int set_operatorfunc_option(void)
 {
-  return option_set_callback_func((char_u *)p_opfunc, &opfunc_cb);
+  return option_set_callback_func(p_opfunc, &opfunc_cb);
 }
 
 #if defined(EXITFREE)
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 12c2888f5c..e54e6080f0 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -420,7 +420,7 @@ void set_init_1(bool clean_arg)
     // use utf-8 as 'default' if locale encoding can't be detected.
     p = (char_u *)xmemdupz(S_LEN("utf-8"));
   }
-  fenc_default = p;
+  fenc_default = (char *)p;
 
 #ifdef HAVE_WORKING_LIBINTL
   // GNU gettext 0.10.37 supports this feature: set the codeset used for
@@ -1129,9 +1129,9 @@ int do_set(char *arg, int opt_flags)
                                     opt_flags);
           } else if (opt_idx >= 0) {  // String.
             char_u *save_arg = NULL;
-            char_u *s = NULL;
+            char *s = NULL;
             char_u *oldval = NULL;         // previous value if *varp
-            char_u *newval;
+            char *newval;
             char_u *origval = NULL;
             char_u *origval_l = NULL;
             char_u *origval_g = NULL;
@@ -1175,24 +1175,24 @@ int do_set(char *arg, int opt_flags)
             }
 
             if (nextchar == '&') {  // set to default val
-              newval = options[opt_idx].def_val;
+              newval = (char *)options[opt_idx].def_val;
               // expand environment variables and ~ since the
               // default value was already expanded, only
               // required when an environment variable was set
               // later
               if (newval == NULL) {
-                newval = (char_u *)empty_option;
+                newval = empty_option;
               } else if (!(options[opt_idx].flags & P_NO_DEF_EXP)) {
-                s = option_expand(opt_idx, newval);
+                s = (char *)option_expand(opt_idx, (char_u *)newval);
                 if (s == NULL) {
                   s = newval;
                 }
-                newval = vim_strsave(s);
+                newval = xstrdup(s);
               } else {
-                newval = (char_u *)xstrdup((char *)newval);
+                newval = xstrdup(newval);
               }
             } else if (nextchar == '<') {  // set to global val
-              newval = vim_strsave(*(char_u **)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL));
+              newval = xstrdup(*(char **)get_varp_scope(&(options[opt_idx]), OPT_GLOBAL));
             } else {
               arg++;                    // jump to after the '=' or ':'
 
@@ -1212,13 +1212,13 @@ int do_set(char *arg, int opt_flags)
                   *(char **)varp = empty_option;
                   break;
                 case 1:
-                  *(char_u **)varp = vim_strsave((char_u *)"indent,eol");
+                  *(char_u **)varp = (char_u *)xstrdup("indent,eol");
                   break;
                 case 2:
-                  *(char_u **)varp = vim_strsave((char_u *)"indent,eol,start");
+                  *(char_u **)varp = (char_u *)xstrdup("indent,eol,start");
                   break;
                 case 3:
-                  *(char_u **)varp = vim_strsave((char_u *)"indent,eol,nostop");
+                  *(char_u **)varp = (char_u *)xstrdup("indent,eol,nostop");
                   break;
                 }
                 xfree(oldval);
@@ -1301,7 +1301,7 @@ int do_set(char *arg, int opt_flags)
                   arg += i;
                   s += i;
                 } else {
-                  *s++ = (uint8_t)(*arg++);
+                  *s++ = *arg++;
                 }
               }
               *s = NUL;
@@ -1311,7 +1311,7 @@ int do_set(char *arg, int opt_flags)
               // comma.
               if (!(adding || prepending || removing)
                   || (flags & P_COMMA)) {
-                s = option_expand(opt_idx, newval);
+                s = (char *)option_expand(opt_idx, (char_u *)newval);
                 if (s != NULL) {
                   xfree(newval);
                   newlen = (unsigned)STRLEN(s) + 1;
@@ -1328,7 +1328,7 @@ int do_set(char *arg, int opt_flags)
               i = 0;                    // init for GCC
               if (removing || (flags & P_NODUP)) {
                 i = (int)STRLEN(newval);
-                s = find_dup_item(origval, newval, flags);
+                s = (char *)find_dup_item(origval, (char_u *)newval, flags);
 
                 // do not add if already there
                 if ((adding || prepending) && s != NULL) {
@@ -1340,7 +1340,7 @@ int do_set(char *arg, int opt_flags)
                 // if no duplicate, move pointer to end of
                 // original value
                 if (s == NULL) {
-                  s = origval + (int)STRLEN(origval);
+                  s = (char *)origval + (int)STRLEN(origval);
                 }
               }
 
@@ -1377,7 +1377,7 @@ int do_set(char *arg, int opt_flags)
                 if (*s) {
                   // may need to remove a comma
                   if (flags & P_COMMA) {
-                    if (s == origval) {
+                    if (s == (char *)origval) {
                       // include comma after string
                       if (s[i] == ',') {
                         i++;
@@ -1388,7 +1388,7 @@ int do_set(char *arg, int opt_flags)
                       i++;
                     }
                   }
-                  STRMOVE(newval + (s - origval), s + i);
+                  STRMOVE(newval + (s - (char *)origval), s + i);
                 }
               }
 
@@ -1399,14 +1399,14 @@ int do_set(char *arg, int opt_flags)
                   // 'whichwrap'
                   if (flags & P_ONECOMMA) {
                     if (*s != ',' && *(s + 1) == ','
-                        && vim_strchr((char *)s + 2, *s) != NULL) {
+                        && vim_strchr(s + 2, *s) != NULL) {
                       // Remove the duplicated value and the next comma.
                       STRMOVE(s, s + 2);
                       continue;
                     }
                   } else {
                     if ((!(flags & P_COMMA) || *s != ',')
-                        && vim_strchr((char *)s + 1, *s) != NULL) {
+                        && vim_strchr(s + 1, *s) != NULL) {
                       STRMOVE(s, s + 1);
                       continue;
                     }
@@ -1421,7 +1421,7 @@ int do_set(char *arg, int opt_flags)
             }
 
             // Set the new value.
-            *(char_u **)(varp) = newval;
+            *(char_u **)(varp) = (char_u *)newval;
 
             // origval may be freed by
             // did_set_string_option(), make a copy.
@@ -1431,7 +1431,7 @@ int do_set(char *arg, int opt_flags)
 
             // newval (and varp) may become invalid if the
             // buffer is closed by autocommands.
-            saved_newval = (newval != NULL) ? xstrdup((char *)newval) : 0;
+            saved_newval = (newval != NULL) ? xstrdup(newval) : 0;
 
             {
               uint32_t *p = insecure_flag(curwin, opt_idx, opt_flags);
@@ -4451,7 +4451,7 @@ void buf_copy_options(buf_T *buf, int flags)
       buf->b_p_cpt = xstrdup(p_cpt);
       COPY_OPT_SCTX(buf, BV_CPT);
 #ifdef BACKSLASH_IN_FILENAME
-      buf->b_p_csl = vim_strsave(p_csl);
+      buf->b_p_csl = xstrdup(p_csl);
       COPY_OPT_SCTX(buf, BV_CSL);
 #endif
       buf->b_p_cfu = xstrdup(p_cfu);
@@ -4826,7 +4826,7 @@ int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***fi
   int num_normal = 0;  // Nr of matching non-term-code settings
   int match;
   int count = 0;
-  char_u *str;
+  char *str;
   int loop;
   static char *(names[]) = { "all" };
   int ic = regmatch->rm_ic;  // remember the ignore-case flag
@@ -4848,7 +4848,7 @@ int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***fi
         }
       }
     }
-    for (size_t opt_idx = 0; (str = (char_u *)options[opt_idx].fullname) != NULL;
+    for (size_t opt_idx = 0; (str = options[opt_idx].fullname) != NULL;
          opt_idx++) {
       if (options[opt_idx].var == NULL) {
         continue;
@@ -4858,7 +4858,7 @@ int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***fi
         continue;
       }
       match = false;
-      if (vim_regexec(regmatch, (char *)str, (colnr_T)0)
+      if (vim_regexec(regmatch, str, (colnr_T)0)
           || (options[opt_idx].shortname != NULL
               && vim_regexec(regmatch,
                              options[opt_idx].shortname,
@@ -4870,7 +4870,7 @@ int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***fi
         if (loop == 0) {
           num_normal++;
         } else {
-          (*file)[count++] = (char *)vim_strsave(str);
+          (*file)[count++] = xstrdup(str);
         }
       }
     }
@@ -4881,7 +4881,7 @@ int ExpandSettings(expand_T *xp, regmatch_T *regmatch, int *num_file, char ***fi
       } else {
         return OK;
       }
-      *file = xmalloc((size_t)(*num_file) * sizeof(char_u *));
+      *file = xmalloc((size_t)(*num_file) * sizeof(char *));
     }
   }
   return OK;
@@ -5230,7 +5230,7 @@ int fill_culopt_flags(char *val, win_T *wp)
 /// Set the callback function value for an option that accepts a function name,
 /// lambda, et al. (e.g. 'operatorfunc', 'tagfunc', etc.)
 /// @return  OK if the option is successfully set to a function, otherwise FAIL
-int option_set_callback_func(char_u *optval, Callback *optcb)
+int option_set_callback_func(char *optval, Callback *optcb)
 {
   if (optval == NULL || *optval == NUL) {
     callback_free(optcb);
@@ -5242,7 +5242,7 @@ int option_set_callback_func(char_u *optval, Callback *optcb)
       || (STRNCMP(optval, "function(", 9) == 0)
       || (STRNCMP(optval, "funcref(", 8) == 0)) {
     // Lambda expression or a funcref
-    tv = eval_expr((char *)optval);
+    tv = eval_expr(optval);
     if (tv == NULL) {
       return FAIL;
     }
@@ -5250,7 +5250,7 @@ int option_set_callback_func(char_u *optval, Callback *optcb)
     // treat everything else as a function name string
     tv = xcalloc(1, sizeof(*tv));
     tv->v_type = VAR_STRING;
-    tv->vval.v_string = (char *)vim_strsave(optval);
+    tv->vval.v_string = xstrdup(optval);
   }
 
   Callback cb;
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index c226966ef6..8581dae7a3 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -253,7 +253,7 @@ void check_buf_options(buf_T *buf)
 
 /// Free the string allocated for an option.
 /// Checks for the string being empty_option. This may happen if we're out of
-/// memory, vim_strsave() returned NULL, which was replaced by empty_option by
+/// memory, xstrdup() returned NULL, which was replaced by empty_option by
 /// check_options().
 /// Does NOT check for P_ALLOCED flag!
 void free_string_option(char *p)
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index c940c86675..2f2a8c7fdc 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -669,8 +669,8 @@ void expand_env_esc(char_u *restrict srcp, char_u *restrict dst, int dstlen, boo
 
           ExpandInit(&xpc);
           xpc.xp_context = EXPAND_FILES;
-          var = ExpandOne(&xpc, dst, NULL,
-                          WILD_ADD_SLASH|WILD_SILENT, WILD_EXPAND_FREE);
+          var = (char_u *)ExpandOne(&xpc, (char *)dst, NULL,
+                                    WILD_ADD_SLASH|WILD_SILENT, WILD_EXPAND_FREE);
           mustfree = true;
         }
 #else
@@ -684,7 +684,7 @@ void expand_env_esc(char_u *restrict srcp, char_u *restrict dst, int dstlen, boo
       // If 'shellslash' is set change backslashes to forward slashes.
       // Can't use slash_adjust(), p_ssl may be set temporarily.
       if (p_ssl && var != NULL && vim_strchr(var, '\\') != NULL) {
-        char_u *p = vim_strsave(var);
+        char_u *p = xstrdup(var);
 
         if (mustfree) {
           xfree(var);
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index f3b3c1dfbf..25f51f89a9 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -52,11 +52,11 @@ static void save_patterns(int num_pat, char **pat, int *num_file, char ***file)
 {
   *file = xmalloc((size_t)num_pat * sizeof(char_u *));
   for (int i = 0; i < num_pat; i++) {
-    char_u *s = vim_strsave((char_u *)pat[i]);
+    char *s = xstrdup(pat[i]);
     // Be compatible with expand_filename(): halve the number of
     // backslashes.
-    backslash_halve((char *)s);
-    (*file)[i] = (char *)s;
+    backslash_halve(s);
+    (*file)[i] = s;
   }
   *num_file = num_pat;
 }
@@ -160,7 +160,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
   }
 
   // get a name for the temp file
-  if ((tempname = vim_tempname()) == NULL) {
+  if ((tempname = (char_u *)vim_tempname()) == NULL) {
     emsg(_(e_notmp));
     return FAIL;
   }
@@ -746,7 +746,7 @@ char_u *get_cmd_output(char_u *cmd, char_u *infile, ShellOpts flags, size_t *ret
   }
 
   // get a name for the temp file
-  char_u *tempname = vim_tempname();
+  char_u *tempname = (char_u *)vim_tempname();
   if (tempname == NULL) {
     emsg(_(e_notmp));
     return NULL;
diff --git a/src/nvim/path.c b/src/nvim/path.c
index 2646b9e75e..accd7badbb 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -829,10 +829,10 @@ static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
 static void expand_path_option(char_u *curdir, garray_T *gap)
 {
   char_u *path_option = *curbuf->b_p_path == NUL ? p_path : (char_u *)curbuf->b_p_path;
-  char_u *buf = xmalloc(MAXPATHL);
+  char *buf = xmalloc(MAXPATHL);
 
   while (*path_option != NUL) {
-    copy_option_part((char **)&path_option, (char *)buf, MAXPATHL, " ,");
+    copy_option_part((char **)&path_option, buf, MAXPATHL, " ,");
 
     if (buf[0] == '.' && (buf[1] == NUL || vim_ispathsep(buf[1]))) {
       // Relative to current buffer:
@@ -852,12 +852,12 @@ static void expand_path_option(char_u *curdir, garray_T *gap)
         STRMOVE(buf + len, buf + 2);
       }
       memmove(buf, curbuf->b_ffname, len);
-      simplify_filename(buf);
+      simplify_filename((char_u *)buf);
     } else if (buf[0] == NUL) {
       STRCPY(buf, curdir);  // relative to current directory
-    } else if (path_with_url((char *)buf)) {
+    } else if (path_with_url(buf)) {
       continue;  // URL can't be used here
-    } else if (!path_is_absolute(buf)) {
+    } else if (!path_is_absolute((char_u *)buf)) {
       // Expand relative path to their full path equivalent
       size_t len = STRLEN(curdir);
       if (len + STRLEN(buf) + 3 > MAXPATHL) {
@@ -866,10 +866,10 @@ static void expand_path_option(char_u *curdir, garray_T *gap)
       STRMOVE(buf + len + 1, buf);
       STRCPY(buf, curdir);
       buf[len] = (char_u)PATHSEP;
-      simplify_filename(buf);
+      simplify_filename((char_u *)buf);
     }
 
-    GA_APPEND(char_u *, gap, vim_strsave(buf));
+    GA_APPEND(char *, gap, xstrdup(buf));
   }
 
   xfree(buf);
@@ -919,12 +919,12 @@ static char_u *get_path_cutoff(char_u *fname, garray_T *gap)
 // that matches the pattern. Beware, this is at least O(n^2) wrt "gap->ga_len".
 static void uniquefy_paths(garray_T *gap, char_u *pattern)
 {
-  char_u **fnames = (char_u **)gap->ga_data;
+  char **fnames = gap->ga_data;
   bool sort_again = false;
   regmatch_T regmatch;
   garray_T path_ga;
-  char_u **in_curdir = NULL;
-  char_u *short_name;
+  char **in_curdir = NULL;
+  char *short_name;
 
   ga_remove_duplicate_strings(gap);
   ga_init(&path_ga, (int)sizeof(char_u *), 1);
@@ -933,11 +933,11 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
   // regex matches anywhere in the path. FIXME: is this valid for all
   // possible patterns?
   size_t len = STRLEN(pattern);
-  char_u *file_pattern = xmalloc(len + 2);
+  char *file_pattern = xmalloc(len + 2);
   file_pattern[0] = '*';
   file_pattern[1] = NUL;
   STRCAT(file_pattern, pattern);
-  char *pat = file_pat_to_reg_pat((char *)file_pattern, NULL, NULL, true);
+  char *pat = file_pat_to_reg_pat(file_pattern, NULL, NULL, true);
   xfree(file_pattern);
   if (pat == NULL) {
     return;
@@ -957,21 +957,21 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
   in_curdir = xcalloc((size_t)gap->ga_len, sizeof(char_u *));
 
   for (int i = 0; i < gap->ga_len && !got_int; i++) {
-    char_u *path = fnames[i];
+    char *path = fnames[i];
     int is_in_curdir;
-    char_u *dir_end = (char_u *)gettail_dir((const char *)path);
-    char_u *pathsep_p;
-    char_u *path_cutoff;
+    char *dir_end = (char *)gettail_dir((const char *)path);
+    char *pathsep_p;
+    char *path_cutoff;
 
     len = STRLEN(path);
     is_in_curdir = FNAMENCMP(curdir, path, dir_end - path) == 0
                    && curdir[dir_end - path] == NUL;
     if (is_in_curdir) {
-      in_curdir[i] = vim_strsave(path);
+      in_curdir[i] = xstrdup(path);
     }
 
     // Shorten the filename while maintaining its uniqueness
-    path_cutoff = get_path_cutoff(path, &path_ga);
+    path_cutoff = (char *)get_path_cutoff((char_u *)path, &path_ga);
 
     // Don't assume all files can be reached without path when search
     // pattern starts with **/, so only remove path_cutoff
@@ -979,17 +979,17 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
     if (pattern[0] == '*' && pattern[1] == '*'
         && vim_ispathsep_nocolon(pattern[2])
         && path_cutoff != NULL
-        && vim_regexec(&regmatch, (char *)path_cutoff, (colnr_T)0)
-        && is_unique(path_cutoff, gap, i)) {
+        && vim_regexec(&regmatch, path_cutoff, (colnr_T)0)
+        && is_unique((char_u *)path_cutoff, gap, i)) {
       sort_again = true;
       memmove(path, path_cutoff, STRLEN(path_cutoff) + 1);
     } else {
       // Here all files can be reached without path, so get shortest
       // unique path.  We start at the end of the path. */
       pathsep_p = path + len - 1;
-      while (find_previous_pathsep(path, &pathsep_p)) {
-        if (vim_regexec(&regmatch, (char *)pathsep_p + 1, (colnr_T)0)
-            && is_unique(pathsep_p + 1, gap, i)
+      while (find_previous_pathsep((char_u *)path, (char_u **)&pathsep_p)) {
+        if (vim_regexec(&regmatch, pathsep_p + 1, (colnr_T)0)
+            && is_unique((char_u *)pathsep_p + 1, gap, i)
             && path_cutoff != NULL && pathsep_p + 1 >= path_cutoff) {
           sort_again = true;
           memmove(path, pathsep_p + 1, STRLEN(pathsep_p));
@@ -998,7 +998,7 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
       }
     }
 
-    if (path_is_absolute(path)) {
+    if (path_is_absolute((char_u *)path)) {
       // Last resort: shorten relative to curdir if possible.
       // 'possible' means:
       // 1. It is under the current directory.
@@ -1009,10 +1009,10 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
       //     c:\foo\bar\file.txt   c:\foo\bar    .\file.txt
       //     /file.txt             /             /file.txt
       //     c:\file.txt           c:\           .\file.txt
-      short_name = path_shorten_fname(path, curdir);
+      short_name = (char *)path_shorten_fname((char_u *)path, curdir);
       if (short_name != NULL && short_name > path + 1) {
         STRCPY(path, ".");
-        add_pathsep((char *)path);
+        add_pathsep(path);
         STRMOVE(path + STRLEN(path), short_name);
       }
     }
@@ -1021,8 +1021,8 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
 
   // Shorten filenames in /in/current/directory/{filename}
   for (int i = 0; i < gap->ga_len && !got_int; i++) {
-    char_u *rel_path;
-    char_u *path = in_curdir[i];
+    char *rel_path;
+    char *path = in_curdir[i];
 
     if (path == NULL) {
       continue;
@@ -1030,18 +1030,18 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
 
     // If the {filename} is not unique, change it to ./{filename}.
     // Else reduce it to {filename}
-    short_name = path_shorten_fname(path, curdir);
+    short_name = (char *)path_shorten_fname((char_u *)path, curdir);
     if (short_name == NULL) {
       short_name = path;
     }
-    if (is_unique(short_name, gap, i)) {
+    if (is_unique((char_u *)short_name, gap, i)) {
       STRCPY(fnames[i], short_name);
       continue;
     }
 
     rel_path = xmalloc(STRLEN(short_name) + STRLEN(PATHSEPSTR) + 2);
     STRCPY(rel_path, ".");
-    add_pathsep((char *)rel_path);
+    add_pathsep(rel_path);
     STRCAT(rel_path, short_name);
 
     xfree(fnames[i]);
@@ -2099,11 +2099,11 @@ char_u *path_shorten_fname(char_u *full_path, char_u *dir_name)
 ///                        If FAIL is returned, *num_file and *file are either
 ///                        unchanged or *num_file is set to 0 and *file is set
 ///                        to NULL or points to "".
-int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
+int expand_wildcards_eval(char **pat, int *num_file, char ***file, int flags)
 {
   int ret = FAIL;
-  char_u *eval_pat = NULL;
-  char *exp_pat = (char *)(*pat);
+  char *eval_pat = NULL;
+  char *exp_pat = *pat;
   char *ignored_msg;
   size_t usedlen;
   const bool is_cur_alt_file = *exp_pat == '%' || *exp_pat == '#';
@@ -2111,12 +2111,13 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
 
   if (is_cur_alt_file || *exp_pat == '<') {
     emsg_off++;
-    eval_pat = eval_vars((char_u *)exp_pat, (char_u *)exp_pat, &usedlen, NULL, &ignored_msg, NULL,
-                         true);
+    eval_pat = (char *)eval_vars((char_u *)exp_pat, (char_u *)exp_pat, &usedlen, NULL, &ignored_msg,
+                                 NULL,
+                                 true);
     emsg_off--;
     if (eval_pat != NULL) {
       star_follows = strcmp(exp_pat + usedlen, "*") == 0;
-      exp_pat = concat_str((char *)eval_pat, exp_pat + usedlen);
+      exp_pat = concat_str(eval_pat, exp_pat + usedlen);
     }
   }
 
@@ -2130,7 +2131,7 @@ int expand_wildcards_eval(char_u **pat, int *num_file, char ***file, int flags)
       // pattern anyway (without the star) so that this works for remote
       // files and non-file buffer names.
       *file = xmalloc(sizeof(char *));
-      **file = (char *)eval_pat;
+      **file = eval_pat;
       eval_pat = NULL;
       *num_file = 1;
       ret = OK;
diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index 3ba09b45a1..c676dcddbd 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -102,7 +102,7 @@ int plines_win_nofold(win_T *wp, linenr_T lnum)
   unsigned int col;
   int width;
 
-  s = (char *)ml_get_buf(wp->w_buffer, lnum, false);
+  s = ml_get_buf(wp->w_buffer, lnum, false);
   if (*s == NUL) {  // empty line
     return 1;
   }
@@ -144,7 +144,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
     return lines + 1;
   }
 
-  char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
+  char_u *line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
 
   colnr_T col = 0;
   chartabsize_T cts;
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 86f60cb57e..cd2dd4b89c 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -710,7 +710,7 @@ static int qf_get_next_buf_line(qfstate_T *state)
   if (state->buflnum > state->lnumlast) {
     return QF_END_OF_INPUT;
   }
-  char *p_buf = (char *)ml_get_buf(state->buf, state->buflnum, false);
+  char *p_buf = ml_get_buf(state->buf, state->buflnum, false);
   state->buflnum += 1;
 
   size_t len = STRLEN(p_buf);
@@ -3832,7 +3832,7 @@ static buf_T *qf_find_buf(qf_info_T *qi)
 /// @return  OK or FAIL
 int qf_process_qftf_option(void)
 {
-  return option_set_callback_func((char_u *)p_qftf, &qftf_cb);
+  return option_set_callback_func(p_qftf, &qftf_cb);
 }
 
 /// Update the w:quickfix_title variable in the quickfix/location list window in
@@ -4317,7 +4317,7 @@ static char *get_mef_name(void)
   static int off = 0;
 
   if (*p_mef == NUL) {
-    name = (char *)vim_tempname();
+    name = vim_tempname();
     if (name == NULL) {
       emsg(_(e_notmp));
     }
@@ -5153,7 +5153,7 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
                          fname,
                          NULL,
                          duplicate_name ? 0 : buf->b_fnum,
-                         (char *)ml_get_buf(buf, regmatch->startpos[0].lnum + lnum, false),
+                         ml_get_buf(buf, regmatch->startpos[0].lnum + lnum, false),
                          regmatch->startpos[0].lnum + lnum,
                          regmatch->endpos[0].lnum + lnum,
                          regmatch->startpos[0].col + 1,
@@ -5180,7 +5180,7 @@ static bool vgr_match_buflines(qf_list_T *qfl, char *fname, buf_T *buf, char *sp
         }
       }
     } else {
-      char *const str = (char *)ml_get_buf(buf, lnum, false);
+      char *const str = ml_get_buf(buf, lnum, false);
       int score;
       uint32_t matches[MAX_FUZZY_MATCHES];
       const size_t sz = sizeof(matches) / sizeof(matches[0]);
@@ -5260,7 +5260,7 @@ static bool existing_swapfile(const buf_T *buf)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if (buf->b_ml.ml_mfp != NULL && buf->b_ml.ml_mfp->mf_fname != NULL) {
-    const char *const fname = (char *)buf->b_ml.ml_mfp->mf_fname;
+    const char *const fname = buf->b_ml.ml_mfp->mf_fname;
     const size_t len = STRLEN(fname);
 
     return fname[len - 1] != 'p' || fname[len - 2] != 'w';
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index ffa68c56b2..a94f91d103 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -137,7 +137,7 @@ static int re_multi_type(int c)
   return NOT_MULTI;
 }
 
-static char_u *reg_prev_sub = NULL;
+static char *reg_prev_sub = NULL;
 
 /*
  * REGEXP_INRANGE contains all characters which are always special in a []
@@ -1040,7 +1040,7 @@ static char_u *reg_getline(linenr_T lnum)
     // Must have matched the "\n" in the last line.
     return (char_u *)"";
   }
-  return ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, false);
+  return (char_u *)ml_get_buf(rex.reg_buf, rex.reg_firstlnum + lnum, false);
 }
 
 static char_u *reg_startzp[NSUBEXP];  // Workspace to mark beginning
@@ -1523,23 +1523,21 @@ static fptr_T do_Lower(int *d, int c)
   return (fptr_T)do_Lower;
 }
 
-/*
- * regtilde(): Replace tildes in the pattern by the old pattern.
- *
- * Short explanation of the tilde: It stands for the previous replacement
- * pattern.  If that previous pattern also contains a ~ we should go back a
- * step further...  But we insert the previous pattern into the current one
- * and remember that.
- * This still does not handle the case where "magic" changes.  So require the
- * user to keep his hands off of "magic".
- *
- * The tildes are parsed once before the first call to vim_regsub().
- */
-char_u *regtilde(char_u *source, int magic, bool preview)
+/// regtilde(): Replace tildes in the pattern by the old pattern.
+///
+/// Short explanation of the tilde: It stands for the previous replacement
+/// pattern.  If that previous pattern also contains a ~ we should go back a
+/// step further...  But we insert the previous pattern into the current one
+/// and remember that.
+/// This still does not handle the case where "magic" changes.  So require the
+/// user to keep his hands off of "magic".
+///
+/// The tildes are parsed once before the first call to vim_regsub().
+char *regtilde(char *source, int magic, bool preview)
 {
-  char_u *newsub = source;
-  char_u *tmpsub;
-  char_u *p;
+  char *newsub = source;
+  char *tmpsub;
+  char *p;
   int len;
   int prevlen;
 
@@ -1575,7 +1573,7 @@ char_u *regtilde(char_u *source, int magic, bool preview)
       if (*p == '\\' && p[1]) {         // skip escaped characters
         p++;
       }
-      p += utfc_ptr2len((char *)p) - 1;
+      p += utfc_ptr2len(p) - 1;
     }
   }
 
@@ -1584,7 +1582,7 @@ char_u *regtilde(char_u *source, int magic, bool preview)
     // Store a copy of newsub  in reg_prev_sub.  It is always allocated,
     // because recursive calls may make the returned string invalid.
     xfree(reg_prev_sub);
-    reg_prev_sub = vim_strsave(newsub);
+    reg_prev_sub = xstrdup(newsub);
   }
 
   return newsub;
@@ -1717,7 +1715,7 @@ int vim_regsub_multi(regmmatch_T *rmp, linenr_T lnum, char_u *source, char_u *de
 
 // When nesting more than a couple levels it's probably a mistake.
 #define MAX_REGSUB_NESTING 4
-static char_u *eval_result[MAX_REGSUB_NESTING] = { NULL, NULL, NULL, NULL };
+static char *eval_result[MAX_REGSUB_NESTING] = { NULL, NULL, NULL, NULL };
 
 #if defined(EXITFREE)
 void free_resub_eval_result(void)
@@ -1826,21 +1824,21 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest, int des
           eval_result[nested] = NULL;
         } else {
           char buf[NUMBUFLEN];
-          eval_result[nested] = (char_u *)tv_get_string_buf_chk(&rettv, buf);
+          eval_result[nested] = (char *)tv_get_string_buf_chk(&rettv, buf);
           if (eval_result[nested] != NULL) {
-            eval_result[nested] = vim_strsave(eval_result[nested]);
+            eval_result[nested] = xstrdup(eval_result[nested]);
           }
         }
         tv_clear(&rettv);
       } else {
-        eval_result[nested] = (char_u *)eval_to_string((char *)source + 2, NULL, true);
+        eval_result[nested] = eval_to_string((char *)source + 2, NULL, true);
       }
       nesting--;
 
       if (eval_result[nested] != NULL) {
         int had_backslash = false;
 
-        for (s = eval_result[nested]; *s != NUL; MB_PTR_ADV(s)) {
+        for (s = (char_u *)eval_result[nested]; *s != NUL; MB_PTR_ADV(s)) {
           // Change NL to CR, so that it becomes a line break,
           // unless called from vim_regexec_nl().
           // Skip over a backslashed character.
@@ -1862,9 +1860,9 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest, int des
         }
         if (had_backslash && (flags & REGSUB_BACKSLASH)) {
           // Backslashes will be consumed, need to double them.
-          s = vim_strsave_escaped(eval_result[nested], (char_u *)"\\");
+          s = vim_strsave_escaped((char_u *)eval_result[nested], (char_u *)"\\");
           xfree(eval_result[nested]);
-          eval_result[nested] = s;
+          eval_result[nested] = (char *)s;
         }
 
         dst += STRLEN(eval_result[nested]);
@@ -2466,12 +2464,12 @@ static bool vim_regexec_string(regmatch_T *rmp, char_u *line, colnr_T col, bool
       && result == NFA_TOO_EXPENSIVE) {
     int save_p_re = (int)p_re;
     int re_flags = (int)rmp->regprog->re_flags;
-    char_u *pat = vim_strsave(((nfa_regprog_T *)rmp->regprog)->pattern);
+    char *pat = xstrdup(((nfa_regprog_T *)rmp->regprog)->pattern);
 
     p_re = BACKTRACKING_ENGINE;
     vim_regfree(rmp->regprog);
-    report_re_switch(pat);
-    rmp->regprog = vim_regcomp((char *)pat, re_flags);
+    report_re_switch((char_u *)pat);
+    rmp->regprog = vim_regcomp(pat, re_flags);
     if (rmp->regprog != NULL) {
       rmp->regprog->re_in_use = true;
       result = rmp->regprog->engine->regexec_nl(rmp, line, col, nl);
@@ -2557,16 +2555,16 @@ long vim_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_T lnum,
       && result == NFA_TOO_EXPENSIVE) {
     int save_p_re = (int)p_re;
     int re_flags = (int)rmp->regprog->re_flags;
-    char_u *pat = vim_strsave(((nfa_regprog_T *)rmp->regprog)->pattern);
+    char *pat = xstrdup(((nfa_regprog_T *)rmp->regprog)->pattern);
 
     p_re = BACKTRACKING_ENGINE;
     regprog_T *prev_prog = rmp->regprog;
 
-    report_re_switch(pat);
+    report_re_switch((char_u *)pat);
     // checking for \z misuse was already done when compiling for NFA,
     // allow all here
     reg_do_extmatch = REX_ALL;
-    rmp->regprog = vim_regcomp((char *)pat, re_flags);
+    rmp->regprog = vim_regcomp(pat, re_flags);
     reg_do_extmatch = 0;
 
     if (rmp->regprog == NULL) {
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index ccf2b60da2..63e4dd5b7e 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -1857,14 +1857,14 @@ static char_u *regatom(int *flagp)
       char_u *lp;
 
       ret = regnode(EXACTLY);
-      lp = reg_prev_sub;
+      lp = (char_u *)reg_prev_sub;
       while (*lp != NUL) {
         regc(*lp++);
       }
       regc(NUL);
       if (*reg_prev_sub != NUL) {
         *flagp |= HASWIDTH;
-        if ((lp - reg_prev_sub) == 1) {
+        if ((lp - (char_u *)reg_prev_sub) == 1) {
           *flagp |= SIMPLE;
         }
       }
diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h
index b313dfe877..5d7175b89a 100644
--- a/src/nvim/regexp_defs.h
+++ b/src/nvim/regexp_defs.h
@@ -127,7 +127,7 @@ typedef struct {
   int has_zend;                         // pattern contains \ze
   int has_backref;                      // pattern contains \1 .. \9
   int reghasz;
-  char_u *pattern;
+  char *pattern;
   int nsubexp;                          // number of ()
   int nstate;
   nfa_state_T state[1];                 // actually longer..
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index 4c1058ba36..ea11398c30 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -1959,9 +1959,9 @@ static int nfa_regatom(void)
       emsg(_(e_nopresub));
       return FAIL;
     }
-    for (lp = reg_prev_sub; *lp != NUL; MB_CPTR_ADV(lp)) {
+    for (lp = (char_u *)reg_prev_sub; *lp != NUL; MB_CPTR_ADV(lp)) {
       EMIT(utf_ptr2char((char *)lp));
-      if (lp != reg_prev_sub) {
+      if (lp != (char_u *)reg_prev_sub) {
         EMIT(NFA_CONCAT);
       }
     }
@@ -7593,7 +7593,7 @@ static regprog_T *nfa_regcomp(char_u *expr, int re_flags)
 #endif
   // Remember whether this pattern has any \z specials in it.
   prog->reghasz = re_has_z;
-  prog->pattern = vim_strsave(expr);
+  prog->pattern = xstrdup((char *)expr);
 #ifdef REGEXP_DEBUG
   nfa_regengine.expr = NULL;
 #endif
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index d268dde845..8e10f2d62d 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -620,7 +620,7 @@ void setcursor_mayforce(bool force)
       // With 'rightleft' set and the cursor on a double-wide character,
       // position it on the leftmost column.
       col = curwin->w_width_inner - curwin->w_wcol
-            - ((utf_ptr2cells((char *)get_cursor_pos_ptr()) == 2
+            - ((utf_ptr2cells(get_cursor_pos_ptr()) == 2
                 && vim_isprintc(gchar_cursor())) ? 2 : 1);
     }
 
diff --git a/src/nvim/search.c b/src/nvim/search.c
index 490e79ebb0..e2df31c04f 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -175,11 +175,11 @@ int search_regcomp(char_u *pat, int pat_save, int pat_use, int options, regmmatc
   if (!(options & SEARCH_KEEP) && (cmdmod.cmod_flags & CMOD_KEEPPATTERNS) == 0) {
     // search or global command
     if (pat_save == RE_SEARCH || pat_save == RE_BOTH) {
-      save_re_pat(RE_SEARCH, pat, magic);
+      save_re_pat(RE_SEARCH, (char *)pat, magic);
     }
     // substitute or global command
     if (pat_save == RE_SUBST || pat_save == RE_BOTH) {
-      save_re_pat(RE_SUBST, pat, magic);
+      save_re_pat(RE_SUBST, (char *)pat, magic);
     }
   }
 
@@ -198,11 +198,11 @@ char_u *get_search_pat(void)
   return mr_pattern;
 }
 
-void save_re_pat(int idx, char_u *pat, int magic)
+void save_re_pat(int idx, char *pat, int magic)
 {
-  if (spats[idx].pat != pat) {
+  if (spats[idx].pat != (char_u *)pat) {
     free_spat(&spats[idx]);
-    spats[idx].pat = vim_strsave(pat);
+    spats[idx].pat = (char_u *)xstrdup(pat);
     spats[idx].magic = magic;
     spats[idx].no_scs = no_smartcase;
     spats[idx].timestamp = os_time();
@@ -225,11 +225,11 @@ void save_search_patterns(void)
   if (save_level++ == 0) {
     saved_spats[0] = spats[0];
     if (spats[0].pat != NULL) {
-      saved_spats[0].pat = vim_strsave(spats[0].pat);
+      saved_spats[0].pat = (char_u *)xstrdup((char *)spats[0].pat);
     }
     saved_spats[1] = spats[1];
     if (spats[1].pat != NULL) {
-      saved_spats[1].pat = vim_strsave(spats[1].pat);
+      saved_spats[1].pat = (char_u *)xstrdup((char *)spats[1].pat);
     }
     saved_spats_last_idx = last_idx;
     saved_spats_no_hlsearch = no_hlsearch;
@@ -296,7 +296,7 @@ void save_last_search_pattern(void)
 
   saved_last_search_spat = spats[RE_SEARCH];
   if (spats[RE_SEARCH].pat != NULL) {
-    saved_last_search_spat.pat = vim_strsave(spats[RE_SEARCH].pat);
+    saved_last_search_spat.pat = (char_u *)xstrdup((char *)spats[RE_SEARCH].pat);
   }
   saved_last_idx = last_idx;
   saved_no_hlsearch = no_hlsearch;
@@ -474,7 +474,7 @@ void set_last_search_pat(const char_u *s, int idx, int magic, int setlast)
     if (spats[idx].pat == NULL) {
       saved_spats[idx].pat = NULL;
     } else {
-      saved_spats[idx].pat = vim_strsave(spats[idx].pat);
+      saved_spats[idx].pat = (char_u *)xstrdup((char *)spats[idx].pat);
     }
     saved_spats_last_idx = last_idx;
   }
@@ -571,7 +571,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
                && pos->lnum <= buf->b_ml.ml_line_count
                && pos->col < MAXCOL - 2) {
       // Watch out for the "col" being MAXCOL - 2, used in a closed fold.
-      ptr = ml_get_buf(buf, pos->lnum, false);
+      ptr = (char_u *)ml_get_buf(buf, pos->lnum, false);
       if ((int)STRLEN(ptr) <= pos->col) {
         start_char_len = 1;
       } else {
@@ -642,7 +642,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
           if (lnum + matchpos.lnum > buf->b_ml.ml_line_count) {
             ptr = (char_u *)"";
           } else {
-            ptr = ml_get_buf(buf, lnum + matchpos.lnum, false);
+            ptr = (char_u *)ml_get_buf(buf, lnum + matchpos.lnum, false);
           }
 
           // Forward search in the first line: match should be after
@@ -711,7 +711,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
               }
               // Need to get the line pointer again, a multi-line search may
               // have made it invalid.
-              ptr = ml_get_buf(buf, lnum, false);
+              ptr = (char_u *)ml_get_buf(buf, lnum, false);
             }
             if (!match_ok) {
               continue;
@@ -794,7 +794,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
               }
               // Need to get the line pointer again, a
               // multi-line search may have made it invalid.
-              ptr = ml_get_buf(buf, lnum + matchpos.lnum, false);
+              ptr = (char_u *)ml_get_buf(buf, lnum + matchpos.lnum, false);
             }
 
             // If there is only a match after the cursor, skip
@@ -822,7 +822,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
             } else {
               pos->col--;
               if (pos->lnum <= buf->b_ml.ml_line_count) {
-                ptr = ml_get_buf(buf, pos->lnum, false);
+                ptr = (char_u *)ml_get_buf(buf, pos->lnum, false);
                 pos->col -= utf_head_off((char *)ptr, (char *)ptr + pos->col);
               }
             }
@@ -1443,7 +1443,7 @@ int search_for_exact_line(buf_T *buf, pos_T *pos, Direction dir, char_u *pat)
     if (start == 0) {
       start = pos->lnum;
     }
-    ptr = ml_get_buf(buf, pos->lnum, false);
+    ptr = (char_u *)ml_get_buf(buf, pos->lnum, false);
     p = (char_u *)skipwhite((char *)ptr);
     pos->col = (colnr_T)(p - ptr);
 
@@ -2717,7 +2717,7 @@ static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchst
     }
     if (done_search) {
       xfree(lastpat);
-      lastpat = vim_strsave(spats[last_idx].pat);
+      lastpat = (char_u *)xstrdup((char *)spats[last_idx].pat);
       chgtick = (int)buf_get_changedtick(curbuf);
       lbuf = curbuf;
       lastpos = p;
@@ -2827,7 +2827,7 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
       goto the_end;
     }
     xfree(spats[last_idx].pat);
-    spats[last_idx].pat = vim_strsave(pattern);
+    spats[last_idx].pat = (char_u *)xstrdup((char *)pattern);
   }
   if (spats[last_idx].pat == NULL || *spats[last_idx].pat == NUL) {
     goto the_end;  // the previous pattern was never defined
@@ -3103,7 +3103,7 @@ bool fuzzy_match(char_u *const str, const char_u *const pat_arg, const bool matc
 
   *outScore = 0;
 
-  char_u *const save_pat = vim_strsave(pat_arg);
+  char_u *const save_pat = (char_u *)xstrdup((char *)pat_arg);
   char_u *pat = save_pat;
   char_u *p = pat;
 
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 1a70b77053..312c30e4a9 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1238,7 +1238,7 @@ static void shada_read(ShaDaReadDef *const sd_reader, const int flags)
       // string is close to useless: you can only use it with :& or :~ and
       // that’s all because s//~ is not available until the first call to
       // regtilde. Vim was not calling this for some reason.
-      (void)(char *)regtilde((char_u *)cur_entry.data.sub_string.sub, p_magic, false);
+      (void)regtilde(cur_entry.data.sub_string.sub, p_magic, false);
       // Do not free shada entry: its allocated memory was saved above.
       break;
     case kSDItemHistoryEntry:
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 30e256b37a..7f07d2ff2c 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -194,8 +194,8 @@ int did_set_spelltab;
 char *e_format = N_("E759: Format error in spell file");
 
 // Remember what "z?" replaced.
-char_u *repl_from = NULL;
-char_u *repl_to = NULL;
+char *repl_from = NULL;
+char *repl_to = NULL;
 
 /// Main spell-checking function.
 /// "ptr" points to a character that could be the start of a word.
@@ -1275,7 +1275,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
   decor_spell_nav_start(wp);
 
   while (!got_int) {
-    char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
+    char_u *line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
 
     len = STRLEN(line);
     if (buflen < len + MAXWLEN + 2) {
@@ -1302,7 +1302,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
 
       // Need to get the line again, may have looked at the previous
       // one.
-      line = ml_get_buf(wp->w_buffer, lnum, false);
+      line = (char_u *)ml_get_buf(wp->w_buffer, lnum, false);
     }
 
     // Copy the line into "buf" and append the start of the next line if
@@ -1312,7 +1312,7 @@ size_t spell_move_to(win_T *wp, int dir, bool allwords, bool curline, hlf_T *att
     STRCPY(buf, line);
     if (lnum < wp->w_buffer->b_ml.ml_line_count) {
       spell_cat_line(buf + STRLEN(buf),
-                     ml_get_buf(wp->w_buffer, lnum + 1, false),
+                     (char_u *)ml_get_buf(wp->w_buffer, lnum + 1, false),
                      MAXWLEN);
     }
     char_u *p = buf + skip;
@@ -1573,15 +1573,15 @@ static void int_wordlist_spl(char_u *fname)
                int_wordlist, spell_enc());
 }
 
-// Allocate a new slang_T for language "lang".  "lang" can be NULL.
-// Caller must fill "sl_next".
-slang_T *slang_alloc(char_u *lang)
+/// Allocate a new slang_T for language "lang".  "lang" can be NULL.
+/// Caller must fill "sl_next".
+slang_T *slang_alloc(char *lang)
   FUNC_ATTR_NONNULL_RET
 {
   slang_T *lp = xcalloc(1, sizeof(slang_T));
 
   if (lang != NULL) {
-    lp->sl_name = vim_strsave(lang);
+    lp->sl_name = xstrdup(lang);
   }
   ga_init(&lp->sl_rep, sizeof(fromto_T), 10);
   ga_init(&lp->sl_repsal, sizeof(fromto_T), 10);
@@ -1693,7 +1693,7 @@ void slang_clear_sug(slang_T *lp)
 static void spell_load_cb(char *fname, void *cookie)
 {
   spelload_T *slp = (spelload_T *)cookie;
-  slang_T *slang = spell_load_file((char_u *)fname, slp->sl_lang, NULL, false);
+  slang_T *slang = spell_load_file(fname, (char *)slp->sl_lang, NULL, false);
   if (slang != NULL) {
     // When a previously loaded file has NOBREAK also use it for the
     // ".add" files.
@@ -1861,7 +1861,7 @@ char *did_set_spelllang(win_T *wp)
   langp_T *lp, *lp2;
   static bool recursive = false;
   char *ret_msg = NULL;
-  char_u *spl_copy;
+  char *spl_copy;
 
   bufref_T bufref;
   set_bufref(&bufref, wp->w_buffer);
@@ -1879,12 +1879,12 @@ char *did_set_spelllang(win_T *wp)
 
   // Make a copy of 'spelllang', the SpellFileMissing autocommands may change
   // it under our fingers.
-  spl_copy = vim_strsave((char_u *)wp->w_s->b_p_spl);
+  spl_copy = xstrdup(wp->w_s->b_p_spl);
 
   wp->w_s->b_cjk = 0;
 
   // Loop over comma separated language names.
-  for (splp = (char *)spl_copy; *splp != NUL;) {
+  for (splp = spl_copy; *splp != NUL;) {
     // Get one language name.
     copy_option_part(&splp, (char *)lang, MAXWLEN, ",");
     region = NULL;
@@ -1952,7 +1952,7 @@ char *did_set_spelllang(win_T *wp)
     // If not found try loading the language now.
     if (slang == NULL) {
       if (filename) {
-        (void)spell_load_file(lang, lang, NULL, false);
+        (void)spell_load_file((char *)lang, (char *)lang, NULL, false);
       } else {
         spell_load_lang(lang);
         // SpellFileMissing autocommands may do anything, including
@@ -2054,7 +2054,7 @@ char *did_set_spelllang(win_T *wp)
           *p = NUL;             // truncate at ".encoding.add"
         }
       }
-      slang = spell_load_file(spf_name, lang, NULL, true);
+      slang = spell_load_file((char *)spf_name, (char *)lang, NULL, true);
 
       // If one of the languages has NOBREAK we assume the addition
       // files also have this.
diff --git a/src/nvim/spell_defs.h b/src/nvim/spell_defs.h
index 27b9777dc2..2c4aebe420 100644
--- a/src/nvim/spell_defs.h
+++ b/src/nvim/spell_defs.h
@@ -115,7 +115,7 @@ typedef struct slang_S slang_T;
 
 struct slang_S {
   slang_T *sl_next;         // next language
-  char_u *sl_name;          // language name "en", "en.rare", "nl", etc.
+  char *sl_name;            // language name "en", "en.rare", "nl", etc.
   char *sl_fname;           // name of .spl file
   bool sl_add;              // true if it's a .add file.
 
@@ -252,7 +252,7 @@ typedef struct wordcount_S {
 #define MAXWORDCOUNT 0xffff
 
 // Remember what "z?" replaced.
-extern char_u *repl_from;
-extern char_u *repl_to;
+extern char *repl_from;
+extern char *repl_to;
 
 #endif  // NVIM_SPELL_DEFS_H
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 661ca54fad..e6e56d615c 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -572,10 +572,10 @@ static inline int spell_check_magic_string(FILE *const fd)
 /// @param silent  no error if file doesn't exist
 ///
 /// @return  the slang_T the spell file was loaded into.  NULL for error.
-slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, bool silent)
+slang_T *spell_load_file(char *fname, char *lang, slang_T *old_lp, bool silent)
 {
   FILE *fd;
-  char_u *p;
+  char *p;
   int n;
   int len;
   slang_T *lp = NULL;
@@ -583,7 +583,7 @@ slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, bool sile
   int res;
   bool did_estack_push = false;
 
-  fd = os_fopen((char *)fname, "r");
+  fd = os_fopen(fname, "r");
   if (fd == NULL) {
     if (!silent) {
       semsg(_(e_notopen), fname);
@@ -604,16 +604,16 @@ slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, bool sile
     lp = slang_alloc(lang);
 
     // Remember the file name, used to reload the file when it's updated.
-    lp->sl_fname = (char *)vim_strsave(fname);
+    lp->sl_fname = xstrdup(fname);
 
     // Check for .add.spl.
-    lp->sl_add = strstr(path_tail((char *)fname), SPL_FNAME_ADD) != NULL;
+    lp->sl_add = strstr(path_tail(fname), SPL_FNAME_ADD) != NULL;
   } else {
     lp = old_lp;
   }
 
   // Set sourcing_name, so that error messages mention the file name.
-  estack_push(ETYPE_SPELL, (char *)fname, 0);
+  estack_push(ETYPE_SPELL, fname, 0);
   did_estack_push = true;
 
   // <HEADER>: <fileID>
@@ -697,11 +697,11 @@ slang_T *spell_load_file(char_u *fname, char_u *lang, slang_T *old_lp, bool sile
       break;
 
     case SN_MAP:
-      p = READ_STRING(fd, len);                         // <mapstr>
+      p = (char *)READ_STRING(fd, len);                         // <mapstr>
       if (p == NULL) {
         goto endFAIL;
       }
-      set_map_str(lp, p);
+      set_map_str(lp, (char_u *)p);
       xfree(p);
       break;
 
@@ -1824,7 +1824,7 @@ static void spell_reload_one(char_u *fname, bool added_word)
   for (slang = first_lang; slang != NULL; slang = slang->sl_next) {
     if (path_full_compare((char *)fname, slang->sl_fname, false, true) == kEqualFiles) {
       slang_clear(slang);
-      if (spell_load_file(fname, NULL, slang, false) == NULL) {
+      if (spell_load_file((char *)fname, NULL, slang, false) == NULL) {
         // reloading failed, clear the language
         slang_clear(slang);
       }
@@ -2005,17 +2005,17 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   char_u *line;
   char_u *pc = NULL;
 #define MAXITEMCNT  30
-  char_u *(items[MAXITEMCNT]);
+  char *(items[MAXITEMCNT]);
   int itemcnt;
-  char_u *p;
+  char *p;
   int lnum = 0;
   affheader_T *cur_aff = NULL;
   bool did_postpone_prefix = false;
   int aff_todo = 0;
   hashtab_T *tp;
-  char_u *low = NULL;
-  char_u *fol = NULL;
-  char_u *upp = NULL;
+  char *low = NULL;
+  char *fol = NULL;
+  char *upp = NULL;
   int do_rep;
   int do_repsal;
   int do_sal;
@@ -2090,8 +2090,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     // Split the line up in white separated items.  Put a NUL after each
     // item.
     itemcnt = 0;
-    for (p = line;;) {
-      while (*p != NUL && *p <= ' ') {  // skip white space and CR/NL
+    for (p = (char *)line;;) {
+      while (*p != NUL && (uint8_t)(*p) <= ' ') {  // skip white space and CR/NL
         p++;
       }
       if (*p == NUL) {
@@ -2102,12 +2102,12 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
       }
       items[itemcnt++] = p;
       // A few items have arbitrary text argument, don't split them.
-      if (itemcnt == 2 && spell_info_item(items[0])) {
-        while (*p >= ' ' || *p == TAB) {  // skip until CR/NL
+      if (itemcnt == 2 && spell_info_item((char_u *)items[0])) {
+        while ((uint8_t)(*p) >= ' ' || *p == TAB) {  // skip until CR/NL
           p++;
         }
       } else {
-        while (*p > ' ') {  // skip until white space or CR/NL
+        while ((uint8_t)(*p) > ' ') {  // skip until white space or CR/NL
           p++;
         }
       }
@@ -2154,7 +2154,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           smsg(_("FLAG after using flags in %s line %d: %s"),
                fname, lnum, items[1]);
         }
-      } else if (spell_info_item(items[0]) && itemcnt > 1) {
+      } else if (spell_info_item((char_u *)items[0]) && itemcnt > 1) {
         p = getroom(spin,
                     (spin->si_info == NULL ? 0 : STRLEN(spin->si_info))
                     + STRLEN(items[0])
@@ -2166,9 +2166,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         STRCAT(p, items[0]);
         STRCAT(p, " ");
         STRCAT(p, items[1]);
-        spin->si_info = p;
+        spin->si_info = (char_u *)p;
       } else if (is_aff_rule(items, itemcnt, "MIDWORD", 2) && midword == NULL) {
-        midword = (char_u *)getroom_save(spin, items[1]);
+        midword = (char_u *)getroom_save(spin, (char_u *)items[1]);
       } else if (is_aff_rule(items, itemcnt, "TRY", 2)) {
         // ignored, we look in the tree for what chars may appear
       }
@@ -2176,44 +2176,44 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
       else if ((is_aff_rule(items, itemcnt, "RAR", 2)
                 || is_aff_rule(items, itemcnt, "RARE", 2))
                && aff->af_rare == 0) {
-        aff->af_rare = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_rare = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                     fname, lnum);
       }
       // TODO: remove "KEP" later
       else if ((is_aff_rule(items, itemcnt, "KEP", 2)
                 || is_aff_rule(items, itemcnt, "KEEPCASE", 2))
                && aff->af_keepcase == 0) {
-        aff->af_keepcase = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_keepcase = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                         fname, lnum);
       } else if ((is_aff_rule(items, itemcnt, "BAD", 2)
                   || is_aff_rule(items, itemcnt, "FORBIDDENWORD", 2))
                  && aff->af_bad == 0) {
-        aff->af_bad = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_bad = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                    fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "NEEDAFFIX", 2)
                  && aff->af_needaffix == 0) {
-        aff->af_needaffix = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_needaffix = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                          fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "CIRCUMFIX", 2)
                  && aff->af_circumfix == 0) {
-        aff->af_circumfix = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_circumfix = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                          fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "NOSUGGEST", 2)
                  && aff->af_nosuggest == 0) {
-        aff->af_nosuggest = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_nosuggest = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                          fname, lnum);
       } else if ((is_aff_rule(items, itemcnt, "NEEDCOMPOUND", 2)
                   || is_aff_rule(items, itemcnt, "ONLYINCOMPOUND", 2))
                  && aff->af_needcomp == 0) {
-        aff->af_needcomp = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_needcomp = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                         fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDROOT", 2)
                  && aff->af_comproot == 0) {
-        aff->af_comproot = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_comproot = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                         fname, lnum);
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDFORBIDFLAG", 2)
                  && aff->af_compforbid == 0) {
-        aff->af_compforbid = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_compforbid = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                           fname, lnum);
         if (aff->af_pref.ht_used > 0) {
           smsg(_("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
@@ -2221,7 +2221,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDPERMITFLAG", 2)
                  && aff->af_comppermit == 0) {
-        aff->af_comppermit = affitem2flag(aff->af_flagtype, items[1],
+        aff->af_comppermit = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                           fname, lnum);
         if (aff->af_pref.ht_used > 0) {
           smsg(_("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
@@ -2234,7 +2234,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         p = getroom(spin, STRLEN(items[1]) + 2, false);
         STRCPY(p, items[1]);
         STRCAT(p, "+");
-        compflags = p;
+        compflags = (char_u *)p;
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDRULES", 2)) {
         // We don't use the count, but do check that it's a number and
         // not COMPOUNDRULE mistyped.
@@ -2257,7 +2257,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             STRCAT(p, "/");
           }
           STRCAT(p, items[1]);
-          compflags = p;
+          compflags = (char_u *)p;
         }
       } else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
                  && compmax == 0) {
@@ -2306,12 +2306,12 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
         if (i >= gap->ga_len) {
           ga_grow(gap, 2);
-          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[1]);
-          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, items[2]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[1]);
+          ((char **)(gap->ga_data))[gap->ga_len++] = getroom_save(spin, (char_u *)items[2]);
         }
       } else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
                  && syllable == NULL) {
-        syllable = (char_u *)getroom_save(spin, items[1]);
+        syllable = (char_u *)getroom_save(spin, (char_u *)items[1]);
       } else if (is_aff_rule(items, itemcnt, "NOBREAK", 1)) {
         spin->si_nobreak = true;
       } else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1)) {
@@ -2356,7 +2356,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         } else {
           // New affix letter.
           cur_aff = getroom(spin, sizeof(*cur_aff), true);
-          cur_aff->ah_flag = affitem2flag(aff->af_flagtype, items[1],
+          cur_aff->ah_flag = affitem2flag(aff->af_flagtype, (char_u *)items[1],
                                           fname, lnum);
           if (cur_aff->ah_flag == 0 || STRLEN(items[1]) >= AH_KEY_LEN) {
             break;
@@ -2444,10 +2444,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         aff_entry = getroom(spin, sizeof(*aff_entry), true);
 
         if (STRCMP(items[2], "0") != 0) {
-          aff_entry->ae_chop = (char_u *)getroom_save(spin, items[2]);
+          aff_entry->ae_chop = (char_u *)getroom_save(spin, (char_u *)items[2]);
         }
         if (STRCMP(items[3], "0") != 0) {
-          aff_entry->ae_add = (char_u *)getroom_save(spin, items[3]);
+          aff_entry->ae_add = (char_u *)getroom_save(spin, (char_u *)items[3]);
 
           // Recognize flags on the affix: abcd/XYZ
           aff_entry->ae_flags = (char_u *)vim_strchr((char *)aff_entry->ae_add, '/');
@@ -2467,7 +2467,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           if (STRCMP(items[4], ".") != 0) {
             char_u buf[MAXLINELEN];
 
-            aff_entry->ae_cond = (char_u *)getroom_save(spin, items[4]);
+            aff_entry->ae_cond = (char_u *)getroom_save(spin, (char_u *)items[4]);
             if (*items[0] == 'P') {
               sprintf((char *)buf, "^%s", items[4]);
             } else {
@@ -2502,10 +2502,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               if (c_up != c
                   && (aff_entry->ae_cond == NULL
                       || utf_ptr2char((char *)aff_entry->ae_cond) == c)) {
-                p = aff_entry->ae_add
+                p = (char *)aff_entry->ae_add
                     + STRLEN(aff_entry->ae_add);
                 MB_PTR_BACK(aff_entry->ae_add, p);
-                if (utf_ptr2char((char *)p) == c_up) {
+                if (utf_ptr2char(p) == c_up) {
                   upper = true;
                   aff_entry->ae_chop = NULL;
                   *p = NUL;
@@ -2515,7 +2515,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                   // upper-case letter.
                   if (aff_entry->ae_cond != NULL) {
                     char_u buf[MAXLINELEN];
-                    onecap_copy(items[4], buf, true);
+                    onecap_copy((char_u *)items[4], buf, true);
                     aff_entry->ae_cond = (char_u *)getroom_save(spin, buf);
                     if (aff_entry->ae_cond != NULL) {
                       sprintf((char *)buf, "^%s",
@@ -2534,10 +2534,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               int n;
 
               // Find a previously used condition.
-              for (idx = spin->si_prefcond.ga_len - 1; idx >= 0;
-                   --idx) {
-                p = ((char_u **)spin->si_prefcond.ga_data)[idx];
-                if (str_equal(p, aff_entry->ae_cond)) {
+              for (idx = spin->si_prefcond.ga_len - 1; idx >= 0; idx--) {
+                p = ((char **)spin->si_prefcond.ga_data)[idx];
+                if (str_equal((char_u *)p, aff_entry->ae_cond)) {
                   break;
                 }
               }
@@ -2551,9 +2550,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 
               // Add the prefix to the prefix tree.
               if (aff_entry->ae_add == NULL) {
-                p = (char_u *)"";
+                p = "";
               } else {
-                p = aff_entry->ae_add;
+                p = (char *)aff_entry->ae_add;
               }
 
               // PFX_FLAGS is a negative number, so that
@@ -2571,7 +2570,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               if (aff_entry->ae_compforbid) {
                 n |= WFP_COMPFORBID;
               }
-              tree_add_word(spin, p, spin->si_prefroot, n,
+              tree_add_word(spin, (char_u *)p, spin->si_prefroot, n,
                             idx, cur_aff->ah_newID);
               did_postpone_prefix = true;
             }
@@ -2584,11 +2583,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           }
         }
       } else if (is_aff_rule(items, itemcnt, "FOL", 2) && fol == NULL) {
-        fol = vim_strsave(items[1]);
+        fol = xstrdup(items[1]);
       } else if (is_aff_rule(items, itemcnt, "LOW", 2) && low == NULL) {
-        low = vim_strsave(items[1]);
+        low = xstrdup(items[1]);
       } else if (is_aff_rule(items, itemcnt, "UPP", 2) && upp == NULL) {
-        upp = vim_strsave(items[1]);
+        upp = xstrdup(items[1]);
       } else if (is_aff_rule(items, itemcnt, "REP", 2)
                  || is_aff_rule(items, itemcnt, "REPSAL", 2)) {
         // Ignore REP/REPSAL count
@@ -2619,8 +2618,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             }
           }
           add_fromto(spin, items[0][3] == 'S'
-              ? &spin->si_repsal
-              : &spin->si_rep, items[1], items[2]);
+                     ? &spin->si_repsal
+                     : &spin->si_rep, (char_u *)items[1], (char_u *)items[2]);
         }
       } else if (is_aff_rule(items, itemcnt, "MAP", 2)) {
         // MAP item or count
@@ -2640,7 +2639,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
             if ((!GA_EMPTY(&spin->si_map)
                  && vim_strchr(spin->si_map.ga_data, c)
                  != NULL)
-                || vim_strchr((char *)p, c) != NULL) {
+                || vim_strchr(p, c) != NULL) {
               smsg(_("Duplicate character in MAP in %s line %d"),
                    fname, lnum);
             }
@@ -2658,31 +2657,31 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           // SAL item (sounds-a-like)
           // Either one of the known keys or a from-to pair.
           if (STRCMP(items[1], "followup") == 0) {
-            spin->si_followup = sal_to_bool(items[2]);
+            spin->si_followup = sal_to_bool((char_u *)items[2]);
           } else if (STRCMP(items[1], "collapse_result") == 0) {
-            spin->si_collapse = sal_to_bool(items[2]);
+            spin->si_collapse = sal_to_bool((char_u *)items[2]);
           } else if (STRCMP(items[1], "remove_accents") == 0) {
-            spin->si_rem_accents = sal_to_bool(items[2]);
+            spin->si_rem_accents = sal_to_bool((char_u *)items[2]);
           } else {
             // when "to" is "_" it means empty
-            add_fromto(spin, &spin->si_sal, items[1],
+            add_fromto(spin, &spin->si_sal, (char_u *)items[1],
                        STRCMP(items[2], "_") == 0 ? (char_u *)""
-                                                  : items[2]);
+                       : (char_u *)items[2]);
           }
         }
       } else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
                  && sofofrom == NULL) {
-        sofofrom = (char_u *)getroom_save(spin, items[1]);
+        sofofrom = (char_u *)getroom_save(spin, (char_u *)items[1]);
       } else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
                  && sofoto == NULL) {
-        sofoto = (char_u *)getroom_save(spin, items[1]);
+        sofoto = (char_u *)getroom_save(spin, (char_u *)items[1]);
       } else if (STRCMP(items[0], "COMMON") == 0) {
         int i;
 
         for (i = 1; i < itemcnt; i++) {
           if (HASHITEM_EMPTY(hash_find(&spin->si_commonwords, (char *)items[i]))) {
-            p = vim_strsave(items[i]);
-            hash_add(&spin->si_commonwords, p);
+            p = xstrdup(items[i]);
+            hash_add(&spin->si_commonwords, (char_u *)p);
           }
         }
       } else {
@@ -2773,9 +2772,9 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   return aff;
 }
 
-// Returns true when items[0] equals "rulename", there are "mincount" items or
-// a comment is following after item "mincount".
-static bool is_aff_rule(char_u **items, int itemcnt, char *rulename, int mincount)
+/// @return  true when items[0] equals "rulename", there are "mincount" items or
+///          a comment is following after item "mincount".
+static bool is_aff_rule(char **items, int itemcnt, char *rulename, int mincount)
 {
   return STRCMP(items[0], rulename) == 0
          && (itemcnt == mincount
@@ -4914,7 +4913,7 @@ static void spell_make_sugfile(spellinfo_T *spin, char *wfname)
   }
   if (slang == NULL) {
     spell_message(spin, _("Reading back spell file..."));
-    slang = spell_load_file((char_u *)wfname, NULL, NULL, false);
+    slang = spell_load_file(wfname, NULL, NULL, false);
     if (slang == NULL) {
       return;
     }
@@ -5233,7 +5232,7 @@ static void sug_write(spellinfo_T *spin, char_u *fname)
 
   for (linenr_T lnum = 1; lnum <= wcount; lnum++) {
     // <sugline>: <sugnr> ... NUL
-    char_u *line = ml_get_buf(spin->si_spellbuf, lnum, false);
+    char_u *line = (char_u *)ml_get_buf(spin->si_spellbuf, lnum, false);
     size_t len = STRLEN(line) + 1;
     if (fwrite(line, len, 1, fd) == 0) {
       emsg(_(e_write));
@@ -5531,7 +5530,7 @@ void spell_add_word(char_u *word, int len, SpellAddType what, int idx, bool undo
 
   if (idx == 0) {           // use internal wordlist
     if (int_wordlist == NULL) {
-      int_wordlist = vim_tempname();
+      int_wordlist = (char_u *)vim_tempname();
       if (int_wordlist == NULL) {
         return;
       }
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index c07e460ea8..c38fa2b24f 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -407,7 +407,7 @@ int spell_check_sps(void)
 /// When "count" is non-zero use that suggestion.
 void spell_suggest(int count)
 {
-  char_u *line;
+  char *line;
   pos_T prev_cursor = curwin->w_cursor;
   char_u wcopy[MAXWLEN + 2];
   char_u *p;
@@ -453,10 +453,10 @@ void spell_suggest(int count)
     // No bad word or it starts after the cursor: use the word under the
     // cursor.
     curwin->w_cursor = prev_cursor;
-    line = (char_u *)get_cursor_line_ptr();
-    p = line + curwin->w_cursor.col;
+    line = get_cursor_line_ptr();
+    p = (char_u *)line + curwin->w_cursor.col;
     // Backup to before start of word.
-    while (p > line && spell_iswordp_nmw(p, curwin)) {
+    while (p > (char_u *)line && spell_iswordp_nmw(p, curwin)) {
       MB_PTR_BACK(line, p);
     }
     // Forward to start of word.
@@ -468,7 +468,7 @@ void spell_suggest(int count)
       beep_flush();
       return;
     }
-    curwin->w_cursor.col = (colnr_T)(p - line);
+    curwin->w_cursor.col = (colnr_T)(p - (char_u *)line);
   }
 
   // Get the word and its length.
@@ -477,7 +477,7 @@ void spell_suggest(int count)
   need_cap = check_need_cap(curwin->w_cursor.lnum, curwin->w_cursor.col);
 
   // Make a copy of current line since autocommands may free the line.
-  line = vim_strsave((char_u *)get_cursor_line_ptr());
+  line = xstrdup(get_cursor_line_ptr());
   spell_suggest_timeout = 5000;
 
   // Get the list of suggestions.  Limit to 'lines' - 2 or the number in
@@ -487,7 +487,7 @@ void spell_suggest(int count)
   } else {
     limit = sps_limit;
   }
-  spell_find_suggest(line + curwin->w_cursor.col, badlen, &sug, limit,
+  spell_find_suggest((char_u *)line + curwin->w_cursor.col, badlen, &sug, limit,
                      true, need_cap, true);
 
   if (GA_EMPTY(&sug.su_ga)) {
@@ -593,20 +593,20 @@ void spell_suggest(int count)
     if (sug.su_badlen > stp->st_orglen) {
       // Replacing less than "su_badlen", append the remainder to
       // repl_to.
-      repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)sug.su_badlen);
+      repl_from = xstrnsave((char *)sug.su_badptr, (size_t)sug.su_badlen);
       vim_snprintf((char *)IObuff, IOSIZE, "%s%.*s", stp->st_word,
                    sug.su_badlen - stp->st_orglen,
                    sug.su_badptr + stp->st_orglen);
-      repl_to = vim_strsave(IObuff);
+      repl_to = xstrdup((char *)IObuff);
     } else {
       // Replacing su_badlen or more, use the whole word.
-      repl_from = (char_u *)xstrnsave((char *)sug.su_badptr, (size_t)stp->st_orglen);
-      repl_to = vim_strsave((char_u *)stp->st_word);
+      repl_from = xstrnsave((char *)sug.su_badptr, (size_t)stp->st_orglen);
+      repl_to = xstrdup(stp->st_word);
     }
 
     // Replace the word.
     p = xmalloc(STRLEN(line) - (size_t)stp->st_orglen + (size_t)stp->st_wordlen + 1);
-    c = (int)(sug.su_badptr - line);
+    c = (int)(sug.su_badptr - (char_u *)line);
     memmove(p, line, (size_t)c);
     STRCPY(p + c, stp->st_word);
     STRCAT(p, sug.su_badptr + stp->st_orglen);
@@ -678,7 +678,7 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   char_u buf[MAXPATHL];
   char *p;
   bool do_combine = false;
-  char_u *sps_copy;
+  char *sps_copy;
   static bool expr_busy = false;
   int c;
   langp_T *lp;
@@ -758,10 +758,10 @@ static void spell_find_suggest(char_u *badptr, int badlen, suginfo_T *su, int ma
   }
 
   // Make a copy of 'spellsuggest', because the expression may change it.
-  sps_copy = vim_strsave((char_u *)p_sps);
+  sps_copy = xstrdup(p_sps);
 
   // Loop over the items in 'spellsuggest'.
-  for (p = (char *)sps_copy; *p != NUL;) {
+  for (p = sps_copy; *p != NUL;) {
     copy_option_part(&p, (char *)buf, MAXPATHL, ",");
 
     if (STRNCMP(buf, "expr:", 5) == 0) {
@@ -2806,7 +2806,7 @@ static void add_sound_suggest(suginfo_T *su, char_u *goodword, int score, langp_
   }
 
   // Go over the list of good words that produce this soundfold word
-  nrline = ml_get_buf(slang->sl_sugbuf, (linenr_T)sfwordnr + 1, false);
+  nrline = (char_u *)ml_get_buf(slang->sl_sugbuf, (linenr_T)sfwordnr + 1, false);
   orgnr = 0;
   while (*nrline != NUL) {
     // The wordnr was stored in a minimal nr of bytes as an offset to the
diff --git a/src/nvim/statusline.c b/src/nvim/statusline.c
index 9b441ba0a9..5f686ef96f 100644
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -426,7 +426,7 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   int len;
   int fillchar;
   char buf[MAXPATHL];
-  char_u *stl;
+  char *stl;
   char *p;
   stl_hlrec_t *hltab;
   StlClickRecord *tabtab;
@@ -448,14 +448,14 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
   // setup environment for the task at hand
   if (wp == NULL) {
     // Use 'tabline'.  Always at the first line of the screen.
-    stl = (char_u *)p_tal;
+    stl = p_tal;
     row = 0;
     fillchar = ' ';
     attr = HL_ATTR(HLF_TPF);
     maxwidth = Columns;
     use_sandbox = was_set_insecurely(wp, "tabline", 0);
   } else if (draw_winbar) {
-    stl = (char_u *)((*wp->w_p_wbr != NUL) ? wp->w_p_wbr : p_wbr);
+    stl = ((*wp->w_p_wbr != NUL) ? wp->w_p_wbr : p_wbr);
     row = -1;  // row zero is first row of text
     col = 0;
     grid = &wp->w_grid;
@@ -491,19 +491,19 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
     }
 
     if (draw_ruler) {
-      stl = (char_u *)p_ruf;
+      stl = p_ruf;
       // advance past any leading group spec - implicit in ru_col
       if (*stl == '%') {
         if (*++stl == '-') {
           stl++;
         }
-        if (atoi((char *)stl)) {
+        if (atoi(stl)) {
           while (ascii_isdigit(*stl)) {
             stl++;
           }
         }
         if (*stl++ != '(') {
-          stl = (char_u *)p_ruf;
+          stl = p_ruf;
         }
       }
       col = ru_col - (Columns - maxwidth);
@@ -522,9 +522,9 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
       use_sandbox = was_set_insecurely(wp, "rulerformat", 0);
     } else {
       if (*wp->w_p_stl != NUL) {
-        stl = (char_u *)wp->w_p_stl;
+        stl = wp->w_p_stl;
       } else {
-        stl = (char_u *)p_stl;
+        stl = p_stl;
       }
       use_sandbox = was_set_insecurely(wp, "statusline", *wp->w_p_stl == NUL ? 0 : OPT_LOCAL);
     }
@@ -544,9 +544,9 @@ void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
 
   // Make a copy, because the statusline may include a function call that
   // might change the option value and free the memory.
-  stl = vim_strsave(stl);
+  stl = xstrdup(stl);
   width =
-    build_stl_str_hl(ewp, buf, sizeof(buf), (char *)stl, use_sandbox,
+    build_stl_str_hl(ewp, buf, sizeof(buf), stl, use_sandbox,
                      fillchar, maxwidth, &hltab, &tabtab);
   xfree(stl);
   ewp->w_p_crb = p_crb_save;
@@ -711,7 +711,7 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, int use_san
   }
 
   // Get line & check if empty (cursorpos will show "0-1").
-  const char *line_ptr = (char *)ml_get_buf(wp->w_buffer, lnum, false);
+  const char *line_ptr = ml_get_buf(wp->w_buffer, lnum, false);
   bool empty_line = (*line_ptr == NUL);
 
   // Get the byte value now, in case we need it below. This is more
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index d7a0472cbf..04f9311d7e 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -49,13 +49,6 @@
 #include "nvim/vim.h"
 #include "nvim/window.h"
 
-/// Copy "string" into newly allocated memory.
-char_u *vim_strsave(const char_u *string)
-  FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
-{
-  return (char_u *)xstrdup((char *)string);
-}
-
 /// Copy up to `len` bytes of `string` into newly allocated memory and
 /// terminate with a NUL. The allocated memory always has size `len + 1`, even
 /// when `string` is shorter.
@@ -292,11 +285,11 @@ char_u *vim_strsave_shellescape(const char_u *string, bool do_special, bool do_n
 char_u *vim_strsave_up(const char_u *string)
   FUNC_ATTR_NONNULL_RET FUNC_ATTR_MALLOC FUNC_ATTR_NONNULL_ALL
 {
-  char_u *p1;
+  char *p1;
 
-  p1 = vim_strsave(string);
-  vim_strup(p1);
-  return p1;
+  p1 = xstrdup((char *)string);
+  vim_strup((char_u *)p1);
+  return (char_u *)p1;
 }
 
 /// Like xstrnsave(), but make all characters uppercase.
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index fedd053e88..1daeebd7b9 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -2468,7 +2468,7 @@ static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_
           break;
         }
 
-        line = ml_get_buf(syn_buf, startpos->lnum, false);
+        line = (char_u *)ml_get_buf(syn_buf, startpos->lnum, false);
         int line_len = (int)STRLEN(line);
 
         // take care of an empty match or negative offset
@@ -2604,7 +2604,7 @@ static void syn_add_end_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *spp
   if (result->lnum > syn_buf->b_ml.ml_line_count) {
     col = 0;
   } else if (off != 0) {
-    base = ml_get_buf(syn_buf, result->lnum, false);
+    base = (char_u *)ml_get_buf(syn_buf, result->lnum, false);
     p = base + col;
     if (off > 0) {
       while (off-- > 0 && *p != NUL) {
@@ -2649,7 +2649,7 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
     col = (int)STRLEN(ml_get_buf(syn_buf, result->lnum, false));
   }
   if (off != 0) {
-    base = ml_get_buf(syn_buf, result->lnum, false);
+    base = (char_u *)ml_get_buf(syn_buf, result->lnum, false);
     p = base + col;
     if (off > 0) {
       while (off-- && *p != NUL) {
@@ -2668,7 +2668,7 @@ static void syn_add_start_off(lpos_T *result, regmmatch_T *regmatch, synpat_T *s
 /// Get current line in syntax buffer.
 static char *syn_getcurline(void)
 {
-  return (char *)ml_get_buf(syn_buf, current_lnum, false);
+  return ml_get_buf(syn_buf, current_lnum, false);
 }
 
 // Call vim_regexec() to find a match with "rmp" in "syn_buf".
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 04154384af..8be752239c 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -96,7 +96,7 @@ static char *mt_names[MT_COUNT/2] =
 { "FSC", "F C", "F  ", "FS ", " SC", "  C", "   ", " S " };
 
 #define NOTAGFILE       99              // return value for jumpto_tag
-static char_u *nofile_fname = NULL;   // fname for NOTAGFILE error
+static char *nofile_fname = NULL;       // fname for NOTAGFILE error
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "tag.c.generated.h"
@@ -109,7 +109,7 @@ static char_u *recurmsg
 static char_u *tfu_inv_ret_msg
   = (char_u *)N_("E987: invalid return value from tagfunc");
 
-static char_u *tagmatchname = NULL;   // name of last used tag
+static char *tagmatchname = NULL;   // name of last used tag
 
 // Tag for preview window is remembered separately, to avoid messing up the
 // normal tagstack.
@@ -142,7 +142,7 @@ static int tfu_in_use = false;  // disallow recursive call of tagfunc
 /// @param tag  tag (pattern) to jump to
 /// @param forceit  :ta with !
 /// @param verbose  print "tag not found" message
-bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
+bool do_tag(char *tag, int type, int count, int forceit, int verbose)
 {
   taggy_T *tagstack = curwin->w_tagstack;
   int tagstackidx = curwin->w_tagstackidx;
@@ -195,7 +195,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
   }
 
   prev_num_matches = num_matches;
-  free_string_option((char *)nofile_fname);
+  free_string_option(nofile_fname);
   nofile_fname = NULL;
 
   clearpos(&saved_fmark.mark);          // shutup gcc 4.0
@@ -208,7 +208,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
     new_tag = true;
     if (g_do_tagpreview != 0) {
       tagstack_clear_entry(&ptag_entry);
-      ptag_entry.tagname = (char *)vim_strsave(tag);
+      ptag_entry.tagname = xstrdup(tag);
     }
   } else {
     if (g_do_tagpreview != 0) {
@@ -232,7 +232,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
           cur_fnum = ptag_entry.cur_fnum;
         } else {
           tagstack_clear_entry(&ptag_entry);
-          ptag_entry.tagname = (char *)vim_strsave(tag);
+          ptag_entry.tagname = xstrdup(tag);
         }
       } else {
         // If the last used entry is not at the top, delete all tag
@@ -252,7 +252,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         }
 
         // put the tag name in the tag stack
-        tagstack[tagstackidx].tagname = (char *)vim_strsave(tag);
+        tagstack[tagstackidx].tagname = xstrdup(tag);
 
         curwin->w_tagstacklen = tagstacklen;
 
@@ -419,13 +419,13 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
   // Repeat searching for tags, when a file has not been found.
   for (;;) {
     int other_name;
-    char_u *name;
+    char *name;
 
     // When desired match not found yet, try to find it (and others).
     if (use_tagstack) {
-      name = (char_u *)tagstack[tagstackidx].tagname;
+      name = tagstack[tagstackidx].tagname;
     } else if (g_do_tagpreview != 0) {
-      name = (char_u *)ptag_entry.tagname;
+      name = ptag_entry.tagname;
     } else {
       name = tag;
     }
@@ -435,7 +435,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         || other_name) {
       if (other_name) {
         xfree(tagmatchname);
-        tagmatchname = vim_strsave(name);
+        tagmatchname = xstrdup(name);
       }
 
       if (type == DT_SELECT || type == DT_JUMP
@@ -466,7 +466,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         flags |= TAG_NO_TAGFUNC;
       }
 
-      if (find_tags((char *)name, &new_num_matches, &new_matches, flags,
+      if (find_tags(name, &new_num_matches, &new_matches, flags,
                     max_num_matches, (char *)buf_ffname) == OK
           && new_num_matches < max_num_matches) {
         max_num_matches = MAXCOL;  // If less than max_num_matches
@@ -522,7 +522,7 @@ bool do_tag(char_u *tag, int type, int count, int forceit, int verbose)
         print_tag_list(new_tag, use_tagstack, num_matches, matches);
         ask_for_selection = true;
       } else if (type == DT_LTAG) {
-        if (add_llist_tags(tag, num_matches, matches) == FAIL) {
+        if (add_llist_tags((char_u *)tag, num_matches, matches) == FAIL) {
           goto end_do_tag;
         }
 
@@ -1172,7 +1172,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
   taglist = rettv.vval.v_list;
 
   TV_LIST_ITER_CONST(taglist, li, {
-    char_u *res_name;
+    char *res_name;
     char_u *res_fname;
     char_u *res_cmd;
     char_u *res_kind;
@@ -1200,7 +1200,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
 
       len += strlen(tv->vval.v_string) + 1;   // Space for "\tVALUE"
       if (!STRCMP(dict_key, "name")) {
-        res_name = (char_u *)tv->vval.v_string;
+        res_name = tv->vval.v_string;
         continue;
       }
       if (!STRCMP(dict_key, "filename")) {
@@ -1230,10 +1230,10 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
       break;
     }
 
-    char_u *const mfp = name_only ? vim_strsave(res_name) : xmalloc(len + 2);
+    char *const mfp = name_only ? xstrdup(res_name) : xmalloc(len + 2);
 
     if (!name_only) {
-      char_u *p = mfp;
+      char_u *p = (char_u *)mfp;
 
       *p++ = MT_GL_OTH + 1;   // mtt
       *p++ = TAG_SEP;     // no tag file name
@@ -2242,13 +2242,13 @@ static garray_T tag_fnames = GA_EMPTY_INIT_VALUE;
 // 'runtimepath' doc directories.
 static void found_tagfile_cb(char *fname, void *cookie)
 {
-  char_u *const tag_fname = vim_strsave((char_u *)fname);
+  char *const tag_fname = xstrdup(fname);
 
 #ifdef BACKSLASH_IN_FILENAME
   slash_adjust(tag_fname);
 #endif
-  simplify_filename(tag_fname);
-  GA_APPEND(char_u *, &tag_fnames, tag_fname);
+  simplify_filename((char_u *)tag_fname);
+  GA_APPEND(char *, &tag_fnames, tag_fname);
 }
 
 #if defined(EXITFREE)
@@ -2319,8 +2319,8 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
   if (first) {
     // Init.  We make a copy of 'tags', because autocommands may change
     // the value without notifying us.
-    tnp->tn_tags = vim_strsave((*curbuf->b_p_tags != NUL) ? (char_u *)curbuf->b_p_tags : p_tags);
-    tnp->tn_np = (char *)tnp->tn_tags;
+    tnp->tn_tags = xstrdup((*curbuf->b_p_tags != NUL) ? curbuf->b_p_tags : (char *)p_tags);
+    tnp->tn_np = tnp->tn_tags;
   }
 
   // Loop until we have found a file name that can be used.
@@ -2550,7 +2550,8 @@ static char_u *tag_full_fname(tagptrs_T *tagp)
 {
   int c = *tagp->fname_end;
   *tagp->fname_end = NUL;
-  char_u *fullname = expand_tag_fname(tagp->fname, tagp->tag_fname, false);
+  char_u *fullname =
+    (char_u *)expand_tag_fname((char *)tagp->fname, (char *)tagp->tag_fname, false);
   *tagp->fname_end = (char_u)c;
 
   return fullname;
@@ -2573,7 +2574,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   char_u *pbuf;                    // search pattern buffer
   char_u *pbuf_end;
   char_u *tofree_fname = NULL;
-  char_u *fname;
+  char *fname;
   tagptrs_T tagp;
   int retval = FAIL;
   int getfile_result = GETFILE_UNUSED;
@@ -2596,7 +2597,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
 
   // truncate the file name, so it can be used as a string
   *tagp.fname_end = NUL;
-  fname = tagp.fname;
+  fname = (char *)tagp.fname;
 
   // copy the command to pbuf[], remove trailing CR/NL
   str = tagp.command;
@@ -2619,18 +2620,17 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
 
   // Expand file name, when needed (for environment variables).
   // If 'tagrelative' option set, may change file name.
-  fname = expand_tag_fname(fname, tagp.tag_fname, true);
-  tofree_fname = fname;         // free() it later
+  fname = expand_tag_fname(fname, (char *)tagp.tag_fname, true);
+  tofree_fname = (char_u *)fname;         // free() it later
 
   // Check if the file with the tag exists before abandoning the current
   // file.  Also accept a file name for which there is a matching BufReadCmd
   // autocommand event (e.g., http://sys/file).
-  if (!os_path_exists((char *)fname)
-      && !has_autocmd(EVENT_BUFREADCMD, (char *)fname,
-                      NULL)) {
+  if (!os_path_exists(fname)
+      && !has_autocmd(EVENT_BUFREADCMD, fname, NULL)) {
     retval = NOTAGFILE;
     xfree(nofile_fname);
-    nofile_fname = vim_strsave(fname);
+    nofile_fname = xstrdup(fname);
     goto erret;
   }
 
@@ -2644,8 +2644,8 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
     // entering it (autocommands) so turn the tag filename
     // into a fullpath
     if (!curwin->w_p_pvw) {
-      full_fname = (char_u *)FullName_save((char *)fname, false);
-      fname = full_fname;
+      full_fname = (char_u *)FullName_save(fname, false);
+      fname = (char *)full_fname;
 
       // Make the preview window the current window.
       // Open a preview window when needed.
@@ -2656,7 +2656,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   // If it was a CTRL-W CTRL-] command split window now.  For ":tab tag"
   // open a new tab page.
   if (postponed_split && (swb_flags & (SWB_USEOPEN | SWB_USETAB))) {
-    buf_T *const existing_buf = buflist_findname_exp((char *)fname);
+    buf_T *const existing_buf = buflist_findname_exp(fname);
 
     if (existing_buf != NULL) {
       const win_T *wp = NULL;
@@ -2701,7 +2701,7 @@ static int jumpto_tag(const char_u *lbuf_arg, int forceit, int keep_help)
   if (getfile_result == GETFILE_UNUSED) {
     // Careful: getfile() may trigger autocommands and call jumpto_tag()
     // recursively.
-    getfile_result = getfile(0, (char *)fname, NULL, true, (linenr_T)0, forceit);
+    getfile_result = getfile(0, fname, NULL, true, (linenr_T)0, forceit);
   }
   keep_help_flag = false;
 
@@ -2867,18 +2867,19 @@ erret:
   return retval;
 }
 
-// If "expand" is true, expand wildcards in fname.
-// If 'tagrelative' option set, change fname (name of file containing tag)
-// according to tag_fname (name of tag file containing fname).
-// Returns a pointer to allocated memory.
-static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bool expand)
+/// If "expand" is true, expand wildcards in fname.
+/// If 'tagrelative' option set, change fname (name of file containing tag)
+/// according to tag_fname (name of tag file containing fname).
+///
+/// @return  a pointer to allocated memory.
+static char *expand_tag_fname(char *fname, char *const tag_fname, const bool expand)
 {
-  char_u *p;
-  char_u *expanded_fname = NULL;
+  char *p;
+  char *expanded_fname = NULL;
   expand_T xpc;
 
   // Expand file name (for environment variables) when needed.
-  if (expand && path_has_wildcard((char *)fname)) {
+  if (expand && path_has_wildcard(fname)) {
     ExpandInit(&xpc);
     xpc.xp_context = EXPAND_FILES;
     expanded_fname = ExpandOne(&xpc, fname, NULL,
@@ -2888,18 +2889,18 @@ static char_u *expand_tag_fname(char_u *fname, char_u *const tag_fname, const bo
     }
   }
 
-  char_u *retval;
+  char *retval;
   if ((p_tr || curbuf->b_help)
-      && !vim_isAbsName(fname)
-      && (p = (char_u *)path_tail((char *)tag_fname)) != tag_fname) {
+      && !vim_isAbsName((char_u *)fname)
+      && (p = path_tail(tag_fname)) != tag_fname) {
     retval = xmalloc(MAXPATHL);
     STRCPY(retval, tag_fname);
     STRLCPY(retval + (p - tag_fname), fname,
             MAXPATHL - (p - tag_fname));
     // Translate names like "src/a/../b/file.c" into "src/b/file.c".
-    simplify_filename(retval);
+    simplify_filename((char_u *)retval);
   } else {
-    retval = vim_strsave(fname);
+    retval = xstrdup(fname);
   }
 
   xfree(expanded_fname);
@@ -2922,7 +2923,7 @@ static int test_for_current(char *fname, char *fname_end, char *tag_fname, char
       c = (unsigned char)(*fname_end);
       *fname_end = NUL;
     }
-    char *fullname = (char *)expand_tag_fname((char_u *)fname, (char_u *)tag_fname, true);
+    char *fullname = expand_tag_fname(fname, tag_fname, true);
     retval = (path_full_compare(fullname, buf_ffname, true, true) & kEqualFiles);
     xfree(fullname);
     *fname_end = (char)c;
diff --git a/src/nvim/tag.h b/src/nvim/tag.h
index 0b4039afb6..7f2ef8d6d7 100644
--- a/src/nvim/tag.h
+++ b/src/nvim/tag.h
@@ -34,7 +34,7 @@
 
 // Structure used for get_tagfname().
 typedef struct {
-  char_u *tn_tags;         // value of 'tags' when starting
+  char *tn_tags;           // value of 'tags' when starting
   char *tn_np;             // current position in tn_tags
   int tn_did_filefind_init;
   int tn_hf_idx;
diff --git a/src/nvim/textformat.c b/src/nvim/textformat.c
index 6e69fb95c8..5c53f84700 100644
--- a/src/nvim/textformat.c
+++ b/src/nvim/textformat.c
@@ -97,7 +97,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
     colnr_T len;
     colnr_T virtcol;
     int orig_col = 0;
-    char_u *saved_text = NULL;
+    char *saved_text = NULL;
     colnr_T col;
     colnr_T end_col;
     bool did_do_comment = false;
@@ -353,7 +353,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
     if (State & VREPLACE_FLAG) {
       // In MODE_VREPLACE state, we will backspace over the text to be
       // wrapped, so save a copy now to put on the next line.
-      saved_text = vim_strsave(get_cursor_pos_ptr());
+      saved_text = xstrdup(get_cursor_pos_ptr());
       curwin->w_cursor.col = orig_col;
       saved_text[startcol] = NUL;
 
@@ -425,7 +425,7 @@ void internal_format(int textwidth, int second_indent, int flags, bool format_on
     if (State & VREPLACE_FLAG) {
       // In MODE_VREPLACE state we have backspaced over the text to be
       // moved, now we re-insert it into the new line.
-      ins_bytes((char *)saved_text);
+      ins_bytes(saved_text);
       xfree(saved_text);
     } else {
       // Check if cursor is not past the NUL off the line, cindent
@@ -508,13 +508,13 @@ static bool ends_in_white(linenr_T lnum)
 /// @param lnum  The first line.  White-space is ignored.
 ///
 /// @note the whole of 'leader1' must match 'leader2_len' characters from 'leader2'.
-static bool same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, int leader2_len,
-                        char_u *leader2_flags)
+static bool same_leader(linenr_T lnum, int leader1_len, char *leader1_flags, int leader2_len,
+                        char *leader2_flags)
 {
   int idx1 = 0, idx2 = 0;
-  char_u *p;
-  char_u *line1;
-  char_u *line2;
+  char *p;
+  char *line1;
+  char *line2;
 
   if (leader1_len == 0) {
     return leader2_len == 0;
@@ -552,9 +552,9 @@ static bool same_leader(linenr_T lnum, int leader1_len, char_u *leader1_flags, i
 
   // Get current line and next line, compare the leaders.
   // The first line has to be saved, only one line can be locked at a time.
-  line1 = vim_strsave((char_u *)ml_get(lnum));
+  line1 = xstrdup(ml_get(lnum));
   for (idx1 = 0; ascii_iswhite(line1[idx1]); idx1++) {}
-  line2 = (char_u *)ml_get(lnum + 1);
+  line2 = ml_get(lnum + 1);
   for (idx2 = 0; idx2 < leader2_len; idx2++) {
     if (!ascii_iswhite(line2[idx2])) {
       if (line1[idx1++] != line2[idx2]) {
@@ -605,8 +605,8 @@ static bool paragraph_start(linenr_T lnum)
   if (has_format_option(FO_Q_NUMBER) && (get_number_indent(lnum) > 0)) {
     return true;                // numbered item starts in "lnum".
   }
-  if (!same_leader(lnum - 1, leader_len, leader_flags,
-                   next_leader_len, next_leader_flags)) {
+  if (!same_leader(lnum - 1, leader_len, (char *)leader_flags,
+                   next_leader_len, (char *)next_leader_flags)) {
     return true;                // change of comment leader.
   }
   return false;
@@ -1018,9 +1018,9 @@ void format_lines(linenr_T line_count, bool avoid_fex)
       // When the comment leader changes, it's the end of the paragraph.
       if (curwin->w_cursor.lnum >= curbuf->b_ml.ml_line_count
           || !same_leader(curwin->w_cursor.lnum,
-                          leader_len, leader_flags,
+                          leader_len, (char *)leader_flags,
                           next_leader_len,
-                          next_leader_flags)) {
+                          (char *)next_leader_flags)) {
         // Special case: If the next line starts with a line comment
         // and this line has a line comment after some text, the
         // paragraph doesn't really end.
diff --git a/src/nvim/textobject.c b/src/nvim/textobject.c
index 6863b40599..621efa44cf 100644
--- a/src/nvim/textobject.c
+++ b/src/nvim/textobject.c
@@ -1157,7 +1157,7 @@ again:
 
   // Search for matching "</aaa>".  First isolate the "aaa".
   inc_cursor();
-  p = get_cursor_pos_ptr();
+  p = (char_u *)get_cursor_pos_ptr();
   for (cp = p;
        *cp != NUL && *cp != '>' && !ascii_iswhite(*cp);
        MB_PTR_ADV(cp)) {}
@@ -1196,7 +1196,7 @@ again:
       }
     }
   } else {
-    char_u *c = get_cursor_pos_ptr();
+    char_u *c = (char_u *)get_cursor_pos_ptr();
     // Exclude the '<' of the end tag.
     // If the closing tag is on new line, do not decrement cursor, but make
     // operation exclusive, so that the linefeed will be selected
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 5f086df4e9..ab14f4d4ea 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -567,7 +567,7 @@ int u_savecommon(buf_T *buf, linenr_T top, linenr_T bot, linenr_T newbot, int re
         u_freeentry(uep, i);
         return FAIL;
       }
-      uep->ue_array[i] = u_save_line_buf(buf, lnum++);
+      uep->ue_array[i] = (char_u *)u_save_line_buf(buf, lnum++);
     }
   } else {
     uep->ue_array = NULL;
@@ -621,7 +621,7 @@ void u_compute_hash(buf_T *buf, char_u *hash)
   context_sha256_T ctx;
   sha256_start(&ctx);
   for (linenr_T lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
-    char_u *p = ml_get_buf(buf, lnum, false);
+    char_u *p = (char_u *)ml_get_buf(buf, lnum, false);
     sha256_update(&ctx, p, (uint32_t)(STRLEN(p) + 1));
   }
   sha256_finish(&ctx, hash);
@@ -2643,7 +2643,7 @@ void ex_undolist(exarg_T *eap)
         }
         vim_snprintf_add((char *)IObuff, IOSIZE, "  %3ld", uhp->uh_save_nr);
       }
-      GA_APPEND(char_u *, &ga, vim_strsave(IObuff));
+      GA_APPEND(char *, &ga, xstrdup((char *)IObuff));
     }
 
     uhp->uh_walk = mark;
@@ -3027,16 +3027,16 @@ void u_blockfree(buf_T *buf)
 /// @param lnum the line to copy
 static char_u *u_save_line(linenr_T lnum)
 {
-  return u_save_line_buf(curbuf, lnum);
+  return (char_u *)u_save_line_buf(curbuf, lnum);
 }
 
 /// Allocate memory and copy line into it
 ///
 /// @param lnum line to copy
 /// @param buf buffer to copy from
-static char_u *u_save_line_buf(buf_T *buf, linenr_T lnum)
+static char *u_save_line_buf(buf_T *buf, linenr_T lnum)
 {
-  return vim_strsave(ml_get_buf(buf, lnum, false));
+  return xstrdup(ml_get_buf(buf, lnum, false));
 }
 
 /// Check if the 'modified' flag is set, or 'ff' has changed (only need to
-- 
cgit 


From 2aeb8d976f0be298e23fca90463d2ff2c348ebf7 Mon Sep 17 00:00:00 2001
From: Andreas Schneider <asn@cryptomilk.org>
Date: Sat, 1 Jan 2022 07:28:55 +0100
Subject: feat(term): add support for libvterm >= 0.2

Signed-off-by: Andreas Schneider <asn@cryptomilk.org>
---
 src/nvim/terminal.c | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

(limited to 'src')

diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 125e4cb586..744579217b 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -120,6 +120,10 @@ struct terminal {
   // window height has increased) and must be deleted from the terminal buffer
   int sb_pending;
 
+  char *title;     // VTermStringFragment buffer
+  size_t title_len;    // number of rows pushed to sb_buffer
+  size_t title_size;   // sb_buffer size
+
   // buf_T instance that acts as a "drawing surface" for libvterm
   // we can't store a direct reference to the buffer because the
   // refresh_timer_cb may be called after the buffer was freed, and there's
@@ -636,6 +640,7 @@ void terminal_destroy(Terminal **termpp)
       xfree(term->sb_buffer[i]);
     }
     xfree(term->sb_buffer);
+    xfree(term->title);
     vterm_free(term->vt);
     xfree(term);
     *termpp = NULL;  // coverity[dead-store]
@@ -887,7 +892,34 @@ static int term_settermprop(VTermProp prop, VTermValue *val, void *data)
 
   case VTERM_PROP_TITLE: {
     buf_T *buf = handle_get_buffer(term->buf_handle);
+#if VTERM_VERSION_MAJOR > 0 || (VTERM_VERSION_MAJOR == 0 && VTERM_VERSION_MINOR >= 2)
+    VTermStringFragment frag = val->string;
+
+    if (frag.initial && frag.final) {
+      buf_set_term_title(buf, frag.str, frag.len);
+      break;
+    }
+
+    if (frag.initial) {
+      term->title_len = 0;
+      term->title_size = MAX(frag.len, 1024);
+      term->title = xmalloc(sizeof(char *) * term->title_size);
+    } else if (term->title_len + frag.len > term->title_size) {
+      term->title_size *= 2;
+      term->title = xrealloc(term->title, sizeof(char *) * term->title_size);
+    }
+
+    memcpy(term->title + term->title_len, frag.str, frag.len);
+    term->title_len += frag.len;
+
+    if (frag.final) {
+      buf_set_term_title(buf, term->title, term->title_len);
+      xfree(term->title);
+      term->title = NULL;
+    }
+#else
     buf_set_term_title(buf, val->string, strlen(val->string));
+#endif
     break;
   }
 
-- 
cgit 


From db9b8b08e74ae8cfb08960eca0a7273538ebcdf1 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Tue, 6 Sep 2022 22:23:54 +0200
Subject: refactor(typval): change FC_CFUNC abstraction into FC_LUAREF

"cfuncs" was only ever used to wrap luarefs. As vim8script is
finished and will not be developed further, support for "cfuncs"
for other usecases are not planned. This abstraction was immediately
broken anyway in order to get luarefs out of userfuncs again.

Even if a new kind of userfunc needs to be invented in the future,
likely just extending the FC_... flag union directy, instead of
invoking unnecessary heap object and c function pointer indirection,
will be a more straightforward design pattern.
---
 src/nvim/api/private/converter.c |  9 +++------
 src/nvim/eval/typval.h           | 11 +----------
 src/nvim/eval/userfunc.c         | 35 +++++++++--------------------------
 src/nvim/eval/userfunc.h         | 14 ++++++++++++++
 src/nvim/lua/converter.c         | 11 ++++-------
 src/nvim/lua/converter.h         |  8 --------
 src/nvim/lua/executor.c          | 33 +++++----------------------------
 7 files changed, 36 insertions(+), 85 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/private/converter.c b/src/nvim/api/private/converter.c
index 8724ef4432..b6b3c83f3c 100644
--- a/src/nvim/api/private/converter.c
+++ b/src/nvim/api/private/converter.c
@@ -65,8 +65,8 @@ typedef struct {
 #define TYPVAL_ENCODE_CONV_FUNC_START(tv, fun) \
   do { \
     ufunc_T *fp = find_func(fun); \
-    if (fp != NULL && fp->uf_cb == nlua_CFunction_func_call) { \
-      LuaRef ref = api_new_luaref(((LuaCFunctionState *)fp->uf_cb_state)->lua_callable.func_ref); \
+    if (fp != NULL && (fp->uf_flags & FC_LUAREF)) { \
+      LuaRef ref = api_new_luaref(fp->uf_luaref); \
       kvi_push(edata->stack, LUAREF_OBJ(ref)); \
     } else { \
       TYPVAL_ENCODE_CONV_NIL(tv); \
@@ -351,10 +351,7 @@ bool object_to_vim(Object obj, typval_T *tv, Error *err)
   }
 
   case kObjectTypeLuaRef: {
-    LuaCFunctionState *state = xmalloc(sizeof(LuaCFunctionState));
-    state->lua_callable.func_ref = api_new_luaref(obj.data.luaref);
-    char *name =
-      (char *)register_cfunc(&nlua_CFunction_func_call, &nlua_CFunction_func_free, state);
+    char *name = (char *)register_luafunc(api_new_luaref(obj.data.luaref));
     tv->v_type = VAR_FUNC;
     tv->vval.v_string = xstrdup(name);
     break;
diff --git a/src/nvim/eval/typval.h b/src/nvim/eval/typval.h
index cf7b04c8ce..6373ead1a3 100644
--- a/src/nvim/eval/typval.h
+++ b/src/nvim/eval/typval.h
@@ -286,12 +286,6 @@ typedef struct {
 /// Number of fixed variables used for arguments
 #define FIXVAR_CNT 12
 
-/// Callback interface for C function reference>
-///     Used for managing functions that were registered with |register_cfunc|
-typedef int (*cfunc_T)(int argcount, typval_T *argvars, typval_T *rettv, void *state);  // NOLINT
-/// Callback to clear cfunc_T and any associated state.
-typedef void (*cfunc_free_T)(void *state);
-
 // Structure to hold info for a function that is currently being executed.
 typedef struct funccall_S funccall_T;
 
@@ -330,10 +324,7 @@ struct ufunc {
   garray_T uf_lines;         ///< function lines
   int uf_profiling;     ///< true when func is being profiled
   int uf_prof_initialized;
-  // Managing cfuncs
-  cfunc_T uf_cb;            ///< C function extension callback
-  cfunc_free_T uf_cb_free;       ///< C function extension free callback
-  void *uf_cb_state;      ///< State of C function extension.
+  LuaRef uf_luaref;      ///< lua callback, used if (uf_flags & FC_LUAREF)
   // Profiling the function as a whole.
   int uf_tm_count;      ///< nr of calls
   proftime_T uf_tm_total;      ///< time spent in function + children
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index 36bc51179c..a899e1579b 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -28,20 +28,6 @@
 #include "nvim/ui.h"
 #include "nvim/vim.h"
 
-// flags used in uf_flags
-#define FC_ABORT    0x01          // abort function on error
-#define FC_RANGE    0x02          // function accepts range
-#define FC_DICT     0x04          // Dict function, uses "self"
-#define FC_CLOSURE  0x08          // closure, uses outer scope variables
-#define FC_DELETED  0x10          // :delfunction used while uf_refcount > 0
-#define FC_REMOVED  0x20          // function redefined while uf_refcount > 0
-#define FC_SANDBOX  0x40          // function defined in the sandbox
-#define FC_DEAD     0x80          // function kept only for reference to dfunc
-#define FC_EXPORT   0x100         // "export def Func()"
-#define FC_NOARGS   0x200         // no a: variables in lambda
-#define FC_VIM9     0x400         // defined in vim9 script file
-#define FC_CFUNC    0x800         // C function extension
-
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "eval/userfunc.c.generated.h"
 #endif
@@ -758,9 +744,9 @@ static void func_clear_items(ufunc_T *fp)
   ga_clear_strings(&(fp->uf_lines));
   XFREE_CLEAR(fp->uf_name_exp);
 
-  if (fp->uf_cb_free != NULL) {
-    fp->uf_cb_free(fp->uf_cb_state);
-    fp->uf_cb_free = NULL;
+  if (fp->uf_flags & FC_LUAREF) {
+    api_free_luaref(fp->uf_luaref);
+    fp->uf_luaref = LUA_NOREF;
   }
 
   XFREE_CLEAR(fp->uf_tml_count);
@@ -1538,9 +1524,8 @@ int call_func(const char *funcname, int len, typval_T *rettv, int argcount_in, t
 
       if (fp != NULL && (fp->uf_flags & FC_DELETED)) {
         error = ERROR_DELETED;
-      } else if (fp != NULL && (fp->uf_flags & FC_CFUNC)) {
-        cfunc_T cb = fp->uf_cb;
-        error = (*cb)(argcount, argvars, rettv, fp->uf_cb_state);
+      } else if (fp != NULL && (fp->uf_flags & FC_LUAREF)) {
+        error = typval_exec_lua_callable(fp->uf_luaref, argcount, argvars, rettv);
       } else if (fp != NULL) {
         if (funcexe->argv_func != NULL) {
           // postponed filling in the arguments, do it now
@@ -3552,20 +3537,18 @@ bool set_ref_in_func(char_u *name, ufunc_T *fp_in, int copyID)
   return abort;
 }
 
-/// Registers a C extension user function.
-char_u *register_cfunc(cfunc_T cb, cfunc_free_T cb_free, void *state)
+/// Registers a luaref as a lambda.
+char_u *register_luafunc(LuaRef ref)
 {
   char_u *name = get_lambda_name();
   ufunc_T *fp = xcalloc(1, offsetof(ufunc_T, uf_name) + STRLEN(name) + 1);
 
   fp->uf_refcount = 1;
   fp->uf_varargs = true;
-  fp->uf_flags = FC_CFUNC;
+  fp->uf_flags = FC_LUAREF;
   fp->uf_calls = 0;
   fp->uf_script_ctx = current_sctx;
-  fp->uf_cb = cb;
-  fp->uf_cb_free = cb_free;
-  fp->uf_cb_state = state;
+  fp->uf_luaref = ref;
 
   STRCPY(fp->uf_name, name);
   hash_add(&func_hashtab, UF2HIKEY(fp));
diff --git a/src/nvim/eval/userfunc.h b/src/nvim/eval/userfunc.h
index 4b7007aae9..9811f2afb3 100644
--- a/src/nvim/eval/userfunc.h
+++ b/src/nvim/eval/userfunc.h
@@ -9,6 +9,20 @@
 #define HIKEY2UF(p)  ((ufunc_T *)(p - offsetof(ufunc_T, uf_name)))
 #define HI2UF(hi)    HIKEY2UF((hi)->hi_key)
 
+// flags used in uf_flags
+#define FC_ABORT    0x01          // abort function on error
+#define FC_RANGE    0x02          // function accepts range
+#define FC_DICT     0x04          // Dict function, uses "self"
+#define FC_CLOSURE  0x08          // closure, uses outer scope variables
+#define FC_DELETED  0x10          // :delfunction used while uf_refcount > 0
+#define FC_REMOVED  0x20          // function redefined while uf_refcount > 0
+#define FC_SANDBOX  0x40          // function defined in the sandbox
+#define FC_DEAD     0x80          // function kept only for reference to dfunc
+#define FC_EXPORT   0x100         // "export def Func()"
+#define FC_NOARGS   0x200         // no a: variables in lambda
+#define FC_VIM9     0x400         // defined in vim9 script file
+#define FC_LUAREF  0x800          // luaref callback
+
 ///< Structure used by trans_function_name()
 typedef struct {
   dict_T *fd_dict;  ///< Dictionary used.
diff --git a/src/nvim/lua/converter.c b/src/nvim/lua/converter.c
index 21dd5139d7..735a75a6f1 100644
--- a/src/nvim/lua/converter.c
+++ b/src/nvim/lua/converter.c
@@ -385,12 +385,9 @@ nlua_pop_typval_table_processing_end:
       break;
     }
     case LUA_TFUNCTION: {
-      LuaCFunctionState *state = xmalloc(sizeof(LuaCFunctionState));
-      state->lua_callable.func_ref = nlua_ref_global(lstate, -1);
+      LuaRef func = nlua_ref_global(lstate, -1);
 
-      char *name = (char *)register_cfunc(&nlua_CFunction_func_call,
-                                          &nlua_CFunction_func_free,
-                                          state);
+      char *name = (char *)register_luafunc(func);
 
       cur.tv->v_type = VAR_FUNC;
       cur.tv->vval.v_string = xstrdup(name);
@@ -476,8 +473,8 @@ static bool typval_conv_special = false;
 #define TYPVAL_ENCODE_CONV_FUNC_START(tv, fun) \
   do { \
     ufunc_T *fp = find_func(fun); \
-    if (fp != NULL && fp->uf_cb == nlua_CFunction_func_call) { \
-      nlua_pushref(lstate, ((LuaCFunctionState *)fp->uf_cb_state)->lua_callable.func_ref); \
+    if (fp != NULL && fp->uf_flags & FC_LUAREF) { \
+      nlua_pushref(lstate, fp->uf_luaref); \
     } else { \
       TYPVAL_ENCODE_CONV_NIL(tv); \
     } \
diff --git a/src/nvim/lua/converter.h b/src/nvim/lua/converter.h
index f6a85900ba..ddc0acfbfa 100644
--- a/src/nvim/lua/converter.h
+++ b/src/nvim/lua/converter.h
@@ -9,14 +9,6 @@
 #include "nvim/eval/typval.h"
 #include "nvim/func_attr.h"
 
-typedef struct {
-  LuaRef func_ref;
-} LuaCallable;
-
-typedef struct {
-  LuaCallable lua_callable;
-} LuaCFunctionState;
-
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "lua/converter.h.generated.h"
 #endif
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 1013cf76f9..857e2111d6 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1425,12 +1425,11 @@ int nlua_source_using_linegetter(LineGetter fgetline, void *cookie, char *name)
 /// @param[in]  argcount Count of typval arguments
 /// @param[in]  argvars Typval Arguments
 /// @param[out] rettv The return value from the called function.
-int typval_exec_lua_callable(lua_State *lstate, LuaCallable lua_cb, int argcount, typval_T *argvars,
-                             typval_T *rettv)
+int typval_exec_lua_callable(LuaRef lua_cb, int argcount, typval_T *argvars, typval_T *rettv)
 {
-  LuaRef cb = lua_cb.func_ref;
+  lua_State *lstate = global_lstate;
 
-  nlua_pushref(lstate, cb);
+  nlua_pushref(lstate, lua_cb);
 
   PUSH_ALL_TYPVALS(lstate, argvars, argcount, false);
 
@@ -1833,26 +1832,6 @@ static int nlua_is_thread(lua_State *lstate)
   return 1;
 }
 
-// Required functions for lua c functions as VimL callbacks
-
-int nlua_CFunction_func_call(int argcount, typval_T *argvars, typval_T *rettv, void *state)
-{
-  lua_State *const lstate = global_lstate;
-  LuaCFunctionState *funcstate = (LuaCFunctionState *)state;
-
-  return typval_exec_lua_callable(lstate, funcstate->lua_callable,
-                                  argcount, argvars, rettv);
-}
-
-void nlua_CFunction_func_free(void *state)
-{
-  lua_State *const lstate = global_lstate;
-  LuaCFunctionState *funcstate = (LuaCFunctionState *)state;
-
-  nlua_unref_global(lstate, funcstate->lua_callable.func_ref);
-  xfree(funcstate);
-}
-
 bool nlua_is_table_from_lua(typval_T *const arg)
 {
   if (arg->v_type == VAR_DICT) {
@@ -1898,11 +1877,9 @@ char_u *nlua_register_table_as_callable(typval_T *const arg)
   }
   lua_pop(lstate, 2);  // [table]
 
-  LuaCFunctionState *state = xmalloc(sizeof(LuaCFunctionState));
-  state->lua_callable.func_ref = nlua_ref_global(lstate, -1);
+  LuaRef func = nlua_ref_global(lstate, -1);
 
-  char_u *name = register_cfunc(&nlua_CFunction_func_call,
-                                &nlua_CFunction_func_free, state);
+  char_u *name = register_luafunc(func);
 
   lua_pop(lstate, 1);  // []
   assert(top == lua_gettop(lstate));
-- 
cgit 


From 9d1d3a67073ab04f29a1e437e90faede764a4313 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Wed, 7 Sep 2022 15:55:39 +0200
Subject: vim-patch:9.0.0402: javascript module files are not recoginzed
 (#20108)

Problem:    Javascript module files are not recoginzed.
Solution:   Recognize "*.jsm" files as Javascript. (Brett Holman,
            closes vim/vim#11069)
https://github.com/vim/vim/commit/bb6c4073e79e86ef69c315338e00c12f0d8d6395
---
 src/nvim/testdir/test_filetype.vim | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 4f5ae830b7..703d420847 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -275,7 +275,7 @@ let s:filename_checks = {
     \ 'jam': ['file.jpl', 'file.jpr', 'JAM-file.file', 'JAM.file', 'Prl-file.file', 'Prl.file'],
     \ 'java': ['file.java', 'file.jav'],
     \ 'javacc': ['file.jj', 'file.jjt'],
-    \ 'javascript': ['file.js', 'file.javascript', 'file.es', 'file.mjs', 'file.cjs'],
+    \ 'javascript': ['file.js', 'file.jsm', 'file.javascript', 'file.es', 'file.mjs', 'file.cjs'],
     \ 'javascript.glimmer': ['file.gjs'],
     \ 'javascriptreact': ['file.jsx'],
     \ 'jess': ['file.clp'],
-- 
cgit 


From 4dc4cf346755375e49410e16635c00a602b26c36 Mon Sep 17 00:00:00 2001
From: ii14 <59243201+ii14@users.noreply.github.com>
Date: Wed, 7 Sep 2022 17:59:27 +0200
Subject: fix(options): mark `winhighlight` as list style  (#19477)

Also add missing fcs, lcs and winhighlight to list of key-value options for `vim.opt`.

Co-authored-by: ii14 <ii14@users.noreply.github.com>
---
 src/nvim/options.lua | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src')

diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 49adf03aa0..1d9a821e20 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -2868,7 +2868,8 @@ return {
     {
       full_name='winhighlight', abbreviation='winhl',
       short_desc=N_("Setup window-local highlights");
-      type='string', scope={'window'},
+      type='string', list='onecomma', scope={'window'},
+      deny_duplicates=true,
       alloced=true,
       redraw={'current_window'},
       defaults={if_true=""}
-- 
cgit 


From ead524656dc1664622f80509a983519a190ca48a Mon Sep 17 00:00:00 2001
From: luukvbaal <31730729+luukvbaal@users.noreply.github.com>
Date: Wed, 7 Sep 2022 18:08:00 +0200
Subject: vim-patch:9.0.0403: 'equalalways' may be off when 'laststatus' is
 zero (#20109)

Problem:    'equalalways' may be off when 'laststatus' is zero.
Solution:   call last_status() before win_equal(). (Luuk van Baal,
            closes https://github.com/vim/vim/pull/11070)
https://github.com/vim/vim/commit/fd7e60a33ddd83a82da4eb6267f1c12fa926f32b
---
 src/nvim/testdir/test_window_cmd.vim | 15 +++++++++++++++
 src/nvim/window.c                    |  9 +++++----
 2 files changed, 20 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_window_cmd.vim b/src/nvim/testdir/test_window_cmd.vim
index 1f4b9b77c6..1f9d6b59b7 100644
--- a/src/nvim/testdir/test_window_cmd.vim
+++ b/src/nvim/testdir/test_window_cmd.vim
@@ -1464,4 +1464,19 @@ func Test_win_move_statusline()
   %bwipe!
 endfunc
 
+func Test_win_equal_last_status()
+  let save_lines = &lines
+  set lines=20
+  set splitbelow
+  set laststatus=0
+
+  split | split | quit
+  call assert_equal(winheight(1), winheight(2))
+
+  let &lines = save_lines
+  set splitbelow&
+  set laststatus&
+endfunc
+
+
 " vim: shiftwidth=2 sts=2 expandtab
diff --git a/src/nvim/window.c b/src/nvim/window.c
index a6cc53080b..63a6eb9fb6 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -2849,6 +2849,11 @@ int win_close(win_T *win, bool free_buf, bool force)
     check_cursor();
   }
 
+  // If last window has a status line now and we don't want one,
+  // remove the status line. Do this before win_equal(), because
+  // it may change the height of a window.
+  last_status(false);
+
   if (!was_floating) {
     if (!curwin->w_floating && p_ea && (*p_ead == 'b' || *p_ead == dir)) {
       // If the frame of the closed window contains the new current window,
@@ -2870,10 +2875,6 @@ int win_close(win_T *win, bool free_buf, bool force)
 
   split_disallowed--;
 
-  // If last window has a status line now and we don't want one,
-  // remove the status line.
-  last_status(false);
-
   // After closing the help window, try restoring the window layout from
   // before it was opened.
   if (help_window) {
-- 
cgit 


From 93a0c2dd63e369528664037b118ff9b9b38a20d4 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 8 Sep 2022 08:12:10 +0800
Subject: vim-patch:8.2.3702: first key in dict is seen as curly expression and
 fails

Problem:    First key in dict is seen as curly expression and fails.
Solution:   Ignore failure of curly expression. (closes vim/vim#9247)
https://github.com/vim/vim/commit/98cb90ef865089a5ddd20bc0303d449fb7d97fb2
---
 src/nvim/eval.c                    | 17 ++++++++---------
 src/nvim/testdir/test_listdict.vim |  3 +++
 2 files changed, 11 insertions(+), 9 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 0c41381313..1171695be3 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -2997,7 +2997,9 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
       // decimal, hex or octal number
       vim_str2nr(*arg, NULL, &len, STR2NR_ALL, &n, NULL, 0, true);
       if (len == 0) {
-        semsg(_(e_invexpr2), *arg);
+        if (evaluate) {
+          semsg(_(e_invexpr2), *arg);
+        }
         ret = FAIL;
         break;
       }
@@ -4582,7 +4584,7 @@ static int dict_get_tv(char **arg, typval_T *rettv, int evaluate, bool literal)
 {
   typval_T tv;
   char *key = NULL;
-  char *start = skipwhite(*arg + 1);
+  char *curly_expr = skipwhite(*arg + 1);
   char buf[NUMBUFLEN];
 
   // First check if it's not a curly-braces thing: {expr}.
@@ -4590,13 +4592,10 @@ static int dict_get_tv(char **arg, typval_T *rettv, int evaluate, bool literal)
   // twice.  Unfortunately this means we need to call eval1() twice for the
   // first item.
   // But {} is an empty Dictionary.
-  if (*start != '}') {
-    if (eval1(&start, &tv, false) == FAIL) {    // recursive!
-      return FAIL;
-    }
-    if (*skipwhite(start) == '}') {
-      return NOTDONE;
-    }
+  if (*curly_expr != '}'
+      && eval1(&curly_expr, &tv, false) == OK
+      && *skipwhite(curly_expr) == '}') {
+    return NOTDONE;
   }
 
   dict_T *d = NULL;
diff --git a/src/nvim/testdir/test_listdict.vim b/src/nvim/testdir/test_listdict.vim
index 08c415a069..f0440ae14b 100644
--- a/src/nvim/testdir/test_listdict.vim
+++ b/src/nvim/testdir/test_listdict.vim
@@ -165,6 +165,9 @@ func Test_dict()
   call assert_equal({'c': 'ccc', '1': 99, 'b': [1, 2, function('strlen')], '3': 33, '-1': {'a': 1}}, d)
   call filter(d, 'v:key =~ ''[ac391]''')
   call assert_equal({'c': 'ccc', '1': 99, '3': 33, '-1': {'a': 1}}, d)
+
+  " allow key starting with number at the start, not a curly expression
+  call assert_equal({'1foo': 77}, #{1foo: 77})
 endfunc
 
 " Dictionary identity
-- 
cgit 


From 4a67f9d386bb16149eecf32f45a3cb73878f12e7 Mon Sep 17 00:00:00 2001
From: ii14 <ii14@users.noreply.github.com>
Date: Wed, 7 Sep 2022 20:45:22 +0200
Subject: vim-patch:9.0.0409: #{g:x} was seen as a curly-braces expression

Problem:    #{g:x} was seen as a curly-braces expression.
Solution:   Do never see #{} as a curly-braces expression. (closes vim/vim#11075)
https://github.com/vim/vim/commit/7c7e1e9b98d4e5dbe7358c795a635c6f1f36f418
---
 src/nvim/eval.c                    | 6 ++++--
 src/nvim/testdir/test_listdict.vim | 4 ++++
 2 files changed, 8 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 1171695be3..aa2849279e 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -4587,12 +4587,14 @@ static int dict_get_tv(char **arg, typval_T *rettv, int evaluate, bool literal)
   char *curly_expr = skipwhite(*arg + 1);
   char buf[NUMBUFLEN];
 
-  // First check if it's not a curly-braces thing: {expr}.
+  // First check if it's not a curly-braces expression: {expr}.
   // Must do this without evaluating, otherwise a function may be called
   // twice.  Unfortunately this means we need to call eval1() twice for the
   // first item.
-  // But {} is an empty Dictionary.
+  // "{}" is an empty Dictionary.
+  // "#{abc}" is never a curly-braces expression.
   if (*curly_expr != '}'
+      && !literal
       && eval1(&curly_expr, &tv, false) == OK
       && *skipwhite(curly_expr) == '}') {
     return NOTDONE;
diff --git a/src/nvim/testdir/test_listdict.vim b/src/nvim/testdir/test_listdict.vim
index f0440ae14b..9cef6905a5 100644
--- a/src/nvim/testdir/test_listdict.vim
+++ b/src/nvim/testdir/test_listdict.vim
@@ -168,6 +168,10 @@ func Test_dict()
 
   " allow key starting with number at the start, not a curly expression
   call assert_equal({'1foo': 77}, #{1foo: 77})
+
+  " #{expr} is not a curly expression
+  let x = 'x'
+  call assert_equal(#{g: x}, #{g:x})
 endfunc
 
 " Dictionary identity
-- 
cgit 


From 80a566b55fd90fb49271e04106ddafb8ccb470cb Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 8 Sep 2022 08:50:43 +0800
Subject: vim-patch:9.0.0410: struct member cts_lnum is unused

Problem:    Struct member cts_lnum is unused.
Solution:   Delete it.
https://github.com/vim/vim/commit/d7633114af2365e32080b61af473db347a3489c2
---
 src/nvim/plines.c | 1 -
 src/nvim/plines.h | 1 -
 2 files changed, 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index c676dcddbd..176f86c691 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -292,7 +292,6 @@ void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T
                           char *ptr)
 {
   cts->cts_win = wp;
-  cts->cts_lnum = lnum;
   cts->cts_vcol = col;
   cts->cts_line = line;
   cts->cts_ptr = ptr;
diff --git a/src/nvim/plines.h b/src/nvim/plines.h
index 7b228f3e91..f463d82f10 100644
--- a/src/nvim/plines.h
+++ b/src/nvim/plines.h
@@ -6,7 +6,6 @@
 // Argument for lbr_chartabsize().
 typedef struct {
   win_T *cts_win;
-  linenr_T cts_lnum;   // zero when not using text properties
   char *cts_line;    // start of the line
   char *cts_ptr;     // current position in line
 
-- 
cgit 


From 06f9da547cbcc0b12c2d946a0abe0aee0bad4011 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Thu, 8 Sep 2022 08:52:45 +0800
Subject: vim-patch:9.0.0412: compiler warning for unused argument

Problem:    Compiler warning for unused argument.
Solution:   Add UNUSED.
https://github.com/vim/vim/commit/e5a420fb33518e08313f653f3031bc36f949e086
---
 src/nvim/plines.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/plines.c b/src/nvim/plines.c
index 176f86c691..cbde0cfff9 100644
--- a/src/nvim/plines.c
+++ b/src/nvim/plines.c
@@ -288,8 +288,8 @@ unsigned int win_linetabsize(win_T *wp, linenr_T lnum, char_u *line, colnr_T len
 ///
 /// "line" is the start of the line, "ptr" is the first relevant character.
 /// When "lnum" is zero do not use text properties that insert text.
-void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum, colnr_T col, char *line,
-                          char *ptr)
+void init_chartabsize_arg(chartabsize_T *cts, win_T *wp, linenr_T lnum FUNC_ATTR_UNUSED,
+                          colnr_T col, char *line, char *ptr)
 {
   cts->cts_win = wp;
   cts->cts_vcol = col;
-- 
cgit 


From 42aeb5c5b18af1362362a2e6bdf10a2a4ec70f0f Mon Sep 17 00:00:00 2001
From: dundargoc <gocundar@gmail.com>
Date: Tue, 9 Aug 2022 17:02:51 +0200
Subject: build: remove unnecessary policy related code

Having cmake version 3.10 as the required minimum version ensures these
are set to new by default.
---
 src/nvim/CMakeLists.txt | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/nvim/CMakeLists.txt b/src/nvim/CMakeLists.txt
index 635833748d..a1b57f927e 100755
--- a/src/nvim/CMakeLists.txt
+++ b/src/nvim/CMakeLists.txt
@@ -443,11 +443,6 @@ endif()
 
 set(NVIM_EXEC_LINK_LIBRARIES ${NVIM_LINK_LIBRARIES} ${LUA_PREFERRED_LIBRARIES})
 
-# Add IPO flags (for LTO), or error if CMake does not know the flags. #8654
-if(POLICY CMP0069)
-  cmake_policy(SET CMP0069 NEW)
-endif()
-
 add_executable(nvim ${NVIM_GENERATED_FOR_SOURCES} ${NVIM_GENERATED_FOR_HEADERS}
   ${NVIM_GENERATED_SOURCES} ${NVIM_SOURCES} ${NVIM_HEADERS}
   ${EXTERNAL_SOURCES} ${EXTERNAL_HEADERS})
@@ -461,7 +456,7 @@ set_property(TARGET nvim APPEND PROPERTY
              INCLUDE_DIRECTORIES ${LUA_PREFERRED_INCLUDE_DIRS})
 set_property(TARGET nvim PROPERTY ENABLE_EXPORTS TRUE)
 
-if(ENABLE_LTO AND (POLICY CMP0069))
+if(ENABLE_LTO)
   include(CheckIPOSupported)
   check_ipo_supported(RESULT IPO_SUPPORTED)
   if(IPO_SUPPORTED AND (NOT CMAKE_BUILD_TYPE MATCHES Debug))
-- 
cgit 


From 08602ec1ab2674385ddda8feaef2d3d9360d834d Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Thu, 8 Sep 2022 16:06:00 +0200
Subject: vim-patch:9.0.0417: Jsonnet files are not recognized (#20119)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Problem:    Jsonnet files are not recognized.
Solution:   Add a pattern for Jsonnet files. (Cezary Drożak, closes vim/vim#11073,
            closes vim/vim#11081)
https://github.com/vim/vim/commit/2a4c885d54171f68ec2c2d6eb4ae281c7fefb802
---
 src/nvim/testdir/test_filetype.vim | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 703d420847..8448154bfa 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -285,6 +285,7 @@ let s:filename_checks = {
     \ 'json': ['file.json', 'file.jsonp', 'file.json-patch', 'file.webmanifest', 'Pipfile.lock', 'file.ipynb', '.babelrc', '.eslintrc', '.prettierrc', '.firebaserc', 'file.slnf'],
     \ 'json5': ['file.json5'],
     \ 'jsonc': ['file.jsonc'],
+    \ 'jsonnet': ['file.jsonnet', 'file.libjsonnet'],
     \ 'jsp': ['file.jsp'],
     \ 'julia': ['file.jl'],
     \ 'kconfig': ['Kconfig', 'Kconfig.debug', 'Kconfig.file'],
-- 
cgit 


From ad2d6a624b10a52cdcfb7fdd9d8b1be24b13ed83 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Fri, 9 Sep 2022 17:53:15 +0200
Subject: vim-patch:9.0.0424: gitattributes files are not recognized (#20134)

Problem:    gitattributes files are not recognized.
Solution:   Add patterns to match gitattributes files. (closes vim/vim#11085)
https://github.com/vim/vim/commit/7d56cfc861e57145f003315efd835cf5dfd5b145
---
 src/nvim/testdir/test_filetype.vim | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 8448154bfa..d983a36840 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -213,6 +213,7 @@ let s:filename_checks = {
     \ 'gedcom': ['file.ged', 'lltxxxxx.txt', '/tmp/lltmp', '/tmp/lltmp-file', 'any/tmp/lltmp', 'any/tmp/lltmp-file'],
     \ 'gemtext': ['file.gmi', 'file.gemini'],
     \ 'gift': ['file.gift'],
+    \ 'gitattributes': ['file.git/info/attributes', '.gitattributes', '/.config/git/attributes', '/etc/gitattributes', '/usr/local/etc/gitattributes', 'some.git/info/attributes'],
     \ 'gitcommit': ['COMMIT_EDITMSG', 'MERGE_MSG', 'TAG_EDITMSG', 'NOTES_EDITMSG', 'EDIT_DESCRIPTION'],
     \ 'gitconfig': ['file.git/config', 'file.git/config.worktree', 'file.git/worktrees/x/config.worktree', '.gitconfig', '.gitmodules', 'file.git/modules//config', '/.config/git/config', '/etc/gitconfig', '/usr/local/etc/gitconfig', '/etc/gitconfig.d/file', 'any/etc/gitconfig.d/file', '/.gitconfig.d/file', 'any/.config/git/config', 'any/.gitconfig.d/file', 'some.git/config', 'some.git/modules/any/config'],
     \ 'gitolite': ['gitolite.conf', '/gitolite-admin/conf/file', 'any/gitolite-admin/conf/file'],
-- 
cgit 


From 9b0e1256e25d387bf65cb9baa1edd99fbc128724 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Fri, 9 Sep 2022 18:48:12 +0200
Subject: vim-patch:9.0.0427: Drupal theme files are not recognized (#20138)

Problem:    Drupal theme files are not recognized.
Solution:   Use php filetype for Drupl theme files.  Remove trailing spaces.
            (Rodrigo Aguilera, closes vim/vim#11096)
https://github.com/vim/vim/commit/8995c4cd4e697141faf74da9a87e0c1221bfb161
---
 src/nvim/testdir/test_filetype.vim | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index d983a36840..1cc804117a 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -409,7 +409,7 @@ let s:filename_checks = {
     \ 'perl': ['file.plx', 'file.al', 'file.psgi', 'gitolite.rc', '.gitolite.rc', 'example.gitolite.rc'],
     \ 'pf': ['pf.conf'],
     \ 'pfmain': ['main.cf'],
-    \ 'php': ['file.php', 'file.php9', 'file.phtml', 'file.ctp', 'file.phpt'],
+    \ 'php': ['file.php', 'file.php9', 'file.phtml', 'file.ctp', 'file.phpt', 'file.theme'],
     \ 'pike': ['file.pike', 'file.pmod'],
     \ 'pilrc': ['file.rcp'],
     \ 'pine': ['.pinerc', 'pinerc', '.pinercex', 'pinercex'],
@@ -534,7 +534,7 @@ let s:filename_checks = {
     \ 'stata': ['file.ado', 'file.do', 'file.imata', 'file.mata'],
     \ 'stp': ['file.stp'],
     \ 'sudoers': ['any/etc/sudoers', 'sudoers.tmp', '/etc/sudoers', 'any/etc/sudoers.d/file'],
-    \ 'supercollider': ['file.quark'], 
+    \ 'supercollider': ['file.quark'],
     \ 'surface': ['file.sface'],
     \ 'svelte': ['file.svelte'],
     \ 'svg': ['file.svg'],
@@ -1352,7 +1352,7 @@ func Test_mod_file()
   unlet g:filetype_mod
   bwipe!
 
-  " RAPID header start with a line containing only "%%%", 
+  " RAPID header start with a line containing only "%%%",
   " but is not always present.
   call writefile(['%%%'], 'modfile.mod')
   split modfile.mod
@@ -1368,7 +1368,7 @@ func Test_mod_file()
   bwipe!
   call delete('modfile.Mod')
 
-  " RAPID is not case sensitive, embedded spaces, sysmodule, 
+  " RAPID is not case sensitive, embedded spaces, sysmodule,
   " file starts with empty line(s).
   call writefile(['', 'MODULE  rapidmödüle  (SYSMODULE,NOSTEPIN)'], 'modfile.MOD')
   split modfile.MOD
@@ -1496,7 +1496,7 @@ func Test_prg_file()
   unlet g:filetype_prg
   bwipe!
 
-  " RAPID header start with a line containing only "%%%", 
+  " RAPID header start with a line containing only "%%%",
   " but is not always present.
   call writefile(['%%%'], 'prgfile.prg')
   split prgfile.prg
@@ -1512,7 +1512,7 @@ func Test_prg_file()
   bwipe!
   call delete('prgfile.Prg')
 
-  " RAPID is not case sensitive, embedded spaces, sysmodule, 
+  " RAPID is not case sensitive, embedded spaces, sysmodule,
   " file starts with empty line(s).
   call writefile(['', 'MODULE  rapidmödüle  (SYSMODULE,NOSTEPIN)'], 'prgfile.PRG')
   split prgfile.PRG
@@ -1623,7 +1623,7 @@ func Test_sys_file()
   unlet g:filetype_sys
   bwipe!
 
-  " RAPID header start with a line containing only "%%%", 
+  " RAPID header start with a line containing only "%%%",
   " but is not always present.
   call writefile(['%%%'], 'sysfile.sys')
   split sysfile.sys
@@ -1639,7 +1639,7 @@ func Test_sys_file()
   bwipe!
   call delete('sysfile.Sys')
 
-  " RAPID is not case sensitive, embedded spaces, sysmodule, 
+  " RAPID is not case sensitive, embedded spaces, sysmodule,
   " file starts with empty line(s).
   call writefile(['', 'MODULE  rapidmödüle  (SYSMODULE,NOSTEPIN)'], 'sysfile.SYS')
   split sysfile.SYS
-- 
cgit 


From c5322e752e9e568de907f7a1ef733bbfe342140c Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/api/command.c              |  14 ++---
 src/nvim/api/ui.c                   |   2 +-
 src/nvim/buffer.c                   |   4 +-
 src/nvim/change.c                   |   4 +-
 src/nvim/cmdexpand.c                |  11 ++--
 src/nvim/cmdhist.c                  |  12 ++--
 src/nvim/debugger.c                 |   2 +-
 src/nvim/diff.c                     |  20 +++---
 src/nvim/edit.c                     |   2 +-
 src/nvim/eval.c                     |  12 ++--
 src/nvim/eval/funcs.c               |   2 +-
 src/nvim/eval/typval.c              |   4 +-
 src/nvim/eval/userfunc.c            |   4 +-
 src/nvim/eval/vars.c                |   2 +-
 src/nvim/ex_cmds.c                  |  10 +--
 src/nvim/ex_docmd.c                 |  20 +++---
 src/nvim/ex_getln.c                 |   2 +-
 src/nvim/fileio.c                   |  28 ++++-----
 src/nvim/generators/gen_options.lua |   2 +-
 src/nvim/grid.c                     |  10 +--
 src/nvim/grid.h                     |  16 ++---
 src/nvim/grid_defs.h                |   2 +-
 src/nvim/help.c                     |  18 +++---
 src/nvim/highlight_group.c          |  12 ++--
 src/nvim/insexpand.c                |  16 ++---
 src/nvim/lua/executor.c             |   2 +-
 src/nvim/lua/stdlib.c               |   2 +-
 src/nvim/lua/treesitter.c           |   2 +-
 src/nvim/mapping.c                  |  10 +--
 src/nvim/mbyte.c                    |  36 +++++------
 src/nvim/memline.c                  |  38 ++++++------
 src/nvim/menu.c                     |   4 +-
 src/nvim/message.c                  |   8 +--
 src/nvim/message.h                  |   2 +-
 src/nvim/normal.c                   |  38 ++++++------
 src/nvim/option.c                   |  64 ++++++++++---------
 src/nvim/option_defs.h              |   6 +-
 src/nvim/optionstr.c                |  14 ++---
 src/nvim/os/shell.c                 |  20 +++---
 src/nvim/os/users.c                 |   6 +-
 src/nvim/profile.c                  |   8 +--
 src/nvim/quickfix.c                 |  13 ++--
 src/nvim/runtime.c                  |   2 +-
 src/nvim/shada.c                    |   8 +--
 src/nvim/sign.c                     |  12 ++--
 src/nvim/sign_defs.h                |   6 +-
 src/nvim/spell.c                    |  68 ++++++++++-----------
 src/nvim/spellfile.c                | 118 ++++++++++++++++++------------------
 src/nvim/spellsuggest.c             |  90 +++++++++++++--------------
 src/nvim/state.c                    |   2 +-
 src/nvim/strings.c                  |   2 +-
 src/nvim/syntax.c                   |  46 +++++++-------
 src/nvim/tag.c                      |  77 ++++++++++++-----------
 src/nvim/terminal.c                 |   4 +-
 src/nvim/testing.c                  |   2 +-
 src/nvim/undo.c                     |  16 ++---
 src/nvim/undo_defs.h                |   4 +-
 src/nvim/usercmd.c                  |   4 +-
 src/nvim/vim.h                      |   1 -
 src/nvim/window.h                   |  10 +--
 60 files changed, 484 insertions(+), 492 deletions(-)

(limited to 'src')

diff --git a/src/nvim/api/command.c b/src/nvim/api/command.c
index 11715a49dc..b3518f1b0f 100644
--- a/src/nvim/api/command.c
+++ b/src/nvim/api/command.c
@@ -591,15 +591,15 @@ String nvim_cmd(uint64_t channel_id, Dict(cmd) *cmd, Dict(cmd_opts) *opts, Error
 
       if (*mods.split.data.string.data == NUL) {
         // Empty string, do nothing.
-      } else if (STRCMP(mods.split.data.string.data, "aboveleft") == 0
-                 || STRCMP(mods.split.data.string.data, "leftabove") == 0) {
+      } else if (strcmp(mods.split.data.string.data, "aboveleft") == 0
+                 || strcmp(mods.split.data.string.data, "leftabove") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_ABOVE;
-      } else if (STRCMP(mods.split.data.string.data, "belowright") == 0
-                 || STRCMP(mods.split.data.string.data, "rightbelow") == 0) {
+      } else if (strcmp(mods.split.data.string.data, "belowright") == 0
+                 || strcmp(mods.split.data.string.data, "rightbelow") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_BELOW;
-      } else if (STRCMP(mods.split.data.string.data, "topleft") == 0) {
+      } else if (strcmp(mods.split.data.string.data, "topleft") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_TOP;
-      } else if (STRCMP(mods.split.data.string.data, "botright") == 0) {
+      } else if (strcmp(mods.split.data.string.data, "botright") == 0) {
         cmdinfo.cmdmod.cmod_split |= WSP_BOT;
       } else {
         VALIDATION_ERROR("Invalid value for 'mods.split'");
@@ -938,7 +938,7 @@ void nvim_buf_del_user_command(Buffer buffer, String name, Error *err)
 
   for (int i = 0; i < gap->ga_len; i++) {
     ucmd_T *cmd = USER_CMD_GA(gap, i);
-    if (!STRCMP(name.data, cmd->uc_name)) {
+    if (!strcmp(name.data, cmd->uc_name)) {
       free_ucmd(cmd);
 
       gap->ga_len -= 1;
diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index 1534e547b0..27fb4b8e16 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -845,7 +845,7 @@ static void remote_ui_raw_line(UI *ui, Integer grid, Integer row, Integer startc
     for (size_t i = 0; i < ncells; i++) {
       repeat++;
       if (i == ncells - 1 || attrs[i] != attrs[i + 1]
-          || STRCMP(chunk[i], chunk[i + 1])) {
+          || strcmp(chunk[i], chunk[i + 1])) {
         if (UI_BUF_SIZE - BUF_POS(data) < 2 * (1 + 2 + sizeof(schar_T) + 5 + 5)) {
           // close to overflowing the redraw buffer. finish this event,
           // flush, and start a new "grid_line" event at the current position.
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 8f23102e2e..658d372cee 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -3335,7 +3335,7 @@ static bool value_change(char *str, char **last)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   if ((str == NULL) != (*last == NULL)
-      || (str != NULL && *last != NULL && STRCMP(str, *last) != 0)) {
+      || (str != NULL && *last != NULL && strcmp(str, *last) != 0)) {
     xfree(*last);
     if (str == NULL) {
       *last = NULL;
@@ -4159,7 +4159,7 @@ bool buf_contents_changed(buf_T *buf)
     if (buf->b_ml.ml_line_count == curbuf->b_ml.ml_line_count) {
       differ = false;
       for (linenr_T lnum = 1; lnum <= curbuf->b_ml.ml_line_count; lnum++) {
-        if (STRCMP(ml_get_buf(buf, lnum, false), ml_get(lnum)) != 0) {
+        if (strcmp(ml_get_buf(buf, lnum, false), ml_get(lnum)) != 0) {
           differ = true;
           break;
         }
diff --git a/src/nvim/change.c b/src/nvim/change.c
index f4568fc617..6cd971cd74 100644
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -544,7 +544,7 @@ void save_file_ff(buf_T *buf)
 
   // Only use free/alloc when necessary, they take time.
   if (buf->b_start_fenc == NULL
-      || STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0) {
+      || strcmp(buf->b_start_fenc, buf->b_p_fenc) != 0) {
     xfree(buf->b_start_fenc);
     buf->b_start_fenc = xstrdup(buf->b_p_fenc);
   }
@@ -582,7 +582,7 @@ bool file_ff_differs(buf_T *buf, bool ignore_empty)
   if (buf->b_start_fenc == NULL) {
     return *buf->b_p_fenc != NUL;
   }
-  return STRCMP(buf->b_start_fenc, buf->b_p_fenc) != 0;
+  return strcmp(buf->b_start_fenc, buf->b_p_fenc) != 0;
 }
 
 /// Insert string "p" at the cursor position.  Stops at a NUL byte.
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index 3f624c77f3..d2cfb25bf9 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -66,8 +66,8 @@ static int compl_selected;
 
 static int sort_func_compare(const void *s1, const void *s2)
 {
-  char_u *p1 = *(char_u **)s1;
-  char_u *p2 = *(char_u **)s2;
+  char *p1 = *(char **)s1;
+  char *p2 = *(char **)s2;
 
   if (*p1 != '<' && *p2 == '<') {
     return -1;
@@ -75,7 +75,7 @@ static int sort_func_compare(const void *s1, const void *s2)
   if (*p1 == '<' && *p2 != '<') {
     return 1;
   }
-  return STRCMP(p1, p2);
+  return strcmp(p1, p2);
 }
 
 static void ExpandEscape(expand_T *xp, char_u *str, int numfiles, char **files, int options)
@@ -1148,7 +1148,7 @@ static void set_context_for_wildcard_arg(exarg_T *eap, const char *arg, bool use
     // A full match ~user<Tab> will be replaced by user's home
     // directory i.e. something like ~user<Tab> -> /home/user/
     if (*p == NUL && p > (const char *)xp->xp_pattern + 1
-        && match_user((char_u *)xp->xp_pattern + 1) >= 1) {
+        && match_user(xp->xp_pattern + 1) >= 1) {
       xp->xp_context = EXPAND_USER;
       xp->xp_pattern++;
     }
@@ -2294,8 +2294,7 @@ static void ExpandGeneric(expand_T *xp, regmatch_T *regmatch, int *num_file, cha
         || xp->xp_context == EXPAND_FUNCTIONS
         || xp->xp_context == EXPAND_USER_FUNC) {
       // <SNR> functions should be sorted to the end.
-      qsort((void *)(*file), (size_t)(*num_file), sizeof(char_u *),
-            sort_func_compare);
+      qsort((void *)(*file), (size_t)(*num_file), sizeof(char *), sort_func_compare);
     } else {
       sort_strings(*file, *num_file);
     }
diff --git a/src/nvim/cmdhist.c b/src/nvim/cmdhist.c
index 38353f44b5..3747c91c4f 100644
--- a/src/nvim/cmdhist.c
+++ b/src/nvim/cmdhist.c
@@ -186,7 +186,7 @@ static inline void clear_hist_entry(histentry_T *hisptr)
 /// If 'move_to_front' is true, matching entry is moved to end of history.
 ///
 /// @param move_to_front  Move the entry to the front if it exists
-static int in_history(int type, char_u *str, int move_to_front, int sep)
+static int in_history(int type, char *str, int move_to_front, int sep)
 {
   int last_i = -1;
 
@@ -201,8 +201,8 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
 
     // For search history, check that the separator character matches as
     // well.
-    char_u *p = (char_u *)history[type][i].hisstr;
-    if (STRCMP(str, p) == 0
+    char *p = history[type][i].hisstr;
+    if (strcmp(str, p) == 0
         && (type != HIST_SEARCH || sep == p[STRLEN(p) + 1])) {
       if (!move_to_front) {
         return true;
@@ -217,7 +217,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
 
   if (last_i >= 0) {
     list_T *const list = history[type][i].additional_elements;
-    str = (char_u *)history[type][i].hisstr;
+    str = history[type][i].hisstr;
     while (i != hisidx[type]) {
       if (++i >= hislen) {
         i = 0;
@@ -227,7 +227,7 @@ static int in_history(int type, char_u *str, int move_to_front, int sep)
     }
     tv_list_unref(list);
     history[type][i].hisnum = ++hisnum[type];
-    history[type][i].hisstr = (char *)str;
+    history[type][i].hisstr = str;
     history[type][i].timestamp = os_time();
     history[type][i].additional_elements = NULL;
     return true;
@@ -304,7 +304,7 @@ void add_to_history(int histype, char *new_entry, int in_map, int sep)
     }
     last_maptick = -1;
   }
-  if (!in_history(histype, (char_u *)new_entry, true, sep)) {
+  if (!in_history(histype, new_entry, true, sep)) {
     if (++hisidx[histype] == hislen) {
       hisidx[histype] = 0;
     }
diff --git a/src/nvim/debugger.c b/src/nvim/debugger.c
index b720628e33..e91491e665 100644
--- a/src/nvim/debugger.c
+++ b/src/nvim/debugger.c
@@ -646,7 +646,7 @@ void ex_breakdel(exarg_T *eap)
     for (int i = 0; i < gap->ga_len; i++) {
       bpi = &DEBUGGY(gap, i);
       if (bp->dbg_type == bpi->dbg_type
-          && STRCMP(bp->dbg_name, bpi->dbg_name) == 0
+          && strcmp(bp->dbg_name, bpi->dbg_name) == 0
           && (bp->dbg_lnum == bpi->dbg_lnum
               || (bp->dbg_lnum == 0
                   && (best_lnum == 0
diff --git a/src/nvim/diff.c b/src/nvim/diff.c
index 69883966ab..c5092dc866 100644
--- a/src/nvim/diff.c
+++ b/src/nvim/diff.c
@@ -592,9 +592,9 @@ static void diff_check_unchanged(tabpage_T *tp, diff_T *dp)
           break;
         }
 
-        if (diff_cmp((char_u *)line_org, (char_u *)ml_get_buf(tp->tp_diffbuf[i_new],
-                                                              dp->df_lnum[i_new] + off_new,
-                                                              false)) != 0) {
+        if (diff_cmp(line_org, ml_get_buf(tp->tp_diffbuf[i_new],
+                                          dp->df_lnum[i_new] + off_new,
+                                          false)) != 0) {
           break;
         }
       }
@@ -1923,8 +1923,8 @@ static bool diff_equal_entry(diff_T *dp, int idx1, int idx2)
     char *line = xstrdup(ml_get_buf(curtab->tp_diffbuf[idx1],
                                     dp->df_lnum[idx1] + i, false));
 
-    int cmp = diff_cmp((char_u *)line, (char_u *)ml_get_buf(curtab->tp_diffbuf[idx2],
-                                                            dp->df_lnum[idx2] + i, false));
+    int cmp = diff_cmp(line, ml_get_buf(curtab->tp_diffbuf[idx2],
+                                        dp->df_lnum[idx2] + i, false));
     xfree(line);
 
     if (cmp != 0) {
@@ -1968,23 +1968,23 @@ static bool diff_equal_char(const char_u *const p1, const char_u *const p2, int
 /// @param s2 The second string
 ///
 /// @return on-zero if the two strings are different.
-static int diff_cmp(char_u *s1, char_u *s2)
+static int diff_cmp(char *s1, char *s2)
 {
   if ((diff_flags & DIFF_IBLANK)
-      && (*(char_u *)skipwhite((char *)s1) == NUL || *skipwhite((char *)s2) == NUL)) {
+      && (*(char_u *)skipwhite(s1) == NUL || *skipwhite(s2) == NUL)) {
     return 0;
   }
 
   if ((diff_flags & (DIFF_ICASE | ALL_WHITE_DIFF)) == 0) {
-    return STRCMP(s1, s2);
+    return strcmp(s1, s2);
   }
 
   if ((diff_flags & DIFF_ICASE) && !(diff_flags & ALL_WHITE_DIFF)) {
     return mb_stricmp((const char *)s1, (const char *)s2);
   }
 
-  char *p1 = (char *)s1;
-  char *p2 = (char *)s2;
+  char *p1 = s1;
+  char *p2 = s2;
 
   // Ignore white space changes and possibly ignore case.
   while (*p1 != NUL && *p2 != NUL) {
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index f7a16abfb2..1a8030d511 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -4951,7 +4951,7 @@ static char_u *do_insert_char_pre(int c)
     // Get the value of v:char.  It may be empty or more than one
     // character.  Only use it when changed, otherwise continue with the
     // original character to avoid breaking autoindent.
-    if (STRCMP(buf, get_vim_var_str(VV_CHAR)) != 0) {
+    if (strcmp(buf, get_vim_var_str(VV_CHAR)) != 0) {
       res = xstrdup(get_vim_var_str(VV_CHAR));
     }
   }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index aa2849279e..0f2547120d 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -3998,13 +3998,11 @@ failret:
 bool func_equal(typval_T *tv1, typval_T *tv2, bool ic)
 {
   // empty and NULL function name considered the same
-  char_u *s1 =
-    (char_u *)(tv1->v_type == VAR_FUNC ? tv1->vval.v_string : partial_name(tv1->vval.v_partial));
+  char *s1 = tv1->v_type == VAR_FUNC ? tv1->vval.v_string : partial_name(tv1->vval.v_partial);
   if (s1 != NULL && *s1 == NUL) {
     s1 = NULL;
   }
-  char_u *s2 =
-    (char_u *)(tv2->v_type == VAR_FUNC ? tv2->vval.v_string : partial_name(tv2->vval.v_partial));
+  char *s2 = tv2->v_type == VAR_FUNC ? tv2->vval.v_string : partial_name(tv2->vval.v_partial);
   if (s2 != NULL && *s2 == NUL) {
     s2 = NULL;
   }
@@ -4012,7 +4010,7 @@ bool func_equal(typval_T *tv1, typval_T *tv2, bool ic)
     if (s1 != s2) {
       return false;
     }
-  } else if (STRCMP(s1, s2) != 0) {
+  } else if (strcmp(s1, s2) != 0) {
     return false;
   }
 
@@ -6374,7 +6372,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
     listitem_T *li = tv_list_find(l, 1L);
     if (li != NULL && TV_LIST_ITEM_TV(li)->v_type == VAR_STRING
         && 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) {
       pos.col = len + 1;
     }
 
@@ -7822,7 +7820,7 @@ bool script_autoload(const char *const name, const size_t name_len, const bool r
   // "autoload/", it's always the same.
   int i = 0;
   for (; i < ga_loaded.ga_len; i++) {
-    if (STRCMP(((char **)ga_loaded.ga_data)[i] + 9, scriptname + 9) == 0) {
+    if (strcmp(((char **)ga_loaded.ga_data)[i] + 9, scriptname + 9) == 0) {
       break;
     }
   }
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 408b6e6cb5..fa48f227e3 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -423,7 +423,7 @@ static buf_T *find_buffer(typval_T *avar)
       FOR_ALL_BUFFERS(bp) {
         if (bp->b_fname != NULL
             && (path_with_url(bp->b_fname) || bt_nofilename(bp))
-            && STRCMP(bp->b_fname, avar->vval.v_string) == 0) {
+            && strcmp(bp->b_fname, avar->vval.v_string) == 0) {
           buf = bp;
           break;
         }
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index f6b97fe05b..caba722e5b 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -1016,7 +1016,7 @@ static int item_compare(const void *s1, const void *s2, bool keep_zero)
     if (sortinfo->item_compare_lc) {
       res = strcoll(p1, p2);
     } else {
-      res = sortinfo->item_compare_ic ? STRICMP(p1, p2): STRCMP(p1, p2);
+      res = sortinfo->item_compare_ic ? STRICMP(p1, p2): strcmp(p1, p2);
     }
   } else {
     double n1, n2;
@@ -1568,7 +1568,7 @@ bool tv_callback_equal(const Callback *cb1, const Callback *cb2)
   }
   switch (cb1->type) {
   case kCallbackFuncref:
-    return STRCMP(cb1->data.funcref, cb2->data.funcref) == 0;
+    return strcmp(cb1->data.funcref, cb2->data.funcref) == 0;
   case kCallbackPartial:
     // FIXME: this is inconsistent with tv_equal but is needed for precision
     // maybe change dictwatcheradd to return a watcher id instead?
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index a899e1579b..a1c4b8b893 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -111,7 +111,7 @@ static int get_function_args(char **argp, char_u endchar, garray_T *newargs, int
 
         // Check for duplicate argument name.
         for (i = 0; i < newargs->ga_len; i++) {
-          if (STRCMP(((char **)(newargs->ga_data))[i], arg) == 0) {
+          if (strcmp(((char **)(newargs->ga_data))[i], arg) == 0) {
             semsg(_("E853: Duplicate argument name: %s"), arg);
             xfree(arg);
             goto err_ret;
@@ -2218,7 +2218,7 @@ void ex_function(exarg_T *eap)
         } else {
           p = theline + STRLEN(heredoc_trimmed);
         }
-        if (STRCMP(p, skip_until) == 0) {
+        if (strcmp(p, skip_until) == 0) {
           XFREE_CLEAR(skip_until);
           XFREE_CLEAR(heredoc_trimmed);
           do_concat = true;
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index ba58254bdd..004a239fda 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -113,7 +113,7 @@ static list_T *heredoc_get(exarg_T *eap, char *cmd)
         && STRNCMP(theline, *eap->cmdlinep, marker_indent_len) == 0) {
       mi = marker_indent_len;
     }
-    if (STRCMP(marker, theline + mi) == 0) {
+    if (strcmp(marker, theline + mi) == 0) {
       xfree(theline);
       break;
     }
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 12920d932d..4f33a2d883 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -379,7 +379,7 @@ static int string_compare(const void *s1, const void *s2) FUNC_ATTR_NONNULL_ALL
   if (sort_lc) {
     return strcoll((char *)s1, (char *)s2);
   }
-  return sort_ic ? STRICMP(s1, s2) : STRCMP(s1, s2);
+  return sort_ic ? STRICMP(s1, s2) : strcmp(s1, s2);
 }
 
 static int sort_compare(const void *s1, const void *s2)
@@ -1535,12 +1535,12 @@ char *make_filter_cmd(char *cmd, char *itmp, char *otmp)
 {
   bool is_fish_shell =
 #if defined(UNIX)
-    STRNCMP(invocation_path_tail(p_sh, NULL), "fish", 4) == 0;
+    STRNCMP(invocation_path_tail((char_u *)p_sh, NULL), "fish", 4) == 0;
 #else
     false;
 #endif
-  bool is_pwsh = STRNCMP(invocation_path_tail(p_sh, NULL), "pwsh", 4) == 0
-                 || STRNCMP(invocation_path_tail(p_sh, NULL), "powershell", 10) == 0;
+  bool is_pwsh = STRNCMP(invocation_path_tail((char_u *)p_sh, NULL), "pwsh", 4) == 0
+                 || STRNCMP(invocation_path_tail((char_u *)p_sh, NULL), "powershell", 10) == 0;
 
   size_t len = STRLEN(cmd) + 1;  // At least enough space for cmd + NULL.
 
@@ -3258,7 +3258,7 @@ static bool sub_joining_lines(exarg_T *eap, char *pat, char *sub, char *cmd, boo
   // TODO(vim): find a generic solution to make line-joining operations more
   // efficient, avoid allocating a string that grows in size.
   if (pat != NULL
-      && STRCMP(pat, "\\n") == 0
+      && strcmp(pat, "\\n") == 0
       && *sub == NUL
       && (*cmd == NUL || (cmd[1] == NUL
                           && (*cmd == 'g'
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index e32eb860ce..2a378f6f02 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -3657,7 +3657,7 @@ char *replace_makeprg(exarg_T *eap, char *arg, char **cmdlinep)
   // Don't do it when ":vimgrep" is used for ":grep".
   if ((eap->cmdidx == CMD_make || eap->cmdidx == CMD_lmake || isgrep)
       && !grep_internal(eap->cmdidx)) {
-    const char *program = isgrep ? (*curbuf->b_p_gp == NUL ? (char *)p_gp : curbuf->b_p_gp)
+    const char *program = isgrep ? (*curbuf->b_p_gp == NUL ? p_gp : curbuf->b_p_gp)
                                  : (*curbuf->b_p_mp == NUL ? (char *)p_mp : curbuf->b_p_mp);
 
     arg = skipwhite(arg);
@@ -4114,9 +4114,9 @@ static int get_tabpage_arg(exarg_T *eap)
     tab_number = (int)getdigits(&p, false, tab_number);
 
     if (relative == 0) {
-      if (STRCMP(p, "$") == 0) {
+      if (strcmp(p, "$") == 0) {
         tab_number = LAST_TAB_NR;
-      } else if (STRCMP(p, "#") == 0) {
+      } else if (strcmp(p, "#") == 0) {
         if (valid_tabpage(lastused_tabpage)) {
           tab_number = tabpage_index(lastused_tabpage);
         } else {
@@ -5480,7 +5480,7 @@ bool changedir_func(char *new_dir, CdScope scope)
 
   char *pdir = NULL;
   // ":cd -": Change to previous directory
-  if (STRCMP(new_dir, "-") == 0) {
+  if (strcmp(new_dir, "-") == 0) {
     pdir = get_prevdir(scope);
     if (pdir == NULL) {
       emsg(_("E186: No previous directory"));
@@ -6712,7 +6712,7 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
         valid = 0;                  // Must have ":p:h" to be valid
       } else {
         result = curbuf->b_fname;
-        tilde_file = STRCMP(result, "~") == 0;
+        tilde_file = strcmp(result, "~") == 0;
       }
       break;
 
@@ -6766,7 +6766,7 @@ char_u *eval_vars(char_u *src, char_u *srcstart, size_t *usedlen, linenr_T *lnum
           valid = 0;                        // Must have ":p:h" to be valid
         } else {
           result = buf->b_fname;
-          tilde_file = STRCMP(result, "~") == 0;
+          tilde_file = strcmp(result, "~") == 0;
         }
       }
       break;
@@ -6986,12 +6986,12 @@ void dialog_msg(char *buff, char *format, char *fname)
 /// ":behave {mswin,xterm}"
 static void ex_behave(exarg_T *eap)
 {
-  if (STRCMP(eap->arg, "mswin") == 0) {
+  if (strcmp(eap->arg, "mswin") == 0) {
     set_option_value_give_err("selection", 0L, "exclusive", 0);
     set_option_value_give_err("selectmode", 0L, "mouse,key", 0);
     set_option_value_give_err("mousemodel", 0L, "popup", 0);
     set_option_value_give_err("keymodel", 0L, "startsel,stopsel", 0);
-  } else if (STRCMP(eap->arg, "xterm") == 0) {
+  } else if (strcmp(eap->arg, "xterm") == 0) {
     set_option_value_give_err("selection", 0L, "inclusive", 0);
     set_option_value_give_err("selectmode", 0L, "", 0);
     set_option_value_give_err("mousemodel", 0L, "extend", 0);
@@ -7041,7 +7041,7 @@ static void ex_filetype(exarg_T *eap)
     }
     break;
   }
-  if (STRCMP(arg, "on") == 0 || STRCMP(arg, "detect") == 0) {
+  if (strcmp(arg, "on") == 0 || strcmp(arg, "detect") == 0) {
     if (*arg == 'o' || !filetype_detect) {
       source_runtime(FILETYPE_FILE, DIP_ALL);
       filetype_detect = kTrue;
@@ -7058,7 +7058,7 @@ static void ex_filetype(exarg_T *eap)
       (void)do_doautocmd("filetypedetect BufRead", true, NULL);
       do_modelines(0);
     }
-  } else if (STRCMP(arg, "off") == 0) {
+  } else if (strcmp(arg, "off") == 0) {
     if (plugin || indent) {
       if (plugin) {
         source_runtime(FTPLUGOF_FILE, DIP_ALL);
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index cf95287d61..60c89f61a8 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -2881,7 +2881,7 @@ static bool color_cmdline(CmdlineInfo *colored_ccline)
   // Check whether result of the previous call is still valid.
   if (ccline_colors->prompt_id == colored_ccline->prompt_id
       && ccline_colors->cmdbuff != NULL
-      && STRCMP(ccline_colors->cmdbuff, colored_ccline->cmdbuff) == 0) {
+      && strcmp(ccline_colors->cmdbuff, colored_ccline->cmdbuff) == 0) {
     return ret;
   }
 
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 0d8eec1023..7b117aa6e3 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -806,11 +806,11 @@ retry:
   // Conversion may be required when the encoding of the file is different
   // from 'encoding' or 'encoding' is UTF-16, UCS-2 or UCS-4.
   fio_flags = 0;
-  converted = need_conversion((char_u *)fenc);
+  converted = need_conversion(fenc);
   if (converted) {
     // "ucs-bom" means we need to check the first bytes of the file
     // for a BOM.
-    if (STRCMP(fenc, ENC_UCSBOM) == 0) {
+    if (strcmp(fenc, ENC_UCSBOM) == 0) {
       fio_flags = FIO_UCSBOM;
     } else {
       // Check if UCS-2/4 or Latin1 to UTF-8 conversion needs to be
@@ -2952,7 +2952,7 @@ nobackup:
   }
 
   // Check if the file needs to be converted.
-  converted = need_conversion((char_u *)fenc);
+  converted = need_conversion(fenc);
 
   // Check if UTF-8 to UCS-2/4 or Latin1 conversion needs to be done.  Or
   // Latin1 to Unicode conversion.  This is handled in buf_write_bytes().
@@ -4028,21 +4028,21 @@ static bool ucs2bytes(unsigned c, char_u **pp, int flags) FUNC_ATTR_NONNULL_ALL
 /// @param fenc file encoding to check
 ///
 /// @return true if conversion is required
-static bool need_conversion(const char_u *fenc)
+static bool need_conversion(const char *fenc)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT
 {
   int same_encoding;
   int enc_flags;
   int fenc_flags;
 
-  if (*fenc == NUL || STRCMP(p_enc, fenc) == 0) {
+  if (*fenc == NUL || strcmp(p_enc, fenc) == 0) {
     same_encoding = true;
     fenc_flags = 0;
   } else {
     // Ignore difference between "ansi" and "latin1", "ucs-4" and
     // "ucs-4be", etc.
     enc_flags = get_fio_flags((char_u *)p_enc);
-    fenc_flags = get_fio_flags(fenc);
+    fenc_flags = get_fio_flags((char_u *)fenc);
     same_encoding = (enc_flags != 0 && fenc_flags == enc_flags);
   }
   if (same_encoding) {
@@ -4499,7 +4499,7 @@ int vim_rename(const char_u *from, const char_u *to)
   // to the same file (ignoring case and slash/backslash differences) but
   // the file name differs we need to go through a temp file.
   if (FNAMECMP(from, to) == 0) {
-    if (p_fic && (STRCMP(path_tail((char *)from), path_tail((char *)to))
+    if (p_fic && (strcmp(path_tail((char *)from), path_tail((char *)to))
                   != 0)) {
       use_tmp_file = true;
     } else {
@@ -4745,7 +4745,7 @@ int buf_check_timestamp(buf_T *buf)
   FUNC_ATTR_NONNULL_ALL
 {
   int retval = 0;
-  char_u *path;
+  char *path;
   char *mesg = NULL;
   char *mesg2 = "";
   bool helpmesg = false;
@@ -4760,7 +4760,7 @@ int buf_check_timestamp(buf_T *buf)
   uint64_t orig_size = buf->b_orig_size;
   int orig_mode = buf->b_orig_mode;
   static bool busy = false;
-  char_u *s;
+  char *s;
   char *reason;
 
   bufref_T bufref;
@@ -4835,12 +4835,12 @@ int buf_check_timestamp(buf_T *buf)
         if (!bufref_valid(&bufref)) {
           emsg(_("E246: FileChangedShell autocommand deleted buffer"));
         }
-        s = (char_u *)get_vim_var_str(VV_FCS_CHOICE);
-        if (STRCMP(s, "reload") == 0 && *reason != 'd') {
+        s = get_vim_var_str(VV_FCS_CHOICE);
+        if (strcmp(s, "reload") == 0 && *reason != 'd') {
           reload = RELOAD_NORMAL;
-        } else if (STRCMP(s, "edit") == 0) {
+        } else if (strcmp(s, "edit") == 0) {
           reload = RELOAD_DETECT;
-        } else if (STRCMP(s, "ask") == 0) {
+        } else if (strcmp(s, "ask") == 0) {
           n = false;
         } else {
           return 2;
@@ -4888,7 +4888,7 @@ int buf_check_timestamp(buf_T *buf)
   }
 
   if (mesg != NULL) {
-    path = (char_u *)home_replace_save(buf, buf->b_fname);
+    path = home_replace_save(buf, buf->b_fname);
     if (!helpmesg) {
       mesg2 = "";
     }
diff --git a/src/nvim/generators/gen_options.lua b/src/nvim/generators/gen_options.lua
index 0454c54faf..24b4739fc7 100644
--- a/src/nvim/generators/gen_options.lua
+++ b/src/nvim/generators/gen_options.lua
@@ -115,7 +115,7 @@ local value_dumpers = {
 }
 
 local get_value = function(v)
-  return '(char_u *) ' .. value_dumpers[type(v)](v)
+  return '(char *) ' .. value_dumpers[type(v)](v)
 end
 
 local get_defaults = function(d,n)
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index 22445b9ec7..63bb945f73 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -46,14 +46,14 @@ void grid_adjust(ScreenGrid **grid, int *row_off, int *col_off)
 }
 
 /// Put a unicode char, and up to MAX_MCO composing chars, in a screen cell.
-int schar_from_cc(char_u *p, int c, int u8cc[MAX_MCO])
+int schar_from_cc(char *p, int c, int u8cc[MAX_MCO])
 {
-  int len = utf_char2bytes(c, (char *)p);
+  int len = utf_char2bytes(c, p);
   for (int i = 0; i < MAX_MCO; i++) {
     if (u8cc[i] == 0) {
       break;
     }
-    len += utf_char2bytes(u8cc[i], (char *)p + len);
+    len += utf_char2bytes(u8cc[i], p + len);
   }
   p[len] = 0;
   return len;
@@ -140,7 +140,7 @@ void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes, int *attrp
   if (grid->chars != NULL && row < grid->rows && col < grid->cols) {
     off = grid->line_offset[row] + (size_t)col;
     *attrp = grid->attrs[off];
-    schar_copy(bytes, grid->chars[off]);
+    schar_copy((char *)bytes, grid->chars[off]);
   }
 }
 
@@ -171,7 +171,7 @@ void grid_puts_line_start(ScreenGrid *grid, int row)
   put_dirty_grid = grid;
 }
 
-void grid_put_schar(ScreenGrid *grid, int row, int col, char_u *schar, int attr)
+void grid_put_schar(ScreenGrid *grid, int row, int col, char *schar, int attr)
 {
   assert(put_dirty_row == row);
   size_t off = grid->line_offset[row] + (size_t)col;
diff --git a/src/nvim/grid.h b/src/nvim/grid.h
index 6a93bf3d90..0e79183c14 100644
--- a/src/nvim/grid.h
+++ b/src/nvim/grid.h
@@ -29,30 +29,30 @@ EXTERN sattr_T *linebuf_attr INIT(= NULL);
 // screen grid.
 
 /// Put a ASCII character in a screen cell.
-static inline void schar_from_ascii(char_u *p, const char c)
+static inline void schar_from_ascii(char *p, const char c)
 {
-  p[0] = (char_u)c;
+  p[0] = c;
   p[1] = 0;
 }
 
 /// Put a unicode character in a screen cell.
-static inline int schar_from_char(char_u *p, int c)
+static inline int schar_from_char(char *p, int c)
 {
-  int len = utf_char2bytes(c, (char *)p);
+  int len = utf_char2bytes(c, p);
   p[len] = NUL;
   return len;
 }
 
 /// compare the contents of two screen cells.
-static inline int schar_cmp(char_u *sc1, char_u *sc2)
+static inline int schar_cmp(char *sc1, char *sc2)
 {
-  return strncmp((char *)sc1, (char *)sc2, sizeof(schar_T));
+  return strncmp(sc1, sc2, sizeof(schar_T));
 }
 
 /// copy the contents of screen cell `sc2` into cell `sc1`
-static inline void schar_copy(char_u *sc1, char_u *sc2)
+static inline void schar_copy(char *sc1, char *sc2)
 {
-  xstrlcpy((char *)sc1, (char *)sc2, sizeof(schar_T));
+  xstrlcpy(sc1, sc2, sizeof(schar_T));
 }
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
diff --git a/src/nvim/grid_defs.h b/src/nvim/grid_defs.h
index 9252b8a371..57b3817bc6 100644
--- a/src/nvim/grid_defs.h
+++ b/src/nvim/grid_defs.h
@@ -10,7 +10,7 @@
 #define MAX_MCO  6  // fixed value for 'maxcombine'
 
 // The characters and attributes drawn on grids.
-typedef char_u schar_T[(MAX_MCO + 1) * 4 + 1];
+typedef char schar_T[(MAX_MCO + 1) * 4 + 1];
 typedef int sattr_T;
 
 enum {
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 235f64744a..210c7b518c 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -367,7 +367,7 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
     // the table, it is taken literally (but ~ is escaped).  Otherwise '?'
     // is recognized as a wildcard.
     for (i = (int)ARRAY_SIZE(expr_table); --i >= 0;) {
-      if (STRCMP(arg + 5, expr_table[i]) == 0) {
+      if (strcmp(arg + 5, expr_table[i]) == 0) {
         for (int si = 0, di = 0;; si++) {
           if (arg[si] == '~') {
             d[di++] = '\\';
@@ -384,7 +384,7 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
     // Recognize a few exceptions to the rule.  Some strings that contain
     // '*'are changed to "star", otherwise '*' is recognized as a wildcard.
     for (i = 0; except_tbl[i][0] != NULL; i++) {
-      if (STRCMP(arg, except_tbl[i][0]) == 0) {
+      if (strcmp(arg, except_tbl[i][0]) == 0) {
         STRCPY(d, except_tbl[i][1]);
         break;
       }
@@ -556,8 +556,8 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
 /// tag matches it.  Otherwise remove "@en" if "en" is the only language.
 void cleanup_help_tags(int num_file, char **file)
 {
-  char_u buf[4];
-  char_u *p = buf;
+  char buf[4];
+  char_u *p = (char_u *)buf;
 
   if (p_hlg[0] != NUL && (p_hlg[0] != 'e' || p_hlg[1] != 'n')) {
     *p++ = '@';
@@ -571,7 +571,7 @@ void cleanup_help_tags(int num_file, char **file)
     if (len <= 0) {
       continue;
     }
-    if (STRCMP(file[i] + len, "@en") == 0) {
+    if (strcmp(file[i] + len, "@en") == 0) {
       // Sorting on priority means the same item in another language may
       // be anywhere.  Search all items for a match up to the "@en".
       int j;
@@ -595,7 +595,7 @@ void cleanup_help_tags(int num_file, char **file)
       if (len <= 0) {
         continue;
       }
-      if (STRCMP(file[i] + len, buf) == 0) {
+      if (strcmp(file[i] + len, buf) == 0) {
         // remove the default language
         file[i][len] = NUL;
       }
@@ -615,7 +615,7 @@ void prepare_help_buffer(void)
   // latin1 word characters (for translated help files).
   // Only set it when needed, buf_init_chartab() is some work.
   char *p = "!-~,^*,^|,^\",192-255";
-  if (STRCMP(curbuf->b_p_isk, p) != 0) {
+  if (strcmp(curbuf->b_p_isk, p) != 0) {
     set_string_option_direct("isk", -1, p, OPT_FREE|OPT_LOCAL, 0);
     check_buf_options(curbuf);
     (void)buf_init_chartab(curbuf, false);
@@ -650,7 +650,7 @@ void fix_help_buffer(void)
   bool in_example = false;
 
   // Set filetype to "help".
-  if (STRCMP(curbuf->b_p_ft, "help") != 0) {
+  if (strcmp(curbuf->b_p_ft, "help") != 0) {
     curbuf->b_ro_locked++;
     set_option_value_give_err("ft", 0L, "help", OPT_LOCAL);
     curbuf->b_ro_locked--;
@@ -1162,7 +1162,7 @@ void ex_helptags(exarg_T *eap)
     eap->arg = skipwhite(eap->arg + 3);
   }
 
-  if (STRCMP(eap->arg, "ALL") == 0) {
+  if (strcmp(eap->arg, "ALL") == 0) {
     do_in_path(p_rtp, "doc", DIP_ALL + DIP_DIR, helptags_cb, &add_help_tags);
   } else {
     ExpandInit(&xpc);
diff --git a/src/nvim/highlight_group.c b/src/nvim/highlight_group.c
index 7e5fd52243..2cb8fabfb4 100644
--- a/src/nvim/highlight_group.c
+++ b/src/nvim/highlight_group.c
@@ -791,7 +791,7 @@ void set_hl_group(int id, HlAttrs attrs, Dict(highlight) *dict, int link_id)
   g->sg_attr = hl_get_syn_attr(0, id, attrs);
 
   // 'Normal' is special
-  if (STRCMP(g->sg_name_u, "NORMAL") == 0) {
+  if (strcmp(g->sg_name_u, "NORMAL") == 0) {
     cterm_normal_fg_color = g->sg_cterm_fg;
     cterm_normal_bg_color = g->sg_cterm_bg;
     normal_fg = g->sg_rgb_fg;
@@ -988,7 +988,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
 
   // Make a copy so we can check if any attribute actually changed
   item_before = hl_table[idx];
-  is_normal_group = (STRCMP(hl_table[idx].sg_name_u, "NORMAL") == 0);
+  is_normal_group = (strcmp(hl_table[idx].sg_name_u, "NORMAL") == 0);
 
   // Clear the highlighting for ":hi clear {group}" and ":hi clear".
   if (doclear || (forceit && init)) {
@@ -1119,9 +1119,9 @@ void do_highlight(const char *line, const bool forceit, const bool init)
             hl_table[idx].sg_gui = attr;
           }
         }
-      } else if (STRCMP(key, "FONT") == 0) {
+      } else if (strcmp(key, "FONT") == 0) {
         // in non-GUI fonts are simply ignored
-      } else if (STRCMP(key, "CTERMFG") == 0 || STRCMP(key, "CTERMBG") == 0) {
+      } else if (strcmp(key, "CTERMFG") == 0 || strcmp(key, "CTERMBG") == 0) {
         if (!init || !(hl_table[idx].sg_set & SG_CTERM)) {
           if (!init) {
             hl_table[idx].sg_set |= SG_CTERM;
@@ -1239,7 +1239,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
         if (is_normal_group) {
           normal_fg = hl_table[idx].sg_rgb_fg;
         }
-      } else if (STRCMP(key, "GUIBG") == 0) {
+      } else if (strcmp(key, "GUIBG") == 0) {
         int *indexp = &hl_table[idx].sg_rgb_bg_idx;
 
         if (!init || !(hl_table[idx].sg_set & SG_GUI)) {
@@ -1250,7 +1250,7 @@ void do_highlight(const char *line, const bool forceit, const bool init)
           RgbValue old_color = hl_table[idx].sg_rgb_bg;
           int old_idx = hl_table[idx].sg_rgb_bg_idx;
 
-          if (STRCMP(arg, "NONE") != 0) {
+          if (strcmp(arg, "NONE") != 0) {
             hl_table[idx].sg_rgb_bg = name_to_color(arg, indexp);
           } else {
             hl_table[idx].sg_rgb_bg = -1;
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 686461ce60..7e229d5cb6 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -811,7 +811,7 @@ static int ins_compl_add(char *const str, int len, char *const fname, char *cons
   if (fname != NULL
       && compl_curr_match != NULL
       && compl_curr_match->cp_fname != NULL
-      && STRCMP(fname, compl_curr_match->cp_fname) == 0) {
+      && strcmp(fname, compl_curr_match->cp_fname) == 0) {
     match->cp_fname = compl_curr_match->cp_fname;
   } else if (fname != NULL) {
     match->cp_fname = xstrdup(fname);
@@ -1332,7 +1332,7 @@ static void ins_compl_dictionaries(char_u *dict_start, char_u *pat, int flags, i
       // backticks (for security, the 'dict' option may have been set in
       // a modeline).
       copy_option_part(&dict, buf, LSIZE, ",");
-      if (!thesaurus && STRCMP(buf, "spell") == 0) {
+      if (!thesaurus && strcmp(buf, "spell") == 0) {
         count = -1;
       } else if (vim_strchr(buf, '`') != NULL
                  || expand_wildcards(1, &buf, &count, &files,
@@ -1349,7 +1349,7 @@ static void ins_compl_dictionaries(char_u *dict_start, char_u *pat, int flags, i
       } else {
         ptr = pat;
       }
-      spell_dump_compl(ptr, regmatch.rm_ic, &dir, 0);
+      spell_dump_compl((char *)ptr, regmatch.rm_ic, &dir, 0);
     } else if (count > 0) {  // avoid warning for using "files" uninit
       ins_compl_files(count, files, thesaurus, flags,
                       &regmatch, (char_u *)buf, &dir);
@@ -2588,15 +2588,15 @@ static void get_complete_info(list_T *what_list, dict_T *retdict)
          ; item = TV_LIST_ITEM_NEXT(what_list, item)) {
       const char *what = tv_get_string(TV_LIST_ITEM_TV(item));
 
-      if (STRCMP(what, "mode") == 0) {
+      if (strcmp(what, "mode") == 0) {
         what_flag |= CI_WHAT_MODE;
-      } else if (STRCMP(what, "pum_visible") == 0) {
+      } else if (strcmp(what, "pum_visible") == 0) {
         what_flag |= CI_WHAT_PUM_VISIBLE;
-      } else if (STRCMP(what, "items") == 0) {
+      } else if (strcmp(what, "items") == 0) {
         what_flag |= CI_WHAT_ITEMS;
-      } else if (STRCMP(what, "selected") == 0) {
+      } else if (strcmp(what, "selected") == 0) {
         what_flag |= CI_WHAT_SELECTED;
-      } else if (STRCMP(what, "inserted") == 0) {
+      } else if (strcmp(what, "inserted") == 0) {
         what_flag |= CI_WHAT_INSERTED;
       }
     }
diff --git a/src/nvim/lua/executor.c b/src/nvim/lua/executor.c
index 857e2111d6..78ac051308 100644
--- a/src/nvim/lua/executor.c
+++ b/src/nvim/lua/executor.c
@@ -1044,7 +1044,7 @@ static int nlua_debug(lua_State *lstate)
     if (input.v_type != VAR_STRING
         || input.vval.v_string == NULL
         || *input.vval.v_string == NUL
-        || STRCMP(input.vval.v_string, "cont") == 0) {
+        || strcmp(input.vval.v_string, "cont") == 0) {
       tv_clear(&input);
       return 0;
     }
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index e3d6a7eec8..3051017846 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -499,7 +499,7 @@ static int nlua_iconv(lua_State *lstate)
 
   vimconv_T vimconv;
   vimconv.vc_type = CONV_NONE;
-  convert_setup_ext(&vimconv, from, false, to, false);
+  convert_setup_ext(&vimconv, (char *)from, false, (char *)to, false);
 
   char_u *ret = (char_u *)string_convert(&vimconv, (char *)str, &str_len);
 
diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 971a47f8c9..f3c67e265f 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -834,7 +834,7 @@ static int node_field(lua_State *L)
     do {
       const char *current_field = ts_tree_cursor_current_field_name(&cursor);
 
-      if (current_field != NULL && !STRCMP(field_name, current_field)) {
+      if (current_field != NULL && !strcmp(field_name, current_field)) {
         push_node(L, ts_tree_cursor_current_node(&cursor), 1);  // [table, node]
         lua_rawseti(L, -2, (int)++curr_index);
       }
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 94b432a553..9f169427f5 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -971,12 +971,12 @@ static int get_map_mode(char **cmdp, bool forceit)
 /// Clear all mappings (":mapclear") or abbreviations (":abclear").
 /// "abbr" should be false for mappings, true for abbreviations.
 /// This function used to be called map_clear().
-static void do_mapclear(char *cmdp, char_u *arg, int forceit, int abbr)
+static void do_mapclear(char *cmdp, char *arg, int forceit, int abbr)
 {
   int mode;
   int local;
 
-  local = (STRCMP(arg, "<buffer>") == 0);
+  local = (strcmp(arg, "<buffer>") == 0);
   if (!local && *arg != NUL) {
     emsg(_(e_invarg));
     return;
@@ -1350,7 +1350,7 @@ int ExpandMappings(regmatch_T *regmatch, int *num_file, char ***file)
     char **ptr3 = ptr1 + count;
 
     while (ptr2 < ptr3) {
-      if (STRCMP(*ptr1, *ptr2)) {
+      if (strcmp(*ptr1, *ptr2)) {
         *++ptr1 = *ptr2++;
       } else {
         xfree(*ptr2++);
@@ -2457,13 +2457,13 @@ void ex_unmap(exarg_T *eap)
 /// ":mapclear" and friends.
 void ex_mapclear(exarg_T *eap)
 {
-  do_mapclear(eap->cmd, (char_u *)eap->arg, eap->forceit, false);
+  do_mapclear(eap->cmd, eap->arg, eap->forceit, false);
 }
 
 /// ":abclear" and friends.
 void ex_abclear(exarg_T *eap)
 {
-  do_mapclear(eap->cmd, (char_u *)eap->arg, true, true);
+  do_mapclear(eap->cmd, eap->arg, true, true);
 }
 
 /// Set, tweak, or remove a mapping in a mode. Acts as the implementation for
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index 83b0609052..dc74e23874 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -338,13 +338,13 @@ enc_alias_table[] =
   { NULL,              0 }
 };
 
-// Find encoding "name" in the list of canonical encoding names.
-// Returns -1 if not found.
-static int enc_canon_search(const char_u *name)
+/// Find encoding "name" in the list of canonical encoding names.
+/// Returns -1 if not found.
+static int enc_canon_search(const char *name)
   FUNC_ATTR_PURE
 {
   for (int i = 0; i < IDX_COUNT; i++) {
-    if (STRCMP(name, enc_canon_table[i].name) == 0) {
+    if (strcmp(name, enc_canon_table[i].name) == 0) {
       return i;
     }
   }
@@ -356,7 +356,7 @@ static int enc_canon_search(const char_u *name)
 int enc_canon_props(const char_u *name)
   FUNC_ATTR_PURE
 {
-  int i = enc_canon_search(name);
+  int i = enc_canon_search((char *)name);
   if (i >= 0) {
     return enc_canon_table[i].prop;
   } else if (STRNCMP(name, "2byte-", 6) == 0) {
@@ -379,7 +379,7 @@ int bomb_size(void)
 
   if (curbuf->b_p_bomb && !curbuf->b_p_bin) {
     if (*curbuf->b_p_fenc == NUL
-        || STRCMP(curbuf->b_p_fenc, "utf-8") == 0) {
+        || strcmp(curbuf->b_p_fenc, "utf-8") == 0) {
       n = 3;
     } else if (STRNCMP(curbuf->b_p_fenc, "ucs-2", 5) == 0
                || STRNCMP(curbuf->b_p_fenc, "utf-16", 6) == 0) {
@@ -2115,7 +2115,7 @@ char *enc_canonize(char *enc)
   FUNC_ATTR_NONNULL_RET
 {
   char *p, *s;
-  if (STRCMP(enc, "default") == 0) {
+  if (strcmp(enc, "default") == 0) {
     // Use the default encoding as found by set_init_1().
     return xstrdup(fenc_default);
   }
@@ -2159,12 +2159,12 @@ char *enc_canonize(char *enc)
   }
 
   int i;
-  if (enc_canon_search((char_u *)p) >= 0) {
+  if (enc_canon_search(p) >= 0) {
     // canonical name can be used unmodified
     if (p != r) {
       STRMOVE(r, p);
     }
-  } else if ((i = enc_alias_search((char_u *)p)) >= 0) {
+  } else if ((i = enc_alias_search(p)) >= 0) {
     // alias recognized, get canonical name
     xfree(r);
     r = xstrdup(enc_canon_table[i].name);
@@ -2174,12 +2174,12 @@ char *enc_canonize(char *enc)
 
 /// Search for an encoding alias of "name".
 /// Returns -1 when not found.
-static int enc_alias_search(const char_u *name)
+static int enc_alias_search(const char *name)
 {
   int i;
 
   for (i = 0; enc_alias_table[i].name != NULL; i++) {
-    if (STRCMP(name, enc_alias_table[i].name) == 0) {
+    if (strcmp(name, enc_alias_table[i].name) == 0) {
       return enc_alias_table[i].canon;
     }
   }
@@ -2390,12 +2390,12 @@ static char_u *iconv_string(const vimconv_T *const vcp, char_u *str, size_t slen
 /// @return  FAIL when conversion is not supported, OK otherwise.
 int convert_setup(vimconv_T *vcp, char *from, char *to)
 {
-  return convert_setup_ext(vcp, (char_u *)from, true, (char_u *)to, true);
+  return convert_setup_ext(vcp, from, true, to, true);
 }
 
 /// As convert_setup(), but only when from_unicode_is_utf8 is true will all
 /// "from" unicode charsets be considered utf-8.  Same for "to".
-int convert_setup_ext(vimconv_T *vcp, char_u *from, bool from_unicode_is_utf8, char_u *to,
+int convert_setup_ext(vimconv_T *vcp, char *from, bool from_unicode_is_utf8, char *to,
                       bool to_unicode_is_utf8)
 {
   int from_prop;
@@ -2413,12 +2413,12 @@ int convert_setup_ext(vimconv_T *vcp, char_u *from, bool from_unicode_is_utf8, c
 
   // No conversion when one of the names is empty or they are equal.
   if (from == NULL || *from == NUL || to == NULL || *to == NUL
-      || STRCMP(from, to) == 0) {
+      || strcmp(from, to) == 0) {
     return OK;
   }
 
-  from_prop = enc_canon_props(from);
-  to_prop = enc_canon_props(to);
+  from_prop = enc_canon_props((char_u *)from);
+  to_prop = enc_canon_props((char_u *)to);
   if (from_unicode_is_utf8) {
     from_is_utf8 = from_prop & ENC_UNICODE;
   } else {
@@ -2448,8 +2448,8 @@ int convert_setup_ext(vimconv_T *vcp, char_u *from, bool from_unicode_is_utf8, c
 #ifdef HAVE_ICONV
   else {  // NOLINT(readability/braces)
     // Use iconv() for conversion.
-    vcp->vc_fd = (iconv_t)my_iconv_open(to_is_utf8 ? (char_u *)"utf-8" : to,
-                                        from_is_utf8 ? (char_u *)"utf-8" : from);
+    vcp->vc_fd = (iconv_t)my_iconv_open(to_is_utf8 ? (char_u *)"utf-8" : (char_u *)to,
+                                        from_is_utf8 ? (char_u *)"utf-8" : (char_u *)from);
     if (vcp->vc_fd != (iconv_t)-1) {
       vcp->vc_type = CONV_ICONV;
       vcp->vc_factor = 4;       // could be longer too...
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index e6cb1b79fc..c288703328 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -1110,7 +1110,7 @@ void ml_recover(bool checkext)
     for (idx = 1; idx <= lnum; idx++) {
       // Need to copy one line, fetching the other one may flush it.
       p = xstrdup(ml_get(idx));
-      i = STRCMP(p, ml_get(idx + lnum));
+      i = strcmp(p, ml_get(idx + lnum));
       xfree(p);
       if (i != 0) {
         changed_internal();
@@ -1238,7 +1238,7 @@ int recover_names(char_u *fname, int list, int nr, char **fname_out)
         names[2] = xstrdup(".sw?");
         num_names = 3;
       } else {
-        num_names = recov_file_names(names, fname_res, true);
+        num_names = recov_file_names(names, (char *)fname_res, true);
       }
     } else {                      // check directory dir_name
       if (fname == NULL) {
@@ -1261,7 +1261,7 @@ int recover_names(char_u *fname, int list, int nr, char **fname_out)
           tail = (char_u *)path_tail((char *)fname_res);
           tail = (char_u *)concat_fnames((char *)dir_name, (char *)tail, true);
         }
-        num_names = recov_file_names(names, tail, false);
+        num_names = recov_file_names(names, (char *)tail, false);
         xfree(tail);
       }
     }
@@ -1553,7 +1553,7 @@ static bool swapfile_unchanged(char *fname)
   return ret;
 }
 
-static int recov_file_names(char **names, char_u *path, int prepend_dot)
+static int recov_file_names(char **names, char *path, int prepend_dot)
   FUNC_ATTR_NONNULL_ALL
 {
   int num_names = 0;
@@ -1561,7 +1561,7 @@ static int recov_file_names(char **names, char_u *path, int prepend_dot)
   // May also add the file name with a dot prepended, for swap file in same
   // dir as original file.
   if (prepend_dot) {
-    names[num_names] = modname((char *)path, ".sw?", true);
+    names[num_names] = modname(path, ".sw?", true);
     if (names[num_names] == NULL) {
       return num_names;
     }
@@ -1569,14 +1569,14 @@ static int recov_file_names(char **names, char_u *path, int prepend_dot)
   }
 
   // Form the normal swap file name pattern by appending ".sw?".
-  names[num_names] = concat_fnames((char *)path, ".sw?", false);
+  names[num_names] = concat_fnames(path, ".sw?", false);
   if (num_names >= 1) {     // check if we have the same name twice
-    char_u *p = (char_u *)names[num_names - 1];
+    char *p = names[num_names - 1];
     int i = (int)STRLEN(names[num_names - 1]) - (int)STRLEN(names[num_names]);
     if (i > 0) {
       p += i;               // file name has been expanded to full path
     }
-    if (STRCMP(p, names[num_names]) != 0) {
+    if (strcmp(p, names[num_names]) != 0) {
       num_names++;
     } else {
       xfree(names[num_names]);
@@ -3305,7 +3305,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
                 // when the name differs, need to check the
                 // inode too.
                 expand_env((char *)b0.b0_fname, NameBuff, MAXPATHL);
-                if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
+                if (fnamecmp_ino(buf->b_ffname, NameBuff,
                                  char_to_long(b0.b0_ino))) {
                   differ = true;
                 }
@@ -3314,7 +3314,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
               // The name in the swap file may be
               // "~user/path/file".  Expand it first.
               expand_env((char *)b0.b0_fname, NameBuff, MAXPATHL);
-              if (fnamecmp_ino((char_u *)buf->b_ffname, (char_u *)NameBuff,
+              if (fnamecmp_ino(buf->b_ffname, NameBuff,
                                char_to_long(b0.b0_ino))) {
                 differ = true;
               }
@@ -3519,24 +3519,24 @@ static int b0_magic_wrong(ZERO_BL *b0p)
 ///
 /// @param fname_c  current file name
 /// @param fname_s  file name from swap file
-static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0)
+static bool fnamecmp_ino(char *fname_c, char *fname_s, long ino_block0)
 {
   uint64_t ino_c = 0;               // ino of current file
   uint64_t ino_s;                   // ino of file from swap file
-  char_u buf_c[MAXPATHL];           // full path of fname_c
-  char_u buf_s[MAXPATHL];           // full path of fname_s
+  char buf_c[MAXPATHL];             // full path of fname_c
+  char buf_s[MAXPATHL];             // full path of fname_s
   int retval_c;                     // flag: buf_c valid
   int retval_s;                     // flag: buf_s valid
 
   FileInfo file_info;
-  if (os_fileinfo((char *)fname_c, &file_info)) {
+  if (os_fileinfo(fname_c, &file_info)) {
     ino_c = os_fileinfo_inode(&file_info);
   }
 
   // First we try to get the inode from the file name, because the inode in
   // the swap file may be outdated.  If that fails (e.g. this path is not
   // valid on this machine), use the inode from block 0.
-  if (os_fileinfo((char *)fname_s, &file_info)) {
+  if (os_fileinfo(fname_s, &file_info)) {
     ino_s = os_fileinfo_inode(&file_info);
   } else {
     ino_s = (uint64_t)ino_block0;
@@ -3548,17 +3548,17 @@ static bool fnamecmp_ino(char_u *fname_c, char_u *fname_s, long ino_block0)
 
   // One of the inode numbers is unknown, try a forced vim_FullName() and
   // compare the file names.
-  retval_c = vim_FullName((char *)fname_c, (char *)buf_c, MAXPATHL, true);
-  retval_s = vim_FullName((char *)fname_s, (char *)buf_s, MAXPATHL, true);
+  retval_c = vim_FullName(fname_c, (char *)buf_c, MAXPATHL, true);
+  retval_s = vim_FullName(fname_s, (char *)buf_s, MAXPATHL, true);
   if (retval_c == OK && retval_s == OK) {
-    return STRCMP(buf_c, buf_s) != 0;
+    return strcmp(buf_c, buf_s) != 0;
   }
 
   // Can't compare inodes or file names, guess that the files are different,
   // unless both appear not to exist at all, then compare with the file name
   // in the swap file.
   if (ino_s == 0 && ino_c == 0 && retval_c == FAIL && retval_s == FAIL) {
-    return STRCMP(fname_c, fname_s) != 0;
+    return strcmp(fname_c, fname_s) != 0;
   }
   return true;
 }
diff --git a/src/nvim/menu.c b/src/nvim/menu.c
index 7a08a4d6f6..d8b7e872d9 100644
--- a/src/nvim/menu.c
+++ b/src/nvim/menu.c
@@ -177,7 +177,7 @@ void ex_menu(exarg_T *eap)
     // Change sensitivity of the menu.
     // For the PopUp menu, remove a menu for each mode separately.
     // Careful: menu_enable_recurse() changes menu_path.
-    if (STRCMP(menu_path, "*") == 0) {          // meaning: do all menus
+    if (strcmp(menu_path, "*") == 0) {          // meaning: do all menus
       menu_path = "";
     }
 
@@ -193,7 +193,7 @@ void ex_menu(exarg_T *eap)
     menu_enable_recurse(*root_menu_ptr, menu_path, modes, enable);
   } else if (unmenu) {
     // Delete menu(s).
-    if (STRCMP(menu_path, "*") == 0) {          // meaning: remove all menus
+    if (strcmp(menu_path, "*") == 0) {          // meaning: remove all menus
       menu_path = "";
     }
 
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 63012900df..2d23797bc8 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -321,7 +321,7 @@ bool msg_attr_keep(const char *s, int attr, bool keep, bool multiline)
       || (*s != '<'
           && last_msg_hist != NULL
           && last_msg_hist->msg != NULL
-          && STRCMP(s, last_msg_hist->msg))) {
+          && strcmp(s, last_msg_hist->msg))) {
     add_msg_hist(s, -1, attr, multiline);
   }
 
@@ -978,7 +978,7 @@ static void add_msg_hist_multiattr(const char *s, int len, int attr, bool multil
     while (len > 0 && s[len - 1] == '\n') {
       len--;
     }
-    p->msg = (char_u *)xmemdupz(s, (size_t)len);
+    p->msg = xmemdupz(s, (size_t)len);
   } else {
     p->msg = NULL;
   }
@@ -1028,7 +1028,7 @@ void ex_messages(void *const eap_p)
   struct msg_hist *p;
   int c = 0;
 
-  if (STRCMP(eap->arg, "clear") == 0) {
+  if (strcmp(eap->arg, "clear") == 0) {
     int keep = eap->addr_count == 0 ? 0 : eap->line2;
 
     while (msg_hist_len > keep) {
@@ -1095,7 +1095,7 @@ void ex_messages(void *const eap_p)
       if (kv_size(p->multiattr)) {
         msg_multiattr(p->multiattr, p->kind, false);
       } else if (p->msg != NULL) {
-        msg_attr_keep((char *)p->msg, p->attr, false, p->multiline);
+        msg_attr_keep(p->msg, p->attr, false, p->multiline);
       }
     }
     msg_hist_off = false;
diff --git a/src/nvim/message.h b/src/nvim/message.h
index 4dba26f958..811e621c11 100644
--- a/src/nvim/message.h
+++ b/src/nvim/message.h
@@ -36,7 +36,7 @@ typedef kvec_t(HlMessageChunk) HlMessage;
 /// Message history for `:messages`
 typedef struct msg_hist {
   struct msg_hist *next;  ///< Next message.
-  char_u *msg;            ///< Message text.
+  char *msg;            ///< Message text.
   const char *kind;     ///< Message kind (for msg_ext)
   int attr;               ///< Message highlighting.
   bool multiline;         ///< Multiline message.
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 2fe482d8aa..326469bd38 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -1807,7 +1807,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, long count, bool fixindent)
         return false;
       }
       jump_flags = 0;
-      if (STRCMP(p_mousem, "popup_setpos") == 0) {
+      if (strcmp(p_mousem, "popup_setpos") == 0) {
         // First set the cursor position before showing the popup
         // menu.
         if (VIsual_active) {
@@ -4164,7 +4164,7 @@ void do_nv_ident(int c1, int c2)
 
 /// 'K' normal-mode command. Get the command to lookup the keyword under the
 /// cursor.
-static size_t nv_K_getcmd(cmdarg_T *cap, char_u *kp, bool kp_help, bool kp_ex, char **ptr_arg,
+static size_t nv_K_getcmd(cmdarg_T *cap, char *kp, bool kp_help, bool kp_ex, char **ptr_arg,
                           size_t n, char *buf, size_t buf_size)
 {
   if (kp_help) {
@@ -4201,8 +4201,8 @@ static size_t nv_K_getcmd(cmdarg_T *cap, char_u *kp, bool kp_help, bool kp_ex, c
 
   // When a count is given, turn it into a range.  Is this
   // really what we want?
-  bool isman = (STRCMP(kp, "man") == 0);
-  bool isman_s = (STRCMP(kp, "man -s") == 0);
+  bool isman = (strcmp(kp, "man") == 0);
+  bool isman_s = (strcmp(kp, "man -s") == 0);
   if (cap->count0 != 0 && !(isman || isman_s)) {
     snprintf(buf, buf_size, ".,.+%" PRId64, (int64_t)(cap->count0 - 1));
   }
@@ -4234,12 +4234,12 @@ static size_t nv_K_getcmd(cmdarg_T *cap, char_u *kp, bool kp_help, bool kp_ex, c
 static void nv_ident(cmdarg_T *cap)
 {
   char *ptr = NULL;
-  char_u *p;
+  char *p;
   size_t n = 0;                 // init for GCC
   int cmdchar;
   bool g_cmd;                   // "g" command
   bool tag_cmd = false;
-  char_u *aux_ptr;
+  char *aux_ptr;
 
   if (cap->cmdchar == 'g') {    // "g*", "g#", "g]" and "gCTRL-]"
     cmdchar = cap->nchar;
@@ -4275,8 +4275,8 @@ static void nv_ident(cmdarg_T *cap)
   // Allocate buffer to put the command in.  Inserting backslashes can
   // double the length of the word.  p_kp / curbuf->b_p_kp could be added
   // and some numbers.
-  char_u *kp = *curbuf->b_p_kp == NUL ? p_kp : (char_u *)curbuf->b_p_kp;  // 'keywordprg'
-  bool kp_help = (*kp == NUL || STRCMP(kp, ":he") == 0 || STRCMP(kp, ":help") == 0);
+  char *kp = *curbuf->b_p_kp == NUL ? (char *)p_kp : curbuf->b_p_kp;  // 'keywordprg'
+  bool kp_help = (*kp == NUL || strcmp(kp, ":he") == 0 || strcmp(kp, ":help") == 0);
   if (kp_help && *skipwhite(ptr) == NUL) {
     emsg(_(e_noident));   // found white space only
     return;
@@ -4336,10 +4336,10 @@ static void nv_ident(cmdarg_T *cap)
     ptr = xstrnsave(ptr, n);
     if (kp_ex) {
       // Escape the argument properly for an Ex command
-      p = (char_u *)vim_strsave_fnameescape((const char *)ptr, VSE_NONE);
+      p = vim_strsave_fnameescape((const char *)ptr, VSE_NONE);
     } else {
       // Escape the argument properly for a shell command
-      p = vim_strsave_shellescape((char_u *)ptr, true, true);
+      p = (char *)vim_strsave_shellescape((char_u *)ptr, true, true);
     }
     xfree(ptr);
     char *newbuf = xrealloc(buf, STRLEN(buf) + STRLEN(p) + 1);
@@ -4348,33 +4348,33 @@ static void nv_ident(cmdarg_T *cap)
     xfree(p);
   } else {
     if (cmdchar == '*') {
-      aux_ptr = (char_u *)(p_magic ? "/.*~[^$\\" : "/^$\\");
+      aux_ptr = (p_magic ? "/.*~[^$\\" : "/^$\\");
     } else if (cmdchar == '#') {
-      aux_ptr = (char_u *)(p_magic ? "/?.*~[^$\\" : "/?^$\\");
+      aux_ptr = (p_magic ? "/?.*~[^$\\" : "/?^$\\");
     } else if (tag_cmd) {
       if (curbuf->b_help) {
         // ":help" handles unescaped argument
-        aux_ptr = (char_u *)"";
+        aux_ptr = "";
       } else {
-        aux_ptr = (char_u *)"\\|\"\n[";
+        aux_ptr = "\\|\"\n[";
       }
     } else {
-      aux_ptr = (char_u *)"\\|\"\n*?[";
+      aux_ptr = "\\|\"\n*?[";
     }
 
-    p = (char_u *)buf + STRLEN(buf);
+    p = buf + STRLEN(buf);
     while (n-- > 0) {
       // put a backslash before \ and some others
-      if (vim_strchr((char *)aux_ptr, *ptr) != NULL) {
+      if (vim_strchr(aux_ptr, *ptr) != NULL) {
         *p++ = '\\';
       }
       // When current byte is a part of multibyte character, copy all
       // bytes of that character.
       const size_t len = (size_t)(utfc_ptr2len(ptr) - 1);
       for (size_t i = 0; i < len && n > 0; i++, n--) {
-        *p++ = (char_u)(*ptr++);
+        *p++ = *ptr++;
       }
-      *p++ = (char_u)(*ptr++);
+      *p++ = *ptr++;
     }
     *p = NUL;
   }
diff --git a/src/nvim/option.c b/src/nvim/option.c
index e54e6080f0..dbc2102541 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -156,7 +156,7 @@ typedef struct vimoption {
                            // buffer-local option: global value
   idopt_T indir;                // global option: PV_NONE;
                                 // local option: indirect option index
-  char_u *def_val;         // default values for variable (neovim!!)
+  char *def_val;         // default values for variable (neovim!!)
   LastSet last_set;             // script in which the option was last set
 } vimoption_T;
 
@@ -290,7 +290,7 @@ void set_init_1(bool clean_arg)
         buf[j] = NUL;
         opt_idx = findoption("cdpath");
         if (opt_idx >= 0) {
-          options[opt_idx].def_val = buf;
+          options[opt_idx].def_val = (char *)buf;
           options[opt_idx].flags |= P_DEF_ALLOCED;
         } else {
           xfree(buf);           // cannot happen
@@ -384,7 +384,7 @@ void set_init_1(bool clean_arg)
         && options[opt_idx].var != NULL) {
       p = _(*(char **)options[opt_idx].var);
     } else {
-      p = (char *)option_expand(opt_idx, NULL);
+      p = option_expand(opt_idx, NULL);
     }
     if (p != NULL) {
       p = xstrdup(p);
@@ -392,7 +392,7 @@ void set_init_1(bool clean_arg)
       if (options[opt_idx].flags & P_DEF_ALLOCED) {
         xfree(options[opt_idx].def_val);
       }
-      options[opt_idx].def_val = (char_u *)p;
+      options[opt_idx].def_val = p;
       options[opt_idx].flags |= P_DEF_ALLOCED;
     }
   }
@@ -449,12 +449,12 @@ static void set_option_default(int opt_idx, int opt_flags)
       // freeing and allocating the value.
       if (options[opt_idx].indir != PV_NONE) {
         set_string_option_direct(NULL, opt_idx,
-                                 (char *)options[opt_idx].def_val, opt_flags, 0);
+                                 options[opt_idx].def_val, opt_flags, 0);
       } else {
         if ((opt_flags & OPT_FREE) && (flags & P_ALLOCED)) {
           free_string_option(*(char **)(varp));
         }
-        *(char_u **)varp = options[opt_idx].def_val;
+        *(char **)varp = options[opt_idx].def_val;
         options[opt_idx].flags &= ~P_ALLOCED;
       }
     } else if (flags & P_NUM) {
@@ -533,9 +533,7 @@ static void set_string_default(const char *name, char *val, bool allocated)
       xfree(options[opt_idx].def_val);
     }
 
-    options[opt_idx].def_val = allocated
-        ? (char_u *)val
-        : (char_u *)xstrdup(val);
+    options[opt_idx].def_val = allocated ? val : xstrdup(val);
     options[opt_idx].flags |= P_DEF_ALLOCED;
   }
 }
@@ -579,7 +577,7 @@ void set_number_default(char *name, long val)
 
   opt_idx = findoption(name);
   if (opt_idx >= 0) {
-    options[opt_idx].def_val = (char_u *)(intptr_t)val;
+    options[opt_idx].def_val = (char *)(intptr_t)val;
   }
 }
 
@@ -594,7 +592,7 @@ void free_all_options(void)
         free_string_option(*(char **)options[i].var);
       }
       if (options[i].flags & P_DEF_ALLOCED) {
-        free_string_option((char *)options[i].def_val);
+        free_string_option(options[i].def_val);
       }
     } else if (options[i].var != VAR_WIN && (options[i].flags & P_STRING)) {
       // buffer-local option: free global value
@@ -648,7 +646,7 @@ void set_init_3(void)
     : !(options[idx_sp].flags & P_WAS_SET);
 
   size_t len = 0;
-  char *p = (char *)invocation_path_tail(p_sh, &len);
+  char *p = (char *)invocation_path_tail((char_u *)p_sh, &len);
   p = xstrnsave(p, len);
 
   {
@@ -660,11 +658,11 @@ void set_init_3(void)
         || FNAMECMP(p, "tcsh") == 0) {
       if (do_sp) {
         p_sp = "|& tee";
-        options[idx_sp].def_val = (char_u *)p_sp;
+        options[idx_sp].def_val = p_sp;
       }
       if (do_srr) {
         p_srr = ">&";
-        options[idx_srr].def_val = (char_u *)p_srr;
+        options[idx_srr].def_val = p_srr;
       }
     } else if (FNAMECMP(p, "sh") == 0
                || FNAMECMP(p, "ksh") == 0
@@ -679,11 +677,11 @@ void set_init_3(void)
       // Always use POSIX shell style redirection if we reach this
       if (do_sp) {
         p_sp = "2>&1| tee";
-        options[idx_sp].def_val = (char_u *)p_sp;
+        options[idx_sp].def_val = p_sp;
       }
       if (do_srr) {
         p_srr = ">%s 2>&1";
-        options[idx_srr].def_val = (char_u *)p_srr;
+        options[idx_srr].def_val = p_srr;
       }
     }
     xfree(p);
@@ -747,12 +745,12 @@ void set_title_defaults(void)
   // not need to be contacted.
   idx1 = findoption("title");
   if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
-    options[idx1].def_val = (char_u *)(intptr_t)0;
+    options[idx1].def_val = 0;
     p_title = 0;
   }
   idx1 = findoption("icon");
   if (idx1 >= 0 && !(options[idx1].flags & P_WAS_SET)) {
-    options[idx1].def_val = (char_u *)(intptr_t)0;
+    options[idx1].def_val = 0;
     p_icon = 0;
   }
 }
@@ -1175,7 +1173,7 @@ int do_set(char *arg, int opt_flags)
             }
 
             if (nextchar == '&') {  // set to default val
-              newval = (char *)options[opt_idx].def_val;
+              newval = options[opt_idx].def_val;
               // expand environment variables and ~ since the
               // default value was already expanded, only
               // required when an environment variable was set
@@ -1183,7 +1181,7 @@ int do_set(char *arg, int opt_flags)
               if (newval == NULL) {
                 newval = empty_option;
               } else if (!(options[opt_idx].flags & P_NO_DEF_EXP)) {
-                s = (char *)option_expand(opt_idx, (char_u *)newval);
+                s = option_expand(opt_idx, newval);
                 if (s == NULL) {
                   s = newval;
                 }
@@ -1311,7 +1309,7 @@ int do_set(char *arg, int opt_flags)
               // comma.
               if (!(adding || prepending || removing)
                   || (flags & P_COMMA)) {
-                s = (char *)option_expand(opt_idx, (char_u *)newval);
+                s = option_expand(opt_idx, newval);
                 if (s != NULL) {
                   xfree(newval);
                   newlen = (unsigned)STRLEN(s) + 1;
@@ -1683,7 +1681,7 @@ char_u *find_shada_parameter(int type)
 /// These string options cannot be indirect!
 /// If "val" is NULL expand the current value of the option.
 /// Return pointer to NameBuff, or NULL when not expanded.
-static char_u *option_expand(int opt_idx, char_u *val)
+static char *option_expand(int opt_idx, char *val)
 {
   // if option doesn't need expansion nothing to do
   if (!(options[opt_idx].flags & P_EXPAND) || options[opt_idx].var == NULL) {
@@ -1691,7 +1689,7 @@ static char_u *option_expand(int opt_idx, char_u *val)
   }
 
   if (val == NULL) {
-    val = *(char_u **)options[opt_idx].var;
+    val = *(char **)options[opt_idx].var;
   }
 
   // If val is longer than MAXPATHL no meaningful expansion can be done,
@@ -1704,15 +1702,15 @@ static char_u *option_expand(int opt_idx, char_u *val)
   // Escape spaces when expanding 'tags', they are used to separate file
   // names.
   // For 'spellsuggest' expand after "file:".
-  expand_env_esc(val, (char_u *)NameBuff, MAXPATHL,
+  expand_env_esc((char_u *)val, (char_u *)NameBuff, MAXPATHL,
                  (char_u **)options[opt_idx].var == &p_tags, false,
                  (char_u **)options[opt_idx].var == (char_u **)&p_sps ? (char_u *)"file:" :
                  NULL);
-  if (STRCMP(NameBuff, val) == 0) {   // they are the same
+  if (strcmp(NameBuff, val) == 0) {   // they are the same
     return NULL;
   }
 
-  return (char_u *)NameBuff;
+  return NameBuff;
 }
 
 /// After setting various option values: recompute variables that depend on
@@ -2133,7 +2131,7 @@ static char *set_bool_option(const int opt_idx, char_u *const varp, const int va
 
       // Arabic requires a utf-8 encoding, inform the user if it's not
       // set.
-      if (STRCMP(p_enc, "utf-8") != 0) {
+      if (strcmp(p_enc, "utf-8") != 0) {
         static char *w_arabic = N_("W17: Arabic requires UTF-8, do ':set encoding=utf-8'");
 
         msg_source(HL_ATTR(HLF_W));
@@ -2758,7 +2756,7 @@ int findoption_len(const char *const arg, const size_t len)
       if (STRLEN(options[opt_idx].fullname) == 7) {
         return findoption_len("shada", 5);
       }
-      assert(STRCMP(options[opt_idx].fullname, "viminfofile") == 0);
+      assert(strcmp(options[opt_idx].fullname, "viminfofile") == 0);
       return findoption_len("shadafile", 9);
     }
   }
@@ -3329,7 +3327,7 @@ static int optval_default(vimoption_T *p, char_u *varp)
     return *(int *)varp == (int)(intptr_t)p->def_val;
   }
   // P_STRING
-  return STRCMP(*(char_u **)varp, p->def_val) == 0;
+  return strcmp(*(char **)varp, p->def_val) == 0;
 }
 
 /// Send update to UIs with values of UI relevant options
@@ -5309,7 +5307,7 @@ char_u *get_showbreak_value(win_T *const win)
   if (win->w_p_sbr == NULL || *win->w_p_sbr == NUL) {
     return (char_u *)p_sbr;
   }
-  if (STRCMP(win->w_p_sbr, "NONE") == 0) {
+  if (strcmp(win->w_p_sbr, "NONE") == 0) {
     return (char_u *)empty_option;
   }
   return (char_u *)win->w_p_sbr;
@@ -5455,13 +5453,13 @@ size_t copy_option_part(char **option, char *buf, size_t maxlen, char *sep_chars
 /// Return true when 'shell' has "csh" in the tail.
 int csh_like_shell(void)
 {
-  return strstr(path_tail((char *)p_sh), "csh") != NULL;
+  return strstr(path_tail(p_sh), "csh") != NULL;
 }
 
 /// Return true when 'shell' has "fish" in the tail.
 bool fish_like_shell(void)
 {
-  return strstr(path_tail((char *)p_sh), "fish") != NULL;
+  return strstr(path_tail(p_sh), "fish") != NULL;
 }
 
 /// Return the number of requested sign columns, based on current
@@ -5619,7 +5617,7 @@ static Dictionary vimoption2dict(vimoption_T *opt)
   const char *type;
   Object def;
   // TODO(bfredl): do you even nocp?
-  char_u *def_val = opt->def_val;
+  char_u *def_val = (char_u *)opt->def_val;
   if (opt->flags & P_STRING) {
     type = "string";
     def = CSTR_TO_OBJ(def_val ? (char *)def_val : "");
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index 031a853c0c..5dabc92bfc 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -503,7 +503,7 @@ EXTERN int p_eb;                // 'errorbells'
 EXTERN char_u *p_ef;            // 'errorfile'
 EXTERN char *p_efm;             // 'errorformat'
 EXTERN char *p_gefm;            // 'grepformat'
-EXTERN char_u *p_gp;            // 'grepprg'
+EXTERN char *p_gp;              // 'grepprg'
 EXTERN int p_eol;               ///< 'endofline'
 EXTERN char *p_ei;              // 'eventignore'
 EXTERN int p_et;                ///< 'expandtab'
@@ -684,11 +684,11 @@ EXTERN unsigned ssop_flags;
 #define SSOP_TERMINAL          0x10000
 #define SSOP_SKIP_RTP          0x20000
 
-EXTERN char_u *p_sh;            // 'shell'
+EXTERN char *p_sh;              // 'shell'
 EXTERN char_u *p_shcf;          // 'shellcmdflag'
 EXTERN char *p_sp;              // 'shellpipe'
 EXTERN char_u *p_shq;           // 'shellquote'
-EXTERN char_u *p_sxq;           // 'shellxquote'
+EXTERN char *p_sxq;             // 'shellxquote'
 EXTERN char_u *p_sxe;           // 'shellxescape'
 EXTERN char *p_srr;             // 'shellredir'
 EXTERN int p_stmp;              // 'shelltemp'
diff --git a/src/nvim/optionstr.c b/src/nvim/optionstr.c
index 8581dae7a3..9d21603754 100644
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -683,7 +683,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
   } else if (varp == &p_bex || varp == &p_pm) {  // 'backupext' and 'patchmode'
-    if (STRCMP(*p_bex == '.' ? p_bex + 1 : p_bex,
+    if (strcmp(*p_bex == '.' ? p_bex + 1 : p_bex,
                *p_pm == '.' ? p_pm + 1 : p_pm) == 0) {
       errmsg = e_backupext_and_patchmode_are_equal;
     }
@@ -731,7 +731,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
       }
     }
   } else if (varp == &p_hl) {  // 'highlight'
-    if (STRCMP(*varp, HIGHLIGHT_INIT) != 0) {
+    if (strcmp(*varp, HIGHLIGHT_INIT) != 0) {
       errmsg = e_unsupportedoption;
     }
   } else if (varp == &p_jop) {  // 'jumpoptions'
@@ -823,13 +823,13 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     }
 
     if (errmsg == NULL) {
-      // canonize the value, so that STRCMP() can be used on it
+      // canonize the value, so that strcmp() can be used on it
       p = enc_canonize(*varp);
       xfree(*varp);
       *varp = p;
       if (varp == &p_enc) {
         // only encoding=utf-8 allowed
-        if (STRCMP(p_enc, "utf-8") != 0) {
+        if (strcmp(p_enc, "utf-8") != 0) {
           errmsg = e_unsupportedoption;
         } else {
           spell_reload();
@@ -1358,7 +1358,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     } else {
       if (opt_strings_flags(ve, p_ve_values, flags, true) != OK) {
         errmsg = e_invarg;
-      } else if (STRCMP(p_ve, oldval) != 0) {
+      } else if (strcmp(p_ve, oldval) != 0) {
         // Recompute cursor position in case the new 've' setting
         // changes something.
         validate_virtcol();
@@ -1393,7 +1393,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
-      value_changed = STRCMP(oldval, *varp) != 0;
+      value_changed = strcmp(oldval, *varp) != 0;
 
       // Since we check the value, there is no need to set P_INSECURE,
       // even when the value comes from a modeline.
@@ -1403,7 +1403,7 @@ char *did_set_string_option(int opt_idx, char **varp, char *oldval, char *errbuf
     if (!valid_filetype(*varp)) {
       errmsg = e_invarg;
     } else {
-      value_changed = STRCMP(oldval, *varp) != 0;
+      value_changed = strcmp(oldval, *varp) != 0;
 
       // Since we check the value, there is no need to set P_INSECURE,
       // even when the value comes from a modeline.
diff --git a/src/nvim/os/shell.c b/src/nvim/os/shell.c
index 25f51f89a9..cf66899493 100644
--- a/src/nvim/os/shell.c
+++ b/src/nvim/os/shell.c
@@ -129,7 +129,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
 
   bool is_fish_shell =
 #if defined(UNIX)
-    STRNCMP(invocation_path_tail(p_sh, NULL), "fish", 4) == 0;
+    STRNCMP(invocation_path_tail((char_u *)p_sh, NULL), "fish", 4) == 0;
 #else
     false;
 #endif
@@ -182,14 +182,14 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
       && *(pat[0] + len - 1) == '`') {
     shell_style = STYLE_BT;
   } else if ((len = STRLEN(p_sh)) >= 3) {
-    if (STRCMP(p_sh + len - 3, "csh") == 0) {
+    if (strcmp(p_sh + len - 3, "csh") == 0) {
       shell_style = STYLE_GLOB;
-    } else if (STRCMP(p_sh + len - 3, "zsh") == 0) {
+    } else if (strcmp(p_sh + len - 3, "zsh") == 0) {
       shell_style = STYLE_PRINT;
     }
   }
   if (shell_style == STYLE_ECHO
-      && strstr(path_tail((char *)p_sh), "sh") != NULL) {
+      && strstr(path_tail(p_sh), "sh") != NULL) {
     shell_style = STYLE_VIMGLOB;
   }
 
@@ -555,11 +555,11 @@ notfound:
 char **shell_build_argv(const char *cmd, const char *extra_args)
   FUNC_ATTR_NONNULL_RET
 {
-  size_t argc = tokenize(p_sh, NULL) + (cmd ? tokenize(p_shcf, NULL) : 0);
+  size_t argc = tokenize((char_u *)p_sh, NULL) + (cmd ? tokenize(p_shcf, NULL) : 0);
   char **rv = xmalloc((argc + 4) * sizeof(*rv));
 
   // Split 'shell'
-  size_t i = tokenize(p_sh, rv);
+  size_t i = tokenize((char_u *)p_sh, rv);
 
   if (extra_args) {
     rv[i++] = xstrdup(extra_args);        // Push a copy of `extra_args`
@@ -700,7 +700,7 @@ int call_shell(char_u *cmd, ShellOpts opts, char_u *extra_shell_arg)
 
   if (p_verbose > 3) {
     verbose_enter();
-    smsg(_("Executing command: \"%s\""), cmd == NULL ? p_sh : cmd);
+    smsg(_("Executing command: \"%s\""), cmd == NULL ? p_sh : (char *)cmd);
     msg_putchar('\n');
     verbose_leave();
   }
@@ -1316,7 +1316,7 @@ static char *shell_xescape_xquote(const char *cmd)
   }
 
   const char *ecmd = cmd;
-  if (*p_sxe != NUL && STRCMP(p_sxq, "(") == 0) {
+  if (*p_sxe != NUL && strcmp(p_sxq, "(") == 0) {
     ecmd = (char *)vim_strsave_escaped_ext((char_u *)cmd, p_sxe, '^', false);
   }
   size_t ncmd_size = strlen(ecmd) + STRLEN(p_sxq) * 2 + 1;
@@ -1324,9 +1324,9 @@ static char *shell_xescape_xquote(const char *cmd)
 
   // When 'shellxquote' is ( append ).
   // When 'shellxquote' is "( append )".
-  if (STRCMP(p_sxq, "(") == 0) {
+  if (strcmp(p_sxq, "(") == 0) {
     vim_snprintf(ncmd, ncmd_size, "(%s)", ecmd);
-  } else if (STRCMP(p_sxq, "\"(") == 0) {
+  } else if (strcmp(p_sxq, "\"(") == 0) {
     vim_snprintf(ncmd, ncmd_size, "\"(%s)\"", ecmd);
   } else {
     vim_snprintf(ncmd, ncmd_size, "%s%s%s", p_sxq, ecmd, p_sxq);
diff --git a/src/nvim/os/users.c b/src/nvim/os/users.c
index bd34e917b2..0c662e8843 100644
--- a/src/nvim/os/users.c
+++ b/src/nvim/os/users.c
@@ -93,7 +93,7 @@ int os_get_usernames(garray_T *users)
       for (i = 0; i < users->ga_len; i++) {
         char *local_user = ((char **)users->ga_data)[i];
 
-        if (STRCMP(local_user, user_env) == 0) {
+        if (strcmp(local_user, user_env) == 0) {
           break;
         }
       }
@@ -208,14 +208,14 @@ char *get_users(expand_T *xp, int idx)
 /// @return 0 if name does not match any user name.
 ///         1 if name partially matches the beginning of a user name.
 ///         2 is name fully matches a user name.
-int match_user(char_u *name)
+int match_user(char *name)
 {
   int n = (int)STRLEN(name);
   int result = 0;
 
   init_users();
   for (int i = 0; i < ga_users.ga_len; i++) {
-    if (STRCMP(((char_u **)ga_users.ga_data)[i], name) == 0) {
+    if (strcmp(((char **)ga_users.ga_data)[i], name) == 0) {
       return 2;       // full match
     }
     if (STRNCMP(((char_u **)ga_users.ga_data)[i], name, n) == 0) {
diff --git a/src/nvim/profile.c b/src/nvim/profile.c
index cded231c85..9957224351 100644
--- a/src/nvim/profile.c
+++ b/src/nvim/profile.c
@@ -291,23 +291,23 @@ void ex_profile(exarg_T *eap)
     set_vim_var_nr(VV_PROFILING, 1L);
   } else if (do_profiling == PROF_NONE) {
     emsg(_("E750: First use \":profile start {fname}\""));
-  } else if (STRCMP(eap->arg, "stop") == 0) {
+  } else if (strcmp(eap->arg, "stop") == 0) {
     profile_dump();
     do_profiling = PROF_NONE;
     set_vim_var_nr(VV_PROFILING, 0L);
     profile_reset();
-  } else if (STRCMP(eap->arg, "pause") == 0) {
+  } else if (strcmp(eap->arg, "pause") == 0) {
     if (do_profiling == PROF_YES) {
       pause_time = profile_start();
     }
     do_profiling = PROF_PAUSED;
-  } else if (STRCMP(eap->arg, "continue") == 0) {
+  } else if (strcmp(eap->arg, "continue") == 0) {
     if (do_profiling == PROF_PAUSED) {
       pause_time = profile_end(pause_time);
       profile_set_wait(profile_add(profile_get_wait(), pause_time));
     }
     do_profiling = PROF_YES;
-  } else if (STRCMP(eap->arg, "dump") == 0) {
+  } else if (strcmp(eap->arg, "dump") == 0) {
     profile_dump();
   } else {
     // The rest is similar to ":breakadd".
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index cd2dd4b89c..0dcbcf56b1 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1098,7 +1098,7 @@ static int qf_init_ext(qf_info_T *qi, int qf_idx, const char *restrict efile, bu
 
   // If the errorformat didn't change between calls, then reuse the previously
   // parsed values.
-  if (last_efm == NULL || (STRCMP(last_efm, efm) != 0)) {
+  if (last_efm == NULL || (strcmp(last_efm, efm) != 0)) {
     // free the previously parsed data
     XFREE_CLEAR(last_efm);
     free_efm_list(&fmt_first);
@@ -2085,7 +2085,7 @@ static int qf_get_fnum(qf_list_T *qfl, char *directory, char *fname)
   }
 
   if (qf_last_bufname != NULL
-      && STRCMP(bufname, qf_last_bufname) == 0
+      && strcmp(bufname, qf_last_bufname) == 0
       && bufref_valid(&qf_last_bufref)) {
     buf = qf_last_bufref.br_buf;
     xfree(ptr);
@@ -4180,8 +4180,7 @@ int grep_internal(cmdidx_T cmdidx)
           || cmdidx == CMD_lgrep
           || cmdidx == CMD_grepadd
           || cmdidx == CMD_lgrepadd)
-         && STRCMP("internal",
-                   *curbuf->b_p_gp == NUL ? p_gp : (char_u *)curbuf->b_p_gp) == 0;
+         && strcmp("internal", *curbuf->b_p_gp == NUL ? p_gp : curbuf->b_p_gp) == 0;
 }
 
 // Return the make/grep autocmd name.
@@ -5417,7 +5416,7 @@ static int vgr_process_files(win_T *wp, qf_info_T *qi, vgr_args_T *cmd_args, boo
           // directory we jumped to below.
           if (buf == *first_match_buf
               && *target_dir == NULL
-              && STRCMP(dirname_start, dirname_now) != 0) {
+              && strcmp(dirname_start, dirname_now) != 0) {
             *target_dir = xstrdup(dirname_now);
           }
 
@@ -5540,7 +5539,7 @@ static void restore_start_dir(char *dirname_start)
   char *dirname_now = xmalloc(MAXPATHL);
 
   os_dirname((char_u *)dirname_now, MAXPATHL);
-  if (STRCMP(dirname_start, dirname_now) != 0) {
+  if (strcmp(dirname_start, dirname_now) != 0) {
     // If the directory has changed, change it back by building up an
     // appropriate ex command and executing it.
     exarg_T ea = {
@@ -6498,7 +6497,7 @@ static int qf_setprop_curidx(qf_info_T *qi, qf_list_T *qfl, const dictitem_T *di
   // If the specified index is '$', then use the last entry
   if (di->di_tv.v_type == VAR_STRING
       && di->di_tv.vval.v_string != NULL
-      && STRCMP(di->di_tv.vval.v_string, "$") == 0) {
+      && strcmp(di->di_tv.vval.v_string, "$") == 0) {
     newidx = qfl->qf_count;
   } else {
     // Otherwise use the specified index
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index a38f743081..b43db2256f 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -651,7 +651,7 @@ static bool path_is_after(char *buf, size_t buflen)
   // "after" dir in SOME codepaths not not in ALL codepaths.
   return buflen >= 5
          && (!(buflen >= 6) || vim_ispathsep(buf[buflen - 6]))
-         && STRCMP(buf + buflen - 5, "after") == 0;
+         && strcmp(buf + buflen - 5, "after") == 0;
 }
 
 RuntimeSearchPath runtime_search_path_build(void)
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 312c30e4a9..1c29689487 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -752,7 +752,7 @@ static int open_shada_file_for_reading(const char *const fname, ShaDaReadDef *sd
     return error;
   }
 
-  assert(STRCMP(p_enc, "utf-8") == 0);
+  assert(strcmp(p_enc, "utf-8") == 0);
 
   return 0;
 }
@@ -1313,9 +1313,9 @@ static void shada_read(ShaDaReadDef *const sd_reader, const int flags)
         MERGE_JUMPS(curwin->w_jumplistlen, curwin->w_jumplist, xfmark_T,
                     fmark.timestamp, fmark.mark, cur_entry,
                     (buf == NULL
-                       ? (jl_entry.fname != NULL
-                          && STRCMP(fm.fname, jl_entry.fname) == 0)
-                       : fm.fmark.fnum == jl_entry.fmark.fnum),
+                     ? (jl_entry.fname != NULL
+                        && strcmp(fm.fname, jl_entry.fname) == 0)
+                     : fm.fmark.fnum == jl_entry.fmark.fnum),
                     free_xfmark, SDE_TO_XFMARK, ADJUST_IDX, DUMMY_AFTERFREE);
 #undef SDE_TO_XFMARK
 #undef ADJUST_IDX
diff --git a/src/nvim/sign.c b/src/nvim/sign.c
index 7d931a853b..ed546cf303 100644
--- a/src/nvim/sign.c
+++ b/src/nvim/sign.c
@@ -86,7 +86,7 @@ static signgroup_T *sign_group_ref(const char *groupname)
     STRCPY(group->sg_name, groupname);
     group->sg_refcount = 1;
     group->sg_next_sign_id = 1;
-    hash_add_item(&sg_table, hi, group->sg_name, hash);
+    hash_add_item(&sg_table, hi, (char_u *)group->sg_name, hash);
   } else {
     // existing group
     group = HI2SG(hi);
@@ -119,10 +119,10 @@ static void sign_group_unref(char *groupname)
 /// or in a named group. If 'group' is '*', then the sign is part of the group.
 static bool sign_in_group(sign_entry_T *sign, const char *group)
 {
-  return ((group != NULL && STRCMP(group, "*") == 0)
+  return ((group != NULL && strcmp(group, "*") == 0)
           || (group == NULL && sign->se_group == NULL)
           || (group != NULL && sign->se_group != NULL
-              && STRCMP(group, sign->se_group->sg_name) == 0));
+              && strcmp(group, sign->se_group->sg_name) == 0));
 }
 
 /// Get the next free sign identifier in the specified group
@@ -784,7 +784,7 @@ static int sign_cmd_idx(char *begin_cmd, char *end_cmd)
 
   *end_cmd = NUL;
   for (idx = 0;; idx++) {
-    if (cmds[idx] == NULL || STRCMP(begin_cmd, cmds[idx]) == 0) {
+    if (cmds[idx] == NULL || strcmp(begin_cmd, cmds[idx]) == 0) {
       break;
     }
   }
@@ -801,7 +801,7 @@ static sign_T *sign_find(const char *name, sign_T **sp_prev)
     *sp_prev = NULL;
   }
   for (sp = first_sign; sp != NULL; sp = sp->sn_next) {
-    if (STRCMP(sp->sn_name, name) == 0) {
+    if (strcmp(sp->sn_name, name) == 0) {
       break;
     }
     if (sp_prev != NULL) {
@@ -1034,7 +1034,7 @@ static int sign_place(int *sign_id, const char *sign_group, const char *sign_nam
   }
 
   for (sp = first_sign; sp != NULL; sp = sp->sn_next) {
-    if (STRCMP(sp->sn_name, sign_name) == 0) {
+    if (strcmp(sp->sn_name, sign_name) == 0) {
       break;
     }
   }
diff --git a/src/nvim/sign_defs.h b/src/nvim/sign_defs.h
index f1184202e7..16e783aab7 100644
--- a/src/nvim/sign_defs.h
+++ b/src/nvim/sign_defs.h
@@ -10,9 +10,9 @@
 
 // Sign group
 typedef struct signgroup_S {
-  uint16_t sg_refcount;      // number of signs in this group
-  int sg_next_sign_id;  // next sign id for this group
-  char_u sg_name[1];       // sign group name
+  uint16_t sg_refcount;   // number of signs in this group
+  int sg_next_sign_id;    // next sign id for this group
+  char sg_name[1];        // sign group name
 } signgroup_T;
 
 // Macros to get the sign group structure from the group name
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 7f07d2ff2c..4acefd9d64 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -1559,7 +1559,7 @@ static void spell_load_lang(char_u *lang)
 // use "latin1" for "latin9".  And limit to 60 characters (just in case).
 char_u *spell_enc(void)
 {
-  if (STRLEN(p_enc) < 60 && STRCMP(p_enc, "iso-8859-15") != 0) {
+  if (STRLEN(p_enc) < 60 && strcmp(p_enc, "iso-8859-15") != 0) {
     return (char_u *)p_enc;
   }
   return (char_u *)"latin1";
@@ -1843,19 +1843,19 @@ char *did_set_spelllang(win_T *wp)
 {
   garray_T ga;
   char *splp;
-  char_u *region;
-  char_u region_cp[3];
+  char *region;
+  char region_cp[3];
   bool filename;
   int region_mask;
   slang_T *slang;
   int c;
-  char_u lang[MAXWLEN + 1];
-  char_u spf_name[MAXPATHL];
+  char lang[MAXWLEN + 1];
+  char spf_name[MAXPATHL];
   int len;
-  char_u *p;
+  char *p;
   int round;
   char *spf;
-  char_u *use_region = NULL;
+  char *use_region = NULL;
   bool dont_use_region = false;
   bool nobreak = false;
   langp_T *lp, *lp2;
@@ -1894,7 +1894,7 @@ char *did_set_spelllang(win_T *wp)
       continue;
     }
 
-    if (STRCMP(lang, "cjk") == 0) {
+    if (strcmp(lang, "cjk") == 0) {
       wp->w_s->b_cjk = 1;
       continue;
     }
@@ -1906,7 +1906,7 @@ char *did_set_spelllang(win_T *wp)
       filename = true;
 
       // Locate a region and remove it from the file name.
-      p = (char_u *)vim_strchr(path_tail((char *)lang), '_');
+      p = vim_strchr(path_tail((char *)lang), '_');
       if (p != NULL && ASCII_ISALPHA(p[1]) && ASCII_ISALPHA(p[2])
           && !ASCII_ISALPHA(p[3])) {
         STRLCPY(region_cp, p + 1, 3);
@@ -1943,7 +1943,7 @@ char *did_set_spelllang(win_T *wp)
     if (region != NULL) {
       // If the region differs from what was used before then don't
       // use it for 'spellfile'.
-      if (use_region != NULL && STRCMP(region, use_region) != 0) {
+      if (use_region != NULL && strcmp(region, use_region) != 0) {
         dont_use_region = true;
       }
       use_region = region;
@@ -1954,7 +1954,7 @@ char *did_set_spelllang(win_T *wp)
       if (filename) {
         (void)spell_load_file((char *)lang, (char *)lang, NULL, false);
       } else {
-        spell_load_lang(lang);
+        spell_load_lang((char_u *)lang);
         // SpellFileMissing autocommands may do anything, including
         // destroying the buffer we are using...
         if (!bufref_valid(&bufref)) {
@@ -1972,7 +1972,7 @@ char *did_set_spelllang(win_T *wp)
         region_mask = REGION_ALL;
         if (!filename && region != NULL) {
           // find region in sl_regions
-          c = find_region(slang->sl_regions, region);
+          c = find_region(slang->sl_regions, (char_u *)region);
           if (c == REGION_ALL) {
             if (slang->sl_add) {
               if (*slang->sl_regions != NUL) {
@@ -2015,7 +2015,7 @@ char *did_set_spelllang(win_T *wp)
       if (int_wordlist == NULL) {
         continue;
       }
-      int_wordlist_spl(spf_name);
+      int_wordlist_spl((char_u *)spf_name);
     } else {
       // One entry in 'spellfile'.
       copy_option_part(&spf, (char *)spf_name, MAXPATHL - 5, ",");
@@ -2023,9 +2023,9 @@ char *did_set_spelllang(win_T *wp)
 
       // If it was already found above then skip it.
       for (c = 0; c < ga.ga_len; c++) {
-        p = (char_u *)LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
+        p = LANGP_ENTRY(ga, c)->lp_slang->sl_fname;
         if (p != NULL
-            && path_full_compare((char *)spf_name, (char *)p, false, true) == kEqualFiles) {
+            && path_full_compare((char *)spf_name, p, false, true) == kEqualFiles) {
           break;
         }
       }
@@ -2049,7 +2049,7 @@ char *did_set_spelllang(win_T *wp)
         STRCPY(lang, "internal wordlist");
       } else {
         STRLCPY(lang, path_tail((char *)spf_name), MAXWLEN + 1);
-        p = (char_u *)vim_strchr((char *)lang, '.');
+        p = vim_strchr((char *)lang, '.');
         if (p != NULL) {
           *p = NUL;             // truncate at ".encoding.add"
         }
@@ -2066,7 +2066,7 @@ char *did_set_spelllang(win_T *wp)
       region_mask = REGION_ALL;
       if (use_region != NULL && !dont_use_region) {
         // find region in sl_regions
-        c = find_region(slang->sl_regions, use_region);
+        c = find_region(slang->sl_regions, (char_u *)use_region);
         if (c != REGION_ALL) {
           region_mask = 1 << c;
         } else if (*slang->sl_regions != NUL) {
@@ -3171,23 +3171,23 @@ void ex_spelldump(exarg_T *eap)
 /// @param ic  ignore case
 /// @param dir  direction for adding matches
 /// @param dumpflags_arg  DUMPFLAG_*
-void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
+void spell_dump_compl(char *pat, int ic, Direction *dir, int dumpflags_arg)
 {
   langp_T *lp;
   slang_T *slang;
   idx_T arridx[MAXWLEN];
   int curi[MAXWLEN];
-  char_u word[MAXWLEN];
+  char word[MAXWLEN];
   int c;
-  char_u *byts;
+  char *byts;
   idx_T *idxs;
   linenr_T lnum = 0;
   int depth;
   int n;
   int flags;
-  char_u *region_names = NULL;         // region names being used
+  char *region_names = NULL;         // region names being used
   bool do_region = true;                    // dump region names and numbers
-  char_u *p;
+  char *p;
   int dumpflags = dumpflags_arg;
   int patlen;
 
@@ -3197,11 +3197,11 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
     if (ic) {
       dumpflags |= DUMPFLAG_ICASE;
     } else {
-      n = captype(pat, NULL);
+      n = captype((char_u *)pat, NULL);
       if (n == WF_ONECAP) {
         dumpflags |= DUMPFLAG_ONECAP;
       } else if (n == WF_ALLCAP
-                 && (int)STRLEN(pat) > utfc_ptr2len((char *)pat)) {
+                 && (int)STRLEN(pat) > utfc_ptr2len(pat)) {
         dumpflags |= DUMPFLAG_ALLCAP;
       }
     }
@@ -3211,11 +3211,11 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
   // regions or none at all.
   for (int lpi = 0; lpi < curwin->w_s->b_langp.ga_len; lpi++) {
     lp = LANGP_ENTRY(curwin->w_s->b_langp, lpi);
-    p = lp->lp_slang->sl_regions;
+    p = (char *)lp->lp_slang->sl_regions;
     if (p[0] != 0) {
       if (region_names == NULL) {           // first language with regions
         region_names = p;
-      } else if (STRCMP(region_names, p) != 0) {
+      } else if (strcmp(region_names, p) != 0) {
         do_region = false;                  // region names are different
         break;
       }
@@ -3257,11 +3257,11 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
     for (int round = 1; round <= 2; round++) {
       if (round == 1) {
         dumpflags &= ~DUMPFLAG_KEEPCASE;
-        byts = slang->sl_fbyts;
+        byts = (char *)slang->sl_fbyts;
         idxs = slang->sl_fidxs;
       } else {
         dumpflags |= DUMPFLAG_KEEPCASE;
-        byts = slang->sl_kbyts;
+        byts = (char *)slang->sl_kbyts;
         idxs = slang->sl_kidxs;
       }
       if (byts == NULL) {
@@ -3281,7 +3281,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
           // Do one more byte at this node.
           n = arridx[depth] + curi[depth];
           curi[depth]++;
-          c = byts[n];
+          c = (uint8_t)byts[n];
           if (c == 0 || depth >= MAXWLEN - 1) {
             // End of word or reached maximum length, deal with the
             // word.
@@ -3304,7 +3304,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
               // when it's the first one.
               c = (int)((unsigned)flags >> 24);
               if (c == 0 || curi[depth] == 2) {
-                dump_word(slang, word, pat, dir,
+                dump_word(slang, (char_u *)word, (char_u *)pat, dir,
                           dumpflags, flags, lnum);
                 if (pat == NULL) {
                   lnum++;
@@ -3313,13 +3313,13 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
 
               // Apply the prefix, if there is one.
               if (c != 0) {
-                lnum = dump_prefixes(slang, word, pat, dir,
+                lnum = dump_prefixes(slang, (char_u *)word, (char_u *)pat, dir,
                                      dumpflags, flags, lnum);
               }
             }
           } else {
             // Normal char, go one level deeper.
-            word[depth++] = (char_u)c;
+            word[depth++] = (char)c;
             arridx[depth] = idxs[n];
             curi[depth] = 1;
 
@@ -3331,7 +3331,7 @@ void spell_dump_compl(char_u *pat, int ic, Direction *dir, int dumpflags_arg)
             // ignore case...
             assert(depth >= 0);
             if (depth <= patlen
-                && mb_strnicmp((char *)word, (char *)pat, (size_t)depth) != 0) {
+                && mb_strnicmp((char *)word, pat, (size_t)depth) != 0) {
               depth--;
             }
           }
@@ -3613,7 +3613,7 @@ char *did_set_spell_option(bool is_spellfile)
   if (is_spellfile) {
     int l = (int)STRLEN(curwin->w_s->b_p_spf);
     if (l > 0
-        && (l < 4 || STRCMP(curwin->w_s->b_p_spf + l - 4, ".add") != 0)) {
+        && (l < 4 || strcmp(curwin->w_s->b_p_spf + l - 4, ".add") != 0)) {
       errmsg = e_invarg;
     }
   }
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index e6e56d615c..2858942d0b 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -355,12 +355,12 @@ struct affentry_S {
 
 // Affix header from ".aff" file.  Used for af_pref and af_suff.
 typedef struct affheader_S {
-  char_u ah_key[AH_KEY_LEN];    // key for hashtab == name of affix
+  char ah_key[AH_KEY_LEN];      // key for hashtab == name of affix
   unsigned ah_flag;             // affix name as number, uses "af_flagtype"
   int ah_newID;                 // prefix ID after renumbering; 0 if not used
   int ah_combine;               // suffix may combine with prefix
   int ah_follows;               // another affix block should be following
-  affentry_T *ah_first;        // first affix entry
+  affentry_T *ah_first;         // first affix entry
 } affheader_T;
 
 #define HI2AH(hi)   ((affheader_T *)(hi)->hi_key)
@@ -2102,7 +2102,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
       }
       items[itemcnt++] = p;
       // A few items have arbitrary text argument, don't split them.
-      if (itemcnt == 2 && spell_info_item((char_u *)items[0])) {
+      if (itemcnt == 2 && spell_info_item(items[0])) {
         while ((uint8_t)(*p) >= ' ' || *p == TAB) {  // skip until CR/NL
           p++;
         }
@@ -2130,11 +2130,11 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         spin->si_conv.vc_fail = true;
       } else if (is_aff_rule(items, itemcnt, "FLAG", 2)
                  && aff->af_flagtype == AFT_CHAR) {
-        if (STRCMP(items[1], "long") == 0) {
+        if (strcmp(items[1], "long") == 0) {
           aff->af_flagtype = AFT_LONG;
-        } else if (STRCMP(items[1], "num") == 0) {
+        } else if (strcmp(items[1], "num") == 0) {
           aff->af_flagtype = AFT_NUM;
-        } else if (STRCMP(items[1], "caplong") == 0) {
+        } else if (strcmp(items[1], "caplong") == 0) {
           aff->af_flagtype = AFT_CAPLONG;
         } else {
           smsg(_("Invalid value for FLAG in %s line %d: %s"),
@@ -2154,7 +2154,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           smsg(_("FLAG after using flags in %s line %d: %s"),
                fname, lnum, items[1]);
         }
-      } else if (spell_info_item((char_u *)items[0]) && itemcnt > 1) {
+      } else if (spell_info_item(items[0]) && itemcnt > 1) {
         p = getroom(spin,
                     (spin->si_info == NULL ? 0 : STRLEN(spin->si_info))
                     + STRLEN(items[0])
@@ -2299,8 +2299,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 
         // Only add the couple if it isn't already there.
         for (i = 0; i < gap->ga_len - 1; i += 2) {
-          if (STRCMP(((char **)(gap->ga_data))[i], items[1]) == 0
-              && STRCMP(((char **)(gap->ga_data))[i + 1], items[2]) == 0) {
+          if (strcmp(((char **)(gap->ga_data))[i], items[1]) == 0
+              && strcmp(((char **)(gap->ga_data))[i + 1], items[2]) == 0) {
             break;
           }
         }
@@ -2324,8 +2324,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         aff->af_pfxpostpone = true;
       } else if (is_aff_rule(items, itemcnt, "IGNOREEXTRA", 1)) {
         aff->af_ignoreextra = true;
-      } else if ((STRCMP(items[0], "PFX") == 0
-                  || STRCMP(items[0], "SFX") == 0)
+      } else if ((strcmp(items[0], "PFX") == 0
+                  || strcmp(items[0], "SFX") == 0)
                  && aff_todo == 0
                  && itemcnt >= 4) {
         int lasti = 4;
@@ -2375,14 +2375,14 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
                  fname, lnum, items[1]);
           }
           STRCPY(cur_aff->ah_key, items[1]);
-          hash_add(tp, cur_aff->ah_key);
+          hash_add(tp, (char_u *)cur_aff->ah_key);
 
           cur_aff->ah_combine = (*items[2] == 'Y');
         }
 
         // Check for the "S" flag, which apparently means that another
         // block with the same affix name is following.
-        if (itemcnt > lasti && STRCMP(items[lasti], "S") == 0) {
+        if (itemcnt > lasti && strcmp(items[lasti], "S") == 0) {
           lasti++;
           cur_aff->ah_follows = true;
         } else {
@@ -2398,7 +2398,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           smsg(_(e_afftrailing), fname, lnum, items[lasti]);
         }
 
-        if (STRCMP(items[2], "Y") != 0 && STRCMP(items[2], "N") != 0) {
+        if (strcmp(items[2], "Y") != 0 && strcmp(items[2], "N") != 0) {
           smsg(_("Expected Y or N in %s line %d: %s"),
                fname, lnum, items[2]);
         }
@@ -2421,10 +2421,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         }
 
         aff_todo = atoi((char *)items[3]);
-      } else if ((STRCMP(items[0], "PFX") == 0
-                  || STRCMP(items[0], "SFX") == 0)
+      } else if ((strcmp(items[0], "PFX") == 0
+                  || strcmp(items[0], "SFX") == 0)
                  && aff_todo > 0
-                 && STRCMP(cur_aff->ah_key, items[1]) == 0
+                 && strcmp(cur_aff->ah_key, items[1]) == 0
                  && itemcnt >= 5) {
         affentry_T *aff_entry;
         bool upper = false;
@@ -2434,7 +2434,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         // mean mistakes go unnoticed.  Require a comment-starter.
         // Hunspell uses a "-" item.
         if (itemcnt > lasti && *items[lasti] != '#'
-            && (STRCMP(items[lasti], "-") != 0
+            && (strcmp(items[lasti], "-") != 0
                 || itemcnt != lasti + 1)) {
           smsg(_(e_afftrailing), fname, lnum, items[lasti]);
         }
@@ -2443,10 +2443,10 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         aff_todo--;
         aff_entry = getroom(spin, sizeof(*aff_entry), true);
 
-        if (STRCMP(items[2], "0") != 0) {
+        if (strcmp(items[2], "0") != 0) {
           aff_entry->ae_chop = (char_u *)getroom_save(spin, (char_u *)items[2]);
         }
-        if (STRCMP(items[3], "0") != 0) {
+        if (strcmp(items[3], "0") != 0) {
           aff_entry->ae_add = (char_u *)getroom_save(spin, (char_u *)items[3]);
 
           // Recognize flags on the affix: abcd/XYZ
@@ -2464,7 +2464,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           aff_entry->ae_next = cur_aff->ah_first;
           cur_aff->ah_first = aff_entry;
 
-          if (STRCMP(items[4], ".") != 0) {
+          if (strcmp(items[4], ".") != 0) {
             char_u buf[MAXLINELEN];
 
             aff_entry->ae_cond = (char_u *)getroom_save(spin, (char_u *)items[4]);
@@ -2536,7 +2536,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
               // Find a previously used condition.
               for (idx = spin->si_prefcond.ga_len - 1; idx >= 0; idx--) {
                 p = ((char **)spin->si_prefcond.ga_data)[idx];
-                if (str_equal((char_u *)p, aff_entry->ae_cond)) {
+                if (str_equal(p, (char *)aff_entry->ae_cond)) {
                   break;
                 }
               }
@@ -2595,8 +2595,8 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
           smsg(_("Expected REP(SAL) count in %s line %d"),
                fname, lnum);
         }
-      } else if ((STRCMP(items[0], "REP") == 0
-                  || STRCMP(items[0], "REPSAL") == 0)
+      } else if ((strcmp(items[0], "REP") == 0
+                  || strcmp(items[0], "REPSAL") == 0)
                  && itemcnt >= 3) {
         // REP/REPSAL item
         // Myspell ignores extra arguments, we require it starts with
@@ -2656,16 +2656,16 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
         if (do_sal) {
           // SAL item (sounds-a-like)
           // Either one of the known keys or a from-to pair.
-          if (STRCMP(items[1], "followup") == 0) {
-            spin->si_followup = sal_to_bool((char_u *)items[2]);
-          } else if (STRCMP(items[1], "collapse_result") == 0) {
-            spin->si_collapse = sal_to_bool((char_u *)items[2]);
-          } else if (STRCMP(items[1], "remove_accents") == 0) {
-            spin->si_rem_accents = sal_to_bool((char_u *)items[2]);
+          if (strcmp(items[1], "followup") == 0) {
+            spin->si_followup = sal_to_bool(items[2]);
+          } else if (strcmp(items[1], "collapse_result") == 0) {
+            spin->si_collapse = sal_to_bool(items[2]);
+          } else if (strcmp(items[1], "remove_accents") == 0) {
+            spin->si_rem_accents = sal_to_bool(items[2]);
           } else {
             // when "to" is "_" it means empty
             add_fromto(spin, &spin->si_sal, (char_u *)items[1],
-                       STRCMP(items[2], "_") == 0 ? (char_u *)""
+                       strcmp(items[2], "_") == 0 ? (char_u *)""
                        : (char_u *)items[2]);
           }
         }
@@ -2675,7 +2675,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
       } else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
                  && sofoto == NULL) {
         sofoto = (char_u *)getroom_save(spin, (char_u *)items[1]);
-      } else if (STRCMP(items[0], "COMMON") == 0) {
+      } else if (strcmp(items[0], "COMMON") == 0) {
         int i;
 
         for (i = 1; i < itemcnt; i++) {
@@ -2744,7 +2744,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
   }
 
   if (syllable != NULL) {
-    aff_check_string(spin->si_syllable, syllable, "SYLLABLE");
+    aff_check_string((char *)spin->si_syllable, (char *)syllable, "SYLLABLE");
     spin->si_syllable = syllable;
   }
 
@@ -2755,15 +2755,15 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
     } else if (!GA_EMPTY(&spin->si_sal)) {
       smsg(_("Both SAL and SOFO lines in %s"), fname);
     } else {
-      aff_check_string(spin->si_sofofr, sofofrom, "SOFOFROM");
-      aff_check_string(spin->si_sofoto, sofoto, "SOFOTO");
+      aff_check_string((char *)spin->si_sofofr, (char *)sofofrom, "SOFOFROM");
+      aff_check_string((char *)spin->si_sofoto, (char *)sofoto, "SOFOTO");
       spin->si_sofofr = sofofrom;
       spin->si_sofoto = sofoto;
     }
   }
 
   if (midword != NULL) {
-    aff_check_string(spin->si_midword, midword, "MIDWORD");
+    aff_check_string((char *)spin->si_midword, (char *)midword, "MIDWORD");
     spin->si_midword = midword;
   }
 
@@ -2776,7 +2776,7 @@ static afffile_T *spell_read_aff(spellinfo_T *spin, char_u *fname)
 ///          a comment is following after item "mincount".
 static bool is_aff_rule(char **items, int itemcnt, char *rulename, int mincount)
 {
-  return STRCMP(items[0], rulename) == 0
+  return strcmp(items[0], rulename) == 0
          && (itemcnt == mincount
              || (itemcnt > mincount && items[mincount][0] == '#'));
 }
@@ -2813,15 +2813,15 @@ static void aff_process_flags(afffile_T *affile, affentry_T *entry)
   }
 }
 
-// Returns true if "s" is the name of an info item in the affix file.
-static bool spell_info_item(char_u *s)
+/// @return  true if "s" is the name of an info item in the affix file.
+static bool spell_info_item(char *s)
 {
-  return STRCMP(s, "NAME") == 0
-         || STRCMP(s, "HOME") == 0
-         || STRCMP(s, "VERSION") == 0
-         || STRCMP(s, "AUTHOR") == 0
-         || STRCMP(s, "EMAIL") == 0
-         || STRCMP(s, "COPYRIGHT") == 0;
+  return strcmp(s, "NAME") == 0
+         || strcmp(s, "HOME") == 0
+         || strcmp(s, "VERSION") == 0
+         || strcmp(s, "AUTHOR") == 0
+         || strcmp(s, "EMAIL") == 0
+         || strcmp(s, "COPYRIGHT") == 0;
 }
 
 // Turn an affix flag name into a number, according to the FLAG type.
@@ -3013,23 +3013,23 @@ static void aff_check_number(int spinval, int affval, char *name)
   }
 }
 
-// Give a warning when "spinval" and "affval" strings are set and not the same.
-static void aff_check_string(char_u *spinval, char_u *affval, char *name)
+/// Give a warning when "spinval" and "affval" strings are set and not the same.
+static void aff_check_string(char *spinval, char *affval, char *name)
 {
-  if (spinval != NULL && STRCMP(spinval, affval) != 0) {
+  if (spinval != NULL && strcmp(spinval, affval) != 0) {
     smsg(_("%s value differs from what is used in another .aff file"),
          name);
   }
 }
 
-// Returns true if strings "s1" and "s2" are equal.  Also consider both being
-// NULL as equal.
-static bool str_equal(char_u *s1, char_u *s2)
+/// @return  true if strings "s1" and "s2" are equal.  Also consider both being
+///          NULL as equal.
+static bool str_equal(char *s1, char *s2)
 {
   if (s1 == NULL || s2 == NULL) {
     return s1 == s2;
   }
-  return STRCMP(s1, s2) == 0;
+  return strcmp(s1, s2) == 0;
 }
 
 // Add a from-to item to "gap".  Used for REP and SAL items.
@@ -3045,10 +3045,10 @@ static void add_fromto(spellinfo_T *spin, garray_T *gap, char_u *from, char_u *t
   ftp->ft_to = (char_u *)getroom_save(spin, word);
 }
 
-// Converts a boolean argument in a SAL line to true or false;
-static bool sal_to_bool(char_u *s)
+/// Converts a boolean argument in a SAL line to true or false;
+static bool sal_to_bool(char *s)
 {
-  return STRCMP(s, "1") == 0 || STRCMP(s, "true") == 0;
+  return strcmp(s, "1") == 0 || strcmp(s, "true") == 0;
 }
 
 // Free the structure filled by spell_read_aff().
@@ -4337,13 +4337,13 @@ static bool node_equal(wordnode_T *n1, wordnode_T *n2)
   return p1 == NULL && p2 == NULL;
 }
 
-// Function given to qsort() to sort the REP items on "from" string.
+/// Function given to qsort() to sort the REP items on "from" string.
 static int rep_compare(const void *s1, const void *s2)
 {
   fromto_T *p1 = (fromto_T *)s1;
   fromto_T *p2 = (fromto_T *)s2;
 
-  return STRCMP(p1->ft_from, p2->ft_from);
+  return strcmp((char *)p1->ft_from, (char *)p2->ft_from);
 }
 
 /// Write the Vim .spl file "fname".
@@ -5299,7 +5299,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
 
   if (fcount >= 1) {
     len = (int)STRLEN(fnames[0]);
-    if (fcount == 1 && len > 4 && STRCMP(fnames[0] + len - 4, ".add") == 0) {
+    if (fcount == 1 && len > 4 && strcmp(fnames[0] + len - 4, ".add") == 0) {
       // For ":mkspell path/en.latin1.add" output file is
       // "path/en.latin1.add.spl".
       incount = 1;
@@ -5309,7 +5309,7 @@ static void mkspell(int fcount, char **fnames, bool ascii, bool over_write, bool
       incount = 1;
       vim_snprintf(wfname, MAXPATHL, SPL_FNAME_TMPL,
                    fnames[0], spin.si_ascii ? (char_u *)"ascii" : spell_enc());
-    } else if (len > 4 && STRCMP(fnames[0] + len - 4, ".spl") == 0) {
+    } else if (len > 4 && strcmp(fnames[0] + len - 4, ".spl") == 0) {
       // Name ends in ".spl", use as the file name.
       STRLCPY(wfname, fnames[0], MAXPATHL);
     } else {
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index c38fa2b24f..5f432f1c9a 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -354,7 +354,7 @@ int spell_check_sps(void)
 {
   char *p;
   char *s;
-  char_u buf[MAXPATHL];
+  char buf[MAXPATHL];
   int f;
 
   sps_flags = 0;
@@ -370,11 +370,11 @@ int spell_check_sps(void)
       if (*s != NUL && !ascii_isdigit(*s)) {
         f = -1;
       }
-    } else if (STRCMP(buf, "best") == 0) {
+    } else if (strcmp(buf, "best") == 0) {
       f = SPS_BEST;
-    } else if (STRCMP(buf, "fast") == 0) {
+    } else if (strcmp(buf, "fast") == 0) {
       f = SPS_FAST;
-    } else if (STRCMP(buf, "double") == 0) {
+    } else if (strcmp(buf, "double") == 0) {
       f = SPS_DOUBLE;
     } else if (STRNCMP(buf, "expr:", 5) != 0
                && STRNCMP(buf, "file:", 5) != 0
@@ -1114,7 +1114,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
 {
   char_u tword[MAXWLEN];            // good word collected so far
   trystate_T stack[MAXWLEN];
-  char_u preword[MAXWLEN * 3] = { 0 };  // word found with proper case;
+  char preword[MAXWLEN * 3] = { 0 };  // word found with proper case;
   // concatenation of prefix compound
   // words and split word.  NUL terminated
   // when going deeper but not when coming
@@ -1241,7 +1241,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
           // and make find_keepcap_word() works.
           tword[sp->ts_twordlen] = NUL;
           make_case_word(tword + sp->ts_splitoff,
-                         preword + sp->ts_prewordlen, flags);
+                         (char_u *)preword + sp->ts_prewordlen, flags);
           sp->ts_prewordlen = (char_u)STRLEN(preword);
           sp->ts_splitoff = sp->ts_twordlen;
         }
@@ -1326,7 +1326,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                          sp->ts_fidx - sp->ts_splitfidx) == 0) {
             preword[sp->ts_prewordlen] = NUL;
             newscore = score_wordcount_adj(slang, sp->ts_score,
-                                           preword + sp->ts_prewordlen,
+                                           (char_u *)preword + sp->ts_prewordlen,
                                            sp->ts_prewordlen > 0);
             // Add the suggestion if the score isn't too bad.
             if (newscore <= su->su_maxscore) {
@@ -1362,13 +1362,13 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                   sp->ts_twordlen - sp->ts_splitoff + 1);
 
           // Verify CHECKCOMPOUNDPATTERN  rules.
-          if (match_checkcompoundpattern(preword,  sp->ts_prewordlen,
+          if (match_checkcompoundpattern((char_u *)preword,  sp->ts_prewordlen,
                                          &slang->sl_comppat)) {
             compound_ok = false;
           }
 
           if (compound_ok) {
-            p = preword;
+            p = (char_u *)preword;
             while (*skiptowhite((char *)p) != NUL) {
               p = (char_u *)skipwhite(skiptowhite((char *)p));
             }
@@ -1381,7 +1381,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
           }
 
           // Get pointer to last char of previous word.
-          p = preword + sp->ts_prewordlen;
+          p = (char_u *)preword + sp->ts_prewordlen;
           MB_PTR_BACK(preword, p);
         }
       }
@@ -1394,7 +1394,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
       } else if (flags & WF_KEEPCAP) {
         // Must find the word in the keep-case tree.
         find_keepcap_word(slang, tword + sp->ts_splitoff,
-                          preword + sp->ts_prewordlen);
+                          (char_u *)preword + sp->ts_prewordlen);
       } else {
         // Include badflags: If the badword is onecap or allcap
         // use that for the goodword too.  But if the badword is
@@ -1413,14 +1413,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
           c &= ~WF_ONECAP;
         }
         make_case_word(tword + sp->ts_splitoff,
-                       preword + sp->ts_prewordlen, c);
+                       (char_u *)preword + sp->ts_prewordlen, c);
       }
 
       if (!soundfold) {
         // Don't use a banned word.  It may appear again as a good
         // word, thus remember it.
         if (flags & WF_BANNED) {
-          add_banned(su, preword + sp->ts_prewordlen);
+          add_banned(su, (char_u *)preword + sp->ts_prewordlen);
           break;
         }
         if ((sp->ts_complen == sp->ts_compsplit
@@ -1445,7 +1445,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         }
 
         if (!spell_valid_case(su->su_badflags,
-                              captype(preword + sp->ts_prewordlen, NULL))) {
+                              captype((char_u *)preword + sp->ts_prewordlen, NULL))) {
           newscore += SCORE_ICASE;
         }
       }
@@ -1457,7 +1457,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
           && compound_ok) {
         // The badword also ends: add suggestions.
 #ifdef DEBUG_TRIEWALK
-        if (soundfold && STRCMP(preword, "smwrd") == 0) {
+        if (soundfold && strcmp(preword, "smwrd") == 0) {
           int j;
 
           // print the stack of changes that brought us here
@@ -1470,14 +1470,14 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
         if (soundfold) {
           // For soundfolded words we need to find the original
           // words, the edit distance and then add them.
-          add_sound_suggest(su, preword, sp->ts_score, lp);
+          add_sound_suggest(su, (char_u *)preword, sp->ts_score, lp);
         } else if (sp->ts_fidx > 0) {
           // Give a penalty when changing non-word char to word
           // char, e.g., "thes," -> "these".
           p = fword + sp->ts_fidx;
           MB_PTR_BACK(fword, p);
           if (!spell_iswordp(p, curwin) && *preword != NUL) {
-            p = preword + STRLEN(preword);
+            p = (char_u *)preword + STRLEN(preword);
             MB_PTR_BACK(preword, p);
             if (spell_iswordp(p, curwin)) {
               newscore += SCORE_NONWORD;
@@ -1487,7 +1487,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
           // Give a bonus to words seen before.
           score = score_wordcount_adj(slang,
                                       sp->ts_score + newscore,
-                                      preword + sp->ts_prewordlen,
+                                      (char_u *)preword + sp->ts_prewordlen,
                                       sp->ts_prewordlen > 0);
 
           // Add the suggestion if the score isn't too bad.
@@ -1499,10 +1499,10 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
             if (su->su_badflags & WF_MIXCAP) {
               // We really don't know if the word should be
               // upper or lower case, add both.
-              c = captype(preword, NULL);
+              c = captype((char_u *)preword, NULL);
               if (c == 0 || c == WF_ALLCAP) {
                 make_case_word(tword + sp->ts_splitoff,
-                               preword + sp->ts_prewordlen,
+                               (char_u *)preword + sp->ts_prewordlen,
                                c == 0 ? WF_ALLCAP : 0);
 
                 add_suggestion(su, &su->su_ga, (char *)preword,
@@ -1589,7 +1589,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
                 && (flags & WF_NEEDCOMP)) {
               break;
             }
-            p = preword;
+            p = (char_u *)preword;
             while (*skiptowhite((char *)p) != NUL) {
               p = (char_u *)skipwhite(skiptowhite((char *)p));
             }
@@ -1607,7 +1607,7 @@ static void suggest_trie_walk(suginfo_T *su, langp_T *lp, char_u *fword, bool so
 
             // Give a bonus to words seen before.
             newscore = score_wordcount_adj(slang, newscore,
-                                           preword + sp->ts_prewordlen, true);
+                                           (char_u *)preword + sp->ts_prewordlen, true);
           }
 
           if (TRY_DEEPER(su, stack, depth, newscore)) {
@@ -2515,8 +2515,8 @@ static void score_combine(suginfo_T *su)
   garray_T *gap;
   langp_T *lp;
   suggest_T *stp;
-  char_u *p;
-  char_u badsound[MAXWLEN];
+  char *p;
+  char badsound[MAXWLEN];
   int round;
   slang_T *slang = NULL;
 
@@ -2526,11 +2526,11 @@ static void score_combine(suginfo_T *su)
     if (!GA_EMPTY(&lp->lp_slang->sl_sal)) {
       // soundfold the bad word
       slang = lp->lp_slang;
-      spell_soundfold(slang, su->su_fbadword, true, badsound);
+      spell_soundfold(slang, su->su_fbadword, true, (char_u *)badsound);
 
       for (int i = 0; i < su->su_ga.ga_len; i++) {
         stp = &SUG(su->su_ga, i);
-        stp->st_altscore = stp_sal_score(stp, su, slang, badsound);
+        stp->st_altscore = stp_sal_score(stp, su, slang, (char_u *)badsound);
         if (stp->st_altscore == SCORE_MAXMAX) {
           stp->st_score = (stp->st_score * 3 + SCORE_BIG) / 4;
         } else {
@@ -2578,10 +2578,10 @@ static void score_combine(suginfo_T *su)
       gap = round == 1 ? &su->su_ga : &su->su_sga;
       if (i < gap->ga_len) {
         // Don't add a word if it's already there.
-        p = (char_u *)SUG(*gap, i).st_word;
+        p = SUG(*gap, i).st_word;
         int j;
         for (j = 0; j < ga.ga_len; j++) {
-          if (STRCMP(stp[j].st_word, p) == 0) {
+          if (strcmp(stp[j].st_word, p) == 0) {
             break;
           }
         }
@@ -2659,7 +2659,7 @@ static int stp_sal_score(suggest_T *stp, suginfo_T *su, slang_T *slang, char_u *
   // Sound-fold the word and compute the score for the difference.
   spell_soundfold(slang, pgood, false, goodsound);
 
-  return soundalike_score(goodsound, pbad);
+  return soundalike_score((char *)goodsound, (char *)pbad);
 }
 
 /// structure used to store soundfolded words that add_sound_suggest() has
@@ -3306,15 +3306,15 @@ static int cleanup_suggestions(garray_T *gap, int maxscore, int keep)
 ///
 /// @param goodstart  sound-folded good word
 /// @param badstart  sound-folded bad word
-static int soundalike_score(char_u *goodstart, char_u *badstart)
+static int soundalike_score(char *goodstart, char *badstart)
 {
-  char_u *goodsound = goodstart;
-  char_u *badsound = badstart;
+  char *goodsound = goodstart;
+  char *badsound = badstart;
   int goodlen;
   int badlen;
   int n;
-  char_u *pl, *ps;
-  char_u *pl2, *ps2;
+  char *pl, *ps;
+  char *pl2, *ps2;
   int score = 0;
 
   // Adding/inserting "*" at the start (word starts with vowel) shouldn't be
@@ -3379,7 +3379,7 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
       ps++;
     }
     // strings must be equal after second delete
-    if (STRCMP(pl + 1, ps) == 0) {
+    if (strcmp(pl + 1, ps) == 0) {
       return score + SCORE_DEL * 2;
     }
 
@@ -3403,12 +3403,12 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
 
     // 2: delete then swap, then rest must be equal
     if (pl2[0] == ps2[1] && pl2[1] == ps2[0]
-        && STRCMP(pl2 + 2, ps2 + 2) == 0) {
+        && strcmp(pl2 + 2, ps2 + 2) == 0) {
       return score + SCORE_DEL + SCORE_SWAP;
     }
 
     // 3: delete then substitute, then the rest must be equal
-    if (STRCMP(pl2 + 1, ps2 + 1) == 0) {
+    if (strcmp(pl2 + 1, ps2 + 1) == 0) {
       return score + SCORE_DEL + SCORE_SUBST;
     }
 
@@ -3421,7 +3421,7 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
         ps2++;
       }
       // delete a char and then strings must be equal
-      if (STRCMP(pl2 + 1, ps2) == 0) {
+      if (strcmp(pl2 + 1, ps2) == 0) {
         return score + SCORE_SWAP + SCORE_DEL;
       }
     }
@@ -3434,7 +3434,7 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
       ps2++;
     }
     // delete a char and then strings must be equal
-    if (STRCMP(pl2 + 1, ps2) == 0) {
+    if (strcmp(pl2 + 1, ps2) == 0) {
       return score + SCORE_SUBST + SCORE_DEL;
     }
 
@@ -3462,12 +3462,12 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
       }
       // 3: swap and swap again
       if (pl2[0] == ps2[1] && pl2[1] == ps2[0]
-          && STRCMP(pl2 + 2, ps2 + 2) == 0) {
+          && strcmp(pl2 + 2, ps2 + 2) == 0) {
         return score + SCORE_SWAP + SCORE_SWAP;
       }
 
       // 4: swap and substitute
-      if (STRCMP(pl2 + 1, ps2 + 1) == 0) {
+      if (strcmp(pl2 + 1, ps2 + 1) == 0) {
         return score + SCORE_SWAP + SCORE_SUBST;
       }
     }
@@ -3485,12 +3485,12 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
 
     // 6: substitute and swap
     if (pl2[0] == ps2[1] && pl2[1] == ps2[0]
-        && STRCMP(pl2 + 2, ps2 + 2) == 0) {
+        && strcmp(pl2 + 2, ps2 + 2) == 0) {
       return score + SCORE_SUBST + SCORE_SWAP;
     }
 
     // 7: substitute and substitute
-    if (STRCMP(pl2 + 1, ps2 + 1) == 0) {
+    if (strcmp(pl2 + 1, ps2 + 1) == 0) {
       return score + SCORE_SUBST + SCORE_SUBST;
     }
 
@@ -3501,7 +3501,7 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
       pl2++;
       ps2++;
     }
-    if (STRCMP(pl2 + 1, ps2) == 0) {
+    if (strcmp(pl2 + 1, ps2) == 0) {
       return score + SCORE_INS + SCORE_DEL;
     }
 
@@ -3512,7 +3512,7 @@ static int soundalike_score(char_u *goodstart, char_u *badstart)
       pl2++;
       ps2++;
     }
-    if (STRCMP(pl2, ps2 + 1) == 0) {
+    if (strcmp(pl2, ps2 + 1) == 0) {
       return score + SCORE_INS + SCORE_DEL;
     }
 
diff --git a/src/nvim/state.c b/src/nvim/state.c
index 61740800a1..458eed960f 100644
--- a/src/nvim/state.c
+++ b/src/nvim/state.c
@@ -237,7 +237,7 @@ void may_trigger_modechanged(void)
   char pattern_buf[2 * MODE_MAX_LENGTH];
 
   get_mode(curr_mode);
-  if (STRCMP(curr_mode, last_mode) == 0) {
+  if (strcmp(curr_mode, last_mode) == 0) {
     return;
   }
 
diff --git a/src/nvim/strings.c b/src/nvim/strings.c
index 04f9311d7e..ee6172e7fc 100644
--- a/src/nvim/strings.c
+++ b/src/nvim/strings.c
@@ -460,7 +460,7 @@ char *vim_strchr(const char *const string, const int c)
 static int sort_compare(const void *s1, const void *s2)
   FUNC_ATTR_NONNULL_ALL
 {
-  return STRCMP(*(char **)s1, *(char **)s2);
+  return strcmp(*(char **)s1, *(char **)s2);
 }
 
 void sort_strings(char **files, int count)
diff --git a/src/nvim/syntax.c b/src/nvim/syntax.c
index 1daeebd7b9..ce952147f7 100644
--- a/src/nvim/syntax.c
+++ b/src/nvim/syntax.c
@@ -98,7 +98,7 @@ typedef struct syn_pattern {
 
 typedef struct syn_cluster_S {
   char_u *scl_name;         // syntax cluster name
-  char_u *scl_name_u;       // uppercase of scl_name
+  char *scl_name_u;         // uppercase of scl_name
   int16_t *scl_list;        // IDs in this syntax cluster
 } syn_cluster_T;
 
@@ -3918,7 +3918,7 @@ static char *get_syn_options(char *arg, syn_opt_arg_T *opt, int *conceal_char, i
           return NULL;
         }
         gname = xstrnsave(gname_start, (size_t)(arg - gname_start));
-        if (STRCMP(gname, "NONE") == 0) {
+        if (strcmp(gname, "NONE") == 0) {
           *opt->sync_idx = NONE_IDX;
         } else {
           syn_id = syn_name2id(gname);
@@ -4306,13 +4306,13 @@ static void syn_cmd_region(exarg_T *eap, int syncing)
     }
     xfree(key);
     key = vim_strnsave_up(rest, (size_t)(key_end - rest));
-    if (STRCMP(key, "MATCHGROUP") == 0) {
+    if (strcmp(key, "MATCHGROUP") == 0) {
       item = ITEM_MATCHGROUP;
-    } else if (STRCMP(key, "START") == 0) {
+    } else if (strcmp(key, "START") == 0) {
       item = ITEM_START;
-    } else if (STRCMP(key, "END") == 0) {
+    } else if (strcmp(key, "END") == 0) {
       item = ITEM_END;
-    } else if (STRCMP(key, "SKIP") == 0) {
+    } else if (strcmp(key, "SKIP") == 0) {
       if (pat_ptrs[ITEM_SKIP] != NULL) {  // One skip pattern allowed.
         illegal = true;
         break;
@@ -4584,7 +4584,7 @@ static int syn_scl_name2id(char *name)
   int i;
   for (i = curwin->w_s->b_syn_clusters.ga_len; --i >= 0;) {
     if (SYN_CLSTR(curwin->w_s)[i].scl_name_u != NULL
-        && STRCMP(name_u, SYN_CLSTR(curwin->w_s)[i].scl_name_u) == 0) {
+        && strcmp(name_u, SYN_CLSTR(curwin->w_s)[i].scl_name_u) == 0) {
       break;
     }
   }
@@ -4642,7 +4642,7 @@ static int syn_add_cluster(char *name)
                                          &curwin->w_s->b_syn_clusters);
   CLEAR_POINTER(scp);
   scp->scl_name = (char_u *)name;
-  scp->scl_name_u = vim_strsave_up((char_u *)name);
+  scp->scl_name_u = (char *)vim_strsave_up((char_u *)name);
   scp->scl_list = NULL;
 
   if (STRICMP(name, "Spell") == 0) {
@@ -4847,7 +4847,7 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
     next_arg = skipwhite(arg_end);
     xfree(key);
     key = vim_strnsave_up(arg_start, (size_t)(arg_end - arg_start));
-    if (STRCMP(key, "CCOMMENT") == 0) {
+    if (strcmp(key, "CCOMMENT") == 0) {
       if (!eap->skip) {
         curwin->w_s->b_syn_sync_flags |= SF_CCOMMENT;
       }
@@ -4886,12 +4886,12 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
           curwin->w_s->b_syn_sync_minlines = n;
         }
       }
-    } else if (STRCMP(key, "FROMSTART") == 0) {
+    } else if (strcmp(key, "FROMSTART") == 0) {
       if (!eap->skip) {
         curwin->w_s->b_syn_sync_minlines = MAXLNUM;
         curwin->w_s->b_syn_sync_maxlines = 0;
       }
-    } else if (STRCMP(key, "LINECONT") == 0) {
+    } else if (strcmp(key, "LINECONT") == 0) {
       if (*next_arg == NUL) {  // missing pattern
         illegal = true;
         break;
@@ -4930,11 +4930,11 @@ static void syn_cmd_sync(exarg_T *eap, int syncing)
       next_arg = skipwhite(arg_end + 1);
     } else {
       eap->arg = next_arg;
-      if (STRCMP(key, "MATCH") == 0) {
+      if (strcmp(key, "MATCH") == 0) {
         syn_cmd_match(eap, true);
-      } else if (STRCMP(key, "REGION") == 0) {
+      } else if (strcmp(key, "REGION") == 0) {
         syn_cmd_region(eap, true);
-      } else if (STRCMP(key, "CLEAR") == 0) {
+      } else if (strcmp(key, "CLEAR") == 0) {
         syn_cmd_clear(eap, true);
       } else {
         illegal = true;
@@ -4997,10 +4997,10 @@ static int get_id_list(char **const arg, const int keylen, int16_t **const list,
       for (end = p; *end && !ascii_iswhite(*end) && *end != ','; end++) {}
       char *const name = xmalloc((size_t)(end - p) + 3);   // leave room for "^$"
       STRLCPY(name + 1, p, end - p + 1);
-      if (STRCMP(name + 1, "ALLBUT") == 0
-          || STRCMP(name + 1, "ALL") == 0
-          || STRCMP(name + 1, "TOP") == 0
-          || STRCMP(name + 1, "CONTAINED") == 0) {
+      if (strcmp(name + 1, "ALLBUT") == 0
+          || strcmp(name + 1, "ALL") == 0
+          || strcmp(name + 1, "TOP") == 0
+          || strcmp(name + 1, "CONTAINED") == 0) {
         if (TOUPPER_ASC(**arg) != 'C') {
           semsg(_("E407: %s not allowed here"), name + 1);
           failed = true;
@@ -5280,7 +5280,7 @@ void ex_syntax(exarg_T *eap)
       semsg(_("E410: Invalid :syntax subcommand: %s"), subcmd_name);
       break;
     }
-    if (STRCMP(subcmd_name, subcommands[i].name) == 0) {
+    if (strcmp(subcmd_name, subcommands[i].name) == 0) {
       eap->arg = skipwhite(subcmd_end);
       (subcommands[i].func)(eap, false);
       break;
@@ -5566,13 +5566,13 @@ int syn_get_foldlevel(win_T *wp, linenr_T lnum)
 // ":syntime".
 void ex_syntime(exarg_T *eap)
 {
-  if (STRCMP(eap->arg, "on") == 0) {
+  if (strcmp(eap->arg, "on") == 0) {
     syn_time_on = true;
-  } else if (STRCMP(eap->arg, "off") == 0) {
+  } else if (strcmp(eap->arg, "off") == 0) {
     syn_time_on = false;
-  } else if (STRCMP(eap->arg, "clear") == 0) {
+  } else if (strcmp(eap->arg, "clear") == 0) {
     syntime_clear();
-  } else if (STRCMP(eap->arg, "report") == 0) {
+  } else if (strcmp(eap->arg, "report") == 0) {
     syntime_report();
   } else {
     semsg(_(e_invarg2), eap->arg);
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index 8be752239c..b363dfc889 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -52,8 +52,7 @@
 // Structure to hold pointers to various items in a tag line.
 typedef struct tag_pointers {
   // filled in by parse_tag_line():
-  char_u *tagname;  // start of tag name (skip "file:")
-                    //
+  char *tagname;  // start of tag name (skip "file:")
   char_u *tagname_end;  // char after tag name
   char_u *fname;   // first char of file name
   char_u *fname_end;  // char after file name
@@ -225,7 +224,7 @@ bool do_tag(char *tag, int type, int count, int forceit, int verbose)
             )) {
       if (g_do_tagpreview != 0) {
         if (ptag_entry.tagname != NULL
-            && STRCMP(ptag_entry.tagname, tag) == 0) {
+            && strcmp(ptag_entry.tagname, tag) == 0) {
           // Jumping to same tag: keep the current match, so that
           // the CursorHold autocommand example works.
           cur_match = ptag_entry.cur_match;
@@ -429,7 +428,7 @@ bool do_tag(char *tag, int type, int count, int forceit, int verbose)
     } else {
       name = tag;
     }
-    other_name = (tagmatchname == NULL || STRCMP(tagmatchname, name) != 0);
+    other_name = (tagmatchname == NULL || strcmp(tagmatchname, name) != 0);
     if (new_tag
         || (cur_match >= num_matches && max_num_matches != MAXCOL)
         || other_name) {
@@ -487,7 +486,7 @@ bool do_tag(char *tag, int type, int count, int forceit, int verbose)
           parse_match(matches[j], &tagp);
           for (i = idx; i < new_num_matches; i++) {
             parse_match(new_matches[i], &tagp2);
-            if (STRCMP(tagp.tagname, tagp2.tagname) == 0) {
+            if (strcmp(tagp.tagname, tagp2.tagname) == 0) {
               char_u *p = (char_u *)new_matches[i];
               for (k = i; k > idx; k--) {
                 new_matches[k] = new_matches[k - 1];
@@ -683,7 +682,7 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
   // Assume that the first match indicates how long the tags can
   // be, and align the file names to that.
   parse_match(matches[0], &tagp);
-  taglen = (int)(tagp.tagname_end - tagp.tagname + 2);
+  taglen = (int)(tagp.tagname_end - (char_u *)tagp.tagname + 2);
   if (taglen < 18) {
     taglen = 18;
   }
@@ -719,8 +718,8 @@ static void print_tag_list(int new_tag, int use_tagstack, int num_matches, char
                        (int)(tagp.tagkind_end - tagp.tagkind));
     }
     msg_advance(13);
-    msg_outtrans_len_attr((char *)tagp.tagname,
-                          (int)(tagp.tagname_end - tagp.tagname),
+    msg_outtrans_len_attr(tagp.tagname,
+                          (int)(tagp.tagname_end - (char_u *)tagp.tagname),
                           HL_ATTR(HLF_T));
     msg_putchar(' ');
     taglen_advance(taglen);
@@ -877,7 +876,7 @@ static int add_llist_tags(char_u *tag, int num_matches, char **matches)
     parse_match(matches[i], &tagp);
 
     // Save the tag name
-    len = (int)(tagp.tagname_end - tagp.tagname);
+    len = (int)(tagp.tagname_end - (char_u *)tagp.tagname);
     if (len > 128) {
       len = 128;
     }
@@ -1191,7 +1190,7 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
     res_kind = NULL;
 
     TV_DICT_ITER(TV_LIST_ITEM_TV(li)->vval.v_dict, di, {
-      const char_u *dict_key = di->di_key;
+      const char *dict_key = (char *)di->di_key;
       typval_T *tv = &di->di_tv;
 
       if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL) {
@@ -1199,20 +1198,20 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
       }
 
       len += strlen(tv->vval.v_string) + 1;   // Space for "\tVALUE"
-      if (!STRCMP(dict_key, "name")) {
+      if (!strcmp(dict_key, "name")) {
         res_name = tv->vval.v_string;
         continue;
       }
-      if (!STRCMP(dict_key, "filename")) {
+      if (!strcmp(dict_key, "filename")) {
         res_fname = (char_u *)tv->vval.v_string;
         continue;
       }
-      if (!STRCMP(dict_key, "cmd")) {
+      if (!strcmp(dict_key, "cmd")) {
         res_cmd = (char_u *)tv->vval.v_string;
         continue;
       }
       has_extra = 1;
-      if (!STRCMP(dict_key, "kind")) {
+      if (!strcmp(dict_key, "kind")) {
         res_kind = (char_u *)tv->vval.v_string;
         continue;
       }
@@ -1260,22 +1259,22 @@ static int find_tagfunc_tags(char_u *pat, garray_T *ga, int *match_count, int fl
         }
 
         TV_DICT_ITER(TV_LIST_ITEM_TV(li)->vval.v_dict, di, {
-          const char_u *dict_key = di->di_key;
+          const char *dict_key = (char *)di->di_key;
           typval_T *tv = &di->di_tv;
           if (tv->v_type != VAR_STRING || tv->vval.v_string == NULL) {
             continue;
           }
 
-          if (!STRCMP(dict_key, "name")) {
+          if (!strcmp(dict_key, "name")) {
             continue;
           }
-          if (!STRCMP(dict_key, "filename")) {
+          if (!strcmp(dict_key, "filename")) {
             continue;
           }
-          if (!STRCMP(dict_key, "cmd")) {
+          if (!strcmp(dict_key, "cmd")) {
             continue;
           }
-          if (!STRCMP(dict_key, "kind")) {
+          if (!strcmp(dict_key, "kind")) {
             continue;
           }
 
@@ -1814,7 +1813,7 @@ parse_line:
         // This speeds up tag searching a lot!
         if (orgpat.headlen) {
           CLEAR_FIELD(tagp);
-          tagp.tagname = lbuf;
+          tagp.tagname = (char *)lbuf;
           tagp.tagname_end = (char_u *)vim_strchr((char *)lbuf, TAB);
           if (tagp.tagname_end == NULL) {
             // Corrupted tag line.
@@ -1824,7 +1823,7 @@ parse_line:
 
           // Skip this line if the length of the tag is different and
           // there is no regexp, or the tag is too short.
-          cmplen = (int)(tagp.tagname_end - tagp.tagname);
+          cmplen = (int)(tagp.tagname_end - (char_u *)tagp.tagname);
           if (p_tl != 0 && cmplen > p_tl) {         // adjust for 'taglength'
             cmplen = (int)p_tl;
           }
@@ -1846,7 +1845,7 @@ parse_line:
 
             // Compare the current tag with the searched tag.
             if (sortic) {
-              tagcmp = tag_strnicmp(tagp.tagname, orgpat.head,
+              tagcmp = tag_strnicmp((char_u *)tagp.tagname, orgpat.head,
                                     (size_t)cmplen);
             } else {
               tagcmp = STRNCMP(tagp.tagname, orgpat.head, cmplen);
@@ -1877,7 +1876,7 @@ parse_line:
                   search_info.low_char =
                     TOUPPER_ASC(tagp.tagname[0]);
                 } else {
-                  search_info.low_char = tagp.tagname[0];
+                  search_info.low_char = (uint8_t)tagp.tagname[0];
                 }
                 continue;
               }
@@ -1889,7 +1888,7 @@ parse_line:
                 search_info.high_char =
                   TOUPPER_ASC(tagp.tagname[0]);
               } else {
-                search_info.high_char = tagp.tagname[0];
+                search_info.high_char = (uint8_t)tagp.tagname[0];
               }
               continue;
             }
@@ -1898,7 +1897,7 @@ parse_line:
             break;
           } else if (state == TS_SKIP_BACK) {
             assert(cmplen >= 0);
-            if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
+            if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
               state = TS_STEP_FORWARD;
             } else {
               // Have to skip back more.  Restore the curr_offset
@@ -1908,7 +1907,7 @@ parse_line:
             continue;
           } else if (state == TS_STEP_FORWARD) {
             assert(cmplen >= 0);
-            if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
+            if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
               if ((off_T)vim_ftell(fp) > search_info.match_offset) {
                 break;                  // past last match
               } else {
@@ -1919,7 +1918,7 @@ parse_line:
             // skip this match if it can't match
             assert(cmplen >= 0);
           }
-          if (mb_strnicmp((char *)tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
+          if (mb_strnicmp(tagp.tagname, (char *)orgpat.head, (size_t)cmplen) != 0) {
             continue;
           }
 
@@ -1943,7 +1942,7 @@ parse_line:
 
         // First try matching with the pattern literally (also when it is
         // a regexp).
-        cmplen = (int)(tagp.tagname_end - tagp.tagname);
+        cmplen = (int)(tagp.tagname_end - (char_u *)tagp.tagname);
         if (p_tl != 0 && cmplen > p_tl) {           // adjust for 'taglength'
           cmplen = (int)p_tl;
         }
@@ -1953,7 +1952,7 @@ parse_line:
         } else {
           if (orgpat.regmatch.rm_ic) {
             assert(cmplen >= 0);
-            match = mb_strnicmp((char *)tagp.tagname, (char *)orgpat.pat, (size_t)cmplen) == 0;
+            match = mb_strnicmp(tagp.tagname, (char *)orgpat.pat, (size_t)cmplen) == 0;
             if (match) {
               match_no_ic = (STRNCMP(tagp.tagname, orgpat.pat,
                                      cmplen) == 0);
@@ -1970,12 +1969,12 @@ parse_line:
 
           cc = *tagp.tagname_end;
           *tagp.tagname_end = NUL;
-          match = vim_regexec(&orgpat.regmatch, (char *)tagp.tagname, (colnr_T)0);
+          match = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
           if (match) {
-            matchoff = (int)(orgpat.regmatch.startp[0] - tagp.tagname);
+            matchoff = (int)(orgpat.regmatch.startp[0] - (char_u *)tagp.tagname);
             if (orgpat.regmatch.rm_ic) {
               orgpat.regmatch.rm_ic = false;
-              match_no_ic = vim_regexec(&orgpat.regmatch, (char *)tagp.tagname, (colnr_T)0);
+              match_no_ic = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
               orgpat.regmatch.rm_ic = true;
             }
           }
@@ -2029,7 +2028,7 @@ parse_line:
             // detecting duplicates.
             // The format is {tagname}@{lang}NUL{heuristic}NUL
             *tagp.tagname_end = NUL;
-            len = (size_t)(tagp.tagname_end - tagp.tagname);
+            len = (size_t)(tagp.tagname_end - (char_u *)tagp.tagname);
             mfp = xmalloc(sizeof(char) + len + 10 + ML_EXTRA + 1);
 
             p = (char_u *)mfp;
@@ -2037,7 +2036,7 @@ parse_line:
             p[len] = '@';
             STRCPY(p + len + 1, help_lang);
             snprintf((char *)p + len + 1 + ML_EXTRA, STRLEN(p) + len + 1 + ML_EXTRA, "%06d",
-                     help_heuristic((char *)tagp.tagname,
+                     help_heuristic(tagp.tagname,
                                     match_re ? matchoff : 0, !match_no_ic)
                      + help_pri);
 
@@ -2063,7 +2062,7 @@ parse_line:
               }
               get_it_again = false;
             } else {
-              len = (size_t)(tagp.tagname_end - tagp.tagname);
+              len = (size_t)(tagp.tagname_end - (char_u *)tagp.tagname);
               mfp = xmalloc(sizeof(char) + len + 1);
               STRLCPY(mfp, tagp.tagname, len + 1);
 
@@ -2306,7 +2305,7 @@ int get_tagfname(tagname_T *tnp, int first, char *buf)
       simplify_filename((char_u *)buf);
 
       for (int i = 0; i < tag_fnames.ga_len; i++) {
-        if (STRCMP(buf, ((char **)(tag_fnames.ga_data))[i]) == 0) {
+        if (strcmp(buf, ((char **)(tag_fnames.ga_data))[i]) == 0) {
           return FAIL;  // avoid duplicate file names
         }
       }
@@ -2394,7 +2393,7 @@ static int parse_tag_line(char_u *lbuf, tagptrs_T *tagp)
   char_u *p;
 
   // Isolate the tagname, from lbuf up to the first white
-  tagp->tagname = lbuf;
+  tagp->tagname = (char *)lbuf;
   p = (char_u *)vim_strchr((char *)lbuf, TAB);
   if (p == NULL) {
     return FAIL;
@@ -3015,7 +3014,7 @@ int expand_tags(int tagnames, char_u *pat, int *num_file, char ***file)
       size_t len;
 
       parse_match((*file)[i], &t_p);
-      len = (size_t)(t_p.tagname_end - t_p.tagname);
+      len = (size_t)(t_p.tagname_end - (char_u *)t_p.tagname);
       if (len > name_buf_size - 3) {
         char_u *buf;
 
@@ -3112,7 +3111,7 @@ int get_tags(list_T *list, char_u *pat, char_u *buf_fname)
       tv_list_append_dict(list, dict);
 
       full_fname = tag_full_fname(&tp);
-      if (add_tag_field(dict, "name", (char *)tp.tagname, (char *)tp.tagname_end) == FAIL
+      if (add_tag_field(dict, "name", tp.tagname, (char *)tp.tagname_end) == FAIL
           || add_tag_field(dict, "filename", (char *)full_fname, NULL) == FAIL
           || add_tag_field(dict, "cmd", (char *)tp.command, (char *)tp.command_end) == FAIL
           || add_tag_field(dict, "kind", (char *)tp.tagkind,
diff --git a/src/nvim/terminal.c b/src/nvim/terminal.c
index 744579217b..46f141492b 100644
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -234,7 +234,7 @@ Terminal *terminal_open(buf_T *buf, TerminalOptions opts)
   set_option_value("wrap", false, NULL, OPT_LOCAL);
   set_option_value("list", false, NULL, OPT_LOCAL);
   if (buf->b_ffname != NULL) {
-    buf_set_term_title(buf, buf->b_ffname, strlen((char *)buf->b_ffname));
+    buf_set_term_title(buf, buf->b_ffname, strlen(buf->b_ffname));
   }
   RESET_BINDING(curwin);
   // Reset cursor in current window.
@@ -428,7 +428,7 @@ bool terminal_enter(void)
   long save_w_p_so = curwin->w_p_so;
   long save_w_p_siso = curwin->w_p_siso;
   if (curwin->w_p_cul && curwin->w_p_culopt_flags & CULOPT_NBR) {
-    if (STRCMP(curwin->w_p_culopt, "number")) {
+    if (strcmp(curwin->w_p_culopt, "number")) {
       save_w_p_culopt = curwin->w_p_culopt;
       curwin->w_p_culopt = xstrdup("number");
     }
diff --git a/src/nvim/testing.c b/src/nvim/testing.c
index 4a252dca3e..348d5c6e29 100644
--- a/src/nvim/testing.c
+++ b/src/nvim/testing.c
@@ -419,7 +419,7 @@ static int assert_equalfile(typval_T *argvars)
       line2[lineidx] = NUL;
       ga_concat(&ga, " after \"");
       ga_concat(&ga, line1);
-      if (STRCMP(line1, line2) != 0) {
+      if (strcmp(line1, line2) != 0) {
         ga_concat(&ga, "\" vs \"");
         ga_concat(&ga, line2);
       }
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index ab14f4d4ea..8ee708aa4d 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -567,7 +567,7 @@ int u_savecommon(buf_T *buf, linenr_T top, linenr_T bot, linenr_T newbot, int re
         u_freeentry(uep, i);
         return FAIL;
       }
-      uep->ue_array[i] = (char_u *)u_save_line_buf(buf, lnum++);
+      uep->ue_array[i] = u_save_line_buf(buf, lnum++);
     }
   } else {
     uep->ue_array = NULL;
@@ -1038,7 +1038,7 @@ static bool serialize_uep(bufinfo_T *bi, u_entry_T *uep)
     if (!undo_write_bytes(bi, len, 4)) {
       return false;
     }
-    if (len > 0 && !undo_write(bi, uep->ue_array[i], len)) {
+    if (len > 0 && !undo_write(bi, (char_u *)uep->ue_array[i], len)) {
       return false;
     }
   }
@@ -1064,7 +1064,7 @@ static u_entry_T *unserialize_uep(bufinfo_T *bi, bool *error, const char *file_n
       memset(array, 0, sizeof(char_u *) * (size_t)uep->ue_size);
     }
   }
-  uep->ue_array = array;
+  uep->ue_array = (char **)array;
 
   for (size_t i = 0; i < (size_t)uep->ue_size; i++) {
     int line_len = undo_read_4c(bi);
@@ -2283,7 +2283,7 @@ static void u_undoredo(int undo, bool do_buf_event)
         // line.
         long i;
         for (i = 0; i < newsize && i < oldsize; i++) {
-          if (STRCMP(uep->ue_array[i], ml_get(top + 1 + (linenr_T)i)) != 0) {
+          if (strcmp(uep->ue_array[i], ml_get(top + 1 + (linenr_T)i)) != 0) {
             break;
           }
         }
@@ -2327,9 +2327,9 @@ static void u_undoredo(int undo, bool do_buf_event)
         // If the file is empty, there is an empty line 1 that we
         // should get rid of, by replacing it with the new line
         if (empty_buffer && lnum == 0) {
-          ml_replace((linenr_T)1, (char *)uep->ue_array[i], true);
+          ml_replace((linenr_T)1, uep->ue_array[i], true);
         } else {
-          ml_append(lnum, (char *)uep->ue_array[i], (colnr_T)0, false);
+          ml_append(lnum, uep->ue_array[i], (colnr_T)0, false);
         }
         xfree(uep->ue_array[i]);
       }
@@ -2363,7 +2363,7 @@ static void u_undoredo(int undo, bool do_buf_event)
     u_newcount += newsize;
     u_oldcount += oldsize;
     uep->ue_size = oldsize;
-    uep->ue_array = newarray;
+    uep->ue_array = (char **)newarray;
     uep->ue_bot = top + newsize + 1;
 
     // insert this entry in front of the new entry list
@@ -2744,7 +2744,7 @@ void u_find_first_changed(void)
   linenr_T lnum;
   for (lnum = 1; lnum < curbuf->b_ml.ml_line_count
        && lnum <= uep->ue_size; lnum++) {
-    if (STRCMP(ml_get_buf(curbuf, lnum, false), uep->ue_array[lnum - 1]) != 0) {
+    if (strcmp(ml_get_buf(curbuf, lnum, false), uep->ue_array[lnum - 1]) != 0) {
       clearpos(&(uhp->uh_cursor));
       uhp->uh_cursor.lnum = lnum;
       return;
diff --git a/src/nvim/undo_defs.h b/src/nvim/undo_defs.h
index 4b64f97919..7c065c540b 100644
--- a/src/nvim/undo_defs.h
+++ b/src/nvim/undo_defs.h
@@ -21,11 +21,11 @@ typedef struct {
 
 typedef struct u_entry u_entry_T;
 struct u_entry {
-  u_entry_T *ue_next;         // pointer to next entry in list
+  u_entry_T *ue_next;           // pointer to next entry in list
   linenr_T ue_top;              // number of line above undo block
   linenr_T ue_bot;              // number of line below undo block
   linenr_T ue_lcount;           // linecount when u_save called
-  char_u **ue_array;       // array of lines in undo block
+  char **ue_array;              // array of lines in undo block
   long ue_size;                 // number of lines in ue_array
 #ifdef U_DEBUG
   int ue_magic;                 // magic number to check allocation
diff --git a/src/nvim/usercmd.c b/src/nvim/usercmd.c
index 3726273d28..6d6ba2466e 100644
--- a/src/nvim/usercmd.c
+++ b/src/nvim/usercmd.c
@@ -280,7 +280,7 @@ char *get_user_commands(expand_T *xp FUNC_ATTR_UNUSED, int idx)
     char *name = USER_CMD(idx)->uc_name;
 
     for (int i = 0; i < buf->b_ucmds.ga_len; i++) {
-      if (STRCMP(name, USER_CMD_GA(&buf->b_ucmds, i)->uc_name) == 0) {
+      if (strcmp(name, USER_CMD_GA(&buf->b_ucmds, i)->uc_name) == 0) {
         // global command is overruled by buffer-local one
         return "";
       }
@@ -1006,7 +1006,7 @@ void ex_delcommand(exarg_T *eap)
   for (;;) {
     for (i = 0; i < gap->ga_len; i++) {
       cmd = USER_CMD_GA(gap, i);
-      res = STRCMP(arg, cmd->uc_name);
+      res = strcmp(arg, cmd->uc_name);
       if (res <= 0) {
         break;
       }
diff --git a/src/nvim/vim.h b/src/nvim/vim.h
index ec8d6ab153..6c7bc05c82 100644
--- a/src/nvim/vim.h
+++ b/src/nvim/vim.h
@@ -205,7 +205,6 @@ enum { FOLD_TEXT_LEN = 51, };  //!< buffer size for get_foldtext()
 #define STRCPY(d, s)        strcpy((char *)(d), (char *)(s))
 #define STRNCPY(d, s, n)    strncpy((char *)(d), (char *)(s), (size_t)(n))
 #define STRLCPY(d, s, n)    xstrlcpy((char *)(d), (char *)(s), (size_t)(n))
-#define STRCMP(d, s)        strcmp((char *)(d), (char *)(s))
 #define STRNCMP(d, s, n)    strncmp((char *)(d), (char *)(s), (size_t)(n))
 #ifdef HAVE_STRCASECMP
 # define STRICMP(d, s)      strcasecmp((char *)(d), (char *)(s))
diff --git a/src/nvim/window.h b/src/nvim/window.h
index 3137035b25..a564a0cfad 100644
--- a/src/nvim/window.h
+++ b/src/nvim/window.h
@@ -45,8 +45,8 @@ typedef struct {
   do { \
     win_T *const wp_ = (wp); \
     const pos_T curpos_ = wp_->w_cursor; \
-    char_u cwd_[MAXPATHL]; \
-    char_u autocwd_[MAXPATHL]; \
+    char cwd_[MAXPATHL]; \
+    char autocwd_[MAXPATHL]; \
     bool apply_acd_ = false; \
     int cwd_status_ = FAIL; \
     /* Getting and setting directory can be slow on some systems, only do */ \
@@ -56,13 +56,13 @@ typedef struct {
         && (curwin->w_localdir != NULL || wp->w_localdir != NULL \
             || (curtab != tp && (curtab->tp_localdir != NULL || tp->tp_localdir != NULL)) \
             || p_acd)) { \
-      cwd_status_ = os_dirname(cwd_, MAXPATHL); \
+      cwd_status_ = os_dirname((char_u *)cwd_, MAXPATHL); \
     } \
     /* If 'acd' is set, check we are using that directory.  If yes, then */ \
     /* apply 'acd' afterwards, otherwise restore the current directory. */ \
     if (cwd_status_ == OK && p_acd) { \
       do_autochdir(); \
-      apply_acd_ = os_dirname(autocwd_, MAXPATHL) == OK && STRCMP(cwd_, autocwd_) == 0; \
+      apply_acd_ = os_dirname((char_u *)autocwd_, MAXPATHL) == OK && strcmp(cwd_, autocwd_) == 0; \
     } \
     switchwin_T switchwin_; \
     if (switch_win_noblock(&switchwin_, wp_, (tp), true) == OK) { \
@@ -73,7 +73,7 @@ typedef struct {
     if (apply_acd_) { \
       do_autochdir(); \
     } else if (cwd_status_ == OK) { \
-      os_chdir((char *)cwd_); \
+      os_chdir(cwd_); \
     } \
     /* Update the status line if the cursor moved. */ \
     if (win_valid(wp_) && !equalpos(curpos_, wp_->w_cursor)) { \
-- 
cgit 


From 684bc749efef0fa31395d349f4495d79ec5f3fd5 Mon Sep 17 00:00:00 2001
From: Dundar Göc <gocdundar@gmail.com>
Date: Fri, 26 Aug 2022 23:11:25 +0200
Subject: refactor: replace char_u with char

Work on https://github.com/neovim/neovim/issues/459
---
 src/nvim/arglist.c       |  2 +-
 src/nvim/autocmd.c       |  6 ++--
 src/nvim/buffer.c        |  4 +--
 src/nvim/cmdexpand.c     |  2 +-
 src/nvim/eval.c          | 10 +++---
 src/nvim/eval/funcs.c    | 22 ++++++------
 src/nvim/eval/userfunc.c |  4 +--
 src/nvim/ex_cmds.c       |  6 ++--
 src/nvim/ex_docmd.c      |  4 +--
 src/nvim/ex_getln.c      |  2 +-
 src/nvim/file_search.c   | 25 +++++++-------
 src/nvim/fileio.c        | 80 +++++++++++++++++++++----------------------
 src/nvim/garray.c        |  2 +-
 src/nvim/globals.h       |  2 +-
 src/nvim/hardcopy.c      | 14 ++++----
 src/nvim/help.c          | 44 ++++++++++++------------
 src/nvim/indent.c        |  2 +-
 src/nvim/insexpand.c     | 12 +++----
 src/nvim/lua/stdlib.c    |  4 +--
 src/nvim/mark.c          | 12 +++----
 src/nvim/memline.c       | 16 ++++-----
 src/nvim/option.c        | 34 +++++++++----------
 src/nvim/os/env.c        |  6 ++--
 src/nvim/path.c          | 88 ++++++++++++++++++++++++++----------------------
 src/nvim/profile.c       |  2 +-
 src/nvim/quickfix.c      | 48 +++++++++++++-------------
 src/nvim/regexp.c        | 12 +++----
 src/nvim/regexp_bt.c     |  4 +--
 src/nvim/regexp_defs.h   |  4 +--
 src/nvim/regexp_nfa.c    |  4 +--
 src/nvim/runtime.c       |  4 +--
 src/nvim/search.c        | 16 ++++-----
 src/nvim/shada.c         |  4 +--
 src/nvim/spell.c         |  8 ++---
 src/nvim/spellfile.c     |  2 +-
 src/nvim/spellsuggest.c  |  4 +--
 src/nvim/tag.c           |  2 +-
 src/nvim/undo.c          |  2 +-
 src/nvim/vim.h           | 18 ----------
 39 files changed, 262 insertions(+), 275 deletions(-)

(limited to 'src')

diff --git a/src/nvim/arglist.c b/src/nvim/arglist.c
index 0000636417..02e3a99aab 100644
--- a/src/nvim/arglist.c
+++ b/src/nvim/arglist.c
@@ -633,7 +633,7 @@ void ex_argdedupe(exarg_T *eap FUNC_ATTR_UNUSED)
 {
   for (int i = 0; i < ARGCOUNT; i++) {
     for (int j = i + 1; j < ARGCOUNT; j++) {
-      if (FNAMECMP(ARGLIST[i].ae_fname, ARGLIST[j].ae_fname) == 0) {
+      if (path_fnamecmp(ARGLIST[i].ae_fname, ARGLIST[j].ae_fname) == 0) {
         xfree(ARGLIST[j].ae_fname);
         memmove(ARGLIST + j, ARGLIST + j + 1,
                 (size_t)(ARGCOUNT - j - 1) * sizeof(aentry_T));
diff --git a/src/nvim/autocmd.c b/src/nvim/autocmd.c
index 635875b16f..9d37647a4e 100644
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -2396,7 +2396,7 @@ bool au_exists(const char *const arg) FUNC_ATTR_WARN_UNUSED_RESULT
   }
 
   // if pattern is "<buffer>", special handling is needed which uses curbuf
-  // for pattern "<buffer=N>, FNAMECMP() will work fine
+  // for pattern "<buffer=N>, path_fnamecmp() will work fine
   if (pattern != NULL && STRICMP(pattern, "<buffer>") == 0) {
     buflocal_buf = curbuf;
   }
@@ -2404,12 +2404,12 @@ bool au_exists(const char *const arg) FUNC_ATTR_WARN_UNUSED_RESULT
   // Check if there is an autocommand with the given pattern.
   for (; ap != NULL; ap = ap->next) {
     // only use a pattern when it has not been removed and has commands.
-    // For buffer-local autocommands, FNAMECMP() works fine.
+    // For buffer-local autocommands, path_fnamecmp() works fine.
     if (ap->pat != NULL && ap->cmds != NULL
         && (group == AUGROUP_ALL || ap->group == group)
         && (pattern == NULL
             || (buflocal_buf == NULL
-                ? FNAMECMP(ap->pat, pattern) == 0
+                ? path_fnamecmp(ap->pat, pattern) == 0
                 : ap->buflocal_nr == buflocal_buf->b_fnum))) {
       retval = true;
       break;
diff --git a/src/nvim/buffer.c b/src/nvim/buffer.c
index 658d372cee..1cc68c9cee 100644
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -2733,7 +2733,7 @@ void buflist_list(exarg_T *eap)
       IObuff[len++] = ' ';
     } while (--i > 0 && len < IOSIZE - 18);
     if (vim_strchr(eap->arg, 't') && buf->b_last_used) {
-      undo_fmt_time(IObuff + len, (size_t)(IOSIZE - len), buf->b_last_used);
+      undo_fmt_time((char_u *)IObuff + len, (size_t)(IOSIZE - len), buf->b_last_used);
     } else {
       vim_snprintf((char *)IObuff + len, (size_t)(IOSIZE - len), _("line %" PRId64),
                    buf == curbuf ? (int64_t)curwin->w_cursor.lnum : (int64_t)buflist_findlnum(buf));
@@ -2965,7 +2965,7 @@ static bool otherfile_buf(buf_T *buf, char *ffname, FileID *file_id_p, bool file
   if (ffname == NULL || *ffname == NUL || buf->b_ffname == NULL) {
     return true;
   }
-  if (FNAMECMP(ffname, buf->b_ffname) == 0) {
+  if (path_fnamecmp(ffname, buf->b_ffname) == 0) {
     return false;
   }
   {
diff --git a/src/nvim/cmdexpand.c b/src/nvim/cmdexpand.c
index d2cfb25bf9..3e9edea372 100644
--- a/src/nvim/cmdexpand.c
+++ b/src/nvim/cmdexpand.c
@@ -361,7 +361,7 @@ static char *ExpandOne_start(int mode, expand_T *xp, char *str, int options)
         // expand_wildcards, only need to check the first two.
         non_suf_match = 0;
         for (int i = 0; i < 2; i++) {
-          if (match_suffix((char_u *)xp->xp_files[i])) {
+          if (match_suffix(xp->xp_files[i])) {
             non_suf_match++;
           }
         }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index 0f2547120d..ead01fcbad 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -8117,7 +8117,7 @@ repeat:
 
         // Do not call shorten_fname() here since it removes the prefix
         // even though the path does not have a prefix.
-        if (FNAMENCMP(p, dirname, namelen) == 0) {
+        if (path_fnamencmp(p, dirname, namelen) == 0) {
           p += namelen;
           if (vim_ispathsep(*p)) {
             while (*p && vim_ispathsep(*p)) {
@@ -8329,7 +8329,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
     while (vim_regexec_nl(&regmatch, (char_u *)str, (colnr_T)(tail - str))) {
       // Skip empty match except for first match.
       if (regmatch.startp[0] == regmatch.endp[0]) {
-        if ((char_u *)zero_width == regmatch.startp[0]) {
+        if (zero_width == regmatch.startp[0]) {
           // avoid getting stuck on a match with an empty string
           int i = utfc_ptr2len(tail);
           memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
@@ -8337,7 +8337,7 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
           tail += i;
           continue;
         }
-        zero_width = (char *)regmatch.startp[0];
+        zero_width = regmatch.startp[0];
       }
 
       // Get some space for a temporary buffer to do the substitution
@@ -8350,14 +8350,14 @@ char *do_string_sub(char *str, char *pat, char *sub, typval_T *expr, char *flags
                          (regmatch.endp[0] - regmatch.startp[0])));
 
       // copy the text up to where the match is
-      int i = (int)(regmatch.startp[0] - (char_u *)tail);
+      int i = (int)(regmatch.startp[0] - tail);
       memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
       // add the substituted text
       (void)vim_regsub(&regmatch, (char_u *)sub, expr,
                        (char_u *)ga.ga_data + ga.ga_len + i, sublen,
                        REGSUB_COPY | REGSUB_MAGIC);
       ga.ga_len += i + sublen - 1;
-      tail = (char *)regmatch.endp[0];
+      tail = regmatch.endp[0];
       if (*tail == NUL) {
         break;
       }
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index fa48f227e3..b59caab34f 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -4984,9 +4984,9 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
         li = TV_LIST_ITEM_NEXT(l, li);
         idx++;
       } else {
-        startcol = (colnr_T)(regmatch.startp[0]
-                             + utfc_ptr2len((char *)regmatch.startp[0]) - str);
-        if (startcol > (colnr_T)len || str + startcol <= regmatch.startp[0]) {
+        startcol = (colnr_T)((char_u *)regmatch.startp[0]
+                             + utfc_ptr2len(regmatch.startp[0]) - str);
+        if (startcol > (colnr_T)len || str + startcol <= (char_u *)regmatch.startp[0]) {
           match = false;
           break;
         }
@@ -5005,8 +5005,8 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
 
         const size_t rd = (size_t)(regmatch.endp[0] - regmatch.startp[0]);
         TV_LIST_ITEM_TV(li1)->vval.v_string = xmemdupz((const char *)regmatch.startp[0], rd);
-        TV_LIST_ITEM_TV(li3)->vval.v_number = (varnumber_T)(regmatch.startp[0] - expr);
-        TV_LIST_ITEM_TV(li4)->vval.v_number = (varnumber_T)(regmatch.endp[0] - expr);
+        TV_LIST_ITEM_TV(li3)->vval.v_number = (varnumber_T)((char_u *)regmatch.startp[0] - expr);
+        TV_LIST_ITEM_TV(li4)->vval.v_number = (varnumber_T)(regmatch.endp[0] - (char *)expr);
         if (l != NULL) {
           TV_LIST_ITEM_TV(li2)->vval.v_number = (varnumber_T)idx;
         }
@@ -5041,10 +5041,10 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
         } else {
           if (type == kSomeMatch) {
             rettv->vval.v_number =
-              (varnumber_T)(regmatch.startp[0] - str);
+              (varnumber_T)((char_u *)regmatch.startp[0] - str);
           } else {
             rettv->vval.v_number =
-              (varnumber_T)(regmatch.endp[0] - str);
+              (varnumber_T)(regmatch.endp[0] - (char *)str);
           }
           rettv->vval.v_number += (varnumber_T)(str - expr);
         }
@@ -6225,8 +6225,8 @@ static void f_rename(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
     rettv->vval.v_number = -1;
   } else {
     char buf[NUMBUFLEN];
-    rettv->vval.v_number = vim_rename((const char_u *)tv_get_string(&argvars[0]),
-                                      (const char_u *)tv_get_string_buf(&argvars[1], buf));
+    rettv->vval.v_number = vim_rename(tv_get_string(&argvars[0]),
+                                      tv_get_string_buf(&argvars[1], buf));
   }
 }
 
@@ -8193,11 +8193,11 @@ static void f_split(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
         break;
       }
       // Advance to just after the match.
-      if (regmatch.endp[0] > (char_u *)str) {
+      if (regmatch.endp[0] > str) {
         col = 0;
       } else {
         // Don't get stuck at the same match.
-        col = utfc_ptr2len((char *)regmatch.endp[0]);
+        col = utfc_ptr2len(regmatch.endp[0]);
       }
       str = (const char *)regmatch.endp[0];
     }
diff --git a/src/nvim/eval/userfunc.c b/src/nvim/eval/userfunc.c
index a1c4b8b893..70c9e02d5c 100644
--- a/src/nvim/eval/userfunc.c
+++ b/src/nvim/eval/userfunc.c
@@ -2462,7 +2462,7 @@ void ex_function(exarg_T *eap)
         p = vim_strchr((char *)scriptname, '/');
         plen = (int)STRLEN(p);
         slen = (int)STRLEN(SOURCING_NAME);
-        if (slen > plen && FNAMECMP(p, SOURCING_NAME + slen - plen) == 0) {
+        if (slen > plen && path_fnamecmp(p, SOURCING_NAME + slen - plen) == 0) {
           j = OK;
         }
         xfree(scriptname);
@@ -2632,7 +2632,7 @@ char *get_user_func_name(expand_T *xp, int idx)
       return (char *)fp->uf_name;  // Prevent overflow.
     }
 
-    cat_func_name(IObuff, fp);
+    cat_func_name((char_u *)IObuff, fp);
     if (xp->xp_context != EXPAND_USER_FUNC) {
       STRCAT(IObuff, "(");
       if (!fp->uf_varargs && GA_EMPTY(&fp->uf_args)) {
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index 4f33a2d883..96bef4902c 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -559,10 +559,10 @@ void ex_sort(exarg_T *eap)
     end_col = len;
     if (regmatch.regprog != NULL && vim_regexec(&regmatch, s, 0)) {
       if (sort_rx) {
-        start_col = (colnr_T)(regmatch.startp[0] - (char_u *)s);
-        end_col = (colnr_T)(regmatch.endp[0] - (char_u *)s);
+        start_col = (colnr_T)(regmatch.startp[0] - s);
+        end_col = (colnr_T)(regmatch.endp[0] - s);
       } else {
-        start_col = (colnr_T)(regmatch.endp[0] - (char_u *)s);
+        start_col = (colnr_T)(regmatch.endp[0] - s);
       }
     } else if (regmatch.regprog != NULL) {
       end_col = 0;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index 2a378f6f02..5defabc05a 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -2836,12 +2836,12 @@ static void append_command(char *cmd)
   }
   STRCAT(IObuff, ": ");
   d = (char *)IObuff + STRLEN(IObuff);
-  while (*s != NUL && (char_u *)d - IObuff + 5 < IOSIZE) {
+  while (*s != NUL && d - IObuff + 5 < IOSIZE) {
     if ((char_u)s[0] == 0xc2 && (char_u)s[1] == 0xa0) {
       s += 2;
       STRCPY(d, "<a0>");
       d += 4;
-    } else if ((char_u *)d - IObuff + utfc_ptr2len(s) + 1 >= IOSIZE) {
+    } else if (d - IObuff + utfc_ptr2len(s) + 1 >= IOSIZE) {
       break;
     } else {
       mb_copy_char((const char **)&s, &d);
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 60c89f61a8..2b7797ddc8 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -2005,7 +2005,7 @@ static int command_line_handle_key(CommandLineState *s)
   } else {
     int j = utf_char2bytes(s->c, (char *)IObuff);
     IObuff[j] = NUL;                // exclude composing chars
-    put_on_cmdline(IObuff, j, true);
+    put_on_cmdline((char_u *)IObuff, j, true);
   }
   return command_line_changed(s);
 }
diff --git a/src/nvim/file_search.c b/src/nvim/file_search.c
index 5416be651d..b3491e98c2 100644
--- a/src/nvim/file_search.c
+++ b/src/nvim/file_search.c
@@ -112,7 +112,7 @@ typedef struct ff_visited {
   FileID file_id;
   // The memory for this struct is allocated according to the length of
   // ffv_fname.
-  char_u ffv_fname[1];                  // actually longer
+  char ffv_fname[1];                  // actually longer
 } ff_visited_T;
 
 // We might have to manage several visited lists during a search.
@@ -463,7 +463,7 @@ void *vim_findfile_init(char *path, char *filename, char *stopdirs, int level, i
           xfree(buf);
           goto error_return;
         }
-        STRLCAT(ff_expand_buffer, search_ctx->ffsc_fix_path, eb_len + (size_t)len + 1);
+        xstrlcat(ff_expand_buffer, search_ctx->ffsc_fix_path, eb_len + (size_t)len + 1);
         add_pathsep(ff_expand_buffer);
       } else {
         len = (int)STRLEN(search_ctx->ffsc_fix_path);
@@ -813,8 +813,7 @@ char_u *vim_findfile(void *search_ctx_arg)
                 }
                 if (os_dirname((char_u *)ff_expand_buffer, MAXPATHL)
                     == OK) {
-                  p = path_shorten_fname(file_path,
-                                         (char_u *)ff_expand_buffer);
+                  p = (char_u *)path_shorten_fname((char *)file_path, ff_expand_buffer);
                   if (p != NULL) {
                     STRMOVE(file_path, p);
                   }
@@ -859,8 +858,8 @@ char_u *vim_findfile(void *search_ctx_arg)
       if (STRNCMP(stackp->ffs_wc_path, "**", 2) == 0) {
         for (int i = stackp->ffs_filearray_cur;
              i < stackp->ffs_filearray_size; i++) {
-          if (FNAMECMP(stackp->ffs_filearray[i],
-                       stackp->ffs_fix_path) == 0) {
+          if (path_fnamecmp(stackp->ffs_filearray[i],
+                            (char *)stackp->ffs_fix_path) == 0) {
             continue;             // don't repush same directory
           }
           if (!os_isdir(stackp->ffs_filearray[i])) {
@@ -883,9 +882,9 @@ char_u *vim_findfile(void *search_ctx_arg)
       ff_stack_T *sptr;
 
       // is the last starting directory in the stop list?
-      if (ff_path_in_stoplist((char_u *)search_ctx->ffsc_start_dir,
+      if (ff_path_in_stoplist(search_ctx->ffsc_start_dir,
                               (int)(path_end - (char_u *)search_ctx->ffsc_start_dir),
-                              (char_u **)search_ctx->ffsc_stopdirs_v) == true) {
+                              search_ctx->ffsc_stopdirs_v) == true) {
         break;
       }
 
@@ -981,7 +980,7 @@ static ff_visited_list_hdr_T *ff_get_visited_list(char *filename,
   if (*list_headp != NULL) {
     retptr = *list_headp;
     while (retptr != NULL) {
-      if (FNAMECMP(filename, retptr->ffvl_filename) == 0) {
+      if (path_fnamecmp(filename, retptr->ffvl_filename) == 0) {
 #ifdef FF_VERBOSE
         if (p_verbose >= 5) {
           verbose_enter_scroll();
@@ -1080,7 +1079,7 @@ static int ff_check_visited(ff_visited_T **visited_list, char *fname, char *wc_p
 
   // check against list of already visited files
   for (vp = *visited_list; vp != NULL; vp = vp->ffv_next) {
-    if ((url && FNAMECMP(vp->ffv_fname, ff_expand_buffer) == 0)
+    if ((url && path_fnamecmp(vp->ffv_fname, ff_expand_buffer) == 0)
         || (!url && vp->file_id_valid
             && os_fileid_equal(&(vp->file_id), &file_id))) {
       // are the wildcard parts equal
@@ -1224,7 +1223,7 @@ static void ff_clear(ff_search_ctx_T *search_ctx)
 /// check if the given path is in the stopdirs
 ///
 /// @return  true if yes else false
-static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
+static int ff_path_in_stoplist(char *path, int path_len, char **stopdirs_v)
 {
   int i = 0;
 
@@ -1243,12 +1242,12 @@ static int ff_path_in_stoplist(char_u *path, int path_len, char_u **stopdirs_v)
       // match for parent directory. So '/home' also matches
       // '/home/rks'. Check for PATHSEP in stopdirs_v[i], else
       // '/home/r' would also match '/home/rks'
-      if (FNAMENCMP(stopdirs_v[i], path, path_len) == 0
+      if (path_fnamencmp(stopdirs_v[i], path, (size_t)path_len) == 0
           && vim_ispathsep(stopdirs_v[i][path_len])) {
         return true;
       }
     } else {
-      if (FNAMECMP(stopdirs_v[i], path) == 0) {
+      if (path_fnamecmp(stopdirs_v[i], path) == 0) {
         return true;
       }
     }
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 7b117aa6e3..0bc7f736bc 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -117,7 +117,7 @@ struct bw_info {
 
 static char *e_auchangedbuf = N_("E812: Autocommands changed buffer or buffer name");
 
-void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
+void filemess(buf_T *buf, char *name, char *s, int attr)
 {
   int msg_scroll_save;
 
@@ -126,7 +126,7 @@ void filemess(buf_T *buf, char_u *name, char_u *s, int attr)
   }
   add_quoted_fname((char *)IObuff, IOSIZE - 100, buf, (const char *)name);
   // Avoid an over-long translation to cause trouble.
-  STRLCAT(IObuff, s, IOSIZE);
+  xstrlcat(IObuff, s, IOSIZE);
   // For the first message may have to start a new line.
   // For further ones overwrite the previous one, reset msg_scroll before
   // calling filemess().
@@ -350,7 +350,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
 
     // If the name is too long we might crash further on, quit here.
     if (namelen >= MAXPATHL) {
-      filemess(curbuf, (char_u *)fname, (char_u *)_("Illegal file name"), 0);
+      filemess(curbuf, fname, _("Illegal file name"), 0);
       msg_end();
       msg_scroll = msg_save;
       return FAIL;
@@ -361,7 +361,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
     // swap file may destroy it!  Reported on MS-DOS and Win 95.
     if (after_pathsep(fname, fname + namelen)) {
       if (!silent) {
-        filemess(curbuf, (char_u *)fname, (char_u *)_(msg_is_a_directory), 0);
+        filemess(curbuf, fname, _(msg_is_a_directory), 0);
       }
       msg_end();
       msg_scroll = msg_save;
@@ -383,10 +383,10 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
         ) {
       if (S_ISDIR(perm)) {
         if (!silent) {
-          filemess(curbuf, (char_u *)fname, (char_u *)_(msg_is_a_directory), 0);
+          filemess(curbuf, fname, _(msg_is_a_directory), 0);
         }
       } else {
-        filemess(curbuf, (char_u *)fname, (char_u *)_("is not a file"), 0);
+        filemess(curbuf, fname, _("is not a file"), 0);
       }
       msg_end();
       msg_scroll = msg_save;
@@ -475,9 +475,9 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
       }
       if (!silent) {
         if (dir_of_file_exists((char_u *)fname)) {
-          filemess(curbuf, (char_u *)sfname, (char_u *)new_file_message(), 0);
+          filemess(curbuf, sfname, new_file_message(), 0);
         } else {
-          filemess(curbuf, (char_u *)sfname, (char_u *)_("[New DIRECTORY]"), 0);
+          filemess(curbuf, sfname, _("[New DIRECTORY]"), 0);
         }
       }
       // Even though this is a new file, it might have been
@@ -497,15 +497,15 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
       }
       return OK;                  // a new file is not an error
     } else {
-      filemess(curbuf, (char_u *)sfname, (char_u *)((fd == UV_EFBIG) ? _("[File too big]") :
+      filemess(curbuf, sfname, ((fd == UV_EFBIG) ? _("[File too big]") :
 #if defined(UNIX) && defined(EOVERFLOW)
-                                                    // libuv only returns -errno
-                                                    // in Unix and in Windows
-                                                    // open() does not set
-                                                    // EOVERFLOW
-                                                    (fd == -EOVERFLOW) ? _("[File too big]") :
+                                // libuv only returns -errno
+                                // in Unix and in Windows
+                                // open() does not set
+                                // EOVERFLOW
+                                (fd == -EOVERFLOW) ? _("[File too big]") :
 #endif
-                                                    _("[Permission Denied]")), 0);
+                                _("[Permission Denied]")), 0);
       curbuf->b_p_ro = true;                  // must use "w!" now
     }
 
@@ -661,7 +661,7 @@ int readfile(char *fname, char *sfname, linenr_T from, linenr_T lines_to_skip,
 
   if (!recoverymode && !filtering && !(flags & READ_DUMMY) && !silent) {
     if (!read_stdin && !read_buffer) {
-      filemess(curbuf, (char_u *)sfname, (char_u *)"", 0);
+      filemess(curbuf, sfname, "", 0);
     }
   }
 
@@ -1728,7 +1728,7 @@ failed:
 
     if (got_int) {
       if (!(flags & READ_DUMMY)) {
-        filemess(curbuf, (char_u *)sfname, (char_u *)_(e_interr), 0);
+        filemess(curbuf, sfname, _(e_interr), 0);
         if (newfile) {
           curbuf->b_p_ro = true;                // must use "w!" now
         }
@@ -2253,7 +2253,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
   fname = sfname;
 #endif
 
-  if (buf->b_ffname != NULL && FNAMECMP(ffname, buf->b_ffname) == 0) {
+  if (buf->b_ffname != NULL && path_fnamecmp(ffname, buf->b_ffname) == 0) {
     overwriting = true;
   } else {
     overwriting = false;
@@ -2455,9 +2455,9 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
 #ifndef UNIX
              (char_u *)sfname,
 #else
-             (char_u *)fname,
+             fname,
 #endif
-             (char_u *)"", 0);               // show that we are busy
+             "", 0);               // show that we are busy
   }
   msg_scroll = false;               // always overwrite the file message now
 
@@ -2596,7 +2596,7 @@ int buf_write(buf_T *buf, char *fname, char *sfname, linenr_T start, linenr_T en
         STRCPY(IObuff, fname);
         for (i = 4913;; i += 123) {
           char *tail = path_tail((char *)IObuff);
-          size_t size = (size_t)((char_u *)tail - IObuff);
+          size_t size = (size_t)(tail - IObuff);
           snprintf(tail, IOSIZE - size, "%d", i);
           if (!os_fileinfo_link((char *)IObuff, &file_info)) {
             break;
@@ -2884,7 +2884,7 @@ nobackup:
           // If the renaming of the original file to the backup file
           // works, quit here.
           ///
-          if (vim_rename((char_u *)fname, (char_u *)backup) == 0) {
+          if (vim_rename(fname, backup) == 0) {
             break;
           }
 
@@ -3100,7 +3100,7 @@ restore_backup:
               // In that case we leave the copy around.
               // If file does not exist, put the copy in its place
               if (!os_path_exists(fname)) {
-                vim_rename((char_u *)backup, (char_u *)fname);
+                vim_rename(backup, fname);
               }
               // if original file does exist throw away the copy
               if (os_path_exists(fname)) {
@@ -3108,7 +3108,7 @@ restore_backup:
               }
             } else {
               // try to put the original file back
-              vim_rename((char_u *)backup, (char_u *)fname);
+              vim_rename(backup, fname);
             }
           }
 
@@ -3375,7 +3375,7 @@ restore_backup:
           end = 1;  // success
         }
       } else {
-        if (vim_rename((char_u *)backup, (char_u *)fname) == 0) {
+        if (vim_rename(backup, fname) == 0) {
           end = 1;
         }
       }
@@ -3471,7 +3471,7 @@ restore_backup:
       if (org == NULL) {
         emsg(_("E205: Patchmode: can't save original file"));
       } else if (!os_path_exists(org)) {
-        vim_rename((char_u *)backup, (char_u *)org);
+        vim_rename(backup, org);
         XFREE_CLEAR(backup);                   // don't delete the file
 #ifdef UNIX
         os_file_settime(org,
@@ -3716,20 +3716,20 @@ void msg_add_lines(int insert_space, long lnum, off_T nchars)
 {
   char_u *p;
 
-  p = IObuff + STRLEN(IObuff);
+  p = (char_u *)IObuff + STRLEN(IObuff);
 
   if (insert_space) {
     *p++ = ' ';
   }
   if (shortmess(SHM_LINES)) {
-    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - IObuff)), "%" PRId64 "L, %" PRId64 "B",
+    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - (char_u *)IObuff)), "%" PRId64 "L, %" PRId64 "B",
                  (int64_t)lnum, (int64_t)nchars);
   } else {
-    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - IObuff)),
+    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - (char_u *)IObuff)),
                  NGETTEXT("%" PRId64 " line, ", "%" PRId64 " lines, ", lnum),
                  (int64_t)lnum);
     p += STRLEN(p);
-    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - IObuff)),
+    vim_snprintf((char *)p, (size_t)(IOSIZE - (p - (char_u *)IObuff)),
                  NGETTEXT("%" PRId64 " byte", "%" PRId64 " bytes", nchars),
                  (int64_t)nchars);
   }
@@ -4189,7 +4189,7 @@ void shorten_buf_fname(buf_T *buf, char_u *dirname, int force)
     if (buf->b_sfname != buf->b_ffname) {
       XFREE_CLEAR(buf->b_sfname);
     }
-    p = (char *)path_shorten_fname((char_u *)buf->b_ffname, dirname);
+    p = path_shorten_fname(buf->b_ffname, (char *)dirname);
     if (p != NULL) {
       buf->b_sfname = xstrdup(p);
       buf->b_fname = buf->b_sfname;
@@ -4481,7 +4481,7 @@ int put_time(FILE *fd, time_t time_)
 /// function will (attempts to?) copy the file across if rename fails -- webb
 ///
 /// @return  -1 for failure, 0 for success
-int vim_rename(const char_u *from, const char_u *to)
+int vim_rename(const char *from, const char *to)
   FUNC_ATTR_NONNULL_ALL
 {
   int fd_in;
@@ -4498,7 +4498,7 @@ int vim_rename(const char_u *from, const char_u *to)
   // When the names are identical, there is nothing to do.  When they refer
   // to the same file (ignoring case and slash/backslash differences) but
   // the file name differs we need to go through a temp file.
-  if (FNAMECMP(from, to) == 0) {
+  if (path_fnamecmp(from, to) == 0) {
     if (p_fic && (strcmp(path_tail((char *)from), path_tail((char *)to))
                   != 0)) {
       use_tmp_file = true;
@@ -4536,13 +4536,13 @@ int vim_rename(const char_u *from, const char_u *to)
       snprintf(tail, (size_t)((MAXPATHL + 1) - (tail - (char *)tempname - 1)), "%d", n);
 
       if (!os_path_exists((char *)tempname)) {
-        if (os_rename(from, tempname) == OK) {
-          if (os_rename(tempname, to) == OK) {
+        if (os_rename((char_u *)from, tempname) == OK) {
+          if (os_rename(tempname, (char_u *)to) == OK) {
             return 0;
           }
           // Strange, the second step failed.  Try moving the
           // file back and return failure.
-          (void)os_rename(tempname, from);
+          (void)os_rename(tempname, (char_u *)from);
           return -1;
         }
         // If it fails for one temp name it will most likely fail
@@ -4560,15 +4560,15 @@ int vim_rename(const char_u *from, const char_u *to)
   os_remove((char *)to);
 
   // First try a normal rename, return if it works.
-  if (os_rename(from, to) == OK) {
+  if (os_rename((char_u *)from, (char_u *)to) == OK) {
     return 0;
   }
 
   // Rename() failed, try copying the file.
-  perm = os_getperm((const char *)from);
+  perm = os_getperm(from);
 #ifdef HAVE_ACL
   // For systems that support ACL: get the ACL from the original file.
-  acl = mch_get_acl(from);
+  acl = mch_get_acl((char_u *)from);
 #endif
   fd_in = os_open((char *)from, O_RDONLY, 0);
   if (fd_in < 0) {
@@ -4621,7 +4621,7 @@ int vim_rename(const char_u *from, const char_u *to)
   os_setperm((const char *)to, perm);
 #endif
 #ifdef HAVE_ACL
-  mch_set_acl(to, acl);
+  mch_set_acl((char_u *)to, acl);
   mch_free_acl(acl);
 #endif
   if (errmsg != NULL) {
diff --git a/src/nvim/garray.c b/src/nvim/garray.c
index 1afabe4e10..adc3eda5ca 100644
--- a/src/nvim/garray.c
+++ b/src/nvim/garray.c
@@ -123,7 +123,7 @@ void ga_remove_duplicate_strings(garray_T *gap)
 
   // loop over the growing array in reverse
   for (int i = gap->ga_len - 1; i > 0; i--) {
-    if (FNAMECMP(fnames[i - 1], fnames[i]) == 0) {
+    if (path_fnamecmp(fnames[i - 1], fnames[i]) == 0) {
       xfree(fnames[i]);
 
       // close the gap (move all strings one slot lower)
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 84c01e0140..1cd8db6266 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -670,7 +670,7 @@ EXTERN bool cmd_silent INIT(= false);    // don't echo the command line
 EXTERN int swap_exists_action INIT(= SEA_NONE);  ///< For dialog when swap file already exists.
 EXTERN bool swap_exists_did_quit INIT(= false);  ///< Selected "quit" at the dialog.
 
-EXTERN char_u IObuff[IOSIZE];               ///< Buffer for sprintf, I/O, etc.
+EXTERN char IObuff[IOSIZE];                 ///< Buffer for sprintf, I/O, etc.
 EXTERN char NameBuff[MAXPATHL];             ///< Buffer for expanding file names
 EXTERN char msg_buf[MSG_BUF_LEN];           ///< Small buffer for messages
 EXTERN char os_buf[                         ///< Buffer for the os/ layer
diff --git a/src/nvim/hardcopy.c b/src/nvim/hardcopy.c
index 903349dcae..b530e2c5ec 100644
--- a/src/nvim/hardcopy.c
+++ b/src/nvim/hardcopy.c
@@ -734,7 +734,7 @@ void ex_hardcopy(exarg_T *eap)
           sprintf((char *)IObuff, _("Printing page %d (%zu%%)"),
                   page_count + 1 + side,
                   prtpos.bytes_printed * 100 / bytes_to_print);
-          if (!mch_print_begin_page(IObuff)) {
+          if (!mch_print_begin_page((char_u *)IObuff)) {
             goto print_fail;
           }
 
@@ -744,7 +744,7 @@ void ex_hardcopy(exarg_T *eap)
                     collated_copies + 1,
                     settings.n_collated_copies);
           }
-          prt_message(IObuff);
+          prt_message((char_u *)IObuff);
 
           // Output header if required
           if (prt_header_height() > 0) {
@@ -798,13 +798,13 @@ void ex_hardcopy(exarg_T *eap)
 
     vim_snprintf((char *)IObuff, IOSIZE, _("Printed: %s"),
                  settings.jobname);
-    prt_message(IObuff);
+    prt_message((char_u *)IObuff);
   }
 
 print_fail:
   if (got_int || settings.user_abort) {
-    sprintf((char *)IObuff, "%s", _("Printing aborted"));
-    prt_message(IObuff);
+    snprintf(IObuff, IOSIZE, "%s", _("Printing aborted"));
+    prt_message((char_u *)IObuff);
   }
   mch_print_end(&settings);
 
@@ -1493,8 +1493,8 @@ static int prt_find_resource(char *name, struct prt_ps_resource_S *resource)
   // Look for named resource file in runtimepath
   STRCPY(buffer, "print");
   add_pathsep(buffer);
-  STRLCAT(buffer, name, MAXPATHL);
-  STRLCAT(buffer, ".ps", MAXPATHL);
+  xstrlcat(buffer, name, MAXPATHL);
+  xstrlcat(buffer, ".ps", MAXPATHL);
   resource->filename[0] = NUL;
   retval = (do_in_runtimepath(buffer, 0, prt_resource_name, resource->filename)
             && resource->filename[0] != NUL);
diff --git a/src/nvim/help.c b/src/nvim/help.c
index 210c7b518c..507c5904b3 100644
--- a/src/nvim/help.c
+++ b/src/nvim/help.c
@@ -428,7 +428,7 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
         // completion.
         // Insert a backslash before '~', '$' and '.' to avoid their
         // special meaning.
-        if ((char_u *)d - IObuff > IOSIZE - 10) {           // getting too long!?
+        if (d - IObuff > IOSIZE - 10) {           // getting too long!?
           break;
         }
         switch (*s) {
@@ -459,7 +459,7 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
         if (*s < ' '
             || (*s == '^' && s[1]
                 && (ASCII_ISALPHA(s[1]) || vim_strchr("?@[\\]^", s[1]) != NULL))) {
-          if ((char_u *)d > IObuff && d[-1] != '_' && d[-1] != '\\') {
+          if (d > IObuff && d[-1] != '_' && d[-1] != '\\') {
             *d++ = '_';                 // prepend a '_' to make x_CTRL-x
           }
           STRCPY(d, "CTRL-");
@@ -513,15 +513,15 @@ int find_help_tags(const char *arg, int *num_matches, char ***matches, bool keep
       *d = NUL;
 
       if (*IObuff == '`') {
-        if ((char_u *)d > IObuff + 2 && d[-1] == '`') {
+        if (d > IObuff + 2 && d[-1] == '`') {
           // remove the backticks from `command`
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
           d[-2] = NUL;
-        } else if ((char_u *)d > IObuff + 3 && d[-2] == '`' && d[-1] == ',') {
+        } else if (d > IObuff + 3 && d[-2] == '`' && d[-1] == ',') {
           // remove the backticks and comma from `command`,
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
           d[-3] = NUL;
-        } else if ((char_u *)d > IObuff + 4 && d[-3] == '`'
+        } else if (d > IObuff + 4 && d[-3] == '`'
                    && d[-2] == '\\' && d[-1] == '.') {
           // remove the backticks and dot from `command`\.
           memmove(IObuff, IObuff + 1, STRLEN(IObuff));
@@ -687,8 +687,8 @@ void fix_help_buffer(void)
   // In the "help.txt" and "help.abx" file, add the locally added help
   // files.  This uses the very first line in the help file.
   char *const fname = path_tail(curbuf->b_fname);
-  if (FNAMECMP(fname, "help.txt") == 0
-      || (FNAMENCMP(fname, "help.", 5) == 0
+  if (path_fnamecmp(fname, "help.txt") == 0
+      || (path_fnamencmp(fname, "help.", 5) == 0
           && ASCII_ISALPHA(fname[5])
           && ASCII_ISALPHA(fname[6])
           && TOLOWER_ASC(fname[7]) == 'x'
@@ -715,8 +715,8 @@ void fix_help_buffer(void)
 
           // Find all "doc/ *.txt" files in this directory.
           if (!add_pathsep((char *)NameBuff)
-              || STRLCAT(NameBuff, "doc/*.??[tx]",  // NOLINT
-                         sizeof(NameBuff)) >= MAXPATHL) {
+              || xstrlcat(NameBuff, "doc/*.??[tx]",  // NOLINT
+                          sizeof(NameBuff)) >= MAXPATHL) {
             emsg(_(e_fnametoolong));
             continue;
           }
@@ -746,18 +746,18 @@ void fix_help_buffer(void)
                 if (e1 == NULL || e2 == NULL) {
                   continue;
                 }
-                if (FNAMECMP(e1, ".txt") != 0
-                    && FNAMECMP(e1, fname + 4) != 0) {
+                if (path_fnamecmp(e1, ".txt") != 0
+                    && path_fnamecmp(e1, fname + 4) != 0) {
                   // Not .txt and not .abx, remove it.
                   XFREE_CLEAR(fnames[i1]);
                   continue;
                 }
                 if (e1 - f1 != e2 - f2
-                    || FNAMENCMP(f1, f2, e1 - f1) != 0) {
+                    || path_fnamencmp(f1, f2, (size_t)(e1 - f1)) != 0) {
                   continue;
                 }
-                if (FNAMECMP(e1, ".txt") == 0
-                    && FNAMECMP(e2, fname + 4) == 0) {
+                if (path_fnamecmp(e1, ".txt") == 0
+                    && path_fnamecmp(e2, fname + 4) == 0) {
                   // use .abx instead of .txt
                   XFREE_CLEAR(fnames[i1]);
                 }
@@ -772,7 +772,7 @@ void fix_help_buffer(void)
               if (fd == NULL) {
                 continue;
               }
-              vim_fgets(IObuff, IOSIZE, fd);
+              vim_fgets((char_u *)IObuff, IOSIZE, fd);
               if (IObuff[0] == '*'
                   && (s = vim_strchr((char *)IObuff + 1, '*'))
                   != NULL) {
@@ -819,7 +819,7 @@ void fix_help_buffer(void)
                 convert_setup(&vc, NULL, NULL);
 
                 ml_append(lnum, cp, (colnr_T)0, false);
-                if ((char_u *)cp != IObuff) {
+                if (cp != IObuff) {
                   xfree(cp);
                 }
                 lnum++;
@@ -871,8 +871,8 @@ static void helptags_one(char *dir, const char *ext, const char *tagfname, bool
   // Find all *.txt files.
   size_t dirlen = STRLCPY(NameBuff, dir, sizeof(NameBuff));
   if (dirlen >= MAXPATHL
-      || STRLCAT(NameBuff, "/**/*", sizeof(NameBuff)) >= MAXPATHL  // NOLINT
-      || STRLCAT(NameBuff, ext, sizeof(NameBuff)) >= MAXPATHL) {
+      || xstrlcat(NameBuff, "/**/*", sizeof(NameBuff)) >= MAXPATHL  // NOLINT
+      || xstrlcat(NameBuff, ext, sizeof(NameBuff)) >= MAXPATHL) {
     emsg(_(e_fnametoolong));
     return;
   }
@@ -896,7 +896,7 @@ static void helptags_one(char *dir, const char *ext, const char *tagfname, bool
   // Do this before scanning through all the files.
   memcpy(NameBuff, dir, dirlen + 1);
   if (!add_pathsep((char *)NameBuff)
-      || STRLCAT(NameBuff, tagfname, sizeof(NameBuff)) >= MAXPATHL) {
+      || xstrlcat(NameBuff, tagfname, sizeof(NameBuff)) >= MAXPATHL) {
     emsg(_(e_fnametoolong));
     return;
   }
@@ -931,7 +931,7 @@ static void helptags_one(char *dir, const char *ext, const char *tagfname, bool
     const char *const fname = files[fi] + dirlen + 1;
 
     bool firstline = true;
-    while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int) {
+    while (!vim_fgets((char_u *)IObuff, IOSIZE, fd) && !got_int) {
       if (firstline) {
         // Detect utf-8 file by a non-ASCII char in the first line.
         TriState this_utf8 = kNone;
@@ -974,7 +974,7 @@ static void helptags_one(char *dir, const char *ext, const char *tagfname, bool
           // characters, there is white space before it and is
           // followed by a white character or end-of-line.
           if (s == p2
-              && ((char_u *)p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t')
+              && (p1 == IObuff || p1[-1] == ' ' || p1[-1] == '\t')
               && (vim_strchr(" \t\n\r", s[1]) != NULL
                   || s[1] == '\0')) {
             *p2 = '\0';
@@ -1067,7 +1067,7 @@ static void do_helptags(char *dirname, bool add_help_tags, bool ignore_writeerr)
   // Get a list of all files in the help directory and in subdirectories.
   STRLCPY(NameBuff, dirname, sizeof(NameBuff));
   if (!add_pathsep((char *)NameBuff)
-      || STRLCAT(NameBuff, "**", sizeof(NameBuff)) >= MAXPATHL) {
+      || xstrlcat(NameBuff, "**", sizeof(NameBuff)) >= MAXPATHL) {
     emsg(_(e_fnametoolong));
     return;
   }
diff --git a/src/nvim/indent.c b/src/nvim/indent.c
index af5bcd7d2a..0f7a5a8e44 100644
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -721,7 +721,7 @@ int get_number_indent(linenr_T lnum)
     // start matching for the flp beyond any comment leader...
     if (vim_regexec(&regmatch, ml_get(lnum) + lead_len, (colnr_T)0)) {
       pos.lnum = lnum;
-      pos.col = (colnr_T)(*regmatch.endp - (char_u *)ml_get(lnum));
+      pos.col = (colnr_T)(*regmatch.endp - ml_get(lnum));
       pos.coladd = 0;
     }
     vim_regfree(regmatch.regprog);
diff --git a/src/nvim/insexpand.c b/src/nvim/insexpand.c
index 7e229d5cb6..a5e7929525 100644
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -665,7 +665,7 @@ static char_u *ins_compl_infercase_gettext(char_u *str, int char_len, int compl_
   }
 
   *p = NUL;
-  return IObuff;
+  return (char_u *)IObuff;
 }
 
 /// This is like ins_compl_add(), but if 'ic' and 'inf' are set, then the
@@ -1443,20 +1443,20 @@ static void ins_compl_files(int count, char **files, int thesaurus, int flags, r
     while (!got_int && !compl_interrupted && !vim_fgets(buf, LSIZE, fp)) {
       ptr = buf;
       while (vim_regexec(regmatch, (char *)buf, (colnr_T)(ptr - buf))) {
-        ptr = regmatch->startp[0];
+        ptr = (char_u *)regmatch->startp[0];
         if (ctrl_x_mode_line_or_eval()) {
           ptr = find_line_end(ptr);
         } else {
           ptr = find_word_end(ptr);
         }
-        add_r = ins_compl_add_infercase(regmatch->startp[0],
-                                        (int)(ptr - regmatch->startp[0]),
+        add_r = ins_compl_add_infercase((char_u *)regmatch->startp[0],
+                                        (int)(ptr - (char_u *)regmatch->startp[0]),
                                         p_ic, (char_u *)files[i], *dir, false);
         if (thesaurus) {
           // For a thesaurus, add all the words in the line
           ptr = buf;
           add_r = thesaurus_add_words_in_line(files[i], &ptr, *dir,
-                                              regmatch->startp[0]);
+                                              (char_u *)regmatch->startp[0]);
         }
         if (add_r == OK) {
           // if dir was BACKWARD then honor it just once
@@ -2980,7 +2980,7 @@ static char_u *ins_comp_get_next_word_or_line(buf_T *ins_buf, pos_T *cur_match_p
           *cont_s_ipos = true;
         }
         IObuff[len] = NUL;
-        ptr = IObuff;
+        ptr = (char_u *)IObuff;
       }
       if (len == compl_length) {
         return NULL;
diff --git a/src/nvim/lua/stdlib.c b/src/nvim/lua/stdlib.c
index 3051017846..9b1890403e 100644
--- a/src/nvim/lua/stdlib.c
+++ b/src/nvim/lua/stdlib.c
@@ -60,8 +60,8 @@ static int regex_match(lua_State *lstate, regprog_T **prog, char_u *str)
   *prog = rm.regprog;
 
   if (match) {
-    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - str));
-    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.startp[0] - (char *)str));
+    lua_pushinteger(lstate, (lua_Integer)(rm.endp[0] - (char *)str));
     return 2;
   }
   return 0;
diff --git a/src/nvim/mark.c b/src/nvim/mark.c
index a6d0a68323..6f8aecb3ff 100644
--- a/src/nvim/mark.c
+++ b/src/nvim/mark.c
@@ -665,8 +665,8 @@ static void fname2fnum(xfmark_T *fm)
     }
 
     // Try to shorten the file name.
-    os_dirname(IObuff, IOSIZE);
-    p = path_shorten_fname((char_u *)NameBuff, IObuff);
+    os_dirname((char_u *)IObuff, IOSIZE);
+    p = (char_u *)path_shorten_fname(NameBuff, (char *)IObuff);
 
     // buflist_new() will call fmarks_check_names()
     (void)buflist_new((char *)NameBuff, (char *)p, (linenr_T)1, 0);
@@ -686,21 +686,21 @@ void fmarks_check_names(buf_T *buf)
   }
 
   for (i = 0; i < NGLOBALMARKS; i++) {
-    fmarks_check_one(&namedfm[i], name, buf);
+    fmarks_check_one(&namedfm[i], (char *)name, buf);
   }
 
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
     for (i = 0; i < wp->w_jumplistlen; i++) {
-      fmarks_check_one(&wp->w_jumplist[i], name, buf);
+      fmarks_check_one(&wp->w_jumplist[i], (char *)name, buf);
     }
   }
 }
 
-static void fmarks_check_one(xfmark_T *fm, char_u *name, buf_T *buf)
+static void fmarks_check_one(xfmark_T *fm, char *name, buf_T *buf)
 {
   if (fm->fmark.fnum == 0
       && fm->fname != NULL
-      && FNAMECMP(name, fm->fname) == 0) {
+      && path_fnamecmp(name, fm->fname) == 0) {
     fm->fmark.fnum = buf->b_fnum;
     XFREE_CLEAR(fm->fname);
   }
diff --git a/src/nvim/memline.c b/src/nvim/memline.c
index c288703328..9d1ad5903d 100644
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -349,7 +349,7 @@ void ml_setname(buf_T *buf)
 {
   bool success = false;
   memfile_T *mfp;
-  char_u *fname;
+  char *fname;
   char *dirp;
 
   mfp = buf->b_ml.ml_mfp;
@@ -369,7 +369,7 @@ void ml_setname(buf_T *buf)
     if (*dirp == NUL) {             // tried all directories, fail
       break;
     }
-    fname = (char_u *)findswapname(buf, &dirp, mfp->mf_fname, &found_existing_dir);
+    fname = findswapname(buf, &dirp, mfp->mf_fname, &found_existing_dir);
     // alloc's fname
     if (dirp == NULL) {             // out of memory
       break;
@@ -379,7 +379,7 @@ void ml_setname(buf_T *buf)
     }
 
     // if the file name is the same we don't have to do anything
-    if (FNAMECMP(fname, mfp->mf_fname) == 0) {
+    if (path_fnamecmp(fname, mfp->mf_fname) == 0) {
       xfree(fname);
       success = true;
       break;
@@ -391,10 +391,10 @@ void ml_setname(buf_T *buf)
     }
 
     // try to rename the swap file
-    if (vim_rename((char_u *)mfp->mf_fname, fname) == 0) {
+    if (vim_rename(mfp->mf_fname, fname) == 0) {
       success = true;
       mf_free_fnames(mfp);
-      mf_set_fnames(mfp, (char *)fname);
+      mf_set_fnames(mfp, fname);
       ml_upd_block0(buf, UB_SAME_DIR);
       break;
     }
@@ -3273,7 +3273,7 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
     }
 
     // A file name equal to old_fname is OK to use.
-    if (old_fname != NULL && FNAMECMP(fname, old_fname) == 0) {
+    if (old_fname != NULL && path_fnamecmp(fname, old_fname) == 0) {
       break;
     }
 
@@ -3298,8 +3298,8 @@ static char *findswapname(buf_T *buf, char **dirp, char *old_fname, bool *found_
             // buffer don't compare the directory names, they can
             // have a different mountpoint.
             if (b0.b0_flags & B0_SAME_DIR) {
-              if (FNAMECMP(path_tail((char *)buf->b_ffname),
-                           path_tail((char *)b0.b0_fname)) != 0
+              if (path_fnamecmp(path_tail(buf->b_ffname),
+                                path_tail((char *)b0.b0_fname)) != 0
                   || !same_directory((char_u *)fname, (char_u *)buf->b_ffname)) {
                 // Symlinks may point to the same file even
                 // when the name differs, need to check the
diff --git a/src/nvim/option.c b/src/nvim/option.c
index dbc2102541..ab4db30aaf 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -654,8 +654,8 @@ void set_init_3(void)
     // Default for p_sp is "| tee", for p_srr is ">".
     // For known shells it is changed here to include stderr.
     //
-    if (FNAMECMP(p, "csh") == 0
-        || FNAMECMP(p, "tcsh") == 0) {
+    if (path_fnamecmp(p, "csh") == 0
+        || path_fnamecmp(p, "tcsh") == 0) {
       if (do_sp) {
         p_sp = "|& tee";
         options[idx_sp].def_val = p_sp;
@@ -664,16 +664,16 @@ void set_init_3(void)
         p_srr = ">&";
         options[idx_srr].def_val = p_srr;
       }
-    } else if (FNAMECMP(p, "sh") == 0
-               || FNAMECMP(p, "ksh") == 0
-               || FNAMECMP(p, "mksh") == 0
-               || FNAMECMP(p, "pdksh") == 0
-               || FNAMECMP(p, "zsh") == 0
-               || FNAMECMP(p, "zsh-beta") == 0
-               || FNAMECMP(p, "bash") == 0
-               || FNAMECMP(p, "fish") == 0
-               || FNAMECMP(p, "ash") == 0
-               || FNAMECMP(p, "dash") == 0) {
+    } else if (path_fnamecmp(p, "sh") == 0
+               || path_fnamecmp(p, "ksh") == 0
+               || path_fnamecmp(p, "mksh") == 0
+               || path_fnamecmp(p, "pdksh") == 0
+               || path_fnamecmp(p, "zsh") == 0
+               || path_fnamecmp(p, "zsh-beta") == 0
+               || path_fnamecmp(p, "bash") == 0
+               || path_fnamecmp(p, "fish") == 0
+               || path_fnamecmp(p, "ash") == 0
+               || path_fnamecmp(p, "dash") == 0) {
       // Always use POSIX shell style redirection if we reach this
       if (do_sp) {
         p_sp = "2>&1| tee";
@@ -1237,19 +1237,19 @@ int do_set(char *arg, int opt_flags)
                 *errbuf = NUL;
                 i = getdigits_int(&arg, true, 0);
                 if (i & 1) {
-                  STRLCAT(errbuf, "b,", sizeof(errbuf));
+                  xstrlcat(errbuf, "b,", sizeof(errbuf));
                 }
                 if (i & 2) {
-                  STRLCAT(errbuf, "s,", sizeof(errbuf));
+                  xstrlcat(errbuf, "s,", sizeof(errbuf));
                 }
                 if (i & 4) {
-                  STRLCAT(errbuf, "h,l,", sizeof(errbuf));
+                  xstrlcat(errbuf, "h,l,", sizeof(errbuf));
                 }
                 if (i & 8) {
-                  STRLCAT(errbuf, "<,>,", sizeof(errbuf));
+                  xstrlcat(errbuf, "<,>,", sizeof(errbuf));
                 }
                 if (i & 16) {
-                  STRLCAT(errbuf, "[,],", sizeof(errbuf));
+                  xstrlcat(errbuf, "[,],", sizeof(errbuf));
                 }
                 save_arg = (char_u *)arg;
                 arg = errbuf;
diff --git a/src/nvim/os/env.c b/src/nvim/os/env.c
index 2f2a8c7fdc..34ed3aaf6e 100644
--- a/src/nvim/os/env.c
+++ b/src/nvim/os/env.c
@@ -476,7 +476,7 @@ void init_homedir(void)
     // Change to the directory and get the actual path.  This resolves
     // links.  Don't do it when we can't return.
     if (os_dirname((char_u *)os_buf, MAXPATHL) == OK && os_chdir(os_buf) == 0) {
-      if (!os_chdir(var) && os_dirname(IObuff, IOSIZE) == OK) {
+      if (!os_chdir(var) && os_dirname((char_u *)IObuff, IOSIZE) == OK) {
         var = (char *)IObuff;
       }
       if (os_chdir(os_buf) != 0) {
@@ -804,7 +804,7 @@ static char *remove_tail(char *path, char *pend, char *dirname)
   char *new_tail = pend - len - 1;
 
   if (new_tail >= path
-      && FNAMENCMP((char_u *)new_tail, (char_u *)dirname, len) == 0
+      && path_fnamencmp(new_tail, dirname, len) == 0
       && (new_tail == path || after_pathsep(path, new_tail))) {
     return new_tail;
   }
@@ -1098,7 +1098,7 @@ size_t home_replace(const buf_T *const buf, const char *src, char *const dst, si
     size_t len = dirlen;
     for (;;) {
       if (len
-          && FNAMENCMP(src, (char_u *)p, len) == 0
+          && path_fnamencmp(src, p, len) == 0
           && (vim_ispathsep(src[len])
               || (!one && (src[len] == ',' || src[len] == ' '))
               || src[len] == NUL)) {
diff --git a/src/nvim/path.c b/src/nvim/path.c
index accd7badbb..38112be3ce 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -73,7 +73,7 @@ FileComparison path_full_compare(char *const s1, char *const s2, const bool chec
     if (checkname) {
       vim_FullName(exp1, full1, MAXPATHL, false);
       vim_FullName(s2, full2, MAXPATHL, false);
-      if (FNAMECMP(full1, full2) == 0) {
+      if (path_fnamecmp(full1, full2) == 0) {
         return kEqualFileNames;
       }
     }
@@ -331,6 +331,12 @@ bool dir_of_file_exists(char_u *fname)
 
 /// Compare two file names
 ///
+/// On some systems case in a file name does not matter, on others it does.
+///
+/// @note Does not account for maximum name lengths and things like "../dir",
+///       thus it is not 100% accurate. OS may also use different algorithm for
+///       case-insensitive comparison.
+///
 /// Handles '/' and '\\' correctly and deals with &fileignorecase option.
 ///
 /// @param[in]  fname1  First file name.
@@ -575,7 +581,7 @@ bool path_has_exp_wildcard(const char_u *p)
 static size_t path_expand(garray_T *gap, const char_u *path, int flags)
   FUNC_ATTR_NONNULL_ALL
 {
-  return do_path_expand(gap, path, 0, flags, false);
+  return do_path_expand(gap, (char *)path, 0, flags, false);
 }
 
 static const char *scandir_next_with_dots(Directory *dir)
@@ -596,7 +602,7 @@ static const char *scandir_next_with_dots(Directory *dir)
 /// Implementation of path_expand().
 ///
 /// Chars before `path + wildoff` do not get expanded.
-static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff, int flags,
+static size_t do_path_expand(garray_T *gap, const char *path, size_t wildoff, int flags,
                              bool didstar)
   FUNC_ATTR_NONNULL_ALL
 {
@@ -623,18 +629,18 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   char_u *p = buf;
   char_u *s = buf;
   char_u *e = NULL;
-  const char_u *path_end = path;
+  const char_u *path_end = (char_u *)path;
   while (*path_end != NUL) {
     // May ignore a wildcard that has a backslash before it; it will
     // be removed by rem_backslash() or file_pat_to_reg_pat() below.
-    if (path_end >= path + wildoff && rem_backslash((char *)path_end)) {
+    if (path_end >= (char_u *)path + wildoff && rem_backslash((char *)path_end)) {
       *p++ = *path_end++;
     } else if (vim_ispathsep_nocolon(*path_end)) {
       if (e != NULL) {
         break;
       }
       s = p + 1;
-    } else if (path_end >= path + wildoff
+    } else if (path_end >= (char_u *)path + wildoff
                && (vim_strchr("*?[{~$", *path_end) != NULL
 #ifndef WIN32
                    || (!p_fic && (flags & EW_ICASE) && mb_isalpha(utf_ptr2char((char *)path_end)))
@@ -704,7 +710,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
       && *path_end == '/') {
     STRCPY(s, path_end + 1);
     stardepth++;
-    (void)do_path_expand(gap, buf, (size_t)(s - buf), flags, true);
+    (void)do_path_expand(gap, (char *)buf, (size_t)(s - buf), flags, true);
     stardepth--;
   }
   *s = NUL;
@@ -713,17 +719,17 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
   char *dirpath = (*buf == NUL ? "." : (char *)buf);
   if (os_file_is_readable(dirpath) && os_scandir(&dir, dirpath)) {
     // Find all matching entries.
-    char_u *name;
+    char *name;
     scandir_next_with_dots(NULL);  // initialize
-    while (!got_int && (name = (char_u *)scandir_next_with_dots(&dir)) != NULL) {
+    while (!got_int && (name = (char *)scandir_next_with_dots(&dir)) != NULL) {
       if ((name[0] != '.'
            || starts_with_dot
            || ((flags & EW_DODOT)
                && name[1] != NUL
                && (name[1] != '.' || name[2] != NUL)))  // -V557
-          && ((regmatch.regprog != NULL && vim_regexec(&regmatch, (char *)name, 0))
+          && ((regmatch.regprog != NULL && vim_regexec(&regmatch, name, 0))
               || ((flags & EW_NOTWILD)
-                  && FNAMENCMP(path + (s - buf), name, e - s) == 0))) {
+                  && path_fnamencmp(path + (s - buf), name, (size_t)(e - s)) == 0))) {
         STRCPY(s, name);
         len = STRLEN(buf);
 
@@ -733,7 +739,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
           STRCPY(buf + len, "/**");  // NOLINT
           STRCPY(buf + len + 3, path_end);
           stardepth++;
-          (void)do_path_expand(gap, buf, len + 1, flags, true);
+          (void)do_path_expand(gap, (char *)buf, len + 1, flags, true);
           stardepth--;
         }
 
@@ -741,7 +747,7 @@ static size_t do_path_expand(garray_T *gap, const char_u *path, size_t wildoff,
         if (path_has_exp_wildcard(path_end)) {      // handle more wildcards
           // need to expand another component of the path
           // remove backslashes for the remaining components only
-          (void)do_path_expand(gap, buf, len + 1, flags, false);
+          (void)do_path_expand(gap, (char *)buf, len + 1, flags, false);
         } else {
           FileInfo file_info;
 
@@ -797,9 +803,9 @@ static int find_previous_pathsep(char_u *path, char_u **psep)
 
 /// Returns true if "maybe_unique" is unique wrt other_paths in "gap".
 /// "maybe_unique" is the end portion of "((char_u **)gap->ga_data)[i]".
-static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
+static bool is_unique(char *maybe_unique, garray_T *gap, int i)
 {
-  char_u **other_paths = (char_u **)gap->ga_data;
+  char **other_paths = gap->ga_data;
 
   for (int j = 0; j < gap->ga_len; j++) {
     if (j == i) {
@@ -810,8 +816,8 @@ static bool is_unique(char_u *maybe_unique, garray_T *gap, int i)
     if (other_path_len < candidate_len) {
       continue;  // it's different when it's shorter
     }
-    char_u *rival = other_paths[j] + other_path_len - candidate_len;
-    if (FNAMECMP(maybe_unique, rival) == 0
+    char *rival = other_paths[j] + other_path_len - candidate_len;
+    if (path_fnamecmp(maybe_unique, rival) == 0
         && (rival == other_paths[j] || vim_ispathsep(*(rival - 1)))) {
       return false;  // match
     }
@@ -950,9 +956,9 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
     return;
   }
 
-  char_u *curdir = xmalloc(MAXPATHL);
-  os_dirname(curdir, MAXPATHL);
-  expand_path_option(curdir, &path_ga);
+  char *curdir = xmalloc(MAXPATHL);
+  os_dirname((char_u *)curdir, MAXPATHL);
+  expand_path_option((char_u *)curdir, &path_ga);
 
   in_curdir = xcalloc((size_t)gap->ga_len, sizeof(char_u *));
 
@@ -964,7 +970,7 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
     char *path_cutoff;
 
     len = STRLEN(path);
-    is_in_curdir = FNAMENCMP(curdir, path, dir_end - path) == 0
+    is_in_curdir = path_fnamencmp(curdir, path, (size_t)(dir_end - path)) == 0
                    && curdir[dir_end - path] == NUL;
     if (is_in_curdir) {
       in_curdir[i] = xstrdup(path);
@@ -980,7 +986,7 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
         && vim_ispathsep_nocolon(pattern[2])
         && path_cutoff != NULL
         && vim_regexec(&regmatch, path_cutoff, (colnr_T)0)
-        && is_unique((char_u *)path_cutoff, gap, i)) {
+        && is_unique(path_cutoff, gap, i)) {
       sort_again = true;
       memmove(path, path_cutoff, STRLEN(path_cutoff) + 1);
     } else {
@@ -989,7 +995,7 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
       pathsep_p = path + len - 1;
       while (find_previous_pathsep((char_u *)path, (char_u **)&pathsep_p)) {
         if (vim_regexec(&regmatch, pathsep_p + 1, (colnr_T)0)
-            && is_unique((char_u *)pathsep_p + 1, gap, i)
+            && is_unique(pathsep_p + 1, gap, i)
             && path_cutoff != NULL && pathsep_p + 1 >= path_cutoff) {
           sort_again = true;
           memmove(path, pathsep_p + 1, STRLEN(pathsep_p));
@@ -1009,7 +1015,7 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
       //     c:\foo\bar\file.txt   c:\foo\bar    .\file.txt
       //     /file.txt             /             /file.txt
       //     c:\file.txt           c:\           .\file.txt
-      short_name = (char *)path_shorten_fname((char_u *)path, curdir);
+      short_name = path_shorten_fname(path, curdir);
       if (short_name != NULL && short_name > path + 1) {
         STRCPY(path, ".");
         add_pathsep(path);
@@ -1030,11 +1036,11 @@ static void uniquefy_paths(garray_T *gap, char_u *pattern)
 
     // If the {filename} is not unique, change it to ./{filename}.
     // Else reduce it to {filename}
-    short_name = (char *)path_shorten_fname((char_u *)path, curdir);
+    short_name = path_shorten_fname(path, curdir);
     if (short_name == NULL) {
       short_name = path;
     }
-    if (is_unique((char_u *)short_name, gap, i)) {
+    if (is_unique(short_name, gap, i)) {
       STRCPY(fnames[i], short_name);
       continue;
     }
@@ -2037,7 +2043,7 @@ char_u *path_try_shorten_fname(char_u *full_path)
   char_u *p = full_path;
 
   if (os_dirname(dirname, MAXPATHL) == OK) {
-    p = path_shorten_fname(full_path, dirname);
+    p = (char_u *)path_shorten_fname((char *)full_path, (char *)dirname);
     if (p == NULL || *p == NUL) {
       p = full_path;
     }
@@ -2053,7 +2059,7 @@ char_u *path_try_shorten_fname(char_u *full_path)
 /// @return
 ///   - Pointer into `full_path` if shortened.
 ///   - NULL if no shorter name is possible.
-char_u *path_shorten_fname(char_u *full_path, char_u *dir_name)
+char *path_shorten_fname(char *full_path, char *dir_name)
 {
   if (full_path == NULL) {
     return NULL;
@@ -2063,17 +2069,17 @@ char_u *path_shorten_fname(char_u *full_path, char_u *dir_name)
   size_t len = STRLEN(dir_name);
 
   // If dir_name is a path head, full_path can always be made relative.
-  if (len == (size_t)path_head_length() && is_path_head(dir_name)) {
+  if (len == (size_t)path_head_length() && is_path_head((char_u *)dir_name)) {
     return full_path + len;
   }
 
   // If full_path and dir_name do not match, it's impossible to make one
   // relative to the other.
-  if (FNAMENCMP(dir_name, full_path, len) != 0) {
+  if (path_fnamencmp(dir_name, full_path, len) != 0) {
     return NULL;
   }
 
-  char_u *p = full_path + len;
+  char_u *p = (char_u *)full_path + len;
 
   // If *p is not pointing to a path separator, this means that full_path's
   // last directory name is longer than *dir_name's last directory, so they
@@ -2082,7 +2088,7 @@ char_u *path_shorten_fname(char_u *full_path, char_u *dir_name)
     return NULL;
   }
 
-  return p + 1;
+  return (char *)p + 1;
 }
 
 /// Invoke expand_wildcards() for one pattern
@@ -2200,7 +2206,7 @@ int expand_wildcards(int num_pat, char **pat, int *num_files, char ***files, int
   if (*num_files > 1 && !got_int) {
     non_suf_match = 0;
     for (i = 0; i < *num_files; i++) {
-      if (!match_suffix((char_u *)(*files)[i])) {
+      if (!match_suffix((*files)[i])) {
         // Move the name without matching suffix to the front of the list.
         p = (char_u *)(*files)[i];
         for (j = i; j > non_suf_match; j--) {
@@ -2220,27 +2226,27 @@ int expand_wildcards(int num_pat, char **pat, int *num_files, char ***files, int
   return retval;
 }
 
-/// Return true if "fname" matches with an entry in 'suffixes'.
-int match_suffix(char_u *fname)
+/// @return  true if "fname" matches with an entry in 'suffixes'.
+int match_suffix(char *fname)
 {
 #define MAXSUFLEN 30  // maximum length of a file suffix
-  char_u suf_buf[MAXSUFLEN];
+  char suf_buf[MAXSUFLEN];
 
   size_t fnamelen = STRLEN(fname);
   size_t setsuflen = 0;
   for (char_u *setsuf = p_su; *setsuf;) {
     setsuflen = copy_option_part((char **)&setsuf, (char *)suf_buf, MAXSUFLEN, ".,");
     if (setsuflen == 0) {
-      char_u *tail = (char_u *)path_tail((char *)fname);
+      char *tail = path_tail(fname);
 
       // empty entry: match name without a '.'
-      if (vim_strchr((char *)tail, '.') == NULL) {
+      if (vim_strchr(tail, '.') == NULL) {
         setsuflen = 1;
         break;
       }
     } else {
       if (fnamelen >= setsuflen
-          && FNAMENCMP(suf_buf, fname + fnamelen - setsuflen, setsuflen) == 0) {
+          && path_fnamencmp(suf_buf, fname + fnamelen - setsuflen, setsuflen) == 0) {
         break;
       }
       setsuflen = 0;
@@ -2434,8 +2440,8 @@ void path_guess_exepath(const char *argv0, char *buf, size_t bufsize)
         continue;
       }
       STRLCPY(NameBuff, dir, dir_len + 1);
-      STRLCAT(NameBuff, PATHSEPSTR, sizeof(NameBuff));
-      STRLCAT(NameBuff, argv0, sizeof(NameBuff));
+      xstrlcat(NameBuff, PATHSEPSTR, sizeof(NameBuff));
+      xstrlcat(NameBuff, argv0, sizeof(NameBuff));
       if (os_can_exe((char *)NameBuff, NULL, false)) {
         xstrlcpy(buf, (char *)NameBuff, bufsize);
         return;
diff --git a/src/nvim/profile.c b/src/nvim/profile.c
index 9957224351..50a8a371f5 100644
--- a/src/nvim/profile.c
+++ b/src/nvim/profile.c
@@ -728,7 +728,7 @@ static void script_dump_profile(FILE *fd)
         // Keep going till the end of file, so that trailing
         // continuation lines are listed.
         for (int i = 0;; i++) {
-          if (vim_fgets(IObuff, IOSIZE, sfd)) {
+          if (vim_fgets((char_u *)IObuff, IOSIZE, sfd)) {
             break;
           }
           // When a line has been truncated, append NL, taking care
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 0dcbcf56b1..9494308ef0 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -1242,10 +1242,10 @@ static int qf_parse_fmt_f(regmatch_T *rmp, int midx, qffields_T *fields, int pre
   }
 
   // Expand ~/file and $HOME/file to full path.
-  char c = (char)(*rmp->endp[midx]);
+  char c = *rmp->endp[midx];
   *rmp->endp[midx] = NUL;
-  expand_env((char *)rmp->startp[midx], fields->namebuf, CMDBUFFSIZE);
-  *rmp->endp[midx] = (char_u)c;
+  expand_env(rmp->startp[midx], fields->namebuf, CMDBUFFSIZE);
+  *rmp->endp[midx] = c;
 
   // For separate filename patterns (%O, %P and %Q), the specified file
   // should exist.
@@ -1264,7 +1264,7 @@ static int qf_parse_fmt_n(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->enr = (int)atol((char *)rmp->startp[midx]);
+  fields->enr = (int)atol(rmp->startp[midx]);
   return QF_OK;
 }
 
@@ -1275,7 +1275,7 @@ static int qf_parse_fmt_l(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->lnum = (linenr_T)atol((char *)rmp->startp[midx]);
+  fields->lnum = (linenr_T)atol(rmp->startp[midx]);
   return QF_OK;
 }
 
@@ -1286,7 +1286,7 @@ static int qf_parse_fmt_e(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->end_lnum = (linenr_T)atol((char *)rmp->startp[midx]);
+  fields->end_lnum = (linenr_T)atol(rmp->startp[midx]);
   return QF_OK;
 }
 
@@ -1297,7 +1297,7 @@ static int qf_parse_fmt_c(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->col = (int)atol((char *)rmp->startp[midx]);
+  fields->col = (int)atol(rmp->startp[midx]);
   return QF_OK;
 }
 
@@ -1308,7 +1308,7 @@ static int qf_parse_fmt_k(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->end_col = (int)atol((char *)rmp->startp[midx]);
+  fields->end_col = (int)atol(rmp->startp[midx]);
   return QF_OK;
 }
 
@@ -1319,7 +1319,7 @@ static int qf_parse_fmt_t(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->type = (char)(*rmp->startp[midx]);
+  fields->type = *rmp->startp[midx];
   return QF_OK;
 }
 
@@ -1360,7 +1360,7 @@ static int qf_parse_fmt_r(regmatch_T *rmp, int midx, char **tail)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  *tail = (char *)rmp->startp[midx];
+  *tail = rmp->startp[midx];
   return QF_OK;
 }
 
@@ -1372,7 +1372,7 @@ static int qf_parse_fmt_p(regmatch_T *rmp, int midx, qffields_T *fields)
     return QF_FAIL;
   }
   fields->col = 0;
-  for (char *match_ptr = (char *)rmp->startp[midx]; (char_u *)match_ptr != rmp->endp[midx];
+  for (char *match_ptr = rmp->startp[midx]; match_ptr != rmp->endp[midx];
        match_ptr++) {
     fields->col++;
     if (*match_ptr == TAB) {
@@ -1392,7 +1392,7 @@ static int qf_parse_fmt_v(regmatch_T *rmp, int midx, qffields_T *fields)
   if (rmp->startp[midx] == NULL) {
     return QF_FAIL;
   }
-  fields->col = (int)atol((char *)rmp->startp[midx]);
+  fields->col = (int)atol(rmp->startp[midx]);
   fields->use_viscol = true;
   return QF_OK;
 }
@@ -1409,7 +1409,7 @@ static int qf_parse_fmt_s(regmatch_T *rmp, int midx, qffields_T *fields)
     len = CMDBUFFSIZE - 5;
   }
   STRCPY(fields->pattern, "^\\V");
-  STRLCAT(fields->pattern, rmp->startp[midx], len + 4);
+  xstrlcat(fields->pattern, rmp->startp[midx], len + 4);
   fields->pattern[len + 3] = '\\';
   fields->pattern[len + 4] = '$';
   fields->pattern[len + 5] = NUL;
@@ -1428,7 +1428,7 @@ static int qf_parse_fmt_o(regmatch_T *rmp, int midx, qffields_T *fields)
   if (dsize > CMDBUFFSIZE) {
     dsize = CMDBUFFSIZE;
   }
-  STRLCAT(fields->module, rmp->startp[midx], dsize);
+  xstrlcat(fields->module, rmp->startp[midx], dsize);
   return QF_OK;
 }
 
@@ -3074,7 +3074,7 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   }
   msg_puts(" ");
 
-  char_u *tbuf = IObuff;
+  char *tbuf = IObuff;
   size_t tbuflen = IOSIZE;
   size_t len = STRLEN(qfp->qf_text) + 3;
 
@@ -3088,8 +3088,8 @@ static void qf_list_entry(qfline_T *qfp, int qf_idx, bool cursel)
   // with ^^^^.
   qf_fmt_text((fname != NULL || qfp->qf_lnum != 0)
               ? skipwhite(qfp->qf_text) : qfp->qf_text,
-              (char *)tbuf, (int)tbuflen);
-  msg_prt_line((char *)tbuf, false);
+              tbuf, (int)tbuflen);
+  msg_prt_line(tbuf, false);
 
   if (tbuf != IObuff) {
     xfree(tbuf);
@@ -3236,7 +3236,7 @@ static void qf_msg(qf_info_T *qi, int which, char *lead)
       memset(buf + len, ' ', 34 - len);
       buf[34] = NUL;
     }
-    STRLCAT(buf, title, IOSIZE);
+    xstrlcat(buf, title, IOSIZE);
   }
   trunc_string(buf, buf, Columns - 1, IOSIZE);
   msg(buf);
@@ -3965,7 +3965,7 @@ static int qf_buf_add_line(qf_list_T *qfl, buf_T *buf, linenr_T lnum, const qfli
                 (char *)IObuff + len, IOSIZE - len);
   }
 
-  if (ml_append_buf(buf, lnum, IObuff,
+  if (ml_append_buf(buf, lnum, (char_u *)IObuff,
                     (colnr_T)STRLEN(IObuff) + 1, false) == FAIL) {
     return FAIL;
   }
@@ -6948,7 +6948,7 @@ static void hgr_search_file(qf_list_T *qfl, char *fname, regmatch_T *p_regmatch)
   }
 
   linenr_T lnum = 1;
-  while (!vim_fgets(IObuff, IOSIZE, fd) && !got_int) {
+  while (!vim_fgets((char_u *)IObuff, IOSIZE, fd) && !got_int) {
     char *line = (char *)IObuff;
 
     if (vim_regexec(p_regmatch, line, (colnr_T)0)) {
@@ -6967,8 +6967,8 @@ static void hgr_search_file(qf_list_T *qfl, char *fname, regmatch_T *p_regmatch)
                        line,
                        lnum,
                        0,
-                       (int)(p_regmatch->startp[0] - (char_u *)line) + 1,  // col
-                       (int)(p_regmatch->endp[0] - (char_u *)line)
+                       (int)(p_regmatch->startp[0] - line) + 1,  // col
+                       (int)(p_regmatch->endp[0] - line)
                        + 1,    // end_col
                        false,  // vis_col
                        NULL,   // search pattern
@@ -6977,13 +6977,13 @@ static void hgr_search_file(qf_list_T *qfl, char *fname, regmatch_T *p_regmatch)
                        true)    // valid
           == QF_FAIL) {
         got_int = true;
-        if ((char_u *)line != IObuff) {
+        if (line != IObuff) {
           xfree(line);
         }
         break;
       }
     }
-    if ((char_u *)line != IObuff) {
+    if (line != IObuff) {
       xfree(line);
     }
     lnum++;
diff --git a/src/nvim/regexp.c b/src/nvim/regexp.c
index a94f91d103..9a8890a28a 100644
--- a/src/nvim/regexp.c
+++ b/src/nvim/regexp.c
@@ -1621,11 +1621,11 @@ static int fill_submatch_list(int argc FUNC_ATTR_UNUSED, typval_T *argv, int arg
   // There are always 10 list items in staticList10_T.
   listitem_T *li = tv_list_first(listarg->vval.v_list);
   for (int i = 0; i < 10; i++) {
-    char *s = (char *)rsm.sm_match->startp[i];
+    char *s = rsm.sm_match->startp[i];
     if (s == NULL || rsm.sm_match->endp[i] == NULL) {
       s = NULL;
     } else {
-      s = xstrnsave(s, (size_t)(rsm.sm_match->endp[i] - (char_u *)s));
+      s = xstrnsave(s, (size_t)(rsm.sm_match->endp[i] - s));
     }
     TV_LIST_ITEM_TV(li)->v_type = VAR_STRING;
     TV_LIST_ITEM_TV(li)->vval.v_string = s;
@@ -2006,11 +2006,11 @@ static int vim_regsub_both(char_u *source, typval_T *expr, char_u *dest, int des
             }
           }
         } else {
-          s = rex.reg_match->startp[no];
+          s = (char_u *)rex.reg_match->startp[no];
           if (rex.reg_match->endp[no] == NULL) {
             s = NULL;
           } else {
-            len = (int)(rex.reg_match->endp[no] - s);
+            len = (int)(rex.reg_match->endp[no] - (char *)s);
           }
         }
         if (s != NULL) {
@@ -2206,11 +2206,11 @@ char *reg_submatch(int no)
       }
     }
   } else {
-    s = (char *)rsm.sm_match->startp[no];
+    s = rsm.sm_match->startp[no];
     if (s == NULL || rsm.sm_match->endp[no] == NULL) {
       retval = NULL;
     } else {
-      retval = xstrnsave(s, (size_t)(rsm.sm_match->endp[no] - (char_u *)s));
+      retval = xstrnsave(s, (size_t)(rsm.sm_match->endp[no] - s));
     }
   }
 
diff --git a/src/nvim/regexp_bt.c b/src/nvim/regexp_bt.c
index 63e4dd5b7e..59a6ed28af 100644
--- a/src/nvim/regexp_bt.c
+++ b/src/nvim/regexp_bt.c
@@ -5028,8 +5028,8 @@ static long bt_regexec_both(char_u *line, colnr_T col, proftime_T *tm, int *time
     rex.reg_endpos = rex.reg_mmatch->endpos;
   } else {
     prog = (bt_regprog_T *)rex.reg_match->regprog;
-    rex.reg_startp = rex.reg_match->startp;
-    rex.reg_endp = rex.reg_match->endp;
+    rex.reg_startp = (char_u **)rex.reg_match->startp;
+    rex.reg_endp = (char_u **)rex.reg_match->endp;
   }
 
   // Be paranoid...
diff --git a/src/nvim/regexp_defs.h b/src/nvim/regexp_defs.h
index 5d7175b89a..b24ed350e8 100644
--- a/src/nvim/regexp_defs.h
+++ b/src/nvim/regexp_defs.h
@@ -140,8 +140,8 @@ typedef struct {
  */
 typedef struct {
   regprog_T *regprog;
-  char_u *startp[NSUBEXP];
-  char_u *endp[NSUBEXP];
+  char *startp[NSUBEXP];
+  char *endp[NSUBEXP];
   bool rm_ic;
 } regmatch_T;
 
diff --git a/src/nvim/regexp_nfa.c b/src/nvim/regexp_nfa.c
index ea11398c30..fbd4e26c75 100644
--- a/src/nvim/regexp_nfa.c
+++ b/src/nvim/regexp_nfa.c
@@ -7402,8 +7402,8 @@ static long nfa_regexec_both(char_u *line, colnr_T startcol, proftime_T *tm, int
     rex.reg_endpos = rex.reg_mmatch->endpos;
   } else {
     prog = (nfa_regprog_T *)rex.reg_match->regprog;
-    rex.reg_startp = rex.reg_match->startp;
-    rex.reg_endp = rex.reg_match->endp;
+    rex.reg_startp = (char_u **)rex.reg_match->startp;
+    rex.reg_endp = (char_u **)rex.reg_match->endp;
   }
 
   // Be paranoid...
diff --git a/src/nvim/runtime.c b/src/nvim/runtime.c
index b43db2256f..78a157f9fb 100644
--- a/src/nvim/runtime.c
+++ b/src/nvim/runtime.c
@@ -1065,7 +1065,7 @@ static void add_pack_start_dir(char *fname, void *cookie)
       continue;
     }
     STRLCPY(buf, fname, MAXPATHL);
-    STRLCAT(buf, start_pat[i], sizeof buf);
+    xstrlcat(buf, start_pat[i], sizeof buf);
     if (pack_has_entries(buf)) {
       add_pack_dir_to_rtp(buf, true);
     }
@@ -2121,7 +2121,7 @@ scriptitem_T *get_current_script_id(char **fnamep, sctx_T *ret_sctx)
     // - If a script is deleted and another script is written, with a
     //   different name, the inode may be re-used.
     si = &SCRIPT_ITEM(script_sctx.sc_sid);
-    if (si->sn_name != NULL && FNAMECMP(si->sn_name, *fnamep) == 0) {
+    if (si->sn_name != NULL && path_fnamecmp(si->sn_name, *fnamep) == 0) {
       // Found it!
       break;
     }
diff --git a/src/nvim/search.c b/src/nvim/search.c
index e2df31c04f..8477efed92 100644
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -3508,14 +3508,14 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
 
       if (inc_opt != NULL && strstr(inc_opt, "\\zs") != NULL) {
         // Use text from '\zs' to '\ze' (or end) of 'include'.
-        new_fname = (char_u *)find_file_name_in_path((char *)incl_regmatch.startp[0],
+        new_fname = (char_u *)find_file_name_in_path(incl_regmatch.startp[0],
                                                      (size_t)(incl_regmatch.endp[0]
                                                               - incl_regmatch.startp[0]),
                                                      FNAME_EXP|FNAME_INCL|FNAME_REL,
                                                      1L, (char *)p_fname);
       } else {
         // Use text after match with 'include'.
-        new_fname = file_name_in_line(incl_regmatch.endp[0], 0,
+        new_fname = file_name_in_line((char_u *)incl_regmatch.endp[0], 0,
                                       FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, p_fname, NULL);
       }
       already_searched = false;
@@ -3583,19 +3583,19 @@ void find_pattern_in_path(char_u *ptr, Direction dir, size_t len, bool whole, bo
             if (inc_opt != NULL
                 && strstr(inc_opt, "\\zs") != NULL) {
               // pattern contains \zs, use the match
-              p = incl_regmatch.startp[0];
+              p = (char_u *)incl_regmatch.startp[0];
               i = (int)(incl_regmatch.endp[0]
                         - incl_regmatch.startp[0]);
             } else {
               // find the file name after the end of the match
-              for (p = incl_regmatch.endp[0];
+              for (p = (char_u *)incl_regmatch.endp[0];
                    *p && !vim_isfilec(*p); p++) {}
               for (i = 0; vim_isfilec(p[i]); i++) {}
             }
 
             if (i == 0) {
               // Nothing found, use the rest of the line.
-              p = incl_regmatch.endp[0];
+              p = (char_u *)incl_regmatch.endp[0];
               i = (int)STRLEN(p);
             } else if (p > line) {
               // Avoid checking before the start of the line, can
@@ -3681,7 +3681,7 @@ search_line:
         // Pattern must be first identifier after 'define', so skip
         // to that position before checking for match of pattern.  Also
         // don't let it match beyond the end of this identifier.
-        p = def_regmatch.endp[0];
+        p = (char_u *)def_regmatch.endp[0];
         while (*p && !vim_iswordc(*p)) {
           p++;
         }
@@ -3706,7 +3706,7 @@ search_line:
         } else if (regmatch.regprog != NULL
                    && vim_regexec(&regmatch, (char *)line, (colnr_T)(p - line))) {
           matched = true;
-          startp = regmatch.startp[0];
+          startp = (char_u *)regmatch.startp[0];
           // Check if the line is not a comment line (unless we are
           // looking for a define).  A line starting with "# define"
           // is not considered to be a comment line.
@@ -3810,7 +3810,7 @@ search_line:
             cont_s_ipos = true;
           }
           IObuff[i] = NUL;
-          aux = IObuff;
+          aux = (char_u *)IObuff;
 
           if (i == ins_compl_len()) {
             goto exit_matched;
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index 1c29689487..74d8b30347 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -1053,7 +1053,7 @@ static buf_T *find_buffer(khash_t(fnamebufs) *const fname_bufs, const char *cons
   kh_key(fname_bufs, k) = xstrdup(fname);
   FOR_ALL_BUFFERS(buf) {
     if (buf->b_ffname != NULL) {
-      if (FNAMECMP(fname, buf->b_ffname) == 0) {
+      if (path_fnamecmp(fname, buf->b_ffname) == 0) {
         kh_val(fname_bufs, k) = buf;
         return buf;
       }
@@ -3098,7 +3098,7 @@ shada_write_file_nomerge: {}
         }
       }
 #endif
-      if (vim_rename((char_u *)tempname, (char_u *)fname) == -1) {
+      if (vim_rename(tempname, fname) == -1) {
         semsg(_(RNERR "Can't rename ShaDa file from %s to %s!"),
               tempname, fname);
       } else {
diff --git a/src/nvim/spell.c b/src/nvim/spell.c
index 4acefd9d64..42891fd3fb 100644
--- a/src/nvim/spell.c
+++ b/src/nvim/spell.c
@@ -369,7 +369,7 @@ size_t spell_check(win_T *wp, char_u *ptr, hlf_T *attrp, int *capcol, bool docou
         int r = vim_regexec(&regmatch, (char *)ptr, 0);
         wp->w_s->b_cap_prog = regmatch.regprog;
         if (r) {
-          *capcol = (int)(regmatch.endp[0] - ptr);
+          *capcol = (int)(regmatch.endp[0] - (char *)ptr);
         }
       }
 
@@ -1902,7 +1902,7 @@ char *did_set_spelllang(win_T *wp)
     // If the name ends in ".spl" use it as the name of the spell file.
     // If there is a region name let "region" point to it and remove it
     // from the name.
-    if (len > 4 && FNAMECMP(lang + len - 4, ".spl") == 0) {
+    if (len > 4 && path_fnamecmp(lang + len - 4, ".spl") == 0) {
       filename = true;
 
       // Locate a region and remove it from the file name.
@@ -2548,7 +2548,7 @@ bool check_need_cap(linenr_T lnum, colnr_T col)
         break;
       }
       if (vim_regexec(&regmatch, (char *)p, 0)
-          && regmatch.endp[0] == line + endcol) {
+          && (char_u *)regmatch.endp[0] == line + endcol) {
         need_cap = true;
         break;
       }
@@ -3407,7 +3407,7 @@ static void dump_word(slang_T *slang, char_u *word, char_u *pat, Direction *dir,
       if (!HASHITEM_EMPTY(hi)) {
         vim_snprintf((char *)IObuff, IOSIZE, "%s\t%d",
                      tw, HI2WC(hi)->wc_count);
-        p = IObuff;
+        p = (char_u *)IObuff;
       }
     }
 
diff --git a/src/nvim/spellfile.c b/src/nvim/spellfile.c
index 2858942d0b..7da5a7ca4f 100644
--- a/src/nvim/spellfile.c
+++ b/src/nvim/spellfile.c
@@ -895,7 +895,7 @@ void suggest_load_files(void)
       slang->sl_sugloaded = true;
 
       dotp = strrchr(slang->sl_fname, '.');
-      if (dotp == NULL || FNAMECMP(dotp, ".spl") != 0) {
+      if (dotp == NULL || path_fnamecmp(dotp, ".spl") != 0) {
         continue;
       }
       STRCPY(dotp, ".sug");
diff --git a/src/nvim/spellsuggest.c b/src/nvim/spellsuggest.c
index 5f432f1c9a..16af1b72a3 100644
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -533,7 +533,7 @@ void spell_suggest(int count)
       }
       vim_snprintf((char *)IObuff, IOSIZE, "%2d", i + 1);
       if (cmdmsg_rl) {
-        rl_mirror(IObuff);
+        rl_mirror((char_u *)IObuff);
       }
       msg_puts((const char *)IObuff);
 
@@ -559,7 +559,7 @@ void spell_suggest(int count)
         }
         if (cmdmsg_rl) {
           // Mirror the numbers, but keep the leading space.
-          rl_mirror(IObuff + 1);
+          rl_mirror((char_u *)IObuff + 1);
         }
         msg_advance(30);
         msg_puts((const char *)IObuff);
diff --git a/src/nvim/tag.c b/src/nvim/tag.c
index b363dfc889..36f797da06 100644
--- a/src/nvim/tag.c
+++ b/src/nvim/tag.c
@@ -1971,7 +1971,7 @@ parse_line:
           *tagp.tagname_end = NUL;
           match = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
           if (match) {
-            matchoff = (int)(orgpat.regmatch.startp[0] - (char_u *)tagp.tagname);
+            matchoff = (int)(orgpat.regmatch.startp[0] - tagp.tagname);
             if (orgpat.regmatch.rm_ic) {
               orgpat.regmatch.rm_ic = false;
               match_no_ic = vim_regexec(&orgpat.regmatch, tagp.tagname, (colnr_T)0);
diff --git a/src/nvim/undo.c b/src/nvim/undo.c
index 8ee708aa4d..891a42380e 100644
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -2636,7 +2636,7 @@ void ex_undolist(exarg_T *eap)
     if (uhp->uh_prev.ptr == NULL && uhp->uh_walk != nomark
         && uhp->uh_walk != mark) {
       vim_snprintf((char *)IObuff, IOSIZE, "%6ld %7d  ", uhp->uh_seq, changes);
-      undo_fmt_time(IObuff + STRLEN(IObuff), IOSIZE - STRLEN(IObuff), uhp->uh_time);
+      undo_fmt_time((char_u *)IObuff + STRLEN(IObuff), IOSIZE - STRLEN(IObuff), uhp->uh_time);
       if (uhp->uh_save_nr > 0) {
         while (STRLEN(IObuff) < 33) {
           STRCAT(IObuff, " ");
diff --git a/src/nvim/vim.h b/src/nvim/vim.h
index 6c7bc05c82..af0f231b37 100644
--- a/src/nvim/vim.h
+++ b/src/nvim/vim.h
@@ -230,7 +230,6 @@ enum { FOLD_TEXT_LEN = 51, };  //!< buffer size for get_foldtext()
 #endif
 
 #define STRCAT(d, s)        strcat((char *)(d), (char *)(s))  // NOLINT(runtime/printf)
-#define STRLCAT(d, s, n)    xstrlcat((char *)(d), (char *)(s), (size_t)(n))
 
 // Character used as separated in autoload function/variable names.
 #define AUTOLOAD_CHAR '#'
@@ -245,23 +244,6 @@ enum { FOLD_TEXT_LEN = 51, };  //!< buffer size for get_foldtext()
 
 #include "nvim/path.h"
 
-/// Compare file names
-///
-/// On some systems case in a file name does not matter, on others it does.
-///
-/// @note Does not account for maximum name lengths and things like "../dir",
-///       thus it is not 100% accurate. OS may also use different algorithm for
-///       case-insensitive comparison.
-///
-/// @param[in]  x  First file name to compare.
-/// @param[in]  y  Second file name to compare.
-///
-/// @return 0 for equal file names, non-zero otherwise.
-#define FNAMECMP(x, y) path_fnamecmp((const char *)(x), (const char *)(y))
-#define FNAMENCMP(x, y, n) path_fnamencmp((const char *)(x), \
-                                          (const char *)(y), \
-                                          (size_t)(n))
-
 // Enums need a typecast to be used as array index.
 #define HL_ATTR(n)      hl_attr_active[(int)(n)]
 
-- 
cgit 


From 40f9f479b746d0f76fbdd4bc0567d593ca7a6070 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Sat, 10 Sep 2022 13:30:54 +0200
Subject: vim-patch:9.0.0434: gitignore files are not recognized (#20143)

Problem:    gitignore files are not recognized.
Solution:   Add patterns for the gitignore filetype. (closes vim/vim#11102)
https://github.com/vim/vim/commit/9ba2786f15f0b53a90fd221832a5bedfc6dbfe20
---
 src/nvim/testdir/test_filetype.vim | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 1cc804117a..09fb9556f4 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -216,6 +216,7 @@ let s:filename_checks = {
     \ 'gitattributes': ['file.git/info/attributes', '.gitattributes', '/.config/git/attributes', '/etc/gitattributes', '/usr/local/etc/gitattributes', 'some.git/info/attributes'],
     \ 'gitcommit': ['COMMIT_EDITMSG', 'MERGE_MSG', 'TAG_EDITMSG', 'NOTES_EDITMSG', 'EDIT_DESCRIPTION'],
     \ 'gitconfig': ['file.git/config', 'file.git/config.worktree', 'file.git/worktrees/x/config.worktree', '.gitconfig', '.gitmodules', 'file.git/modules//config', '/.config/git/config', '/etc/gitconfig', '/usr/local/etc/gitconfig', '/etc/gitconfig.d/file', 'any/etc/gitconfig.d/file', '/.gitconfig.d/file', 'any/.config/git/config', 'any/.gitconfig.d/file', 'some.git/config', 'some.git/modules/any/config'],
+    \ 'gitignore': ['file.git/info/exclude', '.gitignore', '/.config/git/ignore', 'some.git/info/exclude'],
     \ 'gitolite': ['gitolite.conf', '/gitolite-admin/conf/file', 'any/gitolite-admin/conf/file'],
     \ 'gitrebase': ['git-rebase-todo'],
     \ 'gitsendemail': ['.gitsendemail.msg.xxxxxx'],
-- 
cgit 


From f98cff9575e75a050d2bde01ad950c0c72bcfc3e Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Sun, 11 Sep 2022 16:07:54 +0200
Subject: vim-patch:9.0.0443: blueprint files are not recognized (#20155)

Problem:    Blueprint files are not recognized.
Solution:   Add a pattern for blueprint files. (Gabriele Musco, closes vim/vim#11107)
https://github.com/vim/vim/commit/cce82a55b8105560a2ef724999c856966337b48e
---
 src/nvim/testdir/test_filetype.vim | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 09fb9556f4..8d7c8f0c87 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -88,6 +88,7 @@ let s:filename_checks = {
     \ 'bindzone': ['named.root', '/bind/db.file', '/named/db.file', 'any/bind/db.file', 'any/named/db.file'],
     \ 'bitbake': ['file.bb', 'file.bbappend', 'file.bbclass', 'build/conf/local.conf', 'meta/conf/layer.conf', 'build/conf/bbappend.conf', 'meta-layer/conf/distro/foo.conf'],
     \ 'blank': ['file.bl'],
+    \ 'blueprint': ['file.blp'],
     \ 'bsdl': ['file.bsd', 'file.bsdl'],
     \ 'bst': ['file.bst'],
     \ 'bzl': ['file.bazel', 'file.bzl', 'WORKSPACE'],
-- 
cgit 


From 38059b4f31d8c9374002e209bc9ee2df28ac17fa Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 14:03:32 +0800
Subject: vim-patch:8.2.2646: Vim9: error for not using string doesn't mention
 argument

Problem:    Vim9: error for not using string doesn't mention argument.
Solution:   Add argument number.
https://github.com/vim/vim/commit/f28f2ac425600b88da0bdcc12a82cd620f575681
---
 src/nvim/eval/funcs.c  |  4 ++--
 src/nvim/eval/typval.c | 27 ++++++++++++++++++++-------
 src/nvim/mbyte.c       |  2 +-
 3 files changed, 23 insertions(+), 10 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index b59caab34f..99dfa13d88 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1772,7 +1772,7 @@ static void f_eventhandler(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
 /// "executable()" function
 static void f_executable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_string(&argvars[0]) == FAIL) {
+  if (tv_check_for_string(&argvars[0], 1) == FAIL) {
     return;
   }
 
@@ -1901,7 +1901,7 @@ static void f_win_execute(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "exepath()" function
 static void f_exepath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_nonempty_string(&argvars[0]) == FAIL) {
+  if (tv_check_for_nonempty_string(&argvars[0], 1) == FAIL) {
     return;
   }
 
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index caba722e5b..3bc3cdbd6b 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -40,6 +40,11 @@
 # include "eval/typval.c.generated.h"
 #endif
 
+static char e_string_required_for_argument_nr[]
+  = N_("E1174: String required for argument %d");
+static char e_non_empty_string_required_for_argument_nr[]
+  = N_("E1142: Non-empty string required for argument %d");
+
 bool tv_in_free_unref_items = false;
 
 // TODO(ZyX-I): Remove DICT_MAXNEST, make users be non-recursive instead
@@ -3800,26 +3805,34 @@ float_T tv_get_float(const typval_T *const tv)
   return 0;
 }
 
-// Give an error and return FAIL unless "tv" is a string.
-int tv_check_for_string(const typval_T *const tv)
+/// Give an error and return FAIL unless "tv" is a string.
+int tv_check_for_string(const typval_T *const tv, const int arg)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
   if (tv->v_type != VAR_STRING) {
-    emsg(_(e_stringreq));
+    if (arg > 0) {
+      semsg(_(e_string_required_for_argument_nr), arg);
+    } else {
+      emsg(_(e_stringreq));
+    }
     return FAIL;
   }
   return OK;
 }
 
-// Give an error and return FAIL unless "tv" is a non-empty string.
-int tv_check_for_nonempty_string(const typval_T *const tv)
+/// Give an error and return FAIL unless "tv" is a non-empty string.
+int tv_check_for_nonempty_string(const typval_T *const tv, const int arg)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
-  if (tv_check_for_string(tv) == FAIL) {
+  if (tv_check_for_string(tv, arg) == FAIL) {
     return FAIL;
   }
   if (tv->vval.v_string == NULL || *tv->vval.v_string == NUL) {
-    emsg(_(e_non_empty_string_required));
+    if (arg > 0) {
+      semsg(_(e_non_empty_string_required_for_argument_nr), arg);
+    } else {
+      emsg(_(e_non_empty_string_required));
+    }
     return FAIL;
   }
   return OK;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index dc74e23874..ebb5e2317b 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -2793,7 +2793,7 @@ void f_setcellwidths(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
 void f_charclass(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_string(&argvars[0]) == FAIL
+  if (tv_check_for_string(&argvars[0], 1) == FAIL
       || argvars[0].vval.v_string == NULL) {
     return;
   }
-- 
cgit 


From 49aa9e17fa6f9b22550bff8f468c375ddf03fece Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 14:08:51 +0800
Subject: vim-patch:8.2.2664: Vim9: not enough function arguments checked for
 string

Problem:    Vim9: not enough function arguments checked for string.
Solution:   Check in balloon functions.  Refactor function arguments.
https://github.com/vim/vim/commit/32105ae88f3aa6a6af30336f0bc9f8eb81292cd7

Cherry-pick removal of useless check from patch 8.2.3840.

vim-patch:8.2.3083: crash when passing null string to charclass()

Problem:    Crash when passing null string to charclass().
Solution:   Bail out when string pointer is NULL. (Christian Brabandt,
            closes vim/vim#8498, closes vim/vim#8260)
https://github.com/vim/vim/commit/72463f883cdfd08e29ab0018ef3889284848d5f1
---
 src/nvim/eval/funcs.c  |  4 ++--
 src/nvim/eval/typval.c | 26 +++++++++-----------------
 src/nvim/mbyte.c       |  2 +-
 3 files changed, 12 insertions(+), 20 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 99dfa13d88..bff4361dcb 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -1772,7 +1772,7 @@ static void f_eventhandler(typval_T *argvars, typval_T *rettv, EvalFuncData fptr
 /// "executable()" function
 static void f_executable(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_string(&argvars[0], 1) == FAIL) {
+  if (tv_check_for_string_arg(argvars, 0) == FAIL) {
     return;
   }
 
@@ -1901,7 +1901,7 @@ static void f_win_execute(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 /// "exepath()" function
 static void f_exepath(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_nonempty_string(&argvars[0], 1) == FAIL) {
+  if (tv_check_for_nonempty_string_arg(argvars, 0) == FAIL) {
     return;
   }
 
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 3bc3cdbd6b..c75d16e4fc 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -3805,34 +3805,26 @@ float_T tv_get_float(const typval_T *const tv)
   return 0;
 }
 
-/// Give an error and return FAIL unless "tv" is a string.
-int tv_check_for_string(const typval_T *const tv, const int arg)
+/// Give an error and return FAIL unless "args[idx]" is a string.
+int tv_check_for_string_arg(const typval_T *const args, const int idx)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
-  if (tv->v_type != VAR_STRING) {
-    if (arg > 0) {
-      semsg(_(e_string_required_for_argument_nr), arg);
-    } else {
-      emsg(_(e_stringreq));
-    }
+  if (args[idx].v_type != VAR_STRING) {
+    semsg(_(e_string_required_for_argument_nr), idx + 1);
     return FAIL;
   }
   return OK;
 }
 
-/// Give an error and return FAIL unless "tv" is a non-empty string.
-int tv_check_for_nonempty_string(const typval_T *const tv, const int arg)
+/// Give an error and return FAIL unless "args[idx]" is a non-empty string.
+int tv_check_for_nonempty_string_arg(const typval_T *const args, const int idx)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
 {
-  if (tv_check_for_string(tv, arg) == FAIL) {
+  if (tv_check_for_string_arg(args, idx) == FAIL) {
     return FAIL;
   }
-  if (tv->vval.v_string == NULL || *tv->vval.v_string == NUL) {
-    if (arg > 0) {
-      semsg(_(e_non_empty_string_required_for_argument_nr), arg);
-    } else {
-      emsg(_(e_non_empty_string_required));
-    }
+  if (args[idx].vval.v_string == NULL || *args[idx].vval.v_string == NUL) {
+    semsg(_(e_non_empty_string_required_for_argument_nr), idx + 1);
     return FAIL;
   }
   return OK;
diff --git a/src/nvim/mbyte.c b/src/nvim/mbyte.c
index ebb5e2317b..310ad05196 100644
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -2793,7 +2793,7 @@ void f_setcellwidths(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 
 void f_charclass(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (tv_check_for_string(&argvars[0], 1) == FAIL
+  if (tv_check_for_string_arg(argvars, 0) == FAIL
       || argvars[0].vval.v_string == NULL) {
     return;
   }
-- 
cgit 


From 4448fa88ecca11acd4742ef3d38f9e0d42c0b4a5 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 17:19:45 +0800
Subject: refactor: move f_screenpos() to move.c

---
 src/nvim/eval/funcs.c | 26 --------------------------
 src/nvim/move.c       | 27 +++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 26 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index bff4361dcb..4a139c85d1 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -7057,32 +7057,6 @@ static void f_screencol(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   rettv->vval.v_number = ui_current_col() + 1;
 }
 
-/// "screenpos({winid}, {lnum}, {col})" function
-static void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
-{
-  tv_dict_alloc_ret(rettv);
-  dict_T *dict = rettv->vval.v_dict;
-
-  win_T *wp = find_win_by_nr_or_id(&argvars[0]);
-  if (wp == NULL) {
-    return;
-  }
-
-  pos_T pos = {
-    .lnum   = (linenr_T)tv_get_number(&argvars[1]),
-    .col    = (colnr_T)tv_get_number(&argvars[2]) - 1,
-    .coladd = 0
-  };
-  int row = 0;
-  int scol = 0, ccol = 0, ecol = 0;
-  textpos2screenpos(wp, &pos, &row, &scol, &ccol, &ecol, false);
-
-  tv_dict_add_nr(dict, S_LEN("row"), row);
-  tv_dict_add_nr(dict, S_LEN("col"), scol);
-  tv_dict_add_nr(dict, S_LEN("curscol"), ccol);
-  tv_dict_add_nr(dict, S_LEN("endcol"), ecol);
-}
-
 /// "screenrow()" function
 static void f_screenrow(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 0e2550352d..9e0662c141 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -21,6 +21,7 @@
 #include "nvim/diff.h"
 #include "nvim/drawscreen.h"
 #include "nvim/edit.h"
+#include "nvim/eval.h"
 #include "nvim/fold.h"
 #include "nvim/getchar.h"
 #include "nvim/grid.h"
@@ -977,6 +978,32 @@ void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp,
   *ecolp = ecol + coloff;
 }
 
+/// "screenpos({winid}, {lnum}, {col})" function
+void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  tv_dict_alloc_ret(rettv);
+  dict_T *dict = rettv->vval.v_dict;
+
+  win_T *wp = find_win_by_nr_or_id(&argvars[0]);
+  if (wp == NULL) {
+    return;
+  }
+
+  pos_T pos = {
+    .lnum   = (linenr_T)tv_get_number(&argvars[1]),
+    .col    = (colnr_T)tv_get_number(&argvars[2]) - 1,
+    .coladd = 0
+  };
+  int row = 0;
+  int scol = 0, ccol = 0, ecol = 0;
+  textpos2screenpos(wp, &pos, &row, &scol, &ccol, &ecol, false);
+
+  tv_dict_add_nr(dict, S_LEN("row"), row);
+  tv_dict_add_nr(dict, S_LEN("col"), scol);
+  tv_dict_add_nr(dict, S_LEN("curscol"), ccol);
+  tv_dict_add_nr(dict, S_LEN("endcol"), ecol);
+}
+
 /// Scroll the current window down by "line_count" logical lines.  "CTRL-Y"
 ///
 /// @param line_count number of lines to scroll
-- 
cgit 


From 245ac6f263b6017c050f885212ee80e5738d3b9f Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 17:10:31 +0800
Subject: vim-patch:8.2.5034: there is no way to get the byte index from a
 virtual column

Problem:    There is no way to get the byte index from a virtual column.
Solution:   Add virtcol2col(). (Yegappan Lakshmanan, closes vim/vim#10477,
            closes vim/vim#10098)
https://github.com/vim/vim/commit/5a6ec10cc80ab02eeff644ab19b82312630ea855

Cherry-pick tv_check_for_number_arg() from Vim.
Cherry-pick pathshorten() doc change.
---
 src/nvim/eval.lua                     |  1 +
 src/nvim/eval/typval.c                | 13 +++++++++++++
 src/nvim/move.c                       | 32 ++++++++++++++++++++++++++++++++
 src/nvim/testdir/test_cursor_func.vim | 22 ++++++++++++++++++++++
 4 files changed, 68 insertions(+)

(limited to 'src')

diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index 3e89489459..5c500af899 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -425,6 +425,7 @@ return {
     uniq={args={1, 3}, base=1},
     values={args=1, base=1},
     virtcol={args=1, base=1},
+    virtcol2col={args=3, base=1},
     visualmode={args={0, 1}},
     wait={args={2,3}},
     wildmenumode={},
diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index c75d16e4fc..2089415ffa 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -44,6 +44,8 @@ static char e_string_required_for_argument_nr[]
   = N_("E1174: String required for argument %d");
 static char e_non_empty_string_required_for_argument_nr[]
   = N_("E1142: Non-empty string required for argument %d");
+static char e_number_required_for_argument_nr[]
+  = N_("E1210: Number required for argument %d");
 
 bool tv_in_free_unref_items = false;
 
@@ -3830,6 +3832,17 @@ int tv_check_for_nonempty_string_arg(const typval_T *const args, const int idx)
   return OK;
 }
 
+/// Give an error and return FAIL unless "args[idx]" is a number.
+int tv_check_for_number_arg(const typval_T *const args, const int idx)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
+{
+  if (args[idx].v_type != VAR_NUMBER) {
+    semsg(_(e_number_required_for_argument_nr), idx + 1);
+    return FAIL;
+  }
+  return OK;
+}
+
 /// Get the string value of a "stringish" VimL object.
 ///
 /// @param[in]  tv  Object to get value of.
diff --git a/src/nvim/move.c b/src/nvim/move.c
index 9e0662c141..481746881b 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -22,12 +22,14 @@
 #include "nvim/drawscreen.h"
 #include "nvim/edit.h"
 #include "nvim/eval.h"
+#include "nvim/eval/typval.h"
 #include "nvim/fold.h"
 #include "nvim/getchar.h"
 #include "nvim/grid.h"
 #include "nvim/highlight.h"
 #include "nvim/mbyte.h"
 #include "nvim/memline.h"
+#include "nvim/mouse.h"
 #include "nvim/move.h"
 #include "nvim/option.h"
 #include "nvim/plines.h"
@@ -1004,6 +1006,36 @@ void f_screenpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
   tv_dict_add_nr(dict, S_LEN("endcol"), ecol);
 }
 
+/// "virtcol2col({winid}, {lnum}, {col})" function
+void f_virtcol2col(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
+{
+  rettv->vval.v_number = -1;
+
+  if (tv_check_for_number_arg(argvars, 0) == FAIL
+      || tv_check_for_number_arg(argvars, 1) == FAIL
+      || tv_check_for_number_arg(argvars, 2) == FAIL) {
+    return;
+  }
+
+  win_T *wp = find_win_by_nr_or_id(&argvars[0]);
+  if (wp == NULL) {
+    return;
+  }
+
+  bool error = false;
+  linenr_T lnum = (linenr_T)tv_get_number_chk(&argvars[1], &error);
+  if (error || lnum < 0 || lnum > wp->w_buffer->b_ml.ml_line_count) {
+    return;
+  }
+
+  int screencol = (int)tv_get_number_chk(&argvars[2], &error);
+  if (error || screencol < 0) {
+    return;
+  }
+
+  rettv->vval.v_number = vcol2col(wp, lnum, screencol);
+}
+
 /// Scroll the current window down by "line_count" logical lines.  "CTRL-Y"
 ///
 /// @param line_count number of lines to scroll
diff --git a/src/nvim/testdir/test_cursor_func.vim b/src/nvim/testdir/test_cursor_func.vim
index f13842edc8..2e625f2388 100644
--- a/src/nvim/testdir/test_cursor_func.vim
+++ b/src/nvim/testdir/test_cursor_func.vim
@@ -373,4 +373,26 @@ func Test_setcursorcharpos()
   %bw!
 endfunc
 
+" Test for virtcol2col()
+func Test_virtcol2col()
+  new
+  call setline(1, ["a\tb\tc"])
+  call assert_equal(1, virtcol2col(0, 1, 1))
+  call assert_equal(2, virtcol2col(0, 1, 2))
+  call assert_equal(2, virtcol2col(0, 1, 8))
+  call assert_equal(3, virtcol2col(0, 1, 9))
+  call assert_equal(4, virtcol2col(0, 1, 10))
+  call assert_equal(4, virtcol2col(0, 1, 16))
+  call assert_equal(5, virtcol2col(0, 1, 17))
+  call assert_equal(-1, virtcol2col(10, 1, 1))
+  call assert_equal(-1, virtcol2col(0, 10, 1))
+  call assert_equal(-1, virtcol2col(0, -1, 1))
+  call assert_equal(-1, virtcol2col(0, 1, -1))
+  call assert_equal(5, virtcol2col(0, 1, 20))
+  call assert_fails('echo virtcol2col("0", 1, 20)', 'E1210:')
+  call assert_fails('echo virtcol2col(0, "1", 20)', 'E1210:')
+  call assert_fails('echo virtcol2col(0, 1, "1")', 'E1210:')
+  bw!
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From a48e42a29d2eeef3f3ee0e7e1a89f981efa82d54 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 19:09:23 +0800
Subject: vim-patch:8.2.4671: 'wildignorecase' is sometimes not used for glob()
 (#20165)

Problem:    'wildignorecase' is sometimes not used for glob().
Solution:   Also use 'wildignorecase' when there are no wildcards.
            (closes vim/vim#10066, closes vim/vim#8350)
https://github.com/vim/vim/commit/a3157a476bfa8c3077d510cc8400093c0d115df5
---
 src/nvim/path.c                     | 12 ++++++------
 src/nvim/testdir/test_functions.vim |  2 ++
 2 files changed, 8 insertions(+), 6 deletions(-)

(limited to 'src')

diff --git a/src/nvim/path.c b/src/nvim/path.c
index 38112be3ce..ac07fbee87 100644
--- a/src/nvim/path.c
+++ b/src/nvim/path.c
@@ -1272,12 +1272,12 @@ int gen_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, i
         }
       }
 
-      // If there are wildcards: Expand file names and add each match to
-      // the list.  If there is no match, and EW_NOTFOUND is given, add
-      // the pattern.
-      // If there are no wildcards: Add the file name if it exists or
-      // when EW_NOTFOUND is given.
-      if (path_has_exp_wildcard(p)) {
+      // If there are wildcards or case-insensitive expansion is
+      // required: Expand file names and add each match to the list.  If
+      // there is no match, and EW_NOTFOUND is given, add the pattern.
+      // Otherwise: Add the file name if it exists or when EW_NOTFOUND is
+      // given.
+      if (path_has_exp_wildcard(p) || (flags & EW_ICASE)) {
         if ((flags & EW_PATH)
             && !path_is_absolute(p)
             && !(p[0] == '.'
diff --git a/src/nvim/testdir/test_functions.vim b/src/nvim/testdir/test_functions.vim
index 99ac6ae32c..c41884936e 100644
--- a/src/nvim/testdir/test_functions.vim
+++ b/src/nvim/testdir/test_functions.vim
@@ -2026,6 +2026,8 @@ func Test_glob()
   " Sort output of glob() otherwise we end up with different
   " ordering depending on whether file system is case-sensitive.
   call assert_equal(['XGLOB2', 'Xglob1'], sort(glob('Xglob[12]', 0, 1)))
+  " wildignorecase shall be applied even when the pattern contains no wildcards.
+  call assert_equal('XGLOB2', glob('xglob2'))
   set wildignorecase&
 
   call delete('Xglob1')
-- 
cgit 


From afe01842ef37620e63cab815b84c89454a6b4a87 Mon Sep 17 00:00:00 2001
From: Christian Clason <c.clason@uni-graz.at>
Date: Mon, 12 Sep 2022 15:12:39 +0200
Subject: vim-patch:9.0.0448: SubRip files are not recognized (#20167)

Problem:    SubRip files are not recognized.
Solution:   Add a pattern for SubRip. (closes vim/vim#11113)
https://github.com/vim/vim/commit/5a4eb55122e45444d3a6c56ce108ce29bc8e52ab
---
 src/nvim/testdir/test_filetype.vim | 1 +
 1 file changed, 1 insertion(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_filetype.vim b/src/nvim/testdir/test_filetype.vim
index 8d7c8f0c87..cf40f6211b 100644
--- a/src/nvim/testdir/test_filetype.vim
+++ b/src/nvim/testdir/test_filetype.vim
@@ -530,6 +530,7 @@ let s:filename_checks = {
     \ 'squid': ['squid.conf'],
     \ 'squirrel': ['file.nut'],
     \ 'srec': ['file.s19', 'file.s28', 'file.s37', 'file.mot', 'file.srec'],
+    \ 'srt': ['file.srt'],
     \ 'sshconfig': ['ssh_config', '/.ssh/config', '/etc/ssh/ssh_config.d/file.conf', 'any/etc/ssh/ssh_config.d/file.conf', 'any/.ssh/config', 'any/.ssh/file.conf'],
     \ 'sshdconfig': ['sshd_config', '/etc/ssh/sshd_config.d/file.conf', 'any/etc/ssh/sshd_config.d/file.conf'],
     \ 'st': ['file.st'],
-- 
cgit 


From 5bc0964b97a77148292addd62867c93c5db29085 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 12 Sep 2022 21:47:35 +0800
Subject: vim-patch:9.0.0299: error messages for setcmdline() could be better
 (#20169)

Problem:    Error messages for setcmdline() could be better.
Solution:   Use more specific error messages. (Yegappan Lakshmanan,
            closes vim/vim#10995)
https://github.com/vim/vim/commit/25f1e5556259d536c8608185145b0769262873ff

Cherry-pick tv_check_for_opt_number_arg() from Vim.
---
 src/nvim/eval/typval.c            | 8 ++++++++
 src/nvim/ex_getln.c               | 4 ++--
 src/nvim/testdir/test_cmdline.vim | 4 ++--
 3 files changed, 12 insertions(+), 4 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval/typval.c b/src/nvim/eval/typval.c
index 2089415ffa..777cdc3013 100644
--- a/src/nvim/eval/typval.c
+++ b/src/nvim/eval/typval.c
@@ -3843,6 +3843,14 @@ int tv_check_for_number_arg(const typval_T *const args, const int idx)
   return OK;
 }
 
+/// Check for an optional number argument at "idx"
+int tv_check_for_opt_number_arg(const typval_T *const args, const int idx)
+  FUNC_ATTR_NONNULL_ALL FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_PURE
+{
+  return (args[idx].v_type == VAR_UNKNOWN
+          || tv_check_for_number_arg(args, idx) != FAIL) ? OK : FAIL;
+}
+
 /// Get the string value of a "stringish" VimL object.
 ///
 /// @param[in]  tv  Object to get value of.
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 2b7797ddc8..7d48158b4f 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -4050,8 +4050,8 @@ static int set_cmdline_pos(int pos)
 /// "setcmdline()" function
 void f_setcmdline(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
 {
-  if (argvars[0].v_type != VAR_STRING || argvars[0].vval.v_string == NULL) {
-    emsg(_(e_stringreq));
+  if (tv_check_for_string_arg(argvars, 0) == FAIL
+      || tv_check_for_opt_number_arg(argvars, 1) == FAIL) {
     return;
   }
 
diff --git a/src/nvim/testdir/test_cmdline.vim b/src/nvim/testdir/test_cmdline.vim
index e40ff65051..7443ff8fa4 100644
--- a/src/nvim/testdir/test_cmdline.vim
+++ b/src/nvim/testdir/test_cmdline.vim
@@ -2226,8 +2226,8 @@ func Test_setcmdline()
     call assert_equal(a:pos, getcmdpos())
 
     call assert_fails('call setcmdline("' .. a:text .. '", -1)', 'E487:')
-    call assert_fails('call setcmdline({}, 0)', 'E928:')
-    call assert_fails('call setcmdline("' .. a:text .. '", {})', 'E728:')
+    call assert_fails('call setcmdline({}, 0)', 'E1174:')
+    call assert_fails('call setcmdline("' .. a:text .. '", {})', 'E1210:')
 
     return ''
   endfunc
-- 
cgit