HOME

Mini Shell 1.0
Current File : //usr/share/emacs/26.1/lisp/url/url-parse.elc
;ELC
;;; Compiled
;;; in Emacs version 26.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 "\300\301!\210\300\302!\210\303\304\305\"\207" [require url-vars auth-source autoload url-scheme-get-property "url-methods"] 3)
#@62 compiler-macro for inlining `url-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-p (and (memq (type-of cl-x) cl-struct-url-tags) t)) nil] 9 (#$ . 547)])
(put 'url-p 'compiler-macro 'url-p--cmacro)
#@13 

(fn CL-X)
(defalias 'url-p #[257 "\301!>\205	\302\207" [cl-struct-url-tags type-of t] 3 (#$ . 838)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put url-p side-effect-free error-free put url cl-deftype-satisfies] 5)
#@65 compiler-macro for inlining `url-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-type (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 1)) nil] 9 (#$ . 1083)])
(put 'url-type 'compiler-macro 'url-type--cmacro)
#@206 Access slot "type" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-type #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 1] 5 (#$ . 1421)])
(byte-code "\300\301\302\303#\300\207" [function-put url-type side-effect-free t] 4)
#@65 compiler-macro for inlining `url-user'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-user--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-user (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 2)) nil] 9 (#$ . 1871)])
(put 'url-user 'compiler-macro 'url-user--cmacro)
#@206 Access slot "user" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-user #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 2] 5 (#$ . 2209)])
(byte-code "\300\301\302\303#\300\207" [function-put url-user side-effect-free t] 4)
#@69 compiler-macro for inlining `url-password'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-password--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-password (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 3)) nil] 9 (#$ . 2659)])
(put 'url-password 'compiler-macro 'url-password--cmacro)
#@210 Access slot "password" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-password #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 3] 5 (#$ . 3017)])
(byte-code "\300\301\302\303#\300\207" [function-put url-password side-effect-free t] 4)
#@65 compiler-macro for inlining `url-host'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-host--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-host (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 4)) nil] 9 (#$ . 3479)])
(put 'url-host 'compiler-macro 'url-host--cmacro)
#@206 Access slot "host" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-host #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 4] 5 (#$ . 3817)])
(byte-code "\300\301\302\303#\300\207" [function-put url-host side-effect-free t] 4)
#@69 compiler-macro for inlining `url-portspec'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-portspec--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-portspec (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 5)) nil] 9 (#$ . 4267)])
(put 'url-portspec 'compiler-macro 'url-portspec--cmacro)
#@210 Access slot "portspec" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-portspec #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 5] 5 (#$ . 4625)])
(byte-code "\300\301\302\303#\300\207" [function-put url-portspec side-effect-free t] 4)
#@69 compiler-macro for inlining `url-filename'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-filename--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-filename (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 6)) nil] 9 (#$ . 5087)])
(put 'url-filename 'compiler-macro 'url-filename--cmacro)
#@210 Access slot "filename" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-filename #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 6] 5 (#$ . 5445)])
(byte-code "\300\301\302\303#\300\207" [function-put url-filename side-effect-free t] 4)
#@67 compiler-macro for inlining `url-target'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-target--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-target (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 7)) nil] 9 (#$ . 5907)])
(put 'url-target 'compiler-macro 'url-target--cmacro)
#@208 Access slot "target" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-target #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 7] 5 (#$ . 6255)])
(byte-code "\300\301\302\303#\300\207" [function-put url-target side-effect-free t] 4)
#@71 compiler-macro for inlining `url-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-attributes (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 8)) nil] 9 (#$ . 6711)])
(put 'url-attributes 'compiler-macro 'url-attributes--cmacro)
#@212 Access slot "attributes" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-attributes #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 8] 5 (#$ . 7079)])
(byte-code "\300\301\302\303#\300\207" [function-put url-attributes side-effect-free t] 4)
#@69 compiler-macro for inlining `url-fullness'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-fullness--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-fullness (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 9)) nil] 9 (#$ . 7547)])
(put 'url-fullness 'compiler-macro 'url-fullness--cmacro)
#@210 Access slot "fullness" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-fullness #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 9] 5 (#$ . 7905)])
(byte-code "\300\301\302\303#\300\207" [function-put url-fullness side-effect-free t] 4)
#@67 compiler-macro for inlining `url-silent'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-silent--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-silent (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 10)) nil] 9 (#$ . 8367)])
(put 'url-silent 'compiler-macro 'url-silent--cmacro)
#@208 Access slot "silent" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-silent #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 10] 5 (#$ . 8716)])
(byte-code "\300\301\302\303#\300\207" [function-put url-silent side-effect-free t] 4)
#@72 compiler-macro for inlining `url-use-cookies'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-use-cookies--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-use-cookies (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 11)) nil] 9 (#$ . 9173)])
(put 'url-use-cookies 'compiler-macro 'url-use-cookies--cmacro)
#@213 Access slot "use-cookies" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-use-cookies #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 11] 5 (#$ . 9547)])
(byte-code "\300\301\302\303#\300\207" [function-put url-use-cookies side-effect-free t] 4)
#@73 compiler-macro for inlining `url-asynchronous'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'url-asynchronous--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block url-asynchronous (or (url-p cl-x) (signal 'wrong-type-argument (list 'url cl-x))) (aref cl-x 12)) nil] 9 (#$ . 10019)])
(put 'url-asynchronous 'compiler-macro 'url-asynchronous--cmacro)
#@214 Access slot "asynchronous" of `(url (:constructor nil) (:constructor url-parse-make-urlobj (&optional type user password host portspec filename target attributes fullness)) (:copier nil))' struct CL-X.

(fn CL-X)
(defalias 'url-asynchronous #[257 "\301!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-url-tags type-of signal wrong-type-argument url 12] 5 (#$ . 10399)])
(byte-code "\300\301\302\303#\300\207" [function-put url-asynchronous side-effect-free t] 4)
#@152 compiler-macro for inlining `url-parse-make-urlobj'.

(fn CL-WHOLE-ARG &optional TYPE USER PASSWORD HOST PORTSPEC FILENAME TARGET ATTRIBUTES FULLNESS)
(defalias 'url-parse-make-urlobj--cmacro #[2561 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (type user password host portspec filename target attributes fullness) (cl-block url-parse-make-urlobj (record 'url type user password host portspec filename target attributes fullness nil t t)) nil] 25 (#$ . 10876)])
(put 'url-parse-make-urlobj 'compiler-macro 'url-parse-make-urlobj--cmacro)
#@125 Constructor for objects of type `url'.

(fn &optional TYPE USER PASSWORD HOST PORTSPEC FILENAME TARGET ATTRIBUTES FULLNESS)
(defalias 'url-parse-make-urlobj #[2304 "\300\301\n\n\n\n\n\n\n\n\n\302\303\211&
\207" [record url nil t] 23 (#$ . 11448)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put url-parse-make-urlobj side-effect-free t cl-struct-define url nil cl-structure-object record ((cl-tag-slot) (type) (user) (password) (host) (portspec) (filename) (target) (attributes) (fullness) (silent) (use-cookies t) (asynchronous t)) cl-struct-url-tags] 11)
#@186 Return the port number for the URL specified by URLOBJ.
If the port spec is nil (i.e. URLOBJ specifies no port number),
return the default port number for URLOBJ's scheme.

(fn URLOBJ)
(defalias 'url-port #[257 "\301!>\204\302\303\304D\"\210\211\305H\206?\301!>\204$\302\303\304D\"\210\211\306H\205?\307\301!>\204:\302\303\304D\"\210\306H\310\"\207" [cl-struct-url-tags type-of signal wrong-type-argument url 5 1 url-scheme-get-property default-port] 6 (#$ . 12065)])
(byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put url-port gv-expander #[385 "\300\301\302$\207" [gv--defsetter url-port #[514 "\300\301DE\207" [setf url-portspec] 5 "\n\n(fn PORT URLOBJ)"]] 7 "\n\n(fn DO &rest ARGS)"] put byte-optimizer byte-compile-inline-expand] 5)
#@242 Return the path and query components of URLOBJ.
These two components are stored together in the FILENAME slot of
the object.  The return value of this function is (PATH . QUERY),
where each of PATH and QUERY are strings or nil.

(fn URLOBJ)
(defalias 'url-path-and-query #[257 "\301!>\204\302\303\304D\"\210\211\305H\306\211\2033\307\310\"\2030\311\211\224O\262\311\225\306O\262\2023\262B\207" [cl-struct-url-tags type-of signal wrong-type-argument url 6 nil string-match "\\?" 0] 7 (#$ . 12845)])
#@141 Return the port number specified by URLOBJ, if it is not the default.
If the specified port number is the default, return nil.

(fn URLOBJ)
(defalias 'url-port-if-non-default #[257 "\301!>\204\302\303\304D\"\210\211\305H\306\205:\301!>\204&\302\303\304D\"\210\307H\211\262\2039\310\311\"\232?\205:\207" [cl-struct-url-tags type-of signal wrong-type-argument url 5 nil 1 url-scheme-get-property default-port] 7 (#$ . 13368)])
#@60 Recreate a URL string from the parsed URLOBJ.

(fn URLOBJ)
(defalias 'url-recreate-url #[257 "\301!>\204\302\303\304D\"\210\211\305H\301!>\204!\302\303\304D\"\210\306H\301!>\2043\302\303\304D\"\210\307H\301!>\204F\302\303\304D\"\210\310H\311!\301!>\204]\302\303\304D\"\210\312H\301!>\204q\302\303\304	D\"\210\313H\205~\314P\301	!>\204\217\302\303\304D\"\210\315H\205\227\316\204\241\205\256\205\254\314P\317Q\205\373\320\321
\301!>\204\310\302\303\304D\"\210\211\322H\206\370\301!>\204\335\302\303\304D\"\210\211\305H\205\370\323\301!>\204\363\302\303\304D\"\210\305H\324\"\262\"\206\325\205\n\326P\260\207" [cl-struct-url-tags type-of signal wrong-type-argument url 1 2 3 4 url-port-if-non-default 6 7 ":" 9 "//" "@" format ":%d" 5 url-scheme-get-property default-port "/" "#"] 20 (#$ . 13817)])
#@79 Recreate the attributes of an URL string from the parsed URLOBJ.

(fn URLOBJ)
(defalias 'url-recreate-url-attributes #[257 "\301!>\204\302\303\304D\"\210\211\305H\205.\306\307\310\301!>\204(\302\303\304D\"\210\305H\306#P\207" [cl-struct-url-tags type-of signal wrong-type-argument url 8 ";" mapconcat #[257 "\211A\203\f\211@\300AQ\207\211@\207" ["="] 4 "\n\n(fn X)"]] 8 (#$ . 14714)])
(make-obsolete 'url-recreate-url-attributes nil "24.3")
#@1376 Return an URL-struct of the parts of URL.
The CL-style struct contains the following fields:

TYPE     is the URI scheme (string or nil).
USER     is the user name (string or nil).
PASSWORD is the password (string [deprecated] or nil).
HOST     is the host (a registered name, IP literal in square
         brackets, or IPv4 address in dotted-decimal form).
PORTSPEC is the specified port (a number), or nil.
FILENAME is the path AND the query component of the URI.
TARGET   is the fragment identifier component (used to refer to a
         subordinate resource, e.g. a part of a webpage).
ATTRIBUTES is nil; this slot originally stored the attribute and
         value alists for IMAP URIs, but this feature was removed
         since it conflicts with RFC 3986.
FULLNESS is non-nil if the hierarchical sequence component of
         the URL starts with two slashes, "//".

The parser follows RFC 3986, except that it also tries to handle
URIs that are not fully specified (e.g. lacking TYPE), and it
does not check for or perform %-encoding.

Here is an example.  The URL

  foo://bob:pass@example.com:42/a/b/c.dtb?type=animal&name=narwhal#nose

parses to

  TYPE     = "foo"
  USER     = "bob"
  PASSWORD = "pass"
  HOST     = "example.com"
  PORTSPEC = 42
  FILENAME = "/a/b/c.dtb?type=animal&name=narwhal"
  TARGET   = "nose"
  ATTRIBUTES = nil
  FULLNESS = t

(fn URL)
(defalias 'url-generic-parse-url #[257 "\211\204\303\304\305\211\211\211\211\211\211\211\211\211\306\211&
\207\307\310!r\211q\210\311\312\313\314\315!\316\"\317$\216\305\320	!\210\321 \210c\210eb\210`\305\211\211\211\211\211\211\211\306\322\323!\203U\312\225b\210`\262	\324\325!\227\262\322\326!\203\347\306\262\317u\210`\262	\327\305w\210`{\262\330\331\"\203\204\324\325\"\262\312\225\305O\262\203\237\330\332\"\203\237\324\317\"\262\324\325\"\262\330\333\"\203\270\324\317\"\262\324\325\"\262\202\316\330\334\"\203\316\324\325\"\262\312\211\224O\262\335\232\203\332\305\262\202\343\203\343\336!\262\227\262`\262	\337\230\203\372d{\262\202\"\340\305w\210\322\341!\203\342\305w\210`{\262\322\343!\203\"`\325u\210`d{\262\211d|\266\2033\330\344\"\2033\345!\262\303\304							\305\n\305\306\211&
)\266\211+\207" [deactivate-mark url-parse-syntax-table inhibit-read-only record url nil t generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 set-syntax-table erase-buffer looking-at "\\([a-zA-Z][-a-zA-Z0-9+.]*\\):" match-string 1 "//" "^/?#" string-match "^\\([^@]+\\)@" "\\`\\([^:]*\\):\\(.*\\)" "^\\(\\[[^]]+\\]\\)\\(?::\\([0-9]*\\)\\)?$" ":\\([0-9]*\\)$" "" string-to-number "data" "^?#" "?" "^#" "#" "%[0-9][0-9]" url-unhex-string] 25 (#$ . 15177)])
#@27 

(fn METHOD LOOKFOR URL)
(defalias 'url-bit-for-url '(macro . #[771 "\300\301\302DD\303\304\305BBD\306BB\307\310\311\312\303\313\314\nEE\315BBBB\316BBB\207" [let* urlobj url-generic-parse-url bit funcall (urlobj) ((methods (list 'url-recreate-url 'url-host)) auth-info) while (and (not bit) (> (length methods) 0)) (setq auth-info (auth-source-search :max 1 :host (funcall (pop methods) urlobj) :port (url-type urlobj))) setq plist-get (nth 0 auth-info) ((when (functionp bit) (setq bit (funcall bit)))) (bit)] 13 (#$ . 17967)]))
#@65 Attempt to use .authinfo to find a user for this URL.

(fn URL)
(defalias 'url-user-for-url #[257 "\301!\302!\303\304D\305\204PG\306V\203P\307\310\311\312\211A\262\242!\313\314\n!>\2044\315\316\317\fD\"\210	\311H&\262\320@\321\"\262\322!\203\n \262\202\n\207" [cl-struct-url-tags url-generic-parse-url url-user url-recreate-url url-host nil 0 auth-source-search :max 1 :host :port type-of signal wrong-type-argument url plist-get :user functionp] 15 (#$ . 18508)])
#@69 Attempt to use .authinfo to find a password for this URL.

(fn URL)
(defalias 'url-password-for-url #[257 "\301!\302!\303\304D\305\204PG\306V\203P\307\310\311\312\211A\262\242!\313\314\n!>\2044\315\316\317\fD\"\210	\311H&\262\320@\321\"\262\322!\203\n \262\202\n\207" [cl-struct-url-tags url-generic-parse-url url-password url-recreate-url url-host nil 0 auth-source-search :max 1 :host :port type-of signal wrong-type-argument url plist-get :secret functionp] 15 (#$ . 19004)])
(provide 'url-parse)