patch 8.2.0924: cannot save and restore a register properly

Problem:    Cannot save and restore a register properly.
Solution:   Add getreginfo() and make setreg() accept a dictionary. (Andy
            Massimino, closes #3370)

diff --git a/runtime/doc/eval.txt b/runtime/doc/eval.txt
index 66246e6347f9ca4430625071f4e7b6820590a795..52994f1179ad912629695f213df61a2fe742bbfe 100644 (file)
--- a/runtime/doc/eval.txt
+++ b/runtime/doc/eval.txt
@@ -2506,8 +2506,9 @@ getpid()                  Number  process ID of Vim
 getpos({expr})                 List    position of cursor, mark, etc.
 getqflist([{what}])            List    list of quickfix items
 getreg([{regname} [, 1 [, {list}]]])
-                               String or List   contents of register
-getregtype([{regname}])                String  type of register
+                               String or List   contents of a register
+getreginfo([{regname}])                Dict    information about a register
+getregtype([{regname}])                String  type of a register
 gettabinfo([{expr}])           List    list of tab pages
 gettabvar({nr}, {varname} [, {def}])
                                any     variable {varname} in tab {nr} or {def}
@@ -5596,6 +5597,31 @@ getreg([{regname} [, 1 [, {list}]]])                     *getreg()*
                Can also be used as a |method|: >
                        GetRegname()->getreg()
 
+getreginfo([{regname}])                                        *getreginfo()*
+               Returns detailed information about register {regname} as a
+               Dictionary with the following entries:
+                       regcontents     List of lines contained in register
+                                       {regname}, like
+                                       |getreg|({regname}, 1, 1).
+                       regtype         the type of register {regname}, as in
+                                       |getregtype()|.
+                       isunnamed       Boolean flag, v:true if this register
+                                       is currently pointed to by the unnamed
+                                       register.
+                       points_to       for the unnamed register, gives the
+                                       single letter name of the register
+                                       currently pointed to (see |quotequote|).
+                                       For example, after deleting a line
+                                       with `dd`, this field will be "1",
+                                       which is the register that got the
+                                       deleted text.
+
+               If {regname} is invalid or not set, an empty Dictionary
+               will be returned.
+               If {regname} is not specified, |v:register| is used.
+
+               Can also be used as a |method|: >
+                       GetRegname()->getreginfo()
 
 getregtype([{regname}])                                        *getregtype()*
                The result is a String, which is type of register {regname}.
@@ -9090,8 +9116,8 @@ setqflist({list} [, {action} [, {what}]])         *setqflist()*
 setreg({regname}, {value} [, {options}])
                Set the register {regname} to {value}.
                If {regname} is "" or "@", the unnamed register '"' is used.
-               {value} may be any value returned by |getreg()|, including
-               a |List|.
+               {value} may be any value returned by |getreg()| or
+               |getreginfo()|, including a |List| or |Dict|.
                If {options} contains "a" or {regname} is upper case,
                then the value is appended.
                {options} can also contain a register type specification:
@@ -9118,9 +9144,13 @@ setreg({regname}, {value} [, {options}])
                        :call setreg(v:register, @*)
                        :call setreg('*', @%, 'ac')
                        :call setreg('a', "1\n2\n3", 'b5')
+                       :call setreg('"', { 'points_to': 'a'})
 
 <              This example shows using the functions to save and restore a
                register: >
+                       :let var_a = getreginfo()
+                       :call setreg('a', var_a)
+<              or:
                        :let var_a = getreg('a', 1, 1)
                        :let var_amode = getregtype('a')
                            ....

diff --git a/runtime/doc/usr_41.txt b/runtime/doc/usr_41.txt
index 89d25dfdcb4bf10be889170fc8698da9c2675fdc..1d896f9a98c4f14cdcafdd9258a519a72885180a 100644 (file)
--- a/runtime/doc/usr_41.txt
+++ b/runtime/doc/usr_41.txt
@@ -1155,6 +1155,7 @@ Various:                                  *various-functions*
        undotree()              return the state of the undo tree
 
        getreg()                get contents of a register
+       getreginfo()            get information about a register
        getregtype()            get type of a register
        setreg()                set contents and type of a register
        reg_executing()         return the name of the register being executed

diff --git a/src/evalfunc.c b/src/evalfunc.c
index 2a22f92e21ca0c20215fca07b10902e1046a74d4..cdc806db2b5042f9b1b88d70ffbf2920e6c4a4da 100644 (file)
--- a/src/evalfunc.c
+++ b/src/evalfunc.c
@@ -94,6 +94,7 @@ static void f_getpid(typval_T *argvars, typval_T *rettv);
 static void f_getcurpos(typval_T *argvars, typval_T *rettv);
 static void f_getpos(typval_T *argvars, typval_T *rettv);
 static void f_getreg(typval_T *argvars, typval_T *rettv);
+static void f_getreginfo(typval_T *argvars, typval_T *rettv);
 static void f_getregtype(typval_T *argvars, typval_T *rettv);
 static void f_gettagstack(typval_T *argvars, typval_T *rettv);
 static void f_haslocaldir(typval_T *argvars, typval_T *rettv);
@@ -586,6 +587,7 @@ static funcentry_T global_functions[] =
     {"getpos",         1, 1, FEARG_1,    ret_list_number,      f_getpos},
     {"getqflist",      0, 1, 0,          ret_list_dict_any,    f_getqflist},
     {"getreg",         0, 3, FEARG_1,    ret_string,   f_getreg},
+    {"getreginfo",     0, 1, FEARG_1,    ret_dict_any, f_getreginfo},
     {"getregtype",     0, 1, FEARG_1,    ret_string,   f_getregtype},
     {"gettabinfo",     0, 1, FEARG_1,    ret_list_dict_any,    f_gettabinfo},
     {"gettabvar",      2, 3, FEARG_1,    ret_any,      f_gettabvar},
@@ -6227,6 +6229,72 @@ range_list_materialize(list_T *list)
            break;
 }
 
