feat(userreg): Add user-defined registers to Neovim.

This change unlocks additional registers for Neovim by allowing a user
to define their own behavior for non-builtin registers.

This is accopmlished through a new option 'userregfunc'

The 'userregfunc' defines the function to call when handling a register
for which there is no builtin functionality.

The 'userregfunc' function should take 3 arguments:

   action - Either "yank" or "put"
   register - The character corresponding to the register
   content - In the case of action == "yank", the dictionary describing
             the yanked content, with the following keys:

             {type} - Either "char", "line" or "block"
             {lines} - The lines being yanked as a list
             {width} - The width in case of "block" mode.
             {additional_data} - Additional data (can be returned in
             "put" mode)

   In case of "put" this function should return the content to put. This
   content can be either:

     * A dictionary in the same template as content above.
     * A list of strings. This will be assumed to be "line" mode.
     * A string. This will be assumed to be "char" mode.

An example of a "null" 'userregfunc' that provides an implementation
identical to traditional vim registers would be:

      let s:contents = {}
      function! MyUserregFunction(action, register, content) abort
         if a:action == "put"
           return get(s:contents, a:register, "")
        else
           let s:contents[a:register] = a:content
        endif
      endfunction
      set userregfun=MyUserregFunction

  It is important to note that any valid unicode character can now be a
  register, including something like @☺.

  This change also addresses the multibyte parsing issues surrounding

  let @a = 'xyz'
  let @🔨 = 'hammer'

19 files changed, 512 insertions, 72 deletions

diff --git a/runtime/doc/options.txt b/runtime/doc/options.txt
index 2e0c1f8cc4..22d8d7fe1a 100644
--- a/runtime/doc/options.txt
+++ b/runtime/doc/options.txt
@@ -6722,6 +6722,57 @@ A jump table for the options with a short description can be found at |Q_op|.
 	written to disk (see |crash-recovery|).  Also used for the
 	|CursorHold| autocommand event.
 
+						*'userregfun'* *'urf'*
+'userregfun' 'urf'	string	(default "")
+			global
+	The option specifies a function to be used to handle any registers
+	that Neovim does not natively handle. This option unlocks all
+	characters to be used as registers by the user.
+
+	The 'userregfun' function is called each time a user register is read
+	from or written to.
+
+	The 'userregfun' function must take the following parameters:
+
+		{action} The action being done on this register (either 'yank'
+			or 'put'
+
+		{register} The string holding the name of the register. This
+			is always a single character, though multi-byte
+			characters are allowed.
+
+		{content} If the action is 'yank' this is the content being
+			yanked into the register. The content is a dictionary
+			with the following items:
+
+			{lines} The lines being yanked, as a list.
+
+			{type} The type of yank, either "line", "char", or
+			"block"
+
+			{width} The width in case of "block" mode.
+
+			{additional_data} Additional data. (can be returned in
+			put mode).
+
+	In case the action is 'put', the 'userregfun' function should return
+	the content to place in that location. The content can either be a
+	string, in which case "char" mode is inferred, or it can return a
+	dictionary of the same template that populates 'content'.
+
+	A very simple example of a 'userregfun' function that behaves exactly
+	like traditional registers would look like: >
+		
+		let s:contents = {}
+		function! MyUserregFunction(action, register, content) abort
+		   if a:action == "put"
+		     return get(s:contents, a:register, "")
+		  else
+		     let s:contents[a:register] = a:content
+		  endif
+		endfunction
+		set userregfun=MyUserregFunction
+<
 					*'varsofttabstop'* *'vsts'*
 'varsofttabstop' 'vsts'	string	(default "")
 			local to buffer
diff --git a/src/nvim/buffer_defs.h b/src/nvim/buffer_defs.h
index 15b964f5ed..c9d1efdd56 100644
--- a/src/nvim/buffer_defs.h
+++ b/src/nvim/buffer_defs.h
@@ -710,6 +710,7 @@ struct file_buffer {
   char_u *b_p_cfu;              ///< 'completefunc'
   char_u *b_p_ofu;              ///< 'omnifunc'
   char_u *b_p_tfu;              ///< 'tagfunc'
+  char_u *b_p_urf;              ///< 'userregfunc'
   int b_p_eol;                  ///< 'endofline'
   int b_p_fixeol;               ///< 'fixendofline'
   int b_p_et;                   ///< 'expandtab'
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index cb46e26f82..05497e86ce 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -3061,12 +3061,10 @@ static int eval7(char **arg, typval_T *rettv, int evaluate, int want_string)
   // Register contents: @r.
   case '@':
     (*arg)++;
+    int regname = mb_cptr2char_adv((const char_u**) arg);
     if (evaluate) {
       rettv->v_type = VAR_STRING;
-      rettv->vval.v_string = get_reg_contents(**arg, kGRegExprSrc);
-    }
-    if (**arg != NUL) {
-      (*arg)++;
+      rettv->vval.v_string = get_reg_contents(regname, kGRegExprSrc);
     }
     break;
 
@@ -4166,7 +4164,7 @@ bool garbage_collect(bool testing)
 
   // registers (ShaDa additional data)
   {
-    const void *reg_iter = NULL;
+    iter_register_T reg_iter = ITER_REGISTER_NULL;
     do {
       yankreg_T reg;
       char name = NUL;
@@ -4175,7 +4173,7 @@ bool garbage_collect(bool testing)
       if (name != NUL) {
         ABORTING(set_ref_dict)(reg.additional_data, copyID);
       }
-    } while (reg_iter != NULL);
+    } while (reg_iter != ITER_REGISTER_NULL);
   }
 
   // global marks (ShaDa additional data)
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index 9c3c859771..1e39042a53 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -3673,6 +3673,7 @@ static void f_has(typval_T *argvars, typval_T *rettv, FunPtr fptr)
     "winaltkeys",
     "writebackup",
     "nvim",
+    "userreg",
   };
 
   // XXX: eval_has_provider() may shell out :(
