WWWWWW

Current Directory: /usr/share/emacs/24.3/lisp
Viewing File: /usr/share/emacs/24.3/lisp/thingatpt.elc
;ELC
;;; Compiled by mockbuild@buildfarm01-new.corp.cloudlinux.com on Tue Nov 11 12:48:46 2025
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/thingatpt.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.

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


(provide 'thingatpt)
#@251 Move forward to the end of the Nth next THING.
THING should be a symbol specifying a type of syntactic entity.
Possibilities include `symbol', `list', `sexp', `defun',
`filename', `url', `email', `word', `sentence', `whitespace',
`line', and `page'.
(defalias 'forward-thing #[(thing &optional n) "\301N\206\f\303\304\305\"!\306	!\203	\n\206\307!\202!\310\311\")\207" [thing forward-op n intern-soft format "forward-%s" functionp 1 error "Can't determine how to move over a %s"] 4 (#$ . 574)])
#@441 Determine the start and end buffer locations for the THING at point.
THING should be a symbol specifying a type of syntactic entity.
Possibilities include `symbol', `list', `sexp', `defun',
`filename', `url', `email', `word', `sentence', `whitespace',
`line', and `page'.

See the file `thingatpt.el' for documentation on how to define a
valid THING.

Return a cons cell (START . END) giving the start and end
positions of the thing found.
(defalias 'bounds-of-thing-at-point #[(thing) "\302N\203\302N \207`\303\304\305\217)\207" [thing orig bounds-of-thing-at-point nil (byte-code "\212\306N\206\307 \210\310N\206\311 \210`\211\nX\2039\306N\206\"\312 \210`\nX\2055	W\2055	B)\202q\nb\210\310N\206C\313 \210\306N\206L\314 \210`\310N\206V\315 \210`\f\nX\205p\n
X\205p\f
W\205p\f
B**\207" [thing beg orig real-end real-beg end end-op #[nil "\301\302\"\207" [thing forward-thing 1] 3] beginning-op #[nil "\301\302\"\207" [thing forward-thing -1] 3] #[nil "\301\302\"\207" [thing forward-thing 1] 3] #[nil "\301\302\"\207" [thing forward-thing -1] 3] #[nil "\301\302\"\207" [thing forward-thing 1] 3] #[nil "\301\302\"\207" [thing forward-thing -1] 3]] 4) ((error))] 3 (#$ . 1085)])
#@332 Return the THING at point.
THING should be a symbol specifying a type of syntactic entity.
Possibilities include `symbol', `list', `sexp', `defun',
`filename', `url', `email', `word', `sentence', `whitespace',
`line', `number', and `page'.

See the file `thingatpt.el' for documentation on how to define
a symbol as a valid THING.
(defalias 'thing-at-point #[(thing) "\302N\203\302N \207\303!\211\205	@	A{)\207" [thing bounds thing-at-point bounds-of-thing-at-point] 3 (#$ . 2309)])
#@105 Move point to the beginning of THING.
The bounds of THING are determined by `bounds-of-thing-at-point'.
(defalias 'beginning-of-thing #[(thing) "\302!\211\204
\303\304\"\210	@b)\207" [thing bounds bounds-of-thing-at-point error "No %s here"] 4 (#$ . 2807)])
#@99 Move point to the end of THING.
The bounds of THING are determined by `bounds-of-thing-at-point'.
(defalias 'end-of-thing #[(thing) "\302!\211\204
\303\304\"\210	Ab)\207" [thing bounds bounds-of-thing-at-point error "No %s here"] 4 (#$ . 3075)])
(put 'line 'beginning-op #[nil "n\203\300y\207\301 \207" [-1 beginning-of-line] 1])
#@73 Return non-nil if point is in a string.
[This is an internal function.]
(defalias 'in-string-p #[nil "`\212\301 \210\302\303`\"8*\207" [orig beginning-of-defun 3 parse-partial-sexp] 4 (#$ . 3417)])
#@76 Move point to the end of the current sexp.
[This is an internal function.]
(defalias 'end-of-sexp #[nil "\301fz\211\302=\204\303=\203\304 \203\305u\202\306\305!)\207" [char-syntax nil 41 34 in-string-p 1 forward-sexp] 3 (#$ . 3623)])
(put 'sexp 'end-op 'end-of-sexp)
#@82 Move point to the beginning of the current sexp.
[This is an internal function.]
(defalias 'beginning-of-sexp #[nil "`Sfz\211\301=\204\302=\203\303 \203\304u\202\305\304!)\207" [char-syntax 40 34 in-string-p -1 forward-sexp] 3 (#$ . 3906)])
(byte-code "\300\301\302\303#\210\300\304\305\306#\207" [put sexp beginning-op beginning-of-sexp list bounds-of-thing-at-point thing-at-point-bounds-of-list-at-point] 4)
#@97 Return the bounds of the list at point.
[Internal function used by `bounds-of-thing-at-point'.]
(defalias 'thing-at-point-bounds-of-list-at-point #[nil "\212`\302\303\304\217\302\305\306\217+\207" [beg opoint nil (byte-code "\300\301!\210`\207" [up-list -1] 2) ((error)) (byte-code "\203\303 \210`B\207\303 \210`\304 \210\n`Y\205\n	B)\207" [beg end opoint forward-sexp backward-sexp] 2) ((error))] 4 (#$ . 4333)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\301\306\305#\207" [put defun beginning-op beginning-of-defun end-op end-of-defun forward-op] 4)
#@36 Characters allowable in filenames.
(defvar thing-at-point-file-name-chars "-~/[:alnum:]_.${}#%,:" (#$ . 4917))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put filename end-op #[nil "\301\302\303Q\304\305#\207" [thing-at-point-file-name-chars re-search-forward "\\=[" "]*" nil t] 4] beginning-op #[nil "\301\302\303Q\304\305#\203\304u\207eb\207" [thing-at-point-file-name-chars re-search-backward "[^" "]" nil t] 4]] 4)
#@87 A regular expression probably matching the host and filename or e-mail part of a URL.
(defvar thing-at-point-url-path-regexp "[^]	\n \"'<>[^`{}]*[^]	\n \"'<>[^`{}.,;]+" (#$ . 5359))
#@155 A regular expression probably matching a URL without an access scheme.
Hostname matching is stricter in this case than for
``thing-at-point-url-regexp''.
(defvar thing-at-point-short-url-regexp (concat "[-A-Za-z0-9]+\\.[-A-Za-z0-9.]+" thing-at-point-url-path-regexp) (#$ . 5548))
#@44 Uniform Resource Identifier (URI) Schemes.
(defvar thing-at-point-uri-schemes '("ftp://" "http://" "gopher://" "mailto:" "news:" "nntp:" "telnet://" "wais://" "file:/" "prospero:" "z39.50s:" "z39.50r:" "cid:" "mid:" "vemmi:" "service:" "imap:" "nfs:" "acap:" "rtsp:" "tip:" "pop:" "data:" "dav:" "opaquelocktoken:" "sip:" "tel:" "fax:" "modem:" "ldap:" "https://" "soap.beep:" "soap.beeps:" "urn:" "go:" "afs:" "tn3270:" "mailserver:" "crid:" "dict:" "dns:" "dtn:" "h323:" "im:" "info:" "ipp:" "iris.beep:" "mtqp:" "mupdate:" "pres:" "sips:" "snmp:" "tag:" "tftp:" "xmlrpc.beep:" "xmlrpc.beeps:" "xmpp:" "snews:" "irc:" "mms://" "mmsh://") (#$ . 5834))
#@56 A regular expression probably matching a complete URL.
(defvar thing-at-point-url-regexp (byte-code "\302\303\304\305#\306	R\207" [thing-at-point-uri-schemes thing-at-point-url-path-regexp "\\<\\(" mapconcat identity "\\|" "\\)"] 5) (#$ . 6493))
#@111 A regular expression matching a URL marked up per RFC1738.
This may contain whitespace (including newlines) .
(defvar thing-at-point-markedup-url-regexp "<URL:[^>]+>" (#$ . 6747))
(put 'url 'bounds-of-thing-at-point 'thing-at-point-bounds-of-url-at-point)
(defalias 'thing-at-point-bounds-of-url-at-point #[nil "\305!\211\204\305\n!\205#\306\224\306\225	\203\f\307\\S\f*B)\207" [thing-at-point-markedup-url-regexp strip thing-at-point-url-regexp end beginning thing-at-point-looking-at 0 5] 3])
(put 'url 'thing-at-point 'thing-at-point-url-at-point)
#@298 Return the URL around or before point.

Search backwards for the start of a URL ending at or after point.  If
no URL found, return nil.  The access scheme will be prepended if
absent: "mailto:" if the string contains "@", "ftp://" if it
starts with "ftp" and not "ftp:/", or "http://" by default.
(defalias 'thing-at-point-url-at-point #[nil "\306\307\211\310!\211\204\310\f!\204\310
!\211\205n\311\312\224\312\225\"\203,\n\313\314O\315\316\n\"\203=\317\306\320\211\n$\202,	\203f\315\321\n\"\203L\306\202c\315\322\n\"\203W\323\202c\315\324\n\"\203b\325\202c\326\nP\n\306\230?\205n\n+\207" [strip short url thing-at-point-markedup-url-regexp thing-at-point-url-regexp thing-at-point-short-url-regexp "" nil thing-at-point-looking-at buffer-substring-no-properties 0 5 -1 string-match "[ 	\n
]+" replace-match t "^[a-zA-Z]+:" "@" "mailto:" "^ftp" "ftp://" "http://"] 5 (#$ . 7318)])
#@139 Return non-nil if point is in or just after a match for REGEXP.
Set the match data from the earliest such match ending at or after
point.
(defalias 'thing-at-point-looking-at #[(regexp) "\212`\303\304\n!\203\305\225	Y\203`\306\n\303\307#\210\310\n\303\311#\203<\305\224	V\204\304\n!\203<\305\225	Y\203<`\211\204\205cb\210o\204]\312u\210\304\n!\203]\305\225	Y\203]`\211\204Cb\210\304\n!+\207" [match old-point regexp nil looking-at 0 re-search-forward limit re-search-backward t -1] 4 (#$ . 8233)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put url end-op #[nil "\301 \211\203
Ab\202\302\303!)\207" [bounds thing-at-point-bounds-of-url-at-point error "No URL here"] 3] beginning-op #[nil "\301 \211\203
@b\202\302\303!)\207" [bounds thing-at-point-bounds-of-url-at-point error "No URL here"] 3]] 4)
#@151 A regular expression probably matching an email address.
This does not match the real name portion, only the address, optionally
with angle brackets.
(defvar thing-at-point-email-regexp "<?[-+_.~a-zA-Z][-+_.~:a-zA-Z0-9]*@[-.a-zA-Z0-9]+>?" (#$ . 9087))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put email bounds-of-thing-at-point #[nil "\304!\211\205\305\224\305\225\211\n*B)\207" [thing-at-point-email-regexp thing end beginning thing-at-point-looking-at 0] 3] thing-at-point #[nil "\301\302!\211\205\303@A\")\207" [boundary-pair bounds-of-thing-at-point email buffer-substring-no-properties] 4]] 4)
#@263 Move point to the end of the next sequence of whitespace chars.
Each such sequence may be a single newline, or a sequence of
consecutive space and/or tab characters.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.
(defalias 'forward-whitespace #[(arg) "\301!\203
\302\303\304\305$\207\306W\205.\307\303\304\305#\203'\306\224f\310=\204'\311\304x\210T\211\202\207" [arg natnump re-search-forward "[ 	]+\\|\n" nil move 0 re-search-backward 10 " 	"] 6 (#$ . 9720) "p"])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put buffer end-op #[nil "db\207" #1=[] 1] beginning-op #[nil "eb\207" #1# 1]] 4)
#@273 Move point to the next position that is the end of a symbol.
A symbol is any sequence of characters that are in either the
word constituent or symbol constituent syntax class.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.
(defalias 'forward-symbol #[(arg) "\301!\203
\302\303\304\305$\207\306W\205&\307\303\304\305#\203\310\311!\210T\211\202\207" [arg natnump re-search-forward "\\(\\sw\\|\\s_\\)+" nil move 0 re-search-backward skip-syntax-backward "w_"] 6 (#$ . 10390) "p"])
#@156 Move point past all characters with the same syntax class.
With prefix argument ARG, do it ARG times if positive, or move
backwards ARG times if negative.
(defalias 'forward-same-syntax #[(&optional arg) "\204\301\302W\203\303\304`Sfz!!\210T\211\202\302V\2051\305\304\306fz!!\210S\211\202\207" [arg 1 0 skip-syntax-backward char-to-string skip-syntax-forward nil] 4 (#$ . 10935) "p"])
#@50 Return the word at point.  See `thing-at-point'.
(defalias 'word-at-point #[nil "\300\301!\207" [thing-at-point word] 2 (#$ . 11343)])
#@54 Return the sentence at point.  See `thing-at-point'.
(defalias 'sentence-at-point #[nil "\300\301!\207" [thing-at-point sentence] 2 (#$ . 11484)])
#@85 Read a Lisp expression from STR.
Signal an error if the entire string was not used.
(defalias 'read-from-whole-string #[(str) "\303!\304\305\306\217\211\203\307\310!\202	@*\207" [str read-data more-left read-from-string nil (byte-code "\302	A\303O!\210\304\207" [str read-data read-from-string nil t] 4) ((end-of-file)) error "Can't read whole string"] 4 (#$ . 11637)])
(defalias 'form-at-point #[(&optional thing pred) "\302\303\304\217	\203	!\205)\207" [sexp pred nil (byte-code "\301\302\206\303!!\207" [thing read-from-whole-string thing-at-point sexp] 3) ((error))] 3])
#@52 Return the sexp at point, or nil if none is found.
(defalias 'sexp-at-point #[nil "\300\301!\207" [form-at-point sexp] 2 (#$ . 12236)])
#@54 Return the symbol at point, or nil if none is found.
(defalias 'symbol-at-point #[nil "\301\302!\211\205\303!)\207" [thing thing-at-point symbol intern] 3 (#$ . 12378)])
#@54 Return the number at point, or nil if none is found.
(defalias 'number-at-point #[nil "\300\301\302\"\207" [form-at-point sexp numberp] 3 (#$ . 12558)])
(put 'number 'thing-at-point 'number-at-point)
#@57 Return the Lisp list at point, or nil if none is found.
(defalias 'list-at-point #[nil "\300\301\302\"\207" [form-at-point list listp] 3 (#$ . 12764)])
F1l3 Manager