+/*
+ * "getreginfo()" function
+ */
+    static void
+f_getreginfo(typval_T *argvars, typval_T *rettv)
+{
+    char_u     *strregname;
+    int                regname;
+    char_u     buf[NUMBUFLEN + 2];
+    long       reglen = 0;
+    dict_T     *dict;
+    list_T     *list;
+
+    if (argvars[0].v_type != VAR_UNKNOWN)
+    {
+       strregname = tv_get_string_chk(&argvars[0]);
+       if (strregname == NULL)
+           return;
+    }
+    else
+       strregname = get_vim_var_str(VV_REG);
+
+    regname = (strregname == NULL ? '"' : *strregname);
+    if (regname == 0 || regname == '@')
+       regname = '"';
+
+    if (rettv_dict_alloc(rettv) == FAIL)
+       return;
+    dict = rettv->vval.v_dict;
+
+    list = (list_T *)get_reg_contents(regname, GREG_EXPR_SRC | GREG_LIST);
+    if (list == NULL)
+       return;
+    dict_add_list(dict, "regcontents", list);
+
+    buf[0] = NUL;
+    buf[1] = NUL;
+    switch (get_reg_type(regname, &reglen))
+    {
+       case MLINE: buf[0] = 'V'; break;
+       case MCHAR: buf[0] = 'v'; break;
+       case MBLOCK:
+                   vim_snprintf((char *)buf, sizeof(buf), "%c%ld", Ctrl_V,
+                           reglen + 1);
+                   break;
+    }
+    dict_add_string(dict, (char *)"regtype", buf);
+
+    buf[0] = get_register_name(get_unname_register());
+    buf[1] = NUL;
+    if (regname == '"')
+       dict_add_string(dict, (char *)"points_to", buf);
+    else
+    {
+       dictitem_T      *item = dictitem_alloc((char_u *)"isunnamed");
+
+       if (item != NULL)
+       {
+           item->di_tv.v_type = VAR_SPECIAL;
+           item->di_tv.vval.v_number = regname == buf[0]
+               ? VVAL_TRUE : VVAL_FALSE;
+           dict_add(dict, item);
+       }
+    }
+}
+
     static void
 return_register(int regname, typval_T *rettv)
 {
@@ -7203,7 +7271,11 @@ f_setreg(typval_T *argvars, typval_T *rettv)
     int                append;
     char_u     yank_type;
     long       block_len;
+    typval_T   *regcontents;
+    int                pointreg;
 
+    pointreg = 0;
+    regcontents = NULL;
     block_len = -1;
     yank_type = MAUTO;
     append = FALSE;
@@ -7217,6 +7289,49 @@ f_setreg(typval_T *argvars, typval_T *rettv)
     if (regname == 0 || regname == '@')
        regname = '"';
 
+    if (argvars[1].v_type == VAR_DICT)
+    {
+       dict_T      *d = argvars[1].vval.v_dict;
+       dictitem_T  *di = dict_find(d, (char_u *)"regcontents", -1);
+       if (di != NULL)
+           regcontents = &di->di_tv;
+
+       stropt = dict_get_string(d, (char_u *)"regtype", FALSE);
+       if (stropt != NULL)
+           switch (*stropt)
+           {
+               case 'v':               // character-wise selection
+                   yank_type = MCHAR;
+                   break;
+               case 'V':               // line-wise selection
+                   yank_type = MLINE;
+                   break;
+               case Ctrl_V:            // block-wise selection
+                   yank_type = MBLOCK;
+                   if (VIM_ISDIGIT(stropt[1]))
+                   {
+                       ++stropt;
+                       block_len = getdigits(&stropt) - 1;
+                       --stropt;
+                   }
+                   break;
+           }
+
+       if (regname == '"')
+       {
+           stropt = dict_get_string(d, (char_u *)"points_to", FALSE);
+           if (stropt != NULL)
+           {
+               pointreg = *stropt;
+               regname = pointreg;
+           }
+       }
+       else if (dict_get_number(d, (char_u *)"isunnamed"))
+           pointreg = regname;
+    }
+    else
+       regcontents = &argvars[1];
+
     if (argvars[2].v_type != VAR_UNKNOWN)
     {
        stropt = tv_get_string_chk(&argvars[2]);
@@ -7246,14 +7361,14 @@ f_setreg(typval_T *argvars, typval_T *rettv)
            }
     }
 
