xyzzy my-cursor

my-cursor.l

;;;
;;; my-cursor.l
;;;

;;;
;;; point value
;;;
(defun point-bol ()
  "return point which represents beginning-of-line at point."
  (save-excursion (progn (beginning-of-line) (point))))

(defun point-eol ()
  "return point which represents end-of-line at point."
  (save-excursion (progn (end-of-line) (point))))

;; -----
(defun point-indent-start ()
  "return point which represents indent start at point"
  (max (point-bol)
       (save-excursion
         (goto-eol)
         (back-to-indentation)
         (point))))

(defun point-eol-no-comment ()
  "return point which represents end-of-line but comment at point"
  (if comment-start
      (min (point-eol)
           (save-excursion
             (goto-bol)
             (skip-syntax-spec-forward "^<")
             (skip-syntax-spec-backward " ")
             (point)))
    (point-eol)))

;;;
;;; moving
;;;
(defun beginning-of-line-gnrr ()
  "toggle beginning-of-line and indent-start"
  (interactive)
  (let ((b (point-indent-start)))
    (if (bolp)
        (goto-char b)
      (goto-bol))))

;; -----
(defun end-of-line-gnrr ()
  "toggle end-of-line and comment-start"
  (interactive)
  (let ((e (point-eol-no-comment)))
  (if (eolp)
    (when (< (point-bol) e)
      (goto-char e))
    (goto-eol))))

(global-set-key #\C-a 'beginning-of-line-gnrr)
(global-set-key #\C-e 'end-of-line-gnrr)

(define-key minibuffer-local-map #\C-a 'beginning-of-line)
(define-key minibuffer-local-map #\C-e 'end-of-line)

;; -----
(setq *page-scroll-keep-window-position* nil)
(defun next-page-gnrr ()
  (interactive)
  (next-page)
  (recenter -1))

(defun previous-page-gnrr ()
  (interactive)
  (previous-page))

(global-set-key #\M-n 'next-page-gnrr)
(global-set-key #\M-p 'previous-page-gnrr)

;; -----
(defun beginning-of-buffer-no-mark ()
  (interactive)
  (goto-char (point-min)))

(defun end-of-buffer-no-mark ()
  (interactive)
  (goto-char (point-max))
  (recenter -1))

(global-set-key #\M-P 'beginning-of-buffer-no-mark)
(global-set-key #\M-N 'end-of-buffer-no-mark)

;; -----
(defun forward-word-gnrr ()
  (interactive)
  (if (eolp) (progn (forward-word 1) (when (< (point) (point-max)) (backward-word 1)))
    (let ((dest (save-excursion
                  (if (syntax-whitespace-p (following-char))
                      (progn (skip-white-forward) (forward-word 1) (backward-word 1) (point))
                    (progn (forward-word 2) (backward-word 1) (point)))))
          (eol (save-excursion (progn (goto-eol) (point)))))
      (goto-char (if (>= (point) dest) eol
                   (min dest eol))))))

(global-set-key #\M-f 'forward-word-gnrr)

;; -----
(defun backward-word-gnrr ()
  (interactive)
  (if (bolp) (backward-char 1)
    (let ((dest (save-excursion (progn (backward-word 1) (point))))
          (bol (save-excursion (progn (goto-bol) (point)))))
      (goto-char (max dest bol))
      (when (bolp) (backward-word 1) (goto-eol)))))

(global-set-key #\M-b 'backward-word-gnrr)

;;;
;;; edit
;;;
(defun backward-delete-word-no-kill ()
  (interactive)
  (let ((dest (save-excursion
               (progn (backward-word)
                      (point)))))
    (cond ((char= (preceding-char) #\SPC) (delete-horizontal-spaces))
          ((bolp) (backward-delete-char-untabify 1))
          (t (while (and (< dest (point)) (not (bolp)))
               (backward-delete-char-untabify 1))))))

(global-set-key #\M-h 'backward-delete-word-no-kill)

;; for minibuffer
(define-key minibuffer-local-must-match-map #\M-h 'backward-delete-word-no-kill)
(define-key minibuffer-local-completion-map #\M-h 'backward-delete-word-no-kill)
(define-key minibuffer-local-map #\M-h 'backward-delete-word-no-kill)

;; -----
(defun kill-word-no-kill ()
  (interactive)
  (let ((n (- (save-excursion
                (progn (forward-word)
                       (point)))
              (point))))
    (cond ((char= (following-char) #\SPC) (delete-horizontal-spaces))
          ((eolp) (delete-char 1))
          (t (while (and (< 0 n) (char/= (following-char) #\LFD))
               (delete-char 1) (setq n (1- n)))))))

(global-set-key #\M-d 'kill-word-no-kill)

;; for minibuffer
(define-key minibuffer-local-must-match-map #\M-d 'kill-word-no-kill)
(define-key minibuffer-local-completion-map #\M-d 'kill-word-no-kill)
(define-key minibuffer-local-map #\M-d 'kill-word-no-kill)



#|| -- test
(defun parse-point-syntax-mod ()
  ""
  (let ((ch (following-char)))
    (find-if-not 'not
    (list (when (syntax-close-p ch) :close)
          (when (syntax-close-tag-p ch) :close-tag)
          (when (syntax-end-comment-p ch) :end-comment)
          (when (syntax-end-multi-comment-1-p ch) :end-multi-comment-1)
          (when (syntax-end-multi-comment-2-p ch) :end-multi-comment-2)
          (when (syntax-escape-p ch) :escape)
          (when (syntax-junk-p ch) :junk)
          (when (syntax-math-p ch) :math)
          (when (syntax-open-p ch) :open)
          (when (syntax-open-tag-p ch) :open-tag)
          (when (syntax-punctuation-p ch) :punctuation)
          (when (syntax-quote-p ch) :quote)
          (when (syntax-start-column-comment-p ch) :start-column-comment)
          (when (syntax-start-comment-p ch) :start-comment)
          (when (syntax-start-multi-comment-1-p ch) :start-multi-comment-1)
          (when (syntax-start-multi-comment-2-p ch) :start-multi-comment-2)
          (when (syntax-string-p ch) :string)
          (when (syntax-symbol-p ch) :symbol)
          (when (syntax-symbol-prefix-p ch) :symbol-prefix)
          (when (syntax-whitespace-p ch) :whitespace)
          (when (syntax-word-p ch) :word)))))


(defun forward-word-gnrr ()
  ""
  (interactive)
  (forward-word)
  )
  (skip-syntax-spec-forward
   (case (parse-point-syntax-mod)
     (:open "(")
     (:close ")")
     (:whitespace " ")
     (:symbol "_")
     (:end-comment " ")
     (t "w"))))
  (forward-char)
  (skip-syntax-spec-forward "^w()")
  )
(global-set-key #\M-f 'forward-word-gnrr)
||#