Gecko [ 122.154.134.11 ]

Name	Size	Permission
ada-mode.elc	107.46 KB	-rw-r--r--
ada-prj.elc	17.96 KB	-rw-r--r--
ada-stmt.elc	36.03 KB	-rw-r--r--
ada-xref.elc	54.99 KB	-rw-r--r--
antlr-mode.elc	77.63 KB	-rw-r--r--
asm-mode.elc	6.08 KB	-rw-r--r--
autoconf.elc	3.37 KB	-rw-r--r--
bug-reference.elc	5.83 KB	-rw-r--r--
cap-words.elc	3.54 KB	-rw-r--r--
cc-align.elc	35.43 KB	-rw-r--r--
cc-awk.elc	20.23 KB	-rw-r--r--
cc-bytecomp.elc	10.45 KB	-rw-r--r--
cc-cmds.elc	92.26 KB	-rw-r--r--
cc-compat.elc	2.97 KB	-rw-r--r--
cc-defs.elc	46.7 KB	-rw-r--r--
cc-engine.elc	143.05 KB	-rw-r--r--
cc-fonts.elc	140.72 KB	-rw-r--r--
cc-langs.elc	70.29 KB	-rw-r--r--
cc-menus.elc	7.32 KB	-rw-r--r--
cc-mode.elc	144.75 KB	-rw-r--r--
cc-styles.elc	16.11 KB	-rw-r--r--
cc-subword.elc	6.99 KB	-rw-r--r--
cc-vars.elc	71.07 KB	-rw-r--r--
cfengine.elc	8.09 KB	-rw-r--r--
cmacexp.elc	6.58 KB	-rw-r--r--
compile.elc	69.45 KB	-rw-r--r--
cperl-mode.elc	215.39 KB	-rw-r--r--
cpp.elc	21.52 KB	-rw-r--r--
cwarn.elc	12.8 KB	-rw-r--r--
dcl-mode.elc	49.31 KB	-rw-r--r--
delphi.elc	50.03 KB	-rw-r--r--
ebnf-abn.elc	7.39 KB	-rw-r--r--
ebnf-bnf.elc	7.99 KB	-rw-r--r--
ebnf-dtd.elc	13.82 KB	-rw-r--r--
ebnf-ebx.elc	8.77 KB	-rw-r--r--
ebnf-iso.elc	8.14 KB	-rw-r--r--
ebnf-otz.elc	8.51 KB	-rw-r--r--
ebnf-yac.elc	7.53 KB	-rw-r--r--
ebnf2ps.elc	121.25 KB	-rw-r--r--
ebrowse.elc	202.93 KB	-rw-r--r--
etags.elc	54.14 KB	-rw-r--r--
executable.elc	7.6 KB	-rw-r--r--
f90.elc	82.59 KB	-rw-r--r--
flymake.elc	61.25 KB	-rw-r--r--
fortran.elc	60.13 KB	-rw-r--r--
gdb-ui.elc	138.61 KB	-rw-r--r--
glasses.elc	10.15 KB	-rw-r--r--
grep.elc	27.75 KB	-rw-r--r--
gud.elc	93.94 KB	-rw-r--r--
hideif.elc	26.67 KB	-rw-r--r--
hideshow.elc	24.54 KB	-rw-r--r--
icon.elc	16.23 KB	-rw-r--r--
idlw-complete-structtag.elc	4.75 KB	-rw-r--r--
idlw-help.elc	35.31 KB	-rw-r--r--
idlw-shell.elc	134.39 KB	-rw-r--r--
idlw-toolbar.elc	28.34 KB	-rw-r--r--
idlwave.elc	254.7 KB	-rw-r--r--
inf-lisp.elc	18.43 KB	-rw-r--r--
ld-script.elc	4.91 KB	-rw-r--r--
m4-mode.elc	4.91 KB	-rw-r--r--
make-mode.elc	58.79 KB	-rw-r--r--
mantemp.elc	3.77 KB	-rw-r--r--
meta-mode.elc	27.42 KB	-rw-r--r--
mixal-mode.elc	35.32 KB	-rw-r--r--
modula2.elc	14.23 KB	-rw-r--r--
octave-inf.elc	11.87 KB	-rw-r--r--
octave-mod.elc	44.6 KB	-rw-r--r--
pascal.elc	40.31 KB	-rw-r--r--
perl-mode.elc	22.42 KB	-rw-r--r--
prolog.elc	12.7 KB	-rw-r--r--
ps-mode.elc	33.38 KB	-rw-r--r--
python.elc	86.23 KB	-rw-r--r--
ruby-mode.elc	34.59 KB	-rw-r--r--
scheme.elc	15.94 KB	-rw-r--r--
sh-script.elc	94.73 KB	-rw-r--r--
simula.elc	44.81 KB	-rw-r--r--
sql.elc	101.34 KB	-rw-r--r--
sym-comp.elc	7.15 KB	-rw-r--r--
tcl.elc	38.58 KB	-rw-r--r--
vera-mode.elc	44.5 KB	-rw-r--r--
verilog-mode.elc	331.76 KB	-rw-r--r--
vhdl-mode.elc	510.47 KB	-rw-r--r--
which-func.elc	9.72 KB	-rw-r--r--
xscheme.elc	37.76 KB	-rw-r--r--

