1 ;;; sh-script.el --- shell-script editing commands for Emacs -*- lexical-binding:t -*-
3 ;; Copyright (C) 1993-1997, 1999, 2001-2013 Free Software Foundation, Inc.
5 ;; Author: Daniel Pfeiffer <occitan@esperanto.org>
8 ;; Keywords: languages, unix
10 ;; This file is part of GNU Emacs.
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 3 of the License, or
15 ;; (at your option) any later version.
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.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;; Major mode for editing shell scripts. Bourne, C and rc shells as well
28 ;; as various derivatives are supported and easily derived from. Structured
29 ;; statements can be inserted with one command or abbrev. Completion is
30 ;; available for filenames, variables known from the script, the shell and
31 ;; the environment as well as commands.
35 ;; - In Bourne the keyword `in' is not anchored to case, for, select ...
36 ;; - Variables in `"' strings aren't fontified because there's no way of
37 ;; syntactically distinguishing those from `'' strings.
41 ;; Indentation for rc and es modes is very limited, but for Bourne shells
42 ;; and its derivatives it is quite customizable.
44 ;; The following description applies to sh and derived shells (bash,
47 ;; There are various customization variables which allow tailoring to
48 ;; a wide variety of styles. Most of these variables are named
49 ;; sh-indent-for-XXX and sh-indent-after-XXX. For example.
50 ;; sh-indent-after-if controls the indenting of a line following
51 ;; an if statement, and sh-indent-for-fi controls the indentation
52 ;; of the line containing the fi.
54 ;; You can set each to a numeric value, but it is often more convenient
55 ;; to a symbol such as `+' which uses the value of variable `sh-basic-offset'.
56 ;; By changing this one variable you can increase or decrease how much
57 ;; indentation there is. Valid symbols:
59 ;; + Indent right by sh-basic-offset
60 ;; - Indent left by sh-basic-offset
61 ;; ++ Indent right twice sh-basic-offset
62 ;; -- Indent left twice sh-basic-offset
63 ;; * Indent right half sh-basic-offset
64 ;; / Indent left half sh-basic-offset.
66 ;; There are 4 commands to help set the indentation variables:
69 ;; This shows what variable controls the indentation of the current
70 ;; line and its value.
73 ;; This allows you to set the value of the variable controlling the
74 ;; current line's indentation. You can enter a number or one of a
75 ;; number of special symbols to denote the value of sh-basic-offset,
76 ;; or its negative, or half it, or twice it, etc. If you've used
77 ;; cc-mode this should be familiar. If you forget which symbols are
78 ;; valid simply press C-h at the prompt.
80 ;; `sh-learn-line-indent'
81 ;; Simply make the line look the way you want it, then invoke this
82 ;; command. It will set the variable to the value that makes the line
83 ;; indent like that. If called with a prefix argument then it will set
84 ;; the value to one of the symbols if applicable.
86 ;; `sh-learn-buffer-indent'
87 ;; This is the deluxe function! It "learns" the whole buffer (use
88 ;; narrowing if you want it to process only part). It outputs to a
89 ;; buffer *indent* any conflicts it finds, and all the variables it has
90 ;; learned. This buffer is a sort of Occur mode buffer, allowing you to
91 ;; easily find where something was set. It is popped to automatically
92 ;; if there are any conflicts found or if `sh-popup-occur-buffer' is
94 ;; `sh-indent-comment' will be set if all comments follow the same
95 ;; pattern; if they don't it will be set to nil.
96 ;; Whether `sh-basic-offset' is set is determined by variable
97 ;; `sh-learn-basic-offset'.
99 ;; Unfortunately, `sh-learn-buffer-indent' can take a long time to run
100 ;; (e.g. if there are large case statements). Perhaps it does not make
101 ;; sense to run it on large buffers: if lots of lines have different
102 ;; indentation styles it will produce a lot of diagnostics in the
103 ;; *indent* buffer; if there is a consistent style then running
104 ;; `sh-learn-buffer-indent' on a small region of the buffer should
107 ;; Saving indentation values
108 ;; -------------------------
109 ;; After you've learned the values in a buffer, how to you remember
110 ;; them? Originally I had hoped that `sh-learn-buffer-indent'
111 ;; would make this unnecessary; simply learn the values when you visit
113 ;; You can do this automatically like this:
114 ;; (add-hook 'sh-set-shell-hook 'sh-learn-buffer-indent)
116 ;; However... `sh-learn-buffer-indent' is extremely slow,
117 ;; especially on large-ish buffer. Also, if there are conflicts the
118 ;; "last one wins" which may not produce the desired setting.
120 ;; So...There is a minimal way of being able to save indentation values and
121 ;; to reload them in another buffer or at another point in time.
123 ;; Use `sh-name-style' to give a name to the indentation settings of
124 ;; the current buffer.
125 ;; Use `sh-load-style' to load indentation settings for the current
126 ;; buffer from a specific style.
127 ;; Use `sh-save-styles-to-buffer' to write all the styles to a buffer
128 ;; in lisp code. You can then store it in a file and later use
129 ;; `load-file' to load it.
131 ;; Indentation variables - buffer local or global?
132 ;; ----------------------------------------------
133 ;; I think that often having them buffer-local makes sense,
134 ;; especially if one is using `sh-learn-buffer-indent'. However, if
135 ;; a user sets values using customization, these changes won't appear
136 ;; to work if the variables are already local!
138 ;; To get round this, there is a variable `sh-make-vars-local' and 2
139 ;; functions: `sh-make-vars-local' and `sh-reset-indent-vars-to-global-values'.
141 ;; If `sh-make-vars-local' is non-nil, then these variables become
142 ;; buffer local when the mode is established.
143 ;; If this is nil, then the variables are global. At any time you
144 ;; can make them local with the command `sh-make-vars-local'.
145 ;; Conversely, to update with the global values you can use the
146 ;; command `sh-reset-indent-vars-to-global-values'.
148 ;; This may be awkward, but the intent is to cover all cases.
150 ;; Awkward things, pitfalls
151 ;; ------------------------
152 ;; Indentation for a sh script is complicated for a number of reasons:
154 ;; 1. You can't format by simply looking at symbols, you need to look
155 ;; at keywords. [This is not the case for rc and es shells.]
156 ;; 2. The character ")" is used both as a matched pair "(" ... ")" and
157 ;; as a stand-alone symbol (in a case alternative). This makes
158 ;; things quite tricky!
159 ;; 3. Here-documents in a script should be treated "as is", and when
160 ;; they terminate we want to revert to the indentation of the line
161 ;; containing the "<<" symbol.
162 ;; 4. A line may be continued using the "\".
163 ;; 5. The character "#" (outside a string) normally starts a comment,
164 ;; but it doesn't in the sequence "$#"!
166 ;; To try and address points 2 3 and 5 I used a feature that cperl mode
167 ;; uses, that of a text's syntax property. This, however, has 2
169 ;; 1. We need to scan the buffer to find which ")" symbols belong to a
170 ;; case alternative, to find any here documents, and handle "$#".
174 ;; - Indenting many lines is slow. It currently does each line
175 ;; independently, rather than saving state information.
177 ;; - `sh-learn-buffer-indent' is extremely slow.
179 ;; - "case $x in y) echo ;; esac)" the last ) is mis-identified as being
180 ;; part of a case-pattern. You need to add a semi-colon after "esac" to
181 ;; coerce sh-script into doing the right thing.
183 ;; - "echo $z in ps | head)" the last ) is mis-identified as being part of
184 ;; a case-pattern. You need to put the "in" between quotes to coerce
185 ;; sh-script into doing the right thing.
187 ;; - A line starting with "}>foo" is not indented like "} >foo".
189 ;; Richard Sharman <rsharman@pobox.com> June 1999.
193 ;; page 1: variables and settings
194 ;; page 2: indentation stuff
195 ;; page 3: mode-command and utility functions
196 ;; page 4: statement syntax-commands for various shells
197 ;; page 5: various other commands
203 (require 'executable)
205 (autoload 'comint-completion-at-point "comint")
206 (autoload 'comint-filename-completion "comint")
207 (autoload 'shell-command-completion "shell")
208 (autoload 'shell-environment-variable-completion "shell")
210 (defvar font-lock-comment-face)
211 (defvar font-lock-set-defaults)
212 (defvar font-lock-string-face)
216 "Shell programming utilities."
219 (defgroup sh-script nil
221 :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
226 (defcustom sh-ancestor-alist
245 "Alist showing the direct ancestor of various shells.
246 This is the basis for `sh-feature'. See also `sh-alias-alist'.
247 By default we have the following three hierarchies:
250 jcsh C Shell with Job Control
252 itcsh Ian's TENEX C Shell
257 jsh Bourne Shell with Job Control
258 bash GNU Bourne Again Shell
261 dtksh CDE Desktop Korn Shell
262 pdksh Public Domain Korn Shell
263 wksh Window Korn Shell
265 oash SCO OA (curses) Shell
266 posix IEEE 1003.2 Shell Standard
268 :type '(repeat (cons symbol symbol))
272 (defcustom sh-alias-alist
273 (append (if (eq system-type 'gnu/linux)
276 ;; for the time being
280 "Alist for transforming shell names to what they really are.
281 Use this where the name of the executable doesn't correspond to the type of
283 :type '(repeat (cons symbol symbol))
287 (defcustom sh-shell-file
289 ;; On MSDOS and Windows, collapse $SHELL to lower-case and remove
290 ;; the executable extension, so comparisons with the list of
291 ;; known shells work.
292 (and (memq system-type '(ms-dos windows-nt))
293 (let* ((shell (getenv "SHELL"))
295 (and shell (file-name-nondirectory shell))))
296 ;; shell-script mode doesn't support DOS/Windows shells,
297 ;; so use the default instead.
299 (member (downcase shell-base)
300 '("command.com" "cmd.exe" "4dos.com" "ndos.com"
303 (file-name-sans-extension (downcase shell)))))
306 "The executable file name for the shell being programmed."
311 (defcustom sh-shell-arg
312 ;; bash does not need any options when run in a shell script,
316 ;; Bill_Mann@praxisint.com says -p with ksh can do harm.
318 ;; -p means don't initialize functions from the environment.
320 ;; Someone proposed -motif, but we don't want to encourage
321 ;; use of a non-free widget set.
323 ;; -f means don't run .zshrc.
325 "Single argument string for the magic number. See `sh-feature'."
326 :type '(repeat (cons (symbol :tag "Shell")
327 (choice (const :tag "No Arguments" nil)
328 (string :tag "Arguments")
329 (sexp :format "Evaluate: %v"))))
332 (defcustom sh-imenu-generic-expression
337 "^\\s-*function\\s-+\\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?"
341 "^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()"
344 "Alist of regular expressions for recognizing shell function definitions.
345 See `sh-feature' and `imenu-generic-expression'."
346 :type '(alist :key-type (symbol :tag "Shell")
347 :value-type (alist :key-type (choice :tag "Title"
349 (const :tag "None" nil))
351 (repeat :tag "Regexp, index..." sexp)))
355 (defun sh-current-defun-name ()
356 "Find the name of function or variable at point.
357 For use in `add-log-current-defun-function'."
360 (when (re-search-backward
364 "^\\s-*function\\s-+\\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?"
367 "^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()"
370 "^\\([[:alpha:]_][[:alnum:]_]*\\)="
373 (or (match-string-no-properties 1)
374 (match-string-no-properties 2)
375 (match-string-no-properties 3)))))
377 (defvar sh-shell-variables nil
378 "Alist of shell variable names that should be included in completion.
379 These are used for completion in addition to all the variables named
380 in `process-environment'. Each element looks like (VAR . VAR), where
381 the car and cdr are the same symbol.")
383 (defvar sh-shell-variables-initialized nil
384 "Non-nil if `sh-shell-variables' is initialized.")
386 (defun sh-canonicalize-shell (shell)
387 "Convert a shell name SHELL to the one we should handle it as."
388 (if (string-match "\\.exe\\'" shell)
389 (setq shell (substring shell 0 (match-beginning 0))))
391 (setq shell (intern shell)))
392 (or (cdr (assq shell sh-alias-alist))
395 (defvar sh-shell (sh-canonicalize-shell (file-name-nondirectory sh-shell-file))
396 "The shell being programmed. This is set by \\[sh-set-shell].")
397 ;;;###autoload(put 'sh-shell 'safe-local-variable 'symbolp)
399 (define-abbrev-table 'sh-mode-abbrev-table ())
402 ;; I turned off this feature because it doesn't permit typing commands
403 ;; in the usual way without help.
405 ;; '((csh sh-abbrevs shell
407 ;; "getopts" 'sh-while-getopts)
409 ;; (es sh-abbrevs shell
410 ;; "function" 'sh-function)
412 ;; (ksh88 sh-abbrevs sh
413 ;; "select" 'sh-select)
415 ;; (rc sh-abbrevs shell
417 ;; "function" 'sh-function)
419 ;; (sh sh-abbrevs shell
421 ;; "function" 'sh-function
423 ;; "getopts" 'sh-while-getopts)
425 ;; ;; The next entry is only used for defining the others
426 ;; (shell "for" sh-for
427 ;; "loop" sh-indexed-loop
429 ;; "tmpfile" sh-tmp-file
432 ;; (zsh sh-abbrevs ksh88
433 ;; "repeat" 'sh-repeat))
434 ;; "Abbrev-table used in Shell-Script mode. See `sh-feature'.
435 ;;;Due to the internal workings of abbrev tables, the shell name symbol is
436 ;;;actually defined as the table for the like of \\[edit-abbrevs].")
440 (defun sh-mode-syntax-table (table &rest list)
441 "Copy TABLE and set syntax for successive CHARs according to strings S."
442 (setq table (copy-syntax-table table))
444 (modify-syntax-entry (pop list) (pop list) table))
447 (defvar sh-mode-syntax-table
448 (sh-mode-syntax-table ()
454 ;; ?$ might also have a ". p" syntax. Both "'" and ". p" seem
455 ;; to work fine. This is needed so that dabbrev-expand
468 "The syntax table to use for Shell-Script mode.
469 This is buffer-local in every such buffer.")
471 (defvar sh-mode-syntax-table-input
473 "Syntax-table used in Shell-Script mode. See `sh-feature'.")
476 (let ((map (make-sparse-keymap))
477 (menu-map (make-sparse-keymap)))
478 (define-key map "\C-c(" 'sh-function)
479 (define-key map "\C-c\C-w" 'sh-while)
480 (define-key map "\C-c\C-u" 'sh-until)
481 (define-key map "\C-c\C-t" 'sh-tmp-file)
482 (define-key map "\C-c\C-s" 'sh-select)
483 (define-key map "\C-c\C-r" 'sh-repeat)
484 (define-key map "\C-c\C-o" 'sh-while-getopts)
485 (define-key map "\C-c\C-l" 'sh-indexed-loop)
486 (define-key map "\C-c\C-i" 'sh-if)
487 (define-key map "\C-c\C-f" 'sh-for)
488 (define-key map "\C-c\C-c" 'sh-case)
489 (define-key map "\C-c?" 'sh-show-indent)
490 (define-key map "\C-c=" 'sh-set-indent)
491 (define-key map "\C-c<" 'sh-learn-line-indent)
492 (define-key map "\C-c>" 'sh-learn-buffer-indent)
493 (define-key map "\C-c\C-\\" 'sh-backslash-region)
495 (define-key map "=" 'sh-assignment)
496 (define-key map "\C-c+" 'sh-add)
497 (define-key map "\C-\M-x" 'sh-execute-region)
498 (define-key map "\C-c\C-x" 'executable-interpret)
499 (define-key map "\C-c\C-n" 'sh-send-line-or-region-and-step)
500 (define-key map "\C-c\C-d" 'sh-cd-here)
501 (define-key map "\C-c\C-z" 'sh-show-shell)
503 (define-key map [remap delete-backward-char]
504 'backward-delete-char-untabify)
505 (define-key map "\C-c:" 'sh-set-shell)
506 (define-key map [remap backward-sentence] 'sh-beginning-of-command)
507 (define-key map [remap forward-sentence] 'sh-end-of-command)
508 (define-key map [menu-bar sh-script] (cons "Sh-Script" menu-map))
509 (define-key menu-map [sh-learn-buffer-indent]
510 '(menu-item "Learn buffer indentation" sh-learn-buffer-indent
511 :help "Learn how to indent the buffer the way it currently is."))
512 (define-key menu-map [sh-learn-line-indent]
513 '(menu-item "Learn line indentation" sh-learn-line-indent
514 :help "Learn how to indent a line as it currently is indented"))
515 (define-key menu-map [sh-show-indent]
516 '(menu-item "Show indentation" sh-show-indent
517 :help "Show the how the current line would be indented"))
518 (define-key menu-map [sh-set-indent]
519 '(menu-item "Set indentation" sh-set-indent
520 :help "Set the indentation for the current line"))
522 (define-key menu-map [sh-pair]
523 '(menu-item "Insert braces and quotes in pairs"
525 :button (:toggle . (bound-and-true-p electric-pair-mode))
526 :help "Inserting a brace or quote automatically inserts the matching pair"))
528 (define-key menu-map [sh-s0] '("--"))
530 (define-key menu-map [sh-function]
531 '(menu-item "Function..." sh-function
532 :help "Insert a function definition"))
533 (define-key menu-map [sh-add]
534 '(menu-item "Addition..." sh-add
535 :help "Insert an addition of VAR and prefix DELTA for Bourne (type) shell"))
536 (define-key menu-map [sh-until]
537 '(menu-item "Until Loop" sh-until
538 :help "Insert an until loop"))
539 (define-key menu-map [sh-repeat]
540 '(menu-item "Repeat Loop" sh-repeat
541 :help "Insert a repeat loop definition"))
542 (define-key menu-map [sh-while]
543 '(menu-item "While Loop" sh-while
544 :help "Insert a while loop"))
545 (define-key menu-map [sh-getopts]
546 '(menu-item "Options Loop" sh-while-getopts
547 :help "Insert a while getopts loop."))
548 (define-key menu-map [sh-indexed-loop]
549 '(menu-item "Indexed Loop" sh-indexed-loop
550 :help "Insert an indexed loop from 1 to n."))
551 (define-key menu-map [sh-select]
552 '(menu-item "Select Statement" sh-select
553 :help "Insert a select statement "))
554 (define-key menu-map [sh-if]
555 '(menu-item "If Statement" sh-if
556 :help "Insert an if statement"))
557 (define-key menu-map [sh-for]
558 '(menu-item "For Loop" sh-for
559 :help "Insert a for loop"))
560 (define-key menu-map [sh-case]
561 '(menu-item "Case Statement" sh-case
562 :help "Insert a case/switch statement"))
563 (define-key menu-map [sh-s1] '("--"))
564 (define-key menu-map [sh-exec]
565 '(menu-item "Execute region" sh-execute-region
566 :help "Pass optional header and region to a subshell for noninteractive execution"))
567 (define-key menu-map [sh-exec-interpret]
568 '(menu-item "Execute script..." executable-interpret
569 :help "Run script with user-specified args, and collect output in a buffer"))
570 (define-key menu-map [sh-set-shell]
571 '(menu-item "Set shell type..." sh-set-shell
572 :help "Set this buffer's shell to SHELL (a string)"))
573 (define-key menu-map [sh-backslash-region]
574 '(menu-item "Backslash region" sh-backslash-region
575 :help "Insert, align, or delete end-of-line backslashes on the lines in the region."))
577 "Keymap used in Shell-Script mode.")
579 (defvar sh-skeleton-pair-default-alist '((?( _ ?)) (?\))
580 (?[ ?\s _ ?\s ?]) (?\])
582 "Value to use for `skeleton-pair-default-alist' in Shell-Script mode.")
584 (defcustom sh-dynamic-complete-functions
585 '(shell-environment-variable-completion
586 shell-command-completion
587 comint-filename-completion)
588 "Functions for doing TAB dynamic completion."
589 :type '(repeat function)
592 (defcustom sh-assignment-regexp
593 `((csh . "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?[ \t]*[-+*/%^]?=")
594 ;; actually spaces are only supported in let/(( ... ))
595 (ksh88 . ,(concat "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?"
596 "[ \t]*\\(?:[-+*/%&|~^]\\|<<\\|>>\\)?="))
597 (bash . "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?\\+?=")
598 (rc . "\\<\\([[:alnum:]_*]+\\)[ \t]*=")
599 (sh . "\\<\\([[:alnum:]_]+\\)="))
600 "Regexp for the variable name and what may follow in an assignment.
601 First grouping matches the variable name. This is upto and including the `='
602 sign. See `sh-feature'."
603 :type '(repeat (cons (symbol :tag "Shell")
605 (sexp :format "Evaluate: %v"))))
609 (defcustom sh-indentation 4
610 "The width for further indentation in Shell-Script mode."
613 (put 'sh-indentation 'safe-local-variable 'integerp)
615 (defcustom sh-remember-variable-min 3
616 "Don't remember variables less than this length for completing reads."
621 (defvar sh-header-marker nil
622 "When non-nil is the end of header for prepending by \\[sh-execute-region].
623 That command is also used for setting this variable.")
624 (make-variable-buffer-local 'sh-header-marker)
626 (defcustom sh-beginning-of-command
627 "\\([;({`|&]\\|\\`\\|[^\\]\n\\)[ \t]*\\([/~[:alnum:]:]\\)"
628 "Regexp to determine the beginning of a shell command.
629 The actual command starts at the beginning of the second \\(grouping\\)."
634 (defcustom sh-end-of-command
635 "\\([/~[:alnum:]:]\\)[ \t]*\\([;#)}`|&]\\|$\\)"
636 "Regexp to determine the end of a shell command.
637 The actual command ends at the end of the first \\(grouping\\)."
643 (defcustom sh-here-document-word "EOF"
644 "Word to delimit here documents.
645 If the first character of this string is \"-\", this is taken as
646 part of the redirection operator, rather than part of the
647 word (that is, \"<<-\" instead of \"<<\"). This is a feature
648 used by some shells (for example Bash) to indicate that leading
649 tabs inside the here document should be ignored. In this case,
650 Emacs indents the initial body and end of the here document with
651 tabs, to the same level as the start (note that apart from this
652 there is no support for indentation of here documents). This
653 will only work correctly if `sh-basic-offset' is a multiple of
656 Any quote characters or leading whitespace in the word are
657 removed when closing the here document."
665 "Initial input in Bourne if, while and until skeletons. See `sh-feature'.")
668 ;; customized this out of sheer bravado. not for the faint of heart.
669 ;; but it *did* have an asterisk in the docstring!
670 (defcustom sh-builtins
671 '((bash sh-append posix
672 "." "alias" "bg" "bind" "builtin" "caller" "compgen" "complete"
673 "declare" "dirs" "disown" "enable" "fc" "fg" "help" "history"
674 "jobs" "kill" "let" "local" "popd" "printf" "pushd" "shopt"
675 "source" "suspend" "typeset" "unalias"
677 "mapfile" "readarray")
679 ;; The next entry is only used for defining the others
680 (bourne sh-append shell
681 "eval" "export" "getopts" "newgrp" "pwd" "read" "readonly"
685 "alias" "chdir" "glob" "history" "limit" "nice" "nohup" "rehash"
686 "setenv" "source" "time" "unalias" "unhash")
688 (dtksh sh-append wksh)
690 (es "access" "apids" "cd" "echo" "eval" "false" "let" "limit" "local"
691 "newpgrp" "result" "time" "umask" "var" "vars" "wait" "whatis")
694 "bg" "fg" "jobs" "kill" "stop" "suspend")
697 "bg" "fg" "jobs" "kill" "notify" "stop" "suspend")
699 (ksh88 sh-append bourne
700 "alias" "bg" "false" "fc" "fg" "jobs" "kill" "let" "print" "time"
701 "typeset" "unalias" "whence")
704 "checkwin" "dateline" "error" "form" "menu" "newwin" "oadeinit"
705 "oaed" "oahelp" "oainit" "pp" "ppfile" "scan" "scrollok" "wattr"
706 "wclear" "werase" "win" "wmclose" "wmmessage" "wmopen" "wmove"
707 "wmtitle" "wrefresh")
709 (pdksh sh-append ksh88
715 (rc "builtin" "cd" "echo" "eval" "limit" "newpgrp" "shift" "umask" "wait"
719 "hash" "test" "type")
721 ;; The next entry is only used for defining the others
722 (shell "cd" "echo" "eval" "set" "shift" "umask" "unset" "wait")
724 (wksh sh-append ksh88
725 ;; FIXME: This looks too much like a regexp. --Stef
729 "autoload" "bindkey" "builtin" "chdir" "compctl" "declare" "dirs"
730 "disable" "disown" "echotc" "enable" "functions" "getln" "hash"
731 "history" "integer" "limit" "local" "log" "popd" "pushd" "r"
732 "readonly" "rehash" "sched" "setopt" "source" "suspend" "true"
733 "ttyctl" "type" "unfunction" "unhash" "unlimit" "unsetopt" "vared"
735 "List of all shell builtins for completing read and fontification.
736 Note that on some systems not all builtins are available or some are
737 implemented as aliases. See `sh-feature'."
738 :type '(repeat (cons (symbol :tag "Shell")
739 (choice (repeat string)
740 (sexp :format "Evaluate: %v"))))
741 :version "24.4" ; bash4 additions
746 (defcustom sh-leading-keywords
752 (es "true" "unwind-protect" "whatis")
756 (sh "!" "do" "elif" "else" "if" "then" "trap" "type" "until" "while"))
757 "List of keywords that may be immediately followed by a builtin or keyword.
758 Given some confusion between keywords and builtins depending on shell and
759 system, the distinction here has been based on whether they influence the
760 flow of control or syntax. See `sh-feature'."
761 :type '(repeat (cons (symbol :tag "Shell")
762 (choice (repeat string)
763 (sexp :format "Evaluate: %v"))))
767 (defcustom sh-other-keywords
768 '((bash sh-append bourne
769 "bye" "logout" "select")
771 ;; The next entry is only used for defining the others
776 "breaksw" "default" "end" "endif" "endsw" "foreach" "goto"
777 "if" "logout" "onintr" "repeat" "switch" "then" "while")
779 (es "break" "catch" "exec" "exit" "fn" "for" "forever" "fork" "if"
780 "return" "throw" "while")
782 (ksh88 sh-append bourne
785 (rc "break" "case" "exec" "exit" "fn" "for" "if" "in" "return" "switch"
789 "done" "esac" "fi" "for" "in" "return")
791 ;; The next entry is only used for defining the others
792 (shell "break" "case" "continue" "exec" "exit")
796 "List of keywords not in `sh-leading-keywords'.
798 :type '(repeat (cons (symbol :tag "Shell")
799 (choice (repeat string)
800 (sexp :format "Evaluate: %v"))))
807 "allow_null_glob_expansion" "auto_resume" "BASH" "BASH_ENV"
808 "BASH_VERSINFO" "BASH_VERSION" "cdable_vars" "COMP_CWORD"
809 "COMP_LINE" "COMP_POINT" "COMP_WORDS" "COMPREPLY" "DIRSTACK"
810 "ENV" "EUID" "FCEDIT" "FIGNORE" "FUNCNAME"
811 "glob_dot_filenames" "GLOBIGNORE" "GROUPS" "histchars"
812 "HISTCMD" "HISTCONTROL" "HISTFILE" "HISTFILESIZE"
813 "HISTIGNORE" "history_control" "HISTSIZE"
814 "hostname_completion_file" "HOSTFILE" "HOSTTYPE" "IGNOREEOF"
815 "ignoreeof" "INPUTRC" "LINENO" "MACHTYPE" "MAIL_WARNING"
816 "noclobber" "nolinks" "notify" "no_exit_on_failed_exec"
817 "NO_PROMPT_VARS" "OLDPWD" "OPTERR" "OSTYPE" "PIPESTATUS"
818 "PPID" "POSIXLY_CORRECT" "PROMPT_COMMAND" "PS3" "PS4"
819 "pushd_silent" "PWD" "RANDOM" "REPLY" "SECONDS" "SHELLOPTS"
820 "SHLVL" "TIMEFORMAT" "TMOUT" "UID")
823 "argv" "cdpath" "child" "echo" "histchars" "history" "home"
824 "ignoreeof" "mail" "noclobber" "noglob" "nonomatch" "path" "prompt"
825 "shell" "status" "time" "verbose")
828 "apid" "cdpath" "CDPATH" "history" "home" "ifs" "noexport" "path"
829 "pid" "prompt" "signals")
835 "ENV" "ERRNO" "FCEDIT" "FPATH" "HISTFILE" "HISTSIZE" "LINENO"
836 "OLDPWD" "PPID" "PS3" "PS4" "PWD" "RANDOM" "REPLY" "SECONDS"
840 "FIELD" "FIELD_MAX" "LAST_KEY" "OALIB" "PP_ITEM" "PP_NUM")
843 "apid" "apids" "cdpath" "CDPATH" "history" "home" "ifs" "path" "pid"
847 "CDPATH" "IFS" "OPTARG" "OPTIND" "PS1" "PS2")
849 ;; The next entry is only used for defining the others
850 (shell "COLUMNS" "EDITOR" "HOME" "HUSHLOGIN" "LANG" "LC_COLLATE"
851 "LC_CTYPE" "LC_MESSAGES" "LC_MONETARY" "LC_NUMERIC" "LC_TIME"
852 "LINES" "LOGNAME" "MAIL" "MAILCHECK" "MAILPATH" "PAGER" "PATH"
853 "SHELL" "TERM" "TERMCAP" "TERMINFO" "VISUAL")
856 "addsuffix" "ampm" "autocorrect" "autoexpand" "autolist"
857 "autologout" "chase_symlinks" "correct" "dextract" "edit" "el"
858 "fignore" "gid" "histlit" "HOST" "HOSTTYPE" "HPATH"
859 "ignore_symlinks" "listjobs" "listlinks" "listmax" "matchbeep"
860 "nobeep" "NOREBIND" "oid" "printexitvalue" "prompt2" "prompt3"
861 "pushdsilent" "pushdtohome" "recexact" "recognize_only_executables"
862 "rmstar" "savehist" "SHLVL" "showdots" "sl" "SYSTYPE" "tcsh" "term"
863 "tperiod" "tty" "uid" "version" "visiblebell" "watch" "who"
867 "BAUD" "bindcmds" "cdpath" "DIRSTACKSIZE" "fignore" "FIGNORE" "fpath"
868 "HISTCHARS" "hostcmds" "hosts" "HOSTS" "LISTMAX" "LITHISTSIZE"
869 "LOGCHECK" "mailpath" "manpath" "NULLCMD" "optcmds" "path" "POSTEDIT"
870 "prompt" "PROMPT" "PROMPT2" "PROMPT3" "PROMPT4" "psvar" "PSVAR"
871 "READNULLCMD" "REPORTTIME" "RPROMPT" "RPS1" "SAVEHIST" "SPROMPT"
872 "STTY" "TIMEFMT" "TMOUT" "TMPPREFIX" "varcmds" "watch" "WATCH"
873 "WATCHFMT" "WORDCHARS" "ZDOTDIR"))
874 "List of all shell variables available for completing read.
881 '((((min-colors 88) (class color)
883 (:foreground "yellow1" :weight bold))
886 (:foreground "yellow" :weight bold))
889 (:foreground "tan1" ))
892 "Face to show a here-document"
893 :group 'sh-indentation)
895 ;; These colors are probably icky. It's just a placeholder though.
896 (defface sh-quoted-exec
897 '((((class color) (background dark))
898 (:foreground "salmon"))
899 (((class color) (background light))
900 (:foreground "magenta"))
903 "Face to show quoted execs like ``"
904 :group 'sh-indentation)
905 (define-obsolete-face-alias 'sh-heredoc-face 'sh-heredoc "22.1")
906 (defvar sh-heredoc-face 'sh-heredoc)
908 (defface sh-escaped-newline '((t :inherit font-lock-string-face))
909 "Face used for (non-escaped) backslash at end of a line in Shell-script mode."
913 (defvar sh-font-lock-keywords-var
914 '((csh sh-append shell
915 ("\\${?[#?]?\\([[:alpha:]_][[:alnum:]_]*\\|0\\)" 1
916 font-lock-variable-name-face))
918 (es sh-append executable-font-lock-keywords
919 ("\\$#?\\([[:alpha:]_][[:alnum:]_]*\\|[0-9]+\\)" 1
920 font-lock-variable-name-face))
923 (bash sh-append sh ("\\$(\\(\\sw+\\)" (1 'sh-quoted-exec t) ))
926 ("\\$\\({#?\\)?\\([[:alpha:]_][[:alnum:]_]*\\|[-#?@!]\\)" 2
927 font-lock-variable-name-face)
929 ("^\\(\\sw+\\)[ \t]*(" 1 font-lock-function-name-face)
930 ("\\<\\(function\\)\\>[ \t]*\\(\\sw+\\)?"
931 (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))
932 ("\\(?:^\\s *\\|[[();&|]\\s *\\|\\(?:\\s +-[ao]\\|if\\|else\\|then\\|while\\|do\\)\\s +\\)\\(!\\)"
933 1 font-lock-negation-char-face))
935 ;; The next entry is only used for defining the others
937 ;; Using font-lock-string-face here confuses sh-get-indent-info.
938 ("\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\\\)$" 3 'sh-escaped-newline)
939 ("\\\\[^[:alnum:]]" 0 font-lock-string-face)
940 ("\\${?\\([[:alpha:]_][[:alnum:]_]*\\|[0-9]+\\|[$*_]\\)" 1
941 font-lock-variable-name-face))
943 ("%{?\\(\\sw+\\)" 1 font-lock-keyword-face))
944 (rpm2 sh-append shell
945 ("^\\(\\sw+\\):" 1 font-lock-variable-name-face)))
946 "Default expressions to highlight in Shell Script modes. See `sh-feature'.")
948 (defvar sh-font-lock-keywords-var-1
950 "Subdued level highlighting for Shell Script modes.")
952 (defvar sh-font-lock-keywords-var-2 ()
953 "Gaudy level highlighting for Shell Script modes.")
955 ;; These are used for the syntax table stuff (derived from cperl-mode).
956 ;; Note: parse-sexp-lookup-properties must be set to t for it to work.
957 (defconst sh-st-punc (string-to-syntax "."))
958 (defconst sh-here-doc-syntax (string-to-syntax "|")) ;; generic string
961 (defconst sh-escaped-line-re
962 ;; Should match until the real end-of-continued-line, but if that is not
963 ;; possible (because we bump into EOB or the search bound), then we should
964 ;; match until the search bound.
965 "\\(?:\\(?:.*[^\\\n]\\)?\\(?:\\\\\\\\\\)*\\\\\n\\)*.*")
967 (defconst sh-here-doc-open-re
968 (concat "<<-?\\s-*\\\\?\\(\\(?:['\"][^'\"]+['\"]\\|\\sw\\|[-/~._]\\)+\\)"
969 sh-escaped-line-re "\\(\n\\)")))
971 (defun sh--inside-noncommand-expression (pos)
973 (let ((ppss (syntax-ppss pos)))
975 (goto-char (nth 1 ppss))
977 ;; $((...)) or $[...] or ${...}.
978 (`?\( (and (eq ?\( (char-before))
979 (eq ?\$ (char-before (1- (point))))))
980 ((or `?\{ `?\[) (eq ?\$ (char-before))))))))
982 (defun sh-font-lock-open-heredoc (start string eol)
983 "Determine the syntax of the \\n after a <<EOF.
984 START is the position of <<.
985 STRING is the actual word used as delimiter (e.g. \"EOF\").
986 INDENTED is non-nil if the here document's content (and the EOF mark) can
987 be indented (i.e. a <<- was used rather than just <<).
988 Point is at the beginning of the next line."
989 (unless (or (memq (char-before start) '(?< ?>))
990 (sh-in-comment-or-string start)
991 (sh--inside-noncommand-expression start))
992 ;; We're looking at <<STRING, so we add "^STRING$" to the syntactic
993 ;; font-lock keywords to detect the end of this here document.
994 (let ((str (replace-regexp-in-string "['\"]" "" string))
995 (ppss (save-excursion (syntax-ppss eol))))
997 ;; The \n not only starts the heredoc but also closes a comment.
998 ;; Let's close the comment just before the \n.
999 (put-text-property (1- eol) eol 'syntax-table '(12))) ;">"
1000 (if (or (nth 5 ppss) (> (count-lines start eol) 1))
1001 ;; If the sh-escaped-line-re part of sh-here-doc-open-re has matched
1002 ;; several lines, make sure we refontify them together.
1003 ;; Furthermore, if (nth 5 ppss) is non-nil (i.e. the \n is
1004 ;; escaped), it means the right \n is actually further down.
1005 ;; Don't bother fixing it now, but place a multiline property so
1006 ;; that when jit-lock-context-* refontifies the rest of the
1007 ;; buffer, it also refontifies the current line with it.
1008 (put-text-property start (1+ eol) 'syntax-multiline t))
1009 (put-text-property eol (1+ eol) 'sh-here-doc-marker str)
1010 (prog1 sh-here-doc-syntax
1011 (goto-char (+ 2 start))))))
1013 (defun sh-syntax-propertize-here-doc (end)
1014 (let ((ppss (syntax-ppss)))
1015 (when (eq t (nth 3 ppss))
1016 (let ((key (get-text-property (nth 8 ppss) 'sh-here-doc-marker))
1017 (case-fold-search nil))
1018 (when (re-search-forward
1019 (concat "^\\([ \t]*\\)" (regexp-quote key) "\\(\n\\)")
1021 (let ((eol (match-beginning 2)))
1022 (put-text-property eol (1+ eol)
1023 'syntax-table sh-here-doc-syntax)))))))
1025 (defun sh-font-lock-quoted-subshell (limit)
1026 "Search for a subshell embedded in a string.
1027 Find all the unescaped \" characters within said subshell, remembering that
1028 subshells can nest."
1029 ;; FIXME: This can (and often does) match multiple lines, yet it makes no
1030 ;; effort to handle multiline cases correctly, so it ends up being
1032 (when (eq ?\" (nth 3 (syntax-ppss))) ; Check we matched an opening quote.
1033 ;; bingo we have a $( or a ` inside a ""
1034 (let (;; `state' can be: double-quote, backquote, code.
1035 (state (if (eq (char-before) ?`) 'backquote 'code))
1036 ;; Stacked states in the context.
1037 (states '(double-quote)))
1038 (while (and state (progn (skip-chars-forward "^'\\\\\"`$()" limit)
1040 ;; unescape " inside a $( ... ) construct.
1044 (_ (forward-char 1) (skip-chars-forward "^'" limit))))
1045 (?\\ (forward-char 1))
1047 (`double-quote (setq state (pop states)))
1048 (_ (push state states) (setq state 'double-quote)))
1049 (if state (put-text-property (point) (1+ (point))
1050 'syntax-table '(1))))
1052 (`backquote (setq state (pop states)))
1053 (_ (push state states) (setq state 'backquote))))
1054 (?\$ (if (not (eq (char-after (1+ (point))) ?\())
1058 (_ (push state states) (setq state 'code)))))
1061 (_ (push state states) (setq state 'code))))
1064 (_ (setq state (pop states)))))
1065 (_ (error "Internal error in sh-font-lock-quoted-subshell")))
1066 (forward-char 1)))))
1069 (defun sh-is-quoted-p (pos)
1070 (and (eq (char-before pos) ?\\)
1071 (not (sh-is-quoted-p (1- pos)))))
1073 (defun sh-font-lock-paren (start)
1074 (unless (nth 8 (syntax-ppss))
1078 ;; Skip through all patterns
1083 (forward-comment (- (point-max)))
1084 (when (and (eolp) (sh-is-quoted-p (point)))
1087 ;; Skip through one pattern
1089 (or (/= 0 (skip-syntax-backward "w_"))
1090 (/= 0 (skip-chars-backward "-$=?[]*@/\\\\"))
1091 (and (sh-is-quoted-p (1- (point)))
1092 (goto-char (- (point) 2)))
1093 (when (memq (char-before) '(?\" ?\' ?\}))
1094 (condition-case nil (progn (backward-sexp 1) t)
1096 ;; Patterns can be preceded by an open-paren (bug#1320).
1097 (when (eq (char-before (point)) ?\()
1099 (setq open (point)))
1101 (forward-comment (- (point-max)))
1102 ;; Maybe we've bumped into an escaped newline.
1103 (sh-is-quoted-p (point)))
1105 (when (eq (char-before) ?|)
1106 (backward-char 1) t)))
1107 (and (> (point) (1+ (point-min)))
1108 (progn (backward-char 2)
1109 (if (> start (line-end-position))
1110 (put-text-property (point) (1+ start)
1111 'syntax-multiline t))
1112 ;; FIXME: The `in' may just be a random argument to
1113 ;; a normal command rather than the real `in' keyword.
1114 ;; I.e. we should look back to try and find the
1115 ;; corresponding `case'.
1116 (and (looking-at ";[;&]\\|\\_<in")
1117 ;; ";; esac )" is a case that looks
1118 ;; like a case-pattern but it's really just a close
1119 ;; paren after a case statement. I.e. if we skipped
1120 ;; over `esac' just now, we're not looking
1121 ;; at a case-pattern.
1122 (not (looking-at "..[ \t\n]+esac[^[:word:]_]"))))
1125 (put-text-property open (1+ open) 'syntax-table sh-st-punc))
1128 (defun sh-font-lock-backslash-quote ()
1129 (if (eq (save-excursion (nth 3 (syntax-ppss (match-beginning 0)))) ?\')
1130 ;; In a '...' the backslash is not escaping.
1134 (defun sh-syntax-propertize-function (start end)
1136 (sh-syntax-propertize-here-doc end)
1138 (syntax-propertize-rules
1139 (sh-here-doc-open-re
1140 (2 (sh-font-lock-open-heredoc
1141 (match-beginning 0) (match-string 1) (match-beginning 2))))
1142 ("\\s|" (0 (prog1 nil (sh-syntax-propertize-here-doc end))))
1143 ;; A `#' begins a comment when it is unquoted and at the
1144 ;; beginning of a word. In the shell, words are separated by
1145 ;; metacharacters. The list of special chars is taken from
1146 ;; the single-unix spec of the shell command language (under
1147 ;; `quoting') but with `$' removed.
1148 ("\\(?:[^|&;<>()`\\\"' \t\n]\\|\\${\\)\\(#+\\)" (1 "_"))
1149 ;; In a '...' the backslash is not escaping.
1150 ("\\(\\\\\\)'" (1 (sh-font-lock-backslash-quote)))
1151 ;; Make sure $@ and $? are correctly recognized as sexps.
1152 ("\\$\\([?@]\\)" (1 "_"))
1153 ;; Distinguish the special close-paren in `case'.
1154 (")" (0 (sh-font-lock-paren (match-beginning 0))))
1155 ;; Highlight (possibly nested) subshells inside "" quoted
1156 ;; regions correctly.
1157 ("\"\\(?:\\(?:[^\\\"]\\|\\\\.\\)*?\\)??\\(\\$(\\|`\\)"
1159 (if (nth 8 (save-excursion (syntax-ppss (match-beginning 0))))
1160 (goto-char (1+ (match-beginning 0)))
1161 ;; Save excursion because we want to also apply other
1162 ;; syntax-propertize rules within the affected region.
1164 (sh-font-lock-quoted-subshell end)))))))
1166 (defun sh-font-lock-syntactic-face-function (state)
1167 (let ((q (nth 3 state)))
1170 (if (eq q ?\`) 'sh-quoted-exec font-lock-string-face)
1172 font-lock-comment-face)))
1174 (defgroup sh-indentation nil
1175 "Variables controlling indentation in shell scripts.
1177 Note: customizing these variables will not affect existing buffers if
1178 `sh-make-vars-local' is non-nil. See the documentation for
1179 variable `sh-make-vars-local', command `sh-make-vars-local'
1180 and command `sh-reset-indent-vars-to-global-values'."
1184 (defcustom sh-set-shell-hook nil
1185 "Hook run by `sh-set-shell'."
1189 (defcustom sh-mode-hook nil
1190 "Hook run by `sh-mode'."
1194 (defcustom sh-learn-basic-offset nil
1195 "When `sh-guess-basic-offset' should learn `sh-basic-offset'.
1198 t means: only if there seems to be an obvious value.
1199 Anything else means: whenever we have a \"good guess\" as to the value."
1201 (const :tag "Never" nil)
1202 (const :tag "Only if sure" t)
1203 (const :tag "If have a good guess" usually))
1204 :group 'sh-indentation)
1206 (defcustom sh-popup-occur-buffer nil
1207 "Controls when `sh-learn-buffer-indent' pops the `*indent*' buffer.
1208 If t it is always shown. If nil, it is shown only when there
1211 (const :tag "Only when there are conflicts." nil)
1212 (const :tag "Always" t))
1213 :group 'sh-indentation)
1215 (defcustom sh-blink t
1216 "If non-nil, `sh-show-indent' shows the line indentation is relative to.
1217 The position on the line is not necessarily meaningful.
1218 In some cases the line will be the matching keyword, but this is not
1221 :group 'sh-indentation)
1223 (defcustom sh-first-lines-indent 0
1224 "The indentation of the first non-blank non-comment line.
1225 Usually 0 meaning first column.
1226 Can be set to a number, or to nil which means leave it as is."
1228 (const :tag "Leave as is" nil)
1229 (integer :tag "Column number"
1230 :menu-tag "Indent to this col (0 means first col)" ))
1231 :group 'sh-indentation)
1234 (defcustom sh-basic-offset 4
1235 "The default indentation increment.
1236 This value is used for the `+' and `-' symbols in an indentation variable."
1238 :group 'sh-indentation)
1239 (put 'sh-basic-offset 'safe-local-variable 'integerp)
1241 (defcustom sh-indent-comment t
1242 "How a comment line is to be indented.
1243 nil means leave it as it is;
1244 t means indent it as a normal line, aligning it to previous non-blank
1246 a number means align to that column, e.g. 0 means first column."
1248 (const :tag "Leave as is." nil)
1249 (const :tag "Indent as a normal line." t)
1250 (integer :menu-tag "Indent to this col (0 means first col)."
1251 :tag "Indent to column number.") )
1253 :group 'sh-indentation)
1256 (defvar sh-debug nil
1257 "Enable lots of debug messages - if function `sh-debug' is enabled.")
1260 ;; Uncomment this defun and comment the defmacro for debugging.
1261 ;; (defun sh-debug (&rest args)
1262 ;; "For debugging: display message ARGS if variable SH-DEBUG is non-nil."
1264 ;; (apply 'message args)))
1265 (defmacro sh-debug (&rest _args))
1267 (defconst sh-symbol-list
1268 '((const :tag "+ " :value +
1269 :menu-tag "+ Indent right by sh-basic-offset")
1270 (const :tag "- " :value -
1271 :menu-tag "- Indent left by sh-basic-offset")
1272 (const :tag "++" :value ++
1273 :menu-tag "++ Indent right twice sh-basic-offset")
1274 (const :tag "--" :value --
1275 :menu-tag "-- Indent left twice sh-basic-offset")
1276 (const :tag "* " :value *
1277 :menu-tag "* Indent right half sh-basic-offset")
1278 (const :tag "/ " :value /
1279 :menu-tag "/ Indent left half sh-basic-offset")))
1281 (defcustom sh-indent-for-else 0
1282 "How much to indent an `else' relative to its `if'. Usually 0."
1284 (integer :menu-tag "A number (positive=>indent right)"
1286 (const :tag "--") ;; separator!
1289 :group 'sh-indentation)
1291 (defconst sh-number-or-symbol-list
1292 (append '((integer :menu-tag "A number (positive=>indent right)"
1294 (const :tag "--")) ; separator
1297 (defcustom sh-indent-for-fi 0
1298 "How much to indent a `fi' relative to its `if'. Usually 0."
1299 :type `(choice ,@ sh-number-or-symbol-list )
1300 :group 'sh-indentation)
1302 (defcustom sh-indent-for-done 0
1303 "How much to indent a `done' relative to its matching stmt. Usually 0."
1304 :type `(choice ,@ sh-number-or-symbol-list )
1305 :group 'sh-indentation)
1307 (defcustom sh-indent-after-else '+
1308 "How much to indent a statement after an `else' statement."
1309 :type `(choice ,@ sh-number-or-symbol-list )
1310 :group 'sh-indentation)
1312 (defcustom sh-indent-after-if '+
1313 "How much to indent a statement after an `if' statement.
1314 This includes lines after `else' and `elif' statements, too, but
1315 does not affect the `else', `elif' or `fi' statements themselves."
1316 :type `(choice ,@ sh-number-or-symbol-list )
1317 :group 'sh-indentation)
1319 (defcustom sh-indent-for-then 0
1320 "How much to indent a `then' relative to its `if'."
1321 :type `(choice ,@ sh-number-or-symbol-list )
1322 :group 'sh-indentation)
1324 (defcustom sh-indent-for-do 0
1325 "How much to indent a `do' statement.
1326 This is relative to the statement before the `do', typically a
1327 `while', `until', `for', `repeat' or `select' statement."
1328 :type `(choice ,@ sh-number-or-symbol-list)
1329 :group 'sh-indentation)
1331 (defcustom sh-indent-after-do '+
1332 "How much to indent a line after a `do' statement.
1333 This is used when the `do' is the first word of the line.
1334 This is relative to the statement before the `do', typically a
1335 `while', `until', `for', `repeat' or `select' statement."
1336 :type `(choice ,@ sh-number-or-symbol-list)
1337 :group 'sh-indentation)
1339 (defcustom sh-indent-after-loop-construct '+
1340 "How much to indent a statement after a loop construct.
1342 This variable is used when the keyword `do' is on the same line as the
1343 loop statement (e.g., `until', `while' or `for').
1344 If the `do' is on a line by itself, then `sh-indent-after-do' is used instead."
1345 :type `(choice ,@ sh-number-or-symbol-list)
1346 :group 'sh-indentation)
1349 (defcustom sh-indent-after-done 0
1350 "How much to indent a statement after a `done' keyword.
1351 Normally this is 0, which aligns the `done' to the matching
1352 looping construct line.
1353 Setting it non-zero allows you to have the `do' statement on a line
1354 by itself and align the done under to do."
1355 :type `(choice ,@ sh-number-or-symbol-list)
1356 :group 'sh-indentation)
1358 (defcustom sh-indent-for-case-label '+
1359 "How much to indent a case label statement.
1360 This is relative to the line containing the `case' statement."
1361 :type `(choice ,@ sh-number-or-symbol-list)
1362 :group 'sh-indentation)
1364 (defcustom sh-indent-for-case-alt '++
1365 "How much to indent statements after the case label.
1366 This is relative to the line containing the `case' statement."
1367 :type `(choice ,@ sh-number-or-symbol-list)
1368 :group 'sh-indentation)
1371 (defcustom sh-indent-for-continuation '+
1372 "How much to indent for a continuation statement."
1373 :type `(choice ,@ sh-number-or-symbol-list)
1374 :group 'sh-indentation)
1376 (defcustom sh-indent-after-open '+
1377 "How much to indent after a line with an opening parenthesis or brace.
1378 For an open paren after a function, `sh-indent-after-function' is used."
1379 :type `(choice ,@ sh-number-or-symbol-list)
1380 :group 'sh-indentation)
1382 (defcustom sh-indent-after-function '+
1383 "How much to indent after a function line."
1384 :type `(choice ,@ sh-number-or-symbol-list)
1385 :group 'sh-indentation)
1387 ;; These 2 are for the rc shell:
1389 (defcustom sh-indent-after-switch '+
1390 "How much to indent a `case' statement relative to the `switch' statement.
1391 This is for the rc shell."
1392 :type `(choice ,@ sh-number-or-symbol-list)
1393 :group 'sh-indentation)
1395 (defcustom sh-indent-after-case '+
1396 "How much to indent a statement relative to the `case' statement.
1397 This is for the rc shell."
1398 :type `(choice ,@ sh-number-or-symbol-list)
1399 :group 'sh-indentation)
1401 (defcustom sh-backslash-column 48
1402 "Column in which `sh-backslash-region' inserts backslashes."
1406 (defcustom sh-backslash-align t
1407 "If non-nil, `sh-backslash-region' will align backslashes."
1411 ;; Internal use - not designed to be changed by the user:
1413 (defun sh-mkword-regexpr (word)
1414 "Make a regexp which matches WORD as a word.
1415 This specifically excludes an occurrence of WORD followed by
1416 punctuation characters like '-'."
1417 (concat word "\\([^-[:alnum:]_]\\|$\\)"))
1419 (defconst sh-re-done (sh-mkword-regexpr "done"))
1422 (defconst sh-kws-for-done
1423 '((sh . ( "while" "until" "for" ) )
1424 (bash . ( "while" "until" "for" "select" ) )
1425 (ksh88 . ( "while" "until" "for" "select" ) )
1426 (zsh . ( "while" "until" "for" "repeat" "select" ) ) )
1427 "Which keywords can match the word `done' in this shell.")
1430 (defconst sh-indent-supported
1434 "Indentation rule set to use for each shell type.")
1436 (defvar sh-indent-supported-here nil
1437 "Non-nil if we support indentation for the current buffer's shell type.")
1439 (defconst sh-var-list
1441 sh-basic-offset sh-first-lines-indent sh-indent-after-case
1442 sh-indent-after-do sh-indent-after-done
1443 sh-indent-after-else
1445 sh-indent-after-loop-construct
1446 sh-indent-after-open
1448 sh-indent-for-case-alt
1449 sh-indent-for-case-label
1450 sh-indent-for-continuation
1457 "A list of variables used by script mode to control indentation.
1458 This list is used when switching between buffer-local and global
1459 values of variables, and for the commands using indentation styles.")
1461 (defvar sh-make-vars-local t
1462 "Controls whether indentation variables are local to the buffer.
1463 If non-nil, indentation variables are made local initially.
1464 If nil, you can later make the variables local by invoking
1465 command `sh-make-vars-local'.
1466 The default is t because I assume that in one Emacs session one is
1467 frequently editing existing scripts with different styles.")
1470 ;; inferior shell interaction
1471 ;; TODO: support multiple interactive shells
1472 (defvar-local sh-shell-process nil
1473 "The inferior shell process for interaction.")
1475 (defvar explicit-shell-file-name)
1477 (defun sh-shell-process (force)
1478 "Get a shell process for interaction.
1479 If FORCE is non-nil and no process found, create one."
1480 (if (and sh-shell-process (process-live-p sh-shell-process))
1482 (setq sh-shell-process
1483 (let ((found nil) proc
1484 (procs (process-list)))
1485 (while (and (not found) procs
1486 (process-live-p (setq proc (pop procs)))
1487 (process-command proc))
1488 (when (string-equal sh-shell (file-name-nondirectory
1489 (car (process-command proc))))
1494 (let ((explicit-shell-file-name sh-shell-file))
1497 (defun sh-show-shell ()
1498 "Pop the shell interaction buffer."
1500 (pop-to-buffer (process-buffer (sh-shell-process t))))
1502 (defun sh-send-text (text)
1503 "Send the text to the `sh-shell-process'."
1504 (comint-send-string (sh-shell-process t) (concat text "\n")))
1506 (defun sh-cd-here ()
1507 "Change directory in the current interaction shell to the current one."
1509 (sh-send-text (concat "cd " default-directory)))
1511 (defun sh-send-line-or-region-and-step ()
1512 "Send the current line to the inferior shell and step to the next line.
1513 When the region is active, send the region instead."
1517 (setq from (region-beginning)
1520 (setq from (line-beginning-position)
1521 to (line-end-position)
1523 (sh-send-text (buffer-substring-no-properties from to))
1527 ;; mode-command and utility functions
1530 (define-derived-mode sh-mode prog-mode "Shell-script"
1531 "Major mode for editing shell scripts.
1532 This mode works for many shells, since they all have roughly the same syntax,
1533 as far as commands, arguments, variables, pipes, comments etc. are concerned.
1534 Unless the file's magic number indicates the shell, your usual shell is
1535 assumed. Since filenames rarely give a clue, they are not further analyzed.
1537 This mode adapts to the variations between shells (see `sh-set-shell') by
1538 means of an inheritance based feature lookup (see `sh-feature'). This
1539 mechanism applies to all variables (including skeletons) that pertain to
1540 shell-specific features.
1542 The default style of this mode is that of Rosenblatt's Korn shell book.
1543 The syntax of the statements varies with the shell being used. The
1544 following commands are available, based on the current shell's syntax:
1546 \\[sh-case] case statement
1548 \\[sh-function] function definition
1549 \\[sh-if] if statement
1550 \\[sh-indexed-loop] indexed loop from 1 to n
1551 \\[sh-while-getopts] while getopts loop
1552 \\[sh-repeat] repeat loop
1553 \\[sh-select] select loop
1554 \\[sh-until] until loop
1555 \\[sh-while] while loop
1557 For sh and rc shells indentation commands are:
1558 \\[sh-show-indent] Show the variable controlling this line's indentation.
1559 \\[sh-set-indent] Set then variable controlling this line's indentation.
1560 \\[sh-learn-line-indent] Change the indentation variable so this line
1561 would indent to the way it currently is.
1562 \\[sh-learn-buffer-indent] Set the indentation variables so the
1563 buffer indents as it currently is indented.
1566 \\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
1567 \\[newline-and-indent] Delete unquoted space and indent new line same as this one.
1568 \\[sh-end-of-command] Go to end of successive commands.
1569 \\[sh-beginning-of-command] Go to beginning of successive commands.
1570 \\[sh-set-shell] Set this buffer's shell, and maybe its magic number.
1571 \\[sh-execute-region] Have optional header and region be executed in a subshell.
1573 `sh-electric-here-document-mode' controls whether insertion of two
1574 unquoted < insert a here document.
1576 If you generally program a shell different from your login shell you can
1577 set `sh-shell-file' accordingly. If your shell's file name doesn't correctly
1578 indicate what shell it is use `sh-alias-alist' to translate.
1580 If your shell gives error messages with line numbers, you can use \\[executable-interpret]
1581 with your script for an edit-interpret-debug cycle."
1582 (make-local-variable 'sh-shell-file)
1583 (make-local-variable 'sh-shell)
1585 (setq-local skeleton-pair-default-alist
1586 sh-skeleton-pair-default-alist)
1587 (setq-local skeleton-end-hook
1588 (lambda () (or (eolp) (newline) (indent-relative))))
1590 (setq-local paragraph-start (concat page-delimiter "\\|$"))
1591 (setq-local paragraph-separate paragraph-start)
1592 (setq-local comment-start "# ")
1593 (setq-local comment-start-skip "#+[\t ]*")
1594 (setq-local local-abbrev-table sh-mode-abbrev-table)
1595 (setq-local comint-dynamic-complete-functions
1596 sh-dynamic-complete-functions)
1597 (add-hook 'completion-at-point-functions 'comint-completion-at-point nil t)
1598 ;; we can't look if previous line ended with `\'
1599 (setq-local comint-prompt-regexp "^[ \t]*")
1600 (setq-local imenu-case-fold-search nil)
1601 (setq font-lock-defaults
1602 `((sh-font-lock-keywords
1603 sh-font-lock-keywords-1 sh-font-lock-keywords-2)
1605 ((?/ . "w") (?~ . "w") (?. . "w") (?- . "w") (?_ . "w")) nil
1606 (font-lock-syntactic-face-function
1607 . sh-font-lock-syntactic-face-function)))
1608 (setq-local syntax-propertize-function #'sh-syntax-propertize-function)
1609 (add-hook 'syntax-propertize-extend-region-functions
1610 #'syntax-propertize-multiline 'append 'local)
1611 (sh-electric-here-document-mode 1)
1612 (setq-local skeleton-pair-alist '((?` _ ?`)))
1613 (setq-local skeleton-pair-filter-function 'sh-quoted-p)
1614 (setq-local skeleton-further-elements
1615 '((< '(- (min sh-indentation (current-column))))))
1616 (setq-local skeleton-filter-function 'sh-feature)
1617 (setq-local skeleton-newline-indent-rigidly t)
1618 (setq-local defun-prompt-regexp
1619 (concat "^\\(function[ \t]\\|[[:alnum:]]+[ \t]+()[ \t]+\\)"))
1620 (setq-local add-log-current-defun-function #'sh-current-defun-name)
1621 (add-hook 'completion-at-point-functions
1622 #'sh-completion-at-point-function nil t)
1623 ;; Parse or insert magic number for exec, and set all variables depending
1624 ;; on the shell thus determined.
1626 (cond ((save-excursion
1627 (goto-char (point-min))
1628 (looking-at "#![ \t]?\\([^ \t\n]*/bin/env[ \t]\\)?\\([^ \t\n]+\\)"))
1630 ((not buffer-file-name) sh-shell-file)
1631 ;; Checks that use `buffer-file-name' follow.
1632 ((string-match "\\.m?spec\\'" buffer-file-name) "rpm")
1633 ((string-match "[.]sh\\>" buffer-file-name) "sh")
1634 ((string-match "[.]bash\\>" buffer-file-name) "bash")
1635 ((string-match "[.]ksh\\>" buffer-file-name) "ksh")
1636 ((string-match "[.]csh\\>" buffer-file-name) "csh")
1637 ((equal (file-name-nondirectory buffer-file-name) ".profile") "sh")
1642 (defalias 'shell-script-mode 'sh-mode)
1645 (defun sh-font-lock-keywords (&optional keywords)
1646 "Function to get simple fontification based on `sh-font-lock-keywords'.
1647 This adds rules for comments and assignments."
1648 (sh-feature sh-font-lock-keywords-var
1649 (when (stringp (sh-feature sh-assignment-regexp))
1651 `((,(sh-feature sh-assignment-regexp)
1652 1 font-lock-variable-name-face)
1655 ,@executable-font-lock-keywords)))))
1657 (defun sh-font-lock-keywords-1 (&optional builtins)
1658 "Function to get better fontification including keywords."
1659 (let ((keywords (concat "\\([;(){}`|&]\\|^\\)[ \t]*\\(\\("
1660 (regexp-opt (sh-feature sh-leading-keywords) t)
1662 (regexp-opt (append (sh-feature sh-leading-keywords)
1663 (sh-feature sh-other-keywords))
1665 (sh-font-lock-keywords
1667 `((,(concat keywords "[ \t]+\\)?"
1668 (regexp-opt (sh-feature sh-builtins) t)
1670 (2 font-lock-keyword-face nil t)
1671 (6 font-lock-builtin-face))
1672 ,@(sh-feature sh-font-lock-keywords-var-2)))
1673 (,(concat keywords "\\)\\>")
1674 2 font-lock-keyword-face)
1675 ,@(sh-feature sh-font-lock-keywords-var-1)))))
1677 (defun sh-font-lock-keywords-2 ()
1678 "Function to get better fontification including keywords and builtins."
1679 (sh-font-lock-keywords-1 t))
1683 (defun sh--vars-before-point ()
1686 (while (re-search-backward "^[ \t]*\\([[:alnum:]_]+\\)=" nil t)
1687 (push (match-string 1) vars))
1690 ;; (defun sh--var-completion-table (string pred action)
1691 ;; (complete-with-action action (sh--vars-before-point) string pred))
1693 (defun sh--cmd-completion-table (string pred action)
1695 (append (when (fboundp 'imenu--make-index-alist)
1696 (mapcar #'car (imenu--make-index-alist)))
1697 (mapcar (lambda (v) (concat v "="))
1698 (sh--vars-before-point))
1699 (locate-file-completion-table
1700 exec-path exec-suffixes string pred t)
1701 '("if" "while" "until" "for"))))
1702 (complete-with-action action cmds string pred)))
1704 (defun sh-completion-at-point-function ()
1706 (skip-chars-forward "[:alnum:]_")
1708 (_ (skip-chars-backward "[:alnum:]_"))
1711 ((eq (char-before) ?$)
1712 (list start end (sh--vars-before-point)))
1713 ((sh-smie--keyword-p)
1714 (list start end #'sh--cmd-completion-table))))))
1716 ;;; Indentation and navigation with SMIE.
1720 ;; The SMIE code should generally be preferred, but it currently does not obey
1721 ;; the various indentation custom-vars, and it misses some important features
1722 ;; of the old code, mostly: sh-learn-line/buffer-indent, sh-show-indent,
1723 ;; sh-name/save/load-style.
1724 (defvar sh-use-smie t
1725 "Whether to use the SMIE code for navigation and indentation.")
1727 (defun sh-smie--keyword-p ()
1728 "Non-nil if we're at a keyword position.
1729 A keyword position is one where if we're looking at something that looks
1730 like a keyword, then it is a keyword."
1731 (let ((prev (funcall smie-backward-token-function)))
1732 (if (zerop (length prev))
1733 (looking-back "\\s(" (1- (point)))
1734 (assoc prev smie-grammar))))
1736 (defun sh-smie--newline-semi-p (&optional tok)
1737 "Return non-nil if a newline should be treated as a semi-colon.
1738 Here we assume that a newline should be treated as a semi-colon unless it
1739 comes right after a special keyword.
1740 This function does not pay attention to line-continuations.
1741 If TOK is nil, point should be before the newline; otherwise, TOK is the token
1742 before the newline and in that case point should be just before the token."
1745 (setq tok (funcall smie-backward-token-function)))
1746 (if (and (zerop (length tok))
1747 (looking-back "\\s(" (1- (point))))
1749 (not (numberp (nth 2 (assoc tok smie-grammar)))))))
1751 ;;;; SMIE support for `sh'.
1753 (defconst sh-smie-sh-grammar
1754 (smie-prec2->grammar
1756 '((exp) ;A constant, or a $var, or a sequence of them...
1757 (cmd ("case" exp "in" branches "esac")
1758 ("if" cmd "then" cmd "fi")
1759 ("if" cmd "then" cmd "else" cmd "fi")
1760 ("if" cmd "then" cmd "elif" cmd "then" cmd "fi")
1761 ("if" cmd "then" cmd "elif" cmd "then" cmd "else" cmd "fi")
1762 ("if" cmd "then" cmd "elif" cmd "then" cmd
1763 "elif" cmd "then" cmd "else" cmd "fi")
1764 ("while" cmd "do" cmd "done")
1765 ("until" cmd "do" cmd "done")
1766 ("for" exp "in" cmd "do" cmd "done")
1767 ("for" exp "do" cmd "done")
1768 ("select" exp "in" cmd "do" cmd "done") ;bash&zsh&ksh88.
1769 ("repeat" exp "do" cmd "done") ;zsh.
1770 (exp "always" exp) ;zsh.
1771 (cmd "|" cmd) (cmd "|&" cmd)
1772 (cmd "&&" cmd) (cmd "||" cmd)
1773 (cmd ";" cmd) (cmd "&" cmd))
1774 (rpattern (rpattern "|" rpattern))
1775 (pattern (rpattern) ("case-(" rpattern))
1776 (branches (branches ";;" branches)
1777 (branches ";&" branches) (branches ";;&" branches) ;bash.
1778 (pattern "case-)" cmd)))
1779 '((assoc ";;" ";&" ";;&"))
1780 '((assoc ";" "&") (assoc "&&" "||") (assoc "|" "|&")))))
1782 (defconst sh-smie--sh-operators
1783 (delq nil (mapcar (lambda (x)
1786 (not (string-match "\\`[a-z]" x))
1788 sh-smie-sh-grammar)))
1790 (defconst sh-smie--sh-operators-re (regexp-opt sh-smie--sh-operators))
1791 (defconst sh-smie--sh-operators-back-re
1792 (concat "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*"
1793 "\\(" sh-smie--sh-operators-re "\\)"))
1795 (defun sh-smie--sh-keyword-in-p ()
1796 "Assuming we're looking at \"in\", return non-nil if it's a keyword.
1797 Does not preserve point."
1798 (let ((forward-sexp-function nil)
1799 (words nil) ;We've seen words.
1800 (newline nil) ;We've seen newlines after the words.
1804 (setq prev (funcall smie-backward-token-function))
1806 ((zerop (length prev))
1808 (progn (cl-assert words) (setq res 'word))
1812 (scan-error (setq res 'unknown)))))
1814 (if words (setq newline t)
1815 (setq res 'keyword)))
1816 ((member prev '("case" "for" "select")) (setq res 'keyword))
1817 ((assoc prev smie-grammar) (setq res 'word))
1820 (progn (cl-assert words) (setq res 'word))
1824 (defun sh-smie--sh-keyword-p (tok)
1825 "Non-nil if TOK (at which we're looking) really is a keyword."
1826 (if (equal tok "in")
1827 (sh-smie--sh-keyword-in-p)
1828 (sh-smie--keyword-p)))
1830 (defun sh-smie-sh-forward-token ()
1831 (if (and (looking-at "[ \t]*\\(?:#\\|\\(\\s|\\)\\|$\\)")
1833 (skip-chars-backward " \t")
1835 (if (and (match-end 1) (not (nth 3 (syntax-ppss))))
1836 ;; Right before a here-doc.
1837 (let ((forward-sexp-function nil))
1839 ;; Pretend the here-document is a "newline representing a
1840 ;; semi-colon", since the here-doc otherwise covers the newline(s).
1842 (let ((semi (sh-smie--newline-semi-p)))
1845 (sh-smie-sh-forward-token))))
1846 (forward-comment (point-max))
1848 ((looking-at "\\\\\n") (forward-line 1) (sh-smie-sh-forward-token))
1849 ((looking-at sh-smie--sh-operators-re)
1850 (goto-char (match-end 0))
1851 (let ((tok (match-string-no-properties 0)))
1852 (if (and (memq (aref tok (1- (length tok))) '(?\; ?\& ?\|))
1853 (looking-at "[ \t]*\\(?:#\\|$\\)"))
1857 (let* ((pos (point))
1858 (tok (smie-default-forward-token)))
1860 ((equal tok ")") "case-)")
1861 ((equal tok "(") "case-(")
1862 ((and tok (string-match "\\`[a-z]" tok)
1863 (assoc tok smie-grammar)
1867 (sh-smie--sh-keyword-p tok))))
1871 (defun sh-smie--looking-back-at-continuation-p ()
1873 (and (if (eq (char-before) ?\n) (progn (forward-char -1) t) (eolp))
1874 (looking-back "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\\\"
1875 (line-beginning-position)))))
1877 (defun sh-smie-sh-backward-token ()
1878 (let ((bol (line-beginning-position)))
1879 (forward-comment (- (point)))
1881 ((and (bolp) (not (bobp))
1882 (equal (syntax-after (1- (point))) (string-to-syntax "|"))
1883 (not (nth 3 (syntax-ppss))))
1884 ;; Right after a here-document.
1885 (let ((forward-sexp-function nil))
1887 ;; Pretend the here-document is a "newline representing a
1888 ;; semi-colon", since the here-doc otherwise covers the newline(s).
1892 ((sh-smie--looking-back-at-continuation-p)
1894 (funcall smie-backward-token-function))
1895 ((sh-smie--newline-semi-p) ";")
1896 (t (funcall smie-backward-token-function))))
1897 ((looking-back sh-smie--sh-operators-back-re
1898 (line-beginning-position) 'greedy)
1899 (goto-char (match-beginning 1))
1900 (match-string-no-properties 1))
1902 (let ((tok (smie-default-backward-token)))
1904 ((equal tok ")") "case-)")
1905 ((equal tok "(") "case-(")
1906 ((and tok (string-match "\\`[a-z]" tok)
1907 (assoc tok smie-grammar)
1908 (not (save-excursion (sh-smie--sh-keyword-p tok))))
1912 (defcustom sh-indent-after-continuation t
1913 "If non-nil, try to make sure text is indented after a line continuation."
1916 :group 'sh-indentation)
1918 (defun sh-smie--continuation-start-indent ()
1919 "Return the initial indentation of a continued line.
1920 May return nil if the line should not be treated as continued."
1923 (unless (sh-smie--looking-back-at-continuation-p)
1924 (current-indentation))))
1926 (defun sh-smie-sh-rules (kind token)
1927 (pcase (cons kind token)
1928 (`(:elem . basic) sh-indentation)
1929 (`(:after . "case-)") (- (sh-var-value 'sh-indent-for-case-alt)
1930 (sh-var-value 'sh-indent-for-case-label)))
1931 ((and `(:before . ,_)
1932 (guard (when sh-indent-after-continuation
1935 (skip-chars-backward " \t")
1936 (sh-smie--looking-back-at-continuation-p))))))
1937 ;; After a line-continuation, make sure the rest is indented.
1938 (let* ((sh-indent-after-continuation nil)
1939 (indent (smie-indent-calculate))
1940 (initial (sh-smie--continuation-start-indent)))
1941 (when (and (numberp indent) (numberp initial)
1942 (<= indent initial))
1943 `(column . ,(+ initial sh-indentation)))))
1944 (`(:before . ,(or `"(" `"{" `"["))
1945 (if (smie-rule-hanging-p) (smie-rule-parent)))
1946 ;; FIXME: Maybe this handling of ;; should be made into
1947 ;; a smie-rule-terminator function that takes the substitute ";" as arg.
1948 (`(:before . ,(or `";;" `";&" `";;&"))
1949 (if (and (smie-rule-bolp) (looking-at ";;?&?[ \t]*\\(#\\|$\\)"))
1950 (cons 'column (smie-indent-keyword ";"))
1951 (smie-rule-separator kind)))
1952 (`(:after . ,(or `";;" `";&" `";;&"))
1953 (with-demoted-errors
1954 (smie-backward-sexp token)
1956 (if (or (smie-rule-bolp)
1958 (and (member (funcall smie-backward-token-function)
1962 (smie-indent-calculate)))))
1963 (`(:after . "|") (if (smie-rule-parent-p "|") nil 4))
1964 ;; Attempt at backward compatibility with the old config variables.
1965 (`(:before . "fi") (sh-var-value 'sh-indent-for-fi))
1966 (`(:before . "done") (sh-var-value 'sh-indent-for-done))
1967 (`(:after . "else") (sh-var-value 'sh-indent-after-else))
1968 (`(:after . "if") (sh-var-value 'sh-indent-after-if))
1969 (`(:before . "then") (sh-var-value 'sh-indent-for-then))
1970 (`(:before . "do") (sh-var-value 'sh-indent-for-do))
1972 (sh-var-value (if (smie-rule-hanging-p)
1973 'sh-indent-after-loop-construct 'sh-indent-after-do)))
1974 ;; sh-indent-after-done: aligned completely differently.
1975 (`(:after . "in") (sh-var-value 'sh-indent-for-case-label))
1976 ;; sh-indent-for-continuation: Line continuations are handled differently.
1977 (`(:after . ,(or `"(" `"{" `"[")) (sh-var-value 'sh-indent-after-open))
1978 ;; sh-indent-after-function: we don't handle it differently.
1981 ;; (defconst sh-smie-csh-grammar
1982 ;; (smie-prec2->grammar
1984 ;; '((exp) ;A constant, or a $var, or a sequence of them...
1986 ;; (cmd "else" "else-if" exp "then" elseifcmd))
1987 ;; (cmd ("switch" branches "endsw")
1989 ;; ("if" exp "then" cmd "endif")
1990 ;; ("if" exp "then" cmd "else" cmd "endif")
1991 ;; ("if" exp "then" elseifcmd "endif")
1992 ;; ;; ("if" exp "then" cmd "else" cmd "endif")
1993 ;; ;; ("if" exp "then" cmd "else" "if" exp "then" cmd "endif")
1994 ;; ;; ("if" exp "then" cmd "else" "if" exp "then" cmd
1995 ;; ;; "else" cmd "endif")
1996 ;; ;; ("if" exp "then" cmd "else" "if" exp "then" cmd
1997 ;; ;; "else" "if" exp "then" cmd "endif")
1998 ;; ("while" cmd "end")
1999 ;; ("foreach" cmd "end")
2000 ;; (cmd "|" cmd) (cmd "|&" cmd)
2001 ;; (cmd "&&" cmd) (cmd "||" cmd)
2002 ;; (cmd ";" cmd) (cmd "&" cmd))
2003 ;; ;; This is a lie, but (combined with the corresponding disambiguation
2004 ;; ;; rule) it makes it more clear that `case' and `default' are the key
2005 ;; ;; separators and the `:' is a secondary tokens.
2006 ;; (branches (branches "case" branches)
2007 ;; (branches "default" branches)
2008 ;; (exp ":" branches)))
2009 ;; '((assoc "else" "then" "endif"))
2010 ;; '((assoc "case" "default") (nonassoc ":"))
2011 ;; '((assoc ";;" ";&" ";;&"))
2012 ;; '((assoc ";" "&") (assoc "&&" "||") (assoc "|" "|&")))))
2014 ;;;; SMIE support for `rc'.
2016 (defconst sh-smie-rc-grammar
2017 (smie-prec2->grammar
2019 '((exp) ;A constant, or a $var, or a sequence of them...
2020 (cmd (cmd "case" cmd)
2023 ("for" exp) ("while" exp)
2024 (cmd "|" cmd) (cmd "|&" cmd)
2025 (cmd "&&" cmd) (cmd "||" cmd)
2026 (cmd ";" cmd) (cmd "&" cmd))
2027 (pattern (pattern "|" pattern))
2028 (branches (branches ";;" branches)
2029 (branches ";&" branches) (branches ";;&" branches) ;bash.
2030 (pattern "case-)" cmd)))
2031 '((assoc ";;" ";&" ";;&"))
2032 '((assoc "case") (assoc ";" "&") (assoc "&&" "||") (assoc "|" "|&")))))
2034 (defun sh-smie--rc-after-special-arg-p ()
2035 "Check if we're after the first arg of an if/while/for/... construct.
2036 Returns the construct's token and moves point before it, if so."
2037 (forward-comment (- (point)))
2038 (when (looking-back ")\\|\\_<not" (- (point) 3))
2040 (let ((forward-sexp-function nil))
2042 (car (member (funcall smie-backward-token-function)
2043 '("if" "for" "switch" "while")))))))
2045 (defun sh-smie--rc-newline-semi-p ()
2046 "Return non-nil if a newline should be treated as a semi-colon.
2047 Point should be before the newline."
2049 (let ((tok (funcall smie-backward-token-function)))
2050 (if (or (when (equal tok "not") (forward-word 1) t)
2051 (and (zerop (length tok)) (eq (char-before) ?\))))
2052 (not (sh-smie--rc-after-special-arg-p))
2053 (sh-smie--newline-semi-p tok)))))
2055 (defun sh-smie-rc-forward-token ()
2056 ;; FIXME: Code duplication with sh-smie-sh-forward-token.
2057 (if (and (looking-at "[ \t]*\\(?:#\\|\\(\\s|\\)\\|$\\)")
2059 (skip-chars-backward " \t")
2061 (if (and (match-end 1) (not (nth 3 (syntax-ppss))))
2062 ;; Right before a here-doc.
2063 (let ((forward-sexp-function nil))
2065 ;; Pretend the here-document is a "newline representing a
2066 ;; semi-colon", since the here-doc otherwise covers the newline(s).
2068 (let ((semi (sh-smie--rc-newline-semi-p)))
2071 (sh-smie-rc-forward-token))))
2072 (forward-comment (point-max))
2074 ((looking-at "\\\\\n") (forward-line 1) (sh-smie-rc-forward-token))
2075 ;; ((looking-at sh-smie--rc-operators-re)
2076 ;; (goto-char (match-end 0))
2077 ;; (let ((tok (match-string-no-properties 0)))
2078 ;; (if (and (memq (aref tok (1- (length tok))) '(?\; ?\& ?\|))
2079 ;; (looking-at "[ \t]*\\(?:#\\|$\\)"))
2080 ;; (forward-line 1))
2083 (let* ((pos (point))
2084 (tok (smie-default-forward-token)))
2086 ;; ((equal tok ")") "case-)")
2087 ((and tok (string-match "\\`[a-z]" tok)
2088 (assoc tok smie-grammar)
2092 (sh-smie--keyword-p))))
2096 (defun sh-smie-rc-backward-token ()
2097 ;; FIXME: Code duplication with sh-smie-sh-backward-token.
2098 (let ((bol (line-beginning-position)))
2099 (forward-comment (- (point)))
2101 ((and (bolp) (not (bobp))
2102 (equal (syntax-after (1- (point))) (string-to-syntax "|"))
2103 (not (nth 3 (syntax-ppss))))
2104 ;; Right after a here-document.
2105 (let ((forward-sexp-function nil))
2107 ;; Pretend the here-document is a "newline representing a
2108 ;; semi-colon", since the here-doc otherwise covers the newline(s).
2110 ((< (point) bol) ;We skipped over a newline.
2112 ;; A continued line.
2114 (looking-back "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\\\"
2115 (line-beginning-position)))
2117 (funcall smie-backward-token-function))
2118 ((sh-smie--rc-newline-semi-p) ";")
2119 (t (funcall smie-backward-token-function))))
2120 ;; ((looking-back sh-smie--sh-operators-back-re
2121 ;; (line-beginning-position) 'greedy)
2122 ;; (goto-char (match-beginning 1))
2123 ;; (match-string-no-properties 1))
2125 (let ((tok (smie-default-backward-token)))
2127 ;; ((equal tok ")") "case-)")
2128 ((and tok (string-match "\\`[a-z]" tok)
2129 (assoc tok smie-grammar)
2130 (not (save-excursion (sh-smie--keyword-p))))
2134 (defun sh-smie-rc-rules (kind token)
2135 (pcase (cons kind token)
2136 (`(:elem . basic) sh-indentation)
2137 ;; (`(:after . "case") (or sh-indentation smie-indent-basic))
2139 (if (smie-rule-parent-p "case")
2140 (smie-rule-parent (sh-var-value 'sh-indent-after-case))))
2143 (when (sh-smie--rc-after-special-arg-p)
2144 `(column . ,(current-column)))))
2145 (`(:before . ,(or `"(" `"{" `"["))
2146 (if (smie-rule-hanging-p) (smie-rule-parent)))
2147 ;; FIXME: SMIE parses "if (exp) cmd" as "(if ((exp) cmd))" so "cmd" is
2148 ;; treated as an arg to (exp) by default, which indents it all wrong.
2149 ;; To handle it right, we should extend smie-indent-exps so that the
2150 ;; preceding keyword can give special rules. Currently the only special
2151 ;; rule we have is the :list-intro hack, which we use here to align "cmd"
2152 ;; with "(exp)", which is rarely the right thing to do, but is better
2154 (`(:list-intro . ,(or `"for" `"if" `"while")) t)
2155 ;; sh-indent-after-switch: handled implicitly by the default { rule.
2158 ;;; End of SMIE code.
2160 (defvar sh-regexp-for-done nil
2161 "A buffer-local regexp to match opening keyword for done.")
2163 (defvar sh-kw-alist nil
2164 "A buffer-local, since it is shell-type dependent, list of keywords.")
2166 ;; ( key-word first-on-this on-prev-line )
2167 ;; This is used to set `sh-kw-alist' which is a list of sublists each
2168 ;; having 3 elements:
2170 ;; a rule to check when the keyword appears on "this" line
2171 ;; a rule to check when the keyword appears on "the previous" line
2172 ;; The keyword is usually a string and is the first word on a line.
2173 ;; If this keyword appears on the line whose indentation is to be
2174 ;; calculated, the rule in element 2 is called. If this returns
2175 ;; non-zero, the resulting point (which may be changed by the rule)
2176 ;; is used as the default indentation.
2177 ;; If it returned false or the keyword was not found in the table,
2178 ;; then the keyword from the previous line is looked up and the rule
2179 ;; in element 3 is called. In this case, however,
2180 ;; `sh-get-indent-info' does not stop but may keep going and test
2181 ;; other keywords against rules in element 3. This is because the
2182 ;; preceding line could have, for example, an opening "if" and an
2183 ;; opening "while" keyword and we need to add the indentation offsets
2188 ("if" nil sh-handle-prev-if)
2189 ("elif" sh-handle-this-else sh-handle-prev-else)
2190 ("else" sh-handle-this-else sh-handle-prev-else)
2191 ("fi" sh-handle-this-fi sh-handle-prev-fi)
2192 ("then" sh-handle-this-then sh-handle-prev-then)
2193 ("(" nil sh-handle-prev-open)
2194 ("{" nil sh-handle-prev-open)
2195 ("[" nil sh-handle-prev-open)
2196 ("}" sh-handle-this-close nil)
2197 (")" sh-handle-this-close nil)
2198 ("]" sh-handle-this-close nil)
2199 ("case" nil sh-handle-prev-case)
2200 ("esac" sh-handle-this-esac sh-handle-prev-esac)
2201 (case-label nil sh-handle-after-case-label) ;; ???
2202 (";;" nil sh-handle-prev-case-alt-end) ;; ???
2203 (";;&" nil sh-handle-prev-case-alt-end) ;Like ";;" with diff semantics.
2204 (";&" nil sh-handle-prev-case-alt-end) ;Like ";;" with diff semantics.
2205 ("done" sh-handle-this-done sh-handle-prev-done)
2206 ("do" sh-handle-this-do sh-handle-prev-do))
2208 ;; Note: we don't need specific stuff for bash and zsh shells;
2209 ;; the regexp `sh-regexp-for-done' handles the extra keywords
2210 ;; these shells use.
2212 ("{" nil sh-handle-prev-open)
2213 ("}" sh-handle-this-close nil)
2214 ("case" sh-handle-this-rc-case sh-handle-prev-rc-case))))
2218 (defun sh-set-shell (shell &optional no-query-flag insert-flag)
2219 "Set this buffer's shell to SHELL (a string).
2220 When used interactively, insert the proper starting #!-line,
2221 and make the visited file executable via `executable-set-magic',
2222 perhaps querying depending on the value of `executable-query'.
2224 When this function is called noninteractively, INSERT-FLAG (the third
2225 argument) controls whether to insert a #!-line and think about making
2226 the visited file executable, and NO-QUERY-FLAG (the second argument)
2227 controls whether to query about making the visited file executable.
2229 Calls the value of `sh-set-shell-hook' if set."
2230 (interactive (list (completing-read
2231 (format "Shell \(default %s\): "
2233 ;; This used to use interpreter-mode-alist, but that is
2234 ;; no longer appropriate now that uses regexps.
2235 ;; Maybe there could be a separate variable that lists
2236 ;; the shells, used here and to construct i-mode-alist.
2237 ;; But the following is probably good enough:
2238 (append (mapcar (lambda (e) (symbol-name (car e)))
2241 nil nil nil nil sh-shell-file)
2242 (eq executable-query 'function)
2244 (if (string-match "\\.exe\\'" shell)
2245 (setq shell (substring shell 0 (match-beginning 0))))
2246 (setq sh-shell (intern (file-name-nondirectory shell))
2247 sh-shell (or (cdr (assq sh-shell sh-alias-alist))
2251 (executable-set-magic shell (sh-feature sh-shell-arg)
2252 no-query-flag insert-flag)))
2253 (setq mode-line-process (format "[%s]" sh-shell))
2254 (setq-local sh-shell-variables nil)
2255 (setq-local sh-shell-variables-initialized nil)
2256 (setq-local imenu-generic-expression
2257 (sh-feature sh-imenu-generic-expression))
2258 (let ((tem (sh-feature sh-mode-syntax-table-input)))
2260 (setq-local sh-mode-syntax-table
2261 (apply 'sh-mode-syntax-table tem))
2262 (set-syntax-table sh-mode-syntax-table)))
2263 (dolist (var (sh-feature sh-variables))
2264 (sh-remember-variable var))
2265 (if (setq-local sh-indent-supported-here
2266 (sh-feature sh-indent-supported))
2268 (message "Setting up indent for shell type %s" sh-shell)
2269 (let ((mksym (lambda (name)
2270 (intern (format "sh-smie-%s-%s"
2271 sh-indent-supported-here name)))))
2272 (smie-setup (symbol-value (funcall mksym "grammar"))
2273 (funcall mksym "rules")
2274 :forward-token (funcall mksym "forward-token")
2275 :backward-token (funcall mksym "backward-token")))
2277 (setq-local parse-sexp-lookup-properties t)
2278 (setq-local sh-kw-alist (sh-feature sh-kw))
2279 (let ((regexp (sh-feature sh-kws-for-done)))
2281 (setq-local sh-regexp-for-done
2282 (sh-mkword-regexpr (regexp-opt regexp t)))))
2283 (message "setting up indent stuff")
2284 ;; sh-mode has already made indent-line-function local
2285 ;; but do it in case this is called before that.
2286 (setq-local indent-line-function 'sh-indent-line))
2287 (if sh-make-vars-local
2288 (sh-make-vars-local))
2289 (message "Indentation setup for shell type %s" sh-shell))
2290 (message "No indentation for this shell type.")
2291 (setq indent-line-function 'sh-basic-indent-line))
2292 (when font-lock-mode
2293 (setq font-lock-set-defaults nil)
2294 (font-lock-set-defaults)
2295 (font-lock-fontify-buffer))
2296 (setq sh-shell-process nil)
2297 (run-hooks 'sh-set-shell-hook))
2300 (defun sh-feature (alist &optional function)
2301 "Index ALIST by the current shell.
2302 If ALIST isn't a list where every element is a cons, it is returned as is.
2303 Else indexing follows an inheritance logic which works in two ways:
2305 - Fall back on successive ancestors (see `sh-ancestor-alist') as long as
2306 the alist contains no value for the current shell.
2307 The ultimate default is always `sh'.
2309 - If the value thus looked up is a list starting with `sh-append',
2310 we call the function `sh-append' with the rest of the list as
2311 arguments, and use the value. However, the next element of the
2312 list is not used as-is; instead, we look it up recursively
2313 in ALIST to allow the function called to define the value for
2314 one shell to be derived from another shell.
2315 The value thus determined is physically replaced into the alist.
2317 If FUNCTION is non-nil, it is called with one argument,
2318 the value thus obtained, and the result is used instead."
2319 (or (if (consp alist)
2320 ;; Check for something that isn't a valid alist.
2322 (while (and l (consp (car l)))
2326 (let ((orig-sh-shell sh-shell))
2327 (let ((sh-shell sh-shell)
2329 (while (and sh-shell
2330 (not (setq elt (assq sh-shell alist))))
2331 (setq sh-shell (cdr (assq sh-shell sh-ancestor-alist))))
2332 ;; If the shell is not known, treat it as sh.
2334 (setq elt (assq 'sh alist)))
2335 (setq val (cdr elt))
2336 (if (and (consp val)
2337 (memq (car val) '(sh-append sh-modify)))
2340 ;; Refer to the value for a different shell,
2341 ;; as a kind of inheritance.
2342 (let ((sh-shell (car (cdr val))))
2346 (setq sh-shell orig-sh-shell
2347 val (funcall function val)))
2352 ;; I commented this out because nobody calls it -- rms.
2353 ;;(defun sh-abbrevs (ancestor &rest list)
2354 ;; "Iff it isn't, define the current shell as abbrev table and fill that.
2355 ;;Abbrev table will inherit all abbrevs from ANCESTOR, which is either an abbrev
2356 ;;table or a list of (NAME1 EXPANSION1 ...). In addition it will define abbrevs
2357 ;;according to the remaining arguments NAMEi EXPANSIONi ...
2358 ;;EXPANSION may be either a string or a skeleton command."
2359 ;; (or (if (boundp sh-shell)
2360 ;; (symbol-value sh-shell))
2362 ;; (if (listp ancestor)
2363 ;; (nconc list ancestor))
2364 ;; (define-abbrev-table sh-shell ())
2365 ;; (if (vectorp ancestor)
2366 ;; (mapatoms (lambda (atom)
2368 ;; (define-abbrev (symbol-value sh-shell)
2369 ;; (symbol-name atom)
2370 ;; (symbol-value atom)
2371 ;; (symbol-function atom))))
2374 ;; (define-abbrev (symbol-value sh-shell)
2376 ;; (if (stringp (car (cdr list)))
2379 ;; (if (symbolp (car (cdr list)))
2380 ;; (car (cdr list))))
2381 ;; (setq list (cdr (cdr list)))))
2382 ;; (symbol-value sh-shell)))
2385 (defun sh-append (ancestor &rest list)
2386 "Return list composed of first argument (a list) physically appended to rest."
2387 (nconc list ancestor))
2390 (defun sh-modify (skeleton &rest list)
2391 "Modify a copy of SKELETON by replacing I1 with REPL1, I2 with REPL2 ..."
2392 (setq skeleton (copy-sequence skeleton))
2394 (setcar (or (nthcdr (car list) skeleton)
2395 (error "Index %d out of bounds" (car list)))
2397 (setq list (nthcdr 2 list)))
2401 (defun sh-basic-indent-line ()
2402 "Indent a line for Sh mode (shell script mode).
2403 Indent as far as preceding non-empty line, then by steps of `sh-indentation'.
2404 Lines containing only comments are considered empty."
2406 (let ((previous (save-excursion
2407 (while (and (progn (beginning-of-line)
2411 (back-to-indentation)
2413 (eq (following-char) ?#)))))
2417 (indent-to (if (eq this-command 'newline-and-indent)
2419 (if (< (current-column)
2420 (setq current (progn (back-to-indentation)
2422 (if (eolp) previous 0)
2423 (delete-region (point)
2424 (progn (beginning-of-line) (point)))
2426 (max previous (* (1+ (/ current sh-indentation))
2428 (* (1+ (/ current sh-indentation)) sh-indentation))))))
2429 (if (< (current-column) (current-indentation))
2430 (skip-chars-forward " \t"))))
2433 (defun sh-execute-region (start end &optional flag)
2434 "Pass optional header and region to a subshell for noninteractive execution.
2435 The working directory is that of the buffer, and only environment variables
2436 are already set which is why you can mark a header within the script.
2438 With a positive prefix ARG, instead of sending region, define header from
2439 beginning of buffer to point. With a negative prefix ARG, instead of sending
2440 region, clear header."
2441 (interactive "r\nP")
2443 (setq sh-header-marker (if (> (prefix-numeric-value flag) 0)
2445 (if sh-header-marker
2447 (let (buffer-undo-list)
2448 (goto-char sh-header-marker)
2449 (append-to-buffer (current-buffer) start end)
2450 (shell-command-on-region (point-min)
2451 (setq end (+ sh-header-marker
2454 (delete-region sh-header-marker end)))
2455 (shell-command-on-region start end (concat sh-shell-file " -")))))
2458 (defun sh-remember-variable (var)
2459 "Make VARIABLE available for future completing reads in this buffer."
2460 (or (< (length var) sh-remember-variable-min)
2462 (assoc var sh-shell-variables)
2463 (push (cons var var) sh-shell-variables))
2468 (defun sh-quoted-p ()
2469 "Is point preceded by an odd number of backslashes?"
2470 (eq -1 (% (save-excursion (skip-chars-backward "\\\\")) 2)))
2472 ;; Indentation stuff.
2473 (defun sh-must-support-indent ()
2474 "Signal an error if the shell type for this buffer is not supported.
2475 Also, the buffer must be in Shell-script mode."
2476 (unless sh-indent-supported-here
2477 (error "This buffer's shell does not support indentation through Emacs")))
2479 (defun sh-make-vars-local ()
2480 "Make the indentation variables local to this buffer.
2481 Normally they already are local. This command is provided in case
2482 variable `sh-make-vars-local' has been set to nil.
2484 To revert all these variables to the global values, use
2485 command `sh-reset-indent-vars-to-global-values'."
2487 (mapc 'make-local-variable sh-var-list)
2488 (message "Indentation variables are now local."))
2490 (defun sh-reset-indent-vars-to-global-values ()
2491 "Reset local indentation variables to the global values.
2492 Then, if variable `sh-make-vars-local' is non-nil, make them local."
2494 (mapc 'kill-local-variable sh-var-list)
2495 (if sh-make-vars-local
2496 (mapcar 'make-local-variable sh-var-list)))
2499 ;; Theoretically these are only needed in shell and derived modes.
2500 ;; However, the routines which use them are only called in those modes.
2501 (defconst sh-special-keywords "then\\|do")
2503 (defun sh-help-string-for-variable (var)
2504 "Construct a string for `sh-read-variable' when changing variable VAR ."
2505 (let ((msg (documentation-property var 'variable-documentation))
2507 (unless (memq var '(sh-first-lines-indent sh-indent-comment))
2510 You can enter a number (positive to increase indentation,
2511 negative to decrease indentation, zero for no change to indentation).
2513 Or, you can enter one of the following symbols which are relative to
2514 the value of variable `sh-basic-offset'
2515 which in this buffer is currently %s.
2519 (mapconcat (lambda (x)
2520 (nth (1- (length x)) x))
2521 sh-symbol-list "\n\t"))))
2523 ;; The following shows the global not the local value!
2524 ;; (format "Current value of %s is %s\n\n" var (symbol-value var))
2527 (defun sh-read-variable (var)
2528 "Read a new value for indentation variable VAR."
2529 (let ((minibuffer-help-form `(sh-help-string-for-variable
2532 (setq val (read-from-minibuffer
2533 (format "New value for %s (press %s for help): "
2534 var (single-key-description help-char))
2535 (format "%s" (symbol-value var))
2541 (defun sh-in-comment-or-string (start)
2542 "Return non-nil if START is in a comment or string."
2544 (let ((state (syntax-ppss start)))
2545 (or (nth 3 state) (nth 4 state)))))
2547 (defun sh-goto-matching-if ()
2548 "Go to the matching if for a fi.
2549 This handles nested if..fi pairs."
2550 (let ((found (sh-find-prev-matching "\\bif\\b" "\\bfi\\b" 1)))
2552 (goto-char found))))
2555 ;; Functions named sh-handle-this-XXX are called when the keyword on the
2556 ;; line whose indentation is being handled contain XXX;
2557 ;; those named sh-handle-prev-XXX are when XXX appears on the previous line.
2559 (defun sh-handle-prev-if ()
2560 (list '(+ sh-indent-after-if)))
2562 (defun sh-handle-this-else ()
2563 (if (sh-goto-matching-if)
2564 ;; (list "aligned to if")
2565 (list "aligned to if" '(+ sh-indent-for-else))
2569 (defun sh-handle-prev-else ()
2570 (if (sh-goto-matching-if)
2571 (list '(+ sh-indent-after-if))
2574 (defun sh-handle-this-fi ()
2575 (if (sh-goto-matching-if)
2576 (list "aligned to if" '(+ sh-indent-for-fi))
2580 (defun sh-handle-prev-fi ()
2581 ;; Why do we have this rule? Because we must go back to the if
2582 ;; to get its indent. We may continue back from there.
2583 ;; We return nil because we don't have anything to add to result,
2584 ;; the side affect of setting align-point is all that matters.
2585 ;; we could return a comment (a string) but I can't think of a good one...
2586 (sh-goto-matching-if)
2589 (defun sh-handle-this-then ()
2590 (let ((p (sh-goto-matching-if)))
2592 (list '(+ sh-indent-for-then))
2595 (defun sh-handle-prev-then ()
2596 (let ((p (sh-goto-matching-if)))
2598 (list '(+ sh-indent-after-if))
2601 (defun sh-handle-prev-open ()
2603 (let ((x (sh-prev-stmt)))
2608 (looking-at "function\\b")
2609 (looking-at "\\s-*\\S-+\\s-*()")
2611 (list '(+ sh-indent-after-function))
2612 (list '(+ sh-indent-after-open)))
2615 (defun sh-handle-this-close ()
2616 (forward-char 1) ;; move over ")"
2617 (if (sh-safe-forward-sexp -1)
2618 (list "aligned to opening paren")))
2620 (defun sh-goto-matching-case ()
2621 (let ((found (sh-find-prev-matching "\\bcase\\b" "\\besac\\b" 1)))
2622 (if found (goto-char found))))
2624 (defun sh-handle-prev-case ()
2625 ;; This is typically called when point is on same line as a case
2626 ;; we shouldn't -- and can't find prev-case
2627 (if (looking-at ".*\\<case\\>")
2628 (list '(+ sh-indent-for-case-label))
2629 (error "We don't seem to be on a line with a case"))) ;; debug
2631 (defun sh-handle-this-esac ()
2632 (if (sh-goto-matching-case)
2633 (list "aligned to matching case")))
2635 (defun sh-handle-prev-esac ()
2636 (if (sh-goto-matching-case)
2637 (list "matching case")))
2639 (defun sh-handle-after-case-label ()
2640 (if (sh-goto-matching-case)
2641 (list '(+ sh-indent-for-case-alt))))
2643 (defun sh-handle-prev-case-alt-end ()
2644 (if (sh-goto-matching-case)
2645 (list '(+ sh-indent-for-case-label))))
2647 (defun sh-safe-forward-sexp (&optional arg)
2648 "Try and do a `forward-sexp', but do not error.
2649 Return new point if successful, nil if an error occurred."
2652 (forward-sexp (or arg 1))
2653 (point)) ;; return point if successful
2655 (sh-debug "oops!(1) %d" (point))
2656 nil))) ;; return nil if fail
2658 (defun sh-goto-match-for-done ()
2659 (let ((found (sh-find-prev-matching sh-regexp-for-done sh-re-done 1)))
2661 (goto-char found))))
2663 (defun sh-handle-this-done ()
2664 (if (sh-goto-match-for-done)
2665 (list "aligned to do stmt" '(+ sh-indent-for-done))))
2667 (defun sh-handle-prev-done ()
2668 (if (sh-goto-match-for-done)
2669 (list "previous done")))
2671 (defun sh-handle-this-do ()
2672 (if (sh-goto-match-for-done)
2673 (list '(+ sh-indent-for-do))))
2675 (defun sh-handle-prev-do ()
2678 (narrow-to-region (point) (line-beginning-position))
2679 (sh-goto-match-for-done))
2680 (sh-debug "match for done found on THIS line")
2681 (list '(+ sh-indent-after-loop-construct)))
2682 ((sh-goto-match-for-done)
2683 (sh-debug "match for done found on PREV line")
2684 (list '(+ sh-indent-after-do)))
2686 (message "match for done NOT found")
2690 (defun sh-find-prev-switch ()
2691 "Find the line for the switch keyword matching this line's case keyword."
2692 (re-search-backward "\\<switch\\>" nil t))
2694 (defun sh-handle-this-rc-case ()
2695 (if (sh-find-prev-switch)
2696 (list '(+ sh-indent-after-switch))
2697 ;; (list '(+ sh-indent-for-case-label))
2700 (defun sh-handle-prev-rc-case ()
2701 (list '(+ sh-indent-after-case)))
2703 (defun sh-check-rule (n thing)
2704 (let ((rule (nth n (assoc thing sh-kw-alist)))
2708 (setq val (funcall rule))
2709 (sh-debug "rule (%d) for %s at %d is %s\n-> returned %s"
2710 n thing (point) rule val)))
2714 (defun sh-get-indent-info ()
2715 "Return indent-info for this line.
2716 This is a list. nil means the line is to be left as is.
2717 Otherwise it contains one or more of the following sublists:
2718 \(t NUMBER\) NUMBER is the base location in the buffer that indentation is
2719 relative to. If present, this is always the first of the
2720 sublists. The indentation of the line in question is
2721 derived from the indentation of this point, possibly
2722 modified by subsequent sublists.
2724 \(- VAR\) Get the value of variable VAR and add to or subtract from
2725 the indentation calculated so far.
2726 \(= VAR\) Get the value of variable VAR and *replace* the
2727 indentation with its value. This only occurs for
2728 special variables such as `sh-indent-comment'.
2729 STRING This is ignored for the purposes of calculating
2730 indentation, it is printed in certain cases to help show
2731 what the indentation is based on."
2732 ;; See comments before `sh-kw'.
2734 (let ((have-result nil)
2741 ;; Note: setting result to t means we are done and will return nil.
2742 ;;(This function never returns just t.)
2744 ((or (nth 3 (syntax-ppss (point)))
2745 (eq (get-text-property (point) 'face) sh-heredoc-face))
2746 ;; String continuation -- don't indent
2748 (setq have-result t))
2749 ((looking-at "\\s-*#") ; was (equal this-kw "#")
2751 (setq result t) ;; return nil if 1st line!
2752 (setq result (list '(= sh-indent-comment)))
2753 ;; we still need to get previous line in case
2754 ;; sh-indent-comment is t (indent as normal)
2755 (setq align-point (sh-prev-line nil))
2756 (setq have-result nil)
2761 ;; Continuation lines are handled specially
2762 (if (sh-this-is-a-continuation)
2767 (not (memq (char-before (- (point) 2)) '(?\s ?\t))))
2768 ;; By convention, if the continuation \ is not
2769 ;; preceded by a SPC or a TAB it means that the line
2770 ;; is cut at a place where spaces cannot be freely
2771 ;; added/removed. I.e. do not indent the line.
2773 ;; We assume the line being continued is already
2774 ;; properly indented...
2775 ;; (setq prev-line-end (sh-prev-line))
2776 (setq align-point (sh-prev-line nil))
2777 (list '(+ sh-indent-for-continuation))))
2778 (setq have-result t))
2780 (skip-chars-forward " \t")
2781 (setq this-kw (sh-get-kw)))
2783 ;; Handle "this" keyword: first word on the line we're
2784 ;; calculating indentation info for.
2786 (if (setq val (sh-check-rule 1 this-kw))
2788 (setq align-point (point))
2790 "this - setting align-point to %d" align-point)
2791 (setq result (append result val))
2792 (setq have-result t)
2793 ;; set prev-line to continue processing remainder
2794 ;; of this line as a previous line
2795 (setq prev-line-end (point))
2799 (setq prev-line-end (sh-prev-line 'end)))
2803 ;; We start off at beginning of this line.
2804 ;; Scan previous statements while this is <=
2805 ;; start of previous line.
2806 (goto-char prev-line-end)
2808 (while (and x (setq x (sh-prev-thing)))
2809 (sh-debug "at %d x is: %s result is: %s" (point) x result)
2812 (equal (get-text-property (1- (point)) 'syntax-table)
2814 (sh-debug "Case label) here")
2815 (setq x 'case-label)
2816 (if (setq val (sh-check-rule 2 x))
2818 (setq result (append result val))
2819 (setq align-point (point))))
2822 ;; FIXME: This charset looks too much like a regexp. --Stef
2823 (skip-chars-forward "[a-z0-9]*?")
2825 ((string-match "[])}]" x)
2826 (setq x (sh-safe-forward-sexp -1))
2829 (setq align-point (point))
2830 (setq result (append result
2831 (list "aligned to opening paren")))
2833 ((string-match "[[({]" x)
2834 (sh-debug "Checking special thing: %s" x)
2835 (if (setq val (sh-check-rule 2 x))
2836 (setq result (append result val)))
2838 (setq align-point (point)))
2839 ((string-match "[\"'`]" x)
2840 (sh-debug "Skipping back for %s" x)
2842 (setq x (sh-safe-forward-sexp -1)))
2844 (sh-debug "Checking string %s at %s" x (point))
2845 (if (setq val (sh-check-rule 2 x))
2846 ;; (or (eq t (car val))
2847 ;; (eq t (car (car val))))
2848 (setq result (append result val)))
2849 ;; not sure about this test Wed Jan 27 23:48:35 1999
2850 (setq align-point (point))
2854 (error "Don't know what to do with %s" x))
2857 (sh-debug "result is %s" result)
2859 (sh-debug "No prev line!")
2860 (sh-debug "result: %s align-point: %s" result align-point)
2864 ;; was: (setq result (append result (list (list t align-point))))
2865 (setq result (append (list (list t align-point)) result))
2867 (sh-debug "result is now: %s" result)
2870 (setq result (list (if prev-line-end
2871 (list t prev-line-end)
2872 (list '= 'sh-first-lines-indent)))))
2876 (sh-debug "result is: %s" result)
2882 (defun sh-get-indent-var-for-line (&optional info)
2883 "Return the variable controlling indentation for this line.
2884 If there is not [just] one such variable, return a string
2885 indicating the problem.
2886 If INFO is supplied it is used, else it is calculated."
2892 (setq info (sh-get-indent-info)))
2894 (setq result "this line to be left as is")
2895 (while (and info (null result))
2896 (setq elt (car info))
2902 (error "sh-get-indent-var-for-line invalid elt: %s" elt))
2906 ((symbolp (setq sym (nth 1 elt)))
2907 ;; A bit of a kludge - when we see the sh-indent-comment
2908 ;; ignore other variables. Otherwise it is tricky to
2909 ;; "learn" the comment indentation.
2910 (if (eq var 'sh-indent-comment)
2914 "this line is controlled by more than 1 variable.")
2917 (error "sh-get-indent-var-for-line invalid list elt: %s" elt)))
2918 (setq info (cdr info))
2923 (setq result reason))
2925 ;; e.g. just had (t POS)
2926 (setq result "line has default indentation"))
2931 ;; Finding the previous line isn't trivial.
2932 ;; We must *always* go back one more and see if that is a continuation
2933 ;; line -- it is the PREVIOUS line which is continued, not the one
2935 ;; Also, we want to treat a whole "here document" as one big line,
2936 ;; because we may want to a align to the beginning of it.
2939 ;; - go back to previous non-empty line
2940 ;; - if this is in a here-document, go to the beginning of it
2941 ;; - while previous line is continued, go back one line
2942 (defun sh-prev-line (&optional end)
2943 "Back to end of previous non-comment non-empty line.
2944 Go to beginning of logical line unless END is non-nil, in which case
2945 we go to the end of the previous line and do not check for continuations."
2948 (forward-comment (- (point-max)))
2949 (unless end (beginning-of-line))
2950 (when (and (not (bobp))
2951 (equal (get-text-property (1- (point)) 'face)
2953 (let ((p1 (previous-single-property-change (1- (point)) 'face)))
2958 (beginning-of-line)))))
2960 ;; we must check previous lines to see if they are continuation lines
2961 ;; if so, we must return position of first of them
2962 (while (and (sh-this-is-a-continuation)
2963 (>= 0 (forward-line -1))))
2965 (skip-chars-forward " \t"))
2969 (defun sh-prev-stmt ()
2970 "Return the address of the previous stmt or nil."
2971 ;; This is used when we are trying to find a matching keyword.
2972 ;; Searching backward for the keyword would certainly be quicker, but
2973 ;; it is hard to remove "false matches" -- such as if the keyword
2974 ;; appears in a string or quote. This way is slower, but (I think) safer.
2981 (skip-chars-backward " \t;|&({[")
2982 (while (and (not found)
2985 ;; Do a backward-sexp if possible, else backup bit by bit...
2986 (if (sh-safe-forward-sexp -1)
2988 (if (looking-at sh-special-keywords)
2993 ;; backward-sexp failed
2994 (if (zerop (skip-chars-backward " \t()[\]{};`'"))
2997 (let ((back (sh-prev-line nil)))
3000 (setq going nil)))))
3002 (skip-chars-backward " \t")
3003 (if (or (and (bolp) (not (sh-this-is-a-continuation)))
3004 (eq (char-before) ?\;)
3005 (looking-at "\\s-*[|&]"))
3006 (setq found (point)))))
3011 (skip-chars-forward " \t|&({[")
3012 (setq found (point))))
3013 (if (>= (point) start)
3015 (debug "We didn't move!")
3018 (sh-debug "Did not find prev stmt.")))
3022 (defun sh-get-word ()
3023 "Get a shell word skipping whitespace from point."
3025 (skip-chars-forward "\t ")
3026 (let ((start (point)))
3028 (if (looking-at "[\"'`]")
3029 (sh-safe-forward-sexp)
3030 ;; (> (skip-chars-forward "^ \t\n\"'`") 0)
3031 (> (skip-chars-forward "-_$[:alnum:]") 0)
3033 (buffer-substring start (point))
3036 (defun sh-prev-thing ()
3037 "Return the previous thing this logical line."
3038 ;; This is called when `sh-get-indent-info' is working backwards on
3039 ;; the previous line(s) finding what keywords may be relevant for
3040 ;; indenting. It moves over sexps if possible, and will stop
3041 ;; on a ; and at the beginning of a line if it is not a continuation
3044 ;; Added a kludge for ";;"
3045 ;; Possible return values:
3047 ;; a string - possibly a keyword
3051 (let ((start (point))
3052 (min-point (if (sh-this-is-a-continuation)
3054 (line-beginning-position))))
3055 (skip-chars-backward " \t;" min-point)
3056 (if (looking-at "\\s-*;[;&]")
3057 ;; (message "Found ;; !")
3059 (skip-chars-backward "^)}];\"'`({[" min-point)
3060 (let ((c (if (> (point) min-point) (char-before))))
3061 (sh-debug "stopping at %d c is %s start=%d min-point=%d"
3062 (point) c start min-point)
3063 (if (not (memq c '(?\n nil ?\;)))
3064 ;; c -- return a string
3066 ;; Return the leading keyword of the "command" we supposedly
3067 ;; skipped over. Maybe we skipped too far (e.g. past a `do' or
3068 ;; `then' that precedes the actual command), so check whether
3069 ;; we're looking at such a keyword and if so, move back forward.
3070 (let ((boundary (point))
3074 ;; Skip forward over white space newline and \ at eol.
3075 (skip-chars-forward " \t\n\\\\" start)
3076 (if (>= (point) start)
3078 (sh-debug "point: %d >= start: %d" (point) start)
3080 (if next (setq boundary next))
3081 (sh-debug "Now at %d start=%d" (point) start)
3082 (setq kwd (sh-get-word))
3083 (if (member kwd (sh-feature sh-leading-keywords))
3088 (goto-char boundary)
3092 (defun sh-this-is-a-continuation ()
3093 "Return non-nil if current line is a continuation of previous line."
3095 (and (zerop (forward-line -1))
3096 (looking-at ".*\\\\$")
3097 (not (nth 4 (parse-partial-sexp (match-beginning 0) (match-end 0)
3100 (defun sh-get-kw (&optional where and-move)
3101 "Return first word of line from WHERE.
3102 If AND-MOVE is non-nil then move to end of word."
3103 (let ((start (point)))
3107 (buffer-substring (point)
3108 (progn (skip-chars-forward "^ \t\n;&|")(point)))
3110 (goto-char start)))))
3112 (defun sh-find-prev-matching (open close &optional depth)
3113 "Find a matching token for a set of opening and closing keywords.
3114 This takes into account that there may be nested open..close pairings.
3115 OPEN and CLOSE are regexps denoting the tokens to be matched.
3116 Optional parameter DEPTH (usually 1) says how many to look for."
3117 (let ((parse-sexp-ignore-comments t)
3118 (forward-sexp-function nil)
3120 (setq depth (or depth 1))
3126 (setq prev (sh-prev-stmt)))
3129 (if (looking-at "\\\\\n")
3132 (skip-chars-forward " \t")))
3135 (setq depth (1- depth))
3136 (sh-debug "found open at %d - depth = %d" (point) depth))
3138 (setq depth (1+ depth))
3139 (sh-debug "found close - depth = %d" depth))
3149 (defun sh-var-value (var &optional ignore-error)
3150 "Return the value of variable VAR, interpreting symbols.
3151 It can also return t or nil.
3152 If an invalid value is found, throw an error unless Optional argument
3153 IGNORE-ERROR is non-nil."
3154 (let ((val (symbol-value var)))
3165 (- sh-basic-offset))
3167 (* 2 sh-basic-offset))
3169 (* 2 (- sh-basic-offset)))
3171 (/ sh-basic-offset 2))
3173 (/ (- sh-basic-offset) 2))
3175 (funcall (if ignore-error #'message #'error)
3176 "Don't know how to handle %s's value of %s" var val)
3179 (defun sh-set-var-value (var value &optional no-symbol)
3180 "Set variable VAR to VALUE.
3181 Unless optional argument NO-SYMBOL is non-nil, then if VALUE is
3182 can be represented by a symbol then do so."
3186 ((= value sh-basic-offset)
3188 ((= value (- sh-basic-offset))
3190 ((eq value (* 2 sh-basic-offset))
3192 ((eq value (* 2 (- sh-basic-offset)))
3194 ((eq value (/ sh-basic-offset 2))
3196 ((eq value (/ (- sh-basic-offset) 2))
3203 (defun sh-calculate-indent (&optional info)
3204 "Return the indentation for the current line.
3205 If INFO is supplied it is used, else it is calculated from current line."
3210 (setq info (sh-get-indent-info)))
3213 (sh-debug "info: %s ofs=%s" info ofs)
3214 (setq elt (car info))
3216 ((stringp elt)) ;; do nothing?
3218 (setq a (car (car info)))
3219 (setq b (nth 1 (car info)))
3224 (setq val (current-indentation)))
3225 (setq base-value val))
3227 (setq val (sh-var-value b))
3233 ;; set info to nil so we stop immediately
3234 (setq base-value nil ofs nil info nil))
3235 ((eq val t) (setq ofs 0)) ;; indent as normal line
3237 ;; The following assume the (t POS) come first!
3238 (setq ofs val base-value 0)
3239 (setq info nil)))) ;; ? stop now
3240 ((eq a '+) (setq ofs (+ ofs val)))
3241 ((eq a '-) (setq ofs (- ofs val)))
3243 (error "sh-calculate-indent invalid a a=%s b=%s" a b))))
3245 (error "sh-calculate-indent invalid elt: a=%s b=%s" a b))))
3247 (error "sh-calculate-indent invalid elt %s" elt)))
3248 (sh-debug "a=%s b=%s val=%s base-value=%s ofs=%s"
3249 a b val base-value ofs)
3250 (setq info (cdr info)))
3252 (sh-debug "at end: base-value: %s ofs: %s" base-value ofs)
3255 ((or (null base-value)(null ofs))
3257 ((and (numberp base-value)(numberp ofs))
3258 (sh-debug "base (%d) + ofs (%d) = %d"
3259 base-value ofs (+ base-value ofs))
3260 (+ base-value ofs)) ;; return value
3262 (error "sh-calculate-indent: Help. base-value=%s ofs=%s"
3267 (defun sh-indent-line ()
3268 "Indent the current line."
3270 (let ((indent (sh-calculate-indent))
3271 (pos (- (point-max) (point))))
3274 (skip-chars-forward " \t")
3275 (indent-line-to indent)
3276 ;; If initial point was within line's indentation,
3277 ;; position after the indentation. Else stay at same point in text.
3278 (if (> (- (point-max) pos) (point))
3279 (goto-char (- (point-max) pos))))))
3282 (defun sh-blink (blinkpos &optional msg)
3283 "Move cursor momentarily to BLINKPOS and display MSG."
3284 ;; We can get here without it being a number on first line
3285 (if (numberp blinkpos)
3287 (goto-char blinkpos)
3288 (if msg (message "%s" msg) (message nil))
3289 (sit-for blink-matching-delay))
3290 (if msg (message "%s" msg) (message nil))))
3292 (defun sh-show-indent (arg)
3293 "Show the how the current line would be indented.
3294 This tells you which variable, if any, controls the indentation of
3296 If optional arg ARG is non-null (called interactively with a prefix),
3297 a pop up window describes this variable.
3298 If variable `sh-blink' is non-nil then momentarily go to the line
3299 we are indenting relative to, if applicable."
3301 (sh-must-support-indent)
3303 (smie-config-show-indent)
3304 (let* ((info (sh-get-indent-info))
3305 (var (sh-get-indent-var-for-line info))
3306 (curr-indent (current-indentation))
3309 (message "%s" (setq msg var))
3310 (setq val (sh-calculate-indent info))
3312 (if (eq curr-indent val)
3313 (setq msg (format "%s is %s" var (symbol-value var)))
3316 (format "%s (%s) would change indent from %d to: %d"
3317 var (symbol-value var) curr-indent val)
3318 (format "%s (%s) would leave line as is"
3319 var (symbol-value var)))
3322 (describe-variable var)))
3324 (let ((info (sh-get-indent-info)))
3325 (if (and info (listp (car info))
3326 (eq (car (car info)) t))
3327 (sh-blink (nth 1 (car info)) msg)
3328 (message "%s" msg)))
3332 (defun sh-set-indent ()
3333 "Set the indentation for the current line.
3334 If the current line is controlled by an indentation variable, prompt
3335 for a new value for it."
3337 (sh-must-support-indent)
3339 (smie-config-set-indent)
3340 (let* ((info (sh-get-indent-info))
3341 (var (sh-get-indent-var-for-line info))
3342 val old-val indent-val)
3344 (message "Cannot set indent - %s" var)
3345 (setq old-val (symbol-value var))
3346 (setq val (sh-read-variable var))
3350 (setq indent-val (sh-calculate-indent info))
3352 (message "Variable: %s Value: %s would indent to: %d"
3353 var (symbol-value var) indent-val)
3354 (message "Variable: %s Value: %s would leave line as is."
3355 var (symbol-value var)))
3356 ;; I'm not sure about this, indenting it now?
3357 ;; No. Because it would give the impression that an undo would
3358 ;; restore thing, but the value has been altered.
3363 (message "Bad value for %s, restoring to previous value %s"
3370 (defun sh-learn-line-indent (arg)
3371 "Learn how to indent a line as it currently is indented.
3373 If there is an indentation variable which controls this line's indentation,
3374 then set it to a value which would indent the line the way it
3377 If the value can be represented by one of the symbols then do so
3378 unless optional argument ARG (the prefix when interactive) is non-nil."
3380 (sh-must-support-indent)
3382 (smie-config-set-indent)
3383 ;; I'm not sure if we show allow learning on an empty line.
3384 ;; Though it might occasionally be useful I think it usually
3385 ;; would just be confusing.
3388 (looking-at "\\s-*$"))
3389 (message "sh-learn-line-indent ignores empty lines.")
3390 (let* ((info (sh-get-indent-info))
3391 (var (sh-get-indent-var-for-line info))
3392 ival sval diff new-val
3394 (curr-indent (current-indentation)))
3397 (message "Cannot learn line - %s" var))
3398 ((eq var 'sh-indent-comment)
3399 ;; This is arbitrary...
3400 ;; - if curr-indent is 0, set to curr-indent
3401 ;; - else if it has the indentation of a "normal" line,
3403 ;; - else set to curr-indent.
3404 (setq sh-indent-comment
3405 (if (= curr-indent 0)
3407 (let* ((sh-indent-comment t)
3408 (val2 (sh-calculate-indent info)))
3409 (if (= val2 curr-indent)
3412 (message "%s set to %s" var (symbol-value var))
3414 ((numberp (setq sval (sh-var-value var)))
3415 (setq ival (sh-calculate-indent info))
3416 (setq diff (- curr-indent ival))
3418 (sh-debug "curr-indent: %d ival: %d diff: %d var:%s sval %s"
3419 curr-indent ival diff var sval)
3420 (setq new-val (+ sval diff))
3421 ;; I commented out this because someone might want to replace
3422 ;; a value of `+' with the current value of sh-basic-offset
3425 ;; (message "No change needed!")
3426 (sh-set-var-value var new-val no-symbol)
3427 (message "%s set to %s" var (symbol-value var))
3431 (message "Cannot change %s" var)))))))
3435 (defun sh-mark-init (buffer)
3436 "Initialize a BUFFER to be used by `sh-mark-line'."
3437 (with-current-buffer (get-buffer-create buffer)
3442 (defun sh-mark-line (message point buffer &optional add-linenum occur-point)
3443 "Insert MESSAGE referring to location POINT in current buffer into BUFFER.
3444 Buffer BUFFER is in `occur-mode'.
3445 If ADD-LINENUM is non-nil the message is preceded by the line number.
3446 If OCCUR-POINT is non-nil then the line is marked as a new occurrence
3447 so that `occur-next' and `occur-prev' will work."
3448 (let ((m1 (make-marker))
3452 (set-marker m1 point (current-buffer))
3454 (setq line (format "%d: " (1+ (count-lines 1 point))))))
3456 (if (get-buffer buffer)
3457 (set-buffer (get-buffer buffer))
3458 (set-buffer (get-buffer-create buffer))
3461 (goto-char (point-max))
3462 (setq start (point))
3463 (let ((inhibit-read-only t))
3466 (setq occur-point (point)))
3469 (add-text-properties
3471 '(mouse-face highlight
3472 help-echo "mouse-2: go to the line where I learned this")))
3475 (put-text-property start (point) 'occur-target m1)
3477 (put-text-property start occur-point
3481 ;; Is this really worth having?
3482 (defvar sh-learned-buffer-hook nil
3483 "An abnormal hook, called with an alist of learned variables.")
3484 ;; Example of how to use sh-learned-buffer-hook
3486 ;; (defun what-i-learned (list)
3488 ;; (with-current-buffer "*scratch*"
3489 ;; (goto-char (point-max))
3490 ;; (insert "(setq\n")
3492 ;; (insert (format " %s %s \n"
3493 ;; (nth 0 (car p)) (nth 1 (car p))))
3494 ;; (setq p (cdr p)))
3498 ;; (add-hook 'sh-learned-buffer-hook 'what-i-learned)
3501 ;; Originally this was sh-learn-region-indent (beg end)
3502 ;; However, in practice this was awkward so I changed it to
3503 ;; use the whole buffer. Use narrowing if needbe.
3504 (defun sh-learn-buffer-indent (&optional arg)
3505 "Learn how to indent the buffer the way it currently is.
3507 Output in buffer \"*indent*\" shows any lines which have conflicting
3508 values of a variable, and the final value of all variables learned.
3509 When called interactively, pop to this buffer automatically if
3510 there are any discrepancies.
3512 If no prefix ARG is given, then variables are set to numbers.
3513 If a prefix arg is given, then variables are set to symbols when
3514 applicable -- e.g. to symbol `+' if the value is that of the
3516 If a positive numerical prefix is given, then `sh-basic-offset'
3517 is set to the prefix's numerical value.
3518 Otherwise, sh-basic-offset may or may not be changed, according
3519 to the value of variable `sh-learn-basic-offset'.
3521 Abnormal hook `sh-learned-buffer-hook' if non-nil is called when the
3522 function completes. The function is abnormal because it is called
3523 with an alist of variables learned. This feature may be changed or
3524 removed in the future.
3526 This command can often take a long time to run."
3528 (sh-must-support-indent)
3532 (goto-char (point-min))
3533 (let ((learned-var-list nil)
3534 (out-buffer "*indent*")
3540 (comment-col nil) ;; number if all same, t if seen diff values
3541 (comments-always-default t) ;; nil if we see one not default
3543 (specified-basic-offset (and arg (numberp arg)
3547 (setq vec (make-vector max 0))
3548 (sh-mark-init out-buffer)
3550 (if specified-basic-offset
3552 (setq sh-basic-offset arg)
3554 (format "Using specified sh-basic-offset of %d"
3557 (format "Initial value of sh-basic-offset: %s"
3560 (while (< (point) (point-max))
3561 (setq linenum (1+ linenum))
3562 ;; (if (zerop (% linenum 10))
3563 (message "line %d" linenum)
3565 (unless (looking-at "\\s-*$") ;; ignore empty lines!
3566 (let* ((sh-indent-comment t) ;; info must return default indent
3567 (info (sh-get-indent-info))
3568 (var (sh-get-indent-var-for-line info))
3569 sval ival diff new-val
3570 (curr-indent (current-indentation)))
3576 ((numberp (setq sval (sh-var-value var 'no-error)))
3577 ;; the numberp excludes comments since sval will be t.
3578 (setq ival (sh-calculate-indent))
3579 (setq diff (- curr-indent ival))
3580 (setq new-val (+ sval diff))
3581 (sh-set-var-value var new-val 'no-symbol)
3582 (unless (looking-at "\\s-*#") ;; don't learn from comments
3583 (if (setq previous-set-info (assoc var learned-var-list))
3585 ;; it was already there, is it same value ?
3586 (unless (eq (symbol-value var)
3587 (nth 1 previous-set-info))
3589 (format "Variable %s was set to %s"
3590 var (symbol-value var))
3591 (point) out-buffer t t)
3593 (format " but was previously set to %s"
3594 (nth 1 previous-set-info))
3595 (nth 2 previous-set-info) out-buffer t)
3596 (setq num-diffs (1+ num-diffs))
3597 ;; (delete previous-set-info learned-var-list)
3598 (setcdr previous-set-info
3599 (list (symbol-value var) (point)))
3602 (setq learned-var-list
3603 (append (list (list var (symbol-value var)
3606 (if (numberp new-val)
3609 "This line's indent value: %d" new-val)
3611 (setq new-val (- new-val)))
3613 (aset vec new-val (1+ (aref vec new-val))))))
3615 ((eq var 'sh-indent-comment)
3616 (unless (= curr-indent (sh-calculate-indent info))
3617 ;; this is not the default indentation
3618 (setq comments-always-default nil)
3619 (if comment-col ;; then we have see one before
3620 (or (eq comment-col curr-indent)
3621 (setq comment-col t)) ;; seen a different one
3622 (setq comment-col curr-indent))
3625 (sh-debug "Cannot learn this line!!!")
3628 "at %s learned-var-list is %s" (point) learned-var-list)
3635 "comment-col = %s comments-always-default = %s"
3636 comment-col comments-always-default))
3638 (sh-mark-line msg nil out-buffer)))
3641 (setq msg "\nComments are all in 1st column.\n"))
3642 (comments-always-default
3643 (setq msg "\nComments follow default indentation.\n")
3644 (setq comment-col t))
3645 ((numberp comment-col)
3646 (setq msg (format "\nComments are in col %d." comment-col)))
3648 (setq msg "\nComments seem to be mixed, leaving them as is.\n")
3649 (setq comment-col nil)
3652 (sh-mark-line msg nil out-buffer)
3654 (sh-mark-line initial-msg nil out-buffer t t)
3656 (setq suggested (sh-guess-basic-offset vec))
3658 (if (and suggested (not specified-basic-offset))
3661 ;; t => set it if we have a single value as a number
3662 ((and (eq sh-learn-basic-offset t) (numberp suggested))
3664 ;; other non-nil => set it if only one value was found
3665 (sh-learn-basic-offset
3666 (if (numberp suggested)
3668 (if (= (length suggested) 1)
3674 (setq learned-var-list
3675 (append (list (list 'sh-basic-offset
3676 (setq sh-basic-offset new-value)
3679 ;; Not sure if we need to put this line in, since
3680 ;; it will appear in the "Learned variable settings".
3682 (format "Changed sh-basic-offset to: %d" sh-basic-offset)
3685 (if (listp suggested)
3686 (format "Possible value(s) for sh-basic-offset: %s"
3687 (mapconcat 'int-to-string suggested " "))
3688 (format "Suggested sh-basic-offset: %d" suggested))
3692 (setq learned-var-list
3693 (append (list (list 'sh-indent-comment comment-col (point-max)))
3695 (setq sh-indent-comment comment-col)
3696 (let ((name (buffer-name)))
3697 (sh-mark-line "\nLearned variable settings:" nil out-buffer)
3699 ;; Set learned variables to symbolic rather than numeric
3700 ;; values where possible.
3701 (dolist (learned-var (reverse learned-var-list))
3702 (let ((var (car learned-var))
3703 (val (nth 1 learned-var)))
3704 (when (and (not (eq var 'sh-basic-offset))
3706 (sh-set-var-value var val)))))
3707 (dolist (learned-var (reverse learned-var-list))
3708 (let ((var (car learned-var)))
3709 (sh-mark-line (format " %s %s" var (symbol-value var))
3710 (nth 2 learned-var) out-buffer)))
3711 (with-current-buffer out-buffer
3712 (goto-char (point-min))
3713 (let ((inhibit-read-only t))
3715 (format "Indentation values for buffer %s.\n" name)
3716 (format "%d indentation variable%s different values%s\n\n"
3720 (if (zerop num-diffs)
3722 ;; Are abnormal hooks considered bad form?
3723 (run-hook-with-args 'sh-learned-buffer-hook learned-var-list)
3724 (and (called-interactively-p 'any)
3725 (or sh-popup-occur-buffer (> num-diffs 0))
3726 (pop-to-buffer out-buffer))))))
3728 (defun sh-guess-basic-offset (vec)
3729 "See if we can determine a reasonable value for `sh-basic-offset'.
3730 This is experimental, heuristic and arbitrary!
3731 Argument VEC is a vector of information collected by
3732 `sh-learn-buffer-indent'.
3734 number - there appears to be a good single value
3735 list of numbers - no obvious one, here is a list of one or more
3737 nil - we couldn't find a reasonable one."
3738 (let* ((max (1- (length vec)))
3740 (totals (make-vector max 0)))
3742 (cl-incf (aref totals i) (* 4 (aref vec i)))
3744 (cl-incf (aref totals i) (aref vec (/ i 2))))
3746 (cl-incf (aref totals i) (aref vec (* i 2))))
3754 (if (/= (aref totals i) 0)
3755 (push (cons i (aref totals i)) x))
3758 (setq x (sort (nreverse x) (lambda (a b) (> (cdr a) (cdr b)))))
3759 (setq tot (apply '+ (append totals nil)))
3760 (sh-debug (format "vec: %s\ntotals: %s\ntot: %d"
3764 (message "no values!")) ;; we return nil
3766 (message "only value is %d" (car (car x)))
3767 (setq result (car (car x)))) ;; return single value
3768 ((> (cdr (car x)) (/ tot 2))
3770 (message "basic-offset is probably %d" (car (car x)))
3771 (setq result (car (car x)))) ;; again, return a single value
3772 ((>= (cdr (car x)) (* 2 (cdr (car (cdr x)))))
3773 ;; 1st is >= 2 * 2nd
3774 (message "basic-offset could be %d" (car (car x)))
3775 (setq result (car (car x))))
3776 ((>= (+ (cdr (car x))(cdr (car (cdr x)))) (/ tot 2))
3777 ;; 1st & 2nd together >= 50% - return a list
3778 (setq p x sum 0 result nil)
3780 (<= (setq sum (+ sum (cdr (car p)))) (/ tot 2)))
3781 (setq result (append result (list (car (car p)))))
3783 (message "Possible choices for sh-basic-offset: %s"
3784 (mapconcat 'int-to-string result " ")))
3786 (message "No obvious value for sh-basic-offset. Perhaps %d"
3788 ;; result is nil here
3792 ;; ========================================================================
3794 ;; Styles -- a quick and dirty way of saving the indentation settings.
3796 (defvar sh-styles-alist nil
3797 "A list of all known shell indentation styles.")
3799 (defun sh-name-style (name &optional confirm-overwrite)
3800 "Name the current indentation settings as a style called NAME.
3801 If this name exists, the command will prompt whether it should be
3803 - - it was called interactively with a prefix argument, or
3804 - - called non-interactively with optional CONFIRM-OVERWRITE non-nil."
3805 ;; (interactive "sName for this style: ")
3808 (read-from-minibuffer "Name for this style? " )
3809 (not current-prefix-arg)))
3810 (let ((slist (cons name
3811 (mapcar (lambda (var) (cons var (symbol-value var)))
3813 (style (assoc name sh-styles-alist)))
3815 (if (and confirm-overwrite
3816 (not (y-or-n-p "This style exists. Overwrite it? ")))
3817 (message "Not changing style %s" name)
3818 (message "Updating style %s" name)
3819 (setcdr style (cdr slist)))
3820 (message "Creating new style %s" name)
3821 (push slist sh-styles-alist))))
3823 (defun sh-load-style (name)
3824 "Set shell indentation values for this buffer from those in style NAME."
3825 (interactive (list (completing-read
3826 "Which style to use for this buffer? "
3827 sh-styles-alist nil t)))
3828 (let ((sl (assoc name sh-styles-alist)))
3830 (error "sh-load-style - style %s not known" name)
3831 (dolist (var (cdr sl))
3832 (set (car var) (cdr var))))))
3834 (defun sh-save-styles-to-buffer (buff)
3835 "Save all current styles in elisp to buffer BUFF.
3836 This is always added to the end of the buffer."
3839 (read-from-minibuffer "Buffer to save styles in? " "*scratch*")))
3840 (with-current-buffer (get-buffer-create buff)
3841 (goto-char (point-max))
3843 (pp `(setq sh-styles-alist ',sh-styles-alist) (current-buffer))))
3847 ;; statement syntax-commands for various shells
3849 ;; You are welcome to add the syntax or even completely new statements as
3850 ;; appropriate for your favorite shell.
3852 (defconst sh-non-closing-paren
3853 ;; If we leave it rear-sticky, calling `newline' ends up inserting a \n
3854 ;; that inherits this property, which then confuses the indentation.
3855 (propertize ")" 'syntax-table sh-st-punc 'rear-nonsticky t))
3857 (define-skeleton sh-case
3858 "Insert a case/switch statement. See `sh-feature'."
3860 "switch( " str " )" \n
3861 > "case " (read-string "pattern: ") ?: \n
3864 ( "other pattern, %s: "
3874 > "switch( " str " ) {" \n
3875 > "case " (read-string "pattern: ") \n
3877 ( "other pattern, %s: "
3885 > "case " str " in" \n
3887 > str sh-non-closing-paren \n
3890 > "*" sh-non-closing-paren \n
3895 (define-skeleton sh-for
3896 "Insert a for loop. See `sh-feature'."
3910 (sh "Index variable: "
3911 > "for " str " in " _ "; do" \n
3912 > _ | ?$ & (sh-remember-variable str) \n
3917 (define-skeleton sh-indexed-loop
3918 "Insert an indexed loop from 1 to n. See `sh-feature'."
3919 (bash sh-modify posix)
3920 (csh "Index variable: "
3922 "while( $" str " <= " (read-string "upper limit: ") " )" \n
3928 (ksh88 "Index variable: "
3929 > "integer " str "=0" \n
3930 > "while (( ( " str " += 1 ) <= "
3931 (read-string "upper limit: ")
3933 > _ ?$ (sh-remember-variable str) > \n
3935 (posix "Index variable: "
3937 "while [ $" str " -le "
3938 (read-string "upper limit: ")
3941 str ?= (sh-add (sh-remember-variable str) 1) \n
3943 (rc "Index variable: "
3944 > "for( " str " in" " `{awk 'BEGIN { for( i=1; i<="
3945 (read-string "upper limit: ")
3946 "; i++ ) print i }'`}) {" \n
3947 > _ ?$ (sh-remember-variable str) \n
3949 (sh "Index variable: "
3950 > "for " str " in `awk 'BEGIN { for( i=1; i<="
3951 (read-string "upper limit: ")
3952 "; i++ ) print i }'`; do" \n
3953 > _ ?$ (sh-remember-variable str) \n
3957 (defun sh-shell-initialize-variables ()
3958 "Scan the buffer for variable assignments.
3959 Add these variables to `sh-shell-variables'."
3960 (message "Scanning buffer `%s' for variable assignments..." (buffer-name))
3962 (goto-char (point-min))
3963 (setq sh-shell-variables-initialized t)
3964 (while (search-forward "=" nil t)
3966 (message "Scanning buffer `%s' for variable assignments...done"
3969 (defvar sh-add-buffer)
3971 (defun sh-add-completer (string predicate code)
3972 "Do completion using `sh-shell-variables', but initialize it first.
3973 This function is designed for use as the \"completion table\",
3974 so it takes three arguments:
3975 STRING, the current buffer contents;
3976 PREDICATE, the predicate for filtering possible matches;
3977 CODE, which says what kind of things to do.
3978 CODE can be nil, t or `lambda'.
3979 nil means to return the best completion of STRING, or nil if there is none.
3980 t means to return a list of all possible completions of STRING.
3981 `lambda' means to return t if STRING is a valid completion as it stands."
3983 (with-current-buffer sh-add-buffer
3984 (or sh-shell-variables-initialized
3985 (sh-shell-initialize-variables))
3986 (nconc (mapcar (lambda (var)
3987 (substring var 0 (string-match "=" var)))
3988 process-environment)
3989 sh-shell-variables))))
3990 (complete-with-action code vars string predicate)))
3992 (defun sh-add (var delta)
3993 "Insert an addition of VAR and prefix DELTA for Bourne (type) shell."
3995 (let ((sh-add-buffer (current-buffer)))
3996 (list (completing-read "Variable: " 'sh-add-completer)
3997 (prefix-numeric-value current-prefix-arg))))
3998 (insert (sh-feature '((bash . "$(( ")
4004 (sh-remember-variable var)
4005 (if (< delta 0) " - " " + ")
4006 (number-to-string (abs delta))
4007 (sh-feature '((bash . " ))")
4016 (define-skeleton sh-function
4017 "Insert a function definition. See `sh-feature'."
4018 (bash sh-modify ksh88
4021 "function " str " {" \n
4033 (define-skeleton sh-if
4034 "Insert an if statement. See `sh-feature'."
4036 "if( " str " ) then" \n
4038 ( "other condition, %s: "
4039 < "else if( " str " ) then" \n
4046 > "if { " str " } {" \n
4048 ( "other condition, %s: "
4049 "} { " str " } {" > \n
4056 > "if( " str " ) {" \n
4058 ( "other condition, %s: "
4059 "} else if( " str " ) {" > \n
4066 '(setq input (sh-feature sh-test))
4067 > "if " str "; then" \n
4069 ( "other condition, %s: "
4070 > "elif " str "; then" > \n
4079 (define-skeleton sh-repeat
4080 "Insert a repeat loop definition. See `sh-feature'."
4086 > "repeat " str "; do" > \n
4090 ;;;(put 'sh-repeat 'menu-enable '(sh-feature sh-repeat))
4094 (define-skeleton sh-select
4095 "Insert a select statement. See `sh-feature'."
4096 (ksh88 "Index variable: "
4097 > "select " str " in " _ "; do" \n
4100 (bash sh-append ksh88))
4101 ;;;(put 'sh-select 'menu-enable '(sh-feature sh-select))
4105 (define-skeleton sh-tmp-file
4106 "Insert code to setup temporary file handling. See `sh-feature'."
4107 (bash sh-append ksh88)
4108 (csh (file-name-nondirectory (buffer-file-name))
4109 "set tmp = `mktemp -t " str ".XXXXXX`" \n
4111 (and (goto-char (point-max))
4115 "rm $tmp* >&/dev/null" > \n)
4116 (es (file-name-nondirectory (buffer-file-name))
4117 > "local( signals = $signals sighup sigint;" \n
4118 > "tmp = `{ mktemp -t " str ".XXXXXX } ) {" \n
4120 > "rm $tmp^* >[2]/dev/null" \n
4128 (rc (file-name-nondirectory (buffer-file-name))
4129 > "tmp = `{ mktemp -t " str ".XXXXXX }" \n
4130 "fn sigexit { rm $tmp^* >[2]/dev/null }" \n)
4131 (sh (file-name-nondirectory (buffer-file-name))
4132 > "TMP=`mktemp -t " str ".XXXXXX`" \n
4133 "trap \"rm $TMP* 2>/dev/null\" " ?0 \n))
4137 (define-skeleton sh-until
4138 "Insert an until loop. See `sh-feature'."
4140 '(setq input (sh-feature sh-test))
4141 > "until " str "; do" \n
4144 ;;;(put 'sh-until 'menu-enable '(sh-feature sh-until))
4148 (define-skeleton sh-while
4149 "Insert a while loop. See `sh-feature'."
4165 '(setq input (sh-feature sh-test))
4166 > "while " str "; do" \n
4172 (define-skeleton sh-while-getopts
4173 "Insert a while getopts loop. See `sh-feature'.
4174 Prompts for an options string which consists of letters for each recognized
4175 option followed by a colon `:' if the option accepts an argument."
4180 > "switch( \"$1\" )" \n
4181 '(setq input '("- x" . 2))
4184 < "case " '(eval str)
4185 '(if (string-match " +" str)
4186 (setq v1 (substring str (match-end 0))
4187 str (substring str 0 (match-beginning 0)))
4190 > "set " v1 & " = $2" | -4 & _ \n
4191 (if v1 "shift") & \n
4206 18 "$(basename $0)")
4208 > "while getopts :" str " OPT; do" \n
4210 '(setq v1 (append (vconcat str) nil))
4211 ( (prog1 (if v1 (char-to-string (car v1)))
4212 (if (eq (nth 1 v1) ?:)
4213 (setq v1 (nthcdr 2 v1)
4217 > str "|+" str sh-non-closing-paren \n
4220 > "*" sh-non-closing-paren \n
4221 > "echo" " \"usage: " "`basename $0`"
4222 " [+-" '(setq v1 (point)) str
4224 (while (search-backward ":" v1 t)
4225 (replace-match " ARG] [+-" t t)))
4226 (if (eq (preceding-char) ?-) -5)
4227 (if (and (sequencep v1) (length v1)) "] " "} ")
4233 "shift " (sh-add "OPTIND" -1) \n
4238 (defun sh-assignment (arg)
4239 "Remember preceding identifier for future completion and do self-insert."
4241 (self-insert-command arg)
4243 (sh-remember-variable
4245 (if (re-search-forward (sh-feature sh-assignment-regexp)
4247 (beginning-of-line 1))
4249 (match-string 1))))))
4252 (defun sh-maybe-here-document (arg)
4253 "Insert self. Without prefix, following unquoted `<' inserts here document.
4254 The document is bounded by `sh-here-document-word'."
4255 (declare (obsolete sh-electric-here-document-mode "24.3"))
4257 (self-insert-command (prefix-numeric-value arg))
4258 (or arg (sh--maybe-here-document)))
4260 (defun sh--maybe-here-document ()
4261 (or (not (looking-back "[^<]<<"))
4265 (nth 8 (syntax-ppss))
4266 (let ((tabs (if (string-match "\\`-" sh-here-document-word)
4267 (make-string (/ (current-indentation) tab-width) ?\t)
4269 (delim (replace-regexp-in-string "['\"]" ""
4270 sh-here-document-word)))
4271 (insert sh-here-document-word)
4272 (or (eolp) (looking-at "[ \t]") (insert ?\s))
4279 (insert ?\n tabs (replace-regexp-in-string
4280 "\\`-?[ \t]*" "" delim))))))
4282 (define-minor-mode sh-electric-here-document-mode
4283 "Make << insert a here document skeleton."
4285 (if sh-electric-here-document-mode
4286 (add-hook 'post-self-insert-hook #'sh--maybe-here-document nil t)
4287 (remove-hook 'post-self-insert-hook #'sh--maybe-here-document t)))
4289 ;; various other commands
4291 (defun sh-beginning-of-command ()
4292 ;; FIXME: Redefine using SMIE.
4293 "Move point to successive beginnings of commands."
4295 (if (re-search-backward sh-beginning-of-command nil t)
4296 (goto-char (match-beginning 2))))
4298 (defun sh-end-of-command ()
4299 ;; FIXME: Redefine using SMIE.
4300 "Move point to successive ends of commands."
4302 (if (re-search-forward sh-end-of-command nil t)
4303 (goto-char (match-end 1))))
4305 ;; Backslashification. Stolen from make-mode.el.
4307 (defun sh-backslash-region (from to delete-flag)
4308 "Insert, align, or delete end-of-line backslashes on the lines in the region.
4309 With no argument, inserts backslashes and aligns existing backslashes.
4310 With an argument, deletes the backslashes.
4312 This function does not modify the last line of the region if the region ends
4313 right at the start of the following line; it does not modify blank lines
4314 at the start of the region. So you can put the region around an entire
4315 shell command and conveniently use this command."
4316 (interactive "r\nP")
4319 (let ((column sh-backslash-column)
4320 (endmark (make-marker)))
4321 (move-marker endmark to)
4322 ;; Compute the smallest column number past the ends of all the lines.
4323 (if sh-backslash-align
4325 (if (not delete-flag)
4326 (while (< (point) to)
4328 (if (= (preceding-char) ?\\)
4329 (progn (forward-char -1)
4330 (skip-chars-backward " \t")))
4331 (setq column (max column (1+ (current-column))))
4333 ;; Adjust upward to a tab column, if that doesn't push
4335 (if (> (% column tab-width) 0)
4336 (let ((adjusted (* (/ (+ column tab-width -1) tab-width)
4338 (if (< adjusted (window-width))
4339 (setq column adjusted))))))
4340 ;; Don't modify blank lines at start of region.
4342 (while (and (< (point) endmark) (eolp))
4344 ;; Add or remove backslashes on all the lines.
4345 (while (and (< (point) endmark)
4346 ;; Don't backslashify the last line
4347 ;; if the region ends right at the start of the next line.
4350 (< (point) endmark)))
4351 (if (not delete-flag)
4352 (sh-append-backslash column)
4353 (sh-delete-backslash))
4355 (move-marker endmark nil))))
4357 (defun sh-append-backslash (column)
4359 ;; Note that "\\\\" is needed to get one backslash.
4360 (if (= (preceding-char) ?\\)
4361 (progn (forward-char -1)
4362 (delete-horizontal-space)
4363 (indent-to column (if sh-backslash-align nil 1)))
4364 (indent-to column (if sh-backslash-align nil 1))
4367 (defun sh-delete-backslash ()
4372 (if (looking-at "\\\\")
4373 (delete-region (1+ (point))
4374 (progn (skip-chars-backward " \t") (point)))))))
4376 (provide 'sh-script)
4378 ;;; sh-script.el ends here