(pascal-beg-of-defun): More intuitive behavior when having nested functons.

(pascal-indent-nested-functions) (pascal-indent-line)
(pascal-calculate-indent) (pascal-get-lineup-indent): Support for
indenting nested functions.

1 files changed, 78 insertions, 44 deletions

diff --git a/lisp/progmodes/pascal.el b/lisp/progmodes/pascal.el
index 3cbfc5c8fd2..d27a84543d6 100644
--- a/lisp/progmodes/pascal.el
+++ b/lisp/progmodes/pascal.el
@@ -1,6 +1,6 @@
 ;;; pascal.el --- major mode for editing pascal source in Emacs
 
-;; Copyright (C) 1993, 1994, 95, 96, 97, 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1993, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
 
 ;; Author: Espen Skoglund <espensk@stud.cs.uit.no>
 ;; Keywords: languages
@@ -119,6 +119,7 @@
 (defconst pascal-beg-block-re   "\\<\\(begin\\|case\\|record\\|repeat\\)\\>")
 (defconst pascal-end-block-re   "\\<\\(end\\|until\\)\\>")
 (defconst pascal-declaration-re "\\<\\(const\\|label\\|type\\|var\\)\\>")
+(defconst pascal-progbeg-re     "\\<\\program\\>")
 (defconst pascal-defun-re       "\\<\\(function\\|procedure\\|program\\)\\>")
 (defconst pascal-sub-block-re   "\\<\\(if\\|else\\|for\\|while\\|with\\)\\>")
 (defconst pascal-noindent-re    "\\<\\(begin\\|end\\|until\\|else\\)\\>")
@@ -195,6 +196,11 @@ These include after semicolons and after the punctuation mark after an `end'."
   :type 'boolean
   :group 'pascal)
 
+(defcustom pascal-indent-nested-functions t
+  "*Non-nil means nested functions are indented."
+  :type 'boolean
+  :group 'pascal)
+
 (defcustom pascal-tab-always-indent t
   "*Non-nil means TAB in Pascal mode should always reindent the current line.
 If this is nil, TAB inserts a tab if it is at the end of the line
@@ -216,10 +222,11 @@ do auto lineup in parameterlist, declarations or case-statements
 respectively. The word 'all' will do all lineups. '(case paramlist) for
 instance will do lineup in case-statements and parameterlist, while '(all)
 will do all lineups."
-  :type '(repeat (choice (const all)
-			 (const paramlist)
-			 (const declaration)
-			 (const case)))
+  :type '(set :extra-offset 8
+	      (const :tag "Everything" all)
+	      (const :tag "Parameter lists" paramlist)
+	      (const :tag "Decalrations" declaration)
+	      (const :tag "Case statements" case))
   :group 'pascal)
 
 (defcustom pascal-toggle-completions nil
@@ -323,20 +330,22 @@ Other useful functions are:
 
 Variables controlling indentation/edit style:
 
- pascal-indent-level      (default 3)
+ pascal-indent-level (default 3)
     Indentation of Pascal statements with respect to containing block.
- pascal-case-indent       (default 2)
+ pascal-case-indent (default 2)
     Indentation for case statements.
- pascal-auto-newline      (default nil)
+ pascal-auto-newline (default nil)
     Non-nil means automatically newline after semicolons and the punctuation
     mark after an end.
+ pascal-indent-nested-functions (default t)
+    Non-nil means nested functions are indented.
  pascal-tab-always-indent (default t)
     Non-nil means TAB in Pascal mode should always reindent the current line,
     regardless of where in the line point is when the TAB command is used.
- pascal-auto-endcomments  (default t)
+ pascal-auto-endcomments (default t)
     Non-nil means a comment { ... } is set after the ends which ends cases and
     functions. The name of the function or case will be set between the braces.
- pascal-auto-lineup       (default t)
+ pascal-auto-lineup (default t)
     List of contexts where auto lineup of :'s or ='s should be done.
 
 See also the user variables pascal-type-keywords, pascal-start-keywords and
@@ -611,7 +620,7 @@ area.  See also `pascal-comment-area'."
 		   (setq func (1+ func)))
 	       (setq nest (1- nest)))
 	      ((match-end 3)                       ; function|procedure
-	       (if (or (> nest 0) (= 0 func))
+	       (if (= 0 func)
 		   (throw 'found t)
 		 (setq func (1- func)))))))
     nil))
@@ -777,7 +786,7 @@ on the line which ends a function or procedure named NAME."
     (paramlist . (pascal-indent-paramlist t))
     (comment . (pascal-indent-comment t))
     (defun . ind) (contexp . ind)
