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



(byte-code "\300\301\302\303\304\305\304\306\307\310&	\210\311\312\313\314\315DD\316\317\320%\210\311\321\313\314\322DD\323\324\325\317\326&\210\311\327\313\314\330DD\331\317\332%\210\311\333\313\314\334DD\335\317\336%\210\311\337\313\314\340DD\341\317\342%\210\311\343\313\314\344DD\345\317\346%\210\311\347\313\314\350DD\351\317\352%\210\353\347!\210\311\354\313\314\355DD\356\317\357%\210\311\360\313\314\361DD\362\317\363%\210\353\360!\210\311\364\313\314\365DD\366\317\367%\210\353\364!\210\311\370\313\314\371DD\372\317\373%\210\353\370!\210\311\374\313\314\375DD\376\317\377%\210\311\201@\313\314\201ADD\201B\317\201C%\210\311\201D\313\314\201EDD\201F\317\201G%\210\353\201D!\210\311\201H\313\314\201IDD\201J\317\201G%\210\353\201H!\210\311\201K\313\314\201LDD\201M\317\201N\201O\201P&\210\311\201Q\313\314\201RDD\201S\317\201N\201O\201T&\207" [custom-declare-group proced nil "Proced mode." :group processes unix :prefix "proced-" custom-declare-variable proced-signal-function funcall function #[0 "\300\207" [signal-process] 1 #1=""] "Name of signal function.\nIt can be an elisp function (usually `signal-process') or a string specifying\nthe external command (usually \"kill\")." :type (choice (function :tag "function") (string :tag "command")) proced-renice-command #[0 "\300\207" ["renice"] 1 #1#] "Name of renice command." :version "24.3" (string :tag "command") proced-signal-list #[0 "\300\207" [(("HUP" . "   (1.  Hangup)") ("INT" . "   (2.  Terminal interrupt)") ("QUIT" . "  (3.  Terminal quit)") ("ABRT" . "  (6.  Process abort)") ("KILL" . "  (9.  Kill - cannot be caught or ignored)") ("ALRM" . "  (14. Alarm Clock)") ("TERM" . "  (15. Termination)") ("BUS" . "   (Access to an undefined portion of a memory object)") ("CHLD" . "  (Child process terminated, stopped, or continued)") ("CONT" . "  (Continue executing, if stopped)") ("FPE" . "   (Erroneous arithmetic operation)") ("ILL" . "   (Illegal Instruction)") ("PIPE" . "  (Write on a pipe with no one to read it)") ("SEGV" . "  (Invalid memory reference)") ("STOP" . "  (Stop executing / pause - cannot be caught or ignored)") ("TSTP" . "  (Terminal stop / pause)") ("TTIN" . "  (Background process attempting read)") ("TTOU" . "  (Background process attempting write)") ("URG" . "   (High bandwidth data is available at a socket)") ("USR1" . "  (User-defined signal 1)") ("USR2" . "  (User-defined signal 2)"))] 1 #1#] "List of signals, used for minibuffer completion." (repeat (cons (string :tag "signal name") (string :tag "description"))) proced-grammar-alist #[0 "\300\207" [((euid "EUID" "%d" right proced-< nil (euid pid) (nil t nil)) (user "User" nil left proced-string-lessp nil (user pid) (nil t nil)) (egid "EGID" "%d" right proced-< nil (egid euid pid) (nil t nil)) (group "Group" nil left proced-string-lessp nil (group user pid) (nil t nil)) (comm "Command" nil left proced-string-lessp nil (comm pid) (nil t nil)) (state "Stat" nil left proced-string-lessp nil (state pid) (nil t nil)) (ppid "PPID" "%d" right proced-< nil (ppid pid) ((lambda (ppid) (proced-filter-parents proced-process-alist ppid)) "refine to process parents")) (pgrp "PGrp" "%d" right proced-< nil (pgrp euid pid) (nil t nil)) (sess "Sess" "%d" right proced-< nil (sess pid) (nil t nil)) (ttname "TTY" proced-format-ttname left proced-string-lessp nil (ttname pid) (nil t nil)) (tpgid "TPGID" "%d" right proced-< nil (tpgid pid) (nil t nil)) (minflt "MinFlt" "%d" right proced-< nil (minflt pid) (nil t t)) (majflt "MajFlt" "%d" right proced-< nil (majflt pid) (nil t t)) (cminflt "CMinFlt" "%d" right proced-< nil (cminflt pid) (nil t t)) (cmajflt "CMajFlt" "%d" right proced-< nil (cmajflt pid) (nil t t)) (utime "UTime" proced-format-time right proced-time-lessp t (utime pid) (nil t t)) (stime "STime" proced-format-time right proced-time-lessp t (stime pid) (nil t t)) (time "Time" proced-format-time right proced-time-lessp t (time pid) (nil t t)) (cutime "CUTime" proced-format-time right proced-time-lessp t (cutime pid) (nil t t)) (cstime "CSTime" proced-format-time right proced-time-lessp t (cstime pid) (nil t t)) (ctime "CTime" proced-format-time right proced-time-lessp t (ctime pid) (nil t t)) (pri "Pr" "%d" right proced-< t (pri pid) (nil t t)) (nice "Ni" "%3d" 3 proced-< t (nice pid) (t t nil)) (thcount "THCount" "%d" right proced-< t (thcount pid) (nil t t)) (start "Start" proced-format-start 6 proced-time-lessp nil (start pid) (t t nil)) (vsize "VSize" "%d" right proced-< t (vsize pid) (nil t t)) (rss "RSS" "%d" right proced-< t (rss pid) (nil t t)) (etime "ETime" proced-format-time right proced-time-lessp t (etime pid) (nil t t)) (pcpu "%CPU" "%.1f" right proced-< t (pcpu pid) (nil t t)) (pmem "%Mem" "%.1f" right proced-< t (pmem pid) (nil t t)) (args "Args" proced-format-args left proced-string-lessp nil (args pid) (nil t nil)) (pid "PID" "%d" right proced-< nil (pid) ((lambda (ppid) (proced-filter-children proced-process-alist ppid)) "refine to process children")) (tree "Tree" proced-format-tree left nil nil nil nil))] 1 #1#] "Alist of rules for handling Proced attributes.\n\nEach element has the form\n\n  (KEY NAME FORMAT JUSTIFY PREDICATE REVERSE SORT-SCHEME REFINER).\n\nSymbol KEY is the car of a process attribute.\n\nString NAME appears in the header line.\n\nFORMAT specifies the format for displaying the attribute values.  It can\nbe a string passed to `format'.  It can be a function called with one\nargument, the value of the attribute.  The value nil means take as is.\n\nIf JUSTIFY is an integer, its modulus gives the width of the attribute\nvalues formatted with FORMAT.  If JUSTIFY is positive, NAME appears\nright-justified, otherwise it appears left-justified.  If JUSTIFY is `left'\nor `right', the field width is calculated from all field values in the listing.\nIf JUSTIFY is `left', the field values are formatted left-justified and\nright-justified otherwise.\n\nPREDICATE is the predicate for sorting and filtering the process listing\nbased on attribute KEY.  PREDICATE takes two arguments P1 and P2,\nthe corresponding attribute values of two processes.  PREDICATE should\nreturn `equal' if P1 has same rank like P2.  Any other non-nil value says\nthat P1 is \"less than\" P2, or nil if not.\nIf PREDICATE is nil the attribute cannot be sorted.\n\nPREDICATE defines an ascending sort order.  REVERSE is non-nil if the sort\norder is descending.\n\nSORT-SCHEME is a list (KEY1 KEY2 ...) defining a hierarchy of rules\nfor sorting the process listing.  KEY1, KEY2, ... are KEYs appearing as cars\nof `proced-grammar-alist'.  First the PREDICATE of KEY1 is evaluated.\nIf it yields non-equal, it defines the sort order for the corresponding\nprocesses.  If it evaluates to `equal' the PREDICATE of KEY2 is evaluated, etc.\n\nREFINER can be a list of flags (LESS-B EQUAL-B LARGER-B) used by the command\n`proced-refine' (see there) to refine the listing based on attribute KEY.\nThis command compares the value of attribute KEY of every process with\nthe value of attribute KEY of the process at the position of point\nusing PREDICATE.\nIf PREDICATE yields non-nil, the process is accepted if LESS-B is non-nil.\nIf PREDICATE yields `equal', the process is accepted if EQUAL-B is non-nil.\nIf PREDICATE yields nil, the process is accepted if LARGER-B is non-nil.\n\nREFINER can also be a list (FUNCTION HELP-ECHO).\nFUNCTION is called with one argument, the PID of the process at the position\nof point.  The function must return a list of PIDs that is used for the refined\nlisting.  HELP-ECHO is a string that is shown when mouse is over this field.\n\nIf REFINER is nil no refinement is done." (repeat (list :tag "Attribute" (symbol :tag "Key") (string :tag "Header") (choice :tag "Format" (const :tag "None" nil) (string :tag "Format String") (function :tag "Formatting Function")) (choice :tag "Justification" (const :tag "left" left) (const :tag "right" right) (integer :tag "width")) (choice :tag "Predicate" (const :tag "None" nil) (function :tag "Function")) (boolean :tag "Descending Sort Order") (repeat :tag "Sort Scheme" (symbol :tag "Key")) (choice :tag "Refiner" (const :tag "None" nil) (list (function :tag "Refinement Function") (string :tag "Help echo")) (list :tag "Refine Flags" (boolean :tag "Less") (boolean :tag "Equal") (boolean :tag "Larger"))))) proced-custom-attributes #[0 "\300\207" [nil] 1 #1#] "List of functions defining custom attributes.\nThis variable extends the functionality of `proced-process-attributes'.\nEach function is called with one argument, the list of attributes\nof a system process.  It returns a cons cell of the form (KEY . VALUE)\nlike `process-attributes'.  This cons cell is appended to the list\nreturned by `proced-process-attributes'.\nIf the function returns nil, the value is ignored." (repeat (function :tag "Attribute")) proced-format-alist #[0 "\300\207" [((short user pid tree pcpu pmem start time (args comm)) (medium user pid tree pcpu pmem vsize rss ttname state start time (args comm)) (long user euid group pid tree pri nice pcpu pmem vsize rss ttname state start time (args comm)) (verbose user euid group egid pid ppid tree pgrp sess pri nice pcpu pmem state thcount vsize rss ttname tpgid minflt majflt cminflt cmajflt start time utime stime ctime cutime cstime etime (args comm)))] 1 #1#] "Alist of formats of listing.\nThe car of each element is a symbol, the name of the format.\nThe cdr is a list of attribute keys appearing in `proced-grammar-alist'.\nAn element of this list may also be a list of attribute keys that specifies\nalternatives.  If the first attribute is absent for a process, use the second\none, etc." (alist :key-type (symbol :tag "Format Name") :value-type (repeat :tag "Keys" (choice (symbol :tag #1#) (repeat :tag "Alternative Keys" (symbol :tag #1#))))) proced-format #[0 "\300\207" [short] 1 #1#] "Current format of Proced listing.\nIt can be the car of an element of `proced-format-alist'.\nIt can also be a list of keys appearing in `proced-grammar-alist'." (choice (symbol :tag "Format Name") (repeat :tag "Keys" (symbol :tag #1#))) make-variable-buffer-local proced-filter-alist #[0 "\300\211\301\302\303 !\304QBD\305\300\301\302\303 !\304QB\306BB\307\310\311\312\313\314\315\316\317 EFD\257\207" [user "\\`" regexp-quote user-real-login-name "\\'" user-running ((state . "\\`[Rr]\\'")) (all) (all-running (state . "\\`[Rr]\\'")) emacs fun-all lambda (list) proced-filter-children list emacs-pid] 11 #1#] "Alist of process filters.\nThe car of each element is a symbol, the name of the filter.\nThe cdr is a list of elementary filters that are applied to every process.\nA process is displayed if it passes all elementary filters of a selected\nfilter.\n\nAn elementary filter can be one of the following:\n(KEY . REGEXP)   If value of attribute KEY matches REGEXP,\n                 accept this process.\n(KEY . FUN)      Apply function FUN to attribute KEY.  Accept this process,\n                 if FUN returns non-nil.\n(function . FUN) For each process, apply function FUN to list of attributes\n                 of each.  Accept the process if FUN returns non-nil.\n(fun-all . FUN)  Apply function FUN to entire process list.\n                 FUN must return the filtered list." (repeat (cons :tag "Filter" (symbol :tag "Filter Name") (repeat :tag "Filters" (choice (cons :tag "Key . Regexp" (symbol :tag "Key") regexp) (cons :tag "Key . Function" (symbol :tag "Key") function) (cons :tag "Function" (const :tag "Key: function" function) function) (cons :tag "Fun-all" (const :tag "Key: fun-all" fun-all) function))))) proced-filter #[0 "\300\207" [user] 1 #1#] "Current filter of proced listing.\nIt can be the car of an element of `proced-filter-alist'.\nIt can also be a list of elementary filters as in the cdrs of the elements\nof `proced-filter-alist'." (choice (symbol :tag "Filter Name") (repeat :tag "Filters" (choice (cons :tag "Key . Regexp" (symbol :tag "Key") regexp) (cons :tag "Key . Function" (symbol :tag "Key") function) (cons :tag "Function" (const :tag "Key: function" function) function) (cons :tag "Fun-all" (const :tag "Key: fun-all" fun-all) function)))) proced-sort #[0 "\300\207" [pcpu] 1 #1#] "Current sort scheme for proced listing.\nIt must be the KEY of an element of `proced-grammar-alist'.\nIt can also be a list of KEYs as in the SORT-SCHEMEs of the elements\nof `proced-grammar-alist'." (choice (symbol :tag "Sort Scheme") (repeat :tag "Key List" (symbol :tag "Key"))) proced-descend #[0 "\300\207" [t] 1 #1#] "Non-nil if proced listing is sorted in descending order." (boolean :tag "Descending Sort Order") proced-goal-attribute #[0 "\300\207" [args] 1 #1#] "If non-nil, key of the attribute that defines the `goal-column'." (choice (const :tag "none" nil) (symbol :tag "key")) proced-auto-update-interval #[0 "\300\207" [5] 1 #1#] "Time interval in seconds for auto updating Proced buffers." integer proced-auto-update-flag #[0 "\300\207" [nil] 1 #1#] "Non-nil for auto update of a Proced buffer.\nCan be changed interactively via `proced-toggle-auto-update'." boolean proced-tree-flag #[0 "\300\207" [nil] 1 #1#] "Non-nil for display of Proced buffer as process tree." proced-post-display-hook #[0 "\300\207" [nil] 1 #1#] "Normal hook run after displaying or updating a Proced buffer.\nMay be used to adapt the window size via `fit-window-to-buffer'." hook :options (fit-window-to-buffer) proced-after-send-signal-hook #[0 "\300\207" [nil] 1 #1#] "Normal hook run after sending a signal to processes by `proced-send-signal'.\nMay be used to revert the process listing." (proced-revert)] 10)
#@55 Non-nil means Proced is known to work on this system.
(defvar proced-available (byte-code "\300 ??\207" [list-system-processes] 1) (#$ . 13685))
#@147 Alist of processes displayed by Proced.
The car of each element is the PID, and the cdr is a list of
cons pairs, see `proced-process-attributes'.
(defvar proced-process-alist nil (#$ . 13837))
(make-variable-buffer-local 'proced-process-alist)
#@91 Sort scheme for listing (internal format).
It is a list of lists (KEY PREDICATE REVERSE).
(defvar proced-sort-internal nil (#$ . 14087))
#@40 In Proced, the current mark character.
(defvar proced-marker-char 42 (#$ . 14230))
(byte-code "\300\301\302\303\304\305\304\306&\210\307\310\311\312#\210\307\313\314\315#\210\307\316\317\320#\207" [custom-declare-group proced-faces nil "Faces used by Proced." :group proced faces custom-declare-face proced-mark ((t (:inherit font-lock-constant-face))) "Face used for Proced marks." proced-marked ((t (:inherit error))) "Face used for marked processes." proced-sort-header ((t (:inherit font-lock-keyword-face))) "Face used for header of attribute used for sorting."] 8)
#@81 Regexp matching a marked line.
Important: the match ends just after the marker.
(defvar proced-re-mark "^[^ \n]" (#$ . 14808))
#@39 Headers in Proced buffer as a string.
(defvar proced-header-line nil (#$ . 14941))
(make-variable-buffer-local 'proced-header-line)
#@38 Temporary alist (internal variable).
(defvar proced-temp-alist nil (#$ . 15079))
#@42 Proced process tree (internal variable).
(defvar proced-process-tree nil (#$ . 15166))
#@53 Internal variable for depth of Proced process tree.
(defvar proced-tree-depth nil (#$ . 15259))
#@58 Stores if Proced auto update timer is already installed.
(defvar proced-auto-update-timer nil (#$ . 15361))
#@28 Name of Proced Log buffer.
(defvar proced-log-buffer "*Proced log*" (#$ . 15475))
#@25 Help string for Proced.
(defconst proced-help-string "(n)ext, (p)revious, (m)ark, (u)nmark, (k)ill, (q)uit (type ? for more help)" (#$ . 15563))
#@57 Help string shown when mouse is over a sortable header.
(defconst proced-header-help-echo "mouse-1, mouse-2: sort by attribute %s%s (%s)" (#$ . 15714))
#@57 Help string shown when mouse is over a refinable field.
(defconst proced-field-help-echo "mouse-2, RET: refine by attribute %s %s" (#$ . 15872))
(defvar proced-font-lock-keywords (byte-code "\302B\303\304	!\305Q\306BD\207" [proced-re-mark proced-marker-char 'proced-mark "^[" char-to-string "]" (".+" (proced-move-to-goal-column) nil (0 'proced-marked))] 4))
#@29 Keymap for Proced commands.
(defvar proced-mode-map (byte-code "\300 \301
\302\303#\210\301
\304\303#\210\301
\305\306#\210\301
\307\303#\210\301
\310\306#\210\301
\311\306#\210\301
\312\306#\210\301
\313\303#\210\301
\314\306#\210\301
\315\316#\210\301
\317\316#\210\320\316\321\317#\210\301
\322\323#\210\301
\311\324#\210\301
\325\326#\210\301
\327\330#\210\301
\331\332#\210\301
\333\334#\210\301
\335\336#\210\301
\337\340#\210\301
\341\342#\210\301
\343\342#\210\301
\344\345#\210\301
\346\347#\210\301
\350\351#\210\301
\352\353#\210\301
\354\355#\210\301
\356\357#\210\301
\360\361#\210\301
\362\363#\210\301
\364\363#\210\301
\365\366#\210\301
\367\370#\210\301
\371\372#\210\301
\373\374#\210\301
\375\374#\210\301
\376\377#\210\301
\201@\201A#\210\301
\201B\201C#\210\301
\201D\201E#\210\301
\201F\201E#\210\207" [make-sparse-keymap define-key " " next-line "n" "p" previous-line "" "" "" [33554464] [down] [up] "d" proced-mark "m" put :advertised-binding "u" proced-unmark proced-unmark-backward "M" proced-mark-all "U" proced-unmark-all "t" proced-toggle-marks "C" proced-mark-children "P" proced-mark-parents "f" proced-filter-interactive [mouse-2] proced-refine "
" "sc" proced-sort-pcpu "sm" proced-sort-pmem "sp" proced-sort-pid "ss" proced-sort-start "sS" proced-sort-interactive "st" proced-sort-time "su" proced-sort-user [header-line mouse-1] proced-sort-header [header-line mouse-2] "T" proced-toggle-tree "F" proced-format-interactive "o" proced-omit-processes "x" proced-send-signal "k" "r" proced-renice "h" describe-mode "?" proced-help [remap undo] proced-undo [remap advertised-undo]] 5) (#$ . 16238))
#@14 Proced Menu.
(defvar proced-menu nil (#$ . 17885))
(byte-code "\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323	\"BBB\324\325\320\326\322\327\n\"BBB\330BBBBBBBBBBBB$\207" [proced-mode-map proced-filter-alist proced-format-alist easy-menu-do-define proced-menu "Proced Menu." "Proced" ["Mark" proced-mark :help "Mark Current Process"] ["Unmark" proced-unmark :help "Unmark Current Process"] ["Mark All" proced-mark-all :help "Mark All Processes"] ["Unmark All" proced-unmark-all :help "Unmark All Process"] ["Toggle Marks" proced-toggle-marks :help "Marked Processes Become Unmarked, and Vice Versa"] ["Mark Children" proced-mark-children :help "Mark Current Process and its Children"] ["Mark Parents" proced-mark-parents :help "Mark Current Process and its Parents"] "--" "Filters" :help "Select Filter for Process Listing" mapcar #[257 "\211@\300\301!\302\303DD\304\305\306\307\310\303	DE&\207" [vector symbol-name proced-filter-interactive quote :style radio :selected eq proced-filter] 12 "\n\n(fn EL)"] ("Sorting" :help "Select Sort Scheme" ["Sort..." proced-sort-interactive :help "Sort Process List"] "--" ["Sort by %CPU" proced-sort-pcpu] ["Sort by %MEM" proced-sort-pmem] ["Sort by PID" proced-sort-pid] ["Sort by START" proced-sort-start] ["Sort by TIME" proced-sort-time] ["Sort by USER" proced-sort-user]) "Formats" "Select Format for Process Listing" #[257 "\211@\300\301!\302\303DD\304\305\306\307\310\303	DE&\207" [vector symbol-name proced-format-interactive quote :style radio :selected eq proced-format] 12 "\n\n(fn EL)"] (["Tree Display" proced-toggle-tree :style toggle :selected (eval proced-tree-flag) :help "Display Proced Buffer as Process Tree"] "--" ["Omit Marked Processes" proced-omit-processes :help "Omit Marked Processes in Process Listing."] "--" ["Revert" revert-buffer :help "Revert Process Listing"] ["Auto Update" proced-toggle-auto-update :style toggle :selected (eval proced-auto-update-flag) :help "Auto Update of Proced Buffer"] "--" ["Send signal" proced-send-signal :help "Send Signal to Marked Processes"] ["Renice" proced-renice :help "Renice Marked Processes"])] 21)
#@46 Return regexp matching `proced-marker-char'.
(defalias 'proced-marker-regexp #[0 "\301\302\303!!P\207" [proced-marker-char "^" regexp-quote char-to-string] 4 (#$ . 20031)])
#@86 Display success message for ACTION performed for COUNT processes.

(fn ACTION COUNT)
(defalias 'proced-success-message #[514 "\300\301\211\302U\203\303\202\304$\207" [message "%s %s process%s" 1 "" "es"] 8 (#$ . 20211)])
#@62 Move to `goal-column' if non-nil.  Return position of point.
(defalias 'proced-move-to-goal-column #[0 "\301 \210m\204\203u\210\202\302u\210`\207" [goal-column beginning-of-line 2] 1 (#$ . 20444)])
#@39 Return header line for Proced buffer.
(defalias 'proced-header-line #[0 "\301\302!\303 GX\205\303 \304O\211\203=\305\306\307#\2035\305\225\262
\310\305\224\311\312\313	\\E%\210\202\210\314\315\316#\262
\317\320\311\312\313E#
D\207" [proced-header-line line-number-display-width columns window-hscroll nil 0 string-match "[ 	\n]+" put-text-property display space :align-to replace-regexp-in-string "\\(%\\)" "\\1\\1" propertize " "] 11 (#$ . 20656)])
#@86 Return pid of system process at point.
Return nil if point is not on a process line.
(defalias 'proced-pid-at-point #[0 "\212\300 \210\301\302!\205\303\304\225\305\")\207" [beginning-of-line looking-at "^. ." get-text-property 0 proced-pid] 3 (#$ . 21131)])
(defvar proced-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [proced-mode-hook variable-documentation put "Hook run after entering Proced mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp proced-mode-map definition-name proced-mode] 4)
(defvar proced-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [proced-mode-abbrev-table proced-mode-map variable-documentation put purecopy "Keymap for `proced-mode'." boundp proced-mode-syntax-table definition-name proced-mode (lambda (#1=#:def-tmp-var) (defvar proced-mode-syntax-table #1#)) make-syntax-table "Syntax table for `proced-mode'." (lambda (#1#) (defvar proced-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `proced-mode'." derived-mode-parent special-mode] 5)
#@1853 Mode for displaying system processes and sending signals to them.
Type \[proced] to start a Proced session.  In a Proced buffer
type \<proced-mode-map>\[proced-mark] to mark a process for later commands.
Type \[proced-send-signal] to send signals to marked processes.

The initial content of a listing is defined by the variable `proced-filter'
and the variable `proced-format'.
The variable `proced-filter' specifies which system processes are displayed.
The variable `proced-format' specifies which attributes are displayed for
each process.  Type \[proced-filter-interactive] and \[proced-format-interactive]
to change the values of `proced-filter' and `proced-format'.
The current value of the variable `proced-filter' is indicated in the
mode line.

The sort order of Proced listings is defined by the variable `proced-sort'.
Type \[proced-sort-interactive] or click on a header in the header line
to change the sort scheme.  The current sort scheme is indicated in the
mode line, using "+" or "-" for ascending or descending sort order.

Type \[proced-toggle-tree] to toggle whether the listing is
displayed as process tree.

Type \[proced-toggle-auto-update] to automatically update the
process list.  The time interval for updates can be configured
via `proced-auto-update-interval'.

An existing Proced listing can be refined by typing \[proced-refine].
Refining an existing listing does not update the variable `proced-filter'.

The attribute-specific rules for formatting, filtering, sorting, and refining
are defined in `proced-grammar-alist'.

After displaying or updating a Proced buffer, Proced runs the normal hook
`proced-post-display-hook'.

\{proced-mode-map}

In addition to any hooks its parent mode `special-mode' might have
run, this mode runs the hook `proced-mode-hook', as the final or
penultimate step during initialization.
(defalias 'proced-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324
\325\"\204R
)=\204R\326
\325)C#\210\327!\210\330\f!\210
)\331\332!\210\333\332!\210\307\211*+\334,\335\336\337\340\307$\210\306\341!\210\342!\306\343!\210\344#&\204\225-\203\225\345\307-\346#&)\347\350!\207" [delay-mode-hooks major-mode mode-name proced-mode-map proced-mode-syntax-table proced-mode-abbrev-table make-local-variable t special-mode proced-mode "Proced" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table abbrev-mode 0 auto-fill-mode (:eval (proced-header-line)) add-hook post-command-hook force-mode-line-update nil revert-buffer-function proced-revert font-lock-defaults (proced-font-lock-keywords t nil nil beginning-of-line) run-at-time proced-auto-update-timer run-mode-hooks proced-mode-hook local-abbrev-table buffer-read-only truncate-lines header-line-format proced-auto-update-interval] 6 (#$ . 22540) nil])
#@318 Generate a listing of UNIX system processes.
\<proced-mode-map>
If invoked with optional ARG, do not select the window displaying
the process information.

This function runs the normal hook `proced-post-display-hook'.

See `proced-mode' for a description of features available in
Proced buffers.

(fn &optional ARG)
(defalias 'proced #[256 "\204\301\302!\210\303\304!\305
q\210\306 \307U\262
\211\203 \310 \210\311\312!\210\2031\313!\210r
q\210\311\312!)\207\314!\210\311\312!\210\315\316\317!!\207" [proced-available error "Proced is not available on this system" get-buffer-create "*Proced*" nil buffer-size 0 proced-mode proced-update t display-buffer pop-to-buffer message substitute-command-keys "Type \\<proced-mode-map>\\[quit-window] to quit, \\[proced-help] for help"] 6 (#$ . 25605) "P"])
#@49 Auto-update Proced buffers using `run-at-time'.
(defalias 'proced-auto-update-timer #[0 "\302 \211\205#\211@r\211q\210\303=\203	\203\304\305\211\"\210)
A\266\202\202\207" [major-mode proced-auto-update-flag buffer-list proced-mode proced-update t] 5 (#$ . 26419)])
#@290 Change whether this Proced buffer is updated automatically.
With prefix ARG, update this buffer automatically if ARG is positive,
otherwise do not update.  Sets the variable `proced-auto-update-flag'.
The time interval for updates is specified via `proced-auto-update-interval'.

(fn ARG)
(defalias 'proced-toggle-auto-update #[257 "\211\301=\203?\202\211\203\302
!\303V\202?\304\305\203$\306\202%\307\"\207" [proced-auto-update-flag toggle prefix-numeric-value 0 message "Proced auto update %s" "enabled" "disabled"] 4 (#$ . 26699) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
#@67 Mark the current (or next COUNT) processes.

(fn &optional COUNT)
(defalias 'proced-mark #[256 "\300\301\"\207" [proced-do-mark t] 4 (#$ . 27315) "p"])
#@69 Unmark the current (or next COUNT) processes.

(fn &optional COUNT)
(defalias 'proced-unmark #[256 "\300\301\"\207" [proced-do-mark nil] 4 (#$ . 27474) "p"])
#@74 Unmark the previous (or COUNT previous) processes.

(fn &optional COUNT)
(defalias 'proced-unmark-backward #[256 "\300\301\206\302[\"\207" [proced-do-mark nil 1] 4 (#$ . 27639) "p"])
#@83 Mark the current (or next COUNT) processes using MARK.

(fn MARK &optional COUNT)
(defalias 'proced-do-mark #[513 "\211\204\301\262
\211\302W\303\302X\203
\202\304 S\305!^T\262\306 \210
S\211\262\302U\2049m\2049\307\"\210\202#\310 )\207" [buffer-read-only 1 0 nil line-number-at-pos abs beginning-of-line proced-insert-mark proced-move-to-goal-column] 6 (#$ . 27831)])
#@65 Toggle marks: marked processes become unmarked, and vice versa.
(defalias 'proced-toggle-marks #[0 "\301 \302\212eb\210m?\205-\303
!\203\304\302!\210\202g\305U\203'\304\306!\210\202\307y\210\202*\207" [buffer-read-only proced-marker-regexp nil looking-at proced-insert-mark 32 t 1] 3 (#$ . 28222) nil])
#@213 If MARK is non-nil, insert `proced-marker-char'.
If BACKWARD is non-nil, move one line backwards before inserting the mark.
Otherwise move one line forward after inserting the mark.

(fn MARK &optional BACKWARD)
(defalias 'proced-insert-mark #[513 "\211\203\301y\210
\203\202\302c\210\303\304!\210\211?\205\305y\207" [proced-marker-char -1 32 delete-char 1 nil] 4 (#$ . 28543)])
#@102 Mark all processes.
If `transient-mark-mode' is turned on and the region is active,
mark the region.
(defalias 'proced-mark-all #[0 "\300\301!\207" [proced-do-mark-all t] 2 (#$ . 28938) nil])
#@106 Unmark all processes.
If `transient-mark-mode' is turned on and the region is active,
unmark the region.
(defalias 'proced-unmark-all #[0 "\300\301!\207" [proced-do-mark-all nil] 2 (#$ . 29137) nil])
#@124 Mark all processes using MARK.
If `transient-mark-mode' is turned on and the region is active,
mark the region.

(fn MARK)
(defalias 'proced-do-mark-all #[257 "\302
\203	\202\n\303\304 \305\211\212\306 \2038\212\307 b\210\310\311!\204$\305y\210`)\262
\312 b\210\310\311!\204>\313 \210\202>eb\210d\262
`
W\203[\310!\204UT\262c\210\314\315!\210\305y\210\202>\316\203d\317\202e\320\"+\207" [proced-marker-char buffer-read-only 0 32 proced-marker-regexp nil use-region-p region-end looking-at "^" region-beginning beginning-of-line delete-char 1 proced-success-message "Marked" "Unmarked"] 7 (#$ . 29344)])
#@129 Mark child processes of process PPID.
Also mark process PPID unless prefix OMIT-PPID is non-nil.

(fn PPID &optional OMIT-PPID)
(defalias 'proced-mark-children #[513 "\301\302#!\207" [proced-process-alist proced-mark-process-alist proced-filter-children] 7 (#$ . 29974) (byte-code "\301 D\207" [current-prefix-arg proced-pid-at-point] 2)])
#@122 Mark parent processes of process CPID.
Also mark CPID unless prefix OMIT-CPID is non-nil.

(fn CPID &optional OMIT-CPID)
(defalias 'proced-mark-parents #[513 "\301\302#!\207" [proced-process-alist proced-mark-process-alist proced-filter-parents] 7 (#$ . 30325) (byte-code "\301 D\207" [current-prefix-arg proced-pid-at-point] 2)])
#@115 Mark processes in PROCESS-ALIST.
If QUIET is non-nil suppress status message.

(fn PROCESS-ALIST &optional QUIET)
(defalias 'proced-mark-process-alist #[513 "\302\203(\303\212eb\210m\204'\304 \236\203!	c\210\305\306!\210\211T\262
\303y\210\202*
?\2051\307\310\"\207" [buffer-read-only proced-marker-char 0 nil proced-pid-at-point delete-char 1 proced-success-message "Marked"] 6 (#$ . 30667)])
#@329 Omit marked processes.
With prefix ARG, omit that many lines starting with the current line.
(A negative argument omits backward.)
If `transient-mark-mode' is turned on and the region is active,
omit the processes in region.
If QUIET is non-nil suppress status message.
Returns count of omitted lines.

(fn &optional ARG QUIET)
(defalias 'proced-omit-processes #[512 "\301 \302\303\304 \203*\305\306 \307 \"\212\306 b\210

W\203%\310 \210
T\262\202)\210\202\204\204L\212eb\210m\204H\311\303\312#\203H\310 \210\211T\262
\2022)\202\204\302W\203fm\204\204\211W\203\204\310 \210\211T\262
\202R\302W\203\204o\204\204\211[W\203\204\313y\210\310 \210\211T\262
\202l\211\302U\204\215\314 \210\204\226\315\316\"\210)\207" [buffer-read-only proced-marker-regexp 0 nil use-region-p count-lines region-beginning region-end proced-omit-process re-search-forward t -1 proced-move-to-goal-column proced-success-message "Omitted"] 8 (#$ . 31078) "P"])
#@83 Omit process from listing point is on.
Update `proced-process-alist' accordingly.
(defalias 'proced-omit-process #[0 "\301\302 \"\303 \212\304y\210`)|\207" [proced-process-alist assq-delete-all proced-pid-at-point line-beginning-position nil] 3 (#$ . 32050)])
#@103 Apply FILTER-LIST to PROCESS-ALIST.
Return the filtered process list.

(fn PROCESS-ALIST FILTER-LIST)
(defalias 'proced-filter #[514 "\2119\203\211\236A\262
\211\211\203\214\211@\301
@\302=\203#
A!\262
\202\203
@\303=\203I\211\203E\211@@
A!\203>\211B\262
A\266\202\202+\210\202\203
A\211;\203W\304\305\"\202X\211\301\211\203\201\211@@
A\236A\262\203z!\203z\211B\262
A\266\202\202[\266\262
A\266\202\202\f\210
\207" [proced-filter-alist nil fun-all function make-closure #[257 "\301\300\"\207" [V0 string-match] 4 "\n\n(fn VAL)"]] 12 (#$ . 32319)])
#@180 Filter Proced buffer using SCHEME.
When called interactively, an empty string means nil, i.e., no filtering.
Set variable `proced-filter' to SCHEME.  Revert listing.

(fn SCHEME)
(defalias 'proced-filter-interactive #[257 "
=?\205\f\211\301\302!\207" [proced-filter proced-update t] 3 (#$ . 32912) (byte-code "\301\302\303\304$\211\305\230?\205\306
!C\207" [proced-filter-alist completing-read "Filter: " nil t "" intern] 5)])
#@153 For PROCESS-ALIST return list of parent processes of PID.
This list includes PID unless OMIT-PID is non-nil.

(fn PROCESS-ALIST PID &optional OMIT-PID)
(defalias 'proced-filter-parents #[770 "\211?\205	
\236C\236\300\301A\236A\211\262\2033\211U\2043\211\236\211\262\2033\211\262
B\262\202
\207" [nil ppid] 8 (#$ . 33352)])
#@157 For PROCESS-ALIST return list of child processes of PPID.
This list includes PPID unless OMIT-PPID is non-nil.

(fn PROCESS-ALIST PPID &optional OMIT-PPID)
(defalias 'proced-filter-children #[770 "\301!\302
\303!\211\203\211@\211\236B\262
A\266\202\202	\210\203*\304\"\202+\211)\207" [proced-temp-alist proced-children-alist nil proced-children-pids assq-delete-all] 9 (#$ . 33700)])
#@305 Return children alist for PROCESS-ALIST.
The children alist has elements (PPID PID1 PID2 ...).
PPID is a parent PID.  PID1, PID2, ... are the child processes of PPID.
The children alist inherits the sorting order of PROCESS-ALIST.
The list of children does not include grandchildren.

(fn PROCESS-ALIST)
(defalias 'proced-children-alist #[257 "\300\301\"\302\211\203P\211@\303
A\236A\262\203I
@U\204I\236\203I\302
\211A\262\242\211\262\203G
@=\203&\302\262\211@AB\241\210\202&\266
A\266\202\202\210\300\304\"\211\262\207" [mapcar #[257 "\211@C\207" #1=[] 2 "\n\n(fn A)"] nil ppid #[257 "\211@
A\237B\207" #1# 3 "\n\n(fn A)"]] 10 (#$ . 34106)])
#@67 Return list of children PIDs of PPID (including PPID).

(fn PPID)
(defalias 'proced-children-pids #[257 "\211\236A\211\203
\301\302\303\304\"\"B\207
C\207" [proced-temp-alist apply append mapcar proced-children-pids] 8 (#$ . 34782)])
#@288 Return process tree for PROCESS-ALIST.
It is an alist of alists where the car of each alist is a parent process
and the cdr is a list of child processes according to the ppid attribute
of these processes.
The process tree inherits the sorting order of PROCESS-ALIST.

(fn PROCESS-ALIST)
(defalias 'proced-process-tree #[257 "\302
!\303\211
	\211A\242\211\262\203\304
!B\202\237*\207" [proced-process-tree proced-temp-alist proced-children-alist nil proced-process-tree-internal] 5 (#$ . 35027)])
#@60 Helper function for `proced-process-tree'.

(fn PID-ALIST)
(defalias 'proced-process-tree-internal #[257 "\211A\302\211@\211\262\2035\211\236\211\262\203#\303
\"\304!\240\210\202.
	\236\240\210\303
	\"A\262\202\266\207" [proced-temp-alist proced-process-tree nil assq-delete-all proced-process-tree-internal] 7 (#$ . 35540)])
#@702 Toggle the display of the process listing as process tree.
With prefix ARG, display as process tree if ARG is positive, otherwise
do not display as process tree.  Sets the variable `proced-tree-flag'.

The process tree is generated from the selected processes in the
Proced buffer (that is, the processes in `proced-process-alist').
All processes that do not have a parent process in this list
according to their ppid attribute become the root of a process tree.
Each parent process is followed by its child processes.
The process tree inherits the chosen sorting order of the process listing,
that is, child processes of the same parent process are sorted using
the selected sorting order.

(fn ARG)
(defalias 'proced-toggle-tree #[257 "\211\301=\203?\202\211\203\302
!\303V\202?\304 \210\305\306\203'\307\202(\310\"\207" [proced-tree-flag toggle prefix-numeric-value 0 proced-update message "Proced process tree display %s" "enabled" "disabled"] 4 (#$ . 35891) (byte-code "\206\301C\207" [current-prefix-arg toggle] 1)])
#@492 Rearrange PROCESS-ALIST as process tree.
If `proced-tree-flag' is non-nil, rearrange PROCESS-ALIST such that
every processes is followed by its child processes.  Each process
gets a tree attribute that specifies the depth of the process in the tree.
A root process is a process with no parent within PROCESS-ALIST according
to its value of the ppid attribute.  It has depth 0.

If `proced-tree-flag' is nil, remove the tree attribute.
Return the rearranged process list.

(fn PROCESS-ALIST)
(defalias 'proced-tree #[257 "\203(\301
!\304\305\211
\211A\262\242\211\262\203$\306
!\210\202	\237+\207\211\211\203<\211\307\310@\"\240\210\211A\262
\202)\210\207" [proced-tree-flag proced-process-tree proced-temp-alist proced-tree-depth 0 nil proced-tree-insert assq-delete-all tree] 8 (#$ . 36938)])
#@55 Helper function for `proced-tree'.

(fn PROCESS-TREE)
(defalias 'proced-tree-insert #[257 "\211@\236\303
@C\304	BCA#\nB
A\205 	T\305\306A\")\207" [proced-temp-alist proced-tree-depth proced-process-tree append tree mapc proced-tree-insert] 6 (#$ . 37755)])
#@1579 Refine Proced listing by comparing with the attribute value at point.
Optional EVENT is the location of the Proced field.

Refinement is controlled by the REFINER defined for each attribute ATTR
in `proced-grammar-alist'.

If REFINER is a list of flags and point is on a process's value of ATTR,
this command compares the value of ATTR of every process with the value
of ATTR of the process at the position of point.

The predicate for the comparison of two ATTR values is defined
in `proced-grammar-alist'.  For each return value of the predicate
a refine flag is defined in `proced-grammar-alist'.  One can select
processes for which the value of ATTR is "less than", "equal",
and / or "larger" than ATTR of the process point is on.  A process
is included in the new listing if the refine flag for the corresponding
return value of the predicate is non-nil.
The help-echo string for `proced-refine' uses "+" or "-" to indicate
the current values of these refine flags.

If REFINER is a cons pair (FUNCTION . HELP-ECHO), FUNCTION is called
with one argument, the PID of the process at the position of point.
The function must return a list of PIDs that is used for the refined
listing.  HELP-ECHO is a string that is shown when mouse is over this field.

This command refines an already existing process listing generated initially
based on the value of the variable `proced-filter'.  It does not change
this variable.  It does not revert the listing.  If you frequently need
a certain refinement, consider defining a new filter in `proced-filter-alist'.

(fn &optional EVENT)
(defalias 'proced-refine #[256 "\211\203\n\302\303!!\210\304`\305\"\304`\306\"
\203\210\211\203\210
\236\307
8\211\205\207\310
@!\2033\211@!\202\205\211:\203\205\3118	\236A\236A\312\211	\211\203\201\211@\nA\236A\"\262\313\267\202k\3148\202rA@\202r\203z@\203z\211B\262
A\266\202\202E\210\266\315 \207\316\317!\207" [proced-grammar-alist proced-process-alist posn-set-point event-end get-text-property proced-key proced-pid 7 functionp 4 nil #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (nil 93 equal 100)) 2 proced-update message "No refiner defined here."] 14 (#$ . 38026) (list last-input-event)])
#@125 Return t if NUM1 less than NUM2.
Return `equal' if NUM1 equals NUM2.  Return nil if NUM1 greater than NUM2.

(fn NUM1 NUM2)
(defalias 'proced-< #[514 "

U\203\300\207

W\207" [equal] 4 (#$ . 40289)])
#@150 Return t if string S1 is less than S2 in lexicographic order.
Return `equal' if S1 and S2 have identical contents.
Return nil otherwise.

(fn S1 S2)
(defalias 'proced-string-lessp #[514 "

\230\203\300\207

\231\207" [equal] 4 (#$ . 40498)])
#@122 Return t if time value T1 is less than time value T2.
Return `equal' if T1 equals T2.  Return nil otherwise.

(fn T1 T2)
(defalias 'proced-time-lessp #[514 "\300\"\206\300
\"?\205\301\207" [time-less-p equal] 5 (#$ . 40749)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias proced-xor xor nil make-obsolete "27.1"] 4)
#@56 Predicate for sorting processes P1 and P2.

(fn P1 P2)
(defalias 'proced-sort-p #[514 "A\2042@\211@A\236A
@A\236A
\2051\211\2051A@\"\3018
\204)\207\211?\205/
\266\202\207\302\211\211\211\3032\220\211A\262\242\211\262\203\214@A\236A\262@A\236A\262

\205g\211\205gA@\"\262\304=\204;\305\303\3018
\204\262
\202\207\211?\205\205
\266\202\"\210\202;\306=0\207" [proced-sort-internal 2 nil done equal throw t] 12 (#$ . 41098)])
#@228 Sort PROCESS-ALIST using scheme SORTER.
SORTER is a scheme like `proced-sort'.
DESCEND is non-nil if the first element of SORTER is sorted
in descending order.
Return the sorted process list.

(fn PROCESS-ALIST SORTER DESCEND)
(defalias 'proced-sort #[771 "\302\303<\203\202&9\203\304\2368\206&9\203\"C\202&\305\306\"\"\211\203=	\211@@	@A@E\240\210\307\310\"\207\207" [proced-grammar-alist proced-sort-internal mapcar #[257 "\211\236\301
8\204\302\303@\"\210
\3018\3048E\207" [proced-grammar-alist 4 error "Attribute %s not sortable" 5] 6 "\n\n(fn ARG)"] 6 error "Sorter undefined %s" sort proced-sort-p] 9 (#$ . 41570)])
#@653 Sort Proced buffer using SCHEME.
When called interactively, an empty string means nil, i.e., no sorting.

Prefix ARG controls sort order:
- If prefix ARG is positive (negative), sort in ascending (descending) order.
- If ARG is nil or `no-arg' and SCHEME is equal to the previous sorting scheme,
  reverse the sorting order.
- If ARG is nil or `no-arg' and SCHEME differs from the previous sorting scheme,
  adopt the sorting order defined for SCHEME in `proced-grammar-alist'.

Set variable `proced-sort' to SCHEME.  The current sort scheme is displayed
in the mode line, using "+" or "-" for ascending or descending order.

(fn SCHEME &optional ARG)
(defalias 'proced-sort-interactive #[513 "\211\303=\203\232\203	?\202O\211\303=\203)\304:\203\"@\202#\n\2368\202O\211\2035\305
!\306W\202O\232\203@	?\202O\304:\203K@\202L\n\2368
\307 \207" [proced-sort proced-descend proced-grammar-alist no-arg 5 prefix-numeric-value 0 proced-update] 5 (#$ . 42226) (byte-code "\302\303\304\211\203\211@\305
8\203\211@CB\262
A\266\202\202\262
\302\306$\211\307\230?\205.\310
!	\2063\311D\207" [proced-grammar-alist current-prefix-arg nil completing-read "Sort attribute: " 4 t "" intern no-arg] 7)])
#@134 Sort Proced buffer by percentage CPU time (%CPU).
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-pcpu #[256 "\300\301\"\207" [proced-sort-interactive pcpu] 4 (#$ . 43458) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@138 Sort Proced buffer by percentage memory usage (%MEM).
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-pmem #[256 "\300\301\"\207" [proced-sort-interactive pmem] 4 (#$ . 43759) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@111 Sort Proced buffer by PID.
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-pid #[256 "\300\301\"\207" [proced-sort-interactive pid] 4 (#$ . 44064) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@140 Sort Proced buffer by time the command started (START).
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-start #[256 "\300\301\"\207" [proced-sort-interactive start] 4 (#$ . 44340) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@123 Sort Proced buffer by CPU time (TIME).
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-time #[256 "\300\301\"\207" [proced-sort-interactive time] 4 (#$ . 44649) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@112 Sort Proced buffer by USER.
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn &optional ARG)
(defalias 'proced-sort-user #[256 "\300\301\"\207" [proced-sort-interactive user] 4 (#$ . 44939) (byte-code "\206\301C\207" [current-prefix-arg no-arg] 1)])
#@300 Sort Proced listing based on an attribute.
EVENT is a mouse event with starting position in the header line.
It is converted to the corresponding attribute key.
This command updates the variable `proced-sort'.
Prefix ARG controls sort order, see `proced-sort-interactive'.

(fn EVENT &optional ARG)
(defalias 'proced-sort-header #[513 "\301!\211\211\302
8\262
\206\303
!\262
\304\211\305 r\306\307\"\216\310\211@\262
!\210\203-A\2020\311!\312 \\\262\313X\205XGW\205X\314\315#\262
\203U\316\"\202X\317\320!*\207" [proced-header-line event-start 7 posn-string nil internal--before-save-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-save-selected-window] 2] select-window posn-point window-hscroll 0 get-text-property proced-key proced-sort-interactive message "No sorter defined here."] 11 (#$ . 45218) (byte-code "	\206\302D\207" [last-input-event last-prefix-arg no-arg] 2)])
#@39 Format time interval TIME.

(fn TIME)
(defalias 'proced-format-time #[257 "\300
\301\"\302
\303\"\304\303\"\302
\305\"\304\305\"\302
\306\"\304\306\"\307W\203-\310\311%\207\307W\203:\310\312$\207\310\313#\207" [time-convert integer truncate 86400 mod 3600 60 0 format "%d-%02d:%02d:%02d" "%02d:%02d:%02d" "%02d:%02d"] 14 (#$ . 46150)])
#@79 Format time START.
The return string is always 6 characters wide.

(fn START)
(defalias 'proced-format-start #[257 "\300
!\300 \3018\3018W\203\302\303\"\207\3048\3048U\203-\3058\3058U\203-\302\306\"\207\302\307\"\207" [decode-time 5 format-time-string "  %Y" 3 4 " %H:%M" "%b %e"] 6 (#$ . 46511)])
#@62 Format attribute TTNAME, omitting path "/dev/".

(fn TTNAME)
(defalias 'proced-format-ttname #[257 "\211\300\301\"\203
\302\225\202\302\303O\207" [string-match "\\`/dev/" 0 nil] 5 (#$ . 46828)])
#@35 Format attribute TREE.

(fn TREE)
(defalias 'proced-format-tree #[257 "\300
\301\"\302!P\207" [make-string 32 number-to-string] 4 (#$ . 47033)])
#@88 Format attribute ARGS.
Replace newline characters by "^J" (two characters).

(fn ARGS)
(defalias 'proced-format-args #[257 "\300\301\302#\207" [string-replace "\n" "^J"] 5 (#$ . 47185)])
#@64 Display PROCESS-ALIST using FORMAT.

(fn PROCESS-ALIST FORMAT)
(defalias 'proced-format #[514 "\2119\203\211\236A\262
\306\307 C!@\310\211	\203$\311\236\203$\312\313BB\262\211\203b\211@\2119\203>\211\236\203[\211B\262\202[\211
A\262\242\211\262\203[\236\203>B\262\310\262
\202>
A\266\202\202%\210
\237\266\204\314G\315\"c\210\n:\203x\n@\202y\n\310\211\211A\262\242\236\211\262\203s\211@\3168\211;\203\232\317\320\"\202\243\211\204\242\321\202\243\211\203\254\322\202\255\323\3248\205\345=\203\276\f\202\301\3258\326\327\330\331\332
\203\321\333\202\322\334
A@	\203\337\335\202\340\336$\257\262
\3378\340
@!\203
\326\327\341\331\332\342A@\"\257\202
\211:\205
\326\327\341\331\332\343
A@\344\345\n\323##\257\310=\203+
\346\347\"\262eb\210\350	8\247\203\223
\f\211\203t
\211@\310\210	
A\236A\262\203Y
\351\352	!#\202e
\332\353\354\3508!\355Q\356\"\261\210\310y\210
A\266\202\2028
\210\332\353\354\350\f8!\355Q\351\352\fA@#\"\nB\262\n\266\202{\204\345
\350	8\357=\203\345
\f\211\203\321
\211@\310\210	
A\236A\262\203\304
\351\352	!#\202\305
\356c\210\310y\210
A\266\202\202\243
\210\351\352\nA@#\nB\262\n\266\202{A@G\310\211\211\203*\211@\f
A\236A\262\203\351\352\f!	#\262G]\262B\262\202#\356B\262\360]\262
A\266\202\202\356
\210\353\350
8\357=\2039\333\202:\323\354!\355R\332
\351\352A@\f#\"B\262\237\211\203n\211@\310\210\332\"\261\210\310y\210
A\266\202\202R\266
\202{eb\210\211\203\220\211@\361`\362 \363@$\210\310y\210
A\266\202\202w\210\344\321\237\322#9\364\3659\"\203\2519\313\211\224O9eb\210\366\367\310\370#\205\275\313\224\313\225|\210\202\254\207" [proced-format-alist proced-tree-flag proced-sort proced-grammar-alist proced-descend proced-header-help-echo proced-process-attributes emacs-pid nil ppid tree 0 make-string 10 2 make-closure #[257 "\301\300\"\207" [V0 format] 4 "\n\n(fn ARG)"] identity " " "" 4 5 proced-key mouse-face header-line-highlight help-echo format "-" "+" "descending" "ascending" 7 functionp highlight "mouse-2, RET: %s" "mouse-2, RET: refine by attribute %s %s" mapconcat #[257 "\211\203\300\207\301\207" ["+" "-"] 2 "\n\n(fn S)"] append (face proced-sort-header) 3 apply propertize "%" number-to-string "s" "?" left 1 put-text-property line-end-position proced-pid string-match "[ 	]+$" re-search-forward "[ 	
]+$" t proced-header-line] 23 (#$ . 47379)])
#@224 Format Proced buffer using SCHEME.
When called interactively, an empty string means nil, i.e., no formatting.
Set variable `proced-format' to SCHEME.
With prefix REVERT non-nil revert listing.

(fn SCHEME &optional REVERT)
(defalias 'proced-format-interactive #[513 "=\203\n\211\205
\301
!\207" [proced-format proced-update] 4 (#$ . 49862) (byte-code "\302\303\304\305$\211\306\230?\205\307
!	D\207" [proced-format-alist current-prefix-arg completing-read "Format: " nil t "" intern] 5)])
#@316 Return alist of attributes for each system process.
This alist can be customized via `proced-custom-attributes'.
Optional arg PID-LIST is a list of PIDs of system process that are analyzed.
If no attributes are known for a process (possibly because it already died)
the process is ignored.

(fn &optional PID-LIST)
(defalias 'proced-process-attributes #[256 "\301\211\211\206	\302 \211\203L\211@\303
!\211\262\203E\304
BB\262\211\203=\211@\211!\211\262\2036B\262
A\266\202\202 \210\211BB\262
A\266\202\202	\207" [proced-custom-attributes nil list-system-processes process-attributes pid] 10 (#$ . 50367)])
#@275 Update the Proced process information.  Preserves point and marks.
With prefix REVERT non-nil, revert listing.
Suppress status information if QUIET is nil.
After updating a displayed Proced buffer run the normal hook
`proced-post-display-hook'.

(fn &optional REVERT QUIET)
(defalias 'proced-update #[512 "
\206?\262\211\204\306\203\307\202\310!\210
\203\311 \302\301	\"\n#\312!\f:\2033\313\314\315 \316`\317\"

\211\203U\316`S\317\"\203Q`\320`\317\"Z\202V\321\202ViE\266\202\313\211
eb\210\322\323\313\314#\203\201\324 \325\326\"\216\315 )\262
\327\330!B
B\262
\202b\331 \210\332\"\210eb\210m\204\232\333c\210\313y\210\202\215\3336P6\203\250\334\313!\21078\236\211\205\322\335 \321U?\205\322\336\337A@!6\"\205\322\340
8\203\320\321\224\202\322\321\2259\210eb\210\313\211\211\204\344@\203_
m\204_
\315 \262\236\211\262\203

Ac\210\341\330!\210\342 \210@=\203Y
A@\203M
\343 \313\204@
\344`\313#\211\262\203@
\211b\210A@\316`\317\"=\203
\3458\344`!`Z^u\210`\262\202
\204H
\346 \262\266\202Y
\347 \3458\\\343 ^\262
\313y\210\202\344\211\203j
\211b\266\202q
eb\210\346 \266\350	\203~
\351\352	!P\202
\353\n\203\245
\n:\203\215
\n@\202\216
\n\2118\236\354\203\233
\355\202\234
\356A@Q\266\202\202\246
\353Q:\357 \210\360 \203\265
\361\362!\210\206\312
\363 \206\312
\306\203\310
\364\202\311
\365!*\207" [proced-process-alist proced-filter proced-sort proced-descend buffer-undo-list buffer-read-only message "Updating process information..." "Updating process display..." proced-process-attributes proced-tree nil t proced-pid-at-point get-text-property proced-key previous-single-property-change 0 re-search-forward "^\\(\\S-\\)" match-data make-closure #[0 "\301\300\302\"\207" [V0 set-match-data evaporate] 3] match-string-no-properties 1 erase-buffer proced-format "  " set-buffer-modified-p buffer-size string-match regexp-quote 3 delete-char beginning-of-line line-end-position next-property-change 2 proced-move-to-goal-column line-beginning-position "Proced" ": " symbol-name "" " by " "-" "+" force-mode-line-update get-buffer-window run-hooks proced-post-display-hook input-pending-p "Updating process information...done." "Updating process display...done." proced-header-line proced-goal-attribute proced-grammar-alist goal-column mode-name] 15 (#$ . 51003) "P"])
#@118 Reevaluate the process listing based on the currently running processes.
Preserves point and marks.

(fn &rest ARGS)
(defalias 'proced-revert #[128 "\300\301!\207" [proced-update t] 3 (#$ . 53368)])
#@240 Return marked processes as alist of PIDs.
If no process is marked return alist with the PID of the process point is on.
The cdrs of the alist are the text strings displayed by Proced for these
processes.  They are used for error messages.
(defalias 'proced-marked-processes #[0 "\300 \301\212eb\210\302\301\303#\203!\304 \305\306\307 \\\310 \"B
B\262
\202)\211\203)\211\237\207\304 \211\205:\211\305\306\307 \\\310 \"BC\207" [proced-marker-regexp nil re-search-forward t proced-pid-at-point buffer-substring-no-properties 2 line-beginning-position line-end-position] 7 (#$ . 53574)])
#@236 Execute the forms in BODY in a temporary buffer displaying PROCESS-ALIST.
PROCESS-ALIST is an alist of process PIDs as in `proced-process-alist'.
The value returned is the value of the last form in BODY.

(fn PROCESS-ALIST &rest BODY)
(defalias 'proced-with-processes-buffer '(macro . #[385 "\300\301\302\303\304\305\300\306\307\310\311\312\313D\314BB\315BBBBBB\316\317	BB\257E\207" [let ((bufname " *Marked Processes*") (header-line (substring-no-properties proced-header-line))) with-current-buffer (get-buffer-create bufname) (setq truncate-lines t proced-header-line header-line header-line-format '(:eval (proced-header-line))) (add-hook 'post-command-hook #'force-mode-line-update nil t) ((inhibit-read-only t)) (erase-buffer) (buffer-disable-undo) (setq buffer-read-only t) dolist process ((insert "  " (cdr process) "\n")) ((delete-char -1) (goto-char (point-min))) save-window-excursion (display-buffer (current-buffer) '(display-buffer-in-direction (direction . bottom) (window-height . fit-window-to-buffer)))] 16 (#$ . 54171)]))
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put proced-with-processes-buffer lisp-indent-function 1 put edebug-form-spec t] 5)
#@746 Send a SIGNAL to processes in PROCESS-ALIST.
PROCESS-ALIST is an alist as returned by `proced-marked-processes'.
Interactively, PROCESS-ALIST contains the marked processes.
If no process is marked, it contains the process point is on,
SIGNAL may be a string (HUP, INT, TERM, etc.) or a number.
After sending SIGNAL to all processes in PROCESS-ALIST, this command
runs the normal hook `proced-after-send-signal-hook'.

For backward compatibility SIGNAL and PROCESS-ALIST may be nil.
Then PROCESS-ALIST contains the marked processes or the process point is on
and SIGNAL is queried interactively.  This noninteractive usage is still
supported but discouraged.  It will be removed in a future version of Emacs.

(fn &optional SIGNAL PROCESS-ALIST)
(defalias 'proced-send-signal #[512 "
\203\211\204\233\306\307N\204\310\306\307\311#\210\312\313!\210\314\315!\210\316 \262

\204\233\211G\317U\203/\320\2024\321\322G\"\311\323\324D\325\n!r\326\327!q\210\311\211\330\331\332\333\334\311$\210\311\335 \210\336 \210\311@\211\203p\211@\337
A\340\261\210
A\266\202\202\\\210\341\342!\210eb\210)\343 \344\345\"\216\346p\347\"\210\350\351\352QA\334\211\211\211\353&\262)\210)\210*\210\334\354B!\203
;\203\273\355\356\"\203\265\357!\202\274\360!\202\274\211\203
\211@\3611\345B
@\"\362U?\205\340\363\364A\"\210\211AB\211\2620\210\202\371\363\364\"\210\363\364A\"\210
AB\211\262\266
A\266\202\202\275\266\202h
\321\365\"\211\203f
\211@\366\367\311\"r\211q\210\344\370\"\216\3711L
\372B\334\311\334\373@!&\362U?\205G
\363p!\210\363\364A\"\210
AB\211\2620\210\202]
\210\363p!\210\363\364A\"\210
AB\262*\210
A\266\202\202\n
\266\211\203\216
\374\321\375\"\321\376GGG\317U\203\204
\377\202\207
\201C$\"\266\202\231
\201D\201EG\"\266\201F\201G!\207" [completion-extra-properties completion-ignore-case proced-header-line truncate-lines header-line-format inhibit-read-only proced-send-signal proced-outdated put t message "Outdated usage of `proced-send-signal'" sit-for 2 proced-marked-processes 1 "1 process" format "%d processes" :annotation-function #[257 "\301
\"A\207" [proced-signal-list assoc] 4 "\n\n(fn S)"] substring-no-properties get-buffer-create " *Marked Processes*" (:eval (proced-header-line)) add-hook post-command-hook force-mode-line-update nil erase-buffer buffer-disable-undo "  " "\n" delete-char -1 current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] display-buffer (display-buffer-in-direction (direction . bottom) (window-height . fit-window-to-buffer)) completing-read "Send signal [" "] (default TERM): " "TERM" functionp string-match "\\`[0-9]+\\'" string-to-number make-symbol (error) 0 proced-log "%s\n" "-%s" generate-new-buffer " *temp*" #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] (error) call-process number-to-string proced-log-summary "Signal %s" "%d of %d signal%s failed" "" buffer-read-only proced-signal-list proced-signal-function "s" proced-success-message "Sent signal to" run-hooks proced-after-send-signal-hook] 15 (#$ . 55368) (byte-code "\306 \211G\307U\203
\310\202\311\312G\"\313\314\315D\316\n!r\317\320!q\210\313\211\321\322\323\324\325\313$\210\313\326 \210\327 \210\313%\211\203N\211@\330
A\331\261\210
A\266\202\202:\210\332\333!\210eb\210)\334 \335\336\"\216\337p\340\"\210\341\342\343Q&\325\211\211\211\344&)D\262
)\262
*\207" [completion-ignore-case completion-extra-properties proced-header-line truncate-lines header-line-format inhibit-read-only proced-marked-processes 1 "1 process" format "%d processes" t :annotation-function #[257 "\301
\"A\207" [proced-signal-list assoc] 4 "\n\n(fn S)"] substring-no-properties get-buffer-create " *Marked Processes*" (:eval (proced-header-line)) add-hook post-command-hook force-mode-line-update nil erase-buffer buffer-disable-undo "  " "\n" delete-char -1 current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] display-buffer (display-buffer-in-direction (direction . bottom) (window-height . fit-window-to-buffer)) completing-read "Send signal [" "] (default TERM): " "TERM" buffer-read-only proced-signal-list] 12)])
#@385 Renice the processes in PROCESS-ALIST to PRIORITY.
PROCESS-ALIST is an alist as returned by `proced-marked-processes'.
Interactively, PROCESS-ALIST contains the marked processes.
If no process is marked, it contains the process point is on,
After renicing all processes in PROCESS-ALIST, this command runs
the normal hook `proced-after-send-signal-hook'.

(fn PRIORITY PROCESS-ALIST)
(defalias 'proced-renice #[514 "
\247\203\n\301!\262\302
\211\203g\211@\303\304\305\"r\211q\210\306\307\"\216\3101M\311\302\305\302\n\301@!&\312U?\205H\313p!\210\313\314A\"\210
AB\211\2620\210\202^\210\313p!\210\313\314A\"\210
AB\262*\210
A\266\202\202\f\210\211\203\214\315\316\317\"\316\320GGG\321U\203\204\322\202\205\323$\"\266\202\223\324\325G\"\266\326\327!\207" [proced-renice-command number-to-string nil generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] (error) call-process 0 proced-log "%s\n" proced-log-summary format "Renice %s" "%d of %d renice%s failed" 1 "" "s" proced-success-message "Reniced" run-hooks proced-after-send-signal-hook] 14 (#$ . 59589) (byte-code "\305 \306!r\307\310!q\210\311\211\312\313\314\315\316\311$\210\311\317 \210\320 \210\311
\211\2037\211@\321
A\322\261\210
A\266\202\202#\210\323\324!\210eb\210)\325 \326\327\"\216\330p\331\"\210\332\333!)D\262
)\207" [proced-header-line truncate-lines header-line-format inhibit-read-only buffer-read-only proced-marked-processes substring-no-properties get-buffer-create " *Marked Processes*" t (:eval (proced-header-line)) add-hook post-command-hook force-mode-line-update nil erase-buffer buffer-disable-undo "  " "\n" delete-char -1 current-window-configuration make-closure #[0 "\301\300!\207" [V0 set-window-configuration] 2] display-buffer (display-buffer-in-direction (direction . bottom) (window-height . fit-window-to-buffer)) read-number "New priority: "] 7)])
#@185 Pop up a buffer with error log output from Proced.
A group of errors from a single command ends with a formfeed.
Thus, use \[backward-page] to find the beginning of a group of errors.
(defalias 'proced-why #[0 "\303!\205.\304 r\305\306\"\216\307\310\303!!!\210\311\312\313!\210\311db\210\314y\210\315\316!\210\317\320!*\262
\207" [proced-log-buffer truncate-lines buffer-read-only get-buffer internal--before-save-selected-window make-closure #[0 "\301\300!\207" [V0 internal--after-save-selected-window] 2] select-window display-buffer t set-buffer-modified-p nil -1 backward-page 1 recenter 0] 5 (#$ . 61538) nil])
#@339 Log a message or the contents of a buffer.
If LOG is a string and there are more args, it is formatted with
those ARGS.  Usually the LOG string ends with a \n.
End each bunch of errors with (proced-log t signal):
this inserts the current time, buffer and signal at the start of the page,
and  (formfeed) at the end.

(fn LOG &rest ARGS)
(defalias 'proced-log #[385 "pr\302!q\210db\210\303;\203\"
\203\304\305#\202c\202Q\306!\203.\307!\202Q\310=\205Q\311\312!\210n\204?\313c\210\314 \305\315\316!@#\261\210db\210\317c*\207" [proced-log-buffer buffer-read-only get-buffer-create nil apply format-message bufferp insert-buffer-substring t backward-page 1 "\n" current-time-string "	Buffer `%s', signal `%s'\n" buffer-name "\f\n"] 8 (#$ . 62168)])
#@134 State a summary of SIGNAL's failures, in echo area and log buffer.
STRING is an overall summary of the failures.

(fn SIGNAL STRING)
(defalias 'proced-log-summary #[514 "\300\301#\210\302\303\303Q!\210\302\304\"\207" [message "Signal %s: %s--type ? for details" proced-log "\n" t] 6 (#$ . 62942)])
#@35 Provide help for the Proced user.
(defalias 'proced-help #[0 "\302 \210\303=\203\f\304 \207\305	!\207" [last-command proced-help-string proced-why proced-help describe-mode message] 2 (#$ . 63250) nil])
#@144 Undo in a Proced buffer.
This doesn't recover killed processes, it just undoes changes in the Proced
buffer.  You can use it to recover marks.
(defalias 'proced-undo #[0 "\301\302 \210)\303\304!\207" [buffer-read-only nil undo message "Change in Proced buffer undone.\nKilled processes cannot be recovered by Emacs."] 2 (#$ . 63462) nil])
(provide 'proced)