(defconst py-version "$Revision$"

"`python-mode' version number.")

(require 'comint)

(require 'custom)

(require 'cl)

(require 'compile)

(defgroup python nil

"Support for the Python programming language, <http://www.python.org/>"

:group 'languages

:prefix "py-")

(defcustom py-python-command "python"

"*Shell command used to start Python interpreter."

:type 'string

:group 'python)

(defcustom py-jpython-command "jpython"

"*Shell command used to start the JPython interpreter."

:type 'string

:group 'python

:tag "JPython Command")

(defcustom py-default-interpreter 'cpython

"*Which Python interpreter is used by default.

:type '(choice (const :tag "Python (a.k.a. CPython)" cpython)

(const :tag "JPython" jpython))

:group 'python)

(defcustom py-python-command-args '("-i")

"*List of string arguments to be used when starting a Python shell."

:type '(repeat string)

:group 'python)

(defcustom py-jpython-command-args '("-i")

"*List of string arguments to be used when starting a JPython shell."

:type '(repeat string)

:group 'python

:tag "JPython Command Args")

(defcustom py-indent-offset 4

"*Amount of offset per level of indentation.

:type 'integer

:group 'python)

(defcustom py-continuation-offset 4

"*Additional amount of offset to give for some continuation lines.

:type 'integer

:group 'python)

(defcustom py-smart-indentation t

"*Should `python-mode' try to automagically set some indentation variables?

:type 'boolean

:group 'python)

(defcustom py-align-multiline-strings-p t

"*Flag describing how multi-line triple quoted strings are aligned.

:type '(choice (const :tag "Align under preceding line" t)

(const :tag "Align to column zero" nil))

:group 'python)

(defcustom py-block-comment-prefix "##"

"*String used by \\[comment-region] to comment out a block of code.

:type 'string

:group 'python)

(defcustom py-honor-comment-indentation t

"*Controls how comment lines influence subsequent indentation.

:type '(choice

(const :tag "Skip all comment lines (fast)" nil)

(const :tag "Single # `sets' indentation for next line" t)

(const :tag "Single # `sets' indentation except at column zero"

other)

)

:group 'python)

(defcustom py-temp-directory

(let ((ok '(lambda (x)

(and x

(setq x (expand-file-name x)) ; always true

(file-directory-p x)

(file-writable-p x)

x))))

(or (funcall ok (getenv "TMPDIR"))

(funcall ok "/usr/tmp")

(funcall ok "/tmp")

(funcall ok "/var/tmp")

(funcall ok ".")

(error

"Couldn't find a usable temp directory -- set `py-temp-directory'")))

"*Directory used for temporary files created by a *Python* process.

:type 'string

:group 'python)

(defcustom py-beep-if-tab-change t

"*Ring the bell if `tab-width' is changed.

:type 'boolean

:group 'python)

(defcustom py-jump-on-exception t

"*Jump to innermost exception frame in *Python Output* buffer.

:type 'boolean

:group 'python)

(defcustom py-ask-about-save t

"If not nil, ask about which buffers to save before executing some code.

:type 'boolean

:group 'python)

(defcustom py-backspace-function 'backward-delete-char-untabify

"*Function called by `py-electric-backspace' when deleting backwards."

:type 'function

:group 'python)

(defcustom py-delete-function 'delete-char

"*Function called by `py-electric-delete' when deleting forwards."

:type 'function

:group 'python)

(defcustom py-imenu-show-method-args-p nil

"*Controls echoing of arguments of functions & methods in the Imenu buffer.

:type 'boolean

:group 'python)

(make-variable-buffer-local 'py-indent-offset)

(defcustom py-pdbtrack-do-tracking-p t

"*Controls whether the pdbtrack feature is enabled or not.

:type 'boolean

:group 'python)

(make-variable-buffer-local 'py-pdbtrack-do-tracking-p)

(defcustom py-pdbtrack-minor-mode-string " PDB"

"*String to use in the minor mode list when pdbtrack is enabled."

:type 'string

:group 'python)

(defcustom py-import-check-point-max

20000

"Maximum number of characters to search for a Java-ish import statement.

:type 'integer

:group 'python

)

(defcustom py-jpython-packages

'("java" "javax" "org" "com")

"Imported packages that imply `jpython-mode'."

:type '(repeat string)

:group 'python)

(defvar py-master-file nil

"If non-nil, execute the named file instead of the buffer's file.

buffer is prepended to come up with a file name.")

(make-variable-buffer-local 'py-master-file)

(defcustom py-pychecker-command "pychecker"

"*Shell command used to run Pychecker."

:type 'string

:group 'python

:tag "Pychecker Command")

(defcustom py-pychecker-command-args '("--stdlib")

"*List of string arguments to be passed to pychecker."

:type '(repeat string)

:group 'python

:tag "Pychecker Command Args")

(defvar py-shell-alist

'(("jpython" . 'jpython)

("jython" . 'jpython)

("python" . 'cpython))

"*Alist of interpreters and python shells. Used by `py-choose-shell'

to select the appropriate python interpreter mode for a file.")

(defconst py-emacs-features

(let (features)

features)

"A list of features extant in the Emacs you are using.

support for features needed by `python-mode'.")

(defvar py-pseudo-keyword-face 'py-pseudo-keyword-face

"Face for pseudo keywords in Python mode, like self, True, False, Ellipsis.")

(make-face 'py-pseudo-keyword-face)

(defun py-font-lock-mode-hook ()

(or (face-differs-from-default-p 'py-pseudo-keyword-face)

(copy-face 'font-lock-keyword-face 'py-pseudo-keyword-face)))

(add-hook 'font-lock-mode-hook 'py-font-lock-mode-hook)

(defvar python-font-lock-keywords

(let ((kw1 (mapconcat 'identity

'("and" "assert" "break" "class"

"continue" "def" "del" "elif"

"else" "except" "exec" "for"

"from" "global" "if" "import"

"in" "is" "lambda" "not"

"or" "pass" "print" "raise"

"return" "while" "yield"

)

"\\|"))

(kw2 (mapconcat 'identity

'("else:" "except:" "finally:" "try:")

"\\|"))

)

(list

;; keywords

(cons (concat "\\b\\(" kw1 "\\)\\b[ \n\t(]") 1)

;; block introducing keywords with immediately following colons.

;; Yes "except" is in both lists.

(cons (concat "\\b\\(" kw2 "\\)[ \n\t(]") 1)

;; `as' but only in "import foo as bar"

'("[ \t]*\\(\\bfrom\\b.*\\)?\\bimport\\b.*\\b\\(as\\)\\b" . 2)

;; classes

'("\\bclass[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"

1 font-lock-type-face)

;; functions

'("\\bdef[ \t]+\\([a-zA-Z_]+[a-zA-Z0-9_]*\\)"

1 font-lock-function-name-face)

;; pseudo-keywords

'("\\b\\(self\\|None\\|True\\|False\\|Ellipsis\\)\\b"

1 py-pseudo-keyword-face)

))

"Additional expressions to highlight in Python mode.")

(put 'python-mode 'font-lock-defaults '(python-font-lock-keywords))

(defvar py-file-queue nil

"Queue of Python temp files awaiting execution.

Currently-active file is at the head of the list.")

(defvar py-pdbtrack-is-tracking-p nil)

(defvar py-pdbtrack-last-grubbed-buffer nil

"Record of the last buffer used when the source path was invalid.

prospect as debugging continues.")

(make-variable-buffer-local 'py-pdbtrack-last-grubbed-buffer)

(defvar py-pychecker-history nil)

(defconst py-stringlit-re

(concat

;; These fail if backslash-quote ends the string (not worth

;; fixing?). They precede the short versions so that the first two

;; quotes don't look like an empty short string.

;;

;; (maybe raw), long single quoted triple quoted strings (SQTQ),

;; with potential embedded single quotes

"[rR]?'''[^']*\\(\\('[^']\\|''[^']\\)[^']*\\)*'''"

"\\|"

;; (maybe raw), long double quoted triple quoted strings (DQTQ),

;; with potential embedded double quotes

"[rR]?\"\"\"[^\"]*\\(\\(\"[^\"]\\|\"\"[^\"]\\)[^\"]*\\)*\"\"\""

"\\|"

"[rR]?'\\([^'\n\\]\\|\\\\.\\)*'" ; single-quoted

"\\|" ; or

"[rR]?\"\\([^\"\n\\]\\|\\\\.\\)*\"" ; double-quoted

)

"Regular expression matching a Python string literal.")

(defconst py-continued-re

;; This is tricky because a trailing backslash does not mean

;; continuation if it's in a comment

(concat

"\\(" "[^#'\"\n\\]" "\\|" py-stringlit-re "\\)*"

"\\\\$")

"Regular expression matching Python backslash continuation lines.")

(defconst py-blank-or-comment-re "[ \t]*\\($\\|#\\)"

"Regular expression matching a blank or comment line.")

(defconst py-outdent-re

(concat "\\(" (mapconcat 'identity

'("else:"

"except\\(\\s +.*\\)?:"

"finally:"

"elif\\s +.*:")

"\\|")

"\\)")

"Regular expression matching statements to be dedented one level.")

(defconst py-block-closing-keywords-re

"\\(return\\|raise\\|break\\|continue\\|pass\\)"

"Regular expression matching keywords which typically close a block.")

(defconst py-no-outdent-re

(concat

"\\("

(mapconcat 'identity

(list "try:"

"except\\(\\s +.*\\)?:"

"while\\s +.*:"

"for\\s +.*:"

"if\\s +.*:"

"elif\\s +.*:"

(concat py-block-closing-keywords-re "[ \t\n]")

)

"\\|")

"\\)")

"Regular expression matching lines not to dedent after.")

(defconst py-defun-start-re

"^\\([ \t]*\\)def[ \t]+\\([a-zA-Z_0-9]+\\)\\|\\(^[a-zA-Z_0-9]+\\)[ \t]*="

;; If you change this, you probably have to change py-current-defun

;; as well. This is only used by py-current-defun to find the name

;; for add-log.el.

"Regular expression matching a function, method, or variable assignment.")

(defconst py-class-start-re "^class[ \t]*\\([a-zA-Z_0-9]+\\)"

;; If you change this, you probably have to change py-current-defun

;; as well. This is only used by py-current-defun to find the name

;; for add-log.el.

"Regular expression for finding a class name.")

(defconst py-traceback-line-re

"[ \t]+File \"\\([^\"]+\\)\", line \\([0-9]+\\)"

"Regular expression that describes tracebacks.")

(defconst py-pdbtrack-stack-entry-regexp

"^> \\(.*\\)(\\([0-9]+\\))\\([?a-zA-Z0-9_]+\\)()"

"Regular expression pdbtrack uses to find a stack trace entry.")

(defconst py-pdbtrack-input-prompt "\n[(<]*pdb[>)]+ "

"Regular expression pdbtrack uses to recognize a pdb prompt.")

(defconst py-pdbtrack-track-range 10000

"Max number of characters from end of buffer to search for stack entry.")

(defvar python-mode-abbrev-table nil

"Abbrev table in use in `python-mode' buffers.")

(define-abbrev-table 'python-mode-abbrev-table nil)

(defvar python-mode-hook nil

"*Hook called by `python-mode'.")

(defvar jpython-mode-hook nil

"*Hook called by `jpython-mode'. `jpython-mode' also calls

`python-mode-hook'.")

(defvar py-shell-hook nil

"*Hook called by `py-shell'.")

(and (fboundp 'make-obsolete-variable)

(make-obsolete-variable 'py-mode-hook 'python-mode-hook))

(defvar py-mode-map ()

"Keymap used in `python-mode' buffers.")

(if py-mode-map

nil

(setq py-mode-map (make-sparse-keymap))

;; electric keys

(define-key py-mode-map ":" 'py-electric-colon)

;; indentation level modifiers

(define-key py-mode-map "\C-c\C-l" 'py-shift-region-left)

(define-key py-mode-map "\C-c\C-r" 'py-shift-region-right)

(define-key py-mode-map "\C-c<" 'py-shift-region-left)

(define-key py-mode-map "\C-c>" 'py-shift-region-right)

;; paragraph and string filling

(define-key py-mode-map "\eq" 'py-fill-paragraph)

;; subprocess commands

(define-key py-mode-map "\C-c\C-c" 'py-execute-buffer)

(define-key py-mode-map "\C-c\C-m" 'py-execute-import-or-reload)

(define-key py-mode-map "\C-c\C-s" 'py-execute-string)

(define-key py-mode-map "\C-c|" 'py-execute-region)

(define-key py-mode-map "\e\C-x" 'py-execute-def-or-class)

(define-key py-mode-map "\C-c!" 'py-shell)

(define-key py-mode-map "\C-c\C-t" 'py-toggle-shells)

;; Caution! Enter here at your own risk. We are trying to support

;; several behaviors and it gets disgusting. :-( This logic ripped

;; largely from CC Mode.

;;

;; In XEmacs 19, Emacs 19, and Emacs 20, we use this to bind

;; backwards deletion behavior to DEL, which both Delete and

;; Backspace get translated to. There's no way to separate this

;; behavior in a clean way, so deal with it! Besides, it's been

;; this way since the dawn of time.

(if (not (boundp 'delete-key-deletes-forward))

(define-key py-mode-map "\177" 'py-electric-backspace)

;; However, XEmacs 20 actually achieved enlightenment. It is

;; possible to sanely define both backward and forward deletion

;; behavior under X separately (TTYs are forever beyond hope, but

;; who cares? XEmacs 20 does the right thing with these too).

(define-key py-mode-map [delete] 'py-electric-delete)

(define-key py-mode-map [backspace] 'py-electric-backspace))

;; Separate M-BS from C-M-h. The former should remain

;; backward-kill-word.

(define-key py-mode-map [(control meta h)] 'py-mark-def-or-class)

(define-key py-mode-map "\C-c\C-k" 'py-mark-block)

;; Miscellaneous

(define-key py-mode-map "\C-c:" 'py-guess-indent-offset)

(define-key py-mode-map "\C-c\t" 'py-indent-region)

(define-key py-mode-map "\C-c\C-d" 'py-pdbtrack-toggle-stack-tracking)

(define-key py-mode-map "\C-c\C-n" 'py-next-statement)

(define-key py-mode-map "\C-c\C-p" 'py-previous-statement)

(define-key py-mode-map "\C-c\C-u" 'py-goto-block-up)

(define-key py-mode-map "\C-c#" 'py-comment-region)

(define-key py-mode-map "\C-c?" 'py-describe-mode)

(define-key py-mode-map [f1] 'py-help-at-point)

(define-key py-mode-map "\C-c\C-h" 'py-help-at-point)

(define-key py-mode-map "\e\C-a" 'py-beginning-of-def-or-class)

(define-key py-mode-map "\e\C-e" 'py-end-of-def-or-class)

(define-key py-mode-map "\C-c-" 'py-up-exception)

(define-key py-mode-map "\C-c=" 'py-down-exception)

;; stuff that is `standard' but doesn't interface well with

;; python-mode, which forces us to rebind to special commands

(define-key py-mode-map "\C-xnd" 'py-narrow-to-defun)

;; information

(define-key py-mode-map "\C-c\C-b" 'py-submit-bug-report)

(define-key py-mode-map "\C-c\C-v" 'py-version)

(define-key py-mode-map "\C-c\C-w" 'py-pychecker-run)

;; shadow global bindings for newline-and-indent w/ the py- version.

;; BAW - this is extremely bad form, but I'm not going to change it

;; for now.

(mapcar #'(lambda (key)

(define-key py-mode-map key 'py-newline-and-indent))

(where-is-internal 'newline-and-indent))

;; Force RET to be py-newline-and-indent even if it didn't get

;; mapped by the above code. motivation: Emacs' default binding for

;; RET is `newline' and C-j is `newline-and-indent'. Most Pythoneers

;; expect RET to do a `py-newline-and-indent' and any Emacsers who

;; dislike this are probably knowledgeable enough to do a rebind.

;; However, we do *not* change C-j since many Emacsers have already

;; swapped RET and C-j and they don't want C-j bound to `newline' to

;; change.

(define-key py-mode-map "\C-m" 'py-newline-and-indent)

)

(defvar py-mode-output-map nil

"Keymap used in *Python Output* buffers.")

(if py-mode-output-map

nil

(setq py-mode-output-map (make-sparse-keymap))

(define-key py-mode-output-map [button2] 'py-mouseto-exception)

(define-key py-mode-output-map "\C-c\C-c" 'py-goto-exception)

;; TBD: Disable all self-inserting keys. This is bogus, we should

;; really implement this as *Python Output* buffer being read-only

(mapcar #' (lambda (key)

(define-key py-mode-output-map key

#'(lambda () (interactive) (beep))))

(where-is-internal 'self-insert-command))

)

(defvar py-shell-map nil

"Keymap used in *Python* shell buffers.")

(if py-shell-map

nil

(setq py-shell-map (copy-keymap comint-mode-map))

(define-key py-shell-map [tab] 'tab-to-tab-stop)

(define-key py-shell-map "\C-c-" 'py-up-exception)

(define-key py-shell-map "\C-c=" 'py-down-exception)

)

(defvar py-mode-syntax-table nil

"Syntax table used in `python-mode' buffers.")

(when (not py-mode-syntax-table)

(setq py-mode-syntax-table (make-syntax-table))

(modify-syntax-entry ?\( "()" py-mode-syntax-table)

(modify-syntax-entry ?\) ")(" py-mode-syntax-table)

(modify-syntax-entry ?\[ "(]" py-mode-syntax-table)

(modify-syntax-entry ?\] ")[" py-mode-syntax-table)

(modify-syntax-entry ?\{ "(}" py-mode-syntax-table)

(modify-syntax-entry ?\} "){" py-mode-syntax-table)

;; Add operator symbols misassigned in the std table

(modify-syntax-entry ?\$ "." py-mode-syntax-table)

(modify-syntax-entry ?\% "." py-mode-syntax-table)

(modify-syntax-entry ?\& "." py-mode-syntax-table)

(modify-syntax-entry ?\* "." py-mode-syntax-table)

(modify-syntax-entry ?\+ "." py-mode-syntax-table)

(modify-syntax-entry ?\- "." py-mode-syntax-table)

(modify-syntax-entry ?\/ "." py-mode-syntax-table)

(modify-syntax-entry ?\< "." py-mode-syntax-table)

(modify-syntax-entry ?\= "." py-mode-syntax-table)

(modify-syntax-entry ?\> "." py-mode-syntax-table)

(modify-syntax-entry ?\| "." py-mode-syntax-table)

;; For historical reasons, underscore is word class instead of

;; symbol class. GNU conventions say it should be symbol class, but

;; there's a natural conflict between what major mode authors want

;; and what users expect from `forward-word' and `backward-word'.

;; Guido and I have hashed this out and have decided to keep

;; underscore in word class. If you're tempted to change it, try

;; binding M-f and M-b to py-forward-into-nomenclature and

;; py-backward-into-nomenclature instead. This doesn't help in all

;; situations where you'd want the different behavior

;; (e.g. backward-kill-word).

(modify-syntax-entry ?\_ "w" py-mode-syntax-table)

;; Both single quote and double quote are string delimiters

(modify-syntax-entry ?\' "\"" py-mode-syntax-table)

(modify-syntax-entry ?\" "\"" py-mode-syntax-table)

;; backquote is open and close paren

(modify-syntax-entry ?\` "$" py-mode-syntax-table)

;; comment delimiters

(modify-syntax-entry ?\# "<" py-mode-syntax-table)

(modify-syntax-entry ?\n ">" py-mode-syntax-table)

)

(defvar py-dotted-expression-syntax-table nil

"Syntax table used to identify Python dotted expressions.")

(when (not py-dotted-expression-syntax-table)

(setq py-dotted-expression-syntax-table

(copy-syntax-table py-mode-syntax-table))

(modify-syntax-entry ?_ "_" py-dotted-expression-syntax-table)

(modify-syntax-entry ?. "_" py-dotted-expression-syntax-table))

(defmacro py-safe (&rest body)

"Safely execute BODY, return nil if an error occurred."

(` (condition-case nil

(progn (,@ body))

(error nil))))

(defsubst py-keep-region-active ()

"Keep the region active in XEmacs."

;; Ignore byte-compiler warnings you might see. Also note that

;; FSF's Emacs 19 does it differently; its policy doesn't require us

;; to take explicit action.

(and (boundp 'zmacs-region-stays)

(setq zmacs-region-stays t)))

(defsubst py-point (position)

"Returns the value of point at certain commonly referenced POSITIONs.

(let ((here (point)))

(cond

((eq position 'bol) (beginning-of-line))

((eq position 'eol) (end-of-line))

((eq position 'bod) (py-beginning-of-def-or-class))

((eq position 'eod) (py-end-of-def-or-class))

;; Kind of funny, I know, but useful for py-up-exception.

((eq position 'bob) (beginning-of-buffer))

((eq position 'eob) (end-of-buffer))

((eq position 'boi) (back-to-indentation))

((eq position 'bos) (py-goto-initial-line))

(t (error "Unknown buffer position requested: %s" position))

)

(prog1

(point)

(goto-char here))))

(defsubst py-highlight-line (from to file line)

(cond

((fboundp 'make-extent)

;; XEmacs

(let ((e (make-extent from to)))

(set-extent-property e 'mouse-face 'highlight)

(set-extent-property e 'py-exc-info (cons file line))

(set-extent-property e 'keymap py-mode-output-map)))

(t

;; Emacs -- Please port this!

)

))

(defun py-in-literal (&optional lim)

"Return non-nil if point is in a Python literal (a comment or string).

;; This is the version used for non-XEmacs, which has a nicer

;; interface.

;;

;; WARNING: Watch out for infinite recursion.

(let* ((lim (or lim (py-point 'bod)))

(state (parse-partial-sexp lim (point))))

(cond

((nth 3 state) 'string)

((nth 4 state) 'comment)

(t nil))))

(defun py-fast-in-literal (&optional lim)

"Fast version of `py-in-literal', used only by XEmacs.

;; don't have to worry about context == 'block-comment

(buffer-syntactic-context))

(if (fboundp 'buffer-syntactic-context)

(defalias 'py-in-literal 'py-fast-in-literal))

(defvar py-menu nil

"Menu for Python Mode.

package. Note that the latest X/Emacs releases contain this package.")

(and (py-safe (require 'easymenu) t)

(easy-menu-define

py-menu py-mode-map "Python Mode menu"

'("Python"

["Comment Out Region" py-comment-region (mark)]

["Uncomment Region" (py-comment-region (point) (mark) '(4)) (mark)]

"-"

["Mark current block" py-mark-block t]

["Mark current def" py-mark-def-or-class t]

["Mark current class" (py-mark-def-or-class t) t]

"-"

["Shift region left" py-shift-region-left (mark)]

["Shift region right" py-shift-region-right (mark)]

"-"

["Import/reload file" py-execute-import-or-reload t]

["Execute buffer" py-execute-buffer t]

["Execute region" py-execute-region (mark)]

["Execute def or class" py-execute-def-or-class (mark)]

["Execute string" py-execute-string t]

["Start interpreter..." py-shell t]

"-"

["Go to start of block" py-goto-block-up t]

["Go to start of class" (py-beginning-of-def-or-class t) t]

["Move to end of class" (py-end-of-def-or-class t) t]

["Move to start of def" py-beginning-of-def-or-class t]

["Move to end of def" py-end-of-def-or-class t]

"-"

["Describe mode" py-describe-mode t]

)))

(defvar py-imenu-class-regexp

(concat ; <<classes>>

"\\(" ;

"^[ \t]*" ; newline and maybe whitespace

"\\(class[ \t]+[a-zA-Z0-9_]+\\)" ; class name

; possibly multiple superclasses

"\\([ \t]*\\((\\([a-zA-Z0-9_,. \t\n]\\)*)\\)?\\)"

"[ \t]*:" ; and the final :

"\\)" ; >>classes<<

)

"Regexp for Python classes for use with the Imenu package."

)

(defvar py-imenu-method-regexp

(concat ; <<methods and functions>>

"\\(" ;

"^[ \t]*" ; new line and maybe whitespace

"\\(def[ \t]+" ; function definitions start with def

"\\([a-zA-Z0-9_]+\\)" ; name is here

; function arguments...

"[ \t]*(\\([^:#]*\\))"

"\\)" ; end of def

"[ \t]*:" ; and then the :

"\\)" ; >>methods and functions<<

)

"Regexp for Python methods/functions for use with the Imenu package."

)

(defvar py-imenu-method-no-arg-parens '(2 8)

"Indices into groups of the Python regexp for use with Imenu.

information.")

(defvar py-imenu-method-arg-parens '(2 7)

"Indices into groups of the Python regexp for use with imenu.

information.")

(defvar py-imenu-generic-expression

(cons

(concat

py-imenu-class-regexp

"\\|" ; or...

py-imenu-method-regexp

)

py-imenu-method-no-arg-parens)

"Generic Python expression which may be used directly with Imenu.

alternative for finding the index.")

(defvar py-imenu-generic-regexp nil)

(defvar py-imenu-generic-parens nil)

(defun py-imenu-create-index-function ()

"Python interface function for the Imenu package.

(setq py-imenu-generic-regexp (car py-imenu-generic-expression)

py-imenu-generic-parens (if py-imenu-show-method-args-p

py-imenu-method-arg-parens

py-imenu-method-no-arg-parens))

(goto-char (point-min))

;; Warning: When the buffer has no classes or functions, this will

;; return nil, which seems proper according to the Imenu API, but

;; causes an error in the XEmacs port of Imenu. Sigh.

(py-imenu-create-index-engine nil))

(defun py-imenu-create-index-engine (&optional start-indent)

"Function for finding Imenu definitions in Python.

(let (index-alist

sub-method-alist

looking-p

def-name prev-name

cur-indent def-pos

(class-paren (first py-imenu-generic-parens))

(def-paren (second py-imenu-generic-parens)))

(setq looking-p

(re-search-forward py-imenu-generic-regexp (point-max) t))

(while looking-p

(save-excursion

;; used to set def-name to this value but generic-extract-name

;; is new to imenu-1.14. this way it still works with

;; imenu-1.11

;;(imenu--generic-extract-name py-imenu-generic-parens))

(let ((cur-paren (if (match-beginning class-paren)

class-paren def-paren)))

(setq def-name

(buffer-substring-no-properties (match-beginning cur-paren)

(match-end cur-paren))))

(save-match-data

(py-beginning-of-def-or-class 'either))

(beginning-of-line)

(setq cur-indent (current-indentation)))

;; HACK: want to go to the next correct definition location. We

;; explicitly list them here but it would be better to have them

;; in a list.

(setq def-pos

(or (match-beginning class-paren)

(match-beginning def-paren)))

;; if we don't have a starting indent level, take this one

(or start-indent

(setq start-indent cur-indent))

;; if we don't have class name yet, take this one

(or prev-name

(setq prev-name def-name))

;; what level is the next definition on? must be same, deeper

;; or shallower indentation

(cond

;; Skip code in comments and strings

((py-in-literal))

;; at the same indent level, add it to the list...

((= start-indent cur-indent)

(push (cons def-name def-pos) index-alist))

;; deeper indented expression, recurse

((< start-indent cur-indent)

;; the point is currently on the expression we're supposed to

;; start on, so go back to the last expression. The recursive

;; call will find this place again and add it to the correct

;; list

(re-search-backward py-imenu-generic-regexp (point-min) 'move)

(setq sub-method-alist (py-imenu-create-index-engine cur-indent))

(if sub-method-alist

;; we put the last element on the index-alist on the start

;; of the submethod alist so the user can still get to it.

(let ((save-elmt (pop index-alist)))

(push (cons prev-name

(cons save-elmt sub-method-alist))

index-alist))))

;; found less indented expression, we're done.

(t

(setq looking-p nil)

(re-search-backward py-imenu-generic-regexp (point-min) t)))

;; end-cond

(setq prev-name def-name)

(and looking-p

(setq looking-p

(re-search-forward py-imenu-generic-regexp

(point-max) 'move))))

(nreverse index-alist)))

(defun py-choose-shell-by-shebang ()

"Choose CPython or JPython mode by looking at #! on the first line.

;; look for an interpreter specified in the first line

;; similar to set-auto-mode (files.el)

(let* ((re (if (boundp 'auto-mode-interpreter-regexp)