-    if (argvars[1].v_type == VAR_LIST)
+    if (regcontents && regcontents->v_type == VAR_LIST)
     {
        char_u          **lstval;
        char_u          **allocval;
        char_u          buf[NUMBUFLEN];
        char_u          **curval;
        char_u          **curallocval;
-       list_T          *ll = argvars[1].vval.v_list;
+       list_T          *ll = regcontents->vval.v_list;
        listitem_T      *li;
        int             len;
 
@@ -7298,14 +7413,17 @@ free_lstval:
            vim_free(*--curallocval);
        vim_free(lstval);
     }
-    else
+    else if (regcontents)
     {
-       strval = tv_get_string_chk(&argvars[1]);
+       strval = tv_get_string_chk(regcontents);
        if (strval == NULL)
            return;
        write_reg_contents_ex(regname, strval, -1,
                                                append, yank_type, block_len);
     }
+    if (pointreg != 0)
+       get_yank_register(pointreg, TRUE);
+
     rettv->vval.v_number = 0;
 }
 

diff --git a/src/proto/register.pro b/src/proto/register.pro
index 6ad4e49716ce7f18a2ebe28034f6c7618e68e328..07a74b352406fc3ed407f347a6f40d2119e3d941 100644 (file)
--- a/src/proto/register.pro
+++ b/src/proto/register.pro
@@ -29,6 +29,7 @@ void free_yank_all(void);
 int op_yank(oparg_T *oap, int deleting, int mess);
 void do_put(int regname, int dir, long count, int flags);
 int get_register_name(int num);
+int get_unname_register(void);
 void ex_display(exarg_T *eap);
 void dnd_yank_drag_data(char_u *str, long len);
 char_u get_reg_type(int regname, long *reglen);

diff --git a/src/register.c b/src/register.c
index e56149f39221cdfd4162d4eee4d08b3579f9164f..f89a530b448c31a18533f3838ff708462cd9de2b 100644 (file)
--- a/src/register.c
+++ b/src/register.c
@@ -2110,6 +2110,15 @@ get_register_name(int num)
     }
 }
 
+/*
+ * Return the index of the register "" points to.
+ */
+    int
+get_unname_register()
+{
+    return y_previous == NULL ? -1 : y_previous - &y_regs[0];
+}
+
 /*
  * ":dis" and ":registers": Display the contents of the yank registers.
  */

diff --git a/src/testdir/test_eval_stuff.vim b/src/testdir/test_eval_stuff.vim
index 33c57fd0528092e9ed286fa6f1b76e86b4850a1d..3a229b5c1a3f8d09031baf329b6dd968b299e332 100644 (file)
--- a/src/testdir/test_eval_stuff.vim
+++ b/src/testdir/test_eval_stuff.vim
@@ -529,7 +529,6 @@ func Test_setreg_basic()
   call assert_fails('call setreg(1)', 'E119:')
   call assert_fails('call setreg(1, 2, 3, 4)', 'E118:')
   call assert_fails('call setreg([], 2)', 'E730:')
