home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / editors / emacs / xemacs / xemacs-1.006 / xemacs-1 / lib / xemacs-19.13 / lisp / ilisp / ilisp-mov.el < prev    next >
Encoding:
Text File  |  1995-01-26  |  6.4 KB  |  202 lines
  1. ;;; -*- Mode: Emacs-Lisp -*-
  2.  
  3. ;;; ilisp-mov.el --
  4.  
  5. ;;; This file is part of ILISP.
  6. ;;; Version: 5.7
  7. ;;;
  8. ;;; Copyright (C) 1990, 1991, 1992, 1993 Chris McConnell
  9. ;;;               1993, 1994 Ivan Vasquez
  10. ;;;               1994, 1995 Marco Antoniotti and Rick Busdiecker
  11. ;;;
  12. ;;; Other authors' names for which this Copyright notice also holds
  13. ;;; may appear later in this file.
  14. ;;;
  15. ;;; Send mail to 'ilisp-request@lehman.com' to be included in the
  16. ;;; ILISP mailing list. 'ilisp@lehman.com' is the general ILISP
  17. ;;; mailing list were bugs and improvements are discussed.
  18. ;;;
  19. ;;; ILISP is freely redistributable under the terms found in the file
  20. ;;; COPYING.
  21.  
  22.  
  23.  
  24. ;;;%%Movement
  25. (defun bol-ilisp (arg)
  26.   "Goes to the beginning of line, then skips past the prompt, if any.
  27. If a prefix argument is given (\\[universal-argument]), then no prompt skip 
  28. -- go straight to column 0.
  29.  
  30. The prompt skip is done by skipping text matching the regular expression
  31. comint-prompt-regexp or ilisp-other-prompt, both buffer local variables."
  32.   (interactive "P")
  33.   (beginning-of-line)
  34.   (if (null arg) 
  35.       (or (comint-skip-prompt)
  36.       (if ilisp-other-prompt
  37.           (let ((comint-prompt-regexp ilisp-other-prompt))
  38.         (comint-skip-prompt))))))
  39.  
  40. ;;;
  41. (defun beginning-of-defun-lisp (&optional stay)
  42.   "Go to the next left paren that starts at the left margin or after a
  43. prompt in an ILISP buffer.  If optional STAY, then do not move to
  44. prior defun if at the start of one in an ilisp mode."
  45.   (interactive)
  46.   (if (memq major-mode ilisp-modes)
  47.       (let ((point (point)))
  48.     (if (and (not stay) (= point (lisp-input-start)))
  49.         (progn (forward-line -1) (lisp-input-start))))
  50.       (beginning-of-defun)))
  51.  
  52. ;;;
  53. (defun end-of-defun-lisp ()
  54.   "Go to the next left paren that starts at the left margin or after a
  55. prompt in an ILISP buffer and go to the end of the expression."
  56.   (interactive)
  57.   (let ((point (point)))
  58.     (if (memq major-mode ilisp-modes)
  59.     (beginning-of-defun-lisp t)
  60.     (if (or (lisp-in-string)
  61.         (progn (beginning-of-line)
  62.                (re-search-forward "^[ \t\n]*[^; \t\n]" nil t)
  63.                (back-to-indentation)
  64.                (not (bolp))))
  65.         (beginning-of-defun-lisp t)))
  66.     (lisp-end-defun-text t)
  67.     (if (= point (point))        ;Already at end so move to next end
  68.     (progn
  69.       (if (memq major-mode ilisp-modes)
  70.           (re-search-forward comint-prompt-regexp (point-max) t)
  71.           (lisp-skip (point-max)))
  72.       (if (not (or (eobp)
  73.                (= (char-after (point)) ?\n)))
  74.           (lisp-end-defun-text t))))))
  75.  
  76. ;;;
  77. (defun lisp-defun-begin ()
  78.   "Go to the start of the containing defun and return point."
  79.   (let (begin)
  80.     (if (memq major-mode ilisp-modes)
  81.     (lisp-input-start)
  82.     (if (or (eobp) (not (and (bolp) (= (char-after (point)) ?\())))
  83.         (beginning-of-defun))
  84.     (point))))
  85.  
  86. ;;;
  87. (defun lisp-defun-end (&optional no-errorp at-beginp)
  88.   "Go to the end of the containing defun and return point or nil if
  89. there is no end."
  90.   (if (not at-beginp) (lisp-defun-begin))
  91.   (condition-case ()
  92.       (progn
  93.     (lisp-skip (point-max))        ;To skip comments on defun-end
  94.     (forward-sexp)
  95.     (point))
  96.     (error (if no-errorp nil (error "Unbalanced parentheses")))))
  97.  
  98. ;;;
  99. (defun lisp-find-next-start ()
  100.   "Find the start of the next line at the left margin that starts with
  101. a character besides whitespace, a \) or ;;; and return the
  102. point."
  103.   (if (eobp)
  104.       (point-max)
  105.       (save-excursion
  106.     (forward-char)
  107.     (if (re-search-forward "^\\(\\(;;;\\)\\|\\([^ \t\n\);]\\)\\)" nil t)
  108.         (match-beginning 0)
  109.         (point-max)))))
  110.  
  111. ;;;
  112. (defun lisp-end-defun-text (&optional at-start)
  113.   "Go the end of the text associated with the current defun and return
  114. point.  The end is the last character before whitespace leading to
  115. a left paren or ;;; at the left margin unless it is in a string."
  116.   (if (not at-start) (lisp-defun-begin))
  117.   (let ((point (point))
  118.     (boundary (lisp-find-next-start))
  119.     (final (save-excursion
  120.          (condition-case ()
  121.              (progn (forward-sexp) (point))
  122.            (error (point-max))))))
  123.     ;; Find the next line starting at the left margin and then check
  124.     ;; to see if it is in a string. 
  125.     (while (progn
  126.          (skip-chars-forward "^\"" boundary) ;To the next string
  127.          (if (= (point) boundary)    
  128.          nil            ;No quote found and at limit
  129.          (let ((string-boundary ;Start of next defun
  130.             (save-excursion
  131.               (if (re-search-forward "^\(\\|^;;;" nil t)
  132.                   (match-beginning 0)
  133.                   (point-max)))))
  134.            (if (condition-case ()
  135.                (progn (forward-sexp) t)
  136.              (error (goto-char string-boundary) nil))
  137.                (if (>= (point) boundary)
  138.                ;; Boundary was in string
  139.                (if (> (point) string-boundary)
  140.                    (progn    ;String ended in next defun
  141.                  (goto-char string-boundary)
  142.                  nil)
  143.                    (if (> (setq boundary
  144.                         (lisp-find-next-start))
  145.                       final)
  146.                    ;; Normal defun
  147.                    (progn (goto-char final) nil)
  148.                    t))
  149.                t)
  150.                ;; Unclosed string
  151.                nil)))))
  152.     (re-search-backward  "^[^; \t\n]\\|^[^;\n][ \t]*[^ \t\n]" point t)
  153.     (end-of-line)
  154.     (skip-chars-backward " \t")
  155.     (if (< (point) point)
  156.     (goto-char point)
  157.     (if (save-excursion
  158.           (let ((point (point)))
  159.         (beginning-of-line)
  160.         (if comment-start (search-forward comment-start point t))))
  161.         (progn (next-line 1) (indent-line-ilisp)))
  162.     (point))))
  163.  
  164. ;;;
  165. (defun lisp-in-comment (test)
  166.   "Return T if you are in a comment."
  167.   (beginning-of-line)
  168.   (and (looking-at test)
  169.        (not (= (match-end 0)
  170.            (progn (end-of-line) (point))))))
  171.  
  172. ;;;
  173. (defun lisp-in-string (&optional begin end)
  174.   "Return the string region that immediately follows/precedes point or
  175. that contains point in optional region BEGIN to END.  If point is in
  176. region, T will be returned as well."
  177.   (save-excursion
  178.     (if (not begin)
  179.     (save-excursion
  180.       (setq end (lisp-end-defun-text)
  181.         begin (lisp-defun-begin))))
  182.     (let* ((point (progn (skip-chars-forward " \t") (point)))
  183.        (done nil))
  184.       (goto-char begin)
  185.       (while (and (< (point) end) (not done))
  186.     (skip-chars-forward "^\"" end)
  187.     (setq begin (point))
  188.     (if (< begin end)
  189.         (if (and (not (bobp)) (= (char-after (1- begin)) ??))
  190.         (forward-char)
  191.         (if (condition-case () (progn (forward-sexp) (<= (point) end))
  192.               (error nil))
  193.             (progn        ;After string
  194.               (skip-chars-forward " \t")
  195.               (if (or (= begin point) (= point (point)))
  196.               (setq done (list begin (point) nil))
  197.               (if (and (< begin point) (< point (point)))
  198.                   (setq done (list begin (point) t)))))
  199.             ;; In string at end of buffer
  200.             (setq done (list begin end t))))))
  201.       done)))
  202.