From 083865071b52d746de50294a0603bc6dbe20b3ec Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 12:27:37 +0800
Subject: vim-patch:8.2.0807: cannot easily restore a mapping

Problem:    Cannot easily restore a mapping.
Solution:   Add mapset().
https://github.com/vim/vim/commit/4c9243f9fb708c9010867d3cc8e928f36b58509a

Use MapArgument to reduce number of arguments of map_add().

N/A patches for version.c:

vim-patch:8.2.0809: build failure with small features

Problem:    Build failure with small features. (Tony Mechelynck)
Solution:   Move "expr" inside #ifdef.
https://github.com/vim/vim/commit/5a80f8ad5dc0b2cc63400255dcf3c63f6c1a2ef9
---
 src/nvim/eval.lua                |   1 +
 src/nvim/mapping.c               | 174 +++++++++++++++++++++++++++++----------
 src/nvim/testdir/test_maparg.vim |  51 +++++++++---
 3 files changed, 168 insertions(+), 58 deletions(-)

(limited to 'src')

diff --git a/src/nvim/eval.lua b/src/nvim/eval.lua
index 3db0d27018..c8eb0334fa 100644
--- a/src/nvim/eval.lua
+++ b/src/nvim/eval.lua
@@ -250,6 +250,7 @@ return {
     map={args=2, base=1},
     maparg={args={1, 4}, base=1},
     mapcheck={args={1, 3}, base=1},
+    mapset={args=3, base=1},
     match={args={2, 4}, base=1},
     matchadd={args={2, 5}, base=1},
     matchaddpos={args={2, 5}, base=1},
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 93374a41bd..384497174d 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -428,6 +428,63 @@ static int str_to_mapargs(const char_u *strargs, bool is_unmap, MapArguments *ma
   return 0;
 }
 
+/// @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,
+                    MapArguments *args, int noremap, int mode, bool is_abbr, scid_T sid,
+                    linenr_T lnum, bool simplified)
+{
+  mapblock_T *mp = xcalloc(1, sizeof(mapblock_T));
+
+  // If CTRL-C has been mapped, don't always use it for Interrupting.
+  if (*keys == Ctrl_C) {
+    if (map_table == buf->b_maphash) {
+      buf->b_mapped_ctrl_c |= mode;
+    } else {
+      mapped_ctrl_c |= mode;
+    }
+  }
+
+  mp->m_keys = vim_strsave(keys);
+  mp->m_str = args->rhs;
+  mp->m_orig_str = args->orig_rhs;
+  mp->m_luaref = args->rhs_lua;
+  if (!simplified) {
+    args->rhs = NULL;
+    args->orig_rhs = NULL;
+    args->rhs_lua = LUA_NOREF;
+  }
+  mp->m_keylen = (int)STRLEN(mp->m_keys);
+  mp->m_noremap = noremap;
+  mp->m_nowait = args->nowait;
+  mp->m_silent = args->silent;
+  mp->m_mode = mode;
+  mp->m_simplified = simplified;
+  mp->m_expr = args->expr;
+  mp->m_replace_keycodes = args->replace_keycodes;
+  if (sid >= 0) {
+    mp->m_script_ctx.sc_sid = sid;
+    mp->m_script_ctx.sc_lnum = lnum;
+  } else {
+    mp->m_script_ctx = current_sctx;
+    mp->m_script_ctx.sc_lnum += sourcing_lnum;
+    nlua_set_sctx(&mp->m_script_ctx);
+  }
+  mp->m_desc = NULL;
+  if (args->desc != NULL) {
+    mp->m_desc = xstrdup(args->desc);
+  }
+
+  // add the new entry in front of the abbrlist or maphash[] list
+  if (is_abbr) {
+    mp->m_next = *abbr_table;
+    *abbr_table = mp;
+  } else {
+    const int n = MAP_HASH(mp->m_mode, mp->m_keys[0]);
+    mp->m_next = map_table[n];
+    map_table[n] = mp;
+  }
+}
+
 /// Sets or removes a mapping or abbreviation in buffer `buf`.
 ///
 /// @param maptype    @see do_map
@@ -780,51 +837,10 @@ 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.
-    mp = xmalloc(sizeof(mapblock_T));
-
-    // If CTRL-C has been mapped, don't always use it for Interrupting.
-    if (*lhs == Ctrl_C) {
-      if (map_table == buf->b_maphash) {
-        buf->b_mapped_ctrl_c |= mode;
-      } else {
-        mapped_ctrl_c |= mode;
-      }
-    }
-
-    mp->m_keys = vim_strsave(lhs);
-    mp->m_str = args->rhs;
-    mp->m_orig_str = args->orig_rhs;
-    mp->m_luaref = args->rhs_lua;
-    if (!keyround1_simplified) {
-      args->rhs = NULL;
-      args->orig_rhs = NULL;
-      args->rhs_lua = LUA_NOREF;
-    }
-    mp->m_keylen = (int)STRLEN(mp->m_keys);
-    mp->m_noremap = noremap;
-    mp->m_nowait = args->nowait;
-    mp->m_silent = args->silent;
-    mp->m_mode = mode;
-    mp->m_simplified = keyround1_simplified;  // Notice this when porting patch 8.2.0807
-    mp->m_expr = args->expr;
-    mp->m_replace_keycodes = args->replace_keycodes;
-    mp->m_script_ctx = current_sctx;
-    mp->m_script_ctx.sc_lnum += sourcing_lnum;
-    nlua_set_sctx(&mp->m_script_ctx);
-    mp->m_desc = NULL;
-    if (args->desc != NULL) {
-      mp->m_desc = xstrdup(args->desc);
-    }
-
-    // add the new entry in front of the abbrlist or maphash[] list
-    if (is_abbrev) {
-      mp->m_next = *abbr_table;
-      *abbr_table = mp;
-    } else {
-      n = MAP_HASH(mp->m_mode, mp->m_keys[0]);
-      mp->m_next = map_table[n];
-      map_table[n] = mp;
-    }
+    map_add(buf, map_table, abbr_table, lhs, args, noremap, mode, is_abbrev,
+            -1,  // sid
+            0,   // lnum
+            keyround1_simplified);
   }
 
 theend:
