HCoop / bpt / emacs.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix typo enviroment => environment
[bpt/emacs.git] / lisp / progmodes / python.el
CommitLineData
33d0aec1 1;;; python.el --- Python's flying circus support for Emacs
45c138ac 2
e2d8d479 3;; Copyright (C) 2010, 2011 Free Software Foundation, Inc.
45c138ac
FEG		 4
5;; Author: Fabián E. Gallina <fabian@anue.biz>
b7f13559
FEG		 6;; URL: https://github.com/fgallina/python.el
7;; Version: 0.23.1
45c138ac
FEG		 8;; Maintainer: FSF
9;; Created: Jul 2010
10;; Keywords: languages
11
12;; This file is NOT part of GNU Emacs.
13
14;; python.el is free software: you can redistribute it and/or modify
15;; it under the terms of the GNU General Public License as published by
16;; the Free Software Foundation, either version 3 of the License, or
17;; (at your option) any later version.
18
19;; python.el is distributed in the hope that it will be useful,
20;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22;; GNU General Public License for more details.
23
24;; You should have received a copy of the GNU General Public License
25;; along with python.el. If not, see <http://www.gnu.org/licenses/>.
26
27;;; Commentary:
28
29;; Major mode for editing Python files with some fontification and
30;; indentation bits extracted from original Dave Love's python.el
31;; found in GNU/Emacs.
32
33;; While it probably has less features than Dave Love's python.el and
34;; PSF's python-mode.el it provides the main stuff you'll need while
35;; keeping it simple :)
36
37;; Implements Syntax highlighting, Indentation, Movement, Shell
64348c32
FEG		 38;; interaction, Shell completion, Shell virtualenv support, Pdb
39;; tracking, Symbol completion, Skeletons, FFAP, Code Check, Eldoc,
40;; imenu.
45c138ac
FEG		 41
42;; Syntax highlighting: Fontification of code is provided and supports
43;; python's triple quoted strings properly.
44
45;; Indentation: Automatic indentation with indentation cycling is
46;; provided, it allows you to navigate different available levels of
67845102
FEG		 47;; indentation by hitting <tab> several times. Also when inserting a
48;; colon the `python-indent-electric-colon' command is invoked and
49;; causes the current line to be dedented automatically if needed.
45c138ac
FEG		 50
51;; Movement: `beginning-of-defun' and `end-of-defun' functions are
4cafacb5
FEG		 52;; properly implemented. Also there are specialized
53;; `forward-sentence' and `backward-sentence' replacements
54;; (`python-nav-forward-sentence', `python-nav-backward-sentence'
55;; respectively). Extra functions `python-nav-sentence-start' and
56;; `python-nav-sentence-end' are included to move to the beginning and
57;; to the end of a setence while taking care of multiline definitions.
45c138ac
FEG		 58
59;; Shell interaction: is provided and allows you easily execute any
60;; block of code of your current buffer in an inferior Python process.
61
62;; Shell completion: hitting tab will try to complete the current
4e531f7a 63;; word. Shell completion is implemented in a manner that if you
45c138ac
FEG		 64;; change the `python-shell-interpreter' to any other (for example
65;; IPython) it should be easy to integrate another way to calculate
57808175 66;; completions. You just need to specify your custom
45c138ac 67;; `python-shell-completion-setup-code' and
4cafacb5 68;; `python-shell-completion-string-code'.
62feb915
FEG		 69
70;; Here is a complete example of the settings you would use for
71;; iPython
72
73;; (setq
74;; python-shell-interpreter "ipython"
75;; python-shell-interpreter-args ""
76;; python-shell-prompt-regexp "In \\[[0-9]+\\]: "
77;; python-shell-prompt-output-regexp "Out\\[[0-9]+\\]: "
78;; python-shell-completion-setup-code ""
79;; python-shell-completion-string-code
80;; "';'.join(__IP.complete('''%s'''))\n")
45c138ac 81
099bf010
FEG		 82;; Please note that the default completion system depends on the
83;; readline module, so if you are using some Operating System that
84;; bundles Python without it (like Windows) just install the
85;; pyreadline from http://ipython.scipy.org/moin/PyReadline/Intro and
86;; you should be good to go.
87
64348c32
FEG		 88;; Shell virtualenv support: The shell also contains support for
89;; virtualenvs and other special environment modifications thanks to
66bbb27f
FEG		 90;; `python-shell-process-environment' and `python-shell-exec-path'.
91;; These two variables allows you to modify execution paths and
307bd2e8 92;; environment variables to make easy for you to setup virtualenv rules
64348c32 93;; or behavior modifications when running shells. Here is an example
66bbb27f
FEG		 94;; of how to make shell processes to be run using the /path/to/env/
95;; virtualenv:
96
97;; (setq python-shell-process-environment
98;; (list
99;; (format "PATH=%s" (mapconcat
100;; 'identity
101;; (reverse
102;; (cons (getenv "PATH")
103;; '("/path/to/env/bin/")))
104;; ":"))
105;; "VIRTUAL_ENV=/path/to/env/"))
106;; (python-shell-exec-path . ("/path/to/env/bin/"))
107
64348c32
FEG		 108;; Since the above is cumbersome and can be programatically
109;; calculated, the variable `python-shell-virtualenv-path' is
110;; provided. When this variable is set with the path of the
111;; virtualenv to use, `process-environment' and `exec-path' get proper
112;; values in order to run shells inside the specified virtualenv. So
113;; the following will achieve the same as the previous example:
114
115;; (setq python-shell-virtualenv-path "/path/to/env/")
116
45c138ac
FEG		 117;; Pdb tracking: when you execute a block of code that contains some
118;; call to pdb (or ipdb) it will prompt the block of code and will
119;; follow the execution of pdb marking the current line with an arrow.
120
4e531f7a 121;; Symbol completion: you can complete the symbol at point. It uses
45c138ac
FEG		 122;; the shell completion in background so you should run
123;; `python-shell-send-buffer' from time to time to get better results.
124
e2803784
FEG		 125;; Skeletons: 6 skeletons are provided for simple inserting of class,
126;; def, for, if, try and while. These skeletons are integrated with
127;; dabbrev. If you have `dabbrev-mode' activated and
128;; `python-skeleton-autoinsert' is set to t, then whenever you type
129;; the name of any of those defined and hit SPC, they will be
130;; automatically expanded.
131
2947016a
FEG		 132;; FFAP: You can find the filename for a given module when using ffap
133;; out of the box. This feature needs an inferior python shell
134;; running.
135
2d63ad56
FEG		 136;; Code check: Check the current file for errors with `python-check'
137;; using the program defined in `python-check-command'.
8b3e0e76 138
45c138ac 139;; Eldoc: returns documentation for object at point by using the
4e531f7a 140;; inferior python subprocess to inspect its documentation. As you
45c138ac
FEG		 141;; might guessed you should run `python-shell-send-buffer' from time
142;; to time to get better results too.
143
4cafacb5
FEG		 144;; imenu: This mode supports imenu. It builds a plain or tree menu
145;; depending on the value of `python-imenu-make-tree'. Also you can
fc2dc7df
FEG		 146;; customize if menu items should include its type using
147;; `python-imenu-include-defun-type'.
148
57808175
FEG		 149;; If you used python-mode.el you probably will miss auto-indentation
150;; when inserting newlines. To achieve the same behavior you have
151;; two options:
152
153;; 1) Use GNU/Emacs' standard binding for `newline-and-indent': C-j.
154
155;; 2) Add the following hook in your .emacs:
156
157;; (add-hook 'python-mode-hook
158;; #'(lambda ()
159;; (define-key python-mode-map "\C-m" 'newline-and-indent)))
160
161;; I'd recommend the first one since you'll get the same behavior for
162;; all modes out-of-the-box.
163
45c138ac
FEG		 164;;; Installation:
165
166;; Add this to your .emacs:
167
168;; (add-to-list 'load-path "/folder/containing/file")
169;; (require 'python)
170
171;;; TODO:
172
45c138ac
FEG		 173;;; Code:
174
45c138ac 175(require 'ansi-color)
73ed6836 176(require 'comint)
45c138ac
FEG		 177
178(eval-when-compile
73ed6836
FEG		 179 (require 'cl)
180 ;; Avoid compiler warnings
181 (defvar view-return-to-alist)
182 (defvar compilation-error-regexp-alist)
183 (defvar outline-heading-end-regexp))
45c138ac
FEG		 184
185(autoload 'comint-mode "comint")
186
187;;;###autoload
188(add-to-list 'auto-mode-alist (cons (purecopy "\\.py\\'") 'python-mode))
189;;;###autoload
190(add-to-list 'interpreter-mode-alist (cons (purecopy "python") 'python-mode))
191
192(defgroup python nil
193 "Python Language's flying circus support for Emacs."
194 :group 'languages
195 :version "23.2"
196 :link '(emacs-commentary-link "python"))
197
198\f
199;;; Bindings
200
201(defvar python-mode-map
202 (let ((map (make-sparse-keymap)))
9fff1858
FEG		 203 ;; Movement
204 (substitute-key-definition 'backward-sentence
205 'python-nav-backward-sentence
206 map global-map)
207 (substitute-key-definition 'forward-sentence
208 'python-nav-forward-sentence
209 map global-map)
45c138ac
FEG		 210 ;; Indent specific
211 (define-key map "\177" 'python-indent-dedent-line-backspace)
212 (define-key map (kbd "<backtab>") 'python-indent-dedent-line)
213 (define-key map "\C-c<" 'python-indent-shift-left)
214 (define-key map "\C-c>" 'python-indent-shift-right)
ffdb56c3 215 (define-key map ":" 'python-indent-electric-colon)
e2803784
FEG		 216 ;; Skeletons
217 (define-key map "\C-c\C-tc" 'python-skeleton-class)
218 (define-key map "\C-c\C-td" 'python-skeleton-def)
219 (define-key map "\C-c\C-tf" 'python-skeleton-for)
220 (define-key map "\C-c\C-ti" 'python-skeleton-if)
221 (define-key map "\C-c\C-tt" 'python-skeleton-try)
222 (define-key map "\C-c\C-tw" 'python-skeleton-while)
45c138ac
FEG		 223 ;; Shell interaction
224 (define-key map "\C-c\C-s" 'python-shell-send-string)
225 (define-key map "\C-c\C-r" 'python-shell-send-region)
226 (define-key map "\C-\M-x" 'python-shell-send-defun)
227 (define-key map "\C-c\C-c" 'python-shell-send-buffer)
228 (define-key map "\C-c\C-l" 'python-shell-send-file)
229 (define-key map "\C-c\C-z" 'python-shell-switch-to-shell)
8b3e0e76
FEG		 230 ;; Some util commands
231 (define-key map "\C-c\C-v" 'python-check)
78334b43 232 (define-key map "\C-c\C-f" 'python-eldoc-at-point)
45c138ac
FEG		 233 ;; Utilities
234 (substitute-key-definition 'complete-symbol 'completion-at-point
235 map global-map)
236 (easy-menu-define python-menu map "Python Mode menu"
237 `("Python"
238 :help "Python-specific Features"
239 ["Shift region left" python-indent-shift-left :active mark-active
240 :help "Shift region left by a single indentation step"]
241 ["Shift region right" python-indent-shift-right :active mark-active
242 :help "Shift region right by a single indentation step"]
243 "-"
244 ["Mark def/class" mark-defun
245 :help "Mark outermost definition around point"]
246 "-"
247 ["Start of def/class" beginning-of-defun
248 :help "Go to start of outermost definition around point"]
45c138ac
FEG		 249 ["End of def/class" end-of-defun
250 :help "Go to end of definition around point"]
251 "-"
e2803784
FEG		 252 ("Skeletons")
253 "-"
45c138ac
FEG		 254 ["Start interpreter" run-python
255 :help "Run inferior Python process in a separate buffer"]
256 ["Switch to shell" python-shell-switch-to-shell
257 :help "Switch to running inferior Python process"]
258 ["Eval string" python-shell-send-string
259 :help "Eval string in inferior Python session"]
260 ["Eval buffer" python-shell-send-buffer
261 :help "Eval buffer in inferior Python session"]
262 ["Eval region" python-shell-send-region
263 :help "Eval region in inferior Python session"]
264 ["Eval defun" python-shell-send-defun
265 :help "Eval defun in inferior Python session"]
266 ["Eval file" python-shell-send-file
267 :help "Eval file in inferior Python session"]
268 ["Debugger" pdb :help "Run pdb under GUD"]
269 "-"
8b3e0e76
FEG		 270 ["Check file" python-check
271 :help "Check file for errors"]
78334b43
FEG		 272 ["Help on symbol" python-eldoc-at-point
273 :help "Get help on symbol at point"]
45c138ac
FEG		 274 ["Complete symbol" completion-at-point
275 :help "Complete symbol before point"]))
276 map)
277 "Keymap for `python-mode'.")
278
279\f
280;;; Python specialized rx
281
73ed6836
FEG		 282(eval-when-compile
283 (defconst python-rx-constituents
284 (list
285 `(block-start . ,(rx symbol-start
286 (or "def" "class" "if" "elif" "else" "try"
287 "except" "finally" "for" "while" "with")
288 symbol-end))
0567effb
FEG		 289 `(decorator . ,(rx line-start (* space) ?@ (any letter ?_)
290 (* (any word ?_))))
73ed6836 291 `(defun . ,(rx symbol-start (or "def" "class") symbol-end))
0567effb 292 `(symbol-name . ,(rx (any letter ?_) (* (any word ?_))))
73ed6836
FEG		 293 `(open-paren . ,(rx (or "{" "[" "(")))
294 `(close-paren . ,(rx (or "}" "]" ")")))
295 `(simple-operator . ,(rx (any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%)))
296 `(not-simple-operator . ,(rx (not (any ?+ ?- ?/ ?& ?^ ?~ ?| ?* ?< ?> ?= ?%))))
297 `(operator . ,(rx (or "+" "-" "/" "&" "^" "~" "|" "*" "<" ">"
298 "=" "%" "**" "//" "<<" ">>" "<=" "!="
299 "==" ">=" "is" "not")))
300 `(assignment-operator . ,(rx (or "=" "+=" "-=" "*=" "/=" "//=" "%=" "**="
e2d8d479
FEG		 301 ">>=" "<<=" "&=" "^=" "|="))))
302 "Additional Python specific sexps for `python-rx'"))
45c138ac
FEG		 303
304(defmacro python-rx (&rest regexps)
4cafacb5 305 "Python mode specialized rx macro which supports common python named REGEXPS."
45c138ac
FEG		 306 (let ((rx-constituents (append python-rx-constituents rx-constituents)))
307 (cond ((null regexps)
308 (error "No regexp"))
309 ((cdr regexps)
310 (rx-to-string `(and ,@regexps) t))
311 (t
312 (rx-to-string (car regexps) t)))))
313
314\f
315;;; Font-lock and syntax
316
317(defvar python-font-lock-keywords
318 ;; Keywords
319 `(,(rx symbol-start
320 (or "and" "del" "from" "not" "while" "as" "elif" "global" "or" "with"
321 "assert" "else" "if" "pass" "yield" "break" "except" "import"
322 "print" "class" "exec" "in" "raise" "continue" "finally" "is"
323 "return" "def" "for" "lambda" "try" "self")
324 symbol-end)
325 ;; functions
326 (,(rx symbol-start "def" (1+ space) (group (1+ (or word ?_))))
327 (1 font-lock-function-name-face))
328 ;; classes
329 (,(rx symbol-start "class" (1+ space) (group (1+ (or word ?_))))
330 (1 font-lock-type-face))
331 ;; Constants
c61d750e
FEG		 332 (,(rx symbol-start
333 ;; copyright, license, credits, quit, exit are added by the
334 ;; site module and since they are not intended to be used in
335 ;; programs they are not added here either.
336 (or "None" "True" "False" "Ellipsis" "__debug__" "NotImplemented")
337 symbol-end) . font-lock-constant-face)
45c138ac
FEG		 338 ;; Decorators.
339 (,(rx line-start (* (any " \t")) (group "@" (1+ (or word ?_))
340 (0+ "." (1+ (or word ?_)))))
341 (1 font-lock-type-face))
342 ;; Builtin Exceptions
343 (,(rx symbol-start
344 (or "ArithmeticError" "AssertionError" "AttributeError"
345 "BaseException" "BufferError" "BytesWarning" "DeprecationWarning"
346 "EOFError" "EnvironmentError" "Exception" "FloatingPointError"
347 "FutureWarning" "GeneratorExit" "IOError" "ImportError"
348 "ImportWarning" "IndentationError" "IndexError" "KeyError"
349 "KeyboardInterrupt" "LookupError" "MemoryError" "NameError"
c61d750e 350 "NotImplementedError" "OSError" "OverflowError"
45c138ac
FEG		 351 "PendingDeprecationWarning" "ReferenceError" "RuntimeError"
352 "RuntimeWarning" "StandardError" "StopIteration" "SyntaxError"
353 "SyntaxWarning" "SystemError" "SystemExit" "TabError" "TypeError"
354 "UnboundLocalError" "UnicodeDecodeError" "UnicodeEncodeError"
355 "UnicodeError" "UnicodeTranslateError" "UnicodeWarning"
356 "UserWarning" "ValueError" "Warning" "ZeroDivisionError")
357 symbol-end) . font-lock-type-face)
358 ;; Builtins
9438f1ef
FEG		 359 (,(rx symbol-start
360 (or "_" "__doc__" "__import__" "__name__" "__package__" "abs" "all"
361 "any" "apply" "basestring" "bin" "bool" "buffer" "bytearray"
362 "bytes" "callable" "chr" "classmethod" "cmp" "coerce" "compile"
363 "complex" "delattr" "dict" "dir" "divmod" "enumerate" "eval"
364 "execfile" "file" "filter" "float" "format" "frozenset"
365 "getattr" "globals" "hasattr" "hash" "help" "hex" "id" "input"
366 "int" "intern" "isinstance" "issubclass" "iter" "len" "list"
367 "locals" "long" "map" "max" "min" "next" "object" "oct" "open"
368 "ord" "pow" "print" "property" "range" "raw_input" "reduce"
369 "reload" "repr" "reversed" "round" "set" "setattr" "slice"
370 "sorted" "staticmethod" "str" "sum" "super" "tuple" "type"
371 "unichr" "unicode" "vars" "xrange" "zip")
372 symbol-end) . font-lock-builtin-face)
45c138ac
FEG		 373 ;; asignations
374 ;; support for a = b = c = 5
375 (,(lambda (limit)
d8e594db
FEG		 376 (let ((re (python-rx (group (+ (any word ?. ?_)))
377 (? ?\[ (+ (not (any ?\]))) ?\]) (* space)
45c138ac
FEG		 378 assignment-operator)))
379 (when (re-search-forward re limit t)
14a78495 380 (while (and (python-info-ppss-context 'paren)
45c138ac 381 (re-search-forward re limit t)))
14a78495 382 (if (and (not (python-info-ppss-context 'paren))
534e2438 383 (not (equal (char-after (point-marker)) ?=)))
45c138ac
FEG		 384 t
385 (set-match-data nil)))))
386 (1 font-lock-variable-name-face nil nil))
387 ;; support for a, b, c = (1, 2, 3)
388 (,(lambda (limit)
389 (let ((re (python-rx (group (+ (any word ?. ?_))) (* space)
390 (* ?, (* space) (+ (any word ?. ?_)) (* space))
391 ?, (* space) (+ (any word ?. ?_)) (* space)
392 assignment-operator)))
393 (when (and (re-search-forward re limit t)
394 (goto-char (nth 3 (match-data))))
14a78495 395 (while (and (python-info-ppss-context 'paren)
45c138ac
FEG		 396 (re-search-forward re limit t))
397 (goto-char (nth 3 (match-data))))
14a78495 398 (if (not (python-info-ppss-context 'paren))
45c138ac
FEG		 399 t
400 (set-match-data nil)))))
401 (1 font-lock-variable-name-face nil nil))))
402
45c138ac 403(defconst python-font-lock-syntactic-keywords
ecf24fd7
FEG		 404 ;; Make outer chars of matching triple-quote sequences into generic
405 ;; string delimiters. Fixme: Is there a better way?
45c138ac 406 ;; First avoid a sequence preceded by an odd number of backslashes.
ecf24fd7
FEG		 407 `((,(concat "\\(?:\\([RUru]\\)[Rr]?\\|^\\|[^\\]\\(?:\\\\.\\)*\\)" ;Prefix.
408 "\\(?:\\('\\)'\\('\\)\\|\\(?2:\"\\)\"\\(?3:\"\\)\\)")
409 (3 (python-quote-syntax)))))
410
411(defun python-quote-syntax ()
45c138ac
FEG		 412 "Put `syntax-table' property correctly on triple quote.
413Used for syntactic keywords. N is the match number (1, 2 or 3)."
414 ;; Given a triple quote, we have to check the context to know
415 ;; whether this is an opening or closing triple or whether it's
416 ;; quoted anyhow, and should be ignored. (For that we need to do
417 ;; the same job as `syntax-ppss' to be correct and it seems to be OK
418 ;; to use it here despite initial worries.) We also have to sort
419 ;; out a possible prefix -- well, we don't _have_ to, but I think it
420 ;; should be treated as part of the string.
421
422 ;; Test cases:
423 ;; ur"""ar""" x='"' # """
424 ;; x = ''' """ ' a
425 ;; '''
426 ;; x '"""' x """ \"""" x
427 (save-excursion
428 (goto-char (match-beginning 0))
ecf24fd7
FEG		 429 (let ((syntax (save-match-data (syntax-ppss))))
430 (cond
431 ((eq t (nth 3 syntax)) ; after unclosed fence
432 ;; Consider property for the last char if in a fenced string.
433 (goto-char (nth 8 syntax)) ; fence position
434 (skip-chars-forward "uUrR") ; skip any prefix
435 ;; Is it a matching sequence?
436 (if (eq (char-after) (char-after (match-beginning 2)))
437 (put-text-property (match-beginning 3) (match-end 3)
438 'syntax-table (string-to-syntax "|"))))
439 ((match-end 1)
440 ;; Consider property for initial char, accounting for prefixes.
441 (put-text-property (match-beginning 1) (match-end 1)
442 'syntax-table (string-to-syntax "|")))
443 (t
444 ;; Consider property for initial char, accounting for prefixes.
445 (put-text-property (match-beginning 2) (match-end 2)
446 'syntax-table (string-to-syntax "|"))))
447 )))
45c138ac
FEG		 448
449(defvar python-mode-syntax-table
450 (let ((table (make-syntax-table)))
451 ;; Give punctuation syntax to ASCII that normally has symbol
452 ;; syntax or has word syntax and isn't a letter.
453 (let ((symbol (string-to-syntax "_"))
454 (sst (standard-syntax-table)))
455 (dotimes (i 128)
456 (unless (= i ?_)
457 (if (equal symbol (aref sst i))
458 (modify-syntax-entry i "." table)))))
459 (modify-syntax-entry ?$ "." table)
460 (modify-syntax-entry ?% "." table)
461 ;; exceptions
462 (modify-syntax-entry ?# "<" table)
463 (modify-syntax-entry ?\n ">" table)
464 (modify-syntax-entry ?' "\"" table)
465 (modify-syntax-entry ?` "$" table)
466 table)
467 "Syntax table for Python files.")
468
469(defvar python-dotty-syntax-table
470 (let ((table (make-syntax-table python-mode-syntax-table)))
471 (modify-syntax-entry ?. "w" table)
472 (modify-syntax-entry ?_ "w" table)
473 table)
474 "Dotty syntax table for Python files.
475It makes underscores and dots word constituent chars.")
476
477\f
478;;; Indentation
479
480(defcustom python-indent-offset 4
481 "Default indentation offset for Python."
482 :group 'python
483 :type 'integer
484 :safe 'integerp)
485
486(defcustom python-indent-guess-indent-offset t
487 "Non-nil tells Python mode to guess `python-indent-offset' value."
488 :type 'boolean
0f55249e
FEG		 489 :group 'python
490 :safe 'booleanp)
45c138ac
FEG		 491
492(defvar python-indent-current-level 0
493 "Current indentation level `python-indent-line-function' is using.")
494
495(defvar python-indent-levels '(0)
496 "Levels of indentation available for `python-indent-line-function'.")
497
498(defvar python-indent-dedenters '("else" "elif" "except" "finally")
499 "List of words that should be dedented.
500These make `python-indent-calculate-indentation' subtract the value of
501`python-indent-offset'.")
502
503(defun python-indent-guess-indent-offset ()
954aa7bd 504 "Guess and set `python-indent-offset' for the current buffer."
bbac1eb8
FEG		 505 (save-excursion
506 (save-restriction
507 (widen)
508 (goto-char (point-min))
509 (let ((found-block))
510 (while (and (not found-block)
511 (re-search-forward
512 (python-rx line-start block-start) nil t))
14a78495
FEG		 513 (when (and (not (python-info-ppss-context 'string))
514 (not (python-info-ppss-context 'comment))
bbac1eb8
FEG		 515 (progn
516 (goto-char (line-end-position))
589cefd7 517 (forward-comment -9999)
bbac1eb8
FEG		 518 (eq ?: (char-before))))
519 (setq found-block t)))
520 (if (not found-block)
521 (message "Can't guess python-indent-offset, using defaults: %s"
522 python-indent-offset)
523 (while (and (progn
524 (goto-char (line-end-position))
525 (python-info-continuation-line-p))
526 (not (eobp)))
527 (forward-line 1))
528 (forward-line 1)
589cefd7 529 (forward-comment 9999)
14d9f80c
FEG		 530 (let ((indent-offset (current-indentation)))
531 (when (> indent-offset 0)
532 (setq python-indent-offset indent-offset))))))))
45c138ac 533
e2d8d479
FEG		 534(defun python-indent-context ()
535 "Get information on indentation context.
536Context information is returned with a cons with the form:
537 \(STATUS . START)
45c138ac
FEG		 538
539Where status can be any of the following symbols:
45c138ac
FEG		 540 * inside-paren: If point in between (), {} or []
541 * inside-string: If point is inside a string
542 * after-backslash: Previous line ends in a backslash
543 * after-beginning-of-block: Point is after beginning of block
544 * after-line: Point is after normal line
545 * no-indent: Point is at beginning of buffer or other special case
45c138ac
FEG		 546START is the buffer position where the sexp starts."
547 (save-restriction
548 (widen)
549 (let ((ppss (save-excursion (beginning-of-line) (syntax-ppss)))
550 (start))
551 (cons
552 (cond
69bab1de 553 ;; Beginning of buffer
19b122e4
FEG		 554 ((save-excursion
555 (goto-char (line-beginning-position))
556 (bobp))
69bab1de 557 'no-indent)
45c138ac 558 ;; Inside a paren
14a78495 559 ((setq start (python-info-ppss-context 'paren ppss))
45c138ac
FEG		 560 'inside-paren)
561 ;; Inside string
14a78495 562 ((setq start (python-info-ppss-context 'string ppss))
45c138ac
FEG		 563 'inside-string)
564 ;; After backslash
14a78495
FEG		 565 ((setq start (when (not (or (python-info-ppss-context 'string ppss)
566 (python-info-ppss-context 'comment ppss)))
45c138ac
FEG		 567 (let ((line-beg-pos (line-beginning-position)))
568 (when (eq ?\\ (char-before (1- line-beg-pos)))
569 (- line-beg-pos 2)))))
570 'after-backslash)
571 ;; After beginning of block
572 ((setq start (save-excursion
573 (let ((block-regexp (python-rx block-start))
574 (block-start-line-end ":[[:space:]]*$"))
575 (back-to-indentation)
257b0017 576 (forward-comment -9999)
45c138ac
FEG		 577 (back-to-indentation)
578 (when (or (python-info-continuation-line-p)
579 (and (not (looking-at block-regexp))
580 (save-excursion
581 (re-search-forward
582 block-start-line-end
583 (line-end-position) t))))
584 (while (and (forward-line -1)
585 (python-info-continuation-line-p)
586 (not (bobp))))
587 (when (not (looking-at block-regexp))
588 (forward-line 1)))
589 (back-to-indentation)
590 (when (and (looking-at block-regexp)
591 (or (re-search-forward
592 block-start-line-end
593 (line-end-position) t)
594 (python-info-continuation-line-p)))
595 (point-marker)))))
596 'after-beginning-of-block)
597 ;; After normal line
598 ((setq start (save-excursion
257b0017
FEG		 599 (back-to-indentation)
600 (forward-comment -9999)
3697b531 601 (python-nav-sentence-start)
45c138ac
FEG		 602 (point-marker)))
603 'after-line)
604 ;; Do not indent
605 (t 'no-indent))
606 start))))
607
608(defun python-indent-calculate-indentation ()
609 "Calculate correct indentation offset for the current line."
610 (let* ((indentation-context (python-indent-context))
611 (context-status (car indentation-context))
612 (context-start (cdr indentation-context)))
613 (save-restriction
614 (widen)
615 (save-excursion
616 (case context-status
617 ('no-indent 0)
618 ('after-beginning-of-block
619 (goto-char context-start)
620 (+ (current-indentation) python-indent-offset))
621 ('after-line
622 (-
623 (save-excursion
624 (goto-char context-start)
625 (current-indentation))
626 (if (progn
627 (back-to-indentation)
628 (looking-at (regexp-opt python-indent-dedenters)))
629 python-indent-offset
630 0)))
631 ('inside-string
632 (goto-char context-start)
633 (current-indentation))
634 ('after-backslash
635 (let* ((block-continuation
636 (save-excursion
637 (forward-line -1)
638 (python-info-block-continuation-line-p)))
639 (assignment-continuation
640 (save-excursion
641 (forward-line -1)
642 (python-info-assignment-continuation-line-p)))
9f1537ef
FEG		 643 (dot-continuation
644 (save-excursion
645 (back-to-indentation)
646 (when (looking-at "\\.")
647 (forward-line -1)
107c2439
FEG		 648 (goto-char (line-end-position))
649 (while (and (re-search-backward "\\." (line-beginning-position) t)
650 (or (python-info-ppss-context 'comment)
651 (python-info-ppss-context 'string)
652 (python-info-ppss-context 'paren))))
653 (if (and (looking-at "\\.")
654 (not (or (python-info-ppss-context 'comment)
655 (python-info-ppss-context 'string)
656 (python-info-ppss-context 'paren))))
657 (current-column)
658 (+ (current-indentation) python-indent-offset)))))
659 (indentation (cond
660 (dot-continuation
661 dot-continuation)
662 (block-continuation
663 (goto-char block-continuation)
664 (re-search-forward
665 (python-rx block-start (* space))
666 (line-end-position) t)
667 (current-column))
668 (assignment-continuation
669 (goto-char assignment-continuation)
670 (re-search-forward
671 (python-rx simple-operator)
672 (line-end-position) t)
673 (forward-char 1)
674 (re-search-forward
675 (python-rx (* space))
676 (line-end-position) t)
677 (current-column))
678 (t
679 (goto-char context-start)
9787f829
FEG		 680 (if (not
681 (save-excursion
682 (back-to-indentation)
683 (looking-at
684 "\\(?:return\\|from\\|import\\)\s+")))
107c2439
FEG		 685 (current-indentation)
686 (+ (current-indentation)
9787f829
FEG		 687 (length
688 (match-string-no-properties 0))))))))
45c138ac
FEG		 689 indentation))
690 ('inside-paren
17d13b85 691 (or (save-excursion
f8994527 692 (skip-syntax-forward "\s" (line-end-position))
f9471190
FEG		 693 (when (and (looking-at (regexp-opt '(")" "]" "}")))
694 (not (forward-char 1))
695 (not (python-info-ppss-context 'paren)))
17d13b85
FEG		 696 (goto-char context-start)
697 (back-to-indentation)
698 (current-column)))
699 (-
700 (save-excursion
701 (goto-char context-start)
702 (forward-char)
703 (save-restriction
704 (narrow-to-region
705 (line-beginning-position)
706 (line-end-position))
589cefd7 707 (forward-comment 9999))
17d13b85
FEG		 708 (if (looking-at "$")
709 (+ (current-indentation) python-indent-offset)
589cefd7 710 (forward-comment 9999)
17d13b85
FEG		 711 (current-column)))
712 (if (progn
713 (back-to-indentation)
714 (looking-at (regexp-opt '(")" "]" "}"))))
715 python-indent-offset
716 0)))))))))
45c138ac
FEG		 717
718(defun python-indent-calculate-levels ()
719 "Calculate `python-indent-levels' and reset `python-indent-current-level'."
720 (let* ((indentation (python-indent-calculate-indentation))
721 (remainder (% indentation python-indent-offset))
722 (steps (/ (- indentation remainder) python-indent-offset)))
65e4f764 723 (setq python-indent-levels (list 0))
45c138ac 724 (dotimes (step steps)
65e4f764 725 (push (* python-indent-offset (1+ step)) python-indent-levels))
45c138ac 726 (when (not (eq 0 remainder))
65e4f764 727 (push (+ (* python-indent-offset steps) remainder) python-indent-levels))
45c138ac
FEG		 728 (setq python-indent-levels (nreverse python-indent-levels))
729 (setq python-indent-current-level (1- (length python-indent-levels)))))
730
731(defun python-indent-toggle-levels ()
732 "Toggle `python-indent-current-level' over `python-indent-levels'."
733 (setq python-indent-current-level (1- python-indent-current-level))
734 (when (< python-indent-current-level 0)
735 (setq python-indent-current-level (1- (length python-indent-levels)))))
736
737(defun python-indent-line (&optional force-toggle)
738 "Internal implementation of `python-indent-line-function'.
45c138ac
FEG		 739Uses the offset calculated in
740`python-indent-calculate-indentation' and available levels
e2d8d479
FEG		 741indicated by the variable `python-indent-levels' to set the
742current indentation.
45c138ac
FEG		 743
744When the variable `last-command' is equal to
e2d8d479
FEG		 745`indent-for-tab-command' or FORCE-TOGGLE is non-nil it cycles
746levels indicated in the variable `python-indent-levels' by
747setting the current level in the variable
748`python-indent-current-level'.
45c138ac
FEG		 749
750When the variable `last-command' is not equal to
e2d8d479
FEG		 751`indent-for-tab-command' and FORCE-TOGGLE is nil it calculates
752possible indentation levels and saves it in the variable
753`python-indent-levels'. Afterwards it sets the variable
754`python-indent-current-level' correctly so offset is equal
755to (`nth' `python-indent-current-level' `python-indent-levels')"
45c138ac
FEG		 756 (if (or (and (eq this-command 'indent-for-tab-command)
757 (eq last-command this-command))
758 force-toggle)
86f1889a
FEG		 759 (if (not (equal python-indent-levels '(0)))
760 (python-indent-toggle-levels)
761 (python-indent-calculate-levels))
45c138ac
FEG		 762 (python-indent-calculate-levels))
763 (beginning-of-line)
764 (delete-horizontal-space)
765 (indent-to (nth python-indent-current-level python-indent-levels))
766 (save-restriction
767 (widen)
768 (let ((closing-block-point (python-info-closing-block)))
769 (when closing-block-point
770 (message "Closes %s" (buffer-substring
771 closing-block-point
772 (save-excursion
773 (goto-char closing-block-point)
774 (line-end-position))))))))
775
776(defun python-indent-line-function ()
777 "`indent-line-function' for Python mode.
e2d8d479 778See `python-indent-line' for details."
45c138ac
FEG		 779 (python-indent-line))
780
781(defun python-indent-dedent-line ()
e2d8d479 782 "De-indent current line."
45c138ac 783 (interactive "*")
14a78495
FEG		 784 (when (and (not (or (python-info-ppss-context 'string)
785 (python-info-ppss-context 'comment)))
45c138ac
FEG		 786 (<= (point-marker) (save-excursion
787 (back-to-indentation)
788 (point-marker)))
789 (> (current-column) 0))
790 (python-indent-line t)
791 t))
792
793(defun python-indent-dedent-line-backspace (arg)
e2d8d479 794 "De-indent current line.
45c138ac 795Argument ARG is passed to `backward-delete-char-untabify' when
e2d8d479 796point is not in between the indentation."
45c138ac
FEG		 797 (interactive "*p")
798 (when (not (python-indent-dedent-line))
799 (backward-delete-char-untabify arg)))
183f9296 800(put 'python-indent-dedent-line-backspace 'delete-selection 'supersede)
45c138ac
FEG		 801
802(defun python-indent-region (start end)
803 "Indent a python region automagically.
804
805Called from a program, START and END specify the region to indent."
cb42456f
FEG		 806 (let ((deactivate-mark nil))
807 (save-excursion
808 (goto-char end)
809 (setq end (point-marker))
810 (goto-char start)
811 (or (bolp) (forward-line 1))
812 (while (< (point) end)
813 (or (and (bolp) (eolp))
814 (let (word)
815 (forward-line -1)
816 (back-to-indentation)
817 (setq word (current-word))
818 (forward-line 1)
819 (when word
820 (beginning-of-line)
821 (delete-horizontal-space)
822 (indent-to (python-indent-calculate-indentation)))))
823 (forward-line 1))
824 (move-marker end nil))))
45c138ac
FEG		 825
826(defun python-indent-shift-left (start end &optional count)
827 "Shift lines contained in region START END by COUNT columns to the left.
e2d8d479
FEG		 828COUNT defaults to `python-indent-offset'. If region isn't
829active, the current line is shifted. The shifted region includes
830the lines in which START and END lie. An error is signaled if
831any lines in the region are indented less than COUNT columns."
45c138ac
FEG		 832 (interactive
833 (if mark-active
834 (list (region-beginning) (region-end) current-prefix-arg)
835 (list (line-beginning-position) (line-end-position) current-prefix-arg)))
836 (if count
837 (setq count (prefix-numeric-value count))
838 (setq count python-indent-offset))
839 (when (> count 0)
cb42456f
FEG		 840 (let ((deactivate-mark nil))
841 (save-excursion
842 (goto-char start)
843 (while (< (point) end)
844 (if (and (< (current-indentation) count)
845 (not (looking-at "[ \t]*$")))
846 (error "Can't shift all lines enough"))
847 (forward-line))
848 (indent-rigidly start end (- count))))))
45c138ac
FEG		 849
850(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")
851
852(defun python-indent-shift-right (start end &optional count)
853 "Shift lines contained in region START END by COUNT columns to the left.
e2d8d479
FEG		 854COUNT defaults to `python-indent-offset'. If region isn't
855active, the current line is shifted. The shifted region includes
856the lines in which START and END lie."
45c138ac
FEG		 857 (interactive
858 (if mark-active
859 (list (region-beginning) (region-end) current-prefix-arg)
860 (list (line-beginning-position) (line-end-position) current-prefix-arg)))
cb42456f
FEG		 861 (let ((deactivate-mark nil))
862 (if count
863 (setq count (prefix-numeric-value count))
864 (setq count python-indent-offset))
865 (indent-rigidly start end count)))
45c138ac 866
ffdb56c3 867(defun python-indent-electric-colon (arg)
e2d8d479
FEG		 868 "Insert a colon and maybe de-indent the current line.
869With numeric ARG, just insert that many colons. With
870\\[universal-argument], just insert a single colon."
ffdb56c3
FEG		 871 (interactive "*P")
872 (self-insert-command (if (not (integerp arg)) 1 arg))
c43cd8b1
FEG		 873 (when (and (not arg)
874 (eolp)
875 (not (equal ?: (char-after (- (point-marker) 2))))
876 (not (or (python-info-ppss-context 'string)
877 (python-info-ppss-context 'comment))))
878 (let ((indentation (current-indentation))
879 (calculated-indentation (python-indent-calculate-indentation)))
880 (when (> indentation calculated-indentation)
881 (save-excursion
882 (indent-line-to calculated-indentation)
883 (when (not (python-info-closing-block))
884 (indent-line-to indentation)))))))
ffdb56c3
FEG		 885(put 'python-indent-electric-colon 'delete-selection t)
886
45c138ac
FEG		 887\f
888;;; Navigation
889
0567effb 890(defvar python-nav-beginning-of-defun-regexp
af5c1beb
FEG		 891 (python-rx line-start (* space) defun (+ space) (group symbol-name))
892 "Regular expresion matching beginning of class or function.
fc2dc7df
FEG		 893The name of the defun should be grouped so it can be retrieved
894via `match-string'.")
45c138ac 895
6b432853 896(defun python-nav-beginning-of-defun (&optional nodecorators)
053a6c72 897 "Move point to `beginning-of-defun'.
6b432853
FEG		 898When NODECORATORS is non-nil decorators are not included. This
899is the main part of`python-beginning-of-defun-function'
74d7b605 900implementation. Return non-nil if point is moved to the
fc2dc7df 901`beginning-of-defun'."
0567effb
FEG		 902 (let ((indent-pos (save-excursion
903 (back-to-indentation)
904 (point-marker)))
74d7b605 905 (found)
0567effb
FEG		 906 (include-decorators
907 (lambda ()
6b432853
FEG		 908 (when (not nodecorators)
909 (when (save-excursion
910 (forward-line -1)
911 (looking-at (python-rx decorator)))
912 (while (and (not (bobp))
913 (forward-line -1)
914 (looking-at (python-rx decorator))))
915 (when (not (bobp)) (forward-line 1)))))))
0567effb
FEG		 916 (if (and (> (point) indent-pos)
917 (save-excursion
918 (goto-char (line-beginning-position))
919 (looking-at python-nav-beginning-of-defun-regexp)))
45c138ac 920 (progn
0567effb 921 (goto-char (line-beginning-position))
74d7b605
FEG		 922 (funcall include-decorators)
923 (setq found t))
0567effb 924 (goto-char (line-beginning-position))
74d7b605
FEG		 925 (when (re-search-backward python-nav-beginning-of-defun-regexp nil t)
926 (setq found t))
0567effb 927 (goto-char (or (python-info-ppss-context 'string) (point)))
74d7b605
FEG		 928 (funcall include-decorators))
929 found))
0567effb 930
6b432853 931(defun python-beginning-of-defun-function (&optional arg nodecorators)
0567effb
FEG		 932 "Move point to the beginning of def or class.
933With positive ARG move that number of functions forward. With
6b432853 934negative do the same but backwards. When NODECORATORS is non-nil
74d7b605 935decorators are not included. Return non-nil if point is moved to the
fc2dc7df 936`beginning-of-defun'."
0567effb
FEG		 937 (when (or (null arg) (= arg 0)) (setq arg 1))
938 (if (> arg 0)
74d7b605
FEG		 939 (dotimes (i arg (python-nav-beginning-of-defun nodecorators)))
940 (let ((found))
941 (dotimes (i (- arg) found)
942 (python-end-of-defun-function)
589cefd7 943 (forward-comment 9999)
74d7b605
FEG		 944 (goto-char (line-end-position))
945 (when (not (eobp))
946 (setq found
947 (python-nav-beginning-of-defun nodecorators)))))))
45c138ac
FEG		 948
949(defun python-end-of-defun-function ()
950 "Move point to the end of def or class.
951Returns nil if point is not in a def or class."
0567effb
FEG		 952 (interactive)
953 (let ((beg-defun-indent)
954 (decorator-regexp "[[:space:]]*@"))
955 (when (looking-at decorator-regexp)
956 (while (and (not (eobp))
957 (forward-line 1)
958 (looking-at decorator-regexp))))
959 (when (not (looking-at python-nav-beginning-of-defun-regexp))
960 (python-beginning-of-defun-function))
961 (setq beg-defun-indent (current-indentation))
962 (forward-line 1)
963 (while (and (forward-line 1)
964 (not (eobp))
965 (or (not (current-word))
966 (> (current-indentation) beg-defun-indent))))
589cefd7 967 (forward-comment 9999)
0567effb 968 (goto-char (line-beginning-position))))
45c138ac 969
3697b531
FEG		 970(defun python-nav-sentence-start ()
971 "Move to start of current sentence."
972 (interactive "^")
973 (while (and (not (back-to-indentation))
974 (not (bobp))
975 (when (or
976 (save-excursion
977 (forward-line -1)
978 (python-info-line-ends-backslash-p))
9fff1858 979 (python-info-ppss-context 'string)
3697b531
FEG		 980 (python-info-ppss-context 'paren))
981 (forward-line -1)))))
982
983(defun python-nav-sentence-end ()
984 "Move to end of current sentence."
985 (interactive "^")
986 (while (and (goto-char (line-end-position))
987 (not (eobp))
988 (when (or
989 (python-info-line-ends-backslash-p)
9fff1858 990 (python-info-ppss-context 'string)
3697b531
FEG		 991 (python-info-ppss-context 'paren))
992 (forward-line 1)))))
993
9fff1858 994(defun python-nav-backward-sentence (&optional arg)
4cafacb5 995 "Move backward to start of sentence. With ARG, do it arg times.
9fff1858
FEG		 996See `python-nav-forward-sentence' for more information."
997 (interactive "^p")
998 (or arg (setq arg 1))
999 (python-nav-forward-sentence (- arg)))
1000
1001(defun python-nav-forward-sentence (&optional arg)
4cafacb5 1002 "Move forward to next end of sentence. With ARG, repeat.
9fff1858
FEG		 1003With negative argument, move backward repeatedly to start of sentence."
1004 (interactive "^p")
1005 (or arg (setq arg 1))
1006 (while (> arg 0)
1007 (forward-comment 9999)
1008 (python-nav-sentence-end)
1009 (forward-line 1)
1010 (setq arg (1- arg)))
1011 (while (< arg 0)
1012 (python-nav-sentence-end)
1013 (forward-comment -9999)
1014 (python-nav-sentence-start)
1015 (forward-line -1)
1016 (setq arg (1+ arg))))
1017
45c138ac
FEG		 1018\f
1019;;; Shell integration
1020
0f55249e
FEG		 1021(defcustom python-shell-buffer-name "Python"
1022 "Default buffer name for Python interpreter."
1023 :type 'string
1024 :group 'python
1025 :safe 'stringp)
45c138ac
FEG		 1026
1027(defcustom python-shell-interpreter "python"
1028 "Default Python interpreter for shell."
45c138ac 1029 :type 'string
c0428ba0 1030 :group 'python
45c138ac
FEG		 1031 :safe 'stringp)
1032
0f55249e
FEG		 1033(defcustom python-shell-internal-buffer-name "Python Internal"
1034 "Default buffer name for the Internal Python interpreter."
1035 :type 'string
1036 :group 'python
1037 :safe 'stringp)
1fe1b5aa 1038
45c138ac
FEG		 1039(defcustom python-shell-interpreter-args "-i"
1040 "Default arguments for the Python interpreter."
45c138ac 1041 :type 'string
c0428ba0 1042 :group 'python
45c138ac
FEG		 1043 :safe 'stringp)
1044
1045(defcustom python-shell-prompt-regexp ">>> "
e2d8d479
FEG		 1046 "Regular Expression matching top\-level input prompt of python shell.
1047It should not contain a caret (^) at the beginning."
45c138ac
FEG		 1048 :type 'string
1049 :group 'python
1050 :safe 'stringp)
1051
1052(defcustom python-shell-prompt-block-regexp "[.][.][.] "
e2d8d479
FEG		 1053 "Regular Expression matching block input prompt of python shell.
1054It should not contain a caret (^) at the beginning."
45c138ac
FEG		 1055 :type 'string
1056 :group 'python
1057 :safe 'stringp)
1058
0f55249e 1059(defcustom python-shell-prompt-output-regexp ""
e2d8d479
FEG		 1060 "Regular Expression matching output prompt of python shell.
1061It should not contain a caret (^) at the beginning."
62feb915
FEG		 1062 :type 'string
1063 :group 'python
1064 :safe 'stringp)
1065
45c138ac 1066(defcustom python-shell-prompt-pdb-regexp "[(<]*[Ii]?[Pp]db[>)]+ "
e2d8d479
FEG		 1067 "Regular Expression matching pdb input prompt of python shell.
1068It should not contain a caret (^) at the beginning."
45c138ac
FEG		 1069 :type 'string
1070 :group 'python
1071 :safe 'stringp)
1072
30e429dd
FEG		 1073(defcustom python-shell-send-setup-max-wait 5
1074 "Seconds to wait for process output before code setup.
1075If output is received before the especified time then control is
1076returned in that moment and not after waiting."
0f55249e 1077 :type 'integer
30e429dd 1078 :group 'python
0f55249e 1079 :safe 'integerp)
30e429dd 1080
66bbb27f 1081(defcustom python-shell-process-environment nil
307bd2e8
FEG		 1082 "List of environment variables for Python shell.
1083This variable follows the same rules as `process-environment'
66bbb27f
FEG		 1084since it merges with it before the process creation routines are
1085called. When this variable is nil, the Python shell is run with
307bd2e8 1086the default `process-environment'."
66bbb27f
FEG		 1087 :type '(repeat string)
1088 :group 'python
1089 :safe 'listp)
1090
1091(defcustom python-shell-exec-path nil
1092 "List of path to search for binaries.
1093This variable follows the same rules as `exec-path' since it
1094merges with it before the process creation routines are called.
1095When this variable is nil, the Python shell is run with the
1096default `exec-path'."
1097 :type '(repeat string)
1098 :group 'python
1099 :safe 'listp)
1100
64348c32
FEG		 1101(defcustom python-shell-virtualenv-path nil
1102 "Path to virtualenv root.
1103This variable, when set to a string, makes the values stored in
1104`python-shell-process-environment' and `python-shell-exec-path'
1105to be modified properly so shells are started with the specified
1106virtualenv."
1107 :type 'string
1108 :group 'python
1109 :safe 'stringp)
1110
c0428ba0
FEG		 1111(defcustom python-shell-setup-codes '(python-shell-completion-setup-code
1112 python-ffap-setup-code
1113 python-eldoc-setup-code)
1114 "List of code run by `python-shell-send-setup-codes'.
e2d8d479 1115Each variable can contain either a simple string with the code to
c0428ba0
FEG		 1116execute or a cons with the form (CODE . DESCRIPTION), where CODE
1117is a string with the code to execute and DESCRIPTION is the
1118description of it."
1119 :type '(repeat symbol)
1120 :group 'python
1121 :safe 'listp)
1122
45c138ac
FEG		 1123(defcustom python-shell-compilation-regexp-alist
1124 `((,(rx line-start (1+ (any " \t")) "File \""
1125 (group (1+ (not (any "\"<")))) ; avoid `<stdin>' &c
1126 "\", line " (group (1+ digit)))
1127 1 2)
1128 (,(rx " in file " (group (1+ not-newline)) " on line "
1129 (group (1+ digit)))
1130 1 2)
1131 (,(rx line-start "> " (group (1+ (not (any "(\"<"))))
1132 "(" (group (1+ digit)) ")" (1+ (not (any "("))) "()")
1133 1 2))
1134 "`compilation-error-regexp-alist' for inferior Python."
1135 :type '(alist string)
1136 :group 'python)
1137
1138(defun python-shell-get-process-name (dedicated)
1139 "Calculate the appropiate process name for inferior Python process.
45c138ac
FEG		 1140If DEDICATED is t and the variable `buffer-file-name' is non-nil
1141returns a string with the form
1142`python-shell-buffer-name'[variable `buffer-file-name'] else
e2d8d479
FEG		 1143returns the value of `python-shell-buffer-name'. After
1144calculating the process name adds the buffer name for the process
1145in the `same-window-buffer-names' list."
45c138ac
FEG		 1146 (let ((process-name
1147 (if (and dedicated
1148 buffer-file-name)
1149 (format "%s[%s]" python-shell-buffer-name buffer-file-name)
1150 (format "%s" python-shell-buffer-name))))
1151 (add-to-list 'same-window-buffer-names (purecopy
1152 (format "*%s*" process-name)))
1153 process-name))
1154
1fe1b5aa
FEG		 1155(defun python-shell-internal-get-process-name ()
1156 "Calculate the appropiate process name for Internal Python process.
1157The name is calculated from `python-shell-global-buffer-name' and
1158a hash of all relevant global shell settings in order to ensure
1159uniqueness for different types of configurations."
1160 (format "%s [%s]"
1161 python-shell-internal-buffer-name
1162 (md5
1163 (concat
1164 (python-shell-parse-command)
1165 (mapconcat #'symbol-value python-shell-setup-codes "")
1166 (mapconcat #'indentity python-shell-process-environment "")
64348c32 1167 (or python-shell-virtualenv-path "")
1fe1b5aa
FEG		 1168 (mapconcat #'indentity python-shell-exec-path "")))))
1169
45c138ac 1170(defun python-shell-parse-command ()
e2d8d479 1171 "Calculate the string used to execute the inferior Python process."
45c138ac
FEG		 1172 (format "%s %s" python-shell-interpreter python-shell-interpreter-args))
1173
307bd2e8
FEG		 1174(defun python-shell-calculate-process-environment ()
1175 "Calculate process environment given `python-shell-virtualenv-path'."
64348c32
FEG		 1176 (let ((env (python-util-merge 'list python-shell-process-environment
1177 process-environment 'string=))
1178 (virtualenv (if python-shell-virtualenv-path
1179 (directory-file-name python-shell-virtualenv-path)
1180 nil)))
1181 (if (not virtualenv)
1182 env
1183 (dolist (envvar env)
1184 (let* ((split (split-string envvar "=" t))
1185 (name (nth 0 split))
1186 (value (nth 1 split)))
1187 (when (not (string= name "PYTHONHOME"))
1188 (when (string= name "PATH")
1189 (setq value (format "%s/bin:%s" virtualenv value)))
1190 (setq env (cons (format "%s=%s" name value) env)))))
1191 (cons (format "VIRTUAL_ENV=%s" virtualenv) env))))
1192
1193(defun python-shell-calculate-exec-path ()
1194 "Calculate exec path given `python-shell-virtualenv-path'."
1195 (let ((path (python-util-merge 'list python-shell-exec-path
1196 exec-path 'string=)))
1197 (if (not python-shell-virtualenv-path)
1198 path
1199 (cons (format "%s/bin"
1200 (directory-file-name python-shell-virtualenv-path))
1201 path))))
1202
45c138ac
FEG		 1203(defun python-comint-output-filter-function (output)
1204 "Hook run after content is put into comint buffer.
1205OUTPUT is a string with the contents of the buffer."
1206 (ansi-color-filter-apply output))
1207
1208(defvar inferior-python-mode-current-file nil
1209 "Current file from which a region was sent.")
1210(make-variable-buffer-local 'inferior-python-mode-current-file)
1211
45c138ac 1212(define-derived-mode inferior-python-mode comint-mode "Inferior Python"
62feb915 1213 "Major mode for Python inferior process.
e2d8d479
FEG		 1214Runs a Python interpreter as a subprocess of Emacs, with Python
1215I/O through an Emacs buffer. Variables
1216`python-shell-interpreter' and `python-shell-interpreter-args'
1217controls which Python interpreter is run. Variables
1218`python-shell-prompt-regexp',
1219`python-shell-prompt-output-regexp',
1220`python-shell-prompt-block-regexp',
1221`python-shell-completion-setup-code',
1222`python-shell-completion-string-code', `python-eldoc-setup-code',
1223`python-eldoc-string-code', `python-ffap-setup-code' and
1224`python-ffap-string-code' can customize this mode for different
1225Python interpreters.
1226
1227You can also add additional setup code to be run at
1228initialization of the interpreter via `python-shell-setup-codes'
1229variable.
1230
1231\(Type \\[describe-mode] in the process buffer for a list of commands.)"
45c138ac
FEG		 1232 (set-syntax-table python-mode-syntax-table)
1233 (setq mode-line-process '(":%s"))
1234 (setq comint-prompt-regexp (format "^\\(?:%s\\|%s\\|%s\\)"
1235 python-shell-prompt-regexp
1236 python-shell-prompt-block-regexp
1237 python-shell-prompt-pdb-regexp))
1238 (make-local-variable 'comint-output-filter-functions)
1239 (add-hook 'comint-output-filter-functions
1240 'python-comint-output-filter-function)
1241 (add-hook 'comint-output-filter-functions
1242 'python-pdbtrack-comint-output-filter-function)
1243 (set (make-local-variable 'compilation-error-regexp-alist)
1244 python-shell-compilation-regexp-alist)
ed0eb594
FEG		 1245 (define-key inferior-python-mode-map [remap complete-symbol]
1246 'completion-at-point)
1247 (add-hook 'completion-at-point-functions
1248 'python-shell-completion-complete-at-point nil 'local)
62feb915
FEG		 1249 (add-to-list (make-local-variable 'comint-dynamic-complete-functions)
1250 'python-shell-completion-complete-at-point)
1251 (define-key inferior-python-mode-map (kbd "<tab>")
1252 'python-shell-completion-complete-or-indent)
45c138ac
FEG		 1253 (compilation-shell-minor-mode 1))
1254
96eeb83a 1255(defun python-shell-make-comint (cmd proc-name &optional pop)
77afb61a 1256 "Create a python shell comint buffer.
96eeb83a 1257CMD is the python command to be executed and PROC-NAME is the
77afb61a 1258process name the comint buffer will get. After the comint buffer
96eeb83a
FEG		 1259is created the `inferior-python-mode' is activated. If POP is
1260non-nil the buffer is shown."
77afb61a
FEG		 1261 (save-excursion
1262 (let* ((proc-buffer-name (format "*%s*" proc-name))
307bd2e8 1263 (process-environment (python-shell-calculate-process-environment))
77afb61a
FEG		 1264 (exec-path (python-shell-calculate-exec-path)))
1265 (when (not (comint-check-proc proc-buffer-name))
96eeb83a
FEG		 1266 (let* ((cmdlist (split-string-and-unquote cmd))
1267 (buffer (apply 'make-comint proc-name (car cmdlist) nil
1268 (cdr cmdlist)))
1269 (python-shell-interpreter-1 python-shell-interpreter)
1270 (python-shell-interpreter-args-1 python-shell-interpreter-args)
1271 (python-shell-prompt-regexp-1 python-shell-prompt-regexp)
1272 (python-shell-prompt-output-regexp-1
1273 python-shell-prompt-output-regexp)
1274 (python-shell-prompt-block-regexp-1
1275 python-shell-prompt-block-regexp)
1276 (python-shell-completion-setup-code-1
1277 python-shell-completion-setup-code)
1278 (python-shell-completion-string-code-1
1279 python-shell-completion-string-code)
1280 (python-eldoc-setup-code-1 python-eldoc-setup-code)
1281 (python-eldoc-string-code-1 python-eldoc-string-code)
1282 (python-ffap-setup-code-1 python-ffap-setup-code)
1283 (python-ffap-string-code-1 python-ffap-string-code)
1284 (python-shell-setup-codes-1 python-shell-setup-codes))
1285 (with-current-buffer buffer
1286 (inferior-python-mode)
1287 (set (make-local-variable 'python-shell-interpreter)
1288 python-shell-interpreter-1)
1289 (set (make-local-variable 'python-shell-interpreter-args)
1290 python-shell-interpreter-args-1)
1291 (set (make-local-variable 'python-shell-prompt-regexp)
1292 python-shell-prompt-regexp-1)
1293 (set (make-local-variable 'python-shell-prompt-output-regexp)
1294 python-shell-prompt-output-regexp-1)
1295 (set (make-local-variable 'python-shell-prompt-block-regexp)
1296 python-shell-prompt-block-regexp-1)
1297 (set (make-local-variable 'python-shell-completion-setup-code)
1298 python-shell-completion-setup-code-1)
1299 (set (make-local-variable 'python-shell-completion-string-code)
1300 python-shell-completion-string-code-1)
1301 (set (make-local-variable 'python-eldoc-setup-code)
1302 python-eldoc-setup-code-1)
1303 (set (make-local-variable 'python-eldoc-string-code)
1304 python-eldoc-string-code-1)
1305 (set (make-local-variable 'python-ffap-setup-code)
1306 python-ffap-setup-code-1)
1307 (set (make-local-variable 'python-ffap-string-code)
1308 python-ffap-string-code-1)
1309 (set (make-local-variable 'python-shell-setup-codes)
1310 python-shell-setup-codes-1))))
1311 (when pop
1312 (pop-to-buffer proc-buffer-name)))))
77afb61a 1313
45c138ac
FEG		 1314(defun run-python (dedicated cmd)
1315 "Run an inferior Python process.
e2d8d479
FEG		 1316Input and output via buffer named after
1317`python-shell-buffer-name'. If there is a process already
1318running in that buffer, just switch to it.
1319With argument, allows you to define DEDICATED, so a dedicated
1320process for the current buffer is open, and define CMD so you can
1321edit the command used to call the interpreter (default is value
1322of `python-shell-interpreter' and arguments defined in
1323`python-shell-interpreter-args'). Runs the hook
1324`inferior-python-mode-hook' (after the `comint-mode-hook' is
1325run).
1326\(Type \\[describe-mode] in the process buffer for a list of commands.)"
45c138ac
FEG		 1327 (interactive
1328 (if current-prefix-arg
1329 (list
1330 (y-or-n-p "Make dedicated process? ")
1331 (read-string "Run Python: " (python-shell-parse-command)))
1332 (list nil (python-shell-parse-command))))
96eeb83a 1333 (python-shell-make-comint cmd (python-shell-get-process-name dedicated) t)
45c138ac
FEG		 1334 dedicated)
1335
1fe1b5aa
FEG		 1336(defun run-python-internal ()
1337 "Run an inferior Internal Python process.
1338Input and output via buffer named after
1339`python-shell-internal-buffer-name' and what
1340`python-shell-internal-get-process-name' returns. This new kind
1341of shell is intended to be used for generic communication related
1342to defined configurations. The main difference with global or
1343dedicated shells is that these ones are attached to a
1344configuration, not a buffer. This means that can be used for
1345example to retrieve the sys.path and other stuff, without messing
1346with user shells. Runs the hook
1347`inferior-python-mode-hook' (after the `comint-mode-hook' is
1348run). \(Type \\[describe-mode] in the process buffer for a list
1349of commands.)"
1350 (interactive)
77afb61a
FEG		 1351 (python-shell-make-comint
1352 (python-shell-parse-command)
1353 (python-shell-internal-get-process-name)))
1fe1b5aa 1354
45c138ac
FEG		 1355(defun python-shell-get-process ()
1356 "Get inferior Python process for current buffer and return it."
1357 (let* ((dedicated-proc-name (python-shell-get-process-name t))
1358 (dedicated-proc-buffer-name (format "*%s*" dedicated-proc-name))
1359 (global-proc-name (python-shell-get-process-name nil))
1360 (global-proc-buffer-name (format "*%s*" global-proc-name))
1361 (dedicated-running (comint-check-proc dedicated-proc-buffer-name))
1362 (global-running (comint-check-proc global-proc-buffer-name)))
1363 ;; Always prefer dedicated
1364 (get-buffer-process (or (and dedicated-running dedicated-proc-buffer-name)
1365 (and global-running global-proc-buffer-name)))))
1366
1367(defun python-shell-get-or-create-process ()
1368 "Get or create an inferior Python process for current buffer and return it."
79dafa51
FEG		 1369 (let* ((old-buffer (current-buffer))
1370 (dedicated-proc-name (python-shell-get-process-name t))
45c138ac
FEG		 1371 (dedicated-proc-buffer-name (format "*%s*" dedicated-proc-name))
1372 (global-proc-name (python-shell-get-process-name nil))
1373 (global-proc-buffer-name (format "*%s*" global-proc-name))
1374 (dedicated-running (comint-check-proc dedicated-proc-buffer-name))
1375 (global-running (comint-check-proc global-proc-buffer-name))
1376 (current-prefix-arg 4))
1377 (when (and (not dedicated-running) (not global-running))
1378 (if (call-interactively 'run-python)
1379 (setq dedicated-running t)
1380 (setq global-running t)))
1381 ;; Always prefer dedicated
79dafa51 1382 (switch-to-buffer old-buffer)
45c138ac
FEG		 1383 (get-buffer-process (if dedicated-running
1384 dedicated-proc-buffer-name
1385 global-proc-buffer-name))))
1386
1fe1b5aa
FEG		 1387(defun python-shell-internal-get-or-create-process ()
1388 "Get or create an inferior Internal Python process."
1389 (let* ((proc-name (python-shell-internal-get-process-name))
1390 (proc-buffer-name (format "*%s*" proc-name)))
1391 (run-python-internal)
1392 (get-buffer-process proc-buffer-name)))
1393
9ce938be
FEG		 1394(defun python-shell-send-string (string &optional process msg)
1395 "Send STRING to inferior Python PROCESS.
1396When MSG is non-nil messages the first line of STRING."
45c138ac 1397 (interactive "sPython command: ")
9ce938be
FEG		 1398 (let ((process (or process (python-shell-get-or-create-process)))
1399 (lines (split-string string "\n" t)))
1400 (when msg
1401 (message (format "Sent: %s..." (nth 0 lines))))
1402 (if (> (length lines) 1)
1403 (let* ((temp-file-name (make-temp-file "py"))
1404 (file-name (or (buffer-file-name) temp-file-name)))
1405 (with-temp-file temp-file-name
1406 (insert string)
1407 (delete-trailing-whitespace))
1408 (python-shell-send-file file-name process temp-file-name))
1409 (comint-send-string process string)
1410 (when (or (not (string-match "\n$" string))
1411 (string-match "\n[ \t].*\n?$" string))
1412 (comint-send-string process "\n")))))
1413
1414(defun python-shell-send-string-no-output (string &optional process msg)
1415 "Send STRING to PROCESS and inhibit output.
e2d8d479
FEG		 1416When MSG is non-nil messages the first line of STRING. Return
1417the output."
9ce938be
FEG		 1418 (let* ((output-buffer)
1419 (process (or process (python-shell-get-or-create-process)))
1420 (comint-preoutput-filter-functions
1421 (append comint-preoutput-filter-functions
1422 '(ansi-color-filter-apply
1423 (lambda (string)
1424 (setq output-buffer (concat output-buffer string))
1425 "")))))
1426 (python-shell-send-string string process msg)
1427 (accept-process-output process)
62feb915
FEG		 1428 ;; Cleanup output prompt regexp
1429 (when (and (not (string= "" output-buffer))
1430 (> (length python-shell-prompt-output-regexp) 0))
1431 (setq output-buffer
1432 (with-temp-buffer
2db30ac5 1433 (insert output-buffer)
62feb915 1434 (goto-char (point-min))
589cefd7 1435 (forward-comment 9999)
62feb915
FEG		 1436 (buffer-substring-no-properties
1437 (or
1438 (and (looking-at python-shell-prompt-output-regexp)
1439 (re-search-forward
1440 python-shell-prompt-output-regexp nil t 1))
1441 (point-marker))
1442 (point-max)))))
9ce938be
FEG		 1443 (mapconcat
1444 (lambda (string) string)
1445 (butlast (split-string output-buffer "\n")) "\n")))
45c138ac 1446
1fe1b5aa
FEG		 1447(defun python-shell-internal-send-string (string)
1448 "Send STRING to the Internal Python interpreter.
1449Returns the output. See `python-shell-send-string-no-output'."
1450 (python-shell-send-string-no-output
1451 ;; Makes this function compatible with the old
1452 ;; python-send-receive. (At least for CEDET).
1453 (replace-regexp-in-string "_emacs_out +" "" string)
1454 (python-shell-internal-get-or-create-process) nil))
1455
1456(define-obsolete-function-alias
1457 'python-send-receive 'python-shell-internal-send-string "23.3"
1458 "Send STRING to inferior Python (if any) and return result.
1459The result is what follows `_emacs_out' in the output.
1460This is a no-op if `python-check-comint-prompt' returns nil.")
1461
45c138ac
FEG		 1462(defun python-shell-send-region (start end)
1463 "Send the region delimited by START and END to inferior Python process."
1464 (interactive "r")
9ce938be
FEG		 1465 (let ((deactivate-mark nil))
1466 (python-shell-send-string (buffer-substring start end) nil t)))
45c138ac
FEG		 1467
1468(defun python-shell-send-buffer ()
1469 "Send the entire buffer to inferior Python process."
1470 (interactive)
1471 (save-restriction
1472 (widen)
1473 (python-shell-send-region (point-min) (point-max))))
1474
1475(defun python-shell-send-defun (arg)
2ed294c5 1476 "Send the current defun to inferior Python process.
45c138ac
FEG		 1477When argument ARG is non-nil sends the innermost defun."
1478 (interactive "P")
1479 (save-excursion
2ed294c5
FEG		 1480 (python-shell-send-region
1481 (progn
1482 (or (python-beginning-of-defun-function)
1483 (progn (beginning-of-line) (point-marker))))
1484 (progn
1485 (or (python-end-of-defun-function)
1486 (progn (end-of-line) (point-marker)))))))
45c138ac 1487
d439cda5
FEG		 1488(defun python-shell-send-file (file-name &optional process temp-file-name)
1489 "Send FILE-NAME to inferior Python PROCESS.
1490If TEMP-FILE-NAME is passed then that file is used for processing
1491instead, while internally the shell will continue to use
1492FILE-NAME."
45c138ac 1493 (interactive "fFile to send: ")
9ce938be
FEG		 1494 (let* ((process (or process (python-shell-get-or-create-process)))
1495 (temp-file-name (when temp-file-name
1496 (expand-file-name temp-file-name)))
1497 (file-name (or (expand-file-name file-name) temp-file-name)))
1498 (when (not file-name)
1499 (error "If FILE-NAME is nil then TEMP-FILE-NAME must be non-nil"))
d439cda5 1500 (with-current-buffer (process-buffer process)
24b68537
FEG		 1501 (setq inferior-python-mode-current-file
1502 (convert-standard-filename file-name)))
13d914ed 1503 (python-shell-send-string
b962ebad 1504 (format
d439cda5
FEG		 1505 (concat "__pyfile = open('''%s''');"
1506 "exec(compile(__pyfile.read(), '''%s''', 'exec'));"
1507 "__pyfile.close()")
1508 (or temp-file-name file-name) file-name)
13d914ed 1509 process)))
45c138ac
FEG		 1510
1511(defun python-shell-switch-to-shell ()
1512 "Switch to inferior Python process buffer."
1513 (interactive)
1514 (pop-to-buffer (process-buffer (python-shell-get-or-create-process)) t))
1515
c0428ba0
FEG		 1516(defun python-shell-send-setup-code ()
1517 "Send all setup code for shell.
1518This function takes the list of setup code to send from the
1519`python-shell-setup-codes' list."
1520 (let ((msg "Sent %s")
1521 (process (get-buffer-process (current-buffer))))
30e429dd 1522 (accept-process-output process python-shell-send-setup-max-wait)
c0428ba0
FEG		 1523 (dolist (code python-shell-setup-codes)
1524 (when code
1525 (when (consp code)
1526 (setq msg (cdr code)))
1527 (message (format msg code))
1528 (python-shell-send-string-no-output
1529 (symbol-value code) process)))))
1530
1531(add-hook 'inferior-python-mode-hook
1532 #'python-shell-send-setup-code)
1533
45c138ac
FEG		 1534\f
1535;;; Shell completion
1536
0f55249e 1537(defcustom python-shell-completion-setup-code
45c138ac
FEG		 1538 "try:
1539 import readline
1540except ImportError:
1541 def __COMPLETER_all_completions(text): []
1542else:
1543 import rlcompleter
1544 readline.set_completer(rlcompleter.Completer().complete)
1545 def __COMPLETER_all_completions(text):
1546 import sys
1547 completions = []
1548 try:
1549 i = 0
1550 while True:
1551 res = readline.get_completer()(text, i)
1552 if not res: break
1553 i += 1
1554 completions.append(res)
1555 except NameError:
1556 pass
1557 return completions"
0f55249e
FEG		 1558 "Code used to setup completion in inferior Python processes."
1559 :type 'string
1560 :group 'python
1561 :safe 'stringp)
45c138ac 1562
0f55249e 1563(defcustom python-shell-completion-string-code
45c138ac 1564 "';'.join(__COMPLETER_all_completions('''%s'''))\n"
0f55249e
FEG		 1565 "Python code used to get a string of completions separated by semicolons."
1566 :type 'string
1567 :group 'python
1568 :safe 'stringp)
45c138ac 1569
075a0f61
FEG		 1570(defun python-shell-completion--get-completions (input process)
1571 "Retrieve available completions for INPUT using PROCESS."
1572 (with-current-buffer (process-buffer process)
62feb915
FEG		 1573 (let ((completions (python-shell-send-string-no-output
1574 (format python-shell-completion-string-code input)
1575 process)))
1576 (when (> (length completions) 2)
1577 (split-string completions "^'\\|^\"\\|;\\|'$\\|\"$" t)))))
075a0f61
FEG		 1578
1579(defun python-shell-completion--get-completion (input completions)
1580 "Get completion for INPUT using COMPLETIONS."
1581 (let ((completion (when completions
1582 (try-completion input completions))))
1583 (cond ((eq completion t)
1584 input)
1585 ((null completion)
1586 (message "Can't find completion for \"%s\"" input)
1587 (ding)
1588 input)
1589 ((not (string= input completion))
1590 completion)
1591 (t
1592 (message "Making completion list...")
1593 (with-output-to-temp-buffer "*Python Completions*"
1594 (display-completion-list
1595 (all-completions input completions)))
1596 input))))
1597
45c138ac
FEG		 1598(defun python-shell-completion-complete-at-point ()
1599 "Perform completion at point in inferior Python process."
1600 (interactive)
3d6913c7
FEG		 1601 (with-syntax-table python-dotty-syntax-table
1602 (when (and comint-last-prompt-overlay
1603 (> (point-marker) (overlay-end comint-last-prompt-overlay)))
1604 (let* ((process (get-buffer-process (current-buffer)))
075a0f61
FEG		 1605 (input (substring-no-properties
1606 (or (comint-word (current-word)) "") nil nil)))
1607 (delete-char (- (length input)))
1608 (insert
1609 (python-shell-completion--get-completion
1610 input (python-shell-completion--get-completions input process)))))))
45c138ac 1611
45c138ac
FEG		 1612(defun python-shell-completion-complete-or-indent ()
1613 "Complete or indent depending on the context.
e2d8d479
FEG		 1614If content before pointer is all whitespace indent. If not try
1615to complete."
45c138ac
FEG		 1616 (interactive)
1617 (if (string-match "^[[:space:]]*$"
1618 (buffer-substring (comint-line-beginning-position)
1619 (point-marker)))
1620 (indent-for-tab-command)
1621 (comint-dynamic-complete)))
1622
45c138ac
FEG		 1623\f
1624;;; PDB Track integration
1625
0f55249e 1626(defcustom python-pdbtrack-stacktrace-info-regexp
45c138ac 1627 "> %s(\\([0-9]+\\))\\([?a-zA-Z0-9_<>]+\\)()"
e2d8d479 1628 "Regular Expression matching stacktrace information.
0f55249e 1629Used to extract the current line and module being inspected. The
e2d8d479
FEG		 1630regexp should not start with a caret (^) and can contain a string
1631placeholder (\%s) which is replaced with the filename beign
1632inspected (so other files in the debugging process are not
0f55249e
FEG		 1633opened)"
1634 :type 'string
1635 :group 'python
1636 :safe 'stringp)
45c138ac
FEG		 1637
1638(defvar python-pdbtrack-tracking-buffers '()
1639 "Alist containing elements of form (#<buffer> . #<buffer>).
1640The car of each element of the alist is the tracking buffer and
1641the cdr is the tracked buffer.")
1642
1643(defun python-pdbtrack-get-or-add-tracking-buffers ()
1644 "Get/Add a tracked buffer for the current buffer.
1645Internally it uses the `python-pdbtrack-tracking-buffers' alist.
1646Returns a cons with the form:
1647 * (#<tracking buffer> . #< tracked buffer>)."
1648 (or
1649 (assq (current-buffer) python-pdbtrack-tracking-buffers)
1650 (let* ((file (with-current-buffer (current-buffer)
d439cda5 1651 inferior-python-mode-current-file))
45c138ac
FEG		 1652 (tracking-buffers
1653 `(,(current-buffer) .
1654 ,(or (get-file-buffer file)
1655 (find-file-noselect file)))))
1656 (set-buffer (cdr tracking-buffers))
1657 (python-mode)
1658 (set-buffer (car tracking-buffers))
1659 (setq python-pdbtrack-tracking-buffers
1660 (cons tracking-buffers python-pdbtrack-tracking-buffers))
1661 tracking-buffers)))
1662
1663(defun python-pdbtrack-comint-output-filter-function (output)
1664 "Move overlay arrow to current pdb line in tracked buffer.
1665Argument OUTPUT is a string with the output from the comint process."
1666 (when (not (string= output ""))
1667 (let ((full-output (ansi-color-filter-apply
1668 (buffer-substring comint-last-input-end
1669 (point-max)))))
1670 (if (string-match python-shell-prompt-pdb-regexp full-output)
1671 (let* ((tracking-buffers (python-pdbtrack-get-or-add-tracking-buffers))
1672 (line-num
1673 (save-excursion
1674 (string-match
1675 (format python-pdbtrack-stacktrace-info-regexp
1676 (regexp-quote
d439cda5 1677 inferior-python-mode-current-file))
45c138ac
FEG		 1678 full-output)
1679 (string-to-number (or (match-string-no-properties 1 full-output) ""))))
1680 (tracked-buffer-window (get-buffer-window (cdr tracking-buffers)))
1681 (tracked-buffer-line-pos))
1682 (when line-num
1683 (with-current-buffer (cdr tracking-buffers)
1684 (set (make-local-variable 'overlay-arrow-string) "=>")
1685 (set (make-local-variable 'overlay-arrow-position) (make-marker))
1686 (setq tracked-buffer-line-pos (progn
1687 (goto-char (point-min))
1688 (forward-line (1- line-num))
1689 (point-marker)))
1690 (when tracked-buffer-window
1691 (set-window-point tracked-buffer-window tracked-buffer-line-pos))
1692 (set-marker overlay-arrow-position tracked-buffer-line-pos)))
1693 (pop-to-buffer (cdr tracking-buffers))
1694 (switch-to-buffer-other-window (car tracking-buffers)))
1695 (let ((tracking-buffers (assq (current-buffer)
1696 python-pdbtrack-tracking-buffers)))
1697 (when tracking-buffers
1698 (if inferior-python-mode-current-file
1699 (with-current-buffer (cdr tracking-buffers)
1700 (set-marker overlay-arrow-position nil))
1701 (kill-buffer (cdr tracking-buffers)))
1702 (setq python-pdbtrack-tracking-buffers
1703 (assq-delete-all (current-buffer)
1704 python-pdbtrack-tracking-buffers)))))))
1705 output)
1706
1707\f
1708;;; Symbol completion
1709
1710(defun python-completion-complete-at-point ()
1711 "Complete current symbol at point.
1712For this to work the best as possible you should call
1713`python-shell-send-buffer' from time to time so context in
1714inferior python process is updated properly."
1715 (interactive)
1716 (let ((process (python-shell-get-process)))
1717 (if (not process)
4e531f7a 1718 (error "Completion needs an inferior Python process running")
075a0f61
FEG		 1719 (with-syntax-table python-dotty-syntax-table
1720 (let* ((input (substring-no-properties
1721 (or (comint-word (current-word)) "") nil nil))
1722 (completions (python-shell-completion--get-completions
1723 input process)))
1724 (delete-char (- (length input)))
1725 (insert
1726 (python-shell-completion--get-completion
1727 input completions)))))))
45c138ac
FEG		 1728
1729(add-to-list 'debug-ignored-errors "^Completion needs an inferior Python process running.")
1730
1731\f
1732;;; Fill paragraph
1733
c2cb97ae
FEG		 1734(defcustom python-fill-comment-function 'python-fill-comment
1735 "Function to fill comments.
1736This is the function used by `python-fill-paragraph-function' to
1737fill comments."
1738 :type 'symbol
1739 :group 'python
1740 :safe 'symbolp)
1741
1742(defcustom python-fill-string-function 'python-fill-string
1743 "Function to fill strings.
1744This is the function used by `python-fill-paragraph-function' to
1745fill strings."
1746 :type 'symbol
1747 :group 'python
1748 :safe 'symbolp)
1749
1750(defcustom python-fill-decorator-function 'python-fill-decorator
1751 "Function to fill decorators.
1752This is the function used by `python-fill-paragraph-function' to
1753fill decorators."
1754 :type 'symbol
1755 :group 'python
1756 :safe 'symbolp)
1757
1758(defcustom python-fill-paren-function 'python-fill-paren
1759 "Function to fill parens.
1760This is the function used by `python-fill-paragraph-function' to
1761fill parens."
1762 :type 'symbol
1763 :group 'python
1764 :safe 'symbolp)
1765
45c138ac
FEG		 1766(defun python-fill-paragraph-function (&optional justify)
1767 "`fill-paragraph-function' handling multi-line strings and possibly comments.
1768If any of the current line is in or at the end of a multi-line string,
1769fill the string or the paragraph of it that point is in, preserving
4e531f7a
FEG		 1770the string's indentation.
1771Optional argument JUSTIFY defines if the paragraph should be justified."
45c138ac
FEG		 1772 (interactive "P")
1773 (save-excursion
1774 (back-to-indentation)
1775 (cond
1776 ;; Comments
c2cb97ae
FEG		 1777 ((funcall python-fill-comment-function justify))
1778 ;; Strings/Docstrings
45c138ac 1779 ((save-excursion (skip-chars-forward "\"'uUrR")
14a78495 1780 (python-info-ppss-context 'string))
c2cb97ae 1781 (funcall python-fill-string-function justify))
45c138ac
FEG		 1782 ;; Decorators
1783 ((equal (char-after (save-excursion
1784 (back-to-indentation)
c2cb97ae
FEG		 1785 (point-marker))) ?@)
1786 (funcall python-fill-decorator-function justify))
45c138ac 1787 ;; Parens
14a78495 1788 ((or (python-info-ppss-context 'paren)
45c138ac
FEG		 1789 (looking-at (python-rx open-paren))
1790 (save-excursion
1791 (skip-syntax-forward "^(" (line-end-position))
1792 (looking-at (python-rx open-paren))))
c2cb97ae 1793 (funcall python-fill-paren-function justify))
45c138ac
FEG		 1794 (t t))))
1795
c2cb97ae 1796(defun python-fill-comment (&optional justify)
053a6c72
FEG		 1797 "Comment fill function for `python-fill-paragraph-function'.
1798JUSTIFY should be used (if applicable) as in `fill-paragraph'."
c2cb97ae
FEG		 1799 (fill-comment-paragraph justify))
1800
1801(defun python-fill-string (&optional justify)
053a6c72
FEG		 1802 "String fill function for `python-fill-paragraph-function'.
1803JUSTIFY should be used (if applicable) as in `fill-paragraph'."
c2cb97ae
FEG		 1804 (let ((marker (point-marker))
1805 (string-start-marker
1806 (progn
1807 (skip-chars-forward "\"'uUrR")
1808 (goto-char (python-info-ppss-context 'string))
1809 (skip-chars-forward "\"'uUrR")
1810 (point-marker)))
1811 (reg-start (line-beginning-position))
1812 (string-end-marker
1813 (progn
1814 (while (python-info-ppss-context 'string)
1815 (goto-char (1+ (point-marker))))
1816 (skip-chars-backward "\"'")
1817 (point-marker)))
1818 (reg-end (line-end-position))
1819 (fill-paragraph-function))
1820 (save-restriction
1821 (narrow-to-region reg-start reg-end)
1822 (save-excursion
1823 (goto-char string-start-marker)
1824 (delete-region (point-marker) (progn
1825 (skip-syntax-forward "> ")
1826 (point-marker)))
1827 (goto-char string-end-marker)
1828 (delete-region (point-marker) (progn
1829 (skip-syntax-backward "> ")
1830 (point-marker)))
1831 (save-excursion
1832 (goto-char marker)
1833 (fill-paragraph justify))
1834 ;; If there is a newline in the docstring lets put triple
1835 ;; quote in it's own line to follow pep 8
1836 (when (save-excursion
1837 (re-search-backward "\n" string-start-marker t))
1838 (newline)
1839 (newline-and-indent))
1840 (fill-paragraph justify)))) t)
1841
1842(defun python-fill-decorator (&optional justify)
053a6c72
FEG		 1843 "Decorator fill function for `python-fill-paragraph-function'.
1844JUSTIFY should be used (if applicable) as in `fill-paragraph'."
c2cb97ae
FEG		 1845 t)
1846
1847(defun python-fill-paren (&optional justify)
053a6c72
FEG		 1848 "Paren fill function for `python-fill-paragraph-function'.
1849JUSTIFY should be used (if applicable) as in `fill-paragraph'."
c2cb97ae
FEG		 1850 (save-restriction
1851 (narrow-to-region (progn
1852 (while (python-info-ppss-context 'paren)
1853 (goto-char (1- (point-marker))))
1854 (point-marker)
1855 (line-beginning-position))
1856 (progn
1857 (when (not (python-info-ppss-context 'paren))
1858 (end-of-line)
1859 (when (not (python-info-ppss-context 'paren))
1860 (skip-syntax-backward "^)")))
1861 (while (python-info-ppss-context 'paren)
1862 (goto-char (1+ (point-marker))))
1863 (point-marker)))
1864 (let ((paragraph-start "\f\\|[ \t]*$")
1865 (paragraph-separate ",")
1866 (fill-paragraph-function))
1867 (goto-char (point-min))
1868 (fill-paragraph justify))
1869 (while (not (eobp))
1870 (forward-line 1)
1871 (python-indent-line)
1872 (goto-char (line-end-position)))) t)
1873
45c138ac 1874\f
e2803784
FEG		 1875;;; Skeletons
1876
1877(defcustom python-skeleton-autoinsert nil
1878 "Non-nil means template skeletons will be automagically inserted.
1879This happens when pressing \"if<SPACE>\", for example, to prompt for
1880the if condition."
1881 :type 'boolean
0f55249e
FEG		 1882 :group 'python
1883 :safe 'booleanp)
e2803784
FEG		 1884
1885(defvar python-skeleton-available '()
1886 "Internal list of available skeletons.")
e2803784
FEG		 1887
1888(define-abbrev-table 'python-mode-abbrev-table ()
1889 "Abbrev table for Python mode."
1890 :case-fixed t
1891 ;; Allow / inside abbrevs.
1892 :regexp "\\(?:^\\|[^/]\\)\\<\\([[:word:]/]+\\)\\W*"
1893 ;; Only expand in code.
1894 :enable-function (lambda ()
e2803784 1895 (and
14a78495
FEG		 1896 (not (or (python-info-ppss-context 'string)
1897 (python-info-ppss-context 'comment)))
e2803784
FEG		 1898 python-skeleton-autoinsert)))
1899
1900(defmacro python-skeleton-define (name doc &rest skel)
1901 "Define a `python-mode' skeleton using NAME DOC and SKEL.
1902The skeleton will be bound to python-skeleton-NAME and will
1903be added to `python-mode-abbrev-table'."
1904 (let* ((name (symbol-name name))
1905 (function-name (intern (concat "python-skeleton-" name))))
73ed6836
FEG		 1906 `(progn
1907 (define-abbrev python-mode-abbrev-table ,name "" ',function-name)
1908 (setq python-skeleton-available
1909 (cons ',function-name python-skeleton-available))
1910 (define-skeleton ,function-name
1911 ,(or doc
1912 (format "Insert %s statement." name))
1913 ,@skel))))
e2803784
FEG		 1914(put 'python-skeleton-define 'lisp-indent-function 2)
1915
1916(defmacro python-define-auxiliary-skeleton (name doc &optional &rest skel)
1917 "Define a `python-mode' auxiliary skeleton using NAME DOC and SKEL.
1918The skeleton will be bound to python-skeleton-NAME."
1919 (let* ((name (symbol-name name))
1920 (function-name (intern (concat "python-skeleton--" name)))
1921 (msg (format
1922 "Add '%s' clause? " name)))
1923 (when (not skel)
1924 (setq skel
1925 `(< ,(format "%s:" name) \n \n
1926 > _ \n)))
1927 `(define-skeleton ,function-name
1928 ,(or doc
1929 (format "Auxiliary skeleton for %s statement." name))
1930 nil
1931 (unless (y-or-n-p ,msg)
1932 (signal 'quit t))
1933 ,@skel)))
1934(put 'python-define-auxiliary-skeleton 'lisp-indent-function 2)
1935
1936(python-define-auxiliary-skeleton else nil)
1937
1938(python-define-auxiliary-skeleton except nil)
1939
1940(python-define-auxiliary-skeleton finally nil)
1941
1942(python-skeleton-define if nil
1943 "Condition: "
1944 "if " str ":" \n
1945 _ \n
1946 ("other condition, %s: "
1947 <
1948 "elif " str ":" \n
1949 > _ \n nil)
1950 '(python-skeleton--else) | ^)
1951
1952(python-skeleton-define while nil
1953 "Condition: "
1954 "while " str ":" \n
1955 > _ \n
1956 '(python-skeleton--else) | ^)
1957
1958(python-skeleton-define for nil
1959 "Iteration spec: "
1960 "for " str ":" \n
1961 > _ \n
1962 '(python-skeleton--else) | ^)
1963
1964(python-skeleton-define try nil
1965 nil
1966 "try:" \n
1967 > _ \n
1968 ("Exception, %s: "
1969 <
1970 "except " str ":" \n
1971 > _ \n nil)
1972 resume:
1973 '(python-skeleton--except)
1974 '(python-skeleton--else)
1975 '(python-skeleton--finally) | ^)
1976
1977(python-skeleton-define def nil
1978 "Function name: "
1979 "def " str " (" ("Parameter, %s: "
1980 (unless (equal ?\( (char-before)) ", ")
1981 str) "):" \n
1982 "\"\"\"" - "\"\"\"" \n
1983 > _ \n)
1984
1985(python-skeleton-define class nil
1986 "Class name: "
1987 "class " str " (" ("Inheritance, %s: "
1988 (unless (equal ?\( (char-before)) ", ")
1989 str)
1990 & ")" | -2
1991 ":" \n
1992 "\"\"\"" - "\"\"\"" \n
1993 > _ \n)
1994
1995(defun python-skeleton-add-menu-items ()
1996 "Add menu items to Python->Skeletons menu."
1997 (let ((skeletons (sort python-skeleton-available 'string<))
1998 (items))
1999 (dolist (skeleton skeletons)
2000 (easy-menu-add-item
2001 nil '("Python" "Skeletons")
2002 `[,(format
2003 "Insert %s" (caddr (split-string (symbol-name skeleton) "-")))
2004 ,skeleton t]))))
2005\f
046428d3
FEG		 2006;;; FFAP
2007
0f55249e 2008(defcustom python-ffap-setup-code
046428d3
FEG		 2009 "def __FFAP_get_module_path(module):
2010 try:
2011 import os
2012 path = __import__(module).__file__
2013 if path[-4:] == '.pyc' and os.path.exists(path[0:-1]):
2014 path = path[:-1]
2015 return path
2016 except:
2017 return ''"
0f55249e
FEG		 2018 "Python code to get a module path."
2019 :type 'string
2020 :group 'python
2021 :safe 'stringp)
046428d3 2022
0f55249e 2023(defcustom python-ffap-string-code
046428d3 2024 "__FFAP_get_module_path('''%s''')\n"
0f55249e
FEG		 2025 "Python code used to get a string with the path of a module."
2026 :type 'string
2027 :group 'python
2028 :safe 'stringp)
046428d3 2029
046428d3
FEG		 2030(defun python-ffap-module-path (module)
2031 "Function for `ffap-alist' to return path for MODULE."
2032 (let ((process (or
2033 (and (eq major-mode 'inferior-python-mode)
2034 (get-buffer-process (current-buffer)))
2035 (python-shell-get-process))))
2036 (if (not process)
2037 nil
2038 (let ((module-file
9ce938be 2039 (python-shell-send-string-no-output
046428d3
FEG		 2040 (format python-ffap-string-code module) process)))
2041 (when module-file
2947016a 2042 (substring-no-properties module-file 1 -1))))))
046428d3
FEG		 2043
2044(eval-after-load "ffap"
2045 '(progn
2046 (push '(python-mode . python-ffap-module-path) ffap-alist)
2047 (push '(inferior-python-mode . python-ffap-module-path) ffap-alist)))
2048
046428d3 2049\f
8b3e0e76
FEG		 2050;;; Code check
2051
0f55249e 2052(defcustom python-check-command
8b3e0e76 2053 "pychecker --stdlib"
0f55249e
FEG		 2054 "Command used to check a Python file."
2055 :type 'string
2056 :group 'python
2057 :safe 'stringp)
8b3e0e76
FEG		 2058
2059(defvar python-check-custom-command nil
2060 "Internal use.")
2061
2062(defun python-check (command)
2063 "Check a Python file (default current buffer's file).
2064Runs COMMAND, a shell command, as if by `compile'. See
2065`python-check-command' for the default."
2066 (interactive
2067 (list (read-string "Check command: "
2068 (or python-check-custom-command
2069 (concat python-check-command " "
2070 (shell-quote-argument
2071 (or
2072 (let ((name (buffer-file-name)))
2073 (and name
2074 (file-name-nondirectory name)))
2075 "")))))))
2076 (setq python-check-custom-command command)
2077 (save-some-buffers (not compilation-ask-about-save) nil)
2078 (compilation-start command))
2079
2080\f
45c138ac
FEG		 2081;;; Eldoc
2082
0f55249e 2083(defcustom python-eldoc-setup-code
45c138ac
FEG		 2084 "def __PYDOC_get_help(obj):
2085 try:
15cc40b8 2086 import inspect
9e662938
FEG		 2087 if hasattr(obj, 'startswith'):
2088 obj = eval(obj, globals())
15cc40b8
FEG		 2089 doc = inspect.getdoc(obj)
2090 if not doc and callable(obj):
2091 target = None
2092 if inspect.isclass(obj) and hasattr(obj, '__init__'):
2093 target = obj.__init__
2094 objtype = 'class'
2095 else:
2096 target = obj
2097 objtype = 'def'
2098 if target:
2099 args = inspect.formatargspec(
2100 *inspect.getargspec(target)
2101 )
2102 name = obj.__name__
2103 doc = '{objtype} {name}{args}'.format(
2104 objtype=objtype, name=name, args=args
2105 )
2106 else:
2107 doc = doc.splitlines()[0]
45c138ac 2108 except:
9e662938
FEG		 2109 doc = ''
2110 try:
2111 exec('print doc')
2112 except SyntaxError:
2113 print(doc)"
0f55249e
FEG		 2114 "Python code to setup documentation retrieval."
2115 :type 'string
2116 :group 'python
2117 :safe 'stringp)
45c138ac 2118
0f55249e 2119(defcustom python-eldoc-string-code
9e662938 2120 "__PYDOC_get_help('''%s''')\n"
0f55249e
FEG		 2121 "Python code used to get a string with the documentation of an object."
2122 :type 'string
2123 :group 'python
2124 :safe 'stringp)
45c138ac 2125
78334b43 2126(defun python-eldoc--get-doc-at-point (&optional force-input force-process)
d439cda5
FEG		 2127 "Internal implementation to get documentation at point.
2128If not FORCE-INPUT is passed then what `current-word' returns
2129will be used. If not FORCE-PROCESS is passed what
2130`python-shell-get-process' returns is used."
78334b43 2131 (let ((process (or force-process (python-shell-get-process))))
45c138ac
FEG		 2132 (if (not process)
2133 "Eldoc needs an inferior Python process running."
2134 (let* ((current-defun (python-info-current-defun))
78334b43
FEG		 2135 (input (or force-input
2136 (with-syntax-table python-dotty-syntax-table
2137 (if (not current-defun)
2138 (current-word)
2139 (concat current-defun "." (current-word))))))
45c138ac
FEG		 2140 (ppss (syntax-ppss))
2141 (help (when (and input
2142 (not (string= input (concat current-defun ".")))
14a78495
FEG		 2143 (not (or (python-info-ppss-context 'string ppss)
2144 (python-info-ppss-context 'comment ppss))))
45c138ac
FEG		 2145 (when (string-match (concat
2146 (regexp-quote (concat current-defun "."))
2147 "self\\.") input)
2148 (with-temp-buffer
2149 (insert input)
2150 (goto-char (point-min))
2151 (forward-word)
2152 (forward-char)
2153 (delete-region (point-marker) (search-forward "self."))
2154 (setq input (buffer-substring (point-min) (point-max)))))
9ce938be 2155 (python-shell-send-string-no-output
1066882c 2156 (format python-eldoc-string-code input) process))))
45c138ac
FEG		 2157 (with-current-buffer (process-buffer process)
2158 (when comint-last-prompt-overlay
2159 (delete-region comint-last-input-end
2160 (overlay-start comint-last-prompt-overlay))))
2161 (when (and help
2162 (not (string= help "\n")))
2163 help)))))
2164
78334b43
FEG		 2165(defun python-eldoc-function ()
2166 "`eldoc-documentation-function' for Python.
2167For this to work the best as possible you should call
2168`python-shell-send-buffer' from time to time so context in
2169inferior python process is updated properly."
2170 (python-eldoc--get-doc-at-point))
2171
2172(defun python-eldoc-at-point (symbol)
2173 "Get help on SYMBOL using `help'.
2174Interactively, prompt for symbol."
2175 (interactive
2176 (let ((symbol (with-syntax-table python-dotty-syntax-table
2177 (current-word)))
2178 (enable-recursive-minibuffers t))
2179 (list (read-string (if symbol
2180 (format "Describe symbol (default %s): " symbol)
2181 "Describe symbol: ")
2182 nil nil symbol))))
2183 (let ((process (python-shell-get-process)))
2184 (if (not process)
2185 (message "Eldoc needs an inferior Python process running.")
15cc40b8 2186 (message (python-eldoc--get-doc-at-point symbol process)))))
78334b43 2187
45c138ac 2188\f
fc2dc7df
FEG		 2189;;; Imenu
2190
2191(defcustom python-imenu-include-defun-type t
2192 "Non-nil make imenu items to include its type."
2193 :type 'boolean
2194 :group 'python
2195 :safe 'booleanp)
2196
c942de99 2197(defcustom python-imenu-make-tree t
fc2dc7df
FEG		 2198 "Non-nil make imenu to build a tree menu.
2199Set to nil for speed."
2200 :type 'boolean
2201 :group 'python
2202 :safe 'booleanp)
2203
2204(defcustom python-imenu-subtree-root-label "<Jump to %s>"
2205 "Label displayed to navigate to root from a subtree.
2206It can contain a \"%s\" which will be replaced with the root name."
2207 :type 'string
2208 :group 'python
2209 :safe 'stringp)
2210
2211(defvar python-imenu-index-alist nil
2212 "Calculated index tree for imenu.")
2213
2214(defun python-imenu-tree-assoc (keylist tree)
2215 "Using KEYLIST traverse TREE."
2216 (if keylist
2217 (python-imenu-tree-assoc (cdr keylist)
2218 (ignore-errors (assoc (car keylist) tree)))
2219 tree))
2220
2221(defun python-imenu-make-element-tree (element-list full-element plain-index)
2222 "Make a tree from plain alist of module names.
2223ELEMENT-LIST is the defun name splitted by \".\" and FULL-ELEMENT
2224is the same thing, the difference is that FULL-ELEMENT remains
2225untouched in all recursive calls.
2226Argument PLAIN-INDEX is the calculated plain index used to build the tree."
2227 (when (not (python-imenu-tree-assoc full-element python-imenu-index-alist))
2228 (when element-list
2229 (let* ((subelement-point (cdr (assoc
2230 (mapconcat #'identity full-element ".")
2231 plain-index)))
2232 (subelement-name (car element-list))
c942de99
FEG		 2233 (subelement-position (python-util-position
2234 subelement-name full-element))
fc2dc7df
FEG		 2235 (subelement-path (when subelement-position
2236 (butlast
2237 full-element
2238 (- (length full-element)
2239 subelement-position)))))
2240 (let ((path-ref (python-imenu-tree-assoc subelement-path
2241 python-imenu-index-alist)))
2242 (if (not path-ref)
2243 (push (cons subelement-name subelement-point)
2244 python-imenu-index-alist)
2245 (when (not (listp (cdr path-ref)))
2246 ;; Modifiy root cdr to be a list
2247 (setcdr path-ref
2248 (list (cons (format python-imenu-subtree-root-label
2249 (car path-ref))
2250 (cdr (assoc
2251 (mapconcat #'identity
2252 subelement-path ".")
2253 plain-index))))))
2254 (when (not (assoc subelement-name path-ref))
2255 (push (cons subelement-name subelement-point) (cdr path-ref))))))
2256 (python-imenu-make-element-tree (cdr element-list)
2257 full-element plain-index))))
2258
2259(defun python-imenu-make-tree (index)
2260"Build the imenu alist tree from plain INDEX.
2261
2262The idea of this function is that given the alist:
2263
2264 '((\"Test\" . 100)
2265 (\"Test.__init__\" . 200)
2266 (\"Test.some_method\" . 300)
2267 (\"Test.some_method.another\" . 400)
2268 (\"Test.something_else\" . 500)
2269 (\"test\" . 600)
2270 (\"test.reprint\" . 700)
2271 (\"test.reprint\" . 800))
2272
2273This tree gets built:
2274
2275 '((\"Test\" . ((\"jump to...\" . 100)
2276 (\"__init__\" . 200)
2277 (\"some_method\" . ((\"jump to...\" . 300)
2278 (\"another\" . 400)))
2279 (\"something_else\" . 500)))
2280 (\"test\" . ((\"jump to...\" . 600)
2281 (\"reprint\" . 700)
2282 (\"reprint\" . 800))))
2283
2284Internally it uses `python-imenu-make-element-tree' to create all
2285branches for each element."
2286(setq python-imenu-index-alist nil)
c942de99
FEG		 2287(mapc (lambda (element)
2288 (python-imenu-make-element-tree element element index))
2289 (mapcar (lambda (element)
2290 (split-string (car element) "\\." t)) index))
fc2dc7df
FEG		 2291python-imenu-index-alist)
2292
2293(defun python-imenu-create-index ()
2294 "`imenu-create-index-function' for Python."
2295 (let ((index))
2296 (goto-char (point-max))
2297 (while (python-beginning-of-defun-function 1 t)
2298 (let ((defun-dotted-name
2299 (python-info-current-defun python-imenu-include-defun-type)))
2300 (push (cons defun-dotted-name (point)) index)))
2301 (if python-imenu-make-tree
2302 (python-imenu-make-tree index)
2303 index)))
2304
2305\f
45c138ac
FEG		 2306;;; Misc helpers
2307
fc2dc7df 2308(defun python-info-current-defun (&optional include-type)
45c138ac 2309 "Return name of surrounding function with Python compatible dotty syntax.
fc2dc7df 2310Optional argument INCLUDE-TYPE indicates to include the type of the defun.
45c138ac
FEG		 2311This function is compatible to be used as
2312`add-log-current-defun-function' since it returns nil if point is
2313not inside a defun."
6b432853 2314 (let ((names '())
0b7b2e51
FEG		 2315 (min-indent)
2316 (first-run t))
45c138ac
FEG		 2317 (save-restriction
2318 (widen)
2319 (save-excursion
6b432853 2320 (goto-char (line-end-position))
589cefd7 2321 (forward-comment -9999)
15cc40b8 2322 (setq min-indent (current-indentation))
fc2dc7df 2323 (while (python-beginning-of-defun-function 1 t)
0b7b2e51
FEG		 2324 (when (or (< (current-indentation) min-indent)
2325 first-run)
2326 (setq first-run nil)
6b432853 2327 (setq min-indent (current-indentation))
af5c1beb 2328 (looking-at python-nav-beginning-of-defun-regexp)
fc2dc7df
FEG		 2329 (setq names (cons
2330 (if (not include-type)
2331 (match-string-no-properties 1)
2332 (mapconcat 'identity
2333 (split-string
2334 (match-string-no-properties 0)) " "))
2335 names))))))
45c138ac
FEG		 2336 (when names
2337 (mapconcat (lambda (string) string) names "."))))
2338
2339(defun python-info-closing-block ()
e2d8d479 2340 "Return the point of the block the current line closes."
45c138ac
FEG		 2341 (let ((closing-word (save-excursion
2342 (back-to-indentation)
2343 (current-word)))
2344 (indentation (current-indentation)))
2345 (when (member closing-word python-indent-dedenters)
2346 (save-excursion
2347 (forward-line -1)
2348 (while (and (> (current-indentation) indentation)
2349 (not (bobp))
2350 (not (back-to-indentation))
2351 (forward-line -1)))
2352 (back-to-indentation)
2353 (cond
2354 ((not (equal indentation (current-indentation))) nil)
2355 ((string= closing-word "elif")
2356 (when (member (current-word) '("if" "elif"))
2357 (point-marker)))
2358 ((string= closing-word "else")
2359 (when (member (current-word) '("if" "elif" "except" "for" "while"))
2360 (point-marker)))
2361 ((string= closing-word "except")
2362 (when (member (current-word) '("try"))
2363 (point-marker)))
2364 ((string= closing-word "finally")
2365 (when (member (current-word) '("except" "else"))
2366 (point-marker))))))))
2367
2368(defun python-info-line-ends-backslash-p ()
2369 "Return non-nil if current line ends with backslash."
2370 (string= (or (ignore-errors
2371 (buffer-substring
2372 (line-end-position)
2373 (- (line-end-position) 1))) "") "\\"))
2374
2375(defun python-info-continuation-line-p ()
2376 "Return non-nil if current line is continuation of another."
85655287
FEG		 2377 (let ((current-ppss-context-type (python-info-ppss-context-type)))
2378 (and
2379 (equal (save-excursion
2380 (goto-char (line-end-position))
2381 (forward-comment 9999)
2382 (python-info-ppss-context-type))
2383 current-ppss-context-type)
2384 (or (python-info-line-ends-backslash-p)
2385 (string-match ",[[:space:]]*$" (buffer-substring
2386 (line-beginning-position)
2387 (line-end-position)))
2388 (save-excursion
2389 (let ((innermost-paren (progn
2390 (goto-char (line-end-position))
2391 (python-info-ppss-context 'paren))))
2392 (when (and innermost-paren
2393 (and (<= (line-beginning-position) innermost-paren)
2394 (>= (line-end-position) innermost-paren)))
2395 (goto-char innermost-paren)
2396 (looking-at (python-rx open-paren (* space) line-end)))))
2397 (save-excursion
2398 (back-to-indentation)
2399 (python-info-ppss-context 'paren))))))
45c138ac
FEG		 2400
2401(defun python-info-block-continuation-line-p ()
2402 "Return non-nil if current line is a continuation of a block."
2403 (save-excursion
2404 (while (and (not (bobp))
2405 (python-info-continuation-line-p))
2406 (forward-line -1))
2407 (forward-line 1)
2408 (back-to-indentation)
2409 (when (looking-at (python-rx block-start))
2410 (point-marker))))
2411
2412(defun python-info-assignment-continuation-line-p ()
2413 "Return non-nil if current line is a continuation of an assignment."
2414 (save-excursion
2415 (while (and (not (bobp))
2416 (python-info-continuation-line-p))
2417 (forward-line -1))
2418 (forward-line 1)
2419 (back-to-indentation)
2420 (when (and (not (looking-at (python-rx block-start)))
2421 (save-excursion
2422 (and (re-search-forward (python-rx not-simple-operator
2423 assignment-operator
2424 not-simple-operator)
2425 (line-end-position) t)
14a78495 2426 (not (or (python-info-ppss-context 'string)
9f1537ef 2427 (python-info-ppss-context 'paren)
14a78495 2428 (python-info-ppss-context 'comment))))))
45c138ac
FEG		 2429 (point-marker))))
2430
14a78495
FEG		 2431(defun python-info-ppss-context (type &optional syntax-ppss)
2432 "Return non-nil if point is on TYPE using SYNTAX-PPSS.
85655287 2433TYPE can be 'comment, 'string or 'paren. It returns the start
14a78495
FEG		 2434character address of the specified TYPE."
2435 (let ((ppss (or syntax-ppss (syntax-ppss))))
2436 (case type
2437 ('comment
2438 (and (nth 4 ppss)
2439 (nth 8 ppss)))
2440 ('string
2441 (nth 8 ppss))
2442 ('paren
2443 (nth 1 ppss))
2444 (t nil))))
2445
85655287
FEG		 2446(defun python-info-ppss-context-type (&optional syntax-ppss)
2447 "Return the context type using SYNTAX-PPSS.
2448The type returned can be 'comment, 'string or 'paren."
2449 (let ((ppss (or syntax-ppss (syntax-ppss))))
2450 (cond
2451 ((and (nth 4 ppss)
2452 (nth 8 ppss))
2453 'comment)
2454 ((nth 8 ppss)
2455 'string)
2456 ((nth 1 ppss)
2457 'paren)
2458 (t nil))))
2459
45c138ac 2460\f
c942de99
FEG		 2461;;; Utility functions
2462
2463;; Stolen from GNUS
2464(defun python-util-merge (type list1 list2 pred)
4cafacb5
FEG		 2465 "Destructively merge lists to produce a new one.
2466Argument TYPE is for compatibility and ignored. LIST1 and LIST2
2467are the list to be merged. Ordering of the elements is preserved
2468according to PRED, a `less-than' predicate on the elements."
c942de99
FEG		 2469 (let ((res nil))
2470 (while (and list1 list2)
2471 (if (funcall pred (car list2) (car list1))
2472 (push (pop list2) res)
2473 (push (pop list1) res)))
2474 (nconc (nreverse res) list1 list2)))
2475
2476(defun python-util-position (item seq)
2477 "Find the first occurrence of ITEM in SEQ.
2478Return the index of the matching item, or nil if not found."
2479 (let ((member-result (member item seq)))
2480 (when member-result
2481 (- (length seq) (length member-result)))))
2482
2483\f
45c138ac
FEG		 2484;;;###autoload
2485(define-derived-mode python-mode fundamental-mode "Python"
e2d8d479
FEG		 2486 "Major mode for editing Python files.
2487
2488\\{python-mode-map}
2489Entry to this mode calls the value of `python-mode-hook'
2490if that value is non-nil."
45c138ac
FEG		 2491 (set (make-local-variable 'tab-width) 8)
2492 (set (make-local-variable 'indent-tabs-mode) nil)
2493
2494 (set (make-local-variable 'comment-start) "# ")
2495 (set (make-local-variable 'comment-start-skip) "#+\\s-*")
2496
2497 (set (make-local-variable 'parse-sexp-lookup-properties) t)
2498 (set (make-local-variable 'parse-sexp-ignore-comments) t)
2499
2500 (set (make-local-variable 'font-lock-defaults)
2501 '(python-font-lock-keywords
2502 nil nil nil nil
2503 (font-lock-syntactic-keywords . python-font-lock-syntactic-keywords)))
2504
2505 (set (make-local-variable 'indent-line-function) #'python-indent-line-function)
2506 (set (make-local-variable 'indent-region-function) #'python-indent-region)
2507
2508 (set (make-local-variable 'paragraph-start) "\\s-*$")
2509 (set (make-local-variable 'fill-paragraph-function) 'python-fill-paragraph-function)
2510
2511 (set (make-local-variable 'beginning-of-defun-function)
2512 #'python-beginning-of-defun-function)
2513 (set (make-local-variable 'end-of-defun-function)
2514 #'python-end-of-defun-function)
2515
2516 (add-hook 'completion-at-point-functions
2517 'python-completion-complete-at-point nil 'local)
2518
fc2dc7df
FEG		 2519 (setq imenu-create-index-function #'python-imenu-create-index)
2520
45c138ac
FEG		 2521 (set (make-local-variable 'add-log-current-defun-function)
2522 #'python-info-current-defun)
2523
e2803784
FEG		 2524 (set (make-local-variable 'skeleton-further-elements)
2525 '((abbrev-mode nil)
2526 (< '(backward-delete-char-untabify (min python-indent-offset
2527 (current-column))))
2528 (^ '(- (1+ (current-indentation))))))
2529
45c138ac
FEG		 2530 (set (make-local-variable 'eldoc-documentation-function)
2531 #'python-eldoc-function)
2532
2533 (add-to-list 'hs-special-modes-alist
2534 `(python-mode "^\\s-*\\(?:def\\|class\\)\\>" nil "#"
2535 ,(lambda (arg)
2536 (python-end-of-defun-function)) nil))
2537
82c2b0de
FEG		 2538 (set (make-local-variable 'mode-require-final-newline) t)
2539
45c138ac
FEG		 2540 (set (make-local-variable 'outline-regexp)
2541 (python-rx (* space) block-start))
2542 (set (make-local-variable 'outline-heading-end-regexp) ":\\s-*\n")
2543 (set (make-local-variable 'outline-level)
2544 #'(lambda ()
2545 "`outline-level' function for Python mode."
2546 (1+ (/ (current-indentation) python-indent-offset))))
2547
e2803784
FEG		 2548 (python-skeleton-add-menu-items)
2549
45c138ac
FEG		 2550 (when python-indent-guess-indent-offset
2551 (python-indent-guess-indent-offset)))
2552
2553
2554(provide 'python)
2555;;; python.el ends here
Unnamed repository; edit this file 'description' to name the repository.