path: root/src/nvim/extreg.c

// Extended Register (Extregister) System
// Allows Lua callbacks to intercept yank and put operations for custom storage backends

#include "nvim/extreg.h"

#include "nvim/ascii_defs.h"
#include "nvim/errors.h"
#include "nvim/eval/typval.h"
#include "nvim/eval/typval_defs.h"
#include "nvim/ex_getln.h"
#include "nvim/globals.h"
#include "nvim/hashtab.h"
#include "nvim/lua/converter.h"
#include "nvim/lua/executor.h"
#include "nvim/mbyte.h"
#include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/ops.h"
#include "nvim/os/time.h"
#include "nvim/register.h"
#include "nvim/strings.h"
#include "nvim/types_defs.h"

#include "extreg.c.generated.h"

// Global storage maps
hashtab_T extreg_providers = { 0 };  ///< name (string) -> provider_index (number)
dict_T extreg_aliases = { 0 };    ///< alias (1-char string) -> provider_name (string)

// Global state for dynamic register
extreg_provider_t *active_extreg = NULL;  ///< Currently selected extreg provider

// Check if alias character is valid for binding
static bool is_valid_alias(int codepoint)
{
  if (codepoint <= 0) {
    return false;  // Invalid codepoint
  }
  
  // Reject all control characters (C0: 0x00-0x1F, DEL: 0x7F, C1: 0x80-0x9F)
  if (codepoint <= 0x1F || (codepoint >= 0x7F && codepoint <= 0x9F)) {
    return false;
  }
  
  // For ASCII printable (0x20-0x7E), validate against special characters
  if (codepoint <= 127) {
    const char *invalid = "=_#%./:;+";
    return vim_strchr(invalid, (char)codepoint) == NULL && !ascii_isdigit(codepoint)
           && (codepoint < 'A' || codepoint > 'Z') && (codepoint < 'a' || codepoint > 'z')
           && codepoint != ' ';  // Reject space explicitly
  }
  
  // For non-ASCII Unicode codepoints, allow anything in valid Unicode range
  // except private use areas and surrogates
  if (codepoint > 0x10FFFF) {
    return false;  // Invalid Unicode
  }
  // Reject private use areas
  if ((codepoint >= 0xE000 && codepoint <= 0xF8FF) ||      // PUA
      (codepoint >= 0xF0000 && codepoint <= 0xFFFFD) ||    // Supplementary PUA
      (codepoint >= 0x100000 && codepoint <= 0x10FFFD)) {  // Supplementary PUA
    return false;
  }
  // Reject surrogates
  if (codepoint >= 0xD800 && codepoint <= 0xDFFF) {
    return false;
  }
  return true;
}

// Global state flag
static bool extreg_initialized = false;

// Initialize extregister system
void extreg_init(void)
{
  if (extreg_initialized) {
    return;  // Already initialized
  }

  hash_init(&extreg_providers);
  hash_init(&extreg_aliases.dv_hashtab);
  extreg_initialized = true;
}

// Clear all extregisters (used on exit or reset)
void extreg_clear_all(void)
{
  hash_lock(&extreg_providers);

  HASHTAB_ITER(&extreg_providers, hi, {
    extreg_free_provider(HASH_ITEM_TO_EXTREG_PROVIDER(hi));
    hash_remove(&extreg_providers, hi);
  });

  hash_clear(&extreg_providers);
  hash_unlock(&extreg_providers);
}

/// Prompt user to select an extregister provider
/// @return '~' if successful, NUL if cancelled or error
int get_extreg_register(void)
{
  char *provider_name = getcmdline('~', 0, 0, true);
  if (provider_name == NULL) {
    active_extreg = NULL;
    return NUL;  // User cancelled with <Esc>
  }
  if (*provider_name == NUL) {
    xfree(provider_name);
    return '~';  // Use previously selected provider
  }
  active_extreg = extreg_get_provider(provider_name);
  xfree(provider_name);
  if (active_extreg == NULL) {
    semsg(_("E356: Unknown extregister name"));
    return NUL;
  }
  return '~';  // Use extreg register
}

int get_alias_register(int alias)
{
  extreg_provider_t *prov = extreg_get_provider_for_alias(alias);
  
  if (prov) {
    active_extreg = prov;
    return '~';
  }
  
  // Not an extreg alias - clear any stale active_extreg state
  active_extreg = NULL;
  return alias;
}

int get_extreg_or_alias_register(int reg)
{
  if (reg == '~') {
    return get_extreg_register();
  } else {
    return get_alias_register(reg);
  }
}

