;; csh-mode.el --- csh (and tcsh) script editing mode for Emacs.
;;
;; Version:    1.2
;; Date:       April 2, 1999
;; Maintainer: Dan Harkless <software@harkless.org>
;;
;; Description:
;;   csh and tcsh script editing mode for Emacs.
;; 
;; Installation:
;;   Put csh-mode.el in some directory in your load-path and load it.
;;
;; Usage:
;;   This major mode assists shell script writers with indentation
;;   control and control structure construct matching in much the same
;;   fashion as other programming language modes. Invoke describe-mode
;;   for more information.
;; 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; Author key:
;;   DH - Dan Harkless     <software@harkless.org>
;;   CM - Carlo Migliorini <migliorini@sodalia.it>
;;   JR - Jack Repenning   <jackr@sgi.com>
;;   GE - Gary Ellison     <Gary.F.Ellison@att.com>
;;
;; *** REVISION HISTORY ***
;;
;; DATE MOD.  BY  REASON FOR MODIFICATION
;; ---------  --  --------------------------------------------------------------
;;  2 Apr 99  DH  1.2: Noticed an out-of-date comment referencing .bashrc etc.
;; 11 Dec 96  DH  1.1: ksh-mode just indented continuation lines by 1 space.
;;                csh-mode looks at the first line and indents properly to line
;;                up under the open-paren, quote, or command.  
;; 11 Dec 96  DH  Added fontification for history substitutions.
;; 10 Dec 96  DH  Added indentation and fontification for labels.  Added
;;                fontification for variables and backquoted strings.
;;  9 Dec 96  DH  1.0: Brought csh-mode up to the level of functionality of
;;                the original ksh-mode.
;;  7 Oct 96  CM  0.1: Hacked ksh-mode.el into minimally functional csh-mode.el
;;                by doing search-and-replace and some keyword changes.
;;  8 Aug 96  JR  (Last modification to ksh-mode 2.6.)
;;                [...]
;; 19 Jun 92  GE  (Conception of ksh-mode.)
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(defconst csh-mode-version "1.2"
  "*Version number of this version of csh-mode")

(defvar csh-mode-hook 
  '(lambda ()
     (auto-fill-mode 1))
  "Hook to run each time csh-mode is entered.")


