;ELC ;;; Compiled ;;; in Emacs version 28.0.50 ;;; with all optimizations. (custom-declare-group 'leaf nil "Symplifying your `.emacs' configuration." :group 'lisp) #@102 Make list from ARGS. Same as `list' but this macro does not evaluate any arguments. (fn &rest ARGS) (defalias 'leaf-list '(macro . #[128 "\300D\207" [quote] 3 (#$ . 177)])) (defvar leaf--paths nil) (defvar leaf--load-file-name nil) #@119 Special keywords and conversion rule to be processed by `leaf'. Sort by `leaf-sort-leaf--values-plist' in this order. (defvar leaf-keywords '(:disabled (unless (eval (car leaf--value)) `(,@leaf--body)) :leaf-path (if (and leaf--body (eval (car leaf--value))) `((leaf-handler-leaf-path ,leaf--name) ,@leaf--body) `(,@leaf--body)) :leaf-protect (if (and leaf--body (eval (car leaf--value))) `((leaf-handler-leaf-protect ,leaf--name ,@leaf--body)) `(,@leaf--body)) :load-path `(,@(mapcar (lambda (elm) `(add-to-list 'load-path ,elm)) leaf--value) ,@leaf--body) :load-path* `(,@(mapcar (lambda (elm) `(add-to-list 'load-path (locate-user-emacs-file ,elm))) leaf--value) ,@leaf--body) :leaf-autoload `(,@(when (car leaf--value) (mapcar (lambda (elm) `(unless (fboundp ',(car elm)) (autoload #',(car elm) ,(cdr elm) nil t))) (reverse leaf--autoload))) ,@leaf--body) :defun `(,@(mapcar (lambda (elm) `(declare-function ,(car elm) ,(symbol-name (cdr elm)))) leaf--value) ,@leaf--body) :defvar `(,@(mapcar (lambda (elm) `(defvar ,elm)) leaf--value) ,@leaf--body) :leaf-defun `(,@(when (car leaf--value) (mapcar (lambda (elm) `(declare-function ,(car elm) ,(cdr elm))) (reverse leaf--autoload))) ,@leaf--body) :leaf-defvar `(,@(mapcar (lambda (elm) `(defvar ,elm)) leaf--value) ,@leaf--body) :preface `(,@leaf--value ,@leaf--body) :when (when leaf--body `((when ,@(if (= 1 (length leaf--value)) leaf--value `((and ,@leaf--value))) ,@leaf--body))) :unless (when leaf--body `((unless ,@(if (= 1 (length leaf--value)) leaf--value `((and ,@leaf--value))) ,@leaf--body))) :if (when leaf--body `((if ,@(if (= 1 (length leaf--value)) leaf--value `((and ,@leaf--value))) (progn ,@leaf--body)))) :doc `(,@leaf--body) :req `(,@leaf--body) :tag `(,@leaf--body) :file `(,@leaf--body) :url `(,@leaf--body) :added `(,@leaf--body) :emacs< (when leaf--body `((when (version< emacs-version ,leaf--value) ,@leaf--body))) :emacs<= (when leaf--body `((when (version<= emacs-version ,leaf--value) ,@leaf--body))) :emacs= (when leaf--body `((when (version= emacs-version ,leaf--value) ,@leaf--body))) :emacs> (when leaf--body `((when (version< ,leaf--value emacs-version) ,@leaf--body))) :emacs>= (when leaf--body `((when (version<= ,leaf--value emacs-version) ,@leaf--body))) :package `(,@(mapcar (lambda (elm) `(leaf-handler-package ,leaf--name ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :after (when leaf--body (let ((ret `(progn ,@leaf--body))) (dolist (elm leaf--value) (setq ret `(eval-after-load ',elm ',ret))) `(,ret))) :commands (progn (leaf-register-autoload leaf--value leaf--name) `(,@leaf--body)) :bind (progn (leaf-register-autoload (cadr leaf--value) leaf--name) `((leaf-keys ,(car leaf--value)) ,@leaf--body)) :bind* (progn (leaf-register-autoload (cadr leaf--value) leaf--name) `((leaf-keys* ,(car leaf--value)) ,@leaf--body)) :bind-keymap `((leaf-keys-bind-keymap ,(car leaf--value) nil ',leaf--name) ,@leaf--body) :bind-keymap* `((leaf-keys-bind-keymap* ,(car leaf--value) nil ',leaf--name) ,@leaf--body) :mode (progn (leaf-register-autoload (mapcar #'cdr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(add-to-list 'auto-mode-alist '(,(car elm) \, (cdr elm)))) leaf--value) ,@leaf--body)) :interpreter (progn (leaf-register-autoload (mapcar #'cdr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(add-to-list 'interpreter-mode-alist '(,(car elm) \, (cdr elm)))) leaf--value) ,@leaf--body)) :magic (progn (leaf-register-autoload (mapcar #'cdr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(add-to-list 'magic-mode-alist '(,(car elm) \, (cdr elm)))) leaf--value) ,@leaf--body)) :magic-fallback (progn (leaf-register-autoload (mapcar #'cdr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(add-to-list 'magic-fallback-mode-alist '(,(car elm) \, (cdr elm)))) leaf--value) ,@leaf--body)) :hook (progn (leaf-register-autoload (mapcar #'cdr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(add-hook ',(car elm) #',(cdr elm))) leaf--value) ,@leaf--body)) :advice (progn (leaf-register-autoload (cadr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(advice-add ,@elm)) (car leaf--value)) ,@leaf--body)) :advice-remove (progn (leaf-register-autoload (cadr leaf--value) leaf--name) `(,@(mapcar (lambda (elm) `(advice-remove ,@elm)) (car leaf--value)) ,@leaf--body)) :pre-setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :pre-setf `(,@(mapcar (lambda (elm) `(setf ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :pre-push `(,@(mapcar (lambda (elm) `(push ,(cdr elm) ,(car elm))) leaf--value) ,@leaf--body) :pl-pre-setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :auth-pre-setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :custom `(,@(mapcar (lambda (elm) `(customize-set-variable ',(car elm) ,(cdr elm) ,(leaf--create-custom-comment :custom))) leaf--value) ,@leaf--body) :custom* `(,@(mapcar (lambda (elm) `(customize-set-variable ',(car elm) ,(cdr elm) ,(leaf--create-custom-comment :custom*))) leaf--value) ,@leaf--body) :pl-custom `(,@(mapcar (lambda (elm) `(customize-set-variable ',(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)) ,(leaf--create-custom-comment :pl-custom (cdr elm)))) leaf--value) ,@leaf--body) :auth-custom `(,@(mapcar (lambda (elm) `(customize-set-variable ',(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)) ,(leaf--create-custom-comment :auth-custom (cdr elm)))) leaf--value) ,@leaf--body) :custom-face `((custom-set-faces ,@(mapcar (lambda (elm) `'(,(car elm) ,(car (cddr elm)) nil ,(leaf--create-custom-comment :custom-face))) leaf--value)) ,@leaf--body) :init `(,@leaf--value ,@leaf--body) :require `(,@(mapcar (lambda (elm) `(require ',elm)) leaf--value) ,@leaf--body) :global-minor-mode (progn (mapc (lambda (elm) (leaf-register-autoload (car elm) (cdr elm))) leaf--value) `(,@(mapcar (lambda (elm) `(,(car elm) 1)) leaf--value) ,@leaf--body)) :leaf-defer (let* ((eval-after-p (and leaf--body (eval (car leaf--value)) (leaf-list-memq leaf-defer-keywords (leaf-plist-keys leaf--raw)))) (file (leaf-this-file)) (let-or-progn (if file `(let ((leaf--load-file-name ,file))) '(progn)))) (if eval-after-p `((eval-after-load ',leaf--name '(,@let-or-progn ,@leaf--body))) `(,@leaf--body))) :setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :setq-default `(,@(mapcar (lambda (elm) `(setq-default ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :setf `(,@(mapcar (lambda (elm) `(setf ,(car elm) ,(cdr elm))) leaf--value) ,@leaf--body) :push `(,@(mapcar (lambda (elm) `(push ,(cdr elm) ,(car elm))) leaf--value) ,@leaf--body) :pl-setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :auth-setq `(,@(mapcar (lambda (elm) `(setq ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :pl-setq-default `(,@(mapcar (lambda (elm) `(setq-default ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :auth-setq-default `(,@(mapcar (lambda (elm) `(setq-default ,(car elm) (leaf-handler-auth ,leaf--name ,(car elm) ,(cdr elm)))) leaf--value) ,@leaf--body) :config `(,@leaf--value ,@leaf--body) :defer-config `((eval-after-load ',leaf--name '(progn ,@leaf--value)) ,@leaf--body)) (#$ . 418)) #@17 Normalize rule. (defvar leaf-normalize '(((memq leaf--key '(:require)) (let ((ret (leaf-flatten leaf--value))) (if (eq nil (car ret)) nil (delete-dups (delq nil (leaf-subst t leaf--name ret)))))) ((memq leaf--key '(:load-path :load-path* :commands :after :defvar)) (mapcar (lambda (elm) (cond ((memq leaf--key '(:after)) (if (eq elm t) leaf--name elm)) (t elm))) (delete-dups (delq nil (leaf-flatten leaf--value))))) ((memq leaf--key (list :package :global-minor-mode :hook :mode :interpreter :magic :magic-fallback :defun :pl-setq :pl-pre-setq :pl-setq-default :pl-custom :auth-custom :auth-pre-setq :auth-setq :auth-setq-default :setq :pre-setq :setq-default :custom :custom-face)) (mapcar (lambda (elm) (cond ((leaf-pairp elm) (if (eq t (car elm)) `(,leaf--name \, (cdr elm)) elm)) ((memq leaf--key '(:package)) (if (equal '(t) elm) `(,leaf--name) `(,@elm))) ((memq leaf--key '(:global-minor-mode)) `(,(leaf-mode-sym (if (equal '(t) elm) leaf--name (car elm))) \, leaf--name)) ((memq leaf--key '(:hook :mode :interpreter :magic :magic-fallback)) `(,@elm \, (leaf-mode-sym leaf--name))) ((memq leaf--key '(:defun)) `(,@elm \, leaf--name)) ((memq leaf--key (list :pl-custom :pl-pre-setq :pl-setq :pl-setq-default :auth-custom :auth-pre-setq :auth-setq :auth-setq-default)) `(,@elm . leaf-default-plstore)) ((memq leaf--key '(:setq :pre-setq :setq-default :custom :custom-face)) elm) (t elm))) (mapcan (lambda (elm) (leaf-normalize-list-in-list elm 'dotlistp)) leaf--value))) ((memq leaf--key '(:emacs< :emacs<= :emacs= :emacs> :emacs>=)) (let ((arg (if (listp leaf--value) (leaf-flatten leaf--value) (list leaf--value)))) (if (not (<= (length arg) 2)) (leaf-error "%s could handle only one argument, %s" leaf--key leaf--value) (let ((val (if (= 1 (length arg)) (car arg) (eval arg)))) (cond ((stringp val) val) ((numberp val) (number-to-string val)) ((eq 'quote (car-safe val)) (number-to-string (eval val))) (t (leaf-error "%s recieve unknown type argument, %s" leaf--key val))))))) ((memq leaf--key '(:custom*)) (mapcar (lambda (elm) (cons (car elm) (cadr elm))) (mapcan 'identity leaf--value))) ((memq leaf--key '(:setf :push :pre-setf :pre-push)) (apply #'append leaf--value)) ((memq leaf--key '(:bind :bind* :bind-keymap :bind-keymap*)) (eval `(leaf-keys ,leaf--value ,leaf--name))) ((memq leaf--key '(:leaf-defvar)) (when (eval (car leaf--value)) (let ((args (append (leaf-plist-get :bind leaf--raw) (leaf-plist-get :bind* leaf--raw)))) (when args (mapcan (lambda (elm) (when (symbolp (car elm)) `(,(leaf-sym-from-keyword (car elm))))) (car (eval `(leaf-keys ,args ,leaf--name)))))))) ((memq leaf--key '(:advice)) (let (val fns) (setq val (mapcan (lambda (elm) (cond ((and (listp elm) (listp (car elm))) (mapcar (lambda (el) (let ((where (nth 0 el)) (sym (nth 1 el)) (fn (nth 2 el))) (setq fns (append fns `(,(nth 2 el)))) `(',sym ,where #',fn))) elm)) ((listp elm) (let ((where (nth 0 elm)) (sym (nth 1 elm)) (fn (nth 2 elm))) (setq fns (append fns `(,(nth 2 elm)))) `((',sym ,where #',fn)))))) leaf--value)) `(,val ,(delq nil (mapcar (lambda (elm) (when (symbolp elm) elm)) fns))))) ((memq leaf--key '(:advice-remove)) (let (val fns) (setq val (mapcan (lambda (elm) (cond ((and (listp elm) (listp (car elm))) (mapcar (lambda (el) (let ((sym (nth 0 el)) (fn (nth 1 el))) (push fn fns) `(',sym #',fn))) elm)) ((listp elm) (let ((sym (nth 0 elm)) (fn (nth 1 elm))) (push fn fns) `((',sym #',fn)))))) leaf--value)) `(,val ,(delq nil (mapcar (lambda (elm) (when (symbolp elm) elm)) fns))))) (t leaf--value)) (#$ . 7876)) #@14 Verify rule. (defvar leaf-verify '(((memq leaf--key (list :package)) (if (not (equal '(nil) (car leaf--value))) leaf--value nil)) ((memq leaf--key (list :hook :defun :pl-setq :pl-pre-setq :pl-setq-default :pl-custom :auth-custom :auth-pre-setq :auth-setq :auth-setq-default :setq :pre-setq :setq-default :custom :custom-face)) (delq nil (mapcar (lambda (elm) (let ((var (car elm))) (cond ((eq t var) (prog1 nil (leaf-error "Error occurs in leaf block: %s" leaf--name) (leaf-error "Attempt modify constant: t; Please check your specification"))) ((eq nil var) (prog1 nil (leaf-error "Error occurs in leaf block: %s" leaf--name) (leaf-error "Attempt modify constant: nil; Please check your specification"))) ((keywordp var) (prog1 nil (leaf-error "Error occurs in leaf block: %s" leaf--name) (leaf-error "Attempt modify constant keyword: %s; Please check your specification" var))) ((not (symbolp var)) (prog1 nil (leaf-error "Error occurs in leaf block: %s" leaf--name) (leaf-error "Attempt modify list; Please check your specification"))) (t elm)))) leaf--value))) (t leaf--value)) (#$ . 11407)) (byte-code "\300\301\302\303\304DD\305\306\307\310\311&\207" [custom-declare-variable leaf-defaults funcall function #[0 "\300\207" [nil] 1] "The value that are interpreted as specified for all `leaf' blocks." :type (plist :key-type (choice (const :leaf-autoload) (const :leaf-defer) (const :leaf-protect) (const :leaf-defun) (const :leaf-defvar) (const :leaf-path) (symbol :tag "A keyword in `M-x leaf-available-keywords`")) :value-type (choice boolean (sexp :tag "Default value of the keyword"))) :group leaf] 8) #@50 The value for all `leaf' blocks for leaf system. (defvar leaf-system-defaults (list :leaf-autoload t :leaf-defer t :leaf-protect t :leaf-defun t :leaf-defvar t :leaf-path t) (#$ . 13029)) (byte-code "\300\301\302\303\304DD\305\306\307\310\311&\210\300\312\302\303\313DD\314\306\307\310\311&\210\300\315\302\303\316DD\317\306\320\310\311&\210\300\321\302\303\322DD\323\306\307\310\311&\210\300\324\302\303\325DD\326\306\307\310\311&\210\300\327\302\303\330DD\331\306\320\310\311&\210\300\332\302\303\333DD\334\306\307\310\311&\210\300\335\302\303\336DD\337\306\340\310\311&\210\300\341\302\303\342DD\343\306\320\344\345\310\311& \210\300\346\302\303\347DD\350\306\320\344\351\310\311& \207" [custom-declare-variable leaf-defer-keywords funcall function #[0 "\300\301\302\303\304\305\306\307\257\207" [:bind :bind* :mode :interpreter :magic :magic-fallback :hook :commands] 8] "The specified keyword is interpreted as a defer keyword.\n`leaf' blocks containing the keywords are interpreted as lazy loadable.\nTo stop this function, specify ':leaf-defer nil'" :type sexp :group leaf leaf-alias-keyword-alist #[0 "\300\207" [((:ensure . :package))] 1] "The alias keyword. KEY is treated as an alias for VALUE." leaf-expand-minimally #[0 "\300\207" [nil] 1] "If non-nil, make the expanded code as minimal as possible.\nIf non-nil, disabled keywords of `leaf-expand-minimally-suppress-keywords'." boolean leaf-expand-minimally-suppress-keywords #[0 "\300\207" [(:leaf-protect :leaf-defun :leaf-defvar :leaf-path)] 1] "Suppress keywords when `leaf-expand-minimally' is non-nil." leaf-options-ensure-default-pin #[0 "\300\207" [nil] 1] "Set the default pin with :package.\n'nil is using package manager default.\nThis feature is not yet implemented." leaf-use-authinfo #[0 "\300\207" [nil] 1] "If non-nil value, use raw authinfo file as encripted file.\nIf nil, use authinfo.plist powerd by `plstore' for :auth-* keywords'" leaf-default-plstore #[0 "\300\301!\302!\205\f\303!\207" [locate-user-emacs-file "leaf-plstore.plist" file-readable-p plstore-open] 3] "Default value if omit store variable in plstore related keywords.\nThis variable must be result of `plstore-open'." leaf-find-regexp #[0 "\300\207" [#1=".*([[:space:]]*leaf[[:space:]]+\\(%s\\)"] 1 #1#] "The regexp used by `leaf-find' to search for a leaf block.\nNote it must contain a `%s' at the place where `format'\nshould insert the leaf name." regexp leaf-enable-imenu-support #[0 "\300\207" [t] 1] "If non-nil, enable `imenu' integrations.\nRef: `lisp-imenu-generic-expression'." :set #[514 "L\210\300\301\203\302\303\304\305\306\307BBDE\202%\310\311\312\304\305\306\313BBD\314BBE\"\207" [eval-after-load lisp-mode add-to-list 'lisp-imenu-generic-expression quote "Leaf" ".*([[:space:]]*leaf[[:space:]]+\\(\\(?:\\sw\\|\\s_\\|\\\\.\\)+\\)" (1) setq lisp-imenu-generic-expression delete (1) (lisp-imenu-generic-expression)] 11 "\n\n(fn SYM VALUE)"] leaf-find-function-support #[0 "\300\207" [t] 1] "If non-nil, enable `find-func' integrations.\nRef: `find-function-regexp-alist'." #[514 "L\210\300\301\203\302\202\303\"\207" [eval-after-load find-func (add-to-list 'find-function-regexp-alist '(leaf . leaf-find-regexp)) (setq find-function-regexp-alist (delete '(leaf . leaf-find-regexp) find-function-regexp-alist))] 5 "\n\n(fn SYM VALUE)"]] 10) #@265 Another implementation for `mapcan'. `mapcan' uses `nconc', but Emacs-22 doesn't support it. Apply FUNC to each element of SEQ, and concatenate the results by altering them (using `nconc'). SEQ may be a list, a vector, a 'bool-vector, or a string. (fn FUNC SEQ) (defalias 'leaf-mapcaappend #[514 "\300\301\302\"\"\207" [apply append mapcar] 7 (#$ . 16367)]) (byte-code "\300\301\302\303#\304\305!\204\306\305\301\"\210\300\207" [function-put leaf-mapcaappend lisp-indent-function 2 fboundp mapcan defalias] 4) #@104 Return t if VAR is pair. If ALLOW is non-nil, allow nil as the last element. (fn VAR &optional ALLOW) (defalias 'leaf-pairp #[513 "<\2053A:\203)\301>\204)\302!\303U\2053\304A@D\305\304D\306BB\235\2053\211\203/\307\207A??\207" [backquote-backquote-symbol lambda safe-length 3 quote 'quote ('function) t] 6 (#$ . 16890)]) #@110 Return t if VAR is doted list. If ALLOW is non-nil, allow nil as the last element. (fn VAR &optional ALLOW) (defalias 'leaf-dotlistp #[513 "\300\"\206\300\301!\"\206\300\301\302\"\"\207" [leaf-pairp last 3] 6 (#$ . 17231)]) #@67 Return t if LIST contained element of SYMLIST. (fn SYMLIST LIST) (defalias 'leaf-list-memq #[514 "\300\301\302\303\304\"\"\"\207" [delq nil mapcar make-closure #[257 "\211\300>\207" [V0] 3 "\n\n(fn X)"]] 8 (#$ . 17472)]) #@39 Return flatten list of LST. (fn LST) (defalias 'leaf-flatten #[257 "\300C\211\301\302\"\240\210\211\242!\207" [nil make-closure #[257 "\211:\204\211C\207\301\300\242\"\207" [V0 mapcan] 4 "\n\n(fn LST)"]] 6 (#$ . 17702)]) #@50 Substitute NEW for OLD in LST. (fn OLD NEW LST) (defalias 'leaf-subst #[771 "\300\301\302#\"\207" [mapcar make-closure #[257 "\211\300=\203\301\207\207" [V0 V1] 3 "\n\n(fn ELM)"]] 8 (#$ . 17935)]) (byte-code "\300\301\302\303#\300\207" [function-put leaf-subst lisp-indent-function 2] 4) #@153 Return a copy of LIST, which may be a dotted list. see `cl-copy-list'. The elements of LIST are not copied, just the list structure itself. (fn LIST) (defalias 'leaf-copy-list #[257 "\211:\203\300:\203\211A\262\242B\262\202\211\237\241\210\207\211@\207" [nil] 5 (#$ . 18236)]) #@60 Insert VALUE into LIST after INDEX. (fn VALUE LIST INDEX) (defalias 'leaf-insert-after #[771 "\211\233\211AB\241\266\207" [] 7 (#$ . 18534)]) #@102 Insert VALUE into LIST after TARGET search with SEARCHFN. (fn VALUE LIST TARGET &optional SEARCHFN) (defalias 'leaf-insert-after-value #[1027 "G\206\300\"\211\204\301\302#\207\303GZ#\207" [memq leaf-error "%s is not found in given list; %s" leaf-insert-after] 11 (#$ . 18689)]) #@256 Apply FN to each element of SEQ, and make a list of the results. The result is a list just as long as SEQUENCE. SEQ may be a list, a vector, a 'bool-vector, or a string. Unlike `mapcar', it works well with dotlist (last cdr is non-nil list). (fn FN SEQ) (defalias 'leaf-safe-mapcar #[514 "\300!A\203\301!\262\300!\302\241\210\303\"\207" [last leaf-copy-list nil mapcar] 5 (#$ . 18992)]) #@220 Return a copy of LIST with the last N elements removed. If N is omitted or nil, the last element is removed from the copy. Unlike `butlast', it works well with dotlist (last cdr is non-nil list). (fn LIST &optional N) (defalias 'leaf-safe-butlast #[513 "\300!A\203\301!\262\300!\302\241\210\303\"\207" [last leaf-copy-list nil butlast] 5 (#$ . 19395)]) #@36 Get all keys of PLIST. (fn PLIST) (defalias 'leaf-plist-keys #[257 "\300\203\211A\262\242B\262A\262\202\211\237\207" [nil] 4 (#$ . 19763)]) #@87 `plist-get' with DEFAULT value in PLIST search KEY. (fn KEY PLIST &optional DEFAULT) (defalias 'leaf-plist-get #[770 "\300\"\203\301\"\206\211\207" [plist-member plist-get] 6 (#$ . 19921)]) (byte-code "\301\302\303\304#\305\306\"\203\301\302\307\310#\210\301\207" [emacs-version function-put leaf-plist-get lisp-indent-function 1 version<= "24.3" gv-expander #[1027 "\300!\203 \211\202\301\302!\303\304\305 %\"=\203#\207\306DC\"\207" [macroexp-copyable-p make-symbol "k" gv-get make-closure #[514 "\304\303E\305!\203\211\202\306\307!\300\302\204\310D\202#\311\310D\302F\312\313\301\303  %\"=\2034\207\314DC\"\207" [V0 V1 V2 V3 plist-member macroexp-const-p make-symbol "p" cadr if make-closure #[257 "\304\305\300\301E\306\307\305\300\301EDE\303\310\301\310\302EE!F\207" [V0 V1 V2 V3 if plist-member setcar cdr cons] 10 "\n\n(fn VAL)"] macroexp-let*] 12 "\n\n(fn GETTER SETTER)"] macroexp-let*] 14 "\n\n(fn DO KEY PLIST &optional DEFAULT)"]] 5) #@248 Find the first element of ALIST whose `car' equals KEY and return its `cdr'. If KEY is not found in ALIST, return DEFAULT. Equality with KEY is tested by TESTFN, defaulting to `eq'. see `alist-get'. (fn KEY ALIST &optional DEFAULT REMOVE TESTFN) (defalias 'leaf-alist-get #[1282 "\211\204\n\236\202\300#\211\203\211A\207\207" [assoc] 9 (#$ . 20927)]) #@76 Return normalizied `intern'ed symbol from KEYWORD or SYMBOL. (fn KEYWORD) (defalias 'leaf-sym-from-keyword #[257 "\300!\203\301\302!\303\304O!\207\207" [keywordp intern symbol-name 1 nil] 5 (#$ . 21296)]) #@45 Return mode like symbol from SYM. (fn SYM) (defalias 'leaf-mode-sym #[257 "\301!\302\303\304\305\306#)\266\203?\205\307P!\207" [inhibit-changing-match-data symbol-name intern "-mode$" nil t string-match "-mode"] 11 (#$ . 21512)]) #@97 Raise error with type leaf. MESSAGE and ARGS is same form as `lwarn'. (fn MESSAGE &rest ARGS) (defalias 'leaf-error #[385 "\300\301\302\303BBB\"\207" [apply lwarn leaf :error] 8 (#$ . 21758)]) #@59 Create message for TYPE using ARGS. (fn TYPE &rest ARGS) (defalias 'leaf--create-custom-comment #[385 "\302\303\"\304>\205\211A\262\242\302\305\"\262 \205\302\306 \"Q\207" [leaf--name load-file-name format "Customized with leaf in `%s' block" (:pl-custom :auth-custom) " using `%s' plstore" " at `%s'"] 7 (#$ . 21961)]) #@27 Return path to this file. (defalias 'leaf-this-file #[0 "\304\300!\203\n\206\304\301!\203 \206\n\206 \207" [leaf--load-file-name byte-compile-current-file load-file-name buffer-file-name boundp] 2 (#$ . 22298)]) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put leaf-this-file speed -1 put byte-optimizer byte-compile-inline-expand] 5) #@48 Return current available `leaf' keywords list. (defalias 'leaf-available-keywords #[0 "\302!\303\304\305 \"!\304\306\"\211\211\2039\211@\211@A\211>\204*\307\310 #\266\2022\311#\266A\266\202\202\210\312\313!\203G\314\315!!\207\207" [leaf-keywords leaf-alias-keyword-alist leaf-plist-keys delete-dups mapcar car #[257 "\211\301\"B\207" [leaf-alias-keyword-alist leaf-alist-get] 5 "\n\n(fn ELM)"] leaf-error "`leaf-alias-keyword-alist' is broken. %s is missing from leaf-keywords; %s" leaf-insert-after-value called-interactively-p interactive message prin1-to-string] 11 (#$ . 22666) nil]) #@69 Return format string of `leaf' SEXP like `pp-to-string'. (fn SEXP) (defalias 'leaf-pp-to-string '(macro . #[257 "\300\301DD\207" [with-output-to-string leaf-pp] 4 (#$ . 23285)])) #@67 Output the pretty-printed representation of leaf SEXP. (fn SEXP) (defalias 'leaf-pp #[257 "\300\301\302\303\"r\211q\210\304\305\"\216\306\307\310\311\312\313\314\315 \"BDD!\316\317!#c\210\320 \210\321 \210\322ed\"\210\323ed\"*\262\324\325P!\266\207" [nil generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205 \302\300!\207" [V0 buffer-name kill-buffer] 2] replace-regexp-in-string eval rx group or mapcar symbol-name leaf-available-keywords "\n\\1" prin1-to-string delete-trailing-whitespace emacs-lisp-mode indent-region buffer-substring-no-properties princ "\n"] 11 (#$ . 23472)]) (defvar leaf-expand-buffer-name "*Leaf Expand*") (defvar leaf-expand-issue-template "## Description\n\n\n\n## Issue leaf-block\n```elisp\n%s\n```\n\n## `macroexpand-1` leaf-block\n```elisp\n%s\n```\n\n## Expected leaf-block\n\n\n\n```elisp\n\n\n```\n") #@31 Create issue template buffer. (defalias 'leaf-create-issue-template #[0 "\306!\212\3071\310\311!?\205\312\313!\210\2020\210\202\314\266\315\316 \317`\313\"\")\320!\321rq\210\322 \210\323\n\314\211\321\324\325\326!\203G\326\202H\327!!+#c\210\330!*\207" [leaf-expand-buffer-name leaf-expand-minimally leaf-expand-issue-template print-quoted eval-expression-print-level eval-expression-print-length get-buffer-create (error) looking-at "(leaf " backward-up-list 1 nil buffer-substring-no-properties line-beginning-position scan-sexps read t erase-buffer format pp-to-string fboundp macroexpand-1 macroexpand display-buffer] 9 (#$ . 24424) nil]) #@25 Expand `leaf' at point. (defalias 'leaf-expand #[0 "\305!\212\3061\307\310!?\205\311\312!\210\2020\210\202\313\266\314\315 \316`\312\"\")\317!\320rq\210\321 \210\322\323\324\325\326\"\313\211\320\327\330\331!\203K\331\202L\332!!+$c\210\333 \210\334ed\"\210\335!*\207" [leaf-expand-buffer-name leaf-expand-minimally print-quoted eval-expression-print-level eval-expression-print-length get-buffer-create (error) looking-at "(leaf " backward-up-list 1 nil buffer-substring-no-properties line-beginning-position scan-sexps read t erase-buffer format "%s\n\n;; %s\n\n%s" make-string 80 45 pp-to-string fboundp macroexpand-1 macroexpand emacs-lisp-mode indent-region display-buffer] 10 (#$ . 25093) nil]) #@188 Safely add NEWELT to the list stored in the generalized variable PLACE. This is equivalent to `push' if PLACE is bound, otherwise, `setq' is used to define a new list. (fn NEWELT PLACE) (defalias 'leaf-safe-push '(macro . #[514 "\300\301\302DD\303E\304\305DEF\207" [if boundp quote push setq list] 9 (#$ . 25822)])) #@41 Find the leaf block of NAME. (fn NAME) (defalias 'leaf-find #[257 "\301\302!\210\303!\304\305\306\"\"\211G\307U\203\211@\202\310\311\"\312\313#\211\2058\314@!A\2034Ab\210\315\316!\210\207" [leaf--paths require find-func intern mapcan make-closure #[257 "\300@=\205\n\211AC\207" [V0] 3 "\n\n(fn ELM)"] 1 completing-read "Select one: " find-function-search-for-symbol leaf pop-to-buffer run-hooks find-function-after-hook] 8 (#$ . 26151) (byte-code "\301\302\303\"!\211\204\304\305!\207\306\307\301\302\303\"!\"C\207" [leaf--paths delete-dups mapcar car error "Leaf has no definition informations" completing-read "Find leaf: "] 7)]) #@39 The leaf-override-global-mode keymap. (defvar leaf-key-override-global-map (make-keymap) (#$ . 26811)) #@127 Non-nil if Leaf-Key-Override-Global mode is enabled. Use the command `leaf-key-override-global-mode' to change this variable. (defvar leaf-key-override-global-mode t (#$ . 26921)) (make-variable-buffer-local 'leaf-key-override-global-mode) #@642 A minor mode so that keymap settings override other modes. This is a minor mode. If called interactively, toggle the `Leaf-Key-Override-Global mode' mode. If the prefix argument is positive, enable the mode, and if it is zero or negative, disable the mode. If called from Lisp, toggle the mode if ARG is `toggle'. Enable the mode if ARG is nil, omitted, or is a positive number. Disable the mode if ARG is a negative number. To check whether the minor mode is enabled in the current buffer, evaluate `leaf-key-override-global-mode'. The mode's hook is called both when the mode is enabled and when it is disabled. (fn &optional ARG) (defalias 'leaf-key-override-global-mode #[256 "\302 \303=\203 ?\202\247\203\304W\203\305\202\306\307\301!\2031\310\300 \"\2031\300 B\311\312\203;\313\202<\314\"\210\315\316!\203^\302 \203P\211\302 \232\203^\317\320\203Z\321\202[\322\323#\210\210\324 \210\207" [leaf-key-override-global-mode local-minor-modes current-message toggle 1 nil t boundp delq run-hooks leaf-key-override-global-mode-hook leaf-key-override-global-mode-on-hook leaf-key-override-global-mode-off-hook called-interactively-p any message "Leaf-Key-Override-Global mode %sabled%s" "en" "dis" " in current buffer" force-mode-line-update] 6 (#$ . 27168) (byte-code "\203\n\301!\202 \302C\207" [current-prefix-arg prefix-numeric-value toggle] 2)]) (defvar leaf-key-override-global-mode-hook nil) (byte-code "\302\303N\204\f\304\302\303\305#\210\304\302\306\307#\210\304\302\310\311C#\210\312\313\314\315\300!\205#\311\211%\210\316\317\313 BC\"\207" [leaf-key-override-global-mode-map leaf-key-override-global-map leaf-key-override-global-mode-hook variable-documentation put "Hook run after entering or leaving `leaf-key-override-global-mode'.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" custom-type hook standard-value nil add-minor-mode leaf-key-override-global-mode "" boundp add-to-list emulation-mode-map-alists] 6) #@98 List of bindings performed by `leaf-key'. Elements have the form (MAP KEY CMD ORIGINAL-CMD PATH) (defvar leaf-key-bindlist nil (#$ . 29224)) #@900 Bind KEY to COMMAND in KEYMAP (`global-map' if not passed). KEY-NAME may be a vector, in which case it is passed straight to `define-key'. Or it may be a string to be interpreted as spelled-out keystrokes. See documentation of `edmacro-mode' for details. COMMAND must be an interactive function or lambda form. KEYMAP, if present, should be a keymap and not a quoted symbol. For example: (leaf-key "M-h" #'some-interactive-function my-mode-map) If PREDICATE is non-nil, it is a form evaluated to determine when a key should be bound. It must return non-nil in such cases. Emacs can evaluate this form at any time that it does redisplay or operates on menu data structures, so you should write it so it can safely be called at any time. You can also use [remap COMMAND] as KEY. For example: (leaf-key [remap backward-sentence] 'sh-beginning-of-command) (fn KEY COMMAND &optional KEYMAP) (defalias 'leaf-key '(macro . #[770 "\304!\304!\304!\211\206\305\306!\307\300!\203\206*\307\301!\203% \206*\n\206* \310\306!\2047\311!\210;\203B\202F\312!\313\314\315\203U \202Y\316\fDED\317\320\f\321\n\257DDD\322\323\203x\f\202|\316 D\324 DFF\207" [leaf--load-file-name byte-compile-current-file load-file-name buffer-file-name eval global-map vectorp boundp nil read-kbd-macro key-description let* old lookup-key kbd value \` (\, (and old (not (numberp old)) old)) (leaf-safe-push value leaf-key-bindlist) define-key quote] 20 (#$ . 29372)])) #@105 Similar to `leaf-key', but overrides any mode-specific bindings. Bind COMMAND at KEY. (fn KEY COMMAND) (defalias 'leaf-key* '(macro . #[514 "\300\301BBB\207" [leaf-key ('leaf-key-override-global-map)] 6 (#$ . 30872)])) #@697 Bind multiple BIND for KEYMAP defined in PKG. BIND is (KEY . COMMAND) or (KEY . nil) to unbind KEY. If BIND-KEYMAP is non-nil generate `leaf-key-bind-keymap' instead of `leaf-key'. If BIND-KEYMAP-PKG is passed, require it before binding. OPTIONAL: BIND also accept below form. (:{{map}} :package {{pkg}} (KEY . COMMAND) (KEY . COMMAND)) KEYMAP is quoted keymap name. PKG is quoted package name which define KEYMAP. (wrap `eval-after-load' PKG) If DRYRUN-NAME is non-nil, return list like (LEAF_KEYS-FORMS (FN FN ...)) If omit :package of BIND, fill it in LEAF_KEYS-FORM. NOTE: BIND can also accept list of these. (fn BIND &optional DRYRUN-NAME BIND-KEYMAP BIND-KEYMAP-PKG) (defalias 'leaf-keys '(macro . #[1025 "\300\301C\301C\301C\301C\302\303\n\n\n\n\n\n\n\n& \240\210\242 !\210\2035\304\242\237\242\237DD\207\242A\203A\305\242\237B\207\242@\207" [#[257 "\3001 \211<\205\301@!;\204\302\301@!!\205\211A:?0\207\303\207" [(error) eval vectorp nil] 4 "\n\n(fn X)"] nil make-closure #[257 "\303!\2033\305\301\203\310@A\311\302\257\202\312@\313ADE\305\242B\240\210\306\306\242B\240\210\307A\307\242B\240\207\211@<\203O\303@!\203O\314\315\316\301\302\303\304\305\306\307&\"\207\317@!\204\\\211@9\203\332\320@!\321\322A\"\211\203o\323\233\202qA\303@!\203|\211\202~\211@\324\314\315\325\301\307  %\"B\306\203\234\322BBB\202\243\322\300BBB\306\242B\240\210\203\323:\204\266C\202\267\211\203\322\211@\301\204\313\326\327D\327DE\262A\266\202\202\267\210\305\305\242B\240\207\314\315\330\304\"\"\207" [V0 V1 V2 V3 V4 V5 V6 V7 leaf-key-bind-keymap nil leaf-key function mapcar make-closure #[257 "\302!\2033\304\300\203\307@A\310\301\257\202\311@\312ADE\304\242B\240\210\305\305\242B\240\210\306A\306\242B\240\207\303\242!\207" [V0 V1 V2 V3 V4 V5 V6 leaf-key-bind-keymap nil leaf-key function] 7 "\n\n(fn ELM)"] keywordp leaf-sym-from-keyword leaf-plist-get :package 3 progn #[257 "\301A\301\242B\240\210\300\203\304@A\305\302D\305\303D\257\207\306@\307AD\305\302DF\207" [V0 V1 V2 V3 leaf-key-bind-keymap quote leaf-key function] 7 "\n\n(fn ELM)"] eval-after-load quote #[257 "\300\242!\207" [V0] 3 "\n\n(fn ELM)"]] 13 "\n\n(fn BIND)"] quote progn] 20 (#$ . 31101)])) #@116 Similar to `leaf-keys' but bind BIND to `leaf-key-override-global-map'. BIND must not contain :{{map}}. (fn BIND) (defalias 'leaf-keys* '(macro . #[257 "\211@:\204\211A:\204\211C\202\211\300\301BD\207" [leaf-keys :leaf-key-override-global-map] 5 (#$ . 33397)])) #@137 Bind KEY to KMAP in KEYMAP (`global-map' if not passed). If PKG passed, require PKG before binding. (fn KEY KMAP &optional KEYMAP PKG) (defalias 'leaf-key-bind-keymap '(macro . #[1026 "\300\205\301D\302FE\207" [progn require leaf-key] 10 (#$ . 33674)])) #@173 Similar to `leaf-keys-bind-keymap', but overrides any mode-specific bindings. Bind KEYMAP at KEY. If PKG passed, require PKG before binding. (fn KEY KEYMAP &optional PKG) (defalias 'leaf-key-bind-keymap* '(macro . #[770 "\300\301\257\207" [leaf-keys-bind-keymap 'leaf-key-override-global-map] 8 (#$ . 33946)])) #@575 Bind multiple BIND for KEYMAP defined in PKG. BIND is (KEY . KEYMAP) or (KEY . nil) to unbind KEY. If PKG passed, require PKG before binding. OPTIONAL: BIND also accept below form. (:{{map}} :package {{pkg}} (KEY . KEYMAP) (KEY . KEYMAP)) KEYMAP is quoted keymap name. PKG is quoted package name which define KEYMAP. (wrap `eval-after-load' PKG) If DRYRUN-NAME is non-nil, return list like (LEAF_KEYS-FORMS (FN FN ...)) If omit :package of BIND, fill it in LEAF_KEYS-FORM. NOTE: BIND can also accept list of these. (fn BIND &optional DRYRUN-NAME PKG) (defalias 'leaf-keys-bind-keymap '(macro . #[769 "\300\301\257\207" [leaf-keys 'bind-keymap] 8 (#$ . 34269)])) #@178 Similar to `leaf-keys-bind-keymap' but overrides any mode-specific bindings. BIND must not contain :{{map}}. If PKG passed, require PKG before binding. (fn BIND &optional PKG) (defalias 'leaf-keys-bind-keymap* '(macro . #[513 "@:\204A:\204C\202\300\301BE\207" [leaf-keys :leaf-key-override-global-map] 6 (#$ . 34965)])) (defvar leaf-key-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" [leaf-key-list-mode-hook variable-documentation put "Hook run after entering Leaf-key Bindings mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp leaf-key-list-mode-map definition-name leaf-key-list-mode] 4) (defvar leaf-key-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" [leaf-key-list-mode-abbrev-table leaf-key-list-mode-map variable-documentation put purecopy "Keymap for `leaf-key-list-mode'." boundp leaf-key-list-mode-syntax-table definition-name leaf-key-list-mode (lambda (#1=#:def-tmp-var) (defvar leaf-key-list-mode-syntax-table #1#)) make-syntax-table "Syntax table for `leaf-key-list-mode'." (lambda (#1#) (defvar leaf-key-list-mode-abbrev-table #1#)) define-abbrev-table nil "Abbrev table for `leaf-key-list-mode'." derived-mode-parent tabulated-list-mode] 5) #@274 Major mode for listing bindings configured via `leaf-key'. In addition to any hooks its parent mode `tabulated-list-mode' might have run, this mode runs the hook `leaf-key-list-mode-hook', as the final or penultimate step during initialization. \{leaf-key-list-mode-map} (defalias 'leaf-key-list-mode #[0 "\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\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R &=\204R\326 \325&C#\210\327 !\210\330\f!\210 &\331'\332\333\334(\211\203\235\211@T\262\335@!A@!\3368!\3378! \3408!%DB\262A\266\202\202e\210\211\237\266\203)\341*\342 \210\343 \210)\344\345!\207" [delay-mode-hooks major-mode mode-name leaf-key-list-mode-map leaf-key-list-mode-syntax-table leaf-key-list-mode-abbrev-table make-local-variable t tabulated-list-mode leaf-key-list-mode "Leaf-key Bindings" 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 [("Map" 20 t) ("Key" 20 t) ("Command" 40 t) ("Before Command" 40 t) ("Path" 0 t)] 0 #[257 "\211;\203\207\300\301=\203\302\202!\207" [prin1-to-string nil ---] 4 "\n\n(fn ELM)"] nil vector 2 3 4 ("Map") tabulated-list-print tabulated-list-init-header run-mode-hooks leaf-key-list-mode-hook local-abbrev-table tabulated-list-format leaf-key-bindlist tabulated-list-entries tabulated-list-sort-key] 14 (#$ . 36562) nil]) #@53 Display all the bindings configured via `leaf-key'. (defalias 'leaf-key-describe-bindings #[0 "\300\301!\210\302\303!r\211q\210\304 \210)\305!\207" [require tabulated-list get-buffer-create "*Leaf-key bindings*" leaf-key-list-mode display-buffer] 3 (#$ . 38127) nil]) #@74 Registor FN as autoload for PKG. FN also accept list of FN. (fn FN PKG) (defalias 'leaf-register-autoload #[514 "\300\301\302\"<\203\202C\"\207" [mapc make-closure #[257 "\211\302\300!B\2059\205\211 \235?\205\211 B\211\207" [V0 leaf--autoload symbol-name] 4 "\n\n(fn ELM)"]] 6 (#$ . 38402)]) #@74 Registor FN as autoload for PKG. FN also accept list of FN. (fn FN PKG) (defalias 'leaf-register-bind-keymap-autoload #[514 "\300\301\302\"<\203\202C\"\207" [mapc make-closure #[257 "\302\303\304\300#!\305\300!B\205 9\205 \211 \235?\205 \211 B\211\207" [V0 leaf--autoload intern format "leaf-key--bind-keymap--%s--%s" symbol-name] 6 "\n\n(fn ELM)"]] 6 (#$ . 38718)]) #@85 Meta handler for :leaf-protect in NAME for BODY `leaf' block. (fn NAME &rest BODY) (defalias 'leaf-handler-leaf-protect '(macro . #[385 "\301\302\303B\304\305\306\307\211\310\n\"\205\307\311\"\312Q\313BBEDF\207" [load-file-name condition-case err progn error display-warning 'leaf format "Error in `%s' block" " at `%s'" ". Error msg: %s" ((error-message-string err))] 13 (#$ . 39107)])) (byte-code "\300\301\302\303#\300\207" [function-put leaf-handler-leaf-protect lisp-indent-function 1] 4) #@50 Meta handler for :leaf-path for NAME. (fn NAME) (defalias 'leaf-handler-leaf-path '(macro . #[257 "\300\301\302\303\304\305\306\307\310 D\311BBEEF\207" [let ((file (leaf-this-file))) (unless (boundp 'leaf--paths) (defvar leaf--paths nil)) when file add-to-list 'leaf--paths cons quote (file)] 11 (#$ . 39615)])) #@67 Handler ensure PKG via PIN in NAME leaf block. (fn NAME PKG PIN) (defalias 'leaf-handler-package '(macro . #[771 "\301\302\303DD\301\304\303D\305BB\306BB\307\310\311\303DD\312\307\313\314\315\311\303DDE\312\316\317\320\211\321\"\2057\320\322\"\320\323\"\324R\325BBEDFDFF\207" [load-file-name unless package-installed-p quote assoc (package-archive-contents) ((package-refresh-contents)) condition-case _err package-install error err progn (package-refresh-contents) display-warning 'leaf format "In `%s' block" " at `%s'" ", failed to :package of `%s'." " Error msg: %s" ((error-message-string err))] 22 (#$ . 39935)])) #@68 Handler auth-* to set SYM of NAME from STORE. (fn NAME SYM STORE) (defalias 'leaf-handler-auth '(macro . #[771 "\203\301\302\303\304\305\306\"EDC\307\302\310\311\305\312 \"\313BBFE\207\307\301\302\314\315\305\306 \"EDDC\307\302\316\302\317\305\320\f\"!E\311\305\321\f\"DFE\322BBB\207" [leaf-use-authinfo let res auth-source-search :host format "leaf-%s" if (funcall (plist-get (car res) :secret)) error "Failed to search `leaf-%s' as machine/host name in auth-sources: '%%s" (auth-sources) cdr-safe plstore-get plist-get intern ":%s" "Failed to search `leaf-%s' in specified plstore" ((error "Right value is returns nil or `leaf-default-plstore' is not set"))] 15 (#$ . 40577)])) #@44 Apply keyword alias for PLIST. (fn PLIST) (defalias 'leaf-apply-keyword-alias #[257 "\301\302\303\"!\302\304\"\211\211\203&\211@\211@A\305 #\262\266A\266\202\202 \210\207" [leaf-alias-keyword-alist delete-dups mapcar car #[257 "\211\301\"B\207" [leaf-alias-keyword-alist leaf-alist-get] 5 "\n\n(fn ELM)"] leaf-subst] 11 (#$ . 41276)]) #@64 Append leaf default values to PLIST and return it. (fn PLIST) (defalias 'leaf-append-defaults #[257 "\304\205 \305\306 \"\n $\207" [leaf-expand-minimally leaf-expand-minimally-suppress-keywords leaf-defaults leaf-system-defaults append mapcan #[257 "\211\300D\207" [nil] 3 "\n\n(fn ELM)"]] 6 (#$ . 41632)]) #@836 Return normalized list from LST. PROVVAL is provisionary value. Example: - when DOTLISTP is nil a => (a) (a b c) => (a b c) (a . b) => (a . b) (a . nil) => (a . nil) (a) => (a . nil) ((a . b) (c . d)) => ((a . b) (c . d)) ((a) (b) (c)) => ((a) (b) (c)) ((a b c) . d) => ((a b c) . d) - when DOTLISTP is non-nil a => ((a)) (a b c) => ((a) (b) (c)) (a . b) => ((a . b)) (a . nil) => ((a . nil)) (a) => ((a . nil)) ((a . b) (c . d)) => ((a . b) (c . d)) ((a) (b) (c)) => ((a) (b) (c)) ((a b c) . d) => ((a . d) (b . d) (c . d)) ((x . y) ((a b c) . d)) => ((x . y) (a . d) (b . d) (c . d)) (fn LST &optional DOTLISTP PROVVAL) (defalias 'leaf-normalize-list-in-list #[769 "\204:\204\fC\207\207:\204BC\207<\205g\301\302!A\203,\302!A\202Y\303>\203@\302\303>G\211\262\"\202Y\304\302\305\"@D\306\304D\307BB\235\205Y\302\305\211\262\"\310\311\312#\313\"\"\266\202\207" [backquote-backquote-symbol 0 last lambda quote 2 'quote ('function) mapcan make-closure #[257 "\302\303\301\206\300#\207" [V0 V1 leaf-normalize-list-in-list t] 5 "\n\n(fn ELM)"] leaf-safe-butlast] 10 (#$ . 41950)]) #@201 Given a list-valued PLIST, return sorted-list PLIST. EXAMPLE: (leaf-sort-values-plist '(:config (message "a") :disabled (t))) => (:disabled (t) :config (message "a")) (fn PLIST) (defalias 'leaf-sort-values-plist #[257 "\300\301 \211\203)\211@\302\"\203\"\303\304\"D\"\262\305\300#\210A\266\202\202\210\203O\211A\262\242\211A\262\242\211\203J\306\307\310\311\312!\"C\"\210\266\202*\207" [nil leaf-available-keywords plist-member append plist-get plist-put signal error format "leaf: Unrecognized keyword %s" symbol-name] 10 (#$ . 43283)]) #@270 Given a PLIST, return list-valued PLIST. EXAMPLE: (leaf-merge-value-on-duplicate-key '(:defer (t) :config ((message "a") (message "b")) :config ((message "c")))) => (:defer (t) :config ((message "a") (message "b") (message "c"))) (fn PLIST) (defalias 'leaf-merge-dupkey-values-plist #[257 "\300\2035\211A\262\242\211A\262\242\301\"\203*\302\303\304\"\"#\266\202\303D\"\266\203\202\207" [nil plist-member plist-put append plist-get] 11 (#$ . 43876)]) #@590 Given a pseudo-PLIST, return PLIST. If MERGEP is t, return well-formed PLIST. If EVALP is t, `eval' each element which have `quote' or `backquote'. EXAMPLE: (leaf-normalize-plist '(:defer t :config (message "a") (message "b") :config (message "c")) nil) => (:defer (t) :config ((message "a") (message "b")) :config ((message "c"))) (leaf-normalize-plist '(:defer t :config (message "a") (message "b") :config (message "c")) t) => (:defer (t) :config ((message "a") (message "b") (message "c")) (fn PLIST &optional MERGEP EVALP) (defalias 'leaf-normalize-plist #[769 "\301!\302\211\211\203J\211@\303!\203\"B\262\211B\262\302\262\202C\203>\211<\203>\304@D\305\304DD\235\203>\306!\202?\211B\262A\266\202\202\210\203S\307!\207\207" [backquote-backquote-symbol reverse nil keywordp quote 'quote eval leaf-merge-dupkey-values-plist] 12 (#$ . 44385)]) (byte-code "\300\301\302\303\304 \"B!\207" [eval progn mapcar #[257 "\300!\301\302O\303\304\305\306\"!\307\305\310\"\311BBBB\207" [symbol-name 1 nil defcustom intern format "leaf-expand-%s" t "If nil, do not expand values for :%s." (:type 'boolean :group 'leaf)] 8 "\n\n(fn ELM)"] leaf-available-keywords] 5) #@197 Process keywords for NAME via argument PLIST, RAW. NOTE: Not check PLIST, PLIST has already been carefully checked parent funcitons. Don't call this function directory. (fn NAME PLIST RAW) (defalias 'leaf-process-keywords #[771 "\205c\211A\262\242\306 !\307\310O\211A\262\242\211\310\311\312B!\311\312B!\313 \f#\314\315\316\n\"!\317!\203X\311!\203S\311\320 \"!\202_\202_\311\320 \"!\262.\207" [leaf--name leaf--key leaf--keyname leaf--value leaf--raw leaf--rest symbol-name 1 nil eval cond leaf-process-keywords intern format "leaf-expand-%s" boundp plist-get leaf--body leaf-normalize leaf-verify leaf-keywords] 8 (#$ . 45639)]) #@88 Symplify your `.emacs' configuration for package NAME with ARGS. (fn NAME &rest ARGS) (defalias 'leaf '(macro . #[385 "\301\302\303\304!!\305\306#!\307\310\311D\312\211#)BB\207" [leaf--autoload leaf-sort-values-plist leaf-normalize-plist leaf-apply-keyword-alias leaf-append-defaults merge eval nil prog1 quote leaf-process-keywords] 9 (#$ . 46321)])) (byte-code "\300\301\302\303#\304\301!\207" [function-put leaf lisp-indent-function defun provide] 4)