;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:07:44 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/org/org-macs.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 "\301\302!\204
\303\302\304\305B\"\210\306Y\203!\303\307\310\"\210\311\307\312\313#\210\202,\303\307\314\"\210\311\307\312\313#\210\301\207" [emacs-major-version fboundp declare-function defalias macro #[(fn file &optional arglist fileonly) "\300\207" [nil] 1] 23 org-char-to-string #[(c) "\301!\207" [c char-to-string] 2 "Defsubst to decode UTF-8 character values in emacs 23 and beyond."] put byte-optimizer byte-compile-inline-expand #[(c) "\301\302\303\"!\207" [c string decode-char ucs] 4 "Defsubst to decode UTF-8 character values in emacs 22."]] 4)
(defalias 'org-with-gensyms '(macro . #[(symbols &rest body) "\302\303\304\"	BB\207" [symbols body let mapcar #[(s) "\301\302\303\304\305DDEDD\207" [s make-symbol concat "--" symbol-name quote] 7]] 4]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-with-gensyms edebug-form-spec (sexp body) lisp-indent-function 1] 4)
(defalias 'org-called-interactively-p '(macro . #[(&optional kind) "\303V\204\303Y\203	\304Y\203\305\306\nDD\207\307\207" [emacs-major-version emacs-minor-version kind 23 2 with-no-warnings called-interactively-p (interactive-p)] 3]))
(byte-code "\302\303\304\305#\210\306\307!\204+\310W\204\310U\203+	\311W\203+\312\307\313\314B\"\210\302\307\304\315#\210\302\207" [emacs-major-version emacs-minor-version put org-called-interactively-p edebug-form-spec (&optional ("quote" symbolp)) fboundp with-silent-modifications 23 2 defalias macro #[(&rest body) "\301B\207" [body org-unmodified] 2] (body)] 4)
#@58 Return the value of symbol VAR if it is bound, else nil.
(defalias 'org-bound-and-true-p '(macro . #[(var) "\301\302\303DDE\207" [var and boundp quote] 4 (#$ . 2086)]))
(put 'org-bound-and-true-p 'edebug-form-spec '(symbolp))
#@43 Is S a string with a non-white character?
(defalias 'org-string-nw-p #[(s) ";\205
\301\302\"\205
\207" [s org-string-match-p "\\S-"] 3 (#$ . 2320)])
#@83 If V not nil, and also not the string "nil", then return V.
Otherwise return nil.
(defalias 'org-not-nil #[(v) "\205\f\301\232?\205\f\207" [v "nil"] 2 (#$ . 2480)])
#@90 Execute body without changing `buffer-modified-p'.
Also, do not record undo information.
(defalias 'org-unmodified '(macro . #[(&rest body) "\301\302\303\304\305BBED\207" [body set-buffer-modified-p prog1 (buffer-modified-p) let ((buffer-undo-list t) (inhibit-modification-hooks t))] 6 (#$ . 2656)]))
(put 'org-unmodified 'edebug-form-spec '(body))
#@52 Substitute posix classes in regular expression RE.
(defalias 'org-substitute-posix-classes #[(re) "\303 \304\216\305\306	\"\203\307\310\311\211	$\202\305\312	\"\203)\307\310\311\211	$\202\305\313	\"\203:\307\314\311\211	$\202)\305\315	\"\203K\307\316\311\211	$\202:	+\207" [re ss save-match-data-internal match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) string-match "\\[:alnum:\\]" replace-match "a-zA-Z0-9" t "\\[:word:\\]" "\\[:alpha:\\]" "a-zA-Z" "\\[:punct:\\]" "
-@[-`{-~"] 5 (#$ . 3012)])
#@46 Replace posix classes in regular expression.
(defalias 'org-re '(macro . #[(s) "\207" [s] 1 (#$ . 3580)]))
(put 'org-re 'edebug-form-spec '(form))
(defalias 'org-preserve-lc '(macro . #[(&rest body) "\303\304!\303\305!\306	\307B\310BD\311\312\nB\313	D\314DFE*\207" [col line body make-symbol "--line" "--col" let ((org-current-line)) ((current-column)) unwind-protect progn org-goto-line org-move-to-column] 7]))
(put 'org-preserve-lc 'edebug-form-spec '(body))
#@67 Run BODY while preserving the buffer's `buffer-modified-p' state.
(defalias 'org-with-buffer-modified-unmodified '(macro . #[(&rest body) "\302\303!\304\305BC\306\307	B\310DEE)\207" [was-modified body make-symbol "--was-modified" let ((buffer-modified-p)) unwind-protect progn set-buffer-modified-p] 6 (#$ . 4053)]))
(defalias 'org-without-partial-completion '(macro . #[(&rest body) "\301\302\303\304\305BB\306BBBBB\207" [body if (and (boundp 'partial-completion-mode) partial-completion-mode (fboundp 'partial-completion-mode)) unwind-protect progn (partial-completion-mode -1) ((partial-completion-mode 1))] 6]))
(put 'org-without-partial-completion 'edebug-form-spec '(body))
#@480 Add '(intangible t) to PROPS if Emacs version is earlier than Emacs 22.
In Emacs 21, invisible text is not avoided by the command loop, so the
intangible property is needed to make sure point skips this text.
In Emacs 22, this is not necessary.  The intangible text property has
led to problems with flyspell.  These problems are fixed in flyspell.el,
but we still avoid setting the property in Emacs 22 and later.
We use a macro so that the test can happen at compilation time.
(defalias 'org-maybe-intangible '(macro . #[(props) "\302W\203\303\304	E\207	\207" [emacs-major-version props 22 append '(intangible t)] 3 (#$ . 4745)]))
#@75 Move to buffer and point of point-or-marker POM for the duration of BODY.
(defalias 'org-with-point-at '(macro . #[(pom &rest body) "\303\304!\305	DC\306\307\310D\311\312DDE\306\313\314\315BBD\nBBEE)\207" [mpom pom body make-symbol "--mpom" let save-excursion if markerp set-buffer marker-buffer goto-char or ((point))] 9 (#$ . 5387)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-with-point-at edebug-form-spec (form body) lisp-indent-function 1] 4)
(defalias 'org-no-warnings '(macro . #[(&rest body) "\301\302!\203\n\302\202\303B\207" [body fboundp with-no-warnings progn] 2]))
(put 'org-no-warnings 'edebug-form-spec '(body))
#@69 Execute BODY if there is no `org-protected' text property at point.
(defalias 'org-if-unprotected '(macro . #[(&rest body) "\301\302BB\207" [body unless (get-text-property (point) 'org-protected)] 3 (#$ . 6053)]))
(put 'org-if-unprotected 'edebug-form-spec '(body))
#@71 Execute BODY if there is no `org-protected' text property at point-1.
(defalias 'org-if-unprotected-1 '(macro . #[(&rest body) "\301\302BB\207" [body unless (get-text-property (1- (point)) 'org-protected)] 3 (#$ . 6326)]))
(put 'org-if-unprotected-1 'edebug-form-spec '(body))
#@67 Execute BODY if there is no `org-protected' text property at POS.
(defalias 'org-if-unprotected-at '(macro . #[(pos &rest body) "\302\303\304BB	BB\207" [pos body unless get-text-property ('org-protected)] 4 (#$ . 6610)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-if-unprotected-at edebug-form-spec (form body) lisp-indent-function 1] 4)
#@62 Like re-search-forward, but stop only in unprotected places.
(defalias 'org-re-search-forward-unprotected #[(&rest args) "\300\301\215\207" [exit (byte-code "\301\302\"\204\f\303\304\305\"\210\306\307\224\310\"\204\303\304`\"\210\202" [args apply re-search-forward throw exit nil get-text-property 0 org-protected] 3)] 2 (#$ . 6978)])
#@63 Execute BODY while recording undo information in two buffers.
(defalias 'org-with-remote-undo '(macro . #[(_buffer &rest _body) "\306\307!\306\310!\306\311!\306\312!\306\313!\306\314!\306\315!\306\316!$%\317%\320B$\321B
\322B\f&D\323B\n\324&\325BBD	\257\326'\327\330\331	\332\324
\333BBE\332\n\324\f\334BBE\257\327\335	E\336	\324
\337BBE\336\324\f\340BBE\341\342$%
	\f\257\343BB\257FC\".BB\207" [c2 c1 undo2 undo1 buf2 buf1 make-symbol "--cline" "--cmd" "--buf1" "--buf2" "--undo1" "--undo2" "--c1" "--c2" let ((org-current-line)) (this-command) ((current-buffer)) (buffer-undo-list) with-current-buffer (buffer-undo-list) append when org-agenda-allow-remote-undo setq org-verify-change-for-undo (buffer-undo-list) (buffer-undo-list) or and ((undo-boundary)) ((undo-boundary)) push list (org-agenda-undo-list) cmd cline _buffer _body] 19 (#$ . 7325)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-with-remote-undo edebug-form-spec (form body) lisp-indent-function 1] 4)
#@29 Inhibit read-only for BODY.
(defalias 'org-no-read-only '(macro . #[(&rest body) "\301\302BB\207" [body let ((inhibit-read-only t))] 3 (#$ . 8349)]))
(put 'org-no-read-only 'edebug-form-spec '(body))
#@66 Properties to remove when a string without properties is wanted.
(defconst org-rm-props '(invisible t face t keymap t intangible t mouse-face t rear-nonsticky t mouse-map t fontified t org-emphasis t) (#$ . 8556))
(defalias 'org-match-string-no-properties #[(num &optional string) "\302	\"\207" [num string match-string-no-properties] 3])
(put 'org-match-string-no-properties 'byte-optimizer 'byte-compile-inline-expand)
#@124 Remove all text properties from string S.
When RESTRICTED is non-nil, only remove the properties listed
in `org-rm-props'.
(defalias 'org-no-properties #[(s &optional restricted) "\303\304!\203\304\305G\306$\210\202(	\203 \307\305G\n$\210\202(\304\305G\306$\210\207" [s restricted org-rm-props fboundp set-text-properties 0 nil remove-text-properties] 5 (#$ . 8985)])
(put 'org-no-properties 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-get-alist-option #[(option key) "\303=\203\303\207	\303=\203\303\207\304	\"\203\304	\"A\207\305	\236A\211<\203.\306\307\n\"\202/\n)\207" [key option r t assoc default delq nil] 4])
(put 'org-get-alist-option 'byte-optimizer 'byte-compile-inline-expand)
#@314 Check if external program CMD for USE exists, error if not.
When the program does exist, return its path.
When it does not exist and NO-ERROR is set, return nil.
Otherwise, throw an error.  The optional argument USE can describe what this
program is needed for, so that the error message can be more informative.
(defalias 'org-check-external-command #[(cmd &optional use no-error) "\303!\206	?\205\304\305\n\203\306\307\n\"\202\310#\207" [cmd no-error use executable-find error "Can't find `%s'%s" format " (%s)" ""] 6 (#$ . 9721)])
(put 'org-check-external-command 'byte-optimizer 'byte-compile-inline-expand)
#@191 Modified `buffer-invisibility-spec' for Emacs 21.
Some ops with invisible text do not work correctly on Emacs 21.  For these
we turn off invisibility temporarily.  Use this in a `let' form.
(defalias 'org-inhibit-invisibility #[nil "\302W?\205	\207" [emacs-major-version buffer-invisibility-spec 22] 2 (#$ . 10350)])
(put 'org-inhibit-invisibility 'byte-optimizer 'byte-compile-inline-expand)
#@55 Make VAR local in current buffer and set it to VALUE.
(defalias 'org-set-local #[(var value) "\302!	L\207" [var value make-local-variable] 2 (#$ . 10752)])
(put 'org-set-local 'byte-optimizer 'byte-compile-inline-expand)
#@34 Return the last element of LIST.
(defalias 'org-last #[(list) "\301!@\207" [list last] 2 (#$ . 10980)])
(put 'org-last 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-let #[(list &rest body) "\302\303	BB!\207" [list body eval let] 4])
(put 'org-let 'lisp-indent-function 1)
(defalias 'org-let2 #[(list1 list2 &rest body) "\303\304\304	\nBBCBB!\207" [list1 list2 body eval let] 6])
(put 'org-let2 'lisp-indent-function 2)
#@61 Call COMMAND interactively, but pretend prefix arg was ARG.
(defalias 'org-call-with-arg #[(command arg) "\303\n!)\207" [arg current-prefix-arg command call-interactively] 2 (#$ . 11422)])
(put 'org-call-with-arg 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-current-line #[(&optional pos) "\212\203b\210n\203\301\202\302\303\301`\"\\)\207" [pos 1 0 count-lines] 4])
(put 'org-current-line 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-goto-line #[(N) "\214~\210eb\210Sy)\207" [N] 1])
(put 'org-goto-line 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-current-line-string #[(&optional to-here) "\301 \203\n`\202\f\302 {\207" [to-here point-at-bol point-at-eol] 2])
(put 'org-current-line-string 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'org-pos-in-match-range #[(pos n) "\224\205\224	X\205\225	Y\207" [n pos] 2])
(put 'org-pos-in-match-range 'byte-optimizer 'byte-compile-inline-expand)
#@69 Establish autoload for all FUNCTIONS in FILE, if not bound already.
(defalias 'org-autoload #[(file functions) "\304\305\"\306\211A@\211\205!\307	!\204\310	\n\311$\210\202*\207" [file f d functions format "Documentation will be available after `%s.el' is loaded." nil fboundp autoload t] 5 (#$ . 12391)])
#@50 Looking-at at the beginning of the current line.
(defalias 'org-match-line #[(re) "\212\301 b\210\302!)\207" [re point-at-bol looking-at] 2 (#$ . 12714)])
#@76 Delete PROPERTY from PLIST.
This is in contrast to merely setting it to 0.
(defalias 'org-plist-delete #[(plist property) "\304	\203!\n	@=\204\305	@	A@#	\211AA)\211\204)\207" [p plist property x nil plist-put] 5 (#$ . 12876)])
#@72 Like `replace-match', but add the text properties found original text.
(defalias 'org-replace-match-keep-properties #[(newtext &optional fixedcase literal string) "\304\305\306\224	\"\"\307\n	$\207" [newtext string fixedcase literal org-add-props text-properties-at 0 replace-match] 5 (#$ . 13120)])
#@296 Save and restore outline visibility around BODY.
If USE-MARKERS is non-nil, use markers for the positions.
This means that the buffer may change while running BODY,
but it also means that the buffer should stay alive
during the operation, because otherwise all these markers will
point nowhere.
(defalias 'org-save-outline-visibility '(macro . #[(use-markers &rest body) "\304\305!\304\306!\307	\310\nDDD\311\312\313\312BE\314	DE\315\n\316\317	EEEF*\207" [rtn data use-markers body make-symbol "--data" "--rtn" let org-outline-overlay-data unwind-protect progn setq org-set-outline-overlay-data when mapc (lambda (c) (and (markerp (car c)) (move-marker (car c) nil)) (and (markerp (cdr c)) (move-marker (cdr c) nil)))] 9 (#$ . 13431)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-save-outline-visibility lisp-indent-function 1 edebug-form-spec (form body)] 4)
#@53 Execute body while temporarily widening the buffer.
(defalias 'org-with-wide-buffer '(macro . #[(&rest body) "\301\302\303BBD\207" [body save-excursion save-restriction (widen)] 4 (#$ . 14325)]))
(put 'org-with-wide-buffer 'edebug-form-spec '(body))
#@53 Execute BODY with limited number of outline levels.
(defalias 'org-with-limited-levels '(macro . #[(&rest body) "\301\302BB\207" [body let* ((org-called-with-limited-levels t) (org-outline-regexp (org-get-limited-outline-regexp)) (outline-regexp org-outline-regexp) (org-outline-regexp-bol (concat "^" org-outline-regexp)))] 3 (#$ . 14582)]))
(put 'org-with-limited-levels 'edebug-form-spec '(body))
#@119 Return outline-regexp with limited number of levels.
The number of levels is controlled by `org-inlinetask-min-level'
(defalias 'org-get-limited-outline-regexp #[nil "\305\306!\203\f\307\310!\204\207	S\203\n\311_S\202\n\312\313\f\"*\207" [org-outline-regexp org-inlinetask-min-level limit-level org-odd-levels-only nstars derived-mode-p org-mode featurep org-inlinetask 2 format "\\*\\{1,%d\\} "] 3 (#$ . 14990)])
#@50 Compatibility function replacing format-seconds.
(defalias 'org-format-seconds #[(string seconds) "\302\303!\203\303	\"\207\304\305	!\"\207" [string seconds fboundp format-seconds format-time-string seconds-to-time] 4 (#$ . 15421)])
(defalias 'org-eval-in-environment '(macro . #[(environment form) "\302\303\304\305	DFD\207" [environment form eval list 'let quote] 6]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put org-eval-in-environment edebug-form-spec (form form) lisp-indent-function 1] 4)
#@175 Return alist based on FLAT.
FLAT is a list with alternating symbol names and values.  The
returned alist is a list of lists with the symbol name in car and
the value in cdr.
(defalias 'org-make-parameter-alist #[(flat) "\205@\211A@)D\302\211AA)!B\207" [flat x org-make-parameter-alist] 4 (#$ . 15945)])
(provide 'org-macs)