-  call assert_fails('call setreg(1, {})', 'E731:')
   call assert_fails('call setreg(1, 2, [])', 'E730:')
   call assert_fails('call setreg("/", ["1", "2"])', 'E883:')
   call assert_fails('call setreg("=", ["1", "2"])', 'E883:')

diff --git a/src/testdir/test_registers.vim b/src/testdir/test_registers.vim
index f774153a916067b5e8a0b9ab605111e5cf885dc7..b803b3aff152902f7c8aaace33279ffb8c57a7b8 100644 (file)
--- a/src/testdir/test_registers.vim
+++ b/src/testdir/test_registers.vim
@@ -416,4 +416,76 @@ func Test_execute_register()
   call assert_beeps('normal! c@r')
 endfunc
 
+" Test for getting register info
+func Test_get_reginfo()
+  enew
+  call setline(1, ['foo', 'bar'])
+
+  exe 'norm! "zyy'
+  let info = getreginfo('"')
+  call assert_equal('z', info.points_to)
+  call setreg('y', 'baz')
+  call assert_equal('z', getreginfo('').points_to)
+  call setreg('y', { 'isunnamed': v:true })
+  call assert_equal('y', getreginfo('"').points_to)
+
+  exe '$put'
+  call assert_equal(getreg('y'), getline(3))
+  call setreg('', 'qux')
+  call assert_equal('0', getreginfo('').points_to)
+  call setreg('x', 'quux')
+  call assert_equal('0', getreginfo('').points_to)
+
+  let info = getreginfo('')
+  call assert_equal(getreg('', 1, 1), info.regcontents)
+  call assert_equal(getregtype(''), info.regtype)
+
+  exe "norm! 0\<c-v>e" .. '"zy'
+  let info = getreginfo('z')
+  call assert_equal(getreg('z', 1, 1), info.regcontents)
+  call assert_equal(getregtype('z'), info.regtype)
+  call assert_equal(1, +info.isunnamed)
+
+  let info = getreginfo('"')
+  call assert_equal('z', info.points_to)
+
+  bwipe!
+endfunc
+
+" Test for restoring register with dict from getreginfo
+func Test_set_register_dict()
+  enew!
+
+  call setreg('"', #{ regcontents: ['one', 'two'],
+        \ regtype: 'V', points_to: 'z' })
+  call assert_equal(['one', 'two'], getreg('"', 1, 1))
+  let info = getreginfo('"')
+  call assert_equal('z', info.points_to)
+  call assert_equal('V', info.regtype)
+  call assert_equal(1, +getreginfo('z').isunnamed)
+
+  call setreg('x', #{ regcontents: ['three', 'four'],
+        \ regtype: 'v', isunnamed: v:true })
+  call assert_equal(['three', 'four'], getreg('"', 1, 1))
+  let info = getreginfo('"')
+  call assert_equal('x', info.points_to)
+  call assert_equal('v', info.regtype)
+  call assert_equal(1, +getreginfo('x').isunnamed)
+
+  call setreg('y', #{ regcontents: 'five',
+        \ regtype: "\<c-v>", isunnamed: v:false })
+  call assert_equal("\<c-v>4", getreginfo('y').regtype)
+  call assert_equal(0, +getreginfo('y').isunnamed)
+  call assert_equal(['three', 'four'], getreg('"', 1, 1))
+  call assert_equal('x', getreginfo('"').points_to)
+
+  call setreg('"', #{ regcontents: 'six' })
+  call assert_equal('0', getreginfo('"').points_to)
+  call assert_equal(1, +getreginfo('0').isunnamed)
+  call assert_equal(['six'], getreginfo('0').regcontents)
+  call assert_equal(['six'], getreginfo('"').regcontents)
+
+  bwipe!
+endfunc
+
 " vim: shiftwidth=2 sts=2 expandtab

diff --git a/src/version.c b/src/version.c
index 5c39aa67d0f6472139cb2799adc039060b76fdac..9e4993ddae012117270ed46a031b60998d2fff13 100644 (file)
--- a/src/version.c
+++ b/src/version.c
@@ -754,6 +754,8 @@ static char *(features[]) =
 
 static int included_patches[] =
 {   /* Add new patch number below this line */
+/**/
+    924,
 /**/
     923,
 /**/