flymake / emacs-flymake Goto Github PK

View Code? Open in Web Editor NEW

182.0 18.0 36.0 136 KB

Continuous syntax checking for Emacs. Fork to add max parallel invocations and other bug fixes.

Home Page: http://www.illusori.co.uk/projects/emacs-flymake/

License: GNU General Public License v3.0

Emacs Lisp 99.50% Makefile 0.50%

flymake emacs-flymake emacs-lisp emacs

emacs-flymake's Introduction

emacs-flymake

This project is a fork of Pavel Kobyakov's excellent flymake.el to let me play around with some updates before contributing them upstream. The fork was started in 2011 from the v0 version, and it has evolved in a different direction compared to the flymake version included in Emacs (v1, as of 2023). These two versions are incompatible and, as of 2023, the Emacs version is maintained more regularly.

Features added so far, since version 0.3:

Support for queuing up syntax checks once a certain number are in-progress.
Support for placing temporary files in the system temporary directory.
Spawns only one buffer-modification timer check rather than one per buffer.
Show multiple errors in tooltips.
Improved support for remote files over Tramp.
Improved error message classification. (err/warn/info, customizable regexp)
Support for new languages: Javascript and CSS.
Minor other bug fixes.

For a full list of changes, please refer to the Changes file.

Queued syntax checks

If you use desktop.el with hundreds of buffers open you've probably had problems when you restart emacs with flymake running: it'll try to run a syntax check on everything at once.

Now there's a limit of 4 syntax checks running at once, any more that are attempted go on a queue that will empty as one of the 4 slots frees up.

You can customize the number of parallel checks that run, or turn off the limit entirely with the 'flymake-max-parallel-syntax-checks' variable.

;; Let's run 8 checks at once instead.
(setq flymake-max-parallel-syntax-checks 8)

;; I don't want no steekin' limits.
(setq flymake-max-parallel-syntax-checks nil)

Use the system temporary directory for temp files

By default Flymake creates a temporary copy of the file being inspected in the same directory as the original file. This is helpful if you're using relative pathnames for includes, but not so helpful if you have something in your environment that's triggered by file changes in your project directory (continuous integration, webserver restarts, etc).

Now you can toggle between the two behaviours with the 'flymake-run-in-place' variable.

;; Yes, I want my copies in the same dir as the original.
(setq flymake-run-in-place t)

;; Nope, I want my copies in the system temp dir.
(setq flymake-run-in-place nil)
;; This lets me say where my temp dir is.
(setq temporary-file-directory "~/.emacs.d/tmp/")

One buffer modification timer check

Again, if you have multiple hundreds of buffers open, original Flymake would start thrashing your CPU trying to keep up with 1-second timer looking for modifications for every buffer, my laptop would have emacs sat at 60-90% CPU doing nothing but try to check for whether buffers had been modified.

Now only a single timer is spawned, it still runs once per second but only looks for changes in the current buffer.

This is much more CPU-friendly but also means that if you quickly switch away from a buffer after making changes, the syntax check may not be run until you return to the buffer. (The last-modified value is still retained per-buffer so the changes will still be detected once you return for long enough for the 1-second timer to happen.)

Show multiple errors in tooltips

The tooltips containing errors can now also be configured to include more than one error with the 'flymake-number-of-errors-to-display' variable:

;; I want to see at most the first 4 errors for a line.
(setq flymake-number-of-errors-to-display 4)

;; I want to see all errors for the line.
(setq flymake-number-of-errors-to-display nil)

Improved support for remote files over Tramp

Flymake has a few odd errors when operating on Tramp files, this version fixes bypasses most of the errors if you're running with flymake-run-in-place set to nil. This ensures that the syntax check is run in temporary-file-directory, which is probably the local machine rather than the remote.

If flymake-run-in-place is set to t things are a little more complicated: the syntax check will be run in the same directory as the original file, this (usually) means that it will run in a shell on the remote machine.

Flymake attempts to cope with this gracefully, but there's a couple of odd behaviours in Tramp which make this difficult:

Tramp places the contents of the remote shell login message at the end of the buffer being syntax-checked. This version of Flymake takes steps to prevent this from modifying the buffer in any way.
If the syntax-check command to run is not found on the remote machine, the command process just hangs and never completes. At the moment Flymake has no special handling of this situation and it will mean that the syntax check never appears to finish.

Improved error message classification

Error messages from the syntax checker can now be classed as info messages in addition or error and warning, and there's a new face to highlight info messages in: flymake-infoline.

In addition, the separation of errors into err/warn/info is now handled by the customizable regexps: flymake-warn-line-regexp and flymake-info-line-regexp. The default fall-through if neither regexp matches is still to classify the message as an error.

Support for new languages

Javascript support has been added by running JSHint if it's available.

There's a number of other good ways of hooking up Javascript support out there, this is by no means the most complete and awesome implementation, but it's pretty simple to get running if you have node.js and npm installed:
```
npm -g install jshint
```
CSS support has been added by running CSSLint if it's available:
```
npm -g install csslint
```
RPM Specfile support has been added by running rpmlint if it's available.
gettext() .po file support has been provided by msgfmt if it's available.

