blob: 5d9af67cf43add7616e1239e6673e157fc9921c4 [file] [log] [blame]
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001;;; python-mode.el --- Major mode for editing Python programs
2
3;; Copyright (C) 1992,1993,1994 Tim Peters
4
Barry Warsawb2d5e622002-04-22 15:29:27 +00005;; Author: 1995-2002 Barry A. Warsaw
Barry Warsawfec75d61995-07-05 23:26:15 +00006;; 1992-1994 Tim Peters
Barry Warsawa97a3f31997-11-04 18:47:06 +00007;; Maintainer: python-mode@python.org
8;; Created: Feb 1992
9;; Keywords: python languages oop
Barry Warsaw7b0f5681995-03-08 21:33:04 +000010
Barry Warsaw19b1c612001-07-06 20:27:29 +000011(defconst py-version "$Revision$"
Barry Warsawc72c11c1997-08-09 06:42:08 +000012 "`python-mode' version number.")
13
Barry Warsawcfec3591995-03-10 15:58:16 +000014;; This software is provided as-is, without express or implied
15;; warranty. Permission to use, copy, modify, distribute or sell this
16;; software, without fee, for any purpose and by any individual or
17;; organization, is hereby granted, provided that the above copyright
18;; notice and this paragraph appear in all copies.
Barry Warsaw7b0f5681995-03-08 21:33:04 +000019
20;;; Commentary:
Barry Warsaw755c6711996-08-01 20:02:55 +000021
Barry Warsaw7b0f5681995-03-08 21:33:04 +000022;; This is a major mode for editing Python programs. It was developed
Barry Warsaw261f87d1996-08-20 19:57:34 +000023;; by Tim Peters after an original idea by Michael A. Guravage. Tim
Barry Warsawf7039e21998-08-20 22:10:46 +000024;; subsequently left the net; in 1995, Barry Warsaw inherited the mode
Barry Warsaw38e21e71998-10-27 22:09:25 +000025;; and is the current maintainer. Tim's now back but disavows all
26;; responsibility for the mode. Smart Tim :-)
Barry Warsaw7b0f5681995-03-08 21:33:04 +000027
Barry Warsaw4f577d22001-04-11 20:23:17 +000028;; pdbtrack support contributed by Ken Manheimer, April 2001.
29
Barry Warsawb2d5e622002-04-22 15:29:27 +000030;; Please use the SourceForge Python project to submit bugs or
31;; patches:
Barry Warsaw4f577d22001-04-11 20:23:17 +000032;;
33;; http://sourceforge.net/projects/python
Barry Warsaw37231521997-12-11 17:23:13 +000034
35;; FOR MORE INFORMATION:
36
Barry Warsaw4f577d22001-04-11 20:23:17 +000037;; There is some information on python-mode.el at
38
Barry Warsawf7039e21998-08-20 22:10:46 +000039;; http://www.python.org/emacs/python-mode/
40;;
Barry Warsawb2d5e622002-04-22 15:29:27 +000041;; It does contain links to other packages that you might find useful,
42;; such as pdb interfaces, OO-Browser links, etc.
Barry Warsaw37231521997-12-11 17:23:13 +000043
44;; BUG REPORTING:
Barry Warsaw7ae77681994-12-12 20:38:05 +000045
Barry Warsaw4f577d22001-04-11 20:23:17 +000046;; As mentioned above, please use the SourceForge Python project for
47;; submitting bug reports or patches. The old recommendation, to use
48;; C-c C-b will still work, but those reports have a higher chance of
49;; getting buried in my mailbox. Please include a complete, but
Barry Warsawaffc0ca1997-11-03 16:59:38 +000050;; concise code sample and a recipe for reproducing the bug. Send
51;; suggestions and other comments to python-mode@python.org.
52
53;; When in a Python mode buffer, do a C-h m for more help. It's
Barry Warsaw37231521997-12-11 17:23:13 +000054;; doubtful that a texinfo manual would be very useful, but if you
55;; want to contribute one, I'll certainly accept it!
Barry Warsawb5e0ecb1995-03-14 18:32:54 +000056
Barry Warsaw7b0f5681995-03-08 21:33:04 +000057;;; Code:
58
Barry Warsaw6dfbe5d1998-08-20 21:51:27 +000059(require 'comint)
Barry Warsawc72c11c1997-08-09 06:42:08 +000060(require 'custom)
Barry Warsaw4f577d22001-04-11 20:23:17 +000061(require 'cl)
Barry Warsaw1f4fed62002-07-17 13:45:00 +000062(require 'compile)
Barry Warsawc72c11c1997-08-09 06:42:08 +000063
Barry Warsaw7b0f5681995-03-08 21:33:04 +000064
65;; user definable variables
66;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
Barry Warsaw7ae77681994-12-12 20:38:05 +000067
Barry Warsawc72c11c1997-08-09 06:42:08 +000068(defgroup python nil
69 "Support for the Python programming language, <http://www.python.org/>"
Barry Warsaw5ed843f1999-07-28 22:06:06 +000070 :group 'languages
71 :prefix "py-")
Barry Warsaw7ae77681994-12-12 20:38:05 +000072
Barry Warsawc72c11c1997-08-09 06:42:08 +000073(defcustom py-python-command "python"
74 "*Shell command used to start Python interpreter."
75 :type 'string
76 :group 'python)
77
Barry Warsawa2398801998-04-09 23:28:20 +000078(defcustom py-jpython-command "jpython"
79 "*Shell command used to start the JPython interpreter."
80 :type 'string
Barry Warsaw5ed843f1999-07-28 22:06:06 +000081 :group 'python
82 :tag "JPython Command")
Barry Warsawa2398801998-04-09 23:28:20 +000083
Barry Warsawaa384fd1999-02-16 23:36:16 +000084(defcustom py-default-interpreter 'cpython
85 "*Which Python interpreter is used by default.
86The value for this variable can be either `cpython' or `jpython'.
87
88When the value is `cpython', the variables `py-python-command' and
89`py-python-command-args' are consulted to determine the interpreter
90and arguments to use.
91
92When the value is `jpython', the variables `py-jpython-command' and
93`py-jpython-command-args' are consulted to determine the interpreter
94and arguments to use.
95
Barry Warsaw11f21561999-07-28 21:59:43 +000096Note that this variable is consulted only the first time that a Python
97mode buffer is visited during an Emacs session. After that, use
Barry Warsawaa384fd1999-02-16 23:36:16 +000098\\[py-toggle-shells] to change the interpreter shell."
99 :type '(choice (const :tag "Python (a.k.a. CPython)" cpython)
100 (const :tag "JPython" jpython))
101 :group 'python)
102
Barry Warsaw8f972b71998-02-05 20:45:49 +0000103(defcustom py-python-command-args '("-i")
104 "*List of string arguments to be used when starting a Python shell."
105 :type '(repeat string)
106 :group 'python)
107
Barry Warsawa2398801998-04-09 23:28:20 +0000108(defcustom py-jpython-command-args '("-i")
109 "*List of string arguments to be used when starting a JPython shell."
110 :type '(repeat string)
Barry Warsaw5ed843f1999-07-28 22:06:06 +0000111 :group 'python
112 :tag "JPython Command Args")
Barry Warsawa2398801998-04-09 23:28:20 +0000113
Barry Warsawc72c11c1997-08-09 06:42:08 +0000114(defcustom py-indent-offset 4
Barry Warsaw41a05c71998-08-10 16:33:12 +0000115 "*Amount of offset per level of indentation.
116`\\[py-guess-indent-offset]' can usually guess a good value when
117you're editing someone else's Python code."
Barry Warsawc72c11c1997-08-09 06:42:08 +0000118 :type 'integer
119 :group 'python)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000120
Barry Warsawfd4c9e82001-06-18 23:40:35 +0000121(defcustom py-continuation-offset 4
Barry Warsaw40fb4522001-07-06 20:07:13 +0000122 "*Additional amount of offset to give for some continuation lines.
Barry Warsawfd4c9e82001-06-18 23:40:35 +0000123Continuation lines are those that immediately follow a backslash
Barry Warsaw40fb4522001-07-06 20:07:13 +0000124terminated line. Only those continuation lines for a block opening
125statement are given this extra offset."
Barry Warsawfd4c9e82001-06-18 23:40:35 +0000126 :type 'integer
127 :group 'python)
128
Barry Warsaw742a5111998-03-13 17:29:15 +0000129(defcustom py-smart-indentation t
130 "*Should `python-mode' try to automagically set some indentation variables?
131When this variable is non-nil, two things happen when a buffer is set
132to `python-mode':
133
Barry Warsawc0d2d511999-06-03 22:18:59 +0000134 1. `py-indent-offset' is guessed from existing code in the buffer.
Barry Warsaw639eea61998-03-16 18:12:13 +0000135 Only guessed values between 2 and 8 are considered. If a valid
Barry Warsaw742a5111998-03-13 17:29:15 +0000136 guess can't be made (perhaps because you are visiting a new
Barry Warsaw639eea61998-03-16 18:12:13 +0000137 file), then the value in `py-indent-offset' is used.
Barry Warsaw742a5111998-03-13 17:29:15 +0000138
Barry Warsaw639eea61998-03-16 18:12:13 +0000139 2. `indent-tabs-mode' is turned off if `py-indent-offset' does not
140 equal `tab-width' (`indent-tabs-mode' is never turned on by
141 Python mode). This means that for newly written code, tabs are
142 only inserted in indentation if one tab is one indentation
143 level, otherwise only spaces are used.
Barry Warsaw742a5111998-03-13 17:29:15 +0000144
Barry Warsaw8046bef1998-03-13 20:04:52 +0000145Note that both these settings occur *after* `python-mode-hook' is run,
146so if you want to defeat the automagic configuration, you must also
147set `py-smart-indentation' to nil in your `python-mode-hook'."
Barry Warsaw742a5111998-03-13 17:29:15 +0000148 :type 'boolean
149 :group 'python)
150
Barry Warsawc72c11c1997-08-09 06:42:08 +0000151(defcustom py-align-multiline-strings-p t
152 "*Flag describing how multi-line triple quoted strings are aligned.
Barry Warsaw095e9c61995-09-19 20:01:42 +0000153When this flag is non-nil, continuation lines are lined up under the
154preceding line's indentation. When this flag is nil, continuation
Barry Warsawc72c11c1997-08-09 06:42:08 +0000155lines are aligned to column zero."
156 :type '(choice (const :tag "Align under preceding line" t)
157 (const :tag "Align to column zero" nil))
158 :group 'python)
Barry Warsaw095e9c61995-09-19 20:01:42 +0000159
Barry Warsaw218eb751998-09-22 19:51:47 +0000160(defcustom py-block-comment-prefix "##"
Barry Warsaw867a32a1996-03-07 18:30:26 +0000161 "*String used by \\[comment-region] to comment out a block of code.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000162This should follow the convention for non-indenting comment lines so
163that the indentation commands won't get confused (i.e., the string
164should be of the form `#x...' where `x' is not a blank or a tab, and
Barry Warsaw218eb751998-09-22 19:51:47 +0000165`...' is arbitrary). However, this string should not end in whitespace."
Barry Warsawc72c11c1997-08-09 06:42:08 +0000166 :type 'string
167 :group 'python)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000168
Barry Warsawc72c11c1997-08-09 06:42:08 +0000169(defcustom py-honor-comment-indentation t
Barry Warsaw6d627751996-03-06 18:41:38 +0000170 "*Controls how comment lines influence subsequent indentation.
Barry Warsaw33d6ec01996-03-05 16:28:07 +0000171
Barry Warsaw6d627751996-03-06 18:41:38 +0000172When nil, all comment lines are skipped for indentation purposes, and
Barry Warsawc72c11c1997-08-09 06:42:08 +0000173if possible, a faster algorithm is used (i.e. X/Emacs 19 and beyond).
Barry Warsaw6d627751996-03-06 18:41:38 +0000174
175When t, lines that begin with a single `#' are a hint to subsequent
176line indentation. If the previous line is such a comment line (as
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000177opposed to one that starts with `py-block-comment-prefix'), then its
Barry Warsaw6d627751996-03-06 18:41:38 +0000178indentation is used as a hint for this line's indentation. Lines that
179begin with `py-block-comment-prefix' are ignored for indentation
180purposes.
181
Barry Warsawd36cfe42002-03-15 16:46:46 +0000182When not nil or t, comment lines that begin with a single `#' are used
183as indentation hints, unless the comment character is in column zero."
Barry Warsawc72c11c1997-08-09 06:42:08 +0000184 :type '(choice
185 (const :tag "Skip all comment lines (fast)" nil)
186 (const :tag "Single # `sets' indentation for next line" t)
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000187 (const :tag "Single # `sets' indentation except at column zero"
188 other)
Barry Warsawc72c11c1997-08-09 06:42:08 +0000189 )
190 :group 'python)
Barry Warsaw33d6ec01996-03-05 16:28:07 +0000191
Barry Warsaw516b6201997-08-09 06:43:20 +0000192(defcustom py-temp-directory
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000193 (let ((ok '(lambda (x)
194 (and x
195 (setq x (expand-file-name x)) ; always true
196 (file-directory-p x)
197 (file-writable-p x)
198 x))))
Barry Warsaw7ae77681994-12-12 20:38:05 +0000199 (or (funcall ok (getenv "TMPDIR"))
200 (funcall ok "/usr/tmp")
201 (funcall ok "/tmp")
Barry Warsawd1648372002-03-18 18:53:56 +0000202 (funcall ok "/var/tmp")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000203 (funcall ok ".")
204 (error
Barry Warsaw6c6db0a1998-02-25 16:33:56 +0000205 "Couldn't find a usable temp directory -- set `py-temp-directory'")))
Barry Warsawd1648372002-03-18 18:53:56 +0000206 "*Directory used for temporary files created by a *Python* process.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000207By default, the first directory from this list that exists and that you
Barry Warsawd1648372002-03-18 18:53:56 +0000208can write into: the value (if any) of the environment variable TMPDIR,
209/usr/tmp, /tmp, /var/tmp, or the current directory."
Barry Warsawc72c11c1997-08-09 06:42:08 +0000210 :type 'string
211 :group 'python)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000212
Barry Warsaw516b6201997-08-09 06:43:20 +0000213(defcustom py-beep-if-tab-change t
Barry Warsaw41a05c71998-08-10 16:33:12 +0000214 "*Ring the bell if `tab-width' is changed.
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000215If a comment of the form
216
217 \t# vi:set tabsize=<number>:
218
219is found before the first code line when the file is entered, and the
220current value of (the general Emacs variable) `tab-width' does not
221equal <number>, `tab-width' is set to <number>, a message saying so is
222displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
Barry Warsawc72c11c1997-08-09 06:42:08 +0000223the Emacs bell is also rung as a warning."
224 :type 'boolean
225 :group 'python)
226
Barry Warsaw9981d221997-12-03 05:25:48 +0000227(defcustom py-jump-on-exception t
228 "*Jump to innermost exception frame in *Python Output* buffer.
Barry Warsaw12c92941998-08-10 21:44:37 +0000229When this variable is non-nil and an exception occurs when running
Barry Warsaw9981d221997-12-03 05:25:48 +0000230Python code synchronously in a subprocess, jump immediately to the
Barry Warsaw12c92941998-08-10 21:44:37 +0000231source code of the innermost traceback frame."
Barry Warsaw3bfed5b1998-05-19 16:25:04 +0000232 :type 'boolean
233 :group 'python)
234
235(defcustom py-ask-about-save t
236 "If not nil, ask about which buffers to save before executing some code.
237Otherwise, all modified buffers are saved without asking."
238 :type 'boolean
239 :group 'python)
Barry Warsaw9981d221997-12-03 05:25:48 +0000240
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000241(defcustom py-backspace-function 'backward-delete-char-untabify
242 "*Function called by `py-electric-backspace' when deleting backwards."
243 :type 'function
244 :group 'python)
245
246(defcustom py-delete-function 'delete-char
247 "*Function called by `py-electric-delete' when deleting forwards."
248 :type 'function
249 :group 'python)
250
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000251(defcustom py-imenu-show-method-args-p nil
252 "*Controls echoing of arguments of functions & methods in the Imenu buffer.
253When non-nil, arguments are printed."
254 :type 'boolean
255 :group 'python)
256(make-variable-buffer-local 'py-indent-offset)
257
Barry Warsaw4f577d22001-04-11 20:23:17 +0000258(defcustom py-pdbtrack-do-tracking-p t
259 "*Controls whether the pdbtrack feature is enabled or not.
260When non-nil, pdbtrack is enabled in all comint-based buffers,
261e.g. shell buffers and the *Python* buffer. When using pdb to debug a
262Python program, pdbtrack notices the pdb prompt and displays the
263source file and line that the program is stopped at, much the same way
264as gud-mode does for debugging C programs with gdb."
265 :type 'boolean
266 :group 'python)
267(make-variable-buffer-local 'py-pdbtrack-do-tracking-p)
268
269(defcustom py-pdbtrack-minor-mode-string " PDB"
270 "*String to use in the minor mode list when pdbtrack is enabled."
271 :type 'string
272 :group 'python)
273
Barry Warsaw88491612002-04-25 21:31:47 +0000274(defcustom py-import-check-point-max
275 20000
276 "Maximum number of characters to search for a Java-ish import statement.
277When `python-mode' tries to calculate the shell to use (either a
278CPython or a JPython shell), it looks at the so-called `shebang' line
279-- i.e. #! line. If that's not available, it looks at some of the
280file heading imports to see if they look Java-like."
281 :type 'integer
282 :group 'python
283 )
284
285(defcustom py-jpython-packages
286 '("java" "javax" "org" "com")
287 "Imported packages that imply `jpython-mode'."
288 :type '(repeat string)
289 :group 'python)
290
Barry Warsawc0ecb531998-01-20 21:43:34 +0000291;; Not customizable
292(defvar py-master-file nil
293 "If non-nil, execute the named file instead of the buffer's file.
Barry Warsaw50b3eb61998-02-25 15:57:47 +0000294The intent is to allow you to set this variable in the file's local
Barry Warsawc0ecb531998-01-20 21:43:34 +0000295variable section, e.g.:
296
297 # Local Variables:
298 # py-master-file: \"master.py\"
299 # End:
300
Barry Warsaw41a05c71998-08-10 16:33:12 +0000301so that typing \\[py-execute-buffer] in that buffer executes the named
Barry Warsaw1bbc0311998-10-27 21:54:56 +0000302master file instead of the buffer's file. If the file name has a
303relative path, the value of variable `default-directory' for the
304buffer is prepended to come up with a file name.")
Barry Warsawc0ecb531998-01-20 21:43:34 +0000305(make-variable-buffer-local 'py-master-file)
306
Barry Warsaw29a90f02002-04-22 21:48:20 +0000307(defcustom py-pychecker-command "pychecker"
308 "*Shell command used to run Pychecker."
309 :type 'string
310 :group 'python
311 :tag "Pychecker Command")
312
313(defcustom py-pychecker-command-args '("--stdlib")
314 "*List of string arguments to be passed to pychecker."
315 :type '(repeat string)
316 :group 'python
317 :tag "Pychecker Command Args")
318
Barry Warsaw88491612002-04-25 21:31:47 +0000319(defvar py-shell-alist
320 '(("jpython" . 'jpython)
321 ("jython" . 'jpython)
322 ("python" . 'cpython))
323 "*Alist of interpreters and python shells. Used by `py-choose-shell'
324to select the appropriate python interpreter mode for a file.")
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000325
Barry Warsawc72c11c1997-08-09 06:42:08 +0000326
327;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
328;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
329
Barry Warsaw5e21cb01997-11-05 18:41:11 +0000330(defconst py-emacs-features
331 (let (features)
Barry Warsaw5e21cb01997-11-05 18:41:11 +0000332 features)
Barry Warsawc12c62e1997-09-04 04:18:07 +0000333 "A list of features extant in the Emacs you are using.
Barry Warsaw6ae21ad1997-11-06 14:36:49 +0000334There are many flavors of Emacs out there, with different levels of
335support for features needed by `python-mode'.")
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000336
Barry Warsaw29a90f02002-04-22 21:48:20 +0000337;; Face for None, True, False, self, and Ellipsis
338(defvar py-pseudo-keyword-face 'py-pseudo-keyword-face
339 "Face for pseudo keywords in Python mode, like self, True, False, Ellipsis.")
340(make-face 'py-pseudo-keyword-face)
341
342(defun py-font-lock-mode-hook ()
343 (or (face-differs-from-default-p 'py-pseudo-keyword-face)
344 (copy-face 'font-lock-keyword-face 'py-pseudo-keyword-face)))
345(add-hook 'font-lock-mode-hook 'py-font-lock-mode-hook)
346
Barry Warsawfb07f401997-02-24 03:37:22 +0000347(defvar python-font-lock-keywords
Barry Warsawb8f11661997-11-06 14:35:15 +0000348 (let ((kw1 (mapconcat 'identity
349 '("and" "assert" "break" "class"
350 "continue" "def" "del" "elif"
351 "else" "except" "exec" "for"
352 "from" "global" "if" "import"
353 "in" "is" "lambda" "not"
354 "or" "pass" "print" "raise"
Barry Warsawe275c422001-06-19 18:24:42 +0000355 "return" "while" "yield"
Barry Warsawb8f11661997-11-06 14:35:15 +0000356 )
357 "\\|"))
358 (kw2 (mapconcat 'identity
359 '("else:" "except:" "finally:" "try:")
360 "\\|"))
Skip Montanaro302e5502003-12-18 21:53:33 +0000361 (kw3 (mapconcat 'identity
362 '("ArithmeticError" "AssertionError"
363 "AttributeError" "DeprecationWarning" "EOFError"
364 "Ellipsis" "EnvironmentError" "Exception" "False"
365 "FloatingPointError" "FutureWarning" "IOError"
366 "ImportError" "IndentationError" "IndexError"
367 "KeyError" "KeyboardInterrupt" "LookupError"
368 "MemoryError" "NameError" "None" "NotImplemented"
369 "NotImplementedError" "OSError" "OverflowError"
370 "OverflowWarning" "PendingDeprecationWarning"
371 "ReferenceError" "RuntimeError" "RuntimeWarning"
Guido van Rossumcd16bf62007-06-13 18:07:49 +0000372 "StopIteration" "SyntaxError"
Skip Montanaro302e5502003-12-18 21:53:33 +0000373 "SyntaxWarning" "SystemError" "SystemExit"
374 "TabError" "True" "TypeError" "UnboundLocalError"
375 "UnicodeDecodeError" "UnicodeEncodeError"
376 "UnicodeError" "UnicodeTranslateError"
377 "UserWarning" "ValueError" "Warning"
378 "ZeroDivisionError" "__debug__"
379 "__import__" "__name__" "abs" "apply" "basestring"
380 "bool" "buffer" "callable" "chr" "classmethod"
Neal Norwitzce96f692006-03-17 06:49:51 +0000381 "cmp" "compile" "complex" "copyright"
Skip Montanaro302e5502003-12-18 21:53:33 +0000382 "delattr" "dict" "dir" "divmod"
Neal Norwitz01688022007-08-12 00:43:29 +0000383 "enumerate" "eval" "exit" "file"
Skip Montanaro302e5502003-12-18 21:53:33 +0000384 "filter" "float" "getattr" "globals" "hasattr"
Georg Brandl66a796e2006-12-19 20:50:34 +0000385 "hash" "hex" "id" "int"
Skip Montanaro302e5502003-12-18 21:53:33 +0000386 "isinstance" "issubclass" "iter" "len" "license"
387 "list" "locals" "long" "map" "max" "min" "object"
388 "oct" "open" "ord" "pow" "property" "range"
Guido van Rossum0919a1a2006-08-26 20:49:04 +0000389 "reload" "repr" "round"
Skip Montanaro302e5502003-12-18 21:53:33 +0000390 "setattr" "slice" "staticmethod" "str" "sum"
391 "super" "tuple" "type" "unichr" "unicode" "vars"
Neal Norwitzce96f692006-03-17 06:49:51 +0000392 "zip")
Skip Montanaro302e5502003-12-18 21:53:33 +0000393 "\\|"))
Barry Warsawb8f11661997-11-06 14:35:15 +0000394 )
Barry Warsaw33ab6e41996-03-05 00:44:31 +0000395 (list
Barry Warsawef3c8911997-11-05 18:55:50 +0000396 ;; keywords
Barry Warsawb8f11661997-11-06 14:35:15 +0000397 (cons (concat "\\b\\(" kw1 "\\)\\b[ \n\t(]") 1)
Skip Montanaro302e5502003-12-18 21:53:33 +0000398 ;; builtins when they don't appear as object attributes
399 (cons (concat "\\(\\b\\|[.]\\)\\(" kw3 "\\)\\b[ \n\t(]") 2)
Barry Warsawb8f11661997-11-06 14:35:15 +0000400 ;; block introducing keywords with immediately following colons.
401 ;; Yes "except" is in both lists.
402 (cons (concat "\\b\\(" kw2 "\\)[ \n\t(]") 1)
Barry Warsawe0c182f2000-12-27 17:41:47 +0000403 ;; `as' but only in "import foo as bar"
404 '("[ \t]*\\(\\bfrom\\b.*\\)?\\bimport\\b.*\\b\\(as\\)\\b" . 2)
Barry Warsaw33ab6e41996-03-05 00:44:31 +0000405 ;; classes
406 '("\\bclass[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"
407 1 font-lock-type-face)
408 ;; functions
409 '("\\bdef[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"
410 1 font-lock-function-name-face)
Barry Warsaw29a90f02002-04-22 21:48:20 +0000411 ;; pseudo-keywords
412 '("\\b\\(self\\|None\\|True\\|False\\|Ellipsis\\)\\b"
413 1 py-pseudo-keyword-face)
Barry Warsaw33ab6e41996-03-05 00:44:31 +0000414 ))
Barry Warsaw62d9d6e1996-03-06 20:32:27 +0000415 "Additional expressions to highlight in Python mode.")
Barry Warsawfb07f401997-02-24 03:37:22 +0000416(put 'python-mode 'font-lock-defaults '(python-font-lock-keywords))
417
Barry Warsawe467bfb1997-11-26 05:40:58 +0000418;; have to bind py-file-queue before installing the kill-emacs-hook
Barry Warsaw7ae77681994-12-12 20:38:05 +0000419(defvar py-file-queue nil
420 "Queue of Python temp files awaiting execution.
421Currently-active file is at the head of the list.")
422
Barry Warsaw4f577d22001-04-11 20:23:17 +0000423(defvar py-pdbtrack-is-tracking-p nil)
Ken Manheimered6000a2003-03-03 17:09:44 +0000424(defvar py-pdbtrack-last-grubbed-buffer nil
425 "Record of the last buffer used when the source path was invalid.
426
427This buffer is consulted before the buffer-list history for satisfying
428`py-pdbtrack-grub-for-buffer', since it's the most often the likely
429prospect as debugging continues.")
430(make-variable-buffer-local 'py-pdbtrack-last-grubbed-buffer)
Barry Warsaw29a90f02002-04-22 21:48:20 +0000431(defvar py-pychecker-history nil)
Barry Warsaw4f577d22001-04-11 20:23:17 +0000432
433
Barry Warsawc72c11c1997-08-09 06:42:08 +0000434
435;; Constants
436
Barry Warsawc72c11c1997-08-09 06:42:08 +0000437(defconst py-stringlit-re
438 (concat
Barry Warsaw751f4931998-05-19 16:06:21 +0000439 ;; These fail if backslash-quote ends the string (not worth
440 ;; fixing?). They precede the short versions so that the first two
441 ;; quotes don't look like an empty short string.
442 ;;
443 ;; (maybe raw), long single quoted triple quoted strings (SQTQ),
444 ;; with potential embedded single quotes
445 "[rR]?'''[^']*\\(\\('[^']\\|''[^']\\)[^']*\\)*'''"
446 "\\|"
447 ;; (maybe raw), long double quoted triple quoted strings (DQTQ),
448 ;; with potential embedded double quotes
449 "[rR]?\"\"\"[^\"]*\\(\\(\"[^\"]\\|\"\"[^\"]\\)[^\"]*\\)*\"\"\""
450 "\\|"
451 "[rR]?'\\([^'\n\\]\\|\\\\.\\)*'" ; single-quoted
Barry Warsawc72c11c1997-08-09 06:42:08 +0000452 "\\|" ; or
Barry Warsaw751f4931998-05-19 16:06:21 +0000453 "[rR]?\"\\([^\"\n\\]\\|\\\\.\\)*\"" ; double-quoted
Barry Warsaw41a05c71998-08-10 16:33:12 +0000454 )
455 "Regular expression matching a Python string literal.")
Barry Warsaw751f4931998-05-19 16:06:21 +0000456
Barry Warsawc72c11c1997-08-09 06:42:08 +0000457(defconst py-continued-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000458 ;; This is tricky because a trailing backslash does not mean
459 ;; continuation if it's in a comment
Barry Warsawc72c11c1997-08-09 06:42:08 +0000460 (concat
461 "\\(" "[^#'\"\n\\]" "\\|" py-stringlit-re "\\)*"
Barry Warsaw41a05c71998-08-10 16:33:12 +0000462 "\\\\$")
463 "Regular expression matching Python backslash continuation lines.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000464
Barry Warsaw41a05c71998-08-10 16:33:12 +0000465(defconst py-blank-or-comment-re "[ \t]*\\($\\|#\\)"
Barry Warsaw71c3adb1998-08-10 16:34:33 +0000466 "Regular expression matching a blank or comment line.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000467
Barry Warsawc72c11c1997-08-09 06:42:08 +0000468(defconst py-outdent-re
469 (concat "\\(" (mapconcat 'identity
470 '("else:"
471 "except\\(\\s +.*\\)?:"
472 "finally:"
473 "elif\\s +.*:")
474 "\\|")
Barry Warsaw41a05c71998-08-10 16:33:12 +0000475 "\\)")
476 "Regular expression matching statements to be dedented one level.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000477
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000478(defconst py-block-closing-keywords-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000479 "\\(return\\|raise\\|break\\|continue\\|pass\\)"
480 "Regular expression matching keywords which typically close a block.")
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000481
Barry Warsawc72c11c1997-08-09 06:42:08 +0000482(defconst py-no-outdent-re
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000483 (concat
484 "\\("
485 (mapconcat 'identity
486 (list "try:"
487 "except\\(\\s +.*\\)?:"
488 "while\\s +.*:"
489 "for\\s +.*:"
490 "if\\s +.*:"
491 "elif\\s +.*:"
492 (concat py-block-closing-keywords-re "[ \t\n]")
493 )
494 "\\|")
Barry Warsaw41a05c71998-08-10 16:33:12 +0000495 "\\)")
496 "Regular expression matching lines not to dedent after.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000497
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000498(defconst py-defun-start-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000499 "^\\([ \t]*\\)def[ \t]+\\([a-zA-Z_0-9]+\\)\\|\\(^[a-zA-Z_0-9]+\\)[ \t]*="
500 ;; If you change this, you probably have to change py-current-defun
501 ;; as well. This is only used by py-current-defun to find the name
502 ;; for add-log.el.
Barry Warsaw71c3adb1998-08-10 16:34:33 +0000503 "Regular expression matching a function, method, or variable assignment.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000504
Barry Warsaw41a05c71998-08-10 16:33:12 +0000505(defconst py-class-start-re "^class[ \t]*\\([a-zA-Z_0-9]+\\)"
506 ;; If you change this, you probably have to change py-current-defun
507 ;; as well. This is only used by py-current-defun to find the name
508 ;; for add-log.el.
509 "Regular expression for finding a class name.")
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000510
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000511(defconst py-traceback-line-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000512 "[ \t]+File \"\\([^\"]+\\)\", line \\([0-9]+\\)"
513 "Regular expression that describes tracebacks.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000514
Barry Warsaw4f577d22001-04-11 20:23:17 +0000515;; pdbtrack contants
516(defconst py-pdbtrack-stack-entry-regexp
Ken Manheimere7aca522003-03-03 00:35:32 +0000517; "^> \\([^(]+\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_]+\\)()"
518 "^> \\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_]+\\)()"
Barry Warsaw4f577d22001-04-11 20:23:17 +0000519 "Regular expression pdbtrack uses to find a stack trace entry.")
520
Ken Manheimer2448f1b2003-05-01 21:07:32 +0000521(defconst py-pdbtrack-input-prompt "\n[(<]*pdb[>)]+ "
Barry Warsaw4f577d22001-04-11 20:23:17 +0000522 "Regular expression pdbtrack uses to recognize a pdb prompt.")
523
524(defconst py-pdbtrack-track-range 10000
525 "Max number of characters from end of buffer to search for stack entry.")
526
Barry Warsawc72c11c1997-08-09 06:42:08 +0000527
528
Barry Warsawc72c11c1997-08-09 06:42:08 +0000529;; Major mode boilerplate
530
Barry Warsaw7ae77681994-12-12 20:38:05 +0000531;; define a mode-specific abbrev table for those who use such things
532(defvar python-mode-abbrev-table nil
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000533 "Abbrev table in use in `python-mode' buffers.")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000534(define-abbrev-table 'python-mode-abbrev-table nil)
535
Barry Warsaw7ae77681994-12-12 20:38:05 +0000536(defvar python-mode-hook nil
537 "*Hook called by `python-mode'.")
538
Barry Warsaw88491612002-04-25 21:31:47 +0000539(defvar jpython-mode-hook nil
540 "*Hook called by `jpython-mode'. `jpython-mode' also calls
541`python-mode-hook'.")
542
Barry Warsaw56bd2ed2002-04-25 15:44:17 +0000543(defvar py-shell-hook nil
544 "*Hook called by `py-shell'.")
545
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000546;; In previous version of python-mode.el, the hook was incorrectly
547;; called py-mode-hook, and was not defvar'd. Deprecate its use.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000548(and (fboundp 'make-obsolete-variable)
549 (make-obsolete-variable 'py-mode-hook 'python-mode-hook))
550
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000551(defvar py-mode-map ()
552 "Keymap used in `python-mode' buffers.")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000553(if py-mode-map
Barry Warsawc72c11c1997-08-09 06:42:08 +0000554 nil
Barry Warsaw7ae77681994-12-12 20:38:05 +0000555 (setq py-mode-map (make-sparse-keymap))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000556 ;; electric keys
557 (define-key py-mode-map ":" 'py-electric-colon)
558 ;; indentation level modifiers
559 (define-key py-mode-map "\C-c\C-l" 'py-shift-region-left)
560 (define-key py-mode-map "\C-c\C-r" 'py-shift-region-right)
561 (define-key py-mode-map "\C-c<" 'py-shift-region-left)
562 (define-key py-mode-map "\C-c>" 'py-shift-region-right)
Skip Montanaro6c5bc342002-12-31 16:56:20 +0000563 ;; paragraph and string filling
564 (define-key py-mode-map "\eq" 'py-fill-paragraph)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000565 ;; subprocess commands
566 (define-key py-mode-map "\C-c\C-c" 'py-execute-buffer)
Barry Warsaw820273d1998-05-19 15:54:45 +0000567 (define-key py-mode-map "\C-c\C-m" 'py-execute-import-or-reload)
Barry Warsaw1d0364b1998-05-19 16:15:26 +0000568 (define-key py-mode-map "\C-c\C-s" 'py-execute-string)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000569 (define-key py-mode-map "\C-c|" 'py-execute-region)
Barry Warsaw820273d1998-05-19 15:54:45 +0000570 (define-key py-mode-map "\e\C-x" 'py-execute-def-or-class)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000571 (define-key py-mode-map "\C-c!" 'py-shell)
Barry Warsawa2398801998-04-09 23:28:20 +0000572 (define-key py-mode-map "\C-c\C-t" 'py-toggle-shells)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000573 ;; Caution! Enter here at your own risk. We are trying to support
574 ;; several behaviors and it gets disgusting. :-( This logic ripped
575 ;; largely from CC Mode.
576 ;;
577 ;; In XEmacs 19, Emacs 19, and Emacs 20, we use this to bind
578 ;; backwards deletion behavior to DEL, which both Delete and
579 ;; Backspace get translated to. There's no way to separate this
580 ;; behavior in a clean way, so deal with it! Besides, it's been
581 ;; this way since the dawn of time.
582 (if (not (boundp 'delete-key-deletes-forward))
583 (define-key py-mode-map "\177" 'py-electric-backspace)
584 ;; However, XEmacs 20 actually achieved enlightenment. It is
585 ;; possible to sanely define both backward and forward deletion
586 ;; behavior under X separately (TTYs are forever beyond hope, but
587 ;; who cares? XEmacs 20 does the right thing with these too).
588 (define-key py-mode-map [delete] 'py-electric-delete)
589 (define-key py-mode-map [backspace] 'py-electric-backspace))
Barry Warsaw8c4a8de1997-11-26 20:30:33 +0000590 ;; Separate M-BS from C-M-h. The former should remain
591 ;; backward-kill-word.
592 (define-key py-mode-map [(control meta h)] 'py-mark-def-or-class)
Barry Warsaw2518c671997-11-05 00:51:08 +0000593 (define-key py-mode-map "\C-c\C-k" 'py-mark-block)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000594 ;; Miscellaneous
595 (define-key py-mode-map "\C-c:" 'py-guess-indent-offset)
596 (define-key py-mode-map "\C-c\t" 'py-indent-region)
Barry Warsaw4f577d22001-04-11 20:23:17 +0000597 (define-key py-mode-map "\C-c\C-d" 'py-pdbtrack-toggle-stack-tracking)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000598 (define-key py-mode-map "\C-c\C-n" 'py-next-statement)
599 (define-key py-mode-map "\C-c\C-p" 'py-previous-statement)
600 (define-key py-mode-map "\C-c\C-u" 'py-goto-block-up)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000601 (define-key py-mode-map "\C-c#" 'py-comment-region)
602 (define-key py-mode-map "\C-c?" 'py-describe-mode)
Barry Warsawa7cc43b2002-04-22 17:15:19 +0000603 (define-key py-mode-map "\C-c\C-h" 'py-help-at-point)
Barry Warsawab0e86c1998-05-19 15:31:46 +0000604 (define-key py-mode-map "\e\C-a" 'py-beginning-of-def-or-class)
605 (define-key py-mode-map "\e\C-e" 'py-end-of-def-or-class)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000606 (define-key py-mode-map "\C-c-" 'py-up-exception)
607 (define-key py-mode-map "\C-c=" 'py-down-exception)
Barry Warsawf8ddb6a1999-01-18 21:49:39 +0000608 ;; stuff that is `standard' but doesn't interface well with
609 ;; python-mode, which forces us to rebind to special commands
610 (define-key py-mode-map "\C-xnd" 'py-narrow-to-defun)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000611 ;; information
612 (define-key py-mode-map "\C-c\C-b" 'py-submit-bug-report)
613 (define-key py-mode-map "\C-c\C-v" 'py-version)
Barry Warsaw29a90f02002-04-22 21:48:20 +0000614 (define-key py-mode-map "\C-c\C-w" 'py-pychecker-run)
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000615 ;; shadow global bindings for newline-and-indent w/ the py- version.
616 ;; BAW - this is extremely bad form, but I'm not going to change it
617 ;; for now.
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000618 (mapcar #'(lambda (key)
619 (define-key py-mode-map key 'py-newline-and-indent))
620 (where-is-internal 'newline-and-indent))
Barry Warsawf19feb81999-01-21 17:06:11 +0000621 ;; Force RET to be py-newline-and-indent even if it didn't get
622 ;; mapped by the above code. motivation: Emacs' default binding for
623 ;; RET is `newline' and C-j is `newline-and-indent'. Most Pythoneers
624 ;; expect RET to do a `py-newline-and-indent' and any Emacsers who
625 ;; dislike this are probably knowledgeable enough to do a rebind.
626 ;; However, we do *not* change C-j since many Emacsers have already
627 ;; swapped RET and C-j and they don't want C-j bound to `newline' to
628 ;; change.
629 (define-key py-mode-map "\C-m" 'py-newline-and-indent)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000630 )
631
632(defvar py-mode-output-map nil
Barry Warsaw41a05c71998-08-10 16:33:12 +0000633 "Keymap used in *Python Output* buffers.")
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000634(if py-mode-output-map
635 nil
636 (setq py-mode-output-map (make-sparse-keymap))
637 (define-key py-mode-output-map [button2] 'py-mouseto-exception)
638 (define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)
639 ;; TBD: Disable all self-inserting keys. This is bogus, we should
640 ;; really implement this as *Python Output* buffer being read-only
641 (mapcar #' (lambda (key)
642 (define-key py-mode-output-map key
643 #'(lambda () (interactive) (beep))))
644 (where-is-internal 'self-insert-command))
Barry Warsaw850437a1995-03-08 21:50:28 +0000645 )
Barry Warsaw7ae77681994-12-12 20:38:05 +0000646
Barry Warsaw6dfbe5d1998-08-20 21:51:27 +0000647(defvar py-shell-map nil
648 "Keymap used in *Python* shell buffers.")
649(if py-shell-map
650 nil
651 (setq py-shell-map (copy-keymap comint-mode-map))
652 (define-key py-shell-map [tab] 'tab-to-tab-stop)
653 (define-key py-shell-map "\C-c-" 'py-up-exception)
654 (define-key py-shell-map "\C-c=" 'py-down-exception)
655 )
656
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000657(defvar py-mode-syntax-table nil
658 "Syntax table used in `python-mode' buffers.")
Barry Warsawa7cc43b2002-04-22 17:15:19 +0000659(when (not py-mode-syntax-table)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000660 (setq py-mode-syntax-table (make-syntax-table))
Barry Warsawc72c11c1997-08-09 06:42:08 +0000661 (modify-syntax-entry ?\( "()" py-mode-syntax-table)
662 (modify-syntax-entry ?\) ")(" py-mode-syntax-table)
663 (modify-syntax-entry ?\[ "(]" py-mode-syntax-table)
664 (modify-syntax-entry ?\] ")[" py-mode-syntax-table)
665 (modify-syntax-entry ?\{ "(}" py-mode-syntax-table)
666 (modify-syntax-entry ?\} "){" py-mode-syntax-table)
667 ;; Add operator symbols misassigned in the std table
668 (modify-syntax-entry ?\$ "." py-mode-syntax-table)
669 (modify-syntax-entry ?\% "." py-mode-syntax-table)
670 (modify-syntax-entry ?\& "." py-mode-syntax-table)
671 (modify-syntax-entry ?\* "." py-mode-syntax-table)
672 (modify-syntax-entry ?\+ "." py-mode-syntax-table)
673 (modify-syntax-entry ?\- "." py-mode-syntax-table)
674 (modify-syntax-entry ?\/ "." py-mode-syntax-table)
675 (modify-syntax-entry ?\< "." py-mode-syntax-table)
676 (modify-syntax-entry ?\= "." py-mode-syntax-table)
677 (modify-syntax-entry ?\> "." py-mode-syntax-table)
678 (modify-syntax-entry ?\| "." py-mode-syntax-table)
679 ;; For historical reasons, underscore is word class instead of
680 ;; symbol class. GNU conventions say it should be symbol class, but
681 ;; there's a natural conflict between what major mode authors want
682 ;; and what users expect from `forward-word' and `backward-word'.
683 ;; Guido and I have hashed this out and have decided to keep
684 ;; underscore in word class. If you're tempted to change it, try
685 ;; binding M-f and M-b to py-forward-into-nomenclature and
Barry Warsawaa384fd1999-02-16 23:36:16 +0000686 ;; py-backward-into-nomenclature instead. This doesn't help in all
687 ;; situations where you'd want the different behavior
688 ;; (e.g. backward-kill-word).
Barry Warsawc72c11c1997-08-09 06:42:08 +0000689 (modify-syntax-entry ?\_ "w" py-mode-syntax-table)
690 ;; Both single quote and double quote are string delimiters
691 (modify-syntax-entry ?\' "\"" py-mode-syntax-table)
692 (modify-syntax-entry ?\" "\"" py-mode-syntax-table)
Barry Warsawc72c11c1997-08-09 06:42:08 +0000693 ;; comment delimiters
694 (modify-syntax-entry ?\# "<" py-mode-syntax-table)
695 (modify-syntax-entry ?\n ">" py-mode-syntax-table)
696 )
Barry Warsaw7ae77681994-12-12 20:38:05 +0000697
Barry Warsawa7cc43b2002-04-22 17:15:19 +0000698;; An auxiliary syntax table which places underscore and dot in the
699;; symbol class for simplicity
700(defvar py-dotted-expression-syntax-table nil
701 "Syntax table used to identify Python dotted expressions.")
702(when (not py-dotted-expression-syntax-table)
703 (setq py-dotted-expression-syntax-table
704 (copy-syntax-table py-mode-syntax-table))
705 (modify-syntax-entry ?_ "_" py-dotted-expression-syntax-table)
706 (modify-syntax-entry ?. "_" py-dotted-expression-syntax-table))
707
Barry Warsawb3e81d51996-09-04 15:12:42 +0000708
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000709
Barry Warsawbc3760b1998-09-14 16:16:18 +0000710;; Utilities
Barry Warsawbc3760b1998-09-14 16:16:18 +0000711(defmacro py-safe (&rest body)
712 "Safely execute BODY, return nil if an error occurred."
713 (` (condition-case nil
714 (progn (,@ body))
715 (error nil))))
716
717(defsubst py-keep-region-active ()
718 "Keep the region active in XEmacs."
719 ;; Ignore byte-compiler warnings you might see. Also note that
720 ;; FSF's Emacs 19 does it differently; its policy doesn't require us
721 ;; to take explicit action.
722 (and (boundp 'zmacs-region-stays)
723 (setq zmacs-region-stays t)))
724
725(defsubst py-point (position)
726 "Returns the value of point at certain commonly referenced POSITIONs.
727POSITION can be one of the following symbols:
728
729 bol -- beginning of line
730 eol -- end of line
731 bod -- beginning of def or class
732 eod -- end of def or class
733 bob -- beginning of buffer
734 eob -- end of buffer
735 boi -- back to indentation
736 bos -- beginning of statement
737
738This function does not modify point or mark."
739 (let ((here (point)))
740 (cond
741 ((eq position 'bol) (beginning-of-line))
742 ((eq position 'eol) (end-of-line))
743 ((eq position 'bod) (py-beginning-of-def-or-class))
744 ((eq position 'eod) (py-end-of-def-or-class))
745 ;; Kind of funny, I know, but useful for py-up-exception.
746 ((eq position 'bob) (beginning-of-buffer))
747 ((eq position 'eob) (end-of-buffer))
748 ((eq position 'boi) (back-to-indentation))
749 ((eq position 'bos) (py-goto-initial-line))
750 (t (error "Unknown buffer position requested: %s" position))
751 )
752 (prog1
753 (point)
754 (goto-char here))))
755
756(defsubst py-highlight-line (from to file line)
757 (cond
758 ((fboundp 'make-extent)
759 ;; XEmacs
760 (let ((e (make-extent from to)))
761 (set-extent-property e 'mouse-face 'highlight)
762 (set-extent-property e 'py-exc-info (cons file line))
763 (set-extent-property e 'keymap py-mode-output-map)))
764 (t
765 ;; Emacs -- Please port this!
766 )
767 ))
768
769(defun py-in-literal (&optional lim)
770 "Return non-nil if point is in a Python literal (a comment or string).
771Optional argument LIM indicates the beginning of the containing form,
772i.e. the limit on how far back to scan."
773 ;; This is the version used for non-XEmacs, which has a nicer
774 ;; interface.
775 ;;
776 ;; WARNING: Watch out for infinite recursion.
777 (let* ((lim (or lim (py-point 'bod)))
778 (state (parse-partial-sexp lim (point))))
779 (cond
780 ((nth 3 state) 'string)
781 ((nth 4 state) 'comment)
782 (t nil))))
783
784;; XEmacs has a built-in function that should make this much quicker.
785;; In this case, lim is ignored
786(defun py-fast-in-literal (&optional lim)
787 "Fast version of `py-in-literal', used only by XEmacs.
788Optional LIM is ignored."
789 ;; don't have to worry about context == 'block-comment
790 (buffer-syntactic-context))
791
792(if (fboundp 'buffer-syntactic-context)
793 (defalias 'py-in-literal 'py-fast-in-literal))
794
795
796
Barry Warsaw42f707f1996-07-29 21:05:05 +0000797;; Menu definitions, only relevent if you have the easymenu.el package
798;; (standard in the latest Emacs 19 and XEmacs 19 distributions).
Barry Warsaw5490a061996-08-06 15:43:33 +0000799(defvar py-menu nil
800 "Menu for Python Mode.
Barry Warsawc72c11c1997-08-09 06:42:08 +0000801This menu will get created automatically if you have the `easymenu'
802package. Note that the latest X/Emacs releases contain this package.")
Barry Warsaw5490a061996-08-06 15:43:33 +0000803
Barry Warsawc72c11c1997-08-09 06:42:08 +0000804(and (py-safe (require 'easymenu) t)
805 (easy-menu-define
806 py-menu py-mode-map "Python Mode menu"
807 '("Python"
808 ["Comment Out Region" py-comment-region (mark)]
809 ["Uncomment Region" (py-comment-region (point) (mark) '(4)) (mark)]
810 "-"
811 ["Mark current block" py-mark-block t]
Barry Warsaw2518c671997-11-05 00:51:08 +0000812 ["Mark current def" py-mark-def-or-class t]
813 ["Mark current class" (py-mark-def-or-class t) t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000814 "-"
815 ["Shift region left" py-shift-region-left (mark)]
816 ["Shift region right" py-shift-region-right (mark)]
817 "-"
Barry Warsaw820273d1998-05-19 15:54:45 +0000818 ["Import/reload file" py-execute-import-or-reload t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000819 ["Execute buffer" py-execute-buffer t]
820 ["Execute region" py-execute-region (mark)]
Barry Warsaw820273d1998-05-19 15:54:45 +0000821 ["Execute def or class" py-execute-def-or-class (mark)]
Barry Warsaw1d0364b1998-05-19 16:15:26 +0000822 ["Execute string" py-execute-string t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000823 ["Start interpreter..." py-shell t]
824 "-"
825 ["Go to start of block" py-goto-block-up t]
Barry Warsawab0e86c1998-05-19 15:31:46 +0000826 ["Go to start of class" (py-beginning-of-def-or-class t) t]
827 ["Move to end of class" (py-end-of-def-or-class t) t]
828 ["Move to start of def" py-beginning-of-def-or-class t]
829 ["Move to end of def" py-end-of-def-or-class t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000830 "-"
831 ["Describe mode" py-describe-mode t]
832 )))
Barry Warsaw42f707f1996-07-29 21:05:05 +0000833
Barry Warsaw81437461996-08-01 19:48:02 +0000834
835
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000836;; Imenu definitions
837(defvar py-imenu-class-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000838 (concat ; <<classes>>
839 "\\(" ;
840 "^[ \t]*" ; newline and maybe whitespace
841 "\\(class[ \t]+[a-zA-Z0-9_]+\\)" ; class name
842 ; possibly multiple superclasses
Barry Warsaw3179fe01998-04-04 21:36:53 +0000843 "\\([ \t]*\\((\\([a-zA-Z0-9_,. \t\n]\\)*)\\)?\\)"
Barry Warsaw81437461996-08-01 19:48:02 +0000844 "[ \t]*:" ; and the final :
845 "\\)" ; >>classes<<
846 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000847 "Regexp for Python classes for use with the Imenu package."
Barry Warsaw81437461996-08-01 19:48:02 +0000848 )
849
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000850(defvar py-imenu-method-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000851 (concat ; <<methods and functions>>
852 "\\(" ;
853 "^[ \t]*" ; new line and maybe whitespace
854 "\\(def[ \t]+" ; function definitions start with def
855 "\\([a-zA-Z0-9_]+\\)" ; name is here
856 ; function arguments...
Barry Warsaw1d5f9881998-10-28 04:08:13 +0000857;; "[ \t]*(\\([-+/a-zA-Z0-9_=,\* \t\n.()\"'#]*\\))"
858 "[ \t]*(\\([^:#]*\\))"
Barry Warsaw81437461996-08-01 19:48:02 +0000859 "\\)" ; end of def
860 "[ \t]*:" ; and then the :
861 "\\)" ; >>methods and functions<<
862 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000863 "Regexp for Python methods/functions for use with the Imenu package."
Barry Warsaw81437461996-08-01 19:48:02 +0000864 )
865
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000866(defvar py-imenu-method-no-arg-parens '(2 8)
867 "Indices into groups of the Python regexp for use with Imenu.
Barry Warsaw81437461996-08-01 19:48:02 +0000868
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000869Using these values will result in smaller Imenu lists, as arguments to
Barry Warsaw81437461996-08-01 19:48:02 +0000870functions are not listed.
871
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000872See the variable `py-imenu-show-method-args-p' for more
Barry Warsaw81437461996-08-01 19:48:02 +0000873information.")
874
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000875(defvar py-imenu-method-arg-parens '(2 7)
Barry Warsaw1bbc0311998-10-27 21:54:56 +0000876 "Indices into groups of the Python regexp for use with imenu.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000877Using these values will result in large Imenu lists, as arguments to
Barry Warsaw81437461996-08-01 19:48:02 +0000878functions are listed.
879
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000880See the variable `py-imenu-show-method-args-p' for more
Barry Warsaw81437461996-08-01 19:48:02 +0000881information.")
882
883;; Note that in this format, this variable can still be used with the
884;; imenu--generic-function. Otherwise, there is no real reason to have
885;; it.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000886(defvar py-imenu-generic-expression
Barry Warsaw81437461996-08-01 19:48:02 +0000887 (cons
888 (concat
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000889 py-imenu-class-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000890 "\\|" ; or...
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000891 py-imenu-method-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000892 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000893 py-imenu-method-no-arg-parens)
894 "Generic Python expression which may be used directly with Imenu.
Barry Warsaw81437461996-08-01 19:48:02 +0000895Used by setting the variable `imenu-generic-expression' to this value.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000896Also, see the function \\[py-imenu-create-index] for a better
897alternative for finding the index.")
Barry Warsaw81437461996-08-01 19:48:02 +0000898
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000899;; These next two variables are used when searching for the Python
Barry Warsaw81437461996-08-01 19:48:02 +0000900;; class/definitions. Just saving some time in accessing the
901;; generic-python-expression, really.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000902(defvar py-imenu-generic-regexp nil)
903(defvar py-imenu-generic-parens nil)
Barry Warsaw81437461996-08-01 19:48:02 +0000904
905
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000906(defun py-imenu-create-index-function ()
907 "Python interface function for the Imenu package.
908Finds all Python classes and functions/methods. Calls function
909\\[py-imenu-create-index-engine]. See that function for the details
910of how this works."
911 (setq py-imenu-generic-regexp (car py-imenu-generic-expression)
912 py-imenu-generic-parens (if py-imenu-show-method-args-p
913 py-imenu-method-arg-parens
914 py-imenu-method-no-arg-parens))
Barry Warsaw81437461996-08-01 19:48:02 +0000915 (goto-char (point-min))
Barry Warsaw1d5f9881998-10-28 04:08:13 +0000916 ;; Warning: When the buffer has no classes or functions, this will
917 ;; return nil, which seems proper according to the Imenu API, but
918 ;; causes an error in the XEmacs port of Imenu. Sigh.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000919 (py-imenu-create-index-engine nil))
Barry Warsaw81437461996-08-01 19:48:02 +0000920
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000921(defun py-imenu-create-index-engine (&optional start-indent)
922 "Function for finding Imenu definitions in Python.
Barry Warsaw81437461996-08-01 19:48:02 +0000923
924Finds all definitions (classes, methods, or functions) in a Python
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000925file for the Imenu package.
Barry Warsaw81437461996-08-01 19:48:02 +0000926
927Returns a possibly nested alist of the form
928
929 (INDEX-NAME . INDEX-POSITION)
930
931The second element of the alist may be an alist, producing a nested
932list as in
933
934 (INDEX-NAME . INDEX-ALIST)
935
936This function should not be called directly, as it calls itself
937recursively and requires some setup. Rather this is the engine for
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000938the function \\[py-imenu-create-index-function].
Barry Warsaw81437461996-08-01 19:48:02 +0000939
940It works recursively by looking for all definitions at the current
941indention level. When it finds one, it adds it to the alist. If it
942finds a definition at a greater indentation level, it removes the
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000943previous definition from the alist. In its place it adds all
Barry Warsaw81437461996-08-01 19:48:02 +0000944definitions found at the next indentation level. When it finds a
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000945definition that is less indented then the current level, it returns
946the alist it has created thus far.
Barry Warsaw81437461996-08-01 19:48:02 +0000947
948The optional argument START-INDENT indicates the starting indentation
949at which to continue looking for Python classes, methods, or
950functions. If this is not supplied, the function uses the indentation
951of the first definition found."
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000952 (let (index-alist
953 sub-method-alist
Barry Warsaw81437461996-08-01 19:48:02 +0000954 looking-p
955 def-name prev-name
956 cur-indent def-pos
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000957 (class-paren (first py-imenu-generic-parens))
958 (def-paren (second py-imenu-generic-parens)))
Barry Warsaw81437461996-08-01 19:48:02 +0000959 (setq looking-p
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000960 (re-search-forward py-imenu-generic-regexp (point-max) t))
Barry Warsaw81437461996-08-01 19:48:02 +0000961 (while looking-p
962 (save-excursion
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000963 ;; used to set def-name to this value but generic-extract-name
964 ;; is new to imenu-1.14. this way it still works with
965 ;; imenu-1.11
966 ;;(imenu--generic-extract-name py-imenu-generic-parens))
Barry Warsaw81437461996-08-01 19:48:02 +0000967 (let ((cur-paren (if (match-beginning class-paren)
968 class-paren def-paren)))
969 (setq def-name
Barry Warsawc8520351997-11-26 06:14:40 +0000970 (buffer-substring-no-properties (match-beginning cur-paren)
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000971 (match-end cur-paren))))
Barry Warsaw93c88cc1998-08-18 02:00:44 +0000972 (save-match-data
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000973 (py-beginning-of-def-or-class 'either))
Barry Warsaw81437461996-08-01 19:48:02 +0000974 (beginning-of-line)
975 (setq cur-indent (current-indentation)))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000976 ;; HACK: want to go to the next correct definition location. We
977 ;; explicitly list them here but it would be better to have them
978 ;; in a list.
Barry Warsaw81437461996-08-01 19:48:02 +0000979 (setq def-pos
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000980 (or (match-beginning class-paren)
981 (match-beginning def-paren)))
Barry Warsaw81437461996-08-01 19:48:02 +0000982 ;; if we don't have a starting indent level, take this one
983 (or start-indent
984 (setq start-indent cur-indent))
Barry Warsaw81437461996-08-01 19:48:02 +0000985 ;; if we don't have class name yet, take this one
986 (or prev-name
987 (setq prev-name def-name))
Barry Warsaw81437461996-08-01 19:48:02 +0000988 ;; what level is the next definition on? must be same, deeper
989 ;; or shallower indentation
990 (cond
Barry Warsaw32a03962002-07-16 16:04:13 +0000991 ;; Skip code in comments and strings
992 ((py-in-literal))
Barry Warsaw81437461996-08-01 19:48:02 +0000993 ;; at the same indent level, add it to the list...
994 ((= start-indent cur-indent)
Barry Warsaw81437461996-08-01 19:48:02 +0000995 (push (cons def-name def-pos) index-alist))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000996 ;; deeper indented expression, recurse
Barry Warsaw81437461996-08-01 19:48:02 +0000997 ((< start-indent cur-indent)
Barry Warsaw81437461996-08-01 19:48:02 +0000998 ;; the point is currently on the expression we're supposed to
999 ;; start on, so go back to the last expression. The recursive
1000 ;; call will find this place again and add it to the correct
1001 ;; list
Barry Warsaw6839d3a1998-10-28 00:10:45 +00001002 (re-search-backward py-imenu-generic-regexp (point-min) 'move)
1003 (setq sub-method-alist (py-imenu-create-index-engine cur-indent))
Barry Warsaw81437461996-08-01 19:48:02 +00001004 (if sub-method-alist
1005 ;; we put the last element on the index-alist on the start
1006 ;; of the submethod alist so the user can still get to it.
1007 (let ((save-elmt (pop index-alist)))
Barry Warsawc8520351997-11-26 06:14:40 +00001008 (push (cons prev-name
Barry Warsaw81437461996-08-01 19:48:02 +00001009 (cons save-elmt sub-method-alist))
1010 index-alist))))
Barry Warsaw81437461996-08-01 19:48:02 +00001011 ;; found less indented expression, we're done.
1012 (t
1013 (setq looking-p nil)
Barry Warsaw6839d3a1998-10-28 00:10:45 +00001014 (re-search-backward py-imenu-generic-regexp (point-min) t)))
1015 ;; end-cond
Barry Warsaw81437461996-08-01 19:48:02 +00001016 (setq prev-name def-name)
1017 (and looking-p
1018 (setq looking-p
Barry Warsaw6839d3a1998-10-28 00:10:45 +00001019 (re-search-forward py-imenu-generic-regexp
Barry Warsaw81437461996-08-01 19:48:02 +00001020 (point-max) 'move))))
1021 (nreverse index-alist)))
1022
Barry Warsaw88491612002-04-25 21:31:47 +00001023
1024
1025(defun py-choose-shell-by-shebang ()
1026 "Choose CPython or JPython mode by looking at #! on the first line.
1027Returns the appropriate mode function.
1028Used by `py-choose-shell', and similar to but distinct from
1029`set-auto-mode', though it uses `auto-mode-interpreter-regexp' (if available)."
1030 ;; look for an interpreter specified in the first line
1031 ;; similar to set-auto-mode (files.el)
1032 (let* ((re (if (boundp 'auto-mode-interpreter-regexp)
1033 auto-mode-interpreter-regexp
1034 ;; stolen from Emacs 21.2
1035 "#![ \t]?\\([^ \t\n]*/bin/env[ \t]\\)?\\([^ \t\n]+\\)"))
1036 (interpreter (save-excursion
1037 (goto-char (point-min))
1038 (if (looking-at re)
1039 (match-string 2)
1040 "")))
1041 elt)
1042 ;; Map interpreter name to a mode.
1043 (setq elt (assoc (file-name-nondirectory interpreter)
1044 py-shell-alist))
1045 (and elt (caddr elt))))
1046
1047
1048
1049(defun py-choose-shell-by-import ()
1050 "Choose CPython or JPython mode based imports.
1051If a file imports any packages in `py-jpython-packages', within
1052`py-import-check-point-max' characters from the start of the file,
1053return `jpython', otherwise return nil."
1054 (let (mode)
1055 (save-excursion
1056 (goto-char (point-min))
1057 (while (and (not mode)
1058 (search-forward-regexp
1059 "^\\(\\(from\\)\\|\\(import\\)\\) \\([^ \t\n.]+\\)"
1060 py-import-check-point-max t))
1061 (setq mode (and (member (match-string 4) py-jpython-packages)
1062 'jpython
1063 ))))
1064 mode))
1065
1066
1067(defun py-choose-shell ()
1068 "Choose CPython or JPython mode. Returns the appropriate mode function.
1069This does the following:
1070 - look for an interpreter with `py-choose-shell-by-shebang'
1071 - examine imports using `py-choose-shell-by-import'
1072 - default to the variable `py-default-interpreter'"
1073 (interactive)
1074 (or (py-choose-shell-by-shebang)
1075 (py-choose-shell-by-import)
1076 py-default-interpreter
1077; 'cpython ;; don't use to py-default-interpreter, because default
1078; ;; is only way to choose CPython
1079 ))
1080
Barry Warsaw42f707f1996-07-29 21:05:05 +00001081
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001082;;;###autoload
Barry Warsaw7ae77681994-12-12 20:38:05 +00001083(defun python-mode ()
1084 "Major mode for editing Python files.
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001085To submit a problem report, enter `\\[py-submit-bug-report]' from a
1086`python-mode' buffer. Do `\\[py-describe-mode]' for detailed
1087documentation. To see what version of `python-mode' you are running,
1088enter `\\[py-version]'.
1089
1090This mode knows about Python indentation, tokens, comments and
1091continuation lines. Paragraphs are separated by blank lines only.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001092
1093COMMANDS
1094\\{py-mode-map}
1095VARIABLES
1096
Barry Warsaw42f707f1996-07-29 21:05:05 +00001097py-indent-offset\t\tindentation increment
Barry Warsaw41a05c71998-08-10 16:33:12 +00001098py-block-comment-prefix\t\tcomment string used by `comment-region'
Barry Warsaw42f707f1996-07-29 21:05:05 +00001099py-python-command\t\tshell command to invoke Python interpreter
Barry Warsaw42f707f1996-07-29 21:05:05 +00001100py-temp-directory\t\tdirectory used for temp files (if needed)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001101py-beep-if-tab-change\t\tring the bell if `tab-width' is changed"
Barry Warsaw7ae77681994-12-12 20:38:05 +00001102 (interactive)
Barry Warsaw615d4a41996-09-04 14:14:10 +00001103 ;; set up local variables
Barry Warsaw7ae77681994-12-12 20:38:05 +00001104 (kill-all-local-variables)
Barry Warsaw615d4a41996-09-04 14:14:10 +00001105 (make-local-variable 'font-lock-defaults)
1106 (make-local-variable 'paragraph-separate)
1107 (make-local-variable 'paragraph-start)
1108 (make-local-variable 'require-final-newline)
1109 (make-local-variable 'comment-start)
Barry Warsaw5c8bef11996-12-17 21:56:10 +00001110 (make-local-variable 'comment-end)
Barry Warsaw615d4a41996-09-04 14:14:10 +00001111 (make-local-variable 'comment-start-skip)
1112 (make-local-variable 'comment-column)
Barry Warsaw003932a1998-07-07 15:11:24 +00001113 (make-local-variable 'comment-indent-function)
Barry Warsaw615d4a41996-09-04 14:14:10 +00001114 (make-local-variable 'indent-region-function)
1115 (make-local-variable 'indent-line-function)
Barry Warsawb3e81d51996-09-04 15:12:42 +00001116 (make-local-variable 'add-log-current-defun-function)
Barry Warsaw615d4a41996-09-04 14:14:10 +00001117 ;;
Barry Warsaw7ae77681994-12-12 20:38:05 +00001118 (set-syntax-table py-mode-syntax-table)
Barry Warsaw003932a1998-07-07 15:11:24 +00001119 (setq major-mode 'python-mode
1120 mode-name "Python"
1121 local-abbrev-table python-mode-abbrev-table
1122 font-lock-defaults '(python-font-lock-keywords)
1123 paragraph-separate "^[ \t]*$"
1124 paragraph-start "^[ \t]*$"
1125 require-final-newline t
1126 comment-start "# "
1127 comment-end ""
1128 comment-start-skip "# *"
1129 comment-column 40
1130 comment-indent-function 'py-comment-indent-function
1131 indent-region-function 'py-indent-region
1132 indent-line-function 'py-indent-line
Barry Warsawb3e81d51996-09-04 15:12:42 +00001133 ;; tell add-log.el how to find the current function/method/variable
1134 add-log-current-defun-function 'py-current-defun
Barry Warsawb1f89511996-09-03 16:38:30 +00001135 )
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001136 (use-local-map py-mode-map)
Barry Warsaw42f707f1996-07-29 21:05:05 +00001137 ;; add the menu
1138 (if py-menu
1139 (easy-menu-add py-menu))
Barry Warsaw57697af1995-09-14 20:01:14 +00001140 ;; Emacs 19 requires this
Barry Warsawc72c11c1997-08-09 06:42:08 +00001141 (if (boundp 'comment-multi-line)
Barry Warsaw57697af1995-09-14 20:01:14 +00001142 (setq comment-multi-line nil))
Barry Warsaw6839d3a1998-10-28 00:10:45 +00001143 ;; Install Imenu if available
Barry Warsaw742a5111998-03-13 17:29:15 +00001144 (when (py-safe (require 'imenu))
Barry Warsaw6839d3a1998-10-28 00:10:45 +00001145 (setq imenu-create-index-function #'py-imenu-create-index-function)
1146 (setq imenu-generic-expression py-imenu-generic-expression)
Barry Warsaw742a5111998-03-13 17:29:15 +00001147 (if (fboundp 'imenu-add-to-menubar)
1148 (imenu-add-to-menubar (format "%s-%s" "IM" mode-name)))
1149 )
1150 ;; Run the mode hook. Note that py-mode-hook is deprecated.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001151 (if python-mode-hook
1152 (run-hooks 'python-mode-hook)
Barry Warsaw742a5111998-03-13 17:29:15 +00001153 (run-hooks 'py-mode-hook))
1154 ;; Now do the automagical guessing
1155 (if py-smart-indentation
1156 (let ((offset py-indent-offset))
Barry Warsaw145ab1c1998-05-19 14:49:49 +00001157 ;; It's okay if this fails to guess a good value
Barry Warsaw742a5111998-03-13 17:29:15 +00001158 (if (and (py-safe (py-guess-indent-offset))
1159 (<= py-indent-offset 8)
1160 (>= py-indent-offset 2))
1161 (setq offset py-indent-offset))
1162 (setq py-indent-offset offset)
Barry Warsaw639eea61998-03-16 18:12:13 +00001163 ;; Only turn indent-tabs-mode off if tab-width !=
1164 ;; py-indent-offset. Never turn it on, because the user must
1165 ;; have explicitly turned it off.
1166 (if (/= tab-width py-indent-offset)
1167 (setq indent-tabs-mode nil))
Barry Warsaw11f21561999-07-28 21:59:43 +00001168 ))
1169 ;; Set the default shell if not already set
1170 (when (null py-which-shell)
Barry Warsaw88491612002-04-25 21:31:47 +00001171 (py-toggle-shells (py-choose-shell))))
1172
1173
1174(defun jpython-mode ()
1175 "Major mode for editing JPython/Jython files.
1176This is a simple wrapper around `python-mode'.
1177It runs `jpython-mode-hook' then calls `python-mode.'
1178It is added to `interpreter-mode-alist' and `py-choose-shell'.
1179"
1180 (interactive)
1181 (python-mode)
1182 (py-toggle-shells 'jpython)
1183 (when jpython-mode-hook
1184 (run-hooks 'jpython-mode-hook)))
1185
1186
1187;; It's handy to add recognition of Python files to the
1188;; interpreter-mode-alist and to auto-mode-alist. With the former, we
1189;; can specify different `derived-modes' based on the #! line, but
1190;; with the latter, we can't. So we just won't add them if they're
1191;; already added.
1192(let ((modes '(("jpython" . jpython-mode)
1193 ("jython" . jpython-mode)
1194 ("python" . python-mode))))
1195 (while modes
1196 (when (not (assoc (car modes) interpreter-mode-alist))
Barry Warsawcf22c822002-04-25 21:46:33 +00001197 (push (car modes) interpreter-mode-alist))
Barry Warsaw88491612002-04-25 21:31:47 +00001198 (setq modes (cdr modes))))
1199
1200(when (not (or (rassq 'python-mode auto-mode-alist)
1201 (rassq 'jpython-mode auto-mode-alist)))
1202 (push '("\\.py$" . python-mode) auto-mode-alist))
1203
Barry Warsaw7ae77681994-12-12 20:38:05 +00001204
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001205
Barry Warsawb91b7431995-03-14 15:55:20 +00001206;; electric characters
Barry Warsaw3874a3d1995-03-14 22:05:53 +00001207(defun py-outdent-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00001208 "Returns non-nil if the current line should dedent one level."
Barry Warsaw3874a3d1995-03-14 22:05:53 +00001209 (save-excursion
1210 (and (progn (back-to-indentation)
1211 (looking-at py-outdent-re))
Barry Warsaw1a1c6bb1999-01-09 17:22:38 +00001212 ;; short circuit infloop on illegal construct
1213 (not (bobp))
Barry Warsawf06777d1998-01-21 05:36:18 +00001214 (progn (forward-line -1)
1215 (py-goto-initial-line)
1216 (back-to-indentation)
Barry Warsaw3874a3d1995-03-14 22:05:53 +00001217 (while (or (looking-at py-blank-or-comment-re)
1218 (bobp))
1219 (backward-to-indentation 1))
1220 (not (looking-at py-no-outdent-re)))
1221 )))
Skip Montanaro98a4fbe2003-08-01 04:00:32 +00001222
Barry Warsawb91b7431995-03-14 15:55:20 +00001223(defun py-electric-colon (arg)
1224 "Insert a colon.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001225In certain cases the line is dedented appropriately. If a numeric
1226argument ARG is provided, that many colons are inserted
1227non-electrically. Electric behavior is inhibited inside a string or
1228comment."
Skip Montanaro98a4fbe2003-08-01 04:00:32 +00001229 (interactive "*P")
Barry Warsawb91b7431995-03-14 15:55:20 +00001230 (self-insert-command (prefix-numeric-value arg))
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001231 ;; are we in a string or comment?
1232 (if (save-excursion
1233 (let ((pps (parse-partial-sexp (save-excursion
Barry Warsawab0e86c1998-05-19 15:31:46 +00001234 (py-beginning-of-def-or-class)
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001235 (point))
1236 (point))))
1237 (not (or (nth 3 pps) (nth 4 pps)))))
1238 (save-excursion
1239 (let ((here (point))
1240 (outdent 0)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001241 (indent (py-compute-indentation t)))
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001242 (if (and (not arg)
1243 (py-outdent-p)
1244 (= indent (save-excursion
Barry Warsawa7661821996-08-02 16:22:43 +00001245 (py-next-statement -1)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001246 (py-compute-indentation t)))
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001247 )
1248 (setq outdent py-indent-offset))
Barry Warsaw41a05c71998-08-10 16:33:12 +00001249 ;; Don't indent, only dedent. This assumes that any lines
1250 ;; that are already dedented relative to
1251 ;; py-compute-indentation were put there on purpose. It's
1252 ;; highly annoying to have `:' indent for you. Use TAB, C-c
1253 ;; C-l or C-c C-r to adjust. TBD: Is there a better way to
1254 ;; determine this???
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001255 (if (< (current-indentation) indent) nil
1256 (goto-char here)
1257 (beginning-of-line)
1258 (delete-horizontal-space)
1259 (indent-to (- indent outdent))
1260 )))))
Barry Warsawb91b7431995-03-14 15:55:20 +00001261
1262
Barry Warsawa97a3f31997-11-04 18:47:06 +00001263;; Python subprocess utilities and filters
1264(defun py-execute-file (proc filename)
Neal Norwitz01688022007-08-12 00:43:29 +00001265 "Send to Python interpreter process PROC \"exec(open('FILENAME').read())\".
Barry Warsaw41a05c71998-08-10 16:33:12 +00001266Make that process's buffer visible and force display. Also make
1267comint believe the user typed this string so that
1268`kill-output-from-shell' does The Right Thing."
Barry Warsawa97a3f31997-11-04 18:47:06 +00001269 (let ((curbuf (current-buffer))
1270 (procbuf (process-buffer proc))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001271; (comint-scroll-to-bottom-on-output t)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001272 (msg (format "## working on region in file %s...\n" filename))
Neal Norwitz01688022007-08-12 00:43:29 +00001273 (cmd (format "exec(open(r'%s').read())\n" filename)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001274 (unwind-protect
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001275 (save-excursion
Barry Warsawa97a3f31997-11-04 18:47:06 +00001276 (set-buffer procbuf)
1277 (goto-char (point-max))
1278 (move-marker (process-mark proc) (point))
1279 (funcall (process-filter proc) proc msg))
1280 (set-buffer curbuf))
1281 (process-send-string proc cmd)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001282
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001283(defun py-comint-output-filter-function (string)
1284 "Watch output for Python prompt and exec next file waiting in queue.
1285This function is appropriate for `comint-output-filter-functions'."
Barry Warsaw014e0e21998-11-17 19:24:47 +00001286 ;; TBD: this should probably use split-string
Barry Warsaw4f94c731998-09-25 19:40:10 +00001287 (when (and (or (string-equal string ">>> ")
Barry Warsaw4f94c731998-09-25 19:40:10 +00001288 (and (>= (length string) 5)
1289 (string-equal (substring string -5) "\n>>> ")))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001290 py-file-queue)
Barry Warsaw17afa132002-04-26 15:49:52 +00001291 (pop-to-buffer (current-buffer))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001292 (py-safe (delete-file (car py-file-queue)))
1293 (setq py-file-queue (cdr py-file-queue))
1294 (if py-file-queue
1295 (let ((pyproc (get-buffer-process (current-buffer))))
1296 (py-execute-file pyproc (car py-file-queue))))
1297 ))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001298
Barry Warsaw4f577d22001-04-11 20:23:17 +00001299(defun py-pdbtrack-overlay-arrow (activation)
1300 "Activate or de arrow at beginning-of-line in current buffer."
1301 ;; This was derived/simplified from edebug-overlay-arrow
1302 (cond (activation
1303 (setq overlay-arrow-position (make-marker))
1304 (setq overlay-arrow-string "=>")
1305 (set-marker overlay-arrow-position (py-point 'bol) (current-buffer))
1306 (setq py-pdbtrack-is-tracking-p t))
1307 (overlay-arrow-position
1308 (setq overlay-arrow-position nil)
1309 (setq py-pdbtrack-is-tracking-p nil))
1310 ))
1311
1312(defun py-pdbtrack-track-stack-file (text)
1313 "Show the file indicated by the pdb stack entry line, in a separate window.
1314
1315Activity is disabled if the buffer-local variable
1316`py-pdbtrack-do-tracking-p' is nil.
1317
1318We depend on the pdb input prompt matching `py-pdbtrack-input-prompt'
Ken Manheimere7aca522003-03-03 00:35:32 +00001319at the beginning of the line.
1320
1321If the traceback target file path is invalid, we look for the most
1322recently visited python-mode buffer which either has the name of the
1323current function \(or class) or which defines the function \(or
1324class). This is to provide for remote scripts, eg, Zope's 'Script
Ken Manheimer595adce2003-05-01 20:46:14 +00001325(Python)' - put a _copy_ of the script in a buffer named for the
1326script, and set to python-mode, and pdbtrack will find it.)"
Barry Warsaw4f577d22001-04-11 20:23:17 +00001327 ;; Instead of trying to piece things together from partial text
1328 ;; (which can be almost useless depending on Emacs version), we
1329 ;; monitor to the point where we have the next pdb prompt, and then
1330 ;; check all text from comint-last-input-end to process-mark.
1331 ;;
Ken Manheimere7aca522003-03-03 00:35:32 +00001332 ;; Also, we're very conservative about clearing the overlay arrow,
1333 ;; to minimize residue. This means, for instance, that executing
1334 ;; other pdb commands wipe out the highlight. You can always do a
1335 ;; 'where' (aka 'w') command to reveal the overlay arrow.
Barry Warsaw4f577d22001-04-11 20:23:17 +00001336 (let* ((origbuf (current-buffer))
1337 (currproc (get-buffer-process origbuf)))
Ken Manheimere7aca522003-03-03 00:35:32 +00001338
Barry Warsaw4f577d22001-04-11 20:23:17 +00001339 (if (not (and currproc py-pdbtrack-do-tracking-p))
1340 (py-pdbtrack-overlay-arrow nil)
Ken Manheimere7aca522003-03-03 00:35:32 +00001341
1342 (let* ((procmark (process-mark currproc))
Barry Warsaw4f577d22001-04-11 20:23:17 +00001343 (block (buffer-substring (max comint-last-input-end
1344 (- procmark
1345 py-pdbtrack-track-range))
1346 procmark))
Ken Manheimere7aca522003-03-03 00:35:32 +00001347 target target_fname target_lineno)
1348
Barry Warsaw4f577d22001-04-11 20:23:17 +00001349 (if (not (string-match (concat py-pdbtrack-input-prompt "$") block))
1350 (py-pdbtrack-overlay-arrow nil)
Ken Manheimere7aca522003-03-03 00:35:32 +00001351
1352 (setq target (py-pdbtrack-get-source-buffer block))
1353
1354 (if (stringp target)
1355 (message "pdbtrack: %s" target)
1356
1357 (setq target_lineno (car target))
1358 (setq target_buffer (cadr target))
1359 (setq target_fname (buffer-file-name target_buffer))
1360 (switch-to-buffer-other-window target_buffer)
1361 (goto-line target_lineno)
1362 (message "pdbtrack: line %s, file %s" target_lineno target_fname)
1363 (py-pdbtrack-overlay-arrow t)
1364 (pop-to-buffer origbuf t)
1365
1366 )))))
1367 )
1368
1369(defun py-pdbtrack-get-source-buffer (block)
1370 "Return line number and buffer of code indicated by block's traceback text.
1371
1372We look first to visit the file indicated in the trace.
1373
1374Failing that, we look for the most recently visited python-mode buffer
1375with the same name or having
1376having the named function.
1377
1378If we're unable find the source code we return a string describing the
1379problem as best as we can determine."
1380
1381 (if (not (string-match py-pdbtrack-stack-entry-regexp block))
1382
1383 "Traceback cue not found"
1384
1385 (let* ((filename (match-string 1 block))
1386 (lineno (string-to-int (match-string 2 block)))
1387 (funcname (match-string 3 block))
1388 funcbuffer)
1389
1390 (cond ((file-exists-p filename)
1391 (list lineno (find-file-noselect filename)))
1392
1393 ((setq funcbuffer (py-pdbtrack-grub-for-buffer funcname lineno))
1394 (if (string-match "/Script (Python)$" filename)
1395 ;; Add in number of lines for leading '##' comments:
1396 (setq lineno
1397 (+ lineno
1398 (save-excursion
1399 (set-buffer funcbuffer)
1400 (count-lines
1401 (point-min)
Ken Manheimerad428cd2003-03-03 04:05:03 +00001402 (max (point-min)
1403 (string-match "^\\([^#]\\|#[^#]\\|#$\\)"
1404 (buffer-substring (point-min)
Ken Manheimer8e9b80f2003-06-17 19:18:57 +00001405 (point-max)))
Ken Manheimerad428cd2003-03-03 04:05:03 +00001406 ))))))
Ken Manheimere7aca522003-03-03 00:35:32 +00001407 (list lineno funcbuffer))
1408
1409 ((= (elt filename 0) ?\<)
1410 (format "(Non-file source: '%s')" filename))
1411
Ken Manheimer595adce2003-05-01 20:46:14 +00001412 (t (format "Not found: %s(), %s" funcname filename)))
Ken Manheimere7aca522003-03-03 00:35:32 +00001413 )
1414 )
1415 )
1416
1417(defun py-pdbtrack-grub-for-buffer (funcname lineno)
1418 "Find most recent buffer itself named or having function funcname.
1419
Ken Manheimered6000a2003-03-03 17:09:44 +00001420We first check the last buffer this function found, if any, then walk
1421throught the buffer-list history for python-mode buffers that are
1422named for funcname or define a function funcname."
Ken Manheimere7aca522003-03-03 00:35:32 +00001423 (let ((buffers (buffer-list))
Ken Manheimere7aca522003-03-03 00:35:32 +00001424 curbuf
1425 got)
1426 (while (and buffers (not got))
1427 (setq buf (car buffers)
1428 buffers (cdr buffers))
Ken Manheimered6000a2003-03-03 17:09:44 +00001429 (if (and (save-excursion (set-buffer buf)
1430 (string= major-mode "python-mode"))
1431 (or (string-match funcname (buffer-name buf))
Ken Manheimere7aca522003-03-03 00:35:32 +00001432 (string-match (concat "^\\s-*\\(def\\|class\\)\\s-+"
1433 funcname "\\s-*(")
Ken Manheimer8e9b80f2003-06-17 19:18:57 +00001434 (save-excursion
1435 (set-buffer buf)
1436 (buffer-substring (point-min)
1437 (point-max))))))
Ken Manheimere7aca522003-03-03 00:35:32 +00001438 (setq got buf)))
Ken Manheimered6000a2003-03-03 17:09:44 +00001439 (setq py-pdbtrack-last-grubbed-buffer got)))
Barry Warsaw4f577d22001-04-11 20:23:17 +00001440
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001441(defun py-postprocess-output-buffer (buf)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001442 "Highlight exceptions found in BUF.
1443If an exception occurred return t, otherwise return nil. BUF must exist."
Barry Warsawf9b99f41998-03-26 16:08:59 +00001444 (let (line file bol err-p)
Barry Warsaw9981d221997-12-03 05:25:48 +00001445 (save-excursion
1446 (set-buffer buf)
1447 (beginning-of-buffer)
1448 (while (re-search-forward py-traceback-line-re nil t)
1449 (setq file (match-string 1)
1450 line (string-to-int (match-string 2))
1451 bol (py-point 'bol))
Barry Warsawf9b99f41998-03-26 16:08:59 +00001452 (py-highlight-line bol (py-point 'eol) file line)))
1453 (when (and py-jump-on-exception line)
1454 (beep)
1455 (py-jump-to-exception file line)
1456 (setq err-p t))
1457 err-p))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001458
Barry Warsaw9981d221997-12-03 05:25:48 +00001459
Barry Warsawa97a3f31997-11-04 18:47:06 +00001460
1461;;; Subprocess commands
1462
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001463;; only used when (memq 'broken-temp-names py-emacs-features)
1464(defvar py-serial-number 0)
1465(defvar py-exception-buffer nil)
1466(defconst py-output-buffer "*Python Output*")
Barry Warsawa2398801998-04-09 23:28:20 +00001467(make-variable-buffer-local 'py-output-buffer)
1468
1469;; for toggling between CPython and JPython
Barry Warsawaa384fd1999-02-16 23:36:16 +00001470(defvar py-which-shell nil)
Barry Warsawa2398801998-04-09 23:28:20 +00001471(defvar py-which-args py-python-command-args)
1472(defvar py-which-bufname "Python")
1473(make-variable-buffer-local 'py-which-shell)
1474(make-variable-buffer-local 'py-which-args)
1475(make-variable-buffer-local 'py-which-bufname)
1476
1477(defun py-toggle-shells (arg)
1478 "Toggles between the CPython and JPython shells.
Barry Warsaw11f21561999-07-28 21:59:43 +00001479
Barry Warsaw41a05c71998-08-10 16:33:12 +00001480With positive argument ARG (interactively \\[universal-argument]),
1481uses the CPython shell, with negative ARG uses the JPython shell, and
Barry Warsaw11f21561999-07-28 21:59:43 +00001482with a zero argument, toggles the shell.
1483
1484Programmatically, ARG can also be one of the symbols `cpython' or
1485`jpython', equivalent to positive arg and negative arg respectively."
Barry Warsawa2398801998-04-09 23:28:20 +00001486 (interactive "P")
1487 ;; default is to toggle
1488 (if (null arg)
1489 (setq arg 0))
Barry Warsaw11f21561999-07-28 21:59:43 +00001490 ;; preprocess arg
1491 (cond
1492 ((equal arg 0)
1493 ;; toggle
1494 (if (string-equal py-which-bufname "Python")
1495 (setq arg -1)
1496 (setq arg 1)))
1497 ((equal arg 'cpython) (setq arg 1))
1498 ((equal arg 'jpython) (setq arg -1)))
Barry Warsawa2398801998-04-09 23:28:20 +00001499 (let (msg)
1500 (cond
1501 ((< 0 arg)
1502 ;; set to CPython
1503 (setq py-which-shell py-python-command
1504 py-which-args py-python-command-args
1505 py-which-bufname "Python"
1506 msg "CPython"
1507 mode-name "Python"))
1508 ((> 0 arg)
1509 (setq py-which-shell py-jpython-command
1510 py-which-args py-jpython-command-args
1511 py-which-bufname "JPython"
1512 msg "JPython"
1513 mode-name "JPython"))
1514 )
Barry Warsawea609c11998-04-10 16:08:26 +00001515 (message "Using the %s shell" msg)
Barry Warsawa2398801998-04-09 23:28:20 +00001516 (setq py-output-buffer (format "*%s Output*" py-which-bufname))))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001517
Barry Warsawa97a3f31997-11-04 18:47:06 +00001518;;;###autoload
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001519(defun py-shell (&optional argprompt)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001520 "Start an interactive Python interpreter in another window.
1521This is like Shell mode, except that Python is running in the window
1522instead of a shell. See the `Interactive Shell' and `Shell Mode'
1523sections of the Emacs manual for details, especially for the key
1524bindings active in the `*Python*' buffer.
1525
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001526With optional \\[universal-argument], the user is prompted for the
1527flags to pass to the Python interpreter. This has no effect when this
1528command is used to switch to an existing process, only when a new
1529process is started. If you use this, you will probably want to ensure
1530that the current arguments are retained (they will be included in the
1531prompt). This argument is ignored when this function is called
1532programmatically, or when running in Emacs 19.34 or older.
1533
Barry Warsawa2398801998-04-09 23:28:20 +00001534Note: You can toggle between using the CPython interpreter and the
1535JPython interpreter by hitting \\[py-toggle-shells]. This toggles
1536buffer local variables which control whether all your subshell
1537interactions happen to the `*JPython*' or `*Python*' buffers (the
1538latter is the name used for the CPython buffer).
1539
Barry Warsawa97a3f31997-11-04 18:47:06 +00001540Warning: Don't use an interactive Python if you change sys.ps1 or
1541sys.ps2 from their default values, or if you're running code that
1542prints `>>> ' or `... ' at the start of a line. `python-mode' can't
1543distinguish your output from Python's output, and assumes that `>>> '
1544at the start of a line is a prompt from Python. Similarly, the Emacs
1545Shell mode code assumes that both `>>> ' and `... ' at the start of a
1546line are Python prompts. Bad things can happen if you fool either
1547mode.
1548
1549Warning: If you do any editing *in* the process buffer *while* the
1550buffer is accepting output from Python, do NOT attempt to `undo' the
1551changes. Some of the output (nowhere near the parts you changed!) may
1552be lost if you do. This appears to be an Emacs bug, an unfortunate
1553interaction between undo and process filters; the same problem exists in
1554non-Python process buffers using the default (Emacs-supplied) process
1555filter."
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001556 (interactive "P")
Barry Warsaw50765ab1999-08-10 21:49:00 +00001557 ;; Set the default shell if not already set
1558 (when (null py-which-shell)
1559 (py-toggle-shells py-default-interpreter))
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001560 (let ((args py-which-args))
1561 (when (and argprompt
1562 (interactive-p)
1563 (fboundp 'split-string))
1564 ;; TBD: Perhaps force "-i" in the final list?
1565 (setq args (split-string
1566 (read-string (concat py-which-bufname
1567 " arguments: ")
1568 (concat
1569 (mapconcat 'identity py-which-args " ") " ")
1570 ))))
1571 (switch-to-buffer-other-window
1572 (apply 'make-comint py-which-bufname py-which-shell nil args))
1573 (make-local-variable 'comint-prompt-regexp)
1574 (setq comint-prompt-regexp "^>>> \\|^[.][.][.] \\|^(pdb) ")
1575 (add-hook 'comint-output-filter-functions
1576 'py-comint-output-filter-function)
Barry Warsaw4f577d22001-04-11 20:23:17 +00001577 ;; pdbtrack
1578 (add-hook 'comint-output-filter-functions 'py-pdbtrack-track-stack-file)
1579 (setq py-pdbtrack-do-tracking-p t)
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001580 (set-syntax-table py-mode-syntax-table)
1581 (use-local-map py-shell-map)
Barry Warsaw56bd2ed2002-04-25 15:44:17 +00001582 (run-hooks 'py-shell-hook)
Barry Warsaw3b4e2f01999-02-16 23:52:46 +00001583 ))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001584
Barry Warsawa97a3f31997-11-04 18:47:06 +00001585(defun py-clear-queue ()
1586 "Clear the queue of temporary files waiting to execute."
1587 (interactive)
1588 (let ((n (length py-file-queue)))
1589 (mapcar 'delete-file py-file-queue)
1590 (setq py-file-queue nil)
1591 (message "%d pending files de-queued." n)))
1592
Barry Warsaw820273d1998-05-19 15:54:45 +00001593
Barry Warsawa97a3f31997-11-04 18:47:06 +00001594(defun py-execute-region (start end &optional async)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001595 "Execute the region in a Python interpreter.
1596
Barry Warsawa97a3f31997-11-04 18:47:06 +00001597The region is first copied into a temporary file (in the directory
1598`py-temp-directory'). If there is no Python interpreter shell
1599running, this file is executed synchronously using
Barry Warsaw41a05c71998-08-10 16:33:12 +00001600`shell-command-on-region'. If the program is long running, use
1601\\[universal-argument] to run the command asynchronously in its own
1602buffer.
1603
1604When this function is used programmatically, arguments START and END
1605specify the region to execute, and optional third argument ASYNC, if
1606non-nil, specifies to run the command asynchronously in its own
1607buffer.
Barry Warsawa97a3f31997-11-04 18:47:06 +00001608
Neal Norwitz01688022007-08-12 00:43:29 +00001609If the Python interpreter shell is running, the region is exec()'d
Barry Warsawa97a3f31997-11-04 18:47:06 +00001610in that shell. If you try to execute regions too quickly,
1611`python-mode' will queue them up and execute them one at a time when
1612it sees a `>>> ' prompt from Python. Each time this happens, the
1613process buffer is popped into a window (if it's not already in some
1614window) so you can see it, and a comment of the form
1615
1616 \t## working on region in file <name>...
1617
1618is inserted at the end. See also the command `py-clear-queue'."
1619 (interactive "r\nP")
Barry Warsaw4aab68e2002-04-25 19:17:42 +00001620 ;; Skip ahead to the first non-blank line
Barry Warsaw014e0e21998-11-17 19:24:47 +00001621 (let* ((proc (get-process py-which-bufname))
Barry Warsaw5e21cb01997-11-05 18:41:11 +00001622 (temp (if (memq 'broken-temp-names py-emacs-features)
Barry Warsaw1b344241998-08-07 22:24:16 +00001623 (let
1624 ((sn py-serial-number)
1625 (pid (and (fboundp 'emacs-pid) (emacs-pid))))
1626 (setq py-serial-number (1+ py-serial-number))
1627 (if pid
1628 (format "python-%d-%d" sn pid)
1629 (format "python-%d" sn)))
Barry Warsaw2f32fbb1998-02-25 16:45:43 +00001630 (make-temp-name "python-")))
Barry Warsawb2d5e622002-04-22 15:29:27 +00001631 (file (concat (expand-file-name temp py-temp-directory) ".py"))
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001632 (cur (current-buffer))
Barry Warsawb2d5e622002-04-22 15:29:27 +00001633 (buf (get-buffer-create file))
1634 shell)
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001635 ;; Write the contents of the buffer, watching out for indented regions.
1636 (save-excursion
1637 (goto-char start)
Barry Warsaw69c92662002-05-12 17:37:46 +00001638 (beginning-of-line)
1639 (while (and (looking-at "\\s *$")
1640 (< (point) end))
1641 (forward-line 1))
1642 (setq start (point))
1643 (or (< start end)
1644 (error "Region is empty"))
Barry Warsaw99eadf42000-06-23 20:24:25 +00001645 (let ((needs-if (/= (py-point 'bol) (py-point 'boi))))
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001646 (set-buffer buf)
Barry Warsawb2d5e622002-04-22 15:29:27 +00001647 (python-mode)
Barry Warsaw99eadf42000-06-23 20:24:25 +00001648 (when needs-if
1649 (insert "if 1:\n"))
Barry Warsawa0113cd2002-04-22 16:23:29 +00001650 (insert-buffer-substring cur start end)
1651 ;; Set the shell either to the #! line command, or to the
1652 ;; py-which-shell buffer local variable.
Barry Warsaw88491612002-04-25 21:31:47 +00001653 (setq shell (or (py-choose-shell-by-shebang)
1654 (py-choose-shell-by-import)
1655 py-which-shell))))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001656 (cond
Barry Warsaw145ab1c1998-05-19 14:49:49 +00001657 ;; always run the code in its own asynchronous subprocess
Barry Warsawa97a3f31997-11-04 18:47:06 +00001658 (async
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001659 ;; User explicitly wants this to run in its own async subprocess
1660 (save-excursion
1661 (set-buffer buf)
1662 (write-region (point-min) (point-max) file nil 'nomsg))
Barry Warsaw34d83171998-11-20 03:04:07 +00001663 (let* ((buf (generate-new-buffer-name py-output-buffer))
1664 ;; TBD: a horrible hack, but why create new Custom variables?
1665 (arg (if (string-equal py-which-bufname "Python")
1666 "-u" "")))
Barry Warsawb2d5e622002-04-22 15:29:27 +00001667 (start-process py-which-bufname buf shell arg file)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001668 (pop-to-buffer buf)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001669 (py-postprocess-output-buffer buf)
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001670 ;; TBD: clean up the temporary file!
Barry Warsawa97a3f31997-11-04 18:47:06 +00001671 ))
1672 ;; if the Python interpreter shell is running, queue it up for
1673 ;; execution there.
1674 (proc
1675 ;; use the existing python shell
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001676 (save-excursion
1677 (set-buffer buf)
1678 (write-region (point-min) (point-max) file nil 'nomsg))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001679 (if (not py-file-queue)
1680 (py-execute-file proc file)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001681 (message "File %s queued for execution" file))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001682 (setq py-file-queue (append py-file-queue (list file)))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001683 (setq py-exception-buffer (cons file (current-buffer))))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001684 (t
Barry Warsawa0113cd2002-04-22 16:23:29 +00001685 ;; TBD: a horrible hack, but why create new Custom variables?
1686 (let ((cmd (concat shell (if (string-equal py-which-bufname "JPython")
1687 " -" ""))))
Barry Warsaw34d83171998-11-20 03:04:07 +00001688 ;; otherwise either run it synchronously in a subprocess
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001689 (save-excursion
1690 (set-buffer buf)
1691 (shell-command-on-region (point-min) (point-max)
1692 cmd py-output-buffer))
Barry Warsaw34d83171998-11-20 03:04:07 +00001693 ;; shell-command-on-region kills the output buffer if it never
1694 ;; existed and there's no output from the command
1695 (if (not (get-buffer py-output-buffer))
1696 (message "No output.")
1697 (setq py-exception-buffer (current-buffer))
1698 (let ((err-p (py-postprocess-output-buffer py-output-buffer)))
1699 (pop-to-buffer py-output-buffer)
1700 (if err-p
1701 (pop-to-buffer py-exception-buffer)))
Barry Warsawcaee2fe2000-05-23 05:47:43 +00001702 ))
Barry Warsaw29a90f02002-04-22 21:48:20 +00001703 ))
Barry Warsaw71534602001-02-20 23:07:56 +00001704 ;; Clean up after ourselves.
1705 (kill-buffer buf)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001706
Barry Warsaw820273d1998-05-19 15:54:45 +00001707
1708;; Code execution commands
Barry Warsawa97a3f31997-11-04 18:47:06 +00001709(defun py-execute-buffer (&optional async)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001710 "Send the contents of the buffer to a Python interpreter.
Barry Warsawc0ecb531998-01-20 21:43:34 +00001711If the file local variable `py-master-file' is non-nil, execute the
1712named file instead of the buffer's file.
1713
Barry Warsaw7ae77681994-12-12 20:38:05 +00001714If there is a *Python* process buffer it is used. If a clipping
1715restriction is in effect, only the accessible portion of the buffer is
1716sent. A trailing newline will be supplied if needed.
1717
Barry Warsaw41a05c71998-08-10 16:33:12 +00001718See the `\\[py-execute-region]' docs for an account of some
1719subtleties, including the use of the optional ASYNC argument."
Barry Warsawa97a3f31997-11-04 18:47:06 +00001720 (interactive "P")
Barry Warsawc0ecb531998-01-20 21:43:34 +00001721 (if py-master-file
1722 (let* ((filename (expand-file-name py-master-file))
1723 (buffer (or (get-file-buffer filename)
1724 (find-file-noselect filename))))
1725 (set-buffer buffer)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001726 (py-execute-region (point-min) (point-max) async))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001727
Barry Warsaw820273d1998-05-19 15:54:45 +00001728(defun py-execute-import-or-reload (&optional async)
1729 "Import the current buffer's file in a Python interpreter.
1730
1731If the file has already been imported, then do reload instead to get
Barry Warsaw7c29b231998-07-07 17:45:38 +00001732the latest version.
1733
Neal Norwitz01688022007-08-12 00:43:29 +00001734If the file's name does not end in \".py\", then do exec instead.
Barry Warsaw7c29b231998-07-07 17:45:38 +00001735
1736If the current buffer is not visiting a file, do `py-execute-buffer'
1737instead.
1738
1739If the file local variable `py-master-file' is non-nil, import or
1740reload the named file instead of the buffer's file. The file may be
1741saved based on the value of `py-execute-import-or-reload-save-p'.
Barry Warsaw820273d1998-05-19 15:54:45 +00001742
Barry Warsaw41a05c71998-08-10 16:33:12 +00001743See the `\\[py-execute-region]' docs for an account of some
1744subtleties, including the use of the optional ASYNC argument.
Barry Warsaw820273d1998-05-19 15:54:45 +00001745
Barry Warsaw7c29b231998-07-07 17:45:38 +00001746This may be preferable to `\\[py-execute-buffer]' because:
Barry Warsaw820273d1998-05-19 15:54:45 +00001747
1748 - Definitions stay in their module rather than appearing at top
1749 level, where they would clutter the global namespace and not affect
1750 uses of qualified names (MODULE.NAME).
1751
1752 - The Python debugger gets line number information about the functions."
1753 (interactive "P")
1754 ;; Check file local variable py-master-file
1755 (if py-master-file
1756 (let* ((filename (expand-file-name py-master-file))
1757 (buffer (or (get-file-buffer filename)
1758 (find-file-noselect filename))))
1759 (set-buffer buffer)))
1760 (let ((file (buffer-file-name (current-buffer))))
1761 (if file
1762 (progn
Barry Warsaw3bfed5b1998-05-19 16:25:04 +00001763 ;; Maybe save some buffers
1764 (save-some-buffers (not py-ask-about-save) nil)
Barry Warsaw820273d1998-05-19 15:54:45 +00001765 (py-execute-string
1766 (if (string-match "\\.py$" file)
1767 (let ((f (file-name-sans-extension
1768 (file-name-nondirectory file))))
1769 (format "if globals().has_key('%s'):\n reload(%s)\nelse:\n import %s\n"
1770 f f f))
Neal Norwitz01688022007-08-12 00:43:29 +00001771 (format "exec(open(r'%s'))\n" file))
Barry Warsaw820273d1998-05-19 15:54:45 +00001772 async))
1773 ;; else
1774 (py-execute-buffer async))))
1775
1776
1777(defun py-execute-def-or-class (&optional async)
1778 "Send the current function or class definition to a Python interpreter.
1779
1780If there is a *Python* process buffer it is used.
1781
Barry Warsaw41a05c71998-08-10 16:33:12 +00001782See the `\\[py-execute-region]' docs for an account of some
1783subtleties, including the use of the optional ASYNC argument."
Barry Warsaw820273d1998-05-19 15:54:45 +00001784 (interactive "P")
1785 (save-excursion
1786 (py-mark-def-or-class)
1787 ;; mark is before point
1788 (py-execute-region (mark) (point) async)))
1789
1790
1791(defun py-execute-string (string &optional async)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001792 "Send the argument STRING to a Python interpreter.
Barry Warsaw820273d1998-05-19 15:54:45 +00001793
1794If there is a *Python* process buffer it is used.
1795
Barry Warsaw41a05c71998-08-10 16:33:12 +00001796See the `\\[py-execute-region]' docs for an account of some
1797subtleties, including the use of the optional ASYNC argument."
Barry Warsaw820273d1998-05-19 15:54:45 +00001798 (interactive "sExecute Python command: ")
1799 (save-excursion
1800 (set-buffer (get-buffer-create
1801 (generate-new-buffer-name " *Python Command*")))
1802 (insert string)
1803 (py-execute-region (point-min) (point-max) async)))
1804
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001805
1806
1807(defun py-jump-to-exception (file line)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001808 "Jump to the Python code in FILE at LINE."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001809 (let ((buffer (cond ((string-equal file "<stdin>")
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001810 (if (consp py-exception-buffer)
1811 (cdr py-exception-buffer)
1812 py-exception-buffer))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001813 ((and (consp py-exception-buffer)
1814 (string-equal file (car py-exception-buffer)))
1815 (cdr py-exception-buffer))
1816 ((py-safe (find-file-noselect file)))
1817 ;; could not figure out what file the exception
1818 ;; is pointing to, so prompt for it
1819 (t (find-file (read-file-name "Exception file: "
1820 nil
1821 file t))))))
1822 (pop-to-buffer buffer)
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001823 ;; Force Python mode
Barry Warsaw820273d1998-05-19 15:54:45 +00001824 (if (not (eq major-mode 'python-mode))
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001825 (python-mode))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001826 (goto-line line)
1827 (message "Jumping to exception in file %s on line %d" file line)))
1828
1829(defun py-mouseto-exception (event)
Barry Warsaw12c92941998-08-10 21:44:37 +00001830 "Jump to the code which caused the Python exception at EVENT.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001831EVENT is usually a mouse click."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001832 (interactive "e")
1833 (cond
1834 ((fboundp 'event-point)
1835 ;; XEmacs
1836 (let* ((point (event-point event))
1837 (buffer (event-buffer event))
1838 (e (and point buffer (extent-at point buffer 'py-exc-info)))
1839 (info (and e (extent-property e 'py-exc-info))))
1840 (message "Event point: %d, info: %s" point info)
1841 (and info
1842 (py-jump-to-exception (car info) (cdr info)))
1843 ))
1844 ;; Emacs -- Please port this!
1845 ))
1846
1847(defun py-goto-exception ()
1848 "Go to the line indicated by the traceback."
1849 (interactive)
1850 (let (file line)
1851 (save-excursion
1852 (beginning-of-line)
1853 (if (looking-at py-traceback-line-re)
1854 (setq file (match-string 1)
1855 line (string-to-int (match-string 2)))))
1856 (if (not file)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001857 (error "Not on a traceback line"))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001858 (py-jump-to-exception file line)))
1859
1860(defun py-find-next-exception (start buffer searchdir errwhere)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001861 "Find the next Python exception and jump to the code that caused it.
1862START is the buffer position in BUFFER from which to begin searching
1863for an exception. SEARCHDIR is a function, either
1864`re-search-backward' or `re-search-forward' indicating the direction
1865to search. ERRWHERE is used in an error message if the limit (top or
1866bottom) of the trackback stack is encountered."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001867 (let (file line)
1868 (save-excursion
1869 (set-buffer buffer)
1870 (goto-char (py-point start))
1871 (if (funcall searchdir py-traceback-line-re nil t)
1872 (setq file (match-string 1)
1873 line (string-to-int (match-string 2)))))
1874 (if (and file line)
1875 (py-jump-to-exception file line)
1876 (error "%s of traceback" errwhere))))
1877
1878(defun py-down-exception (&optional bottom)
1879 "Go to the next line down in the traceback.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001880With \\[univeral-argument] (programmatically, optional argument
1881BOTTOM), jump to the bottom (innermost) exception in the exception
1882stack."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001883 (interactive "P")
1884 (let* ((proc (get-process "Python"))
1885 (buffer (if proc "*Python*" py-output-buffer)))
1886 (if bottom
1887 (py-find-next-exception 'eob buffer 're-search-backward "Bottom")
1888 (py-find-next-exception 'eol buffer 're-search-forward "Bottom"))))
1889
1890(defun py-up-exception (&optional top)
1891 "Go to the previous line up in the traceback.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001892With \\[universal-argument] (programmatically, optional argument TOP)
1893jump to the top (outermost) exception in the exception stack."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001894 (interactive "P")
1895 (let* ((proc (get-process "Python"))
1896 (buffer (if proc "*Python*" py-output-buffer)))
1897 (if top
1898 (py-find-next-exception 'bob buffer 're-search-forward "Top")
Barry Warsawffbc17d1997-11-27 20:08:14 +00001899 (py-find-next-exception 'bol buffer 're-search-backward "Top"))))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001900
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001901
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001902;; Electric deletion
1903(defun py-electric-backspace (arg)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001904 "Delete preceding character or levels of indentation.
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001905Deletion is performed by calling the function in `py-backspace-function'
Barry Warsawb0539931996-12-17 22:05:07 +00001906with a single argument (the number of characters to delete).
Barry Warsaw7ae77681994-12-12 20:38:05 +00001907
Barry Warsaw41a05c71998-08-10 16:33:12 +00001908If point is at the leftmost column, delete the preceding newline.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001909
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001910Otherwise, if point is at the leftmost non-whitespace character of a
1911line that is neither a continuation line nor a non-indenting comment
1912line, or if point is at the end of a blank line, this command reduces
1913the indentation to match that of the line that opened the current
1914block of code. The line that opened the block is displayed in the
Barry Warsaw41a05c71998-08-10 16:33:12 +00001915echo area to help you keep track of where you are. With
1916\\[universal-argument] dedents that many blocks (but not past column
1917zero).
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001918
1919Otherwise the preceding character is deleted, converting a tab to
1920spaces if needed so that only a single column position is deleted.
Barry Warsawfa2def21999-05-24 21:43:37 +00001921\\[universal-argument] specifies how many characters to delete;
1922default is 1.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001923
1924When used programmatically, argument ARG specifies the number of
1925blocks to dedent, or the number of characters to delete, as indicated
1926above."
Barry Warsaw03970731996-07-03 23:12:52 +00001927 (interactive "*p")
Barry Warsaw7ae77681994-12-12 20:38:05 +00001928 (if (or (/= (current-indentation) (current-column))
1929 (bolp)
1930 (py-continuation-line-p)
Barry Warsawfa2def21999-05-24 21:43:37 +00001931; (not py-honor-comment-indentation)
1932; (looking-at "#[^ \t\n]") ; non-indenting #
1933 )
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001934 (funcall py-backspace-function arg)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001935 ;; else indent the same as the colon line that opened the block
Barry Warsaw7ae77681994-12-12 20:38:05 +00001936 ;; force non-blank so py-goto-block-up doesn't ignore it
1937 (insert-char ?* 1)
1938 (backward-char)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001939 (let ((base-indent 0) ; indentation of base line
1940 (base-text "") ; and text of base line
1941 (base-found-p nil))
Barry Warsaw03970731996-07-03 23:12:52 +00001942 (save-excursion
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001943 (while (< 0 arg)
Barry Warsaw03970731996-07-03 23:12:52 +00001944 (condition-case nil ; in case no enclosing block
1945 (progn
1946 (py-goto-block-up 'no-mark)
1947 (setq base-indent (current-indentation)
1948 base-text (py-suck-up-leading-text)
1949 base-found-p t))
1950 (error nil))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001951 (setq arg (1- arg))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001952 (delete-char 1) ; toss the dummy character
1953 (delete-horizontal-space)
1954 (indent-to base-indent)
1955 (if base-found-p
1956 (message "Closes block: %s" base-text)))))
1957
Barry Warsawfc8a01f1995-03-09 16:07:29 +00001958
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001959(defun py-electric-delete (arg)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001960 "Delete preceding or following character or levels of whitespace.
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001961
1962The behavior of this function depends on the variable
1963`delete-key-deletes-forward'. If this variable is nil (or does not
Barry Warsaw41a05c71998-08-10 16:33:12 +00001964exist, as in older Emacsen and non-XEmacs versions), then this
1965function behaves identically to \\[c-electric-backspace].
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001966
1967If `delete-key-deletes-forward' is non-nil and is supported in your
1968Emacs, then deletion occurs in the forward direction, by calling the
Barry Warsaw41a05c71998-08-10 16:33:12 +00001969function in `py-delete-function'.
1970
1971\\[universal-argument] (programmatically, argument ARG) specifies the
1972number of characters to delete (default is 1)."
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001973 (interactive "*p")
Barry Warsaw1d7b0fa1999-01-15 02:12:31 +00001974 (if (or (and (fboundp 'delete-forward-p) ;XEmacs 21
1975 (delete-forward-p))
1976 (and (boundp 'delete-key-deletes-forward) ;XEmacs 20
1977 delete-key-deletes-forward))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001978 (funcall py-delete-function arg)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001979 (py-electric-backspace arg)))
1980
1981;; required for pending-del and delsel modes
Skip Montanaro98a4fbe2003-08-01 04:00:32 +00001982(put 'py-electric-colon 'delete-selection t) ;delsel
1983(put 'py-electric-colon 'pending-delete t) ;pending-del
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001984(put 'py-electric-backspace 'delete-selection 'supersede) ;delsel
1985(put 'py-electric-backspace 'pending-delete 'supersede) ;pending-del
1986(put 'py-electric-delete 'delete-selection 'supersede) ;delsel
1987(put 'py-electric-delete 'pending-delete 'supersede) ;pending-del
1988
1989
1990
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001991(defun py-indent-line (&optional arg)
1992 "Fix the indentation of the current line according to Python rules.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001993With \\[universal-argument] (programmatically, the optional argument
1994ARG non-nil), ignore dedenting rules for block closing statements
1995(e.g. return, raise, break, continue, pass)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001996
1997This function is normally bound to `indent-line-function' so
1998\\[indent-for-tab-command] will call it."
1999 (interactive "P")
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002000 (let* ((ci (current-indentation))
2001 (move-to-indentation-p (<= (current-column) ci))
Barry Warsaw7cb505c1996-10-23 20:44:59 +00002002 (need (py-compute-indentation (not arg))))
Barry Warsaw41a05c71998-08-10 16:33:12 +00002003 ;; see if we need to dedent
Barry Warsaw3874a3d1995-03-14 22:05:53 +00002004 (if (py-outdent-p)
Barry Warsaw0012c1e1995-03-14 16:32:55 +00002005 (setq need (- need py-indent-offset)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002006 (if (/= ci need)
2007 (save-excursion
2008 (beginning-of-line)
2009 (delete-horizontal-space)
2010 (indent-to need)))
2011 (if move-to-indentation-p (back-to-indentation))))
2012
2013(defun py-newline-and-indent ()
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002014 "Strives to act like the Emacs `newline-and-indent'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002015This is just `strives to' because correct indentation can't be computed
2016from scratch for Python code. In general, deletes the whitespace before
2017point, inserts a newline, and takes an educated guess as to how you want
2018the new line indented."
2019 (interactive)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002020 (let ((ci (current-indentation)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002021 (if (< ci (current-column)) ; if point beyond indentation
2022 (newline-and-indent)
2023 ;; else try to act like newline-and-indent "normally" acts
2024 (beginning-of-line)
2025 (insert-char ?\n 1)
2026 (move-to-column ci))))
2027
Barry Warsaw7cb505c1996-10-23 20:44:59 +00002028(defun py-compute-indentation (honor-block-close-p)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002029 "Compute Python indentation.
2030When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',
2031`raise', `break', `continue', and `pass' force one level of
2032dedenting."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002033 (save-excursion
Barry Warsawf64b4051998-02-12 16:52:14 +00002034 (beginning-of-line)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00002035 (let* ((bod (py-point 'bod))
Barry Warsaw3b3ff4e1997-11-26 20:58:48 +00002036 (pps (parse-partial-sexp bod (point)))
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002037 (boipps (parse-partial-sexp bod (py-point 'boi)))
2038 placeholder)
Barry Warsaw095e9c61995-09-19 20:01:42 +00002039 (cond
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00002040 ;; are we inside a multi-line string or comment?
Barry Warsaw3b3ff4e1997-11-26 20:58:48 +00002041 ((or (and (nth 3 pps) (nth 3 boipps))
2042 (and (nth 4 pps) (nth 4 boipps)))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002043 (save-excursion
2044 (if (not py-align-multiline-strings-p) 0
2045 ;; skip back over blank & non-indenting comment lines
2046 ;; note: will skip a blank or non-indenting comment line
2047 ;; that happens to be a continuation line too
2048 (re-search-backward "^[ \t]*\\([^ \t\n#]\\|#[ \t\n]\\)" nil 'move)
2049 (back-to-indentation)
2050 (current-column))))
2051 ;; are we on a continuation line?
2052 ((py-continuation-line-p)
2053 (let ((startpos (point))
2054 (open-bracket-pos (py-nesting-level))
Barry Warsawce60bc71996-08-01 18:17:14 +00002055 endpos searching found state)
Barry Warsaw095e9c61995-09-19 20:01:42 +00002056 (if open-bracket-pos
2057 (progn
2058 ;; align with first item in list; else a normal
2059 ;; indent beyond the line with the open bracket
2060 (goto-char (1+ open-bracket-pos)) ; just beyond bracket
2061 ;; is the first list item on the same line?
2062 (skip-chars-forward " \t")
2063 (if (null (memq (following-char) '(?\n ?# ?\\)))
2064 ; yes, so line up with it
2065 (current-column)
2066 ;; first list item on another line, or doesn't exist yet
2067 (forward-line 1)
2068 (while (and (< (point) startpos)
2069 (looking-at "[ \t]*[#\n\\\\]")) ; skip noise
2070 (forward-line 1))
Barry Warsaw92166d91998-04-01 21:59:41 +00002071 (if (and (< (point) startpos)
2072 (/= startpos
2073 (save-excursion
2074 (goto-char (1+ open-bracket-pos))
Barry Warsaw77d1fce1998-04-16 20:04:59 +00002075 (forward-comment (point-max))
Barry Warsaw92166d91998-04-01 21:59:41 +00002076 (point))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002077 ;; again mimic the first list item
2078 (current-indentation)
2079 ;; else they're about to enter the first item
2080 (goto-char open-bracket-pos)
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002081 (setq placeholder (point))
2082 (py-goto-initial-line)
2083 (py-goto-beginning-of-tqs
2084 (save-excursion (nth 3 (parse-partial-sexp
2085 placeholder (point)))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002086 (+ (current-indentation) py-indent-offset))))
2087
2088 ;; else on backslash continuation line
2089 (forward-line -1)
2090 (if (py-continuation-line-p) ; on at least 3rd line in block
2091 (current-indentation) ; so just continue the pattern
2092 ;; else started on 2nd line in block, so indent more.
2093 ;; if base line is an assignment with a start on a RHS,
2094 ;; indent to 2 beyond the leftmost "="; else skip first
2095 ;; chunk of non-whitespace characters on base line, + 1 more
2096 ;; column
2097 (end-of-line)
Barry Warsawfd4c9e82001-06-18 23:40:35 +00002098 (setq endpos (point)
2099 searching t)
Barry Warsaw095e9c61995-09-19 20:01:42 +00002100 (back-to-indentation)
2101 (setq startpos (point))
2102 ;; look at all "=" from left to right, stopping at first
2103 ;; one not nested in a list or string
2104 (while searching
2105 (skip-chars-forward "^=" endpos)
2106 (if (= (point) endpos)
2107 (setq searching nil)
2108 (forward-char 1)
2109 (setq state (parse-partial-sexp startpos (point)))
2110 (if (and (zerop (car state)) ; not in a bracket
2111 (null (nth 3 state))) ; & not in a string
2112 (progn
2113 (setq searching nil) ; done searching in any case
2114 (setq found
2115 (not (or
2116 (eq (following-char) ?=)
2117 (memq (char-after (- (point) 2))
2118 '(?< ?> ?!)))))))))
2119 (if (or (not found) ; not an assignment
2120 (looking-at "[ \t]*\\\\")) ; <=><spaces><backslash>
2121 (progn
2122 (goto-char startpos)
2123 (skip-chars-forward "^ \t\n")))
Barry Warsaw40fb4522001-07-06 20:07:13 +00002124 ;; if this is a continuation for a block opening
2125 ;; statement, add some extra offset.
2126 (+ (current-column) (if (py-statement-opens-block-p)
2127 py-continuation-offset 0)
2128 1)
Barry Warsawfd4c9e82001-06-18 23:40:35 +00002129 ))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002130
2131 ;; not on a continuation line
Barry Warsawa7891711996-08-01 15:53:09 +00002132 ((bobp) (current-indentation))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002133
Barry Warsawa7891711996-08-01 15:53:09 +00002134 ;; Dfn: "Indenting comment line". A line containing only a
2135 ;; comment, but which is treated like a statement for
2136 ;; indentation calculation purposes. Such lines are only
2137 ;; treated specially by the mode; they are not treated
2138 ;; specially by the Python interpreter.
2139
2140 ;; The rules for indenting comment lines are a line where:
2141 ;; - the first non-whitespace character is `#', and
2142 ;; - the character following the `#' is whitespace, and
Barry Warsaw41a05c71998-08-10 16:33:12 +00002143 ;; - the line is dedented with respect to (i.e. to the left
Barry Warsawa7891711996-08-01 15:53:09 +00002144 ;; of) the indentation of the preceding non-blank line.
2145
2146 ;; The first non-blank line following an indenting comment
2147 ;; line is given the same amount of indentation as the
2148 ;; indenting comment line.
2149
2150 ;; All other comment-only lines are ignored for indentation
2151 ;; purposes.
2152
2153 ;; Are we looking at a comment-only line which is *not* an
Barry Warsaw145ab1c1998-05-19 14:49:49 +00002154 ;; indenting comment line? If so, we assume that it's been
Barry Warsawa7891711996-08-01 15:53:09 +00002155 ;; placed at the desired indentation, so leave it alone.
2156 ;; Indenting comment lines are aligned as statements down
2157 ;; below.
2158 ((and (looking-at "[ \t]*#[^ \t\n]")
2159 ;; NOTE: this test will not be performed in older Emacsen
2160 (fboundp 'forward-comment)
2161 (<= (current-indentation)
2162 (save-excursion
2163 (forward-comment (- (point-max)))
2164 (current-indentation))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002165 (current-indentation))
2166
2167 ;; else indentation based on that of the statement that
2168 ;; precedes us; use the first line of that statement to
2169 ;; establish the base, in case the user forced a non-std
2170 ;; indentation for the continuation lines (if any)
2171 (t
Barry Warsawc01c5c81995-09-14 18:49:11 +00002172 ;; skip back over blank & non-indenting comment lines note:
2173 ;; will skip a blank or non-indenting comment line that
Barry Warsawfd0fb381996-03-04 17:15:40 +00002174 ;; happens to be a continuation line too. use fast Emacs 19
2175 ;; function if it's there.
Barry Warsaw6d627751996-03-06 18:41:38 +00002176 (if (and (eq py-honor-comment-indentation nil)
Barry Warsaw33d6ec01996-03-05 16:28:07 +00002177 (fboundp 'forward-comment))
Barry Warsawfd0fb381996-03-04 17:15:40 +00002178 (forward-comment (- (point-max)))
Barry Warsaw218eb751998-09-22 19:51:47 +00002179 (let ((prefix-re (concat py-block-comment-prefix "[ \t]*"))
2180 done)
Barry Warsaw6d627751996-03-06 18:41:38 +00002181 (while (not done)
Barry Warsaw12c92941998-08-10 21:44:37 +00002182 (re-search-backward "^[ \t]*\\([^ \t\n#]\\|#\\)" nil 'move)
2183 (setq done (or (bobp)
2184 (and (eq py-honor-comment-indentation t)
2185 (save-excursion
2186 (back-to-indentation)
Barry Warsaw218eb751998-09-22 19:51:47 +00002187 (not (looking-at prefix-re))
Barry Warsaw12c92941998-08-10 21:44:37 +00002188 ))
2189 (and (not (eq py-honor-comment-indentation t))
2190 (save-excursion
2191 (back-to-indentation)
Barry Warsawd36cfe42002-03-15 16:46:46 +00002192 (and (not (looking-at prefix-re))
2193 (or (looking-at "[^#]")
2194 (not (zerop (current-column)))
2195 ))
2196 ))
Barry Warsaw12c92941998-08-10 21:44:37 +00002197 ))
Barry Warsaw6d627751996-03-06 18:41:38 +00002198 )))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002199 ;; if we landed inside a string, go to the beginning of that
2200 ;; string. this handles triple quoted, multi-line spanning
2201 ;; strings.
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002202 (py-goto-beginning-of-tqs (nth 3 (parse-partial-sexp bod (point))))
Barry Warsawc210e691998-01-20 22:52:56 +00002203 ;; now skip backward over continued lines
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002204 (setq placeholder (point))
Barry Warsaw095e9c61995-09-19 20:01:42 +00002205 (py-goto-initial-line)
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002206 ;; we may *now* have landed in a TQS, so find the beginning of
2207 ;; this string.
2208 (py-goto-beginning-of-tqs
2209 (save-excursion (nth 3 (parse-partial-sexp
2210 placeholder (point)))))
Barry Warsawf831d811996-07-31 20:42:59 +00002211 (+ (current-indentation)
2212 (if (py-statement-opens-block-p)
2213 py-indent-offset
Barry Warsaw7cb505c1996-10-23 20:44:59 +00002214 (if (and honor-block-close-p (py-statement-closes-block-p))
Barry Warsawf831d811996-07-31 20:42:59 +00002215 (- py-indent-offset)
2216 0)))
2217 )))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002218
2219(defun py-guess-indent-offset (&optional global)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002220 "Guess a good value for, and change, `py-indent-offset'.
Barry Warsaw41a05c71998-08-10 16:33:12 +00002221
2222By default, make a buffer-local copy of `py-indent-offset' with the
2223new value, so that other Python buffers are not affected. With
2224\\[universal-argument] (programmatically, optional argument GLOBAL),
2225change the global value of `py-indent-offset'. This affects all
2226Python buffers (that don't have their own buffer-local copy), both
2227those currently existing and those created later in the Emacs session.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002228
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002229Some people use a different value for `py-indent-offset' than you use.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002230There's no excuse for such foolishness, but sometimes you have to deal
2231with their ugly code anyway. This function examines the file and sets
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002232`py-indent-offset' to what it thinks it was when they created the
2233mess.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002234
2235Specifically, it searches forward from the statement containing point,
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002236looking for a line that opens a block of code. `py-indent-offset' is
2237set to the difference in indentation between that line and the Python
Barry Warsaw7ae77681994-12-12 20:38:05 +00002238statement following it. If the search doesn't succeed going forward,
2239it's tried again going backward."
2240 (interactive "P") ; raw prefix arg
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002241 (let (new-value
2242 (start (point))
Barry Warsawe908b6b1998-03-19 22:48:02 +00002243 (restart (point))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002244 (found nil)
2245 colon-indent)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002246 (py-goto-initial-line)
2247 (while (not (or found (eobp)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00002248 (when (and (re-search-forward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
2249 (not (py-in-literal restart)))
2250 (setq restart (point))
2251 (py-goto-initial-line)
2252 (if (py-statement-opens-block-p)
2253 (setq found t)
2254 (goto-char restart))))
2255 (unless found
Barry Warsaw7ae77681994-12-12 20:38:05 +00002256 (goto-char start)
2257 (py-goto-initial-line)
2258 (while (not (or found (bobp)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00002259 (setq found (and
2260 (re-search-backward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
2261 (or (py-goto-initial-line) t) ; always true -- side effect
2262 (py-statement-opens-block-p)))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002263 (setq colon-indent (current-indentation)
2264 found (and found (zerop (py-next-statement 1)))
2265 new-value (- (current-indentation) colon-indent))
2266 (goto-char start)
Barry Warsawe908b6b1998-03-19 22:48:02 +00002267 (if (not found)
2268 (error "Sorry, couldn't guess a value for py-indent-offset")
2269 (funcall (if global 'kill-local-variable 'make-local-variable)
2270 'py-indent-offset)
2271 (setq py-indent-offset new-value)
Barry Warsawd35c2551998-09-25 00:08:38 +00002272 (or noninteractive
2273 (message "%s value of py-indent-offset set to %d"
2274 (if global "Global" "Local")
2275 py-indent-offset)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00002276 ))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002277
Barry Warsaw003932a1998-07-07 15:11:24 +00002278(defun py-comment-indent-function ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002279 "Python version of `comment-indent-function'."
2280 ;; This is required when filladapt is turned off. Without it, when
2281 ;; filladapt is not used, comments which start in column zero
2282 ;; cascade one character to the right
Barry Warsaw003932a1998-07-07 15:11:24 +00002283 (save-excursion
2284 (beginning-of-line)
2285 (let ((eol (py-point 'eol)))
2286 (and comment-start-skip
2287 (re-search-forward comment-start-skip eol t)
2288 (setq eol (match-beginning 0)))
2289 (goto-char eol)
2290 (skip-chars-backward " \t")
2291 (max comment-column (+ (current-column) (if (bolp) 0 1)))
2292 )))
2293
Barry Warsawf8ddb6a1999-01-18 21:49:39 +00002294(defun py-narrow-to-defun (&optional class)
2295 "Make text outside current defun invisible.
2296The defun visible is the one that contains point or follows point.
2297Optional CLASS is passed directly to `py-beginning-of-def-or-class'."
2298 (interactive "P")
2299 (save-excursion
2300 (widen)
2301 (py-end-of-def-or-class class)
2302 (let ((end (point)))
2303 (py-beginning-of-def-or-class class)
2304 (narrow-to-region (point) end))))
2305
Barry Warsaw003932a1998-07-07 15:11:24 +00002306
Barry Warsaw7ae77681994-12-12 20:38:05 +00002307(defun py-shift-region (start end count)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002308 "Indent lines from START to END by COUNT spaces."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002309 (save-excursion
Barry Warsaw41a05c71998-08-10 16:33:12 +00002310 (goto-char end)
2311 (beginning-of-line)
2312 (setq end (point))
2313 (goto-char start)
2314 (beginning-of-line)
2315 (setq start (point))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002316 (indent-rigidly start end count)))
2317
2318(defun py-shift-region-left (start end &optional count)
2319 "Shift region of Python code to the left.
2320The lines from the line containing the start of the current region up
2321to (but not including) the line containing the end of the region are
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002322shifted to the left, by `py-indent-offset' columns.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002323
2324If a prefix argument is given, the region is instead shifted by that
Barry Warsaw41a05c71998-08-10 16:33:12 +00002325many columns. With no active region, dedent only the current line.
2326You cannot dedent the region if any line is already at column zero."
Barry Warsawdea4a291996-07-03 22:59:12 +00002327 (interactive
2328 (let ((p (point))
2329 (m (mark))
2330 (arg current-prefix-arg))
2331 (if m
2332 (list (min p m) (max p m) arg)
2333 (list p (save-excursion (forward-line 1) (point)) arg))))
2334 ;; if any line is at column zero, don't shift the region
2335 (save-excursion
2336 (goto-char start)
2337 (while (< (point) end)
2338 (back-to-indentation)
Barry Warsaw71e315b1996-07-23 15:03:16 +00002339 (if (and (zerop (current-column))
2340 (not (looking-at "\\s *$")))
Barry Warsaw41a05c71998-08-10 16:33:12 +00002341 (error "Region is at left edge"))
Barry Warsawdea4a291996-07-03 22:59:12 +00002342 (forward-line 1)))
2343 (py-shift-region start end (- (prefix-numeric-value
2344 (or count py-indent-offset))))
2345 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002346
2347(defun py-shift-region-right (start end &optional count)
2348 "Shift region of Python code to the right.
2349The lines from the line containing the start of the current region up
2350to (but not including) the line containing the end of the region are
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002351shifted to the right, by `py-indent-offset' columns.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002352
2353If a prefix argument is given, the region is instead shifted by that
Barry Warsawdea4a291996-07-03 22:59:12 +00002354many columns. With no active region, indent only the current line."
2355 (interactive
2356 (let ((p (point))
2357 (m (mark))
2358 (arg current-prefix-arg))
2359 (if m
2360 (list (min p m) (max p m) arg)
2361 (list p (save-excursion (forward-line 1) (point)) arg))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002362 (py-shift-region start end (prefix-numeric-value
Barry Warsawdea4a291996-07-03 22:59:12 +00002363 (or count py-indent-offset)))
2364 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002365
2366(defun py-indent-region (start end &optional indent-offset)
2367 "Reindent a region of Python code.
Barry Warsaw867a32a1996-03-07 18:30:26 +00002368
Barry Warsaw7ae77681994-12-12 20:38:05 +00002369The lines from the line containing the start of the current region up
2370to (but not including) the line containing the end of the region are
2371reindented. If the first line of the region has a non-whitespace
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002372character in the first column, the first line is left alone and the
2373rest of the region is reindented with respect to it. Else the entire
Barry Warsaw867a32a1996-03-07 18:30:26 +00002374region is reindented with respect to the (closest code or indenting
2375comment) statement immediately preceding the region.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002376
2377This is useful when code blocks are moved or yanked, when enclosing
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002378control structures are introduced or removed, or to reformat code
2379using a new value for the indentation offset.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002380
2381If a numeric prefix argument is given, it will be used as the value of
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002382the indentation offset. Else the value of `py-indent-offset' will be
Barry Warsaw7ae77681994-12-12 20:38:05 +00002383used.
2384
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002385Warning: The region must be consistently indented before this function
Barry Warsaw7ae77681994-12-12 20:38:05 +00002386is called! This function does not compute proper indentation from
2387scratch (that's impossible in Python), it merely adjusts the existing
2388indentation to be correct in context.
2389
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002390Warning: This function really has no idea what to do with
2391non-indenting comment lines, and shifts them as if they were indenting
2392comment lines. Fixing this appears to require telepathy.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002393
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002394Special cases: whitespace is deleted from blank lines; continuation
2395lines are shifted by the same amount their initial line was shifted,
2396in order to preserve their relative indentation with respect to their
Barry Warsaw7ae77681994-12-12 20:38:05 +00002397initial line; and comment lines beginning in column 1 are ignored."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002398 (interactive "*r\nP") ; region; raw prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00002399 (save-excursion
2400 (goto-char end) (beginning-of-line) (setq end (point-marker))
2401 (goto-char start) (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002402 (let ((py-indent-offset (prefix-numeric-value
2403 (or indent-offset py-indent-offset)))
2404 (indents '(-1)) ; stack of active indent levels
2405 (target-column 0) ; column to which to indent
2406 (base-shifted-by 0) ; amount last base line was shifted
2407 (indent-base (if (looking-at "[ \t\n]")
Barry Warsaw7cb505c1996-10-23 20:44:59 +00002408 (py-compute-indentation t)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002409 0))
2410 ci)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002411 (while (< (point) end)
2412 (setq ci (current-indentation))
2413 ;; figure out appropriate target column
2414 (cond
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002415 ((or (eq (following-char) ?#) ; comment in column 1
2416 (looking-at "[ \t]*$")) ; entirely blank
2417 (setq target-column 0))
2418 ((py-continuation-line-p) ; shift relative to base line
2419 (setq target-column (+ ci base-shifted-by)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002420 (t ; new base line
2421 (if (> ci (car indents)) ; going deeper; push it
2422 (setq indents (cons ci indents))
2423 ;; else we should have seen this indent before
2424 (setq indents (memq ci indents)) ; pop deeper indents
2425 (if (null indents)
2426 (error "Bad indentation in region, at line %d"
2427 (save-restriction
2428 (widen)
2429 (1+ (count-lines 1 (point)))))))
2430 (setq target-column (+ indent-base
2431 (* py-indent-offset
2432 (- (length indents) 2))))
2433 (setq base-shifted-by (- target-column ci))))
2434 ;; shift as needed
2435 (if (/= ci target-column)
2436 (progn
2437 (delete-horizontal-space)
2438 (indent-to target-column)))
2439 (forward-line 1))))
2440 (set-marker end nil))
2441
Barry Warsawa7891711996-08-01 15:53:09 +00002442(defun py-comment-region (beg end &optional arg)
2443 "Like `comment-region' but uses double hash (`#') comment starter."
2444 (interactive "r\nP")
Barry Warsaw3fcaf611996-08-01 20:11:51 +00002445 (let ((comment-start py-block-comment-prefix))
Barry Warsawa7891711996-08-01 15:53:09 +00002446 (comment-region beg end arg)))
2447
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002448
2449;; Functions for moving point
Barry Warsaw7ae77681994-12-12 20:38:05 +00002450(defun py-previous-statement (count)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002451 "Go to the start of the COUNTth preceding Python statement.
2452By default, goes to the previous statement. If there is no such
2453statement, goes to the first statement. Return count of statements
2454left to move. `Statements' do not include blank, comment, or
2455continuation lines."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002456 (interactive "p") ; numeric prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00002457 (if (< count 0) (py-next-statement (- count))
2458 (py-goto-initial-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002459 (let (start)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002460 (while (and
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002461 (setq start (point)) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00002462 (> count 0)
2463 (zerop (forward-line -1))
2464 (py-goto-statement-at-or-above))
2465 (setq count (1- count)))
2466 (if (> count 0) (goto-char start)))
2467 count))
2468
2469(defun py-next-statement (count)
2470 "Go to the start of next Python statement.
2471If the statement at point is the i'th Python statement, goes to the
2472start of statement i+COUNT. If there is no such statement, goes to the
2473last statement. Returns count of statements left to move. `Statements'
2474do not include blank, comment, or continuation lines."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002475 (interactive "p") ; numeric prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00002476 (if (< count 0) (py-previous-statement (- count))
2477 (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002478 (let (start)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002479 (while (and
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002480 (setq start (point)) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00002481 (> count 0)
2482 (py-goto-statement-below))
2483 (setq count (1- count)))
2484 (if (> count 0) (goto-char start)))
2485 count))
2486
2487(defun py-goto-block-up (&optional nomark)
2488 "Move up to start of current block.
2489Go to the statement that starts the smallest enclosing block; roughly
2490speaking, this will be the closest preceding statement that ends with a
2491colon and is indented less than the statement you started on. If
2492successful, also sets the mark to the starting point.
2493
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002494`\\[py-mark-block]' can be used afterward to mark the whole code
2495block, if desired.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002496
2497If called from a program, the mark will not be set if optional argument
2498NOMARK is not nil."
2499 (interactive)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002500 (let ((start (point))
2501 (found nil)
2502 initial-indent)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002503 (py-goto-initial-line)
2504 ;; if on blank or non-indenting comment line, use the preceding stmt
2505 (if (looking-at "[ \t]*\\($\\|#[^ \t\n]\\)")
2506 (progn
2507 (py-goto-statement-at-or-above)
2508 (setq found (py-statement-opens-block-p))))
2509 ;; search back for colon line indented less
2510 (setq initial-indent (current-indentation))
2511 (if (zerop initial-indent)
2512 ;; force fast exit
2513 (goto-char (point-min)))
2514 (while (not (or found (bobp)))
2515 (setq found
2516 (and
2517 (re-search-backward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
2518 (or (py-goto-initial-line) t) ; always true -- side effect
2519 (< (current-indentation) initial-indent)
2520 (py-statement-opens-block-p))))
2521 (if found
2522 (progn
2523 (or nomark (push-mark start))
2524 (back-to-indentation))
2525 (goto-char start)
2526 (error "Enclosing block not found"))))
2527
Barry Warsawab0e86c1998-05-19 15:31:46 +00002528(defun py-beginning-of-def-or-class (&optional class count)
2529 "Move point to start of `def' or `class'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002530
2531Searches back for the closest preceding `def'. If you supply a prefix
Barry Warsawab0e86c1998-05-19 15:31:46 +00002532arg, looks for a `class' instead. The docs below assume the `def'
2533case; just substitute `class' for `def' for the other case.
Barry Warsaw7c29b231998-07-07 17:45:38 +00002534Programmatically, if CLASS is `either', then moves to either `class'
2535or `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002536
Barry Warsawab0e86c1998-05-19 15:31:46 +00002537When second optional argument is given programmatically, move to the
2538COUNTth start of `def'.
2539
2540If point is in a `def' statement already, and after the `d', simply
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002541moves point to the start of the statement.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002542
Barry Warsawab0e86c1998-05-19 15:31:46 +00002543Otherwise (i.e. when point is not in a `def' statement, or at or
2544before the `d' of a `def' statement), searches for the closest
2545preceding `def' statement, and leaves point at its start. If no such
2546statement can be found, leaves point at the start of the buffer.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002547
Barry Warsawab0e86c1998-05-19 15:31:46 +00002548Returns t iff a `def' statement is found by these rules.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002549
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002550Note that doing this command repeatedly will take you closer to the
2551start of the buffer each time.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002552
Barry Warsaw7c29b231998-07-07 17:45:38 +00002553To mark the current `def', see `\\[py-mark-def-or-class]'."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002554 (interactive "P") ; raw prefix arg
Barry Warsaw6839d3a1998-10-28 00:10:45 +00002555 (setq count (or count 1))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002556 (let ((at-or-before-p (<= (current-column) (current-indentation)))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002557 (start-of-line (goto-char (py-point 'bol)))
2558 (start-of-stmt (goto-char (py-point 'bos)))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002559 (start-re (cond ((eq class 'either) "^[ \t]*\\(class\\|def\\)\\>")
2560 (class "^[ \t]*class\\>")
2561 (t "^[ \t]*def\\>")))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002562 )
2563 ;; searching backward
2564 (if (and (< 0 count)
2565 (or (/= start-of-stmt start-of-line)
2566 (not at-or-before-p)))
2567 (end-of-line))
2568 ;; search forward
2569 (if (and (> 0 count)
2570 (zerop (current-column))
2571 (looking-at start-re))
2572 (end-of-line))
Barry Warsawddc46961999-07-27 21:40:02 +00002573 (if (re-search-backward start-re nil 'move count)
2574 (goto-char (match-beginning 0)))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002575
Barry Warsawab0e86c1998-05-19 15:31:46 +00002576;; Backwards compatibility
2577(defalias 'beginning-of-python-def-or-class 'py-beginning-of-def-or-class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002578
Barry Warsawab0e86c1998-05-19 15:31:46 +00002579(defun py-end-of-def-or-class (&optional class count)
2580 "Move point beyond end of `def' or `class' body.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002581
Barry Warsawab0e86c1998-05-19 15:31:46 +00002582By default, looks for an appropriate `def'. If you supply a prefix
2583arg, looks for a `class' instead. The docs below assume the `def'
2584case; just substitute `class' for `def' for the other case.
Barry Warsaw7c29b231998-07-07 17:45:38 +00002585Programmatically, if CLASS is `either', then moves to either `class'
2586or `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002587
Barry Warsawab0e86c1998-05-19 15:31:46 +00002588When second optional argument is given programmatically, move to the
2589COUNTth end of `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002590
Barry Warsawab0e86c1998-05-19 15:31:46 +00002591If point is in a `def' statement already, this is the `def' we use.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002592
Barry Warsawab0e86c1998-05-19 15:31:46 +00002593Else, if the `def' found by `\\[py-beginning-of-def-or-class]'
2594contains the statement you started on, that's the `def' we use.
2595
2596Otherwise, we search forward for the closest following `def', and use that.
2597
2598If a `def' can be found by these rules, point is moved to the start of
2599the line immediately following the `def' block, and the position of the
2600start of the `def' is returned.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002601
2602Else point is moved to the end of the buffer, and nil is returned.
2603
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002604Note that doing this command repeatedly will take you closer to the
2605end of the buffer each time.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002606
Barry Warsaw7c29b231998-07-07 17:45:38 +00002607To mark the current `def', see `\\[py-mark-def-or-class]'."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002608 (interactive "P") ; raw prefix arg
Barry Warsawab0e86c1998-05-19 15:31:46 +00002609 (if (and count (/= count 1))
2610 (py-beginning-of-def-or-class (- 1 count)))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002611 (let ((start (progn (py-goto-initial-line) (point)))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002612 (which (cond ((eq class 'either) "\\(class\\|def\\)")
2613 (class "class")
2614 (t "def")))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002615 (state 'not-found))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002616 ;; move point to start of appropriate def/class
2617 (if (looking-at (concat "[ \t]*" which "\\>")) ; already on one
2618 (setq state 'at-beginning)
Barry Warsawab0e86c1998-05-19 15:31:46 +00002619 ;; else see if py-beginning-of-def-or-class hits container
2620 (if (and (py-beginning-of-def-or-class class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002621 (progn (py-goto-beyond-block)
2622 (> (point) start)))
2623 (setq state 'at-end)
2624 ;; else search forward
2625 (goto-char start)
2626 (if (re-search-forward (concat "^[ \t]*" which "\\>") nil 'move)
2627 (progn (setq state 'at-beginning)
2628 (beginning-of-line)))))
2629 (cond
2630 ((eq state 'at-beginning) (py-goto-beyond-block) t)
2631 ((eq state 'at-end) t)
2632 ((eq state 'not-found) nil)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002633 (t (error "Internal error in `py-end-of-def-or-class'")))))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002634
2635;; Backwards compabitility
Barry Warsaw820273d1998-05-19 15:54:45 +00002636(defalias 'end-of-python-def-or-class 'py-end-of-def-or-class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002637
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002638
2639;; Functions for marking regions
Barry Warsaw7ae77681994-12-12 20:38:05 +00002640(defun py-mark-block (&optional extend just-move)
2641 "Mark following block of lines. With prefix arg, mark structure.
2642Easier to use than explain. It sets the region to an `interesting'
2643block of succeeding lines. If point is on a blank line, it goes down to
2644the next non-blank line. That will be the start of the region. The end
2645of the region depends on the kind of line at the start:
2646
2647 - If a comment, the region will include all succeeding comment lines up
2648 to (but not including) the next non-comment line (if any).
2649
2650 - Else if a prefix arg is given, and the line begins one of these
2651 structures:
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002652
2653 if elif else try except finally for while def class
2654
Barry Warsaw7ae77681994-12-12 20:38:05 +00002655 the region will be set to the body of the structure, including
2656 following blocks that `belong' to it, but excluding trailing blank
2657 and comment lines. E.g., if on a `try' statement, the `try' block
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002658 and all (if any) of the following `except' and `finally' blocks
2659 that belong to the `try' structure will be in the region. Ditto
2660 for if/elif/else, for/else and while/else structures, and (a bit
2661 degenerate, since they're always one-block structures) def and
2662 class blocks.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002663
2664 - Else if no prefix argument is given, and the line begins a Python
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002665 block (see list above), and the block is not a `one-liner' (i.e.,
2666 the statement ends with a colon, not with code), the region will
2667 include all succeeding lines up to (but not including) the next
2668 code statement (if any) that's indented no more than the starting
2669 line, except that trailing blank and comment lines are excluded.
2670 E.g., if the starting line begins a multi-statement `def'
2671 structure, the region will be set to the full function definition,
2672 but without any trailing `noise' lines.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002673
2674 - Else the region will include all succeeding lines up to (but not
2675 including) the next blank line, or code or indenting-comment line
2676 indented strictly less than the starting line. Trailing indenting
2677 comment lines are included in this case, but not trailing blank
2678 lines.
2679
2680A msg identifying the location of the mark is displayed in the echo
2681area; or do `\\[exchange-point-and-mark]' to flip down to the end.
2682
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002683If called from a program, optional argument EXTEND plays the role of
2684the prefix arg, and if optional argument JUST-MOVE is not nil, just
2685moves to the end of the block (& does not set mark or display a msg)."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002686 (interactive "P") ; raw prefix arg
2687 (py-goto-initial-line)
2688 ;; skip over blank lines
2689 (while (and
2690 (looking-at "[ \t]*$") ; while blank line
2691 (not (eobp))) ; & somewhere to go
2692 (forward-line 1))
2693 (if (eobp)
2694 (error "Hit end of buffer without finding a non-blank stmt"))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002695 (let ((initial-pos (point))
2696 (initial-indent (current-indentation))
2697 last-pos ; position of last stmt in region
2698 (followers
2699 '((if elif else) (elif elif else) (else)
2700 (try except finally) (except except) (finally)
2701 (for else) (while else)
2702 (def) (class) ) )
2703 first-symbol next-symbol)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002704
2705 (cond
2706 ;; if comment line, suck up the following comment lines
2707 ((looking-at "[ \t]*#")
2708 (re-search-forward "^[ \t]*[^ \t#]" nil 'move) ; look for non-comment
2709 (re-search-backward "^[ \t]*#") ; and back to last comment in block
2710 (setq last-pos (point)))
2711
2712 ;; else if line is a block line and EXTEND given, suck up
2713 ;; the whole structure
2714 ((and extend
2715 (setq first-symbol (py-suck-up-first-keyword) )
2716 (assq first-symbol followers))
2717 (while (and
2718 (or (py-goto-beyond-block) t) ; side effect
2719 (forward-line -1) ; side effect
2720 (setq last-pos (point)) ; side effect
2721 (py-goto-statement-below)
2722 (= (current-indentation) initial-indent)
2723 (setq next-symbol (py-suck-up-first-keyword))
2724 (memq next-symbol (cdr (assq first-symbol followers))))
2725 (setq first-symbol next-symbol)))
2726
2727 ;; else if line *opens* a block, search for next stmt indented <=
2728 ((py-statement-opens-block-p)
2729 (while (and
2730 (setq last-pos (point)) ; always true -- side effect
2731 (py-goto-statement-below)
Barry Warsawf070cce2002-05-23 19:42:16 +00002732 (> (current-indentation) initial-indent)
2733 )))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002734
2735 ;; else plain code line; stop at next blank line, or stmt or
2736 ;; indenting comment line indented <
2737 (t
2738 (while (and
2739 (setq last-pos (point)) ; always true -- side effect
2740 (or (py-goto-beyond-final-line) t)
2741 (not (looking-at "[ \t]*$")) ; stop at blank line
2742 (or
2743 (>= (current-indentation) initial-indent)
2744 (looking-at "[ \t]*#[^ \t\n]"))) ; ignore non-indenting #
2745 nil)))
2746
2747 ;; skip to end of last stmt
2748 (goto-char last-pos)
2749 (py-goto-beyond-final-line)
2750
2751 ;; set mark & display
2752 (if just-move
2753 () ; just return
2754 (push-mark (point) 'no-msg)
2755 (forward-line -1)
2756 (message "Mark set after: %s" (py-suck-up-leading-text))
2757 (goto-char initial-pos))))
2758
Barry Warsaw2518c671997-11-05 00:51:08 +00002759(defun py-mark-def-or-class (&optional class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002760 "Set region to body of def (or class, with prefix arg) enclosing point.
2761Pushes the current mark, then point, on the mark ring (all language
2762modes do this, but although it's handy it's never documented ...).
2763
2764In most Emacs language modes, this function bears at least a
Barry Warsawab0e86c1998-05-19 15:31:46 +00002765hallucinogenic resemblance to `\\[py-end-of-def-or-class]' and
2766`\\[py-beginning-of-def-or-class]'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002767
2768And in earlier versions of Python mode, all 3 were tightly connected.
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002769Turned out that was more confusing than useful: the `goto start' and
2770`goto end' commands are usually used to search through a file, and
2771people expect them to act a lot like `search backward' and `search
2772forward' string-search commands. But because Python `def' and `class'
2773can nest to arbitrary levels, finding the smallest def containing
2774point cannot be done via a simple backward search: the def containing
2775point may not be the closest preceding def, or even the closest
2776preceding def that's indented less. The fancy algorithm required is
2777appropriate for the usual uses of this `mark' command, but not for the
2778`goto' variations.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002779
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002780So the def marked by this command may not be the one either of the
2781`goto' commands find: If point is on a blank or non-indenting comment
2782line, moves back to start of the closest preceding code statement or
2783indenting comment line. If this is a `def' statement, that's the def
2784we use. Else searches for the smallest enclosing `def' block and uses
2785that. Else signals an error.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002786
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002787When an enclosing def is found: The mark is left immediately beyond
2788the last line of the def block. Point is left at the start of the
2789def, except that: if the def is preceded by a number of comment lines
2790followed by (at most) one optional blank line, point is left at the
2791start of the comments; else if the def is preceded by a blank line,
2792point is left at its start.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002793
2794The intent is to mark the containing def/class and its associated
2795documentation, to make moving and duplicating functions and classes
2796pleasant."
2797 (interactive "P") ; raw prefix arg
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002798 (let ((start (point))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002799 (which (cond ((eq class 'either) "\\(class\\|def\\)")
2800 (class "class")
2801 (t "def"))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002802 (push-mark start)
2803 (if (not (py-go-up-tree-to-keyword which))
2804 (progn (goto-char start)
Barry Warsaw7c29b231998-07-07 17:45:38 +00002805 (error "Enclosing %s not found"
2806 (if (eq class 'either)
2807 "def or class"
2808 which)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002809 ;; else enclosing def/class found
2810 (setq start (point))
2811 (py-goto-beyond-block)
2812 (push-mark (point))
2813 (goto-char start)
2814 (if (zerop (forward-line -1)) ; if there is a preceding line
2815 (progn
2816 (if (looking-at "[ \t]*$") ; it's blank
2817 (setq start (point)) ; so reset start point
2818 (goto-char start)) ; else try again
2819 (if (zerop (forward-line -1))
2820 (if (looking-at "[ \t]*#") ; a comment
2821 ;; look back for non-comment line
2822 ;; tricky: note that the regexp matches a blank
2823 ;; line, cuz \n is in the 2nd character class
2824 (and
2825 (re-search-backward "^[ \t]*[^ \t#]" nil 'move)
2826 (forward-line 1))
2827 ;; no comment, so go back
Barry Warsaw4da6bd51997-11-26 06:00:26 +00002828 (goto-char start)))))))
2829 (exchange-point-and-mark)
2830 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002831
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002832;; ripped from cc-mode
2833(defun py-forward-into-nomenclature (&optional arg)
2834 "Move forward to end of a nomenclature section or word.
Barry Warsaw41a05c71998-08-10 16:33:12 +00002835With \\[universal-argument] (programmatically, optional argument ARG),
2836do it that many times.
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002837
2838A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
2839 (interactive "p")
2840 (let ((case-fold-search nil))
2841 (if (> arg 0)
Barry Warsawc5a8cbd1996-08-05 21:53:02 +00002842 (re-search-forward
2843 "\\(\\W\\|[_]\\)*\\([A-Z]*[a-z0-9]*\\)"
2844 (point-max) t arg)
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002845 (while (and (< arg 0)
2846 (re-search-backward
Barry Warsawc5a8cbd1996-08-05 21:53:02 +00002847 "\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\(\\W\\|[_]\\)\\w+"
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002848 (point-min) 0))
2849 (forward-char 1)
2850 (setq arg (1+ arg)))))
2851 (py-keep-region-active))
2852
2853(defun py-backward-into-nomenclature (&optional arg)
2854 "Move backward to beginning of a nomenclature section or word.
2855With optional ARG, move that many times. If ARG is negative, move
2856forward.
2857
2858A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
2859 (interactive "p")
2860 (py-forward-into-nomenclature (- arg))
2861 (py-keep-region-active))
2862
2863
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002864
Barry Warsaw4f577d22001-04-11 20:23:17 +00002865;; pdbtrack functions
2866(defun py-pdbtrack-toggle-stack-tracking (arg)
2867 (interactive "P")
2868 (if (not (get-buffer-process (current-buffer)))
2869 (error "No process associated with buffer '%s'" (current-buffer)))
2870 ;; missing or 0 is toggle, >0 turn on, <0 turn off
2871 (if (or (not arg)
2872 (zerop (setq arg (prefix-numeric-value arg))))
2873 (setq py-pdbtrack-do-tracking-p (not py-pdbtrack-do-tracking-p))
2874 (setq py-pdbtrack-do-tracking-p (> arg 0)))
2875 (message "%sabled Python's pdbtrack"
2876 (if py-pdbtrack-do-tracking-p "En" "Dis")))
2877
2878(defun turn-on-pdbtrack ()
2879 (interactive)
2880 (py-pdbtrack-toggle-stack-tracking 1))
2881
2882(defun turn-off-pdbtrack ()
2883 (interactive)
2884 (py-pdbtrack-toggle-stack-tracking 0))
2885
2886
2887
Barry Warsaw29a90f02002-04-22 21:48:20 +00002888;; Pychecker
2889(defun py-pychecker-run (command)
2890 "*Run pychecker (default on the file currently visited)."
2891 (interactive
2892 (let ((default
2893 (format "%s %s %s" py-pychecker-command
2894 (mapconcat 'identity py-pychecker-command-args " ")
Barry Warsaw7f232122002-09-28 18:17:56 +00002895 (buffer-file-name)))
2896 (last (when py-pychecker-history
2897 (let* ((lastcmd (car py-pychecker-history))
2898 (cmd (cdr (reverse (split-string lastcmd))))
2899 (newcmd (reverse (cons (buffer-file-name) cmd))))
2900 (mapconcat 'identity newcmd " ")))))
Barry Warsaw29a90f02002-04-22 21:48:20 +00002901
2902 (list
Skip Montanaro302e5502003-12-18 21:53:33 +00002903 (if (fboundp 'read-shell-command)
2904 (read-shell-command "Run pychecker like this: "
2905 (if last
2906 last
2907 default)
2908 'py-pychecker-history)
2909 (read-string "Run pychecker like this: "
2910 (if last
2911 last
2912 default)
2913 'py-pychecker-history))
2914 )))
Barry Warsaw29a90f02002-04-22 21:48:20 +00002915 (save-some-buffers (not py-ask-about-save) nil)
Barry Warsawdaa19212002-07-16 15:56:28 +00002916 (compile-internal command "No more errors"))
Barry Warsaw29a90f02002-04-22 21:48:20 +00002917
2918
2919
2920;; pydoc commands. The guts of this function is stolen from XEmacs's
2921;; symbol-near-point, but without the useless regexp-quote call on the
2922;; results, nor the interactive bit. Also, we've added the temporary
2923;; syntax table setting, which Skip originally had broken out into a
2924;; separate function. Note that Emacs doesn't have the original
2925;; function.
Barry Warsawa7cc43b2002-04-22 17:15:19 +00002926(defun py-symbol-near-point ()
2927 "Return the first textual item to the nearest point."
2928 ;; alg stolen from etag.el
2929 (save-excursion
2930 (with-syntax-table py-dotted-expression-syntax-table
2931 (if (or (bobp) (not (memq (char-syntax (char-before)) '(?w ?_))))
2932 (while (not (looking-at "\\sw\\|\\s_\\|\\'"))
2933 (forward-char 1)))
2934 (while (looking-at "\\sw\\|\\s_")
2935 (forward-char 1))
2936 (if (re-search-backward "\\sw\\|\\s_" nil t)
2937 (progn (forward-char 1)
2938 (buffer-substring (point)
2939 (progn (forward-sexp -1)
2940 (while (looking-at "\\s'")
2941 (forward-char 1))
2942 (point))))
2943 nil))))
2944
2945(defun py-help-at-point ()
2946 "Get help from Python based on the symbol nearest point."
2947 (interactive)
2948 (let* ((sym (py-symbol-near-point))
2949 (base (substring sym 0 (or (search "." sym :from-end t) 0)))
2950 cmd)
2951 (if (not (equal base ""))
2952 (setq cmd (concat "import " base "\n")))
2953 (setq cmd (concat "import pydoc\n"
2954 cmd
Barry Warsaw04949552002-04-22 22:05:49 +00002955 "try: pydoc.help('" sym "')\n"
Barry Warsawa7cc43b2002-04-22 17:15:19 +00002956 "except: print 'No help available on:', \"" sym "\""))
2957 (message cmd)
Barry Warsaw04949552002-04-22 22:05:49 +00002958 (py-execute-string cmd)
2959 (set-buffer "*Python Output*")
2960 ;; BAW: Should we really be leaving the output buffer in help-mode?
2961 (help-mode)))
Barry Warsawa7cc43b2002-04-22 17:15:19 +00002962
2963
2964
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002965;; Documentation functions
Barry Warsaw7ae77681994-12-12 20:38:05 +00002966
2967;; dump the long form of the mode blurb; does the usual doc escapes,
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002968;; plus lines of the form ^[vc]:name$ to suck variable & command docs
2969;; out of the right places, along with the keys they're on & current
2970;; values
Barry Warsaw7ae77681994-12-12 20:38:05 +00002971(defun py-dump-help-string (str)
2972 (with-output-to-temp-buffer "*Help*"
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002973 (let ((locals (buffer-local-variables))
2974 funckind funcname func funcdoc
2975 (start 0) mstart end
2976 keys )
Barry Warsaw7ae77681994-12-12 20:38:05 +00002977 (while (string-match "^%\\([vc]\\):\\(.+\\)\n" str start)
2978 (setq mstart (match-beginning 0) end (match-end 0)
2979 funckind (substring str (match-beginning 1) (match-end 1))
2980 funcname (substring str (match-beginning 2) (match-end 2))
2981 func (intern funcname))
2982 (princ (substitute-command-keys (substring str start mstart)))
2983 (cond
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002984 ((equal funckind "c") ; command
2985 (setq funcdoc (documentation func)
2986 keys (concat
2987 "Key(s): "
2988 (mapconcat 'key-description
2989 (where-is-internal func py-mode-map)
2990 ", "))))
2991 ((equal funckind "v") ; variable
Barry Warsaw604cefa1996-09-03 18:17:04 +00002992 (setq funcdoc (documentation-property func 'variable-documentation)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002993 keys (if (assq func locals)
2994 (concat
2995 "Local/Global values: "
2996 (prin1-to-string (symbol-value func))
2997 " / "
2998 (prin1-to-string (default-value func)))
2999 (concat
3000 "Value: "
3001 (prin1-to-string (symbol-value func))))))
3002 (t ; unexpected
3003 (error "Error in py-dump-help-string, tag `%s'" funckind)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003004 (princ (format "\n-> %s:\t%s\t%s\n\n"
3005 (if (equal funckind "c") "Command" "Variable")
3006 funcname keys))
3007 (princ funcdoc)
3008 (terpri)
3009 (setq start end))
3010 (princ (substitute-command-keys (substring str start))))
3011 (print-help-return-message)))
3012
3013(defun py-describe-mode ()
3014 "Dump long form of Python-mode docs."
3015 (interactive)
3016 (py-dump-help-string "Major mode for editing Python files.
3017Knows about Python indentation, tokens, comments and continuation lines.
3018Paragraphs are separated by blank lines only.
3019
3020Major sections below begin with the string `@'; specific function and
3021variable docs begin with `->'.
3022
3023@EXECUTING PYTHON CODE
3024
Barry Warsaw820273d1998-05-19 15:54:45 +00003025\\[py-execute-import-or-reload]\timports or reloads the file in the Python interpreter
Barry Warsaw7ae77681994-12-12 20:38:05 +00003026\\[py-execute-buffer]\tsends the entire buffer to the Python interpreter
3027\\[py-execute-region]\tsends the current region
Barry Warsaw820273d1998-05-19 15:54:45 +00003028\\[py-execute-def-or-class]\tsends the current function or class definition
3029\\[py-execute-string]\tsends an arbitrary string
Barry Warsaw7ae77681994-12-12 20:38:05 +00003030\\[py-shell]\tstarts a Python interpreter window; this will be used by
Barry Warsaw820273d1998-05-19 15:54:45 +00003031\tsubsequent Python execution commands
3032%c:py-execute-import-or-reload
Barry Warsaw7ae77681994-12-12 20:38:05 +00003033%c:py-execute-buffer
3034%c:py-execute-region
Barry Warsaw820273d1998-05-19 15:54:45 +00003035%c:py-execute-def-or-class
3036%c:py-execute-string
Barry Warsaw7ae77681994-12-12 20:38:05 +00003037%c:py-shell
3038
3039@VARIABLES
3040
3041py-indent-offset\tindentation increment
Barry Warsaw42f707f1996-07-29 21:05:05 +00003042py-block-comment-prefix\tcomment string used by comment-region
Barry Warsaw7ae77681994-12-12 20:38:05 +00003043
3044py-python-command\tshell command to invoke Python interpreter
Barry Warsaw7ae77681994-12-12 20:38:05 +00003045py-temp-directory\tdirectory used for temp files (if needed)
3046
3047py-beep-if-tab-change\tring the bell if tab-width is changed
3048%v:py-indent-offset
3049%v:py-block-comment-prefix
3050%v:py-python-command
Barry Warsaw7ae77681994-12-12 20:38:05 +00003051%v:py-temp-directory
3052%v:py-beep-if-tab-change
3053
3054@KINDS OF LINES
3055
3056Each physical line in the file is either a `continuation line' (the
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003057preceding line ends with a backslash that's not part of a comment, or
3058the paren/bracket/brace nesting level at the start of the line is
3059non-zero, or both) or an `initial line' (everything else).
Barry Warsaw7ae77681994-12-12 20:38:05 +00003060
3061An initial line is in turn a `blank line' (contains nothing except
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003062possibly blanks or tabs), a `comment line' (leftmost non-blank
3063character is `#'), or a `code line' (everything else).
Barry Warsaw7ae77681994-12-12 20:38:05 +00003064
3065Comment Lines
3066
3067Although all comment lines are treated alike by Python, Python mode
3068recognizes two kinds that act differently with respect to indentation.
3069
3070An `indenting comment line' is a comment line with a blank, tab or
3071nothing after the initial `#'. The indentation commands (see below)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003072treat these exactly as if they were code lines: a line following an
Barry Warsaw7ae77681994-12-12 20:38:05 +00003073indenting comment line will be indented like the comment line. All
3074other comment lines (those with a non-whitespace character immediately
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003075following the initial `#') are `non-indenting comment lines', and
3076their indentation is ignored by the indentation commands.
Barry Warsaw7ae77681994-12-12 20:38:05 +00003077
3078Indenting comment lines are by far the usual case, and should be used
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003079whenever possible. Non-indenting comment lines are useful in cases
3080like these:
Barry Warsaw7ae77681994-12-12 20:38:05 +00003081
3082\ta = b # a very wordy single-line comment that ends up being
3083\t #... continued onto another line
3084
3085\tif a == b:
3086##\t\tprint 'panic!' # old code we've `commented out'
3087\t\treturn a
3088
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003089Since the `#...' and `##' comment lines have a non-whitespace
3090character following the initial `#', Python mode ignores them when
3091computing the proper indentation for the next line.
Barry Warsaw7ae77681994-12-12 20:38:05 +00003092
3093Continuation Lines and Statements
3094
3095The Python-mode commands generally work on statements instead of on
3096individual lines, where a `statement' is a comment or blank line, or a
3097code line and all of its following continuation lines (if any)
3098considered as a single logical unit. The commands in this mode
3099generally (when it makes sense) automatically move to the start of the
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003100statement containing point, even if point happens to be in the middle
3101of some continuation line.
Barry Warsaw7ae77681994-12-12 20:38:05 +00003102
3103
3104@INDENTATION
3105
3106Primarily for entering new code:
3107\t\\[indent-for-tab-command]\t indent line appropriately
3108\t\\[py-newline-and-indent]\t insert newline, then indent
Barry Warsaw27ee1151997-12-03 05:03:44 +00003109\t\\[py-electric-backspace]\t reduce indentation, or delete single character
Barry Warsaw7ae77681994-12-12 20:38:05 +00003110
3111Primarily for reindenting existing code:
3112\t\\[py-guess-indent-offset]\t guess py-indent-offset from file content; change locally
3113\t\\[universal-argument] \\[py-guess-indent-offset]\t ditto, but change globally
3114
3115\t\\[py-indent-region]\t reindent region to match its context
3116\t\\[py-shift-region-left]\t shift region left by py-indent-offset
3117\t\\[py-shift-region-right]\t shift region right by py-indent-offset
3118
3119Unlike most programming languages, Python uses indentation, and only
3120indentation, to specify block structure. Hence the indentation supplied
3121automatically by Python-mode is just an educated guess: only you know
3122the block structure you intend, so only you can supply correct
3123indentation.
3124
3125The \\[indent-for-tab-command] and \\[py-newline-and-indent] keys try to suggest plausible indentation, based on
3126the indentation of preceding statements. E.g., assuming
3127py-indent-offset is 4, after you enter
3128\tif a > 0: \\[py-newline-and-indent]
3129the cursor will be moved to the position of the `_' (_ is not a
3130character in the file, it's just used here to indicate the location of
3131the cursor):
3132\tif a > 0:
3133\t _
3134If you then enter `c = d' \\[py-newline-and-indent], the cursor will move
3135to
3136\tif a > 0:
3137\t c = d
3138\t _
3139Python-mode cannot know whether that's what you intended, or whether
3140\tif a > 0:
3141\t c = d
3142\t_
3143was your intent. In general, Python-mode either reproduces the
3144indentation of the (closest code or indenting-comment) preceding
3145statement, or adds an extra py-indent-offset blanks if the preceding
3146statement has `:' as its last significant (non-whitespace and non-
3147comment) character. If the suggested indentation is too much, use
Barry Warsaw27ee1151997-12-03 05:03:44 +00003148\\[py-electric-backspace] to reduce it.
Barry Warsaw7ae77681994-12-12 20:38:05 +00003149
3150Continuation lines are given extra indentation. If you don't like the
3151suggested indentation, change it to something you do like, and Python-
3152mode will strive to indent later lines of the statement in the same way.
3153
3154If a line is a continuation line by virtue of being in an unclosed
3155paren/bracket/brace structure (`list', for short), the suggested
3156indentation depends on whether the current line contains the first item
3157in the list. If it does, it's indented py-indent-offset columns beyond
3158the indentation of the line containing the open bracket. If you don't
3159like that, change it by hand. The remaining items in the list will mimic
3160whatever indentation you give to the first item.
3161
3162If a line is a continuation line because the line preceding it ends with
3163a backslash, the third and following lines of the statement inherit their
3164indentation from the line preceding them. The indentation of the second
3165line in the statement depends on the form of the first (base) line: if
3166the base line is an assignment statement with anything more interesting
3167than the backslash following the leftmost assigning `=', the second line
3168is indented two columns beyond that `='. Else it's indented to two
3169columns beyond the leftmost solid chunk of non-whitespace characters on
3170the base line.
3171
3172Warning: indent-region should not normally be used! It calls \\[indent-for-tab-command]
3173repeatedly, and as explained above, \\[indent-for-tab-command] can't guess the block
3174structure you intend.
3175%c:indent-for-tab-command
3176%c:py-newline-and-indent
Barry Warsaw27ee1151997-12-03 05:03:44 +00003177%c:py-electric-backspace
Barry Warsaw7ae77681994-12-12 20:38:05 +00003178
3179
3180The next function may be handy when editing code you didn't write:
3181%c:py-guess-indent-offset
3182
3183
3184The remaining `indent' functions apply to a region of Python code. They
3185assume the block structure (equals indentation, in Python) of the region
3186is correct, and alter the indentation in various ways while preserving
3187the block structure:
3188%c:py-indent-region
3189%c:py-shift-region-left
3190%c:py-shift-region-right
3191
3192@MARKING & MANIPULATING REGIONS OF CODE
3193
3194\\[py-mark-block]\t mark block of lines
Barry Warsaw2518c671997-11-05 00:51:08 +00003195\\[py-mark-def-or-class]\t mark smallest enclosing def
3196\\[universal-argument] \\[py-mark-def-or-class]\t mark smallest enclosing class
Barry Warsaw42f707f1996-07-29 21:05:05 +00003197\\[comment-region]\t comment out region of code
3198\\[universal-argument] \\[comment-region]\t uncomment region of code
Barry Warsaw7ae77681994-12-12 20:38:05 +00003199%c:py-mark-block
Barry Warsaw2518c671997-11-05 00:51:08 +00003200%c:py-mark-def-or-class
Barry Warsaw42f707f1996-07-29 21:05:05 +00003201%c:comment-region
Barry Warsaw7ae77681994-12-12 20:38:05 +00003202
3203@MOVING POINT
3204
3205\\[py-previous-statement]\t move to statement preceding point
3206\\[py-next-statement]\t move to statement following point
3207\\[py-goto-block-up]\t move up to start of current block
Barry Warsawab0e86c1998-05-19 15:31:46 +00003208\\[py-beginning-of-def-or-class]\t move to start of def
3209\\[universal-argument] \\[py-beginning-of-def-or-class]\t move to start of class
3210\\[py-end-of-def-or-class]\t move to end of def
3211\\[universal-argument] \\[py-end-of-def-or-class]\t move to end of class
Barry Warsaw7ae77681994-12-12 20:38:05 +00003212
3213The first two move to one statement beyond the statement that contains
3214point. A numeric prefix argument tells them to move that many
3215statements instead. Blank lines, comment lines, and continuation lines
3216do not count as `statements' for these commands. So, e.g., you can go
3217to the first code statement in a file by entering
3218\t\\[beginning-of-buffer]\t to move to the top of the file
3219\t\\[py-next-statement]\t to skip over initial comments and blank lines
3220Or do `\\[py-previous-statement]' with a huge prefix argument.
3221%c:py-previous-statement
3222%c:py-next-statement
3223%c:py-goto-block-up
Barry Warsawab0e86c1998-05-19 15:31:46 +00003224%c:py-beginning-of-def-or-class
3225%c:py-end-of-def-or-class
Barry Warsaw7ae77681994-12-12 20:38:05 +00003226
3227@LITTLE-KNOWN EMACS COMMANDS PARTICULARLY USEFUL IN PYTHON MODE
3228
3229`\\[indent-new-comment-line]' is handy for entering a multi-line comment.
3230
3231`\\[set-selective-display]' with a `small' prefix arg is ideally suited for viewing the
3232overall class and def structure of a module.
3233
3234`\\[back-to-indentation]' moves point to a line's first non-blank character.
3235
3236`\\[indent-relative]' is handy for creating odd indentation.
3237
3238@OTHER EMACS HINTS
3239
3240If you don't like the default value of a variable, change its value to
3241whatever you do like by putting a `setq' line in your .emacs file.
3242E.g., to set the indentation increment to 4, put this line in your
3243.emacs:
3244\t(setq py-indent-offset 4)
3245To see the value of a variable, do `\\[describe-variable]' and enter the variable
3246name at the prompt.
3247
3248When entering a key sequence like `C-c C-n', it is not necessary to
3249release the CONTROL key after doing the `C-c' part -- it suffices to
3250press the CONTROL key, press and release `c' (while still holding down
3251CONTROL), press and release `n' (while still holding down CONTROL), &
3252then release CONTROL.
3253
3254Entering Python mode calls with no arguments the value of the variable
3255`python-mode-hook', if that value exists and is not nil; for backward
3256compatibility it also tries `py-mode-hook'; see the `Hooks' section of
3257the Elisp manual for details.
3258
3259Obscure: When python-mode is first loaded, it looks for all bindings
3260to newline-and-indent in the global keymap, and shadows them with
3261local bindings to py-newline-and-indent."))
3262
Barry Warsaw56bd2ed2002-04-25 15:44:17 +00003263(require 'info-look)
Barry Warsaw5dfc7af2002-04-30 18:58:52 +00003264;; The info-look package does not always provide this function (it
3265;; appears this is the case with XEmacs 21.1)
3266(when (fboundp 'info-lookup-maybe-add-help)
3267 (info-lookup-maybe-add-help
3268 :mode 'python-mode
3269 :regexp "[a-zA-Z0-9_]+"
3270 :doc-spec '(("(python-lib)Module Index")
3271 ("(python-lib)Class-Exception-Object Index")
3272 ("(python-lib)Function-Method-Variable Index")
3273 ("(python-lib)Miscellaneous Index")))
3274 )
Barry Warsaw56bd2ed2002-04-25 15:44:17 +00003275
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003276
3277;; Helper functions
Barry Warsaw7ae77681994-12-12 20:38:05 +00003278(defvar py-parse-state-re
3279 (concat
Barry Warsaw644991f2002-10-21 15:58:29 +00003280 "^[ \t]*\\(elif\\|else\\|while\\|def\\|class\\)\\>"
Barry Warsaw7ae77681994-12-12 20:38:05 +00003281 "\\|"
3282 "^[^ #\t\n]"))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003283
Barry Warsaw7ae77681994-12-12 20:38:05 +00003284(defun py-parse-state ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003285 "Return the parse state at point (see `parse-partial-sexp' docs)."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003286 (save-excursion
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00003287 (let ((here (point))
Barry Warsawb2d5e622002-04-22 15:29:27 +00003288 pps done)
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00003289 (while (not done)
3290 ;; back up to the first preceding line (if any; else start of
3291 ;; buffer) that begins with a popular Python keyword, or a
3292 ;; non- whitespace and non-comment character. These are good
3293 ;; places to start parsing to see whether where we started is
3294 ;; at a non-zero nesting level. It may be slow for people who
3295 ;; write huge code blocks or huge lists ... tough beans.
3296 (re-search-backward py-parse-state-re nil 'move)
3297 (beginning-of-line)
Barry Warsawf64b4051998-02-12 16:52:14 +00003298 ;; In XEmacs, we have a much better way to test for whether
3299 ;; we're in a triple-quoted string or not. Emacs does not
Barry Warsaw145ab1c1998-05-19 14:49:49 +00003300 ;; have this built-in function, which is its loss because
Barry Warsawf64b4051998-02-12 16:52:14 +00003301 ;; without scanning from the beginning of the buffer, there's
3302 ;; no accurate way to determine this otherwise.
Barry Warsawb2d5e622002-04-22 15:29:27 +00003303 (save-excursion (setq pps (parse-partial-sexp (point) here)))
3304 ;; make sure we don't land inside a triple-quoted string
3305 (setq done (or (not (nth 3 pps))
3306 (bobp)))
3307 ;; Just go ahead and short circuit the test back to the
3308 ;; beginning of the buffer. This will be slow, but not
3309 ;; nearly as slow as looping through many
3310 ;; re-search-backwards.
3311 (if (not done)
3312 (goto-char (point-min))))
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00003313 pps)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003314
Barry Warsaw7ae77681994-12-12 20:38:05 +00003315(defun py-nesting-level ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003316 "Return the buffer position of the last unclosed enclosing list.
3317If nesting level is zero, return nil."
Barry Warsawf64b4051998-02-12 16:52:14 +00003318 (let ((status (py-parse-state)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003319 (if (zerop (car status))
3320 nil ; not in a nest
3321 (car (cdr status))))) ; char# of open bracket
3322
Barry Warsaw7ae77681994-12-12 20:38:05 +00003323(defun py-backslash-continuation-line-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003324 "Return t iff preceding line ends with backslash that is not in a comment."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003325 (save-excursion
3326 (beginning-of-line)
3327 (and
3328 ;; use a cheap test first to avoid the regexp if possible
3329 ;; use 'eq' because char-after may return nil
3330 (eq (char-after (- (point) 2)) ?\\ )
3331 ;; make sure; since eq test passed, there is a preceding line
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003332 (forward-line -1) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00003333 (looking-at py-continued-re))))
3334
Barry Warsaw7ae77681994-12-12 20:38:05 +00003335(defun py-continuation-line-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003336 "Return t iff current line is a continuation line."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003337 (save-excursion
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003338 (beginning-of-line)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003339 (or (py-backslash-continuation-line-p)
3340 (py-nesting-level))))
3341
Barry Warsaw9c1696c1998-12-15 04:36:22 +00003342(defun py-goto-beginning-of-tqs (delim)
3343 "Go to the beginning of the triple quoted string we find ourselves in.
3344DELIM is the TQS string delimiter character we're searching backwards
3345for."
Barry Warsaw3c34bb32000-10-27 05:00:25 +00003346 (let ((skip (and delim (make-string 1 delim)))
3347 (continue t))
Barry Warsaw9c1696c1998-12-15 04:36:22 +00003348 (when skip
3349 (save-excursion
Barry Warsaw3c34bb32000-10-27 05:00:25 +00003350 (while continue
3351 (py-safe (search-backward skip))
3352 (setq continue (and (not (bobp))
3353 (= (char-before) ?\\))))
3354 (if (and (= (char-before) delim)
3355 (= (char-before (1- (point))) delim))
Barry Warsaw9c1696c1998-12-15 04:36:22 +00003356 (setq skip (make-string 3 delim))))
3357 ;; we're looking at a triple-quoted string
3358 (py-safe (search-backward skip)))))
3359
Barry Warsaw7ae77681994-12-12 20:38:05 +00003360(defun py-goto-initial-line ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003361 "Go to the initial line of the current statement.
3362Usually this is the line we're on, but if we're on the 2nd or
3363following lines of a continuation block, we need to go up to the first
3364line of the block."
3365 ;; Tricky: We want to avoid quadratic-time behavior for long
3366 ;; continued blocks, whether of the backslash or open-bracket
3367 ;; varieties, or a mix of the two. The following manages to do that
3368 ;; in the usual cases.
3369 ;;
3370 ;; Also, if we're sitting inside a triple quoted string, this will
3371 ;; drop us at the line that begins the string.
Barry Warsaw9ec9fbc1998-01-21 05:15:57 +00003372 (let (open-bracket-pos)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003373 (while (py-continuation-line-p)
3374 (beginning-of-line)
3375 (if (py-backslash-continuation-line-p)
3376 (while (py-backslash-continuation-line-p)
3377 (forward-line -1))
3378 ;; else zip out of nested brackets/braces/parens
3379 (while (setq open-bracket-pos (py-nesting-level))
3380 (goto-char open-bracket-pos)))))
3381 (beginning-of-line))
3382
Barry Warsaw7ae77681994-12-12 20:38:05 +00003383(defun py-goto-beyond-final-line ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003384 "Go to the point just beyond the fine line of the current statement.
3385Usually this is the start of the next line, but if this is a
3386multi-line statement we need to skip over the continuation lines."
3387 ;; Tricky: Again we need to be clever to avoid quadratic time
3388 ;; behavior.
3389 ;;
3390 ;; XXX: Not quite the right solution, but deals with multi-line doc
3391 ;; strings
Barry Warsaw751f4931998-05-19 16:06:21 +00003392 (if (looking-at (concat "[ \t]*\\(" py-stringlit-re "\\)"))
3393 (goto-char (match-end 0)))
3394 ;;
Barry Warsaw7ae77681994-12-12 20:38:05 +00003395 (forward-line 1)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003396 (let (state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003397 (while (and (py-continuation-line-p)
3398 (not (eobp)))
3399 ;; skip over the backslash flavor
3400 (while (and (py-backslash-continuation-line-p)
3401 (not (eobp)))
3402 (forward-line 1))
3403 ;; if in nest, zip to the end of the nest
3404 (setq state (py-parse-state))
3405 (if (and (not (zerop (car state)))
3406 (not (eobp)))
3407 (progn
Barry Warsawaffc0ca1997-11-03 16:59:38 +00003408 (parse-partial-sexp (point) (point-max) 0 nil state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003409 (forward-line 1))))))
3410
Barry Warsaw7ae77681994-12-12 20:38:05 +00003411(defun py-statement-opens-block-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003412 "Return t iff the current statement opens a block.
3413I.e., iff it ends with a colon that is not in a comment. Point should
3414be at the start of a statement."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003415 (save-excursion
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003416 (let ((start (point))
3417 (finish (progn (py-goto-beyond-final-line) (1- (point))))
3418 (searching t)
3419 (answer nil)
3420 state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003421 (goto-char start)
3422 (while searching
3423 ;; look for a colon with nothing after it except whitespace, and
3424 ;; maybe a comment
3425 (if (re-search-forward ":\\([ \t]\\|\\\\\n\\)*\\(#.*\\)?$"
3426 finish t)
3427 (if (eq (point) finish) ; note: no `else' clause; just
3428 ; keep searching if we're not at
3429 ; the end yet
3430 ;; sure looks like it opens a block -- but it might
3431 ;; be in a comment
3432 (progn
3433 (setq searching nil) ; search is done either way
3434 (setq state (parse-partial-sexp start
3435 (match-beginning 0)))
3436 (setq answer (not (nth 4 state)))))
3437 ;; search failed: couldn't find another interesting colon
3438 (setq searching nil)))
3439 answer)))
3440
Barry Warsawf831d811996-07-31 20:42:59 +00003441(defun py-statement-closes-block-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003442 "Return t iff the current statement closes a block.
3443I.e., if the line starts with `return', `raise', `break', `continue',
3444and `pass'. This doesn't catch embedded statements."
Barry Warsawf831d811996-07-31 20:42:59 +00003445 (let ((here (point)))
Barry Warsawa8f99ba1999-05-24 18:37:57 +00003446 (py-goto-initial-line)
Barry Warsawc0d2d511999-06-03 22:18:59 +00003447 (back-to-indentation)
Barry Warsawf831d811996-07-31 20:42:59 +00003448 (prog1
Barry Warsawaffc0ca1997-11-03 16:59:38 +00003449 (looking-at (concat py-block-closing-keywords-re "\\>"))
Barry Warsawf831d811996-07-31 20:42:59 +00003450 (goto-char here))))
3451
Barry Warsaw7ae77681994-12-12 20:38:05 +00003452(defun py-goto-beyond-block ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003453 "Go to point just beyond the final line of block begun by the current line.
3454This is the same as where `py-goto-beyond-final-line' goes unless
3455we're on colon line, in which case we go to the end of the block.
3456Assumes point is at the beginning of the line."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003457 (if (py-statement-opens-block-p)
3458 (py-mark-block nil 'just-move)
3459 (py-goto-beyond-final-line)))
3460
Barry Warsaw7ae77681994-12-12 20:38:05 +00003461(defun py-goto-statement-at-or-above ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003462 "Go to the start of the first statement at or preceding point.
3463Return t if there is such a statement, otherwise nil. `Statement'
3464does not include blank lines, comments, or continuation lines."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003465 (py-goto-initial-line)
3466 (if (looking-at py-blank-or-comment-re)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003467 ;; skip back over blank & comment lines
3468 ;; note: will skip a blank or comment line that happens to be
3469 ;; a continuation line too
3470 (if (re-search-backward "^[ \t]*[^ \t#\n]" nil t)
3471 (progn (py-goto-initial-line) t)
3472 nil)
Barry Warsaw7ae77681994-12-12 20:38:05 +00003473 t))
3474
Barry Warsaw7ae77681994-12-12 20:38:05 +00003475(defun py-goto-statement-below ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003476 "Go to start of the first statement following the statement containing point.
3477Return t if there is such a statement, otherwise nil. `Statement'
3478does not include blank lines, comments, or continuation lines."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003479 (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003480 (let ((start (point)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003481 (py-goto-beyond-final-line)
3482 (while (and
Barry Warsawf070cce2002-05-23 19:42:16 +00003483 (or (looking-at py-blank-or-comment-re)
3484 (py-in-literal))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003485 (not (eobp)))
3486 (forward-line 1))
3487 (if (eobp)
3488 (progn (goto-char start) nil)
3489 t)))
3490
Barry Warsaw7ae77681994-12-12 20:38:05 +00003491(defun py-go-up-tree-to-keyword (key)
Barry Warsaw41a05c71998-08-10 16:33:12 +00003492 "Go to begining of statement starting with KEY, at or preceding point.
3493
3494KEY is a regular expression describing a Python keyword. Skip blank
3495lines and non-indenting comments. If the statement found starts with
3496KEY, then stop, otherwise go back to first enclosing block starting
3497with KEY. If successful, leave point at the start of the KEY line and
3498return t. Otherwise, leav point at an undefined place and return nil."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003499 ;; skip blanks and non-indenting #
3500 (py-goto-initial-line)
3501 (while (and
3502 (looking-at "[ \t]*\\($\\|#[^ \t\n]\\)")
3503 (zerop (forward-line -1))) ; go back
3504 nil)
3505 (py-goto-initial-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003506 (let* ((re (concat "[ \t]*" key "\\b"))
3507 (case-fold-search nil) ; let* so looking-at sees this
3508 (found (looking-at re))
3509 (dead nil))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003510 (while (not (or found dead))
3511 (condition-case nil ; in case no enclosing block
3512 (py-goto-block-up 'no-mark)
3513 (error (setq dead t)))
3514 (or dead (setq found (looking-at re))))
3515 (beginning-of-line)
3516 found))
3517
Barry Warsaw7ae77681994-12-12 20:38:05 +00003518(defun py-suck-up-leading-text ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003519 "Return string in buffer from start of indentation to end of line.
3520Prefix with \"...\" if leading whitespace was skipped."
Barry Warsaw7ae77681994-12-12 20:38:05 +00003521 (save-excursion
3522 (back-to-indentation)
3523 (concat
3524 (if (bolp) "" "...")
3525 (buffer-substring (point) (progn (end-of-line) (point))))))
3526
Barry Warsaw7ae77681994-12-12 20:38:05 +00003527(defun py-suck-up-first-keyword ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003528 "Return first keyword on the line as a Lisp symbol.
3529`Keyword' is defined (essentially) as the regular expression
3530([a-z]+). Returns nil if none was found."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003531 (let ((case-fold-search nil))
Barry Warsaw7ae77681994-12-12 20:38:05 +00003532 (if (looking-at "[ \t]*\\([a-z]+\\)\\b")
3533 (intern (buffer-substring (match-beginning 1) (match-end 1)))
3534 nil)))
3535
Barry Warsawb3e81d51996-09-04 15:12:42 +00003536(defun py-current-defun ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003537 "Python value for `add-log-current-defun-function'.
3538This tells add-log.el how to find the current function/method/variable."
Barry Warsawb3e81d51996-09-04 15:12:42 +00003539 (save-excursion
3540 (if (re-search-backward py-defun-start-re nil t)
3541 (or (match-string 3)
3542 (let ((method (match-string 2)))
3543 (if (and (not (zerop (length (match-string 1))))
3544 (re-search-backward py-class-start-re nil t))
3545 (concat (match-string 1) "." method)
3546 method)))
3547 nil)))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003548
3549
Barry Warsawfec75d61995-07-05 23:26:15 +00003550(defconst py-help-address "python-mode@python.org"
Barry Warsaw850437a1995-03-08 21:50:28 +00003551 "Address accepting submission of bug reports.")
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003552
Barry Warsaw850437a1995-03-08 21:50:28 +00003553(defun py-version ()
3554 "Echo the current version of `python-mode' in the minibuffer."
3555 (interactive)
3556 (message "Using `python-mode' version %s" py-version)
3557 (py-keep-region-active))
3558
3559;; only works under Emacs 19
3560;(eval-when-compile
3561; (require 'reporter))
3562
3563(defun py-submit-bug-report (enhancement-p)
3564 "Submit via mail a bug report on `python-mode'.
Barry Warsaw41a05c71998-08-10 16:33:12 +00003565With \\[universal-argument] (programmatically, argument ENHANCEMENT-P
3566non-nil) just submit an enhancement request."
Barry Warsaw850437a1995-03-08 21:50:28 +00003567 (interactive
3568 (list (not (y-or-n-p
Barry Warsaw41a05c71998-08-10 16:33:12 +00003569 "Is this a bug report (hit `n' to send other comments)? "))))
Barry Warsawb5e0ecb1995-03-14 18:32:54 +00003570 (let ((reporter-prompt-for-summary-p (if enhancement-p
3571 "(Very) brief summary: "
3572 t)))
Barry Warsaw850437a1995-03-08 21:50:28 +00003573 (require 'reporter)
3574 (reporter-submit-bug-report
3575 py-help-address ;address
Barry Warsawb5e0ecb1995-03-14 18:32:54 +00003576 (concat "python-mode " py-version) ;pkgname
Barry Warsaw850437a1995-03-08 21:50:28 +00003577 ;; varlist
3578 (if enhancement-p nil
3579 '(py-python-command
3580 py-indent-offset
3581 py-block-comment-prefix
Barry Warsaw850437a1995-03-08 21:50:28 +00003582 py-temp-directory
3583 py-beep-if-tab-change))
3584 nil ;pre-hooks
3585 nil ;post-hooks
3586 "Dear Barry,") ;salutation
3587 (if enhancement-p nil
3588 (set-mark (point))
3589 (insert
3590"Please replace this text with a sufficiently large code sample\n\
3591and an exact recipe so that I can reproduce your problem. Failure\n\
3592to do so may mean a greater delay in fixing your bug.\n\n")
3593 (exchange-point-and-mark)
3594 (py-keep-region-active))))
3595
3596
Barry Warsaw47384781997-11-26 05:27:45 +00003597(defun py-kill-emacs-hook ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003598 "Delete files in `py-file-queue'.
3599These are Python temporary files awaiting execution."
Barry Warsaw47384781997-11-26 05:27:45 +00003600 (mapcar #'(lambda (filename)
3601 (py-safe (delete-file filename)))
3602 py-file-queue))
3603
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003604;; arrange to kill temp files when Emacs exists
Barry Warsawc72c11c1997-08-09 06:42:08 +00003605(add-hook 'kill-emacs-hook 'py-kill-emacs-hook)
Barry Warsaw4f577d22001-04-11 20:23:17 +00003606(add-hook 'comint-output-filter-functions 'py-pdbtrack-track-stack-file)
3607
3608;; Add a designator to the minor mode strings
3609(or (assq 'py-pdbtrack-minor-mode-string minor-mode-alist)
3610 (push '(py-pdbtrack-is-tracking-p py-pdbtrack-minor-mode-string)
3611 minor-mode-alist))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003612
3613
3614
Skip Montanaro6c5bc342002-12-31 16:56:20 +00003615;;; paragraph and string filling code from Bernhard Herzog
3616;;; see http://mail.python.org/pipermail/python-list/2002-May/103189.html
3617
3618(defun py-fill-comment (&optional justify)
3619 "Fill the comment paragraph around point"
3620 (let (;; Non-nil if the current line contains a comment.
3621 has-comment
3622
3623 ;; If has-comment, the appropriate fill-prefix for the comment.
3624 comment-fill-prefix)
3625
3626 ;; Figure out what kind of comment we are looking at.
3627 (save-excursion
3628 (beginning-of-line)
3629 (cond
3630 ;; A line with nothing but a comment on it?
3631 ((looking-at "[ \t]*#[# \t]*")
3632 (setq has-comment t
3633 comment-fill-prefix (buffer-substring (match-beginning 0)
3634 (match-end 0))))
3635
3636 ;; A line with some code, followed by a comment? Remember that the hash
3637 ;; which starts the comment shouldn't be part of a string or character.
3638 ((progn
3639 (while (not (looking-at "#\\|$"))
3640 (skip-chars-forward "^#\n\"'\\")
3641 (cond
3642 ((eq (char-after (point)) ?\\) (forward-char 2))
3643 ((memq (char-after (point)) '(?\" ?')) (forward-sexp 1))))
3644 (looking-at "#+[\t ]*"))
3645 (setq has-comment t)
3646 (setq comment-fill-prefix
3647 (concat (make-string (current-column) ? )
3648 (buffer-substring (match-beginning 0) (match-end 0)))))))
3649
3650 (if (not has-comment)
3651 (fill-paragraph justify)
3652
3653 ;; Narrow to include only the comment, and then fill the region.
3654 (save-restriction
3655 (narrow-to-region
3656
3657 ;; Find the first line we should include in the region to fill.
3658 (save-excursion
3659 (while (and (zerop (forward-line -1))
3660 (looking-at "^[ \t]*#")))
3661
3662 ;; We may have gone to far. Go forward again.
3663 (or (looking-at "^[ \t]*#")
3664 (forward-line 1))
3665 (point))
3666
3667 ;; Find the beginning of the first line past the region to fill.
3668 (save-excursion
3669 (while (progn (forward-line 1)
3670 (looking-at "^[ \t]*#")))
3671 (point)))
3672
3673 ;; Lines with only hashes on them can be paragraph boundaries.
3674 (let ((paragraph-start (concat paragraph-start "\\|[ \t#]*$"))
3675 (paragraph-separate (concat paragraph-separate "\\|[ \t#]*$"))
3676 (fill-prefix comment-fill-prefix))
3677 ;;(message "paragraph-start %S paragraph-separate %S"
3678 ;;paragraph-start paragraph-separate)
3679 (fill-paragraph justify))))
3680 t))
3681
3682
3683(defun py-fill-string (start &optional justify)
3684 "Fill the paragraph around (point) in the string starting at start"
3685 ;; basic strategy: narrow to the string and call the default
3686 ;; implementation
3687 (let (;; the start of the string's contents
3688 string-start
3689 ;; the end of the string's contents
3690 string-end
3691 ;; length of the string's delimiter
3692 delim-length
3693 ;; The string delimiter
3694 delim
3695 )
3696
3697 (save-excursion
3698 (goto-char start)
3699 (if (looking-at "\\('''\\|\"\"\"\\|'\\|\"\\)\\\\?\n?")
3700 (setq string-start (match-end 0)
3701 delim-length (- (match-end 1) (match-beginning 1))
3702 delim (buffer-substring-no-properties (match-beginning 1)
3703 (match-end 1)))
3704 (error "The parameter start is not the beginning of a python string"))
3705
3706 ;; if the string is the first token on a line and doesn't start with
3707 ;; a newline, fill as if the string starts at the beginning of the
3708 ;; line. this helps with one line docstrings
3709 (save-excursion
3710 (beginning-of-line)
3711 (and (/= (char-before string-start) ?\n)
3712 (looking-at (concat "[ \t]*" delim))
3713 (setq string-start (point))))
3714
3715 (forward-sexp (if (= delim-length 3) 2 1))
3716
3717 ;; with both triple quoted strings and single/double quoted strings
3718 ;; we're now directly behind the first char of the end delimiter
3719 ;; (this doesn't work correctly when the triple quoted string
3720 ;; contains the quote mark itself). The end of the string's contents
3721 ;; is one less than point
3722 (setq string-end (1- (point))))
3723
3724 ;; Narrow to the string's contents and fill the current paragraph
3725 (save-restriction
3726 (narrow-to-region string-start string-end)
3727 (let ((ends-with-newline (= (char-before (point-max)) ?\n)))
3728 (fill-paragraph justify)
3729 (if (and (not ends-with-newline)
3730 (= (char-before (point-max)) ?\n))
3731 ;; the default fill-paragraph implementation has inserted a
3732 ;; newline at the end. Remove it again.
3733 (save-excursion
3734 (goto-char (point-max))
3735 (delete-char -1)))))
3736
3737 ;; return t to indicate that we've done our work
3738 t))
3739
3740(defun py-fill-paragraph (&optional justify)
3741 "Like \\[fill-paragraph], but handle Python comments and strings.
3742If any of the current line is a comment, fill the comment or the
3743paragraph of it that point is in, preserving the comment's indentation
3744and initial `#'s.
3745If point is inside a string, narrow to that string and fill.
3746"
3747 (interactive "P")
3748 (let* ((bod (py-point 'bod))
3749 (pps (parse-partial-sexp bod (point))))
3750 (cond
3751 ;; are we inside a comment or on a line with only whitespace before
3752 ;; the comment start?
3753 ((or (nth 4 pps)
3754 (save-excursion (beginning-of-line) (looking-at "[ \t]*#")))
3755 (py-fill-comment justify))
3756 ;; are we inside a string?
3757 ((nth 3 pps)
Skip Montanaro45637692003-07-31 04:59:48 +00003758 (py-fill-string (nth 8 pps)))
Skip Montanaro6c5bc342002-12-31 16:56:20 +00003759 ;; otherwise use the default
3760 (t
3761 (fill-paragraph justify)))))
3762
3763
3764
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003765(provide 'python-mode)
3766;;; python-mode.el ends here