diff --git a/src/nvim/eval/vars.c b/src/nvim/eval/vars.c
index b38849730a..73e84a8c1e 100644
--- a/src/nvim/eval/vars.c
+++ b/src/nvim/eval/vars.c
@@ -388,7 +388,7 @@ const char *skip_var_list(const char *arg, int *var_count, int *semicolon)
 static const char *skip_var_one(const char *arg)
 {
   if (*arg == '@' && arg[1] != NUL) {
-    return arg + 2;
+    return arg + 1 + utfc_ptr2len(arg + 1);
   }
   return (char *)find_name_end(*arg == '$' || *arg == '&' ? arg + 1 : arg,
                                NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
@@ -692,10 +692,14 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
       return NULL;
     }
     arg++;
+
+    int regname = utf_ptr2char(arg);
+    int mblen = utf_ptr2len(arg);
+
     if (op != NULL && vim_strchr("+-*/%", *op) != NULL) {
       semsg(_(e_letwrong), op);
     } else if (endchars != NULL
-               && vim_strchr(endchars, *skipwhite(arg + 1)) == NULL) {
+               && vim_strchr(endchars, *skipwhite(arg + mblen)) == NULL) {
       emsg(_(e_letunexp));
     } else {
       char *s;
@@ -703,7 +707,7 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
       char *ptofree = NULL;
       const char *p = tv_get_string_chk(tv);
       if (p != NULL && op != NULL && *op == '.') {
-        s = get_reg_contents(*arg == '@' ? '"' : *arg, kGRegExprSrc);
+        s = get_reg_contents(*arg == '@' ? '"' : regname, kGRegExprSrc);
         if (s != NULL) {
           ptofree = (char *)concat_str((char_u *)s, (const char_u *)p);
           p = (const char *)ptofree;
@@ -711,9 +715,9 @@ static char *ex_let_one(char *arg, typval_T *const tv, const bool copy, const bo
         }
       }
       if (p != NULL) {
-        write_reg_contents(*arg == '@' ? '"' : *arg,
+        write_reg_contents(*arg == '@' ? '"' : regname,
                            (const char_u *)p, (ssize_t)STRLEN(p), false);
-        arg_end = arg + 1;
+        arg_end = arg + mblen;
       }
       xfree(ptofree);
     }
diff --git a/src/nvim/map.c b/src/nvim/map.c
index d3058a5d52..86e7317b56 100644
--- a/src/nvim/map.c
+++ b/src/nvim/map.c
@@ -163,6 +163,8 @@ static inline bool ColorKey_eq(ColorKey ae1, ColorKey ae2)
   return memcmp(&ae1, &ae2, sizeof(ae1)) == 0;
 }
 
+MAP_IMPL(ptr_t, int, DEFAULT_INITIALIZER)
+MAP_IMPL(int, ptr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(int, int, DEFAULT_INITIALIZER)
 MAP_IMPL(int, cstr_t, DEFAULT_INITIALIZER)
 MAP_IMPL(cstr_t, ptr_t, DEFAULT_INITIALIZER)
diff --git a/src/nvim/map.h b/src/nvim/map.h
index 845daac3f7..acc796bd98 100644
--- a/src/nvim/map.h
+++ b/src/nvim/map.h
@@ -35,6 +35,8 @@
 // NOTE: Keys AND values must be allocated! khash.h does not make a copy.
 //
 MAP_DECLS(int, int)
+MAP_DECLS(int, ptr_t)
+MAP_DECLS(ptr_t, int)
 MAP_DECLS(int, cstr_t)
 MAP_DECLS(cstr_t, ptr_t)
 MAP_DECLS(cstr_t, int)
diff --git a/src/nvim/ops.c b/src/nvim/ops.c
index 3be4536f16..889cc4f5bc 100644
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -21,6 +21,7 @@
 #include "nvim/edit.h"
 #include "nvim/eval.h"
 #include "nvim/eval/typval.h"
+#include "nvim/eval/userfunc.h"
 #include "nvim/ex_cmds.h"
 #include "nvim/ex_cmds2.h"
 #include "nvim/ex_getln.h"
@@ -55,8 +56,24 @@
 #include "nvim/undo.h"
 #include "nvim/vim.h"
 #include "nvim/window.h"
+#include "nvim/yankmap.h"
 
-static yankreg_T y_regs[NUM_REGISTERS] = { 0 };
+struct yank_registers {
+  yankmap_T inner;
+};
+
+yank_registers_T y_regs;
+
+static yankreg_T *get_reg(yank_registers_T *regs, int idx) 
+{
+  return yankmap_get(&regs->inner, idx);
+
+}
+
+static yankreg_T *get_global_reg(int idx)
+{
+  return get_reg(&y_regs, idx);
+}
 
 static yankreg_T *y_previous = NULL;  // ptr to last written yankreg
 
@@ -769,6 +786,24 @@ char_u *get_expr_line_src(void)
   return vim_strsave(expr_line);
 }
 
+
+int get_userreg(int regname)
+{
+  if ((regname >= 'a' && regname <= 'z')
+      || (regname >= 'A' && regname <= 'Z')
+      || (regname >= '0' && regname <= '9')
+      || (regname <= 127 && strchr("\"-:.%#=*+_/", regname))
+      || regname == Ctrl_F
+      || regname == Ctrl_P
+      || regname == Ctrl_W
+      || regname == Ctrl_A
+      || (regname + USER_REGISTERS_START) < regname) {
+    return -1;
+  }
+
+  return regname + USER_REGISTERS_START;
+}
+
 /// @return  whether `regname` is a valid name of a yank register.
 ///
 /// @note: There is no check for 0 (default register), caller should do this.
@@ -785,12 +820,152 @@ bool valid_yank_reg(int regname, bool writing)
       || regname == '-'
       || regname == '_'
       || regname == '*'
-      || regname == '+') {
+      || regname == '+'
+      || get_userreg(regname) != -1) {
     return true;
   }
   return false;
 }
 