@@ -2023,6 +2039,7 @@ static void mapblock_fill_dict(dict_T *const dict, const mapblock_T *const mp, l
     tv_dict_add_nr(dict, S_LEN("replace_keycodes"), 1);
   }
   tv_dict_add_allocated_str(dict, S_LEN("mode"), mapmode);
+  tv_dict_add_nr(dict, S_LEN("simplified"), mp->m_simplified ? 1 : 0);
 }
 
 static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
@@ -2108,6 +2125,73 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
   xfree(alt_keys_buf);
 }
 
+/// "mapset()" function
+void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
+{
+  char buf[NUMBUFLEN];
+  const char *which = tv_get_string_buf_chk(&argvars[0], buf);
+  int mode = get_map_mode((char **)&which, 0);
+  bool is_abbr = tv_get_number(&argvars[1]) != 0;
+
+  if (argvars[2].v_type != VAR_DICT) {
+    emsg(_(e_dictreq));
+    return;
+  }
+  dict_T *d = argvars[2].vval.v_dict;
+
+  // Get the values in the same order as above in get_maparg().
+  char *lhs = tv_dict_get_string(d, "lhs", false);
+  if (lhs == NULL) {
+    emsg(_("E99: lhs entry missing in mapset() dict argument"));
+    return;
+  }
+  char *rhs = tv_dict_get_string(d, "rhs", false);
+  if (rhs == NULL) {
+    emsg(_("E99: rhs entry missing in mapset() dict argument"));
+    return;
+  }
+
+  int noremap = tv_dict_get_number(d, "noremap") ? REMAP_NONE : 0;
+  if (tv_dict_get_number(d, "script") != 0) {
+    noremap = REMAP_SCRIPT;
+  }
+
+  // TODO: support "callback" and "desc"
+  MapArguments args = {
+    .rhs = vim_strsave((char_u *)rhs),
+    .rhs_lua = LUA_NOREF,
+    .orig_rhs = vim_strsave((char_u *)rhs),
+    .expr = tv_dict_get_number(d, "expr") != 0,
+    .silent = tv_dict_get_number(d, "silent") != 0,
+    .nowait = tv_dict_get_number(d, "nowait") != 0,
+  };
+
+  scid_T sid = (scid_T)tv_dict_get_number(d, "sid");
+  linenr_T lnum = (linenr_T)tv_dict_get_number(d, "lnum");
+
+  mapblock_T **map_table = maphash;
+  mapblock_T **abbr_table = &first_abbr;
+
+  if (tv_dict_get_number(d, "buffer") != 0) {
+    map_table = curbuf->b_maphash;
+    abbr_table = &curbuf->b_first_abbr;
+  }
+  // mode from the dict is not used
+  bool simplified = tv_dict_get_number(d, "simplified") != 0;
+
+  // Delete any existing mapping for this lhs and mode.
+  char_u *arg = vim_strsave((char_u *)lhs);
+  do_map(1, arg, mode, is_abbr);  // TODO: refactor this later
+  xfree(arg);
+
+  char *keys_buf = NULL;
+  char *keys = replace_termcodes(lhs, STRLEN(lhs), &keys_buf, REPTERM_FROM_PART | REPTERM_DO_LT,
+                                 NULL, CPO_TO_CPO_FLAGS);
+  map_add(curbuf, map_table, abbr_table, (char_u *)keys, &args, noremap, mode, is_abbr, sid, lnum,
+          simplified);
+  xfree(keys_buf);
+}
+
 /// "maparg()" function
 void f_maparg(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index f9429a8020..ec9af3d825 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -1,12 +1,12 @@
-" Tests for maparg().
+" Tests for maparg(), mapcheck() and mapset().
 " Also test utf8 map with a 0x80 byte.
 " Also test mapcheck()
 
-function s:SID()     
+func s:SID()     
   return str2nr(matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$'))
-endfun
+endfunc
 
-function Test_maparg()
+funct Test_maparg()
   new
   set cpo-=<
   set encoding=utf8
@@ -17,24 +17,24 @@ function Test_maparg()
   vnoremap <script> <buffer> <expr> <silent> bar isbar
   call assert_equal("is<F4>foo", maparg('foo<C-V>'))
   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo<C-V>',
-        \ 'mode': ' ', 'nowait': 0, 'expr': 0, 'sid': sid, 'lnum': lnum + 1,
-        \ 'rhs': 'is<F4>foo', 'buffer': 0},
-        \ maparg('foo<C-V>', '', 0, 1))
+        \ 'mode': ' ', 'nowait': 0, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 
+	\ 'simplified': 1, 'rhs': 'is<F4>foo', 'buffer': 0},
+	\ maparg('foo<C-V>', '', 0, 1))
   call assert_equal({'silent': 1, 'noremap': 1, 'script': 1, 'lhs': 'bar', 'mode': 'v',
         \ 'nowait': 0, 'expr': 1, 'sid': sid, 'lnum': lnum + 2,
-        \ 'rhs': 'isbar', 'buffer': 1},
+	\ 'simplified': 0, 'rhs': 'isbar', 'buffer': 1},
         \ 'bar'->maparg('', 0, 1))
   let lnum = expand('<sflnum>')
   map <buffer> <nowait> foo bar
   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo', 'mode': ' ',
         \ 'nowait': 1, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 'rhs': 'bar',
