;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:50:34 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/progmodes/cperl-mode.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.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")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (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\304\305\306\301&\210\300\322\302\323\304\305\306\301&\210\300\324\302\325\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." cperl-speed "Speed vs. validity tuneup." cperl-help-system "Help system tuneup."] 10) #@135 *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 '(#$ . -1462) :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 '(#$ . -1730) :type 'boolean :group 'cperl-autoinsert-details) #@68 *Indentation of CPerl statements with respect to containing block. (custom-declare-variable 'cperl-indent-level '2 '(#$ . -2044) :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 '(#$ . -2230) :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 '(#$ . -2490) :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 '(#$ . -2804) :type 'integer :group 'cperl-indentation-details) #@61 *Offset of CPerl label lines relative to usual indentation. (custom-declare-variable 'cperl-label-offset '-2 '(#$ . -2995) :type 'integer :group 'cperl-indentation-details) #@39 *Minimal offset of CPerl label lines. (custom-declare-variable 'cperl-min-label-indent '1 '(#$ . -3174) :type 'integer :group 'cperl-indentation-details) #@54 *Extra indent for lines not starting new statements. (custom-declare-variable 'cperl-continued-statement-offset '2 '(#$ . -3334) :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 '(#$ . -3520) :type 'integer :group 'cperl-indentation-details) #@68 *Extra indent for substatements that start with close-parenthesis. (custom-declare-variable 'cperl-close-paren-offset '-1 '(#$ . -3766) :type 'integer :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 '(#$ . -3959) :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 '(#$ . -4370) :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 '(#$ . -4599) :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 '(#$ . -4868) :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 '(#$ . -5121) :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 '"({[]})<" '(#$ . -5382) :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 '(#$ . -5634) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy) (byte-code "\301B\301\207" [current-load-list zmacs-regions] 2) #@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))) '(#$ . -5959) :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 '(#$ . -6318) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy) #@107 *Not-nil (and non-null) means keywords are electric in CPerl. Can be overwritten by `cperl-hairy' if nil. (custom-declare-variable 'cperl-electric-keywords 'nil '(#$ . -6639) :type '(choice (const null) boolean) :group 'cperl-affected-by-hairy) #@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 '(#$ . -6891) :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 '(#$ . -7298) :type 'integer :group 'cperl-indentation-details) #@45 *What to use as `vc-header-alist' in CPerl. (custom-declare-variable 'cperl-vc-header-alist ''((SCCS "$sccs = '%W%' ;") (RCS "$rcs = ' $Id$ ' ;")) '(#$ . -7495) :type '(repeat (list symbol string)) :group 'cperl) #@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))) '(#$ . -7714) :type 'boolean :group 'cperl) #@164 *Not-nil (and non-null) means not to prompt on C-h f. The opposite behaviour 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 '(#$ . -8026) :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 '(#$ . -8343) :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 '(#$ . -8662) :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 '(#$ . -8943) :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 '(#$ . -9090) :type 'face :group 'cperl-faces) #@35 *Face for here-docs highlighting. (custom-declare-variable 'cperl-here-face ''font-lock-string-face '(#$ . -9270) :type 'face :group 'cperl-faces) #@45 *Face for highlighting trailing whitespace. (custom-declare-variable 'cperl-invalid-face ''underline '(#$ . -9423) :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) '(#$ . -9593) :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 '(#$ . -9795) :type 'boolean :group 'cperl-faces) #@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 '(#$ . -9976) :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 '(#$ . -10221) :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 '(#$ . -10447) :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 '(#$ . -10657) :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" '(#$ . -10840) :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) '(#$ . -11058) :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 '(#$ . -11286) :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\\)$" '(#$ . -11530) :type 'regexp :group 'cperl) #@59 *Regexp to match files/dirs to skip when generating TAGS. (custom-declare-variable 'cperl-noscan-files-regexp '"/\\(\\.\\.?\\|SCCS\\|RCS\\|blib\\)$" '(#$ . -11711) :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 '(#$ . -11911) :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 '(#$ . -12159) :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 '(#$ . -12369) :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 '"" '(#$ . -12541) :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 '(#$ . -12734) :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 '(#$ . -12930) :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 '(#$ . -13257) :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 '(#$ . -13536) :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 '(#$ . -13818) :type 'boolean :group 'cperl-indentation-details) #@126 *Non-nil means that CPerl uses `font-lock's routines for syntaxification. Having it TRUE may be not completely debugged yet. (custom-declare-variable 'cperl-syntaxify-by-font-lock '(and window-system (boundp 'parse-sexp-lookup-properties)) '(#$ . -14073) :type '(choice (const message) boolean) :group 'cperl-speed) #@105 *Non-nil means that CPerl unwinds to a start of along construction when syntaxifying a chunk of buffer. (custom-declare-variable 'cperl-syntaxify-unwind 't '(#$ . -14396) :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) (underline nil "LightGray" strikeout)) '(#$ . 14609) :type '(repeat (cons symbol (cons (choice (const nil) string) (cons (choice (const nil) string) (repeat symbol))))) :group 'cperl-faces) (byte-code "\301B\303\301!\204\304\305\306\307#\302B\303\302!\204\304\310\311\"\312\313\314\315\316\317\320\nDD\321BBBB\322\323\324%\210\312\325\326\327\330\331\320\332\333 \334BBBBD\335BBBB\322\323\324%\210\312\336\337\340\341\342\320\343\333 \344BBBBD\345BBBB\346\323\324%\207" [current-load-list cperl-dark-background cperl-dark-foreground boundp cperl-choose-color "navy" "os2blue" "darkgreen" "orchid1" "orange" custom-declare-face cperl-nonoverridable-face (((class grayscale) (background light)) (:background "Gray90" :italic t :underline t)) (((class grayscale) (background dark)) (:foreground "Gray80" :italic t :underline t :bold t)) (((class color) (background light)) (:foreground "chartreuse3")) ((class color) (background dark)) :foreground ((t (:bold t :underline t))) "Font Lock mode face used to highlight array names." :group cperl-faces cperl-array-face (((class grayscale) (background light)) (:background "Gray90" :bold t)) (((class grayscale) (background dark)) (:foreground "Gray80" :bold t)) (((class color) (background light)) (:foreground "Blue" :background "lightyellow2" :bold t)) ((class color) (background dark)) "yellow" :background (:bold t) ((t (:bold t))) cperl-hash-face (((class grayscale) (background light)) (:background "Gray90" :bold t :italic t)) (((class grayscale) (background dark)) (:foreground "Gray80" :bold t :italic t)) (((class color) (background light)) (:foreground "Red" :background "lightyellow2" :bold t :italic t)) ((class color) (background dark)) "Red" (:bold t :italic t) ((t (:bold t :italic t))) "Font Lock mode face used to highlight hash names."] 11) #@2255 Get newest version of this package from ftp://ftp.math.ohio-state.edu/pub/users/ilya/emacs and/or ftp://ftp.math.ohio-state.edu/pub/users/ilya/perl 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 RMS Emaxen v19.34 and v20.2 up to the level of RMS Emacs v20.3 - a must for a good Perl mode.) You will not get much from XEmacs, its syntax abilities are too primitive. 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/perl-info.tar.gz older version was on http://www.metronet.com:70/9/perlinfo/perl5/manual/perl5-info.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 (#$ . 17050)) #@2114 Some faces will not be shown on some versions of Emacs unless you install choose-color.el, available from ftp://ftp.math.ohio-state.edu/pub/users/ilya/emacs/ Emacs had a _very_ restricted syntax parsing engine until RMS's Emacs 20.1. Most problems below are corrected starting from this version of Emacs, and all of them should go with (future) RMS's version 20.3. Note that even with newer Emacsen interaction of `font-lock' and syntaxification is not cleaned up. You may get slightly different colors basing on the order of fontification and syntaxification. This might be corrected by setting `cperl-syntaxify-by-font-lock' to t, but the corresponding code is still extremely buggy. 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} (legal 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 RMS's 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 'please-ignore-this-line (#$ . 19370)) #@2217 As you know from `problems' section, Perl syntax is too hard for CPerl on older Emacsen. Here is what you can do if you cannot upgrade, or if you want to switch off these capabilities on RMS Emacs 20.2 (+patches) or 20.3 or better. Please skip this docs if you run a capable Emacs already. Most of the time, if you write your own code, you may find an equivalent (and almost as readable) expression (what is discussed below is usually not relevant on newer Emacsen, since they can do it automatically). Try to help CPerl: add comments with embedded quotes to fix CPerl misunderstandings about the end of quotation: $a='500$'; # '; You won't need it too often. The reason: $ "quotes" the following character (this saves a life a lot of times in CPerl), thus due to Emacs parsing rules it does not consider tick (i.e., ' ) after a dollar as a closing one, but as a usual character. This is usually correct, but not in the above context. Even with older Emacsen the indentation code is pretty wise. The only drawback is that it relied on Emacs parsing to find matching parentheses. And Emacs *could not* match parentheses in Perl 100% correctly. So 1 if s#//#/#; would not break indentation, but 1 if ( s#//#/# ); would. Upgrade. By similar reasons s"abc"def"; would confuse CPerl a lot. If you still get wrong indentation in situation that you think the code should be able to parse, try: a) Check what Emacs thinks about balance of your parentheses. b) Supply the code to me (IZ). Pods were treated _very_ rudimentally. Here-documents were not treated at all (except highlighting and inhibiting indentation). Upgrade. To speed up coloring the following compromises exist: a) sub in $mypackage::sub may be highlighted. b) -z in [a-z] may be highlighted. c) if your regexp contains a keyword (like "s"), it may be highlighted. Imenu in 19.31 is broken. Set `imenu-use-keymap-menu' to t, and remove `car' before `imenu-choose-buffer-index' in `imenu'. `imenu-add-to-menubar' in 20.2 is broken. A lot of things on XEmacs may be broken too, judging by bug reports I receive. Note that some releases of XEmacs are better than the others as far as bugs reports I see are concerned. (defvar cperl-non-problems 'please-ignore-this-line (#$ . 21553)) #@3753 RMS asked me to list good things about CPerl. Here they go: 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-accessable "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. 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).  (defvar cperl-praise 'please-ignore-this-line (#$ . 23843)) #@1834 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 (#$ . 27663)) #@1563 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-function-name-face' Special-cased m// and s//foo/, _ 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-face' 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.) (Not finished.) (defvar cperl-tips-faces 'please-ignore-this-line (#$ . 29563)) (byte-code "\302B\303\304 \"\302\207" [current-load-list emacs-version cperl-xemacs-p string-match "XEmacs\\|Lucid"] 3) (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 cperl-xemacs-p] 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) (#$ . 31528)) (byte-code "\301!\203G\302U\203\303H\301\207" [cperl-del-back-ch vectorp 1 0] 2) (defalias 'cperl-mark-active #[nil "\300 \207" [mark] 1]) (byte-code "\203 \301\302M\210\202\301\303M\210\304\305M\210\301\207" [cperl-xemacs-p cperl-use-region-p #[nil "\203\301 \207\302\207" [zmacs-regions mark t] 1] #[nil "\203 \207\302\207" [transient-mark-mode mark-active t] 1] cperl-mark-active #[nil "\207" [mark-active] 1]] 2) (defalias 'cperl-enable-font-lock #[nil "\206 \207" [cperl-xemacs-p window-system] 1]) (put 'cperl-enable-font-lock 'byte-optimizer 'byte-compile-inline-expand) (defalias 'cperl-putback-char #[(c) "\301CL\207" [c unread-command-events] 2]) (byte-code "\301\302!\203\203\303\304M\210\202\303\305M\210\306\307!\204\307\310M\210\301\207" [cperl-xemacs-p boundp unread-command-events cperl-putback-char #[(c) "\301\302!C\211\207" [unread-command-events eval (character-to-event c)] 2] #[(c) "\300\301\302!L\207" [unread-command-event eval (character-to-event c)] 3] fboundp uncomment-region #[(beg end) "\302 \303#\207" [beg end comment-region -1] 4 nil "r"]] 2) #@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) (#$ . 32868)) (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) #@27 Hook run by `cperl-mode'. (custom-declare-variable 'cperl-mode-hook 'nil '(#$ . 33322) :type 'hook :group 'cperl) (byte-code "\301B\304\301!\204\f\305\302B\304\302!\204\305\303B\304\303!\204,\212\306\307\211\")G\310V\305\207" [current-load-list cperl-syntax-state cperl-syntax-done-to cperl-emacs-can-parse boundp nil parse-partial-sexp 1 9] 3) (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) #@44 Abbrev table in use in Cperl-mode buffers. (defvar cperl-mode-abbrev-table nil (#$ . 33899)) (add-hook 'edit-var-mode-alist '(perl-mode (regexp . "^cperl-"))) #@28 Keymap used in CPerl mode. (defvar cperl-mode-map nil (#$ . 34064)) (byte-code "\204\234\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 \203\203\353\202\204\354\355#\210\307\356\357#\210\307\360\361#\210\307 \203\235\362\202\236\363\364#\210\365\366\211\211J\367=\203\262 \202\300 \203\276\n\206\300\370\202\300\fJ+\203 \307 \203\316\371\202\317\372\364#\210\307 \203\334\373\202\335\374\375#\210\307 \203\352\376\202\353\377\201E\372!#\210\307 \203\376\201F\202\201G\201E\374!#\210\202/\307 \203\201H\202\377\201I#\210\307 \203)\201J\202,\201G\375#\210 \203f@\201KX\203fA\201LX\203f\307\201M\201N#\210\307\201O\201P#\210\307\201Q\201R#\210\202\234\201S\201T\352B$\210\201S\201U\201NB$\210\201S\201V\201RB$\210\201S\201W\201PB$\210\201XCBC\201YCBC\201DCBC\201Z\201D!\204\301\366D\366\201[\201\\\217\207" [cperl-mode-map cperl-xemacs-p hairy default symbol cperl-hairy 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 "a" cperl-toggle-autohelp "" cperl-indent-exp [(control meta |)] [-67108740] cperl-lineup "" cperl-electric-backspace " " cperl-indent-command [(control c) (control h) F] "F" cperl-info-on-command cperl-clobber-lisp-bindings nil null t [(control h) f] "f" [(control h) v] "v" cperl-get-help [(control c) (control h) f] "f" emacs-minor-version emacs-major-version global-map current-load-list cperl-old-style key-binding [(control c) (control h) v] "v" [(control c) (control h) f] cperl-info-on-current-command [(control c) (control h) v] 11 19 "\361" cperl-fill-paragraph ";" cperl-indent-for-comment "" cperl-indent-region substitute-key-definition indent-sexp fill-paragraph indent-region indent-for-comment cperl-menu cperl-lazy-installed boundp (byte-code "\303\304!\210\301B\305\301\306\307#\210\310\301!\204\311\312\301\n\307\313$\207" [current-load-list cperl-menu cperl-mode-map require easymenu put variable-documentation "Menu for CPerl mode" boundp 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" cperl-fill-paragraph t] "----" ["Line up a construction" cperl-lineup (cperl-use-region-p)] ["Invert if/unless/while/until" cperl-invert-if-unless t] ("Regexp" ["Beautify" cperl-beautify-regexp cperl-use-syntax-table-text-property] ["Beautify a group" cperl-beautify-level 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]) ["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)] ["Insert spaces if needed" cperl-find-bad-style t] ["Class Hierarchy from TAGS" cperl-tags-hier-init t] ["CPerl pretty print (exprmntl)" cperl-ps-print (fboundp 'ps-extend-face-list)] ["Imenu on info" cperl-imenu-on-info (featurep 'imenu)] ("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-pod-to-manpage t] ["Auto-help on" cperl-lazy-install (and (fboundp 'run-with-idle-timer) (not cperl-lazy-installed))] ["Auto-help off" (eval '(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 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] ["FSF" (cperl-set-style "FSF") t] ["BSD" (cperl-set-style "BSD") t] ["Whitesmith" (cperl-set-style "Whitesmith") t] ["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] ["Non-problems" (describe-variable 'cperl-non-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" 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" '(#$ . 40372) t) #@44 Syntax table in use in Cperl-mode buffers. (defvar cperl-mode-syntax-table nil (#$ . 40571)) #@55 Syntax table in use in Cperl-mode string-like chunks. (defvar cperl-string-syntax-table nil (#$ . 40670)) (byte-code "\204\207\306 \307\310\311#\210\307\312\313#\210\307\314\313#\210\307\315\313#\210\307\316\313#\210\307\317\313#\210\307\320\313#\210\307\321\313#\210\307\322\313#\210\307\323\313#\210\307\324\311#\210\307\325\326#\210\307\327\330#\210\307\331\332#\210\307\333\332#\210 \203k\307\334\335#\210\307\336\337#\210\307\340\313#\210\341!\307\324\313\n#\210\307\327\313\n#\210\304 B\342\304!\204\223\343\305 B\342\305!\204\237\343\343\207" [cperl-mode-syntax-table cperl-under-as-char cperl-string-syntax-table current-load-list cperl-faces-init cperl-msb-fixed 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 boundp nil] 4) #@7601 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' behaviour, 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 K&R and BSD indentation styles are `cperl-indent-level' 5 8 `cperl-continued-statement-offset' 5 8 `cperl-brace-offset' -5 -8 `cperl-label-offset' -5 -8 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). 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-non-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\226\322\311\211\211J\312=\203h\n\202v\f\203t \206v\313\202v J+\203\226\323 \203\204\324\202\205\325\326#\210\323 \203\222\327\202\223\330\331#\210\332@\333A\204\257BC\334\335\336\"\210CB)D\337\340\311\211\211J\312=\203\305\n\202\323\f\203\321 \206\323\313\202\323 J+\203\333\341\202\334\342!\210\343E!\210\344\345!\210\346FP%\344\347!\210%'\344\350!\210\313(\344\351!\210\352)\344\353!\210\313+\344\354!\210\355,\344\356!\210\357.\344\360!\210G0\344\361!\210\3621\344\363!\210\3643\344\365!\210\3665\344\367!\210\3137\344\370!\210\3718\344\372!\210\373:\344\374!\210\311<\344\375!\210\375HL\210\344\376!\210I\377\231\203k\201R\202}I\201S\231\203z\201T\202}\201U>\344\201V!\210J\203\322\344\201W!\210\201W\313L\210\201X\201Y!\204\250\201Y\201ZL\210\344\201Y!\210\201Y\201[L\210\344\201\\!\210\344\201L!\210K\203\315\201]\202\320\201^L\344\201_!\210\344\201`!\201aL\210 \204\353M\203 \201b\311\211\211J\312=\203\376\n\202\f\f\203\n \206\f\313\202\f J+\203 N\204\201c \210\201d\341!\210\201X\201e!\2034O\2044\201f \210\201g\201h!\203E\201iP!\210\201j\201k!\210Q\205eK\206eN\204a\201l \210\201m \207" [cperl-mode-map hairy default symbol cperl-hairy cperl-xemacs-p 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 [(control h) f] "f" cperl-info-on-current-command [(control c) (control h) f] "f" cperl-info-on-command cperl-mode "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)) abbrev-mode cperl-electric-keywords 1 0 set-syntax-table make-local-variable 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[ ]+\\([^ \n{(;]+\\)[ ]*" comment-indent-function cperl-comment-indent parse-sexp-ignore-comments indent-region-function cperl-indent-region imenu-create-index-function cperl-imenu--create-perl-index imenu-sort-function vc-header-alist font-lock-defaults "19.30" major-mode mode-name abbrevs-changed prev-a-c local-abbrev-table cperl-mode-syntax-table page-delimiter cperl-comment-column cperl-vc-header-alist emacs-version cperl-use-syntax-table-text-property cperl-syntaxify-by-font-lock font-lock-syntactic-keywords window-system cperl-faces-init cperl-msb-fixed cperl-menu cperl-pod-here-scan (cperl-font-lock-keywords-2) "19.33" ((cperl-font-lock-keywords cperl-font-lock-keywords-1 cperl-font-lock-keywords-2)) ((cperl-load-font-lock-keywords cperl-load-font-lock-keywords-1 cperl-load-font-lock-keywords-2)) cperl-syntax-state parse-sexp-lookup-properties boundp font-lock-unfontify-region-function font-lock-default-unfontify-region cperl-font-lock-unfontify-region-function cperl-syntax-done-to (t (cperl-fontify-syntaxically)) (t) cperl-old-style normal-auto-fill-function cperl-do-auto-fill cperl-font-lock cperl-init-faces font-lock-mode msb-menu-cond cperl-msb-fix featurep easymenu easy-menu-add run-hooks cperl-mode-hook cperl-init-faces-weak cperl-find-pods-heres] 5 (#$ . 41536) 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 \233 A@S\f\310 \311E D\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 "\306B\301B\307\301!\204\310\302B\307\302!\204\311\303B\307\303!\204(\312\304B\307\304!\2044\313\305B\307\305!\204@\314\315B\307\315!\204M\316 \306\207" [current-load-list cperl-st-cfence cperl-st-sfence cperl-st-punct cperl-st-word cperl-st-bra cperl-wrong-comment boundp (14) (15) (1) (2) (4 . 62) cperl-st-ket (5 . 60)] 2) (defalias 'cperl-comment-indent #[nil "`i\306\211\307\310!\203\311\202Y\212\312 \313`\314\"\f=\211\2030\315\316!\210h\317=\203.\320u\210\306` U\203A\321\306x\210iT ]\202X \204Oc\210\322G!\210\323\324 \325\"\210\n),\207" [phony was c p cperl-st-cfence comment-column nil looking-at "^#" 0 cperl-to-comment-or-eol get-text-property syntax-table re-search-forward "#\\|$" 35 -1 " " backward-char t indent-to 1 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 (#$ . 54619) 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 (#$ . 54858) "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 (#$ . 55079) "r\np"]) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list cperl-brace-recursing boundp nil] 2) #@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\360l\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\")\207" [arg up-list prefix-numeric-value cperl-after-expr-p nil "{;)"] 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-char arg only-before cperl-extra-newline-before-brace cperl-auto-newline] 5 (#$ . 55410) "P"]) #@73 Insert character, correct line's indentation, correct quoting by space. (defalias 'cperl-electric-lbrace #[(arg &optional end) "\306\211\307 \206 \n\205 \310 \205 \311 `V\205 \212\311 b\210\312 )\313\314!\203Ah\315=\203A\212\316\306x\210\317\320!)\203A\321c\210\212\322 \210\317\323!)\204S\324\306\325\"\204U\306\326!\210\327\306\211 \211!J\330=\203o \202\200\"\203}\206\200\307\202\200!J+\205\262#\331=\205\262#\332$\306\">\205\262 \203\237\333 !b\210\334#`\211\205\262\326\307\"\210b-\207" [cperl-auto-newline end cperl-electric-parens-mark other-end cperl-brace-recursing after nil t cperl-mark-active mark point-marker cperl-val cperl-electric-lbrace-space 36 "$" looking-at "\\(\\$\\$\\)*\\$\\([^\\$]\\|$\\)" 32 beginning-of-line "[ ]*#" cperl-after-expr-p "{;)" cperl-electric-brace cperl-electric-parens null 123 append marker-position 125 pos arg hairy default symbol cperl-hairy last-command-char cperl-electric-parens-string] 7 (#$ . 56944) "P"]) #@40 Insert a matching pair of parentheses. (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 \.\?}) (91 . 93) (40 . 41) (60 . 62)) cperl-hairy last-command-char cperl-electric-parens-string abbrev-mode arg] 6 (#$ . 57956) "P"]) #@134 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. (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\230b\210\322\321!\323 \324\"A\"c\210Tb\202\262\320\321!!+\207" [cperl-electric-parens-mark hairy default symbol cperl-hairy last-command-char 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 (#$ . 58849) "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\2110\212\313\314\315\217\210\316\313\317\")\205\351\212\320\3210\322#)?\205\351\212\320\323\313\322#?\206V\324\325!\206V1\205V\326`\327\"\330=?)\205\351h\331=\203q\332u\210\333c\210\334u\210\322\322 \335> \203x\336c\210\337 \2102\203\244\n\203\210\340\202\211\341c\210\342c\210\337 \210\340c\210\337 \210\343c\210\n\203\257\344c\210\202\257\n\203\254\345\202\255\346c\210\324\347!\204\270\333c\210\337 \210 \203\324\350\351!\210 \203\315\352u\210\202\330\353\352!\210\202\330\350\354!\210\f\203\341\3553!\2104\205\351\356\357!-\207" [last-command-char 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 "[#\"'`]\\|\\" t "^=" looking-at "=cut" get-text-property syntax-type pod 121 -2 " " 2 (self-insert-command newline) " $" cperl-indent-line "\n" " ()\n" "{" "\n}" " while ();" " {\n} while ();" " () {\n}" "[ ]\\|$" search-backward "$" 1 delete-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] 5 (#$ . 59785)]) #@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 (#$ . 61357)]) #@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\310\311\312\217\210h\313=\205^\314\315!.\314\316!\317u\210n\205^\320`\321\"\206^\322\310\323\"\206^\324\325e\326#\205^\314\327!\206]0\205]\320`\330\"\331=??)\205\340\212\332\333\310\326#-)-\204\270\334c\210\335\336!\210\337\340!\210.\203\264\212\317u\210\324\341\310\326#)\204\264\337\342!\210\343\344\345 !!`\346 \347\350\261\210\335\351!\210\fb\210\337\336!\210\310\210\326\202\270\337\342!\210\n\203\323`\352\353\261\210\335\336!\210\fb\210\337\342!\210\310\210\326/\205\340 \205\340\3541!.\207" [last-command-char this-command over really-delete p name (32 10 9 12) (self-insert-command newline) nil (backward-sexp 1) ((error)) 61 looking-at "head1\\>" "over\\>" -1 get-text-property in-pod cperl-after-expr-p "{;:" re-search-backward "\\(\\`\n?\\|\n\n\\)=\\sw+" t "=cut" syntax-type pod search-forward "\n\n=" "\n\n=cut" cperl-ensure-newlines 2 forward-sexp -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 (#$ . 61611)]) #@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 "[#\"'`]\\|\\" 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 (#$ . 62974)]) #@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\311\212\311.x\210\312u\210\313\314!)\204B\313\315!\204B\316\317 \320#\203\311\212\321\f \312#@\312=\205^\313\322!\205^\323\324!\210\325 \211\fX)\203\311\311\307x\210h\326\327\307\">\204r\330c\210\331c\210\312y\210\332 \210 b\210\313\333!\204\215\324u\210\331c\210\332 \210\324y\210\332 \210\306 \210\313\334!\204\276\307\210\335\336.\"\210\311\307x\210h\326\327\307\">\204\265\330c\210\331c\210\332 \210\312y\210\312y\210\307\210\337 \202`\307\210\313\340!\203\346\212\311\307x\210h)\341=\203\346\342y\210\332 \202`\212\343\312!\210\313\344!\205\372\313\345!\313\346!\320)\203@\n\205+\343\312!\210\324v\210``\212\307\210`){\347\212\307\210`)`Z!\210\350 \212\fb\210 c\210)?\205`\351 \2038\342\2029\352!\210\342y\202`\353`\354\"\203P\351\352!\210\342y\202`\313\355!\203^\324y\210\332 \202`\337 .\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 "[,; ]*\\($\\|#\\)" 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 (#$ . 63947) nil]) #@50 Insert character and correct line's indentation. (defalias 'cperl-electric-semi #[(arg) "\203\302 !\207\303\304 !!\207" [cperl-auto-newline arg cperl-electric-terminator self-insert-command prefix-numeric-value] 3 (#$ . 65545) "P"]) #@50 Insert character and correct line's indentation. (defalias 'cperl-electric-terminator #[(arg) "\306`\205 \307=?\206\nl\203\224\212\310 \210\311\306w\210g\312U\206_ \307=\203C\212\313v\210\311\306w\210`\fW\205?\fSb\210\314\315!?)\206_\316 \210\317`\f\"\3208\206^\3218\206^\3228))\204\224\323\324!!\210 \203q\325 \326 \210 \203~\327 \210\326 \210\212 \203\214\330 !Sb\210\202\217\331u\210\332\313!\210) \203\246\212 b\210\323\324!!)\202\254\323\324!!+\207" [cperl-auto-newline last-command-char cperl-auto-newline-after-colon auto end insertpos nil 58 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] 4 (#$ . 65787) "P"]) #@92 Backspace-untabify, or remove the whitespace around the point inserted by an electric key. (defalias 'cperl-electric-backspace #[(arg) "\203' \305>\203'h\306>\203'\307 \310=\203\311\307w\210`\311\307x\210`\n|)\207 \312=\203/\313\203P \313=\203Ph\314>\203P\307\311\307w\210`\311\307x\210`\n|)\207\315\f!\207" [cperl-auto-newline last-command p this-command 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] 2 (#$ . 66608) "p"]) (defalias 'cperl-inside-parens-p #[nil "\300\301\302\217\207" [nil (byte-code "\212\214`\300 \210`}\210db\210\301`\302\303#\206ef\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 (#$ . 67414) "P"]) #@81 Indent current line as Perl code. Return the amount the indentation changed by. (defalias 'cperl-indent-line #[(&optional parse-data) "\306\211\211\211\211d`Z\307!\211\310 \210` \306=\204& \311=\203.\312 \306\202x\313\306w\210 <\203: @\314\315!\203Q \316V\203x \\]\202xg\317U\203_ Z\202xg\320>\203m \\\202xg\321U\203x \\\313\306w\210\f\205\203 iZ\211\203\216\322\n!\203\236dZ`V\203\262dZb\210\202\262 `|\210 j\210dZ`V\203\262dZb\210\n.\207" [pos case-fold-search shift-amt beg i indent nil cperl-calculate-indent beginning-of-line t current-indentation " " looking-at "[A-Za-z_][A-Za-z_0-9]*:[^:]" 0 125 (41 93) 123 zerop parse-data cperl-min-label-indent cperl-label-offset cperl-indent-level cperl-close-paren-offset cperl-brace-offset] 8 (#$ . 68379)]) (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 % \n F.\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]) (defalias 'cperl-block-p #[nil "\300e!\210h\301\302\303\">\206<\212\304 )\206<hz\305>\205<\306 \210\307\310!\203+\307\311!?\206<\312\303x\210hz\313>\205<\306 \210\307\314!\207" [cperl-backward-to-noncomment append ";){}$@&%" nil cperl-after-label (119 95) backward-sexp looking-at "[a-zA-Z0-9_:]+[ \n\f]*[{#]" "\\(bless\\|return\\|q[wqrx]?\\|tr\\|[smy]\\)\\>" " \n\f" (119 95) "sub[ ]+[a-zA-Z0-9_:]+[ \n\f]*\\(([^()]*)[ \n\f]*\\)?[#{]"] 4]) (byte-code "\301B\302\301!\204\f\303\301\207" [current-load-list cperl-look-for-prop boundp ((pod in-pod) (here-doc-delim here-doc-group))] 2) #@301 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\"\310>\206\311\312!\203\313\314!\206?\205\311\315!?\2054\316 \210`\212\317\320w\210g)\306`\305\"`\320\211\211<= \204s\212\321\320!\210e`S]\306 \307\"\322\n>\"A@\206\\\307\n\323>\203r\324 \"\206keb\210\316 \210`)\fb\210\320?\325@@@A@\"A\326@8\206\216A@BAA@\211CA@D\320E@\203\310@\f\240\210@AC\240\210\326@8\204\302@\211FAA)B\240\210\327@8E\327C8\204\326\330C8\203\335\330C8\2022D\204p\317\320w\210\212Bb\210\331 \326A8\203\371G\202\372\332Z)<\333U\203H\202 \332\\\321E\206e!\210o\204N`E=\204Nh\334=\204Nh\335=\2030\336e!\204N<\337\340\320\">\204Nh\341=\203j\342\343!\210\317\320x\210\311\344!\203j@\203f<\345=\204f@\211FAA)\fC\241\210\332\202lI\\\2022Df\333U\204\225DTb\210<\337\340\320\">\204\221\311\346!\204\221\317\320w\210i\2022Db\210\347 \204\311DTb\210<\335=\204\264\311\346!\204\264\317\320w\210i<\335=\203\304GJ\\\202\305\332\\\2022\fb\210\321D!\210h\341=\203\367`\326Zfz\350>\203\367h\351=\203\354\352D!\210\316 \210\321D!\210\202\321h\337\353\354\">\204Ph\335=\203 \336D!\204P\352D!\210<\337\355\320\">\203 \332\202\"I\311\356!\203=\331 KV\2038\331 LZ\202>\357 \202>i\\<\333=\203KH\202L\332\\\2022Db\210\212\360u\210\331 E\332M\361\320w\210\311\362!\203\204g\363U\203u\360y\210\202_\212\320\210`M)\364\365!\210\202_`=W\205\253M`V\203\252\331 KV\203\242\331 LZ\202\253EG\\\202\253i*\2062n\203\302\366G!\203\302NI\\\202\304G\317\320x\210n\203\320\332\202\322O\\h\367=\203\335\342\343!\210\317\320x\210h\370=\203\342\343!\210\311\371!\203\372\212\316 \210`)`\"A@\211E\203ETb\210\317\320w\210i\2021\212\316 \210\311\373!)\203/\331 KV\203*\331 LZ\2021\357 \2021\331 \\. )\207" [cperl-indent-left-aligned-comments look-prop prop p pre-indent-point in-pod get-text-property syntax-type (pod here-doc here-doc-delim format) looking-at "[ ]*\n=" error "Spaces before pod section!" "^#" beginning-of-line " " nil cperl-backward-to-noncomment assoc (pod here-doc format here-doc-delim) previous-single-property-change cperl-get-state 2 3 4 current-indentation 0 123 59 125 cperl-after-block-and-statement-beg append ")]}" 58 forward-sexp -1 "[ ]*[a-zA-Z_][a-zA-Z_0-9]*[ ]*:" 10 "[ ]*\\(#\\|$\\)" cperl-block-p (119 95) 44 cperl-backward-to-start-of-continued-exp " ;{" (nil) "}])" "\\w+[ ]*:" cperl-calculate-indent 1 " \n" "#\\|[a-zA-Z0-9_$]*:[^:]" 35 search-forward ":" zerop 41 98 "sub\\>" parse-partial-sexp "[ ]*[a-zA-Z_][a-zA-Z_0-9]*:[^:]" char-after indent-point cperl-look-for-prop case-fold-search parse-data s-s start state containing-sexp old-indent x cperl-indent-level cperl-continued-brace-offset cperl-continued-statement-offset cperl-close-paren-offset cperl-min-label-indent cperl-label-offset colon-line-end cperl-brace-offset cperl-brace-imaginary-offset] 8 (#$ . 70374)]) #@150 Alist of indentation rules for CPerl mode. The values mean: nil: do not indent; number: add this amount of indentation. Not finished, not used. (defvar cperl-indent-alist '((string nil) (comment nil) (toplevel 0) (toplevel-after-parenth 2) (toplevel-continued 2) (expression 1)) (#$ . 73638)) #@177 Return a list of lists ((TYPE POS)...) of good points before the point. POS may be nil if it is hard to find, say, when TYPE is `string' or `comment'. Not finished, not used. (defalias 'cperl-where-am-i #[(&optional parse-start start-state) "\212`\306 \211@ A@\307 8 A@\3103\311\nD\312\fDD4\307 8\2035\313\310\307 8E4B4\202\272\314 8\203D\3154B4\202\272 \204\205\316 \206Oe!\210o\204^h\317\320\310\">\203i\321\nD4B4\202\272h\322=\203z\323\nD4B4\202\272\324\nD4B4\202\272 f\325U\204\251\326 Tb\210\327\330!\204\233\331\310w\210`D\332 D4BB4\202\272 b\210\333 \204\316\326 Tb\210\327\330!\204\300\331\310w\210`D\332 D4BB4\202\272\334 D4B4\316 !\210h\335=\204\347\212\336 )\203\373h\335=\203\361\337 !\210\340 \210\316 !\210\202\332h\317\341\342\">\204  \210\202\272 b\210\212\343u\210\3445\345w\210`W\203>\327\346!\203>g\347U\203/\310\210\202\212\310\210`5)\350\351!\210\202`W\205d5`V\203a\352 6V\203Z\353`DC\202d\354`DC\202d\355`D*\204\272n\203{\3567!\203{89\\\202}7\331\310x\210n\203\211\344\202\213:\\h\322=\203\226\357\360!\210\212\340 \210\327\361!)\203\266\352 6V\203\261\352 ;Z\202\270\362 \202\270\352 \\\2104. \207" [start-point s-s start state prestart containing-sexp cperl-get-state 3 nil parse-start parse-prestart string 4 (comment) cperl-backward-to-noncomment append ";}" toplevel 41 toplevel-after-parenth toplevel-continued 123 expression-blanks looking-at "[ ]*\\(#\\|$\\)" " " expression cperl-block-p in-block 44 cperl-after-label cperl-backward-to-start-of-continued-exp beginning-of-line ";}{" (nil) 1 0 " \n" "#\\|[a-zA-Z_][a-zA-Z0-9_]*:[^:]" 35 search-forward ":" current-indentation label-in-block label-in-block-min-indent statement-in-block zerop forward-sexp -1 "[ ]*[a-zA-Z_][a-zA-Z_0-9]*:[^:]" cperl-calculate-indent case-fold-search res colon-line-end cperl-min-label-indent cperl-indent-level cperl-brace-offset cperl-continued-statement-offset cperl-brace-imaginary-offset cperl-label-offset] 5 (#$ . 73943)]) #@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 (#$ . 75985)]) #@105 Go to position before comment on the current line, or to end of line. Returns true if comment is found. (defalias 'cperl-to-comment-or-eol #[nil "\304\211\211\211\210`\305 \210\306`\307\"\310=\204\311\312\313#\203,h\314=\205\217\315u\210\313\202\217\n\204\214\316`\304\211\211\313&\317 8\203\206\320 8\203~`\320 8b\210\321\322!\203a\311\323\324#\204,\313\211\202-\321\325!\203u\311\326\324#\204,\313\211\202-\313 Sb\210\202,\313\315u\210\202,\313\211\2030\317 8,\207" [lim cpoint stop-in state nil beginning-of-line get-text-property syntax-type 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\\\\#]\\|\\\\[\\\\#]\\)*#"] 8 (#$ . 76344)]) (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]) (put 'cperl-1+ 'byte-optimizer 'byte-compile-inline-expand) (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 t] 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) "\203w \306=?\205\220\n\203 \202\f \n\211dW\2034\307\211T\310$\210\307\211T\311\312$\210*S\n\211dW\203V\307\211T\310$\210\307\211T\311\312$\210*\n =\203q\313Z V\203q\307 TS\310$\210\314 \"\207 \206\220?\206\220\307 \315\n\203\216\316\202\217\317$\207" [cperl-use-syntax-table-text-property noface string cperl-st-sfence cperl-st-cfence bb n put-text-property syntax-table rear-nonsticky t 2 cperl-protect-defun-start face font-lock-string-face font-lock-comment-face how at e cperl-string-syntax-table cperl-pod-here-fontify] 6]) (byte-code "\301B\302\301!\204\f\303\301\207" [current-load-list cperl-starters boundp ((40 . 41) (91 . 93) (123 . 125) (60 . 62))] 2) (defalias 'cperl-forward-re #[(lim end is-2arg set-st st-l err-l argument &optional ostart oend) "\306\211\211\211\211\211\211\307\306w\210`m\203\310\202!f\311 \"A\203`@\203;@\202`\312 \240\210\310@\n\313W\203Z\314\n\315 #\210\nT\211\202H\314\316\317 #\210\320\306\203\211\f\204w\314 \321 #\210\202\211\314 \322\fCP #\210\314\f\323 CP #\210\324\325\326\217\210\203\255\314 \211\316=\203\237\317\202\240\315 #\210\f\203\255\314\f\315 #\210\n \f \257.\207" [go-forward i2 i st ender starter nil " " 0 assoc make-syntax-table 256 modify-syntax-entry "." 92 "\\" t "$" "(" ")" bb (byte-code " d\nT^)f=\203 \204\306u\210\202B\307\f!\210\310\311!\210\307 !\210 \204Bh`\306Zf=\203B\212\312u\210\313\314\315x\306\246U)\203B\316u\210\203 \204g=\203gz\317=\204y`\211 dW\203x\320 \211T\321$\210\320 \211T\322\323$\210*\315\323!\203\341`\211\"# \203\253g\324>\203\256\325\326!\203\241\313\225b\210\202\245\327\315w\210`#\202\256\316u\210\330\211\331=\203\272\332\202\273\333\f#\210 \203\310\330 \333\f#\210\315$\334%&\315\323'() & \306 8\315\207" [starter b p ender st cperl-mode-syntax-table 2 set-syntax-table forward-sexp 1 -2 0 "\\\\" nil -1 46 put-text-property syntax-table rear-nonsticky 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] 11) ((error (byte-code "b\210\306\n\2049\307\310 \f\203\311\312\f \206\f#\202\313\f \206&\f&\2049@\2049\240\210\306\207" [lim set-st end argument ostart oend nil message "End of `%s%s%c ... %c' string/RE not found: %s" format "%c ... %c" "" starter ender bb err-l b] 7))) b cperl-starters set-st st-l] 8]) (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\211 \203D\306 \307\"\203D\310 \307\"\211\203>\n\2030 e S])b\210\311 \210`\211\202 e S])\211b\210\202eb\210\202\f\205c\f\203^\306\f\307\"\203^\f\312\f\307\"\211\204L\f\206c *\207" [opos pos before p end nil get-text-property syntax-type previous-single-property-change beginning-of-line next-single-property-change] 4]) #@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) "\204\ne\306 \204d\306\306\306@\306A\306B\306C\306D\306E\306F\306G\306H\306I\306J\306K\306L\307M!M\306N\306O\306P\310Q\310R\311 S\306T \205_ @Y\211U\203j @\202keVU\205t AW\312X\313Y\306Z\314\315!\203\212 \202\213\315 \314\316!\203\230\202\231\316\314\317!\203\246\202\247\317\314\320!\203\264\202\265\320[\203\300d\202\301 \\\321\322\323\324\325\326\327\322\330\331\332\322\333]\203\331\334\202\332\335\260^\336\216\212_\204\352\337\340!\210M\203\371`ab@\341 \342#\210b\210c\343=\203\344\345!\203\346\212\306\210`)\306#\210` W\203 \347^ \310#\203 \306O\350\224\203A\344\351!\203N[\204\350\f\337\352!\210Y@\204\350\fY`\240\210\202\350\f\353 \210`\211AC\354\224L\306F\347\355\\\356#\204z\337\357!\210\310FY@\204zYA\240\210\353\360!\210`BF\203\212m\204\350\fB V\203\234\341 B\361#\210LO\362AB\363\310$\210\362AB\364\363$\210Ab\210\347\365B\310#\203:\353 \210\362AdedS])`\364\366$\210A`\310efge\203\342h\204\357\362egS]fi\310$\210+M\203*A`\304\f\310jklBAh\203j\204)\362AB\367lkB$\202(\362ABlk$\210-\347\370B\356#\210\353 \210`A\202\262\362`dedS])B\364\366$\210`B\310efge\203^h\204k\362egS]fi\310$\210+M\203(`B\304\f\310jklBAh\203\232j\204\245\362AB\367lkB$\202\244\362ABlk$\210-Cb\210\344\371!\203\346\350\224\350\225\304 \306jklBAh\203\332j\204\345\362AB\367lkB$\202\344\362ABlk$\210-\347\372B\356#\203(\350\224\350\225\304 \306jklBAh\203j\204$\362AB\367lkB$\202#\362ABlk$\210-\202\346\346CB\306#\210Bb\210Bd=\204\350\f\373u\210\202\350\f\360\224\203=`A\374VA\306\211W%WAV\354\224L\375W8\206h\376W8\211I\203t\310J\202\210\377\224\205\206\201x\224?\205\206\344\201y!JJ\204\350\f\377\224\203\235\377\224F\377\225G\202\245\376\224F\376\225GFG{D\201zD!EM\203FG\304\306jklBAh\203\344j\204\357\362AB\367lkB$\202\356\362ABlk$\210-FG\310efge\203h\204\362egS]fi\310$\210+\306y\210`A\347\201{E\201|Q\\\356#\203&M\203\300\354\224\354\225\304\306jklBAh\203Zj\204e\362AB\367lkB$\202d\362ABlk$\210-A\354\225\310efge\203{h\204\210\362egS]fi\310$\210+A\354\224\304@\306jklBAh\203\264j\204\277\362AB\367lkB$\202\276\362ABlk$\210-\354\225dddT^)G\362A\354\224\364\201}$\210\362\354\224G\364\201~$\210\362AG\201\310$\210\346AG\306#\210A\354\225\310efge\203\nh\204\362egS]fi\310$\210+G V\203\350\fLO\202\350\f\337\201\200D\"\210Y@\204\350\fYA\240\210\202\350\f\201\201\224\203\272`A\201\201\224\203Z\201\201\224\201\201\225{\202[\335m\354\224L\306HM\203\306y\354=\203\344\201\202!\204\344\201\203!\204iH\203\231\344\201\204!\203\231\201\205\350!\210\306H\202iH\203\244\306H\202i`F\344\201\206!H\306\210F`\304 \306jklBAh\203\333j\204\346\362AB\367lkB$\202\345\362ABlk$\210-\346F`\306#\210F`\310efge\203h\204\362egS]fi\310$\210+\202i\347\201\202\\\356#\210\353 \210\344\201\207!\203\214``\360\\\304 \306jklBAh\203Rj\204]\362AB\367lkB$\202\\\362ABlk$\210-\346``\360\\\306#\210``\360\\\310efge\203{h\204\210\362egS]fi\310$\210+\202\240\337\201\210m\"\210Y@\204\240YA\240\210\306y\210` V\203\255LO\362A`\364\201\211$\210\202\350\f\201\212\224\204\310\201\213\224\203\245 \201\212\224\203\325\201\212\202\330\201\213\211F\224F\225{H`\211AIF\224fJF\224SfCF\201\212=\2030C\201\214>\206IC\201\215=\203J\201\216=\206IC\201\217=\205IF\224\360Zf\201\217=?\202IJ\201\220=\205I\201\221 n\201\222\216\344\201\223!*C\354\224LF\224b\210\201\224e!\210C\204F\201\213=\203\335Hh\201\225J\201\226>\203~\201\227\202\201\201\230\306\">\204\335h\201\231=\203\227\201\232e!\204\335hz\201\233=\203\306\201\205\373!\210h\201\215=\203\266\344\201\234!\202\303h\201\235>\204\306\344\201\236!\204\335h\201\237=\203\331`\360Zf\201\237=\204\335o\205\371J\201\240=\205\370]\205\370o?\205\370\373u\210\344\201\241!??CASA\202h\201\242=\203`\360Zf\201\215=\203\310CC\204/\374VA\306\211W%WAVAb\210C\204F\375W8\204F\376W8\203MIb\210\202\350\f\344\201\243!\203\\\354\225b\210\202b\201\244\306w\210`A\201\245\201\246H\"Z\201\247\\oZ\310XYH&\211IA@F\360I8D\376I8NI@I`GI\205\253D?\205\253GSKI\203\267I\202\271GB\306EI\203\325K\203\325If\201\250=\203\325\310EI\204 \346A`\310#\210\362A`\364\201\251$\210N\203\317 \201\252G!\211G\203\317 m\204\317 \350u\210\202\317 \346AI\310#\210\344\201\253!\203\217 \201\254F`S\310o$\203( Tb\210D\203\201 h\201\242=\203\201 `Spq\211rdW\203Z \362r\211T\201\255q$\210\362r\211T\201\256\310$\210*Isq\211rdW\203\200 \362r\211T\201\255q$\210\362r\211T\201\256\310$\210*\362AI\364\201\251$\210\202\317 \346F`\310#\210\362A`\364\201\251$\210E\203\314 ITtq\211rdW\203\313 \362r\211T\201\255q$\210\362r\211T\201\256\310$\210*\306Kgz\201\233=\203\n\350v\210K\203\347 \346K`\310#\210G`\304\306jklBAh\203\nj\204\n\362AB\367lkB$\202\n\362ABlk$\210-BA\360\\=\203z\n\201\245\201\257H\"\203z\n\212\306\201\260\201\261\217)\203z\nAB\304\306jklBAh\203k\nj\204v\n\362AB\367lkB$\202u\n\362ABlk$\210-\202 Z\204\242\nu\203 \201\245\201\262H\"\204\242\nHG\354=\203 Af\201\220=\204 A\211dddT^)\304\306jklBAh\203\324\nj\204\337\n\362AB\367lkB$\202\336\n\362ABlk$\210-BSB\304\306jklBAh\203\f j\204 \362AB\367lkB$\202 \362ABlk$\210-Z\203\230 GSG\304\306jklBAh\203I j\204T \362AB\367lkB$\202S \362ABlk$\210-\201\263Afv\"\203\230 F\211T\304\306jklBAh\203\214 j\204\227 \362AB\367lkB$\202\226 \362ABlk$\210-` V\203\350\fLO\202\350\f\201\264\224\203\353 \354\224\211ASf\201\265>\204\350\f\374VA\306\211W%WAV\375W8\204\344 \376W8\204\344 \346\201\264\224\201\264\225\310#\210\354\225b\210\202\350\f\201\266\224\203F\fh\201\267=\203F\f`SA\374VAS\306\211W%WASV\375W8\203>\fAStq\211rdW\203=\f\362r\211T\201\255q$\210\362r\211T\201\256\310$\210*ATb\210\202\350\f\201\266\224\203y\f\354\224\211Ctq\211rdW\203u\f\362r\211T\201\255q$\210\362r\211T\201\256\310$\210*\202\350\f\201\270\224\203\263\f\354\225C\354\224A\374VA\306\211W%WAV\375W8\204\254\f\362CSC\201\255w$\210Cb\210\202\350\f\354\225C\354\224A\374VA\306\211W%WAV\375W8\204\344\f\376W8\204\344\f\346AC\306#\210\310oCb\210`\\V\203o\203\375\f\337\201\271!\210\202 \337\201\272!\210Y@\204 YA\240\210\\b\210\202VWBO\206$ ` ])Y@\2034 Y@b\210\202? _\204? \337\201\273!\210)Y@.#\207" [min cperl-syntax-state cperl-syntax-done-to max face head-face nil eval t buffer-modified-p (nil) (nil) boundp font-lock-string-face font-lock-constant-face font-lock-function-name-face cperl-nonoverridable-face "\\(\\`\n?\\|\n\n\\)=" "\\|" "<<" "\\(" "\\([\"'`]\\)" "\\([^\"'`\n]*\\)" "\\3" "\\\\?\\(\\([a-zA-Z_][a-zA-Z_0-9]*\\)?\\)" "\\(\\)" "\\)" "^[ ]*\\(format\\)[ ]*\\([a-zA-Z0-9_]+\\)?[ ]*=[ ]*$" "\\|\\<\\(q[wxqr]?\\|[msy]\\|tr\\)\\>\\|\\([?/<]\\)\\|\\[ ]*\\([a-zA-Z_:'0-9]+[ ]*\\)?\\(([^()]*)\\)\\|\\$\\(['{]\\)\\|\\(\\" "=cut is not preceded by a POD section" beginning-of-line 0 "\n\n=cut\\>" toend "End of a POD section not marked by =cut" 2 (syntax-type t in-pod t syntax-table t 'cperl-postpone t) put-text-property in-pod syntax-type "\n\n[ ]" pod cperl-postpone "\n\n[^ \f\n]" "=[a-zA-Z0-9_]+\\>[ ]*\\(\\(\n?[^\n]\\)+\\)$" "\n\n=[a-zA-Z0-9_]+\\>[ ]*\\(\\(\n?[^\n]\\)+\\)$" -1 parse-partial-sexp 3 4 5 here-face b e bb tag qtag b1 e1 argument i c tail tb cperl-pod-here-fontify go tmpend case-fold-search inhibit-read-only buffer-undo-list modified after-change-functions use-syntax-state state-point state st-l err-l i2 ignore-max stop-point cperl-use-syntax-table-text-property search non-inter cperl-pod-face cperl-pod-head-face cperl-here-face system-type p post to from cperl-syntaxify-by-font-lock cperl-do-not-fontify now val type name save-match-data-internal end cperl-st-ket how at cperl-st-bra cperl-st-punct cperl-fontify-m-as-s cperl-starters cperl-st-word 6 "[ ]*[=0-9$@%&(]" regexp-quote "^" "$" here-doc here-doc-delim here-doc-group "End of here-document `%s' not found." 8 "^[.;]$" "^#" "^[ ]*{" forward-sexp "^[^\n]*[@^]" "^\\.$" "End of format `%s' not found." format 10 11 (36 64 37 42 35) 45 115 38 60 match-data ((set-match-data save-match-data-internal)) "\\s *\\$?\\([_a-zA-Z:][_a-zA-Z0-9:]*\\s *\\)?>" cperl-backward-to-noncomment append (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|" 62 "[ \n\f]+\\(#[^\n]*\n[ \n\f]*\\)+" " \n\f" string-match "^\\([sy]\\|tr\\)$" cperl-forward-re 92 string cperl-1+ "\\sw*e" cperl-find-pods-heres syntax-table rear-nonsticky "^\\([sm]?\\|qr\\)$" (byte-code "b\210\301\302!\210\303\304!?\207" [tb forward-sexp -1 looking-at "split\\>"] 2) ((error t)) "^\\(m\\|qr\\)$" assoc 13 (36 64 37 38 42) 14 39 15 "Garbage after __END__/__DATA__ ignored" "Unbalanced syntax found while scanning" "Scanning for \"hard\" Perl constructions... done"] 15 (#$ . 81165) nil]) (defalias 'cperl-backward-to-noncomment #[(lim) "\304\211\211\n?\205P` \206\305V\205P\306 x\210`\307 \210\310`\311\"\211\312>\2030\313\304!\210\202\314\315!\204\316 \210n\204\317\304x\210 `W\203J b\210\320\211\202+\207" [pr p stop lim nil 1 " \n\f" beginning-of-line get-text-property syntax-type (pod here-doc here-doc-delim) cperl-unwind-to-safe looking-at "^[ ]*\\(#\\|$\\)" cperl-to-comment-or-eol " " t] 4]) (defalias 'cperl-after-block-p #[(lim) "\212\300\301\302\217)\207" [nil (byte-code "\301\302!\210\303!\210`=\206=h\304=\206=hz\305=\203:\212\301\302!\210\306\307!\2068\303!\210hz\305=\2058\301\302!\210\306\310!)\207\311!\207" [lim forward-sexp -1 cperl-backward-to-noncomment 41 119 looking-at "\\(else\\|grep\\|map\\|BEGIN\\|END\\)\\>" "sub\\>" cperl-after-expr-p] 2) ((error))] 3]) #@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) "\305\211\206e\212\n\204Z`V\203Z\306x\210`\307 \210\310\311!\204 \312 \210\313\305x\210 `W\2034 b\210`h\314=\203Q\315u\210\306x\210hz\316=\203Q\317\315!\210\202 b\210\320\211\203o\206\212`=\206\212\310\321!\206\212 \203t\322 !\202\212h\323\f\206{\324\305\">\206\212h\325=\205\212\326!,\207" [lim p stop test chars nil " \n\f" beginning-of-line looking-at "^[ ]*\\(#\\|$\\)" cperl-to-comment-or-eol " " 58 -1 119 forward-sexp t "[ ]*__\\(END\\|DATA\\)__" eval append "{;" 125 cperl-after-block-p] 5 (#$ . 92186)]) (defalias 'cperl-backward-to-start-of-continued-exp #[(lim) "h\301\302\303\">\203 \304\305!\210\306 \210`X\203Tb\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\304\210`\304\211\212\305 \210\204U`\306`\n\307#@\307U\203$`\202 b\210`\nW\203?\306`\n\304\310$\210l\204'\311\312!\210\202'`\nV\203O\212\304\210`)\202\310\211\203\nb\210\313 ) \203d\314\n!\210\315`\n\",\207" [done top tmp-end cperl-indent-region-fix-constructs nil beginning-of-line parse-partial-sexp -1 t forward-sexp 1 point-marker cperl-fix-line-spacing cperl-indent-region] 6 (#$ . 93568) 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) "\204d\306\211\211\211\211\212\306\210`) \206\307/0\212\310 \210`\311\312!\2047\212\313\314\n\315#)\211\203 1\203[\311\316!\203[\313\314!\210`0\317\306w\2100`|\210\320 \321\"c\210\310 \210\311\322!\203q\313\314!\210\323 \210\320 \321\"c\210\310 \210\311\324!\203\206\307v\210\323 \210\320 \321\"c\210\310 \210\311\325!\203\233\326v\210\323 \210\320 \321\"c\210\310 \210\311\327!\203\260\330v\210\323 \210\320 \321\"c\210\310 \210\311\331!\203\256\332\224\333\334!\210\335u\210`0g\336=\203\323\337\307!\210`/\202\344 \203\336\317\306x\210\202\341\310 \210\306//\205\365\2120b\210\313\340/\315#)/\203/W\203\256\311\341!\203\256n\204l\311\342!\203F\323 \210 \2032\202 3\203=\323 \210\340c\210`\3434!\203l\3444\"\210`\202l\320 \321\"c\210\202l\311\345!\203l \203U2\202W3\204l`/\317\306w\210/`|\210\320 \321\"c\210\311\346!\203\256\317\306w\210`/\337\307!\210`0/b\210\313\3400\315#5\204\224 \203\256/Tb\210\323 \210\340c\210`\3434!\203\256\3444\"\310 \210`0\212\306\210`)/6\203 \f\203 \311\347!\204 \306\350\351\217\203 \335u\210\352\306x\210n\203\357\3434!\210\313\314!\210\323 \210\340c\210\202\323 \210h\353=\204 n\204 h\354=\203\355e!\204 \356c\210\340c\210`\3434!\203\3444\"\310 \210) .\207" [end cperl-indent-region-fix-constructs ee ret have-brace ml 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 "[ ]*}?[ ]*\\<\\(\\els\\(e\\|if\\)\\|continue\\|unless\\|if\\|while\\|for\\(each\\)?\\|until\\)\\>\\( *\\|[ ][ ]+\\)[^ \n#]" "[ ]*\\\\([ ]*(\\|[ \n]*{\\)\\|[ ]*{" 8 re-search-forward "[({]" -1 40 forward-sexp "\n" "[ \n]*{" "\\( *\\| [ ]+\\){" cperl-indent-line cperl-fix-line-spacing "[ ]*\n" "[ \n]*{[ ]*[^ \n#]" "[ ]*}[ ]*\\(\\<\\(els\\(if\\|e\\)\\|continue\\|while\\|until\\)\\>\\|$\\|#\\)" (byte-code "\302\303!\210`X\203h\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 ";" pp p cperl-merge-trailing-else cperl-extra-newline-before-brace-multiline cperl-extra-newline-before-brace parse-data cperl-break-one-line-blocks-when-indent cperl-fix-hanging-brace-when-indent] 7 (#$ . 94303) nil]) (byte-code "\301B\302B\301\207" [current-load-list cperl-update-start cperl-update-end] 2) (defalias 'cperl-delay-update-hook #[(beg end old-len) " \206d^\n \206e]\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 \307\211\211\211\211\211\211\211 \205\307\211\211E\307\310\311&'()*+,-./0\n\203?\312\301\313\"\2101b\210\314 \205Ii\211.-1b\210\315 \307\223n\204`\316\317!\210\320\321!\204j\322\323!\210`X\203Em\204E\320\321!\203\232&\203\232`1Z\324_1Z\325Z\2452\322&2\"\2102')`0\326\327!\211)\204\303\326\330!\211/\203\363\331 .\206\2703=\204\303\307\211.\203\363.\203>)\204>\331 .U\203>\332`\333\"\334=\204>\332`\335\"4=\204>-3\336 \210)\202>\337(!*/\204>*\203>5\203\340(\"b\210\314 \205*\332`\333\"\341>?\205*\332`\335\"4=?\205*i\211.\203>\336 \210\342\307x\210\343\307x\210i-\316\317!\210\202j\320\321!\203b&\203f\3242\322&2\"\2102')\202f\322\307!\210.\f \205\205\212 \205\204 b\210\344c\210\345\325!\210\fb\210\344c\210\345\325!),\207" [end after-change-functions h-a-c cperl-update-end cperl-update-start cperl-emacs-can-parse cperl-update-syntaxification nil 0 "Indenting... (%3d%%)" add-hook cperl-delay-update-hook cperl-to-comment-or-eol make-marker beginning-of-line 2 fboundp imenu-progress-message message "Indenting... For feedback load `imenu'..." 100 -1 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 imenu-scanning-message pm indent-info empty i pp p new-comm-indent old-comm-indent comm st start pos comment-column cperl-st-cfence cperl-indent-region-fix-constructs] 13 (#$ . 97518) "r"]) #@249 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\212\307 \210\310\311!\203)\312\313\224\313\225{\202b\314 \203b\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)\204o\324!\202\214 \203{\307 \210`\202\224\212\325\326y!\203\211\310\327!\204|\310\327!\204\222\330y\210`)\212\330y\210\310\327!\204\225`)}\210eb\210\330y\210`dW\203\303\320\306w\210\310\331!\203\245\322\313\225\313\224Z!\210\202\245 \332P \332P!\" \324!\210, \205 b\210 \313V\203\355\322 !\210 c\210i\fU\206\365#?\205\f\333 \210\334\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 "#+" "\\|^[ #]*$" indent-for-comment cperl-fill-paragraph comment-fill-prefix has-comment justify paragraph-start fill-prefix paragraph-separate iteration] 8 (#$ . 99501) "P"]) (defalias 'cperl-do-auto-fill #[nil "\212\304\210i)V\205P\212\305 \210\306 \210`)g\307>\304\211`Y?\205O\310 \311 \210 b\210n\2037\312\313!\210\314\225b\210\n\203Gg\315>\204G\316c\210\317u\210h\320>\206O\316c+\207" [fill-column marker s c nil beginning-of-line cperl-to-comment-or-eol (32 9) point-marker cperl-fill-paragraph re-search-forward "#+[ ]*" 0 (32 9) " " -1 (32 9)] 4]) (byte-code "\301B\302\301!\204\f\303\301\207" [current-load-list cperl-imenu--function-name-regexp-perl boundp "^\\([ ]*\\(sub\\|package\\)[ \n]+\\([a-zA-Z_0-9:']+\\)[ ]*\\(([^()]*)[ ]*\\)?\\|=head\\([12]\\)[ ]+\\([^\n]+\\)$\\)"] 2) (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+++" mapcar #[(elt) "<\205A<\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\313\310\211\211\211\211\313\310789:;<=>?@ABeb\210C\203E\314\315!\210\202YD\203Y\313E\314DE\"\210E8)\316F\206aG\310\317#\203\332C\204\213D\203\213\320\310!\211E8\321\\V\203\212\314DE\"\210E8)\322\224\203\245\322\224f\323=\203\245\324 H\325\216\326\327!*\203Y\322\224\203\236\330\331\224\332\"\204\236\330\331\224\333\"\204\236\330\331\224\334\"\204\236\212\322\224b\210g)g7\310<`9:\203\3569:@Y\203\356:A:;A;\202\323;@\206\365\335:@\206\375\313 \323=\2032\336\224\336\225{\337\313\nG\310\n$\210\n\211\340P\341\nP\212\342`d\343#\210`)\211:B:;B; \344=\203?7\345=\204Y\346  \323=\204q\336\224\336\225{\337\313\nG\310\n$\210\347\350\n\"\203c\317<\202q9 V\204q\nP\317<\f\n\240\210 \323=\203\204\fABA\202\212\fBBB<\203\225\f=B=\f?B?\202Y\321\224\203Y\346 \351\224\351\225{\337\313\nG\310\n$\210\321\224f\352=\203\300\353\nP\f\n\240\210\354\nP\fAB\f@B@ ?B?\202YC\204\363D\203\363\355E\314DE\"\210E8)\311\312!\203\356B\311\312!\"\202B\237B@\203\357@\237BBBBA\204!=\203\347A\310\211\211\211\211IJKLMM\203^M@JMAMJ@\360\310O\361\nL\"\2043\nJABLBL\2023=MM\203\334M@JMAM\347\362J@\"\203bJ@\313\211\224OK\361KL\"\211I\203\303IA<\203\256IJ@\313\224\322\\\310OJABIAB\241\210\202bIJ@\313\224\322\\\310OJABC\241\210\202bKJ@\313\224\322\\\310OJABCBLBL\202b\363LBBBB.A\203\366\364A\237BBBBA\204@\204\311\312!\203?\203\365?\237BBBB\366B!.\207" [package end-range name index1 index fchar require imenu nil default-value imenu-sort-function 0 message "Scanning Perl for index" re-search-forward t imenu--relative-position 5 2 112 match-data ((set-match-data save-match-data-internal)) looking-at "[ \n]*;" get-text-property 1 syntax-table syntax-type in-pod "" 3 set-text-properties "::" "package " parse-partial-sexp -1 115 59 imenu-example--name-and-position string-match "[:']" 6 50 " " "=" 100 sort "+POD headers+..." 8 assoc "\\(::\\|'\\)[_a-zA-Z0-9]+$" "+Hierarchy+..." "+Packages+..." "+Unsorted List+..." cperl-imenu-addback char prev-pos p ends-ranges packages meth index-meth-alist i-s-f index-unsorted-alist index-pod-alist index-pack-alist index-alist noninteractive imenu-scanning-message pos regexp cperl-imenu--function-name-regexp-perl save-match-data-internal group elt pack hier-list lst] 19]) #@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)) (#$ . 104285)) (byte-code "\300\301!\203 \301\302\303\"\210\300\207" [fboundp eval-after-load "mode-compile" (setq perl-compilation-error-regexp-alist cperl-compilation-error-regexp-alist)] 3) #@40 Initialization under windowed version. (defalias 'cperl-windowed-init #[nil "\301\302!\204\n\203\206 \303 \207\304\305\306\"\210\307\310!\205 \310\311\312\"\207" [cperl-faces-init featurep ps-print 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 (#$ . 104670)]) #@65 Additional expressions to highlight in Perl mode. Minimal set. (defvar cperl-font-lock-keywords-1 nil (#$ . 105134)) #@65 Additional expressions to highlight in Perl mode. Default set. (defvar cperl-font-lock-keywords nil (#$ . 105258)) #@64 Additional expressions to highlight in Perl mode. Maximal set (defvar cperl-font-lock-keywords-2 nil (#$ . 105380)) (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 "\301\300!\206&\300\302\303!\205\303 \235\204\304\300!\210\301\300!\206&\305\300\306\307#\210\300\300\207" [font-lock-constant-face boundp fboundp face-list make-face put variable-documentation "Face for constant and label names"] 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\322 D\323BBB\324\325\326\327\330#\331Q\332B\333\332\334E\335\332\336E\337\340\341\342\312\313!\203K\343\202T\203S\344\202T\345\346\347\350\312\313!\203a\351\202j\203i\352\202j\353\354\257\310\355!\205z\f?\205z\356 \203\205\357\nB\202\206\n\211@A\360@ \"B+\310\361!\203\234\362 \210\312\363!\204\250\312\313!\203\257\364\365!\210\202\306\366\367\370\371#\210\372\367!\204\276\3167\373\310\374!\205\307\374 \235\204\317\375\373!\210\372\373!\204\336\366\373\370\376#\210\373;\377\310\374!\205\347\374 \235\204\357\375\377!\210\372\377!\204\366\377\370\201K#\210\377?\334\310\374!\205 \374 \235\204\375\334!\210\372\334!\204\"\366\334\370\201L#\210\334\336\310\374!\205+\374 \235\2043\375\336!\210\372\336!\204D\366\336\370\201M#\210\336\201C\310\374!\205O\374 \235\204Y\375\201C!\210\372\201C!\204p\366\201C\370\201N#\210\201CC\201D\310\374!\205{\374 \235\204\205\375\201D!\210\372\201D!\204\234\366\201D\370\201O#\210\201DD\201E\310\374!\205\247\374 \235\204\261\375\201E!\210\372\201E!\204\310\366\201E\370\201P#\210\201EE\201F\310\374!\205\323\374 \235\204\335\375\201F!\210\372\201F!\204\364\366\201F\370\201Q#\210\201FF\201F\310\374!\205\377\374 \235\204\201R\310\374!\205\374 \235\203\201S\201R\201F\"\210\201E\310\374!\205(\374 \235\204F\201T\310\374!\2057\374 \235\203F\201S\201T\201E\"\210\336\310\374!\205O\374 \235\204k\201U\310\374!\205^\374 \235\203k\201S\201U\336\"\210\372\201G!\203xG\202{\201V\310\374!\205\203\374 <H\366\367\370\201W#\210\372\367!\204\260\372\201I!\203\254I\201X=\203\254\201Y\202\256H7\373\310\374!\205\271\374 \235\204\325\201Z\310\374!\205\310\374 \235\203\325\201S\201Z\373\"\210\334\310\374!\205\336\374 \235\204>\201S\201[\334\"\210H\201V=\203\201\\\334\201]\201^!\203\201^\202 \201_\"\210\202>H\201`=\2035\201\\\334\201]\201a!\203-\201a\2020\201b\"\210\202>\201c\334\201d\"\210\336\310\374!\205G\374 \235\204\231\201S\334\336\"\210H\201V=\203w\201\\\336\201]\201e!\203o\201e\202r\201f\"\210\202\231H\201`=\203\231\201\\\336\201]\201g!\203\224\201g\202\227\201h\"\210\377\310\374!\205\242\374 \235\204\257\201S\201i\377\"\210\373\310\374!\205\270\374 \235\204\305\201S\201i\373\"\210*\317\211J\207" [font-lock-anchored t-font-lock-keywords-1 t-font-lock-keywords cperl-invalid-face cperl-xemacs-p cperl-syntaxify-by-font-lock 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" "require" "package" "eval" "my" "BEGIN" "END") "\\|" "\\)\\>" 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\\|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\\|cho\\(p\\|mp\\)\\|d\\(e\\(fined\\|lete\\)\\|o\\)\\|DESTROY\\|e\\(ach\\|val\\|xists\\|ls\\(e\\|if\\)\\)\\|END\\|for\\(\\|each\\|mat\\)\\|g\\(rep\\|oto\\)\\|if\\|keys\\|l\\(ast\\|ocal\\)\\|m\\(ap\\|y\\)\\|n\\(ext\\|o\\)\\|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) ("\\*&]\\|\\$[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\\)[ ]*\\(([ ]*\\)?\\([$@%*][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\\)[ ]*\\(([ ]*\\)?\\([$@%*][a-zA-Z0-9_:]+\\)" (3 font-lock-variable-name-face) ("\\=[ ]*,[ ]*\\([$@%*][a-zA-Z0-9_:]+\\)" nil nil (1 font-lock-variable-name-face))) ("^[ {}]*\\(my\\|local\\)[ ]*\\(([ ]*\\)?\\([$@%*][a-zA-Z0-9_:]+\\)" 3 font-lock-variable-name-face) ("\\\203S\343:\212\322\344\311\324#\203\345\224\202d)\"\346\\8\f\2036\347Z=_\350\245\202/\351 \211\327=\203)\352\353 \n\245\354Z8 V\203: 8\f\203I\35587Z!\210\202S\356\3204!8T\"\210\357\317 :\"\210\202b\360\361\"\210\340 !.\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 beginning-of-buffer 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 count-lines "^[ ][^\n]*\n+\\([^ \n\f]\\|\\'\\)" 0 2 3 100 frame-char-height 18 x-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 (#$ . 121477) (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 (#$ . 123423) 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]) (defalias 'cperl-imenu-on-info #[nil "p\305\305\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 nil nil]) #@514 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\211\212b\210\306\210\307 b\210\310\306w\210\307 \311\306#\210b\210i\312\313!\203S\312\314!\203L\315\316\317\224\317\225{!\320Q\202c\321\322!\210\202c\312\323!\203]\321\324!\210\316\325g!!\206o \206o!\"\204y\326\"\327\330!\210`W\203\242\331 \332#\203\242\317\224b\203\242i\332 \fV\203y \202y\n\204\252\321\333!\210b\210\f\"\\\211\246\317U\204\306\f\245T_`\334\306x\210`|\210\fj\210\327\330!\210`W\205\360\331 \332#\205\360\317\224b\205\360\202\306.\207" [e b seen tcol col search 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" " " end beg step cperl-lineup-step cperl-indent-level minshift] 7 (#$ . 124563) "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" "/\\<\\(package\\|sub\\)[ \\t]+\\(\\([a-zA-Z0-9:_]*::\\)?\\([a-zA-Z0-9_]+\\)[ \\t]*\\(([^()]*)[ ]*\\)?\\([{#]\\|$\\)\\)/\\4/") 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 (#$ . 126107) 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 (#$ . 126985) 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 (#$ . 127218) 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 (#$ . 127505) nil]) #@91 Toggle the state of automatic help message in CPerl mode. See `cperl-lazy-help-time' too. (defalias 'cperl-toggle-autohelp #[nil "\301\302!\203!\203\303\304!\210\202\305 \210\306\307\203\310\202\311\"\207\306\312!\207" [cperl-lazy-installed fboundp run-with-idle-timer eval (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 (#$ . 127946) 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 (#$ . 128452) nil]) (byte-code "\301B\302\301!\204\f\303\301\207" [current-load-list cperl-tmp-buffer boundp " *cperl-tmp*"] 2) (defalias 'cperl-setup-tmp-buf #[nil "\303!q\210\304 !\210\305 \210\306\307!\210\n\205\310\311!\210\311\312L\207" [cperl-tmp-buffer cperl-mode-syntax-table cperl-use-syntax-table-text-property-for-tags get-buffer-create set-syntax-table buffer-disable-undo auto-fill-mode 0 make-local-variable parse-sexp-lookup-properties t] 2]) (defalias 'cperl-xsub-scan #[nil "\306\307!\210\310\311\310\211\211\211\211eb\210\203\"\312\313!\210\2025\2035\311 \312 \"\210 )\314\315\310\316#\203\347\204_\203_\317\310!\211 \320\\V\203^\312 \"\210 )\321\224\203\211\321\224\321\225{\311\224b\210\322\310w\210\323u\210\324\325!\203\204\323\224\323\225{\2025\310\2025 \2035\326\224\203\325\326\224Tb\210\327 \326\224\326\225{\203\263\330\331P\n\"\203\263\nG\310O\330\332\n\"\204\310 \332\nQ\fAB\211B\f\n\240\210\fB\2025\327 \211 \333P\240\210\fB\2025\204\377\203\377\334 \312 \"\210 ).\207" [prefix package name index1 index prev-pos require imenu nil 0 message "Scanning XSUB for index" re-search-forward "^\\([ ]*MODULE\\>[^\n]*\\\\|\\([a-zA-Z_][a-zA-Z_0-9]*\\)(\\|[ ]*BOOT:\\)" t imenu--relative-position 5 2 " " 1 looking-at "[^\n]*\\" 3 imenu-example--name-and-position string-match "^" "::" "::BOOT:" 100 index-alist noninteractive imenu-scanning-message pos] 8]) (defalias 'cperl-find-tags #[(file xs topdir) "\306\307!\306\211\211\211\211\211&'(\212'\203\"'q\210\202%\310 \210\311 \210\312)!@)\313\314)\"\210*\203D+\204D\315\316\317\217\210+\203P\320 &\202\\\321 (\322\323(\"A&\324\325&\"&\311 \210&\203\304&@&A& \203f \326\234\327\330\331 @\"\203\214 @\332\306O\202\216 @\333\334 \335\234!\336\334 \333\234S!\337\261\210\330\340 @\"\203f\330\341 \326\234\"\203f \326\234\333\224\333\225O AB&B\211&\204k`\333b\210)\342\343\nG\306\n$\210,\n\343,GO\232\203\350),G\306O\344\n\336\334\fS!\337\261\210\333d{\311 \210-\204\313\345)\"\210 . \207" [cperl-tmp-buffer cperl-pod-here-fontify rel ret pos elt nil get-buffer cperl-setup-tmp-buf erase-buffer insert-file-contents message "Scanning file %s ..." err (cperl-find-pods-heres) ((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`\"T\306\307w\210l\204\"\305u\210`\303 \210`{F\207" [elt string-match "^[_a-zA-Z]" beginning-of-line count-lines 1 ":_a-zA-Z0-9" nil] 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" lst b ind file cperl-use-syntax-table-text-property-for-tags xs topdir noninteractive] 10]) #@174 Add to TAGS data for Perl and XSUB 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-noxs #[nil "\300\301\211\302\211\301\302&\207" [cperl-write-tags nil t] 7 (#$ . 131738)]) #@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 (#$ . 132043)]) (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'()\212*\204Y\317)!\203S+\203K\320 \210\202Y\320)!\210\202Y\321)!q\210 \203\210,\322=\204o,\203o\323 \210\322,\324\325-?\205z.\325$/\326\327/\"\210)\202\330\331\"\211'\203\2270\204,\322=\203\244db\210\202\370,\203\257\323 \210\202\370\332b\210\333\334 G\316 $\210 \334 GO\232\203\314 G\316O\335\336 \337Q\316\325#\203\365\340\336!\210`\212\332u\210\335\336\316\341#\203\356`\342Z\202\357d)|\210\202\370db\210\343' #c\210*?\205\344\334!\210\345\346!\205\346 -\207" [file dir default-directory topdir system-type rel 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 directory-files t mapcar #[(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" "," search-backward toend 2 cperl-find-tags save-buffer fboundp initialize-new-tags-table xs case-fold-search tags-file-name inbuffer cperl-xemacs-p erase recurse cperl-scan-files-regexp files noxs] 6]) (byte-code "\301B\302\301!\204\f\303\301\207" [current-load-list cperl-tags-hier-regexp-list boundp "^\\(\\(package\\)\\>\\|sub\\>[^\n]+::\\|[a-zA-Z_][a-zA-Z_0-9:]*([^\n]+::\\|[ ]*BOOT:[^\n]+::\\)"] 2) #@29 Global hierarchy of classes (defvar cperl-hierarchy '(nil nil) (#$ . 134029)) (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\236A\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\204\226\312\211\211\211\211\211\211\211\211\313()*+,-)( E.\203Q/\204A\314\315!\210\316\317!\210\320/!q\210\321 \210\202d0\204Z\314\315!\210\322\3230\"\210\316\324!\210\322\n @\"\210\322\n A@\"\210\312\325 A@B\326 @BE*\327*\330\"\210 AA\331\332*AB!\240\210\316\333!\210.\n\311 8\204\240\334\335!\2101\203\256\336\337\311 8\"\202\267\306\340!\210\341\311 8!\211\203\320<\203\320A\203\315A\211\202\302@\342!\203\342\343\344\234!\210\345\330\234!\210\346=\205\353\347\337!\207" [update cperl-hierarchy remover b l4 l3 require etags imenu 2 nil #[(elt) "AA\206\f\211A@A\241\207" [elt] 2] call-interactively visit-tags-table message "Updating list of classes..." get-file-buffer cperl-tags-hier-fill mapcar #[(tagsfile) "\301\302\"\210\303!q\210\304 \207" [tagsfile message "Updating list of classes... %s" get-file-buffer cperl-tags-hier-fill] 3] "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" x-popup-menu t tmm tmm-prompt vectorp find-file 0 etags-goto-tag-location -999 cperl-tags-hier-init l2 l1 to cons1 name pack cperl-xemacs-p tags-file-name tags-table-list window-system] 11 (#$ . 134833) nil]) (defalias 'cperl-tags-treeify #[(to level) "\306\307\310\311\312\"\313#\314Q\nA@A\315\n8A\316\316\316\316\316\316\316\316\316 \316!\316\"\316#\316$\316%\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 mapcar #[(elt) "\302 T\"\207" [elt level cperl-tags-treeify] 3] #[(elt) "A<\205G\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] 6]) (defalias 'cperl-list-fold #[(list name limit) "\306\211\211\307\fG X\203\f\202J\306\306\f\203BT\f@\fA X\2032 \nB\202\n\n\237B B C\310\202\n\n\237B B\237,\207" [num elt1 list2 list1 list limit nil 0 1 imenu-max-items name] 4]) (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=+<>~]") "\\|") (#$ . 138372)) #@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]+[ ]*=>") "\\|") (#$ . 138587)) (byte-code "\301B\301\207" [current-load-list found-bad] 2) #@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`\304\305 \210\306\307\310\311\312\313\314&\210 \203 b\202\"b\210\315\316!*\207" [p found-bad last-nonmenu-event nil 13 beginning-of-buffer 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 (#$ . 139154) nil]) (defalias 'cperl-next-bad-style #[nil "\306\307`\306\n\203l\310\f\306\311#\203l`\312\224b\210\313 !\204Yg\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 ((set-match-data save-match-data-internal)) 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=" "#!") "\\|") (#$ . 140574)) (byte-code "\301B\303\301!\204\f\304\302B\303\302!\204\305\305\207" [current-load-list cperl-message-on-help-error cperl-help-from-timer boundp t nil] 2) (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\202Sh\316\317\311\">\203D\320u\210\202Sh\321=\203Si\301=\203S\320u\210h\322=\203\345\306\323!\203\345\320u\210\202\345\306\324!\203wh\325=\203w\320u\210\202\345\306\326!\203\211h\314=\203\211\320u\210\202\345\306\327!\203\320\330\311x\210h\314=\203\250`\313Zf\314=\204\250\320u\210\202\345g\331=\203\345\332\333\334h!\"\203\345\212\335\320!\210h\322=\205\305\306\323!)\203\345\336\337!\210\202\345g\314=\203\345h\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 ((set-match-data save-match-data-internal)) 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 (#$ . 142090) nil]) #@39 Where the documentation can be found. (defvar cperl-doc-buffer " *perl-doc*" (#$ . 142853)) #@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\210\310\315 \"\203)\316 \313\211\225OP\202\210\310\317 \"\203;\320 \313\211\225OP\202\210 \321\230\203M\310\322 \"\203M\323\202\210\310\324 \"\203a\325\326 \313H\327\\!P\202\210\310\330 \"\203m\331\202\210\310\332 \"\203y\333\202\210 \334\230\203\210\310\335 \"\203\210\336\337\340\341 !\342R\343 \210eb\210\307\344d\306#\203\264\212\345\313!\210`\307\210\346\347 `{\"*\202\275)\205\275\346\350 \",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 64 "^CORE::" "CORE::" "^SUPER::" "SUPER::" "<" "^<\\$?[a-zA-Z0-9_:]+>" "" "^" "\\([^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] 4 (#$ . 142951)]) #@15016 # based on '@(#)@ perl-descr.el 1.9 - describe-perl-symbol' [Perl 5] ! ... 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. Initial value 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 perl script being executed. May be set. $: 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 . $^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. .. Alternation, also range operator. .= Concatenate assignment strings ... / ... Division. /PATTERN/ioxsmg Pattern match ... /= ... Division assignment. /PATTERN/ioxsmg Pattern match. ... < ... Numeric less than. Glob. See , <> as well. Reads line from filehandle NAME (a bareword or dollar-bareword). Glob (Unless pattern is bareword/dollar-bareword - see ). <> 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. Also used by split unless in array 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. 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. 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(LIST) 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). ... 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(LIST) 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 . 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 . 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 "Ignore my value" (#$ . 144101)) #@67 Go to the perl documentation buffer and insert the documentation. (defalias 'cperl-switch-to-doc-buffer #[nil "\303!t\203\304 !\210\202 q\210\305 \306U\205\"\307\310\311\"c\210\312\211)\207" [cperl-doc-buffer buf buffer-read-only get-buffer-create switch-to-buffer-other-window buffer-size 0 documentation-property cperl-short-docs variable-documentation t] 3 (#$ . 159180) nil]) (defalias 'cperl-beautify-regexp-piece #[(b e embed) "\306\211\211\307 \307 \306\211\211\2111234\204$5Tb\210\202V5b\210\310\311!\203;\312u\210\313\314!\210\314u\210\202V\310\315!\203G\316u\210\202V\310\317!\203S\312u\210\202V\314u\2104\203`\320 \202biS\21126\206l7\\\310\321!\204w\322c\2108b\210\323 \210\324\3258\326#\203\2308b\210\322c\2102j\2108`\306\223\2105b\210\312\210`\3278!W\203^\323 \210`3\326\330\306w\2103`|\210 j\210 \203F\310\331!\203F\332\225b\210\326\314\224\203\327\333u\210\2022\316\224\204\347\334\224\203\361h\335=\203\361\333u\210\336\314!\210\2022\337\224\203%`1\310\340!\203\332\225b\210\324\3418\326#\2041Sb\210\342\343!\210h\335=\2032\333u\210\336\314!\210\2022\344\224\203\352\332\224b\210i =\204:\322c\210 j\210`1\336\314!\210 `S\306\223\210\f`\306\223\210\345\224\204[\3461 \326#\210\202\2421\312\\f\335=\204\2421\312\\f\347=\203\2021\312\\b\210\336\314!\210\346` \326#\210\202\2421\312\\f\350=\203\2331\316\\b\210\346` \326#\210\202\242\3461 \326#\210\fb\210\310\351!\203\262\332\225b\210\202\305g\335=\203\305\336\314!\210g\352=\203\305\306u\210\330\306w\210\306\310\353!\203\337l\204\330\354 \210\323\312!\210\202\342\322c\210\306\210\306\2022\355\224\2032\333u\210`1\323 \210\324\3251\326#\203 1b\210\322c\210\202`1|\2102j\210\314u\210\330\306w\210\306\310\353!\203*\323\312!\210\202-\322c\210\306\210\306\310\356!\204?\n\203?\357c\210\330\306w\210\202\274\310\353!\204T\342\360``T{\"\210 \203\237\312\210\202\237`\3278!Y\205\202\320 2U?\205\202\323 \210`3\330\306w\2103`|\2102j. \207" [code inline spaces c1 m1 m nil make-marker looking-at "(\\?\\\\#" 2 delete-char 1 "(\\?[^a-zA-Z]" 3 "(\\?" current-indentation "[ ]*[\n#]" "\n" beginning-of-line re-search-forward "[^ ]" t marker-position " " "\\([a-zA-Z0-9]+[^*+{?]\\)\\|\\$\\([a-zA-Z0-9_]+\\([[{]\\)?\\|[^\n )|]\\)\\|[$^]\\|\\(\\\\.\\|[^][()#|*+?\n]\\)\\([*+{?]\\??\\)?\\|\\(\\[\\)\\|\\((\\(\\?\\)?\\)\\|\\(|\\)" 0 -1 5 123 forward-sexp 6 "\\^?\\]" "\\]\\([*+{?]\\)?" error "[]-group not terminated" 7 8 cperl-beautify-regexp-piece 40 60 "[*+?]\\??" 63 "[#\n]" indent-for-comment 9 "[ \n]" " " "unknown code \"%s\" in a regexp" tmp c s embed b cperl-regexp-indent-step cperl-indent-level e] 10]) (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\204Tb\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 #[nil "\302 b\210`\303 \304\305!\210`S\306\223\210\307 \306#*\207" [e b cperl-make-regexp-x make-marker forward-sexp 1 nil cperl-beautify-regexp-piece] 4 (#$ . 162586) nil]) #@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?\2051g\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 (#$ . 162916) 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 "\304 \210`\305 \306\211\307\310!\210\n`S\306\223\210 b\210\311\312\n\313#\205K\310\224\203A\204-\314 \315\316!\210`\317\306w\210 `|\210j\210\202\320\321!\210\322 \210\202,\207" [c s e b cperl-regext-to-level-start make-marker nil forward-sexp 1 re-search-forward "\\(#\\)\\|\n" t current-indentation beginning-of-line 2 " " delete-char -1 just-one-space] 4 (#$ . 163352) 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 "\304\305\306\217\210`\307 \304\211\310\311!\210\n`S\304\223\210 Tb\210\312\313\n\314#\205/\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 (#$ . 163947) 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 #[nil "\302 \210`\303 \304\305!\210`S\306\223\210\307 \306#*\207" [e b cperl-regext-to-level-start make-marker forward-sexp 1 nil cperl-beautify-regexp-piece] 4 (#$ . 164505) nil]) #@49 Change `if (A) {B}' into `B if A;' if possible. (defalias 'cperl-invert-if-unless #[nil "\306\307!\204\n\310\311!\210\306\312!\203U`\313\211\211\211\211\211\211\211\211\314\224\314\225{/0123\310\315!\210`1\310\311!\210`2g\316=\203N1b\210\310\317!\210`/\310\311!\210`0g\320=\203G\3211!\210h\322=\203G\313\323\324\217\203t\325\326\"\202R/Sb\210\3210!\210h\327=\203\207\311u\210`0b\210\330\331 \332#\203\302\314\224\211\314\225{\3330\n\"\334 8\204\273\335 8\204\273\336 8\204\273\325\337 #\210\314\225b\210\202\2150Tb\210\340\313w\210` { b\210\306\341!\204\345\342\313w\210\f\343`/S{Q\f\344\232\203\355\3451Sb\210\3212!\210\306\346!\2041Sb\210`2Tb\210\340\313w\210`\n{0/|\21021|\2103b\210\f\347\261\210\350 \210\317v\210`3\347 \351\261\210\311u\210\352 \2103b\210\350 \210\353 \202R\325\354\"\202R\325\355\". \207\325\356!\207" [s0 pos45 p state s2 s1 looking-at "\\<" forward-sexp -1 "\\<\\(if\\|unless\\|while\\|until\\)\\>" nil 0 2 40 1 123 cperl-backward-to-noncomment 41 (byte-code "b\210\301\302!\210\301\303!\210\304\305!\207" [pos5 forward-sexp 1 -1 looking-at "\\"] 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" "\n" "" "1" "[ \n]*)" " " just-one-space ";" delete-horizontal-space cperl-indent-line "`%s' (EXPR) not with a {BLOCK}" "`%s' not with an (EXPR)" "Not at `if', `unless', `while', or `unless'" pos5 pos4 pos3 pos2 pos1] 13 (#$ . 164884) nil]) #@24 Run `perldoc' on WORD. (defalias 'cperl-perldoc #[(word) "\303\304!\210\305\306\"\205\305\307\310Q\311\312\313\"\"\211\203\314\202\315\316!*\207" [word is-func manual-program require man string-match "^[a-z]+$" "^" "\\>" documentation-property cperl-short-docs variable-documentation "perldoc -f" "perldoc" Man-getpage-in-background] 6 (#$ . 166516) (list (let* ((default-entry (cperl-word-at-point)) (input (read-string (format "perldoc entry%s: " (if (string= default-entry "") "" (format " (default %s)" default-entry)))))) (if (string= input "") (if (string= default-entry "") (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 (#$ . 167172) nil]) #@27 *File name for `pod2man'. (custom-declare-variable 'pod2man-program '"pod2man" '(#$ . -167335) :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!\212 q\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 (#$ . 167463) nil]) #@60 Builds the entire background manpage and cleaning command. (defalias 'cperl-pod2man-build-command #[nil "\306P \n\203*\n@\203*\n@@\n@A \307 \310\311\312\f\310#\260\nA*\202 *\207" [pod2man-program Man-filter-list flist command pargs pcom " %s 2>/dev/null" " | " " " mapconcat #[(phrase) ";\204 \301\302!\210\207" [phrase error "Malformed Man-filter-list"] 2]] 8 (#$ . 167989)]) (defalias 'cperl-lazy-install #[nil "\300\207" [nil] 1]) (byte-code "\303\304!\203=\301B\305\301\306\307#\210\310\301!\204\311\302B\305\302\306\312#\210\310\302!\204*\311\313\314M\210\315\316M\210\317\320M\210\321\322M\210\313 \210\311\207" [current-load-list cperl-help-shown cperl-lazy-installed fboundp run-with-idle-timer put variable-documentation "Non-nil means that the help was already shown now." boundp nil "Non-nil means that the lazy-help handlers are installed now." 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-variable-buffer-local 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 nil 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 nil 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\307\307\310\310\310\f\310 \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] 4]) (byte-code "\301B\302\301!\204\f\303\303\207" [current-load-list cperl-d-l boundp nil] 2) (defalias 'cperl-fontify-syntaxically #[(end) "\306` @\203\307\310\"`\204e\311\312!\203'\313\312!\210 ^ V\203A \211\203A\314 \310\306\310%\210\315=\203V\315\316\f \n @&\210,\306\207" [end cperl-syntax-state istate iend dbg start nil cperl-unwind-to-safe t boundp font-lock-hot-pass eval cperl-find-pods-heres message "Syntaxified %s..%s from %s to %s(%s), state %s-->%s" cperl-syntaxify-unwind cperl-syntax-done-to cperl-syntaxify-by-font-lock] 9]) (defalias 'cperl-fontify-update #[(end) "`\304\211\211 W\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-update-syntaxification #[(from to) "\205 \205\n\203\n W\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: 4.23" string-match ":\\s *\\([0-9.]+\\)" 1] 3) (#$ . 171321)) (provide 'cperl-mode)