/// Register a new extregister provider
/// @param name Unique provider name
/// @param text_yanked_cb Lua callback for yank operations (LUA_NOREF if not provided)
/// @param text_put_cb Lua callback for put operations (LUA_NOREF if not provided)
/// @return true on success, false on failure
int extreg_register(const char *name, LuaRef text_yanked_cb, LuaRef text_put_cb)
{
  assert(name != NULL);

  if (strlen(name) > 256) {
    semsg(_("E356: extregister name is too long")); // Stop nasty things from happening. with
                                                    // absurdly long register names.
    return 0;
  }

  hash_lock(&extreg_providers);

  // Check if provider already exists
  hashitem_T *hi = hash_find(&extreg_providers, name);
  if (!HASHITEM_EMPTY(hi)) {
    hash_unlock(&extreg_providers);
    semsg(_("E356: Already have an extregister named '%s'"), name);
    return 0;
  }

  extreg_provider_t* prov = xcalloc(1, sizeof(*prov) + strlen(name) + 1);
  prov->text_yanked_cb = text_yanked_cb;
  prov->text_put_cb = text_put_cb;
  prov->registered = true;
  prov->recursion_id = 0;
  strcpy(prov->name, name);
  CLEAR_POINTER(&prov->yreg);

  // Add to hash table
  hash_add(&extreg_providers, prov->name);

  hash_unlock(&extreg_providers);

  return 1;
}

/// Parse provider name from ~provider syntax
///
/// Extracts provider name from string starting with '~'.
/// Returns the provider name as an allocated string (caller must free).
/// Advances input pointer past the provider name.
///
/// @param[in]  in_arg  Input string starting with '~provider ...'
/// @param[out] out     Output: pointer to char after provider name
/// @return Allocated provider name string, or NULL on error (empty/invalid name)
char *extreg_parse_provider(char *in_arg, char **out)
  FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_NONNULL_ARG(2) FUNC_ATTR_WARN_UNUSED_RESULT
{
  assert(*in_arg == '~');

  *out = in_arg + 1;

  // Must have something after '~'
  if (in_arg[1] == NUL) {
    return NULL;
  }

  // Allocate buffer for provider name
  size_t buf_size = 16;  // Start with small buffer
  char *buf = xmalloc(buf_size);
  size_t buf_i = 0;

  // Parse provider name: allow [A-Za-z0-9._]
  char *p = in_arg + 1;
  while (*p && (ASCII_ISALNUM(*p) || *p == '.' || *p == '_')) {
    // Expand buffer if needed
    if (buf_i >= buf_size - 1) {
      buf_size *= 2;
      buf = xrealloc(buf, buf_size);
    }
    buf[buf_i++] = *p;
    p++;
  }
  buf[buf_i] = NUL;

  // Must have at least one valid character
  if (buf_i == 0) {
    xfree(buf);
    return NULL;
  }

  *out = p;
  return buf;  // Caller must free
}

/// Unregister an extregister provider
/// @param name Provider name to unregister
/// @return true on success, false if not found
int extreg_unregister(const char *name)
{
  hash_lock(&extreg_providers);

  hashitem_T *hi = hash_find(&extreg_providers, name);
  if (HASHITEM_EMPTY(hi)) {
    hash_unlock(&extreg_providers);
    return false;
  }
  extreg_provider_t *prov = HASH_ITEM_TO_EXTREG_PROVIDER(hi);
  hash_remove(&extreg_providers, hi);

  hash_unlock(&extreg_providers);

  extreg_free_provider(prov);

  return true;
}

void extreg_free_provider(extreg_provider_t* prov)
{
  if (active_extreg == prov) {
    active_extreg = NULL;
  }
  // Free Lua callbacks
  nlua_unref_global(get_global_lstate(), prov->text_yanked_cb);
  nlua_unref_global(get_global_lstate(), prov->text_put_cb);

  free_register(&prov->yreg);
  xfree(prov);
}

/// Bind a character to an extregister provider
/// @param alias_codepoint Codepoint to bind
/// @param provider_name Name of provider to bind to
/// @return true on success, false on failure
int extreg_bind(int alias_codepoint, const char *provider_name)
{
  char utf8_buf[MB_MAXBYTES + 1];
  int utf8_len = utf_char2bytes(alias_codepoint, utf8_buf);
  utf8_buf[utf8_len] = NUL;

  if (!is_valid_alias(alias_codepoint)) {
    semsg(_("E356: '%s' cannot be used as an extregister alias"), utf8_buf);
    return false;
  }

  // Reject empty provider names
  if (!provider_name || *provider_name == NUL) {
    semsg(_("E356: provider name cannot be empty"));
    return false;
  }

  // Don't allow overriding bindings. Must explicitly unbind()
  dictitem_T *di = tv_dict_find(&extreg_aliases, utf8_buf, (ptrdiff_t)utf8_len);
  if (di != NULL) {
    semsg(_("E356: alias '%s' already bound."), utf8_buf);
    return false;
  }

  di = tv_dict_item_alloc_len(utf8_buf, (size_t)utf8_len);
  di->di_tv.v_type = VAR_STRING;
  di->di_tv.vval.v_string =