Gecko [ 122.154.134.11 ]

Name	Size	Permission
ada-mode.elc	107.46 KB	-rw-r--r--
ada-prj.elc	17.96 KB	-rw-r--r--
ada-stmt.elc	36.03 KB	-rw-r--r--
ada-xref.elc	54.99 KB	-rw-r--r--
antlr-mode.elc	77.63 KB	-rw-r--r--
asm-mode.elc	6.08 KB	-rw-r--r--
autoconf.elc	3.37 KB	-rw-r--r--
bug-reference.elc	5.83 KB	-rw-r--r--
cap-words.elc	3.54 KB	-rw-r--r--
cc-align.elc	35.43 KB	-rw-r--r--
cc-awk.elc	20.23 KB	-rw-r--r--
cc-bytecomp.elc	10.45 KB	-rw-r--r--
cc-cmds.elc	92.26 KB	-rw-r--r--
cc-compat.elc	2.97 KB	-rw-r--r--
cc-defs.elc	46.7 KB	-rw-r--r--
cc-engine.elc	143.05 KB	-rw-r--r--
cc-fonts.elc	140.72 KB	-rw-r--r--
cc-langs.elc	70.29 KB	-rw-r--r--
cc-menus.elc	7.32 KB	-rw-r--r--
cc-mode.elc	144.75 KB	-rw-r--r--
cc-styles.elc	16.11 KB	-rw-r--r--
cc-subword.elc	6.99 KB	-rw-r--r--
cc-vars.elc	71.07 KB	-rw-r--r--
cfengine.elc	8.09 KB	-rw-r--r--
cmacexp.elc	6.58 KB	-rw-r--r--
compile.elc	69.45 KB	-rw-r--r--
cperl-mode.elc	215.39 KB	-rw-r--r--
cpp.elc	21.52 KB	-rw-r--r--
cwarn.elc	12.8 KB	-rw-r--r--
dcl-mode.elc	49.31 KB	-rw-r--r--
delphi.elc	50.03 KB	-rw-r--r--
ebnf-abn.elc	7.39 KB	-rw-r--r--
ebnf-bnf.elc	7.99 KB	-rw-r--r--
ebnf-dtd.elc	13.82 KB	-rw-r--r--
ebnf-ebx.elc	8.77 KB	-rw-r--r--
ebnf-iso.elc	8.14 KB	-rw-r--r--
ebnf-otz.elc	8.51 KB	-rw-r--r--
ebnf-yac.elc	7.53 KB	-rw-r--r--
ebnf2ps.elc	121.25 KB	-rw-r--r--
ebrowse.elc	202.93 KB	-rw-r--r--
etags.elc	54.14 KB	-rw-r--r--
executable.elc	7.6 KB	-rw-r--r--
f90.elc	82.59 KB	-rw-r--r--
flymake.elc	61.25 KB	-rw-r--r--
fortran.elc	60.13 KB	-rw-r--r--
gdb-ui.elc	138.61 KB	-rw-r--r--
glasses.elc	10.15 KB	-rw-r--r--
grep.elc	27.75 KB	-rw-r--r--
gud.elc	93.94 KB	-rw-r--r--
hideif.elc	26.67 KB	-rw-r--r--
hideshow.elc	24.54 KB	-rw-r--r--
icon.elc	16.23 KB	-rw-r--r--
idlw-complete-structtag.elc	4.75 KB	-rw-r--r--
idlw-help.elc	35.31 KB	-rw-r--r--
idlw-shell.elc	134.39 KB	-rw-r--r--
idlw-toolbar.elc	28.34 KB	-rw-r--r--
idlwave.elc	254.7 KB	-rw-r--r--
inf-lisp.elc	18.43 KB	-rw-r--r--
ld-script.elc	4.91 KB	-rw-r--r--
m4-mode.elc	4.91 KB	-rw-r--r--
make-mode.elc	58.79 KB	-rw-r--r--
mantemp.elc	3.77 KB	-rw-r--r--
meta-mode.elc	27.42 KB	-rw-r--r--
mixal-mode.elc	35.32 KB	-rw-r--r--
modula2.elc	14.23 KB	-rw-r--r--
octave-inf.elc	11.87 KB	-rw-r--r--
octave-mod.elc	44.6 KB	-rw-r--r--
pascal.elc	40.31 KB	-rw-r--r--
perl-mode.elc	22.42 KB	-rw-r--r--
prolog.elc	12.7 KB	-rw-r--r--
ps-mode.elc	33.38 KB	-rw-r--r--
python.elc	86.23 KB	-rw-r--r--
ruby-mode.elc	34.59 KB	-rw-r--r--
scheme.elc	15.94 KB	-rw-r--r--
sh-script.elc	94.73 KB	-rw-r--r--
simula.elc	44.81 KB	-rw-r--r--
sql.elc	101.34 KB	-rw-r--r--
sym-comp.elc	7.15 KB	-rw-r--r--
tcl.elc	38.58 KB	-rw-r--r--
vera-mode.elc	44.5 KB	-rw-r--r--
verilog-mode.elc	331.76 KB	-rw-r--r--
vhdl-mode.elc	510.47 KB	-rw-r--r--
which-func.elc	9.72 KB	-rw-r--r--
xscheme.elc	37.76 KB	-rw-r--r--

Code Editor : sh-script.elc

