lisp/progmodes/sh-script.el

   1 ;;; sh-script.el --- shell-script editing commands for Emacs
   2
   3 ;; Copyright (C) 1993, 1994, 1995, 1996 by Free Software Foundation, Inc.
   4
   5 ;; Author: Daniel.Pfeiffer@Informatik.START.dbp.de, fax (+49 69) 7588-2389
   6 ;; Version: 2.0e
   7 ;; Maintainer: FSF
   8 ;; Keywords: languages, unix
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software; you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 2, or (at your option)
  15 ;; any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  25 ;; Boston, MA 02111-1307, USA.
  26
  27 ;;; Commentary:
  28
  29 ;; Major mode for editing shell scripts.  Bourne, C and rc shells as well
  30 ;; as various derivatives are supported and easily derived from.  Structured
  31 ;; statements can be inserted with one command or abbrev.  Completion is
  32 ;; available for filenames, variables known from the script, the shell and
  33 ;; the environment as well as commands.
  34
  35 ;;; Known Bugs:
  36
  37 ;; - In Bourne the keyword `in' is not anchored to case, for, select ...
  38 ;; - Variables in `"' strings aren't fontified because there's no way of
  39 ;;   syntactically distinguishing those from `'' strings.
  40
  41 ;;; Code:
  42
  43 ;; page 1:      variables and settings
  44 ;; page 2:      mode-command and utility functions
  45 ;; page 3:      statement syntax-commands for various shells
  46 ;; page 4:      various other commands
  47
  48 (require 'executable)
  49
  50 (defvar sh-mode-hook nil
  51   "*Hook run by `sh-mode'.")
  52
  53 (defvar sh-set-shell-hook nil
  54   "*Hook run by `sh-set-shell'.")
  55
  56 (defvar sh-ancestor-alist
  57   '((ash . sh)
  58     (bash . jsh)
  59     (dtksh . ksh)
  60     (es . rc)
  61     (itcsh . tcsh)
  62     (jcsh . csh)
  63     (jsh . sh)
  64     (ksh . ksh88)
  65     (ksh88 . jsh)
  66     (oash . sh)
  67     (pdksh . ksh88)
  68     (posix . sh)
  69     (tcsh . csh)
  70     (wksh . ksh88)
  71     (wsh . sh)
  72     (zsh . ksh88))
  73   "*Alist showing the direct ancestor of various shells.
  74 This is the basis for `sh-feature'.  See also `sh-alias-alist'.
  75 By default we have the following three hierarchies:
  76
  77 csh             C Shell
  78   jcsh          C Shell with Job Control
  79   tcsh          Toronto C Shell
  80     itcsh       ? Toronto C Shell
  81 rc              Plan 9 Shell
  82   es            Extensible Shell
  83 sh              Bourne Shell
  84   ash           ? Shell
  85   jsh           Bourne Shell with Job Control
  86     bash        GNU Bourne Again Shell
  87     ksh88       Korn Shell '88
  88       ksh       Korn Shell '93
  89         dtksh   CDE Desktop Korn Shell
  90       pdksh     Public Domain Korn Shell
  91       wksh      Window Korn Shell
  92       zsh       Z Shell
  93   oash          SCO OA (curses) Shell
  94   posix         IEEE 1003.2 Shell Standard
  95   wsh           ? Shell")
  96
  97
  98 (defvar sh-alias-alist
  99   (nconc (if (eq system-type 'gnu/linux)
 100              '((csh . tcsh)
 101                (ksh . pdksh)))
 102          ;; for the time being
 103          '((ksh . ksh88)
 104            (sh5 . sh)))
 105   "*Alist for transforming shell names to what they really are.
 106 Use this where the name of the executable doesn't correspond to the type of
 107 shell it really is.")
 108
 109
 110 (defvar sh-shell-file
 111   (or
 112    ;; On MSDOS and Windows, collapse $SHELL to lower-case and remove
 113    ;; the executable extension, so comparisons with the list of
 114    ;; known shells work.
 115    (and (memq system-type '(ms-dos windows-nt))
 116         (file-name-sans-extension (downcase (getenv "SHELL"))))
 117    (getenv "SHELL")
 118    "/bin/sh")
 119   "*The executable file name for the shell being programmed.")
 120
 121
 122 (defvar sh-shell-arg
 123   ;; bash does not need any options when run in a shell script,
 124   '((bash)
 125     (csh . "-f")
 126     (pdksh)
 127     ;; Bill_Mann@praxisint.com says -p with ksh can do harm.
 128     (ksh88)
 129     ;; -p means don't initialize functions from the environment.
 130     (rc . "-p")
 131     ;; Someone proposed -motif, but we don't want to encourage
 132     ;; use of a non-free widget set.
 133     (wksh)
 134     ;; -f means don't run .zshrc.
 135     (zsh . "-f"))
 136   "*Single argument string for the magic number.  See `sh-feature'.")
 137
 138 (defvar sh-shell-variables nil
 139   "Alist of shell variable names that should be included in completion.
 140 These are used for completion in addition to all the variables named
 141 in `process-environment'.  Each element looks like (VAR . VAR), where
 142 the car and cdr are the same symbol.")
 143
 144 (defvar sh-shell-variables-initialized nil
 145   "Non-nil if `sh-shell-variables' is initialized.")
 146
 147 (defun sh-canonicalize-shell (shell)
 148   "Convert a shell name SHELL to the one we should handle it as."
 149   (or (symbolp shell)
 150       (setq shell (intern shell)))
 151   (or (cdr (assq shell sh-alias-alist))
 152       shell))
 153
 154 (defvar sh-shell (sh-canonicalize-shell (file-name-nondirectory sh-shell-file))
 155   "The shell being programmed.  This is set by \\[sh-set-shell].")
 156
 157 ;;; I turned off this feature because it doesn't permit typing commands
 158 ;;; in the usual way without help.
 159 ;;;(defvar sh-abbrevs
 160 ;;;  '((csh eval sh-abbrevs shell
 161 ;;;      "switch" 'sh-case
 162 ;;;      "getopts" 'sh-while-getopts)
 163
 164 ;;;    (es eval sh-abbrevs shell
 165 ;;;     "function" 'sh-function)
 166
 167 ;;;    (ksh88 eval sh-abbrevs sh
 168 ;;;        "select" 'sh-select)
 169
 170 ;;;    (rc eval sh-abbrevs shell
 171 ;;;     "case" 'sh-case
 172 ;;;     "function" 'sh-function)
 173
 174 ;;;    (sh eval sh-abbrevs shell
 175 ;;;     "case" 'sh-case
 176 ;;;     "function" 'sh-function
 177 ;;;     "until" 'sh-until
 178 ;;;     "getopts" 'sh-while-getopts)
 179
 180 ;;;    ;; The next entry is only used for defining the others
 181 ;;;    (shell "for" sh-for
 182 ;;;        "loop" sh-indexed-loop
 183 ;;;        "if" sh-if
 184 ;;;        "tmpfile" sh-tmp-file
 185 ;;;        "while" sh-while)
 186
 187 ;;;    (zsh eval sh-abbrevs ksh88
 188 ;;;      "repeat" 'sh-repeat))
 189 ;;;  "Abbrev-table used in Shell-Script mode.  See `sh-feature'.
 190 ;;;Due to the internal workings of abbrev tables, the shell name symbol is
 191 ;;;actually defined as the table for the like of \\[edit-abbrevs].")
 192
 193
 194
 195 (defvar sh-mode-syntax-table
 196   '((sh eval sh-mode-syntax-table ()
 197         ?\# "<"
 198         ?\^l ">#"
 199         ?\n ">#"
 200         ?\" "\"\""
 201         ?\' "\"'"
 202         ?\` "\"`"
 203         ?$ "\\"                     ; `escape' so $# doesn't start a comment
 204         ?! "_"
 205         ?% "_"
 206         ?: "_"
 207         ?. "_"
 208         ?^ "_"
 209         ?~ "_")
 210     (csh eval identity sh)
 211     (rc eval identity sh))
 212   "Syntax-table used in Shell-Script mode.  See `sh-feature'.")
 213
 214
 215
 216 (defvar sh-mode-map
 217   (let ((map (make-sparse-keymap))
 218         (menu-map (make-sparse-keymap "Insert")))
 219     (define-key map "\C-c(" 'sh-function)
 220     (define-key map "\C-c\C-w" 'sh-while)
 221     (define-key map "\C-c\C-u" 'sh-until)
 222     (define-key map "\C-c\C-t" 'sh-tmp-file)
 223     (define-key map "\C-c\C-s" 'sh-select)
 224     (define-key map "\C-c\C-r" 'sh-repeat)
 225     (define-key map "\C-c\C-o" 'sh-while-getopts)
 226     (define-key map "\C-c\C-l" 'sh-indexed-loop)
 227     (define-key map "\C-c\C-i" 'sh-if)
 228     (define-key map "\C-c\C-f" 'sh-for)
 229     (define-key map "\C-c\C-c" 'sh-case)
 230
 231     (define-key map "=" 'sh-assignment)
 232     (define-key map "\C-c+" 'sh-add)
 233     (define-key map "\C-\M-x" 'sh-execute-region)
 234     (define-key map "\C-c\C-x" 'executable-interpret)
 235     (define-key map "<" 'sh-maybe-here-document)
 236     (define-key map "(" 'skeleton-pair-insert-maybe)
 237     (define-key map "{" 'skeleton-pair-insert-maybe)
 238     (define-key map "[" 'skeleton-pair-insert-maybe)
 239     (define-key map "'" 'skeleton-pair-insert-maybe)
 240     (define-key map "`" 'skeleton-pair-insert-maybe)
 241     (define-key map "\"" 'skeleton-pair-insert-maybe)
 242
 243     (define-key map "\t" 'sh-indent-line)
 244     (substitute-key-definition 'complete-tag 'comint-dynamic-complete
 245                                map (current-global-map))
 246     (substitute-key-definition 'newline-and-indent 'sh-newline-and-indent
 247                                map (current-global-map))
 248     (substitute-key-definition 'delete-backward-char
 249                                'backward-delete-char-untabify
 250                                map (current-global-map))
 251     (define-key map "\C-c:" 'sh-set-shell)
 252     (substitute-key-definition 'beginning-of-defun
 253                                'sh-beginning-of-compound-command
 254                                map (current-global-map))
 255     (substitute-key-definition 'backward-sentence 'sh-beginning-of-command
 256                                map (current-global-map))
 257     (substitute-key-definition 'forward-sentence 'sh-end-of-command
 258                                map (current-global-map))
 259     (define-key map [menu-bar insert] (cons "Insert" menu-map))
 260     (define-key menu-map [sh-while]     '("While Loop" . sh-while))
 261     (define-key menu-map [sh-until]     '("Until Loop" . sh-until))
 262     (define-key menu-map [sh-tmp-file]  '("Temporary File" . sh-tmp-file))
 263     (define-key menu-map [sh-select]    '("Select Statement" . sh-select))
 264     (define-key menu-map [sh-repeat]    '("Repeat Loop" . sh-repeat))
 265     (define-key menu-map [sh-while-getopts]
 266                                         '("Options Loop" . sh-while-getopts))
 267     (define-key menu-map [sh-indexed-loop]
 268                                         '("Indexed Loop" . sh-indexed-loop))
 269     (define-key menu-map [sh-if]        '("If Statement" . sh-if))
 270     (define-key menu-map [sh-for]       '("For Loop" . sh-for))
 271     (define-key menu-map [sh-case]      '("Case Statement" . sh-case))
 272     map)
 273   "Keymap used in Shell-Script mode.")
 274
 275
 276
 277 (defvar sh-dynamic-complete-functions
 278   '(shell-dynamic-complete-environment-variable
 279     shell-dynamic-complete-command
 280     comint-dynamic-complete-filename)
 281   "*Functions for doing TAB dynamic completion.")
 282
 283
 284 (defvar sh-require-final-newline
 285   '((csh . t)
 286     (pdksh . t)
 287     (rc eval . require-final-newline)
 288     (sh eval . require-final-newline))
 289   "*Value of `require-final-newline' in Shell-Script mode buffers.
 290 See `sh-feature'.")
 291
 292
 293 (defvar sh-assignment-regexp
 294   '((csh . "\\<\\([a-zA-Z0-9_]+\\)\\(\\[.+\\]\\)?[ \t]*[-+*/%^]?=")
 295     ;; actually spaces are only supported in let/(( ... ))
 296     (ksh88 . "\\<\\([a-zA-Z0-9_]+\\)\\(\\[.+\\]\\)?[ \t]*\\([-+*/%&|~^]\\|<<\\|>>\\)?=")
 297     (rc . "\\<\\([a-zA-Z0-9_*]+\\)[ \t]*=")
 298     (sh . "\\<\\([a-zA-Z0-9_]+\\)="))
 299   "*Regexp for the variable name and what may follow in an assignment.
 300 First grouping matches the variable name.  This is upto and including the `='
 301 sign.  See `sh-feature'.")
 302
 303
 304 (defvar sh-indentation 4
 305   "The width for further indentation in Shell-Script mode.")
 306
 307
 308 (defvar sh-remember-variable-min 3
 309   "*Don't remember variables less than this length for completing reads.")
 310
 311
 312 (defvar sh-header-marker nil
 313   "When non-`nil' is the end of header for prepending by \\[sh-execute-region].
 314 That command is also used for setting this variable.")
 315
 316
 317 (defvar sh-beginning-of-command
 318   "\\([;({`|&]\\|\\`\\|[^\\]\n\\)[ \t]*\\([/~a-zA-Z0-9:]\\)"
 319   "*Regexp to determine the beginning of a shell command.
 320 The actual command starts at the beginning of the second \\(grouping\\).")
 321
 322
 323 (defvar sh-end-of-command
 324   "\\([/~a-zA-Z0-9:]\\)[ \t]*\\([;#)}`|&]\\|$\\)"
 325   "*Regexp to determine the end of a shell command.
 326 The actual command ends at the end of the first \\(grouping\\).")
 327
 328
 329
 330 (defvar sh-here-document-word "EOF"
 331   "Word to delimit here documents.")
 332
 333 (defvar sh-test
 334   '((sh "[  ]" . 3)
 335     (ksh88 "[[  ]]" . 4))
 336   "Initial input in Bourne if, while and until skeletons.  See `sh-feature'.")
 337
 338
 339 (defvar sh-builtins
 340   '((bash eval sh-append posix
 341           "alias" "bg" "bind" "builtin" "declare" "dirs" "enable" "fc" "fg"
 342           "help" "history" "jobs" "kill" "let" "local" "popd" "pushd" "source"
 343           "suspend" "typeset" "unalias")
 344
 345     ;; The next entry is only used for defining the others
 346     (bourne eval sh-append shell
 347             "eval" "export" "getopts" "newgrp" "pwd" "read" "readonly"
 348             "times" "ulimit")
 349
 350     (csh eval sh-append shell
 351          "alias" "chdir" "glob" "history" "limit" "nice" "nohup" "rehash"
 352          "setenv" "source" "time" "unalias" "unhash")
 353
 354     (dtksh eval identity wksh)
 355
 356     (es "access" "apids" "cd" "echo" "eval" "false" "let" "limit" "local"
 357         "newpgrp" "result" "time" "umask" "var" "vars" "wait" "whatis")
 358
 359     (jsh eval sh-append sh
 360          "bg" "fg" "jobs" "kill" "stop" "suspend")
 361
 362     (jcsh eval sh-append csh
 363          "bg" "fg" "jobs" "kill" "notify" "stop" "suspend")
 364
 365     (ksh88 eval sh-append bourne
 366            "alias" "bg" "false" "fc" "fg" "jobs" "kill" "let" "print" "time"
 367            "typeset" "unalias" "whence")
 368
 369     (oash eval sh-append sh
 370           "checkwin" "dateline" "error" "form" "menu" "newwin" "oadeinit"
 371           "oaed" "oahelp" "oainit" "pp" "ppfile" "scan" "scrollok" "wattr"
 372           "wclear" "werase" "win" "wmclose" "wmmessage" "wmopen" "wmove"
 373           "wmtitle" "wrefresh")
 374
 375     (pdksh eval sh-append ksh88
 376            "bind")
 377
 378     (posix eval sh-append sh
 379            "command")
 380
 381     (rc "builtin" "cd" "echo" "eval" "limit" "newpgrp" "shift" "umask" "wait"
 382         "whatis")
 383
 384     (sh eval sh-append bourne
 385         "hash" "test" "type")
 386
 387     ;; The next entry is only used for defining the others
 388     (shell "cd" "echo" "eval" "set" "shift" "umask" "unset" "wait")
 389
 390     (wksh eval sh-append ksh88
 391           "Xt[A-Z][A-Za-z]*")
 392
 393     (zsh eval sh-append ksh88
 394          "autoload" "bindkey" "builtin" "chdir" "compctl" "declare" "dirs"
 395          "disable" "disown" "echotc" "enable" "functions" "getln" "hash"
 396          "history" "integer" "limit" "local" "log" "popd" "pushd" "r"
 397          "readonly" "rehash" "sched" "setopt" "source" "suspend" "true"
 398          "ttyctl" "type" "unfunction" "unhash" "unlimit" "unsetopt" "vared"
 399          "which"))
 400   "*List of all shell builtins for completing read and fontification.
 401 Note that on some systems not all builtins are available or some are
 402 implemented as aliases.  See `sh-feature'.")
 403
 404
 405
 406 (defvar sh-leading-keywords
 407   '((csh "else")
 408
 409     (es "true" "unwind-protect" "whatis")
 410
 411     (rc "else")
 412
 413     (sh "do" "elif" "else" "if" "then" "trap" "type" "until" "while"))
 414   "*List of keywords that may be immediately followed by a builtin or keyword.
 415 Given some confusion between keywords and builtins depending on shell and
 416 system, the distinction here has been based on whether they influence the
 417 flow of control or syntax.  See `sh-feature'.")
 418
 419
 420 (defvar sh-other-keywords
 421   '((bash eval sh-append bourne
 422           "bye" "logout")
 423
 424     ;; The next entry is only used for defining the others
 425     (bourne eval sh-append sh
 426             "function")
 427
 428     (csh eval sh-append shell
 429          "breaksw" "default" "end" "endif" "endsw" "foreach" "goto"
 430          "if" "logout" "onintr" "repeat" "switch" "then" "while")
 431
 432     (es "break" "catch" "exec" "exit" "fn" "for" "forever" "fork" "if"
 433         "return" "throw" "while")
 434
 435     (ksh88 eval sh-append bourne
 436            "select")
 437
 438     (rc "break" "case" "exec" "exit" "fn" "for" "if" "in" "return" "switch"
 439         "while")
 440
 441     (sh eval sh-append shell
 442         "done" "esac" "fi" "for" "in" "return")
 443
 444     ;; The next entry is only used for defining the others
 445     (shell "break" "case" "continue" "exec" "exit")
 446
 447     (zsh eval sh-append bash
 448          "select"))
 449   "*List of keywords not in `sh-leading-keywords'.
 450 See `sh-feature'.")
 451
 452
 453
 454 (defvar sh-variables
 455   '((bash eval sh-append sh
 456           "allow_null_glob_expansion" "auto_resume" "BASH" "BASH_VERSION"
 457           "cdable_vars" "ENV" "EUID" "FCEDIT" "FIGNORE" "glob_dot_filenames"
 458           "histchars" "HISTFILE" "HISTFILESIZE" "history_control" "HISTSIZE"
 459           "hostname_completion_file" "HOSTTYPE" "IGNOREEOF" "ignoreeof"
 460           "LINENO" "MAIL_WARNING" "noclobber" "nolinks" "notify"
 461           "no_exit_on_failed_exec" "NO_PROMPT_VARS" "OLDPWD" "OPTERR" "PPID"
 462           "PROMPT_COMMAND" "PS4" "pushd_silent" "PWD" "RANDOM" "REPLY"
 463           "SECONDS" "SHLVL" "TMOUT" "UID")
 464
 465     (csh eval sh-append shell
 466          "argv" "cdpath" "child" "echo" "histchars" "history" "home"
 467          "ignoreeof" "mail" "noclobber" "noglob" "nonomatch" "path" "prompt"
 468          "shell" "status" "time" "verbose")
 469
 470     (es eval sh-append shell
 471         "apid" "cdpath" "CDPATH" "history" "home" "ifs" "noexport" "path"
 472         "pid" "prompt" "signals")
 473
 474     (jcsh eval sh-append csh
 475          "notify")
 476
 477     (ksh88 eval sh-append sh
 478            "ENV" "ERRNO" "FCEDIT" "FPATH" "HISTFILE" "HISTSIZE" "LINENO"
 479            "OLDPWD" "PPID" "PS3" "PS4" "PWD" "RANDOM" "REPLY" "SECONDS"
 480            "TMOUT")
 481
 482     (oash eval sh-append sh
 483           "FIELD" "FIELD_MAX" "LAST_KEY" "OALIB" "PP_ITEM" "PP_NUM")
 484
 485     (rc eval sh-append shell
 486         "apid" "apids" "cdpath" "CDPATH" "history" "home" "ifs" "path" "pid"
 487         "prompt" "status")
 488
 489     (sh eval sh-append shell
 490         "CDPATH" "IFS" "OPTARG" "OPTIND" "PS1" "PS2")
 491
 492     ;; The next entry is only used for defining the others
 493     (shell "COLUMNS" "EDITOR" "HOME" "HUSHLOGIN" "LANG" "LC_COLLATE"
 494            "LC_CTYPE" "LC_MESSAGES" "LC_MONETARY" "LC_NUMERIC" "LC_TIME"
 495            "LINES" "LOGNAME" "MAIL" "MAILCHECK" "MAILPATH" "PAGER" "PATH"
 496            "SHELL" "TERM" "TERMCAP" "TERMINFO" "VISUAL")
 497
 498     (tcsh eval sh-append csh
 499           "addsuffix" "ampm" "autocorrect" "autoexpand" "autolist"
 500           "autologout" "chase_symlinks" "correct" "dextract" "edit" "el"
 501           "fignore" "gid" "histlit" "HOST" "HOSTTYPE" "HPATH"
 502           "ignore_symlinks" "listjobs" "listlinks" "listmax" "matchbeep"
 503           "nobeep" "NOREBIND" "oid" "printexitvalue" "prompt2" "prompt3"
 504           "pushdsilent" "pushdtohome" "recexact" "recognize_only_executables"
 505           "rmstar" "savehist" "SHLVL" "showdots" "sl" "SYSTYPE" "tcsh" "term"
 506           "tperiod" "tty" "uid" "version" "visiblebell" "watch" "who"
 507           "wordchars")
 508
 509     (zsh eval sh-append ksh88
 510          "BAUD" "bindcmds" "cdpath" "DIRSTACKSIZE" "fignore" "FIGNORE" "fpath"
 511          "HISTCHARS" "hostcmds" "hosts" "HOSTS" "LISTMAX" "LITHISTSIZE"
 512          "LOGCHECK" "mailpath" "manpath" "NULLCMD" "optcmds" "path" "POSTEDIT"
 513          "prompt" "PROMPT" "PROMPT2" "PROMPT3" "PROMPT4" "psvar" "PSVAR"
 514          "READNULLCMD" "REPORTTIME" "RPROMPT" "RPS1" "SAVEHIST" "SPROMPT"
 515          "STTY" "TIMEFMT" "TMOUT" "TMPPREFIX" "varcmds" "watch" "WATCH"
 516          "WATCHFMT" "WORDCHARS" "ZDOTDIR"))
 517   "List of all shell variables available for completing read.
 518 See `sh-feature'.")
 519
 520
 521
 522 (defvar sh-font-lock-keywords
 523   '((csh eval sh-append shell
 524          '("\\${?[#?]?\\([A-Za-z_][A-Za-z0-9_]*\\|0\\)" 1
 525            font-lock-variable-name-face))
 526
 527     (es eval sh-append executable-font-lock-keywords
 528         '("\\$#?\\([A-Za-z_][A-Za-z0-9_]*\\|[0-9]+\\)" 1
 529           font-lock-variable-name-face))
 530
 531     (rc eval identity es)
 532
 533     (sh eval sh-append shell
 534         '("\\$\\({#?\\)?\\([A-Za-z_][A-Za-z0-9_]*\\|[-#?@!]\\)" 2
 535           font-lock-variable-name-face))
 536
 537     ;; The next entry is only used for defining the others
 538     (shell eval sh-append executable-font-lock-keywords
 539            '("\\\\[^A-Za-z0-9]" 0 font-lock-string-face)
 540            '("\\${?\\([A-Za-z_][A-Za-z0-9_]*\\|[0-9]+\\|[$*_]\\)" 1
 541              font-lock-variable-name-face)))
 542   "*Rules for highlighting shell scripts.  See `sh-feature'.")
 543
 544 (defvar sh-font-lock-keywords-1
 545   '((sh "[ \t]in\\>"))
 546   "*Additional rules for highlighting shell scripts.  See `sh-feature'.")
 547
 548 (defvar sh-font-lock-keywords-2 ()
 549   "*Yet more rules for highlighting shell scripts.  See `sh-feature'.")
 550
 551 \f
 552 ;; mode-command and utility functions
 553
 554 ;;;###autoload
 555 (put 'sh-mode 'mode-class 'special)
 556
 557 ;;;###autoload
 558 (defun sh-mode ()
 559   "Major mode for editing shell scripts.
 560 This mode works for many shells, since they all have roughly the same syntax,
 561 as far as commands, arguments, variables, pipes, comments etc. are concerned.
 562 Unless the file's magic number indicates the shell, your usual shell is
 563 assumed.  Since filenames rarely give a clue, they are not further analyzed.
 564
 565 This mode adapts to the variations between shells (see `sh-set-shell') by
 566 means of an inheritance based feature lookup (see `sh-feature').  This
 567 mechanism applies to all variables (including skeletons) that pertain to
 568 shell-specific features.
 569
 570 The default style of this mode is that of Rosenblatt's Korn shell book.
 571 The syntax of the statements varies with the shell being used.  The
 572 following commands are available, based on the current shell's syntax:
 573
 574 \\[sh-case]      case statement
 575 \\[sh-for]       for loop
 576 \\[sh-function]  function definition
 577 \\[sh-if]        if statement
 578 \\[sh-indexed-loop]      indexed loop from 1 to n
 579 \\[sh-while-getopts]     while getopts loop
 580 \\[sh-repeat]    repeat loop
 581 \\[sh-select]    select loop
 582 \\[sh-until]     until loop
 583 \\[sh-while]     while loop
 584
 585 \\[backward-delete-char-untabify]        Delete backward one position, even if it was a tab.
 586 \\[sh-newline-and-indent]        Delete unquoted space and indent new line same as this one.
 587 \\[sh-end-of-command]    Go to end of successive commands.
 588 \\[sh-beginning-of-command]      Go to beginning of successive commands.
 589 \\[sh-set-shell]         Set this buffer's shell, and maybe its magic number.
 590 \\[sh-execute-region]    Have optional header and region be executed in a subshell.
 591
 592 \\[sh-maybe-here-document]       Without prefix, following an unquoted < inserts here document.
 593 {, (, [, ', \", `
 594         Unless quoted with \\, insert the pairs {}, (), [], or '', \"\", ``.
 595
 596 If you generally program a shell different from your login shell you can
 597 set `sh-shell-file' accordingly.  If your shell's file name doesn't correctly
 598 indicate what shell it is use `sh-alias-alist' to translate.
 599
 600 If your shell gives error messages with line numbers, you can use \\[executable-interpret]
 601 with your script for an edit-interpret-debug cycle."
 602   (interactive)
 603   (kill-all-local-variables)
 604   (use-local-map sh-mode-map)
 605   (make-local-variable 'indent-line-function)
 606   (make-local-variable 'indent-region-function)
 607   (make-local-variable 'skeleton-end-hook)
 608   (make-local-variable 'paragraph-start)
 609   (make-local-variable 'paragraph-separate)
 610   (make-local-variable 'comment-start)
 611   (make-local-variable 'comment-start-skip)
 612   (make-local-variable 'require-final-newline)
 613   (make-local-variable 'sh-header-marker)
 614   (make-local-variable 'sh-shell-file)
 615   (make-local-variable 'sh-shell)
 616   (make-local-variable 'skeleton-pair-alist)
 617   (make-local-variable 'skeleton-pair-filter)
 618   (make-local-variable 'comint-dynamic-complete-functions)
 619   (make-local-variable 'comint-prompt-regexp)
 620   (make-local-variable 'font-lock-defaults)
 621   (make-local-variable 'skeleton-filter)
 622   (make-local-variable 'skeleton-newline-indent-rigidly)
 623   (make-local-variable 'sh-shell-variables)
 624   (make-local-variable 'sh-shell-variables-initialized)
 625   (setq major-mode 'sh-mode
 626         mode-name "Shell-script"
 627         indent-line-function 'sh-indent-line
 628         ;; not very clever, but enables wrapping skeletons around regions
 629         indent-region-function (lambda (b e)
 630                                  (save-excursion
 631                                    (goto-char b)
 632                                    (skip-syntax-backward "-")
 633                                    (setq b (point))
 634                                    (goto-char e)
 635                                    (skip-syntax-backward "-")
 636                                    (indent-rigidly b (point) sh-indentation)))
 637         skeleton-end-hook (lambda ()
 638                             (or (eolp) (newline) (indent-relative)))
 639         paragraph-start (concat page-delimiter "\\|$")
 640         paragraph-separate paragraph-start
 641         comment-start "# "
 642         comint-dynamic-complete-functions sh-dynamic-complete-functions
 643         ;; we can't look if previous line ended with `\'
 644         comint-prompt-regexp "^[ \t]*"
 645         font-lock-defaults
 646           `((sh-font-lock-keywords
 647              sh-font-lock-keywords-1
 648              sh-font-lock-keywords-2)
 649             nil nil
 650             ((?/ . "w") (?~ . "w") (?. . "w") (?- . "w") (?_ . "w")))
 651         skeleton-pair-alist '((?` _ ?`))
 652         skeleton-pair-filter 'sh-quoted-p
 653         skeleton-further-elements '((< '(- (min sh-indentation
 654                                                 (current-column)))))
 655         skeleton-filter 'sh-feature
 656         skeleton-newline-indent-rigidly t)
 657   ;; Parse or insert magic number for exec, and set all variables depending
 658   ;; on the shell thus determined.
 659   (let ((interpreter
 660          (save-excursion
 661            (goto-char (point-min))
 662            (if (looking-at "#![ \t]?\\([^ \t\n]*/bin/env[ \t]\\)?\\([^ \t\n]+\\)")
 663                (buffer-substring (match-beginning 2)
 664                                  (match-end 2))))))
 665     (if interpreter
 666         (sh-set-shell interpreter nil nil)))
 667   (run-hooks 'sh-mode-hook))
 668 ;;;###autoload
 669 (defalias 'shell-script-mode 'sh-mode)
 670
 671
 672 (defun sh-font-lock-keywords (&optional keywords)
 673   "Function to get simple fontification based on `sh-font-lock-keywords'.
 674 This adds rules for comments and assignments."
 675   (sh-feature sh-font-lock-keywords
 676               (lambda (list)
 677                 `((,(sh-feature sh-assignment-regexp)
 678                    1 font-lock-variable-name-face)
 679                   ,@keywords
 680                   ,@list))))
 681
 682 (defun sh-font-lock-keywords-1 (&optional builtins)
 683   "Function to get better fontification including keywords."
 684   (let ((keywords (concat "\\([;(){}`|&]\\|^\\)[ \t]*\\(\\(\\("
 685                           (mapconcat 'identity
 686                                      (sh-feature sh-leading-keywords)
 687                                      "\\|")
 688                           "\\)[ \t]+\\)?\\("
 689                           (mapconcat 'identity
 690                                      (append (sh-feature sh-leading-keywords)
 691                                              (sh-feature sh-other-keywords))
 692                                      "\\|")
 693                           "\\)")))
 694     (sh-font-lock-keywords
 695      `(,@(if builtins
 696              `((,(concat keywords "[ \t]+\\)?\\("
 697                          (mapconcat 'identity (sh-feature sh-builtins) "\\|")
 698                          "\\)\\>")
 699                 (2 font-lock-keyword-face nil t)
 700                 (6 font-lock-builtin-face))
 701                ,@(sh-feature sh-font-lock-keywords-2)))
 702          (,(concat keywords "\\)\\>")
 703           2 font-lock-keyword-face)
 704          ,@(sh-feature sh-font-lock-keywords-1)))))
 705
 706 (defun sh-font-lock-keywords-2 ()
 707   "Function to get better fontification including keywords and builtins."
 708   (sh-font-lock-keywords-1 t))
 709
 710
 711 (defun sh-set-shell (shell &optional no-query-flag insert-flag)
 712   "Set this buffer's shell to SHELL (a string).
 713 Makes this script executable via `executable-set-magic', and sets up the
 714 proper starting #!-line, if INSERT-FLAG is non-nil.
 715 Calls the value of `sh-set-shell-hook' if set."
 716   (interactive (list (completing-read "Name or path of shell: "
 717                                       interpreter-mode-alist
 718                                       (lambda (x) (eq (cdr x) 'sh-mode)))
 719                      (eq executable-query 'function)
 720                      t))
 721   (setq sh-shell (intern (file-name-nondirectory shell))
 722         sh-shell (or (cdr (assq sh-shell sh-alias-alist))
 723                      sh-shell))
 724   (if insert-flag
 725       (setq sh-shell-file
 726             (executable-set-magic shell (sh-feature sh-shell-arg)
 727                                   no-query-flag insert-flag)))
 728   (setq require-final-newline (sh-feature sh-require-final-newline)
 729 ;;;     local-abbrev-table (sh-feature sh-abbrevs)
 730         font-lock-keywords nil          ; force resetting
 731         font-lock-syntax-table nil
 732         comment-start-skip "#+[\t ]*"
 733         mode-line-process (format "[%s]" sh-shell)
 734         sh-shell-variables nil
 735         sh-shell-variables-initialized nil
 736         shell (sh-feature sh-variables))
 737   (set-syntax-table (sh-feature sh-mode-syntax-table))
 738   (while shell
 739     (sh-remember-variable (car shell))
 740     (setq shell (cdr shell)))
 741   (and (boundp 'font-lock-mode)
 742        font-lock-mode
 743        (font-lock-mode (font-lock-mode 0)))
 744   (run-hooks 'sh-set-shell-hook))
 745
 746
 747
 748 (defun sh-feature (list &optional function)
 749   "Index ALIST by the current shell.
 750 If ALIST isn't a list where every element is a cons, it is returned as is.
 751 Else indexing follows an inheritance logic which works in two ways:
 752
 753   - Fall back on successive ancestors (see `sh-ancestor-alist') as long as
 754     the alist contains no value for the current shell.
 755
 756   - If the value thus looked up is a list starting with `eval' its `cdr' is
 757     first evaluated.  If that is also a list and the first argument is a
 758     symbol in ALIST it is not evaluated, but rather recursively looked up in
 759     ALIST to allow the function called to define the value for one shell to be
 760     derived from another shell.  While calling the function, is the car of the
 761     alist element is the current shell.
 762     The value thus determined is physically replaced into the alist.
 763
 764 Optional FUNCTION is applied to the determined value and the result is cached
 765 in ALIST."
 766   (or (if (consp list)
 767           (let ((l list))
 768             (while (and l (consp (car l)))
 769               (setq l (cdr l)))
 770             (if l list)))
 771       (if function
 772           (cdr (assoc (setq function (cons sh-shell function)) list)))
 773       (let ((sh-shell sh-shell)
 774             elt val)
 775         (while (and sh-shell
 776                     (not (setq elt (assq sh-shell list))))
 777           (setq sh-shell (cdr (assq sh-shell sh-ancestor-alist))))
 778         (if (and (consp (setq val (cdr elt)))
 779                  (eq (car val) 'eval))
 780             (setcdr elt
 781                     (setq val
 782                           (eval (if (consp (setq val (cdr val)))
 783                                     (let ((sh-shell (car (cdr val)))
 784                                           function)
 785                                       (if (assq sh-shell list)
 786                                           (setcar (cdr val)
 787                                                   (list 'quote
 788                                                         (sh-feature list))))
 789                                       val)
 790                                   val)))))
 791         (if function
 792             (nconc list
 793                    (list (cons function
 794                                (setq sh-shell (car function)
 795                                      val (funcall (cdr function) val))))))
 796         val)))
 797
 798
 799
 800 ;;; I commented this out because nobody calls it -- rms.
 801 ;;;(defun sh-abbrevs (ancestor &rest list)
 802 ;;;  "Iff it isn't, define the current shell as abbrev table and fill that.
 803 ;;;Abbrev table will inherit all abbrevs from ANCESTOR, which is either an abbrev
 804 ;;;table or a list of (NAME1 EXPANSION1 ...).  In addition it will define abbrevs
 805 ;;;according to the remaining arguments NAMEi EXPANSIONi ...
 806 ;;;EXPANSION may be either a string or a skeleton command."
 807 ;;;  (or (if (boundp sh-shell)
 808 ;;;       (symbol-value sh-shell))
 809 ;;;      (progn
 810 ;;;     (if (listp ancestor)
 811 ;;;         (nconc list ancestor))
 812 ;;;     (define-abbrev-table sh-shell ())
 813 ;;;     (if (vectorp ancestor)
 814 ;;;         (mapatoms (lambda (atom)
 815 ;;;                     (or (eq atom 0)
 816 ;;;                         (define-abbrev (symbol-value sh-shell)
 817 ;;;                           (symbol-name atom)
 818 ;;;                           (symbol-value atom)
 819 ;;;                           (symbol-function atom))))
 820 ;;;                   ancestor))
 821 ;;;     (while list
 822 ;;;       (define-abbrev (symbol-value sh-shell)
 823 ;;;         (car list)
 824 ;;;         (if (stringp (car (cdr list)))
 825 ;;;             (car (cdr list))
 826 ;;;           "")
 827 ;;;         (if (symbolp (car (cdr list)))
 828 ;;;             (car (cdr list))))
 829 ;;;       (setq list (cdr (cdr list)))))
 830 ;;;      (symbol-value sh-shell)))
 831
 832
 833 (defun sh-mode-syntax-table (table &rest list)
 834   "Copy TABLE and set syntax for successive CHARs according to strings S."
 835   (setq table (copy-syntax-table table))
 836   (while list
 837     (modify-syntax-entry (car list) (car (cdr list)) table)
 838     (setq list (cdr (cdr list))))
 839   table)
 840
 841
 842 (defun sh-append (ancestor &rest list)
 843   "Return list composed of first argument (a list) physically appended to rest."
 844   (nconc list ancestor))
 845
 846
 847 (defun sh-modify (skeleton &rest list)
 848   "Modify a copy of SKELETON by replacing I1 with REPL1, I2 with REPL2 ..."
 849   (setq skeleton (copy-sequence skeleton))
 850   (while list
 851     (setcar (or (nthcdr (car list) skeleton)
 852                 (error "Index %d out of bounds" (car list)))
 853             (car (cdr list)))
 854     (setq list (nthcdr 2 list)))
 855   skeleton)
 856
 857
 858 (defun sh-indent-line ()
 859   "Indent as far as preceding non-empty line, then by steps of `sh-indentation'.
 860 Lines containing only comments are considered empty."
 861   (interactive)
 862   (let ((previous (save-excursion
 863                     (while (and (not (bobp))
 864                                 (progn
 865                                   (forward-line -1)
 866                                   (back-to-indentation)
 867                                   (or (eolp)
 868                                       (eq (following-char) ?#)))))
 869                     (current-column)))
 870         current)
 871     (save-excursion
 872       (indent-to (if (eq this-command 'newline-and-indent)
 873                      previous
 874                    (if (< (current-column)
 875                           (setq current (progn (back-to-indentation)
 876                                                (current-column))))
 877                        (if (eolp) previous 0)
 878                      (delete-region (point)
 879                                     (progn (beginning-of-line) (point)))
 880                      (if (eolp)
 881                          (max previous (* (1+ (/ current sh-indentation))
 882                                           sh-indentation))
 883                        (* (1+ (/ current sh-indentation)) sh-indentation))))))
 884     (if (< (current-column) (current-indentation))
 885         (skip-chars-forward " \t"))))
 886
 887
 888 (defun sh-execute-region (start end &optional flag)
 889   "Pass optional header and region to a subshell for noninteractive execution.
 890 The working directory is that of the buffer, and only environment variables
 891 are already set which is why you can mark a header within the script.
 892
 893 With a positive prefix ARG, instead of sending region, define header from
 894 beginning of buffer to point.  With a negative prefix ARG, instead of sending
 895 region, clear header."
 896   (interactive "r\nP")
 897   (if flag
 898       (setq sh-header-marker (if (> (prefix-numeric-value flag) 0)
 899                                  (point-marker)))
 900     (if sh-header-marker
 901         (save-excursion
 902           (let (buffer-undo-list)
 903             (goto-char sh-header-marker)
 904             (append-to-buffer (current-buffer) start end)
 905             (shell-command-on-region (point-min)
 906                                      (setq end (+ sh-header-marker
 907                                                   (- end start)))
 908                                      sh-shell-file)
 909             (delete-region sh-header-marker end)))
 910       (shell-command-on-region start end (concat sh-shell-file " -")))))
 911
 912
 913 (defun sh-remember-variable (var)
 914   "Make VARIABLE available for future completing reads in this buffer."
 915   (or (< (length var) sh-remember-variable-min)
 916       (getenv var)
 917       (assoc var sh-shell-variables)
 918       (setq sh-shell-variables (cons (cons var var) sh-shell-variables)))
 919   var)
 920
 921
 922
 923 (defun sh-quoted-p ()
 924   "Is point preceded by an odd number of backslashes?"
 925   (eq -1 (% (save-excursion (skip-chars-backward "\\\\")) 2)))
 926 \f
 927 ;; statement syntax-commands for various shells
 928
 929 ;; You are welcome to add the syntax or even completely new statements as
 930 ;; appropriate for your favorite shell.
 931
 932 (define-skeleton sh-case
 933   "Insert a case/switch statement.  See `sh-feature'."
 934   (csh "expression: "
 935        "switch( " str " )" \n
 936        > "case " (read-string "pattern: ") ?: \n
 937        > _ \n
 938        "breaksw" \n
 939        ( "other pattern, %s: "
 940          < "case " str ?: \n
 941          > _ \n
 942          "breaksw" \n)
 943        < "default:" \n
 944        > _ \n
 945        resume:
 946        < < "endsw")
 947   (es)
 948   (rc "expression: "
 949       "switch( " str " ) {" \n
 950       > "case " (read-string "pattern: ") \n
 951       > _ \n
 952       ( "other pattern, %s: "
 953         < "case " str \n
 954         > _ \n)
 955       < "case *" \n
 956       > _ \n
 957       resume:
 958       < < ?})
 959   (sh "expression: "
 960       "case " str " in" \n
 961       > (read-string "pattern: ") ?\) \n
 962       > _ \n
 963       ";;" \n
 964       ( "other pattern, %s: "
 965         < str ?\) \n
 966         > _ \n
 967         ";;" \n)
 968       < "*)" \n
 969       > _ \n
 970       resume:
 971       < < "esac"))
 972 (put 'sh-case 'menu-enable '(sh-feature sh-case))
 973
 974
 975
 976 (define-skeleton sh-for
 977   "Insert a for loop.  See `sh-feature'."
 978   (csh eval sh-modify sh
 979        1 "foreach "
 980        3 " ( "
 981        5 " )"
 982        15 "end")
 983   (es eval sh-modify rc
 984       3 " = ")
 985   (rc eval sh-modify sh
 986       1 "for( "
 987       5 " ) {"
 988       15 ?})
 989   (sh "Index variable: "
 990       "for " str " in " _ "; do" \n
 991       > _ | ?$ & (sh-remember-variable str) \n
 992       < "done"))
 993
 994
 995
 996 (define-skeleton sh-indexed-loop
 997   "Insert an indexed loop from 1 to n.  See `sh-feature'."
 998   (bash eval identity posix)
 999   (csh "Index variable: "
1000        "@ " str " = 1" \n
1001        "while( $" str " <= " (read-string "upper limit: ") " )" \n
1002        > _ ?$ str \n
1003        "@ " str "++" \n
1004        < "end")
1005   (es eval sh-modify rc
1006       3 " =")
1007   (ksh88 "Index variable: "
1008          "integer " str "=0" \n
1009          "while (( ( " str " += 1 ) <= "
1010          (read-string "upper limit: ")
1011          " )); do" \n
1012          > _ ?$ (sh-remember-variable str) \n
1013          < "done")
1014   (posix "Index variable: "
1015          str "=1" \n
1016          "while [ $" str " -le "
1017          (read-string "upper limit: ")
1018          " ]; do" \n
1019          > _ ?$ str \n
1020          str ?= (sh-add (sh-remember-variable str) 1) \n
1021          < "done")
1022   (rc "Index variable: "
1023       "for( " str " in" " `{awk 'BEGIN { for( i=1; i<="
1024       (read-string "upper limit: ")
1025       "; i++ ) print i }'}) {" \n
1026       > _ ?$ (sh-remember-variable str) \n
1027       < ?})
1028   (sh "Index variable: "
1029       "for " str " in `awk 'BEGIN { for( i=1; i<="
1030       (read-string "upper limit: ")
1031       "; i++ ) print i }'`; do" \n
1032       > _ ?$ (sh-remember-variable str) \n
1033       < "done"))
1034
1035
1036 (defun sh-shell-initialize-variables ()
1037   "Scan the buffer for variable assignments.
1038 Add these variables to `sh-shell-variables'."
1039   (message "Scanning buffer `%s' for variable assignments..." (buffer-name))
1040   (save-excursion
1041     (goto-char (point-min))
1042     (setq sh-shell-variables-initialized t)
1043     (while (search-forward "=" nil t)
1044       (sh-assignment 0)))
1045   (message "Scanning buffer `%s' for variable assignments...done"
1046            (buffer-name)))
1047
1048 (defvar sh-add-buffer)
1049
1050 (defun sh-add-completer (string predicate code)
1051   "Do completion using `sh-shell-variables', but initialize it first.
1052 This function is designed for use as the \"completion table\",
1053 so it takes three arguments:
1054   STRING, the current buffer contents;
1055   PREDICATE, the predicate for filtering possible matches;
1056   CODE, which says what kind of things to do.
1057 CODE can be nil, t or `lambda'.
1058 nil means to return the best completion of STRING, or nil if there is none.
1059 t means to return a list of all possible completions of STRING.
1060 `lambda' means to return t if STRING is a valid completion as it stands."
1061   (let ((sh-shell-variables
1062          (save-excursion
1063            (set-buffer sh-add-buffer)
1064            (or sh-shell-variables-initialized
1065                (sh-shell-initialize-variables))
1066            (nconc (mapcar (lambda (var)
1067                             (let ((name
1068                                    (substring var 0 (string-match "=" var))))
1069                               (cons name name)))
1070                           process-environment)
1071                   sh-shell-variables))))
1072     (cond ((null code)
1073            (try-completion string sh-shell-variables predicate))
1074           ((eq code t)
1075            (all-completions string sh-shell-variables predicate))
1076           ((eq code 'lambda)
1077            (assoc string sh-shell-variables)))))
1078
1079 (defun sh-add (var delta)
1080   "Insert an addition of VAR and prefix DELTA for Bourne (type) shell."
1081   (interactive
1082    (let ((sh-add-buffer (current-buffer)))
1083      (list (completing-read "Variable: " 'sh-add-completer)
1084            (prefix-numeric-value current-prefix-arg))))
1085   (insert (sh-feature '((bash . "$[ ")
1086                         (ksh88 . "$(( ")
1087                         (posix . "$(( ")
1088                         (rc . "`{expr $")
1089                         (sh . "`expr $")
1090                         (zsh . "$[ ")))
1091           (sh-remember-variable var)
1092           (if (< delta 0) " - " " + ")
1093           (number-to-string (abs delta))
1094           (sh-feature '((bash . " ]")
1095                         (ksh88 . " ))")
1096                         (posix . " ))")
1097                         (rc . "}")
1098                         (sh . "`")
1099                         (zsh . " ]")))))
1100
1101
1102
1103 (define-skeleton sh-function
1104   "Insert a function definition.  See `sh-feature'."
1105   (bash eval sh-modify ksh88
1106         3 "() {")
1107   (ksh88 "name: "
1108          "function " str " {" \n
1109          > _ \n
1110          < "}")
1111   (rc eval sh-modify ksh88
1112         1 "fn ")
1113   (sh ()
1114       "() {" \n
1115       > _ \n
1116       < "}"))
1117
1118
1119
1120 (define-skeleton sh-if
1121   "Insert an if statement.  See `sh-feature'."
1122   (csh "condition: "
1123        "if( " str " ) then" \n
1124        > _ \n
1125        ( "other condition, %s: "
1126          < "else if( " str " ) then" \n
1127          > _ \n)
1128        < "else" \n
1129        > _ \n
1130        resume:
1131        < "endif")
1132   (es "condition: "
1133       "if { " str " } {" \n
1134        > _ \n
1135        ( "other condition, %s: "
1136          < "} { " str " } {" \n
1137          > _ \n)
1138        < "} {" \n
1139        > _ \n
1140        resume:
1141        < ?})
1142   (rc eval sh-modify csh
1143       3 " ) {"
1144       8 '( "other condition, %s: "
1145            < "} else if( " str " ) {" \n
1146            > _ \n)
1147       10 "} else {"
1148       17 ?})
1149   (sh "condition: "
1150       '(setq input (sh-feature sh-test))
1151       "if " str "; then" \n
1152       > _ \n
1153       ( "other condition, %s: "
1154         < "elif " str "; then" \n
1155         > _ \n)
1156       < "else" \n
1157       > _ \n
1158       resume:
1159       < "fi"))
1160
1161
1162
1163 (define-skeleton sh-repeat
1164   "Insert a repeat loop definition.  See `sh-feature'."
1165   (es nil
1166       "forever {" \n
1167       > _ \n
1168       < ?})
1169   (zsh "factor: "
1170       "repeat " str "; do"\n
1171       > _ \n
1172       < "done"))
1173 (put 'sh-repeat 'menu-enable '(sh-feature sh-repeat))
1174
1175
1176
1177 (define-skeleton sh-select
1178   "Insert a select statement.  See `sh-feature'."
1179   (ksh88 "Index variable: "
1180          "select " str " in " _ "; do" \n
1181          > ?$ str \n
1182          < "done"))
1183 (put 'sh-select 'menu-enable '(sh-feature sh-select))
1184
1185
1186
1187 (define-skeleton sh-tmp-file
1188   "Insert code to setup temporary file handling.  See `sh-feature'."
1189   (bash eval identity ksh88)
1190   (csh (file-name-nondirectory (buffer-file-name))
1191        "set tmp = /tmp/" str ".$$" \n
1192        "onintr exit" \n _
1193        (and (goto-char (point-max))
1194             (not (bolp))
1195             ?\n)
1196        "exit:\n"
1197        "rm $tmp* >&/dev/null" >)
1198   (es (file-name-nondirectory (buffer-file-name))
1199       "local( signals = $signals sighup sigint; tmp = /tmp/" str ".$pid ) {" \n
1200       > "catch @ e {" \n
1201       > "rm $tmp^* >[2]/dev/null" \n
1202       "throw $e" \n
1203       < "} {" \n
1204       > _ \n
1205       < ?} \n
1206       < ?})
1207   (ksh88 eval sh-modify sh
1208          6 "EXIT")
1209   (rc (file-name-nondirectory (buffer-file-name))
1210        "tmp = /tmp/" str ".$pid" \n
1211        "fn sigexit { rm $tmp^* >[2]/dev/null }")
1212   (sh (file-name-nondirectory (buffer-file-name))
1213       "TMP=/tmp/" str ".$$" \n
1214       "trap \"rm $TMP* 2>/dev/null\" " ?0))
1215
1216
1217
1218 (define-skeleton sh-until
1219   "Insert an until loop.  See `sh-feature'."
1220   (sh "condition: "
1221       '(setq input (sh-feature sh-test))
1222       "until " str "; do" \n
1223       > _ \n
1224       < "done"))
1225 (put 'sh-until 'menu-enable '(sh-feature sh-until))
1226
1227
1228
1229 (define-skeleton sh-while
1230   "Insert a while loop.  See `sh-feature'."
1231   (csh eval sh-modify sh
1232        2 "while( "
1233        4 " )"
1234        10 "end")
1235   (es eval sh-modify rc
1236       2 "while { "
1237       4 " } {")
1238   (rc eval sh-modify csh
1239       4 " ) {"
1240       10 ?})
1241   (sh "condition: "
1242       '(setq input (sh-feature sh-test))
1243       "while " str "; do" \n
1244       > _ \n
1245       < "done"))
1246
1247
1248
1249 (define-skeleton sh-while-getopts
1250   "Insert a while getopts loop.  See `sh-feature'.
1251 Prompts for an options string which consists of letters for each recognized
1252 option followed by a colon `:' if the option accepts an argument."
1253   (bash eval sh-modify sh
1254         18 "${0##*/}")
1255   (csh nil
1256        "while( 1 )" \n
1257        > "switch( \"$1\" )" \n
1258        '(setq input '("- x" . 2))
1259        > >
1260        ( "option, %s: "
1261          < "case " '(eval str)
1262          '(if (string-match " +" str)
1263               (setq v1 (substring str (match-end 0))
1264                     str (substring str 0 (match-beginning 0)))
1265             (setq v1 nil))
1266          str ?: \n
1267          > "set " v1 & " = $2" | -4 & _ \n
1268          (if v1 "shift") & \n
1269          "breaksw" \n)
1270        < "case --:" \n
1271        > "shift" \n
1272        < "default:" \n
1273        > "break" \n
1274        resume:
1275        < < "endsw" \n
1276        "shift" \n
1277        < "end")
1278   (ksh88 eval sh-modify sh
1279          16 "print"
1280          18 "${0##*/}"
1281          36 "OPTIND-1")
1282   (posix eval sh-modify sh
1283          18 "$(basename $0)")
1284   (sh "optstring: "
1285       "while getopts :" str " OPT; do" \n
1286       > "case $OPT in" \n
1287       > >
1288       '(setq v1 (append (vconcat str) nil))
1289       ( (prog1 (if v1 (char-to-string (car v1)))
1290           (if (eq (nth 1 v1) ?:)
1291               (setq v1 (nthcdr 2 v1)
1292                     v2 "\"$OPTARG\"")
1293             (setq v1 (cdr v1)
1294                   v2 nil)))
1295         < str "|+" str ?\) \n
1296         > _ v2 \n
1297         ";;" \n)
1298       < "*)" \n
1299       > "echo" " \"usage: " "`basename $0`"
1300       " [+-" '(setq v1 (point)) str
1301       '(save-excursion
1302          (while (search-backward ":" v1 t)
1303            (replace-match " ARG] [+-" t t)))
1304       (if (eq (preceding-char) ?-) -5)
1305       "] [--] ARGS...\"" \n
1306       "exit 2" \n
1307       < < "esac" \n
1308       < "done" \n
1309       "shift " (sh-add "OPTIND" -1)))
1310 (put 'sh-while-getopts 'menu-enable '(sh-feature sh-while-getopts))
1311
1312
1313
1314 (defun sh-assignment (arg)
1315   "Remember preceding identifier for future completion and do self-insert."
1316   (interactive "p")
1317   (self-insert-command arg)
1318   (if (<= arg 1)
1319       (sh-remember-variable
1320        (save-excursion
1321          (if (re-search-forward (sh-feature sh-assignment-regexp)
1322                                 (prog1 (point)
1323                                   (beginning-of-line 1))
1324                                 t)
1325              (match-string 1))))))
1326
1327
1328
1329 (defun sh-maybe-here-document (arg)
1330   "Inserts self.  Without prefix, following unquoted `<' inserts here document.
1331 The document is bounded by `sh-here-document-word'."
1332   (interactive "*P")
1333   (self-insert-command (prefix-numeric-value arg))
1334   (or arg
1335       (not (eq (char-after (- (point) 2)) last-command-char))
1336       (save-excursion
1337         (backward-char 2)
1338         (sh-quoted-p))
1339       (progn
1340         (insert sh-here-document-word)
1341         (or (eolp) (looking-at "[ \t]") (insert ? ))
1342         (end-of-line 1)
1343         (while
1344             (sh-quoted-p)
1345           (end-of-line 2))
1346         (newline)
1347         (save-excursion (insert ?\n sh-here-document-word)))))
1348
1349 \f
1350 ;; various other commands
1351
1352 (autoload 'comint-dynamic-complete "comint"
1353   "Dynamically perform completion at point." t)
1354
1355 (autoload 'shell-dynamic-complete-command "shell"
1356   "Dynamically complete the command at point." t)
1357
1358 (autoload 'comint-dynamic-complete-filename "comint"
1359   "Dynamically complete the filename at point." t)
1360
1361 (autoload 'shell-dynamic-complete-environment-variable "shell"
1362   "Dynamically complete the environment variable at point." t)
1363
1364
1365
1366 (defun sh-newline-and-indent ()
1367   "Strip unquoted whitespace, insert newline, and indent like current line."
1368   (interactive "*")
1369   (indent-to (prog1 (current-indentation)
1370                (delete-region (point)
1371                               (progn
1372                                 (or (zerop (skip-chars-backward " \t"))
1373                                     (if (sh-quoted-p)
1374                                         (forward-char)))
1375                                 (point)))
1376                (newline))))
1377
1378
1379
1380 (defun sh-beginning-of-command ()
1381   "Move point to successive beginnings of commands."
1382   (interactive)
1383   (if (re-search-backward sh-beginning-of-command nil t)
1384       (goto-char (match-beginning 2))))
1385
1386
1387 (defun sh-end-of-command ()
1388   "Move point to successive ends of commands."
1389   (interactive)
1390   (if (re-search-forward sh-end-of-command nil t)
1391       (goto-char (match-end 1))))
1392
1393 (provide 'sh-script)
1394 ;; sh-script.el ends here