add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Misc/python-mode.el (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Misc/python-mode.el+3768−0

@@ -0,0 +1,3768 @@
	1	;;; python-mode.el --- Major mode for editing Python programs
	2
	3	;; Copyright (C) 1992,1993,1994 Tim Peters
	4
	5	;; Author: 1995-2002 Barry A. Warsaw
	6	;; 1992-1994 Tim Peters
	7	;; Maintainer: python-mode@python.org
	8	;; Created: Feb 1992
	9	;; Keywords: python languages oop
	10
	11	(defconst py-version "$Revision: 34960 $"
	12	"`python-mode' version number.")
	13
	14	;; 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.
	19
	20	;;; Commentary:
	21
	22	;; This is a major mode for editing Python programs. It was developed
	23	;; by Tim Peters after an original idea by Michael A. Guravage. Tim
	24	;; subsequently left the net; in 1995, Barry Warsaw inherited the mode
	25	;; and is the current maintainer. Tim's now back but disavows all
	26	;; responsibility for the mode. Smart Tim :-)
	27
	28	;; pdbtrack support contributed by Ken Manheimer, April 2001.
	29
	30	;; Please use the SourceForge Python project to submit bugs or
	31	;; patches:
	32	;;
	33	;; http://sourceforge.net/projects/python
	34
	35	;; FOR MORE INFORMATION:
	36
	37	;; There is some information on python-mode.el at
	38
	39	;; http://www.python.org/emacs/python-mode/
	40	;;
	41	;; It does contain links to other packages that you might find useful,
	42	;; such as pdb interfaces, OO-Browser links, etc.
	43
	44	;; BUG REPORTING:
	45
	46	;; As mentioned above, please use the SourceForge Python project for
	47	;; submitting bug reports or patches. The old recommendation, to use
	48	;; C-c C-b will still work, but those reports have a higher chance of
	49	;; getting buried in my mailbox. Please include a complete, but
	50	;; concise code sample and a recipe for reproducing the bug. Send
	51	;; suggestions and other comments to python-mode@python.org.
	52
	53	;; When in a Python mode buffer, do a C-h m for more help. It's
	54	;; doubtful that a texinfo manual would be very useful, but if you
	55	;; want to contribute one, I'll certainly accept it!
	56
	57	;;; Code:
	58
	59	(require 'comint)
	60	(require 'custom)
	61	(require 'cl)
	62	(require 'compile)
	63
	64
	65	;; user definable variables
	66	;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
	67
	68	(defgroup python nil
	69	"Support for the Python programming language, <http://www.python.org/>"
	70	:group 'languages
	71	:prefix "py-")
	72
	73	(defcustom py-python-command "python"
	74	"*Shell command used to start Python interpreter."
	75	:type 'string
	76	:group 'python)
	77
	78	(defcustom py-jpython-command "jpython"
	79	"*Shell command used to start the JPython interpreter."
	80	:type 'string
	81	:group 'python
	82	:tag "JPython Command")
	83
	84	(defcustom py-default-interpreter 'cpython
	85	"*Which Python interpreter is used by default.
	86	The value for this variable can be either `cpython' or `jpython'.
	87
	88	When the value is `cpython', the variables `py-python-command' and
	89	`py-python-command-args' are consulted to determine the interpreter
	90	and arguments to use.
	91
	92	When the value is `jpython', the variables `py-jpython-command' and
	93	`py-jpython-command-args' are consulted to determine the interpreter
	94	and arguments to use.
	95
	96	Note that this variable is consulted only the first time that a Python
	97	mode buffer is visited during an Emacs session. After that, use
	98	\\[py-toggle-shells] to change the interpreter shell."
	99	:type '(choice (const :tag "Python (a.k.a. CPython)" cpython)
	100	(const :tag "JPython" jpython))
	101	:group 'python)
	102
	103	(defcustom py-python-command-args '("-i")
	104	"*List of string arguments to be used when starting a Python shell."
	105	:type '(repeat string)
	106	:group 'python)
	107
	108	(defcustom py-jpython-command-args '("-i")
	109	"*List of string arguments to be used when starting a JPython shell."
	110	:type '(repeat string)
	111	:group 'python
	112	:tag "JPython Command Args")
	113
	114	(defcustom py-indent-offset 4
	115	"*Amount of offset per level of indentation.
	116	`\\[py-guess-indent-offset]' can usually guess a good value when
	117	you're editing someone else's Python code."
	118	:type 'integer
	119	:group 'python)
	120
	121	(defcustom py-continuation-offset 4
	122	"*Additional amount of offset to give for some continuation lines.
	123	Continuation lines are those that immediately follow a backslash
	124	terminated line. Only those continuation lines for a block opening
	125	statement are given this extra offset."
	126	:type 'integer
	127	:group 'python)
	128
	129	(defcustom py-smart-indentation t
	130	"*Should `python-mode' try to automagically set some indentation variables?
	131	When this variable is non-nil, two things happen when a buffer is set
	132	to `python-mode':
	133
	134	1. `py-indent-offset' is guessed from existing code in the buffer.
	135	Only guessed values between 2 and 8 are considered. If a valid
	136	guess can't be made (perhaps because you are visiting a new
	137	file), then the value in `py-indent-offset' is used.
	138
	139	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.
	144
	145	Note that both these settings occur after `python-mode-hook' is run,
	146	so if you want to defeat the automagic configuration, you must also
	147	set `py-smart-indentation' to nil in your `python-mode-hook'."
	148	:type 'boolean
	149	:group 'python)
	150
	151	(defcustom py-align-multiline-strings-p t
	152	"*Flag describing how multi-line triple quoted strings are aligned.
	153	When this flag is non-nil, continuation lines are lined up under the
	154	preceding line's indentation. When this flag is nil, continuation
	155	lines 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)
	159
	160	(defcustom py-block-comment-prefix "##"
	161	"*String used by \\[comment-region] to comment out a block of code.
	162	This should follow the convention for non-indenting comment lines so
	163	that the indentation commands won't get confused (i.e., the string
	164	should be of the form `#x...' where `x' is not a blank or a tab, and
	165	`...' is arbitrary). However, this string should not end in whitespace."
	166	:type 'string
	167	:group 'python)
	168
	169	(defcustom py-honor-comment-indentation t
	170	"*Controls how comment lines influence subsequent indentation.
	171
	172	When nil, all comment lines are skipped for indentation purposes, and
	173	if possible, a faster algorithm is used (i.e. X/Emacs 19 and beyond).
	174
	175	When t, lines that begin with a single `#' are a hint to subsequent
	176	line indentation. If the previous line is such a comment line (as
	177	opposed to one that starts with `py-block-comment-prefix'), then its
	178	indentation is used as a hint for this line's indentation. Lines that
	179	begin with `py-block-comment-prefix' are ignored for indentation
	180	purposes.
	181
	182	When not nil or t, comment lines that begin with a single `#' are used
	183	as indentation 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)
	187	(const :tag "Single # `sets' indentation except at column zero"
	188	other)
	189	)
	190	:group 'python)
	191
	192	(defcustom py-temp-directory
	193	(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))))
	199	(or (funcall ok (getenv "TMPDIR"))
	200	(funcall ok "/usr/tmp")
	201	(funcall ok "/tmp")
	202	(funcall ok "/var/tmp")
	203	(funcall ok ".")
	204	(error
	205	"Couldn't find a usable temp directory -- set `py-temp-directory'")))
	206	"Directory used for temporary files created by a Python* process.
	207	By default, the first directory from this list that exists and that you
	208	can write into: the value (if any) of the environment variable TMPDIR,
	209	/usr/tmp, /tmp, /var/tmp, or the current directory."
	210	:type 'string
	211	:group 'python)
	212
	213	(defcustom py-beep-if-tab-change t
	214	"*Ring the bell if `tab-width' is changed.
	215	If a comment of the form
	216
	217	\t# vi:set tabsize=<number>:
	218
	219	is found before the first code line when the file is entered, and the
	220	current value of (the general Emacs variable) `tab-width' does not
	221	equal <number>, `tab-width' is set to <number>, a message saying so is
	222	displayed in the echo area, and if `py-beep-if-tab-change' is non-nil
	223	the Emacs bell is also rung as a warning."
	224	:type 'boolean
	225	:group 'python)
	226
	227	(defcustom py-jump-on-exception t
	228	"Jump to innermost exception frame in Python Output* buffer.
	229	When this variable is non-nil and an exception occurs when running
	230	Python code synchronously in a subprocess, jump immediately to the
	231	source code of the innermost traceback frame."
	232	:type 'boolean
	233	:group 'python)
	234
	235	(defcustom py-ask-about-save t
	236	"If not nil, ask about which buffers to save before executing some code.
	237	Otherwise, all modified buffers are saved without asking."
	238	:type 'boolean
	239	:group 'python)
	240
	241	(defcustom py-backspace-function 'backward-delete-char-untabify
	242	"*Function called by `py-electric-backspace' when deleting backwards."
	243	:type 'function
	244	:group 'python)
	245
	246	(defcustom py-delete-function 'delete-char
	247	"*Function called by `py-electric-delete' when deleting forwards."
	248	:type 'function
	249	:group 'python)
	250
	251	(defcustom py-imenu-show-method-args-p nil
	252	"*Controls echoing of arguments of functions & methods in the Imenu buffer.
	253	When non-nil, arguments are printed."
	254	:type 'boolean
	255	:group 'python)
	256	(make-variable-buffer-local 'py-indent-offset)
	257
	258	(defcustom py-pdbtrack-do-tracking-p t
	259	"*Controls whether the pdbtrack feature is enabled or not.
	260	When non-nil, pdbtrack is enabled in all comint-based buffers,
	261	e.g. shell buffers and the Python buffer. When using pdb to debug a
	262	Python program, pdbtrack notices the pdb prompt and displays the
	263	source file and line that the program is stopped at, much the same way
	264	as gud-mode does for debugging C programs with gdb."
	265	:type 'boolean
	266	:group 'python)
	267	(make-variable-buffer-local 'py-pdbtrack-do-tracking-p)
	268
	269	(defcustom py-pdbtrack-minor-mode-string " PDB"
	270	"*String to use in the minor mode list when pdbtrack is enabled."
	271	:type 'string
	272	:group 'python)
	273
	274	(defcustom py-import-check-point-max
	275	20000
	276	"Maximum number of characters to search for a Java-ish import statement.
	277	When `python-mode' tries to calculate the shell to use (either a
	278	CPython or a JPython shell), it looks at the so-called `shebang' line
	279	-- i.e. #! line. If that's not available, it looks at some of the
	280	file heading imports to see if they look Java-like."
	281	:type 'integer
	282	:group 'python
	283	)
	284
	285	(defcustom py-jpython-packages
	286	'("java" "javax" "org" "com")
	287	"Imported packages that imply `jpython-mode'."
	288	:type '(repeat string)
	289	:group 'python)
	290
	291	;; Not customizable
	292	(defvar py-master-file nil
	293	"If non-nil, execute the named file instead of the buffer's file.
	294	The intent is to allow you to set this variable in the file's local
	295	variable section, e.g.:
	296
	297	# Local Variables:
	298	# py-master-file: \"master.py\"
	299	# End:
	300
	301	so that typing \\[py-execute-buffer] in that buffer executes the named
	302	master file instead of the buffer's file. If the file name has a
	303	relative path, the value of variable `default-directory' for the
	304	buffer is prepended to come up with a file name.")
	305	(make-variable-buffer-local 'py-master-file)
	306
	307	(defcustom py-pychecker-command "pychecker"
	308	"*Shell command used to run Pychecker."
	309	:type 'string
	310	:group 'python
	311	:tag "Pychecker Command")
	312
	313	(defcustom py-pychecker-command-args '("--stdlib")
	314	"*List of string arguments to be passed to pychecker."
	315	:type '(repeat string)
	316	:group 'python
	317	:tag "Pychecker Command Args")
	318
	319	(defvar py-shell-alist
	320	'(("jpython" . 'jpython)
	321	("jython" . 'jpython)
	322	("python" . 'cpython))
	323	"*Alist of interpreters and python shells. Used by `py-choose-shell'
	324	to select the appropriate python interpreter mode for a file.")
	325
	326
	327	;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
	328	;; NO USER DEFINABLE VARIABLES BEYOND THIS POINT
	329
	330	(defconst py-emacs-features
	331	(let (features)
	332	features)
	333	"A list of features extant in the Emacs you are using.
	334	There are many flavors of Emacs out there, with different levels of
	335	support for features needed by `python-mode'.")
	336
	337	;; Face for None, True, False, self, and Ellipsis
	338	(defvar py-pseudo-keyword-face 'py-pseudo-keyword-face
	339	"Face for pseudo keywords in Python mode, like self, True, False, Ellipsis.")
	340	(make-face 'py-pseudo-keyword-face)
	341
	342	(defun py-font-lock-mode-hook ()
	343	(or (face-differs-from-default-p 'py-pseudo-keyword-face)
	344	(copy-face 'font-lock-keyword-face 'py-pseudo-keyword-face)))
	345	(add-hook 'font-lock-mode-hook 'py-font-lock-mode-hook)
	346
	347	(defvar python-font-lock-keywords
	348	(let ((kw1 (mapconcat 'identity
	349	'("and" "assert" "break" "class"
	350	"continue" "def" "del" "elif"
	351	"else" "except" "exec" "for"
	352	"from" "global" "if" "import"
	353	"in" "is" "lambda" "not"
	354	"or" "pass" "print" "raise"
	355	"return" "while" "yield"
	356	)
	357	"\\\|"))
	358	(kw2 (mapconcat 'identity
	359	'("else:" "except:" "finally:" "try:")
	360	"\\\|"))
	361	(kw3 (mapconcat 'identity
	362	'("ArithmeticError" "AssertionError"
	363	"AttributeError" "DeprecationWarning" "EOFError"
	364	"Ellipsis" "EnvironmentError" "Exception" "False"
	365	"FloatingPointError" "FutureWarning" "IOError"
	366	"ImportError" "IndentationError" "IndexError"
	367	"KeyError" "KeyboardInterrupt" "LookupError"
	368	"MemoryError" "NameError" "None" "NotImplemented"
	369	"NotImplementedError" "OSError" "OverflowError"
	370	"OverflowWarning" "PendingDeprecationWarning"
	371	"ReferenceError" "RuntimeError" "RuntimeWarning"
	372	"StandardError" "StopIteration" "SyntaxError"
	373	"SyntaxWarning" "SystemError" "SystemExit"
	374	"TabError" "True" "TypeError" "UnboundLocalError"
	375	"UnicodeDecodeError" "UnicodeEncodeError"
	376	"UnicodeError" "UnicodeTranslateError"
	377	"UserWarning" "ValueError" "Warning"
	378	"ZeroDivisionError" "__debug__"
	379	"__import__" "__name__" "abs" "apply" "basestring"
	380	"bool" "buffer" "callable" "chr" "classmethod"
	381	"cmp" "coerce" "compile" "complex" "copyright"
	382	"delattr" "dict" "dir" "divmod"
	383	"enumerate" "eval" "execfile" "exit" "file"
	384	"filter" "float" "getattr" "globals" "hasattr"
	385	"hash" "hex" "id" "input" "int" "intern"
	386	"isinstance" "issubclass" "iter" "len" "license"
	387	"list" "locals" "long" "map" "max" "min" "object"
	388	"oct" "open" "ord" "pow" "property" "range"
	389	"raw_input" "reduce" "reload" "repr" "round"
	390	"setattr" "slice" "staticmethod" "str" "sum"
	391	"super" "tuple" "type" "unichr" "unicode" "vars"
	392	"xrange" "zip")
	393	"\\\|"))
	394	)
	395	(list
	396	;; keywords
	397	(cons (concat "\\b\$" kw1 "\$\\b[ \n\t(]") 1)
	398	;; builtins when they don't appear as object attributes
	399	(cons (concat "\$\\b\\\|[.]\$\$" kw3 "\$\\b[ \n\t(]") 2)
	400	;; block introducing keywords with immediately following colons.
	401	;; Yes "except" is in both lists.
	402	(cons (concat "\\b\$" kw2 "\$[ \n\t(]") 1)
	403	;; `as' but only in "import foo as bar"
	404	'("[ \t]\$\\bfrom\\b.\$?\\bimport\\b.*\\b\$as\$\\b" . 2)
	405	;; classes
	406	'("\\bclass[ \t]+\$[a-zA-Z_]+[a-zA-Z0-9_]*\$"
	407	1 font-lock-type-face)
	408	;; functions
	409	'("\\bdef[ \t]+\$[a-zA-Z_]+[a-zA-Z0-9_]*\$"
	410	1 font-lock-function-name-face)
	411	;; pseudo-keywords
	412	'("\\b\$self\\\|None\\\|True\\\|False\\\|Ellipsis\$\\b"
	413	1 py-pseudo-keyword-face)
	414	))
	415	"Additional expressions to highlight in Python mode.")
	416	(put 'python-mode 'font-lock-defaults '(python-font-lock-keywords))
	417
	418	;; have to bind py-file-queue before installing the kill-emacs-hook
	419	(defvar py-file-queue nil
	420	"Queue of Python temp files awaiting execution.
	421	Currently-active file is at the head of the list.")
	422
	423	(defvar py-pdbtrack-is-tracking-p nil)
	424	(defvar py-pdbtrack-last-grubbed-buffer nil
	425	"Record of the last buffer used when the source path was invalid.
	426
	427	This buffer is consulted before the buffer-list history for satisfying
	428	`py-pdbtrack-grub-for-buffer', since it's the most often the likely
	429	prospect as debugging continues.")
	430	(make-variable-buffer-local 'py-pdbtrack-last-grubbed-buffer)
	431	(defvar py-pychecker-history nil)
	432
	433
	434
	435	;; Constants
	436
	437	(defconst py-stringlit-re
	438	(concat
	439	;; These fail if backslash-quote ends the string (not worth
	440	;; fixing?). They precede the short versions so that the first two
	441	;; quotes don't look like an empty short string.
	442	;;
	443	;; (maybe raw), long single quoted triple quoted strings (SQTQ),
	444	;; with potential embedded single quotes
	445	"[rR]?'''[^']\$\\('[^']\\\|''[^']\$[^']\\)*'''"
	446	"\\\|"
	447	;; (maybe raw), long double quoted triple quoted strings (DQTQ),
	448	;; with potential embedded double quotes
	449	"[rR]?\"\"\"[^\"]\$\\(\"[^\"]\\\|\"\"[^\"]\$[^\"]\\)*\"\"\""
	450	"\\\|"
	451	"[rR]?'\$[^'\n\\]\\\|\\\\.\$*'" ; single-quoted
	452	"\\\|" ; or
	453	"[rR]?\"\$[^\"\n\\]\\\|\\\\.\$*\"" ; double-quoted
	454	)
	455	"Regular expression matching a Python string literal.")
	456
	457	(defconst py-continued-re
	458	;; This is tricky because a trailing backslash does not mean
	459	;; continuation if it's in a comment
	460	(concat
	461	"\$" "[^#'\"\n\\]" "\\\|" py-stringlit-re "\$*"
	462	"\\\\$")
	463	"Regular expression matching Python backslash continuation lines.")
	464
	465	(defconst py-blank-or-comment-re "[ \t]*\$$\\\|#\$"
	466	"Regular expression matching a blank or comment line.")
	467
	468	(defconst py-outdent-re
	469	(concat "\\(" (mapconcat 'identity
	470	'("else:"
	471	"except\$\\s +.*\$?:"
	472	"finally:"
	473	"elif\\s +.*:")
	474	"\\\|")
	475	"\\)")
	476	"Regular expression matching statements to be dedented one level.")
	477
	478	(defconst py-block-closing-keywords-re
	479	"\$return\\\|raise\\\|break\\\|continue\\\|pass\$"
	480	"Regular expression matching keywords which typically close a block.")
	481
	482	(defconst py-no-outdent-re
	483	(concat
	484	"\\("
	485	(mapconcat 'identity
	486	(list "try:"
	487	"except\$\\s +.*\$?:"
	488	"while\\s +.*:"
	489	"for\\s +.*:"
	490	"if\\s +.*:"
	491	"elif\\s +.*:"
	492	(concat py-block-closing-keywords-re "[ \t\n]")
	493	)
	494	"\\\|")
	495	"\\)")
	496	"Regular expression matching lines not to dedent after.")
	497
	498	(defconst py-defun-start-re
	499	"^\$[ \t]\$def[ \t]+\$[a-zA-Z_0-9]+\$\\\|\$^[a-zA-Z_0-9]+\$[ \t]="
	500	;; If you change this, you probably have to change py-current-defun
	501	;; as well. This is only used by py-current-defun to find the name
	502	;; for add-log.el.
	503	"Regular expression matching a function, method, or variable assignment.")
	504
	505	(defconst py-class-start-re "^class[ \t]*\$[a-zA-Z_0-9]+\$"
	506	;; If you change this, you probably have to change py-current-defun
	507	;; as well. This is only used by py-current-defun to find the name
	508	;; for add-log.el.
	509	"Regular expression for finding a class name.")
	510
	511	(defconst py-traceback-line-re
	512	"[ \t]+File \"\$[^\"]+\$\", line \$[0-9]+\$"
	513	"Regular expression that describes tracebacks.")
	514
	515	;; pdbtrack contants
	516	(defconst py-pdbtrack-stack-entry-regexp
	517	; "^> \$[^(]+\$(\$[0-9]+\$)\$[?a-zA-Z0-9_]+\$()"
	518	"^> \$.*\$(\$[0-9]+\$)\$[?a-zA-Z0-9_]+\$()"
	519	"Regular expression pdbtrack uses to find a stack trace entry.")
	520
	521	(defconst py-pdbtrack-input-prompt "\n[(<]*pdb[>)]+ "
	522	"Regular expression pdbtrack uses to recognize a pdb prompt.")
	523
	524	(defconst py-pdbtrack-track-range 10000
	525	"Max number of characters from end of buffer to search for stack entry.")
	526
	527
	528
	529	;; Major mode boilerplate
	530
	531	;; define a mode-specific abbrev table for those who use such things
	532	(defvar python-mode-abbrev-table nil
	533	"Abbrev table in use in `python-mode' buffers.")
	534	(define-abbrev-table 'python-mode-abbrev-table nil)
	535
	536	(defvar python-mode-hook nil
	537	"*Hook called by `python-mode'.")
	538
	539	(defvar jpython-mode-hook nil
	540	"*Hook called by `jpython-mode'. `jpython-mode' also calls
	541	`python-mode-hook'.")
	542
	543	(defvar py-shell-hook nil
	544	"*Hook called by `py-shell'.")
	545
	546	;; In previous version of python-mode.el, the hook was incorrectly
	547	;; called py-mode-hook, and was not defvar'd. Deprecate its use.
	548	(and (fboundp 'make-obsolete-variable)
	549	(make-obsolete-variable 'py-mode-hook 'python-mode-hook))
	550
	551	(defvar py-mode-map ()
	552	"Keymap used in `python-mode' buffers.")
	553	(if py-mode-map
	554	nil
	555	(setq py-mode-map (make-sparse-keymap))
	556	;; electric keys
	557	(define-key py-mode-map ":" 'py-electric-colon)
	558	;; indentation level modifiers
	559	(define-key py-mode-map "\C-c\C-l" 'py-shift-region-left)
	560	(define-key py-mode-map "\C-c\C-r" 'py-shift-region-right)
	561	(define-key py-mode-map "\C-c<" 'py-shift-region-left)
	562	(define-key py-mode-map "\C-c>" 'py-shift-region-right)
	563	;; paragraph and string filling
	564	(define-key py-mode-map "\eq" 'py-fill-paragraph)
	565	;; subprocess commands
	566	(define-key py-mode-map "\C-c\C-c" 'py-execute-buffer)
	567	(define-key py-mode-map "\C-c\C-m" 'py-execute-import-or-reload)
	568	(define-key py-mode-map "\C-c\C-s" 'py-execute-string)
	569	(define-key py-mode-map "\C-c\|" 'py-execute-region)
	570	(define-key py-mode-map "\e\C-x" 'py-execute-def-or-class)
	571	(define-key py-mode-map "\C-c!" 'py-shell)
	572	(define-key py-mode-map "\C-c\C-t" 'py-toggle-shells)
	573	;; Caution! Enter here at your own risk. We are trying to support
	574	;; several behaviors and it gets disgusting. :-( This logic ripped
	575	;; largely from CC Mode.
	576	;;
	577	;; In XEmacs 19, Emacs 19, and Emacs 20, we use this to bind
	578	;; backwards deletion behavior to DEL, which both Delete and
	579	;; Backspace get translated to. There's no way to separate this
	580	;; behavior in a clean way, so deal with it! Besides, it's been
	581	;; this way since the dawn of time.
	582	(if (not (boundp 'delete-key-deletes-forward))
	583	(define-key py-mode-map "\177" 'py-electric-backspace)
	584	;; However, XEmacs 20 actually achieved enlightenment. It is
	585	;; possible to sanely define both backward and forward deletion
	586	;; behavior under X separately (TTYs are forever beyond hope, but
	587	;; who cares? XEmacs 20 does the right thing with these too).
	588	(define-key py-mode-map [delete] 'py-electric-delete)
	589	(define-key py-mode-map [backspace] 'py-electric-backspace))
	590	;; Separate M-BS from C-M-h. The former should remain
	591	;; backward-kill-word.
	592	(define-key py-mode-map [(control meta h)] 'py-mark-def-or-class)
	593	(define-key py-mode-map "\C-c\C-k" 'py-mark-block)
	594	;; Miscellaneous
	595	(define-key py-mode-map "\C-c:" 'py-guess-indent-offset)
	596	(define-key py-mode-map "\C-c\t" 'py-indent-region)
	597	(define-key py-mode-map "\C-c\C-d" 'py-pdbtrack-toggle-stack-tracking)
	598	(define-key py-mode-map "\C-c\C-n" 'py-next-statement)
	599	(define-key py-mode-map "\C-c\C-p" 'py-previous-statement)
	600	(define-key py-mode-map "\C-c\C-u" 'py-goto-block-up)
	601	(define-key py-mode-map "\C-c#" 'py-comment-region)
	602	(define-key py-mode-map "\C-c?" 'py-describe-mode)
	603	(define-key py-mode-map "\C-c\C-h" 'py-help-at-point)
	604	(define-key py-mode-map "\e\C-a" 'py-beginning-of-def-or-class)
	605	(define-key py-mode-map "\e\C-e" 'py-end-of-def-or-class)
	606	(define-key py-mode-map "\C-c-" 'py-up-exception)
	607	(define-key py-mode-map "\C-c=" 'py-down-exception)
	608	;; stuff that is `standard' but doesn't interface well with
	609	;; python-mode, which forces us to rebind to special commands
	610	(define-key py-mode-map "\C-xnd" 'py-narrow-to-defun)
	611	;; information
	612	(define-key py-mode-map "\C-c\C-b" 'py-submit-bug-report)
	613	(define-key py-mode-map "\C-c\C-v" 'py-version)
	614	(define-key py-mode-map "\C-c\C-w" 'py-pychecker-run)
	615	;; shadow global bindings for newline-and-indent w/ the py- version.
	616	;; BAW - this is extremely bad form, but I'm not going to change it
	617	;; for now.
	618	(mapcar #'(lambda (key)
	619	(define-key py-mode-map key 'py-newline-and-indent))
	620	(where-is-internal 'newline-and-indent))
	621	;; Force RET to be py-newline-and-indent even if it didn't get
	622	;; mapped by the above code. motivation: Emacs' default binding for
	623	;; RET is `newline' and C-j is `newline-and-indent'. Most Pythoneers
	624	;; expect RET to do a `py-newline-and-indent' and any Emacsers who
	625	;; dislike this are probably knowledgeable enough to do a rebind.
	626	;; However, we do not change C-j since many Emacsers have already
	627	;; swapped RET and C-j and they don't want C-j bound to `newline' to
	628	;; change.
	629	(define-key py-mode-map "\C-m" 'py-newline-and-indent)
	630	)
	631
	632	(defvar py-mode-output-map nil
	633	"Keymap used in Python Output buffers.")
	634	(if py-mode-output-map
	635	nil
	636	(setq py-mode-output-map (make-sparse-keymap))
	637	(define-key py-mode-output-map [button2] 'py-mouseto-exception)
	638	(define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)
	639	;; TBD: Disable all self-inserting keys. This is bogus, we should
	640	;; really implement this as Python Output buffer being read-only
	641	(mapcar #' (lambda (key)
	642	(define-key py-mode-output-map key
	643	#'(lambda () (interactive) (beep))))
	644	(where-is-internal 'self-insert-command))
	645	)
	646
	647	(defvar py-shell-map nil
	648	"Keymap used in Python shell buffers.")
	649	(if py-shell-map
	650	nil
	651	(setq py-shell-map (copy-keymap comint-mode-map))
	652	(define-key py-shell-map [tab] 'tab-to-tab-stop)
	653	(define-key py-shell-map "\C-c-" 'py-up-exception)
	654	(define-key py-shell-map "\C-c=" 'py-down-exception)
	655	)
	656
	657	(defvar py-mode-syntax-table nil
	658	"Syntax table used in `python-mode' buffers.")
	659	(when (not py-mode-syntax-table)
	660	(setq py-mode-syntax-table (make-syntax-table))
	661	(modify-syntax-entry ?\( "()" py-mode-syntax-table)
	662	(modify-syntax-entry ?\) ")(" py-mode-syntax-table)
	663	(modify-syntax-entry ?\[ "(]" py-mode-syntax-table)
	664	(modify-syntax-entry ?\] ")[" py-mode-syntax-table)
	665	(modify-syntax-entry ?\{ "(}" py-mode-syntax-table)
	666	(modify-syntax-entry ?\} "){" py-mode-syntax-table)
	667	;; Add operator symbols misassigned in the std table
	668	(modify-syntax-entry ?\$ "." py-mode-syntax-table)
	669	(modify-syntax-entry ?\% "." py-mode-syntax-table)
	670	(modify-syntax-entry ?\& "." py-mode-syntax-table)
	671	(modify-syntax-entry ?\* "." py-mode-syntax-table)
	672	(modify-syntax-entry ?\+ "." py-mode-syntax-table)
	673	(modify-syntax-entry ?\- "." py-mode-syntax-table)
	674	(modify-syntax-entry ?\/ "." py-mode-syntax-table)
	675	(modify-syntax-entry ?\< "." py-mode-syntax-table)
	676	(modify-syntax-entry ?\= "." py-mode-syntax-table)
	677	(modify-syntax-entry ?\> "." py-mode-syntax-table)
	678	(modify-syntax-entry ?\\| "." py-mode-syntax-table)
	679	;; For historical reasons, underscore is word class instead of
	680	;; symbol class. GNU conventions say it should be symbol class, but
	681	;; there's a natural conflict between what major mode authors want
	682	;; and what users expect from `forward-word' and `backward-word'.
	683	;; Guido and I have hashed this out and have decided to keep
	684	;; underscore in word class. If you're tempted to change it, try
	685	;; binding M-f and M-b to py-forward-into-nomenclature and
	686	;; py-backward-into-nomenclature instead. This doesn't help in all
	687	;; situations where you'd want the different behavior
	688	;; (e.g. backward-kill-word).
	689	(modify-syntax-entry ?\_ "w" py-mode-syntax-table)
	690	;; Both single quote and double quote are string delimiters
	691	(modify-syntax-entry ?\' "\"" py-mode-syntax-table)
	692	(modify-syntax-entry ?\" "\"" py-mode-syntax-table)
	693	;; backquote is open and close paren
	694	(modify-syntax-entry ?\` "$" py-mode-syntax-table)
	695	;; comment delimiters
	696	(modify-syntax-entry ?\# "<" py-mode-syntax-table)
	697	(modify-syntax-entry ?\n ">" py-mode-syntax-table)
	698	)
	699
	700	;; An auxiliary syntax table which places underscore and dot in the
	701	;; symbol class for simplicity
	702	(defvar py-dotted-expression-syntax-table nil
	703	"Syntax table used to identify Python dotted expressions.")
	704	(when (not py-dotted-expression-syntax-table)
	705	(setq py-dotted-expression-syntax-table
	706	(copy-syntax-table py-mode-syntax-table))
	707	(modify-syntax-entry ?_ "_" py-dotted-expression-syntax-table)
	708	(modify-syntax-entry ?. "_" py-dotted-expression-syntax-table))
	709
	710
	711
	712	;; Utilities
	713	(defmacro py-safe (&rest body)
	714	"Safely execute BODY, return nil if an error occurred."
	715	(` (condition-case nil
	716	(progn (,@ body))
	717	(error nil))))
	718
	719	(defsubst py-keep-region-active ()
	720	"Keep the region active in XEmacs."
	721	;; Ignore byte-compiler warnings you might see. Also note that
	722	;; FSF's Emacs 19 does it differently; its policy doesn't require us
	723	;; to take explicit action.
	724	(and (boundp 'zmacs-region-stays)
	725	(setq zmacs-region-stays t)))
	726
	727	(defsubst py-point (position)
	728	"Returns the value of point at certain commonly referenced POSITIONs.
	729	POSITION can be one of the following symbols:
	730
	731	bol -- beginning of line
	732	eol -- end of line
	733	bod -- beginning of def or class
	734	eod -- end of def or class
	735	bob -- beginning of buffer
	736	eob -- end of buffer
	737	boi -- back to indentation
	738	bos -- beginning of statement
	739
	740	This function does not modify point or mark."
	741	(let ((here (point)))
	742	(cond
	743	((eq position 'bol) (beginning-of-line))
	744	((eq position 'eol) (end-of-line))
	745	((eq position 'bod) (py-beginning-of-def-or-class))
	746	((eq position 'eod) (py-end-of-def-or-class))
	747	;; Kind of funny, I know, but useful for py-up-exception.
	748	((eq position 'bob) (beginning-of-buffer))
	749	((eq position 'eob) (end-of-buffer))
	750	((eq position 'boi) (back-to-indentation))
	751	((eq position 'bos) (py-goto-initial-line))
	752	(t (error "Unknown buffer position requested: %s" position))
	753	)
	754	(prog1
	755	(point)
	756	(goto-char here))))
	757
	758	(defsubst py-highlight-line (from to file line)
	759	(cond
	760	((fboundp 'make-extent)
	761	;; XEmacs
	762	(let ((e (make-extent from to)))
	763	(set-extent-property e 'mouse-face 'highlight)
	764	(set-extent-property e 'py-exc-info (cons file line))
	765	(set-extent-property e 'keymap py-mode-output-map)))
	766	(t
	767	;; Emacs -- Please port this!
	768	)
	769	))
	770
	771	(defun py-in-literal (&optional lim)
	772	"Return non-nil if point is in a Python literal (a comment or string).
	773	Optional argument LIM indicates the beginning of the containing form,
	774	i.e. the limit on how far back to scan."
	775	;; This is the version used for non-XEmacs, which has a nicer
	776	;; interface.
	777	;;
	778	;; WARNING: Watch out for infinite recursion.
	779	(let* ((lim (or lim (py-point 'bod)))
	780	(state (parse-partial-sexp lim (point))))
	781	(cond
	782	((nth 3 state) 'string)
	783	((nth 4 state) 'comment)
	784	(t nil))))
	785
	786	;; XEmacs has a built-in function that should make this much quicker.
	787	;; In this case, lim is ignored
	788	(defun py-fast-in-literal (&optional lim)
	789	"Fast version of `py-in-literal', used only by XEmacs.
	790	Optional LIM is ignored."
	791	;; don't have to worry about context == 'block-comment
	792	(buffer-syntactic-context))
	793
	794	(if (fboundp 'buffer-syntactic-context)
	795	(defalias 'py-in-literal 'py-fast-in-literal))
	796
	797
	798
	799	;; Menu definitions, only relevent if you have the easymenu.el package
	800	;; (standard in the latest Emacs 19 and XEmacs 19 distributions).
	801	(defvar py-menu nil
	802	"Menu for Python Mode.
	803	This menu will get created automatically if you have the `easymenu'
	804	package. Note that the latest X/Emacs releases contain this package.")
	805
	806	(and (py-safe (require 'easymenu) t)
	807	(easy-menu-define
	808	py-menu py-mode-map "Python Mode menu"
	809	'("Python"
	810	["Comment Out Region" py-comment-region (mark)]
	811	["Uncomment Region" (py-comment-region (point) (mark) '(4)) (mark)]
	812	"-"
	813	["Mark current block" py-mark-block t]
	814	["Mark current def" py-mark-def-or-class t]
	815	["Mark current class" (py-mark-def-or-class t) t]
	816	"-"
	817	["Shift region left" py-shift-region-left (mark)]
	818	["Shift region right" py-shift-region-right (mark)]
	819	"-"
	820	["Import/reload file" py-execute-import-or-reload t]
	821	["Execute buffer" py-execute-buffer t]
	822	["Execute region" py-execute-region (mark)]
	823	["Execute def or class" py-execute-def-or-class (mark)]
	824	["Execute string" py-execute-string t]
	825	["Start interpreter..." py-shell t]
	826	"-"
	827	["Go to start of block" py-goto-block-up t]
	828	["Go to start of class" (py-beginning-of-def-or-class t) t]
	829	["Move to end of class" (py-end-of-def-or-class t) t]
	830	["Move to start of def" py-beginning-of-def-or-class t]
	831	["Move to end of def" py-end-of-def-or-class t]
	832	"-"
	833	["Describe mode" py-describe-mode t]
	834	)))
	835
	836
	837
	838	;; Imenu definitions
	839	(defvar py-imenu-class-regexp
	840	(concat ; <<classes>>
	841	"\\(" ;
	842	"^[ \t]*" ; newline and maybe whitespace
	843	"\$class[ \t]+[a-zA-Z0-9_]+\$" ; class name
	844	; possibly multiple superclasses
	845	"\$[ \t]\\((\\([a-zA-Z0-9_,. \t\n]\$)\\)?\\)"
	846	"[ \t]*:" ; and the final :
	847	"\\)" ; >>classes<<
	848	)
	849	"Regexp for Python classes for use with the Imenu package."
	850	)
	851
	852	(defvar py-imenu-method-regexp
	853	(concat ; <<methods and functions>>
	854	"\\(" ;
	855	"^[ \t]*" ; new line and maybe whitespace
	856	"\\(def[ \t]+" ; function definitions start with def
	857	"\$[a-zA-Z0-9_]+\$" ; name is here
	858	; function arguments...
	859	;; "[ \t](\$[-+/a-zA-Z0-9_=,\ \t\n.()\"'#]*\$)"
	860	"[ \t](\$[^:#]\$)"
	861	"\\)" ; end of def
	862	"[ \t]*:" ; and then the :
	863	"\\)" ; >>methods and functions<<
	864	)
	865	"Regexp for Python methods/functions for use with the Imenu package."
	866	)
	867
	868	(defvar py-imenu-method-no-arg-parens '(2 8)
	869	"Indices into groups of the Python regexp for use with Imenu.
	870
	871	Using these values will result in smaller Imenu lists, as arguments to
	872	functions are not listed.
	873
	874	See the variable `py-imenu-show-method-args-p' for more
	875	information.")
	876
	877	(defvar py-imenu-method-arg-parens '(2 7)
	878	"Indices into groups of the Python regexp for use with imenu.
	879	Using these values will result in large Imenu lists, as arguments to
	880	functions are listed.
	881
	882	See the variable `py-imenu-show-method-args-p' for more
	883	information.")
	884
	885	;; Note that in this format, this variable can still be used with the
	886	;; imenu--generic-function. Otherwise, there is no real reason to have
	887	;; it.
	888	(defvar py-imenu-generic-expression
	889	(cons
	890	(concat
	891	py-imenu-class-regexp
	892	"\\\|" ; or...
	893	py-imenu-method-regexp
	894	)
	895	py-imenu-method-no-arg-parens)
	896	"Generic Python expression which may be used directly with Imenu.
	897	Used by setting the variable `imenu-generic-expression' to this value.
	898	Also, see the function \\[py-imenu-create-index] for a better
	899	alternative for finding the index.")
	900
	901	;; These next two variables are used when searching for the Python
	902	;; class/definitions. Just saving some time in accessing the
	903	;; generic-python-expression, really.
	904	(defvar py-imenu-generic-regexp nil)
	905	(defvar py-imenu-generic-parens nil)
	906
	907
	908	(defun py-imenu-create-index-function ()
	909	"Python interface function for the Imenu package.
	910	Finds all Python classes and functions/methods. Calls function
	911	\\[py-imenu-create-index-engine]. See that function for the details
	912	of how this works."
	913	(setq py-imenu-generic-regexp (car py-imenu-generic-expression)
	914	py-imenu-generic-parens (if py-imenu-show-method-args-p
	915	py-imenu-method-arg-parens
	916	py-imenu-method-no-arg-parens))
	917	(goto-char (point-min))
	918	;; Warning: When the buffer has no classes or functions, this will
	919	;; return nil, which seems proper according to the Imenu API, but
	920	;; causes an error in the XEmacs port of Imenu. Sigh.
	921	(py-imenu-create-index-engine nil))
	922
	923	(defun py-imenu-create-index-engine (&optional start-indent)
	924	"Function for finding Imenu definitions in Python.
	925
	926	Finds all definitions (classes, methods, or functions) in a Python
	927	file for the Imenu package.
	928
	929	Returns a possibly nested alist of the form
	930
	931	(INDEX-NAME . INDEX-POSITION)
	932
	933	The second element of the alist may be an alist, producing a nested
	934	list as in
	935
	936	(INDEX-NAME . INDEX-ALIST)
	937
	938	This function should not be called directly, as it calls itself
	939	recursively and requires some setup. Rather this is the engine for
	940	the function \\[py-imenu-create-index-function].
	941
	942	It works recursively by looking for all definitions at the current
	943	indention level. When it finds one, it adds it to the alist. If it
	944	finds a definition at a greater indentation level, it removes the
	945	previous definition from the alist. In its place it adds all
	946	definitions found at the next indentation level. When it finds a
	947	definition that is less indented then the current level, it returns
	948	the alist it has created thus far.
	949
	950	The optional argument START-INDENT indicates the starting indentation
	951	at which to continue looking for Python classes, methods, or
	952	functions. If this is not supplied, the function uses the indentation
	953	of the first definition found."
	954	(let (index-alist
	955	sub-method-alist
	956	looking-p
	957	def-name prev-name
	958	cur-indent def-pos
	959	(class-paren (first py-imenu-generic-parens))
	960	(def-paren (second py-imenu-generic-parens)))
	961	(setq looking-p
	962	(re-search-forward py-imenu-generic-regexp (point-max) t))
	963	(while looking-p
	964	(save-excursion
	965	;; used to set def-name to this value but generic-extract-name
	966	;; is new to imenu-1.14. this way it still works with
	967	;; imenu-1.11
	968	;;(imenu--generic-extract-name py-imenu-generic-parens))
	969	(let ((cur-paren (if (match-beginning class-paren)
	970	class-paren def-paren)))
	971	(setq def-name
	972	(buffer-substring-no-properties (match-beginning cur-paren)
	973	(match-end cur-paren))))
	974	(save-match-data
	975	(py-beginning-of-def-or-class 'either))
	976	(beginning-of-line)
	977	(setq cur-indent (current-indentation)))
	978	;; HACK: want to go to the next correct definition location. We
	979	;; explicitly list them here but it would be better to have them
	980	;; in a list.
	981	(setq def-pos
	982	(or (match-beginning class-paren)
	983	(match-beginning def-paren)))
	984	;; if we don't have a starting indent level, take this one
	985	(or start-indent
	986	(setq start-indent cur-indent))
	987	;; if we don't have class name yet, take this one
	988	(or prev-name
	989	(setq prev-name def-name))
	990	;; what level is the next definition on? must be same, deeper
	991	;; or shallower indentation
	992	(cond
	993	;; Skip code in comments and strings
	994	((py-in-literal))
	995	;; at the same indent level, add it to the list...
	996	((= start-indent cur-indent)
	997	(push (cons def-name def-pos) index-alist))
	998	;; deeper indented expression, recurse
	999	((< start-indent cur-indent)
	1000	;; the point is currently on the expression we're supposed to
	1001	;; start on, so go back to the last expression. The recursive
	1002	;; call will find this place again and add it to the correct
	1003	;; list
	1004	(re-search-backward py-imenu-generic-regexp (point-min) 'move)
	1005	(setq sub-method-alist (py-imenu-create-index-engine cur-indent))
	1006	(if sub-method-alist
	1007	;; we put the last element on the index-alist on the start
	1008	;; of the submethod alist so the user can still get to it.
	1009	(let ((save-elmt (pop index-alist)))
	1010	(push (cons prev-name
	1011	(cons save-elmt sub-method-alist))
	1012	index-alist))))
	1013	;; found less indented expression, we're done.
	1014	(t
	1015	(setq looking-p nil)
	1016	(re-search-backward py-imenu-generic-regexp (point-min) t)))
	1017	;; end-cond
	1018	(setq prev-name def-name)
	1019	(and looking-p
	1020	(setq looking-p
	1021	(re-search-forward py-imenu-generic-regexp
	1022	(point-max) 'move))))
	1023	(nreverse index-alist)))
	1024
	1025
	1026
	1027	(defun py-choose-shell-by-shebang ()
	1028	"Choose CPython or JPython mode by looking at #! on the first line.
	1029	Returns the appropriate mode function.
	1030	Used by `py-choose-shell', and similar to but distinct from
	1031	`set-auto-mode', though it uses `auto-mode-interpreter-regexp' (if available)."
	1032	;; look for an interpreter specified in the first line
	1033	;; similar to set-auto-mode (files.el)
	1034	(let* ((re (if (boundp 'auto-mode-interpreter-regexp)
	1035	auto-mode-interpreter-regexp
	1036	;; stolen from Emacs 21.2
	1037	"#![ \t]?\$[^ \t\n]*/bin/env[ \t]\$?\$[^ \t\n]+\$"))
	1038	(interpreter (save-excursion
	1039	(goto-char (point-min))
	1040	(if (looking-at re)
	1041	(match-string 2)
	1042	"")))
	1043	elt)
	1044	;; Map interpreter name to a mode.
	1045	(setq elt (assoc (file-name-nondirectory interpreter)
	1046	py-shell-alist))
	1047	(and elt (caddr elt))))
	1048
	1049
	1050
	1051	(defun py-choose-shell-by-import ()
	1052	"Choose CPython or JPython mode based imports.
	1053	If a file imports any packages in `py-jpython-packages', within
	1054	`py-import-check-point-max' characters from the start of the file,
	1055	return `jpython', otherwise return nil."
	1056	(let (mode)
	1057	(save-excursion
	1058	(goto-char (point-min))
	1059	(while (and (not mode)
	1060	(search-forward-regexp
	1061	"^\$\\(from\$\\\|\$import\$\\) \$[^ \t\n.]+\$"
	1062	py-import-check-point-max t))
	1063	(setq mode (and (member (match-string 4) py-jpython-packages)
	1064	'jpython
	1065	))))
	1066	mode))
	1067
	1068
	1069	(defun py-choose-shell ()
	1070	"Choose CPython or JPython mode. Returns the appropriate mode function.
	1071	This does the following:
	1072	- look for an interpreter with `py-choose-shell-by-shebang'
	1073	- examine imports using `py-choose-shell-by-import'
	1074	- default to the variable `py-default-interpreter'"
	1075	(interactive)
	1076	(or (py-choose-shell-by-shebang)
	1077	(py-choose-shell-by-import)
	1078	py-default-interpreter
	1079	; 'cpython ;; don't use to py-default-interpreter, because default
	1080	; ;; is only way to choose CPython
	1081	))
	1082
	1083
	1084	;;;###autoload
	1085	(defun python-mode ()
	1086	"Major mode for editing Python files.
	1087	To submit a problem report, enter `\\[py-submit-bug-report]' from a
	1088	`python-mode' buffer. Do `\\[py-describe-mode]' for detailed
	1089	documentation. To see what version of `python-mode' you are running,
	1090	enter `\\[py-version]'.
	1091
	1092	This mode knows about Python indentation, tokens, comments and
	1093	continuation lines. Paragraphs are separated by blank lines only.
	1094
	1095	COMMANDS
	1096	\\{py-mode-map}
	1097	VARIABLES
	1098
	1099	py-indent-offset\t\tindentation increment
	1100	py-block-comment-prefix\t\tcomment string used by `comment-region'
	1101	py-python-command\t\tshell command to invoke Python interpreter
	1102	py-temp-directory\t\tdirectory used for temp files (if needed)
	1103	py-beep-if-tab-change\t\tring the bell if `tab-width' is changed"
	1104	(interactive)
	1105	;; set up local variables
	1106	(kill-all-local-variables)
	1107	(make-local-variable 'font-lock-defaults)
	1108	(make-local-variable 'paragraph-separate)
	1109	(make-local-variable 'paragraph-start)
	1110	(make-local-variable 'require-final-newline)
	1111	(make-local-variable 'comment-start)
	1112	(make-local-variable 'comment-end)
	1113	(make-local-variable 'comment-start-skip)
	1114	(make-local-variable 'comment-column)
	1115	(make-local-variable 'comment-indent-function)
	1116	(make-local-variable 'indent-region-function)
	1117	(make-local-variable 'indent-line-function)
	1118	(make-local-variable 'add-log-current-defun-function)
	1119	;;
	1120	(set-syntax-table py-mode-syntax-table)
	1121	(setq major-mode 'python-mode
	1122	mode-name "Python"
	1123	local-abbrev-table python-mode-abbrev-table
	1124	font-lock-defaults '(python-font-lock-keywords)
	1125	paragraph-separate "^[ \t]*$"
	1126	paragraph-start "^[ \t]*$"
	1127	require-final-newline t
	1128	comment-start "# "
	1129	comment-end ""
	1130	comment-start-skip "# *"
	1131	comment-column 40
	1132	comment-indent-function 'py-comment-indent-function
	1133	indent-region-function 'py-indent-region
	1134	indent-line-function 'py-indent-line
	1135	;; tell add-log.el how to find the current function/method/variable
	1136	add-log-current-defun-function 'py-current-defun
	1137	)
	1138	(use-local-map py-mode-map)
	1139	;; add the menu
	1140	(if py-menu
	1141	(easy-menu-add py-menu))
	1142	;; Emacs 19 requires this
	1143	(if (boundp 'comment-multi-line)
	1144	(setq comment-multi-line nil))
	1145	;; Install Imenu if available
	1146	(when (py-safe (require 'imenu))
	1147	(setq imenu-create-index-function #'py-imenu-create-index-function)
	1148	(setq imenu-generic-expression py-imenu-generic-expression)
	1149	(if (fboundp 'imenu-add-to-menubar)
	1150	(imenu-add-to-menubar (format "%s-%s" "IM" mode-name)))
	1151	)
	1152	;; Run the mode hook. Note that py-mode-hook is deprecated.
	1153	(if python-mode-hook
	1154	(run-hooks 'python-mode-hook)
	1155	(run-hooks 'py-mode-hook))
	1156	;; Now do the automagical guessing
	1157	(if py-smart-indentation
	1158	(let ((offset py-indent-offset))
	1159	;; It's okay if this fails to guess a good value
	1160	(if (and (py-safe (py-guess-indent-offset))
	1161	(<= py-indent-offset 8)
	1162	(>= py-indent-offset 2))
	1163	(setq offset py-indent-offset))
	1164	(setq py-indent-offset offset)
	1165	;; Only turn indent-tabs-mode off if tab-width !=
	1166	;; py-indent-offset. Never turn it on, because the user must
	1167	;; have explicitly turned it off.
	1168	(if (/= tab-width py-indent-offset)
	1169	(setq indent-tabs-mode nil))
	1170	))
	1171	;; Set the default shell if not already set
	1172	(when (null py-which-shell)
	1173	(py-toggle-shells (py-choose-shell))))
	1174
	1175
	1176	(defun jpython-mode ()
	1177	"Major mode for editing JPython/Jython files.
	1178	This is a simple wrapper around `python-mode'.
	1179	It runs `jpython-mode-hook' then calls `python-mode.'
	1180	It is added to `interpreter-mode-alist' and `py-choose-shell'.
	1181	"
	1182	(interactive)
	1183	(python-mode)
	1184	(py-toggle-shells 'jpython)
	1185	(when jpython-mode-hook
	1186	(run-hooks 'jpython-mode-hook)))
	1187
	1188
	1189	;; It's handy to add recognition of Python files to the
	1190	;; interpreter-mode-alist and to auto-mode-alist. With the former, we
	1191	;; can specify different `derived-modes' based on the #! line, but
	1192	;; with the latter, we can't. So we just won't add them if they're
	1193	;; already added.
	1194	(let ((modes '(("jpython" . jpython-mode)
	1195	("jython" . jpython-mode)
	1196	("python" . python-mode))))
	1197	(while modes
	1198	(when (not (assoc (car modes) interpreter-mode-alist))
	1199	(push (car modes) interpreter-mode-alist))
	1200	(setq modes (cdr modes))))
	1201
	1202	(when (not (or (rassq 'python-mode auto-mode-alist)
	1203	(rassq 'jpython-mode auto-mode-alist)))
	1204	(push '("\\.py$" . python-mode) auto-mode-alist))
	1205
	1206
	1207
	1208	;; electric characters
	1209	(defun py-outdent-p ()
	1210	"Returns non-nil if the current line should dedent one level."
	1211	(save-excursion
	1212	(and (progn (back-to-indentation)
	1213	(looking-at py-outdent-re))
	1214	;; short circuit infloop on illegal construct
	1215	(not (bobp))
	1216	(progn (forward-line -1)
	1217	(py-goto-initial-line)
	1218	(back-to-indentation)
	1219	(while (or (looking-at py-blank-or-comment-re)
	1220	(bobp))
	1221	(backward-to-indentation 1))
	1222	(not (looking-at py-no-outdent-re)))
	1223	)))
	1224
	1225	(defun py-electric-colon (arg)
	1226	"Insert a colon.
	1227	In certain cases the line is dedented appropriately. If a numeric
	1228	argument ARG is provided, that many colons are inserted
	1229	non-electrically. Electric behavior is inhibited inside a string or
	1230	comment."
	1231	(interactive "*P")
	1232	(self-insert-command (prefix-numeric-value arg))
	1233	;; are we in a string or comment?
	1234	(if (save-excursion
	1235	(let ((pps (parse-partial-sexp (save-excursion
	1236	(py-beginning-of-def-or-class)
	1237	(point))
	1238	(point))))
	1239	(not (or (nth 3 pps) (nth 4 pps)))))
	1240	(save-excursion
	1241	(let ((here (point))
	1242	(outdent 0)
	1243	(indent (py-compute-indentation t)))
	1244	(if (and (not arg)
	1245	(py-outdent-p)
	1246	(= indent (save-excursion
	1247	(py-next-statement -1)
	1248	(py-compute-indentation t)))
	1249	)
	1250	(setq outdent py-indent-offset))
	1251	;; Don't indent, only dedent. This assumes that any lines
	1252	;; that are already dedented relative to
	1253	;; py-compute-indentation were put there on purpose. It's
	1254	;; highly annoying to have `:' indent for you. Use TAB, C-c
	1255	;; C-l or C-c C-r to adjust. TBD: Is there a better way to
	1256	;; determine this???
	1257	(if (< (current-indentation) indent) nil
	1258	(goto-char here)
	1259	(beginning-of-line)
	1260	(delete-horizontal-space)
	1261	(indent-to (- indent outdent))
	1262	)))))
	1263
	1264
	1265	;; Python subprocess utilities and filters
	1266	(defun py-execute-file (proc filename)
	1267	"Send to Python interpreter process PROC \"execfile('FILENAME')\".
	1268	Make that process's buffer visible and force display. Also make
	1269	comint believe the user typed this string so that
	1270	`kill-output-from-shell' does The Right Thing."
	1271	(let ((curbuf (current-buffer))
	1272	(procbuf (process-buffer proc))
	1273	; (comint-scroll-to-bottom-on-output t)
	1274	(msg (format "## working on region in file %s...\n" filename))
	1275	(cmd (format "execfile(r'%s')\n" filename)))
	1276	(unwind-protect
	1277	(save-excursion
	1278	(set-buffer procbuf)
	1279	(goto-char (point-max))
	1280	(move-marker (process-mark proc) (point))
	1281	(funcall (process-filter proc) proc msg))
	1282	(set-buffer curbuf))
	1283	(process-send-string proc cmd)))
	1284
	1285	(defun py-comint-output-filter-function (string)
	1286	"Watch output for Python prompt and exec next file waiting in queue.
	1287	This function is appropriate for `comint-output-filter-functions'."
	1288	;; TBD: this should probably use split-string
	1289	(when (and (or (string-equal string ">>> ")
	1290	(and (>= (length string) 5)
	1291	(string-equal (substring string -5) "\n>>> ")))
	1292	py-file-queue)
	1293	(pop-to-buffer (current-buffer))
	1294	(py-safe (delete-file (car py-file-queue)))
	1295	(setq py-file-queue (cdr py-file-queue))
	1296	(if py-file-queue
	1297	(let ((pyproc (get-buffer-process (current-buffer))))
	1298	(py-execute-file pyproc (car py-file-queue))))
	1299	))
	1300
	1301	(defun py-pdbtrack-overlay-arrow (activation)
	1302	"Activate or de arrow at beginning-of-line in current buffer."
	1303	;; This was derived/simplified from edebug-overlay-arrow
	1304	(cond (activation
	1305	(setq overlay-arrow-position (make-marker))
	1306	(setq overlay-arrow-string "=>")
	1307	(set-marker overlay-arrow-position (py-point 'bol) (current-buffer))
	1308	(setq py-pdbtrack-is-tracking-p t))
	1309	(overlay-arrow-position
	1310	(setq overlay-arrow-position nil)
	1311	(setq py-pdbtrack-is-tracking-p nil))
	1312	))
	1313
	1314	(defun py-pdbtrack-track-stack-file (text)
	1315	"Show the file indicated by the pdb stack entry line, in a separate window.
	1316
	1317	Activity is disabled if the buffer-local variable
	1318	`py-pdbtrack-do-tracking-p' is nil.
	1319
	1320	We depend on the pdb input prompt matching `py-pdbtrack-input-prompt'
	1321	at the beginning of the line.
	1322
	1323	If the traceback target file path is invalid, we look for the most
	1324	recently visited python-mode buffer which either has the name of the
	1325	current function \(or class) or which defines the function \(or
	1326	class). This is to provide for remote scripts, eg, Zope's 'Script
	1327	(Python)' - put a _copy_ of the script in a buffer named for the
	1328	script, and set to python-mode, and pdbtrack will find it.)"
	1329	;; Instead of trying to piece things together from partial text
	1330	;; (which can be almost useless depending on Emacs version), we
	1331	;; monitor to the point where we have the next pdb prompt, and then
	1332	;; check all text from comint-last-input-end to process-mark.
	1333	;;
	1334	;; Also, we're very conservative about clearing the overlay arrow,
	1335	;; to minimize residue. This means, for instance, that executing
	1336	;; other pdb commands wipe out the highlight. You can always do a
	1337	;; 'where' (aka 'w') command to reveal the overlay arrow.
	1338	(let* ((origbuf (current-buffer))
	1339	(currproc (get-buffer-process origbuf)))
	1340
	1341	(if (not (and currproc py-pdbtrack-do-tracking-p))
	1342	(py-pdbtrack-overlay-arrow nil)
	1343
	1344	(let* ((procmark (process-mark currproc))
	1345	(block (buffer-substring (max comint-last-input-end
	1346	(- procmark
	1347	py-pdbtrack-track-range))
	1348	procmark))
	1349	target target_fname target_lineno)
	1350
	1351	(if (not (string-match (concat py-pdbtrack-input-prompt "$") block))
	1352	(py-pdbtrack-overlay-arrow nil)
	1353
	1354	(setq target (py-pdbtrack-get-source-buffer block))
	1355
	1356	(if (stringp target)
	1357	(message "pdbtrack: %s" target)
	1358
	1359	(setq target_lineno (car target))
	1360	(setq target_buffer (cadr target))
	1361	(setq target_fname (buffer-file-name target_buffer))
	1362	(switch-to-buffer-other-window target_buffer)
	1363	(goto-line target_lineno)
	1364	(message "pdbtrack: line %s, file %s" target_lineno target_fname)
	1365	(py-pdbtrack-overlay-arrow t)
	1366	(pop-to-buffer origbuf t)
	1367
	1368	)))))
	1369	)
	1370
	1371	(defun py-pdbtrack-get-source-buffer (block)
	1372	"Return line number and buffer of code indicated by block's traceback text.
	1373
	1374	We look first to visit the file indicated in the trace.
	1375
	1376	Failing that, we look for the most recently visited python-mode buffer
	1377	with the same name or having
	1378	having the named function.
	1379
	1380	If we're unable find the source code we return a string describing the
	1381	problem as best as we can determine."
	1382
	1383	(if (not (string-match py-pdbtrack-stack-entry-regexp block))
	1384
	1385	"Traceback cue not found"
	1386
	1387	(let* ((filename (match-string 1 block))
	1388	(lineno (string-to-int (match-string 2 block)))
	1389	(funcname (match-string 3 block))
	1390	funcbuffer)
	1391
	1392	(cond ((file-exists-p filename)
	1393	(list lineno (find-file-noselect filename)))
	1394
	1395	((setq funcbuffer (py-pdbtrack-grub-for-buffer funcname lineno))
	1396	(if (string-match "/Script (Python)$" filename)
	1397	;; Add in number of lines for leading '##' comments:
	1398	(setq lineno
	1399	(+ lineno
	1400	(save-excursion
	1401	(set-buffer funcbuffer)
	1402	(count-lines
	1403	(point-min)
	1404	(max (point-min)
	1405	(string-match "^\$[^#]\\\|#[^#]\\\|#$\$"
	1406	(buffer-substring (point-min)
	1407	(point-max)))
	1408	))))))
	1409	(list lineno funcbuffer))
	1410
	1411	((= (elt filename 0) ?\<)
	1412	(format "(Non-file source: '%s')" filename))
	1413
	1414	(t (format "Not found: %s(), %s" funcname filename)))
	1415	)
	1416	)
	1417	)
	1418
	1419	(defun py-pdbtrack-grub-for-buffer (funcname lineno)
	1420	"Find most recent buffer itself named or having function funcname.
	1421
	1422	We first check the last buffer this function found, if any, then walk
	1423	throught the buffer-list history for python-mode buffers that are
	1424	named for funcname or define a function funcname."
	1425	(let ((buffers (buffer-list))
	1426	curbuf
	1427	got)
	1428	(while (and buffers (not got))
	1429	(setq buf (car buffers)
	1430	buffers (cdr buffers))
	1431	(if (and (save-excursion (set-buffer buf)
	1432	(string= major-mode "python-mode"))
	1433	(or (string-match funcname (buffer-name buf))
	1434	(string-match (concat "^\\s-*\$def\\\|class\$\\s-+"
	1435	funcname "\\s-*(")
	1436	(save-excursion
	1437	(set-buffer buf)
	1438	(buffer-substring (point-min)
	1439	(point-max))))))
	1440	(setq got buf)))
	1441	(setq py-pdbtrack-last-grubbed-buffer got)))
	1442
	1443	(defun py-postprocess-output-buffer (buf)
	1444	"Highlight exceptions found in BUF.
	1445	If an exception occurred return t, otherwise return nil. BUF must exist."
	1446	(let (line file bol err-p)
	1447	(save-excursion
	1448	(set-buffer buf)
	1449	(beginning-of-buffer)
	1450	(while (re-search-forward py-traceback-line-re nil t)
	1451	(setq file (match-string 1)
	1452	line (string-to-int (match-string 2))
	1453	bol (py-point 'bol))
	1454	(py-highlight-line bol (py-point 'eol) file line)))
	1455	(when (and py-jump-on-exception line)
	1456	(beep)
	1457	(py-jump-to-exception file line)
	1458	(setq err-p t))
	1459	err-p))
	1460
	1461
	1462
	1463	;;; Subprocess commands
	1464
	1465	;; only used when (memq 'broken-temp-names py-emacs-features)
	1466	(defvar py-serial-number 0)
	1467	(defvar py-exception-buffer nil)
	1468	(defconst py-output-buffer "Python Output")
	1469	(make-variable-buffer-local 'py-output-buffer)
	1470
	1471	;; for toggling between CPython and JPython
	1472	(defvar py-which-shell nil)
	1473	(defvar py-which-args py-python-command-args)
	1474	(defvar py-which-bufname "Python")
	1475	(make-variable-buffer-local 'py-which-shell)
	1476	(make-variable-buffer-local 'py-which-args)
	1477	(make-variable-buffer-local 'py-which-bufname)
	1478
	1479	(defun py-toggle-shells (arg)
	1480	"Toggles between the CPython and JPython shells.
	1481
	1482	With positive argument ARG (interactively \\[universal-argument]),
	1483	uses the CPython shell, with negative ARG uses the JPython shell, and
	1484	with a zero argument, toggles the shell.
	1485
	1486	Programmatically, ARG can also be one of the symbols `cpython' or
	1487	`jpython', equivalent to positive arg and negative arg respectively."
	1488	(interactive "P")
	1489	;; default is to toggle
	1490	(if (null arg)
	1491	(setq arg 0))
	1492	;; preprocess arg
	1493	(cond
	1494	((equal arg 0)
	1495	;; toggle
	1496	(if (string-equal py-which-bufname "Python")
	1497	(setq arg -1)
	1498	(setq arg 1)))
	1499	((equal arg 'cpython) (setq arg 1))
	1500	((equal arg 'jpython) (setq arg -1)))
	1501	(let (msg)
	1502	(cond
	1503	((< 0 arg)
	1504	;; set to CPython
	1505	(setq py-which-shell py-python-command
	1506	py-which-args py-python-command-args
	1507	py-which-bufname "Python"
	1508	msg "CPython"
	1509	mode-name "Python"))
	1510	((> 0 arg)
	1511	(setq py-which-shell py-jpython-command
	1512	py-which-args py-jpython-command-args
	1513	py-which-bufname "JPython"
	1514	msg "JPython"
	1515	mode-name "JPython"))
	1516	)
	1517	(message "Using the %s shell" msg)
	1518	(setq py-output-buffer (format "%s Output" py-which-bufname))))
	1519
	1520	;;;###autoload
	1521	(defun py-shell (&optional argprompt)
	1522	"Start an interactive Python interpreter in another window.
	1523	This is like Shell mode, except that Python is running in the window
	1524	instead of a shell. See the `Interactive Shell' and `Shell Mode'
	1525	sections of the Emacs manual for details, especially for the key
	1526	bindings active in the `Python' buffer.
	1527
	1528	With optional \\[universal-argument], the user is prompted for the
	1529	flags to pass to the Python interpreter. This has no effect when this
	1530	command is used to switch to an existing process, only when a new
	1531	process is started. If you use this, you will probably want to ensure
	1532	that the current arguments are retained (they will be included in the
	1533	prompt). This argument is ignored when this function is called
	1534	programmatically, or when running in Emacs 19.34 or older.
	1535
	1536	Note: You can toggle between using the CPython interpreter and the
	1537	JPython interpreter by hitting \\[py-toggle-shells]. This toggles
	1538	buffer local variables which control whether all your subshell
	1539	interactions happen to the `JPython' or `Python' buffers (the
	1540	latter is the name used for the CPython buffer).
	1541
	1542	Warning: Don't use an interactive Python if you change sys.ps1 or
	1543	sys.ps2 from their default values, or if you're running code that
	1544	prints `>>> ' or `... ' at the start of a line. `python-mode' can't
	1545	distinguish your output from Python's output, and assumes that `>>> '
	1546	at the start of a line is a prompt from Python. Similarly, the Emacs
	1547	Shell mode code assumes that both `>>> ' and `... ' at the start of a
	1548	line are Python prompts. Bad things can happen if you fool either
	1549	mode.
	1550
	1551	Warning: If you do any editing in the process buffer while the
	1552	buffer is accepting output from Python, do NOT attempt to `undo' the
	1553	changes. Some of the output (nowhere near the parts you changed!) may
	1554	be lost if you do. This appears to be an Emacs bug, an unfortunate
	1555	interaction between undo and process filters; the same problem exists in
	1556	non-Python process buffers using the default (Emacs-supplied) process
	1557	filter."
	1558	(interactive "P")
	1559	;; Set the default shell if not already set
	1560	(when (null py-which-shell)
	1561	(py-toggle-shells py-default-interpreter))
	1562	(let ((args py-which-args))
	1563	(when (and argprompt
	1564	(interactive-p)
	1565	(fboundp 'split-string))
	1566	;; TBD: Perhaps force "-i" in the final list?
	1567	(setq args (split-string
	1568	(read-string (concat py-which-bufname
	1569	" arguments: ")
	1570	(concat
	1571	(mapconcat 'identity py-which-args " ") " ")
	1572	))))
	1573	(switch-to-buffer-other-window
	1574	(apply 'make-comint py-which-bufname py-which-shell nil args))
	1575	(make-local-variable 'comint-prompt-regexp)
	1576	(setq comint-prompt-regexp "^>>> \\\|^[.][.][.] \\\|^(pdb) ")
	1577	(add-hook 'comint-output-filter-functions
	1578	'py-comint-output-filter-function)
	1579	;; pdbtrack
	1580	(add-hook 'comint-output-filter-functions 'py-pdbtrack-track-stack-file)
	1581	(setq py-pdbtrack-do-tracking-p t)
	1582	(set-syntax-table py-mode-syntax-table)
	1583	(use-local-map py-shell-map)
	1584	(run-hooks 'py-shell-hook)
	1585	))
	1586
	1587	(defun py-clear-queue ()
	1588	"Clear the queue of temporary files waiting to execute."
	1589	(interactive)
	1590	(let ((n (length py-file-queue)))
	1591	(mapcar 'delete-file py-file-queue)
	1592	(setq py-file-queue nil)
	1593	(message "%d pending files de-queued." n)))
	1594
	1595
	1596	(defun py-execute-region (start end &optional async)
	1597	"Execute the region in a Python interpreter.
	1598
	1599	The region is first copied into a temporary file (in the directory
	1600	`py-temp-directory'). If there is no Python interpreter shell
	1601	running, this file is executed synchronously using
	1602	`shell-command-on-region'. If the program is long running, use
	1603	\\[universal-argument] to run the command asynchronously in its own
	1604	buffer.
	1605
	1606	When this function is used programmatically, arguments START and END
	1607	specify the region to execute, and optional third argument ASYNC, if
	1608	non-nil, specifies to run the command asynchronously in its own
	1609	buffer.
	1610
	1611	If the Python interpreter shell is running, the region is execfile()'d
	1612	in that shell. If you try to execute regions too quickly,
	1613	`python-mode' will queue them up and execute them one at a time when
	1614	it sees a `>>> ' prompt from Python. Each time this happens, the
	1615	process buffer is popped into a window (if it's not already in some
	1616	window) so you can see it, and a comment of the form
	1617
	1618	\t## working on region in file <name>...
	1619
	1620	is inserted at the end. See also the command `py-clear-queue'."
	1621	(interactive "r\nP")
	1622	;; Skip ahead to the first non-blank line
	1623	(let* ((proc (get-process py-which-bufname))
	1624	(temp (if (memq 'broken-temp-names py-emacs-features)
	1625	(let
	1626	((sn py-serial-number)
	1627	(pid (and (fboundp 'emacs-pid) (emacs-pid))))
	1628	(setq py-serial-number (1+ py-serial-number))
	1629	(if pid
	1630	(format "python-%d-%d" sn pid)
	1631	(format "python-%d" sn)))
	1632	(make-temp-name "python-")))
	1633	(file (concat (expand-file-name temp py-temp-directory) ".py"))
	1634	(cur (current-buffer))
	1635	(buf (get-buffer-create file))
	1636	shell)
	1637	;; Write the contents of the buffer, watching out for indented regions.
	1638	(save-excursion
	1639	(goto-char start)
	1640	(beginning-of-line)
	1641	(while (and (looking-at "\\s *$")
	1642	(< (point) end))
	1643	(forward-line 1))
	1644	(setq start (point))
	1645	(or (< start end)
	1646	(error "Region is empty"))
	1647	(let ((needs-if (/= (py-point 'bol) (py-point 'boi))))
	1648	(set-buffer buf)
	1649	(python-mode)
	1650	(when needs-if
	1651	(insert "if 1:\n"))
	1652	(insert-buffer-substring cur start end)
	1653	;; Set the shell either to the #! line command, or to the
	1654	;; py-which-shell buffer local variable.
	1655	(setq shell (or (py-choose-shell-by-shebang)
	1656	(py-choose-shell-by-import)
	1657	py-which-shell))))
	1658	(cond
	1659	;; always run the code in its own asynchronous subprocess
	1660	(async
	1661	;; User explicitly wants this to run in its own async subprocess
	1662	(save-excursion
	1663	(set-buffer buf)
	1664	(write-region (point-min) (point-max) file nil 'nomsg))
	1665	(let* ((buf (generate-new-buffer-name py-output-buffer))
	1666	;; TBD: a horrible hack, but why create new Custom variables?
	1667	(arg (if (string-equal py-which-bufname "Python")
	1668	"-u" "")))
	1669	(start-process py-which-bufname buf shell arg file)
	1670	(pop-to-buffer buf)
	1671	(py-postprocess-output-buffer buf)
	1672	;; TBD: clean up the temporary file!
	1673	))
	1674	;; if the Python interpreter shell is running, queue it up for
	1675	;; execution there.
	1676	(proc
	1677	;; use the existing python shell
	1678	(save-excursion
	1679	(set-buffer buf)
	1680	(write-region (point-min) (point-max) file nil 'nomsg))
	1681	(if (not py-file-queue)
	1682	(py-execute-file proc file)
	1683	(message "File %s queued for execution" file))
	1684	(setq py-file-queue (append py-file-queue (list file)))
	1685	(setq py-exception-buffer (cons file (current-buffer))))
	1686	(t
	1687	;; TBD: a horrible hack, but why create new Custom variables?
	1688	(let ((cmd (concat shell (if (string-equal py-which-bufname "JPython")
	1689	" -" ""))))
	1690	;; otherwise either run it synchronously in a subprocess
	1691	(save-excursion
	1692	(set-buffer buf)
	1693	(shell-command-on-region (point-min) (point-max)
	1694	cmd py-output-buffer))
	1695	;; shell-command-on-region kills the output buffer if it never
	1696	;; existed and there's no output from the command
	1697	(if (not (get-buffer py-output-buffer))
	1698	(message "No output.")
	1699	(setq py-exception-buffer (current-buffer))
	1700	(let ((err-p (py-postprocess-output-buffer py-output-buffer)))
	1701	(pop-to-buffer py-output-buffer)
	1702	(if err-p
	1703	(pop-to-buffer py-exception-buffer)))
	1704	))
	1705	))
	1706	;; Clean up after ourselves.
	1707	(kill-buffer buf)))
	1708
	1709
	1710	;; Code execution commands
	1711	(defun py-execute-buffer (&optional async)
	1712	"Send the contents of the buffer to a Python interpreter.
	1713	If the file local variable `py-master-file' is non-nil, execute the
	1714	named file instead of the buffer's file.
	1715
	1716	If there is a Python process buffer it is used. If a clipping
	1717	restriction is in effect, only the accessible portion of the buffer is
	1718	sent. A trailing newline will be supplied if needed.
	1719
	1720	See the `\\[py-execute-region]' docs for an account of some
	1721	subtleties, including the use of the optional ASYNC argument."
	1722	(interactive "P")
	1723	(if py-master-file
	1724	(let* ((filename (expand-file-name py-master-file))
	1725	(buffer (or (get-file-buffer filename)
	1726	(find-file-noselect filename))))
	1727	(set-buffer buffer)))
	1728	(py-execute-region (point-min) (point-max) async))
	1729
	1730	(defun py-execute-import-or-reload (&optional async)
	1731	"Import the current buffer's file in a Python interpreter.
	1732
	1733	If the file has already been imported, then do reload instead to get
	1734	the latest version.
	1735
	1736	If the file's name does not end in \".py\", then do execfile instead.
	1737
	1738	If the current buffer is not visiting a file, do `py-execute-buffer'
	1739	instead.
	1740
	1741	If the file local variable `py-master-file' is non-nil, import or
	1742	reload the named file instead of the buffer's file. The file may be
	1743	saved based on the value of `py-execute-import-or-reload-save-p'.
	1744
	1745	See the `\\[py-execute-region]' docs for an account of some
	1746	subtleties, including the use of the optional ASYNC argument.
	1747
	1748	This may be preferable to `\\[py-execute-buffer]' because:
	1749
	1750	- Definitions stay in their module rather than appearing at top
	1751	level, where they would clutter the global namespace and not affect
	1752	uses of qualified names (MODULE.NAME).
	1753
	1754	- The Python debugger gets line number information about the functions."
	1755	(interactive "P")
	1756	;; Check file local variable py-master-file
	1757	(if py-master-file
	1758	(let* ((filename (expand-file-name py-master-file))
	1759	(buffer (or (get-file-buffer filename)
	1760	(find-file-noselect filename))))
	1761	(set-buffer buffer)))
	1762	(let ((file (buffer-file-name (current-buffer))))
	1763	(if file
	1764	(progn
	1765	;; Maybe save some buffers
	1766	(save-some-buffers (not py-ask-about-save) nil)
	1767	(py-execute-string
	1768	(if (string-match "\\.py$" file)
	1769	(let ((f (file-name-sans-extension
	1770	(file-name-nondirectory file))))
	1771	(format "if globals().has_key('%s'):\n reload(%s)\nelse:\n import %s\n"
	1772	f f f))
	1773	(format "execfile(r'%s')\n" file))
	1774	async))
	1775	;; else
	1776	(py-execute-buffer async))))
	1777
	1778
	1779	(defun py-execute-def-or-class (&optional async)
	1780	"Send the current function or class definition to a Python interpreter.
	1781
	1782	If there is a Python process buffer it is used.
	1783
	1784	See the `\\[py-execute-region]' docs for an account of some
	1785	subtleties, including the use of the optional ASYNC argument."
	1786	(interactive "P")
	1787	(save-excursion
	1788	(py-mark-def-or-class)
	1789	;; mark is before point
	1790	(py-execute-region (mark) (point) async)))
	1791
	1792
	1793	(defun py-execute-string (string &optional async)
	1794	"Send the argument STRING to a Python interpreter.
	1795
	1796	If there is a Python process buffer it is used.
	1797
	1798	See the `\\[py-execute-region]' docs for an account of some
	1799	subtleties, including the use of the optional ASYNC argument."
	1800	(interactive "sExecute Python command: ")
	1801	(save-excursion
	1802	(set-buffer (get-buffer-create
	1803	(generate-new-buffer-name " Python Command")))
	1804	(insert string)
	1805	(py-execute-region (point-min) (point-max) async)))
	1806
	1807
	1808
	1809	(defun py-jump-to-exception (file line)
	1810	"Jump to the Python code in FILE at LINE."
	1811	(let ((buffer (cond ((string-equal file "<stdin>")
	1812	(if (consp py-exception-buffer)
	1813	(cdr py-exception-buffer)
	1814	py-exception-buffer))
	1815	((and (consp py-exception-buffer)
	1816	(string-equal file (car py-exception-buffer)))
	1817	(cdr py-exception-buffer))
	1818	((py-safe (find-file-noselect file)))
	1819	;; could not figure out what file the exception
	1820	;; is pointing to, so prompt for it
	1821	(t (find-file (read-file-name "Exception file: "
	1822	nil
	1823	file t))))))
	1824	(pop-to-buffer buffer)
	1825	;; Force Python mode
	1826	(if (not (eq major-mode 'python-mode))
	1827	(python-mode))
	1828	(goto-line line)
	1829	(message "Jumping to exception in file %s on line %d" file line)))
	1830
	1831	(defun py-mouseto-exception (event)
	1832	"Jump to the code which caused the Python exception at EVENT.
	1833	EVENT is usually a mouse click."
	1834	(interactive "e")
	1835	(cond
	1836	((fboundp 'event-point)
	1837	;; XEmacs
	1838	(let* ((point (event-point event))
	1839	(buffer (event-buffer event))
	1840	(e (and point buffer (extent-at point buffer 'py-exc-info)))
	1841	(info (and e (extent-property e 'py-exc-info))))
	1842	(message "Event point: %d, info: %s" point info)
	1843	(and info
	1844	(py-jump-to-exception (car info) (cdr info)))
	1845	))
	1846	;; Emacs -- Please port this!
	1847	))
	1848
	1849	(defun py-goto-exception ()
	1850	"Go to the line indicated by the traceback."
	1851	(interactive)
	1852	(let (file line)
	1853	(save-excursion
	1854	(beginning-of-line)
	1855	(if (looking-at py-traceback-line-re)
	1856	(setq file (match-string 1)
	1857	line (string-to-int (match-string 2)))))
	1858	(if (not file)
	1859	(error "Not on a traceback line"))
	1860	(py-jump-to-exception file line)))
	1861
	1862	(defun py-find-next-exception (start buffer searchdir errwhere)
	1863	"Find the next Python exception and jump to the code that caused it.
	1864	START is the buffer position in BUFFER from which to begin searching
	1865	for an exception. SEARCHDIR is a function, either
	1866	`re-search-backward' or `re-search-forward' indicating the direction
	1867	to search. ERRWHERE is used in an error message if the limit (top or
	1868	bottom) of the trackback stack is encountered."
	1869	(let (file line)
	1870	(save-excursion
	1871	(set-buffer buffer)
	1872	(goto-char (py-point start))
	1873	(if (funcall searchdir py-traceback-line-re nil t)
	1874	(setq file (match-string 1)
	1875	line (string-to-int (match-string 2)))))
	1876	(if (and file line)
	1877	(py-jump-to-exception file line)
	1878	(error "%s of traceback" errwhere))))
	1879
	1880	(defun py-down-exception (&optional bottom)
	1881	"Go to the next line down in the traceback.
	1882	With \\[univeral-argument] (programmatically, optional argument
	1883	BOTTOM), jump to the bottom (innermost) exception in the exception
	1884	stack."
	1885	(interactive "P")
	1886	(let* ((proc (get-process "Python"))
	1887	(buffer (if proc "Python" py-output-buffer)))
	1888	(if bottom
	1889	(py-find-next-exception 'eob buffer 're-search-backward "Bottom")
	1890	(py-find-next-exception 'eol buffer 're-search-forward "Bottom"))))
	1891
	1892	(defun py-up-exception (&optional top)
	1893	"Go to the previous line up in the traceback.
	1894	With \\[universal-argument] (programmatically, optional argument TOP)
	1895	jump to the top (outermost) exception in the exception stack."
	1896	(interactive "P")
	1897	(let* ((proc (get-process "Python"))
	1898	(buffer (if proc "Python" py-output-buffer)))
	1899	(if top
	1900	(py-find-next-exception 'bob buffer 're-search-forward "Top")
	1901	(py-find-next-exception 'bol buffer 're-search-backward "Top"))))
	1902
	1903
	1904	;; Electric deletion
	1905	(defun py-electric-backspace (arg)
	1906	"Delete preceding character or levels of indentation.
	1907	Deletion is performed by calling the function in `py-backspace-function'
	1908	with a single argument (the number of characters to delete).
	1909
	1910	If point is at the leftmost column, delete the preceding newline.
	1911
	1912	Otherwise, if point is at the leftmost non-whitespace character of a
	1913	line that is neither a continuation line nor a non-indenting comment
	1914	line, or if point is at the end of a blank line, this command reduces
	1915	the indentation to match that of the line that opened the current
	1916	block of code. The line that opened the block is displayed in the
	1917	echo area to help you keep track of where you are. With
	1918	\\[universal-argument] dedents that many blocks (but not past column
	1919	zero).
	1920
	1921	Otherwise the preceding character is deleted, converting a tab to
	1922	spaces if needed so that only a single column position is deleted.
	1923	\\[universal-argument] specifies how many characters to delete;
	1924	default is 1.
	1925
	1926	When used programmatically, argument ARG specifies the number of
	1927	blocks to dedent, or the number of characters to delete, as indicated
	1928	above."
	1929	(interactive "*p")
	1930	(if (or (/= (current-indentation) (current-column))
	1931	(bolp)
	1932	(py-continuation-line-p)
	1933	; (not py-honor-comment-indentation)
	1934	; (looking-at "#[^ \t\n]") ; non-indenting #
	1935	)
	1936	(funcall py-backspace-function arg)
	1937	;; else indent the same as the colon line that opened the block
	1938	;; force non-blank so py-goto-block-up doesn't ignore it
	1939	(insert-char ?* 1)
	1940	(backward-char)
	1941	(let ((base-indent 0) ; indentation of base line
	1942	(base-text "") ; and text of base line
	1943	(base-found-p nil))
	1944	(save-excursion
	1945	(while (< 0 arg)
	1946	(condition-case nil ; in case no enclosing block
	1947	(progn
	1948	(py-goto-block-up 'no-mark)
	1949	(setq base-indent (current-indentation)
	1950	base-text (py-suck-up-leading-text)
	1951	base-found-p t))
	1952	(error nil))
	1953	(setq arg (1- arg))))
	1954	(delete-char 1) ; toss the dummy character
	1955	(delete-horizontal-space)
	1956	(indent-to base-indent)
	1957	(if base-found-p
	1958	(message "Closes block: %s" base-text)))))
	1959
	1960
	1961	(defun py-electric-delete (arg)
	1962	"Delete preceding or following character or levels of whitespace.
	1963
	1964	The behavior of this function depends on the variable
	1965	`delete-key-deletes-forward'. If this variable is nil (or does not
	1966	exist, as in older Emacsen and non-XEmacs versions), then this
	1967	function behaves identically to \\[c-electric-backspace].
	1968
	1969	If `delete-key-deletes-forward' is non-nil and is supported in your
	1970	Emacs, then deletion occurs in the forward direction, by calling the
	1971	function in `py-delete-function'.
	1972
	1973	\\[universal-argument] (programmatically, argument ARG) specifies the
	1974	number of characters to delete (default is 1)."
	1975	(interactive "*p")
	1976	(if (or (and (fboundp 'delete-forward-p) ;XEmacs 21
	1977	(delete-forward-p))
	1978	(and (boundp 'delete-key-deletes-forward) ;XEmacs 20
	1979	delete-key-deletes-forward))
	1980	(funcall py-delete-function arg)
	1981	(py-electric-backspace arg)))
	1982
	1983	;; required for pending-del and delsel modes
	1984	(put 'py-electric-colon 'delete-selection t) ;delsel
	1985	(put 'py-electric-colon 'pending-delete t) ;pending-del
	1986	(put 'py-electric-backspace 'delete-selection 'supersede) ;delsel
	1987	(put 'py-electric-backspace 'pending-delete 'supersede) ;pending-del
	1988	(put 'py-electric-delete 'delete-selection 'supersede) ;delsel
	1989	(put 'py-electric-delete 'pending-delete 'supersede) ;pending-del
	1990
	1991
	1992
	1993	(defun py-indent-line (&optional arg)
	1994	"Fix the indentation of the current line according to Python rules.
	1995	With \\[universal-argument] (programmatically, the optional argument
	1996	ARG non-nil), ignore dedenting rules for block closing statements
	1997	(e.g. return, raise, break, continue, pass)
	1998
	1999	This function is normally bound to `indent-line-function' so
	2000	\\[indent-for-tab-command] will call it."
	2001	(interactive "P")
	2002	(let* ((ci (current-indentation))
	2003	(move-to-indentation-p (<= (current-column) ci))
	2004	(need (py-compute-indentation (not arg))))
	2005	;; see if we need to dedent
	2006	(if (py-outdent-p)
	2007	(setq need (- need py-indent-offset)))
	2008	(if (/= ci need)
	2009	(save-excursion
	2010	(beginning-of-line)
	2011	(delete-horizontal-space)
	2012	(indent-to need)))
	2013	(if move-to-indentation-p (back-to-indentation))))
	2014
	2015	(defun py-newline-and-indent ()
	2016	"Strives to act like the Emacs `newline-and-indent'.
	2017	This is just `strives to' because correct indentation can't be computed
	2018	from scratch for Python code. In general, deletes the whitespace before
	2019	point, inserts a newline, and takes an educated guess as to how you want
	2020	the new line indented."
	2021	(interactive)
	2022	(let ((ci (current-indentation)))
	2023	(if (< ci (current-column)) ; if point beyond indentation
	2024	(newline-and-indent)
	2025	;; else try to act like newline-and-indent "normally" acts
	2026	(beginning-of-line)
	2027	(insert-char ?\n 1)
	2028	(move-to-column ci))))
	2029
	2030	(defun py-compute-indentation (honor-block-close-p)
	2031	"Compute Python indentation.
	2032	When HONOR-BLOCK-CLOSE-P is non-nil, statements such as `return',
	2033	`raise', `break', `continue', and `pass' force one level of
	2034	dedenting."
	2035	(save-excursion
	2036	(beginning-of-line)
	2037	(let* ((bod (py-point 'bod))
	2038	(pps (parse-partial-sexp bod (point)))
	2039	(boipps (parse-partial-sexp bod (py-point 'boi)))
	2040	placeholder)
	2041	(cond
	2042	;; are we inside a multi-line string or comment?
	2043	((or (and (nth 3 pps) (nth 3 boipps))
	2044	(and (nth 4 pps) (nth 4 boipps)))
	2045	(save-excursion
	2046	(if (not py-align-multiline-strings-p) 0
	2047	;; skip back over blank & non-indenting comment lines
	2048	;; note: will skip a blank or non-indenting comment line
	2049	;; that happens to be a continuation line too
	2050	(re-search-backward "^[ \t]*\$[^ \t\n#]\\\|#[ \t\n]\$" nil 'move)
	2051	(back-to-indentation)
	2052	(current-column))))
	2053	;; are we on a continuation line?
	2054	((py-continuation-line-p)
	2055	(let ((startpos (point))
	2056	(open-bracket-pos (py-nesting-level))
	2057	endpos searching found state)
	2058	(if open-bracket-pos
	2059	(progn
	2060	;; align with first item in list; else a normal
	2061	;; indent beyond the line with the open bracket
	2062	(goto-char (1+ open-bracket-pos)) ; just beyond bracket
	2063	;; is the first list item on the same line?
	2064	(skip-chars-forward " \t")
	2065	(if (null (memq (following-char) '(?\n ?# ?\\)))
	2066	; yes, so line up with it
	2067	(current-column)
	2068	;; first list item on another line, or doesn't exist yet
	2069	(forward-line 1)
	2070	(while (and (< (point) startpos)
	2071	(looking-at "[ \t]*[#\n\\\\]")) ; skip noise
	2072	(forward-line 1))
	2073	(if (and (< (point) startpos)
	2074	(/= startpos
	2075	(save-excursion
	2076	(goto-char (1+ open-bracket-pos))
	2077	(forward-comment (point-max))
	2078	(point))))
	2079	;; again mimic the first list item
	2080	(current-indentation)
	2081	;; else they're about to enter the first item
	2082	(goto-char open-bracket-pos)
	2083	(setq placeholder (point))
	2084	(py-goto-initial-line)
	2085	(py-goto-beginning-of-tqs
	2086	(save-excursion (nth 3 (parse-partial-sexp
	2087	placeholder (point)))))
	2088	(+ (current-indentation) py-indent-offset))))
	2089
	2090	;; else on backslash continuation line
	2091	(forward-line -1)
	2092	(if (py-continuation-line-p) ; on at least 3rd line in block
	2093	(current-indentation) ; so just continue the pattern
	2094	;; else started on 2nd line in block, so indent more.
	2095	;; if base line is an assignment with a start on a RHS,
	2096	;; indent to 2 beyond the leftmost "="; else skip first
	2097	;; chunk of non-whitespace characters on base line, + 1 more
	2098	;; column
	2099	(end-of-line)
	2100	(setq endpos (point)
	2101	searching t)
	2102	(back-to-indentation)
	2103	(setq startpos (point))
	2104	;; look at all "=" from left to right, stopping at first
	2105	;; one not nested in a list or string
	2106	(while searching
	2107	(skip-chars-forward "^=" endpos)
	2108	(if (= (point) endpos)
	2109	(setq searching nil)
	2110	(forward-char 1)
	2111	(setq state (parse-partial-sexp startpos (point)))
	2112	(if (and (zerop (car state)) ; not in a bracket
	2113	(null (nth 3 state))) ; & not in a string
	2114	(progn
	2115	(setq searching nil) ; done searching in any case
	2116	(setq found
	2117	(not (or
	2118	(eq (following-char) ?=)
	2119	(memq (char-after (- (point) 2))
	2120	'(?< ?> ?!)))))))))
	2121	(if (or (not found) ; not an assignment
	2122	(looking-at "[ \t]*\\\\")) ; <=><spaces><backslash>
	2123	(progn
	2124	(goto-char startpos)
	2125	(skip-chars-forward "^ \t\n")))
	2126	;; if this is a continuation for a block opening
	2127	;; statement, add some extra offset.
	2128	(+ (current-column) (if (py-statement-opens-block-p)
	2129	py-continuation-offset 0)
	2130	1)
	2131	))))
	2132
	2133	;; not on a continuation line
	2134	((bobp) (current-indentation))
	2135
	2136	;; Dfn: "Indenting comment line". A line containing only a
	2137	;; comment, but which is treated like a statement for
	2138	;; indentation calculation purposes. Such lines are only
	2139	;; treated specially by the mode; they are not treated
	2140	;; specially by the Python interpreter.
	2141
	2142	;; The rules for indenting comment lines are a line where:
	2143	;; - the first non-whitespace character is `#', and
	2144	;; - the character following the `#' is whitespace, and
	2145	;; - the line is dedented with respect to (i.e. to the left
	2146	;; of) the indentation of the preceding non-blank line.
	2147
	2148	;; The first non-blank line following an indenting comment
	2149	;; line is given the same amount of indentation as the
	2150	;; indenting comment line.
	2151
	2152	;; All other comment-only lines are ignored for indentation
	2153	;; purposes.
	2154
	2155	;; Are we looking at a comment-only line which is not an
	2156	;; indenting comment line? If so, we assume that it's been
	2157	;; placed at the desired indentation, so leave it alone.
	2158	;; Indenting comment lines are aligned as statements down
	2159	;; below.
	2160	((and (looking-at "[ \t]*#[^ \t\n]")
	2161	;; NOTE: this test will not be performed in older Emacsen
	2162	(fboundp 'forward-comment)
	2163	(<= (current-indentation)
	2164	(save-excursion
	2165	(forward-comment (- (point-max)))
	2166	(current-indentation))))
	2167	(current-indentation))
	2168
	2169	;; else indentation based on that of the statement that
	2170	;; precedes us; use the first line of that statement to
	2171	;; establish the base, in case the user forced a non-std
	2172	;; indentation for the continuation lines (if any)
	2173	(t
	2174	;; skip back over blank & non-indenting comment lines note:
	2175	;; will skip a blank or non-indenting comment line that
	2176	;; happens to be a continuation line too. use fast Emacs 19
	2177	;; function if it's there.
	2178	(if (and (eq py-honor-comment-indentation nil)
	2179	(fboundp 'forward-comment))
	2180	(forward-comment (- (point-max)))
	2181	(let ((prefix-re (concat py-block-comment-prefix "[ \t]*"))
	2182	done)
	2183	(while (not done)
	2184	(re-search-backward "^[ \t]*\$[^ \t\n#]\\\|#\$" nil 'move)
	2185	(setq done (or (bobp)
	2186	(and (eq py-honor-comment-indentation t)
	2187	(save-excursion
	2188	(back-to-indentation)
	2189	(not (looking-at prefix-re))
	2190	))
	2191	(and (not (eq py-honor-comment-indentation t))
	2192	(save-excursion
	2193	(back-to-indentation)
	2194	(and (not (looking-at prefix-re))
	2195	(or (looking-at "[^#]")
	2196	(not (zerop (current-column)))
	2197	))
	2198	))
	2199	))
	2200	)))
	2201	;; if we landed inside a string, go to the beginning of that
	2202	;; string. this handles triple quoted, multi-line spanning
	2203	;; strings.
	2204	(py-goto-beginning-of-tqs (nth 3 (parse-partial-sexp bod (point))))
	2205	;; now skip backward over continued lines
	2206	(setq placeholder (point))
	2207	(py-goto-initial-line)
	2208	;; we may now have landed in a TQS, so find the beginning of
	2209	;; this string.
	2210	(py-goto-beginning-of-tqs
	2211	(save-excursion (nth 3 (parse-partial-sexp
	2212	placeholder (point)))))
	2213	(+ (current-indentation)
	2214	(if (py-statement-opens-block-p)
	2215	py-indent-offset
	2216	(if (and honor-block-close-p (py-statement-closes-block-p))
	2217	(- py-indent-offset)
	2218	0)))
	2219	)))))
	2220
	2221	(defun py-guess-indent-offset (&optional global)
	2222	"Guess a good value for, and change, `py-indent-offset'.
	2223
	2224	By default, make a buffer-local copy of `py-indent-offset' with the
	2225	new value, so that other Python buffers are not affected. With
	2226	\\[universal-argument] (programmatically, optional argument GLOBAL),
	2227	change the global value of `py-indent-offset'. This affects all
	2228	Python buffers (that don't have their own buffer-local copy), both
	2229	those currently existing and those created later in the Emacs session.
	2230
	2231	Some people use a different value for `py-indent-offset' than you use.
	2232	There's no excuse for such foolishness, but sometimes you have to deal
	2233	with their ugly code anyway. This function examines the file and sets
	2234	`py-indent-offset' to what it thinks it was when they created the
	2235	mess.
	2236
	2237	Specifically, it searches forward from the statement containing point,
	2238	looking for a line that opens a block of code. `py-indent-offset' is
	2239	set to the difference in indentation between that line and the Python
	2240	statement following it. If the search doesn't succeed going forward,
	2241	it's tried again going backward."
	2242	(interactive "P") ; raw prefix arg
	2243	(let (new-value
	2244	(start (point))
	2245	(restart (point))
	2246	(found nil)
	2247	colon-indent)
	2248	(py-goto-initial-line)
	2249	(while (not (or found (eobp)))
	2250	(when (and (re-search-forward ":[ \t]*\$$\\\|[#\\]\$" nil 'move)
	2251	(not (py-in-literal restart)))
	2252	(setq restart (point))
	2253	(py-goto-initial-line)
	2254	(if (py-statement-opens-block-p)
	2255	(setq found t)
	2256	(goto-char restart))))
	2257	(unless found
	2258	(goto-char start)
	2259	(py-goto-initial-line)
	2260	(while (not (or found (bobp)))
	2261	(setq found (and
	2262	(re-search-backward ":[ \t]*\$$\\\|[#\\]\$" nil 'move)
	2263	(or (py-goto-initial-line) t) ; always true -- side effect
	2264	(py-statement-opens-block-p)))))
	2265	(setq colon-indent (current-indentation)
	2266	found (and found (zerop (py-next-statement 1)))
	2267	new-value (- (current-indentation) colon-indent))
	2268	(goto-char start)
	2269	(if (not found)
	2270	(error "Sorry, couldn't guess a value for py-indent-offset")
	2271	(funcall (if global 'kill-local-variable 'make-local-variable)
	2272	'py-indent-offset)
	2273	(setq py-indent-offset new-value)
	2274	(or noninteractive
	2275	(message "%s value of py-indent-offset set to %d"
	2276	(if global "Global" "Local")
	2277	py-indent-offset)))
	2278	))
	2279
	2280	(defun py-comment-indent-function ()
	2281	"Python version of `comment-indent-function'."
	2282	;; This is required when filladapt is turned off. Without it, when
	2283	;; filladapt is not used, comments which start in column zero
	2284	;; cascade one character to the right
	2285	(save-excursion
	2286	(beginning-of-line)
	2287	(let ((eol (py-point 'eol)))
	2288	(and comment-start-skip
	2289	(re-search-forward comment-start-skip eol t)
	2290	(setq eol (match-beginning 0)))
	2291	(goto-char eol)
	2292	(skip-chars-backward " \t")
	2293	(max comment-column (+ (current-column) (if (bolp) 0 1)))
	2294	)))
	2295
	2296	(defun py-narrow-to-defun (&optional class)
	2297	"Make text outside current defun invisible.
	2298	The defun visible is the one that contains point or follows point.
	2299	Optional CLASS is passed directly to `py-beginning-of-def-or-class'."
	2300	(interactive "P")
	2301	(save-excursion
	2302	(widen)
	2303	(py-end-of-def-or-class class)
	2304	(let ((end (point)))
	2305	(py-beginning-of-def-or-class class)
	2306	(narrow-to-region (point) end))))
	2307
	2308
	2309	(defun py-shift-region (start end count)
	2310	"Indent lines from START to END by COUNT spaces."
	2311	(save-excursion
	2312	(goto-char end)
	2313	(beginning-of-line)
	2314	(setq end (point))
	2315	(goto-char start)
	2316	(beginning-of-line)
	2317	(setq start (point))
	2318	(indent-rigidly start end count)))
	2319
	2320	(defun py-shift-region-left (start end &optional count)
	2321	"Shift region of Python code to the left.
	2322	The lines from the line containing the start of the current region up
	2323	to (but not including) the line containing the end of the region are
	2324	shifted to the left, by `py-indent-offset' columns.
	2325
	2326	If a prefix argument is given, the region is instead shifted by that
	2327	many columns. With no active region, dedent only the current line.
	2328	You cannot dedent the region if any line is already at column zero."
	2329	(interactive
	2330	(let ((p (point))
	2331	(m (mark))
	2332	(arg current-prefix-arg))
	2333	(if m
	2334	(list (min p m) (max p m) arg)
	2335	(list p (save-excursion (forward-line 1) (point)) arg))))
	2336	;; if any line is at column zero, don't shift the region
	2337	(save-excursion
	2338	(goto-char start)
	2339	(while (< (point) end)
	2340	(back-to-indentation)
	2341	(if (and (zerop (current-column))
	2342	(not (looking-at "\\s *$")))
	2343	(error "Region is at left edge"))
	2344	(forward-line 1)))
	2345	(py-shift-region start end (- (prefix-numeric-value
	2346	(or count py-indent-offset))))
	2347	(py-keep-region-active))
	2348
	2349	(defun py-shift-region-right (start end &optional count)
	2350	"Shift region of Python code to the right.
	2351	The lines from the line containing the start of the current region up
	2352	to (but not including) the line containing the end of the region are
	2353	shifted to the right, by `py-indent-offset' columns.
	2354
	2355	If a prefix argument is given, the region is instead shifted by that
	2356	many columns. With no active region, indent only the current line."
	2357	(interactive
	2358	(let ((p (point))
	2359	(m (mark))
	2360	(arg current-prefix-arg))
	2361	(if m
	2362	(list (min p m) (max p m) arg)
	2363	(list p (save-excursion (forward-line 1) (point)) arg))))
	2364	(py-shift-region start end (prefix-numeric-value
	2365	(or count py-indent-offset)))
	2366	(py-keep-region-active))
	2367
	2368	(defun py-indent-region (start end &optional indent-offset)
	2369	"Reindent a region of Python code.
	2370
	2371	The lines from the line containing the start of the current region up
	2372	to (but not including) the line containing the end of the region are
	2373	reindented. If the first line of the region has a non-whitespace
	2374	character in the first column, the first line is left alone and the
	2375	rest of the region is reindented with respect to it. Else the entire
	2376	region is reindented with respect to the (closest code or indenting
	2377	comment) statement immediately preceding the region.
	2378
	2379	This is useful when code blocks are moved or yanked, when enclosing
	2380	control structures are introduced or removed, or to reformat code
	2381	using a new value for the indentation offset.
	2382
	2383	If a numeric prefix argument is given, it will be used as the value of
	2384	the indentation offset. Else the value of `py-indent-offset' will be
	2385	used.
	2386
	2387	Warning: The region must be consistently indented before this function
	2388	is called! This function does not compute proper indentation from
	2389	scratch (that's impossible in Python), it merely adjusts the existing
	2390	indentation to be correct in context.
	2391
	2392	Warning: This function really has no idea what to do with
	2393	non-indenting comment lines, and shifts them as if they were indenting
	2394	comment lines. Fixing this appears to require telepathy.
	2395
	2396	Special cases: whitespace is deleted from blank lines; continuation
	2397	lines are shifted by the same amount their initial line was shifted,
	2398	in order to preserve their relative indentation with respect to their
	2399	initial line; and comment lines beginning in column 1 are ignored."
	2400	(interactive "*r\nP") ; region; raw prefix arg
	2401	(save-excursion
	2402	(goto-char end) (beginning-of-line) (setq end (point-marker))
	2403	(goto-char start) (beginning-of-line)
	2404	(let ((py-indent-offset (prefix-numeric-value
	2405	(or indent-offset py-indent-offset)))
	2406	(indents '(-1)) ; stack of active indent levels
	2407	(target-column 0) ; column to which to indent
	2408	(base-shifted-by 0) ; amount last base line was shifted
	2409	(indent-base (if (looking-at "[ \t\n]")
	2410	(py-compute-indentation t)
	2411	0))
	2412	ci)
	2413	(while (< (point) end)
	2414	(setq ci (current-indentation))
	2415	;; figure out appropriate target column
	2416	(cond
	2417	((or (eq (following-char) ?#) ; comment in column 1
	2418	(looking-at "[ \t]*$")) ; entirely blank
	2419	(setq target-column 0))
	2420	((py-continuation-line-p) ; shift relative to base line
	2421	(setq target-column (+ ci base-shifted-by)))
	2422	(t ; new base line
	2423	(if (> ci (car indents)) ; going deeper; push it
	2424	(setq indents (cons ci indents))
	2425	;; else we should have seen this indent before
	2426	(setq indents (memq ci indents)) ; pop deeper indents
	2427	(if (null indents)
	2428	(error "Bad indentation in region, at line %d"
	2429	(save-restriction
	2430	(widen)
	2431	(1+ (count-lines 1 (point)))))))
	2432	(setq target-column (+ indent-base
	2433	(* py-indent-offset
	2434	(- (length indents) 2))))
	2435	(setq base-shifted-by (- target-column ci))))
	2436	;; shift as needed
	2437	(if (/= ci target-column)
	2438	(progn
	2439	(delete-horizontal-space)
	2440	(indent-to target-column)))
	2441	(forward-line 1))))
	2442	(set-marker end nil))
	2443
	2444	(defun py-comment-region (beg end &optional arg)
	2445	"Like `comment-region' but uses double hash (`#') comment starter."
	2446	(interactive "r\nP")
	2447	(let ((comment-start py-block-comment-prefix))
	2448	(comment-region beg end arg)))
	2449
	2450
	2451	;; Functions for moving point
	2452	(defun py-previous-statement (count)
	2453	"Go to the start of the COUNTth preceding Python statement.
	2454	By default, goes to the previous statement. If there is no such
	2455	statement, goes to the first statement. Return count of statements
	2456	left to move. `Statements' do not include blank, comment, or
	2457	continuation lines."
	2458	(interactive "p") ; numeric prefix arg
	2459	(if (< count 0) (py-next-statement (- count))
	2460	(py-goto-initial-line)
	2461	(let (start)
	2462	(while (and
	2463	(setq start (point)) ; always true -- side effect
	2464	(> count 0)
	2465	(zerop (forward-line -1))
	2466	(py-goto-statement-at-or-above))
	2467	(setq count (1- count)))
	2468	(if (> count 0) (goto-char start)))
	2469	count))
	2470
	2471	(defun py-next-statement (count)
	2472	"Go to the start of next Python statement.
	2473	If the statement at point is the i'th Python statement, goes to the
	2474	start of statement i+COUNT. If there is no such statement, goes to the
	2475	last statement. Returns count of statements left to move. `Statements'
	2476	do not include blank, comment, or continuation lines."
	2477	(interactive "p") ; numeric prefix arg
	2478	(if (< count 0) (py-previous-statement (- count))
	2479	(beginning-of-line)
	2480	(let (start)
	2481	(while (and
	2482	(setq start (point)) ; always true -- side effect
	2483	(> count 0)
	2484	(py-goto-statement-below))
	2485	(setq count (1- count)))
	2486	(if (> count 0) (goto-char start)))
	2487	count))
	2488
	2489	(defun py-goto-block-up (&optional nomark)
	2490	"Move up to start of current block.
	2491	Go to the statement that starts the smallest enclosing block; roughly
	2492	speaking, this will be the closest preceding statement that ends with a
	2493	colon and is indented less than the statement you started on. If
	2494	successful, also sets the mark to the starting point.
	2495
	2496	`\\[py-mark-block]' can be used afterward to mark the whole code
	2497	block, if desired.
	2498
	2499	If called from a program, the mark will not be set if optional argument
	2500	NOMARK is not nil."
	2501	(interactive)
	2502	(let ((start (point))
	2503	(found nil)
	2504	initial-indent)
	2505	(py-goto-initial-line)
	2506	;; if on blank or non-indenting comment line, use the preceding stmt
	2507	(if (looking-at "[ \t]*\$$\\\|#[^ \t\n]\$")
	2508	(progn
	2509	(py-goto-statement-at-or-above)
	2510	(setq found (py-statement-opens-block-p))))
	2511	;; search back for colon line indented less
	2512	(setq initial-indent (current-indentation))
	2513	(if (zerop initial-indent)
	2514	;; force fast exit
	2515	(goto-char (point-min)))
	2516	(while (not (or found (bobp)))
	2517	(setq found
	2518	(and
	2519	(re-search-backward ":[ \t]*\$$\\\|[#\\]\$" nil 'move)
	2520	(or (py-goto-initial-line) t) ; always true -- side effect
	2521	(< (current-indentation) initial-indent)
	2522	(py-statement-opens-block-p))))
	2523	(if found
	2524	(progn
	2525	(or nomark (push-mark start))
	2526	(back-to-indentation))
	2527	(goto-char start)
	2528	(error "Enclosing block not found"))))
	2529
	2530	(defun py-beginning-of-def-or-class (&optional class count)
	2531	"Move point to start of `def' or `class'.
	2532
	2533	Searches back for the closest preceding `def'. If you supply a prefix
	2534	arg, looks for a `class' instead. The docs below assume the `def'
	2535	case; just substitute `class' for `def' for the other case.
	2536	Programmatically, if CLASS is `either', then moves to either `class'
	2537	or `def'.
	2538
	2539	When second optional argument is given programmatically, move to the
	2540	COUNTth start of `def'.
	2541
	2542	If point is in a `def' statement already, and after the `d', simply
	2543	moves point to the start of the statement.
	2544
	2545	Otherwise (i.e. when point is not in a `def' statement, or at or
	2546	before the `d' of a `def' statement), searches for the closest
	2547	preceding `def' statement, and leaves point at its start. If no such
	2548	statement can be found, leaves point at the start of the buffer.
	2549
	2550	Returns t iff a `def' statement is found by these rules.
	2551
	2552	Note that doing this command repeatedly will take you closer to the
	2553	start of the buffer each time.
	2554
	2555	To mark the current `def', see `\\[py-mark-def-or-class]'."
	2556	(interactive "P") ; raw prefix arg
	2557	(setq count (or count 1))
	2558	(let ((at-or-before-p (<= (current-column) (current-indentation)))
	2559	(start-of-line (goto-char (py-point 'bol)))
	2560	(start-of-stmt (goto-char (py-point 'bos)))
	2561	(start-re (cond ((eq class 'either) "^[ \t]*\$class\\\|def\$\\>")
	2562	(class "^[ \t]*class\\>")
	2563	(t "^[ \t]*def\\>")))
	2564	)
	2565	;; searching backward
	2566	(if (and (< 0 count)
	2567	(or (/= start-of-stmt start-of-line)
	2568	(not at-or-before-p)))
	2569	(end-of-line))
	2570	;; search forward
	2571	(if (and (> 0 count)
	2572	(zerop (current-column))
	2573	(looking-at start-re))
	2574	(end-of-line))
	2575	(if (re-search-backward start-re nil 'move count)
	2576	(goto-char (match-beginning 0)))))
	2577
	2578	;; Backwards compatibility
	2579	(defalias 'beginning-of-python-def-or-class 'py-beginning-of-def-or-class)
	2580
	2581	(defun py-end-of-def-or-class (&optional class count)
	2582	"Move point beyond end of `def' or `class' body.
	2583
	2584	By default, looks for an appropriate `def'. If you supply a prefix
	2585	arg, looks for a `class' instead. The docs below assume the `def'
	2586	case; just substitute `class' for `def' for the other case.
	2587	Programmatically, if CLASS is `either', then moves to either `class'
	2588	or `def'.
	2589
	2590	When second optional argument is given programmatically, move to the
	2591	COUNTth end of `def'.
	2592
	2593	If point is in a `def' statement already, this is the `def' we use.
	2594
	2595	Else, if the `def' found by `\\[py-beginning-of-def-or-class]'
	2596	contains the statement you started on, that's the `def' we use.
	2597
	2598	Otherwise, we search forward for the closest following `def', and use that.
	2599
	2600	If a `def' can be found by these rules, point is moved to the start of
	2601	the line immediately following the `def' block, and the position of the
	2602	start of the `def' is returned.
	2603
	2604	Else point is moved to the end of the buffer, and nil is returned.
	2605
	2606	Note that doing this command repeatedly will take you closer to the
	2607	end of the buffer each time.
	2608
	2609	To mark the current `def', see `\\[py-mark-def-or-class]'."
	2610	(interactive "P") ; raw prefix arg
	2611	(if (and count (/= count 1))
	2612	(py-beginning-of-def-or-class (- 1 count)))
	2613	(let ((start (progn (py-goto-initial-line) (point)))
	2614	(which (cond ((eq class 'either) "\$class\\\|def\$")
	2615	(class "class")
	2616	(t "def")))
	2617	(state 'not-found))
	2618	;; move point to start of appropriate def/class
	2619	(if (looking-at (concat "[ \t]*" which "\\>")) ; already on one
	2620	(setq state 'at-beginning)
	2621	;; else see if py-beginning-of-def-or-class hits container
	2622	(if (and (py-beginning-of-def-or-class class)
	2623	(progn (py-goto-beyond-block)
	2624	(> (point) start)))
	2625	(setq state 'at-end)
	2626	;; else search forward
	2627	(goto-char start)
	2628	(if (re-search-forward (concat "^[ \t]*" which "\\>") nil 'move)
	2629	(progn (setq state 'at-beginning)
	2630	(beginning-of-line)))))
	2631	(cond
	2632	((eq state 'at-beginning) (py-goto-beyond-block) t)
	2633	((eq state 'at-end) t)
	2634	((eq state 'not-found) nil)
	2635	(t (error "Internal error in `py-end-of-def-or-class'")))))
	2636
	2637	;; Backwards compabitility
	2638	(defalias 'end-of-python-def-or-class 'py-end-of-def-or-class)
	2639
	2640
	2641	;; Functions for marking regions
	2642	(defun py-mark-block (&optional extend just-move)
	2643	"Mark following block of lines. With prefix arg, mark structure.
	2644	Easier to use than explain. It sets the region to an `interesting'
	2645	block of succeeding lines. If point is on a blank line, it goes down to
	2646	the next non-blank line. That will be the start of the region. The end
	2647	of the region depends on the kind of line at the start:
	2648
	2649	- If a comment, the region will include all succeeding comment lines up
	2650	to (but not including) the next non-comment line (if any).
	2651
	2652	- Else if a prefix arg is given, and the line begins one of these
	2653	structures:
	2654
	2655	if elif else try except finally for while def class
	2656
	2657	the region will be set to the body of the structure, including
	2658	following blocks that `belong' to it, but excluding trailing blank
	2659	and comment lines. E.g., if on a `try' statement, the `try' block
	2660	and all (if any) of the following `except' and `finally' blocks
	2661	that belong to the `try' structure will be in the region. Ditto
	2662	for if/elif/else, for/else and while/else structures, and (a bit
	2663	degenerate, since they're always one-block structures) def and
	2664	class blocks.
	2665
	2666	- Else if no prefix argument is given, and the line begins a Python
	2667	block (see list above), and the block is not a `one-liner' (i.e.,
	2668	the statement ends with a colon, not with code), the region will
	2669	include all succeeding lines up to (but not including) the next
	2670	code statement (if any) that's indented no more than the starting
	2671	line, except that trailing blank and comment lines are excluded.
	2672	E.g., if the starting line begins a multi-statement `def'
	2673	structure, the region will be set to the full function definition,
	2674	but without any trailing `noise' lines.
	2675
	2676	- Else the region will include all succeeding lines up to (but not
	2677	including) the next blank line, or code or indenting-comment line
	2678	indented strictly less than the starting line. Trailing indenting
	2679	comment lines are included in this case, but not trailing blank
	2680	lines.
	2681
	2682	A msg identifying the location of the mark is displayed in the echo
	2683	area; or do `\\[exchange-point-and-mark]' to flip down to the end.
	2684
	2685	If called from a program, optional argument EXTEND plays the role of
	2686	the prefix arg, and if optional argument JUST-MOVE is not nil, just
	2687	moves to the end of the block (& does not set mark or display a msg)."
	2688	(interactive "P") ; raw prefix arg
	2689	(py-goto-initial-line)
	2690	;; skip over blank lines
	2691	(while (and
	2692	(looking-at "[ \t]*$") ; while blank line
	2693	(not (eobp))) ; & somewhere to go
	2694	(forward-line 1))
	2695	(if (eobp)
	2696	(error "Hit end of buffer without finding a non-blank stmt"))
	2697	(let ((initial-pos (point))
	2698	(initial-indent (current-indentation))
	2699	last-pos ; position of last stmt in region
	2700	(followers
	2701	'((if elif else) (elif elif else) (else)
	2702	(try except finally) (except except) (finally)
	2703	(for else) (while else)
	2704	(def) (class) ) )
	2705	first-symbol next-symbol)
	2706
	2707	(cond
	2708	;; if comment line, suck up the following comment lines
	2709	((looking-at "[ \t]*#")
	2710	(re-search-forward "^[ \t]*[^ \t#]" nil 'move) ; look for non-comment
	2711	(re-search-backward "^[ \t]*#") ; and back to last comment in block
	2712	(setq last-pos (point)))
	2713
	2714	;; else if line is a block line and EXTEND given, suck up
	2715	;; the whole structure
	2716	((and extend
	2717	(setq first-symbol (py-suck-up-first-keyword) )
	2718	(assq first-symbol followers))
	2719	(while (and
	2720	(or (py-goto-beyond-block) t) ; side effect
	2721	(forward-line -1) ; side effect
	2722	(setq last-pos (point)) ; side effect
	2723	(py-goto-statement-below)
	2724	(= (current-indentation) initial-indent)
	2725	(setq next-symbol (py-suck-up-first-keyword))
	2726	(memq next-symbol (cdr (assq first-symbol followers))))
	2727	(setq first-symbol next-symbol)))
	2728
	2729	;; else if line opens a block, search for next stmt indented <=
	2730	((py-statement-opens-block-p)
	2731	(while (and
	2732	(setq last-pos (point)) ; always true -- side effect
	2733	(py-goto-statement-below)
	2734	(> (current-indentation) initial-indent)
	2735	)))
	2736
	2737	;; else plain code line; stop at next blank line, or stmt or
	2738	;; indenting comment line indented <
	2739	(t
	2740	(while (and
	2741	(setq last-pos (point)) ; always true -- side effect
	2742	(or (py-goto-beyond-final-line) t)
	2743	(not (looking-at "[ \t]*$")) ; stop at blank line
	2744	(or
	2745	(>= (current-indentation) initial-indent)
	2746	(looking-at "[ \t]*#[^ \t\n]"))) ; ignore non-indenting #
	2747	nil)))
	2748
	2749	;; skip to end of last stmt
	2750	(goto-char last-pos)
	2751	(py-goto-beyond-final-line)
	2752
	2753	;; set mark & display
	2754	(if just-move
	2755	() ; just return
	2756	(push-mark (point) 'no-msg)
	2757	(forward-line -1)
	2758	(message "Mark set after: %s" (py-suck-up-leading-text))
	2759	(goto-char initial-pos))))
	2760
	2761	(defun py-mark-def-or-class (&optional class)
	2762	"Set region to body of def (or class, with prefix arg) enclosing point.
	2763	Pushes the current mark, then point, on the mark ring (all language
	2764	modes do this, but although it's handy it's never documented ...).
	2765
	2766	In most Emacs language modes, this function bears at least a
	2767	hallucinogenic resemblance to `\\[py-end-of-def-or-class]' and
	2768	`\\[py-beginning-of-def-or-class]'.
	2769
	2770	And in earlier versions of Python mode, all 3 were tightly connected.
	2771	Turned out that was more confusing than useful: the `goto start' and
	2772	`goto end' commands are usually used to search through a file, and
	2773	people expect them to act a lot like `search backward' and `search
	2774	forward' string-search commands. But because Python `def' and `class'
	2775	can nest to arbitrary levels, finding the smallest def containing
	2776	point cannot be done via a simple backward search: the def containing
	2777	point may not be the closest preceding def, or even the closest
	2778	preceding def that's indented less. The fancy algorithm required is
	2779	appropriate for the usual uses of this `mark' command, but not for the
	2780	`goto' variations.
	2781
	2782	So the def marked by this command may not be the one either of the
	2783	`goto' commands find: If point is on a blank or non-indenting comment
	2784	line, moves back to start of the closest preceding code statement or
	2785	indenting comment line. If this is a `def' statement, that's the def
	2786	we use. Else searches for the smallest enclosing `def' block and uses
	2787	that. Else signals an error.
	2788
	2789	When an enclosing def is found: The mark is left immediately beyond
	2790	the last line of the def block. Point is left at the start of the
	2791	def, except that: if the def is preceded by a number of comment lines
	2792	followed by (at most) one optional blank line, point is left at the
	2793	start of the comments; else if the def is preceded by a blank line,
	2794	point is left at its start.
	2795
	2796	The intent is to mark the containing def/class and its associated
	2797	documentation, to make moving and duplicating functions and classes
	2798	pleasant."
	2799	(interactive "P") ; raw prefix arg
	2800	(let ((start (point))
	2801	(which (cond ((eq class 'either) "\$class\\\|def\$")
	2802	(class "class")
	2803	(t "def"))))
	2804	(push-mark start)
	2805	(if (not (py-go-up-tree-to-keyword which))
	2806	(progn (goto-char start)
	2807	(error "Enclosing %s not found"
	2808	(if (eq class 'either)
	2809	"def or class"
	2810	which)))
	2811	;; else enclosing def/class found
	2812	(setq start (point))
	2813	(py-goto-beyond-block)
	2814	(push-mark (point))
	2815	(goto-char start)
	2816	(if (zerop (forward-line -1)) ; if there is a preceding line
	2817	(progn
	2818	(if (looking-at "[ \t]*$") ; it's blank
	2819	(setq start (point)) ; so reset start point
	2820	(goto-char start)) ; else try again
	2821	(if (zerop (forward-line -1))
	2822	(if (looking-at "[ \t]*#") ; a comment
	2823	;; look back for non-comment line
	2824	;; tricky: note that the regexp matches a blank
	2825	;; line, cuz \n is in the 2nd character class
	2826	(and
	2827	(re-search-backward "^[ \t]*[^ \t#]" nil 'move)
	2828	(forward-line 1))
	2829	;; no comment, so go back
	2830	(goto-char start)))))))
	2831	(exchange-point-and-mark)
	2832	(py-keep-region-active))
	2833
	2834	;; ripped from cc-mode
	2835	(defun py-forward-into-nomenclature (&optional arg)
	2836	"Move forward to end of a nomenclature section or word.
	2837	With \\[universal-argument] (programmatically, optional argument ARG),
	2838	do it that many times.
	2839
	2840	A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
	2841	(interactive "p")
	2842	(let ((case-fold-search nil))
	2843	(if (> arg 0)
	2844	(re-search-forward
	2845	"\$\\W\\\|[_]\$\$[A-Z][a-z0-9]*\$"
	2846	(point-max) t arg)
	2847	(while (and (< arg 0)
	2848	(re-search-backward
	2849	"\$\\W\\\|[a-z0-9]\$[A-Z]+\\\|\$\\W\\\|[_]\$\\w+"
	2850	(point-min) 0))
	2851	(forward-char 1)
	2852	(setq arg (1+ arg)))))
	2853	(py-keep-region-active))
	2854
	2855	(defun py-backward-into-nomenclature (&optional arg)
	2856	"Move backward to beginning of a nomenclature section or word.
	2857	With optional ARG, move that many times. If ARG is negative, move
	2858	forward.
	2859
	2860	A `nomenclature' is a fancy way of saying AWordWithMixedCaseNotUnderscores."
	2861	(interactive "p")
	2862	(py-forward-into-nomenclature (- arg))
	2863	(py-keep-region-active))
	2864
	2865
	2866
	2867	;; pdbtrack functions
	2868	(defun py-pdbtrack-toggle-stack-tracking (arg)
	2869	(interactive "P")
	2870	(if (not (get-buffer-process (current-buffer)))
	2871	(error "No process associated with buffer '%s'" (current-buffer)))
	2872	;; missing or 0 is toggle, >0 turn on, <0 turn off
	2873	(if (or (not arg)
	2874	(zerop (setq arg (prefix-numeric-value arg))))
	2875	(setq py-pdbtrack-do-tracking-p (not py-pdbtrack-do-tracking-p))
	2876	(setq py-pdbtrack-do-tracking-p (> arg 0)))
	2877	(message "%sabled Python's pdbtrack"
	2878	(if py-pdbtrack-do-tracking-p "En" "Dis")))
	2879
	2880	(defun turn-on-pdbtrack ()
	2881	(interactive)
	2882	(py-pdbtrack-toggle-stack-tracking 1))
	2883
	2884	(defun turn-off-pdbtrack ()
	2885	(interactive)
	2886	(py-pdbtrack-toggle-stack-tracking 0))
	2887
	2888
	2889
	2890	;; Pychecker
	2891	(defun py-pychecker-run (command)
	2892	"*Run pychecker (default on the file currently visited)."
	2893	(interactive
	2894	(let ((default
	2895	(format "%s %s %s" py-pychecker-command
	2896	(mapconcat 'identity py-pychecker-command-args " ")
	2897	(buffer-file-name)))
	2898	(last (when py-pychecker-history
	2899	(let* ((lastcmd (car py-pychecker-history))
	2900	(cmd (cdr (reverse (split-string lastcmd))))
	2901	(newcmd (reverse (cons (buffer-file-name) cmd))))
	2902	(mapconcat 'identity newcmd " ")))))
	2903
	2904	(list
	2905	(if (fboundp 'read-shell-command)
	2906	(read-shell-command "Run pychecker like this: "
	2907	(if last
	2908	last
	2909	default)
	2910	'py-pychecker-history)
	2911	(read-string "Run pychecker like this: "
	2912	(if last
	2913	last
	2914	default)
	2915	'py-pychecker-history))
	2916	)))
	2917	(save-some-buffers (not py-ask-about-save) nil)
	2918	(compile-internal command "No more errors"))
	2919
	2920
	2921
	2922	;; pydoc commands. The guts of this function is stolen from XEmacs's
	2923	;; symbol-near-point, but without the useless regexp-quote call on the
	2924	;; results, nor the interactive bit. Also, we've added the temporary
	2925	;; syntax table setting, which Skip originally had broken out into a
	2926	;; separate function. Note that Emacs doesn't have the original
	2927	;; function.
	2928	(defun py-symbol-near-point ()
	2929	"Return the first textual item to the nearest point."
	2930	;; alg stolen from etag.el
	2931	(save-excursion
	2932	(with-syntax-table py-dotted-expression-syntax-table
	2933	(if (or (bobp) (not (memq (char-syntax (char-before)) '(?w ?_))))
	2934	(while (not (looking-at "\\sw\\\|\\s_\\\|\\'"))
	2935	(forward-char 1)))
	2936	(while (looking-at "\\sw\\\|\\s_")
	2937	(forward-char 1))
	2938	(if (re-search-backward "\\sw\\\|\\s_" nil t)
	2939	(progn (forward-char 1)
	2940	(buffer-substring (point)
	2941	(progn (forward-sexp -1)
	2942	(while (looking-at "\\s'")
	2943	(forward-char 1))
	2944	(point))))
	2945	nil))))
	2946
	2947	(defun py-help-at-point ()
	2948	"Get help from Python based on the symbol nearest point."
	2949	(interactive)
	2950	(let* ((sym (py-symbol-near-point))
	2951	(base (substring sym 0 (or (search "." sym :from-end t) 0)))
	2952	cmd)
	2953	(if (not (equal base ""))
	2954	(setq cmd (concat "import " base "\n")))
	2955	(setq cmd (concat "import pydoc\n"
	2956	cmd
	2957	"try: pydoc.help('" sym "')\n"
	2958	"except: print 'No help available on:', \"" sym "\""))
	2959	(message cmd)
	2960	(py-execute-string cmd)
	2961	(set-buffer "Python Output")
	2962	;; BAW: Should we really be leaving the output buffer in help-mode?
	2963	(help-mode)))
	2964
	2965
	2966
	2967	;; Documentation functions
	2968
	2969	;; dump the long form of the mode blurb; does the usual doc escapes,
	2970	;; plus lines of the form ^[vc]:name$ to suck variable & command docs
	2971	;; out of the right places, along with the keys they're on & current
	2972	;; values
	2973	(defun py-dump-help-string (str)
	2974	(with-output-to-temp-buffer "Help"
	2975	(let ((locals (buffer-local-variables))
	2976	funckind funcname func funcdoc
	2977	(start 0) mstart end
	2978	keys )
	2979	(while (string-match "^%\$[vc]\$:\$.+\$\n" str start)
	2980	(setq mstart (match-beginning 0) end (match-end 0)
	2981	funckind (substring str (match-beginning 1) (match-end 1))
	2982	funcname (substring str (match-beginning 2) (match-end 2))
	2983	func (intern funcname))
	2984	(princ (substitute-command-keys (substring str start mstart)))
	2985	(cond
	2986	((equal funckind "c") ; command
	2987	(setq funcdoc (documentation func)
	2988	keys (concat
	2989	"Key(s): "
	2990	(mapconcat 'key-description
	2991	(where-is-internal func py-mode-map)
	2992	", "))))
	2993	((equal funckind "v") ; variable
	2994	(setq funcdoc (documentation-property func 'variable-documentation)
	2995	keys (if (assq func locals)
	2996	(concat
	2997	"Local/Global values: "
	2998	(prin1-to-string (symbol-value func))
	2999	" / "
	3000	(prin1-to-string (default-value func)))
	3001	(concat
	3002	"Value: "
	3003	(prin1-to-string (symbol-value func))))))
	3004	(t ; unexpected
	3005	(error "Error in py-dump-help-string, tag `%s'" funckind)))
	3006	(princ (format "\n-> %s:\t%s\t%s\n\n"
	3007	(if (equal funckind "c") "Command" "Variable")
	3008	funcname keys))
	3009	(princ funcdoc)
	3010	(terpri)
	3011	(setq start end))
	3012	(princ (substitute-command-keys (substring str start))))
	3013	(print-help-return-message)))
	3014
	3015	(defun py-describe-mode ()
	3016	"Dump long form of Python-mode docs."
	3017	(interactive)
	3018	(py-dump-help-string "Major mode for editing Python files.
	3019	Knows about Python indentation, tokens, comments and continuation lines.
	3020	Paragraphs are separated by blank lines only.
	3021
	3022	Major sections below begin with the string `@'; specific function and
	3023	variable docs begin with `->'.
	3024
	3025	@EXECUTING PYTHON CODE
	3026
	3027	\\[py-execute-import-or-reload]\timports or reloads the file in the Python interpreter
	3028	\\[py-execute-buffer]\tsends the entire buffer to the Python interpreter
	3029	\\[py-execute-region]\tsends the current region
	3030	\\[py-execute-def-or-class]\tsends the current function or class definition
	3031	\\[py-execute-string]\tsends an arbitrary string
	3032	\\[py-shell]\tstarts a Python interpreter window; this will be used by
	3033	\tsubsequent Python execution commands
	3034	%c:py-execute-import-or-reload
	3035	%c:py-execute-buffer
	3036	%c:py-execute-region
	3037	%c:py-execute-def-or-class
	3038	%c:py-execute-string
	3039	%c:py-shell
	3040
	3041	@VARIABLES
	3042
	3043	py-indent-offset\tindentation increment
	3044	py-block-comment-prefix\tcomment string used by comment-region
	3045
	3046	py-python-command\tshell command to invoke Python interpreter
	3047	py-temp-directory\tdirectory used for temp files (if needed)
	3048
	3049	py-beep-if-tab-change\tring the bell if tab-width is changed
	3050	%v:py-indent-offset
	3051	%v:py-block-comment-prefix
	3052	%v:py-python-command
	3053	%v:py-temp-directory
	3054	%v:py-beep-if-tab-change
	3055
	3056	@KINDS OF LINES
	3057
	3058	Each physical line in the file is either a `continuation line' (the
	3059	preceding line ends with a backslash that's not part of a comment, or
	3060	the paren/bracket/brace nesting level at the start of the line is
	3061	non-zero, or both) or an `initial line' (everything else).
	3062
	3063	An initial line is in turn a `blank line' (contains nothing except
	3064	possibly blanks or tabs), a `comment line' (leftmost non-blank
	3065	character is `#'), or a `code line' (everything else).
	3066
	3067	Comment Lines
	3068
	3069	Although all comment lines are treated alike by Python, Python mode
	3070	recognizes two kinds that act differently with respect to indentation.
	3071
	3072	An `indenting comment line' is a comment line with a blank, tab or
	3073	nothing after the initial `#'. The indentation commands (see below)
	3074	treat these exactly as if they were code lines: a line following an
	3075	indenting comment line will be indented like the comment line. All
	3076	other comment lines (those with a non-whitespace character immediately
	3077	following the initial `#') are `non-indenting comment lines', and
	3078	their indentation is ignored by the indentation commands.
	3079
	3080	Indenting comment lines are by far the usual case, and should be used
	3081	whenever possible. Non-indenting comment lines are useful in cases
	3082	like these:
	3083
	3084	\ta = b # a very wordy single-line comment that ends up being
	3085	\t #... continued onto another line
	3086
	3087	\tif a == b:
	3088	##\t\tprint 'panic!' # old code we've `commented out'
	3089	\t\treturn a
	3090
	3091	Since the `#...' and `##' comment lines have a non-whitespace
	3092	character following the initial `#', Python mode ignores them when
	3093	computing the proper indentation for the next line.
	3094
	3095	Continuation Lines and Statements
	3096
	3097	The Python-mode commands generally work on statements instead of on
	3098	individual lines, where a `statement' is a comment or blank line, or a
	3099	code line and all of its following continuation lines (if any)
	3100	considered as a single logical unit. The commands in this mode
	3101	generally (when it makes sense) automatically move to the start of the
	3102	statement containing point, even if point happens to be in the middle
	3103	of some continuation line.
	3104
	3105
	3106	@INDENTATION
	3107
	3108	Primarily for entering new code:
	3109	\t\\[indent-for-tab-command]\t indent line appropriately
	3110	\t\\[py-newline-and-indent]\t insert newline, then indent
	3111	\t\\[py-electric-backspace]\t reduce indentation, or delete single character
	3112
	3113	Primarily for reindenting existing code:
	3114	\t\\[py-guess-indent-offset]\t guess py-indent-offset from file content; change locally
	3115	\t\\[universal-argument] \\[py-guess-indent-offset]\t ditto, but change globally
	3116
	3117	\t\\[py-indent-region]\t reindent region to match its context
	3118	\t\\[py-shift-region-left]\t shift region left by py-indent-offset
	3119	\t\\[py-shift-region-right]\t shift region right by py-indent-offset
	3120
	3121	Unlike most programming languages, Python uses indentation, and only
	3122	indentation, to specify block structure. Hence the indentation supplied
	3123	automatically by Python-mode is just an educated guess: only you know
	3124	the block structure you intend, so only you can supply correct
	3125	indentation.
	3126
	3127	The \\[indent-for-tab-command] and \\[py-newline-and-indent] keys try to suggest plausible indentation, based on
	3128	the indentation of preceding statements. E.g., assuming
	3129	py-indent-offset is 4, after you enter
	3130	\tif a > 0: \\[py-newline-and-indent]
	3131	the cursor will be moved to the position of the `_' (_ is not a
	3132	character in the file, it's just used here to indicate the location of
	3133	the cursor):
	3134	\tif a > 0:
	3135	\t _
	3136	If you then enter `c = d' \\[py-newline-and-indent], the cursor will move
	3137	to
	3138	\tif a > 0:
	3139	\t c = d
	3140	\t _
	3141	Python-mode cannot know whether that's what you intended, or whether
	3142	\tif a > 0:
	3143	\t c = d
	3144	\t_
	3145	was your intent. In general, Python-mode either reproduces the
	3146	indentation of the (closest code or indenting-comment) preceding
	3147	statement, or adds an extra py-indent-offset blanks if the preceding
	3148	statement has `:' as its last significant (non-whitespace and non-
	3149	comment) character. If the suggested indentation is too much, use
	3150	\\[py-electric-backspace] to reduce it.
	3151
	3152	Continuation lines are given extra indentation. If you don't like the
	3153	suggested indentation, change it to something you do like, and Python-
	3154	mode will strive to indent later lines of the statement in the same way.
	3155
	3156	If a line is a continuation line by virtue of being in an unclosed
	3157	paren/bracket/brace structure (`list', for short), the suggested
	3158	indentation depends on whether the current line contains the first item
	3159	in the list. If it does, it's indented py-indent-offset columns beyond
	3160	the indentation of the line containing the open bracket. If you don't
	3161	like that, change it by hand. The remaining items in the list will mimic
	3162	whatever indentation you give to the first item.
	3163
	3164	If a line is a continuation line because the line preceding it ends with
	3165	a backslash, the third and following lines of the statement inherit their
	3166	indentation from the line preceding them. The indentation of the second
	3167	line in the statement depends on the form of the first (base) line: if
	3168	the base line is an assignment statement with anything more interesting
	3169	than the backslash following the leftmost assigning `=', the second line
	3170	is indented two columns beyond that `='. Else it's indented to two
	3171	columns beyond the leftmost solid chunk of non-whitespace characters on
	3172	the base line.
	3173
	3174	Warning: indent-region should not normally be used! It calls \\[indent-for-tab-command]
	3175	repeatedly, and as explained above, \\[indent-for-tab-command] can't guess the block
	3176	structure you intend.
	3177	%c:indent-for-tab-command
	3178	%c:py-newline-and-indent
	3179	%c:py-electric-backspace
	3180
	3181
	3182	The next function may be handy when editing code you didn't write:
	3183	%c:py-guess-indent-offset
	3184
	3185
	3186	The remaining `indent' functions apply to a region of Python code. They
	3187	assume the block structure (equals indentation, in Python) of the region
	3188	is correct, and alter the indentation in various ways while preserving
	3189	the block structure:
	3190	%c:py-indent-region
	3191	%c:py-shift-region-left
	3192	%c:py-shift-region-right
	3193
	3194	@MARKING & MANIPULATING REGIONS OF CODE
	3195
	3196	\\[py-mark-block]\t mark block of lines
	3197	\\[py-mark-def-or-class]\t mark smallest enclosing def
	3198	\\[universal-argument] \\[py-mark-def-or-class]\t mark smallest enclosing class
	3199	\\[comment-region]\t comment out region of code
	3200	\\[universal-argument] \\[comment-region]\t uncomment region of code
	3201	%c:py-mark-block
	3202	%c:py-mark-def-or-class
	3203	%c:comment-region
	3204
	3205	@MOVING POINT
	3206
	3207	\\[py-previous-statement]\t move to statement preceding point
	3208	\\[py-next-statement]\t move to statement following point
	3209	\\[py-goto-block-up]\t move up to start of current block
	3210	\\[py-beginning-of-def-or-class]\t move to start of def
	3211	\\[universal-argument] \\[py-beginning-of-def-or-class]\t move to start of class
	3212	\\[py-end-of-def-or-class]\t move to end of def
	3213	\\[universal-argument] \\[py-end-of-def-or-class]\t move to end of class
	3214
	3215	The first two move to one statement beyond the statement that contains
	3216	point. A numeric prefix argument tells them to move that many
	3217	statements instead. Blank lines, comment lines, and continuation lines
	3218	do not count as `statements' for these commands. So, e.g., you can go
	3219	to the first code statement in a file by entering
	3220	\t\\[beginning-of-buffer]\t to move to the top of the file
	3221	\t\\[py-next-statement]\t to skip over initial comments and blank lines
	3222	Or do `\\[py-previous-statement]' with a huge prefix argument.
	3223	%c:py-previous-statement
	3224	%c:py-next-statement
	3225	%c:py-goto-block-up
	3226	%c:py-beginning-of-def-or-class
	3227	%c:py-end-of-def-or-class
	3228
	3229	@LITTLE-KNOWN EMACS COMMANDS PARTICULARLY USEFUL IN PYTHON MODE
	3230
	3231	`\\[indent-new-comment-line]' is handy for entering a multi-line comment.
	3232
	3233	`\\[set-selective-display]' with a `small' prefix arg is ideally suited for viewing the
	3234	overall class and def structure of a module.
	3235
	3236	`\\[back-to-indentation]' moves point to a line's first non-blank character.
	3237
	3238	`\\[indent-relative]' is handy for creating odd indentation.
	3239
	3240	@OTHER EMACS HINTS
	3241
	3242	If you don't like the default value of a variable, change its value to
	3243	whatever you do like by putting a `setq' line in your .emacs file.
	3244	E.g., to set the indentation increment to 4, put this line in your
	3245	.emacs:
	3246	\t(setq py-indent-offset 4)
	3247	To see the value of a variable, do `\\[describe-variable]' and enter the variable
	3248	name at the prompt.
	3249
	3250	When entering a key sequence like `C-c C-n', it is not necessary to
	3251	release the CONTROL key after doing the `C-c' part -- it suffices to
	3252	press the CONTROL key, press and release `c' (while still holding down
	3253	CONTROL), press and release `n' (while still holding down CONTROL), &
	3254	then release CONTROL.
	3255
	3256	Entering Python mode calls with no arguments the value of the variable
	3257	`python-mode-hook', if that value exists and is not nil; for backward
	3258	compatibility it also tries `py-mode-hook'; see the `Hooks' section of
	3259	the Elisp manual for details.
	3260
	3261	Obscure: When python-mode is first loaded, it looks for all bindings
	3262	to newline-and-indent in the global keymap, and shadows them with
	3263	local bindings to py-newline-and-indent."))
	3264
	3265	(require 'info-look)
	3266	;; The info-look package does not always provide this function (it
	3267	;; appears this is the case with XEmacs 21.1)
	3268	(when (fboundp 'info-lookup-maybe-add-help)
	3269	(info-lookup-maybe-add-help
	3270	:mode 'python-mode
	3271	:regexp "[a-zA-Z0-9_]+"
	3272	:doc-spec '(("(python-lib)Module Index")
	3273	("(python-lib)Class-Exception-Object Index")
	3274	("(python-lib)Function-Method-Variable Index")
	3275	("(python-lib)Miscellaneous Index")))
	3276	)
	3277
	3278
	3279	;; Helper functions
	3280	(defvar py-parse-state-re
	3281	(concat
	3282	"^[ \t]*\$elif\\\|else\\\|while\\\|def\\\|class\$\\>"
	3283	"\\\|"
	3284	"^[^ #\t\n]"))
	3285
	3286	(defun py-parse-state ()
	3287	"Return the parse state at point (see `parse-partial-sexp' docs)."
	3288	(save-excursion
	3289	(let ((here (point))
	3290	pps done)
	3291	(while (not done)
	3292	;; back up to the first preceding line (if any; else start of
	3293	;; buffer) that begins with a popular Python keyword, or a
	3294	;; non- whitespace and non-comment character. These are good
	3295	;; places to start parsing to see whether where we started is
	3296	;; at a non-zero nesting level. It may be slow for people who
	3297	;; write huge code blocks or huge lists ... tough beans.
	3298	(re-search-backward py-parse-state-re nil 'move)
	3299	(beginning-of-line)
	3300	;; In XEmacs, we have a much better way to test for whether
	3301	;; we're in a triple-quoted string or not. Emacs does not
	3302	;; have this built-in function, which is its loss because
	3303	;; without scanning from the beginning of the buffer, there's
	3304	;; no accurate way to determine this otherwise.
	3305	(save-excursion (setq pps (parse-partial-sexp (point) here)))
	3306	;; make sure we don't land inside a triple-quoted string
	3307	(setq done (or (not (nth 3 pps))
	3308	(bobp)))
	3309	;; Just go ahead and short circuit the test back to the
	3310	;; beginning of the buffer. This will be slow, but not
	3311	;; nearly as slow as looping through many
	3312	;; re-search-backwards.
	3313	(if (not done)
	3314	(goto-char (point-min))))
	3315	pps)))
	3316
	3317	(defun py-nesting-level ()
	3318	"Return the buffer position of the last unclosed enclosing list.
	3319	If nesting level is zero, return nil."
	3320	(let ((status (py-parse-state)))
	3321	(if (zerop (car status))
	3322	nil ; not in a nest
	3323	(car (cdr status))))) ; char# of open bracket
	3324
	3325	(defun py-backslash-continuation-line-p ()
	3326	"Return t iff preceding line ends with backslash that is not in a comment."
	3327	(save-excursion
	3328	(beginning-of-line)
	3329	(and
	3330	;; use a cheap test first to avoid the regexp if possible
	3331	;; use 'eq' because char-after may return nil
	3332	(eq (char-after (- (point) 2)) ?\\ )
	3333	;; make sure; since eq test passed, there is a preceding line
	3334	(forward-line -1) ; always true -- side effect
	3335	(looking-at py-continued-re))))
	3336
	3337	(defun py-continuation-line-p ()
	3338	"Return t iff current line is a continuation line."
	3339	(save-excursion
	3340	(beginning-of-line)
	3341	(or (py-backslash-continuation-line-p)
	3342	(py-nesting-level))))
	3343
	3344	(defun py-goto-beginning-of-tqs (delim)
	3345	"Go to the beginning of the triple quoted string we find ourselves in.
	3346	DELIM is the TQS string delimiter character we're searching backwards
	3347	for."
	3348	(let ((skip (and delim (make-string 1 delim)))
	3349	(continue t))
	3350	(when skip
	3351	(save-excursion
	3352	(while continue
	3353	(py-safe (search-backward skip))
	3354	(setq continue (and (not (bobp))
	3355	(= (char-before) ?\\))))
	3356	(if (and (= (char-before) delim)
	3357	(= (char-before (1- (point))) delim))
	3358	(setq skip (make-string 3 delim))))
	3359	;; we're looking at a triple-quoted string
	3360	(py-safe (search-backward skip)))))
	3361
	3362	(defun py-goto-initial-line ()
	3363	"Go to the initial line of the current statement.
	3364	Usually this is the line we're on, but if we're on the 2nd or
	3365	following lines of a continuation block, we need to go up to the first
	3366	line of the block."
	3367	;; Tricky: We want to avoid quadratic-time behavior for long
	3368	;; continued blocks, whether of the backslash or open-bracket
	3369	;; varieties, or a mix of the two. The following manages to do that
	3370	;; in the usual cases.
	3371	;;
	3372	;; Also, if we're sitting inside a triple quoted string, this will
	3373	;; drop us at the line that begins the string.
	3374	(let (open-bracket-pos)
	3375	(while (py-continuation-line-p)
	3376	(beginning-of-line)
	3377	(if (py-backslash-continuation-line-p)
	3378	(while (py-backslash-continuation-line-p)
	3379	(forward-line -1))
	3380	;; else zip out of nested brackets/braces/parens
	3381	(while (setq open-bracket-pos (py-nesting-level))
	3382	(goto-char open-bracket-pos)))))
	3383	(beginning-of-line))
	3384
	3385	(defun py-goto-beyond-final-line ()
	3386	"Go to the point just beyond the fine line of the current statement.
	3387	Usually this is the start of the next line, but if this is a
	3388	multi-line statement we need to skip over the continuation lines."
	3389	;; Tricky: Again we need to be clever to avoid quadratic time
	3390	;; behavior.
	3391	;;
	3392	;; XXX: Not quite the right solution, but deals with multi-line doc
	3393	;; strings
	3394	(if (looking-at (concat "[ \t]*\$" py-stringlit-re "\$"))
	3395	(goto-char (match-end 0)))
	3396	;;
	3397	(forward-line 1)
	3398	(let (state)
	3399	(while (and (py-continuation-line-p)
	3400	(not (eobp)))
	3401	;; skip over the backslash flavor
	3402	(while (and (py-backslash-continuation-line-p)
	3403	(not (eobp)))
	3404	(forward-line 1))
	3405	;; if in nest, zip to the end of the nest
	3406	(setq state (py-parse-state))
	3407	(if (and (not (zerop (car state)))
	3408	(not (eobp)))
	3409	(progn
	3410	(parse-partial-sexp (point) (point-max) 0 nil state)
	3411	(forward-line 1))))))
	3412
	3413	(defun py-statement-opens-block-p ()
	3414	"Return t iff the current statement opens a block.
	3415	I.e., iff it ends with a colon that is not in a comment. Point should
	3416	be at the start of a statement."
	3417	(save-excursion
	3418	(let ((start (point))
	3419	(finish (progn (py-goto-beyond-final-line) (1- (point))))
	3420	(searching t)
	3421	(answer nil)
	3422	state)
	3423	(goto-char start)
	3424	(while searching
	3425	;; look for a colon with nothing after it except whitespace, and
	3426	;; maybe a comment
	3427	(if (re-search-forward ":\$[ \t]\\\|\\\\\n\$\$#.\$?$"
	3428	finish t)
	3429	(if (eq (point) finish) ; note: no `else' clause; just
	3430	; keep searching if we're not at
	3431	; the end yet
	3432	;; sure looks like it opens a block -- but it might
	3433	;; be in a comment
	3434	(progn
	3435	(setq searching nil) ; search is done either way
	3436	(setq state (parse-partial-sexp start
	3437	(match-beginning 0)))
	3438	(setq answer (not (nth 4 state)))))
	3439	;; search failed: couldn't find another interesting colon
	3440	(setq searching nil)))
	3441	answer)))
	3442
	3443	(defun py-statement-closes-block-p ()
	3444	"Return t iff the current statement closes a block.
	3445	I.e., if the line starts with `return', `raise', `break', `continue',
	3446	and `pass'. This doesn't catch embedded statements."
	3447	(let ((here (point)))
	3448	(py-goto-initial-line)
	3449	(back-to-indentation)
	3450	(prog1
	3451	(looking-at (concat py-block-closing-keywords-re "\\>"))
	3452	(goto-char here))))
	3453
	3454	(defun py-goto-beyond-block ()
	3455	"Go to point just beyond the final line of block begun by the current line.
	3456	This is the same as where `py-goto-beyond-final-line' goes unless
	3457	we're on colon line, in which case we go to the end of the block.
	3458	Assumes point is at the beginning of the line."
	3459	(if (py-statement-opens-block-p)
	3460	(py-mark-block nil 'just-move)
	3461	(py-goto-beyond-final-line)))
	3462
	3463	(defun py-goto-statement-at-or-above ()
	3464	"Go to the start of the first statement at or preceding point.
	3465	Return t if there is such a statement, otherwise nil. `Statement'
	3466	does not include blank lines, comments, or continuation lines."
	3467	(py-goto-initial-line)
	3468	(if (looking-at py-blank-or-comment-re)
	3469	;; skip back over blank & comment lines
	3470	;; note: will skip a blank or comment line that happens to be
	3471	;; a continuation line too
	3472	(if (re-search-backward "^[ \t]*[^ \t#\n]" nil t)
	3473	(progn (py-goto-initial-line) t)
	3474	nil)
	3475	t))
	3476
	3477	(defun py-goto-statement-below ()
	3478	"Go to start of the first statement following the statement containing point.
	3479	Return t if there is such a statement, otherwise nil. `Statement'
	3480	does not include blank lines, comments, or continuation lines."
	3481	(beginning-of-line)
	3482	(let ((start (point)))
	3483	(py-goto-beyond-final-line)
	3484	(while (and
	3485	(or (looking-at py-blank-or-comment-re)
	3486	(py-in-literal))
	3487	(not (eobp)))
	3488	(forward-line 1))
	3489	(if (eobp)
	3490	(progn (goto-char start) nil)
	3491	t)))
	3492
	3493	(defun py-go-up-tree-to-keyword (key)
	3494	"Go to begining of statement starting with KEY, at or preceding point.
	3495
	3496	KEY is a regular expression describing a Python keyword. Skip blank
	3497	lines and non-indenting comments. If the statement found starts with
	3498	KEY, then stop, otherwise go back to first enclosing block starting
	3499	with KEY. If successful, leave point at the start of the KEY line and
	3500	return t. Otherwise, leav point at an undefined place and return nil."
	3501	;; skip blanks and non-indenting #
	3502	(py-goto-initial-line)
	3503	(while (and
	3504	(looking-at "[ \t]*\$$\\\|#[^ \t\n]\$")
	3505	(zerop (forward-line -1))) ; go back
	3506	nil)
	3507	(py-goto-initial-line)
	3508	(let* ((re (concat "[ \t]*" key "\\b"))
	3509	(case-fold-search nil) ; let* so looking-at sees this
	3510	(found (looking-at re))
	3511	(dead nil))
	3512	(while (not (or found dead))
	3513	(condition-case nil ; in case no enclosing block
	3514	(py-goto-block-up 'no-mark)
	3515	(error (setq dead t)))
	3516	(or dead (setq found (looking-at re))))
	3517	(beginning-of-line)
	3518	found))
	3519
	3520	(defun py-suck-up-leading-text ()
	3521	"Return string in buffer from start of indentation to end of line.
	3522	Prefix with \"...\" if leading whitespace was skipped."
	3523	(save-excursion
	3524	(back-to-indentation)
	3525	(concat
	3526	(if (bolp) "" "...")
	3527	(buffer-substring (point) (progn (end-of-line) (point))))))
	3528
	3529	(defun py-suck-up-first-keyword ()
	3530	"Return first keyword on the line as a Lisp symbol.
	3531	`Keyword' is defined (essentially) as the regular expression
	3532	([a-z]+). Returns nil if none was found."
	3533	(let ((case-fold-search nil))
	3534	(if (looking-at "[ \t]*\$[a-z]+\$\\b")
	3535	(intern (buffer-substring (match-beginning 1) (match-end 1)))
	3536	nil)))
	3537
	3538	(defun py-current-defun ()
	3539	"Python value for `add-log-current-defun-function'.
	3540	This tells add-log.el how to find the current function/method/variable."
	3541	(save-excursion
	3542	(if (re-search-backward py-defun-start-re nil t)
	3543	(or (match-string 3)
	3544	(let ((method (match-string 2)))
	3545	(if (and (not (zerop (length (match-string 1))))
	3546	(re-search-backward py-class-start-re nil t))
	3547	(concat (match-string 1) "." method)
	3548	method)))
	3549	nil)))
	3550
	3551
	3552	(defconst py-help-address "python-mode@python.org"
	3553	"Address accepting submission of bug reports.")
	3554
	3555	(defun py-version ()
	3556	"Echo the current version of `python-mode' in the minibuffer."
	3557	(interactive)
	3558	(message "Using `python-mode' version %s" py-version)
	3559	(py-keep-region-active))
	3560
	3561	;; only works under Emacs 19
	3562	;(eval-when-compile
	3563	; (require 'reporter))
	3564
	3565	(defun py-submit-bug-report (enhancement-p)
	3566	"Submit via mail a bug report on `python-mode'.
	3567	With \\[universal-argument] (programmatically, argument ENHANCEMENT-P
	3568	non-nil) just submit an enhancement request."
	3569	(interactive
	3570	(list (not (y-or-n-p
	3571	"Is this a bug report (hit `n' to send other comments)? "))))
	3572	(let ((reporter-prompt-for-summary-p (if enhancement-p
	3573	"(Very) brief summary: "
	3574	t)))
	3575	(require 'reporter)
	3576	(reporter-submit-bug-report
	3577	py-help-address ;address
	3578	(concat "python-mode " py-version) ;pkgname
	3579	;; varlist
	3580	(if enhancement-p nil
	3581	'(py-python-command
	3582	py-indent-offset
	3583	py-block-comment-prefix
	3584	py-temp-directory
	3585	py-beep-if-tab-change))
	3586	nil ;pre-hooks
	3587	nil ;post-hooks
	3588	"Dear Barry,") ;salutation
	3589	(if enhancement-p nil
	3590	(set-mark (point))
	3591	(insert
	3592	"Please replace this text with a sufficiently large code sample\n\
	3593	and an exact recipe so that I can reproduce your problem. Failure\n\
	3594	to do so may mean a greater delay in fixing your bug.\n\n")
	3595	(exchange-point-and-mark)
	3596	(py-keep-region-active))))
	3597
	3598
	3599	(defun py-kill-emacs-hook ()
	3600	"Delete files in `py-file-queue'.
	3601	These are Python temporary files awaiting execution."
	3602	(mapcar #'(lambda (filename)
	3603	(py-safe (delete-file filename)))
	3604	py-file-queue))
	3605
	3606	;; arrange to kill temp files when Emacs exists
	3607	(add-hook 'kill-emacs-hook 'py-kill-emacs-hook)
	3608	(add-hook 'comint-output-filter-functions 'py-pdbtrack-track-stack-file)
	3609
	3610	;; Add a designator to the minor mode strings
	3611	(or (assq 'py-pdbtrack-minor-mode-string minor-mode-alist)
	3612	(push '(py-pdbtrack-is-tracking-p py-pdbtrack-minor-mode-string)
	3613	minor-mode-alist))
	3614
	3615
	3616
	3617	;;; paragraph and string filling code from Bernhard Herzog
	3618	;;; see http://mail.python.org/pipermail/python-list/2002-May/103189.html
	3619
	3620	(defun py-fill-comment (&optional justify)
	3621	"Fill the comment paragraph around point"
	3622	(let (;; Non-nil if the current line contains a comment.
	3623	has-comment
	3624
	3625	;; If has-comment, the appropriate fill-prefix for the comment.
	3626	comment-fill-prefix)
	3627
	3628	;; Figure out what kind of comment we are looking at.
	3629	(save-excursion
	3630	(beginning-of-line)
	3631	(cond
	3632	;; A line with nothing but a comment on it?
	3633	((looking-at "[ \t]#[# \t]")
	3634	(setq has-comment t
	3635	comment-fill-prefix (buffer-substring (match-beginning 0)
	3636	(match-end 0))))
	3637
	3638	;; A line with some code, followed by a comment? Remember that the hash
	3639	;; which starts the comment shouldn't be part of a string or character.
	3640	((progn
	3641	(while (not (looking-at "#\\\|$"))
	3642	(skip-chars-forward "^#\n\"'\\")
	3643	(cond
	3644	((eq (char-after (point)) ?\\) (forward-char 2))
	3645	((memq (char-after (point)) '(?\" ?')) (forward-sexp 1))))
	3646	(looking-at "#+[\t ]*"))
	3647	(setq has-comment t)
	3648	(setq comment-fill-prefix
	3649	(concat (make-string (current-column) ? )
	3650	(buffer-substring (match-beginning 0) (match-end 0)))))))
	3651
	3652	(if (not has-comment)
	3653	(fill-paragraph justify)
	3654
	3655	;; Narrow to include only the comment, and then fill the region.
	3656	(save-restriction
	3657	(narrow-to-region
	3658
	3659	;; Find the first line we should include in the region to fill.
	3660	(save-excursion
	3661	(while (and (zerop (forward-line -1))
	3662	(looking-at "^[ \t]*#")))
	3663
	3664	;; We may have gone to far. Go forward again.
	3665	(or (looking-at "^[ \t]*#")
	3666	(forward-line 1))
	3667	(point))
	3668
	3669	;; Find the beginning of the first line past the region to fill.
	3670	(save-excursion
	3671	(while (progn (forward-line 1)
	3672	(looking-at "^[ \t]*#")))
	3673	(point)))
	3674
	3675	;; Lines with only hashes on them can be paragraph boundaries.
	3676	(let ((paragraph-start (concat paragraph-start "\\\|[ \t#]*$"))
	3677	(paragraph-separate (concat paragraph-separate "\\\|[ \t#]*$"))
	3678	(fill-prefix comment-fill-prefix))
	3679	;;(message "paragraph-start %S paragraph-separate %S"
	3680	;;paragraph-start paragraph-separate)
	3681	(fill-paragraph justify))))
	3682	t))
	3683
	3684
	3685	(defun py-fill-string (start &optional justify)
	3686	"Fill the paragraph around (point) in the string starting at start"
	3687	;; basic strategy: narrow to the string and call the default
	3688	;; implementation
	3689	(let (;; the start of the string's contents
	3690	string-start
	3691	;; the end of the string's contents
	3692	string-end
	3693	;; length of the string's delimiter
	3694	delim-length
	3695	;; The string delimiter
	3696	delim
	3697	)
	3698
	3699	(save-excursion
	3700	(goto-char start)
	3701	(if (looking-at "\$'''\\\|\"\"\"\\\|'\\\|\"\$\\\\?\n?")
	3702	(setq string-start (match-end 0)
	3703	delim-length (- (match-end 1) (match-beginning 1))
	3704	delim (buffer-substring-no-properties (match-beginning 1)
	3705	(match-end 1)))
	3706	(error "The parameter start is not the beginning of a python string"))
	3707
	3708	;; if the string is the first token on a line and doesn't start with
	3709	;; a newline, fill as if the string starts at the beginning of the
	3710	;; line. this helps with one line docstrings
	3711	(save-excursion
	3712	(beginning-of-line)
	3713	(and (/= (char-before string-start) ?\n)
	3714	(looking-at (concat "[ \t]*" delim))
	3715	(setq string-start (point))))
	3716
	3717	(forward-sexp (if (= delim-length 3) 2 1))
	3718
	3719	;; with both triple quoted strings and single/double quoted strings
	3720	;; we're now directly behind the first char of the end delimiter
	3721	;; (this doesn't work correctly when the triple quoted string
	3722	;; contains the quote mark itself). The end of the string's contents
	3723	;; is one less than point
	3724	(setq string-end (1- (point))))
	3725
	3726	;; Narrow to the string's contents and fill the current paragraph
	3727	(save-restriction
	3728	(narrow-to-region string-start string-end)
	3729	(let ((ends-with-newline (= (char-before (point-max)) ?\n)))
	3730	(fill-paragraph justify)
	3731	(if (and (not ends-with-newline)
	3732	(= (char-before (point-max)) ?\n))
	3733	;; the default fill-paragraph implementation has inserted a
	3734	;; newline at the end. Remove it again.
	3735	(save-excursion
	3736	(goto-char (point-max))
	3737	(delete-char -1)))))
	3738
	3739	;; return t to indicate that we've done our work
	3740	t))
	3741
	3742	(defun py-fill-paragraph (&optional justify)
	3743	"Like \\[fill-paragraph], but handle Python comments and strings.
	3744	If any of the current line is a comment, fill the comment or the
	3745	paragraph of it that point is in, preserving the comment's indentation
	3746	and initial `#'s.
	3747	If point is inside a string, narrow to that string and fill.
	3748	"
	3749	(interactive "P")
	3750	(let* ((bod (py-point 'bod))
	3751	(pps (parse-partial-sexp bod (point))))
	3752	(cond
	3753	;; are we inside a comment or on a line with only whitespace before
	3754	;; the comment start?
	3755	((or (nth 4 pps)
	3756	(save-excursion (beginning-of-line) (looking-at "[ \t]*#")))
	3757	(py-fill-comment justify))
	3758	;; are we inside a string?
	3759	((nth 3 pps)
	3760	(py-fill-string (nth 8 pps)))
	3761	;; otherwise use the default
	3762	(t
	3763	(fill-paragraph justify)))))
	3764
	3765
	3766
	3767	(provide 'python-mode)
	3768	;;; python-mode.el ends here