+static int call_userreg_put(const char* urf, int regname, typval_T* out)
+{
+  char regname_str[5];
+  int len;
+
+  len = (*utf_char2len)(regname);
+  regname_str[len] = 0;
+  utf_char2bytes(regname, regname_str);
+
+  typval_T args[3];
+  args[0].v_type = VAR_STRING;
+  args[1].v_type = VAR_STRING;
+  args[2].v_type = VAR_NUMBER;
+
+  args[0].vval.v_string = "put";
+  args[1].vval.v_string = regname_str;
+  args[2].vval.v_number = 0;
+
+  funcexe_T funcexe = FUNCEXE_INIT;
+  funcexe.evaluate = true;
+
+  return call_func(
+        urf,
+        -1,
+        out,
+        /* argcount_in = */ 3,
+        args,
+        &funcexe);
+}
+
+// Converts a typval returned from the userregfunction to a register.
+static void typval_to_yankreg(yankreg_T* yankreg, typval_T* val)
+{
+  if (!yankreg || !val) return;
+
+  char* type;
+  dict_T* dict;
+  typval_T tv;
+  size_t i;
+  size_t sz;
+
+  free_register(yankreg);
+  memset(yankreg, 0, sizeof(*yankreg));
+
+  switch (val->v_type) {
+
+  case VAR_DICT:
+    dict = val->vval.v_dict;
+    type = tv_dict_get_string(dict, "type", false);
+
+    if (!strcmp(type, "block")) {
+      yankreg->y_width = (int) tv_dict_get_number(dict, "width");
+      yankreg->y_type = kMTBlockWise;
+    } else if (!strcmp(type, "line")) {
+      yankreg->y_type = kMTLineWise;
+    } else {
+      yankreg->y_type = kMTCharWise;
+    }
+
+    if (tv_dict_get_tv(dict, "lines", &tv) == OK) {
+      if (tv.v_type == VAR_STRING) {
+        yankreg->y_array = xcalloc(sizeof(char*), 1);
+        yankreg->y_array[0] = strdup(tv.vval.v_string);
+      } else if (tv.v_type == VAR_LIST) {
+        yankreg->y_array =
+          xcalloc(sizeof(char*), (size_t) tv_list_len(tv.vval.v_list));
+
+        i = 0;
+        TV_LIST_ITER_CONST(tv.vval.v_list, li, {
+          if (li->li_tv.v_type == VAR_STRING) {
+            yankreg->y_array[i] = strdup(tv_get_string(&li->li_tv));
+          } else {
+            yankreg->y_array[i] = NULL;
+          }
+          ++ i;
+        });
+
+        yankreg->y_size = i;
+      }
+    } else {
+      yankreg->y_array = NULL;
+    }
+
+    if (tv_dict_get_tv(dict, "additional_data", &tv) == OK) {
+      if (tv.v_type == VAR_DICT) {
+        yankreg->additional_data = tv.vval.v_dict;
+      }
+    }
+    break;
+
+  case VAR_LIST:
+    yankreg->y_type = kMTLineWise;
+    sz = (size_t) tv_list_len(val->vval.v_list);
+    yankreg->y_array = xcalloc(sizeof(char*), sz);
+    yankreg->y_size = sz;
+    i = 0;
+    TV_LIST_ITER_CONST(val->vval.v_list, li, {
+      yankreg->y_array[i] = strdup(tv_get_string(&li->li_tv));
+      i ++;
+    });
+    break;
+
+  default:
+    yankreg->y_type = kMTCharWise;
+    yankreg->y_size = 1;
+
+    if (val->vval.v_string) {
+      yankreg->y_array = xcalloc(sizeof(char*), 1);
+      yankreg->y_array[0] = strdup(tv_get_string(val));
+    } else {
+      yankreg->y_array = NULL;
+    }
+
+    break;
+
+  }
+
+  yankreg->timestamp = os_time();
+}
+
+static void copy_userreg(yankreg_T* into, int regname)
+{
+  if (!into) return;
+
+  if (!curbuf->b_p_urf || strlen((char *) curbuf->b_p_urf) == 0)
+    return;
+
+
+  typval_T* ret = xmalloc(sizeof(typval_T));
+
+  if (call_userreg_put((const char*) curbuf->b_p_urf, regname, ret) == FAIL) {
+    return;
+  }
+
+  typval_to_yankreg(into, ret);
+
+  tv_free(ret);
+}
+
 /// @return yankreg_T to use, according to the value of `regname`.
 /// Cannot handle the '_' (black hole) register.
 /// Must only be called with a valid register name!
