# HG changeset patch # User Stefan Monnier # Date 1156096516 0 # Node ID 2657308de2f65aa3fdd8eb06e52ea349796e7e69 # Parent 18443633d75d01b20690068837143a0dcaf1899f Update to Dave Love's latest version. (python-font-lock-keywords, python-mode): Don't use font-lock-syntax-table, but match symbol elements explicitly instead. (python-mode-map): Add help, and a few more key bindings. (python-skip-comments/blanks): Move out of comments as well. (python-continuation-line-p): Behave better with unbalanced parens. (python-blank-line-p): New fun. (python-open-block-statement-p): Don't use a heuristic. (python-outdent-p): Better handle blocks-in-the-same-line. (python-calculate-indentation): Misc improvements. (python-comment-indent): Remove. (python-block-pairs): New var. (python-first-word): New fun. (python-indentation-levels): Handle more common cases. (python-indent-line-1): Add `leave' argument. (python-indent-region): New fun. (python-skip-out): New fun. (python-beginning-of-statement, python-end-of-statement): Use it. (python-next-statement): Return correct count even at eob. (python-end-of-block): Fix paren-typo. (python-imenu-create-index): Add module variables. (run-python): Add `new' arg. Check we're at a prompt before returning. (python-send-command): Move to end of buffer. Wait for prompt to return. (python-set-proc): New fun. (python-imports): New var. (python-describe-symbol): Use it. Adjust to new interface of `ehelp'. (python-eldoc-function): Try to move out of arg list. (python-outline-level): Offset by 1. (python-find-imports): New fun. (python-symbol-completions): Use python-imports. (python-module-path, ffap-alist): Add support for ffap. (python-skeletons, python-mode-abbrev-table, def-python-skeleton) (pythin-insert-*, python-default-template, python-expand-template): Add templates/skeletons. (python-setup-brm): Support for Bicycle Repair Man. (python-abbrev-syntax-table): New var. (python-abbrev-pc-hook, python-pea-hook): New funs. diff -r 18443633d75d -r 2657308de2f6 lisp/ChangeLog --- a/lisp/ChangeLog Sun Aug 20 17:54:48 2006 +0000 +++ b/lisp/ChangeLog Sun Aug 20 17:55:16 2006 +0000 @@ -1,3 +1,45 @@ +2006-08-20 Dave Love + + * progmodes/python.el: Update to Dave Love's latest version. + (python-font-lock-keywords, python-mode): Don't use + font-lock-syntax-table, but match symbol elements explicitly instead. + (python-mode-map): Add help, and a few more key bindings. + (python-skip-comments/blanks): Move out of comments as well. + (python-continuation-line-p): Behave better with unbalanced parens. + (python-blank-line-p): New fun. + (python-open-block-statement-p): Don't use a heuristic. + (python-outdent-p): Better handle blocks-in-the-same-line. + (python-calculate-indentation): Misc improvements. + (python-comment-indent): Remove. + (python-block-pairs): New var. + (python-first-word): New fun. + (python-indentation-levels): Handle more common cases. + (python-indent-line-1): Add `leave' argument. + (python-indent-region): New fun. + (python-skip-out): New fun. + (python-beginning-of-statement, python-end-of-statement): Use it. + (python-next-statement): Return correct count even at eob. + (python-end-of-block): Fix paren-typo. + (python-imenu-create-index): Add module variables. + (run-python): Add `new' arg. + Check we're at a prompt before returning. + (python-send-command): Move to end of buffer. + Wait for prompt to return. + (python-set-proc): New fun. + (python-imports): New var. + (python-describe-symbol): Use it. Adjust to new interface of `ehelp'. + (python-eldoc-function): Try to move out of arg list. + (python-outline-level): Offset by 1. + (python-find-imports): New fun. + (python-symbol-completions): Use python-imports. + (python-module-path, ffap-alist): Add support for ffap. + (python-skeletons, python-mode-abbrev-table, def-python-skeleton) + (pythin-insert-*, python-default-template, python-expand-template): + Add templates/skeletons. + (python-setup-brm): Support for Bicycle Repair Man. + (python-abbrev-syntax-table): New var. + (python-abbrev-pc-hook, python-pea-hook): New funs. + 2006-08-20 Chong Yidong * frame.el (blink-cursor-start): Set timer first. diff -r 18443633d75d -r 2657308de2f6 lisp/progmodes/python.el --- a/lisp/progmodes/python.el Sun Aug 20 17:54:48 2006 +0000 +++ b/lisp/progmodes/python.el Sun Aug 20 17:55:16 2006 +0000 @@ -9,19 +9,19 @@ ;; This file is part of GNU Emacs. -;; This file is free software; you can redistribute it and/or modify +;; GNU Emacs is free software; you can redistribute it and/or modify ;; it under the terms of the GNU General Public License as published by ;; the Free Software Foundation; either version 2, or (at your option) ;; any later version. -;; This file is distributed in the hope that it will be useful, +;; GNU Emacs is distributed in the hope that it will be useful, ;; but WITHOUT ANY WARRANTY; without even the implied warranty of ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ;; GNU General Public License for more details. ;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs; see the file COPYING. If not, write to -;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, +;; along with GNU Emacs; see the file COPYING. If not, write to the +;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ;; Boston, MA 02110-1301, USA. ;;; Commentary: @@ -32,41 +32,43 @@ ;; maintained with Python. That isn't covered by an FSF copyright ;; assignment, unlike this code, and seems not to be well-maintained ;; for Emacs (though I've submitted fixes). This mode is rather -;; simpler and is, perhaps, better in other ways. In particular, -;; using the syntax functions with text properties maintained by -;; font-lock should make it more correct with arbitrary string and -;; comment contents. +;; simpler and is better in other ways. In particular, using the +;; syntax functions with text properties maintained by font-lock makes +;; it more correct with arbitrary string and comment contents. ;; This doesn't implement all the facilities of python-mode.el. Some ;; just need doing, e.g. catching exceptions in the inferior Python ;; buffer (but see M-x pdb for debugging). [Actually, the use of -;; `compilation-minor-mode' now is probably enough for that.] Others -;; don't seem appropriate. For instance, `forward-into-nomenclature' -;; should be done separately, since it's not specific to Python, and -;; I've installed a minor mode to do the job properly in Emacs 22. +;; `compilation-shell-minor-mode' now is probably enough for that.] +;; Others don't seem appropriate. For instance, +;; `forward-into-nomenclature' should be done separately, since it's +;; not specific to Python, and I've installed a minor mode to do the +;; job properly in Emacs 23. [CC mode 5.31 contains an incompatible +;; feature, `c-subword-mode' which is intended to have a similar +;; effect, but actually only affects word-oriented keybindings.] + ;; Other things seem more natural or canonical here, e.g. the ;; {beginning,end}-of-defun implementation dealing with nested -;; definitions, and the inferior mode following `cmuscheme'. The +;; definitions, and the inferior mode following `cmuscheme'. (The ;; inferior mode can find the source of errors from -;; `python-send-region' & al via `compilation-minor-mode'. Successive -;; TABs cycle between possible indentations for the line. There is -;; symbol completion using lookup in Python. +;; `python-send-region' & al via `compilation-shell-minor-mode'.) +;; There is (limited) symbol completion using lookup in Python and +;; Eldoc support also using the inferior process. Successive TABs +;; cycle between possible indentations for the line. -;; Even where it has similar facilities, this is incompatible with -;; python-mode.el in various respects. For instance, various key -;; bindings are changed to obey Emacs conventions, and things like -;; marking blocks and `beginning-of-defun' behave differently. +;; Even where it has similar facilities, this mode is incompatible +;; with python-mode.el in some respects. For instance, various key +;; bindings are changed to obey Emacs conventions. ;; TODO: See various Fixmes below. ;;; Code: -;; It's messy to autoload the relevant comint functions so that comint -;; is only required when inferior Python is used. -(require 'comint) (eval-when-compile (require 'compile) - (autoload 'info-lookup-maybe-add-help "info-look")) + (require 'comint)) + +(autoload 'comint-mode "comint") (defgroup python nil "Silly walks in the Python language." @@ -84,31 +86,37 @@ ;;;; Font lock (defvar python-font-lock-keywords - `(,(rx (and word-start - ;; From v 2.3 reference. - ;; def and class dealt with separately below - (or "and" "assert" "break" "continue" "del" "elif" "else" - "except" "exec" "finally" "for" "from" "global" "if" - "import" "in" "is" "lambda" "not" "or" "pass" "print" - "raise" "return" "try" "while" "yield" - ;; Future keywords - "as" "None") - word-end)) - (,(rx (and word-start (group "class") (1+ space) (group (1+ word)))) - (1 font-lock-keyword-face) (2 font-lock-type-face)) - (,(rx (and word-start (group "def") (1+ space) (group (1+ word)))) - (1 font-lock-keyword-face) (2 font-lock-function-name-face)))) + `(,(rx symbol-start + ;; From v 2.4 reference. + ;; def and class dealt with separately below + (or "and" "assert" "break" "continue" "del" "elif" "else" + "except" "exec" "finally" "for" "from" "global" "if" + "import" "in" "is" "lambda" "not" "or" "pass" "print" + "raise" "return" "try" "while" "yield" + ;; Future keywords + "as" "None") + symbol-end) + ;; Definitions + (,(rx symbol-start (group "class") (1+ space) (group (1+ (or word ?_)))) + (1 font-lock-keyword-face) (2 font-lock-type-face)) + (,(rx symbol-start (group "def") (1+ space) (group (1+ (or word ?_)))) + (1 font-lock-keyword-face) (2 font-lock-function-name-face)) + ;; Top-level assignments are worth highlighting. + (,(rx line-start (group (1+ (or word ?_))) (0+ space) "=") + (1 font-lock-variable-name-face)) + (,(rx "@" (1+ (or word ?_))) ; decorators + (0 font-lock-preprocessor-face)))) (defconst python-font-lock-syntactic-keywords ;; Make outer chars of matching triple-quote sequences into generic ;; string delimiters. Fixme: Is there a better way? - `((,(rx (and (or line-start buffer-start (not (syntax escape))) ; avoid escaped - ; leading quote - (group (optional (any "uUrR"))) ; prefix gets syntax property - (optional (any "rR")) ; possible second prefix - (group (syntax string-quote)) ; maybe gets property - (backref 2) ; per first quote - (group (backref 2)))) ; maybe gets property + `((,(rx (or line-start buffer-start + (not (syntax escape))) ; avoid escaped leading quote + (group (optional (any "uUrR"))) ; prefix gets syntax property + (optional (any "rR")) ; possible second prefix + (group (syntax string-quote)) ; maybe gets property + (backref 2) ; per first quote + (group (backref 2))) ; maybe gets property (1 (python-quote-syntax 1)) (2 (python-quote-syntax 2)) (3 (python-quote-syntax 3))) @@ -132,6 +140,8 @@ ;; x = ''' """ ' a ;; ''' ;; x '"""' x """ \"""" x + ;; Fixme: """""" goes wrong (due to syntax-ppss not getting the string + ;; fence context). (save-excursion (goto-char (match-beginning 0)) (cond @@ -140,19 +150,17 @@ (let ((syntax (syntax-ppss))) (when (eq t (nth 3 syntax)) ; after unclosed fence (goto-char (nth 8 syntax)) ; fence position - ;; Skip any prefix. - (if (memq (char-after) '(?u ?U ?R ?r)) - (skip-chars-forward "uUrR")) + (skip-chars-forward "uUrR") ; skip any prefix ;; Is it a matching sequence? (if (eq (char-after) (char-after (match-beginning 2))) (eval-when-compile (string-to-syntax "|")))))) ;; Consider property for initial char, accounting for prefixes. - ((or (and (= n 2) ; not prefix + ((or (and (= n 2) ; leading quote (not prefix) (= (match-beginning 1) (match-end 1))) ; prefix is null (and (= n 1) ; prefix (/= (match-beginning 1) (match-end 1)))) ; non-empty (unless (eq 'string (syntax-ppss-context (syntax-ppss))) - (eval-when-compile (string-to-syntax "|")))) + (eval-when-compile (string-to-syntax "|")))) ;; Otherwise (we're in a non-matching string) the property is ;; nil, which is OK. ))) @@ -204,23 +212,37 @@ (define-key map "\C-c\C-l" 'python-load-file) ; a la cmuscheme (substitute-key-definition 'complete-symbol 'python-complete-symbol map global-map) - ;; Fixme: Add :help to menu. + (define-key map "\C-c\C-i" 'python-find-imports) + (define-key map "\C-c\C-t" 'python-expand-template) (easy-menu-define python-menu map "Python Mode menu" - '("Python" - ["Shift region left" python-shift-left :active mark-active] - ["Shift region right" python-shift-right :active mark-active] + `("Python" + :help "Python-specific Features" + ["Shift region left" python-shift-left :active mark-active + :help "Shift by a single indentation step"] + ["Shift region right" python-shift-right :active mark-active + :help "Shift by a single indentation step"] "-" - ["Mark block" python-mark-block] + ["Mark block" python-mark-block + :help "Mark innermost block around point"] ["Mark def/class" mark-defun :help "Mark innermost definition around point"] "-" - ["Start of block" python-beginning-of-block] - ["End of block" python-end-of-block] + ["Start of block" python-beginning-of-block + :help "Go to start of innermost definition around point"] + ["End of block" python-end-of-block + :help "Go to end of innermost definition around point"] ["Start of def/class" beginning-of-defun :help "Go to start of innermost definition around point"] ["End of def/class" end-of-defun :help "Go to end of innermost definition around point"] "-" + ("Templates..." + :help "Expand templates for compound statements" + :filter (lambda (&rest junk) + (mapcar (lambda (elt) + (vector (car elt) (cdr elt) t)) + python-skeletons))) ; defined later + "-" ["Start interpreter" run-python :help "Run `inferior' Python in separate buffer"] ["Import/reload file" python-load-file @@ -233,12 +255,23 @@ :help "Evaluate current definition in inferior Python session"] ["Switch to interpreter" python-switch-to-python :help "Switch to inferior Python buffer"] + ["Set default process" python-set-proc + :help "Make buffer's inferior process the default" + :active (buffer-live-p python-buffer)] ["Check file" python-check :help "Run pychecker"] ["Debugger" pdb :help "Run pdb under GUD"] "-" ["Help on symbol" python-describe-symbol - :help "Use pydoc on symbol at point"])) + :help "Use pydoc on symbol at point"] + ["Complete symbol" python-complete-symbol + :help "Complete (qualified) symbol before point"] + ["Update imports" python-find-imports + :help "Update list of top-level imports for completion"])) map)) +;; Fixme: add toolbar stuff for useful things like symbol help, send +;; region, at least. (Shouldn't be specific to Python, obviously.) +;; eric has items including: (un)indent, (un)comment, restart script, +;; run script, debug script; also things for profiling, unit testing. (defvar python-mode-syntax-table (let ((table (make-syntax-table))) @@ -263,7 +296,8 @@ (defsubst python-in-string/comment () "Return non-nil if point is in a Python literal (a comment or string)." - (syntax-ppss-context (syntax-ppss))) + ;; We don't need to save the match data. + (nth 8 (syntax-ppss))) (defconst python-space-backslash-table (let ((table (copy-syntax-table python-mode-syntax-table))) @@ -273,13 +307,21 @@ (defun python-skip-comments/blanks (&optional backward) "Skip comments and blank lines. -BACKWARD non-nil means go backwards, otherwise go forwards. Backslash is -treated as whitespace so that continued blank lines are skipped. -Doesn't move out of comments -- should be outside or at end of line." - (with-syntax-table python-space-backslash-table - (forward-comment (if backward - most-negative-fixnum - most-positive-fixnum)))) +BACKWARD non-nil means go backwards, otherwise go forwards. +Backslash is treated as whitespace so that continued blank lines +are skipped. Doesn't move out of comments -- should be outside +or at end of line." + (let ((arg (if backward + ;; If we're in a comment (including on the trailing + ;; newline), forward-comment doesn't move backwards out + ;; of it. Don't set the syntax table round this bit! + (let ((syntax (syntax-ppss))) + (if (nth 4 syntax) + (goto-char (nth 8 syntax))) + (- (point-max))) + (point-max)))) + (with-syntax-table python-space-backslash-table + (forward-comment arg)))) (defun python-backslash-continuation-line-p () "Non-nil if preceding line ends with backslash that is not in a comment." @@ -289,12 +331,17 @@ (defun python-continuation-line-p () "Return non-nil if current line continues a previous one. The criteria are that the previous line ends in a backslash outside -comments and strings, or that the bracket/paren nesting depth is nonzero." - (or (and (eq ?\\ (char-before (line-end-position 0))) - (not (syntax-ppss-context (syntax-ppss)))) - (< 0 (syntax-ppss-depth - (save-excursion ; syntax-ppss with arg changes point - (syntax-ppss (line-beginning-position))))))) +comments and strings, or that point is within brackets/parens." + (or (python-backslash-continuation-line-p) + (let ((depth (syntax-ppss-depth + (save-excursion ; syntax-ppss with arg changes point + (syntax-ppss (line-beginning-position)))))) + (or (> depth 0) + (if (< depth 0) ; Unbalanced brackets -- act locally + (save-excursion + (condition-case () + (progn (backward-up-list) t) ; actually within brackets + (error nil)))))))) (defun python-comment-line-p () "Return non-nil iff current line has only a comment." @@ -304,6 +351,12 @@ (back-to-indentation) (looking-at (rx (or (syntax comment-start) line-end)))))) +(defun python-blank-line-p () + "Return non-nil iff current line is blank." + (save-excursion + (beginning-of-line) + (looking-at "\\s-*$"))) + (defun python-beginning-of-string () "Go to beginning of string around point. Do nothing if not in string." @@ -316,50 +369,33 @@ BOS non-nil means point is known to be at beginning of statement." (save-excursion (unless bos (python-beginning-of-statement)) - (and (not (python-comment-line-p)) - (re-search-forward (rx (and ?: (0+ space) - (optional (and (syntax comment-start) - (0+ not-newline))) - line-end)) - (save-excursion (python-end-of-statement)) - t) - (not (progn (goto-char (match-beginning 0)) - (python-in-string/comment)))))) + (looking-at (rx (and (or "if" "else" "elif" "while" "for" "def" + "class" "try" "except" "finally") + symbol-end))))) (defun python-close-block-statement-p (&optional bos) "Return non-nil if current line is a statement closing a block. BOS non-nil means point is at beginning of statement. -The criteria are that the line isn't a comment or in string and starts with -keyword `raise', `break', `continue' or `pass'." +The criteria are that the line isn't a comment or in string and + starts with keyword `raise', `break', `continue' or `pass'." (save-excursion (unless bos (python-beginning-of-statement)) (back-to-indentation) - (looking-at (rx (and (or "return" "raise" "break" "continue" "pass") - symbol-end))))) + (looking-at (rx (or "return" "raise" "break" "continue" "pass") + symbol-end)))) (defun python-outdent-p () "Return non-nil if current line should outdent a level." (save-excursion (back-to-indentation) - (and (looking-at (rx (and (or (and (or "else" "finally") symbol-end) - (and (or "except" "elif") symbol-end - (1+ (not (any ?:))))) - (optional space) ":" (optional space) - (or (syntax comment-start) line-end)))) - (progn (end-of-line) - (not (python-in-string/comment))) + (and (looking-at (rx (and (or "else" "finally" "except" "elif") + symbol-end))) + (not (python-in-string/comment)) ;; Ensure there's a previous statement and move to it. (zerop (python-previous-statement)) (not (python-close-block-statement-p t)) ;; Fixme: check this - (not (looking-at (rx (and (or (and (or "if" "elif" "except" - "for" "while") - symbol-end (1+ (not (any ?:)))) - (and "try" symbol-end)) - (optional space) ":" (optional space) - (or (syntax comment-start) line-end))))) - (progn (end-of-line) - (not (python-in-string/comment)))))) + (not (python-open-block-statement-p))))) ;;;; Indentation. @@ -377,22 +413,26 @@ (defcustom python-indent-string-contents t "*Non-nil means indent contents of multi-line strings together. This means indent them the same as the preceding non-blank line. -Otherwise indent them to column zero." +Otherwise preserve their indentation. + +This only applies to `doc' strings, i.e. those that form statements; +the indentation is preserved in others." :type '(choice (const :tag "Align with preceding" t) - (const :tag "Indent to column 0" nil)) + (const :tag "Preserve indentation" nil)) :group 'python) (defcustom python-honour-comment-indentation nil "Non-nil means indent relative to preceding comment line. -Only do this for comments where the leading comment character is followed -by space. This doesn't apply to comment lines, which are always indented -in lines with preceding comments." +Only do this for comments where the leading comment character is +followed by space. This doesn't apply to comment lines, which +are always indented in lines with preceding comments." :type 'boolean :group 'python) (defcustom python-continuation-offset 4 "*Number of columns of additional indentation for continuation lines. -Continuation lines follow a backslash-terminated line starting a statement." +Continuation lines follow a backslash-terminated line starting a +statement." :group 'python :type 'integer) @@ -406,9 +446,9 @@ (goto-char (point-min)) (let (done indent) (while (and (not done) (not (eobp))) - (when (and (re-search-forward (rx (and ?: (0+ space) - (or (syntax comment-start) - line-end))) + (when (and (re-search-forward (rx ?: (0+ space) + (or (syntax comment-start) + line-end)) nil 'move) (python-open-block-statement-p)) (save-excursion @@ -425,8 +465,21 @@ (setq indent-tabs-mode nil))) indent))))) +;; Alist of possible indentations and start of statement they would +;; close. Used in indentation cycling (below). +(defvar python-indent-list nil + "Internal use.") +;; Length of the above +(defvar python-indent-list-length nil + "Internal use.") +;; Current index into the alist. +(defvar python-indent-index nil + "Internal use.") + (defun python-calculate-indentation () "Calculate Python indentation for line at point." + (setq python-indent-list nil + python-indent-list-length 1) (save-excursion (beginning-of-line) (let ((syntax (syntax-ppss)) @@ -434,17 +487,25 @@ (cond ((eq 'string (syntax-ppss-context syntax)) ; multi-line string (if (not python-indent-string-contents) - 0 - (save-excursion + (current-indentation) + ;; Only respect `python-indent-string-contents' in doc + ;; strings (defined as those which form statements). + (if (not (save-excursion + (python-beginning-of-statement) + (looking-at (rx (or (syntax string-delimiter) + (syntax string-quote)))))) + (current-indentation) ;; Find indentation of preceding non-blank line within string. (setq start (nth 8 syntax)) (forward-line -1) (while (and (< start (point)) (looking-at "\\s-*$")) (forward-line -1)) (current-indentation)))) - ((python-continuation-line-p) + ((python-continuation-line-p) ; after backslash, or bracketed (let ((point (point)) - (open-start (cadr syntax))) + (open-start (cadr syntax)) + (backslash (python-backslash-continuation-line-p)) + (colon (eq ?: (char-before (1- (line-beginning-position)))))) (if open-start ;; Inside bracketed expression. (progn @@ -458,7 +519,11 @@ (backward-sexp) (< (point) point)) (error nil)))) - (current-column) + ;; Extra level if we're backslash-continued or + ;; following a key. + (if (or backslash colon) + (+ python-indent (current-column)) + (current-column)) ;; Otherwise indent relative to statement start, one ;; level per bracketing level. (goto-char (1+ open-start)) @@ -472,16 +537,15 @@ (current-indentation) ;; First continuation line. Indent one step, with an ;; extra one if statement opens a block. - (save-excursion - (python-beginning-of-statement) - (+ (current-indentation) python-continuation-offset - (if (python-open-block-statement-p t) - python-indent - 0))))))) + (python-beginning-of-statement) + (+ (current-indentation) python-continuation-offset + (if (python-open-block-statement-p t) + python-indent + 0)))))) ((bobp) 0) ;; Fixme: Like python-mode.el; not convinced by this. - ((looking-at (rx (and (0+ space) (syntax comment-start) - (not (any " \t\n"))))) ; non-indentable comment + ((looking-at (rx (0+ space) (syntax comment-start) + (not (any " \t\n")))) ; non-indentable comment (current-indentation)) (t (let ((point (point))) (if python-honour-comment-indentation @@ -498,86 +562,129 @@ (python-beginning-of-statement) t) ;; indentable comment like python-mode.el - ((and (looking-at (rx (and (syntax comment-start) - (or space line-end)))) + ((and (looking-at (rx (syntax comment-start) + (or space line-end))) (/= 0 (current-column))))) - (throw 'done t)))) - ;; Else back over all comments. - (python-skip-comments/blanks t) - (python-beginning-of-statement)) - ;; don't lose on bogus outdent - (max 0 (+ (current-indentation) - (or (cond ((python-open-block-statement-p t) - python-indent) - ((python-close-block-statement-p t) - (- python-indent))) - (progn (goto-char point) - (if (python-outdent-p) - (- python-indent))) - 0))))))))) - -(defun python-comment-indent () - "`comment-indent-function' for Python." - ;; If previous non-blank line was a comment, use its indentation. - ;; FIXME: This seems unnecessary since the default code delegates to - ;; indent-according-to-mode. --Stef - (unless (bobp) - (save-excursion - (forward-comment -1) - (if (eq ?# (char-after)) (current-column))))) + (throw 'done t))))) + (python-indentation-levels) + ;; Prefer to indent comments with an immediately-following + ;; statement, e.g. + ;; ... + ;; # ... + ;; def ... + (when (and (> python-indent-list-length 1) + (python-comment-line-p)) + (forward-line) + (unless (python-comment-line-p) + (let ((elt (assq (current-indentation) python-indent-list))) + (setq python-indent-list + (nconc (delete elt python-indent-list) + (list elt)))))) + (caar (last python-indent-list)))))))) ;;;; Cycling through the possible indentations with successive TABs. ;; These don't need to be buffer-local since they're only relevant ;; during a cycle. -;; Alist of possible indentations and start of statement they would close. -(defvar python-indent-list nil - "Internal use.") -;; Length of the above -(defvar python-indent-list-length nil - "Internal use.") -;; Current index into the alist. -(defvar python-indent-index nil - "Internal use.") - (defun python-initial-text () "Text of line following indentation and ignoring any trailing comment." - (buffer-substring (+ (line-beginning-position) (current-indentation)) - (save-excursion - (end-of-line) - (forward-comment -1) - (point)))) + (save-excursion + (buffer-substring (progn + (back-to-indentation) + (point)) + (progn + (end-of-line) + (forward-comment -1) + (point))))) + +(defconst python-block-pairs + '(("else" "if" "elif" "while" "for" "try" "except") + ("elif" "if" "elif") + ("except" "try" "except") + ("finally" "try")) + "Alist of keyword matches. +The car of an element is a keyword introducing a statement which +can close a block opened by a keyword in the cdr.") + +(defun python-first-word () + "Return first word (actually symbol) on the line." + (save-excursion + (back-to-indentation) + (current-word t))) (defun python-indentation-levels () "Return a list of possible indentations for this line. +It is assumed not to be a continuation line or in a multi-line string. Includes the default indentation and those which would close all -enclosing blocks. Assumes the line has already been indented per -`python-indent-line'. Elements of the list are actually pairs: +enclosing blocks. Elements of the list are actually pairs: \(INDENTATION . TEXT), where TEXT is the initial text of the corresponding block opening (or nil)." (save-excursion - (let ((levels (list (cons (current-indentation) - (save-excursion - (if (python-beginning-of-block) - (python-initial-text))))))) - ;; Only one possibility if we immediately follow a block open or - ;; are in a continuation line. - (unless (or (python-continuation-line-p) - (save-excursion (and (python-previous-statement) - (python-open-block-statement-p t)))) - (while (python-beginning-of-block) - (push (cons (current-indentation) (python-initial-text)) - levels))) - levels))) + (let ((initial "") + levels indent) + ;; Only one possibility immediately following a block open + ;; statement, assuming it doesn't have a `suite' on the same line. + (cond + ((save-excursion (and (python-previous-statement) + (python-open-block-statement-p t) + (setq indent (current-indentation)) + ;; Check we don't have something like: + ;; if ...: ... + (if (progn (python-end-of-statement) + (python-skip-comments/blanks t) + (eq ?: (char-before))) + (setq indent (+ python-indent indent))))) + (push (cons indent initial) levels)) + ;; Only one possibility for comment line immediately following + ;; another. + ((save-excursion + (when (python-comment-line-p) + (forward-line -1) + (if (python-comment-line-p) + (push (cons (current-indentation) initial) levels))))) + ;; Fixme: Maybe have a case here which indents (only) first + ;; line after a lambda. + (t + (let ((start (car (assoc (python-first-word) python-block-pairs)))) + (python-previous-statement) + ;; Is this a valid indentation for the line of interest? + (unless (or (if start ; potentially only outdentable + ;; Check for things like: + ;; if ...: ... + ;; else ...: + ;; where the second line need not be outdented. + (not (member (python-first-word) + (cdr (assoc start + python-block-pairs))))) + ;; Not sensible to indent to the same level as + ;; previous `return' &c. + (python-close-block-statement-p)) + (push (cons (current-indentation) (python-initial-text)) + levels)) + (while (python-beginning-of-block) + (when (or (not start) + (member (python-first-word) + (cdr (assoc start python-block-pairs)))) + (push (cons (current-indentation) (python-initial-text)) + levels)))))) + (prog1 (or levels (setq levels '((0 . "")))) + (setq python-indent-list levels + python-indent-list-length (length python-indent-list)))))) ;; This is basically what `python-indent-line' would be if we didn't ;; do the cycling. -(defun python-indent-line-1 () - "Subroutine of `python-indent-line'." +(defun python-indent-line-1 (&optional leave) + "Subroutine of `python-indent-line'. +Does non-repeated indentation. LEAVE non-nil means leave +indentation if it is valid, i.e. one of the positions returned by +`python-calculate-indentation'." (let ((target (python-calculate-indentation)) (pos (- (point-max) (point)))) - (if (= target (current-indentation)) + (if (or (= target (current-indentation)) + ;; Maybe keep a valid indentation. + (and leave python-indent-list + (assq (current-indentation) python-indent-list))) (if (< (current-column) (current-indentation)) (back-to-indentation)) (beginning-of-line) @@ -589,29 +696,41 @@ (defun python-indent-line () "Indent current line as Python code. When invoked via `indent-for-tab-command', cycle through possible -indentations for current line. The cycle is broken by a command different -from `indent-for-tab-command', i.e. successive TABs do the cycling." +indentations for current line. The cycle is broken by a command +different from `indent-for-tab-command', i.e. successive TABs do +the cycling." (interactive) - ;; Don't do extra work if invoked via `indent-region', for instance. - (if (not (eq this-command 'indent-for-tab-command)) - (python-indent-line-1) - (if (eq last-command this-command) - (if (= 1 python-indent-list-length) - (message "Sole indentation") - (progn (setq python-indent-index (% (1+ python-indent-index) - python-indent-list-length)) - (beginning-of-line) - (delete-horizontal-space) - (indent-to (car (nth python-indent-index python-indent-list))) - (if (python-block-end-p) - (let ((text (cdr (nth python-indent-index - python-indent-list)))) - (if text - (message "Closes: %s" text)))))) - (python-indent-line-1) - (setq python-indent-list (python-indentation-levels) - python-indent-list-length (length python-indent-list) - python-indent-index (1- python-indent-list-length))))) + (if (and (eq this-command 'indent-for-tab-command) + (eq last-command this-command)) + (if (= 1 python-indent-list-length) + (message "Sole indentation") + (progn (setq python-indent-index + (% (1+ python-indent-index) python-indent-list-length)) + (beginning-of-line) + (delete-horizontal-space) + (indent-to (car (nth python-indent-index python-indent-list))) + (if (python-block-end-p) + (let ((text (cdr (nth python-indent-index + python-indent-list)))) + (if text + (message "Closes: %s" text)))))) + (python-indent-line-1) + (setq python-indent-index (1- python-indent-list-length)))) + +(defun python-indent-region (start end) + "`indent-region-function' for Python. +Leaves validly-indented lines alone, i.e. doesn't indent to +another valid position." + (save-excursion + (goto-char end) + (setq end (point-marker)) + (goto-char start) + (or (bolp) (forward-line 1)) + (while (< (point) end) + (or (and (bolp) (eolp)) + (python-indent-line-1 t)) + (forward-line 1)) + (move-marker end nil))) (defun python-block-end-p () "Non-nil if this is a line in a statement closing a block, @@ -622,23 +741,20 @@ (save-excursion (python-previous-statement) (current-indentation)))))) - -;; Fixme: Define an indent-region-function. It should probably leave -;; lines alone if the indentation is already at one of the allowed -;; levels. Otherwise, M-C-\ typically keeps indenting more deeply -;; down a function. ;;;; Movement. +;; Fixme: Define {for,back}ward-sexp-function? Maybe skip units like +;; block, statement, depending on context. + (defun python-beginning-of-defun () "`beginning-of-defun-function' for Python. Finds beginning of innermost nested class or method definition. -Returns the name of the definition found at the end, or nil if reached -start of buffer." +Returns the name of the definition found at the end, or nil if +reached start of buffer." (let ((ci (current-indentation)) - (def-re (rx (and line-start (0+ space) (or "def" "class") - (1+ space) - (group (1+ (or word (syntax symbol))))))) + (def-re (rx line-start (0+ space) (or "def" "class") (1+ space) + (group (1+ (or word (syntax symbol)))))) found lep def-line) (if (python-comment-line-p) (setq ci most-positive-fixnum)) @@ -652,10 +768,14 @@ ;; Must be less indented or matching top level, or ;; equally indented if we started on a definition line. (let ((in (current-indentation))) - (or (and (zerop ci) (zerop in)) - (= lep (line-end-position)) ; on initial line - (and def-line (= in ci)) - (< in ci))) + (or (and (zerop ci) (zerop in)) + (= lep (line-end-position)) ; on initial line + ;; Not sure why it was like this -- fails in case of + ;; last internal function followed by first + ;; non-def statement of the main body. +;; (and def-line (= in ci)) + (= in ci) + (< in ci))) (not (python-in-string/comment))) (setq found t))))) @@ -663,7 +783,7 @@ "`end-of-defun-function' for Python. Finds end of innermost nested class or method definition." (let ((orig (point)) - (pattern (rx (and line-start (0+ space) (or "def" "class") space)))) + (pattern (rx line-start (0+ space) (or "def" "class") space))) ;; Go to start of current block and check whether it's at top ;; level. If it is, and not a block start, look forward for ;; definition statement. @@ -692,8 +812,9 @@ (python-end-of-block) ;; Count trailing space in defun (but not trailing comments). (skip-syntax-forward " >") - (beginning-of-line)) - ;; Catch pathological case like this, where the beginning-of-defun + (unless (eobp) ; e.g. missing final newline + (beginning-of-line))) + ;; Catch pathological cases like this, where the beginning-of-defun ;; skips to a definition we're not in: ;; if ...: ;; ... @@ -706,26 +827,43 @@ (defun python-beginning-of-statement () "Go to start of current statement. -Accounts for continuation lines, multi-line strings, and multi-line bracketed -expressions." +Accounts for continuation lines, multi-line strings, and +multi-line bracketed expressions." (beginning-of-line) (python-beginning-of-string) - (catch 'foo - (while (python-continuation-line-p) - (beginning-of-line) - (if (python-backslash-continuation-line-p) + (while (python-continuation-line-p) + (beginning-of-line) + (if (python-backslash-continuation-line-p) + (progn + (forward-line -1) (while (python-backslash-continuation-line-p) - (forward-line -1)) - (python-beginning-of-string) - ;; Skip forward out of nested brackets. - (condition-case () ; beware invalid syntax - (let ((depth (syntax-ppss-depth (syntax-ppss)))) - ;; Beware negative depths. - (if (> depth 0) (backward-up-list depth)) - t) - (error (throw 'foo nil)))))) + (forward-line -1))) + (python-beginning-of-string) + (python-skip-out))) (back-to-indentation)) +(defun python-skip-out (&optional forward syntax) + "Skip out of any nested brackets. +Skip forward if FORWARD is non-nil, else backward. +If SYNTAX is non-nil it is the state returned by `syntax-ppss' at point. +Return non-nil iff skipping was done." + (let ((depth (syntax-ppss-depth (or syntax (syntax-ppss)))) + (forward (if forward -1 1))) + (unless (zerop depth) + (if (> depth 0) + ;; Skip forward out of nested brackets. + (condition-case () ; beware invalid syntax + (progn (backward-up-list (* forward depth)) t) + (error nil)) + ;; Invalid syntax (too many closed brackets). + ;; Skip out of as many as possible. + (let (done) + (while (condition-case () + (progn (backward-up-list forward) + (setq done t)) + (error nil))) + done))))) + (defun python-end-of-statement () "Go to the end of the current statement and return point. Usually this is the start of the next line, but if this is a @@ -745,13 +883,7 @@ (condition-case () ; beware invalid syntax (progn (forward-sexp) t) (error (end-of-line)))) - ((> (syntax-ppss-depth s) 0) - ;; Skip forward out of nested brackets. - (condition-case () ; beware invalid syntax - (progn (backward-up-list - (- (syntax-ppss-depth s))) - t) - (error (end-of-line)))))) + ((python-skip-out t s)))) (end-of-line)) (unless comment (eq ?\\ (char-before)))) ; Line continued? @@ -785,7 +917,8 @@ (while (and (> count 0) (not (eobp))) (python-end-of-statement) (python-skip-comments/blanks) - (setq count (1- count))) + (unless (eobp) + (setq count (1- count)))) count)) (defun python-beginning-of-block (&optional arg) @@ -802,7 +935,8 @@ ((< arg 0) (python-end-of-block (- arg))) (t (let ((point (point))) - (if (python-comment-line-p) + (if (or (python-comment-line-p) + (python-blank-line-p)) (python-skip-comments/blanks t)) (python-beginning-of-statement) (let ((ci (current-indentation))) @@ -830,32 +964,31 @@ (defun python-end-of-block (&optional arg) "Go to end of current block. -With numeric arg, do it that many times. If ARG is negative, call -`python-beginning-of-block' instead. -If current statement is in column zero and doesn't open a block, don't -move and return nil. Otherwise return t." +With numeric arg, do it that many times. If ARG is negative, +call `python-beginning-of-block' instead. +If current statement is in column zero and doesn't open a block, +don't move and return nil. Otherwise return t." (interactive "p") (unless arg (setq arg 1)) (if (< arg 0) - (python-beginning-of-block (- arg))) - (while (and (> arg 0) - (let* ((point (point)) - (_ (if (python-comment-line-p) - (python-skip-comments/blanks t))) - (ci (current-indentation)) - (open (python-open-block-statement-p))) - (if (and (zerop ci) (not open)) - (not (goto-char point)) - (catch 'done - (while (zerop (python-next-statement)) - (when (or (and open (<= (current-indentation) ci)) - (< (current-indentation) ci)) - (python-skip-comments/blanks t) - (beginning-of-line 2) - (throw 'done t))) - (not (goto-char point)))))) - (setq arg (1- arg))) - (zerop arg)) + (python-beginning-of-block (- arg)) + (while (and (> arg 0) + (let* ((point (point)) + (_ (if (python-comment-line-p) + (python-skip-comments/blanks t))) + (ci (current-indentation)) + (open (python-open-block-statement-p))) + (if (and (zerop ci) (not open)) + (not (goto-char point)) + (catch 'done + (while (zerop (python-next-statement)) + (when (or (and open (<= (current-indentation) ci)) + (< (current-indentation) ci)) + (python-skip-comments/blanks t) + (beginning-of-line 2) + (throw 'done t))))))) + (setq arg (1- arg))) + (zerop arg))) ;;;; Imenu. @@ -868,14 +1001,23 @@ definition; it has a space prepended to the name so that it sorts first with `imenu--sort-by-name' (though, unfortunately, sub-menus precede it)." - (unless (boundp 'python-recursing) ; dynamically bound below - (goto-char (point-min))) ; normal call from Imenu - (let (index-alist ; accumulated value to return - name) + (unless (boundp 'python-recursing) ; dynamically bound below + ;; Normal call from Imenu. + (goto-char (point-min)) + ;; Without this, we can get an infloop if the buffer isn't all + ;; fontified. I guess this is really a bug in syntax.el. OTOH, + ;; _with_ this, imenu doesn't immediately work; I can't figure out + ;; what's going on, but it must be something to do with timers in + ;; font-lock. + ;; This can't be right, especially not when jit-lock is not used. --Stef + ;; (unless (get-text-property (1- (point-max)) 'fontified) + ;; (font-lock-fontify-region (point-min) (point-max))) + ) + (let (index-alist) ; accumulated value to return (while (re-search-forward - (rx (and line-start (0+ space) ; leading space - (or (group "def") (group "class")) ; type - (1+ space) (group (1+ (or word ?_))))) ; name + (rx line-start (0+ space) ; leading space + (or (group "def") (group "class")) ; type + (1+ space) (group (1+ (or word ?_)))) ; name nil t) (unless (python-in-string/comment) (let ((pos (match-beginning 0)) @@ -890,7 +1032,22 @@ (progn (push (cons (concat " " name) pos) sublist) (push (cons name sublist) index-alist)) (push (cons name pos) index-alist))))))) - (nreverse index-alist))) + (unless (boundp 'python-recursing) + ;; Look for module variables. + (let (vars) + (goto-char (point-min)) + (while (re-search-forward + (rx line-start (group (1+ (or word ?_))) (0+ space) "=") + nil t) + (unless (python-in-string/comment) + (push (cons (match-string 1) (match-beginning 1)) + vars))) + (setq index-alist (nreverse index-alist)) + (if vars + (push (cons "Module variables" + (nreverse vars)) + index-alist)))) + index-alist)) ;;;; `Electric' commands. @@ -910,20 +1067,26 @@ (defun python-backspace (arg) "Maybe delete a level of indentation on the current line. -If not at the end of line's indentation, or on a comment line, just call -`backward-delete-char-untabify'. With ARG, repeat that many times." +Do so if point is at the end of the line's indentation. +Otherwise just call `backward-delete-char-untabify'. +Repeat ARG times." (interactive "*p") (if (or (/= (current-indentation) (current-column)) (bolp) (python-continuation-line-p)) (backward-delete-char-untabify arg) - (let ((indent 0)) - (save-excursion - (while (and (> arg 0) (python-beginning-of-block)) - (setq arg (1- arg))) - (when (zerop arg) - (setq indent (current-indentation)) - (message "Closes %s" (python-initial-text)))) + ;; Look for the largest valid indentation which is smaller than + ;; the current indentation. + (let ((indent 0) + (ci (current-indentation)) + (indents (python-indentation-levels)) + initial) + (dolist (x indents) + (if (< (car x) ci) + (setq indent (max indent (car x))))) + (setq initial (cdr (assq indent indents))) + (if (> (length initial) 0) + (message "Closes %s" initial)) (delete-horizontal-space) (indent-to indent)))) (put 'python-backspace 'delete-selection 'supersede) @@ -965,8 +1128,8 @@ (defcustom python-python-command "python" "*Shell command to run Python interpreter. Any arguments can't contain whitespace. -Note that IPython may not work properly; it must at least be used with the -`-cl' flag, i.e. use `ipython -cl'." +Note that IPython may not work properly; it must at least be used +with the `-cl' flag, i.e. use `ipython -cl'." :group 'python :type 'string) @@ -978,51 +1141,39 @@ (defvar python-command python-python-command "Actual command used to run Python. -May be `python-python-command' or `python-jython-command'. -Additional arguments are added when the command is used by `run-python' -et al.") +May be `python-python-command' or `python-jython-command', possibly +modified by the user. Additional arguments are added when the command +is used by `run-python' et al.") (defvar python-buffer nil - "The current python process buffer." - ;; Fixme: a single process is currently assumed, so that this doc - ;; is misleading. + "*The current python process buffer. -;; "*The current python process buffer. -;; To run multiple Python processes, start the first with \\[run-python]. -;; It will be in a buffer named *Python*. Rename that with -;; \\[rename-buffer]. Now start a new process with \\[run-python]. It -;; will be in a new buffer, named *Python*. Switch between the different -;; process buffers with \\[switch-to-buffer]. +Commands that send text from source buffers to Python processes have +to choose a process to send to. This is determined by buffer-local +value of `python-buffer'. If its value in the current buffer, +i.e. both any local value and the default one, is nil, `run-python' +and commands that send to the Python process will start a new process. -;; Commands that send text from source buffers to Python processes have -;; to choose a process to send to. This is determined by global variable -;; `python-buffer'. Suppose you have three inferior Pythons running: -;; Buffer Process -;; foo python -;; bar python<2> -;; *Python* python<3> -;; If you do a \\[python-send-region-and-go] command on some Python source -;; code, what process does it go to? +Whenever \\[run-python] starts a new process, it resets the default +value of `python-buffer' to be the new process's buffer and sets the +buffer-local value similarly if the current buffer is in Python mode +or Inferior Python mode, so that source buffer stays associated with a +specific sub-process. -;; - In a process buffer (foo, bar, or *Python*), send it to that process. -;; - In some other buffer (e.g. a source file), send it to the process -;; attached to `python-buffer'. -;; Process selection is done by function `python-proc'. - -;; Whenever \\[run-python] starts a new process, it resets `python-buffer' -;; to be the new process's buffer. If you only run one process, this will -;; do the right thing. If you run multiple processes, you can change -;; `python-buffer' to another process buffer with \\[set-variable]." - ) +Use \\[python-set-proc] to set the default value from a buffer with a +local value.") +(make-variable-buffer-local 'python-buffer) (defconst python-compilation-regexp-alist ;; FIXME: maybe these should move to compilation-error-regexp-alist-alist. - `((,(rx (and line-start (1+ (any " \t")) "File \"" - (group (1+ (not (any "\"<")))) ; avoid `' &c - "\", line " (group (1+ digit)))) + ;; The first already is (for CAML), but the second isn't. Anyhow, + ;; these are specific to the inferior buffer. -- fx + `((,(rx line-start (1+ (any " \t")) "File \"" + (group (1+ (not (any "\"<")))) ; avoid `' &c + "\", line " (group (1+ digit))) 1 2) - (,(rx (and " in file " (group (1+ not-newline)) " on line " - (group (1+ digit)))) + (,(rx " in file " (group (1+ not-newline)) " on line " + (group (1+ digit))) 1 2)) "`compilation-error-regexp-alist' for inferior Python.") @@ -1040,9 +1191,9 @@ ;; (define-key map "\C-c\C-f" 'python-describe-symbol) map)) -;; Fixme: This should inherit some stuff from python-mode, but I'm not -;; sure how much: at least some keybindings, like C-c C-f; syntax?; -;; font-locking, e.g. for triple-quoted strings? +;; Fixme: This should inherit some stuff from `python-mode', but I'm +;; not sure how much: at least some keybindings, like C-c C-f; +;; syntax?; font-locking, e.g. for triple-quoted strings? (define-derived-mode inferior-python-mode comint-mode "Inferior Python" "Major mode for interacting with an inferior Python process. A Python process can be started with \\[run-python]. @@ -1050,14 +1201,15 @@ Hooks `comint-mode-hook' and `inferior-python-mode-hook' are run in that order. -You can send text to the inferior Python process from other buffers containing -Python source. - * `python-switch-to-python' switches the current buffer to the Python +You can send text to the inferior Python process from other buffers +containing Python source. + * \\[python-switch-to-python] switches the current buffer to the Python process buffer. - * `python-send-region' sends the current region to the Python process. - * `python-send-region-and-go' switches to the Python process buffer + * \\[python-send-region] sends the current region to the Python process. + * \\[python-send-region-and-go] switches to the Python process buffer after sending the text. -For running multiple processes in multiple buffers, see `python-buffer'. +For running multiple processes in multiple buffers, see `run-python' and +`python-buffer'. \\{inferior-python-mode-map}" :group 'python @@ -1069,7 +1221,7 @@ ;; Still required by `comint-redirect-send-command', for instance ;; (and we need to match things like `>>> ... >>> '): (set (make-local-variable 'comint-prompt-regexp) - (rx (and line-start (1+ (and (repeat 3 (any ">.")) ?\s))))) + (rx line-start (1+ (and (repeat 3 (any ">.")) " ")))) (set (make-local-variable 'compilation-error-regexp-alist) python-compilation-regexp-alist) (compilation-shell-minor-mode 1)) @@ -1112,12 +1264,16 @@ (when python-preoutput-leftover (setq s (concat python-preoutput-leftover s)) (setq python-preoutput-leftover nil)) - (cond ((and (string-match (rx (and string-start (repeat 3 (any ".>")) - " " string-end)) + (cond ((and (string-match (rx string-start (repeat 3 (any ".>")) + " " string-end) s) (/= (let ((inhibit-field-text-motion t)) (line-beginning-position)) (point))) + ;; The need for this seems to be system-dependent: + ;; What is this all about, exactly? --Stef + ;; (if (and (eq ?. (aref s 0))) + ;; (accept-process-output (get-buffer-process (current-buffer)) 1)) "") ((string= s "_emacs_ok\n") (when python-preoutput-continuation @@ -1136,60 +1292,82 @@ "") (t s))) +(autoload 'comint-check-proc "comint") + ;;;###autoload -(defun run-python (&optional cmd noshow) +(defun run-python (&optional cmd noshow new) "Run an inferior Python process, input and output via buffer *Python*. CMD is the Python command to run. NOSHOW non-nil means don't show the buffer automatically. -If there is a process already running in `*Python*', switch to -that buffer. Interactively, a prefix arg allows you to edit the initial -command line (default is `python-command'); `-i' etc. args will be added -to this as appropriate. Runs the hook `inferior-python-mode-hook' -\(after the `comint-mode-hook' is run). -\(Type \\[describe-mode] in the process buffer for a list of commands.)" - (interactive (list (if current-prefix-arg - (read-string "Run Python: " python-command) - python-command))) + +Normally, if there is a process already running in `python-buffer', +switch to that buffer. Interactively, a prefix arg allows you to edit +the initial command line (default is `python-command'); `-i' etc. args +will be added to this as appropriate. A new process is started if: +one isn't running attached to `python-buffer', or interactively the +default `python-command', or argument NEW is non-nil. See also the +documentation for `python-buffer'. + +Runs the hook `inferior-python-mode-hook' \(after the +`comint-mode-hook' is run). \(Type \\[describe-mode] in the process +buffer for a list of commands.)" + (interactive (if current-prefix-arg + (list (read-string "Run Python: " python-command) nil t) + (list python-command))) (unless cmd (setq cmd python-python-command)) (setq python-command cmd) ;; Fixme: Consider making `python-buffer' buffer-local as a buffer ;; (not a name) in Python buffers from which `run-python' &c is ;; invoked. Would support multiple processes better. - (unless (comint-check-proc python-buffer) - (let* ((cmdlist (append (python-args-to-list cmd) '("-i"))) - (path (getenv "PYTHONPATH")) - (process-environment ; to import emacs.py - (cons (concat "PYTHONPATH=" data-directory - (if path (concat ":" path))) - process-environment))) - (set-buffer (apply 'make-comint "Python" (car cmdlist) nil - (cdr cmdlist))) - (setq python-buffer (buffer-name))) - (inferior-python-mode) - ;; Load function defintions we need. - ;; Before the preoutput function was used, this was done via -c in - ;; cmdlist, but that loses the banner and doesn't run the startup - ;; file. The code might be inline here, but there's enough that it - ;; seems worth putting in a separate file, and it's probably cleaner - ;; to put it in a module. - (python-send-string "import emacs")) - (unless noshow (pop-to-buffer python-buffer))) + (when (or new (not (comint-check-proc python-buffer))) + (save-current-buffer + (let* ((cmdlist (append (python-args-to-list cmd) '("-i"))) + (path (getenv "PYTHONPATH")) + (process-environment ; to import emacs.py + (cons (concat "PYTHONPATH=" data-directory + (if path (concat ":" path))) + process-environment))) + (set-buffer (apply 'make-comint-in-buffer "Python" + (generate-new-buffer "*Python*") + (car cmdlist) nil (cdr cmdlist))) + (setq-default python-buffer (current-buffer)) + (setq python-buffer (current-buffer))) + (accept-process-output (get-buffer-process python-buffer) 5) + (inferior-python-mode))) + (if (eq 'python-mode major-mode) + (setq python-buffer (default-value 'python-buffer))) ; buffer-local + ;; Load function definitions we need. + ;; Before the preoutput function was used, this was done via -c in + ;; cmdlist, but that loses the banner and doesn't run the startup + ;; file. The code might be inline here, but there's enough that it + ;; seems worth putting in a separate file, and it's probably cleaner + ;; to put it in a module. + (python-send-string "import emacs") + ;; Ensure we're at a prompt before doing anything else. + (python-send-receive "print '_emacs_out ()'") + ;; Without this, help output goes into the inferior python buffer if + ;; the process isn't already running. + (sit-for 1 t) ;Should we use accept-process-output instead? --Stef + (unless noshow (pop-to-buffer python-buffer t))) ;; Fixme: We typically lose if the inferior isn't in the normal REPL, ;; e.g. prompt is `help> '. Probably raise an error if the form of -;; the prompt is unexpected; actually, it needs to be `>>> ', not +;; the prompt is unexpected. Actually, it needs to be `>>> ', not ;; `... ', i.e. we're not inputting a block &c. However, this may not -;; be the place to do it, e.g. we might actually want to send commands -;; having set up such a state. +;; be the place to check it, e.g. we might actually want to send +;; commands having set up such a state. (defun python-send-command (command) - "Like `python-send-string' but resets `compilation-minor-mode'." - (goto-char (point-max)) + "Like `python-send-string' but resets `compilation-shell-minor-mode'." (let ((end (marker-position (process-mark (python-proc))))) + (with-current-buffer python-buffer (goto-char (point-max))) (compilation-forget-errors) (python-send-string command) - (set-marker compilation-parsing-end end) - (setq compilation-last-buffer (current-buffer)))) + ;; Must wait until this has completed before re-setting variables below. + (python-send-receive "print '_emacs_out ()'") + (with-current-buffer python-buffer + (set-marker compilation-parsing-end end) + (setq compilation-last-buffer (current-buffer))))) (defun python-send-region (start end) "Send the region to the inferior Python process." @@ -1202,8 +1380,8 @@ ;; filter). This function also catches exceptions and truncates ;; tracebacks not to mention the frame of the function itself. ;; - ;; The compilation-minor-mode parsing takes care of relating the - ;; reference to the temporary file to the source. + ;; The `compilation-shell-minor-mode' parsing takes care of relating + ;; the reference to the temporary file to the source. ;; ;; Fixme: Write a `coding' header to the temp file if the region is ;; non-ASCII. @@ -1220,11 +1398,11 @@ (set-marker orig-start (line-beginning-position 0))) (write-region "if True:\n" nil f nil 'nomsg)) (write-region start end f t 'nomsg) - (with-current-buffer (process-buffer (python-proc)) ;Runs python if needed. - (python-send-command command) + (python-send-command command) + (with-current-buffer (process-buffer (python-proc)) ;; Tell compile.el to redirect error locations in file `f' to ;; positions past marker `orig-start'. It has to be done *after* - ;; python-send-command's call to compilation-forget-errors. + ;; `python-send-command''s call to `compilation-forget-errors'. (compilation-fake-loc orig-start f)))) (defun python-send-string (string) @@ -1247,10 +1425,10 @@ (progn (end-of-defun) (point))))) (defun python-switch-to-python (eob-p) - "Switch to the Python process buffer. + "Switch to the Python process buffer, maybe starting new process. With prefix arg, position cursor at end of buffer." (interactive "P") - (pop-to-buffer (process-buffer (python-proc))) ;Runs python if needed. + (pop-to-buffer (process-buffer (python-proc)) t) ;Runs python if needed. (when eob-p (push-mark) (goto-char (point-max)))) @@ -1264,9 +1442,9 @@ (defcustom python-source-modes '(python-mode jython-mode) "*Used to determine if a buffer contains Python source code. -If it's loaded into a buffer that is in one of these major modes, it's -considered a Python source file by `python-load-file'. -Used by these commands to determine defaults." +If a file is loaded into a buffer that is in one of these major modes, +it is considered Python source by `python-load-file', which uses the +value to determine defaults." :type '(repeat function) :group 'python) @@ -1274,6 +1452,8 @@ "Caches (directory . file) pair used in the last `python-load-file' command. Used for determining the default in the next one.") +(autoload 'comint-get-source "comint") + (defun python-load-file (file-name) "Load a Python file FILE-NAME into the inferior Python process. If the file has extension `.py' import or reload it as a module. @@ -1297,17 +1477,27 @@ (format "execfile(%S)" file-name))) (message "%s loaded" file-name))) -;; Fixme: If we need to start the process, wait until we've got the OK -;; from the startup. (defun python-proc () "Return the current Python process. See variable `python-buffer'. Starts a new process if necessary." - (or (if python-buffer - (get-buffer-process (if (eq major-mode 'inferior-python-mode) + ;; Fixme: Maybe should look for another active process if there + ;; isn't one for `python-buffer'. + (unless (comint-check-proc python-buffer) + (run-python nil t)) + (get-buffer-process (or (if (eq major-mode 'inferior-python-mode) (current-buffer) - python-buffer))) - (progn (run-python nil t) - (python-proc)))) + python-buffer)))) + +(defun python-set-proc () + "Set the default value of `python-buffer' to correspond to this buffer. +If the current buffer has a local value of `python-buffer', set the +default (global) value to that. The associated Python process is +the one that gets input from \\[python-send-region] et al when used +in a buffer that doesn't have a local value of `python-buffer'." + (interactive) + (if (local-variable-p 'python-buffer) + (setq-default python-buffer python-buffer) + (error "No local value of `python-buffer'"))) ;;;; Context-sensitive help. @@ -1322,16 +1512,22 @@ (defvar view-return-to-alist) (eval-when-compile (autoload 'help-buffer "help-fns")) +(defvar python-imports) ; forward declaration + ;; Fixme: Should this actually be used instead of info-look, i.e. be -;; bound to C-h S? Can we use other pydoc stuff before python 2.2? +;; bound to C-h S? [Probably not, since info-look may work in cases +;; where this doesn't.] (defun python-describe-symbol (symbol) "Get help on SYMBOL using `help'. Interactively, prompt for symbol. -Symbol may be anything recognized by the interpreter's `help' command -- -e.g. `CALLS' -- not just variables in scope. -This only works for Python version 2.2 or newer since earlier interpreters -don't support `help'." +Symbol may be anything recognized by the interpreter's `help' +command -- e.g. `CALLS' -- not just variables in scope in the +interpreter. This only works for Python version 2.2 or newer +since earlier interpreters don't support `help'. + +In some cases where this doesn't find documentation, \\[info-lookup-symbol] +will." ;; Note that we do this in the inferior process, not a separate one, to ;; ensure the environment is appropriate. (interactive @@ -1343,28 +1539,23 @@ "Describe symbol: ") nil nil symbol)))) (if (equal symbol "") (error "No symbol")) - (let* ((func `(lambda () - (comint-redirect-send-command - (format "emacs.ehelp(%S, globals(), locals())\n" ,symbol) - "*Help*" nil)))) - ;; Ensure we have a suitable help buffer. - ;; Fixme: Maybe process `Related help topics' a la help xrefs and - ;; allow C-c C-f in help buffer. - (let ((temp-buffer-show-hook ; avoid xref stuff - (lambda () - (toggle-read-only 1) - (setq view-return-to-alist - (list (cons (selected-window) help-return-method)))))) - (help-setup-xref (list 'python-describe-symbol symbol) (interactive-p)) - (with-output-to-temp-buffer (help-buffer) - (with-current-buffer standard-output - (set (make-local-variable 'comint-redirect-subvert-readonly) t) - (print-help-return-message)))) - (if (and python-buffer (get-buffer python-buffer)) - (with-current-buffer python-buffer - (funcall func)) - (setq python-preoutput-continuation func) - (run-python nil t)))) + ;; Ensure we have a suitable help buffer. + ;; Fixme: Maybe process `Related help topics' a la help xrefs and + ;; allow C-c C-f in help buffer. + (let ((temp-buffer-show-hook ; avoid xref stuff + (lambda () + (toggle-read-only 1) + (setq view-return-to-alist + (list (cons (selected-window) help-return-method)))))) + (with-output-to-temp-buffer (help-buffer) + (with-current-buffer standard-output + ;; Fixme: Is this actually useful? + (help-setup-xref (list 'python-describe-symbol symbol) (interactive-p)) + (set (make-local-variable 'comint-redirect-subvert-readonly) t) + (print-help-return-message)))) + (comint-redirect-send-command-to-process (format "emacs.ehelp(%S, %s)" + symbol python-imports) + "*Help*" (python-proc) nil nil)) (add-to-list 'debug-ignored-errors "^No symbol") @@ -1379,17 +1570,32 @@ python-preoutput-leftover)) python-preoutput-result)) -;; Fixme: try to make it work with point in the arglist. Also, is -;; there anything reasonable we can do with random methods? +;; Fixme: Is there anything reasonable we can do with random methods? ;; (Currently only works with functions.) (defun python-eldoc-function () "`eldoc-print-current-symbol-info' for Python. -Only works when point is in a function name, not its arglist, for instance. -Assumes an inferior Python is running." +Only works when point is in a function name, not its arg list, for +instance. Assumes an inferior Python is running." (let ((symbol (with-syntax-table python-dotty-syntax-table (current-word)))) - (when symbol - (python-send-receive (format "emacs.eargs(%S)" symbol))))) + ;; First try the symbol we're on. + (or (and symbol + (python-send-receive (format "emacs.eargs(%S, %s)" + symbol python-imports))) + ;; Try moving to symbol before enclosing parens. + (let ((s (syntax-ppss))) + (unless (zerop (car s)) + (when (eq ?\( (char-after (nth 1 s))) + (save-excursion + (goto-char (nth 1 s)) + (skip-syntax-backward "-") + (let ((point (point))) + (skip-chars-backward "a-zA-Z._") + (if (< (point) point) + (python-send-receive + (format "emacs.eargs(%S, %s)" + (buffer-substring-no-properties (point) point) + python-imports))))))))))) ;;;; Info-look functionality. @@ -1443,7 +1649,7 @@ ("(python-lib)Miscellaneous Index" nil "")))))) (eval-after-load "info-look" '(python-after-info-look)) -;;;; Miscellancy. +;;;; Miscellany. (defcustom python-jython-packages '("java" "javax" "org" "com") "Packages implying `jython-mode'. @@ -1473,8 +1679,8 @@ (jython-mode) (if (catch 'done (while (re-search-forward - (rx (and line-start (or "import" "from") (1+ space) - (group (1+ (not (any " \t\n.")))))) + (rx line-start (or "import" "from") (1+ space) + (group (1+ (not (any " \t\n."))))) (+ (point-min) 10000) ; Probably not worth customizing. t) (if (member (match-string 1) python-jython-packages) @@ -1562,7 +1768,7 @@ "`outline-level' function for Python mode. The level is the number of `python-indent' steps of indentation of current line." - (/ (current-indentation) python-indent)) + (1+ (/ (current-indentation) python-indent))) ;; Fixme: Consider top-level assignments, imports, &c. (defun python-current-defun () @@ -1577,10 +1783,8 @@ (python-beginning-of-block) (end-of-line) (beginning-of-defun) - (if (looking-at (rx (and (0+ space) (or "def" "class") (1+ space) - (group (1+ (or word (syntax symbol)))) - ;; Greediness makes this unnecessary? --Stef - symbol-end))) + (if (looking-at (rx (0+ space) (or "def" "class") (1+ space) + (group (1+ (or word (syntax symbol)))))) (push (match-string 1) accum))) (if accum (mapconcat 'identity accum "."))))) @@ -1593,17 +1797,68 @@ (push-mark (point) nil t) (python-end-of-block) (exchange-point-and-mark)) + +;; Fixme: Provide a find-function-like command to find source of a +;; definition (separate from BicycleRepairMan). Complicated by +;; finding the right qualified name. ;;;; Completion. +(defvar python-imports nil + "String of top-level import statements updated by `python-find-imports'.") +(make-variable-buffer-local 'python-imports) + +;; Fixme: Should font-lock try to run this when it deals with an import? +;; Maybe not a good idea if it gets run multiple times when the +;; statement is being edited, and is more likely to end up with +;; something syntactically incorrect. +;; However, what we should do is to trundle up the block tree from point +;; to extract imports that appear to be in scope, and add those. +(defun python-find-imports () + "Find top-level imports, updating `python-imports'." + (interactive) + (save-excursion + (let (lines) + (goto-char (point-min)) + (while (re-search-forward "^import\\>\\|^from\\>" nil t) + (unless (syntax-ppss-context (syntax-ppss)) + (push (buffer-substring (line-beginning-position) + (line-beginning-position 2)) + lines))) + (setq python-imports + (if lines + (apply #'concat +;; This is probably best left out since you're unlikely to need the +;; doc for a function in the buffer and the import will lose if the +;; Python sub-process' working directory isn't the same as the +;; buffer's. +;; (if buffer-file-name +;; (concat +;; "import " +;; (file-name-sans-extension +;; (file-name-nondirectory buffer-file-name)))) + (nreverse lines)) + "None")) + (when lines + (set-text-properties 0 (length python-imports) nil python-imports) + ;; The output ends up in the wrong place if the string we + ;; send contains newlines (from the imports). + (setq python-imports + (replace-regexp-in-string "\n" "\\n" + (format "%S" python-imports) t t)))))) + +;; Fixme: This fails the first time if the sub-process isn't already +;; running. Presumably a timing issue with i/o to the process. (defun python-symbol-completions (symbol) "Return a list of completions of the string SYMBOL from Python process. -The list is sorted." +The list is sorted. +Uses `python-imports' to load modules against which to complete." (when symbol (let ((completions (condition-case () - (car (read-from-string (python-send-receive - (format "emacs.complete(%S)" symbol)))) + (car (read-from-string + (python-send-receive + (format "emacs.complete(%S,%s)" symbol python-imports)))) (error nil)))) (sort ;; We can get duplicates from the above -- don't know why. @@ -1615,15 +1870,12 @@ (let ((end (point)) (start (save-excursion (and (re-search-backward - (rx (and (or buffer-start (regexp "[^[:alnum:]._]")) - (group (1+ (regexp "[[:alnum:]._]"))) - point)) + (rx (or buffer-start (regexp "[^[:alnum:]._]")) + (group (1+ (regexp "[[:alnum:]._]"))) point) nil t) (match-beginning 1))))) (if start (buffer-substring-no-properties start end)))) -;; Fixme: We should have an abstraction of this sort of thing in the -;; core. (defun python-complete-symbol () "Perform completion on the Python symbol preceding point. Repeating the command scrolls the completion window." @@ -1658,8 +1910,6 @@ (display-completion-list completions symbol)) (message "Making completion list...%s" "done")))))))) -(eval-when-compile (require 'hippie-exp)) - (defun python-try-complete (old) "Completion function for Python for use with `hippie-expand'." (when (eq major-mode 'python-mode) ; though we only add it locally @@ -1680,16 +1930,211 @@ (if old (he-reset-string)) nil))) +;;;; FFAP support + +(defun python-module-path (module) + "Function for `ffap-alist' to return path to MODULE." + (python-send-receive (format "emacs.modpath (%S)" module))) + +(eval-after-load "ffap" + '(push '(python-mode . python-module-path) ffap-alist)) + +;;;; Skeletons + +(defvar python-skeletons nil + "Alist of named skeletons for Python mode. +Elements are of the form (NAME . EXPANDER-FUNCTION).") + +(defvar python-mode-abbrev-table nil + "Abbrev table for Python mode. +The default contents correspond to the elements of `python-skeletons'.") +(define-abbrev-table 'python-mode-abbrev-table ()) + +(eval-when-compile + ;; Define a user-level skeleton and add it to `python-skeletons' and + ;; the abbrev table. +(defmacro def-python-skeleton (name &rest elements) + (let* ((name (symbol-name name)) + (function (intern (concat "python-insert-" name)))) + `(progn + (add-to-list 'python-skeletons ',(cons name function)) + (define-abbrev python-mode-abbrev-table ,name "" ',function nil t) + (define-skeleton ,function + ,(format "Insert Python \"%s\" template." name) + ,@elements))))) +(put 'def-python-skeleton 'lisp-indent-function 2) + +;; From `skeleton-further-elements': +;; `<': outdent a level; +;; `^': delete indentation on current line and also previous newline. +;; Not quote like `delete-indentation'. Assumes point is at +;; beginning of indentation. + +(def-python-skeleton if + "Condition: " + "if " str ":" \n + > _ \n + ("other condition, %s: " + < ; Avoid wrong indentation after block opening. + "elif " str ":" \n + > _ \n nil) + (python-else) | ^) + +(define-skeleton python-else + "Auxiliary skeleton." + nil + (unless (eq ?y (read-char "Add `else' clause? (y for yes or RET for no) ")) + (signal 'quit t)) + < "else:" \n + > _ \n) + +(def-python-skeleton while + "Condition: " + "while " str ":" \n + > _ \n + (python-else) | ^) + +(def-python-skeleton for + "Target, %s: " + "for " str " in " (skeleton-read "Expression, %s: ") ":" \n + > _ \n + (python-else) | ^) + +(def-python-skeleton try/except + nil + "try:" \n + > _ \n + ("Exception, %s: " + < "except " str (python-target) ":" \n + > _ \n nil) + < "except:" \n + > _ \n + (python-else) | ^) + +(define-skeleton python-target + "Auxiliary skeleton." + "Target, %s: " ", " str | -2) + +(def-python-skeleton try/finally + nil + "try:" \n + > _ \n + < "finally:" \n + > _ \n) + +(def-python-skeleton def + "Name: " + "def " str " (" ("Parameter, %s: " (unless (equal ?\( (char-before)) ", ") + str) "):" \n + "\"\"\"" @ " \"\"\"" \n ; Fixme: syntaxification wrong for """""" + > _ \n) + +(def-python-skeleton class + "Name: " + "class " str " (" ("Inheritance, %s: " + (unless (equal ?\( (char-before)) ", ") + str) + & ")" | -2 ; close list or remove opening + ":" \n + "\"\"\"" @ " \"\"\"" \n + > _ \n) + +(defvar python-default-template "if" + "Default template to expand by `python-insert-template'. +Updated on each expansion.") + +(defun python-expand-template (name) + "Expand template named NAME. +Interactively, prompt for the name with completion." + (interactive + (list (completing-read (format "Template to expand (default %s): " + python-default-template) + python-skeletons nil t))) + (if (equal "" name) + (setq name python-default-template) + (setq python-default-template name)) + (let ((func (cdr (assoc name python-skeletons)))) + (if func + (funcall func) + (error "Undefined template: %s" name)))) + +;;;; Bicycle Repair Man support + +(autoload 'pymacs-load "pymacs" nil t) +(autoload 'brm-init "bikemacs") + +;; I'm not sure how useful BRM really is, and it's certainly dangerous +;; the way it modifies files outside Emacs... Also note that the +;; current BRM loses with tabs used for indentation -- I submitted a +;; fix . +(defun python-setup-brm () + "Set up Bicycle Repair Man refactoring tool (if available). + +Note that the `refactoring' features change files independently of +Emacs and may modify and save the contents of the current buffer +without confirmation." + (interactive) + (condition-case data + (unless (fboundp 'brm-rename) + (pymacs-load "bikeemacs" "brm-") ; first line of normal recipe + (let ((py-mode-map (make-sparse-keymap)) ; it assumes this + (features (cons 'python-mode features)) ; and requires this + menu) + (brm-init) ; second line of normal recipe + (remove-hook 'python-mode-hook ; undo this from `brm-init' + '(lambda () (easy-menu-add brm-menu))) + (easy-menu-define + python-brm-menu python-mode-map + "Bicycle Repair Man" + '("BicycleRepairMan" + :help "Interface to navigation and refactoring tool" + "Queries" + ["Find References" brm-find-references + :help "Find references to name at point in compilation buffer"] + ["Find Definition" brm-find-definition + :help "Find definition of name at point"] + "-" + "Refactoring" + ["Rename" brm-rename + :help "Replace name at point with a new name everywhere"] + ["Extract Method" brm-extract-method + :active (and mark-active (not buffer-read-only)) + :help "Replace statements in region with a method"] + ["Extract Local Variable" brm-extract-local-variable + :active (and mark-active (not buffer-read-only)) + :help "Replace expression in region with an assignment"] + ["Inline Local Variable" brm-inline-local-variable + :help + "Substitute uses of variable at point with its definition"] + ;; Fixme: Should check for anything to revert. + ["Undo Last Refactoring" brm-undo :help ""])))) + (error (error "Bicyclerepairman setup failed: %s" data)))) + ;;;; Modes. (defvar outline-heading-end-regexp) (defvar eldoc-documentation-function) +;; Stuff to allow expanding abbrevs with non-word constituents. +(defun python-abbrev-pc-hook () + "Set the syntax table before possibly expanding abbrevs." + (remove-hook 'post-command-hook 'python-abbrev-pc-hook t) + (set-syntax-table python-mode-syntax-table)) + +(defvar python-abbrev-syntax-table + (copy-syntax-table python-mode-syntax-table) + "Syntax table used when expanding abbrevs.") + +(defun python-pea-hook () + "Reset the syntax table after possibly expanding abbrevs." + (set-syntax-table python-abbrev-syntax-table) + (add-hook 'post-command-hook 'python-abbrev-pc-hook nil t)) +(modify-syntax-entry ?/ "w" python-abbrev-syntax-table) + ;;;###autoload (define-derived-mode python-mode fundamental-mode "Python" "Major mode for editing Python files. -Turns on Font Lock mode unconditionally since it is required for correct -parsing of the source. +Font Lock mode is currently required for correct parsing of the source. See also `jython-mode', which is actually invoked if the buffer appears to contain Jython code. See also `run-python' and associated Python mode commands for running Python under Emacs. @@ -1703,21 +2148,27 @@ Colon is electric: it outdents the line if appropriate, e.g. for an else statement. \\[python-backspace] at the beginning of an indented statement deletes a level of indentation to close the current block; otherwise it -deletes a charcter backward. TAB indents the current line relative to +deletes a character backward. TAB indents the current line relative to the preceding code. Successive TABs, with no intervening command, cycle through the possibilities for indentation on the basis of enclosing blocks. -\\[fill-paragraph] fills comments and multiline strings appropriately, but has no +\\[fill-paragraph] fills comments and multi-line strings appropriately, but has no effect outside them. Supports Eldoc mode (only for functions, using a Python process), Info-Look and Imenu. In Outline minor mode, `class' and `def' -lines count as headers. +lines count as headers. Symbol completion is available in the +same way as in the Python shell using the `rlcompleter' module +and this is added to the Hippie Expand functions locally if +Hippie Expand mode is turned on. Completion of symbols of the +form x.y only works if the components are literal +module/attribute names, not variables. An abbrev table is set up +with skeleton expansions for compound statement templates. \\{python-mode-map}" :group 'python (set (make-local-variable 'font-lock-defaults) - '(python-font-lock-keywords nil nil ((?_ . "w")) nil + '(python-font-lock-keywords nil nil nil nil (font-lock-syntactic-keywords . python-font-lock-syntactic-keywords) ;; This probably isn't worth it. @@ -1726,15 +2177,17 @@ )) (set (make-local-variable 'parse-sexp-lookup-properties) t) (set (make-local-variable 'comment-start) "# ") - (set (make-local-variable 'comment-indent-function) #'python-comment-indent) (set (make-local-variable 'indent-line-function) #'python-indent-line) + (set (make-local-variable 'indent-region-function) #'python-indent-region) (set (make-local-variable 'paragraph-start) "\\s-*$") (set (make-local-variable 'fill-paragraph-function) 'python-fill-paragraph) (set (make-local-variable 'require-final-newline) mode-require-final-newline) (set (make-local-variable 'add-log-current-defun-function) #'python-current-defun) - ;; Fixme: Generalize to do all blocks? - (set (make-local-variable 'outline-regexp) "\\s-*\\(def\\|class\\)\\>") + (set (make-local-variable 'outline-regexp) + (rx (* space) (or "class" "def" "elif" "else" "except" "finally" + "for" "if" "try" "while") + symbol-end)) (set (make-local-variable 'outline-heading-end-regexp) ":\\s-*\n") (set (make-local-variable 'outline-level) #'python-outline-level) (set (make-local-variable 'open-paren-in-column-0-is-defun-start) nil) @@ -1746,20 +2199,28 @@ (set (make-local-variable 'eldoc-documentation-function) #'python-eldoc-function) (add-hook 'eldoc-mode-hook - '(lambda () (run-python nil t)) nil t) ; need it running - (unless (assoc 'python-mode hs-special-modes-alist) - (setq - hs-special-modes-alist - (cons (list - 'python-mode "^\\s-*def\\>" nil "#" - (lambda (arg)(python-end-of-defun)(skip-chars-backward " \t\n")) - nil) - hs-special-modes-alist))) + (lambda () (run-python nil t)) ; need it running + nil t) + ;; Fixme: should be in hideshow. This seems to be of limited use + ;; since it isn't (can't be) indentation-based. Also hide-level + ;; doesn't seem to work properly. + (add-to-list 'hs-special-modes-alist + `(python-mode "^\\s-*def\\>" nil "#" + ,(lambda (arg) + (python-end-of-defun) + (skip-chars-backward " \t\n")) + nil)) + (set (make-local-variable 'skeleton-further-elements) + '((< '(backward-delete-char-untabify (min python-indent + (current-column)))) + (^ '(- (1+ (current-indentation)))))) + (add-hook 'pre-abbrev-expand-hook 'python-pea-hook nil t) (if (featurep 'hippie-exp) (set (make-local-variable 'hippie-expand-try-functions-list) (cons 'python-try-complete hippie-expand-try-functions-list))) (when python-guess-indent (python-guess-indent)) (set (make-local-variable 'python-command) python-python-command) + (python-find-imports) (unless (boundp 'python-mode-running) ; kill the recursion from jython-mode (let ((python-mode-running t)) (python-maybe-jython)))) @@ -1767,9 +2228,11 @@ (custom-add-option 'python-mode-hook 'imenu-add-menubar-index) (custom-add-option 'python-mode-hook '(lambda () - "Turn on Indent Tabs mode." - (set (make-local-variable 'indent-tabs-mode) t))) + "Turn off Indent Tabs mode." + (set (make-local-variable 'indent-tabs-mode) nil))) (custom-add-option 'python-mode-hook 'turn-on-eldoc-mode) +(custom-add-option 'python-mode-hook 'abbrev-mode) +(custom-add-option 'python-mode-hook 'python-setup-brm) ;;;###autoload (define-derived-mode jython-mode python-mode "Jython" @@ -1780,5 +2243,6 @@ (set (make-local-variable 'python-command) python-jython-command)) (provide 'python) +(provide 'python-21) ;; arch-tag: 6fce1d99-a704-4de9-ba19-c6e4912b0554 ;;; python.el ends here