HOME

Mini Shell 1.0
Current File : //usr/share/emacs/26.1/lisp/eshell/esh-arg.elc
;ELC
;;; Compiled
;;; in Emacs version 26.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

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


(byte-code "\300\301!\210\302\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\322\323\312\305&\210\314\324\316\317\325DD\326\327\330\322\323\312\305&	\210\314\331\316\317\332DD\333\322\334\312\305&\210\314\335\316\317\336DD\337\322\340\312\305&\210\314\341\316\317\342DD\343\322\344\312\305&\207" [provide esh-arg require esh-mode 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 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 "?\205A	?\205A\304\n!\205A\305\225\211\206`\211dU\206!\211f>\262\262\205A\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 eshell-arg-load-hook #[0 "\300\207" [nil] 1] "A hook that gets run when `eshell-arg' is loaded." :version "24.1" eshell-delimiter-argument-list #[0 "\300\207" [(59 38 124 62 32 9 10)] 1] "List of characters to recognize as argument separators." (repeat character) eshell-special-chars-inside-quoting #[0 "\300\207" [(92 34)] 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] "Characters that require escaping outside of double quotes.\nWithout escaping them, they will introduce a change in the argument." (repeat character)] 10)
(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)
#@39 Initialize the argument parsing code.
(defalias 'eshell-arg-initialize #[0 "\303\304\305#\210\306\301!\210\307\306\302!\210\307\211\207" [eshell-command-map eshell-inside-quote-regexp eshell-outside-quote-regexp define-key [(meta 98)] eshell-insert-buffer-name make-local-variable nil] 4 (#$ . 3694)])
#@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 (#$ . 4005) "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 (#$ . 4219)])
(put 'eshell-escape-arg 'byte-optimizer 'byte-compile-inline-expand)
#@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 (#$ . 4481)])
#@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 (#$ . 4882)])
#@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 (#$ . 5096)])
(put 'eshell-arg-delimiter 'byte-optimizer 'byte-compile-inline-expand)
#@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\305\306\"\307\"\310\311%\312#\207" [0 mapconcat make-byte-code 257 "\302\300\301\242\"\206\303!\301\211\242T\240\210\207" vconcat vector [eshell-quote-backslash char-to-string] 4 "\n\n(fn C)" ""] 10 (#$ . 5416)])
#@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\214b\210}\210\304\211C\305\306 \304\211\304\307\310\311\312\313!\314\"\315$\216\316ed\317#\210\3202Qm?\205P`\321 `U\203B\322\323d{\"\210\211\203KC\244\210\266\202-0\211\262\203j\324\320<\203b\202h`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-byte-code 0 "\300?\205\301\302!\207" vconcat vector [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 (#$ . 5833)])
#@47 Get the next argument.  Leave point after it.
(defalias 'eshell-parse-argument #[0 "?\211\205`\304\305\211\305\3062Am?\205@\307\310!\206%\311\305f!\305u\210	\204.\211\202<\2047	C\304	C\244\210\210\2020\210\203X	\203X\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 (#$ . 6661)])
#@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 (#$ . 7314)])
(put 'eshell-operator 'byte-optimizer 'byte-compile-inline-expand)
#@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 (#$ . 7585)])
(put 'eshell-looking-at-backslash-return 'byte-optimizer 'byte-compile-inline-expand)
#@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!\202\211>\205\303\301\"\207" [eshell-special-chars-outside-quoting 92 char-to-string string] 6 (#$ . 7887)])
#@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 (#$ . 8233)])
#@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\313D\262\262\207" [nil 39 eshell-find-delimiter throw eshell-incomplete buffer-substring-no-properties string-match "''" replace-match "'" t eshell-escape-arg] 7 (#$ . 9063)])
#@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\"\2029\214\301u\210`}\210\307 \211\301=\203/\310\2022\311D\262)Tb\210)\262\207" [eshell-current-quoted nil 34 eshell-find-delimiter t throw eshell-incomplete eshell-parse-argument "" eshell-escape-arg] 6 (#$ . 9477)])
#@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 "?\205d	?\205d\303\304!\205d`\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`\"DTb\210\202`\323b\210\266\202\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 (#$ . 9892)])
#@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 (#$ . 10781)])