@@ -828,7 +1003,11 @@ yankreg_T *get_yank_register(int regname, int mode)
   if (i == -1) {
     i = 0;
   }
-  reg = &y_regs[i];
+  reg = get_global_reg(i);
+  if (get_userreg(regname) != -1 && mode != YREG_YANK) {
+    // If the mode is not yank, copy the userreg data to the reg.
+    copy_userreg(reg, regname);
+  }
 
   if (mode == YREG_YANK) {
     // remember the written register for unnamed paste
@@ -897,8 +1076,7 @@ int do_record(int c)
 
   if (reg_recording == 0) {
     // start recording
-    // registers 0-9, a-z and " are allowed
-    if (c < 0 || (!ASCII_ISALNUM(c) && c != '"')) {
+    if (c < 0) {
       retval = FAIL;
     } else {
       reg_recording = c;
@@ -930,9 +1108,10 @@ int do_record(int c)
     }
 
     // Name of requested register, or empty string for unnamed operation.
-    char buf[NUMBUFLEN + 2];
-    buf[0] = (char)regname;
-    buf[1] = NUL;
+    char buf[NUMBUFLEN + 5];
+    int len = (*utf_char2len)(regname);
+    utf_char2bytes(regname, buf);
+    buf[len] = NUL;
     (void)tv_dict_add_str(dict, S_LEN("regname"), buf);
     tv_dict_set_keys_readonly(dict);
 
@@ -1013,6 +1192,9 @@ static int stuff_yank(int regname, char_u *p)
     reg->y_type = kMTCharWise;
   }
   reg->timestamp = os_time();
+  if (get_userreg(regname) != -1) {
+    return eval_yank_userreg(curbuf->b_p_urf, regname, reg);
+  }
   return OK;
 }
 
@@ -1339,6 +1521,79 @@ static void stuffescaped(const char *arg, bool literally)
   }
 }
 
+/// Converts a yankreg to a dict which can be used as an argument to the
+// userregfunc.
+static dict_T* yankreg_to_dict(yankreg_T* yankreg) {
+  dict_T *const dict = tv_dict_alloc();
+  dict->dv_refcount = 1;
+  tv_dict_add_nr(dict, S_LEN("width"), yankreg->y_width);
+
+  const char* type;
+
+  switch(yankreg->y_type) {
+    case kMTLineWise:
+      type = "line";
+      break;
+    case kMTCharWise:
+      type = "char";
+      break;
+    case kMTBlockWise:
+      type = "block";
+      break;
+    default:
+      type = "unknown";
+  }
+
+  tv_dict_add_str(dict, S_LEN("type"), type);
+  if (yankreg->additional_data) {
+    tv_dict_add_dict(dict, S_LEN("additional_data"), yankreg->additional_data);
+  }
+
+  list_T *const lines = tv_list_alloc(yankreg->y_size);
+
+  size_t i;
+  for (i = 0; i < yankreg->y_size; ++ i) {
+    tv_list_append_string(
+        lines, yankreg->y_array[i], strlen(yankreg->y_array[i]));
+  }
+
+  tv_dict_add_list(dict, S_LEN("lines"), lines);
+
+  return dict;
+}
+
+/*
+ * Executes the yank() function on a user-defined register to set the contents
+ * of that register.
+ */
+static int eval_yank_userreg(const char_u *ufn, int regname, yankreg_T *reg)
+{
+  if (!reg)
+    return -1;
+
+  int ret, len;
+  char regname_str[5];
+
+  len = (*utf_char2len)(regname);
+  regname_str[len] = 0;
+  utf_char2bytes(regname, regname_str);
+
+  typval_T args[4];
+  args[0].v_type = VAR_STRING;
+  args[1].v_type = VAR_STRING;
+  args[2].v_type = VAR_DICT;
+  args[3].v_type = VAR_UNKNOWN;
+
+  args[0].vval.v_string = "yank";
+  args[1].vval.v_string = regname_str;
+  args[2].vval.v_dict = yankreg_to_dict(reg);
+
+  char *dup_ufn = strdup((char *)ufn);
+  ret = (int)call_func_retnr(dup_ufn, 3, args);
+  xfree(dup_ufn);
+  return ret;
+}
+
 /// If "regname" is a special register, return true and store a pointer to its
 /// value in "argp".
 ///
@@ -1425,6 +1680,9 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
   case '_':                     // black hole: always empty
     *argp = "";
     return true;
+
+  default:
+    break;
   }
 
   return false;
