%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/calc/
Current File : //usr/local/share/emacs/27.2/lisp/calc/calc-yank.elc
;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; 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\300\302!\207" [require calc-ext calc-macs] 2)
(defalias 'calc-kill #[(nn &optional no-delete) "\302=\203\n\303\304!\207\305	!\207" [major-mode nn calc-mode calc-do #[nil "\306 \210\307\310!\210\311`!\312]\313!	\314W\203%m\203\nS\n	Z	[\315\n!\210\316	\317\n	\320#\"\321\n!\210`\321\n	Z!\210\204E\320u\210\322\f`\"\210
\204W\323	\317\n	\320#\"\210)@B\211+\207" [nn n num stuff first no-delete calc-force-refresh calc-set-command-flag no-align calc-locate-cursor-element 1 prefix-numeric-value 0 calc-check-stack calc-top-list - -1 calc-cursor-stack-index copy-region-as-kill calc-pop-stack kill-ring calc-last-kill] 6] kill-line] 2 nil "P"])
(defalias 'calc-force-refresh #[nil "\204	\205
\302\303 )\207" [calc-executing-macro calc-display-dirty nil calc-refresh] 1])
(defalias 'calc-locate-cursor-element #[(pt) "\212db\210\303[	\n#)\207" [calc-stack-top calc-stack pt calc-locate-cursor-scan] 4])
(defalias 'calc-locate-cursor-scan #[(n stack pt) "`X\204\n	\204\f\n\207	@A@[y\210\303\nT	A#\207" [pt stack n calc-locate-cursor-scan] 4])
(defalias 'calc-kill-region #[(top bot &optional no-delete) "\304=\203\n\305\306!\207	\203\307\n\"\207\310\n\"\207" [major-mode no-delete top bot calc-mode calc-do #[nil "\306 \210\307\310!\210\311!\212\312	!\210`)\311S!\212\312\313\fS]!\210`)\314	\f\315#\316\n
\"\210@\317\f\"B?\205E\320\f\"-\207" [top top-num top-pos bot bot-num bot-pos calc-force-refresh calc-set-command-flag no-align calc-locate-cursor-element calc-cursor-stack-index 0 - -1 copy-region-as-kill calc-top-list calc-pop-stack num kill-ring calc-last-kill no-delete] 4] copy-region-as-kill kill-region] 3 nil "r"])
(defalias 'calc-copy-as-kill #[(n) "\301\302\"\207" [n calc-kill t] 3 nil "P"])
(defalias 'calc-copy-region-as-kill #[(top bot) "\302	\303#\207" [top bot calc-kill-region t] 4 nil "r"])
#@64 Return a regexp which will match a Calc number base RADIX-NUM.
(defalias 'math-number-regexp #[(radix-num) "\304X\203\305Y\203\306\307S!\310Q\2021\311U\203 \312\2021\313\314\315\316\\\"\317\314\315\320\\\"\310\260\211\321P	\322	\323R\324\325\n\325\n\326\n\327\n\330\n\327\n\330\330\n\331\260+\207" [radix-num digit-range integer-regexp decimal-regexp 2 10 "[0-" number-to-string "]" 11 "[0-9aA]" "[0-9a-" format "%c" 86 "A-" 54 "+" "+\\." "*" " *\\([-_+]?" "[eE][-+]?[0-9]+\\|[-_+]?" "*[:/]" "[:/]" "\\|[-_+]?" "\\) *\\(\n\\|\\'\\)"] 20 (#$ . 2299)])
#@610 Yank a value into the Calculator buffer.

Valid numeric prefixes for RADIX: 0, 2, 6, 8
No radix notation is prepended for any other numeric prefix.

If RADIX is 2, prepend "2#"  - Binary.
If RADIX is 8, prepend "8#"  - Octal.
If RADIX is 0, prepend "10#" - Decimal.
If RADIX is 6, prepend "16#" - Hexadecimal.

If RADIX is a non-nil list (created using \[universal-argument]), the user
will be prompted to enter the radix in the minibuffer.

If RADIX is nil or if the yanked string already has a calc radix prefix, the
yanked string will be passed on directly to the Calculator buffer without any
alteration.
(defalias 'calc-yank #[(radix) "\300\301!\207" [calc-do #[nil "\306\307\310\311\211\311\312\313!\203\313\307\314\"\202@
\203.\315\f\311\314#\316#)\266\203\2032\f\202\211
<\203S\317\320!\211\250\203L\321X\203L\322Y\204p\323\324!\210\202p
\325\267\202i\321\202o\326\202o\327\202o\330\202o\331\332
\"\210\311\203\210\333!\334P\335!\336\n	\337P\f#\202\211\f$%\242\f=\203\231%A\202\311$;\205\311\340\341$!!\211&\242\323=\203\306\340$!\211&\242\323=\203\301\323\342!\202\310&\202\310&)-#\207" [radix-num radix-notation valid-num-regexp kill-ring-yank-pointer thing-raw radix calc-pop-push-record-list 0 "yank" nil fboundp current-kill t "^[-(]*[0-9]\\{1,2\\}#" string-match read-number "Set radix for yanked content (2-36): " 2 36 error "The radix has to be an integer between 2 and 36." #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (2 89 8 93 0 97 6 101)) 8 10 16 message "No radix prepended for invalid *numeric* prefix %0d." number-to-string "#" math-number-regexp replace-regexp-in-string "\\&" math-read-exprs calc-clean-newlines "Bad format in yanked data" inhibit-changing-match-data thing calc-last-kill val] 11]] 2 (#$ . 2877) "P"])
#@149 Alist of elements (NAME . (TEXT . CALCVAL)).
NAME is a character (a number).
TEXT and CALCVAL are the TEXT and internal structure of stack entries.
(defvar calc-register-alist nil (#$ . 4723))
#@137 Set the contents of the Calc register REGISTER to (TEXT . CALCVAL),
as well as set the contents of the Emacs register REGISTER to TEXT.
(defalias 'calc-set-register #[(register text calcval) "\306	\"\210\n\236	\fB\203
\241\210\202 
B\211\nB
*\207" [register text calc-register-alist #1=#:p calcval #2=#:v set-register] 3 (#$ . 4923)])
#@235 Return the CALCVAL portion of the contents of the Calc register REG,
unless the TEXT portion doesn't match the contents of the Emacs register REG,
in which case either return the contents of the Emacs register (if it is
text) or nil.
(defalias 'calc-get-register #[(reg) "	\236A\n\236A;\205\"\f@;\203!\f@\230\203!\fA\202\"*\207" [reg calc-register-alist register-alist val cval] 3 (#$ . 5277)])
#@158 Copy the lines in the region into register REGISTER.
With prefix arg, delete as well.

Interactively, reads the register using `register-read-with-preview'.
(defalias 'calc-copy-to-register #[(register start end &optional delete-flag) "\306=\203G\307	!\212\310\n!\210`)\307\fS!\212\310\311
S]!\210`)\312\n
\313#{\314\315
\"#\210\205D\316\317!.\207\320	\f$\207" [major-mode start top-num top-pos end bot-num calc-mode calc-locate-cursor-element calc-cursor-stack-index 0 - -1 calc-set-register calc-top-list calc-do #[nil "\302	\"\207" [num bot-num calc-pop-stack] 3] copy-to-register bot-pos num str register delete-flag] 6 (#$ . 5690) (list (register-read-with-preview "Copy to register: ") (region-beginning) (region-end) current-prefix-arg)])
#@114 Insert the contents of register REGISTER.

Interactively, reads the register using `register-read-with-preview'.
(defalias 'calc-insert-register #[(register) "\303=\203\304	!\305\306!)\207\307	!\207" [major-mode register val calc-mode calc-get-register calc-do #[nil "\302\303\304\204
\305\306!\202::\203\202:\307\310!!\211\242\305=\2038\307!\211\242\305=\2034\305\306!\2029	\2029	)#\207" [val nval calc-pop-push-record-list 0 "insr" error "Bad format in register data" math-read-exprs calc-clean-newlines] 7] insert-register] 2 (#$ . 6472) (list (register-read-with-preview "Insert register: "))])
#@188 Add the lines in the region to register REGISTER.
If PREPEND is non-nil, add them to the beginning of the register,
otherwise the end.  If DELETE-FLAG is non-nil, also delete the region.
(defalias 'calc-add-to-register #[(register start end prepend delete-flag) "\306!\212\307	!\210`)\306S!\212\307\310\fS]!\210`)\311	\f\312#\n
{\313\f\"\236A\211\204G\314#\210\202s\203a\314@P\315A\"#\210\202s\314@P\315A\"#\210\205{\316\317!.\207" [start top-num top-pos end bot-num bot-pos calc-locate-cursor-element calc-cursor-stack-index 0 - -1 calc-top-list calc-set-register append calc-do #[nil "\302	\"\207" [num bot-num calc-pop-stack] 3] num str calcval register calc-register-alist cval prepend delete-flag] 7 (#$ . 7098)])
#@175 Copy the lines in the region to the end of register REGISTER.
With prefix arg, also delete the region.

Interactively, reads the register using `register-read-with-preview'.
(defalias 'calc-append-to-register #[(register start end &optional delete-flag) "\305=\203\306	\n\307\f%\207\310	\n\f$\207" [major-mode register start end delete-flag calc-mode calc-add-to-register nil append-to-register] 6 (#$ . 7881) (list (register-read-with-preview "Append to register: ") (region-beginning) (region-end) current-prefix-arg)])
#@181 Copy the lines in the region to the beginning of register REGISTER.
With prefix arg, also delete the region.

Interactively, reads the register using `register-read-with-preview'.
(defalias 'calc-prepend-to-register #[(register start end &optional delete-flag) "\305=\203\306	\n\307\f%\207\310	\n\f$\207" [major-mode register start end delete-flag calc-mode calc-add-to-register t prepend-to-register] 6 (#$ . 8415) (list (register-read-with-preview "Prepend to register: ") (region-beginning) (region-end) current-prefix-arg)])
(defalias 'calc-clean-newlines #[(s) "\301\302\"\204\301\303\"\203\304\305\306\"!\207\301\307\"\203)\304\305\306\"\310\305\311\"Q!\207\207" [s string-match "\\`[ \n
]+\\([^]*\\)\\'" "\\`\\([^]*\\)[ \n
]+\\'" calc-clean-newlines math-match-substring 1 "\\`\\(.*\\)[\n
]+\\([^]*\\)\\'" "," 2] 6])
(defalias 'calc-do-grab-region #[(top bot arg) "\306>\203\n\307\310!\210p\311\312!\313\211\313\211\203]:\203)\314\202]\315!\211\316U\203@\317 \320  \202]\212`y\210\316V\203U` \202\\ `) {\321 \210\203q\322\f!\202\223\322\323\f\324Q!\211\242\325=\203\223
G\326U\203\223
A@\242\325=\203\223
A@
\242\307=\203\306\n\203\245\327	!\210\202\255\330\314!\210\331	!\210b\210
A@\203\274\316\202\275\332\\u\210\307\326
8!\210\333\334`\".\207" [major-mode from-buffer calc-was-started single data vals (calc-mode calc-trail-mode) error "This command works only in a regular text buffer" get-buffer-window "*Calculator*" nil t prefix-numeric-value 0 point-at-bol point-at-eol calc math-read-expr "[" "]" vec 2 pop-to-buffer calc-quit switch-to-buffer 1 calc-do #[nil "\301\302\303#\207" [vals calc-enter-result 0 "grab"] 4] pos arg top bot] 5])
(defalias 'calc-do-grab-rectangle #[(top bot arg &optional reduce) "\306>\203\n\307\310!\210\212	b\210i)\212b\210i)p\311\312!)\313\211*+\313\211,-\313\211./\n\fU\203g\212\n\314U\204B\307\315!\210	b\210`W\203^`.\316y\210.`S{*B*\202E*\237*)\202m\317	\"*\320 \210\321C+\314-0\203\2140:\203\206\314\202\212\3220!0*\203\316\3230!\203	0\314U\203\242\3240\314/\321C,*@G\313\211123/3W\203/0\\\21123Y\203\327\325\326*@/\"!\202\342\325\326*@/2#!\2111\242\307=\203\3651,\3143\202\265,1C\244,2\211/\202\267+\202|\327\330*@\"\203\321\331*@!D,\202|0\204=\327\332*@\"\203=\314\224/\325\333*@\314\"!,\202|\327\334*@\"\203O\333*@\335\"\202R*@4\336/\325\3374\340Q!\211,\242\307=\203{\3254!\2115\242\307=\204z\3215D,)),\242\307=\203\263)\203\220\341
!\210\202\230\342\343!\210\344
!\210	b\210-y\210\345,A@\n\f^/#u\210\307\335,8!\210,\346\232\204\301,+B+*A*-T-\202\214\347\350`\".\n\207" [major-mode top col1 bot col2 from-buffer (calc-mode calc-trail-mode) error "This command works only in a regular text buffer" get-buffer-window "*Calculator*" nil 0 "Point and mark must be at beginning of line, or define a rectangle" 1 extract-rectangle calc vec prefix-numeric-value natnump 1000000 math-read-expr substring string-match "\\` *-?[0-9][0-9]?[0-9]?[0-9]?[0-9]?[0-9]? *\\'" string-to-number "[[{][^][{}]*[]}]" math-match-substring "\\`\\([0-9]+:[ 	]\\)?\\(.*[^, 	]\\)[, 	]*\\'" 2 -1 "[" "]" pop-to-buffer calc-quit t switch-to-buffer + (vec) calc-do #[nil "\203\302\303\304\305	\237E#\207\302\303\306	\237#\207" [reduce mat calc-enter-result 0 "grb+" (var add var-add) "grab"] 6] calc-was-started data mat vals lnum pt pos arg v j w s v2] 6])
#@47 Copy the top of stack into an editing buffer.
(defalias 'calc-copy-to-buffer #[(nn) "\306>?\205p\307\211\211\310\311!\210\203b\210
:\205+\f?\205+\312\313!\210\314	!,\207" [major-mode newbuf oldbuf movept thebuf nn (calc-mode calc-trail-mode) nil calc-do #[nil "\212\306 \210\307!	\n\310=\203\311\202\312\313\211\"#p$%\2067\314\315 \312\"\2067\314\315 \311\"\2067\316\317!&\203B:\203w\320\312!\320\311!S
ZU\203w\321\311!\210\322	\203\\\323\202]\324!\203f\312\225Sb\210\313\"`\321\312!\210`S
Z\202\271#\312V\203\220\321#!\210`\321\312!\210`
Z\202\271#\312W\203\253\321#[!\210`\321#[S!\210`\202\271eb\210\311y\210`\321\312!\210`r&q\210:\203\312\325\326 \327 \"\210\330`\331\"\210'\203\352:\204\352\332r$q\210\f{)\"\"\210\202\"n\204\361\313\"\333$\f#\210\"\203\"\311#`\334 V\203\335y\210`\334 Y\203\336\337!\210#T#\202#y\210)%\203*`(\340p!\2056\341\340p!`\".\207" [nn calc-line-numbering calc-language bot top big-offset calc-force-refresh prefix-numeric-value big 1 0 nil calc-find-writable-buffer buffer-list error "No other buffer" calc-substack-height calc-cursor-stack-index looking-at "[0-9]+: *[^ \n]" " *[^ \n]" kill-region region-beginning region-end push-mark t calc-overwrite-string insert-buffer-substring mark -1 delete-char 4 get-buffer-window set-window-point eat-lnums n oldbuf thebuf newbuf overwrite-mode movept] 5] calc-quit t switch-to-buffer] 4 (#$ . 11914) "P"])
(defalias 'calc-overwrite-string #[(str eat-lnums) "\305\306\"\203
\307\310\311#	\203\307\312\"\305\313\"\203+\314\315!\203+`\310\225|\210c\207\310\211GW\205s\nH\211\316U\203h\nGSU\204l`\317\210\f`|\210m\203Y\320c\210\202\\\321u\210	\203d\n\312\\)\202l\322\321!\210\nT\211\202.)\207" [str eat-lnums i last-command-event pt string-match "\n\\'" substring 0 -1 4 "\\`[-+]?[0-9.]+\\(e-?[0-9]+\\)?\\'" looking-at "[-+]?[0-9.]+\\(e-?[0-9]+\\)?" 10 nil "\n" 1 self-insert-command] 5])
(defalias 'calc-find-writable-buffer #[(buf mode) "\205-\302\303\304@!\"\204%	\305U\203+\302\306\304@!\"\204%\307@!\204+\310A	\"\207@\207" [buf mode string-match "\\`\\( .*\\|\\*Calc.*\\)" buffer-name 0 "\\`\\*.*" get-buffer-window calc-find-writable-buffer] 4])
(defalias 'calc-edit #[(n) "\300\301`\"\210\302 \207" [calc-do #[nil "\306=\203	\307 \310\311V\312\311V\203\313\202\314\306V\203)\315!\202.\315\311[\"\")\316\317	\2068D\n\"\210
\205N
@\320\261\210
A\211\204@\310+\207" [n flag allow-ret calc-full-float-format calc-float-format list 0 calc-stack-size nil 1 mapcar #[(x) "\301\302\"\207" [x math-format-flat-expr 0] 3] #[(x) "\211\242\302=\262\203\f\303\304\305 \"\207" [x allow-ret vec t math-format-nice-expr frame-width] 3] calc-top-list calc-edit-mode calc-finish-stack-edit "\n"] 6] calc-show-edit-buffer] 3 nil "p"])
(defalias 'calc-alg-edit #[(str) "\301\302!\210\303 \210\304\261\210\305u\210\306\307!\207" [str calc-edit-mode (calc-finish-stack-edit 0) calc-show-edit-buffer "\n" -1 calc-set-command-flag do-edit] 2])
#@42 Keymap for use by the calc-edit command.
(defvar calc-edit-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\304#\210)\207" [map make-sparse-keymap define-key "\n" calc-edit-finish "
" calc-edit-return ""] 4) (#$ . 14979))
#@121 Calculator editing mode.  Press RET, LFD, or C-c C-c to finish.
To cancel the edit, simply kill the *Calc Edit* buffer.
(defalias 'calc-edit-mode #[(&optional handler allow-ret title) "\204\306\307!\210p\310\311!	q\210\312 \210\313!\210\314\211\315-\316.\317\320!\210\321\322!\210\n\321\323!\210\n\321\324!\210\325\326!\205@/\321\327!\210\321\330!\210\331\332 !\321\333!\2100\3261\334 \210)\335\336\337\326\211$\210\3402\206u2\206u\341\342\343!0\203\201\344\202\202\345\342\346!R\347\350\351\326\352\326\353\326&	c\210\321\354!\210`\211,*\207" [handler buf oldbuf calc-edit-mode-map buffer-read-only truncate-lines error "This command can be used only indirectly through calc-edit" get-buffer-create "*Calc Edit*" kill-all-local-variables use-local-map nil calc-edit-mode "Calc Edit" run-mode-hooks calc-edit-mode-hook make-local-variable calc-original-buffer calc-return-buffer calc-one-window one-window-p t calc-edit-handler calc-restore-trail get-buffer-window calc-trail-buffer calc-allow-ret erase-buffer add-hook kill-buffer-hook #[nil "\301\302\303!\210)\304\305!\207" [calc-edit-handler nil calc-edit-finish t message "(Canceled)"] 2] propertize "Calc Edit Mode. " format-message "Press `C-c C-c'" "" " or RET" " to finish, `C-x k RET' to cancel.\n\n" font-lock-face italic read-only rear-nonsticky front-sticky calc-edit-top major-mode mode-name pop-up-windows allow-ret inhibit-read-only title] 11 (#$ . 15235) nil])
(put 'calc-edit-mode 'mode-class 'special)
(defalias 'calc-show-edit-buffer #[nil "p\306\307!\203	\203\310\311\312!!\210\202/\n\203)\313\n\314H!\203)\315\313\n\314H!!\210\316\311\312!!\210\317 \320 W\203K\f\203K\313\321 !\211\203J\322
!\210)\323\324!\210b)\207" [buf pop-up-windows calc-embedded-info calc-return-buffer calc-display-trail win one-window-p t pop-to-buffer get-buffer-create "*Calc Edit*" get-buffer-window 1 select-window switch-to-buffer window-width frame-width calc-trail-buffer delete-window set-buffer-modified-p nil calc-edit-top] 5])
(defalias 'calc-edit-return #[nil "\301\300!\203
\203
\302 \207\303 \207" [calc-allow-ret boundp newline calc-edit-finish] 2 nil nil])
#@75 Finish calc-edit mode.  Parse buffer contents and push them on the stack.
(defalias 'calc-edit-finish #[(&optional keep) "\306\307!\210\310\301!\203(\310\302!\203(\310\303!\203(\310\311!\203(\310\304!\203(\312=\204,\313\314!\210p	\n\f \212\315!\203Lq\210\316=\204P\313\317!\210)!b\210\320 \203_\321	!\210\203m\322\323!\204m\324 \210\325!\203~\326\325!!\210\202\203\327!\210\"\203\220\330 !\210\202\225\331 !\210
\203\235\332\333!\210\306\334!-\207" [major-mode calc-original-buffer calc-return-buffer calc-one-window calc-restore-trail calc-edit-disp-trail message "Working..." boundp calc-edit-handler calc-edit-mode error "This command is valid only in buffers created by calc-edit" buffer-name calc-mode "Original calculator buffer has been corrupted" buffer-modified-p eval one-window-p t delete-window get-buffer-window select-window switch-to-buffer bury-buffer kill-buffer calc-do #[nil "\300\301\302\"\207" [calc-trail-display 1 t] 3] "" one-window return original buf calc-edit-top keep] 5 (#$ . 17416) "P"])
#@77 Cancel calc-edit mode.  Ignore the Calc Edit buffer and don't change stack.
(defalias 'calc-edit-cancel #[nil "\301\302 \210)\303\304!\207" [calc-edit-handler nil calc-edit-finish message "(Canceled)"] 2 (#$ . 18484) nil])
(defalias 'calc-finish-stack-edit #[(num) "pd{`\306
\250\203&
\307V\203&\310\311\"\211\203&	\312I\210\202\313!\210\306\314 \310\315\"\205<\316!*\211\242\317=\203Y\313\f!\210\nA@\\b\210\317\3208!\210\321\322!-\207" [calc-edit-top pos start str buf num nil 1 string-match "\n." 44 switch-to-buffer math-standard-ops "[^\n	 ]" math-read-exprs error 2 calc-do #[nil "9\203	@L\210\305!\207\n\203\306\307\310\"\210	\205=\311=\203%\312\202&\f\313Y\2035\314\315	#\202<\314\307\315	[$)\207" [num vals calc-edit-disp-trail last-command-event calc-simplify-mode calc-refresh-evaltos calc-trail-display 1 t 10 none 0 calc-enter-result "edit"] 5] calc-original-buffer math-expr-opers calc-language vals] 5])
(provide 'calc-yank)
Zerion Mini Shell 1.0