Current File : //proc/thread-self/root/kunden/usr/share/emacs/27.2/lisp/net/quickurl.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!\210\300\303!\210\304\305\306\307\310\311\312\313\314\315&	\210\316\317\320\321\310\322\323\324\312\305&	\210\316\325\326\327\323\330\312\305&\210\316\331\332\333\323\330\312\305&\210\316\334\335\336\323\330\312\305&\207" [require thingatpt pp browse-url custom-declare-group quickurl nil "Insert a URL based on text at point in buffer." :version "21.1" :group abbrev :prefix "quickurl-" custom-declare-variable quickurl-url-file (locate-user-emacs-file "quickurls" ".quickurls") "File that contains the URL list." "24.4" :type file quickurl-format-function #'quickurl-format-url "Function to format the URL before insertion into the current buffer." function quickurl-sort-function #'quickurl-sort-urls "Function to sort the URL list." quickurl-grab-lookup-function #'current-word "Function to grab the thing to lookup."] 10)
#@49 Default function for `quickurl-assoc-function'.
(defalias 'quickurl--assoc-function #[(key alist) "\302	\303#\207" [key alist assoc-string t] 4 (#$ . 1272)])
(byte-code "\300\301\302\303\304\305\306\307\310\311&	\210\300\312\313\314\306\315\310\311&\210\300\316\317\320\306\321\310\311&\210\300\322\323\324\306\321\310\311&\210\300\325\326\327\306\330\310\311&\207" [custom-declare-variable quickurl-assoc-function #'quickurl--assoc-function "Function to use for alist lookup into `quickurl-urls'." :version "26.1" :type function :group quickurl quickurl-completion-ignore-case t "Should `quickurl-ask' ignore case when doing the input lookup?" boolean quickurl-prefix ";; -*- lisp -*-\n\n" "Text to write to `quickurl-url-file' before writing the URL list." string quickurl-postfix "" "Text to write to `quickurl-url-file' after writing the URL list.\n\nSee the constant `quickurl-reread-hook-postfix' for some example text that\ncould be used here." quickurl-list-mode-hook nil "Hooks for `quickurl-list-mode'." hook] 10)
#@339 Example `quickurl-postfix' text that adds a local variable to the
`quickurl-url-file' so that if you edit it by hand it will ensure that
`quickurl-urls' is updated with the new URL list.

To make use of this do something like:

  (setq quickurl-postfix quickurl-reread-hook-postfix)

in your init file (after loading/requiring quickurl).
(defconst quickurl-reread-hook-postfix "\n;; Local Variables:\n;; eval: (progn (require 'quickurl) (add-hook 'write-file-functions (lambda () (quickurl-read) nil) nil t))\n;; End:\n" (#$ . 2308))
#@55 URL alist for use with `quickurl' and `quickurl-ask'.
(defvar quickurl-urls nil (#$ . 2848))
#@49 Local keymap for a `quickurl-list-mode' buffer.
(defvar quickurl-list-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\320#\210\302\322\323#\210)\207" [map make-sparse-keymap define-key "a" quickurl-list-add-url [(control m)] quickurl-list-insert-url "u" quickurl-list-insert-naked-url " " quickurl-list-insert-with-lookup "l" quickurl-list-insert-lookup "d" quickurl-list-insert-with-desc [(control g)] quickurl-list-quit "q" [mouse-2] quickurl-list-mouse-select] 4) (#$ . 2947))
#@34 Name for the URL listing buffer.
(defvar quickurl-list-buffer-name "*quickurl-list*" (#$ . 3550))
#@51 `current-buffer' when `quickurl-list' was called.
(defvar quickurl-list-last-buffer nil (#$ . 3654))
#@30 Does the URL have a comment?
(defalias 'quickurl-url-commented-p #[(url) "A<\207" [url] 1 (#$ . 3761)])
#@58 Create a URL from KEYWORD, URL and (optionally) COMMENT.
(defalias 'quickurl-make-url #[(keyword url &optional comment) "\203G\303U\204	\nE\207	\nB\207" [comment keyword url 0] 3 (#$ . 3872)])
(defalias 'quickurl-url-keyword 'car "Return the keyword for the URL.\n\n(fn URL)")
#@81 Return the actual URL of the URL.

Note that this function is a setfable place.
(defalias 'quickurl-url-url #[(url) "\301!\203\nA@\207A\207" [url quickurl-url-commented-p] 2 (#$ . 4162)])
(byte-code "\300\301\302\303#\300\207" [function-put quickurl-url-url gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter quickurl-url-url #[(store url) "\302\303\304D\305D\306DF	E\207" [url store setf if quickurl-url-commented-p cadr cdr] 6]] 5]] 4)
#@135 Get the comment from a URL.

If the URL has no comment an empty string is returned. Also note that this
function is a setfable place.
(defalias 'quickurl-url-comment #[(url) "\301!\203\n\3028\207\303\207" [url quickurl-url-commented-p 2 ""] 2 (#$ . 4638)])
(byte-code "\300\301\302\303#\300\207" [function-put quickurl-url-comment gv-expander #[(do &rest args) "\302\303\304	$\207" [do args gv--defsetter quickurl-url-comment #[(store url) "\302\303D\302\304\305	DD\306\307D\310DE\306\311\312E	EF\313\304\305	DD\306\307D\314\307D	EEEF\207" [url store if quickurl-url-commented-p zerop length setf cdr cadr nth 2 unless list] 10]] 5]] 4)
#@119 Return a description for the URL.

If the URL has a comment then this is returned, otherwise the keyword is
returned.
(defalias 'quickurl-url-description #[(url) "\302!\211G\303U\203\304!\202	)\207" [url desc quickurl-url-comment 0 quickurl-url-keyword] 3 (#$ . 5292)])
(defalias 'quickurl-format-url #[(url) "\301\302\303!\"\207" [url format "<URL:%s>" quickurl-url-url] 4])
#@66 Sort URLs in LIST according to their `quickurl-url-description'.
(defalias 'quickurl-sort-urls #[(list) "\301\302\"\207" [list sort #[(x y) "\302!\227\302	!\227\231\207" [x y quickurl-url-description] 3]] 3 (#$ . 5682)])
#@216 `read' the URL list from BUFFER into `quickurl-urls'.

BUFFER, if nil, defaults to current buffer.
Note that this function moves point to `point-min' before doing the `read'
It also restores point after the `read'.
(defalias 'quickurl-read #[(&optional buffer) "\212eb\210\303	\206p!!\211)\207" [quickurl-sort-function buffer quickurl-urls read] 3 (#$ . 5912)])
#@64 Load the contents of `quickurl-url-file' into `quickurl-urls'.
(defalias 'quickurl-load-urls #[nil "\302!\205\303\304!r	q\210\305\216\306!\210\307 +\207" [quickurl-url-file #1=#:temp-buffer file-exists-p generate-new-buffer " *temp*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] insert-file-contents quickurl-read] 2 (#$ . 6284)])
#@62 Save the contents of `quickurl-urls' to `quickurl-url-file'.
(defalias 'quickurl-save-urls #[nil "\306\307!rq\210\310\216p\311\312!\210\313\f!\210\312
!\210\314ed\311\315%-\207" [#1=#:temp-buffer print-length standard-output quickurl-prefix quickurl-urls quickurl-postfix generate-new-buffer " *temp*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] nil princ pp write-region 0 quickurl-url-file] 6 (#$ . 6645)])
#@252 Return URL associated with key LOOKUP.

The lookup is done by looking in the alist `quickurl-urls' and the `cons'
for the URL is returned. The actual method used to look into the alist
depends on the setting of the variable `quickurl-assoc-function'.
(defalias 'quickurl-find-url #[(lookup) "	\n\"\207" [quickurl-assoc-function lookup quickurl-urls] 3 (#$ . 7088)])
#@133 Insert URL, formatted using `quickurl-format-function'.

Also display a `message' saying what the URL was unless SILENT is non-nil.
(defalias 'quickurl-insert #[(url &optional silent) "	!c\210\n?\205\303\304\305	!\"\207" [quickurl-format-function url silent message "Found %s" quickurl-url-url] 4 (#$ . 7462)])
#@184 Insert a URL based on LOOKUP.

If not supplied LOOKUP is taken to be the word at point in the current
buffer, this default action can be modified via
`quickurl-grab-lookup-function'.
(defalias 'quickurl #[(&optional lookup) "\204	 \211\205.\303 \210\304!\211\204\305\306\"\202-\307\310!\203'\311\310!\210\312c\210\313\n!)\207" [lookup quickurl-grab-lookup-function url quickurl-load-urls quickurl-find-url error "No URL associated with \"%s\"" looking-at "\\w" skip-syntax-forward " " quickurl-insert] 4 (#$ . 7783) nil])
#@63 Insert a URL, with `completing-read' prompt, based on LOOKUP.
(defalias 'quickurl-ask #[(lookup) "\302!\211\205\303	!)\207" [lookup url quickurl-find-url quickurl-insert] 3 (#$ . 8323) (list (progn (quickurl-load-urls) (let ((completion-ignore-case quickurl-completion-ignore-case)) (completing-read "Lookup: " quickurl-urls nil t))))])
#@362 Attempt to grab a word/URL pair from point in the current buffer.

Point should be somewhere on the URL and the word is taken to be the thing
that is returned from calling `quickurl-grab-lookup-function' once a
`backward-word' has been issued at the start of the URL.

It is assumed that the URL is either "unguarded" or is wrapped inside an
<URL:...> wrapper.
(defalias 'quickurl-grab-url #[nil "\305\300!\211\2058\212\306\300!\210\307	!\203\310\311!\210\312\313!\210\n \211\2057\314\315\316!r\fq\210\317\216c\210\320ed\"+\"*)\207" [url thing-at-point-markedup-url-regexp quickurl-grab-lookup-function word #1=#:temp-buffer thing-at-point beginning-of-thing thing-at-point-looking-at search-backward "<URL:" backward-word-strictly 1 quickurl-make-url generate-new-buffer " *temp*" #[nil "\301!\205	\302!\207" [#1# buffer-name kill-buffer] 2] buffer-substring-no-properties] 5 (#$ . 8671)])
#@158 Allow the user to interactively add a new URL associated with WORD.

See `quickurl-grab-url' for details on how the default word/URL combination
is decided.
(defalias 'quickurl-add-url #[(word url comment) "G\306U\203\307\310!\207\311 \210\312!\211\203)\313\314!\203%\315\316\317\"!\202*\320\202*\320\211\205\302	\203\231	\321!\203F\211A
\240\210)\202N\211
\241\210))	\321!\203G\306U\203p\211A@\241\210)\202\225AA\211\240\210)\202\225G\306U\204\225\211AD\241\210))\202\244\322
#B!\323 \210\324 !\203\270\325 \210\313\314!\205\302\326\327
\"*\207" [word current-url add-it #1=#:v #2=#:v url 0 error "You must specify a WORD for lookup" quickurl-load-urls quickurl-find-url called-interactively-p interactive y-or-n-p format "\"%s\" exists, replace URL? " t quickurl-url-commented-p quickurl-make-url quickurl-save-urls get-buffer quickurl-list-populate-buffer message "Added %s" #3=#:v #4=#:v comment #5=#:v #6=#:c #7=#:v quickurl-urls quickurl-sort-function quickurl-list-buffer-name] 5 (#$ . 9581) (let ((word-url (quickurl-grab-url))) (list (read-string "Word: " (quickurl-url-keyword word-url)) (read-string "URL: " (quickurl-url-url word-url)) (read-string "Comment: " (quickurl-url-comment word-url))))])
#@193 Browse the URL associated with LOOKUP.

If not supplied LOOKUP is taken to be the word at point in the
current buffer, this default action can be modified via
`quickurl-grab-lookup-function'.
(defalias 'quickurl-browse-url #[(&optional lookup) "\204	 \211\205#\303 \210\304!\211\203\305\306\n!!\202\"\307\310\")\207" [lookup quickurl-grab-lookup-function url quickurl-load-urls quickurl-find-url browse-url quickurl-url-url error "No URL associated with \"%s\""] 4 (#$ . 10871) nil])
#@72 Browse the URL, with `completing-read' prompt, associated with LOOKUP.
(defalias 'quickurl-browse-url-ask #[(lookup) "\302!\211\205
\303\304	!!)\207" [lookup url quickurl-find-url browse-url quickurl-url-url] 4 (#$ . 11372) (list (progn (quickurl-load-urls) (completing-read "Browse: " quickurl-urls nil t)))])
#@58 Pull `quickurl-url-file' into a buffer for hand editing.
(defalias 'quickurl-edit-urls #[nil "\301!\207" [quickurl-url-file find-file] 2 (#$ . 11692) nil])
(defvar quickurl-list-mode-hook nil)
(byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [quickurl-list-mode-hook variable-documentation put "Hook run after entering Quickurl mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp quickurl-list-mode-map definition-name quickurl-list-mode] 4)
(defvar quickurl-list-mode-map (make-sparse-keymap))
(byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204\303\307\310\311#\210\312\313 !\210\307\302N\204-\303\307\302\304\314!#\210\306\300!\204B\303\300\310\311#\210\315\316\300\317\"\210!\210\300\302N\204P\303\300\302\304\320!#\210\303\311\321\322#\207" [quickurl-list-mode-abbrev-table quickurl-list-mode-map variable-documentation put purecopy "Keymap for `quickurl-list-mode'." boundp quickurl-list-mode-syntax-table definition-name quickurl-list-mode (lambda (#1=#:def-tmp-var) (defvar quickurl-list-mode-syntax-table #1#)) make-syntax-table "Syntax table for `quickurl-list-mode'." (lambda (#1#) (defvar quickurl-list-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `quickurl-list-mode'." derived-mode-parent special-mode] 5)
#@299 A mode for browsing the quickurl URL list.

The key bindings for `quickurl-list-mode' are:

\{quickurl-list-mode-map}

In addition to any hooks its parent mode `special-mode' might have run,
this mode runs the hook `quickurl-list-mode-hook', as the final or penultimate step
during initialization.
(defalias 'quickurl-list-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324\325\"\204V=\204V\326\325C#\210\327!\210\330\f!\210\307)\331\332!\207" [delay-mode-hooks major-mode mode-name quickurl-list-mode-map quickurl-list-mode-syntax-table parent make-local-variable t special-mode quickurl-list-mode "Quickurl" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table run-mode-hooks quickurl-list-mode-hook quickurl-list-mode-abbrev-table local-abbrev-table truncate-lines] 6 (#$ . 13097) nil])
#@73 Display `quickurl-list' as a formatted list using `quickurl-list-mode'.
(defalias 'quickurl-list #[nil "\302 \210\303 \230\204\fp\304!\210\305 \210\306 \207" [quickurl-list-buffer-name quickurl-list-last-buffer quickurl-load-urls buffer-name pop-to-buffer quickurl-list-populate-buffer quickurl-list-mode] 2 (#$ . 14194) nil])
#@38 Populate the `quickurl-list' buffer.
(defalias 'quickurl-list-populate-buffer #[nil "r\306!q\210	\307\211\n:\203\"\n@\310!G\fB\nA\211\202
\f\237+\206*\311C\312\313\314\315
\"\"\316\317 \210	\307\211\203h@`\312\310!\320!#c\210\321`S\322#\210)A\211\204C*eb,\207" [quickurl-list-buffer-name quickurl-urls #1=#:--cl-var-- url #2=#:--cl-var-- sizes get-buffer nil quickurl-url-description 20 format "%%-%ds %%s\n" apply max t erase-buffer quickurl-url-url add-text-properties (mouse-face highlight help-echo "mouse-2: insert this URL") fmt inhibit-read-only --dolist-tail-- start] 6 (#$ . 14531)])
#@67 Wrapper for `quickurl-add-url' that doesn't guess the parameters.
(defalias 'quickurl-list-add-url #[(word url comment) "\303	\n#\207" [word url comment quickurl-add-url] 4 (#$ . 15166) "sWord: \nsURL: \nsComment: "])
#@52 Kill the buffer named `quickurl-list-buffer-name'.
(defalias 'quickurl-list-quit #[nil "\300\301!\207" [quit-window t] 2 (#$ . 15391) nil])
#@39 Select the URL under the mouse click.
(defalias 'quickurl-list-mouse-select #[(event) "\301\302!!b\210\303 \207" [event posn-point event-end quickurl-list-insert-url] 3 (#$ . 15537) "e"])
#@353 Insert the URL under cursor into `quickurl-list-last-buffer'.
TYPE dictates what will be inserted, options are:
  `url'         - Insert the URL as <URL:url>
  `naked-url'   - Insert the URL with no formatting
  `with-lookup' - Insert "lookup <URL:url>"
  `with-desc'   - Insert "description <URL:url>"
  `lookup'      - Insert the lookup for that URL
(defalias 'quickurl-list-insert #[(type) "\305e\306 \"8\211\203Gr\nq\210\307\267\202@\f	!\202A\310	!\202A\311\312\313	!\310	!#\202A\311\314\315	!\310	!#\202A\313	!\202A\316c\210)\202K\317\320!\210	)\207" [quickurl-urls url quickurl-list-last-buffer type quickurl-format-function count-lines line-beginning-position #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (url 22 naked-url 28 with-lookup 34 with-desc 46 lookup 58)) quickurl-url-url format "%s <URL:%s>" quickurl-url-keyword "%S <URL:%s>" quickurl-url-description nil error "No URL details on that line"] 6 (#$ . 15733)])
#@76 Macro to make a key-response function for use in `quickurl-list-mode-map'.
(defalias 'quickurl-list-make-inserter '(macro . #[(type) "\301\302\303\304\"!\305\303\306\"\307\310\311\312DD\313BB\257\207" [type defun intern format "quickurl-list-insert-%S" nil "Insert the result of calling `quickurl-list-insert' with `%s'." (interactive) when quickurl-list-insert quote ((quickurl-list-quit))] 9 (#$ . 16719)]))
#@65 Insert the result of calling `quickurl-list-insert' with `url'.
(defalias 'quickurl-list-insert-url #[nil "\300\301!\205\302 \207" [quickurl-list-insert url quickurl-list-quit] 2 (#$ . 17139) nil])
#@71 Insert the result of calling `quickurl-list-insert' with `naked-url'.
(defalias 'quickurl-list-insert-naked-url #[nil "\300\301!\205\302 \207" [quickurl-list-insert naked-url quickurl-list-quit] 2 (#$ . 17345) nil])
#@73 Insert the result of calling `quickurl-list-insert' with `with-lookup'.
(defalias 'quickurl-list-insert-with-lookup #[nil "\300\301!\205\302 \207" [quickurl-list-insert with-lookup quickurl-list-quit] 2 (#$ . 17569) nil])
#@71 Insert the result of calling `quickurl-list-insert' with `with-desc'.
(defalias 'quickurl-list-insert-with-desc #[nil "\300\301!\205\302 \207" [quickurl-list-insert with-desc quickurl-list-quit] 2 (#$ . 17799) nil])
#@68 Insert the result of calling `quickurl-list-insert' with `lookup'.
(defalias 'quickurl-list-insert-lookup #[nil "\300\301!\205\302 \207" [quickurl-list-insert lookup quickurl-list-quit] 2 (#$ . 18023) nil])
(provide 'quickurl)