Gecko [ goons4good.org ]

Name	Size	Permission	Date
em-alias.elc	6.23 KB	-rw-r--r--	2023-06-07 04:13
em-banner.elc	1.69 KB	-rw-r--r--	2023-06-07 04:13
em-basic.elc	4.15 KB	-rw-r--r--	2023-06-07 04:13
em-cmpl.elc	10.67 KB	-rw-r--r--	2023-06-07 04:13
em-dirs.elc	15.43 KB	-rw-r--r--	2023-06-07 04:13
em-glob.elc	8.45 KB	-rw-r--r--	2023-06-07 04:13
em-hist.elc	28.48 KB	-rw-r--r--	2023-06-07 04:13
em-ls.elc	26.68 KB	-rw-r--r--	2023-06-07 04:13
em-pred.elc	15.36 KB	-rw-r--r--	2023-06-07 04:13
em-prompt.elc	5.37 KB	-rw-r--r--	2023-06-07 04:13
em-rebind.elc	7.36 KB	-rw-r--r--	2023-06-07 04:13
em-script.elc	4.12 KB	-rw-r--r--	2023-06-07 04:13
em-smart.elc	8.38 KB	-rw-r--r--	2023-06-07 04:13
em-term.elc	3.55 KB	-rw-r--r--	2023-06-07 04:13
em-unix.elc	37.2 KB	-rw-r--r--	2023-06-07 04:13
em-xtra.elc	4.77 KB	-rw-r--r--	2023-06-07 04:13
esh-arg.elc	10.64 KB	-rw-r--r--	2023-06-07 04:13
esh-cmd.elc	37.2 KB	-rw-r--r--	2023-06-07 04:13
esh-ext.elc	9.88 KB	-rw-r--r--	2023-06-07 04:13
esh-groups.el	7.47 KB	-rw-r--r--	2023-06-07 04:00
esh-io.elc	13.17 KB	-rw-r--r--	2023-06-07 04:13
esh-mode.elc	29.08 KB	-rw-r--r--	2023-06-07 04:13
esh-module.elc	2.65 KB	-rw-r--r--	2023-06-07 04:13
esh-opt.elc	7.32 KB	-rw-r--r--	2023-06-07 04:13
esh-proc.elc	16.24 KB	-rw-r--r--	2023-06-07 04:13
esh-util.elc	19.55 KB	-rw-r--r--	2023-06-07 04:13
esh-var.elc	14.92 KB	-rw-r--r--	2023-06-07 04:13
eshell.elc	7.25 KB	-rw-r--r--	2023-06-07 04:13

Rename

