+++ /dev/null
-;;; python.el --- silly walks for Python
-
-;; Copyright (C) 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
-
-;; Author: Dave Love <fx@gnu.org>
-;; Maintainer: FSF
-;; Created: Nov 2003
-;; Keywords: languages
-
-;; This file is part of GNU Emacs.
-
-;; 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.
-
-;; 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,
-;; Boston, MA 02110-1301, USA.
-
-;;; Commentary:
-
-;; Major mode for editing Python, with support for inferior processes.
-
-;; There is another Python mode, python-mode.el, used by XEmacs and
-;; 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 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-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
-;; inferior mode can find the source of errors from
-;; `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 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:
-
-(eval-when-compile
- (require 'cl)
- (require 'compile)
- (require 'comint)
- (require 'hippie-exp))
-
-(autoload 'comint-mode "comint")
-
-(defgroup python nil
- "Silly walks in the Python language."
- :group 'languages
- :version "22.1"
- :link '(emacs-commentary-link "python"))
-\f
-;;;###autoload
-(add-to-list 'interpreter-mode-alist '("jython" . jython-mode))
-;;;###autoload
-(add-to-list 'interpreter-mode-alist '("python" . python-mode))
-;;;###autoload
-(add-to-list 'auto-mode-alist '("\\.py\\'" . python-mode))
-\f
-;;;; Font lock
-
-(defvar python-font-lock-keywords
- `(,(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"
- ;; Not real keywords, but close enough to be fontified as such
- "self" "True" "False")
- 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 (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)))
- ;; This doesn't really help.
-;;; (,(rx (and ?\\ (group ?\n))) (1 " "))
- ))
-
-(defun python-quote-syntax (n)
- "Put `syntax-table' property correctly on triple quote.
-Used for syntactic keywords. N is the match number (1, 2 or 3)."
- ;; Given a triple quote, we have to check the context to know
- ;; whether this is an opening or closing triple or whether it's
- ;; quoted anyhow, and should be ignored. (For that we need to do
- ;; the same job as `syntax-ppss' to be correct and it seems to be OK
- ;; to use it here despite initial worries.) We also have to sort
- ;; out a possible prefix -- well, we don't _have_ to, but I think it
- ;; should be treated as part of the string.
-
- ;; Test cases:
- ;; ur"""ar""" x='"' # """
- ;; 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
- ;; Consider property for the last char if in a fenced string.
- ((= n 3)
- (let ((syntax (syntax-ppss)))
- (when (eq t (nth 3 syntax)) ; after unclosed fence
- (goto-char (nth 8 syntax)) ; fence position
- (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) ; 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 (nth 3 (syntax-ppss))
- (eval-when-compile (string-to-syntax "|"))))
- ;; Otherwise (we're in a non-matching string) the property is
- ;; nil, which is OK.
- )))
-
-;; This isn't currently in `font-lock-defaults' as probably not worth
-;; it -- we basically only mess with a few normally-symbol characters.
-
-;; (defun python-font-lock-syntactic-face-function (state)
-;; "`font-lock-syntactic-face-function' for Python mode.
-;; Returns the string or comment face as usual, with side effect of putting
-;; a `syntax-table' property on the inside of the string or comment which is
-;; the standard syntax table."
-;; (if (nth 3 state)
-;; (save-excursion
-;; (goto-char (nth 8 state))
-;; (condition-case nil
-;; (forward-sexp)
-;; (error nil))
-;; (put-text-property (1+ (nth 8 state)) (1- (point))
-;; 'syntax-table (standard-syntax-table))
-;; 'font-lock-string-face)
-;; (put-text-property (1+ (nth 8 state)) (line-end-position)
-;; 'syntax-table (standard-syntax-table))
-;; 'font-lock-comment-face))
-\f
-;;;; Keymap and syntax
-
-(defvar python-mode-map
- (let ((map (make-sparse-keymap)))
- ;; Mostly taken from python-mode.el.
- (define-key map ":" 'python-electric-colon)
- (define-key map "\177" 'python-backspace)
- (define-key map "\C-c<" 'python-shift-left)
- (define-key map "\C-c>" 'python-shift-right)
- (define-key map "\C-c\C-k" 'python-mark-block)
- (define-key map "\C-c\C-n" 'python-next-statement)
- (define-key map "\C-c\C-p" 'python-previous-statement)
- (define-key map "\C-c\C-u" 'python-beginning-of-block)
- (define-key map "\C-c\C-f" 'python-describe-symbol)
- (define-key map "\C-c\C-w" 'python-check)
- (define-key map "\C-c\C-v" 'python-check) ; a la sgml-mode
- (define-key map "\C-c\C-s" 'python-send-string)
- (define-key map [?\C-\M-x] 'python-send-defun)
- (define-key map "\C-c\C-r" 'python-send-region)
- (define-key map "\C-c\M-r" 'python-send-region-and-go)
- (define-key map "\C-c\C-c" 'python-send-buffer)
- (define-key map "\C-c\C-z" 'python-switch-to-python)
- (define-key map "\C-c\C-m" 'python-load-file)
- (define-key map "\C-c\C-l" 'python-load-file) ; a la cmuscheme
- (substitute-key-definition 'complete-symbol 'python-complete-symbol
- map global-map)
- (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"
- :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
- :help "Mark innermost block around point"]
- ["Mark def/class" mark-defun
- :help "Mark innermost definition around point"]
- "-"
- ["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
- :help "Load into inferior Python session"]
- ["Eval buffer" python-send-buffer
- :help "Evaluate buffer en bloc in inferior Python session"]
- ["Eval region" python-send-region :active mark-active
- :help "Evaluate region en bloc in inferior Python session"]
- ["Eval def/class" python-send-defun
- :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"]
- ["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)))
- ;; Give punctuation syntax to ASCII that normally has symbol
- ;; syntax or has word syntax and isn't a letter.
- (let ((symbol (string-to-syntax "_"))
- (sst (standard-syntax-table)))
- (dotimes (i 128)
- (unless (= i ?_)
- (if (equal symbol (aref sst i))
- (modify-syntax-entry i "." table)))))
- (modify-syntax-entry ?$ "." table)
- (modify-syntax-entry ?% "." table)
- ;; exceptions
- (modify-syntax-entry ?# "<" table)
- (modify-syntax-entry ?\n ">" table)
- (modify-syntax-entry ?' "\"" table)
- (modify-syntax-entry ?` "$" table)
- table))
-\f
-;;;; Utility stuff
-
-(defsubst python-in-string/comment ()
- "Return non-nil if point is in a Python literal (a comment or string)."
- ;; 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)))
- (modify-syntax-entry ?\\ " " table)
- table)
- "`python-mode-syntax-table' with backslash given whitespace syntax.")
-
-(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."
- (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."
- (and (eq ?\\ (char-before (line-end-position 0)))
- (not (syntax-ppss-context (syntax-ppss)))))
-
-(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 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."
- (save-excursion
- (end-of-line)
- (when (eq 'comment (syntax-ppss-context (syntax-ppss)))
- (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."
- (let ((state (syntax-ppss)))
- (when (eq 'string (syntax-ppss-context state))
- (goto-char (nth 8 state)))))
-
-(defun python-open-block-statement-p (&optional bos)
- "Return non-nil if statement at point opens a block.
-BOS non-nil means point is known to be at beginning of statement."
- (save-excursion
- (unless bos (python-beginning-of-statement))
- (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'."
- (save-excursion
- (unless bos (python-beginning-of-statement))
- (back-to-indentation)
- (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 "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 (python-open-block-statement-p)))))
-\f
-;;;; Indentation.
-
-(defcustom python-indent 4
- "Number of columns for a unit of indentation in Python mode.
-See also `\\[python-guess-indent]'"
- :group 'python
- :type 'integer)
-(put 'python-indent 'safe-local-variable 'integerp)
-
-(defcustom python-guess-indent t
- "Non-nil means Python mode guesses `python-indent' for the buffer."
- :type 'boolean
- :group 'python)
-
-(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 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 "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."
- :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."
- :group 'python
- :type 'integer)
-
-(defun python-guess-indent ()
- "Guess step for indentation of current buffer.
-Set `python-indent' locally to the value guessed."
- (interactive)
- (save-excursion
- (save-restriction
- (widen)
- (goto-char (point-min))
- (let (done indent)
- (while (and (not done) (not (eobp)))
- (when (and (re-search-forward (rx ?: (0+ space)
- (or (syntax comment-start)
- line-end))
- nil 'move)
- (python-open-block-statement-p))
- (save-excursion
- (python-beginning-of-statement)
- (let ((initial (current-indentation)))
- (if (zerop (python-next-statement))
- (setq indent (- (current-indentation) initial)))
- (if (and (>= indent 2) (<= indent 8)) ; sanity check
- (setq done t))))))
- (when done
- (when (/= indent (default-value 'python-indent))
- (set (make-local-variable 'python-indent) indent)
- (unless (= tab-width python-indent)
- (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))
- start)
- (cond
- ((eq 'string (syntax-ppss-context syntax)) ; multi-line string
- (if (not python-indent-string-contents)
- (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) ; after backslash, or bracketed
- (let ((point (point))
- (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
- (goto-char (1+ open-start))
- ;; Look for first item in list (preceding point) and
- ;; align with it, if found.
- (if (with-syntax-table python-space-backslash-table
- (let ((parse-sexp-ignore-comments t))
- (condition-case ()
- (progn (forward-sexp)
- (backward-sexp)
- (< (point) point))
- (error nil))))
- ;; 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))
- (python-beginning-of-statement)
- (+ (current-indentation) (* (car syntax) python-indent))))
- ;; Otherwise backslash-continued.
- (forward-line -1)
- (if (python-continuation-line-p)
- ;; We're past first continuation line. Align with
- ;; previous line.
- (current-indentation)
- ;; First continuation line. Indent one step, with an
- ;; extra one if statement opens a block.
- (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 (0+ space) (syntax comment-start)
- (not (any " \t\n")))) ; non-indentable comment
- (current-indentation))
- (t (if python-honour-comment-indentation
- ;; Back over whitespace, newlines, non-indentable comments.
- (catch 'done
- (while t
- (if (cond ((bobp))
- ;; not at comment start
- ((not (forward-comment -1))
- (python-beginning-of-statement)
- t)
- ;; trailing comment
- ((/= (current-column) (current-indentation))
- (python-beginning-of-statement)
- t)
- ;; indentable comment like python-mode.el
- ((and (looking-at (rx (syntax comment-start)
- (or space line-end)))
- (/= 0 (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.
-
-(defun python-initial-text ()
- "Text of line following indentation and ignoring any trailing comment."
- (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. 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 ((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 (&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 (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)
- (delete-horizontal-space)
- (indent-to target)
- (if (> (- (point-max) pos) (point))
- (goto-char (- (point-max) pos))))))
-
-(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."
- (interactive)
- (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,
-or a blank line indented to where it would close a block."
- (and (not (python-comment-line-p))
- (or (python-close-block-statement-p t)
- (< (current-indentation)
- (save-excursion
- (python-previous-statement)
- (current-indentation))))))
-\f
-;;;; 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."
- (let ((ci (current-indentation))
- (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))
- (while (and (not (bobp)) (not found))
- ;; Treat bol at beginning of function as outside function so
- ;; that successive C-M-a makes progress backwards.
- ;;(setq def-line (looking-at def-re))
- (unless (bolp) (end-of-line))
- (setq lep (line-end-position))
- (if (and (re-search-backward def-re nil 'move)
- ;; 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
- ;; 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)))))
-
-(defun python-end-of-defun ()
- "`end-of-defun-function' for Python.
-Finds end of innermost nested class or method definition."
- (let ((orig (point))
- (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.
- (when (python-comment-line-p)
- (end-of-line)
- (forward-comment most-positive-fixnum))
- (if (not (python-open-block-statement-p))
- (python-beginning-of-block))
- (if (zerop (current-indentation))
- (unless (python-open-block-statement-p)
- (while (and (re-search-forward pattern nil 'move)
- (python-in-string/comment))) ; just loop
- (unless (eobp)
- (beginning-of-line)))
- ;; Don't move before top-level statement that would end defun.
- (end-of-line)
- (python-beginning-of-defun))
- ;; If we got to the start of buffer, look forward for
- ;; definition statement.
- (if (and (bobp) (not (looking-at "def\\|class")))
- (while (and (not (eobp))
- (re-search-forward pattern nil 'move)
- (python-in-string/comment)))) ; just loop
- ;; We're at a definition statement (or end-of-buffer).
- (unless (eobp)
- (python-end-of-block)
- ;; Count trailing space in defun (but not trailing comments).
- (skip-syntax-forward " >")
- (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 ...:
- ;; ...
- ;; else:
- ;; ... # point here
- ;; ...
- ;; def ...
- (if (< (point) orig)
- (goto-char (point-max)))))
-
-(defun python-beginning-of-statement ()
- "Go to start of current statement.
-Accounts for continuation lines, multi-line strings, and
-multi-line bracketed expressions."
- (beginning-of-line)
- (python-beginning-of-string)
- (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)
- (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
-multi-line statement we need to skip over the continuation lines.
-On a comment line, go to end of line."
- (end-of-line)
- (while (let (comment)
- ;; Move past any enclosing strings and sexps, or stop if
- ;; we're in a comment.
- (while (let ((s (syntax-ppss)))
- (cond ((eq 'comment (syntax-ppss-context s))
- (setq comment t)
- nil)
- ((eq 'string (syntax-ppss-context s))
- ;; Go to start of string and skip it.
- (goto-char (nth 8 s))
- (condition-case () ; beware invalid syntax
- (progn (forward-sexp) t)
- (error (end-of-line))))
- ((python-skip-out t s))))
- (end-of-line))
- (unless comment
- (eq ?\\ (char-before)))) ; Line continued?
- (end-of-line 2)) ; Try next line.
- (point))
-
-(defun python-previous-statement (&optional count)
- "Go to start of previous statement.
-With argument COUNT, do it COUNT times. Stop at beginning of buffer.
-Return count of statements left to move."
- (interactive "p")
- (unless count (setq count 1))
- (if (< count 0)
- (python-next-statement (- count))
- (python-beginning-of-statement)
- (while (and (> count 0) (not (bobp)))
- (python-skip-comments/blanks t)
- (python-beginning-of-statement)
- (unless (bobp) (setq count (1- count))))
- count))
-
-(defun python-next-statement (&optional count)
- "Go to start of next statement.
-With argument COUNT, do it COUNT times. Stop at end of buffer.
-Return count of statements left to move."
- (interactive "p")
- (unless count (setq count 1))
- (if (< count 0)
- (python-previous-statement (- count))
- (beginning-of-line)
- (while (and (> count 0) (not (eobp)))
- (python-end-of-statement)
- (python-skip-comments/blanks)
- (unless (eobp)
- (setq count (1- count))))
- count))
-
-(defun python-beginning-of-block (&optional arg)
- "Go to start of current block.
-With numeric arg, do it that many times. If ARG is negative, call
-`python-end-of-block' instead.
-If point is on the first line of a block, use its outer block.
-If current statement is in column zero, don't move and return nil.
-Otherwise return non-nil."
- (interactive "p")
- (unless arg (setq arg 1))
- (cond
- ((zerop arg))
- ((< arg 0) (python-end-of-block (- arg)))
- (t
- (let ((point (point)))
- (if (or (python-comment-line-p)
- (python-blank-line-p))
- (python-skip-comments/blanks t))
- (python-beginning-of-statement)
- (let ((ci (current-indentation)))
- (if (zerop ci)
- (not (goto-char point)) ; return nil
- ;; Look upwards for less indented statement.
- (if (catch 'done
-;;; This is slower than the below.
-;;; (while (zerop (python-previous-statement))
-;;; (when (and (< (current-indentation) ci)
-;;; (python-open-block-statement-p t))
-;;; (beginning-of-line)
-;;; (throw 'done t)))
- (while (and (zerop (forward-line -1)))
- (when (and (< (current-indentation) ci)
- (not (python-comment-line-p))
- ;; Move to beginning to save effort in case
- ;; this is in string.
- (progn (python-beginning-of-statement) t)
- (python-open-block-statement-p t))
- (beginning-of-line)
- (throw 'done t)))
- (not (goto-char point))) ; Failed -- return nil
- (python-beginning-of-block (1- arg)))))))))
-
-(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."
- (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))
- opoint)
- (if (and (zerop ci) (not open))
- (not (goto-char point))
- (catch 'done
- (setq opoint (point))
- (while (and (zerop (python-next-statement))
- (not (= opoint (point))))
- (setq opoint (point))
- (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)))
-\f
-;;;; Imenu.
-
-(defvar python-recursing)
-(defun python-imenu-create-index ()
- "`imenu-create-index-function' for Python.
-
-Makes nested Imenu menus from nested `class' and `def' statements.
-The nested menus are headed by an item referencing the outer
-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
- ;; 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 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))
- (name (match-string-no-properties 3)))
- (if (match-beginning 2) ; def or class?
- (setq name (concat "class " name)))
- (save-restriction
- (narrow-to-defun)
- (let* ((python-recursing t)
- (sublist (python-imenu-create-index)))
- (if sublist
- (progn (push (cons (concat " " name) pos) sublist)
- (push (cons name sublist) index-alist))
- (push (cons name pos) 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))
-\f
-;;;; `Electric' commands.
-
-(defun python-electric-colon (arg)
- "Insert a colon and maybe outdent the line if it is a statement like `else'.
-With numeric ARG, just insert that many colons. With \\[universal-argument],
-just insert a single colon."
- (interactive "*P")
- (self-insert-command (if (not (integerp arg)) 1 arg))
- (and (not arg)
- (eolp)
- (python-outdent-p)
- (not (python-in-string/comment))
- (> (current-indentation) (python-calculate-indentation))
- (python-indent-line))) ; OK, do it
-(put 'python-electric-colon 'delete-selection t)
-
-(defun python-backspace (arg)
- "Maybe delete a level of indentation on the current line.
-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)
- ;; 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)
-\f
-;;;; pychecker
-
-(defcustom python-check-command "pychecker --stdlib"
- "Command used to check a Python file."
- :type 'string
- :group 'python)
-
-(defvar python-saved-check-command nil
- "Internal use.")
-
-;; After `sgml-validate-command'.
-(defun python-check (command)
- "Check a Python file (default current buffer's file).
-Runs COMMAND, a shell command, as if by `compile'.
-See `python-check-command' for the default."
- (interactive
- (list (read-string "Checker command: "
- (or python-saved-check-command
- (concat python-check-command " "
- (let ((name (buffer-file-name)))
- (if name
- (file-name-nondirectory name))))))))
- (setq python-saved-check-command command)
- (require 'compile) ;To define compilation-* variables.
- (save-some-buffers (not compilation-ask-about-save) nil)
- (let ((compilation-error-regexp-alist
- (cons '("(\\([^,]+\\), line \\([0-9]+\\))" 1 2)
- compilation-error-regexp-alist)))
- (compilation-start command)))
-\f
-;;;; Inferior mode stuff (following cmuscheme).
-
-;; Fixme: Make sure we can work with IPython.
-
-(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'."
- :group 'python
- :type 'string)
-
-(defcustom python-jython-command "jython"
- "Shell command to run Jython interpreter.
-Any arguments can't contain whitespace."
- :group 'python
- :type 'string)
-
-(defvar python-command python-python-command
- "Actual command used to run Python.
-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.
-
-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.
-
-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.
-
-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.
- ;; 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 " in file " (group (1+ not-newline)) " on line "
- (group (1+ digit)))
- 1 2))
- "`compilation-error-regexp-alist' for inferior Python.")
-
-(defvar inferior-python-mode-map
- (let ((map (make-sparse-keymap)))
- ;; This will inherit from comint-mode-map.
- (define-key map "\C-c\C-l" 'python-load-file)
- (define-key map "\C-c\C-v" 'python-check)
- ;; Note that we _can_ still use these commands which send to the
- ;; Python process even at the prompt iff we have a normal prompt,
- ;; i.e. '>>> ' and not '... '. See the comment before
- ;; python-send-region. Fixme: uncomment these if we address that.
-
- ;; (define-key map [(meta ?\t)] 'python-complete-symbol)
- ;; (define-key map "\C-c\C-f" 'python-describe-symbol)
- map))
-
-(defvar inferior-python-mode-syntax-table
- (let ((st (make-syntax-table python-mode-syntax-table)))
- ;; Don't get confused by apostrophes in the process's output (e.g. if
- ;; you execute "help(os)").
- (modify-syntax-entry ?\' "." st)
- ;; Maybe we should do the same for double quotes?
- ;; (modify-syntax-entry ?\" "." st)
- st))
-
-;; 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].
-
-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
- 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 `run-python' and
-`python-buffer'.
-
-\\{inferior-python-mode-map}"
- :group 'python
- (setq mode-line-process '(":%s"))
- (set (make-local-variable 'comint-input-filter) 'python-input-filter)
- (add-hook 'comint-preoutput-filter-functions #'python-preoutput-filter
- nil t)
- ;; Still required by `comint-redirect-send-command', for instance
- ;; (and we need to match things like `>>> ... >>> '):
- (set (make-local-variable 'comint-prompt-regexp)
- (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))
-
-(defcustom inferior-python-filter-regexp "\\`\\s-*\\S-?\\S-?\\s-*\\'"
- "Input matching this regexp is not saved on the history list.
-Default ignores all inputs of 0, 1, or 2 non-blank characters."
- :type 'regexp
- :group 'python)
-
-(defun python-input-filter (str)
- "`comint-input-filter' function for inferior Python.
-Don't save anything for STR matching `inferior-python-filter-regexp'."
- (not (string-match inferior-python-filter-regexp str)))
-
-;; Fixme: Loses with quoted whitespace.
-(defun python-args-to-list (string)
- (let ((where (string-match "[ \t]" string)))
- (cond ((null where) (list string))
- ((not (= where 0))
- (cons (substring string 0 where)
- (python-args-to-list (substring string (+ 1 where)))))
- (t (let ((pos (string-match "[^ \t]" string)))
- (if pos (python-args-to-list (substring string pos))))))))
-
-(defvar python-preoutput-result nil
- "Data from last `_emacs_out' line seen by the preoutput filter.")
-
-(defvar python-preoutput-leftover nil)
-(defvar python-preoutput-skip-next-prompt nil)
-
-;; Using this stops us getting lines in the buffer like
-;; >>> ... ... >>>
-(defun python-preoutput-filter (s)
- "`comint-preoutput-filter-functions' function: ignore prompts not at bol."
- (when python-preoutput-leftover
- (setq s (concat python-preoutput-leftover s))
- (setq python-preoutput-leftover nil))
- (let ((start 0)
- (res ""))
- ;; First process whole lines.
- (while (string-match "\n" s start)
- (let ((line (substring s start (setq start (match-end 0)))))
- ;; Skip prompt if needed.
- (when (and python-preoutput-skip-next-prompt
- (string-match comint-prompt-regexp line))
- (setq python-preoutput-skip-next-prompt nil)
- (setq line (substring line (match-end 0))))
- ;; Recognize special _emacs_out lines.
- (if (and (string-match "\\`_emacs_out \\(.*\\)\n\\'" line)
- (local-variable-p 'python-preoutput-result))
- (progn
- (setq python-preoutput-result (match-string 1 line))
- (set (make-local-variable 'python-preoutput-skip-next-prompt) t))
- (setq res (concat res line)))))
- ;; Then process the remaining partial line.
- (unless (zerop start) (setq s (substring s start)))
- (cond ((and (string-match comint-prompt-regexp s)
- ;; Drop this prompt if it follows an _emacs_out...
- (or python-preoutput-skip-next-prompt
- ;; ... or if it's not gonna be inserted at BOL.
- ;; Maybe we could be more selective here.
- (if (zerop (length res))
- (not (bolp))
- (string-match ".\\'" res))))
- ;; 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))
- (setq python-preoutput-skip-next-prompt nil)
- res)
- ((let ((end (min (length "_emacs_out ") (length s))))
- (eq t (compare-strings s nil end "_emacs_out " nil end)))
- ;; The leftover string is a prefix of _emacs_out so we don't know
- ;; yet whether it's an _emacs_out or something else: wait until we
- ;; get more output so we can resolve this ambiguity.
- (set (make-local-variable 'python-preoutput-leftover) s)
- res)
- (t (concat res s)))))
-
-(autoload 'comint-check-proc "comint")
-
-;;;###autoload
-(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.
-
-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.
- (when (or new (not (comint-check-proc python-buffer)))
- (with-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)))
- (apply 'make-comint-in-buffer "Python"
- (if new (generate-new-buffer "*Python*") "*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)
- ;; 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.
- ;; Ensure we're at a prompt before doing anything else.
- (python-send-receive "import emacs; print '_emacs_out ()'")))
- (if (derived-mode-p 'python-mode)
- (setq python-buffer (default-value 'python-buffer))) ; buffer-local
- ;; 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
-;; `... ', i.e. we're not inputting a block &c. However, this may not
-;; 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-shell-minor-mode'.
-COMMAND should be a single statement."
- ;; (assert (not (string-match "\n" command)))
- ;; (let ((end (marker-position (process-mark (python-proc)))))
- (with-current-buffer (process-buffer (python-proc))
- (goto-char (point-max))
- (compilation-forget-errors)
- (python-send-string command)
- (setq compilation-last-buffer (current-buffer)))
- ;; No idea what this is for but it breaks the call to
- ;; compilation-fake-loc in python-send-region. -- Stef
- ;; 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))
- ) ;;)
-
-(defun python-send-region (start end)
- "Send the region to the inferior Python process."
- ;; The region is evaluated from a temporary file. This avoids
- ;; problems with blank lines, which have different semantics
- ;; interactively and in files. It also saves the inferior process
- ;; buffer filling up with interpreter prompts. We need a Python
- ;; function to remove the temporary file when it has been evaluated
- ;; (though we could probably do it in Lisp with a Comint output
- ;; filter). This function also catches exceptions and truncates
- ;; tracebacks not to mention the frame of the function itself.
- ;;
- ;; 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.
- (interactive "r")
- (let* ((f (make-temp-file "py"))
- (command (format "emacs.eexecfile(%S)" f))
- (orig-start (copy-marker start)))
- (when (save-excursion
- (goto-char start)
- (/= 0 (current-indentation))) ; need dummy block
- (save-excursion
- (goto-char orig-start)
- ;; Wrong if we had indented code at buffer start.
- (set-marker orig-start (line-beginning-position 0)))
- (write-region "if True:\n" nil f nil 'nomsg))
- (write-region start end f t 'nomsg)
- (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'.
- (compilation-fake-loc orig-start f))))
-
-(defun python-send-string (string)
- "Evaluate STRING in inferior Python process."
- (interactive "sPython command: ")
- (comint-send-string (python-proc) string)
- (unless (string-match "\n\\'" string)
- ;; Make sure the text is properly LF-terminated.
- (comint-send-string (python-proc) "\n"))
- (when (string-match "\n[ \t].*\n?\\'" string)
- ;; If the string contains a final indented line, add a second newline so
- ;; as to make sure we terminate the multiline instruction.
- (comint-send-string (python-proc) "\n")))
-
-(defun python-send-buffer ()
- "Send the current buffer to the inferior Python process."
- (interactive)
- (python-send-region (point-min) (point-max)))
-
-;; Fixme: Try to define the function or class within the relevant
-;; module, not just at top level.
-(defun python-send-defun ()
- "Send the current defun (class or method) to the inferior Python process."
- (interactive)
- (save-excursion (python-send-region (progn (beginning-of-defun) (point))
- (progn (end-of-defun) (point)))))
-
-(defun python-switch-to-python (eob-p)
- "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)) t) ;Runs python if needed.
- (when eob-p
- (push-mark)
- (goto-char (point-max))))
-
-(defun python-send-region-and-go (start end)
- "Send the region to the inferior Python process.
-Then switch to the process buffer."
- (interactive "r")
- (python-send-region start end)
- (python-switch-to-python t))
-
-(defcustom python-source-modes '(python-mode jython-mode)
- "Used to determine if a buffer contains Python source code.
-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)
-
-(defvar python-prev-dir/file nil
- "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.
-Treating it as a module keeps the global namespace clean, provides
-function location information for debugging, and supports users of
-module-qualified names."
- (interactive (comint-get-source "Load Python file: " python-prev-dir/file
- python-source-modes
- t)) ; because execfile needs exact name
- (comint-check-source file-name) ; Check to see if buffer needs saving.
- (setq python-prev-dir/file (cons (file-name-directory file-name)
- (file-name-nondirectory file-name)))
- (with-current-buffer (process-buffer (python-proc)) ;Runs python if needed.
- ;; Fixme: I'm not convinced by this logic from python-mode.el.
- (python-send-command
- (if (string-match "\\.py\\'" file-name)
- (let ((module (file-name-sans-extension
- (file-name-nondirectory file-name))))
- (format "emacs.eimport(%S,%S)"
- module (file-name-directory file-name)))
- (format "execfile(%S)" file-name)))
- (message "%s loaded" file-name)))
-
-(defun python-proc ()
- "Return the current Python process.
-See variable `python-buffer'. Starts a new process if necessary."
- ;; 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 (if (derived-mode-p 'inferior-python-mode)
- (current-buffer)
- 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'")))
-\f
-;;;; Context-sensitive help.
-
-(defconst python-dotty-syntax-table
- (let ((table (make-syntax-table)))
- (set-char-table-parent table python-mode-syntax-table)
- (modify-syntax-entry ?. "_" table)
- table)
- "Syntax table giving `.' symbol syntax.
-Otherwise inherits from `python-mode-syntax-table'.")
-
-(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? [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 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
- (let ((symbol (with-syntax-table python-dotty-syntax-table
- (current-word)))
- (enable-recursive-minibuffers t))
- (list (read-string (if symbol
- (format "Describe symbol (default %s): " symbol)
- "Describe symbol: ")
- nil nil symbol))))
- (if (equal symbol "") (error "No symbol"))
- ;; 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")
-
-(defun python-send-receive (string)
- "Send STRING to inferior Python (if any) and return result.
-The result is what follows `_emacs_out' in the output."
- (python-send-string string)
- (let ((proc (python-proc)))
- (with-current-buffer (process-buffer proc)
- (set (make-local-variable 'python-preoutput-result) nil)
- (while (progn
- (accept-process-output proc 5)
- (null python-preoutput-result)))
- (prog1 python-preoutput-result
- (kill-local-variable 'python-preoutput-result)))))
-
-;; 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 arg list, for
-instance. Assumes an inferior Python is running."
- (let ((symbol (with-syntax-table python-dotty-syntax-table
- (current-word))))
- ;; This is run from timers, so inhibit-quit tends to be set.
- (with-local-quit
- ;; 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))))))))))))
-\f
-;;;; Info-look functionality.
-
-(defun python-after-info-look ()
- "Set up info-look for Python.
-Used with `eval-after-load'."
- (let* ((version (let ((s (shell-command-to-string (concat python-command
- " -V"))))
- (string-match "^Python \\([0-9]+\\.[0-9]+\\>\\)" s)
- (match-string 1 s)))
- ;; Whether info files have a Python version suffix, e.g. in Debian.
- (versioned
- (with-temp-buffer
- (with-no-warnings (Info-mode))
- (condition-case ()
- ;; Don't use `info' because it would pop-up a *info* buffer.
- (with-no-warnings
- (Info-goto-node (format "(python%s-lib)Miscellaneous Index"
- version))
- t)
- (error nil)))))
- (info-lookup-maybe-add-help
- :mode 'python-mode
- :regexp "[[:alnum:]_]+"
- :doc-spec
- ;; Fixme: Can this reasonably be made specific to indices with
- ;; different rules? Is the order of indices optimal?
- ;; (Miscellaneous in -ref first prefers lookup of keywords, for
- ;; instance.)
- (if versioned
- ;; The empty prefix just gets us highlighted terms.
- `((,(concat "(python" version "-ref)Miscellaneous Index") nil "")
- (,(concat "(python" version "-ref)Module Index" nil ""))
- (,(concat "(python" version "-ref)Function-Method-Variable Index"
- nil ""))
- (,(concat "(python" version "-ref)Class-Exception-Object Index"
- nil ""))
- (,(concat "(python" version "-lib)Module Index" nil ""))
- (,(concat "(python" version "-lib)Class-Exception-Object Index"
- nil ""))
- (,(concat "(python" version "-lib)Function-Method-Variable Index"
- nil ""))
- (,(concat "(python" version "-lib)Miscellaneous Index" nil "")))
- '(("(python-ref)Miscellaneous Index" nil "")
- ("(python-ref)Module Index" nil "")
- ("(python-ref)Function-Method-Variable Index" nil "")
- ("(python-ref)Class-Exception-Object Index" nil "")
- ("(python-lib)Module Index" nil "")
- ("(python-lib)Class-Exception-Object Index" nil "")
- ("(python-lib)Function-Method-Variable Index" nil "")
- ("(python-lib)Miscellaneous Index" nil ""))))))
-(eval-after-load "info-look" '(python-after-info-look))
-\f
-;;;; Miscellany.
-
-(defcustom python-jython-packages '("java" "javax" "org" "com")
- "Packages implying `jython-mode'.
-If these are imported near the beginning of the buffer, `python-mode'
-actually punts to `jython-mode'."
- :type '(repeat string)
- :group 'python)
-
-;; Called from `python-mode', this causes a recursive call of the
-;; mode. See logic there to break out of the recursion.
-(defun python-maybe-jython ()
- "Invoke `jython-mode' if the buffer appears to contain Jython code.
-The criterion is either a match for `jython-mode' via
-`interpreter-mode-alist' or an import of a module from the list
-`python-jython-packages'."
- ;; The logic is taken from python-mode.el.
- (save-excursion
- (save-restriction
- (widen)
- (goto-char (point-min))
- (let ((interpreter (if (looking-at auto-mode-interpreter-regexp)
- (match-string 2))))
- (if (and interpreter (eq 'jython-mode
- (cdr (assoc (file-name-nondirectory
- interpreter)
- interpreter-mode-alist))))
- (jython-mode)
- (if (catch 'done
- (while (re-search-forward
- (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)
- (throw 'done t))))
- (jython-mode)))))))
-
-(defun python-fill-paragraph (&optional justify)
- "`fill-paragraph-function' handling comments and multi-line strings.
-If any of the current line is a comment, fill the comment or the
-paragraph of it that point is in, preserving the comment's
-indentation and initial comment characters. Similarly if the end
-of the current line is in or at the end of a multi-line string.
-Otherwise, do nothing."
- (interactive "P")
- (or (fill-comment-paragraph justify)
- ;; The `paragraph-start' and `paragraph-separate' variables
- ;; don't allow us to delimit the last paragraph in a multi-line
- ;; string properly, so narrow to the string and then fill around
- ;; (the end of) the current line.
- (save-excursion
- (end-of-line)
- (let* ((syntax (syntax-ppss))
- (orig (point))
- (start (nth 8 syntax))
- end)
- (cond ((eq t (nth 3 syntax)) ; in fenced string
- (goto-char (nth 8 syntax)) ; string start
- (setq end (condition-case () ; for unbalanced quotes
- (progn (forward-sexp) (point))
- (error (point-max)))))
- ((re-search-backward "\\s|\\s-*\\=" nil t) ; end of fenced
- ; string
- (forward-char)
- (setq end (point))
- (condition-case ()
- (progn (backward-sexp)
- (setq start (point)))
- (error (setq end nil)))))
- (when end
- (save-restriction
- (narrow-to-region start end)
- (goto-char orig)
- (let ((paragraph-separate
- ;; Make sure that fenced-string delimiters that stand
- ;; on their own line stay there.
- (concat "[ \t]*['\"]+[ \t]*$\\|" paragraph-separate)))
- (fill-paragraph justify))))))
- t))
-
-(defun python-shift-left (start end &optional count)
- "Shift lines in region COUNT (the prefix arg) columns to the left.
-COUNT defaults to `python-indent'. If region isn't active, just shift
-current line. The region shifted includes the lines in which START and
-END lie. It is an error if any lines in the region are indented less than
-COUNT columns."
- (interactive (if mark-active
- (list (region-beginning) (region-end) current-prefix-arg)
- (list (point) (point) current-prefix-arg)))
- (if count
- (setq count (prefix-numeric-value count))
- (setq count python-indent))
- (when (> count 0)
- (save-excursion
- (goto-char start)
- (while (< (point) end)
- (if (and (< (current-indentation) count)
- (not (looking-at "[ \t]*$")))
- (error "Can't shift all lines enough"))
- (forward-line))
- (indent-rigidly start end (- count)))))
-
-(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")
-
-(defun python-shift-right (start end &optional count)
- "Shift lines in region COUNT (the prefix arg) columns to the right.
-COUNT defaults to `python-indent'. If region isn't active, just shift
-current line. The region shifted includes the lines in which START and
-END lie."
- (interactive (if mark-active
- (list (region-beginning) (region-end) current-prefix-arg)
- (list (point) (point) current-prefix-arg)))
- (if count
- (setq count (prefix-numeric-value count))
- (setq count python-indent))
- (indent-rigidly start end count))
-
-(defun python-outline-level ()
- "`outline-level' function for Python mode.
-The level is the number of `python-indent' steps of indentation
-of current line."
- (1+ (/ (current-indentation) python-indent)))
-
-;; Fixme: Consider top-level assignments, imports, &c.
-(defun python-current-defun ()
- "`add-log-current-defun-function' for Python."
- (save-excursion
- ;; Move up the tree of nested `class' and `def' blocks until we
- ;; get to zero indentation, accumulating the defined names.
- (let ((start t)
- accum)
- (while (or start (> (current-indentation) 0))
- (setq start nil)
- (python-beginning-of-block)
- (end-of-line)
- (beginning-of-defun)
- (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 ".")))))
-
-(defun python-mark-block ()
- "Mark the block around point.
-Uses `python-beginning-of-block', `python-end-of-block'."
- (interactive)
- (push-mark)
- (python-beginning-of-block)
- (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.
-\f
-;;;; 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.
-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,%s)" symbol python-imports))))
- (error nil))))
- (sort
- ;; We can get duplicates from the above -- don't know why.
- (delete-dups completions)
- #'string<))))
-
-(defun python-partial-symbol ()
- "Return the partial symbol before point (for completion)."
- (let ((end (point))
- (start (save-excursion
- (and (re-search-backward
- (rx (or buffer-start (regexp "[^[:alnum:]._]"))
- (group (1+ (regexp "[[:alnum:]._]"))) point)
- nil t)
- (match-beginning 1)))))
- (if start (buffer-substring-no-properties start end))))
-
-(defun python-complete-symbol ()
- "Perform completion on the Python symbol preceding point.
-Repeating the command scrolls the completion window."
- (interactive)
- (let ((window (get-buffer-window "*Completions*")))
- (if (and (eq last-command this-command)
- window (window-live-p window) (window-buffer window)
- (buffer-name (window-buffer window)))
- (with-current-buffer (window-buffer window)
- (if (pos-visible-in-window-p (point-max) window)
- (set-window-start window (point-min))
- (save-selected-window
- (select-window window)
- (scroll-up))))
- ;; Do completion.
- (let* ((end (point))
- (symbol (python-partial-symbol))
- (completions (python-symbol-completions symbol))
- (completion (if completions
- (try-completion symbol completions))))
- (when symbol
- (cond ((eq completion t))
- ((null completion)
- (message "Can't find completion for \"%s\"" symbol)
- (ding))
- ((not (string= symbol completion))
- (delete-region (- end (length symbol)) end)
- (insert completion))
- (t
- (message "Making completion list...")
- (with-output-to-temp-buffer "*Completions*"
- (display-completion-list completions symbol))
- (message "Making completion list...%s" "done"))))))))
-
-(defun python-try-complete (old)
- "Completion function for Python for use with `hippie-expand'."
- (when (derived-mode-p 'python-mode) ; though we only add it locally
- (unless old
- (let ((symbol (python-partial-symbol)))
- (he-init-string (- (point) (length symbol)) (point))
- (if (not (he-string-member he-search-string he-tried-table))
- (push he-search-string he-tried-table))
- (setq he-expand-list
- (and symbol (python-symbol-completions symbol)))))
- (while (and he-expand-list
- (he-string-member (car he-expand-list) he-tried-table))
- (pop he-expand-list))
- (if he-expand-list
- (progn
- (he-substitute-string (pop he-expand-list))
- t)
- (if old (he-reset-string))
- nil)))
-\f
-;;;; 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))
-\f
-;;;; Skeletons
-
-(defcustom python-use-skeletons nil
- "Non-nil means template skeletons will be automagically inserted.
-This happens when pressing \"if<SPACE>\", for example, to prompt for
-the if condition."
- :type 'boolean
- :group 'python)
-
-(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))
- (if python-use-skeletons
- (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-expand-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))))
-\f
-;;;; 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
- (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))))
-\f
-;;;; 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)
-
-(defvar python-mode-running) ;Dynamically scoped var.
-
-;;;###autoload
-(define-derived-mode python-mode fundamental-mode "Python"
- "Major mode for editing Python files.
-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.
-
-The Emacs commands which work with `defun's, e.g. \\[beginning-of-defun], deal
-with nested `def' and `class' blocks. They take the innermost one as
-current without distinguishing method and class definitions. Used multiple
-times, they move over others at the same indentation level until they reach
-the end of definitions at that level, when they move up a level.
-\\<python-mode-map>
-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 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 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. 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 nil nil
- (font-lock-syntactic-keywords
- . python-font-lock-syntactic-keywords)
- ;; This probably isn't worth it.
- ;; (font-lock-syntactic-face-function
- ;; . python-font-lock-syntactic-face-function)
- ))
- (set (make-local-variable 'parse-sexp-lookup-properties) t)
- (set (make-local-variable 'parse-sexp-ignore-comments) t)
- (set (make-local-variable 'comment-start) "# ")
- (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)
- (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)
- (make-local-variable 'python-saved-check-command)
- (set (make-local-variable 'beginning-of-defun-function)
- 'python-beginning-of-defun)
- (set (make-local-variable 'end-of-defun-function) 'python-end-of-defun)
- (setq imenu-create-index-function #'python-imenu-create-index)
- (set (make-local-variable 'eldoc-documentation-function)
- #'python-eldoc-function)
- (add-hook 'eldoc-mode-hook
- (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)))
- ;; Python defines TABs as being 8-char wide.
- (set (make-local-variable 'tab-width) 8)
- (when python-guess-indent (python-guess-indent))
- ;; Let's make it harder for the user to shoot himself in the foot.
- (unless (= tab-width python-indent)
- (setq indent-tabs-mode nil))
- (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))))
-
-(custom-add-option 'python-mode-hook 'imenu-add-menubar-index)
-(custom-add-option 'python-mode-hook
- (lambda ()
- "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"
- "Major mode for editing Jython files.
-Like `python-mode', but sets up parameters for Jython subprocesses.
-Runs `jython-mode-hook' after `python-mode-hook'."
- :group 'python
- (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
projects / emacs.git / commitdiff