home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / emacs-19.28-src.tgz / tar.out / fsf / emacs / lisp / sh-script.el < prev    next >
Lisp/Scheme  |  1996-09-28  |  30KB  |  905 lines
  1. ;;; sh-script.el --- shell-script editing commands for Emacs
  2. ;; Copyright (C) 1993 Free Software Foundation, Inc.
  3.  
  4. ;; Author: Daniel Pfeiffer, fax (+49 69) 75 88 529, c/o <bonhoure@cict.fr>
  5. ;; Maintainer: FSF
  6. ;; Keywords: shell programming
  7.  
  8. ;; This file is part of GNU Emacs.
  9.  
  10. ;; GNU Emacs is free software; you can redistribute it and/or modify
  11. ;; it under the terms of the GNU General Public License as published by
  12. ;; the Free Software Foundation; either version 2, or (at your option)
  13. ;; any later version.
  14.  
  15. ;; GNU Emacs is distributed in the hope that it will be useful,
  16. ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18. ;; GNU General Public License for more details.
  19.  
  20. ;; You should have received a copy of the GNU General Public License
  21. ;; along with GNU Emacs; see the file COPYING.  If not, write to
  22. ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  
  24. ;;; Commentary:
  25.  
  26. ;; Major mode for editing shell scripts.  Currently sh, ksh, bash and csh,
  27. ;; tcsh are supported.  Structured statements can be inserted with one
  28. ;; command.
  29.  
  30. ;; Autoloading of these functions is currently turned off
  31. ;; because it's not clear whether this mode is really desirable to use.
  32. ;; -- rms
  33.  
  34. ;;; Code:
  35.  
  36. ;; page 1:    variables and settings
  37. ;; page 2:    mode-command and utility functions
  38. ;; page 3:    statement syntax-commands for various shells
  39. ;; page 4:    various other commands
  40.  
  41.  
  42. ;;;###dont-autoload
  43. (setq auto-mode-alist
  44.       ;; matches files
  45.       ;;    - whose path contains /bin/, but not directories
  46.       (cons '("/bin/" . sh-or-other-mode)
  47.         ;;    - that have a suffix .sh or .shar (shell archive)
  48.         ;;    - that contain resources for the various shells
  49.         ;;    - startup files for X11
  50.         (cons '("\\.sh$\\|\\.shar$\\|/\\.\\(profile\\|bash_profile\\|login\\|bash_login\\|logout\\|bash_logout\\|bashrc\\|t?cshrc\\|xinitrc\\|startxrc\\|xsession\\)$" . sh-mode)
  51.           auto-mode-alist)))
  52.  
  53.  
  54. (defvar sh-mode-syntax-table
  55.   (let ((table (copy-syntax-table)))
  56.     (modify-syntax-entry ?\# "<" table)
  57.     (modify-syntax-entry ?\^l ">#" table)
  58.     (modify-syntax-entry ?\n ">#" table)
  59.     (modify-syntax-entry ?\" "\"\"" table)
  60.     (modify-syntax-entry ?\' "\"'" table)
  61.     (modify-syntax-entry ?\` "$`" table)
  62.     (modify-syntax-entry ?$ "_" table)
  63.     (modify-syntax-entry ?! "_" table)
  64.     (modify-syntax-entry ?% "_" table)
  65.     (modify-syntax-entry ?: "_" table)
  66.     (modify-syntax-entry ?. "_" table)
  67.     (modify-syntax-entry ?^ "_" table)
  68.     (modify-syntax-entry ?~ "_" table)
  69.     table)
  70.   "Syntax table in use in Shell-Script mode.")
  71.  
  72.  
  73.  
  74. (defvar sh-use-prefix nil
  75.   "If non-nil when loading, `$' and `<' will be  C-c $  and  C-c < .")
  76.  
  77. (defvar sh-mode-map
  78.   (let ((map (make-sparse-keymap)))
  79.     (define-key map "\C-c(" 'sh-function)
  80.     (define-key map "\C-c\C-w" 'sh-while)
  81.     (define-key map "\C-c\C-u" 'sh-until)
  82.     (define-key map "\C-c\C-s" 'sh-select)
  83.     (define-key map "\C-c\C-l" 'sh-indexed-loop)
  84.     (define-key map "\C-c\C-i" 'sh-if)
  85.     (define-key map "\C-c\C-f" 'sh-for)
  86.     (define-key map "\C-c\C-c" 'sh-case)
  87.     
  88.     (define-key map (if sh-use-prefix "\C-c$" "$")
  89.       'sh-query-for-variable)
  90.     (define-key map "=" 'sh-assignment)
  91.     (define-key map "\C-c+" 'sh-add)
  92.     (define-key map (if sh-use-prefix "\C-c<" "<")
  93.       'sh-maybe-here-document)
  94.     (define-key map "(" 'pair-insert-maybe)
  95.     (define-key map "{" 'pair-insert-maybe)
  96.     (define-key map "[" 'pair-insert-maybe)
  97.     (define-key map "'" 'pair-insert-maybe)
  98.     (define-key map "`" 'pair-insert-maybe)
  99.     (define-key map "\"" 'pair-insert-maybe)
  100.  
  101.     (define-key map "\t" 'sh-indent-line)
  102.     (substitute-key-definition 'complete-tag 'comint-dynamic-complete-filename
  103.                    map (current-global-map))
  104.     (substitute-key-definition 'newline-and-indent 'sh-newline-and-indent
  105.                    map (current-global-map))
  106.     ;; Now that tabs work properly, this might be unwanted.
  107.     (substitute-key-definition 'delete-backward-char
  108.                    'backward-delete-char-untabify
  109.                    map (current-global-map))
  110.     (define-key map "\C-c:" 'sh-set-shell)
  111.     (substitute-key-definition 'beginning-of-defun
  112.                    'sh-beginning-of-compound-command
  113.                    map (current-global-map))
  114.     (substitute-key-definition 'backward-sentence 'sh-beginning-of-command
  115.                    map (current-global-map))
  116.     (substitute-key-definition 'forward-sentence 'sh-end-of-command
  117.                    map (current-global-map))
  118.     (substitute-key-definition 'manual-entry 'sh-manual-entry
  119.                    map (current-global-map))
  120.     (define-key map [menu-bar insert] 
  121.       (cons "Insert" (make-sparse-keymap "Insert")))
  122.     (define-key map [menu-bar insert sh-while] 
  123.       '("While loop" . sh-while))
  124.     (define-key map [menu-bar insert sh-until] 
  125.       '("Until loop" . sh-until))
  126.     (define-key map [menu-bar insert sh-select] 
  127.       '("Select statement" . sh-select))
  128.     (define-key map [menu-bar insert sh-indexed-loop] 
  129.       '("Indexed loop" . sh-indexed-loop))
  130.     (define-key map [menu-bar insert sh-if] 
  131.       '("If statement" . sh-if))
  132.     (define-key map [menu-bar insert sh-for] 
  133.       '("For loop" . sh-for))
  134.     (define-key map [menu-bar insert sh-case] 
  135.       '("Case statement" . sh-case))
  136.     map)
  137.   "Keymap used in Shell-Script mode.")
  138.  
  139.  
  140.  
  141. (defvar sh-find-file-modifies t
  142.   "*What to do when newly found file has no magic number:
  143.     nil    do nothing
  144.     t    insert magic number
  145.     other    insert magic number, but mark as unmodified.")
  146.  
  147.  
  148. (defvar sh-query-for-magic t
  149.   "*If non-nil, ask user before changing or inserting magic number.")
  150.  
  151.  
  152. (defvar sh-magicless-file-regexp "/\\.[^/]+$"
  153.   "*On files with this kind of name no magic is inserted or changed.")
  154.  
  155.  
  156. ;; someone who understands /etc/magic better than me should beef this up
  157. ;; this currently covers only SCO Unix and Sinix executables
  158. ;; the elegant way would be to read /etc/magic
  159. (defvar magic-number-alist '(("L\^a\^h\\|\^?ELF" . hexl-mode)
  160.                  ("#!.*perl" . perl-mode))
  161.   "A regexp to match the magic number of a found file.
  162. Currently this is only used by function `sh-or-other-mode'.")
  163.  
  164.  
  165. (defvar sh-executable ".* is \\([^ \t]*\\)\n"
  166.   "*Regexp to match the output of sh builtin `type' command on your machine.
  167. The regexp must match the whole output, and must contain a \\(something\\)
  168. construct which matches the actual executable.")
  169.  
  170.  
  171.  
  172. (defvar sh-chmod-argument "+x"
  173.   "*After saving, if the file is not executable, set this mode.
  174. The mode can be absolute, such as \"777\", or relative, such as \"+x\".
  175. Do nothing if this is nil.")
  176.  
  177.  
  178. (defvar sh-shell-path (or (getenv "SHELL") "/bin/sh")
  179.   "*The executable of the shell being programmed.")
  180.  
  181. (defvar sh-shell-argument nil
  182.   "*A single argument for the magic number, or nil.")
  183.  
  184. (defvar sh-shell nil
  185.   "The shell being programmed.  This is set by \\[sh-set-shell].")
  186.  
  187. (defvar sh-shell-is-csh nil
  188.   "The shell being programmed.  This is set by \\[sh-set-shell].")
  189.  
  190. (defvar sh-tab-width 4
  191.   "The default value for `tab-width' in Shell-Script mode.
  192. This is the width of tab stops after the indentation of the preceeding line.")
  193.  
  194. (defvar sh-remember-variable-min 3
  195.   "*Don't remember variables less than this length for completing reads.")
  196.  
  197.  
  198. (defvar sh-beginning-of-command
  199.   "\\([;({`|&]\\|^\\)[ \t]*\\([/~:a-zA-Z0-9]\\)"
  200.   "*Regexp to determine the beginning of a shell command.
  201. The actual command starts at the beginning of the second \\(grouping\\).")
  202.  
  203. (defvar sh-end-of-command
  204.   "\\([/~:a-zA-Z0-9]\\)[ \t]*\\([;#)}`|&]\\|$\\)"
  205.   "*Regexp to determine the end of a shell command.
  206. The actual command ends at the end of the first \\(grouping\\).")
  207.  
  208.  
  209.  
  210. (defvar sh-assignment-space '(csh tcsh)
  211.   "List of shells that allow spaces around the assignment =.")
  212.  
  213. (defvar sh-here-document-word "+"
  214.   "Word to delimit here documents.")
  215.  
  216.  
  217. ;process-environment
  218. (defvar sh-variables
  219.   '(("addsuffix" tcsh)            ("allow_null_glob_expansion" bash)
  220.     ("ampm" tcsh)            ("argv" csh tcsh) 
  221.     ("autocorrect" tcsh)        ("autoexpand" tcsh)    
  222.     ("autolist" tcsh)            ("autologout" tcsh)
  223.     ("auto_resume" bash)        ("BASH" bash)
  224.     ("BASH_VERSION" bash)        ("cdable_vars" bash)
  225.     ("cdpath" csh tcsh)            ("CDPATH" sh ksh bash) 
  226.     ("chase_symlinks" tcsh)        ("child" csh tcsh) 
  227.     ("COLUMNS" ksh tcsh)        ("correct" tcsh) 
  228.     ("dextract" tcsh)            ("echo" csh tcsh) 
  229.     ("edit" tcsh)            ("EDITOR") 
  230.     ("el" tcsh)                ("ENV" ksh bash)    
  231.     ("ERRNO" ksh)            ("EUID" bash)
  232.     ("FCEDIT" ksh bash)            ("FIGNORE" bash)
  233.     ("fignore" tcsh)            ("FPATH" ksh) 
  234.     ("gid" tcsh)            ("glob_dot_filenames" bash)
  235.     ("histchars" bash csh tcsh)        ("HISTFILE" ksh bash)
  236.     ("HISTFILESIZE" bash)        ("histlit" tcsh) 
  237.     ("history" csh tcsh)        ("history_control" bash)
  238.     ("HISTSIZE" bash)            ("home" csh tcsh) 
  239.     ("HOME")                ("HOST" tcsh) 
  240.     ("hostname_completion_file" bash)    ("HOSTTYPE" bash tcsh)
  241.     ("HPATH" tcsh)            ("HUSHLOGIN")
  242.     ("IFS" sh ksh bash)            ("ignoreeof" bash csh tcsh)
  243.     ("IGNOREEOF" bash)            ("ignore_symlinks" tcsh) 
  244.     ("LANG")                ("LC_COLLATE") 
  245.     ("LC_CTYPE")            ("LC_MESSAGES") 
  246.     ("LC_MONETARY")            ("LC_NUMERIC") 
  247.     ("LC_TIME")                ("LINENO" ksh bash)
  248.     ("LINES" ksh tcsh)            ("listjobs" tcsh) 
  249.     ("listlinks" tcsh)            ("listmax" tcsh) 
  250.     ("LOGNAME")                ("mail" csh tcsh) 
  251.     ("MAIL")                ("MAILCHECK") 
  252.     ("MAILPATH")            ("MAIL_WARNING" bash)
  253.     ("matchbeep" tcsh)            ("nobeep" tcsh)
  254.     ("noclobber" bash csh tcsh)        ("noglob" csh tcsh)
  255.     ("nolinks" bash)            ("nonomatch" csh tcsh) 
  256.     ("NOREBIND" tcsh)            ("notify" bash)
  257.     ("no_exit_on_failed_exec" bash)    ("NO_PROMPT_VARS" bash)
  258.     ("oid" tcsh)            ("OLDPWD" ksh bash)
  259.     ("OPTARG" sh ksh bash)        ("OPTERR" bash)
  260.     ("OPTIND" sh ksh bash)        ("PAGER") 
  261.     ("path" csh tcsh)            ("PATH") 
  262.     ("PPID" ksh bash)            ("printexitvalue" tcsh) 
  263.     ("prompt" csh tcsh)            ("prompt2" tcsh) 
  264.     ("prompt3" tcsh)            ("PROMPT_COMMAND" bash)
  265.     ("PS1" sh ksh bash)            ("PS2" sh ksh bash)
  266.     ("PS3" ksh)                ("PS4" ksh bash)
  267.     ("pushdsilent" tcsh)        ("pushdtohome" tcsh)
  268.     ("pushd_silent" bash)        ("PWD" ksh bash)
  269.     ("RANDOM" ksh bash)            ("recexact" tcsh) 
  270.     ("recognize_only_executables" tcsh)    ("REPLY" ksh bash)
  271.     ("rmstar" tcsh)            ("savehist" tcsh) 
  272.     ("SECONDS" ksh bash)        ("shell" csh tcsh) 
  273.     ("SHELL")                ("SHLVL" bash tcsh) 
  274.     ("showdots" tcsh)            ("sl" tcsh)    
  275.     ("status" csh tcsh)            ("SYSTYPE" tcsh) 
  276.     ("tcsh" tcsh)            ("term" tcsh) 
  277.     ("TERM")                ("TERMCAP")    
  278.     ("time" csh tcsh)            ("TMOUT" ksh bash) 
  279.     ("tperiod" tcsh)            ("tty" tcsh) 
  280.     ("UID" bash)            ("uid" tcsh)
  281.     ("verbose" csh tcsh)        ("version" tcsh)
  282.     ("visiblebell" tcsh)        ("VISUAL")
  283.     ("watch" tcsh)            ("who" tcsh)
  284.     ("wordchars" tcsh))
  285.   "Alist of all environment and shell variables used for completing read.
  286. Variables only understood by some shells are associated to a list of those.")
  287.  
  288.  
  289.  
  290. (defvar sh-font-lock-keywords
  291.   '(("[ \t]\\(#.*\\)" 1 font-lock-comment-face)
  292.     ("\"[^`]*\"\\|'.*'\\|\\\\[^\nntc]" . font-lock-string-face))
  293.   "*Rules for highlighting shell scripts.
  294. This variable is included into the various variables
  295. `sh-SHELL-font-lock-keywords'.  If no such variable exists for some shell,
  296. this one is used.")
  297.  
  298.  
  299. (defvar sh-sh-font-lock-keywords
  300.   (append sh-font-lock-keywords
  301.       '(("\\(^\\|[^-._a-z0-9]\\)\\(case\\|do\\|done\\|elif\\|else\\|esac\\|fi\\|for\\|if\\|in\\|then\\|until\\|while\\)\\($\\|[^-._a-z0-9]\\)" 2 font-lock-keyword-face t)))
  302.   "*Rules for highlighting Bourne shell scripts.")
  303.  
  304. (defvar sh-ksh-font-lock-keywords
  305.   (append sh-sh-font-lock-keywords
  306.       '(("\\(^\\|[^-._a-z0-9]\\)\\(function\\|select\\)\\($\\|[^-._a-z0-9]\\)" 2 font-lock-keyword-face t)))
  307.   "*Rules for highlighting Korn shell scripts.")
  308.  
  309. (defvar sh-bash-font-lock-keywords
  310.   (append sh-sh-font-lock-keywords
  311.       '(("\\(^\\|[^-._a-z0-9]\\)\\(function\\)\\($\\|[^-._a-z0-9]\\)" 2 font-lock-keyword-face t)))
  312.   "*Rules for highlighting Bourne again shell scripts.")
  313.  
  314.  
  315. (defvar sh-csh-font-lock-keywords
  316.   (append sh-font-lock-keywords
  317.       '(("\\(^\\|[^-._a-z0-9]\\)\\(breaksw\\|case\\|default\\|else\\|end\\|endif\\|foreach\\|if\\|switch\\|then\\|while\\)\\($\\|[^-._a-z0-9]\\)" 2 font-lock-keyword-face t)))
  318.   "*Rules for highlighting C shell scripts.")
  319.  
  320. (defvar sh-tcsh-font-lock-keywords sh-csh-font-lock-keywords
  321.   "*Rules for highlighting Toronto C shell scripts.")
  322.  
  323.  
  324.  
  325. ;; mode-command and utility functions
  326.  
  327. ;;;###dont-autoload
  328. (defun sh-or-other-mode ()
  329.   "Decide whether this is a compiled executable or a script.
  330. Usually the file-names of scripts and binaries cannot be automatically
  331. distinguished, so the presence of an executable's magic number is used."
  332.   (funcall (or (let ((l magic-number-alist))
  333.          (while (and l
  334.                  (not (looking-at (car (car l)))))
  335.            (setq l (cdr l)))
  336.          (cdr (car l)))
  337.            'sh-mode)))
  338.  
  339.  
  340. ;;;###dont-autoload
  341. (defun sh-mode ()
  342.   "Major mode for editing shell scripts.
  343. This mode works for many shells, since they all have roughly the same syntax,
  344. as far as commands, arguments, variables, pipes, comments etc. are concerned.
  345. Unless the file's magic number indicates the shell, your usual shell is
  346. assumed.  Since filenames rarely give a clue, they are not further analyzed.
  347.  
  348. The syntax of the statements varies with the shell being used.  The syntax of
  349. statements can be modified by putting a property on the command or new ones
  350. defined with `define-sh-skeleton'.  For example
  351.  
  352.     (put 'sh-until 'ksh '(() \"until \" _ \\n > \"do\" \\n \"done\"))
  353. or
  354.     (put 'sh-if 'smush '(\"What? \" \"If ya got ( \" str \" ) ya betta { \" _ \" }\"))
  355.  
  356. where `sh-until' or `sh-if' have been or will be defined by `define-sh-skeleton'.
  357.  
  358. The following commands are available, based on the current shell's syntax:
  359.  
  360. \\[sh-case]     case statement
  361. \\[sh-for]     for loop
  362. \\[sh-function]     function definition
  363. \\[sh-if]     if statement
  364. \\[sh-indexed-loop]     indexed loop from 1 to n
  365. \\[sh-select]     select statement
  366. \\[sh-until]     until loop
  367. \\[sh-while]     while loop
  368.  
  369. \\[backward-delete-char-untabify]     Delete backward one position, even if it was a tab.
  370. \\[sh-newline-and-indent]     Delete unquoted space and indent new line same as this one.
  371. \\[sh-end-of-command]     Go to end of successive commands.
  372. \\[sh-beginning-of-command]     Go to beginning of successive commands.
  373. \\[sh-set-shell]     Set this buffer's shell, and maybe its magic number.
  374. \\[sh-manual-entry]     Display the Unix manual entry for the current command or shell.
  375.  
  376. \\[sh-query-for-variable]     Unless quoted with \\, query for a variable with completions offered.
  377. \\[sh-maybe-here-document]     Without prefix, following an unquoted < inserts here document.
  378. {, (, [, ', \", `
  379.     Unless quoted with \\, insert the pairs {}, (), [], or '', \"\", ``."
  380.   (interactive)
  381.   (kill-all-local-variables)
  382.   (set-syntax-table sh-mode-syntax-table)
  383.   (use-local-map sh-mode-map)
  384.   (make-local-variable 'indent-line-function)
  385.   (make-local-variable 'comment-start)
  386.   (make-local-variable 'comment-start-skip)
  387.   (make-local-variable 'after-save-hook)
  388.   (make-local-variable 'require-final-newline)
  389.   (make-local-variable 'sh-shell-path)
  390.   (make-local-variable 'sh-shell)
  391.   (make-local-variable 'sh-shell-is-csh)
  392.   (make-local-variable 'pair-alist)
  393.   (make-local-variable 'pair-filter)
  394.   (make-local-variable 'font-lock-keywords)
  395.   (make-local-variable 'font-lock-keywords-case-fold-search)
  396.   (make-local-variable 'sh-variables)
  397.   (setq major-mode 'sh-mode
  398.     mode-name "Shell-script"
  399.     ;; Why can't Emacs have one standard function with some parameters?
  400.     ;; Only few modes actually analyse the previous line's contents
  401.     indent-line-function 'sh-indent-line
  402.     comment-start "# "
  403.     after-save-hook 'sh-chmod
  404.     tab-width sh-tab-width
  405.     ;; C shells do
  406.     require-final-newline t
  407.     font-lock-keywords-case-fold-search nil
  408.     pair-alist '((?` _ ?`))
  409.     pair-filter 'sh-quoted-p)
  410.   ;; parse or insert magic number for exec
  411.   (save-excursion
  412.     (goto-char (point-min))
  413.     (sh-set-shell
  414.      (if (looking-at "#![\t ]*\\([^\t\n ]+\\)")
  415.      (buffer-substring (match-beginning 1) (match-end 1))
  416.        sh-shell-path)))
  417.   ;; find-file is set by `normal-mode' when called by `after-find-file'
  418.   (and (boundp 'find-file) find-file
  419.        (or (eq sh-find-file-modifies t)
  420.        (set-buffer-modified-p nil)))
  421.   (run-hooks 'sh-mode-hook))
  422. ;;;###dont-autoload
  423. (defalias 'shell-script-mode 'sh-mode)
  424.  
  425.  
  426.  
  427. (defmacro define-sh-skeleton (command documentation &rest definitions)
  428.   "Define COMMAND with [DOCSTRING] to insert statements as in DEFINITION ...
  429. Prior definitions (e.g. from ~/.emacs) are maintained.
  430. Each definition is built up as (SHELL PROMPT ELEMENT ...).  Alternately
  431. a synonym definition can be (SHELL . PREVIOUSLY-DEFINED-SHELL).
  432.  
  433. For the meaning of (PROMPT ELEMENT ...) see `skeleton-insert'.
  434. Each DEFINITION is actually stored as
  435.     (put COMMAND SHELL (PROMPT ELEMENT ...)),
  436. which you can also do yourself."
  437.   (or (stringp documentation)
  438.       (setq definitions (cons documentation definitions)
  439.         documentation ""))
  440.   ;; The compiled version doesn't.
  441.   (require 'backquote)
  442.   (`(progn
  443.       (let ((definitions '(, definitions)))
  444.     (while definitions
  445.       ;; skeleton need not be loaded to define these
  446.       (or (and (not (if (boundp 'skeleton-debug) skeleton-debug))
  447.            (get '(, command) (car (car definitions))))
  448.           (put '(, command) (car (car definitions))
  449.            (if (symbolp (cdr (car definitions)))
  450.                (get '(, command) (cdr (car definitions)))
  451.              (cdr (car definitions)))))
  452.       (setq definitions (cdr definitions))))
  453.       (put '(, command) 'menu-enable '(get '(, command) sh-shell))
  454.       (defun (, command) ()
  455.     (, documentation)
  456.     (interactive)
  457.     (skeleton-insert
  458.      (or (get '(, command) sh-shell)
  459.          (error "%s statement syntax not defined for shell %s."
  460.             '(, command) sh-shell)))))))
  461.  
  462.  
  463.  
  464. (defun sh-indent-line ()
  465.   "Indent as far as preceding line, then by steps of `tab-width'.
  466. If previous line starts with a comment, it's considered empty."
  467.   (interactive)
  468.   (let ((previous (save-excursion
  469.             (line-move -1)
  470.             (back-to-indentation)
  471.             (if (looking-at comment-start-skip)
  472.             0
  473.               (current-column)))))
  474.     (save-excursion
  475.       (indent-to (if (eq this-command 'newline-and-indent)
  476.              previous
  477.            (if (< (current-column)
  478.               (progn (back-to-indentation)
  479.                  (current-column)))
  480.                (if (eolp) previous 0)
  481.              (if (eolp)
  482.              (max previous (* (1+ (/ (current-column) tab-width))
  483.                       tab-width))
  484.                (* (1+ (/ (current-column) tab-width)) tab-width))))))
  485.       (if (< (current-column) (current-indentation))
  486.       (skip-chars-forward " \t"))))
  487.  
  488.  
  489. (defun sh-remember-variable (var)
  490.   "Make VARIABLE available for future completing reads in this buffer."
  491.   (or (< (length var) sh-remember-variable-min)
  492.       (assoc var sh-variables)
  493.       (setq sh-variables (cons (list var) sh-variables)))
  494.   var)
  495.  
  496.  
  497. ;; Augment the standard variables by those found in the environment.
  498. (if (boundp 'process-environment)(let ((l process-environment))
  499.   (while l
  500.     (sh-remember-variable (substring (car l)
  501.                      0 (string-match "=" (car l))))
  502.     (setq l (cdr l)))))
  503.  
  504.  
  505.  
  506. (defun sh-quoted-p ()
  507.   "Is point preceded by an odd number of backslashes?"
  508.   (eq 1 (% (- (point) (save-excursion
  509.             (skip-chars-backward "\\\\")
  510.             (point)))
  511.        2)))
  512.  
  513.  
  514.  
  515. (defun sh-executable (command)
  516.   "If COMMAND is an executable in $PATH its full name is returned.  Else nil."
  517.   (let ((point (point))
  518.     (buffer-modified-p (buffer-modified-p))
  519.     buffer-read-only after-change-function)
  520.     (call-process "sh" nil t nil "-c" (concat "type " command))
  521.     (setq point (prog1 (point)
  522.           (goto-char point)))
  523.     (prog1
  524.     (and (looking-at sh-executable)
  525.          (eq point (match-end 0))
  526.          (buffer-substring (match-beginning 1) (match-end 1)))
  527.       (delete-region (point) point)
  528.       (set-buffer-modified-p buffer-modified-p))))
  529.  
  530.  
  531.  
  532. (defun sh-chmod ()
  533.   "This gets called after saving a file to assure that it be executable.
  534. You can set the absolute or relative mode with `sh-chmod-argument'."
  535.   (if sh-chmod-argument
  536.        (or (file-executable-p buffer-file-name)
  537.        (shell-command (concat "chmod " sh-chmod-argument
  538.                   " " buffer-file-name)))))
  539.  
  540. ;; statement syntax-commands for various shells
  541.  
  542. ;; You are welcome to add the syntax or even completely new statements as
  543. ;; appropriate for your favorite shell.
  544.  
  545. (define-sh-skeleton sh-case
  546.   "Insert a case/switch statement in the current shell's syntax."
  547.   (sh "expression: "
  548.       "case " str " in" \n
  549.       > (read-string "pattern: ") ?\) \n
  550.       > _ \n
  551.       ";;" \n
  552.       ( "other pattern, %s: "
  553.     < str ?\) \n
  554.     > \n
  555.     ";;" \n)
  556.       < "*)" \n
  557.       > \n
  558.       resume:
  559.       < < "esac")
  560.   (ksh . sh)
  561.   (bash . sh)
  562.   (csh "expression: "
  563.        "switch( " str " )" \n
  564.        > "case " (read-string "pattern: ") ?: \n
  565.        > _ \n
  566.        "breaksw" \n
  567.        ( "other pattern, %s: "
  568.      < "case " str ?: \n
  569.      > \n
  570.      "breaksw" \n)
  571.        < "default:" \n
  572.        > \n
  573.        resume:
  574.        < < "endsw")
  575.   (tcsh . csh))
  576.  
  577.  
  578.  
  579. (define-sh-skeleton sh-for
  580.   "Insert a for loop in the current shell's syntax."
  581.   (sh "Index variable: "
  582.       "for " str " in " _ "; do" \n
  583.       > ?$ (sh-remember-variable str) \n
  584.       < "done")
  585.   (ksh . sh)
  586.   (bash . sh)
  587.   (csh "Index variable: "
  588.        "foreach " str " ( " _ " )" \n
  589.        > ?$ (sh-remember-variable str) \n
  590.        < "end")
  591.   (tcsh . csh))
  592.  
  593.  
  594.  
  595. (define-sh-skeleton sh-indexed-loop
  596.   "Insert an indexed loop from 1 to n in the current shell's syntax."
  597.   (sh "Index variable: "
  598.       str "=1" \n
  599.       "while [ $" str " -le "
  600.       (read-string "upper limit: ")
  601.       " ]; do" \n
  602.       > _ ?$ str \n
  603.       str ?= (sh-add (sh-remember-variable str) 1) \n
  604.       < "done")
  605.   (ksh . sh)
  606.   (bash . sh)
  607.   (csh "Index variable: "
  608.        "@ " str " = 1" \n
  609.        "while( $" str " <= "
  610.        (read-string "upper limit: ")
  611.        " )" \n
  612.        > _ ?$ (sh-remember-variable str) \n
  613.        "@ " str "++" \n
  614.        < "end")
  615.   (tcsh . csh))
  616.  
  617.  
  618.  
  619. (defun sh-add (var delta)
  620.   "Insert an addition of VAR and prefix DELTA for Bourne type shells."
  621.   (interactive
  622.    (list (sh-remember-variable
  623.       (completing-read "Variable: " sh-variables
  624.                (lambda (element)
  625.                  (or (not (cdr element))
  626.                  (memq sh-shell (cdr element))))))
  627.      (prefix-numeric-value current-prefix-arg)))
  628.   (setq delta (concat (if (< delta 0) " - " " + ")
  629.               (abs delta)))
  630.   (skeleton-insert
  631.    (assq sh-shell
  632.      '((sh "`expr $" var delta "`")
  633.        (ksh "$(( $" var delta " ))")
  634.        (bash "$[ $" var delta " ]")))
  635.    t))
  636.  
  637.  
  638.  
  639. (define-sh-skeleton sh-function
  640.   "Insert a function definition in the current shell's syntax."
  641.   (sh ()
  642.       "() {" \n
  643.       > _ \n
  644.       < "}")
  645.   (ksh "name: "
  646.        "function " str " {" \n
  647.        > _ \n
  648.        < "}")
  649.   (bash "name: "
  650.        "function " str "() {" \n
  651.        > _ \n
  652.        < "}"))
  653.  
  654.  
  655.  
  656. (define-sh-skeleton sh-if
  657.   "Insert an if statement in the current shell's syntax."
  658.   (sh "condition: "
  659.       "if [ " str " ]; then" \n
  660.       > _ \n
  661.       ( "other condition, %s: "
  662.     < "elif [ " str " ]; then" \n
  663.     > \n)
  664.       < "else" \n
  665.       > \n
  666.       resume:
  667.       < "fi")
  668.   (ksh . sh)
  669.   (bash . sh)
  670.   (csh "condition: "
  671.        "if( " str " ) then" \n
  672.        > _ \n
  673.        ( "other condition, %s: "
  674.      < "else if ( " str " ) then" \n
  675.      > \n)
  676.        < "else" \n
  677.        > \n
  678.        resume:
  679.        < "endif")
  680.   (tcsh . csh))
  681.  
  682.  
  683.  
  684. (define-sh-skeleton sh-select
  685.   "Insert a select statement in the current shell's syntax."
  686.   (ksh "Index variable: "
  687.        "select " str " in " _ "; do" \n
  688.        > ?$ str \n
  689.        < "done"))
  690. (put 'sh-select 'menu-enable '(get 'sh-select sh-shell))
  691.  
  692.  
  693.  
  694. (define-sh-skeleton sh-until
  695.   "Insert an until loop in the current shell's syntax."
  696.   (sh "condition: "
  697.       "until [ " str " ]; do" \n
  698.       > _ \n
  699.       < "done")
  700.   (ksh . sh)
  701.   (bash . sh))
  702. (put 'sh-until 'menu-enable '(get 'sh-until sh-shell))
  703.  
  704.  
  705. (define-sh-skeleton sh-while
  706.   "Insert a while loop in the current shell's syntax."
  707.   (sh "condition: "
  708.       "while [ " str " ]; do" \n
  709.       > _ \n
  710.       < "done")
  711.   (ksh . sh)
  712.   (bash . sh)
  713.   (csh "condition: "
  714.        "while( " str " )" \n
  715.        > _ \n
  716.        < "end")
  717.   (tcsh . csh))
  718.  
  719.  
  720.  
  721. (defun sh-query-for-variable (arg)
  722.   "Unless quoted with `\\', query for variable-name with completions.
  723. Prefix arg 0 means don't insert `$' before the variable.
  724. Prefix arg 2 or more means only do self-insert that many times.
  725.   If { is pressed as the first character, it will surround the variable name."
  726.   (interactive "*p")
  727.   (or (prog1 (or (> arg 1)
  728.          (sh-quoted-p))
  729.     (self-insert-command arg))
  730.     (let (completion-ignore-case
  731.       (minibuffer-local-completion-map
  732.        (or (get 'sh-query-for-variable 'keymap)
  733.            (put 'sh-query-for-variable 'keymap
  734.             (copy-keymap minibuffer-local-completion-map))))
  735.       (buffer (current-buffer)))
  736.       ;; local function that depends on `arg' and `buffer'
  737.       (define-key minibuffer-local-completion-map "{"
  738.     (lambda () (interactive)
  739.       (if (or arg (> (point) 1))
  740.           (beep)
  741.         (save-window-excursion
  742.           (setq arg t)
  743.           (switch-to-buffer-other-window buffer)
  744.           (insert "{}")))))
  745.       (insert
  746.        (prog1
  747.        (sh-remember-variable
  748.         (completing-read "Variable: " sh-variables
  749.                  (lambda (element)
  750.                    (or (not (cdr element))
  751.                    (memq sh-shell (cdr element))))))
  752.      (if (eq t arg) (forward-char 1))))
  753.       (if (eq t arg) (forward-char 1)))))
  754.  
  755.  
  756.  
  757. (defun sh-assignment (arg)
  758.   "Insert self.  Remember previous identifier for future completing read."
  759.   (interactive "p")
  760.   (if (eq arg 1)
  761.       (sh-remember-variable
  762.        (save-excursion
  763.      (buffer-substring
  764.       (progn
  765.         (if (memq sh-shell sh-assignment-space)
  766.         (skip-chars-backward " \t"))
  767.         (point))
  768.       (progn
  769.         (skip-chars-backward "a-zA-Z0-9_")
  770.         (point))))))
  771.   (self-insert-command arg))
  772.  
  773.  
  774.  
  775. (defun sh-maybe-here-document (arg)
  776.   "Inserts self.  Without prefix, following unquoted `<' inserts here document.
  777. The document is bounded by `sh-here-document-word'."
  778.   (interactive "*P")
  779.   (self-insert-command (prefix-numeric-value arg))
  780.   (or arg
  781.       (not (eq (char-after (- (point) 2)) last-command-char))
  782.       (save-excursion
  783.     (goto-char (- (point) 2))
  784.     (sh-quoted-p))
  785.       (progn
  786.     (insert sh-here-document-word)
  787.     (or (looking-at "[ \t\n]") (insert ? ))
  788.     (end-of-line 1)
  789.     (newline)
  790.     (save-excursion (insert ?\n sh-here-document-word)))))
  791.  
  792.  
  793. ;; various other commands
  794.  
  795. (autoload 'comint-dynamic-complete-filename "comint"
  796.   "Dynamically complete the filename at point." t)
  797.  
  798.  
  799.  
  800. (defun sh-newline-and-indent (&optional arg)
  801.   "Strip unquoted whitespace, insert newline, and indent like current line.
  802. Unquoted whitespace is stripped from the current line's end, unless a
  803. prefix ARG is given."
  804.   (interactive "*P")
  805.   (let ((previous (current-indentation))
  806.     (end-of-line (point)))
  807.     (if arg ()
  808.       (skip-chars-backward " \t") 
  809.       (and (< (point) end-of-line)
  810.        (sh-quoted-p)
  811.        (forward-char 1))
  812.       (delete-region (point) end-of-line))
  813.     (newline)
  814.     (indent-to previous)))
  815.  
  816.  
  817.  
  818. (defun sh-set-shell (shell)
  819.   "Set this buffer's shell to SHELL (a string).
  820. Calls the value of `sh-set-shell-hook' if set."
  821.   (interactive "sName or path of shell: ")
  822.   (save-excursion
  823.     (goto-char (point-min))
  824.     (setq sh-shell-path (if (file-name-absolute-p shell)
  825.                       shell
  826.                     (or (sh-executable shell)
  827.                     (error "Cannot find %s." shell)))
  828.       sh-shell (intern (file-name-nondirectory sh-shell-path))
  829.       sh-shell-is-csh (memq sh-shell '(csh tcsh))
  830.       font-lock-keywords
  831.       (intern-soft (format "sh-%s-font-lock-keywords" sh-shell))
  832.       font-lock-keywords (if (and font-lock-keywords
  833.                       (boundp font-lock-keywords))
  834.                  (symbol-value font-lock-keywords)
  835.                    sh-font-lock-keywords)
  836.       comment-start-skip (if sh-shell-is-csh
  837.                  "\\(^\\|[^$]\\|\\$[^{]\\)#+[\t ]*"
  838.                    "\\(^\\|[^$]\\|\\$[^{]\\)\\B#+[\t ]*")
  839.       mode-line-process (format ": %s" sh-shell)
  840.       shell (concat sh-shell-path
  841.             (and sh-shell-argument " ")
  842.             sh-shell-argument))
  843.     (and (not buffer-read-only)
  844.      (not (if buffer-file-name
  845.           (string-match sh-magicless-file-regexp buffer-file-name)))
  846.      ;; find-file is set by `normal-mode' when called by `after-find-file'
  847.      (if (and (boundp 'find-file) find-file) sh-find-file-modifies t)
  848.      (if (looking-at "#!")
  849.          (and (skip-chars-forward "#! \t")
  850.           (not (string= shell
  851.                 (buffer-substring (point)
  852.                           (save-excursion (end-of-line)
  853.                                   (point)))))
  854.           (if sh-query-for-magic
  855.               (y-or-n-p (concat "Replace magic number by ``#! "
  856.                     shell "''? "))
  857.             (message "Magic number ``%s'' replaced."
  858.                  (buffer-substring (point-min) (point))))
  859.           (not (delete-region (point) (progn (end-of-line) (point))))
  860.           (insert shell))
  861.        (if (if sh-query-for-magic
  862.            (y-or-n-p (concat "Add ``#! " shell "''? "))
  863.          t)
  864.            (insert "#! " shell ?\n)))))
  865.   (run-hooks 'sh-set-shell-hook))
  866.  
  867.  
  868.  
  869. (defun sh-beginning-of-command ()
  870.   "Move point to successive beginnings of commands."
  871.   (interactive)
  872.   (if (re-search-backward sh-beginning-of-command nil t)
  873.       (goto-char (match-beginning 2))))
  874.  
  875.  
  876.  
  877. (defun sh-end-of-command ()
  878.   "Move point to successive ends of commands."
  879.   (interactive)
  880.   (if (re-search-forward sh-end-of-command nil t)
  881.       (goto-char (match-end 1))))
  882.  
  883.  
  884.  
  885. (defun sh-manual-entry (arg)
  886.   "Display the Unix manual entry for the current command or shell.
  887. Universal argument ARG, is passed to `Man-getpage-in-background'."
  888.   (interactive "P")
  889.   (let ((command (save-excursion
  890.            (sh-beginning-of-command)
  891.            (sh-executable
  892.             (buffer-substring (point)
  893.                       (progn (forward-sexp) (point)))))))
  894.     (setq command (read-input (concat "Manual entry (default "
  895.                       (symbol-name sh-shell)
  896.                       "): ")
  897.                   (if command
  898.                   (file-name-nondirectory command))))
  899.     (manual-entry (if (string= command "")
  900.               (symbol-name sh-shell)
  901.             command)
  902.           arg)))
  903.  
  904. ;; sh-script.el ends here
  905.