-        \ 'buffer': 1},
+	\ 'simplified': 0, 'buffer': 1},
         \ maparg('foo', '', 0, 1))
   let lnum = expand('<sflnum>')
   tmap baz foo
   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'baz', 'mode': 't',
         \ 'nowait': 0, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 'rhs': 'foo',
-        \ 'buffer': 0},
+	\ 'simplified': 0, 'buffer': 0},
         \ maparg('baz', 't', 0, 1))
 
   map abc x<char-114>x
@@ -89,7 +89,7 @@ function Test_maparg()
   let d = maparg('esc', 'i', 1, 1)
   call assert_equal(['esc', "\<C-V>\<C-V>\<Esc>", '!'], [d.lhs, d.rhs, d.mode])
   abclear
-endfunction
+endfunc
 
 func Test_mapcheck()
   call assert_equal('', mapcheck('a'))
@@ -130,7 +130,7 @@ func Test_mapcheck()
   unabbr ab
 endfunc
 
-function Test_range_map()
+func Test_range_map()
   new
   " Outside of the range, minimum
   inoremap <Char-0x1040> a
@@ -145,6 +145,31 @@ function Test_range_map()
   inoremap <Char-0xf040> d
   execute "normal a\uf040\<Esc>"
   call assert_equal("abcd", getline(1))
-endfunction
+endfunc
+
+func One_mapset_test(keys)
+  exe 'nnoremap ' .. a:keys .. ' original<CR>'
+  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('n', orig.mode)
+
+  exe 'nunmap ' .. a:keys
+  let d = maparg(a:keys, 'n', 0, 1)
+  call assert_equal({}, d)
+
+  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('n', d.mode)
+
+  exe 'nunmap ' .. a:keys
+endfunc
+
+func Test_mapset()
+  call One_mapset_test('K')
+  call One_mapset_test('<F3>')
+endfunc
 
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 5c72640bc2b60a018ccfcf18bca809b635f250f6 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 14:00:57 +0800
Subject: vim-patch:8.2.0812: mapset() does not properly handle <> notation