@@ -1471,14 +1729,14 @@ bool cmdline_paste_reg(int regname, bool literally_arg, bool remcr)
 /// Shift the delete registers: "9 is cleared, "8 becomes "9, etc.
 static void shift_delete_registers(bool y_append)
 {
-  free_register(&y_regs[9]);  // free register "9
+  free_register(get_global_reg(9));  // free register "9
   for (int n = 9; n > 1; n--) {
-    y_regs[n] = y_regs[n - 1];
+    *get_global_reg(n) = *get_global_reg(n - 1);
   }
   if (!y_append) {
-    y_previous = &y_regs[1];
+    y_previous = get_global_reg(1);
   }
-  y_regs[1].y_array = NULL;  // set register "1 to empty
+  get_global_reg(1)->y_array = NULL;  // set register "1 to empty
 }
 
 /// Handle a delete operation.
@@ -1579,7 +1837,7 @@ int op_delete(oparg_T *oap)
     // 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];
+      reg = get_global_reg(1);
       op_yank_reg(oap, false, reg, false);
       did_yank = true;
     }
@@ -2584,13 +2842,22 @@ int op_change(oparg_T *oap)
   return retval;
 }
 
+
+/*
+ * set all the yank registers to empty (called from main())
+ */
+void init_yank(void)
+{
+  init_yankmap(&y_regs.inner);
+}
+
 #if defined(EXITFREE)
 void clear_registers(void)
 {
   int i;
 
   for (i = 0; i < NUM_REGISTERS; i++) {
-    free_register(&y_regs[i]);
+    free_register(get_global_reg(i));
   }
 }
 
@@ -2634,6 +2901,14 @@ bool op_yank(oparg_T *oap, bool message)
 
   yankreg_T *reg = get_yank_register(oap->regname, YREG_YANK);
   op_yank_reg(oap, message, reg, is_append_register(oap->regname));
+
+  if (get_userreg(oap->regname) != -1) {
+    if (eval_yank_userreg(curbuf->b_p_urf, oap->regname, reg) == -1) {
+      beep_flush();
+      return false;
+    }
+  }
+
   set_clipboard(oap->regname, reg);
   do_autocmd_textyankpost(oap, reg);
 
@@ -2815,7 +3090,11 @@ static void op_yank_reg(oparg_T *oap, bool message, yankreg_T *reg, bool append)
       if (oap->regname == NUL) {
         *namebuf = NUL;
       } else {
-        vim_snprintf(namebuf, sizeof(namebuf), _(" into \"%c"), oap->regname);
+        char buf[5];
+        int len = (*utf_char2len) (oap->regname);
+        utf_char2bytes(oap->regname, buf);
+        buf[len] = 0;
+        vim_snprintf(namebuf, sizeof(namebuf), _(" into \"%s"), buf);
       }
 
       // redisplay now, so message is not deleted
@@ -2882,6 +3161,7 @@ static void do_autocmd_textyankpost(oparg_T *oap, yankreg_T *reg)
   FUNC_ATTR_NONNULL_ALL
 {
   static bool recursive = false;
+  int len;
 
   if (recursive || !has_event(EVENT_TEXTYANKPOST)) {
     // No autocommand was defined, or we yanked from this autocommand.
@@ -2903,13 +3183,15 @@ static void do_autocmd_textyankpost(oparg_T *oap, yankreg_T *reg)
   (void)tv_dict_add_list(dict, S_LEN("regcontents"), list);
 
   // Register type.
-  char buf[NUMBUFLEN + 2];
+  char buf[NUMBUFLEN + 6];
   format_reg_type(reg->y_type, reg->y_width, buf, ARRAY_SIZE(buf));
   (void)tv_dict_add_str(dict, S_LEN("regtype"), buf);
 
   // Name of requested register, or empty string for unnamed operation.
-  buf[0] = (char)oap->regname;
-  buf[1] = NUL;
+  len = (*utf_char2len)(oap->regname);
+  buf[len] = 0;
+  utf_char2bytes(oap->regname, buf);
+  recursive = true;
   (void)tv_dict_add_str(dict, S_LEN("regname"), buf);
 
   // Motion type: inclusive or exclusive.
@@ -3128,6 +3410,10 @@ void do_put(int regname, yankreg_T *reg, int dir, long count, int flags)
       reg = get_yank_register(regname, YREG_PASTE);
     }
 
+    if (get_userreg(regname) != -1)  {
+      copy_userreg(reg, regname);
+    }
+
     y_type = reg->y_type;
     y_width = reg->y_width;
     y_size = reg->y_size;
@@ -3780,7 +4066,7 @@ int get_register_name(int num)
 /// @return the index of the register "" points to.
 int get_unname_register(void)
 {
-  return y_previous == NULL ? -1 : (int)(y_previous - &y_regs[0]);
+  return yankmap_find(&y_regs.inner, y_previous);
 }
 
 /// ":dis" and ":registers": Display the contents of the yank registers.
@@ -3819,10 +4105,10 @@ void ex_display(exarg_T *eap)
       if (y_previous != NULL) {
         yb = y_previous;
       } else {
-        yb = &(y_regs[0]);
+        yb = get_global_reg(0);
       }
     } else {
-      yb = &(y_regs[i]);
+      yb = get_global_reg(i);
     }
 
     get_clipboard(name, &yb, true);
