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 : cperl-mode.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:05:05 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/progmodes/cperl-mode.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 "`cperl-mode.el' was compiled for Emacs 19.29 or later"))

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

(byte-code "\303B\304\303!\204�\305\303\306\302!\205�	\206�\n\307V\"\210\303\207" [current-load-list window-system emacs-major-version cperl-can-font-lock default-boundp set-default boundp 20] 4)
(defalias 'cperl-choose-color #[(&rest list) "\302	\203 �\204�\303	@!\204�	A\204�	@	A\211\204�)\207" [answer list nil x-color-defined-p] 3])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\302\313\304\305\306\301&\210\300\314\302\315\304\305\306\301&\210\300\316\302\317\304\305\306\301&\210\300\320\302\321\322\323\304\305\306\301&	\210\300\324\302\325\304\305\306\301&\210\300\326\302\327\304\305\306\301&\207" [custom-declare-group cperl nil "Major mode for editing Perl code." :prefix "cperl-" :group languages :version "20.3" cperl-indentation-details "Indentation." cperl-affected-by-hairy "Variables affected by `cperl-hairy'." cperl-autoinsert-details "Auto-insert tuneup." cperl-faces "Fontification colors." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) cperl-speed "Speed vs. validity tuneup." cperl-help-system "Help system tuneup."] 10)
#@134 *Non-nil means that if, elsif, while, until, else, for, foreach
and do constructs look like:

if ()
	{
	}

instead of:

if () {
	}
(custom-declare-variable 'cperl-extra-newline-before-brace 'nil '(#$ . -1731) :type 'boolean :group 'cperl-autoinsert-details)
#@143 *Non-nil means the same as `cperl-extra-newline-before-brace', but
for constructs with multiline if/unless/while/until/for/foreach condition.
(custom-declare-variable 'cperl-extra-newline-before-brace-multiline 'cperl-extra-newline-before-brace '(#$ . -1998) :type 'boolean :group 'cperl-autoinsert-details)
#@68 *Indentation of CPerl statements with respect to containing block.
(custom-declare-variable 'cperl-indent-level '2 '(#$ . -2312) :type 'integer :group 'cperl-indentation-details)
#@120 *`cperl-lineup' will always lineup at multiple of this number.
If nil, the value of `cperl-indent-level' will be used.
(custom-declare-variable 'cperl-lineup-step 'nil '(#$ . -2498) :type '(choice (const nil) integer) :group 'cperl-indentation-details)
#@187 *Imagined indentation of a Perl open brace that actually follows a statement.
An open brace following other text is treated as if it were this far
to the right of the start of its line.
(custom-declare-variable 'cperl-brace-imaginary-offset '0 '(#$ . -2758) :type 'integer :group 'cperl-indentation-details)
#@74 *Extra indentation for braces, compared with other text in same context.
(custom-declare-variable 'cperl-brace-offset '0 '(#$ . -3072) :type 'integer :group 'cperl-indentation-details)
#@61 *Offset of CPerl label lines relative to usual indentation.
(custom-declare-variable 'cperl-label-offset '-2 '(#$ . -3263) :type 'integer :group 'cperl-indentation-details)
#@39 *Minimal offset of CPerl label lines.
(custom-declare-variable 'cperl-min-label-indent '1 '(#$ . -3442) :type 'integer :group 'cperl-indentation-details)
#@54 *Extra indent for lines not starting new statements.
(custom-declare-variable 'cperl-continued-statement-offset '2 '(#$ . -3602) :type 'integer :group 'cperl-indentation-details)
#@119 *Extra indent for substatements that start with open-braces.
This is in addition to cperl-continued-statement-offset.
(custom-declare-variable 'cperl-continued-brace-offset '0 '(#$ . -3788) :type 'integer :group 'cperl-indentation-details)
#@68 *Extra indent for substatements that start with close-parenthesis.
(custom-declare-variable 'cperl-close-paren-offset '-1 '(#$ . -4034) :type 'integer :group 'cperl-indentation-details)
#@131 *Non-nil means indent statements in if/etc block relative brace, not if/etc.
Versions 5.2 ... 5.20 behaved as if this were `nil'.
(custom-declare-variable 'cperl-indent-wrt-brace 't '(#$ . -4227) :type 'boolean :group 'cperl-indentation-details)
#@293 *Non-nil means automatically newline before and after braces,
and after colons and semicolons, inserted in CPerl code.  The following
\[cperl-electric-backspace] will remove the inserted whitespace.
Insertion after colons requires both this variable and
`cperl-auto-newline-after-colon' set.
(custom-declare-variable 'cperl-auto-newline 'nil '(#$ . -4480) :type 'boolean :group 'cperl-autoinsert-details)
#@110 *Non-nil means automatically indent after insertion of (semi)colon.
Active if `cperl-auto-newline' is false.
(custom-declare-variable 'cperl-autoindent-on-semi 'nil '(#$ . -4892) :type 'boolean :group 'cperl-autoinsert-details)
#@98 *Non-nil means automatically newline even after colons.
Subject to `cperl-auto-newline' setting.
(custom-declare-variable 'cperl-auto-newline-after-colon 'nil '(#$ . -5126) :type 'boolean :group 'cperl-autoinsert-details)
#@146 *Non-nil means TAB in CPerl mode should always reindent the current line,
regardless of where in the line point is when the TAB command is used.
(custom-declare-variable 'cperl-tab-always-indent 't '(#$ . -5355) :type 'boolean :group 'cperl-indentation-details)
#@116 *Non-nil (and non-null) means CPerl buffers will use `font-lock-mode'.
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-font-lock 'nil '(#$ . -5624) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@112 *Non-nil (and non-null) means { after $ should be preceded by ` '.
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-electric-lbrace-space 'nil '(#$ . -5877) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@119 *String of parentheses that should be electric in CPerl.
Closing ones are electric only if the region is highlighted.
(custom-declare-variable 'cperl-electric-parens-string '"({[]})<" '(#$ . -6138) :type 'string :group 'cperl-affected-by-hairy)
#@116 *Non-nil (and non-null) means parentheses should be electric in CPerl.
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-electric-parens 'nil '(#$ . -6390) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@111 *Not-nil means that electric parens look for active mark.
Default is yes if there is visual feedback on mark.
(custom-declare-variable 'cperl-electric-parens-mark '(and window-system (or (and (boundp 'transient-mark-mode) transient-mark-mode) (and (boundp 'zmacs-regions) zmacs-regions))) '(#$ . -6649) :type 'boolean :group 'cperl-autoinsert-details)
#@176 *If true, LFD should be hairy in CPerl, otherwise C-c LFD is hairy.
In any case these two mean plain and hairy linefeeds together.
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-electric-linefeed 'nil '(#$ . -7008) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@457 *Not-nil (and non-null) means keywords are electric in CPerl.
Can be overwritten by `cperl-hairy' if nil.

Uses `abbrev-mode' to do the expansion.  If you want to use your
own abbrevs in cperl-mode, but do not want keywords to be
electric, you must redefine `cperl-mode-abbrev-table': do
\[edit-abbrevs], search for `cperl-mode-abbrev-table', and, in
that paragraph, delete the words that appear at the ends of lines and
that begin with "cperl-electric".

(custom-declare-variable 'cperl-electric-keywords 'nil '(#$ . -7329) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@59 *Not-nil means electric-backspace will untabify in CPerl.
(custom-declare-variable 'cperl-electric-backspace-untabify 't '(#$ . -7930) :type 'boolean :group 'cperl-autoinsert-details)
#@297 *Not-nil means most of the bells and whistles are enabled in CPerl.
Affects: `cperl-font-lock', `cperl-electric-lbrace-space',
`cperl-electric-parens', `cperl-electric-linefeed', `cperl-electric-keywords',
`cperl-info-on-command-no-prompt', `cperl-clobber-lisp-bindings',
`cperl-lazy-help-time'.
(custom-declare-variable 'cperl-hairy 'nil '(#$ . -8121) :type 'boolean :group 'cperl-affected-by-hairy)
#@77 *Column to put comments in CPerl (use \[cperl-indent] to lineup with code).
(custom-declare-variable 'cperl-comment-column '32 '(#$ . -8528) :type 'integer :group 'cperl-indentation-details)
#@71 *Non-nil means that comment started at column 0 should be indentable.
(custom-declare-variable 'cperl-indent-comment-at-column-0 'nil '(#$ . -8725) :type 'boolean :group 'cperl-indentation-details)
#@74 *Special version of `vc-sccs-header' that is used in CPerl mode buffers.
(custom-declare-variable 'cperl-vc-sccs-header ''("($sccs) = ('%W%' =~ /(\\d+(\\.\\d+)+)/) ;") '(#$ . -8929) :type '(repeat string) :group 'cperl)
#@73 *Special version of `vc-rcs-header' that is used in CPerl mode buffers.
(custom-declare-variable 'cperl-vc-rcs-header ''("($rcs) = (' $Id$ ' =~ /(\\d+(\\.\\d+)+)/);") '(#$ . -9155) :type '(repeat string) :group 'cperl)
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305\301\306\"\207" [current-load-list cperl-vc-header-alist default-boundp set-default nil make-obsolete-variable "use cperl-vc-rcs-header or cperl-vc-sccs-header instead."] 3)
#@72 *Whether to install us into `interpreter-' and `extension' mode lists.
(custom-declare-variable 'cperl-clobber-mode-lists '(not (and (boundp 'interpreter-mode-alist) (assoc "miniperl" interpreter-mode-alist) (assoc "\\.\$[pP][Llm]\\|al\$$" auto-mode-alist))) '(#$ . -9610) :type 'boolean :group 'cperl)
#@163 *Not-nil (and non-null) means not to prompt on C-h f.
The opposite behavior is always available if prefixed with C-c.
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-info-on-command-no-prompt 'nil '(#$ . -9922) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@170 *Not-nil (and non-null) means not overwrite C-h f.
The function is available on \[cperl-info-on-command], \[cperl-get-help].
Can be overwritten by `cperl-hairy' if nil.
(custom-declare-variable 'cperl-clobber-lisp-bindings 'nil '(#$ . -10238) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy)
#@128 *Not-nil (and non-null) means to show lazy help after given idle time.
Can be overwritten by `cperl-hairy' to be 5 sec if nil.
(custom-declare-variable 'cperl-lazy-help-time 'nil '(#$ . -10558) :type '(choice (const null) (const nil) integer) :group 'cperl-affected-by-hairy)
#@29 *Face for POD highlighting.
(custom-declare-variable 'cperl-pod-face ''font-lock-comment-face '(#$ . -10840) :type 'face :group 'cperl-faces)
#@51 *Face for POD highlighting.
Font for POD headers.
(custom-declare-variable 'cperl-pod-head-face ''font-lock-variable-name-face '(#$ . -10988) :type 'face :group 'cperl-faces)
#@35 *Face for here-docs highlighting.
(custom-declare-variable 'cperl-here-face ''font-lock-string-face '(#$ . -11169) :type 'face :group 'cperl-faces)
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list cperl-singly-quote-face default-boundp set-default nil] 3)
#@45 *Face for highlighting trailing whitespace.
(custom-declare-variable 'cperl-invalid-face ''underline '(#$ . -11463) :type 'face :version "21.1" :group 'cperl-faces)
#@74 *Not-nil after evaluation means to highlight POD and here-docs sections.
(custom-declare-variable 'cperl-pod-here-fontify ''(featurep 'font-lock) '(#$ . -11634) :type 'boolean :group 'cperl-faces)
#@75 *Not-nil means highlight 1arg regular expressions operators same as 2arg.
(custom-declare-variable 'cperl-fontify-m-as-s 't '(#$ . -11837) :type 'boolean :group 'cperl-faces)
#@313 *Non-nil means perform additional highlighting on variables.
Currently only changes how scalar variables are highlighted.
Note that that variable is only read at initialization time for
the variable `cperl-font-lock-keywords-2', so changing it after you've
entered CPerl mode the first time will have no effect.
(custom-declare-variable 'cperl-highlight-variables-indiscriminately 'nil '(#$ . -12019) :type 'boolean :group 'cperl)
#@140 *Not-nil means look for POD and here-docs sections during startup.
You can always make lookup from menu or using \[cperl-find-pods-heres].
(custom-declare-variable 'cperl-pod-here-scan 't '(#$ . -12457) :type 'boolean :group 'cperl-speed)
#@109 *Not-nil means make marking of regular expression more thorough.
Effective only with `cperl-pod-here-scan'.
(custom-declare-variable 'cperl-regexp-scan 't '(#$ . -12703) :type 'boolean :group 'cperl-speed)
#@159 *Not-nil means install hook to know which regions of buffer are changed.
May significantly speed up delayed fontification.  Changes take effect
after reload.
(custom-declare-variable 'cperl-hook-after-change 't '(#$ . -12916) :type 'boolean :group 'cperl-speed)
#@113 *Not-nil means add backreferences to generated `imenu's.
May require patched `imenu' and `imenu-go'.  Obsolete.
(custom-declare-variable 'cperl-imenu-addback 'nil '(#$ . -13185) :type 'boolean :group 'cperl-help-system)
#@77 *Non-nil means shrink-wrapping of info-buffer allowed up to these percents.
(custom-declare-variable 'cperl-max-help-size '66 '(#$ . -13411) :type '(choice integer (const nil)) :group 'cperl-help-system)
#@62 *Non-nil means shrink-wrapping of info-buffer-frame allowed.
(custom-declare-variable 'cperl-shrink-wrap-info-frame 't '(#$ . -13621) :type 'boolean :group 'cperl-help-system)
#@107 *Name of the info page containing perl docs.
Older version of this page was called `perl5', newer `perl'.
(custom-declare-variable 'cperl-info-page '"perl" '(#$ . -13804) :type 'string :group 'cperl-help-system)
#@69 *Non-nil means CPerl sets up and uses `syntax-table' text property.
(custom-declare-variable 'cperl-use-syntax-table-text-property '(boundp 'parse-sexp-lookup-properties) '(#$ . -14022) :type 'boolean :group 'cperl-speed)
#@78 *Non-nil means: set up and use `syntax-table' text property generating TAGS.
(custom-declare-variable 'cperl-use-syntax-table-text-property-for-tags 'cperl-use-syntax-table-text-property '(#$ . -14250) :type 'boolean :group 'cperl-speed)
#@54 *Regexp to match files to scan when generating TAGS.
(custom-declare-variable 'cperl-scan-files-regexp '"\\.\$[pP][Llm]\\|xs\$$" '(#$ . -14494) :type 'regexp :group 'cperl)
#@59 *Regexp to match files/dirs to skip when generating TAGS.
(custom-declare-variable 'cperl-noscan-files-regexp '"/\$\\.\\.?\\|SCCS\\|RCS\\|CVS\\|blib\$$" '(#$ . -14675) :type 'regexp :group 'cperl)
#@101 *Indentation used when beautifying regexps.
If nil, the value of `cperl-indent-level' will be used.
(custom-declare-variable 'cperl-regexp-indent-step 'nil '(#$ . -14881) :type '(choice integer (const nil)) :group 'cperl-indentation-details)
#@76 *Non-nil means that the comment starting in leftmost column should indent.
(custom-declare-variable 'cperl-indent-left-aligned-comments 't '(#$ . -15129) :type 'boolean :group 'cperl-indentation-details)
#@71 *Non-nil means that the _ (underline) should be treated as word char.
(custom-declare-variable 'cperl-under-as-char 'nil '(#$ . -15339) :type 'boolean :group 'cperl)
#@92 *Extra arguments to use when starting Perl.
Currently used with `cperl-check-syntax' only.
(custom-declare-variable 'cperl-extra-perl-args '"" '(#$ . -15511) :type 'string :group 'cperl)
#@73 *Non-nil means that the `cperl-electric-keyword' prints a help message.
(custom-declare-variable 'cperl-message-electric-keyword 't '(#$ . -15704) :type 'boolean :group 'cperl-help-system)
#@169 *Amount of space to insert between `}' and `else' or `elsif'
in `cperl-indent-region'.  Set to nil to leave as is.  Values other
than 1 and nil will probably not work.
(custom-declare-variable 'cperl-indent-region-fix-constructs '1 '(#$ . -15900) :type '(choice (const nil) (const 1)) :group 'cperl-indentation-details)
#@139 *Non-nil means that one-line if/unless/while/until/for/foreach BLOCKs
need to be reformatted into multiline ones when indenting a region.
(custom-declare-variable 'cperl-break-one-line-blocks-when-indent 't '(#$ . -16227) :type 'boolean :group 'cperl-indentation-details)
#@146 *Non-nil means that BLOCK-end `}' may be put on a separate line
when indenting a region.
Braces followed by else/elsif/while/until are excepted.
(custom-declare-variable 'cperl-fix-hanging-brace-when-indent 't '(#$ . -16506) :type 'boolean :group 'cperl-indentation-details)
#@129 *Non-nil means that BLOCK-end `}' followed by else/elsif/continue
may be merged to be on the same line when indenting a region.
(custom-declare-variable 'cperl-merge-trailing-else 't '(#$ . -16788) :type 'boolean :group 'cperl-indentation-details)
#@206 *Non-nil means that non-block ()-, {}- and []-groups are indented as blocks,
but for trailing "," inside the group, which won't increase indentation.
One should tune up `cperl-close-paren-offset' as well.
(custom-declare-variable 'cperl-indent-parens-as-block 'nil '(#$ . -17043) :type 'boolean :group 'cperl-indentation-details)
#@75 *Non-nil means that CPerl uses `font-lock's routines for syntaxification.
(custom-declare-variable 'cperl-syntaxify-by-font-lock '(and cperl-can-font-lock (boundp 'parse-sexp-lookup-properties)) '(#$ . -17379) :type '(choice (const message) boolean) :group 'cperl-speed)
#@106 *Non-nil means that CPerl unwinds to a start of a long construction
when syntaxifying a chunk of buffer.
(custom-declare-variable 'cperl-syntaxify-unwind 't '(#$ . -17657) :type 'boolean :group 'cperl-speed)
#@135 *Non-nil means that CPerl syntaxifies up to the point before showing menu.
This way enabling/disabling of menu items is more correct.
(custom-declare-variable 'cperl-syntaxify-for-menu 't '(#$ . -17872) :type 'boolean :group 'cperl-speed)
#@73 List given as an argument to `ps-extend-face-list' in `cperl-ps-print'.
(custom-declare-variable 'cperl-ps-print-face-properties ''((font-lock-keyword-face nil nil bold shadow) (font-lock-variable-name-face nil nil bold) (font-lock-function-name-face nil nil bold italic box) (font-lock-constant-face nil "LightGray" bold) (cperl-array-face nil "LightGray" bold underline) (cperl-hash-face nil "LightGray" bold italic underline) (font-lock-comment-face nil "LightGray" italic) (font-lock-string-face nil nil italic underline) (cperl-nonoverridable-face nil nil italic underline) (font-lock-type-face nil nil underline) (font-lock-warning-face nil "LightGray" bold italic box) (underline nil "LightGray" strikeout)) '(#$ . 18117) :type '(repeat (cons symbol (cons (choice (const nil) string) (cons (choice (const nil) string) (repeat symbol))))) :group 'cperl-faces)
(byte-code "\302B\303\302!\204�\304\302\305\306\307\310#\"\210\301B\303\301!\204%�\304\301\305\311\312\"\"\210\313\314\315\316\317\320\321	DD\322BBBB\323\324\325%\210\313\326\327\330\331\332\321\333\334\n\335BBBBD\336BBBB\337\324\325%\210\313\340\341\342\343\344\321\345\334\n\346BBBBD\347BBBB\350\324\325%\207" [current-load-list cperl-dark-foreground cperl-dark-background default-boundp set-default cperl-choose-color "navy" "os2blue" "darkgreen" "orchid1" "orange" custom-declare-face cperl-nonoverridable-face (((class grayscale) (background light)) (:background "Gray90" :slant italic :underline t)) (((class grayscale) (background dark)) (:foreground "Gray80" :slant italic :underline t :weight bold)) (((class color) (background light)) (:foreground "chartreuse3")) ((class color) (background dark)) :foreground ((t (:weight bold :underline t))) "Font Lock mode face used non-overridable keywords and modifiers of regexps." :group cperl-faces cperl-array-face (((class grayscale) (background light)) (:background "Gray90" :weight bold)) (((class grayscale) (background dark)) (:foreground "Gray80" :weight bold)) (((class color) (background light)) (:foreground "Blue" :background "lightyellow2" :weight bold)) ((class color) (background dark)) "yellow" :background (:weight bold) ((t (:weight bold))) "Font Lock mode face used to highlight array names." cperl-hash-face (((class grayscale) (background light)) (:background "Gray90" :weight bold :slant italic)) (((class grayscale) (background dark)) (:foreground "Gray80" :weight bold :slant italic)) (((class color) (background light)) (:foreground "Red" :background "lightyellow2" :weight bold :slant italic)) ((class color) (background dark)) "Red" (:weight bold :slant italic) ((t (:weight bold :slant italic))) "Font Lock mode face used to highlight hash names."] 11)
#@2206 Get maybe newer version of this package from
  http://ilyaz.org/software/emacs
Subdirectory `cperl-mode' may contain yet newer development releases and/or
patches to related files.

For best results apply to an older Emacs the patches from
  ftp://ftp.math.ohio-state.edu/pub/users/ilya/cperl-mode/patches
(this upgrades syntax-parsing abilities of Emacsen v19.34 and
v20.2 up to the level of Emacs v20.3 - a must for a good Perl
mode.)  As of beginning of 2003, XEmacs may provide a similar ability.

Get support packages choose-color.el (or font-lock-extra.el before
19.30), imenu-go.el from the same place.  (Look for other files there
too... ;-).  Get a patch for imenu.el in 19.29.  Note that for 19.30 and
later you should use choose-color.el *instead* of font-lock-extra.el
(and you will not get smart highlighting in C :-().

Note that to enable Compile choices in the menu you need to install
mode-compile.el.

If your Emacs does not default to `cperl-mode' on Perl files, and you
want it to: put the following into your .emacs file:

(defalias 'perl-mode 'cperl-mode)

Get perl5-info from
  $CPAN/doc/manual/info/perl5-old/perl5-info.tar.gz
Also, one can generate a newer documentation running `pod2texi' converter
  $CPAN/doc/manual/info/perl5/pod2texi-0.1.tar.gz

If you use imenu-go, run imenu on perl5-info buffer (you can do it
from Perl menu).  If many files are related, generate TAGS files from
Tools/Tags submenu in Perl menu.

If some class structure is too complicated, use Tools/Hierarchy-view
from Perl menu, or hierarchic view of imenu.  The second one uses the
current buffer only, the first one requires generation of TAGS from
Perl/Tools/Tags menu beforehand.

Run Perl/Tools/Insert-spaces-if-needed to fix your lazy typing.

Switch auto-help on/off with Perl/Tools/Auto-help.

Though with contemporary Emaxen CPerl mode should maintain the correct
parsing of Perl even when editing, sometimes it may be lost.  Fix this by

\[normal-mode]

In cases of more severe confusion sometimes it is helpful to do

\[load-library] cperl-mode RET
  \[normal-mode]

Before reporting (non-)problems look in the problem section of online
micro-docs on what I know about CPerl problems.
(defvar cperl-tips 'please-ignore-this-line (#$ . 20828))
#@535 Description of problems in CPerl mode.
Some faces will not be shown on some versions of Emacs unless you
install choose-color.el, available from
  http://ilyaz.org/software/emacs

`fill-paragraph' on a comment may leave the point behind the
paragraph.  It also triggers a bug in some versions of Emacs (CPerl tries
to detect it and bulk out).

See documentation of a variable `cperl-problems-old-emaxen' for the
problems which disappear if you upgrade Emacs to a reasonably new
version (20.3 for Emacs, and those of 2004 for XEmacs).
(defvar cperl-problems 'please-ignore-this-line (#$ . 23098))
#@2110 Description of problems in CPerl mode specific for older Emacs versions.

Emacs had a _very_ restricted syntax parsing engine until version
20.1.  Most problems below are corrected starting from this version of
Emacs, and all of them should be fixed in version 20.3.  (Or apply
patches to Emacs 19.33/34 - see tips.)  XEmacs was very backward in
this respect (until 2003).

Note that even with newer Emacsen in some very rare cases the details
of interaction of `font-lock' and syntaxification may be not cleaned
up yet.  You may get slightly different colors basing on the order of
fontification and syntaxification.  Say, the initial faces is correct,
but editing the buffer breaks this.

Even with older Emacsen CPerl mode tries to corrects some Emacs
misunderstandings, however, for efficiency reasons the degree of
correction is different for different operations.  The partially
corrected problems are: POD sections, here-documents, regexps.  The
operations are: highlighting, indentation, electric keywords, electric
braces.

This may be confusing, since the regexp s#//#/#; may be highlighted
as a comment, but it will be recognized as a regexp by the indentation
code.  Or the opposite case, when a POD section is highlighted, but
may break the indentation of the following code (though indentation
should work if the balance of delimiters is not broken by POD).

The main trick (to make $ a "backslash") makes constructions like
${aaa} look like unbalanced braces.  The only trick I can think of is
to insert it as $ {aaa} (valid in perl5, not in perl4).

Similar problems arise in regexps, when /(\s|$)/ should be rewritten
as /($|\s)/.  Note that such a transposition is not always possible.

The solution is to upgrade your Emacs or patch an older one.  Note
that Emacs 20.2 has some bugs related to `syntax-table' text
properties.  Patches are available on the main CPerl download site,
and on CPAN.

If these bugs cannot be fixed on your machine (say, you have an inferior
environment and cannot recompile), you may still disable all the fancy stuff
via `cperl-use-syntax-table-text-property'.
(defvar cperl-problems-old-emaxen 'please-ignore-this-line (#$ . 23702))
#@4338 Advantages of CPerl mode.

0) It uses the newest `syntax-table' property ;-);

1) It does 99% of Perl syntax correct (as opposed to 80-90% in Perl
mode - but the latter number may have improved too in last years) even
with old Emaxen which do not support `syntax-table' property.

When using `syntax-table' property for syntax assist hints, it should
handle 99.995% of lines correct - or somesuch.  It automatically
updates syntax assist hints when you edit your script.

2) It is generally believed to be "the most user-friendly Emacs
package" whatever it may mean (I doubt that the people who say similar
things tried _all_ the rest of Emacs ;-), but this was not a lonely
voice);

3) Everything is customizable, one-by-one or in a big sweep;

4) It has many easily-accessible "tools":
        a) Can run program, check syntax, start debugger;
        b) Can lineup vertically "middles" of rows, like `=' in
                a  = b;
                cc = d;
        c) Can insert spaces where this impoves readability (in one
                interactive sweep over the buffer);
        d) Has support for imenu, including:
                1) Separate unordered list of "interesting places";
                2) Separate TOC of POD sections;
                3) Separate list of packages;
                4) Hierarchical view of methods in (sub)packages;
                5) and functions (by the full name - with package);
        e) Has an interface to INFO docs for Perl; The interface is
                very flexible, including shrink-wrapping of
                documentation buffer/frame;
        f) Has a builtin list of one-line explanations for perl constructs.
        g) Can show these explanations if you stay long enough at the
                corresponding place (or on demand);
        h) Has an enhanced fontification (using 3 or 4 additional faces
                comparing to font-lock - basically, different
                namespaces in Perl have different colors);
        i) Can construct TAGS basing on its knowledge of Perl syntax,
                the standard menu has 6 different way to generate
                TAGS (if "by directory", .xs files - with C-language
                bindings - are included in the scan);
        j) Can build a hierarchical view of classes (via imenu) basing
                on generated TAGS file;
        k) Has electric parentheses, electric newlines, uses Abbrev
                for electric logical constructs
                        while () {}
                with different styles of expansion (context sensitive
                to be not so bothering).  Electric parentheses behave
                "as they should" in a presence of a visible region.
        l) Changes msb.el "on the fly" to insert a group "Perl files";
        m) Can convert from
		if (A) { B }
	   to
		B if A;

n) Highlights (by user-choice) either 3-delimiters constructs
	   (such as tr/a/b/), or regular expressions and `y/tr';
	o) Highlights trailing whitespace;
	p) Is able to manipulate Perl Regular Expressions to ease
	   conversion to a more readable form.
        q) Can ispell POD sections and HERE-DOCs.
	r) Understands comments and character classes inside regular
	   expressions; can find matching () and [] in a regular expression.
	s) Allows indentation of //x-style regular expressions;
	t) Highlights different symbols in regular expressions according
	   to their function; much less problems with backslashitis;
	u) Allows to find regular expressions which contain interpolated parts.

5) The indentation engine was very smart, but most of tricks may be
not needed anymore with the support for `syntax-table' property.  Has
progress indicator for indentation (with `imenu' loaded).

6) Indent-region improves inline-comments as well; also corrects
whitespace *inside* the conditional/loop constructs.

7) Fill-paragraph correctly handles multi-line comments;

8) Can switch to different indentation styles by one command, and restore
the settings present before the switch.

9) When doing indentation of control constructs, may correct
line-breaks/spacing between elements of the construct.

10) Uses a linear-time algorith for indentation of regions (on Emaxen with
capable syntax engines).

11) Syntax-highlight, indentation, sexp-recognition inside regular expressions.

(defvar cperl-praise 'please-ignore-this-line (#$ . 25892))
#@1833 This is an incomplete compendium of what is available in other parts
of CPerl documentation.  (Please inform me if I skept anything.)

There is a perception that CPerl is slower than alternatives.  This part
of documentation is designed to overcome this misconception.

*By default* CPerl tries to enable the most comfortable settings.
From most points of view, correctly working package is infinitely more
comfortable than a non-correctly working one, thus by default CPerl
prefers correctness over speed.  Below is the guide how to change
settings if your preferences are different.

A)  Speed of loading the file.  When loading file, CPerl may perform a
scan which indicates places which cannot be parsed by primitive Emacs
syntax-parsing routines, and marks them up so that either

A1) CPerl may work around these deficiencies (for big chunks, mostly
        PODs and HERE-documents), or
    A2) On capable Emaxen CPerl will use improved syntax-handlings
	which reads mark-up hints directly.

The scan in case A2 is much more comprehensive, thus may be slower.

User can disable syntax-engine-helping scan of A2 by setting
       `cperl-use-syntax-table-text-property'
    variable to nil (if it is set to t).

One can disable the scan altogether (both A1 and A2) by setting
       `cperl-pod-here-scan'
    to nil.

B) Speed of editing operations.

One can add a (minor) speedup to editing operations by setting
       `cperl-use-syntax-table-text-property'
    variable to nil (if it is set to t).  This will disable
    syntax-engine-helping scan, thus will make many more Perl
    constructs be wrongly recognized by CPerl, thus may lead to
    wrongly matched parentheses, wrong indentation, etc.

One can unset `cperl-syntaxify-unwind'.  This might speed up editing
    of, say, long POD sections.
(defvar cperl-speed 'please-ignore-this-line (#$ . 30297))
#@2483 CPerl mode uses following faces for highlighting:

`cperl-array-face'			Array names
  `cperl-hash-face'			Hash names
  `font-lock-comment-face'	Comments, PODs and whatever is considered
				syntaxically to be not code
  `font-lock-constant-face'	HERE-doc delimiters, labels, delimiters of
				2-arg operators s/y/tr/ or of RExen,
  `font-lock-warning-face'	Special-cased m// and s//foo/,
  `font-lock-function-name-face' _ as a target of a file tests, file tests,
				subroutine names at the moment of definition
				(except those conflicting with Perl operators),
				package names (when recognized), format names
  `font-lock-keyword-face'	Control flow switch constructs, declarators
  `cperl-nonoverridable-face'	Non-overridable keywords, modifiers of RExen
  `font-lock-string-face'	Strings, qw() constructs, RExen, POD sections,
				literal parts and the terminator of formats
				and whatever is syntaxically considered
				as string literals
  `font-lock-type-face'		Overridable keywords
  `font-lock-variable-name-face' Variable declarations, indirect array and
				hash names, POD headers/item names
  `cperl-invalid'		Trailing whitespace

Note that in several situations the highlighting tries to inform about
possible confusion, such as different colors for function names in
declarations depending on what they (do not) override, or special cases
m// and s/// which do not do what one would expect them to do.

Help with best setup of these faces for printout requested (for each of
the faces: please specify bold, italic, underline, shadow and box.)

In regular expressions (except character classes):
  `font-lock-string-face'	"Normal" stuff and non-0-length constructs
  `font-lock-constant-face':	Delimiters
  `font-lock-warning-face'	Special-cased m// and s//foo/,
				Mismatched closing delimiters, parens
				we couldn't match, misplaced quantifiers,
				unrecognized escape sequences
  `cperl-nonoverridable-face'	Modifiers, as gism in m/REx/gism
  `font-lock-type-face'		POSIX classes inside charclasses,
				escape sequences with arguments (0  p N)
				and others match-a-char escape sequences
  `font-lock-keyword-face'	Capturing parens, and |
  `font-lock-function-name-face' Special symbols: $ ^ . [ ] [^ ] (?{ }) (??{ })
  `font-lock-builtin-face'	"Remaining" 0-length constructs, executable
				parts of a REx, not-capturing parens
  `font-lock-variable-name-face' Interpolated constructs, embedded code
  `font-lock-comment-face'	Embedded comments

(defvar cperl-tips-faces 'please-ignore-this-line (#$ . 32196))
(defalias 'cperl-define-key '(macro . #[(emacs-key definition &optional xemacs-key) "\303\304\203�\305\306	F\202�	\nF\207" [xemacs-key emacs-key definition define-key cperl-mode-map if (featurep 'xemacs)] 6]))
#@61 Character generated by key bound to `delete-backward-char'.
(defvar cperl-del-back-ch (byte-code "\300\301\302!\301\303!\"@\207" [append where-is-internal delete-backward-char backward-delete-char-untabify] 4) (#$ . 34962))
(byte-code "\301!\203�G\302U\203�\303H\301\207" [cperl-del-back-ch vectorp 1 0] 2)
(defalias 'cperl-mark-active #[nil "\300 \207" [mark] 1])
(byte-code "\300\301\302\"\210\300\303\304\"\207" [defalias cperl-use-region-p #[nil "\203�	\207\302\207" [transient-mark-mode mark-active t] 1] cperl-mark-active #[nil "\207" [mark-active] 1]] 3)
(defalias 'cperl-enable-font-lock #[nil "\207" [cperl-can-font-lock] 1])
(put 'cperl-enable-font-lock 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'cperl-putback-char #[(c) "C\211\207" [c unread-command-events] 2])
(byte-code "\300\301!\204�\302\301\303\"\210\300\207" [fboundp uncomment-region defalias #[(beg end) "\302	\303#\207" [beg end comment-region -1] 4 nil "r"]] 3)
#@47 Text property which inhibits refontification.
(defvar cperl-do-not-fontify (byte-code "\301\231\203�\302\207\303\207" [emacs-version "19.30" fontified lazy-lock] 2) (#$ . 35930))
(defalias 'cperl-put-do-not-fontify #[(from to &optional post) "\205�	?\205�\305e\nS]\f\306$\207" [post cperl-syntaxify-by-font-lock from to cperl-do-not-fontify put-text-property t] 5])
(put 'cperl-put-do-not-fontify 'byte-optimizer 'byte-compile-inline-expand)
#@25 Hook run by CPerl mode.
(custom-declare-variable 'cperl-mode-hook 'nil '(#$ . 36384) :type 'hook :group 'cperl)
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\304\"\210\306B\302\306!\2045�\303\306\212\307``\")G\310V\"\210\304\207" [current-load-list cperl-syntax-state default-boundp set-default nil cperl-syntax-done-to cperl-emacs-can-parse parse-partial-sexp 9] 5)
(defalias 'cperl-val #[(symbol &optional default hairy) "J\304=\203	�	\207\n\203�\206�\305\207J\207" [symbol default cperl-hairy hairy null t] 2])
(put 'cperl-val 'byte-optimizer 'byte-compile-inline-expand)
#@148 Makes indent of the current line the requested amount.
Unless KEEP, removes the old indentation.  Works around a bug in ancient
versions of Emacs.
(defalias 'cperl-make-indent #[(column &optional minimum keep) "\304`\305\"	\204\f�\306 \210\307\n\"\210\2054�i\310V\2054�\212\311 \210\304`\305\"\2063�\312\313!\2053�\314`\310\225\305$))\207" [prop keep column minimum get-text-property syntax-type delete-horizontal-space indent-to 0 beginning-of-line looking-at "\\=[ 	]" put-text-property] 5 (#$ . 37010)])
#@44 Abbrev table in use in CPerl mode buffers.
(defvar cperl-mode-abbrev-table nil (#$ . 37527))
(add-hook 'edit-var-mode-alist '(perl-mode (regexp . "^cperl-")))
#@28 Keymap used in CPerl mode.
(defvar cperl-mode-map nil (#$ . 37692))
(byte-code "\204\306 \307\310\311#\210\307\312\313#\210\307\314\313#\210\307\315\313#\210\307\316\317#\210\307\320\321#\210\307\322\321#\210\307\323\324#\210\307\325\326#\210\307\327\330#\210\307\331\332#\210\307\333\334#\210\307\335\336#\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\356#\210\307\357\360#\210\307\361\362#\210\307\363\364#\210\307\365\366#\210\307\367\370#\210\307\371\372#\210\307\373\374#\210\307\375\376#\210\307\377\201A�#\210\307\201B�\201C�#\210\307\201D�\201E�#\210\201F�\201G�\211\211J\201H�=\203\350�\n\202\370�\f\203\366�	\206\370�\201I�\202\370�J+\203/\307\201J�\201E�#\210\307\201K�\201L�#\210\307\201M�\201N�\201J�!#\210\307\201O�\201N�\201K�!#\210\202C\307\201M�\201P�#\210\307\201O�\201L�#\210\201Q�\201R�!\204Z\201S�\201T�\201U�
$\210\201S�\201V�\374
$\210\201S�\201W�\201X�
$\210\201S�\201Y�\201Z�
$\210\201[�@B@\201\\�\201[�!\204\234\201]�\201[�\201G�\"\210\201G�\201^�\201_�\217\207" [cperl-mode-map hairy default symbol cperl-hairy global-map make-sparse-keymap define-key "{" cperl-electric-lbrace "[" cperl-electric-paren "(" "<" "}" cperl-electric-brace "]" cperl-electric-rparen ")" ";" cperl-electric-semi ":" cperl-electric-terminator "\n" newline-and-indent "\n" cperl-linefeed "" cperl-invert-if-unless "" cperl-toggle-auto-newline "" cperl-toggle-abbrev "" cperl-toggle-construct-fix "" auto-fill-mode "" cperl-toggle-electric "" cperl-find-bad-style "" cperl-pod-spell "" cperl-here-doc-spell "" cperl-narrow-to-here-doc "" cperl-next-interpolated-REx "" cperl-next-interpolated-REx-0 "" cperl-next-interpolated-REx-1 "a" cperl-toggle-autohelp "p" cperl-perldoc "P" cperl-perldoc-at-point "" cperl-indent-exp [201326716] cperl-lineup "" current-load-list cperl-electric-backspace "	" cperl-indent-command "F" cperl-info-on-command cperl-clobber-lisp-bindings nil null t "f" "v" cperl-get-help "f" key-binding "v" cperl-info-on-current-command boundp fill-paragraph-function substitute-key-definition fill-paragraph cperl-fill-paragraph indent-sexp indent-region cperl-indent-region indent-for-comment cperl-indent-for-comment cperl-old-style default-boundp set-default (byte-code "\302\303!\210\304B\305\304\306\307#\210\310\304!\204�\311\304\312\"\210\313\304	\307\314$\207" [current-load-list cperl-mode-map require easymenu cperl-menu put variable-documentation "Menu for CPerl mode" default-boundp set-default nil easy-menu-do-define ("Perl" ["Beginning of function" beginning-of-defun t] ["End of function" end-of-defun t] ["Mark function" mark-defun t] ["Indent expression" cperl-indent-exp t] ["Fill paragraph/comment" fill-paragraph t] "----" ["Line up a construction" cperl-lineup (cperl-use-region-p)] ["Invert if/unless/while etc" cperl-invert-if-unless t] ("Regexp" ["Beautify" cperl-beautify-regexp cperl-use-syntax-table-text-property] ["Beautify one level deep" (cperl-beautify-regexp 1) cperl-use-syntax-table-text-property] ["Beautify a group" cperl-beautify-level cperl-use-syntax-table-text-property] ["Beautify a group one level deep" (cperl-beautify-level 1) cperl-use-syntax-table-text-property] ["Contract a group" cperl-contract-level cperl-use-syntax-table-text-property] ["Contract groups" cperl-contract-levels cperl-use-syntax-table-text-property] "----" ["Find next interpolated" cperl-next-interpolated-REx (next-single-property-change (point-min) 'REx-interpolated)] ["Find next interpolated (no //o)" cperl-next-interpolated-REx-0 (or (text-property-any (point-min) (point-max) 'REx-interpolated t) (text-property-any (point-min) (point-max) 'REx-interpolated 1))] ["Find next interpolated (neither //o nor whole-REx)" cperl-next-interpolated-REx-1 (text-property-any (point-min) (point-max) 'REx-interpolated t)]) ["Insert spaces if needed to fix style" cperl-find-bad-style t] ["Refresh \"hard\" constructions" cperl-find-pods-heres t] "----" ["Indent region" cperl-indent-region (cperl-use-region-p)] ["Comment region" cperl-comment-region (cperl-use-region-p)] ["Uncomment region" cperl-uncomment-region (cperl-use-region-p)] "----" ["Run" mode-compile (fboundp 'mode-compile)] ["Kill" mode-compile-kill (and (fboundp 'mode-compile-kill) (get-buffer "*compilation*"))] ["Next error" next-error (get-buffer "*compilation*")] ["Check syntax" cperl-check-syntax (fboundp 'mode-compile)] "----" ["Debugger" cperl-db t] "----" ("Tools" ["Imenu" imenu (fboundp 'imenu)] ["Imenu on Perl Info" cperl-imenu-on-info (featurep 'imenu)] "----" ["Ispell PODs" cperl-pod-spell (or (get-text-property (point-min) 'in-pod) (< (progn (and cperl-syntaxify-for-menu (cperl-update-syntaxification (point-max) (point-max))) (next-single-property-change (point-min) 'in-pod nil (point-max))) (point-max)))] ["Ispell HERE-DOCs" cperl-here-doc-spell (< (progn (and cperl-syntaxify-for-menu (cperl-update-syntaxification (point-max) (point-max))) (next-single-property-change (point-min) 'here-doc-group nil (point-max))) (point-max))] ["Narrow to this HERE-DOC" cperl-narrow-to-here-doc (eq 'here-doc (progn (and cperl-syntaxify-for-menu (cperl-update-syntaxification (point) (point))) (get-text-property (point) 'syntax-type)))] ["Select this HERE-DOC or POD section" cperl-select-this-pod-or-here-doc (memq (progn (and cperl-syntaxify-for-menu (cperl-update-syntaxification (point) (point))) (get-text-property (point) 'syntax-type)) '(here-doc pod))] "----" ["CPerl pretty print (exprmntl)" cperl-ps-print (fboundp 'ps-extend-face-list)] "----" ["Syntaxify region" cperl-find-pods-heres-region (cperl-use-region-p)] ["Profile syntaxification" cperl-time-fontification t] ["Debug errors in delayed fontification" cperl-emulate-lazy-lock t] ["Debug unwind for syntactic scan" cperl-toggle-set-debug-unwind t] ["Debug backtrace on syntactic scan (BEWARE!!!)" (cperl-toggle-set-debug-unwind nil t) t] "----" ["Class Hierarchy from TAGS" cperl-tags-hier-init t] ("Tags" ["Create tags for current file" (cperl-write-tags nil t) t] ["Add tags for current file" (cperl-write-tags) t] ["Create tags for Perl files in directory" (cperl-write-tags nil t nil t) t] ["Add tags for Perl files in directory" (cperl-write-tags nil nil nil t) t] ["Create tags for Perl files in (sub)directories" (cperl-write-tags nil t t t) t] ["Add tags for Perl files in (sub)directories" (cperl-write-tags nil nil t t) t])) ("Perl docs" ["Define word at point" imenu-go-find-at-position (fboundp 'imenu-go-find-at-position)] ["Help on function" cperl-info-on-command t] ["Help on function at point" cperl-info-on-current-command t] ["Help on symbol at point" cperl-get-help t] ["Perldoc" cperl-perldoc t] ["Perldoc on word at point" cperl-perldoc-at-point t] ["View manpage of POD in this file" cperl-build-manpage t] ["Auto-help on" cperl-lazy-install (and (fboundp 'run-with-idle-timer) (not cperl-lazy-installed))] ["Auto-help off" cperl-lazy-unstall (and (fboundp 'run-with-idle-timer) cperl-lazy-installed)]) ("Toggle..." ["Auto newline" cperl-toggle-auto-newline t] ["Electric parens" cperl-toggle-electric t] ["Electric keywords" cperl-toggle-abbrev t] ["Fix whitespace on indent" cperl-toggle-construct-fix t] ["Auto-help on Perl constructs" cperl-toggle-autohelp t] ["Auto fill" auto-fill-mode t]) ("Indent styles..." ["CPerl" (cperl-set-style "CPerl") t] ["PerlStyle" (cperl-set-style "PerlStyle") t] ["GNU" (cperl-set-style "GNU") t] ["C++" (cperl-set-style "C++") t] ["K&R" (cperl-set-style "K&R") t] ["BSD" (cperl-set-style "BSD") t] ["Whitesmith" (cperl-set-style "Whitesmith") t] ["Memorize Current" (cperl-set-style "Current") t] ["Memorized" (cperl-set-style-back) cperl-old-style]) ("Micro-docs" ["Tips" (describe-variable 'cperl-tips) t] ["Problems" (describe-variable 'cperl-problems) t] ["Speed" (describe-variable 'cperl-speed) t] ["Praise" (describe-variable 'cperl-praise) t] ["Faces" (describe-variable 'cperl-tips-faces) t] ["CPerl mode" (describe-function 'cperl-mode) t] ["CPerl version" (message "The version of master-file for this CPerl is %s-Emacs" cperl-version) t]))] 5) ((error))] 6)
#@141 Display the result of expanding all C macros occurring in the region.
The expansion is entirely correct because it uses the C preprocessor.
(autoload 'c-macro-expand "cmacexp" '(#$ . 45907) t)
#@112 Regular expression to match optional whitespace with interpspersed comments.
Should contain exactly one group.
(defconst cperl-maybe-white-and-comment-rex "[ 	\n]*\$#[^\n]*\n[ 	\n]*\$*" (#$ . 46107))
#@103 Regular expression to match whitespace with interpspersed comments.
Should contain exactly one group.
(defconst cperl-white-and-comment-rex "\$[ 	\n]\\|#[^\n]*\n\$+" (#$ . 46316))
#@217 Match the text after `sub' in a subroutine declaration.
If NAMED is nil, allows anonymous subroutines.  Matches up to the first ":"
of attributes (if present), or end of the name or prototype (whatever is
the last).
(defalias 'cperl-after-sub-regexp #[(named attr) "\304\305\306	\203\f�\307\202
�\310\304\n\311\312\304\n\304\313\203&�\304\n\314\315\304\n\316\317\260\202'�\320\306\312\260\207" [cperl-white-and-comment-rex named cperl-maybe-white-and-comment-rex attr "\$" "\\(::[a-zA-Z_0-9:']+\\|[a-zA-Z_'][a-zA-Z_0-9:']*\$" "\\)" "" "?" "\$([^()]*)\$" "\\)?" ":" "\$\\sw\\|_\$+" "\$(\\(\\\\.\\|[^\\\\()]\\|([^\\\\()]*)\$*)\\)?" ":\\)?" "\\)+" "[^:]"] 21 (#$ . 46505)])
(byte-code "\306\307\310\311#\210\305B\312\305!\204R�\313\305\314\315\316	\317\320\321\303\322\316	\323\324\203)�\325\202*�\326\316\f\327\330\316\f\316\331\n\203C�\316\f\332\333\316\f\334\335\260\202D�\336\324\330\260*\f\320\337\340\324\260
\"\210\341B\312\341!\204d�\313\341
\320\342Q\"\210\322\207" [current-load-list cperl-white-and-comment-rex attr named cperl-maybe-white-and-comment-rex cperl-imenu--function-name-regexp-perl put cperl-after-sub-regexp byte-optimizer byte-compile-inline-expand default-boundp set-default "^\$" "\\([ 	]*package" "\\(" "\\([a-zA-Z_0-9:']+\$\\)?\\)" "\\|" "[ 	]*sub" nil "\$::[a-zA-Z_0-9:']+\\|[a-zA-Z_'][a-zA-Z_0-9:']*\$" "\\)" "" "?" "\$([^()]*)\$" "\\)?" ":" "\$\\sw\\|_\$+" "\$(\\(\\\\.\\|[^\\\\()]\\|([^\\\\()]*)\$*)\\)?" ":\\)?" "\\)+" "[^:]" "=head\$[1-4]\$[ 	]+" "\$[^\n]+\$$" cperl-outline-regexp "\\`"] 30)
#@44 Syntax table in use in CPerl mode buffers.
(defvar cperl-mode-syntax-table nil (#$ . 48072))
#@55 Syntax table in use in CPerl mode string-like chunks.
(defvar cperl-string-syntax-table nil (#$ . 48171))
(defalias 'cperl-1- #[(p) "eS]\207" [p] 2])
(put 'cperl-1- 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'cperl-1+ #[(p) "dT^\207" [p] 2])
(byte-code "\304\305\306\307#\210\204\231�\310 \311\312\313#\210\311\314\315#\210\311\316\315#\210\311\317\315#\210\311\320\315#\210\311\321\315#\210\311\322\315#\210\311\323\315#\210\311\324\315#\210\311\325\315#\210\311\326\313#\210\311\327\330#\210\311\331\332#\210\311\333\334#\210\311\335\334#\210	\203q�\311\336\337#\210\311\340\341#\210\311\342\315#\210\343!\311\326\315\n#\210\311\344\315\n#\210\311\345\315\n#\210\311\331\315\n#\210\346B\347\346!\204\250�\350\346\351\"\210\352B\347\352!\204\267�\350\352\351\"\210\353B\347\353!\204\306�\350\353\354\"\210\355B\347\355!\204\325�\350\355\351\"\210\356B\347\356!\204\344�\350\356\351\"\210\357B\347\357!\204\363�\350\357\351\"\210\351\207" [cperl-mode-syntax-table cperl-under-as-char cperl-string-syntax-table current-load-list put cperl-1+ byte-optimizer byte-compile-inline-expand make-syntax-table modify-syntax-entry 92 "\\" 47 "." 42 43 45 61 37 60 62 38 36 10 ">" 35 "<" 39 "\"" 96 95 "w" 58 "_" 124 copy-syntax-table 123 125 cperl-faces-init default-boundp set-default nil cperl-msb-fixed cperl-use-major-mode cperl-mode cperl-font-lock-multiline-start cperl-font-lock-multiline cperl-font-locking] 4)
#@58 Alist that specifies how to match errors in perl output.
(defvar cperl-compilation-error-regexp-alist '(("^[^\n]* \$file\\|at\$ \$[^ 	\n]+\$ [^\n]*line \$[0-9]+\$[\\., \n]" 2 3)) (#$ . 49634))
#@8212 Major mode for editing Perl code.
Expression and list commands understand all C brackets.
Tab indents for Perl code.
Paragraphs are separated by blank lines only.
Delete converts tabs to spaces as it moves back.

Various characters in Perl almost always come in pairs: {}, (), [],
sometimes <>.  When the user types the first, she gets the second as
well, with optional special formatting done on {}.  (Disabled by
default.)  You can always quote (with \[quoted-insert]) the left
"paren" to avoid the expansion.  The processing of < is special,
since most the time you mean "less".  CPerl mode tries to guess
whether you want to type pair <>, and inserts is if it
appropriate.  You can set `cperl-electric-parens-string' to the string that
contains the parenths from the above list you want to be electrical.
Electricity of parenths is controlled by `cperl-electric-parens'.
You may also set `cperl-electric-parens-mark' to have electric parens
look for active mark and "embrace" a region if possible.'

CPerl mode provides expansion of the Perl control constructs:

if, else, elsif, unless, while, until, continue, do,
   for, foreach, formy and foreachmy.

and POD directives (Disabled by default, see `cperl-electric-keywords'.)

The user types the keyword immediately followed by a space, which
causes the construct to be expanded, and the point is positioned where
she is most likely to want to be.  eg. when the user types a space
following "if" the following appears in the buffer: if () { or if ()
} { } and the cursor is between the parentheses.  The user can then
type some boolean expression within the parens.  Having done that,
typing \[cperl-linefeed] places you - appropriately indented - on a
new line between the braces (if you typed \[cperl-linefeed] in a POD
directive line, then appropriate number of new lines is inserted).

If CPerl decides that you want to insert "English" style construct like

bite if angry;

it will not do any expansion.  See also help on variable
`cperl-extra-newline-before-brace'.  (Note that one can switch the
help message on expansion by setting `cperl-message-electric-keyword'
to nil.)

\[cperl-linefeed] is a convenience replacement for typing carriage
return.  It places you in the next line with proper indentation, or if
you type it inside the inline block of control construct, like

foreach (@lines) {print; print}

and you are on a boundary of a statement inside braces, it will
transform the construct into a multiline and will place you into an
appropriately indented blank line.  If you need a usual
`newline-and-indent' behavior, it is on \[newline-and-indent],
see documentation on `cperl-electric-linefeed'.

Use \[cperl-invert-if-unless] to change a construction of the form

if (A) { B }

into

B if A;

\{cperl-mode-map}

Setting the variable `cperl-font-lock' to t switches on font-lock-mode
(even with older Emacsen), `cperl-electric-lbrace-space' to t switches
on electric space between $ and {, `cperl-electric-parens-string' is
the string that contains parentheses that should be electric in CPerl
(see also `cperl-electric-parens-mark' and `cperl-electric-parens'),
setting `cperl-electric-keywords' enables electric expansion of
control structures in CPerl.  `cperl-electric-linefeed' governs which
one of two linefeed behavior is preferable.  You can enable all these
options simultaneously (recommended mode of use) by setting
`cperl-hairy' to t.  In this case you can switch separate options off
by setting them to `null'.  Note that one may undo the extra
whitespace inserted by semis and braces in `auto-newline'-mode by
consequent \[cperl-electric-backspace].

If your site has perl5 documentation in info format, you can use commands
\[cperl-info-on-current-command] and \[cperl-info-on-command] to access it.
These keys run commands `cperl-info-on-current-command' and
`cperl-info-on-command', which one is which is controlled by variable
`cperl-info-on-command-no-prompt' and `cperl-clobber-lisp-bindings'
(in turn affected by `cperl-hairy').

Even if you have no info-format documentation, short one-liner-style
help is available on \[cperl-get-help], and one can run perldoc or
man via menu.

It is possible to show this help automatically after some idle time.
This is regulated by variable `cperl-lazy-help-time'.  Default with
`cperl-hairy' (if the value of `cperl-lazy-help-time' is nil) is 5
secs idle time .  It is also possible to switch this on/off from the
menu, or via \[cperl-toggle-autohelp].  Requires `run-with-idle-timer'.

Use \[cperl-lineup] to vertically lineup some construction - put the
beginning of the region at the start of construction, and make region
span the needed amount of lines.

Variables `cperl-pod-here-scan', `cperl-pod-here-fontify',
`cperl-pod-face', `cperl-pod-head-face' control processing of POD and
here-docs sections.  With capable Emaxen results of scan are used
for indentation too, otherwise they are used for highlighting only.

Variables controlling indentation style:
 `cperl-tab-always-indent'
    Non-nil means TAB in CPerl mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 `cperl-indent-left-aligned-comments'
    Non-nil means that the comment starting in leftmost column should indent.
 `cperl-auto-newline'
    Non-nil means automatically newline before and after braces,
    and after colons and semicolons, inserted in Perl code.  The following
    \[cperl-electric-backspace] will remove the inserted whitespace.
    Insertion after colons requires both this variable and
    `cperl-auto-newline-after-colon' set.
 `cperl-auto-newline-after-colon'
    Non-nil means automatically newline even after colons.
    Subject to `cperl-auto-newline' setting.
 `cperl-indent-level'
    Indentation of Perl statements within surrounding block.
    The surrounding block's indentation is the indentation
    of the line on which the open-brace appears.
 `cperl-continued-statement-offset'
    Extra indentation given to a substatement, such as the
    then-clause of an if, or body of a while, or just a statement continuation.
 `cperl-continued-brace-offset'
    Extra indentation given to a brace that starts a substatement.
    This is in addition to `cperl-continued-statement-offset'.
 `cperl-brace-offset'
    Extra indentation for line if it starts with an open brace.
 `cperl-brace-imaginary-offset'
    An open brace following other text is treated as if it the line started
    this far to the right of the actual line indentation.
 `cperl-label-offset'
    Extra indentation for line that is a label.
 `cperl-min-label-indent'
    Minimal indentation for line that is a label.

Settings for classic indent-styles: K&R BSD=C++ GNU PerlStyle=Whitesmith
  `cperl-indent-level'                5   4       2   4
  `cperl-brace-offset'                0   0       0   0
  `cperl-continued-brace-offset'     -5  -4       0   0
  `cperl-label-offset'               -5  -4      -2  -4
  `cperl-continued-statement-offset'  5   4       2   4

CPerl knows several indentation styles, and may bulk set the
corresponding variables.  Use \[cperl-set-style] to do this.  Use
\[cperl-set-style-back] to restore the memorized preexisting values
(both available from menu).  See examples in `cperl-style-examples'.

Part of the indentation style is how different parts of if/elsif/else
statements are broken into lines; in CPerl, this is reflected on how
templates for these constructs are created (controlled by
`cperl-extra-newline-before-brace'), and how reflow-logic should treat "continuation" blocks of else/elsif/continue, controlled by the same variable,
and by `cperl-extra-newline-before-brace-multiline',
`cperl-merge-trailing-else', `cperl-indent-region-fix-constructs'.

If `cperl-indent-level' is 0, the statement after opening brace in
column 0 is indented on
`cperl-brace-offset'+`cperl-continued-statement-offset'.

Turning on CPerl mode calls the hooks in the variable `cperl-mode-hook'
with no args.

DO NOT FORGET to read micro-docs (available from `Perl' menu)
or as help on variables `cperl-tips', `cperl-problems',
`cperl-praise', `cperl-speed'.
(defalias 'cperl-mode #[nil "\306 \210\307!\210\310\311\211\211J\312=\203�\n\202&�\f\203$�	\206&�\313\202&�J+\2034�\314\315\316\"\210\314\317\320\"\210\321\311\211\211J\312=\203E�\n\202S�\f\203Q�	\206S�\313\202S�J+\203\206�\322\311\211\211J\312=\203h�\n\202v�\f\203t�	\206v�\313\202v�J+\203\206�\323\324\325#\210\323\326\327#\210
@\330ABC\331\332\333\"\210CB)D\334\311\211\211J\312=\203\257�\n\202\275�\f\203\273�	\206\275�\313\202\275�J+\203\305�\335\336!\210\337E!\210\340\341!\210\340\342!\210\340\343!\210F#\340\344!\210\345$\340\346!\210\347GP&\340\350!\210&(\340\351!\210\313)\340\352!\210\353*\340\354!\210H,\340\355!\210\356-\340\357!\210\360/\340\361!\210I1\340\362!\210\3632\340\364!\210\365\366\367J6\370K\371\3726\203?\360\202@\373\370L\374\375\370L\370\376J\203d\370L\377\201q�\370L\201r�\201s�\260\202g\201t�\372\375\260*\201u�\201v�\372L\2604\340\201M�!\210\201w�M\201x�\201N�!\203\231\340\201N�!\210\201y�N\340\201O�!\210\313O\340\201P�!\210\201z�P\340\201Q�!\210\201{�Q\340\201R�!\210\311R\340\201T�!\210ST\340\201V�!\210UV\340\201X�!\210W\206\357\201|�U@D\201}�S@DDX\201x�\201Z�!\2036\340\201Z�!\210\201~�Y@B\201Z�JBZ\201�\201\200�!\203%\201\200�\211[ \210)\202R\340\201\\�!\210\201~�\\B\\\202R\201x�\201\\�!\203R\340\201\\�!\210\201\201�Y\201\\�J\"\\\340\201^�!\210]\201\202�\231\203g\201\203�\202y]\201\204�\231\203v\201\205�\202y\201\206�^\340\201_�!\210\311_`\203\313\340\201a�!\210\313a\201x�\201b�!\204\241\201\207�b\340\201b�!\210\201\210�b\340\201c�!\210\311c\340\201e�!\210d\203\306\201\211�\202\311\201\212�e\201x�\201g�!\203\344\313f\340\201g�!\210\313g\202\357\340\201h�!\210\201\213�h\340\201h�!\210\201\213�h\340\201\214�!\210\201x�\201i�!\203\340\201i�!\210\201\215�i\2026\201�\201\216�!\2046\201\216�\201\217�KM\210\201\220�\201\217�\201\221�\"\210j\203p\201\222�\311\211\211J\312=\203N\n\202\\\f\203Z	\206\\\313\202\\J+\203pk\204j\201\223� \210\201\224�\336!\210\340\201l�!\210\201\225�l\201x�\201\226�!\203\217m\204\217\201\227� \210\201\230�\201\231�!\203\240\201\232�n!\210\201\233�\201\234�!\210o\203\272\201\235�\201\236�\201\237�\311\313$\210p\205\322d\206\322k\204\316\201\240� \210\201\241� \207" [cperl-mode-map hairy default symbol cperl-hairy cperl-use-major-mode kill-all-local-variables use-local-map cperl-electric-linefeed nil null t local-set-key "\n" cperl-linefeed "\n" newline-and-indent cperl-clobber-lisp-bindings cperl-info-on-command-no-prompt define-key "f" cperl-info-on-current-command "f" cperl-info-on-command "CPerl" define-abbrev-table cperl-mode-abbrev-table (("if" "if" cperl-electric-keyword 0) ("elsif" "elsif" cperl-electric-keyword 0) ("while" "while" cperl-electric-keyword 0) ("until" "until" cperl-electric-keyword 0) ("unless" "unless" cperl-electric-keyword 0) ("else" "else" cperl-electric-else 0) ("continue" "continue" cperl-electric-else 0) ("for" "for" cperl-electric-keyword 0) ("foreach" "foreach" cperl-electric-keyword 0) ("formy" "formy" cperl-electric-keyword 0) ("foreachmy" "foreachmy" cperl-electric-keyword 0) ("do" "do" cperl-electric-keyword 0) ("=pod" "=pod" cperl-electric-pod 0) ("=over" "=over" cperl-electric-pod 0) ("=head1" "=head1" cperl-electric-pod 0) ("=head2" "=head2" cperl-electric-pod 0) ("pod" "pod" cperl-electric-pod 0) ("over" "over" cperl-electric-pod 0) ("head1" "head1" cperl-electric-pod 0) ("head2" "head2" cperl-electric-pod 0)) cperl-electric-keywords abbrev-mode 1 set-syntax-table make-local-variable cperl-font-lock-multiline-start cperl-font-locking outline-regexp outline-level cperl-outline-level paragraph-start "^$\\|" paragraph-separate paragraph-ignore-fill-prefix indent-line-function cperl-indent-line require-final-newline comment-start "# " comment-end "" comment-column comment-start-skip "#+ *" defun-prompt-regexp "^[ 	]*\$sub" named attr-groups "\\(" "\\(::[a-zA-Z_0-9:']+\\|[a-zA-Z_'][a-zA-Z_0-9:']*\$" "\\)" "?" "\$([^()]*)\$" "\\)?" ":" "\$\\sw\\|_\$+" major-mode mode-name abbrevs-changed prev-a-c local-abbrev-table cperl-mode-syntax-table cperl-outline-regexp page-delimiter mode-require-final-newline cperl-comment-column attr cperl-white-and-comment-rex cperl-maybe-white-and-comment-rex comment-indent-function fill-paragraph-function parse-sexp-ignore-comments indent-region-function imenu-create-index-function imenu-sort-function cperl-vc-rcs-header vc-rcs-header cperl-vc-sccs-header vc-sccs-header cperl-vc-header-alist vc-header-alist cperl-compilation-error-regexp-alist compilation-error-regexp-alist-alist f compilation-error-regexp-alist emacs-version font-lock-defaults cperl-syntax-state cperl-use-syntax-table-text-property parse-sexp-lookup-properties font-lock-unfontify-region-function cperl-syntax-done-to cperl-syntaxify-by-font-lock font-lock-syntactic-keywords cperl-font-lock-multiline font-lock-multiline font-lock-fontify-region-function normal-auto-fill-function cperl-can-font-lock cperl-faces-init facemenu-add-face-function cperl-msb-fixed cperl-menu cperl-hook-after-change cperl-pod-here-scan "\$(\\(\\\\.\\|[^\\\\()]\\|([^\\\\()]*)\$*)\\)?" ":\\)?" "\\)+" "[^:]" "\\|" "\$BEGIN\\|CHECK\\|INIT\\|END\\|AUTOLOAD\\|DESTROY\$" cperl-comment-indent boundp cperl-fill-paragraph cperl-indent-region cperl-imenu--create-perl-index SCCS RCS cperl fboundp compilation-build-compilation-error-regexp-alist append "19.30" (cperl-font-lock-keywords-2 nil nil ((95 . "w"))) "19.33" ((cperl-font-lock-keywords cperl-font-lock-keywords-1 cperl-font-lock-keywords-2) nil nil ((95 . "w"))) ((cperl-load-font-lock-keywords cperl-load-font-lock-keywords-1 cperl-load-font-lock-keywords-2) nil nil ((95 . "w"))) font-lock-default-unfontify-region cperl-font-lock-unfontify-region-function ((cperl-fontify-syntaxically)) (t) cperl-font-lock-fontify-region-function cperl-old-style cperl-do-auto-fill cperl-old-auto-fill-mode auto-fill-mode defalias #[(&optional arg) "\302\303!\210\205�	\304>\205�\305\211\207" [auto-fill-function major-mode eval (cperl-old-auto-fill-mode arg) (perl-mode cperl-mode) cperl-do-auto-fill] 2 nil "P"] cperl-font-lock cperl-init-faces font-lock-mode cperl-facemenu-add-face-function msb-menu-cond cperl-msb-fix featurep easymenu easy-menu-add run-mode-hooks cperl-mode-hook add-hook after-change-functions cperl-after-change-function cperl-init-faces-weak cperl-find-pods-heres] 23 (#$ . 49841) nil])
(defalias 'cperl-db #[nil "\301\302!\210\303\304\305:\203�@\202�\306\307 P\310\211\311%!\207" [gud-perldb-history require gud perldb read-from-minibuffer "Run perldb (like this): " "perl " buffer-file-name nil (gud-perldb-history . 1)] 7 nil nil])
(defalias 'cperl-msb-fix #[nil "\306	G\211S	8\n\307Z	\233A@S\f\310
\311ED\241,\207" [cperl-msb-fixed msb-menu-cond l last precdr handle t 2 (memq major-mode '(cperl-mode perl-mode)) "Perl Files (%d)"] 5])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\306\"\210\307B\302\307!\204-�\303\307\310\"\210\311B\302\311!\204<�\303\311\312\"\210\313B\302\313!\204K�\303\313\314\"\210\315B\302\315!\204Z�\303\315\316\"\210\301\207" [current-load-list cperl-st-cfence default-boundp set-default (14) cperl-st-sfence (15) cperl-st-punct (1) cperl-st-word (2) cperl-st-bra (4 . 62) cperl-st-ket (5 . 60)] 3)
(defalias 'cperl-comment-indent #[nil "`i\306\211\f\204�\307\310!\203�\311\202l�\212\312 \313`\314\"
=\211\2034�\315\316!\210h\317=\2032�\320u\210\306`U\203S�\321\306x\210i\211\311=\203K�\202k�	T]\202k�	\204a�c\210G[u\210\322\323\324\"\210\n),\207" [phony was c p cperl-indent-comment-at-column-0 cperl-st-cfence nil looking-at "^#" 0 cperl-to-comment-or-eol get-text-property syntax-table re-search-forward "#\\|$" 35 -1 " 	" t cperl-make-indent 1 comment-column comment-start cperl-wrong-comment] 5])
#@47 Substitute for `indent-for-comment' in CPerl.
(defalias 'cperl-indent-for-comment #[nil "\302\303 \210\205�\304 \210	Gu)\207" [cperl-wrong-comment comment-start nil indent-for-comment cperl-to-comment-or-eol] 1 (#$ . 65938) nil])
#@83 Comment or uncomment each line in the region in CPerl mode.
See `comment-region'.
(defalias 'cperl-comment-region #[(b e arg) "\304\305	\n#)\207" [comment-start b e arg "#" comment-region] 4 (#$ . 66177) "r\np"])
#@83 Uncomment or comment each line in the region in CPerl mode.
See `comment-region'.
(defalias 'cperl-uncomment-region #[(b e arg) "\304\305	\n[#)\207" [comment-start b e arg "#" comment-region] 4 (#$ . 66398) "r\np"])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list cperl-brace-recursing default-boundp set-default nil] 3)
#@281 Insert character and correct line's indentation.
If ONLY-BEFORE and `cperl-auto-newline', will insert newline before the
place (even in empty line), but not after.  If after ")" and the inserted
char is "{", insert extra newline before only if
`cperl-extra-newline-before-brace'.
(defalias 'cperl-electric-brace #[(arg &optional only-before) "\306\205�\307 \205�\310 `W\205�\310 	\203d�\204d�\311\306\211\211J\312=\203/�
\202?�\203<�\f\206?�\313\202?�J+\203d�\212\314 \210`)`Y\203d�\212\315 	b\210\316 \317!\n\"\210)\320u\202 \321=\203{�\306\322\323\217\204{�\324\325!!!\202!\204\360�l\203\360�\"\204\223�\212\326\306x\210n)\204\266� \316=\203\253�#\204\253�\212\326\306x\210h)\327=\204\266�$\203\360�\330 \210\331 \210\324\325!!!\210\330 \210$\203\310�`S$\203\330�\"\204\330�\331 \210\330 \210\212\n\203\353�\nb\210\332\333\320 \"!\210`S\334\335!\210)\n\203\212\nb\210\324\325!!!)\202\324\325!!!*\207" [cperl-electric-parens-mark other-end insertpos cperl-brace-recursing hairy default nil cperl-mark-active mark cperl-electric-parens null t cperl-to-comment-or-eol point-marker 123 cperl-electric-lbrace 1 125 (byte-code "\212\301\302![!\210\303\304\305\"\206�\306\304\307\")\207" [arg up-list prefix-numeric-value cperl-after-expr-p nil "{;)" cperl-after-block-p pre] 3) ((error)) self-insert-command prefix-numeric-value " 	" 41 cperl-indent-line newline search-forward make-string delete-char -1 symbol cperl-hairy last-command-event arg only-before cperl-extra-newline-before-brace cperl-auto-newline] 5 (#$ . 66761) "P"])
#@73 Insert character, correct line's indentation, correct quoting by space.
(defalias 'cperl-electric-lbrace #[(arg &optional end) "\306	\206�\n\205�\307 \205�\310 `V\205�\212\310 b\210\311 )\312\211\313\312\211\211J\314=\203;�\202L� \203I�\206L�\306\202L�J+\203e�h\315=\203e�\212\316\312x\210\317\320!)\203e�\321c\210\212\322 \210\317\323!)\204w�\324\312\325\"\204y�\312\326!!\210\327\312\211\211J\314=\203\223�\202\244� \203\241�\206\244�\306\202\244�J+\205\324�\"\330=\205\324�\"\331#\312\">\205\324�
\203\303�\332
!b\210\333\"`\211\205\324�\326!\306\"\210\fb-\207" [cperl-auto-newline end cperl-electric-parens-mark after pos other-end t cperl-mark-active mark point-marker nil cperl-electric-lbrace-space null 36 "$" looking-at "\$\\$\\$\$*\\$\$[^\\$]\\|$\$" 32 beginning-of-line "[ 	]*#" cperl-after-expr-p "{;)" cperl-electric-brace cperl-electric-parens 123 append marker-position 125 cperl-brace-recursing hairy default symbol cperl-hairy arg last-command-event cperl-electric-parens-string] 6 (#$ . 68340) "P"])
#@95 Insert an opening parenthesis or a matching pair of parentheses.
See `cperl-electric-parens'.
(defalias 'cperl-electric-paren #[(arg) "\212\306 \210`)\205�\307 \205�\310 `V\205�\212\310 b\210\311 )\312\313\211\211J\314=\2031�\f\202@�\203>�\206@�\315\202@�
J+\203\233�\316\313\">\203\233�\212\317 \210`)`Y\203\233�\320=\203p�\203i�\321 \210\322\313\323\"\202q�\324\203\233�\325\326!!\210	\203\204�\327	!b\210\330\326!\331\332\"A\"c\210\326![u\202\241�\325\326!!*\207" [cperl-electric-parens-mark other-end beg hairy default symbol beginning-of-line cperl-mark-active mark point-marker cperl-electric-parens nil null t append cperl-to-comment-or-eol 60 expand-abbrev cperl-after-expr-p "{;(,:=" 1 self-insert-command prefix-numeric-value marker-position make-string assoc ((123 . 125) (91 . 93) (40 . 41) (60 . 62)) cperl-hairy last-command-event cperl-electric-parens-string abbrev-mode arg] 6 (#$ . 69413) "P"])
#@171 Insert a matching pair of parentheses if marking is active.
If not, or if we are not at the end of marking range, would self-insert.
Affected by `cperl-electric-parens'.
(defalias 'cperl-electric-rparen #[(arg) "\212\306 \210`)\205E�\307\310\211\211J\311=\203�\n\202)�\f\203'�	\206)�\312\202)�J+\205E�
\313\310\">\205E�\314 \205E�\315 `W\205E�\315 \310\203\254�\307\310\211\211J\311=\203b�\n\202p�\f\203n�	\206p�\312\202p�J+\203\254�
\316>\203\254�\212\317 \210`)`Y\203\254�\320\321!!\210`\203\230�b\210\322\321!\323
\324\"A\"c\210Tb\202\262�\320\321!!+\207" [cperl-electric-parens-mark hairy default symbol cperl-hairy last-command-event beginning-of-line cperl-electric-parens nil null t append cperl-mark-active mark (41 93 125 62) cperl-to-comment-or-eol self-insert-command prefix-numeric-value make-string assoc ((125 . 123) (93 . 91) (41 . 40) (62 . 60)) cperl-electric-parens-string p other-end beg arg] 6 (#$ . 70362) "P"])
#@137 Insert a construction appropriate after a keyword.
Help message may be switched off by setting `cperl-message-electric-keyword'
to nil.
(defalias 'cperl-electric-keyword #[nil "\212\306 \210`)\307=\205�	\310=\311>\205�	\312>\313\2116\212\313\314\315\217\210\316\313\317\")\205\212\320\3216\322#)?\205\212\320\323\313\322#?\206V�\324\325!\206V�7\205V�\326`\327\"\330=?)\205\212\331\332!\210g\333\334\313\">)?\205h\335=\203\201�\336u\210\337c\210\340u\210\322\211	\341>
\203\210�\342c\210\343 \2108\203\264�\n\203\230�\344\202\231�\345c\210\346c\210\343 \210\344c\210\343 \210\347c\210\n\203\277�\350c\210\202\277�\n\203\274�\351\202\275�\352c\210\324\353!\204\310�\337c\210\343 \210
\203\344�\354\355!\210\203\335�\356u\210\202\366�\357\356!\210\202\366�\354\360!\210\361=\203\366�\362\356!\210\362\332!\210\f\203\377�\3639!\210:\205\364\365!-\207" [last-command-event this-command do my delete dollar beginning-of-line 36 self-insert-command (32 10 9 12) (self-insert-command newline) nil (byte-code "\301\302!\210\303\304!\301\207" [do backward-sexp 1 looking-at "do\\>"] 2) ((error)) cperl-after-expr-p "{;:" re-search-backward "[#\"'`]\\|\\<q\$\\|[wqxr]\$\\>" t "^=" looking-at "=cut" get-text-property syntax-type pod forward-sexp -1 append "$@%&*" 121 -2 " " 2 (self-insert-command newline) " $" cperl-indent-line "\n" " ()\n" "{" "\n}" " while ();" " {\n} while ();" " () {\n}" "[ 	]\\|$" search-backward "$" 1 delete-char ")" 40 delete-backward-char cperl-putback-char message "Precede char by C-q to avoid expansion" beg cperl-use-syntax-table-text-property cperl-extra-newline-before-brace cperl-del-back-ch cperl-message-electric-keyword] 6 (#$ . 71336)])
#@49 Make sure there are N newlines after the point.
(defalias 'cperl-ensure-newlines #[(n &optional pos) "\204�`\302\303!\203�\304u\210\202�\303c\210	\304V\203!�\305	S\"\207b\207" [pos n looking-at "\n" 1 cperl-ensure-newlines] 3 (#$ . 73040)])
#@56 Insert a POD chunk appropriate after a =POD directive.
(defalias 'cperl-electric-pod #[nil "\306>\205	�	\307>\310\211\211\211\211\211+,-\212\311v\210h\312=\205c�\313\314!,\313\315!\2052�\313\316!?\311u\210n\205c�\317`\320\"\206c�\321\310\322\"\206c�\323\324e\325#\205c�\313\326!?\205c�.?\206c�\317`\327\"\330=)\205\340�\212\331\332\310\325#+)+\204\271�\333c\210\334\335!\210\336v\210,\203\266�\212\311u\210\323\337\310\325#)\204\266�\340v\210\341\342\343 !!`\344
\345\346\261\210\334\347!\210\fb\210\335v\210\310\210\325\202\271�\340v\210\n\203\323�`\350\351\261\210\334\335!\210\fb\210\340v\210\310\210\325-\205\340�\205\340�\352/!.\207" [last-command-event this-command over really-delete p name (32 10 9 12) (self-insert-command newline) nil -1 61 looking-at "head1\\>[ 	]*$" "over\\>[ 	]*$" "over[ 	]*\n\n\n*=item\\>" get-text-property in-pod cperl-after-expr-p "{;:" re-search-backward "\$\\`\n?\\|^\n\$=\\sw+" t "\n*=cut" syntax-type pod re-search-forward "^\n=" "\n\n=cut" cperl-ensure-newlines 2 -2 "\$\\`\n?\\|\n\n\$=head1\\>" 1 file-name-sans-extension file-name-nondirectory buffer-file-name " NAME\n\n" " - \n\n=head1 SYNOPSIS\n\n\n\n" "=head1 DESCRIPTION" 4 "\n\n=item \n\n\n\n" "=back" cperl-putback-char notlast head1 delete cperl-use-syntax-table-text-property cperl-del-back-ch] 7 (#$ . 73294)])
#@137 Insert a construction appropriate after a keyword.
Help message may be switched off by setting `cperl-message-electric-keyword'
to nil.
(defalias 'cperl-electric-else #[nil "\212\306 \210`)\212\307\310!\210\311\312\313\")\205v�\212\314\315\316#)?\205v�\212\314\317\312\316#?\206:�\320\321!\206:�	\205:�\322`\323\"\324=?)\205v�\325 \210\n\203T�\326c\210\327c\210\325 \210\330c\210\202W�\331c\210\320\332!\204`�\333c\210\325 \210\334y\210\325 \210\335!\210\336
\205v�\337\340!)\207" [beg cperl-use-syntax-table-text-property cperl-extra-newline-before-brace cperl-del-back-ch this-command cperl-message-electric-keyword beginning-of-line backward-sexp 1 cperl-after-expr-p nil "{;:" re-search-backward "[#\"'`]\\|\\<q\$\\|[wqxr]\$\\>" t "^=" looking-at "=cut" get-text-property syntax-type pod cperl-indent-line "\n" "{" "\n\n}" " {\n\n}" "[ 	]\\|$" " " -1 cperl-putback-char cperl-electric-else message "Precede char by C-q to avoid expansion"] 4 (#$ . 74645)])
#@99 Go to end of line, open a new line and indent appropriately.
If in POD, insert appropriate lines.
(defalias 'cperl-linefeed #[nil "\212\306 \210`)\212\307\210`)`\307\211\211\211/\212\310 \210`\fY)\203\317�\212\311/x\210\312u\210\313\314!)\204B�\313\315!\204B�\316\317
\320#\203\317�\212\321\f
\312#@\312=\205d�\313\322!\205d�\323e!\205d�\324\325!\210\326 \211\fX)\203\317�\311\307x\210h\327\330\307\">\204x�\331c\210\332c\210\312y\210\333 \210b\210\313\334!\204\223�\325u\210\332c\210\333 \210\325y\210\333 \210\306 \210\313\335!\204\304�\307\210\336\337/\"\210\311\307x\210h\327\330\307\">\204\273�\331c\210\332c\210\333 \210\312y\210\312y\210\307\210\340 \202f\307\210\313\341!\203\354�\212\311\307x\210h)\342=\203\354�\343y\210\333 \202f\212\344\312!\210\313\345!\205�\313\346!\313\347!\320)\203F\n\2051\344\312!\210\325v\210``\212\307\210`){\350\212\307\210`)`Z!\210\351 \212\fb\210	c\210)?\205f\352	\203>\343\202?\353!\210\343y\202f\354`\355\"\203V\352\353!\210\343y\202f\313\356!\203d\325y\210\333 \202f\340 .\207" [res cut over start pos end beginning-of-line nil cperl-to-comment-or-eol " 	" -1 looking-at "[;{]" "[ 	]*}" re-search-forward "\\=[ 	]*;" t parse-partial-sexp "[,; 	]*\$$\\|#\$" cperl-after-block-p backward-sexp 1 point-marker append ";{" ";" "\n" cperl-indent-line "{[ 	]*$" "[ 	]*}[,; 	]*$" search-backward "}" newline-and-indent "\n[ 	]*{$" 41 2 forward-paragraph "\$\\`\n?\\|\n\$=\\sw+" "\$\\`\n?\\|\n\$=cut\\>" "\$\\`\n?\\|\n\$=over\\>" delete-char expand-abbrev cperl-ensure-newlines 4 get-text-property in-pod "\n[ 	]*$" beg] 8 (#$ . 75618) nil])
#@50 Insert character and correct line's indentation.
(defalias 'cperl-electric-semi #[(arg) "\203�\303	!\207\304\305	!!\210\n\205�\306 \207" [cperl-auto-newline arg cperl-autoindent-on-semi cperl-electric-terminator self-insert-command prefix-numeric-value cperl-indent-line] 3 (#$ . 77245) "P"])
#@50 Insert character and correct line's indentation.
(defalias 'cperl-electric-terminator #[(arg) "`\205
�	\306=?\206
�\n\307l\203\224�\212\310 \210\311\307w\210g\312U\206_�	\306=\203C�\212\313v\210\311\307w\210`
W\205?�
Sb\210\314\315!?)\206_�\316 \210\317`
\"\3208\206^�\3218\206^�\3228))\204\224�\323\324!!\210\f\203q�\325 \326 \210\f\203~�\327 \210\326 \210\212\203\214�\330!Sb\210\202\217�\331u\210\332\313!\210)\203\246�\212b\210\323\324!!)\202\254�\323\324!!+\207" [cperl-auto-newline last-command-event cperl-auto-newline-after-colon insertpos auto end 58 nil beginning-of-line " 	" 35 1 looking-at ":" beginning-of-defun parse-partial-sexp 3 4 5 self-insert-command prefix-numeric-value point-marker cperl-indent-line newline marker-position -1 delete-char pps arg] 3 (#$ . 77547) "P"])
#@149 Backspace, or remove the whitespace around the point inserted by an electric
key.  Will untabify if `cperl-electric-backspace-untabify' is non-nil.
(defalias 'cperl-electric-backspace #[(arg) "\203'�	\306>\203'�h\307>\203'�\310	\311=\203�\312\310w\210`\312\310x\210`\n|)\207	\313=\203/�\314\203P�	\314=\203P�h\315>\203P�\310\312\310w\210`\312\310x\210`\n|)\207\f\203X�\316
!\207\317
!\207" [cperl-auto-newline last-command p this-command cperl-electric-backspace-untabify arg (cperl-electric-semi cperl-electric-terminator cperl-electric-lbrace) (32 9 10) nil cperl-electric-lbrace " 	\n" cperl-electric-else cperl-electric-else-really (32 9 10) backward-delete-char-untabify delete-backward-char] 2 (#$ . 78369) "p"])
(put 'cperl-electric-backspace 'delete-selection 'supersede)
(defalias 'cperl-inside-parens-p #[nil "\300\301\302\217\207" [nil (byte-code "\212\214`\300 \210`}\210db\210\301`\302\303#\206�ef\304U*\207" [beginning-of-defun scan-lists -1 1 40] 4) ((error))] 3])
#@524 Indent current line as Perl code, or in some cases insert a tab character.
If `cperl-tab-always-indent' is non-nil (the default), always indent current
line.  Otherwise, indent the current line only if point is at the left margin
or in the line's indentation; otherwise insert a tab.

A numeric argument, regardless of its value,
means indent rigidly all the lines of the expression starting after point
so that this line becomes properly indented.
The relative indentation among the lines of the expression are preserved.
(defalias 'cperl-indent-command #[(&optional whole-exp) "\305``\"\210\203;�\306 \307\211\212\f\203�\310 \210`\311\312!\210`\nb\210\312y\210`)\2059�	\nV\2059�\313\n	\314$+\207\f\204L�\212\315\307x\210n)\204L�\316 \207\306 \207" [whole-exp end beg shift-amt cperl-tab-always-indent cperl-update-syntaxification cperl-indent-line nil beginning-of-line forward-sexp 1 indent-code-rigidly "#" " 	" insert-tab] 5 (#$ . 79365) "P"])
#@81 Indent current line as Perl code.
Return the amount the indentation changed by.
(defalias 'cperl-indent-line #[(&optional parse-data) "\306d`Z\306\211\211\211\307!\211\310 \210`\306=\204&�\311=\203.�\312 \306\202~�\313\306w\210<\203:�@\314\315!\203W�\314\316!\204W�\317V\203~�\\]\202~�g\320U\203e�Z\202~�g\321>\203s�\\\202~�g\322U\203~�\\\313\306w\210\n\205\211�iZ\211\203\224�\323!\203\244�d\fZ`V\203\265�d\fZb\210\202\265�\324!\210d\fZ`V\203\265�d\fZb\210.\207" [shift-amt beg i indent pos case-fold-search nil cperl-calculate-indent beginning-of-line t current-indentation " 	" looking-at "[A-Za-z_][A-Za-z_0-9]*:[^:]" "[smy]:\\|tr:" 0 125 (41 93) 123 zerop cperl-make-indent parse-data cperl-min-label-indent cperl-label-offset cperl-indent-level cperl-close-paren-offset cperl-brace-offset] 7 (#$ . 80330)])
(defalias 'cperl-after-label #[nil "h\300=\205�`\301Zfz\302>\205�\303 \210\304\305!\207" [58 2 (119 95) backward-sexp looking-at "[a-zA-Z_][a-zA-Z0-9_]*:[^:]"] 2])
(defalias 'cperl-get-state #[(&optional parse-start start-state) "\212`\306\211\211\211
\203�
\fX\203�
b\210\202!�\307 \210\306
`
\204Q�`\fW\203J�`\211\306\310	\f\311#\211@\311V\204(�\312\313\314!\210\202(�	\203Q�	b\210`\n\204`�\310	\f\311\306
%	\nF.\207" [prestart start state depth start-point parse-start nil beginning-of-defun parse-partial-sexp -1 t beginning-of-line 2 start-state] 7])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\301\207" [current-load-list cperl-look-for-prop default-boundp set-default ((pod in-pod) (here-doc-delim here-doc-group))] 3)
#@93 Given that P has a property PROP, find where the property starts.
Will not look before LIM.
(defalias 'cperl-beginning-of-property #[(p prop &optional lim) "\303dT^)	\n#\206�e\207" [p prop lim previous-single-property-change] 4 (#$ . 81950)])
(defalias 'cperl-sniff-for-indent #[(&optional parse-data) "\306``\"\210\307`\310\"\212\311>\203�\307`\312\"\204�\313!\202\310\314\315!\203*�\316\317!\202\310	\2048�\314\320!\2038�\321\202\310\307`\322\"\203C�\323\202\310\324 \210`\212\325\326w\210`)\211f`\326\211@A\326\211BC\326D\212\327\326!\210e`S]@\307@\310\"A\330AE\"A@\206\202�\310BA\331>\203\230�\332@B\"b\210\324 \210`)
b\210\326F\333G@GA@\"H\334G8\206\264�H@IHA@\211JA@K\326LG\203\356�G
\240\210GAJ\240\210\334G8\204\350�G\211MAA)I\240\210\335G8L\307`\312\"\203l\307@d@T^)\312\"D\332`\312\"T@\212\327@!\210\324 \210`@X\2031@b\210\325\326w\210`f\336\337\326\">?\2056`\2026\325\326w\210`)C\340@\"AD\204P\313\312\341@C$\202\306C\203c\313\312\342C\f@&\202\306\313\312\343@#\202\306\307\344\"\203z\313\344`\"\202\306\345J8\203\205\346\202\306\335J8\203\220\347\202\306K\204\f\325\326w\210\327L\206\240e!\210o\206\340`L=\206\340h\350=\206\340h\351=\203\277\352e!\206\340\f\336\353\326\">\206\340h\354=\203\334\355\356!\210\325\326x\210\314\357!\206\340\307`\360\"\211J\203\375G\203\375\f\361=\204\375G\211MAA)
C\241\210\313\362I\fJ\334H8%\202\306Kf\363U\211D\205\212Kb\210\364 )\211C\204ZN\204ZKTb\210\f\336D\203:\365\202;\353\326\">\204K\314\366!\204K\325\326w\210`L\313\367\f`DK%\202\306
b\210\327K!\210h\354=\203\210`\334Zfz\370>\203\210h\371=\203}\372K!\210\324 \210\327K!\210\202b`SK=\204\307h\336C\203\233\373\202\234\374\375\">\204\307h\351=\203\257\352K!\204\307\307`\360\"\204\307\372K!\210\313\376`\fCD%\202\306Kb\210\212\377u\210\201Q�O\201R�\326w\210\314\201S�!\203\"\314\201T�!\204\"g\201U�U\203\370\377y\210\202\324g\201V�U\203\201W�`\322\"\206\ndb\210\202\324\212\326\210`O)\201X�\201Y�!\210\202\324`\nW\2052\313\201Z�`OK$*\206\306\325\326x\210nLP\204F\327e!\210h\201[�=\203V\355\356!\210\327e!\210\307`\201\\�\"\203i\332`\201\\�\"b\202zh\201]�=\203\261\355\356!\210\314\201^�!\203\261\340\212\324 \210`)`\"A@\211@\203\261@Tb\210\325\326w\210\313\201_�K\fD\205\246C?L\201`�`&\202\306\313\201_�K\fD\205\300C?L\326`&.*\207" [res cperl-indent-left-aligned-comments indent-point char-after-pos char-after pre-indent-point cperl-update-syntaxification get-text-property syntax-type (pod here-doc here-doc-delim format) indentable vector looking-at "[ 	]*\n=" error "Spaces before POD section!" "^#" [comment-special:at-beginning-of-line] in-pod [in-pod] beginning-of-line " 	" nil cperl-backward-to-noncomment assoc (pod here-doc format here-doc-delim) cperl-beginning-of-property cperl-get-state 2 3 append "#\n" parse-partial-sexp terminator cont-line first-line REx-part2 4 [comment] [string] 59 125 cperl-after-block-and-statement-beg ")]}" 58 forward-sexp -1 "[ 	]*[a-zA-Z_][a-zA-Z_0-9]*[ 	]*:" first-format-line 10 toplevel 123 cperl-block-p "}" "[ 	]*\$#\\|$\$" in-parens (119 95) 44 cperl-backward-to-start-of-continued-exp " ;{" " ,;{" (nil) continuation 1 p prop look-prop is-block delim cperl-look-for-prop case-fold-search parse-data s-s start state containing-sexp old-indent x cperl-indent-parens-as-block colon-line-end cperl-indent-wrt-brace 0 " 	\n" "#\\|\$[a-zA-Z0-9_$]+\$:[^:]\\|=[a-zA-Z]" "[sym]:\\|tr:" 35 61 next-single-property-change search-forward ":" have-prev-sibling 41 attrib-group 98 "sub\\>" code-start-in-block t] 9])
#@125 Alist of indentation rules for CPerl mode.
The values mean:
  nil: do not indent;
  number: add this amount of indentation.
(defvar cperl-indent-rules-alist '((pod nil) (here-doc nil) (here-doc-delim nil) (format nil) (in-pod nil) (comment-special:at-beginning-of-line nil) (string t) (comment nil)) (#$ . 85616))
#@300 Return appropriate indentation for current line as Perl code.
In usual case returns an integer: the column to indent to.
Returns nil if line starts inside a string, t if in a comment.

Will not correct the indentation for labels, but will correct it for braces
and closing parentheses and brackets.
(defalias 'cperl-calculate-indent #[(&optional parse-data) "\212\306!\307\211\310!\203h\311\312\234\f\"\211\203#�\n\211A@)\202l\312\234\313=\2039�\314\234b\210\307\315\307\217\210i\202l\312\234\316=\203\336�\314\234\317=\203S�\320\234b\210iS\202l\314\234\321=\203n�\320\234b\210\3220\206h�1\323i#\202l\314\234\324=\203\327�\320\234b\210\325\307w\210`\326\234b\210\325\307w\210\327`	\"@\330\234\326\234b\210\322	0\206\242�1_\n\331=\203\257�2[\202\301�\n\332=\203\300�0\206\274�1[\202\301�\312g\332=\203\321�0\206\322�1\202\322�\312i$\202l\333\334\"\202l\312\234\335=\203\322\212\314\234b\210\336 \330\234\203\372�1\202\373�\312Z)\320\234\337=\203\n3\202\312\326\234\203\312\2024#\202l\312\234\340=\203D\320\234b\210i\326\234\203?\314\234\341=\203?12\\\202@\312\\\202l\312\234\342=\203\256\314\234b\210\322\320\234\343\344\307\">\203a\312\202c4\326\234\204w\330\234\203w\320\234\341=\204{\312\202\20012\\\345\346!\203\233\336 5V\203\226\336 6Z\202\234\347 \202\234i\320\234\337=\203\2513\202\252\312$\202l\312\234\350=\203\346\314\234b\210\320\234`V\203\342\336 5V\203\323\336 6Z\202l1\212\326\234b\210\336 )\\\202li\202l\312\234\351=\203a\314\234b\210\322n\203\3521!\20374\\\202	1\326\234\203\320\234\341=\20312\\\202 \312\330\234\203*\312\202,8\353\234b\210\354\234\203;i\202]\212\355 \210\345\356!)\203[\336 5V\203V\336 6Z\202]\347 \202]\336 $\202l\333\334\"\202l\333\357\",\207" [parse-data p what i cperl-indent-rules-alist x cperl-sniff-for-indent nil vectorp assoc 0 REx-part2 1 (forward-sexp -1) indentable terminator 2 first-line + -1 cont-line " 	)" 3 parse-partial-sexp 4 41 124 error "Unrecognized value of indent: %s" toplevel current-indentation 123 in-parens 125 continuation append "}])" looking-at "\$\\w\\|_\$+[ 	]*:" cperl-calculate-indent have-prev-sibling code-start-in-block zerop 6 5 beginning-of-line "[ 	]*[a-zA-Z_][a-zA-Z_0-9]*:[^:]" "Got strange value of indent: %s" cperl-regexp-indent-step cperl-indent-level cperl-close-paren-offset cperl-continued-brace-offset cperl-continued-statement-offset cperl-min-label-indent cperl-label-offset cperl-brace-offset cperl-brace-imaginary-offset] 7 (#$ . 85937)])
#@118 Return the indentation amount for line, assuming that
the current line is to be regarded as part of a block comment.
(defalias 'cperl-calculate-indent-within-comment #[nil "\302\211\212\303 \210\304\302w\210`g\305U\203 �\306y\203 �\307 \203 �`	b\210i+\207" [star-start end nil beginning-of-line " 	" 35 -1 cperl-to-comment-or-eol] 2 (#$ . 88524)])
#@138 Go to position before comment on the current line, or to end of line.
Returns true if comment is found.  In POD will not move the point.
(defalias 'cperl-to-comment-or-eol #[nil "\306\211\211\211\210`\306\211\204�\307\n\211\"\210\310 \210\311`\312\"\211\203,�\313`\312\306d$	\314=\204D�\203<�\nV\203Q�\315\316\n\317#\203Q�h\320=\205\301�\321u\210\317\202\301�\203^�\nX\203^�b\210\f\204\276�\322`\n\306\211\211\317&\323
8\203\270�\324
8\203\260�`\324
8b\210\325\326!\203\223�\315\327\n\330#\204^�\317\211\202_�\325\331!\203\247�\315\332\n\330#\204^�\317\211\202_�\317Sb\210\202^�\317\321u\210\202^�\317\211\203b�\323
8.\207" [e pr lim cpoint stop-in state nil cperl-update-syntaxification beginning-of-line get-text-property syntax-type next-single-property-change pod re-search-forward "\\=[ 	]*\$#\\|$\$" t 35 -1 parse-partial-sexp 4 2 looking-at "\$s\\|tr\$\\>" "\\=\\w+[ 	]*#\$[^\n\\\\#]\\|\\\\[\\\\#]\$*#\$[^\n\\\\#]\\|\\\\[\\\\#]\$*" move "\$m\\|q\\([qxwr]\$?\\)\\>" "\\=\\w+[ 	]*#\$[^\n\\\\#]\\|\\\\[\\\\#]\$*#" cperl-font-locking] 8 (#$ . 88883)])
(defalias 'cperl-modify-syntax-type #[(at how) "dW\205�\302\211T\303	$\210\302\211T\304\305$\207" [at how put-text-property syntax-table rear-nonsticky (syntax-table)] 5])
(put 'cperl-modify-syntax-type 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'cperl-protect-defun-start #[(s e) "\212b\210\303\304	\305#\205�\306`S`\307\n$\210\202�)\207" [s e cperl-st-punct re-search-forward "^\\s(" to-end put-text-property syntax-table] 5])
(defalias 'cperl-commentify #[(bb e string &optional noface) "\203\244�	\306=?\205\275�\n\203�\202�\f
\307ZV\203B�
\211dW\203>�\310\211T\311$\210\310\211T\312\313$\210*\202\204�
\n\211dW\203a�\310\211T\311$\210\310\211T\312\313$\210*S\n\211dW\203\203�\310\211T\311$\210\310\211T\312\313$\210*\n=\203\236�\307Z
V\203\236�\310
TS\311$\210\314
\"\207	\206\275�?\206\275�\310
\315\n\203\273�\316\202\274�\317$\207" [cperl-use-syntax-table-text-property noface string cperl-st-sfence cperl-st-cfence bb n 2 put-text-property syntax-table rear-nonsticky (syntax-table) cperl-protect-defun-start face font-lock-string-face font-lock-comment-face e cperl-st-punct how at cperl-string-syntax-table cperl-pod-here-fontify] 6])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\301\207" [current-load-list cperl-starters default-boundp set-default ((40 . 41) (91 . 93) (123 . 125) (60 . 62))] 3)
#@165 Get a syntax table cached in ST, or create and cache into ST a syntax table.
All the entries of the syntax table are ".", except for a backslash, which
is quoting.
(defalias 'cperl-cached-syntax-table #[(st) "\242\203�@\207\302 \240\210@\303\211\304W\203%�\305	\306#\210	T\211\202�)\305\307\310#\210\207" [st i make-syntax-table 0 256 modify-syntax-entry "." 92 "\\"] 5 (#$ . 91374)])
#@776 Find the end of a regular expression or a stringish construct (q[] etc).
The point should be before the starting delimiter.

Goes to LIM if none is found.  If IS-2ARG is non-nil, assumes that it
is s/// or tr/// like expression.  If END is nil, generates an error
message if needed.  If SET-ST is non-nil, will use (or generate) a
cached syntax table in ST-L.  If ERR-L is non-nil, will store the
error message in its CAR (unless it already contains some error
message).  ARGUMENT should be the name of the construct (used in error
messages).  OSTART, OEND may be set in recursive calls when processing
the second argument of 2ARG construct.

Works *before* syntax recognition is done.  In IS-2ARG situation may
modify syntax-type text property if the situation is too hard.
(defalias 'cperl-forward-re #[(lim end is-2arg st-l err-l argument &optional ostart oend) "\306\211\211\211\211\211\211\211\211\307\306w\210`m\203$�\310\202'�f\311\"A\312!\313\306\204J�\314\315
#\210\202`�\314\316CP
#\210\314\317CP
#\210\320\321\322\217\210\203\206�\314\211\323=\203v�\324\202w�\325
#\210\203\206�\314\325
#\210\f\n\257.	\207" [set-st reset-st go-forward i2 i st nil " 	" 0 assoc cperl-cached-syntax-table t modify-syntax-entry "$" "(" ")" bb (byte-code "	d\nT^)f=\203�\204�\306u\210\202R�\307 \310
!\210\311\312!\210`	TX\203-�\313\314!\210\310\f!\210\315\204R�h`\306Zf=\203R�\212\316u\210\317\315x\306\246\320U)\203R�\321u\210 \203\217�\204\217�g=\203\217�gz\322=\204\211�`!\"\211#dW\203\210�\323#\211T\307\"$\210\323#\211T\324\325$\210*\315 \326$ \203\360�`\211%&\203\273�g\327>\203\276�\330\331!\203\261�\320\225b\210\202\265�\332\315w\210`&\202\276�\321u\210\333\211\334=\203\312�\335\202\313�\336
#\210\203\330�\333\336
#\210\315'\337()\315*+,&\3068\315\207" [starter b p ender reset-st st 2 syntax-table set-syntax-table forward-sexp 1 error "Unfinished regular expression" nil -2 "\\\\" 0 -1 46 put-text-property rear-nonsticky (syntax-table) t (32 9 10 12) looking-at "[ 	\n\f]+\$#[^\n]*\n[ 	\n\f]*\$+" " 	\n\f" modify-syntax-entry 92 "\\" "." cperl-forward-re is-2arg cperl-st-punct how at go-forward i i2 set-st lim end st-l err-l argument] 10) ((error (byte-code "b\210\306\n\203
�\307\n!\210\204B�\310\311\f
\203%�\312\313

\206!�
#\202&�\314\206/�&\204B�@\204B�\240\210\306\207" [lim set-st reset-st end argument ostart nil set-syntax-table message "End of `%s%s%c ... %c' string/RE not found: %s" format "%c ... %c" "" oend starter ender bb err-l b] 7))) 92 "\\" "." ender starter b cperl-starters st-l] 9 (#$ . 91778)])
#@147 Find the end of a group in a REx.
Return the error message (if any).  Does not work if delimiter is `)'.
Works before syntax recognition is done.
(defalias 'cperl-forward-group-in-re #[(&optional st-l) "\204�\304C\304\211\211\302\305\306\217\210\203\"�\307\310\311#\210\307\312\311#\210	\203*�\313	!\210\n+\207" [st-l reset-st b st nil (byte-code "\303!\304\305\306	#\210\304\307\310	#\210\311 \312	!\210\313\314!\207" [st-l st reset-st cperl-cached-syntax-table modify-syntax-entry 40 "()" 41 ")(" syntax-table set-syntax-table forward-sexp 1] 4) ((error (message "cperl-forward-group-in-re: error %s" b))) modify-syntax-entry 40 "." 41 set-syntax-table] 4 (#$ . 94426)])
(defalias 'cperl-postpone-fontification #[(b e type val &optional now) "\203�	\206�\306\n\307\f
B$\207\306\n\f
$\207" [cperl-syntaxify-by-font-lock now b e type val put-text-property cperl-postpone] 6])
(put 'cperl-postpone-fontification 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'cperl-unwind-to-safe #[(before &optional end) "`\305	\203Q�\306 \210\307`\211\310\"\203Q�	\311	\310\"\211e=\203#�\305	\203K�\n\203=�	eS])b\210\306 \210`\211\202�	eS])\211b\210\202�eb\210\202�\312\313!\203b�\314\305x\315U\204b�\305u\210`\f\205\227�\212\f\203\221�\307\f\310\"\203\221�\f\316\f\310\305d$\211\203i�\fb\210n\204\213�\317y\210`\211\204m�\f\206\226�	)*\207" [opos pos before p end nil beginning-of-line get-text-property syntax-type cperl-beginning-of-property looking-at "\n*=" "\n" 0 next-single-property-change 1] 6])
#@131 Syntaxically mark (and fontify) attributes of a subroutine.
Should be called with the point before leading colon of an attribute.
(defalias 'cperl-find-sub-attrs #[(&optional st-l b-fname e-fname pos) "\204�\306C\306\211\211\211\211`\306\211\307\310\311\217\210\203\236�\312`\313\314\315!\2031�\316\2022�\317$\210\203W�\320\321\322\\`\"W\203W�\312\322\\`dT^)\323\324$\210\203\236� \325\314\315!\203l�!\202n�\"\306#$%&'\203\222�#\204\235�\312&\326%$B$\202\234�\312&%$$\210-\203\261�\327\330\331#\210\327\332\331#\210
\205\270�\333
!.\207" [st-l end1 start1 start after-first reset-st nil b (byte-code "\306\307\310\311	\203
�\312\202�\313\314\315\260!\203\324�\316\224\203R�\317\224\317\224d\nT^)\320\321#$%&\203G�\f\204Q�\322%$\323#
B$\202P�\322%$#
$\210-\324\224'\324\225('(\320\321#$%&\203\200�\f\204\212�\322%$\323#
B$\202\211�\322%$#
$\210-(b\210\325\225\203\312�)\204\255�\326*!)\327\330\331)#\210\327\332\333)#\210\334 +`\335)!\210\336\316!\210\335+!\210\321+\337\n`\340#\210\341\342 !\210\340\202��\321\207" [cperl-maybe-white-and-comment-rex after-first p font-lock-constant-face now val looking-at "\$" ":" "\$" "?" "" "\$\\sw+\$" "\$(\$?" 1 0 face nil put-text-property cperl-postpone 3 4 cperl-cached-syntax-table modify-syntax-entry 40 "()" 41 ")(" syntax-table set-syntax-table forward-sexp cperl-commentify t forward-comment buffer-size type e b cperl-syntaxify-by-font-lock start1 end1 st st-l reset-st] 8) ((error (byte-code "\304\305\306e`\"\205�	\205�	{\n$\210\307\211\207" [start1 end1 b start message "L%d: attribute `%s': %s" count-lines nil] 6))) put-text-property attrib-group looking-at "{" t 0 1 count-lines 3 syntax-type sub-decl face cperl-postpone modify-syntax-entry 40 "." 41 set-syntax-table p st pos b-fname e-fname font-lock-function-name-face font-lock-variable-name-face now val type e cperl-syntaxify-by-font-lock] 8 (#$ . 95967)])
(defalias 'cperl-look-at-leading-count #[(is-x-REx e) "`W\205J�\306\307	\203�\310\202�\311\312QS\313#\205J�h\314=?\205J�`S`\315\n\316\203B�\206I�\317\320
\fB$\202I�\317
\f$-\207" [e is-x-REx font-lock-warning-face now val type re-search-forward "\\=" "[ 	\n]*" "" "[{?+*]" t 123 face nil put-text-property cperl-postpone b cperl-syntaxify-by-font-lock] 6])
(put 'cperl-look-at-leading-count 'byte-optimizer 'byte-compile-inline-expand)
#@205 Scans the buffer for hard-to-parse Perl constructions.
If `cperl-pod-here-fontify' is not-nil after evaluation, will fontify
the sections using `cperl-pod-head-face', `cperl-pod-face',
`cperl-here-face'.
(defalias 'cperl-find-pods-heres #[(&optional min max non-inter end ignore-max end-of-here-doc) "\204\n�e\306\204�d\307\f!\306\211@\306\211AB\306\211CD\306\211EF\306\211GH\306\211IJ\306\211KL\306\211MN\306\211OP\306\211QR\306\211ST\306\211UV\306W\310\211XY\311 Z\306\211[\\\306\211]^\310_	\205�	@Y\211`\203\212�	@\202\213�ea`\205\224�	Ab\306Cc\306Cd\312\313!\203\251�\202\252�\313\312\314!\203\267�\f\202\270�\314e\312\315!\203\305�
\202\306�\315f\312\316!\203\323�\202\324�\316\312\315!\203\341�
\202\342�\315
\312\314!\203\357�\f\202\360�\314\f\312\317!\203\375�\202\376�\317g\312\320!\203\202\f\320\312\321!\203\202\321\312\322!\203'\202(\322h\312\323!\2035\2026\323i\312\324!\203C\202D\324jk\203Od\202Pl\325\326\327\330\331\332\333\334\326\335\336\337\326\340m\203\200\326\341\326\342\326\343\330n\344\330o\345\326\346\326\347\326\350\326\351\260\202\201\352\260p\353\216\212q\204\221\354\355!\210\f\203\241rAsBtC\356\357#\210b\210u\360=\203\314`\361=\203\314\310W\362\363!)\203\314\364\212\306\210`)\306#\210`W\203B\365p\310#\203B\306@\366\224D\212\367aD\306\211b%)bDa\370\224\203oh\371=\203G`SD\367aDS\306\211b%bDSa\372b8\203?DSvw\211xdW\203>\373x\211T\374w$\210\373x\211T\375\376$\210*DTb\210\202\366\224\211Fvw\211xdW\203k\373x\211T\374w$\210\373x\211T\375\376$\210*\202\372b8\204\377b8\204\361\224\203
\366\224D\367aD\306\211b%bDa\372b8\204\254\377b8\204\254\362\201\214�!\203\323\372b8\204\377b8\204k\204\354\201\215�!\210d@\204d`\240\210\202\201\216� \210`\211DF\366\224O\306I\365\201\217�l\201\220�#\204Db\210\365\201\221�l\201\220�#\203\354\201\222�!\210\310Id@\204dD\240\210\201\216�\201\223�!\210`\211EV\2036\356E\201\224�#\210O@\373DE\201\225�\310$\210\373DE\201\226�\201\225�$\210Db\210\365\201\227�E\310#\203\354\201\216� \210\373DyeyS])`\201\226�\201\230�$\210D`\310z{|z\203\212}\204\227\373e|S]{~\310$\210+\f\203\326D`\201A�A\310\200\201ED}\203\312\204\325\373DE\201\231�\201\200B$\202\324\373DE\201\200$\210-\365\201\232�E\201\220�#\210\201\216� \210`D\202R\373`yeyS])E\201\226�\201\230�$\210`E\310z{|z\203}\204!\373e|S]{~\310$\210+\f\203\362`E\201A�A\310\200\201ED}\203T\204_\373DE\201\231�\201\200B$\202^\373DE\201\200$\210-Fb\210\362\201\233�!\203\247\361\224\361\225\201A�B\306\200\201ED}\203\233\204\246\373DE\201\231�\201\200B$\202\245\373DE\201\200$\210-\365\201\234�E\201\220�#\203\362\361\224\361\225\201A�B\306\200\201ED}\203\343\204\356\373DE\201\231�\201\200B$\202\355\373DE\201\200$\210-\202\247\364FE\306#\210Eb\210Ed=\204\201\235�u\210\202\201\223�\224\203v`D\366\224O\201\236�\224\205O\201\237� \202\201\240�\216\362\201\241�!\206N\212\306\201\242�\201\243�\217)\206N\201\244�\224?\205N\362\201\245�!*\211M\204\201\223�\225M\201\236�\224\203q\201\236�\224I\201\236�\225J\202y\377\224I\377\225JIJ{G\201\246�G!H\f\203\352IJ\201A�e\306\200\201ED}\203\273\204\306\373DE\201\231�\201\200B$\202\305\373DE\201\200$\210-IJ\310z{|z\203\334}\204\351\373e|S]{~\310$\210+\306y\210`L\203\203\371\203b\210`D\365\201\247�H\201\250�Ql\201\220�#\204,db\210\365\201\251�!\210\354\201\252�G\"\210d@\204,dD\240\210\f\203\311\366\224\366\225\201A�e\306\200\201ED}\203_\204j\373DE\201\231�\201\200B$\202i\373DE\201\200$\210-D\366\225\310z{|z\203\200}\204\215\373e|S]{~\310$\210+D\366\224\201A�C\306\200\201ED}\203\275\204\310\373DE\201\231�\201\200B$\202\307\373DE\201\200$\210-\366\225ydyT^)J\373D\366\224\201\226�\201\253�$\210\373\366\224J\201\226�\201\254�$\210\373DJ\201\255�\310$\210\373D\211ydyT^)\201\256�\201\257�$\210\364DJ\306#\210D\366\225\310z{|z\203+}\2048\373e|S]{~\310$\210+abB\201\260�ML\310\204\310J&\361\234\211[\203d[`V\203d[b\210\202hJ[JV\203O@\202\201\261�\224\203	`D\201\261�\224\203\223\201\261�\224\201\261�\225{\202\224\352]\366\224O\306K\373\212\201\216� \210`)D\201\262�\310$\210\f\203`\306y\366=\203k\362\201\263�!\204k\362\201\264�!\204\262K\203\342\362\201\265�!\203\342\201\266�\361!\210\306K\202\262K\203\355\306K\202\262`I\362\201\267�!K\306\210I`\201A�\306\200\201ED}\203(\2043\373DE\201\231�\201\200B$\2022\373DE\201\200$\210-\364I`\306#\210I`\310z{|z\203O}\204\\\373e|S]{~\310$\210+\202\262\365\201\263�l\201\220�#\210\201\216� \210\362\201\270�!\203\347``\201\223�\\\201A�\306\200\201ED}\203\251\204\264\373DE\201\231�\201\200B$\202\263\373DE\201\200$\210-\364``\201\223�\\\306#\210``\201\223�\\\310z{|z\203\326}\204\343\373e|S]{~\310$\210+\202\373\354\201\271�]\"\210d@\204\373dD\240\210\306y\210`V\203	O@\373D`\201\226�\201\272�$\210\202\201\273�\224\204%	\201\274�\224\203#\201\273�\224\2032	\201\273�\2025	\201\274�\211I\224I\225{K`\211DLI\224fMI\224SfFI\201\273�=\203\310	F\201\275�\201\276�\306\">\205\341	F\201\277�=\203{	M\201\300�=\202\341	F\201\301�=\203\223	I\224\201\223�Zf\201\301�=\202\341	F\201\302�=\203\253	I\224\201\223�Zf\201\277�=\202\341	F\201\303�=\203\304	I\224\201\223�Zf\201\303�=?\202\341	\310\202\341	M\201\304�=\205\341	\201\237� \202\201\305�\216\362\201\306�!*F\366\224OI\224b\210\201\307�e!\210F\204\303\nI\201\274�=\203\245\n\352K\306Ih\201\275�M\201\310�>\203\n\201\311�\202\n\201\312�\306\">\204|\nh\201\313�=\2032\n\201\314�e!\204|\nhz\201\315�=\203c\n\201\266�\201\235�!\210h\201\277�=\203S\n\362\201\316�!\202`\nh\201\317�>\204c\n\362\201\320�!\204|\nh\201\321�=\203x\n`\201\223�Zf\201\321�=\204|\no\205\232\nM\201\322�=\205\231\nm\205\231\no?\205\231\n\201\235�u\210\362\201\323�!??FDSD\202\303\nhI`I\201\302�=\203\303\n
\201\223�Zf\201\277�=\203\303\n\310FF\204\235Db\210\362\201\324�!\203\333\n\366\225b\210\202\341\n\201\325�\306w\210g\201\313�=\203HI\201\326�=\203H
Sb\210\201\325�\306x\210h\201\275�\201\327�\306\">\203\310F\202\306\201\330�\201\331�\217\210F\204;\362\201\332�!\204;g\201\333�>\203A\201\266�\361!\210\362\201\334�!\203A\310F\202\235Db\210\202\235g\201\335�=\203``Tf\201\302�=\203`\310F\202\235g\201\301�=\203\226I\201\326�=\203\226\362\201\336�!\203\226
Sb\210\201\325�\306x\210h\201\275�\201\327�\306\">\203\226\310F\202\235m\203\235\310FF\203\251Lb\210\202\362\201\324�!\203\270\366\225b\210\202\276\201\325�\306w\210`DV\203\321\373D`\201\226�\201\337�$\210`D\201\340�\201\341�K\"U\201\342�l\204UcdK&\211LA@I\201\223�L8G\377L8L@L`JL\205\fG?\205\fJSNL\203&\fL\202(\fJE\306\211HQ\306\\L\203J\fN\203J\fLf\201\343�=\203J\f\310H
\203V\f\362\201\344�!\202[\f\362\201\345�!\203a\f\310Q
\203m\f\362\201\346�!\202r\f\362\201\347�!\203x\f\310\\L\204\311\f\364D`\310#\210\373D`\201\226�\201\350�$\210Q\204\241\f\201\340�\201\351�K\"\203\253\f\373D`\201\352�\310$\210
\203\275
JydyT^)\211J\203\275
m\204\275
\361u\210\202\275
\364DL\310#\210\362\201\353�!\203o
abB\201\260�I`S\310\204$@\203\362\fTb\210G\203C
h\201\302�=\203C
`S\205w\211xdW\203 
\373x\211T\374w$\210\373x\211T\375\376$\210*L\206w\211xdW\203B
\373x\211T\374w$\210\373x\211T\375\376$\210*\373DL\201\226�\201\350�$\210\373L`\201\226�\201\354�$\210Q\203\275
\373DL\201\352�\310$\210\202\275
\364I`\310#\210\373D`\201\226�\201\350�$\210Q\203\222
\373DL\201\352�\310$\210H\203\272
LTvw\211xdW\203\271
\373x\211T\374w$\210\373x\211T\375\376$\210*\306Ngz\201\315�=\203\361v\210N\203\325
\364N`\310#\210J`\201A�i\306\200\201ED}\203\204\373DE\201\231�\201\200B$\202
\373DE\201\200$\210-\201\340�\201\355�K\"\205+KG\366U?\206+M\201\304�=?\211P\203\210E\201\223�D\\=\203\210\212\306\201\356�\201\357�\217)\203\210DE\201A�\306\200\201ED}\203y\204\204\373DE\201\231�\201\200B$\202\203\373DE\201\200$\210-\202mU\204\260\207\203.\201\340�\201\360�K\"\204\260KG\366=\203.Df\201\304�=\204.D\211ydyT^)\201A�e\306\200\201ED}\203\346\204\361\373DE\201\231�\201\200B$\202\360\373DE\201\200$\210-ESE\201A�e\306\200\201ED}\203\"\204-\373DE\201\231�\201\200B$\202,\373DE\201\200$\210-P\203T\210\203T\212DTb\210QEEQ`EW\203\253\365\201\361�Q\203\\\201\362�\202]\352\201\363�QES\310#\203\253h\201\326�=\204\253`S`\201A�\306\200\201ED}\203\237\206\251\373DE\201\231�\201\200B$\202\251\373DE\201\200$-\210*Q\203\307Df\201\364�=\203\301\201\365�\202\332\201\366�\202\332Df\201\364�=\203\327\201\367�\202\332\201\370�\326\201\371�\326\201\372�\326Df\201\373�=\203\363\201\374�\202Df\201\322�=\203\201\375�\202\201\376�\326\330\201\377�\330\201�\326\201\326\201\337\330\211\201\201\201\326\201\201\326\201\326\201\326\201	\326\201\n\326\201\330\201\f\326\201
\326\201\326\201\326\201\201\337\326\201\2601V`ESW\203S\365VES\201#\203S\366\224b\210`RgT\201\244�\224\203\376\366\225b\210\201\274�\224\203\225\201\274�\224b\210`EY\203\241ESb\210\366\224`\201A�T\201\373�=\203\273\306\201\201\217\202;T\201=\203\311h\202;T\201=\203\f`RTV\203\373\366\224`\201\\\203\352\366\202�\366\224DT=\203\377`ES=\203\377\361\202�\310$\210\202;f\202;T\201\275�\201\306\">\203f\202;T\201=\2039\201\273�\224\2044h\202;g\202;g\306\200\201ED}\203a\204l\373DE\201\231�\201\200B$\202k\373DE\201\200$\210-T\201\275�\201\306\">\203\370\201\340�\201\201\366!\"\204\370QEEQ`EW\203\367\365\201\361�Q\203\250\201\362�\202\251\352\201\363�QES\310#\203\367h\201\326�=\204\367`S`\201A�\306\200\201ED}\203\353\206\365\373DE\201\231�\201\200B$\202\365\373DE\201\200$-\210*\306T\202\371\201\224\203\270\201\223�u\210`EY\203ESb\210\202\262`RhH`\201\223�Z`S\201A�H\201\275�\201\306\">\203<\202>g\306\200\201ED}\203d\204o\373DE\201\231�\201\200B$\202n\373DE\201\200$\210-DfH=\203H\201\275�\201\306\">\203m\203\237H\201\373�=\203\237\373R`S\374v$\210`S`\201A�H\201\275�\201 \306\">\203\271\201f�\202\320H\201\275�\201!\306\">\203\315\201g�\202\320\201h�\306\200\201ED}\203\366\204\373DE\201\231�\201\200B$\202�\373DE\201\200$\210-H\201\275�\201\"\306\">\203\365\201#ES\201#\204wH\201\275�\201$\306\">\203:\365\201%ES\201#\204wH\201&=\203Q\365\201'ES\201#\204wH\201\275�\201(\306\">\203m\365\201)ES\201#\204wHz\201\315�=\203\262RS`\201A�j\306\200\201ED}\203\246\204\261\373DE\201\231�\201\200B$\202\260\373DE\201\200$\210-\306T\202\371\372\224\2039\361u\210Df\201*=\203\353g\201\343�=\203\366`ydyT^)f\201*=\203\366\201\223�u\210\202\366g\201*=\203\366\361u\210DK\306G`HDf\201+=\2034g\201\343�=\203?`ydyT^)f\201+=\203?HT\211H\203?\201\223�u\210\202?g\201+=\203?\361u\210K\203\365Df\201+=\203U\201,\202X\201-ES\201\220�#\203\212\201.\201/K\310#\205\346R`W\205\346h\201\343�=\205\212\2010\306x\201\223�\246\366U?\205\346\362Df\201+=\203\237\2011\202\336Df\201\301�=\203\257\2012\202\336Df\201*=\203\277\2013\202\336Dfz\201\315�=\203\333\2014\2015Df!\2016Q\202\336\2017!\205\346`\211K)\203\372K`BGBG`\211K\202A\306\211K\204DK\203\354\2018R\"\210m\203)`\201\223�ZRV\203)\373RT`S\374v$\210RH\201A�f\306\200\201ED}\203X\204c\373DE\201\231�\201\200B$\202b\373DE\201\200$\210-`S`\201A�f\306\200\201ED}\203\222\204\235\373DE\201\231�\201\200B$\202\234\373DE\201\200$\210-Df\201+=\203\346`\201\223�Z`S\201A�g\306\200\201ED}\203\332\204\345\373DE\201\231�\201\200B$\202\344\373DE\201\200$\210-G\2033G@@G@A\201A�j\306\200\201ED}\203\204)\373DE\201\231�\201\200B$\202(\373DE\201\200$\210-GA\211G\204\353\306T\202\371\201\223�\224\203c\201\223�\224\201\223�\225U\204c\201\216�\201\223�!\210`EV\203\371ESb\210\202\371\377\224\203\272\306T\366\225b\210m\203}\373`S`\374v$\210`S`\201A�\306\200\201ED}\203\253\204\266\373DE\201\231�\201\200B$\202\265\373DE\201\200$\210-\202\371\201\236�\224\203\341\366\225G\2019c!\211H\204\367`EY\203\341\201:\211H\204\367`\201\223�Zf\201\313�=\204\201;\211H\203ESb\210\354\201<H\"\210\202\333GS`S\201A�\306\200\201ED}\2037\204B\373DE\201\231�\201\200B$\202A\373DE\201\200$\210-RGS\201A�f\306\200\201ED}\203s\204~\373DE\201\231�\201\200B$\202}\373DE\201\200$\210-`S`\201A�f\306\200\201ED}\203\255\204\270\373DE\201\231�\201\200B$\202\267\373DE\201\200$\210-m\203\333\373`\201\223�Z`S\374\211$\210\373R\201\223�\\R\372\\\374\211$\210\306T\202\371\201=\201>ES\201\220�#\204\371\354\201?R\"\210`EY\203ESb\210T\203^`S\364RS\306#\210RS\201A�\306\200\201ED}\203D\204O\373DE\201\231�\201\200B$\202N\373DE\201\200$\210-\202^)P\203mQ\203m\373DTES\201@\201A$\210U\203J\203I\203JIV\203JSJ\201A�e\306\200\201ED}\203\264\204\277\373DE\201\231�\201\200B$\202\276\373DE\201\200$\210-m\204\201BDf\212\"\203I\211T\201A�e\306\200\201ED}\203\377\204\n\373DE\201\231�\201\200B$\202	\373DE\201\200$\210-\373I\211T\201C\310$\210`V\203O@\202\201D\224\203\230\201E\224I\201E\225JDSf\201F>\204Db\210\201D\224f\201=\203\202\364\201D\224\201D\225\310#\210\366\225b\210\201G\201H !\210\362\201I!\203\201JcIJD$\210\202\201D\224b\210\201JcIJD$\210\202\201K\224\203\265\366\225F\373FSF\374\213$\210Fb\210\202\201L\224\203\316\366\225F\364DF\306#\210\310\204\202\201M\224\203\f\366\225FDb\210\2010\306x\210Dvw\211xdW\203\373x\211T\374w$\210\373x\211T\375\376$\210*Fb\210\202\201N\201O!\210`lV\203\314\204\203)\354\201P!\210\202;\354\201Q!\210d@\204;dD\240\210lb\210\202\314abB@\206P`])d@\203`d@b\210\202kq\204k\354\201R!\210)d@[.5D\207" [min cperl-syntax-state cperl-syntax-done-to max cperl-pod-here-fontify go nil eval t buffer-modified-p boundp font-lock-string-face font-lock-constant-face font-lock-function-name-face font-lock-variable-name-face font-lock-builtin-face font-lock-comment-face font-lock-warning-face font-lock-keyword-face cperl-nonoverridable-face font-lock-type-face "\$\\`\n?\\|^\n\$=" "\\|" "<<" "\$" "[ 	]*" "\\([\"'`]\$" "\$[^\"'`\n]*\$" "\\3" "\\\\?\$\\([a-zA-Z_][a-zA-Z_0-9]*\$?\\)" "\$\$" "\\)" "^[ 	]*\$format\$[ 	]*\$[a-zA-Z0-9_]+\$?[ 	]*=[ 	]*$" "\\<\$q[wxqr]?\\|[msy]\\|tr\$\\>" "\$[?/<]\$" "\\<sub\\>" "\$::[a-zA-Z_:'0-9]*\\|[a-zA-Z_'][a-zA-Z_:'0-9]*\$\\)?" "\$([^()]*)\\|:[^:]\$\\)" "\\$\$['{]\$" "\$\\<sub[ 	\n\f]+\\|[&*$@%]\$[a-zA-Z0-9_]*'" "__\$END\\|DATA\$__" "\\\\\$['`\"($]\$" "" ((byte-code "\301 \203
�\204
�\302\303!\210\303\207" [modified buffer-modified-p set-buffer-modified-p nil] 2)) message "Scanning for \"hard\" Perl constructions..." remove-text-properties (syntax-type t in-pod t syntax-table t attrib-group t REx-interpolated t cperl-postpone t syntax-subtype t rear-nonsticky t front-sticky t here-doc-group t first-format-line t REx-part2 t indentable t) emx 1 looking-at "extproc[ 	]" cperl-commentify re-search-forward 0 parse-partial-sexp 18 39 3 put-text-property syntax-table rear-nonsticky (syntax-table) 4 tmpend face head-face here-face b e bb tag qtag b1 e1 argument i c tail tb is-REx is-x-REx REx-subgr-start REx-subgr-end was-subgr i2 hairy-RE case-fold-search inhibit-read-only buffer-undo-list modified overshoot is-o-REx name after-change-functions cperl-font-locking use-syntax-state state-point state st-l err-l my-cperl-delimiters-face my-cperl-REx-spec-char-face my-cperl-REx-0length-face my-cperl-REx-ctl-face my-cperl-REx-modifiers-face my-cperl-REx-length1-face ignore-max stop-point cperl-use-syntax-table-text-property cperl-white-and-comment-rex cperl-maybe-white-and-comment-rex search non-inter cperl-pod-face cperl-pod-head-face cperl-here-face system-type cperl-st-punct how at p post to from cperl-syntaxify-by-font-lock cperl-do-not-fontify now val type save-match-data-internal end-of-here-doc end cperl-st-ket cperl-st-bra cperl-fontify-m-as-s cperl-regexp-scan cperl-st-cfence cperl-starters cperl-st-word "cut\\>" "=cut is not preceded by a POD section" beginning-of-line "^\n=cut\\>" toend "\n=cut\\>" "=cut is not preceded by an empty line" 2 (syntax-type t in-pod t syntax-table t attrib-group t REx-interpolated t cperl-postpone t syntax-subtype t here-doc-group t rear-nonsticky t front-sticky t first-format-line t REx-part2 t indentable t) in-pod syntax-type "\n\n[ 	]" pod cperl-postpone "\n\n[^ 	\f\n]" "=[a-zA-Z0-9_]+\\>[ 	]*\$\\(\n?[^\n]\$+\\)$" "^\n=[a-zA-Z0-9_]+\\>[ 	]*\$\\(\n?[^\n]\$+\\)$" -1 5 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "[ 	]*(" (byte-code "b\210\302\303!\210\304 \305\216\306\307!\205 �\302\310!\210\306\311!\205 �\312\313\314\217*\207" [tb save-match-data-internal forward-sexp -1 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) looking-at "[0-9$({]" 1 "[ 	]*<<" nil (byte-code "\300\301!\210\302\303!?\207" [forward-sexp -2 looking-at "\$printf?\\|system\\|exec\\|sort\$\\>"] 2) ((error t))] 3) ((error)) 6 "[ 	]*[=0-9$@%&(]" regexp-quote "^" "$" "\\'" "End of here-document `%s' not found." here-doc here-doc-delim here-doc-group front-sticky (syntax-type) cperl-find-pods-heres 8 first-format-line "^[.;]$" "^#" "^[ 	]*{" forward-sexp "^[^\n]*[@^]" "^\\.$" "End of format `%s' not found." format 10 11 append "$@%*#_:-&>" 45 115 58 62 38 60 ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) "\\$?\$[_a-zA-Z:][_a-zA-Z0-9:]*\$?>" cperl-backward-to-noncomment (63 60) "~{(=|&*!,;:[" "~{(=|&+-*!,;:[" 125 cperl-after-block-p 119 "[a-zA-Z]\\>" (36 64 38 37) "\$while\\|if\\|unless\\|until\\|and\\|or\\|not\\|xor\\|split\\|grep\\|map\\|print\$\\>" 46 63 "\\s|" "[ 	\n\f]+\$#[^\n]*\n[ 	\n\f]*\$+" " 	\n\f" 123 "$@%&*" (forward-sexp -1) ((error)) "[$@]\\$*\$[a-zA-Z0-9_:]+\\|[^{]\$\$[ 	\n]*->\$?[ 	\n]*{" (123 91) "\$[ 	\n]*->\$?[ 	\n]*{" 61 "::[a-zA-Z0-9_:]*[ 	\n\f]*}" prestring string-match "^\$[sy]\\|tr\$$" cperl-forward-re 92 ".\\sw*x" "\\sw*x" ".\\sw*o" "\\sw*o" string "^qw$" indentable "\\sw*e" multiline "^\$[sm]?\\|qr\$$" (byte-code "b\210\301\302!\210\303\304!?\207" [tb forward-sexp -1 looking-at "split\\>"] 2) ((error t)) "^\$m\\|qr\$$" "\\=" "[ 	\n]*" "[{?+*]" 35 "\$(\\?\\\\#\$\\|\$\\\\#\$" "\$(\\?#\$\\|\$#\$" "\$(\\?\\\\#\$\$\$" "\$(\\?#\$\$\$" "\$\\[\$" "\$]\$" 41 "\$))))\$" "\$(\\\\\\?\\\\\\?{\\|()\\\\\\?{\$" "\$(\\?\\??{\$" "[$@]" "[_a-zA-Z:][_a-zA-Z0-9:]*" "{[^{}]*}" "[^{(|) 	
\n\f]" "->" "\\)?" "\\[[^][]*\\]" "\\)*" "[)^|$.*?+]" "{[0-9]+}" "{[0-9]+,[0-9]*}" "\\\\[luLUEQbBAzZG]" "(" "\\?\$(\\?\$" "\\?[:=!>?{]" "\\?[-imsx]+[:)]" "\\?([0-9]+)" "\\?<[=!]" "\\\\\$.\$" to-end (byte-code "\212\304\305!\210`V\203(�f\306=\203�\307\310!\202�`Tf\306=\203$�	\202)�\n\202)�)\207" [b my-cperl-REx-0length-face my-cperl-REx-ctl-face font-lock-warning-face forward-sexp -1 63 looking-at "(\\\\\\?"] 2) ((error font-lock-warning-face)) 124 36 REx-interpolated "^." 40 "(|" "(\\?[-imsx]+)" match-string 12 "ghijkmoqvFHIJKMORTVY" ".])^$|*?+" ".]^$" "*?+" "01234567" "\\=[01234567]?[01234567]?" "89" "\\=[0123456789]*" 120 "\\=[0-9a-fA-F][0-9a-fA-F]?\\|\\={[0-9a-fA-F]+}" "pPN" "\\={[^{}]+}\\|." 94 93 "\\=\$\\\\[^]]\\|[^]\\\\]\$*\\\\]" "\\=\$\\\\.\\|[^]\\\\]\$*]" search-backward "[" "\\\\" "\\\\*\\[:\\^?\\sw+:\\\\\\]" "\\\\*\\[\\\\:\\^?\\sw+\\\\:]" "\\\\*\\[:\$\\\\\\^\$?\\sw+:]" "\\\\*\\[:\$\\\\\\^\$?\$\\\\" char-to-string "\\|\\sw\$+:]" "\\\\*\\[:\\^?\\sw*:]" "Couldn't find end of charclass in a REx, pos=%s" cperl-forward-group-in-re "no matching `)' found" "Can't find })" "%s" search-forward ")" "Couldn't find end of (?#...)-comment in a REx, pos=%s" syntax-subtype x-REx assoc REx-part2 17 14 (36 64 37 38 42) forward-comment buffer-size ":[^:]" cperl-find-sub-attrs 19 20 21 error "Error in regexp of the sniffer" "Garbage after __END__/__DATA__ ignored" "Unbalanced syntax found while scanning" "Scanning for \"hard\" Perl constructions... done"] 50 (#$ . 98412) nil])
(defalias 'cperl-find-pods-heres-region #[(min max) "\302	\"\207" [min max cperl-find-pods-heres] 3 nil "r"])
(defalias 'cperl-backward-to-noncomment #[(lim) "\304\211\211\n?\205X�`\206�eV\205X�\305x\210`\306 \210\307`\310\"\211\311>\2032�\312\304!\210\307`\310\"\313\314!\203>�\315>\203�\316 \210n\204�\317\304x\210	`W\203R�	b\210\320\211\202�+\207" [pr p stop lim nil " 	\n\f" beginning-of-line get-text-property syntax-type (pod here-doc here-doc-delim) cperl-unwind-to-safe looking-at "^[ 	]*\$#\\|$\$" (string prestring) cperl-to-comment-or-eol " 	" t] 4])
(defalias 'cperl-block-p #[nil "\301e!\210h\302\303\304\">\206I�\212\305 )\206I�\306`eS])\307\"\206I�hz\310>\205I�\311 \210\312\313!\2038�\312\314!?\206I�\301e!\210h\315=\205I�\316\317!\210\312\320!\207" [p cperl-backward-to-noncomment append ";){}$@&%�" nil cperl-after-label get-text-property attrib-group (119 95) backward-sexp looking-at "[a-zA-Z0-9_:]+[ 	\n\f]*[{#]" "\$bless\\|return\\|q[wqrx]?\\|tr\\|[smy]\$\\>" 98 forward-sexp -1 "sub[ 	\n\f#]"] 4])
#@287 Return true if the preceeding } (if PRE-BLOCK, following {) delimits a block.
Would not look before LIM.  Assumes that LIM is a good place to begin a
statement.  The kind of block we treat here is one after which a new
statement would start; thus the block in ${func()} does not count.
(defalias 'cperl-after-block-p #[(lim &optional pre-block) "\212\300\301\302\217)\207" [nil (byte-code "\204�\303\304!\210\305	!\210`	=\206[�h\306=\206[�\212\307 )\206[�\310`e\nS])\311\"\206[�hz\312>\203X�\212\303\304!\210\313\314!\203E�\313\315!?\206V�\305	!\210h\316=\205V�\303\304!\210\313\317!)\207\320	!\207" [pre-block lim p forward-sexp -1 cperl-backward-to-noncomment 41 cperl-after-label get-text-property attrib-group (119 95) looking-at "\$else\\|continue\\|grep\\|map\\|BEGIN\\|END\\|CHECK\\|INIT\$\\>" "\$\\sw\\|_\$+::" 98 "sub[ 	\n\f#]" cperl-after-expr-p] 3) ((error))] 3 (#$ . 120365)])
#@260 Return true if the position is good for start of expression.
TEST is the expression to evaluate at the found position.  If absent,
CHARS is a string that contains good characters to have before us (however,
`}' is treated "smartly" if it is not in the list).
(defalias 'cperl-after-expr-p #[(&optional lim chars test) "\206�e\306\211\211\307``\"\210\212\204\203�`V\203\203�\310x\210`\311 \210\312`\313\"\2036�\314`\313\"b\210\311\315!\210\312`\316\"\203G�\314`\316\"b\210\311\315!\210\317\320!\204�\321 \210\322\306x\210\n`W\203]�\nb\210`h\323=\203z�\324u\210\310x\210hz\325>\203z�\326\324!\210\202�\nb\210\327\211\203�o\206\302�`=\206\302�\317\330!\206\302�\f\203\235�\331\f!\202\302�h\332
\206\244�\333\306\">\206\302�h\334=\203\266�\335!\206\302�g\336=\205\302�\312`\337\"\340=-\207" [lim pr p stop test chars nil cperl-update-syntaxification " 	\n\f" beginning-of-line get-text-property here-doc-group cperl-beginning-of-property 0 in-pod looking-at "^[ 	]*\$#\\|$\$" cperl-to-comment-or-eol " 	" 58 -1 (119 95) forward-sexp t "[ 	]*__\$END\\|DATA\$__" eval append "{;" 125 cperl-after-block-p 46 syntax-type format] 5 (#$ . 121268)])
(defalias 'cperl-backward-to-start-of-expr #[(&optional lim) "\300\301\302\217\207" [nil (byte-code "\203\n�`V\205�\301!?\205�\302\303!\210\304\305x\210\202��\207" [lim cperl-after-expr-p forward-sexp -1 "$@%#" nil] 2) ((error))] 3])
(defalias 'cperl-at-end-of-expr #[(&optional lim) "\301\302P!\206\f�\303\304\305\217\207" [cperl-maybe-white-and-comment-rex looking-at "[;}]" nil (byte-code "\212`\302\303!\210\302\304!\210h\305\306\307\">\203�\304u\210\202�`W\206#�\310	!*\207" [p lim forward-sexp 1 -1 append "%&@$*" nil cperl-after-expr-p] 4) ((error t))] 3])
(defalias 'cperl-forward-to-end-of-expr #[(&optional lim) "\300\301\302\217\207" [nil (byte-code "`\206�dW\205�\301 ?\205�\302\303!\210\202��\207" [lim cperl-at-end-of-expr forward-sexp 1] 2) ((error))] 3])
(defalias 'cperl-backward-to-start-of-continued-exp #[(lim) "h\301\302\303\">\203
�\304\305!\210\306 \210`X\203�Tb\210\307\303w\207" [lim append ")]}\"'`" nil forward-sexp -1 beginning-of-line " 	"] 4])
(defalias 'cperl-after-block-and-statement-beg #[(lim) "\301!\205*�\212\302\303!\210\304e!\210o\206)�`=\206)�hz\305U?\206)�\302\303!\210\306\307!?)\207" [lim cperl-after-block-p forward-sexp -1 cperl-backward-to-noncomment 119 looking-at "\$map\\|grep\\|printf?\\|system\\|exec\\|tr\\|s\$\\>"] 2])
#@267 Simple variant of indentation of continued-sexp.

Will not indent comment if it starts at `comment-indent' or looks like
continuation of the comment on the previous line.

If `cperl-indent-region-fix-constructs', will improve spacing on
conditional/loop constructs.
(defalias 'cperl-indent-exp #[nil "\212\305\210`\305\211\212\306 \210\204z�`\307`\n\310#@\310U\203$�`\202�	b\210`\nW\203?�\307`\n\305\311$\210l\204'�\312\313!\210\202'�`\nV\204p�h\314=\203X�`\305\315\316\217\210	b\210\202p�\317\320P!\203n�\321\225b\210\212\305\210`)\202p�\311\212\305\210`)\202�\nb\210\322 )\f\203\211�\323\n!\210\324`\n\",\207" [done top tmp-end cperl-maybe-white-and-comment-rex cperl-indent-region-fix-constructs nil beginning-of-line parse-partial-sexp -1 t forward-sexp 1 41 (byte-code "\302\303!\210g\304=\203�\302\305!\210\306\307!\203�\302\305!\210\306\310\311\312\313\260!\203.�	b\210\302\314!\210`\302\207" [cperl-maybe-white-and-comment-rex top forward-sexp -2 36 -1 looking-at "\$my\\|local\\|our\$\\>" "\$\\elsif\\|if\\|unless\\|while\\|until" "\\|for\\(each\$?\\>\$\\(" "\\(my\\|local\\|our\$\\)?" "\\$[_a-zA-Z0-9]+\\)?\\)\\>" 1] 7) ((error (byte-code "\301\211\207" [done t] 2))) looking-at "\\<\$else\\|elsif|continue\$\\>" 0 point-marker cperl-fix-line-spacing cperl-indent-region] 5 (#$ . 123729) nil])
#@93 Improve whitespace in a conditional/loop construct.
Returns some position at the last line.
(defalias 'cperl-fix-line-spacing #[(&optional end parse-data) "\204�d\212\306\210`)	\206�\307\306\211\211\211\21112\212\310 \210`\311\312!\2048�\212\313\3142\315#)\211\203j3\203_�\311\316!\203\202�\313\314!\210`1\317\306w\2101`|\210\320	\321\"c\210\310 \210\202\202�\311\322!\203\202�\212\313\314!\210\323 \210\324c\210`\3254!\203\201�\3264\"\210`)\311\327!\203\230�\313\314!\210\323 \210\320	\321\"c\210\310 \210\311\330!\203\255�\307v\210\323 \210\320	\321\"c\210\310 \210\311\331!\203\302�\332v\210\323 \210\320	\321\"c\210\310 \210\311\333!\203\330�\334\335!\210\323 \210\320	\321\"c\210\310 \210\311\336!\203\371\337\224\340\341!\210\342u\210`1g\343=\203\372�\334\307!\210`\202\n\f\203\317\306x\210\202\310 \210\306
\205\2121b\210\313\324
\315#)
\203$
W\203\371\311\344!\203\371n\204\272\311\345!\203h\323 \210\f\203@5\202B6\203_\323 \210\324c\210`\3254!\203\272\3264\"\210`\202\272\320	\321\"c\210\202\272\311\346!\203\217\f\203w5\202y6\204\217`\317\306w\210
`|\210\320	\321\"c\210\202\272\311\347!\203\272\f\203\2365\202\2406\203\272\323 \210\324c\210`\3254!\203\272\3264\"\210`\311\350!\203\371\317\306w\210`\334\307!\210`1
b\210\313\3241\315#7\204\340\f\203\371
Tb\210\323 \210\324c\210`\3254!\203\371\3264\"\310 \210`1\212\306\210`)8\203j\203j\311\351!\204j\306\352\353\217\203j\342u\210\354\306x\210n\2039\3254!\210\313\314!\210\323 \210\324c\210\202Z\323 \210h\355=\204Un\204Uh\356=\203R\357e!\204U\360c\210\324c\210`\3254!\203g\3264\"\310 \210)\n.\207" [end cperl-indent-region-fix-constructs ret have-brace ml pp nil 1 beginning-of-line looking-at "[ 	]*\$els\\(e\\|if\$\\|continue\\|if\\|while\\|for\$each\$?\\|until\\)" search-forward "}" t "[ 	]*}[ 	]*\n[ 	\n]*\$els\\(e\\|if\$\\|continue\\)\\>" " 	\n" make-string 32 "[ 	]*}[ 	]*\$els\\(e\\|if\$\\|continue\\)\\>" delete-horizontal-space "\n" cperl-indent-line cperl-fix-line-spacing "[ 	]*}\$	*\\|[ 	][ 	]+\$\\<\$els\\(e\\|if\$\\|continue\\)\\>" "[ 	]*}?[ 	]*\\<\$\\els\\(e\\|if\$\\|continue\\|unless\\|if\\|while\\|for\$each\$?\\|until\\)\\>\$	*\\|[ 	][ 	]+\$[^ 	\n#]" "[ 	]*\\<for\$each\$?[ 	]+\$my\\|local\\|our\$\$	*\\|[ 	][ 	]+\$[^ 	\n]" 2 "[ 	]*\\<for\$each\$?[ 	]+\$my\\|local\\|our\$[ 	]*\\$[_a-zA-Z0-9]+\$	*\\|[ 	][ 	]+\$[^ 	\n#]" forward-sexp 3 "[ 	]*\$}[ 	]*\$?\\<\$\\els\\(e\\|if\$\\|continue\\|if\\|unless\\|while\\|for\$each\$?\$\\([ 	]+\\(my\\|local\\|our\$\\)?[ 	]*\\$[_a-zA-Z0-9]+\\)?\\|until\\)\\>\$[ 	]*(\\|[ 	\n]*{\$\\|[ 	]*{" 8 re-search-forward "[({]" -1 40 "[ 	\n]*{" "\$	*\\| [ 	]+\${" "[ 	]*\n" "[	 ]*{" "[ 	\n]*{[ 	]*[^ 	\n#]" "[ 	]*}[ 	]*\$\\<\\(els\\(if\\|e\$\\|continue\\|while\\|until\\)\\>\\|$\\|#\\)" (byte-code "\302\303!\210`X\203�h\304=\203�\305e!\203�\306\207	b\210\307\207" [pp p up-list 1 125 cperl-after-block-and-statement-beg t nil] 2) ((error)) " 	" 59 125 cperl-after-block-p ";" p ee cperl-merge-trailing-else parse-data cperl-extra-newline-before-brace-multiline cperl-extra-newline-before-brace cperl-break-one-line-blocks-when-indent cperl-fix-hanging-brace-when-indent] 7 (#$ . 125071) nil])
(defalias 'cperl-delay-update-hook #[(beg end old-len) "	\206�d^\n\206�e]\211\207" [beg cperl-update-start end cperl-update-end] 2])
#@369 Simple variant of indentation of region in CPerl mode.
Should be slow.  Will not indent comment if it starts at `comment-indent'
or looks like continuation of the comment on the previous line.
Indents all the lines whose first character is between START and END
inclusive.

If `cperl-indent-region-fix-constructs', will improve spacing on
conditional/loop constructs.
(defalias 'cperl-indent-region #[(start end) "\306\211\"\210\212\307\211	
\205�\307\211\211E\310\307\211\211\211\211\211\211\211\211 !\"#$%&'()\n\203<�\311\301\312\"\210*b\210\313 \205F�i\211%$*b\210\314 \307\223n\204]�\315\316!\210`X\203m\204`'\317\320!\211 \204\220�\317\321!\211&\203\300�\322 %\206\205�+=\204\220�\307\211%\203\300�%\203 \204\322 %U\203\323`\324\"\325=\204\323`\326\",=\204$+\327 \210)\202\330)!!&\204!\203-\203\334�\331)\"b\210\313 \205\367�\323`\324\"\332>?\205\367�\323`\326\",=?\205\367�i\211%\203\327 \210\333\307x\210\334\307x\210i$\315\316!\210\202]�.	\2051\2051\212b\210\335c\210\336\337!\210\fb\210\335c\210\336\337!),\207" [end after-change-functions h-a-c cperl-update-end cperl-update-start cperl-emacs-can-parse cperl-update-syntaxification nil 0 add-hook cperl-delay-update-hook cperl-to-comment-or-eol make-marker beginning-of-line 2 looking-at "[ 	]*\n" "[ 	]*#" current-indentation get-text-property syntax-type pod syntax-table indent-for-comment cperl-indent-line cperl-fix-line-spacing (pod here-doc) " 	" "#" " " delete-char -1 empty i pp p new-comm-indent old-comm-indent comm st pm indent-info start comment-column cperl-st-cfence cperl-indent-region-fix-constructs] 12 (#$ . 128481) "r"])
#@248 Like `fill-paragraph', but handle CPerl comments.
If any of the current line is a comment, fill the comment or the
block of it that point is in, preserving the comment's initial
indentation and initial hashes.  Behaves usually outside of comment.
(defalias 'cperl-fill-paragraph #[(&optional justify iteration) "\306\211\211\211\211\211\211\211 !\212\307 \210\310\311!\203,�\312!\313\224\313\225{\202e�\314 \203e�\312!\310\315!\210`i\316i\317\"\313\224\313\225{P\320\306x\210`
{\fiZ
`Z\321 \322\n!\210\316	\323\"c\210)!\204s�\324\"!\210\202\214
\203�\307 \210`\202\230�\212\325\326y!\203\215�\310\327!\204\200�\310\327!\204\226�\330y\210`)\212\330y\210\310\327!\204\231�`)}\210\212eb\210\330y\210`dW\203\332�\320\306w\210\310\331!\203\252�`\313\224=\203\313�`\313\225=\203\317�\332\333!\210\322\313\225\313\224Z!\210\202\252�)#\334P#\334P$%#\324\"!\210,
\203
b\210	\313V\203\322	!\210c\210i\fU\204&\204\f\335 \210\336\"\312\"\210.	\312\207" [comment-column dc len spaces c start nil beginning-of-line looking-at "[ 	]*#[# 	]*" t 0 cperl-to-comment-or-eol "#+[ 	]*" make-string 32 " 	" point-marker delete-char 45 fill-paragraph zerop -1 "^[ 	]*#+[ 	]*[^ 	\n#]" 1 "#+" error "Bug in Emacs: `looking-at' in `narrow-to-region': match-data is garbage" "\\|^[ 	#]*$" indent-for-comment cperl-fill-paragraph comment-fill-prefix fill-paragraph-function has-comment justify paragraph-start fill-prefix paragraph-separate iteration] 9 (#$ . 130161)])
(defalias 'cperl-do-auto-fill #[nil "\212\304\210i)V\205Q�\212\305 \210\306 \210`)g\307>\304\211`Y?\205P�\310 \311\304!\210	b\210n\2038�\312\313!\210\314\225b\210\n\203H�g\315>\204H�\316c\210\317u\210h\320>\206P�\316c+\207" [fill-column marker s c nil beginning-of-line cperl-to-comment-or-eol (32 9) point-marker fill-paragraph re-search-forward "#+[ 	]*" 0 (32 9) " " -1 (32 9)] 4])
(defalias 'cperl-imenu-addback #[(lst &optional isback name) "\204�	\207\n\204\f�\304\305\306\203�	A\202�	\"\210	\207" [cperl-imenu-addback lst name isback "+++BACK+++" mapc #[(elt) "<\205�A<\205�	\nBAB\241\210\303A\304	#\207" [elt name lst cperl-imenu-addback t] 4]] 3])
(defalias 'cperl-imenu--create-perl-index #[(&optional regexp) "\306\307!\210\310\211\211\211\311\312!\310\211\211\211\211\211\211\313\310\211\211\211\313\3106789:;<=>?@ABeb\210\314dd\"\210\315C\206I�D\310\316#\203\307\317\224\203a�\320 E\321\216\322\323!*\203A�\324\224\204k�\325\224\203\202\326\327\224\330\"\204\202\326\327\224\331\"\204\202\326\327\224\332\"\204\202\324\224\310<`9:\203\247�9:@Y\203\247�:A:;A;\202\214�;@\206\256�\333:@\206\266�\313
\203\370�\317\224\203\333�\317\224\317\225{\334\313\nG\310\n$\210\n\211\335P\336\nP\202\337�\337\333\212\340`d\341#\210`)\211:B:;B;\202g\342=\206\326`\343\"\313=77\203
\203A�
\204%\325\224\325\225{\211\204%\334\313\nG\310\n$\210\344 \2118
\2032\324\2023\325\225\310\223\210
\204V\345\346\n\"\203H\316<\202V9	V\204V\nP\316<\n8B
\203h\fABA\202n\fBBB<\203y\f=B=\f?B?\202A�\347\224\203A�\350\224\350\225{\344 \2118\350\224\310\223\210\334\313\nG\310\n$\210\351\347\224f\352Z\353_\354\"\nP\2118B\355\nP\fAB\f@B@?B?\202A�\311\312!\203\327\356B\311\312!\"\202\332B\237B@\203\353\357@\237BBBBA\204\365=\203\273A\310\211\211\211\211FGHIJJ\2032J@GJAJG@\325\310O\360\nI\"\204\nGABIBI\202=JJ\203\260J@GJAJ\345\361G@\"\2036G@\313\211\224OH\360HI\"\211F\203\227FA<\203\202FG@\324\313\224\\\310OGABFAB\241\210\2026FG@\324\313\224\\\310OGABC\241\210\2026HG@\324\313\224\\\310OGABCBIBI\2026\362IBBBB.A\203\312\363A\237BBBBA\204\332@\204\332\311\312!\203\351?\203\351\364?\237BBBB\365B!.\207" [package end-range name index1 index is-pack require imenu nil default-value imenu-sort-function 0 cperl-update-syntaxification re-search-forward t 5 match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) looking-at "[ 	\n]*;" 2 8 get-text-property 1 syntax-table syntax-type in-pod "" set-text-properties "::" "package " "package;" parse-partial-sexp -1 59 attrib-group make-marker string-match "[:']" 16 17 make-string 49 3 32 "=" sort "+POD headers+..." assoc "\$::\\|'\$[_a-zA-Z0-9]+$" "+Hierarchy+..." "+Packages+..." "+Unsorted List+..." cperl-imenu-addback prev-pos is-proto marker p ends-ranges packages meth index-meth-alist i-s-f index-unsorted-alist index-pod-alist index-pack-alist index-alist regexp cperl-imenu--function-name-regexp-perl save-match-data-internal group elt pack hier-list lst] 20])
(defalias 'cperl-outline-level #[nil "\301!\210\302\224\204�\303\207\304\224\203�\303\207\305\224\203�\302\207\306\224\203$�\306\224f\307Z\207\310\207" [outline-regexp looking-at 1 0 2 8 16 48 5] 2])
#@40 Initialization under windowed version.
(defalias 'cperl-windowed-init #[nil "\302\303!\203�\206)�\304\305!\203�\306\307 \207?\205)�\310\311\312\"\210\313\314!\205)�\314\315\316\"\207" [cperl-faces-init cperl-font-lock-multiline featurep ps-print boundp font-lock-multiline t cperl-init-faces add-hook font-lock-mode-hook #[nil "\302>\205\f�	\206\f�\303 \207" [major-mode cperl-faces-init (perl-mode cperl-mode) cperl-init-faces] 2] fboundp eval-after-load "ps-print" (or cperl-faces-init (cperl-init-faces))] 3 (#$ . 135014)])
#@65 Additional expressions to highlight in Perl mode.  Minimal set.
(defvar cperl-font-lock-keywords-1 nil (#$ . 135553))
#@65 Additional expressions to highlight in Perl mode.  Default set.
(defvar cperl-font-lock-keywords nil (#$ . 135677))
#@64 Additional expressions to highlight in Perl mode.  Maximal set
(defvar cperl-font-lock-keywords-2 nil (#$ . 135799))
(defalias 'cperl-load-font-lock-keywords #[nil "\204�\302 \210	\207" [cperl-faces-init cperl-font-lock-keywords cperl-init-faces] 1])
(defalias 'cperl-load-font-lock-keywords-1 #[nil "\204�\302 \210	\207" [cperl-faces-init cperl-font-lock-keywords-1 cperl-init-faces] 1])
(defalias 'cperl-load-font-lock-keywords-2 #[nil "\204�\302 \210	\207" [cperl-faces-init cperl-font-lock-keywords-2 cperl-init-faces] 1])
(defalias 'cperl-init-faces-weak #[nil "\300\301!\204.�\301\302\303!\205�\303 \235\204�\304\301!\210\300\301!\204.�\305\301\306\307#\210\310\301!\204.�\311\301\211\"\210\300\312!\206]�\312\302\303!\205=�\303 \235\204E�\304\312!\210\300\312!\206]�\305\312\306\313#\210\310\312!\204\\�\311\312\211\"\210\312\207" [boundp font-lock-constant-face fboundp face-list make-face put variable-documentation "Face for constant and label names" default-boundp set-default font-lock-warning-face "Face for things which should stand out"] 4])
(defalias 'cperl-init-faces #[nil "\300\301\302\217\207" [errs (byte-code "\306\307!\210\310\311!\203�\312\313!\203�\314\315!\210\316\211\211\310\311!\203\"�\317\320\321\322D\323BBB\324\325\326\327\330#\331Q\332B\333\332\334E\335\332\336E\337\340\f\341\342
\343
\344\260\332@\203R�\345\202S�\346E\347\350\312\313!\203`�\351\202i�\203h�\352\202i�\353\354\355\356\312\313!\203v�\357\202\256�\203\255�\360
\361
\362\260\363@\203\213�\364\202\214�\365D\366
\367
\370\260@\203\235�\371\202\236�\372@?\205\245�\373\374BBBE\202\256�\375\376\377\201K�\257\310\201L�!\205\301�\201M�A\203\321�\201N�	\201O�C\"B\203\336�\201P�\nB\202\337�\n\211CD\201N�C	\"E+\310\201Q�!\203\373�\201R� \210\312\201S�!\204	\312\313!\203\201T�\201U�!\210\202\251\201V�\201W�\201X�\201Y�#\210\201Z�\201W�!\2045\201[�\201W�\316\"\210\201\\�\310\201G�!\205D\201G� \235\204P\201]�\201\\�!\210\201^�\201\\�!\204{\201V�\201\\�\201X�\201_�#\210\201Z�\201\\�!\204{\201[�\201\\�\211\"\210\364\310\201G�!\205\210\201G� \235\204\222\201]�\364!\210\201^�\364!\204\265\201V�\364\201X�\201`�#\210\201Z�\364!\204\265\201[�\364\211\"\210\334\310\201G�!\205\302\201G� \235\204\314\201]�\334!\210\201^�\334!\204\357\201V�\334\201X�\201a�#\210\201Z�\334!\204\357\201[�\334\211\"\210\336\310\201G�!\205\374\201G� \235\204\201]�\336!\210\201^�\336!\204)\201V�\336\201X�\201b�#\210\201Z�\336!\204)\201[�\336\211\"\210\201c�\310\201G�!\2058\201G� \235\204D\201]�\201c�!\210\201^�\201c�!\204o\201V�\201c�\201X�\201d�#\210\201Z�\201c�!\204o\201[�\201c�\211\"\210\201e�\310\201G�!\205~\201G� \235\204\212\201]�\201e�!\210\201^�\201e�!\204\265\201V�\201e�\201X�\201f�#\210\201Z�\201e�!\204\265\201[�\201e�\211\"\210\201g�\310\201G�!\205\304\201G� \235\204\320\201]�\201g�!\210\201^�\201g�!\204\373\201V�\201g�\201X�\201h�#\210\201Z�\201g�!\204\373\201[�\201g�\211\"\210\201i�\310\201G�!\205\n\201G� \235\204\201]�\201i�!\210\201^�\201i�!\204A\201V�\201i�\201X�\201j�#\210\201Z�\201i�!\204A\201[�\201i�\211\"\210\201k�\310\201G�!\205P\201G� \235\204\\\201]�\201k�!\210\201^�\201k�!\204\207\201V�\201k�\201X�\201l�#\210\201Z�\201k�!\204\207\201[�\201k�\211\"\210\201k�\310\201G�!\205\226\201G� \235\204\270\201m�\310\201G�!\205\251\201G� \235\203\270\201n�\201m�\201k�\"\210\201i�\310\201G�!\205\307\201G� \235\204\351\201o�\310\201G�!\205\332\201G� \235\203\351\201n�\201o�\201i�\"\210\336\310\201G�!\205\366\201G� \235\204\201p�\310\201G�!\205	\201G� \235\203\201n�\201p�\336\"\210\201^�\201F�!\203%F\202(\201q�\310\201G�!\2054\201G� GH\201V�\201W�\201X�\201r�#\210\201Z�\201W�!\204s\201[�\201W�\201^�\201I�!\203oI\201s�=\203o\201t�\202qH\"\210\201\\�\310\201G�!\205\202\201G� \235\204\244\201u�\310\201G�!\205\225\201G� \235\203\244\201n�\201u�\201\\�\"\210\334\310\201G�!\205\261\201G� \235\204\201n�\201v�\334\"\210H\201q�=\203\343\201w�\334\201x�\201y�!\203\333\201y�\202\336\201z�\"\210\202H\201{�=\203\201w�\334\201x�\201|�!\203�\201|�\202\201}�\"\210\202\201~�\334\201�\"\210\336\310\201G�!\205\201G� \235\204p\201n�\334\336\"\210H\201q�=\203N\201w�\336\201x�\201\200�!\203F\201\200�\202I\201\201�\"\210\202pH\201{�=\203p\201w�\336\201x�\201\202�!\203k\201\202�\202n\201\203�\"\210\364\310\201G�!\205}\201G� \235\204\212\201n�\201\204�\364\"\210\201\\�\310\201G�!\205\231\201G� \235\204\250\201n�\201\204�\201\\�\"\210*\317\211J\207" [font-lock-anchored t-font-lock-keywords-1 t-font-lock-keywords cperl-invalid-face cperl-white-and-comment-rex cperl-maybe-white-and-comment-rex require font-lock fboundp font-lock-fontify-anchored-keywords featurep font-lock-extra message "You have an obsolete package `font-lock-extra'.  Install `choose-color'." nil t "[ 	]+$" 0 quote (t) "\$^\\|[^$@%&\\]\$\\<\$" mapconcat identity ("if" "until" "while" "elsif" "else" "unless" "for" "foreach" "continue" "exit" "die" "last" "goto" "next" "redo" "return" "local" "exec" "sub" "do" "dump" "use" "our" "require" "package" "eval" "my" "BEGIN" "END" "CHECK" "INIT") "\\|" "\$\\>" 2 "\$^\\|[^$@%&\\]\$\\<\$a\\(bs\\|ccept\\|tan2\\|larm\\|nd\$\\|b\$in\\(d\\|mode\$\\|less\\)\\|c\$h\\(r\\(\\|oot\$\\|dir\\|mod\\|own\\)\\|aller\\|rypt\\|lose\$\\|dir\$\\|mp\\|o\$s\\|n\\(tinue\\|nect\$\\)\\)\\|CORE\\|d\$ie\\|bm\\(close\\|open\$\\|ump\\)\\|e\$x\\(p\\|it\\|ec\$\\|q\\|nd\$p\\(rotoent\\|went\$\\|hostent\\|servent\\|netent\\|grent\\)\\|of\\)\\|f\$ileno\\|cntl\\|lock\\|or\\(k\\|mline\$\\)\\|g\$t\\|lob\\|mtime\\|e\\(\\|t\\(p\\(pid\\|r\\(iority\\|oto\\(byn\\(ame\\|umber\$\\|ent\\)\\)\\|eername\\|w\$uid\\|ent\\|nam\$\\|grp\\)\\|host\$by\\(addr\\|name\$\\|ent\\)\\|s\$erv\\(by\\(port\\|name\$\\|ent\\)\\|ock\$name\\|opt\$\\)\\|c\\|login\\|net\$by\\(addr\\|name\$\\|ent\\)\\|gr\$ent\\|nam\\|gid\$\\)\\)\\)\\|hex\\|i\$n\\(t\\|dex\$\\|octl\\)\\|join\\|kill\\|l\$i\\(sten\\|nk\$\\|stat\\|c\$\\|first\$\\|t\\|e\$\\|ngth\$\\|o\$c\\(altime\\|k\$\\|g\\)\\)\\|m\$sg\\(rcv\\|snd\\|ctl\\|get\$\\|kdir\\)\\|n\$e\\|ot\$\\|o\$pen\\(\\|dir\$\\|r\$\\|d\$\\|ct\\)\\|p\$ipe\\|ack\$\\|quotemeta\\|r\$index\\|and\\|mdir\\|e\\(quire\\|ad\\(pipe\\|\\|lin\\(k\\|e\$\\|dir\\)\\|set\\|cv\\|verse\\|f\\|winddir\\|name\\)\\)\\|s\$printf\\|qrt\\|rand\\|tat\\|ubstr\\|e\\(t\\(p\\(r\\(iority\\|otoent\$\\|went\\|grp\\)\\|hostent\\|s\$ervent\\|ockopt\$\\|netent\\|grent\\)\\|ek\$\\|dir\$\\|lect\\|m\$ctl\\|op\\|get\$\\|nd\\)\\|h\$utdown\\|m\\(read\\|ctl\\|write\\|get\$\\)\\|y\$s\\(read\\|call\\|open\\|tem\\|write\$\\|mlink\\)\\|in\\|leep\\|ocket\$pair\\|\$\\)\\|t\$runcate\\|ell\\(\\|dir\$\\|ime\$\\|s\$\\)\\|u\$c\\(\\|first\$\\|time\\|mask\\|n\$pack\\|link\$\\)\\|v\$alues\\|ec\$\\|w\$a\\(rn\\|it\\(pid\\|\$\\|ntarray\\)\\|rite\\)\\|x\$\\|or\$\\|__\$FILE__\\|LINE__\\|PACKAGE__\$\\)\\>" font-lock-type-face "\$^\\|[^$@%&\\]\$\\<\$AUTOLOAD\\|BEGIN\\|CHECK\\|cho\\(p\\|mp\$\\|d\$e\\(fined\\|lete\$\\|o\\)\\|DESTROY\\|e\$ach\\|val\\|xists\\|ls\\(e\\|if\$\\)\\|END\\|for\$\\|each\\|mat\$\\|g\$rep\\|oto\$\\|INIT\\|if\\|keys\\|l\$ast\\|ocal\$\\|m\$ap\\|y\$\\|n\$ext\\|o\$\\|our\\|p\$ackage\\|rint\\(\\|f\$\\|ush\\|o\$p\\|s\$\\)\\|q\$\\|q\\|w\\|x\\|r\$\\|re\$turn\\|do\$\\|s\$pli\\(ce\\|t\$\\|calar\\|tudy\\|ub\\|hift\\|ort\\)\\|t\$r\\|ie\$\\|u\$se\\|n\\(shift\\|ti\\(l\\|e\$\\|def\\|less\\)\\)\\|while\\|y\\|__\$END\\|DATA\$__\\|[sm]\\)\\>" cperl-nonoverridable-face ("-[rwxoRWXOezsfdlpSbctugkTBMAC]\\>\$[ 	]+_\\>\$?" 0 font-lock-function-name-face keep) "\\<sub" "\$[^ \n	{;()]+\$" "\$" "([^()]*)\$?" "[{;]" (if (eq (char-after (cperl-1- (match-end 0))) 123) 'font-lock-function-name-face 'font-lock-variable-name-face) (progn (if (< 1 (count-lines (match-beginning 0) (match-end 0))) (put-text-property (+ 3 (match-beginning 0)) (match-end 0) 'syntax-type 'multiline)) (if (eq (char-after (cperl-1- (match-end 0))) 123) 'font-lock-function-name-face 'font-lock-variable-name-face)) ("\\<\$package\\|require\\|use\\|import\\|no\\|bootstrap\$[ 	]+\$[a-zA-z_][a-zA-z_0-9:]*\$[ 	;]" 2 font-lock-function-name-face) ("^[ 	]*format[ 	]+\$[a-zA-z_][a-zA-z_0-9:]*\$[ 	]*=[ 	]*$" 1 font-lock-function-name-face) ("\$[]}\\\\%@>*&]\\|\\$[a-zA-Z0-9_:]*\$[ 	]*{[ 	]*\$-?[a-zA-Z0-9_:]+\$[ 	]*}" (2 font-lock-string-face t) (0 '(restart 2 t))) ("\$[]}\\\\%@>*&]\\|\\$[a-zA-Z0-9_:]*\$[ 	]*{[ 	]*\$-?[a-zA-Z0-9_:]+\$[ 	]*}" (2 font-lock-string-face t) ("\\=[ 	]*{[ 	]*\$-?[a-zA-Z0-9_:]+\$[ 	]*}" nil nil (1 font-lock-string-face t))) ("\$[]}\\\\%@>*&]\\|\\$[a-zA-Z0-9_:]*\$[ 	]*{[ 	]*\$-?[a-zA-Z0-9_:]+\$[ 	]*}" 2 font-lock-string-face t) ("[[ 	{,(]\$-?[a-zA-Z0-9_:]+\$[ 	]*=>" 1 font-lock-string-face t) ("^[ 	]*\$[a-zA-Z0-9_]+[ 	]*:\$[ 	]*\$$\\|{\\|\\<\\(until\\|while\\|for\\(each\$?\\|do\\)\\>\\)" 1 font-lock-constant-face) ("\\<\$continue\\|next\\|last\\|redo\\|goto\$\\>[ 	]+\$[a-zA-Z0-9_:]+\$" 2 font-lock-constant-face) ("^[ 	]*\$my\\|local\\|our\$[ 	]*\$([ 	]*\$?\$[$@%*][a-zA-Z0-9_:]+\$\$[ 	]*,\$?" (3 font-lock-variable-name-face) (4 '(another 4 nil ("\\=[ 	]*,[ 	]*\$[$@%*][a-zA-Z0-9_:]+\$\$[ 	]*,\$?" (1 font-lock-variable-name-face) (2 '(restart 2 nil) nil t))) nil t)) "\\<\$my\\|local\\|our\$" "\$(" "\$?\$[$@%*]\\([a-zA-Z0-9_:]+\\|[^a-zA-Z0-9_]\$\\)" 5 font-lock-variable-name-face (progn (setq cperl-font-lock-multiline-start (match-beginning 0)) 'font-lock-variable-name-face) "\\=" "," "\$[$@%*]\\([a-zA-Z0-9_:]+\\|[^a-zA-Z0-9_]\$\\)" (if (match-beginning 3) (save-excursion (goto-char (match-beginning 3)) (condition-case nil (forward-sexp 1) (error (condition-case nil (forward-char 200) (error nil)))) (1- (point))) (forward-char -2)) (if (match-beginning 3) (point-max) (forward-char -2)) (progn (if (or (not cperl-font-lock-multiline-start) (> 2 (count-lines cperl-font-lock-multiline-start (point)))) nil (put-text-property (1+ cperl-font-lock-multiline-start) (point) 'syntax-type 'multiline)) (setq cperl-font-lock-multiline-start nil)) ((3 font-lock-variable-name-face)) ("^[ 	{}]*\$my\\|local\\|our\$[ 	]*\$([ 	]*\$?\$[$@%*][a-zA-Z0-9_:]+\$" 3 font-lock-variable-name-face) ("\\<for\$each\$?\$[ 	]+\\(my\\|local\\|our\$\\)?[ 	]*\$\\$[a-zA-Z_][a-zA-Z_0-9]*\$[ 	]*(" 4 font-lock-variable-name-face) ("\$?:^\\|[^smywqrx$]\$\$!\$" 1 font-lock-negation-char-face) cperl-font-lock-multiline cperl-highlight-variables-indiscriminately cperl-syntaxify-by-font-lock cperl-font-lock-keywords-1 cperl-font-lock-keywords cperl-font-lock-keywords-2 font-lock-background-mode face-list background font-lock-display-type cperl-faces-init ("\\[\$\\^\$" 1 font-lock-negation-char-face prepend) turn-on-font-lock (("\$\\([@%]\\|$#\$[a-zA-Z_:][a-zA-Z0-9_:]*\\)" 1 (if (eq (char-after (match-beginning 2)) 37) 'cperl-hash-face 'cperl-array-face) t) ("\$\\([$@]+\$[a-zA-Z_:][a-zA-Z0-9_:]*\\)[ 	]*\$[[{]\$" 1 (if (= (- (match-end 2) (match-beginning 2)) 1) (if (eq (char-after (match-beginning 3)) 123) 'cperl-hash-face 'cperl-array-face) font-lock-variable-name-face) t) ("\$@\\|\\$#\$\$\\$+\\([a-zA-Z_:][a-zA-Z0-9_:]*\\|[^ 	\n]\$\\)" (1 cperl-array-face) (2 font-lock-variable-name-face)) ("\$%\$\$\\$+\\([a-zA-Z_:][a-zA-Z0-9_:]*\\|[^ 	\n]\$\\)" (1 cperl-hash-face) (2 font-lock-variable-name-face))) append ("\$[$*]{?\\sw+\$" 1 font-lock-variable-name-face) cperl-fontify-update ps-print-buffer cperl-ps-print-init choose-color eval (font-lock-require-faces (list (list 'font-lock-comment-face ["Firebrick" "OrangeRed" "DimGray" "Gray80"] nil [nil nil t t t] [nil nil t t t] nil) (list 'font-lock-string-face ["RosyBrown" "LightSalmon" "Gray50" "LightGray"] nil nil [nil nil t t t] nil) (list 'font-lock-function-name-face (vector "Blue" "LightSkyBlue" "Gray50" "LightGray" (cdr (assq 'background-color (frame-parameters)))) (vector nil nil nil nil (cdr (assq 'foreground-color (frame-parameters)))) [nil nil t t t] nil nil) (list 'font-lock-variable-name-face ["DarkGoldenrod" "LightGoldenrod" "DimGray" "Gray90"] nil [nil nil t t t] [nil nil t t t] nil) (list 'font-lock-type-face ["DarkOliveGreen" "PaleGreen" "DimGray" "Gray80"] nil [nil nil t t t] nil [nil nil t t t]) (list 'font-lock-warning-face ["Pink" "Red" "Gray50" "LightGray"] ["gray20" "gray90" "gray80" "gray20"] [nil nil t t t] nil [nil nil t t t]) (list 'font-lock-constant-face ["CadetBlue" "Aquamarine" "Gray50" "LightGray"] nil [nil nil t t t] nil [nil nil t t t]) (list 'cperl-nonoverridable-face ["chartreuse3" ("orchid1" "orange") nil "Gray80"] [nil nil "gray90"] [nil nil nil t t] [nil nil t t] [nil nil t t t]) (list 'cperl-array-face ["blue" "yellow" nil "Gray80"] ["lightyellow2" ("navy" "os2blue" "darkgreen") "gray90"] t nil nil) (list 'cperl-hash-face ["red" "red" nil "Gray80"] ["lightyellow2" ("navy" "os2blue" "darkgreen") "gray90"] t t nil))) put cperl-guessed-background variable-documentation "Display characteristics as guessed by cperl." default-boundp set-default font-lock-constant-face make-face boundp "Face for constant and label names" "Face for variable names" "Face for data types" "Face for data types from another group" font-lock-warning-face "Face for things which should stand out" font-lock-comment-face "Face for comments" font-lock-function-name-face "Face for function names" cperl-hash-face "Face for hashes" cperl-array-face "Face for arrays" font-lock-emphasized-face copy-face font-lock-other-emphasized-face font-lock-other-type-face light "Background as guessed by CPerl mode" grayscale gray font-lock-reference-face default set-face-foreground x-color-defined-p "seagreen" "sea green" dark "os2pink" "pink" set-face-background "gray90" "chartreuse3" "chartreuse" "orchid1" "orange" italic] 20) ((error (message "cperl-init-faces (ignored): %s" errs)))] 3])
#@66 Initialization of `ps-print' components for faces used in CPerl.
(defalias 'cperl-ps-print-init #[nil "\300\301\302\"\207" [eval-after-load "ps-print" (setq ps-bold-faces (append '(cperl-array-face cperl-hash-face) ps-bold-faces) ps-italic-faces (append '(cperl-nonoverridable-face cperl-hash-face) ps-italic-faces) ps-underlined-faces (append '(cperl-array-face cperl-hash-face underline cperl-nonoverridable-face) ps-underlined-faces))] 3 (#$ . 149576)])
#@244 Pretty-print in CPerl style.
If optional argument FILE is an empty string, prints to printer, otherwise
to the file FILE.  If FILE is nil, prompts for a file name.

Style of printout regulated by the variable `cperl-ps-print-face-properties'.
(defalias 'cperl-ps-print #[(&optional file) "\204�\304\305\306 \307P\310\211\311%G\312V\204�\310\313\314!\210\315	\316!\210\317!*\207" [file ps-print-face-extension-alist ps-print-color-p cperl-ps-print-face-properties read-from-minibuffer "Print to file (if empty - to printer): " buffer-file-name ".ps" nil file-name-history 0 require ps-print t ps-extend-face-list ps-print-buffer-with-faces] 6 (#$ . 150040) nil])
(byte-code "\203�\302 \210\303	B\304\305!\207" [cperl-can-font-lock current-load-list cperl-windowed-init cperl-styles-entries (lambda (#1=#:defconst-tmp-var) (defconst cperl-styles-entries #1#)) (cperl-indent-level cperl-brace-offset cperl-continued-brace-offset cperl-label-offset cperl-extra-newline-before-brace cperl-extra-newline-before-brace-multiline cperl-merge-trailing-else cperl-continued-statement-offset)] 2)
#@64 Examples of if/else with different indent styles (with v4.23).
(defconst cperl-style-examples "##### Numbers etc are: cperl-indent-level cperl-brace-offset\n##### cperl-continued-brace-offset cperl-label-offset\n##### cperl-continued-statement-offset\n##### cperl-merge-trailing-else cperl-extra-newline-before-brace\n\n########### (Do not forget cperl-extra-newline-before-brace-multiline)\n\n### CPerl	(=GNU - extra-newline-before-brace + merge-trailing-else) 2/0/0/-2/2/t/nil\nif (foo) {\n  bar\n    baz;\n label:\n  {\n    boon;\n  }\n} else {\n  stop;\n}\n\n### PerlStyle	(=CPerl with 4 as indent)		4/0/0/-4/4/t/nil\nif (foo) {\n    bar\n	baz;\n label:\n    {\n	boon;\n    }\n} else {\n    stop;\n}\n\n### GNU							2/0/0/-2/2/nil/t\nif (foo)\n  {\n    bar\n      baz;\n  label:\n    {\n      boon;\n    }\n  }\nelse\n  {\n    stop;\n  }\n\n### C++		(=PerlStyle with braces aligned with control words) 4/0/-4/-4/4/nil/t\nif (foo)\n{\n    bar\n	baz;\n label:\n    {\n	boon;\n    }\n}\nelse\n{\n    stop;\n}\n\n### BSD		(=C++, but will not change preexisting merge-trailing-else\n###		 and extra-newline-before-brace )		4/0/-4/-4/4\nif (foo)\n{\n    bar\n	baz;\n label:\n    {\n	boon;\n    }\n}\nelse\n{\n    stop;\n}\n\n### K&R		(=C++ with indent 5 - merge-trailing-else, but will not\n###		 change preexisting extra-newline-before-brace)	5/0/-5/-5/5/nil\nif (foo)\n{\n     bar\n	  baz;\n label:\n     {\n	  boon;\n     }\n}\nelse\n{\n     stop;\n}\n\n### Whitesmith	(=PerlStyle, but will not change preexisting\n###		 extra-newline-before-brace and merge-trailing-else) 4/0/0/-4/4\nif (foo)\n    {\n	bar\n	    baz;\n    label:\n	{\n	    boon;\n	}\n    }\nelse\n    {\n	stop;\n    }\n" (#$ . 151144))
#@161 List of variables to set to get a particular indentation style.
Should be used via `cperl-set-style' or via Perl menu.

See examples in `cperl-style-examples'.
(defconst cperl-style-alist '(("CPerl" (cperl-indent-level . 2) (cperl-brace-offset . 0) (cperl-continued-brace-offset . 0) (cperl-label-offset . -2) (cperl-continued-statement-offset . 2) (cperl-extra-newline-before-brace) (cperl-extra-newline-before-brace-multiline) (cperl-merge-trailing-else . t)) ("PerlStyle" (cperl-indent-level . 4) (cperl-brace-offset . 0) (cperl-continued-brace-offset . 0) (cperl-label-offset . -4) (cperl-continued-statement-offset . 4) (cperl-extra-newline-before-brace) (cperl-extra-newline-before-brace-multiline) (cperl-merge-trailing-else . t)) ("GNU" (cperl-indent-level . 2) (cperl-brace-offset . 0) (cperl-continued-brace-offset . 0) (cperl-label-offset . -2) (cperl-continued-statement-offset . 2) (cperl-extra-newline-before-brace . t) (cperl-extra-newline-before-brace-multiline . t) (cperl-merge-trailing-else)) ("K&R" (cperl-indent-level . 5) (cperl-brace-offset . 0) (cperl-continued-brace-offset . -5) (cperl-label-offset . -5) (cperl-continued-statement-offset . 5) (cperl-merge-trailing-else)) ("BSD" (cperl-indent-level . 4) (cperl-brace-offset . 0) (cperl-continued-brace-offset . -4) (cperl-label-offset . -4) (cperl-continued-statement-offset . 4)) ("C++" (cperl-indent-level . 4) (cperl-brace-offset . 0) (cperl-continued-brace-offset . -4) (cperl-label-offset . -4) (cperl-continued-statement-offset . 4) (cperl-extra-newline-before-brace . t) (cperl-extra-newline-before-brace-multiline . t) (cperl-merge-trailing-else)) ("Whitesmith" (cperl-indent-level . 4) (cperl-brace-offset . 0) (cperl-continued-brace-offset . 0) (cperl-label-offset . -4) (cperl-continued-statement-offset . 4)) ("Current")) (#$ . 152856))
#@526 Set CPerl mode variables to use one of several different indentation styles.
The arguments are a string representing the desired style.
The list of styles is in `cperl-style-alist', available styles
are CPerl, PerlStyle, GNU, K&R, BSD, C++ and Whitesmith.

The current value of style is memorized (unless there is a memorized
data already), may be restored by `cperl-set-style-back'.

Chosing "Current" style will not change style, so this may be used for
side-effect of memorizing only.  Examples in `cperl-style-examples'.
(defalias 'cperl-set-style #[(style) "\204	�\306\307	\"\310\n\"A\311\211\211\n\n\205,�\n@\n\nA\n@\nAL\210\202�,\207" [cperl-old-style cperl-styles-entries style cperl-style-alist sym str mapcar #[(name) "\301!B\207" [name eval] 3] assoc nil setting] 4 (#$ . 154689) (let ((list (mapcar #'(lambda (elt) (list (car elt))) cperl-style-alist))) (list (completing-read "Enter style: " list nil 'insist)))])
#@49 Restore a style memorized by `cperl-set-style'.
(defalias 'cperl-set-style-back #[nil "\204�\302\303!\210\304\205�@A	@	AL\210\202\n�)\207" [cperl-old-style setting error "The style was not changed" nil] 2 (#$ . 155636) nil])
(defalias 'cperl-check-syntax #[nil "\302\303!\210\304P\305\306!)\207" [cperl-extra-perl-args perl-dbg-flags require mode-compile " -wc" eval (mode-compile)] 2 nil nil])
(defalias 'cperl-info-buffer #[(type) "\203�\304\202	�\305\306	!\306\307!\n\203�\n\202�\310\213+\207" [type bname info oldbuf "*info-perl-var*" "*info-perl*" get-buffer "*info*" ((byte-code "\305\306!\210\203�q\210\307\310!\210\311\213\210\312	\n\203�\313\202�\314\"\210\315q\210\307!\210\2034�\310q\210\307\315!\210q\210\316\304!\210\317p\207" [oldbuf cperl-info-page type bname window-min-height require info rename-buffer "*info-perl-tmp*" ((info)) Info-find-node "perlvar" "perlfunc" "*info*" make-local-variable 2] 3))] 2])
#@35 Return the word at point or at P.
(defalias 'cperl-word-at-point #[(&optional p) "\212\203�b\210\303 \206#�\304\305!\210\306\301!\203�	\206\"�\n\301N\206\"�\307 )\207" [p find-tag-default-function major-mode cperl-word-at-point-hard require etags boundp find-tag-default] 2 (#$ . 156593)])
#@210 Show documentation for Perl command COMMAND in other window.
If perl-info buffer is shown in some frame, uses this frame.
Customized by setting variables `cperl-shrink-wrap-info-frame',
`cperl-max-help-size'.
(defalias 'cperl-info-on-command #[(command) "p\306\307!\310Q\311\211\211\211\211\211\211\211\211\211\211\211\211\211123456789:;\312\313\"\203:�\314:\312\315\"8\3168!4\317 \320
!24q\210eb\2108\204a�\321\314!\210\322y\210\321:\311\323#\203]\324\325!\203s�\326y\210\327 \210`94\330\331E3\204\225�	\203\225�\332	@\323\"3	A\202�3\203\253�\3333!4=\204\253�\33434\"\2103\203\266�\3203!11\203\303�21=\203\313�\3354!\210\202\325�\3364!\210\3373!\2109b\210\340 6\341 565SW\211\203\361�<\202\363�=\203S\342\3439\212\321\344\311\323#\203\345\224\202	d)\"\\7\f\2035\346Z<_\347\245\202/\350 \211\326=\203)\351\352 \n\245\353Z7V\203:7\f\203I\35476Z!\210\202S\355\3203!7T\"\210\356\317 9\"\210\202b\357\360\"\210\337
!.\207" [command buf-list char-height max-height not-loner iniwin "^" regexp-quote "[^a-zA-Z_0-9]" nil string-match "^-[a-zA-Z]$" "^-X[ 	\n]" "^[$@%]" cperl-info-buffer selected-window window-frame re-search-forward -1 t re-search-backward "^[ 	\n\f]" 1 beginning-of-line "*info-perl-var*" "*info-perl*" get-buffer-window window-buffer set-window-buffer pop-to-buffer special-display-popup-frame select-window window-height frame-height 2 count-lines "^[ 	][^\n]*\n+\$[^ 	\n\f]\\|\\'\$" 0 3 100 frame-char-height 18 display-pixel-height 4 enlarge-window set-frame-height set-window-start message "No entry for %s found." fr2 fr1 win buf frheight iniheight height isvar pos cmd-desc buffer cperl-max-help-size cperl-shrink-wrap-info-frame] 17 (#$ . 156894) (let* ((default (cperl-word-at-point)) (read (read-string (format "Find doc for Perl function (default %s): " default)))) (list (if (equal read "") default read)))])
#@63 Show documentation for Perl command at point in other window.
(defalias 'cperl-info-on-current-command #[nil "\300\301 !\207" [cperl-info-on-command cperl-word-at-point] 2 (#$ . 158823) nil])
(defalias 'cperl-imenu-info-imenu-search #[nil "\300\301!?\205
�\302\303!\210\304y\207" [looking-at "^-X[ 	\n]" re-search-backward "^\n\$[-a-zA-Z_]+\$[ 	\n]" 1] 2])
(defalias 'cperl-imenu-info-imenu-name #[nil "\300\224\300\225{\207" [1] 2])
#@69 Shows imenu for Perl Info Buffer.
Opens Perl Info buffer if needed.
(defalias 'cperl-imenu-on-info #[nil "p\305\211\305\214\306\213)\211\2055�\307 \210\310\311!\210\312\fA!\203(�\313\fA!b\210\202,�\fAb\210\314\315 `\"\210\310!-\207" [buffer imenu-create-index-function imenu-prev-index-position-function imenu-extract-index-name-function index-item nil ((byte-code "\303\304!q\210\305\306\307\310 \207" [imenu-create-index-function imenu-prev-index-position-function imenu-extract-index-name-function cperl-info-buffer nil imenu-default-create-index-function cperl-imenu-info-imenu-search cperl-imenu-info-imenu-name imenu-choose-buffer-index] 2)) push-mark pop-to-buffer "*info-perl*" markerp marker-position set-window-start selected-window] 4 (#$ . 159265) nil])
#@512 Lineup construction in a region.
Beginning of region should be at the start of a construction.
All first occurrences of this construction in the lines that are
partially contained in the region are lined up at the same column.

MINSHIFT is the minimal amount of space to insert before the construction.
STEP is the tabwidth to position constructions.
If STEP is nil, `cperl-lineup-step' will be used
(or `cperl-indent-level', if `cperl-lineup-step' is nil).
Will not move the position at the start to the left.
(defalias 'cperl-lineup #[(beg end &optional step minshift) "\306\211\211\211\211\212
b\210\306\210\307 b\210\310\306w\210\307 \311
\306#\210b\210i\312\313!\203N�\312\314!\203G�\315\316\317\224\317\225{!\320Q\202^�\321\322!\210\202^�\312\323!\203X�\321\324!\210\316\325g!!\206j�\206j� !\204t�\326!\327\330!\210`
W\203\233�\331\f
\332#\203\233�\317\224b\203\233�i\332\nV\203t�\n\202t�	\204\243�\321\333!\210b\210!\\\211\246\317U\204\277�\245T_\334!\210\327\330!\210`
W\205\336�\331\f
\332#\205\336�\317\224b\205\336�\202\277�.\207" [b seen tcol col search end nil point-marker " 	\f" indent-region looking-at "[a-zA-Z0-9_]" "\\<[a-zA-Z0-9_]+\\>" "\\<" regexp-quote 0 "\\>" error "Cannot line up in a middle of the word" "$" "Cannot line up end of line" char-to-string 1 beginning-of-line 2 re-search-forward t "The construction to line up occurred only once" cperl-make-indent beg step cperl-lineup-step cperl-indent-level minshift] 6 (#$ . 160047) "r"])
#@140 Run etags with appropriate options for Perl files.
If optional argument ALL is `recursive', will process Perl files
in subdirectories too.
(defalias 'cperl-etags #[(&optional add all files) "\306\307\310\203�\311	B\f\204�
C\312=\203)�\313\314\315\nE	\"\316\202@�\203;�\313\314\317\nE	\"\316\202@�\313	\f\"\320\321\n\310\211\211	&\211\322=\206T�\323\324\"+\207" [res args cmd add files buffer-file-name "etags" ("-l" "none" "-r" "/\\<sub[ \\t]+\$\\([a-zA-Z0-9:_]*::\$?\$[a-zA-Z0-9_]+\$\\)[ \\t]*\$([^()]*)[ 	]*\$?\$[ 	]*:[^#{;]*\$?\$[{#]\\|$\$/\\3/" "-r" "/\\<package[ \\t]+\$\\([a-zA-Z0-9:_]*::\$?\$[a-zA-Z0-9_]+\$\\)[ \\t]*\$[#;]\\|$\$/\\1/" "-r" "/\\<\$package\$[ \\t]*;/\\1;/") nil "-a" recursive append "-e" "sub wanted {push @ARGV, $File::Find::name if /\\.[pP][Llm]$/}\n				use File::Find;\n				find(\\&wanted, '.');\n				exec @ARGV;" "perl" "push @ARGV, <*.PL *.pl *.pm>;\n				exec @ARGV;" apply call-process 0 message "etags returned \"%s\"" all] 8 (#$ . 161566) nil])
#@43 Toggle the state of `cperl-auto-newline'.
(defalias 'cperl-toggle-auto-newline #[nil "?\301\302\203
�\303\202�\304\"\207" [cperl-auto-newline message "Newlines will %sbe auto-inserted now." "" "not "] 3 (#$ . 162587) nil])
#@64 Toggle the state of automatic keyword expansion in CPerl mode.
(defalias 'cperl-toggle-abbrev #[nil "\300\203	�\301\202\n�\302!\210\303\304\203�\305\202�\306\"\207" [abbrev-mode 0 1 message "Perl control structure will %sbe auto-inserted now." "" "not "] 3 (#$ . 162820) nil])
#@57 Toggle the state of parentheses doubling in CPerl mode.
(defalias 'cperl-toggle-electric #[nil "\304\305\211\211J\306=\203�	\202�\203�\206�\307\202�\nJ+\203'�\306\202(�\307\310\311\304\305\211\211J\306=\203<�	\202J�\203H�\206J�\307\202J�\nJ+\203R�\312\202S�\313\"\207" [hairy default symbol cperl-hairy cperl-electric-parens nil null t message "Parentheses will %sbe auto-doubled now." "" "not "] 6 (#$ . 163107) nil])
#@134 Toggle the state of Auto-Help on Perl constructs (put in the message area).
Delay of auto-help controlled by `cperl-lazy-help-time'.
(defalias 'cperl-toggle-autohelp #[nil "\301\302!\203 �\203�\303 \210\202�\304 \210\305\306\203�\307\202�\310\"\207\305\311!\207" [cperl-lazy-installed fboundp run-with-idle-timer cperl-lazy-unstall cperl-lazy-install message "Perl help messages will %sbe automatically shown now." "" "not " "Cannot automatically show Perl help messages - run-with-idle-timer missing."] 3 (#$ . 163549) nil])
#@66 Toggle whether `indent-region'/`indent-sexp' fix whitespace too.
(defalias 'cperl-toggle-construct-fix #[nil "?\205�\301\302\303\203�\304\202�\305\"\207" [cperl-indent-region-fix-constructs 1 message "indent-region/indent-sexp will %sbe automatically fix whitespace." "" "not "] 3 (#$ . 164087) nil])
#@648 Toggle (or, with numeric argument, set) debugging state of syntaxification.
Nonpositive numeric argument disables debugging messages.  The message
summarizes which regions it was decided to rescan for syntactic constructs.

The message looks like this:

Syxify req=123..138 actual=101..146 done-to: 112=>146 statepos: 73=>117

Numbers are character positions in the buffer.  REQ provides the range to
rescan requested by `font-lock'.  ACTUAL is the range actually resyntaxified;
for correct operation it should start and end outside any special syntactic
construct.  DONE-TO and STATEPOS indicate changes to internal caches maintained
by CPerl.
(defalias 'cperl-toggle-set-debug-unwind #[(arg &optional backtrace) "\204�	\n\203
�\302\202�\303=\203�\304\202�\305\304V\203*�\n\203&�\302\202+�\303\202+�\306\211\303\307\306=\203:�\310\202;�\311\"\207" [arg cperl-syntaxify-by-font-lock backtrace message 0 1 t "Debugging messages of syntax unwind %sabled." "dis" "en"] 5 (#$ . 164401) "P"])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\301\207" [current-load-list cperl-tmp-buffer default-boundp set-default " *cperl-tmp*"] 3)
(defalias 'cperl-setup-tmp-buf #[nil "\304!q\210\305	!\210\306 \210\307\310!\210\n\205�\311\303!\210\312\211\207" [cperl-tmp-buffer cperl-mode-syntax-table cperl-use-syntax-table-text-property-for-tags parse-sexp-lookup-properties get-buffer-create set-syntax-table buffer-disable-undo auto-fill-mode 0 make-local-variable t] 2])
(defalias 'cperl-xsub-scan #[nil "\306\307!\210\310\311\310\211\211\211\211eb\210\312\313\310\314#\203\246�\315\224\203H�\315\224\315\225{\311\224b\210\316\310w\210\317u\210\320\321!\203C�\317\224\317\225{\202�\310\202�	\203�\322\224\203\224�\322\224Tb\210\323 \322\224\322\225{\203r�\324\325P\n\"\203r�\nG\310O\324\326\n\"\204\207�	\326\nQ\fAB\211B\f\n\240\210\fB\202�\323 \211	\327P\240\210\fB\202�.\207" [prefix package name index1 index prev-pos require imenu nil 0 re-search-forward "^\$[ 	]*MODULE\\>[^\n]*\\<PACKAGE[ 	]*=[ 	]*\\([a-zA-Z_][a-zA-Z_0-9:]*\$\\>\\|\$[a-zA-Z_][a-zA-Z_0-9]*\$(\\|[ 	]*BOOT:\\)" t 2 " 	" 1 looking-at "[^\n]*\\<PREFIX[ 	]*=[ 	]*\$[a-zA-Z_][a-zA-Z_0-9]*\$\\>" 3 imenu-example--name-and-position string-match "^" "::" "::BOOT:" index-alist] 8])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list cperl-unreadable-ok default-boundp set-default nil] 3)
(defalias 'cperl-find-tags #[(ifile xs topdir) "\306!\307\211\211\211\211\211\211\211\211()*+,\212,\203(�,q\210\202+�\310 \210\311 \210\312\313\314\217\210	\204?�\315\316-\"\202 \315\317	\"\210.\203S�/\204S�\312\320\321\217\210/\203_�\322 *\202k�\323 +\324\325+\"A*\326\327*\"*\311 \210*\203\337�*@)*A*)\203u�)\330\234\331\332\333)@\"\203\240�)@\334\307O\202\243�)@\335\336)\337\234!\340\336)\335\234S!\341\261\210\332\342)@\"\203u�\332\343)\330\234\"\203u�)\330\234\335\224\335\225O)AB*B\211*\204z�`(\335b\210	\344\345\fG\307\f$\2100\f\3450GO\232\203	0G\307O\346\f\340\336(S!\341\261\210\335d{\311 \2101\204\315\347	\"\210
.\207" [cperl-tmp-buffer file f cperl-pod-here-fontify rel ret get-buffer nil cperl-setup-tmp-buf erase-buffer err (byte-code "\302!@\302\207" [ifile file insert-file-contents] 2) ((error (byte-code "\204�\302\303\304	\"!\203�\305\202�\306\307	\"\210\302\207" [cperl-unreadable-ok ifile y-or-n-p format "File %s unreadable.  Continue? " t error "Aborting: unreadable file %s"] 4))) message "Unreadable file %s" "Scanning file %s ..." (byte-code "\301\302\211#\207" [noninteractive cperl-find-pods-heres nil] 4) ((error (message "While scanning for syntax: %s" err))) cperl-xsub-scan cperl-imenu--create-perl-index assoc "+Unsorted List+..." mapcar #[(elt) "\301\302@\"\205)�Ab\210\303 \210@`\304\305`\"TAb\210l\204\"�\305u\210`\303 \210`{F\207" [elt string-match "^[_a-zA-Z]" beginning-of-line count-lines 1] 5] 3 127 string-match "^package " 8 1 number-to-string 2 "," "\n" "^[_a-zA-Z]+::" "^sub[ 	]+\$[_a-zA-Z]+\$[^:_a-zA-Z]" set-text-properties 0 "\f\n" "Scanning file %s finished" pos elt lst ind b ifile cperl-use-syntax-table-text-property-for-tags xs topdir noninteractive] 11])
#@177 Add to TAGS data for "pure" Perl files in the current directory and kids.
Use as
  emacs -batch -q -no-site-file -l emacs/cperl-mode.el         -f cperl-add-tags-recurse-noxs

(defalias 'cperl-add-tags-recurse-noxs #[nil "\300\301\211\302\211\301\302&\207" [cperl-write-tags nil t] 7 (#$ . 168624)])
#@300 Add to TAGS data for "pure" Perl in the current directory and kids.
Writes down fullpath, so TAGS is relocatable (but if the build directory
is relocated, the file TAGS inside it breaks). Use as
  emacs -batch -q -no-site-file -l emacs/cperl-mode.el         -f cperl-add-tags-recurse-noxs-fullpath

(defalias 'cperl-add-tags-recurse-noxs-fullpath #[nil "\300\301\211\302\211\301\302\303&\207" [cperl-write-tags nil t ""] 8 (#$ . 168932)])
#@170 Add to TAGS file data for Perl files in the current directory and kids.
Use as
  emacs -batch -q -no-site-file -l emacs/cperl-mode.el         -f cperl-add-tags-recurse

(defalias 'cperl-add-tags-recurse #[nil "\300\301\211\302\211$\207" [cperl-write-tags nil t] 5 (#$ . 169379)])
(defalias 'cperl-write-tags #[(&optional file erase recurse dir inbuffer noxs topdir) "\306\307!\210\204 �	\203�\n\202�\310 	\204 �\311 \203 �\312\313!\210\204&�\n\314\f\315=\316\211\211)*+,\212-\204Q�\317,!\203K�\320,!\210\202Q�\321,!q\210	\203w�.\322=\204g�.\203g�\323 \210\322.\324\325\326\217/\327\330/\"\210)\202\365�\331\332\"\211*\203\206�0\204\365�.\322=\203\223�db\210\202\355�.\203\236�\323 \210\202\355�\333b\210)\334\335)G\316)$\210)\335GO\232\203\300�G\316O)\336\337)\340Q\316\341#\203\352�\342\337!\210`\212\333u\210\336\337\316\343#\203\343�`\344Z\202\344�d)|\210\202\355�db\210\345*#c\210-?\205\346\335!\210\347\350!\205\350 .\207" [file dir default-directory topdir system-type tm require etags buffer-file-name buffer-modified-p error "Save buffer first!" "TAGS" emx nil file-exists-p visit-tags-table-buffer find-file-noselect ignore erase-buffer err (byte-code "\303\304	?\205	�\n\304$\207" [file recurse cperl-scan-files-regexp directory-files t] 5) ((error (byte-code "?\205�\303\304\305	\"!\203�\306\307\211\207\310\311	\"\207" [cperl-unreadable-ok file tm y-or-n-p format "Directory %s unreadable.  Continue? " t nil error "Aborting: unreadable directory %s"] 4))) mapc #[(file) "\306	\"\203	�\307\207\310	!\204\"�\306\n	\"\2053�\311	\f\307\312
&\207\f\204(�\307\207\311	\f\312\211
&\207" [cperl-noscan-files-regexp file cperl-scan-files-regexp erase recurse noxs string-match nil file-directory-p cperl-write-tags t topdir] 8] string-match "\\.xs$" 1 set-text-properties 0 search-forward "\f\n" "," t search-backward toend 2 cperl-find-tags save-buffer fboundp initialize-new-tags-table rel xs case-fold-search tags-file-name inbuffer erase files noxs] 6])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\301\207" [current-load-list cperl-tags-hier-regexp-list default-boundp set-default "^\$\\(package\$\\>\\|sub\\>[^\n]+::\\|[a-zA-Z_][a-zA-Z_0-9:]*([^\n]+::\\|[ 	]*BOOT:[^\n]+::\\)"] 3)
#@30 Global hierarchy of classes.
(defvar cperl-hierarchy '(nil nil) (#$ . 171648))
(defalias 'cperl-tags-hier-fill #[nil "\306b\210\307\211\211\211\211\211\211\211\211\211\211\211\310\307\311#\205\255�\312\224\313\224\314 \210\315\316!\203\247�\313\224\313\225{\317\224\317\225{\203R�\306\202S�\312\320 \321\322#\323 \324u\210\325
8\"\211\203\200�\f\326	\"B\fAB\241\210\202\247�\326	\"BCB\203\236�A\fA@B\240\210\202\247�\f@B\240\210\307\210\202!�.\f\207" [fileind info str file cons1 ord 1 nil re-search-forward t 0 2 beginning-of-line looking-at "\$[^\n]+\$\$[^\n]+\$\$[0-9]+\$,\$[0-9]+\$" 3 file-of-tag format "%s:%s" etags-snarf-tag -1 assoc vector chunk line pos name pack type cperl-tags-hier-regexp-list cperl-hierarchy] 12])
#@226 Show hierarchical menu of classes and methods.
Finds info about classes by a scan of loaded TAGS files.
Supposes that the TAGS files contain fully qualified function names.
One may build such TAGS files from CPerl mode menu.
(defalias 'cperl-tags-hier-init #[(&optional update) "\306\307!\210\306\310!\210\204�\311	8\204y�\312\313\211\211\211\211\211\211\211\211'()*+,'
\fE-\204;�\314\315!\210\316\317-\"\210\320\321!\210\316,	@\"\210\316,	A@\"\210\313\322	A@B\323	@BE(\324(\325\"\210	AA\326\327(AB!\240\210\320\330!\210.\n\311	8\204\203�\331\332!\210\333\334!\203\222�\334\211. )\202\224�/\203\240�\335\336\311	8\"\202\251�\306\337!\210\340\311	8!\211\203\302�<\203\302�A\203\277�A\211\202\264�@\341!\203\324�\342\343\234!\210\344\325\234!\210\345=\205\335�\346\336!\207" [update cperl-hierarchy b l4 l3 l2 require etags imenu 2 #[(elt) "AA\206\f�\211A@A\241\207" [elt] 2] nil call-interactively visit-tags-table mapc #[(tagsfile) "\301\302\"\210\303!q\210\304 \207" [tagsfile message "Updating list of classes... %s" get-file-buffer cperl-tags-hier-fill] 3] message "Updating list of classes... postprocessing..." "Packages: " "Methods: " cperl-tags-treeify 1 cperl-menu-to-keymap ("+++UPDATE+++" . -999) "Updating list of classes: done, requesting display..." error "No items found" fboundp display-popup-menus-p x-popup-menu t tmm tmm-prompt vectorp find-file 0 etags-goto-tag-location -999 cperl-tags-hier-init l1 to cons1 name pack remover tags-table-list f window-system] 11 (#$ . 172453) nil])
(defalias 'cperl-tags-treeify #[(to level) "\306\307\310\311\312\"\313#\314Q\nA@A\315\n8A\316\211\316\211\316\211\316\211\316\211 !\316\211\"#\316\211$%\316&\317'\n
\241\210\n\320\321'\"\210\315\321'\f\"\210 \203i�\321\322\nA\"\210\321\323\nA\"\210\324\325!\203�\n\326\nA\324\325!\"\241\210\321\327\324\325!\203\222�\326\"\324\325!\"\237\202\224�\"\"\210\321\330\324\325!\203\251�\326!\324\325!\"\237\202\253�!\".\207" [level regexp to packages methods l1 "^\$" mapconcat identity make-list "[_a-zA-Z0-9]+" "::" "\$\$::\$?" 2 nil #[(elt) "\306	@\"\203U�\n\307=\204�\310\225\203U�	@\311\307\225O\310\225\205%�	@\310\225\312O\313\314\"\211\204G�\315C\316CEAB\241\210A@\n8\211	AB\241\207\n\310=\203c�	B\211\207	B\211\207" [regexp elt ord head tail recurse string-match 1 2 0 nil t assoc "Packages: " "Methods: " writeto cons1 cons2 root-functions root-packages] 5] 1 mapc #[(elt) "\302	T\"\207" [elt level cperl-tags-treeify] 3] #[(elt) "A<\205�G\301=\205�\211A@@\240\210\211A@A\241\207" [elt 2] 2] default-value imenu-sort-function sort #[(elt) "	AB\241\207" [to elt] 3] #[(elt) "\302	@P	ABAB\241\207" [to elt "package "] 3] head tail cons1 cons2 ord writeto packs recurse root-packages root-functions ms many_ms same_name ps move-deeper] 7])
(defalias 'cperl-list-fold #[(list name limit) "\306\211\211\307\fG
X\203�\f\202J�\306\211\f\203B�T\f@\fA	X\2032�	\nB\202�\n\n\237BB	C\310\202�\n\n\237BB\237,\207" [num elt1 list2 list1 list limit nil 0 1 imenu-max-items name] 5])
(defalias 'cperl-menu-to-keymap #[(menu &optional name) "\303\304\305\306\307	\310\n#\")B\207" [list menu imenu-max-items nil keymap mapcar #[(elt) "A<\203�\303A@	#\304@\305\n!BB\207A@\306E\207" [elt imenu-max-items list cperl-list-fold nil cperl-menu-to-keymap t] 4] cperl-list-fold "Root"] 7])
#@66 Finds places such that insertion of a whitespace may help a lot.
(defvar cperl-bad-style-regexp (mapconcat 'identity '("[^-\n	 <>=+!.&|(*/'`\"#^][-=+<>!|&^]" "[-<>=+^&|]+[^- 	\n=+<>~]") "\\|") (#$ . 175890))
#@109 If matches at the start of match found by `my-bad-c-style-regexp',
insertion of a whitespace will not help.
(defvar cperl-not-bad-style-regexp (mapconcat 'identity '("[^-	 <>=+]\$--\\|\\+\\+\$" "[a-zA-Z0-9_][|&][a-zA-Z0-9_$]" "&[(a-zA-Z0-9_$]" "<\\$?\\sw+\$\\.\\(\\sw\\|_\$+\\)?>" "-[a-zA-Z][ 	]+[_$\"'`a-zA-Z]" "-[0-9]" "\\+\\+" "--" ".->" "->" "\\[-" "\\\\[&$@*\\\\]" "^=" "\\$." "<<[a-zA-Z_'\"`]" "||" "&&" "[CBIXSLFZ]<\$\\sw\\|\\s \\|\\s_\\|[\n]\$*>" "-[a-zA-Z_0-9]+[ 	]*=>") "\\|") (#$ . 176105))
#@151 Find places in the buffer where insertion of a whitespace may help.
Prompts user for insertion of spaces.
Currently it is tuned to C and Perl syntax.
(defalias 'cperl-find-bad-style #[nil "\303`\304eb\210\305\306\307\310\311\312\313&\210	\203�	b\202\"�b\210\314\315!*\207" [p found-bad last-nonmenu-event nil 13 map-y-or-n-p "Insert space here? " #[(arg) "\300c\207" [" "] 1] cperl-next-bad-style ("location" "locations" "insert a space into") ((18 (lambda (arg) (let ((buffer-quit-function 'exit-recursive-edit)) (message "Exit with Esc Esc") (recursive-edit) t)) "edit, exit with Esc Esc") (101 (lambda (arg) (let ((buffer-quit-function 'exit-recursive-edit)) (message "Exit with Esc Esc") (recursive-edit) t)) "edit, exit with Esc Esc")) t message "No appropriate place found"] 7 (#$ . 176620) nil])
(defalias 'cperl-next-bad-style #[nil "\306\307`\306\n\203l�\310\f\306\311#\203l�`\312\224b\210\313
!\204Y�g\314=\2032�\212\315\306x\210h\316>)\204Y�\317 \320\216`\321 \210\322`\"\3238\206U�\3248\206U�\3258+\203`�\312\225b\210\202�Sb\210\306\202�\n,?\207" [found point not-found p cperl-bad-style-regexp cperl-not-bad-style-regexp nil t re-search-forward to-end 0 looking-at 45 " 	\n" (61 62 60 44 40 91 123) match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) beginning-of-defun parse-partial-sexp 3 4 5 save-match-data-internal pps found-bad] 4])
#@52 Matches places in the buffer we can find help for.
(defvar cperl-have-help-regexp (mapconcat 'identity '("[$@%*&][0-9a-zA-Z_:]+\$[ 	]*[[{]\$?" "[$@]\\^[a-zA-Z]" "[$@][^ \n	]" "-[a-zA-Z]" "\\\\[a-zA-Z0]" "^=[a-z][a-zA-Z0-9_]*" "[-!&*+,-./<=>?\\\\^|~]+" "[a-zA-Z_0-9:]+" "x=" "#!") "\\|") (#$ . 178053))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305B\302\305!\204�\303\305\306\"\210\306\207" [current-load-list cperl-message-on-help-error default-boundp set-default t cperl-help-from-timer nil] 3)
(defalias 'cperl-word-at-point-hard #[nil "m\204�l\204�\301u\210\302\303\212\304 \210`)\305#\210\306\307!\203e�\310\311x\210h\312=\2035�`\313Zf\314=\2035�\315u\210\202S�h\316\317\311\">\203D�\320u\210\202S�h\321=\203S�i\301=\203S�\320u\210h\322=\203\345�\306\323!\203\345�\320u\210\202\345�\306\324!\203w�h\325=\203w�\320u\210\202\345�\306\326!\203\211�h\314=\203\211�\320u\210\202\345�\306\327!\203\320�\330\311x\210h\314=\203\250�`\313Zf\314=\204\250�\320u\210\202\345�g\331=\203\345�\332\333\334h!\"\203\345�\212\335\320!\210h\322=\205\305�\306\323!)\203\345�\336\337!\210\202\345�g\314=\203\345�h\322=\203\345�\306\323!\203\345�\320u\210\306!\205\360�\340\224\340\225{\207" [cperl-have-help-regexp 1 re-search-backward "[-a-zA-Z0-9_:!&*+,-./<=>?\\\\^|~$%@]" beginning-of-line to-beg looking-at "[a-zA-Z0-9_:]" "a-zA-Z0-9_:" nil 94 2 36 -2 append "*$@%&\\" -1 61 60 "\\$?[a-zA-Z0-9_:]+>" "=" 120 "\\^" "[-!&*+,-./<=>?\\\\^|~]" "-!&*+,-./<=>?\\\\^|~" 62 string-match "[a-zA-Z0-9_]" char-to-string forward-sexp search-backward "<" 0] 4])
#@191 Get one-line docs on the symbol at the point.
The data for these docs is a little bit obsolete and may be in fact longer
than a line.  Your contribution to update/shorten it is appreciated.
(defalias 'cperl-get-help #[nil "\304 \305\216\212\306 \211\2032�\n\205(�\307\310	\"?\205(�\311`\312\"\313>\206(�\311`\314\"\315>?\205@�\316	!\202@�\205@�\317\320`\321`\\d^{\",\207" [save-match-data-internal word cperl-help-from-timer cperl-message-on-help-error match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) cperl-word-at-point-hard string-match "^#!\\|\\\\\\|^=" get-text-property face (font-lock-comment-face font-lock-string-face) syntax-type (pod here-doc format) cperl-describe-perl-symbol message "Nothing found for %s..." 5] 6 (#$ . 179614) nil])
#@39 Where the documentation can be found.
(defvar cperl-doc-buffer " *perl-doc*" (#$ . 180419))
#@64 Display the documentation of symbol at point, a Perl operator.
(defalias 'cperl-describe-perl-symbol #[(val) "\306\307\211\310\311\"\203�\312\313O\314P\202\212�\310\315\"\203)�\316\313\211\225OP\202\212�\310\317\"\203;�\320\313\211\225OP\202\212�\321\230\203M�\310\322\"\203M�\323\202\212�\310\324\"\203c�\325\326\327\330\331\313H#!P\202\212�\310\332\"\203o�\333\202\212�\310\334\"\203{�\335\202\212�\336\230\203\212�\310\337\"\203\212�\340\341\342\343!\344R\345 \210eb\210\307\346d\306#\203\266�\212\347\313!\210`\307\210\350\351
`{\"*\202\277�+\205\277�\350\352\",C\207" [regexp args-file enable-recursive-minibuffers val case-fold-search lnstart t nil string-match "^[&*][a-zA-Z_]" 0 1 "NAME" "^[$@]\$[a-zA-Z_:0-9]+\$[ 	]*\\[" "@" "^[$@]\$[a-zA-Z_:0-9]+\$[ 	]*{" "%" "x" "^x=" "x=" "^\\$[-]" "$^" char-to-string + 65 -1 "^CORE::" "CORE::" "^SUPER::" "SUPER::" "<" "^<\\$?[a-zA-Z0-9_:]+>" "<NAME>" "^" "\$[^a-zA-Z0-9_:]+[ 	]+\$?" regexp-quote "\$[ 	([/]\\|$\$" cperl-switch-to-doc-buffer re-search-forward beginning-of-line message "%s" "No definition for %s" cperl-message-on-help-error] 7 (#$ . 180517)])
#@15447 # based on '@(#)@ perl-descr.el 1.9 - describe-perl-symbol' [Perl 5]
...	Range (list context); flip/flop [no flop when flip] (scalar context).
! ...	Logical negation.
... != ...	Numeric inequality.
... !~ ...	Search pattern, substitution, or translation (negated).
$!	In numeric context: errno.  In a string context: error string.
$"	The separator which joins elements of arrays interpolated in strings.
$#	The output format for printed numbers.  Default is %.15g or close.
$$	Process number of this script.  Changes in the fork()ed child process.
$%	The current page number of the currently selected output channel.

The following variables are always local to the current block:

$1	Match of the 1st set of parentheses in the last match (auto-local).
$2	Match of the 2nd set of parentheses in the last match (auto-local).
$3	Match of the 3rd set of parentheses in the last match (auto-local).
$4	Match of the 4th set of parentheses in the last match (auto-local).
$5	Match of the 5th set of parentheses in the last match (auto-local).
$6	Match of the 6th set of parentheses in the last match (auto-local).
$7	Match of the 7th set of parentheses in the last match (auto-local).
$8	Match of the 8th set of parentheses in the last match (auto-local).
$9	Match of the 9th set of parentheses in the last match (auto-local).
$&	The string matched by the last pattern match (auto-local).
$'	The string after what was matched by the last match (auto-local).
$`	The string before what was matched by the last match (auto-local).

$(	The real gid of this process.
$)	The effective gid of this process.
$*	Deprecated: Set to 1 to do multiline matching within a string.
$+	The last bracket matched by the last search pattern.
$,	The output field separator for the print operator.
$-	The number of lines left on the page.
$.	The current input line number of the last filehandle that was read.
$/	The input record separator, newline by default.
$0	Name of the file containing the current perl script (read/write).
$:     String may be broken after these characters to fill ^-lines in a format.
$;	Subscript separator for multi-dim array emulation.  Default "\034".
$<	The real uid of this process.
$=	The page length of the current output channel.  Default is 60 lines.
$>	The effective uid of this process.
$?	The status returned by the last ``, pipe close or `system'.
$@	The perl error message from the last eval or do @var{EXPR} command.
$ARGV	The name of the current file used with <> .
$[	Deprecated: The index of the first element/char in an array/string.
$\	The output record separator for the print operator.
$]	The perl version string as displayed with perl -v.
$^	The name of the current top-of-page format.
$^A     The current value of the write() accumulator for format() lines.
$^D	The value of the perl debug (-D) flags.
$^E     Information about the last system error other than that provided by $!.
$^F	The highest system file descriptor, ordinarily 2.
$^H     The current set of syntax checks enabled by `use strict'.
$^I	The value of the in-place edit extension (perl -i option).
$^L     What formats output to perform a formfeed.  Default is \f.
$^M     A buffer for emergency memory allocation when running out of memory.
$^O     The operating system name under which this copy of Perl was built.
$^P	Internal debugging flag.
$^T	The time the script was started.  Used by -A/-M/-C file tests.
$^W	True if warnings are requested (perl -w flag).
$^X	The name under which perl was invoked (argv[0] in C-speech).
$_	The default input and pattern-searching space.
$|	Auto-flush after write/print on current output channel?  Default 0.
$~	The name of the current report format.
... % ...	Modulo division.
... %= ...	Modulo division assignment.
%ENV	Contains the current environment.
%INC	List of files that have been require-d or do-ne.
%SIG	Used to set signal handlers for various signals.
... & ...	Bitwise and.
... && ...	Logical and.
... &&= ...	Logical and assignment.
... &= ...	Bitwise and assignment.
... * ...	Multiplication.
... ** ...	Exponentiation.
*NAME	Glob: all objects refered by NAME.  *NAM1 = *NAM2 aliases NAM1 to NAM2.
&NAME(arg0, ...)	Subroutine call.  Arguments go to @_.
... + ...	Addition.		+EXPR	Makes EXPR into scalar context.
++	Auto-increment (magical on strings).	++EXPR	EXPR++
... += ...	Addition assignment.
,	Comma operator.
... - ...	Subtraction.
--	Auto-decrement (NOT magical on strings).	--EXPR	EXPR--
... -= ...	Subtraction assignment.
-A	Access time in days since script started.
-B	File is a non-text (binary) file.
-C	Inode change time in days since script started.
-M	Age in days since script started.
-O	File is owned by real uid.
-R	File is readable by real uid.
-S	File is a socket .
-T	File is a text file.
-W	File is writable by real uid.
-X	File is executable by real uid.
-b	File is a block special file.
-c	File is a character special file.
-d	File is a directory.
-e	File exists .
-f	File is a plain file.
-g	File has setgid bit set.
-k	File has sticky bit set.
-l	File is a symbolic link.
-o	File is owned by effective uid.
-p	File is a named pipe (FIFO).
-r	File is readable by effective uid.
-s	File has non-zero size.
-t	Tests if filehandle (STDIN by default) is opened to a tty.
-u	File has setuid bit set.
-w	File is writable by effective uid.
-x	File is executable by effective uid.
-z	File has zero size.
.	Concatenate strings.
..	Range (list context); flip/flop (scalar context) operator.
.=	Concatenate assignment strings
... / ...	Division.	/PATTERN/ioxsmg	Pattern match
... /= ...	Division assignment.
/PATTERN/ioxsmg	Pattern match.
... < ...    Numeric less than.	<pattern>	Glob.	See <NAME>, <> as well.
<NAME>	Reads line from filehandle NAME (a bareword or dollar-bareword).
<pattern>	Glob (Unless pattern is bareword/dollar-bareword - see <NAME>).
<>	Reads line from union of files in @ARGV (= command line) and STDIN.
... << ...	Bitwise shift left.	<<	start of HERE-DOCUMENT.
... <= ...	Numeric less than or equal to.
... <=> ...	Numeric compare.
... = ...	Assignment.
... == ...	Numeric equality.
... =~ ...	Search pattern, substitution, or translation
... > ...	Numeric greater than.
... >= ...	Numeric greater than or equal to.
... >> ...	Bitwise shift right.
... >>= ...	Bitwise shift right assignment.
... ? ... : ...	Condition=if-then-else operator.   ?PAT? One-time pattern match.
?PATTERN?	One-time pattern match.
@ARGV	Command line arguments (not including the command name - see $0).
@INC	List of places to look for perl scripts during do/include/use.
@_    Parameter array for subroutines; result of split() unless in list context.
\  Creates reference to what follows, like \$var, or quotes non-\w in strings.
\0	Octal char, e.g. \033.
\E	Case modification terminator.  See \Q, \L, and \U.
\L	Lowercase until \E .  See also \l, lc.
\U	Upcase until \E .  See also \u, uc.
\Q	Quote metacharacters until \E .  See also quotemeta.
\a	Alarm character (octal 007).
\b	Backspace character (octal 010).
\c	Control character, e.g. \c[ .
\e	Escape character (octal 033).
\f	Formfeed character (octal 014).
\l	Lowercase the next character.  See also \L and \u, lcfirst.
\n	Newline character (octal 012 on most systems).
\r	Return character (octal 015 on most systems).
\t	Tab character (octal 011).
\u	Upcase the next character.  See also \U and \l, ucfirst.
\x	Hex character, e.g. \x1b.
... ^ ...	Bitwise exclusive or.
__END__	Ends program source.
__DATA__	Ends program source.
__FILE__	Current (source) filename.
__LINE__	Current line in current source.
__PACKAGE__	Current package.
ARGV	Default multi-file input filehandle.  <ARGV> is a synonym for <>.
ARGVOUT	Output filehandle with -i flag.
BEGIN { ... }	Immediately executed (during compilation) piece of code.
END { ... }	Pseudo-subroutine executed after the script finishes.
CHECK { ... }	Pseudo-subroutine executed after the script is compiled.
INIT { ... }	Pseudo-subroutine executed before the script starts running.
DATA	Input filehandle for what follows after __END__	or __DATA__.
accept(NEWSOCKET,GENERICSOCKET)
alarm(SECONDS)
atan2(X,Y)
bind(SOCKET,NAME)
binmode(FILEHANDLE)
caller[(LEVEL)]
chdir(EXPR)
chmod(LIST)
chop[(LIST|VAR)]
chown(LIST)
chroot(FILENAME)
close(FILEHANDLE)
closedir(DIRHANDLE)
... cmp ...	String compare.
connect(SOCKET,NAME)
continue of { block } continue { block }.  Is executed after `next' or at end.
cos(EXPR)
crypt(PLAINTEXT,SALT)
dbmclose(%HASH)
dbmopen(%HASH,DBNAME,MODE)
defined(EXPR)
delete($HASH{KEY})
die(LIST)
do { ... }|SUBR while|until EXPR	executes at least once
do(EXPR|SUBR([LIST]))	(with while|until executes at least once)
dump LABEL
each(%HASH)
endgrent
endhostent
endnetent
endprotoent
endpwent
endservent
eof[([FILEHANDLE])]
... eq ...	String equality.
eval(EXPR) or eval { BLOCK }
exec([TRUENAME] ARGV0, ARGVs)     or     exec(SHELL_COMMAND_LINE)
exit(EXPR)
exp(EXPR)
fcntl(FILEHANDLE,FUNCTION,SCALAR)
fileno(FILEHANDLE)
flock(FILEHANDLE,OPERATION)
for (EXPR;EXPR;EXPR) { ... }
foreach [VAR] (@ARRAY) { ... }
fork
... ge ...	String greater than or equal.
getc[(FILEHANDLE)]
getgrent
getgrgid(GID)
getgrnam(NAME)
gethostbyaddr(ADDR,ADDRTYPE)
gethostbyname(NAME)
gethostent
getlogin
getnetbyaddr(ADDR,ADDRTYPE)
getnetbyname(NAME)
getnetent
getpeername(SOCKET)
getpgrp(PID)
getppid
getpriority(WHICH,WHO)
getprotobyname(NAME)
getprotobynumber(NUMBER)
getprotoent
getpwent
getpwnam(NAME)
getpwuid(UID)
getservbyname(NAME,PROTO)
getservbyport(PORT,PROTO)
getservent
getsockname(SOCKET)
getsockopt(SOCKET,LEVEL,OPTNAME)
gmtime(EXPR)
goto LABEL
... gt ...	String greater than.
hex(EXPR)
if (EXPR) { ... } [ elsif (EXPR) { ... } ... ] [ else { ... } ] or EXPR if EXPR
index(STR,SUBSTR[,OFFSET])
int(EXPR)
ioctl(FILEHANDLE,FUNCTION,SCALAR)
join(EXPR,LIST)
keys(%HASH)
kill(LIST)
last [LABEL]
... le ...	String less than or equal.
length(EXPR)
link(OLDFILE,NEWFILE)
listen(SOCKET,QUEUESIZE)
local(LIST)
localtime(EXPR)
log(EXPR)
lstat(EXPR|FILEHANDLE|VAR)
... lt ...	String less than.
m/PATTERN/iogsmx
mkdir(FILENAME,MODE)
msgctl(ID,CMD,ARG)
msgget(KEY,FLAGS)
msgrcv(ID,VAR,SIZE,TYPE.FLAGS)
msgsnd(ID,MSG,FLAGS)
my VAR or my (VAR1,...)	Introduces a lexical variable ($VAR, @ARR, or %HASH).
our VAR or our (VAR1,...) Lexically enable a global variable ($V, @A, or %H).
... ne ...	String inequality.
next [LABEL]
oct(EXPR)
open(FILEHANDLE[,EXPR])
opendir(DIRHANDLE,EXPR)
ord(EXPR)	ASCII value of the first char of the string.
pack(TEMPLATE,LIST)
package NAME	Introduces package context.
pipe(READHANDLE,WRITEHANDLE)	Create a pair of filehandles on ends of a pipe.
pop(ARRAY)
print [FILEHANDLE] [(LIST)]
printf [FILEHANDLE] (FORMAT,LIST)
push(ARRAY,LIST)
q/STRING/	Synonym for 'STRING'
qq/STRING/	Synonym for "STRING"
qx/STRING/	Synonym for `STRING`
rand[(EXPR)]
read(FILEHANDLE,SCALAR,LENGTH[,OFFSET])
readdir(DIRHANDLE)
readlink(EXPR)
recv(SOCKET,SCALAR,LEN,FLAGS)
redo [LABEL]
rename(OLDNAME,NEWNAME)
require [FILENAME | PERL_VERSION]
reset[(EXPR)]
return(LIST)
reverse(LIST)
rewinddir(DIRHANDLE)
rindex(STR,SUBSTR[,OFFSET])
rmdir(FILENAME)
s/PATTERN/REPLACEMENT/gieoxsm
scalar(EXPR)
seek(FILEHANDLE,POSITION,WHENCE)
seekdir(DIRHANDLE,POS)
select(FILEHANDLE | RBITS,WBITS,EBITS,TIMEOUT)
semctl(ID,SEMNUM,CMD,ARG)
semget(KEY,NSEMS,SIZE,FLAGS)
semop(KEY,...)
send(SOCKET,MSG,FLAGS[,TO])
setgrent
sethostent(STAYOPEN)
setnetent(STAYOPEN)
setpgrp(PID,PGRP)
setpriority(WHICH,WHO,PRIORITY)
setprotoent(STAYOPEN)
setpwent
setservent(STAYOPEN)
setsockopt(SOCKET,LEVEL,OPTNAME,OPTVAL)
shift[(ARRAY)]
shmctl(ID,CMD,ARG)
shmget(KEY,SIZE,FLAGS)
shmread(ID,VAR,POS,SIZE)
shmwrite(ID,STRING,POS,SIZE)
shutdown(SOCKET,HOW)
sin(EXPR)
sleep[(EXPR)]
socket(SOCKET,DOMAIN,TYPE,PROTOCOL)
socketpair(SOCKET1,SOCKET2,DOMAIN,TYPE,PROTOCOL)
sort [SUBROUTINE] (LIST)
splice(ARRAY,OFFSET[,LENGTH[,LIST]])
split[(/PATTERN/[,EXPR[,LIMIT]])]
sprintf(FORMAT,LIST)
sqrt(EXPR)
srand(EXPR)
stat(EXPR|FILEHANDLE|VAR)
study[(SCALAR)]
sub [NAME [(format)]] { BODY }	sub NAME [(format)];	sub [(format)] {...}
substr(EXPR,OFFSET[,LEN])
symlink(OLDFILE,NEWFILE)
syscall(LIST)
sysread(FILEHANDLE,SCALAR,LENGTH[,OFFSET])
system([TRUENAME] ARGV0 [,ARGV])     or     system(SHELL_COMMAND_LINE)
syswrite(FILEHANDLE,SCALAR,LENGTH[,OFFSET])
tell[(FILEHANDLE)]
telldir(DIRHANDLE)
time
times
tr/SEARCHLIST/REPLACEMENTLIST/cds
truncate(FILE|EXPR,LENGTH)
umask[(EXPR)]
undef[(EXPR)]
unless (EXPR) { ... } [ else { ... } ] or EXPR unless EXPR
unlink(LIST)
unpack(TEMPLATE,EXPR)
unshift(ARRAY,LIST)
until (EXPR) { ... }					EXPR until EXPR
utime(LIST)
values(%HASH)
vec(EXPR,OFFSET,BITS)
wait
waitpid(PID,FLAGS)
wantarray	Returns true if the sub/eval is called in list context.
warn(LIST)
while  (EXPR) { ... }					EXPR while EXPR
write[(EXPR|FILEHANDLE)]
... x ...	Repeat string or array.
x= ...	Repetition assignment.
y/SEARCHLIST/REPLACEMENTLIST/
... | ...	Bitwise or.
... || ...	Logical or.
~ ...		Unary bitwise complement.
#!	OS interpreter indicator.  If contains `perl', used for options, and -x.
AUTOLOAD {...}	Shorthand for `sub AUTOLOAD {...}'.
CORE::		Prefix to access builtin function if imported sub obscures it.
SUPER::		Prefix to lookup for a method in @ISA classes.
DESTROY		Shorthand for `sub DESTROY {...}'.
... EQ ...	Obsolete synonym of `eq'.
... GE ...	Obsolete synonym of `ge'.
... GT ...	Obsolete synonym of `gt'.
... LE ...	Obsolete synonym of `le'.
... LT ...	Obsolete synonym of `lt'.
... NE ...	Obsolete synonym of `ne'.
abs [ EXPR ]	absolute value
... and ...		Low-precedence synonym for &&.
bless REFERENCE [, PACKAGE]	Makes reference into an object of a package.
chomp [LIST]	Strips $/ off LIST/$_.  Returns count.  Special if $/ eq ''!
chr		Converts a number to char with the same ordinal.
else		Part of if/unless {BLOCK} elsif {BLOCK} else {BLOCK}.
elsif		Part of if/unless {BLOCK} elsif {BLOCK} else {BLOCK}.
exists $HASH{KEY}	True if the key exists.
format [NAME] =	 Start of output format.  Ended by a single dot (.) on a line.
formline PICTURE, LIST	Backdoor into "format" processing.
glob EXPR	Synonym of <EXPR>.
lc [ EXPR ]	Returns lowercased EXPR.
lcfirst [ EXPR ]	Returns EXPR with lower-cased first letter.
grep EXPR,LIST  or grep {BLOCK} LIST	Filters LIST via EXPR/BLOCK.
map EXPR, LIST	or map {BLOCK} LIST	Applies EXPR/BLOCK to elts of LIST.
no PACKAGE [SYMBOL1, ...]  Partial reverse for `use'.  Runs `unimport' method.
not ...		Low-precedence synonym for ! - negation.
... or ...		Low-precedence synonym for ||.
pos STRING    Set/Get end-position of the last match over this string, see \G.
quotemeta [ EXPR ]	Quote regexp metacharacters.
qw/WORD1 .../		Synonym of split('', 'WORD1 ...')
readline FH	Synonym of <FH>.
readpipe CMD	Synonym of `CMD`.
ref [ EXPR ]	Type of EXPR when dereferenced.
sysopen FH, FILENAME, MODE [, PERM]	(MODE is numeric, see Fcntl.)
tie VAR, PACKAGE, LIST	Hide an object behind a simple Perl variable.
tied		Returns internal object for a tied data.
uc [ EXPR ]	Returns upcased EXPR.
ucfirst [ EXPR ]	Returns EXPR with upcased first letter.
untie VAR	Unlink an object from a simple Perl variable.
use PACKAGE [SYMBOL1, ...]  Compile-time `require' with consequent `import'.
... xor ...		Low-precedence synonym for exclusive or.
prototype \&SUB	Returns prototype of the function given a reference.
=head1		Top-level heading.
=head2		Second-level heading.
=head3		Third-level heading (is there such?).
=over [ NUMBER ]	Start list.
=item [ TITLE ]		Start new item in the list.
=back		End list.
=cut		Switch from POD to Perl.
=pod		Switch from Perl to POD.

(defvar cperl-short-docs 'please-ignore-this-line (#$ . 181679))
#@67 Go to the perl documentation buffer and insert the documentation.
(defalias 'cperl-switch-to-doc-buffer #[(&optional interactive) "\304!\n\203�\305	!\210\202�	q\210\306 \307U\205\"�\310\311\312\"c\210\313\211)\207" [cperl-doc-buffer buf interactive buffer-read-only get-buffer-create switch-to-buffer-other-window buffer-size 0 documentation-property cperl-short-docs variable-documentation t] 3 (#$ . 197196) "p"])
(defalias 'cperl-beautify-regexp-piece #[(b e embed level) "\306\211\211\307 \307 \306\211\211\211\211:;<=>\204'�?Tb\210\202Y�?b\210\310\311!\203>�\312u\210\313\314!\210\314u\210\202Y�\310\315!\203J�\316u\210\202Y�\310\317!\203V�\312u\210\202Y�\314u\210>\203c�\320 \202e�iS\211<@\206o�A\\\310\321!\204z�\322c\210Bb\210\323 \210\324\325B\326#\203\237�Bb\210\327 \210\322c\210\330<!\210B`\306\223\210?b\210\312\210`\331B!W\203\353\323 \210`=\326\332\306w\210=`|\210\330\f!\210\n\203\323\310\333!\203\323\334\225b\210\326\314\224\203\337�\335u\210\202\277\316\224\204\357�\336\224\203\371�h\337=\203\371�\335u\210\340\314!\210\202\277\341\224\203#C\203#D\203#\335u\210\340\314!\210h\342=\204\343\344!\210\324\345B\326#\210\202\277\341\224\203r`;\310\346!\2035\334\225b\210\204^\324\347B\326#\203^h\350=\203X\324\351B\326#\2045\343\352!\210\2025\326\211\2039h\342=\204h\343\344!\210\324\345B\326#\210\202\277\353\224\203p\334\224b\210i\211\f=\204\215\327 \210\322c\210\330\f!\210`;\340\314!\210:`S\306\223\210
`\306\223\210E\314U\203\276;b\210\354\322
\326#\203%\355`
\fZ#\210\202%ESE\356\224\204\325\357;:\326E$\210\202%\312;\\f\337=\204%\312;\\f\360=\203\377\312;\\b\210\340\314!\210\357`:\326E$\210\202%\312;\\f\361=\203\316;\\b\210\357`:\326E$\210\202%\357;:\326E$\210
b\210\310\362!\2035\334\225b\210\202Hg\337=\203H\340\314!\210g\363=\203H\306u\210\332\306w\210\306\310\364!\203bl\204[\365 \210\323\312!\210\202h\327 \210\322c\210\306\210\306\202\277\366\224\203\277\335u\210`;\323 \210\324\325;\326#\203\224;b\210\327 \210\322c\210\202\231`;|\210\330<!\210\314u\210\332\306w\210\306\310\364!\203\264\323\312!\210\202\272\327 \210\322c\210\306\210\306\310\367!\204\314\203\314\370c\210\332\306w\210\202\304�\310\364!\204\341\343\371``T{\"\210\n\203\246�\312\210\202\246�`\331B!Y\205\320 <U?\205\323 \210\330<!.\n\207" [pos code inline spaces c1 m1 nil make-marker looking-at "(\\?\\\\#" 2 delete-char 1 "(\\?[^a-zA-Z]" 3 "(\\?" current-indentation "[ 	]*[\n#]" "\n" beginning-of-line re-search-forward "[^ 	]" t delete-horizontal-space cperl-make-indent marker-position " 	" "\$[a-zA-Z0-9]+[^*+{?]\$\\|\\$\$[a-zA-Z0-9_]+\\([[{]\$?\\|[^\n 	)|]\\)\\|[$^]\\|\$\\\\.\\|[^][()#|*+?\n]\$\$[*+{?]\\??\$?\\|\$\\[\$\\|\$(\\(\\?\$?\\)\\|\$|\$" 0 -1 5 123 forward-sexp 6 93 error "[]-group not terminated" "\\=\$[*+?]\\|{[0-9]+\\(,[0-9]*\$?}\\)\\??" "\\^?\\]" "\\[:\\|\\]" 58 ":\\]" "[:POSIX:]-group in []-group not terminated" 7 search-forward indent-rigidly 8 cperl-beautify-regexp-piece 40 60 "[*+?]\\??" 63 "[#\n]" indent-for-comment 9 "[ 	\n]" " " "Unknown code `%s' in a regexp" m tmp c s embed b cperl-regexp-indent-step cperl-indent-level e cperl-regexp-scan cperl-use-syntax-table-text-property level] 11])
(defalias 'cperl-make-regexp-x #[nil "\212\204	�\306\307!\210\310\311!\204�\310\312!\203�\313u\210\202�\314\311!\210`\315 \316\211ih\317=\316\320\313!\210`S\316\223\210h\n\203P�\f`\321Zf=\203P�\306\322!\210\n\203X�\320\313!\210\310\323!\203c�\324\202f�\325c\210
\204\204�Tb\210\326\327\324#\203\204�\330u\210\331c\210\313u\210\202o�.\207" [cperl-use-syntax-table-text-property s sub-p c delim have-x error "I need to have a regexp marked!" looking-at "\\s|" "\$[smy]\\|qr\$\\s|" 1 re-search-backward make-marker nil 115 forward-sexp 2 "Possible s/blah// - do not know how to deal with" "\\sw*x" t "x" re-search-forward "\$\\=\\|[^\\\\]\$\$\\\\\\\\\$*[ 	\n#]" -1 "\\" e b] 7])
#@114 Do it.  (Experimental, may change semantics, recheck the result.)
We suppose that the regexp is scanned already.
(defalias 'cperl-beautify-regexp #[(&optional deep) "\203\n�\303!\202�\304\212\305 b\210`\306 \307\310!\210	`S\311\223\210\312\n	\311$+\207" [deep e b prefix-numeric-value -1 cperl-make-regexp-x make-marker forward-sexp 1 nil cperl-beautify-regexp-piece] 5 (#$ . 201185) "P"])
#@92 Goto start of an enclosing group in regexp.
We suppose that the regexp is scanned already.
(defalias 'cperl-regext-to-level-start #[nil "\302 \303?\2051�g\304=\204�\305\306	T\307#\204�\310\311!\210\212\312\303x\210\313\314!)\211\204�\315u\210\202�*\207" [done limit cperl-make-regexp-x nil 40 search-backward "(" t error "Cannot find `(' which starts a group" "\\" looking-at "\$\\\\\\\\\$*(" -1] 5 (#$ . 201588) nil])
#@157 Find an enclosing group in regexp and contract it.
(Experimental, may change semantics, recheck the result.)
We suppose that the regexp is scanned already.
(defalias 'cperl-contract-level #[nil "\303 \210`\304 \305\306\307!\210	`S\305\223\210\nb\210\310\311	\312#\205@�\307\224\2036�\204+�\313 \314\315!\210\316!\210\202�\317\320!\210\321 \210\202�+\207" [c e b cperl-regext-to-level-start make-marker nil forward-sexp 1 re-search-forward "\$#\$\\|\n" to-end current-indentation beginning-of-line 2 cperl-make-indent delete-char -1 just-one-space] 4 (#$ . 202024) nil])
#@167 Find an enclosing group in regexp and contract all the kids.
(Experimental, may change semantics, recheck the result.)
We suppose that the regexp is scanned already.
(defalias 'cperl-contract-levels #[nil "\212\304\305\306\217\210`\307 \304\211\310\311!\210\n`S\304\223\210Tb\210\312\313\n\314#\2050�\311\224\204�\315 \210\202�-\207" [c s e b nil (cperl-regext-to-level-start) ((error (byte-code "\300 b\207" [cperl-make-regexp-x] 1))) make-marker forward-sexp 1 re-search-forward "\$\\\\\\\\\$\\|(" t cperl-contract-level] 4 (#$ . 202611) nil])
#@157 Find an enclosing group in regexp and beautify it.
(Experimental, may change semantics, recheck the result.)
We suppose that the regexp is scanned already.
(defalias 'cperl-beautify-level #[(&optional deep) "\203\n�\303!\202�\304\212\305 \210`\306 \307\310!\210	`S\311\223\210\312\n	\311$+\207" [deep e b prefix-numeric-value -1 cperl-regext-to-level-start make-marker forward-sexp 1 nil cperl-beautify-regexp-piece] 5 (#$ . 203173) "P"])
#@67 Change `B if A;' into `if (A) {B}' etc if possible.
(Unfinished.)
(defalias 'cperl-invert-if-unless-modifiers #[nil "\306\211\211\211\211\211\211\211\211\307!\"#$hz\310U\203#�\311\312!\210`\313 \210`\"\311\314!\210\315 \210`
b\210\316!\204V�\nb\210\316!\204T�`\"V\203T�\311\312!\210\202@�`\316!\204`�\317\320!\210\321\224\321\225{\311\314!\210`\311\322!\210\311\314!\210`!\313 \210`\211\"!{#
b\210\311\323!\210\311\312!\210\324\306x\210`\315 \210`\n{$\325\306w\210`|\210\326#\327\261\210\316\330!\203\266�\331 \210
\f|\210\"!|\210\"b\210	\332$\333\261\210`!\316\334!\203\333�\335 \210\202\352�\316\330!\203\347�\331 \210\202\352�\336 \210\314y\210\316\337!\203\373�\335 \210``T|\210\340 \210!Sb\210\311\314!\210\340 \210\"b.\n\207" [w-rex if-string post-A pre-A post-if pre-if nil "\\<\$if\\|unless\\|while\\|until\\|for\\|foreach\$\\>" 119 forward-sexp -1 cperl-backward-to-start-of-expr 1 cperl-forward-to-end-of-expr looking-at error "Can't find `if', `unless', `while', `until', `for' or `foreach'" 0 -2 2 "$@%#" " 	;" "\n" ";\n}" "[ 	]*#" cperl-indent-for-comment " (" ") {" "[ 	]+$" delete-horizontal-space just-one-space "[ 	]*$" cperl-indent-line post-B pre-B B A] 11 (#$ . 203625) nil])
#@243 Change `if (A) {B}' into `B if A;' etc (or visa versa) if possible.
If the cursor is not on the leading keyword of the BLOCK flavor of
construct, will assume it is the STATEMENT flavor, so will try to find
the appropriate statement modifier.
(defalias 'cperl-invert-if-unless #[nil "hz\306U\203�\307\310!\210\311\312!\203\273`\313\211\211\211\211\211\211\211\211\211\211\314\224\314\225{3456789\307\315!\210`7\307\310!\210`8g\316=\205P�\212\313\317\320\217)\211\203\2627b\210\307\321!\210`5\307\310!\210`6g\322=\203\253\3237!\210h\324=\203\253\313\325\326\217\203\206�\327\330\"\202\2705Sb\210\3236!\210h\331=\203\231�\310u\210`6b\210\332\333\334#\203\326�\314\224\211\314\225{4\3356\f\"\336
8\204\317�\337
8\204\317�\340
8\204\317�\327\3414#\210\314\225b\210\202\237�6Tb\210\342\313w\210`{3b\210\311\343!\204\367�\344\313w\210`5S{3\345\232\203\34637Sb\210\3238!\210\311\347!\2047Sb\210`8Tb\210\342\313w\210`\f{465|\21087|\2109b\2103\350\261\210	\203E	\350\261\210\351 \210\321v\210`8\3504\352\261\210\353 \210`5\311\354!\203d\355 \2105b\210\310u\210\353 \2108b\210\351 \2109b\210\356 8\313\2238`\3578!X\203\223\360 \210\321y\210\202\201\3578!b\210	\205\270\310y\210\355 \210\3578!b\202\270\327\361\"\202\270\307\310!\210\362 .
\207\362 \207" [if-string B-comment is-block end-B-code p state 119 forward-sexp -1 looking-at "\\<\$if\\|unless\\|while\\|until\\|for\\|foreach\$\\>" nil 0 2 40 (byte-code "\300\301!\210\300\302!\210g\303=\207" [forward-sexp 2 -1 123] 2) ((error)) 1 123 cperl-backward-to-noncomment 41 (byte-code "b\210\301\302!\210\301\303!\210\304\305!\207" [post-B forward-sexp 1 -1 looking-at "\\<els\$e\\|if\$\\>"] 2) ((error)) error "`%s' (EXPR) {BLOCK} with `else'/`elsif'" 59 re-search-forward "\\<\$for\\|foreach\\|if\\|unless\\|while\\|until\$\\>\\|;" t parse-partial-sexp 3 4 5 "`%s' inside `%s' BLOCK" " 	\n" ";?[ 	\n]*}" "; 	\n" "" "1" "[ 	\n]*)" " " just-one-space ";" delete-horizontal-space "#" indent-for-comment make-marker marker-position cperl-indent-line "`%s' (EXPR) not with an {BLOCK}" cperl-invert-if-unless-modifiers B A post-B pre-B post-A pre-A pre-if] 15 (#$ . 204869) nil])
#@24 Run `perldoc' on WORD.
(defalias 'cperl-perldoc #[(word) "\304\305!\210\306\307\310	\"\205�\307\311	\312Q\313\314\315\"\"\211\203 �\316\202!�\317\320	!+\207" [case-fold-search word is-func manual-program require man nil string-match "^[a-z]+$" "^" "\\>" documentation-property cperl-short-docs variable-documentation "perldoc -f" "perldoc" Man-getpage-in-background] 6 (#$ . 207083) (list (let* ((default-entry (cperl-word-at-point)) (input (read-string (format "perldoc entry%s: " (if (string= default-entry #1="") #1# (format " (default %s)" default-entry)))))) (if (string= input #1#) (if (string= default-entry #1#) (error "No perldoc args given") default-entry) input)))])
#@43 Run a `perldoc' on the word around point.
(defalias 'cperl-perldoc-at-point #[nil "\300\301 !\207" [cperl-perldoc cperl-word-at-point] 2 (#$ . 207771) nil])
#@27 *File name for `pod2man'.
(custom-declare-variable 'pod2man-program '"pod2man" '(#$ . -207934) :type 'file :group 'cperl)
#@71 Create a virtual manpage in Emacs from the Perl Online Documentation.
(defalias 'cperl-pod-to-manpage #[nil "\306\307!\210\310P\311P\312\n!\212q\210\313\f!\314\315\316\"\210\317\320
\321\322\323\324 	\"%\325\"-\207" [buffer-file-name pod2man-args bufname buffer process-environment pod2man-program require man " | nroff -man " "Man " generate-new-buffer copy-sequence setenv "TERM" "dumb" set-process-sentinel start-process "sh" "-c" format cperl-pod2man-build-command Man-bgproc-sentinel] 9 (#$ . 208062) nil])
#@61 Create a virtual manpage in Emacs from the POD in the file.
(defalias 'cperl-build-manpage #[nil "\302\303!\210\304\305	!)\207" [manual-program buffer-file-name require man "perldoc" Man-getpage-in-background] 2 (#$ . 208588) nil])
#@60 Builds the entire background manpage and cleaning command.
(defalias 'cperl-pod2man-build-command #[nil "\306P\307\301!\205\n�	\n\2030�\n@\2030�\n@@\n@A\310
\311\312\313\f\311#\260\nA*\202\f�*\207" [pod2man-program Man-filter-list flist command pargs pcom " %s 2>/dev/null" boundp " | " " " mapconcat #[(phrase) ";\204	�\301\302!\210\207" [phrase error "Malformed Man-filter-list"] 2]] 8 (#$ . 208827)])
#@170 Move point to next REx which has interpolated parts without //o.
Skips RExes consisting of one interpolated variable.

Note that skipped RExen are not performance hits.
(defalias 'cperl-next-interpolated-REx-1 #[nil "\300\301!\207" [cperl-next-interpolated-REx 1] 2 (#$ . 209250) ""])
#@66 Move point to next REx which has interpolated parts without //o.
(defalias 'cperl-next-interpolated-REx-0 #[nil "\300\301!\207" [cperl-next-interpolated-REx 0] 2 (#$ . 209541) ""])
#@453 Move point to next REx which has interpolated parts.
SKIP is a list of possible types to skip, BEG and LIMIT are the starting
point and the limit of search (default to point and end of buffer).

SKIP may be a number, then it behaves as list of numbers up to SKIP; this
semantic may be used as a numeric argument.

Types are 0 for / $rex /o (interpolated once), 1 for /$rex/ (if $rex is
a result of qr//, this is not a performance hit), t for the rest.
(defalias 'cperl-next-interpolated-REx #[(&optional skip beg limit) "\247\203	�\304D	\204�`\n\204�d\305\306	\307\"\310=\203'�\311	\307\305\n$\312\313\314	\n$\210\2037�b\202:�\315\316!)\207" [skip beg limit pp 0 nil get-text-property syntax-type string next-single-property-change cperl-map-pods-heres #[(s e p) "\303\304\"	>\203�\305\207\306\207" [s skip pp get-text-property REx-interpolated t nil] 3] REx-interpolated message "No more interpolated REx"] 5 (#$ . 209729) "P"])
#@101 Spell-check HERE-documents in the Perl buffer.
If a region is highlighted, restricts to the region.
(defalias 'cperl-here-doc-spell #[(&optional beg end) "\302\303	#\207" [beg end cperl-pod-spell t] 4 (#$ . 210681) ""])
#@145 Spell-check POD documentation.
If invoked with prefix argument, will do HERE-DOCs instead.
If a region is highlighted, restricts to the region.
(defalias 'cperl-pod-spell #[(&optional do-heres beg end) "\212\303\211\304 \203�\305 `^\305 `]\202�ed\306\307\n\203%�\310\202&�\311	$+\207" [end beg do-heres nil cperl-mark-active mark cperl-map-pods-heres #[(s e p) "\203�\212	b\210\303y\210`)\304\n	\"\210\305\207" [do-heres e s -1 ispell-region t] 3] here-doc-group in-pod] 5 (#$ . 210909) "P"])
#@156 Executes a function over regions of pods or here-documents.
PROP is the text-property to search for; default to `in-pod'.  Stop when
function returns nil.
(defalias 'cperl-map-pods-heres #[(func &optional prop s end) "\306\211\211\307\f\204�\310
\204�e\f\204�d\f\311\f\211\"\210\212
\211b\210\205P�\fW\205P�\312\f\"\313\f\306\f$	\203K�
\n\f#\n\202(�-\207" [cont has-prop posend pos prop s nil t in-pod cperl-update-syntaxification get-text-property next-single-property-change end func] 5 (#$ . 211421)])
#@181 Return HERE document region around the point.
Return nil if the point is not in a HERE document region.  If POD is non-nil,
will return a POD section if point is in a POD section.
(defalias 'cperl-get-here-doc-region #[(&optional pos pod) "\204�`\304\211\"\210\305\306\"\307=\204!�	\2053�\305\306\"\301=\2053�\310\306\"\311\306\"\211\n\2061�d*B\207" [pos pod e b cperl-update-syntaxification get-text-property syntax-type here-doc cperl-beginning-of-property next-single-property-change] 5 (#$ . 211958)])
#@75 Narrows editing region to the HERE-DOC at POS.
POS defaults to the point.
(defalias 'cperl-narrow-to-here-doc #[(&optional pos) "\204�`\302!\211\204�\303\304!\210	@	A}\210\305\306!)\207" [pos p cperl-get-here-doc-region error "Not inside a HERE document" message "When you are finished with narrow editing, type C-x n w"] 3 (#$ . 212480) "d"])
#@73 Select the HERE-DOC (or POD section) at POS.
POS defaults to the point.
(defalias 'cperl-select-this-pod-or-here-doc #[(&optional pos) "\302\303\"\211\203�	@b\210\304	A\305\303#\202�\306\307!)\207" [pos p cperl-get-here-doc-region t push-mark nil message "I do not think POS is in POD or a HERE-doc..."] 5 (#$ . 212836) "d"])
#@248 A callback to process user-initiated font-change requests.
Translates `bold', `italic', and `bold-italic' requests to insertion of
corresponding POD directives, and `underline' to C<> POD directive.

Such requests are usually bound to M-o LETTER.
(defalias 'cperl-facemenu-add-face-function #[(face end) "\302`\303\"\204�\304\305!\210\306=\203�\307\202�\310\311\236\206!�\304\312\"A\207" [face facemenu-end-add-face get-text-property in-pod error "Faces can only be set within POD" bold-italic ">>" ">" ((bold . "B<") (italic . "I<") (bold-italic . "B<I<") (underline . "C<")) "Face %s not configured for cperl-mode"] 3 (#$ . 213173)])
#@433 Times how long it takes to do incremental fontification in a region.
L is the line to start at, STEP is the number of lines to skip when
doing next incremental fontification, LIM is the maximal number of
incremental fontification to perform.  Messages are accumulated in
*Messages* buffer.

May be used for pinpointing which construct slows down buffer fontification:
start with default arguments, then refine the slowdown regions.
(defalias 'cperl-time-fontification #[(&optional l step lim) "\204�\306	\204\f�\307\n\204�\310\311\211 \312\313\211\314!\210\315 \210\f \211Z[\316\317#\210
\nW\203k�m\204k�	y\210	\\
T\320``\"\210\f \211Z[\\\316\321$\210\2026�-\207" [l step lim timems tt c 1 500 40 #[nil "\301 \211A@\302_\3038\302\245\\)\207" [tt current-time 1000 2] 4] 0 nil goto-line cperl-mode message "cperl-mode at %s: %s" cperl-update-syntaxification "to %s:%6s,%7s" delta tot] 6 (#$ . 213823) "nLine to start at: \nnStep to do incremental fontification: "])
#@356 Emulate `lazy-lock' without `condition-case', so `debug-on-error' works.
Start fontifying the buffer from the start (or end) using the given
WINDOW-SIZE (units is lines).  Negative WINDOW-SIZE starts at end, and
goes backwards; default is -50.  This function is not CPerl-specific; it
may be used to debug problems with delayed incremental fontification.
(defalias 'cperl-emulate-lazy-lock #[(&optional window-size) "\204�\304\305V\203�e\202�d\306\211b\210\307 \210\310\303!\210\311 \305V\203-�\ndW\2020�\neV\205F�y\210`\312	\n^	\n]\"\210	\202!�*\207" [window-size p pos font-lock-cache-position -50 0 nil normal-mode make-local-variable make-marker font-lock-fontify-region] 5 (#$ . 214838) "nSize of window for incremental fontification, negative goes backwards: "])
(defalias 'cperl-lazy-install #[nil "\300\207" [nil] 1])
(defalias 'cperl-lazy-unstall #[nil "\300\207" [nil] 1])
(byte-code "\301\302!\203G�\303B\304\303\305\306#\210\307\303!\204�\310\303\311\"\210\312B\304\312\305\313#\210\307\312!\2040�\310\312\311\"\210\314\315\316\"\210\314\317\320\"\210\314\321\322\"\210\314\323\324\"\210\315 \210\311\207" [current-load-list fboundp run-with-idle-timer cperl-help-shown put variable-documentation "Non-nil means that the help was already shown now." default-boundp set-default nil cperl-lazy-installed "Non-nil means that the lazy-help handlers are installed now." defalias cperl-lazy-install #[nil "\305\306!\210\307\310\211\211J\311=\203�	\202#�\203!�\206#�\312\202#�\nJ+\205Y�\f?\205Y�\313\314\315\"\210\316\307\317\320\211J\311=\203C�	\202Q�\203O�\206Q�\312\202Q�\nJ+\312\321#\210\312\211\207" [hairy default symbol cperl-hairy cperl-lazy-installed make-local-variable cperl-help-shown cperl-lazy-help-time nil null t add-hook post-command-hook cperl-lazy-hook run-with-idle-timer 1000000 5 cperl-get-help-defer] 5 "Switches on Auto-Help on Perl constructs (put in the message area).\nDelay of auto-help controlled by `cperl-lazy-help-time'." nil] cperl-lazy-unstall #[nil "\301\302\303\"\210\304\305!\210\306\211\207" [cperl-lazy-installed remove-hook post-command-hook cperl-lazy-hook cancel-function-timers cperl-get-help-defer nil] 3 "Switches off Auto-Help on Perl constructs (put in the message area).\nDelay of auto-help controlled by `cperl-lazy-help-time'." nil] cperl-lazy-hook #[nil "\301\211\207" [cperl-help-shown nil] 2] cperl-get-help-defer #[nil "\304>\205�\305\306\307 \210\306\211*\207" [major-mode cperl-help-from-timer cperl-message-on-help-error cperl-help-shown (perl-mode cperl-mode) nil t cperl-get-help] 2]] 4)
(defalias 'cperl-font-lock-unfontify-region-function #[(beg end) "\306 \307\211\307\310\211\310\211\f
\310\311\312#\210?\205+�\306 \205+�\313\310!.	\207" [modified buffer-undo-list inhibit-read-only inhibit-point-motion-hooks before-change-functions after-change-functions buffer-modified-p t nil remove-text-properties (face nil) set-buffer-modified-p deactivate-mark buffer-file-name buffer-file-truename beg end] 5])
#@229 Extends the region to safe positions, then calls the default function.
Newer `font-lock's can do it themselves.
We unwind only as far as needed for fontification.  Syntaxification may
do extra unwind via `cperl-unwind-to-safe'.
(defalias 'cperl-font-lock-fontify-region-function #[(beg end loudly) "\212b\210\203%�\303 \210\304`\211\305\"\306=\203%�\307\305\"\211\203�b\210\202�`	b\210	\203O�n\2047�\310\311\312\217\210\304`\211\305\"\306=\203O�\313	\305\310d$\211b\210\202*�`)\314	\n#\207" [beg end loudly beginning-of-line get-text-property syntax-type multiline cperl-beginning-of-property nil (forward-line 1) ((error)) next-single-property-change font-lock-default-fontify-region] 6 (#$ . 217869)])
(byte-code "\301B\302\301!\204�\303\301\304\"\210\304\207" [current-load-list cperl-d-l default-boundp set-default nil] 3)
(defalias 'cperl-fontify-syntaxically #[(end) "`	\n@\306\211\211\307=\203%�\310\311!\210\312\211 \210)	\204-�e\313\203:�\f\204:�	\202=�	`^\211b\210\314 \210`\203R�\315\313\"`
V\203f�
\211\203f�\316
\313\306\313%\210\317>\203�\320\321
	\n@&	\210.\306\207" [end cperl-syntax-done-to cperl-syntax-state edebug-backtrace-buffer from-start start nil backtrace require edebug edebug-backtrace t beginning-of-line cperl-unwind-to-safe cperl-find-pods-heres (backtrace message) message "Syxify req=%s..%s actual=%s..%s done-to: %s=>%s statepos: %s=>%s" istate idone iend dbg cperl-syntaxify-by-font-lock f cperl-hook-after-change cperl-syntaxify-unwind] 11])
(defalias 'cperl-fontify-update #[(end) "e\304\211d\nW\203-�\305\n\306\"\307\n\306\304$	\203'�\310\n	@	A$\210\211\202	�+\304\207" [posend prop pos end nil get-text-property cperl-postpone next-single-property-change put-text-property] 6])
(defalias 'cperl-fontify-update-bad #[(end) "`\305\306\"\307	\203�\310dT^)\306\"\206�e\fW\203>�\311\306\"	\2034�\312\n	@	A$\210\n\305\306\"\202�+\307\207" [pos prop posend p end get-text-property cperl-postpone nil cperl-beginning-of-property next-single-property-change put-text-property] 5])
(defalias 'cperl-after-change-function #[(beg end old-len) "\205	�	^\211\207" [cperl-syntax-done-to beg] 2])
(defalias 'cperl-update-syntaxification #[(from to) "\205�	\205�\n\203�\nW\205�\212\fb\210\305!)\207" [cperl-use-syntax-table-text-property cperl-syntaxify-by-font-lock cperl-syntax-done-to to from cperl-fontify-syntaxically] 2])
#@62 Version of IZ-supported CPerl package this file is based on.
(defvar cperl-version (byte-code "\301\302\303\"\210\304\224\304\225O)\207" [v "Revision: 5.23" string-match ":\\s *\$[0-9.]+\$" 1] 3) (#$ . 220323))
(provide 'cperl-mode)

${this.title}

Code Editor : cperl-mode.elc