-    (unknown . 0) (string . 0)))
+    (unknown . ind) (string . 0) (progbeg . 0)))
 
 (defun pascal-indent-command ()
   "Indent for special part of code."
@@ -805,20 +814,27 @@ on the line which ends a function or procedure named NAME."
   (let* ((indent-str (pascal-calculate-indent))
 	 (type (car indent-str))
 	 (ind (car (cdr indent-str))))
-    (if (looking-at "^[0-9a-zA-Z]+[ \t]*:[^=]")
+    ;; Labels should not be indented.
+    (if (and (looking-at "^[0-9a-zA-Z]+[ \t]*:[^=]")
+	     (not (eq type 'declaration)))
 	(search-forward ":" nil t))
     (delete-horizontal-space)
-    ;; Some things should not be indented
-    (if (or (and (eq type 'declaration) (looking-at pascal-declaration-re))
-	    (eq type 'cpp)
-	    (looking-at pascal-defun-re))
-	()
-      ;; Other things should have no extra indent
-      (if (looking-at pascal-noindent-re)
-	  (indent-to ind)
-	;; But most lines are treated this way:
-	(indent-to (eval (cdr (assoc type pascal-indent-alist))))
-	))))
+    (cond (; Some things should not be indented
+	   (or (and (eq type 'declaration) (looking-at pascal-declaration-re))
+	       (eq type 'cpp))
+	   ())
+	  (; Other things should have no extra indent
+	   (looking-at pascal-noindent-re)
+	   (indent-to ind))
+	  (; Nested functions should be indented
+	   (looking-at pascal-defun-re)
+	   (if (and pascal-indent-nested-functions
+		    (eq type 'defun))
+	       (indent-to (+ ind pascal-indent-level))
+	     (indent-to ind)))
+	  (; But most lines are treated this way
+	   (indent-to (eval (cdr (assoc type pascal-indent-alist))))
+	   ))))
 
 (defun pascal-calculate-indent ()
   "Calculate the indent of the current Pascal line.
@@ -828,7 +844,8 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
 	   (oldpos (point))
 	   (state (save-excursion (parse-partial-sexp (point-min) (point))))
 	   (nest 0) (par 0) (complete (looking-at "[ \t]*end\\>"))
-	   (elsed (looking-at "[ \t]*else\\>"))
+	   (elsed (looking-at "[ \t]*else\\>")) (funccnt 0)
+	   (did-func (looking-at "[ \t]*\\(procedure\\|function\\)\\>"))
 	   (type (catch 'nesting
 		   ;; Check if inside a string, comment or parenthesis
 		   (cond ((nth 3 state) (throw 'nesting 'string))
@@ -855,6 +872,12 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
 						    (point))
 				    (point)))
 			    (throw 'nesting 'caseblock))
+			   (;--Beginning of program
+			    (looking-at pascal-progbeg-re)
+			    (throw 'nesting 'progbeg))
+			   (;--No known statements
+			    (bobp)
+			    (throw 'nesting 'progbeg))
 			   (;--Nest block outwards
 			    (looking-at pascal-beg-block-re)
 			    (if (= nest 0)
@@ -863,16 +886,26 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
 				      ((looking-at "record\\>")
 				       (throw 'nesting 'declaration))
 				      (t (throw 'nesting 'block)))
+			      (if (and (looking-at "record\\>") (= nest 1))
+				  (setq funccnt (1- funccnt)))
 			      (setq nest (1- nest))))
 			   (;--Nest block inwards
 			    (looking-at pascal-end-block-re)
 			    (if (and (looking-at "end\\s ")
 				     elsed (not complete))
 				(throw 'nesting 'block))
+			    (if (= nest 0)
+				(setq funccnt (1+ funccnt)))
 			    (setq complete t
 				  nest (1+ nest)))
 			   (;--Defun (or parameter list)
-			    (looking-at pascal-defun-re)
+			    (and (looking-at pascal-defun-re)
+				 (progn (setq funccnt (1- funccnt)
+					      did-func t)
+					(or (bolp) (< funccnt 0))))
+			    ;; Prevent searching whole buffer
+			    (if (and (bolp) (>= funccnt 0))
+				(throw 'nesting 'progbeg))
 			    (if (= 0 par)
 				(throw 'nesting 'defun)
 			      (setq par 0)
@@ -886,7 +919,9 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
 				    (throw 'nesting 'declaration)
 				  (throw 'nesting 'paramlist)))))
 			   (;--Declaration part
-			    (looking-at pascal-declaration-re)
+			    (and (looking-at pascal-declaration-re)
+				 (not did-func)
+				 (= funccnt 0))
 			    (if (save-excursion
 				  (goto-char oldpos)
 				  (forward-line -1)
@@ -897,9 +932,6 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
 			    (and (not complete)
 				 (looking-at pascal-sub-block-re))
 			    (throw 'nesting 'block))
-			   (;--No known statements
-			    (bobp)
-			    (throw 'nesting 'unknown))
 			   (;--Found complete statement
 			    (save-excursion (forward-sexp 1)
 					    (= (following-char) ?\;))
@@ -1052,23 +1084,25 @@ indent of the current line in parameterlist."
 (defun pascal-get-lineup-indent (b e str)
   (save-excursion
     (let ((ind 0)
-	  (reg (concat str "\\|\\(\\<record\\>\\)")))
+	  (reg (concat str "\\|\\(\\<record\\>\\)\\|" pascal-defun-re)))
       (goto-char b)
       ;; Get rightmost position
       (while (< (point) e)
-	(if (re-search-forward reg (min e (pascal-get-end-of-line 2)) 'move)
-	    (progn
-	      ;; Skip record blocks
-	      (if (match-beginning 1)
-		  (pascal-declaration-end)
-		(progn
-		  (goto-char (match-beginning 0))
-		  (skip-chars-backward " \t")
-		  (if (> (current-column) ind)
-		      (setq ind (current-column)))
-		  (goto-char (match-end 0))
-		  (end-of-line)
-		  )))))
+	(and (re-search-forward reg (min e (pascal-get-end-of-line 2)) 'move)
+	     (cond ((match-beginning 1)
+		    ;; Skip record blocks
+		    (pascal-declaration-end))
+		   ((match-beginning 2)
+		    ;; We have entered a new procedure.  Exit.
+		    (goto-char e))
+		   (t
+		    (goto-char (match-beginning 0))
+		    (skip-chars-backward " \t")
+		    (if (> (current-column) ind)
+			(setq ind (current-column)))
+		    (goto-char (match-end 0))
+		    (end-of-line)
+		    ))))
       ;; In case no lineup was found
       (if (> ind 0)
 	  (1+ ind)