;;
;; -------------------------------------------> Variables controlling completion
;;
(defvar csh-completion-list '())
(make-variable-buffer-local 'csh-completion-list)
(set-default 'csh-completion-list  '())
;;
;; -type-  : type number, 0:misc, 1:variable, 2:function
;; -regexp-: regexp used to parse the script
;; -match- : used by match-beginning/end to pickup target
;;
(defvar csh-completion-type-misc 0)
(defvar csh-completion-regexp-var "\\([A-Za-z_0-9]+\\)=")
(defvar csh-completion-type-var 1)
(defvar csh-completion-match-var 1) 
(defvar csh-completion-regexp-var2 "\\$\\({\\|{#\\)?\\([A-Za-z_0-9]+\\)[#%:}]?")
(defvar csh-completion-match-var2 2)
(defvar csh-completion-regexp-function
  "\\(function\\)?[ \t]*\\([A-Za-z_0-9]+\\)[ \t]*([ \t]*)")
(defvar csh-completion-type-function 2)
(defvar csh-completion-match-function 2)


;;
;; ------------------------------------> Variables controlling indentation style
;;
(defvar csh-indent 4
  "*Indentation of csh statements with respect to containing block. A value
of nil indicates compound list keyword \(\"do\" and \"then\"\) alignment.")

(defvar csh-case-item-offset csh-indent
  "*Additional indentation for case items within a case statement.")
(defvar csh-case-indent nil
  "*Additional indentation for statements under case items.")
(defvar csh-comment-regexp "^\\s *#"
  "*Regular expression used to recognize comments. Customize to support
csh-like languages.")
(defvar csh-match-and-tell t
  "*If non-nil echo in the minibuffer the matching compound command
for the \"breaksw\", \"end\", or \"endif\".")
(defvar csh-tab-always-indent t
  "*Controls the operation of the TAB key. If t (the default), always
reindent the current line.  If nil, indent the current line only if
point is at the left margin or in the line's indentation; otherwise
insert a tab.")


;;
;; ----------------------------------------> Constants containing syntax regexps
;; 
(defconst csh-case-default-re
  "^\\s *\\(case\\|default\\)\\b"
  "Regexp used to locate grouping keywords case and default" )

(defconst csh-case-item-re "^\\s *\\(case .*\\|default\\):"
  "Regexp used to match case-items")

(defconst csh-end-re "^\\s *end\\b"
  "Regexp used to match keyword: end")

(defconst csh-endif-re "^\\s *endif\\b"
  "Regexp used to match keyword: endif")

(defconst csh-endsw-re "^\\s *endsw\\b"
  "Regexp used to match keyword: endsw")

(defconst csh-else-re "^\\s *\\belse\\(\\b\\|$\\)"
  "Regexp used to match keyword: else")

(defconst csh-else-if-re "^\\s *\\belse if\\(\\b\\|$\\)"
  "Regexp used to match keyword pair: else if")

(defconst csh-if-re "^\\s *if\\b.+\\(\\\\\\|\\bthen\\b\\)"
  "Regexp used to match non-one-line if statements")

(defconst csh-iteration-keywords-re "^[^#\n]*\\s\"*\\b\\(while\\|foreach\\)\\b"
  "Match one of the keywords: while, foreach")

(defconst csh-keywords-re
  "^\\s *\\(else\\b\\|foreach\\b\\|if\\b.+\\(\\\\\\|\\bthen\\b\\)\\|switch\\b\\|while\\b\\)"
  "Regexp used to detect compound command keywords: else, if, foreach, while")

(defconst csh-label-re "^\\s *[^!#$\n ]+:"
  "Regexp used to match flow-control labels")

(defconst csh-multiline-re "^.*\\\\$"
  "Regexp used to match a line with a statement using more lines.")

(defconst csh-switch-re "^\\s *switch\\b"
  "Regexp used to match keyword: switch")


;;
;; ----------------------------------------> Variables controlling fontification
;;
(defvar csh-keywords '("@" "alias" "bg" "break" "breaksw" "case" "cd" "chdir" 
		       "continue" "default" "dirs" "echo" "else" "end" "endif"
		       "endsw" "eval" "exec" "exit" "fg" "foreach" "glob" "goto"
		       "hashstat" "history" "if" "jobs" "kill" "limit" "login"
		       "logout" "limit" "notify" "onintr" "popd" "printenv"
		       "pushd" "rehash" "repeat" "set" "setenv" "shift" "source"
		       "stop" "suspend" "switch" "then" "time" "umask" "unalias"
		       "unhash" "unlimit" "unset" "unsetenv" "wait" "while"
		       ;; tcsh-keywords
		       "alloc" "bindkey" "builtins" "complete" "echotc"
		       "filetest" "hup" "log" "ls-F" "nice" "nohup" "sched"
		       "settc" "setty" "telltc" "uncomplete" "where" "which"))

(require 'font-lock)  ; need to do this before referring to font-lock-* below

(defconst csh-font-lock-keywords
  ;; NOTE:  The order of some of the items in this list is significant.  Do not
  ;;        alphabetize or otherwise blindly rearrange.
  (list
   ;; Comments on line 1, which are missed by syntactic fontification.
   '("^#.*" 0 font-lock-comment-face)

   ;; Label definitions (1 means first parenthesized exp in regexp).
   '("^\\s *\\([^!#$\n ]+\\):" 1 font-lock-function-name-face)
  
   ;; Label references.
   '("\\b\\(goto\\|onintr\\)\\b\\s +\\([^!#$ \n\t]+\\)"
     2 font-lock-function-name-face)
  
   ;; Variable settings.
   '("\\(@\\|set\\|setenv\\)\\s +\\([0-9A-Za-z_]+\\b\\)"
     2 font-lock-variable-name-face)
   
   ;; Variable references not inside of strings.
   '("\\$[][0-9A-Za-z_#:?]+" 0 font-lock-variable-name-face)

   ;; Backquoted strings.  'keep' means to just fontify non-fontified text.
   '("`\\(.*\\)`" 1 font-lock-reference-face keep)

   ;; NOTE:  The following variables need to be anchored to the beginning of
   ;;        line to prevent re-fontifying text in comments.  Due to this, we
   ;;        can only catch a finite number of occurrences.  More can be added.
   ;;        The 't' means to override previous fontification.
   ;;
   ;;        Variable references inside of " strings.
   '("^[^#\n]*\".*\\(\\$[][0-9A-Za-z_#:?]+\\).*\""
     1 font-lock-variable-name-face t)                                    ; 1
   '("^[^#\n]*\".*\\(\\$[][0-9A-Za-z_#:?]+\\).*\\$[][0-9A-Za-z_#:?]+.*\""
     1 font-lock-variable-name-face t)                                    ; 2
   (cons (concat "^[^#\n]*\".*\\(\\$[][0-9A-Za-z_#:?]+\\).*"
		 "\\$[][0-9A-Za-z_#:?]+.*\\$[][0-9A-Za-z_#:?]+.*\"")
	 (list 1 font-lock-variable-name-face t))                         ; 3
   ;;
   ;;        History substitutions.  
   '("^![^~= \n\t]+" 0 font-lock-reference-face t)                      ; BOL
   '("^[^#\n]*[^#\\\n]\\(![^~= \n\t]+\\)" 1 font-lock-reference-face t) ; 1
   '("^[^#\n]*[^#\\\n]\\(![^~= \n\t]+\\).*![^~= \n\t]+"
     1 font-lock-reference-face t)                                      ; 2

   ;; Keywords.
   (cons (concat
	  "\\(\\<"
	  (mapconcat 'identity csh-keywords "\\>\\|\\<")
	  "\\>\\)")
	 1)
   ))

(put 'csh-mode 'font-lock-keywords 'csh-font-lock-keywords)


;;
;; -------------------------------------------------------> Mode-specific tables
;;
(defvar csh-mode-abbrev-table nil
  "Abbrev table used while in csh mode.")
(define-abbrev-table 'csh-mode-abbrev-table ())

(defvar csh-mode-map nil 
  "Keymap used in csh mode")
(if csh-mode-map
    ()
  (setq csh-mode-map (make-sparse-keymap))
;;(define-key csh-mode-map "\177"    'backward-delete-char-untabify)
  (define-key csh-mode-map "\C-c\t"  'csh-completion-init-and-pickup)
  (define-key csh-mode-map "\C-j"    'reindent-then-newline-and-indent)
  (define-key csh-mode-map "\e\t"    'csh-complete-symbol)
  (define-key csh-mode-map "\n"      'reindent-then-newline-and-indent)
  (define-key csh-mode-map '[return] 'reindent-then-newline-and-indent)
  (define-key csh-mode-map "\t"      'csh-indent-command)
;;(define-key csh-mode-map "\t"      'csh-indent-line)
  )

(defvar csh-mode-syntax-table nil
  "Syntax table used while in csh mode.")
(if csh-mode-syntax-table
    ;; If it's already set up, don't change it.
    ()
  ;; Else, create it from the standard table and modify entries that need to be.
  (setq csh-mode-syntax-table (make-syntax-table))
  (modify-syntax-entry ?&  "."  csh-mode-syntax-table) ; & -punctuation
  (modify-syntax-entry ?*  "."  csh-mode-syntax-table) ; * -punctuation
  (modify-syntax-entry ?-  "."  csh-mode-syntax-table) ; - -punctuation
  (modify-syntax-entry ?=  "."  csh-mode-syntax-table) ; = -punctuation
  (modify-syntax-entry ?+  "."  csh-mode-syntax-table) ; + -punctuation
  (modify-syntax-entry ?|  "."  csh-mode-syntax-table) ; | -punctuation
  (modify-syntax-entry ?<  "."  csh-mode-syntax-table) ; < -punctuation
  (modify-syntax-entry ?>  "."  csh-mode-syntax-table) ; > -punctuation
  (modify-syntax-entry ?/  "."  csh-mode-syntax-table) ; / -punctuation
  (modify-syntax-entry ?\' "\"" csh-mode-syntax-table) ; ' -string quote
  (modify-syntax-entry ?.  "w"  csh-mode-syntax-table) ; . -word constituent
  (modify-syntax-entry ??  "w"  csh-mode-syntax-table) ; ? -word constituent

  ;; \n - comment ender, first character of 2-char comment sequence
  (modify-syntax-entry ?\n "> 1" csh-mode-syntax-table) ; # -word constituent

  ;;   - whitespace, first character of 2-char comment sequence
  (modify-syntax-entry ?   "  1" csh-mode-syntax-table) ; 

  ;; \t - whitespace, first character of 2-char comment sequence
  (modify-syntax-entry ?\t "  1" csh-mode-syntax-table) ; # -word constituent

  ;; # - word constituent, second character of 2-char comment sequence
  (modify-syntax-entry ?#  "w 2" csh-mode-syntax-table) ; # -word constituent
  )


;;
;; ------------------------------------------------------------------> Functions
;;
(defun csh-current-line ()
  "Return the vertical position of point in the buffer.
Top line is 1."
  (+ (count-lines (point-min) (point))
     (if (= (current-column) 0) 1 0))
  )

(defun csh-get-compound-level 
  (begin-re end-re anchor-point &optional balance-list)
  "Determine how much to indent this structure. Return a list (level line) 
of the matching compound command or nil if no match found."
  (let* 
      (;; Locate the next compound begin keyword bounded by point-min
       (match-point (if (re-search-backward begin-re (point-min) t)
			(match-beginning 0) 0))
       (nest-column (if (zerop match-point)
			1 
		      (progn
			(goto-char match-point)
			(current-indentation))))
       (nest-list (cons 0 0))    ;; sentinel cons since cdr is >= 1
       )
    (if (zerop match-point)
	nil ;; graceful exit from recursion
      (progn
	(if (nlistp balance-list)
	    (setq balance-list (list)))
	;; Now search forward from matching start keyword for end keyword
	(while (and (consp nest-list) (zerop (cdr nest-list))
		    (re-search-forward end-re anchor-point t))
	  (if (not (memq (point) balance-list))
	      (progn
		(setq balance-list (cons (point) balance-list))
		(goto-char match-point)  ;; beginning of compound cmd
		(setq nest-list
		      (csh-get-compound-level begin-re end-re
					     anchor-point balance-list))
		)))

	(cond ((consp nest-list)
	       (if (zerop (cdr nest-list))
		 (progn
		   (goto-char match-point)
		   (cons nest-column (csh-current-line)))
		 nest-list))
	      (t nil)
	      )
	)
      )
    )
  )

(defun csh-get-nest-level ()
  "Return a 2 element list (nest-level nest-line) describing where the
current line should nest."
  (let ((case-fold-search)
    	(level))
    (save-excursion
      (forward-line -1)
      (while (and (not (bobp))
		  (null level))
	(if (and (not (looking-at "^\\s *$"))
 		 (not (save-excursion
 			(forward-line -1)
 			(beginning-of-line)
			(looking-at csh-multiline-re)))
		 (not (looking-at csh-comment-regexp)))
	    (setq level (cons (current-indentation)
			      (csh-current-line)))
	  (forward-line -1)
	  );; if
	);; while
      (if (null level)
	  (cons (current-indentation) (csh-current-line))
	level)
      )
    )
  )

(defun csh-get-nester-column (nest-line)
  "Return the column to indent to with respect to nest-line taking 
into consideration keywords and other nesting constructs."
  (save-excursion 
    (let ((fence-post)
	  (case-fold-search)
	  (start-line (csh-current-line)))
      ;;
      ;; Handle case item indentation constructs for this line
      (cond ((looking-at csh-case-item-re)
	     ;; This line is a case item...
	     (save-excursion
	       (goto-line nest-line)
	       (let ((fence-post (save-excursion (end-of-line) (point))))
		 (cond ((re-search-forward csh-switch-re fence-post t)
			;; If this is the first case under the switch, indent.
			(goto-char (match-beginning 0))
			(+ (current-indentation) csh-case-item-offset))

		       ((re-search-forward csh-case-item-re fence-post t)
			;; If this is another case right under a previous case
			;; without intervening code, stay at the same
			;; indentation. 
			(goto-char (match-beginning 0))
			(current-indentation))
		       
		       (t
			;; Else, this is a new case.  Outdent.
			(- (current-indentation) csh-case-item-offset))
		       )
		 )))
	    (t;; Not a case-item.  What to do relative to the nest-line?
	     (save-excursion
	       (goto-line nest-line)
	       (setq fence-post (save-excursion (end-of-line) (point)))
	       (save-excursion
		 (cond
		  ;;
		  ;; Check if we are in a continued statement
		  ((and (looking-at csh-multiline-re)
			(save-excursion
			  (goto-line (1- start-line))
			  (looking-at csh-multiline-re)))
		   (if (looking-at ".*[\'\"]\\\\")
		       ;; If this is a continued string, indent under
		       ;; opening quote.
		       (progn
			 (re-search-forward "[\'\"]")
			 (forward-char -1))
		     (if (looking-at ".*([^\)\n]*\\\\")
			 ;; Else if this is a continued parenthesized
			 ;; list, indent after paren.
			 (re-search-forward "(" fence-post t)
		       ;; Else, indent after whitespace after first word.
		       (re-search-forward "[^ \t]+[ \t]+" fence-post t)))
		   (current-column))
		  
		  ;; In order to locate the column of the keyword,
		  ;; which might be embedded within a case-item,
		  ;; it is necessary to use re-search-forward.
		  ;; Search by literal case, since shell is
		  ;; case-sensitive.
		  ((re-search-forward csh-keywords-re fence-post t)
		   (goto-char (match-beginning 1))
		   (if (looking-at csh-switch-re)
		       (+ (current-indentation) csh-case-item-offset)
		     (+ (current-indentation)
			(if (null csh-indent)
			    2 csh-indent)
			)))
		  
		  ((re-search-forward csh-case-default-re fence-post t)  
		   (if (null csh-indent)
		       (progn 
			 (goto-char (match-end 1))
			 (+ (current-indentation) 1))
		     (progn
		       (goto-char (match-beginning 1))
		       (+ (current-indentation) csh-indent))
		     ))
		  
		  ;;
		  ;; Now detect first statement under a case item
		  ((looking-at csh-case-item-re)
		   (if (null csh-case-indent)
		       (progn
			 (re-search-forward csh-case-item-re fence-post t)
			 (goto-char (match-end 1))
			 (+ (current-column) 1))
		     (+ (current-indentation) csh-case-indent)))
		  
		  ;;
		  ;; If this is the first statement under a control-flow
		  ;; label, indent one level. 
		  ((csh-looking-at-label)
		   (+ (current-indentation) csh-indent))
		  
		  ;; This is hosed when using current-column
		  ;; and there is a multi-command expression as the
		  ;; nester.
		  (t (current-indentation)))
		 )
	       ));; excursion over
	    );; Not a case-item
      );;let
    );; excursion
  );; defun

(defun csh-indent-command ()
  "Indent current line relative to containing block and allow for
csh-tab-always-indent customization"
  (interactive)
  (let (case-fold-search)
    (cond ((save-excursion
	     (skip-chars-backward " \t")
	     (bolp))
	   (csh-indent-line))
	  (csh-tab-always-indent
	   (save-excursion
	     (csh-indent-line)))
	  (t (insert-tab))
	  ))
  )

(defun csh-indent-line ()
  "Indent current line as far as it should go according
to the syntax/context"
  (interactive)
  (let (case-fold-search)
    (save-excursion
      (beginning-of-line)
      (if (bobp)
	  nil
	;;
	;; Align this line to current nesting level
	(let*
	    (
	     (level-list (csh-get-nest-level)) ; Where to nest against
	     ;;           (last-line-level (car level-list))
	     (this-line-level (current-indentation))
	     (nester-column (csh-get-nester-column (cdr level-list)))
	     (struct-match (csh-match-structure-and-reindent))
	     )
	  (if struct-match
	      (setq nester-column struct-match))
	  (if (eq nester-column this-line-level)
	      nil
	    (beginning-of-line)
	    (let ((beg (point)))
	      (back-to-indentation)
	      (delete-region beg (point)))
	    (indent-to nester-column))
	  );; let*
	);; if
      );; excursion
    ;;
    ;; Position point on this line
    (let*
	(
	 (this-line-level (current-indentation))
	 (this-bol (save-excursion
		     (beginning-of-line)
		     (point)))
	 (this-point (- (point) this-bol))
	 )
      (cond ((> this-line-level this-point);; point in initial white space
	     (back-to-indentation))
	    (t nil)
	    );; cond
      );; let*
    );; let
  );; defun

(defun csh-indent-region (start end)
  "From start to end, indent each line."
  ;; The algorithm is just moving through the region line by line with
  ;; the match noise turned off.  Only modifies nonempty lines.
  (save-excursion
    (let (csh-match-and-tell
	  (endmark (copy-marker end)))
      
      (goto-char start)
      (beginning-of-line)
      (setq start (point))
      (while (> (marker-position endmark) start)
	(if (not (and (bolp) (eolp)))
	    (csh-indent-line))
	(forward-line 1)
	(setq start (point)))

      (set-marker endmark nil)
      )
    )
  )

(defun csh-line-to-string ()
  "From point, construct a string from all characters on
current line"
  (skip-chars-forward " \t") ;; skip tabs as well as spaces
  (buffer-substring (point)
                    (progn
                      (end-of-line 1)
                      (point))))

(defun csh-looking-at-label ()
  "Return true if current line is a label (not the default: case label)."
  (and
   (looking-at csh-label-re)
   (not (looking-at "^\\s *default:"))))

(defun csh-match-indent-level (begin-re end-re)
  "Match the compound command and indent. Return nil on no match,
indentation to use for this line otherwise."
  (interactive)
  (let* ((case-fold-search)
	 (nest-list 
	  (save-excursion
	    (csh-get-compound-level begin-re end-re (point))
	    ))
	 ) ;; bindings
    (if (null nest-list)
	(progn
	  (if csh-match-and-tell
	      (message "No matching compound command"))
	  nil) ;; Propagate a miss.
      (let* (
	     (nest-level (car nest-list))
	     (match-line (cdr nest-list))
	     ) ;; bindings
	(if csh-match-and-tell
	    (save-excursion
	      (goto-line match-line)
	      (message "Matched ... %s" (csh-line-to-string))
	      ) ;; excursion
	  ) ;; if csh-match-and-tell
	nest-level ;;Propagate a hit.
	) ;; let*
      ) ;; if
    ) ;; let*
  ) ;; defun csh-match-indent-level

(defun csh-match-structure-and-reindent ()
  "If the current line matches one of the indenting keywords
or one of the control structure ending keywords then reindent. Also
if csh-match-and-tell is non-nil the matching structure will echo in
the minibuffer"
  (interactive)
  (let (case-fold-search)
    (save-excursion
      (beginning-of-line)
      (cond ((looking-at csh-else-re)
	     (csh-match-indent-level csh-if-re csh-endif-re))
	    ((looking-at csh-else-if-re)
	     (csh-match-indent-level csh-if-re csh-endif-re))
	    ((looking-at csh-endif-re)
	     (csh-match-indent-level csh-if-re csh-endif-re))
	    ((looking-at csh-end-re)
	     (csh-match-indent-level csh-iteration-keywords-re csh-end-re))
	    ((looking-at csh-endsw-re)
	     (csh-match-indent-level csh-switch-re csh-endsw-re))
	    ((csh-looking-at-label)
	     ;; Flush control-flow labels left since they don't nest.
	     0)
	    ;;
	    (t nil)
	    );; cond
      )
    ))

;;;###autoload
(defun csh-mode ()
  "csh-mode 2.0 - Major mode for editing csh and tcsh scripts.
Special key bindings and commands:
\\{csh-mode-map}
Variables controlling indentation style:
csh-indent
    Indentation of csh statements with respect to containing block.
    Default value is 4.
csh-case-indent
    Additional indentation for statements under case items.
    Default value is nil which will align the statements one position 
    past the \")\" of the pattern.
csh-case-item-offset
    Additional indentation for case items within a case statement.
    Default value is 2.
csh-tab-always-indent
    Controls the operation of the TAB key. If t (the default), always
    reindent the current line.  If nil, indent the current line only if
    point is at the left margin or in the line's indentation; otherwise
    insert a tab.
csh-match-and-tell
    If non-nil echo in the minibuffer the matching compound command
    for the \"done\", \"}\", \"fi\", or \"endsw\". Default value is t.

csh-comment-regexp
  Regular expression used to recognize comments. Customize to support
  csh-like languages. Default value is \"\^\\\\s *#\".

Style Guide.
 By setting
    (setq csh-indent default-tab-width)

    The following style is obtained:

    if [ -z $foo ]
	    then
		    bar    # <-- csh-group-offset is additive to csh-indent
		    foo
    fi

 By setting
    (setq csh-indent default-tab-width)
    (setq csh-group-offset (- 0 csh-indent))

    The following style is obtained:

    if [ -z $foo ]
    then
	    bar
	    foo
    fi

 By setting
    (setq csh-case-item-offset 1)
    (setq csh-case-indent nil)

    The following style is obtained:

    case x in *
     foo) bar           # <-- csh-case-item-offset
          baz;;         # <-- csh-case-indent aligns with \")\"
     foobar) foo
             bar;;
    endsw

 By setting
    (setq csh-case-item-offset 1)
    (setq csh-case-indent 6)

    The following style is obtained:

    case x in *
     foo) bar           # <-- csh-case-item-offset
           baz;;        # <-- csh-case-indent
     foobar) foo
           bar;;
    endsw
    

Installation:
  Put csh-mode.el in some directory in your load-path.
  Put the following forms in your .emacs file.

 (setq auto-mode-alist
      (append auto-mode-alist
              (list
               '(\"\\\\.csh$\" . csh-mode)
               '(\"\\\\.login\" . csh-mode))))

 (setq csh-mode-hook
      (function (lambda ()
         (font-lock-mode 1)             ;; font-lock the buffer
         (setq csh-indent 8)
         (setq csh-tab-always-indent t)
         (setq csh-match-and-tell t)
         (setq csh-align-to-keyword t)	;; Turn on keyword alignment
	 )))"
  (interactive)
  (kill-all-local-variables)
  (use-local-map csh-mode-map)
  (setq major-mode 'csh-mode)
  (setq mode-name "Csh")
  (setq local-abbrev-table csh-mode-abbrev-table)
  (set-syntax-table csh-mode-syntax-table)
  (make-local-variable 'indent-line-function)
  (setq indent-line-function 'csh-indent-line)
  (make-local-variable 'indent-region-function)
  (setq indent-region-function 'csh-indent-region)
  (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 "#+ *")
  ;;
  ;; config font-lock mode
  (make-local-variable 'font-lock-keywords) 
  (setq font-lock-keywords csh-font-lock-keywords)
  ;;
  ;; Let the user customize
  (run-hooks 'csh-mode-hook)
  ) ;; defun

;;
;; Completion code supplied by Haavard Rue <hrue@imf.unit.no>.
;;
;;
;; add a completion with a given type to the list
;;
(defun csh-addto-alist (completion type)
  (setq csh-completion-list
	(append csh-completion-list
		(list (cons completion type)))))

(defun csh-bol-point ()
  (save-excursion
    (beginning-of-line)
    (point)))

(defun csh-complete-symbol ()
  "Perform completion."
  (interactive)
  (let* ((case-fold-search)
	 (end (point))
         (beg (unwind-protect
                  (save-excursion
                    (backward-sexp 1)
                    (while (= (char-syntax (following-char)) ?\')
                      (forward-char 1))
                    (point))))
         (pattern (buffer-substring beg end))
	 (predicate 
	  ;;
	  ;; ` or $( mark a function
	  ;;
	  (save-excursion
	    (goto-char beg)
	    (if (or
		 (save-excursion
		   (backward-char 1)
		   (looking-at "`"))
		 (save-excursion
		   (backward-char 2)
		   (looking-at "\\$(")))
		(function (lambda (sym)
			    (equal (cdr sym) csh-completion-type-function)))
	      ;;
	      ;; a $, ${ or ${# mark a variable
	      ;;
	      (if (or
		   (save-excursion
		     (backward-char 1)
		     (looking-at "\\$"))
		   (save-excursion
		     (backward-char 2)
		     (looking-at "\\${"))
		   (save-excursion
		     (backward-char 3)
		     (looking-at "\\${#")))
		  (function (lambda (sym)
			      (equal (cdr sym)
				     csh-completion-type-var)))
		;;
		;; don't know. use 'em all
		;;
		(function (lambda (sym) t))))))
	 ;;
	 (completion (try-completion pattern csh-completion-list predicate)))
    ;;
    (cond ((eq completion t))
	  ;;
	  ;; oops, what is this ?
	  ;;
          ((null completion)
           (message "Can't find completion for \"%s\"" pattern))
	  ;;
	  ;; insert
	  ;;
          ((not (string= pattern completion))
           (delete-region beg end)
           (insert completion))
	  ;;
	  ;; write possible completion in the minibuffer,
	  ;; use this instead of a seperate buffer (usual)
	  ;;
          (t
           (let ((list (all-completions pattern csh-completion-list predicate))
		 (string ""))
	     (while list
	       (progn
		 (setq string (concat string (format "%s " (car list))))
		 (setq list (cdr list))))
	     (message string))))))

;;
;; init the list and pickup all 
;;
(defun csh-completion-init-and-pickup ()
  (interactive)
  (let (case-fold-search)
    (csh-completion-list-init)
    (csh-pickup-all)))

;;
;; init the list
;;
(defun csh-completion-list-init ()
  (interactive)
  (setq csh-completion-list
	(list
	 (cons "break"  csh-completion-type-misc)
	 (cons "breaksw"  csh-completion-type-misc)
	 (cons "case"  csh-completion-type-misc)
	 (cons "continue"  csh-completion-type-misc)
	 (cons "endif"  csh-completion-type-misc)
	 (cons "exit"  csh-completion-type-misc)
	 (cons "foreach"  csh-completion-type-misc)
	 (cons "if"  csh-completion-type-misc)
	 (cons "while"  csh-completion-type-misc))))

(defun csh-eol-point ()
  (save-excursion
    (end-of-line)
    (point)))

(defun csh-pickup-all ()
  "Pickup all completions in buffer."
  (interactive)
  (csh-pickup-completion-driver (point-min) (point-max) t))

(defun csh-pickup-completion (regexp type match pmin pmax)
  "Pickup completion in region and addit to the list, if not already
there." 
  (let ((i 0) kw obj)
    (save-excursion
      (goto-char pmin)
      (while (and
	      (re-search-forward regexp pmax t)
	      (match-beginning match)
	      (setq kw  (buffer-substring
			 (match-beginning match)
			 (match-end match))))
	(progn
	  (setq obj (assoc kw csh-completion-list))
	  (if (or (equal nil obj)
		  (and (not (equal nil obj))
		       (not (= type (cdr obj)))))
	      (progn
		(setq i (1+ i))
		(csh-addto-alist kw type))))))
    i))

(defun csh-pickup-completion-driver (pmin pmax message)
  "Driver routine for csh-pickup-completion."
  (if message
      (message "pickup completion..."))
  (let* (
	 (i1
	  (csh-pickup-completion  csh-completion-regexp-var
				 csh-completion-type-var
				 csh-completion-match-var
				 pmin pmax))
	 (i2
	  (csh-pickup-completion  csh-completion-regexp-var2
				 csh-completion-type-var
				 csh-completion-match-var2
				 pmin pmax))
	 (i3
	  (csh-pickup-completion  csh-completion-regexp-function
				 csh-completion-type-function
				 csh-completion-match-function
				 pmin pmax)))
    (if message
	(message "pickup %d variables and %d functions." (+ i1 i2) i3))))

(defun csh-pickup-this-line ()
  "Pickup all completions in current line."
  (interactive)
  (csh-pickup-completion-driver (csh-bol-point) (csh-eol-point) nil))


(provide 'csh-mode)
;;; csh-mode.el ends here