Current File : //usr/local/share/emacs/27.2/lisp/progmodes/sh-script.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.
;;; This file uses dynamic docstrings, first added in Emacs 19.29.
;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(byte-code "\300\301!\210\302\303\304\"\210\302\305\304\"\210\302\306\304\"\210\302\307\310\"\210\302\311\310\"\210\312\313\314\315\316\317%\210\312\320\314\321\322\323\316\313\324\325& \210\326\327\330\331\332DD\333\334\335\336\337\316\320& \210\326\340\330\331\341DD\342\334\343\316\320&\210\326\344\330\331\345DD\346\334\347\316\320&\210\326\350\330\331\351DD\352\334\353\316\320&\210\326\354\330\331\355DD\356\334\357\316\320\336\360& \207" [require executable autoload comint-completion-at-point "comint" comint-filename-completion comint-send-string shell-command-completion "shell" shell-environment-variable-completion custom-declare-group sh nil "Shell programming utilities." :group languages sh-script "Shell script mode." :link (custom-group-link :tag "Font Lock Faces group" font-lock-faces) :prefix "sh-" custom-declare-variable sh-ancestor-alist funcall function #[0 "\300\207" [((ash . sh) (bash . jsh) (bash2 . jsh) (dash . ash) (dtksh . ksh) (es . rc) (itcsh . tcsh) (jcsh . csh) (jsh . sh) (ksh . ksh88) (ksh88 . jsh) (oash . sh) (pdksh . ksh88) (mksh . pdksh) (posix . sh) (tcsh . csh) (wksh . ksh88) (wsh . sh) (zsh . ksh88) (rpm . sh))] 1] "Alist showing the direct ancestor of various shells.\nThis is the basis for `sh-feature'. See also `sh-alias-alist'.\nBy default we have the following three hierarchies:\n\ncsh C Shell\n jcsh C Shell with Job Control\n tcsh TENEX C Shell\n itcsh Ian's TENEX C Shell\nrc Plan 9 Shell\n es Extensible Shell\nsh Bourne Shell\n ash Almquist Shell\n dash Debian Almquist Shell\n jsh Bourne Shell with Job Control\n bash GNU Bourne Again Shell\n ksh88 Korn Shell '88\n ksh Korn Shell '93\n dtksh CDE Desktop Korn Shell\n pdksh Public Domain Korn Shell\n mksh MirOS BSD Korn Shell\n wksh Window Korn Shell\n zsh Z Shell\n oash SCO OA (curses) Shell\n posix IEEE 1003.2 Shell Standard\n wsh ? Shell" :type (repeat (cons symbol symbol)) :version "24.4" sh-alias-alist #[0 "\301\302=\205 \303\304\"\207" [system-type append gnu/linux ((csh . tcsh) (ksh . pdksh)) ((ksh . ksh88) (bash2 . bash) (sh5 . sh) ("^/system/bin/sh$" . mksh))] 3] "Alist for transforming shell names to what they really are.\nUse this where the name of the executable doesn't correspond to\nthe type of shell it really is. Keys are regular expressions\nmatched against the full path of the interpreter. (For backward\ncompatibility, keys may also be symbols, which are matched\nagainst the interpreter's basename. The values are symbols\nnaming the shell." (repeat (cons (radio (regexp :tag "Regular expression") (symbol :tag "Basename")) (symbol :tag "Shell"))) sh-shell-file #[0 "\301>\203( \302\303!\211\205 \304!\203 \211\227\305\235\203 \306\202# \307\227!\266\202\206/ \302\303!\206/ \306\207" [system-type (ms-dos windows-nt) getenv "SHELL" file-name-nondirectory ("command.com" "cmd.exe" "4dos.com" "ndos.com" "cmdproxy.exe") "/bin/sh" file-name-sans-extension] 4] "The executable file name for the shell being programmed." string sh-shell-arg #[0 "\300\207" [((bash) (csh . "-f") (pdksh) (ksh88) (rc . "-p") (wksh) (zsh . "-f"))] 1] "Single argument string for the magic number. See `sh-feature'." (repeat (cons (symbol :tag "Shell") (choice (const :tag "No Arguments" nil) (string :tag "Arguments") (sexp :format "Evaluate: %v")))) sh-imenu-generic-expression #[0 "\300\207" [((sh (nil "^\\s-*function\\s-+\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?" 1) (nil "^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()" 1)))] 1] "Alist of regular expressions for recognizing shell function definitions.\nSee `sh-feature' and `imenu-generic-expression'." (alist :key-type (symbol :tag "Shell") :value-type (alist :key-type (choice :tag "Title" string (const :tag "None" nil)) :value-type (repeat :tag "Regexp, index..." sexp))) "20.4"] 10)
#@94 Find the name of function or variable at point.
For use in `add-log-current-defun-function'.
(defalias 'sh-current-defun-name #[0 "\212\300\210\301\302\300\303#\205 \304\305!\206 \304\306!\206 \304\307!)\207" [nil re-search-backward "\\(?:^\\s-*function\\s-+\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*\\(?:()\\)?\\)\\|\\(?:^\\s-*\\([[:alpha:]_][[:alnum:]_]*\\)\\s-*()\\)\\|\\(?:^\\([[:alpha:]_][[:alnum:]_]*\\)=\\)" t match-string-no-properties 1 2 3] 4 (#$ . 4251)])
#@246 Alist of shell variable names that should be included in completion.
These are used for completion in addition to all the variables named
in `process-environment'. Each element looks like (VAR . VAR), where
the car and cdr are the same symbol.
(defvar sh-shell-variables nil (#$ . 4723))
#@49 Non-nil if `sh-shell-variables' is initialized.
(defvar sh-shell-variables-initialized nil (#$ . 5018))
#@150 Convert a shell name SHELL to the one we should handle it as.
SHELL is a full path to the shell interpreter; return a shell
name symbol.
(fn SHELL)
(defalias 'sh-canonicalize-shell #[257 "\301\302\"\203 \303\304\211\224#\202 \211\305\306!!\307\211\310\307:\203c @\262\211A\262\242\262;\203C \301\"\203C \262\307\211\262\202D \310\203c =\203X \262\307\211\262\202Y \310\203c A\262\202 \203k \202l \211\207" [sh-alias-alist string-match "\\.exe\\'" substring 0 intern file-name-nondirectory nil t] 11 (#$ . 5129)])
#@62 The shell being programmed. This is set by \[sh-set-shell].
(defvar sh-shell (sh-canonicalize-shell sh-shell-file) (#$ . 5679))
(define-abbrev-table 'sh-mode-abbrev-table nil)
#@95 Copy TABLE and set syntax for successive CHARs according to strings S.
(fn TABLE &rest LIST)
(defalias 'sh-mode-syntax-table #[385 "\300!\262\211\203 \301\211A\262\242\211A\262\242#\210\202 \207" [copy-syntax-table modify-syntax-entry] 6 (#$ . 5862)])
#@91 The syntax table to use for Shell-Script mode.
This is buffer-local in every such buffer.
(defvar sh-mode-syntax-table (sh-mode-syntax-table nil 35 "<" 10 ">#" 34 "\"\"" 39 "\"'" 96 "\"`" 36 "'" 33 #1="_" 37 #1# 58 #1# 46 #1# 94 #1# 126 #1# 44 #1# 61 #2="." 59 #2# 124 #2# 38 #2# 60 #2# 62 #2#) (#$ . 6131))
#@60 Syntax-table used in Shell-Script mode. See `sh-feature'.
(defvar sh-mode-syntax-table-input (byte-code "\301\302\303BBD\207" [sh-mode-syntax-table (sh) rpm (39 ".")] 4) (#$ . 6445))
#@35 Keymap used in Shell-Script mode.
(defvar sh-mode-map (byte-code "\300 \300 \301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\210\301\314\315#\210\301\316\317#\210\301\320\321#\210\301\322\323#\210\301\324\325#\210\301\326\327#\210\301\330\331#\210\301\332\333#\210\301\334\335#\210\301\336\337#\210\301\340\341#\210\301\342\343#\210\301\344\345#\210\301\346\347#\210\301\350\351#\210\301\352\353#\210\301\354\355#\210\301\356\357#\210\301\360\361#\210\301\362\363#\210\301\364\365#\210\301\366\367B#\210\301\370\371#\210\301\372\373#\210\301\374\375#\210\301\376\377#\210\301\201@ \201A #\210\301\201B \201C #\210\301\201D \201E #\210\301\201F \201G #\210\301\201H \201I #\210\301\201J \201K #\210\301\201L \201M #\210\301\201N \201O #\210\301\201P \201Q #\210\301\201R \201S #\210\301\201T \201U #\210\301\201V \201W #\210\301\201X \201Y #\210\301\201Z \201[ #\210\301\201\\ \201] #\210\301\201^ \201_ #\210\301\201` \201a #\210\301\201b \201c #\210\207" [make-sparse-keymap define-key "(" sh-function "" sh-while "" sh-until "" sh-tmp-file "" sh-select "" sh-repeat "" sh-while-getopts "\f" sh-indexed-loop " " sh-if "" sh-for "" sh-case "?" sh-show-indent "=" sh-set-indent "<" sh-learn-line-indent ">" sh-learn-buffer-indent " " sh-backslash-region "+" sh-add "\230" sh-execute-region "" executable-interpret "" sh-send-line-or-region-and-step "" sh-cd-here "" sh-show-shell [remap delete-backward-char] backward-delete-char-untabify ":" sh-set-shell [remap backward-sentence] sh-beginning-of-command [remap forward-sentence] sh-end-of-command [menu-bar sh-script] "Sh-Script" [sh-learn-buffer-indent] (menu-item "Learn buffer indentation" sh-learn-buffer-indent :help "Learn how to indent the buffer the way it currently is.") [sh-learn-line-indent] (menu-item "Learn line indentation" sh-learn-line-indent :help "Learn how to indent a line as it currently is indented") [sh-show-indent] (menu-item "Show indentation" sh-show-indent :help "Show the how the current line would be indented") [sh-set-indent] (menu-item "Set indentation" sh-set-indent :help "Set the indentation for the current line") [sh-pair] (menu-item "Insert braces and quotes in pairs" electric-pair-mode :button (:toggle bound-and-true-p electric-pair-mode) :help "Inserting a brace or quote automatically inserts the matching pair") [sh-s0] ("--") [sh-function] (menu-item "Function..." sh-function :help "Insert a function definition") [sh-add] (menu-item "Addition..." sh-add :help "Insert an addition of VAR and prefix DELTA for Bourne (type) shell") [sh-until] (menu-item "Until Loop" sh-until :help "Insert an until loop") [sh-repeat] (menu-item "Repeat Loop" sh-repeat :help "Insert a repeat loop definition") [sh-while] (menu-item "While Loop" sh-while :help "Insert a while loop") [sh-getopts] (menu-item "Options Loop" sh-while-getopts :help "Insert a while getopts loop.") [sh-indexed-loop] (menu-item "Indexed Loop" sh-indexed-loop :help "Insert an indexed loop from 1 to n.") [sh-select] (menu-item "Select Statement" sh-select :help "Insert a select statement ") [sh-if] (menu-item "If Statement" sh-if :help "Insert an if statement") [sh-for] (menu-item "For Loop" sh-for :help "Insert a for loop") [sh-case] (menu-item "Case Statement" sh-case :help "Insert a case/switch statement") [sh-s1] ("--") [sh-exec] (menu-item "Execute region" sh-execute-region :help "Pass optional header and region to a subshell for noninteractive execution") [sh-exec-interpret] (menu-item "Execute script..." executable-interpret :help "Run script with user-specified args, and collect output in a buffer") [sh-set-shell] (menu-item "Set shell type..." sh-set-shell :help "Set this buffer's shell to SHELL (a string)") [sh-backslash-region] (menu-item "Backslash region" sh-backslash-region :help "Insert, align, or delete end-of-line backslashes on the lines in the region.")] 7) (#$ . 6636))
#@70 Value to use for `skeleton-pair-default-alist' in Shell-Script mode.
(defvar sh-skeleton-pair-default-alist '((40 _ 41) (41) (91 32 _ 32 93) (93) (123 _ 125) (125)) (#$ . 10627))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\315\310\311&\210\316\317\320\321#\210\322\211\203F \211@\317N\203? \320N\204? \323\320\317N#\210A\266\202\202% \210\324\317\320\325#\210\323\317\326\327#\210\300\330\302\303\331DD\332\306\333\310\311&\207" [custom-declare-variable sh-dynamic-complete-functions funcall function #[0 "\300\207" [(shell-environment-variable-completion shell-command-completion comint-filename-completion)] 1] "Functions for doing TAB dynamic completion." :type (repeat function) :group sh-script sh-assignment-regexp #[0 "\300\301\302B\303BB\207" [(csh . "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?[ ]*[-+*/%^]?=") ksh88 "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?[ ]*\\(?:[-+*/%&|~^]\\|<<\\|>>\\)?=" ((bash . "\\<\\([[:alnum:]_]+\\)\\(\\[.+\\]\\)?\\+?=") (rc . "\\<\\([[:alnum:]_*]+\\)[ ]*=") (sh . "\\<\\([[:alnum:]_]+\\)="))] 3] "Regexp for the variable name and what may follow in an assignment.\nFirst grouping matches the variable name. This is upto and including the `='\nsign. See `sh-feature'." (repeat (cons (symbol :tag "Shell") (choice regexp (sexp :format "Evaluate: %v")))) defvaralias sh-indentation sh-basic-offset nil (saved-value saved-variable-comment) put make-obsolete-variable "26.1" safe-local-variable integerp sh-remember-variable-min #[0 "\300\207" [3] 1] "Don't remember variables less than this length for completing reads." integer] 8)
#@128 When non-nil is the end of header for prepending by \[sh-execute-region].
That command is also used for setting this variable.
(defvar sh-header-marker nil (#$ . 12252))
(byte-code "\300\301!\210\302\303\304\305\306DD\307\310\311\312\313&\210\302\314\304\305\315DD\316\310\311\312\313&\210\302\317\304\305\320DD\321\310\322\312\313&\207" [make-variable-buffer-local sh-header-marker custom-declare-variable sh-beginning-of-command funcall function #[0 "\300\207" [#1="\\([;({`|&]\\|\\`\\|[^\\]\n\\)[ ]*\\([/~[:alnum:]:]\\)"] 1 #1#] "Regexp to determine the beginning of a shell command.\nThe actual command starts at the beginning of the second \\(grouping\\)." :type regexp :group sh-script sh-end-of-command #[0 "\300\207" [#2="\\([/~[:alnum:]:]\\)[ ]*\\([;#)}`|&]\\|$\\)"] 1 #2#] "Regexp to determine the end of a shell command.\nThe actual command ends at the end of the first \\(grouping\\)." sh-here-document-word #[0 "\300\207" [#3="EOF"] 1 #3#] "Word to delimit here documents.\nIf the first character of this string is \"-\", this is taken as\npart of the redirection operator, rather than part of the\nword (that is, \"<<-\" instead of \"<<\"). This is a feature\nused by some shells (for example Bash) to indicate that leading\ntabs inside the here document should be ignored. In this case,\nEmacs indents the initial body and end of the here document with\ntabs, to the same level as the start (note that apart from this\nthere is no support for indentation of here documents). This\nwill only work correctly if `sh-basic-offset' is a multiple of\n`tab-width'.\n\nAny quote characters or leading whitespace in the word are\nremoved when closing the here document." string] 8)
#@75 Initial input in Bourne if, while and until skeletons. See `sh-feature'.
(defvar sh-test '((sh "[ ]" . 3) (ksh88 "[[ ]]" . 4)) (#$ . 13954))
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \210\300\314\302\303\315DD\316\306\317\312\313&\210\300\320\302\303\321DD\322\306\323\312\313&\207" [custom-declare-variable sh-builtins funcall function #[0 "\300\207" [((bash sh-append posix "." "alias" "bg" "bind" "builtin" "caller" "compgen" "complete" "declare" "dirs" "disown" "enable" "fc" "fg" "help" "history" "jobs" "kill" "let" "local" "popd" "printf" "pushd" "shopt" "source" "suspend" "typeset" "unalias" "mapfile" "readarray" "coproc") (bourne sh-append shell "eval" "export" "getopts" "newgrp" "pwd" "read" "readonly" "times" "ulimit") (csh sh-append shell "alias" "chdir" "glob" "history" "limit" "nice" "nohup" "rehash" "setenv" "source" "time" "unalias" "unhash") (dtksh sh-append wksh) (es "access" "apids" "cd" "echo" "eval" "false" "let" "limit" "local" "newpgrp" "result" "time" "umask" "var" "vars" "wait" "whatis") (jsh sh-append sh "bg" "fg" "jobs" "kill" "stop" "suspend") (jcsh sh-append csh "bg" "fg" "jobs" "kill" "notify" "stop" "suspend") (ksh88 sh-append bourne "alias" "bg" "false" "fc" "fg" "jobs" "kill" "let" "print" "time" "typeset" "unalias" "whence") (oash sh-append sh "checkwin" "dateline" "error" "form" "menu" "newwin" "oadeinit" "oaed" "oahelp" "oainit" "pp" "ppfile" "scan" "scrollok" "wattr" "wclear" "werase" "win" "wmclose" "wmmessage" "wmopen" "wmove" "wmtitle" "wrefresh") (pdksh sh-append ksh88 "bind") (posix sh-append sh "command") (rc "builtin" "cd" "echo" "eval" "limit" "newpgrp" "shift" "umask" "wait" "whatis") (sh sh-append bourne "hash" "test" "type") (shell "cd" "echo" "eval" "set" "shift" "umask" "unset" "wait") (wksh sh-append ksh88) (zsh sh-append ksh88 "autoload" "bindkey" "builtin" "chdir" "compctl" "declare" "dirs" "disable" "disown" "echotc" "enable" "functions" "getln" "hash" "history" "integer" "limit" "local" "log" "popd" "pushd" "r" "readonly" "rehash" "sched" "setopt" "source" "suspend" "true" "ttyctl" "type" "unfunction" "unhash" "unlimit" "unsetopt" "vared" "which"))] 1] "List of all shell builtins for completing read and fontification.\nNote that on some systems not all builtins are available or some are\nimplemented as aliases. See `sh-feature'." :type (repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v")))) :version "24.4" :group sh-script sh-leading-keywords #[0 "\300\207" [((bash sh-append sh "time") (csh "else") (es "true" "unwind-protect" "whatis") (rc "else") (sh "!" "do" "elif" "else" "if" "then" "trap" "type" "until" "while"))] 1] "List of keywords that may be immediately followed by a builtin or keyword.\nGiven some confusion between keywords and builtins depending on shell and\nsystem, the distinction here has been based on whether they influence the\nflow of control or syntax. See `sh-feature'." (repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v")))) sh-other-keywords #[0 "\300\207" [((bash sh-append bourne "bye" "logout" "select") (bourne sh-append sh "function") (csh sh-append shell "breaksw" "default" "end" "endif" "endsw" "foreach" "goto" "if" "logout" "onintr" "repeat" "switch" "then" "while") (es "break" "catch" "exec" "exit" "fn" "for" "forever" "fork" "if" "return" "throw" "while") (ksh88 sh-append bourne "select") (rc "break" "case" "exec" "exit" "fn" "for" "if" "in" "return" "switch" "while") (sh sh-append shell "done" "esac" "fi" "for" "in" "return") (shell "break" "case" "continue" "exec" "exit") (zsh sh-append bash "select" "foreach"))] 1] "List of keywords not in `sh-leading-keywords'.\nSee `sh-feature'." (repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v"))))] 10)
#@78 List of all shell variables available for completing read.
See `sh-feature'.
(defvar sh-variables '((bash sh-append sh "allow_null_glob_expansion" "auto_resume" "BASH" "BASH_ENV" "BASH_VERSINFO" "BASH_VERSION" "cdable_vars" "COMP_CWORD" "COMP_LINE" "COMP_POINT" "COMP_WORDS" "COMPREPLY" "DIRSTACK" "ENV" "EUID" "FCEDIT" "FIGNORE" "FUNCNAME" "glob_dot_filenames" "GLOBIGNORE" "GROUPS" "histchars" "HISTCMD" "HISTCONTROL" "HISTFILE" "HISTFILESIZE" "HISTIGNORE" "history_control" "HISTSIZE" "hostname_completion_file" "HOSTFILE" "HOSTTYPE" "IGNOREEOF" "ignoreeof" "INPUTRC" "LINENO" "MACHTYPE" "MAIL_WARNING" "noclobber" "nolinks" "notify" "no_exit_on_failed_exec" "NO_PROMPT_VARS" "OLDPWD" "OPTERR" "OSTYPE" "PIPESTATUS" "PPID" "POSIXLY_CORRECT" "PROMPT_COMMAND" "PS3" "PS4" "pushd_silent" "PWD" "RANDOM" "REPLY" "SECONDS" "SHELLOPTS" "SHLVL" "TIMEFORMAT" "TMOUT" "UID") (csh sh-append shell "argv" "cdpath" "child" "echo" "histchars" "history" "home" "ignoreeof" "mail" "noclobber" "noglob" "nonomatch" "path" "prompt" "shell" "status" "time" "verbose") (es sh-append shell "apid" "cdpath" "CDPATH" "history" "home" "ifs" "noexport" "path" "pid" "prompt" "signals") (jcsh sh-append csh "notify") (ksh88 sh-append sh "ENV" "ERRNO" "FCEDIT" "FPATH" "HISTFILE" "HISTSIZE" "LINENO" "OLDPWD" "PPID" "PS3" "PS4" "PWD" "RANDOM" "REPLY" "SECONDS" "TMOUT") (oash sh-append sh "FIELD" "FIELD_MAX" "LAST_KEY" "OALIB" "PP_ITEM" "PP_NUM") (rc sh-append shell "apid" "apids" "cdpath" "CDPATH" "history" "home" "ifs" "path" "pid" "prompt" "status") (sh sh-append shell "CDPATH" "IFS" "OPTARG" "OPTIND" "PS1" "PS2") (shell "COLUMNS" "EDITOR" "HOME" "HUSHLOGIN" "LANG" "LC_COLLATE" "LC_CTYPE" "LC_MESSAGES" "LC_MONETARY" "LC_NUMERIC" "LC_TIME" "LINES" "LOGNAME" "MAIL" "MAILCHECK" "MAILPATH" "PAGER" "PATH" "SHELL" "TERM" "TERMCAP" "TERMINFO" "VISUAL") (tcsh sh-append csh "addsuffix" "ampm" "autocorrect" "autoexpand" "autolist" "autologout" "chase_symlinks" "correct" "dextract" "edit" "el" "fignore" "gid" "histlit" "HOST" "HOSTTYPE" "HPATH" "ignore_symlinks" "listjobs" "listlinks" "listmax" "matchbeep" "nobeep" "NOREBIND" "oid" "printexitvalue" "prompt2" "prompt3" "pushdsilent" "pushdtohome" "recexact" "recognize_only_executables" "rmstar" "savehist" "SHLVL" "showdots" "sl" "SYSTYPE" "tcsh" "term" "tperiod" "tty" "uid" "version" "visiblebell" "watch" "who" "wordchars") (zsh sh-append ksh88 "BAUD" "bindcmds" "cdpath" "DIRSTACKSIZE" "fignore" "FIGNORE" "fpath" "HISTCHARS" "hostcmds" "hosts" "HOSTS" "LISTMAX" "LITHISTSIZE" "LOGCHECK" "mailpath" "manpath" "NULLCMD" "optcmds" "path" "POSTEDIT" "prompt" "PROMPT" "PROMPT2" "PROMPT3" "PROMPT4" "psvar" "PSVAR" "READNULLCMD" "REPORTTIME" "RPROMPT" "RPS1" "SAVEHIST" "SPROMPT" "STTY" "TIMEFMT" "TMOUT" "TMPPREFIX" "varcmds" "watch" "WATCH" "WATCHFMT" "WORDCHARS" "ZDOTDIR")) (#$ . 17788))
(byte-code "\300\301\302\303\304\305%\210\300\306\307\310\304\305%\210\300\311\312\313\304\314\315\316&\207" [custom-declare-face sh-heredoc ((((min-colors 88) (class color) (background dark)) (:foreground "yellow1" :weight bold)) (((class color) (background dark)) (:foreground "yellow" :weight bold)) (((class color) (background light)) (:foreground "tan1")) (t (:weight bold))) "Face to show a here-document." :group sh-indentation sh-quoted-exec ((((class color) (background dark)) (:foreground "salmon")) (((class color) (background light)) (:foreground "magenta")) (t (:weight bold))) "Face to show quoted execs like \\=`blabla\\=`." sh-escaped-newline ((t :inherit font-lock-string-face)) "Face used for (non-escaped) backslash at end of a line in Shell-script mode." sh-script :version "22.1"] 8)
#@76 Default expressions to highlight in Shell Script modes. See `sh-feature'.
(defvar sh-font-lock-keywords-var '((csh sh-append shell ("\\${?[#?]?\\([[:alpha:]_][[:alnum:]_]*\\|0\\)" 1 font-lock-variable-name-face)) (es sh-append executable-font-lock-keywords ("\\$#?\\([[:alpha:]_][[:alnum:]_]*\\|[0-9]+\\)" 1 font-lock-variable-name-face)) (rc sh-append es) (bash sh-append sh ("\\$(\\(\\sw+\\)" (1 'sh-quoted-exec t))) (sh sh-append shell ("\\$\\({#?\\)?\\([[:alpha:]_][[:alnum:]_]*\\|[-#?@!]\\)" 2 font-lock-variable-name-face) ("^\\(\\sw+\\)[ ]*(" 1 font-lock-function-name-face) ("\\<\\(function\\)\\>[ ]*\\(\\sw+\\)?" (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t)) ("\\(?:^\\s *\\|[[();&|]\\s *\\|\\(?:\\s +-[ao]\\|if\\|else\\|then\\|while\\|do\\)\\s +\\)\\(!\\)" 1 font-lock-negation-char-face)) (shell ("\\(^\\|[^\\]\\)\\(\\\\\\\\\\)*\\(\\\\\\)$" 3 'sh-escaped-newline) ("\\\\[^[:alnum:]]" 0 font-lock-string-face) ("\\${?\\([[:alpha:]_][[:alnum:]_]*\\|[0-9]+\\|[$*_]\\)" 1 font-lock-variable-name-face)) (rpm sh-append rpm2 ("%{?\\(\\sw+\\)" 1 font-lock-keyword-face)) (rpm2 sh-append shell ("^Summary:\\(.*\\)$" (1 font-lock-doc-face t)) ("^\\(\\sw+\\):" 1 font-lock-variable-name-face))) (#$ . 21427))
#@52 Subdued level highlighting for Shell Script modes.
(defvar sh-font-lock-keywords-var-1 '((sh "[ ]in\\>")) (#$ . 22667))
#@50 Gaudy level highlighting for Shell Script modes.
(defvar sh-font-lock-keywords-var-2 nil (#$ . 22794))
(defconst sh-st-punc '(1))
(defconst sh-here-doc-syntax '(15))
(defconst sh-escaped-line-re "\\(?:\\(?:.*[^\\\n]\\)?\\(?:\\\\\\\\\\)*\\\\\n\\)*.*")
(defconst sh-here-doc-open-re (concat "[^<]<<-?\\s-*\\\\?\\(\\(?:['\"][^'\"]+['\"]\\|\\sw\\|[-/~._]\\)+\\)" sh-escaped-line-re "\\(\n\\)"))
#@12
(fn POS)
(defalias 'sh--inside-noncommand-expression #[257 "\212\300!\211A@\2051 \211A@b\210\301f\211\302\267\202' `Sf\303=\202( `Sf\304=\202( \301\262\2061 \305`S!\262)\207" [syntax-ppss nil #s(hash-table size 3 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (40 23 91 31 123 31)) 40 36 sh--inside-noncommand-expression] 5 (#$ . 23191)])
#@330 Determine the syntax of the \n after a <<EOF.
START is the position of <<.
STRING is the actual word used as delimiter (e.g. "EOF").
INDENTED is non-nil if the here document's content (and the EOF mark) can
be indented (i.e. a <<- was used rather than just <<).
Point is at the beginning of the next line.
(fn START STRING EOL)
(defalias 'sh-font-lock-open-heredoc #[771 "\206 `Sf\301>\206 \302!\206 \303!?\205Y \304\305\306#\212\307!)\3108\2031 \311S\312\313$\210\3148\204@ \315\"\316V\203H \311T\317\320$\210\311\211T\321$\210\322\\b\210\266\202\207" [sh-here-doc-syntax (60 62) sh-in-comment-or-string sh--inside-noncommand-expression replace-regexp-in-string "['\"]" "" syntax-ppss 4 put-text-property syntax-table (12) 5 count-lines 1 syntax-multiline t sh-here-doc-marker 2] 10 (#$ . 23560)])
#@12
(fn END)
(defalias 'sh-syntax-propertize-here-doc #[257 "\302 \3038\304=\205- \305\3068\307\"\310\311\312\313!\314Q\315#\205* \316\224\317\211T\320 $\262)\262\207" [case-fold-search sh-here-doc-syntax syntax-ppss 3 t get-text-property 8 sh-here-doc-marker nil re-search-forward "^\\([ ]*\\)" regexp-quote "\\(\n\\)" move 2 put-text-property syntax-table] 9 (#$ . 24387)])
#@152 Search for a subshell embedded in a string.
Find all the unescaped " characters within said subshell, remembering that
subshells can nest.
(fn LIMIT)
(defalias 'sh-font-lock-quoted-subshell #[257 "\300\301 8\302=\205\376 `Sf\303=\203 \304\202 \305`\306\203\350 \307w\210`W\203\350 \310f\211\311\267\202\335 \312=\204\341 \313u\210`\314w\210\212`b\210\315\316\317#\203U \320``S\321\322$\210\202B \210)\210\202\341 \313u\210\202\341 \312=\203r \211A\262\242\262\202z B\262\312\262\203\341 \320``T\321\323$\210\202\341 \304=\203\232 \211A\262\242\262\202\341 B\262\304\262\202\341 `Tf\324=\203\341 \313u\210B\262\305\262\202\341 \312=\204\341 B\262\305\262\202\341 \312=\204\341 \211A\262\242\262\202\341 \325\326!\210\210\313u\210\202 \327 W\205\374 \320`\330\317$\210\331\332\333\310\317$\266\203\207" [3 syntax-ppss 34 96 backquote code (double-quote) "^'\\\\\"`$()" nil #s(hash-table size 7 test eql rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (39 46 92 91 34 97 96 137 36 165 40 187 41 204)) double-quote 1 "^'" search-forward "\"" t put-text-property syntax-table (1) (1) 40 error "Internal error in sh-font-lock-quoted-subshell" line-beginning-position syntax-multiline add-hook syntax-propertize-extend-region-functions syntax-propertize-multiline] 12 (#$ . 24777)])
#@12
(fn POS)
(defalias 'sh-is-quoted-p #[257 "\211\206 `Sf\300=\205 \301S!?\207" [92 sh-is-quoted-p] 3 (#$ . 26111)])
#@14
(fn START)
(defalias 'sh-font-lock-paren #[257 "\301\302 8?\205\301 \212\303b\210\304d[!\210l\203\" \305`!\203\" \306u\210\202
\307\310!\311U\203\" \312\303x\311U\203\" \305`S!\203@ `\313Zb\204\" `Sf\314>\203Z \3151U \316\317!\210\3200\202W \210\303\204\" `\206_ `Sf\321=\203l \306u\210`\262\304d[!\210\305`!\203} \306u\210\202l `Sf\322=\203\213 \306u\210\202
`eTV\205\276 \323u\210\324 V\203\244 \325`T\326\320$\210\327\330!\205\276 \327\331!?\205\276 \211\203\275 \325\211T\332$\210\262)\207" [sh-st-punc 8 syntax-ppss nil forward-comment sh-is-quoted-p -1 skip-syntax-backward "w_" 0 "-$=?[]*@/\\\\" 2 (34 39 125) (error) backward-sexp 1 t 40 124 -2 line-end-position put-text-property syntax-multiline looking-at ";[;&]\\|\\_<in" "..[ \n]+esac[^[:word:]_]" syntax-table] 7 (#$ . 26236)])
(defalias 'sh-font-lock-backslash-quote #[0 "\212\301\302\303\224!8)\304=\205 \207" [sh-st-punc 3 syntax-ppss 0 39] 3])
#@18
(fn START END)
(defalias 'sh-syntax-propertize-function #[514 "b\210\300!\210`b\210`W\2053\301\302\303#\2053\304\224\203= \304\224\304\225\305\306\224T\307\310!\304\224#\211\2038 \311\312$\210\266\202\f \313\224\203i \314\315!\211A\316\233\241\210\317!\266\306\224\306\225\320\211\203a \311\312$\210\300!\266\202\f \321\224\203z \311\321\224\321\225\312\322$\210\202\f \323\224\203\213 \311\323\224\323\225\312\322$\210\202\f \324\224\203\234 \311\324\224\324\225\312\322$\210\202\f \325\224\203\306 \314\315!\211A\326\233\241\210\317!\266\310\224\310\225\327 \211\203\301 \311\312$\210\266\202\f \316\224\203\327 \311\316\224\316\225\312\322$\210\202\f \330\224\203\314\315!\211A\331\233\241\210\317!\266\306\224\306\225\332\306\224!\211\203\376 \311\312$\210\266\202\f \333\224\203\f \314\315!\211A\331\233\241\210\317!\266\316\212\334\306\224!)8\203*\306\224Tb\210\202\f \212\335!\210)\202\f \207" [sh-syntax-propertize-here-doc re-search-forward "[^<]<<-?\\s-*\\\\?\\(\\(?:['\"][^'\"]+['\"]\\|\\sw\\|[-/~._]\\)+\\)\\(?:\\(?:.*[^\\\n]\\)?\\(?:\\\\\\\\\\)*\\\\\n\\)*.*\\(\n\\)\\|\\(\\s|\\)\\|\\(?:[^|&;<>(`\\\"' \n]\\|\\${\\|\\(?:[^\\]\\|^\\)\\\\\\(?:\\\\\\\\\\)*.\\)\\(#+\\)\\|[^|&;<>(`\\\"' \n](\\(#+\\)\\|(\\(#\\)[^)]+?)[^|&;<>)`\\\"' \n]\\|\\(\\\\\\)'\\|\\$\\([?@]\\)\\|\\()\\)\\|\"\\(?:\\(?:[^\\\"]\\|\\\\.\\)*?\\)??\\(\\$(\\|`\\)" t 2 sh-font-lock-open-heredoc 0 match-string 1 put-text-property syntax-table 3 match-data ints 8 set-match-data nil 4 (3) 5 6 7 14 sh-font-lock-backslash-quote 9 20 sh-font-lock-paren 10 syntax-ppss sh-font-lock-quoted-subshell] 12 (#$ . 27169)])
#@14
(fn STATE)
(defalias 'sh-font-lock-syntactic-face-function #[257 "\3028\211\203 \303!\203 \211\304=\203 \305\202 \202 \306\202 \207" [font-lock-string-face font-lock-comment-face 3 characterp 96 sh-quoted-exec sh-heredoc] 4 (#$ . 28808)])
(byte-code "\300\301\302\303\304\305%\210\306\307\310\311\312DD\313\314\315\304\305&\210\306\316\310\311\317DD\320\314\315\321\322\304\305& \210\306\323\310\311\324DD\325\314\326\304\301&\210\306\327\310\311\330DD\331\314\332\304\301&\210\306\333\310\311\334DD\335\314\336\304\301&\210\306\337\310\311\340DD\341\314\342\304\301&\210\306\343\310\311\344DD\345\314\346\304\301&\210\347\343\350\351#\210\306\352\310\311\353DD\354\314\355\356\357\304\301& \207" [custom-declare-group sh-indentation nil "Variables controlling indentation in shell scripts.\n\nNote: customizing these variables will not affect existing buffers if\n`sh-make-vars-local' is non-nil. See the documentation for\nvariable `sh-make-vars-local', command `sh-make-vars-local'\nand command `sh-reset-indent-vars-to-global-values'." :group sh-script custom-declare-variable sh-set-shell-hook funcall function #[0 "\300\207" [nil] 1] "Hook run by `sh-set-shell'." :type hook sh-mode-hook #[0 "\300\207" [(sh-electric-here-document-mode)] 1] "Hook run by `sh-mode'." :options (sh-electric-here-document-mode) sh-learn-basic-offset #[0 "\300\207" [nil] 1] "When `sh-guess-basic-offset' should learn `sh-basic-offset'.\n\nnil mean: never.\nt means: only if there seems to be an obvious value.\nAnything else means: whenever we have a \"good guess\" as to the value." (choice (const :tag "Never" nil) (const :tag "Only if sure" t) (const :tag "If have a good guess" usually)) sh-popup-occur-buffer #[0 "\300\207" [nil] 1] "Controls when `sh-learn-buffer-indent' pops the `*indent*' buffer.\nIf t it is always shown. If nil, it is shown only when there\nare conflicts." (choice (const :tag "Only when there are conflicts." nil) (const :tag "Always" t)) sh-blink #[0 "\300\207" [t] 1] "If non-nil, `sh-show-indent' shows the line indentation is relative to.\nThe position on the line is not necessarily meaningful.\nIn some cases the line will be the matching keyword, but this is not\nalways the case." boolean sh-first-lines-indent #[0 "\300\207" [0] 1] "The indentation of the first non-blank non-comment line.\nUsually 0 meaning first column.\nCan be set to a number, or to nil which means leave it as is." (choice (const :tag "Leave as is" nil) (integer :tag "Column number" :menu-tag "Indent to this col (0 means first col)")) sh-basic-offset #[0 "\300\207" [4] 1] "The default indentation increment.\nThis value is used for the `+' and `-' symbols in an indentation variable." integer put safe-local-variable integerp sh-indent-comment #[0 "\300\207" [t] 1] "How a comment line is to be indented.\nnil means leave it as it is;\nt means indent it as a normal line, aligning it to previous non-blank\n non-comment line;\na number means align to that column, e.g. 0 means first column." (choice (const :tag "Leave as is." nil) (const :tag "Indent as a normal line." t) (integer :menu-tag "Indent to this col (0 means first col)." :tag "Indent to column number.")) :version "24.3"] 10)
#@68 Enable lots of debug messages - if function `sh-debug' is enabled.
(defvar sh-debug nil (#$ . 32056))
#@19
(fn &rest ARGS)
(defalias 'sh-debug '(macro . #[128 "\300\207" [nil] 2 (#$ . 32164)]))
(defconst sh-symbol-list '((const :tag "+ " :value + :menu-tag "+ Indent right by sh-basic-offset") (const :tag "- " :value - :menu-tag "- Indent left by sh-basic-offset") (const :tag "++" :value ++ :menu-tag "++ Indent right twice sh-basic-offset") (const :tag "--" :value -- :menu-tag "-- Indent left twice sh-basic-offset") (const :tag "* " :value * :menu-tag "* Indent right half sh-basic-offset") (const :tag "/ " :value / :menu-tag "/ Indent left half sh-basic-offset")))
(byte-code "\301\302\303\304\305DD\306\307\310\311\312BBB\313\314&\207" [sh-symbol-list custom-declare-variable sh-indent-for-else funcall function #[0 "\300\207" [0] 1] "How much to indent an `else' relative to its `if'. Usually 0." :type choice (integer :menu-tag "A number (positive=>indent right)" :tag "A number") (const :tag "--") :group sh-indentation] 9)
(defconst sh-number-or-symbol-list (append '((integer :menu-tag "A number (positive=>indent right)" :tag "A number") (const :tag "--")) sh-symbol-list))
(byte-code "\301\302\303\304\305DD\306\307\310B\311\312&\210\301\313\303\304\314DD\315\307\310B\311\312&\210\301\316\303\304\317DD\320\307\310B\311\312&\210\301\321\303\304\322DD\323\307\310B\311\312&\210\301\324\303\304\325DD\326\307\310B\311\312&\210\301\327\303\304\330DD\331\307\310B\311\312&\210\301\332\303\304\333DD\334\307\310B\311\312&\210\301\335\303\304\336DD\337\307\310B\311\312&\210\301\340\303\304\341DD\342\307\310B\311\312&\210\301\343\303\304\344DD\345\307\310B\311\312&\210\301\346\303\304\347DD\350\307\310B\311\312&\210\301\351\303\304\352DD\353\307\310B\311\312&\210\301\354\303\304\355DD\356\307\310B\311\312&\210\301\357\303\304\360DD\361\307\310B\311\312&\210\301\362\303\304\363DD\364\307\310B\311\312&\210\301\365\303\304\366DD\367\307\310B\311\312&\210\301\370\303\304\371DD\372\307\373\311\374&\210\301\375\303\304\376DD\377\307\201@ \311\374&\207" [sh-number-or-symbol-list custom-declare-variable sh-indent-for-fi funcall function #[0 "\300\207" [0] 1] "How much to indent a `fi' relative to its `if'. Usually 0." :type choice :group sh-indentation sh-indent-for-done #[0 "\300\207" [0] 1] "How much to indent a `done' relative to its matching stmt. Usually 0." sh-indent-after-else #[0 "\300\207" [+] 1] "How much to indent a statement after an `else' statement." sh-indent-after-if #[0 "\300\207" [+] 1] "How much to indent a statement after an `if' statement.\nThis includes lines after `else' and `elif' statements, too, but\ndoes not affect the `else', `elif' or `fi' statements themselves." sh-indent-for-then #[0 "\300\207" [0] 1] "How much to indent a `then' relative to its `if'." sh-indent-for-do #[0 "\300\207" [0] 1] "How much to indent a `do' statement.\nThis is relative to the statement before the `do', typically a\n`while', `until', `for', `repeat' or `select' statement." sh-indent-after-do #[0 "\300\207" [+] 1] "How much to indent a line after a `do' statement.\nThis is used when the `do' is the first word of the line.\nThis is relative to the statement before the `do', typically a\n`while', `until', `for', `repeat' or `select' statement." sh-indent-after-loop-construct #[0 "\300\207" [+] 1] "How much to indent a statement after a loop construct.\n\nThis variable is used when the keyword `do' is on the same line as the\nloop statement (e.g., `until', `while' or `for').\nIf the `do' is on a line by itself, then `sh-indent-after-do' is used instead." sh-indent-after-done #[0 "\300\207" [0] 1] "How much to indent a statement after a `done' keyword.\nNormally this is 0, which aligns the `done' to the matching\nlooping construct line.\nSetting it non-zero allows you to have the `do' statement on a line\nby itself and align the done under to do." sh-indent-for-case-label #[0 "\300\207" [+] 1] "How much to indent a case label statement.\nThis is relative to the line containing the `case' statement." sh-indent-for-case-alt #[0 "\300\207" [++] 1] "How much to indent statements after the case label.\nThis is relative to the line containing the `case' statement." sh-indent-for-continuation #[0 "\300\207" [+] 1] "How much to indent for a continuation statement." sh-indent-after-open #[0 "\300\207" [+] 1] "How much to indent after a line with an opening parenthesis or brace.\nFor an open paren after a function, `sh-indent-after-function' is used." sh-indent-after-function #[0 "\300\207" [+] 1] "How much to indent after a function line." sh-indent-after-switch #[0 "\300\207" [+] 1] "How much to indent a `case' statement relative to the `switch' statement.\nThis is for the rc shell." sh-indent-after-case #[0 "\300\207" [+] 1] "How much to indent a statement relative to the `case' statement.\nThis is for the rc shell." sh-backslash-column #[0 "\300\207" [48] 1] "Column in which `sh-backslash-region' inserts backslashes." integer sh sh-backslash-align #[0 "\300\207" [t] 1] "If non-nil, `sh-backslash-region' will align backslashes." boolean] 8)
#@150 Make a regexp which matches WORD as a word.
This specifically excludes an occurrence of WORD followed by
punctuation characters like `-'.
(fn WORD)
(defalias 'sh-mkword-regexpr #[257 "\211\300P\207" ["\\([^-[:alnum:]_]\\|$\\)"] 3 (#$ . 37224)])
(defconst sh-re-done (sh-mkword-regexpr "done"))
#@57 Which keywords can match the word `done' in this shell.
(defconst sh-kws-for-done '((sh "while" "until" "for") (bash "while" "until" "for" "select") (ksh88 "while" "until" "for" "select") (zsh "while" "until" "for" "repeat" "select")) (#$ . 37525))
#@50 Indentation rule set to use for each shell type.
(defconst sh-indent-supported '((sh . sh) (csh) (rc . rc)) (#$ . 37780))
#@72 Non-nil if we support indentation for the current buffer's shell type.
(defvar sh-indent-supported-here nil (#$ . 37908))
#@198 A list of variables used by script mode to control indentation.
This list is used when switching between buffer-local and global
values of variables, and for the commands using indentation styles.
(defconst sh-var-list '(sh-basic-offset sh-first-lines-indent sh-indent-after-case sh-indent-after-do sh-indent-after-done sh-indent-after-else sh-indent-after-if sh-indent-after-loop-construct sh-indent-after-open sh-indent-comment sh-indent-for-case-alt sh-indent-for-case-label sh-indent-for-continuation sh-indent-for-do sh-indent-for-done sh-indent-for-else sh-indent-for-fi sh-indent-for-then) (#$ . 38037))
#@340 Controls whether indentation variables are local to the buffer.
If non-nil, indentation variables are made local initially.
If nil, you can later make the variables local by invoking
command `sh-make-vars-local'.
The default is t because I assume that in one Emacs session one is
frequently editing existing scripts with different styles.
(defvar sh-make-vars-local t (#$ . 38655))
#@45 The inferior shell process for interaction.
(defvar sh-shell-process nil (#$ . 39043))
(make-variable-buffer-local 'sh-shell-process)
#@104 Get a shell process for interaction.
If FORCE is non-nil and no process found, create one.
(fn FORCE)
(defalias 'sh-shell-process #[257 "\304!\203 \207\305\211\306 \2049 \211\2039 \304\211A\262\242\211\262!\2039 \307!\2039 \310\307!@!\230\203\f \262\202\f \206H \205H \311\n\312 )!\266\203\211\207" [sh-shell-process sh-shell sh-shell-file explicit-shell-file-name process-live-p nil process-list process-command file-name-nondirectory get-buffer-process shell] 8 (#$ . 39184)])
#@35 Pop the shell interaction buffer.
(defalias 'sh-show-shell #[0 "\300\301\302\303!!!\207" [pop-to-buffer process-buffer sh-shell-process t] 4 (#$ . 39686) nil])
#@53 Send the text to the `sh-shell-process'.
(fn TEXT)
(defalias 'sh-send-text #[257 "\300\301\302!\303P\"\207" [comint-send-string sh-shell-process t "\n"] 5 (#$ . 39852)])
#@71 Change directory in the current interaction shell to the current one.
(defalias 'sh-cd-here #[0 "\301\302P!\207" [default-directory sh-send-text "cd "] 3 (#$ . 40030) nil])
#@124 Send the current line to the inferior shell and step to the next line.
When the region is active, send the region instead.
(defalias 'sh-send-line-or-region-and-step #[0 "\300\211\211\301 \203 \302 \262\303 \262\262\202\" \304 \262\305 \262T\262\306\307\"!\210\211b\207" [nil use-region-p region-beginning region-end line-beginning-position line-end-position sh-send-text buffer-substring-no-properties] 7 (#$ . 40211) nil])
(defalias 'sh-after-hack-local-variables #[0 "\301\236\205 \302 9\203 \303 !\202 !\207" [file-local-variables-alist sh-shell sh-set-shell symbol-name] 3])
(defvar sh-mode-hook nil)
(byte-code "\300\301N\204\f \302\300\301\303#\210\304\305!\204 \302\305\306\307#\210\300\207" [sh-mode-hook variable-documentation put "Hook run after entering Shell-script mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp sh-mode-map definition-name sh-mode] 4)
(defvar sh-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204 \303\301\302\304\305!#\210\306\307!\204 \303\307\310\311#\210\312\313 !\210\307\302N\204- \303\307\302\304\314!#\210\306\300!\204B \303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P \303\300\302\304\320!#\210\303\311\321\322#\207" [sh-mode-abbrev-table sh-mode-map variable-documentation put purecopy "Keymap for `sh-mode'." boundp sh-mode-syntax-table definition-name sh-mode (lambda (#1=#:def-tmp-var) (defvar sh-mode-syntax-table #1#)) make-syntax-table "Syntax table for `sh-mode'." (lambda (#1#) (defvar sh-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `sh-mode'." derived-mode-parent prog-mode] 5)
#@2512 Major mode for editing shell scripts.
This mode works for many shells, since they all have roughly the same syntax,
as far as commands, arguments, variables, pipes, comments etc. are concerned.
Unless the file's magic number indicates the shell, your usual shell is
assumed. Since filenames rarely give a clue, they are not further analyzed.
This mode adapts to the variations between shells (see `sh-set-shell') by
means of an inheritance based feature lookup (see `sh-feature'). This
mechanism applies to all variables (including skeletons) that pertain to
shell-specific features. Shell script files can use the `sh-shell' local
variable to indicate the shell variant to be used for the file.
The default style of this mode is that of Rosenblatt's Korn shell book.
The syntax of the statements varies with the shell being used. The
following commands are available, based on the current shell's syntax:
\<sh-mode-map>
\[sh-case] case statement
\[sh-for] for loop
\[sh-function] function definition
\[sh-if] if statement
\[sh-indexed-loop] indexed loop from 1 to n
\[sh-while-getopts] while getopts loop
\[sh-repeat] repeat loop
\[sh-select] select loop
\[sh-until] until loop
\[sh-while] while loop
For sh and rc shells indentation commands are:
\[sh-show-indent] Show the variable controlling this line's indentation.
\[sh-set-indent] Set then variable controlling this line's indentation.
\[sh-learn-line-indent] Change the indentation variable so this line
would indent to the way it currently is.
\[sh-learn-buffer-indent] Set the indentation variables so the
buffer indents as it currently is indented.
\[backward-delete-char-untabify] Delete backward one position, even if it was a tab.
\[sh-end-of-command] Go to end of successive commands.
\[sh-beginning-of-command] Go to beginning of successive commands.
\[sh-set-shell] Set this buffer's shell, and maybe its magic number.
\[sh-execute-region] Have optional header and region be executed in a subshell.
`sh-electric-here-document-mode' controls whether insertion of two
unquoted < insert a here document. You can control this behavior by
modifying `sh-mode-hook'.
If you generally program a shell different from your login shell you can
set `sh-shell-file' accordingly. If your shell's file name doesn't correctly
indicate what shell it is use `sh-alias-alist' to translate.
If your shell gives error messages with line numbers, you can use \[executable-interpret]
with your script for an edit-interpret-debug cycle.
(defalias 'sh-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203 \314\311\313\310\313N#\210\315 !\204' \316 \317 \"\210\320\f!\211\2035 \211\321 =\203; \322\f\323 \"\210\210\324
\325\"\204R
$=\204R \326
\325$C#\210\327 !\210\330\f!\210
$\306\331!\210\306\332!\210\306\333!\210@\306\334!\210A\335P \306\336!\210 \337P \306\340!\210\341 \306\342!\210\343\"\306\344!\210
$\306\345!\210B%\346\347\350\351\307$\210\306\352!\210\353*\306\354!\210\351,\355\351\211\356\351\357\360B\257C\306\361!\210\3621\346\363\364\365\366$\210\306\367!\210\3707\306\371!\210\3729\306\373!\210\374;\306\375!\210\376=\306\377!\210\307?\306\201D !\210\201G D\306\201E !\210\201H E\346\347\201I \351\307$\210\201J \212eb\210\201K \201L !)\203+\201M \201N !\202\310F\2045\202\310\201O \201P F\"\203G\201Q \202\310\201O \201R F\"\203Y\201S \202\310\201O \201T F\"\203k\201U \202\310\201O \201V F\"\203}\201W \202\310\201O \201X F\"\203\217\201Y \202\310\201O \201Z F\"\203\241\201[ \202\310\201O \201\\ F\"\203\263\201] \202\310\201^ F!\201_ \232\203\306\201S \202\310\351\211#\210\346\201` \201a \351\307$\210)\201b \201c !\207" [delay-mode-hooks major-mode mode-name sh-mode-map sh-mode-syntax-table sh-mode-abbrev-table make-local-variable t prog-mode sh-mode "Shell-script" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table sh-shell-file sh-shell skeleton-pair-default-alist paragraph-start "\\|$" paragraph-separate "\\|#!/" comment-start "# " comment-start-skip "#+[ ]*" local-abbrev-table comint-dynamic-complete-functions add-hook completion-at-point-functions comint-completion-at-point nil comint-prompt-regexp "^[ ]*" imenu-case-fold-search (sh-font-lock-keywords sh-font-lock-keywords-1 sh-font-lock-keywords-2) ((47 . "w") (126 . "w") (46 . "w") (45 . "w") (95 . "w")) font-lock-syntactic-face-function sh-font-lock-syntactic-face-function syntax-propertize-function sh-syntax-propertize-function syntax-propertize-extend-region-functions syntax-propertize-multiline append local skeleton-pair-alist ((96 _ 96)) skeleton-pair-filter-function sh-quoted-p skeleton-further-elements ((< '(- (min sh-basic-offset (current-column))))) skeleton-filter-function sh-feature skeleton-newline-indent-rigidly sh-skeleton-pair-default-alist page-delimiter sh-dynamic-complete-functions font-lock-defaults defun-prompt-regexp add-log-current-defun-function buffer-file-name "^\\(\\(function[ ]\\)?[ ]*[[:alnum:]_]+[ ]*([ ]*)\\|function[ ]+[[:alnum:]_]+[ ]*\\(([ ]*)\\)?\\)[ ]*" sh-current-defun-name sh-completion-at-point-function sh-set-shell looking-at "#![ ]?\\([^ \n]*/bin/env[ ]\\)?\\([^ \n]+\\)" match-string 2 string-match "\\.m?spec\\'" "rpm" "[.]sh\\>" "sh" "[.]bash\\>" "bash" "[.]ksh\\>" "ksh" "[.]mkshrc\\>" "mksh" "[.]t?csh\\(rc\\)?\\>" "csh" "[.]zsh\\(rc\\|env\\)?\\>" "zsh" file-name-nondirectory ".profile" hack-local-variables-hook sh-after-hack-local-variables run-mode-hooks sh-mode-hook] 7 (#$ . 41903) nil])
(defalias 'shell-script-mode 'sh-mode)
#@143 Function to get simple fontification based on `sh-font-lock-keywords'.
This adds rules for comments and assignments.
(fn &optional KEYWORDS)
(defalias 'sh-font-lock-keywords #[256 "\302\302 !;\205 \303\304\305\306\307!\310\"\311\312%\"\207" [sh-font-lock-keywords-var sh-assignment-regexp sh-feature make-byte-code 257 "\303 !\304B\305\300\n#B\207" vconcat vector [sh-assignment-regexp executable-font-lock-keywords sh-feature (1 font-lock-variable-name-face) append] 6 "\n\n(fn LIST)"] 9 (#$ . 47613)])
#@83 Function to get better fontification including keywords.
(fn &optional BUILTINS)
(defalias 'sh-font-lock-keywords-1 #[256 "\305\306\307!\310\"\311\306\312\307!\307 !\"\310\"R\313\312\205* \311\306\307\n!\310\"\314R\315B\307 !B\316P\317BC\307\f!#!\207" [sh-leading-keywords sh-other-keywords sh-builtins sh-font-lock-keywords-var-2 sh-font-lock-keywords-var-1 "\\([;(){}`|&]\\|^\\)[ ]*\\(\\(" regexp-opt sh-feature t "[ ]+\\)?" append sh-font-lock-keywords "\\>" ((2 font-lock-keyword-face nil t) (6 font-lock-builtin-face)) "\\)\\>" (2 font-lock-keyword-face)] 9 (#$ . 48129)])
#@71 Function to get better fontification including keywords and builtins.
(defalias 'sh-font-lock-keywords-2 #[0 "\300\301!\207" [sh-font-lock-keywords-1 t] 2 (#$ . 48721)])
(defalias 'sh--vars-before-point #[0 "\212\300\301\302\300\303#\203 \304\305!B\262\202 \211\262)\207" [nil re-search-backward "^[ ]*\\([[:alnum:]_]+\\)=" t match-string 1] 5])
#@27
(fn STRING PRED ACTION)
(defalias 'sh--cmd-completion-table #[771 "\302\303\304!\205 \305\306\3071 \304 0\202 \210\310\"\305\311\312 \"\313 \314%\315$\316$\207" [exec-path exec-suffixes append fboundp imenu--make-index-alist mapcar car (imenu-unavailable) nil #[257 "\211\300P\207" ["="] 3 "\n\n(fn V)"] sh--vars-before-point locate-file-completion-table t ("if" "while" "until" "for") complete-with-action] 12 (#$ . 49079)])
(defalias 'sh-completion-at-point-function #[0 "\212\300\301w\210`\300\301x``Sf\302=\203 \211\303 E\202# \304 \205# \211\305E\266\203)\207" ["[:alnum:]_" nil 36 sh--vars-before-point sh-smie--keyword-p sh--cmd-completion-table] 6])
(require 'smie)
#@62 Whether to use the SMIE code for navigation and indentation.
(defvar sh-use-smie t (#$ . 49778))
#@152 Non-nil if we're at a keyword position.
A keyword position is one where if we're looking at something that looks
like a keyword, then it is a keyword.
(defalias 'sh-smie--keyword-p #[0 " \211G\302U\203 \303\304`S\"\202 \305 \"\207" [smie-backward-token-function smie-grammar 0 looking-back "\\`\\|\\s(" assoc] 4 (#$ . 49882)])
#@409 Return non-nil if a newline should be treated as a semi-colon.
Here we assume that a newline should be treated as a semi-colon unless it
comes right after a special keyword.
This function does not pay attention to line-continuations.
If TOK is nil, point should be before the newline; otherwise, TOK is the token
before the newline and in that case point should be just before the token.
(fn &optional TOK)
(defalias 'sh-smie--newline-semi-p #[256 "\212\211\204 \262\211G\302U\205 \303\304`S\"?\205! \305\306 \"8\247?)\207" [smie-backward-token-function smie-grammar 0 looking-back "\\s(" 2 assoc] 5 (#$ . 50220)])
(defconst sh-smie-sh-grammar '((:smie-closer-alist (#1="case" . #13="esac") (#1# . #14="in") (#2="if" . "fi") (#2# . #11="then") ("if" . #10="else") ("if" . #9="elif") (#3="while" . "done") (#3# . #8="do") (#4="until" . "done") (#4# . "do") (#5="for" . "done") (#5# . "do") (#5# . "in") (#6="select" . "done") (#6# . "do") (#6# . "in") (#7="repeat" . #12="done") (#7# . "do")) (#8# 0 1) (#9# 3 2) (#10# 3 3) (#11# 2 3) (#3# (71) 0) (#4# (72) 0) ("for" (73) 0) (#6# (74) 0) (#7# (75) 0) (#2# (76) 2) ("&" 38 38) (";" 38 38) ("||" 49 49) ("&&" 49 49) ("|&" 60 60) ("always" 77 78) (#12# 1 (79)) ("fi" 3 (80)) (#13# 0 (81)) (";;" 14 14) (";&" 14 14) (";;&" 14 14) ("case-)" 26 25) ("case-(" (82) 37) ("|" 60 60) (#14# 0 0) (#1# (83) 0)))
(defconst sh-smie--sh-operators (byte-code "\301\302\303\304\"\"\207" [sh-smie-sh-grammar delq nil mapcar #[257 "\211@\262\211;\205 \300\301\"?\205 \211\207" [string-match "\\`[a-z]"] 4 "\n\n(fn X)"]] 5))
(defconst sh-smie--sh-operators-re (regexp-opt sh-smie--sh-operators))
(defconst sh-smie--sh-operators-back-re (concat "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(" sh-smie--sh-operators-re "\\)"))
#@92 Assuming we're looking at "in", return non-nil if it's a keyword.
Does not preserve point.
(defalias 'sh-smie--sh-keyword-in-p #[0 "\303\211\211\211\211\204\212 \262\211G\304U\203I \203( \204\" \305\306!\210\307\262\202 o\2032 \307\262\202 \310\262\3111@ \312\313!0\202E \210\314\211\262\210\202 \211\315\267\202e \203Y \310\262\202 \316\262\202 \316\262\202 \317\n\"\203r \307\262\202 \203\204 \204~ \305\306!\210\307\262\202 \310\262\202 )\316=\207" [forward-sexp-function smie-backward-token-function smie-grammar nil 0 cl--assertion-failed words word t (scan-error) forward-sexp -1 unknown #s(hash-table size 4 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (";" 79 "case" 95 "for" 95 "select" 95)) keyword assoc] 8 (#$ . 51985)])
#@72 Non-nil if TOK (at which we're looking) really is a keyword.
(fn TOK)
(defalias 'sh-smie--sh-keyword-p #[257 "\300\301!\203 \302\207\211\303\232\203 \304 \207\305 \207" [looking-at "[[:alnum:]_]+=" nil "in" sh-smie--sh-keyword-in-p sh-smie--keyword-p] 3 (#$ . 52778)])
(defalias 'sh-smie--default-forward-token #[0 "\300d!\210\301`\302\303!\304U\203 \302\305!\210\306\307!\203 \310u\210\202 `\"\207" [forward-comment buffer-substring-no-properties skip-syntax-forward "." 0 "w_'" looking-at "\\\\" 2] 4])
(defalias 'sh-smie--default-backward-token #[0 "\300`[!\210`\301\302!\211\303U\204- \211\304=\203d `\301\305!\306\246\304=\203$ \307\202( \211b\210\310\262\203d \301\311!\210\301\305!\303U\203- `S\206? `Sf\312=\203m `\304u\210\301\305!\306\246\304=\203X \307\202\\ \211b\210\310\262\203m \202- `\301\305!\306\246Zb\210\313`\"\207" [forward-comment skip-syntax-backward "." 0 -1 "\\" 2 t nil "w_'" 92 buffer-substring-no-properties] 5])
(defalias 'sh-smie-sh-forward-token #[0 "\303\304!\203@ \212\305\306x\210n)\204@ \307\225\203% \310\311 8\204% \306\312\307!\210)\313\207m?\205? \314 \307y\210\211\2047 m\203; \313\202= \315 \262\207\316d!\210\303\317!\203P \307y\210\315 \207\303 !\203r \320\225b\210\321\320!\211GSH\322>\203p \303\323!\203p \307y\210\211\207`\324 \211\325\267\202\203 \326\202\245 \327\202\245 \211\203\244 \330\331\"\203\244 \332\n\"\203\244 \212b\210\333!)\204\244 \334\202\245 \211\207" [forward-sexp-function sh-smie--sh-operators-re smie-grammar looking-at "[ ]*\\(?:#\\|\\(\\s|\\)\\|$\\)" " " nil 1 3 syntax-ppss forward-sexp ";" sh-smie--newline-semi-p sh-smie-sh-forward-token forward-comment "\\\\\n" 0 match-string-no-properties (59 38 124) "[ ]*\\(?:#\\|$\\)" sh-smie--default-forward-token #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (")" 123 "(" 127)) "case-)" "case-(" string-match "\\`[a-z]" assoc sh-smie--sh-keyword-p " word "] 5])
(defalias 'sh-smie--looking-back-at-continuation-p #[0 "\212`Sf\300=\203 \301u\210\202 l\205 \302\303\304 \")\207" [10 -1 looking-back "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\\\" line-beginning-position] 3])
(defalias 'sh-smie-sh-backward-token #[0 "\304 \305`[!\210n\203* o\204* \306`S!\307\232\203* \310\311 8\204* \312\313\314!\210)\315\202\217 `W\203K \316 \203= \314u\210 \202\217 \317 \203F \315\202\217 \202\217 \320\n\304 \321#\203^ \322\224b\210\323\322!\202\217 \324 \211\325\267\202n \326\202\215 \327\202\215 \211\203\214 \330\331\"\203\214 \332 \"\203\214 \212\333!)\204\214 \334\202\215 \211\262\207" [forward-sexp-function smie-backward-token-function sh-smie--sh-operators-back-re smie-grammar line-beginning-position forward-comment syntax-after (15) 3 syntax-ppss nil forward-sexp -1 ";" sh-smie--looking-back-at-continuation-p sh-smie--newline-semi-p looking-back greedy 1 match-string-no-properties sh-smie--default-backward-token #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (")" 102 "(" 106)) "case-)" "case-(" string-match "\\`[a-z]" assoc sh-smie--sh-keyword-p " word "] 5])
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313& \207" [custom-declare-variable sh-indent-after-continuation funcall function #[0 "\300\207" [t] 1] "If non-nil, indent relative to the continued line's beginning.\nContinued lines can either be indented as \"one long wrapped line\" without\npaying attention to the actual syntactic structure, as in:\n\n for f \\\n in a; do \\\n toto; \\\n done\n\nor as lines that just don't have implicit semi-colons between them, as in:\n\n for f \\\n in a; do \\\n toto; \\\n done\n\nWith `always' you get the former behavior whereas with nil you get the latter.\nWith t, you get the latter as long as that would indent the continuation line\ndeeper than the initial line." :version "25.1" :type (choice (const nil :tag "Never") (const t :tag "Only if needed to make it deeper") (const always :tag "Always")) :group sh-indentation] 10)
#@116 Return the initial indentation of a continued line.
May return nil if the line should not be treated as continued.
(defalias 'sh-smie--continuation-start-indent #[0 "\212\300y\210\301 ?\205\f \302 )\207" [-1 sh-smie--looking-back-at-continuation-p current-indentation] 1 (#$ . 56793)])
(defalias 'sh-smie--indent-continuation #[0 "\203 \212\3031 \304\305x\210\306 0\202 \210\305)\204 \305\207\307=\2035 \212\310y\210\306 \203/ \311 \2023 \311 \\)\207\212\305\312 )\n\247\204E \202r \310y\210\311 \211W\203T \305\202l \306 \203d ^\262\211V\202l \211 \\^\262\305\262\204E \266\202)\207" [sh-indent-after-continuation sh-basic-offset most-positive-fixnum (error) " " nil sh-smie--looking-back-at-continuation-p always -1 current-indentation smie-indent-calculate] 5])
#@19
(fn KIND TOKEN)
(defalias 'sh-smie-sh-rules #[514 "B\303\304\305\306\307\310\311\312\313\267\202 \202\326\314\315!\314\316!Z\202\326:\203\244@\211\317\267\202l A\211\320\267\202\224 \321\322\323\324#\204J \325 \205\325 \326 \202\325 \327 ?\205\325 \330\331\332!8\324\232\204P \333\334 B\202\325 \327 \203t \335\336!\203t \333\337\340!B\202\325 \341
!\202\325 \342\f!?\205\325 \331\f!\210\333 \343\344\"\334 \\B\202\325 \n\345\267\202\324 \314\346!\202\325 \314\347!\202\325 \314\350!\202\325 \314\351!\202\325 \314\352!\202\325 \314\353!\202\325 \314\325 \203\311 \354\202\312 \355!\202\325 \314\316!\202\325 \356\262\202\237 A\211\357\235\203\3601 \331\f!\210\333\327 \204 \212\n \361\235\205\374 \327 )\203i\202\362 B0\202g\363\364\"\210\356\262\202g\n\365\267\202I \202g \202g \202g \202g \202g \202g \202g \202g\211\366\235\203f\335\367!\204[\314\370!\202g\371\225Sb\210\333iB\202g\356\262\202\237 \372\267\202\236 \202\237 \202\237 \202\237 \202\237 \202\237 \202\237 \202\237 \202\237\356\262\202\326\373\267\202\325\211 \202\326 \202\326 \202\326 \202\326 \202\326 \202\326 \202\326 \202\326\356\207" [sh-basic-offset smie-rules-function smie-backward-token-function #[0 "\300\301!\207" [sh-var-value sh-indent-for-case-label] 2] #[0 "\300\301 \203\n \302\202 \303!\207" [sh-var-value smie-rule-hanging-p sh-indent-after-loop-construct sh-indent-after-do] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-for-do] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-for-then] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-after-if] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-after-else] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-for-done] 2] #[0 "\300\301!\207" [sh-var-value sh-indent-for-fi] 2] #s(hash-table size 2 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((:elem . basic) 18 (:after . "case-)") 22)) sh-var-value sh-indent-for-case-alt sh-indent-for-case-label #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:before 47 :after 218)) #s(hash-table size 13 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ("case" 56 "for" 56 "if" 56 "while" 56 "[" 56 "{" 56 "(" 56 ";;&" 97 ";&" 97 ";;" 97 "||" 123 "&&" 123 "|" 123)) smie-rule-prev-p "&&" "||" "|" smie-rule-hanging-p smie-rule-parent smie-rule-bolp 2 smie-backward-sexp halfexp column smie-indent-virtual looking-at ";;?&?[ ]*\\(#\\|$\\)" smie-indent-keyword ";" smie-rule-separator smie-rule-parent-p :elem basic #s(hash-table size 8 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1=(:before . "fi") 155 #2=(:before . "done") 161 #3=(:after . "else") 167 #4=(:after . "if") 173 #5=(:before . "then") 179 #6=(:before . "do") 185 #7=(:after . "do") 191 #8=(:after . "in") 206)) sh-indent-for-fi sh-indent-for-done sh-indent-after-else sh-indent-after-if sh-indent-for-then sh-indent-for-do sh-indent-after-loop-construct sh-indent-after-do nil (";;&" ";&" ";;") (debug error) ("in" ";;") smie-indent-calculate message "Error: %S" #s(hash-table size 8 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 285 #2# 290 #3# 295 #4# 300 #5# 305 #6# 311 #7# 317 #8# 323)) ("[" "{" "(") ".[ ]*[^\n #]" sh-indent-after-open 0 #s(hash-table size 8 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 371 #2# 376 #3# 381 #4# 386 #5# 391 #6# 396 #7# 402 #8# 408)) #s(hash-table size 8 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (#1# 427 #2# 432 #3# 437 #4# 442 #5# 447 #6# 452 #7# 457 #8# 463))] 17 (#$ . 57584)])
(defconst sh-smie-rc-grammar '((";&" 0 0) (";;&" 0 0) ("case-)" 12 11) (";;" 0 0) ("if" (67) 68) ("switch" (69) 70) ("for" (71) 72) ("while" (73) 74) ("|" 56 56) ("|&" 56 56) ("&&" 45 45) ("||" 45 45) (";" 34 34) ("case" 23 23) ("&" 34 34)))
#@134 Check if we're after the first arg of an if/while/for/... construct.
Returns the construct's token and moves point before it, if so.
(defalias 'sh-smie--rc-after-special-arg-p #[0 "\302`[!\210\303\304`\305Z\"\205\" \3061 \307\310\311!\210 \312\235@)0\207\210\307\207" [forward-sexp-function smie-backward-token-function forward-comment looking-back ")\\|\\_<not" 3 (error) nil forward-sexp -1 ("if" "for" "switch" "while")] 4 (#$ . 61478)])
#@100 Return non-nil if a newline should be treated as a semi-colon.
Point should be before the newline.
(defalias 'sh-smie--rc-newline-semi-p #[0 "\212 \211\301\232\203 \302\303!\210\202 \211G\304U\203% `Sf\305=\203% \306 ?\202( \307!\262)\207" [smie-backward-token-function "not" forward-word-strictly 1 0 41 sh-smie--rc-after-special-arg-p sh-smie--newline-semi-p] 3 (#$ . 61929)])
(defalias 'sh-smie-rc-forward-token #[0 "\302\303!\2039 \212\304\305x\210n)\2049 \306\225\203% \307\310 8\204% \305\311\306!\210)\312\207\313 \306y\210\211\2042 m\2036 \312\2028 \314 \207\315d!\210\302\316!\203I \306y\210\314 \207`\317 \211\203l \320\321\"\203l \322 \"\203l \212b\210\323 )\204l \324\202m \211\207" [forward-sexp-function smie-grammar looking-at "[ ]*\\(?:#\\|\\(\\s|\\)\\|$\\)" " " nil 1 3 syntax-ppss forward-sexp ";" sh-smie--rc-newline-semi-p sh-smie-rc-forward-token forward-comment "\\\\\n" sh-smie--default-forward-token string-match "\\`[a-z]" assoc sh-smie--keyword-p " word "] 5])
(defalias 'sh-smie-rc-backward-token #[0 "\303 \304`[!\210n\203* o\204* \305`S!\306\232\203* \307\310 8\204* \311\312\313!\210)\314\202t `W\203R l\203D \315\316\303 \"\203D \313u\210 \202t \317 \203M \314\202t \202t \320 \211\203q \321\322\"\203q \323\n\"\203q \212\324 )\204q \325\202r \211\262\207" [forward-sexp-function smie-backward-token-function smie-grammar line-beginning-position forward-comment syntax-after (15) 3 syntax-ppss nil forward-sexp -1 ";" looking-back "\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\\\" sh-smie--rc-newline-semi-p sh-smie--default-backward-token string-match "\\`[a-z]" assoc sh-smie--keyword-p " word "] 5])
#@19
(fn KIND TOKEN)
(defalias 'sh-smie-rc-rules #[514 "B\211\301\267\202( \202^ \302\303!\205^ \304\305\306!!\202^ \212\307 \205$ \310iB)\202^ \211:\203] \211@\211\311\267\202W A\211\312\235\205D \313 \205D \304 \262\202X A\211\314\235\205R \315\262\202X \316\262\202^ \316\207" [sh-basic-offset #s(hash-table size 3 test equal rehash-size 1.5 rehash-threshold 0.8125 purecopy t data ((:elem . basic) 9 (:after . ";") 13 (:before . "{") 27)) smie-rule-parent-p "case" smie-rule-parent sh-var-value sh-indent-after-case sh-smie--rc-after-special-arg-p column #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (:before 53 :list-intro 73)) ("[" "{" "(") smie-rule-hanging-p ("while" "if" "for") t nil] 7 (#$ . 63579)])
#@58 A buffer-local regexp to match opening keyword for done.
(defvar sh-regexp-for-done nil (#$ . 64342))
#@69 A buffer-local, since it is shell-type dependent, list of keywords.
(defvar sh-kw-alist nil (#$ . 64450))
(defconst sh-kw '((sh ("if" nil sh-handle-prev-if) ("elif" sh-handle-this-else sh-handle-prev-else) ("else" sh-handle-this-else sh-handle-prev-else) ("fi" sh-handle-this-fi sh-handle-prev-fi) ("then" sh-handle-this-then sh-handle-prev-then) ("(" nil sh-handle-prev-open) ("{" nil sh-handle-prev-open) ("[" nil sh-handle-prev-open) ("}" sh-handle-this-close nil) (")" sh-handle-this-close nil) ("]" sh-handle-this-close nil) ("case" nil sh-handle-prev-case) ("esac" sh-handle-this-esac sh-handle-prev-esac) (case-label nil sh-handle-after-case-label) (";;" nil sh-handle-prev-case-alt-end) (";;&" nil sh-handle-prev-case-alt-end) (";&" nil sh-handle-prev-case-alt-end) ("done" sh-handle-this-done sh-handle-prev-done) ("do" sh-handle-this-do sh-handle-prev-do)) (rc ("{" nil sh-handle-prev-open) ("}" sh-handle-this-close nil) ("case" sh-handle-this-rc-case sh-handle-prev-rc-case))))
#@793 Set this buffer's shell to SHELL (a string).
When used interactively, insert the proper starting #!-line,
and make the visited file executable via `executable-set-magic',
perhaps querying depending on the value of `executable-query'.
When this function is called noninteractively, INSERT-FLAG (the third
argument) controls whether to insert a #!-line and think about making
the visited file executable, and NO-QUERY-FLAG (the second argument)
controls whether to query about making the visited file executable.
Calls the value of `sh-set-shell-hook' if set.
Shell script files can cause this function be called automatically
when the file is visited by having a `sh-shell' file-local variable
whose value is the shell name (don't quote it).
(fn SHELL &optional NO-QUERY-FLAG INSERT-FLAG)
(defalias 'sh-set-shell #[769 "\306\307\"\203 \310\311\211\224#\262\312!\211\203 \313\314 !$\315\316\"\317\304!\210\320\317\305!\210\320\317\321!\210\3149!\314:!\211\203R \317\322!\210\323\322\"\324!\210\210\314;!\211\203h \211@\325!\210A\266\202\202W \210\317\326!\210\314<!\211\203\341 \327\330\"\210\331\332\333\334\335B\336\320$\210\337\340\341\320\342$\210\343\344!J\345!\346\347!\350\351!&\266=\204\321 \317\352!\210\314>!*\314?!\211\203\305 \317\353!\210\354\355\342\"!+\210\327\356!\210\317\357!\210\360/1\203\331 \361 \210\327\362\"\210\202\354 \327\363!\210\317\357!\210\364/@\203\372 \3205\365 \210\366 \210\320A\367\370!\207" [sh-shell sh-shell-arg sh-shell-file mode-line-process sh-shell-variables sh-shell-variables-initialized string-match "\\.exe\\'" substring 0 sh-canonicalize-shell executable-set-magic sh-feature format "[%s]" make-local-variable nil imenu-generic-expression sh-mode-syntax-table apply set-syntax-table sh-remember-variable sh-indent-supported-here message "Setting up indent for shell type %s" #[257 "\301\302\303#!\207" [sh-indent-supported-here intern format "sh-smie-%s-%s"] 6 "\n\n(fn NAME)"] advice--add-function :around #[0 "\300\301!\207" [advice--buffer-local smie--hanging-eolp-function] 2] #[257 "\300\301\"\207" [advice--set-buffer-local smie--hanging-eolp-function] 4 "\n\n(fn GV--VAL)"] #[257 "\300\301!\203\n \302\225b\207\211 \207" [looking-at "[ ]*\\\\\n" 0] 3 "\n\n(fn ORIG)"] add-hook smie-indent-functions sh-smie--indent-continuation t smie-setup "grammar" "rules" :forward-token "forward-token" :backward-token "backward-token" sh-kw-alist sh-regexp-for-done sh-mkword-regexpr regexp-opt "setting up indent stuff" indent-line-function sh-indent-line sh-make-vars-local "Indentation setup for shell type %s" "No indentation for this shell type." sh-basic-indent-line font-lock-set-defaults font-lock-flush run-hooks sh-set-shell-hook sh-imenu-generic-expression sh-mode-syntax-table-input sh-variables sh-indent-supported sh-use-smie sh-kw sh-kws-for-done font-lock-mode sh-shell-process] 12 (#$ . 65447) (byte-code "\303\304\305\"\306\307\310 \"\311\"\312\211\211\211&\n\313=\314E\207" [sh-shell-file sh-ancestor-alist executable-query completing-read format "Shell (default %s): " append mapcar #[257 "\300@!\207" [symbol-name] 3 "\n\n(fn E)"] ("csh" "rc" "sh") nil function t] 8)])
#@945 Index ALIST by the current shell.
If ALIST isn't a list where every element is a cons, it is returned as is.
Else indexing follows an inheritance logic which works in two ways:
- Fall back on successive ancestors (see `sh-ancestor-alist') as long as
the alist contains no value for the current shell.
The ultimate default is always `sh'.
- If the value thus looked up is a list starting with `sh-append',
we call the function `sh-append' with the rest of the list as
arguments, and use the value. However, the next element of the
list is not used as-is; instead, we look it up recursively
in ALIST to allow the function called to define the value for
one shell to be derived from another shell.
The value thus determined is physically replaced into the alist.
If FUNCTION is non-nil, it is called with one argument,
the value thus obtained, and the result is used instead.
(fn ALIST &optional FUNCTION)
(defalias 'sh-feature #[513 ":\203! \211\203 \211@:\203 \211A\262\202 \211\205 \262\206z \211\302\211\211\203> \236\211\262\204> \236A\211\204+ \204H \303\236\262A\262\211:\203j \211@\304>\203j \305@A@\306!)AA#\262\203u !\262)\266\202\262\207" [sh-shell sh-ancestor-alist nil sh (sh-append sh-modify) apply sh-feature] 11 (#$ . 68649)])
#@104 Return list composed of first argument (a list) physically appended to rest.
(fn ANCESTOR &rest LIST)
(defalias 'sh-append #[385 "\211\244\207" [] 4 (#$ . 69976)])
#@99 Modify a copy of SKELETON by replacing I1 with REPL1, I2 with REPL2 ...
(fn SKELETON &rest LIST)
(defalias 'sh-modify #[385 "\300!\262\211\203\" \211@\233\206 \301\302@\"A@\240\210\211AA\262\202 \207" [copy-sequence error "Index %d out of bounds"] 5 (#$ . 70148)])
#@180 Indent a line for Sh mode (shell script mode).
Indent as far as preceding non-empty line, then by steps of `sh-basic-offset'.
Lines containing only comments are considered empty.
(defalias 'sh-basic-indent-line #[0 "\212\303 \210o\204 \304y\210\305 \210l\204 g\306=\204 i)\307\212\310=\204, \2030 \311=\2030 \202d i\305 \210i\211\262W\203H l\203D \202d \312\202d `\303 \210`|\210l\203^ \n\245T\n_]\202d \211\n\245T\n_j\210)i\313 W\205q \314\307w\207" [this-command electric-indent-mode sh-basic-offset beginning-of-line -1 back-to-indentation 35 nil newline-and-indent newline 0 current-indentation " "] 5 (#$ . 70430) nil])
#@429 Pass optional header and region to a subshell for noninteractive execution.
The working directory is that of the buffer, and only environment variables
are already set which is why you can mark a header within the script.
With a positive prefix ARG, instead of sending region, define header from
beginning of buffer to point. With a negative prefix ARG, instead of sending
region, clear header.
(fn START END &optional FLAG)
(defalias 'sh-execute-region #[770 "\211\203 \303!\304V\205 \305 \211\207\2034 \212\306b\210\307p#\210\310eZ\\\211\262\n#\210|*\207\310\n\311P#\207" [sh-header-marker buffer-undo-list sh-shell-file prefix-numeric-value 0 point-marker nil append-to-buffer shell-command-on-region " -"] 8 (#$ . 71074) "r\nP"])
#@79 Make VARIABLE available for future completing reads in this buffer.
(fn VAR)
(defalias 'sh-remember-variable #[257 "\211GW\204 \302!\204 \303 \"\204 \211B B\207" [sh-remember-variable-min sh-shell-variables getenv assoc] 4 (#$ . 71835)])
#@52 Is point preceded by an odd number of backslashes?
(defalias 'sh-quoted-p #[0 "\212\300\301x)\302\246\303=\207" ["\\\\" nil 2 -1] 2 (#$ . 72088)])
#@116 Signal an error if the shell type for this buffer is not supported.
Also, the buffer must be in Shell-script mode.
(defalias 'sh-must-support-indent #[0 "?\205 \301\302!\207" [sh-indent-supported-here error "This buffer's shell does not support indentation through Emacs"] 2 (#$ . 72242)])
#@278 Make the indentation variables local to this buffer.
Normally they already are local. This command is provided in case
variable `sh-make-vars-local' has been set to nil.
To revert all these variables to the global values, use
command `sh-reset-indent-vars-to-global-values'.
(defalias 'sh-make-vars-local #[0 "\301\302\"\210\303\304!\207" [sh-var-list mapc make-local-variable message "Indentation variables are now local."] 3 (#$ . 72541) nil])
#@125 Reset local indentation variables to the global values.
Then, if variable `sh-make-vars-local' is non-nil, make them local.
(defalias 'sh-reset-indent-vars-to-global-values #[0 "\302\303\"\210 \205
\304\305\"\207" [sh-var-list sh-make-vars-local mapc kill-local-variable mapcar make-local-variable] 3 (#$ . 72997) nil])
(defconst sh-special-keywords "then\\|do")
#@82 Construct a string for `sh-read-variable' when changing variable VAR .
(fn VAR)
(defalias 'sh-help-string-for-variable #[257 "\302\303\"\304\305>\204 \306\307\310\311 \312##\262P\207" [sh-basic-offset sh-symbol-list documentation-property variable-documentation "" (sh-first-lines-indent sh-indent-comment) format "\n\nYou can enter a number (positive to increase indentation,\nnegative to decrease indentation, zero for no change to indentation).\n\nOr, you can enter one of the following symbols which are relative to\nthe value of variable `sh-basic-offset'\nwhich in this buffer is currently %s.\n\n %s." mapconcat #[257 "\211GS8\207" [] 3 "\n\n(fn X)"] "\n "] 10 (#$ . 73369)])
#@58 Read a new value for indentation variable VAR.
(fn VAR)
(defalias 'sh-read-variable #[257 "\302\303DD\304\305\306\307\310 !#\306\311J\"\304\312$\262)\207" [minibuffer-help-form help-char sh-help-string-for-variable quote nil read-from-minibuffer format "New value for %s (press %s for help): " single-key-description "%s" t] 9 (#$ . 74067)])
#@64 Return non-nil if START is in a comment or string.
(fn START)
(defalias 'sh-in-comment-or-string #[257 "\212\300!\3018\206
\3028\262)\207" [syntax-ppss 3 4] 4 (#$ . 74423)])
#@67 Go to the matching if for a fi.
This handles nested if..fi pairs.
(defalias 'sh-goto-matching-if #[0 "\300\301\302\303#\211\205 \211b\207" [sh-find-prev-matching "\\bif\\b" "\\bfi\\b" 1] 4 (#$ . 74609)])
(defalias 'sh-handle-prev-if #[0 "\300C\207" [(+ sh-indent-after-if)] 1])
(defalias 'sh-handle-this-else #[0 "\300 \205 \301\302D\207" [sh-goto-matching-if "aligned to if" (+ sh-indent-for-else)] 2])
(defalias 'sh-handle-prev-else #[0 "\300 \205 \301C\207" [sh-goto-matching-if (+ sh-indent-after-if)] 1])
(defalias 'sh-handle-this-fi #[0 "\300 \205 \301\302D\207" [sh-goto-matching-if "aligned to if" (+ sh-indent-for-fi)] 2])
(defalias 'sh-handle-prev-fi #[0 "\300 \210\301\207" [sh-goto-matching-if nil] 1])
(defalias 'sh-handle-this-then #[0 "\300 \211\205 \301C\207" [sh-goto-matching-if (+ sh-indent-for-then)] 2])
(defalias 'sh-handle-prev-then #[0 "\300 \211\205 \301C\207" [sh-goto-matching-if (+ sh-indent-after-if)] 2])
(defalias 'sh-handle-prev-open #[0 "\212\300 \211\203 \211b\210\301\302!\204 \301\303!\203 \304C\202 \305C\262)\207" [sh-prev-stmt looking-at "function\\b" "\\s-*\\S-+\\s-*()" (+ sh-indent-after-function) (+ sh-indent-after-open)] 3])
(defalias 'sh-handle-this-close #[0 "\300u\210\301\302!\205 \303C\207" [1 sh-safe-forward-sexp -1 "aligned to opening paren"] 2])
(defalias 'sh-goto-matching-case #[0 "\300\301\302\303#\211\205 \211b\207" [sh-find-prev-matching "\\bcase\\b" "\\besac\\b" 1] 4])
(defalias 'sh-handle-prev-case #[0 "\300\301!\203 \302C\207\303\304!\207" [looking-at ".*\\<case\\>" (+ sh-indent-for-case-label) error "We don't seem to be on a line with a case"] 2])
(defalias 'sh-handle-this-esac #[0 "\300 \205 \301C\207" [sh-goto-matching-case "aligned to matching case"] 1])
(defalias 'sh-handle-prev-esac #[0 "\300 \205 \301C\207" [sh-goto-matching-case "matching case"] 1])
(defalias 'sh-handle-after-case-label #[0 "\300 \205 \301C\207" [sh-goto-matching-case (+ sh-indent-for-case-alt)] 1])
(defalias 'sh-handle-prev-case-alt-end #[0 "\300 \205 \301C\207" [sh-goto-matching-case (+ sh-indent-for-case-label)] 1])
#@126 Try and do a `forward-sexp', but do not error.
Return new point if successful, nil if an error occurred.
(fn &optional ARG)
(defalias 'sh-safe-forward-sexp #[256 "\3001 \301\206\n \302!\210`0\207\210\303\207" [(error) forward-sexp 1 nil] 3 (#$ . 76704)])
(defalias 'sh-goto-match-for-done #[0 "\302 \303#\211\205 \211b\207" [sh-regexp-for-done sh-re-done sh-find-prev-matching 1] 4])
(defalias 'sh-handle-this-done #[0 "\300 \205 \301\302D\207" [sh-goto-match-for-done "aligned to do stmt" (+ sh-indent-for-done)] 2])
(defalias 'sh-handle-prev-done #[0 "\300 \205 \301C\207" [sh-goto-match-for-done "previous done"] 1])
(defalias 'sh-handle-this-do #[0 "\300 \205 \301C\207" [sh-goto-match-for-done (+ sh-indent-for-do)] 1])
(defalias 'sh-handle-prev-do #[0 "\214`\300 }\210\301 )\203 \302C\207\301 \203 \303C\207\304\305!\210\306\207" [line-beginning-position sh-goto-match-for-done (+ sh-indent-after-loop-construct) (+ sh-indent-after-do) message "match for done NOT found" nil] 2])
#@73 Find the line for the switch keyword matching this line's case keyword.
(defalias 'sh-find-prev-switch #[0 "\300\301\302\303#\207" [re-search-backward "\\<switch\\>" nil t] 4 (#$ . 77706)])
(defalias 'sh-handle-this-rc-case #[0 "\300 \205 \301C\207" [sh-find-prev-switch (+ sh-indent-after-switch)] 1])
(defalias 'sh-handle-prev-rc-case #[0 "\300C\207" [(+ sh-indent-after-case)] 1])
#@16
(fn N THING)
(defalias 'sh-check-rule #[514 "\301\"8\302\203 \262\207" [sh-kw-alist assoc nil] 6 (#$ . 78097)])
#@903 Return indent-info for this line.
This is a list. nil means the line is to be left as is.
Otherwise it contains one or more of the following sublists:
(t NUMBER) NUMBER is the base location in the buffer that indentation is
relative to. If present, this is always the first of the
sublists. The indentation of the line in question is
derived from the indentation of this point, possibly
modified by subsequent sublists.
(+ VAR)
(- VAR) Get the value of variable VAR and add to or subtract from
the indentation calculated so far.
(= VAR) Get the value of variable VAR and *replace* the
indentation with its value. This only occurs for
special variables such as `sh-indent-comment'.
STRING This is ignored for the purposes of calculating
indentation, it is printed in certain cases to help show
what the indentation is based on.
(defalias 'sh-get-indent-info #[0 "\212\301\211\211\211\211\211\211\302 \210\303\304`!8\204 \305`\306\"\307=\203% \310\262\310\262\202A \311\312!\203A o\2035 \310\262\202A \313C\262\314\301!\262\301\262\204\234 \315 \203r \212\302 \210`\316Z\206V `Sf\317>)\204c \320C\202j \314\301!\262\321C\262\310\262\202} \302 \210\322\301w\210\323 \262\203\234 \324\325\"\211\262\203\234 `\262\326\"\262\310\262`\262\204\246 \314\327!\262\203k\212b\210\310\262\211\203j\330 \211\262\203j\211\331\232\203\362 \305`S\332\"\232\203\362 \333\262\324\316\"\211\262\203\344 \326\"\262`\262o\204\353 \334u\210\335\301w\210\202\261 \336\337\"\203\340\334!\262\211\203\261 `\262\326\341C\"\262\202\261 \336\342\"\2030\324\316\"\211\262\203'\326\"\262\334u\210`\262\202\261 \336\343\"\203?\340\334!\262\202\261 \211;\203b\324\316\"\211\262\203U\326\"\262`\262n\204\261 \334u\210\202\261 \344\345\"\210\202\261 )\203x\326\310DC\"\262\204\214\203\206\310D\202\211\346\347DC\262\310=\203\225\301\262\266\207)\207" [sh-st-punc nil beginning-of-line 3 syntax-ppss get-text-property face sh-heredoc t looking-at "\\s-*#" (= sh-indent-comment) sh-prev-line sh-this-is-a-continuation 2 (32 9) (= nil) (+ sh-indent-for-continuation) " " sh-get-kw sh-check-rule 1 append end sh-prev-thing ")" syntax-table case-label -1 "*0-9?[]a-z" string-match "[])}]" sh-safe-forward-sexp "aligned to opening paren" "[[({]" "[\"'`]" error "Don't know what to do with %s" = sh-first-lines-indent] 10 (#$ . 78226)])
#@218 Return the variable controlling indentation for this line.
If there is not [just] one such variable, return a string
indicating the problem.
If INFO is supplied it is used, else it is calculated.
(fn &optional INFO)
(defalias 'sh-get-indent-var-for-line #[256 "\300\211\211\211\211\204
\301 \262\204 \302\262\202t \203t \204t @\262\211;\203. \211\262\202m \211<\204; \303\304\"\210\202m \211@\305=\204m \211A@\211\2629\203h \306=\203X \262\202m \203b \307\262\202m \262\202m \303\310\"\210A\262\202 \204{ \262\204\202 \262\204\211 \311\262\207" [nil sh-get-indent-info "this line to be left as is" error "sh-get-indent-var-for-line invalid elt: %s" t sh-indent-comment "this line is controlled by more than 1 variable." "sh-get-indent-var-for-line invalid list elt: %s" "line has default indentation"] 9 (#$ . 80693)])
#@216 Back to end of previous non-comment non-empty line.
Go to beginning of logical line unless END is non-nil, in which case
we go to the end of the previous line and do not check for continuations.
(fn &optional END)
(defalias 'sh-prev-line #[256 "\212\300 \210\301d[!\210\211\204 \300 \210o\2048 \302`S\303\"\304=\2038 \305`S\303\"\211\2037 \211b\210\2034 \306\210\2027 \300 \210\210\211\204O \307 \203H \310\311yY\204< \300 \210\312\306w\210`)\207" [beginning-of-line forward-comment get-text-property face sh-heredoc previous-single-property-change nil sh-this-is-a-continuation 0 -1 " "] 4 (#$ . 81553)])
#@49 Return the address of the previous stmt or nil.
(defalias 'sh-prev-stmt #[0 "\212\301`\302\211\303\302x\210\204r o\204r \203r \304\305!\203- \306!\203' \211\262\202M `\262\202M \307\302x\310U\2038 \305u\210n\203M \311\302!\211\203I \211b\210\202L \302\262\210\204 \312\302x\210n\203^ \313 \203l `Sf\314=\204l \306\315!\203 `\262\202 \203y b\210\203\204 \316\302w\210`\262`Y\203\221 \317\320!\210\302\262\266\204)\207" [sh-special-keywords t nil " ;|&({[" sh-safe-forward-sexp -1 looking-at " ()[]{};`'" 0 sh-prev-line " " sh-this-is-a-continuation 59 "\\s-*[|&]" " |&({[" debug "We didn't move!"] 6 (#$ . 82170) nil])
#@50 Get a shell word skipping whitespace from point.
(defalias 'sh-get-word #[0 "\300\301w\210`\302\303!\203 \304 \202 \305\301w\306V\204 \211`{\207" [" " nil looking-at "[\"'`]" sh-safe-forward-sexp "-_$[:alnum:]" 0] 3 (#$ . 82816) nil])
#@46 Return the previous thing this logical line.
(defalias 'sh-prev-thing #[0 "n?\205l `\301 \203 \302\303!\202 \304 \305x\210\306\307!\203! \310\202j \311x\210`V\205. `Sf\211\312>\204: \313!\202h `\303\211\314w\210`Y\204b \211\203P \211\262\315 \262\316!\235\203b `\262\202= b\210\266\203\262\266\202\207" [sh-leading-keywords sh-this-is-a-continuation sh-prev-line nil line-beginning-position " ;" looking-at "\\s-*;[;&]" ";;" "^)}];\"'`({[" (10 nil 59) char-to-string " \n\\\\" sh-get-word sh-feature] 9 (#$ . 83061)])
#@68 Return non-nil if current line is a continuation of previous line.
(defalias 'sh-this-is-a-continuation #[0 "\212\300y\301U\205 \302\303!\205 \304\305\301\224\301\225\306\211\211\307&8?)\207" [-1 0 looking-at ".*\\\\$" 4 parse-partial-sexp nil t] 8 (#$ . 83605)])
#@119 Return first word of line from WHERE.
If AND-MOVE is non-nil then move to end of word.
(fn &optional WHERE AND-MOVE)
(defalias 'sh-get-kw #[512 "`\203 b\210`\300\301w\210`{\204 b\210\207" ["^ \n;&|" nil] 6 (#$ . 83879)])
#@296 Find a matching token for a set of opening and closing keywords.
This takes into account that there may be nested open..close pairings.
OPEN and CLOSE are regexps denoting the tokens to be matched.
Optional parameter DEPTH (usually 1) says how many to look for.
(fn OPEN CLOSE &optional DEPTH)
(defalias 'sh-find-prev-matching #[770 "\302\303\211\206\f \304\262\212\3051X \306U?\205T o?\205T \307 \211\262\205T \211b\210\212\310\311!\2038 \312u\210\313\303w\210\310!\203F S\262\202P \310!\203P T\262)\202 0\202\\ \210\202] \210\306=\205d \211+\207" [forward-sexp-function parse-sexp-ignore-comments t nil 1 (error) 0 sh-prev-stmt looking-at "\\\\\n" 2 " "] 8 (#$ . 84115)])
#@214 Return the value of variable VAR, interpreting symbols.
It can also return t or nil.
If an invalid value is found, throw an error unless Optional argument
IGNORE-ERROR is non-nil.
(fn VAR &optional IGNORE-ERROR)
(defalias 'sh-var-value #[513 "J\211\247\203 \211\202U \211\301=\203 \211\202U \211\204 \211\202U \211\302\267\202F \202U [\202U \303_\202U \303[_\202U \303\245\202U [\303\245\202U \203N \304\202O \305\306#\210\307\207" [sh-basic-offset t #s(hash-table size 6 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (+ 35 - 39 ++ 44 -- 50 * 57 / 63)) 2 message error "Don't know how to handle %s's value of %s" 0] 7 (#$ . 84815)])
#@171 Set variable VAR to VALUE.
Unless optional argument NO-SYMBOL is non-nil, then if VALUE is
can be represented by a symbol then do so.
(fn VAR VALUE &optional NO-SYMBOL)
(defalias 'sh-set-var-value #[770 "\211\203 L\207U\203 \301L\207[U\203 \302L\207\303_=\203) \304L\207\303[_=\2036 \305L\207\303\245=\203B \306L\207[\303\245=\203O \307L\207L\207" [sh-basic-offset + - 2 ++ -- * /] 6 (#$ . 85487)])
#@140 Return the indentation for the current line.
If INFO is supplied it is used, else it is calculated from current line.
(fn &optional INFO)
(defalias 'sh-calculate-indent #[256 "\300\211\301\211\211\211\204 \302 \262\205\327 \203\261 @\262;\204\251 <\203\244 @@\262@A@\262\303=\203J \212b\210\304 \262)\211\262\202\251 9\203\233 \305!\262\306\267\202\222 \211\204j \301\262\301\262\301\262\202\251 \211\303=\203v \300\262\202\251 \211\262\300\262\301\262\202\251 \\\262\202\251 Z\262\202\251 \307\310#\210\202\251 \307\311#\210\202\251 \307\312\"\210A\262\202 \203\271 \204\275 \301\202\327 \247\203\316 \247\203\316 \\\202\327 \307\313#\210\301\207" [0 nil sh-get-indent-info t current-indentation sh-var-value #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (= 90 + 130 - 138)) error "sh-calculate-indent invalid a a=%s b=%s" "sh-calculate-indent invalid elt: a=%s b=%s" "sh-calculate-indent invalid elt %s" "sh-calculate-indent: Help. base-value=%s ofs=%s"] 11 (#$ . 85919)])
#@26 Indent the current line.
(defalias 'sh-indent-line #[0 "\300 d`Z\205 \301 \210\302\303w\210\304!\210dZ`V\205 dZb\207" [sh-calculate-indent beginning-of-line " " nil indent-line-to] 4 (#$ . 87002) nil])
#@83 Move cursor momentarily to BLINKPOS and display MSG.
(fn BLINKPOS &optional MSG)
(defalias 'sh-blink #[513 "\247\203 \212b\210\211\203 \301\302\"\210\202 \301\303!\210\304!)\207\211\203' \301\302\"\207\301\303!\207" [blink-matching-delay message "%s" nil sit-for] 5 (#$ . 87217)])
#@356 Show how the current line would be indented.
This tells you which variable, if any, controls the indentation of
this line.
If optional arg ARG is non-null (called interactively with a prefix),
a pop up window describes this variable.
If variable `sh-blink' is non-nil then momentarily go to the line
we are indenting relative to, if applicable.
(fn ARG)
(defalias 'sh-show-indent #[257 "\302 \210\203\n \303 \207\304 \305!\306 \307\211;\203# \310\311\211\262\"\210\202^ \312!\262=\2039 \313\314\211J#\262\202R \203J \313\315\211J%\202P \313\316\211J#\262\203^ \203^ \317!\210 \203\211 \304 \211\203\200 \211@<\203\200 \211@@\320=\203\200 \301@A@\"\202\204 \310\311\"\262\202\215 \310\311\"\207" [sh-use-smie sh-blink sh-must-support-indent smie-config-show-indent sh-get-indent-info sh-get-indent-var-for-line current-indentation nil message "%s" sh-calculate-indent format "%s is %s" "%s (%s) would change indent from %d to: %d" "%s (%s) would leave line as is" describe-variable t] 12 (#$ . 87514) "P"])
#@136 Set the indentation for the current line.
If the current line is controlled by an indentation variable, prompt
for a new value for it.
(defalias 'sh-set-indent #[0 "\301 \210\203\n \302 \207\303 \304!\305\211\211;\203 \306\307\"\202\\ J\262\310!\262\3111L L\210\312!\262\211\203B \306\313\211J$\202H \306\314\211J#0\202\\ \210L\210\306\315#\210\316\317!\210\305\207" [sh-use-smie sh-must-support-indent smie-config-set-indent sh-get-indent-info sh-get-indent-var-for-line nil message "Cannot set indent - %s" sh-read-variable (error) sh-calculate-indent "Variable: %s Value: %s would indent to: %d" "Variable: %s Value: %s would leave line as is." "Bad value for %s, restoring to previous value %s" sit-for 1] 10 (#$ . 88555) nil])
#@357 Learn how to indent a line as it currently is indented.
If there is an indentation variable which controls this line's indentation,
then set it to a value which would indent the line the way it
presently is.
If the value can be represented by one of the symbols then do so
unless optional argument ARG (the prefix when interactive) is non-nil.
(fn ARG)
(defalias 'sh-learn-line-indent #[257 "\302 \210\203\n \303 \207\212\304 \210\305\306!)\203 \307\310!\207\311 \312!\313\211\211\211\314 ;\2034 \307\315\"\202\231 \301=\203d \211\316U\203E \316\202Y \317\320!\211U\203U \317\202V )\262\307\321\211J#\202\231 \322!\211\262\247\203\221 \320!\262\211Z\262\\\262\323#\210\307\321\211J#\202\231 \324 \210\307\325\"\207" [sh-use-smie sh-indent-comment sh-must-support-indent smie-config-set-indent beginning-of-line looking-at "\\s-*$" message "sh-learn-line-indent ignores empty lines." sh-get-indent-info sh-get-indent-var-for-line nil current-indentation "Cannot learn line - %s" 0 t sh-calculate-indent "%s set to %s" sh-var-value sh-set-var-value debug "Cannot change %s"] 13 (#$ . 89318) "*P"])
#@64 Initialize a BUFFER to be used by `sh-mark-line'.
(fn BUFFER)
(defalias 'sh-mark-init #[257 "r\300!q\210\301 \210\302 )\207" [get-buffer-create erase-buffer occur-mode] 3 (#$ . 90463)])
#@359 Insert MESSAGE referring to location POINT in current buffer into BUFFER.
Buffer BUFFER is in `occur-mode'.
If ADD-LINENUM is non-nil the message is preceded by the line number.
If OCCUR-POINT is non-nil then the line is marked as a new occurrence
so that `occur-next' and `occur-prev' will work.
(fn MESSAGE POINT BUFFER &optional ADD-LINENUM OCCUR-POINT)
(defalias 'sh-mark-line #[1283 "\301 \302\303\203 p\223\210\203 \304\305\306\307\n\"T\"\262\212\310!\203/ \310!q\210\2028 \311!q\210\312 \210db\210`\262\313\211c\210\203J `\262c\210\203Y \314`\315#\210\316c\210\205s \317`\320$\210\205s \317\321\313$*\207" [inhibit-read-only make-marker nil "" format "%d: " count-lines 1 get-buffer get-buffer-create occur-mode t add-text-properties (mouse-face highlight help-echo "mouse-2: go to the line where I learned this") "\n" put-text-property occur-target occur-match] 13 (#$ . 90658)])
#@62 An abnormal hook, called with an alist of learned variables.
(defvar sh-learned-buffer-hook nil (#$ . 91586))
#@1088 Learn how to indent the buffer the way it currently is.
If `sh-use-smie' is non-nil, call `smie-config-guess'.
Otherwise, run the sh-script specific indent learning command, as
described below.
Output in buffer "*indent*" shows any lines which have conflicting
values of a variable, and the final value of all variables learned.
When called interactively, pop to this buffer automatically if
there are any discrepancies.
If no prefix ARG is given, then variables are set to numbers.
If a prefix arg is given, then variables are set to symbols when
applicable -- e.g. to symbol `+' if the value is that of the
basic indent.
If a positive numerical prefix is given, then `sh-basic-offset'
is set to the prefix's numerical value.
Otherwise, sh-basic-offset may or may not be changed, according
to the value of variable `sh-learn-basic-offset'.
Abnormal hook `sh-learned-buffer-hook' if non-nil is called when the
function completes. The function is abnormal because it is called
with an alist of variables learned.
This command can often take a long time to run.
(fn &optional ARG)
(defalias 'sh-learn-buffer-indent #[256 "\306 \210\203\n \307 \207\212eb\210\310\311\312\310\313\310\211\211\314\310\n\205' \n\247\205' \n\312V\312\310\315 \312\"\262\316\f!\210\203E
\317\320 \"\262\202K \317\321 \"\262`dW\203DT\262\322\323\"\210\324\325!\204>\314\326 \327!\310\211\211\211\330 \203;;\204;\331\332\"\211\262\247\203\333 \262\211Z\262\\\262\334\335#\210\324\336!\204;\337\"\211\262\203\344 JA@=\204\361 \340\317\341\211J#`\314\211%\210\340\317\342A@\"\3438\314$\210T\262J`D\241\210\202\361 \344\211J`EC\"\262\247\203;\312W\203 [\262W\203;HTI\210\202;\302=\203;\211\333!U\204;\310\262\f\f\2038\f=\204;\314\262
\202;\211\262
)\266\345y\210\202K \203Y\317\346#\262\340\310#\210\312=\203e\347\262\202\207\203r\350\262\314\262\202\207\247\203\201\317\351\"\262\202\207\352\262\310\262\340\310#\210\340\310\314\211%\210\353!\262\211\203 \204 \f\314=\203\265\211\247\203\265\211\202\317\f\203\316\211\247\203\302\211\202\317\211G\345U\205\317\211@\202\317\310\211\203\355\344\301\211dEC\"\262\340\317\354 \"\310#\210\202\340<\203\377\317\355\356\357\360#\"\202\317\361\"\310#\210\210\344\302dEC\"\262
\362 \340\363\310#\210\203N\364!\211\203M\211@\211@A@\301=\204D\211\247\203D\334\"\210\266A\266\202\202)\210\364!\211\203p\211@\211@\340\317\365\211J#\3438#\266A\266\202\202R\210r\fq\210eb\210\314 \317\366\"\317\367\211\345U\203\215\370\202\216\371\312U\203\231\372\202\232\373$\261\210*\210\374\375\"\210\376\377!\205\276@\204\270\n\312V\205\276\201A \f!\266\215)\207" [sh-use-smie sh-basic-offset sh-indent-comment sh-debug sh-learn-basic-offset inhibit-read-only sh-must-support-indent smie-config-guess nil "*indent*" 0 17 t make-vector sh-mark-init format "Using specified sh-basic-offset of %d" "Initial value of sh-basic-offset: %s" message "line %d" looking-at "\\s-*$" sh-get-indent-info sh-get-indent-var-for-line current-indentation sh-var-value no-error sh-calculate-indent sh-set-var-value no-symbol "\\s-*#" assoc sh-mark-line "Variable %s was set to %s" " but was previously set to %s" 2 append 1 "comment-col = %s comments-always-default = %s" "\nComments are all in 1st column.\n" "\nComments follow default indentation.\n" "\nComments are in col %d." "\nComments seem to be mixed, leaving them as is.\n" sh-guess-basic-offset "Changed sh-basic-offset to: %d" "Possible value(s) for sh-basic-offset: %s" mapconcat int-to-string " " "Suggested sh-basic-offset: %d" buffer-name "\nLearned variable settings:" reverse " %s %s" "Indentation values for buffer %s.\n" "%d indentation variable%s different values%s\n\n" " has" "s have" "." ":" run-hook-with-args sh-learned-buffer-hook called-interactively-p any sh-popup-occur-buffer pop-to-buffer] 27 (#$ . 91704) "P"])
#@415 See if we can determine a reasonable value for `sh-basic-offset'.
This is experimental, heuristic and arbitrary!
Argument VEC is a vector of information collected by
`sh-learn-buffer-indent'.
Return values:
number - there appears to be a good single value
list of numbers - no obvious one, here is a list of one or more
reasonable choices
nil - we couldn't find a reasonable one.
(fn VEC)
(defalias 'sh-guess-basic-offset #[257 "\211GS\300\301\302\"W\203[ \211H\303 H_\\I\266\304\246\302U\203: \211H\304\245H\\I\266\304_W\203T \211H\304_H\\I\266T\262\202 \305\211\211\211\211\300\262W\203\210 H\302U\204\200 HBB\262T\262\202c \306\237\307\"\262\310\311\312\305\"\"\262G\302U\203\247 \313\314!\210\202FG\300U\203\276 \313\315@@\"\210@@\262\202F@A\304\245V\203\330 \313\316@@\"\210@@\262\202F@A\304A@A_Y\203\366 \313\317@@\"\210@@\262\202F@AA@A\\\304\245Y\203>\262\302\262\305\262\211\2031@A\\\211\262\304\245X\2031\312@@C\"\262\211A\262\202\313\320\321\322\323#\"\210\202F\313\324@@\"\210\266\205\207" [1 make-vector 0 4 2 nil sort #[514 "AAV\207" [] 4 "\n\n(fn A B)"] apply + append message "no values!" "only value is %d" "basic-offset is probably %d" "basic-offset could be %d" "Possible choices for sh-basic-offset: %s" mapconcat int-to-string " " "No obvious value for sh-basic-offset. Perhaps %d"] 15 (#$ . 95713)])
#@47 A list of all known shell indentation styles.
(defvar sh-styles-alist nil (#$ . 97179))
#@312 Name the current indentation settings as a style called NAME.
If this name exists, the command will prompt whether it should be
overwritten if
- - it was called interactively with a prefix argument, or
- - called non-interactively with optional CONFIRM-OVERWRITE non-nil.
(fn NAME &optional CONFIRM-OVERWRITE)
(defalias 'sh-name-style #[513 "\302\303\"B\304 \"\211\203+ \203 \305\306!\204 \307\310\"\2025 \307\311\"\210\211A\241\2025 \307\312\"\210 B\211\207" [sh-var-list sh-styles-alist mapcar #[257 "\211JB\207" [] 3 "\n\n(fn VAR)"] assoc y-or-n-p "This style exists. Overwrite it? " message "Not changing style %s" "Updating style %s" "Creating new style %s"] 7 (#$ . 97274) (byte-code "\301\302!?D\207" [current-prefix-arg read-from-minibuffer "Name for this style? "] 2)])
#@83 Set shell indentation values for this buffer from those in style NAME.
(fn NAME)
(defalias 'sh-load-style #[257 "\301\"\211\204 \302\303\"\202& \211A\211\205$ \211@\211@AL\210A\266\202\202 \262\207" [sh-styles-alist assoc error "sh-load-style - style %s not known"] 6 (#$ . 98075) (byte-code "\301\302\303\304$C\207" [sh-styles-alist completing-read "Which style to use for this buffer? " nil t] 5)])
#@108 Save all current styles in elisp to buffer BUFF.
This is always added to the end of the buffer.
(fn BUFF)
(defalias 'sh-save-styles-to-buffer #[257 "r\301!q\210db\210\302c\210\303\304\300\305DEp\")\207" [sh-styles-alist get-buffer-create "\n" pp setq quote] 6 (#$ . 98493) (byte-code "\300\301\302\"C\207" [read-from-minibuffer "Buffer to save styles in? " "*scratch*"] 3)])
(defconst sh-non-closing-paren (propertize ")" 'syntax-table sh-st-punc 'rear-nonsticky t))
(put 'sh-case 'no-self-insert t)
#@579 Insert a case/switch statement. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-case #[512 "\300\301#\207" [skeleton-proxy-new ((csh "expression: " "switch( " str " )" n > "case " (read-string "pattern: ") 58 n > _ n "breaksw" n ("other pattern, %s: " < "case " str 58 n > _ n "breaksw" n) < "default:" n > _ n resume: < < "endsw" n) (es) (rc "expression: " > "switch( " str " ) {" n > "case " (read-string "pattern: ") n > _ n ("other pattern, %s: " "case " str > n > _ n) "case *" > n > _ n resume: 125 > n) (sh "expression: " > "case " str " in" n ("pattern, %s: " > str sh-non-closing-paren n > _ n ";;" n) > "*" sh-non-closing-paren n > _ n resume: "esac" > n))] 6 (#$ . 99003) "*P\nP"])
(put 'sh-for 'no-self-insert t)
#@566 Insert a for loop. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-for #[512 "\300\301#\207" [skeleton-proxy-new ((csh sh-modify sh 1 "" 2 "foreach " 4 " ( " 6 " )" 15 '< 16 "end") (es sh-modify rc 4 " = ") (rc sh-modify sh 2 "for( " 6 " ) {" 15 125) (sh "Index variable: " > "for " str " in " _ "; do" n > _ | 36 & (sh-remember-variable str) n "done" > n))] 6 (#$ . 100249) "*P\nP"])
(put 'sh-indexed-loop 'no-self-insert t)
#@583 Insert an indexed loop from 1 to n. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-indexed-loop #[512 "\300\301#\207" [skeleton-proxy-new ((bash sh-modify posix) (csh "Index variable: " "@ " str " = 1" n "while( $" str " <= " (read-string "upper limit: ") " )" n > _ 36 str n "@ " str "++" n < "end" n) (es sh-modify rc 4 " =") (ksh88 "Index variable: " > "integer " str "=0" n > "while (( ( " str " += 1 ) <= " (read-string "upper limit: ") " )); do" n > _ 36 (sh-remember-variable str) > n "done" > n) (posix "Index variable: " > str "=1" n "while [ $" str " -le " (read-string "upper limit: ") " ]; do" n > _ 36 str n str 61 (sh-add (sh-remember-variable str) 1) n "done" > n) (rc "Index variable: " > "for( " str " in" " `{awk 'BEGIN { for( i=1; i<=" (read-string "upper limit: ") "; i++ ) print i }'`}) {" n > _ 36 (sh-remember-variable str) n 125 > n) (sh "Index variable: " > "for " str " in `awk 'BEGIN { for( i=1; i<=" (read-string "upper limit: ") "; i++ ) print i }'`; do" n > _ 36 (sh-remember-variable str) n "done" > n))] 6 (#$ . 101196) "*P\nP"])
#@88 Scan the buffer for variable assignments.
Add these variables to `sh-shell-variables'.
(defalias 'sh-shell-initialize-variables #[0 "\301\302\303 \"\210\212eb\210\304\305\306\307\304#\203 \310 \210\202\f )\311\312\310\307\304$\210\301\313\303 \"\207" [sh-shell-variables-initialized message "Scanning buffer `%s' for variable assignments..." buffer-name t search-forward "=" nil sh--assignment-collect add-hook post-self-insert-hook "Scanning buffer `%s' for variable assignments...done"] 5 (#$ . 102779)])
#@575 Do completion using `sh-shell-variables', but initialize it first.
This function is designed for use as the "completion table",
so it takes three arguments:
STRING, the current buffer contents;
PREDICATE, the predicate for filtering possible matches;
CODE, which says what kind of things to do.
CODE can be nil, t or `lambda'.
nil means to return the best completion of STRING, or nil if there is none.
t means to return a list of all possible completions of STRING.
`lambda' means to return t if STRING is a valid completion as it stands.
(fn STRING PREDICATE CODE)
(defalias 'sh-add-completer #[771 "rq\210 \204 \304 \210\305\306\n\" \244)\307$\207" [sh-add-buffer sh-shell-variables-initialized process-environment sh-shell-variables sh-shell-initialize-variables mapcar #[257 "\300\301\302\303\"#\207" [substring 0 string-match "="] 7 "\n\n(fn VAR)"] complete-with-action] 9 (#$ . 103295)])
#@85 Insert an addition of VAR and prefix DELTA for Bourne (type) shell.
(fn VAR DELTA)
(defalias 'sh-add #[514 "\300\301!\302!\303W\203 \304\202 \305\306\307!!\300\310!\261\207" [sh-feature ((bash . "$(( ") (ksh88 . "$(( ") (posix . "$(( ") (rc . "`{expr $") (sh . "`expr $") (zsh . "$[ ")) sh-remember-variable 0 " - " " + " number-to-string abs ((bash . " ))") (ksh88 . " ))") (posix . " ))") (rc . "}") (sh . "`") (zsh . " ]"))] 8 (#$ . 104213) (byte-code "p\302\303\304\"\305 !)D\207" [sh-add-buffer current-prefix-arg completing-read "Variable: " sh-add-completer prefix-numeric-value] 3)])
(put 'sh-function 'no-self-insert t)
#@577 Insert a function definition. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-function #[512 "\300\301#\207" [skeleton-proxy-new ((bash sh-modify ksh88 3 "() {") (ksh88 "name: " "function " str " {" n > _ n < "}" n) (rc sh-modify ksh88 1 "fn ") (sh nil "() {" n > _ n < "}" n))] 6 (#$ . 104857) "*P\nP"])
(put 'sh-if 'no-self-insert t)
#@571 Insert an if statement. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-if #[512 "\300\301#\207" [skeleton-proxy-new ((csh "condition: " "if( " str " ) then" n > _ n ("other condition, %s: " < "else if( " str " ) then" n > _ n) < "else" n > _ n resume: < "endif" n) (es "condition: " > "if { " str " } {" n > _ n ("other condition, %s: " "} { " str " } {" > n > _ n) "} {" > n > _ n resume: 125 > n) (rc "condition: " > "if( " str " ) {" n > _ n ("other condition, %s: " "} else if( " str " ) {" > n > _ n) "} else {" > n > _ n resume: 125 > n) (sh "condition: " '(setq input (sh-feature sh-test)) > "if " str "; then" n > _ n ("other condition, %s: " > "elif " str "; then" > n > n) "else" > n > n resume: "fi" > n))] 6 (#$ . 105714) "*P\nP"])
(put 'sh-repeat 'no-self-insert t)
#@580 Insert a repeat loop definition. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-repeat #[512 "\300\301#\207" [skeleton-proxy-new ((es nil > "forever {" n > _ n 125 > n) (zsh "factor: " > "repeat " str "; do" > n > n "done" > n))] 6 (#$ . 107015) "*P\nP"])
(put 'sh-select 'no-self-insert t)
#@574 Insert a select statement. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-select #[512 "\300\301#\207" [skeleton-proxy-new ((ksh88 "Index variable: " > "select " str " in " _ "; do" n > 36 str n "done" > n) (bash sh-append ksh88))] 6 (#$ . 107828) "*P\nP"])
(put 'sh-tmp-file 'no-self-insert t)
#@593 Insert code to setup temporary file handling. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-tmp-file #[512 "\300\301#\207" [skeleton-proxy-new ((bash sh-append ksh88) (csh (file-name-nondirectory (buffer-file-name)) "set tmp = `mktemp -t " str ".XXXXXX`" n "onintr exit" n _ (and (goto-char (point-max)) (not (bolp)) 10) "exit:\n" "rm $tmp* >&/dev/null" > n) (es (file-name-nondirectory (buffer-file-name)) > "local( signals = $signals sighup sigint;" n > "tmp = `{ mktemp -t " str ".XXXXXX } ) {" n > "catch @ e {" n > "rm $tmp^* >[2]/dev/null" n "throw $e" n "} {" > n _ n 125 > n 125 > n) (ksh88 sh-modify sh 7 "EXIT") (rc (file-name-nondirectory (buffer-file-name)) > "tmp = `{ mktemp -t " str ".XXXXXX }" n "fn sigexit { rm $tmp^* >[2]/dev/null }" n) (sh (file-name-nondirectory (buffer-file-name)) > "TMP=`mktemp -t " str ".XXXXXX`" n "trap \"rm $TMP* 2>/dev/null\" " 48 n))] 6 (#$ . 108645) "*P\nP"])
(put 'sh-until 'no-self-insert t)
#@569 Insert an until loop. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-until #[512 "\300\301#\207" [skeleton-proxy-new ((sh "condition: " '(setq input (sh-feature sh-test)) > "until " str "; do" n > _ n "done" > n))] 6 (#$ . 110110) "*P\nP"])
(put 'sh-while 'no-self-insert t)
#@568 Insert a while loop. See `sh-feature'.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-while #[512 "\300\301#\207" [skeleton-proxy-new ((csh sh-modify sh 2 "" 3 "while( " 5 " )" 10 '< 11 "end") (es sh-modify sh 3 "while { " 5 " } {" 10 125) (rc sh-modify sh 3 "while( " 5 " ) {" 10 125) (sh "condition: " '(setq input (sh-feature sh-test)) > "while " str "; do" n > _ n "done" > n))] 6 (#$ . 110907) "*P\nP"])
(put 'sh-while-getopts 'no-self-insert t)
#@718 Insert a while getopts loop. See `sh-feature'.
Prompts for an options string which consists of letters for each recognized
option followed by a colon `:' if the option accepts an argument.
This is a skeleton command (see `skeleton-insert').
Normally the skeleton text is inserted at point, with nothing "inside".
If there is a highlighted region, the skeleton text is wrapped
around the region text.
A prefix argument ARG says to wrap the skeleton around the next ARG words.
A prefix argument of -1 says to wrap around region, even if not highlighted.
A prefix argument of zero says to wrap around zero words---that is, nothing.
This is a way of overriding the use of a highlighted region.
(fn &optional STR ARG)
(defalias 'sh-while-getopts #[512 "\300\301#\207" [skeleton-proxy-new ((bash sh-modify sh 18 "${0##*/}") (csh nil "while( 1 )" n > "switch( \"$1\" )" n '(setq input '("- x" . 2)) > > ("option, %s: " < "case " '(eval str) '(if (string-match " +" str) (setq v1 (substring str (match-end 0)) str (substring str 0 (match-beginning 0))) (setq v1 nil)) str 58 n > "set " v1 & " = $2" | -4 & _ n (if v1 "shift") & n "breaksw" n) < "case --:" n > "shift" n < "default:" n > "break" n resume: < < "endsw" n "shift" n < "end" n) (ksh88 sh-modify sh 16 "print" 18 "${0##*/}" 37 "OPTIND-1") (posix sh-modify sh 18 "$(basename $0)") (sh "optstring: " > "while getopts :" str " OPT; do" n > "case $OPT in" n '(setq v1 (append (vconcat str) nil)) ((prog1 (if v1 (char-to-string (car v1))) (if (eq (nth 1 v1) 58) (setq v1 (nthcdr 2 v1) v2 "\"$OPTARG\"") (setq v1 (cdr v1) v2 nil))) > str "|+" str sh-non-closing-paren n > _ v2 n > ";;" n) > "*" sh-non-closing-paren n > "echo" " \"usage: " "`basename $0`" " [+-" '(setq v1 (point)) str '(save-excursion (while (search-backward ":" v1 t) (replace-match " ARG] [+-" t t))) (if (eq (preceding-char) 45) -5) (if (and (sequencep v1) (length v1)) "] " "} ") "[--] ARGS...\"" n "exit 2" > n "esac" > n "done" > n "shift " (sh-add "OPTIND" -1) n "OPTIND=1" n))] 6 (#$ . 111862) "*P\nP"])
(put 'sh-assignment 'delete-selection t)
#@83 Remember preceding identifier for future completion and do self-insert.
(fn ARG)
(defalias 'sh-assignment #[257 "\300!\210\301 \207" [self-insert-command sh--assignment-collect] 3 (#$ . 113942) "p"])
(defalias 'sh--assignment-collect #[0 "\301`Sf\302=\205 \212\303\304!`\305\306!\210\307#\205 \310\306!)!\207" [sh-assignment-regexp sh-remember-variable 61 re-search-forward sh-feature beginning-of-line 1 t match-string] 6])
#@139 Insert self. Without prefix, following unquoted `<' inserts here document.
The document is bounded by `sh-here-document-word'.
(fn ARG)
(defalias 'sh-maybe-here-document #[257 "\300\301!!\210\211\206\f \302 \207" [self-insert-command prefix-numeric-value sh--maybe-here-document] 4 (#$ . 114379) "*P"])
(make-obsolete 'sh-maybe-here-document 'sh-electric-here-document-mode "24.3")
(defalias 'sh--maybe-here-document #[0 "\302\303\304 \"\205r \212\305u\210\306 \206 \307`!)?\205r \310\311 8?\205r \312\313\"\2032 \314\315 \245\316\"\2023 \317\320\321\317#h\322U\204B \323\324!\210c\210l\204R \325\326!\204R \327c\210\330\210\306 \203` \331\210\202U \332\261\210\212\332\320\333\317#\261)\266\202\207" [sh-here-document-word tab-width looking-back "[^<]<<[ E-]" line-beginning-position -2 sh-quoted-p sh--inside-noncommand-expression 8 syntax-ppss string-match "\\`-" make-string current-indentation 9 "" replace-regexp-in-string "['\"]" 45 delete-char -1 looking-at "[ ]" 32 1 2 10 "\\`-?[ ]*"] 8])
#@129 Non-nil if Sh-Electric-Here-Document mode is enabled.
Use the command `sh-electric-here-document-mode' to change this variable.
(defvar sh-electric-here-document-mode nil (#$ . 115402))
(make-variable-buffer-local 'sh-electric-here-document-mode)
#@320 Make << insert a here document skeleton.
If called interactively, enable Sh-Electric-Here-Document mode if ARG
is positive, and disable it if ARG is zero or negative. If called
from Lisp, also enable the mode if ARG is omitted or nil, and toggle
it if ARG is `toggle'; disable the mode otherwise.
(fn &optional ARG)
(defalias 'sh-electric-here-document-mode #[256 "\301 \302=\203
?\202 \303!\304V\211\203! \305\306\307\310\311$\210\202' \312\306\307\311#\210\313\314\2031 \315\2022 \316\"\210\317\320!\203V \301 \203F \211\301 \232\203V \321\322\323\203Q \324\202R \325#\266\210\326 \210\207" [sh-electric-here-document-mode current-message toggle prefix-numeric-value 0 add-hook post-self-insert-hook sh--maybe-here-document nil t remove-hook run-hooks sh-electric-here-document-mode-hook sh-electric-here-document-mode-on-hook sh-electric-here-document-mode-off-hook called-interactively-p any " in current buffer" message "Sh-Electric-Here-Document mode %sabled%s" "en" "dis" force-mode-line-update] 8 (#$ . 115656) (byte-code "\206 \301C\207" [current-prefix-arg toggle] 1)])
(defvar sh-electric-here-document-mode-hook nil)
(byte-code "\301\302N\204\f \303\301\302\304#\210\305\306\307\310\300!\205 \307\211%\207" [sh-electric-here-document-mode-map sh-electric-here-document-mode-hook variable-documentation put "Hook run after entering or leaving `sh-electric-here-document-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" add-minor-mode sh-electric-here-document-mode nil boundp] 6)
#@50 Move point to successive beginnings of commands.
(defalias 'sh-beginning-of-command #[0 "\301\302\303#\205 \304\224b\207" [sh-beginning-of-command re-search-backward nil t 2] 4 (#$ . 117257) nil])
#@44 Move point to successive ends of commands.
(defalias 'sh-end-of-command #[0 "\301\302\303#\205 \304\225b\207" [sh-end-of-command re-search-forward nil t 1] 4 (#$ . 117462) nil])
#@490 Insert, align, or delete end-of-line backslashes on the lines in the region.
With no argument, inserts backslashes and aligns existing backslashes.
With an argument, deletes the backslashes.
This function does not modify the last line of the region if the region ends
right at the start of the following line; it does not modify blank lines
at the start of the region. So you can put the region around an entire
shell command and conveniently use this command.
(fn FROM TO DELETE-FLAG)
(defalias 'sh-backslash-region #[771 "\212b\210\303 \211\304\223\210 \203R \2046 `W\2036 \304\210h\305U\203* \306u\210\307\304x\210iT]\262\310y\210\202 \n\246\311V\203R \312\n\306#\n\245\n_\211\313 W\203Q \211\262\210b\210`W\203e l\203e \310y\210\202U `W\203\212 \212\310y\210`W)\203\212 \204\201 \314!\210\202\204 \315 \210\310y\210\202e \211\304\211\223\266\202)\207" [sh-backslash-column sh-backslash-align tab-width make-marker nil 92 -1 " " 1 0 + window-width sh-append-backslash sh-delete-backslash] 9 (#$ . 117649) "r\nP"])
#@15
(fn COLUMN)
(defalias 'sh-append-backslash #[257 "\301\210h\302U\203 \303u\210\304 \210\305?\205 \306\"\207\305?\205! \306\"\210\307c\207" [sh-backslash-align nil 92 -1 delete-horizontal-space indent-to 1 "\\"] 4 (#$ . 118694)])
(defalias 'sh-delete-backslash #[0 "\300\210n\206 \301u\210\302\303!\205 `T\304\300x\210`|\207" [nil -1 looking-at "\\\\" " "] 3])
(provide 'sh-script)
Mini Shell