@@ -5536,6 +5822,10 @@ static yankreg_T *init_write_reg(int name, yankreg_T **old_y_previous, bool must
 
 static void finish_write_reg(int name, yankreg_T *reg, yankreg_T *old_y_previous)
 {
+  if (get_userreg(name) != -1) {
+    eval_yank_userreg(curbuf->b_p_urf, name, reg);
+  }
+
   // Send text of clipboard register to the clipboard.
   set_clipboard(name, reg);
 
@@ -6962,7 +7252,7 @@ static yankreg_T *adjust_clipboard_name(int *name, bool quiet, bool writing)
   }
 
   if (explicit_cb_reg) {
-    target = &y_regs[*name == '*' ? STAR_REGISTER : PLUS_REGISTER];
+    target = get_global_reg(*name == '*' ? STAR_REGISTER : PLUS_REGISTER);
     if (writing && (cb_flags & (*name == '*' ? CB_UNNAMED : CB_UNNAMEDPLUS))) {
       clipboard_needs_update = false;
     }
@@ -6979,10 +7269,10 @@ static yankreg_T *adjust_clipboard_name(int *name, bool quiet, bool writing)
 
     if (cb_flags & CB_UNNAMEDPLUS) {
       *name = (cb_flags & CB_UNNAMED && writing) ? '"': '+';
-      target = &y_regs[PLUS_REGISTER];
+      target = get_global_reg(PLUS_REGISTER);
     } else {
       *name = '*';
-      target = &y_regs[STAR_REGISTER];
+      target = get_global_reg(STAR_REGISTER);
     }
     goto end;
   }
@@ -7298,11 +7588,11 @@ static inline bool reg_empty(const yankreg_T *const reg)
 /// Iterate over global registers.
 ///
 /// @see op_register_iter
-const void *op_global_reg_iter(const void *const iter, char *const name, yankreg_T *const reg,
-                               bool *is_unnamed)
+iter_register_T op_global_reg_iter(iter_register_T iter, char *const name,
+                               yankreg_T *const reg, bool *is_unnamed)
   FUNC_ATTR_NONNULL_ARG(2, 3, 4) FUNC_ATTR_WARN_UNUSED_RESULT
 {
-  return op_reg_iter(iter, y_regs, name, reg, is_unnamed);
+  return op_reg_iter(iter, &y_regs, name, reg, is_unnamed);
 }
 
 /// Iterate over registers `regs`.
@@ -7314,30 +7604,31 @@ const void *op_global_reg_iter(const void *const iter, char *const name, yankreg
 ///
 /// @return Pointer that must be passed to next `op_register_iter` call or
 ///         NULL if iteration is over.
-const void *op_reg_iter(const void *const iter, const yankreg_T *const regs, char *const name,
-                        yankreg_T *const reg, bool *is_unnamed)
+iter_register_T op_reg_iter(iter_register_T iter, yank_registers_T *regs,
+                        char *const name, yankreg_T *const reg,
+                        bool *is_unnamed)
   FUNC_ATTR_NONNULL_ARG(3, 4, 5) FUNC_ATTR_WARN_UNUSED_RESULT
 {
   *name = NUL;
-  const yankreg_T *iter_reg = (iter == NULL
-                               ? &(regs[0])
-                               : (const yankreg_T *const)iter);
-  while (iter_reg - &(regs[0]) < NUM_SAVED_REGISTERS && reg_empty(iter_reg)) {
-    iter_reg++;
-  }
-  if (iter_reg - &(regs[0]) == NUM_SAVED_REGISTERS || reg_empty(iter_reg)) {
-    return NULL;
-  }
-  int iter_off = (int)(iter_reg - &(regs[0]));
-  *name = (char)get_register_name(iter_off);
-  *reg = *iter_reg;
-  *is_unnamed = (iter_reg == y_previous);
-  while (++iter_reg - &(regs[0]) < NUM_SAVED_REGISTERS) {
-    if (!reg_empty(iter_reg)) {
-      return (void *)iter_reg;
+  int iter_idx = (int)(iter == ITER_REGISTER_NULL ? 0 : iter - 1);
+
+  while (iter_idx < NUM_SAVED_REGISTERS && reg_empty(get_reg(regs, iter_idx)))
+    ++iter_idx;
+
+  if (iter_idx >= NUM_SAVED_REGISTERS || reg_empty(get_reg(regs, iter_idx)))
+    return ITER_REGISTER_NULL;
+
+  *reg = *get_reg(regs, iter_idx);
+  *name = (char)get_register_name((int)iter_idx);
+  *is_unnamed = (get_reg(regs, iter_idx) == y_previous);
+
+  while (++iter_idx < NUM_SAVED_REGISTERS) {
+    if (!reg_empty(get_reg(regs, iter_idx))) {
+      return (iter_register_T)(iter_idx + 1);
     }
   }
-  return NULL;
+
+  return ITER_REGISTER_NULL;
 }
 
 /// Get a number of non-empty registers
@@ -7345,8 +7636,8 @@ size_t op_reg_amount(void)
   FUNC_ATTR_WARN_UNUSED_RESULT
 {
   size_t ret = 0;
-  for (size_t i = 0; i < NUM_SAVED_REGISTERS; i++) {
-    if (!reg_empty(y_regs + i)) {
+  for (int i = 0; i < NUM_SAVED_REGISTERS; i++) {
+    if (!reg_empty(get_global_reg(i))) {
       ret++;
     }
   }
@@ -7366,11 +7657,11 @@ bool op_reg_set(const char name, const yankreg_T reg, bool is_unnamed)
   if (i == -1) {
     return false;
   }
-  free_register(&y_regs[i]);
-  y_regs[i] = reg;
+  free_register(get_global_reg(i));
+  *get_global_reg(i) = reg;
 
   if (is_unnamed) {
-    y_previous = &y_regs[i];
+    y_previous = get_global_reg(i);
   }
   return true;
 }
@@ -7386,7 +7677,7 @@ const yankreg_T *op_reg_get(const char name)
   if (i == -1) {
     return NULL;
   }
-  return &y_regs[i];
+  return get_global_reg(i);
 }
 
 /// Set the previous yank register
@@ -7401,7 +7692,7 @@ bool op_reg_set_previous(const char name)
     return false;
   }
 
-  y_previous = &y_regs[i];
+  y_previous = get_global_reg(i);
   return true;
 }
 
diff --git a/src/nvim/ops.h b/src/nvim/ops.h
index 05893c9940..a456d68003 100644
--- a/src/nvim/ops.h
+++ b/src/nvim/ops.h
@@ -22,6 +22,7 @@ typedef int (*Indenter)(void);
 #define PUT_LINE_SPLIT   16     // split line for linewise register
 #define PUT_LINE_FORWARD 32     // put linewise register below Visual sel.
 #define PUT_BLOCK_INNER  64     // in block mode, do not add trailing spaces
+#define ITER_REGISTER_NULL 0
 
 /*
  * Registers:
@@ -37,7 +38,8 @@ typedef int (*Indenter)(void);
 // The following registers should not be saved in ShaDa file:
 #define STAR_REGISTER 37
 #define PLUS_REGISTER 38
-#define NUM_REGISTERS 39
+#define USER_REGISTERS_START 39
+#define NUM_REGISTERS USER_REGISTERS_START
 
 // Operator IDs; The order must correspond to opchars[] in ops.c!
 #define OP_NOP          0       // no pending operation
@@ -96,6 +98,8 @@ typedef enum {
   YREG_YANK,
   YREG_PUT,
 } yreg_mode_t;
+/// Returns a reference to a user-defined register.
+int get_userreg(const int regname);
 
 /// Convert register name into register index
 ///
@@ -118,10 +122,15 @@ static inline int op_reg_index(const int regname)
   } else if (regname == '+') {
     return PLUS_REGISTER;
   } else {
-    return -1;
+    return get_userreg(regname);
   }
 }
 
+struct yank_registers;
+typedef struct yank_registers yank_registers_T;
+
+typedef size_t iter_register_T;
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "ops.h.generated.h"
 #endif
diff --git a/src/nvim/option.c b/src/nvim/option.c
index 5c487a7c62..cb2da3c57d 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -4094,6 +4094,8 @@ static char_u *get_varp(vimoption_T *p)
     return (char_u *)&(curbuf->b_p_cfu);
   case PV_OFU:
     return (char_u *)&(curbuf->b_p_ofu);
+  case PV_URF:
+    return (char_u *)&(curbuf->b_p_urf);
   case PV_EOL:
     return (char_u *)&(curbuf->b_p_eol);
   case PV_FIXEOL:
@@ -4503,6 +4505,8 @@ void buf_copy_options(buf_T *buf, int flags)
       COPY_OPT_SCTX(buf, BV_CFU);
       buf->b_p_ofu = vim_strsave(p_ofu);
       COPY_OPT_SCTX(buf, BV_OFU);
+      buf->b_p_urf = vim_strsave(p_urf);
+      COPY_OPT_SCTX(buf, BV_URF);
       buf->b_p_tfu = vim_strsave(p_tfu);
       COPY_OPT_SCTX(buf, BV_TFU);
       buf->b_p_sts = p_sts;
diff --git a/src/nvim/option_defs.h b/src/nvim/option_defs.h
index ad8092add2..af2383d91d 100644
--- a/src/nvim/option_defs.h
+++ b/src/nvim/option_defs.h
@@ -825,6 +825,7 @@ EXTERN int p_wa;                // 'writeany'
 EXTERN int p_wb;                // 'writebackup'
 EXTERN long p_wd;               // 'writedelay'
 EXTERN int p_cdh;               // 'cdhome'
+EXTERN char_u *p_urf;           // 'userregister'
 
 EXTERN int p_force_on;          ///< options that cannot be turned off.
 EXTERN int p_force_off;         ///< options that cannot be turned on.
@@ -921,6 +922,7 @@ enum {
   BV_WM,
   BV_VSTS,
   BV_VTS,
+  BV_URF,
   BV_COUNT,  // must be the last one
 };
 
diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index 2f941f5d0c..89de495d7a 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -2691,6 +2691,15 @@ return {
       defaults={if_true=4000}
     },
     {
+      full_name='userregfunc', abbreviation='urf',
+      type='string', scope={'buffer'},
+      secure=true,
+      vi_def=true,
+      alloced=true,
+      varname='p_urf',
+      defaults={if_true=""}
+    },
+    {
       full_name='varsofttabstop', abbreviation='vsts',
       short_desc=N_("list of numbers of spaces that <Tab> uses while editing"),
       type='string', list='comma', scope={'buffer'},
diff --git a/src/nvim/po/da.po b/src/nvim/po/da.po
index dfcc052288..f2b28ccc90 100644
--- a/src/nvim/po/da.po
+++ b/src/nvim/po/da.po
@@ -4142,7 +4142,7 @@ msgid "freeing %ld lines"
 msgstr "frigør %ld linjer"
 
 #, c-format
-msgid " into \"%c"
+msgid " into \"%s"
 msgstr " i \"%c"
 
 #, c-format
diff --git a/src/nvim/po/fr.po b/src/nvim/po/fr.po
index 614ba013e6..239d6da211 100644
--- a/src/nvim/po/fr.po
+++ b/src/nvim/po/fr.po
@@ -4410,7 +4410,7 @@ msgid "freeing %ld lines"
 msgstr "lib�ration de %ld lignes"
 
 #, c-format
-msgid " into \"%c"
+msgid " into \"%s"
 msgstr " dans \"%c"
 
 #, c-format
diff --git a/src/nvim/po/tr.po b/src/nvim/po/tr.po
index fae2fd4967..d534666bbb 100644
--- a/src/nvim/po/tr.po
+++ b/src/nvim/po/tr.po
@@ -4149,7 +4149,7 @@ msgid "E748: No previously used register"
 msgstr "E748: Daha önce kullanılan bir yazmaç yok"
 
 #, c-format
-msgid " into \"%c"
+msgid " into \"%s"
 msgstr " \"%c"
 
 #, c-format
diff --git a/src/nvim/po/uk.po b/src/nvim/po/uk.po
index da87d50683..1b514ad7c3 100644
--- a/src/nvim/po/uk.po
+++ b/src/nvim/po/uk.po
@@ -4132,7 +4132,7 @@ msgid "E748: No previously used register"
 msgstr "E748: Регістри перед цим не вживались"
 
 #, c-format
-msgid " into \"%c"
+msgid " into \"%s"
 msgstr " у \"%c"
 
 #, c-format
diff --git a/src/nvim/shada.c b/src/nvim/shada.c
index daa8e99d31..0927473be0 100644
--- a/src/nvim/shada.c
+++ b/src/nvim/shada.c
@@ -2378,7 +2378,7 @@ static inline void add_search_pattern(PossiblyFreedShadaEntry *const ret_pse,
 static inline void shada_initialize_registers(WriteMergerState *const wms, int max_reg_lines)
   FUNC_ATTR_NONNULL_ALL FUNC_ATTR_ALWAYS_INLINE
 {
-  const void *reg_iter = NULL;
+  iter_register_T reg_iter = ITER_REGISTER_NULL;
   const bool limit_reg_lines = max_reg_lines >= 0;
   do {
     yankreg_T reg;
@@ -2409,7 +2409,7 @@ static inline void shada_initialize_registers(WriteMergerState *const wms, int m
         }
       }
     };
-  } while (reg_iter != NULL);
+  } while (reg_iter != ITER_REGISTER_NULL);
 }
 
 /// Replace numbered mark in WriteMergerState
diff --git a/src/nvim/yankmap.c b/src/nvim/yankmap.c
new file mode 100644
index 0000000000..d9229e015d
--- /dev/null
+++ b/src/nvim/yankmap.c
@@ -0,0 +1,42 @@
+#include "nvim/yankmap.h"
+
+#include "nvim/memory.h"
+
+void init_yankmap(yankmap_T* map)
+{
+  memset(map, 0, sizeof(yankmap_T));
+
+  map_init(int, ptr_t, &map->reg_to_yankreg);
+  map_init(ptr_t, int, &map->yankreg_to_reg);
+}
+
+yankreg_T* yankmap_get(yankmap_T* yankmap, int reg)
+{
+  yankreg_T** ret =
+    (yankreg_T**) map_ref(int, ptr_t)(&yankmap->reg_to_yankreg, reg, true);
+
+  if (ret) {
+    if (! (*ret)) {
+      *ret = xcalloc(sizeof(yankreg_T), 1);
+    }
+
+    /* Add the back-reference */
+    int* ref = map_ref(ptr_t, int)(&yankmap->yankreg_to_reg, *ret, true);
+    *ref = reg;
+
+    return *ret;
+  }
+
+  return NULL;
+}
+
+int yankmap_find(yankmap_T* yankmap, yankreg_T* yankreg)
+{
+  int* ref = map_ref(ptr_t, int)(&yankmap->yankreg_to_reg, yankreg, false);
+
+  if (ref) {
+    return *ref;
+  }
+
+  return -1;
+}
diff --git a/src/nvim/yankmap.h b/src/nvim/yankmap.h
new file mode 100644
index 0000000000..da7c4dcf13
--- /dev/null
+++ b/src/nvim/yankmap.h
@@ -0,0 +1,24 @@
+#ifndef YANK_TRIE_H_
+#define YANK_TRIE_H_
+
+#include <stdbool.h>
+#include "nvim/ops.h"
+#include "nvim/map.h"
+
+typedef struct {
+  /* Register name to yank register. */
+  Map(int, ptr_t) reg_to_yankreg;
+
+  /* Yank register to register name. */
+  Map(ptr_t, int) yankreg_to_reg;
+} yankmap_T;
+
+void init_yankmap(yankmap_T* yankmap);
+
+yankreg_T* yankmap_get(yankmap_T* yankmap, int index);
+
+yankreg_T* yankmap_put(yankmap_T* yankmap, int index);
+
+int yankmap_find(yankmap_T* yankmap, yankreg_T* yankreg);
+
+#endif