changeset 72459:2657308de2f6

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.

--- 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 @@
[phone]  Dave Love  <[e-mail]>
+
+	* 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  <[e-mail]>
 
 	* frame.el (blink-cursor-start): Set timer first.

--- 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 `<stdin>' &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 `<stdin>' &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 <URL:http://www.loveshack.ukfsn.org/emacs/bikeemacs.py.diff>.
+(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