EMACS: ¿Cómo arrancar el último texto tirado independientemente de los asesinatos posteriores?

Question

A menudo me encuentro repetidamente tirando algo después de hacer algunos asesinatos y se convierte en un proceso como:

1. Cy
2. Cy mi
3. Cy mi mi
4. Cy mi mi mi

Cada vez que mato un mensaje de texto, empuja el primer asesinato en el anillo de asesinato para que necesite recorrer todos los asesinatos para volver al texto que quiero arrancar. Lo que quiero hacer es tirar repetidamente el mismo texto mientras mata el texto entre los yanquis. es posible?

Answer 1

Este es un truco extraño, pero puede ayudar.

La primera vez que usas M-y Normalmente recibe un error (sin Yank anterior). Entonces, la idea es que esta primera vez obtienes el último yanco en lugar del último asesinato.

Para almacenar ese último Yank, uso el registro 'Y' en este ejemplo.

Estas 2 funciones se extenderían alrededor de Yank y Yank-Pop. Esperas errores, espero sugerencias.

(defun jp/yank (&optional arg)
  "Yank and save text to register Y"
  (interactive)
  (set-register ?Y (current-kill 0 t))
  (yank arg))

(defun jp/yank-pop (&optional arg)
  "If yank-pop fails, then insert register Y"
  (interactive)
  (condition-case nil
      (yank-pop arg)
    (error (insert (get-register ?Y)))))

(global-set-key (kbd "M-y") (quote jp/yank-pop))
(global-set-key (kbd "C-y") (quote jp/yank))

Answer 2

No uses el anillo de matar; Pon el texto en un registro en su lugar. C-x r s a para almacenar el texto de la región en (digamos) registrarse "A"; después C-x r i a para insertarlo en otro lugar.

Answer 3

Podrías usar M-x delete-region En su lugar, para matar el texto, posiblemente vinculándolo a una clave si quieres usarlo mucho.

Answer 4

1. Si quieres sacar repetidamente el mismo texto, usa el selección secundaria en lugar de la región o el texto matado.

   Lo que falta en Vanilla Emacs es una encuadernación clave para yank de la selección secundaria. yo suelo C-M-y Para eso (ver biblioteca second-sel.el).

2. Llegar acceso directo a cualquier asesinato en el anillo de matar, use M-y con Examinar el anillo de matar o con Carámbano. En ambos casos, M-y En el nivel superior le brinda acceso a todas las entradas en el anillo de matar.

   Y si usas la biblioteca second-sel.el Luego, además del anillo de matar, tienes acceso a un anillo de tus selecciones secundarias pasadas.

   Y si usas la biblioteca second-sel.el y Carámbano después M-y tira una entrada desde el anillo desde el que te tiraste por última vez (anillo de matar o anillo de selección secundaria).

   Y si usas la biblioteca Examinar el anillo de matar+.el Luego, el navegador Kill-Ring le brinda acceso a un anillo alternativo también (que, por defecto, es el anillo de selecciones secundarias si usa la biblioteca second-sel.el).

Answer 5

Estoy tratando de piratear a lo largo de la línea de usar un modo menor. Llamemos a esto delete-mode. Una vez que llegas al modo de eliminación, mata los comandos (kill-line, kill-paragraph, kill-word, ...) cambiará su comportamiento para que el kill-region parte de sus comandos será reemplazada por delete-region, y no se agregará material nuevo al anillo de matar. Mientras esté en este modo, el anillo de matar se mantendrá constante. Cuando vuelve a salir de este modo, el comportamiento vuelve a la normalidad.

Lo siguiente es un código incompleto Intentando implementar lo que escribí anteriormente. Funciona correctamente al cambiar al modo Eliminar, pero tiene problemas para volver a cambiar (apagar el modo menor). Cualquier ayuda para solucionar esto sería apreciado.

(defvar delete-mode nil)

(defun delete-mode ()
    "delete minor-mode"
    (interactive)
    (setq delete-mode (not delete-mode))
    (if delete-mode
        (defalias 'kill-region 'delete-region)
        (defalias 'kill-region 'original-kill-region)
    )
)

