%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /usr/local/share/emacs/27.2/lisp/emacs-lisp/
Upload File :
Create Path :
Current File : //usr/local/share/emacs/27.2/lisp/emacs-lisp/elint.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\302\303\304\305\306\307&\210\310\311\312\313\314DD\315\316\317\320\321\306\301&	\210\310\322\312\313\323DD\324\316\325\320\326\306\301\327\330&\210\310\331\312\313\332DD\333\316\334\320\335\327\330\306\301&\210\310\336\312\313\337DD\340\316\341\320\342\306\301\327\330&\207" [custom-declare-group elint nil "Linting for Emacs Lisp." :prefix "elint-" :group maint custom-declare-variable elint-log-buffer funcall function #[0 "\300\207" [#1="*Elint*"] 1 #1#] "The buffer in which to log lint messages." :type string :safe stringp elint-scan-preloaded #[0 "\300\207" [t] 1] "Non-nil means to scan `preloaded-file-list' when initializing.\nOtherwise, just scan the DOC file for functions and variables.\nThis is faster, but less accurate, since it misses undocumented features.\nThis may result in spurious warnings about unknown functions, etc." boolean booleanp :version "23.2" elint-ignored-warnings #[0 "\300\207" [nil] 1] "If non-nil, a list of issue types that Elint should ignore.\nThis is useful if Elint has trouble understanding your code and\nyou need to suppress lots of spurious warnings.  The valid list elements\nare as follows, and suppress messages about the indicated features:\n  undefined-functions - calls to unknown functions\n  unbound-reference   - reference to unknown variables\n  unbound-assignment  - assignment to unknown variables\n  macro-expansions    - failure to expand macros\n  empty-let           - let-bindings with empty variable lists" (choice (const :tag "Don't suppress any warnings" nil) (repeat :tag "List of issues to ignore" (choice (const undefined-functions :tag "Calls to unknown functions") (const unbound-reference :tag "Reference to unknown variables") (const unbound-assignment :tag "Assignment to unknown variables") (const macro-expansion :tag "Failure to expand macros") (const empty-let :tag "Let-binding with empty varlist")))) #[257 "\211?\206\211<\205\211\300\301\"\232\207" [mapcar #[257 "\211\300>\205\211\207" [(undefined-functions unbound-reference unbound-assignment macro-expansion empty-let)] 3 "\n\n(fn E)"]] 5 "\n\n(fn VALUE)"] elint-directory-skip-re #[0 "\300\207" [#2="\\(ldefs-boot\\|loaddefs\\)\\.el\\'"] 1 #2#] "If non-nil, a regexp matching files to skip when linting a directory." (choice (const :tag "Lint all files" nil) (regexp :tag "Regexp to skip")) string-or-null-p] 12)
#@131 Standard variables, excluding `elint-builtin-variables'.
These are variables that we cannot detect automatically for some reason.
(defconst elint-standard-variables '(vc-mode local-write-file-hooks activate-menubar-hook buffer-name-history coding-system-history extended-command-history yes-or-no-p-history) (#$ . 2792))
#@180 List of built-in variables.  Set by `elint-initialize'.
This is actually all those documented in the DOC file, which includes
built-in variables and those from dumped Lisp files.
(defvar elint-builtin-variables nil (#$ . 3120))
#@62 List of `loaddefs.el' variables.  Set by `elint-initialize'.
(defvar elint-autoloaded-variables nil (#$ . 3354))
#@124 Environment defined by the preloaded (dumped) Lisp files.
Set by `elint-initialize', if `elint-scan-preloaded' is non-nil.
(defvar elint-preloaded-env nil (#$ . 3474))
#@60 Those built-ins for which we can't find arguments, if any.
(defconst elint-unknown-builtin-args '((encode-time time &rest obsolescent-arguments)) (#$ . 3648))
#@66 Errors without `error-message' or `error-conditions' properties.
(defvar elint-extra-errors '(file-locked file-supersession ftp-error) (#$ . 3813))
#@130 Regexp matching elements of `preloaded-file-list' to ignore.
We ignore them because they contain no definitions of use to Elint.
(defconst elint-preloaded-skip-re "\\(?:/char\\(?:acters\\|prop\\)\\|c\\(?:p51932\\|us-start\\)\\|eucjp-ms\\|l\\(?:anguage/\\|oad\\(?:\\(?:defs\\|up\\)\\.el\\)\\)\\|mule-conf\\)" (#$ . 3968))
#@105 Create a top form.
FORM is the form, and POS is the point where it starts in the buffer.

(fn FORM POS)
(defalias 'elint-make-top-form #[514 "B\207" [] 4 (#$ . 4296)])
(put 'elint-make-top-form 'byte-optimizer 'byte-compile-inline-expand)
#@50 Extract the form from a TOP-FORM.

(fn TOP-FORM)
(defalias 'elint-top-form-form #[257 "\211@\207" [] 2 (#$ . 4543)])
(put 'elint-top-form-form 'byte-optimizer 'byte-compile-inline-expand)
#@54 Extract the position from a TOP-FORM.

(fn TOP-FORM)
(defalias 'elint-top-form-pos #[257 "\211A\207" [] 2 (#$ . 4737)])
(put 'elint-top-form-pos 'byte-optimizer 'byte-compile-inline-expand)
#@30 Create an empty environment.
(defalias 'elint-make-env #[0 "\300C\300\211E\207" [nil] 3 (#$ . 4933)])
(put 'elint-make-env 'byte-optimizer 'byte-compile-inline-expand)
#@98 Augment ENV with NEWENV.
None of them is modified, and the new env is returned.

(fn ENV NEWENV)
(defalias 'elint-env-add-env #[514 "\300@@\"\300A@A@\"\300AA@AA@\"E\207" [append] 7 (#$ . 5107)])
(put 'elint-env-add-env 'byte-optimizer 'byte-compile-inline-expand)
#@106 Augment ENV with the variable VAR.
The new environment is returned, the old is unmodified.

(fn ENV VAR)
(defalias 'elint-env-add-var #[514 "\211C@BAB\207" [] 4 (#$ . 5384)])
(put 'elint-env-add-var 'byte-optimizer 'byte-compile-inline-expand)
#@110 Augment ENV with the variable VAR.
ENV is modified so VAR is seen everywhere.
ENV is returned.

(fn ENV VAR)
(defalias 'elint-env-add-global-var #[514 "@CC\244\210\207" [] 4 (#$ . 5637)])
(put 'elint-env-add-global-var 'byte-optimizer 'byte-compile-inline-expand)
#@116 Non-nil if ENV contains the variable VAR.
Actually, a list with VAR as a single element is returned.

(fn ENV VAR)
(defalias 'elint-env-find-var #[514 "\211@\236\207" [] 4 (#$ . 5911)])
(put 'elint-env-find-var 'byte-optimizer 'byte-compile-inline-expand)
#@143 Augment ENV with the function FUNC, which has the arguments ARGS.
The new environment is returned, the old is unmodified.

(fn ENV FUNC ARGS)
(defalias 'elint-env-add-func #[771 "@DA@BAA@E\207" [] 6 (#$ . 6175)])
(put 'elint-env-add-func 'byte-optimizer 'byte-compile-inline-expand)
#@104 Non-nil if ENV contains the function FUNC.
Actually, a list of (FUNC ARGS) is returned.

(fn ENV FUNC)
(defalias 'elint-env-find-func #[514 "\211A@\236\207" [] 4 (#$ . 6470)])
(put 'elint-env-find-func 'byte-optimizer 'byte-compile-inline-expand)
#@179 Augment ENV with the macro named MACRO.
DEF is the macro definition (a lambda expression or similar).
The new environment is returned, the old is unmodified.

(fn ENV MACRO DEF)
(defalias 'elint-env-add-macro #[771 "@A@BAA@BE\207" [] 7 (#$ . 6725)])
(put 'elint-env-add-macro 'byte-optimizer 'byte-compile-inline-expand)
#@97 Return the macro environment of ENV.
This environment can be passed to `macroexpand'.

(fn ENV)
(defalias 'elint-env-macro-env #[257 "\211AA@\207" [] 2 (#$ . 7057)])
(put 'elint-env-macro-env 'byte-optimizer 'byte-compile-inline-expand)
#@48 Non-nil if ENV contains MACRO.

(fn ENV MACRO)
(defalias 'elint-env-macrop #[514 "\211\211AA@\262\236\207" [] 5 (#$ . 7300)])
(put 'elint-env-macrop 'byte-optimizer 'byte-compile-inline-expand)
#@32 Lint the file FILE.

(fn FILE)
(defalias 'elint-file #[257 "\306!\262\204\f\307 \210\310!\211\311 \210)\312\313!\210r\nq\210	\230\2045\314\315\316	\"\313\"\210\314\315\317\"\313\"\210\211)\210\320\321\"\322\323\"\210\204N\314\320\324\325 #\313\"\210\326\327!r\211q\210\330\331\332\333\334!\335\"\336$\216\337!\210\340\f]\341 p\330\331\342\333\334\"\343\"\336$\216\344)!\210\345\346\347 \"\210)\266,\210\312 \210\322\350\"\207" [elint-builtin-variables default-directory elint-log-buffer noninteractive max-lisp-eval-depth buffer-file-name expand-file-name elint-initialize file-name-directory elint-display-log elint-set-mode-line t elint-log-message format-message "\f\nLeaving directory `%s'" "Entering directory `%s'" format "Linting file %s" message "%s..." "\f\n%s at %s" current-time-string generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents 1000 syntax-table "r\301q\210\302\300!)\207" [set-syntax-table] set-syntax-table mapc elint-top-form elint-update-env "%s...done" emacs-lisp-mode-syntax-table] 12 (#$ . 7502) "fElint file: "])
#@107 Lint all the .el files in DIRECTORY.
A complicated directory may require a lot of memory.

(fn DIRECTORY)
(defalias 'elint-directory #[257 "\302\303\302\"\211\2039\211@\304\305\"\2032\306!\2032\307!\2042\304	\"\203.\310\311\"\210\2022\312!\210A\266\202\202\210)\313 \207" [elint-running elint-directory-skip-re t directory-files string-match "\\.el\\'" file-readable-p auto-save-file-name-p message "Skipping file %s" elint-file elint-set-mode-line] 6 (#$ . 8668) "DElint directory: "])
#@77 Lint the current buffer.
If necessary, this first calls `elint-initialize'.
(defalias 'elint-current-buffer #[0 "\204\301 \210\302\303\304\305 \206\306 \"!\210\307 \210\310\311!\210\312\313\314 \"\210\310 \210\315\316\311\"\207" [elint-builtin-variables elint-initialize elint-clear-log format "Linting %s" buffer-file-name buffer-name elint-display-log elint-set-mode-line t mapc elint-top-form elint-update-env elint-log-message "\nLinting finished.\n"] 4 (#$ . 9178) nil])
#@80 Lint the function at point.
If necessary, this first calls `elint-initialize'.
(defalias 'elint-defun #[0 "\204\301 \210\212\302 \204\303\304!\210`\305p!\306 \210\307 \210\310B\266\202!\266\202)\207" [elint-builtin-variables elint-initialize beginning-of-defun error "Lint what?" read elint-display-log elint-update-env elint-top-form] 7 (#$ . 9665) nil])
#@70 The environment of an elisp buffer.
Will be local in linted buffers.
(defvar elint-buffer-env nil (#$ . 10036))
#@61 The top forms in a buffer.
Will be local in linted buffers.
(defvar elint-buffer-forms nil (#$ . 10154))
#@113 The last time the buffers env was updated.
Is measured in buffer-modified-ticks and is local in linted buffers.
(defvar elint-last-env-time nil (#$ . 10266))
#@77 List of all libraries this buffer has required, or that have been provided.
(defvar elint-features nil (#$ . 10430))
#@170 Update the elint environment in the current buffer.
Don't do anything if the buffer hasn't been changed since this
function was called the last time.
Returns the forms.
(defalias 'elint-update-env #[0 "\305\303p\"\203\305\301p\"\203\305\300p\"\203\306 U\203	\207\307\301!\210\310 \307\302!\210\311\307\303!\210\312	!\f\203T\f\313@@\"\313A@A@\"\313AA@AA@\"E\266\307\300!\210\306 	\207" [elint-last-env-time elint-buffer-forms elint-features elint-buffer-env elint-preloaded-env local-variable-p buffer-modified-tick make-local-variable elint-get-top-forms nil elint-init-env append] 7 (#$ . 10554)])
#@50 Collect all the top forms in the current buffer.
(defalias 'elint-get-top-forms #[0 "\212\301eb\210\302 \203C`h\303U\203\304\305\303\306p!#\210\202?\30713\306p!B\266\202B\211\2620\202>\210b\210\310\311\312 {\"\210)\202\211\237\262)\207" [elint-current-pos nil elint-find-next-top-form 39 elint-warning "Skipping quoted form `%c%.20s...'" read (end-of-file) error "Missing `)' in top form: %s" line-end-position] 6 (#$ . 11181)])
#@88 Find the next top form from point.
Return nil if there are no more forms, t otherwise.
(defalias 'elint-find-next-top-form #[0 "\300`d\301\302$\210m?\207" [parse-partial-sexp nil t] 5 (#$ . 11633)])
#@61 Process FORM, adding to ELINT-ENV if recognized.

(fn FORM)
(defalias 'elint-init-form #[257 "\211<\204
\303\304\"\210\202L\211@\305>\203&A@\211C@BAB\266\202\202L\211@\306>\203HA@\3078@DA@BAA@E\266\203\202L\211@\310=\203\213A@\311@DA@BAA@E\266\203\211A@\211C@BAB\266\202\211\312\313\314A@\"!\211C@BAB\266\202\202L\211@\315=\203\272A@\316@DA@BAA@E\266\203\211A@\211C@BAB\266\202\202L\211@\317=\203\357\211A@\203\357A@\320@DA@BAA@E\266\203\211A@\211C@BAB\266\202\202L\211@\321=\203A@A@\322@DA@BAA@E\266\203\202L\211@\323=\203TA@G\324W\2049\3258\326=\2049\3078;\204=\327\330A@\"\210\322\202@\3258@DA@BAA@E\266\203\202L\211@\331=\203\225\3078<\203\225\3078A@\211A@\236\266\202A@A@\203A@\202\200\322@DA@BAA@E\266\203\210\202L\211@\332=\203\321A@\333AAB@A@BAA@BE\266\203\211A@\3078@DA@BAA@E\266\203\202L\211@\334=\203\377\211G\324U\203\377\211A@\242\335=\203\377\3078\336\232\203\377\337\301!\210\211A@A@	B\202L\211@\340=\203\341A@!\211\n\235\203\n\210\202\211\nB\210\202L\211@\342>\203L\341A@!\341\3078!\n>\204J\n\235\203@\n\210\202D\nB\343#\266\207" [elint-env elint-extra-errors elint-features elint-warning "Skipping non-list form `%s'" (defvar defconst defcustom) (defun defsubst) 2 define-derived-mode nil intern format "%s-map" define-minor-mode (&optional arg) easy-menu-define (event) autoload unknown declare-function 4 3 t elint-error "Malformed declaration for `%s'" defalias defmacro lambda put quote 'error-conditions make-local-variable provide eval (require cc-require cc-require-when-compile) elint-add-required-env] 9 (#$ . 11838)])
#@52 Initialize the environment from FORMS.

(fn FORMS)
(defalias 'elint-init-env #[257 "\301C\301\211E\301\203/@\211@\262\262A\262\211\242\302>\203(\303\304A\"\210\202\304!\210\202)\207" [elint-env nil (eval-and-compile eval-when-compile progn prog1 prog2 with-no-warnings) mapc elint-init-form] 6 (#$ . 13558)])
#@85 Augment ENV with the variables defined by feature NAME in FILE.

(fn ENV NAME FILE)
(defalias 'elint-add-required-env #[771 "\3011Y\211;\203
\211\202\302!\303\304P\305\"\211\206\303\305\"\211\203Or\306!q\210\307 \210\310@@\"\310A@A@\"\310AA@AA@\"E\266\202\211\262)\202S\311\312\"\266\2030\202b\313\314\315!#\262\210\207" [elint-buffer-env (error) symbol-name locate-library ".el" t find-file-noselect elint-update-env append error "%s.el not found in load-path" message "Can't get variables from require'd library %s: %s" error-message-string] 13 (#$ . 13890)])
#@40 The currently linted top form, or nil.
(defvar elint-top-form nil (#$ . 14485))
#@84 The value t if the currently linted top form has been mentioned in the log buffer.
(defvar elint-top-form-logged nil (#$ . 14571))
#@29 Lint a top FORM.

(fn FORM)
(defalias 'elint-top-form #[257 "\211\304\211A\262\305\211@\262\"+\207" [elint-current-pos elint-top-form-logged elint-top-form elint-buffer-env nil elint-form] 5 (#$ . 14708)])
#@60 Functions to call when some special form should be linted.
(defconst elint-special-forms '((let . elint-check-let-form) (let* . elint-check-let-form) (setq . elint-check-setq-form) (quote . elint-check-quote-form) (function . elint-check-quote-form) (cond . elint-check-cond-form) (lambda . elint-check-defun-form) (function . elint-check-function-form) (setq-default . elint-check-setq-form) (defalias . elint-check-defalias-form) (defun . elint-check-defun-form) (defsubst . elint-check-defun-form) (defmacro . elint-check-defun-form) (defvar . elint-check-defvar-form) (defconst . elint-check-defvar-form) (defcustom . elint-check-defcustom-form) (macro . elint-check-macro-form) (condition-case . elint-check-condition-case-form) (condition-case-unless-debug . elint-check-condition-case-form) (if . elint-check-conditional-form) (when . elint-check-conditional-form) (unless . elint-check-conditional-form) (and . elint-check-conditional-form) (or . elint-check-conditional-form)) (#$ . 14928))
#@187 Lint FORM in the environment ENV.
Optional argument NOHANDLER non-nil means ignore `elint-special-forms'.
Returns the environment created by the form.

(fn FORM ENV &optional NOHANDLER)
(defalias 'elint-form #[770 ":\203\277@\236A\211\203\204\211\"\202\276@\302\"\303\304\267\202:\305\262\306	>\204A\307\310\"\210\202A\202A\311\"\262\211\211AA@\262\236\266\202\203\201\211\203}\3121m\313\314\211AA@\262\"\"0\202\274\210\315	>\204y\307\316\"\210\202\274\202\2749\203\222\317!\205\223\320!\202\223\211<\203\263\211@\321=\203\263\203\256\313\314	!\"\202\272\202\272\322A\"\262\266\203\2079\203\342\323!\324H\325U\204\340\326	>\204\340\327\"\203\340\330\331\"\210\207\207" [elint-special-forms elint-ignored-warnings elint-get-args t #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (undefined 38 unknown 55)) nil undefined-functions elint-error "Call to undefined function: %s" elint-match-args (error) elint-form macroexpand macro-expansion "Elint failed to expand macro: %s" fboundp indirect-function macro elint-forms symbol-name 0 58 unbound-reference elint-unbound-variable elint-warning "Reference to unbound symbol: %s"] 12 (#$ . 15935)])
#@81 Lint the FORMS, accumulating an environment, starting with ENV.

(fn FORMS ENV)
(defalias 'elint-forms #[514 "<\203\211\203\211@\300\"\262A\266\202\202\207\301\302\"\210\207" [elint-form elint-error "Elint failed to parse form: %s"] 7 (#$ . 17201)])
#@37 Name of a temporarily bound symbol.
(defvar elint-bound-variable nil (#$ . 17471))
#@50 Return t if VAR is unbound in ENV.

(fn VAR ENV)
(defalias 'elint-unbound-variable #[514 "\304>\206&=\206&\211\211@\236\266\202\206&	>\206&\n>\206&>?\207" [elint-bound-variable elint-builtin-variables elint-autoloaded-variables elint-standard-variables (nil t)] 6 (#$ . 17560)])
#@60 Match ARGLIST against ARGPATTERN.

(fn ARGLIST ARGPATTERN)
(defalias 'elint-match-args #[514 "\300A\301\204
\203d@\302=\203\303\262A\262\202@\304=\204d\300=\2033\203A\203A\303=\203O\203O\204O\305\306#\210\307\262\202d\303=\203Y\203dA\262A\262\202\207" [all t &optional optional &rest elint-error "Wrong number of args: %s, %s" nil] 10 (#$ . 17859)])
#@46 Name of a temporarily bound function symbol.
(defvar elint-bound-function nil (#$ . 18259))
#@95 Find the args of FUNC in ENV.
Returns `unknown' if we couldn't find arguments.

(fn FUNC ENV)
(defalias 'elint-get-args #[514 "\211\211A@\236\266\202\211\203\211A@\202J9\203G=\203\"\301\202J\302!\203C\303!\304!\203;\305N\206>\301\202>\306!\262\202J\307\202J\306!\207" [elint-bound-function unknown fboundp indirect-function subrp elint-args elint-find-args-in-code undefined] 6 (#$ . 18357)])
#@110 Extract the arguments from CODE.
CODE can be a lambda expression, a macro, or byte-compiled code.

(fn CODE)
(defalias 'elint-find-args-in-code #[257 "\300!\211<\203\f\211\202
\301\207" [help-function-arglist unknown] 3 (#$ . 18781)])
#@41 Lint a cond FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-cond-form #[514 "A\211\203|\211@\211:\203p\211@\211\302\232\204l\211\303\232\204l\211\242\304=\203A\211G\305U\203A\211A@\242\306=\203A\211A@A@\307\"\210)\202l\211\242\310=\203g\211G\305U\203g\211A@\242\306=\203g\211A@A@\307\"\210)\202l\307\"\210\210\202u\311\312\"\210A\266\202\202\210\207" [elint-bound-function elint-bound-variable (featurep 'xemacs) (not (featurep 'emacs)) fboundp 2 quote elint-forms boundp elint-error "cond clause should be a list: %s"] 8 (#$ . 19025)])
#@58 Lint a defun/defmacro/lambda FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-defun-form #[514 "\211C@\300=\203A\202AA\262\301\302\303\304\305\306!\307\"\310\311%@\"\210\312A\242\"\207" [lambda mapc make-byte-code 257 "\211\301>\206\300\211\242\211C@BAB\266\202\240\207" vconcat vector [(&optional &rest)] 6 "\n\n(fn P)" elint-forms] 10 (#$ . 19597)])
#@45 Lint a defalias FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-defalias-form #[514 "A@\3008\242\301=\203)\211\242\301=\203)\302A@\"\303=\203)\304\305A@A@#\210\266\306\307#\207" [2 quote elint-get-args undefined elint-warning "Alias `%s' has unknown target `%s'" elint-form t] 8 (#$ . 19975)])
#@47 Lint the let/let* FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-let-form #[514 "A@\211\204+G\301V\203\"\302>\204\303\304\"\210\305AA\"\202m\306\307\"\210\202m\211G\301U\203M\211@9\203M\211A@<\203M\310A@@!\203M\303\311\"\210C\312\313\314\315\316\317		#\320\"\321\322%\"\210\305AA\242\"\262\207" [elint-ignored-warnings 2 empty-let elint-warning "Empty varlist in let: %s" elint-forms elint-error "Malformed let: %s" fboundp "Suspect varlist: %s" mapc make-byte-code 257 "\2119\203\302\211\242\211C@BAB\266\202\240\207\211:\203E\211G\303X\203E\304A@\300@\305=\2030\301\2022\302\242\"\210\302\211\242@\211C@BAB\266\202\240\207\306\307\"\207" vconcat vector [2 elint-form let elint-error "Malformed `let' declaration: %s"] 6 "\n\n(fn S)"] 13 (#$ . 20291)])
#@43 Lint the setq FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-setq-form #[514 "\301G\302\"\303U\204\304\305\"\210\211\306\211A\262\203b@\262A@\262AA\2629\203B\307>\204G\310\"\203G\304\311\"\210\202G\312\313\"\210\314\"\2109\203\211C@BAB\266\202\262\202\207" [elint-ignored-warnings mod 2 1 elint-warning "Missing value in setq: %s" nil unbound-assignment elint-unbound-variable "Setting previously unbound symbol: %s" elint-error "Setting non-symbol in setq: %s" elint-form] 9 (#$ . 21098)])
#@54 Lint the defvar/defconst FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-defvar-form #[514 "G\300U\204G\301U\204G\302U\203/\303\3018!\203/\304\3008\"A@@CC\244\210\207\305\306\"\210\207" [2 3 4 string-or-null-p elint-form elint-error "Malformed variable declaration: %s"] 6 (#$ . 21636)])
#@48 Lint the defcustom FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-defcustom-form #[514 "G\300V\203#\301G\302\"\303U\203#\304\3058\"A@@CC\244\210\207\306\307\"\210\207" [3 logand 1 0 elint-form 2 elint-error "Malformed variable declaration: %s"] 6 (#$ . 21950)])
#@47 Lint the function FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-function-form #[514 "\243@\2119\203#\211A@\236\266\202\204\300!\204\301\302\"\210\202E\211:\2036\211@\303>\2036\304\"\202E\211;\203?\202E\305\306\"\210\207" [fboundp elint-warning "Reference to undefined function: %s" (lambda macro) elint-form elint-error "Not a function object: %s"] 7 (#$ . 22233)])
#@44 Lint the quote FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-quote-form #[514 "\207" [] 3 (#$ . 22633)])
#@45 Check the macro FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-macro-form #[514 "\300@AD\"\207" [elint-check-function-form] 5 (#$ . 22749)])
#@56 Check the `condition-case' FORM in ENV.

(fn FORM ENV)
(defalias 'elint-check-condition-case-form #[514 "\211G\300W\203\301\302\"\210\202mA@9\204\303\304\"\210\305\3068\"\262A@\211C@BAB\266\202\307\300\233\211\203k\211@\211@\262\310\3119\203LC\202\\<\203U\202\\\301\312\"\210\307\"\210\313A\"\210A\266\202\2026\266\211\207" [3 elint-error "Malformed condition-case: %s" elint-warning "First parameter should be a symbol: %s" elint-form 2 nil mapc #[257 "\211\301N\206\211\302N\206\211>\206\303\304\"\207" [elint-extra-errors error-conditions error-message elint-warning "Not an error symbol in error handler: %s"] 4 "\n\n(fn S)"] "Bad error list in error handler: %s" elint-forms] 12 (#$ . 22903)])
#@99 Check the when/unless/and/or FORM in ENV.
Does basic handling of `featurep' tests.

(fn FORM ENV)
(defalias 'elint-check-conditional-form #[514 "@A@\302>\2032\211\242\303=\2032\211G\304U\2032\211A@\242\305=\2032\211A@A@\306\307#\210)\202i\310>\203_\211\242\311=\203_\211G\304U\203_\211A@\242\305=\203_\211A@A@\306\307#\210)\202i\312=\203\244\211\242\303=\203\244\211G\304U\203\244\211A@\242\305=\203\244\211A@A@\306\3048\"\210)\313\233\211\203\240\211@\306\"\210A\266\202\202\215\210\202i\312=\203\351\211\242\311=\203\351\211G\304U\203\351\211A@\242\305=\203\351\211A@A@\306\3048\"\210)\313\233\211\203\345\211@\306\"\210A\266\202\202\322\210\202i\314>\203\211\203i\211\315\235\204i\211\242\316=\203\211A\242\317\232\204i\320>\203\211\321\232\204i\312=\203M\211\2033\211\322\235\2043\211\242\316=\203M\211A\242\323\232\203M\313\233\211\203I\211@\306\"\210A\266\202\2026\210\202i\312=\203c\211\324\232\203c\306\3048\"\210\202i\306\307#\210\266\207" [elint-bound-variable elint-bound-function (when and) boundp 2 quote elint-form t (when and) fboundp if 3 (when and) ((featurep 'xemacs) (not (featurep 'emacs))) and (featurep 'xemacs) (unless or) (featurep 'emacs) ((featurep 'xemacs) (not (featurep 'emacs))) (featurep 'xemacs) (featurep 'emacs)] 9 (#$ . 23650)])
#@25 

(fn TYPE STRING ARGS)
(defalias 'elint-log #[771 "\301\302\303\304 \211\203\305!\202\306 \262\307\300!\203'\212b\210\310e\311 \"T)\202(\312\313\314		#%!\207" [elint-current-pos elint-log-message format "%s:%d:%s: %s" buffer-file-name file-name-nondirectory buffer-name boundp count-lines line-beginning-position 0 apply format-message] 13 (#$ . 25007)])
#@108 Report a linting error.
STRING and ARGS are thrown on `format' to get the message.

(fn STRING &rest ARGS)
(defalias 'elint-error #[385 "\300\301#\207" [elint-log "Error"] 6 (#$ . 25383)])
#@70 Report a linting warning.
See `elint-error'.

(fn STRING &rest ARGS)
(defalias 'elint-warning #[385 "\300\301#\207" [elint-log "Warning"] 6 (#$ . 25580)])
#@78 Print or insert STRING, depending on value of `noninteractive'.

(fn STRING)
(defalias 'elint-output #[257 "\203	\301\302\"\207\211\303\261\207" [noninteractive message "%s" "\n"] 4 (#$ . 25743)])
#@151 Insert ERRSTR last in the lint log buffer.
Optional argument TOP non-nil means pretend `elint-top-form-logged' is non-nil.

(fn ERRSTR &optional TOP)
(defalias 'elint-log-message #[513 "r\303 q\210db\210\304n\204\305 \210	\204H\211\204H\n\211@\262\211@\306\307\267\202B\310\311A@\"\202C\310\312A@\"\202C\310\313A@\"\202C\314!\266\304\306!*\207" [inhibit-read-only elint-top-form-logged elint-top-form elint-get-log-buffer t newline elint-output #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (defun 39 defsubst 39 defmacro 48 defvar 57 defconst 57)) format "\nIn function %s:" "\nIn macro %s:" "\nIn variable %s:" "\nIn top level expression:"] 8 (#$ . 25951)])
#@102 Clear the lint log buffer.
Insert HEADER followed by a blank line if non-nil.

(fn &optional HEADER)
(defalias 'elint-clear-log #[256 "r\302 q\210\211\303\304 \210\205\305\261*\207" [default-directory inhibit-read-only elint-get-log-buffer t erase-buffer "\n"] 4 (#$ . 26674)])
#@30 Display the lint log buffer.
(defalias 'elint-display-log #[0 "\301\302\303 !\210\304\305!)\207" [pop-up-windows t display-buffer elint-get-log-buffer sit-for 0] 2 (#$ . 26966)])
#@71 Set the mode-line-process of the Elint log buffer.

(fn &optional ON)
(defalias 'elint-set-mode-line #[256 "r\303 q\210\304=\205)\211\204\305\301!\203!	\203!\306\307\310\311#\202&\306\312\310\313#C\211)\207" [major-mode elint-running mode-line-process elint-get-log-buffer compilation-mode boundp propertize ":run" face compilation-warning ":finished" compilation-info] 5 (#$ . 27152)])
#@32 Return a log buffer for elint.
(defalias 'elint-get-log-buffer #[0 "\303!\206r\304!q\210	\305=\204\305 \210\306p)\207" [elint-log-buffer major-mode buffer-undo-list get-buffer get-buffer-create compilation-mode t] 2 (#$ . 27553)])
#@66 Mark function FUNC as having argument list ARGS.

(fn FUNC ARGS)
(defalias 'elint-put-function-args #[514 "9\205\211\205\211\300=?\205\301\302#\207" [unknown put elint-args] 6 (#$ . 27797)])
#@145 Initialize elint.
If elint is already initialized, this does nothing, unless
optional prefix argument REINIT is non-nil.

(fn &optional REINIT)
(defalias 'elint-initialize #[256 "\203\f\211\204\f\306\307!\207\306\310!\210\311 \312 \313\314\315 \"\210\n\203%\313\316\n\"\210\203G\f\211\203F\211@\317
\"\204?\320\321#A\266\202\202*\210\306\322!\207" [elint-builtin-variables elint-autoloaded-variables elint-unknown-builtin-args elint-scan-preloaded preloaded-file-list elint-preloaded-skip-re message "Elint is already initialized" "Initializing elint..." elint-scan-doc-file elint-find-autoloaded-variables mapc #[257 "\300@A\"\207" [elint-put-function-args] 4 "\n\n(fn X)"] elint-find-builtin-args #[257 "\300@A\"\207" [elint-put-function-args] 4 "\n\n(fn X)"] string-match elint-add-required-env nil "Initializing elint...done" elint-preloaded-env] 7 (#$ . 28004) "P"])
#@121 Scan the DOC file for function and variables.
Marks the function with their arguments, and returns a list of variables.
(defalias 'elint-scan-doc-file #[0 "\302\303\211\211\212\304!\203q\210eb\210\202 \305!q\210\306\307	\"!\210\310\311\303\312#\203\203\313`\314 {!\211\262\203 \315\316!\317\230\203J\320!\203 B\262\202 \321!\203 \310\322\303\312#\203 \323u\210\315\316!\211\262\203 \3241s\325\326\327\330#!0\202u\210\303\211\262\203 \331\"\210\202 )\207" [internal-doc-file-name doc-directory " *DOC*" nil get-buffer get-buffer-create insert-file-contents-literally expand-file-name re-search-forward "\\([VF]\\)" t intern-soft line-end-position match-string 1 "V" boundp fboundp "\\(^(fn.*)\\)?" -1 (error) read replace-regexp-in-string "^(fn ?" "(" elint-put-function-args] 9 (#$ . 28905)])
#@44 Return a list of all autoloaded variables.
(defalias 'elint-find-autoloaded-variables #[0 "\300\211\301\302!r\211q\210\303\304\305\306\307!\310\"\311$\216\312\313\314!!\210\315\316\300\317#\203<\320\321\322!!\211\262\203\323!\203B\262\202*\210\207" [nil generate-new-buffer " *temp*" make-byte-code 0 "\301\300!\205	\302\300!\207" vconcat vector [buffer-name kill-buffer] 2 insert-file-contents locate-library "loaddefs.el" re-search-forward "^(defvar \\([[:alnum:]_-]+\\)" t intern-soft match-string 1 boundp] 9 (#$ . 29737)])
#@42 Return a list of all built-in functions.
(defalias 'elint-find-builtins #[0 "\300C\301\302\303\304\305\306!\307\"\310\311%!\210\211\242\207" [nil mapatoms make-byte-code 257 "\301K!\205
\300\300\242B\240\207" vconcat vector [subrp] 4 "\n\n(fn S)"] 8 (#$ . 30285)])
#@317 Return a list of the built-in functions and their arguments.
If LIST is nil, call `elint-find-builtins' to get a list of all built-in
functions, otherwise use LIST.

Each function is represented by a cons cell:
(function-symbol . args)
If no documentation could be found args will be `unknown'.

(fn &optional LIST)
(defalias 'elint-find-builtin-args #[256 "\300\301\206\302 \"\207" [mapcar #[257 "\300\301\"\211\203-\302\303\"\203-\3041(\305\306\307\310\311\312\313\314	\"#\301$!0\202*\210\315\2060\316B\207" [documentation t string-match "\n\n(fn\\(.*)\\)\\'" (error) read replace-regexp-in-string "\\([^ ]+\\)\\.\\.\\.)\\'" "&rest \\1)" format "(%s %s" match-string 1 nil unknown] 12 "\n\n(fn F)"] elint-find-builtins] 4 (#$ . 30562)])
(provide 'elint)

Zerion Mini Shell 1.0