Problem:    mapset() does not properly handle <> notation.
Solution:   Convert <> codes. (closes vim/vim#6116)
https://github.com/vim/vim/commit/c94c1467b9b86156a6b7c8d3e41ff01c13d2be07
---
 src/nvim/mapping.c               |  7 ++--
 src/nvim/testdir/test_maparg.vim | 69 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 73 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 384497174d..3613849a73 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -2150,6 +2150,9 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     emsg(_("E99: rhs entry missing in mapset() dict argument"));
     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;
   if (tv_dict_get_number(d, "script") != 0) {
@@ -2158,9 +2161,9 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   // TODO: support "callback" and "desc"
   MapArguments args = {
-    .rhs = vim_strsave((char_u *)rhs),
+    .rhs = (char_u *)rhs,
     .rhs_lua = LUA_NOREF,
-    .orig_rhs = vim_strsave((char_u *)rhs),
+    .orig_rhs = vim_strsave((char_u *)orig_rhs),
     .expr = tv_dict_get_number(d, "expr") != 0,
     .silent = tv_dict_get_number(d, "silent") != 0,
     .nowait = tv_dict_get_number(d, "nowait") != 0,
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index ec9af3d825..6fea66b7c6 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -6,7 +6,7 @@ func s:SID()
   return str2nr(matchstr(expand('<sfile>'), '<SNR>\zs\d\+\ze_SID$'))
 endfunc
 
-funct Test_maparg()
+func Test_maparg()
   new
   set cpo-=<
   set encoding=utf8
@@ -170,6 +170,73 @@ endfunc
 func Test_mapset()
   call One_mapset_test('K')
   call One_mapset_test('<F3>')
+
+  " Check <> key conversion
+  new
+  inoremap K one<Left>x
+  call feedkeys("iK\<Esc>", 'xt')
+  call assert_equal('onxe', getline(1))
+
+  let orig = maparg('K', 'i', 0, 1)
+  call assert_equal('K', orig.lhs)
+  call assert_equal('one<Left>x', orig.rhs)
+  call assert_equal('i', orig.mode)
+
+  iunmap K
+  let d = maparg('K', 'i', 0, 1)
+  call assert_equal({}, d)
+
+  call mapset('i', 0, orig)
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('onxe', getline(1))
+
+  iunmap K
+
+  " Test literal <CR> using a backslash
+  let cpo_save = &cpo
+  set cpo-=B
+  inoremap K one\<CR>two
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('one<CR>two', getline(1))
+
+  let orig = maparg('K', 'i', 0, 1)
+  call assert_equal('K', orig.lhs)
+  call assert_equal('one\<CR>two', orig.rhs)
+  call assert_equal('i', orig.mode)
+
+  iunmap K
+  let d = maparg('K', 'i', 0, 1)
+  call assert_equal({}, d)
+
+  call mapset('i', 0, orig)
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('one<CR>two', getline(1))
+
+  iunmap K
+  let &cpo = cpo_save
+
+  " Test literal <CR> using CTRL-V
+  inoremap K one<CR>two
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('one<CR>two', getline(1))
+
+  let orig = maparg('K', 'i', 0, 1)
+  call assert_equal('K', orig.lhs)
+  call assert_equal("one\x16<CR>two", orig.rhs)
+  call assert_equal('i', orig.mode)
+
+  iunmap K
+  let d = maparg('K', 'i', 0, 1)
+  call assert_equal({}, d)
+
+  call mapset('i', 0, orig)
+  call feedkeys("SK\<Esc>", 'xt')
+  call assert_equal('one<CR>two', getline(1))
+
+  iunmap K
+  let &cpo = cpo_save
+
+  bwipe!
 endfunc
 
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 6963c2bdcd3cc2a2f0466b23152e80fc0d037a2c Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 14:04:55 +0800
Subject: vim-patch:8.2.0815: maparg() does not provide enough information for
 mapset()

Problem:    maparg() does not provide enough information for mapset().
Solution:   Add "lhsraw" and "lhsrawalt" items.  Drop "simplified"
https://github.com/vim/vim/commit/9c65253fe702ea010afec11aa971acd542c35de2

vim-patch:9.0.0127: unused variable

Problem:    Unused variable.
Solution:   Remove the variable. (closes vim/vim#10829)
https://github.com/vim/vim/commit/e95f22f63a1871b91e5508088e5ae4905ce28cd7
---
 src/nvim/mapping.c               | 71 ++++++++++++++++++++--------------------
 src/nvim/testdir/test_maparg.vim | 48 ++++++++++++++++++++++-----
 2 files changed, 74 insertions(+), 45 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 3613849a73..cbbe07635f 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -1993,9 +1993,9 @@ void f_hasmapto(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// @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, long buffer_value,
-                               bool compatible)
-  FUNC_ATTR_NONNULL_ALL
+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)
 {
   char *const lhs = str2special_save((const char *)mp->m_keys,
                                      compatible, !compatible);
@@ -2027,6 +2027,11 @@ static void mapblock_fill_dict(dict_T *const dict, const mapblock_T *const mp, l
     tv_dict_add_allocated_str(dict, S_LEN("desc"), xstrdup(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);
+  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);
@@ -2039,23 +2044,10 @@ static void mapblock_fill_dict(dict_T *const dict, const mapblock_T *const mp, l
     tv_dict_add_nr(dict, S_LEN("replace_keycodes"), 1);
   }
   tv_dict_add_allocated_str(dict, S_LEN("mode"), mapmode);
-  tv_dict_add_nr(dict, S_LEN("simplified"), mp->m_simplified ? 1 : 0);
 }
 
 static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
 {
-  char *keys_buf = NULL;
-  char_u *alt_keys_buf = NULL;
-  bool did_simplify = false;
-  char_u *rhs;
-  LuaRef rhs_lua;
-  int mode;
-  bool abbr = false;
-  bool get_dict = false;
-  mapblock_T *mp = NULL;
-  int buffer_local;
-  int flags = REPTERM_FROM_PART | REPTERM_DO_LT;
-
   // Return empty string for failure.
   rettv->v_type = VAR_STRING;
   rettv->vval.v_string = NULL;
@@ -2065,8 +2057,11 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     return;
   }
 
-  char buf[NUMBUFLEN];
   const char *which;
+  char buf[NUMBUFLEN];
+  bool abbr = false;
+  bool get_dict = false;
+
   if (argvars[1].v_type != VAR_UNKNOWN) {
     which = tv_get_string_buf_chk(&argvars[1], buf);
     if (argvars[2].v_type != VAR_UNKNOWN) {
@@ -2082,13 +2077,19 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     return;
   }
 
-  mode = get_map_mode((char **)&which, 0);
+  char *keys_buf = NULL;
+  char_u *alt_keys_buf = NULL;
+  bool did_simplify = false;
+  const int flags = REPTERM_FROM_PART | REPTERM_DO_LT;
+  const int mode = get_map_mode((char **)&which, 0);
 
   char_u *keys_simplified
-    = (char_u *)replace_termcodes(keys,
-                                  STRLEN(keys), &keys_buf, flags, &did_simplify,
+    = (char_u *)replace_termcodes(keys, STRLEN(keys), &keys_buf, flags, &did_simplify,
                                   CPO_TO_CPO_FLAGS);
-  rhs = check_map(keys_simplified, mode, exact, false, abbr, &mp, &buffer_local, &rhs_lua);
+  mapblock_T *mp = NULL;
+  int buffer_local;
+  LuaRef rhs_lua;
+  char_u *rhs = check_map(keys_simplified, mode, exact, false, abbr, &mp, &buffer_local, &rhs_lua);
   if (did_simplify) {
     // When the lhs is being simplified the not-simplified keys are
     // preferred for printing, like in do_map().
@@ -2117,7 +2118,8 @@ static void get_maparg(typval_T *argvars, typval_T *rettv, int exact)
     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, buffer_local, true);
+      mapblock_fill_dict(rettv->vval.v_dict, mp, did_simplify ? (char *)keys_simplified : NULL,
+                         buffer_local, true);
     }
   }
 
@@ -2141,13 +2143,11 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   // Get the values in the same order as above in get_maparg().
   char *lhs = tv_dict_get_string(d, "lhs", false);
-  if (lhs == NULL) {
-    emsg(_("E99: lhs entry missing in mapset() dict argument"));
-    return;
-  }
+  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 (rhs == NULL) {
-    emsg(_("E99: rhs entry missing in mapset() dict argument"));
+  if (lhs == NULL || lhsraw == NULL || rhs == NULL) {
+    emsg(_("E460: entries missing in mapset() dict argument"));
     return;
   }
   char *orig_rhs = rhs;
@@ -2180,19 +2180,18 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     abbr_table = &curbuf->b_first_abbr;
   }
   // mode from the dict is not used
-  bool simplified = tv_dict_get_number(d, "simplified") != 0;
 
   // Delete any existing mapping for this lhs and mode.
   char_u *arg = vim_strsave((char_u *)lhs);
   do_map(1, arg, mode, is_abbr);  // TODO: refactor this later
   xfree(arg);
 
-  char *keys_buf = NULL;
-  char *keys = replace_termcodes(lhs, STRLEN(lhs), &keys_buf, REPTERM_FROM_PART | REPTERM_DO_LT,
-                                 NULL, CPO_TO_CPO_FLAGS);
-  map_add(curbuf, map_table, abbr_table, (char_u *)keys, &args, noremap, mode, is_abbr, sid, lnum,
-          simplified);
-  xfree(keys_buf);
+  if (lhsrawalt != NULL) {
+    map_add(curbuf, map_table, abbr_table, (char_u *)lhsrawalt, &args, noremap, mode, is_abbr,
+            sid, lnum, true);
+  }
+  map_add(curbuf, map_table, abbr_table, (char_u *)lhsraw, &args, noremap, mode, is_abbr,
+          sid, lnum, false);
 }
 
 /// "maparg()" function
@@ -2623,7 +2622,7 @@ 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, buffer_value, false);
+        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) {
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index 6fea66b7c6..abbee7db95 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -17,24 +17,28 @@ func Test_maparg()
   vnoremap <script> <buffer> <expr> <silent> bar isbar
   call assert_equal("is<F4>foo", maparg('foo<C-V>'))
   call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo<C-V>',
+        \ 'lhsraw': "foo\x80\xfc\x04V", 'lhsrawalt': "foo\x16",
         \ 'mode': ' ', 'nowait': 0, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 
-	\ 'simplified': 1, 'rhs': 'is<F4>foo', 'buffer': 0},
+	\ 'rhs': 'is<F4>foo', 'buffer': 0},
 	\ maparg('foo<C-V>', '', 0, 1))