;ELC���
;;; Compiled by mockbuild@c6b8.bsys.dev.centos.org on Thu Feb 19 13:05:11 2015
;;; from file /builddir/build/BUILD/emacs-23.1/lisp/progmodes/sh-script.el
;;; in Emacs version 23.1.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.
(if (and (boundp 'emacs-version)
	 (< (aref emacs-version (1- (length emacs-version))) ?A)
	 (or (and (boundp 'epoch::version) epoch::version)
	     (string-lessp emacs-version "19.29")))
    (error "`sh-script.el' was compiled for Emacs 19.29 or later"))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(byte-code "\300\301!\210\302\303\304\305\306\307%\210\302\310\304\311\312\313\306\303\314\315&	\207" [require executable 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-"] 10)
#@662 Alist showing the direct ancestor of various shells.
This is the basis for `sh-feature'.  See also `sh-alias-alist'.
By default we have the following three hierarchies:

csh		C Shell
  jcsh		C Shell with Job Control
  tcsh		TENEX C Shell
    itcsh	Ian's TENEX C Shell
rc		Plan 9 Shell
  es		Extensible Shell
sh		Bourne Shell
  ash		Almquist Shell
  jsh		Bourne Shell with Job Control
    bash	GNU Bourne Again Shell
    ksh88	Korn Shell '88
      ksh	Korn Shell '93
	dtksh	CDE Desktop Korn Shell
      pdksh	Public Domain Korn Shell
      wksh	Window Korn Shell
      zsh	Z Shell
  oash		SCO OA (curses) Shell
  posix		IEEE 1003.2 Shell Standard
  wsh		? Shell
(custom-declare-variable 'sh-ancestor-alist ''((ash . sh) (bash . jsh) (bash2 . jsh) (dtksh . ksh) (es . rc) (itcsh . tcsh) (jcsh . csh) (jsh . sh) (ksh . ksh88) (ksh88 . jsh) (oash . sh) (pdksh . ksh88) (posix . sh) (tcsh . csh) (wksh . ksh88) (wsh . sh) (zsh . ksh88) (rpm . sh)) '(#$ . 939) :type '(repeat (cons symbol symbol)) :group 'sh-script)
#@157 Alist for transforming shell names to what they really are.
Use this where the name of the executable doesn't correspond to the type of
shell it really is.
(custom-declare-variable 'sh-alias-alist '(append (if (eq system-type 'gnu/linux) '((csh . tcsh) (ksh . pdksh))) '((ksh . ksh88) (bash2 . bash) (sh5 . sh))) '(#$ . 1957) :type '(repeat (cons symbol symbol)) :group 'sh-script)
#@58 The executable file name for the shell being programmed.
(custom-declare-variable 'sh-shell-file '(or (and (memq system-type '(ms-dos windows-nt)) (let* ((shell (getenv "SHELL")) (shell-base (and shell (file-name-nondirectory shell)))) (if (or (null shell) (member (downcase shell-base) '("command.com" "cmd.exe" "4dos.com" "ndos.com" "cmdproxy.exe"))) "/bin/sh" (file-name-sans-extension (downcase shell))))) (getenv "SHELL") "/bin/sh") '(#$ . 2345) :type 'string :group 'sh-script)
#@65 Single argument string for the magic number.  See `sh-feature'.
(custom-declare-variable 'sh-shell-arg ''((bash) (csh . "-f") (pdksh) (ksh88) (rc . "-p") (wksh) (zsh . "-f")) '(#$ . 2835) :type '(repeat (cons (symbol :tag "Shell") (choice (const :tag "No Arguments" nil) (string :tag "Arguments") (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@123 Alist of regular expressions for recognizing shell function definitions.
See `sh-feature' and `imenu-generic-expression'.
(custom-declare-variable 'sh-imenu-generic-expression '`((sh (nil "^\\s-*\$function\\s-+\$?\$[[:alpha:]_][[:alnum:]_]+\$\\s-*()" 2))) '(#$ . 3191) :type '(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))) :group 'sh-script :version "20.4")
#@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 (#$ . 3686))
#@49 Non-nil if `sh-shell-variables' is initialized.
(defvar sh-shell-variables-initialized nil (#$ . 3981))
#@63 Convert a shell name SHELL to the one we should handle it as.
(defalias 'sh-canonicalize-shell #[(shell) "\302\303\"\203
�\304\211\224O9\204�\305!	\236A\206�\207" [shell sh-alias-alist string-match "\\.exe\\'" 0 intern] 3 (#$ . 4091)])
#@62 The shell being programmed.  This is set by \[sh-set-shell].
(defvar sh-shell (byte-code "\301\302!!\207" [sh-shell-file sh-canonicalize-shell file-name-nondirectory] 3) (#$ . 4343))
(byte-code "\301B\302\301!\204�\303\301\304\"\210\305\301\304\"\207" [current-load-list sh-mode-abbrev-table default-boundp set-default nil define-abbrev-table] 3)
#@72 Copy TABLE and set syntax for successive CHARs according to strings S.
(defalias 'sh-mode-syntax-table #[(table &rest list) "\302!	\203�\303	\211A@	\211A@#\210\202�\207" [table list copy-syntax-table modify-syntax-entry] 4 (#$ . 4700)])
#@91 The syntax table to use for Shell-Script mode.
This is buffer-local in every such buffer.
(defvar sh-mode-syntax-table nil (#$ . 4951))
#@38 Default syntax table for shell mode.
(defvar sh-mode-default-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="." 60 #2# 62 #2#) (#$ . 5093))
#@60 Syntax-table used in Shell-Script mode.  See `sh-feature'.
(defvar sh-mode-syntax-table-input '((sh)) (#$ . 5340))
#@35 Keymap used in Shell-Script mode.
(defvar sh-mode-map (byte-code "\302 \302 \303	\304\305#\210\303	\306\307#\210\303	\310\311#\210\303	\312\313#\210\303	\314\315#\210\303	\316\317#\210\303	\320\321#\210\303	\322\323#\210\303	\324\325#\210\303	\326\327#\210\303	\330\331#\210\303	\332\333#\210\303	\334\335#\210\303	\336\337#\210\303	\340\341#\210\303	\342\343#\210\303	\344\345#\210\303	\346\347#\210\303	\350\351#\210\303	\352\353#\210\303	\354\355#\210\303	\356\357#\210\303	\360\357#\210\303	\361\357#\210\303	\362\357#\210\303	\363\357#\210\303	\364\357#\210\303	\365\366#\210\303	\367\370#\210\303	\371\372#\210\303	\373\374#\210\303	\375\376#\210\303	\377\201@�B#\210\303\201A�\201B�#\210\303\201C�\201D�#\210\303\201E�\201F�#\210\303\201G�\201H�#\210\303\201I�\201J�#\210\303\201K�\201L�#\210\303\201M�\201N�#\210\303\201O�\201P�#\210\303\201Q�\201R�#\210\303\201S�\201T�#\210\303\201U�\201V�#\210\303\201W�\201X�#\210\303\201Y�\201Z�#\210\303\201[�\201\\�#\210\303\201]�\201^�#\210\303\201_�\201`�#\210\303\201a�\201b�#\210\303\201c�\201d�#\210\303\201e�\201f�#\210\303\201g�\201h�#\210\303\201i�\201j�#\210\303\201k�\201l�#\210	*\207" [menu-map map 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-assignment "+" sh-add "\230" sh-execute-region "" executable-interpret "<" sh-maybe-here-document "(" skeleton-pair-insert-maybe "{" "[" "'" "`" "\"" [remap complete-tag] comint-dynamic-complete [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" (lambda nil (interactive) (require 'skeleton) (setq skeleton-pair (not skeleton-pair))) :button (:toggle and (boundp 'skeleton-pair) skeleton-pair) :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.")] 5) (#$ . 5461))
#@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)) (#$ . 9739))
#@45 Functions for doing TAB dynamic completion.
(custom-declare-variable 'sh-dynamic-complete-functions ''(shell-dynamic-complete-environment-variable shell-dynamic-complete-command comint-dynamic-complete-filename) '(#$ . 9923) :type '(repeat function) :group 'sh-script)
#@157 Value of `require-final-newline' in Shell-Script mode buffers.
(SHELL . t) means use the value of `mode-require-final-newline' for SHELL.
See `sh-feature'.
(custom-declare-variable 'sh-require-final-newline ''((csh . t) (pdksh . t)) '(#$ . 10199) :type '(repeat (cons (symbol :tag "Shell") (choice (const :tag "require" t) (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@171 Regexp for the variable name and what may follow in an assignment.
First grouping matches the variable name.  This is upto and including the `='
sign.  See `sh-feature'.
(custom-declare-variable 'sh-assignment-regexp ''((csh . "\\<\$[[:alnum:]_]+\$\$\\[.+\\]\$?[ 	]*[-+*/%^]?=") (ksh88 . "\\<\$[[:alnum:]_]+\$\$\\[.+\\]\$?[ 	]*\$[-+*/%&|~^]\\|<<\\|>>\$?=") (rc . "\\<\$[[:alnum:]_*]+\$[ 	]*=") (sh . "\\<\$[[:alnum:]_]+\$=")) '(#$ . 10581) :type '(repeat (cons (symbol :tag "Shell") (choice regexp (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@57 The width for further indentation in Shell-Script mode.
(custom-declare-variable 'sh-indentation '4 '(#$ . 11151) :type 'integer :group 'sh-script)
(put 'sh-indentation 'safe-local-variable 'integerp)
#@70 Don't remember variables less than this length for completing reads.
(custom-declare-variable 'sh-remember-variable-min '3 '(#$ . 11358) :type 'integer :group 'sh-script)
#@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 (#$ . 11536))
#@126 Regexp to determine the beginning of a shell command.
The actual command starts at the beginning of the second $grouping$.
(custom-declare-variable 'sh-beginning-of-command '"\$[;({`|&]\\|\\`\\|[^\\]\n\$[ 	]*\$[/~[:alnum:]:]\$" '(#$ . 11713) :type 'regexp :group 'sh-script)
#@111 Regexp to determine the end of a shell command.
The actual command ends at the end of the first $grouping$.
(custom-declare-variable 'sh-end-of-command '"\$[/~[:alnum:]:]\$[ 	]*\$[;#)}`|&]\\|$\$" '(#$ . 12001) :type 'regexp :group 'sh-script)
#@707 Word to delimit here documents.
If the first character of this string is "-", this is taken as
part of the redirection operator, rather than part of the
word (that is, "<<-" instead of "<<").  This is a feature
used by some shells (for example Bash) to indicate that leading
tabs inside the here document should be ignored.  In this case,
Emacs indents the initial body and end of the here document with
tabs, to the same level as the start (note that apart from this
there is no support for indentation of here documents).  This
will only work correctly if `sh-basic-offset' is a multiple of
`tab-width'.

Any quote characters or leading whitespace in the word are
removed when closing the here document.
(custom-declare-variable 'sh-here-document-word '"EOF" '(#$ . 12257) :type 'string :group 'sh-script)
#@75 Initial input in Bourne if, while and until skeletons.  See `sh-feature'.
(defvar sh-test '((sh "[  ]" . 3) (ksh88 "[[  ]]" . 4)) (#$ . 13071))
#@179 List of all shell builtins for completing read and fontification.
Note that on some systems not all builtins are available or some are
implemented as aliases.  See `sh-feature'.
(custom-declare-variable 'sh-builtins ''((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") (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 "Xt[A-Z][A-Za-z]*") (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")) '(#$ . 13222) :type '(repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@270 List of keywords that may be immediately followed by a builtin or keyword.
Given some confusion between keywords and builtins depending on shell and
system, the distinction here has been based on whether they influence the
flow of control or syntax.  See `sh-feature'.
(custom-declare-variable 'sh-leading-keywords ''((bash sh-append sh "time") (csh "else") (es "true" "unwind-protect" "whatis") (rc "else") (sh "!" "do" "elif" "else" "if" "then" "trap" "type" "until" "while")) '(#$ . 15349) :type '(repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@66 List of keywords not in `sh-leading-keywords'.
See `sh-feature'.
(custom-declare-variable 'sh-other-keywords ''((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")) '(#$ . 15967) :type '(repeat (cons (symbol :tag "Shell") (choice (repeat string) (sexp :format "Evaluate: %v")))) :group 'sh-script)
#@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")) (#$ . 16783))
(byte-code "\301\302\303\304\305\306%\210\301\307\310\311\305\306%\210\312\313\314\302#\210\313B\315\313!\204%�\316\313\302\"\210\301\317\320\321\305\322\323\324&\207" [current-load-list 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 ``" put sh-heredoc-face face-alias default-boundp set-default 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 shell ("\\$(\$\\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 ("^\$\\sw+\$:" 1 font-lock-variable-name-face))) (#$ . 20545))
#@52 Subdued level highlighting for Shell Script modes.
(defvar sh-font-lock-keywords-var-1 '((sh "[ 	]in\\>")) (#$ . 21740))
#@50 Gaudy level highlighting for Shell Script modes.
(defvar sh-font-lock-keywords-var-2 nil (#$ . 21867))
(byte-code "\303B\304\305!\210\306B\307\310!\210\311B\312\313!\210\301B\314\315!\210\302B\316\317	\320Q!\210\321B\322\321!\204:�\323\321\324\"\210\325\321!\210\326B\322\326!\204M�\323\326\n\"\210\325\326!\207" [current-load-list sh-escaped-line-re sh-here-doc-open-re sh-st-punc (lambda (#1=#:defconst-tmp-var) (defconst sh-st-punc #1#)) (1) sh-st-symbol (lambda (#2=#:defconst-tmp-var) (defconst sh-st-symbol #2#)) (3) sh-here-doc-syntax (lambda (#3=#:defconst-tmp-var) (defconst sh-here-doc-syntax #3#)) (15) (lambda (#4=#:defconst-tmp-var) (defconst sh-escaped-line-re #4#)) "\$?:\\(?:.*[^\\\n]\$?\$?:\\\\\\\\\$*\\\\\n\\)*.*" (lambda (#5=#:defconst-tmp-var) (defconst sh-here-doc-open-re #5#)) "<<-?\\s-*\\\\?\$\\(?:['\"][^'\"]+['\"]\\|\\sw\$+\\)" "\$\n\$" sh-here-doc-markers default-boundp set-default nil make-variable-buffer-local sh-here-doc-re] 4)
#@103 Determine the syntax of the \n after an EOF.
If non-nil INDENTED indicates that the EOF was indented.
(defalias 'sh-font-lock-close-heredoc #[(bol eof indented) "\203\n�\306!\202�\307\310	\311\n\312\260\313\f\205�\314	\315R\212b\210\316\317
Q\320\321#)\211\203{�\322\225\203{�\f\203C�\322\224\322\225U\204{�\323\324\224!\204{�\212b\210\325\326!\327\330!\210\327 \331#\203n�\324\224b\203n�\323`!\204T�`U)\203{�!\202\237�\206\207�\212\327\320\321#)?\205\237�\332\"\"\" \333\334\"\321\"\335R#\320,\207" [eof eof-re sh-escaped-line-re sre indented ere regexp-quote "" "<<\$-?\$\\s-*['\"\\]?" "['\"]?\$[ 	|;&)<>]" "\$?\\s|" "^" "[ 	]*" "\n" re-search-backward "\\|" nil t 1 sh-in-comment-or-string 0 line-beginning-position 2 re-search-forward "<<" move delete "\\|^\$[ 	]*\$" regexp-opt "\$\n\$" bol start sh-here-doc-open-re sh-here-doc-syntax sh-here-doc-markers sh-here-doc-re] 6 (#$ . 22856)])
#@307 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.
(defalias 'sh-font-lock-open-heredoc #[(start string) "Sf\306>\206�\307!?\205Z�\310\311\312	#\211\235\204(�\nB\f\313\314\315\"\316R)\212\317`S!)\3208\203@�\321`S`\322\323$\210\3248\204P�\325`\"\326V\203W�\321`\327\315$\210)\207" [start string str sh-here-doc-markers sh-here-doc-open-re sh-here-doc-re (60 62) sh-in-comment-or-string replace-regexp-in-string "['\"]" "" "\\|^\$[ 	]*\$" regexp-opt t "\$\n\$" syntax-ppss 4 put-text-property syntax-table (12) 5 count-lines 1 font-lock-multiline ppss sh-here-doc-syntax] 6 (#$ . 23797)])
#@30 Search for a heredoc marker.
(defalias 'sh-font-lock-here-doc #[(limit) "\302	\303#\207" [sh-here-doc-re limit re-search-forward t] 4 (#$ . 24668)])
#@140 Search for a subshell embedded in a string.
Find all the unescaped " characters within said subshell, remembering that
subshells can nest.
(defalias 'sh-font-lock-quoted-subshell #[(limit) "\304\305\306#\205\363�\307\310 8\311=\205\363�`f`Sf\312=\203�\313\202 �\314\315\n\203\361�\316w\210`W\203\361�\317f\320=\203I�\n\321=\204\353�\322u\210\323w\210\202\353�\317f\324=\203V�\322u\210\202\353�\317f\311=\203\201�\n\321=\203l�	\211A@\202r�\n	B\321\n\203\353�\325``T\326\327$\210\202\353�\317f\312=\203\240�\n\313=\203\227�	\211A@\202\353�\n	B\313\202\353�\317f\330=\203\273�`Tf\331=\203\353�\322u\210\n	B\314\202\353�\317f\331=\203\321�\n\321=\204\353�\n	B\314\202\353�\317f\332=\203\347�\n\321=\204\353�	\211A@\202\353�\333\334!\210\322u\210\202$�+\306\207" [limit states state char re-search-forward "\"\$?:\\(?:.\\|\n\$*?[^\\]\$?:\\\\\\\\\$*\\)??\$\\$(\\|`\$" t 3 syntax-ppss 34 96 backquote code (double-quote) "^'\\\\\"`$()" nil 39 double-quote 1 "^'" 92 put-text-property syntax-table (1) 36 40 41 error "Internal error in sh-font-lock-quoted-subshell"] 5 (#$ . 24825)])
(defalias 'sh-is-quoted-p #[(pos) "Sf\301=\205
�\302S!?\207" [pos 92 sh-is-quoted-p] 2])
(defalias 'sh-font-lock-paren #[(start) "\212b\210\302d[!\210\303\304!\305U\203	�\306\307x\305U\203	�\310`S!\203'�`\311Zb\204	�`Sf\312>\2036�\307\313\314\217\204	�\302d[!\210\310`!\203G�\315u\210\2026�`Sf\316=\203U�\315u\210\202�\317u\210\320 V\203g�\321`T\322\323$\210\324\325!\205n�	)\207" [start sh-st-punc forward-comment skip-syntax-backward "w_" 0 "?[]*@/\\" nil sh-is-quoted-p 2 (34 39) (byte-code "\300\301!\210\302\207" [backward-sexp 1 t] 2) ((error)) -1 124 -2 line-end-position put-text-property font-lock-multiline t looking-at ";;\\|in"] 5])
(defalias 'sh-font-lock-backslash-quote #[nil "\212\301\302\303\224!8)\304=\205�\207" [sh-st-punc 3 syntax-ppss 0 39] 3])
(defalias 'sh-font-lock-flush-syntax-ppss-cache #[(limit) "\301`!\210b\210\302\207" [limit syntax-ppss-flush-cache nil] 2])
(byte-code "\302B\303\304\305	E\306\307\310\305	E\311BBBB!\207" [current-load-list sh-st-symbol sh-font-lock-syntactic-keywords (lambda (#1=#:defconst-tmp-var) (defconst sh-font-lock-syntactic-keywords #1#)) "[^|&;<>()`\\\"' 	\n]\$#+\$" 1 ("\$\\\\\$'" (1 (sh-font-lock-backslash-quote))) (sh-font-lock-flush-syntax-ppss-cache) "\\$\$[?@]\$" ((sh-font-lock-here-doc (2 (sh-font-lock-open-heredoc (match-beginning 0) (match-string 1)) nil t) (5 (sh-font-lock-close-heredoc (match-beginning 0) (match-string 4) (and (match-beginning 3) (/= (match-beginning 3) (match-end 3)))) nil t)) (")" 0 (sh-font-lock-paren (match-beginning 0))) (sh-font-lock-quoted-subshell))] 7)
(defalias 'sh-font-lock-syntactic-face-function #[(state) "\3058\211\203 �\306	!\203�	\307=\203�\310\202!�\n\202!�\202!�\f)\207" [state q font-lock-string-face sh-heredoc-face font-lock-comment-face 3 characterp 96 sh-quoted-exec] 3])
(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 no-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)
#@29 Hook run by `sh-set-shell'.
(custom-declare-variable 'sh-set-shell-hook 'nil '(#$ . 28113) :type 'hook :group 'sh-script)
#@24 Hook run by `sh-mode'.
(custom-declare-variable 'sh-mode-hook 'nil '(#$ . 28241) :type 'hook :group 'sh-script)
#@232 When `sh-guess-basic-offset' should learn `sh-basic-offset'.

nil mean:              never.
t means:               only if there seems to be an obvious value.
Anything else means:   whenever we have a "good guess" as to the value.
(custom-declare-variable 'sh-learn-basic-offset 'nil '(#$ . 28360) :type '(choice (const :tag "Never" nil) (const :tag "Only if sure" t) (const :tag "If have a good guess" usually)) :group 'sh-indentation)
#@146 Controls when  `sh-learn-buffer-indent' pops the `*indent*' buffer.
If t it is always shown.  If nil, it is shown only when there
are conflicts.
(custom-declare-variable 'sh-popup-occur-buffer 'nil '(#$ . 28804) :type '(choice (const :tag "Only when there are conflicts." nil) (const :tag "Always" t)) :group 'sh-indentation)
#@215 If non-nil, `sh-show-indent' shows the line indentation is relative to.
The position on the line is not necessarily meaningful.
In some cases the line will be the matching keyword, but this is not
always the case.
(custom-declare-variable 'sh-blink 't '(#$ . 29137) :type 'boolean :group 'sh-indentation)
#@152 The indentation of the first non-blank non-comment line.
Usually 0 meaning first column.
Can be set to a number, or to nil which means leave it as is.
(custom-declare-variable 'sh-first-lines-indent '0 '(#$ . 29449) :type '(choice (const :tag "Leave as is" nil) (integer :tag "Column number" :menu-tag "Indent to this col (0 means first col)")) :group 'sh-indentation)
#@111 The default indentation increment.
This value is used for the `+' and `-' symbols in an indentation variable.
(custom-declare-variable 'sh-basic-offset '4 '(#$ . 29825) :type 'integer :group 'sh-indentation)
(put 'sh-basic-offset 'safe-local-variable 'integerp)
#@224 How a comment line is to be indented.
nil means leave it as it is;
t  means indent it as a normal line, aligning it to previous non-blank
   non-comment line;
a number means align to that column, e.g. 0 means first column.
(custom-declare-variable 'sh-indent-comment 'nil '(#$ . 30094) :type '(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.")) :group 'sh-indentation)
#@68 Enable lots of debug messages - if function `sh-debug' is enabled.
(defvar sh-debug nil (#$ . 30594))
(defalias 'sh-debug '(macro . #[(&rest args) "\300\207" [nil] 1]))
(byte-code "\301B\302\303!\207" [current-load-list sh-symbol-list (lambda (#1=#:defconst-tmp-var) (defconst sh-symbol-list #1#)) ((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"))] 2)
#@64 How much to indent an `else' relative to its `if'.  Usually 0.
(custom-declare-variable 'sh-indent-for-else '0 '(#$ . 31368) :type (byte-code "\301\302\303BBB\207" [sh-symbol-list choice (integer :menu-tag "A number (positive=>indent right)" :tag "A number") (const :tag "--")] 4) :group 'sh-indentation)
(byte-code "\302B\303\304\305	\"!\207" [current-load-list sh-symbol-list sh-number-or-symbol-list (lambda (#1=#:defconst-tmp-var) (defconst sh-number-or-symbol-list #1#)) append ((integer :menu-tag "A number (positive=>indent right)" :tag "A number") (const :tag "--"))] 4)
#@61 How much to indent a `fi' relative to its `if'.  Usually 0.
(custom-declare-variable 'sh-indent-for-fi '0 '(#$ . 31956) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@72 How much to indent a `done' relative to its matching stmt.  Usually 0.
(custom-declare-variable 'sh-indent-for-done '0 '(#$ . 32152) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@59 How much to indent a statement after an `else' statement.
(custom-declare-variable 'sh-indent-after-else ''+ '(#$ . 32361) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@188 How much to indent a statement after an `if' statement.
This includes lines after `else' and `elif' statements, too, but
does not affect the `else', `elif' or `fi' statements themselves.
(custom-declare-variable 'sh-indent-after-if ''+ '(#$ . 32561) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@51 How much to indent a `then' relative to its `if'.
(custom-declare-variable 'sh-indent-for-then '0 '(#$ . 32887) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@158 How much to indent a `do' statement.
This is relative to the statement before the `do', typically a
`while', `until', `for', `repeat' or `select' statement.
(custom-declare-variable 'sh-indent-for-do '0 '(#$ . 33076) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@229 How much to indent a line after a `do' statement.
This is used when the `do' is the first word of the line.
This is relative to the statement before the `do', typically a
`while', `until', `for', `repeat' or `select' statement.
(custom-declare-variable 'sh-indent-after-do ''+ '(#$ . 33370) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@257 How much to indent a statement after a loop construct.

This variable is used when the keyword `do' is on the same line as the
loop statement (e.g., `until', `while' or `for').
If the `do' is on a line by itself, then `sh-indent-after-do' is used instead.
(custom-declare-variable 'sh-indent-after-loop-construct ''+ '(#$ . 33738) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@250 How much to indent a statement after a `done' keyword.
Normally this is 0, which aligns the `done' to the matching
looping construct line.
Setting it non-zero allows you to have the `do' statement on a line
by itself and align the done under to do.
(custom-declare-variable 'sh-indent-after-done '0 '(#$ . 34146) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@106 How much to indent a case label statement.
This is relative to the line containing the `case' statement.
(custom-declare-variable 'sh-indent-for-case-label ''+ '(#$ . 34536) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@115 How much to indent statements after the case label.
This is relative to the line containing the `case' statement.
(custom-declare-variable 'sh-indent-for-case-alt ''++ '(#$ . 34787) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@50 How much to indent for a continuation statement.
(custom-declare-variable 'sh-indent-for-continuation ''+ '(#$ . 35045) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@143 How much to indent after a line with an opening parenthesis or brace.
For an open paren after a function, `sh-indent-after-function' is used.
(custom-declare-variable 'sh-indent-after-open ''+ '(#$ . 35242) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@43 How much to indent after a function line.
(custom-declare-variable 'sh-indent-after-function ''+ '(#$ . 35525) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@101 How much to indent a `case' statement relative to the `switch' statement.
This is for the rc shell.
(custom-declare-variable 'sh-indent-after-switch ''+ '(#$ . 35713) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@92 How much to indent a statement relative to the `case' statement.
This is for the rc shell.
(custom-declare-variable 'sh-indent-after-case ''+ '(#$ . 35956) :type (cons 'choice sh-number-or-symbol-list) :group 'sh-indentation)
#@60 Column in which `sh-backslash-region' inserts backslashes.
(custom-declare-variable 'sh-backslash-column '48 '(#$ . 36188) :type 'integer :group 'sh)
#@59 If non-nil, `sh-backslash-region' will align backslashes.
(custom-declare-variable 'sh-backslash-align 't '(#$ . 36344) :type 'boolean :group 'sh)
#@139 Make a regexp which matches WORD as a word.
This specifically excludes an occurrence of WORD followed by
punctuation characters like '-'.
(defalias 'sh-mkword-regexpr #[(word) "\301P\207" [word "\$[^-[:alnum:]_]\\|$\$"] 2 (#$ . 36498)])
(byte-code "\301B\302\303\304!!\207" [current-load-list sh-re-done (lambda (#1=#:defconst-tmp-var) (defconst sh-re-done #1#)) sh-mkword-regexpr "done"] 3)
#@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")) (#$ . 36901))
#@57 Shell types that shell indenting can do something with.
(defconst sh-indent-supported '((sh . t) (csh) (rc . t)) (#$ . 37156))
#@72 Non-nil if we support indentation for the current buffer's shell type.
(defvar sh-indent-supported-here nil (#$ . 37289))
#@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) (#$ . 37418))
#@341 *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 (#$ . -38036))
#@2494 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.

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.
\[newline-and-indent]	 Delete unquoted space and indent new line same as this one.
\[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-maybe-here-document]	 Without prefix, following an unquoted < inserts here document.
{, (, [, ', ", `
	Unless quoted with \, insert the pairs {}, (), [], or '', "", ``.

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 #[nil "\306 \210\307\310\311\n!\210\312\305!\210\312\313!\210\312\314!\210\312\315!\210\312\316!\210\312\317!\210\312\320!\210\312\321!\210\312\322!\210\312\323!\210\312\324!\210\312\325!\210\312\326!\210\312\327!\210\312\330!\210\312\331!\210\312\332!\210\312\333!\210\312\334!\210\312\335!\210\312\304!\210\336@\337P\211\f\340
\341ABC\342\343D\344\345\346\347E\350\351\343\312\352!\210\353*\312\354!\210\351,\355\212eb\210\356\357!)\203\265�\360\361!\202\nF\204\277�\202\n\362\363F\"\203\313�\364\202\n\362\365F\"\203\327�\366\202\n\362\367F\"\203\343�\370\202\n\362\371F\"\203\357�\372\202\n\362\373F\"\203\373�\374\202\n\375F!\376\232\203\366\202\n\343\211#\210\377\201G�!\207" [major-mode mode-name sh-mode-map sh-skeleton-pair-default-alist skeleton-pair-default-alist skeleton-end-hook kill-all-local-variables sh-mode "Shell-script" use-local-map make-local-variable paragraph-start paragraph-separate comment-start comment-start-skip require-final-newline sh-header-marker sh-shell-file sh-shell skeleton-pair-alist skeleton-pair-filter-function comint-dynamic-complete-functions comint-prompt-regexp font-lock-defaults skeleton-filter-function skeleton-newline-indent-rigidly sh-shell-variables sh-shell-variables-initialized imenu-generic-expression sh-indent-supported-here #[nil "l\206�\300 \206�\301 \207" [newline indent-relative] 1] "\\|$" "# " "#+[	 ]*" "^[ 	]*" nil ((sh-font-lock-keywords sh-font-lock-keywords-1 sh-font-lock-keywords-2) nil nil ((47 . "w") (126 . "w") (46 . "w") (45 . "w") (95 . "w")) nil (font-lock-syntactic-keywords . sh-font-lock-syntactic-keywords) (font-lock-syntactic-face-function . sh-font-lock-syntactic-face-function)) ((96 _ 96)) sh-quoted-p ((< '(- (min sh-indentation (current-column))))) sh-feature t defun-prompt-regexp "^\$function[ 	]\\|[[:alnum:]]+[ 	]+()[ 	]+\$" parse-sexp-ignore-comments sh-set-shell looking-at "#![ 	]?\$[^ 	\n]*/bin/env[ 	]\$?\$[^ 	\n]+\$" match-string 2 string-match "\\.m?spec\\'" "rpm" "[.]sh\\>" "sh" "[.]bash\\>" "bash" "[.]ksh\\>" "ksh" "[.]csh\\>" "csh" file-name-nondirectory ".profile" run-mode-hooks page-delimiter sh-mode-abbrev-table local-abbrev-table sh-dynamic-complete-functions imenu-case-fold-search skeleton-further-elements buffer-file-name sh-mode-hook] 5 (#$ . 38428) nil])
(defalias 'shell-script-mode 'sh-mode)
#@118 Function to get simple fontification based on `sh-font-lock-keywords'.
This adds rules for comments and assignments.
(defalias 'sh-font-lock-keywords #[(&optional keywords) "\302\302	!;\205\n�\303\"\207" [sh-font-lock-keywords-var sh-assignment-regexp sh-feature #[(list) "\304!\305B\306	\n#B\207" [sh-assignment-regexp keywords list executable-font-lock-keywords sh-feature (1 font-lock-variable-name-face) append] 5]] 4 (#$ . 43325)])
#@58 Function to get better fontification including keywords.
(defalias 'sh-font-lock-keywords-1 #[(&optional builtins) "\306\307\310!\311\"\312\307\313\310!\310	!\"\311\"R\314\313\205+�\n\312\307\310\f!\311\"\315R\316B\310
!B\n\317P\320BC\310!#!)\207" [sh-leading-keywords sh-other-keywords keywords builtins sh-builtins sh-font-lock-keywords-var-2 "\$[;(){}`|&]\\|^\$[ 	]*\$\\(" 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) sh-font-lock-keywords-var-1] 8 (#$ . 43771)])
#@71 Function to get better fontification including keywords and builtins.
(defalias 'sh-font-lock-keywords-2 #[nil "\300\301!\207" [sh-font-lock-keywords-1 t] 2 (#$ . 44377)])
#@58 A buffer-local regexp to match opening keyword for done.
(defvar sh-regexp-for-done nil (#$ . 44555))
#@69 A buffer-local, since it is shell-type dependent, list of keywords.
(defvar sh-kw-alist nil (#$ . 44663))
(byte-code "\301B\302\303!\207" [current-load-list sh-kw (lambda (#1=#:defconst-tmp-var) (defconst sh-kw #1#)) ((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) ("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)))] 2)
#@561 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.
(defalias 'sh-set-shell #[(shell &optional no-query-flag insert-flag) "\306\307\"\203
�\310\211\224O\311\312!!\211\n\236A\206�	\203*�\313\314\f!
$(\314)!\211*\315=\203:�+,)\316\317	\"-\320\211./\3140!1\321\322!\210\3142!\211*\203c�\323\322*\"\202e�3)\324!\210\3144!\3205\2116\203\215�6@5\3255!\2106A\2116\204z�*\321\326!\210\3147!\2118\203\341�\327\330	\"\210\321\331!\210\315\321\332!\210\3149!\314:!\211;\203\311�\321\333!\210\334\335;\315\"!)\327\336!\210\337 \203\331�\340 \210\327\341	\"\210\202\350�\327\342!\210\343<\203\366�\320$\344 \210\345 \210\346\347!\207" [shell sh-shell sh-alias-alist insert-flag sh-shell-arg no-query-flag string-match "\\.exe\\'" 0 intern file-name-nondirectory executable-set-magic sh-feature t format "[%s]" nil make-local-variable sh-mode-syntax-table apply set-syntax-table sh-remember-variable indent-line-function message "Setting up indent for shell type %s" parse-sexp-lookup-properties sh-kw-alist sh-regexp-for-done sh-mkword-regexpr regexp-opt "setting up indent stuff" 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-fontify-buffer run-hooks sh-set-shell-hook sh-shell-file sh-require-final-newline tem mode-require-final-newline require-final-newline mode-line-process sh-shell-variables sh-shell-variables-initialized sh-imenu-generic-expression imenu-generic-expression sh-mode-syntax-table-input sh-mode-default-syntax-table sh-variables var #1=#:--cl-dolist-temp-- sh-indent-supported sh-indent-supported-here sh-kw sh-kws-for-done regexp font-lock-mode] 6 (#$ . 45680) (list (completing-read (format "Shell (default %s): " sh-shell-file) interpreter-mode-alist (lambda (x) (eq (cdr x) 'sh-mode)) nil nil nil sh-shell-file) (eq executable-query 'function) t)])
#@914 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.
(defalias 'sh-feature #[(alist &optional function) ":\203!�\211\203�	@:\203�	A\211\204�	\205�)\206x�\n\n\306\211\211\203?�\n\236\211\204?�\n\236A\211\204-�
\204G�\307\236
A\211:\203j�\f@\310>\203j�\311\f@\fA@\312!)\f\211\fAA)#
\203v�
\f!\f,\207" [alist l sh-shell orig-sh-shell val elt nil sh (sh-append sh-modify) apply sh-feature sh-ancestor-alist x function] 5 (#$ . 48131)])
#@78 Return list composed of first argument (a list) physically appended to rest.
(defalias 'sh-append #[(ancestor &rest list) "	\244\207" [list ancestor] 2 (#$ . 49459)])
#@73 Modify a copy of SKELETON by replacing I1 with REPL1, I2 with REPL2 ...
(defalias 'sh-modify #[(skeleton &rest list) "\302!	\203!�	@\233\206�\303\304	@\"	A@\240\210	AA\211\204�\207" [skeleton list copy-sequence error "Index %d out of bounds"] 4 (#$ . 49633)])
#@179 Indent a line for Sh mode (shell script mode).
Indent as far as preceding non-empty line, then by steps of `sh-indentation'.
Lines containing only comments are considered empty.
(defalias 'sh-basic-indent-line #[nil "\212\304 \210o\204�\305y\210\306 \210l\204�g\307=\204�i)\310\212\n\311=\203(�	\202[�i\306 \210i\211W\203?�l\203;�	\202[�\312\202[�`\304 \210`|\210l\203U�	\245T_]\202[�\245T_j\210)i\313 W\205h�\314\310w*\207" [current previous this-command sh-indentation beginning-of-line -1 back-to-indentation 35 nil newline-and-indent 0 current-indentation " 	"] 3 (#$ . 49907) nil])
#@398 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.
(defalias 'sh-execute-region #[(start end &optional flag) "\203�\306!\307V\205�\310 \211\207	\2032�\212\311	b\210\312p\f#\210\313e	\fZ\\\211
#\210	\f|*\207\313\f
\314P#\207" [flag sh-header-marker buffer-undo-list start end sh-shell-file prefix-numeric-value 0 point-marker nil append-to-buffer shell-command-on-region " -"] 5 (#$ . 50513) "r\nP"])
#@69 Make VARIABLE available for future completing reads in this buffer.
(defalias 'sh-remember-variable #[(var) "G	W\204�\303!\204�\304\n\"\204�\211B\nB\207" [var sh-remember-variable-min sh-shell-variables getenv assoc] 3 (#$ . 51275)])
#@52 Is point preceded by an odd number of backslashes?
(defalias 'sh-quoted-p #[nil "\212\300\301x)\302\246\303=\207" ["\\\\" nil 2 -1] 2 (#$ . 51524)])
#@117 *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 #[nil "?\205�\301\302!\207" [sh-indent-supported-here error "This buffer's shell does not support indentation through Emacs"] 2 (#$ . -51680)])
#@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 #[nil "\301\302\"\210\303\304!\207" [sh-var-list mapc make-local-variable message "Indentation variables are now local."] 3 (#$ . 51983) 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 #[nil "\302\303\"\210	\205
�\304\305\"\207" [sh-var-list sh-make-vars-local mapc kill-local-variable mapcar make-local-variable] 3 (#$ . 52441) nil])
(byte-code "\301B\302\303!\207" [current-load-list sh-special-keywords (lambda (#1=#:defconst-tmp-var) (defconst sh-special-keywords #1#)) "then\\|do"] 2)
#@72 Construct a string for `sh-read-variable' when changing variable VAR .
(defalias 'sh-help-string-for-variable #[(var) "\305\306\"\307\310>\204�\311\312\313\314\f\315##\n	P*\207" [var msg2 msg 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 #[(x) "GS8\207" [x] 2] "\n	"] 7 (#$ . 52929)])
#@48 Read a new value for indentation variable VAR.
(defalias 'sh-read-variable #[(var) "\304\305DD\306\307\310\311\312!#\310\313J\"\306\314$\211*\207" [var val 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] 7 (#$ . 53617) "*variable? "])
#@52 Return non-nil if START is in a comment or string.
(defalias 'sh-in-comment-or-string #[(start) "\212\302!\303	8\206�\304	8*\207" [start state syntax-ppss 3 4] 2 (#$ . 53986)])
#@67 Go to the matching if for a fi.
This handles nested if..fi pairs.
(defalias 'sh-goto-matching-if #[nil "\301\302\303\304#\211\205\f�b)\207" [found sh-find-prev-matching "\\bif\\b" "\\bfi\\b" 1] 5 (#$ . 54172)])
(defalias 'sh-handle-prev-if #[nil "\300C\207" [(+ sh-indent-after-if)] 1])
(defalias 'sh-handle-this-else #[nil "\300 \205�\301\302D\207" [sh-goto-matching-if "aligned to if" (+ sh-indent-for-else)] 2])
(defalias 'sh-handle-prev-else #[nil "\300 \205�\301C\207" [sh-goto-matching-if (+ sh-indent-after-if)] 1])
(defalias 'sh-handle-this-fi #[nil "\300 \205�\301\302D\207" [sh-goto-matching-if "aligned to if" (+ sh-indent-for-fi)] 2])
(defalias 'sh-handle-prev-fi #[nil "\300 \210\301\207" [sh-goto-matching-if nil] 1])
(defalias 'sh-handle-this-then #[nil "\301 \211\205	�\302C)\207" [p sh-goto-matching-if (+ sh-indent-for-then)] 2])
(defalias 'sh-handle-prev-then #[nil "\301 \211\205	�\302C)\207" [p sh-goto-matching-if (+ sh-indent-after-if)] 2])
(defalias 'sh-handle-prev-open #[nil "\212\301 \211\203�b\210\302\303!\204�\302\304!\203�\305C\202�\306C*\207" [x sh-prev-stmt looking-at "function\\b" "\\s-*\\S-+\\s-*()" (+ sh-indent-after-function) (+ sh-indent-after-open)] 3])
(defalias 'sh-handle-this-close #[nil "\300u\210\301\302!\205�\303C\207" [1 sh-safe-forward-sexp -1 "aligned to opening paren"] 2])
(defalias 'sh-goto-matching-case #[nil "\301\302\303\304#\211\205\f�b)\207" [found sh-find-prev-matching "\\bcase\\b" "\\besac\\b" 1] 5])
(defalias 'sh-handle-prev-case #[nil "\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 #[nil "\300 \205�\301C\207" [sh-goto-matching-case "aligned to matching case"] 1])
(defalias 'sh-handle-prev-esac #[nil "\300 \205�\301C\207" [sh-goto-matching-case "matching case"] 1])
(defalias 'sh-handle-after-case-label #[nil "\300 \205�\301C\207" [sh-goto-matching-case (+ sh-indent-for-case-alt)] 1])
(defalias 'sh-handle-prev-case-alt-end #[nil "\300 \205�\301C\207" [sh-goto-matching-case (+ sh-indent-for-case-label)] 1])
#@106 Try and do a `forward-sexp', but do not error.
Return new point if successful, nil if an error occurred.
(defalias 'sh-safe-forward-sexp #[(&optional arg) "\300\301\302\217\207" [nil (byte-code "\301\206�\302!\210`\207" [arg forward-sexp 1] 2) ((error))] 3 (#$ . 56314)])
(defalias 'sh-goto-match-for-done #[nil "\303	\304#\211\205\f�\nb)\207" [sh-regexp-for-done sh-re-done found sh-find-prev-matching 1] 5])
(defalias 'sh-handle-this-done #[nil "\300 \205�\301\302D\207" [sh-goto-match-for-done "aligned to do stmt" (+ sh-indent-for-done)] 2])
(defalias 'sh-handle-prev-done #[nil "\300 \205�\301C\207" [sh-goto-match-for-done "previous done"] 1])
(defalias 'sh-handle-this-do #[nil "\300 \205�\301C\207" [sh-goto-match-for-done (+ sh-indent-for-do)] 1])
(defalias 'sh-handle-prev-do #[nil "\214`\212\300 \210`)}\210\301 )\203�\302C\207\301 \203�\303C\207\304\305!\210\306\207" [beginning-of-line 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 #[nil "\300\301\302\303#\207" [re-search-backward "\\<switch\\>" nil t] 4 (#$ . 57353)])
(defalias 'sh-handle-this-rc-case #[nil "\300 \205�\301C\207" [sh-find-prev-switch (+ sh-indent-after-switch)] 1])
(defalias 'sh-handle-prev-rc-case #[nil "\300C\207" [(+ sh-indent-after-case)] 1])
(defalias 'sh-check-rule #[(n thing) "\305	\n\"8\306\211\203�\f *\207" [n thing sh-kw-alist val rule assoc nil] 5])
#@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 #[nil "\212\306\211\211\211\211\211\211\211,-\307 \210\310\311!\203+�o\204+�\312`S\313\"	=\2045�\312`\313\".=\203=�\314\211-\202V�\315\316!\203V�o\203L�\314\202V�\317C\320\306!\306--\204\247�\321 \203\201�\212\307 \210`\322ZSf\323>)\204t�\324C\202z�\320\306!\325C\314-\202\214�\307 \210\326\306w\210\327 ,,\203\247�\330\331,\"\211\203\247�`\332\f\"\314-`-\204\260�\320\333!	\203f\212`	b\210\314\203e\334 \211\203e\335\232\203\370�\312`S\336\"/\232\203\370�\337\330\322\"\211\203\352�\332\f\"`o\204\361�\340u\210\341\306w\210\202\274�\342\343\"\203\344\340!\211\203\274�`\332\345C\"\202\274�\342\346\"\203/\330\322\"\211\203'\332\f\"\340u\210`\202\274�\342\347\"\203>\344\340!\211\202\275�;\203]\330\322\"\211\203Q\332\f\"`n\204\274�\340u\210\202\274�\350\351\"\210\202\274�)\n\203r\332\314\nDC\"\204\205	\203\200\314	D\202\203\352\353DC\314=\203\215\306.	\207" [x prev-line-end align-point result val start nil beginning-of-line boundp font-lock-string-face get-text-property face 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 "[a-z0-9]*?" string-match "[])}]" sh-safe-forward-sexp "aligned to opening paren" "[[({]" "[\"'`]" error "Don't know what to do with %s" = sh-first-lines-indent this-kw have-result sh-heredoc-face sh-st-punc] 9 (#$ . 57873)])
#@197 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.
(defalias 'sh-get-indent-var-for-line #[(&optional info) "\306\211\211\211\211
\204�\307 
\204�\310\202q�
\203q�\204q�
@\211;\203/�\202j�<\204<�\311\312\"\210\202j�@\313=\204j�A@\2119\203e�\f\314=\203W�\f\202j�\f\203`�\315\202j�	\202j�\311\316\"\210
A\211\204�\204w�\f\204}�\n\204\203�\317-\207" [elt sym reason result var info 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"] 6 (#$ . 60322)])
#@196 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.
(defalias 'sh-prev-line #[(&optional end) "\212\303 \210\304d[!\210\204�\303 \210o\2049�\305`S\306\"	\232\2039�\307`S\306\"\211\2038�\nb\210\2035�\310\210\2028�\303 \210)\204P�\311 \203I�\312\313yY\204=�\303 \210\314\310w\210`)\207" [end sh-heredoc-face p1 beginning-of-line forward-comment get-text-property face previous-single-property-change nil sh-this-is-a-continuation 0 -1 " 	"] 4 (#$ . 61157)])
#@49 Return the address of the previous stmt or nil.
(defalias 'sh-prev-stmt #[nil "\212\306`\307\211\310\307x\210	\204t�o\204t�\203t�\311\312!\203/�\313\f!\203*�\202O�`\202O�\314\315\307x!\203:�\312u\210n\203O�\316\307!\211\203L�
b\210\202N�\307)	\204
�\317\307x\210n\203`�\320 \203n�`Sf\321=\204n�\313\322!\203
�`\211\203�	\203{�	b\210	\203\205�\323\307w\210``\nY\203\224�\324\325!\210\307\202\226�	\210	-\207" [prev found start going sh-special-keywords back t nil " 	;|&({[" sh-safe-forward-sexp -1 looking-at zerop " 	()[]{};`'" sh-prev-line " 	" sh-this-is-a-continuation 59 "\\s-*[|&]" " 	|&({[" debug "We didn't move!"] 5 (#$ . 61768) nil])
#@50 Get a shell word skipping whitespace from point.
(defalias 'sh-get-word #[nil "\301\302w\210`\303\304!\203�\305 \202�\306\302w\307V\204�`{)\207" [start "	 " nil looking-at "[\"'`]" sh-safe-forward-sexp "-_$[:alnum:]" 0] 2 (#$ . 62432) nil])
#@46 Return the previous thing this logical line.
(defalias 'sh-prev-thing #[nil "n?\205k�`\306 \203�\307\310!\202�\311 \312x\210\313\314!\203#�\315\202j�\316x\210`V\2050�`Sf\211\317>\204=�\320\n!\202i�`\310\211\321	w\210`	Y\204d�\203S�\322 \211\323!\235\203d�`\202C�
b\210\f+)*\207" [min-point start c next kwd boundary 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 sh-leading-keywords] 4 (#$ . 62684)])
#@68 Return non-nil if current line is a continuation of previous line.
(defalias 'sh-this-is-a-continuation #[nil "\212\300\301y!\205�\302\303!\205�\304\305\306\224\306\225\307\211\211\310&8?)\207" [zerop -1 looking-at ".*\\\\$" 4 parse-partial-sexp 0 nil t] 8 (#$ . 63237)])
#@88 Return first word of line from WHERE.
If AND-MOVE is non-nil then move to end of word.
(defalias 'sh-get-kw #[(&optional where and-move) "`	\203	�	b\210`\303\304w\210`{\n\204�b\210)\207" [start where and-move "^ 	\n;&|" nil] 3 (#$ . 63518)])
#@263 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.
(defalias 'sh-find-prev-matching #[(open close &optional depth) "\303\304\n\206	�\305\212\304\306\307\217\210\n\310=\205�+\207" [prev parse-sexp-ignore-comments depth t nil 1 (byte-code "\304U\204;�o\204;�\305 \211\203;�	b\210\212\306\307!\203\"�\310u\210\311\312w\210\306\n!\203.�S\2027�\306!\2037�T)\202��\312\207" [depth prev open close 0 sh-prev-stmt looking-at "\\\\\n" 2 " 	" nil] 2) ((error)) 0] 3 (#$ . 63770)])
#@181 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.
(defalias 'sh-var-value #[(var &optional ignore-error) "J\211\247\203\f�	\202x�	\304=\203�	\202x�	\204�	\202x�	\305=\203(�\n\202x�	\306=\2033�\n[\202x�	\307=\203?�\n\310_\202x�	\311=\203L�\n[\310_\202x�	\312=\203X�\n\310\245\202x�	\313=\203e�\n[\310\245\202x�\203s�\314\315	#\210\316\202x�\317\315	#)\207" [var val sh-basic-offset ignore-error t + - ++ 2 -- * / message "Don't know how to handle %s's value of %s" 0 error] 5 (#$ . 64471)])
#@135 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.
(defalias 'sh-set-var-value #[(var value &optional no-symbol) "\203�	\nL\207\nU\203�	\304L\207\n[U\203�	\305L\207\n\306_=\203)�	\307L\207\n[\306_=\2036�	\310L\207\n\306\245=\203B�	\311L\207\n[\306\245=\203O�	\312L\207	\nL\207" [no-symbol var value sh-basic-offset + - 2 ++ -- * /] 3 (#$ . 65105)])
#@119 Return the indentation for the current line.
If INFO is supplied it is used, else it is calculated from current line.
(defalias 'sh-calculate-indent #[(&optional info) "\306\211\307\211\211\211\211\204�\310 \205\350�\203\301�@\211;\204\270�\f<\203\263�@@@A@\311=\203N�\212\nb\210\312 )\202\270�\n9\203\252�\313\n!\314=\203\203�\204l�\307\211\307\202\270�\311=\203x�\306\202\270�\306\307\202\270�\315=\203\222�\\\202\270�\316=\203\241�Z\202\270�\317\320\n#\210\202\270�\317\321\n#\210\202\270�\317\322\f\"\210A\211\204\"�
\203\312�\204\316�\307\202\350�
\247\203\340�\247\203\340�
\\\202\350�\317\323
#\210\307.\207" [val var b a elt base-value 0 nil sh-get-indent-info t current-indentation sh-var-value = + - 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" ofs info] 8 (#$ . 65554)])
#@26 Indent the current line.
(defalias 'sh-indent-line #[nil "\302 d`Z\211\205\"�\303 \210\304\305w\210\306	!\210dZ`V\205\"�dZb*\207" [pos indent sh-calculate-indent beginning-of-line " 	" nil indent-line-to] 4 (#$ . 66553) nil])
#@54 Move cursor momentarily to BLINKPOS and display MSG.
(defalias 'sh-blink #[(blinkpos &optional msg) "\247\203�\212b\210	\203�\303\304	\"\210\202�\303\305!\210\306\n!)\207	\203'�\303\304	\"\207\303\305!\207" [blinkpos msg blink-matching-delay message "%s" nil sit-for] 3 (#$ . 66789)])
#@350 Show the 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.
(defalias 'sh-show-indent #[(arg) "\306 \210\307 \310!\311 \312\211	;\203 �\313\314	\211\"\210\202V�\315!\n=\2034�\316\317	\211J#\202J�\203C�\316\320	\211J\n%\202I�\316\321	\211J#
\203V�	\203V�\322	!\210\203\202�\307 \211\203z�@<\203z�@@\323=\203z�\324@A@\f\"\202~�\313\314\f\")\202\206�\313\314\f\"-\207" [info var curr-indent val msg arg sh-must-support-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 sh-blink] 7 (#$ . 67086) "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 #[nil "\305 \210\306 \307!\310\211\310	;\203�\311\312	\"\202'�	J\313	!\310\314\315\217-\207" [info var val old-val indent-val sh-must-support-indent sh-get-indent-info sh-get-indent-var-for-line nil message "Cannot set indent - %s" sh-read-variable (byte-code "	L\210\304\n!\211\203�\305\306\211J$\207\305\307\211J#\207" [var val info indent-val sh-calculate-indent message "Variable: %s  Value: %s  would indent to: %d" "Variable: %s  Value: %s  would leave line as is."] 6) ((error (byte-code "	L\210\302\303	#\210\304\305!\210\306\207" [var old-val message "Bad value for %s, restoring to previous value %s" sit-for 1 nil] 4)))] 4 (#$ . 68075) nil])
#@347 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.
(defalias 'sh-learn-line-indent #[(arg) "\306 \210\212\307 \210\310\311!)\203�\312\313!\207\314 \315!\316\211\316\211\317 	;\2035�\312\320	\"\202\224�	\321=\203g�\322U\203F�\322\202\\�\323\324!\211U\203Y�\323\202[�*\312\325	\211J#\202\224�\326	!\211\247\203\215�\324!\nZ\f\\\327	
#\210\312\325	\211J#\202\224�\330 \210\312\331	\".\207" [info var ival sval diff new-val sh-must-support-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" sh-indent-comment 0 t sh-calculate-indent "%s set to %s" sh-var-value sh-set-var-value debug "Cannot change %s" arg no-symbol curr-indent val2] 5 (#$ . 68912) "*P"])
#@51 Initialize a BUFFER to be used by `sh-mark-line'.
(defalias 'sh-mark-init #[(buffer) "r\301!q\210\302 \210\303 )\207" [buffer get-buffer-create erase-buffer occur-mode] 2 (#$ . 70045)])
#@298 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.
(defalias 'sh-mark-line #[(message point buffer &optional add-linenum occur-point) "\306 \307\310\203�\np\223\210\f\203�\311\312\313\314\"T\"\212\315
!\203,�\315
!q\210\2024�\316
!q\210\317 \210db\210`c\210\203D�`c\210\203R�\320	`\321#\210\322c\210\205l�\323	`\324\n$\210\205l�\323	\325\326$,\207" [line start m1 point add-linenum buffer make-marker nil "" format "%d: " count-lines 1 get-buffer get-buffer-create occur-mode 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 t occur-point message] 5 (#$ . 70239)])
#@63 *An abnormal hook, called with an alist of learned variables.
(defvar sh-learned-buffer-hook nil (#$ . -71178))
#@963 Learn how to indent the buffer the way it currently is.

Output in buffer "*indent*" shows any lines which have conflicting
values of a variable, and the final value of all variables learned.
This buffer is popped to 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 feature may be changed or
removed in the future.

This command can often take a long time to run.
(defalias 'sh-learn-buffer-indent #[(&optional arg) "\306 \210\212eb\210\307\310\311\307\312\307\211\211\313\307\205�\247\205�\311V\311\307@ABCDEFG\314C\311\"B\315F!\210\203P�,\316\317,\"\202V�\316\320,\"`dW\203n\nT\321\322\n\"\210\323\324!\204h\313$\325 H\326H!I\307\211JK\307\211LM\327 NI\203fI;\204f\330I\331\"\211J\247\203<\332 KNKZLJL\\M\333IM\334#\210\323\335!\204f\336IG\"\211D\203IJDA@=\204\337\316\340I\211J#`F\313\211%\210\337\316\341DA@\"\342D8F\313$\210ETEDIJ`D\241\210\202\343I\211J`ECG\"GM\247\203fM\311W\203%M[MMCW\203fBMBMHTI\210\202fI\344=\203fN\332H!U\204f\307@\203b@N=\204f\313@\202fN@.\345y\210\202V�O\203\203\316\346@
#A\337A\307F#\210@\311=\203\220\347A\202\263
\203\235\350A\313@\202\263@\247\203\255\316\351@\"A\202\263\352A\307@\337A\307F#\210\337\f\307F\313\211%\210\353B!\211\203:\204:P\313=\203\341	\247\203\341	\202\374P\203\373	\247\203\357	\202\374	G\345U\205\374	@\202\374\307\211Q\203\343\354Q\211,dECG\"G\337\316\355,\"\307F#\210\2029\337	<\2030\316\356\357\360	\361#\"\2024\316\362	\"\307F#\210)\343\344@dECG\"G@$\363 R\337\364\307F#\210\203\223\365G!\307S\211T\203\222T@\211S@SA@U\211I\354=\204\210U\247\203\210\333IU\"\210*TA\211T\204f*\365G!\307S\211V\203\303V@\211S@I\337\316\366I\211J#\342S8F#\210)VA\211V\204\240*rFq\210eb\210\316\367R\"\316\370E\211\345U\203\337\371\202\340\372\373E!\203\353\374\202\354\375$\261\210*\376\377G\"\210W\204E\311V\205	\201X�F!.\207" [arg suggested linenum specified-basic-offset initial-msg comments-always-default sh-must-support-indent 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 sh-indent-comment 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 sh-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" zerop "." ":" run-hook-with-args sh-learned-buffer-hook comment-col msg vec max previous-set-info num-diffs out-buffer learned-var-list info var sval ival diff new-val curr-indent sh-debug sh-learn-basic-offset new-value name learned-var #1=#:--cl-dolist-temp-- val #2=#:--cl-dolist-temp-- sh-popup-occur-buffer pop-to-buffer] 14 (#$ . 71297) "P"])
#@405 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.
(defalias 'sh-guess-basic-offset #[(vec) "GS\306\307	\310\"\n	W\203O�\n\nH\nH\311_\\I\210\312\n\313\246!\2033�\n\nH\n\313\245H\\I\210\n\313_	W\203H�\n\nH\n\313_H\\I\210\nT\211\202\f�\314\211\211\211\211\306\211	W\203�\nH\310U\204x�\315\n\nHBC\"\nT\211\202_�\316\317\"\320\321\315\314\"\"\312G!\203\236�\322\323!\210\202GG\306U\203\267�\322\324@@\"\210@@\202G@A\313\245V\203\324�\322\325@@\"\210@@\202G@AA@A\313_Y\203\364�\322\326@@\"\210@@\202G@AA@A\\\313\245Y\203?\310\314\f\2032
\f@A\\\211\313\245X\2032\315\f@@C\"\fA\211\204\322\327\330\331\332#\"\210\202G\322\333@@\"\210.\207" [vec max i totals p sum 1 make-vector 0 4 zerop 2 nil append sort #[(a b) "A	AV\207" [a b] 2] apply + 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" tot result x] 7 (#$ . 75322)])
#@47 A list of all known shell indentation styles.
(defvar sh-styles-alist nil (#$ . 76773))
#@273 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.
(defalias 'sh-name-style #[(name &optional confirm-overwrite) "\306\307	\"B\310\n\"\203-�
\203!�\311\312!\204!�\313\314\"\2027�\313\315\"\210\fA\241\2027�\313\316\"\210\f\nB\211*\207" [name sh-var-list sh-styles-alist style slist confirm-overwrite mapcar #[(var) "\211JB\207" [var] 2] assoc y-or-n-p "This style exists.  Overwrite it? " message "Not changing style %s" "Updating style %s" "Creating new style %s"] 4 (#$ . 76868) (list (read-from-minibuffer "Name for this style? ") (not current-prefix-arg))])
#@72 Set shell indentation values for this buffer from those in style NAME.
(defalias 'sh-load-style #[(name) "\305	\"\211\204�\306\307\"\202+�\nA\310\211\203)�\f@\211@AL\210\fA\211\204�*\310)\207" [name sh-styles-alist sl var #1=#:--cl-dolist-temp-- assoc error "sh-load-style - style %s not known" nil] 4 (#$ . 77667) (list (completing-read "Which style to use for this buffer? " sh-styles-alist nil t))])
#@97 Save all current styles in elisp to buffer BUFF.
This is always added to the end of the buffer.
(defalias 'sh-save-styles-to-buffer #[(buff) "r\302!q\210db\210\303c\210\304\305\301\306	DEp\")\207" [buff sh-styles-alist get-buffer-create "\n" pp setq quote] 5 (#$ . 78086) (list (read-from-minibuffer "Buffer to save styles in? " "*scratch*"))])
(byte-code "\302B\303\304\305\306	\307\310%!\210\311\312\313\310#\207" [current-load-list sh-st-punc sh-non-closing-paren (lambda (#1=#:defconst-tmp-var) (defconst sh-non-closing-paren #1#)) propertize ")" syntax-table rear-nonsticky t put sh-case no-self-insert] 7)
#@555 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.
(defalias 'sh-indexed-loop #[(&optional str arg) "\302\303	#\207" [str arg 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))] 4 (#$ . 80900) "*P\nP"])
#@88 Scan the buffer for variable assignments.
Add these variables to `sh-shell-variables'.
(defalias 'sh-shell-initialize-variables #[nil "\301\302\303 \"\210\212eb\210\304\305\306\307\304#\203�\310\311!\210\202\f�)\301\312\303 \"\207" [sh-shell-variables-initialized message "Scanning buffer `%s' for variable assignments..." buffer-name t search-forward "=" nil sh-assignment 0 "Scanning buffer `%s' for variable assignments...done"] 4 (#$ . 82482)])
#@547 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.
(defalias 'sh-add-completer #[(string predicate code) "rq\210	\204�\306 \210\307\310\n\"\244)\311\f\312\"\203#�\313
#\2028�\f\314=\2032�\315
#\2028�\316
#)\207" [sh-add-buffer sh-shell-variables-initialized process-environment sh-shell-variables code string sh-shell-initialize-variables mapcar #[(var) "\301\302\303\"O\211B\207" [var 0 string-match "="] 6] memql (nil) try-completion lambda test-completion all-completions predicate] 4 (#$ . 82940)])
#@69 Insert an addition of VAR and prefix DELTA for Bourne (type) shell.
(defalias 'sh-add #[(var delta) "\302\303!\304!	\305W\203�\306\202�\307\310\311	!!\302\312!\261\207" [var delta sh-feature ((bash . "$(( ") (ksh88 . "$(( ") (posix . "$(( ") (rc . "`{expr $") (sh . "`expr $") (zsh . "$[ ")) sh-remember-variable 0 " - " " + " number-to-string abs ((bash . " ))") (ksh88 . " ))") (posix . " ))") (rc . "}") (sh . "`") (zsh . " ]"))] 6 (#$ . 83959) (let ((sh-add-buffer (current-buffer))) (list (completing-read "Variable: " 'sh-add-completer) (prefix-numeric-value current-prefix-arg)))])
(put 'sh-function 'no-self-insert t)
#@553 Insert a function definition.  See `sh-feature'.

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.
(defalias 'sh-while-getopts #[(&optional str arg) "\302\303	#\207" [str arg 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))] 4 (#$ . 91594) "*P\nP"])
#@73 Remember preceding identifier for future completion and do self-insert.
(defalias 'sh-assignment #[(arg) "\302!\210\303X\205�\304\212\305\306	!`\307\303!\210\310#\205�\311\303!)!\207" [arg sh-assignment-regexp self-insert-command 1 sh-remember-variable re-search-forward sh-feature beginning-of-line t match-string] 6 (#$ . 93632) "p"])
#@129 Insert self.  Without prefix, following unquoted `<' inserts here document.
The document is bounded by `sh-here-document-word'.
(defalias 'sh-maybe-here-document #[(arg) "\306\307!!\210\206e�`\310Zf	=?\206e�\212\311u\210\312 )\206e�\313\314\n\"\203/�\315\316 \245\317\"\2020�\320\321\322\320\n#\nc\210l\204G�\323\324!\204G�\325c\210\326\210\312 \203U�\310\210\202J�\327
\261\210\212\327
\321\330\320\f#\261+\207" [arg last-command-event sh-here-document-word tab-width delim tabs self-insert-command prefix-numeric-value 2 -2 sh-quoted-p string-match "\\`-" make-string current-indentation 9 "" replace-regexp-in-string "['\"]" looking-at "[ 	]" 32 1 10 "\\`-?[ 	]*"] 6 (#$ . 93980) "*P"])
#@42 Dynamically perform completion at point.
(autoload 'comint-dynamic-complete "comint" '(#$ . 94685) t)
#@44 Dynamically complete the command at point.
(autoload 'shell-dynamic-complete-command "shell" '(#$ . 94793) t)
#@45 Dynamically complete the filename at point.
(autoload 'comint-dynamic-complete-filename "comint" '(#$ . 94909) t)
#@57 Dynamically complete the environment variable at point.
(autoload 'shell-dynamic-complete-environment-variable "shell" '(#$ . 95029) t)
#@50 Move point to successive beginnings of commands.
(defalias 'sh-beginning-of-command #[nil "\301\302\303#\205�\304\224b\207" [sh-beginning-of-command re-search-backward nil t 2] 4 (#$ . 95171) nil])
#@44 Move point to successive ends of commands.
(defalias 'sh-end-of-command #[nil "\301\302\303#\205�\304\225b\207" [sh-end-of-command re-search-forward nil t 1] 4 (#$ . 95377) nil])
#@464 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.
(defalias 'sh-backslash-region #[(from to delete-flag) "\212b\210	\306 \n\f\307\223\210
\203Z�\2048�`\fW\2038�\307\210h\310U\203-�\311u\210\312\307x\210iT]\313y\210\202�\246\314V\203Z�\315\311#\245_\211\316 W\203Y�)b\210`\nW\203m�l\203m�\313y\210\202]�`\nW\203\223�\212\313y\210`\nW)\203\223�\204\212�\317!\210\202\215�\320 \210\313y\210\202m�\n\307\211\223+\207" [from sh-backslash-column endmark column to sh-backslash-align make-marker nil 92 -1 " 	" 1 0 + window-width sh-append-backslash sh-delete-backslash delete-flag tab-width adjusted] 5 (#$ . 95565) "r\nP"])
(defalias 'sh-append-backslash #[(column) "\302\210h\303U\203�\304u\210\305 \210\306	?\205�\307\"\207\306	?\205!�\307\"\210\310c\207" [column sh-backslash-align nil 92 -1 delete-horizontal-space indent-to 1 "\\"] 3])
(defalias 'sh-delete-backslash #[nil "\300\210n\206�\301u\210\302\303!\205�`T\304\300x\210`|\207" [nil -1 looking-at "\\\\" " 	"] 3])
(provide 'sh-script)

${this.title}

Code Editor : sh-script.elc