;; 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