%PDF- %PDF- Mini Shell
Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/
Current File : //usr/local/share/emacs/27.2/lisp/thingatpt.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.

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


(provide 'thingatpt)
#@283 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', `uuid', `word', `sentence', `whitespace',
`line', and `page'.

(fn THING &optional N)
(defalias 'forward-thing #[513 "\300N\206\f\301\302\303\"!\304!\203\211\206\305!\202 \306\307\"\207" [forward-op intern-soft format "forward-%s" functionp 1 error "Can't determine how to move over a %s"] 6 (#$ . 430)])
#@461 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', `uuid', `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.

(fn THING)
(defalias 'bounds-of-thing-at-point #[257 "\211\300N\203\211\300N \207`\3011\310\212\302N\206#\303\304\305\306\307!\310\"\311$ \210\312N\2067\303\304\305\306\307!\313\"\311$ \210`\211X\203i\302N\206R\303\304\305\306\307!\314\"\311$ \210`X\205dW\205dB\262\202\301b\210\312N\206~\303\304\305\306\307!\315\"\311$ \210\302N\206\222\303\304\305\306\307!\316\"\311$ \210`\312N\206\247\303\304\305\306\307!\317\"\311$ \210`\211X\205\277X\205\277\211W\205\277\211B\266\202\262)0\202\312\210\320\207" [bounds-of-thing-at-point (error) end-op make-byte-code 0 "\301\300\302\"\207" vconcat vector [forward-thing 1] 3 beginning-op [forward-thing -1] [forward-thing 1] [forward-thing -1] [forward-thing 1] [forward-thing -1] nil] 10 (#$ . 949)])
#@475 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', `uuid', `word', `sentence', `whitespace',
`line', `number', and `page'.

When the optional argument NO-PROPERTIES is non-nil,
strip text properties from the return value.

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

(fn THING &optional NO-PROPERTIES)
(defalias 'thing-at-point #[513 "\300N\203
\300N \202\301!\211\205\211@A{\262\211\2031\2031\302!\2031\303\304G\305$\210\211\207" [thing-at-point bounds-of-thing-at-point sequencep set-text-properties 0 nil] 8 (#$ . 2199)])
#@117 Move point to the beginning of THING.
The bounds of THING are determined by `bounds-of-thing-at-point'.

(fn THING)
(defalias 'beginning-of-thing #[257 "\300!\211\204\f\301\302\"\210\211@b\207" [bounds-of-thing-at-point error "No %s here"] 5 (#$ . 2920)])
#@111 Move point to the end of THING.
The bounds of THING are determined by `bounds-of-thing-at-point'.

(fn THING)
(defalias 'end-of-thing #[257 "\300!\211\204\f\301\302\"\210\211Ab\207" [bounds-of-thing-at-point error "No %s here"] 5 (#$ . 3186)])
(put 'line 'beginning-op #[0 "n\203\300y\207\301 \207" [-1 beginning-of-line] 1])
#@41 Return non-nil if point is in a string.
(defalias 'in-string-p #[0 "`\212\300 \210\301\302`\"8)\207" [beginning-of-defun 3 parse-partial-sexp] 5 (#$ . 3523)])
(make-obsolete 'in-string-p "use (nth 3 (syntax-ppss)) instead." "25.1")
#@44 Move point to the end of the current sexp.
(defalias 'thing-at-point--end-of-sexp #[0 "\300`!\211\301=\204\211\302=\203\303\304 8\203\305u\202)\3061&\307\305!0\202)\310\262\207" [syntax-after 41 34 3 syntax-ppss 1 (scan-error) forward-sexp nil] 3 (#$ . 3762)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\306\307\310\302#\207" [defalias end-of-sexp thing-at-point--end-of-sexp "This is an internal thingatpt function and should not be used." make-obsolete "25.1" put sexp end-op] 4)
#@50 Move point to the beginning of the current sexp.
(defalias 'thing-at-point--beginning-of-sexp #[0 "`Sfz\211\300=\204\211\301=\203\302\303 8\203\304u\202\305\304!\207" [40 34 3 syntax-ppss -1 forward-sexp] 3 (#$ . 4272)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\210\306\307\310\302#\210\306\311\312\313#\207" [defalias beginning-of-sexp thing-at-point--beginning-of-sexp "This is an internal thingatpt function and should not be used." make-obsolete "25.1" put sexp beginning-op list bounds-of-thing-at-point thing-at-point-bounds-of-list-at-point] 4)
#@155 Return the bounds of the list at point.
Prefer the enclosing list with fallback on sexp at point.
[Internal function used by `bounds-of-thing-at-point'.]
(defalias 'thing-at-point-bounds-of-list-at-point #[0 "\212\3001\f\301\302!0\202\210\202&\203&\3031!`\304 \210`B0\202>\210\305\202>\306\307!\211\205<\211@`X\205<`AW\205<\211\262)\207" [(error) up-list -1 (error) forward-sexp nil bounds-of-thing-at-point sexp] 3 (#$ . 4849)])
(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)
#@116 Define THING as a sequence of CHARS.
E.g.:
(define-thing-chars twitter-screen-name "[:alnum:]_")

(fn THING CHARS)
(defalias 'define-thing-chars '(macro . #[514 "\300\301\302D\303\304\305\306\307\310	\311BBB\312BBEF\301\302D\313\304\305\314\315\307\316\317BBB\320BB\321BBEFE\207" [progn put quote 'end-op lambda nil re-search-forward concat "\\=[" ("]*") (nil t) 'beginning-op if re-search-backward "[^" ("]") (nil t) ((forward-char) (goto-char (point-min)))] 15 (#$ . 5454)]))
#@36 Characters allowable in filenames.
(defvar thing-at-point-file-name-chars "-~/[:alnum:]_.${}#%,:" (#$ . 5943))
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put filename end-op #[0 "\301\302\303Q\304\305#\207" [thing-at-point-file-name-chars re-search-forward "\\=[" "]*" nil t] 4] beginning-op #[0 "\301\302\303Q\304\305#\203\304u\207eb\207" [thing-at-point-file-name-chars re-search-backward "[^" "]" nil t] 4]] 4)
#@117 Regexp matching the beginning of a well-formed URI.
If nil, construct the regexp from `thing-at-point-uri-schemes'.
(defvar thing-at-point-beginning-of-url-regexp nil (#$ . 6382))
#@64 Regexp matching the host and filename or e-mail part of a URL.
(defvar thing-at-point-url-path-regexp "[^]	\n \"'<>[^`{}]*[^]	\n \"'<>[^`{}.,;]+" (#$ . 6568))
#@51 Regexp matching a URI without a scheme component.
(defvar thing-at-point-short-url-regexp (concat "[-A-Za-z0-9]+\\.[-A-Za-z0-9.]+" thing-at-point-url-path-regexp) (#$ . 6733))
#@231 List of URI schemes recognized by `thing-at-point-url-at-point'.
Each string in this list should correspond to the start of a
URI's scheme component, up to and including the trailing // if
the scheme calls for that to be present.
(defvar thing-at-point-uri-schemes '("aaa://" "about:" "acap://" "apt:" "bzr://" "bzr+ssh://" "attachment:/" "chrome://" "cid:" "content://" "crid://" "cvs://" "data:" "dav:" "dict://" "doi:" "dns:" "dtn:" "feed:" "file:/" "finger://" "fish://" "ftp://" "geo:" "git://" "go:" "gopher://" "h323:" "http://" "https://" "im:" "imap://" "info:" "ipp:" "irc://" "irc6://" "ircs://" "iris.beep:" "jar:" "ldap://" "ldaps://" "magnet:" "mailto:" "mid:" "mtqp://" "mupdate://" "news:" "nfs://" "nntp://" "opaquelocktoken:" "pop://" "pres:" "resource://" "rmi://" "rsync://" "rtsp://" "rtspu://" "service:" "sftp://" "sip:" "sips:" "smb://" "sms:" "snmp://" "soap.beep://" "soap.beeps://" "ssh://" "svn://" "svn+ssh://" "tag:" "tel:" "telnet://" "tftp://" "tip://" "tn3270://" "udp://" "urn:" "uuid:" "vemmi://" "webcal://" "xri://" "xmlrpc.beep://" "xmlrpc.beeps://" "z39.50r://" "z39.50s://" "xmpp:" "fax:" "man:" "mms://" "mmsh://" "modem:" "prospero:" "snews:" "wais://") (#$ . 6916))
#@216 Regexp matching a URL marked up per RFC1738.
This kind of markup was formerly recommended as a way to indicate
URIs, but as of RFC 3986 it is no longer recommended.
Subexpression 1 should contain the delimited URL.
(defvar thing-at-point-markedup-url-regexp "<URL:\\([^<>\n]+\\)>" (#$ . 8132))
#@35 Regexp matching a newsgroup name.
(defvar thing-at-point-newsgroup-regexp "\\`[[:lower:]]+\\.[-+[:lower:]_0-9.]+\\'" (#$ . 8432))
#@62 Used by `thing-at-point-newsgroup-p' if gnus is not running.
(defvar thing-at-point-newsgroup-heads '("alt" "comp" "gnu" "misc" "news" "sci" "soc" "talk") (#$ . 8568))
#@110 Default scheme for ill-formed URIs that look like <foo@example.com>.
If nil, do not give such URIs a scheme.
(defvar thing-at-point-default-mail-uri-scheme "mailto" (#$ . 8743))
(put 'url 'bounds-of-thing-at-point 'thing-at-point-bounds-of-url-at-point)
#@347 Return a cons cell containing the start and end of the URI at point.
Try to find a URI using `thing-at-point-markedup-url-regexp'.
If that fails, try with `thing-at-point-beginning-of-url-regexp'.
If that also fails, and optional argument LAX is non-nil, return
the bounds of a possible ill-formed URI (one lacking a scheme).

(fn &optional LAX)
(defalias 'thing-at-point-bounds-of-url-at-point #[256 "\300 \2061\301\302\303`\212\304x\210w\210`)\212\304w\210x\210`)\305#\206/\205/B\266\206\207" [thing-at-point--bounds-of-markedup-url "--:=&?$+@-Z_[:alpha:]~#,%;*()!'" "^[0-9a-zA-Z]" ":;.,!?" nil thing-at-point--bounds-of-well-formed-url] 11 (#$ . 9004)])
(defalias 'thing-at-point--bounds-of-markedup-url #[0 "\205B\302`\303 \304 \305\212b\210\211\2045`X\2035`W\2035\306\307#\203`V\203\302\262\202)\211\205?\307\224\307\225B)\266\205\207" [thing-at-point-markedup-url-regexp case-fold-search t line-beginning-position line-end-position nil re-search-forward 1] 9])
#@19 

(fn BEG END PT)
(defalias 'thing-at-point--bounds-of-well-formed-url #[771 "\212b\210\303\211\211\214}\210\304\206\305	!\306Q\262\307\310#\203+`W\203+\311\224\262)\205}eV\203n\312S!\242\313=\203n\214Sd^}\210\3141Y\303\315S\311\316#)0\202[\210\303\211\262)\203n\317S\"\204nS\262X\205}X\205}B\266\203)\207" [thing-at-point-beginning-of-url-regexp thing-at-point-uri-schemes parse-sexp-ignore-comments nil "\\(?:\\`\\|[^a-zA-Z0-9]\\)\\(" regexp-opt "\\)" re-search-forward t 1 syntax-after 4 (error) scan-lists 0 blink-matching-check-mismatch] 10 (#$ . 10014)])
(put 'url 'thing-at-point 'thing-at-point-url-at-point)
#@766 Return the URL around or before point.
If no URL is found, return nil.

If optional argument LAX is non-nil, look for URLs that are not
well-formed, such as foo@bar or <nobody>.

If optional arguments BOUNDS are non-nil, it should be a cons
cell of the form (START . END), containing the beginning and end
positions of the URI.  Otherwise, these positions are detected
automatically from the text around point.

If the scheme component is absent, either because a URI delimited
with <url:...> lacks one, or because an ill-formed URI was found
with LAX or BEG and END, try to add a scheme in the returned URI.
The scheme is chosen heuristically: "mailto:" if the address
looks like an email address, "ftp://" if it starts with
"ftp", etc.

(fn &optional LAX BOUNDS)
(defalias 'thing-at-point-url-at-point #[512 "\211\204	\301!\262\211\205\270\211@AW\205\270\302@A\"\303\304\"\204\265\303\305\"\203S@\206/`Sf\306=\203BAf\307=\203B\202C\310\211\205N\211\311Q\211\262\262\204\265\303\312\"\203\203@\206``Sf\306=\203\203Af\307=\203\203\303\313\314\313P!\"\204\203\315P\211\262\204\265\316!\203\222\317P\211\262\204\265\303\320\"\203\242\321P\211\262\204\265\303\322\"\203\262\323P\211\262\204\265\324\262\211\262\207" [thing-at-point-default-mail-uri-scheme thing-at-point-bounds-of-url-at-point buffer-substring-no-properties string-match "\\`[a-zA-Z][-a-zA-Z0-9+.]*:" "\\`[^:</>@]+@[-.0-9=&?$+A-Z_a-z~#,%;*]" 60 62 "mailto" ":" "\\`[[:alnum:]]+\\'" "~" expand-file-name "mailto:" thing-at-point-newsgroup-p "news:" "\\`ftp\\." "ftp://" "\\`www\\." "http://" nil] 8 (#$ . 10679)])
#@73 Return STRING if it looks like a newsgroup name, else nil.

(fn STRING)
(defalias 'thing-at-point-newsgroup-p #[257 "\302\"\205\204\303	\304\211\203Z@\262A\262\3051RJ\262\306!\203,\307\"\202A<\2037\235\202A\310!\203J\311\"\203J\262\304\262\304\211\2620\202V\210\202\210\202\211\204\202\203\202\302\312\"\211\203\201\313\314\315\225#\211\262\203\201\211\235\203\201\262\210\266\203\207" [thing-at-point-newsgroup-regexp thing-at-point-newsgroup-heads string-match (gnus-active-hashtb gnus-newsrc-hashtb gnus-killed-hashtb) nil (error) obarrayp intern-soft hash-table-p gethash "\\`\\([[:lower:]]+\\)\\." substring 0 1] 10 (#$ . 12315)])
(byte-code "\300\301\302\303#\210\300\301\304\305#\207" [put url end-op #[0 "\300\301!\207" [end-of-thing url] 2] beginning-op #[0 "\300\301!\207" [beginning-of-thing url] 2]] 4)
#@253 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.

Optional argument DISTANCE limits search for REGEXP forward and
back from point.

(fn REGEXP &optional DISTANCE)
(defalias 'thing-at-point-looking-at #[513 "\212`\205	`\\\205`Z\300\211\211\301!\203%\302\225Y\203%`\262\303\304#\210`\262\305\306#\211\262\203`\211W\203`\302\224V\2040\301!\203`\302\225Y\203``\211\262\2040\205\213b\210o\204\204\307u\210\301!\203\204\302\225Y\203\204`\211\262\204gb\210\301!\266\206)\207" [nil looking-at 0 re-search-forward limit re-search-backward t -1] 12 (#$ . 13187)])
#@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]+>?" (#$ . 13889))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\300\306\307\310#\210\300\306\311\312#\207" [put email bounds-of-thing-at-point #[0 "\301\302\"\211\205\303\224\303\225B\266\202\207" [thing-at-point-email-regexp thing-at-point-looking-at 500 0] 5] thing-at-point #[0 "\300\301!\211\205
\302@A\"\207" [bounds-of-thing-at-point email buffer-substring-no-properties] 4] buffer end-op #[0 "db\207" #1=[] 1] beginning-op #[0 "eb\207" #1# 1]] 4)
#@87 A regular expression matching a UUID.
See RFC 4122 for the description of the format.
(defconst thing-at-point-uuid-regexp "\\<[[:xdigit:]]\\{8\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{4\\}-[[:xdigit:]]\\{12\\}\\>" (#$ . 14601))
(put 'uuid 'bounds-of-thing-at-point #[0 "\301\302\"\205\f\303\224\303\225B\207" [thing-at-point-uuid-regexp thing-at-point-looking-at 36 0] 3])
#@80 Return the word at point.  See `thing-at-point'.

(fn &optional NO-PROPERTIES)
(defalias 'word-at-point #[256 "\300\301\"\207" [thing-at-point word] 4 (#$ . 15000)])
#@84 Return the sentence at point.  See `thing-at-point'.

(fn &optional NO-PROPERTIES)
(defalias 'sentence-at-point #[256 "\300\301\"\207" [thing-at-point sentence] 4 (#$ . 15173)])
#@95 Read a Lisp expression from STR.
Signal an error if the entire string was not used.

(fn STR)
(defalias 'thing-at-point--read-from-whole-string #[257 "\300!\3011\300\302A\"!\210\3030\202\210\304\211\203 \305\306!\202\"@\207" [read-from-string (end-of-file) substring t nil error "Can't read whole string"] 6 (#$ . 15358)])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias read-from-whole-string thing-at-point--read-from-whole-string "This is an internal thingatpt function and should not be used." make-obsolete "25.1"] 4)
#@29 

(fn &optional THING PRED)
(defalias 'form-at-point #[512 "\300\206\301!\211;\203\3021\303!0\202\210\304\202\211\203'!\205(\211\207" [thing-at-point sexp (error) thing-at-point--read-from-whole-string nil] 6 (#$ . 15915)])
#@52 Return the sexp at point, or nil if none is found.
(defalias 'sexp-at-point #[0 "\300\301!\207" [form-at-point sexp] 2 (#$ . 16162)])
#@54 Return the symbol at point, or nil if none is found.
(defalias 'symbol-at-point #[0 "\300\301!\211\205\n\302!\207" [thing-at-point symbol intern] 3 (#$ . 16302)])
#@162 Return the number at point, or nil if none is found.
Decimal numbers like "14" or "-14.5", as well as hex numbers
like "0xBEEF09" or "#xBEEF09", are recognized.
(defalias 'number-at-point #[0 "\300\301\302\"\205\303\224\203\304\303\224\303\225{!\207\304\305\224\305\225{\306\"\207" [thing-at-point-looking-at "\\(-?[0-9]+\\.?[0-9]*\\)\\|\\(0x\\|#x\\)\\([a-zA-Z0-9]+\\)" 500 1 string-to-number 3 16] 3 (#$ . 16474)])
(put 'number 'thing-at-point 'number-at-point)
#@186 Return the Lisp list at point, or nil if none is found.
If IGNORE-COMMENT-OR-STRING is non-nil comments and strings are
treated as white space.

(fn &optional IGNORE-COMMENT-OR-STRING)
(defalias 'list-at-point #[256 "\211\205\300 \212\3018\206`b\210\302\303\304\")\207" [syntax-ppss 8 form-at-point list listp] 5 (#$ . 16948)])
Zerion Mini Shell 1.0