Code Editor : python.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:05:11 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/progmodes/python.el
;;; in Emacs version 23.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`python.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(byte-code "\301\302!\210\301\303!\210\304\305\306\"\210\307\310\311\312\313\314\315\316\317\320&	\210\321\322\323\"\210\321\322\324\"\210\321\325\326\"\210\321\327\330\"\210\331B\332\331!\204W�\333\331\334\335\336B\337\340B\341\342B\343\344B\345\346B\347\350B\351\352B\353\354B\257	\"\210\355B\356\357\360\361DD\362\363BD!\207" [current-load-list require comint sym-comp autoload comint-mode "comint" custom-declare-group python nil "Silly walks in the Python language." :group languages :version "22.1" :link (emacs-commentary-link "python") add-to-list interpreter-mode-alist ("jython" . jython-mode) ("python" . python-mode) auto-mode-alist ("\\.py\\'" . python-mode) same-window-buffer-names "*Python*" python-font-lock-keywords default-boundp set-default "\\_<\$?:\\(?:False\\|True\\|a\\(?:nd\\|s\\(?:sert\$?\\)\\|break\\|continue\\|del\\|e\$?:l\\(?:if\\|se\$\\|x\$?:cept\\|ec\$\\)\\|f\$?:inally\\|or\\|rom\$\\|global\\|i\$?:mport\\|[fns]\$\\|lambda\\|not\\|or\\|p\$?:ass\\|rint\$\\|r\$?:aise\\|eturn\$\\|self\\|try\\|w\$?:hile\\|ith\$\\|yield\\)\\)\\_>" "\\_<None\\_>" font-lock-constant-face "\\_<\$class\$[[:space:]]+\$\\(?:[[:word:]]\\|_\$+\\)" ((1 font-lock-keyword-face) (2 font-lock-type-face)) "\\_<\$def\$[[:space:]]+\$\\(?:[[:word:]]\\|_\$+\\)" ((1 font-lock-keyword-face) (2 font-lock-function-name-face)) "^\$\\(?:[[:word:]]\\|_\$+\\)[[:space:]]*=" ((1 font-lock-variable-name-face)) "^[	 ]*\$@\\(?:[[:word:]]\\|_\$+\\)" ((1 font-lock-type-face)) "\\_<\$?:\\(?:A\\(?:\\(?:rithmetic\\|ssertion\\|ttribute\$Error\\)\\|BaseException\\|DeprecationWarning\\|E\$?:OFError\\|nvironmentError\\|xception\$\\|F\$?:loatingPointError\\|utureWarning\$\\|GeneratorExit\\|I\$?:OError\\|mport\\(?:Error\\|Warning\$\\|nde\$?:\\(?:ntation\\|x\$Error\\)\\)\\|Key\$?:Error\\|boardInterrupt\$\\|LookupError\\|MemoryError\\|N\$?:ameError\\|otImplemented\\(?:Error\$?\\)\\|O\$?:\\(?:S\\|verflow\$Error\\)\\|PendingDeprecationWarning\\|R\$?:eferenceError\\|untime\\(?:Error\\|Warning\$\\)\\|S\$?:t\\(?:andardError\\|opIteration\$\\|y\$?:ntax\\(?:Error\\|Warning\$\\|stemE\$?:rror\\|xit\$\\)\\)\\|T\$?:\\(?:ab\\|ype\$Error\\)\\|U\$?:n\\(?:boundLocalError\\|icode\\(?:DecodeError\\|E\\(?:\\(?:ncodeE\$?rror\\)\\|TranslateError\\|Warning\\)\\)\\|serWarning\\)\\|ValueError\\|Warning\\|ZeroDivisionError\\)\\)\\_>" font-lock-type-face "\$?:^\\|[^	 .]\$[	 ]*\\_<\$\\(?:a\\(?:bs\\|ll\\|\\(?:n\\|ppl\$y\\)\\|b\$?:asestring\\|ool\\|uffer\$\\|c\$?:allable\\|hr\\|lassmethod\\|mp\\|o\\(?:erce\\|mp\\(?:ile\\|lex\$\\|pyright\\)\\|redits\\)\\|d\$?:elattr\\|i\\(?:ct\\|r\\|vmod\$\\)\\|e\$?:numerate\\|val\\|x\\(?:ecfile\\|it\$\\)\\|f\$?:il\\(?:e\\|ter\$\\|\$?:loa\\|rozense\$t\\)\\|g\$?:etattr\\|lobals\$\\|h\$?:as\\(?:attr\\|h\$\\|e\$?:lp\\|x\$\\)\\|i\$?:d\\|n\\(?:put\\|t\\(?:ern\$?\\)\\|s\$?:instance\\|subclass\$\\|ter\\)\\|l\$?:en\\|i\\(?:cense\\|st\$\\|o\$?:cals\\|ng\$\\)\\|m\$?:a[px]\\|in\$\\|o\$?:bject\\|ct\\|pen\\|rd\$\\|p\$?:ow\\|roperty\$\\|quit\\|r\$?:a\\(?:nge\\|w_input\$\\|e\$?:duce\\|load\\|pr\\|versed\$\\|ound\\)\\|s\$?:et\\(?:attr\$?\\|lice\\|orted\\|t\$?:aticmethod\\|r\$\\|u\$?:m\\|per\$\\)\\|t\$?:\\(?:upl\\|yp\$e\\)\\|unic\$?:hr\\|ode\$\\|vars\\|xrange\\|zip\\)\\)\\_>" ((1 font-lock-builtin-face)) "\\_<\$?:\\(?:Ellipsis\\|False\\|None\\|True\\|_\\(?:_\\(?:\\(?:d\\(?:ebug\\|oc\$\\|import\\|name\\)__\\)\\)?\\)\\)\\_>" font-lock-builtin-face python-font-lock-syntactic-keywords (lambda (#1=#:defconst-tmp-var) (defconst python-font-lock-syntactic-keywords #1#)) "[^\\]\\\\\$?:\\\\\\\\\$*\$\\s\"\$\\1\$\\1\$" 2 (7) "\$[RUru]?\$[Rr]?\$\\s\"\$\\2\$\\2\$" ((1 (python-quote-syntax 1)) (2 (python-quote-syntax 2)) (3 (python-quote-syntax 3)))] 12)
#@121 Put `syntax-table' property correctly on triple quote.
Used for syntactic keywords.  N is the match number (1, 2 or 3).
(defalias 'python-quote-syntax #[(n) "\212\304\224b\210\305U\203/�\306\307 \305\n8\310=\205+�\311\n8b\210\312\306w\210\306f\313\224f=\205+�\314*\202o�\313U\203=�\315\224\315\225U\204L�\315U\205o�\315\224\315\225U?\205o�\306\307 \3058\203[�\316\202f�\3178\203e�\320\202f�\306)\316=?\205n�\314))\207" [n font-lock-syntactic-keywords syntax ppss 0 3 nil syntax-ppss t 8 "uUrR" 2 (15) 1 string 4 comment] 2 (#$ . 4388)])
(byte-code "\303B\304\303!\204\272�\305\303\306 \307	\310\311#\210\307	\312\313#\210\307	\314\315#\210\307	\316\317#\210\307	\320\321#\210\307	\322\323#\210\307	\324\325#\210\307	\326\327#\210\307	\330\331#\210\307	\332\333#\210\307	\334\335#\210\307	\336\335#\210\307	\337\340#\210\307	\341\342#\210\307	\343\344#\210\307	\345\346#\210\307	\347\350#\210\307	\351\352#\210\307	\353\354#\210\307	\355\354#\210\356\357\360	\n$\210\307	\361\362#\210\307	\363\364#\210\365B\366\365\367\370#\210\304\365!\204\257�\305\365\371\"\210\372\365	\370\373$\210	)\"\210\371\207" [current-load-list map global-map python-mode-map default-boundp set-default make-sparse-keymap define-key ":" python-electric-colon "" python-backspace "<" python-shift-left ">" python-shift-right "" python-mark-block "" python-pdbtrack-toggle-stack-tracking "" python-next-statement "" python-previous-statement "" python-beginning-of-block "" python-describe-symbol "" python-check "" "" python-send-string [134217752] python-send-defun "" python-send-region "\362" python-send-region-and-go "" python-send-buffer "" python-switch-to-python "
" python-load-file "\f" substitute-key-definition complete-symbol symbol-complete "	" python-find-imports "" python-expand-template python-menu put variable-documentation "Python Mode menu" nil easy-menu-do-define ("Python" :help "Python-specific Features" ["Shift region left" python-shift-left :active mark-active :help "Shift by a single indentation step"] ["Shift region right" python-shift-right :active mark-active :help "Shift by a single indentation step"] "-" ["Mark block" python-mark-block :help "Mark innermost block around point"] ["Mark def/class" mark-defun :help "Mark innermost definition around point"] "-" ["Start of block" python-beginning-of-block :help "Go to start of innermost definition around point"] ["End of block" python-end-of-block :help "Go to end of innermost definition around point"] ["Start of def/class" beginning-of-defun :help "Go to start of innermost definition around point"] ["End of def/class" end-of-defun :help "Go to end of innermost definition around point"] "-" ("Templates..." :help "Expand templates for compound statements" :filter (lambda (&rest junk) (abbrev-table-menu python-mode-abbrev-table))) "-" ["Start interpreter" python-shell :help "Run `inferior' Python in separate buffer"] ["Import/reload file" python-load-file :help "Load into inferior Python session"] ["Eval buffer" python-send-buffer :help "Evaluate buffer en bloc in inferior Python session"] ["Eval region" python-send-region :active mark-active :help "Evaluate region en bloc in inferior Python session"] ["Eval def/class" python-send-defun :help "Evaluate current definition in inferior Python session"] ["Switch to interpreter" python-switch-to-python :help "Switch to inferior Python buffer"] ["Set default process" python-set-proc :help "Make buffer's inferior process the default" :active (buffer-live-p python-buffer)] ["Check file" python-check :help "Run pychecker"] ["Debugger" pdb :help "Run pdb under GUD"] "-" ["Help on symbol" python-describe-symbol :help "Use pydoc on symbol at point"] ["Complete symbol" symbol-complete :help "Complete (qualified) symbol before point"] ["Find function" python-find-function :help "Try to find source definition of function at point"] ["Update imports" python-find-imports :help "Update list of top-level imports for completion"])] 7)
#@40 Keymap used in *Python* shell buffers.
(defvar python-shell-map (byte-code "\302!\303	\304\305#\210\303	\306\307#\210\303	\310\311#\210	)\207" [comint-mode-map map copy-keymap define-key [tab] tab-to-tab-stop "-" py-up-exception "=" py-down-exception] 4) (#$ . 8399))
(byte-code "\306B\307\306!\204b�\310\306\311 \312\313 \314\315\f
W\2039�\f\316U\2042�\n\fH\232\2032�\317\f\320	#\210\fT\211\202�,\317\321\320	#\210\317\322\320	#\210\317\323\324	#\210\317\325\326	#\210\317\327\330	#\210\317\331\332	#\210	)\"\210\306\207" [current-load-list table sst symbol i --dotimes-limit-- python-mode-syntax-table default-boundp set-default make-syntax-table (3) standard-syntax-table 128 0 95 modify-syntax-entry "." 36 37 35 "<" 10 ">" 39 "\"" 96 "$"] 7)
#@71 Return non-nil if point is in a Python literal (a comment or string).
(defalias 'python-in-string/comment #[nil "\300\301 8\207" [8 syntax-ppss] 2 (#$ . 9166)])
(put 'python-in-string/comment 'byte-optimizer 'byte-compile-inline-expand)
#@68 `python-mode-syntax-table' with backslash given whitespace syntax.
(defconst python-space-backslash-table (byte-code "\302!\303\304\305	#\210	)\207" [python-mode-syntax-table table copy-syntax-table modify-syntax-entry 92 " "] 4) (#$ . 9409))
#@240 Skip comments and blank lines.
BACKWARD non-nil means go backwards, otherwise go forwards.
Backslash is treated as whitespace so that continued blank lines
are skipped.  Doesn't move out of comments -- should be outside
or at end of line.
(defalias 'python-skip-comments/blanks #[(&optional backward) "\203�\306 \307	8\203�\310	8b\210d[)\202�d\311 p\312\216\313
!\210\314\n!,\207" [backward syntax arg #1=#:buffer #2=#:table python-space-backslash-table syntax-ppss 4 8 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table forward-comment] 2 (#$ . 9661)])
#@73 Non-nil if preceding line ends with backslash that is not in a comment.
(defalias 'python-backslash-continuation-line-p #[nil "\301\302!Sf\303=\205$�\304 \3058\203�\306\202\"�\3078\203!�\310\202\"�\311)?\207" [ppss line-end-position 0 92 syntax-ppss 3 string 4 comment nil] 2 (#$ . 10280)])
#@189 Return non-nil if current line continues a previous one.
The criteria are that the previous line ends in a backslash outside
comments and strings, or that point is within brackets/parens.
(defalias 'python-continuation-line-p #[nil "\302 \206#�\212\303\304 !)\211@)\211\305V\206\"�	\305W\205\"�\212\306\307\310\217))\207" [ppss depth python-backslash-continuation-line-p syntax-ppss line-beginning-position 0 nil (byte-code "\300 \210\301\207" [backward-up-list t] 1) ((error))] 4 (#$ . 10582)])
#@64 Return non-nil if and only if current line has only a comment.
(defalias 'python-comment-line-p #[nil "\212\301\210\302 \3038\203�\304\202�\3058\203�\306\202�\301)\306=\205(�\307 \210\310\311!)\207" [ppss nil syntax-ppss 3 string 4 comment back-to-indentation looking-at "\\s<\\|$"] 2 (#$ . 11086)])
#@54 Return non-nil if and only if current line is blank.
(defalias 'python-blank-line-p #[nil "\212\300 \210\301\302!)\207" [beginning-of-line looking-at "\\s-*$"] 2 (#$ . 11400)])
#@70 Go to beginning of string around point.
Do nothing if not in string.
(defalias 'python-beginning-of-string #[nil "\302 \211\303	8\203�\304\202�\305	8\203�\306\202�\307)\304=\205$�\3108b)\207" [state ppss syntax-ppss 3 string 4 comment nil 8] 3 (#$ . 11583)])
#@119 Return non-nil if statement at point opens a block.
BOS non-nil means point is known to be at beginning of statement.
(defalias 'python-open-block-statement-p #[(&optional bos) "\212\204�\301 \210\302\303!)\207" [bos python-beginning-of-statement looking-at "\$?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\$\\|xcept\\)\\|f\$?:inally\\|or\$\\|if\\|try\\|w\$?:hile\\|ith\$\\)\\)\\_>"] 2 (#$ . 11856)])
#@243 Return non-nil if current line is a statement closing a block.
BOS non-nil means point is at beginning of statement.
The criteria are that the line isn't a comment or in string and
 starts with keyword `raise', `break', `continue' or `pass'.
(defalias 'python-close-block-statement-p #[(&optional bos) "\212\204�\301 \210\302 \210\303\304!)\207" [bos python-beginning-of-statement back-to-indentation looking-at "\$?:\\(?:break\\|continue\\|pass\\|r\\(?:aise\\|eturn\$\\)\\)\\_>"] 2 (#$ . 12267)])
#@56 Return non-nil if current line should outdent a level.
(defalias 'python-outdent-p #[nil "\212\300 \210\301\302!\205#�\303\304 8?\205#�\305\306 !\205#�\307\310!?\205#�\311 ?)\207" [back-to-indentation looking-at "\$?:\\(?:e\\(?:l\\(?:if\\|se\$\\|xcept\\)\\|finally\\)\\)\\_>" 8 syntax-ppss zerop python-previous-statement python-close-block-statement-p t python-open-block-statement-p] 2 (#$ . 12775)])
#@95 Number of columns for a unit of indentation in Python mode.
See also `\[python-guess-indent]'
(custom-declare-variable 'python-indent '4 '(#$ . 13186) :group 'python :type 'integer)
(put 'python-indent 'safe-local-variable 'integerp)
#@67 Non-nil means Python mode guesses `python-indent' for the buffer.
(custom-declare-variable 'python-guess-indent 't '(#$ . 13426) :type 'boolean :group 'python)
#@276 Non-nil means indent contents of multi-line strings together.
This means indent them the same as the preceding non-blank line.
Otherwise preserve their indentation.

This only applies to `doc' strings, i.e. those that form statements;
the indentation is preserved in others.
(custom-declare-variable 'python-indent-string-contents 't '(#$ . 13593) :type '(choice (const :tag "Align with preceding" t) (const :tag "Preserve indentation" nil)) :group 'python)
#@240 Non-nil means indent relative to preceding comment line.
Only do this for comments where the leading comment character is
followed by space.  This doesn't apply to comment lines, which
are always indented in lines with preceding comments.
(custom-declare-variable 'python-honour-comment-indentation 'nil '(#$ . 14058) :type 'boolean :group 'python)
#@145 Number of columns of additional indentation for continuation lines.
Continuation lines follow a backslash-terminated line starting a
statement.
(custom-declare-variable 'python-continuation-offset '4 '(#$ . 14414) :group 'python :type 'integer)
#@641 *Which Python interpreter is used by default.
The value for this variable can be either `cpython' or `jpython'.

When the value is `cpython', the variables `python-python-command' and
`python-python-command-args' are consulted to determine the interpreter
and arguments to use.

When the value is `jpython', the variables `python-jpython-command' and
`python-jpython-command-args' are consulted to determine the interpreter
and arguments to use.

Note that this variable is consulted only the first time that a Python
mode buffer is visited during an Emacs session.  After that, use
\[python-toggle-shells] to change the interpreter shell.
(custom-declare-variable 'python-default-interpreter ''cpython '(#$ . -14666) :type '(choice (const :tag "Python (a.k.a. CPython)" cpython) (const :tag "JPython" jpython)) :group 'python)
#@68 *List of string arguments to be used when starting a Python shell.
(custom-declare-variable 'python-python-command-args ''("-i") '(#$ . -15500) :type '(repeat string) :group 'python)
#@68 *List of string arguments to be used when starting a Jython shell.
(custom-declare-variable 'python-jython-command-args ''("-i") '(#$ . -15689) :type '(repeat string) :group 'python :tag "JPython Command Args")
(byte-code "\302B\303\302!\204�\304\302\305\"\210\306B\303\306!\204�\304\306	\"\210\307B\303\307!\204-�\304\307\310\"\210\311\302!\210\311\306!\210\311\307!\207" [current-load-list python-python-command-args python-which-shell default-boundp set-default nil python-which-args python-which-bufname "Python" make-variable-buffer-local] 3)
#@458 *Controls whether the pdbtrack feature is enabled or not.

When non-nil, pdbtrack is enabled in all comint-based buffers,
e.g. shell interaction buffers and the *Python* buffer.

When using pdb to debug a Python program, pdbtrack notices the
pdb prompt and presents the line in the source file where the
program is stopped in a pop-up buffer.  It's similar to what
gud-mode does for debugging C programs with gdb, but without
having to restart the program.
(custom-declare-variable 'python-pdbtrack-do-tracking-p 't '(#$ . -16252) :type 'boolean :group 'python)
(make-variable-buffer-local 'python-pdbtrack-do-tracking-p)
#@59 *Minor-mode sign to be displayed when pdbtrack is active.
(custom-declare-variable 'python-pdbtrack-minor-mode-string '" PDB" '(#$ . -16880) :type 'string :group 'python)
(byte-code "\301\236\204\n�\302B\301\207" [minor-mode-alist python-pdbtrack-is-tracking-p (python-pdbtrack-is-tracking-p python-pdbtrack-minor-mode-string)] 2)
#@98 Queue of Python temp files awaiting execution.
Currently-active file is at the head of the list.
(defvar python-file-queue nil (#$ . 17220))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list python-pdbtrack-is-tracking-p default-boundp set-default nil] 3)
#@63 Regular expression pdbtrack uses to find a stack trace entry.
(defconst python-pdbtrack-stack-entry-regexp "^> \$.*\$(\$[0-9]+\$)\$[?a-zA-Z0-9_]+\$()" (#$ . 17513))
#@61 Regular expression pdbtrack uses to recognize a pdb prompt.
(defconst python-pdbtrack-input-prompt "\n[(<]*[Pp]db[>)]+ " (#$ . 17690))
#@72 Max number of characters from end of buffer to search for stack entry.
(defconst python-pdbtrack-track-range 10000 (#$ . 17831))
#@97 Guess step for indentation of current buffer.
Set `python-indent' locally to the value guessed.
(defalias 'python-guess-indent #[nil "\212\214~\210eb\210\306\211	\204I�m\204I�\307\310\306\311#\203�\312 \203�\212\313 \210\314 \315\316 !\2033�\314 \nZ\203E�\317Y\203E�\320X\203E�\321*\202�	\205d�\322\303!U\204c�\323\303!\210\fU\204c�\306,\207" [indent done initial python-indent tab-width indent-tabs-mode nil re-search-forward ":[[:space:]]*\$?:\\s<\\|$\$" move python-open-block-statement-p python-beginning-of-statement current-indentation zerop python-next-statement 2 8 t default-value make-local-variable] 4 (#$ . 17966) nil])
#@15 Internal use.
(defvar python-indent-list nil (#$ . 18623))
#@15 Internal use.
(defvar python-indent-list-length nil (#$ . 18688))
#@15 Internal use.
(defvar python-indent-index nil (#$ . 18760))
#@49 Calculate Python indentation for line at point.
(defalias 'python-calculate-indentation #[nil "\306\307\212\310 \210\311 \306\211\312\f8\203�\313\202$�\314\f8\203#�\315\202$�\306)\313=\203a�
\2043�\316 \202>\212\317 \210\320\321!)\204C�\316 \202>\3228\323y\210\n`W\203\\�\320\324!\203\\�\323y\210\202J�\316 \202>\325 \203\360�`\211)A@)\326 \327 SSf\330=*+,-,\203\312�,Tb\210\331 p./\332\216\3330!\210\3341\306\335\336\217,\203\267�+\204\254�*\203\263�2i\\\202\354�i\202\354�,Tb\210\317 \210\316 @2_\\\202\354�\323y\210\325 \203\327�\316 \202\354�\317 \210\337\316 3\340\334!\203\352�2\202\353�\341#,\202>o\203\370�\341\202>\320\342!\203\316 \202>4\203\343\344\215\206>\345 \210	\307V\2035\346 \2035\306y\210\346 \2045\316 \2365\3475\"5C\244)\350!\211)@@)+\207" [python-indent-list python-indent-list-length start syntax ppss python-indent-string-contents nil 1 beginning-of-line syntax-ppss 3 string 4 comment current-indentation python-beginning-of-statement looking-at "\\s|\\|\\s\"" 8 -1 "\\s-*$" python-continuation-line-p python-backslash-continuation-line-p line-beginning-position 58 syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1=#:buffer #2=#:table set-syntax-table] 2)) set-syntax-table t (byte-code "\301 \210\302 \210`W\207" [point forward-sexp backward-sexp] 2) ((error)) + python-open-block-statement-p 0 "[[:space:]]*\\s<[^	\n ]" done (byte-code "o\203�\300\207\301\302!\204�\300\207i\303 U\204�\300\207\304\305!\203*�i\306U\204*�\307\310i\"\202+�\311\2051�\202��\207" [nil forward-comment -1 current-indentation looking-at "\\s<\$?:[[:space:]]\\|$\$" 0 throw done t] 3) python-indentation-levels python-comment-line-p delete last x colon backslash open-start point #1# #2# python-space-backslash-table parse-sexp-ignore-comments python-indent python-continuation-offset python-honour-comment-indentation elt] 6 (#$ . 18826)])
#@71 Text of line following indentation and ignoring any trailing comment.
(defalias 'python-initial-text #[nil "\212\300 \210`\301\210\302\303!\210`{)\207" [back-to-indentation nil forward-comment -1] 3 (#$ . 20742)])
#@142 Alist of keyword matches.
The car of an element is a keyword introducing a statement which
can close a block opened by a keyword in the cdr.
(defconst python-block-pairs '(("else" "if" "elif" "while" "for" "try" "except") ("elif" "if" "elif") ("except" "try" "except") ("finally" "try" "except")) (#$ . 20964))
#@50 Return first word (actually symbol) on the line.
(defalias 'python-first-word #[nil "\212\300 \210\301\302!)\207" [back-to-indentation current-word t] 2 (#$ . 21281)])
#@349 Return a list of possible indentations for this line.
It is assumed not to be a continuation line or in a multi-line string.
Includes the default indentation and those which would close all
enclosing blocks.  Elements of the list are actually pairs:
(INDENTATION . TEXT), where TEXT is the initial text of the
corresponding block opening (or nil).
(defalias 'python-indentation-levels #[nil "\212\306\307\211\212\310 \205.�\311\312!\205.�\313 \211\205.�\314 \210\315\312!\210`Sf\316=\205.�\\\211)\203;�\nB	B\202\233�\212\317 \205Q�\320y\210\317 \205Q�\313 \nB	B\211)\204\233�\321\322 \f\"@\310 \210
\203n�\322 \321
\f\"A\235\203{�\323 \204{�\313 \324 B	B\325 \203\232�
\203\217�\322 \321
\f\"A\235\203{�\313 \324 B	B\202{�)	\206\242�\326\211	\211G,\207" [indent levels initial python-indent python-block-pairs start #1="" nil python-previous-statement python-open-block-statement-p t current-indentation python-end-of-statement python-skip-comments/blanks 58 python-comment-line-p -1 assoc python-first-word python-close-block-statement-p python-initial-text python-beginning-of-block ((0 . #1#)) python-indent-list python-indent-list-length] 5 (#$ . 21456)])
#@193 Subroutine of `python-indent-line'.
Does non-repeated indentation.  LEAVE non-nil means leave
indentation if it is valid, i.e. one of the positions returned by
`python-calculate-indentation'.
(defalias 'python-indent-line-1 #[(&optional leave) "\304 d`Z\211\305 U\204�\n\203)�\203)�\305 \236\203)�i\305 W\205>�\306 \202>�\307 \210\310 \210	j\210dZ`V\205>�dZb*\207" [pos target leave python-indent-list python-calculate-indentation current-indentation back-to-indentation beginning-of-line delete-horizontal-space] 4 (#$ . 22641)])
#@246 Indent current line as Python code.
When invoked via `indent-for-tab-command', cycle through possible
indentations for current line.  The cycle is broken by a command
different from `indent-for-tab-command', i.e. successive TABs do
the cycling.
(defalias 'python-indent-line #[nil "\306=\203;�	=\203;�\n\307U\203�\310\311!\207T\n\246\312 \210\313 \210\f8@j\210\314 \205:�\f8A\211\2059�\310\315
\")\207\316 \210\nS\211\207" [this-command last-command python-indent-list-length python-indent-index python-indent-list text indent-for-tab-command 1 message "Sole indentation" beginning-of-line delete-horizontal-space python-block-end-p "Closes: %s" python-indent-line-1] 4 (#$ . 23186) nil])
#@122 `indent-region-function' for Python.
Leaves validly-indented lines alone, i.e. doesn't indent to
another valid position.
(defalias 'python-indent-region #[(start end) "\212b\210\302 	b\210n\204�\303y\210`W\203)�n\203�l\204#�\304\305!\210\303y\210\202�\306\211\223)\207" [end start point-marker 1 python-indent-line-1 t nil] 3 (#$ . 23891)])
#@117 Non-nil if this is a line in a statement closing a block,
or a blank line indented to where it would close a block.
(defalias 'python-block-end-p #[nil "\300 ?\205�\301\302!\206�\303 \212\304 \210\303 )W\207" [python-comment-line-p python-close-block-statement-p t current-indentation python-previous-statement] 2 (#$ . 24246)])
#@195 `beginning-of-defun-function' for Python.
Finds beginning of innermost nested class or method definition.
Returns the name of the definition found at the end, or nil if
reached start of buffer.
(defalias 'python-beginning-of-defun #[nil "\306 \307\310\211\311 \203�\fo\204Y�	\204Y�n\204�\310\210\312 \313\n\310\314#\203�\306 \315!\2039�\315
!\206I�\312 U\206I�
U\206I�
W)\203�\316\317 8\204�\320\202�	,\207" [lep found def-re ci most-positive-fixnum in current-indentation "^[[:space:]]*\$?:class\\|def\$[[:space:]]+\$\\(?:[[:word:]]\\|\\s_\$+\\)" nil python-comment-line-p line-end-position re-search-backward move zerop 8 syntax-ppss t] 4 (#$ . 24584)])
#@95 `end-of-defun-function' for Python.
Finds end of innermost nested class or method definition.
(defalias 'python-end-of-defun #[nil "`\303\304 \203�\305\210\306\n!\210\307 \204�\310 \210\311\312 !\203=�\307 \204C�\313\305\314#\2033�\315\316 8\204$�m\204C�\317 \210\202C�\305\210\320 \210o\203`�\321\322!\204`�m\204`�\313\305\314#\203`�\315\316 8\204M�m\204r�\323 \210\324\325!\210m\204r�\317 \210`	W\205z�db*\207" [pattern orig most-positive-fixnum "^[[:space:]]*\$?:class\\|def\$[[:space:]]" python-comment-line-p nil forward-comment python-open-block-statement-p python-beginning-of-block zerop current-indentation re-search-forward move 8 syntax-ppss beginning-of-line python-beginning-of-defun looking-at "def\\|class" python-end-of-block skip-syntax-forward " >"] 4 (#$ . 25269)])
#@126 Go to start of current statement.
Accounts for continuation lines, multi-line strings, and
multi-line bracketed expressions.
(defalias 'python-beginning-of-statement #[nil "\301 \210\302 \210\303\304 \203<�\203�`W\202�\305\203<�\301 \210\306 \2031�\307y\210\306 \2037�\307y\210\202&�\302 \210\310 \210`\202�)\311 \207" [point beginning-of-line python-beginning-of-string nil python-continuation-line-p t python-backslash-continuation-line-p -1 python-skip-out back-to-indentation] 2 (#$ . 26071)])
#@207 Skip out of any nested brackets.
Skip forward if FORWARD is non-nil, else backward.
If SYNTAX is non-nil it is the state returned by `syntax-ppss' at point.
Return non-nil if and only if skipping was done.
(defalias 'python-skip-out #[(&optional forward syntax) "\206�\305 \211@)\n\203�\306\202�\307\310!?\2054�\311V\203)�\312\313\314\217\2024�\312\312\315\316\217\204+�\f)*\207" [syntax ppss forward depth done syntax-ppss -1 1 zerop 0 nil (byte-code "\302	_!\210\303\207" [forward depth backward-up-list t] 3) ((error)) (byte-code "\302!\210\303\211\207" [forward done backward-up-list t] 2) ((error))] 4 (#$ . 26583)])
#@223 Go to the end of the current statement and return point.
Usually this is the start of the next line, but if this is a
multi-line statement we need to skip over the continuation lines.
On a comment line, go to end of line.
(defalias 'python-end-of-statement #[nil "\304\210\304\305 \211\306\n8\203�\307\202�\310\n8\203�\300\202�\304)\300=\203+�\311\304\202[�	\306\n8\2037�\307\202B�\310\n8\203A�\300\202B�\304)\307=\203W�`\312	8b\210\304\313\314\217)\202[�\315\311	\")\203e�\304\210\202�?\205o�`Sf\316=)\203y�\317\210\202�`\207" [comment s ppss pos nil syntax-ppss 3 string 4 t 8 (byte-code "\300 \210\301\207" [forward-sexp t] 1) ((error (byte-code "b\210\301\207" [pos nil] 1))) python-skip-out 92 2] 4 (#$ . 27225)])
#@147 Go to start of previous statement.
With argument COUNT, do it COUNT times.  Stop at beginning of buffer.
Return count of statements left to move.
(defalias 'python-previous-statement #[(&optional count) "\204�\301\302W\203�\303[!\207\304 \210\302V\2030�o\2040�\305\306!\210\304 \210o\204�S\211\202�\207" [count 1 0 python-next-statement python-beginning-of-statement python-skip-comments/blanks t] 3 (#$ . 27969) "p"])
#@137 Go to start of next statement.
With argument COUNT, do it COUNT times.  Stop at end of buffer.
Return count of statements left to move.
(defalias 'python-next-statement #[(&optional count) "\204�\303\304W\203�\305[!\207\306 \210\307\304V\203X�m\204X�	\204X�\310 \210\311 \210\312 \313\n8\2037�\314\202B�\315\n8\203A�\316\202B�\307)\314=\203M�\317\202�m\204�S\211\202�)\207" [count bogus ppss 1 0 python-previous-statement beginning-of-line nil python-end-of-statement python-skip-comments/blanks syntax-ppss 3 string 4 comment t] 3 (#$ . 28407) "p"])
#@285 Go to start of current block.
With numeric arg, do it that many times.  If ARG is negative, call
`python-end-of-block' instead.
If point is on the first line of a block, use its outer block.
If current statement is in column zero, don't move and return nil.
Otherwise return non-nil.
(defalias 'python-beginning-of-block #[(&optional arg) "\204�\303\304!\206D�\305W\203�\306[!\207`\307 \204#�\310 \203'�\311\312!\210\313 \210\314 \304\n!\2039�	b?\202C�\315\316\215\205C�\317S!*\207" [arg point ci 1 zerop 0 python-end-of-block python-comment-line-p python-blank-line-p python-skip-comments/blanks t python-beginning-of-statement current-indentation done (byte-code "\302\303y!\203'�\304 W\203��\305 \204��\306 \210\307\310!\203��\311 \210\312\313\310\"\210\202��	b?\207" [ci point zerop -1 current-indentation python-comment-line-p python-beginning-of-statement python-open-block-statement-p t beginning-of-line throw done] 3) python-beginning-of-block] 2 (#$ . 28981) "p"])
#@246 Go to end of current block.
With numeric arg, do it that many times.  If ARG is negative,
call `python-beginning-of-block' instead.
If current statement is in column zero and doesn't open a block,
don't move and return nil.  Otherwise return t.
(defalias 'python-end-of-block #[(&optional arg) "\204�\305\306W\203�\307[!\207\306V\203F�`\310 \205!�\311\312!\313 \314 \315!\2038�\f\2048�	b?\202;�\316\317\215,\203F�S\211\202�\315!\207" [arg point _ ci open 1 0 python-beginning-of-block python-comment-line-p python-skip-comments/blanks t current-indentation python-open-block-statement-p zerop done (byte-code "\302\303 !\205)�\203�\304 	X\204�\304 	W\203��\305\306!\210\307\310!\210\311\312\306\"\210\202��\207" [open ci zerop python-next-statement current-indentation python-skip-comments/blanks t beginning-of-line 2 throw done] 3)] 3 (#$ . 29974) "p"])
#@57 Non-strict length limit for `python-which-func' output.
(defvar python-which-func-length-limit 40 (#$ . 30855))
(defalias 'python-which-func #[nil "\302!\303\304	G\305	$\210	)\207" [python-which-func-length-limit function-name python-current-defun set-text-properties 0 nil] 5])
#@318 `imenu-create-index-function' for Python.

Makes nested Imenu menus from nested `class' and `def' statements.
The nested menus are headed by an item referencing the outer
definition; it has a space prepended to the name so that it sorts
first with `imenu--sort-by-name' (though, unfortunately, sub-menus
precede it).
(defalias 'python-imenu-create-index #[nil "\306\303!\204	�eb\210\307\310\311\307\312#\203R�\313\314 8\204�\315\224\316\317!\320\224\203*�\321	P\214\322 \210\312\323 \211\203H�\324	P\nB\fB	\fBB\202N�	\nBB-\202�\306\303!\204\207�\307eb\210\310\325\307\312#\203x�\313\314 8\204]�\326\327!\327\224B
B\202]�\237
\203\206�\330
\237BB))\207" [index-alist name pos python-recursing sublist vars boundp nil re-search-forward "^[[:space:]]*\$?:\\(def\$\\|\$class\$\\)[[:space:]]+\$\\(?:[[:word:]]\\|_\$+\\)" t 8 syntax-ppss 0 match-string-no-properties 3 2 "class " narrow-to-defun python-imenu-create-index " " "^\$\\(?:[[:word:]]\\|_\$+\\)[[:space:]]*=" match-string 1 "Module variables"] 5 (#$ . 31143)])
#@182 Insert a colon and maybe outdent the line if it is a statement like `else'.
With numeric ARG, just insert that many colons.  With \[universal-argument],
just insert a single colon.
(defalias 'python-electric-colon #[(arg) "\301\250\204\n�\302\202�!\210?\205-�l\205-�\303 \205-�\304\305 8?\205-�\306 \307 V\205-�\310 \207" [arg self-insert-command 1 python-outdent-p 8 syntax-ppss current-indentation python-calculate-indentation python-indent-line] 2 (#$ . 32194) "*P"])
(put 'python-electric-colon 'delete-selection t)
#@214 Maybe delete a level of indentation on the current line.
Do so if point is at the end of the line's indentation outside
strings and comments.
Otherwise just call `backward-delete-char-untabify'.
Repeat ARG times.
(defalias 'python-backspace #[(arg) "\306 iU\203�n\204�\307 \204�\310\311 8\203�\312!\207\313\306 \314 \315\n\315\211\203G�@\211@W\203>�\f
@]A\211\204.�*\f\n\236A\211G\313V\203Y�\316\317	\"\210\320 \210\fj,\207" [arg initial indents ci indent x current-indentation python-continuation-line-p 8 syntax-ppss backward-delete-char-untabify 0 python-indentation-levels nil message "Closes %s" delete-horizontal-space --dolist-tail--] 5 (#$ . 32725) "*p"])
(put 'python-backspace 'delete-selection 'supersede)
#@38 Command used to check a Python file.
(custom-declare-variable 'python-check-command '"pychecker --stdlib" '(#$ . 33470) :type 'string :group 'python)
#@15 Internal use.
(defvar python-saved-check-command nil (#$ . 33626))
#@149 Check a Python file (default current buffer's file).
Runs COMMAND, a shell command, as if by `compile'.
See `python-check-command' for the default.
(defalias 'python-check #[(command) "\304\305!\210\306\n?\307\"\210\310B\311!)\207" [command python-saved-check-command compilation-ask-about-save compilation-error-regexp-alist require compile save-some-buffers nil ("(\$[^,]+\$, line \$[0-9]+\$)" 1 2) compilation-start] 3 (#$ . 33700) (list (read-string "Checker command: " (or python-saved-check-command (concat python-check-command " " (let ((name (buffer-file-name))) (if name (file-name-nondirectory name)))))))])
#@193 Shell command to run Python interpreter.
Any arguments can't contain whitespace.
Note that IPython may not work properly; it must at least be used
with the `-cl' flag, i.e. use `ipython -cl'.
(custom-declare-variable 'python-python-command '"python" '(#$ . 34334) :group 'python :type 'string)
#@82 Shell command to run Jython interpreter.
Any arguments can't contain whitespace.
(custom-declare-variable 'python-jython-command '"jython" '(#$ . 34634) :group 'python :type 'string)
#@206 Actual command used to run Python.
May be `python-python-command' or `python-jython-command', possibly
modified by the user.  Additional arguments are added when the command
is used by `run-python' et al.
(defvar python-command python-python-command (#$ . 34824))
#@759 *The current Python process buffer.

Commands that send text from source buffers to Python processes have
to choose a process to send to.  This is determined by buffer-local
value of `python-buffer'.  If its value in the current buffer,
i.e. both any local value and the default one, is nil, `run-python'
and commands that send to the Python process will start a new process.

Whenever \[run-python] starts a new process, it resets the default
value of `python-buffer' to be the new process's buffer and sets the
buffer-local value similarly if the current buffer is in Python mode
or Inferior Python mode, so that source buffer stays associated with a
specific sub-process.

Use \[python-set-proc] to set the default value from a buffer with a
local value.
(defvar python-buffer nil (#$ . -35095))
(make-variable-buffer-local 'python-buffer)
#@55 `compilation-error-regexp-alist' for inferior Python.
(defconst python-compilation-regexp-alist (byte-code "\300\301B\302\303B\304\305BE\207" ["^[	 ]+File \"\$[^\"<]+\$\", line \$[[:digit:]]+\$" (1 2) " in file \$.+\$ on line \$[[:digit:]]+\$" (1 2) "^> \$[^\"(<]+\$(\$[[:digit:]]+\$)[^(]+()" (1 2)] 4) (#$ . 35944))
(byte-code "\305B\306\305!\204�\307\305\310 \311	\312\313#\210\311	\314\315#\210	)\"\210\316B\306\316!\2049�\307\316\317\n!\320\321\322#\210)\"\210\323\324N\204E�\325\323\324\326#\210\327\305!\204Q�\325\305\330\331#\210\305B\306\305!\204a�\307\305\310 \"\210\327\316!\204m�\325\316\330\331#\210\316B\306\316!\204}�\307\316\317 \"\210\325\304\330\331#\210\304B\306\304!\204\227�\307\304\332\304\333\"\210\f\"\210\325\331\334\335#\210\325\331\336\337#\207" [current-load-list map python-mode-syntax-table st inferior-python-mode-abbrev-table inferior-python-mode-map default-boundp set-default make-sparse-keymap define-key "\f" python-load-file "" python-check inferior-python-mode-syntax-table make-syntax-table modify-syntax-entry 39 "." inferior-python-mode-hook variable-documentation put "Hook run when entering Inferior Python mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp definition-name inferior-python-mode define-abbrev-table nil derived-mode-parent comint-mode custom-mode-group python] 6)
#@671 Major mode for interacting with an inferior Python process.
A Python process can be started with \[run-python].

Hooks `comint-mode-hook' and `inferior-python-mode-hook' are run in
that order.

You can send text to the inferior Python process from other buffers
containing Python source.
 * \[python-switch-to-python] switches the current buffer to the Python
    process buffer.
 * \[python-send-region] sends the current region to the Python process.
 * \[python-send-region-and-go] switches to the Python process buffer
    after sending the text.
For running multiple processes in multiple buffers, see `run-python' and
`python-buffer'.

\{inferior-python-mode-map}
(defalias 'inferior-python-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203�\314\311\313\310\313N#\210\315!\204'�\316\317 \"\210\320\f!\211\2036�
\321 =\203<�\322\f\323 \"\210)\324!\210\325\f!\210$%\326&\306\327!\210\330\331\332\333\334\307$\210\306\335!\210\336\306\337!\210'\340\341!\210)\342\343!\207" [delay-mode-hooks major-mode mode-name inferior-python-mode-map inferior-python-mode-syntax-table parent make-local-variable t comint-mode inferior-python-mode "Inferior Python" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table (":%s") comint-input-filter python-input-filter add-hook comint-preoutput-filter-functions python-preoutput-filter nil comint-prompt-regexp "^\$?:\\(?:[.>]\\{3\\}\\|(Pdb)\$ \\)+" compilation-error-regexp-alist compilation-shell-minor-mode 1 run-mode-hooks inferior-python-mode-hook inferior-python-mode-abbrev-table local-abbrev-table mode-line-process python-compilation-regexp-alist] 6 (#$ . 37393) nil])
#@125 Input matching this regexp is not saved on the history list.
Default ignores all inputs of 0, 1, or 2 non-blank characters.
(custom-declare-variable 'inferior-python-filter-regexp '"\\`\\s-*\\S-?\\S-?\\s-*\\'" '(#$ . 39162) :type 'regexp :group 'python)
#@123 `comint-input-filter' function for inferior Python.
Don't save anything for STR matching `inferior-python-filter-regexp'.
(defalias 'python-input-filter #[(str) "\302	\"?\207" [inferior-python-filter-regexp str string-match] 3 (#$ . 39423)])
(defalias 'python-args-to-list #[(string) "\303\304\"\211\204�C\2023�	\305U\204#�\305	O\306	T\307O!B\2023�\303\310\"\211\2052�\306\n\307O!))\207" [string where pos string-match "[ 	]" 0 python-args-to-list nil "[^ 	]"] 6])
#@64 Data from last `_emacs_out' line seen by the preoutput filter.
(defvar python-preoutput-result nil (#$ . 39904))
#@75 If non-nil, funcall this when `python-preoutput-filter' sees `_emacs_ok'.
(defvar python-preoutput-continuation nil (#$ . 40023))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\304\207" [current-load-list python-preoutput-leftover default-boundp set-default nil python-preoutput-skip-next-prompt] 3)
#@74 `comint-preoutput-filter-functions' function: ignore prompts not at bol.
(defalias 'python-preoutput-filter #[(s) "\203\n�	P\306\307\310\311\312	#\203V�	\307\225\211O
\2032�\311\f\"\2032�\306\f\307\225\306O\311\313\f\"\203N�\314\315!\203N�\316\317\f\"
\320\305!\210\321\202R�\n\fP)\202�\322!\204a�	\306O\311	\"\203\206�
\204\200�\322\nG!\203y�n?\202}�\311\323\n\"\203\206�\306\n\202\253�\324G	G^\325	\306\324\306&)\321=\203\250�\320\300!\210	\n\202\253�\n	P*\207" [python-preoutput-leftover s res start line python-preoutput-skip-next-prompt nil 0 "" string-match "\n" "\\`_emacs_out \$.*\$\n\\'" local-variable-p python-preoutput-result match-string 1 make-local-variable t zerop ".\\'" "_emacs_out " compare-strings comint-prompt-regexp end] 7 (#$ . 40375)])
(byte-code "\301\302\303\"\210\304B\305\304!\204�\306\304\307\"\210\307\207" [current-load-list autoload comint-check-proc "comint" python-version-checked default-boundp set-default nil] 3)
#@51 Check that CMD runs a suitable version of Python.
(defalias 'python-check-version #[(cmd) "\206\f�\304\305	!\n\"\306\232?\205G�\307\n!\204�\310\311\n\"\210\307\n\312P!\304\313\"\210\314\315\"\316\232\203?�\317\224\203?�\320\314\317\"!\317Y\204C�\310\321!\210)\322\211\207" [python-version-checked python-python-command cmd res string-match regexp-quote 0 shell-command-to-string error "Can't run Python command `%s'" " --version" "Python \$[0-9]\$\\.\$[0-9]\$" match-string 1 "2" 2 string-to-number "Only Python versions >= 2.2 and < 3.0 supported" t] 4 (#$ . 41369)])
#@767 Run an inferior Python process, input and output via buffer *Python*.
CMD is the Python command to run.  NOSHOW non-nil means don't show the
buffer automatically.

Normally, if there is a process already running in `python-buffer',
switch to that buffer.  Interactively, a prefix arg allows you to edit
the initial command line (default is `python-command'); `-i' etc. args
will be added to this as appropriate.  A new process is started if:
one isn't running attached to `python-buffer', or interactively the
default `python-command', or argument NEW is non-nil.  See also the
documentation for `python-buffer'.

Runs the hook `inferior-python-mode-hook' (after the
`comint-mode-hook' is run).  (Type \[describe-mode] in the process
buffer for a list of commands.)
(defalias 'run-python #[(&optional cmd noshow new) "\204�	\306!\210\n\204�\307!\204\\�r\310\311!\312\"\313\314!\315
\205+�
\"P#Q$B$\316%\317\320\321\322\323!\f@\316\fA&,q\210\324\303p\"\210p\325\326!\327\"\210\330 \210\331\332!\210)\333\334!\203f�\335\303!\336\337\340\"\210&?\205u�\341\340\"\207" [cmd python-command new python-buffer cmdlist path python-check-version comint-check-proc append python-args-to-list ("-i" "-c" "import sys; sys.path.remove('')") getenv "PYTHONPATH" "PYTHONPATH=" nil apply make-comint-in-buffer "Python" generate-new-buffer "*Python*" set-default accept-process-output get-buffer-process 5 inferior-python-mode python-send-string "import emacs" derived-mode-p python-mode default-value sit-for 1 t pop-to-buffer path-separator data-directory process-environment process-connection-type noshow] 7 (#$ . 41956) (byte-code "\203\f�\302\303	\"\304\305E\207	C\207" [current-prefix-arg python-command read-string "Run Python: " nil t] 3)])
#@70 Like `python-send-string' but resets `compilation-shell-minor-mode'.
(defalias 'python-send-command #[(command) "\302 \205�r\303\304 !q\210db\210\305 \210\306!\210p\211)\207" [command compilation-last-buffer python-check-comint-prompt process-buffer python-proc compilation-forget-errors python-send-string] 2 (#$ . 43717)])
#@49 Send the region to the inferior Python process.
(defalias 'python-send-region #[(start end) "\305\306!\307\310\"\311\n!\212\nb\210\312 \313U)\204-�\212b\210\314\313!\315\223\210)\316\317\315\315\320%\210\316\n\f\321\320%\210\322	!\210r\323\324 !q\210\325\",\207" [f command start orig-start end make-temp-file "py" format "emacs.eexecfile(%S)" copy-marker current-indentation 0 line-beginning-position nil write-region "if True:\n" nomsg t python-send-command process-buffer python-proc compilation-fake-loc] 6 (#$ . 44051) "r"])
#@45 Evaluate STRING in inferior Python process.
(defalias 'python-send-string #[(string) "\301\302 \"\210\303\304\"\204�\301\302 \305\"\210\303\306\"\205�\301\302 \305\"\207" [string comint-send-string python-proc string-match "\n\\'" "\n" "\n[ 	].*\n?\\'"] 3 (#$ . 44597) "sPython command: "])
#@57 Send the current buffer to the inferior Python process.
(defalias 'python-send-buffer #[nil "\300ed\"\207" [python-send-region] 3 (#$ . 44899) nil])
#@74 Send the current defun (class or method) to the inferior Python process.
(defalias 'python-send-defun #[nil "\212\300\301 \210`\302 \210`\")\207" [python-send-region beginning-of-defun end-of-defun] 3 (#$ . 45054) nil])
#@117 Switch to the Python process buffer, maybe starting new process.
With prefix arg, position cursor at end of buffer.
(defalias 'python-switch-to-python #[(eob-p) "\301\302\303 !\304\"\210\205�\305 \210db\207" [eob-p pop-to-buffer process-buffer python-proc t push-mark] 3 (#$ . 45281) "P"])
#@84 Send the region to the inferior Python process.
Then switch to the process buffer.
(defalias 'python-send-region-and-go #[(start end) "\302	\"\210\303\304!\207" [start end python-send-region python-switch-to-python t] 3 (#$ . 45579) "r"])
#@229 Used to determine if a buffer contains Python source code.
If a file is loaded into a buffer that is in one of these major modes,
it is considered Python source by `python-load-file', which uses the
value to determine defaults.
(custom-declare-variable 'python-source-modes ''(python-mode jython-mode) '(#$ . 45826) :type '(repeat function) :group 'python)
#@127 Caches (directory . file) pair used in the last `python-load-file' command.
Used for determining the default in the next one.
(defvar python-prev-dir/file nil (#$ . 46190))
(autoload 'comint-get-source "comint")
#@287 Load a Python file FILE-NAME into the inferior Python process.
If the file has extension `.py' import or reload it as a module.
Treating it as a module keeps the global namespace clean, provides
function location information for debugging, and supports users of
module-qualified names.
(defalias 'python-load-file #[(file-name) "\303!\210\304!\305!Br\306\307 !q\210\310\311\312\"\203,�\313\305!!\314\315\n\304!#)\2020�\314\316\"!\210\317\320\")\207" [file-name python-prev-dir/file module comint-check-source file-name-directory file-name-nondirectory process-buffer python-proc python-send-command string-match "\\.py\\'" file-name-sans-extension format "emacs.eimport(%S,%S)" "execfile(%S)" message "%s loaded"] 6 (#$ . 46409) (comint-get-source "Load Python file: " python-prev-dir/file python-source-modes t)])
#@102 Return the current Python process.
See variable `python-buffer'.  Starts a new process if necessary.
(defalias 'python-proc #[nil "\301!\204�\302\303\304\"\210\305\306\307!\203�p\202�!\207" [python-buffer comint-check-proc run-python nil t get-buffer-process derived-mode-p inferior-python-mode] 3 (#$ . 47241)])
#@337 Set the default value of `python-buffer' to correspond to this buffer.
If the current buffer has a local value of `python-buffer', set the
default (global) value to that.  The associated Python process is
the one that gets input from \[python-send-region] et al when used
in a buffer that doesn't have a local value of `python-buffer'.
(defalias 'python-set-proc #[nil "\301\300!\203�\302\300\"\207\303\304!\207" [python-buffer local-variable-p set-default error "No local value of `python-buffer'"] 3 (#$ . 47566) nil])
#@92 Syntax table giving `.' symbol syntax.
Otherwise inherits from `python-mode-syntax-table'.
(defconst python-dotty-syntax-table (byte-code "\302 \303	\"\210\304\305\306#\210)\207" [table python-mode-syntax-table make-syntax-table set-char-table-parent modify-syntax-entry 46 "_"] 4) (#$ . 48095))
#@386 Get help on SYMBOL using `help'.
Interactively, prompt for symbol.

Symbol may be anything recognized by the interpreter's `help'
command -- e.g. `CALLS' -- not just variables in scope in the
interpreter.  This only works for Python version 2.2 or newer
since earlier interpreters don't support `help'.

In some cases where this doesn't find documentation, \[info-lookup-symbol]
will.
(defalias 'python-describe-symbol #[(symbol) "\305\232\203\n�\306\307!\210\310\311 \220r\nq\210\312\313Dt\"\210\314\303!\210\315\316 )\221\210)\317\320\321\f#\322\323 \324\211%\207" [symbol temp-buffer-show-hook standard-output comint-redirect-subvert-readonly python-imports "" error "No symbol" #[nil "\302\303!\210\304 BC\211\207" [help-return-method view-return-to-alist toggle-read-only 1 selected-window] 2] help-buffer help-setup-xref python-describe-symbol make-local-variable t print-help-return-message comint-redirect-send-command-to-process format "emacs.ehelp(%S, %s)" "*Help*" python-proc nil] 6 (#$ . 48402) (let ((symbol (with-syntax-table python-dotty-syntax-table (current-word))) (enable-recursive-minibuffers t)) (list (read-string (if symbol (format "Describe symbol (default %s): " symbol) "Describe symbol: ") nil nil symbol)))])
(add-to-list 'debug-ignored-errors "^No symbol")
#@176 Send STRING to inferior Python (if any) and return result.
The result is what follows `_emacs_out' in the output.
This is a no-op if `python-check-comint-prompt' returns nil.
(defalias 'python-send-receive #[(string) "\303!\210\304 r\305	!q\210\306	!\205'�\307\302!\210\310\311	\312\"\210\n\203�\n\313\302!\210*\207" [string proc python-preoutput-result python-send-string python-proc process-buffer python-check-comint-prompt make-local-variable nil accept-process-output 5 kill-local-variable] 3 (#$ . 49703)])
#@228 Return non-nil if and only if there's a normal prompt in the inferior buffer.
If there isn't, it's probably not appropriate to send input to return Eldoc
information etc.  If PROC is non-nil, check the buffer for that process.
(defalias 'python-check-comint-prompt #[(&optional proc) "r\302\206�\303 !q\210\212\304 \305\216\306\307\310\311#,\207" [proc save-match-data-internal process-buffer python-proc match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) re-search-backward ">>> \\=" nil t] 4 (#$ . 50227)])
#@161 `eldoc-documentation-function' for Python.
Only works when point is in a function name, not its arg list, for
instance.  Assumes an inferior Python is running.
(defalias 'python-eldoc-function #[nil "\304 p\305\216\306\n!\210\307 +\310\311\312\217)\207" [#1=#:buffer #2=#:table python-dotty-syntax-table symbol syntax-table ((byte-code "rq\210\302	!\210)\302\207" [#1# #2# set-syntax-table] 2)) set-syntax-table current-word nil (byte-code "\305	\203�\306\307\310	\n#!\206F�\311 \312@!?\205E�A@f\313=\205E�\212A@b\210\314\315!\210`\316\305x\210`\fW\205D�\306\307\310\317`\f\"\n#!*))\207" [inhibit-quit symbol python-imports s point nil python-send-receive format "emacs.eargs(%S, %s)" syntax-ppss zerop 40 skip-syntax-backward "-" "a-zA-Z._" buffer-substring-no-properties] 6) ((quit (byte-code "\301\302\303!\207" [quit-flag t eval (ignore nil)] 2)))] 3 (#$ . 50792)])
#@59 Set up info-look for Python.
Used with `eval-after-load'.
(defalias 'python-after-info-look #[nil "\305\306P!\307\310	\"\210\311\312	\")\313\314!rq\210\315\216\316 \210\317\320\321\217+\322\323\324\325\326\327\f\203q�\330\n\331Q\332B\330\n\333\317\334\260C\330\n\335\317\334\260C\330\n\336\317\334\260C\330\n\337\317\334\260C\330\n\340\317\334\260C\330\n\341\317\334\260C\330\n\342\317\334\260C\257\202r�\343&*\207" [python-command s version #1=#:temp-buffer versioned shell-command-to-string " -V" string-match "^Python \$[0-9]+\\.[0-9]+\\>\$" match-string 1 generate-new-buffer " *temp*" ((byte-code "\301!\203\n�\302!\210\301\207" [#1# buffer-name kill-buffer] 2)) Info-mode nil (byte-code "\301\302\303\"!\210\304\207" [version Info-goto-node format "(python%s-lib)Miscellaneous Index" t] 4) ((error)) info-lookup-maybe-add-help :mode python-mode :regexp "[[:alnum:]_]+" :doc-spec "(python" "-ref)Miscellaneous Index" (nil #2="") "-ref)Module Index" #2# "-ref)Function-Method-Variable Index" "-ref)Class-Exception-Object Index" "-lib)Module Index" "-lib)Class-Exception-Object Index" "-lib)Function-Method-Variable Index" "-lib)Miscellaneous Index" (("(python-ref)Miscellaneous Index" nil #2#) ("(python-ref)Module Index" nil #2#) ("(python-ref)Function-Method-Variable Index" nil #2#) ("(python-ref)Class-Exception-Object Index" nil #2#) ("(python-lib)Module Index" nil #2#) ("(python-lib)Class-Exception-Object Index" nil #2#) ("(python-lib)Function-Method-Variable Index" nil #2#) ("(python-lib)Miscellaneous Index" nil #2#))] 18 (#$ . 51680)])
(eval-after-load "info-look" '(python-after-info-look))
#@137 Packages implying `jython-mode'.
If these are imported near the beginning of the buffer, `python-mode'
actually punts to `jython-mode'.
(custom-declare-variable 'python-jython-packages ''("java" "javax" "org" "com") '(#$ . 53315) :type '(repeat string) :group 'python)
#@212 Invoke `jython-mode' if the buffer appears to contain Jython code.
The criterion is either a match for `jython-mode' via
`interpreter-mode-alist' or an import of a module from the list
`python-jython-packages'.
(defalias 'python-maybe-jython #[nil "\212\214~\210eb\210\303!\205�\304\305!\211\203&�\306\307	!\n\"A\310=\203&�\310 \202.�\311\312\215\205.�\310 +\207" [auto-mode-interpreter-regexp interpreter interpreter-mode-alist looking-at match-string 2 assoc file-name-nondirectory jython-mode done (byte-code "\301\302e\303\\\304#\205�\305\306!\235\203��\307\310\304\"\210\202��\207" [python-jython-packages re-search-forward "^\$?:from\\|import\$[[:space:]]+\$[^	\n .]+\$" 10000 t match-string 1 throw done] 4)] 4 (#$ . 53591)])
#@243 `fill-paragraph-function' handling multi-line strings and possibly comments.
If any of the current line is in or at the end of a multi-line string,
fill the string or the paragraph of it that point is in, preserving
the string's indentation.
(defalias 'python-fill-paragraph #[(&optional justify) "\306!\204i�\212\307\210\310 `\307\211\311	8\203#�\307\312!\210)\202M�\313	8\314=\203;�\315	8b\210\316 \307\317\320\217\202M�\321\322\307\314#\203M�\307u\210`\307\323\324\217\210\f\203h�\214\f}\210\nb\210\325\326\327R\307\312!\210+-\314\207" [justify syntax orig start end fill-paragraph-function fill-comment-paragraph nil syntax-ppss 4 fill-paragraph 3 t 8 line-beginning-position (byte-code "\300 \210`\301Z\207" [forward-sexp 3] 2) ((error (point-max))) re-search-backward "\\s|\\s-*\\=" (byte-code "\301 \210\302 \301\207" [start backward-sexp line-beginning-position] 1) ((error)) ".*\$\\s|\$\\1\\{2\\}[	 ]*$\\|\$[\"']\$\\2\\s|" "\$?:" "\$" paragraph-separate] 5 (#$ . 54340) "P"])
#@300 Shift lines in region COUNT (the prefix arg) columns to the left.
COUNT defaults to `python-indent'.  If region isn't active, just shift
current line.  The region shifted includes the lines in which START and
END lie.  It is an error if any lines in the region are indented less than
COUNT columns.
(defalias 'python-shift-left #[(start end &optional count) "\203�\304!\202
�	\305V\205;�\212\nb\210`W\2034�\306 W\203.�\307\310!\204.�\311\312!\210\313y\210\202�\314\n[#)\207" [count python-indent start end prefix-numeric-value 0 current-indentation looking-at "[ 	]*$" error "Can't shift all lines enough" nil indent-rigidly] 4 (#$ . 55357) (byte-code "\203�\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
(add-to-list 'debug-ignored-errors "^Can't shift all lines enough")
#@220 Shift lines in region COUNT (the prefix arg) columns to the right.
COUNT defaults to `python-indent'.  If region isn't active, just shift
current line.  The region shifted includes the lines in which START and
END lie.
(defalias 'python-shift-right #[(start end &optional count) "\203�\304!\202
�	\305\n#\207" [count python-indent start end prefix-numeric-value indent-rigidly] 4 (#$ . 56245) (byte-code "\203�\302 \303 	E\207\304 \305 	E\207" [mark-active current-prefix-arg region-beginning region-end line-beginning-position line-end-position] 3)])
#@124 `outline-level' function for Python mode.
The level is the number of `python-indent' steps of indentation
of current line.
(defalias 'python-outline-level #[nil "\301 \245T\207" [python-indent current-indentation] 2 (#$ . 56813)])
#@46 `add-log-current-defun-function' for Python.
(defalias 'python-current-defun #[(&optional length-limit) "\212\303\304\305\306\215\210	\205 �\n\203�\nV\203�	\307\240\210\310\311	\312#+\207" [length accum length-limit nil -1 done (byte-code "\203�	A\203�\nW\203I�`\304 \210\305\210\306 \210`U\203%�\307\310\305\"\210)\311\312!\203:�\313\314!	B\315\n\314	@G#\316 \317U\203��\307\310\305\"\210\202��\305\207" [length-limit accum length started-from python-beginning-of-block nil beginning-of-defun throw done looking-at "[[:space:]]*\$?:class\\|def\$[[:space:]]+\$\\(?:[[:word:]]\\|\\s_\$+\\)" match-string 1 + current-indentation 0] 4) ".." mapconcat identity "."] 4 (#$ . 57051)])
#@87 Mark the block around point.
Uses `python-beginning-of-block', `python-end-of-block'.
(defalias 'python-mark-block #[nil "\300 \210\301 \210\300`\302\303#\210\304 \210\305 \207" [push-mark python-beginning-of-block nil t python-end-of-block exchange-point-and-mark] 4 (#$ . 57754) nil])
#@73 String of top-level import statements updated by `python-find-imports'.
(defvar python-imports "None" (#$ . 58047))
(make-variable-buffer-local 'python-imports)
#@52 Find top-level imports, updating `python-imports'.
(defalias 'python-find-imports #[nil "\212\304eb\210\305\306\304\307#\203I�\310 \311	8\203�\312\202&�\313	8\203%�\314\202&�\304)\204�\315 \316 Sf\317=\203=�\320y\321U\204-�\n\315\322!{B)\202�\203U�\323\324\237\"\202V�\325\205o�\326\321G\304$\210\327\330\331\332\333\"\307\211%\211*\207" [lines ppss start python-imports nil re-search-forward "^import\\>\\|^from\\>" t syntax-ppss 3 string 4 comment line-beginning-position line-end-position 92 1 0 2 apply concat "None" set-text-properties replace-regexp-in-string "\n" "\\n" format "%S"] 6 (#$ . 58214) nil])
#@157 Return a list of completions of the string SYMBOL from Python process.
The list is sorted.
Uses `python-imports' to load modules against which to complete.
(defalias 'python-symbol-completions #[(symbol) "\205�\302\303\304\217\305\306	!\307\")\207" [symbol completions nil (byte-code "\302\303\304\305	#!!@\207" [symbol python-imports read-from-string python-send-receive format "emacs.complete(%S,%s)"] 6) ((error)) sort delete-dups string<] 3 (#$ . 58848)])
#@58 Return the partial symbol before point (for completion).
(defalias 'python-partial-symbol #[nil "`\212\302\303\304\305#\205\f�\306\224)\205�\307	\"*\207" [start end re-search-backward "\$?:\\`\\|[^[:alnum:]._]\$\$[[:alnum:]._]+\$\\=" nil t 1 buffer-substring-no-properties] 5 (#$ . 59318)])
#@53 Function for `ffap-alist' to return path to MODULE.
(defalias 'python-module-path #[(module) "\301\302\303\"!\207" [module python-send-receive format "emacs.modpath (%S)"] 4 (#$ . 59624)])
(eval-after-load "ffap" '(push '(python-mode . python-module-path) ffap-alist))
#@77 Find source of definition of function NAME.
Interactively, prompt for name.
(defalias 'python-find-function #[(name) "\204�\305\306!\210\307\310\311	#!\312\n!@\211@\nA\204$�\305\313	\"\210\314\315!!\210\f\250\2052�\316\f!,\207" [python-imports name loc file line error "Not called from buffer visiting Python file" python-send-receive format "emacs.location_of (%S, %s)" read-from-string "Don't know where `%s' is defined" pop-to-buffer find-file-noselect goto-line] 6 (#$ . 59900) (let ((symbol (with-syntax-table python-dotty-syntax-table (current-word))) (enable-recursive-minibuffers t)) (list (read-string (if symbol (format "Find location of (default %s): " symbol) "Find location of: ") nil nil symbol)))])
#@151 Non-nil means template skeletons will be automagically inserted.
This happens when pressing "if<SPACE>", for example, to prompt for
the if condition.
(custom-declare-variable 'python-use-skeletons 'nil '(#$ . 60630) :type 'boolean :group 'python)
(byte-code "\302\301\303\304\305\306\307\310\311\312&	\210\313\314\315\316#\210\203!�\317	\320\321\322\303\306&\210\313\322\323\306#\207" [python-use-skeletons python-mode-abbrev-table define-abbrev-table nil "Abbrev table for Python mode." :case-fixed t :regexp "\$?:^\\|[^/]\$\\<\$[[:word:]/]+\$\\W*" :enable-function #[nil "\300\301 8?\207" [8 syntax-ppss] 2] put def-python-skeleton lisp-indent-function 2 define-abbrev "if" "" python-insert-if no-self-insert] 10)
#@533 Insert Python "if" template.

This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.

A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(defalias 'python-insert-class #[(&optional str arg) "\302\303	#\207" [str arg skeleton-proxy-new ("Name: " "class " str " (" ("Inheritance, %s: " (unless (equal 40 (char-before)) ", ") str) & ")" | -2 ":" n "\"\"\"" - "\"\"\"" n > _ n)] 4 (#$ . 68654) "*P\nP"])
#@84 Default template to expand by `python-expand-template'.
Updated on each expansion.
(defvar python-default-template "if" (#$ . 69459))
#@81 Expand template named NAME.
Interactively, prompt for the name with completion.
(defalias 'python-expand-template #[(name) "\304\232\203�	\202
�\305\n\"\211\203�\306!\202 �\307\310\")\207" [name python-default-template python-mode-abbrev-table sym "" abbrev-symbol abbrev-insert error "Undefined template: %s"] 4 (#$ . 69599) (list (completing-read (format "Template to expand (default %s): " python-default-template) python-mode-abbrev-table nil t nil nil python-default-template))])
(byte-code "\300\301\302\303\304$\210\300\305\306\"\207" [autoload pymacs-load "pymacs" nil t brm-init "bikemacs"] 5)
#@215 Set up Bicycle Repair Man refactoring tool (if available).

Note that the `refactoring' features change files independently of
Emacs and may modify and save the contents of the current buffer
without confirmation.
(defalias 'python-setup-brm #[nil "\300\301\302\217\207" [data (byte-code "\303\304!?\2053�\305\306\307\"\210\310 \311B\312 \210\313\314\315\"\210\316\317\320\321#\210\322\317!\204,�\323\317\324\"\210\325\317\n\321\326$*\207" [features py-mode-map python-mode-map fboundp brm-rename pymacs-load "bikeemacs" "brm-" make-sparse-keymap python-mode brm-init remove-hook python-mode-hook (lambda nil (easy-menu-add brm-menu)) put python-brm-menu variable-documentation "Bicycle Repair Man" default-boundp set-default nil easy-menu-do-define ("BicycleRepairMan" :help "Interface to navigation and refactoring tool" "Queries" ["Find References" brm-find-references :help "Find references to name at point in compilation buffer"] ["Find Definition" brm-find-definition :help "Find definition of name at point"] "-" "Refactoring" ["Rename" brm-rename :help "Replace name at point with a new name everywhere"] ["Extract Method" brm-extract-method :active (and mark-active (not buffer-read-only)) :help "Replace statements in region with a method"] ["Extract Local Variable" brm-extract-local-variable :active (and mark-active (not buffer-read-only)) :help "Replace expression in region with an assignment"] ["Inline Local Variable" brm-inline-local-variable :help "Substitute uses of variable at point with its definition"] ["Undo Last Refactoring" brm-undo :help ""])] 5) ((error (error "BicycleRepairMan setup failed: %s" data)))] 3 (#$ . 70219) nil])
(byte-code "\302\303\304\"\210\305\306N\204�\307\305\306\310#\210\311\312!\204�\307\312\313\314#\210\312B\315\312!\204-�\316\312\317 \"\210\311\320!\2049�\307\320\313\314#\210\320B\315\320!\204I�\316\320\321 \"\210\307\301\313\314#\210\301B\315\301!\204c�\316\301\322\301\323\"\210	\"\210\307\314\324\323#\210\307\314\325\326#\207" [current-load-list python-mode-abbrev-table add-hook comint-output-filter-functions python-pdbtrack-track-stack-file python-mode-hook variable-documentation put "Hook run when entering Python mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp python-mode-map definition-name python-mode default-boundp set-default make-sparse-keymap python-mode-syntax-table make-syntax-table define-abbrev-table nil derived-mode-parent custom-mode-group python] 5)
#@1920 Major mode for editing Python files.
Turns on Font Lock mode unconditionally since it is currently required
for correct parsing of the source.
See also `jython-mode', which is actually invoked if the buffer appears to
contain Jython code.  See also `run-python' and associated Python mode
commands for running Python under Emacs.

The Emacs commands which work with `defun's, e.g. \[beginning-of-defun], deal
with nested `def' and `class' blocks.  They take the innermost one as
current without distinguishing method and class definitions.  Used multiple
times, they move over others at the same indentation level until they reach
the end of definitions at that level, when they move up a level.
\<python-mode-map>
Colon is electric: it outdents the line if appropriate, e.g. for
an else statement.  \[python-backspace] at the beginning of an indented statement
deletes a level of indentation to close the current block; otherwise it
deletes a character backward.  TAB indents the current line relative to
the preceding code.  Successive TABs, with no intervening command, cycle
through the possibilities for indentation on the basis of enclosing blocks.

\[fill-paragraph] fills comments and multi-line strings appropriately, but has no
effect outside them.

Supports Eldoc mode (only for functions, using a Python process),
Info-Look and Imenu.  In Outline minor mode, `class' and `def'
lines count as headers.  Symbol completion is available in the
same way as in the Python shell using the `rlcompleter' module
and this is added to the Hippie Expand functions locally if
Hippie Expand mode is turned on.  Completion of symbols of the
form x.y only works if the components are literal
module/attribute names, not variables.  An abbrev table is set up
with skeleton expansions for compound statement templates.

\{python-mode-map}

This mode runs the hook `python-mode-hook', as the final step
during initialization.
(defalias 'python-mode #[nil "\306\300!\210\307\310 \210\311\312\313!\210\314\f!\210
@\306\315!\210\316
\306\317!\210\307\306\320!\210\307\306\321!\210\322\306\323!\210\324\306\325!\210\326\306\327!\210\330\306\331!\210\332\306\333!\210A\306\334!\210\335\306\336!\210\337\306\340!\210\341 \306\342!\210\343\"\306\344!\210\345$\306\346!\210\306\347!\210\350'\306\351!\210\352)\353\354\355\345\307$\210\356B\306\357!\210\360/\353\361\362\345\307$\210\306\363!\210\3643\306\365!\210\3665\367\370\311\371\345\372\373\374BBBBB\"\210\306\375!\210\376=\306\377!\210\201J�?C\204\337�\201C�\201K�!\210D\203\351�\201D� \210?EU\204\364�\345F\306\201H�!\210GH\201L� \210\201M�\201I�!\204\307I\201N� \210))\201O�\201P�!\207" [delay-mode-hooks major-mode mode-name python-mode-map python-mode-syntax-table python-mode-abbrev-table make-local-variable t kill-all-local-variables python-mode "Python" use-local-map set-syntax-table font-lock-defaults (python-font-lock-keywords nil nil nil nil (font-lock-syntactic-keywords . python-font-lock-syntactic-keywords)) parse-sexp-lookup-properties parse-sexp-ignore-comments comment-start "# " indent-line-function python-indent-line indent-region-function python-indent-region paragraph-start "\\s-*$" fill-paragraph-function python-fill-paragraph require-final-newline add-log-current-defun-function python-current-defun outline-regexp "[[:space:]]*\$?:\\(?:class\\|def\\|e\\(?:l\\(?:if\\|se\$\\|xcept\\)\\|f\$?:inally\\|or\$\\|if\\|try\\|w\$?:hile\\|ith\$\\)\\)\\_>" outline-heading-end-regexp ":\\s-*\n" outline-level python-outline-level open-paren-in-column-0-is-defun-start nil python-saved-check-command beginning-of-defun-function python-beginning-of-defun end-of-defun-function python-end-of-defun add-hook which-func-functions python-which-func python-imenu-create-index eldoc-documentation-function python-eldoc-function eldoc-mode-hook #[nil "\300\301\302\"\207" [run-python nil t] 3] symbol-completion-symbol-function python-partial-symbol symbol-completion-completions-function python-symbol-completions add-to-list hs-special-modes-alist "^\\s-*\$?:def\\|class\$\\>" "#" #[(arg) "\300 \210\301\302x\207" [python-end-of-defun " 	\n" nil] 2] (nil) skeleton-further-elements ((< '(backward-delete-char-untabify (min python-indent (current-column)))) (^ '(- (1+ (current-indentation))))) tab-width local-abbrev-table mode-require-final-newline imenu-create-index-function font-lock-mode python-guess-indent python-indent indent-tabs-mode python-python-command python-command python-mode-running 8 1 python-find-imports boundp python-maybe-jython run-mode-hooks python-mode-hook] 8 (#$ . 72767) nil])
#@37 Hook run when entering Python mode.
(custom-declare-variable 'python-mode-hook 'nil '(#$ . 77389) :group 'python :type 'hook)
(byte-code "\302\303\304\"\210\302\303\305\"\210\302\303\306\"\210\302\303\307\"\210\302\303\310\"\210\311\312N\204%�\313\311\312\314#\210\315\316!\2041�\313\316\317\320#\210\316B\321\316!\204A�\322\316\323 \"\210\315\324!\204M�\313\324\317\320#\210\324B\321\324!\204]�\322\324\325 \"\210\313\301\317\320#\210\301B\321\301!\204w�\322\301\326\301\327\"\210	\"\210\313\320\330\331#\210\313\320\332\333#\207" [current-load-list jython-mode-abbrev-table custom-add-option python-mode-hook imenu-add-menubar-index #[nil "\301\211\207" [indent-tabs-mode nil] 2 "Turn off Indent Tabs mode."] turn-on-eldoc-mode abbrev-mode python-setup-brm jython-mode-hook variable-documentation put "Hook run when entering Jython mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp jython-mode-map definition-name jython-mode default-boundp set-default make-sparse-keymap jython-mode-syntax-table make-syntax-table define-abbrev-table nil derived-mode-parent python-mode custom-mode-group python] 5)
#@176 Major mode for editing Jython files.
Like `python-mode', but sets up parameters for Jython subprocesses.
Runs `jython-mode-hook' after `python-mode-hook'.

\{jython-mode-map}
(defalias 'jython-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203�\314\311\313\310\313N#\210\315!\204'�\316\317 \"\210\320\f!\211\2036�
\321 =\203<�\322\f\323 \"\210)\324!\210\325\f!\210\306\326!\210)\327\330!\207" [delay-mode-hooks major-mode mode-name jython-mode-map jython-mode-syntax-table parent make-local-variable t python-mode jython-mode "Jython" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table python-command run-mode-hooks jython-mode-hook jython-mode-abbrev-table local-abbrev-table python-jython-command] 6 (#$ . 78596) nil])
#@136 Watch output for Python prompt and exec next file waiting in queue.
This function is appropriate for `comint-output-filter-functions'.
(defalias 'python-comint-output-filter-function #[(string) "\303\230\204�G\304Y\2050�\305\306O\307\230\2050�	\2050�\306\310\311\217\210	A\211\2050�\312p!\313\n	@\")\207" [string python-file-queue pyproc ">>> " 5 -5 nil "\n>>> " (byte-code "\301@!\207" [python-file-queue delete-file] 2) ((error)) get-buffer-process python-execute-file] 4 (#$ . 79469)])
#@70 Activate or deactivate arrow at beginning-of-line in current buffer.
(defalias 'python-pdbtrack-overlay-arrow #[(activation) "\203�\304 \305\306	\212\307 \210`)p\223\207\310\211\211\207" [activation overlay-arrow-position overlay-arrow-string python-pdbtrack-is-tracking-p make-marker "=>" t beginning-of-line nil] 4 (#$ . 79971)])
#@697 Show the file indicated by the pdb stack entry line, in a separate window.

Activity is disabled if the buffer-local variable
`python-pdbtrack-do-tracking-p' is nil.

We depend on the pdb input prompt being a match for
`python-pdbtrack-input-prompt'.

If the traceback target file path is invalid, we look for the
most recently visited python-mode buffer which either has the
name of the current function or class, or which defines the
function or class.  This is to provide for scripts not in the
local filesytem (e.g., Zope's 'Script (Python)', but it's not
Zope specific).  If you put a copy of the script in a buffer
named for the script and activate python-mode, then pdbtrack will
find it.
(defalias 'python-pdbtrack-track-stack-file #[(text) "p\306!\211\203�\n\204�\307\310!\202\211�\311	!\f
Z]{\310\211\310\211\312\313P\"\204>�\307\310!\202\207�\314!\211;\203U�\307\310!\210\315\316\"\202\207�@\211A@)\317!\320!\210\321!\210\315\322#\210\307\323!\210\324\323\"\210b.*\207" [origbuf currproc python-pdbtrack-do-tracking-p procmark comint-last-input-end python-pdbtrack-track-range get-buffer-process python-pdbtrack-overlay-arrow nil process-mark string-match "$" python-pdbtrack-get-source-buffer message "pdbtrack: %s" buffer-file-name switch-to-buffer-other-window goto-line "pdbtrack: line %s, file %s" t pop-to-buffer block target target_fname target_lineno target_buffer python-pdbtrack-input-prompt x] 5 (#$ . 80317)])
#@335 Return line number and buffer of code indicated by block's traceback text.

We look first to visit the file indicated in the trace.

Failing that, we look for the most recently visited python-mode buffer
with the same name or having the named function.

If we're unable find the source code we return a string describing the
problem.
(defalias 'python-pdbtrack-get-source-buffer #[(block) "\306	\"\204	�\307\207\310\311	\"\312\310\313	\"!\310\314	\"\315\316\n!\203*�\317\n!D\202q�\320\f\"\211\203]�\306\321\n\"\203W�\212
q\210ed\232\203I�\322\202T�\323ee\306\324ed{\"]\")\\
D\202q�\n\322\234\325U\203l�\326\327\n\"\202q�\326\330\f\n#,\207" [python-pdbtrack-stack-entry-regexp block filename lineno funcname funcbuffer string-match "Traceback cue not found" match-string 1 string-to-number 2 3 nil file-exists-p find-file-noselect python-pdbtrack-grub-for-buffer "/Script (Python)$" 0 count-lines "^\$[^#]\\|#[^#]\\|#$\$" 60 format "(Non-file source: '%s')" "Not found: %s(), %s"] 8 (#$ . 81810)])
#@74 Find recent python-mode buffer named, or having function named funcname.
(defalias 'python-pdbtrack-grub-for-buffer #[(funcname lineno) "\305 \306\211\n\203?�\204?�\n@\nA\212	q\210\307\230)\203�\310\f\311	!\"\204:�\310\312\f\313Q\212	q\210ed{)\"\203�	\202�+\207" [got buf buffers major-mode funcname buffer-list nil "python-mode" string-match buffer-name "^\\s-*\$def\\|class\$\\s-+" "\\s-*("] 4 (#$ . 82826)])
#@363 Toggles between the CPython and JPython shells.

With positive argument ARG (interactively \[universal-argument]),
uses the CPython shell, with negative ARG uses the JPython shell, and
with a zero argument, toggles the shell.

Programmatically, ARG can also be one of the symbols `cpython' or
`jpython', equivalent to positive arg and negative arg respectively.
(defalias 'python-toggle-shells #[(arg) "\204�\306\306\232\203�	\307\230\203�\310\202/�\311\202/�\312\232\203'�\311\202/�\313\232\203/�\310\314\306W\203F�
\307\315\307\202Z�\306V\203Z�\316\211\316\317\320\n\")\207" [arg python-which-bufname msg python-python-command python-which-shell python-python-command-args 0 "Python" -1 1 cpython jpython nil "CPython" "JPython" message "Using the %s shell" python-which-args mode-name python-jython-command python-jython-command-args] 4 (#$ . 83258) "P"])
#@227 Send to Python interpreter process PROC "execfile('FILENAME')".
Make that process's buffer visible and force display.  Also make
comint believe the user typed this string so that
`kill-output-from-shell' does The Right Thing.
(defalias 'python-execute-file #[(proc filename) "p\306!\307\310	\"\307\311	\"\312\216\212\fq\210db\210\313!`\314\223\210\315!\"\210*\316\n\",\207" [proc filename cmd msg procbuf curbuf process-buffer format "## working on region in file %s...\n" "execfile(r'%s') # PYTHON-MODE\n" ((set-buffer curbuf)) process-mark nil process-filter process-send-string] 6 (#$ . 84158)])
#@1999 Start an interactive Python interpreter in another window.
This is like Shell mode, except that Python is running in the window
instead of a shell.  See the `Interactive Shell' and `Shell Mode'
sections of the Emacs manual for details, especially for the key
bindings active in the `*Python*' buffer.

With optional \[universal-argument], the user is prompted for the
flags to pass to the Python interpreter.  This has no effect when this
command is used to switch to an existing process, only when a new
process is started.  If you use this, you will probably want to ensure
that the current arguments are retained (they will be included in the
prompt).  This argument is ignored when this function is called
programmatically, or when running in Emacs 19.34 or older.

Note: You can toggle between using the CPython interpreter and the
JPython interpreter by hitting \[python-toggle-shells].  This toggles
buffer local variables which control whether all your subshell
interactions happen to the `*JPython*' or `*Python*' buffers (the
latter is the name used for the CPython buffer).

Warning: Don't use an interactive Python if you change sys.ps1 or
sys.ps2 from their default values, or if you're running code that
prints `>>> ' or `... ' at the start of a line.  `python-mode' can't
distinguish your output from Python's output, and assumes that `>>> '
at the start of a line is a prompt from Python.  Similarly, the Emacs
Shell mode code assumes that both `>>> ' and `... ' at the start of a
line are Python prompts.  Bad things can happen if you fool either
mode.

Warning:  If you do any editing *in* the process buffer *while* the
buffer is accepting output from Python, do NOT attempt to `undo' the
changes.  Some of the output (nowhere near the parts you changed!) may
be lost if you do.  This appears to be an Emacs bug, an unfortunate
interaction between undo and process filters; the same problem exists in
non-Python process buffers using the default (Emacs-supplied) process
filter.
(defalias 'python-shell #[(&optional argprompt) "\204�\306	!\210\n\f\203'�t\203'�\307\310!\203'�\310\311
\312P\313\314\n\315#\315P\"!\316\317\320
\321%!\210\322\323!\210\324\325p!\326\"\210\327\330\331\332\321\333$\210\334!\210\335!)\207" [python-which-shell python-default-interpreter python-which-args args argprompt python-which-bufname python-toggle-shells fboundp split-string read-string " arguments: " mapconcat identity " " switch-to-buffer-other-window apply make-comint nil make-local-variable comint-prompt-regexp set-process-sentinel get-buffer-process python-sentinel "^>>> \\|^[.][.][.] \\|^(pdb) " add-hook comint-output-filter-functions python-comint-output-filter-function t set-syntax-table use-local-map python-mode-syntax-table python-shell-map] 7 (#$ . 84775) "P"])
(defalias 'python-pdbtrack-toggle-stack-tracking #[(arg) "\302p!\204�\303\304p\"\210\203�\305\306!\211!\203�	?\202#�\307V\310\311	\203-�\312\202.�\313\"\207" [arg python-pdbtrack-do-tracking-p get-buffer-process error "No process associated with buffer '%s'" zerop prefix-numeric-value 0 message "%sabled Python's pdbtrack" "En" "Dis"] 3 nil "P"])
(defalias 'turn-on-pdbtrack #[nil "\300\301!\207" [python-pdbtrack-toggle-stack-tracking 1] 2 nil nil])
(defalias 'turn-off-pdbtrack #[nil "\300\301!\207" [python-pdbtrack-toggle-stack-tracking 0] 2 nil nil])
(defalias 'python-sentinel #[(proc msg) "\301\211\207" [overlay-arrow-position nil] 2])
(byte-code "\300\301!\210\300\302!\207" [provide python python-21] 2)

${this.title}

Code Editor : python.elc