Cambiando el comportamiento de Emacs Forward-Word

emacs23

Question

Como dice el título, ¿cómo se cambia el comportamiento de la función de palabra hacia adelante emacs? Por ejemplo, supongamos que [] es el cursor. Entonces:

my $abs_target_path[]= abs_path($target);
<M-f>
my $abs_target_path = abs[_]path($target);

Sé que solo podría usar Mf Mb, pero en lo que a mí respecta, no debería ser necesario y me gustaría cambiarlo. En particular, quiero dos cosas:

1. Cuando presiono Mf, quiero ir al primer carácter de la siguiente palabra independientemente de si el punto está dentro de una palabra, dentro de un grupo de espacios o en algún otro lugar.
2. Personaliza los caracteres de la palabra en una base de modo por modo. Después de todo, moverse en modo CPerl es diferente de, digamos, modo TeX.

Entonces, en el ejemplo anterior, el elemento 1 tendría el cursor se movería a la ''a'' (y el punto a la izquierda) después de golpear Mf. El ítem 2 me permitiría definir guiones bajos y sigilos como caracteres de palabras.

Answer 1

Quería copiar el comportamiento de mi editor anterior, por lo que necesitaba un poco más de control, así que aquí está mi opinión:

(defun my-syntax-class (char)
  "Return ?s, ?w or ?p depending or whether CHAR is a white-space, word or punctuation character."
  (pcase (char-syntax char)
      (`?/s ?s)
      (`?w ?w)
      (`?_ ?w)
      (_ ?p)))

(defun my-forward-word (&optional arg)
  "Move point forward a word (simulate behavior of Far Manager''s editor).
With prefix argument ARG, do it ARG times if positive, or move backwards ARG times if negative."
  (interactive "^p")
  (or arg (setq arg 1))
  (let* ((backward (< arg 0))
         (count (abs arg))
         (char-next
          (if backward ''char-before ''char-after))
         (skip-syntax
          (if backward ''skip-syntax-backward ''skip-syntax-forward))
         (skip-char
          (if backward ''backward-char ''forward-char))
         prev-char next-char)
    (while (> count 0)
      (setq next-char (funcall char-next))
      (loop
       (if (or                          ; skip one char at a time for whitespace,
            (eql next-char ?/n)         ; in order to stop on newlines
            (eql (char-syntax next-char) ?/s))
           (funcall skip-char)
         (funcall skip-syntax (char-to-string (char-syntax next-char))))
       (setq prev-char next-char)
       (setq next-char (funcall char-next))
       ;; (message (format "Prev: %c %c %c Next: %c %c %c"
       ;;                   prev-char (char-syntax prev-char) (my-syntax-class prev-char)
       ;;                   next-char (char-syntax next-char) (my-syntax-class next-char)))
       (when
           (or
            (eql prev-char ?/n)         ; stop on newlines
            (eql next-char ?/n)
            (and                        ; stop on word -> punctuation
             (eql (my-syntax-class prev-char) ?w)
             (eql (my-syntax-class next-char) ?p))
            (and                        ; stop on word -> whitespace
             this-command-keys-shift-translated ; when selecting
             (eql (my-syntax-class prev-char) ?w)
             (eql (my-syntax-class next-char) ?s))
            (and                        ; stop on whitespace -> non-whitespace
             (not backward)             ; when going forward
             (not this-command-keys-shift-translated) ; and not selecting
             (eql (my-syntax-class prev-char) ?s)
             (not (eql (my-syntax-class next-char) ?s)))
            (and                        ; stop on non-whitespace -> whitespace
             backward                   ; when going backward
             (not this-command-keys-shift-translated) ; and not selecting
             (not (eql (my-syntax-class prev-char) ?s))
             (eql (my-syntax-class next-char) ?s))
            )
         (return))
       )
      (setq count (1- count)))))

(defun delete-word (&optional arg)
  "Delete characters forward until encountering the end of a word.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-region (point) (progn (my-forward-word arg) (point))))

(defun backward-delete-word (arg)
  "Delete characters backward until encountering the beginning of a word.
With argument ARG, do this that many times."
  (interactive "p")
  (delete-word (- arg)))

(defun my-backward-word (&optional arg)
  (interactive "^p")
  (or arg (setq arg 1))
  (my-forward-word (- arg)))

(global-set-key (kbd "C-<left>") ''my-backward-word)
(global-set-key (kbd "C-<right>") ''my-forward-word)
(global-set-key (kbd "C-<delete>") ''delete-word)
(global-set-key (kbd "C-<backspace>") ''backward-delete-word)

Answer 2

Tengo un modo menor que cambia los comandos basados ​​en palabras para operar con cambios de sintaxis (y también CamelCaseSubwords). Puede que sea un poco demasiado fino para algunos gustos, pero me parece que básicamente siempre uso el movimiento de un solo personaje.

https://bitbucket.org/jpkotta/syntax-subword

Answer 3

Tratar:

(require ''misc)

Luego use Mx forward-to-word y vea si hace lo que quiere. A continuación, puede volver a enlazar Mf , etc.

Para hacer el _ no un separador de palabras (es decir, convertirlo en un constituyente de palabras) para el modo C y C ++, debe hacer esto:

(modify-syntax-entry ?_ "w" c-mode-syntax-table)
(modify-syntax-entry ?_ "w" c++-mode-syntax-table)

Para obtener más información sobre las tablas de sintaxis, lea esta página wiki . Las tablas de sintaxis generalmente se denominan como tex-mode-syntax-table y cperl-mode-syntax-table .

Answer 4

Ver también la función de sintaxis hacia adelante. Probablemente esto es lo que necesitas para basarte.