-  call assert_equal({'silent': 1, 'noremap': 1, 'script': 1, 'lhs': 'bar', 'mode': 'v',
+  call assert_equal({'silent': 1, 'noremap': 1, 'script': 1, 'lhs': 'bar',
+        \ 'lhsraw': 'bar', 'mode': 'v',
         \ 'nowait': 0, 'expr': 1, 'sid': sid, 'lnum': lnum + 2,
-	\ 'simplified': 0, 'rhs': 'isbar', 'buffer': 1},
+	\ 'rhs': 'isbar', 'buffer': 1},
         \ 'bar'->maparg('', 0, 1))
   let lnum = expand('<sflnum>')
   map <buffer> <nowait> foo bar
-  call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo', 'mode': ' ',
+  call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'foo',
+        \ 'lhsraw': 'foo', 'mode': ' ',
         \ 'nowait': 1, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 'rhs': 'bar',
-	\ 'simplified': 0, 'buffer': 1},
+	\ 'buffer': 1},
         \ maparg('foo', '', 0, 1))
   let lnum = expand('<sflnum>')
   tmap baz foo
-  call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'baz', 'mode': 't',
+  call assert_equal({'silent': 0, 'noremap': 0, 'script': 0, 'lhs': 'baz',
+        \ 'lhsraw': 'baz', 'mode': 't',
         \ 'nowait': 0, 'expr': 0, 'sid': sid, 'lnum': lnum + 1, 'rhs': 'foo',
-	\ 'simplified': 0, 'buffer': 0},
+	\ 'buffer': 0},
         \ maparg('baz', 't', 0, 1))
 
   map abc x<char-114>x
@@ -213,7 +217,6 @@ func Test_mapset()
   call assert_equal('one<CR>two', getline(1))
 
   iunmap K
-  let &cpo = cpo_save
 
   " Test literal <CR> using CTRL-V
   inoremap K one<CR>two
@@ -235,8 +238,35 @@ func Test_mapset()
 
   iunmap K
   let &cpo = cpo_save
-
   bwipe!
 endfunc
 
+func Check_ctrlb_map(d, check_alt)
+  call assert_equal('<C-B>', a:d.lhs)
+  if a:check_alt
+    call assert_equal("\x80\xfc\x04B", a:d.lhsraw)
+    call assert_equal("\x02", a:d.lhsrawalt)
+  else
+    call assert_equal("\x02", a:d.lhsraw)
+  endif
+endfunc
+
+func Test_map_restore()
+  " Test restoring map with alternate keycode
+  nmap <C-B> back
+  let d = maparg('<C-B>', 'n', 0, 1)
+  call Check_ctrlb_map(d, 1)
+  let dsimp = maparg("\x02", 'n', 0, 1)
+  call Check_ctrlb_map(dsimp, 0)
+  nunmap <C-B>
+  call mapset('n', 0, d)
+  let d = maparg('<C-B>', 'n', 0, 1)
+  call Check_ctrlb_map(d, 1)
+  let dsimp = maparg("\x02", 'n', 0, 1)
+  call Check_ctrlb_map(dsimp, 0)
+
+  nunmap <C-B>
+
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab
-- 
cgit 


From 7d45f1a5e8d05000a174dac149b56217c82e0214 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 15:42:01 +0800
Subject: vim-patch:8.2.1773: crash when calling mapset() with a list as first
 argument

