feat(userregfunc): programmable user-defined registers with multibyte support

This patch introduces a new global option `userregfunc`, allowing users
to define custom behavior for registers not handled by Neovim
internally. This enables programmable registers using any Unicode
character — including multibyte characters.

- A new register slot `USER_REGISTER` is introduced. Any register not
  matching the standard set (`0-9a-zA-Z"+-*%#/:.=`, etc.) is routed
  through this system.

- When such a register is accessed, the function defined in
  `userregfunc` is called with three arguments:

    1. `{action}` (string): either `"yank"` or `"put"`
    2. `{register}` (string): UTF-8 character name of the register
    3. `{content}`:
       - If `action == "yank"`: a dictionary with these keys:
         - `lines` (list of strings): the yanked text
         - `type` (string): one of `"v"` (charwise), `"V"` (linewise), or `"b"` (blockwise)
         - `width` (number, optional): present if `type == "b"`
         - `additional_data` (dict, optional): user-extensible metadata
       - If `action == "put"`: this is always `v:null`

- The function may return either:
    - A **string** (used as a charwise register), or
    - A **dictionary** matching the structure above

- Internally, `read_userregister()` and `write_userregister()` convert
  between `yankreg_T` and typval dictionaries.

- Messages and internal logic fully support multibyte register names via
  UTF-8.

- A new `USER_REGISTER` slot is used for logical separation in the
  register table.

Included in this patch is an extensible Lua framework (`vim.userregs`)
for defining user register handlers in Lua. It provides per-register
handlers via `register_handler(registers, handler)`

The global function `_G.def_userreg_func` is registered as the default
implementation of `'userregfunc'`, enabling seamless integration with
the Lua framework.

- Register `λ` dynamically inserts the current date
- Register `&` reads and writes from a "global register" file under
  `stdpath("run")`
- Register `?` returns the result of a shell command
- Registers that auto-adjust based on filetype, cursor context, or
  Treesitter nodes

This change expands the register model into a programmable abstraction —
fully scriptable and extensible — without breaking compatibility.

1 files changed, 59 insertions, 2 deletions

diff --git a/src/nvim/options.lua b/src/nvim/options.lua
index e687490704..1cb0a65bea 100644
--- a/src/nvim/options.lua
+++ b/src/nvim/options.lua
@@ -9678,6 +9678,63 @@ local options = {
       varname = 'p_ur',
     },
     {
+      abbreviation = 'urf',
+      defaults = '',
+      cb = 'did_set_userregfunc',
+      desc = [=[
+      Specifies a function to handle any registers that Neovim does not natively
+      handle. This allows the user to use all characters, including multi-byte ones,
+      as custom register names.
+
+      The function is called whenever a user-defined register is accessed — either
+      when yanking to it ("yank") or putting from it ("put").
+
+      The function must have the following signature:
+
+              function({action}, {register}, {content})
+
+      Parameters:
+              {action} string	"yank" or "put"
+                    "yank" is called when text is yanked into the register.
+                    "put" is called when the register is used for insertion.
+
+              {register} string	A single-character register name. Can be multibyte.
+
+              {content} dict	Only present when {action} is "yank". Contains:
+                     {lines}: list of strings representing the yanked text
+                     {type}:  "char", "line", or "block"
+                     {width}: (optional) present if type is "block"
+                     {additional_data}: (optional) arbitrary user data
+
+      Return value (for "put"):
+      - A string (for "char" mode), or
+      - A dictionary with the same structure as {content}.
+
+      Example (VimL):>vim
+
+	let s:contents = {}
+
+	function! MyUserregFunction(action, register, content) abort
+          if a:register == '?' && a:action ==# 'put' then
+            return strftime("YYYY-MM-DD")
+          end
+	  if a:action ==# 'put'
+	    return get(s:contents, a:register, '')
+	  elseif a:action ==# 'yank'
+	    let s:contents[a:register] = a:content
+	  endif
+	endfunction
+
+	set userregfunc=MyUserregFunction
+      <
+      ]=],
+      full_name = 'userregfunc',
+      scope = { 'global' },
+      short_desc = N_('Dynamically generate register content via VimL functions'),
+      type = 'string',
+      varname = 'p_urf',
+    },
+    {
       abbreviation = 'uc',
       cb = 'did_set_updatecount',
       defaults = 200,
@@ -10642,13 +10699,13 @@ local function preprocess(o)
 
   if type(o.alias) == 'string' then
     o.alias = {
-      o.alias --[[@as string]],
+      o.alias --[[@as string]] ,
     }
   end
 
   if type(o.defaults) ~= 'table' then
     o.defaults = {
-      if_true = o.defaults --[[@as string|boolean|number ]],
+      if_true = o.defaults --[[@as string|boolean|number ]] ,
     }
   end
 end