Commits

Anonymous committed e6cfec9

Sync cperl-mode with upstream 4.35 <1092312347.26913.11.camel@bobcat.mine.nu>.

  • Participants
  • Parent commits b46dfb2

Comments (0)

Files changed (2)

+2004-08-12  Ville Skyttä  <scop@xemacs.org>
+
+	* cperl-mode.el: Sync with upstream version 4.35.
+
 2003-10-31  Norbert Koch  <viteno@xemacs.org>
 
 	* Makefile (VERSION): XEmacs package 1.05 released.

File cperl-mode.el

 ;;; cperl-mode.el --- Perl code editing commands for XEmacs
 
-;;;; The following message is relative to GNU version of the module:
-
-;; Copyright (C) 1985, 86, 87, 1991--2000
+;; Copyright (C) 1985, 86, 87, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 2003
 ;;     Free Software Foundation, Inc.
 ;; Copyright (C) 1997 granted to FSF for changes made by
 ;; Karl M. Hegbloom <karlheg@inetarena.com>
 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 ;; Boston, MA 02111-1307, USA.
 
-;;; Corrections made by Ilya Zakharevich ilya@math.mps.ohio-state.edu
+;;; Corrections made by Ilya Zakharevich cperl@ilyaz.org
 ;;; XEmacs changes by Peter Arius arius@informatik.uni-erlangen.de
 ;;; XEmacs 'delete key behavior handling added for XEmacs 20.x by
 ;;; Gary D. Foster <Gary.Foster@corp.sun.com>
 ;;; Karl M. Hegbloom <karlheg@inetarena.com>
 
-;; Original Vendor Version Number:  (mostly based on...)
-;; Id: cperl-mode.el,v 4.32 2000/05/31 05:13:15 ilya Exp ilya
-
-;; Increment the final digit once per XEmacs-only revision, the other
-;; for merges.  (sound ok?)
-;;;  XEmacs Version Number: 1.4?-?
-
-;; Synced with cperl-mode.el 4.32 by Adrian Aichner <adrian@xemacs.org>
-
 ;;; Commentary:
 
