De passerende functie om te aligneren-regio verhoogt een fout bij het gebruik van de 'justify'-regel

Ik heb * test * buffer met de volgende inhoud:

 1234   23347   35466
    155555      267       31
 1444444 2444 32777

Nu probeer ik te begrijpen hoe het doorgeven van een callback naar align-region werkt, dus ik schreef dit script:

(let* ((group -1)
       (regexp
        "\\(\\s-*[0-9]+\\)")
       (spacing 5)
       (repeat t)
       (rule
        (list (list nil (cons 'regexp regexp)
                    (cons 'group (abs group))
                    (if (< group 0)
                        (cons 'justify t)
                      (cons 'bogus nil))
                    (if (>= spacing 0)
                        (cons 'spacing spacing)
                      (cons 'column (abs spacing)))
                    (cons 'repeat repeat)))))
  (with-current-buffer "*test*"
    (align-region (point-min) (point-max) 'entire rule nil
                  (lambda (&rest r) t))))

Ik heb die regel gekopieerd van de definitie van align-regexp . Wanneer ik mijn code evalueer krijg ik een foutmelding:

Debugger entered--Lisp error: (wrong-type-argument markerp (# . #))
  marker-position((# . #))
  align-areas(((# # . #) (# # . #) (# # . #)) (5 . t) (nil (regexp . "\\(\\s-*[0-9]+\\)") (group . 1) (justify . t) (spacing . 5) (repeat . t)) (lambda (&rest r) t))
  align-region(1 72 entire ((nil (regexp . "\\(\\s-*[0-9]+\\)") (group . 1) (justify . t) (spacing . 5) (repeat . t))) nil (lambda (&rest r) t))
  (save-current-buffer (set-buffer "*test*") (align-region (point-min) (point-max) (quote entire) rule nil (function (lambda (&rest r) t))))
  (let* ((group -1) (regexp "\\(\\s-*[0-9]+\\)") (spacing 5) (repeat t) (rule (list (list nil (cons (quote regexp) regexp) (cons (quote group) (abs group)) (if (< group 0) (cons (quote justify) t) (cons (quote bogus) nil)) (if (>= spacing 0) (cons (quote spacing) spacing) (cons (quote column) (abs spacing))) (cons (quote repeat) repeat))))) (save-current-buffer (set-buffer "*test*") (align-region (point-min) (point-max) (quote entire) rule nil (function (lambda (&rest r) t)))))
  eval((let* ((group -1) (regexp "\\(\\s-*[0-9]+\\)") (spacing 5) (repeat t) (rule (list (list nil (cons (quote regexp) regexp) (cons (quote group) (abs group)) (if (< group 0) (cons (quote justify) t) (cons (quote bogus) nil)) (if (>= spacing 0) (cons (quote spacing) spacing) (cons (quote column) (abs spacing))) (cons (quote repeat) repeat))))) (save-current-buffer (set-buffer "*test*") (align-region (point-min) (point-max) (quote entire) rule nil (function (lambda (&rest r) t))))) nil)
  elisp--eval-last-sexp(t)
  eval-last-sexp(t)
  eval-print-last-sexp(nil)
  funcall-interactively(eval-print-last-sexp nil)
  call-interactively(eval-print-last-sexp nil nil)
  command-execute(eval-print-last-sexp)

Het script evalueert netjes als ik groep in regel 1 in 1 verander (dus ik gebruik geen regel 'rechtvaardigen ). Mis ik iets voor de hand liggend? Ik heb dit getest op emacs-25.3 en 26-0.90 en de resultaten zijn hetzelfde.

1
ja ru de

Geen antwoorden

0