blob: 0bdcfa13cb4060a37dd6a03725fe3cae00d67a12 [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 Warsawf64b4051998-02-12 16:52:14 +00005;; Author: 1995-1998 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 Warsaw38e21e71998-10-27 22:09:25 +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 Warsaw37231521997-12-11 17:23:13 +000028;; This version of python-mode.el is no longer compatible with Emacs
Barry Warsawf7039e21998-08-20 22:10:46 +000029;; 18. I am striving to maintain compatibility with the X/Emacs 19
30;; lineage but as time goes on that becomes more and more difficult.
31;; I current recommend that you upgrade to the latest stable released
Barry Warsaw38e21e71998-10-27 22:09:25 +000032;; version of your favorite branch: Emacs 20.3 or better, or XEmacs
33;; 20.4 or better (XEmacs 21.0 is in beta testing as of this writing
34;; 27-Oct-1998 appears to work fine with this version of
35;; python-mode.el). Even Windows users should be using at least
36;; NTEmacs 20.3, and XEmacs 21.0 will work very nicely on Windows when
37;; it is released.
Barry Warsaw37231521997-12-11 17:23:13 +000038
39;; FOR MORE INFORMATION:
40
Barry Warsawf7039e21998-08-20 22:10:46 +000041;; For more information on installing python-mode.el, especially with
42;; respect to compatibility information, please see
43;;
44;; http://www.python.org/emacs/python-mode/
45;;
46;; This site also contains links to other packages that you might find
47;; useful, such as pdb interfaces, OO-Browser links, etc.
Barry Warsaw37231521997-12-11 17:23:13 +000048
49;; BUG REPORTING:
Barry Warsaw7ae77681994-12-12 20:38:05 +000050
Barry Warsawaffc0ca1997-11-03 16:59:38 +000051;; To submit bug reports, use C-c C-b. Please include a complete, but
52;; concise code sample and a recipe for reproducing the bug. Send
53;; suggestions and other comments to python-mode@python.org.
54
55;; When in a Python mode buffer, do a C-h m for more help. It's
Barry Warsaw37231521997-12-11 17:23:13 +000056;; doubtful that a texinfo manual would be very useful, but if you
57;; want to contribute one, I'll certainly accept it!
Barry Warsawb5e0ecb1995-03-14 18:32:54 +000058
Barry Warsaw37231521997-12-11 17:23:13 +000059;; TO DO LIST:
60
61;; - Better integration with pdb.py and gud-mode for debugging.
Barry Warsawb5e0ecb1995-03-14 18:32:54 +000062;; - Rewrite according to GNU Emacs Lisp standards.
Barry Warsaw9e277db1996-07-31 22:33:40 +000063;; - have py-execute-region on indented code act as if the region is
Barry Warsaw37231521997-12-11 17:23:13 +000064;; left justified. Avoids syntax errors.
65;; - add a py-goto-block-down, bound to C-c C-d
Barry Warsaw7ae77681994-12-12 20:38:05 +000066
Barry Warsaw7b0f5681995-03-08 21:33:04 +000067;;; Code:
68
Barry Warsaw6dfbe5d1998-08-20 21:51:27 +000069(require 'comint)
Barry Warsawc72c11c1997-08-09 06:42:08 +000070(require 'custom)
Barry Warsaw8529ebb1997-12-01 20:03:12 +000071(eval-when-compile
Barry Warsaw673d05f1997-12-02 21:51:57 +000072 (require 'cl)
Barry Warsawb6c1f1f1998-03-19 22:33:06 +000073 (if (not (and (condition-case nil
74 (require 'custom)
75 (error nil))
76 ;; Stock Emacs 19.34 has a broken/old Custom library
77 ;; that does more harm than good. Fortunately, it is
78 ;; missing defcustom
79 (fboundp 'defcustom)))
Barry Warsaw673d05f1997-12-02 21:51:57 +000080 (error "STOP! STOP! STOP! STOP!
81
82The Custom library was not found or is out of date. A more current
83version is required. Please download and install the latest version
84of the Custom library from:
85
86 <http://www.dina.kvl.dk/~abraham/custom/>
87
88See the Python Mode home page for details:
89
Barry Warsaw1d5f9881998-10-28 04:08:13 +000090 <http://www.python.org/emacs/python-mode>
Barry Warsaw673d05f1997-12-02 21:51:57 +000091")))
92
Barry Warsawc72c11c1997-08-09 06:42:08 +000093
Barry Warsaw7b0f5681995-03-08 21:33:04 +000094
95;; user definable variables
96;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
Barry Warsaw7ae77681994-12-12 20:38:05 +000097
Barry Warsawc72c11c1997-08-09 06:42:08 +000098(defgroup python nil
99 "Support for the Python programming language, <http://www.python.org/>"
100 :group 'languages)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000101
Barry Warsawc72c11c1997-08-09 06:42:08 +0000102(defcustom py-python-command "python"
103 "*Shell command used to start Python interpreter."
104 :type 'string
105 :group 'python)
106
Barry Warsawa2398801998-04-09 23:28:20 +0000107(defcustom py-jpython-command "jpython"
108 "*Shell command used to start the JPython interpreter."
109 :type 'string
110 :group 'python)
111
Barry Warsaw8f972b71998-02-05 20:45:49 +0000112(defcustom py-python-command-args '("-i")
113 "*List of string arguments to be used when starting a Python shell."
114 :type '(repeat string)
115 :group 'python)
116
Barry Warsawa2398801998-04-09 23:28:20 +0000117(defcustom py-jpython-command-args '("-i")
118 "*List of string arguments to be used when starting a JPython shell."
119 :type '(repeat string)
120 :group 'python)
121
Barry Warsawc72c11c1997-08-09 06:42:08 +0000122(defcustom py-indent-offset 4
Barry Warsaw41a05c71998-08-10 16:33:12 +0000123 "*Amount of offset per level of indentation.
124`\\[py-guess-indent-offset]' can usually guess a good value when
125you're editing someone else's Python code."
Barry Warsawc72c11c1997-08-09 06:42:08 +0000126 :type 'integer
127 :group 'python)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000128
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
134 1. `py-indent-offset' is guess 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
182When not nil or t, comment lines that begin with a `#' are used as
Barry Warsawc72c11c1997-08-09 06:42:08 +0000183indentation hints, unless the comment character is in column zero."
184 :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")
202 (funcall ok ".")
203 (error
Barry Warsaw6c6db0a1998-02-25 16:33:56 +0000204 "Couldn't find a usable temp directory -- set `py-temp-directory'")))
Barry Warsaw7ae77681994-12-12 20:38:05 +0000205 "*Directory used for temp files created by a *Python* process.
206By default, the first directory from this list that exists and that you
207can write into: the value (if any) of the environment variable TMPDIR,
Barry Warsawc72c11c1997-08-09 06:42:08 +0000208/usr/tmp, /tmp, or the current directory."
209 :type 'string
210 :group 'python)
Barry Warsaw7ae77681994-12-12 20:38:05 +0000211
Barry Warsaw516b6201997-08-09 06:43:20 +0000212(defcustom py-beep-if-tab-change t
Barry Warsaw41a05c71998-08-10 16:33:12 +0000213 "*Ring the bell if `tab-width' is changed.
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000214If a comment of the form
215
216 \t# vi:set tabsize=<number>:
217
218is found before the first code line when the file is entered, and the
219current value of (the general Emacs variable) `tab-width' does not
220equal <number>, `tab-width' is set to <number>, a message saying so is
221displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
Barry Warsawc72c11c1997-08-09 06:42:08 +0000222the Emacs bell is also rung as a warning."
223 :type 'boolean
224 :group 'python)
225
Barry Warsaw9981d221997-12-03 05:25:48 +0000226(defcustom py-jump-on-exception t
227 "*Jump to innermost exception frame in *Python Output* buffer.
Barry Warsaw12c92941998-08-10 21:44:37 +0000228When this variable is non-nil and an exception occurs when running
Barry Warsaw9981d221997-12-03 05:25:48 +0000229Python code synchronously in a subprocess, jump immediately to the
Barry Warsaw12c92941998-08-10 21:44:37 +0000230source code of the innermost traceback frame."
Barry Warsaw3bfed5b1998-05-19 16:25:04 +0000231 :type 'boolean
232 :group 'python)
233
234(defcustom py-ask-about-save t
235 "If not nil, ask about which buffers to save before executing some code.
236Otherwise, all modified buffers are saved without asking."
237 :type 'boolean
238 :group 'python)
Barry Warsaw9981d221997-12-03 05:25:48 +0000239
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000240(defcustom py-backspace-function 'backward-delete-char-untabify
241 "*Function called by `py-electric-backspace' when deleting backwards."
242 :type 'function
243 :group 'python)
244
245(defcustom py-delete-function 'delete-char
246 "*Function called by `py-electric-delete' when deleting forwards."
247 :type 'function
248 :group 'python)
249
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000250(defcustom py-imenu-show-method-args-p nil
251 "*Controls echoing of arguments of functions & methods in the Imenu buffer.
252When non-nil, arguments are printed."
253 :type 'boolean
254 :group 'python)
255(make-variable-buffer-local 'py-indent-offset)
256
Barry Warsawc0ecb531998-01-20 21:43:34 +0000257;; Not customizable
258(defvar py-master-file nil
259 "If non-nil, execute the named file instead of the buffer's file.
Barry Warsaw50b3eb61998-02-25 15:57:47 +0000260The intent is to allow you to set this variable in the file's local
Barry Warsawc0ecb531998-01-20 21:43:34 +0000261variable section, e.g.:
262
263 # Local Variables:
264 # py-master-file: \"master.py\"
265 # End:
266
Barry Warsaw41a05c71998-08-10 16:33:12 +0000267so that typing \\[py-execute-buffer] in that buffer executes the named
Barry Warsaw1bbc0311998-10-27 21:54:56 +0000268master file instead of the buffer's file. If the file name has a
269relative path, the value of variable `default-directory' for the
270buffer is prepended to come up with a file name.")
Barry Warsawc0ecb531998-01-20 21:43:34 +0000271(make-variable-buffer-local 'py-master-file)
272
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000273
Barry Warsawc72c11c1997-08-09 06:42:08 +0000274
275;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
276;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
277
Barry Warsaw5e21cb01997-11-05 18:41:11 +0000278(defconst py-emacs-features
279 (let (features)
280 ;; NTEmacs 19.34.6 has a broken make-temp-name; it always returns
281 ;; the same string.
282 (let ((tmp1 (make-temp-name ""))
283 (tmp2 (make-temp-name "")))
284 (if (string-equal tmp1 tmp2)
285 (push 'broken-temp-names features)))
286 ;; return the features
287 features)
Barry Warsawc12c62e1997-09-04 04:18:07 +0000288 "A list of features extant in the Emacs you are using.
Barry Warsaw6ae21ad1997-11-06 14:36:49 +0000289There are many flavors of Emacs out there, with different levels of
290support for features needed by `python-mode'.")
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000291
Barry Warsawfb07f401997-02-24 03:37:22 +0000292(defvar python-font-lock-keywords
Barry Warsawb8f11661997-11-06 14:35:15 +0000293 (let ((kw1 (mapconcat 'identity
294 '("and" "assert" "break" "class"
295 "continue" "def" "del" "elif"
296 "else" "except" "exec" "for"
297 "from" "global" "if" "import"
298 "in" "is" "lambda" "not"
299 "or" "pass" "print" "raise"
300 "return" "while"
301 )
302 "\\|"))
303 (kw2 (mapconcat 'identity
304 '("else:" "except:" "finally:" "try:")
305 "\\|"))
306 )
Barry Warsaw33ab6e41996-03-05 00:44:31 +0000307 (list
Barry Warsawef3c8911997-11-05 18:55:50 +0000308 ;; keywords
Barry Warsawb8f11661997-11-06 14:35:15 +0000309 (cons (concat "\\b\\(" kw1 "\\)\\b[ \n\t(]") 1)
310 ;; block introducing keywords with immediately following colons.
311 ;; Yes "except" is in both lists.
312 (cons (concat "\\b\\(" kw2 "\\)[ \n\t(]") 1)
Barry Warsaw33ab6e41996-03-05 00:44:31 +0000313 ;; classes
314 '("\\bclass[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"
315 1 font-lock-type-face)
316 ;; functions
317 '("\\bdef[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"
318 1 font-lock-function-name-face)
319 ))
Barry Warsaw62d9d6e1996-03-06 20:32:27 +0000320 "Additional expressions to highlight in Python mode.")
Barry Warsawfb07f401997-02-24 03:37:22 +0000321(put 'python-mode 'font-lock-defaults '(python-font-lock-keywords))
322
Barry Warsawe467bfb1997-11-26 05:40:58 +0000323;; have to bind py-file-queue before installing the kill-emacs-hook
Barry Warsaw7ae77681994-12-12 20:38:05 +0000324(defvar py-file-queue nil
325 "Queue of Python temp files awaiting execution.
326Currently-active file is at the head of the list.")
327
Barry Warsawc72c11c1997-08-09 06:42:08 +0000328
329;; Constants
330
Barry Warsawc72c11c1997-08-09 06:42:08 +0000331(defconst py-stringlit-re
332 (concat
Barry Warsaw751f4931998-05-19 16:06:21 +0000333 ;; These fail if backslash-quote ends the string (not worth
334 ;; fixing?). They precede the short versions so that the first two
335 ;; quotes don't look like an empty short string.
336 ;;
337 ;; (maybe raw), long single quoted triple quoted strings (SQTQ),
338 ;; with potential embedded single quotes
339 "[rR]?'''[^']*\\(\\('[^']\\|''[^']\\)[^']*\\)*'''"
340 "\\|"
341 ;; (maybe raw), long double quoted triple quoted strings (DQTQ),
342 ;; with potential embedded double quotes
343 "[rR]?\"\"\"[^\"]*\\(\\(\"[^\"]\\|\"\"[^\"]\\)[^\"]*\\)*\"\"\""
344 "\\|"
345 "[rR]?'\\([^'\n\\]\\|\\\\.\\)*'" ; single-quoted
Barry Warsawc72c11c1997-08-09 06:42:08 +0000346 "\\|" ; or
Barry Warsaw751f4931998-05-19 16:06:21 +0000347 "[rR]?\"\\([^\"\n\\]\\|\\\\.\\)*\"" ; double-quoted
Barry Warsaw41a05c71998-08-10 16:33:12 +0000348 )
349 "Regular expression matching a Python string literal.")
Barry Warsaw751f4931998-05-19 16:06:21 +0000350
Barry Warsawc72c11c1997-08-09 06:42:08 +0000351(defconst py-continued-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000352 ;; This is tricky because a trailing backslash does not mean
353 ;; continuation if it's in a comment
Barry Warsawc72c11c1997-08-09 06:42:08 +0000354 (concat
355 "\\(" "[^#'\"\n\\]" "\\|" py-stringlit-re "\\)*"
Barry Warsaw41a05c71998-08-10 16:33:12 +0000356 "\\\\$")
357 "Regular expression matching Python backslash continuation lines.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000358
Barry Warsaw41a05c71998-08-10 16:33:12 +0000359(defconst py-blank-or-comment-re "[ \t]*\\($\\|#\\)"
Barry Warsaw71c3adb1998-08-10 16:34:33 +0000360 "Regular expression matching a blank or comment line.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000361
Barry Warsawc72c11c1997-08-09 06:42:08 +0000362(defconst py-outdent-re
363 (concat "\\(" (mapconcat 'identity
364 '("else:"
365 "except\\(\\s +.*\\)?:"
366 "finally:"
367 "elif\\s +.*:")
368 "\\|")
Barry Warsaw41a05c71998-08-10 16:33:12 +0000369 "\\)")
370 "Regular expression matching statements to be dedented one level.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000371
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000372(defconst py-block-closing-keywords-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000373 "\\(return\\|raise\\|break\\|continue\\|pass\\)"
374 "Regular expression matching keywords which typically close a block.")
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000375
Barry Warsawc72c11c1997-08-09 06:42:08 +0000376(defconst py-no-outdent-re
Barry Warsawaffc0ca1997-11-03 16:59:38 +0000377 (concat
378 "\\("
379 (mapconcat 'identity
380 (list "try:"
381 "except\\(\\s +.*\\)?:"
382 "while\\s +.*:"
383 "for\\s +.*:"
384 "if\\s +.*:"
385 "elif\\s +.*:"
386 (concat py-block-closing-keywords-re "[ \t\n]")
387 )
388 "\\|")
Barry Warsaw41a05c71998-08-10 16:33:12 +0000389 "\\)")
390 "Regular expression matching lines not to dedent after.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000391
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000392(defconst py-defun-start-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000393 "^\\([ \t]*\\)def[ \t]+\\([a-zA-Z_0-9]+\\)\\|\\(^[a-zA-Z_0-9]+\\)[ \t]*="
394 ;; If you change this, you probably have to change py-current-defun
395 ;; as well. This is only used by py-current-defun to find the name
396 ;; for add-log.el.
Barry Warsaw71c3adb1998-08-10 16:34:33 +0000397 "Regular expression matching a function, method, or variable assignment.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000398
Barry Warsaw41a05c71998-08-10 16:33:12 +0000399(defconst py-class-start-re "^class[ \t]*\\([a-zA-Z_0-9]+\\)"
400 ;; If you change this, you probably have to change py-current-defun
401 ;; as well. This is only used by py-current-defun to find the name
402 ;; for add-log.el.
403 "Regular expression for finding a class name.")
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000404
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000405(defconst py-traceback-line-re
Barry Warsaw41a05c71998-08-10 16:33:12 +0000406 "[ \t]+File \"\\([^\"]+\\)\", line \\([0-9]+\\)"
407 "Regular expression that describes tracebacks.")
Barry Warsawc72c11c1997-08-09 06:42:08 +0000408
409
410
Barry Warsawc72c11c1997-08-09 06:42:08 +0000411;; Major mode boilerplate
412
Barry Warsaw7ae77681994-12-12 20:38:05 +0000413;; define a mode-specific abbrev table for those who use such things
414(defvar python-mode-abbrev-table nil
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000415 "Abbrev table in use in `python-mode' buffers.")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000416(define-abbrev-table 'python-mode-abbrev-table nil)
417
Barry Warsaw7ae77681994-12-12 20:38:05 +0000418(defvar python-mode-hook nil
419 "*Hook called by `python-mode'.")
420
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000421;; In previous version of python-mode.el, the hook was incorrectly
422;; called py-mode-hook, and was not defvar'd. Deprecate its use.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000423(and (fboundp 'make-obsolete-variable)
424 (make-obsolete-variable 'py-mode-hook 'python-mode-hook))
425
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000426(defvar py-mode-map ()
427 "Keymap used in `python-mode' buffers.")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000428(if py-mode-map
Barry Warsawc72c11c1997-08-09 06:42:08 +0000429 nil
Barry Warsaw7ae77681994-12-12 20:38:05 +0000430 (setq py-mode-map (make-sparse-keymap))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000431 ;; electric keys
432 (define-key py-mode-map ":" 'py-electric-colon)
433 ;; indentation level modifiers
434 (define-key py-mode-map "\C-c\C-l" 'py-shift-region-left)
435 (define-key py-mode-map "\C-c\C-r" 'py-shift-region-right)
436 (define-key py-mode-map "\C-c<" 'py-shift-region-left)
437 (define-key py-mode-map "\C-c>" 'py-shift-region-right)
438 ;; subprocess commands
439 (define-key py-mode-map "\C-c\C-c" 'py-execute-buffer)
Barry Warsaw820273d1998-05-19 15:54:45 +0000440 (define-key py-mode-map "\C-c\C-m" 'py-execute-import-or-reload)
Barry Warsaw1d0364b1998-05-19 16:15:26 +0000441 (define-key py-mode-map "\C-c\C-s" 'py-execute-string)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000442 (define-key py-mode-map "\C-c|" 'py-execute-region)
Barry Warsaw820273d1998-05-19 15:54:45 +0000443 (define-key py-mode-map "\e\C-x" 'py-execute-def-or-class)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000444 (define-key py-mode-map "\C-c!" 'py-shell)
Barry Warsawa2398801998-04-09 23:28:20 +0000445 (define-key py-mode-map "\C-c\C-t" 'py-toggle-shells)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000446 ;; Caution! Enter here at your own risk. We are trying to support
447 ;; several behaviors and it gets disgusting. :-( This logic ripped
448 ;; largely from CC Mode.
449 ;;
450 ;; In XEmacs 19, Emacs 19, and Emacs 20, we use this to bind
451 ;; backwards deletion behavior to DEL, which both Delete and
452 ;; Backspace get translated to. There's no way to separate this
453 ;; behavior in a clean way, so deal with it! Besides, it's been
454 ;; this way since the dawn of time.
455 (if (not (boundp 'delete-key-deletes-forward))
456 (define-key py-mode-map "\177" 'py-electric-backspace)
457 ;; However, XEmacs 20 actually achieved enlightenment. It is
458 ;; possible to sanely define both backward and forward deletion
459 ;; behavior under X separately (TTYs are forever beyond hope, but
460 ;; who cares? XEmacs 20 does the right thing with these too).
461 (define-key py-mode-map [delete] 'py-electric-delete)
462 (define-key py-mode-map [backspace] 'py-electric-backspace))
Barry Warsaw8c4a8de1997-11-26 20:30:33 +0000463 ;; Separate M-BS from C-M-h. The former should remain
464 ;; backward-kill-word.
465 (define-key py-mode-map [(control meta h)] 'py-mark-def-or-class)
Barry Warsaw2518c671997-11-05 00:51:08 +0000466 (define-key py-mode-map "\C-c\C-k" 'py-mark-block)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000467 ;; Miscellaneous
468 (define-key py-mode-map "\C-c:" 'py-guess-indent-offset)
469 (define-key py-mode-map "\C-c\t" 'py-indent-region)
470 (define-key py-mode-map "\C-c\C-n" 'py-next-statement)
471 (define-key py-mode-map "\C-c\C-p" 'py-previous-statement)
472 (define-key py-mode-map "\C-c\C-u" 'py-goto-block-up)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000473 (define-key py-mode-map "\C-c#" 'py-comment-region)
474 (define-key py-mode-map "\C-c?" 'py-describe-mode)
475 (define-key py-mode-map "\C-c\C-hm" 'py-describe-mode)
Barry Warsawab0e86c1998-05-19 15:31:46 +0000476 (define-key py-mode-map "\e\C-a" 'py-beginning-of-def-or-class)
477 (define-key py-mode-map "\e\C-e" 'py-end-of-def-or-class)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000478 (define-key py-mode-map "\C-c-" 'py-up-exception)
479 (define-key py-mode-map "\C-c=" 'py-down-exception)
Barry Warsawf8ddb6a1999-01-18 21:49:39 +0000480 ;; stuff that is `standard' but doesn't interface well with
481 ;; python-mode, which forces us to rebind to special commands
482 (define-key py-mode-map "\C-xnd" 'py-narrow-to-defun)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +0000483 ;; information
484 (define-key py-mode-map "\C-c\C-b" 'py-submit-bug-report)
485 (define-key py-mode-map "\C-c\C-v" 'py-version)
486 ;; py-newline-and-indent mappings
Barry Warsaw82aecb91998-01-21 05:14:24 +0000487 (define-key py-mode-map "\n" 'py-newline-and-indent)
488 (define-key py-mode-map "\C-m" 'py-newline-and-indent)
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000489 ;; shadow global bindings for newline-and-indent w/ the py- version.
490 ;; BAW - this is extremely bad form, but I'm not going to change it
491 ;; for now.
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000492 (mapcar #'(lambda (key)
493 (define-key py-mode-map key 'py-newline-and-indent))
494 (where-is-internal 'newline-and-indent))
495 )
496
497(defvar py-mode-output-map nil
Barry Warsaw41a05c71998-08-10 16:33:12 +0000498 "Keymap used in *Python Output* buffers.")
Barry Warsawa0ee8cd1997-11-26 01:04:44 +0000499(if py-mode-output-map
500 nil
501 (setq py-mode-output-map (make-sparse-keymap))
502 (define-key py-mode-output-map [button2] 'py-mouseto-exception)
503 (define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)
504 ;; TBD: Disable all self-inserting keys. This is bogus, we should
505 ;; really implement this as *Python Output* buffer being read-only
506 (mapcar #' (lambda (key)
507 (define-key py-mode-output-map key
508 #'(lambda () (interactive) (beep))))
509 (where-is-internal 'self-insert-command))
Barry Warsaw850437a1995-03-08 21:50:28 +0000510 )
Barry Warsaw7ae77681994-12-12 20:38:05 +0000511
Barry Warsaw6dfbe5d1998-08-20 21:51:27 +0000512(defvar py-shell-map nil
513 "Keymap used in *Python* shell buffers.")
514(if py-shell-map
515 nil
516 (setq py-shell-map (copy-keymap comint-mode-map))
517 (define-key py-shell-map [tab] 'tab-to-tab-stop)
518 (define-key py-shell-map "\C-c-" 'py-up-exception)
519 (define-key py-shell-map "\C-c=" 'py-down-exception)
520 )
521
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000522(defvar py-mode-syntax-table nil
523 "Syntax table used in `python-mode' buffers.")
Barry Warsaw7ae77681994-12-12 20:38:05 +0000524(if py-mode-syntax-table
Barry Warsawc72c11c1997-08-09 06:42:08 +0000525 nil
Barry Warsaw7ae77681994-12-12 20:38:05 +0000526 (setq py-mode-syntax-table (make-syntax-table))
Barry Warsawc72c11c1997-08-09 06:42:08 +0000527 (modify-syntax-entry ?\( "()" py-mode-syntax-table)
528 (modify-syntax-entry ?\) ")(" py-mode-syntax-table)
529 (modify-syntax-entry ?\[ "(]" py-mode-syntax-table)
530 (modify-syntax-entry ?\] ")[" py-mode-syntax-table)
531 (modify-syntax-entry ?\{ "(}" py-mode-syntax-table)
532 (modify-syntax-entry ?\} "){" py-mode-syntax-table)
533 ;; Add operator symbols misassigned in the std table
534 (modify-syntax-entry ?\$ "." py-mode-syntax-table)
535 (modify-syntax-entry ?\% "." py-mode-syntax-table)
536 (modify-syntax-entry ?\& "." py-mode-syntax-table)
537 (modify-syntax-entry ?\* "." py-mode-syntax-table)
538 (modify-syntax-entry ?\+ "." py-mode-syntax-table)
539 (modify-syntax-entry ?\- "." py-mode-syntax-table)
540 (modify-syntax-entry ?\/ "." py-mode-syntax-table)
541 (modify-syntax-entry ?\< "." py-mode-syntax-table)
542 (modify-syntax-entry ?\= "." py-mode-syntax-table)
543 (modify-syntax-entry ?\> "." py-mode-syntax-table)
544 (modify-syntax-entry ?\| "." py-mode-syntax-table)
545 ;; For historical reasons, underscore is word class instead of
546 ;; symbol class. GNU conventions say it should be symbol class, but
547 ;; there's a natural conflict between what major mode authors want
548 ;; and what users expect from `forward-word' and `backward-word'.
549 ;; Guido and I have hashed this out and have decided to keep
550 ;; underscore in word class. If you're tempted to change it, try
551 ;; binding M-f and M-b to py-forward-into-nomenclature and
552 ;; py-backward-into-nomenclature instead.
553 (modify-syntax-entry ?\_ "w" py-mode-syntax-table)
554 ;; Both single quote and double quote are string delimiters
555 (modify-syntax-entry ?\' "\"" py-mode-syntax-table)
556 (modify-syntax-entry ?\" "\"" py-mode-syntax-table)
557 ;; backquote is open and close paren
558 (modify-syntax-entry ?\` "$" py-mode-syntax-table)
559 ;; comment delimiters
560 (modify-syntax-entry ?\# "<" py-mode-syntax-table)
561 (modify-syntax-entry ?\n ">" py-mode-syntax-table)
562 )
Barry Warsaw7ae77681994-12-12 20:38:05 +0000563
Barry Warsawb3e81d51996-09-04 15:12:42 +0000564
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000565
Barry Warsawbc3760b1998-09-14 16:16:18 +0000566;; Utilities
567
568(defmacro py-safe (&rest body)
569 "Safely execute BODY, return nil if an error occurred."
570 (` (condition-case nil
571 (progn (,@ body))
572 (error nil))))
573
574(defsubst py-keep-region-active ()
575 "Keep the region active in XEmacs."
576 ;; Ignore byte-compiler warnings you might see. Also note that
577 ;; FSF's Emacs 19 does it differently; its policy doesn't require us
578 ;; to take explicit action.
579 (and (boundp 'zmacs-region-stays)
580 (setq zmacs-region-stays t)))
581
582(defsubst py-point (position)
583 "Returns the value of point at certain commonly referenced POSITIONs.
584POSITION can be one of the following symbols:
585
586 bol -- beginning of line
587 eol -- end of line
588 bod -- beginning of def or class
589 eod -- end of def or class
590 bob -- beginning of buffer
591 eob -- end of buffer
592 boi -- back to indentation
593 bos -- beginning of statement
594
595This function does not modify point or mark."
596 (let ((here (point)))
597 (cond
598 ((eq position 'bol) (beginning-of-line))
599 ((eq position 'eol) (end-of-line))
600 ((eq position 'bod) (py-beginning-of-def-or-class))
601 ((eq position 'eod) (py-end-of-def-or-class))
602 ;; Kind of funny, I know, but useful for py-up-exception.
603 ((eq position 'bob) (beginning-of-buffer))
604 ((eq position 'eob) (end-of-buffer))
605 ((eq position 'boi) (back-to-indentation))
606 ((eq position 'bos) (py-goto-initial-line))
607 (t (error "Unknown buffer position requested: %s" position))
608 )
609 (prog1
610 (point)
611 (goto-char here))))
612
613(defsubst py-highlight-line (from to file line)
614 (cond
615 ((fboundp 'make-extent)
616 ;; XEmacs
617 (let ((e (make-extent from to)))
618 (set-extent-property e 'mouse-face 'highlight)
619 (set-extent-property e 'py-exc-info (cons file line))
620 (set-extent-property e 'keymap py-mode-output-map)))
621 (t
622 ;; Emacs -- Please port this!
623 )
624 ))
625
626(defun py-in-literal (&optional lim)
627 "Return non-nil if point is in a Python literal (a comment or string).
628Optional argument LIM indicates the beginning of the containing form,
629i.e. the limit on how far back to scan."
630 ;; This is the version used for non-XEmacs, which has a nicer
631 ;; interface.
632 ;;
633 ;; WARNING: Watch out for infinite recursion.
634 (let* ((lim (or lim (py-point 'bod)))
635 (state (parse-partial-sexp lim (point))))
636 (cond
637 ((nth 3 state) 'string)
638 ((nth 4 state) 'comment)
639 (t nil))))
640
641;; XEmacs has a built-in function that should make this much quicker.
642;; In this case, lim is ignored
643(defun py-fast-in-literal (&optional lim)
644 "Fast version of `py-in-literal', used only by XEmacs.
645Optional LIM is ignored."
646 ;; don't have to worry about context == 'block-comment
647 (buffer-syntactic-context))
648
649(if (fboundp 'buffer-syntactic-context)
650 (defalias 'py-in-literal 'py-fast-in-literal))
651
652
653
Barry Warsaw42f707f1996-07-29 21:05:05 +0000654;; Menu definitions, only relevent if you have the easymenu.el package
655;; (standard in the latest Emacs 19 and XEmacs 19 distributions).
Barry Warsaw5490a061996-08-06 15:43:33 +0000656(defvar py-menu nil
657 "Menu for Python Mode.
Barry Warsawc72c11c1997-08-09 06:42:08 +0000658This menu will get created automatically if you have the `easymenu'
659package. Note that the latest X/Emacs releases contain this package.")
Barry Warsaw5490a061996-08-06 15:43:33 +0000660
Barry Warsawc72c11c1997-08-09 06:42:08 +0000661(and (py-safe (require 'easymenu) t)
662 (easy-menu-define
663 py-menu py-mode-map "Python Mode menu"
664 '("Python"
665 ["Comment Out Region" py-comment-region (mark)]
666 ["Uncomment Region" (py-comment-region (point) (mark) '(4)) (mark)]
667 "-"
668 ["Mark current block" py-mark-block t]
Barry Warsaw2518c671997-11-05 00:51:08 +0000669 ["Mark current def" py-mark-def-or-class t]
670 ["Mark current class" (py-mark-def-or-class t) t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000671 "-"
672 ["Shift region left" py-shift-region-left (mark)]
673 ["Shift region right" py-shift-region-right (mark)]
674 "-"
Barry Warsaw820273d1998-05-19 15:54:45 +0000675 ["Import/reload file" py-execute-import-or-reload t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000676 ["Execute buffer" py-execute-buffer t]
677 ["Execute region" py-execute-region (mark)]
Barry Warsaw820273d1998-05-19 15:54:45 +0000678 ["Execute def or class" py-execute-def-or-class (mark)]
Barry Warsaw1d0364b1998-05-19 16:15:26 +0000679 ["Execute string" py-execute-string t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000680 ["Start interpreter..." py-shell t]
681 "-"
682 ["Go to start of block" py-goto-block-up t]
Barry Warsawab0e86c1998-05-19 15:31:46 +0000683 ["Go to start of class" (py-beginning-of-def-or-class t) t]
684 ["Move to end of class" (py-end-of-def-or-class t) t]
685 ["Move to start of def" py-beginning-of-def-or-class t]
686 ["Move to end of def" py-end-of-def-or-class t]
Barry Warsawc72c11c1997-08-09 06:42:08 +0000687 "-"
688 ["Describe mode" py-describe-mode t]
689 )))
Barry Warsaw42f707f1996-07-29 21:05:05 +0000690
Barry Warsaw81437461996-08-01 19:48:02 +0000691
692
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000693;; Imenu definitions
694(defvar py-imenu-class-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000695 (concat ; <<classes>>
696 "\\(" ;
697 "^[ \t]*" ; newline and maybe whitespace
698 "\\(class[ \t]+[a-zA-Z0-9_]+\\)" ; class name
699 ; possibly multiple superclasses
Barry Warsaw3179fe01998-04-04 21:36:53 +0000700 "\\([ \t]*\\((\\([a-zA-Z0-9_,. \t\n]\\)*)\\)?\\)"
Barry Warsaw81437461996-08-01 19:48:02 +0000701 "[ \t]*:" ; and the final :
702 "\\)" ; >>classes<<
703 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000704 "Regexp for Python classes for use with the Imenu package."
Barry Warsaw81437461996-08-01 19:48:02 +0000705 )
706
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000707(defvar py-imenu-method-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000708 (concat ; <<methods and functions>>
709 "\\(" ;
710 "^[ \t]*" ; new line and maybe whitespace
711 "\\(def[ \t]+" ; function definitions start with def
712 "\\([a-zA-Z0-9_]+\\)" ; name is here
713 ; function arguments...
Barry Warsaw1d5f9881998-10-28 04:08:13 +0000714;; "[ \t]*(\\([-+/a-zA-Z0-9_=,\* \t\n.()\"'#]*\\))"
715 "[ \t]*(\\([^:#]*\\))"
Barry Warsaw81437461996-08-01 19:48:02 +0000716 "\\)" ; end of def
717 "[ \t]*:" ; and then the :
718 "\\)" ; >>methods and functions<<
719 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000720 "Regexp for Python methods/functions for use with the Imenu package."
Barry Warsaw81437461996-08-01 19:48:02 +0000721 )
722
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000723(defvar py-imenu-method-no-arg-parens '(2 8)
724 "Indices into groups of the Python regexp for use with Imenu.
Barry Warsaw81437461996-08-01 19:48:02 +0000725
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000726Using these values will result in smaller Imenu lists, as arguments to
Barry Warsaw81437461996-08-01 19:48:02 +0000727functions are not listed.
728
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000729See the variable `py-imenu-show-method-args-p' for more
Barry Warsaw81437461996-08-01 19:48:02 +0000730information.")
731
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000732(defvar py-imenu-method-arg-parens '(2 7)
Barry Warsaw1bbc0311998-10-27 21:54:56 +0000733 "Indices into groups of the Python regexp for use with imenu.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000734Using these values will result in large Imenu lists, as arguments to
Barry Warsaw81437461996-08-01 19:48:02 +0000735functions are listed.
736
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000737See the variable `py-imenu-show-method-args-p' for more
Barry Warsaw81437461996-08-01 19:48:02 +0000738information.")
739
740;; Note that in this format, this variable can still be used with the
741;; imenu--generic-function. Otherwise, there is no real reason to have
742;; it.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000743(defvar py-imenu-generic-expression
Barry Warsaw81437461996-08-01 19:48:02 +0000744 (cons
745 (concat
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000746 py-imenu-class-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000747 "\\|" ; or...
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000748 py-imenu-method-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000749 )
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000750 py-imenu-method-no-arg-parens)
751 "Generic Python expression which may be used directly with Imenu.
Barry Warsaw81437461996-08-01 19:48:02 +0000752Used by setting the variable `imenu-generic-expression' to this value.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000753Also, see the function \\[py-imenu-create-index] for a better
754alternative for finding the index.")
Barry Warsaw81437461996-08-01 19:48:02 +0000755
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000756;; These next two variables are used when searching for the Python
Barry Warsaw81437461996-08-01 19:48:02 +0000757;; class/definitions. Just saving some time in accessing the
758;; generic-python-expression, really.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000759(defvar py-imenu-generic-regexp nil)
760(defvar py-imenu-generic-parens nil)
Barry Warsaw81437461996-08-01 19:48:02 +0000761
762
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000763(defun py-imenu-create-index-function ()
764 "Python interface function for the Imenu package.
765Finds all Python classes and functions/methods. Calls function
766\\[py-imenu-create-index-engine]. See that function for the details
767of how this works."
768 (setq py-imenu-generic-regexp (car py-imenu-generic-expression)
769 py-imenu-generic-parens (if py-imenu-show-method-args-p
770 py-imenu-method-arg-parens
771 py-imenu-method-no-arg-parens))
Barry Warsaw81437461996-08-01 19:48:02 +0000772 (goto-char (point-min))
Barry Warsaw1d5f9881998-10-28 04:08:13 +0000773 ;; Warning: When the buffer has no classes or functions, this will
774 ;; return nil, which seems proper according to the Imenu API, but
775 ;; causes an error in the XEmacs port of Imenu. Sigh.
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000776 (py-imenu-create-index-engine nil))
Barry Warsaw81437461996-08-01 19:48:02 +0000777
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000778(defun py-imenu-create-index-engine (&optional start-indent)
779 "Function for finding Imenu definitions in Python.
Barry Warsaw81437461996-08-01 19:48:02 +0000780
781Finds all definitions (classes, methods, or functions) in a Python
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000782file for the Imenu package.
Barry Warsaw81437461996-08-01 19:48:02 +0000783
784Returns a possibly nested alist of the form
785
786 (INDEX-NAME . INDEX-POSITION)
787
788The second element of the alist may be an alist, producing a nested
789list as in
790
791 (INDEX-NAME . INDEX-ALIST)
792
793This function should not be called directly, as it calls itself
794recursively and requires some setup. Rather this is the engine for
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000795the function \\[py-imenu-create-index-function].
Barry Warsaw81437461996-08-01 19:48:02 +0000796
797It works recursively by looking for all definitions at the current
798indention level. When it finds one, it adds it to the alist. If it
799finds a definition at a greater indentation level, it removes the
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000800previous definition from the alist. In its place it adds all
Barry Warsaw81437461996-08-01 19:48:02 +0000801definitions found at the next indentation level. When it finds a
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000802definition that is less indented then the current level, it returns
803the alist it has created thus far.
Barry Warsaw81437461996-08-01 19:48:02 +0000804
805The optional argument START-INDENT indicates the starting indentation
806at which to continue looking for Python classes, methods, or
807functions. If this is not supplied, the function uses the indentation
808of the first definition found."
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000809 (let (index-alist
810 sub-method-alist
Barry Warsaw81437461996-08-01 19:48:02 +0000811 looking-p
812 def-name prev-name
813 cur-indent def-pos
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000814 (class-paren (first py-imenu-generic-parens))
815 (def-paren (second py-imenu-generic-parens)))
Barry Warsaw81437461996-08-01 19:48:02 +0000816 (setq looking-p
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000817 (re-search-forward py-imenu-generic-regexp (point-max) t))
Barry Warsaw81437461996-08-01 19:48:02 +0000818 (while looking-p
819 (save-excursion
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000820 ;; used to set def-name to this value but generic-extract-name
821 ;; is new to imenu-1.14. this way it still works with
822 ;; imenu-1.11
823 ;;(imenu--generic-extract-name py-imenu-generic-parens))
Barry Warsaw81437461996-08-01 19:48:02 +0000824 (let ((cur-paren (if (match-beginning class-paren)
825 class-paren def-paren)))
826 (setq def-name
Barry Warsawc8520351997-11-26 06:14:40 +0000827 (buffer-substring-no-properties (match-beginning cur-paren)
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000828 (match-end cur-paren))))
Barry Warsaw93c88cc1998-08-18 02:00:44 +0000829 (save-match-data
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000830 (py-beginning-of-def-or-class 'either))
Barry Warsaw81437461996-08-01 19:48:02 +0000831 (beginning-of-line)
832 (setq cur-indent (current-indentation)))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000833 ;; HACK: want to go to the next correct definition location. We
834 ;; explicitly list them here but it would be better to have them
835 ;; in a list.
Barry Warsaw81437461996-08-01 19:48:02 +0000836 (setq def-pos
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000837 (or (match-beginning class-paren)
838 (match-beginning def-paren)))
Barry Warsaw81437461996-08-01 19:48:02 +0000839 ;; if we don't have a starting indent level, take this one
840 (or start-indent
841 (setq start-indent cur-indent))
Barry Warsaw81437461996-08-01 19:48:02 +0000842 ;; if we don't have class name yet, take this one
843 (or prev-name
844 (setq prev-name def-name))
Barry Warsaw81437461996-08-01 19:48:02 +0000845 ;; what level is the next definition on? must be same, deeper
846 ;; or shallower indentation
847 (cond
848 ;; at the same indent level, add it to the list...
849 ((= start-indent cur-indent)
Barry Warsaw81437461996-08-01 19:48:02 +0000850 (push (cons def-name def-pos) index-alist))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000851 ;; deeper indented expression, recurse
Barry Warsaw81437461996-08-01 19:48:02 +0000852 ((< start-indent cur-indent)
Barry Warsaw81437461996-08-01 19:48:02 +0000853 ;; the point is currently on the expression we're supposed to
854 ;; start on, so go back to the last expression. The recursive
855 ;; call will find this place again and add it to the correct
856 ;; list
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000857 (re-search-backward py-imenu-generic-regexp (point-min) 'move)
858 (setq sub-method-alist (py-imenu-create-index-engine cur-indent))
Barry Warsaw81437461996-08-01 19:48:02 +0000859 (if sub-method-alist
860 ;; we put the last element on the index-alist on the start
861 ;; of the submethod alist so the user can still get to it.
862 (let ((save-elmt (pop index-alist)))
Barry Warsawc8520351997-11-26 06:14:40 +0000863 (push (cons prev-name
Barry Warsaw81437461996-08-01 19:48:02 +0000864 (cons save-elmt sub-method-alist))
865 index-alist))))
Barry Warsaw81437461996-08-01 19:48:02 +0000866 ;; found less indented expression, we're done.
867 (t
868 (setq looking-p nil)
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000869 (re-search-backward py-imenu-generic-regexp (point-min) t)))
870 ;; end-cond
Barry Warsaw81437461996-08-01 19:48:02 +0000871 (setq prev-name def-name)
872 (and looking-p
873 (setq looking-p
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000874 (re-search-forward py-imenu-generic-regexp
Barry Warsaw81437461996-08-01 19:48:02 +0000875 (point-max) 'move))))
876 (nreverse index-alist)))
877
Barry Warsaw42f707f1996-07-29 21:05:05 +0000878
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000879;;;###autoload
Barry Warsaw7ae77681994-12-12 20:38:05 +0000880(defun python-mode ()
881 "Major mode for editing Python files.
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000882To submit a problem report, enter `\\[py-submit-bug-report]' from a
883`python-mode' buffer. Do `\\[py-describe-mode]' for detailed
884documentation. To see what version of `python-mode' you are running,
885enter `\\[py-version]'.
886
887This mode knows about Python indentation, tokens, comments and
888continuation lines. Paragraphs are separated by blank lines only.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000889
890COMMANDS
891\\{py-mode-map}
892VARIABLES
893
Barry Warsaw42f707f1996-07-29 21:05:05 +0000894py-indent-offset\t\tindentation increment
Barry Warsaw41a05c71998-08-10 16:33:12 +0000895py-block-comment-prefix\t\tcomment string used by `comment-region'
Barry Warsaw42f707f1996-07-29 21:05:05 +0000896py-python-command\t\tshell command to invoke Python interpreter
Barry Warsaw42f707f1996-07-29 21:05:05 +0000897py-temp-directory\t\tdirectory used for temp files (if needed)
Barry Warsaw41a05c71998-08-10 16:33:12 +0000898py-beep-if-tab-change\t\tring the bell if `tab-width' is changed"
Barry Warsaw7ae77681994-12-12 20:38:05 +0000899 (interactive)
Barry Warsaw615d4a41996-09-04 14:14:10 +0000900 ;; set up local variables
Barry Warsaw7ae77681994-12-12 20:38:05 +0000901 (kill-all-local-variables)
Barry Warsaw615d4a41996-09-04 14:14:10 +0000902 (make-local-variable 'font-lock-defaults)
903 (make-local-variable 'paragraph-separate)
904 (make-local-variable 'paragraph-start)
905 (make-local-variable 'require-final-newline)
906 (make-local-variable 'comment-start)
Barry Warsaw5c8bef11996-12-17 21:56:10 +0000907 (make-local-variable 'comment-end)
Barry Warsaw615d4a41996-09-04 14:14:10 +0000908 (make-local-variable 'comment-start-skip)
909 (make-local-variable 'comment-column)
Barry Warsaw003932a1998-07-07 15:11:24 +0000910 (make-local-variable 'comment-indent-function)
Barry Warsaw615d4a41996-09-04 14:14:10 +0000911 (make-local-variable 'indent-region-function)
912 (make-local-variable 'indent-line-function)
Barry Warsawb3e81d51996-09-04 15:12:42 +0000913 (make-local-variable 'add-log-current-defun-function)
Barry Warsaw615d4a41996-09-04 14:14:10 +0000914 ;;
Barry Warsaw7ae77681994-12-12 20:38:05 +0000915 (set-syntax-table py-mode-syntax-table)
Barry Warsaw003932a1998-07-07 15:11:24 +0000916 (setq major-mode 'python-mode
917 mode-name "Python"
918 local-abbrev-table python-mode-abbrev-table
919 font-lock-defaults '(python-font-lock-keywords)
920 paragraph-separate "^[ \t]*$"
921 paragraph-start "^[ \t]*$"
922 require-final-newline t
923 comment-start "# "
924 comment-end ""
925 comment-start-skip "# *"
926 comment-column 40
927 comment-indent-function 'py-comment-indent-function
928 indent-region-function 'py-indent-region
929 indent-line-function 'py-indent-line
Barry Warsawb3e81d51996-09-04 15:12:42 +0000930 ;; tell add-log.el how to find the current function/method/variable
931 add-log-current-defun-function 'py-current-defun
Barry Warsawb1f89511996-09-03 16:38:30 +0000932 )
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000933 (use-local-map py-mode-map)
Barry Warsaw42f707f1996-07-29 21:05:05 +0000934 ;; add the menu
935 (if py-menu
936 (easy-menu-add py-menu))
Barry Warsaw57697af1995-09-14 20:01:14 +0000937 ;; Emacs 19 requires this
Barry Warsawc72c11c1997-08-09 06:42:08 +0000938 (if (boundp 'comment-multi-line)
Barry Warsaw57697af1995-09-14 20:01:14 +0000939 (setq comment-multi-line nil))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000940 ;; Install Imenu if available
Barry Warsaw742a5111998-03-13 17:29:15 +0000941 (when (py-safe (require 'imenu))
Barry Warsaw6839d3a1998-10-28 00:10:45 +0000942 (setq imenu-create-index-function #'py-imenu-create-index-function)
943 (setq imenu-generic-expression py-imenu-generic-expression)
Barry Warsaw742a5111998-03-13 17:29:15 +0000944 (if (fboundp 'imenu-add-to-menubar)
945 (imenu-add-to-menubar (format "%s-%s" "IM" mode-name)))
946 )
947 ;; Run the mode hook. Note that py-mode-hook is deprecated.
Barry Warsaw7ae77681994-12-12 20:38:05 +0000948 (if python-mode-hook
949 (run-hooks 'python-mode-hook)
Barry Warsaw742a5111998-03-13 17:29:15 +0000950 (run-hooks 'py-mode-hook))
951 ;; Now do the automagical guessing
952 (if py-smart-indentation
953 (let ((offset py-indent-offset))
Barry Warsaw145ab1c1998-05-19 14:49:49 +0000954 ;; It's okay if this fails to guess a good value
Barry Warsaw742a5111998-03-13 17:29:15 +0000955 (if (and (py-safe (py-guess-indent-offset))
956 (<= py-indent-offset 8)
957 (>= py-indent-offset 2))
958 (setq offset py-indent-offset))
959 (setq py-indent-offset offset)
Barry Warsaw639eea61998-03-16 18:12:13 +0000960 ;; Only turn indent-tabs-mode off if tab-width !=
961 ;; py-indent-offset. Never turn it on, because the user must
962 ;; have explicitly turned it off.
963 (if (/= tab-width py-indent-offset)
964 (setq indent-tabs-mode nil))
Barry Warsaw742a5111998-03-13 17:29:15 +0000965 )))
Barry Warsaw7ae77681994-12-12 20:38:05 +0000966
Barry Warsaw7b0f5681995-03-08 21:33:04 +0000967
Barry Warsawb91b7431995-03-14 15:55:20 +0000968;; electric characters
Barry Warsaw3874a3d1995-03-14 22:05:53 +0000969(defun py-outdent-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +0000970 "Returns non-nil if the current line should dedent one level."
Barry Warsaw3874a3d1995-03-14 22:05:53 +0000971 (save-excursion
972 (and (progn (back-to-indentation)
973 (looking-at py-outdent-re))
Barry Warsaw1a1c6bb1999-01-09 17:22:38 +0000974 ;; short circuit infloop on illegal construct
975 (not (bobp))
Barry Warsawf06777d1998-01-21 05:36:18 +0000976 (progn (forward-line -1)
977 (py-goto-initial-line)
978 (back-to-indentation)
Barry Warsaw3874a3d1995-03-14 22:05:53 +0000979 (while (or (looking-at py-blank-or-comment-re)
980 (bobp))
981 (backward-to-indentation 1))
982 (not (looking-at py-no-outdent-re)))
983 )))
984
Barry Warsawb91b7431995-03-14 15:55:20 +0000985(defun py-electric-colon (arg)
986 "Insert a colon.
Barry Warsaw41a05c71998-08-10 16:33:12 +0000987In certain cases the line is dedented appropriately. If a numeric
988argument ARG is provided, that many colons are inserted
989non-electrically. Electric behavior is inhibited inside a string or
990comment."
Barry Warsawb91b7431995-03-14 15:55:20 +0000991 (interactive "P")
992 (self-insert-command (prefix-numeric-value arg))
Barry Warsaw0c6563f1995-09-14 20:57:02 +0000993 ;; are we in a string or comment?
994 (if (save-excursion
995 (let ((pps (parse-partial-sexp (save-excursion
Barry Warsawab0e86c1998-05-19 15:31:46 +0000996 (py-beginning-of-def-or-class)
Barry Warsaw0c6563f1995-09-14 20:57:02 +0000997 (point))
998 (point))))
999 (not (or (nth 3 pps) (nth 4 pps)))))
1000 (save-excursion
1001 (let ((here (point))
1002 (outdent 0)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001003 (indent (py-compute-indentation t)))
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001004 (if (and (not arg)
1005 (py-outdent-p)
1006 (= indent (save-excursion
Barry Warsawa7661821996-08-02 16:22:43 +00001007 (py-next-statement -1)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001008 (py-compute-indentation t)))
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001009 )
1010 (setq outdent py-indent-offset))
Barry Warsaw41a05c71998-08-10 16:33:12 +00001011 ;; Don't indent, only dedent. This assumes that any lines
1012 ;; that are already dedented relative to
1013 ;; py-compute-indentation were put there on purpose. It's
1014 ;; highly annoying to have `:' indent for you. Use TAB, C-c
1015 ;; C-l or C-c C-r to adjust. TBD: Is there a better way to
1016 ;; determine this???
Barry Warsaw0c6563f1995-09-14 20:57:02 +00001017 (if (< (current-indentation) indent) nil
1018 (goto-char here)
1019 (beginning-of-line)
1020 (delete-horizontal-space)
1021 (indent-to (- indent outdent))
1022 )))))
Barry Warsawb91b7431995-03-14 15:55:20 +00001023
1024
Barry Warsawa97a3f31997-11-04 18:47:06 +00001025;; Python subprocess utilities and filters
1026(defun py-execute-file (proc filename)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001027 "Send to Python interpreter process PROC \"execfile('FILENAME')\".
1028Make that process's buffer visible and force display. Also make
1029comint believe the user typed this string so that
1030`kill-output-from-shell' does The Right Thing."
Barry Warsawa97a3f31997-11-04 18:47:06 +00001031 (let ((curbuf (current-buffer))
1032 (procbuf (process-buffer proc))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001033; (comint-scroll-to-bottom-on-output t)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001034 (msg (format "## working on region in file %s...\n" filename))
Barry Warsaw02e5f691998-09-24 23:48:40 +00001035 (cmd (format "execfile(r'%s')\n" filename)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001036 (unwind-protect
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001037 (save-excursion
Barry Warsawa97a3f31997-11-04 18:47:06 +00001038 (set-buffer procbuf)
1039 (goto-char (point-max))
1040 (move-marker (process-mark proc) (point))
1041 (funcall (process-filter proc) proc msg))
1042 (set-buffer curbuf))
1043 (process-send-string proc cmd)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001044
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001045(defun py-comint-output-filter-function (string)
1046 "Watch output for Python prompt and exec next file waiting in queue.
1047This function is appropriate for `comint-output-filter-functions'."
Barry Warsaw014e0e21998-11-17 19:24:47 +00001048 ;; TBD: this should probably use split-string
Barry Warsaw4f94c731998-09-25 19:40:10 +00001049 (when (and (or (string-equal string ">>> ")
Barry Warsaw4f94c731998-09-25 19:40:10 +00001050 (and (>= (length string) 5)
1051 (string-equal (substring string -5) "\n>>> ")))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001052 py-file-queue)
1053 (py-safe (delete-file (car py-file-queue)))
1054 (setq py-file-queue (cdr py-file-queue))
1055 (if py-file-queue
1056 (let ((pyproc (get-buffer-process (current-buffer))))
1057 (py-execute-file pyproc (car py-file-queue))))
1058 ))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001059
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001060(defun py-postprocess-output-buffer (buf)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001061 "Highlight exceptions found in BUF.
1062If an exception occurred return t, otherwise return nil. BUF must exist."
Barry Warsawf9b99f41998-03-26 16:08:59 +00001063 (let (line file bol err-p)
Barry Warsaw9981d221997-12-03 05:25:48 +00001064 (save-excursion
1065 (set-buffer buf)
1066 (beginning-of-buffer)
1067 (while (re-search-forward py-traceback-line-re nil t)
1068 (setq file (match-string 1)
1069 line (string-to-int (match-string 2))
1070 bol (py-point 'bol))
Barry Warsawf9b99f41998-03-26 16:08:59 +00001071 (py-highlight-line bol (py-point 'eol) file line)))
1072 (when (and py-jump-on-exception line)
1073 (beep)
1074 (py-jump-to-exception file line)
1075 (setq err-p t))
1076 err-p))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001077
Barry Warsaw9981d221997-12-03 05:25:48 +00001078
Barry Warsawa97a3f31997-11-04 18:47:06 +00001079
1080;;; Subprocess commands
1081
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001082;; only used when (memq 'broken-temp-names py-emacs-features)
1083(defvar py-serial-number 0)
1084(defvar py-exception-buffer nil)
1085(defconst py-output-buffer "*Python Output*")
Barry Warsawa2398801998-04-09 23:28:20 +00001086(make-variable-buffer-local 'py-output-buffer)
1087
1088;; for toggling between CPython and JPython
1089(defvar py-which-shell py-python-command)
1090(defvar py-which-args py-python-command-args)
1091(defvar py-which-bufname "Python")
1092(make-variable-buffer-local 'py-which-shell)
1093(make-variable-buffer-local 'py-which-args)
1094(make-variable-buffer-local 'py-which-bufname)
1095
1096(defun py-toggle-shells (arg)
1097 "Toggles between the CPython and JPython shells.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001098With positive argument ARG (interactively \\[universal-argument]),
1099uses the CPython shell, with negative ARG uses the JPython shell, and
1100with a zero argument, toggles the shell."
Barry Warsawa2398801998-04-09 23:28:20 +00001101 (interactive "P")
1102 ;; default is to toggle
1103 (if (null arg)
1104 (setq arg 0))
1105 ;; toggle if zero
1106 (if (= arg 0)
1107 (if (string-equal py-which-bufname "Python")
1108 (setq arg -1)
1109 (setq arg 1)))
1110 (let (msg)
1111 (cond
1112 ((< 0 arg)
1113 ;; set to CPython
1114 (setq py-which-shell py-python-command
1115 py-which-args py-python-command-args
1116 py-which-bufname "Python"
1117 msg "CPython"
1118 mode-name "Python"))
1119 ((> 0 arg)
1120 (setq py-which-shell py-jpython-command
1121 py-which-args py-jpython-command-args
1122 py-which-bufname "JPython"
1123 msg "JPython"
1124 mode-name "JPython"))
1125 )
Barry Warsawea609c11998-04-10 16:08:26 +00001126 (message "Using the %s shell" msg)
Barry Warsawa2398801998-04-09 23:28:20 +00001127 (setq py-output-buffer (format "*%s Output*" py-which-bufname))))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001128
Barry Warsawa97a3f31997-11-04 18:47:06 +00001129;;;###autoload
1130(defun py-shell ()
1131 "Start an interactive Python interpreter in another window.
1132This is like Shell mode, except that Python is running in the window
1133instead of a shell. See the `Interactive Shell' and `Shell Mode'
1134sections of the Emacs manual for details, especially for the key
1135bindings active in the `*Python*' buffer.
1136
Barry Warsawa2398801998-04-09 23:28:20 +00001137Note: You can toggle between using the CPython interpreter and the
1138JPython interpreter by hitting \\[py-toggle-shells]. This toggles
1139buffer local variables which control whether all your subshell
1140interactions happen to the `*JPython*' or `*Python*' buffers (the
1141latter is the name used for the CPython buffer).
1142
Barry Warsawa97a3f31997-11-04 18:47:06 +00001143Warning: Don't use an interactive Python if you change sys.ps1 or
1144sys.ps2 from their default values, or if you're running code that
1145prints `>>> ' or `... ' at the start of a line. `python-mode' can't
1146distinguish your output from Python's output, and assumes that `>>> '
1147at the start of a line is a prompt from Python. Similarly, the Emacs
1148Shell mode code assumes that both `>>> ' and `... ' at the start of a
1149line are Python prompts. Bad things can happen if you fool either
1150mode.
1151
1152Warning: If you do any editing *in* the process buffer *while* the
1153buffer is accepting output from Python, do NOT attempt to `undo' the
1154changes. Some of the output (nowhere near the parts you changed!) may
1155be lost if you do. This appears to be an Emacs bug, an unfortunate
1156interaction between undo and process filters; the same problem exists in
1157non-Python process buffers using the default (Emacs-supplied) process
1158filter."
1159 ;; BAW - should undo be disabled in the python process buffer, if
1160 ;; this bug still exists?
1161 (interactive)
Barry Warsaw2518c671997-11-05 00:51:08 +00001162 (switch-to-buffer-other-window
Barry Warsawa2398801998-04-09 23:28:20 +00001163 (apply 'make-comint py-which-bufname py-which-shell nil py-which-args))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001164 (make-local-variable 'comint-prompt-regexp)
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001165 (setq comint-prompt-regexp "^>>> \\|^[.][.][.] \\|^(pdb) ")
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001166 (add-hook 'comint-output-filter-functions 'py-comint-output-filter-function)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001167 (set-syntax-table py-mode-syntax-table)
Barry Warsaw6dfbe5d1998-08-20 21:51:27 +00001168 (use-local-map py-shell-map)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001169 )
Barry Warsawa97a3f31997-11-04 18:47:06 +00001170
Barry Warsawa97a3f31997-11-04 18:47:06 +00001171(defun py-clear-queue ()
1172 "Clear the queue of temporary files waiting to execute."
1173 (interactive)
1174 (let ((n (length py-file-queue)))
1175 (mapcar 'delete-file py-file-queue)
1176 (setq py-file-queue nil)
1177 (message "%d pending files de-queued." n)))
1178
Barry Warsaw820273d1998-05-19 15:54:45 +00001179
Barry Warsawa97a3f31997-11-04 18:47:06 +00001180(defun py-execute-region (start end &optional async)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001181 "Execute the region in a Python interpreter.
1182
Barry Warsawa97a3f31997-11-04 18:47:06 +00001183The region is first copied into a temporary file (in the directory
1184`py-temp-directory'). If there is no Python interpreter shell
1185running, this file is executed synchronously using
Barry Warsaw41a05c71998-08-10 16:33:12 +00001186`shell-command-on-region'. If the program is long running, use
1187\\[universal-argument] to run the command asynchronously in its own
1188buffer.
1189
1190When this function is used programmatically, arguments START and END
1191specify the region to execute, and optional third argument ASYNC, if
1192non-nil, specifies to run the command asynchronously in its own
1193buffer.
Barry Warsawa97a3f31997-11-04 18:47:06 +00001194
1195If the Python interpreter shell is running, the region is execfile()'d
1196in that shell. If you try to execute regions too quickly,
1197`python-mode' will queue them up and execute them one at a time when
1198it sees a `>>> ' prompt from Python. Each time this happens, the
1199process buffer is popped into a window (if it's not already in some
1200window) so you can see it, and a comment of the form
1201
1202 \t## working on region in file <name>...
1203
1204is inserted at the end. See also the command `py-clear-queue'."
1205 (interactive "r\nP")
1206 (or (< start end)
1207 (error "Region is empty"))
Barry Warsaw014e0e21998-11-17 19:24:47 +00001208 (let* ((proc (get-process py-which-bufname))
Barry Warsaw5e21cb01997-11-05 18:41:11 +00001209 (temp (if (memq 'broken-temp-names py-emacs-features)
Barry Warsaw1b344241998-08-07 22:24:16 +00001210 (let
1211 ((sn py-serial-number)
1212 (pid (and (fboundp 'emacs-pid) (emacs-pid))))
1213 (setq py-serial-number (1+ py-serial-number))
1214 (if pid
1215 (format "python-%d-%d" sn pid)
1216 (format "python-%d" sn)))
Barry Warsaw2f32fbb1998-02-25 16:45:43 +00001217 (make-temp-name "python-")))
1218 (file (expand-file-name temp py-temp-directory)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001219 (write-region start end file nil 'nomsg)
1220 (cond
Barry Warsaw145ab1c1998-05-19 14:49:49 +00001221 ;; always run the code in its own asynchronous subprocess
Barry Warsawa97a3f31997-11-04 18:47:06 +00001222 (async
Barry Warsaw34d83171998-11-20 03:04:07 +00001223 (let* ((buf (generate-new-buffer-name py-output-buffer))
1224 ;; TBD: a horrible hack, but why create new Custom variables?
1225 (arg (if (string-equal py-which-bufname "Python")
1226 "-u" "")))
1227 (start-process py-which-bufname buf py-which-shell arg file)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001228 (pop-to-buffer buf)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001229 (py-postprocess-output-buffer buf)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001230 ))
1231 ;; if the Python interpreter shell is running, queue it up for
1232 ;; execution there.
1233 (proc
1234 ;; use the existing python shell
1235 (if (not py-file-queue)
1236 (py-execute-file proc file)
Barry Warsawa97a3f31997-11-04 18:47:06 +00001237 (message "File %s queued for execution" file))
Barry Warsaw3c96f6f1998-08-20 19:44:51 +00001238 (setq py-file-queue (append py-file-queue (list file)))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001239 (setq py-exception-buffer (cons file (current-buffer))))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001240 (t
Barry Warsaw34d83171998-11-20 03:04:07 +00001241 ;; TBD: a horrible hack, buy why create new Custom variables?
1242 (let ((cmd (concat py-which-shell
1243 (if (string-equal py-which-bufname "JPython")
1244 " -" ""))))
1245 ;; otherwise either run it synchronously in a subprocess
1246 (shell-command-on-region start end cmd py-output-buffer)
1247 ;; shell-command-on-region kills the output buffer if it never
1248 ;; existed and there's no output from the command
1249 (if (not (get-buffer py-output-buffer))
1250 (message "No output.")
1251 (setq py-exception-buffer (current-buffer))
1252 (let ((err-p (py-postprocess-output-buffer py-output-buffer)))
1253 (pop-to-buffer py-output-buffer)
1254 (if err-p
1255 (pop-to-buffer py-exception-buffer)))
1256 )))
Barry Warsaw512af041998-03-25 23:27:17 +00001257 )))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001258
Barry Warsaw820273d1998-05-19 15:54:45 +00001259
1260;; Code execution commands
Barry Warsawa97a3f31997-11-04 18:47:06 +00001261(defun py-execute-buffer (&optional async)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001262 "Send the contents of the buffer to a Python interpreter.
Barry Warsawc0ecb531998-01-20 21:43:34 +00001263If the file local variable `py-master-file' is non-nil, execute the
1264named file instead of the buffer's file.
1265
Barry Warsaw7ae77681994-12-12 20:38:05 +00001266If there is a *Python* process buffer it is used. If a clipping
1267restriction is in effect, only the accessible portion of the buffer is
1268sent. A trailing newline will be supplied if needed.
1269
Barry Warsaw41a05c71998-08-10 16:33:12 +00001270See the `\\[py-execute-region]' docs for an account of some
1271subtleties, including the use of the optional ASYNC argument."
Barry Warsawa97a3f31997-11-04 18:47:06 +00001272 (interactive "P")
Barry Warsawc0ecb531998-01-20 21:43:34 +00001273 (if py-master-file
1274 (let* ((filename (expand-file-name py-master-file))
1275 (buffer (or (get-file-buffer filename)
1276 (find-file-noselect filename))))
1277 (set-buffer buffer)))
Barry Warsawa97a3f31997-11-04 18:47:06 +00001278 (py-execute-region (point-min) (point-max) async))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001279
Barry Warsaw820273d1998-05-19 15:54:45 +00001280(defun py-execute-import-or-reload (&optional async)
1281 "Import the current buffer's file in a Python interpreter.
1282
1283If the file has already been imported, then do reload instead to get
Barry Warsaw7c29b231998-07-07 17:45:38 +00001284the latest version.
1285
1286If the file's name does not end in \".py\", then do execfile instead.
1287
1288If the current buffer is not visiting a file, do `py-execute-buffer'
1289instead.
1290
1291If the file local variable `py-master-file' is non-nil, import or
1292reload the named file instead of the buffer's file. The file may be
1293saved based on the value of `py-execute-import-or-reload-save-p'.
Barry Warsaw820273d1998-05-19 15:54:45 +00001294
Barry Warsaw41a05c71998-08-10 16:33:12 +00001295See the `\\[py-execute-region]' docs for an account of some
1296subtleties, including the use of the optional ASYNC argument.
Barry Warsaw820273d1998-05-19 15:54:45 +00001297
Barry Warsaw7c29b231998-07-07 17:45:38 +00001298This may be preferable to `\\[py-execute-buffer]' because:
Barry Warsaw820273d1998-05-19 15:54:45 +00001299
1300 - Definitions stay in their module rather than appearing at top
1301 level, where they would clutter the global namespace and not affect
1302 uses of qualified names (MODULE.NAME).
1303
1304 - The Python debugger gets line number information about the functions."
1305 (interactive "P")
1306 ;; Check file local variable py-master-file
1307 (if py-master-file
1308 (let* ((filename (expand-file-name py-master-file))
1309 (buffer (or (get-file-buffer filename)
1310 (find-file-noselect filename))))
1311 (set-buffer buffer)))
1312 (let ((file (buffer-file-name (current-buffer))))
1313 (if file
1314 (progn
Barry Warsaw3bfed5b1998-05-19 16:25:04 +00001315 ;; Maybe save some buffers
1316 (save-some-buffers (not py-ask-about-save) nil)
Barry Warsaw820273d1998-05-19 15:54:45 +00001317 (py-execute-string
1318 (if (string-match "\\.py$" file)
1319 (let ((f (file-name-sans-extension
1320 (file-name-nondirectory file))))
1321 (format "if globals().has_key('%s'):\n reload(%s)\nelse:\n import %s\n"
1322 f f f))
Barry Warsaw02e5f691998-09-24 23:48:40 +00001323 (format "execfile(r'%s')\n" file))
Barry Warsaw820273d1998-05-19 15:54:45 +00001324 async))
1325 ;; else
1326 (py-execute-buffer async))))
1327
1328
1329(defun py-execute-def-or-class (&optional async)
1330 "Send the current function or class definition to a Python interpreter.
1331
1332If there is a *Python* process buffer it is used.
1333
Barry Warsaw41a05c71998-08-10 16:33:12 +00001334See the `\\[py-execute-region]' docs for an account of some
1335subtleties, including the use of the optional ASYNC argument."
Barry Warsaw820273d1998-05-19 15:54:45 +00001336 (interactive "P")
1337 (save-excursion
1338 (py-mark-def-or-class)
1339 ;; mark is before point
1340 (py-execute-region (mark) (point) async)))
1341
1342
1343(defun py-execute-string (string &optional async)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001344 "Send the argument STRING to a Python interpreter.
Barry Warsaw820273d1998-05-19 15:54:45 +00001345
1346If there is a *Python* process buffer it is used.
1347
Barry Warsaw41a05c71998-08-10 16:33:12 +00001348See the `\\[py-execute-region]' docs for an account of some
1349subtleties, including the use of the optional ASYNC argument."
Barry Warsaw820273d1998-05-19 15:54:45 +00001350 (interactive "sExecute Python command: ")
1351 (save-excursion
1352 (set-buffer (get-buffer-create
1353 (generate-new-buffer-name " *Python Command*")))
1354 (insert string)
1355 (py-execute-region (point-min) (point-max) async)))
1356
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001357
1358
1359(defun py-jump-to-exception (file line)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001360 "Jump to the Python code in FILE at LINE."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001361 (let ((buffer (cond ((string-equal file "<stdin>")
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001362 (if (consp py-exception-buffer)
1363 (cdr py-exception-buffer)
1364 py-exception-buffer))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001365 ((and (consp py-exception-buffer)
1366 (string-equal file (car py-exception-buffer)))
1367 (cdr py-exception-buffer))
1368 ((py-safe (find-file-noselect file)))
1369 ;; could not figure out what file the exception
1370 ;; is pointing to, so prompt for it
1371 (t (find-file (read-file-name "Exception file: "
1372 nil
1373 file t))))))
1374 (pop-to-buffer buffer)
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001375 ;; Force Python mode
Barry Warsaw820273d1998-05-19 15:54:45 +00001376 (if (not (eq major-mode 'python-mode))
Barry Warsawebc7b7a1998-05-19 15:01:06 +00001377 (python-mode))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001378 (goto-line line)
1379 (message "Jumping to exception in file %s on line %d" file line)))
1380
1381(defun py-mouseto-exception (event)
Barry Warsaw12c92941998-08-10 21:44:37 +00001382 "Jump to the code which caused the Python exception at EVENT.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001383EVENT is usually a mouse click."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001384 (interactive "e")
1385 (cond
1386 ((fboundp 'event-point)
1387 ;; XEmacs
1388 (let* ((point (event-point event))
1389 (buffer (event-buffer event))
1390 (e (and point buffer (extent-at point buffer 'py-exc-info)))
1391 (info (and e (extent-property e 'py-exc-info))))
1392 (message "Event point: %d, info: %s" point info)
1393 (and info
1394 (py-jump-to-exception (car info) (cdr info)))
1395 ))
1396 ;; Emacs -- Please port this!
1397 ))
1398
1399(defun py-goto-exception ()
1400 "Go to the line indicated by the traceback."
1401 (interactive)
1402 (let (file line)
1403 (save-excursion
1404 (beginning-of-line)
1405 (if (looking-at py-traceback-line-re)
1406 (setq file (match-string 1)
1407 line (string-to-int (match-string 2)))))
1408 (if (not file)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001409 (error "Not on a traceback line"))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001410 (py-jump-to-exception file line)))
1411
1412(defun py-find-next-exception (start buffer searchdir errwhere)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001413 "Find the next Python exception and jump to the code that caused it.
1414START is the buffer position in BUFFER from which to begin searching
1415for an exception. SEARCHDIR is a function, either
1416`re-search-backward' or `re-search-forward' indicating the direction
1417to search. ERRWHERE is used in an error message if the limit (top or
1418bottom) of the trackback stack is encountered."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001419 (let (file line)
1420 (save-excursion
1421 (set-buffer buffer)
1422 (goto-char (py-point start))
1423 (if (funcall searchdir py-traceback-line-re nil t)
1424 (setq file (match-string 1)
1425 line (string-to-int (match-string 2)))))
1426 (if (and file line)
1427 (py-jump-to-exception file line)
1428 (error "%s of traceback" errwhere))))
1429
1430(defun py-down-exception (&optional bottom)
1431 "Go to the next line down in the traceback.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001432With \\[univeral-argument] (programmatically, optional argument
1433BOTTOM), jump to the bottom (innermost) exception in the exception
1434stack."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001435 (interactive "P")
1436 (let* ((proc (get-process "Python"))
1437 (buffer (if proc "*Python*" py-output-buffer)))
1438 (if bottom
1439 (py-find-next-exception 'eob buffer 're-search-backward "Bottom")
1440 (py-find-next-exception 'eol buffer 're-search-forward "Bottom"))))
1441
1442(defun py-up-exception (&optional top)
1443 "Go to the previous line up in the traceback.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001444With \\[universal-argument] (programmatically, optional argument TOP)
1445jump to the top (outermost) exception in the exception stack."
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001446 (interactive "P")
1447 (let* ((proc (get-process "Python"))
1448 (buffer (if proc "*Python*" py-output-buffer)))
1449 (if top
1450 (py-find-next-exception 'bob buffer 're-search-forward "Top")
Barry Warsawffbc17d1997-11-27 20:08:14 +00001451 (py-find-next-exception 'bol buffer 're-search-backward "Top"))))
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001452
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001453
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001454;; Electric deletion
1455(defun py-electric-backspace (arg)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001456 "Delete preceding character or levels of indentation.
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001457Deletion is performed by calling the function in `py-backspace-function'
Barry Warsawb0539931996-12-17 22:05:07 +00001458with a single argument (the number of characters to delete).
Barry Warsaw7ae77681994-12-12 20:38:05 +00001459
Barry Warsaw41a05c71998-08-10 16:33:12 +00001460If point is at the leftmost column, delete the preceding newline.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001461
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001462Otherwise, if point is at the leftmost non-whitespace character of a
1463line that is neither a continuation line nor a non-indenting comment
1464line, or if point is at the end of a blank line, this command reduces
1465the indentation to match that of the line that opened the current
1466block of code. The line that opened the block is displayed in the
Barry Warsaw41a05c71998-08-10 16:33:12 +00001467echo area to help you keep track of where you are. With
1468\\[universal-argument] dedents that many blocks (but not past column
1469zero).
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001470
1471Otherwise the preceding character is deleted, converting a tab to
1472spaces if needed so that only a single column position is deleted.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001473\\[universal-argument] specifies how many characters to delete
1474(default is 1).
1475
1476When used programmatically, argument ARG specifies the number of
1477blocks to dedent, or the number of characters to delete, as indicated
1478above."
Barry Warsaw03970731996-07-03 23:12:52 +00001479 (interactive "*p")
Barry Warsaw7ae77681994-12-12 20:38:05 +00001480 (if (or (/= (current-indentation) (current-column))
1481 (bolp)
1482 (py-continuation-line-p)
Barry Warsaw6e527d21996-08-01 15:57:48 +00001483 (not py-honor-comment-indentation)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001484 (looking-at "#[^ \t\n]")) ; non-indenting #
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001485 (funcall py-backspace-function arg)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001486 ;; else indent the same as the colon line that opened the block
Barry Warsaw7ae77681994-12-12 20:38:05 +00001487 ;; force non-blank so py-goto-block-up doesn't ignore it
1488 (insert-char ?* 1)
1489 (backward-char)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001490 (let ((base-indent 0) ; indentation of base line
1491 (base-text "") ; and text of base line
1492 (base-found-p nil))
Barry Warsaw03970731996-07-03 23:12:52 +00001493 (save-excursion
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001494 (while (< 0 arg)
Barry Warsaw03970731996-07-03 23:12:52 +00001495 (condition-case nil ; in case no enclosing block
1496 (progn
1497 (py-goto-block-up 'no-mark)
1498 (setq base-indent (current-indentation)
1499 base-text (py-suck-up-leading-text)
1500 base-found-p t))
1501 (error nil))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001502 (setq arg (1- arg))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001503 (delete-char 1) ; toss the dummy character
1504 (delete-horizontal-space)
1505 (indent-to base-indent)
1506 (if base-found-p
1507 (message "Closes block: %s" base-text)))))
1508
Barry Warsawfc8a01f1995-03-09 16:07:29 +00001509
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001510(defun py-electric-delete (arg)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001511 "Delete preceding or following character or levels of whitespace.
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001512
1513The behavior of this function depends on the variable
1514`delete-key-deletes-forward'. If this variable is nil (or does not
Barry Warsaw41a05c71998-08-10 16:33:12 +00001515exist, as in older Emacsen and non-XEmacs versions), then this
1516function behaves identically to \\[c-electric-backspace].
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001517
1518If `delete-key-deletes-forward' is non-nil and is supported in your
1519Emacs, then deletion occurs in the forward direction, by calling the
Barry Warsaw41a05c71998-08-10 16:33:12 +00001520function in `py-delete-function'.
1521
1522\\[universal-argument] (programmatically, argument ARG) specifies the
1523number of characters to delete (default is 1)."
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001524 (interactive "*p")
Barry Warsaw1d7b0fa1999-01-15 02:12:31 +00001525 (if (or (and (fboundp 'delete-forward-p) ;XEmacs 21
1526 (delete-forward-p))
1527 (and (boundp 'delete-key-deletes-forward) ;XEmacs 20
1528 delete-key-deletes-forward))
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001529 (funcall py-delete-function arg)
Barry Warsaw6d48c4a1997-11-04 19:21:50 +00001530 (py-electric-backspace arg)))
1531
1532;; required for pending-del and delsel modes
1533(put 'py-electric-backspace 'delete-selection 'supersede) ;delsel
1534(put 'py-electric-backspace 'pending-delete 'supersede) ;pending-del
1535(put 'py-electric-delete 'delete-selection 'supersede) ;delsel
1536(put 'py-electric-delete 'pending-delete 'supersede) ;pending-del
1537
1538
1539
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001540(defun py-indent-line (&optional arg)
1541 "Fix the indentation of the current line according to Python rules.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001542With \\[universal-argument] (programmatically, the optional argument
1543ARG non-nil), ignore dedenting rules for block closing statements
1544(e.g. return, raise, break, continue, pass)
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001545
1546This function is normally bound to `indent-line-function' so
1547\\[indent-for-tab-command] will call it."
1548 (interactive "P")
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001549 (let* ((ci (current-indentation))
1550 (move-to-indentation-p (<= (current-column) ci))
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001551 (need (py-compute-indentation (not arg))))
Barry Warsaw41a05c71998-08-10 16:33:12 +00001552 ;; see if we need to dedent
Barry Warsaw3874a3d1995-03-14 22:05:53 +00001553 (if (py-outdent-p)
Barry Warsaw0012c1e1995-03-14 16:32:55 +00001554 (setq need (- need py-indent-offset)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001555 (if (/= ci need)
1556 (save-excursion
1557 (beginning-of-line)
1558 (delete-horizontal-space)
1559 (indent-to need)))
1560 (if move-to-indentation-p (back-to-indentation))))
1561
1562(defun py-newline-and-indent ()
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001563 "Strives to act like the Emacs `newline-and-indent'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001564This is just `strives to' because correct indentation can't be computed
1565from scratch for Python code. In general, deletes the whitespace before
1566point, inserts a newline, and takes an educated guess as to how you want
1567the new line indented."
1568 (interactive)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001569 (let ((ci (current-indentation)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001570 (if (< ci (current-column)) ; if point beyond indentation
1571 (newline-and-indent)
1572 ;; else try to act like newline-and-indent "normally" acts
1573 (beginning-of-line)
1574 (insert-char ?\n 1)
1575 (move-to-column ci))))
1576
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001577(defun py-compute-indentation (honor-block-close-p)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001578 "Compute Python indentation.
1579When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',
1580`raise', `break', `continue', and `pass' force one level of
1581dedenting."
Barry Warsaw7ae77681994-12-12 20:38:05 +00001582 (save-excursion
Barry Warsawf64b4051998-02-12 16:52:14 +00001583 (beginning-of-line)
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001584 (let* ((bod (py-point 'bod))
Barry Warsaw3b3ff4e1997-11-26 20:58:48 +00001585 (pps (parse-partial-sexp bod (point)))
Barry Warsaw9c1696c1998-12-15 04:36:22 +00001586 (boipps (parse-partial-sexp bod (py-point 'boi)))
1587 placeholder)
Barry Warsaw095e9c61995-09-19 20:01:42 +00001588 (cond
Barry Warsawa0ee8cd1997-11-26 01:04:44 +00001589 ;; are we inside a multi-line string or comment?
Barry Warsaw3b3ff4e1997-11-26 20:58:48 +00001590 ((or (and (nth 3 pps) (nth 3 boipps))
1591 (and (nth 4 pps) (nth 4 boipps)))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001592 (save-excursion
1593 (if (not py-align-multiline-strings-p) 0
1594 ;; skip back over blank & non-indenting comment lines
1595 ;; note: will skip a blank or non-indenting comment line
1596 ;; that happens to be a continuation line too
1597 (re-search-backward "^[ \t]*\\([^ \t\n#]\\|#[ \t\n]\\)" nil 'move)
1598 (back-to-indentation)
1599 (current-column))))
1600 ;; are we on a continuation line?
1601 ((py-continuation-line-p)
1602 (let ((startpos (point))
1603 (open-bracket-pos (py-nesting-level))
Barry Warsawce60bc71996-08-01 18:17:14 +00001604 endpos searching found state)
Barry Warsaw095e9c61995-09-19 20:01:42 +00001605 (if open-bracket-pos
1606 (progn
1607 ;; align with first item in list; else a normal
1608 ;; indent beyond the line with the open bracket
1609 (goto-char (1+ open-bracket-pos)) ; just beyond bracket
1610 ;; is the first list item on the same line?
1611 (skip-chars-forward " \t")
1612 (if (null (memq (following-char) '(?\n ?# ?\\)))
1613 ; yes, so line up with it
1614 (current-column)
1615 ;; first list item on another line, or doesn't exist yet
1616 (forward-line 1)
1617 (while (and (< (point) startpos)
1618 (looking-at "[ \t]*[#\n\\\\]")) ; skip noise
1619 (forward-line 1))
Barry Warsaw92166d91998-04-01 21:59:41 +00001620 (if (and (< (point) startpos)
1621 (/= startpos
1622 (save-excursion
1623 (goto-char (1+ open-bracket-pos))
Barry Warsaw77d1fce1998-04-16 20:04:59 +00001624 (forward-comment (point-max))
Barry Warsaw92166d91998-04-01 21:59:41 +00001625 (point))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001626 ;; again mimic the first list item
1627 (current-indentation)
1628 ;; else they're about to enter the first item
1629 (goto-char open-bracket-pos)
Barry Warsaw9c1696c1998-12-15 04:36:22 +00001630 (setq placeholder (point))
1631 (py-goto-initial-line)
1632 (py-goto-beginning-of-tqs
1633 (save-excursion (nth 3 (parse-partial-sexp
1634 placeholder (point)))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001635 (+ (current-indentation) py-indent-offset))))
1636
1637 ;; else on backslash continuation line
1638 (forward-line -1)
1639 (if (py-continuation-line-p) ; on at least 3rd line in block
1640 (current-indentation) ; so just continue the pattern
1641 ;; else started on 2nd line in block, so indent more.
1642 ;; if base line is an assignment with a start on a RHS,
1643 ;; indent to 2 beyond the leftmost "="; else skip first
1644 ;; chunk of non-whitespace characters on base line, + 1 more
1645 ;; column
1646 (end-of-line)
1647 (setq endpos (point) searching t)
1648 (back-to-indentation)
1649 (setq startpos (point))
1650 ;; look at all "=" from left to right, stopping at first
1651 ;; one not nested in a list or string
1652 (while searching
1653 (skip-chars-forward "^=" endpos)
1654 (if (= (point) endpos)
1655 (setq searching nil)
1656 (forward-char 1)
1657 (setq state (parse-partial-sexp startpos (point)))
1658 (if (and (zerop (car state)) ; not in a bracket
1659 (null (nth 3 state))) ; & not in a string
1660 (progn
1661 (setq searching nil) ; done searching in any case
1662 (setq found
1663 (not (or
1664 (eq (following-char) ?=)
1665 (memq (char-after (- (point) 2))
1666 '(?< ?> ?!)))))))))
1667 (if (or (not found) ; not an assignment
1668 (looking-at "[ \t]*\\\\")) ; <=><spaces><backslash>
1669 (progn
1670 (goto-char startpos)
1671 (skip-chars-forward "^ \t\n")))
1672 (1+ (current-column))))))
1673
1674 ;; not on a continuation line
Barry Warsawa7891711996-08-01 15:53:09 +00001675 ((bobp) (current-indentation))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001676
Barry Warsawa7891711996-08-01 15:53:09 +00001677 ;; Dfn: "Indenting comment line". A line containing only a
1678 ;; comment, but which is treated like a statement for
1679 ;; indentation calculation purposes. Such lines are only
1680 ;; treated specially by the mode; they are not treated
1681 ;; specially by the Python interpreter.
1682
1683 ;; The rules for indenting comment lines are a line where:
1684 ;; - the first non-whitespace character is `#', and
1685 ;; - the character following the `#' is whitespace, and
Barry Warsaw41a05c71998-08-10 16:33:12 +00001686 ;; - the line is dedented with respect to (i.e. to the left
Barry Warsawa7891711996-08-01 15:53:09 +00001687 ;; of) the indentation of the preceding non-blank line.
1688
1689 ;; The first non-blank line following an indenting comment
1690 ;; line is given the same amount of indentation as the
1691 ;; indenting comment line.
1692
1693 ;; All other comment-only lines are ignored for indentation
1694 ;; purposes.
1695
1696 ;; Are we looking at a comment-only line which is *not* an
Barry Warsaw145ab1c1998-05-19 14:49:49 +00001697 ;; indenting comment line? If so, we assume that it's been
Barry Warsawa7891711996-08-01 15:53:09 +00001698 ;; placed at the desired indentation, so leave it alone.
1699 ;; Indenting comment lines are aligned as statements down
1700 ;; below.
1701 ((and (looking-at "[ \t]*#[^ \t\n]")
1702 ;; NOTE: this test will not be performed in older Emacsen
1703 (fboundp 'forward-comment)
1704 (<= (current-indentation)
1705 (save-excursion
1706 (forward-comment (- (point-max)))
1707 (current-indentation))))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001708 (current-indentation))
1709
1710 ;; else indentation based on that of the statement that
1711 ;; precedes us; use the first line of that statement to
1712 ;; establish the base, in case the user forced a non-std
1713 ;; indentation for the continuation lines (if any)
1714 (t
Barry Warsawc01c5c81995-09-14 18:49:11 +00001715 ;; skip back over blank & non-indenting comment lines note:
1716 ;; will skip a blank or non-indenting comment line that
Barry Warsawfd0fb381996-03-04 17:15:40 +00001717 ;; happens to be a continuation line too. use fast Emacs 19
1718 ;; function if it's there.
Barry Warsaw6d627751996-03-06 18:41:38 +00001719 (if (and (eq py-honor-comment-indentation nil)
Barry Warsaw33d6ec01996-03-05 16:28:07 +00001720 (fboundp 'forward-comment))
Barry Warsawfd0fb381996-03-04 17:15:40 +00001721 (forward-comment (- (point-max)))
Barry Warsaw218eb751998-09-22 19:51:47 +00001722 (let ((prefix-re (concat py-block-comment-prefix "[ \t]*"))
1723 done)
Barry Warsaw6d627751996-03-06 18:41:38 +00001724 (while (not done)
Barry Warsaw12c92941998-08-10 21:44:37 +00001725 (re-search-backward "^[ \t]*\\([^ \t\n#]\\|#\\)" nil 'move)
1726 (setq done (or (bobp)
1727 (and (eq py-honor-comment-indentation t)
1728 (save-excursion
1729 (back-to-indentation)
Barry Warsaw218eb751998-09-22 19:51:47 +00001730 (not (looking-at prefix-re))
Barry Warsaw12c92941998-08-10 21:44:37 +00001731 ))
1732 (and (not (eq py-honor-comment-indentation t))
1733 (save-excursion
1734 (back-to-indentation)
1735 (not (zerop (current-column)))))
1736 ))
Barry Warsaw6d627751996-03-06 18:41:38 +00001737 )))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001738 ;; if we landed inside a string, go to the beginning of that
1739 ;; string. this handles triple quoted, multi-line spanning
1740 ;; strings.
Barry Warsaw9c1696c1998-12-15 04:36:22 +00001741 (py-goto-beginning-of-tqs (nth 3 (parse-partial-sexp bod (point))))
Barry Warsawc210e691998-01-20 22:52:56 +00001742 ;; now skip backward over continued lines
Barry Warsaw9c1696c1998-12-15 04:36:22 +00001743 (setq placeholder (point))
Barry Warsaw095e9c61995-09-19 20:01:42 +00001744 (py-goto-initial-line)
Barry Warsaw9c1696c1998-12-15 04:36:22 +00001745 ;; we may *now* have landed in a TQS, so find the beginning of
1746 ;; this string.
1747 (py-goto-beginning-of-tqs
1748 (save-excursion (nth 3 (parse-partial-sexp
1749 placeholder (point)))))
Barry Warsawf831d811996-07-31 20:42:59 +00001750 (+ (current-indentation)
1751 (if (py-statement-opens-block-p)
1752 py-indent-offset
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001753 (if (and honor-block-close-p (py-statement-closes-block-p))
Barry Warsawf831d811996-07-31 20:42:59 +00001754 (- py-indent-offset)
1755 0)))
1756 )))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001757
1758(defun py-guess-indent-offset (&optional global)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001759 "Guess a good value for, and change, `py-indent-offset'.
Barry Warsaw41a05c71998-08-10 16:33:12 +00001760
1761By default, make a buffer-local copy of `py-indent-offset' with the
1762new value, so that other Python buffers are not affected. With
1763\\[universal-argument] (programmatically, optional argument GLOBAL),
1764change the global value of `py-indent-offset'. This affects all
1765Python buffers (that don't have their own buffer-local copy), both
1766those currently existing and those created later in the Emacs session.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001767
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001768Some people use a different value for `py-indent-offset' than you use.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001769There's no excuse for such foolishness, but sometimes you have to deal
1770with their ugly code anyway. This function examines the file and sets
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001771`py-indent-offset' to what it thinks it was when they created the
1772mess.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001773
1774Specifically, it searches forward from the statement containing point,
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001775looking for a line that opens a block of code. `py-indent-offset' is
1776set to the difference in indentation between that line and the Python
Barry Warsaw7ae77681994-12-12 20:38:05 +00001777statement following it. If the search doesn't succeed going forward,
1778it's tried again going backward."
1779 (interactive "P") ; raw prefix arg
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001780 (let (new-value
1781 (start (point))
Barry Warsawe908b6b1998-03-19 22:48:02 +00001782 (restart (point))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001783 (found nil)
1784 colon-indent)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001785 (py-goto-initial-line)
1786 (while (not (or found (eobp)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00001787 (when (and (re-search-forward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
1788 (not (py-in-literal restart)))
1789 (setq restart (point))
1790 (py-goto-initial-line)
1791 (if (py-statement-opens-block-p)
1792 (setq found t)
1793 (goto-char restart))))
1794 (unless found
Barry Warsaw7ae77681994-12-12 20:38:05 +00001795 (goto-char start)
1796 (py-goto-initial-line)
1797 (while (not (or found (bobp)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00001798 (setq found (and
1799 (re-search-backward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
1800 (or (py-goto-initial-line) t) ; always true -- side effect
1801 (py-statement-opens-block-p)))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001802 (setq colon-indent (current-indentation)
1803 found (and found (zerop (py-next-statement 1)))
1804 new-value (- (current-indentation) colon-indent))
1805 (goto-char start)
Barry Warsawe908b6b1998-03-19 22:48:02 +00001806 (if (not found)
1807 (error "Sorry, couldn't guess a value for py-indent-offset")
1808 (funcall (if global 'kill-local-variable 'make-local-variable)
1809 'py-indent-offset)
1810 (setq py-indent-offset new-value)
Barry Warsawd35c2551998-09-25 00:08:38 +00001811 (or noninteractive
1812 (message "%s value of py-indent-offset set to %d"
1813 (if global "Global" "Local")
1814 py-indent-offset)))
Barry Warsawe908b6b1998-03-19 22:48:02 +00001815 ))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001816
Barry Warsaw003932a1998-07-07 15:11:24 +00001817(defun py-comment-indent-function ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00001818 "Python version of `comment-indent-function'."
1819 ;; This is required when filladapt is turned off. Without it, when
1820 ;; filladapt is not used, comments which start in column zero
1821 ;; cascade one character to the right
Barry Warsaw003932a1998-07-07 15:11:24 +00001822 (save-excursion
1823 (beginning-of-line)
1824 (let ((eol (py-point 'eol)))
1825 (and comment-start-skip
1826 (re-search-forward comment-start-skip eol t)
1827 (setq eol (match-beginning 0)))
1828 (goto-char eol)
1829 (skip-chars-backward " \t")
1830 (max comment-column (+ (current-column) (if (bolp) 0 1)))
1831 )))
1832
Barry Warsawf8ddb6a1999-01-18 21:49:39 +00001833(defun py-narrow-to-defun (&optional class)
1834 "Make text outside current defun invisible.
1835The defun visible is the one that contains point or follows point.
1836Optional CLASS is passed directly to `py-beginning-of-def-or-class'."
1837 (interactive "P")
1838 (save-excursion
1839 (widen)
1840 (py-end-of-def-or-class class)
1841 (let ((end (point)))
1842 (py-beginning-of-def-or-class class)
1843 (narrow-to-region (point) end))))
1844
Barry Warsaw003932a1998-07-07 15:11:24 +00001845
Barry Warsaw7ae77681994-12-12 20:38:05 +00001846(defun py-shift-region (start end count)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001847 "Indent lines from START to END by COUNT spaces."
Barry Warsaw7ae77681994-12-12 20:38:05 +00001848 (save-excursion
Barry Warsaw41a05c71998-08-10 16:33:12 +00001849 (goto-char end)
1850 (beginning-of-line)
1851 (setq end (point))
1852 (goto-char start)
1853 (beginning-of-line)
1854 (setq start (point))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001855 (indent-rigidly start end count)))
1856
1857(defun py-shift-region-left (start end &optional count)
1858 "Shift region of Python code to the left.
1859The lines from the line containing the start of the current region up
1860to (but not including) the line containing the end of the region are
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001861shifted to the left, by `py-indent-offset' columns.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001862
1863If a prefix argument is given, the region is instead shifted by that
Barry Warsaw41a05c71998-08-10 16:33:12 +00001864many columns. With no active region, dedent only the current line.
1865You cannot dedent the region if any line is already at column zero."
Barry Warsawdea4a291996-07-03 22:59:12 +00001866 (interactive
1867 (let ((p (point))
1868 (m (mark))
1869 (arg current-prefix-arg))
1870 (if m
1871 (list (min p m) (max p m) arg)
1872 (list p (save-excursion (forward-line 1) (point)) arg))))
1873 ;; if any line is at column zero, don't shift the region
1874 (save-excursion
1875 (goto-char start)
1876 (while (< (point) end)
1877 (back-to-indentation)
Barry Warsaw71e315b1996-07-23 15:03:16 +00001878 (if (and (zerop (current-column))
1879 (not (looking-at "\\s *$")))
Barry Warsaw41a05c71998-08-10 16:33:12 +00001880 (error "Region is at left edge"))
Barry Warsawdea4a291996-07-03 22:59:12 +00001881 (forward-line 1)))
1882 (py-shift-region start end (- (prefix-numeric-value
1883 (or count py-indent-offset))))
1884 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001885
1886(defun py-shift-region-right (start end &optional count)
1887 "Shift region of Python code to the right.
1888The lines from the line containing the start of the current region up
1889to (but not including) the line containing the end of the region are
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001890shifted to the right, by `py-indent-offset' columns.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001891
1892If a prefix argument is given, the region is instead shifted by that
Barry Warsawdea4a291996-07-03 22:59:12 +00001893many columns. With no active region, indent only the current line."
1894 (interactive
1895 (let ((p (point))
1896 (m (mark))
1897 (arg current-prefix-arg))
1898 (if m
1899 (list (min p m) (max p m) arg)
1900 (list p (save-excursion (forward-line 1) (point)) arg))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001901 (py-shift-region start end (prefix-numeric-value
Barry Warsawdea4a291996-07-03 22:59:12 +00001902 (or count py-indent-offset)))
1903 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001904
1905(defun py-indent-region (start end &optional indent-offset)
1906 "Reindent a region of Python code.
Barry Warsaw867a32a1996-03-07 18:30:26 +00001907
Barry Warsaw7ae77681994-12-12 20:38:05 +00001908The lines from the line containing the start of the current region up
1909to (but not including) the line containing the end of the region are
1910reindented. If the first line of the region has a non-whitespace
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001911character in the first column, the first line is left alone and the
1912rest of the region is reindented with respect to it. Else the entire
Barry Warsaw867a32a1996-03-07 18:30:26 +00001913region is reindented with respect to the (closest code or indenting
1914comment) statement immediately preceding the region.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001915
1916This is useful when code blocks are moved or yanked, when enclosing
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001917control structures are introduced or removed, or to reformat code
1918using a new value for the indentation offset.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001919
1920If a numeric prefix argument is given, it will be used as the value of
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001921the indentation offset. Else the value of `py-indent-offset' will be
Barry Warsaw7ae77681994-12-12 20:38:05 +00001922used.
1923
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001924Warning: The region must be consistently indented before this function
Barry Warsaw7ae77681994-12-12 20:38:05 +00001925is called! This function does not compute proper indentation from
1926scratch (that's impossible in Python), it merely adjusts the existing
1927indentation to be correct in context.
1928
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001929Warning: This function really has no idea what to do with
1930non-indenting comment lines, and shifts them as if they were indenting
1931comment lines. Fixing this appears to require telepathy.
Barry Warsaw7ae77681994-12-12 20:38:05 +00001932
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001933Special cases: whitespace is deleted from blank lines; continuation
1934lines are shifted by the same amount their initial line was shifted,
1935in order to preserve their relative indentation with respect to their
Barry Warsaw7ae77681994-12-12 20:38:05 +00001936initial line; and comment lines beginning in column 1 are ignored."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001937 (interactive "*r\nP") ; region; raw prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00001938 (save-excursion
1939 (goto-char end) (beginning-of-line) (setq end (point-marker))
1940 (goto-char start) (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001941 (let ((py-indent-offset (prefix-numeric-value
1942 (or indent-offset py-indent-offset)))
1943 (indents '(-1)) ; stack of active indent levels
1944 (target-column 0) ; column to which to indent
1945 (base-shifted-by 0) ; amount last base line was shifted
1946 (indent-base (if (looking-at "[ \t\n]")
Barry Warsaw7cb505c1996-10-23 20:44:59 +00001947 (py-compute-indentation t)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001948 0))
1949 ci)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001950 (while (< (point) end)
1951 (setq ci (current-indentation))
1952 ;; figure out appropriate target column
1953 (cond
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001954 ((or (eq (following-char) ?#) ; comment in column 1
1955 (looking-at "[ \t]*$")) ; entirely blank
1956 (setq target-column 0))
1957 ((py-continuation-line-p) ; shift relative to base line
1958 (setq target-column (+ ci base-shifted-by)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00001959 (t ; new base line
1960 (if (> ci (car indents)) ; going deeper; push it
1961 (setq indents (cons ci indents))
1962 ;; else we should have seen this indent before
1963 (setq indents (memq ci indents)) ; pop deeper indents
1964 (if (null indents)
1965 (error "Bad indentation in region, at line %d"
1966 (save-restriction
1967 (widen)
1968 (1+ (count-lines 1 (point)))))))
1969 (setq target-column (+ indent-base
1970 (* py-indent-offset
1971 (- (length indents) 2))))
1972 (setq base-shifted-by (- target-column ci))))
1973 ;; shift as needed
1974 (if (/= ci target-column)
1975 (progn
1976 (delete-horizontal-space)
1977 (indent-to target-column)))
1978 (forward-line 1))))
1979 (set-marker end nil))
1980
Barry Warsawa7891711996-08-01 15:53:09 +00001981(defun py-comment-region (beg end &optional arg)
1982 "Like `comment-region' but uses double hash (`#') comment starter."
1983 (interactive "r\nP")
Barry Warsaw3fcaf611996-08-01 20:11:51 +00001984 (let ((comment-start py-block-comment-prefix))
Barry Warsawa7891711996-08-01 15:53:09 +00001985 (comment-region beg end arg)))
1986
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001987
1988;; Functions for moving point
Barry Warsaw7ae77681994-12-12 20:38:05 +00001989(defun py-previous-statement (count)
Barry Warsaw41a05c71998-08-10 16:33:12 +00001990 "Go to the start of the COUNTth preceding Python statement.
1991By default, goes to the previous statement. If there is no such
1992statement, goes to the first statement. Return count of statements
1993left to move. `Statements' do not include blank, comment, or
1994continuation lines."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001995 (interactive "p") ; numeric prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00001996 (if (< count 0) (py-next-statement (- count))
1997 (py-goto-initial-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00001998 (let (start)
Barry Warsaw7ae77681994-12-12 20:38:05 +00001999 (while (and
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002000 (setq start (point)) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00002001 (> count 0)
2002 (zerop (forward-line -1))
2003 (py-goto-statement-at-or-above))
2004 (setq count (1- count)))
2005 (if (> count 0) (goto-char start)))
2006 count))
2007
2008(defun py-next-statement (count)
2009 "Go to the start of next Python statement.
2010If the statement at point is the i'th Python statement, goes to the
2011start of statement i+COUNT. If there is no such statement, goes to the
2012last statement. Returns count of statements left to move. `Statements'
2013do not include blank, comment, or continuation lines."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002014 (interactive "p") ; numeric prefix arg
Barry Warsaw7ae77681994-12-12 20:38:05 +00002015 (if (< count 0) (py-previous-statement (- count))
2016 (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002017 (let (start)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002018 (while (and
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002019 (setq start (point)) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00002020 (> count 0)
2021 (py-goto-statement-below))
2022 (setq count (1- count)))
2023 (if (> count 0) (goto-char start)))
2024 count))
2025
2026(defun py-goto-block-up (&optional nomark)
2027 "Move up to start of current block.
2028Go to the statement that starts the smallest enclosing block; roughly
2029speaking, this will be the closest preceding statement that ends with a
2030colon and is indented less than the statement you started on. If
2031successful, also sets the mark to the starting point.
2032
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002033`\\[py-mark-block]' can be used afterward to mark the whole code
2034block, if desired.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002035
2036If called from a program, the mark will not be set if optional argument
2037NOMARK is not nil."
2038 (interactive)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002039 (let ((start (point))
2040 (found nil)
2041 initial-indent)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002042 (py-goto-initial-line)
2043 ;; if on blank or non-indenting comment line, use the preceding stmt
2044 (if (looking-at "[ \t]*\\($\\|#[^ \t\n]\\)")
2045 (progn
2046 (py-goto-statement-at-or-above)
2047 (setq found (py-statement-opens-block-p))))
2048 ;; search back for colon line indented less
2049 (setq initial-indent (current-indentation))
2050 (if (zerop initial-indent)
2051 ;; force fast exit
2052 (goto-char (point-min)))
2053 (while (not (or found (bobp)))
2054 (setq found
2055 (and
2056 (re-search-backward ":[ \t]*\\($\\|[#\\]\\)" nil 'move)
2057 (or (py-goto-initial-line) t) ; always true -- side effect
2058 (< (current-indentation) initial-indent)
2059 (py-statement-opens-block-p))))
2060 (if found
2061 (progn
2062 (or nomark (push-mark start))
2063 (back-to-indentation))
2064 (goto-char start)
2065 (error "Enclosing block not found"))))
2066
Barry Warsawab0e86c1998-05-19 15:31:46 +00002067(defun py-beginning-of-def-or-class (&optional class count)
2068 "Move point to start of `def' or `class'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002069
2070Searches back for the closest preceding `def'. If you supply a prefix
Barry Warsawab0e86c1998-05-19 15:31:46 +00002071arg, looks for a `class' instead. The docs below assume the `def'
2072case; just substitute `class' for `def' for the other case.
Barry Warsaw7c29b231998-07-07 17:45:38 +00002073Programmatically, if CLASS is `either', then moves to either `class'
2074or `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002075
Barry Warsawab0e86c1998-05-19 15:31:46 +00002076When second optional argument is given programmatically, move to the
2077COUNTth start of `def'.
2078
2079If point is in a `def' statement already, and after the `d', simply
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002080moves point to the start of the statement.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002081
Barry Warsawab0e86c1998-05-19 15:31:46 +00002082Otherwise (i.e. when point is not in a `def' statement, or at or
2083before the `d' of a `def' statement), searches for the closest
2084preceding `def' statement, and leaves point at its start. If no such
2085statement can be found, leaves point at the start of the buffer.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002086
Barry Warsawab0e86c1998-05-19 15:31:46 +00002087Returns t iff a `def' statement is found by these rules.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002088
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002089Note that doing this command repeatedly will take you closer to the
2090start of the buffer each time.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002091
Barry Warsaw7c29b231998-07-07 17:45:38 +00002092To mark the current `def', see `\\[py-mark-def-or-class]'."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002093 (interactive "P") ; raw prefix arg
Barry Warsaw6839d3a1998-10-28 00:10:45 +00002094 (setq count (or count 1))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002095 (let ((at-or-before-p (<= (current-column) (current-indentation)))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002096 (start-of-line (goto-char (py-point 'bol)))
2097 (start-of-stmt (goto-char (py-point 'bos)))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002098 (start-re (cond ((eq class 'either) "^[ \t]*\\(class\\|def\\)\\>")
2099 (class "^[ \t]*class\\>")
2100 (t "^[ \t]*def\\>")))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002101 )
2102 ;; searching backward
2103 (if (and (< 0 count)
2104 (or (/= start-of-stmt start-of-line)
2105 (not at-or-before-p)))
2106 (end-of-line))
2107 ;; search forward
2108 (if (and (> 0 count)
2109 (zerop (current-column))
2110 (looking-at start-re))
2111 (end-of-line))
2112 (re-search-backward start-re nil 'move count)
2113 (goto-char (match-beginning 0))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002114
Barry Warsawab0e86c1998-05-19 15:31:46 +00002115;; Backwards compatibility
2116(defalias 'beginning-of-python-def-or-class 'py-beginning-of-def-or-class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002117
Barry Warsawab0e86c1998-05-19 15:31:46 +00002118(defun py-end-of-def-or-class (&optional class count)
2119 "Move point beyond end of `def' or `class' body.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002120
Barry Warsawab0e86c1998-05-19 15:31:46 +00002121By default, looks for an appropriate `def'. If you supply a prefix
2122arg, looks for a `class' instead. The docs below assume the `def'
2123case; just substitute `class' for `def' for the other case.
Barry Warsaw7c29b231998-07-07 17:45:38 +00002124Programmatically, if CLASS is `either', then moves to either `class'
2125or `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002126
Barry Warsawab0e86c1998-05-19 15:31:46 +00002127When second optional argument is given programmatically, move to the
2128COUNTth end of `def'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002129
Barry Warsawab0e86c1998-05-19 15:31:46 +00002130If point is in a `def' statement already, this is the `def' we use.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002131
Barry Warsawab0e86c1998-05-19 15:31:46 +00002132Else, if the `def' found by `\\[py-beginning-of-def-or-class]'
2133contains the statement you started on, that's the `def' we use.
2134
2135Otherwise, we search forward for the closest following `def', and use that.
2136
2137If a `def' can be found by these rules, point is moved to the start of
2138the line immediately following the `def' block, and the position of the
2139start of the `def' is returned.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002140
2141Else point is moved to the end of the buffer, and nil is returned.
2142
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002143Note that doing this command repeatedly will take you closer to the
2144end of the buffer each time.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002145
Barry Warsaw7c29b231998-07-07 17:45:38 +00002146To mark the current `def', see `\\[py-mark-def-or-class]'."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002147 (interactive "P") ; raw prefix arg
Barry Warsawab0e86c1998-05-19 15:31:46 +00002148 (if (and count (/= count 1))
2149 (py-beginning-of-def-or-class (- 1 count)))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002150 (let ((start (progn (py-goto-initial-line) (point)))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002151 (which (cond ((eq class 'either) "\\(class\\|def\\)")
2152 (class "class")
2153 (t "def")))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002154 (state 'not-found))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002155 ;; move point to start of appropriate def/class
2156 (if (looking-at (concat "[ \t]*" which "\\>")) ; already on one
2157 (setq state 'at-beginning)
Barry Warsawab0e86c1998-05-19 15:31:46 +00002158 ;; else see if py-beginning-of-def-or-class hits container
2159 (if (and (py-beginning-of-def-or-class class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002160 (progn (py-goto-beyond-block)
2161 (> (point) start)))
2162 (setq state 'at-end)
2163 ;; else search forward
2164 (goto-char start)
2165 (if (re-search-forward (concat "^[ \t]*" which "\\>") nil 'move)
2166 (progn (setq state 'at-beginning)
2167 (beginning-of-line)))))
2168 (cond
2169 ((eq state 'at-beginning) (py-goto-beyond-block) t)
2170 ((eq state 'at-end) t)
2171 ((eq state 'not-found) nil)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002172 (t (error "Internal error in `py-end-of-def-or-class'")))))
Barry Warsawab0e86c1998-05-19 15:31:46 +00002173
2174;; Backwards compabitility
Barry Warsaw820273d1998-05-19 15:54:45 +00002175(defalias 'end-of-python-def-or-class 'py-end-of-def-or-class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002176
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002177
2178;; Functions for marking regions
Barry Warsaw7ae77681994-12-12 20:38:05 +00002179(defun py-mark-block (&optional extend just-move)
2180 "Mark following block of lines. With prefix arg, mark structure.
2181Easier to use than explain. It sets the region to an `interesting'
2182block of succeeding lines. If point is on a blank line, it goes down to
2183the next non-blank line. That will be the start of the region. The end
2184of the region depends on the kind of line at the start:
2185
2186 - If a comment, the region will include all succeeding comment lines up
2187 to (but not including) the next non-comment line (if any).
2188
2189 - Else if a prefix arg is given, and the line begins one of these
2190 structures:
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002191
2192 if elif else try except finally for while def class
2193
Barry Warsaw7ae77681994-12-12 20:38:05 +00002194 the region will be set to the body of the structure, including
2195 following blocks that `belong' to it, but excluding trailing blank
2196 and comment lines. E.g., if on a `try' statement, the `try' block
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002197 and all (if any) of the following `except' and `finally' blocks
2198 that belong to the `try' structure will be in the region. Ditto
2199 for if/elif/else, for/else and while/else structures, and (a bit
2200 degenerate, since they're always one-block structures) def and
2201 class blocks.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002202
2203 - Else if no prefix argument is given, and the line begins a Python
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002204 block (see list above), and the block is not a `one-liner' (i.e.,
2205 the statement ends with a colon, not with code), the region will
2206 include all succeeding lines up to (but not including) the next
2207 code statement (if any) that's indented no more than the starting
2208 line, except that trailing blank and comment lines are excluded.
2209 E.g., if the starting line begins a multi-statement `def'
2210 structure, the region will be set to the full function definition,
2211 but without any trailing `noise' lines.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002212
2213 - Else the region will include all succeeding lines up to (but not
2214 including) the next blank line, or code or indenting-comment line
2215 indented strictly less than the starting line. Trailing indenting
2216 comment lines are included in this case, but not trailing blank
2217 lines.
2218
2219A msg identifying the location of the mark is displayed in the echo
2220area; or do `\\[exchange-point-and-mark]' to flip down to the end.
2221
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002222If called from a program, optional argument EXTEND plays the role of
2223the prefix arg, and if optional argument JUST-MOVE is not nil, just
2224moves to the end of the block (& does not set mark or display a msg)."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002225 (interactive "P") ; raw prefix arg
2226 (py-goto-initial-line)
2227 ;; skip over blank lines
2228 (while (and
2229 (looking-at "[ \t]*$") ; while blank line
2230 (not (eobp))) ; & somewhere to go
2231 (forward-line 1))
2232 (if (eobp)
2233 (error "Hit end of buffer without finding a non-blank stmt"))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002234 (let ((initial-pos (point))
2235 (initial-indent (current-indentation))
2236 last-pos ; position of last stmt in region
2237 (followers
2238 '((if elif else) (elif elif else) (else)
2239 (try except finally) (except except) (finally)
2240 (for else) (while else)
2241 (def) (class) ) )
2242 first-symbol next-symbol)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002243
2244 (cond
2245 ;; if comment line, suck up the following comment lines
2246 ((looking-at "[ \t]*#")
2247 (re-search-forward "^[ \t]*[^ \t#]" nil 'move) ; look for non-comment
2248 (re-search-backward "^[ \t]*#") ; and back to last comment in block
2249 (setq last-pos (point)))
2250
2251 ;; else if line is a block line and EXTEND given, suck up
2252 ;; the whole structure
2253 ((and extend
2254 (setq first-symbol (py-suck-up-first-keyword) )
2255 (assq first-symbol followers))
2256 (while (and
2257 (or (py-goto-beyond-block) t) ; side effect
2258 (forward-line -1) ; side effect
2259 (setq last-pos (point)) ; side effect
2260 (py-goto-statement-below)
2261 (= (current-indentation) initial-indent)
2262 (setq next-symbol (py-suck-up-first-keyword))
2263 (memq next-symbol (cdr (assq first-symbol followers))))
2264 (setq first-symbol next-symbol)))
2265
2266 ;; else if line *opens* a block, search for next stmt indented <=
2267 ((py-statement-opens-block-p)
2268 (while (and
2269 (setq last-pos (point)) ; always true -- side effect
2270 (py-goto-statement-below)
2271 (> (current-indentation) initial-indent))
2272 nil))
2273
2274 ;; else plain code line; stop at next blank line, or stmt or
2275 ;; indenting comment line indented <
2276 (t
2277 (while (and
2278 (setq last-pos (point)) ; always true -- side effect
2279 (or (py-goto-beyond-final-line) t)
2280 (not (looking-at "[ \t]*$")) ; stop at blank line
2281 (or
2282 (>= (current-indentation) initial-indent)
2283 (looking-at "[ \t]*#[^ \t\n]"))) ; ignore non-indenting #
2284 nil)))
2285
2286 ;; skip to end of last stmt
2287 (goto-char last-pos)
2288 (py-goto-beyond-final-line)
2289
2290 ;; set mark & display
2291 (if just-move
2292 () ; just return
2293 (push-mark (point) 'no-msg)
2294 (forward-line -1)
2295 (message "Mark set after: %s" (py-suck-up-leading-text))
2296 (goto-char initial-pos))))
2297
Barry Warsaw2518c671997-11-05 00:51:08 +00002298(defun py-mark-def-or-class (&optional class)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002299 "Set region to body of def (or class, with prefix arg) enclosing point.
2300Pushes the current mark, then point, on the mark ring (all language
2301modes do this, but although it's handy it's never documented ...).
2302
2303In most Emacs language modes, this function bears at least a
Barry Warsawab0e86c1998-05-19 15:31:46 +00002304hallucinogenic resemblance to `\\[py-end-of-def-or-class]' and
2305`\\[py-beginning-of-def-or-class]'.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002306
2307And in earlier versions of Python mode, all 3 were tightly connected.
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002308Turned out that was more confusing than useful: the `goto start' and
2309`goto end' commands are usually used to search through a file, and
2310people expect them to act a lot like `search backward' and `search
2311forward' string-search commands. But because Python `def' and `class'
2312can nest to arbitrary levels, finding the smallest def containing
2313point cannot be done via a simple backward search: the def containing
2314point may not be the closest preceding def, or even the closest
2315preceding def that's indented less. The fancy algorithm required is
2316appropriate for the usual uses of this `mark' command, but not for the
2317`goto' variations.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002318
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002319So the def marked by this command may not be the one either of the
2320`goto' commands find: If point is on a blank or non-indenting comment
2321line, moves back to start of the closest preceding code statement or
2322indenting comment line. If this is a `def' statement, that's the def
2323we use. Else searches for the smallest enclosing `def' block and uses
2324that. Else signals an error.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002325
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002326When an enclosing def is found: The mark is left immediately beyond
2327the last line of the def block. Point is left at the start of the
2328def, except that: if the def is preceded by a number of comment lines
2329followed by (at most) one optional blank line, point is left at the
2330start of the comments; else if the def is preceded by a blank line,
2331point is left at its start.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002332
2333The intent is to mark the containing def/class and its associated
2334documentation, to make moving and duplicating functions and classes
2335pleasant."
2336 (interactive "P") ; raw prefix arg
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002337 (let ((start (point))
Barry Warsaw7c29b231998-07-07 17:45:38 +00002338 (which (cond ((eq class 'either) "\\(class\\|def\\)")
2339 (class "class")
2340 (t "def"))))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002341 (push-mark start)
2342 (if (not (py-go-up-tree-to-keyword which))
2343 (progn (goto-char start)
Barry Warsaw7c29b231998-07-07 17:45:38 +00002344 (error "Enclosing %s not found"
2345 (if (eq class 'either)
2346 "def or class"
2347 which)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002348 ;; else enclosing def/class found
2349 (setq start (point))
2350 (py-goto-beyond-block)
2351 (push-mark (point))
2352 (goto-char start)
2353 (if (zerop (forward-line -1)) ; if there is a preceding line
2354 (progn
2355 (if (looking-at "[ \t]*$") ; it's blank
2356 (setq start (point)) ; so reset start point
2357 (goto-char start)) ; else try again
2358 (if (zerop (forward-line -1))
2359 (if (looking-at "[ \t]*#") ; a comment
2360 ;; look back for non-comment line
2361 ;; tricky: note that the regexp matches a blank
2362 ;; line, cuz \n is in the 2nd character class
2363 (and
2364 (re-search-backward "^[ \t]*[^ \t#]" nil 'move)
2365 (forward-line 1))
2366 ;; no comment, so go back
Barry Warsaw4da6bd51997-11-26 06:00:26 +00002367 (goto-char start)))))))
2368 (exchange-point-and-mark)
2369 (py-keep-region-active))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002370
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002371;; ripped from cc-mode
2372(defun py-forward-into-nomenclature (&optional arg)
2373 "Move forward to end of a nomenclature section or word.
Barry Warsaw41a05c71998-08-10 16:33:12 +00002374With \\[universal-argument] (programmatically, optional argument ARG),
2375do it that many times.
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002376
2377A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
2378 (interactive "p")
2379 (let ((case-fold-search nil))
2380 (if (> arg 0)
Barry Warsawc5a8cbd1996-08-05 21:53:02 +00002381 (re-search-forward
2382 "\\(\\W\\|[_]\\)*\\([A-Z]*[a-z0-9]*\\)"
2383 (point-max) t arg)
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002384 (while (and (< arg 0)
2385 (re-search-backward
Barry Warsawc5a8cbd1996-08-05 21:53:02 +00002386 "\\(\\W\\|[a-z0-9]\\)[A-Z]+\\|\\(\\W\\|[_]\\)\\w+"
Barry Warsaw9e5a9c81996-07-24 18:26:53 +00002387 (point-min) 0))
2388 (forward-char 1)
2389 (setq arg (1+ arg)))))
2390 (py-keep-region-active))
2391
2392(defun py-backward-into-nomenclature (&optional arg)
2393 "Move backward to beginning of a nomenclature section or word.
2394With optional ARG, move that many times. If ARG is negative, move
2395forward.
2396
2397A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
2398 (interactive "p")
2399 (py-forward-into-nomenclature (- arg))
2400 (py-keep-region-active))
2401
2402
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002403
2404;; Documentation functions
Barry Warsaw7ae77681994-12-12 20:38:05 +00002405
2406;; dump the long form of the mode blurb; does the usual doc escapes,
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002407;; plus lines of the form ^[vc]:name$ to suck variable & command docs
2408;; out of the right places, along with the keys they're on & current
2409;; values
Barry Warsaw7ae77681994-12-12 20:38:05 +00002410(defun py-dump-help-string (str)
2411 (with-output-to-temp-buffer "*Help*"
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002412 (let ((locals (buffer-local-variables))
2413 funckind funcname func funcdoc
2414 (start 0) mstart end
2415 keys )
Barry Warsaw7ae77681994-12-12 20:38:05 +00002416 (while (string-match "^%\\([vc]\\):\\(.+\\)\n" str start)
2417 (setq mstart (match-beginning 0) end (match-end 0)
2418 funckind (substring str (match-beginning 1) (match-end 1))
2419 funcname (substring str (match-beginning 2) (match-end 2))
2420 func (intern funcname))
2421 (princ (substitute-command-keys (substring str start mstart)))
2422 (cond
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002423 ((equal funckind "c") ; command
2424 (setq funcdoc (documentation func)
2425 keys (concat
2426 "Key(s): "
2427 (mapconcat 'key-description
2428 (where-is-internal func py-mode-map)
2429 ", "))))
2430 ((equal funckind "v") ; variable
Barry Warsaw604cefa1996-09-03 18:17:04 +00002431 (setq funcdoc (documentation-property func 'variable-documentation)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002432 keys (if (assq func locals)
2433 (concat
2434 "Local/Global values: "
2435 (prin1-to-string (symbol-value func))
2436 " / "
2437 (prin1-to-string (default-value func)))
2438 (concat
2439 "Value: "
2440 (prin1-to-string (symbol-value func))))))
2441 (t ; unexpected
2442 (error "Error in py-dump-help-string, tag `%s'" funckind)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002443 (princ (format "\n-> %s:\t%s\t%s\n\n"
2444 (if (equal funckind "c") "Command" "Variable")
2445 funcname keys))
2446 (princ funcdoc)
2447 (terpri)
2448 (setq start end))
2449 (princ (substitute-command-keys (substring str start))))
2450 (print-help-return-message)))
2451
2452(defun py-describe-mode ()
2453 "Dump long form of Python-mode docs."
2454 (interactive)
2455 (py-dump-help-string "Major mode for editing Python files.
2456Knows about Python indentation, tokens, comments and continuation lines.
2457Paragraphs are separated by blank lines only.
2458
2459Major sections below begin with the string `@'; specific function and
2460variable docs begin with `->'.
2461
2462@EXECUTING PYTHON CODE
2463
Barry Warsaw820273d1998-05-19 15:54:45 +00002464\\[py-execute-import-or-reload]\timports or reloads the file in the Python interpreter
Barry Warsaw7ae77681994-12-12 20:38:05 +00002465\\[py-execute-buffer]\tsends the entire buffer to the Python interpreter
2466\\[py-execute-region]\tsends the current region
Barry Warsaw820273d1998-05-19 15:54:45 +00002467\\[py-execute-def-or-class]\tsends the current function or class definition
2468\\[py-execute-string]\tsends an arbitrary string
Barry Warsaw7ae77681994-12-12 20:38:05 +00002469\\[py-shell]\tstarts a Python interpreter window; this will be used by
Barry Warsaw820273d1998-05-19 15:54:45 +00002470\tsubsequent Python execution commands
2471%c:py-execute-import-or-reload
Barry Warsaw7ae77681994-12-12 20:38:05 +00002472%c:py-execute-buffer
2473%c:py-execute-region
Barry Warsaw820273d1998-05-19 15:54:45 +00002474%c:py-execute-def-or-class
2475%c:py-execute-string
Barry Warsaw7ae77681994-12-12 20:38:05 +00002476%c:py-shell
2477
2478@VARIABLES
2479
2480py-indent-offset\tindentation increment
Barry Warsaw42f707f1996-07-29 21:05:05 +00002481py-block-comment-prefix\tcomment string used by comment-region
Barry Warsaw7ae77681994-12-12 20:38:05 +00002482
2483py-python-command\tshell command to invoke Python interpreter
Barry Warsaw7ae77681994-12-12 20:38:05 +00002484py-temp-directory\tdirectory used for temp files (if needed)
2485
2486py-beep-if-tab-change\tring the bell if tab-width is changed
2487%v:py-indent-offset
2488%v:py-block-comment-prefix
2489%v:py-python-command
Barry Warsaw7ae77681994-12-12 20:38:05 +00002490%v:py-temp-directory
2491%v:py-beep-if-tab-change
2492
2493@KINDS OF LINES
2494
2495Each physical line in the file is either a `continuation line' (the
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002496preceding line ends with a backslash that's not part of a comment, or
2497the paren/bracket/brace nesting level at the start of the line is
2498non-zero, or both) or an `initial line' (everything else).
Barry Warsaw7ae77681994-12-12 20:38:05 +00002499
2500An initial line is in turn a `blank line' (contains nothing except
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002501possibly blanks or tabs), a `comment line' (leftmost non-blank
2502character is `#'), or a `code line' (everything else).
Barry Warsaw7ae77681994-12-12 20:38:05 +00002503
2504Comment Lines
2505
2506Although all comment lines are treated alike by Python, Python mode
2507recognizes two kinds that act differently with respect to indentation.
2508
2509An `indenting comment line' is a comment line with a blank, tab or
2510nothing after the initial `#'. The indentation commands (see below)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002511treat these exactly as if they were code lines: a line following an
Barry Warsaw7ae77681994-12-12 20:38:05 +00002512indenting comment line will be indented like the comment line. All
2513other comment lines (those with a non-whitespace character immediately
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002514following the initial `#') are `non-indenting comment lines', and
2515their indentation is ignored by the indentation commands.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002516
2517Indenting comment lines are by far the usual case, and should be used
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002518whenever possible. Non-indenting comment lines are useful in cases
2519like these:
Barry Warsaw7ae77681994-12-12 20:38:05 +00002520
2521\ta = b # a very wordy single-line comment that ends up being
2522\t #... continued onto another line
2523
2524\tif a == b:
2525##\t\tprint 'panic!' # old code we've `commented out'
2526\t\treturn a
2527
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002528Since the `#...' and `##' comment lines have a non-whitespace
2529character following the initial `#', Python mode ignores them when
2530computing the proper indentation for the next line.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002531
2532Continuation Lines and Statements
2533
2534The Python-mode commands generally work on statements instead of on
2535individual lines, where a `statement' is a comment or blank line, or a
2536code line and all of its following continuation lines (if any)
2537considered as a single logical unit. The commands in this mode
2538generally (when it makes sense) automatically move to the start of the
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002539statement containing point, even if point happens to be in the middle
2540of some continuation line.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002541
2542
2543@INDENTATION
2544
2545Primarily for entering new code:
2546\t\\[indent-for-tab-command]\t indent line appropriately
2547\t\\[py-newline-and-indent]\t insert newline, then indent
Barry Warsaw27ee1151997-12-03 05:03:44 +00002548\t\\[py-electric-backspace]\t reduce indentation, or delete single character
Barry Warsaw7ae77681994-12-12 20:38:05 +00002549
2550Primarily for reindenting existing code:
2551\t\\[py-guess-indent-offset]\t guess py-indent-offset from file content; change locally
2552\t\\[universal-argument] \\[py-guess-indent-offset]\t ditto, but change globally
2553
2554\t\\[py-indent-region]\t reindent region to match its context
2555\t\\[py-shift-region-left]\t shift region left by py-indent-offset
2556\t\\[py-shift-region-right]\t shift region right by py-indent-offset
2557
2558Unlike most programming languages, Python uses indentation, and only
2559indentation, to specify block structure. Hence the indentation supplied
2560automatically by Python-mode is just an educated guess: only you know
2561the block structure you intend, so only you can supply correct
2562indentation.
2563
2564The \\[indent-for-tab-command] and \\[py-newline-and-indent] keys try to suggest plausible indentation, based on
2565the indentation of preceding statements. E.g., assuming
2566py-indent-offset is 4, after you enter
2567\tif a > 0: \\[py-newline-and-indent]
2568the cursor will be moved to the position of the `_' (_ is not a
2569character in the file, it's just used here to indicate the location of
2570the cursor):
2571\tif a > 0:
2572\t _
2573If you then enter `c = d' \\[py-newline-and-indent], the cursor will move
2574to
2575\tif a > 0:
2576\t c = d
2577\t _
2578Python-mode cannot know whether that's what you intended, or whether
2579\tif a > 0:
2580\t c = d
2581\t_
2582was your intent. In general, Python-mode either reproduces the
2583indentation of the (closest code or indenting-comment) preceding
2584statement, or adds an extra py-indent-offset blanks if the preceding
2585statement has `:' as its last significant (non-whitespace and non-
2586comment) character. If the suggested indentation is too much, use
Barry Warsaw27ee1151997-12-03 05:03:44 +00002587\\[py-electric-backspace] to reduce it.
Barry Warsaw7ae77681994-12-12 20:38:05 +00002588
2589Continuation lines are given extra indentation. If you don't like the
2590suggested indentation, change it to something you do like, and Python-
2591mode will strive to indent later lines of the statement in the same way.
2592
2593If a line is a continuation line by virtue of being in an unclosed
2594paren/bracket/brace structure (`list', for short), the suggested
2595indentation depends on whether the current line contains the first item
2596in the list. If it does, it's indented py-indent-offset columns beyond
2597the indentation of the line containing the open bracket. If you don't
2598like that, change it by hand. The remaining items in the list will mimic
2599whatever indentation you give to the first item.
2600
2601If a line is a continuation line because the line preceding it ends with
2602a backslash, the third and following lines of the statement inherit their
2603indentation from the line preceding them. The indentation of the second
2604line in the statement depends on the form of the first (base) line: if
2605the base line is an assignment statement with anything more interesting
2606than the backslash following the leftmost assigning `=', the second line
2607is indented two columns beyond that `='. Else it's indented to two
2608columns beyond the leftmost solid chunk of non-whitespace characters on
2609the base line.
2610
2611Warning: indent-region should not normally be used! It calls \\[indent-for-tab-command]
2612repeatedly, and as explained above, \\[indent-for-tab-command] can't guess the block
2613structure you intend.
2614%c:indent-for-tab-command
2615%c:py-newline-and-indent
Barry Warsaw27ee1151997-12-03 05:03:44 +00002616%c:py-electric-backspace
Barry Warsaw7ae77681994-12-12 20:38:05 +00002617
2618
2619The next function may be handy when editing code you didn't write:
2620%c:py-guess-indent-offset
2621
2622
2623The remaining `indent' functions apply to a region of Python code. They
2624assume the block structure (equals indentation, in Python) of the region
2625is correct, and alter the indentation in various ways while preserving
2626the block structure:
2627%c:py-indent-region
2628%c:py-shift-region-left
2629%c:py-shift-region-right
2630
2631@MARKING & MANIPULATING REGIONS OF CODE
2632
2633\\[py-mark-block]\t mark block of lines
Barry Warsaw2518c671997-11-05 00:51:08 +00002634\\[py-mark-def-or-class]\t mark smallest enclosing def
2635\\[universal-argument] \\[py-mark-def-or-class]\t mark smallest enclosing class
Barry Warsaw42f707f1996-07-29 21:05:05 +00002636\\[comment-region]\t comment out region of code
2637\\[universal-argument] \\[comment-region]\t uncomment region of code
Barry Warsaw7ae77681994-12-12 20:38:05 +00002638%c:py-mark-block
Barry Warsaw2518c671997-11-05 00:51:08 +00002639%c:py-mark-def-or-class
Barry Warsaw42f707f1996-07-29 21:05:05 +00002640%c:comment-region
Barry Warsaw7ae77681994-12-12 20:38:05 +00002641
2642@MOVING POINT
2643
2644\\[py-previous-statement]\t move to statement preceding point
2645\\[py-next-statement]\t move to statement following point
2646\\[py-goto-block-up]\t move up to start of current block
Barry Warsawab0e86c1998-05-19 15:31:46 +00002647\\[py-beginning-of-def-or-class]\t move to start of def
2648\\[universal-argument] \\[py-beginning-of-def-or-class]\t move to start of class
2649\\[py-end-of-def-or-class]\t move to end of def
2650\\[universal-argument] \\[py-end-of-def-or-class]\t move to end of class
Barry Warsaw7ae77681994-12-12 20:38:05 +00002651
2652The first two move to one statement beyond the statement that contains
2653point. A numeric prefix argument tells them to move that many
2654statements instead. Blank lines, comment lines, and continuation lines
2655do not count as `statements' for these commands. So, e.g., you can go
2656to the first code statement in a file by entering
2657\t\\[beginning-of-buffer]\t to move to the top of the file
2658\t\\[py-next-statement]\t to skip over initial comments and blank lines
2659Or do `\\[py-previous-statement]' with a huge prefix argument.
2660%c:py-previous-statement
2661%c:py-next-statement
2662%c:py-goto-block-up
Barry Warsawab0e86c1998-05-19 15:31:46 +00002663%c:py-beginning-of-def-or-class
2664%c:py-end-of-def-or-class
Barry Warsaw7ae77681994-12-12 20:38:05 +00002665
2666@LITTLE-KNOWN EMACS COMMANDS PARTICULARLY USEFUL IN PYTHON MODE
2667
2668`\\[indent-new-comment-line]' is handy for entering a multi-line comment.
2669
2670`\\[set-selective-display]' with a `small' prefix arg is ideally suited for viewing the
2671overall class and def structure of a module.
2672
2673`\\[back-to-indentation]' moves point to a line's first non-blank character.
2674
2675`\\[indent-relative]' is handy for creating odd indentation.
2676
2677@OTHER EMACS HINTS
2678
2679If you don't like the default value of a variable, change its value to
2680whatever you do like by putting a `setq' line in your .emacs file.
2681E.g., to set the indentation increment to 4, put this line in your
2682.emacs:
2683\t(setq py-indent-offset 4)
2684To see the value of a variable, do `\\[describe-variable]' and enter the variable
2685name at the prompt.
2686
2687When entering a key sequence like `C-c C-n', it is not necessary to
2688release the CONTROL key after doing the `C-c' part -- it suffices to
2689press the CONTROL key, press and release `c' (while still holding down
2690CONTROL), press and release `n' (while still holding down CONTROL), &
2691then release CONTROL.
2692
2693Entering Python mode calls with no arguments the value of the variable
2694`python-mode-hook', if that value exists and is not nil; for backward
2695compatibility it also tries `py-mode-hook'; see the `Hooks' section of
2696the Elisp manual for details.
2697
2698Obscure: When python-mode is first loaded, it looks for all bindings
2699to newline-and-indent in the global keymap, and shadows them with
2700local bindings to py-newline-and-indent."))
2701
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002702
2703;; Helper functions
Barry Warsaw7ae77681994-12-12 20:38:05 +00002704(defvar py-parse-state-re
2705 (concat
2706 "^[ \t]*\\(if\\|elif\\|else\\|while\\|def\\|class\\)\\>"
2707 "\\|"
2708 "^[^ #\t\n]"))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002709
Barry Warsaw7ae77681994-12-12 20:38:05 +00002710(defun py-parse-state ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002711 "Return the parse state at point (see `parse-partial-sexp' docs)."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002712 (save-excursion
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00002713 (let ((here (point))
Barry Warsaw742a5111998-03-13 17:29:15 +00002714 pps done)
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00002715 (while (not done)
2716 ;; back up to the first preceding line (if any; else start of
2717 ;; buffer) that begins with a popular Python keyword, or a
2718 ;; non- whitespace and non-comment character. These are good
2719 ;; places to start parsing to see whether where we started is
2720 ;; at a non-zero nesting level. It may be slow for people who
2721 ;; write huge code blocks or huge lists ... tough beans.
2722 (re-search-backward py-parse-state-re nil 'move)
2723 (beginning-of-line)
Barry Warsawf64b4051998-02-12 16:52:14 +00002724 ;; In XEmacs, we have a much better way to test for whether
2725 ;; we're in a triple-quoted string or not. Emacs does not
Barry Warsaw145ab1c1998-05-19 14:49:49 +00002726 ;; have this built-in function, which is its loss because
Barry Warsawf64b4051998-02-12 16:52:14 +00002727 ;; without scanning from the beginning of the buffer, there's
2728 ;; no accurate way to determine this otherwise.
2729 (if (not (fboundp 'buffer-syntactic-context))
2730 ;; Emacs
Barry Warsaw585f7331998-04-01 21:13:51 +00002731 (progn
2732 (save-excursion (setq pps (parse-partial-sexp (point) here)))
Barry Warsawf64b4051998-02-12 16:52:14 +00002733 ;; make sure we don't land inside a triple-quoted string
Barry Warsaw742a5111998-03-13 17:29:15 +00002734 (setq done (or (not (nth 3 pps))
2735 (bobp))))
Barry Warsawf64b4051998-02-12 16:52:14 +00002736 ;; XEmacs
2737 (setq done (or (not (buffer-syntactic-context))
2738 (bobp)))
2739 (when done
2740 (setq pps (parse-partial-sexp (point) here)))
2741 ))
Barry Warsaw43ecf8e1996-04-06 00:00:19 +00002742 pps)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002743
Barry Warsaw7ae77681994-12-12 20:38:05 +00002744(defun py-nesting-level ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002745 "Return the buffer position of the last unclosed enclosing list.
2746If nesting level is zero, return nil."
Barry Warsawf64b4051998-02-12 16:52:14 +00002747 (let ((status (py-parse-state)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002748 (if (zerop (car status))
2749 nil ; not in a nest
2750 (car (cdr status))))) ; char# of open bracket
2751
Barry Warsaw7ae77681994-12-12 20:38:05 +00002752(defun py-backslash-continuation-line-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002753 "Return t iff preceding line ends with backslash that is not in a comment."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002754 (save-excursion
2755 (beginning-of-line)
2756 (and
2757 ;; use a cheap test first to avoid the regexp if possible
2758 ;; use 'eq' because char-after may return nil
2759 (eq (char-after (- (point) 2)) ?\\ )
2760 ;; make sure; since eq test passed, there is a preceding line
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002761 (forward-line -1) ; always true -- side effect
Barry Warsaw7ae77681994-12-12 20:38:05 +00002762 (looking-at py-continued-re))))
2763
Barry Warsaw7ae77681994-12-12 20:38:05 +00002764(defun py-continuation-line-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002765 "Return t iff current line is a continuation line."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002766 (save-excursion
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002767 (beginning-of-line)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002768 (or (py-backslash-continuation-line-p)
2769 (py-nesting-level))))
2770
Barry Warsaw9c1696c1998-12-15 04:36:22 +00002771(defun py-goto-beginning-of-tqs (delim)
2772 "Go to the beginning of the triple quoted string we find ourselves in.
2773DELIM is the TQS string delimiter character we're searching backwards
2774for."
2775 (let ((skip (and delim (make-string 1 delim))))
2776 (when skip
2777 (save-excursion
2778 (py-safe (search-backward skip))
2779 (if (and (eq (char-before) delim)
2780 (eq (char-before (1- (point))) delim))
2781 (setq skip (make-string 3 delim))))
2782 ;; we're looking at a triple-quoted string
2783 (py-safe (search-backward skip)))))
2784
Barry Warsaw7ae77681994-12-12 20:38:05 +00002785(defun py-goto-initial-line ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002786 "Go to the initial line of the current statement.
2787Usually this is the line we're on, but if we're on the 2nd or
2788following lines of a continuation block, we need to go up to the first
2789line of the block."
2790 ;; Tricky: We want to avoid quadratic-time behavior for long
2791 ;; continued blocks, whether of the backslash or open-bracket
2792 ;; varieties, or a mix of the two. The following manages to do that
2793 ;; in the usual cases.
2794 ;;
2795 ;; Also, if we're sitting inside a triple quoted string, this will
2796 ;; drop us at the line that begins the string.
Barry Warsaw9ec9fbc1998-01-21 05:15:57 +00002797 (let (open-bracket-pos)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002798 (while (py-continuation-line-p)
2799 (beginning-of-line)
2800 (if (py-backslash-continuation-line-p)
2801 (while (py-backslash-continuation-line-p)
2802 (forward-line -1))
2803 ;; else zip out of nested brackets/braces/parens
2804 (while (setq open-bracket-pos (py-nesting-level))
2805 (goto-char open-bracket-pos)))))
2806 (beginning-of-line))
2807
Barry Warsaw7ae77681994-12-12 20:38:05 +00002808(defun py-goto-beyond-final-line ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002809 "Go to the point just beyond the fine line of the current statement.
2810Usually this is the start of the next line, but if this is a
2811multi-line statement we need to skip over the continuation lines."
2812 ;; Tricky: Again we need to be clever to avoid quadratic time
2813 ;; behavior.
2814 ;;
2815 ;; XXX: Not quite the right solution, but deals with multi-line doc
2816 ;; strings
Barry Warsaw751f4931998-05-19 16:06:21 +00002817 (if (looking-at (concat "[ \t]*\\(" py-stringlit-re "\\)"))
2818 (goto-char (match-end 0)))
2819 ;;
Barry Warsaw7ae77681994-12-12 20:38:05 +00002820 (forward-line 1)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002821 (let (state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002822 (while (and (py-continuation-line-p)
2823 (not (eobp)))
2824 ;; skip over the backslash flavor
2825 (while (and (py-backslash-continuation-line-p)
2826 (not (eobp)))
2827 (forward-line 1))
2828 ;; if in nest, zip to the end of the nest
2829 (setq state (py-parse-state))
2830 (if (and (not (zerop (car state)))
2831 (not (eobp)))
2832 (progn
Barry Warsawaffc0ca1997-11-03 16:59:38 +00002833 (parse-partial-sexp (point) (point-max) 0 nil state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002834 (forward-line 1))))))
2835
Barry Warsaw7ae77681994-12-12 20:38:05 +00002836(defun py-statement-opens-block-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002837 "Return t iff the current statement opens a block.
2838I.e., iff it ends with a colon that is not in a comment. Point should
2839be at the start of a statement."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002840 (save-excursion
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002841 (let ((start (point))
2842 (finish (progn (py-goto-beyond-final-line) (1- (point))))
2843 (searching t)
2844 (answer nil)
2845 state)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002846 (goto-char start)
2847 (while searching
2848 ;; look for a colon with nothing after it except whitespace, and
2849 ;; maybe a comment
2850 (if (re-search-forward ":\\([ \t]\\|\\\\\n\\)*\\(#.*\\)?$"
2851 finish t)
2852 (if (eq (point) finish) ; note: no `else' clause; just
2853 ; keep searching if we're not at
2854 ; the end yet
2855 ;; sure looks like it opens a block -- but it might
2856 ;; be in a comment
2857 (progn
2858 (setq searching nil) ; search is done either way
2859 (setq state (parse-partial-sexp start
2860 (match-beginning 0)))
2861 (setq answer (not (nth 4 state)))))
2862 ;; search failed: couldn't find another interesting colon
2863 (setq searching nil)))
2864 answer)))
2865
Barry Warsawf831d811996-07-31 20:42:59 +00002866(defun py-statement-closes-block-p ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002867 "Return t iff the current statement closes a block.
2868I.e., if the line starts with `return', `raise', `break', `continue',
2869and `pass'. This doesn't catch embedded statements."
Barry Warsawf831d811996-07-31 20:42:59 +00002870 (let ((here (point)))
2871 (back-to-indentation)
2872 (prog1
Barry Warsawaffc0ca1997-11-03 16:59:38 +00002873 (looking-at (concat py-block-closing-keywords-re "\\>"))
Barry Warsawf831d811996-07-31 20:42:59 +00002874 (goto-char here))))
2875
Barry Warsaw7ae77681994-12-12 20:38:05 +00002876(defun py-goto-beyond-block ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002877 "Go to point just beyond the final line of block begun by the current line.
2878This is the same as where `py-goto-beyond-final-line' goes unless
2879we're on colon line, in which case we go to the end of the block.
2880Assumes point is at the beginning of the line."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002881 (if (py-statement-opens-block-p)
2882 (py-mark-block nil 'just-move)
2883 (py-goto-beyond-final-line)))
2884
Barry Warsaw7ae77681994-12-12 20:38:05 +00002885(defun py-goto-statement-at-or-above ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002886 "Go to the start of the first statement at or preceding point.
2887Return t if there is such a statement, otherwise nil. `Statement'
2888does not include blank lines, comments, or continuation lines."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002889 (py-goto-initial-line)
2890 (if (looking-at py-blank-or-comment-re)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002891 ;; skip back over blank & comment lines
2892 ;; note: will skip a blank or comment line that happens to be
2893 ;; a continuation line too
2894 (if (re-search-backward "^[ \t]*[^ \t#\n]" nil t)
2895 (progn (py-goto-initial-line) t)
2896 nil)
Barry Warsaw7ae77681994-12-12 20:38:05 +00002897 t))
2898
Barry Warsaw7ae77681994-12-12 20:38:05 +00002899(defun py-goto-statement-below ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002900 "Go to start of the first statement following the statement containing point.
2901Return t if there is such a statement, otherwise nil. `Statement'
2902does not include blank lines, comments, or continuation lines."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002903 (beginning-of-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002904 (let ((start (point)))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002905 (py-goto-beyond-final-line)
2906 (while (and
2907 (looking-at py-blank-or-comment-re)
2908 (not (eobp)))
2909 (forward-line 1))
2910 (if (eobp)
2911 (progn (goto-char start) nil)
2912 t)))
2913
Barry Warsaw7ae77681994-12-12 20:38:05 +00002914(defun py-go-up-tree-to-keyword (key)
Barry Warsaw41a05c71998-08-10 16:33:12 +00002915 "Go to begining of statement starting with KEY, at or preceding point.
2916
2917KEY is a regular expression describing a Python keyword. Skip blank
2918lines and non-indenting comments. If the statement found starts with
2919KEY, then stop, otherwise go back to first enclosing block starting
2920with KEY. If successful, leave point at the start of the KEY line and
2921return t. Otherwise, leav point at an undefined place and return nil."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002922 ;; skip blanks and non-indenting #
2923 (py-goto-initial-line)
2924 (while (and
2925 (looking-at "[ \t]*\\($\\|#[^ \t\n]\\)")
2926 (zerop (forward-line -1))) ; go back
2927 nil)
2928 (py-goto-initial-line)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002929 (let* ((re (concat "[ \t]*" key "\\b"))
2930 (case-fold-search nil) ; let* so looking-at sees this
2931 (found (looking-at re))
2932 (dead nil))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002933 (while (not (or found dead))
2934 (condition-case nil ; in case no enclosing block
2935 (py-goto-block-up 'no-mark)
2936 (error (setq dead t)))
2937 (or dead (setq found (looking-at re))))
2938 (beginning-of-line)
2939 found))
2940
Barry Warsaw7ae77681994-12-12 20:38:05 +00002941(defun py-suck-up-leading-text ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002942 "Return string in buffer from start of indentation to end of line.
2943Prefix with \"...\" if leading whitespace was skipped."
Barry Warsaw7ae77681994-12-12 20:38:05 +00002944 (save-excursion
2945 (back-to-indentation)
2946 (concat
2947 (if (bolp) "" "...")
2948 (buffer-substring (point) (progn (end-of-line) (point))))))
2949
Barry Warsaw7ae77681994-12-12 20:38:05 +00002950(defun py-suck-up-first-keyword ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002951 "Return first keyword on the line as a Lisp symbol.
2952`Keyword' is defined (essentially) as the regular expression
2953([a-z]+). Returns nil if none was found."
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002954 (let ((case-fold-search nil))
Barry Warsaw7ae77681994-12-12 20:38:05 +00002955 (if (looking-at "[ \t]*\\([a-z]+\\)\\b")
2956 (intern (buffer-substring (match-beginning 1) (match-end 1)))
2957 nil)))
2958
Barry Warsawb3e81d51996-09-04 15:12:42 +00002959(defun py-current-defun ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00002960 "Python value for `add-log-current-defun-function'.
2961This tells add-log.el how to find the current function/method/variable."
Barry Warsawb3e81d51996-09-04 15:12:42 +00002962 (save-excursion
2963 (if (re-search-backward py-defun-start-re nil t)
2964 (or (match-string 3)
2965 (let ((method (match-string 2)))
2966 (if (and (not (zerop (length (match-string 1))))
2967 (re-search-backward py-class-start-re nil t))
2968 (concat (match-string 1) "." method)
2969 method)))
2970 nil)))
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002971
2972
Barry Warsawfec75d61995-07-05 23:26:15 +00002973(defconst py-help-address "python-mode@python.org"
Barry Warsaw850437a1995-03-08 21:50:28 +00002974 "Address accepting submission of bug reports.")
Barry Warsaw7b0f5681995-03-08 21:33:04 +00002975
Barry Warsaw850437a1995-03-08 21:50:28 +00002976(defun py-version ()
2977 "Echo the current version of `python-mode' in the minibuffer."
2978 (interactive)
2979 (message "Using `python-mode' version %s" py-version)
2980 (py-keep-region-active))
2981
2982;; only works under Emacs 19
2983;(eval-when-compile
2984; (require 'reporter))
2985
2986(defun py-submit-bug-report (enhancement-p)
2987 "Submit via mail a bug report on `python-mode'.
Barry Warsaw41a05c71998-08-10 16:33:12 +00002988With \\[universal-argument] (programmatically, argument ENHANCEMENT-P
2989non-nil) just submit an enhancement request."
Barry Warsaw850437a1995-03-08 21:50:28 +00002990 (interactive
2991 (list (not (y-or-n-p
Barry Warsaw41a05c71998-08-10 16:33:12 +00002992 "Is this a bug report (hit `n' to send other comments)? "))))
Barry Warsawb5e0ecb1995-03-14 18:32:54 +00002993 (let ((reporter-prompt-for-summary-p (if enhancement-p
2994 "(Very) brief summary: "
2995 t)))
Barry Warsaw850437a1995-03-08 21:50:28 +00002996 (require 'reporter)
2997 (reporter-submit-bug-report
2998 py-help-address ;address
Barry Warsawb5e0ecb1995-03-14 18:32:54 +00002999 (concat "python-mode " py-version) ;pkgname
Barry Warsaw850437a1995-03-08 21:50:28 +00003000 ;; varlist
3001 (if enhancement-p nil
3002 '(py-python-command
3003 py-indent-offset
3004 py-block-comment-prefix
Barry Warsaw850437a1995-03-08 21:50:28 +00003005 py-temp-directory
3006 py-beep-if-tab-change))
3007 nil ;pre-hooks
3008 nil ;post-hooks
3009 "Dear Barry,") ;salutation
3010 (if enhancement-p nil
3011 (set-mark (point))
3012 (insert
3013"Please replace this text with a sufficiently large code sample\n\
3014and an exact recipe so that I can reproduce your problem. Failure\n\
3015to do so may mean a greater delay in fixing your bug.\n\n")
3016 (exchange-point-and-mark)
3017 (py-keep-region-active))))
3018
3019
Barry Warsaw47384781997-11-26 05:27:45 +00003020(defun py-kill-emacs-hook ()
Barry Warsaw41a05c71998-08-10 16:33:12 +00003021 "Delete files in `py-file-queue'.
3022These are Python temporary files awaiting execution."
Barry Warsaw47384781997-11-26 05:27:45 +00003023 (mapcar #'(lambda (filename)
3024 (py-safe (delete-file filename)))
3025 py-file-queue))
3026
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003027;; arrange to kill temp files when Emacs exists
Barry Warsawc72c11c1997-08-09 06:42:08 +00003028(add-hook 'kill-emacs-hook 'py-kill-emacs-hook)
Barry Warsaw7b0f5681995-03-08 21:33:04 +00003029
3030
3031
3032(provide 'python-mode)
3033;;; python-mode.el ends here