CFR - another java decompiler

My current commuting project (keeps me busy on the train ;) is a Java decompiler.

CFR will decompile Java 8 lambdas, Java 7 String switches etc, but is written entirely in Java 6.

To use, simply run the specific version jar, with the class name you want to decompile, and optionally the method name. (--help to list arguments).

• cfr_0_13.jar (May 2013)
• Older versions

FAQ

Observations about syntactic sugar in compilation.

All of this stuff is documented (links where I find them); these are things I found particularly interesting while messing around with this.

• Stringbuilder vs concatenation.
• How are Java 1.5 Enums implemented?
• How is Java 1.4 assert implemented?
• How is switch-on-enum compiled?
• How is Java 7's switch-on-string compiled?
• varargs is just a method attribute...
• Autoboxing is expanded for you by the compiler
• Looking at Integer.valueOf's cache
• Inner classes have to fake friendship...
• Java 8's lambdas..
• Field initialisation and the ConstantValue attribute

To do...

It's got a lot of things missing, which I'm messing with, as and when time makes itself available ;)

• Generic reverse inference (forward inference works... getting better!)
• Better inference of scope for try blocks.
• Better Inlining of synthetic accessors in anonymous classes (very rudimentary currently)
• .... and no doubt much more. ;)

Change history

0_13 (2013-05-16)

• Better class literals
• Treat <clinit> properly as static {}
• Move initialisation from static {} to declarations where possible
• Move initialisation from constrcutors to declarations where possible
• Prune dead decompiled code (step 1)

0_12 (2013-05-09)

• Interface extension methods (defender methods)
• Improve display of annotations
• Fix bug with declaration of string literals when direct from constpool
• Infer top directory when analysing files, to better search for imports.
• Fix issue with typing of array declarations
• Simplify boolean expressions in more places
• Hide anonymous translation classes (eg enum switch lookup classes)
• Various output tidying, imports, package name display
• Fix incorrectly detecting some float literals as double
• Resugar enums (disable with --sugarenums false)

0_11 (2013-04-17)

• Java 8 Lambda functions. (controlled with --decodelambdas)
• Default desugaring is now by language version in class file - i.e. switch in string will not be desugared automatically unless classfile is java 7. Can be controlled with command line parameters.

0_10 (2013-04-05)

• Annotations
• StringBuilder -> String desugaring doesn't lose implicit casts
• Significant improvement to reversing of while(true) logic.
• Inline inner classes
• Initial inner class desugaring - remove (optionally) synthetic constructor args (more to do)

0_9 (2013-03-13)

• Also show throw specification
• Fixed bug which lost stack merges when they weren't immediately used. (quite rare, it happens!!)
• Tidy redundant ternaries

0_8 (2013-03-07)

• Proper variable declarations finally!
• fix some type locking problems introduced in 0_7.

0_7 (2013-03-05)

• Switch on enum re-sugaring
• Better type inference with integral types (i.e. detecting booleans)
• Better basic block detection
• improved argument handling
• Better generics support
  • Will now load referenced classes if possible to get generic signatures
  • Displays signature data for fields
  • Propagates generic type info - so iterator() on List<Fred> will return Iterator<Fred>, and next() on that will return Fred. (You can see this in collection loops very clearly)
• Better command line parameters. (--help to see) (I said better, I didn't say great!).

0_6 (2013-02-01)

• Switch on string re-sugaring
• Remove temporaries in catch blocks

0_5

• Trivial JSR handling
• fixed bug with DUP2_X1 (only ever seen in obfuscated code)
• tidied output
• I2B types
• fix bug with incorrect ordering of continues explicitly at end of while blocks.

0_4

• SWAP op (I've only ever seen this in obfuscated code!!)
• Support for ConstantAttribute
• Extra int type inference from return values
• Allow mutation statements (|=, += etc, support for preinc / postinc).
• Better labelling for this/super calls.

0_3

• Synchronized blocks
• Improved try/catch
• Improve case handling for same branch cases
• Initial handling for generics (only from signature now).

0_2

• Java 6 iteration loops detected
• Better type information/inference
• MULTIANEWARRAY (and other array improvements)
• *CMP* refactored, don't appear in output now.

It goes without saying, that you should not use this to violate any laws, customs or kittens. Decompilers are fun, and that is all.