;ELC ;;; Compiled ;;; in Emacs version 26.3 ;;; 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. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; #@987 Return the string name of file/buffer that is currently begin executed. The first approach for getting this information is perhaps the most pervasive and reliable. But it the most low-level and not part of a public API, so it might change in future implementations. This method uses the name that is recorded by readevalloop of `lread.c' as the car of variable `current-load-list'. Failing that, we use `load-file-name' which should work in some subset of the same places that the first method works. However `load-file-name' will be nil for code that is eval'd. To cover those cases, we try function `buffer-file-name' which is initially correct, for eval'd code, but will change and may be wrong if the code sets or switches buffers after the initial execution. As a last resort, you can pass in SYMBOL which should be some symbol that has been previously defined if none of the above methods work we will use the file-name value find via `symbol-file'. (fn &optional SYMBOL) (defalias '__FILE__ #[256 "\242;\203 @\207 \206\303 \206\304\302!\203\n\207\305!\207" [current-load-list load-file-name bytecomp-filename buffer-file-name boundp symbol-file] 3 (#$ . 409)]) #@898 Autoload an Emacs Lisp file relative to Emacs Lisp code that is in the process of being loaded or eval'd. Define FUNCTION to autoload from FILE. FUNCTION is a symbol. FILE is a string to pass to `load'. DOCSTRING is documentation for the function. INTERACTIVE if non-nil says function can be called interactively. TYPE indicates the type of the object: nil or omitted says function is a function, `keymap' says function is really a keymap, and `macro' or t says function is really a macro. Third through fifth args give info about the real definition. They default to nil. If function is already defined other than as an autoload, this does nothing and returns nil. SYMBOL is the location of of the file of where that was defined (as given by `symbol-file' is used if other methods of finding __FILE__ don't work. (fn FUNCTION-OR-LIST FILE &optional DOCSTRING INTERACTIVE TYPE SYMBOL) (defalias 'autoload-relative #[1538 "<\203\"\300\301\302\303\304\305      &\306\"\307\310%\"\207\311\312\"%\207" [mapc make-byte-code 257 "\306\300\307\301\305\"\302\303\304%\207" vconcat vector [autoload relative-expand-file-name] 7 "\n\n(fn FUNCTION)" autoload relative-expand-file-name] 18 (#$ . 1602)]) #@640 Read relative FILENAME into a buffer and return the buffer. If a buffer exists visiting FILENAME, return that one, but verify that the file has not changed since visited or saved. The buffer is not selected, just returned to the caller. Optional second arg NOWARN non-nil means suppress any warning messages. Optional third arg RAWFILE non-nil means the file is read literally. Optional fourth arg WILDCARDS non-nil means do wildcard processing and visit all the matching files. When wildcards are actually used and expanded, return a list of buffers that are visiting the various files. (fn FILENAME &optional NOWARN RAWFILE WILDCARDS) (defalias 'find-file-noselect-relative #[1025 "\300\301!$\207" [find-file-noselect relative-expand-file-name] 9 (#$ . 2835)]) #@104 Read the relative FILE into a temporary buffer and evaluate BODY in this buffer. (fn FILE &rest BODY) (defalias 'with-relative-file '(macro . #[385 "\300\301\302DDBB\207" [with-temp-buffer insert-file-contents relative-expand-file-name] 6 (#$ . 3611)])) (byte-code "\300\301\302\303#\304\301\305\306#\207" [function-put with-relative-file lisp-indent-function 1 put edebug-form-spec t] 5) #@394 Load an Emacs Lisp file relative to Emacs Lisp code that is in the process of being loaded or eval'd. FILE-OR-LIST is either a string or a list of strings containing files that you want to loaded. If SYMBOL is given, the location of of the file of where that was defined (as given by `symbol-file' is used if other methods of finding __FILE__ don't work. (fn FILE-OR-LIST &optional SYMBOL) (defalias 'load-relative #[513 "<\203\300\301\302\303\304\305!\306\"\307\310%\"\207\311\312\"!\207" [mapcar make-byte-code 257 "\301\302\300\"!\207" vconcat vector [load relative-expand-file-name] 5 "\n\n(fn RELATIVE-FILE)" load relative-expand-file-name] 9 (#$ . 4010)]) #@242 Expand RELATIVE-FILE relative to the Emacs Lisp code that is in the process of being loaded or eval'd. WARNING: it is best to run this function before any buffer-setting or buffer changing operations. (fn RELATIVE-FILE &optional OPT-FILE) (defalias 'relative-expand-file-name #[513 "\211\206\n\301 \206\n\302\204\303\304!\210\305!\262\306P!\207" [default-directory __FILE__ nil error "Can't expand __FILE__ here and no file name given" file-name-directory expand-file-name] 7 (#$ . 4691)]) #@380 Run `require' on an Emacs Lisp file relative to the Emacs Lisp code that is in the process of being loaded or eval'd. The symbol used in require is the base file name (without directory or file extension) treated as a symbol. WARNING: it is best to to run this function before any buffer-setting or buffer changing operations. (fn RELATIVE-FILE &optional OPT-FILE OPT-PREFIX) (defalias 'require-relative #[769 "\211\300\301!!P\302\303!\304\"\"\207" [file-name-sans-extension file-name-nondirectory require intern relative-expand-file-name] 9 (#$ . 5200)]) #@173 Run `require-relative' on each name in LIST which should be a list of strings, each string being the relative name of file you want to run. (fn LIST &optional OPT-PREFIX) (defalias 'require-relative-list '(macro . #[513 "\300\301\302D\303\302\304FED\207" [eval-and-compile dolist rel-file require-relative (__FILE__)] 9 (#$ . 5772)])) #@406 Call `provide' with the feature's symbol name made from source-code's file basename sans extension. For example if you write (provide-me) inside file ~/lisp/foo.el, this is the same as writing: (provide \='foo). With a prefix, that prefix is prepended to the `provide' So in the previous example, if you write (provide-me "bar-") this is the same as writing (provide \='bar-foo). (fn &optional PREFIX) (defalias 'provide-me '(macro . #[256 "\300\301\302\303BBDD\207" [provide intern concat ((file-name-sans-extension (file-name-nondirectory (__FILE__))))] 6 (#$ . 6118)])) (byte-code "\300\301\302\303\304\305 !!P!!\207" [provide intern nil file-name-sans-extension file-name-nondirectory __FILE__] 6)