Move Switch from ext/ to dist/
[perl.git] / emacs / cperl-mode.el
1 ;;; cperl-mode.el --- Perl code editing commands for Emacs
2
3 ;; Copyright (C) 1985, 86, 87, 91, 92, 93, 94, 95, 96, 97, 98, 99,
4 ;;               2000, 2003, 2005, 2006
5 ;;     Free Software Foundation, Inc.
6
7 ;; Author: Ilya Zakharevich and Bob Olson
8 ;; Maintainer: Ilya Zakharevich <ilyaz@cpan.org>
9 ;; Keywords: languages, Perl
10
11 ;; This file is part of GNU Emacs.
12
13 ;;; This code started from the following message of long time ago
14 ;;; (IZ), but Bob does not maintain this mode any more:
15
16 ;;; From: olson@mcs.anl.gov (Bob Olson)
17 ;;; Newsgroups: comp.lang.perl
18 ;;; Subject: cperl-mode: Another perl mode for Gnuemacs
19 ;;; Date: 14 Aug 91 15:20:01 GMT
20
21 ;; Copyright (C) Ilya Zakharevich and Bob Olson
22
23 ;; This file may be distributed
24 ;; either under the same terms as GNU Emacs, or under the same terms
25 ;; as Perl. You should have received a copy of Perl Artistic license
26 ;; along with the Perl distribution.
27
28 ;; GNU Emacs is free software; you can redistribute it and/or modify
29 ;; it under the terms of the GNU General Public License as published by
30 ;; the Free Software Foundation; either version 2, or (at your option)
31 ;; any later version.
32
33 ;; GNU Emacs is distributed in the hope that it will be useful,
34 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
35 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
36 ;; GNU General Public License for more details.
37
38 ;; You should have received a copy of the GNU General Public License
39 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
40 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
41 ;; Boston, MA 02111-1307, USA.
42
43 ;;; Corrections made by Ilya Zakharevich ilyaz@cpan.org
44 ;;; XEmacs changes by Peter Arius arius@informatik.uni-erlangen.de
45
46 ;;; Commentary:
47
48 ;; $Id: cperl-mode.el,v 5.23 2007/02/15 11:34:23 vera Exp vera $
49
50 ;;; If your Emacs does not default to `cperl-mode' on Perl files:
51 ;;; To use this mode put the following into
52 ;;; your .emacs file:
53
54 ;; (autoload 'perl-mode "cperl-mode" "alternate mode for editing Perl programs" t)
55
56 ;; You can either fine-tune the bells and whistles of this mode or
57 ;; bulk enable them by putting
58
59 ;; (setq cperl-hairy t)
60
61 ;; in your .emacs file.  (Emacs rulers do not consider it politically
62 ;; correct to make whistles enabled by default.)
63
64 ;; DO NOT FORGET to read micro-docs (available from `Perl' menu)   <<<<<<
65 ;; or as help on variables `cperl-tips', `cperl-problems',         <<<<<<
66 ;; `cperl-non-problems', `cperl-praise', `cperl-speed'.            <<<<<<
67
68 ;; Additional useful commands to put into your .emacs file (before
69 ;; RMS Emacs 20.3):
70
71 ;; (setq auto-mode-alist
72 ;;      (append '(("\\.\\([pP][Llm]\\|al\\)$" . perl-mode))  auto-mode-alist ))
73 ;; (setq interpreter-mode-alist (append interpreter-mode-alist
74 ;;                                      '(("miniperl" . perl-mode))))
75
76 ;; The mode information (on C-h m) provides some customization help.
77 ;; If you use font-lock feature of this mode, it is advisable to use
78 ;; either lazy-lock-mode or fast-lock-mode.  I prefer lazy-lock.
79
80 ;; Faces used now: three faces for first-class and second-class keywords
81 ;; and control flow words, one for each: comments, string, labels,
82 ;; functions definitions and packages, arrays, hashes, and variable
83 ;; definitions.  If you do not see all these faces, your font-lock does
84 ;; not define them, so you need to define them manually.
85 ;; Maybe you have an obsolete font-lock from 19.28 or earlier.  Upgrade.
86
87 ;; If you have a grayscale monitor, and do not have the variable
88 ;; font-lock-display-type bound to 'grayscale, insert
89
90 ;; (setq font-lock-display-type 'grayscale)
91
92 ;; into your .emacs file (this is relevant before RMS Emacs 20).
93
94 ;; This mode supports font-lock, imenu and mode-compile.  In the
95 ;; hairy version font-lock is on, but you should activate imenu
96 ;; yourself (note that mode-compile is not standard yet).  Well, you
97 ;; can use imenu from keyboard anyway (M-x imenu), but it is better
98 ;; to bind it like that:
99
100 ;; (define-key global-map [M-S-down-mouse-3] 'imenu)
101
102 ;;; Font lock bugs as of v4.32:
103
104 ;; The following kinds of Perl code erroneously start strings:
105 ;; \$`  \$'  \$"
106 ;; $opt::s  $opt_s  $opt{s}  (s => ...)  /\s+.../
107 ;; likewise with m, tr, y, q, qX instead of s
108
109 ;;; In fact the version of font-lock that this version supports can be
110 ;;; much newer than the version you actually have. This means that a
111 ;;; lot of faces can be set up, but are not visible on your screen
112 ;;; since the coloring rules for this faces are not defined.
113
114 ;;; Updates: ========================================
115
116 ;;; Made less hairy by default: parentheses not electric,
117 ;;; linefeed not magic. Bug with abbrev-mode corrected.
118
119 ;;;; After 1.4:
120 ;;;  Better indentation:
121 ;;;  subs inside braces should work now,
122 ;;;  Toplevel braces obey customization.
123 ;;;  indent-for-comment knows about bad cases, cperl-indent-for-comment
124 ;;;  moves cursor to a correct place.
125 ;;;  cperl-indent-exp written from the scratch! Slow... (quadratic!) :-(
126 ;;;        (50 secs on DB::DB (sub of 430 lines), 486/66)
127 ;;;  Minor documentation fixes.
128 ;;;  Imenu understands packages as prefixes (including nested).
129 ;;;  Hairy options can be switched off one-by-one by setting to null.
130 ;;;  Names of functions and variables changed to conform to `cperl-' style.
131
132 ;;;; After 1.5:
133 ;;;  Some bugs with indentation of labels (and embedded subs) corrected.
134 ;;;  `cperl-indent-region' done (slow :-()).
135 ;;;  `cperl-fill-paragraph' done.
136 ;;;  Better package support for `imenu'.
137 ;;;  Progress indicator for indentation (with `imenu' loaded).
138 ;;;  `Cperl-set' was busted, now setting the individual hairy option
139 ;;;     should be better.
140
141 ;;;; After 1.6:
142 ;;; `cperl-set-style' done.
143 ;;; `cperl-check-syntax' done.
144 ;;; Menu done.
145 ;;; New config variables `cperl-close-paren-offset' and `cperl-comment-column'.
146 ;;; Bugs with `cperl-auto-newline' corrected.
147 ;;; `cperl-electric-lbrace' can work with `cperl-auto-newline' in situation
148 ;;; like $hash{.
149
150 ;;;; 1.7 XEmacs (arius@informatik.uni-erlangen.de):
151 ;;; - use `next-command-event', if `next-command-events' does not exist
152 ;;; - use `find-face' as def. of `is-face'
153 ;;; - corrected def. of `x-color-defined-p'
154 ;;; - added const defs for font-lock-comment-face,
155 ;;;   font-lock-keyword-face and font-lock-function-name-face
156 ;;; - added def. of font-lock-variable-name-face
157 ;;; - added (require 'easymenu) inside an `eval-when-compile'
158 ;;; - replaced 4-argument `substitute-key-definition' with ordinary
159 ;;;   `define-key's
160 ;;; - replaced `mark-active' in menu definition by `cperl-use-region-p'.
161 ;;; Todo (at least):
162 ;;; - use emacs-vers.el (http://www.cs.utah.edu/~eeide/emacs/emacs-vers.el.gz)
163 ;;;   for portable code?
164 ;;; - should `cperl-mode' do a
165 ;;;     (if (featurep 'easymenu) (easy-menu-add cperl-menu))
166 ;;;   or should this be left to the user's `cperl-mode-hook'?
167
168 ;;; Some bugs introduced by the above fix corrected (IZ ;-).
169 ;;; Some bugs under XEmacs introduced by the correction corrected.
170
171 ;;; Some more can remain since there are two many different variants.
172 ;;; Please feedback!
173
174 ;;; We do not support fontification of arrays and hashes under
175 ;;; obsolete font-lock any more. Upgrade.
176
177 ;;;; after 1.8 Minor bug with parentheses.
178 ;;;; after 1.9 Improvements from Joe Marzot.
179 ;;;; after 1.10
180 ;;;  Does not need easymenu to compile under XEmacs.
181 ;;;  `vc-insert-headers' should work better.
182 ;;;  Should work with 19.29 and 19.12.
183 ;;;  Small improvements to fontification.
184 ;;;  Expansion of keywords does not depend on C-? being backspace.
185
186 ;;; after 1.10+
187 ;;; 19.29 and 19.12 supported.
188 ;;; `cperl-font-lock-enhanced' deprecated. Use font-lock-extra.el.
189 ;;; Support for font-lock-extra.el.
190
191 ;;;; After 1.11:
192 ;;; Tools submenu.
193 ;;; Support for perl5-info.
194 ;;; `imenu-go-find-at-position' in Tools requires imenu-go.el (see hints above)
195 ;;; Imenu entries do not work with stock imenu.el. Patch sent to maintainers.
196 ;;; Fontifies `require a if b;', __DATA__.
197 ;;; Arglist for auto-fill-mode was incorrect.
198
199 ;;;; After 1.12:
200 ;;; `cperl-lineup-step' and `cperl-lineup' added: lineup constructions
201 ;;; vertically.
202 ;;; `cperl-do-auto-fill' updated for 19.29 style.
203 ;;; `cperl-info-on-command' now has a default.
204 ;;; Workaround for broken C-h on XEmacs.
205 ;;; VC strings escaped.
206 ;;; C-h f now may prompt for function name instead of going on,
207 ;;; controlled by `cperl-info-on-command-no-prompt'.
208
209 ;;;; After 1.13:
210 ;;; Msb buffer list includes perl files
211 ;;; Indent-for-comment uses indent-to
212 ;;; Can write tag files using etags.
213
214 ;;;; After 1.14:
215 ;;; Recognizes (tries to ;-) {...} which are not blocks during indentation.
216 ;;; `cperl-close-paren-offset' affects ?\] too (and ?\} if not block)
217 ;;; Bug with auto-filling comments started with "##" corrected.
218
219 ;;;; Very slow now: on DB::DB 0.91, 486/66:
220
221 ;;;Function Name                             Call Count  Elapsed Time  Average Time
222 ;;;========================================  ==========  ============  ============
223 ;;;cperl-block-p                             469         3.7799999999  0.0080597014
224 ;;;cperl-get-state                           505         163.39000000  0.3235445544
225 ;;;cperl-comment-indent                      12          0.0299999999  0.0024999999
226 ;;;cperl-backward-to-noncomment              939         4.4599999999  0.0047497337
227 ;;;cperl-calculate-indent                    505         172.22000000  0.3410297029
228 ;;;cperl-indent-line                         505         172.88000000  0.3423366336
229 ;;;cperl-use-region-p                        40          0.0299999999  0.0007499999
230 ;;;cperl-indent-exp                          1           177.97000000  177.97000000
231 ;;;cperl-to-comment-or-eol                   1453        3.9800000000  0.0027391603
232 ;;;cperl-backward-to-start-of-continued-exp  9           0.0300000000  0.0033333333
233 ;;;cperl-indent-region                       1           177.94000000  177.94000000
234
235 ;;;; After 1.15:
236 ;;; Takes into account white space after opening parentheses during indent.
237 ;;; May highlight pods and here-documents: see `cperl-pod-here-scan',
238 ;;; `cperl-pod-here-fontify', `cperl-pod-face'. Does not use this info
239 ;;; for indentation so far.
240 ;;; Fontification updated to 19.30 style.
241 ;;; The change 19.29->30 did not add all the required functionality,
242 ;;;     but broke "font-lock-extra.el". Get "choose-color.el" from
243 ;;;       http://ilyaz.org/software/emacs
244
245 ;;;; After 1.16:
246 ;;;       else # comment
247 ;;;    recognized as a start of a block.
248 ;;;  Two different font-lock-levels provided.
249 ;;;  `cperl-pod-head-face' introduced. Used for highlighting.
250 ;;;  `imenu' marks pods, +Packages moved to the head.
251
252 ;;;; After 1.17:
253 ;;;  Scan for pods highlights here-docs too.
254 ;;;  Note that the tag of here-doc may be rehighlighted later by lazy-lock.
255 ;;;  Only one here-doc-tag per line is supported, and one in comment
256 ;;;  or a string may break fontification.
257 ;;;  POD headers were supposed to fill one line only.
258
259 ;;;; After 1.18:
260 ;;;  `font-lock-keywords' were set in 19.30 style _always_. Current scheme
261 ;;;    may  break under XEmacs.
262 ;;;  `cperl-calculate-indent' dis suppose that `parse-start' was defined.
263 ;;;  `fontified' tag is added to fontified text as well as `lazy-lock' (for
264 ;;;    compatibility with older lazy-lock.el) (older one overfontifies
265 ;;;    something nevertheless :-().
266 ;;;  Will not indent something inside pod and here-documents.
267 ;;;  Fontifies the package name after import/no/bootstrap.
268 ;;;  Added new entry to menu with meta-info about the mode.
269
270 ;;;; After 1.19:
271 ;;;  Prefontification works much better with 19.29. Should be checked
272 ;;;   with 19.30 as well.
273 ;;;  Some misprints in docs corrected.
274 ;;;  Now $a{-text} and -text => "blah" are fontified as strings too.
275 ;;;  Now the pod search is much stricter, so it can help you to find
276 ;;;    pod sections which are broken because of whitespace before =blah
277 ;;;    - just observe the fontification.
278
279 ;;;; After 1.20
280 ;;;  Anonymous subs are indented with respect to the level of
281 ;;;    indentation of `sub' now.
282 ;;;  {} is recognized as hash after `bless' and `return'.
283 ;;;  Anonymous subs are split by `cperl-linefeed' as well.
284 ;;;  Electric parens embrace a region if present.
285 ;;;  To make `cperl-auto-newline' useful,
286 ;;;    `cperl-auto-newline-after-colon' is introduced.
287 ;;;  `cperl-electric-parens' is now t or nul. The old meaning is moved to
288 ;;;  `cperl-electric-parens-string'.
289 ;;;  `cperl-toggle-auto-newline' introduced, put on C-c C-a.
290 ;;;  `cperl-toggle-abbrev' introduced, put on C-c C-k.
291 ;;;  `cperl-toggle-electric' introduced, put on C-c C-e.
292 ;;;  Beginning-of-defun-regexp was not anchored.
293
294 ;;;; After 1.21
295 ;;;  Auto-newline grants `cperl-extra-newline-before-brace' if "{" is typed
296 ;;;    after ")".
297 ;;;  {} is recognized as expression after `tr' and friends.
298
299 ;;;; After 1.22
300 ;;;  Entry Hierarchy added to imenu. Very primitive so far.
301 ;;;  One needs newer `imenu-go'.el. A patch to `imenu' is needed as well.
302 ;;;  Writes its own TAGS files.
303 ;;;  Class viewer based on TAGS files. Does not trace @ISA so far.
304 ;;;  19.31: Problems with scan for PODs corrected.
305 ;;;  First POD header correctly fontified.
306 ;;;  I needed (setq imenu-use-keymap-menu t) to get good imenu in 19.31.
307 ;;;  Apparently it makes a lot of hierarchy code obsolete...
308
309 ;;;; After 1.23
310 ;;;  Tags filler now scans *.xs as well.
311 ;;;  The info from *.xs scan is used by the hierarchy viewer.
312 ;;;  Hierarchy viewer documented.
313 ;;;  Bug in 19.31 imenu documented.
314
315 ;;;; After 1.24
316 ;;;  New location for info-files mentioned,
317 ;;;  Electric-; should work better.
318 ;;;  Minor bugs with POD marking.
319
320 ;;;; After 1.25 (probably not...)
321 ;;;  `cperl-info-page' introduced.
322 ;;;  To make `uncomment-region' working, `comment-region' would
323 ;;;  not insert extra space.
324 ;;;  Here documents delimiters better recognized
325 ;;;  (empty one, and non-alphanums in quotes handled). May be wrong with 1<<14?
326 ;;;  `cperl-db' added, used in menu.
327 ;;;  imenu scan removes text-properties, for better debugging
328 ;;;    - but the bug is in 19.31 imenu.
329 ;;;  formats highlighted by font-lock and prescan, embedded comments
330 ;;;  are not treated.
331 ;;;  POD/friends scan merged in one pass.
332 ;;;  Syntax class is not used for analyzing the code, only char-syntax
333 ;;;  may be checked against _ or'ed with w.
334 ;;;  Syntax class of `:' changed to be _.
335 ;;;  `cperl-find-bad-style' added.
336
337 ;;;; After 1.25
338 ;;;  When search for here-documents, we ignore commented << in simplest cases.
339 ;;;  `cperl-get-help' added, available on C-h v and from menu.
340 ;;;  Auto-help added. Default with `cperl-hairy', switchable on/off
341 ;;;   with startup variable `cperl-lazy-help-time' and from
342 ;;;   menu. Requires `run-with-idle-timer'.
343 ;;;  Highlighting of @abc{@efg} was wrong - interchanged two regexps.
344
345 ;;;; After 1.27
346 ;;;  Indentation: At toplevel after a label - fixed.
347 ;;;  1.27 was put to archives in binary mode ===> DOSish :-(
348
349 ;;;; After 1.28
350 ;;;  Thanks to Martin Buchholz <mrb@Eng.Sun.COM>: misprints in
351 ;;;  comments and docstrings corrected, XEmacs support cleaned up.
352 ;;;  The closing parenths would enclose the region into matching
353 ;;;  parens under the same conditions as the opening ones.
354 ;;;  Minor updates to `cperl-short-docs'.
355 ;;;  Will not consider <<= as start of here-doc.
356
357 ;;;; After 1.29
358 ;;;  Added an extra advice to look into Micro-docs. ;-).
359 ;;;  Enclosing of region when you press a closing parenth is regulated by
360 ;;;  `cperl-electric-parens-string'.
361 ;;;  Minor updates to `cperl-short-docs'.
362 ;;;  `initialize-new-tags-table' called only if present (Does this help
363 ;;;     with generation of tags under XEmacs?).
364 ;;;  When creating/updating tag files, new info is written at the old place,
365 ;;;     or at the end (is this a wanted behaviour? I need this in perl build directory).
366
367 ;;;; After 1.30
368 ;;;  All the keywords from keywords.pl included (maybe with dummy explanation).
369 ;;;  No auto-help inside strings, comment, here-docs, formats, and pods.
370 ;;;  Shrinkwrapping of info, regulated by `cperl-max-help-size',
371 ;;;  `cperl-shrink-wrap-info-frame'.
372 ;;;  Info on variables as well.
373 ;;;  Recognision of HERE-DOCS improved yet more.
374 ;;;  Autonewline works on `}' without warnings.
375 ;;;  Autohelp works again on $_[0].
376
377 ;;;; After 1.31
378 ;;;  perl-descr.el found its author - hi, Johan!
379 ;;;  Some support for correct indent after here-docs and friends (may
380 ;;;  be superseeded by eminent change to Emacs internals).
381 ;;;  Should work with older Emaxen as well ( `-style stuff removed).
382
383 ;;;; After 1.32
384
385 ;;;  Started to add support for `syntax-table' property (should work
386 ;;;  with patched Emaxen), controlled by
387 ;;;  `cperl-use-syntax-table-text-property'. Currently recognized:
388 ;;;    All quote-like operators: m, s, y, tr, qq, qw, qx, q,
389 ;;;    // in most frequent context:
390 ;;;          after block or
391 ;;;                    ~ { ( = | & + - * ! , ;
392 ;;;          or
393 ;;;                    while if unless until and or not xor split grep map
394 ;;;    Here-documents, formats, PODs,
395 ;;;    ${...}
396 ;;;    'abc$'
397 ;;;    sub a ($); sub a ($) {}
398 ;;;  (provide 'cperl-mode) was missing!
399 ;;;  `cperl-after-expr-p' is now much smarter after `}'.
400 ;;;  `cperl-praise' added to mini-docs.
401 ;;;  Utilities try to support subs-with-prototypes.
402
403 ;;;; After 1.32.1
404 ;;;  `cperl-after-expr-p' is now much smarter after "() {}" and "word {}":
405 ;;;     if word is "else, map, grep".
406 ;;;  Updated for new values of syntax-table constants.
407 ;;;  Uses `help-char' (at last!) (disabled, does not work?!)
408 ;;;  A couple of regexps where missing _ in character classes.
409 ;;;  -s could be considered as start of regexp, 1../blah/ was not,
410 ;;;  as was not /blah/ at start of file.
411
412 ;;;; After 1.32.2
413 ;;;  "\C-hv" was wrongly "\C-hf"
414 ;;;  C-hv was not working on `[index()]' because of [] in skip-chars-*.
415 ;;;  `__PACKAGE__' supported.
416 ;;;  Thanks for Greg Badros: `cperl-lazy-unstall' is more complete,
417 ;;;  `cperl-get-help' is made compatible with `query-replace'.
418
419 ;;;; As of Apr 15, development version of 19.34 supports
420 ;;;; `syntax-table' text properties. Try setting
421 ;;;; `cperl-use-syntax-table-text-property'.
422
423 ;;;; After 1.32.3
424 ;;;  We scan for s{}[] as well (in simplest situations).
425 ;;;  We scan for $blah'foo as well.
426 ;;;  The default is to use `syntax-table' text property if Emacs is good enough.
427 ;;;  `cperl-lineup' is put on C-M-| (=C-M-S-\\).
428 ;;;  Start of `cperl-beautify-regexp'.
429
430 ;;;; After 1.32.4
431 ;;; `cperl-tags-hier-init' did not work in text-mode.
432 ;;; `cperl-noscan-files-regexp' had a misprint.
433 ;;; Generation of Class Hierarchy was broken due to a bug in `x-popup-menu'
434 ;;;  in 19.34.
435
436 ;;;; After 1.33:
437 ;;; my,local highlight vars after {} too.
438 ;;; TAGS could not be created before imenu was loaded.
439 ;;; `cperl-indent-left-aligned-comments' created.
440 ;;; Logic of `cperl-indent-exp' changed a little bit, should be more
441 ;;;  robust w.r.t. multiline strings.
442 ;;; Recognition of blah'foo takes into account strings.
443 ;;; Added '.al' to the list of Perl extensions.
444 ;;; Class hierarchy is "mostly" sorted (need to rethink algorthm
445 ;;;  of pruning one-root-branch subtrees to get yet better sorting.)
446 ;;; Regeneration of TAGS was busted.
447 ;;; Can use `syntax-table' property when generating TAGS
448 ;;;  (governed by  `cperl-use-syntax-table-text-property-for-tags').
449
450 ;;;; After 1.35:
451 ;;; Can process several =pod/=cut sections one after another.
452 ;;; Knows of `extproc' when under `emx', indents with `__END__' and `__DATA__'.
453 ;;; `cperl-under-as-char' implemented (XEmacs people like broken behaviour).
454 ;;; Beautifier for regexps fixed.
455 ;;; `cperl-beautify-level', `cperl-contract-level' coded
456 ;;;
457 ;;;; Emacs's 20.2 problems:
458 ;;; `imenu.el' has bugs, `imenu-add-to-menubar' does not work.
459 ;;; Couple of others problems with 20.2 were reported, my ability to check/fix
460 ;;; them is very reduced now.
461
462 ;;;; After 1.36:
463 ;;;  'C-M-|' in XEmacs fixed
464
465 ;;;; After 1.37:
466 ;;;  &&s was not recognized as start of regular expression;
467 ;;;  Will "preprocess" the contents of //e part of s///e too;
468 ;;;  What to do with s# blah # foo #e ?
469 ;;;  Should handle s;blah;foo;; better.
470 ;;;  Now the only known problems with regular expression recognition:
471 ;;;;;;;  s<foo>/bar/    - different delimiters (end ignored)
472 ;;;;;;;  s/foo/\\bar/   - backslash at start of subst (made into one chunk)
473 ;;;;;;;  s/foo//        - empty subst (made into one chunk + '/')
474 ;;;;;;;  s/foo/(bar)/   - start-group at start of subst (internal group will not match backwards)
475
476 ;;;; After 1.38:
477 ;;;  We highlight closing / of s/blah/foo/e;
478 ;;;  This handles s# blah # foo #e too;
479 ;;;  s//blah/, s///, s/blah// works again, and s#blah## too, the algorithm
480 ;;;   is much simpler now;
481 ;;;  Next round of changes: s\\\ works, s<blah>/foo/,
482 ;;;   comments between the first and the second part allowed
483 ;;;  Another problem discovered:
484 ;;;;;;;  s[foo] <blah>e - e part delimited by different <> (will not match)
485 ;;;  `cperl-find-pods-heres' somehow maybe called when string-face is undefined
486 ;;;   - put a stupid workaround for 20.1
487
488 ;;;; After 1.39:
489 ;;;  Could indent here-docs for comments;
490 ;;;  These problems fixed:
491 ;;;;;;;  s/foo/\\bar/   - backslash at start of subst (made into two chunk)
492 ;;;;;;;  s[foo] <blah>e - "e" part delimited by "different" <> (will match)
493 ;;;  Matching brackets honor prefices, may expand abbreviations;
494 ;;;  When expanding abbrevs, will remove last char only after
495 ;;;    self-inserted whitespace;
496 ;;;  More convenient "Refress hard constructs" in menu;
497 ;;;  `cperl-add-tags-recurse', `cperl-add-tags-recurse-noxs'
498 ;;;    added (for -batch mode);
499 ;;;  Better handling of errors when scanning for Perl constructs;
500 ;;;;;;;  Possible "problem" with class hierarchy in Perl distribution
501 ;;;;;;;    directory: ./ext duplicates ./lib;
502 ;;;  Write relative paths for generated TAGS;
503
504 ;;;; After 1.40:
505 ;;;  s  /// may be separated by "\n\f" too;
506 ;;;  `s  #blah' recognized as a comment;
507 ;;;  Would highlight s/abc//s wrong;
508 ;;;  Debugging code in `cperl-electric-keywords' was leaking a message;
509
510 ;;;; After 1.41:
511 ;;;  RMS changes for 20.3 merged
512
513 ;;;; 2.0.1.0: RMS mode (has 3 misprints)
514
515 ;;;; After 2.0:
516 ;;;  RMS whitespace changes for 20.3 merged
517
518 ;;;; After 2.1:
519 ;;;  History updated
520
521 ;;;; After 2.2:
522 ;;;  Merge `c-style-alist' since `c-mode' is no more.  (Somebody who
523 ;;;    uses the styles should check that they work OK!)
524 ;;;  All the variable warnings go away, some undef functions too.
525
526 ;;;; After 2.3:
527 ;;;  Added `cperl-perldoc' (thanks to Anthony Foiani <afoiani@uswest.com>)
528 ;;;  Added `cperl-pod-to-manpage' (thanks to Nick Roberts <Nick.Roberts@src.bae.co.uk>)
529 ;;;  All the function warnings go away.
530
531 ;;;; After 2.4:
532 ;;;  `Perl doc', `Regexp' submenus created (latter to allow short displays).
533 ;;;  `cperl-clobber-lisp-bindings' added.
534 ;;;  $a->y() is not y///.
535 ;;;  `cperl-after-block-p' was missing a `save-excursion' => wrong results.
536 ;;;  `cperl-val' was defined too late.
537 ;;;  `cperl-init-faces' was failing.
538 ;;;  Init faces when loading `ps-print'.
539
540 ;;;; After 2.4:
541 ;;;  `cperl-toggle-autohelp' implemented.
542 ;;;  `while SPACE LESS' was buggy.
543 ;;;  `-text' in `[-text => 1]' was not highlighted.
544 ;;;  `cperl-after-block-p' was FALSE after `sub f {}'.
545
546 ;;;; After 2.5:
547 ;;;  `foreachmy', `formy' expanded too.
548 ;;;  Expand `=pod-directive'.
549 ;;;  `cperl-linefeed' behaves reasonable in POD-directive lines.
550 ;;;  `cperl-electric-keyword' prints a message, governed by
551 ;;;    `cperl-message-electric-keyword'.
552
553 ;;;; After 2.6:
554 ;;;  Typing `}' was not checking for being block or not.
555 ;;;  Beautifying levels in RE: Did not know about lookbehind;
556 ;;;                            finding *which* level was not intuitive;
557 ;;;                            `cperl-beautify-levels' added.
558 ;;;  Allow here-docs contain `=head1' and friends (at least for keywords).
559
560 ;;;; After 2.7:
561 ;;;  Fix for broken `font-lock-unfontify-region-function'.  Should
562 ;;;    preserve `syntax-table' properties even with `lazy-lock'.
563
564 ;;;; After 2.8:
565 ;;;  Some more compile time warnings crept in.
566 ;;;  `cperl-indent-region-fix-else' implemented.
567 ;;;  `cperl-fix-line-spacing' implemented.
568 ;;;  `cperl-invert-if-unless' implemented (C-c C-t and in Menu).
569 ;;;  Upgraded hints to mention 20.2's goods/bads.
570 ;;;  Started to use `cperl-extra-newline-before-brace-multiline',
571 ;;;    `cperl-break-one-line-blocks-when-indent',
572 ;;;    `cperl-fix-hanging-brace-when-indent', `cperl-merge-trailing-else'.
573
574 ;;;; After 2.9:
575 ;;;  Workaround for another `font-lock's `syntax-table' text-property bug.
576 ;;;  `zerop' could be applied to nil.
577 ;;;  At last, may work with `font-lock' without setting `cperl-font-lock'.
578 ;;;    (We expect that starting from 19.33, `font-lock' supports keywords
579 ;;;     being a function - what is a correct version?)
580 ;;;  Rename `cperl-indent-region-fix-else' to
581 ;;;    `cperl-indent-region-fix-constructs'.
582 ;;;  `cperl-fix-line-spacing' could be triggered inside strings, would not
583 ;;;     know what to do with BLOCKs of map/printf/etc.
584 ;;;  `cperl-merge-trailing-else' and `cperl-fix-line-spacing' handle
585 ;;;     `continue' too.
586 ;;;  Indentation after {BLOCK} knows about map/printf/etc.
587 ;;;  Finally: treat after-comma lines as continuation lines.
588
589 ;;;; After 2.10:
590 ;;;  `continue' made electric.
591 ;;;  Electric `do' inserts `do/while'.
592 ;;;  Some extra compile-time warnings crept in.
593 ;;;  `font-lock' of 19.33 could not handle font-lock-keywords being a function
594 ;;;      returning a symbol.
595
596 ;;;; After 2.11:
597 ;;;  Changes to make syntaxification to be autoredone via `font-lock'.
598 ;;;    Switched on by `cperl-syntaxify-by-font-lock', off by default so far.
599
600 ;;;; After 2.12:
601 ;;;  Remove some commented out chunks.
602 ;;;  Styles are slightly updated (a lot of work is needed, especially
603 ;;;    with new `cperl-fix-line-spacing').
604
605 ;;;; After 2.13:
606 ;;;  Old value of style is memorized when choosing a new style, may be
607 ;;;    restored from the same menu.
608 ;;;  Mode-documentation added to micro-docs.
609 ;;;  `cperl-praise' updated.
610 ;;;  `cperl-toggle-construct-fix' added on C-c C-w and menu.
611 ;;;  `auto-fill-mode' added on C-c C-f and menu.
612 ;;;  `PerlStyle' style added.
613 ;;;  Message for termination of scan corrected.
614
615 ;;;; After 2.14:
616
617 ;;;  Did not work with -q
618
619 ;;;; After 2.15:
620
621 ;;;  `cperl-speed' hints added.
622 ;;;  Minor style fixes.
623
624 ;;;; After 2.15:
625 ;;;  Make backspace electric after expansion of `else/continue' too.
626
627 ;;;; After 2.16:
628 ;;;  Starting to merge changes to RMS emacs version.
629
630 ;;;; After 2.17:
631 ;;;  Merged custom stuff and darn `font-lock-constant-face'.
632
633 ;;;; After 2.18:
634 ;;;  Bumped the version to 3.1
635
636 ;;;; After 3.1:
637 ;;;  Fixed customization to honor cperl-hairy.
638 ;;;  Created customization groups.  Sent to RMS to include into 2.3.
639
640 ;;;; After 3.2:
641 ;;;  Interaction of `font-lock-hot-pass' and `cperl-syntaxify-by-font-lock'.
642 ;;;  (`cperl-after-block-and-statement-beg'):
643 ;;;  (`cperl-after-block-p'):
644 ;;;  (`cperl-after-expr-p'):    It is BLOCK if we reach lim when backup sexp.
645 ;;;  (`cperl-indent-region'):   Make a marker for END - text added/removed.
646 ;;;  (`cperl-style-alist', `cperl-styles-entries')
647 ;;;             Include `cperl-merge-trailing-else' where the value is clear.
648
649 ;;;; After 3.3:
650 ;;;  (`cperl-tips'):
651 ;;;  (`cperl-problems'):        Improvements to docs.
652
653 ;;;; After 3.4:
654 ;;;  (`cperl-mode'):            Make lazy syntaxification possible.
655 ;;;  (`cperl-find-pods-heres'): Safe a position in buffer where it is safe to
656 ;;;                             restart syntaxification.
657 ;;;  (`cperl-syntaxify-by-font-lock'): Set to t, should be safe now.
658
659 ;;;; After 3.5:
660 ;;;  (`cperl-syntaxify-by-font-lock'): Better default, customizes to
661 ;;;                             `message' too.
662
663 ;;;; After 3.6:
664 ;;;  (`cperl-find-pods-heres'): changed so that -d ?foo? is a RE.
665 ;;;  (`cperl-array-face'): changed name from `font-lock-emphasized-face'.
666 ;;;  (`cperl-hash-face'): changed name from  `font-lock-other-emphasized-face'.
667 ;;;  Use `defface' to define these two extra faces.
668
669 ;;;; After 3.7:
670 ;;;  Can use linear algorithm for indentation if Emacs supports it:
671 ;;;  indenting DB::DB (800+ lines) improved from 69 sec to 11 sec
672 ;;;  (73 vs 15 with imenu).
673 ;;;  (`cperl-emacs-can-parse'): New state.
674 ;;;  (`cperl-indent-line'):     Corrected to use global state.
675 ;;;  (`cperl-calculate-indent'):        Likewise.
676 ;;;  (`cperl-fix-line-spacing'):        Likewise (not used yet).
677
678 ;;;; After 3.8:
679 ;;;  (`cperl-choose-color'):    Converted to a function (to be compilable in text-mode).
680
681 ;;;; After 3.9:
682 ;;;  (`cperl-dark-background '):        Disable without window-system.
683
684 ;;;; After 3.10:
685 ;;;  Do `defface' only if window-system.
686
687 ;;;; After 3.11:
688 ;;;  (`cperl-fix-line-spacing'):        sped up to bail out early.
689 ;;;  (`cperl-indent-region'):   Disable hooks during the call (how to call them later?).
690
691 ;;;  Now indents 820-line-long function in 6.5 sec (including syntaxification) the first time
692 ;;;  (when buffer has few properties), 7.1 sec the second time.
693
694 ;;;Function Name                              Call Count  Elapsed Time  Average Time
695 ;;;=========================================  ==========  ============  ============
696 ;;;cperl-indent-exp                           1           10.039999999  10.039999999
697 ;;;cperl-indent-region                        1           10.0          10.0
698 ;;;cperl-indent-line                          821         6.2100000000  0.0075639464
699 ;;;cperl-calculate-indent                     821         5.0199999999  0.0061144945
700 ;;;cperl-backward-to-noncomment               2856        2.0500000000  0.0007177871
701 ;;;cperl-fontify-syntaxically                 2           1.78          0.8900000000
702 ;;;cperl-find-pods-heres                      2           1.78          0.8900000000
703 ;;;cperl-update-syntaxification               1           1.78          1.78
704 ;;;cperl-fix-line-spacing                     769         1.4800000000  0.0019245773
705 ;;;cperl-after-block-and-statement-beg        163         1.4100000000  0.0086503067
706 ;;;cperl-block-p                              775         1.1800000000  0.0015225806
707 ;;;cperl-to-comment-or-eol                    3652        1.1200000000  0.0003066812
708 ;;;cperl-after-block-p                        165         1.0500000000  0.0063636363
709 ;;;cperl-commentify                           141         0.22          0.0015602836
710 ;;;cperl-get-state                            813         0.16          0.0001968019
711 ;;;cperl-backward-to-start-of-continued-exp   26          0.12          0.0046153846
712 ;;;cperl-delay-update-hook                    2107        0.0899999999  4.271...e-05
713 ;;;cperl-protect-defun-start                  141         0.0700000000  0.0004964539
714 ;;;cperl-after-label                          407         0.0599999999  0.0001474201
715 ;;;cperl-forward-re                           139         0.0299999999  0.0002158273
716 ;;;cperl-comment-indent                       26          0.0299999999  0.0011538461
717 ;;;cperl-use-region-p                         8           0.0           0.0
718 ;;;cperl-lazy-hook                            15          0.0           0.0
719 ;;;cperl-after-expr-p                         8           0.0           0.0
720 ;;;cperl-font-lock-unfontify-region-function  1           0.0           0.0
721
722 ;;;Function Name                              Call Count  Elapsed Time  Average Time
723 ;;;=========================================  ==========  ============  ============
724 ;;;cperl-fix-line-spacing                     769         1.4500000000  0.0018855656
725 ;;;cperl-indent-line                          13          0.3100000000  0.0238461538
726 ;;;cperl-after-block-and-statement-beg        69          0.2700000000  0.0039130434
727 ;;;cperl-after-block-p                        69          0.2099999999  0.0030434782
728 ;;;cperl-calculate-indent                     13          0.1000000000  0.0076923076
729 ;;;cperl-backward-to-noncomment               177         0.0700000000  0.0003954802
730 ;;;cperl-get-state                            13          0.0           0.0
731 ;;;cperl-to-comment-or-eol                    179         0.0           0.0
732 ;;;cperl-get-help-defer                       1           0.0           0.0
733 ;;;cperl-lazy-hook                            11          0.0           0.0
734 ;;;cperl-after-expr-p                         2           0.0           0.0
735 ;;;cperl-block-p                              13          0.0           0.0
736 ;;;cperl-after-label                          5           0.0           0.0
737
738 ;;;; After 3.12:
739 ;;;  (`cperl-find-pods-heres'): do not warn on `=cut' if doing a chunk only.
740
741 ;;;; After 3.13:
742 ;;;  (`cperl-mode'): load pseudo-faces on `cperl-find-pods-heres' (for 19.30).
743 ;;;  (`x-color-defined-p'): was not compiling on XEmacs
744 ;;;  (`cperl-find-pods-heres'): 1 << 6 was OK, but 1<<6 was considered as HERE
745 ;;;                             <file/glob> made into a string.
746
747 ;;;; After 3.14:
748 ;;;  (`cperl-find-pods-heres'): Postpone addition of faces after syntactic step
749 ;;;                             Recognition of <FH> was wrong.
750 ;;;  (`cperl-clobber-lisp-bindings'): if set, C-c variants are the old ones
751 ;;;  (`cperl-unwind-to-safe'):  New function.
752 ;;;  (`cperl-fontify-syntaxically'): Use `cperl-unwind-to-safe' to start at reasonable position.
753
754 ;;;; After 3.15:
755 ;;;  (`cperl-forward-re'):      Highlight the trailing / in s/foo// as string.
756 ;;;                     Highlight the starting // in s//foo/ as function-name.
757
758 ;;;; After 3.16:
759 ;;;  (`cperl-find-pods-heres'): Highlight `gem' in s///gem as a keyword.
760
761 ;;;; After 4.0:
762 ;;;  (`cperl-find-pods-heres'): `qr' added
763 ;;;  (`cperl-electric-keyword'):        Likewise
764 ;;;  (`cperl-electric-else'):           Likewise
765 ;;;  (`cperl-to-comment-or-eol'):       Likewise
766 ;;;  (`cperl-make-regexp-x'):   Likewise
767 ;;;  (`cperl-init-faces'):      Likewise, and `lock' (as overridable?).
768 ;;;  (`cperl-find-pods-heres'): Knows that split// is null-RE.
769 ;;;                             Highlights separators in 3-parts expressions
770 ;;;                             as labels.
771
772 ;;;; After 4.1:
773 ;;;  (`cperl-find-pods-heres'): <> was considered as a glob
774 ;;;  (`cperl-syntaxify-unwind'): New configuration variable
775 ;;;  (`cperl-fontify-m-as-s'):  New configuration variable
776
777 ;;;; After 4.2:
778 ;;;  (`cperl-find-pods-heres'): of the last line being `=head1' fixed.
779
780 ;;;  Handling of a long construct is still buggy if only the part of
781 ;;;  construct touches the updated region (we unwind to the start of
782 ;;;  long construct, but the end may have residual properties).
783
784 ;;;  (`cperl-unwind-to-safe'):  would not go to beginning of buffer.
785 ;;;  (`cperl-electric-pod'):    check for after-expr was performed
786 ;;;                             inside of POD too.
787
788 ;;;; After 4.3:
789 ;;;  (`cperl-backward-to-noncomment'):  better treatment of PODs and HEREs.
790
791 ;;;  Indent-line works good, but indent-region does not - at toplevel...
792 ;;;  (`cperl-unwind-to-safe'):  Signature changed.
793 ;;;  (`x-color-defined-p'):     was defmacro'ed with a tick.  Remove another def.
794 ;;;  (`cperl-clobber-mode-lists'): New configuration variable.
795 ;;;  (`cperl-array-face'): One of definitions was garbled.
796
797 ;;;; After 4.4:
798 ;;;  (`cperl-not-bad-style-regexp'):    Updated.
799 ;;;  (`cperl-make-regexp-x'):   Misprint in a message.
800 ;;;  (`cperl-find-pods-heres'): $a-1 ? foo : bar; was a regexp.
801 ;;;                             `<< (' was considered a start of POD.
802 ;;;  Init:                      `cperl-is-face' was busted.
803 ;;;  (`cperl-make-face'):       New macros.
804 ;;;  (`cperl-force-face'):      New macros.
805 ;;;  (`cperl-init-faces'):      Corrected to use new macros;
806 ;;;                             `if' for copying `reference-face' to
807 ;;;                             `constant-face' was backward.
808 ;;;  (`font-lock-other-type-face'): Done via `defface' too.
809
810 ;;;; After 4.5:
811 ;;;  (`cperl-init-faces-weak'): use `cperl-force-face'.
812 ;;;  (`cperl-after-block-p'):   After END/BEGIN we are a block.
813 ;;;  (`cperl-mode'):            `font-lock-unfontify-region-function'
814 ;;;                             was set to a wrong function.
815 ;;;  (`cperl-comment-indent'):  Commenting __END__ was not working.
816 ;;;  (`cperl-indent-for-comment'):      Likewise.
817 ;;;                             (Indenting is still misbehaving at toplevel.)
818
819 ;;;; After 4.5:
820 ;;;  (`cperl-unwind-to-safe'):  Signature changed, unwinds end too.
821 ;;;  (`cperl-find-pods-heres'): mark qq[]-etc sections as syntax-type=string
822 ;;;  (`cperl-fontify-syntaxically'): Unwinds start and end to go out of
823 ;;;                                  long strings (not very successful).
824
825 ;;;   >>>>  CPerl should be usable in write mode too now <<<<
826
827 ;;;  (`cperl-syntaxify-by-font-lock'): Better default - off in text-mode.
828 ;;;  (`cperl-tips'):            Updated docs.
829 ;;;  (`cperl-problems'):        Updated docs.
830
831 ;;;; After 4.6:
832 ;;;  (`cperl-calculate-indent'):        Did not consider `,' as continuation mark for statements.
833 ;;;  (`cperl-write-tags'):      Correct for XEmacs's `visit-tags-table-buffer'.
834
835 ;;;; After 4.7:
836 ;;;  (`cperl-calculate-indent'): Avoid parse-data optimization at toplevel.
837 ;;;                              Should indent correctly at toplevel too.
838 ;;;  (`cperl-tags-hier-init'):  Gross hack to pretend we work (are we?).
839 ;;;  (`cperl-find-pods-heres'): Was not processing sub protos after a comment ine.
840 ;;;                             Was treating $a++ <= 5 as a glob.
841
842 ;;;; After 4.8:
843 ;;;  (toplevel):                require custom unprotected => failure on 19.28.
844 ;;;  (`cperl-xemacs-p')         defined when compile too
845 ;;;  (`cperl-tags-hier-init'):  Another try to work around XEmacs problems
846 ;;;                             Better progress messages.
847 ;;;  (`cperl-find-tags'):       Was writing line/pos in a wrong order,
848 ;;;                             pos off by 1 and not at beg-of-line.
849 ;;;  (`cperl-etags-snarf-tag'): New macro
850 ;;;  (`cperl-etags-goto-tag-location'): New macro
851 ;;;  (`cperl-write-tags'):      When removing old TAGS info was not
852 ;;;                             relativizing filename
853
854 ;;;; After 4.9:
855 ;;;  (`cperl-version'):         New variable.  New menu entry
856
857 ;;;; After 4.10:
858 ;;;  (`cperl-tips'):            Updated.
859 ;;;  (`cperl-non-problems'):    Updated.
860 ;;;  random:                    References to future 20.3 removed.
861
862 ;;;; After 4.11:
863 ;;;  (`perl-font-lock-keywords'): Would not highlight `sub foo($$);'.
864 ;;;  Docstrings:                Menu was described as `CPerl' instead of `Perl'
865
866 ;;;; After 4.12:
867 ;;;  (`cperl-toggle-construct-fix'): Was toggling to t instead of 1.
868 ;;;  (`cperl-ps-print-init'):   Associate `cperl-array-face', `cperl-hash-face'
869 ;;;                             remove `font-lock-emphasized-face'.
870 ;;;                             remove `font-lock-other-emphasized-face'.
871 ;;;                             remove `font-lock-reference-face'.
872 ;;;                             remove `font-lock-keyword-face'.
873 ;;;                             Use `eval-after-load'.
874 ;;;  (`cperl-init-faces'):      remove init `font-lock-other-emphasized-face'.
875 ;;;                             remove init `font-lock-emphasized-face'.
876 ;;;                             remove init `font-lock-keyword-face'.
877 ;;;  (`cperl-tips-faces'):      New variable and an entry into Mini-docs.
878 ;;;  (`cperl-indent-region'):   Do not indent whitespace lines
879 ;;;  (`cperl-indent-exp'):      Was not processing else-blocks.
880 ;;;  (`cperl-calculate-indent'): Remove another parse-data optimization
881 ;;;                              at toplevel: would indent correctly.
882 ;;;  (`cperl-get-state'):       NOP line removed.
883
884 ;;;; After 4.13:
885 ;;;  (`cperl-ps-print-init'):   Remove not-CPerl-related faces.
886 ;;;  (`cperl-ps-print'):        New function and menu entry.
887 ;;;  (`cperl-ps-print-face-properties'):        New configuration variable.
888 ;;;  (`cperl-invalid-face'):    New configuration variable.
889 ;;;  (`cperl-nonoverridable-face'):     New face.  Renamed from
890 ;;;                                     `font-lock-other-type-face'.
891 ;;;  (`perl-font-lock-keywords'):       Highlight trailing whitespace
892 ;;;  (`cperl-contract-levels'): Documentation corrected.
893 ;;;  (`cperl-contract-level'):  Likewise.
894
895 ;;;; After 4.14:
896 ;;;  (`cperl-ps-print'): `ps-print-face-extension-alist' was not in old Emaxen,
897 ;;;                             same with `ps-extend-face-list'
898 ;;;  (`cperl-ps-extend-face-list'):     New macro.
899
900 ;;;; After 4.15:
901 ;;;  (`cperl-init-faces'):      Interpolate `cperl-invalid-face'.
902 ;;;  (`cperl-forward-re'):      Emit a meaningful error instead of a cryptic
903 ;;;                             one for uncomplete REx near end-of-buffer.
904 ;;;  (`cperl-find-pods-heres'): Tolerate unfinished REx at end-of-buffer.
905
906 ;;;; After 4.16:
907 ;;;  (`cperl-find-pods-heres'): `unwind-protect' was left commented.
908
909 ;;;; After 4.17:
910 ;;;  (`cperl-invalid-face'):    Change to ''underline.
911
912 ;;;; After 4.18:
913 ;;;  (`cperl-find-pods-heres'): / and ? after : start a REx.
914 ;;;  (`cperl-after-expr-p'):    Skip labels when checking
915 ;;;  (`cperl-calculate-indent'): Correct for labels when calculating
916 ;;;                                     indentation of continuations.
917 ;;;                             Docstring updated.
918
919 ;;;; After 4.19:
920 ;;;  Minor (mostly spelling) corrections from 20.3.3 merged.
921
922 ;;;; After 4.20:
923 ;;;  (`cperl-tips'):            Another workaround added.  Sent to RMS for 20.4.
924
925 ;;;; After 4.21:
926 ;;;  (`cperl-praise'):          Mention linear-time indent.
927 ;;;  (`cperl-find-pods-heres'): @if ? a : b was considered a REx.
928
929 ;;;; After 4.22:
930 ;;;  (`cperl-after-expr-p'):    Make true after __END__.
931 ;;;  (`cperl-electric-pod'):    "SYNOPSIS" was misspelled.
932
933 ;;;; After 4.23:
934 ;;;  (`cperl-beautify-regexp-piece'):   Was not allowing for *? after a class.
935 ;;;                                     Allow for POSIX char-classes.
936 ;;;                                     Remove trailing whitespace when
937 ;;;                                     adding new linebreak.
938 ;;;                                     Add a level counter to stop shallow.
939 ;;;                                     Indents unprocessed groups rigidly.
940 ;;;  (`cperl-beautify-regexp'): Add an optional count argument to go that
941 ;;;                             many levels deep.
942 ;;;  (`cperl-beautify-level'):  Likewise
943 ;;;  Menu:                      Add new entries to Regexp menu to do one level
944 ;;;  (`cperl-contract-level'):  Was entering an infinite loop
945 ;;;  (`cperl-find-pods-heres'): Typo (double quoting).
946 ;;;                             Was detecting < $file > as FH instead of glob.
947 ;;;                             Support for comments in RExen (except
948 ;;;                             for m#\#comment#x), governed by
949 ;;;                             `cperl-regexp-scan'.
950 ;;;  (`cperl-regexp-scan'):     New customization variable.
951 ;;;  (`cperl-forward-re'):      Improve logic of resetting syntax table.
952
953 ;;;; After 4.23 and: After 4.24:
954 ;;;  (`cperl-contract-levels'): Restore position.
955 ;;;  (`cperl-beautify-level'):  Likewise.
956 ;;;  (`cperl-beautify-regexp'): Likewise.
957 ;;;  (`cperl-commentify'):      Rudimental support for length=1 runs
958 ;;;  (`cperl-find-pods-heres'): Process 1-char long REx comments too /a#/x
959 ;;;                             Processes REx-comments in #-delimited RExen.
960 ;;;                             MAJOR BUG CORRECTED: after a misparse
961 ;;;                               a body of a subroutine could be corrupted!!!
962 ;;;                               One might need to reeval the function body
963 ;;;                               to fix things.  (A similar bug was
964 ;;;                               present in `cperl-indent-region' eons ago.)
965 ;;; To reproduce:
966 ;;   (defun foo () (let ((a '(t))) (insert (format "%s" a)) (setcar a 'BUG) t))
967 ;;   (foo)
968 ;;   (foo)
969 ;;; C-x C-e the above three lines (at end-of-line).  First evaluation
970 ;;; of `foo' inserts (t), second one inserts (BUG) ?!
971 ;;;
972 ;;; In CPerl it was triggered by inserting then deleting `/' at start of
973 ;;;      /  a (?# asdf  {[(}asdf )ef,/;
974
975 ;;;; After 4.25:
976 ;;; (`cperl-commentify'):       Was recognizing length=2 "strings" as length=1.
977 ;;; (`imenu-example--create-perl-index'):
978 ;;;                             Was not enforcing syntaxification-to-the-end.
979 ;;; (`cperl-invert-if-unless'): Allow `for', `foreach'.
980 ;;; (`cperl-find-pods-heres'):  Quote `cperl-nonoverridable-face'.
981 ;;;                             Mark qw(), m()x as indentable.
982 ;;; (`cperl-init-faces'):       Highlight `sysopen' too.
983 ;;;                             Highlight $var in `for my $var' too.
984 ;;; (`cperl-invert-if-unless'): Was leaving whitespace at end.
985 ;;; (`cperl-linefeed'):         Was splitting $var{$foo} if point after `{'.
986 ;;; (`cperl-calculate-indent'): Remove old commented out code.
987 ;;;                             Support (primitive) indentation of qw(), m()x.
988
989
990 ;;;; After 4.26:
991 ;;; (`cperl-problems'):         Mention `fill-paragraph' on comment. \"" and
992 ;;;                             q [] with intervening newlines.
993 ;;; (`cperl-autoindent-on-semi'):       New customization variable.
994 ;;; (`cperl-electric-semi'):    Use `cperl-autoindent-on-semi'.
995 ;;; (`cperl-tips'):             Mention how to make CPerl the default mode.
996 ;;; (`cperl-mode'):             Support `outline-minor-mode'
997 ;;;                             (Thanks to Mark A. Hershberger).
998 ;;; (`cperl-outline-level'):    New function.
999 ;;; (`cperl-highlight-variables-indiscriminately'):     New customization var.
1000 ;;; (`cperl-init-faces'):       Use `cperl-highlight-variables-indiscriminately'.
1001 ;;;                             (Thanks to Sean Kamath <kamath@pogo.wv.tek.com>).
1002 ;;; (`cperl-after-block-p'):    Support CHECK and INIT.
1003 ;;; (`cperl-init-faces'):       Likewise and "our".
1004 ;;;                             (Thanks to Doug MacEachern <dougm@covalent.net>).
1005 ;;; (`cperl-short-docs'):       Likewise and "our".
1006
1007
1008 ;;;; After 4.27:
1009 ;;; (`cperl-find-pods-heres'):  Recognize \"" as a string.
1010 ;;;                             Mark whitespace and comments between q and []
1011 ;;;                               as `syntax-type' => `prestring'.
1012 ;;;                             Allow whitespace between << and "FOO".
1013 ;;; (`cperl-problems'):         Remove \"" and q [] with intervening newlines.
1014 ;;;                             Mention multiple <<EOF as unsupported.
1015 ;;; (`cperl-highlight-variables-indiscriminately'):     Doc misprint fixed.
1016 ;;; (`cperl-indent-parens-as-block'):   New configuration variable.
1017 ;;; (`cperl-calculate-indent'): Merge cases of indenting non-BLOCK groups.
1018 ;;;                             Use `cperl-indent-parens-as-block'.
1019 ;;; (`cperl-find-pods-heres'):  Test for =cut without empty line instead of
1020 ;;;                             complaining about no =cut.
1021 ;;; (`cperl-electric-pod'):     Change the REx for POD from "\n\n=" to "^\n=".
1022 ;;; (`cperl-find-pods-heres'):  Likewise.
1023 ;;; (`cperl-electric-pod'):     Change `forward-sexp' to `forward-word':
1024 ;;;                             POD could've been marked as comment already.
1025 ;;; (`cperl-unwind-to-safe'):   Unwind before start of POD too.
1026
1027 ;;;; After 4.28:
1028 ;;; (`cperl-forward-re'):       Throw an error at proper moment REx unfinished.
1029
1030 ;;;; After 4.29:
1031 ;;; (`x-color-defined-p'):      Make an extra case to peacify the warning.
1032 ;;; Toplevel:                   `defvar' to peacify the warnings.
1033 ;;; (`cperl-find-pods-heres'):  Could access `font-lock-comment-face' in -nw.
1034 ;;;;                            No -nw-compile time warnings now.
1035 ;;; (`cperl-find-tags'):        TAGS file had too short substring-to-search.
1036 ;;;                             Be less verbose in non-interactive mode
1037 ;;; (`imenu-example--create-perl-index'):       Set index-marker after name
1038 ;;; (`cperl-outline-regexp'):   New variable.
1039 ;;; (`cperl-outline-level'):    Made compatible with `cperl-outline-regexp'.
1040 ;;; (`cperl-mode'):             Made use `cperl-outline-regexp'.
1041
1042 ;;;; After 4.30:
1043 ;;; (`cperl-find-pods-heres'):  =cut the last thing, no blank line, was error.
1044 ;;; (`cperl-outline-level'):    Make start-of-file same level as `package'.
1045
1046 ;;;; After 4.31:
1047 ;;; (`cperl-electric-pod'):     `head1' and `over' electric only if empty.
1048 ;;; (`cperl-unreadable-ok'):    New variable.
1049 ;;; (`cperl-find-tags'):        Use `cperl-unreadable-ok', do not fail
1050 ;;;                             on an unreadable file
1051 ;;; (`cperl-write-tags'):       Use `cperl-unreadable-ok', do not fail
1052 ;;;                             on an unreadable directory
1053
1054 ;;;; After 4.32:
1055 ;;;  Syncronized with v1.60 from Emacs 21.3.
1056 ;;;  Mostly docstring and formatting changes, and:
1057
1058 ;;;  (`cperl-noscan-files-regexp'): Do not scan CVS subdirs
1059 ;;;  (`cperl-problems'):        Note that newer XEmacsen may syntaxify too
1060 ;;;  (`imenu-example--create-perl-index'):
1061 ;;;                             Renamed to `cperl-imenu--create-perl-index'
1062 ;;;  (`cperl-mode'):            Replace `make-variable-buffer-local' by `make-local-variable'
1063 ;;;  (`cperl-setup-tmp-buf'):   Likewise
1064 ;;;  (`cperl-fix-line-spacing'): Fix a misprint of "t" for "\t"
1065 ;;;  (`cperl-next-bad-style'):  Fix misprints in character literals
1066
1067 ;;;; After 4.33:
1068 ;;;  (`cperl-font-lock-keywords'): +etc: Aliased to perl-font-lock-keywords.
1069
1070 ;;;; After 4.34:
1071 ;;;  Further updates of whitespace and spelling w.r.t. RMS version.
1072 ;;;  (`cperl-font-lock-keywords'): +etc: Avoid warnings when aliasing.
1073 ;;;  (`cperl-mode'):            Use `normal-auto-fill-function' if present.
1074 ;;;  (`cperl-use-major-mode'):  New variable
1075 ;;;  (`cperl-can-font-lock'):   New variable; replaces `window-system'
1076 ;;;  (`cperl-tags-hier-init'):  use `display-popup-menus-p' (if present)
1077 ;;;                             to choose `x-popup-menu' vs `tmm-prompt'
1078
1079 ;;;; 4.35 has the following differences from version 1.40+ of RMS Emacs:
1080
1081 ;;; New variables `cperl-use-major-mode', `cperl-can-font-lock';
1082 ;;; `cperl-use-major-mode' is (effectively) 'cperl-mode in RMS.
1083 ;;; `cperl-under-as-char'  is nil in RMS.
1084 ;;; Minor differences in docstrings, and `cperl-non-problems'.
1085 ;;; Backward compatibility addressed: (`); (function (lambda ...)); font-lock;
1086 ;;; (:italic t bold t) vs (:slant italic :weight bold) in faces;
1087 ;;; `normal-auto-fill-function'.
1088 ;;; RMS version has wrong logic in `cperl-calculate-indent': $a = { } is
1089 ;;; wrongly indented if the closing brace is on a separate line.
1090 ;;; Different choice of ordering if's for is-x-REx and (eq (char-after b) ?\#)
1091 ;;; in `cperl-find-pods-heres'. [Cosmetic]
1092
1093 ;;;; After 4.35:
1094 ;;;  (`cperl-find-pods-heres'): If no end of HERE-doc found, mark to the end
1095 ;;;                             of buffer.  This enables recognition of end
1096 ;;;                             of HERE-doc "as one types".
1097 ;;;                             Require "\n" after trailing tag of HERE-doc.
1098 ;;;                             \( made non-quoting outside of string/comment
1099 ;;;                             (gdj-contributed).
1100 ;;;                             Likewise for \$.
1101 ;;;                             Remove `here-doc-group' text property at start
1102 ;;;                             (makes this property reliable).
1103 ;;;                             Text property `first-format-line' ==> t.
1104 ;;;                             Do not recognize $opt_s and $opt::s as s///.
1105 ;;;  (`cperl-perldoc'):         Use case-sensitive search (contributed).
1106 ;;;  (`cperl-fix-line-spacing'): Allow "_" in $vars of foreach etc. when
1107 ;;;                             underscore isn't a word char (gdj-contributed).
1108 ;;;  (`defun-prompt-regexp'):   Allow prototypes.
1109 ;;;  (`cperl-vc-header-alist'): Extract numeric version from the Id.
1110 ;;;  Toplevel:                  Put toggle-autohelp into the mode menu.
1111 ;;;                             Better docs for toggle/set/unset autohelp.
1112 ;;;  (`cperl-electric-backspace-untabify'): New customization variable
1113 ;;;  (`cperl-after-expr-p'):    Works after here-docs, formats, and PODs too
1114 ;;;                             (affects many electric constructs).
1115 ;;;  (`cperl-calculate-indent'): Takes into account `first-format-line' ==>
1116 ;;;                             works after format.
1117 ;;;  (`cperl-short-docs'):      Make it work with ... too.
1118 ;;;                             "array context" ==> "list context"
1119 ;;;  (`cperl-electric-keyword'): make $if (etc: "$@%&*") non-electric
1120 ;;;                             '(' after keyword would insert a doubled paren
1121 ;;;  (`cperl-electric-paren'):  documented affected by `cperl-electric-parens'
1122 ;;;  (`cperl-electric-rparen'): Likewise
1123 ;;;  (`cperl-build-manpage'):   New function by Nick Roberts
1124 ;;;  (`cperl-perldoc'):         Make it work in XEmacs too
1125
1126 ;;;; After 4.36:
1127 ;;;  (`cperl-find-pods-heres'): Recognize s => 1 and {s} (as a key or varname),
1128 ;;;                             { s:: } and { s::bar::baz } as varnames.
1129 ;;;  (`cperl-after-expr-p'):    Updates syntaxification before checks
1130 ;;;  (`cperl-calculate-indent'): Likewise
1131 ;;;                             Fix wrong indent of blocks starting with POD
1132 ;;;  (`cperl-after-block-p'):   Optional argument for checking for a pre-block
1133 ;;;                             Recognize `continue' blocks too.
1134 ;;;  (`cperl-electric-brace'):  use `cperl-after-block-p' for detection;
1135 ;;;                             Now works for else/continue/sub blocks
1136 ;;;  (`cperl-short-docs'):      Minor edits; make messages fit 80-column screen
1137
1138 ;;;; After 5.0:
1139 ;;;  `cperl-add-tags-recurse-noxs-fullpath': new function (for -batch mode)
1140
1141 ;;;; After 5.1:
1142 ;;;;;; Major edit.  Summary of most visible changes:
1143
1144 ;;;;;; a) Multiple <<HERE per line allowed.
1145 ;;;;;; b) Handles multiline subroutine declaration headers (with comments).
1146 ;;;;;;    (The exception is `cperl-etags' - but it is not used in the rest
1147 ;;;;;;    of the mode.)
1148 ;;;;;; c) Fontifies multiline my/our declarations (even with comments,
1149 ;;;;;;    and with legacy `font-lock').
1150 ;;;;;; d) Major speedup of syntaxification, both immediate and postponed
1151 ;;;;;;    (3.5x to 15x [for different CPUs and versions of Emacs] on the
1152 ;;;;;;    huge real-life document I tested).
1153 ;;;;;; e) New bindings, edits to imenu.
1154 ;;;;;; f) "_" is made into word-char during fontification/syntaxification;
1155 ;;;;;;    some attempts to recognize non-word "_" during other operations too.
1156 ;;;;;; g) Detect bug in Emacs with `looking-at' inside `narrow' and bulk out.
1157 ;;;;;; h) autoload some more perldoc-related stuff
1158 ;;;;;; i) Some new convenience features: ISpell POD/HEREDOCs, narrow-to-HEREDOC
1159 ;;;;;; j) Attempt to incorporate XEmacs edits which reached me
1160
1161 ;;;; Fine-grained changelog:
1162 ;;; `cperl-hook-after-change':  New configuration variable
1163 ;;; `cperl-vc-sccs-header':     Likewise
1164 ;;; `cperl-vc-sccs-header':     Likewise
1165 ;;; `cperl-vc-header-alist':    Default via two preceding variables
1166 ;;; `cperl-invalid-face':       Remove double quoting under XEmacs
1167 ;;;                                     (still needed under 21.2)
1168 ;;; `cperl-tips':               Update URLs for resources
1169 ;;; `cperl-problems':           Likewise
1170 ;;; `cperl-praise':             Mention new features
1171 ;;; New C-c key bindings:       for `cperl-find-bad-style',
1172 ;;;     `cperl-pod-spell', `cperl-here-doc-spell', `cperl-narrow-to-here-doc',
1173 ;;;     `cperl-perdoc', `cperl-perldoc-at-point'
1174 ;;; CPerl Mode menu changes:    "Fix style by spaces", "Imenu on Perl Info"
1175 ;;;     moved, new submenu of Tools with Ispell entries and narrowing.
1176 ;;; `cperl-after-sub-regexp':   New defsubst
1177 ;;; `cperl-imenu--function-name-regexp-perl': Use `cperl-after-sub-regexp',
1178 ;;;                             Allows heads up to head4
1179 ;;;                             Allow "package;"
1180 ;;; `defun-prompt-regexp':      Use `cperl-after-sub-regexp',
1181 ;;; `paren-backwards-message':  ??? Something for XEmacs???
1182 ;;; `cperl-mode':               Never auto-switch abbrev-mode off
1183 ;;;                             Try to allow '_' be non-word char
1184 ;;;                             Do not use `font-lock-unfontify-region-function' on XEmacs
1185 ;;;                             Reset syntax cache on mode start
1186 ;;;                             Support multiline facification (even
1187 ;;;                                     on legacy `font-lock')
1188 ;;; `cperl-facemenu-add-face-function': ??? Some contributed code ???
1189 ;;; `cperl-after-change-function':      Since `font-lock' and `lazy-lock'
1190 ;;;         refuse to inform us whether the fontification is due to lazy
1191 ;;;         calling or due to edit to a buffer, install our own hook
1192 ;;;         (controlled by `cperl-hook-after-change')
1193 ;;; `cperl-electric-pod':       =cut may have been recognized as start
1194 ;;; `cperl-block-p':            Moved, updated for attributes
1195 ;;; `cperl-calculate-indent':   Try to allow '_' be non-word char
1196 ;;;                             Support subs with attributes
1197 ;;; `cperl-where-am-i':         Queit (?) a warning
1198 ;;; `cperl-cached-syntax-table' New function
1199 ;;; `cperl-forward-re':         Use `cperl-cached-syntax-table'
1200 ;;; `cperl-unwind-to-safe':     Recognize `syntax-type' property
1201 ;;;                                     changing in a middle of line
1202 ;;; `cperl-find-sub-attrs':     New function
1203 ;;; `cperl-find-pods-heres':    Allow many <<EOP per line
1204 ;;;                             Allow subs with attributes
1205 ;;;                             Major speedups (3.5x..15x on a real-life
1206 ;;;                                     test file nph-proxy.pl)
1207 ;;;                             Recognize "extproc " (OS/2)
1208 ;;;                                     case-folded and only at start
1209 ;;;                             /x on s///x with empty replacement was
1210 ;;;                                     not recognized
1211 ;;;                             Better comments
1212 ;;; `cperl-after-block-p':      Remarks on diff with `cperl-block-p'
1213 ;;;                             Allow subs with attributes, labels
1214 ;;;                             Do not confuse "else::foo" with "else"
1215 ;;;                             Minor optimizations...
1216 ;;; `cperl-after-expr-p':       Try to allow '_' be non-word char
1217 ;;; `cperl-fill-paragraph':     Try to detect a major bug in Emacs
1218 ;;;         with `looking-at' inside `narrow' and bulk out if found
1219 ;;; `cperl-imenu--create-perl-index':   Updates for new
1220 ;;;         `cperl-imenu--function-name-regexp-perl'
1221 ;;; `cperl-outline-level':      Likewise
1222 ;;; `cperl-init-faces':         Allow multiline subroutine headers
1223 ;;;         and my/our declarations, and ones with comments
1224 ;;;                             Allow subroutine attributes
1225 ;;; `cperl-imenu-on-info':      Better docstring.
1226 ;;; `cperl-etags'               Rudimentary support for attributes
1227 ;;;                             Support for packages and "package;"
1228 ;;; `cperl-add-tags-recurse-noxs':      Better (?) docstring
1229 ;;; `cperl-add-tags-recurse-noxs-fullpath': Likewise
1230 ;;; `cperl-tags-hier-init':     Misprint for `fboundp' fixed
1231 ;;; `cperl-not-bad-style-regexp':       Try to allow '_' be non-word char
1232 ;;; `cperl-perldoc':            Add autoload
1233 ;;; `cperl-perldoc-at-point':   Likewise
1234 ;;; `cperl-here-doc-spell':     New function
1235 ;;; `cperl-pod-spell':          Likewise
1236 ;;; `cperl-map-pods-heres':     Likewise
1237 ;;; `cperl-get-here-doc-region':        Likewise
1238 ;;; `cperl-font-lock-fontify-region-function': Likewise (backward compatibility
1239 ;;;                                             for legacy `font-lock')
1240 ;;; `cperl-font-lock-unfontify-region-function': Fix style
1241 ;;; `cperl-fontify-syntaxically':       Recognize and optimize away
1242 ;;;         deferred calls with no-change.  Governed by `cperl-hook-after-change'
1243 ;;; `cperl-fontify-update':     Recognize that syntaxification region
1244 ;;;         can be larger than fontification one.
1245 ;;;         XXXX we leave `cperl-postpone' property, so this is quadratic...
1246 ;;; `cperl-fontify-update-bad': Temporary placeholder until
1247 ;;;         it is clear how to implement `cperl-fontify-update'.
1248 ;;; `cperl-time-fontification': New function
1249 ;;; `attrib-group':             New text attribute
1250 ;;; `multiline':                New value: `syntax-type' text attribute
1251
1252 ;;;; After 5.2:
1253 ;;; `cperl-emulate-lazy-lock':  New function
1254 ;;; `cperl-fontify-syntaxically': Would skip large regions
1255 ;;; Add `cperl-time-fontification', `cperl-emulate-lazy-lock' to menu
1256 ;;; Some globals were declared, but uninitialized
1257
1258 ;;;; After 5.3, 5.4:
1259 ;;; `cperl-facemenu-add-face-function': Add docs, fix U<>
1260 ;;; Copyright message updated.
1261 ;;; `cperl-init-faces':         Work around a bug in `font-lock'. May slow
1262 ;;;                                     facification down a bit.
1263 ;;;                             Misprint for my|our|local for old `font-lock'
1264 ;;;                             "our" was not fontified same as "my|local"
1265 ;;;                             Highlight variables after "my" etc even in
1266 ;;;                                     a middle of an expression
1267 ;;;                             Do not facify multiple variables after my etc
1268 ;;;                                     unless parentheses are present
1269
1270 ;;; After 5.5, 5.6
1271 ;;; `cperl-fontify-syntaxically': after-change hook could reset
1272 ;;;     `cperl-syntax-done-to' to a middle of line; unwind to BOL.
1273
1274 ;;; After 5.7:
1275 ;;; `cperl-init-faces':         Allow highlighting of local ($/)
1276 ;;; `cperl-problems-old-emaxen': New variable (for the purpose of DOCSTRING).
1277 ;;; `cperl-problems':           Remove fixed problems.
1278 ;;; `cperl-find-pods-heres':    Recognize #-comments in m##x too
1279 ;;;                             Recognize charclasses (unless delimiter is \).
1280 ;;; `cperl-fontify-syntaxically': Unwinding to safe was done in wrong order
1281 ;;; `cperl-regexp-scan':        Update docs
1282 ;;; `cperl-beautify-regexp-piece': use information got from regexp scan
1283
1284 ;;; After 5.8:
1285 ;;; Major user visible changes:
1286 ;;; Recognition and fontification of character classes in RExen.
1287 ;;; Variable indentation of RExen according to groups
1288 ;;;
1289 ;;; `cperl-find-pods-heres':    Recognize POSIX classes in REx charclasses
1290 ;;;                             Fontify REx charclasses in variable-name face
1291 ;;;                             Fontify POSIX charclasses in "type" face
1292 ;;;                             Fontify unmatched "]" in function-name face
1293 ;;;                             Mark first-char of HERE-doc as `front-sticky'
1294 ;;;                             Reset `front-sticky' property when needed
1295 ;;; `cperl-calculate-indent':   Indents //x -RExen accordning to parens level
1296 ;;; `cperl-to-comment-or-eol':  Recognize ends of `syntax-type' constructs
1297 ;;; `cperl-backward-to-noncomment': Recognize stringy `syntax-type' constructs
1298 ;;;                             Support `narrow'ed buffers.
1299 ;;; `cperl-praise':             Remove a reservation
1300 ;;; `cperl-make-indent':        New function
1301 ;;; `cperl-indent-for-comment': Use `cperl-make-indent'
1302 ;;; `cperl-indent-line':        Likewise
1303 ;;; `cperl-lineup':             Likewise
1304 ;;; `cperl-beautify-regexp-piece': Likewise
1305 ;;; `cperl-contract-level':     Likewise
1306 ;;; `cperl-toggle-set-debug-unwind': New function
1307 ;;;                             New menu entry for this
1308 ;;; `fill-paragraph-function':  Use when `boundp'
1309 ;;; `cperl-calculate-indent':   Take into account groups when indenting RExen
1310 ;;; `cperl-to-comment-or-eol':  Recognize # which end a string
1311 ;;; `cperl-modify-syntax-type': Make only syntax-table property non-sticky
1312 ;;; `cperl-fill-paragraph':     Return t: needed for `fill-paragraph-function'
1313 ;;; `cperl-fontify-syntaxically': More clear debugging message
1314 ;;; `cperl-pod2man-build-command': XEmacs portability: check `Man-filter-list'
1315 ;;; `cperl-init-faces':         More complicated highlight even on XEmacs (new)
1316 ;;; Merge cosmetic changes from XEmacs
1317
1318 ;;; After 5.9:
1319 ;;; `cperl-1+':                 Moved to before the first use
1320 ;;; `cperl-1-':                 Likewise
1321
1322 ;;; After 5.10:
1323
1324 ;;; This code may lock Emacs hard!!!  Use on your own risk!
1325
1326 ;;; `cperl-font-locking':       New internal variable
1327 ;;; `cperl-beginning-of-property': New function
1328 ;;; `cperl-calculate-indent':   Use `cperl-beginning-of-property'
1329 ;;;     instead of `previous-single-property-change'
1330 ;;; `cperl-unwind-to-safe':     Likewise
1331 ;;; `cperl-after-expr-p':       Likewise
1332 ;;; `cperl-get-here-doc-region': Likewise
1333 ;;; `cperl-font-lock-fontify-region-function': Likewise
1334 ;;; `cperl-to-comment-or-eol':  Do not call `cperl-update-syntaxification'
1335 ;;;                                     recursively
1336 ;;;                             Bound `next-single-property-change'
1337 ;;;                                     via `point-max'
1338 ;;; `cperl-unwind-to-safe':     Bound likewise
1339 ;;; `cperl-font-lock-fontify-region-function': Likewise
1340 ;;; `cperl-find-pods-heres':    Mark as recursive for `cperl-to-comment-or-eol'
1341 ;;;                             Initialization of
1342 ;;;     `cperl-font-lock-multiline-start' could be missed if the "main"
1343 ;;;     fontification did not run due to the keyword being already fontified.
1344 ;;; `cperl-pod-spell':          Return t from do-one-chunk function
1345 ;;; `cperl-map-pods-heres':     Stop when the worker returns nil
1346 ;;;                             Call `cperl-update-syntaxification'
1347 ;;; `cperl-get-here-doc-region': Call `cperl-update-syntaxification'
1348 ;;; `cperl-get-here-doc-delim': Remove unused function
1349
1350 ;;; After 5.11:
1351
1352 ;;;  The possible lockup of Emacs (introduced in 5.10) fixed
1353
1354 ;;; `cperl-unwind-to-safe':     `cperl-beginning-of-property' won't return nil
1355 ;;; `cperl-syntaxify-for-menu': New customization variable
1356 ;;; `cperl-select-this-pod-or-here-doc': New function
1357 ;;; `cperl-get-here-doc-region': Extra argument
1358 ;;;                             Do not adjust pos by 1
1359
1360 ;;; New menu entries (Perl/Tools): selection of current POD or HERE-DOC section
1361 ;;;                             (Debugging CPerl:) backtrace on fontification
1362
1363 ;;; After 5.12:
1364 ;;; `cperl-cached-syntax-table': use `car-safe'
1365 ;;; `cperl-forward-re':         Remove spurious argument SET-ST
1366 ;;;                             Add documentation
1367 ;;; `cperl-forward-group-in-re': New function
1368 ;;; `cperl-find-pods-heres':    Find and highlight (?{}) blocks in RExen
1369 ;;;     (XXXX Temporary (?) hack is to syntax-mark them as comment)
1370
1371 ;;; After 5.13:
1372 ;;; `cperl-string-syntax-table': Make { and } not-grouping
1373 ;;;   (Sometimes they ARE grouping in RExen, but matching them would only
1374 ;;;    confuse in many situations when they are not)
1375 ;;; `beginning-of-buffer':      Replaced two occurences with goto-char...
1376 ;;; `cperl-calculate-indent':   `char-after' could be nil...
1377 ;;; `cperl-find-pods-heres':    REx can start after "[" too
1378 ;;;                             Hightlight (??{}) in RExen too 
1379 ;;; `cperl-maybe-white-and-comment-rex': New constant
1380 ;;; `cperl-white-and-comment-rex': Likewise
1381 ;;;                             XXXX Not very efficient, but hard to make
1382 ;;;                             better while keeping 1 group
1383
1384 ;;; After 5.13:
1385 ;;; `cperl-find-pods-heres':    $foo << identifier() is not a HERE-DOC
1386 ;;;                             Likewise for 1 << identifier
1387
1388 ;;; After 5.14:
1389 ;;; `cperl-find-pods-heres':    Different logic for $foo .= <<EOF etc
1390 ;;;                             Error-less condition-case could fail
1391 ;;; `cperl-font-lock-fontify-region-function': Likewise
1392 ;;; `cperl-init-faces':         Likewise
1393
1394 ;;; After 5.15:
1395 ;;; `cperl-find-pods-heres':    Support property REx-part2
1396 ;;; `cperl-calculate-indent':   Likewise
1397 ;;;                             Don't special-case REx with non-empty 1st line
1398 ;;; `cperl-find-pods-heres':    In RExen, highlight non-literal backslashes
1399 ;;;                             Invert highlighting of charclasses: 
1400 ;;;                                     now the envelop is highlighted
1401 ;;;                             Highlight many others 0-length builtins
1402 ;;; `cperl-praise':             Mention indenting and highlight in RExen
1403
1404 ;;; After 5.15:
1405 ;;; `cperl-find-pods-heres':    Highlight capturing parens in REx
1406
1407 ;;; After 5.16:
1408 ;;; `cperl-find-pods-heres':    Highlight '|' for alternation
1409 ;;;     Initialize `font-lock-warning-face' if not present
1410 ;;; `cperl-find-pods-heres':    Use `font-lock-warning-face' instead of
1411 ;;;                                      `font-lock-function-name-face'
1412 ;;; `cperl-look-at-leading-count': Likewise
1413 ;;; `cperl-find-pods-heres':    localize `font-lock-variable-name-face'
1414 ;;;                                     `font-lock-keyword-face' (needed for
1415 ;;;                                     batch processing) etc
1416 ;;;                             Use `font-lock-builtin-face' for builtin in REx
1417 ;;;                                     Now `font-lock-variable-name-face'
1418 ;;;                                     is used for interpolated variables
1419 ;;;                             Use "talking aliases" for faces inside REx
1420 ;;;                             Highlight parts of REx (except in charclasses)
1421 ;;;                                     according to the syntax and/or semantic
1422 ;;;                             Syntax-mark a {}-part of (?{}) as "comment"
1423 ;;;                                     (it was the ()-part)
1424 ;;;                             Better logic to distinguish what is what in REx
1425 ;;; `cperl-tips-faces':         Document REx highlighting
1426 ;;; `cperl-praise':             Mention REx syntax highlight etc.
1427
1428 ;;; After 5.17:
1429 ;;; `cperl-find-sub-attrs':     Would not always manage to print error message
1430 ;;; `cperl-find-pods-heres':    localize `font-lock-constant-face'
1431
1432 ;;; After 5.18:
1433 ;;; `cperl-find-pods-heres':    Misprint in REx for parsing REx
1434 ;;;                             Very minor optimization
1435 ;;;                             `my-cperl-REx-modifiers-face' got quoted
1436 ;;;                             Recognize "print $foo <<END" as HERE-doc
1437 ;;;                             Put `REx-interpolated' text attribute if needed
1438 ;;; `cperl-invert-if-unless-modifiers': New function
1439 ;;; `cperl-backward-to-start-of-expr': Likewise
1440 ;;; `cperl-forward-to-end-of-expr': Likewise
1441 ;;; `cperl-invert-if-unless':   Works in "the opposite way" too
1442 ;;;                             Cursor position on return is on the switch-word
1443 ;;;                             Indents comments better
1444 ;;; `REx-interpolated':         New text attribute
1445 ;;; `cperl-next-interpolated-REx': New function
1446 ;;; `cperl-next-interpolated-REx-0': Likewise
1447 ;;; `cperl-next-interpolated-REx-1': Likewise
1448 ;;; "\C-c\C-x", "\C-c\C-y", "\C-c\C-v": New keybinding for these functions
1449 ;;; Perl/Regexp menu:           3 new entries for `cperl-next-interpolated-REx'
1450 ;;; `cperl-praise':             Mention finded interpolated RExen
1451
1452 ;;; After 5.19:
1453 ;;; `cperl-init-faces':         Highlight %$foo, @$foo too
1454 ;;; `cperl-short-docs':         Better docs for system, exec
1455 ;;; `cperl-find-pods-heres':    Better detect << after print {FH} <<EOF etc.
1456 ;;;                             Would not find HERE-doc ended by EOF without NL
1457 ;;; `cperl-short-docs':         Correct not-doubled \-escapes
1458 ;;; start block:                Put some `defvar' for stuff gone from XEmacs
1459
1460 ;;; After 5.20:
1461 ;;; initial comment:            Extend copyright, fix email address
1462 ;;; `cperl-indent-comment-at-column-0': New customization variable
1463 ;;; `cperl-comment-indent':     Indentation after $#a would increasy by 1
1464 ;;; `cperl-mode':               Make `defun-prompt-regexp' grok BEGIN/END etc
1465 ;;; `cperl-find-pods-heres':    Mark CODE of s///e as `syntax-type' `multiline'
1466 ;;; `cperl-at-end-of-expr':     Would fail if @BAR=12 follows after ";"
1467 ;;; `cperl-init-faces':         If `cperl-highlight-variables-indiscriminately'
1468 ;;;                                     highlight $ in $foo too (UNTESTED)
1469 ;;; `cperl-set-style':          Docstring missed some available styles
1470 ;;; toplevel:                   Menubar/Perl/Indent-Styles had FSF, now K&R
1471 ;;;                             Change "Current" to "Memorize Current"
1472 ;;; `cperl-indent-wrt-brace':   New customization variable; the default is
1473 ;;;                             as for pre-5.2 version
1474 ;;; `cperl-styles-entries':     Keep `cperl-extra-newline-before-brace-multiline'
1475 ;;; `cperl-style-alist':        Likewise
1476 ;;; `cperl-fix-line-spacing':   Support `cperl-merge-trailing-else' being nil,
1477 ;;;                             and `cperl-extra-newline-before-brace' etc
1478 ;;;                             being t
1479 ;;; `cperl-indent-exp':         Plans B and C to find continuation blocks even
1480 ;;;                             if `cperl-extra-newline-before-brace' is t
1481
1482 ;;; After 5.21:
1483 ;;; Improve some docstrings concerning indentation.
1484 ;;; `cperl-indent-rules-alist': New variable
1485 ;;; `cperl-sniff-for-indent':   New function name
1486 ;;                              (separated from `cperl-calculate-indent')
1487 ;;; `cperl-calculate-indent':   Separated the sniffer and the indenter;
1488 ;;;                             uses `cperl-sniff-for-indent' now
1489 ;;; `cperl-comment-indent':     Test for `cperl-indent-comment-at-column-0'
1490 ;;;                             was inverted;
1491 ;;;                             Support `comment-column' = 0
1492
1493 ;;; After 5.22:
1494 ;;; `cperl-where-am-i':         Remove function
1495 ;;; `cperl-backward-to-noncomment': Would go too far when skipping POD/HEREs
1496 ;;; `cperl-sniff-for-indent':   [string] and [comment] were inverted
1497 ;;;                             When looking for label, skip s:m:y:tr
1498 ;;; `cperl-indent-line':        Likewise.
1499 ;;; `cperl-mode':               `font-lock-multiline' was assumed auto-local
1500 ;;; `cperl-windowed-init':      Wrong `ps-print' handling
1501 ;;;                              (both thanks to Chong Yidong)
1502 ;;; `cperl-look-at-leading-count': Could fail with unfinished RExen
1503 ;;; `cperl-find-pods-heres':    If the second part of s()[] is missing,
1504 ;;;                                     could try to highlight delimiters...
1505
1506 ;;; Code:
1507 \f
1508 (if (fboundp 'eval-when-compile)
1509     (eval-when-compile
1510       (condition-case nil
1511           (require 'custom)
1512         (error nil))
1513       (condition-case nil
1514           (require 'man)
1515         (error nil))
1516       (defconst cperl-xemacs-p (string-match "XEmacs\\|Lucid" emacs-version))
1517       (defvar cperl-can-font-lock
1518         (or cperl-xemacs-p
1519             (and (boundp 'emacs-major-version)
1520                  (or window-system
1521                      (> emacs-major-version 20)))))
1522       (if cperl-can-font-lock
1523           (require 'font-lock))
1524       (defvar msb-menu-cond)
1525       (defvar gud-perldb-history)
1526       (defvar font-lock-background-mode) ; not in Emacs
1527       (defvar font-lock-display-type)   ; ditto
1528       (defvar paren-backwards-message)  ; Not in newer XEmacs?
1529       (defvar vc-rcs-header)            ; likewise?
1530       (defvar vc-sccs-header)           ; likewise?
1531       (or (fboundp 'defgroup)
1532           (defmacro defgroup (name val doc &rest arr)
1533             nil))
1534       (or (fboundp 'custom-declare-variable)
1535           (defmacro defcustom (name val doc &rest arr)
1536             (` (defvar (, name) (, val) (, doc)))))
1537       (or (and (fboundp 'custom-declare-variable)
1538                (string< "19.31" emacs-version)) ;  Checked with 19.30: defface does not work
1539           (defmacro defface (&rest arr)
1540             nil))
1541       ;; Avoid warning (tmp definitions)
1542       (or (fboundp 'x-color-defined-p)
1543           (defmacro x-color-defined-p (col)
1544             (cond ((fboundp 'color-defined-p) (` (color-defined-p (, col))))
1545                   ;; XEmacs >= 19.12
1546                   ((fboundp 'valid-color-name-p) (` (valid-color-name-p (, col))))
1547                   ;; XEmacs 19.11
1548                   ((fboundp 'x-valid-color-name-p) (` (x-valid-color-name-p (, col))))
1549                   (t '(error "Cannot implement color-defined-p")))))
1550       (defmacro cperl-is-face (arg)     ; Takes quoted arg
1551         (cond ((fboundp 'find-face)
1552                (` (find-face (, arg))))
1553               (;;(and (fboundp 'face-list)
1554                ;;       (face-list))
1555                (fboundp 'face-list)
1556                (` (member (, arg) (and (fboundp 'face-list)
1557                                        (face-list)))))
1558               (t
1559                (` (boundp (, arg))))))
1560       (defmacro cperl-make-face (arg descr) ; Takes unquoted arg
1561         (cond ((fboundp 'make-face)
1562                (` (make-face (quote (, arg)))))
1563               (t
1564                (` (defvar (, arg) (quote (, arg)) (, descr))))))
1565       (defmacro cperl-force-face (arg descr) ; Takes unquoted arg
1566         (` (progn
1567              (or (cperl-is-face (quote (, arg)))
1568                  (cperl-make-face (, arg) (, descr)))
1569              (or (boundp (quote (, arg))) ; We use unquoted variants too
1570                  (defvar (, arg) (quote (, arg)) (, descr))))))
1571       (if cperl-xemacs-p
1572           (defmacro cperl-etags-snarf-tag (file line)
1573             (` (progn
1574                  (beginning-of-line 2)
1575                  (list (, file) (, line)))))
1576         (defmacro cperl-etags-snarf-tag (file line)
1577           (` (etags-snarf-tag))))
1578       (if cperl-xemacs-p
1579           (defmacro cperl-etags-goto-tag-location (elt)
1580             (`;;(progn
1581              ;; (switch-to-buffer (get-file-buffer (elt (, elt) 0)))
1582              ;; (set-buffer (get-file-buffer (elt (, elt) 0)))
1583              ;; Probably will not work due to some save-excursion???
1584              ;; Or save-file-position?
1585              ;; (message "Did I get to line %s?" (elt (, elt) 1))
1586              (goto-line (string-to-int (elt (, elt) 1)))))
1587         ;;)
1588         (defmacro cperl-etags-goto-tag-location (elt)
1589           (` (etags-goto-tag-location (, elt)))))))
1590
1591 (defconst cperl-xemacs-p (string-match "XEmacs\\|Lucid" emacs-version))
1592
1593 (defvar cperl-can-font-lock
1594   (or cperl-xemacs-p
1595       (and (boundp 'emacs-major-version)
1596            (or window-system
1597                (> emacs-major-version 20)))))
1598
1599 (condition-case nil
1600     (require 'custom)
1601   (error nil))                          ; Already fixed by eval-when-compile
1602
1603 (defun cperl-choose-color (&rest list)
1604   (let (answer)
1605     (while list
1606       (or answer
1607           (if (or (x-color-defined-p (car list))
1608                   (null (cdr list)))
1609               (setq answer (car list))))
1610       (setq list (cdr list)))
1611     answer))
1612
1613 \f
1614 (defgroup cperl nil
1615   "Major mode for editing Perl code."
1616   :prefix "cperl-"
1617   :group 'languages)
1618
1619 (defgroup cperl-indentation-details nil
1620   "Indentation."
1621   :prefix "cperl-"
1622   :group 'cperl)
1623
1624 (defgroup cperl-affected-by-hairy nil
1625   "Variables affected by `cperl-hairy'."
1626   :prefix "cperl-"
1627   :group 'cperl)
1628
1629 (defgroup cperl-autoinsert-details nil
1630   "Auto-insert tuneup."
1631   :prefix "cperl-"
1632   :group 'cperl)
1633
1634 (defgroup cperl-faces nil
1635   "Fontification colors."
1636   :prefix "cperl-"
1637   :group 'cperl)
1638
1639 (defgroup cperl-speed nil
1640   "Speed vs. validity tuneup."
1641   :prefix "cperl-"
1642   :group 'cperl)
1643
1644 (defgroup cperl-help-system nil
1645   "Help system tuneup."
1646   :prefix "cperl-"
1647   :group 'cperl)
1648
1649 \f
1650 (defcustom cperl-extra-newline-before-brace nil
1651   "*Non-nil means that if, elsif, while, until, else, for, foreach
1652 and do constructs look like:
1653
1654         if ()
1655         {
1656         }
1657
1658 instead of:
1659
1660         if () {
1661         }"
1662   :type 'boolean
1663   :group 'cperl-autoinsert-details)
1664
1665 (defcustom cperl-extra-newline-before-brace-multiline
1666   cperl-extra-newline-before-brace
1667   "*Non-nil means the same as `cperl-extra-newline-before-brace', but
1668 for constructs with multiline if/unless/while/until/for/foreach condition."
1669   :type 'boolean
1670   :group 'cperl-autoinsert-details)
1671
1672 (defcustom cperl-indent-level 2
1673   "*Indentation of CPerl statements with respect to containing block."
1674   :type 'integer
1675   :group 'cperl-indentation-details)
1676
1677 (defcustom cperl-lineup-step nil
1678   "*`cperl-lineup' will always lineup at multiple of this number.
1679 If nil, the value of `cperl-indent-level' will be used."
1680   :type '(choice (const nil) integer)
1681   :group 'cperl-indentation-details)
1682
1683 (defcustom cperl-brace-imaginary-offset 0
1684   "*Imagined indentation of a Perl open brace that actually follows a statement.
1685 An open brace following other text is treated as if it were this far
1686 to the right of the start of its line."
1687   :type 'integer
1688   :group 'cperl-indentation-details)
1689
1690 (defcustom cperl-brace-offset 0
1691   "*Extra indentation for braces, compared with other text in same context."
1692   :type 'integer
1693   :group 'cperl-indentation-details)
1694 (defcustom cperl-label-offset -2
1695   "*Offset of CPerl label lines relative to usual indentation."
1696   :type 'integer
1697   :group 'cperl-indentation-details)
1698 (defcustom cperl-min-label-indent 1
1699   "*Minimal offset of CPerl label lines."
1700   :type 'integer
1701   :group 'cperl-indentation-details)
1702 (defcustom cperl-continued-statement-offset 2
1703   "*Extra indent for lines not starting new statements."
1704   :type 'integer
1705   :group 'cperl-indentation-details)
1706 (defcustom cperl-continued-brace-offset 0
1707   "*Extra indent for substatements that start with open-braces.
1708 This is in addition to cperl-continued-statement-offset."
1709   :type 'integer
1710   :group 'cperl-indentation-details)
1711 (defcustom cperl-close-paren-offset -1
1712   "*Extra indent for substatements that start with close-parenthesis."
1713   :type 'integer
1714   :group 'cperl-indentation-details)
1715
1716 (defcustom cperl-indent-wrt-brace t
1717   "*Non-nil means indent statements in if/etc block relative brace, not if/etc.
1718 Versions 5.2 ... 5.20 behaved as if this were `nil'."
1719   :type 'boolean
1720   :group 'cperl-indentation-details)
1721
1722 (defcustom cperl-auto-newline nil
1723   "*Non-nil means automatically newline before and after braces,
1724 and after colons and semicolons, inserted in CPerl code.  The following
1725 \\[cperl-electric-backspace] will remove the inserted whitespace.
1726 Insertion after colons requires both this variable and
1727 `cperl-auto-newline-after-colon' set."
1728   :type 'boolean
1729   :group 'cperl-autoinsert-details)
1730
1731 (defcustom cperl-autoindent-on-semi nil
1732   "*Non-nil means automatically indent after insertion of (semi)colon.
1733 Active if `cperl-auto-newline' is false."
1734   :type 'boolean
1735   :group 'cperl-autoinsert-details)
1736
1737 (defcustom cperl-auto-newline-after-colon nil
1738   "*Non-nil means automatically newline even after colons.
1739 Subject to `cperl-auto-newline' setting."
1740   :type 'boolean
1741   :group 'cperl-autoinsert-details)
1742
1743 (defcustom cperl-tab-always-indent t
1744   "*Non-nil means TAB in CPerl mode should always reindent the current line,
1745 regardless of where in the line point is when the TAB command is used."
1746   :type 'boolean
1747   :group 'cperl-indentation-details)
1748
1749 (defcustom cperl-font-lock nil
1750   "*Non-nil (and non-null) means CPerl buffers will use `font-lock-mode'.
1751 Can be overwritten by `cperl-hairy' if nil."
1752   :type '(choice (const null) boolean)
1753   :group 'cperl-affected-by-hairy)
1754
1755 (defcustom cperl-electric-lbrace-space nil
1756   "*Non-nil (and non-null) means { after $ should be preceded by ` '.
1757 Can be overwritten by `cperl-hairy' if nil."
1758   :type '(choice (const null) boolean)
1759   :group 'cperl-affected-by-hairy)
1760
1761 (defcustom cperl-electric-parens-string "({[]})<"
1762   "*String of parentheses that should be electric in CPerl.
1763 Closing ones are electric only if the region is highlighted."
1764   :type 'string
1765   :group 'cperl-affected-by-hairy)
1766
1767 (defcustom cperl-electric-parens nil
1768   "*Non-nil (and non-null) means parentheses should be electric in CPerl.
1769 Can be overwritten by `cperl-hairy' if nil."
1770   :type '(choice (const null) boolean)
1771   :group 'cperl-affected-by-hairy)
1772
1773 (defvar zmacs-regions)                  ; Avoid warning
1774
1775 (defcustom cperl-electric-parens-mark
1776   (and window-system
1777        (or (and (boundp 'transient-mark-mode) ; For Emacs
1778                 transient-mark-mode)
1779            (and (boundp 'zmacs-regions) ; For XEmacs
1780                 zmacs-regions)))
1781   "*Not-nil means that electric parens look for active mark.
1782 Default is yes if there is visual feedback on mark."
1783   :type 'boolean
1784   :group 'cperl-autoinsert-details)
1785
1786 (defcustom cperl-electric-linefeed nil
1787   "*If true, LFD should be hairy in CPerl, otherwise C-c LFD is hairy.
1788 In any case these two mean plain and hairy linefeeds together.
1789 Can be overwritten by `cperl-hairy' if nil."
1790   :type '(choice (const null) boolean)
1791   :group 'cperl-affected-by-hairy)
1792
1793 (defcustom cperl-electric-keywords nil
1794   "*Not-nil (and non-null) means keywords are electric in CPerl.
1795 Can be overwritten by `cperl-hairy' if nil."
1796   :type '(choice (const null) boolean)
1797   :group 'cperl-affected-by-hairy)
1798
1799 (defcustom cperl-electric-backspace-untabify t
1800   "*Not-nil means electric-backspace will untabify in CPerl."
1801   :type 'boolean
1802   :group 'cperl-autoinsert-details)
1803
1804 (defcustom cperl-hairy nil
1805   "*Not-nil means most of the bells and whistles are enabled in CPerl.
1806 Affects: `cperl-font-lock', `cperl-electric-lbrace-space',
1807 `cperl-electric-parens', `cperl-electric-linefeed', `cperl-electric-keywords',
1808 `cperl-info-on-command-no-prompt', `cperl-clobber-lisp-bindings',
1809 `cperl-lazy-help-time'."
1810   :type 'boolean
1811   :group 'cperl-affected-by-hairy)
1812
1813 (defcustom cperl-comment-column 32
1814   "*Column to put comments in CPerl (use \\[cperl-indent] to lineup with code)."
1815   :type 'integer
1816   :group 'cperl-indentation-details)
1817
1818 (defcustom cperl-indent-comment-at-column-0 nil
1819   "*Non-nil means that comment started at column 0 should be indentable."
1820   :type 'boolean
1821   :group 'cperl-indentation-details)
1822
1823 (defcustom cperl-vc-sccs-header '("($sccs) = ('%W\%' =~ /(\\d+(\\.\\d+)+)/) ;")
1824   "*Special version of `vc-sccs-header' that is used in CPerl mode buffers."
1825   :type '(repeat string)
1826   :group 'cperl)
1827
1828 (defcustom cperl-vc-rcs-header '("($rcs) = (' $Id\$ ' =~ /(\\d+(\\.\\d+)+)/);")
1829   "*Special version of `vc-rcs-header' that is used in CPerl mode buffers."
1830   :type '(repeat string)
1831      :group 'cperl)
1832
1833 ;; This became obsolete...
1834 (defcustom cperl-vc-header-alist '()
1835   "*What to use as `vc-header-alist' in CPerl.
1836 Obsolete, with newer Emacsen use `cperl-vc-rcs-header' or
1837 `cperl-vc-sccs-header' instead.  If this list is empty, `vc-header-alist'
1838 will be reconstructed basing on these two variables."
1839   :type '(repeat (list symbol string))
1840   :group 'cperl)
1841
1842 (defcustom cperl-clobber-mode-lists
1843   (not
1844    (and
1845     (boundp 'interpreter-mode-alist)
1846     (assoc "miniperl" interpreter-mode-alist)
1847     (assoc "\\.\\([pP][Llm]\\|al\\)$" auto-mode-alist)))
1848   "*Whether to install us into `interpreter-' and `extension' mode lists."
1849   :type 'boolean
1850   :group 'cperl)
1851
1852 (defcustom cperl-info-on-command-no-prompt nil
1853   "*Not-nil (and non-null) means not to prompt on C-h f.
1854 The opposite behaviour is always available if prefixed with C-c.
1855 Can be overwritten by `cperl-hairy' if nil."
1856   :type '(choice (const null) boolean)
1857   :group 'cperl-affected-by-hairy)
1858
1859 (defcustom cperl-clobber-lisp-bindings nil
1860   "*Not-nil (and non-null) means not overwrite C-h f.
1861 The function is available on \\[cperl-info-on-command], \\[cperl-get-help].
1862 Can be overwritten by `cperl-hairy' if nil."
1863   :type '(choice (const null) boolean)
1864   :group 'cperl-affected-by-hairy)
1865
1866 (defcustom cperl-lazy-help-time nil
1867   "*Not-nil (and non-null) means to show lazy help after given idle time.
1868 Can be overwritten by `cperl-hairy' to be 5 sec if nil."
1869   :type '(choice (const null) (const nil) integer)
1870   :group 'cperl-affected-by-hairy)
1871
1872 (defcustom cperl-pod-face 'font-lock-comment-face
1873   "*The result of evaluation of this expression is used for POD highlighting."
1874   :type 'face
1875   :group 'cperl-faces)
1876
1877 (defcustom cperl-pod-head-face 'font-lock-variable-name-face
1878   "*The result of evaluation of this expression is used for POD highlighting.
1879 Font for POD headers."
1880   :type 'face
1881   :group 'cperl-faces)
1882
1883 (defcustom cperl-here-face 'font-lock-string-face
1884   "*The result of evaluation of this expression is used for here-docs highlighting."
1885   :type 'face
1886   :group 'cperl-faces)
1887
1888 ;;; Some double-evaluation happened with font-locks...  Needed with 21.2...
1889 (defvar cperl-singly-quote-face cperl-xemacs-p)
1890
1891 (defcustom cperl-invalid-face           ; Does not customize with '' on XEmacs
1892   (if cperl-singly-quote-face
1893       'underline ''underline) ; On older Emacsen was evaluated by `font-lock'
1894   (if cperl-singly-quote-face
1895       "*This face is used for highlighting trailing whitespace."
1896     "*The result of evaluation of this expression highlights trailing whitespace.")
1897   :type 'face
1898   :group 'cperl-faces)
1899
1900 (defcustom cperl-pod-here-fontify '(featurep 'font-lock)
1901   "*Not-nil after evaluation means to highlight POD and here-docs sections."
1902   :type 'boolean
1903   :group 'cperl-faces)
1904
1905 (defcustom cperl-fontify-m-as-s t
1906   "*Not-nil means highlight 1arg regular expressions operators same as 2arg."
1907   :type 'boolean
1908   :group 'cperl-faces)
1909
1910 (defcustom cperl-highlight-variables-indiscriminately nil
1911   "*Non-nil means perform additional highlighting on variables.
1912 Currently only changes how scalar variables are highlighted.
1913 Note that that variable is only read at initialization time for
1914 the variable `perl-font-lock-keywords-2', so changing it after you've
1915 entered CPerl mode the first time will have no effect."
1916   :type 'boolean
1917   :group 'cperl)
1918
1919 (defcustom cperl-pod-here-scan t
1920   "*Not-nil means look for POD and here-docs sections during startup.
1921 You can always make lookup from menu or using \\[cperl-find-pods-heres]."
1922   :type 'boolean
1923   :group 'cperl-speed)
1924
1925 (defcustom cperl-regexp-scan t
1926   "*Not-nil means make marking of regular expression more thorough.
1927 Effective only with `cperl-pod-here-scan'."
1928   :type 'boolean
1929   :group 'cperl-speed)
1930
1931 (defcustom cperl-hook-after-change t
1932   "*Not-nil means install hook to know which regions of buffer are changed.
1933 May significantly speed up delayed fontification.  Changes take effect
1934 after reload."
1935   :type 'boolean
1936   :group 'cperl-speed)
1937
1938 (defcustom cperl-imenu-addback nil
1939   "*Not-nil means add backreferences to generated `imenu's.
1940 May require patched `imenu' and `imenu-go'.  Obsolete."
1941   :type 'boolean
1942   :group 'cperl-help-system)
1943
1944 (defcustom cperl-max-help-size 66
1945   "*Non-nil means shrink-wrapping of info-buffer allowed up to these percents."
1946   :type '(choice integer (const nil))
1947   :group 'cperl-help-system)
1948
1949 (defcustom cperl-shrink-wrap-info-frame t
1950   "*Non-nil means shrink-wrapping of info-buffer-frame allowed."
1951   :type 'boolean
1952   :group 'cperl-help-system)
1953
1954 (defcustom cperl-info-page "perl"
1955   "*Name of the info page containing perl docs.
1956 Older version of this page was called `perl5', newer `perl'."
1957   :type 'string
1958   :group 'cperl-help-system)
1959
1960 (defcustom cperl-use-syntax-table-text-property
1961   (boundp 'parse-sexp-lookup-properties)
1962   "*Non-nil means CPerl sets up and uses `syntax-table' text property."
1963   :type 'boolean
1964   :group 'cperl-speed)
1965
1966 (defcustom cperl-use-syntax-table-text-property-for-tags
1967   cperl-use-syntax-table-text-property
1968   "*Non-nil means: set up and use `syntax-table' text property generating TAGS."
1969   :type 'boolean
1970   :group 'cperl-speed)
1971
1972 (defcustom cperl-scan-files-regexp "\\.\\([pP][Llm]\\|xs\\)$"
1973   "*Regexp to match files to scan when generating TAGS."
1974   :type 'regexp
1975   :group 'cperl)
1976
1977 (defcustom cperl-noscan-files-regexp
1978   "/\\(\\.\\.?\\|SCCS\\|RCS\\|CVS\\|blib\\)$"
1979   "*Regexp to match files/dirs to skip when generating TAGS."
1980   :type 'regexp
1981   :group 'cperl)
1982
1983 (defcustom cperl-regexp-indent-step nil
1984   "*Indentation used when beautifying regexps.
1985 If nil, the value of `cperl-indent-level' will be used."
1986   :type '(choice integer (const nil))
1987   :group 'cperl-indentation-details)
1988
1989 (defcustom cperl-indent-left-aligned-comments t
1990   "*Non-nil means that the comment starting in leftmost column should indent."
1991   :type 'boolean
1992   :group 'cperl-indentation-details)
1993
1994 (defcustom cperl-under-as-char t
1995   "*Non-nil means that the _ (underline) should be treated as word char."
1996   :type 'boolean
1997   :group 'cperl)
1998
1999 (defcustom cperl-extra-perl-args ""
2000   "*Extra arguments to use when starting Perl.
2001 Currently used with `cperl-check-syntax' only."
2002   :type 'string
2003   :group 'cperl)
2004
2005 (defcustom cperl-message-electric-keyword t
2006   "*Non-nil means that the `cperl-electric-keyword' prints a help message."
2007   :type 'boolean
2008   :group 'cperl-help-system)
2009
2010 (defcustom cperl-indent-region-fix-constructs 1
2011   "*Amount of space to insert between `}' and `else' or `elsif'
2012 in `cperl-indent-region'.  Set to nil to leave as is.  Values other
2013 than 1 and nil will probably not work."
2014   :type '(choice (const nil) (const 1))
2015   :group 'cperl-indentation-details)
2016
2017 (defcustom cperl-break-one-line-blocks-when-indent t
2018   "*Non-nil means that one-line if/unless/while/until/for/foreach BLOCKs
2019 need to be reformatted into multiline ones when indenting a region."
2020   :type 'boolean
2021   :group 'cperl-indentation-details)
2022
2023 (defcustom cperl-fix-hanging-brace-when-indent t
2024   "*Non-nil means that BLOCK-end `}' may be put on a separate line
2025 when indenting a region.
2026 Braces followed by else/elsif/while/until are excepted."
2027   :type 'boolean
2028   :group 'cperl-indentation-details)
2029
2030 (defcustom cperl-merge-trailing-else t
2031   "*Non-nil means that BLOCK-end `}' followed by else/elsif/continue
2032 may be merged to be on the same line when indenting a region."
2033   :type 'boolean
2034   :group 'cperl-indentation-details)
2035
2036 (defcustom cperl-indent-parens-as-block nil
2037   "*Non-nil means that non-block ()-, {}- and []-groups are indented as blocks,
2038 but for trailing \",\" inside the group, which won't increase indentation.
2039 One should tune up `cperl-close-paren-offset' as well."
2040   :type 'boolean
2041   :group 'cperl-indentation-details)
2042
2043 (defcustom cperl-syntaxify-by-font-lock
2044   (and cperl-can-font-lock
2045        (boundp 'parse-sexp-lookup-properties))
2046   "*Non-nil means that CPerl uses `font-lock's routines for syntaxification."
2047   :type '(choice (const message) boolean)
2048   :group 'cperl-speed)
2049
2050 (defcustom cperl-syntaxify-unwind
2051   t
2052   "*Non-nil means that CPerl unwinds to a start of a long construction
2053 when syntaxifying a chunk of buffer."
2054   :type 'boolean
2055   :group 'cperl-speed)
2056
2057 (defcustom cperl-syntaxify-for-menu
2058   t
2059   "*Non-nil means that CPerl syntaxifies up to the point before showing menu.
2060 This way enabling/disabling of menu items is more correct."
2061   :type 'boolean
2062   :group 'cperl-speed)
2063
2064 (defcustom cperl-ps-print-face-properties
2065   '((font-lock-keyword-face             nil nil         bold shadow)
2066     (font-lock-variable-name-face       nil nil         bold)
2067     (font-lock-function-name-face       nil nil         bold italic box)
2068     (font-lock-constant-face            nil "LightGray" bold)
2069     (cperl-array-face                   nil "LightGray" bold underline)
2070     (cperl-hash-face                    nil "LightGray" bold italic underline)
2071     (font-lock-comment-face             nil "LightGray" italic)
2072     (font-lock-string-face              nil nil         italic underline)
2073     (cperl-nonoverridable-face          nil nil         italic underline)
2074     (font-lock-type-face                nil nil         underline)
2075     (font-lock-warning-face             nil "LightGray" bold italic box)
2076     (underline                          nil "LightGray" strikeout))
2077   "List given as an argument to `ps-extend-face-list' in `cperl-ps-print'."
2078   :type '(repeat (cons symbol
2079                        (cons (choice (const nil) string)
2080                              (cons (choice (const nil) string)
2081                                    (repeat symbol)))))
2082   :group 'cperl-faces)
2083
2084 (if cperl-can-font-lock
2085     (progn
2086       (defvar cperl-dark-background
2087         (cperl-choose-color "navy" "os2blue" "darkgreen"))
2088       (defvar cperl-dark-foreground
2089         (cperl-choose-color "orchid1" "orange"))
2090
2091       (defface cperl-nonoverridable-face
2092         (` ((((class grayscale) (background light))
2093              (:background "Gray90" :italic t :underline t))
2094             (((class grayscale) (background dark))
2095              (:foreground "Gray80" :italic t :underline t :bold t))
2096             (((class color) (background light))
2097              (:foreground "chartreuse3"))
2098             (((class color) (background dark))
2099              (:foreground (, cperl-dark-foreground)))
2100             (t (:bold t :underline t))))
2101         "Font Lock mode face used to highlight array names."
2102         :group 'cperl-faces)
2103
2104       (defface cperl-array-face
2105         (` ((((class grayscale) (background light))
2106              (:background "Gray90" :bold t))
2107             (((class grayscale) (background dark))
2108              (:foreground "Gray80" :bold t))
2109             (((class color) (background light))
2110              (:foreground "Blue" :background "lightyellow2" :bold t))
2111             (((class color) (background dark))
2112              (:foreground "yellow" :background (, cperl-dark-background) :bold t))
2113             (t (:bold t))))
2114         "Font Lock mode face used to highlight array names."
2115         :group 'cperl-faces)
2116
2117       (defface cperl-hash-face
2118         (` ((((class grayscale) (background light))
2119              (:background "Gray90" :bold t :italic t))
2120             (((class grayscale) (background dark))
2121              (:foreground "Gray80" :bold t :italic t))
2122             (((class color) (background light))
2123              (:foreground "Red" :background "lightyellow2" :bold t :italic t))
2124             (((class color) (background dark))
2125              (:foreground "Red" :background (, cperl-dark-background) :bold t :italic t))
2126             (t (:bold t :italic t))))
2127         "Font Lock mode face used to highlight hash names."
2128         :group 'cperl-faces)))
2129
2130 \f
2131
2132 ;;; Short extra-docs.
2133
2134 (defvar cperl-tips 'please-ignore-this-line
2135   "Get maybe newer version of this package from
2136   http://ilyaz.org/software/emacs
2137 Subdirectory `cperl-mode' may contain yet newer development releases and/or
2138 patches to related files.
2139
2140 For best results apply to an older Emacs the patches from
2141   ftp://ftp.math.ohio-state.edu/pub/users/ilya/cperl-mode/patches
2142 \(this upgrades syntax-parsing abilities of RMS Emaxen v19.34 and
2143 v20.2 up to the level of RMS Emacs v20.3 - a must for a good Perl
2144 mode.)  As of beginning of 2003, XEmacs may provide a similar ability.
2145
2146 Get support packages choose-color.el (or font-lock-extra.el before
2147 19.30), imenu-go.el from the same place.  \(Look for other files there
2148 too... ;-).  Get a patch for imenu.el in 19.29.  Note that for 19.30 and
2149 later you should use choose-color.el *instead* of font-lock-extra.el
2150 \(and you will not get smart highlighting in C :-().
2151
2152 Note that to enable Compile choices in the menu you need to install
2153 mode-compile.el.
2154
2155 If your Emacs does not default to `cperl-mode' on Perl files, and you
2156 want it to: put the following into your .emacs file:
2157
2158   (autoload 'perl-mode \"cperl-mode\" \"alternate mode for editing Perl programs\" t)
2159
2160 or
2161
2162   (defalias 'perl-mode 'cperl-mode)
2163
2164 Get perl5-info from
2165   $CPAN/doc/manual/info/perl5-old/perl5-info.tar.gz
2166 Also, one can generate a newer documentation running `pod2texi' converter
2167   $CPAN/doc/manual/info/perl5/pod2texi-0.1.tar.gz
2168
2169 If you use imenu-go, run imenu on perl5-info buffer (you can do it
2170 from Perl menu).  If many files are related, generate TAGS files from
2171 Tools/Tags submenu in Perl menu.
2172
2173 If some class structure is too complicated, use Tools/Hierarchy-view
2174 from Perl menu, or hierarchic view of imenu.  The second one uses the
2175 current buffer only, the first one requires generation of TAGS from
2176 Perl/Tools/Tags menu beforehand.
2177
2178 Run Perl/Tools/Insert-spaces-if-needed to fix your lazy typing.
2179
2180 Switch auto-help on/off with Perl/Tools/Auto-help.
2181
2182 Though with contemporary Emaxen CPerl mode should maintain the correct
2183 parsing of Perl even when editing, sometimes it may be lost.  Fix this by
2184
2185   M-x norm RET
2186
2187 or
2188
2189   \\[normal-mode]
2190
2191 In cases of more severe confusion sometimes it is helpful to do
2192
2193   M-x load-l RET cperl-mode RET
2194   M-x norm RET
2195
2196 or
2197
2198   \\[load-library] cperl-mode RET
2199   \\[normal-mode]
2200
2201 Before reporting (non-)problems look in the problem section of online
2202 micro-docs on what I know about CPerl problems.")
2203
2204 (defvar cperl-problems 'please-ignore-this-line
2205   "Description of problems in CPerl mode.
2206 Some faces will not be shown on some versions of Emacs unless you
2207 install choose-color.el, available from
2208   http://ilyaz.org/software/emacs
2209
2210 `fill-paragraph' on a comment may leave the point behind the
2211 paragraph.  It also triggers a bug in some versions of Emacs (CPerl tries
2212 to detect it and bulk out).
2213
2214 See documentation of a variable `cperl-problems-old-emaxen' for the
2215 problems which disappear if you upgrade Emacs to a reasonably new
2216 version (20.3 for RMS Emacs, and those of 2004 for XEmacs).")
2217
2218 (defvar cperl-problems-old-emaxen 'please-ignore-this-line
2219   "Description of problems in CPerl mode specific for older Emacs versions.
2220
2221 Emacs had a _very_ restricted syntax parsing engine until RMS's Emacs
2222 20.1.  Most problems below are corrected starting from this version of
2223 Emacs, and all of them should be fixed in RMS's version 20.3.  (Or apply
2224 patches to Emacs 19.33/34 - see tips.)  XEmacs was very backward in
2225 this respect (until 2003).
2226
2227 Note that even with newer Emacsen in some very rare cases the details
2228 of interaction of `font-lock' and syntaxification may be not cleaned
2229 up yet.  You may get slightly different colors basing on the order of
2230 fontification and syntaxification.  Say, the initial faces is correct,
2231 but editing the buffer breaks this.
2232
2233 Even with older Emacsen CPerl mode tries to corrects some Emacs
2234 misunderstandings, however, for efficiency reasons the degree of
2235 correction is different for different operations.  The partially
2236 corrected problems are: POD sections, here-documents, regexps.  The
2237 operations are: highlighting, indentation, electric keywords, electric
2238 braces.
2239
2240 This may be confusing, since the regexp s#//#/#\; may be highlighted
2241 as a comment, but it will be recognized as a regexp by the indentation
2242 code.  Or the opposite case, when a POD section is highlighted, but
2243 may break the indentation of the following code (though indentation
2244 should work if the balance of delimiters is not broken by POD).
2245
2246 The main trick (to make $ a \"backslash\") makes constructions like
2247 ${aaa} look like unbalanced braces.  The only trick I can think of is
2248 to insert it as $ {aaa} (legal in perl5, not in perl4).
2249
2250 Similar problems arise in regexps, when /(\\s|$)/ should be rewritten
2251 as /($|\\s)/.  Note that such a transposition is not always possible.
2252
2253 The solution is to upgrade your Emacs or patch an older one.  Note
2254 that RMS's 20.2 has some bugs related to `syntax-table' text
2255 properties.  Patches are available on the main CPerl download site,
2256 and on CPAN.
2257
2258 If these bugs cannot be fixed on your machine (say, you have an inferior
2259 environment and cannot recompile), you may still disable all the fancy stuff
2260 via `cperl-use-syntax-table-text-property'.")
2261
2262 (defvar cperl-non-problems 'please-ignore-this-line
2263 "As you know from `problems' section, Perl syntax is too hard for CPerl on
2264 older Emacsen.  Here is what you can do if you cannot upgrade, or if
2265 you want to switch off these capabilities on RMS Emacs 20.2 (+patches) or 20.3
2266 or better.  Please skip this docs if you run a capable Emacs already.
2267
2268 Most of the time, if you write your own code, you may find an equivalent
2269 \(and almost as readable) expression (what is discussed below is usually
2270 not relevant on newer Emacsen, since they can do it automatically).
2271
2272 Try to help CPerl: add comments with embedded quotes to fix CPerl
2273 misunderstandings about the end of quotation:
2274
2275 $a='500$';      # ';
2276
2277 You won't need it too often.  The reason: $ \"quotes\" the following
2278 character (this saves a life a lot of times in CPerl), thus due to
2279 Emacs parsing rules it does not consider tick (i.e., ' ) after a
2280 dollar as a closing one, but as a usual character.  This is usually
2281 correct, but not in the above context.
2282
2283 Even with older Emacsen the indentation code is pretty wise.  The only
2284 drawback is that it relied on Emacs parsing to find matching
2285 parentheses.  And Emacs *could not* match parentheses in Perl 100%
2286 correctly.  So
2287         1 if s#//#/#;
2288 would not break indentation, but
2289         1 if ( s#//#/# );
2290 would.  Upgrade.
2291
2292 By similar reasons
2293         s\"abc\"def\";
2294 could confuse CPerl a lot.
2295
2296 If you still get wrong indentation in situation that you think the
2297 code should be able to parse, try:
2298
2299 a) Check what Emacs thinks about balance of your parentheses.
2300 b) Supply the code to me (IZ).
2301
2302 Pods were treated _very_ rudimentally.  Here-documents were not
2303 treated at all (except highlighting and inhibiting indentation).  Upgrade.
2304
2305 To speed up coloring the following compromises exist:
2306    a) sub in $mypackage::sub may be highlighted.
2307    b) -z in [a-z] may be highlighted.
2308    c) if your regexp contains a keyword (like \"s\"), it may be highlighted.
2309
2310
2311 Imenu in 19.31 is broken.  Set `imenu-use-keymap-menu' to t, and remove
2312 `car' before `imenu-choose-buffer-index' in `imenu'.
2313 `imenu-add-to-menubar' in 20.2 is broken.
2314 A lot of things on XEmacs may be broken too, judging by bug reports I
2315 receive.  Note that some releases of XEmacs are better than the others
2316 as far as bugs reports I see are concerned.")
2317
2318 (defvar cperl-praise 'please-ignore-this-line
2319   "Advantages of CPerl mode.
2320
2321 0) It uses the newest `syntax-table' property ;-);
2322
2323 1) It does 99% of Perl syntax correct (as opposed to 80-90% in Perl
2324 mode - but the latter number may have improved too in last years) even
2325 with old Emaxen which do not support `syntax-table' property.
2326
2327 When using `syntax-table' property for syntax assist hints, it should
2328 handle 99.995% of lines correct - or somesuch.  It automatically
2329 updates syntax assist hints when you edit your script.
2330
2331 2) It is generally believed to be \"the most user-friendly Emacs
2332 package\" whatever it may mean (I doubt that the people who say similar
2333 things tried _all_ the rest of Emacs ;-), but this was not a lonely
2334 voice);
2335
2336 3) Everything is customizable, one-by-one or in a big sweep;
2337
2338 4) It has many easily-accessable \"tools\":
2339         a) Can run program, check syntax, start debugger;
2340         b) Can lineup vertically \"middles\" of rows, like `=' in
2341                 a  = b;
2342                 cc = d;
2343         c) Can insert spaces where this impoves readability (in one
2344                 interactive sweep over the buffer);
2345         d) Has support for imenu, including:
2346                 1) Separate unordered list of \"interesting places\";
2347                 2) Separate TOC of POD sections;
2348                 3) Separate list of packages;
2349                 4) Hierarchical view of methods in (sub)packages;
2350                 5) and functions (by the full name - with package);
2351         e) Has an interface to INFO docs for Perl; The interface is
2352                 very flexible, including shrink-wrapping of
2353                 documentation buffer/frame;
2354         f) Has a builtin list of one-line explanations for perl constructs.
2355         g) Can show these explanations if you stay long enough at the
2356                 corresponding place (or on demand);
2357         h) Has an enhanced fontification (using 3 or 4 additional faces
2358                 comparing to font-lock - basically, different
2359                 namespaces in Perl have different colors);
2360         i) Can construct TAGS basing on its knowledge of Perl syntax,
2361                 the standard menu has 6 different way to generate
2362                 TAGS (if \"by directory\", .xs files - with C-language
2363                 bindings - are included in the scan);
2364         j) Can build a hierarchical view of classes (via imenu) basing
2365                 on generated TAGS file;
2366         k) Has electric parentheses, electric newlines, uses Abbrev
2367                 for electric logical constructs
2368                         while () {}
2369                 with different styles of expansion (context sensitive
2370                 to be not so bothering).  Electric parentheses behave
2371                 \"as they should\" in a presence of a visible region.
2372         l) Changes msb.el \"on the fly\" to insert a group \"Perl files\";
2373         m) Can convert from
2374                 if (A) { B }
2375            to
2376                 B if A;
2377
2378         n) Highlights (by user-choice) either 3-delimiters constructs
2379            (such as tr/a/b/), or regular expressions and `y/tr';
2380         o) Highlights trailing whitespace;
2381         p) Is able to manipulate Perl Regular Expressions to ease
2382            conversion to a more readable form.
2383         q) Can ispell POD sections and HERE-DOCs.
2384         r) Understands comments and character classes inside regular
2385            expressions; can find matching () and [] in a regular expression.
2386         s) Allows indentation of //x-style regular expressions;
2387         t) Highlights different symbols in regular expressions according
2388            to their function; much less problems with backslashitis;
2389         u) Allows to find regular expressions which contain interpolated parts.
2390
2391 5) The indentation engine was very smart, but most of tricks may be
2392 not needed anymore with the support for `syntax-table' property.  Has
2393 progress indicator for indentation (with `imenu' loaded).
2394
2395 6) Indent-region improves inline-comments as well; also corrects
2396 whitespace *inside* the conditional/loop constructs.
2397
2398 7) Fill-paragraph correctly handles multi-line comments;
2399
2400 8) Can switch to different indentation styles by one command, and restore
2401 the settings present before the switch.
2402
2403 9) When doing indentation of control constructs, may correct
2404 line-breaks/spacing between elements of the construct.
2405
2406 10) Uses a linear-time algorith for indentation of regions (on Emaxen with
2407 capable syntax engines).
2408
2409 11) Syntax-highlight, indentation, sexp-recognition inside regular expressions.
2410 ")
2411
2412 (defvar cperl-speed 'please-ignore-this-line
2413   "This is an incomplete compendium of what is available in other parts
2414 of CPerl documentation.  (Please inform me if I skept anything.)
2415
2416 There is a perception that CPerl is slower than alternatives.  This part
2417 of documentation is designed to overcome this misconception.
2418
2419 *By default* CPerl tries to enable the most comfortable settings.
2420 From most points of view, correctly working package is infinitely more
2421 comfortable than a non-correctly working one, thus by default CPerl
2422 prefers correctness over speed.  Below is the guide how to change
2423 settings if your preferences are different.
2424
2425 A)  Speed of loading the file.  When loading file, CPerl may perform a
2426 scan which indicates places which cannot be parsed by primitive Emacs
2427 syntax-parsing routines, and marks them up so that either
2428
2429     A1) CPerl may work around these deficiencies (for big chunks, mostly
2430         PODs and HERE-documents), or
2431     A2) On capable Emaxen CPerl will use improved syntax-handlings
2432         which reads mark-up hints directly.
2433
2434     The scan in case A2 is much more comprehensive, thus may be slower.
2435
2436     User can disable syntax-engine-helping scan of A2 by setting
2437        `cperl-use-syntax-table-text-property'
2438     variable to nil (if it is set to t).
2439
2440     One can disable the scan altogether (both A1 and A2) by setting
2441        `cperl-pod-here-scan'
2442     to nil.
2443
2444 B) Speed of editing operations.
2445
2446     One can add a (minor) speedup to editing operations by setting
2447        `cperl-use-syntax-table-text-property'
2448     variable to nil (if it is set to t).  This will disable
2449     syntax-engine-helping scan, thus will make many more Perl
2450     constructs be wrongly recognized by CPerl, thus may lead to
2451     wrongly matched parentheses, wrong indentation, etc.
2452
2453     One can unset `cperl-syntaxify-unwind'.  This might speed up editing
2454     of, say, long POD sections.")
2455
2456 (defvar cperl-tips-faces 'please-ignore-this-line
2457   "CPerl mode uses following faces for highlighting:
2458
2459   `cperl-array-face'            Array names
2460   `cperl-hash-face'             Hash names
2461   `font-lock-comment-face'      Comments, PODs and whatever is considered
2462                                 syntaxically to be not code
2463   `font-lock-constant-face'     HERE-doc delimiters, labels, delimiters of
2464                                 2-arg operators s/y/tr/ or of RExen,
2465   `font-lock-warning-face'      Special-cased m// and s//foo/,
2466   `font-lock-function-name-face' _ as a target of a file tests, file tests,
2467                                 subroutine names at the moment of definition
2468                                 (except those conflicting with Perl operators),
2469                                 package names (when recognized), format names
2470   `font-lock-keyword-face'      Control flow switch constructs, declarators
2471   `cperl-nonoverridable-face'   Non-overridable keywords, modifiers of RExen
2472   `font-lock-string-face'       Strings, qw() constructs, RExen, POD sections,
2473                                 literal parts and the terminator of formats
2474                                 and whatever is syntaxically considered
2475                                 as string literals
2476   `font-lock-type-face'         Overridable keywords
2477   `font-lock-variable-name-face' Variable declarations, indirect array and
2478                                 hash names, POD headers/item names
2479   `cperl-invalid-face'          Trailing whitespace
2480
2481 Note that in several situations the highlighting tries to inform about
2482 possible confusion, such as different colors for function names in
2483 declarations depending on what they (do not) override, or special cases
2484 m// and s/// which do not do what one would expect them to do.
2485
2486 Help with best setup of these faces for printout requested (for each of
2487 the faces: please specify bold, italic, underline, shadow and box.)
2488
2489 In regular expressions (except character classes):
2490   `font-lock-string-face'       \"Normal\" stuff and non-0-length constructs
2491   `font-lock-constant-face':    Delimiters
2492   `font-lock-warning-face'      Special-cased m// and s//foo/,
2493                                 Mismatched closing delimiters, parens
2494                                 we couldn't match, misplaced quantifiers,
2495                                 unrecognized escape sequences
2496   `cperl-nonoverridable-face'   Modifiers, as gism in m/REx/gism
2497   `font-lock-type-face'         POSIX classes inside charclasses,
2498                                 escape sequences with arguments (\x \23 \p \N)
2499                                 and others match-a-char escape sequences
2500   `font-lock-keyword-face'      Capturing parens, and |
2501   `font-lock-function-name-face' Special symbols: $ ^ . [ ] [^ ] (?{ }) (??{ })
2502   `font-lock-builtin-face'      \"Remaining\" 0-length constructs, executable
2503                                 parts of a REx, not-capturing parens
2504   `font-lock-variable-name-face' Interpolated constructs, embedded code
2505   `font-lock-comment-face'      Embedded comments
2506
2507 ")
2508
2509 \f
2510
2511 ;;; Portability stuff:
2512
2513 (defmacro cperl-define-key (emacs-key definition &optional xemacs-key)
2514   (` (define-key cperl-mode-map
2515        (, (if xemacs-key
2516               (` (if cperl-xemacs-p (, xemacs-key) (, emacs-key)))
2517             emacs-key))
2518        (, definition))))
2519
2520 (defvar cperl-del-back-ch
2521   (car (append (where-is-internal 'delete-backward-char)
2522                (where-is-internal 'backward-delete-char-untabify)))
2523   "Character generated by key bound to `delete-backward-char'.")
2524
2525 (and (vectorp cperl-del-back-ch) (= (length cperl-del-back-ch) 1)
2526      (setq cperl-del-back-ch (aref cperl-del-back-ch 0)))
2527
2528 (defun cperl-mark-active () (mark))     ; Avoid undefined warning
2529 (if cperl-xemacs-p
2530     (progn
2531       ;; "Active regions" are on: use region only if active
2532       ;; "Active regions" are off: use region unconditionally
2533       (defun cperl-use-region-p ()
2534         (if zmacs-regions (mark) t)))
2535   (defun cperl-use-region-p ()
2536     (if transient-mark-mode mark-active t))
2537   (defun cperl-mark-active () mark-active))
2538
2539 (defsubst cperl-enable-font-lock ()
2540   cperl-can-font-lock)
2541
2542 (defun cperl-putback-char (c)           ; Emacs 19
2543   (set 'unread-command-events (list c))) ; Avoid undefined warning
2544
2545 (if (boundp 'unread-command-events)
2546     (if cperl-xemacs-p
2547         (defun cperl-putback-char (c)   ; XEmacs >= 19.12
2548           (setq unread-command-events (list (eval '(character-to-event c))))))
2549   (defun cperl-putback-char (c)         ; XEmacs <= 19.11
2550     (set 'unread-command-event (eval '(character-to-event c))))) ; Avoid warnings
2551
2552 (or (fboundp 'uncomment-region)
2553     (defun uncomment-region (beg end)
2554       (interactive "r")
2555       (comment-region beg end -1)))
2556
2557 (defvar cperl-do-not-fontify
2558   (if (string< emacs-version "19.30")
2559       'fontified
2560     'lazy-lock)
2561   "Text property which inhibits refontification.")
2562
2563 (defsubst cperl-put-do-not-fontify (from to &optional post)
2564   ;; If POST, do not do it with postponed fontification
2565   (if (and post cperl-syntaxify-by-font-lock)
2566       nil
2567     (put-text-property (max (point-min) (1- from))
2568                        to cperl-do-not-fontify t)))
2569
2570 (defcustom cperl-mode-hook nil
2571   "Hook run by CPerl mode."
2572   :type 'hook
2573   :group 'cperl)
2574
2575 (defvar cperl-syntax-state nil)
2576 (defvar cperl-syntax-done-to nil)
2577 (defvar cperl-emacs-can-parse (> (length (save-excursion
2578                                            (parse-partial-sexp (point) (point)))) 9))
2579 \f
2580 ;; Make customization possible "in reverse"
2581 (defsubst cperl-val (symbol &optional default hairy)
2582   (cond
2583    ((eq (symbol-value symbol) 'null) default)
2584    (cperl-hairy (or hairy t))
2585    (t (symbol-value symbol))))
2586 \f
2587
2588 (defun cperl-make-indent (column &optional minimum keep)
2589   "Makes indent of the current line the requested amount.
2590 Unless KEEP, removes the old indentation.  Works around a bug in ancient
2591 versions of Emacs."
2592   (let ((prop (get-text-property (point) 'syntax-type)))
2593     (or keep
2594         (delete-horizontal-space))
2595     (indent-to column minimum)
2596     ;; In old versions (e.g., 19.33) `indent-to' would not inherit properties
2597     (and prop
2598          (> (current-column) 0)
2599          (save-excursion
2600            (beginning-of-line)
2601            (or (get-text-property (point) 'syntax-type)
2602                (and (looking-at "\\=[ \t]")
2603                       (put-text-property (point) (match-end 0)
2604                                          'syntax-type prop)))))))
2605
2606 ;;; Probably it is too late to set these guys already, but it can help later:
2607
2608 (and cperl-clobber-mode-lists
2609      (setq auto-mode-alist
2610       (append '(("\\.\\([pP][Llm]\\|al\\)$" . perl-mode))  auto-mode-alist ))
2611      (and (boundp 'interpreter-mode-alist)
2612           (setq interpreter-mode-alist (append interpreter-mode-alist
2613                                                '(("miniperl" . perl-mode))))))
2614 (if (fboundp 'eval-when-compile)
2615     (eval-when-compile
2616       (mapcar (lambda (p)
2617                 (condition-case nil
2618                     (require p)
2619                   (error nil)))
2620               '(imenu easymenu etags timer man info))
2621       (if (fboundp 'ps-extend-face-list)
2622           (defmacro cperl-ps-extend-face-list (arg)
2623             (` (ps-extend-face-list (, arg))))
2624         (defmacro cperl-ps-extend-face-list (arg)
2625           (` (error "This version of Emacs has no `ps-extend-face-list'"))))
2626       ;; Calling `cperl-enable-font-lock' below doesn't compile on XEmacs,
2627       ;; macros instead of defsubsts don't work on Emacs, so we do the
2628       ;; expansion manually.  Any other suggestions?
2629       (if cperl-can-font-lock
2630           (require 'font-lock))
2631       (require 'cl)))
2632
2633 (defvar cperl-mode-abbrev-table nil
2634   "Abbrev table in use in CPerl mode buffers.")
2635
2636 (add-hook 'edit-var-mode-alist '(perl-mode (regexp . "^cperl-")))
2637
2638 (defvar cperl-mode-map () "Keymap used in CPerl mode.")
2639
2640 (if cperl-mode-map nil
2641   (setq cperl-mode-map (make-sparse-keymap))
2642   (cperl-define-key "{" 'cperl-electric-lbrace)
2643   (cperl-define-key "[" 'cperl-electric-paren)
2644   (cperl-define-key "(" 'cperl-electric-paren)
2645   (cperl-define-key "<" 'cperl-electric-paren)
2646   (cperl-define-key "}" 'cperl-electric-brace)
2647   (cperl-define-key "]" 'cperl-electric-rparen)
2648   (cperl-define-key ")" 'cperl-electric-rparen)
2649   (cperl-define-key ";" 'cperl-electric-semi)
2650   (cperl-define-key ":" 'cperl-electric-terminator)
2651   (cperl-define-key "\C-j" 'newline-and-indent)
2652   (cperl-define-key "\C-c\C-j" 'cperl-linefeed)
2653   (cperl-define-key "\C-c\C-t" 'cperl-invert-if-unless)
2654   (cperl-define-key "\C-c\C-a" 'cperl-toggle-auto-newline)
2655   (cperl-define-key "\C-c\C-k" 'cperl-toggle-abbrev)
2656   (cperl-define-key "\C-c\C-w" 'cperl-toggle-construct-fix)
2657   (cperl-define-key "\C-c\C-f" 'auto-fill-mode)
2658   (cperl-define-key "\C-c\C-e" 'cperl-toggle-electric)
2659   (cperl-define-key "\C-c\C-b" 'cperl-find-bad-style)
2660   (cperl-define-key "\C-c\C-p" 'cperl-pod-spell)
2661   (cperl-define-key "\C-c\C-d" 'cperl-here-doc-spell)
2662   (cperl-define-key "\C-c\C-n" 'cperl-narrow-to-here-doc)
2663   (cperl-define-key "\C-c\C-v" 'cperl-next-interpolated-REx)
2664   (cperl-define-key "\C-c\C-x" 'cperl-next-interpolated-REx-0)
2665   (cperl-define-key "\C-c\C-y" 'cperl-next-interpolated-REx-1)
2666   (cperl-define-key "\C-c\C-ha" 'cperl-toggle-autohelp)
2667   (cperl-define-key "\C-c\C-hp" 'cperl-perldoc)
2668   (cperl-define-key "\C-c\C-hP" 'cperl-perldoc-at-point)
2669   (cperl-define-key "\e\C-q" 'cperl-indent-exp) ; Usually not bound
2670   (cperl-define-key [?\C-\M-\|] 'cperl-lineup
2671                     [(control meta |)])
2672   ;;(cperl-define-key "\M-q" 'cperl-fill-paragraph)
2673   ;;(cperl-define-key "\e;" 'cperl-indent-for-comment)
2674   (cperl-define-key "\177" 'cperl-electric-backspace)
2675   (cperl-define-key "\t" 'cperl-indent-command)
2676   ;; don't clobber the backspace binding:
2677   (cperl-define-key "\C-c\C-hF" 'cperl-info-on-command
2678                     [(control c) (control h) F])
2679   (if (cperl-val 'cperl-clobber-lisp-bindings)
2680       (progn
2681         (cperl-define-key "\C-hf"
2682                           ;;(concat (char-to-string help-char) "f") ; does not work
2683                           'cperl-info-on-command
2684                           [(control h) f])
2685         (cperl-define-key "\C-hv"
2686                           ;;(concat (char-to-string help-char) "v") ; does not work
2687                           'cperl-get-help
2688                           [(control h) v])
2689         (cperl-define-key "\C-c\C-hf"
2690                           ;;(concat (char-to-string help-char) "f") ; does not work
2691                           (key-binding "\C-hf")
2692                           [(control c) (control h) f])
2693         (cperl-define-key "\C-c\C-hv"
2694                           ;;(concat (char-to-string help-char) "v") ; does not work
2695                           (key-binding "\C-hv")
2696                           [(control c) (control h) v]))
2697     (cperl-define-key "\C-c\C-hf" 'cperl-info-on-current-command
2698                       [(control c) (control h) f])
2699     (cperl-define-key "\C-c\C-hv"
2700                       ;;(concat (char-to-string help-char) "v") ; does not work
2701                       'cperl-get-help
2702                       [(control c) (control h) v]))
2703   (if (and cperl-xemacs-p
2704            (<= emacs-minor-version 11) (<= emacs-major-version 19))
2705       (progn
2706         ;; substitute-key-definition is usefulness-deenhanced...
2707         ;;;;;(cperl-define-key "\M-q" 'cperl-fill-paragraph)
2708         (cperl-define-key "\e;" 'cperl-indent-for-comment)
2709         (cperl-define-key "\e\C-\\" 'cperl-indent-region))
2710     (or (boundp 'fill-paragraph-function)
2711         (substitute-key-definition
2712          'fill-paragraph 'cperl-fill-paragraph
2713          cperl-mode-map global-map))
2714     (substitute-key-definition
2715      'indent-sexp 'cperl-indent-exp
2716      cperl-mode-map global-map)
2717     (substitute-key-definition
2718      'indent-region 'cperl-indent-region
2719      cperl-mode-map global-map)
2720     (substitute-key-definition
2721      'indent-for-comment 'cperl-indent-for-comment
2722      cperl-mode-map global-map)))
2723
2724 (defvar cperl-menu)
2725 (defvar cperl-lazy-installed)
2726 (defvar cperl-old-style nil)
2727 (condition-case nil
2728     (progn
2729       (require 'easymenu)
2730       (easy-menu-define
2731        cperl-menu cperl-mode-map "Menu for CPerl mode"
2732        '("Perl"
2733          ["Beginning of function" beginning-of-defun t]
2734          ["End of function" end-of-defun t]
2735          ["Mark function" mark-defun t]
2736          ["Indent expression" cperl-indent-exp t]
2737          ["Fill paragraph/comment" cperl-fill-paragraph t]
2738          "----"
2739          ["Line up a construction" cperl-lineup (cperl-use-region-p)]
2740          ["Invert if/unless/while etc" cperl-invert-if-unless t]
2741          ("Regexp"
2742           ["Beautify" cperl-beautify-regexp
2743            cperl-use-syntax-table-text-property]
2744           ["Beautify one level deep" (cperl-beautify-regexp 1)
2745            cperl-use-syntax-table-text-property]
2746           ["Beautify a group" cperl-beautify-level
2747            cperl-use-syntax-table-text-property]
2748           ["Beautify a group one level deep" (cperl-beautify-level 1)
2749            cperl-use-syntax-table-text-property]
2750           ["Contract a group" cperl-contract-level
2751            cperl-use-syntax-table-text-property]
2752           ["Contract groups" cperl-contract-levels
2753            cperl-use-syntax-table-text-property]
2754           "----"
2755           ["Find next interpolated" cperl-next-interpolated-REx 
2756            (next-single-property-change (point-min) 'REx-interpolated)]
2757           ["Find next interpolated (no //o)"
2758            cperl-next-interpolated-REx-0
2759            (or (text-property-any (point-min) (point-max) 'REx-interpolated t)
2760                (text-property-any (point-min) (point-max) 'REx-interpolated 1))]
2761           ["Find next interpolated (neither //o nor whole-REx)"
2762            cperl-next-interpolated-REx-1
2763            (text-property-any (point-min) (point-max) 'REx-interpolated t)])
2764          ["Insert spaces if needed to fix style" cperl-find-bad-style t]
2765          ["Refresh \"hard\" constructions" cperl-find-pods-heres t]
2766          "----"
2767          ["Indent region" cperl-indent-region (cperl-use-region-p)]
2768          ["Comment region" cperl-comment-region (cperl-use-region-p)]
2769          ["Uncomment region" cperl-uncomment-region (cperl-use-region-p)]
2770          "----"
2771          ["Run" mode-compile (fboundp 'mode-compile)]
2772          ["Kill" mode-compile-kill (and (fboundp 'mode-compile-kill)
2773                                         (get-buffer "*compilation*"))]
2774          ["Next error" next-error (get-buffer "*compilation*")]
2775          ["Check syntax" cperl-check-syntax (fboundp 'mode-compile)]
2776          "----"
2777          ["Debugger" cperl-db t]
2778          "----"
2779          ("Tools"
2780           ["Imenu" imenu (fboundp 'imenu)]
2781           ["Imenu on Perl Info" cperl-imenu-on-info (featurep 'imenu)]
2782           "----"
2783           ["Ispell PODs" cperl-pod-spell
2784            ;; Better not to update syntaxification here:
2785            ;; debugging syntaxificatio can be broken by this???
2786            (or
2787             (get-text-property (point-min) 'in-pod)
2788             (< (progn
2789                  (and cperl-syntaxify-for-menu
2790                       (cperl-update-syntaxification (point-max) (point-max)))
2791                  (next-single-property-change (point-min) 'in-pod nil (point-max)))
2792                (point-max)))]
2793           ["Ispell HERE-DOCs" cperl-here-doc-spell
2794            (< (progn
2795                 (and cperl-syntaxify-for-menu
2796                      (cperl-update-syntaxification (point-max) (point-max)))
2797                 (next-single-property-change (point-min) 'here-doc-group nil (point-max)))
2798               (point-max))]
2799           ["Narrow to this HERE-DOC" cperl-narrow-to-here-doc
2800            (eq 'here-doc  (progn
2801                 (and cperl-syntaxify-for-menu
2802                      (cperl-update-syntaxification (point) (point)))
2803                 (get-text-property (point) 'syntax-type)))]
2804           ["Select this HERE-DOC or POD section"
2805            cperl-select-this-pod-or-here-doc
2806            (memq (progn
2807                    (and cperl-syntaxify-for-menu
2808                         (cperl-update-syntaxification (point) (point)))
2809                    (get-text-property (point) 'syntax-type))
2810                  '(here-doc pod))]
2811           "----"
2812           ["CPerl pretty print (exprmntl)" cperl-ps-print
2813            (fboundp 'ps-extend-face-list)]
2814           "----"
2815           ["Syntaxify region" cperl-find-pods-heres-region
2816            (cperl-use-region-p)]
2817           ["Profile syntaxification" cperl-time-fontification t]
2818           ["Debug errors in delayed fontification" cperl-emulate-lazy-lock t]
2819           ["Debug unwind for syntactic scan" cperl-toggle-set-debug-unwind t]
2820           ["Debug backtrace on syntactic scan (BEWARE!!!)"
2821            (cperl-toggle-set-debug-unwind nil t) t]
2822           "----"
2823           ["Class Hierarchy from TAGS" cperl-tags-hier-init t]
2824           ;;["Update classes" (cperl-tags-hier-init t) tags-table-list]
2825           ("Tags"
2826 ;;;          ["Create tags for current file" cperl-etags t]
2827 ;;;          ["Add tags for current file" (cperl-etags t) t]
2828 ;;;          ["Create tags for Perl files in directory" (cperl-etags nil t) t]
2829 ;;;          ["Add tags for Perl files in directory" (cperl-etags t t) t]
2830 ;;;          ["Create tags for Perl files in (sub)directories"
2831 ;;;           (cperl-etags nil 'recursive) t]
2832 ;;;          ["Add tags for Perl files in (sub)directories"
2833 ;;;           (cperl-etags t 'recursive) t])
2834 ;;;; cperl-write-tags (&optional file erase recurse dir inbuffer)
2835            ["Create tags for current file" (cperl-write-tags nil t) t]
2836            ["Add tags for current file" (cperl-write-tags) t]
2837            ["Create tags for Perl files in directory"
2838             (cperl-write-tags nil t nil t) t]
2839            ["Add tags for Perl files in directory"
2840             (cperl-write-tags nil nil nil t) t]
2841            ["Create tags for Perl files in (sub)directories"
2842             (cperl-write-tags nil t t t) t]
2843            ["Add tags for Perl files in (sub)directories"
2844             (cperl-write-tags nil nil t t) t]))
2845          ("Perl docs"
2846           ["Define word at point" imenu-go-find-at-position
2847            (fboundp 'imenu-go-find-at-position)]
2848           ["Help on function" cperl-info-on-command t]
2849           ["Help on function at point" cperl-info-on-current-command t]
2850           ["Help on symbol at point" cperl-get-help t]
2851           ["Perldoc" cperl-perldoc t]
2852           ["Perldoc on word at point" cperl-perldoc-at-point t]
2853           ["View manpage of POD in this file" cperl-build-manpage t]
2854           ["Auto-help on" cperl-lazy-install
2855            (and (fboundp 'run-with-idle-timer)
2856                 (not cperl-lazy-installed))]
2857           ["Auto-help off" cperl-lazy-unstall
2858            (and (fboundp 'run-with-idle-timer)
2859                 cperl-lazy-installed)])
2860          ("Toggle..."
2861           ["Auto newline" cperl-toggle-auto-newline t]
2862           ["Electric parens" cperl-toggle-electric t]
2863           ["Electric keywords" cperl-toggle-abbrev t]
2864           ["Fix whitespace on indent" cperl-toggle-construct-fix t]
2865           ["Auto-help on Perl constructs" cperl-toggle-autohelp t]
2866           ["Auto fill" auto-fill-mode t])
2867          ("Indent styles..."
2868           ["CPerl" (cperl-set-style "CPerl") t]
2869           ["PerlStyle" (cperl-set-style "PerlStyle") t]
2870           ["GNU" (cperl-set-style "GNU") t]
2871           ["C++" (cperl-set-style "C++") t]
2872           ["K&R" (cperl-set-style "K&R") t]
2873           ["BSD" (cperl-set-style "BSD") t]
2874           ["Whitesmith" (cperl-set-style "Whitesmith") t]
2875           ["Memorize Current" (cperl-set-style "Current") t]
2876           ["Memorized" (cperl-set-style-back) cperl-old-style])
2877          ("Micro-docs"
2878           ["Tips" (describe-variable 'cperl-tips) t]
2879           ["Problems" (describe-variable 'cperl-problems) t]
2880           ["Non-problems" (describe-variable 'cperl-non-problems) t]
2881           ["Speed" (describe-variable 'cperl-speed) t]
2882           ["Praise" (describe-variable 'cperl-praise) t]
2883           ["Faces" (describe-variable 'cperl-tips-faces) t]
2884           ["CPerl mode" (describe-function 'cperl-mode) t]
2885           ["CPerl version"
2886            (message "The version of master-file for this CPerl is %s"
2887                     cperl-version) t]))))
2888   (error nil))
2889
2890 (autoload 'c-macro-expand "cmacexp"
2891   "Display the result of expanding all C macros occurring in the region.
2892 The expansion is entirely correct because it uses the C preprocessor."
2893   t)
2894
2895 ;;; These two must be unwound, otherwise take exponential time
2896 (defconst cperl-maybe-white-and-comment-rex "[ \t\n]*\\(#[^\n]*\n[ \t\n]*\\)*"
2897 "Regular expression to match optional whitespace with interpspersed comments.
2898 Should contain exactly one group.")
2899
2900 ;;; This one is tricky to unwind; still very inefficient...
2901 (defconst cperl-white-and-comment-rex "\\([ \t\n]\\|#[^\n]*\n\\)+"
2902 "Regular expression to match whitespace with interpspersed comments.
2903 Should contain exactly one group.")
2904
2905
2906 ;;; Is incorporated in `cperl-imenu--function-name-regexp-perl'
2907 ;;; `cperl-outline-regexp', `defun-prompt-regexp'.
2908 ;;; Details of groups in this may be used in several functions; see comments
2909 ;;; near mentioned above variable(s)...
2910 ;;; sub($$):lvalue{}  sub:lvalue{} Both allowed...
2911 (defsubst cperl-after-sub-regexp (named attr) ; 9 groups without attr...
2912   "Match the text after `sub' in a subroutine declaration.
2913 If NAMED is nil, allows anonymous subroutines.  Matches up to the first \":\"
2914 of attributes (if present), or end of the name or prototype (whatever is
2915 the last)."
2916   (concat                               ; Assume n groups before this...
2917    "\\("                                ; n+1=name-group
2918      cperl-white-and-comment-rex        ; n+2=pre-name
2919      "\\(::[a-zA-Z_0-9:']+\\|[a-zA-Z_'][a-zA-Z_0-9:']*\\)" ; n+3=name
2920    "\\)"                                ; END n+1=name-group
2921    (if named "" "?")
2922    "\\("                                ; n+4=proto-group
2923      cperl-maybe-white-and-comment-rex  ; n+5=pre-proto
2924      "\\(([^()]*)\\)"                   ; n+6=prototype
2925    "\\)?"                               ; END n+4=proto-group
2926    "\\("                                ; n+7=attr-group
2927      cperl-maybe-white-and-comment-rex  ; n+8=pre-attr
2928      "\\("                              ; n+9=start-attr
2929         ":"
2930         (if attr (concat
2931                   "\\("
2932                      cperl-maybe-white-and-comment-rex ; whitespace-comments
2933                      "\\(\\sw\\|_\\)+"  ; attr-name
2934                      ;; attr-arg (1 level of internal parens allowed!)
2935                      "\\((\\(\\\\.\\|[^\\\\()]\\|([^\\\\()]*)\\)*)\\)?"
2936                      "\\("              ; optional : (XXX allows trailing???)
2937                         cperl-maybe-white-and-comment-rex ; whitespace-comments
2938                      ":\\)?"
2939                   "\\)+")
2940           "[^:]")
2941      "\\)"
2942    "\\)?"                               ; END n+6=proto-group
2943    ))
2944
2945 ;;; Details of groups in this are used in `cperl-imenu--create-perl-index'
2946 ;;;  and `cperl-outline-level'.
2947 ;;;; Was: 2=sub|package; now 2=package-group, 5=package-name 8=sub-name (+3)
2948 (defvar cperl-imenu--function-name-regexp-perl
2949   (concat
2950    "^\\("                               ; 1 = all
2951        "\\([ \t]*package"               ; 2 = package-group
2952           "\\("                         ; 3 = package-name-group
2953             cperl-white-and-comment-rex ; 4 = pre-package-name
2954                "\\([a-zA-Z_0-9:']+\\)\\)?\\)" ; 5 = package-name
2955        "\\|"
2956           "[ \t]*sub"
2957           (cperl-after-sub-regexp 'named nil) ; 8=name 11=proto 14=attr-start
2958           cperl-maybe-white-and-comment-rex     ; 15=pre-block
2959    "\\|"
2960      "=head\\([1-4]\\)[ \t]+"           ; 16=level
2961      "\\([^\n]+\\)$"                    ; 17=text
2962    "\\)"))
2963
2964 (defvar cperl-outline-regexp
2965   (concat cperl-imenu--function-name-regexp-perl "\\|" "\\`"))
2966
2967 (defvar cperl-mode-syntax-table nil
2968   "Syntax table in use in CPerl mode buffers.")
2969
2970 (defvar cperl-string-syntax-table nil
2971   "Syntax table in use in CPerl mode string-like chunks.")
2972
2973 (defsubst cperl-1- (p)
2974   (max (point-min) (1- p)))
2975
2976 (defsubst cperl-1+ (p)
2977   (min (point-max) (1+ p)))
2978
2979 (if cperl-mode-syntax-table
2980     ()
2981   (setq cperl-mode-syntax-table (make-syntax-table))
2982   (modify-syntax-entry ?\\ "\\" cperl-mode-syntax-table)
2983   (modify-syntax-entry ?/ "." cperl-mode-syntax-table)
2984   (modify-syntax-entry ?* "." cperl-mode-syntax-table)
2985   (modify-syntax-entry ?+ "." cperl-mode-syntax-table)
2986   (modify-syntax-entry ?- "." cperl-mode-syntax-table)
2987   (modify-syntax-entry ?= "." cperl-mode-syntax-table)
2988   (modify-syntax-entry ?% "." cperl-mode-syntax-table)
2989   (modify-syntax-entry ?< "." cperl-mode-syntax-table)
2990   (modify-syntax-entry ?> "." cperl-mode-syntax-table)
2991   (modify-syntax-entry ?& "." cperl-mode-syntax-table)
2992   (modify-syntax-entry ?$ "\\" cperl-mode-syntax-table)
2993   (modify-syntax-entry ?\n ">" cperl-mode-syntax-table)
2994   (modify-syntax-entry ?# "<" cperl-mode-syntax-table)
2995   (modify-syntax-entry ?' "\"" cperl-mode-syntax-table)
2996   (modify-syntax-entry ?` "\"" cperl-mode-syntax-table)
2997   (if cperl-under-as-char
2998       (modify-syntax-entry ?_ "w" cperl-mode-syntax-table))
2999   (modify-syntax-entry ?: "_" cperl-mode-syntax-table)
3000   (modify-syntax-entry ?| "." cperl-mode-syntax-table)
3001   (setq cperl-string-syntax-table (copy-syntax-table cperl-mode-syntax-table))
3002   (modify-syntax-entry ?$ "." cperl-string-syntax-table)
3003   (modify-syntax-entry ?\{ "." cperl-string-syntax-table)
3004   (modify-syntax-entry ?\} "." cperl-string-syntax-table)
3005   (modify-syntax-entry ?# "." cperl-string-syntax-table)) ; (?# comment )
3006
3007
3008 \f
3009 ;; provide an alias for working with emacs 19.  the perl-mode that comes
3010 ;; with it is really bad, and this lets us seamlessly replace it.
3011 ;;;###autoload
3012 (fset 'perl-mode 'cperl-mode)
3013 (defvar cperl-faces-init nil)
3014 ;; Fix for msb.el
3015 (defvar cperl-msb-fixed nil)
3016 (defvar font-lock-syntactic-keywords)
3017 (defvar perl-font-lock-keywords)
3018 (defvar perl-font-lock-keywords-1)
3019 (defvar perl-font-lock-keywords-2)
3020 (defvar outline-level)
3021 (if (fboundp 'defvaralias)
3022     (let ((f 'defvaralias)) ; Some functions deduce stuff from the mode name...
3023       (funcall f 'cperl-font-lock-keywords   'perl-font-lock-keywords)
3024       (funcall f 'cperl-font-lock-keywords-1 'perl-font-lock-keywords-1)
3025       (funcall f 'cperl-font-lock-keywords-2 'perl-font-lock-keywords-2)))
3026
3027 (defvar cperl-use-major-mode 'perl-mode)
3028 (defvar cperl-font-lock-multiline-start nil)
3029 (defvar cperl-font-lock-multiline nil)
3030 (defvar cperl-compilation-error-regexp-alist nil)
3031 (defvar cperl-font-locking nil)
3032
3033 ;;;###autoload
3034 (defun cperl-mode ()
3035   "Major mode for editing Perl code.
3036 Expression and list commands understand all C brackets.
3037 Tab indents for Perl code.
3038 Paragraphs are separated by blank lines only.
3039 Delete converts tabs to spaces as it moves back.
3040
3041 Various characters in Perl almost always come in pairs: {}, (), [],
3042 sometimes <>.  When the user types the first, she gets the second as
3043 well, with optional special formatting done on {}.  (Disabled by
3044 default.)  You can always quote (with \\[quoted-insert]) the left
3045 \"paren\" to avoid the expansion.  The processing of < is special,
3046 since most the time you mean \"less\".  CPerl mode tries to guess
3047 whether you want to type pair <>, and inserts is if it
3048 appropriate.  You can set `cperl-electric-parens-string' to the string that
3049 contains the parenths from the above list you want to be electrical.
3050 Electricity of parenths is controlled by `cperl-electric-parens'.
3051 You may also set `cperl-electric-parens-mark' to have electric parens
3052 look for active mark and \"embrace\" a region if possible.'
3053
3054 CPerl mode provides expansion of the Perl control constructs:
3055
3056    if, else, elsif, unless, while, until, continue, do,
3057    for, foreach, formy and foreachmy.
3058
3059 and POD directives (Disabled by default, see `cperl-electric-keywords'.)
3060
3061 The user types the keyword immediately followed by a space, which
3062 causes the construct to be expanded, and the point is positioned where
3063 she is most likely to want to be.  eg. when the user types a space
3064 following \"if\" the following appears in the buffer: if () { or if ()
3065 } { } and the cursor is between the parentheses.  The user can then
3066 type some boolean expression within the parens.  Having done that,
3067 typing \\[cperl-linefeed] places you - appropriately indented - on a
3068 new line between the braces (if you typed \\[cperl-linefeed] in a POD
3069 directive line, then appropriate number of new lines is inserted).
3070
3071 If CPerl decides that you want to insert \"English\" style construct like
3072
3073             bite if angry;
3074
3075 it will not do any expansion.  See also help on variable
3076 `cperl-extra-newline-before-brace'.  (Note that one can switch the
3077 help message on expansion by setting `cperl-message-electric-keyword'
3078 to nil.)
3079
3080 \\[cperl-linefeed] is a convenience replacement for typing carriage
3081 return.  It places you in the next line with proper indentation, or if
3082 you type it inside the inline block of control construct, like
3083
3084             foreach (@lines) {print; print}
3085
3086 and you are on a boundary of a statement inside braces, it will
3087 transform the construct into a multiline and will place you into an
3088 appropriately indented blank line.  If you need a usual
3089 `newline-and-indent' behaviour, it is on \\[newline-and-indent],
3090 see documentation on `cperl-electric-linefeed'.
3091
3092 Use \\[cperl-invert-if-unless] to change a construction of the form
3093
3094             if (A) { B }
3095
3096 into
3097
3098             B if A;
3099
3100 \\{cperl-mode-map}
3101
3102 Setting the variable `cperl-font-lock' to t switches on font-lock-mode
3103 \(even with older Emacsen), `cperl-electric-lbrace-space' to t switches
3104 on electric space between $ and {, `cperl-electric-parens-string' is
3105 the string that contains parentheses that should be electric in CPerl
3106 \(see also `cperl-electric-parens-mark' and `cperl-electric-parens'),
3107 setting `cperl-electric-keywords' enables electric expansion of
3108 control structures in CPerl.  `cperl-electric-linefeed' governs which
3109 one of two linefeed behavior is preferable.  You can enable all these
3110 options simultaneously (recommended mode of use) by setting
3111 `cperl-hairy' to t.  In this case you can switch separate options off
3112 by setting them to `null'.  Note that one may undo the extra
3113 whitespace inserted by semis and braces in `auto-newline'-mode by
3114 consequent \\[cperl-electric-backspace].
3115
3116 If your site has perl5 documentation in info format, you can use commands
3117 \\[cperl-info-on-current-command] and \\[cperl-info-on-command] to access it.
3118 These keys run commands `cperl-info-on-current-command' and
3119 `cperl-info-on-command', which one is which is controlled by variable
3120 `cperl-info-on-command-no-prompt' and `cperl-clobber-lisp-bindings'
3121 \(in turn affected by `cperl-hairy').
3122
3123 Even if you have no info-format documentation, short one-liner-style
3124 help is available on \\[cperl-get-help], and one can run perldoc or
3125 man via menu.
3126
3127 It is possible to show this help automatically after some idle time.
3128 This is regulated by variable `cperl-lazy-help-time'.  Default with
3129 `cperl-hairy' (if the value of `cperl-lazy-help-time' is nil) is 5
3130 secs idle time .  It is also possible to switch this on/off from the
3131 menu, or via \\[cperl-toggle-autohelp].  Requires `run-with-idle-timer'.
3132
3133 Use \\[cperl-lineup] to vertically lineup some construction - put the
3134 beginning of the region at the start of construction, and make region
3135 span the needed amount of lines.
3136
3137 Variables `cperl-pod-here-scan', `cperl-pod-here-fontify',
3138 `cperl-pod-face', `cperl-pod-head-face' control processing of POD and
3139 here-docs sections.  With capable Emaxen results of scan are used
3140 for indentation too, otherwise they are used for highlighting only.
3141
3142 Variables controlling indentation style:
3143  `cperl-tab-always-indent'
3144     Non-nil means TAB in CPerl mode should always reindent the current line,
3145     regardless of where in the line point is when the TAB command is used.
3146  `cperl-indent-left-aligned-comments'
3147     Non-nil means that the comment starting in leftmost column should indent.
3148  `cperl-auto-newline'
3149     Non-nil means automatically newline before and after braces,
3150     and after colons and semicolons, inserted in Perl code.  The following
3151     \\[cperl-electric-backspace] will remove the inserted whitespace.
3152     Insertion after colons requires both this variable and
3153     `cperl-auto-newline-after-colon' set.
3154  `cperl-auto-newline-after-colon'
3155     Non-nil means automatically newline even after colons.
3156     Subject to `cperl-auto-newline' setting.
3157  `cperl-indent-level'
3158     Indentation of Perl statements within surrounding block.
3159     The surrounding block's indentation is the indentation
3160     of the line on which the open-brace appears.
3161  `cperl-continued-statement-offset'
3162     Extra indentation given to a substatement, such as the
3163     then-clause of an if, or body of a while, or just a statement continuation.
3164  `cperl-continued-brace-offset'
3165     Extra indentation given to a brace that starts a substatement.
3166     This is in addition to `cperl-continued-statement-offset'.
3167  `cperl-brace-offset'
3168     Extra indentation for line if it starts with an open brace.
3169  `cperl-brace-imaginary-offset'
3170     An open brace following other text is treated as if it the line started
3171     this far to the right of the actual line indentation.
3172  `cperl-label-offset'
3173     Extra indentation for line that is a label.
3174  `cperl-min-label-indent'
3175     Minimal indentation for line that is a label.
3176
3177 Settings for classic indent-styles: K&R BSD=C++ GNU PerlStyle=Whitesmith
3178   `cperl-indent-level'                5   4       2   4
3179   `cperl-brace-offset'                0   0       0   0
3180   `cperl-continued-brace-offset'     -5  -4       0   0
3181   `cperl-label-offset'               -5  -4      -2  -4
3182   `cperl-continued-statement-offset'  5   4       2   4
3183
3184 CPerl knows several indentation styles, and may bulk set the
3185 corresponding variables.  Use \\[cperl-set-style] to do this.  Use
3186 \\[cperl-set-style-back] to restore the memorized preexisting values
3187 \(both available from menu).  See examples in `cperl-style-examples'.
3188
3189 Part of the indentation style is how different parts of if/elsif/else
3190 statements are broken into lines; in CPerl, this is reflected on how
3191 templates for these constructs are created (controlled by
3192 `cperl-extra-newline-before-brace'), and how reflow-logic should treat \"continuation\" blocks of else/elsif/continue, controlled by the same variable,
3193 and by `cperl-extra-newline-before-brace-multiline',
3194 `cperl-merge-trailing-else', `cperl-indent-region-fix-constructs'.
3195
3196 If `cperl-indent-level' is 0, the statement after opening brace in
3197 column 0 is indented on
3198 `cperl-brace-offset'+`cperl-continued-statement-offset'.
3199
3200 Turning on CPerl mode calls the hooks in the variable `cperl-mode-hook'
3201 with no args.
3202
3203 DO NOT FORGET to read micro-docs (available from `Perl' menu)
3204 or as help on variables `cperl-tips', `cperl-problems',
3205 `cperl-non-problems', `cperl-praise', `cperl-speed'."
3206   (interactive)
3207   (kill-all-local-variables)
3208   (use-local-map cperl-mode-map)
3209   (if (cperl-val 'cperl-electric-linefeed)
3210       (progn
3211         (local-set-key "\C-J" 'cperl-linefeed)
3212         (local-set-key "\C-C\C-J" 'newline-and-indent)))
3213   (if (and
3214        (cperl-val 'cperl-clobber-lisp-bindings)
3215        (cperl-val 'cperl-info-on-command-no-prompt))
3216       (progn
3217         ;; don't clobber the backspace binding:
3218         (cperl-define-key "\C-hf" 'cperl-info-on-current-command [(control h) f])
3219         (cperl-define-key "\C-c\C-hf" 'cperl-info-on-command
3220                           [(control c) (control h) f])))
3221   (setq major-mode cperl-use-major-mode)
3222   (setq mode-name "CPerl")
3223   (if (not cperl-mode-abbrev-table)
3224       (let ((prev-a-c abbrevs-changed))
3225         (define-abbrev-table 'cperl-mode-abbrev-table '(
3226                 ("if" "if" cperl-electric-keyword 0)
3227                 ("elsif" "elsif" cperl-electric-keyword 0)
3228                 ("while" "while" cperl-electric-keyword 0)
3229                 ("until" "until" cperl-electric-keyword 0)
3230                 ("unless" "unless" cperl-electric-keyword 0)
3231                 ("else" "else" cperl-electric-else 0)
3232                 ("continue" "continue" cperl-electric-else 0)
3233                 ("for" "for" cperl-electric-keyword 0)
3234                 ("foreach" "foreach" cperl-electric-keyword 0)
3235                 ("formy" "formy" cperl-electric-keyword 0)
3236                 ("foreachmy" "foreachmy" cperl-electric-keyword 0)
3237                 ("do" "do" cperl-electric-keyword 0)
3238                 ("=pod" "=pod" cperl-electric-pod 0)
3239                 ("=over" "=over" cperl-electric-pod 0)
3240                 ("=head1" "=head1" cperl-electric-pod 0)
3241                 ("=head2" "=head2" cperl-electric-pod 0)
3242                 ("pod" "pod" cperl-electric-pod 0)
3243                 ("over" "over" cperl-electric-pod 0)
3244                 ("head1" "head1" cperl-electric-pod 0)
3245                 ("head2" "head2" cperl-electric-pod 0)))
3246         (setq abbrevs-changed prev-a-c)))
3247   (setq local-abbrev-table cperl-mode-abbrev-table)
3248   (if (cperl-val 'cperl-electric-keywords)
3249       (abbrev-mode 1))
3250   (set-syntax-table cperl-mode-syntax-table)
3251   ;; Until Emacs is multi-threaded, we do not actually need it local:
3252   (make-local-variable 'cperl-font-lock-multiline-start)
3253   (make-local-variable 'cperl-font-locking)
3254   (make-local-variable 'outline-regexp)
3255   ;; (setq outline-regexp imenu-example--function-name-regexp-perl)
3256   (setq outline-regexp cperl-outline-regexp)
3257   (make-local-variable 'outline-level)
3258   (setq outline-level 'cperl-outline-level)
3259   (make-local-variable 'paragraph-start)
3260   (setq paragraph-start (concat "^$\\|" page-delimiter))
3261   (make-local-variable 'paragraph-separate)
3262   (setq paragraph-separate paragraph-start)
3263   (make-local-variable 'paragraph-ignore-fill-prefix)
3264   (setq paragraph-ignore-fill-prefix t)
3265   (if cperl-xemacs-p
3266     (progn
3267       (make-local-variable 'paren-backwards-message)
3268       (set 'paren-backwards-message t)))
3269   (make-local-variable 'indent-line-function)
3270   (setq indent-line-function 'cperl-indent-line)
3271   (make-local-variable 'require-final-newline)
3272   (setq require-final-newline t)
3273   (make-local-variable 'comment-start)
3274   (setq comment-start "# ")
3275   (make-local-variable 'comment-end)
3276   (setq comment-end "")
3277   (make-local-variable 'comment-column)
3278   (setq comment-column cperl-comment-column)
3279   (make-local-variable 'comment-start-skip)
3280   (setq comment-start-skip "#+ *")
3281   (make-local-variable 'defun-prompt-regexp)
3282 ;;;       "[ \t]*sub"
3283 ;;;       (cperl-after-sub-regexp 'named nil) ; 8=name 11=proto 14=attr-start
3284 ;;;       cperl-maybe-white-and-comment-rex     ; 15=pre-block
3285   (setq defun-prompt-regexp
3286         (concat "[ \t]*\\(sub"
3287                 (cperl-after-sub-regexp 'named 'attr-groups)
3288                 "\\|"                   ; per toke.c
3289                 "\\(BEGIN\\|CHECK\\|INIT\\|END\\|AUTOLOAD\\|DESTROY\\)"
3290                 "\\)"
3291                 cperl-maybe-white-and-comment-rex))
3292   (make-local-variable 'comment-indent-function)
3293   (setq comment-indent-function 'cperl-comment-indent)
3294   (and (boundp 'fill-paragraph-function)
3295       (progn
3296         (make-local-variable 'fill-paragraph-function)
3297         (set 'fill-paragraph-function 'cperl-fill-paragraph)))
3298   (make-local-variable 'parse-sexp-ignore-comments)
3299   (setq parse-sexp-ignore-comments t)
3300   (make-local-variable 'indent-region-function)
3301   (setq indent-region-function 'cperl-indent-region)
3302   ;;(setq auto-fill-function 'cperl-do-auto-fill) ; Need to switch on and off!
3303   (make-local-variable 'imenu-create-index-function)
3304   (setq imenu-create-index-function
3305         (function cperl-imenu--create-perl-index))
3306   (make-local-variable 'imenu-sort-function)
3307   (setq imenu-sort-function nil)
3308   (make-local-variable 'vc-rcs-header)
3309   (set 'vc-rcs-header cperl-vc-rcs-header)
3310   (make-local-variable 'vc-sccs-header)
3311   (set 'vc-sccs-header cperl-vc-sccs-header)
3312   ;; This one is obsolete...
3313   (make-local-variable 'vc-header-alist)
3314   (set 'vc-header-alist (or cperl-vc-header-alist ; Avoid warning
3315                             (` ((SCCS (, (car cperl-vc-sccs-header)))
3316                                      (RCS (, (car cperl-vc-rcs-header)))))))
3317   (cond ((boundp 'compilation-error-regexp-alist-alist);; xemacs 20.x
3318          (make-local-variable 'compilation-error-regexp-alist-alist)
3319          (set 'compilation-error-regexp-alist-alist
3320               (cons (cons 'cperl cperl-compilation-error-regexp-alist)
3321                     (symbol-value 'compilation-error-regexp-alist-alist)))
3322          (let ((f 'compilation-build-compilation-error-regexp-alist))
3323            (funcall f)))
3324         ((boundp 'compilation-error-regexp-alist);; xmeacs 19.x
3325          (make-local-variable 'compilation-error-regexp-alist)
3326          (set 'compilation-error-regexp-alist
3327                (cons cperl-compilation-error-regexp-alist
3328                      (symbol-value 'compilation-error-regexp-alist)))))
3329   (make-local-variable 'font-lock-defaults)
3330   (setq font-lock-defaults
3331         (cond
3332          ((string< emacs-version "19.30")
3333           '(perl-font-lock-keywords-2 nil nil ((?_ . "w"))))
3334          ((string< emacs-version "19.33") ; Which one to use?
3335           '((perl-font-lock-keywords
3336              perl-font-lock-keywords-1
3337              perl-font-lock-keywords-2) nil nil ((?_ . "w"))))
3338          (t
3339           '((cperl-load-font-lock-keywords
3340              cperl-load-font-lock-keywords-1
3341              cperl-load-font-lock-keywords-2) nil nil ((?_ . "w"))))))
3342   (make-local-variable 'cperl-syntax-state)
3343   (setq cperl-syntax-state nil)         ; reset syntaxification cache
3344   (if cperl-use-syntax-table-text-property
3345       (progn
3346         (make-local-variable 'parse-sexp-lookup-properties)
3347         ;; Do not introduce variable if not needed, we check it!
3348         (set 'parse-sexp-lookup-properties t)
3349         ;; Fix broken font-lock:
3350         (or (boundp 'font-lock-unfontify-region-function)
3351             (set 'font-lock-unfontify-region-function
3352                  'font-lock-default-unfontify-region))
3353         (unless cperl-xemacs-p          ; Our: just a plug for wrong font-lock
3354           (make-local-variable 'font-lock-unfontify-region-function)
3355           (set 'font-lock-unfontify-region-function ; not present with old Emacs
3356                'cperl-font-lock-unfontify-region-function))
3357         (make-local-variable 'cperl-syntax-done-to)
3358         (setq cperl-syntax-done-to nil) ; reset syntaxification cache
3359         ;; Another bug: unless font-lock-syntactic-keywords, font-lock
3360         ;;  ignores syntax-table text-property.  (t) is a hack
3361         ;;  to make font-lock think that font-lock-syntactic-keywords
3362         ;;  are defined
3363         (make-local-variable 'font-lock-syntactic-keywords)
3364         (setq font-lock-syntactic-keywords
3365               (if cperl-syntaxify-by-font-lock
3366                   '(t (cperl-fontify-syntaxically))
3367                 '(t)))))
3368   (if (boundp 'font-lock-multiline)     ; Newer font-lock; use its facilities
3369       (progn
3370         (setq cperl-font-lock-multiline t) ; Not localized...
3371         (set (make-local-variable 'font-lock-multiline) t))
3372     (make-local-variable 'font-lock-fontify-region-function)
3373     (set 'font-lock-fontify-region-function ; not present with old Emacs
3374          'cperl-font-lock-fontify-region-function))
3375   (make-local-variable 'font-lock-fontify-region-function)
3376   (set 'font-lock-fontify-region-function ; not present with old Emacs
3377        'cperl-font-lock-fontify-region-function)
3378   (make-local-variable 'cperl-old-style)
3379   (if (boundp 'normal-auto-fill-function) ; 19.33 and later
3380       (set (make-local-variable 'normal-auto-fill-function)
3381            'cperl-do-auto-fill)       ; RMS has it as #'cperl-do-auto-fill ???
3382     (or (fboundp 'cperl-old-auto-fill-mode)
3383         (progn
3384           (fset 'cperl-old-auto-fill-mode (symbol-function 'auto-fill-mode))
3385           (defun auto-fill-mode (&optional arg)
3386             (interactive "P")
3387             (eval '(cperl-old-auto-fill-mode arg)) ; Avoid a warning
3388             (and auto-fill-function (memq major-mode '(perl-mode cperl-mode))
3389                  (setq auto-fill-function 'cperl-do-auto-fill))))))
3390   (if (cperl-enable-font-lock)
3391       (if (cperl-val 'cperl-font-lock)
3392           (progn (or cperl-faces-init (cperl-init-faces))
3393                  (font-lock-mode 1))))
3394   (set (make-local-variable 'facemenu-add-face-function)
3395        'cperl-facemenu-add-face-function) ; XXXX What this guy is for???
3396   (and (boundp 'msb-menu-cond)
3397        (not cperl-msb-fixed)
3398        (cperl-msb-fix))
3399   (if (featurep 'easymenu)
3400       (easy-menu-add cperl-menu))       ; A NOP in RMS Emacs.
3401   (run-hooks 'cperl-mode-hook)
3402   (if cperl-hook-after-change
3403       (progn
3404         (make-local-hook 'after-change-functions)
3405         (add-hook 'after-change-functions 'cperl-after-change-function nil t)))
3406   ;; After hooks since fontification will break this
3407   (if cperl-pod-here-scan
3408       (or cperl-syntaxify-by-font-lock
3409        (progn (or cperl-faces-init (cperl-init-faces-weak))
3410               (cperl-find-pods-heres)))))
3411 \f
3412 ;; Fix for perldb - make default reasonable
3413 (defun cperl-db ()
3414   (interactive)
3415   (require 'gud)
3416   (perldb (read-from-minibuffer "Run perldb (like this): "
3417                                 (if (consp gud-perldb-history)
3418                                     (car gud-perldb-history)
3419                                   (concat "perl " ;;(file-name-nondirectory
3420                                           ;; I have problems
3421                                           ;; in OS/2
3422                                           ;; otherwise
3423                                           (buffer-file-name)))
3424                                 nil nil
3425                                 '(gud-perldb-history . 1))))
3426 \f
3427 (defun cperl-msb-fix ()
3428   ;; Adds perl files to msb menu, supposes that msb is already loaded
3429   (setq cperl-msb-fixed t)
3430   (let* ((l (length msb-menu-cond))
3431          (last (nth (1- l) msb-menu-cond))
3432          (precdr (nthcdr (- l 2) msb-menu-cond)) ; cdr of this is last
3433          (handle (1- (nth 1 last))))
3434     (setcdr precdr (list
3435                     (list
3436                      '(memq major-mode '(cperl-mode perl-mode))
3437                      handle
3438                      "Perl Files (%d)")
3439                     last))))
3440 \f
3441 ;; This is used by indent-for-comment
3442 ;; to decide how much to indent a comment in CPerl code
3443 ;; based on its context.  Do fallback if comment is found wrong.
3444
3445 (defvar cperl-wrong-comment)
3446 (defvar cperl-st-cfence '(14))          ; Comment-fence
3447 (defvar cperl-st-sfence '(15))          ; String-fence
3448 (defvar cperl-st-punct '(1))
3449 (defvar cperl-st-word '(2))
3450 (defvar cperl-st-bra '(4 . ?\>))
3451 (defvar cperl-st-ket '(5 . ?\<))
3452
3453
3454 (defun cperl-comment-indent ()          ; called at point at supposed comment
3455   (let ((p (point)) (c (current-column)) was phony)
3456     (if (and (not cperl-indent-comment-at-column-0)
3457              (looking-at "^#"))
3458         0       ; Existing comment at bol stays there.
3459       ;; Wrong comment found
3460       (save-excursion
3461         (setq was (cperl-to-comment-or-eol)
3462               phony (eq (get-text-property (point) 'syntax-table)
3463                         cperl-st-cfence))
3464         (if phony
3465             (progn                      ; Too naive???
3466               (re-search-forward "#\\|$") ; Hmm, what about embedded #?
3467               (if (eq (preceding-char) ?\#)
3468                   (forward-char -1))
3469               (setq was nil)))
3470         (if (= (point) p)               ; Our caller found a correct place
3471             (progn
3472               (skip-chars-backward " \t")
3473               (setq was (current-column))
3474               (if (eq was 0)
3475                   comment-column
3476                 (max (1+ was) ; Else indent at comment column
3477                      comment-column)))
3478           ;; No, the caller found a random place; we need to edit ourselves
3479           (if was nil
3480             (insert comment-start)
3481             (backward-char (length comment-start)))
3482           (setq cperl-wrong-comment t)
3483           (cperl-make-indent comment-column 1) ; Indent min 1
3484           c)))))
3485
3486 ;;;(defun cperl-comment-indent-fallback ()
3487 ;;;  "Is called if the standard comment-search procedure fails.
3488 ;;;Point is at start of real comment."
3489 ;;;  (let ((c (current-column)) target cnt prevc)
3490 ;;;    (if (= c comment-column) nil
3491 ;;;      (setq cnt (skip-chars-backward "[ \t]"))
3492 ;;;      (setq target (max (1+ (setq prevc
3493 ;;;                          (current-column))) ; Else indent at comment column
3494 ;;;                comment-column))
3495 ;;;      (if (= c comment-column) nil
3496 ;;;     (delete-backward-char cnt)
3497 ;;;     (while (< prevc target)
3498 ;;;       (insert "\t")
3499 ;;;       (setq prevc (current-column)))
3500 ;;;     (if (> prevc target) (progn (delete-char -1) (setq prevc (current-column))))
3501 ;;;     (while (< prevc target)
3502 ;;;       (insert " ")
3503 ;;;       (setq prevc (current-column)))))))
3504
3505 (defun cperl-indent-for-comment ()
3506   "Substitute for `indent-for-comment' in CPerl."
3507   (interactive)
3508   (let (cperl-wrong-comment)
3509     (indent-for-comment)
3510     (if cperl-wrong-comment             ; set by `cperl-comment-indent'
3511         (progn (cperl-to-comment-or-eol)
3512                (forward-char (length comment-start))))))
3513
3514 (defun cperl-comment-region (b e arg)
3515   "Comment or uncomment each line in the region in CPerl mode.
3516 See `comment-region'."
3517   (interactive "r\np")
3518   (let ((comment-start "#"))
3519     (comment-region b e arg)))
3520
3521 (defun cperl-uncomment-region (b e arg)
3522   "Uncomment or comment each line in the region in CPerl mode.
3523 See `comment-region'."
3524   (interactive "r\np")
3525   (let ((comment-start "#"))
3526     (comment-region b e (- arg))))
3527
3528 (defvar cperl-brace-recursing nil)
3529
3530 (defun cperl-electric-brace (arg &optional only-before)
3531   "Insert character and correct line's indentation.
3532 If ONLY-BEFORE and `cperl-auto-newline', will insert newline before the
3533 place (even in empty line), but not after.  If after \")\" and the inserted
3534 char is \"{\", insert extra newline before only if
3535 `cperl-extra-newline-before-brace'."
3536   (interactive "P")
3537   (let (insertpos
3538         (other-end (if (and cperl-electric-parens-mark
3539                             (cperl-mark-active)
3540                             (< (mark) (point)))
3541                        (mark)
3542                      nil)))
3543     (if (and other-end
3544              (not cperl-brace-recursing)
3545              (cperl-val 'cperl-electric-parens)
3546              (>= (save-excursion (cperl-to-comment-or-eol) (point)) (point)))
3547         ;; Need to insert a matching pair
3548         (progn
3549           (save-excursion
3550             (setq insertpos (point-marker))
3551             (goto-char other-end)
3552             (setq last-command-char ?\{)
3553             (cperl-electric-lbrace arg insertpos))
3554           (forward-char 1))
3555       ;; Check whether we close something "usual" with `}'
3556       (if (and (eq last-command-char ?\})
3557                (not
3558                 (condition-case nil
3559                     (save-excursion
3560                       (up-list (- (prefix-numeric-value arg)))
3561                       ;;(cperl-after-block-p (point-min))
3562                       (or (cperl-after-expr-p nil "{;)")
3563                           ;; after sub, else, continue
3564                           (cperl-after-block-p nil 'pre)))
3565                   (error nil))))
3566           ;; Just insert the guy
3567           (self-insert-command (prefix-numeric-value arg))
3568         (if (and (not arg)              ; No args, end (of empty line or auto)
3569                  (eolp)
3570                  (or (and (null only-before)
3571                           (save-excursion
3572                             (skip-chars-backward " \t")
3573                             (bolp)))
3574                      (and (eq last-command-char ?\{) ; Do not insert newline
3575                           ;; if after ")" and `cperl-extra-newline-before-brace'
3576                           ;; is nil, do not insert extra newline.
3577                           (not cperl-extra-newline-before-brace)
3578                           (save-excursion
3579                             (skip-chars-backward " \t")
3580                             (eq (preceding-char) ?\))))
3581                      (if cperl-auto-newline
3582                          (progn (cperl-indent-line) (newline) t) nil)))
3583             (progn
3584               (self-insert-command (prefix-numeric-value arg))
3585               (cperl-indent-line)
3586               (if cperl-auto-newline
3587                   (setq insertpos (1- (point))))
3588               (if (and cperl-auto-newline (null only-before))
3589                   (progn
3590                     (newline)
3591                     (cperl-indent-line)))
3592               (save-excursion
3593                 (if insertpos (progn (goto-char insertpos)
3594                                      (search-forward (make-string
3595                                                       1 last-command-char))
3596                                      (setq insertpos (1- (point)))))
3597                 (delete-char -1))))
3598         (if insertpos
3599             (save-excursion
3600               (goto-char insertpos)
3601               (self-insert-command (prefix-numeric-value arg)))
3602           (self-insert-command (prefix-numeric-value arg)))))))
3603
3604 (defun cperl-electric-lbrace (arg &optional end)
3605   "Insert character, correct line's indentation, correct quoting by space."
3606   (interactive "P")
3607   (let ((cperl-brace-recursing t)
3608         (cperl-auto-newline cperl-auto-newline)
3609         (other-end (or end
3610                        (if (and cperl-electric-parens-mark
3611                                 (cperl-mark-active)
3612                                 (> (mark) (point)))
3613                            (save-excursion
3614                              (goto-char (mark))
3615                              (point-marker))
3616                          nil)))
3617         pos after)
3618     (and (cperl-val 'cperl-electric-lbrace-space)
3619          (eq (preceding-char) ?$)
3620          (save-excursion
3621            (skip-chars-backward "$")
3622            (looking-at "\\(\\$\\$\\)*\\$\\([^\\$]\\|$\\)"))
3623          (insert ?\ ))
3624     ;; Check whether we are in comment
3625     (if (and
3626          (save-excursion
3627            (beginning-of-line)
3628            (not (looking-at "[ \t]*#")))
3629          (cperl-after-expr-p nil "{;)"))
3630         nil
3631       (setq cperl-auto-newline nil))
3632     (cperl-electric-brace arg)
3633     (and (cperl-val 'cperl-electric-parens)
3634          (eq last-command-char ?{)
3635          (memq last-command-char
3636                (append cperl-electric-parens-string nil))
3637          (or (if other-end (goto-char (marker-position other-end)))
3638              t)
3639          (setq last-command-char ?} pos (point))
3640          (progn (cperl-electric-brace arg t)
3641                 (goto-char pos)))))
3642
3643 (defun cperl-electric-paren (arg)
3644   "Insert an opening parenthesis or a matching pair of parentheses.
3645 See `cperl-electric-parens'."
3646   (interactive "P")
3647   (let ((beg (save-excursion (beginning-of-line) (point)))
3648         (other-end (if (and cperl-electric-parens-mark
3649                             (cperl-mark-active)
3650                             (> (mark) (point)))
3651                        (save-excursion
3652                          (goto-char (mark))
3653                          (point-marker))
3654                      nil)))
3655     (if (and (cperl-val 'cperl-electric-parens)
3656              (memq last-command-char
3657                    (append cperl-electric-parens-string nil))
3658              (>= (save-excursion (cperl-to-comment-or-eol) (point)) (point))
3659              ;;(not (save-excursion (search-backward "#" beg t)))
3660              (if (eq last-command-char ?<)
3661                  (progn
3662                    (and abbrev-mode ; later it is too late, may be after `for'
3663                         (expand-abbrev))
3664                    (cperl-after-expr-p nil "{;(,:="))
3665                1))
3666         (progn
3667           (self-insert-command (prefix-numeric-value arg))
3668           (if other-end (goto-char (marker-position other-end)))
3669           (insert (make-string
3670                    (prefix-numeric-value arg)
3671                    (cdr (assoc last-command-char '((?{ .?})
3672                                                    (?[ . ?])
3673                                                    (?( . ?))
3674                                                    (?< . ?>))))))
3675           (forward-char (- (prefix-numeric-value arg))))
3676       (self-insert-command (prefix-numeric-value arg)))))
3677
3678 (defun cperl-electric-rparen (arg)
3679   "Insert a matching pair of parentheses if marking is active.
3680 If not, or if we are not at the end of marking range, would self-insert.
3681 Affected by `cperl-electric-parens'."
3682   (interactive "P")
3683   (let ((beg (save-excursion (beginning-of-line) (point)))
3684         (other-end (if (and cperl-electric-parens-mark
3685                             (cperl-val 'cperl-electric-parens)
3686                             (memq last-command-char
3687                                   (append cperl-electric-parens-string nil))
3688                             (cperl-mark-active)
3689                             (< (mark) (point)))
3690                        (mark)
3691                      nil))
3692         p)
3693     (if (and other-end
3694              (cperl-val 'cperl-electric-parens)
3695              (memq last-command-char '( ?\) ?\] ?\} ?\> ))
3696              (>= (save-excursion (cperl-to-comment-or-eol) (point)) (point))
3697              ;;(not (save-excursion (search-backward "#" beg t)))
3698              )
3699         (progn
3700           (self-insert-command (prefix-numeric-value arg))
3701           (setq p (point))
3702           (if other-end (goto-char other-end))
3703           (insert (make-string
3704                    (prefix-numeric-value arg)
3705                    (cdr (assoc last-command-char '((?\} . ?\{)
3706                                                    (?\] . ?\[)
3707                                                    (?\) . ?\()
3708                                                    (?\> . ?\<))))))
3709           (goto-char (1+ p)))
3710       (self-insert-command (prefix-numeric-value arg)))))
3711
3712 (defun cperl-electric-keyword ()
3713   "Insert a construction appropriate after a keyword.
3714 Help message may be switched off by setting `cperl-message-electric-keyword'
3715 to nil."
3716   (let ((beg (save-excursion (beginning-of-line) (point)))
3717         (dollar (and (eq last-command-char ?$)
3718                      (eq this-command 'self-insert-command)))
3719         (delete (and (memq last-command-char '(?\ ?\n ?\t ?\f))
3720                      (memq this-command '(self-insert-command newline))))
3721         my do)
3722     (and (save-excursion
3723            (condition-case nil
3724                (progn
3725                  (backward-sexp 1)
3726                  (setq do (looking-at "do\\>")))
3727              (error nil))
3728            (cperl-after-expr-p nil "{;:"))
3729          (save-excursion
3730            (not
3731             (re-search-backward
3732              "[#\"'`]\\|\\<q\\(\\|[wqxr]\\)\\>"
3733              beg t)))
3734          (save-excursion (or (not (re-search-backward "^=" nil t))
3735                              (or
3736                               (looking-at "=cut")
3737                               (and cperl-use-syntax-table-text-property
3738                                    (not (eq (get-text-property (point)
3739                                                                'syntax-type)
3740                                             'pod))))))
3741          (save-excursion (forward-sexp -1)
3742                          (not (memq (following-char) (append "$@%&*" nil))))
3743          (progn
3744            (and (eq (preceding-char) ?y)
3745                 (progn                  ; "foreachmy"
3746                   (forward-char -2)
3747                   (insert " ")
3748                   (forward-char 2)
3749                   (setq my t dollar t
3750                         delete
3751                         (memq this-command '(self-insert-command newline)))))
3752            (and dollar (insert " $"))
3753            (cperl-indent-line)
3754            ;;(insert " () {\n}")
3755            (cond
3756             (cperl-extra-newline-before-brace
3757              (insert (if do "\n" " ()\n"))
3758              (insert "{")
3759              (cperl-indent-line)
3760              (insert "\n")
3761              (cperl-indent-line)
3762              (insert "\n}")
3763              (and do (insert " while ();")))
3764             (t
3765              (insert (if do " {\n} while ();" " () {\n}"))))
3766            (or (looking-at "[ \t]\\|$") (insert " "))
3767            (cperl-indent-line)
3768            (if dollar (progn (search-backward "$")
3769                              (if my
3770                                  (forward-char 1)
3771                                (delete-char 1)))
3772              (search-backward ")")
3773              (if (eq last-command-char ?\()
3774                  (progn                 ; Avoid "if (())"
3775                    (delete-backward-char 1)
3776                    (delete-backward-char -1))))
3777            (if delete
3778                (cperl-putback-char cperl-del-back-ch))
3779            (if cperl-message-electric-keyword
3780                (message "Precede char by C-q to avoid expansion"))))))
3781
3782 (defun cperl-ensure-newlines (n &optional pos)
3783   "Make sure there are N newlines after the point."
3784   (or pos (setq pos (point)))
3785   (if (looking-at "\n")
3786       (forward-char 1)
3787     (insert "\n"))
3788   (if (> n 1)
3789       (cperl-ensure-newlines (1- n) pos)
3790     (goto-char pos)))
3791
3792 (defun cperl-electric-pod ()
3793   "Insert a POD chunk appropriate after a =POD directive."
3794   (let ((delete (and (memq last-command-char '(?\ ?\n ?\t ?\f))
3795                      (memq this-command '(self-insert-command newline))))
3796         head1 notlast name p really-delete over)
3797     (and (save-excursion
3798            (forward-word -1)
3799            (and
3800             (eq (preceding-char) ?=)
3801             (progn
3802               (setq head1 (looking-at "head1\\>[ \t]*$"))
3803               (setq over (and (looking-at "over\\>[ \t]*$")
3804                               (not (looking-at "over[ \t]*\n\n\n*=item\\>"))))
3805               (forward-char -1)
3806               (bolp))
3807             (or
3808              (get-text-property (point) 'in-pod)
3809              (cperl-after-expr-p nil "{;:")
3810              (and (re-search-backward "\\(\\`\n?\\|^\n\\)=\\sw+" (point-min) t)
3811                   (not (looking-at "\n*=cut"))
3812                   (or (not cperl-use-syntax-table-text-property)
3813                       (eq (get-text-property (point) 'syntax-type) 'pod))))))
3814          (progn
3815            (save-excursion
3816              (setq notlast (re-search-forward "^\n=" nil t)))
3817            (or notlast
3818                (progn
3819                  (insert "\n\n=cut")
3820                  (cperl-ensure-newlines 2)
3821                  (forward-word -2)
3822                  (if (and head1
3823                           (not
3824                            (save-excursion
3825                              (forward-char -1)
3826                              (re-search-backward "\\(\\`\n?\\|\n\n\\)=head1\\>"
3827                                                  nil t)))) ; Only one
3828                      (progn
3829                        (forward-word 1)
3830                        (setq name (file-name-sans-extension
3831                                    (file-name-nondirectory (buffer-file-name)))
3832                              p (point))
3833                        (insert " NAME\n\n" name
3834                                " - \n\n=head1 SYNOPSIS\n\n\n\n"
3835                                "=head1 DESCRIPTION")
3836                        (cperl-ensure-newlines 4)
3837                        (goto-char p)
3838                        (forward-word 2)
3839                        (end-of-line)
3840                        (setq really-delete t))
3841                    (forward-word 1))))
3842            (if over
3843                (progn
3844                  (setq p (point))
3845                  (insert "\n\n=item \n\n\n\n"
3846                          "=back")
3847                  (cperl-ensure-newlines 2)
3848                  (goto-char p)
3849                  (forward-word 1)
3850                  (end-of-line)
3851                  (setq really-delete t)))
3852            (if (and delete really-delete)
3853                (cperl-putback-char cperl-del-back-ch))))))
3854
3855 (defun cperl-electric-else ()
3856   "Insert a construction appropriate after a keyword.
3857 Help message may be switched off by setting `cperl-message-electric-keyword'
3858 to nil."
3859   (let ((beg (save-excursion (beginning-of-line) (point))))
3860     (and (save-excursion
3861            (backward-sexp 1)
3862            (cperl-after-expr-p nil "{;:"))
3863          (save-excursion
3864            (not
3865             (re-search-backward
3866              "[#\"'`]\\|\\<q\\(\\|[wqxr]\\)\\>"
3867              beg t)))
3868          (save-excursion (or (not (re-search-backward "^=" nil t))
3869                              (looking-at "=cut")
3870                              (and cperl-use-syntax-table-text-property
3871                                   (not (eq (get-text-property (point)
3872                                                               'syntax-type)
3873                                            'pod)))))
3874          (progn
3875            (cperl-indent-line)
3876            ;;(insert " {\n\n}")
3877            (cond
3878             (cperl-extra-newline-before-brace
3879              (insert "\n")
3880              (insert "{")
3881              (cperl-indent-line)
3882              (insert "\n\n}"))
3883             (t
3884              (insert " {\n\n}")))
3885            (or (looking-at "[ \t]\\|$") (insert " "))
3886            (cperl-indent-line)
3887            (forward-line -1)
3888            (cperl-indent-line)
3889            (cperl-putback-char cperl-del-back-ch)
3890            (setq this-command 'cperl-electric-else)
3891            (if cperl-message-electric-keyword
3892                (message "Precede char by C-q to avoid expansion"))))))
3893
3894 (defun cperl-linefeed ()
3895   "Go to end of line, open a new line and indent appropriately.
3896 If in POD, insert appropriate lines."
3897   (interactive)
3898   (let ((beg (save-excursion (beginning-of-line) (point)))
3899         (end (save-excursion (end-of-line) (point)))
3900         (pos (point)) start over cut res)
3901     (if (and                            ; Check if we need to split:
3902                                         ; i.e., on a boundary and inside "{...}"
3903          (save-excursion (cperl-to-comment-or-eol)
3904                          (>= (point) pos)) ; Not in a comment
3905          (or (save-excursion
3906                (skip-chars-backward " \t" beg)
3907                (forward-char -1)
3908                (looking-at "[;{]"))     ; After { or ; + spaces
3909              (looking-at "[ \t]*}")     ; Before }
3910              (re-search-forward "\\=[ \t]*;" end t)) ; Before spaces + ;
3911          (save-excursion
3912            (and
3913             (eq (car (parse-partial-sexp pos end -1)) -1)
3914                                         ; Leave the level of parens
3915             (looking-at "[,; \t]*\\($\\|#\\)") ; Comma to allow anon subr
3916                                         ; Are at end
3917             (cperl-after-block-p (point-min))
3918             (progn
3919               (backward-sexp 1)
3920               (setq start (point-marker))
3921               (<= start pos)))))        ; Redundant?  Are after the
3922                                         ; start of parens group.
3923         (progn
3924           (skip-chars-backward " \t")
3925           (or (memq (preceding-char) (append ";{" nil))
3926               (insert ";"))
3927           (insert "\n")
3928           (forward-line -1)
3929           (cperl-indent-line)
3930           (goto-char start)
3931           (or (looking-at "{[ \t]*$")   ; If there is a statement
3932                                         ; before, move it to separate line
3933               (progn
3934                 (forward-char 1)
3935                 (insert "\n")
3936                 (cperl-indent-line)))
3937           (forward-line 1)              ; We are on the target line
3938           (cperl-indent-line)
3939           (beginning-of-line)
3940           (or (looking-at "[ \t]*}[,; \t]*$") ; If there is a statement
3941                                         ; after, move it to separate line
3942               (progn
3943                 (end-of-line)
3944                 (search-backward "}" beg)
3945                 (skip-chars-backward " \t")
3946                 (or (memq (preceding-char) (append ";{" nil))
3947                     (insert ";"))
3948                 (insert "\n")
3949                 (cperl-indent-line)
3950                 (forward-line -1)))
3951           (forward-line -1)             ; We are on the line before target
3952           (end-of-line)
3953           (newline-and-indent))
3954       (end-of-line)                     ; else - no splitting
3955       (cond
3956        ((and (looking-at "\n[ \t]*{$")
3957              (save-excursion
3958                (skip-chars-backward " \t")
3959                (eq (preceding-char) ?\)))) ; Probably if () {} group
3960                                         ; with an extra newline.
3961         (forward-line 2)
3962         (cperl-indent-line))
3963        ((save-excursion                 ; In POD header
3964           (forward-paragraph -1)
3965           ;; (re-search-backward "\\(\\`\n?\\|\n\n\\)=head1\\b")
3966           ;; We are after \n now, so look for the rest
3967           (if (looking-at "\\(\\`\n?\\|\n\\)=\\sw+")
3968               (progn
3969                 (setq cut (looking-at "\\(\\`\n?\\|\n\\)=cut\\>"))
3970                 (setq over (looking-at "\\(\\`\n?\\|\n\\)=over\\>"))
3971                 t)))
3972         (if (and over
3973                  (progn
3974                    (forward-paragraph -1)
3975                    (forward-word 1)
3976                    (setq pos (point))
3977                    (setq cut (buffer-substring (point)
3978                                                (save-excursion
3979                                                  (end-of-line)
3980                                                  (point))))
3981                    (delete-char (- (save-excursion (end-of-line) (point))
3982                                    (point)))
3983                    (setq res (expand-abbrev))
3984                    (save-excursion
3985                      (goto-char pos)
3986                      (insert cut))
3987                    res))
3988             nil
3989           (cperl-ensure-newlines (if cut 2 4))
3990           (forward-line 2)))
3991        ((get-text-property (point) 'in-pod) ; In POD section
3992         (cperl-ensure-newlines 4)
3993         (forward-line 2))
3994        ((looking-at "\n[ \t]*$")        ; Next line is empty - use it.
3995         (forward-line 1)
3996         (cperl-indent-line))
3997        (t
3998         (newline-and-indent))))))
3999
4000 (defun cperl-electric-semi (arg)
4001   "Insert character and correct line's indentation."
4002   (interactive "P")
4003   (if cperl-auto-newline
4004       (cperl-electric-terminator arg)
4005     (self-insert-command (prefix-numeric-value arg))
4006     (if cperl-autoindent-on-semi
4007         (cperl-indent-line))))
4008
4009 (defun cperl-electric-terminator (arg)
4010   "Insert character and correct line's indentation."
4011   (interactive "P")
4012   (let ((end (point))
4013         (auto (and cperl-auto-newline
4014                    (or (not (eq last-command-char ?:))
4015                        cperl-auto-newline-after-colon)))
4016         insertpos)
4017     (if (and ;;(not arg)
4018              (eolp)
4019              (not (save-excursion
4020                     (beginning-of-line)
4021                     (skip-chars-forward " \t")
4022                     (or
4023                      ;; Ignore in comment lines
4024                      (= (following-char) ?#)
4025                      ;; Colon is special only after a label
4026                      ;; So quickly rule out most other uses of colon
4027                      ;; and do no indentation for them.
4028                      (and (eq last-command-char ?:)
4029                           (save-excursion
4030                             (forward-word 1)
4031                             (skip-chars-forward " \t")
4032                             (and (< (point) end)
4033                                  (progn (goto-char (- end 1))
4034                                         (not (looking-at ":"))))))
4035                      (progn
4036                        (beginning-of-defun)
4037                        (let ((pps (parse-partial-sexp (point) end)))
4038                          (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))))
4039         (progn
4040           (self-insert-command (prefix-numeric-value arg))
4041           ;;(forward-char -1)
4042           (if auto (setq insertpos (point-marker)))
4043           ;;(forward-char 1)
4044           (cperl-indent-line)
4045           (if auto
4046               (progn
4047                 (newline)
4048                 (cperl-indent-line)))
4049           (save-excursion
4050             (if insertpos (goto-char (1- (marker-position insertpos)))
4051               (forward-char -1))
4052             (delete-char 1))))
4053     (if insertpos
4054         (save-excursion
4055           (goto-char insertpos)
4056           (self-insert-command (prefix-numeric-value arg)))
4057       (self-insert-command (prefix-numeric-value arg)))))
4058
4059 (defun cperl-electric-backspace (arg)
4060   "Backspace, or remove the whitespace around the point inserted by an electric
4061 key.  Will untabivy if `cperl-electric-backspace-untabify' is non-nil."
4062   (interactive "p")
4063   (if (and cperl-auto-newline
4064            (memq last-command '(cperl-electric-semi
4065                                 cperl-electric-terminator
4066                                 cperl-electric-lbrace))
4067            (memq (preceding-char) '(?\  ?\t ?\n)))
4068       (let (p)
4069         (if (eq last-command 'cperl-electric-lbrace)
4070             (skip-chars-forward " \t\n"))
4071         (setq p (point))
4072         (skip-chars-backward " \t\n")
4073         (delete-region (point) p))
4074     (and (eq last-command 'cperl-electric-else)
4075          ;; We are removing the whitespace *inside* cperl-electric-else
4076          (setq this-command 'cperl-electric-else-really))
4077     (if (and cperl-auto-newline
4078              (eq last-command 'cperl-electric-else-really)
4079              (memq (preceding-char) '(?\  ?\t ?\n)))
4080         (let (p)
4081           (skip-chars-forward " \t\n")
4082           (setq p (point))
4083           (skip-chars-backward " \t\n")
4084           (delete-region (point) p))
4085       (if cperl-electric-backspace-untabify
4086           (backward-delete-char-untabify arg)
4087         (delete-backward-char arg)))))
4088
4089 (defun cperl-inside-parens-p ()         ;; NOT USED????
4090   (condition-case ()
4091       (save-excursion
4092         (save-restriction
4093           (narrow-to-region (point)
4094                             (progn (beginning-of-defun) (point)))
4095           (goto-char (point-max))
4096           (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\()))
4097     (error nil)))
4098 \f
4099 (defun cperl-indent-command (&optional whole-exp)
4100   "Indent current line as Perl code, or in some cases insert a tab character.
4101 If `cperl-tab-always-indent' is non-nil (the default), always indent current
4102 line.  Otherwise, indent the current line only if point is at the left margin
4103 or in the line's indentation; otherwise insert a tab.
4104
4105 A numeric argument, regardless of its value,
4106 means indent rigidly all the lines of the expression starting after point
4107 so that this line becomes properly indented.
4108 The relative indentation among the lines of the expression are preserved."
4109   (interactive "P")
4110   (cperl-update-syntaxification (point) (point))
4111   (if whole-exp
4112       ;; If arg, always indent this line as Perl
4113       ;; and shift remaining lines of expression the same amount.
4114       (let ((shift-amt (cperl-indent-line))
4115             beg end)
4116         (save-excursion
4117           (if cperl-tab-always-indent
4118               (beginning-of-line))
4119           (setq beg (point))
4120           (forward-sexp 1)
4121           (setq end (point))
4122           (goto-char beg)
4123           (forward-line 1)
4124           (setq beg (point)))
4125         (if (and shift-amt (> end beg))
4126             (indent-code-rigidly beg end shift-amt "#")))
4127     (if (and (not cperl-tab-always-indent)
4128              (save-excursion
4129                (skip-chars-backward " \t")
4130                (not (bolp))))
4131         (insert-tab)
4132       (cperl-indent-line))))
4133
4134 (defun cperl-indent-line (&optional parse-data)
4135   "Indent current line as Perl code.
4136 Return the amount the indentation changed by."
4137   (let ((case-fold-search nil)
4138         (pos (- (point-max) (point)))
4139         indent i beg shift-amt)
4140     (setq indent (cperl-calculate-indent parse-data)
4141           i indent)
4142     (beginning-of-line)
4143     (setq beg (point))
4144     (cond ((or (eq indent nil) (eq indent t))
4145            (setq indent (current-indentation) i nil))
4146           ;;((eq indent t)    ; Never?
4147           ;; (setq indent (cperl-calculate-indent-within-comment)))
4148           ;;((looking-at "[ \t]*#")
4149           ;; (setq indent 0))
4150           (t
4151            (skip-chars-forward " \t")
4152            (if (listp indent) (setq indent (car indent)))
4153            (cond ((and (looking-at "[A-Za-z_][A-Za-z_0-9]*:[^:]")
4154                        (not (looking-at "[smy]:\\|tr:")))
4155                   (and (> indent 0)
4156                        (setq indent (max cperl-min-label-indent
4157                                          (+ indent cperl-label-offset)))))
4158                  ((= (following-char) ?})
4159                   (setq indent (- indent cperl-indent-level)))
4160                  ((memq (following-char) '(?\) ?\])) ; To line up with opening paren.
4161                   (setq indent (+ indent cperl-close-paren-offset)))
4162                  ((= (following-char) ?{)
4163                   (setq indent (+ indent cperl-brace-offset))))))
4164