comparison lisp/emacs-lisp/lisp.el @ 31982:ed0ed1c70495

(lisp-complete-symbol): Distinguish the let-binding case from the funcall case. (forward-sexp-function): New variable. (forward-sexp): Use it.

31981:533a4e5f06e2

(defcustom parens-require-spaces t
  "Non-nil means `insert-parentheses' should insert whitespace as needed."
  :type 'boolean
  :group 'lisp)

(defun forward-sexp (&optional arg)
  "Move forward across one balanced expression (sexp).
With ARG, do it that many times.  Negative arg -N means
move backward across N balanced expressions."
  (interactive "p")
  (or arg (setq arg 1))
  (goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
  (if (< arg 0) (backward-prefix-chars)))

(defun backward-sexp (&optional arg)
  "Move backward across one balanced expression (sexp).
With ARG, do it that many times.  Negative arg -N means
move forward across N balanced expressions."

symbols with function definitions, values or properties are
considered."
  (interactive)
  (let* ((end (point))
	 (beg (with-syntax-table emacs-lisp-mode-syntax-table
		  (save-excursion
		    (backward-sexp 1)
		    (while (= (char-syntax (following-char)) ?\')
		      (forward-char 1))
		    (point))))
	 (pattern (buffer-substring-no-properties beg end))
	 (predicate
	  (or predicate
	      (if (eq (char-after (1- beg)) ?\()
		  'fboundp
		(function (lambda (sym)
			    (or (boundp sym) (fboundp sym)
				(symbol-plist sym)))))))
	 (completion (try-completion pattern obarray predicate)))
    (cond ((eq completion t))
	  ((null completion)
	   (message "Can't find completion for \"%s\"" pattern)
	   (ding))

31982:ed0ed1c70495

(defcustom parens-require-spaces t
  "Non-nil means `insert-parentheses' should insert whitespace as needed."
  :type 'boolean
  :group 'lisp)

(defvar forward-sexp-function nil
  "If non-nil, `forward-sexp' delegates to this function.
Should take the same arguments and behave similarly to `forward-sexp'.")

(defun forward-sexp (&optional arg)
  "Move forward across one balanced expression (sexp).
With ARG, do it that many times.  Negative arg -N means
move backward across N balanced expressions."
  (interactive "p")
  (or arg (setq arg 1))
  (if forward-sexp-function
      (funcall forward-sexp-function arg)
    (goto-char (or (scan-sexps (point) arg) (buffer-end arg)))
    (if (< arg 0) (backward-prefix-chars))))

(defun backward-sexp (&optional arg)
  "Move backward across one balanced expression (sexp).
With ARG, do it that many times.  Negative arg -N means
move forward across N balanced expressions."

symbols with function definitions, values or properties are
considered."
  (interactive)
  (let* ((end (point))
	 (beg (with-syntax-table emacs-lisp-mode-syntax-table
		(save-excursion
		  (backward-sexp 1)
		  (while (= (char-syntax (following-char)) ?\')
		    (forward-char 1))
		  (point))))
	 (pattern (buffer-substring-no-properties beg end))
	 (predicate
	  (or predicate
	      (save-excursion
		(goto-char beg)
		(if (not (eq (char-before) ?\())
		    (lambda (sym)	;why not just nil ?   -sm
		      (or (boundp sym) (fboundp sym)
			  (symbol-plist sym)))
		  ;; Looks like a funcall position.  Let's double check.
		  (backward-char 1)	;skip paren
		  (if (condition-case nil
			  (progn (up-list -2) (forward-char 1)
				 (eq (char-after) ?\())
			(error nil))
		      ;; If the first element of the parent list is an open
		      ;; parenthesis we are probably not in a funcall position.
		      ;; Maybe a `let' varlist or something.
		      nil
		    ;; Else, we assume that a function name is expected.
		    'fboundp)))))
	 (completion (try-completion pattern obarray predicate)))
    (cond ((eq completion t))
	  ((null completion)
	   (message "Can't find completion for \"%s\"" pattern)
	   (ding))