-;; Id: cperl-mode.el,v 4.32 2000/05/31 05:13:15 ilya Exp ilya
+;; $Id$
 
 ;;; If your Emacs does not default to `cperl-mode' on Perl files:
 ;;; To use this mode put the following into
 
 ;; (autoload 'perl-mode "cperl-mode" "alternate mode for editing Perl programs" t)
 
-;;; You can either fine-tune the bells and whistles of this mode or
-;;; bulk enable them by putting
+;; You can either fine-tune the bells and whistles of this mode or
+;; bulk enable them by putting
 
 ;; (setq cperl-hairy t)
 
-;;; in your .emacs file.  (Emacs rulers do not consider it politically
-;;; correct to make whistles enabled by default.)
-
-;;; DO NOT FORGET to read micro-docs (available from `Perl' menu)   <<<<<<
-;;; or as help on variables `cperl-tips', `cperl-problems',         <<<<<<
-;;; `cperl-non-problems', `cperl-praise', `cperl-speed'.            <<<<<<
-
-;;; Additional useful commands to put into your .emacs file (before
-;;; Emacs 20.3):
+;; in your .emacs file.  (Emacs rulers do not consider it politically
+;; correct to make whistles enabled by default.)
+
+;; DO NOT FORGET to read micro-docs (available from `Perl' menu)   <<<<<<
+;; or as help on variables `cperl-tips', `cperl-problems',         <<<<<<
+;; `cperl-non-problems', `cperl-praise', `cperl-speed'.            <<<<<<
+
+;; Additional useful commands to put into your .emacs file (before
+;; Emacs 20.3):
 
 ;; (setq auto-mode-alist
 ;;      (append '(("\\.\\([pP][Llm]\\|al\\)$" . perl-mode))  auto-mode-alist ))
 ;; (setq interpreter-mode-alist (append interpreter-mode-alist
 ;; 				        '(("miniperl" . perl-mode))))
 
-;;; The mode information (on C-h m) provides some customization help.
-;;; If you use font-lock feature of this mode, it is advisable to use
-;;; either lazy-lock-mode or fast-lock-mode.  I prefer lazy-lock.
-
-;;; Faces used now: three faces for first-class and second-class keywords
-;;; and control flow words, one for each: comments, string, labels,
-;;; functions definitions and packages, arrays, hashes, and variable
-;;; definitions.  If you do not see all these faces, your font-lock does
-;;; not define them, so you need to define them manually.  Maybe you have
-;;; an obsolete font-lock from 19.28 or earlier.  Upgrade.
-
-;;; If you have a grayscale monitor, and do not have the variable
-;;; font-lock-display-type bound to 'grayscale, insert
-
-;;; (setq font-lock-display-type 'grayscale)
-
-;;; into your .emacs file (this is relevant before Emacs 20).
-
-;;;; This mode supports font-lock, imenu and mode-compile.  In the
-;;;; hairy version font-lock is on, but you should activate imenu
-;;;; yourself (note that mode-compile is not standard yet).  Well, you
-;;;; can use imenu from keyboard anyway (M-x imenu), but it is better
-;;;; to bind it like that:
+;; The mode information (on C-h m) provides some customization help.
+;; If you use font-lock feature of this mode, it is advisable to use
+;; either lazy-lock-mode or fast-lock-mode.  I prefer lazy-lock.
+
+;; Faces used now: three faces for first-class and second-class keywords
+;; and control flow words, one for each: comments, string, labels,
+;; functions definitions and packages, arrays, hashes, and variable
+;; definitions.  If you do not see all these faces, your font-lock does
+;; not define them, so you need to define them manually.
+;; Maybe you have an obsolete font-lock from 19.28 or earlier.  Upgrade.
+
+;; If you have a grayscale monitor, and do not have the variable
+;; font-lock-display-type bound to 'grayscale, insert
+
+;; (setq font-lock-display-type 'grayscale)
+
+;; into your .emacs file (this is relevant before Emacs 20).
+
+;; This mode supports font-lock, imenu and mode-compile.  In the
+;; hairy version font-lock is on, but you should activate imenu
+;; yourself (note that mode-compile is not standard yet).  Well, you
+;; can use imenu from keyboard anyway (M-x imenu), but it is better
+;; to bind it like that:
 
 ;; (define-key global-map [M-S-down-mouse-3] 'imenu)
 
+;;; Font lock bugs as of v4.32:
+
+;; The following kinds of Perl code erroneously start strings:
+;; \$`  \$'  \$"
+;; $opt::s  $opt_s  $opt{s}  (s => ...)  /\s+.../
+;; likewise with m, tr, y, q, qX instead of s
+
 ;;; In fact the version of font-lock that this version supports can be
 ;;; much newer than the version you actually have. This means that a
 ;;; lot of faces can be set up, but are not visible on your screen
 ;;;  Debugging code in `cperl-electric-keywords' was leaking a message;
 
 ;;;; After 1.41:
-;;;  added 'pod-spell' and 'make-pod-list'
-;;;  Two functions used to run ispell only on pod/here regions
-
-;;;; After 1.41:
+;;;  XEmacs: added 'pod-spell' and 'make-pod-list'
+;;;  XEmacs: Two functions used to run ispell only on pod/here regions
 ;;;  RMS changes for 20.3 merged
 
 ;;;; 2.0.1.0: RMS mode (has 3 misprints)
 ;;; (`cperl-write-tags'):	Use `cperl-unreadable-ok', do not fail
 ;;;				on an unreadable directory
 
+;;;; After 4.32:
+;;;  Syncronized with v1.60 from Emacs 21.3.
+;;;  Mostly docstring and formatting changes, and:
+
+;;;  (`cperl-noscan-files-regexp'): Do not scan CVS subdirs
+;;;  (`cperl-problems'):	Note that newer XEmacsen may syntaxify too
+;;;  (`imenu-example--create-perl-index'):
+;;;				Renamed to `cperl-imenu--create-perl-index'
+;;;  (`cperl-mode'):		Replace `make-variable-buffer-local' by `make-local-variable'
+;;;  (`cperl-setup-tmp-buf'):	Likewise
+;;;  (`cperl-fix-line-spacing'): Fix a misprint of "t" for "\t"
+;;;  (`cperl-next-bad-style'):  Fix misprints in character literals
+
+;;;; After 4.33:
+;;;;  (`cperl-font-lock-keywords'): +etc: Aliased to perl-font-lock-keywords.
+
+;;;; After 4.34:
+;;;;  Further updates of whitespace and spelling w.r.t. RMS version.
+;;;;  (`cperl-font-lock-keywords'): +etc: Avoid warnings when aliasing.
+;;;;  (`cperl-mode'):		Use `normal-auto-fill-function' if present.
+;;;;  (`cperl-use-major-mode'): New variable
+;;;;  (`cperl-can-font-lock'):	New variable; replaces `window-system'
+;;;;  (`display-popup-menus-p'): use `display-popup-menus-p' (if present)
+;;;;				 to choose `x-popup-menu' vs `tmm-prompt'
+
 ;;; Code:
 
 
 	  (require 'custom)
 	(error nil))
       (defconst cperl-xemacs-p (string-match "XEmacs\\|Lucid" emacs-version))
+      (defvar cperl-can-font-lock
+	(or cperl-xemacs-p
+	    (and (boundp 'emacs-major-version)
+		 (or window-system
+		     (> emacs-major-version 20)))))
+      (if cperl-can-font-lock
+	  (require 'font-lock))
+      (defvar msb-menu-cond)
+      (defvar gud-perldb-history)
+      (defvar font-lock-background-mode) ; not in Emacs
+      (defvar font-lock-display-type)	; ditto
       (or (fboundp 'defgroup)
 	  (defmacro defgroup (name val doc &rest arr)
 	    nil))
 	  (defmacro defcustom (name val doc &rest arr)
 	    (` (defvar (, name) (, val) (, doc)))))
       (or (and (fboundp 'custom-declare-variable)
-	       (string< "19.31" emacs-version))  ;  Checked with 19.30: defface does not work
+	       (string< "19.31" emacs-version))	;  Checked with 19.30: defface does not work
 	  (defmacro defface (&rest arr)
 	    nil))
-            ;; Avoid warning (tmp definitions)
+      ;; Avoid warning (tmp definitions)
       (or (fboundp 'x-color-defined-p)
 	  (defmacro x-color-defined-p (col)
 	    (cond ((fboundp 'color-defined-p) (` (color-defined-p (, col))))
 		  ((fboundp 'x-valid-color-name-p) (` (x-valid-color-name-p (, col))))
 		  (t '(error "Cannot implement color-defined-p")))))
       (defmacro cperl-is-face (arg)	; Takes quoted arg
-	    (cond ((fboundp 'find-face)
-		   (` (find-face (, arg))))
-		  (;;(and (fboundp 'face-list)
-		   ;;	(face-list))
-		   (fboundp 'face-list)
-		   (` (member (, arg) (and (fboundp 'face-list)
-					   (face-list)))))
-		  (t
-		   (` (boundp (, arg))))))
+	(cond ((fboundp 'find-face)
+	       (` (find-face (, arg))))
+	      (;;(and (fboundp 'face-list)
+	       ;;	(face-list))
+	       (fboundp 'face-list)
+	       (` (member (, arg) (and (fboundp 'face-list)
+				       (face-list)))))
+	      (t
+	       (` (boundp (, arg))))))
       (defmacro cperl-make-face (arg descr) ; Takes unquoted arg
 	(cond ((fboundp 'make-face)
 	       (` (make-face (quote (, arg)))))
 	      (t
-	       (` (defconst (, arg) (quote (, arg)) (, descr))))))
+	       (` (defvar (, arg) (quote (, arg)) (, descr))))))
       (defmacro cperl-force-face (arg descr) ; Takes unquoted arg
 	(` (progn
 	     (or (cperl-is-face (quote (, arg)))
 		 (cperl-make-face (, arg) (, descr)))
 	     (or (boundp (quote (, arg))) ; We use unquoted variants too
-		 (defconst (, arg) (quote (, arg)) (, descr))))))
+		 (defvar (, arg) (quote (, arg)) (, descr))))))
       (if cperl-xemacs-p
 	  (defmacro cperl-etags-snarf-tag (file line)
 	    (` (progn
 	  (` (etags-snarf-tag))))
       (if cperl-xemacs-p
 	  (defmacro cperl-etags-goto-tag-location (elt)
-	    (` ;;(progn
-		 ;; (switch-to-buffer (get-file-buffer (elt (, elt) 0)))
-		 ;; (set-buffer (get-file-buffer (elt (, elt) 0)))
-		 ;; Probably will not work due to some save-excursion???
-		 ;; Or save-file-position?
-		 ;; (message "Did I get to line %s?" (elt (, elt) 1))
-		 (goto-line (string-to-int (elt (, elt) 1)))))
-	    ;;)
+	    (`;;(progn
+	     ;; (switch-to-buffer (get-file-buffer (elt (, elt) 0)))
+	     ;; (set-buffer (get-file-buffer (elt (, elt) 0)))
+	     ;; Probably will not work due to some save-excursion???
+	     ;; Or save-file-position?
+	     ;; (message "Did I get to line %s?" (elt (, elt) 1))
+	     (goto-line (string-to-int (elt (, elt) 1)))))
+	;;)
 	(defmacro cperl-etags-goto-tag-location (elt)
 	  (` (etags-goto-tag-location (, elt)))))))
 
+(defconst cperl-xemacs-p (string-match "XEmacs\\|Lucid" emacs-version))
+
+(defvar cperl-can-font-lock
+  (or cperl-xemacs-p
+      (and (boundp 'emacs-major-version)
+	   (or window-system
+	       (> emacs-major-version 20)))))
+
 (condition-case nil
     (require 'custom)
   (error nil))				; Already fixed by eval-when-compile
 instead of:
 
 	if () {
-	}
-"
+	}"
   :type 'boolean
   :group 'cperl-autoinsert-details)
 
   :group 'cperl-affected-by-hairy)
 
 (defcustom cperl-pod-face 'font-lock-comment-face
-  "*The result of evaluation of this expression is used for pod highlighting."
+  "*The result of evaluation of this expression is used for POD highlighting."
   :type 'face
   :group 'cperl-faces)
 
 (defcustom cperl-pod-head-face 'font-lock-variable-name-face
-  "*The result of evaluation of this expression is used for pod highlighting.
+  "*The result of evaluation of this expression is used for POD highlighting.
 Font for POD headers."
   :type 'face
   :group 'cperl-faces)
   :type 'face
   :group 'cperl-faces)
 
+;; XEmacs change: removed extra ' from ''underline
 (defcustom cperl-invalid-face 'underline ; later evaluated by `font-lock'
   "*The result of evaluation of this expression highlights trailing whitespace."
   :type 'face
   :group 'cperl-faces)
 
 (defcustom cperl-pod-here-fontify '(featurep 'font-lock)
-  "*Not-nil after evaluation means to highlight pod and here-docs sections."
+  "*Not-nil after evaluation means to highlight POD and here-docs sections."
   :type 'boolean
   :group 'cperl-faces)
 
   :group 'cperl-faces)
 
 (defcustom cperl-highlight-variables-indiscriminately nil
-  "*Not-nil means perform additional highlighting on variables.
+  "*Non-nil means perform additional highlighting on variables.
 Currently only changes how scalar variables are highlighted.
 Note that that variable is only read at initialization time for
 the variable `perl-font-lock-keywords-2', so changing it after you've
   :group 'cperl)
 
 (defcustom cperl-pod-here-scan t
-  "*Not-nil means look for pod and here-docs sections during startup.
+  "*Not-nil means look for POD and here-docs sections during startup.
 You can always make lookup from menu or using \\[cperl-find-pods-heres]."
   :type 'boolean
   :group 'cperl-speed)
   :type 'regexp
   :group 'cperl)
 
-(defcustom cperl-noscan-files-regexp "/\\(\\.\\.?\\|SCCS\\|RCS\\|blib\\)$"
+(defcustom cperl-noscan-files-regexp
+  "/\\(\\.\\.?\\|SCCS\\|RCS\\|CVS\\|blib\\)$"
   "*Regexp to match files/dirs to skip when generating TAGS."
   :type 'regexp
   :group 'cperl)
 
 (defcustom cperl-break-one-line-blocks-when-indent t
   "*Non-nil means that one-line if/unless/while/until/for/foreach BLOCKs
-need to be reformated into multiline ones when indenting a region."
+need to be reformatted into multiline ones when indenting a region."
   :type 'boolean
   :group 'cperl-indentation-details)
 
   :group 'cperl-indentation-details)
 
 (defcustom cperl-syntaxify-by-font-lock
-  (and window-system
+  (and cperl-can-font-lock
        (boundp 'parse-sexp-lookup-properties))
   "*Non-nil means that CPerl uses `font-lock's routines for syntaxification."
   :type '(choice (const message) boolean)
 				   (repeat symbol)))))
   :group 'cperl-faces)
 
-(defvar cperl-dark-background
-  (cperl-choose-color "navy" "os2blue" "darkgreen"))
-(defvar cperl-dark-foreground
-  (cperl-choose-color "orchid1" "orange"))
-
-(defface cperl-nonoverridable-face
-  (` ((((class grayscale) (background light))
-       (:background "Gray90" :italic t :underline t))
-      (((class grayscale) (background dark))
-       (:foreground "Gray80" :italic t :underline t :bold t))
-      (((class color) (background light))
-       (:foreground "chartreuse3"))
-      (((class color) (background dark))
-       (:foreground (, cperl-dark-foreground)))
-      (t (:bold t :underline t))))
-  "Font Lock mode face used to highlight array names."
-  :group 'cperl-faces)
-
-(defface cperl-array-face
-  (` ((((class grayscale) (background light))
-       (:background "Gray90" :bold t))
-      (((class grayscale) (background dark))
-       (:foreground "Gray80" :bold t))
-      (((class color) (background light))
-       (:foreground "Blue" :bold t))
-      (((class color) (background dark))
-       (:foreground "yellow" :background (, cperl-dark-background) :bold t))
-      (t (:bold t))))
-  "Font Lock mode face used to highlight array names."
-:group 'cperl-faces)
-
-(defface cperl-hash-face
-  (` ((((class grayscale) (background light))
-       (:background "Gray90" :bold t :italic t))
-      (((class grayscale) (background dark))
-       (:foreground "Gray80" :bold t :italic t))
-      (((class color) (background light))
-       (:foreground "Red" :bold t :italic t))
-      (((class color) (background dark))
-       (:foreground "Red" :background (, cperl-dark-background) :bold t :italic t))
-      (t (:bold t :italic t))))
-  "Font Lock mode face used to highlight hash names."
-  :group 'cperl-faces)
+(if cperl-can-font-lock
+    (progn
+      (defvar cperl-dark-background
+	(cperl-choose-color "navy" "os2blue" "darkgreen"))
+      (defvar cperl-dark-foreground
+	(cperl-choose-color "orchid1" "orange"))
+
+      (defface cperl-nonoverridable-face
+	(` ((((class grayscale) (background light))
+	     (:background "Gray90" :italic t :underline t))
+	    (((class grayscale) (background dark))
+	     (:foreground "Gray80" :italic t :underline t :bold t))
+	    (((class color) (background light))
+	     (:foreground "chartreuse3"))
+	    (((class color) (background dark))
+	     (:foreground (, cperl-dark-foreground)))
+	    (t (:bold t :underline t))))
+	"Font Lock mode face used to highlight array names."
+	:group 'cperl-faces)
+
+      (defface cperl-array-face
+	(` ((((class grayscale) (background light))
+	     (:background "Gray90" :bold t))
+	    (((class grayscale) (background dark))
+	     (:foreground "Gray80" :bold t))
+	    (((class color) (background light))
+	     (:foreground "Blue" :background "lightyellow2" :bold t))
+	    (((class color) (background dark))
+	     (:foreground "yellow" :background (, cperl-dark-background) :bold t))
+	    (t (:bold t))))
+	"Font Lock mode face used to highlight array names."
+	:group 'cperl-faces)
+
+      (defface cperl-hash-face
+	(` ((((class grayscale) (background light))
+	     (:background "Gray90" :bold t :italic t))
+	    (((class grayscale) (background dark))
+	     (:foreground "Gray80" :bold t :italic t))
+	    (((class color) (background light))
+	     (:foreground "Red" :background "lightyellow2" :bold t :italic t))
+	    (((class color) (background dark))
+	     (:foreground "Red" :background (, cperl-dark-background) :bold t :italic t))
+	    (t (:bold t :italic t))))
+	"Font Lock mode face used to highlight hash names."
+	:group 'cperl-faces)))
 
 
 
 ;;; Short extra-docs.
 
 (defvar cperl-tips 'please-ignore-this-line
-  "Get newest version of this package from
+  "Get maybe newer version of this package from
   ftp://ftp.math.ohio-state.edu/pub/users/ilya/emacs
 and/or
   ftp://ftp.math.ohio-state.edu/pub/users/ilya/perl
   ftp://ftp.math.ohio-state.edu/pub/users/ilya/cperl-mode/patches
 \(this upgrades syntax-parsing abilities of Emaxen v19.34 and
 v20.2 up to the level of Emacs v20.3 - a must for a good Perl
-mode.)
+mode.)  As of beginning of 2003, XEmacs may provide a similar ability.
 
 Get support packages choose-color.el (or font-lock-extra.el before
 19.30), imenu-go.el from the same place.  \(Look for other files there
 If your Emacs does not default to `cperl-mode' on Perl files, and you
 want it to: put the following into your .emacs file:
 
-(autoload 'perl-mode \"cperl-mode\" \"alternate mode for editing Perl programs\" t)
+  (autoload 'perl-mode \"cperl-mode\" \"alternate mode for editing Perl programs\" t)
+
+or
+
+  (defalias 'perl-mode 'cperl-mode)
 
 Get perl5-info from
   $CPAN/doc/manual/info/perl-info.tar.gz
 
   M-x norm RET
 
+or
+
+  \\[normal-mode]
+
 In cases of more severe confusion sometimes it is helpful to do
 
   M-x load-l RET cperl-mode RET
   M-x norm RET
 
+or
+
+  \\[load-library] cperl-mode RET
+  \\[normal-mode]
+
 Before reporting (non-)problems look in the problem section of online
 micro-docs on what I know about CPerl problems.")
 
 (defvar cperl-problems 'please-ignore-this-line
-  "Some faces will not be shown on some versions of Emacs unless you
+  "Description of problems in CPerl mode.
+Some faces will not be shown on some versions of Emacs unless you
 install choose-color.el, available from
    ftp://ftp.math.ohio-state.edu/pub/users/ilya/emacs/
 
 Emacs had a _very_ restricted syntax parsing engine until version
 20.1.  Most problems below are corrected starting from this version of
 Emacs, and all of them should be fixed in version 20.3.  (Or apply
-patches to Emacs 19.33/34 - see tips.)
+patches to Emacs 19.33/34 - see tips.)  XEmacs was very backward in
+this respect (until 2003).
 
 Note that even with newer Emacsen in some very rare cases the details
 of interaction of `font-lock' and syntaxification may be not cleaned
 
 This may be confusing, since the regexp s#//#/#\; may be highlighted
 as a comment, but it will be recognized as a regexp by the indentation
-code.  Or the opposite case, when a pod section is highlighted, but
+code.  Or the opposite case, when a POD section is highlighted, but
 may break the indentation of the following code (though indentation
 should work if the balance of delimiters is not broken by POD).
 
 
 If these bugs cannot be fixed on your machine (say, you have an inferior
 environment and cannot recompile), you may still disable all the fancy stuff
-via `cperl-use-syntax-table-text-property'." )
+via `cperl-use-syntax-table-text-property'.")
 
 (defvar cperl-non-problems 'please-ignore-this-line
   "As you know from `problems' section, Perl syntax is too hard for CPerl on
 
 Imenu in 19.31 is broken.  Set `imenu-use-keymap-menu' to t, and remove
 `car' before `imenu-choose-buffer-index' in `imenu'.
-`imenu-add-to-menubar' in 20.2 is broken.
-
+`imenu-add-to-menubar' in 20.2 is broken.  
 A lot of things on XEmacs may be broken too, judging by bug reports I
 receive.  Note that some releases of XEmacs are better than the others
 as far as bugs reports I see are concerned.")
 line-breaks/spacing between elements of the construct.
 
 10) Uses a linear-time algorith for indentation of regions (on Emaxen with
-capable syntax engines).
-")
+capable syntax engines).")
 
 (defvar cperl-speed 'please-ignore-this-line
   "This is an incomplete compendium of what is available in other parts
     wrongly matched parentheses, wrong indentation, etc.
 
     One can unset `cperl-syntaxify-unwind'.  This might speed up editing
-    of, say, long POD sections.
-")
+    of, say, long POD sections.")
 
 (defvar cperl-tips-faces 'please-ignore-this-line
   "CPerl mode uses following faces for highlighting:
 
 ;;; Portability stuff:
 
-(defconst cperl-xemacs-p (string-match "XEmacs\\|Lucid" emacs-version))
-
 (defmacro cperl-define-key (emacs-key definition &optional xemacs-key)
   (` (define-key cperl-mode-map
        (, (if xemacs-key
   (defun cperl-mark-active () mark-active))
 
 (defsubst cperl-enable-font-lock ()
-  (or cperl-xemacs-p window-system))
-
-(defun cperl-putback-char (c)	; Emacs 19
+  cperl-can-font-lock)
+
+(defun cperl-putback-char (c)		; Emacs 19
   (set 'unread-command-events (list c))) ; Avoid undefined warning
 
 (if (boundp 'unread-command-events)
 (defvar cperl-syntax-state nil)
 (defvar cperl-syntax-done-to nil)
 (defvar cperl-emacs-can-parse (> (length (save-excursion
-					   (parse-partial-sexp 1 1))) 9))
+					   (parse-partial-sexp (point) (point)))) 9))
 
 ;; Make customization possible "in reverse"
 (defsubst cperl-val (symbol &optional default hairy)
 					       '(("miniperl" . perl-mode))))))
 (if (fboundp 'eval-when-compile)
     (eval-when-compile
-      (condition-case nil
-	  (require 'imenu)
-	(error nil))
-      (condition-case nil
-	  (require 'easymenu)
-	(error nil))
-      (condition-case nil
-	  (require 'etags)
-	(error nil))
-      (condition-case nil
-	  (require 'timer)
-	(error nil))
-      (condition-case nil
-	  (require 'man)
-	(error nil))
-      (condition-case nil
-	  (require 'info)
-	(error nil))
+      (mapcar (lambda (p)
+		(condition-case nil
+		    (require p)
+		  (error nil)))
+	      '(imenu easymenu etags timer man info))
       (if (fboundp 'ps-extend-face-list)
 	  (defmacro cperl-ps-extend-face-list (arg)
 	    (` (ps-extend-face-list (, arg))))
       ;; Calling `cperl-enable-font-lock' below doesn't compile on XEmacs,
       ;; macros instead of defsubsts don't work on Emacs, so we do the
       ;; expansion manually.  Any other suggestions?
-      (if (or (string-match "XEmacs\\|Lucid" emacs-version)
-	      window-system)
+      (if cperl-can-font-lock
 	  (require 'font-lock))
       (require 'cl)))
 
 		    [(control meta |)])
   ;;(cperl-define-key "\M-q" 'cperl-fill-paragraph)
   ;;(cperl-define-key "\e;" 'cperl-indent-for-comment)
+  ;; XEmacs change: bind cperl-electric-delete to 'delete
   (if cperl-xemacs-p
       (progn
         (cperl-define-key 'backspace 'cperl-electric-backspace)
         (cperl-define-key 'delete 'cperl-electric-delete))
-      (cperl-define-key "\177" 'cperl-electric-backspace))
+    (cperl-define-key "\177" 'cperl-electric-backspace))
   (cperl-define-key "\t" 'cperl-indent-command)
   ;; don't clobber the backspace binding:
   (cperl-define-key "\C-c\C-hF" 'cperl-info-on-command
 (condition-case nil
     (progn
       (require 'easymenu)
-      (easy-menu-define cperl-menu cperl-mode-map "Menu for CPerl mode"
-         '("Perl"
-	   ["Beginning of function" beginning-of-defun t]
-	   ["End of function" end-of-defun t]
-	   ["Mark function" mark-defun t]
-	   ["Indent expression" cperl-indent-exp t]
-	   ["Fill paragraph/comment" cperl-fill-paragraph t]
-	   "----"
-	   ["Line up a construction" cperl-lineup (cperl-use-region-p)]
-	   ["Invert if/unless/while etc" cperl-invert-if-unless t]
-	   ("Regexp"
-	    ["Beautify" cperl-beautify-regexp
-	     cperl-use-syntax-table-text-property]
-	    ["Beautify one level deep" (cperl-beautify-regexp 1)
-	     cperl-use-syntax-table-text-property]
-	    ["Beautify a group" cperl-beautify-level
-	     cperl-use-syntax-table-text-property]
-	    ["Beautify a group one level deep" (cperl-beautify-level 1)
-	     cperl-use-syntax-table-text-property]
-	    ["Contract a group" cperl-contract-level
-	     cperl-use-syntax-table-text-property]
-	    ["Contract groups" cperl-contract-levels
-	     cperl-use-syntax-table-text-property])
-	   ["Refresh \"hard\" constructions" cperl-find-pods-heres t]
-	   "----"
-	   ["Indent region" cperl-indent-region (cperl-use-region-p)]
-	   ["Comment region" cperl-comment-region (cperl-use-region-p)]
-	   ["Uncomment region" cperl-uncomment-region (cperl-use-region-p)]
-	   "----"
-	   ["Run" mode-compile (fboundp 'mode-compile)]
-	   ["Kill" mode-compile-kill (and (fboundp 'mode-compile-kill)
-					  (get-buffer "*compilation*"))]
-	   ["Next error" next-error (get-buffer "*compilation*")]
-	   ["Check syntax" cperl-check-syntax (fboundp 'mode-compile)]
-	   "----"
-	   ["Debugger" cperl-db t]
-	   "----"
-	   ("Tools"
-	    ["Imenu" imenu (fboundp 'imenu)]
-	    ["Insert spaces if needed" cperl-find-bad-style t]
-	    ["Class Hierarchy from TAGS" cperl-tags-hier-init t]
-	    ;;["Update classes" (cperl-tags-hier-init t) tags-table-list]
-	    ["CPerl pretty print (exprmntl)" cperl-ps-print
-	     (fboundp 'ps-extend-face-list)]
-	    ["Imenu on info" cperl-imenu-on-info (featurep 'imenu)]
-	    ("Tags"
+      (easy-menu-define
+       cperl-menu cperl-mode-map "Menu for CPerl mode"
+       '("Perl"
+	 ["Beginning of function" beginning-of-defun t]
+	 ["End of function" end-of-defun t]
+	 ["Mark function" mark-defun t]
+	 ["Indent expression" cperl-indent-exp t]
+	 ["Fill paragraph/comment" cperl-fill-paragraph t]
+	 "----"
+	 ["Line up a construction" cperl-lineup (cperl-use-region-p)]
+	 ["Invert if/unless/while etc" cperl-invert-if-unless t]
+	 ("Regexp"
+	  ["Beautify" cperl-beautify-regexp
+	   cperl-use-syntax-table-text-property]
+	  ["Beautify one level deep" (cperl-beautify-regexp 1)
+	   cperl-use-syntax-table-text-property]
+	  ["Beautify a group" cperl-beautify-level
+	   cperl-use-syntax-table-text-property]
+	  ["Beautify a group one level deep" (cperl-beautify-level 1)
+	   cperl-use-syntax-table-text-property]
+	  ["Contract a group" cperl-contract-level
+	   cperl-use-syntax-table-text-property]
+	  ["Contract groups" cperl-contract-levels
+	   cperl-use-syntax-table-text-property])
+	 ["Refresh \"hard\" constructions" cperl-find-pods-heres t]
+	 "----"
+	 ["Indent region" cperl-indent-region (cperl-use-region-p)]
+	 ["Comment region" cperl-comment-region (cperl-use-region-p)]
+	 ["Uncomment region" cperl-uncomment-region (cperl-use-region-p)]
+	 "----"
+	 ["Run" mode-compile (fboundp 'mode-compile)]
+	 ["Kill" mode-compile-kill (and (fboundp 'mode-compile-kill)
+					(get-buffer "*compilation*"))]
+	 ["Next error" next-error (get-buffer "*compilation*")]
+	 ["Check syntax" cperl-check-syntax (fboundp 'mode-compile)]
+	 "----"
+	 ["Debugger" cperl-db t]
+	 "----"
+	 ("Tools"
+	  ["Imenu" imenu (fboundp 'imenu)]
+	  ["Insert spaces if needed" cperl-find-bad-style t]
+	  ["Class Hierarchy from TAGS" cperl-tags-hier-init t]
+	  ;;["Update classes" (cperl-tags-hier-init t) tags-table-list]
+	  ["CPerl pretty print (exprmntl)" cperl-ps-print 
+	   (fboundp 'ps-extend-face-list)]
+	  ["Imenu on info" cperl-imenu-on-info (featurep 'imenu)]
+	  ("Tags"
 ;;;	     ["Create tags for current file" cperl-etags t]
 ;;;	     ["Add tags for current file" (cperl-etags t) t]
 ;;;	     ["Create tags for Perl files in directory" (cperl-etags nil t) t]
 ;;;	     ["Add tags for Perl files in (sub)directories"
 ;;;	      (cperl-etags t 'recursive) t])
 ;;;; cperl-write-tags (&optional file erase recurse dir inbuffer)
-	     ["Create tags for current file" (cperl-write-tags nil t) t]
-	     ["Add tags for current file" (cperl-write-tags) t]
-	     ["Create tags for Perl files in directory"
-	      (cperl-write-tags nil t nil t) t]
-	     ["Add tags for Perl files in directory"
-	      (cperl-write-tags nil nil nil t) t]
-	     ["Create tags for Perl files in (sub)directories"
-	      (cperl-write-tags nil t t t) t]
-	     ["Add tags for Perl files in (sub)directories"
-	      (cperl-write-tags nil nil t t) t]))
-	   ("Perl docs"
-	    ["Define word at point" imenu-go-find-at-position
-	     (fboundp 'imenu-go-find-at-position)]
-	    ["Help on function" cperl-info-on-command t]
-	    ["Help on function at point" cperl-info-on-current-command t]
-	    ["Help on symbol at point" cperl-get-help t]
-	    ["Perldoc" cperl-perldoc t]
-	    ["Perldoc on word at point" cperl-perldoc-at-point t]
-	    ["View manpage of POD in this file" cperl-pod-to-manpage t]
-	    ["Auto-help on" cperl-lazy-install
-	     (and (fboundp 'run-with-idle-timer)
-		  (not cperl-lazy-installed))]
-	    ["Auto-help off" (eval '(cperl-lazy-unstall))
-	     (and (fboundp 'run-with-idle-timer)
-		  cperl-lazy-installed)])
-	   ("Toggle..."
-	    ["Auto newline" cperl-toggle-auto-newline t]
-	    ["Electric parens" cperl-toggle-electric t]
-	    ["Electric keywords" cperl-toggle-abbrev t]
-	    ["Fix whitespace on indent" cperl-toggle-construct-fix t]
-	    ["Auto fill" auto-fill-mode t])
-	   ("Indent styles..."
-	    ["CPerl" (cperl-set-style "CPerl") t]
-	    ["PerlStyle" (cperl-set-style "PerlStyle") t]
-	    ["GNU" (cperl-set-style "GNU") t]
-	    ["C++" (cperl-set-style "C++") t]
-	    ["FSF" (cperl-set-style "FSF") t]
-	    ["BSD" (cperl-set-style "BSD") t]
-	    ["Whitesmith" (cperl-set-style "Whitesmith") t]
-	    ["Current" (cperl-set-style "Current") t]
-	    ["Memorized" (cperl-set-style-back) cperl-old-style])
-	   ("Micro-docs"
-	    ["Tips" (describe-variable 'cperl-tips) t]
-	    ["Problems" (describe-variable 'cperl-problems) t]
-	    ["Non-problems" (describe-variable 'cperl-non-problems) t]
-	    ["Speed" (describe-variable 'cperl-speed) t]
-	    ["Praise" (describe-variable 'cperl-praise) t]
-	    ["Faces" (describe-variable 'cperl-tips-faces) t]
-	    ["CPerl mode" (describe-function 'cperl-mode) t]
-	    ["CPerl version"
-	     (message "The version of master-file for this CPerl is %s"
-		      cperl-version) t]))))
+	   ["Create tags for current file" (cperl-write-tags nil t) t]
+	   ["Add tags for current file" (cperl-write-tags) t]
+	   ["Create tags for Perl files in directory"
+	    (cperl-write-tags nil t nil t) t]
+	   ["Add tags for Perl files in directory"
+	    (cperl-write-tags nil nil nil t) t]
+	   ["Create tags for Perl files in (sub)directories"
+	    (cperl-write-tags nil t t t) t]
+	   ["Add tags for Perl files in (sub)directories"
+	    (cperl-write-tags nil nil t t) t]))
+	 ("Perl docs"
+	  ["Define word at point" imenu-go-find-at-position 
+	   (fboundp 'imenu-go-find-at-position)]
+	  ["Help on function" cperl-info-on-command t]
+	  ["Help on function at point" cperl-info-on-current-command t]
+	  ["Help on symbol at point" cperl-get-help t]
+	  ["Perldoc" cperl-perldoc t]
+	  ["Perldoc on word at point" cperl-perldoc-at-point t]
+	  ["View manpage of POD in this file" cperl-pod-to-manpage t]
+	  ["Auto-help on" cperl-lazy-install 
+	   (and (fboundp 'run-with-idle-timer)
+		(not cperl-lazy-installed))]
+	  ["Auto-help off" (eval '(cperl-lazy-unstall)) 
+	   (and (fboundp 'run-with-idle-timer)
+		cperl-lazy-installed)])
+	 ("Toggle..."
+	  ["Auto newline" cperl-toggle-auto-newline t]
+	  ["Electric parens" cperl-toggle-electric t]
+	  ["Electric keywords" cperl-toggle-abbrev t]
+	  ["Fix whitespace on indent" cperl-toggle-construct-fix t]
+	  ["Auto fill" auto-fill-mode t]) 
+	 ("Indent styles..."
+	  ["CPerl" (cperl-set-style "CPerl") t]
+	  ["PerlStyle" (cperl-set-style "PerlStyle") t]
+	  ["GNU" (cperl-set-style "GNU") t]
+	  ["C++" (cperl-set-style "C++") t]
+	  ["FSF" (cperl-set-style "FSF") t]
+	  ["BSD" (cperl-set-style "BSD") t]
+	  ["Whitesmith" (cperl-set-style "Whitesmith") t]
+	  ["Current" (cperl-set-style "Current") t]
+	  ["Memorized" (cperl-set-style-back) cperl-old-style])
+	 ("Micro-docs"
+	  ["Tips" (describe-variable 'cperl-tips) t]
+	  ["Problems" (describe-variable 'cperl-problems) t]
+	  ["Non-problems" (describe-variable 'cperl-non-problems) t]
+	  ["Speed" (describe-variable 'cperl-speed) t]
+	  ["Praise" (describe-variable 'cperl-praise) t]
+	  ["Faces" (describe-variable 'cperl-tips-faces) t]
+	  ["CPerl mode" (describe-function 'cperl-mode) t]
+	  ["CPerl version" 
+	   (message "The version of master-file for this CPerl is %s" 
+		    cperl-version) t]))))
   (error nil))
 
 (autoload 'c-macro-expand "cmacexp"
 The expansion is entirely correct because it uses the C preprocessor."
   t)
 
+(defvar cperl-imenu--function-name-regexp-perl
+  (concat
+   "^\\("
+	"[ \t]*\\(sub\\|package\\)[ \t\n]+\\([a-zA-Z_0-9:']+\\)[ \t]*\\(([^()]*)[ \t]*\\)?"
+   "\\|"
+	"=head\\([12]\\)[ \t]+\\([^\n]+\\)$"
+   "\\)"))
+
+(defvar cperl-outline-regexp
+  (concat cperl-imenu--function-name-regexp-perl "\\|" "\\`"))
+
 (defvar cperl-mode-syntax-table nil
   "Syntax table in use in CPerl mode buffers.")
 
   (modify-syntax-entry ?| "." cperl-mode-syntax-table)
   (setq cperl-string-syntax-table (copy-syntax-table cperl-mode-syntax-table))
   (modify-syntax-entry ?$ "." cperl-string-syntax-table)
-  (modify-syntax-entry ?# "." cperl-string-syntax-table) ; (?# comment )
-)
+  (modify-syntax-entry ?# "." cperl-string-syntax-table)) ; (?# comment )
 
 
 
 (defvar perl-font-lock-keywords-1)
 (defvar perl-font-lock-keywords-2)
 (defvar outline-level)
-(defvar cperl-outline-regexp)
+(if (fboundp 'defvaralias)
+    (let ((f 'defvaralias)) ; Some functions deduce stuff from the mode name...
+      (funcall f 'cperl-font-lock-keywords   'perl-font-lock-keywords)
+      (funcall f 'cperl-font-lock-keywords-1 'perl-font-lock-keywords-1)
+      (funcall f 'cperl-font-lock-keywords-2 'perl-font-lock-keywords-2)))
+
+(defvar cperl-use-major-mode 'perl-mode)
 
 ;;;###autoload
 (defun cperl-mode ()
 span the needed amount of lines.
 
 Variables `cperl-pod-here-scan', `cperl-pod-here-fontify',
-`cperl-pod-face', `cperl-pod-head-face' control processing of pod and
+`cperl-pod-face', `cperl-pod-head-face' control processing of POD and
 here-docs sections.  With capable Emaxen results of scan are used
 for indentation too, otherwise they are used for highlighting only.
 
 	(cperl-define-key "\C-hf" 'cperl-info-on-current-command [(control h) f])
 	(cperl-define-key "\C-c\C-hf" 'cperl-info-on-command
 			  [(control c) (control h) f])))
-  (setq major-mode 'perl-mode)
+  (setq major-mode cperl-use-major-mode)
   (setq mode-name "CPerl")
   (if (not cperl-mode-abbrev-table)
       (let ((prev-a-c abbrevs-changed))
   (setq paragraph-separate paragraph-start)
   (make-local-variable 'paragraph-ignore-fill-prefix)
   (setq paragraph-ignore-fill-prefix t)
+  ;; XEmacs addition
   (when cperl-xemacs-p
     (make-local-variable 'paren-backwards-message)
     (setq paren-backwards-message t))
   ;;(setq auto-fill-function 'cperl-do-auto-fill) ; Need to switch on and off!
   (make-local-variable 'imenu-create-index-function)
   (setq imenu-create-index-function
-	(function imenu-example--create-perl-index))
+	(function cperl-imenu--create-perl-index))
   (make-local-variable 'imenu-sort-function)
   (setq imenu-sort-function nil)
   (make-local-variable 'vc-header-alist)
   (make-local-variable 'cperl-syntax-state)
   (if cperl-use-syntax-table-text-property
       (progn
-	(make-variable-buffer-local 'parse-sexp-lookup-properties)
+	(make-local-variable 'parse-sexp-lookup-properties)
 	;; Do not introduce variable if not needed, we check it!
 	(set 'parse-sexp-lookup-properties t)
 	;; Fix broken font-lock:
 	(or (boundp 'font-lock-unfontify-region-function)
 	    (set 'font-lock-unfontify-region-function
-		  'font-lock-default-unfontify-region))
+		 'font-lock-default-unfontify-region))
+        ;; XEmacs change: no unfontify stuff
 	(unless cperl-xemacs-p
-	  (make-variable-buffer-local 'font-lock-unfontify-region-function)
-	  (set 'font-lock-unfontify-region-function
+	  (make-local-variable 'font-lock-unfontify-region-function)
+	  (set 'font-lock-unfontify-region-function ;not present with old Emacs
 	       'cperl-font-lock-unfontify-region-function))
-	(make-variable-buffer-local 'cperl-syntax-done-to)
+	(make-local-variable 'cperl-syntax-done-to)
 	;; Another bug: unless font-lock-syntactic-keywords, font-lock
 	;;  ignores syntax-table text-property.  (t) is a hack
 	;;  to make font-lock think that font-lock-syntactic-keywords
 	;;  are defined
-	(make-variable-buffer-local 'font-lock-syntactic-keywords)
+	(make-local-variable 'font-lock-syntactic-keywords)
 	(setq font-lock-syntactic-keywords
 	      (if cperl-syntaxify-by-font-lock
 		  '(t (cperl-fontify-syntaxically))
 		'(t)))))
   (make-local-variable 'cperl-old-style)
-  ;; XEmacs change: older versions of our fill.el don't buffer-localize
-  ;; fill-paragraph-function.
+  ;; XEmacs addition: set fill-paragraph-function.  Note that older versions
+  ;; of our fill.el don't buffer-localize it.
   (make-local-variable 'fill-paragraph-function)
   (setq fill-paragraph-function 'cperl-fill-paragraph)
-  (or (fboundp 'cperl-old-auto-fill-mode)
-      (progn
-	(fset 'cperl-old-auto-fill-mode (symbol-function 'auto-fill-mode))
-	(defun auto-fill-mode (&optional arg)
-	  (interactive "P")
-	  (eval '(cperl-old-auto-fill-mode arg)) ; Avoid a warning
-	  (and auto-fill-function (eq major-mode 'perl-mode)
-	       (setq auto-fill-function 'cperl-do-auto-fill)))))
+  (if (boundp 'normal-auto-fill-function) ; 19.33 and later
+      (set (make-local-variable 'normal-auto-fill-function)
+	   'cperl-do-auto-fill)	      ; RMS has it as #'cperl-do-auto-fill ???
+    (or (fboundp 'cperl-old-auto-fill-mode)
+	(progn
+	  (fset 'cperl-old-auto-fill-mode (symbol-function 'auto-fill-mode))
+	  (defun auto-fill-mode (&optional arg)
+	    (interactive "P")
+	    (eval '(cperl-old-auto-fill-mode arg)) ; Avoid a warning
+	    (and auto-fill-function (memq major-mode '(perl-mode cperl-mode))
+		 (setq auto-fill-function 'cperl-do-auto-fill))))))
   (if (cperl-enable-font-lock)
       (if (cperl-val 'cperl-font-lock)
 	  (progn (or cperl-faces-init (cperl-init-faces))
   (run-hooks 'cperl-mode-hook)
   ;; After hooks since fontification will break this
   (if cperl-pod-here-scan
-      (or ;;(and (boundp 'font-lock-mode)
-	  ;;     (eval 'font-lock-mode)	; Avoid warning
-	  ;;     (boundp 'font-lock-hot-pass) ; Newer font-lock
-       cperl-syntaxify-by-font-lock  ;;)
+      (or cperl-syntaxify-by-font-lock
        (progn (or cperl-faces-init (cperl-init-faces-weak))
 	      (cperl-find-pods-heres)))))
 
 ;; Fix for perldb - make default reasonable
-(defvar gud-perldb-history)
 (defun cperl-db ()
   (interactive)
   (require 'gud)
 				(if (consp gud-perldb-history)
 				    (car gud-perldb-history)
 				  (concat "perl " ;;(file-name-nondirectory
-						   ;; I have problems
-						   ;; in OS/2
-						   ;; otherwise
-						   (buffer-file-name)))
+					  ;; I have problems
+					  ;; in OS/2
+					  ;; otherwise
+					  (buffer-file-name)))
 				nil nil
 				'(gud-perldb-history . 1))))
 
-(defvar msb-menu-cond)
 (defun cperl-msb-fix ()
   ;; Adds perl files to msb menu, supposes that msb is already loaded
   (setq cperl-msb-fixed t)
 	 (handle (1- (nth 1 last))))
     (setcdr precdr (list
 		    (list
-		     '(eq major-mode 'perl-mode)
+		     '(memq major-mode '(cperl-mode perl-mode))
 		     handle
 		     "Perl Files (%d)")
 		    last))))
 	    (setq last-command-char ?\{)
 	    (cperl-electric-lbrace arg insertpos))
 	  (forward-char 1))
-      ;: Check whether we close something "usual" with `}'
+      ;; Check whether we close something "usual" with `}'
       (if (and (eq last-command-char ?\})
 	       (not
 		(condition-case nil
 (defun cperl-electric-lbrace (arg &optional end)
   "Insert character, correct line's indentation, correct quoting by space."
   (interactive "P")
-  (let (pos after
-	    (cperl-brace-recursing t)
-	    (cperl-auto-newline cperl-auto-newline)
-	    (other-end (or end
-			   (if (and cperl-electric-parens-mark
-				    (cperl-mark-active)
-				    (> (mark) (point)))
-			       (save-excursion
-				 (goto-char (mark))
-				 (point-marker))
-			     nil))))
+  (let ((cperl-brace-recursing t)
+	(cperl-auto-newline cperl-auto-newline)
+	(other-end (or end
+		       (if (and cperl-electric-parens-mark
+				(cperl-mark-active)
+				(> (mark) (point)))
+			   (save-excursion
+			     (goto-char (mark))
+			     (point-marker))
+			 nil)))
+	pos after)
     (and (cperl-val 'cperl-electric-lbrace-space)
 	 (eq (preceding-char) ?$)
 	 (save-excursion
 	(other-end (if (and cperl-electric-parens-mark
 			    (cperl-mark-active)
 			    (> (mark) (point)))
-			   (save-excursion
-			     (goto-char (mark))
-			     (point-marker))
+		       (save-excursion
+			 (goto-char (mark))
+			 (point-marker))
 		     nil)))
     (if (and (cperl-val 'cperl-electric-parens)
 	     (memq last-command-char
 	  (insert (make-string
 		   (prefix-numeric-value arg)
 		   (cdr (assoc last-command-char '((?\} . ?\{)
-						  (?\] . ?\[)
-						  (?\) . ?\()
-						  (?\> . ?\<))))))
+						   (?\] . ?\[)
+						   (?\) . ?\()
+						   (?\> . ?\<))))))
 	  (goto-char (1+ p)))
       (self-insert-command (prefix-numeric-value arg)))))
 
  	     (insert "\n}")
 	     (and do (insert " while ();")))
  	    (t
- 	     (insert (if do " {\n} while ();" " () {\n}")))
- 	    )
+ 	     (insert (if do " {\n} while ();" " () {\n}"))))
 	   (or (looking-at "[ \t]\\|$") (insert " "))
 	   (cperl-indent-line)
 	   (if dollar (progn (search-backward "$")
 			   (save-excursion
 			     (forward-char -1)
 			     (re-search-backward "\\(\\`\n?\\|\n\n\\)=head1\\>"
-						nil t)))) ; Only one
+						 nil t)))) ; Only one
 		     (progn
 		       (forward-word 1)
 		       (setq name (file-name-sans-extension
  	     (cperl-indent-line)
  	     (insert "\n\n}"))
  	    (t
- 	     (insert " {\n\n}"))
- 	    )
+ 	     (insert " {\n\n}")))
 	   (or (looking-at "[ \t]\\|$") (insert " "))
 	   (cperl-indent-line)
 	   (forward-line -1)
     (if (and				; Check if we need to split:
 					; i.e., on a boundary and inside "{...}"
 	 (save-excursion (cperl-to-comment-or-eol)
-	   (>= (point) pos))		; Not in a comment
+			 (>= (point) pos)) ; Not in a comment
 	 (or (save-excursion
 	       (skip-chars-backward " \t" beg)
 	       (forward-char -1)
 	  (cperl-indent-line)
 	  (beginning-of-line)
 	  (or (looking-at "[ \t]*}[,; \t]*$") ; If there is a statement
-					    ; after, move it to separate line
+					; after, move it to separate line
 	      (progn
 		(end-of-line)
 		(search-backward "}" beg)
 	     (save-excursion
 	       (skip-chars-backward " \t")
 	       (eq (preceding-char) ?\)))) ; Probably if () {} group
-					   ; with an extra newline.
+					; with an extra newline.
 	(forward-line 2)
 	(cperl-indent-line))
        ((save-excursion			; In POD header
 (defun cperl-electric-terminator (arg)
   "Insert character and correct line's indentation."
   (interactive "P")
-  (let (insertpos (end (point))
-		  (auto (and cperl-auto-newline
-			     (or (not (eq last-command-char ?:))
-				 cperl-auto-newline-after-colon))))
+  (let ((end (point))
+	(auto (and cperl-auto-newline
+		   (or (not (eq last-command-char ?:))
+		       cperl-auto-newline-after-colon)))
+	insertpos)
     (if (and ;;(not arg)
 	     (eolp)
 	     (not (save-excursion
 	  (delete-region (point) p))
       (backward-delete-char-untabify arg))))
 
+;; XEmacs addition
 ;; helper function for deletion, which honors the desired delete direction
 ;; behavior.  Added by Gary D. Foster, <Gary.Foster@corp.sun.com> and bound
 ;; to the 'delete keysym by default.
-
 (defun cperl-electric-delete (arg)
   "Delete, or remove the whitespace inserted by an electric key.
 Delete direction is controlled by the setting of `delete-key-deletes-forward'."
 (defun cperl-indent-line (&optional parse-data)
   "Indent current line as Perl code.
 Return the amount the indentation changed by."
-  (let (indent i beg shift-amt
-	(case-fold-search nil)
-	(pos (- (point-max) (point))))
+  (let ((case-fold-search nil)
+	(pos (- (point-max) (point)))
+	indent i beg shift-amt)
     (setq indent (cperl-calculate-indent parse-data)
 	  i indent)
     (beginning-of-line)
       (or state (setq state (parse-partial-sexp start start-point -1 nil start-state)))
       (list start state depth prestart))))
 
-(defun cperl-block-p ()			; Do not C-M-q !  One string contains ";" !
+(defun cperl-block-p ()		   ; Do not C-M-q !  One string contains ";" !
   ;; Positions is before ?\{.  Checks whether it starts a block.
   ;; No save-excursion!
   (cperl-backward-to-noncomment (point-min))
 Returns nil if line starts inside a string, t if in a comment.
 
 Will not correct the indentation for labels, but will correct it for braces
-and closing parentheses and brackets.."
+and closing parentheses and brackets."
   (save-excursion
     (if (or
 	 (and (memq (get-text-property (point) 'syntax-type)
 	      (not (get-text-property (point) 'indentable)))
 	 ;; before start of POD - whitespace found since do not have 'pod!
 	 (and (looking-at "[ \t]*\n=")
-	      (error "Spaces before pod section!"))
+	      (error "Spaces before POD section!"))
 	 (and (not cperl-indent-left-aligned-comments)
 	      (looking-at "^#")))
 	nil
-     (beginning-of-line)
-     (let ((indent-point (point))
-	   (char-after (save-excursion
-			   (skip-chars-forward " \t")
-			   (following-char)))
-	   (in-pod (get-text-property (point) 'in-pod))
-	   (pre-indent-point (point))
-	   p prop look-prop is-block delim)
-      (cond
-       (in-pod
-	;; In the verbatim part, probably code example.  What to do???
-	)
-       (t
-	(save-excursion
-	  ;; Not in pod
-	  (cperl-backward-to-noncomment nil)
-	  (setq p (max (point-min) (1- (point)))
-		prop (get-text-property p 'syntax-type)
-		look-prop (or (nth 1 (assoc prop cperl-look-for-prop))
-			      'syntax-type))
-	  (if (memq prop '(pod here-doc format here-doc-delim))
+      (beginning-of-line)
+      (let ((indent-point (point))
+	    (char-after (save-excursion
+			  (skip-chars-forward " \t")
+			  (following-char)))
+	    (in-pod (get-text-property (point) 'in-pod))
+	    (pre-indent-point (point))
+	    p prop look-prop is-block delim)
+	(cond
+	 (in-pod
+	  ;; In the verbatim part, probably code example.  What to do???
+	  )
+	 (t
+	  (save-excursion
+	    ;; Not in POD
+	    (cperl-backward-to-noncomment nil)
+	    (setq p (max (point-min) (1- (point)))
+		  prop (get-text-property p 'syntax-type)
+		  look-prop (or (nth 1 (assoc prop cperl-look-for-prop))
+				'syntax-type))
+	    (if (memq prop '(pod here-doc format here-doc-delim))
+		(progn
+		  (goto-char (or (previous-single-property-change p look-prop)
+				 (point-min)))
+		  (beginning-of-line)
+		  (setq pre-indent-point (point)))))))
+	(goto-char pre-indent-point)
+	(let* ((case-fold-search nil)
+	       (s-s (cperl-get-state (car parse-data) (nth 1 parse-data)))
+	       (start (or (nth 2 parse-data)
+			  (nth 0 s-s)))
+	       (state (nth 1 s-s))
+	       (containing-sexp (car (cdr state)))
+	       old-indent)
+	  (if (and
+	       ;;containing-sexp		;; We are buggy at toplevel :-(
+	       parse-data)
 	      (progn
-		(goto-char (or (previous-single-property-change p look-prop)
-			       (point-min)))
-		(beginning-of-line)
-		(setq pre-indent-point (point)))))))
-      (goto-char pre-indent-point)
-      (let* ((case-fold-search nil)
-	     (s-s (cperl-get-state (car parse-data) (nth 1 parse-data)))
-	     (start (or (nth 2 parse-data)
-			(nth 0 s-s)))
-	     (state (nth 1 s-s))
-	     (containing-sexp (car (cdr state)))
-	     old-indent)
-	(if (and
-	     ;;containing-sexp		;; We are buggy at toplevel :-(
-	     parse-data)
-	    (progn
-	      (setcar parse-data pre-indent-point)
-	      (setcar (cdr parse-data) state)
-	      (or (nth 2 parse-data)
-		  (setcar (cddr parse-data) start))
-	      ;; Before this point: end of statement
-	      (setq old-indent (nth 3 parse-data))))
-	(cond ((get-text-property (point) 'indentable)
-	       ;; indent to just after the surrounding open,
-	       ;; skip blanks if we do not close the expression.
-	       (goto-char (1+ (previous-single-property-change (point) 'indentable)))
-	       (or (memq char-after (append ")]}" nil))
-		   (looking-at "[ \t]*\\(#\\|$\\)")
-		   (skip-chars-forward " \t"))
-	       (current-column))
-	      ((or (nth 3 state) (nth 4 state))
-	       ;; return nil or t if should not change this line
-	       (nth 4 state))
-	      ;; XXXX Do we need to special-case this?
-	      ((null containing-sexp)
-	       ;; Line is at top level.  May be data or function definition,
-	       ;; or may be function argument declaration.
-	       ;; Indent like the previous top level line
-	       ;; unless that ends in a closeparen without semicolon,
-	       ;; in which case this line is the first argument decl.
-	       (skip-chars-forward " \t")
-	       (+ (save-excursion
-		    (goto-char start)
-		    (- (current-indentation)
-		       (if (nth 2 s-s) cperl-indent-level 0)))
-		  (if (= char-after ?{) cperl-continued-brace-offset 0)
-		  (progn
-		    (cperl-backward-to-noncomment (or old-indent (point-min)))
-		    ;; Look at previous line that's at column 0
-		    ;; to determine whether we are in top-level decls
-		    ;; or function's arg decls.  Set basic-indent accordingly.
-		    ;; Now add a little if this is a continuation line.
-		    (if (or (bobp)
-			    (eq (point) old-indent) ; old-indent was at comment
-			    (eq (preceding-char) ?\;)
-			    ;;  Had ?\) too
-			    (and (eq (preceding-char) ?\})
-				 (cperl-after-block-and-statement-beg
-				  (point-min)))	; Was start - too close
-			    (memq char-after (append ")]}" nil))
-			    (and (eq (preceding-char) ?\:) ; label
-				 (progn
-				   (forward-sexp -1)
-				   (skip-chars-backward " \t")
-				   (looking-at "[ \t]*[a-zA-Z_][a-zA-Z_0-9]*[ \t]*:"))))
-			(progn
-			  (if (and parse-data
-				   (not (eq char-after ?\C-j)))
-			      (setcdr (cddr parse-data)
-				      (list pre-indent-point)))
-			  0)
-		      cperl-continued-statement-offset))))
-	      ((not
-		(or (setq is-block
-			  (and (setq delim (= (char-after containing-sexp) ?{))
-			       (save-excursion ; Is it a hash?
-				 (goto-char containing-sexp)
-				 (cperl-block-p))))
-		    cperl-indent-parens-as-block))
-	       ;; group is an expression, not a block:
-	       ;; indent to just after the surrounding open parens,
-	       ;; skip blanks if we do not close the expression.
-	       (goto-char (1+ containing-sexp))
-	       (or (memq char-after
-			 (append (if delim "}" ")]}") nil))
-		   (looking-at "[ \t]*\\(#\\|$\\)")
-		   (skip-chars-forward " \t"))
-	       (+ (current-column)
-		  (if (and delim
-			   (eq char-after ?\}))
-		      ;; Correct indentation of trailing ?\}
-		      (+ cperl-indent-level cperl-close-paren-offset)
-		    0)))
+		(setcar parse-data pre-indent-point)
+		(setcar (cdr parse-data) state)
+		(or (nth 2 parse-data)
+		    (setcar (cddr parse-data) start))
+		;; Before this point: end of statement
+		(setq old-indent (nth 3 parse-data))))
+	  (cond ((get-text-property (point) 'indentable)
+		 ;; indent to just after the surrounding open,
+		 ;; skip blanks if we do not close the expression.
+		 (goto-char (1+ (previous-single-property-change (point) 'indentable)))
+		 (or (memq char-after (append ")]}" nil))
+		     (looking-at "[ \t]*\\(#\\|$\\)")
+		     (skip-chars-forward " \t"))
+		 (current-column))
+		((or (nth 3 state) (nth 4 state))
+		 ;; return nil or t if should not change this line
+		 (nth 4 state))
+		;; XXXX Do we need to special-case this?
+		((null containing-sexp)
+		 ;; Line is at top level.  May be data or function definition,
+		 ;; or may be function argument declaration.
+		 ;; Indent like the previous top level line
+		 ;; unless that ends in a closeparen without semicolon,
+		 ;; in which case this line is the first argument decl.
+		 (skip-chars-forward " \t")
+		 (+ (save-excursion
+		      (goto-char start)
+		      (- (current-indentation)
+			 (if (nth 2 s-s) cperl-indent-level 0)))
+		    (if (= char-after ?{) cperl-continued-brace-offset 0)
+		    (progn
+		      (cperl-backward-to-noncomment (or old-indent (point-min)))
+		      ;; Look at previous line that's at column 0
+		      ;; to determine whether we are in top-level decls
+		      ;; or function's arg decls.  Set basic-indent accordingly.
+		      ;; Now add a little if this is a continuation line.
+		      (if (or (bobp)
+			      (eq (point) old-indent) ; old-indent was at comment
+			      (eq (preceding-char) ?\;)
+			      ;;  Had ?\) too
+			      (and (eq (preceding-char) ?\})
+				   (cperl-after-block-and-statement-beg
+				    (point-min))) ; Was start - too close
+			      (memq char-after (append ")]}" nil))
+			      (and (eq (preceding-char) ?\:) ; label
+				   (progn
+				     (forward-sexp -1)
+				     (skip-chars-backward " \t")
+				     (looking-at "[ \t]*[a-zA-Z_][a-zA-Z_0-9]*[ \t]*:"))))
+			  (progn
+			    (if (and parse-data
+				     (not (eq char-after ?\C-j)))
+				(setcdr (cddr parse-data)
+					(list pre-indent-point)))
+			    0)
+			cperl-continued-statement-offset))))
+		((not
+		  (or (setq is-block
+			    (and (setq delim (= (char-after containing-sexp) ?{))
+				 (save-excursion ; Is it a hash?
+				   (goto-char containing-sexp)
+				   (cperl-block-p))))
+		      cperl-indent-parens-as-block))
+		 ;; group is an expression, not a block:
+		 ;; indent to just after the surrounding open parens,
+		 ;; skip blanks if we do not close the expression.
+		 (goto-char (1+ containing-sexp))
+		 (or (memq char-after
+			   (append (if delim "}" ")]}") nil))
+		     (looking-at "[ \t]*\\(#\\|$\\)")
+		     (skip-chars-forward " \t"))
+		 (+ (current-column)
+		    (if (and delim
+			     (eq char-after ?\}))
+			;; Correct indentation of trailing ?\}
+			(+ cperl-indent-level cperl-close-paren-offset)
+		      0)))
 ;;;	      ((and (/= (char-after containing-sexp) ?{)
 ;;;		    (not cperl-indent-parens-as-block))
 ;;;	       ;; line is expression, not statement:
 ;;;		  (if (eq char-after ?\}) (+ cperl-indent-level
 ;;;					     cperl-close-paren-offset)
 ;;;		    0)))
-	      (t
-	       ;; Statement level.  Is it a continuation or a new statement?
-	       ;; Find previous non-comment character.
-	       (goto-char pre-indent-point)
-	       (cperl-backward-to-noncomment containing-sexp)
-	       ;; Back up over label lines, since they don't
-	       ;; affect whether our line is a continuation.
-	       ;; (Had \, too)
-	       (while ;;(or (eq (preceding-char) ?\,)
-			  (and (eq (preceding-char) ?:)
-			       (or;;(eq (char-after (- (point) 2)) ?\') ; ????
-				(memq (char-syntax (char-after (- (point) 2)))
-				      '(?w ?_))))
-			  ;;)
-		 (if (eq (preceding-char) ?\,)
-		     ;; Will go to beginning of line, essentially.
-		     ;; Will ignore embedded sexpr XXXX.
-		     (cperl-backward-to-start-of-continued-exp containing-sexp))
-		 (beginning-of-line)
-		 (cperl-backward-to-noncomment containing-sexp))
-	       ;; Now we get the answer.
-	       (if (not (or (eq (1- (point)) containing-sexp)
-			    (memq (preceding-char)
-				  (append (if is-block " ;{" " ,;{") '(nil)))
-			    (and (eq (preceding-char) ?\})
-				 (cperl-after-block-and-statement-beg
-				  containing-sexp))))
-		   ;; This line is continuation of preceding line's statement;
-		   ;; indent  `cperl-continued-statement-offset'  more than the
-		   ;; previous line of the statement.
-		   ;;
-		   ;; There might be a label on this line, just
-		   ;; consider it bad style and ignore it.
-		   (progn
-		     (cperl-backward-to-start-of-continued-exp containing-sexp)
-		     (+ (if (memq char-after (append "}])" nil))
-			    0		; Closing parenth
-			  cperl-continued-statement-offset)
-			(if (or is-block
-				(not delim)
-				(not (eq char-after ?\})))
-			    0
-			  ;; Now it is a hash reference
-			  (+ cperl-indent-level cperl-close-paren-offset))
-			(if (looking-at "\\w+[ \t]*:")
-			    (if (> (current-indentation) cperl-min-label-indent)
-				(- (current-indentation) cperl-label-offset)
-			      ;; Do not move `parse-data', this should
-			      ;; be quick anyway (this comment comes
-			      ;; from different location):
-			      (cperl-calculate-indent))
-			  (current-column))
-			(if (eq char-after ?\{)
-			    cperl-continued-brace-offset 0)))
-		 ;; This line starts a new statement.
-		 ;; Position following last unclosed open.
-		 (goto-char containing-sexp)
-		 ;; Is line first statement after an open-brace?
-		 (or
-		  ;; If no, find that first statement and indent like
-		  ;; it.  If the first statement begins with label, do
-		  ;; not believe when the indentation of the label is too
-		  ;; small.
-		  (save-excursion
-		    (forward-char 1)
-		    (setq old-indent (current-indentation))
-		    (let ((colon-line-end 0))
-		      (while (progn (skip-chars-forward " \t\n")
-				    (looking-at "#\\|[a-zA-Z0-9_$]*:[^:]"))
-			;; Skip over comments and labels following openbrace.
-			(cond ((= (following-char) ?\#)
-			       (forward-line 1))
-			      ;; label:
-			      (t
-			       (save-excursion (end-of-line)
-					       (setq colon-line-end (point)))
-			       (search-forward ":"))))
-		      ;; The first following code counts
-		      ;; if it is before the line we want to indent.
-		      (and (< (point) indent-point)
-			   (if (> colon-line-end (point)) ; After label
-			       (if (> (current-indentation)
-				      cperl-min-label-indent)
+		(t
+		 ;; Statement level.  Is it a continuation or a new statement?
+		 ;; Find previous non-comment character.
+		 (goto-char pre-indent-point)
+		 (cperl-backward-to-noncomment containing-sexp)
+		 ;; Back up over label lines, since they don't
+		 ;; affect whether our line is a continuation.
+		 ;; (Had \, too)
+		 (while	;;(or (eq (preceding-char) ?\,)
+		     (and (eq (preceding-char) ?:)
+			  (or ;;(eq (char-after (- (point) 2)) ?\') ; ????
+			   (memq (char-syntax (char-after (- (point) 2)))
+				 '(?w ?_))))
+		   ;;)
+		   (if (eq (preceding-char) ?\,)
+		       ;; Will go to beginning of line, essentially.
+		       ;; Will ignore embedded sexpr XXXX.
+		       (cperl-backward-to-start-of-continued-exp containing-sexp))
+		   (beginning-of-line)
+		   (cperl-backward-to-noncomment containing-sexp))
+		 ;; Now we get the answer.
+		 (if (not (or (eq (1- (point)) containing-sexp)
+			      (memq (preceding-char)
+				    (append (if is-block " ;{" " ,;{") '(nil)))
+			      (and (eq (preceding-char) ?\})
+				   (cperl-after-block-and-statement-beg
+				    containing-sexp))))
+		     ;; This line is continuation of preceding line's statement;
+		     ;; indent  `cperl-continued-statement-offset'  more than the
+		     ;; previous line of the statement.
+		     ;;
+		     ;; There might be a label on this line, just
+		     ;; consider it bad style and ignore it.
+		     (progn
+		       (cperl-backward-to-start-of-continued-exp containing-sexp)
+		       (+ (if (memq char-after (append "}])" nil))
+			      0		; Closing parenth
+			    cperl-continued-statement-offset)
+			  (if (or is-block
+				  (not delim)
+				  (not (eq char-after ?\})))
+			      0
+			    ;; Now it is a hash reference
+			    (+ cperl-indent-level cperl-close-paren-offset))
+			  (if (looking-at "\\w+[ \t]*:")
+			      (if (> (current-indentation) cperl-min-label-indent)
+				  (- (current-indentation) cperl-label-offset)
+				;; Do not move `parse-data', this should
+				;; be quick anyway (this comment comes
+				;; from different location):
+				(cperl-calculate-indent))
+			    (current-column))
+			  (if (eq char-after ?\{)
+			      cperl-continued-brace-offset 0)))
+		   ;; This line starts a new statement.
+		   ;; Position following last unclosed open.
+		   (goto-char containing-sexp)
+		   ;; Is line first statement after an open-brace?
+		   (or
+		    ;; If no, find that first statement and indent like
+		    ;; it.  If the first statement begins with label, do
+		    ;; not believe when the indentation of the label is too
+		    ;; small.
+		    (save-excursion
+		      (forward-char 1)
+		      (setq old-indent (current-indentation))
+		      (let ((colon-line-end 0))
+			(while (progn (skip-chars-forward " \t\n")
+				      (looking-at "#\\|[a-zA-Z0-9_$]*:[^:]"))
+			  ;; Skip over comments and labels following openbrace.
+			  (cond ((= (following-char) ?\#)
+				 (forward-line 1))
+				;; label:
+				(t
+				 (save-excursion (end-of-line)
+						 (setq colon-line-end (point)))
+				 (search-forward ":"))))
+			;; The first following code counts
+			;; if it is before the line we want to indent.
+			(and (< (point) indent-point)
+			     (if (> colon-line-end (point)) ; After label
+				 (if (> (current-indentation)
+					cperl-min-label-indent)
+				     (- (current-indentation) cperl-label-offset)
+				   ;; Do not believe: `max' is involved
+				   (+ old-indent cperl-indent-level))
+			       (current-column)))))
+		    ;; If no previous statement,
+		    ;; indent it relative to line brace is on.
+		    ;; For open brace in column zero, don't let statement
+		    ;; start there too.  If cperl-indent-level is zero,
+		    ;; use cperl-brace-offset + cperl-continued-statement-offset instead.
+		    ;; For open-braces not the first thing in a line,
+		    ;; add in cperl-brace-imaginary-offset.
+
+		    ;; If first thing on a line:  ?????
+		    (+ (if (and (bolp) (zerop cperl-indent-level))
+			   (+ cperl-brace-offset cperl-continued-statement-offset)
+			 cperl-indent-level)
+		       (if (or is-block
+			       (not delim)
+			       (not (eq char-after ?\})))
+			   0
+			 ;; Now it is a hash reference
+			 (+ cperl-indent-level cperl-close-paren-offset))
+		       ;; Move back over whitespace before the openbrace.
+		       ;; If openbrace is not first nonwhite thing on the line,
+		       ;; add the cperl-brace-imaginary-offset.
+		       (progn (skip-chars-backward " \t")
+			      (if (bolp) 0 cperl-brace-imaginary-offset))
+		       ;; If the openbrace is preceded by a parenthesized exp,
+		       ;; move to the beginning of that;
+		       ;; possibly a different line
+		       (progn
+			 (if (eq (preceding-char) ?\))
+			     (forward-sexp -1))
+			 ;; In the case it starts a subroutine, indent with
+			 ;; respect to `sub', not with respect to the
+			 ;; first thing on the line, say in the case of
+			 ;; anonymous sub in a hash.
+			 ;;
+			 (skip-chars-backward " \t")
+			 (if (and (eq (preceding-char) ?b)
+				  (progn
+				    (forward-sexp -1)
+				    (looking-at "sub\\>"))
+				  (setq old-indent
+					(nth 1
+					     (parse-partial-sexp
+					      (save-excursion (beginning-of-line) (point))
+					      (point)))))
+			     (progn (goto-char (1+ old-indent))
+				    (skip-chars-forward " \t")
+				    (current-column))
+			   ;; Get initial indentation of the line we are on.
+			   ;; If line starts with label, calculate label indentation
+			   (if (save-excursion
+				 (beginning-of-line)
+				 (looking-at "[ \t]*[a-zA-Z_][a-zA-Z_0-9]*:[^:]"))
+			       (if (> (current-indentation) cperl-min-label-indent)
 				   (- (current-indentation) cperl-label-offset)
-				 ;; Do not believe: `max' is involved
-				 (+ old-indent cperl-indent-level))
-			     (current-column)))))
-		  ;; If no previous statement,
-		  ;; indent it relative to line brace is on.
-		  ;; For open brace in column zero, don't let statement
-		  ;; start there too.  If cperl-indent-level is zero,
-		  ;; use cperl-brace-offset + cperl-continued-statement-offset instead.
-		  ;; For open-braces not the first thing in a line,
-		  ;; add in cperl-brace-imaginary-offset.
-
-		  ;; If first thing on a line:  ?????
-		  (+ (if (and (bolp) (zerop cperl-indent-level))
-			 (+ cperl-brace-offset cperl-continued-statement-offset)
-		       cperl-indent-level)
-		     (if (or is-block
-			     (not delim)
-			     (not (eq char-after ?\})))
-			 0
-		       ;; Now it is a hash reference
-		       (+ cperl-indent-level cperl-close-paren-offset))
-		     ;; Move back over whitespace before the openbrace.
-		     ;; If openbrace is not first nonwhite thing on the line,
-		     ;; add the cperl-brace-imaginary-offset.
-		     (progn (skip-chars-backward " \t")
-			    (if (bolp) 0 cperl-brace-imaginary-offset))
-		     ;; If the openbrace is preceded by a parenthesized exp,
-		     ;; move to the beginning of that;
-		     ;; possibly a different line
-		     (progn
-		       (if (eq (preceding-char) ?\))
-			   (forward-sexp -1))
-		       ;; In the case it starts a subroutine, indent with
-		       ;; respect to `sub', not with respect to the
-		       ;; first thing on the line, say in the case of
-		       ;; anonymous sub in a hash.
-		       ;;
-		       (skip-chars-backward " \t")
-		       (if (and (eq (preceding-char) ?b)
-				(progn
-				  (forward-sexp -1)
-				  (looking-at "sub\\>"))
-				(setq old-indent
-				      (nth 1
-					   (parse-partial-sexp
-					    (save-excursion (beginning-of-line) (point))
-					    (point)))))
-			   (progn (goto-char (1+ old-indent))
-				  (skip-chars-forward " \t")
-				  (current-column))
-			 ;; Get initial indentation of the line we are on.
-			 ;; If line starts with label, calculate label indentation
-			 (if (save-excursion
-			       (beginning-of-line)
-			       (looking-at "[ \t]*[a-zA-Z_][a-zA-Z_0-9]*:[^:]"))
-			     (if (> (current-indentation) cperl-min-label-indent)
-				 (- (current-indentation) cperl-label-offset)
-			       ;; Do not move `parse-data', this should
-			       ;; be quick anyway:
-			       (cperl-calculate-indent))
-			   (current-indentation))))))))))))))
+				 ;; Do not move `parse-data', this should
+				 ;; be quick anyway:
+				 (cperl-calculate-indent))
+			     (current-indentation))))))))))))))
 
 (defvar cperl-indent-alist
   '((string nil)
 				     (point)))
 			     (cons (list 'expression containing-sexp) res))))
 	    ((progn
-	      ;; Containing-expr starts with \{.  Check whether it is a hash.
-	      (goto-char containing-sexp)
-	      (not (cperl-block-p)))
+	       ;; Containing-expr starts with \{.  Check whether it is a hash.
+	       (goto-char containing-sexp)
+	       (not (cperl-block-p)))
 	     (setq res (cons (list 'expression-blanks
 				   (progn
 				     (goto-char (1+ containing-sexp))
 			(save-excursion (cperl-after-label)))
 	       (if (eq (preceding-char) ?\,)
 		   ;; Will go to beginning of line, essentially
-		     ;; Will ignore embedded sexpr XXXX.
+		   ;; Will ignore embedded sexpr XXXX.
 		   (cperl-backward-to-start-of-continued-exp containing-sexp))
 	       (beginning-of-line)
 	       (cperl-backward-to-noncomment containing-sexp))
   "Go to position before comment on the current line, or to end of line.
 Returns true if comment is found."
   (let (state stop-in cpoint (lim (progn (end-of-line) (point))))
-      (beginning-of-line)
-      (if (or
-	   (eq (get-text-property (point) 'syntax-type) 'pod)
-	   (re-search-forward "\\=[ \t]*\\(#\\|$\\)" lim t))
-	  (if (eq (preceding-char) ?\#) (progn (backward-char 1) t))
-	;; Else
-	(while (not stop-in)
-	  (setq state (parse-partial-sexp (point) lim nil nil nil t))
+    (beginning-of-line)
+    (if (or
+	 (eq (get-text-property (point) 'syntax-type) 'pod)
+	 (re-search-forward "\\=[ \t]*\\(#\\|$\\)" lim t))
+	(if (eq (preceding-char) ?\#) (progn (backward-char 1) t))
+      ;; Else
+      (while (not stop-in)
+	(setq state (parse-partial-sexp (point) lim nil nil nil t))
 					; stop at comment
-	  ;; If fails (beginning-of-line inside sexp), then contains not-comment
-	  (if (nth 4 state)		; After `#';
+	;; If fails (beginning-of-line inside sexp), then contains not-comment
+	(if (nth 4 state)		; After `#';
 					; (nth 2 state) can be
 					; beginning of m,s,qq and so
 					; on
-	      (if (nth 2 state)
-		  (progn
-		    (setq cpoint (point))
-		    (goto-char (nth 2 state))
-		    (cond
-		     ((looking-at "\\(s\\|tr\\)\\>")
-		      (or (re-search-forward
-			   "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*"
-			   lim 'move)
-			  (setq stop-in t)))
-		     ((looking-at "\\(m\\|q\\([qxwr]\\)?\\)\\>")
-		      (or (re-search-forward
-			   "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#"
-			   lim 'move)
-			  (setq stop-in t)))
-		     (t			; It was fair comment
-		      (setq stop-in t)	; Finish
-		      (goto-char (1- cpoint)))))
-		(setq stop-in t)	; Finish
-		(forward-char -1))
-	    (setq stop-in t))		; Finish
-	  )
-	(nth 4 state))))
+	    (if (nth 2 state)
+		(progn
+		  (setq cpoint (point))
+		  (goto-char (nth 2 state))
+		  (cond
+		   ((looking-at "\\(s\\|tr\\)\\>")
+		    (or (re-search-forward
+			 "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*"
+			 lim 'move)
+			(setq stop-in t)))
+		   ((looking-at "\\(m\\|q\\([qxwr]\\)?\\)\\>")
+		    (or (re-search-forward
+			 "\\=\\w+[ \t]*#\\([^\n\\\\#]\\|\\\\[\\\\#]\\)*#"
+			 lim 'move)
+			(setq stop-in t)))
+		   (t			; It was fair comment
+		    (setq stop-in t)	; Finish
+		    (goto-char (1- cpoint)))))
+	      (setq stop-in t)		; Finish
+	      (forward-char -1))
+	  (setq stop-in t)))		; Finish 
+      (nth 4 state))))
 
 (defsubst cperl-1- (p)
   (max (point-min) (1- p)))
   ;; Do after syntactic fontification?
   (if cperl-syntaxify-by-font-lock
       (or now (put-text-property b e 'cperl-postpone (cons type val)))
-      (put-text-property b e type val)))
+    (put-text-property b e type val)))
 
 ;;; Here is how the global structures (those which cannot be
 ;;; recognized locally) are marked:
 		cperl-syntax-state nil
 		cperl-syntax-done-to min))
   (or max (setq max (point-max)))
-  (let* (face head-face here-face b e bb tag qtag b1 e1 argument i c tail tb
-	      is-REx is-x-REx REx-comment-start REx-comment-end was-comment i2
-	      (cperl-pod-here-fontify (eval cperl-pod-here-fontify)) go tmpend
-	      (case-fold-search nil) (inhibit-read-only t) (buffer-undo-list t)
-	      (modified (buffer-modified-p))
-	      (after-change-functions nil)
-	      (use-syntax-state (and cperl-syntax-state
-				     (>= min (car cperl-syntax-state))))
-	      (state-point (if use-syntax-state
-			       (car cperl-syntax-state)
-			     (point-min)))
-	      (state (if use-syntax-state
-			 (cdr cperl-syntax-state)))
-	      ;; (st-l '(nil)) (err-l '(nil)) ; Would overwrite - propagates from a function call to a function call!
-	      (st-l (list nil)) (err-l (list nil))
-	      ;; Somehow font-lock may be not loaded yet...
-	      (font-lock-string-face (if (boundp 'font-lock-string-face)
-					 font-lock-string-face
-				       'font-lock-string-face))
-	      (font-lock-constant-face (if (boundp 'font-lock-constant-face)
-					 font-lock-constant-face
-				       'font-lock-constant-face))
-	      (font-lock-function-name-face
-	       (if (boundp 'font-lock-function-name-face)
-		   font-lock-function-name-face
-		 'font-lock-function-name-face))
-	      (font-lock-comment-face
-	       (if (boundp 'font-lock-comment-face)
-		   font-lock-comment-face
-		 'font-lock-comment-face))
-	      (cperl-nonoverridable-face
-	       (if (boundp 'cperl-nonoverridable-face)
-		   cperl-nonoverridable-face
-		 'cperl-nonoverridable-face))
-	      (stop-point (if ignore-max
-			      (point-max)
-			    max))
-	      (search
+  (let* ((cperl-pod-here-fontify (eval cperl-pod-here-fontify)) go tmpend
+	 face head-face here-face b e bb tag qtag b1 e1 argument i c tail tb
+	 is-REx is-x-REx REx-comment-start REx-comment-end was-comment i2
+	 (case-fold-search nil) (inhibit-read-only t) (buffer-undo-list t)
+	 (modified (buffer-modified-p))
+	 (after-change-functions nil)
+	 (use-syntax-state (and cperl-syntax-state
+				(>= min (car cperl-syntax-state))))
+	 (state-point (if use-syntax-state
+			  (car cperl-syntax-state)
+			(point-min)))
+	 (state (if use-syntax-state
+		    (cdr cperl-syntax-state)))
+	 ;; (st-l '(nil)) (err-l '(nil)) ; Would overwrite - propagates from a function call to a function call!
+	 (st-l (list nil)) (err-l (list nil))
+	 ;; Somehow font-lock may be not loaded yet...
+	 (font-lock-string-face (if (boundp 'font-lock-string-face)
+				    font-lock-string-face
+				  'font-lock-string-face))
+	 (font-lock-constant-face (if (boundp 'font-lock-constant-face)
+				      font-lock-constant-face
+				    'font-lock-constant-face))
+	 (font-lock-function-name-face
+	  (if (boundp 'font-lock-function-name-face)
+	      font-lock-function-name-face
+	    'font-lock-function-name-face))
+	 (font-lock-comment-face
+	  (if (boundp 'font-lock-comment-face)
+	      font-lock-comment-face
+	    'font-lock-comment-face))
+	 (cperl-nonoverridable-face
+	  (if (boundp 'cperl-nonoverridable-face)
+	      cperl-nonoverridable-face
+	    'cperl-nonoverridable-face))
+	 (stop-point (if ignore-max
+			 (point-max)
+		       max))
+	 (search
+	  (concat
+	   "\\(\\`\n?\\|^\n\\)="
+	   "\\|"
+	   ;; One extra () before this:
+	   "<<"
+	   "\\("			; 1 + 1
+	   ;; First variant "BLAH" or just ``.
+	   "[ \t]*"			; Yes, whitespace is allowed!
+	   "\\([\"'`]\\)"		; 2 + 1 = 3
+	   "\\([^\"'`\n]*\\)"		; 3 + 1
+	   "\\3"
+	   "\\|"
+	   ;; Second variant: Identifier or \ID or empty
+	   "\\\\?\\(\\([a-zA-Z_][a-zA-Z_0-9]*\\)?\\)" ; 4 + 1, 5 + 1
+	   ;; Do not have <<= or << 30 or <<30 or << $blah.
+	   ;; "\\([^= \t0-9$@%&]\\|[ \t]+[^ \t\n0-9$@%&]\\)" ; 6 + 1
+	   "\\(\\)"		; To preserve count of pars :-( 6 + 1
+	   "\\)"
+	   "\\|"
+	   ;; 1+6 extra () before this:
+	   "^[ \t]*\\(format\\)[ \t]*\\([a-zA-Z0-9_]+\\)?[ \t]*=[ \t]*$"
+	   (if cperl-use-syntax-table-text-property
 	       (concat
-		"\\(\\`\n?\\|^\n\\)="
 		"\\|"
-		;; One extra () before this:
-		"<<"
-		  "\\("			; 1 + 1
-		  ;; First variant "BLAH" or just ``.
-		     "[ \t]*"		; Yes, whitespace is allowed!
-		     "\\([\"'`]\\)"	; 2 + 1 = 3
-		     "\\([^\"'`\n]*\\)"	; 3 + 1
-		     "\\3"
-		  "\\|"
-		  ;; Second variant: Identifier or \ID or empty
-		    "\\\\?\\(\\([a-zA-Z_][a-zA-Z_0-9]*\\)?\\)" ; 4 + 1, 5 + 1
-		    ;; Do not have <<= or << 30 or <<30 or << $blah.
-		    ;; "\\([^= \t0-9$@%&]\\|[ \t]+[^ \t\n0-9$@%&]\\)" ; 6 + 1
-		    "\\(\\)"		; To preserve count of pars :-( 6 + 1
-		  "\\)"
+		;; 1+6+2=9 extra () before this:
+		"\\<\\(q[wxqr]?\\|[msy]\\|tr\\)\\>"
 		"\\|"
-		;; 1+6 extra () before this:
-		"^[ \t]*\\(format\\)[ \t]*\\([a-zA-Z0-9_]+\\)?[ \t]*=[ \t]*$"
-		(if cperl-use-syntax-table-text-property
-		    (concat
-		     "\\|"
-		     ;; 1+6+2=9 extra () before this:
-		     "\\<\\(q[wxqr]?\\|[msy]\\|tr\\)\\>"
-		     "\\|"
-		     ;; 1+6+2+1=10 extra () before this:
-		     "\\([?/<]\\)"	; /blah/ or ?blah? or <file*glob>
-		     "\\|"
-		     ;; 1+6+2+1+1=11 extra () before this:
-		     "\\<sub\\>[ \t]*\\([a-zA-Z_:'0-9]+[ \t]*\\)?\\(([^()]*)\\)"
-		     "\\|"
-		     ;; 1+6+2+1+1+2=13 extra () before this:
-		     "\\$\\(['{]\\)"
-		     "\\|"
-		     ;; 1+6+2+1+1+2+1=14 extra () before this:
-		     "\\(\\<sub[ \t\n\f]+\\|[&*$@%]\\)[a-zA-Z0-9_]*'"
-		     ;; 1+6+2+1+1+2+1+1=15 extra () before this:
-		     "\\|"
-		     "__\\(END\\|DATA\\)__"
-		     ;; 1+6+2+1+1+2+1+1+1=16 extra () before this:
-		     "\\|"
-		     "\\\\\\(['`\"]\\)"
-		     )
-		  ""))))
+		;; 1+6+2+1=10 extra () before this:
+		"\\([?/<]\\)"	; /blah/ or ?blah? or <file*glob>
+		"\\|"
+		;; 1+6+2+1+1=11 extra () before this:
+		"\\<sub\\>[ \t]*\\([a-zA-Z_:'0-9]+[ \t]*\\)?\\(([^()]*)\\)"
+		"\\|"
+		;; 1+6+2+1+1+2=13 extra () before this:
+		"\\$\\(['{]\\)"
+		"\\|"
+		;; 1+6+2+1+1+2+1=14 extra () before this:
+		"\\(\\<sub[ \t\n\f]+\\|[&*$@%]\\)[a-zA-Z0-9_]*'"
+		;; 1+6+2+1+1+2+1+1=15 extra () before this:
+		"\\|"
+		"__\\(END\\|DATA\\)__"
+		;; 1+6+2+1+1+2+1+1+1=16 extra () before this:
+		"\\|"
+		"\\\\\\(['`\"]\\)")
+	     ""))))
     (unwind-protect
 	(progn
 	  (save-excursion
 	    (or non-inter
 		(message "Scanning for \"hard\" Perl constructions..."))
 	    (and cperl-pod-here-fontify
-		;; We had evals here, do not know why...
-		(setq face cperl-pod-face
-		      head-face cperl-pod-head-face
-		      here-face cperl-here-face))
+		 ;; We had evals here, do not know why...
+		 (setq face cperl-pod-face
+		       head-face cperl-pod-head-face
+		       here-face cperl-here-face))
 	    (remove-text-properties min max
 				    '(syntax-type t in-pod t syntax-table t
 						  cperl-postpone t
 		  (cperl-commentify bb e nil)
 		  (goto-char e)
 		  (or (eq e (point-max))
-		      (forward-char -1)))) ; Prepare for immediate pod start.
+		      (forward-char -1)))) ; Prepare for immediate POD start.
 	       ;; Here document
 	       ;; We do only one here-per-line
                ;; ;; One extra () before this:
 			     (progn
 			       ;; Highlight the ending delimiter
 			       (cperl-postpone-fontification (match-beginning 0) (match-end 0)
-						  'face font-lock-constant-face)
+							     'face font-lock-constant-face)
 			       (cperl-put-do-not-fontify b (match-end 0) t)
 			       ;; Highlight the HERE-DOC
 			       (cperl-postpone-fontification b (match-beginning 0)
-						  'face here-face)))
+							     'face here-face)))
 			 (setq e1 (cperl-1+ (match-end 0)))
 			 (put-text-property b (match-beginning 0)
 					    'syntax-type 'here-doc)
 			(end-of-line)
 			;; Highlight the format line
 			(cperl-postpone-fontification b1 (point)
-					   'face font-lock-string-face)
+						      'face font-lock-string-face)
 			(cperl-commentify b1 (point) nil)
 			(cperl-put-do-not-fontify b1 (point) t))))
 		  ;; We do not search to max, since we may be called from
 		  ;; some hook of fontification, and max is random
 		  (re-search-forward "^[.;]$" stop-point 'toend))
 		(beginning-of-line)
-		(if (looking-at "^\\.$")	; ";" is not supported yet
+		(if (looking-at "^\\.$") ; ";" is not supported yet
 		    (progn
 		      ;; Highlight the ending delimiter
 		      (cperl-postpone-fontification (point) (+ (point) 2)
-					 'face font-lock-string-face)
+						    'face font-lock-string-face)
 		      (cperl-commentify (point) (+ (point) 2) nil)
 		      (cperl-put-do-not-fontify (point) (+ (point) 2) t))
 		  (message "End of format `%s' not found." name)
 			      (memq bb '(?\$ ?\@ ?\% ?\* ?\#)) ; $#y
 			      (and (eq bb ?-) (eq c ?s)) ; -s file test
 			      (and (eq bb ?\&)
-				   (not (eq (char-after  ; &&m/blah/
+				   (not (eq (char-after	; &&m/blah/
 					     (- (match-beginning b1) 2))
 					    ?\&))))
 			   ;; <file> or <$file>
 				    (if is-x-REx
 					(if (eq (char-after b) ?\#)
 					    "\\((\\?\\\\#\\)\\|\\(\\\\#\\)"
-					    "\\((\\?#\\)\\|\\(#\\)")
-					(if (eq (char-after b) ?\#)
-					    "\\((\\?\\\\#\\)"
-					  "\\((\\?#\\)"))
+					  "\\((\\?#\\)\\|\\(#\\)")
+				      (if (eq (char-after b) ?\#)
+					  "\\((\\?\\\\#\\)"
+					"\\((\\?#\\)"))
 				    (1- e) 'to-end))
 			    (goto-char (match-beginning 0))
 			    (setq REx-comment-start (point)
       (if (memq (setq pr (get-text-property (point) 'syntax-type))
 		'(pod here-doc here-doc-delim))
 	  (cperl-unwind-to-safe nil)
-	(if (or (looking-at "^[ \t]*\\(#\\|$\\)")
-		(progn (cperl-to-comment-or-eol) (bolp)))
-	    nil				; Only comment, skip
-	  ;; Else
-	  (skip-chars-backward " \t")
-	  (if (< p (point)) (goto-char p))
-	  (setq stop t))))))
+      (or (looking-at "^[ \t]*\\(#\\|$\\)")
+	  (progn (cperl-to-comment-or-eol) (bolp))
+	  (progn
+	    (skip-chars-backward " \t")
+	    (if (< p (point)) (goto-char p))
+	    (setq stop t)))))))
 
 (defun cperl-after-block-p (lim)
   ;; We suppose that the preceding char is }.
 TEST is the expression to evaluate at the found position.  If absent,
 CHARS is a string that contains good characters to have before us (however,
 `}' is treated \"smartly\" if it is not in the list)."
-  (let (stop p
-	     (lim (or lim (point-min))))
+  (let ((lim (or lim (point-min)))
+	stop p)
     (save-excursion
       (while (and (not stop) (> (point) lim))
 	(skip-chars-backward " \t\n\f" lim)
   (interactive)
   (or end
       (setq end (point-max)))
-  (let (p pp ml have-brace ret
-	  (ee (save-excursion (end-of-line) (point)))
-	  (cperl-indent-region-fix-constructs
-	   (or cperl-indent-region-fix-constructs 1)))
+  (let ((ee (save-excursion (end-of-line) (point)))
+	(cperl-indent-region-fix-constructs
+	 (or cperl-indent-region-fix-constructs 1))
+	p pp ml have-brace ret)
     (save-excursion
       (beginning-of-line)
       (setq ret (point))