(if (not (assq 'delete-mode minor-mode-alist))
    (setq minor-mode-alist
        (cons '(delete-mode "Delete mode on") minor-mode-alist)
    )
    (defalias 'original-kill-region 'kill-region)
)

Answer 6

Intentaré usar más la región de Delete, pero sé mejor los comandos de muerte. Un truco que no requiere programación o planificación anticipada es usar MW después de una cadena particularmente molesta de mi. Esto pone una copia más accesible del Yank final en el anillo de matar.

Answer 7

Una mejor implementación de Yank-Pop

Esto define una mejor implementación de Yank-Pop que intenta solucionar el problema creciente de Yank-Pop.

Solo anula la función "Current-Kill". Debido al diseño modular de Yank, Yank-Pop y las variables de anillo de matar y las funciones en los emacs, resulta que anular la "asesinato de corriente" es todo lo que es necesario para obtener el comportamiento que queremos.

El comportamiento deseado es que (1) matar algo todavía lo pone en la parte delantera del anillo de matar, pero ahora (2) yanking o yank empotando algo también lo pone en la parte delantera del anillo de matar (3) Preservamos la capacidad de Yank-Pop para dar la apariencia de moverse a través del anillo de asesinato incrementando una variable global y usando esto para reemplazar el último elemento de Yank-Pop 'donde estaba. Esto también significa que (4) elementos que se yanks de transición (es decir, los elementos colocados por los comandos de Yank o Yank-Pop, donde el siguiente comando es un Yank-Pop) finalmente se quedan donde están en el anillo de matar.

;; Example:
;; (setq kill-ring '("a" "b" "c" "d" "e"))
;;
;; keystroke        kill ring contents              value of kill-ring-yank-index
;; C-y              ("a" "b" "c" "d" "e")           0
;; M-y              ("b" "a" "c" "d" "e")           1
;; M-y              ("c" "a" "b" "d" "e")           2
;; M-y              ("d" "a" "b" "c" "e")           3

;; C-y              ("d" "a" "b" "c" "e")           0
;; M-y              ("a" "d" "b" "c" "e")           1

;; M-d              ("x" "a" "d" "b" "c" "e")
;; etc.

el código:

;; ----------------------------------------------------------------
;; helper functions

(defun list-insert-before (l n x)
  (if (<= n 0) (cons x l)
    (cons (car l) (list-insert-before (cdr l) (- n 1) x))))

(defun list-prepend-nth (l n)
  (if (<= n 0) l
    (let* ((lx (list-prepend-nth (cdr l) (- n 1))))
      (cons (car lx) (cons (car l) (cdr lx))))))

(defun list-insert-car-at (l n)
  (list-insert-before (cdr l) n (car l)))


;; ----------------------------------------------------------------
;; overriding current-kill

(defvar kill-ring-yank-index 0
  "Index into kill-ring of last yank-pop. The item yank-popped
  will be at the head of the kill ring, but if the next command
  is also yank-pop, it will be returned here first before this
  variable is incremented.")

(defun current-kill (n)
  "Replaces standard 'current-kill' function. This version tries
to fix the increasing yank-pop problem.

TODO:
- respect second argument of original function
- deal with 'interprogram-{cut,paste}-function'
"
  (if (eq 0 n) ;; looks like we're doing a yank; reset
               ;; kill-ring-yank-index to 0 to indicate that the
               ;; current head of the list is useful to the user
      (progn (setq kill-ring-yank-index 0)
             (car kill-ring))

    ;; otherwise put the head of kill-ring back where we had
    ;; previously found it, and fetch the next element
    (setq kill-ring
        (list-insert-car-at kill-ring kill-ring-yank-index))
    (setq kill-ring-yank-index (+ kill-ring-yank-index n))
    (when (>= kill-ring-yank-index (- (length kill-ring) 1))
      (setq kill-ring-yank-index (- (length kill-ring) 1))
      (message "Reached end of kill-ring"))
    (when (< kill-ring-yank-index 0)
      (setq kill-ring-yank-index 0)
      (message "Reached beginning of kill-ring"))
    (setq kill-ring (list-prepend-nth kill-ring kill-ring-yank-index))
    (car kill-ring)))

;; ----------------------------------------------------------------
;; new key binding

;; Here's an auxiliary function and key binding that makes it easy to
;; go back and forth in the kill-ring while we're yank-popping
(defun yank-pop-back () "" (interactive "*")
       (yank-pop -1))

(global-set-key "\C-\M-y" 'yank-pop-back)

Answer 8

yo suelo

MX BROWSE-CHILL-RING

con Keybinding 'M-Y'. También hay soporte de timón.

https://www.emacswiki.org/emacs/browsekillring

Ofrece más soluciones.