;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\302\303\304\305\306\307\310\311&\207" [require esh-util custom-declare-group eshell-arg nil "Argument parsing involves transforming the arguments passed on the\ncommand line into equivalent Lisp forms that, when evaluated, will\nyield the values intended." :tag "Argument parsing" :group eshell] 8)
(defvar eshell-current-argument nil)
(defvar eshell-current-modifiers nil)
(defvar eshell-arg-listified nil)
(defvar eshell-nested-argument nil)
(defvar eshell-current-quoted nil)
(defvar eshell-inside-quote-regexp nil)
(defvar eshell-outside-quote-regexp nil)
(byte-code "\300\301\302\303\304DD\305\306\307\310\311\312\313&	\210\300\314\302\303\315DD\316\310\317\312\313&\210\300\320\302\303\321DD\322\310\323\312\313&\210\300\324\302\303\325DD\326\310\327\312\313&\207" [custom-declare-variable eshell-arg-load-hook funcall function #[0 "\300\207" [nil] 1 #1=""] "A hook that gets run when `eshell-arg' is loaded." :version "24.1" :type hook :group eshell-arg eshell-delimiter-argument-list #[0 "\300\207" [(59 38 124 62 32 9 10)] 1 #1#] "List of characters to recognize as argument separators." (repeat character) eshell-special-chars-inside-quoting #[0 "\300\207" [(92 34)] 1 #1#] "Characters which are still special inside double quotes." (repeat character) eshell-special-chars-outside-quoting #[0 "\301\302\"\207" [eshell-delimiter-argument-list append (35 33 92 34 39)] 3 #1#] "Characters that require escaping outside of double quotes.\nWithout escaping them, they will introduce a change in the argument." (repeat character)] 10)
#@118 Return non-nil if POS is an argument delimiter.
If POS is nil, the location of point is checked.

(fn &optional POS)
(defalias 'eshell-arg-delimiter #[256 "\211\206`\211dU\206\211f>\207" [eshell-delimiter-argument-list] 4 (#$ . 1655)])
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310\311\312\313DD\314\315\316\317\320&\207" [function-put eshell-arg-delimiter speed -1 put byte-optimizer byte-compile-inline-expand custom-declare-variable eshell-parse-argument-hook funcall function #[0 "\300\301\302\303\304\305\306\307\257\207" [eshell-parse-special-reference #[0 "?\205?	?\205?\304\n!\205?\305\225\211\206`\211dU\206!\211f>\266\202\205?\305\225b\210\306\305!\211G\305V\203<\307\305G\310$\210\211\262
\207" [eshell-current-argument eshell-current-quoted eshell-number-regexp eshell-delimiter-argument-list looking-at 0 match-string add-text-properties (number t)] 6] #[0 "\204\f\305\306\307\310	\"\"\n\204\305\306\307\310\"\"\311\f\203!\202\"\n!\205<\312\225b\210\313\312!\211\2039\314\312G\315$\210\211\262
\207" [eshell-inside-quote-regexp eshell-special-chars-inside-quoting eshell-outside-quote-regexp eshell-special-chars-outside-quoting eshell-current-quoted format "[^%s]+" apply string looking-at 0 match-string set-text-properties nil] 6] #[0 "\301\302\303!\204?\205+\302\304!\205+\305\211\262\205+\211\203%\306\307\224\307\225\310#\210\307\225b\210\311 \207" [eshell-current-argument nil looking-at "[ 	]+" "#\\([^<'].*\\|$\\)" t add-text-properties 0 (comment t) eshell-finish-arg] 5] eshell-parse-backslash eshell-parse-literal-quote eshell-parse-double-quote eshell-parse-delimiter] 8 ""] "Define how to process Eshell command line arguments.\nWhen each function on this hook is called, point will be at the\ncurrent position within the argument list.  The function should either\nreturn nil, meaning that it did no argument parsing, or it should\nreturn the result of the parse as a sexp.  It is also responsible for\nmoving the point forward to reflect the amount of input text that was\nparsed.\n\nIf no function handles the current character at point, it will be\ntreated as a literal character." :type hook :group eshell-arg] 9)
(defvar eshell-arg-mode-map (byte-code "\300 \301
\302\303#\210\207" [make-sparse-keymap define-key [3 134217826] eshell-insert-buffer-name] 5))
#@99 Non-nil if Eshell-Arg mode is enabled.
Use the command `eshell-arg-mode' to change this variable.
(defvar eshell-arg-mode nil (#$ . 4006))
(make-variable-buffer-local 'eshell-arg-mode)
#@618 Minor mode for the arg eshell module.

This is a minor mode.  If called interactively, toggle the `Eshell-Arg
mode' mode.  If the prefix argument is positive, enable the mode, and
if it is zero or negative, disable the mode.

If called from Lisp, toggle the mode if ARG is `toggle'.  Enable the
mode if ARG is nil, omitted, or is a positive number.  Disable the
mode if ARG is a negative number.

To check whether the minor mode is enabled in the current buffer,
evaluate `eshell-arg-mode'.

The mode's hook is called both when the mode is enabled and when it is
disabled.

\{eshell-arg-mode-map}

(fn &optional ARG)
(defalias 'eshell-arg-mode #[256 "\302 
\303=\203
?\202
\247\203
\304W\203\305\202\306\307\301!\2031\310\300	\"\2031\300	B\311\312\203;\313\202<\314\"\210\315\316!\203^\302 \203P\211\302 \232\203^\317\320\203Z\321\202[\322\323#\210\210\324 \210\207" [eshell-arg-mode local-minor-modes current-message toggle 1 nil t boundp delq run-hooks eshell-arg-mode-hook eshell-arg-mode-on-hook eshell-arg-mode-off-hook called-interactively-p any message "Eshell-Arg mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 6 (#$ . 4198) (byte-code "\203\n\301!\202\302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)])
(defvar eshell-arg-mode-hook nil)
(byte-code "\301\302N\204\f\303\301\302\304#\210\303\301\305\306#\210\303\301\307\310C#\210\311\312\310\310\211%\207" [eshell-arg-mode-map eshell-arg-mode-hook variable-documentation put "Hook run after entering or leaving `eshell-arg-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode eshell-arg-mode] 6)
#@39 Initialize the argument parsing code.
(defalias 'eshell-arg-initialize #[0 "\302 \210\303\300!\210\304\303\301!\210\304\211\207" [eshell-inside-quote-regexp eshell-outside-quote-regexp eshell-arg-mode make-local-variable nil] 2 (#$ . 5962)])
#@72 Insert BUFFER-NAME into the current buffer at point.

(fn BUFFER-NAME)
(defalias 'eshell-insert-buffer-name #[257 "\300\301\302#\207" [insert-and-inherit "#<buffer " ">"] 5 (#$ . 6212) "BName of buffer: "])
#@63 Return STRING with the `escaped' property on it.

(fn STRING)
(defalias 'eshell-escape-arg #[257 "\211;\203
\300\301G\302$\210\207" [add-text-properties 0 (escaped t)] 6 (#$ . 6426)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put eshell-escape-arg speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@63 If there are pending modifications to be made, make them now.
(defalias 'eshell-resolve-current-argument #[0 "\203<	\203,\211\203!\211@;\204\211\303@D\240\210\211A\262
\202	\304\305\306C\"D\210\307\n\203<\n@D\nA\211\2040\307\211\207" [eshell-current-argument eshell-arg-listified eshell-current-modifiers eshell-to-flat-string eshell-convert append concat nil] 6 (#$ . 6762)])
#@71 Finish the current ARGUMENT being processed.

(fn &optional ARGUMENT)
(defalias 'eshell-finish-arg #[256 "\211\203\211\301\302\303\"\207" [eshell-current-argument throw eshell-arg-done t] 4 (#$ . 7163)])
#@128 Return STRING with magic characters quoted.
Magic characters are those in `eshell-special-chars-outside-quoting'.

(fn STRING)
(defalias 'eshell-quote-argument #[257 "\300C\301\302\303#\304#\207" [0 mapconcat make-closure #[257 "\302\300\301\242\"\206\303
!\301\211\242T\240\210\207" [V0 V1 eshell-quote-backslash char-to-string] 4 "\n\n(fn C)"] ""] 7 (#$ . 7377)])
#@160 Parse all of the arguments at point from BEG to END.
Returns the list of arguments in their raw form.
Point is left at the end of the arguments.

(fn BEG END)
(defalias 'eshell-parse-arguments #[514 "\212\214
b\210

}\210\304\211C\305\306 \304\211\304\307\310\"\216\311ed\312#\210\3132Jm?\205I`\314 `U\203;\315\316d{\"\210\211\203D
C\244\210\266\202&0\211\262\203c\317\313<\203[\202a`AE\"\210A,\262
)\266\203*\207" [inhibit-point-motion-hooks buffer-undo-list inhibit-read-only inhibit-modification-hooks t nil buffer-modified-p make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] remove-text-properties (arg-begin nil arg-end nil) eshell-incomplete eshell-parse-argument error "Failed to parse argument `%s'" throw] 13 (#$ . 7755)])
#@47 Get the next argument.  Leave point after it.
(defalias 'eshell-parse-argument #[0 "?\211\205`\304\305\211\305\3062@m?\205?\307\310!\206%\311\305f!\305u\210	\204-\202\2046	C\304	
C\244\266\2020\210
\203W	\203W\312
\211T\313#\210\312`S`\314#\210\315 \210	,\207" [eshell-nested-argument eshell-current-argument eshell-current-modifiers eshell-arg-listified t nil eshell-arg-done run-hook-with-args-until-success eshell-parse-argument-hook char-to-string add-text-properties (arg-begin t rear-nonsticky (arg-begin arg-end)) (arg-end t rear-nonsticky (arg-end arg-begin)) eshell-resolve-current-argument] 7 (#$ . 8550)])
#@91 A stub function that generates an error if a floating operator is found.

(fn &rest ARGS)
(defalias 'eshell-operator #[128 "\300\301!\207" [error "Unhandled operator in input text"] 3 (#$ . 9196)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put eshell-operator speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@67 Test whether a backslash-return sequence occurs at POS.

(fn POS)
(defalias 'eshell-looking-at-backslash-return #[257 "\211f\300=\205\211TdU\206\211Tf\301=\205\211\302\\dU\207" [92 10 2] 3 (#$ . 9541)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put eshell-looking-at-backslash-return speed -1 put byte-optimizer byte-compile-inline-expand] 5)
#@160 Intelligently backslash the character occurring in STRING at INDEX.
If the character is itself a backslash, it needs no escaping.

(fn STRING &optional INDEX)
(defalias 'eshell-quote-backslash #[513 "

H\211\301=\203
\302
!\207\211>\205\303\301\"\207" [eshell-special-chars-outside-quoting 92 char-to-string string] 6 (#$ . 9917)])
#@390 Parse a single backslash (\) character and the character after.
If the character after the backslash is special, always ignore
the backslash and return the escaped character.

Otherwise, if the backslash is not in quoted string, the
backslash is ignored and the character after is returned.  If the
backslash is in a quoted string, the backslash and the character
after are both returned.
(defalias 'eshell-parse-backslash #[0 "\303f\304=\205a`\211f\304=\205#\211TdU\206#\211Tf\305=\205#\211\306\\dU\262
\203-\307\310\304\"\210\306u\210\203L`Sf	>\203D\311\312`Sf!D\207\313\312`Sf!P\207`Sf\n>\203\\\311\312`Sf!D\207\312`Sf!\207" [eshell-current-quoted eshell-special-chars-inside-quoting eshell-special-chars-outside-quoting nil 92 10 2 throw eshell-incomplete eshell-escape-arg char-to-string "\\"] 3 (#$ . 10261)])
#@64 Parse a literally quoted string.  Nothing has special meaning!
(defalias 'eshell-parse-literal-quote #[0 "\300f\301=\2058\302\301\211\"\211\204\303\304\301\"\2026\305`T\"
Tb\210\306\307\"\2031\310\311\312\211$\262
\202\313
D\262
\262
\207" [nil 39 eshell-find-delimiter throw eshell-incomplete buffer-substring-no-properties string-match "''" replace-match "'" t eshell-escape-arg] 7 (#$ . 11092)])
#@72 Parse a double quoted string, which allows for variable interpolation.
(defalias 'eshell-parse-double-quote #[0 "\301f\302=\205:\303\302\211\301\211\304%\304\211\204\305\306\302\"\2027\214\301u\210`
}\210\307 \211\204-\310\2020\311
D\262
)
Tb\210)\262
\207" [eshell-current-quoted nil 34 eshell-find-delimiter t throw eshell-incomplete eshell-parse-argument "" eshell-escape-arg] 6 (#$ . 11507)])
#@294 Parse a special syntax reference, of the form `#<args>'.

args           := `type' `whitespace' `arbitrary-args' | `arbitrary-args'
type           := "buffer" or "process"
arbitrary-args := any string of characters.

If the form has no `type', the syntax is parsed as if `type' were
"buffer".
(defalias 'eshell-parse-special-reference #[0 "?\205e	?\205e\303\304!\205e`\305\225b\210\306\307!\203#\306\310!\311\230\202$\312\313\314\315\"\211\2041\316\317\314\"\210\211T\211\2068`\211dU\206B\211f\n>\266\202\203^
\203O\320\202P\321\322`\"D
Tb\210\266\202\202cb\266\323\262
\207" [eshell-current-argument eshell-current-quoted eshell-delimiter-argument-list looking-at "#<\\(\\(buffer\\|process\\)\\s-\\)?" 0 match-string 1 2 "buffer" t eshell-find-delimiter 60 62 throw eshell-incomplete get-buffer-create get-process buffer-substring-no-properties nil] 7 (#$ . 11918)])
#@71 Parse an argument delimiter, which is essentially a command operator.
(defalias 'eshell-parse-delimiter #[0 "\301\302!\205G\303\225\203\304 \202E\304\305f\306=\203\"T\262\307\202@f\310=\2031T\262\311\202@\312f\313=\203<\314\202@\315\312f!Db\210!\262
\207" [eshell-current-argument looking-at "[&|;\n]\\s-*" 0 eshell-finish-arg eshell-operator 38 "&&" 124 "||" nil 10 ";" char-to-string] 5 (#$ . 12808)])
(provide 'esh-arg)