perl 5.0 alpha 4

[editor's note: the sparc executables have not been included, and
emacs backup files have been removed.  This was reconstructed from a
tarball found on the September 1994 InfoMagic CD; the date of this is
approximate]

2 files changed, 1022 insertions, 0 deletions

diff --git a/emacs/cperl-mode b/emacs/cperl-mode
new file mode 100644
index 0000000000..eb4aae2ab6
--- /dev/null
+++ b/emacs/cperl-mode
@@ -0,0 +1,710 @@
+Article 15212 of comp.lang.perl:
+Path: netlabs!news.cerf.net!usc!howland.reston.ans.net!spool.mu.edu!umn.edu!news-feed-2.peachnet.edu!concert!duke!khera
+From: khera@cs.duke.edu (Vivek Khera)
+Newsgroups: comp.lang.perl
+Subject: cperl-mode.el
+Message-ID: <KHERA.93Oct21140851@thneed.cs.duke.edu>
+Date: 21 Oct 93 18:08:51 GMT
+Sender: news@duke.cs.duke.edu
+Organization: Duke University CS Dept., Durham, NC
+Lines: 694
+Nntp-Posting-Host: thneed.cs.duke.edu
+X-Md4-Signature: 40dd9bccfb99794a9da2ee891b5bf557
+X-Md5-Signature: e4baa8cf00c94092ebf9712514e4696b
+
+Since I've received requests to do so, I'm posting the cperl-mode.el
+file.  This allows Emacs (both version 18 and 19) to do nice things
+when editing Perl code.  Indentation works well, and it doesn't get
+confused like the perl-mode.el that comes with Emacs 19.
+
+Install this file as cperl-mode.el, and add the following to your
+.emacs file:
+
+(autoload 'perl-mode "cperl-mode" "alternate mode for editing Perl programs" t)
+
+This cperl-mode.el is not exactly the same as when it was originally
+posted here.  I made the following changes:  perl-mode is an alias for
+cperl-mode, and the major mode name is perl-mode, not cperl-mode.
+This is so it is easier to use with Emacs 19.  I suppose one could
+install this as perl-mode.el and then not have to put the autoload
+line in (for Emacs 19).
+
+Anyway, I'm not maintaining this, so don't send me bugs.
+
+--cut here--
+;;; From: olson@mcs.anl.gov (Bob Olson)
+;;; Newsgroups: comp.lang.perl
+;;; Subject: cperl-mode: Another perl mode for Gnuemacs
+;;; Date: 14 Aug 91 15:20:01 GMT
+
+;; Perl code editing commands for Emacs
+;; Copyright (C) 1985, 1986, 1987 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY.  No author or distributor
+;; accepts responsibility to anyone for the consequences of using it
+;; or for whether it serves any particular purpose or works at all,
+;; unless he says so in writing.  Refer to the GNU Emacs General Public
+;; License for full details.
+
+;; Everyone is granted permission to copy, modify and redistribute
+;; GNU Emacs, but only under the conditions described in the
+;; GNU Emacs General Public License.   A copy of this license is
+;; supposed to have been given to you along with GNU Emacs so you
+;; can know your rights and responsibilities.  It should be in a
+;; file named COPYING.  Among other things, the copyright notice
+;; and this notice must be preserved on all copies.
+
+
+(defvar cperl-mode-abbrev-table nil
+  "Abbrev table in use in Cperl-mode buffers.")
+(define-abbrev-table 'cperl-mode-abbrev-table ())
+
+(defvar cperl-mode-map ()
+  "Keymap used in C mode.")
+(if cperl-mode-map
+    ()
+  (setq cperl-mode-map (make-sparse-keymap))
+  (define-key cperl-mode-map "{" 'electric-cperl-brace)
+  (define-key cperl-mode-map "}" 'electric-cperl-brace)
+  (define-key cperl-mode-map ";" 'electric-cperl-semi)
+  (define-key cperl-mode-map ":" 'electric-cperl-terminator)
+  (define-key cperl-mode-map "\e\C-h" 'mark-cperl-function)
+  (define-key cperl-mode-map "\e\C-q" 'indent-cperl-exp)
+  (define-key cperl-mode-map "\177" 'backward-delete-char-untabify)
+  (define-key cperl-mode-map "\t" 'cperl-indent-command))
+
+(autoload 'cperl-macro-expand "cmacexp"
+  "Display the result of expanding all C macros occurring in the region.
+The expansion is entirely correct because it uses the C preprocessor."
+  t)
+
+(defvar cperl-mode-syntax-table nil
+  "Syntax table in use in Cperl-mode buffers.")
+
+(if cperl-mode-syntax-table
+    ()
+  (setq cperl-mode-syntax-table (make-syntax-table))
+  (modify-syntax-entry ?\\ "\\" cperl-mode-syntax-table)
+  (modify-syntax-entry ?/ ". 14" cperl-mode-syntax-table)
+  (modify-syntax-entry ?* ". 23" cperl-mode-syntax-table)
+  (modify-syntax-entry ?+ "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?- "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?= "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?% "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?< "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?> "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?& "." cperl-mode-syntax-table)
+  (modify-syntax-entry ?| "." cperl-mode-syntax-table))
+
+
+(defvar cperl-indent-level 2
+  "*Indentation of C statements with respect to containing block.")
+(defvar cperl-brace-imaginary-offset 0
+  "*Imagined indentation of a C open brace that actually follows a statement.")
+(defvar cperl-brace-offset 0
+  "*Extra indentation for braces, compared with other text in same context.")
+(defvar cperl-argdecl-indent 5
+  "*Indentation level of declarations of C function arguments.")
+(defvar cperl-label-offset -2
+  "*Offset of C label lines and case statements relative to usual indentation.")
+(defvar cperl-continued-statement-offset 2
+  "*Extra indent for lines not starting new statements.")
+(defvar cperl-continued-brace-offset 0
+  "*Extra indent for substatements that start with open-braces.
+This is in addition to cperl-continued-statement-offset.")
+
+(defvar cperl-auto-newline nil
+  "*Non-nil means automatically newline before and after braces,
+and after colons and semicolons, inserted in C code.")
+
+(defvar cperl-tab-always-indent t
+  "*Non-nil means TAB in C mode should always reindent the current line,
+regardless of where in the line point is when the TAB command is used.")
+
+;; provide an alias for working with emacs 19.  the perl-mode that comes
+;; with it is really bad, and this lets us seamlessly replace it.
+(fset 'perl-mode 'cperl-mode)
+(defun cperl-mode ()
+  "Major mode for editing C code.
+Expression and list commands understand all C brackets.
+Tab indents for C code.
+Comments are delimited with /* ... */.
+Paragraphs are separated by blank lines only.
+Delete converts tabs to spaces as it moves back.
+\\{cperl-mode-map}
+Variables controlling indentation style:
+ cperl-tab-always-indent
+    Non-nil means TAB in C mode should always reindent the current line,
+    regardless of where in the line point is when the TAB command is used.
+ cperl-auto-newline
+    Non-nil means automatically newline before and after braces,
+    and after colons and semicolons, inserted in C code.
+ cperl-indent-level
+    Indentation of C statements within surrounding block.
+    The surrounding block's indentation is the indentation
+    of the line on which the open-brace appears.
+ cperl-continued-statement-offset
+    Extra indentation given to a substatement, such as the
+    then-clause of an if or body of a while.
+ cperl-continued-brace-offset
+    Extra indentation given to a brace that starts a substatement.
+    This is in addition to cperl-continued-statement-offset.
+ cperl-brace-offset
+    Extra indentation for line if it starts with an open brace.
+ cperl-brace-imaginary-offset
+    An open brace following other text is treated as if it were
+    this far to the right of the start of its line.
+ cperl-argdecl-indent
+    Indentation level of declarations of C function arguments.
+ cperl-label-offset
+    Extra indentation for line that is a label, or case or default.
+
+Settings for K&R and BSD indentation styles are
+  cperl-indent-level                5    8
+  cperl-continued-statement-offset  5    8
+  cperl-brace-offset               -5   -8
+  cperl-argdecl-indent              0    8
+  cperl-label-offset               -5   -8
+
+Turning on C mode calls the value of the variable cperl-mode-hook with no args,
+if that value is non-nil."
+  (interactive)
+  (kill-all-local-variables)
+  (use-local-map cperl-mode-map)
+  (setq major-mode 'perl-mode)
+  (setq mode-name "CPerl")
+  (setq local-abbrev-table cperl-mode-abbrev-table)
+  (set-syntax-table cperl-mode-syntax-table)
+  (make-local-variable 'paragraph-start)
+  (setq paragraph-start (concat "^$\\|" page-delimiter))
+  (make-local-variable 'paragraph-separate)
+  (setq paragraph-separate paragraph-start)
+  (make-local-variable 'paragraph-ignore-fill-prefix)
+  (setq paragraph-ignore-fill-prefix t)
+  (make-local-variable 'indent-line-function)
+  (setq indent-line-function 'cperl-indent-line)
+  (make-local-variable 'require-final-newline)
+  (setq require-final-newline t)
+  (make-local-variable 'comment-start)
+  (setq comment-start "# ")
+  (make-local-variable 'comment-end)
+  (setq comment-end "")
+  (make-local-variable 'comment-column)
+  (setq comment-column 32)
+  (make-local-variable 'comment-start-skip)
+  (setq comment-start-skip "# *")
+  (make-local-variable 'comment-indent-hook)
+  (setq comment-indent-hook 'cperl-comment-indent)
+  (make-local-variable 'parse-sexp-ignore-comments)
+  (setq parse-sexp-ignore-comments t)
+  (run-hooks 'cperl-mode-hook))
+
+;; This is used by indent-for-comment
+;; to decide how much to indent a comment in C code
+;; based on its context.
+(defun cperl-comment-indent ()
+  (if (looking-at "^#")
+      0				;Existing comment at bol stays there.
+    (save-excursion
+      (skip-chars-backward " \t")
+      (max (1+ (current-column))	;Else indent at comment column
+	   comment-column))))	; except leave at least one space.
+
+(defun electric-cperl-brace (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (let (insertpos)
+    (if (and (not arg)
+	     (eolp)
+	     (or (save-excursion
+		   (skip-chars-backward " \t")
+		   (bolp))
+		 (if cperl-auto-newline (progn (cperl-indent-line) (newline) t) nil)))
+	(progn
+	  (insert last-command-char)
+	  (cperl-indent-line)
+	  (if cperl-auto-newline
+	      (progn
+		(newline)
+		;; (newline) may have done auto-fill
+		(setq insertpos (- (point) 2))
+		(cperl-indent-line)))
+	  (save-excursion
+	    (if insertpos (goto-char (1+ insertpos)))
+	    (delete-char -1))))
+    (if insertpos
+	(save-excursion
+	  (goto-char insertpos)
+	  (self-insert-command (prefix-numeric-value arg)))
+      (self-insert-command (prefix-numeric-value arg)))))
+
+(defun electric-cperl-semi (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (if cperl-auto-newline
+      (electric-cperl-terminator arg)
+    (self-insert-command (prefix-numeric-value arg))))
+
+(defun electric-cperl-terminator (arg)
+  "Insert character and correct line's indentation."
+  (interactive "P")
+  (let (insertpos (end (point)))
+    (if (and (not arg) (eolp)
+	     (not (save-excursion
+		    (beginning-of-line)
+		    (skip-chars-forward " \t")
+		    (or (= (following-char) ?#)
+			;; Colon is special only after a label, or case ....
+			;; So quickly rule out most other uses of colon
+			;; and do no indentation for them.
+			(and (eq last-command-char ?:)
+			     (not (looking-at "case[ \t]"))
+			     (save-excursion
+			       (forward-word 1)
+			       (skip-chars-forward " \t")
+			       (< (point) end)))
+			(progn
+			  (beginning-of-defun)
+			  (let ((pps (parse-partial-sexp (point) end)))
+			    (or (nth 3 pps) (nth 4 pps) (nth 5 pps))))))))
+	(progn
+	  (insert last-command-char)
+	  (cperl-indent-line)
+	  (and cperl-auto-newline
+	       (not (cperl-inside-parens-p))
+	       (progn
+		 (newline)
+		 (setq insertpos (- (point) 2))
+		 (cperl-indent-line)))
+	  (save-excursion
+	    (if insertpos (goto-char (1+ insertpos)))
+	    (delete-char -1))))
+    (if insertpos
+	(save-excursion
+	  (goto-char insertpos)
+	  (self-insert-command (prefix-numeric-value arg)))
+      (self-insert-command (prefix-numeric-value arg)))))
+
+(defun cperl-inside-parens-p ()
+  (condition-case ()
+      (save-excursion
+	(save-restriction
+	  (narrow-to-region (point)
+			    (progn (beginning-of-defun) (point)))
+	  (goto-char (point-max))
+	  (= (char-after (or (scan-lists (point) -1 1) (point-min))) ?\()))
+    (error nil)))
+
+(defun cperl-indent-command (&optional whole-exp)
+  (interactive "P")
+  "Indent current line as C code, or in some cases insert a tab character.
+If cperl-tab-always-indent is non-nil (the default), always indent current line.
+Otherwise, indent the current line only if point is at the left margin
+or in the line's indentation; otherwise insert a tab.
+
+A numeric argument, regardless of its value,
+means indent rigidly all the lines of the expression starting after point
+so that this line becomes properly indented.
+The relative indentation among the lines of the expression are preserved."
+  (if whole-exp
+      ;; If arg, always indent this line as C
+      ;; and shift remaining lines of expression the same amount.
+      (let ((shift-amt (cperl-indent-line))
+	    beg end)
+	(save-excursion
+	  (if cperl-tab-always-indent
+	      (beginning-of-line))
+	  (setq beg (point))
+	  (forward-sexp 1)
+	  (setq end (point))
+	  (goto-char beg)
+	  (forward-line 1)
+	  (setq beg (point)))
+	(if (> end beg)
+	    (indent-code-rigidly beg end shift-amt "#")))
+    (if (and (not cperl-tab-always-indent)
+	     (save-excursion
+	       (skip-chars-backward " \t")
+	       (not (bolp))))
+	(insert-tab)
+      (cperl-indent-line))))
+
+(defun cperl-indent-line ()
+  "Indent current line as C code.
+Return the amount the indentation changed by."
+  (let ((indent (calculate-cperl-indent nil))
+	beg shift-amt
+	(case-fold-search nil)
+	(pos (- (point-max) (point))))
+    (beginning-of-line)
+    (setq beg (point))
+    (cond ((eq indent nil)
+	   (setq indent (current-indentation)))
+	  ((eq indent t)
+	   (setq indent (calculate-cperl-indent-within-comment)))
+	  ((looking-at "[ \t]*#")
+	   (setq indent 0))
+	  (t
+	   (skip-chars-forward " \t")
+	   (if (listp indent) (setq indent (car indent)))
+	   (cond ((or (looking-at "case[ \t]")
+		      (and (looking-at "[A-Za-z]")
+			   (save-excursion
+			     (forward-sexp 1)
+			     (looking-at ":"))))
+		  (setq indent (max 1 (+ indent cperl-label-offset))))
+		 ((and (looking-at "else\\b")
+		       (not (looking-at "else\\s_")))
+		  (setq indent (save-excursion
+				 (cperl-backward-to-start-of-if)
+				 (current-indentation))))
+		 ((= (following-char) ?})
+		  (setq indent (- indent cperl-indent-level)))
+		 ((= (following-char) ?{)
+		  (setq indent (+ indent cperl-brace-offset))))))
+    (skip-chars-forward " \t")
+    (setq shift-amt (- indent (current-column)))
+    (if (zerop shift-amt)
+	(if (> (- (point-max) pos) (point))
+	    (goto-char (- (point-max) pos)))
+      (delete-region beg (point))
+      (indent-to indent)
+      ;; If initial point was within line's indentation,
+      ;; position after the indentation.  Else stay at same point in text.
+      (if (> (- (point-max) pos) (point))
+	  (goto-char (- (point-max) pos))))
+    shift-amt))
+
+(defun calculate-cperl-indent (&optional parse-start)
+  "Return appropriate indentation for current line as C code.
+In usual case returns an integer: the column to indent to.
+Returns nil if line starts inside a string, t if in a comment."
+  (save-excursion
+    (beginning-of-line)
+    (let ((indent-point (point))
+	  (case-fold-search nil)
+	  state
+	  containing-sexp)
+      (if parse-start
+	  (goto-char parse-start)
+	(beginning-of-defun))
+      (while (< (point) indent-point)
+	(setq parse-start (point))
+	(setq state (parse-partial-sexp (point) indent-point 0))
+	(setq containing-sexp (car (cdr state))))
+      (cond ((or (nth 3 state) (nth 4 state))
+	     ;; return nil or t if should not change this line
+	     (nth 4 state))
+	    ((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.
+	     (goto-char indent-point)
+	     (skip-chars-forward " \t")
+	     (if (= (following-char) ?{)
+		 0   ; Unless it starts a function body
+	       (cperl-backward-to-noncomment (or parse-start (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 accordinglu.
+	       (let ((basic-indent
+		      (save-excursion
+			(re-search-backward "^[^ \^L\t\n#]" nil 'move)
+			(if (and (looking-at "\\sw\\|\\s_")
+				 (looking-at ".*(")
+				 (progn
+				   (goto-char (1- (match-end 0)))
+				   (forward-sexp 1)
+				   (and (< (point) indent-point)
+					(not (memq (following-char)
+						   '(?\, ?\;))))))
+			    cperl-argdecl-indent 0))))
+		 ;; Now add a little if this is a continuation line.
+		 (+ basic-indent (if (or (bobp)
+					 (memq (preceding-char) '(?\) ?\; ?\})))
+				     0 cperl-continued-statement-offset)))))
+	    ((/= (char-after containing-sexp) ?{)
+	     ;; line is expression, not statement:
+	     ;; indent to just after the surrounding open.
+	     (goto-char (1+ containing-sexp))
+	     (current-column))
+	    (t
+	     ;; Statement level.  Is it a continuation or a new statement?
+	     ;; Find previous non-comment character.
+	     (goto-char indent-point)
+	     (cperl-backward-to-noncomment containing-sexp)
+	     ;; Back up over label lines, since they don't
+	     ;; affect whether our line is a continuation.
+	     (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) ?\,)
+		   (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 (memq (preceding-char) '(nil ?\, ?\; ?\} ?\{)))
+		 ;; This line is continuation of preceding line's statement;
+		 ;; indent  cperl-continued-statement-offset  more than the
+		 ;; previous line of the statement.
+		 (progn
+		   (cperl-backward-to-start-of-continued-exp containing-sexp)
+		   (+ cperl-continued-statement-offset (current-column)
+		      (if (save-excursion (goto-char indent-point)
+					  (skip-chars-forward " \t")
+					  (eq (following-char) ?{))
+			  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.
+		 (save-excursion
+		   (forward-char 1)
+		   (let ((colon-line-end 0))
+		     (while (progn (skip-chars-forward " \t\n")
+				   (looking-at "#\\|/\\*\\|case[ \t\n].*:\\|[a-zA-Z0-9_$]*:"))
+		       ;; Skip over comments and labels following openbrace.
+		       (cond ((= (following-char) ?\#)
+			      (forward-line 1))
+			     ((= (following-char) ?\/)
+			      (forward-char 2)
+			      (search-forward "*/" nil 'move))
+			     ;; case or 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))
+			      (- (current-indentation) cperl-label-offset)
+			    (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 (and (bolp) (zerop cperl-indent-level))
+			(+ cperl-brace-offset cperl-continued-statement-offset)
+		      cperl-indent-level)
+		    ;; 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))
+		      ;; Get initial indentation of the line we are on.
+		      (current-indentation))))))))))
+
+(defun calculate-cperl-indent-within-comment ()
+  "Return the indentation amount for line, assuming that
+the current line is to be regarded as part of a block comment."
+  (let (end star-start)
+    (save-excursion
+      (beginning-of-line)
+      (skip-chars-forward " \t")
+      (setq star-start (= (following-char) ?\*))
+      (skip-chars-backward " \t\n")
+      (setq end (point))
+      (beginning-of-line)
+      (skip-chars-forward " \t")
+      (and (re-search-forward "/\\*[ \t]*" end t)
+	   star-start
+	   (goto-char (1+ (match-beginning 0))))
+      (current-column))))
+
+
+(defun cperl-backward-to-noncomment (lim)
+  (let (opoint stop)
+    (while (not stop)
+      (skip-chars-backward " \t\n\f" lim)
+      (setq opoint (point))
+      (if (and (>= (point) (+ 2 lim))
+	       (save-excursion
+		 (forward-char -2)
+		 (looking-at "\\*/")))
+	  (search-backward "/*" lim 'move)
+	(beginning-of-line)
+	(skip-chars-forward " \t")
+	(setq stop (or (not (looking-at "#")) (<= (point) lim)))
+	(if stop (goto-char opoint)
+	  (beginning-of-line))))))
+
+(defun cperl-backward-to-start-of-continued-exp (lim)
+  (if (= (preceding-char) ?\))
+      (forward-sexp -1))
+  (beginning-of-line)
+  (if (<= (point) lim)
+      (goto-char (1+ lim)))
+  (skip-chars-forward " \t"))
+
+(defun cperl-backward-to-start-of-if (&optional limit)
+  "Move to the start of the last ``unbalanced'' if."
+  (or limit (setq limit (save-excursion (beginning-of-defun) (point))))
+  (let ((if-level 1)
+	(case-fold-search nil))
+    (while (not (zerop if-level))
+      (backward-sexp 1)
+      (cond ((looking-at "else\\b")
+	     (setq if-level (1+ if-level)))
+	    ((looking-at "if\\b")
+	     (setq if-level (1- if-level)))
+	    ((< (point) limit)
+	     (setq if-level 0)
+	     (goto-char limit))))))
+
+
+(defun mark-cperl-function ()
+  "Put mark at end of C function, point at beginning."
+  (interactive)
+  (push-mark (point))
+  (end-of-defun)
+  (push-mark (point))
+  (beginning-of-defun)
+  (backward-paragraph))
+
+(defun indent-cperl-exp ()
+  "Indent each line of the C grouping following point."
+  (interactive)
+  (let ((indent-stack (list nil))
+	(contain-stack (list (point)))
+	(case-fold-search nil)
+	restart outer-loop-done inner-loop-done state ostate
+	this-indent last-sexp
+	at-else at-brace
+	(opoint (point))
+	(next-depth 0))
+    (save-excursion
+      (forward-sexp 1))
+    (save-excursion
+      (setq outer-loop-done nil)
+      (while (and (not (eobp)) (not outer-loop-done))
+	(setq last-depth next-depth)
+	;; Compute how depth changes over this line
+	;; plus enough other lines to get to one that
+	;; does not end inside a comment or string.
+	;; Meanwhile, do appropriate indentation on comment lines.
+	(setq innerloop-done nil)
+	(while (and (not innerloop-done)
+		    (not (and (eobp) (setq outer-loop-done t))))
+	  (setq ostate state)
+	  (setq state (parse-partial-sexp (point) (progn (end-of-line) (point))
+					  nil nil state))
+	  (setq next-depth (car state))
+	  (if (and (car (cdr (cdr state)))
+		   (>= (car (cdr (cdr state))) 0))
+	      (setq last-sexp (car (cdr (cdr state)))))
+	  (if (or (nth 4 ostate))
+	      (cperl-indent-line))
+	  (if (or (nth 3 state))
+	      (forward-line 1)
+	    (setq innerloop-done t)))
+	(if (<= next-depth 0)
+	    (setq outer-loop-done t))
+	(if outer-loop-done
+	    nil
+	  ;; If this line had ..))) (((.. in it, pop out of the levels
+	  ;; that ended anywhere in this line, even if the final depth
+	  ;; doesn't indicate that they ended.
+	  (while (> last-depth (nth 6 state))
+	    (setq indent-stack (cdr indent-stack)
+		  contain-stack (cdr contain-stack)
+		  last-depth (1- last-depth)))
+	  (if (/= last-depth next-depth)
+	      (setq last-sexp nil))
+	  ;; Add levels for any parens that were started in this line.
+	  (while (< last-depth next-depth)
+	    (setq indent-stack (cons nil indent-stack)
+		  contain-stack (cons nil contain-stack)
+		  last-depth (1+ last-depth)))
+	  (if (null (car contain-stack))
+	      (setcar contain-stack (or (car (cdr state))
+					(save-excursion (forward-sexp -1)
+							(point)))))
+	  (forward-line 1)
+	  (skip-chars-forward " \t")
+	  (if (eolp)
+	      nil
+	    (if (and (car indent-stack)
+		     (>= (car indent-stack) 0))
+		;; Line is on an existing nesting level.
+		;; Lines inside parens are handled specially.
+		(if (/= (char-after (car contain-stack)) ?{)
+		    (setq this-indent (car indent-stack))
+		  ;; Line is at statement level.
+		  ;; Is it a new statement?  Is it an else?
+		  ;; Find last non-comment character before this line
+		  (save-excursion
+		    (setq at-else (looking-at "else\\W"))
+		    (setq at-brace (= (following-char) ?{))
+		    (cperl-backward-to-noncomment opoint)
+		    (if (not (memq (preceding-char) '(nil ?\, ?\; ?} ?: ?{)))
+			;; Preceding line did not end in comma or semi;
+			;; indent this line  cperl-continued-statement-offset
+			;; more than previous.
+			(progn
+			  (cperl-backward-to-start-of-continued-exp (car contain-stack))
+			  (setq this-indent
+				(+ cperl-continued-statement-offset (current-column)
+				   (if at-brace cperl-continued-brace-offset 0))))
+		      ;; Preceding line ended in comma or semi;
+		      ;; use the standard indent for this level.
+		      (if at-else
+			  (progn (cperl-backward-to-start-of-if opoint)
+				 (setq this-indent (current-indentation)))
+			(setq this-indent (car indent-stack))))))
+	      ;; Just started a new nesting level.
+	      ;; Compute the standard indent for this level.
+	      (let ((val (calculate-cperl-indent
+			   (if (car indent-stack)
+			       (- (car indent-stack))))))
+		(setcar indent-stack
+			(setq this-indent val))))
+	    ;; Adjust line indentation according to its contents
+	    (if (or (looking-at "case[ \t]")
+		    (and (looking-at "[A-Za-z]")
+			 (save-excursion
+			   (forward-sexp 1)
+			   (looking-at ":"))))
+		(setq this-indent (max 1 (+ this-indent cperl-label-offset))))
+	    (if (= (following-char) ?})
+		(setq this-indent (- this-indent cperl-indent-level)))
+	    (if (= (following-char) ?{)
+		(setq this-indent (+ this-indent cperl-brace-offset)))
+	    ;; Put chosen indentation into effect.
+	    (or (= (current-column) this-indent)
+		(= (following-char) ?\#)
+		(progn
+		  (delete-region (point) (progn (beginning-of-line) (point)))
+		  (indent-to this-indent)))
+	    ;; Indent any comment following the text.
+	    (or (looking-at comment-start-skip)
+		(if (re-search-forward comment-start-skip (save-excursion (end-of-line) (point)) t)
+		    (progn (indent-for-comment) (beginning-of-line)))))))))
+; (message "Indenting C expression...done")
+  )
+--cut here--
+--
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
+Vivek Khera, Gradual Student/Systems Guy  Department of Computer Science
+Internet: khera@cs.duke.edu               Box 90129
+          RIPEM/PGP/MIME spoken here      Durham, NC 27708-0129 (919)660-6528
+
+
diff --git a/emacs/emacs19 b/emacs/emacs19
new file mode 100644
index 0000000000..c3bb070a64
--- /dev/null
+++ b/emacs/emacs19
@@ -0,0 +1,312 @@
+Article 15041 of comp.lang.perl:
+Path: netlabs!news.cerf.net!usc!sol.ctr.columbia.edu!news.kei.com!bloom-beacon.mit.edu!paperboy.osf.org!meissner
+From: meissner@osf.org (Michael Meissner)
+Newsgroups: comp.lang.perl
+Subject: Re: question on using perldb.el  with emacs
+Date: 17 Oct 1993 21:10:21 GMT
+Organization: Open Software Foundation
+Lines: 297
+Message-ID: <MEISSNER.93Oct17171021@pasta.osf.org>
+References: <BSHAW.93Oct17143524@bobasun.spdc.ti.com>
+NNTP-Posting-Host: pasta.osf.org
+In-reply-to: bshaw@bobasun.spdc.ti.com's message of Sun, 17 Oct 1993 19:35:24 GMT
+
+In article <BSHAW.93Oct17143524@bobasun.spdc.ti.com> bshaw@bobasun.spdc.ti.com
+(Bob Shaw) writes:
+
+| Hi folks
+| 
+| Say, I'm trying to use perldb with emacs.  I can invoke perldb 
+| within emacs ok and get the window *perldb-foo*  but when it asks
+| for "additional command line arguments" , no matter what I give it
+| I get the error message   Symbol's function definition is void:  make-
+| shell.
+| 
+| The debugger , by itself, works fine but wanted to try out perldb in
+| emacs.
+
+This is a symptom of using Emacs 19.xx with perldb.el which was originally made
+for emacs version 18.xx.  You can either install the emacs19 replacement for
+perldb that hooks it in with GUD (grand unified debugger), or apply the patches
+that I picked off of the net (I use the perldb replacement that uses GUD
+myself):
+
+#!/bin/sh
+# This is a shell archive (produced by shar 3.49)
+# To extract the files from this archive, save it to a file, remove
+# everything above the "!/bin/sh" line above, and type "sh file_name".
+#
+# made 10/17/1993 21:07 UTC by meissner@pasta.osf.org
+# Source directory /usr/users/meissner/elisp
+#
+# existing files will NOT be overwritten unless -c is specified
+#
+# This shar contains:
+# length  mode       name
+# ------ ---------- ------------------------------------------
+#   4761 -rw-r--r-- emacs19-perldb.el
+#   3845 -rw-rw-r-- emacs19-perldb.patches
+#
+# ============= emacs19-perldb.el ==============
+if test -f 'emacs19-perldb.el' -a X"$1" != X"-c"; then
+	echo 'x - skipping emacs19-perldb.el (File already exists)'
+else
+echo 'x - extracting emacs19-perldb.el (Text)'
+sed 's/^X//' << 'SHAR_EOF' > 'emacs19-perldb.el' &&
+X;; Author : Stephane Boucher
+X;; Note : This is an add on for gud (Part of GNU Emacs 19). It is
+X;;        derived from the gdb section that is part of gud.
+X
+X;; Copyright (C) 1993 Stephane Boucher.
+X
+X;; Perldb is free software; you can redistribute it and/or modify
+X;; it under the terms of the GNU General Public License as published by
+X;; the Free Software Foundation; either version 2, or (at your option)
+X;; any later version.
+X
+X;; Perldb Emacs is distributed in the hope that it will be useful,
+X;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+X;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+X;; GNU General Public License for more details.
+X
+X;; You should have received a copy of the GNU General Public License
+X;; along with GNU Emacs; see the file COPYING.  If not, write to
+X;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+X
+X(require 'gud)
+X
+X;; ======================================================================
+X;; perldb functions
+X
+X;;; History of argument lists passed to perldb.
+X(defvar gud-perldb-history nil)
+X
+X(defun gud-perldb-massage-args (file args)
+X  (cons "-d" (cons file (cons "-emacs" args))))
+X
+X;; There's no guarantee that Emacs will hand the filter the entire
+X;; marker at once; it could be broken up across several strings.  We
+X;; might even receive a big chunk with several markers in it.  If we
+X;; receive a chunk of text which looks like it might contain the
+X;; beginning of a marker, we save it here between calls to the
+X;; filter.
+X(defvar gud-perldb-marker-acc "")
+X
+X(defun gud-perldb-marker-filter (string)
+X  (save-match-data
+X    (setq gud-perldb-marker-acc (concat gud-perldb-marker-acc string))
+X    (let ((output ""))
+X
+X      ;; Process all the complete markers in this chunk.
+X      (while (string-match "^\032\032\\([^:\n]*\\):\\([0-9]*\\):.*\n"
+X			   gud-perldb-marker-acc)
+X	(setq
+X
+X	 ;; Extract the frame position from the marker.
+X	 gud-last-frame
+X	 (cons (substring gud-perldb-marker-acc (match-beginning 1) (match-end 1))
+X	       (string-to-int (substring gud-perldb-marker-acc
+X					 (match-beginning 2)
+X					 (match-end 2))))
+X
+X	 ;; Append any text before the marker to the output we're going
+X	 ;; to return - we don't include the marker in this text.
+X	 output (concat output
+X			(substring gud-perldb-marker-acc 0 (match-beginning 0)))
+X
+X	 ;; Set the accumulator to the remaining text.
+X	 gud-perldb-marker-acc (substring gud-perldb-marker-acc (match-end 0))))
+X
+X      ;; Does the remaining text look like it might end with the
+X      ;; beginning of another marker?  If it does, then keep it in
+X      ;; gud-perldb-marker-acc until we receive the rest of it.  Since we
+X      ;; know the full marker regexp above failed, it's pretty simple to
+X      ;; test for marker starts.
+X      (if (string-match "^\032.*\\'" gud-perldb-marker-acc)
+X	  (progn
+X	    ;; Everything before the potential marker start can be output.
+X	    (setq output (concat output (substring gud-perldb-marker-acc
+X						   0 (match-beginning 0))))
+X
+X	    ;; Everything after, we save, to combine with later input.
+X	    (setq gud-perldb-marker-acc
+X		  (substring gud-perldb-marker-acc (match-beginning 0))))
+X
+X	(setq output (concat output gud-perldb-marker-acc)
+X	      gud-perldb-marker-acc ""))
+X
+X      output)))
+X
+X(defun gud-perldb-find-file (f)
+X  (find-file-noselect f))
+X
+X;;;###autoload
+X(defun perldb (command-line)
+X  "Run perldb on program FILE in buffer *gud-FILE*.
+XThe directory containing FILE becomes the initial working directory
+Xand source-file directory for your debugger."
+X  (interactive
+X   (list (read-from-minibuffer "Run perldb (like this): "
+X			       (if (consp gud-perldb-history)
+X				   (car gud-perldb-history)
+X				 "perl ")
+X			       nil nil
+X			       '(gud-perldb-history . 1))))
+X  (gud-overload-functions '((gud-massage-args . gud-perldb-massage-args)
+X			    (gud-marker-filter . gud-perldb-marker-filter)
+X			    (gud-find-file . gud-perldb-find-file)
+X			    ))
+X
+X  (gud-common-init command-line)
+X
+X  (gud-def gud-break  "b %l"         "\C-b" "Set breakpoint at current line.")
+X  (gud-def gud-remove "d %l"         "\C-d" "Remove breakpoint at current line")
+X  (gud-def gud-step   "s"            "\C-s" "Step one source line with display.")
+X  (gud-def gud-next   "n"            "\C-n" "Step one line (skip functions).")
+X  (gud-def gud-cont   "c"            "\C-r" "Continue with display.")
+X;  (gud-def gud-finish "finish"       "\C-f" "Finish executing current function.")
+X;  (gud-def gud-up     "up %p"        "<" "Up N stack frames (numeric arg).")
+X;  (gud-def gud-down   "down %p"      ">" "Down N stack frames (numeric arg).")
+X  (gud-def gud-print  "%e"           "\C-p" "Evaluate perl expression at point.")
+X
+X  (setq comint-prompt-regexp "^  DB<[0-9]+> ")
+X  (run-hooks 'perldb-mode-hook)
+X  )
+SHAR_EOF
+chmod 0644 emacs19-perldb.el ||
+echo 'restore of emacs19-perldb.el failed'
+Wc_c="`wc -c < 'emacs19-perldb.el'`"
+test 4761 -eq "$Wc_c" ||
+	echo 'emacs19-perldb.el: original size 4761, current size' "$Wc_c"
+fi
+# ============= emacs19-perldb.patches ==============
+if test -f 'emacs19-perldb.patches' -a X"$1" != X"-c"; then
+	echo 'x - skipping emacs19-perldb.patches (File already exists)'
+else
+echo 'x - extracting emacs19-perldb.patches (Text)'
+sed 's/^X//' << 'SHAR_EOF' > 'emacs19-perldb.patches' &&
+XFrom dmm0t@rincewind.mech.virginia.edu Fri Jul 16 23:17:10 1993
+XPath: paperboy.osf.org!bloom-beacon.mit.edu!biosci!uwm.edu!ux1.cso.uiuc.edu!howland.reston.ans.net!darwin.sura.net!news-feed-2.peachnet.edu!concert!uvaarpa!murdoch!rincewind.mech.virginia.edu!dmm0t
+XFrom: dmm0t@rincewind.mech.virginia.edu (David Meyer)
+XNewsgroups: gnu.emacs.sources
+XSubject: patches to perldb.el for emacs-19
+XMessage-ID: <CA7uq9.30J@murdoch.acc.Virginia.EDU>
+XDate: 15 Jul 93 17:18:07 GMT
+XSender: usenet@murdoch.acc.Virginia.EDU
+XOrganization: University of Virginia
+XLines: 97
+X
+X
+XHere are my patches to perldb.el (the perl debugger mode that comes
+Xwith perl 4.0xx).  Basically, all I've done is to hack perldb.el to
+Xuse comint.el stuff rather than the old shell.el stuff (i.e. change
+Xshell-mode-map to comint-mode-map).
+X
+XI've been using my patched version without problem, but if anyone sees
+Xsomething I've missed, please post or send e-mail.
+X
+X				Thanks,
+X						Dave
+X
+X
+X*** /Users/dmm0t/perldb.el	Thu Jul 15 13:06:59 1993
+X--- perldb.el	Tue Jul  6 22:24:41 1993
+X***************
+X*** 65,71 ****
+X  
+X  (if perldb-mode-map
+X     nil
+X!   (setq perldb-mode-map (copy-keymap shell-mode-map))
+X    (define-key perldb-mode-map "\C-l" 'perldb-refresh))
+X  
+X  (define-key ctl-x-map " " 'perldb-break)
+X--- 65,71 ----
+X  
+X  (if perldb-mode-map
+X     nil
+X!   (setq perldb-mode-map (copy-keymap comint-mode-map))
+X    (define-key perldb-mode-map "\C-l" 'perldb-refresh))
+X  
+X  (define-key ctl-x-map " " 'perldb-break)
+X***************
+X*** 122,131 ****
+X    (setq mode-name "Inferior Perl")
+X    (setq mode-line-process '(": %s"))
+X    (use-local-map perldb-mode-map)
+X!   (make-local-variable 'last-input-start)
+X!   (setq last-input-start (make-marker))
+X!   (make-local-variable 'last-input-end)
+X!   (setq last-input-end (make-marker))
+X    (make-local-variable 'perldb-last-frame)
+X    (setq perldb-last-frame nil)
+X    (make-local-variable 'perldb-last-frame-displayed-p)
+X--- 122,131 ----
+X    (setq mode-name "Inferior Perl")
+X    (setq mode-line-process '(": %s"))
+X    (use-local-map perldb-mode-map)
+X!   (make-local-variable 'comint-last-input-start)
+X!   (setq comint-last-input-start (make-marker))
+X!   (make-local-variable 'comint-last-input-end)
+X!   (setq comint-last-input-end (make-marker))
+X    (make-local-variable 'perldb-last-frame)
+X    (setq perldb-last-frame nil)
+X    (make-local-variable 'perldb-last-frame-displayed-p)
+X***************
+X*** 134,142 ****
+X    (setq perldb-delete-prompt-marker nil)
+X    (make-local-variable 'perldb-filter-accumulator)
+X    (setq perldb-filter-accumulator nil)
+X!   (make-local-variable 'shell-prompt-pattern)
+X!   (setq shell-prompt-pattern perldb-prompt-pattern)
+X!   (run-hooks 'shell-mode-hook 'perldb-mode-hook))
+X  
+X  (defvar current-perldb-buffer nil)
+X  
+X--- 134,142 ----
+X    (setq perldb-delete-prompt-marker nil)
+X    (make-local-variable 'perldb-filter-accumulator)
+X    (setq perldb-filter-accumulator nil)
+X!   (make-local-variable 'comint-prompt-regexp)
+X!   (setq comint-prompt-regexp perldb-prompt-pattern)
+X!   (run-hooks 'comint-mode-hook 'perldb-mode-hook))
+X  
+X  (defvar current-perldb-buffer nil)
+X  
+X***************
+X*** 189,195 ****
+X      (setq default-directory dir)
+X      (or (bolp) (newline))
+X      (insert "Current directory is " default-directory "\n")
+X!     (apply 'make-shell
+X  	   (concat "perldb-" file) perldb-command-name nil "-d" path "-emacs"
+X  	   (parse-args args))
+X      (perldb-mode)
+X--- 189,195 ----
+X      (setq default-directory dir)
+X      (or (bolp) (newline))
+X      (insert "Current directory is " default-directory "\n")
+X!     (apply 'make-comint
+X  	   (concat "perldb-" file) perldb-command-name nil "-d" path "-emacs"
+X  	   (parse-args args))
+X      (perldb-mode)
+X-- 
+XDavid M. Meyer                             Mechanical & Aerospace Engineering
+Xdmm0t@rincewind.mech.virginia.edu          University of Virginia
+XNeXTmail ok
+X
+SHAR_EOF
+chmod 0664 emacs19-perldb.patches ||
+echo 'restore of emacs19-perldb.patches failed'
+Wc_c="`wc -c < 'emacs19-perldb.patches'`"
+test 3845 -eq "$Wc_c" ||
+	echo 'emacs19-perldb.patches: original size 3845, current size' "$Wc_c"
+fi
+exit 0
+
+--
+Michael Meissner	email: meissner@osf.org		phone: 617-621-8861
+Open Software Foundation, 11 Cambridge Center, Cambridge, MA, 02142
+
+Old hackers never die, their bugs just increase.
+
+