Other bug fixes

Logging no longer errors.
Log files are now proper logs rather than last-message-only.
Log files now have timestamps to help debugging where time is going.
You can customize where the log is created with flymake-log-file-name.
Provides hooks so that flymake-cursor doesn't need to wrap our functions.
Compile is now clean without warnings.
Support for invoking correct perl under perlbrew multiple-installs.
No longer prompt about running flymake processes when killing buffers.

Known Issues

Perl syntax checking uses "perl -c", which executes BEGIN blocks, this can be considered a security vulnerability when opening untrusted files. For more information: http://stackoverflow.com/a/12908487/870000

emacs-flymake's People

Contributors

Stargazers

Watchers

emacs-flymake's Issues

please ignore compiled lisp file

Please add *.elc to .gitignore
Without that line, a clone with a compiled file (flymake.elc) looks dirty.

Setting project include dirs is painful

Documentation is sparse. It implies, from what is written there, that I could do something like this:

(defun my-project-dirs (basedir)
  (mapcar #'(lambda (r) (expand-file-name (concat (expand-file-name basedir) "/" r)))
          '("." "..")))
(setq flymake-proc-get-project-include-dirs-function #'my-project-dirs)

Doing that in *scratch* buffer does not change the fact, that my

#include <args.hpp> // resides in BASEDIR/..

Is still not recognized.

Then there are the ways, not mentioned in above documentation (some project local .el file with an eval statement) and whatever else google yields on the subject.

I am aware, I could write #include "../args.hpp" instead, but in my reality, project file locations have nothing to do in c++ source files. It is a configuration matter, not code.

Then there is the cryptic

The default implementation, flymake-proc-get-project-include-dirs-imp, uses a make call.

which says nothing about any requirements for the makefile.
Looking at source code of flymake, it seems to look for something like INCLUDE_DIRS. So, in my Makefile, I wrote:

INCLUDE_DIRS = . ..

But that still does not yield the correct result.
And even if it worked, it is but a half-baked solution, because the Makefile could build multiple targets with different include directories for each of them.

Since using language servers (lsp-mode) is quite common today, maybe there is a convenient solution for flymake to make use of that infrastructure to find out, which project include directories are required.

Problem with javac signalling errors in files other than currently scanned

Flymake gives "Configuration error" and switches off if errors are only found in other files than a given one. I.e., it fails when I check my java project with javac, and current file has no errors at all, but one of the dependencies is flawed.

The following hack fixes the problem:

(defadvice flymake-post-syntax-check (before flymake-force-check-was-interrupted)
    (setq flymake-check-was-interrupted t))
(ad-activate 'flymake-post-syntax-check)

I have debugged the "flymake-post-syntax-check" function and found out that it does not normally work with the case. It's either the checking process has a zero exit code or no errors in the current file, or a non-zero exit code and errors in the file. I do not fully understand the meaning of the third case - the one that the hack uses.

Anyway, in my case - non-zero exit code and no errors in the file checked - flymake fails.

PS I am okay with giving more code-related details.

"flymake-same-files" produces wrong results when "flymake-run-in-place" is nil

I struggled with the problem for some time and figured out that when the following is used

(setq flymake-run-in-place nil)

the file, which is compared against the source file has temp suffix in the end, which
causes "flymake-same-files" to return false when comparing e.g. these 2 files

"~/projects/some-path/models_flymake26065vXh.py"
"/home/user/projects/some-path/models.py"

This leads to wrong check results (no errors found, when they are present).

Please add upstream patch to cope with non-writable directories

Emacs trunk has recently patched flymake (see Emacs bug #8954) to avoid trying to write temporary files in non-writable directories. Please add the patch from that bug.

Maybe in general it's a good time to start merging your changes upstream, so you (and we users!) can avoid this sort of to-and-fro in order to get all our favourite bugs fixed?

flymake & selective-display

When using flymake in conjunction with modes that use selective-display (such as folding-mode, the highlighting and error navigation ( flymake-goto-*-error) do not find the correct lines.

this is because forward-line jumps right over the hidden lines.

I redefined flymake-highlight-line and flymake-goto-line to use goto-line rather than forward-line, and I'm getting the behavior that I want -- that is flymake is highlighting the actual errors.

I'm not sure if this is an issue worth pursuing -- even the goto-line documentation says you "probably want" to use forward-line, as you are doing. I just thought I'd bring it up since it does not work correctly in this instance!

"Configuration error..." when using on files opened from symbolic link directories

Consider the following scenario:

~/projects/name/test.pl
~/shortcut -> ~/projects/name

If I open test.pl from projects/name, flymake works. However if I open it through the symbolic link "shortcut" then I get a "configuration error has occured... flymake will be switched off". Analyzing the log file, the problem is the temporary copy test_flymake.pl was not found! It was created correctly however:

[2013-08-17 11:33:07.549462] starting process on dir /home/peter/shortcut/
[2013-08-17 11:33:07.558302] started process 20470, command=(perl -wc ../projects/name/test_flymake.pl)
[2013-08-17 11:33:07.584354] received 85 byte(s) of output from process 20470
[2013-08-17 11:33:07.592350] received process output: 
  > Can't open perl script "../projects/name/test_flymake.pl": No such file or directory
  >

At first look it seems the path is correct, but there is a problem. On Debian linux in bash, if I'm in a symbolic link that's pointing to a directory, cd .. takes me out of the "symbolic directory" (to where the symbolic link is), but executing a file with .. does not behave the same: it refers to the directory one level above the linked directory, NOT the symbolic link itself!

peter@atom:~$ ls -l
total 12
-rw-r--r-- 1 peter peter 4758 Aug 17 11:35 flymake.log
drwxr-xr-x 3 peter peter 4096 Aug 17 11:25 projects
lrwxrwxrwx 1 peter peter   25 Aug 17 11:27 shortcut -> /home/peter/projects/name

peter@atom:~/shortcut$ cd ..
peter@atom:~$ 
peter@atom:~$ cd shortcut
peter@atom:~/shortcut$ ls ..
name

I would have too, expected ls .. to list the home directory, but it lists ~/projects instead, that's why the file is not found!

trouble with flymake over tramp

Hey, not sure if this is a flymake issue or a tramp issue. Maybe you can help or point me in the right direction.

When editing a file over tramp, that is connecting to a remote maching over ssh, and flymake enabled, when I open a file text like this gets appended to the buffer (no change is made to the file, unless I save):

Last login: Wed Oct 19 00:08:50 2011 from c-69-181-217-43.hsd1.ca.comcast.net
Agent pid 7356
[dave@starbuck ~]$

Obviously the text is coming from tramp establishing a connection with the host. But how is flymake adding that text to the file?

I'm trying your copy of flymake, hoping that a (setq flymake-run-in-place nil) would put a stop to this problem. But that setting has no effect, the problem happens either way.

Again if you have any idea how to fix this, please let me know. I'd like to use flymake when editing remotely over tramp.

FEATURE - enable shortcut for error tooltips

Since the function flymake-popup-current-error-menu is gone, it is clear how to display the error simply by pressing a key. One has to move the mouse over the erroneous line instead - which is awkward IMHO.

Example usage?

In the original flymake, this was how I configured it to run on Python files:

(when (load "flymake" t)
  (defun flymake-pychecker-init ()
    (let* ((temp-file (flymake-init-create-temp-buffer-copy
                       'flymake-create-temp-inplace))
           (local-file (file-relative-name
                        temp-file
                        (file-name-directory buffer-file-name))))
      (list "~/.emacs.d/vendor/pychecker.sh" (list local-file))))
  (add-to-list 'flymake-allowed-file-name-masks
               '("\\.py\\'" flymake-pychecker-init)))

Your fork introduced a feature to put the temp files in the system temp directory:

(setq flymake-run-in-place nil)

My code above still works with your fork, but it looks strange with the reference to flymake-create-temp-inplace. How should this configuration be rewritten for your fork?

Cannot be used with perl scripts with taint mode

If a perl script has taint mode enabled on its first line:

!/usr/bin/perl -T

then flymake will show an error on this line:

"-T" is on the #! line, it must also be used on the command line

This is because if a perl script has -T then it cannot be executed without -T. But the flymake-perl-init function only uses options c, w, I, and does not use -T .

gcc-4.9/gfortran-4.9 warning regexps not capturing text

In general, I don't quite understand how to modify the regexps used to tell what is an error and what is a warning. (Perhaps part of the issue is all the regexps coming from compile.el?) That having been said, using Intel's ifort works (well everything gets marked as an error but that's better than gfortran+flymake). With gfortran, the warnings are in the following format:

statN_factory_flymake.F90:13.44:

  function new_statN(this,order) result(res)
                                            1
Warning: Return value 'res' of function 'new_statn' declared at (1) not set

Flymake can see that there is a problem on line 13, but the warning text gets thrown away, and no useful message appears when running flymake-display-err-menu-for-current-line

Dependency resolution and flymake implementation with Fortran is a real pain, and I've finally got a Makefile based system working that does it well and automatically, but the final hurdle is to get flymake to correctly categorize errors, warnings, and remarks/info, and with gcc, to retain the messages associated with them.

Any help or advice would be much appreciated.

func flymake-post-syntax-check, please check "flymake-check-start-time"

Function flymake-post-syntax-check defined like follows:

(defun flymake-post-syntax-check (exit-status command)
(setq flymake-err-info flymake-new-err-info)
(setq flymake-new-err-info nil)
(setq flymake-err-info
    (flymake-fix-line-numbers
     flymake-err-info 1 (flymake-count-lines)))
(flymake-delete-own-overlays)
(flymake-highlight-err-lines flymake-err-info)
(let (err-count warn-count info-count)
(setq err-count (flymake-get-err-count flymake-err-info "e"))
(setq warn-count  (flymake-get-err-count flymake-err-info "w"))
(setq info-count  (flymake-get-err-count flymake-err-info "i"))
(flymake-log 2 "%s: %d error(s), %d warning(s), %d info in %.2f second(s)"
             (buffer-name) err-count warn-count info-count
             (- (flymake-float-time) flymake-check-start-time))
(setq flymake-check-start-time nil)

(if (and (equal 0 err-count) (equal 0 warn-count) (equal 0 info-count))
    (if (equal 0 exit-status)
        (flymake-report-status "" "")        ; PASSED
      (if (not flymake-check-was-interrupted)
          (flymake-report-fatal-status "CFGERR"
                                       (format "Configuration error has occurred while running %s" command))
        (flymake-report-status nil ""))) ; "STOPPED"
  (flymake-report-status (format "%d/%d/%d" err-count warn-count info-count) "")))
(run-hooks 'flymake-after-syntax-check-hook))

At snippet: (flymake-log 2 "%s: %d error(s), %d warning(s), %d info in %.2f second(s)" (buffer-name) err-count warn-count info-count (- (flymake-float-time) flymake-check-start-time))
How about check variable flymake-check-start-time to see whether it is nil because otherwise expression (- (flymake-float-time) flymake-check-start-time)) will fail with an error.

This behavior costed a emacs dummy (like me) one afternoon to locate it. It would be better to check flymake-check-start-time whether it equals to nil, don't you agree?

Add status update

Last update is from 5 years ago. Could you add some note about how this version compares to the official flymake?

unescaped whitespace based error while using flymake on a c++ header file

When i turn on flymake on a header file in my cpp project I can observe flymake correctly determining a master file for it, but the make call failes. That is caused by a whitespace in my work path.

the command flymake tries to evaluate:
command=(make -s -C PATH_CONTAINING_WHITESPACE CHK_SOURCES=FILE_PATH_CONTAINING_WHITESPACE SYNTAX_CHECK_MODE=1 check-syntax)

This should be fixable by using >"< to encapsulate the path or escaping whitespaces in the command as far as I see, but sadly I was unable to determine where to put that change with my little lisp knowledge.

Turn on flymake-find-file-hook by default?

I find the following line in flymake.el:

  ;;+(add-hook 'find-file-hook 'flymake-find-file-hook)

I see no problem with uncommenting it (it seems to be the simplest way to get flymake working everywhere currently available). I currently simply copied it into my Emacs configuration.

The most obvious alternative is something like:

http://www.emacswiki.org/emacs/init-flymake.el

I filed a similar bug upstream (so far no reply): http://debbugs.gnu.org/cgi/bugreport.cgi?bug=13779

Flymake temp files break build

Duplicate modules are an error in Haskell. Flymake creates a *_flymake.hs file that is an exact copy. Creation of this file in the same directory results in a compilation error.

Please provide a configuration option to write *_flymake files somewhere else so builds are not broken.

Timer handling is incorrect

In this fork, flymake-timer has been changed from a buffer-local variable to a global, but on buffer close, we still kill the timer. So closing one flycheck buffer prevents automatic flycheck in all buffers until flymake-mode is enabled somewhere else.

Standard flymake doesn't restart checking when changes are made

I'm not sure this fork has the problem, but with stock flymake, if you make a legal change (say, insert a space) and then introduce a syntax error while the first check is going, the error is never caught.

I do this to get around it:

(defun interrupting-flymake-start-syntax-check (base-function)
  (when (and (boundp 'flymake-syntax-check-process) (process-live-p flymake-syntax-check-process))
    (setq flymake-check-was-interrupted t)
    (flymake-kill-process flymake-syntax-check-process))
  (funcall base-function)
  (let ((proc (car flymake-processes)))
    (set-process-query-on-exit-flag proc nil)
    (set (make-local-variable 'flymake-syntax-check-process) proc)
    (setq flymake-check-was-interrupted t)
    (setq flymake-is-running nil)))

(advice-add 'flymake-start-syntax-check :around #'interrupting-flymake-start-syntax-check)

Usage instructions about how to replace default flymake

Could you add to flymake.el the instructions on how to load your file in a recent Emacs?

Because recent Emacs already include flymake, a (require 'flymake) doesn't load yours.

If I use (load-file "/w/emacs-flymake/flymake.el"), then I see conflicts or dependency with the old one:

macroexp--expand-all: (void-function flymake-ler-p)
Compiler-macro error for flymake-ler-p: (void-function flymake-ler-p--cmacro)
macroexp--expand-all: (void-function flymake-ler-p)
Compiler-macro error for flymake-ler-p: (void-function flymake-ler-p--cmacro)
macroexp--expand-all: (void-function flymake-ler-p)
Compiler-macro error for flymake-ler-p: (void-function flymake-ler-p--cmacro)
macroexp--expand-all: (void-function flymake-ler-p)
Compiler-macro error for flymake-ler-p: (void-function flymake-ler-p--cmacro)
macroexp--expand-all: (void-function flymake-ler-p)
Compiler-macro error for flymake-ler-p: (void-function flymake-ler-p--cmacro)
Loading /w/emacs-flymake/flymake.el (source)...done

Long log:


Debugger entered--Lisp error: (void-function flymake-ler-p)
  indirect-function(flymake-ler-p)
  (autoload-do-load (indirect-function func) func)
  (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))
  (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil)))
  (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))
  (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))
  (closure ((pcase-3 closure ((pcase-4 closure ((form flymake-ler-p cl-x) t) (args f) (macroexp--expand-all (cons f args))) (form flymake-ler-p cl-x) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form flymake-ler-p cl-x) t) (args f) (macroexp--expand-all (cons f args))) (form flymake-ler-p cl-x) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))))(flymake-ler-p)
  funcall((closure ((pcase-3 closure ((pcase-4 closure ((form flymake-ler-p cl-x) t) (args f) (macroexp--expand-all (cons f args))) (form flymake-ler-p cl-x) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form flymake-ler-p cl-x) t) (args f) (macroexp--expand-all (cons f args))) (form flymake-ler-p cl-x) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))) flymake-ler-p)
  (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (... ...) (funcall pcase-0 x x x)) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr form))) (let ((args x) (fun x)) (macroexp--cons (macroexp--all-forms fun 2) (macroexp--all-forms args) form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (cond ((consp x) (let* ... ...)) ((eq x ...) (let* ... ...)) (t (funcall pcase-2 x)))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))
  (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (let (... ...) (macroexp--cons ... ... form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (cond (... ...) (... ...) (t ...))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x))))
  (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (let ... ...)) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* (...) (cond ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form))
  (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list ... ... ...)) (macroexp--expand-all (cons fun ...)))))) (pcase-2 (function (lambda (func) (let ((handler ...)) (if (null handler) (macroexp--all-forms form 1) (if ... nil ...) (let ... ...)))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons (macroexp--all-clauses bindings 1) (macroexp--all-forms body) (cdr form)) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err (macroexp--cons ... ... ...) (cdr form)) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x ...)) (let (...) (macroexp--cons ... ... form)))) ((eq x (quote condition-case)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x ...)) (if (eq x ...) (let* ... ...) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form)))
  (if (eq (car-safe form) (quote backquote-list*)) (macroexpand (macroexp--all-forms form 1) macroexpand-all-environment) (let ((new-form (macroexpand form macroexpand-all-environment))) (setq form (if (and (not (eq form new-form)) (car-safe form) (symbolp (car form)) (get (car form) (quote byte-obsolete-info)) (or (not (fboundp ...)) (byte-compile-warning-enabled-p (quote obsolete)))) (let* ((fun (car form)) (obsolete (get fun ...))) (macroexp--warn-and-return (macroexp--obsolete-warning fun obsolete (if ... "alias" "macro")) new-form)) new-form))) (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" ...) (macroexp--expand-all ...))))) (pcase-2 (function (lambda (func) (let (...) (if ... ... ... ...))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons ... ... ...) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err ... ...) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* (...) (let ... ...))) ((eq x (quote condition-case)) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* (...) (if ... ... ...))) ((eq x (quote quote)) (let nil form)) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((consp x) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((eq x (quote sort)) (let* (...) (if ... ... ...))) ((eq x (quote funcall)) (let* (...) (if ... ... ...))) (t (funcall pcase-2 x)))) (let nil form))))
  macroexp--expand-all((flymake-ler-p cl-x))
  macroexp--all-forms((or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) 1)
  (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))
  (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))
  (closure ((pcase-3 closure ((pcase-4 closure ((form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" ... ...)) t) (args f) (macroexp--expand-all (cons f args))) (form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (args f) (macroexp--expand-all (cons f args))) (form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))))(or)
  funcall((closure ((pcase-3 closure ((pcase-4 closure ((form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" ... ...)) t) (args f) (macroexp--expand-all (cons f args))) (form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (args f) (macroexp--expand-all (cons f args))) (form or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))) or)
  (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (... ...) (funcall pcase-0 x x x)) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr form))) (let ((args x) (fun x)) (macroexp--cons (macroexp--all-forms fun 2) (macroexp--all-forms args) form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (cond ((consp x) (let* ... ...)) ((eq x ...) (let* ... ...)) (t (funcall pcase-2 x)))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))
  (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (let (... ...) (macroexp--cons ... ... form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (cond (... ...) (... ...) (t ...))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x))))
  (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (let ... ...)) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* (...) (cond ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form))
  (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list ... ... ...)) (macroexp--expand-all (cons fun ...)))))) (pcase-2 (function (lambda (func) (let ((handler ...)) (if (null handler) (macroexp--all-forms form 1) (if ... nil ...) (let ... ...)))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons (macroexp--all-clauses bindings 1) (macroexp--all-forms body) (cdr form)) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err (macroexp--cons ... ... ...) (cdr form)) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x ...)) (let (...) (macroexp--cons ... ... form)))) ((eq x (quote condition-case)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x ...)) (if (eq x ...) (let* ... ...) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form)))
  (if (eq (car-safe form) (quote backquote-list*)) (macroexpand (macroexp--all-forms form 1) macroexpand-all-environment) (let ((new-form (macroexpand form macroexpand-all-environment))) (setq form (if (and (not (eq form new-form)) (car-safe form) (symbolp (car form)) (get (car form) (quote byte-obsolete-info)) (or (not (fboundp ...)) (byte-compile-warning-enabled-p (quote obsolete)))) (let* ((fun (car form)) (obsolete (get fun ...))) (macroexp--warn-and-return (macroexp--obsolete-warning fun obsolete (if ... "alias" "macro")) new-form)) new-form))) (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" ...) (macroexp--expand-all ...))))) (pcase-2 (function (lambda (func) (let (...) (if ... ... ... ...))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons ... ... ...) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err ... ...) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* (...) (let ... ...))) ((eq x (quote condition-case)) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* (...) (if ... ... ...))) ((eq x (quote quote)) (let nil form)) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((consp x) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((eq x (quote sort)) (let* (...) (if ... ... ...))) ((eq x (quote funcall)) (let* (...) (if ... ... ...))) (t (funcall pcase-2 x)))) (let nil form))))
  macroexp--expand-all((or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))))
  macroexp--all-forms((progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) 1)
  (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))
  (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))
  (closure ((pcase-3 closure ((pcase-4 closure ((form progn (or ... ...) (aref cl-x 1)) t) (args f) (macroexp--expand-all (cons f args))) (form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (args f) (macroexp--expand-all (cons f args))) (form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))))(progn)
  funcall((closure ((pcase-3 closure ((pcase-4 closure ((form progn (or ... ...) (aref cl-x 1)) t) (args f) (macroexp--expand-all (cons f args))) (form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (args f) (macroexp--expand-all (cons f args))) (form progn (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))) progn)
  (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (... ...) (funcall pcase-0 x x x)) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr form))) (let ((args x) (fun x)) (macroexp--cons (macroexp--all-forms fun 2) (macroexp--all-forms args) form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (cond ((consp x) (let* ... ...)) ((eq x ...) (let* ... ...)) (t (funcall pcase-2 x)))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))
  (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (let (... ...) (macroexp--cons ... ... form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (cond (... ...) (... ...) (t ...))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x))))
  (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (let ... ...)) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* (...) (cond ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form))
  (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list ... ... ...)) (macroexp--expand-all (cons fun ...)))))) (pcase-2 (function (lambda (func) (let ((handler ...)) (if (null handler) (macroexp--all-forms form 1) (if ... nil ...) (let ... ...)))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons (macroexp--all-clauses bindings 1) (macroexp--all-forms body) (cdr form)) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err (macroexp--cons ... ... ...) (cdr form)) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x ...)) (let (...) (macroexp--cons ... ... form)))) ((eq x (quote condition-case)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x ...)) (if (eq x ...) (let* ... ...) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form)))
  (if (eq (car-safe form) (quote backquote-list*)) (macroexpand (macroexp--all-forms form 1) macroexpand-all-environment) (let ((new-form (macroexpand form macroexpand-all-environment))) (setq form (if (and (not (eq form new-form)) (car-safe form) (symbolp (car form)) (get (car form) (quote byte-obsolete-info)) (or (not (fboundp ...)) (byte-compile-warning-enabled-p (quote obsolete)))) (let* ((fun (car form)) (obsolete (get fun ...))) (macroexp--warn-and-return (macroexp--obsolete-warning fun obsolete (if ... "alias" "macro")) new-form)) new-form))) (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" ...) (macroexp--expand-all ...))))) (pcase-2 (function (lambda (func) (let (...) (if ... ... ... ...))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons ... ... ...) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err ... ...) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* (...) (let ... ...))) ((eq x (quote condition-case)) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* (...) (if ... ... ...))) ((eq x (quote quote)) (let nil form)) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((consp x) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((eq x (quote sort)) (let* (...) (if ... ... ...))) ((eq x (quote funcall)) (let* (...) (if ... ... ...))) (t (funcall pcase-2 x)))) (let nil form))))
  macroexp--expand-all((cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)))
  macroexp--all-forms((lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1))) 2)
  (macroexp--cons (macroexp--all-forms f 2) nil (cdr form))
  (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form)
  (let ((f x)) (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form))
  (if (null x) (let ((f x)) (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form)) (let nil form))
  (let* ((x (cdr x))) (if (null x) (let ((f x)) (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form)) (let nil form)))
  (if (eq x (quote lambda)) (let* ((x (cdr x))) (if (null x) (let ((f x)) (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form)) (let nil form))) (let nil form))
  (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr x))) (if (null x) (let ((f x)) (macroexp--cons (quote function) (macroexp--cons (macroexp--all-forms f 2) nil (cdr form)) form)) (let nil form))) (let nil form)))
  (if (consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr x))) (if (null x) (let ((f x)) (macroexp--cons (quote function) (macroexp--cons ... nil ...) form)) (let nil form))) (let nil form))) (let nil form))
  (let* ((x (car x))) (if (consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr x))) (if (null x) (let (...) (macroexp--cons ... ... form)) (let nil form))) (let nil form))) (let nil form)))
  (if (consp x) (let* ((x (car x))) (if (consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (if (null x) (let ... ...) (let nil form))) (let nil form))) (let nil form))) (let nil form))
  (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (if ... ... ...)) (let nil form))) (let nil form))) (let nil form)))
  (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (... ...) (funcall pcase-0 x x x)) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr form))) (let ((args x) (fun x)) (macroexp--cons (macroexp--all-forms fun 2) (macroexp--all-forms args) form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (cond ((consp x) (let* ... ...)) ((eq x ...) (let* ... ...)) (t (funcall pcase-2 x)))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))
  (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (let (... ...) (macroexp--cons ... ... form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (cond (... ...) (... ...) (t ...))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x))))
  (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (let ... ...)) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* (...) (cond ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form))
  (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list ... ... ...)) (macroexp--expand-all (cons fun ...)))))) (pcase-2 (function (lambda (func) (let ((handler ...)) (if (null handler) (macroexp--all-forms form 1) (if ... nil ...) (let ... ...)))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons (macroexp--all-clauses bindings 1) (macroexp--all-forms body) (cdr form)) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err (macroexp--cons ... ... ...) (cdr form)) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x ...)) (let (...) (macroexp--cons ... ... form)))) ((eq x (quote condition-case)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x ...)) (if (eq x ...) (let* ... ...) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form)))
  (if (eq (car-safe form) (quote backquote-list*)) (macroexpand (macroexp--all-forms form 1) macroexpand-all-environment) (let ((new-form (macroexpand form macroexpand-all-environment))) (setq form (if (and (not (eq form new-form)) (car-safe form) (symbolp (car form)) (get (car form) (quote byte-obsolete-info)) (or (not (fboundp ...)) (byte-compile-warning-enabled-p (quote obsolete)))) (let* ((fun (car form)) (obsolete (get fun ...))) (macroexp--warn-and-return (macroexp--obsolete-warning fun obsolete (if ... "alias" "macro")) new-form)) new-form))) (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" ...) (macroexp--expand-all ...))))) (pcase-2 (function (lambda (func) (let (...) (if ... ... ... ...))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons ... ... ...) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err ... ...) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* (...) (let ... ...))) ((eq x (quote condition-case)) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* (...) (if ... ... ...))) ((eq x (quote quote)) (let nil form)) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((consp x) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((eq x (quote sort)) (let* (...) (if ... ... ...))) ((eq x (quote funcall)) (let* (...) (if ... ... ...))) (t (funcall pcase-2 x)))) (let nil form))))
  macroexp--expand-all((function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1)))))
  macroexp--all-forms((defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1))))) 1)
  (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))
  (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform (macroexp--all-forms form 1))) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))
  (closure ((pcase-3 closure ((pcase-4 closure ((form defalias (quote flymake-ler-file) (function ...)) t) (args f) (macroexp--expand-all (cons f args))) (form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file ... ...)))) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file ... ...)))) t) (args f) (macroexp--expand-all (cons f args))) (form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" ... ...)) (aref cl-x 1))))) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform))))))(defalias)
  funcall((closure ((pcase-3 closure ((pcase-4 closure ((form defalias (quote flymake-ler-file) (function ...)) t) (args f) (macroexp--expand-all (cons f args))) (form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file ... ...)))) t) (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list (quote lambda) (nth 1 f) (quote \.\.\.))) (macroexp--expand-all (cons fun (cons arg1 (cons f args)))))) (pcase-4 closure ((form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file ... ...)))) t) (args f) (macroexp--expand-all (cons f args))) (form defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" ... ...)) (aref cl-x 1))))) t) (func) (let ((handler (function-get func (quote compiler-macro)))) (if (null handler) (macroexp--all-forms form 1) (if (functionp handler) nil (condition-case err (autoload-do-load (indirect-function func) func) ((debug error) (message "macroexp--expand-all: %S" err) nil))) (let ((newform (macroexp--compiler-macro handler form))) (if (eq form newform) (if (equal form (setq newform ...)) form (setq form (macroexp--compiler-macro handler newform)) (if (eq newform form) newform (macroexp--expand-all newform))) (macroexp--expand-all newform)))))) defalias)
  (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (... ...) (funcall pcase-0 x x x)) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x (cdr form))) (let ((args x) (fun x)) (macroexp--cons (macroexp--all-forms fun 2) (macroexp--all-forms args) form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (cond ((consp x) (let* ... ...)) ((eq x ...) (let* ... ...)) (t (funcall pcase-2 x)))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x)) (x (cdr x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x (car x))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))
  (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil))) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form))) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* ((x ...)) (let (... ...) (macroexp--cons ... ... form))) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (cond (... ...) (... ...) (t ...))) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...) (x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x))) (funcall pcase-2 x)))) (t (funcall pcase-2 x))))
  (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x (cdr form))) (let ((clauses x)) (macroexp--cons (quote cond) (macroexp--all-clauses clauses) form)))) ((eq x (quote condition-case)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (funcall pcase-1 x x x)) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x (car x))) (if (eq x (quote lambda)) (let* (...) (let ... ...)) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x (cdr form))) (if (consp x) (let* (...) (cond ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x (cdr form))) (if (consp x) (let* (... ...) (if ... ... ...)) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x (cdr form))) (if (consp x) (let* (...) (if ... ... ...)) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form))
  (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" (list ... ... ...)) (macroexp--expand-all (cons fun ...)))))) (pcase-2 (function (lambda (func) (let ((handler ...)) (if (null handler) (macroexp--all-forms form 1) (if ... nil ...) (let ... ...)))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons (macroexp--all-clauses bindings 1) (macroexp--all-forms body) (cdr form)) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err (macroexp--cons ... ... ...) (cdr form)) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* ((x ...)) (let (...) (macroexp--cons ... ... form)))) ((eq x (quote condition-case)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-0 nil nil nil)))) ((memq x (quote (defconst defvar))) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* ((x ...)) (if (consp x) (let* ... ...) (let nil form)))) ((eq x (quote quote)) (let nil form)) ((memq x (quote (let* let))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-1 nil nil x)))) ((consp x) (let* ((x ...)) (if (eq x ...) (let* ... ...) (funcall pcase-2 x)))) ((memq x (quote (mapc mapconcat mapatoms mapcar apply funcall))) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote sort)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) ((eq x (quote funcall)) (let* ((x ...)) (if (consp x) (let* ... ...) (funcall pcase-2 x)))) (t (funcall pcase-2 x)))) (let nil form)))
  (if (eq (car-safe form) (quote backquote-list*)) (macroexpand (macroexp--all-forms form 1) macroexpand-all-environment) (let ((new-form (macroexpand form macroexpand-all-environment))) (setq form (if (and (not (eq form new-form)) (car-safe form) (symbolp (car form)) (get (car form) (quote byte-obsolete-info)) (or (not (fboundp ...)) (byte-compile-warning-enabled-p (quote obsolete)))) (let* ((fun (car form)) (obsolete (get fun ...))) (macroexp--warn-and-return (macroexp--obsolete-warning fun obsolete (if ... "alias" "macro")) new-form)) new-form))) (let* ((pcase-4 (function (lambda (args f) (macroexp--expand-all (cons f args))))) (pcase-3 (function (lambda (args f arg1 fun) (macroexp--warn-and-return (format "%s quoted with ' rather than with #'" ...) (macroexp--expand-all ...))))) (pcase-2 (function (lambda (func) (let (...) (if ... ... ... ...))))) (pcase-1 (function (lambda (body bindings fun) (macroexp--cons fun (macroexp--cons ... ... ...) form)))) (pcase-0 (function (lambda (handlers body err) (macroexp--cons (quote condition-case) (macroexp--cons err ... ...) form))))) (if (consp form) (let* ((x (car form))) (cond ((eq x (quote cond)) (let* (...) (let ... ...))) ((eq x (quote condition-case)) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let nil (macroexp--all-forms form 2))) ((eq x (quote function)) (let* (...) (if ... ... ...))) ((eq x (quote quote)) (let nil form)) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((consp x) (let* (...) (if ... ... ...))) ((memq x (quote ...)) (let* (...) (if ... ... ...))) ((eq x (quote sort)) (let* (...) (if ... ... ...))) ((eq x (quote funcall)) (let* (...) (if ... ... ...))) (t (funcall pcase-2 x)))) (let nil form))))
  macroexp--expand-all((defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1))))))
  macroexpand-all((defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1))))))
  internal-macroexpand-for-load((defalias (quote flymake-ler-file) (function (lambda (cl-x) (cl-block flymake-ler-file (or (flymake-ler-p cl-x) (error "%s accessing a non-%s" (quote flymake-ler-file) (quote flymake-ler))) (aref cl-x 1))))) t)
  eval-buffer()  ; Reading at buffer position 33057
  funcall-interactively(eval-buffer)
  call-interactively(eval-buffer record nil)
  command-execute(eval-buffer record)
  execute-extended-command(nil "eval-buffer" nil)
  funcall-interactively(execute-extended-command nil "eval-buffer" nil)
  call-interactively(execute-extended-command nil nil)
  command-execute(execute-extended-command)

This is with: GNU Emacs 25.0.50.1 (x86_64-unknown-linux-gnu, X toolkit, Xaw scroll bars) of 2015-01-12 on la4

Maybe you can use a different name like flymake-il? Or really merge everything into main Emacs?

Thanks

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.