From 87f79ddf49fe005cde9a3db1b575efc63d80ac2a Mon Sep 17 00:00:00 2001 From: jochen Date: Tue, 24 Nov 1998 21:23:05 +0000 Subject: [PATCH] Initial revision git-svn-id: https://svn.code.sf.net/p/jode/code/trunk@129 379699f6-c40d-0410-875b-85095c16579e --- jode/COPYING | 340 +++++++++++++++++++ jode/jode/bytecode/ClassFormatException.java | 32 ++ jode/jode/bytecode/ClassHierarchy.java | 177 ++++++++++ jode/jode/bytecode/ConstantPool.java | 147 ++++++++ jode/jode/bytecode/prj.el | 86 +++++ jode/maketar | 9 + jode/test/AssignOp.java | 63 ++++ jode/test/For.java | 17 + jode/test/IfCombine.java | 15 + jode/test/InnerClass.java | 48 +++ jode/test/Test.java | 253 ++++++++++++++ jode/test/TriadicExpr.java | 20 ++ jode/test/TryCatch.java | 138 ++++++++ 13 files changed, 1345 insertions(+) create mode 100644 jode/COPYING create mode 100644 jode/jode/bytecode/ClassFormatException.java create mode 100644 jode/jode/bytecode/ClassHierarchy.java create mode 100644 jode/jode/bytecode/ConstantPool.java create mode 100644 jode/jode/bytecode/prj.el create mode 100755 jode/maketar create mode 100644 jode/test/AssignOp.java create mode 100644 jode/test/For.java create mode 100644 jode/test/IfCombine.java create mode 100644 jode/test/InnerClass.java create mode 100644 jode/test/Test.java create mode 100644 jode/test/TriadicExpr.java create mode 100644 jode/test/TryCatch.java diff --git a/jode/COPYING b/jode/COPYING new file mode 100644 index 0000000..eeb586b --- /dev/null +++ b/jode/COPYING @@ -0,0 +1,340 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) 19yy + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) 19yy name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. diff --git a/jode/jode/bytecode/ClassFormatException.java b/jode/jode/bytecode/ClassFormatException.java new file mode 100644 index 0000000..8bddb2c --- /dev/null +++ b/jode/jode/bytecode/ClassFormatException.java @@ -0,0 +1,32 @@ +/* jode.bytecode.ClassFormatException Copyright (C) 1997-1998 Jochen Hoenicke. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + * + * $Id$ + */ +package jode.bytecode; + +/** + * This exception is thrown, if the class file has an unknown format. + * @author Jochen Hoenicke + */ +public class ClassFormatException extends java.io.IOException{ + public ClassFormatException(String detail) { + super(detail); + } + public ClassFormatException() { + super(); + } +} diff --git a/jode/jode/bytecode/ClassHierarchy.java b/jode/jode/bytecode/ClassHierarchy.java new file mode 100644 index 0000000..5c79211 --- /dev/null +++ b/jode/jode/bytecode/ClassHierarchy.java @@ -0,0 +1,177 @@ +/* jode.bytecode.ClassHierarchy Copyright (C) 1997-1998 Jochen Hoenicke. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + * + * $Id$ + */ +package jode.bytecode; +import jode.SearchPath; +import java.io.*; +import java.util.Hashtable; + +/** + * This class does represent a class similar to java.lang.Class. You + * can get the super class and the interfaces. + * + * The main difference to java.lang.Class is, that the objects are builded + * from a stream containing the .class file, and that it uses the + * jode.Type to represent types instead of Class itself. + * + * @author Jochen Hoenicke + */ +public class ClassHierarchy { + private String name; + private int modifiers = -1; + private ClassHierarchy superclass; + private ClassHierarchy[] interfaces; + private static SearchPath classpath; + private ConstantPool constantPool; + private static Hashtable classes = new Hashtable(); // XXX - weak map + + public final static ClassHierarchy javaLangObject = + ClassHierarchy.forName("java.lang.Object"); + + public static void setClassPath(SearchPath path) { + classpath = path; + } + + + public static ClassHierarchy forName(String name) { + if (name == null) + return null; + name = name.replace('/', '.'); + ClassHierarchy clazz = (ClassHierarchy) classes.get(name); + if (clazz == null) { + clazz = new ClassHierarchy(name); + classes.put(name, clazz); + } + return clazz; + } + + public ClassHierarchy(String name) { + this.name = name; + } + + private void readHeader(DataInputStream input) + throws IOException { + if (input.readInt() != 0xcafebabe) + throw new ClassFormatException("Wrong magic"); + if (input.readUnsignedShort() > 3) + throw new ClassFormatException("Wrong minor"); + if (input.readUnsignedShort() != 45) + throw new ClassFormatException("Wrong major"); + } + + private void readConstants(DataInputStream input) + throws IOException { + constantPool = new ConstantPool(); + constantPool.read(input); + } + + private void readNameAndSuper(DataInputStream input) + throws IOException { + modifiers = input.readUnsignedShort(); + String name = constantPool.getClassName(input.readUnsignedShort()); + if (!this.name.equals(name)) + new ClassFormatException("Class has wrong name: "+name); + superclass = ClassHierarchy.forName + (constantPool.getClassName(input.readUnsignedShort())); + } + + private void readInterfaces(DataInputStream input) + throws IOException { + int count = input.readUnsignedShort(); + interfaces = new ClassHierarchy[count]; + for (int i=0; i< count; i++) { + interfaces[i] = ClassHierarchy.forName + (constantPool.getClassName(input.readUnsignedShort())); + } + } + + private void loadHierarchy() { + try { + DataInputStream input = + new DataInputStream(classpath.getFile(name.replace('.', '/') + + ".class")); + readHeader(input); + readConstants(input); + readNameAndSuper(input); + readInterfaces(input); + + constantPool = null; // Now allow clean up + } catch (IOException ex) { + String message = ex.getLocalizedMessage(); + System.err.println("Can't read class " + name + + ", types may be incorrect. (" + + ex.getClass().getName() + + (message != null ? ": " + message : "")+")"); + + if (name.equals("java.lang.Object")) + superclass = null; + else + superclass = ClassHierarchy.forName("java.lang.Object"); + interfaces = new ClassHierarchy[0]; + } + } + + public ClassHierarchy getSuperclass() { + if (interfaces == null) + loadHierarchy(); + return superclass; + } + + public ClassHierarchy[] getInterfaces() { + if (interfaces == null) + loadHierarchy(); + return interfaces; + } + + public int getModifiers() { + return modifiers; + } + + public boolean isInterface() { + if (interfaces == null) + loadHierarchy(); + return java.lang.reflect.Modifier.isInterface(modifiers); + } + + public String toString() { + return name; + } + + public String getName() { + return name; + } + + public boolean superClassOf(ClassHierarchy son) { + while (son != this && son != null) { + son = son.getSuperclass(); + } + return son == this; + } + + public boolean implementedBy(ClassHierarchy clazz) { + while (clazz != this && clazz != null) { + ClassHierarchy[] ifaces = clazz.getInterfaces(); + for (int i=0; i< ifaces.length; i++) { + if (implementedBy(ifaces[i])) + return true; + } + clazz = clazz.getSuperclass(); + } + return clazz == this; + } +} diff --git a/jode/jode/bytecode/ConstantPool.java b/jode/jode/bytecode/ConstantPool.java new file mode 100644 index 0000000..98ce8b2 --- /dev/null +++ b/jode/jode/bytecode/ConstantPool.java @@ -0,0 +1,147 @@ +/* jode.bytecode.ConstantPool Copyright (C) 1998 Jochen Hoenicke. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2, or (at your option) + * any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; see the file COPYING. If not, write to + * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + * + * $Id$ + */ +package jode.bytecode; +import java.io.*; + +/** + * This class represent the constant pool. + * + * @author Jochen Hoenicke + */ +public class ConstantPool { + public final static int CLASS = 7; + public final static int FIELDREF = 9; + public final static int METHODREF = 10; + public final static int INTERFACEMETHODREF = 11; + public final static int STRING = 8; + public final static int INTEGER = 3; + public final static int FLOAT = 4; + public final static int LONG = 5; + public final static int DOUBLE = 6; + public final static int NAMEANDTYPE = 12; + public final static int UTF8 = 1; + + int[] tags; + int[] indices1, indices2; + + Object[] constants; + + public ConstantPool () { + } + + public void read(DataInputStream stream) + throws IOException { + int count = stream.readUnsignedShort(); + tags = new int[count]; + indices1 = new int[count]; + indices2 = new int[count]; + constants = new Object[count]; + + for (int i=1; i< count; i++) { + int tag = stream.readUnsignedByte(); + tags[i] = tag; + switch (tag) { + case CLASS: + indices1[i] = stream.readUnsignedShort(); + break; + case FIELDREF: + case METHODREF: + case INTERFACEMETHODREF: + indices1[i] = stream.readUnsignedShort(); + indices2[i] = stream.readUnsignedShort(); + break; + case STRING: + indices1[i] = stream.readUnsignedShort(); + break; + case INTEGER: + constants[i] = new Integer(stream.readInt()); + break; + case FLOAT: + constants[i] = new Float(stream.readFloat()); + break; + case LONG: + constants[i] = new Long(stream.readLong()); + tags[++i] = -LONG; + break; + case DOUBLE: + constants[i] = new Double(stream.readDouble()); + tags[++i] = -DOUBLE; + break; + case NAMEANDTYPE: + indices1[i] = stream.readUnsignedShort(); + indices2[i] = stream.readUnsignedShort(); + break; + case UTF8: + constants[i] = new String(stream.readUTF()); + break; + default: + throw new ClassFormatException("unknown constant tag"); + } + } + } + + public String getUTF8(int i) throws ClassFormatException { + if (i == 0) + return null; + if (tags[i] != UTF8) + throw new ClassFormatException("Tag mismatch"); + return (String)constants[i]; + } + + public String getClassName(int i) throws ClassFormatException { + if (i == 0) + return null; + if (tags[i] != CLASS) + throw new ClassFormatException("Tag mismatch"); + return getUTF8(indices1[i]); + } + + public String toString(int i) { + switch (tags[i]) { + case CLASS: + return "class "+toString(indices1[i]); + case STRING: + return "\""+toString(indices1[i])+"\""; + case INTEGER: + case FLOAT: + case LONG: + case DOUBLE: + case UTF8: + return constants[i].toString(); + case FIELDREF: + case METHODREF: + case INTERFACEMETHODREF: + return "Ref: "+toString(indices1[i])+": " + + toString(indices2[i]); + case NAMEANDTYPE: + return toString(indices1[i])+" "+toString(indices2[i]); + default: + return "unknown tag: "+tags[i]; + } + } + + public String toString() { + StringBuffer result = new StringBuffer("[ null"); + for (int i=1; i< tags.length; i++) { + result.append(", ").append(toString(i)); + } + result.append(" ]"); + return result.toString(); + } +} diff --git a/jode/jode/bytecode/prj.el b/jode/jode/bytecode/prj.el new file mode 100644 index 0000000..9d5e726 --- /dev/null +++ b/jode/jode/bytecode/prj.el @@ -0,0 +1,86 @@ + + + +(jde-set-project-name "default") +(jde-set-variables + '(jde-run-option-properties nil) + '(jde-run-option-stack-size (quote ((128 . "kilobytes") (400 . "kilobytes")))) + '(jde-gen-buffer-templates (quote (("Class" . jde-gen-class) ("Console" . jde-gen-console) ("Swing App" . jde-gen-jfc-app)))) + '(jde-compile-option-command-line-args "") + '(jde-gen-action-listener-template (quote ("'& (P \"Component name: \")" "\".addActionListener(new ActionListener() {\" 'n>" "\"public void actionPerformed(ActionEvent e) {\" 'n>" "\"}});\" 'n>"))) + '(jde-compile-option-depend nil) + '(jde-compile-option-optimize nil) + '(jde-run-option-verify (quote (nil t))) + '(jde-gen-inner-class-template (quote ("'& \"class \" (P \"Class name: \" class)" "(P \"Superclass: \" super t)" "(let ((parent (jde-gen-lookup-named 'super)))" "(if (not (string= parent \"\"))" "(concat \" extends \" parent))) \" {\" 'n>" "\"public \" (s class) \"() {\" 'n> \"}\" 'n> \"}\" 'n>"))) + '(jde-run-read-vm-args nil) + '(jde-entering-java-buffer-hooks (quote (jde-reload-project-file))) + '(jde-run-applet-viewer "appletviewer") + '(jde-compile-option-debug t t) + '(jde-project-file-name "prj.el") + '(jde-run-option-verbose (quote (nil nil nil))) + '(jde-run-application-class "") + '(jde-db-option-vm-args nil) + '(jde-run-option-heap-size (quote ((1 . "megabytes") (16 . "megabytes")))) + '(jde-db-read-vm-args nil) + '(jde-db-option-heap-profile (quote (nil "./java.hprof" 5 20 "Allocation objects"))) + '(jde-db-mode-hook nil) + '(jde-run-option-garbage-collection (quote (t t))) + '(jde-compile-option-vm-args nil) + '(jde-run-applet-doc "index.html") + '(jde-db-option-java-profile (quote (nil . "./java.prof"))) + '(jde-gen-get-set-var-template (quote ("'n>" "(P \"Variable type: \" type) \" \"" "(P \"Variable name: \" name) \";\" 'n> 'n>" "\"/**\" 'n>" "\"* Get the value of \" (s name) \".\" 'n>" "\"* @return Value of \" (s name) \".\" 'n>" "\"*/\" 'n>" "\"public \" (s type) \" get\" (jde-gen-init-cap (jde-gen-lookup-named 'name))" "\"() {return \" (s name) \";}\" 'n> 'n>" "\"/**\" 'n>" "\"* Set the value of \" (s name) \".\" 'n>" "\"* @param v Value to assign to \" (s name) \".\" 'n>" "\"*/\" 'n>" "\"public void set\" (jde-gen-init-cap (jde-gen-lookup-named 'name))" "\"(\" (s type) \" v) {this.\" (s name) \" = v;}\" 'n>"))) + '(jde-db-option-verify (quote (nil t))) + '(jde-run-mode-hook nil) + '(jde-db-option-classpath nil) + '(jde-compile-option-deprecation nil) + '(jde-db-startup-commands nil) + '(jde-gen-boilerplate-function (quote jde-gen-create-buffer-boilerplate)) + '(jde-compile-option-nodebug nil) + '(jde-compile-option-classpath nil) + '(jde-build-use-make nil) + '(jde-quote-classpath t) + '(jde-gen-to-string-method-template (quote ("'&" "\"public String toString() {\" 'n>" "\"return super.toString();\" 'n>" "\"}\" 'n>"))) + '(jde-run-read-app-args nil) + '(jde-db-source-directories (quote ("d:/jdk1.2/src/"))) + '(jde-db-option-properties nil) + '(jde-db-option-stack-size (quote ((128 . "kilobytes") (400 . "kilobytes")))) + '(jde-db-set-initial-breakpoint t) + '(jde-run-option-application-args (quote ("jode.flow.FlowBlock")) t) + '(jde-gen-mouse-listener-template (quote ("'& (P \"Component name: \")" "\".addMouseListener(new MouseAdapter() {\" 'n>" "\"public void mouseClicked(MouseEvent e) {}\" 'n>" "\"public void mouseEntered(MouseEvent e) {}\" 'n>" "\"public void mouseExited(MouseEvent e) {}\" 'n>" "\"public void mousePressed(MouseEvent e) {}\" 'n>" "\"public void mouseReleased(MouseEvent e) {}});\" 'n>"))) + '(jde-gen-console-buffer-template (quote ("(funcall jde-gen-boilerplate-function) 'n" "\"/**\" 'n" "\" * \"" "(file-name-nondirectory buffer-file-name) 'n" "\" *\" 'n" "\" *\" 'n" "\" * Created: \" (current-time-string) 'n" "\" *\" 'n" "\" * @author \" (user-full-name) 'n" "\" * @version\" 'n" "\" */\" 'n>" "'n>" "\"public class \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\" {\" 'n> 'n>" "\"public \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\"() {\" 'n>" "'n>" "\"}\" 'n>" "'n>" "\"public static void main(String[] args) {\" 'n>" "'p 'n>" "\"}\" 'n> 'n>" "\"} // \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "'n>"))) + '(jde-compile-option-directory "~/java" t) + '(jde-run-option-vm-args nil) + '(jde-make-program "make") + '(jde-use-font-lock t) + '(jde-db-option-garbage-collection (quote (t t))) + '(jde-gen-class-buffer-template (quote ("(funcall jde-gen-boilerplate-function)" "\"package jode;\" 'n" "'n" "\"/**\" 'n" "\" * \" 'n" "\" * @author \" (user-full-name) 'n" "\" */\" 'n" "\"public class \" (file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\" \" (jde-gen-get-super-class) \" {\" 'n" "> 'n" "> \"public \" (file-name-sans-extension (file-name-nondirectory buffer-file-name)) \"() {\" 'n" "> 'p 'n" "> \"}\" 'n" "> 'n" "> \"}\" 'n"))) + '(jde-compiler "javac") + '(jde-jdk-doc-url "file:/usr/doc/packages/jdk115/docs/index.html") + '(jde-db-debugger (quote ("jdb" . "Executable"))) + '(jde-compile-option-optimize-interclass nil) + '(jde-run-option-classpath nil) + '(jde-key-bindings (quote (("" . jde-compile) ("" . jde-run) ("" . jde-db) ("" . jde-build) ("" . jde-run-menu-run-applet) ("" . jde-browse-jdk-doc) ("" . jde-save-project) (" " . jde-gen-println)))) + '(jde-gen-mouse-motion-listener-template (quote ("'& (P \"Component name: \")" "\".addMouseMotionListener(new MouseMotionAdapter() {\" 'n>" "\"public void mouseDragged(MouseEvent e) {}\" 'n>" "\"public void mouseMoved(MouseEvent e) {}});\" 'n>"))) + '(jde-db-marker-regexp "^Breakpoint hit: .*(\\([^$]*\\).*:\\([0-9]*\\))") + '(jde-run-working-directory "") + '(jde-gen-window-listener-template (quote ("'& (P \"Window name: \")" "\".addWindowListener(new WindowAdapter() {\" 'n>" "\"public void windowActivated(WindowEvent e) {}\" 'n>" "\"public void windowClosed(WindowEvent e) {}\" 'n>" "\"public void windowClosing(WindowEvent e) {System.exit(0);}\" 'n>" "\"public void windowDeactivated(WindowEvent e) {}\" 'n>" "\"public void windowDeiconified(WindowEvent e) {}\" 'n>" "\"public void windowIconified(WindowEvent e) {}\" 'n>" "\"public void windowOpened(WindowEvent e) {}});\" 'n>"))) + '(jde-global-classpath nil) + '(jde-enable-abbrev-mode nil) + '(jde-gen-println (quote ("'&" "\"System.out.println(\" (P \"Print out: \") \");\" 'n>"))) + '(jde-run-option-heap-profile (quote (nil "./java.hprof" 5 20 "Allocation objects"))) + '(jde-db-read-app-args nil) + '(jde-db-option-verbose (quote (nil nil nil))) + '(jde-run-java-vm "java") + '(jde-read-compile-args nil) + '(jde-run-option-java-profile (quote (nil . "./java.prof"))) + '(jde-compile-option-encoding nil) + '(jde-run-java-vm-w "javaw") + '(jde-compile-option-nowarn nil) + '(jde-gen-jfc-app-buffer-template (quote ("(funcall jde-gen-boilerplate-function) 'n" "\"import java.awt.*;\" 'n" "\"import java.awt.event.*;\" 'n" "\"import com.sun.java.swing.*;\" 'n 'n" "\"/**\" 'n" "\" * \"" "(file-name-nondirectory buffer-file-name) 'n" "\" *\" 'n" "\" *\" 'n" "\" * Created: \" (current-time-string) 'n" "\" *\" 'n" "\" * @author \" (user-full-name) 'n" "\" * @version\" 'n" "\" */\" 'n>" "'n>" "\"public class \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\" extends JFrame {\" 'n> 'n>" "\"public \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\"() {\" 'n>" "\"super(\\\"\" (P \"Enter app title: \") \"\\\");\" 'n>" "\"setSize(600, 400);\" 'n>" "\"addWindowListener(new WindowAdapter() {\" 'n>" "\"public void windowClosing(WindowEvent e) {System.exit(0);}\" 'n>" "\"public void windowOpened(WindowEvent e) {}});\" 'n>" "\"}\" 'n>" "'n>" "\"public static void main(String[] args) {\" 'n>" "'n>" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\" f = new \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "\"();\" 'n>" "\"f.show();\" 'n>" "'p 'n>" "\"}\" 'n> 'n>" "\"} // \"" "(file-name-sans-extension (file-name-nondirectory buffer-file-name))" "'n>"))) + '(jde-db-option-application-args nil) + '(jde-gen-buffer-boilerplate (quote ("/* " (file-name-nondirectory buffer-file-name) " Copyright (C) 1997-1998 Jochen Hoenicke." 'n " *" 'n " * This program is free software; you can redistribute it and/or modify" 'n " * it under the terms of the GNU General Public License as published by" 'n " * the Free Software Foundation; either version 2, or (at your option)" 'n " * any later version." 'n " *" 'n " * This program is distributed in the hope that it will be useful," 'n " * but WITHOUT ANY WARRANTY; without even the implied warranty of" 'n " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the" 'n " * GNU General Public License for more details." 'n " *" 'n " * You should have received a copy of the GNU General Public License" 'n " * along with this program; see the file COPYING. If not, write to" 'n " * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA." 'n " *" 'n " * $" "Id$" 'n " */" 'n))) + '(jde-db-option-heap-size (quote ((1 . "megabytes") (16 . "megabytes")))) + '(jde-compile-option-verbose nil) + '(jde-mode-abbreviations (quote (("ab" . "abstract") ("bo" . "boolean") ("br" . "break") ("by" . "byte") ("byv" . "byvalue") ("cas" . "cast") ("ca" . "catch") ("ch" . "char") ("cl" . "class") ("co" . "const") ("con" . "continue") ("de" . "default") ("dou" . "double") ("el" . "else") ("ex" . "extends") ("fa" . "false") ("fi" . "final") ("fin" . "finally") ("fl" . "float") ("fo" . "for") ("fu" . "future") ("ge" . "generic") ("go" . "goto") ("impl" . "implements") ("impo" . "import") ("ins" . "instanceof") ("in" . "int") ("inte" . "interface") ("lo" . "long") ("na" . "native") ("ne" . "new") ("nu" . "null") ("pa" . "package") ("pri" . "private") ("pro" . "protected") ("pu" . "public") ("re" . "return") ("sh" . "short") ("st" . "static") ("su" . "super") ("sw" . "switch") ("sy" . "synchronized") ("th" . "this") ("thr" . "throw") ("throw" . "throws") ("tra" . "transient") ("tr" . "true") ("vo" . "void") ("vol" . "volatile") ("wh" . "while")))) + '(jde-make-args "") + '(jde-gen-code-templates (quote (("Get Set Pair" . jde-gen-get-set) ("toString method" . jde-gen-to-string-method) ("Action Listener" . jde-gen-action-listener) ("Window Listener" . jde-gen-window-listener) ("Mouse Listener" . jde-gen-mouse-listener) ("Mouse Motion Listener" . jde-gen-mouse-motion-listener) ("Inner Class" . jde-gen-inner-class) ("println" . jde-gen-println))))) diff --git a/jode/maketar b/jode/maketar new file mode 100755 index 0000000..b5b40c2 --- /dev/null +++ b/jode/maketar @@ -0,0 +1,9 @@ +#!/bin/sh + +echo '#!/bin/sh' > co.all +echo co -u *.java flow/*.java gb/*.java >> co.all +echo javac -d \$HOME/java -g gb/*.java Decompiler.java >> co.all + +cd .. +tar -cvzf jode.tar.gz jode/co.all jode/maketar \ + jode/RCS jode/flow/RCS jode/gb/RCS jode/test/*.java diff --git a/jode/test/AssignOp.java b/jode/test/AssignOp.java new file mode 100644 index 0000000..f6df953 --- /dev/null +++ b/jode/test/AssignOp.java @@ -0,0 +1,63 @@ +package jode.test; + +public class AssignOp { + static int static_int; + static double static_double; + static String static_String; + static long static_long; + + int obj_int; + long obj_long; + double obj_double; + String obj_String; + + int [] arr_int; + long[] arr_long; + double[] arr_double; + String[] arr_String; + + void assop() { + int local_int = 0; + double local_double = 1.0; + String local_String = null; + + local_int |= 25 | local_int; + static_int <<= 3; + obj_int *= 17 + obj_int; + arr_int[local_int] /= (obj_int+=7); + + local_double /= 3.0; + static_double *= obj_int; + obj_double -= 25; + arr_double[local_int] /= (local_double+=7.0); + + static_String += "Hallo"; + obj_String += "Hallo"; + arr_String[0] += local_double + static_String + "Hallo" + obj_int; + local_String += "Hallo"; + } + + void prepost() { + int local_int= -1; + long local_long= 4; + + local_long = local_int++; + obj_long = ++obj_int; + arr_long[static_int] = static_long = (arr_long[--static_int] = (static_int--))+1; + } + + void iinc() { + int local_int = 0; + local_int += 5; + obj_int = (local_int -= 5); + + static_int = local_int++; + obj_int = --local_int; + } +} + + + + + + diff --git a/jode/test/For.java b/jode/test/For.java new file mode 100644 index 0000000..586e736 --- /dev/null +++ b/jode/test/For.java @@ -0,0 +1,17 @@ +package jode.test; + +public class For { + + boolean nested() { + outer: + for (int i=0; i< 100; i++) { + for (int j=0; j< 100; j++) { + if (i < j) + continue outer; + } + return false; + } + return true; + } + +} diff --git a/jode/test/IfCombine.java b/jode/test/IfCombine.java new file mode 100644 index 0000000..b1300e7 --- /dev/null +++ b/jode/test/IfCombine.java @@ -0,0 +1,15 @@ +package jode.test; + +public class IfCombine { + boolean a,b,c; + int i,j,k; + + public void foo() { + if ( a && (b || c) && (i 5) { + for (int j=0; j<5; j++) { + z++; + } + } + i--; + } + } + public void arithTest() { + int a=1,b=2; + boolean x = true,y = false; + int c=0; + skip(); + if (x & y) { + c = 5; + skip(); + x &= y; + skip(); + x = x | y; + skip(); + x ^= y; + skip(); + x = x && y; + skip(); + b <<= a; + b <<= c; + } + a&=b; + } + + + + public void switchWhileTest() { + int local_1__114 = g_in; + int local_2__115 = 0; + int local_3__116 = 0; + int local_4__117 = 0; + z = 5; + switch (local_1__114) { + case 1: + while (local_4__117 == 0) { + local_4__117 = 1; + local_2__115 = g_in; + local_3__116 = g_in; + if (local_2__115 > 7) + local_2__115 = local_2__115 - 4; + int local_5__118 = 0; + while (local_5__118 < 4) { + int local_6__119 = 0; + while (local_6__119 < 5) { + if (ain[local_6__119] == local_2__115 + local_5__118 && ain[local_6__119] == local_3__116) + local_4__117 = 0; + local_6__119 += 1; + } + local_5__118 += 1; + } + } + int local_5__120 = 0; + while (local_5__120 < 5) { + ain[z] = local_2__115 + local_5__120; + ain[z] = local_3__116; + z += 1; + local_5__120 += 1; + } + break; + case 2: + while (local_4__117 == 0) { + local_4__117 = 1; + local_2__115 = g_in; + local_3__116 = g_in; + if (local_3__116 > 7) + local_3__116 = local_3__116 - 4; + int local_5__121 = 0; + while (local_5__121 < 4) { + int local_6__122 = 0; + while (local_6__122 < 4) { + if (ain[local_6__122] == local_2__115 && ain[local_6__122] == local_3__116 + local_5__121) + local_4__117 = 0; + local_6__122 += 1; + } + local_5__121 += 1; + } + } + int local_5__123 = 0; + while (local_5__123 < 4) { + ain[z] = local_2__115; + ain[z] = local_3__116 + local_5__123; + z += 1; + local_5__123 += 1; + } + break; + } + } + + public void intTypeTest() { + boolean b = false; + boolean abo[] = null; + byte aby[] = null; + byte by; + int in; + short sh; + b = g_bo; + in = g_sh; + sh = (short)g_in; + by = (byte)sh; + sh = by; + in = by; + abo[0] = g_bo; + abo[1] = false; + abo[2] = true; + aby[0] = g_by; + aby[1] = 0; + aby[2] = 1; + } + + /** + * This is an example where our flow analysis doesn't find an + * elegant solution. The reason is, that we try to make + * while(true)-loops as small as possible (you can't see the real + * end of the loop, if it is breaked there like here). + * + * Look at the assembler code and you know why my Decompiler has + * problems with this. But the decompiler does produce compilable + * code which produces the same assembler code. + * + * A solution would be, to make switches as big as possible (like we + * already do it with try-catch-blocks). + */ + void WhileTrueSwitch() { + int i = 1; + while (true) { + switch (i) { + case 0: + return; + case 1: + i = 5; + continue; + case 2: + i = 6; + continue; + case 3: + throw new RuntimeException(); + default: + i = 7; + return; + } + } + } + + native void arrFunc(B[] b); + + /** + * This is an example where it is really hard to know, which type + * each local has. + */ + void DifficultType () { + B myB = c; + C myC = c; + I2 myI2 = c; + I12 myI12 = c; + boolean bool = true; + B[] aB = new C[3]; + arrFunc(new C[3]); + + while (bool) { + if (bool) { + i1 = myB; + i2 = myC; + i1 = aB[0]; + } else if (bool) { + i1 = myI12; + i2 = myI2; + } else { + i1 = myC; + i2 = myI12; + } + myB = b; + if (bool) + myI2 = i12; + else { + myI12 = d; + myI2 = e; + } + } + } + + /** + * This is an example where it is really hard to know, which type + * each local has. + */ + void DifficultArrayType () { + boolean bool = true; + B[] aB = new C[3]; + arrFunc(new C[3]); + C[][][][][] x = new C[4][3][4][][]; + int[][][][][] y = new int[1][2][][][]; + + while (bool) { + if (bool) { + i1 = aB[0]; + aB[0] = b; + } + } + } +} + diff --git a/jode/test/TriadicExpr.java b/jode/test/TriadicExpr.java new file mode 100644 index 0000000..345d821 --- /dev/null +++ b/jode/test/TriadicExpr.java @@ -0,0 +1,20 @@ +package jode.test; + +public class TriadicExpr { + int a,b,c,d,e,f,g,h,i,j; + boolean bool; + + void test() { + if( (a< b ? bool : (a