1 ;;; python.el --- silly walks for Python
3 ;; Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
5 ;; Author: Dave Love <fx@gnu.org>
10 ;; This file is part of GNU Emacs.
12 ;; This file is free software; you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation; either version 2, or (at your option)
17 ;; This file is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs; see the file COPYING. If not, write to
24 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
25 ;; Boston, MA 02110-1301, USA.
29 ;; Major mode for editing Python, with support for inferior processes.
31 ;; There is another Python mode, python-mode.el, used by XEmacs and
32 ;; maintained with Python. That isn't covered by an FSF copyright
33 ;; assignment, unlike this code, and seems not to be well-maintained
34 ;; for Emacs (though I've submitted fixes). This mode is rather
35 ;; simpler and is, perhaps, better in other ways. In particular,
36 ;; using the syntax functions with text properties maintained by
37 ;; font-lock should make it more correct with arbitrary string and
40 ;; This doesn't implement all the facilities of python-mode.el. Some
41 ;; just need doing, e.g. catching exceptions in the inferior Python
42 ;; buffer (but see M-x pdb for debugging). [Actually, the use of
43 ;; `compilation-minor-mode' now is probably enough for that.] Others
44 ;; don't seem appropriate. For instance, `forward-into-nomenclature'
45 ;; should be done separately, since it's not specific to Python, and
46 ;; I've installed a minor mode to do the job properly in Emacs 22.
47 ;; Other things seem more natural or canonical here, e.g. the
48 ;; {beginning,end}-of-defun implementation dealing with nested
49 ;; definitions, and the inferior mode following `cmuscheme'. The
50 ;; inferior mode can find the source of errors from
51 ;; `python-send-region' & al via `compilation-minor-mode'. Successive
52 ;; TABs cycle between possible indentations for the line. There is
53 ;; symbol completion using lookup in Python.
55 ;; Even where it has similar facilities, this is incompatible with
56 ;; python-mode.el in various respects. For instance, various key
57 ;; bindings are changed to obey Emacs conventions, and things like
58 ;; marking blocks and `beginning-of-defun' behave differently.
60 ;; TODO: See various Fixmes below.
64 ;; It's messy to autoload the relevant comint functions so that comint
65 ;; is only required when inferior Python is used.
69 (autoload 'info-lookup-maybe-add-help
"info-look"))
72 "Silly walks in the Python language."
75 :link
'(emacs-commentary-link "python"))
78 (add-to-list 'interpreter-mode-alist
'("jython" . jython-mode
))
80 (add-to-list 'interpreter-mode-alist
'("python" . python-mode
))
82 (add-to-list 'auto-mode-alist
'("\\.py\\'" . python-mode
))
86 (defvar python-font-lock-keywords
87 `(,(rx (and word-start
88 ;; From v 2.3 reference.
89 ;; def and class dealt with separately below
90 (or "and" "assert" "break" "continue" "del" "elif" "else"
91 "except" "exec" "finally" "for" "from" "global" "if"
92 "import" "in" "is" "lambda" "not" "or" "pass" "print"
93 "raise" "return" "try" "while" "yield"
97 (,(rx (and word-start
(group "class") (1+ space
) (group (1+ word
))))
98 (1 font-lock-keyword-face
) (2 font-lock-type-face
))
99 (,(rx (and word-start
(group "def") (1+ space
) (group (1+ word
))))
100 (1 font-lock-keyword-face
) (2 font-lock-function-name-face
))))
102 (defconst python-font-lock-syntactic-keywords
103 ;; Make outer chars of matching triple-quote sequences into generic
104 ;; string delimiters. Fixme: Is there a better way?
105 `((,(rx (and (or line-start buffer-start
(not (syntax escape
))) ; avoid escaped
107 (group (optional (any "uUrR"))) ; prefix gets syntax property
108 (optional (any "rR")) ; possible second prefix
109 (group (syntax string-quote
)) ; maybe gets property
110 (backref 2) ; per first quote
111 (group (backref 2)))) ; maybe gets property
112 (1 (python-quote-syntax 1))
113 (2 (python-quote-syntax 2))
114 (3 (python-quote-syntax 3)))
115 ;; This doesn't really help.
116 ;;; (,(rx (and ?\\ (group ?\n))) (1 " "))
119 (defun python-quote-syntax (n)
120 "Put `syntax-table' property correctly on triple quote.
121 Used for syntactic keywords. N is the match number (1, 2 or 3)."
122 ;; Given a triple quote, we have to check the context to know
123 ;; whether this is an opening or closing triple or whether it's
124 ;; quoted anyhow, and should be ignored. (For that we need to do
125 ;; the same job as `syntax-ppss' to be correct and it seems to be OK
126 ;; to use it here despite initial worries.) We also have to sort
127 ;; out a possible prefix -- well, we don't _have_ to, but I think it
128 ;; should be treated as part of the string.
131 ;; ur"""ar""" x='"' # """
134 ;; x '"""' x """ \"""" x
136 (goto-char (match-beginning 0))
138 ;; Consider property for the last char if in a fenced string.
140 (let ((syntax (syntax-ppss)))
141 (when (eq t
(nth 3 syntax
)) ; after unclosed fence
142 (goto-char (nth 8 syntax
)) ; fence position
144 (if (memq (char-after) '(?u ?U ?R ?r
))
145 (skip-chars-forward "uUrR"))
146 ;; Is it a matching sequence?
147 (if (eq (char-after) (char-after (match-beginning 2)))
148 (eval-when-compile (string-to-syntax "|"))))))
149 ;; Consider property for initial char, accounting for prefixes.
150 ((or (and (= n
2) ; not prefix
151 (= (match-beginning 1) (match-end 1))) ; prefix is null
152 (and (= n
1) ; prefix
153 (/= (match-beginning 1) (match-end 1)))) ; non-empty
154 (unless (eq 'string
(syntax-ppss-context (syntax-ppss)))
155 (eval-when-compile (string-to-syntax "|"))))
156 ;; Otherwise (we're in a non-matching string) the property is
160 ;; This isn't currently in `font-lock-defaults' as probably not worth
161 ;; it -- we basically only mess with a few normally-symbol characters.
163 ;; (defun python-font-lock-syntactic-face-function (state)
164 ;; "`font-lock-syntactic-face-function' for Python mode.
165 ;; Returns the string or comment face as usual, with side effect of putting
166 ;; a `syntax-table' property on the inside of the string or comment which is
167 ;; the standard syntax table."
170 ;; (goto-char (nth 8 state))
171 ;; (condition-case nil
174 ;; (put-text-property (1+ (nth 8 state)) (1- (point))
175 ;; 'syntax-table (standard-syntax-table))
176 ;; 'font-lock-string-face)
177 ;; (put-text-property (1+ (nth 8 state)) (line-end-position)
178 ;; 'syntax-table (standard-syntax-table))
179 ;; 'font-lock-comment-face))
181 ;;;; Keymap and syntax
183 (defvar python-mode-map
184 (let ((map (make-sparse-keymap)))
185 ;; Mostly taken from python-mode.el.
186 (define-key map
":" 'python-electric-colon
)
187 (define-key map
"\177" 'python-backspace
)
188 (define-key map
"\C-c<" 'python-shift-left
)
189 (define-key map
"\C-c>" 'python-shift-right
)
190 (define-key map
"\C-c\C-k" 'python-mark-block
)
191 (define-key map
"\C-c\C-n" 'python-next-statement
)
192 (define-key map
"\C-c\C-p" 'python-previous-statement
)
193 (define-key map
"\C-c\C-u" 'python-beginning-of-block
)
194 (define-key map
"\C-c\C-f" 'python-describe-symbol
)
195 (define-key map
"\C-c\C-w" 'python-check
)
196 (define-key map
"\C-c\C-v" 'python-check
) ; a la sgml-mode
197 (define-key map
"\C-c\C-s" 'python-send-string
)
198 (define-key map
[?\C-\M-x
] 'python-send-defun
)
199 (define-key map
"\C-c\C-r" 'python-send-region
)
200 (define-key map
"\C-c\M-r" 'python-send-region-and-go
)
201 (define-key map
"\C-c\C-c" 'python-send-buffer
)
202 (define-key map
"\C-c\C-z" 'python-switch-to-python
)
203 (define-key map
"\C-c\C-m" 'python-load-file
)
204 (define-key map
"\C-c\C-l" 'python-load-file
) ; a la cmuscheme
205 (substitute-key-definition 'complete-symbol
'python-complete-symbol
207 ;; Fixme: Add :help to menu.
208 (easy-menu-define python-menu map
"Python Mode menu"
210 ["Shift region left" python-shift-left
:active mark-active
]
211 ["Shift region right" python-shift-right
:active mark-active
]
213 ["Mark block" python-mark-block
]
214 ["Mark def/class" mark-defun
215 :help
"Mark innermost definition around point"]
217 ["Start of block" python-beginning-of-block
]
218 ["End of block" python-end-of-block
]
219 ["Start of def/class" beginning-of-defun
220 :help
"Go to start of innermost definition around point"]
221 ["End of def/class" end-of-defun
222 :help
"Go to end of innermost definition around point"]
224 ["Start interpreter" run-python
225 :help
"Run `inferior' Python in separate buffer"]
226 ["Import/reload file" python-load-file
227 :help
"Load into inferior Python session"]
228 ["Eval buffer" python-send-buffer
229 :help
"Evaluate buffer en bloc in inferior Python session"]
230 ["Eval region" python-send-region
:active mark-active
231 :help
"Evaluate region en bloc in inferior Python session"]
232 ["Eval def/class" python-send-defun
233 :help
"Evaluate current definition in inferior Python session"]
234 ["Switch to interpreter" python-switch-to-python
235 :help
"Switch to inferior Python buffer"]
236 ["Check file" python-check
:help
"Run pychecker"]
237 ["Debugger" pdb
:help
"Run pdb under GUD"]
239 ["Help on symbol" python-describe-symbol
240 :help
"Use pydoc on symbol at point"]))
243 (defvar python-mode-syntax-table
244 (let ((table (make-syntax-table)))
245 ;; Give punctuation syntax to ASCII that normally has symbol
246 ;; syntax or has word syntax and isn't a letter.
247 (let ((symbol (string-to-syntax "_"))
248 (sst (standard-syntax-table)))
251 (if (equal symbol
(aref sst i
))
252 (modify-syntax-entry i
"." table
)))))
253 (modify-syntax-entry ?$
"." table
)
254 (modify-syntax-entry ?%
"." table
)
256 (modify-syntax-entry ?
# "<" table
)
257 (modify-syntax-entry ?
\n ">" table
)
258 (modify-syntax-entry ?
' "\"" table
)
259 (modify-syntax-entry ?
` "$" table
)
264 (defsubst python-in-string
/comment
()
265 "Return non-nil if point is in a Python literal (a comment or string)."
266 (syntax-ppss-context (syntax-ppss)))
268 (defconst python-space-backslash-table
269 (let ((table (copy-syntax-table python-mode-syntax-table
)))
270 (modify-syntax-entry ?
\\ " " table
)
272 "`python-mode-syntax-table' with backslash given whitespace syntax.")
274 (defun python-skip-comments/blanks
(&optional backward
)
275 "Skip comments and blank lines.
276 BACKWARD non-nil means go backwards, otherwise go forwards. Backslash is
277 treated as whitespace so that continued blank lines are skipped.
278 Doesn't move out of comments -- should be outside or at end of line."
279 (with-syntax-table python-space-backslash-table
280 (forward-comment (if backward
282 most-positive-fixnum
))))
284 (defun python-backslash-continuation-line-p ()
285 "Non-nil if preceding line ends with backslash that is not in a comment."
286 (and (eq ?
\\ (char-before (line-end-position 0)))
287 (not (syntax-ppss-context (syntax-ppss)))))
289 (defun python-continuation-line-p ()
290 "Return non-nil if current line continues a previous one.
291 The criteria are that the previous line ends in a backslash outside
292 comments and strings, or that the bracket/paren nesting depth is nonzero."
293 (or (and (eq ?
\\ (char-before (line-end-position 0)))
294 (not (syntax-ppss-context (syntax-ppss))))
295 (/= 0 (syntax-ppss-depth
296 (save-excursion ; syntax-ppss with arg changes point
297 (syntax-ppss (line-beginning-position)))))))
299 (defun python-comment-line-p ()
300 "Return non-nil iff current line has only a comment."
303 (when (eq 'comment
(syntax-ppss-context (syntax-ppss)))
304 (back-to-indentation)
305 (looking-at (rx (or (syntax comment-start
) line-end
))))))
307 (defun python-beginning-of-string ()
308 "Go to beginning of string around point.
309 Do nothing if not in string."
310 (let ((state (syntax-ppss)))
311 (when (eq 'string
(syntax-ppss-context state
))
312 (goto-char (nth 8 state
)))))
314 (defun python-open-block-statement-p (&optional bos
)
315 "Return non-nil if statement at point opens a block.
316 BOS non-nil means point is known to be at beginning of statement."
318 (unless bos
(python-beginning-of-statement))
319 (and (not (python-comment-line-p))
320 (re-search-forward (rx (and ?
: (0+ space
)
321 (optional (and (syntax comment-start
)
324 (save-excursion (python-end-of-statement))
326 (not (progn (goto-char (match-beginning 0))
327 (python-in-string/comment
))))))
329 (defun python-close-block-statement-p (&optional bos
)
330 "Return non-nil if current line is a statement closing a block.
331 BOS non-nil means point is at beginning of statement.
332 The criteria are that the line isn't a comment or in string and starts with
333 keyword `raise', `break', `continue' or `pass'."
335 (unless bos
(python-beginning-of-statement))
336 (back-to-indentation)
337 (looking-at (rx (and (or "return" "raise" "break" "continue" "pass")
340 (defun python-outdent-p ()
341 "Return non-nil if current line should outdent a level."
343 (back-to-indentation)
344 (and (looking-at (rx (and (or (and (or "else" "finally") symbol-end
)
345 (and (or "except" "elif") symbol-end
346 (1+ (not (any ?
:)))))
347 (optional space
) ":" (optional space
)
348 (or (syntax comment-start
) line-end
))))
350 (not (python-in-string/comment
)))
351 ;; Ensure there's a previous statement and move to it.
352 (zerop (python-previous-statement))
353 (not (python-close-block-statement-p t
))
355 (not (looking-at (rx (and (or (and (or "if" "elif" "except"
357 symbol-end
(1+ (not (any ?
:))))
358 (and "try" symbol-end
))
359 (optional space
) ":" (optional space
)
360 (or (syntax comment-start
) line-end
)))))
362 (not (python-in-string/comment
))))))
366 (defcustom python-indent
4
367 "*Number of columns for a unit of indentation in Python mode.
368 See also `\\[python-guess-indent]'"
372 (defcustom python-guess-indent t
373 "*Non-nil means Python mode guesses `python-indent' for the buffer."
377 (defcustom python-indent-string-contents t
378 "*Non-nil means indent contents of multi-line strings together.
379 This means indent them the same as the preceding non-blank line.
380 Otherwise indent them to column zero."
381 :type
'(choice (const :tag
"Align with preceding" t
)
382 (const :tag
"Indent to column 0" nil
))
385 (defcustom python-honour-comment-indentation nil
386 "Non-nil means indent relative to preceding comment line.
387 Only do this for comments where the leading comment character is followed
388 by space. This doesn't apply to comment lines, which are always indented
389 in lines with preceding comments."
393 (defcustom python-continuation-offset
4
394 "*Number of columns of additional indentation for continuation lines.
395 Continuation lines follow a backslash-terminated line starting a statement."
399 (defun python-guess-indent ()
400 "Guess step for indentation of current buffer.
401 Set `python-indent' locally to the value guessed."
406 (goto-char (point-min))
408 (while (and (not done
) (not (eobp)))
409 (when (and (re-search-forward (rx (and ?
: (0+ space
)
410 (or (syntax comment-start
)
413 (python-open-block-statement-p))
415 (python-beginning-of-statement)
416 (let ((initial (current-indentation)))
417 (if (zerop (python-next-statement))
418 (setq indent
(- (current-indentation) initial
)))
419 (if (and (>= indent
2) (<= indent
8)) ; sanity check
422 (when (/= indent
(default-value 'python-indent
))
423 (set (make-local-variable 'python-indent
) indent
)
424 (unless (= tab-width python-indent
)
425 (setq indent-tabs-mode nil
)))
428 (defun python-calculate-indentation ()
429 "Calculate Python indentation for line at point."
432 (let ((syntax (syntax-ppss))
435 ((eq 'string
(syntax-ppss-context syntax
)) ; multi-line string
436 (if (not python-indent-string-contents
)
439 ;; Find indentation of preceding non-blank line within string.
440 (setq start
(nth 8 syntax
))
442 (while (and (< start
(point)) (looking-at "\\s-*$"))
444 (current-indentation))))
445 ((python-continuation-line-p)
446 (let ((point (point))
447 (open-start (cadr syntax
)))
449 ;; Inside bracketed expression.
451 (goto-char (1+ open-start
))
452 ;; Look for first item in list (preceding point) and
453 ;; align with it, if found.
454 (if (with-syntax-table python-space-backslash-table
455 (let ((parse-sexp-ignore-comments t
))
457 (progn (forward-sexp)
462 ;; Otherwise indent relative to statement start, one
463 ;; level per bracketing level.
464 (goto-char (1+ open-start
))
465 (python-beginning-of-statement)
466 (+ (current-indentation) (* (car syntax
) python-indent
))))
467 ;; Otherwise backslash-continued.
469 (if (python-continuation-line-p)
470 ;; We're past first continuation line. Align with
472 (current-indentation)
473 ;; First continuation line. Indent one step, with an
474 ;; extra one if statement opens a block.
476 (python-beginning-of-statement)
477 (+ (current-indentation) python-continuation-offset
478 (if (python-open-block-statement-p t
)
482 ;; Fixme: Like python-mode.el; not convinced by this.
483 ((looking-at (rx (and (0+ space
) (syntax comment-start
)
484 (not (any " \t\n"))))) ; non-indentable comment
485 (current-indentation))
486 (t (let ((point (point)))
487 (if python-honour-comment-indentation
488 ;; Back over whitespace, newlines, non-indentable comments.
492 ;; not at comment start
493 ((not (forward-comment -
1))
494 (python-beginning-of-statement)
497 ((/= (current-column) (current-indentation))
498 (python-beginning-of-statement)
500 ;; indentable comment like python-mode.el
501 ((and (looking-at (rx (and (syntax comment-start
)
502 (or space line-end
))))
503 (/= 0 (current-column)))))
505 ;; Else back over all comments.
506 (python-skip-comments/blanks t
)
507 (python-beginning-of-statement))
508 ;; don't lose on bogus outdent
509 (max 0 (+ (current-indentation)
510 (or (cond ((python-open-block-statement-p t
)
512 ((python-close-block-statement-p t
)
514 (progn (goto-char point
)
515 (if (python-outdent-p)
519 (defun python-comment-indent ()
520 "`comment-indent-function' for Python."
521 ;; If previous non-blank line was a comment, use its indentation.
522 ;; FIXME: This seems unnecessary since the default code delegates to
523 ;; indent-according-to-mode. --Stef
527 (if (eq ?
# (char-after)) (current-column)))))
529 ;;;; Cycling through the possible indentations with successive TABs.
531 ;; These don't need to be buffer-local since they're only relevant
534 ;; Alist of possible indentations and start of statement they would close.
535 (defvar python-indent-list nil
537 ;; Length of the above
538 (defvar python-indent-list-length nil
540 ;; Current index into the alist.
541 (defvar python-indent-index nil
544 (defun python-initial-text ()
545 "Text of line following indentation and ignoring any trailing comment."
546 (buffer-substring (+ (line-beginning-position) (current-indentation))
552 (defun python-indentation-levels ()
553 "Return a list of possible indentations for this line.
554 Includes the default indentation and those which would close all
555 enclosing blocks. Assumes the line has already been indented per
556 `python-indent-line'. Elements of the list are actually pairs:
557 \(INDENTATION . TEXT), where TEXT is the initial text of the
558 corresponding block opening (or nil)."
560 (let ((levels (list (cons (current-indentation)
562 (if (python-beginning-of-block)
563 (python-initial-text)))))))
564 ;; Only one possibility if we immediately follow a block open or
565 ;; are in a continuation line.
566 (unless (or (python-continuation-line-p)
567 (save-excursion (and (python-previous-statement)
568 (python-open-block-statement-p t
))))
569 (while (python-beginning-of-block)
570 (push (cons (current-indentation) (python-initial-text))
574 ;; This is basically what `python-indent-line' would be if we didn't
576 (defun python-indent-line-1 ()
577 "Subroutine of `python-indent-line'."
578 (let ((target (python-calculate-indentation))
579 (pos (- (point-max) (point))))
580 (if (= target
(current-indentation))
581 (if (< (current-column) (current-indentation))
582 (back-to-indentation))
584 (delete-horizontal-space)
586 (if (> (- (point-max) pos
) (point))
587 (goto-char (- (point-max) pos
))))))
589 (defun python-indent-line ()
590 "Indent current line as Python code.
591 When invoked via `indent-for-tab-command', cycle through possible
592 indentations for current line. The cycle is broken by a command different
593 from `indent-for-tab-command', i.e. successive TABs do the cycling."
595 ;; Don't do extra work if invoked via `indent-region', for instance.
596 (if (not (eq this-command
'indent-for-tab-command
))
597 (python-indent-line-1)
598 (if (eq last-command this-command
)
599 (if (= 1 python-indent-list-length
)
600 (message "Sole indentation")
601 (progn (setq python-indent-index
(%
(1+ python-indent-index
)
602 python-indent-list-length
))
604 (delete-horizontal-space)
605 (indent-to (car (nth python-indent-index python-indent-list
)))
606 (if (python-block-end-p)
607 (let ((text (cdr (nth python-indent-index
608 python-indent-list
))))
610 (message "Closes: %s" text
))))))
611 (python-indent-line-1)
612 (setq python-indent-list
(python-indentation-levels)
613 python-indent-list-length
(length python-indent-list
)
614 python-indent-index
(1- python-indent-list-length
)))))
616 (defun python-block-end-p ()
617 "Non-nil if this is a line in a statement closing a block,
618 or a blank line indented to where it would close a block."
619 (and (not (python-comment-line-p))
620 (or (python-close-block-statement-p t
)
621 (< (current-indentation)
623 (python-previous-statement)
624 (current-indentation))))))
626 ;; Fixme: Define an indent-region-function. It should probably leave
627 ;; lines alone if the indentation is already at one of the allowed
628 ;; levels. Otherwise, M-C-\ typically keeps indenting more deeply
633 (defun python-beginning-of-defun ()
634 "`beginning-of-defun-function' for Python.
635 Finds beginning of innermost nested class or method definition.
636 Returns the name of the definition found at the end, or nil if reached
638 (let ((ci (current-indentation))
639 (def-re (rx (and line-start
(0+ space
) (or "def" "class")
641 (group (1+ (or word
(syntax symbol
)))))))
643 (if (python-comment-line-p)
644 (setq ci most-positive-fixnum
))
645 (while (and (not (bobp)) (not found
))
646 ;; Treat bol at beginning of function as outside function so
647 ;; that successive C-M-a makes progress backwards.
648 (setq def-line
(looking-at def-re
))
649 (unless (bolp) (end-of-line))
650 (setq lep
(line-end-position))
651 (if (and (re-search-backward def-re nil
'move
)
652 ;; Must be less indented or matching top level, or
653 ;; equally indented if we started on a definition line.
654 (let ((in (current-indentation)))
655 (or (and (zerop ci
) (zerop in
))
656 (= lep
(line-end-position)) ; on initial line
657 (and def-line
(= in ci
))
659 (not (python-in-string/comment
)))
662 (defun python-end-of-defun ()
663 "`end-of-defun-function' for Python.
664 Finds end of innermost nested class or method definition."
666 (pattern (rx (and line-start
(0+ space
) (or "def" "class") space
))))
667 ;; Go to start of current block and check whether it's at top
668 ;; level. If it is, and not a block start, look forward for
669 ;; definition statement.
670 (when (python-comment-line-p)
672 (forward-comment most-positive-fixnum
))
673 (if (not (python-open-block-statement-p))
674 (python-beginning-of-block))
675 (if (zerop (current-indentation))
676 (unless (python-open-block-statement-p)
677 (while (and (re-search-forward pattern nil
'move
)
678 (python-in-string/comment
))) ; just loop
680 (beginning-of-line)))
681 ;; Don't move before top-level statement that would end defun.
683 (python-beginning-of-defun))
684 ;; If we got to the start of buffer, look forward for
685 ;; definition statement.
686 (if (and (bobp) (not (looking-at "def\\|class")))
687 (while (and (not (eobp))
688 (re-search-forward pattern nil
'move
)
689 (python-in-string/comment
)))) ; just loop
690 ;; We're at a definition statement (or end-of-buffer).
692 (python-end-of-block)
693 ;; Count trailing space in defun (but not trailing comments).
694 (skip-syntax-forward " >")
696 ;; Catch pathological case like this, where the beginning-of-defun
697 ;; skips to a definition we're not in:
705 (goto-char (point-max)))))
707 (defun python-beginning-of-statement ()
708 "Go to start of current statement.
709 Accounts for continuation lines, multi-line strings, and multi-line bracketed
712 (python-beginning-of-string)
714 (while (python-continuation-line-p)
716 (if (python-backslash-continuation-line-p)
717 (while (python-backslash-continuation-line-p)
719 (python-beginning-of-string)
720 ;; Skip forward out of nested brackets.
721 (condition-case () ; beware invalid syntax
722 (progn (backward-up-list (syntax-ppss-depth (syntax-ppss))) t
)
723 (error (throw 'foo nil
))))))
724 (back-to-indentation))
726 (defun python-end-of-statement ()
727 "Go to the end of the current statement and return point.
728 Usually this is the start of the next line, but if this is a
729 multi-line statement we need to skip over the continuation lines.
730 On a comment line, go to end of line."
732 (while (let (comment)
733 ;; Move past any enclosing strings and sexps, or stop if
734 ;; we're in a comment.
735 (while (let ((s (syntax-ppss)))
736 (cond ((eq 'comment
(syntax-ppss-context s
))
739 ((eq 'string
(syntax-ppss-context s
))
740 ;; Go to start of string and skip it.
741 (goto-char (nth 8 s
))
742 (condition-case () ; beware invalid syntax
743 (progn (forward-sexp) t
)
744 (error (end-of-line))))
745 ((> (syntax-ppss-depth s
) 0)
746 ;; Skip forward out of nested brackets.
747 (condition-case () ; beware invalid syntax
748 (progn (backward-up-list
749 (- (syntax-ppss-depth s
)))
751 (error (end-of-line))))))
754 (eq ?
\\ (char-before)))) ; Line continued?
755 (end-of-line 2)) ; Try next line.
758 (defun python-previous-statement (&optional count
)
759 "Go to start of previous statement.
760 With argument COUNT, do it COUNT times. Stop at beginning of buffer.
761 Return count of statements left to move."
763 (unless count
(setq count
1))
765 (python-next-statement (- count
))
766 (python-beginning-of-statement)
767 (while (and (> count
0) (not (bobp)))
768 (python-skip-comments/blanks t
)
769 (python-beginning-of-statement)
770 (unless (bobp) (setq count
(1- count
))))
773 (defun python-next-statement (&optional count
)
774 "Go to start of next statement.
775 With argument COUNT, do it COUNT times. Stop at end of buffer.
776 Return count of statements left to move."
778 (unless count
(setq count
1))
780 (python-previous-statement (- count
))
782 (while (and (> count
0) (not (eobp)))
783 (python-end-of-statement)
784 (python-skip-comments/blanks
)
785 (setq count
(1- count
)))
788 (defun python-beginning-of-block (&optional arg
)
789 "Go to start of current block.
790 With numeric arg, do it that many times. If ARG is negative, call
791 `python-end-of-block' instead.
792 If point is on the first line of a block, use its outer block.
793 If current statement is in column zero, don't move and return nil.
794 Otherwise return non-nil."
796 (unless arg
(setq arg
1))
799 ((< arg
0) (python-end-of-block (- arg
)))
801 (let ((point (point)))
802 (if (python-comment-line-p)
803 (python-skip-comments/blanks t
))
804 (python-beginning-of-statement)
805 (let ((ci (current-indentation)))
807 (not (goto-char point
)) ; return nil
808 ;; Look upwards for less indented statement.
810 ;;; This is slower than the below.
811 ;;; (while (zerop (python-previous-statement))
812 ;;; (when (and (< (current-indentation) ci)
813 ;;; (python-open-block-statement-p t))
814 ;;; (beginning-of-line)
815 ;;; (throw 'done t)))
816 (while (and (zerop (forward-line -
1)))
817 (when (and (< (current-indentation) ci
)
818 (not (python-comment-line-p))
819 ;; Move to beginning to save effort in case
820 ;; this is in string.
821 (progn (python-beginning-of-statement) t
)
822 (python-open-block-statement-p t
))
825 (not (goto-char point
))) ; Failed -- return nil
826 (python-beginning-of-block (1- arg
)))))))))
828 (defun python-end-of-block (&optional arg
)
829 "Go to end of current block.
830 With numeric arg, do it that many times. If ARG is negative, call
831 `python-beginning-of-block' instead.
832 If current statement is in column zero and doesn't open a block, don't
833 move and return nil. Otherwise return t."
835 (unless arg
(setq arg
1))
837 (python-beginning-of-block (- arg
)))
838 (while (and (> arg
0)
839 (let* ((point (point))
840 (_ (if (python-comment-line-p)
841 (python-skip-comments/blanks t
)))
842 (ci (current-indentation))
843 (open (python-open-block-statement-p)))
844 (if (and (zerop ci
) (not open
))
845 (not (goto-char point
))
847 (while (zerop (python-next-statement))
848 (when (or (and open
(<= (current-indentation) ci
))
849 (< (current-indentation) ci
))
850 (python-skip-comments/blanks t
)
851 (beginning-of-line 2)
853 (not (goto-char point
))))))
859 (defvar python-recursing
)
860 (defun python-imenu-create-index ()
861 "`imenu-create-index-function' for Python.
863 Makes nested Imenu menus from nested `class' and `def' statements.
864 The nested menus are headed by an item referencing the outer
865 definition; it has a space prepended to the name so that it sorts
866 first with `imenu--sort-by-name' (though, unfortunately, sub-menus
868 (unless (boundp 'python-recursing
) ; dynamically bound below
869 (goto-char (point-min))) ; normal call from Imenu
870 (let (index-alist ; accumulated value to return
872 (while (re-search-forward
873 (rx (and line-start
(0+ space
) ; leading space
874 (or (group "def") (group "class")) ; type
875 (1+ space
) (group (1+ (or word ?_
))))) ; name
877 (unless (python-in-string/comment
)
878 (let ((pos (match-beginning 0))
879 (name (match-string-no-properties 3)))
880 (if (match-beginning 2) ; def or class?
881 (setq name
(concat "class " name
)))
884 (let* ((python-recursing t
)
885 (sublist (python-imenu-create-index)))
887 (progn (push (cons (concat " " name
) pos
) sublist
)
888 (push (cons name sublist
) index-alist
))
889 (push (cons name pos
) index-alist
)))))))
890 (nreverse index-alist
)))
892 ;;;; `Electric' commands.
894 (defun python-electric-colon (arg)
895 "Insert a colon and maybe outdent the line if it is a statement like `else'.
896 With numeric ARG, just insert that many colons. With \\[universal-argument],
897 just insert a single colon."
899 (self-insert-command (if (not (integerp arg
)) 1 arg
))
903 (not (python-in-string/comment
))
904 (> (current-indentation) (python-calculate-indentation))
905 (python-indent-line))) ; OK, do it
906 (put 'python-electric-colon
'delete-selection t
)
908 (defun python-backspace (arg)
909 "Maybe delete a level of indentation on the current line.
910 If not at the end of line's indentation, or on a comment line, just call
911 `backward-delete-char-untabify'. With ARG, repeat that many times."
913 (if (or (/= (current-indentation) (current-column))
915 (python-continuation-line-p))
916 (backward-delete-char-untabify arg
)
919 (while (and (> arg
0) (python-beginning-of-block))
922 (setq indent
(current-indentation))
923 (message "Closes %s" (python-initial-text))))
924 (delete-horizontal-space)
925 (indent-to indent
))))
926 (put 'python-backspace
'delete-selection
'supersede
)
930 (defcustom python-check-command
"pychecker --stdlib"
931 "*Command used to check a Python file."
935 (defvar python-saved-check-command nil
938 ;; After `sgml-validate-command'.
939 (defun python-check (command)
940 "Check a Python file (default current buffer's file).
941 Runs COMMAND, a shell command, as if by `compile'.
942 See `python-check-command' for the default."
944 (list (read-string "Checker command: "
945 (or python-saved-check-command
946 (concat python-check-command
" "
947 (let ((name (buffer-file-name)))
949 (file-name-nondirectory name
))))))))
950 (setq python-saved-check-command command
)
951 (require 'compile
) ;To define compilation-* variables.
952 (save-some-buffers (not compilation-ask-about-save
) nil
)
953 (let ((compilation-error-regexp-alist
954 (cons '("(\\([^,]+\\), line \\([0-9]+\\))" 1 2)
955 compilation-error-regexp-alist
)))
956 (compilation-start command
)))
958 ;;;; Inferior mode stuff (following cmuscheme).
960 ;; Fixme: Make sure we can work with IPython.
962 (defcustom python-python-command
"python"
963 "*Shell command to run Python interpreter.
964 Any arguments can't contain whitespace.
965 Note that IPython may not work properly; it must at least be used with the
966 `-cl' flag, i.e. use `ipython -cl'."
970 (defcustom python-jython-command
"jython"
971 "*Shell command to run Jython interpreter.
972 Any arguments can't contain whitespace."
976 (defvar python-command python-python-command
977 "Actual command used to run Python.
978 May be `python-python-command' or `python-jython-command'.
979 Additional arguments are added when the command is used by `run-python'
982 (defvar python-buffer nil
983 "The current python process buffer."
984 ;; Fixme: a single process is currently assumed, so that this doc
987 ;; "*The current python process buffer.
988 ;; To run multiple Python processes, start the first with \\[run-python].
989 ;; It will be in a buffer named *Python*. Rename that with
990 ;; \\[rename-buffer]. Now start a new process with \\[run-python]. It
991 ;; will be in a new buffer, named *Python*. Switch between the different
992 ;; process buffers with \\[switch-to-buffer].
994 ;; Commands that send text from source buffers to Python processes have
995 ;; to choose a process to send to. This is determined by global variable
996 ;; `python-buffer'. Suppose you have three inferior Pythons running:
1000 ;; *Python* python<3>
1001 ;; If you do a \\[python-send-region-and-go] command on some Python source
1002 ;; code, what process does it go to?
1004 ;; - In a process buffer (foo, bar, or *Python*), send it to that process.
1005 ;; - In some other buffer (e.g. a source file), send it to the process
1006 ;; attached to `python-buffer'.
1007 ;; Process selection is done by function `python-proc'.
1009 ;; Whenever \\[run-python] starts a new process, it resets `python-buffer'
1010 ;; to be the new process's buffer. If you only run one process, this will
1011 ;; do the right thing. If you run multiple processes, you can change
1012 ;; `python-buffer' to another process buffer with \\[set-variable]."
1015 (defconst python-compilation-regexp-alist
1016 ;; FIXME: maybe these should move to compilation-error-regexp-alist-alist.
1017 `((,(rx (and line-start
(1+ (any " \t")) "File \""
1018 (group (1+ (not (any "\"<")))) ; avoid `<stdin>' &c
1019 "\", line " (group (1+ digit
))))
1021 (,(rx (and " in file " (group (1+ not-newline
)) " on line "
1022 (group (1+ digit
))))
1024 "`compilation-error-regexp-alist' for inferior Python.")
1026 (defvar inferior-python-mode-map
1027 (let ((map (make-sparse-keymap)))
1028 ;; This will inherit from comint-mode-map.
1029 (define-key map
"\C-c\C-l" 'python-load-file
)
1030 (define-key map
"\C-c\C-v" 'python-check
)
1031 ;; Note that we _can_ still use these commands which send to the
1032 ;; Python process even at the prompt iff we have a normal prompt,
1033 ;; i.e. '>>> ' and not '... '. See the comment before
1034 ;; python-send-region. Fixme: uncomment these if we address that.
1036 ;; (define-key map [(meta ?\t)] 'python-complete-symbol)
1037 ;; (define-key map "\C-c\C-f" 'python-describe-symbol)
1040 ;; Fixme: This should inherit some stuff from python-mode, but I'm not
1041 ;; sure how much: at least some keybindings, like C-c C-f; syntax?;
1042 ;; font-locking, e.g. for triple-quoted strings?
1043 (define-derived-mode inferior-python-mode comint-mode
"Inferior Python"
1044 "Major mode for interacting with an inferior Python process.
1045 A Python process can be started with \\[run-python].
1047 Hooks `comint-mode-hook' and `inferior-python-mode-hook' are run in
1050 You can send text to the inferior Python process from other buffers containing
1052 * `python-switch-to-python' switches the current buffer to the Python
1054 * `python-send-region' sends the current region to the Python process.
1055 * `python-send-region-and-go' switches to the Python process buffer
1056 after sending the text.
1057 For running multiple processes in multiple buffers, see `python-buffer'.
1059 \\{inferior-python-mode-map}"
1061 (set-syntax-table python-mode-syntax-table
)
1062 (setq mode-line-process
'(":%s"))
1063 (set (make-local-variable 'comint-input-filter
) 'python-input-filter
)
1064 (add-hook 'comint-preoutput-filter-functions
#'python-preoutput-filter
1066 ;; Still required by `comint-redirect-send-command', for instance
1067 ;; (and we need to match things like `>>> ... >>> '):
1068 (set (make-local-variable 'comint-prompt-regexp
)
1069 (rx (and line-start
(1+ (and (repeat 3 (any ">.")) ?\s
)))))
1070 (set (make-local-variable 'compilation-error-regexp-alist
)
1071 python-compilation-regexp-alist
)
1072 (compilation-shell-minor-mode 1))
1074 (defcustom inferior-python-filter-regexp
"\\`\\s-*\\S-?\\S-?\\s-*\\'"
1075 "*Input matching this regexp is not saved on the history list.
1076 Default ignores all inputs of 0, 1, or 2 non-blank characters."
1080 (defun python-input-filter (str)
1081 "`comint-input-filter' function for inferior Python.
1082 Don't save anything for STR matching `inferior-python-filter-regexp'."
1083 (not (string-match inferior-python-filter-regexp str
)))
1085 ;; Fixme: Loses with quoted whitespace.
1086 (defun python-args-to-list (string)
1087 (let ((where (string-match "[ \t]" string
)))
1088 (cond ((null where
) (list string
))
1090 (cons (substring string
0 where
)
1091 (python-args-to-list (substring string
(+ 1 where
)))))
1092 (t (let ((pos (string-match "[^ \t]" string
)))
1093 (if pos
(python-args-to-list (substring string pos
))))))))
1095 (defvar python-preoutput-result nil
1096 "Data from last `_emacs_out' line seen by the preoutput filter.")
1098 (defvar python-preoutput-continuation nil
1099 "If non-nil, funcall this when `python-preoutput-filter' sees `_emacs_ok'.")
1101 (defvar python-preoutput-leftover nil
)
1103 ;; Using this stops us getting lines in the buffer like
1105 ;; Also look for (and delete) an `_emacs_ok' string and call
1106 ;; `python-preoutput-continuation' if we get it.
1107 (defun python-preoutput-filter (s)
1108 "`comint-preoutput-filter-functions' function: ignore prompts not at bol."
1109 (when python-preoutput-leftover
1110 (setq s
(concat python-preoutput-leftover s
))
1111 (setq python-preoutput-leftover nil
))
1112 (cond ((and (string-match (rx (and string-start
(repeat 3 (any ".>"))
1115 (/= (let ((inhibit-field-text-motion t
))
1116 (line-beginning-position))
1119 ((string= s
"_emacs_ok\n")
1120 (when python-preoutput-continuation
1121 (funcall python-preoutput-continuation
)
1122 (setq python-preoutput-continuation nil
))
1124 ((string-match "_emacs_out \\(.*\\)\n" s
)
1125 (setq python-preoutput-result
(match-string 1 s
))
1127 ((string-match ".*\n" s
)
1129 ((or (eq t
(compare-strings s nil nil
"_emacs_ok\n" nil
(length s
)))
1130 (let ((end (min (length "_emacs_out ") (length s
))))
1131 (eq t
(compare-strings s nil end
"_emacs_out " nil end
))))
1132 (setq python-preoutput-leftover s
)
1137 (defun run-python (&optional cmd noshow
)
1138 "Run an inferior Python process, input and output via buffer *Python*.
1139 CMD is the Python command to run. NOSHOW non-nil means don't show the
1140 buffer automatically.
1141 If there is a process already running in `*Python*', switch to
1142 that buffer. Interactively, a prefix arg allows you to edit the initial
1143 command line (default is `python-command'); `-i' etc. args will be added
1144 to this as appropriate. Runs the hook `inferior-python-mode-hook'
1145 \(after the `comint-mode-hook' is run).
1146 \(Type \\[describe-mode] in the process buffer for a list of commands.)"
1147 (interactive (list (if current-prefix-arg
1148 (read-string "Run Python: " python-command
)
1150 (unless cmd
(setq cmd python-python-command
))
1151 (setq python-command cmd
)
1152 ;; Fixme: Consider making `python-buffer' buffer-local as a buffer
1153 ;; (not a name) in Python buffers from which `run-python' &c is
1154 ;; invoked. Would support multiple processes better.
1155 (unless (comint-check-proc python-buffer
)
1156 (let* ((cmdlist (append (python-args-to-list cmd
) '("-i")))
1157 (path (getenv "PYTHONPATH"))
1158 (process-environment ; to import emacs.py
1159 (cons (concat "PYTHONPATH=" data-directory
1160 (if path
(concat ":" path
)))
1161 process-environment
)))
1162 (set-buffer (apply 'make-comint
"Python" (car cmdlist
) nil
1164 (setq python-buffer
(buffer-name)))
1165 (inferior-python-mode)
1166 ;; Load function defintions we need.
1167 ;; Before the preoutput function was used, this was done via -c in
1168 ;; cmdlist, but that loses the banner and doesn't run the startup
1169 ;; file. The code might be inline here, but there's enough that it
1170 ;; seems worth putting in a separate file, and it's probably cleaner
1171 ;; to put it in a module.
1172 (python-send-string "import emacs"))
1173 (unless noshow
(pop-to-buffer python-buffer
)))
1175 ;; Fixme: We typically lose if the inferior isn't in the normal REPL,
1176 ;; e.g. prompt is `help> '. Probably raise an error if the form of
1177 ;; the prompt is unexpected; actually, it needs to be `>>> ', not
1178 ;; `... ', i.e. we're not inputting a block &c. However, this may not
1179 ;; be the place to do it, e.g. we might actually want to send commands
1180 ;; having set up such a state.
1182 (defun python-send-command (command)
1183 "Like `python-send-string' but resets `compilation-minor-mode'."
1184 (goto-char (point-max))
1185 (let ((end (marker-position (process-mark (python-proc)))))
1186 (compilation-forget-errors)
1187 (python-send-string command
)
1188 (set-marker compilation-parsing-end end
)
1189 (setq compilation-last-buffer
(current-buffer))))
1191 (defun python-send-region (start end
)
1192 "Send the region to the inferior Python process."
1193 ;; The region is evaluated from a temporary file. This avoids
1194 ;; problems with blank lines, which have different semantics
1195 ;; interactively and in files. It also saves the inferior process
1196 ;; buffer filling up with interpreter prompts. We need a Python
1197 ;; function to remove the temporary file when it has been evaluated
1198 ;; (though we could probably do it in Lisp with a Comint output
1199 ;; filter). This function also catches exceptions and truncates
1200 ;; tracebacks not to mention the frame of the function itself.
1202 ;; The compilation-minor-mode parsing takes care of relating the
1203 ;; reference to the temporary file to the source.
1205 ;; Fixme: Write a `coding' header to the temp file if the region is
1208 (let* ((f (make-temp-file "py"))
1209 (command (format "emacs.eexecfile(%S)" f
))
1210 (orig-start (copy-marker start
)))
1211 (when (save-excursion
1213 (/= 0 (current-indentation))) ; need dummy block
1215 (goto-char orig-start
)
1216 ;; Wrong if we had indented code at buffer start.
1217 (set-marker orig-start
(line-beginning-position 0)))
1218 (write-region "if True:\n" nil f nil
'nomsg
))
1219 (write-region start end f t
'nomsg
)
1220 (with-current-buffer (process-buffer (python-proc)) ;Runs python if needed.
1221 (python-send-command command
)
1222 ;; Tell compile.el to redirect error locations in file `f' to
1223 ;; positions past marker `orig-start'. It has to be done *after*
1224 ;; python-send-command's call to compilation-forget-errors.
1225 (compilation-fake-loc orig-start f
))))
1227 (defun python-send-string (string)
1228 "Evaluate STRING in inferior Python process."
1229 (interactive "sPython command: ")
1230 (comint-send-string (python-proc) string
)
1231 (comint-send-string (python-proc) "\n\n"))
1233 (defun python-send-buffer ()
1234 "Send the current buffer to the inferior Python process."
1236 (python-send-region (point-min) (point-max)))
1238 ;; Fixme: Try to define the function or class within the relevant
1239 ;; module, not just at top level.
1240 (defun python-send-defun ()
1241 "Send the current defun (class or method) to the inferior Python process."
1243 (save-excursion (python-send-region (progn (beginning-of-defun) (point))
1244 (progn (end-of-defun) (point)))))
1246 (defun python-switch-to-python (eob-p)
1247 "Switch to the Python process buffer.
1248 With prefix arg, position cursor at end of buffer."
1250 (pop-to-buffer (process-buffer (python-proc))) ;Runs python if needed.
1253 (goto-char (point-max))))
1255 (defun python-send-region-and-go (start end
)
1256 "Send the region to the inferior Python process.
1257 Then switch to the process buffer."
1259 (python-send-region start end
)
1260 (python-switch-to-python t
))
1262 (defcustom python-source-modes
'(python-mode jython-mode
)
1263 "*Used to determine if a buffer contains Python source code.
1264 If it's loaded into a buffer that is in one of these major modes, it's
1265 considered a Python source file by `python-load-file'.
1266 Used by these commands to determine defaults."
1267 :type
'(repeat function
)
1270 (defvar python-prev-dir
/file nil
1271 "Caches (directory . file) pair used in the last `python-load-file' command.
1272 Used for determining the default in the next one.")
1274 (defun python-load-file (file-name)
1275 "Load a Python file FILE-NAME into the inferior Python process.
1276 If the file has extension `.py' import or reload it as a module.
1277 Treating it as a module keeps the global namespace clean, provides
1278 function location information for debugging, and supports users of
1279 module-qualified names."
1280 (interactive (comint-get-source "Load Python file: " python-prev-dir
/file
1282 t
)) ; because execfile needs exact name
1283 (comint-check-source file-name
) ; Check to see if buffer needs saving.
1284 (setq python-prev-dir
/file
(cons (file-name-directory file-name
)
1285 (file-name-nondirectory file-name
)))
1286 (with-current-buffer (process-buffer (python-proc)) ;Runs python if needed.
1287 ;; Fixme: I'm not convinced by this logic from python-mode.el.
1288 (python-send-command
1289 (if (string-match "\\.py\\'" file-name
)
1290 (let ((module (file-name-sans-extension
1291 (file-name-nondirectory file-name
))))
1292 (format "emacs.eimport(%S,%S)"
1293 module
(file-name-directory file-name
)))
1294 (format "execfile(%S)" file-name
)))
1295 (message "%s loaded" file-name
)))
1297 ;; Fixme: If we need to start the process, wait until we've got the OK
1298 ;; from the startup.
1299 (defun python-proc ()
1300 "Return the current Python process.
1301 See variable `python-buffer'. Starts a new process if necessary."
1302 (or (if python-buffer
1303 (get-buffer-process (if (eq major-mode
'inferior-python-mode
)
1306 (progn (run-python nil t
)
1309 ;;;; Context-sensitive help.
1311 (defconst python-dotty-syntax-table
1312 (let ((table (make-syntax-table)))
1313 (set-char-table-parent table python-mode-syntax-table
)
1314 (modify-syntax-entry ?.
"_" table
)
1316 "Syntax table giving `.' symbol syntax.
1317 Otherwise inherits from `python-mode-syntax-table'.")
1319 (defvar view-return-to-alist
)
1320 (eval-when-compile (autoload 'help-buffer
"help-fns"))
1322 ;; Fixme: Should this actually be used instead of info-look, i.e. be
1323 ;; bound to C-h S? Can we use other pydoc stuff before python 2.2?
1324 (defun python-describe-symbol (symbol)
1325 "Get help on SYMBOL using `help'.
1326 Interactively, prompt for symbol.
1328 Symbol may be anything recognized by the interpreter's `help' command --
1329 e.g. `CALLS' -- not just variables in scope.
1330 This only works for Python version 2.2 or newer since earlier interpreters
1331 don't support `help'."
1332 ;; Note that we do this in the inferior process, not a separate one, to
1333 ;; ensure the environment is appropriate.
1335 (let ((symbol (with-syntax-table python-dotty-syntax-table
1337 (enable-recursive-minibuffers t
))
1338 (list (read-string (if symbol
1339 (format "Describe symbol (default %s): " symbol
)
1340 "Describe symbol: ")
1342 (if (equal symbol
"") (error "No symbol"))
1343 (let* ((func `(lambda ()
1344 (comint-redirect-send-command
1345 (format "emacs.ehelp(%S, globals(), locals())\n" ,symbol
)
1347 ;; Ensure we have a suitable help buffer.
1348 ;; Fixme: Maybe process `Related help topics' a la help xrefs and
1349 ;; allow C-c C-f in help buffer.
1350 (let ((temp-buffer-show-hook ; avoid xref stuff
1352 (toggle-read-only 1)
1353 (setq view-return-to-alist
1354 (list (cons (selected-window) help-return-method
))))))
1355 (help-setup-xref (list 'python-describe-symbol symbol
) (interactive-p))
1356 (with-output-to-temp-buffer (help-buffer)
1357 (with-current-buffer standard-output
1358 (set (make-local-variable 'comint-redirect-subvert-readonly
) t
)
1359 (print-help-return-message))))
1360 (if (and python-buffer
(get-buffer python-buffer
))
1361 (with-current-buffer python-buffer
1363 (setq python-preoutput-continuation func
)
1364 (run-python nil t
))))
1366 (add-to-list 'debug-ignored-errors
"^No symbol")
1368 (defun python-send-receive (string)
1369 "Send STRING to inferior Python (if any) and return result.
1370 The result is what follows `_emacs_out' in the output (or nil)."
1371 (let ((proc (python-proc)))
1372 (python-send-string string
)
1373 (setq python-preoutput-result nil
)
1375 (accept-process-output proc
5)
1376 python-preoutput-leftover
))
1377 python-preoutput-result
))
1379 ;; Fixme: try to make it work with point in the arglist. Also, is
1380 ;; there anything reasonable we can do with random methods?
1381 ;; (Currently only works with functions.)
1382 (defun python-eldoc-function ()
1383 "`eldoc-print-current-symbol-info' for Python.
1384 Only works when point is in a function name, not its arglist, for instance.
1385 Assumes an inferior Python is running."
1386 (let ((symbol (with-syntax-table python-dotty-syntax-table
1389 (python-send-receive (format "emacs.eargs(%S)" symbol
)))))
1391 ;;;; Info-look functionality.
1393 (defun python-after-info-look ()
1394 "Set up info-look for Python.
1395 Used with `eval-after-load'."
1396 (let* ((version (let ((s (shell-command-to-string (concat python-command
1398 (string-match "^Python \\([0-9]+\\.[0-9]+\\>\\)" s
)
1399 (match-string 1 s
)))
1400 ;; Whether info files have a Python version suffix, e.g. in Debian.
1403 (with-no-warnings (Info-mode))
1405 ;; Don't use `info' because it would pop-up a *info* buffer.
1407 (Info-goto-node (format "(python%s-lib)Miscellaneous Index"
1411 (info-lookup-maybe-add-help
1413 :regexp
"[[:alnum:]_]+"
1415 ;; Fixme: Can this reasonably be made specific to indices with
1416 ;; different rules? Is the order of indices optimal?
1417 ;; (Miscellaneous in -ref first prefers lookup of keywords, for
1420 ;; The empty prefix just gets us highlighted terms.
1421 `((,(concat "(python" version
"-ref)Miscellaneous Index") nil
"")
1422 (,(concat "(python" version
"-ref)Module Index" nil
""))
1423 (,(concat "(python" version
"-ref)Function-Method-Variable Index"
1425 (,(concat "(python" version
"-ref)Class-Exception-Object Index"
1427 (,(concat "(python" version
"-lib)Module Index" nil
""))
1428 (,(concat "(python" version
"-lib)Class-Exception-Object Index"
1430 (,(concat "(python" version
"-lib)Function-Method-Variable Index"
1432 (,(concat "(python" version
"-lib)Miscellaneous Index" nil
"")))
1433 '(("(python-ref)Miscellaneous Index" nil
"")
1434 ("(python-ref)Module Index" nil
"")
1435 ("(python-ref)Function-Method-Variable Index" nil
"")
1436 ("(python-ref)Class-Exception-Object Index" nil
"")
1437 ("(python-lib)Module Index" nil
"")
1438 ("(python-lib)Class-Exception-Object Index" nil
"")
1439 ("(python-lib)Function-Method-Variable Index" nil
"")
1440 ("(python-lib)Miscellaneous Index" nil
""))))))
1441 (eval-after-load "info-look" '(python-after-info-look))
1445 (defcustom python-jython-packages
'("java" "javax" "org" "com")
1446 "Packages implying `jython-mode'.
1447 If these are imported near the beginning of the buffer, `python-mode'
1448 actually punts to `jython-mode'."
1449 :type
'(repeat string
)
1452 ;; Called from `python-mode', this causes a recursive call of the
1453 ;; mode. See logic there to break out of the recursion.
1454 (defun python-maybe-jython ()
1455 "Invoke `jython-mode' if the buffer appears to contain Jython code.
1456 The criterion is either a match for `jython-mode' via
1457 `interpreter-mode-alist' or an import of a module from the list
1458 `python-jython-packages'."
1459 ;; The logic is taken from python-mode.el.
1463 (goto-char (point-min))
1464 (let ((interpreter (if (looking-at auto-mode-interpreter-regexp
)
1466 (if (and interpreter
(eq 'jython-mode
1467 (cdr (assoc (file-name-nondirectory
1469 interpreter-mode-alist
))))
1472 (while (re-search-forward
1473 (rx (and line-start
(or "import" "from") (1+ space
)
1474 (group (1+ (not (any " \t\n."))))))
1475 (+ (point-min) 10000) ; Probably not worth customizing.
1477 (if (member (match-string 1) python-jython-packages
)
1481 (defun python-fill-paragraph (&optional justify
)
1482 "`fill-paragraph-function' handling comments and multi-line strings.
1483 If any of the current line is a comment, fill the comment or the
1484 paragraph of it that point is in, preserving the comment's
1485 indentation and initial comment characters. Similarly if the end
1486 of the current line is in or at the end of a multi-line string.
1487 Otherwise, do nothing."
1489 (or (fill-comment-paragraph justify
)
1490 ;; The `paragraph-start' and `paragraph-separate' variables
1491 ;; don't allow us to delimit the last paragraph in a multi-line
1492 ;; string properly, so narrow to the string and then fill around
1493 ;; (the end of) the current line.
1496 (let* ((syntax (syntax-ppss))
1498 (start (nth 8 syntax
))
1500 (cond ((eq t
(nth 3 syntax
)) ; in fenced string
1501 (goto-char (nth 8 syntax
)) ; string start
1502 (condition-case () ; for unbalanced quotes
1503 (progn (forward-sexp)
1505 (error (setq end
(point-max)))))
1506 ((re-search-backward "\\s|\\s-*\\=" nil t
) ; end of fenced
1511 (progn (backward-sexp)
1512 (setq start
(point)))
1516 (narrow-to-region start end
)
1518 (fill-paragraph justify
))))))
1521 (defun python-shift-left (start end
&optional count
)
1522 "Shift lines in region COUNT (the prefix arg) columns to the left.
1523 COUNT defaults to `python-indent'. If region isn't active, just shift
1524 current line. The region shifted includes the lines in which START and
1525 END lie. It is an error if any lines in the region are indented less than
1527 (interactive (if mark-active
1528 (list (region-beginning) (region-end) current-prefix-arg
)
1529 (list (point) (point) current-prefix-arg
)))
1531 (setq count
(prefix-numeric-value count
))
1532 (setq count python-indent
))
1536 (while (< (point) end
)
1537 (if (and (< (current-indentation) count
)
1538 (not (looking-at "[ \t]*$")))
1539 (error "Can't shift all lines enough"))
1541 (indent-rigidly start end
(- count
)))))
1543 (add-to-list 'debug-ignored-errors
"^Can't shift all lines enough")
1545 (defun python-shift-right (start end
&optional count
)
1546 "Shift lines in region COUNT (the prefix arg) columns to the right.
1547 COUNT defaults to `python-indent'. If region isn't active, just shift
1548 current line. The region shifted includes the lines in which START and
1550 (interactive (if mark-active
1551 (list (region-beginning) (region-end) current-prefix-arg
)
1552 (list (point) (point) current-prefix-arg
)))
1554 (setq count
(prefix-numeric-value count
))
1555 (setq count python-indent
))
1556 (indent-rigidly start end count
))
1558 (defun python-outline-level ()
1559 "`outline-level' function for Python mode.
1560 The level is the number of `python-indent' steps of indentation
1562 (/ (current-indentation) python-indent
))
1564 ;; Fixme: Consider top-level assignments, imports, &c.
1565 (defun python-current-defun ()
1566 "`add-log-current-defun-function' for Python."
1568 ;; Move up the tree of nested `class' and `def' blocks until we
1569 ;; get to zero indentation, accumulating the defined names.
1572 (while (or start
(> (current-indentation) 0))
1574 (python-beginning-of-block)
1576 (beginning-of-defun)
1577 (if (looking-at (rx (and (0+ space
) (or "def" "class") (1+ space
)
1578 (group (1+ (or word
(syntax symbol
))))
1579 ;; Greediness makes this unnecessary? --Stef
1581 (push (match-string 1) accum
)))
1582 (if accum
(mapconcat 'identity accum
".")))))
1584 (defun python-mark-block ()
1585 "Mark the block around point.
1586 Uses `python-beginning-of-block', `python-end-of-block'."
1589 (python-beginning-of-block)
1590 (push-mark (point) nil t
)
1591 (python-end-of-block)
1592 (exchange-point-and-mark))
1596 (defun python-symbol-completions (symbol)
1597 "Return a list of completions of the string SYMBOL from Python process.
1598 The list is sorted."
1602 (car (read-from-string (python-send-receive
1603 (format "emacs.complete(%S)" symbol
))))
1606 ;; We can get duplicates from the above -- don't know why.
1607 (delete-dups completions
)
1610 (defun python-partial-symbol ()
1611 "Return the partial symbol before point (for completion)."
1613 (start (save-excursion
1614 (and (re-search-backward
1615 (rx (and (or buffer-start
(regexp "[^[:alnum:]._]"))
1616 (group (1+ (regexp "[[:alnum:]._]")))
1619 (match-beginning 1)))))
1620 (if start
(buffer-substring-no-properties start end
))))
1622 ;; Fixme: We should have an abstraction of this sort of thing in the
1624 (defun python-complete-symbol ()
1625 "Perform completion on the Python symbol preceding point.
1626 Repeating the command scrolls the completion window."
1628 (let ((window (get-buffer-window "*Completions*")))
1629 (if (and (eq last-command this-command
)
1630 window
(window-live-p window
) (window-buffer window
)
1631 (buffer-name (window-buffer window
)))
1632 (with-current-buffer (window-buffer window
)
1633 (if (pos-visible-in-window-p (point-max) window
)
1634 (set-window-start window
(point-min))
1635 (save-selected-window
1636 (select-window window
)
1639 (let* ((end (point))
1640 (symbol (python-partial-symbol))
1641 (completions (python-symbol-completions symbol
))
1642 (completion (if completions
1643 (try-completion symbol completions
))))
1645 (cond ((eq completion t
))
1647 (message "Can't find completion for \"%s\"" symbol
)
1649 ((not (string= symbol completion
))
1650 (delete-region (- end
(length symbol
)) end
)
1651 (insert completion
))
1653 (message "Making completion list...")
1654 (with-output-to-temp-buffer "*Completions*"
1655 (display-completion-list completions symbol
))
1656 (message "Making completion list...%s" "done"))))))))
1658 (eval-when-compile (require 'hippie-exp
))
1660 (defun python-try-complete (old)
1661 "Completion function for Python for use with `hippie-expand'."
1662 (when (eq major-mode
'python-mode
) ; though we only add it locally
1664 (let ((symbol (python-partial-symbol)))
1665 (he-init-string (- (point) (length symbol
)) (point))
1666 (if (not (he-string-member he-search-string he-tried-table
))
1667 (push he-search-string he-tried-table
))
1668 (setq he-expand-list
1669 (and symbol
(python-symbol-completions symbol
)))))
1670 (while (and he-expand-list
1671 (he-string-member (car he-expand-list
) he-tried-table
))
1672 (pop he-expand-list
))
1675 (he-substitute-string (pop he-expand-list
))
1677 (if old
(he-reset-string))
1682 (defvar outline-heading-end-regexp
)
1683 (defvar eldoc-documentation-function
)
1686 (define-derived-mode python-mode fundamental-mode
"Python"
1687 "Major mode for editing Python files.
1688 Turns on Font Lock mode unconditionally since it is required for correct
1689 parsing of the source.
1690 See also `jython-mode', which is actually invoked if the buffer appears to
1691 contain Jython code. See also `run-python' and associated Python mode
1692 commands for running Python under Emacs.
1694 The Emacs commands which work with `defun's, e.g. \\[beginning-of-defun], deal
1695 with nested `def' and `class' blocks. They take the innermost one as
1696 current without distinguishing method and class definitions. Used multiple
1697 times, they move over others at the same indentation level until they reach
1698 the end of definitions at that level, when they move up a level.
1700 Colon is electric: it outdents the line if appropriate, e.g. for
1701 an else statement. \\[python-backspace] at the beginning of an indented statement
1702 deletes a level of indentation to close the current block; otherwise it
1703 deletes a charcter backward. TAB indents the current line relative to
1704 the preceding code. Successive TABs, with no intervening command, cycle
1705 through the possibilities for indentation on the basis of enclosing blocks.
1707 \\[fill-paragraph] fills comments and multiline strings appropriately, but has no
1708 effect outside them.
1710 Supports Eldoc mode (only for functions, using a Python process),
1711 Info-Look and Imenu. In Outline minor mode, `class' and `def'
1712 lines count as headers.
1714 \\{python-mode-map}"
1716 (set (make-local-variable 'font-lock-defaults
)
1717 '(python-font-lock-keywords nil nil
((?_ .
"w")) nil
1718 (font-lock-syntactic-keywords
1719 . python-font-lock-syntactic-keywords
)
1720 ;; This probably isn't worth it.
1721 ;; (font-lock-syntactic-face-function
1722 ;; . python-font-lock-syntactic-face-function)
1724 (set (make-local-variable 'parse-sexp-lookup-properties
) t
)
1725 (set (make-local-variable 'comment-start
) "# ")
1726 (set (make-local-variable 'comment-indent-function
) #'python-comment-indent
)
1727 (set (make-local-variable 'indent-line-function
) #'python-indent-line
)
1728 (set (make-local-variable 'paragraph-start
) "\\s-*$")
1729 (set (make-local-variable 'fill-paragraph-function
) 'python-fill-paragraph
)
1730 (set (make-local-variable 'require-final-newline
) mode-require-final-newline
)
1731 (set (make-local-variable 'add-log-current-defun-function
)
1732 #'python-current-defun
)
1733 ;; Fixme: Generalize to do all blocks?
1734 (set (make-local-variable 'outline-regexp
) "\\s-*\\(def\\|class\\)\\>")
1735 (set (make-local-variable 'outline-heading-end-regexp
) ":\\s-*\n")
1736 (set (make-local-variable 'outline-level
) #'python-outline-level
)
1737 (set (make-local-variable 'open-paren-in-column-0-is-defun-start
) nil
)
1738 (make-local-variable 'python-saved-check-command
)
1739 (set (make-local-variable 'beginning-of-defun-function
)
1740 'python-beginning-of-defun
)
1741 (set (make-local-variable 'end-of-defun-function
) 'python-end-of-defun
)
1742 (setq imenu-create-index-function
#'python-imenu-create-index
)
1743 (set (make-local-variable 'eldoc-documentation-function
)
1744 #'python-eldoc-function
)
1745 (add-hook 'eldoc-mode-hook
1746 '(lambda () (run-python nil t
)) nil t
) ; need it running
1747 (if (featurep 'hippie-exp
)
1748 (set (make-local-variable 'hippie-expand-try-functions-list
)
1749 (cons 'python-try-complete hippie-expand-try-functions-list
)))
1750 (unless font-lock-mode
(font-lock-mode 1))
1751 (when python-guess-indent
(python-guess-indent))
1752 (set (make-local-variable 'python-command
) python-python-command
)
1753 (unless (boundp 'python-mode-running
) ; kill the recursion from jython-mode
1754 (let ((python-mode-running t
))
1755 (python-maybe-jython))))
1757 (custom-add-option 'python-mode-hook
'imenu-add-menubar-index
)
1758 (custom-add-option 'python-mode-hook
1760 "Turn on Indent Tabs mode."
1761 (set (make-local-variable 'indent-tabs-mode
) t
)))
1762 (custom-add-option 'python-mode-hook
'turn-on-eldoc-mode
)
1765 (define-derived-mode jython-mode python-mode
"Jython"
1766 "Major mode for editing Jython files.
1767 Like `python-mode', but sets up parameters for Jython subprocesses.
1768 Runs `jython-mode-hook' after `python-mode-hook'."
1770 (set (make-local-variable 'python-command
) python-jython-command
))
1773 ;; arch-tag: 6fce1d99-a704-4de9-ba19-c6e4912b0554
1774 ;;; python.el ends here