;ELC���
;;; Compiled by mockbuild@buildfarm06.corp.cloudlinux.com on Wed Jun  7 08:13:51 2023
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/eshell/esh-arg.el
;;; in Emacs version 24.3.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\304\305\306\307\310\311&\210\312\313\314\315\316\317\310\303&\210\312\320\304\321\322\323\316\317\310\303&	\210\312\324\325\326\316\327\310\303&\210\312\330\331\332\316\333\310\303&\210\312\334\335\336\316\337\310\303&\207" [provide esh-arg 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 (list 'eshell-parse-special-reference #'(lambda nil (when (and (not eshell-current-argument) (not eshell-current-quoted) (looking-at eshell-number-regexp) (eshell-arg-delimiter (match-end 0))) (goto-char (match-end 0)) (let ((str (match-string 0))) (if (> (length str) 0) (add-text-properties 0 (length str) '(number t) str)) str))) #'(lambda nil (unless eshell-inside-quote-regexp (setq eshell-inside-quote-regexp (format "[^%s]+" (apply 'string eshell-special-chars-inside-quoting)))) (unless eshell-outside-quote-regexp (setq eshell-outside-quote-regexp (format "[^%s]+" (apply 'string eshell-special-chars-outside-quoting)))) (when (looking-at (if eshell-current-quoted eshell-inside-quote-regexp eshell-outside-quote-regexp)) (goto-char (match-end 0)) (let ((str (match-string 0))) (if str (set-text-properties 0 (length str) nil str)) str))) #'(lambda nil (let (comment-p) (when (or (looking-at "[ 	]+") (and (not eshell-current-argument) (looking-at "#\$[^<'].*\\|$\$") (setq comment-p t))) (if comment-p (add-text-properties (match-beginning 0) (match-end 0) '(comment t))) (goto-char (match-end 0)) (eshell-finish-arg)))) 'eshell-parse-backslash 'eshell-parse-literal-quote 'eshell-parse-double-quote 'eshell-parse-delimiter) "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 "A hook that gets run when `eshell-arg' is loaded." :version "24.1" eshell-delimiter-argument-list '(59 38 124 62 32 9 10) "List of characters to recognize as argument separators." (repeat character) eshell-special-chars-inside-quoting '(92 34) "Characters which are still special inside double quotes." (repeat character) eshell-special-chars-outside-quoting (append eshell-delimiter-argument-list '(35 33 92 34 39)) "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 #[nil "\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 (#$ . 3738)])
#@54 Insert BUFFER-NAME into the current buffer at point.
(defalias 'eshell-insert-buffer-name #[(buffer-name) "\301\302\303#\207" [buffer-name insert-and-inherit "#<buffer " ">"] 4 (#$ . 4051) "BName of buffer: "])
#@50 Return STRING with the `escaped' property on it.
(defalias 'eshell-escape-arg #[(string) ";\203
�\301\302G\303$\210\207" [string add-text-properties 0 (escaped t)] 5 (#$ . 4269)])
(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 #[nil "\203=�	\203-�\211\203\"�\n@;\204�\n\304\n@D\240\210\nA\211\204�\305\306\307C\"D)\310\203=�@DA\211\2041�\310\211\207" [eshell-current-argument eshell-arg-listified parts eshell-current-modifiers eshell-to-flat-string eshell-convert append concat nil] 5 (#$ . 4528)])
#@46 Finish the current argument being processed.
(defalias 'eshell-finish-arg #[(&optional argument) "\203�\302\303\304\"\207" [argument eshell-current-argument throw eshell-arg-done t] 3 (#$ . 4928)])
#@98 Return non-nil if POS is an argument delimiter.
If POS is nil, the location of point is checked.
(defalias 'eshell-arg-delimiter #[(&optional pos) "\206�`\211dU\206�f	>)\207" [pos eshell-delimiter-argument-list] 3 (#$ . 5136)])
(put 'eshell-arg-delimiter 'byte-optimizer 'byte-compile-inline-expand)
#@115 Return STRING with magic characters quoted.
Magic characters are those in `eshell-special-chars-outside-quoting'.
(defalias 'eshell-quote-argument #[(string) "\302\303\304	\305#)\207" [index string 0 mapconcat #[(c) "\303	\"\206\n�\304\n!	T\207" [string index c eshell-quote-backslash char-to-string] 3] ""] 4 (#$ . 5448)])
#@146 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.
(defalias 'eshell-parse-arguments #[(beg end) "\212\214b\210	}\210\306\211C\307\310 \306\211\306\307\211\307\311\216\312ed\313#\210\314\315\215\211\203G�\316\314\n<\203@�\n\202E�\n`AE\"\210A.
\207" [beg end delim args inhibit-point-motion-hooks #1=#:modified t nil buffer-modified-p ((byte-code "\204�\301\302!\210\302\207" [#1# restore-buffer-modified-p nil] 2)) remove-text-properties (arg-begin nil arg-end nil) eshell-incomplete (byte-code "m?\205$�`\303 `U\203�\304\305d{\"\210	\203 �\n	C\244\210*\202��\207" [here arg args eshell-parse-argument error "Failed to parse argument '%s'"] 4) throw buffer-undo-list inhibit-read-only inhibit-modification-hooks deactivate-mark buffer-file-name buffer-file-truename] 6 (#$ . 5782)])
#@47 Get the next argument.  Leave point after it.
(defalias 'eshell-parse-argument #[nil "?\211\205�`\306\307\211\307\310\311\215\210	\203+�\203+�\312\n\211T\313#\210\312`S`\314#\210\315 \210.\207" [eshell-nested-argument outer arg-begin eshell-current-argument eshell-current-modifiers eshell-arg-listified t nil eshell-arg-done (byte-code "m\204-�\303\304!\206�\305\306f!\306u\210	\204�\202)�\n\204$�	C\307	C\244\210)\202��\306\207" [result eshell-current-argument eshell-arg-listified run-hook-with-args-until-success eshell-parse-argument-hook char-to-string nil t] 2) 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] 5 (#$ . 6693)])
#@74 A stub function that generates an error if a floating operator is found.
(defalias 'eshell-operator #[(&rest args) "\300\301!\207" [error "Unhandled operator in input text"] 2 (#$ . 7452)])
(put 'eshell-operator 'byte-optimizer 'byte-compile-inline-expand)
#@57 Test whether a backslash-return sequence occurs at POS.
(defalias 'eshell-looking-at-backslash-return #[(pos) "f\301=\205�TdU\206�Tf\302=\205�\303\\dU\207" [pos 92 10 2] 2 (#$ . 7715)])
(put 'eshell-looking-at-backslash-return 'byte-optimizer 'byte-compile-inline-expand)
#@131 Intelligently backslash the character occurring in STRING at INDEX.
If the character is itself a backslash, it needs no escaping.
(defalias 'eshell-quote-backslash #[(string &optional index) "	H\211\304=\203�\305\n!\202�\n>\205�\300\304\n\")\207" [string index char eshell-special-chars-outside-quoting 92 char-to-string] 4 (#$ . 8001)])
#@180 Parse a single backslash () character, which might mean escape.
It only means escape if the character immediately following is a
special character that is not itself a backslash.
(defalias 'eshell-parse-backslash #[nil "\304f\305=\205}�`\211f\305=\205$�TdU\206$�Tf\306=\205$�\307\\dU)\203-�\310\311\305\"\207`Tf\305=\204T�	\203A�`Tf\n>\202F�`Tf>\203T�\307u\210\312\313`Sf!D\207`T\211f\305=\205r�TdU\206r�Tf\306=\205r�\307\\dU)\203y�\304u\210\304u\210\314\207" [pos 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 "\\"] 4 (#$ . 8352)])
#@64 Parse a literally quoted string.  Nothing has special meaning!
(defalias 'eshell-parse-literal-quote #[nil "\302f\303=\2057�\304\303\211\"\211\204�\305\306\303\"\2026�\307`T\"Tb\210\310\311	\"\2032�\312\313\314\211	$\202!�\315	)D)\207" [end string nil 39 eshell-find-delimiter throw eshell-incomplete buffer-substring-no-properties string-match "''" replace-match "'" t eshell-escape-arg] 6 (#$ . 9018)])
#@72 Parse a double quoted string, which allows for variable interpolation.
(defalias 'eshell-parse-double-quote #[nil "\303f\304=\205:�\305\304\211\303\211\306%\306\204�\307\310\304\"\2029�\214\303u\210`}\210\311 \211\303=\2031�\312\2024�\313\nD*Tb\210*\207" [end eshell-current-quoted arg nil 34 eshell-find-delimiter t throw eshell-incomplete eshell-parse-argument "" eshell-escape-arg] 7 (#$ . 9435)])
#@62 Parse a special syntax reference, of the form '#<type arg>'.
(defalias 'eshell-parse-special-reference #[nil "?\205^�	?\205^�\306\307!\205^�`\310\225b\210\311\312!\313\230\314\315\316\"\211\204,�\317\320\315\"\202]�\fT\211\2064�`\211dU\206@�
f>*\203Y�\203L�\321\202M�\322\323`\f\"D\fTb\210\202]�\324\nb\210+\207" [eshell-current-argument eshell-current-quoted here buffer-p end pos looking-at "#<\$buffer\\|process\$\\s-" 0 match-string 1 "buffer" eshell-find-delimiter 60 62 throw eshell-incomplete get-buffer-create get-process buffer-substring-no-properties nil eshell-delimiter-argument-list] 5 (#$ . 9849)])
#@71 Parse an argument delimiter, which is essentially a command operator.
(defalias 'eshell-parse-delimiter #[nil "\302\303!\205E�\304\225	\203�\305 \202D�\305\306f\307=\203\"�T\310\202?�f\311=\2030�T\312\202?�\313f\314=\203;�\315\202?�\316\313f!Db\210!)\207" [end eshell-current-argument looking-at "[&|;\n]\\s-*" 0 eshell-finish-arg eshell-operator 38 "&&" 124 "||" nil 10 ";" char-to-string] 4 (#$ . 10479)])