Problem:    Crash when calling mapset() with a list as first argument.
Solution:   Check for NULL. (closes vim/vim#7040)
https://github.com/vim/vim/commit/1b9129809d8269acb8e7c79d8fc99c7976b4f76e
---
 src/nvim/mapping.c               | 7 +++++--
 src/nvim/testdir/test_maparg.vim | 2 ++
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index cbbe07635f..0bb397c748 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -2132,8 +2132,11 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   char buf[NUMBUFLEN];
   const char *which = tv_get_string_buf_chk(&argvars[0], buf);
-  int mode = get_map_mode((char **)&which, 0);
-  bool is_abbr = tv_get_number(&argvars[1]) != 0;
+  if (which == NULL) {
+    return;
+  }
+  const int mode = get_map_mode((char **)&which, 0);
+  const bool is_abbr = tv_get_number(&argvars[1]) != 0;
 
   if (argvars[2].v_type != VAR_DICT) {
     emsg(_(e_dictreq));
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index abbee7db95..6b69def374 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -239,6 +239,8 @@ func Test_mapset()
   iunmap K
   let &cpo = cpo_save
   bwipe!
+
+  call assert_fails('call mapset([], v:false, {})', 'E730:')
 endfunc
 
 func Check_ctrlb_map(d, check_alt)
-- 
cgit 


From 34e7dc5d051918dc9df3d7bd8309a9a4974e7874 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 15:43:38 +0800
Subject: vim-patch:8.2.2804: setting buffer local mapping with mapset()
 changes global

Problem:    Setting buffer local mapping with mapset() changes global mapping.
Solution:   Only set the local mapping. (closes vim/vim#8143)
https://github.com/vim/vim/commit/7ba1e4d363164e32a93cceab64b42e8c6d89e9f3
---
 src/nvim/mapping.c               | 24 +++++++++++-------------
 src/nvim/testdir/test_maparg.vim | 21 +++++++++++++++++++++
 2 files changed, 32 insertions(+), 13 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index 0bb397c748..ac81cbcb89 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -2171,23 +2171,21 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     .silent = tv_dict_get_number(d, "silent") != 0,
     .nowait = tv_dict_get_number(d, "nowait") != 0,
   };
-
   scid_T sid = (scid_T)tv_dict_get_number(d, "sid");
   linenr_T lnum = (linenr_T)tv_dict_get_number(d, "lnum");
-
-  mapblock_T **map_table = maphash;
-  mapblock_T **abbr_table = &first_abbr;
-
-  if (tv_dict_get_number(d, "buffer") != 0) {
-    map_table = curbuf->b_maphash;
-    abbr_table = &curbuf->b_first_abbr;
-  }
+  bool buffer = tv_dict_get_number(d, "buffer") != 0;
   // mode from the dict is not used
 
+  mapblock_T **map_table = buffer ? curbuf->b_maphash : maphash;
+  mapblock_T **abbr_table = buffer ? &curbuf->b_first_abbr : &first_abbr;
+
   // Delete any existing mapping for this lhs and mode.
-  char_u *arg = vim_strsave((char_u *)lhs);
-  do_map(1, arg, mode, is_abbr);  // TODO: refactor this later
-  xfree(arg);
+  MapArguments unmap_args = MAP_ARGUMENTS_INIT;
+  set_maparg_lhs_rhs(lhs, strlen(lhs), rhs, strlen(rhs), LUA_NOREF, 0, &unmap_args);
+  unmap_args.buffer = buffer;
+  buf_do_map(1, &unmap_args, mode, false, curbuf);
+  xfree(unmap_args.rhs);
+  xfree(unmap_args.orig_rhs);
 
   if (lhsrawalt != NULL) {
     map_add(curbuf, map_table, abbr_table, (char_u *)lhsrawalt, &args, noremap, mode, is_abbr,
@@ -2219,7 +2217,7 @@ void f_mapcheck(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 /// @param buffer  If true, make a buffer-local mapping for curbuf
 void add_map(char *lhs, char *rhs, int mode, bool buffer)
 {
-  MapArguments args = { 0 };
+  MapArguments args = MAP_ARGUMENTS_INIT;
   set_maparg_lhs_rhs(lhs, strlen(lhs), rhs, strlen(rhs), LUA_NOREF, 0, &args);
   args.buffer = buffer;
 
diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index 6b69def374..0bade1df7f 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -253,6 +253,27 @@ func Check_ctrlb_map(d, check_alt)
   endif
 endfunc
 
+func Test_map_local()
+  nmap a global
+  nmap <buffer>a local
+
+  let prev_map_list = split(execute('nmap a'), "\n")
+  call assert_match('n\s*a\s*@local', prev_map_list[0])
+  call assert_match('n\s*a\s*global', prev_map_list[1])
+
+  let mapping = maparg('a', 'n', 0, 1)
+  call assert_equal(1, mapping.buffer)
+  let mapping.rhs = 'new_local'
+  call mapset('n', 0, mapping)
+
+  " Check that the global mapping is left untouched.
+  let map_list = split(execute('nmap a'), "\n")
+  call assert_match('n\s*a\s*@new_local', map_list[0])
+  call assert_match('n\s*a\s*global', map_list[1])
+
+  nunmap a
+endfunc
+
 func Test_map_restore()
   " Test restoring map with alternate keycode
   nmap <C-B> back
-- 
cgit 


From 9cebfbe6abf41cdbb501a3acf9857b1d34c1cffc Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 15:38:54 +0800
Subject: vim-patch:8.2.4831: crash when using maparg() and unmapping
 simplified keys

Problem:    Crash when using maparg() and unmapping simplified keys.
Solution:   Do not keep a mapblock pointer. (closes vim/vim#10294)
https://github.com/vim/vim/commit/2c8a7ebdad9da017bfb6dc8a0f46acea77ec2e17

N/A patches for version.c:

vim-patch:8.2.0832: compiler warning for uninitialized variable

Problem:    Compiler warning for uninitialized variable. (Tony Mechelynck)
Solution:   Add initial value.
https://github.com/vim/vim/commit/a55ba06f6904af3d6a78fc90358cf72d4f2e8450
---
 src/nvim/testdir/test_maparg.vim | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'src')

diff --git a/src/nvim/testdir/test_maparg.vim b/src/nvim/testdir/test_maparg.vim
index 0bade1df7f..dad4c81a7b 100644
--- a/src/nvim/testdir/test_maparg.vim
+++ b/src/nvim/testdir/test_maparg.vim
@@ -85,6 +85,12 @@ func Test_maparg()
   call assert_equal(['{', 'w', 's'], [d.lhs, d.rhs, d.mode])
   sunmap {
 
+  map <C-I> foo
+  unmap <Tab>
+  " This used to cause a segfault
+  call maparg('<C-I>', '', 0, 1)
+  unmap <C-I>
+
   map abc <Nop>
   call assert_equal("<Nop>", maparg('abc'))
   unmap abc
@@ -93,6 +99,7 @@ func Test_maparg()
   let d = maparg('esc', 'i', 1, 1)
   call assert_equal(['esc', "\<C-V>\<C-V>\<Esc>", '!'], [d.lhs, d.rhs, d.mode])
   abclear
+  unlet d
 endfunc
 
 func Test_mapcheck()
-- 
cgit 


From 8a032a686643305120f28baedb5613e3f286ae63 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 15:56:29 +0800
Subject: vim-patch:8.2.5106: default cmdwin mappings are re-mappable

Problem:    Default cmdwin mappings are re-mappable.
Solution:   Make the default mappings not re-mappable. (closes vim/vim#10580)  Use
            symbols for the first do_map() argument.
https://github.com/vim/vim/commit/44068e97dbd8fc8ebd93113e436a1e37a6bff52c
---
 src/nvim/digraph.c |  4 ++--
 src/nvim/mapping.c | 40 +++++++++++++++++++++-------------------
 src/nvim/mapping.h |  5 +++++
 3 files changed, 28 insertions(+), 21 deletions(-)

(limited to 'src')

diff --git a/src/nvim/digraph.c b/src/nvim/digraph.c
index 36f6d06512..733b3d3d5d 100644
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -2121,7 +2121,7 @@ void ex_loadkeymap(exarg_T *eap)
     vim_snprintf((char *)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(0, buf, MODE_LANGMAP, false);
+    (void)do_map(MAPTYPE_MAP, buf, MODE_LANGMAP, false);
   }
 
   p_cpo = save_cpo;
@@ -2158,7 +2158,7 @@ static void keymap_unload(void)
 
   for (int i = 0; i < curbuf->b_kmap_ga.ga_len; i++) {
     vim_snprintf(buf, sizeof(buf), "<buffer> %s", kp[i].from);
-    (void)do_map(1, (char_u *)buf, MODE_LANGMAP, false);
+    (void)do_map(MAPTYPE_UNMAP, (char_u *)buf, MODE_LANGMAP, false);
   }
   keymap_ga_clear(&curbuf->b_kmap_ga);
 
diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index ac81cbcb89..e8464ae76f 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -509,7 +509,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
   abbr_table = &first_abbr;
 
   // For ":noremap" don't remap, otherwise do remap.
-  if (maptype == 2) {
+  if (maptype == MAPTYPE_NOREMAP) {
     noremap = REMAP_NONE;
   } else {
     noremap = REMAP_YES;
@@ -527,10 +527,10 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
 
   const bool has_lhs = (args->lhs[0] != NUL);
   const bool has_rhs = args->rhs_lua != LUA_NOREF || (args->rhs[0] != NUL) || args->rhs_is_noop;
-  const bool do_print = !has_lhs || (maptype != 1 && !has_rhs);
+  const bool do_print = !has_lhs || (maptype != MAPTYPE_UNMAP && !has_rhs);
 
   // check for :unmap without argument
-  if (maptype == 1 && !has_lhs) {
+  if (maptype == MAPTYPE_UNMAP && !has_lhs) {
     retval = 1;
     goto theend;
   }
@@ -564,13 +564,11 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
         goto theend;
       }
 
-      if (is_abbrev && maptype != 1) {
-        //
+      if (is_abbrev && maptype != MAPTYPE_UNMAP) {
         // If an abbreviation ends in a keyword character, the
         // rest must be all keyword-char or all non-keyword-char.
         // Otherwise we won't be able to find the start of it in a
         // vi-compatible way.
-        //
         int same = -1;
 
         const int first = vim_iswordp(lhs);
@@ -608,7 +606,8 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
     }
 
     // Check if a new local mapping wasn't already defined globally.
-    if (args->unique && map_table == buf->b_maphash && has_lhs && has_rhs && maptype != 1) {
+    if (args->unique && map_table == buf->b_maphash && has_lhs && has_rhs
+        && maptype != MAPTYPE_UNMAP) {
       // need to loop over all global hash lists
       for (int hash = 0; hash < 256 && !got_int; hash++) {
         if (is_abbrev) {
@@ -638,7 +637,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
     }
 
     // When listing global mappings, also list buffer-local ones here.
-    if (map_table != buf->b_maphash && !has_rhs && maptype != 1) {
+    if (map_table != buf->b_maphash && !has_rhs && maptype != MAPTYPE_UNMAP) {
       // need to loop over all global hash lists
       for (int hash = 0; hash < 256 && !got_int; hash++) {
         if (is_abbrev) {
@@ -673,7 +672,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
     // entry with a matching 'to' part. This was done to allow ":ab foo bar"
     // to be unmapped by typing ":unab foo", where "foo" will be replaced by
     // "bar" because of the abbreviation.
-    for (int round = 0; (round == 0 || maptype == 1) && round <= 1
+    for (int round = 0; (round == 0 || maptype == MAPTYPE_UNMAP) && round <= 1
          && !did_it && !got_int; round++) {
       int hash_start, hash_end;
       if (has_lhs || is_abbrev) {
@@ -707,7 +706,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
               p = mp->m_keys;
             }
             if (STRNCMP(p, lhs, (size_t)(n < len ? n : len)) == 0) {
-              if (maptype == 1) {
+              if (maptype == MAPTYPE_UNMAP) {
                 // Delete entry.
                 // Only accept a full match.  For abbreviations
                 // we ignore trailing space when matching with
@@ -803,7 +802,7 @@ static int buf_do_map(int maptype, MapArguments *args, int mode, bool is_abbrev,
       }
     }
 
-    if (maptype == 1) {
+    if (maptype == MAPTYPE_UNMAP) {
       // delete entry
       if (!did_it) {
         if (!keyround1_simplified) {
@@ -879,7 +878,9 @@ theend:
 /// for :cabbr mode is MODE_CMDLINE
 /// ```
 ///
-/// @param maptype  0 for |:map|, 1 for |:unmap|, 2 for |noremap|.
+/// @param maptype  MAPTYPE_MAP for |:map|
+///                 MAPTYPE_UNMAP for |:unmap|
+///                 MAPTYPE_NOREMAP for |noremap|.
 /// @param arg      C-string containing the arguments of the map/abbrev
 ///                 command, i.e. everything except the initial `:[X][nore]map`.
 ///                 - Cannot be a read-only string; it will be modified.
@@ -896,7 +897,7 @@ theend:
 int do_map(int maptype, char_u *arg, int mode, bool is_abbrev)
 {
   MapArguments parsed_args;
-  int result = str_to_mapargs(arg, maptype == 1, &parsed_args);
+  int result = str_to_mapargs(arg, maptype == MAPTYPE_UNMAP, &parsed_args);
   switch (result) {
   case 0:
     break;
@@ -2183,7 +2184,7 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   MapArguments unmap_args = MAP_ARGUMENTS_INIT;
   set_maparg_lhs_rhs(lhs, strlen(lhs), rhs, strlen(rhs), LUA_NOREF, 0, &unmap_args);
   unmap_args.buffer = buffer;
-  buf_do_map(1, &unmap_args, mode, false, curbuf);
+  buf_do_map(MAPTYPE_UNMAP, &unmap_args, mode, false, curbuf);
   xfree(unmap_args.rhs);
   xfree(unmap_args.orig_rhs);
 
@@ -2221,7 +2222,7 @@ void add_map(char *lhs, char *rhs, int mode, bool buffer)
   set_maparg_lhs_rhs(lhs, strlen(lhs), rhs, strlen(rhs), LUA_NOREF, 0, &args);
   args.buffer = buffer;
 
-  buf_do_map(2, &args, mode, false, curbuf);
+  buf_do_map(MAPTYPE_NOREMAP, &args, mode, false, curbuf);
   xfree(args.rhs);
   xfree(args.orig_rhs);
 }
@@ -2401,7 +2402,8 @@ static void do_exmap(exarg_T *eap, int isabbrev)
   char *cmdp = eap->cmd;
   mode = get_map_mode(&cmdp, eap->forceit || isabbrev);
 
-  switch (do_map((*cmdp == 'n') ? 2 : (*cmdp == 'u'),
+  switch (do_map((*cmdp == 'n') ? MAPTYPE_NOREMAP
+                 : (*cmdp == 'u') ? MAPTYPE_UNMAP : MAPTYPE_MAP,
                  (char_u *)eap->arg, mode, isabbrev)) {
   case 1:
     emsg(_(e_invarg));
@@ -2561,11 +2563,11 @@ void modify_keymap(uint64_t channel_id, Buffer buffer, bool is_unmap, String mod
   }
 
   // buf_do_map() reads noremap/unmap as its own argument.
-  int maptype_val = 0;
+  int maptype_val = MAPTYPE_MAP;
   if (is_unmap) {
-    maptype_val = 1;
+    maptype_val = MAPTYPE_UNMAP;
   } else if (is_noremap) {
-    maptype_val = 2;
+    maptype_val = MAPTYPE_NOREMAP;
   }
 
   switch (buf_do_map(maptype_val, &parsed_args, mode_val, 0, target_buf)) {
diff --git a/src/nvim/mapping.h b/src/nvim/mapping.h
index 98d0074075..7c48c3bce2 100644
--- a/src/nvim/mapping.h
+++ b/src/nvim/mapping.h
@@ -48,6 +48,11 @@ typedef struct map_arguments MapArguments;
 #define MAP_ARGUMENTS_INIT { false, false, false, false, false, false, false, false, \
                              { 0 }, 0, { 0 }, 0, NULL, 0, LUA_NOREF, false, NULL, 0, NULL }
 
+// Used for the first argument of do_map()
+#define MAPTYPE_MAP      0
+#define MAPTYPE_UNMAP    1
+#define MAPTYPE_NOREMAP  2
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "mapping.h.generated.h"
 #endif
-- 
cgit 


From d954e8da62faccd468896baf2fe06107196cf952 Mon Sep 17 00:00:00 2001
From: zeertzjq <zeertzjq@outlook.com>
Date: Mon, 1 Aug 2022 16:46:58 +0800
Subject: feat(mapset): support restoring "replace_keycodes" and "desc"

---
 src/nvim/mapping.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'src')

diff --git a/src/nvim/mapping.c b/src/nvim/mapping.c
index e8464ae76f..41ab236676 100644
--- a/src/nvim/mapping.c
+++ b/src/nvim/mapping.c
@@ -428,6 +428,9 @@ static int str_to_mapargs(const char_u *strargs, bool is_unmap, MapArguments *ma
   return 0;
 }
 
+/// @param args  "rhs", "rhs_lua", "orig_rhs", "expr", "silent", "nowait", "replace_keycodes" and
+///              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,
                     MapArguments *args, int noremap, int mode, bool is_abbr, scid_T sid,
@@ -2162,15 +2165,15 @@ void f_mapset(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   if (tv_dict_get_number(d, "script") != 0) {
     noremap = REMAP_SCRIPT;
   }
-
-  // TODO: support "callback" and "desc"
-  MapArguments args = {
+  MapArguments args = {  // TODO(zeertzjq): support restoring "callback"?
     .rhs = (char_u *)rhs,
     .rhs_lua = LUA_NOREF,
     .orig_rhs = vim_strsave((char_u *)orig_rhs),
     .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),
   };
   scid_T sid = (scid_T)tv_dict_get_number(d, "sid");
   linenr_T lnum = (linenr_T)tv_dict_get_number(d, "lnum");
-- 
cgit