Add javassist to external
We are going to add android-mock to external, which uses javassist.
Change-Id: Ibc17ea987c3a8cebb0a30e56d3574c3bacd589b2
diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..b5d12be
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2011 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+# We only want this apk build for tests.
+LOCAL_MODULE_TAGS := tests
+
+# We need classes from the tools dir in the JDK
+LOCAL_CLASSPATH := $(HOST_JDK_TOOLS_JAR)
+
+LOCAL_MODULE := javassistlib
+
+LOCAL_SRC_FILES := $(call all-java-files-under,src/main)
+
+include $(BUILD_HOST_JAVA_LIBRARY)
diff --git a/HOWTO.txt b/HOWTO.txt
new file mode 100644
index 0000000..91f9992
--- /dev/null
+++ b/HOWTO.txt
@@ -0,0 +1,4 @@
+In order to update the code, simply export it from svn with the regenerate_from_source.sh.
+If you want to run the tests, remember to do it from master or a branch that
+includes junit.jar and that has been compiled. The command is:
+ant -propertyfile build.properties test
diff --git a/License.html b/License.html
new file mode 100644
index 0000000..bec1335
--- /dev/null
+++ b/License.html
@@ -0,0 +1,372 @@
+<HTML>
+<HEAD>
+<TITLE>Javassist License</TITLE>
+<META http-equiv=Content-Type content="text/html; charset=iso-8859-1">
+<META content="MSHTML 5.50.4916.2300" name=GENERATOR></HEAD>
+
+<BODY text=#000000 vLink=#551a8b aLink=#ff0000 link=#0000ee bgColor=#ffffff>
+<CENTER><B><FONT size=+2>MOZILLA PUBLIC LICENSE</FONT></B> <BR><B>Version
+1.1</B>
+<P>
+<HR width="20%">
+</CENTER>
+<P><B>1. Definitions.</B>
+<UL><B>1.0.1. "Commercial Use" </B>means distribution or otherwise making the
+ Covered Code available to a third party.
+ <P><B>1.1. ''Contributor''</B> means each entity that creates or contributes
+ to the creation of Modifications.
+ <P><B>1.2. ''Contributor Version''</B> means the combination of the Original
+ Code, prior Modifications used by a Contributor, and the Modifications made by
+ that particular Contributor.
+ <P><B>1.3. ''Covered Code''</B> means the Original Code or Modifications or
+ the combination of the Original Code and Modifications, in each case including
+ portions thereof<B>.</B>
+ <P><B>1.4. ''Electronic Distribution Mechanism''</B> means a mechanism
+ generally accepted in the software development community for the electronic
+ transfer of data.
+ <P><B>1.5. ''Executable''</B> means Covered Code in any form other than Source
+ Code.
+ <P><B>1.6. ''Initial Developer''</B> means the individual or entity identified
+ as the Initial Developer in the Source Code notice required by <B>Exhibit
+ A</B>.
+ <P><B>1.7. ''Larger Work''</B> means a work which combines Covered Code or
+ portions thereof with code not governed by the terms of this License.
+ <P><B>1.8. ''License''</B> means this document.
+ <P><B>1.8.1. "Licensable"</B> means having the right to grant, to the maximum
+ extent possible, whether at the time of the initial grant or subsequently
+ acquired, any and all of the rights conveyed herein.
+ <P><B>1.9. ''Modifications''</B> means any addition to or deletion from the
+ substance or structure of either the Original Code or any previous
+ Modifications. When Covered Code is released as a series of files, a
+ Modification is:
+ <UL><B>A.</B> Any addition to or deletion from the contents of a file
+ containing Original Code or previous Modifications.
+ <P><B>B.</B> Any new file that contains any part of the Original Code or
+ previous Modifications. <BR> </P></UL><B>1.10. ''Original Code''</B>
+ means Source Code of computer software code which is described in the Source
+ Code notice required by <B>Exhibit A</B> as Original Code, and which, at the
+ time of its release under this License is not already Covered Code governed by
+ this License.
+ <P><B>1.10.1. "Patent Claims"</B> means any patent claim(s), now owned or
+ hereafter acquired, including without limitation, method, process, and
+ apparatus claims, in any patent Licensable by grantor.
+ <P><B>1.11. ''Source Code''</B> means the preferred form of the Covered Code
+ for making modifications to it, including all modules it contains, plus any
+ associated interface definition files, scripts used to control compilation and
+ installation of an Executable, or source code differential comparisons against
+ either the Original Code or another well known, available Covered Code of the
+ Contributor's choice. The Source Code can be in a compressed or archival form,
+ provided the appropriate decompression or de-archiving software is widely
+ available for no charge.
+ <P><B>1.12. "You'' (or "Your") </B> means an individual or a legal entity
+ exercising rights under, and complying with all of the terms of, this License
+ or a future version of this License issued under Section 6.1. For legal
+ entities, "You'' includes any entity which controls, is controlled by, or is
+ under common control with You. For purposes of this definition, "control''
+ means (a) the power, direct or indirect, to cause the direction or management
+ of such entity, whether by contract or otherwise, or (b) ownership of more
+ than fifty percent (50%) of the outstanding shares or beneficial ownership of
+ such entity.</P></UL><B>2. Source Code License.</B>
+<UL><B>2.1. The Initial Developer Grant.</B> <BR>The Initial Developer hereby
+ grants You a world-wide, royalty-free, non-exclusive license, subject to third
+ party intellectual property claims:
+ <UL><B>(a)</B> <B> </B>under intellectual property rights (other than
+ patent or trademark) Licensable by Initial Developer to use, reproduce,
+ modify, display, perform, sublicense and distribute the Original Code (or
+ portions thereof) with or without Modifications, and/or as part of a Larger
+ Work; and
+ <P><B>(b)</B> under Patents Claims infringed by the making, using or selling
+ of Original Code, to make, have made, use, practice, sell, and offer for
+ sale, and/or otherwise dispose of the Original Code (or portions thereof).
+ <UL>
+ <UL></UL></UL><B>(c) </B>the licenses granted in this Section 2.1(a) and (b)
+ are effective on the date Initial Developer first distributes Original Code
+ under the terms of this License.
+ <P><B>(d) </B>Notwithstanding Section 2.1(b) above, no patent license is
+ granted: 1) for code that You delete from the Original Code; 2) separate
+ from the Original Code; or 3) for infringements caused by: i) the
+ modification of the Original Code or ii) the combination of the Original
+ Code with other software or devices. <BR> </P></UL><B>2.2. Contributor
+ Grant.</B> <BR>Subject to third party intellectual property claims, each
+ Contributor hereby grants You a world-wide, royalty-free, non-exclusive
+ license
+ <UL> <BR><B>(a)</B> <B> </B>under intellectual property rights (other
+ than patent or trademark) Licensable by Contributor, to use, reproduce,
+ modify, display, perform, sublicense and distribute the Modifications
+ created by such Contributor (or portions thereof) either on an unmodified
+ basis, with other Modifications, as Covered Code and/or as part of a Larger
+ Work; and
+ <P><B>(b)</B> under Patent Claims infringed by the making, using, or selling
+ of Modifications made by that Contributor either alone and/or in<FONT
+ color=#000000> combination with its Contributor Version (or portions of such
+ combination), to make, use, sell, offer for sale, have made, and/or
+ otherwise dispose of: 1) Modifications made by that Contributor (or portions
+ thereof); and 2) the combination of Modifications made by that
+ Contributor with its Contributor Version (or portions of such
+ combination).</FONT>
+ <P><B>(c) </B>the licenses granted in Sections 2.2(a) and 2.2(b) are
+ effective on the date Contributor first makes Commercial Use of the Covered
+ Code.
+ <P><B>(d) </B> Notwithstanding Section 2.2(b) above, no
+ patent license is granted: 1) for any code that Contributor has deleted from
+ the Contributor Version; 2) separate from the Contributor
+ Version; 3) for infringements caused by: i) third party
+ modifications of Contributor Version or ii) the combination of
+ Modifications made by that Contributor with other software (except as
+ part of the Contributor Version) or other devices; or 4) under Patent Claims
+ infringed by Covered Code in the absence of Modifications made by that
+ Contributor.</P></UL></UL>
+<P><BR><B>3. Distribution Obligations.</B>
+<UL><B>3.1. Application of License.</B> <BR>The Modifications which You create
+ or to which You contribute are governed by the terms of this License,
+ including without limitation Section <B>2.2</B>. The Source Code version of
+ Covered Code may be distributed only under the terms of this License or a
+ future version of this License released under Section <B>6.1</B>, and You must
+ include a copy of this License with every copy of the Source Code You
+ distribute. You may not offer or impose any terms on any Source Code version
+ that alters or restricts the applicable version of this License or the
+ recipients' rights hereunder. However, You may include an additional document
+ offering the additional rights described in Section <B>3.5</B>.
+ <P><B>3.2. Availability of Source Code.</B> <BR>Any Modification which You
+ create or to which You contribute must be made available in Source Code form
+ under the terms of this License either on the same media as an Executable
+ version or via an accepted Electronic Distribution Mechanism to anyone to whom
+ you made an Executable version available; and if made available via Electronic
+ Distribution Mechanism, must remain available for at least twelve (12) months
+ after the date it initially became available, or at least six (6) months after
+ a subsequent version of that particular Modification has been made available
+ to such recipients. You are responsible for ensuring that the Source Code
+ version remains available even if the Electronic Distribution Mechanism is
+ maintained by a third party.
+ <P><B>3.3. Description of Modifications.</B> <BR>You must cause all Covered
+ Code to which You contribute to contain a file documenting the changes You
+ made to create that Covered Code and the date of any change. You must include
+ a prominent statement that the Modification is derived, directly or
+ indirectly, from Original Code provided by the Initial Developer and including
+ the name of the Initial Developer in (a) the Source Code, and (b) in any
+ notice in an Executable version or related documentation in which You describe
+ the origin or ownership of the Covered Code.
+ <P><B>3.4. Intellectual Property Matters</B>
+ <UL><B>(a) Third Party Claims</B>. <BR>If Contributor has knowledge that a
+ license under a third party's intellectual property rights is required to
+ exercise the rights granted by such Contributor under Sections 2.1 or 2.2,
+ Contributor must include a text file with the Source Code distribution
+ titled "LEGAL'' which describes the claim and the party making the claim in
+ sufficient detail that a recipient will know whom to contact. If Contributor
+ obtains such knowledge after the Modification is made available as described
+ in Section 3.2, Contributor shall promptly modify the LEGAL file in all
+ copies Contributor makes available thereafter and shall take other steps
+ (such as notifying appropriate mailing lists or newsgroups) reasonably
+ calculated to inform those who received the Covered Code that new knowledge
+ has been obtained.
+ <P><B>(b) Contributor APIs</B>. <BR>If Contributor's Modifications include
+ an application programming interface and Contributor has knowledge of patent
+ licenses which are reasonably necessary to implement that API, Contributor
+ must also include this information in the LEGAL file.
+ <BR> </P></UL>
+ <B>(c) Representations.</B>
+ <UL>Contributor represents that, except as disclosed pursuant to Section
+ 3.4(a) above, Contributor believes that Contributor's Modifications are
+ Contributor's original creation(s) and/or Contributor has sufficient rights
+ to grant the rights conveyed by this License.</UL>
+ <P><BR><B>3.5. Required Notices.</B> <BR>You must duplicate the notice in
+ <B>Exhibit A</B> in each file of the Source Code. If it is not possible
+ to put such notice in a particular Source Code file due to its structure, then
+ You must include such notice in a location (such as a relevant directory)
+ where a user would be likely to look for such a notice. If You created
+ one or more Modification(s) You may add your name as a Contributor to the
+ notice described in <B>Exhibit A</B>. You must also duplicate this
+ License in any documentation for the Source Code where You describe
+ recipients' rights or ownership rights relating to Covered Code. You may
+ choose to offer, and to charge a fee for, warranty, support, indemnity or
+ liability obligations to one or more recipients of Covered Code. However, You
+ may do so only on Your own behalf, and not on behalf of the Initial Developer
+ or any Contributor. You must make it absolutely clear than any such warranty,
+ support, indemnity or liability obligation is offered by You alone, and You
+ hereby agree to indemnify the Initial Developer and every Contributor for any
+ liability incurred by the Initial Developer or such Contributor as a result of
+ warranty, support, indemnity or liability terms You offer.
+ <P><B>3.6. Distribution of Executable Versions.</B> <BR>You may distribute
+ Covered Code in Executable form only if the requirements of Section
+ <B>3.1-3.5</B> have been met for that Covered Code, and if You include a
+ notice stating that the Source Code version of the Covered Code is available
+ under the terms of this License, including a description of how and where You
+ have fulfilled the obligations of Section <B>3.2</B>. The notice must be
+ conspicuously included in any notice in an Executable version, related
+ documentation or collateral in which You describe recipients' rights relating
+ to the Covered Code. You may distribute the Executable version of Covered Code
+ or ownership rights under a license of Your choice, which may contain terms
+ different from this License, provided that You are in compliance with the
+ terms of this License and that the license for the Executable version does not
+ attempt to limit or alter the recipient's rights in the Source Code version
+ from the rights set forth in this License. If You distribute the Executable
+ version under a different license You must make it absolutely clear that any
+ terms which differ from this License are offered by You alone, not by the
+ Initial Developer or any Contributor. You hereby agree to indemnify the
+ Initial Developer and every Contributor for any liability incurred by the
+ Initial Developer or such Contributor as a result of any such terms You offer.
+
+ <P><B>3.7. Larger Works.</B> <BR>You may create a Larger Work by combining
+ Covered Code with other code not governed by the terms of this License and
+ distribute the Larger Work as a single product. In such a case, You must make
+ sure the requirements of this License are fulfilled for the Covered
+Code.</P></UL><B>4. Inability to Comply Due to Statute or Regulation.</B>
+<UL>If it is impossible for You to comply with any of the terms of this
+ License with respect to some or all of the Covered Code due to statute,
+ judicial order, or regulation then You must: (a) comply with the terms of this
+ License to the maximum extent possible; and (b) describe the limitations and
+ the code they affect. Such description must be included in the LEGAL file
+ described in Section <B>3.4</B> and must be included with all distributions of
+ the Source Code. Except to the extent prohibited by statute or regulation,
+ such description must be sufficiently detailed for a recipient of ordinary
+ skill to be able to understand it.</UL><B>5. Application of this License.</B>
+<UL>This License applies to code to which the Initial Developer has attached
+ the notice in <B>Exhibit A</B> and to related Covered Code.</UL><B>6. Versions
+of the License.</B>
+<UL><B>6.1. New Versions</B>. <BR>Netscape Communications Corporation
+ (''Netscape'') may publish revised and/or new versions of the License from
+ time to time. Each version will be given a distinguishing version number.
+ <P><B>6.2. Effect of New Versions</B>. <BR>Once Covered Code has been
+ published under a particular version of the License, You may always continue
+ to use it under the terms of that version. You may also choose to use such
+ Covered Code under the terms of any subsequent version of the License
+ published by Netscape. No one other than Netscape has the right to modify the
+ terms applicable to Covered Code created under this License.
+ <P><B>6.3. Derivative Works</B>. <BR>If You create or use a modified version
+ of this License (which you may only do in order to apply it to code which is
+ not already Covered Code governed by this License), You must (a) rename Your
+ license so that the phrases ''Mozilla'', ''MOZILLAPL'', ''MOZPL'',
+ ''Netscape'', "MPL", ''NPL'' or any confusingly similar phrase do not appear
+ in your license (except to note that your license differs from this License)
+ and (b) otherwise make it clear that Your version of the license contains
+ terms which differ from the Mozilla Public License and Netscape Public
+ License. (Filling in the name of the Initial Developer, Original Code or
+ Contributor in the notice described in <B>Exhibit A</B> shall not of
+ themselves be deemed to be modifications of this License.)</P></UL><B>7.
+DISCLAIMER OF WARRANTY.</B>
+<UL>COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS'' BASIS, WITHOUT
+ WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT
+ LIMITATION, WARRANTIES THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE,
+ FIT FOR A PARTICULAR PURPOSE OR NON-INFRINGING. THE ENTIRE RISK AS TO THE
+ QUALITY AND PERFORMANCE OF THE COVERED CODE IS WITH YOU. SHOULD ANY COVERED
+ CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT THE INITIAL DEVELOPER OR ANY
+ OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY SERVICING, REPAIR OR
+ CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL PART OF THIS
+ LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER THIS
+ DISCLAIMER.</UL><B>8. TERMINATION.</B>
+<UL><B>8.1. </B>This License and the rights granted hereunder will
+ terminate automatically if You fail to comply with terms herein and fail to
+ cure such breach within 30 days of becoming aware of the breach. All
+ sublicenses to the Covered Code which are properly granted shall survive any
+ termination of this License. Provisions which, by their nature, must remain in
+ effect beyond the termination of this License shall survive.
+ <P><B>8.2. </B>If You initiate litigation by asserting a patent
+ infringement claim (excluding declatory judgment actions) against Initial
+ Developer or a Contributor (the Initial Developer or Contributor against whom
+ You file such action is referred to as "Participant") alleging that:
+ <P><B>(a) </B>such Participant's Contributor Version directly or
+ indirectly infringes any patent, then any and all rights granted by such
+ Participant to You under Sections 2.1 and/or 2.2 of this License shall, upon
+ 60 days notice from Participant terminate prospectively, unless if within 60
+ days after receipt of notice You either: (i) agree in writing to pay
+ Participant a mutually agreeable reasonable royalty for Your past and future
+ use of Modifications made by such Participant, or (ii) withdraw Your
+ litigation claim with respect to the Contributor Version against such
+ Participant. If within 60 days of notice, a reasonable royalty and
+ payment arrangement are not mutually agreed upon in writing by the parties or
+ the litigation claim is not withdrawn, the rights granted by Participant to
+ You under Sections 2.1 and/or 2.2 automatically terminate at the expiration of
+ the 60 day notice period specified above.
+ <P><B>(b)</B> any software, hardware, or device, other than such
+ Participant's Contributor Version, directly or indirectly infringes any
+ patent, then any rights granted to You by such Participant under Sections
+ 2.1(b) and 2.2(b) are revoked effective as of the date You first made, used,
+ sold, distributed, or had made, Modifications made by that Participant.
+ <P><B>8.3. </B>If You assert a patent infringement claim against
+ Participant alleging that such Participant's Contributor Version directly or
+ indirectly infringes any patent where such claim is resolved (such as by
+ license or settlement) prior to the initiation of patent infringement
+ litigation, then the reasonable value of the licenses granted by such
+ Participant under Sections 2.1 or 2.2 shall be taken into account in
+ determining the amount or value of any payment or license.
+ <P><B>8.4.</B> In the event of termination under Sections 8.1 or 8.2
+ above, all end user license agreements (excluding distributors and
+ resellers) which have been validly granted by You or any distributor hereunder
+ prior to termination shall survive termination.</P></UL><B>9. LIMITATION OF
+LIABILITY.</B>
+<UL>UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, WHETHER TORT (INCLUDING
+ NEGLIGENCE), CONTRACT, OR OTHERWISE, SHALL YOU, THE INITIAL DEVELOPER, ANY
+ OTHER CONTRIBUTOR, OR ANY DISTRIBUTOR OF COVERED CODE, OR ANY SUPPLIER OF ANY
+ OF SUCH PARTIES, BE LIABLE TO ANY PERSON FOR ANY INDIRECT, SPECIAL,
+ INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER INCLUDING, WITHOUT
+ LIMITATION, DAMAGES FOR LOSS OF GOODWILL, WORK STOPPAGE, COMPUTER FAILURE OR
+ MALFUNCTION, OR ANY AND ALL OTHER COMMERCIAL DAMAGES OR LOSSES, EVEN IF SUCH
+ PARTY SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF SUCH DAMAGES. THIS
+ LIMITATION OF LIABILITY SHALL NOT APPLY TO LIABILITY FOR DEATH OR PERSONAL
+ INJURY RESULTING FROM SUCH PARTY'S NEGLIGENCE TO THE EXTENT APPLICABLE LAW
+ PROHIBITS SUCH LIMITATION. SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR
+ LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THIS EXCLUSION AND
+ LIMITATION MAY NOT APPLY TO YOU.</UL><B>10. U.S. GOVERNMENT END USERS.</B>
+<UL>The Covered Code is a ''commercial item,'' as that term is defined in 48
+ C.F.R. 2.101 (Oct. 1995), consisting of ''commercial computer software'' and
+ ''commercial computer software documentation,'' as such terms are used in 48
+ C.F.R. 12.212 (Sept. 1995). Consistent with 48 C.F.R. 12.212 and 48 C.F.R.
+ 227.7202-1 through 227.7202-4 (June 1995), all U.S. Government End Users
+ acquire Covered Code with only those rights set forth herein.</UL><B>11.
+MISCELLANEOUS.</B>
+<UL>This License represents the complete agreement concerning subject matter
+ hereof. If any provision of this License is held to be unenforceable, such
+ provision shall be reformed only to the extent necessary to make it
+ enforceable. This License shall be governed by California law provisions
+ (except to the extent applicable law, if any, provides otherwise), excluding
+ its conflict-of-law provisions. With respect to disputes in which at least one
+ party is a citizen of, or an entity chartered or registered to do business in
+ the United States of America, any litigation relating to this License shall be
+ subject to the jurisdiction of the Federal Courts of the Northern District of
+ California, with venue lying in Santa Clara County, California, with the
+ losing party responsible for costs, including without limitation, court costs
+ and reasonable attorneys' fees and expenses. The application of the United
+ Nations Convention on Contracts for the International Sale of Goods is
+ expressly excluded. Any law or regulation which provides that the language of
+ a contract shall be construed against the drafter shall not apply to this
+ License.</UL><B>12. RESPONSIBILITY FOR CLAIMS.</B>
+<UL>As between Initial Developer and the Contributors, each party is
+ responsible for claims and damages arising, directly or indirectly, out of its
+ utilization of rights under this License and You agree to work with Initial
+ Developer and Contributors to distribute such responsibility on an equitable
+ basis. Nothing herein is intended or shall be deemed to constitute any
+ admission of liability.</UL><B>13. MULTIPLE-LICENSED CODE.</B>
+<UL>Initial Developer may designate portions of the Covered Code as
+ �Multiple-Licensed?. �Multiple-Licensed? means that the Initial
+ Developer permits you to utilize portions of the Covered Code under Your
+ choice of the MPL or the alternative licenses, if any, specified by the
+ Initial Developer in the file described in Exhibit A.</UL>
+<P><BR><B>EXHIBIT A -Mozilla Public License.</B>
+<UL>The contents of this file are subject to the Mozilla Public License
+ Version 1.1 (the "License"); you may not use this file except in compliance
+ with the License. You may obtain a copy of the License at
+ <BR>http://www.mozilla.org/MPL/
+ <P>Software distributed under the License is distributed on an "AS IS" basis,
+ WITHOUT WARRANTY OF <BR>ANY KIND, either express or implied. See the License
+ for the specific language governing rights and <BR>limitations under the
+ License.
+ <P>The Original Code is Javassist.
+ <P>The Initial Developer of the Original Code is Shigeru Chiba.
+ Portions created by the Initial Developer are<BR>
+ Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+ <P>Contributor(s): ______________________________________.
+
+ <P>Alternatively, the contents of this file may be used under the terms of
+ the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ in which case the provisions of the LGPL are applicable instead
+ of those above. If you wish to allow use of your version of this file only
+ under the terms of the LGPL, and not to allow others to
+ use your version of this file under the terms of the MPL, indicate your
+ decision by deleting the provisions above and replace them with the notice
+ and other provisions required by the LGPL. If you do not delete
+ the provisions above, a recipient may use your version of this file under
+ the terms of either the MPL or the LGPL.
+
+ <P></P></UL>
+</BODY>
+</HTML>
diff --git a/Readme.html b/Readme.html
new file mode 100644
index 0000000..f6429fe
--- /dev/null
+++ b/Readme.html
@@ -0,0 +1,800 @@
+<html>
+<HEAD>
+ <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
+ <TITLE>Read Me First</TITLE>
+</HEAD>
+<body>
+
+<h1>Javassist version 3</h1>
+
+<h3>Copyright (C) 1999-2010 by Shigeru Chiba, All rights reserved.</h3>
+
+<p><br></p>
+
+<p>Javassist (JAVA programming ASSISTant) makes Java bytecode manipulation
+simple. It is a class library for editing bytecodes in Java;
+it enables Java programs to define a new class at runtime and to
+modify a class file when the JVM loads it. Unlike other similar
+bytecode editors, Javassist provides two levels of API: source level
+and bytecode level. If the users use the source-level API, they can
+edit a class file without knowledge of the specifications of the Java
+bytecode. The whole API is designed with only the vocabulary of the
+Java language. You can even specify inserted bytecode in the form of
+source text; Javassist compiles it on the fly. On the other hand, the
+bytecode-level API allows the users to directly edit a class file as
+other editors.
+
+<p><br>
+
+<h2>Files</h2>
+
+<ul>
+<table>
+<tr>
+<td><li><tt><a href="License.html">License.html</a></tt></td>
+<td>License file
+(Also see the <a href="#copyright">copyright notices</a> below)</td>
+</tr>
+
+<tr>
+<td><li><tt><a href="tutorial/tutorial.html">tutorial/tutorial.html</a></tt></td>
+<td>Tutorial</td>
+</tr>
+
+<tr>
+<td><li><tt>./javassist.jar</tt></td>
+<td>The Javassist jar file (class files)</td>
+</tr>
+
+<tr>
+<td><li><tt>./src/main</tt></td>
+<td>The source files</td>
+</tr>
+
+<tr>
+<td><li><tt><a href="html/index.html">html/index.html</a></tt></td>
+<td>The top page of the Javassist API document.</td>
+</tr>
+
+<tr>
+<td><li><tt>./sample/</tt></td>
+<td>Sample programs</td>
+</tr>
+</table>
+</ul>
+
+<p><br>
+
+<h2>How to run sample programs</h2>
+
+<p>JDK 1.4 or later is needed.
+
+<h3>0. If you have Apache Ant</h3>
+
+<p>Run the sample-all task.
+Otherwise, follow the instructions below.
+
+<h3>1. Move to the directory where this Readme.html file is located.</h3>
+
+<p>In the following instructions, we assume that the javassist.jar
+file is included in the class path.
+For example, the javac and java commands must receive
+the following <code>classpath</code> option:
+
+<ul><pre>
+-classpath ".:javassist.jar"
+</pre></ul>
+
+<p>If the operating system is Windows, the path
+separator must be not <code>:</code> (colon) but
+<code>;</code> (semicolon). The java command can receive
+the <code>-cp</code> option
+as well as <code>-classpath</code>.
+
+<p>If you don't want to use the class-path option, you can make
+<code>javassist.jar</code> included in the <code>CLASSPATH</code>
+environment:
+
+<ul><pre>
+export CLASSPATH=.:javassist.jar
+</pre></ul>
+
+<p>or if the operating system is Windows:
+
+<ul><pre>
+set CLASSPATH=.;javassist.jar
+</pre></ul>
+
+
+<p>Otherwise, you can copy <tt>javassist.jar</tt> to the directory
+
+<ul><<i>java-home</i>><tt>/jre/lib/ext</tt>.</ul>
+
+<p><<i>java-home</i>> depends on the system. It is usually
+<tt>/usr/local/java</tt>, <tt>c:\j2sdk1.4\</tt>, etc.
+
+<h3>2. sample/Test.java</h3>
+
+<p> This is a very simple program using Javassist.
+
+<p> To run, type the commands:
+
+<ul><pre>
+% javac sample/Test.java
+% java sample.Test
+</pre></ul>
+
+<p> For more details, see <a type="text/plain" href="sample/Test.java">sample/Test.java</a>
+
+<h3>3. sample/reflect/*.java</h3>
+
+<p> This is the "verbose metaobject" example well known in reflective
+ programming. This program dynamically attaches a metaobject to
+ a Person object. The metaobject prints a message if a method
+ is called on the Person object.
+
+<p> To run, type the commands:
+
+<ul><pre>
+% javac sample/reflect/*.java
+% java javassist.tools.reflect.Loader sample.reflect.Main Joe
+</pre></ul>
+
+<p>Compare this result with that of the regular execution without reflection:
+
+<ul><pre>% java sample.reflect.Person Joe</pre></ul>
+
+<p> For more details, see <a type="text/plain" href="sample/reflect/Main.java">sample/reflect/Main.java</a>
+
+<p> Furthermore, the Person class can be statically modified so that
+ all the Person objects become reflective without sample.reflect.Main.
+ To do this, type the commands:
+
+<ul><pre>
+% java javassist.tools.reflect.Compiler sample.reflect.Person -m sample.reflect.VerboseMetaobj
+</pre></ul>
+
+<p> Then,
+<ul><pre>
+% java sample.reflect.Person Joe
+</pre></ul>
+
+<h3>4. sample/duplicate/*.java</h3>
+
+<p> This is another example of reflective programming.
+
+<p> To run, type the commands:
+
+<ul><pre>
+% javac sample/duplicate/*.java
+% java sample.duplicate.Main
+</pre></ul>
+
+<p>Compare this result with that of the regular execution without reflection:
+
+<ul><pre>% java sample.duplicate.Viewer</pre></ul>
+
+<p>For more details, see
+<a type="text/plain" href="sample/duplicate/Main.java">sample/duplicate/Main.java</a>
+
+<h3>5. sample/vector/*.java</h3>
+
+<p>This example shows the use of Javassit for producing a class representing
+a vector of a given type at compile time.
+
+<p> To run, type the commands:
+<ul><pre>
+% javac sample/vector/*.java
+% java sample.preproc.Compiler sample/vector/Test.j
+% javac sample/vector/Test.java
+% java sample.vector.Test
+</pre></ul>
+
+<p>Note: <code>javassist.jar</code> is unnecessary to compile and execute
+<code>sample/vector/Test.java</code>.
+
+For more details, see
+<a type="text/plain" href="sample/vector/Test.j">sample/vector/Test.j</a>
+and <a type="text/plain" href="sample/vector/VectorAssistant.java">sample/vector/VectorAssistant.java</a>
+
+<h3>6. sample/rmi/*.java</h3>
+
+<p> This demonstrates the javassist.rmi package.
+
+<p> To run, type the commands:
+<ul><pre>
+% javac sample/rmi/*.java
+% java sample.rmi.Counter 5001
+</pre></ul>
+
+<p> The second line starts a web server listening to port 5001.
+
+<p> Then, open <a href="sample/rmi/webdemo.html">sample/rmi/webdemo.html</a>
+with a web browser running
+ on the local host. (<tt>webdemo.html</tt> trys to fetch an applet from
+ <tt>http://localhost:5001/</tt>, which is the web server we started above.)
+
+<p> Otherwise, run sample.rmi.CountApplet as an application:
+
+<ul><pre>
+% java javassist.web.Viewer localhost 5001 sample.rmi.CountApplet
+</pre></ul>
+
+<h3>7. sample/evolve/*.java</h3>
+
+<p> This is a demonstration of the class evolution mechanism implemented
+ with Javassist. This mechanism enables a Java program to reload an
+ existing class file under some restriction.
+
+<p> To run, type the commands:
+<ul><pre>
+% javac sample/evolve/*.java
+% java sample.evolve.DemoLoader 5003
+</pre></ul>
+
+<p> The second line starts a class loader DemoLoader, which runs a web
+ server DemoServer listening to port 5003.
+
+<p> Then, open <a href="http://localhost:5003/demo.html">http://localhost:5003/demo.html</a> with a web browser running
+ on the local host.
+(Or, see <a href="sample/evolve/start.html">sample/evolve/start.html</a>.)
+
+<h3>8. sample/hotswap/*.java</h3>
+
+<p>This shows dynamic class reloading by the JPDA. It needs JDK 1.4 or later.
+To run, first type the following commands:
+
+<ul><pre>
+% cd sample/hotswap
+% javac *.java
+% cd logging
+% javac *.java
+% cd ..
+</pre></ul>
+
+<p>If your Java is 1.4, then type:
+
+<ul><pre>
+% java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000 Test
+</pre></ul>
+
+<p>If you are using Java 5, then type:
+
+<ul><pre>
+% java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000 Test
+</pre></ul>
+
+<p>Note that the class path must include <code>JAVA_HOME/lib/tools.jar</code>.
+
+<h2>Hints</h2>
+
+<p>To know the version number, type this command:
+
+<ul><pre>
+% java -jar javassist.jar
+</pre></ul>
+
+<p>Javassist provides a class file viewer for debugging. For more details,
+see javassist.Dump.
+
+<p><br>
+
+<h2>Changes</h2>
+
+<p>-version 3.14 on October 5, 2010
+
+<ul>
+ <li>JIRA JASSIST-121, 123, 128, 129, 130, 131, 132.
+</ul>
+
+<p>-version 3.13 on July 19, 2010
+
+<ul>
+ <li>JIRA JASSIST-118, 119, 122, 124, 125.
+</ul>
+
+<p>-version 3.12.1 on June 10, 2010
+
+<p>-version 3.12 on April 16, 2010
+
+<p>-version 3.11 on July 3, 2009
+<ul>
+ <li>JIRA JASSIST-67, 68, 74, 75, 76, 77, 81, 83, 84, 85, 86, 87 were fixed.
+ <li>Now javassist.bytecode.CodeIterator can insert a gap into
+ a large method body more than 32KB. (JIRA JASSIST-79, 80)
+</ul>
+
+<p>-version 3.10 on March 5, 2009
+
+<ul>
+ <li>JIRA JASSIST-69, 70, 71 were fixed.
+</ul>
+
+<p>-version 3.9 on October 9, 2008
+<ul>
+ <li>ClassPool.makeClassIfNew(InputStream) was implemented.
+ <li>CtNewMethod.wrapped(..) and CtNewConstructor.wrapped(..)
+ implicitly append a method like _added_m$0.
+ This method now has a synthetic attribute.
+ <li>JIRA JASSIST-66 has been fixed.
+</ul>
+
+<p>-version 3.8.1 on July 17, 2008
+<ul>
+ <li>CtClass.rebuildClassFile() has been added.
+ <li>A few bugs of javassist.bytecode.analysis have been fixed.
+ 3.8.0 could not correctly deal with one letter class name
+ such as I and J.
+</ul>
+
+<p>-version 3.8.0 on June 13, 2008
+<ul>
+ <li>javassist.bytecode.analysis was implemented.
+ <li>JASSIST-45, 47, 51, 54-57, 60, 62 were fixed.
+</ul>
+
+<p>-version 3.7.1 on March 10, 2008
+<ul>
+ <li>a bug of javassist.util.proxy has been fixed.
+</ul>
+
+<p>-version 3.7 on January 20, 2008
+<ul>
+ <li>Several minor bugs have been fixed.
+</ul>
+
+<p>-version 3.6.0 on September 13, 2007
+
+<p>-version 3.6.0.CR1 on July 27, 2007
+
+<ul>
+ <li>The stack map table introduced since Java 6 has been supported.
+ <li>CtClass#getDeclaredBehaviors() now returns a class initializer
+ as well as methods and constructors.
+ <li>The default status of automatic pruning was made off.
+ Instead of pruning, this version of Javassist compresses
+ the data structure of a class file after toBytecode() is called.
+ The compressed class file is automatically decompressed when needed.
+ This saves memory space better than pruning.
+ <li><a href="http://jira.jboss.com/jira/browse/JASSIST-33">JIRA JASSIST-33</a> has been fixed.
+</ul>
+
+<p>-version 3.5 on April 29, 2007
+<ul>
+ <li>Various minor updates.
+</ul>
+
+<p>-version 3.4 on November 17, 2006
+<ul>
+ <li>A bug in CodeConverter#replaceFieldRead() and CodeConverter#replaceFieldWrite()
+ was fixed. <a href="http://jira.jboss.com/jira/browse/JBAOP-284">JBAOP-284</a>.
+
+ <li>A synchronization bug and a performance bug in <code>javassist.util.proxy</code>
+ have been fixed
+ (<a href="http://jira.jboss.com/jira/browse/JASSIST-28">JASSIST-28</a>).
+ Now generated proxy classes are cached. To turn the caching off,
+ set <code>ProxyFactory.useCache</code> to <code>false</code>.
+</ul>
+
+<p>-version 3.3 on August 17, 2006
+<ul>
+ <li>CtClass#toClass() and ClassPool#toClass() were modified to accept a
+ <code>ProtectionDomain</code>
+ (<a href="http://jira.jboss.com/jira/browse/JASSIST-23">JASSIST-23</a>).
+ Now ClassPool#toClass(CtClass, ClassLoader) should not be overridden. All
+ subclasses of ClassPool must override toClass(CtClass, ClassLoader,
+ ProtectionDomain).
+
+ <li>CtClass#getAvailableAnnotations() etc. have been implemented.
+
+ <li>A bug related to a way of dealing with a bridge method was fixed
+ (<a href="http://jira.jboss.com/jira/browse/HIBERNATE-37">HIBERNATE-37</a>).
+
+ <li>javassist.scopedpool package was added.
+</ul>
+
+<p>-version 3.2 on June 21, 2006
+
+<ul>
+ <li>The behavior of CtBehavior#getParameterAnnotations() has been changed.
+ It is now compatible to Java Reflection API
+ (<a href="http://jira.jboss.com/jira/browse/JASSIST-19">JASSIST-19</a>).
+</ul>
+
+<p>- version 3.2.0.CR2 on May 9, 2006
+<ul>
+ <li>A bug of replace(String,ExprEditor) in javassist.expr.Expr has been fixed.
+ <li>Updated ProxyFactory getClassLoader to choose the javassit class loader
+ when the proxy superclass has a null class loader (a jdk/endorsed class)
+ (<a href='http://jira.jboss.com/jira/browse/JASSIST-18'>JASSIST-18</a>).
+ <li>Updated the throws clause of the javassist.util.proxy.MethodHandler
+ to be Throwable rather than Exception
+ (<a href='http://jira.jboss.com/jira/browse/JASSIST-16'>JASSIST-16</a>).
+</ul>
+
+<p>- version 3.2.0.CR1 on March 18, 2006
+<ul>
+ <li>Annotations enhancements to javassist.bytecode.MethodInfo.
+ <li>Allow a ClassPool to override the "guess" at the classloader to use.
+</ul>
+
+<p>- version 3.1 on February 23, 2006
+
+<ul>
+ <li>getFields(), getMethods(), and getConstructors() in CtClass
+ were changed to return non-private memebers instead of only
+ public members.
+ <li>getEnclosingClass() in javassist.CtClass was renamed
+ to getEnclosingMethod().
+ <li>getModifiers() was extended to return Modifier.STATIC if the class
+ is a static inner class.
+ <li>The return type of CtClass.stopPruning() was changed from void
+ to boolean.
+ <li>toMethod() in javassist.CtConstructor has been implemented.
+ <li>It includes new javassist.util.proxy package
+ similar to Enhancer of CGLIB.
+ <p>
+ <li>The subpackages of Javassist were restructured.
+ <ul>
+ <li>javassist.tool package was renamed to javassist.tools.
+ <li>HotSwapper was moved to javassist.util.
+ <li>Several subpackages were moved to javassist.tools.
+ <li>javassist.preproc package was elminated and the source was
+ moved to the sample directory.
+ </ul>
+</ul>
+
+<p>- version 3.1 RC2 on September 7, 2005
+
+<ul>
+ <li>RC2 is released mainly for an administrative reason.
+ <li>A few bugs have been fixed.
+</ul>
+
+<p>- version 3.1 RC1 on August 29, 2005
+
+<ul>
+ <li>Better annotation supports. See <code>CtClass.getAnnotations()</code>
+ <li>javassist.tool.HotSwapper was added.
+ <li>javassist.ClassPool.importPackage() was added.
+ <li>The compiler now accepts array initializers
+ (only one dimensional arrays).
+ <li>javassist.Dump was moved to javassist.tool.Dump.
+ <li>Many bugs were fixed.
+</ul>
+
+<p>- version 3.0 on January 18, 2005
+
+<ul>
+ <li>The compiler now supports synchronized statements and finally
+ clauses.
+ <li>You can now remove a method and a field.
+</ul>
+
+<p>- version 3.0 RC1 on September 13, 2004.
+
+<ul>
+ <li>CtClass.toClass() has been reimplemented. The behavior has been
+ changed.
+ <li>javassist.expr.NewArray has been implemented. It enables modifying
+ an expression for array creation.
+ <li><code>.class</code> notation has been supported. The modified class
+ file needs javassist.runtime.DotClass at runtime.
+ <li>a bug in <code>CtClass.getMethods()</code> has been fixed.
+ <li>The compiler supports a switch statement.
+</ul>
+
+<p>- version 3.0 beta on May 18th, 2004.
+
+<ul>
+ <li>The ClassPool framework has been redesigned.
+ <ul>
+ <li>writeFile(), write(), ... in ClassPool have been moved to CtClass.
+ <li>The design of javassist.Translator has been changed.
+ </ul>
+
+ <li>javassist.bytecode.annotation has been added for meta tags.
+ <li>CtClass.makeNestedClass() has been added.
+ <li>The methods declared in javassist.bytecode.InnerClassesAttribute
+ have been renamed a bit.
+ <li>Now local variables were made available in the source text passed to
+ CtBehavior.insertBefore(), MethodCall.replace(), etc.
+ <li>CtClass.main(), which prints the version number, has been added.
+ <li>ClassPool.SimpleLoader has been public.
+ <li>javassist.bytecode.DeprecatedAttribute has been added.
+ <li>javassist.bytecode.LocalVariableAttribute has been added.
+ <li>CtClass.getURL() and javassist.ClassPath.find() has been added.
+ <li>CtBehavior.insertAt() has been added.
+ <li>CtClass.detach() has been added.
+ <li>CodeAttribute.computeMaxStack() has been added.
+</ul>
+
+<p>- version 2.6 in August, 2003.
+
+<ul>
+ <li>The behavior of CtClass.setSuperclass() was changed.
+ To obtain the previous behavior, call CtClass.replaceClassName().
+ <li>CtConstructor.setBody() now works for class initializers.
+ <li>CtNewMethod.delegator() now works for static methods.
+ <li>javassist.expr.Expr.indexOfBytecode() has been added.
+ <li>javassist.Loader has been modified so that getPackage() returns
+ a package object.
+ <li>Now, the compiler can correctly compile a try statement and an
+ infinite while-loop.
+</ul>
+
+<p>- version 2.5.1 in May, 2003.
+<br>Simple changes for integration with JBoss AOP
+<ul>
+ <li>Made ClassPool.get0 protected so that subclasses of ClassPool can call it.
+ <li>Moved all access to the class cache (the field ClassPool.classes) to a method called getCached(String classname). This is so subclasses of ClassPool can override this behavior.
+</ul>
+
+<p>- version 2.5 in May, 2003.
+<br>From this version, Javassist is part of the JBoss project.
+<ul>
+ <li>The license was changed from MPL to MPL/LGPL dual.
+ <li>ClassPool.removeClassPath() and ClassPath.close() have been added.
+ <li>ClassPool.makeClass(InputStream) has been added.
+ <li>CtClass.makeClassInitializer() has been added.
+ <li>javassist.expr.Expr has been changed to a public class.
+ <li>javassist.expr.Handler has been added.
+ <li>javassist.expr.MethodCall.isSuper() has been added.
+ <li>CtMethod.isEmpty() and CtConstructor.isEmpty() have been added.
+ <li>LoaderClassPath has been implemented.
+</ul>
+
+<p>- version 2.4 in February, 2003.
+<ul>
+ <li>The compiler included in Javassist did not correctly work with
+ interface methods. This bug was fixed.
+ <li>Now javassist.bytecode.Bytecode allows more than 255 local
+ variables in the same method.
+ <li>javassist.expr.Instanceof and Cast have been added.
+ <li>javassist.expr.{MethodCall,NewExpr,FieldAccess,Instanceof,Cast}.where()
+ have been added. They return the caller-side method surrounding the
+ expression.
+ <li>javassist.expr.{MethodCall,NewExpr,FieldAccess,Instanceof,Cast}.mayThrow()
+ have been added.
+ <li>$class has been introduced.
+ <li>The parameters to replaceFieldRead(), replaceFieldWrite(),
+ and redirectFieldAccess() in javassist.CodeConverter are changed.
+ <li>The compiler could not correctly handle a try-catch statement.
+ This bug has been fixed.
+</ul>
+
+<p>- version 2.3 in December, 2002.
+<ul>
+ <li>The tutorial has been revised a bit.
+ <li>SerialVersionUID class was donated by Bob Lee. Thanks.
+ <li>CtMethod.setBody() and CtConstructor.setBody() have been added.
+ <li>javassist.reflect.ClassMetaobject.useContextClassLoader has been added.
+ If true, the reflection package does not use Class.forName() but uses
+ a context class loader specified by the user.
+ <li>$sig and $type are now available.
+ <li>Bugs in Bytecode.write() and read() have been fixed.
+</ul>
+
+<p>- version 2.2 in October, 2002.
+<ul>
+ <li>The tutorial has been revised.
+ <li>A new package <code>javassist.expr</code> has been added.
+ This is replacement of classic <code>CodeConverter</code>.
+ <li>javassist.ConstParameter was changed into
+ javassist.CtMethod.ConstParameter.
+ <li>javassist.FieldInitializer was renamed into
+ javassist.CtField.Initializer.
+ <li>A bug in javassist.bytecode.Bytecode.addInvokeinterface() has been
+ fixed.
+ <li>In javassist.bytecode.Bytecode, addGetfield(), addGetstatic(),
+ addInvokespecial(), addInvokestatic(), addInvokevirtual(),
+ and addInvokeinterface()
+ have been modified to update the current statck depth.
+</ul>
+
+<p>- version 2.1 in July, 2002.
+<ul>
+ <li>javassist.CtMember and javassist.CtBehavior have been added.
+ <li>javassist.CtClass.toBytecode() has been added.
+ <li>javassist.CtClass.toClass() and javassist.ClassPool.writeAsClass()
+ has been added.
+ <li>javassist.ByteArrayClassPath has been added.
+ <li>javassist.bytecode.Mnemonic has been added.
+ <li>Several bugs have been fixed.
+</ul>
+
+<p>- version 2.0 (major update) in November, 2001.
+<ul>
+ <li>The javassist.bytecode package has been provided. It is a
+ lower-level API for directly modifying a class file although
+ the users must have detailed knowledge of the Java bytecode.
+
+ <li>The mechanism for creating CtClass objects have been changed.
+
+ <li>javassist.tool.Dump moves to the javassist package.
+</ul>
+
+<p>version 1.0 in July, 2001.
+<ul>
+ <li>javassist.reflect.Metaobject and ClassMetaobject was changed.
+ Now they throw the same exception that they receive from a
+ base-level object.
+</ul>
+
+<p>- version 0.8
+<ul>
+ <li>javassist.tool.Dump was added. It is a class file viewer.
+
+ <li>javassist.FiledInitializer.byNewArray() was added. It is for
+ initializing a field with an array object.
+
+ <li>javassist.CodeConverter.redirectMethodCall() was added.
+
+ <li>javassist.Run was added.
+</ul>
+
+<p>- version 0.7
+<ul>
+ <li>javassit.Loader was largely modified. javassist.UserLoader was
+ deleted. Instead, Codebase was renamed to ClassPath
+ and UserClassPath was added. Now programmers who want to
+ customize Loader must write a class implementing UserClassPath
+ instead of UserLoader. This change is for sharing class search paths
+ between Loader and CtClass.CtClass(String).
+
+ <li>CtClass.addField(), addMethod(), addConstructor(), addWrapper() were
+ also largely modified so that it receives CtNewMethod, CtNewConstructor,
+ or CtNewField. The static methods for creating these objects were
+ added to the API.
+
+ <li>Constructors are now represented by CtConstructor objects.
+ CtConstructor is a subclass of CtMethod.
+
+ <li>CtClass.getUserAttribute() was removed. Use CtClass.getAttribute().
+
+ <li>javassist.rmi.RmiLoader was added.
+
+ <li>javassist.reflect.Metalevel._setMetaobject() was added. Now
+ metaobjects can be replaced at runtime.
+</ul>
+
+<p>- version 0.6
+<ul>
+ <li>Javassist was modified to correctly deal with array types appearing
+ in signatures.
+
+ <li>A bug crashed resulting bytecode if a class includes a private static
+ filed. It has been fixed.
+
+ <li>javassist.CtNewInterface was added.
+
+ <li>javassist.Loader.recordClass() was renamed into makeClass().
+
+ <li>javassist.UserLoader.loadClass() was changed to take the second
+ parameter.
+</ul>
+
+<p>- version 0.5
+<ul>
+ <li>a bug-fix version.
+</ul>
+
+<p>- version 0.4
+<ul>
+ <li>Major update again. Many classes and methods were changed.
+ Most of methods taking java.lang.Class have been changed to
+ take javassist.CtClass.
+</ul>
+
+<p>- version 0.3
+<ul>
+ <li>Major update. Many classes and methods were changed.
+</ul>
+
+<p>- version 0.2
+<ul>
+ <li>Jar/zip files are supported.
+</ul>
+
+<p>-version 0.1 on April 16, 1999.
+<ul>
+ <li>The first release.
+</ul>
+
+<p><br>
+
+<h2>Bug reports etc.</h2>
+
+<dl>
+<dt>Bug reports:
+<dd>Post your reports at <a href="http://www.jboss.org/jive.jsp">Forums</a>
+or directly send an email to:
+<br>
+<tt><a href="mailto:chiba@acm.org">chiba@acm.org</a></tt>
+or
+<tt><a href="mailto:chiba@is.titech.ac.jp">chiba@is.titech.ac.jp</a></tt>
+<br>
+
+<p><dt>The home page of Javassist:
+<dd>Visit <a href="http://www.javassist.org"><tt>www.javassist.org</tt></a>
+and <a href="http://www.jboss.org/index.html?module=html&op=userdisplay&id=developers/projects/javassist"><tt>www.jboss.org</tt></a>
+
+</dl>
+
+<p><br>
+
+<a name="copyright">
+<h2>Copyright notices</h2>
+
+<p>Javassist, a Java-bytecode translator toolkit.
+<br>Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+
+<p>The contents of this software, Javassist, are subject to
+the Mozilla Public License Version 1.1 (the "License");<br>
+you may not use this software except in compliance
+with the License. You may obtain a copy of the License at
+<br>http://www.mozilla.org/MPL/
+
+<p>Software distributed under the License is distributed on an "AS IS"
+basis, WITHOUT WARRANTY OF <br>ANY KIND, either express or implied.
+See the License for the specific language governing rights and
+<br>limitations under the License.
+
+<p>The Original Code is Javassist.
+
+<p>The Initial Developer of the Original Code is Shigeru Chiba.
+Portions created by the Initial Developer are<br>
+Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+<p>Contributor(s): ______________________________________.
+
+<p>Alternatively, the contents of this software may be used under the
+terms of the GNU Lesser General Public License Version 2.1 or later
+(the "LGPL"), in which case the provisions of the LGPL are applicable
+instead of those above. If you wish to allow use of your version of
+this software only under the terms of the LGPL, and not to allow others to
+use your version of this software under the terms of the MPL, indicate
+your decision by deleting the provisions above and replace them with
+the notice and other provisions required by the LGPL. If you do not
+delete the provisions above, a recipient may use your version of this
+software under the terms of either the MPL or the LGPL.
+
+<p>If you obtain this software as part of JBoss, the contents of this
+software may be used under only the terms of the LGPL. To use them
+under the MPL, you must obtain a separate package including only
+Javassist but not the other part of JBoss.
+
+<p>All the contributors to the original source tree must agree to
+the original license term described above.
+
+<p><br>
+
+<h2>Acknowledgments</h2>
+
+<p>The development of this software is sponsored in part by the PRESTO
+and CREST programs of <a href="http://www.jst.go.jp/">Japan
+Science and Technology Corporation</a>.
+
+<p>I'd like to thank Michiaki Tatsubori, Johan Cloetens,
+Philip Tomlinson, Alex Villazon, Pascal Rapicault, Dan HE, Eric Tanter,
+Michael Haupt, Toshiyuki Sasaki, Renaud Pawlak, Luc Bourlier,
+Eric Bui, Lewis Stiller, Susumu Yamazaki, Rodrigo Teruo Tomita,
+Marc Segura-Devillechaise, Jan Baudisch, Julien Blass, Yoshiki Sato,
+Fabian Crabus, Bo Norregaard Jorgensen, Bob Lee, Bill Burke,
+Remy Sanlaville, Muga Nishizawa, Alexey Loubyansky, Saori Oki,
+Andreas Salathe, Dante Torres estrada, S. Pam, Nuno Santos,
+Denis Taye, Colin Sampaleanu, Robert Bialek, Asato Shimotaki,
+Howard Lewis Ship, Richard Jones, Marjan Sterjev,
+Bruce McDonald, Mark Brennan, Vlad Skarzhevskyy,
+Brett Randall, Tsuyoshi Murakami, Nathan Meyers, Yoshiyuki Usui
+Yutaka Sunaga, Arjan van der Meer, Bruce Eckel, Guillaume Pothier,
+Kumar Matcha, Andreas Salathe, Renat Zubairov, Armin Haaf,
+Emmanuel Bernard
+and all other contributors for their contributions.
+
+<p><br>
+
+<hr>
+<a href="http://www.is.titech.ac.jp/~chiba">Shigeru Chiba</a>
+(Email: <tt>chiba@acm.org</tt>)
+<br>Dept. of Math. and Computing Sciences,
+<a href="http://www.titech.ac.jp">Tokyo Institute of Technology</a>
diff --git a/build.properties b/build.properties
new file mode 100644
index 0000000..42e774e
--- /dev/null
+++ b/build.properties
@@ -0,0 +1,4 @@
+# We only use junit, so we set the lib.dir to the junit out dir; this
+# works only on full builds that include master and in unix (though
+# you can change the path in your local repository).
+lib.dir=../../out/host/linux-x86/framework
diff --git a/build.xml b/build.xml
new file mode 100644
index 0000000..9d4c329
--- /dev/null
+++ b/build.xml
@@ -0,0 +1,298 @@
+<?xml version="1.0"?>
+
+<!-- =================================================================== -->
+<!-- JBoss build file -->
+<!-- =================================================================== -->
+
+<project name="javassist" default="jar" basedir=".">
+
+ <property name="dist-version" value="javassist-3.14.0-GA"/>
+
+ <property environment="env"/>
+ <property name="target.jar" value="javassist.jar"/>
+ <property name="target-src.jar" value="javassist-src.jar"/>
+ <property name="lib.dir" value="${basedir}/lib"/>
+ <property name="src.dir" value="${basedir}/src/main"/>
+ <property name="build.dir" value="${basedir}/build"/>
+ <property name="build.classes.dir" value="${build.dir}/classes"/>
+ <property name="test.src.dir" value="${basedir}/src/test"/>
+ <property name="test.build.dir" value="${basedir}/build/test-classes"/>
+ <property name="test.reports.dir" value = "${basedir}/build/test-output"/>
+
+ <property name="run.dir" value="${build.classes.dir}"/>
+
+ <!-- Build classpath -->
+ <path id="classpath">
+ <pathelement location="${build.classes.dir}"/>
+ </path>
+
+ <property name="build.classpath" refid="classpath"/>
+
+ <path id="test.compile.classpath">
+ <pathelement location="${build.classes.dir}"/>
+ <pathelement location="${lib.dir}/junit.jar"/>
+ </path>
+
+ <property name="test.compile.classpath" refid="test.compile.classpath"/>
+
+ <path id="test.classpath">
+ <pathelement location="${test.build.dir}"/>
+ <pathelement location="${lib.dir}/junit.jar"/>
+ <pathelement location="${build.classes.dir}"/>
+ </path>
+
+ <property name="test.classpath" refid="test.classpath"/>
+
+ <!-- =================================================================== -->
+ <!-- Prepares the build directory -->
+ <!-- =================================================================== -->
+ <target name="prepare" >
+ <mkdir dir="${build.dir}"/>
+ <mkdir dir="${build.classes.dir}"/>
+ <mkdir dir="${test.build.dir}"/>
+ <mkdir dir="${test.reports.dir}"/>
+ </target>
+
+ <!-- =================================================================== -->
+ <!-- Compiles the source code -->
+ <!-- =================================================================== -->
+ <target name="compile" depends="prepare">
+ <javac srcdir="${src.dir}"
+ destdir="${build.classes.dir}"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="**">
+ <classpath refid="classpath"/>
+ </javac>
+ </target>
+
+ <target name="compile14" depends="prepare">
+ <javac srcdir="${src.dir}"
+ destdir="${build.classes.dir}"
+ debug="on"
+ deprecation="on"
+ source="1.4"
+ target="1.4"
+ optimize="off"
+ includes="**">
+ <classpath refid="classpath"/>
+ </javac>
+ </target>
+
+ <target name="test-compile" depends="compile">
+ <javac srcdir="${test.src.dir}"
+ destdir="${test.build.dir}"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="**">
+ <classpath refid="test.compile.classpath"/>
+ </javac>
+ </target>
+
+ <target name="test" depends="test-compile">
+ <junit fork="true" printsummary="true">
+ <classpath refid="test.classpath"/>
+ <formatter type="plain"/>
+ <formatter type="xml"/>
+ <batchtest todir="${test.reports.dir}">
+ <fileset dir="${test.build.dir}">
+ <include name="**/*Test.*"/>
+ </fileset>
+ </batchtest>
+ </junit>
+ </target>
+
+ <target name="sample" depends="compile">
+ <javac srcdir="${basedir}"
+ destdir="${build.classes.dir}"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="sample/**"
+ excludes="sample/hotswap/**,sample/evolve/sample/**">
+ <classpath refid="classpath"/>
+ </javac>
+
+ <copy file="sample/vector/Test.j"
+ todir="${build.classes.dir}/sample/vector"/>
+
+ <javac srcdir="${basedir}/sample/evolve"
+ destdir="${build.classes.dir}/sample/evolve/"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="sample/**">
+ <classpath refid="classpath"/>
+ </javac>
+ <copy todir="${build.classes.dir}/sample/evolve">
+ <fileset dir="sample/evolve"/>
+ </copy>
+ <copy file="${build.classes.dir}/sample/evolve/WebPage.class"
+ tofile="${build.classes.dir}/sample/evolve/WebPage.class.0"/>
+ <copy file="${build.classes.dir}/sample/evolve/sample/evolve/WebPage.class"
+ tofile="${build.classes.dir}/sample/evolve/WebPage.class.1"/>
+
+ <javac srcdir="${basedir}/sample/hotswap"
+ destdir="${build.classes.dir}"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="*">
+ <classpath refid="classpath"/>
+ </javac>
+ <mkdir dir="${build.classes.dir}/logging"/>
+ <javac srcdir="${basedir}/sample/hotswap/logging"
+ destdir="${build.classes.dir}/logging"
+ debug="on"
+ deprecation="on"
+ optimize="off"
+ includes="*">
+ <classpath refid="classpath"/>
+ </javac>
+ <echo>To run the sample programs without ant, change the current directory
+to ${build.classes.dir}.</echo>
+ </target>
+
+ <target name="jar" depends="compile14">
+ <jar jarfile="${target.jar}" manifest="${src.dir}/META-INF/MANIFEST.MF">
+ <fileset dir="${build.classes.dir}">
+ <include name="**/*.class"/>
+ </fileset>
+ </jar>
+ <jar jarfile="${target-src.jar}" manifest="${src.dir}/META-INF/MANIFEST.MF">
+ <fileset dir="${src.dir}">
+ <include name="javassist/**"/>
+ </fileset>
+ </jar>
+ </target>
+
+ <target name="javadocs">
+ <mkdir dir="html"/>
+ <javadoc
+ Locale="en_US"
+ packagenames="javassist.*"
+ excludepackagenames="javassist.compiler.*,javassist.convert.*,javassist.scopedpool.*,javassist.bytecode.stackmap.*"
+ sourcepath="src/main"
+ defaultexcludes="yes"
+ destdir="html"
+ author="true"
+ version="true"
+ use="true"
+ public="true"
+ nohelp="true"
+ windowtitle="Javassist API">
+ <doctitle><![CDATA[<h1>Javassist</h1>]]></doctitle>
+ <bottom><![CDATA[<i>Javassist, a Java-bytecode translator toolkit.<br>
+Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.</i>]]></bottom>
+ </javadoc>
+ </target>
+
+ <target name="dist" depends="jar,javadocs">
+ <delete file="${dist-version}.zip"/>
+ <zip zipfile="${dist-version}.zip">
+ <zipfileset dir="${basedir}" prefix="${dist-version}">
+ <include name="html/**"/>
+ <include name="sample/**"/>
+ <include name="src/main/**"/>
+ <include name="tutorial/**"/>
+ <include name="*.html"/>
+ <include name="*.xml"/>
+ <include name="${target.jar}"/>
+ </zipfileset>
+ </zip>
+ </target>
+
+ <target name="clean">
+ <delete dir="build"/>
+ <delete dir="html"/>
+ <delete file="${target.jar}"/>
+ <delete file="${dist-version}.zip"/>
+ </target>
+
+ <!-- =================================================================== -->
+ <!-- Run samples -->
+ <!-- =================================================================== -->
+
+ <target name = "sample-all"
+ depends="sample-test,sample-reflect,sample-duplicate,sample-vector">
+ <echo>** please run sample-rmi, sample-evolve, and</echo>
+ <echo> sample-hotswap (or -hotswap5) separately **</echo>
+ </target>
+
+ <target name = "sample-test" depends="sample" >
+ <java fork="true" dir="${run.dir}" classname="sample.Test">
+ <classpath refid="classpath"/>
+ </java>
+ </target>
+
+ <target name = "sample-reflect" depends="sample" >
+ <java fork="true" dir="${run.dir}" classname="javassist.tools.reflect.Loader">
+ <classpath refid="classpath"/>
+ <arg line="sample.reflect.Main Joe" />
+ </java>
+ </target>
+
+ <target name = "sample-duplicate" depends="sample" >
+ <echo>run sample.duplicate.Viewer without reflection</echo>
+ <java fork="true" dir="${run.dir}" classname="sample.duplicate.Viewer">
+ <classpath refid="classpath"/>
+ </java>
+ <echo>run sample.duplicate.Viewer with reflection</echo>
+ <java fork="true" dir="${run.dir}" classname="sample.duplicate.Main">
+ <classpath refid="classpath"/>
+ </java>
+ </target>
+
+ <target name = "sample-vector" depends="sample" >
+ <echo>sample.preproc.Compiler sample/vector/Test.j</echo>
+ <java fork="true" dir="${run.dir}" classname="sample.preproc.Compiler">
+ <classpath refid="classpath"/>
+ <arg line="sample/vector/Test.j"/>
+ </java>
+ <echo>javac sample/vector/Test.java</echo>
+ <javac srcdir="${build.classes.dir}"
+ destdir="${build.classes.dir}"
+ includes="sample/vector/Test.java">
+ <classpath refid="classpath"/>
+ </javac>
+ <java fork="true" dir="${run.dir}" classname="sample.vector.Test" />
+ </target>
+
+ <target name = "sample-rmi" depends="sample" >
+ <echo>** Please open sample/rmi/webdemo.html with your browser **</echo>
+ <java fork="true" dir="${run.dir}" classname="sample.rmi.Counter">
+ <classpath refid="classpath"/>
+ <arg value="5001" />
+ </java>
+ </target>
+
+ <target name = "sample-evolve" depends="sample" >
+ <echo>** Please open http://localhost:5003/demo.html with your browser **</echo>
+ <java fork="true" dir="${run.dir}" classname="sample.evolve.DemoLoader">
+ <classpath refid="classpath"/>
+ <arg value="5003" />
+ </java>
+ </target>
+
+ <!-- for JDK 1.4 -->
+ <target name = "sample-hotswap" depends="sample">
+ <echo>** JAVA_HOME/lib/tools.jar must be included in CLASS_PATH</echo>
+ <echo>** for JDK 1.4</echo>
+ <java fork="true" dir="${run.dir}" classname="Test">
+ <jvmarg line="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000" />
+ <classpath refid="classpath"/>
+ </java>
+ </target>
+
+ <!-- for Java 5 -->
+ <target name = "sample-hotswap5" depends="sample">
+ <echo>** JAVA_HOME/lib/tools.jar must be included in CLASS_PATH</echo>
+ <echo>** for JDK 1.5 or later</echo>
+ <java fork="true" dir="${run.dir}" classname="Test">
+ <jvmarg line="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000" />
+ <classpath refid="classpath"/>
+ </java>
+ </target>
+</project>
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..0b8c335
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,262 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+ <groupId>org.javassist</groupId>
+ <artifactId>javassist</artifactId>
+ <packaging>jar</packaging>
+ <description>Javassist (JAVA programming ASSISTant) makes Java bytecode manipulation
+ simple. It is a class library for editing bytecodes in Java.
+ </description>
+ <version>3.14.0-GA</version>
+ <name>Javassist</name>
+ <url>http://www.javassist.org/</url>
+
+ <issueManagement>
+ <system>JIRA</system>
+ <url>https://jira.jboss.org/jira/browse/JASSIST/</url>
+ </issueManagement>
+ <licenses>
+ <!-- this is the license under which javassist is usually distributed
+ -->
+ <license>
+ <name>MPL 1.1</name>
+ <url>http://www.mozilla.org/MPL/MPL-1.1.html</url>
+ </license>
+ <!-- this is the license under which javassist is distributed when
+ it is bundled with JBoss
+ -->
+ <license>
+ <name>LGPL 2.1</name>
+ <url>http://www.gnu.org/licenses/lgpl-2.1.html</url>
+ </license>
+ </licenses>
+
+ <scm>
+ <connection>scm:svn:http://anonsvn.jboss.org/repos/javassist/</connection>
+ <developerConnection>scm:svn:https://svn.jboss.org/repos/javassist/</developerConnection>
+ <url>http://fisheye.jboss.org/browse/javassist/</url>
+ </scm>
+
+ <developers>
+ <developer>
+ <id>chiba</id>
+ <name>Shigeru Chiba</name>
+ <email>chiba@acm.org</email>
+ <organization>Tokyo Institute of Technology</organization>
+ <organizationUrl>http://www.javassist.org/</organizationUrl>
+ <roles>
+ <role>project lead</role>
+ </roles>
+ <timezone>8</timezone>
+ </developer>
+
+ <developer>
+ <id>adinn</id>
+ <name>Andrew Dinn</name>
+ <email>adinn@redhat.com</email>
+ <organization>JBoss</organization>
+ <organizationUrl>http://www.jboss.org/</organizationUrl>
+ <roles>
+ <role>contributing developer</role>
+ </roles>
+ <timezone>0</timezone>
+ </developer>
+
+ <developer>
+ <id>kabir.khan@jboss.com</id>
+ <name>Kabir Khan</name>
+ <email>kabir.khan@jboss.com</email>
+ <organization>JBoss</organization>
+ <organizationUrl>http://www.jboss.org/</organizationUrl>
+ <roles>
+ <role>contributing developer</role>
+ </roles>
+ <timezone>0</timezone>
+ </developer>
+ </developers>
+
+ <distributionManagement>
+ <!--
+ You need entries in your .m2/settings.xml like this:
+ <servers>
+ <server>
+ <id>jboss-releases-repository</id>
+ <username>your_jboss.org_username</username>
+ <password>password</password>
+ </server>
+ <server>
+ <id>jboss-snapshots-repository</id>
+ <username>your_jboss.org_username</username>
+ <password>password</password>
+ </server>
+ </servers>
+
+ To deploy a snapshot, you need to run
+
+ mvn deploy -Dversion=3.x.y-SNAPSHOT
+
+ To deploy a release you need to change the version to 3.x.y.GA and run
+
+ mvn deploy
+ -->
+ <repository>
+ <id>jboss-releases-repository</id>
+ <name>JBoss Releases Repository</name>
+ <url>https://repository.jboss.org/nexus/service/local/staging/deploy/maven2/</url>
+ </repository>
+ <snapshotRepository>
+ <id>jboss-snapshots-repository</id>
+ <name>JBoss Snapshots Repository</name>
+ <url>https://repository.jboss.org/nexus/content/repositories/snapshots/</url>
+ </snapshotRepository>
+ </distributionManagement>
+ <build>
+ <sourceDirectory>src/main/</sourceDirectory>
+ <testSourceDirectory>src/test/</testSourceDirectory>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ <configuration>
+ <source>1.4</source>
+ <target>1.4</target>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-jar-plugin</artifactId>
+ <configuration>
+ <archive>
+ <manifestFile>${project.build.sourceDirectory}/META-INF/MANIFEST.MF</manifestFile>
+ </archive>
+ </configuration>
+ </plugin>
+ <plugin>
+ <artifactId>maven-source-plugin</artifactId>
+ <version>2.0.3</version>
+ <executions>
+ <execution>
+ <id>attach-sources</id>
+ <goals>
+ <goal>jar</goal>
+ </goals>
+ </execution>
+ </executions>
+ <inherited>true</inherited>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-javadoc-plugin</artifactId>
+ <version>2.7</version>
+ <configuration>
+ <attach>true</attach>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+ <profiles>
+ <!-- profile for releasing to sonatype repo
+ exercise with mvn -PcentralRelease
+ -->
+ <profile>
+ <id>centralRelease</id>
+ <!-- obviously we need to use the Sonatype staging repo for upload -->
+ <distributionManagement>
+ <repository>
+ <id>sonatype-releases-repository</id>
+ <name>Sonatype Releases Repository</name>
+ <url>https://oss.sonatype.org/service/local/staging/deploy/maven2</url>
+ </repository>
+ </distributionManagement>
+ <!-- we need to be able to sign the jars we install -->
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-gpg-plugin</artifactId>
+ <configuration>
+ <passphrase>${gpg.passphrase}</passphrase>
+ <useAgent>${gpg.useAgent}</useAgent>
+ </configuration>
+ <executions>
+ <execution>
+ <id>sign-artifacts</id>
+ <phase>verify</phase>
+ <goals>
+ <goal>sign</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+ </profile>
+ <!-- profiles to add tools jar containing com.sun.jdi code
+ needed by sample code
+ -->
+ <profile>
+ <id>jdk14</id>
+ <activation>
+ <jdk>1.4</jdk>
+ <property>
+ <name>!no.tools</name>
+ </property>
+ </activation>
+ <dependencies>
+ <dependency>
+ <groupId>com.sun</groupId>
+ <artifactId>tools</artifactId>
+ <version>1.4</version>
+ <scope>system</scope>
+ <optional>true</optional>
+ <systemPath>${java.home}/../lib/tools.jar</systemPath>
+ </dependency>
+ </dependencies>
+ </profile>
+ <profile>
+ <id>jdk15</id>
+ <activation>
+ <jdk>1.5</jdk>
+ <property>
+ <name>!no.tools</name>
+ </property>
+ </activation>
+ <dependencies>
+ <dependency>
+ <groupId>com.sun</groupId>
+ <artifactId>tools</artifactId>
+ <version>1.5</version>
+ <scope>system</scope>
+ <optional>true</optional>
+ <systemPath>${java.home}/../lib/tools.jar</systemPath>
+ </dependency>
+ </dependencies>
+ </profile>
+ <profile>
+ <id>jdk16</id>
+ <activation>
+ <jdk>1.6</jdk>
+ <property>
+ <name>!no.tools</name>
+ </property>
+ </activation>
+ <dependencies>
+ <dependency>
+ <groupId>com.sun</groupId>
+ <artifactId>tools</artifactId>
+ <version>1.6</version>
+ <scope>system</scope>
+ <optional>true</optional>
+ <systemPath>${java.home}/../lib/tools.jar</systemPath>
+ </dependency>
+ </dependencies>
+ </profile>
+ </profiles>
+ <dependencies>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <version>3.8.1</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+</project>
diff --git a/regenerate_from_source.sh b/regenerate_from_source.sh
new file mode 100644
index 0000000..2f744e1
--- /dev/null
+++ b/regenerate_from_source.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+#
+# Copyright (C) 2011 The Android Open Source Project.
+# This script imports the src, test, etc. from javassist. It DOESN'T commit
+# to git giving you a chance to review the changes. Remember that changes in
+# bin are normally ignored by git, but we need to force them this case.
+#
+# This script doesn't take any parameter.
+
+svn export --force http://anonsvn.jboss.org/repos/javassist/trunk .
+rm lib/junit.jar
+# I don't check if there is something on lib on purpose; that way, if
+# anything new is added, we will get a visible error.
+rmdir lib
diff --git a/sample/Test.java b/sample/Test.java
new file mode 100644
index 0000000..1e2b49c
--- /dev/null
+++ b/sample/Test.java
@@ -0,0 +1,44 @@
+package sample;
+
+import javassist.*;
+
+/*
+ A very simple sample program
+
+ This program overwrites sample/Test.class (the class file of this
+ class itself) for adding a method g(). If the method g() is not
+ defined in class Test, then this program adds a copy of
+ f() to the class Test with name g(). Otherwise, this program does
+ not modify sample/Test.class at all.
+
+ To see the modified class definition, execute:
+
+ % javap sample.Test
+
+ after running this program.
+*/
+public class Test {
+ public int f(int i) {
+ return i + 1;
+ }
+
+ public static void main(String[] args) throws Exception {
+ ClassPool pool = ClassPool.getDefault();
+
+ CtClass cc = pool.get("sample.Test");
+ try {
+ cc.getDeclaredMethod("g");
+ System.out.println("g() is already defined in sample.Test.");
+ }
+ catch (NotFoundException e) {
+ /* getDeclaredMethod() throws an exception if g()
+ * is not defined in sample.Test.
+ */
+ CtMethod fMethod = cc.getDeclaredMethod("f");
+ CtMethod gMethod = CtNewMethod.copy(fMethod, "g", cc, null);
+ cc.addMethod(gMethod);
+ cc.writeFile(); // update the class file
+ System.out.println("g() was added.");
+ }
+ }
+}
diff --git a/sample/duplicate/Ball.java b/sample/duplicate/Ball.java
new file mode 100644
index 0000000..21d6e1c
--- /dev/null
+++ b/sample/duplicate/Ball.java
@@ -0,0 +1,44 @@
+package sample.duplicate;
+
+import java.awt.Graphics;
+import java.awt.Color;
+
+public class Ball {
+ private int x, y;
+ private Color color;
+ private int radius = 30;
+ private boolean isBackup = false;
+
+ public Ball(int x, int y) {
+ move(x, y);
+ changeColor(Color.orange);
+ }
+
+ // This constructor is for a backup object.
+ public Ball(Ball b) {
+ isBackup = true;
+ }
+
+ // Adjust the position so that the backup object is visible.
+ private void adjust() {
+ if (isBackup) {
+ this.x += 50;
+ this.y += 50;
+ }
+ }
+
+ public void paint(Graphics g) {
+ g.setColor(color);
+ g.fillOval(x, y, radius, radius);
+ }
+
+ public void move(int x, int y) {
+ this.x = x;
+ this.y = y;
+ adjust();
+ }
+
+ public void changeColor(Color color) {
+ this.color = color;
+ }
+}
diff --git a/sample/duplicate/DuplicatedObject.java b/sample/duplicate/DuplicatedObject.java
new file mode 100644
index 0000000..7161493
--- /dev/null
+++ b/sample/duplicate/DuplicatedObject.java
@@ -0,0 +1,38 @@
+package sample.duplicate;
+
+import javassist.tools.reflect.*;
+
+public class DuplicatedObject extends Metaobject {
+ private DuplicatedObject backup;
+
+ // if a base-level object is created, this metaobject creates
+ // a copy of the base-level object.
+
+ public DuplicatedObject(Object self, Object[] args) {
+ super(self, args);
+ ClassMetaobject clazz = getClassMetaobject();
+ if (clazz.isInstance(args[0]))
+ backup = null; // self is a backup object.
+ else {
+ Object[] args2 = new Object[1];
+ args2[0] = self;
+ try {
+ Metalevel m = (Metalevel)clazz.newInstance(args2);
+ backup = (DuplicatedObject)m._getMetaobject();
+ }
+ catch (CannotCreateException e) {
+ backup = null;
+ }
+ }
+ }
+
+ public Object trapMethodcall(int identifier, Object[] args)
+ throws Throwable
+ {
+ Object obj = super.trapMethodcall(identifier, args);
+ if (backup != null)
+ backup.trapMethodcall(identifier, args);
+
+ return obj;
+ }
+}
diff --git a/sample/duplicate/Main.java b/sample/duplicate/Main.java
new file mode 100644
index 0000000..064f13c
--- /dev/null
+++ b/sample/duplicate/Main.java
@@ -0,0 +1,44 @@
+package sample.duplicate;
+
+/*
+ Runtime metaobject (JDK 1.2 or later only).
+
+ With the javassist.tools.reflect package, the users can attach a metaobject
+ to an object. The metaobject can control the behavior of the object.
+ For example, you can implement fault tolerancy with this ability. One
+ of the implementation techniques of fault tolernacy is to make a copy
+ of every object containing important data and maintain it as a backup.
+ If the machine running the object becomes down, the backup object on a
+ different machine is used to continue the execution.
+
+ To make the copy of the object a real backup, all the method calls to
+ the object must be also sent to that copy. The metaobject is needed
+ for this duplication of the method calls. It traps every method call
+ and invoke the same method on the copy of the object so that the
+ internal state of the copy is kept equivalent to that of the original
+ object.
+
+ First, run sample.duplicate.Viewer without a metaobject.
+
+ % java sample.duplicate.Viewer
+
+ This program shows a ball in a window.
+
+ Then, run the same program with a metaobject, which is an instance
+ of sample.duplicate.DuplicatedObject.
+
+ % java sample.duplicate.Main
+
+ You would see two balls in a window. This is because
+ sample.duplicate.Viewer is loaded by javassist.tools.reflect.Loader so that
+ a metaobject would be attached.
+*/
+public class Main {
+ public static void main(String[] args) throws Throwable {
+ javassist.tools.reflect.Loader cl = new javassist.tools.reflect.Loader();
+ cl.makeReflective("sample.duplicate.Ball",
+ "sample.duplicate.DuplicatedObject",
+ "javassist.tools.reflect.ClassMetaobject");
+ cl.run("sample.duplicate.Viewer", args);
+ }
+}
diff --git a/sample/duplicate/Viewer.java b/sample/duplicate/Viewer.java
new file mode 100644
index 0000000..aec13f6
--- /dev/null
+++ b/sample/duplicate/Viewer.java
@@ -0,0 +1,78 @@
+package sample.duplicate;
+
+import java.applet.*;
+import java.awt.*;
+import java.awt.event.*;
+
+public class Viewer extends Applet
+ implements MouseListener, ActionListener, WindowListener
+{
+ private static final Color[] colorList = {
+ Color.orange, Color.pink, Color.green, Color.blue };
+
+ private Ball ball;
+ private int colorNo;
+
+ public void init() {
+ colorNo = 0;
+ Button b = new Button("change");
+ b.addActionListener(this);
+ add(b);
+
+ addMouseListener(this);
+ }
+
+ public void start() {
+ ball = new Ball(50, 50);
+ ball.changeColor(colorList[0]);
+ }
+
+ public void paint(Graphics g) {
+ ball.paint(g);
+ }
+
+ public void mouseClicked(MouseEvent ev) {
+ ball.move(ev.getX(), ev.getY());
+ repaint();
+ }
+
+ public void mouseEntered(MouseEvent ev) {}
+
+ public void mouseExited(MouseEvent ev) {}
+
+ public void mousePressed(MouseEvent ev) {}
+
+ public void mouseReleased(MouseEvent ev) {}
+
+ public void actionPerformed(ActionEvent e) {
+ ball.changeColor(colorList[++colorNo % colorList.length]);
+ repaint();
+ }
+
+ public void windowOpened(WindowEvent e) {}
+
+ public void windowClosing(WindowEvent e) {
+ System.exit(0);
+ }
+
+ public void windowClosed(WindowEvent e) {}
+
+ public void windowIconified(WindowEvent e) {}
+
+ public void windowDeiconified(WindowEvent e) {}
+
+ public void windowActivated(WindowEvent e) {}
+
+ public void windowDeactivated(WindowEvent e) {}
+
+ public static void main(String[] args) {
+ Frame f = new Frame("Viewer");
+ Viewer view = new Viewer();
+ f.addWindowListener(view);
+ f.add(view);
+ f.setSize(300, 300);
+ view.init();
+ view.start();
+ f.setVisible(true);
+ }
+}
diff --git a/sample/evolve/CannotCreateException.java b/sample/evolve/CannotCreateException.java
new file mode 100644
index 0000000..828afb0
--- /dev/null
+++ b/sample/evolve/CannotCreateException.java
@@ -0,0 +1,14 @@
+package sample.evolve;
+
+/**
+ * Signals that VersionManager.newInstance() fails.
+ */
+public class CannotCreateException extends RuntimeException {
+ public CannotCreateException(String s) {
+ super(s);
+ }
+
+ public CannotCreateException(Exception e) {
+ super("by " + e.toString());
+ }
+}
diff --git a/sample/evolve/CannotUpdateException.java b/sample/evolve/CannotUpdateException.java
new file mode 100644
index 0000000..bd28bba
--- /dev/null
+++ b/sample/evolve/CannotUpdateException.java
@@ -0,0 +1,14 @@
+package sample.evolve;
+
+/**
+ * Signals that VersionManager.update() fails.
+ */
+public class CannotUpdateException extends Exception {
+ public CannotUpdateException(String msg) {
+ super(msg);
+ }
+
+ public CannotUpdateException(Exception e) {
+ super("by " + e.toString());
+ }
+}
diff --git a/sample/evolve/DemoLoader.java b/sample/evolve/DemoLoader.java
new file mode 100644
index 0000000..7c770bd
--- /dev/null
+++ b/sample/evolve/DemoLoader.java
@@ -0,0 +1,38 @@
+package sample.evolve;
+
+import javassist.*;
+
+/**
+ * DemoLoader is a class loader for running a program including
+ * an updatable class. This simple loader allows only a single
+ * class to be updatable. (Extending it for supporting multiple
+ * updatable classes is easy.)
+ *
+ * To run, type as follows:
+ *
+ * % java sample.evolve.DemoLoader <port number>
+ *
+ * Then DemoLoader launches sample.evolve.DemoServer with <port number>.
+ * It also translates sample.evolve.WebPage, which sample.evolve.DemoServer
+ * uses, so that it is an updable class.
+ *
+ * Note: JDK 1.2 or later only.
+ */
+public class DemoLoader {
+ private static final int initialVersion = 0;
+ private String updatableClassName = null;
+ private CtClass updatableClass = null;
+
+ /* Creates a <code>DemoLoader</code> for making class WebPage
+ * updatable. Then it runs main() in sample.evolve.DemoServer.
+ */
+ public static void main(String[] args) throws Throwable {
+ Evolution translator = new Evolution();
+ ClassPool cp = ClassPool.getDefault();
+ Loader cl = new Loader();
+ cl.addTranslator(cp, translator);
+
+ translator.makeUpdatable("sample.evolve.WebPage");
+ cl.run("sample.evolve.DemoServer", args);
+ }
+}
diff --git a/sample/evolve/DemoServer.java b/sample/evolve/DemoServer.java
new file mode 100644
index 0000000..b334bcc
--- /dev/null
+++ b/sample/evolve/DemoServer.java
@@ -0,0 +1,102 @@
+package sample.evolve;
+
+import javassist.tools.web.*;
+import java.io.*;
+
+/**
+ * A web server for demonstrating class evolution. It must be
+ * run with a DemoLoader.
+ *
+ * If a html file /java.html is requested, this web server calls
+ * WebPage.show() for constructing the contents of that html file
+ * So if a DemoLoader changes the definition of WebPage, then
+ * the image of /java.html is also changed.
+ * Note that WebPage is not an applet. It is rather
+ * similar to a CGI script or a servlet. The web server never
+ * sends the class file of WebPage to web browsers.
+ *
+ * Furthermore, if a html file /update.html is requested, this web
+ * server overwrites WebPage.class (class file) and calls update()
+ * in VersionManager so that WebPage.class is loaded into the JVM
+ * again. The new contents of WebPage.class are copied from
+ * either sample/evolve/WebPage.class
+ * or sample/evolve/sample/evolve/WebPage.class.
+ */
+public class DemoServer extends Webserver {
+
+ public static void main(String[] args) throws IOException
+ {
+ if (args.length == 1) {
+ DemoServer web = new DemoServer(Integer.parseInt(args[0]));
+ web.run();
+ }
+ else
+ System.err.println(
+ "Usage: java sample.evolve.DemoServer <port number>");
+ }
+
+ public DemoServer(int port) throws IOException {
+ super(port);
+ htmlfileBase = "sample/evolve/";
+ }
+
+ private static final String ver0 = "sample/evolve/WebPage.class.0";
+ private static final String ver1 = "sample/evolve/WebPage.class.1";
+ private String currentVersion = ver0;
+
+ public void doReply(InputStream in, OutputStream out, String cmd)
+ throws IOException, BadHttpRequest
+ {
+ if (cmd.startsWith("GET /java.html ")) {
+ runJava(out);
+ return;
+ }
+ else if (cmd.startsWith("GET /update.html ")) {
+ try {
+ if (currentVersion == ver0)
+ currentVersion = ver1;
+ else
+ currentVersion = ver0;
+
+ updateClassfile(currentVersion);
+ VersionManager.update("sample.evolve.WebPage");
+ }
+ catch (CannotUpdateException e) {
+ logging(e.toString());
+ }
+ catch (FileNotFoundException e) {
+ logging(e.toString());
+ }
+ }
+
+ super.doReply(in, out, cmd);
+ }
+
+ private void runJava(OutputStream outs) throws IOException {
+ OutputStreamWriter out = new OutputStreamWriter(outs);
+ out.write("HTTP/1.0 200 OK\r\n\r\n");
+ WebPage page = new WebPage();
+ page.show(out);
+ out.close();
+ }
+
+ /* updateClassfile() copies the specified file to WebPage.class.
+ */
+ private void updateClassfile(String filename)
+ throws IOException, FileNotFoundException
+ {
+ byte[] buf = new byte[1024];
+
+ FileInputStream fin
+ = new FileInputStream(filename);
+ FileOutputStream fout
+ = new FileOutputStream("sample/evolve/WebPage.class");
+ for (;;) {
+ int len = fin.read(buf);
+ if (len >= 0)
+ fout.write(buf, 0, len);
+ else
+ break;
+ }
+ }
+}
diff --git a/sample/evolve/Evolution.java b/sample/evolve/Evolution.java
new file mode 100644
index 0000000..e804ff4
--- /dev/null
+++ b/sample/evolve/Evolution.java
@@ -0,0 +1,189 @@
+package sample.evolve;
+
+import javassist.*;
+
+/**
+ * Evolution provides a set of methods for instrumenting bytecodes.
+ *
+ * For class evolution, updatable class A is renamed to B. Then an abstract
+ * class named A is produced as the super class of B. If the original class A
+ * has a public method m(), then the abstract class A has an abstract method
+ * m().
+ *
+ * abstract class A abstract m() _makeInstance() | class A --------> class B m()
+ * m()
+ *
+ * Also, all the other classes are translated so that "new A(i)" in the methods
+ * is replaced with "_makeInstance(i)". This makes it possible to change the
+ * behavior of the instantiation of the class A.
+ */
+public class Evolution implements Translator {
+ public final static String handlerMethod = "_makeInstance";
+
+ public final static String latestVersionField = VersionManager.latestVersionField;
+
+ public final static String versionManagerMethod = "initialVersion";
+
+ private static CtMethod trapMethod;
+
+ private static final int initialVersion = 0;
+
+ private ClassPool pool;
+
+ private String updatableClassName = null;
+
+ private CtClass updatableClass = null;
+
+ public void start(ClassPool _pool) throws NotFoundException {
+ pool = _pool;
+
+ // Get the definition of Sample.make() and store it into trapMethod
+ // for later use.
+ trapMethod = _pool.getMethod("sample.evolve.Sample", "make");
+ }
+
+ public void onLoad(ClassPool _pool, String classname)
+ throws NotFoundException, CannotCompileException {
+ onLoadUpdatable(classname);
+
+ /*
+ * Replaces all the occurrences of the new operator with a call to
+ * _makeInstance().
+ */
+ CtClass clazz = _pool.get(classname);
+ CtClass absClass = updatableClass;
+ CodeConverter converter = new CodeConverter();
+ converter.replaceNew(absClass, absClass, handlerMethod);
+ clazz.instrument(converter);
+ }
+
+ private void onLoadUpdatable(String classname) throws NotFoundException,
+ CannotCompileException {
+ // if the class is a concrete class,
+ // classname is <updatableClassName>$$<version>.
+
+ int i = classname.lastIndexOf("$$");
+ if (i <= 0)
+ return;
+
+ String orgname = classname.substring(0, i);
+ if (!orgname.equals(updatableClassName))
+ return;
+
+ int version;
+ try {
+ version = Integer.parseInt(classname.substring(i + 2));
+ }
+ catch (NumberFormatException e) {
+ throw new NotFoundException(classname, e);
+ }
+
+ CtClass clazz = pool.getAndRename(orgname, classname);
+ makeConcreteClass(clazz, updatableClass, version);
+ }
+
+ /*
+ * Register an updatable class.
+ */
+ public void makeUpdatable(String classname) throws NotFoundException,
+ CannotCompileException {
+ if (pool == null)
+ throw new RuntimeException(
+ "Evolution has not been linked to ClassPool.");
+
+ CtClass c = pool.get(classname);
+ updatableClassName = classname;
+ updatableClass = makeAbstractClass(c);
+ }
+
+ /**
+ * Produces an abstract class.
+ */
+ protected CtClass makeAbstractClass(CtClass clazz)
+ throws CannotCompileException, NotFoundException {
+ int i;
+
+ CtClass absClass = pool.makeClass(clazz.getName());
+ absClass.setModifiers(Modifier.PUBLIC | Modifier.ABSTRACT);
+ absClass.setSuperclass(clazz.getSuperclass());
+ absClass.setInterfaces(clazz.getInterfaces());
+
+ // absClass.inheritAllConstructors();
+
+ CtField fld = new CtField(pool.get("java.lang.Class"),
+ latestVersionField, absClass);
+ fld.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
+
+ CtField.Initializer finit = CtField.Initializer.byCall(pool
+ .get("sample.evolve.VersionManager"), versionManagerMethod,
+ new String[] { clazz.getName() });
+ absClass.addField(fld, finit);
+
+ CtField[] fs = clazz.getDeclaredFields();
+ for (i = 0; i < fs.length; ++i) {
+ CtField f = fs[i];
+ if (Modifier.isPublic(f.getModifiers()))
+ absClass.addField(new CtField(f.getType(), f.getName(),
+ absClass));
+ }
+
+ CtConstructor[] cs = clazz.getDeclaredConstructors();
+ for (i = 0; i < cs.length; ++i) {
+ CtConstructor c = cs[i];
+ int mod = c.getModifiers();
+ if (Modifier.isPublic(mod)) {
+ CtMethod wm = CtNewMethod.wrapped(absClass, handlerMethod, c
+ .getParameterTypes(), c.getExceptionTypes(),
+ trapMethod, null, absClass);
+ wm.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
+ absClass.addMethod(wm);
+ }
+ }
+
+ CtMethod[] ms = clazz.getDeclaredMethods();
+ for (i = 0; i < ms.length; ++i) {
+ CtMethod m = ms[i];
+ int mod = m.getModifiers();
+ if (Modifier.isPublic(mod))
+ if (Modifier.isStatic(mod))
+ throw new CannotCompileException(
+ "static methods are not supported.");
+ else {
+ CtMethod m2 = CtNewMethod.abstractMethod(m.getReturnType(),
+ m.getName(), m.getParameterTypes(), m
+ .getExceptionTypes(), absClass);
+ absClass.addMethod(m2);
+ }
+ }
+
+ return absClass;
+ }
+
+ /**
+ * Modifies the given class file so that it is a subclass of the abstract
+ * class produced by makeAbstractClass().
+ *
+ * Note: the naming convention must be consistent with
+ * VersionManager.update().
+ */
+ protected void makeConcreteClass(CtClass clazz, CtClass abstractClass,
+ int version) throws CannotCompileException, NotFoundException {
+ int i;
+ clazz.setSuperclass(abstractClass);
+ CodeConverter converter = new CodeConverter();
+ CtField[] fs = clazz.getDeclaredFields();
+ for (i = 0; i < fs.length; ++i) {
+ CtField f = fs[i];
+ if (Modifier.isPublic(f.getModifiers()))
+ converter.redirectFieldAccess(f, abstractClass, f.getName());
+ }
+
+ CtConstructor[] cs = clazz.getDeclaredConstructors();
+ for (i = 0; i < cs.length; ++i)
+ cs[i].instrument(converter);
+
+ CtMethod[] ms = clazz.getDeclaredMethods();
+ for (i = 0; i < ms.length; ++i)
+ ms[i].instrument(converter);
+ }
+}
diff --git a/sample/evolve/Sample.java b/sample/evolve/Sample.java
new file mode 100644
index 0000000..c147c96
--- /dev/null
+++ b/sample/evolve/Sample.java
@@ -0,0 +1,12 @@
+package sample.evolve;
+
+/**
+ * This is a sample class used by Transformer.
+ */
+public class Sample {
+ public static Class _version;
+
+ public static Object make(Object[] args) {
+ return VersionManager.make(_version, args);
+ }
+}
diff --git a/sample/evolve/VersionManager.java b/sample/evolve/VersionManager.java
new file mode 100644
index 0000000..efecee1
--- /dev/null
+++ b/sample/evolve/VersionManager.java
@@ -0,0 +1,90 @@
+package sample.evolve;
+
+import java.util.Hashtable;
+import java.lang.reflect.*;
+
+/**
+ * Runtime system for class evolution
+ */
+public class VersionManager {
+ private static Hashtable versionNo = new Hashtable();
+
+ public final static String latestVersionField = "_version";
+
+ /**
+ * For updating the definition of class my.X, say:
+ *
+ * VersionManager.update("my.X");
+ */
+ public static void update(String qualifiedClassname)
+ throws CannotUpdateException {
+ try {
+ Class c = getUpdatedClass(qualifiedClassname);
+ Field f = c.getField(latestVersionField);
+ f.set(null, c);
+ }
+ catch (ClassNotFoundException e) {
+ throw new CannotUpdateException("cannot update class: "
+ + qualifiedClassname);
+ }
+ catch (Exception e) {
+ throw new CannotUpdateException(e);
+ }
+ }
+
+ private static Class getUpdatedClass(String qualifiedClassname)
+ throws ClassNotFoundException {
+ int version;
+ Object found = versionNo.get(qualifiedClassname);
+ if (found == null)
+ version = 0;
+ else
+ version = ((Integer)found).intValue() + 1;
+
+ Class c = Class.forName(qualifiedClassname + "$$" + version);
+ versionNo.put(qualifiedClassname, new Integer(version));
+ return c;
+ }
+
+ /*
+ * initiaVersion() is used to initialize the _version field of the updatable
+ * classes.
+ */
+ public static Class initialVersion(String[] params) {
+ try {
+ return getUpdatedClass(params[0]);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException("cannot initialize " + params[0]);
+ }
+ }
+
+ /**
+ * make() performs the object creation of the updatable classes. The
+ * expression "new <updatable class>" is replaced with a call to this
+ * method.
+ */
+ public static Object make(Class clazz, Object[] args) {
+ Constructor[] constructors = clazz.getConstructors();
+ int n = constructors.length;
+ for (int i = 0; i < n; ++i) {
+ try {
+ return constructors[i].newInstance(args);
+ }
+ catch (IllegalArgumentException e) {
+ // try again
+ }
+ catch (InstantiationException e) {
+ throw new CannotCreateException(e);
+ }
+ catch (IllegalAccessException e) {
+ throw new CannotCreateException(e);
+ }
+ catch (InvocationTargetException e) {
+ throw new CannotCreateException(e);
+ }
+ }
+
+ throw new CannotCreateException("no constructor matches");
+ }
+}
diff --git a/sample/evolve/WebPage.java b/sample/evolve/WebPage.java
new file mode 100644
index 0000000..7d420fe
--- /dev/null
+++ b/sample/evolve/WebPage.java
@@ -0,0 +1,17 @@
+package sample.evolve;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Updatable class. DemoServer instantiates this class and calls
+ * show() on the created object.
+ */
+
+public class WebPage {
+ public void show(OutputStreamWriter out) throws IOException {
+ Calendar c = new GregorianCalendar();
+ out.write(c.getTime().toString());
+ out.write("<P><A HREF=\"demo.html\">Return to the home page.</A>");
+ }
+}
diff --git a/sample/evolve/demo.html b/sample/evolve/demo.html
new file mode 100644
index 0000000..3eedf3d
--- /dev/null
+++ b/sample/evolve/demo.html
@@ -0,0 +1,39 @@
+<H2>Class Evolution</H2>
+
+<P>This is a demonstration of the class evolution mechanism
+implemented with Javassist. This mechanism enables a Java program to
+reload an existing class file. Although the reloaded class file is
+not applied to exiting objects (the old class file is used for those
+objects), it is effective in newly created objects.
+
+<P>Since the reloading is transparently executed, no programming
+convention is needed. However, there are some limitations on possible
+changes of the class definition. For example, the new class definition
+must have the same set of methods as the old one. These limitations are
+necessary for keeping the type system consistent.
+
+
+<H3><a href="java.html">Run WebPage.show()</a></H3>
+
+<P>The web server creates a new <code>WebPage</code> object and
+calls <code>show()</code> on that object. This method works as
+if it is a CGI script or a servlet and you will see the html file
+produced by this method on your browser.
+
+<H3><a href="update.html">Change WebPage.class</a></H3>
+
+<P>The web server overwrites class file <code>WebPage.class</code>
+on the local disk. Then it signals that <code>WebPage.class</code>
+must be reloaded into the JVM. If you run <code>WebPage.show()</code>
+again, you will see a different page on your browser.
+
+<H3>Source files</H3>
+
+<P>Web server: <A HREF="DemoServer.java"><code>DemoServer.java</code></A>
+
+<P>WebPage: <A HREF="WebPage.java"><code>WebPage.java</code></A> and
+another <A HREF="sample/evolve/WebPage.java"><code>WebPage.java</code></A>
+
+<P>Class loader: <A HREF="DemoLoader.java"><code>DemoLoader.java</code></A>,
+ <A HREF="Evolution.java"><code>Evolution.java</code></A>, and
+ <A HREF="VersionManager.java"><code>VersionManager.java</code></A>.
diff --git a/sample/evolve/sample/evolve/WebPage.java b/sample/evolve/sample/evolve/WebPage.java
new file mode 100644
index 0000000..507b956
--- /dev/null
+++ b/sample/evolve/sample/evolve/WebPage.java
@@ -0,0 +1,20 @@
+package sample.evolve;
+
+import java.io.*;
+import java.util.*;
+
+/**
+ * Updatable class. DemoServer instantiates this class and calls
+ * show() on the created object.
+ */
+
+public class WebPage {
+ public void show(OutputStreamWriter out) throws IOException {
+ out.write("<H2>Current Time:</H2>");
+ Calendar c = new GregorianCalendar();
+ out.write("<CENTER><H3><FONT color=\"blue\">");
+ out.write(c.getTime().toString());
+ out.write("</FONT></H3></CENTER><HR>");
+ out.write("<P><A HREF=\"demo.html\">Return to the home page.</A>");
+ }
+}
diff --git a/sample/evolve/start.html b/sample/evolve/start.html
new file mode 100644
index 0000000..8ab3f94
--- /dev/null
+++ b/sample/evolve/start.html
@@ -0,0 +1,23 @@
+<h2>Instructions</h2>
+
+<p>1. Compile <code>sample/evolve/*.java</code>.
+
+<p>2. change the current directory to <code>sample/evolve</code><br>
+and compile there <code>sample/evolve/WebPage.java</code><br>
+(i.e. compile <code>sample/evolve/sample/evolve/WebPage.java</code>).
+
+<p>The two versions of <code>WebPage.class</code> are used<br>
+for changing the contents of <code>WebPage.class</code> during
+the demo.
+
+<p>3. Run the server on the local host (where your web browser is running):
+
+<ul>
+<code>% java sample.evolve.DemoLoader 5003
+</code></ul>
+
+<p>4. Click below:
+
+<ul><h2><a href="http://localhost:5003/demo.html">
+Start!
+</a></h2></ul>
diff --git a/sample/evolve/update.html b/sample/evolve/update.html
new file mode 100644
index 0000000..8255165
--- /dev/null
+++ b/sample/evolve/update.html
@@ -0,0 +1,3 @@
+<h2><code>WebPage.class</code> has been changed.</h2>
+
+<a href="demo.html">Return to the home page.</a>
diff --git a/sample/hotswap/HelloWorld.java b/sample/hotswap/HelloWorld.java
new file mode 100644
index 0000000..51d8fcd
--- /dev/null
+++ b/sample/hotswap/HelloWorld.java
@@ -0,0 +1,5 @@
+public class HelloWorld {
+ public void print() {
+ System.out.println("hello world");
+ }
+}
diff --git a/sample/hotswap/Test.java b/sample/hotswap/Test.java
new file mode 100644
index 0000000..651d218
--- /dev/null
+++ b/sample/hotswap/Test.java
@@ -0,0 +1,25 @@
+import java.io.*;
+import javassist.util.HotSwapper;
+
+public class Test {
+ public static void main(String[] args) throws Exception {
+ HotSwapper hs = new HotSwapper(8000);
+ new HelloWorld().print();
+
+ File newfile = new File("logging/HelloWorld.class");
+ byte[] bytes = new byte[(int)newfile.length()];
+ new FileInputStream(newfile).read(bytes);
+ System.out.println("** reload a logging version");
+
+ hs.reload("HelloWorld", bytes);
+ new HelloWorld().print();
+
+ newfile = new File("HelloWorld.class");
+ bytes = new byte[(int)newfile.length()];
+ new FileInputStream(newfile).read(bytes);
+ System.out.println("** reload the original version");
+
+ hs.reload("HelloWorld", bytes);
+ new HelloWorld().print();
+ }
+}
diff --git a/sample/hotswap/logging/HelloWorld.java b/sample/hotswap/logging/HelloWorld.java
new file mode 100644
index 0000000..88f0866
--- /dev/null
+++ b/sample/hotswap/logging/HelloWorld.java
@@ -0,0 +1,6 @@
+public class HelloWorld {
+ public void print() {
+ System.out.println("** HelloWorld.print()");
+ System.out.println("hello world");
+ }
+}
diff --git a/sample/preproc/Assistant.java b/sample/preproc/Assistant.java
new file mode 100644
index 0000000..81b93b2
--- /dev/null
+++ b/sample/preproc/Assistant.java
@@ -0,0 +1,53 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2005 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package sample.preproc;
+
+import javassist.CtClass;
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+
+/**
+ * This is an interface for objects invoked by the
+ * Javassist preprocessor when the preprocessor encounters an annotated
+ * import declaration.
+ *
+ * @see sample.preproc.Compiler
+ */
+public interface Assistant {
+ /**
+ * Is called when the Javassist preprocessor encounters an
+ * import declaration annotated with the "by" keyword.
+ *
+ * <p>The original import declaration is replaced with new import
+ * declarations of classes returned by this method. For example,
+ * the following implementation does not change the original
+ * declaration:
+ *
+ * <ul><pre>
+ * public CtClass[] assist(ClassPool cp, String importname, String[] args) {
+ * return new CtClass[] { cp.get(importname) };
+ * }
+ * </pre></uL>
+ *
+ * @param cp class pool
+ * @param importname the class imported by the declaration
+ * @param args the parameters specified by the annotation
+ * @return the classes imported in the java source
+ * program produced by the preprocessor.
+ */
+ public CtClass[] assist(ClassPool cp, String importname,
+ String[] args) throws CannotCompileException;
+}
diff --git a/sample/preproc/Compiler.java b/sample/preproc/Compiler.java
new file mode 100644
index 0000000..5481c0f
--- /dev/null
+++ b/sample/preproc/Compiler.java
@@ -0,0 +1,352 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2005 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package sample.preproc;
+
+import java.io.IOException;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.util.Vector;
+import javassist.CannotCompileException;
+import javassist.CtClass;
+import javassist.ClassPool;
+
+/**
+ * This is a preprocessor for Java source programs using annotated
+ * import declarations.
+ *
+ * <ul><pre>
+ * import <i>class-name</i> by <i>assistant-name</i> [(<i>arg1, arg2, ...</i>)]
+ * </pre></ul>
+ *
+ * <p>To process this annotation, run this class as follows:
+ *
+ * <ul><pre>
+ * java sample.preproc.Compiler sample.j
+ * </pre></ul>
+ *
+ * <p>This command produces <code>sample.java</code>, which only includes
+ * regular import declarations. Also, the Javassist program
+ * specified by <i>assistant-name</i> is executed so that it produces
+ * class files under the <code>./tmpjvst</code> directory. The class
+ * specified by <i>assistant-name</i> must implement
+ * <code>sample.preproc.Assistant</code>.
+ *
+ * @see sample.preproc.Assistant
+ */
+
+public class Compiler {
+ protected BufferedReader input;
+ protected BufferedWriter output;
+ protected ClassPool classPool;
+
+ /**
+ * Constructs a <code>Compiler</code> with a source file.
+ *
+ * @param inputname the name of the source file.
+ */
+ public Compiler(String inputname) throws CannotCompileException {
+ try {
+ input = new BufferedReader(new FileReader(inputname));
+ }
+ catch (IOException e) {
+ throw new CannotCompileException("cannot open: " + inputname);
+ }
+
+ String outputname = getOutputFilename(inputname);
+ if (outputname.equals(inputname))
+ throw new CannotCompileException("invalid source name: "
+ + inputname);
+
+ try {
+ output = new BufferedWriter(new FileWriter(outputname));
+ }
+ catch (IOException e) {
+ throw new CannotCompileException("cannot open: " + outputname);
+ }
+
+ classPool = ClassPool.getDefault();
+ }
+
+ /**
+ * Starts preprocessing.
+ */
+ public void process() throws IOException, CannotCompileException {
+ int c;
+ CommentSkipper reader = new CommentSkipper(input, output);
+ while ((c = reader.read()) != -1) {
+ output.write(c);
+ if (c == 'p') {
+ if (skipPackage(reader))
+ break;
+ }
+ else if (c == 'i')
+ readImport(reader);
+ else if (c != ' ' && c != '\t' && c != '\n' && c != '\r')
+ break;
+ }
+
+ while ((c = input.read()) != -1)
+ output.write(c);
+
+ input.close();
+ output.close();
+ }
+
+ private boolean skipPackage(CommentSkipper reader) throws IOException {
+ int c;
+ c = reader.read();
+ output.write(c);
+ if (c != 'a')
+ return true;
+
+ while ((c = reader.read()) != -1) {
+ output.write(c);
+ if (c == ';')
+ break;
+ }
+
+ return false;
+ }
+
+ private void readImport(CommentSkipper reader)
+ throws IOException, CannotCompileException
+ {
+ int word[] = new int[5];
+ int c;
+ for (int i = 0; i < 5; ++i) {
+ word[i] = reader.read();
+ output.write(word[i]);
+ }
+
+ if (word[0] != 'm' || word[1] != 'p' || word[2] != 'o'
+ || word[3] != 'r' || word[4] != 't')
+ return; // syntax error?
+
+ c = skipSpaces(reader, ' ');
+ StringBuffer classbuf = new StringBuffer();
+ while (c != ' ' && c != '\t' && c != '\n' && c != '\r'
+ && c != ';' && c != -1) {
+ classbuf.append((char)c);
+ c = reader.read();
+ }
+
+ String importclass = classbuf.toString();
+ c = skipSpaces(reader, c);
+ if (c == ';') {
+ output.write(importclass);
+ output.write(';');
+ return;
+ }
+ if (c != 'b')
+ syntaxError(importclass);
+
+ reader.read(); // skip 'y'
+
+ StringBuffer assistant = new StringBuffer();
+ Vector args = new Vector();
+ c = readAssistant(reader, importclass, assistant, args);
+ c = skipSpaces(reader, c);
+ if (c != ';')
+ syntaxError(importclass);
+
+ runAssistant(importclass, assistant.toString(), args);
+ }
+
+ void syntaxError(String importclass) throws CannotCompileException {
+ throw new CannotCompileException("Syntax error. Cannot import "
+ + importclass);
+ }
+
+ int readAssistant(CommentSkipper reader, String importclass,
+ StringBuffer assistant, Vector args)
+ throws IOException, CannotCompileException
+ {
+ int c = readArgument(reader, assistant);
+ c = skipSpaces(reader, c);
+ if (c == '(') {
+ do {
+ StringBuffer arg = new StringBuffer();
+ c = readArgument(reader, arg);
+ args.addElement(arg.toString());
+ c = skipSpaces(reader, c);
+ } while (c == ',');
+
+ if (c != ')')
+ syntaxError(importclass);
+
+ return reader.read();
+ }
+
+ return c;
+ }
+
+ int readArgument(CommentSkipper reader, StringBuffer buf)
+ throws IOException
+ {
+ int c = skipSpaces(reader, ' ');
+ while ('A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
+ || '0' <= c && c <= '9' || c == '.' || c == '_') {
+ buf.append((char)c);
+ c = reader.read();
+ }
+
+ return c;
+ }
+
+ int skipSpaces(CommentSkipper reader, int c) throws IOException {
+ while (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+ if (c == '\n' || c == '\r')
+ output.write(c);
+
+ c = reader.read();
+ }
+
+ return c;
+ }
+
+ /**
+ * Is invoked if this compiler encoutenrs:
+ *
+ * <ul><pre>
+ * import <i>class name</i> by <i>assistant</i> (<i>args1</i>, <i>args2</i>, ...);
+ * </pre></ul>
+ *
+ * @param classname class name
+ * @param assistantname assistant
+ * @param argv args1, args2, ...
+ */
+ private void runAssistant(String importname, String assistantname,
+ Vector argv)
+ throws IOException, CannotCompileException
+ {
+ Class assistant;
+ Assistant a;
+ int s = argv.size();
+ String[] args = new String[s];
+ for (int i = 0; i < s; ++i)
+ args[i] = (String)argv.elementAt(i);
+
+ try {
+ assistant = Class.forName(assistantname);
+ }
+ catch (ClassNotFoundException e) {
+ throw new CannotCompileException("Cannot find " + assistantname);
+ }
+
+ try {
+ a = (Assistant)assistant.newInstance();
+ }
+ catch (Exception e) {
+ throw new CannotCompileException(e);
+ }
+
+ CtClass[] imports = a.assist(classPool, importname, args);
+ s = imports.length;
+ if (s < 1)
+ output.write(" java.lang.Object;");
+ else {
+ output.write(' ');
+ output.write(imports[0].getName());
+ output.write(';');
+ for (int i = 1; i < s; ++i) {
+ output.write(" import ");
+ output.write(imports[1].getName());
+ output.write(';');
+ }
+ }
+ }
+
+ private String getOutputFilename(String input) {
+ int i = input.lastIndexOf('.');
+ if (i < 0)
+ i = input.length();
+
+ return input.substring(0, i) + ".java";
+ }
+
+ public static void main(String[] args) {
+ if (args.length > 0)
+ try {
+ Compiler c = new Compiler(args[0]);
+ c.process();
+ }
+ catch (IOException e) {
+ System.err.println(e);
+ }
+ catch (CannotCompileException e) {
+ System.err.println(e);
+ }
+ else {
+ System.err.println("Javassist version " + CtClass.version);
+ System.err.println("No source file is specified.");
+ }
+ }
+}
+
+class CommentSkipper {
+ private BufferedReader input;
+ private BufferedWriter output;
+
+ public CommentSkipper(BufferedReader reader, BufferedWriter writer) {
+ input = reader;
+ output = writer;
+ }
+
+ public int read() throws IOException {
+ int c;
+ while ((c = input.read()) != -1)
+ if (c != '/')
+ return c;
+ else {
+ c = input.read();
+ if (c == '/')
+ skipCxxComments();
+ else if (c == '*')
+ skipCComments();
+ else
+ output.write('/');
+ }
+
+ return c;
+ }
+
+ private void skipCxxComments() throws IOException {
+ int c;
+ output.write("//");
+ while ((c = input.read()) != -1) {
+ output.write(c);
+ if (c == '\n' || c == '\r')
+ break;
+ }
+ }
+
+ private void skipCComments() throws IOException {
+ int c;
+ boolean star = false;
+ output.write("/*");
+ while ((c = input.read()) != -1) {
+ output.write(c);
+ if (c == '*')
+ star = true;
+ else if(star && c == '/')
+ break;
+ else
+ star = false;
+ }
+ }
+}
diff --git a/sample/preproc/package.html b/sample/preproc/package.html
new file mode 100644
index 0000000..dee15e0
--- /dev/null
+++ b/sample/preproc/package.html
@@ -0,0 +1,14 @@
+<html>
+<body>
+A sample preprocessor.
+
+<p>The preprocessor for running Javassist at compile time.
+The produced class files are saved on a local disk.
+
+<p>This package is provided as a sample implementation of the
+preprocessor using Javassist. All the programs in this package
+uses only the regular Javassist API; they never call any hidden
+methods.
+
+</body>
+</html>
diff --git a/sample/reflect/Main.java b/sample/reflect/Main.java
new file mode 100644
index 0000000..972e896
--- /dev/null
+++ b/sample/reflect/Main.java
@@ -0,0 +1,32 @@
+package sample.reflect;
+
+import javassist.tools.reflect.Loader;
+
+/*
+ The "verbose metaobject" example (JDK 1.2 or later only).
+
+ Since this program registers class Person as a reflective class
+ (in a more realistic demonstration, what classes are reflective
+ would be specified by some configuration file), the class loader
+ modifies Person.class when loading into the JVM so that the class
+ Person is changed into a reflective class and a Person object is
+ controlled by a VerboseMetaobj.
+
+ To run,
+
+ % java javassist.tools.reflect.Loader sample.reflect.Main Joe
+
+ Compare this result with that of the regular execution without reflection:
+
+ % java sample.reflect.Person Joe
+*/
+public class Main {
+ public static void main(String[] args) throws Throwable {
+ Loader cl = (Loader)Main.class.getClassLoader();
+ cl.makeReflective("sample.reflect.Person",
+ "sample.reflect.VerboseMetaobj",
+ "javassist.tools.reflect.ClassMetaobject");
+
+ cl.run("sample.reflect.Person", args);
+ }
+}
diff --git a/sample/reflect/Person.java b/sample/reflect/Person.java
new file mode 100644
index 0000000..90ccb18
--- /dev/null
+++ b/sample/reflect/Person.java
@@ -0,0 +1,53 @@
+/*
+ * A base-level class controlled by VerboseMetaobj.
+ */
+
+package sample.reflect;
+
+import javassist.tools.reflect.Metalevel;
+import javassist.tools.reflect.Metaobject;
+
+public class Person {
+ public String name;
+
+ public static int birth = 3;
+
+ public static final String defaultName = "John";
+
+ public Person(String name, int birthYear) {
+ if (name == null)
+ this.name = defaultName;
+ else
+ this.name = name;
+
+ birth = birthYear;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public int getAge(int year) {
+ return year - birth;
+ }
+
+ public static void main(String[] args) {
+ String name;
+ if (args.length > 0)
+ name = args[0];
+ else
+ name = "Bill";
+
+ Person p = new Person(name, 1960);
+ System.out.println("name: " + p.getName());
+ System.out.println("object: " + p.toString());
+
+ // change the metaobject of p.
+ if (p instanceof Metalevel) {
+ ((Metalevel)p)._setMetaobject(new Metaobject(p, null));
+ System.out.println("<< the metaobject was changed.>>");
+ }
+
+ System.out.println("age: " + p.getAge(1999));
+ }
+}
diff --git a/sample/reflect/VerboseMetaobj.java b/sample/reflect/VerboseMetaobj.java
new file mode 100644
index 0000000..cc47999
--- /dev/null
+++ b/sample/reflect/VerboseMetaobj.java
@@ -0,0 +1,27 @@
+package sample.reflect;
+
+import javassist.tools.reflect.*;
+
+public class VerboseMetaobj extends Metaobject {
+ public VerboseMetaobj(Object self, Object[] args) {
+ super(self, args);
+ System.out.println("** constructed: " + self.getClass().getName());
+ }
+
+ public Object trapFieldRead(String name) {
+ System.out.println("** field read: " + name);
+ return super.trapFieldRead(name);
+ }
+
+ public void trapFieldWrite(String name, Object value) {
+ System.out.println("** field write: " + name);
+ super.trapFieldWrite(name, value);
+ }
+
+ public Object trapMethodcall(int identifier, Object[] args)
+ throws Throwable {
+ System.out.println("** trap: " + getMethodName(identifier) + "() in "
+ + getClassMetaobject().getName());
+ return super.trapMethodcall(identifier, args);
+ }
+}
diff --git a/sample/rmi/AlertDialog.java b/sample/rmi/AlertDialog.java
new file mode 100644
index 0000000..99fae5c
--- /dev/null
+++ b/sample/rmi/AlertDialog.java
@@ -0,0 +1,30 @@
+package sample.rmi;
+
+import java.awt.*;
+import java.awt.event.*;
+
+public class AlertDialog extends Frame implements ActionListener {
+ private Label label;
+
+ public AlertDialog() {
+ super("Alert");
+ setSize(200, 100);
+ setLocation(100, 100);
+ label = new Label();
+ Button b = new Button("OK");
+ b.addActionListener(this);
+ Panel p = new Panel();
+ p.add(b);
+ add("North", label);
+ add("South", p);
+ }
+
+ public void show(String message) {
+ label.setText(message);
+ setVisible(true);
+ }
+
+ public void actionPerformed(ActionEvent e) {
+ setVisible(false);
+ }
+}
diff --git a/sample/rmi/CountApplet.java b/sample/rmi/CountApplet.java
new file mode 100644
index 0000000..e4ee0ee
--- /dev/null
+++ b/sample/rmi/CountApplet.java
@@ -0,0 +1,83 @@
+package sample.rmi;
+
+import java.applet.*;
+import java.awt.*;
+import java.awt.event.*;
+import javassist.tools.rmi.ObjectImporter;
+import javassist.tools.rmi.ObjectNotFoundException;
+import javassist.tools.web.Viewer;
+
+public class CountApplet extends Applet implements ActionListener {
+ private Font font;
+ private ObjectImporter importer;
+ private Counter counter;
+ private AlertDialog dialog;
+ private String message;
+
+ private String paramButton;
+ private String paramName;
+
+ public void init() {
+ paramButton = getParameter("button");
+ paramName = getParameter("name");
+ importer = new ObjectImporter(this);
+ commonInit();
+ }
+
+ /* call this method instead of init() if this program is not run
+ * as an applet.
+ */
+ public void applicationInit() {
+ paramButton = "OK";
+ paramName = "counter";
+ Viewer cl = (Viewer)getClass().getClassLoader();
+ importer = new ObjectImporter(cl.getServer(), cl.getPort());
+ commonInit();
+ }
+
+ private void commonInit() {
+ font = new Font("SansSerif", Font.ITALIC, 40);
+ Button b = new Button(paramButton);
+ b.addActionListener(this);
+ add(b);
+ dialog = new AlertDialog();
+ message = "???";
+ }
+
+ public void destroy() {
+ dialog.dispose();
+ }
+
+ public void start() {
+ try {
+ counter = (Counter)importer.lookupObject(paramName);
+ message = Integer.toString(counter.get());
+ }
+ catch (ObjectNotFoundException e) {
+ dialog.show(e.toString());
+ }
+ }
+
+ public void actionPerformed(ActionEvent e) {
+ counter.increase();
+ message = Integer.toString(counter.get());
+ repaint();
+ }
+
+ public void paint(Graphics g) {
+ g.setFont(font);
+ g.drawRect(50, 50, 100, 100);
+ g.setColor(Color.blue);
+ g.drawString(message, 60, 120);
+ }
+
+ public static void main(String[] args) {
+ Frame f = new Frame("CountApplet");
+ CountApplet ca = new CountApplet();
+ f.add(ca);
+ f.setSize(300, 300);
+ ca.applicationInit();
+ ca.start();
+ f.setVisible(true);
+ }
+}
diff --git a/sample/rmi/Counter.java b/sample/rmi/Counter.java
new file mode 100644
index 0000000..0920ca7
--- /dev/null
+++ b/sample/rmi/Counter.java
@@ -0,0 +1,32 @@
+package sample.rmi;
+
+import javassist.tools.rmi.AppletServer;
+import java.io.IOException;
+import javassist.CannotCompileException;
+import javassist.NotFoundException;
+
+public class Counter {
+ private int count = 0;
+
+ public int get() {
+ return count;
+ }
+
+ synchronized public int increase() {
+ count += 1;
+ return count;
+ }
+
+ public static void main(String[] args)
+ throws IOException, NotFoundException, CannotCompileException
+ {
+ if (args.length == 1) {
+ AppletServer web = new AppletServer(args[0]);
+ web.exportObject("counter", new Counter());
+ web.run();
+ }
+ else
+ System.err.println(
+ "Usage: java sample.rmi.Counter <port number>");
+ }
+}
diff --git a/sample/rmi/inside.gif b/sample/rmi/inside.gif
new file mode 100644
index 0000000..c69c8ee
--- /dev/null
+++ b/sample/rmi/inside.gif
Binary files differ
diff --git a/sample/rmi/start.html b/sample/rmi/start.html
new file mode 100644
index 0000000..33321ad
--- /dev/null
+++ b/sample/rmi/start.html
@@ -0,0 +1,15 @@
+<h2>Instructions</h2>
+
+<p>1. Run the server on the local host (where your web browser is running):
+
+<ul>% java sample.rmi.Counter 5001</ul>
+
+<p>2. Click below:
+
+<h2><a href="webdemo.html">
+Start!
+</a></h2>
+
+<p>If you don't want to use a web browser, do as follows:
+
+<ul><pre>% java javassist.tools.web.Viewer localhost 5001 sample.rmi.CountApplet</pre></ul>
diff --git a/sample/rmi/webdemo.html b/sample/rmi/webdemo.html
new file mode 100644
index 0000000..a2b595c
--- /dev/null
+++ b/sample/rmi/webdemo.html
@@ -0,0 +1,203 @@
+<html>
+<body>
+<h2>Remote Method Invocation</h2>
+
+<P>Javassist enables an applet to access a remote object as if it is a
+local object. The applet can communicate through a socket with the
+host that executes the web server distributing that applet. However,
+the applet cannot directly call a method on an object if the object is
+on a remote host. The <code>javassist.tools.rmi</code> package provides
+a mechanism for the applet to transparently access the remote object.
+The rules that the applet must be subject to are simpler than the
+standard Java RMI.
+
+<h3>1. Sample applet</h3>
+
+<P>The applet showing below is a simple number counter.
+If you press the button, the number is increased by one.
+An interesting feature of this applet is that the object
+recording the current number is contained by the web server
+written in Java. The applet must access the object through a socket
+to obtain the current number.
+
+<p><center>
+<applet codebase="http://localhost:5001"
+code="sample.rmi.CountApplet" width=200 height=200>
+<param name=name value="counter">
+<param name=button value="+1">
+</applet>
+</center>
+
+<p>However, the program of the applet does not need to directly handle
+a socket. The <code>ObjectImporter</code> provided by Javassist deals
+with all the awkward programming.
+Look at the lines shown with red:
+
+<p><b>Figure 1: Applet</b>
+
+<pre>
+<font color="red">import javassist.tools.rmi.ObjectImporter;</font>
+
+public class CountApplet extends Applet implements ActionListener {
+ private Font font;
+ <font color="red">private ObjectImporter importer;
+ private Counter counter;</font>
+ private AlertDialog dialog;
+ private String message;
+
+ public void init() {
+ font = new Font("SansSerif", Font.ITALIC, 40);
+ Button b = new Button(getParameter("button"));
+ b.addActionListener(this);
+ add(b);
+ <font color="red">importer = new ObjectImporter(this);</font>
+ dialog = new AlertDialog();
+ message = "???";
+ }
+
+ public void start() {
+ String counterName = getParameter("name");
+ <font color="red">counter = (Counter)importer.getObject(counterName);</font>
+ message = Integer.toString(<font color="red">counter.get()</font>);
+ }
+
+ /* The method called when the button is pressed.
+ */
+ public void actionPerformed(ActionEvent e) {
+ message = Integer.toString(<font color="red">counter.increase()</font>);
+ repaint();
+ }
+
+ public void paint(Graphics g) {
+ g.setFont(font);
+ g.drawRect(50, 50, 100, 100);
+ g.setColor(Color.blue);
+ g.drawString(message, 60, 120);
+ }
+}
+</pre>
+
+<p>A <code>Counter</code> object running on a remote host
+maintains the counter number. To access this object, the applet first
+calls <code>getObject()</code> on an <code>ObjectImporter</code>
+to obtain a reference to the object. The parameter is the name associated
+with the object by the web server. Once the reference is obtained, it
+is delt with as if it is a reference to a local object.
+For example, <code>counter.get()</code> and <code>counter.increase()</code>
+call methods on the remote object.
+
+<p>The definition of the <code>Counter</code> class is also
+straightforward:
+
+<p><b>Figure 2: Remote object</b>
+
+<pre>
+public class Counter {
+ private int count = 0;
+
+ public int get() {
+ return count;
+ }
+
+ public int increase() {
+ count += 1;
+ return count;
+ }
+}
+</pre>
+
+<p>Note that the <code>javassist.tools.rmi</code> package does not require
+the <code>Counter</code> class to be an interface unlike the Java RMI,
+with which <code>Counter</code> must be an interface and it must be
+implemented by another class.
+
+<p>To make the <code>Counter</code> object available from the applet,
+it must be registered with the web server. A <code>AppletServer</code>
+object is a simple webserver that can distribute <code>.html</code> files
+and <code>.class</code> files (Java applets).
+
+<p><b>Figure 3: Server-side program</b>
+
+<pre>
+public class MyWebServer {
+ public static void main(String[] args) throws IOException, CannotCompileException
+ {
+ AppletServer web = new AppletServer(args[0]);
+ <font color="red">web.exportObject("counter", new Counter());</font>
+ web.run();
+ }
+}
+</pre>
+
+<p>The <code>exportObject()</code> method registers a remote object
+with the <code>AppletServer</code> object. In the example above,
+a <code>Counter</code> object is registered. The applet can access
+the object with the name "counter". The web server starts the service
+if the <code>run()</code> method is called.
+
+<p><br>
+
+<h3>2. Features</h3>
+
+The remote method invocation mechanism provided by Javassist has the
+following features:
+
+<ul>
+<li><b>Regular Java syntax:</b><br>
+ The applet can call a method on a remote object with regular
+ Java syntax.
+<p>
+
+<li><b>No special naming convention:</b><br>
+ The applet can use the same class name as the server-side program.
+ The reference object to a remote <code>Foo</code> object is
+ also represented by the class <code>Foo</code>.
+ Unlike other similar
+ systems, it is not represented by a different class such as
+ <code>ProxyFoo</code> or an interface implemented by
+ <code>Foo</code>.
+<p>
+
+<li><b>No extra compiler:</b><br>
+ All the programs, both the applet and the server-side program,
+ are compiled by the regular Java compiler. No external compiler
+ is needed.
+</ul>
+
+<p> With the Java RMI or Voyager, the applet programmer must define
+an interface for every remote object class and access the remote object
+through that interface.
+On the other hand, the <code>javassist.tools.rmi</code> package does not
+require the programmer to follow that programming convention.
+It is suitable for writing simple distributed programs like applets.
+
+<p><br>
+
+<h3>3. Inside of the system</h3>
+
+<p>A key idea of the implementation is that the applet and the server-side
+program must use different versions of the class <code>Counter</code>.
+The <code>Counter</code> object in the applet must work as a proxy
+object, which transfers the method invocations to the <code>Counter</code>
+object in the server-side program.
+
+<p>With other systems like the Java RMI, the class of this proxy object is
+produced by a special compiler such as <code>rmic</code>.
+It must be manually maintained by the programmer.
+
+<center><img src="inside.gif"></center>
+
+<p>However, Javassist automatically generates the proxy class at
+runtime so that the programmer does not have to be concerned about the
+maintenance of the proxy class.
+If the web browser running the applet
+requests to load the <code>Counter</code> class, which is the class
+of an exported object,
+then the web server
+transfers the version of <code>Counter</code> that Javassist generates
+as a proxy class.
+
+<p><br>
+
+</body>
+</html>
diff --git a/sample/vector/Sample.java b/sample/vector/Sample.java
new file mode 100644
index 0000000..7a47aad
--- /dev/null
+++ b/sample/vector/Sample.java
@@ -0,0 +1,14 @@
+package sample.vector;
+
+public class Sample extends java.util.Vector {
+ public void add(X e) {
+ super.addElement(e);
+ }
+
+ public X at(int i) {
+ return (X)super.elementAt(i);
+ }
+}
+
+class X {
+}
diff --git a/sample/vector/Sample2.java b/sample/vector/Sample2.java
new file mode 100644
index 0000000..dd5c965
--- /dev/null
+++ b/sample/vector/Sample2.java
@@ -0,0 +1,13 @@
+package sample.vector;
+
+public class Sample2 extends java.util.Vector {
+ public Object add(Object[] args) {
+ super.addElement(args[0]);
+ return null;
+ }
+
+ public Object at(Object[] args) {
+ int i = ((Integer)args[0]).intValue();
+ return super.elementAt(i);
+ }
+}
diff --git a/sample/vector/Test.j b/sample/vector/Test.j
new file mode 100644
index 0000000..4ae7f6b
--- /dev/null
+++ b/sample/vector/Test.j
@@ -0,0 +1,38 @@
+/*
+ A sample program using sample.vector.VectorAssistant
+ and the sample.preproc package.
+
+ This automatically produces the classes representing vectors of integer
+ and vectors of java.lang.String.
+
+ To compile and run this program, do as follows:
+
+ % java sample.preproc.Compiler sample/vector/Test.j
+ % javac sample/vector/Test.java
+ % java sample.vector.Test
+
+ The first line produces one source file (sample/Test.java) and
+ two class files (sample/vector/intVector.class and
+ sample/vector/StringVector.class).
+*/
+
+package sample.vector;
+
+import java.util.Vector by sample.vector.VectorAssistant(java.lang.String);
+import java.util.Vector by sample.vector.VectorAssistant(int);
+
+public class Test {
+ public static void main(String[] args) {
+ intVector iv = new intVector();
+ iv.add(3);
+ iv.add(4);
+ for (int i = 0; i < iv.size(); ++i)
+ System.out.println(iv.at(i));
+
+ StringVector sv = new StringVector();
+ sv.add("foo");
+ sv.add("bar");
+ for (int i = 0; i < sv.size(); ++i)
+ System.out.println(sv.at(i));
+ }
+}
diff --git a/sample/vector/VectorAssistant.java b/sample/vector/VectorAssistant.java
new file mode 100644
index 0000000..8b721db
--- /dev/null
+++ b/sample/vector/VectorAssistant.java
@@ -0,0 +1,135 @@
+package sample.vector;
+
+import java.io.IOException;
+import javassist.*;
+import sample.preproc.Assistant;
+
+/**
+ * This is a Javassist program which produce a new class representing
+ * vectors of a given type. For example,
+ *
+ * <ul>import java.util.Vector by sample.vector.VectorAssistant(int)</ul>
+ *
+ * <p>requests the Javassist preprocessor to substitute the following
+ * lines for the original import declaration:
+ *
+ * <ul><pre>
+ * import java.util.Vector;
+ * import sample.vector.intVector;
+ * </pre></ul>
+ *
+ * <p>The Javassist preprocessor calls <code>VectorAssistant.assist()</code>
+ * and produces class <code>intVector</code> equivalent to:
+ *
+ * <ul><pre>
+ * package sample.vector;
+ *
+ * public class intVector extends Vector {
+ * pubilc void add(int value) {
+ * addElement(new Integer(value));
+ * }
+ *
+ * public int at(int index) {
+ * return elementAt(index).intValue();
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p><code>VectorAssistant.assist()</code> uses
+ * <code>sample.vector.Sample</code> and <code>sample.vector.Sample2</code>
+ * as a template to produce the methods <code>add()</code> and
+ * <code>at()</code>.
+ */
+public class VectorAssistant implements Assistant {
+ public final String packageName = "sample.vector.";
+
+ /**
+ * Calls <code>makeSubclass()</code> and produces a new vector class.
+ * This method is called by a <code>sample.preproc.Compiler</code>.
+ *
+ * @see sample.preproc.Compiler
+ */
+ public CtClass[] assist(ClassPool pool, String vec, String[] args)
+ throws CannotCompileException
+ {
+ if (args.length != 1)
+ throw new CannotCompileException(
+ "VectorAssistant receives a single argument.");
+
+ try {
+ CtClass subclass;
+ CtClass elementType = pool.get(args[0]);
+ if (elementType.isPrimitive())
+ subclass = makeSubclass2(pool, elementType);
+ else
+ subclass = makeSubclass(pool, elementType);
+
+ CtClass[] results = { subclass, pool.get(vec) };
+ return results;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (IOException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Produces a new vector class. This method does not work if
+ * the element type is a primitive type.
+ *
+ * @param type the type of elements
+ */
+ public CtClass makeSubclass(ClassPool pool, CtClass type)
+ throws CannotCompileException, NotFoundException, IOException
+ {
+ CtClass vec = pool.makeClass(makeClassName(type));
+ vec.setSuperclass(pool.get("java.util.Vector"));
+
+ CtClass c = pool.get("sample.vector.Sample");
+ CtMethod addmethod = c.getDeclaredMethod("add");
+ CtMethod atmethod = c.getDeclaredMethod("at");
+
+ ClassMap map = new ClassMap();
+ map.put("sample.vector.X", type.getName());
+
+ vec.addMethod(CtNewMethod.copy(addmethod, "add", vec, map));
+ vec.addMethod(CtNewMethod.copy(atmethod, "at", vec, map));
+ vec.writeFile();
+ return vec;
+ }
+
+ /**
+ * Produces a new vector class. This uses wrapped methods so that
+ * the element type can be a primitive type.
+ *
+ * @param type the type of elements
+ */
+ public CtClass makeSubclass2(ClassPool pool, CtClass type)
+ throws CannotCompileException, NotFoundException, IOException
+ {
+ CtClass vec = pool.makeClass(makeClassName(type));
+ vec.setSuperclass(pool.get("java.util.Vector"));
+
+ CtClass c = pool.get("sample.vector.Sample2");
+ CtMethod addmethod = c.getDeclaredMethod("add");
+ CtMethod atmethod = c.getDeclaredMethod("at");
+
+ CtClass[] args1 = { type };
+ CtClass[] args2 = { CtClass.intType };
+ CtMethod m
+ = CtNewMethod.wrapped(CtClass.voidType, "add", args1,
+ null, addmethod, null, vec);
+ vec.addMethod(m);
+ m = CtNewMethod.wrapped(type, "at", args2,
+ null, atmethod, null, vec);
+ vec.addMethod(m);
+ vec.writeFile();
+ return vec;
+ }
+
+ private String makeClassName(CtClass type) {
+ return packageName + type.getSimpleName() + "Vector";
+ }
+}
diff --git a/src/main/META-INF/MANIFEST.MF b/src/main/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..02ac494
--- /dev/null
+++ b/src/main/META-INF/MANIFEST.MF
@@ -0,0 +1,8 @@
+Manifest-Version: 1.1
+Specification-Title: Javassist
+Created-By: Shigeru Chiba, Tokyo Institute of Technology
+Specification-Vendor: Shigeru Chiba, Tokyo Institute of Technology
+Specification-Version: 3.14.0.GA
+Main-Class: javassist.CtClass
+
+Name: javassist/
diff --git a/src/main/javassist/ByteArrayClassPath.java b/src/main/javassist/ByteArrayClassPath.java
new file mode 100644
index 0000000..f09f81f
--- /dev/null
+++ b/src/main/javassist/ByteArrayClassPath.java
@@ -0,0 +1,98 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.*;
+import java.net.URL;
+import java.net.MalformedURLException;
+
+/**
+ * A <code>ByteArrayClassPath</code> contains bytes that is served as
+ * a class file to a <code>ClassPool</code>. It is useful to convert
+ * a byte array to a <code>CtClass</code> object.
+ *
+ * <p>For example, if you want to convert a byte array <code>b</code>
+ * into a <code>CtClass</code> object representing the class with a name
+ * <code>classname</code>, then do as following:
+ *
+ * <ul><pre>
+ * ClassPool cp = ClassPool.getDefault();
+ * cp.insertClassPath(new ByteArrayClassPath(classname, b));
+ * CtClass cc = cp.get(classname);
+ * </pre></ul>
+ *
+ * <p>The <code>ClassPool</code> object <code>cp</code> uses the created
+ * <code>ByteArrayClassPath</code> object as the source of the class file.
+ *
+ * <p>A <code>ByteArrayClassPath</code> must be instantiated for every
+ * class. It contains only a single class file.
+ *
+ * @see javassist.ClassPath
+ * @see ClassPool#insertClassPath(ClassPath)
+ * @see ClassPool#appendClassPath(ClassPath)
+ * @see ClassPool#makeClass(InputStream)
+ */
+public class ByteArrayClassPath implements ClassPath {
+ protected String classname;
+ protected byte[] classfile;
+
+ /*
+ * Creates a <code>ByteArrayClassPath</code> containing the given
+ * bytes.
+ *
+ * @param name a fully qualified class name
+ * @param classfile the contents of a class file.
+ */
+ public ByteArrayClassPath(String name, byte[] classfile) {
+ this.classname = name;
+ this.classfile = classfile;
+ }
+
+ /**
+ * Closes this class path.
+ */
+ public void close() {}
+
+ public String toString() {
+ return "byte[]:" + classname;
+ }
+
+ /**
+ * Opens the class file.
+ */
+ public InputStream openClassfile(String classname) {
+ if(this.classname.equals(classname))
+ return new ByteArrayInputStream(classfile);
+ else
+ return null;
+ }
+
+ /**
+ * Obtains the URL.
+ */
+ public URL find(String classname) {
+ if(this.classname.equals(classname)) {
+ String cname = classname.replace('.', '/') + ".class";
+ try {
+ // return new File(cname).toURL();
+ return new URL("file:/ByteArrayClassPath/" + cname);
+ }
+ catch (MalformedURLException e) {}
+ }
+
+ return null;
+ }
+}
diff --git a/src/main/javassist/CannotCompileException.java b/src/main/javassist/CannotCompileException.java
new file mode 100644
index 0000000..35ad6e7
--- /dev/null
+++ b/src/main/javassist/CannotCompileException.java
@@ -0,0 +1,119 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Thrown when bytecode transformation has failed.
+ */
+public class CannotCompileException extends Exception {
+ private Throwable myCause;
+
+ /**
+ * Gets the cause of this throwable.
+ * It is for JDK 1.3 compatibility.
+ */
+ public Throwable getCause() {
+ return (myCause == this ? null : myCause);
+ }
+
+ /**
+ * Initializes the cause of this throwable.
+ * It is for JDK 1.3 compatibility.
+ */
+ public synchronized Throwable initCause(Throwable cause) {
+ myCause = cause;
+ return this;
+ }
+
+ private String message;
+
+ /**
+ * Gets a long message if it is available.
+ */
+ public String getReason() {
+ if (message != null)
+ return message;
+ else
+ return this.toString();
+ }
+
+ /**
+ * Constructs a CannotCompileException with a message.
+ *
+ * @param msg the message.
+ */
+ public CannotCompileException(String msg) {
+ super(msg);
+ message = msg;
+ initCause(null);
+ }
+
+ /**
+ * Constructs a CannotCompileException with an <code>Exception</code>
+ * representing the cause.
+ *
+ * @param e the cause.
+ */
+ public CannotCompileException(Throwable e) {
+ super("by " + e.toString());
+ message = null;
+ initCause(e);
+ }
+
+ /**
+ * Constructs a CannotCompileException with a detailed message
+ * and an <code>Exception</code> representing the cause.
+ *
+ * @param msg the message.
+ * @param e the cause.
+ */
+ public CannotCompileException(String msg, Throwable e) {
+ this(msg);
+ initCause(e);
+ }
+
+ /**
+ * Constructs a CannotCompileException with a
+ * <code>NotFoundException</code>.
+ */
+ public CannotCompileException(NotFoundException e) {
+ this("cannot find " + e.getMessage(), e);
+ }
+
+ /**
+ * Constructs a CannotCompileException with an <code>CompileError</code>.
+ */
+ public CannotCompileException(CompileError e) {
+ this("[source error] " + e.getMessage(), e);
+ }
+
+ /**
+ * Constructs a CannotCompileException
+ * with a <code>ClassNotFoundException</code>.
+ */
+ public CannotCompileException(ClassNotFoundException e, String name) {
+ this("cannot find " + name, e);
+ }
+
+ /**
+ * Constructs a CannotCompileException with a ClassFormatError.
+ */
+ public CannotCompileException(ClassFormatError e, String name) {
+ this("invalid class format: " + name, e);
+ }
+}
diff --git a/src/main/javassist/ClassClassPath.java b/src/main/javassist/ClassClassPath.java
new file mode 100644
index 0000000..c9925d8
--- /dev/null
+++ b/src/main/javassist/ClassClassPath.java
@@ -0,0 +1,96 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.InputStream;
+import java.net.URL;
+
+/**
+ * A search-path for obtaining a class file
+ * by <code>getResourceAsStream()</code> in <code>java.lang.Class</code>.
+ *
+ * <p>Try adding a <code>ClassClassPath</code> when a program is running
+ * with a user-defined class loader and any class files are not found with
+ * the default <code>ClassPool</code>. For example,
+ *
+ * <ul><pre>
+ * ClassPool cp = ClassPool.getDefault();
+ * cp.insertClassPath(new ClassClassPath(this.getClass()));
+ * </pre></ul>
+ *
+ * This code snippet permanently adds a <code>ClassClassPath</code>
+ * to the default <code>ClassPool</code>. Note that the default
+ * <code>ClassPool</code> is a singleton. The added
+ * <code>ClassClassPath</code> uses a class object representing
+ * the class including the code snippet above.
+ *
+ * @see ClassPool#insertClassPath(ClassPath)
+ * @see ClassPool#appendClassPath(ClassPath)
+ * @see LoaderClassPath
+ */
+public class ClassClassPath implements ClassPath {
+ private Class thisClass;
+
+ /** Creates a search path.
+ *
+ * @param c the <code>Class</code> object used to obtain a class
+ * file. <code>getResourceAsStream()</code> is called on
+ * this object.
+ */
+ public ClassClassPath(Class c) {
+ thisClass = c;
+ }
+
+ ClassClassPath() {
+ /* The value of thisClass was this.getClass() in early versions:
+ *
+ * thisClass = this.getClass();
+ *
+ * However, this made openClassfile() not search all the system
+ * class paths if javassist.jar is put in jre/lib/ext/
+ * (with JDK1.4).
+ */
+ this(java.lang.Object.class);
+ }
+
+ /**
+ * Obtains a class file by <code>getResourceAsStream()</code>.
+ */
+ public InputStream openClassfile(String classname) {
+ String jarname = "/" + classname.replace('.', '/') + ".class";
+ return thisClass.getResourceAsStream(jarname);
+ }
+
+ /**
+ * Obtains the URL of the specified class file.
+ *
+ * @return null if the class file could not be found.
+ */
+ public URL find(String classname) {
+ String jarname = "/" + classname.replace('.', '/') + ".class";
+ return thisClass.getResource(jarname);
+ }
+
+ /**
+ * Does nothing.
+ */
+ public void close() {
+ }
+
+ public String toString() {
+ return thisClass.getName() + ".class";
+ }
+}
diff --git a/src/main/javassist/ClassMap.java b/src/main/javassist/ClassMap.java
new file mode 100644
index 0000000..e923a38
--- /dev/null
+++ b/src/main/javassist/ClassMap.java
@@ -0,0 +1,170 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.Descriptor;
+
+/**
+ * A hash table associating class names with different names.
+ *
+ * <p>This hashtable is used for replacing class names in a class
+ * definition or a method body. Define a subclass of this class
+ * if a more complex mapping algorithm is needed. For example,
+ *
+ * <ul><pre>class MyClassMap extends ClassMap {
+ * public Object get(Object jvmClassName) {
+ * String name = toJavaName((String)jvmClassName);
+ * if (name.startsWith("java."))
+ * return toJvmName("java2." + name.substring(5));
+ * else
+ * return super.get(jvmClassName);
+ * }
+ * }</pre></ul>
+ *
+ * <p>This subclass maps <code>java.lang.String</code> to
+ * <code>java2.lang.String</code>. Note that <code>get()</code>
+ * receives and returns the internal representation of a class name.
+ * For example, the internal representation of <code>java.lang.String</code>
+ * is <code>java/lang/String</code>.
+ *
+ * @see #get(Object)
+ * @see CtClass#replaceClassName(ClassMap)
+ * @see CtNewMethod#copy(CtMethod,String,CtClass,ClassMap)
+ */
+public class ClassMap extends java.util.HashMap {
+ private ClassMap parent;
+
+ /**
+ * Constructs a hash table.
+ */
+ public ClassMap() { parent = null; }
+
+ ClassMap(ClassMap map) { parent = map; }
+
+ /**
+ * Maps a class name to another name in this hashtable.
+ * The names are obtained with calling <code>Class.getName()</code>.
+ * This method translates the given class names into the
+ * internal form used in the JVM before putting it in
+ * the hashtable.
+ *
+ * @param oldname the original class name
+ * @param newname the substituted class name.
+ */
+ public void put(CtClass oldname, CtClass newname) {
+ put(oldname.getName(), newname.getName());
+ }
+
+ /**
+ * Maps a class name to another name in this hashtable.
+ * If the hashtable contains another mapping from the same
+ * class name, the old mapping is replaced.
+ * This method translates the given class names into the
+ * internal form used in the JVM before putting it in
+ * the hashtable.
+ *
+ * <p>If <code>oldname</code> is identical to
+ * <code>newname</code>, then this method does not
+ * perform anything; it does not record the mapping from
+ * <code>oldname</code> to <code>newname</code>. See
+ * <code>fix</code> method.
+ *
+ * @param oldname the original class name.
+ * @param newname the substituted class name.
+ * @see #fix(String)
+ */
+ public void put(String oldname, String newname) {
+ if (oldname == newname)
+ return;
+
+ String oldname2 = toJvmName(oldname);
+ String s = (String)get(oldname2);
+ if (s == null || !s.equals(oldname2))
+ super.put(oldname2, toJvmName(newname));
+ }
+
+ /**
+ * Is equivalent to <code>put()</code> except that
+ * the given mapping is not recorded into the hashtable
+ * if another mapping from <code>oldname</code> is
+ * already included.
+ *
+ * @param oldname the original class name.
+ * @param newname the substituted class name.
+ */
+ public void putIfNone(String oldname, String newname) {
+ if (oldname == newname)
+ return;
+
+ String oldname2 = toJvmName(oldname);
+ String s = (String)get(oldname2);
+ if (s == null)
+ super.put(oldname2, toJvmName(newname));
+ }
+
+ protected final void put0(Object oldname, Object newname) {
+ super.put(oldname, newname);
+ }
+
+ /**
+ * Returns the class name to wihch the given <code>jvmClassName</code>
+ * is mapped. A subclass of this class should override this method.
+ *
+ * <p>This method receives and returns the internal representation of
+ * class name used in the JVM.
+ *
+ * @see #toJvmName(String)
+ * @see #toJavaName(String)
+ */
+ public Object get(Object jvmClassName) {
+ Object found = super.get(jvmClassName);
+ if (found == null && parent != null)
+ return parent.get(jvmClassName);
+ else
+ return found;
+ }
+
+ /**
+ * Prevents a mapping from the specified class name to another name.
+ */
+ public void fix(CtClass clazz) {
+ fix(clazz.getName());
+ }
+
+ /**
+ * Prevents a mapping from the specified class name to another name.
+ */
+ public void fix(String name) {
+ String name2 = toJvmName(name);
+ super.put(name2, name2);
+ }
+
+ /**
+ * Converts a class name into the internal representation used in
+ * the JVM.
+ */
+ public static String toJvmName(String classname) {
+ return Descriptor.toJvmName(classname);
+ }
+
+ /**
+ * Converts a class name from the internal representation used in
+ * the JVM to the normal one used in Java.
+ */
+ public static String toJavaName(String classname) {
+ return Descriptor.toJavaName(classname);
+ }
+}
diff --git a/src/main/javassist/ClassPath.java b/src/main/javassist/ClassPath.java
new file mode 100644
index 0000000..d34b279
--- /dev/null
+++ b/src/main/javassist/ClassPath.java
@@ -0,0 +1,67 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.InputStream;
+import java.net.URL;
+
+/**
+ * <code>ClassPath</code> is an interface implemented by objects
+ * representing a class search path.
+ * <code>ClassPool</code> uses those objects for reading class files.
+ *
+ * <p>The users can define a class implementing this interface so that
+ * a class file is obtained from a non-standard source.
+ *
+ * @see ClassPool#insertClassPath(ClassPath)
+ * @see ClassPool#appendClassPath(ClassPath)
+ * @see ClassPool#removeClassPath(ClassPath)
+ */
+public interface ClassPath {
+ /**
+ * Opens a class file.
+ * This method may be called just to examine whether the class file
+ * exists as well as to read the contents of the file.
+ *
+ * <p>This method can return null if the specified class file is not
+ * found. If null is returned, the next search path is examined.
+ * However, if an error happens, this method must throw an exception
+ * so that the search will be terminated.
+ *
+ * <p>This method should not modify the contents of the class file.
+ *
+ * @param classname a fully-qualified class name
+ * @return the input stream for reading a class file
+ * @see javassist.Translator
+ */
+ InputStream openClassfile(String classname) throws NotFoundException;
+
+ /**
+ * Returns the uniform resource locator (URL) of the class file
+ * with the specified name.
+ *
+ * @param classname a fully-qualified class name.
+ * @return null if the specified class file could not be found.
+ */
+ URL find(String classname);
+
+ /**
+ * This method is invoked when the <code>ClassPath</code> object is
+ * detached from the search path. It will be an empty method in most of
+ * classes.
+ */
+ void close();
+}
diff --git a/src/main/javassist/ClassPool.java b/src/main/javassist/ClassPool.java
new file mode 100644
index 0000000..b75bfb6
--- /dev/null
+++ b/src/main/javassist/ClassPool.java
@@ -0,0 +1,1107 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.security.ProtectionDomain;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import javassist.bytecode.Descriptor;
+
+/**
+ * A container of <code>CtClass</code> objects.
+ * A <code>CtClass</code> object must be obtained from this object.
+ * If <code>get()</code> is called on this object,
+ * it searches various sources represented by <code>ClassPath</code>
+ * to find a class file and then it creates a <code>CtClass</code> object
+ * representing that class file. The created object is returned to the
+ * caller.
+ *
+ * <p><b>Memory consumption memo:</b>
+ *
+ * <p><code>ClassPool</code> objects hold all the <code>CtClass</code>es
+ * that have been created so that the consistency among modified classes
+ * can be guaranteed. Thus if a large number of <code>CtClass</code>es
+ * are processed, the <code>ClassPool</code> will consume a huge amount
+ * of memory. To avoid this, a <code>ClassPool</code> object
+ * should be recreated, for example, every hundred classes processed.
+ * Note that <code>getDefault()</code> is a singleton factory.
+ * Otherwise, <code>detach()</code> in <code>CtClass</code> should be used
+ * to avoid huge memory consumption.
+ *
+ * <p><b><code>ClassPool</code> hierarchy:</b>
+ *
+ * <p><code>ClassPool</code>s can make a parent-child hierarchy as
+ * <code>java.lang.ClassLoader</code>s. If a <code>ClassPool</code> has
+ * a parent pool, <code>get()</code> first asks the parent pool to find
+ * a class file. Only if the parent could not find the class file,
+ * <code>get()</code> searches the <code>ClassPath</code>s of
+ * the child <code>ClassPool</code>. This search order is reversed if
+ * <code>ClassPath.childFirstLookup</code> is <code>true</code>.
+ *
+ * @see javassist.CtClass
+ * @see javassist.ClassPath
+ */
+public class ClassPool {
+ // used by toClass().
+ private static java.lang.reflect.Method defineClass1, defineClass2;
+
+ static {
+ try {
+ AccessController.doPrivileged(new PrivilegedExceptionAction(){
+ public Object run() throws Exception{
+ Class cl = Class.forName("java.lang.ClassLoader");
+ defineClass1 = cl.getDeclaredMethod("defineClass",
+ new Class[] { String.class, byte[].class,
+ int.class, int.class });
+
+ defineClass2 = cl.getDeclaredMethod("defineClass",
+ new Class[] { String.class, byte[].class,
+ int.class, int.class, ProtectionDomain.class });
+ return null;
+ }
+ });
+ }
+ catch (PrivilegedActionException pae) {
+ throw new RuntimeException("cannot initialize ClassPool", pae.getException());
+ }
+ }
+
+ /**
+ * Determines the search order.
+ *
+ * <p>If this field is true, <code>get()</code> first searches the
+ * class path associated to this <code>ClassPool</code> and then
+ * the class path associated with the parent <code>ClassPool</code>.
+ * Otherwise, the class path associated with the parent is searched
+ * first.
+ *
+ * <p>The default value is false.
+ */
+ public boolean childFirstLookup = false;
+
+ /**
+ * Turning the automatic pruning on/off.
+ *
+ * <p>If this field is true, <code>CtClass</code> objects are
+ * automatically pruned by default when <code>toBytecode()</code> etc.
+ * are called. The automatic pruning can be turned on/off individually
+ * for each <code>CtClass</code> object.
+ *
+ * <p>The initial value is false.
+ *
+ * @see CtClass#prune()
+ * @see CtClass#stopPruning(boolean)
+ * @see CtClass#detach()
+ */
+ public static boolean doPruning = false;
+
+ private int compressCount;
+ private static final int COMPRESS_THRESHOLD = 100;
+
+ /* releaseUnmodifiedClassFile was introduced for avoiding a bug
+ of JBoss AOP. So the value should be true except for JBoss AOP.
+ */
+
+ /**
+ * If true, unmodified and not-recently-used class files are
+ * periodically released for saving memory.
+ *
+ * <p>The initial value is true.
+ */
+ public static boolean releaseUnmodifiedClassFile = true;
+
+ protected ClassPoolTail source;
+ protected ClassPool parent;
+ protected Hashtable classes; // should be synchronous
+
+ /**
+ * Table of registered cflow variables.
+ */
+ private Hashtable cflow = null; // should be synchronous.
+
+ private static final int INIT_HASH_SIZE = 191;
+
+ private ArrayList importedPackages;
+
+ /**
+ * Creates a root class pool. No parent class pool is specified.
+ */
+ public ClassPool() {
+ this(null);
+ }
+
+ /**
+ * Creates a root class pool. If <code>useDefaultPath</code> is
+ * true, <code>appendSystemPath()</code> is called. Otherwise,
+ * this constructor is equivalent to the constructor taking no
+ * parameter.
+ *
+ * @param useDefaultPath true if the system search path is
+ * appended.
+ */
+ public ClassPool(boolean useDefaultPath) {
+ this(null);
+ if (useDefaultPath)
+ appendSystemPath();
+ }
+
+ /**
+ * Creates a class pool.
+ *
+ * @param parent the parent of this class pool. If this is a root
+ * class pool, this parameter must be <code>null</code>.
+ * @see javassist.ClassPool#getDefault()
+ */
+ public ClassPool(ClassPool parent) {
+ this.classes = new Hashtable(INIT_HASH_SIZE);
+ this.source = new ClassPoolTail();
+ this.parent = parent;
+ if (parent == null) {
+ CtClass[] pt = CtClass.primitiveTypes;
+ for (int i = 0; i < pt.length; ++i)
+ classes.put(pt[i].getName(), pt[i]);
+ }
+
+ this.cflow = null;
+ this.compressCount = 0;
+ clearImportedPackages();
+ }
+
+ /**
+ * Returns the default class pool.
+ * The returned object is always identical since this method is
+ * a singleton factory.
+ *
+ * <p>The default class pool searches the system search path,
+ * which usually includes the platform library, extension
+ * libraries, and the search path specified by the
+ * <code>-classpath</code> option or the <code>CLASSPATH</code>
+ * environment variable.
+ *
+ * <p>When this method is called for the first time, the default
+ * class pool is created with the following code snippet:
+ *
+ * <ul><code>ClassPool cp = new ClassPool();
+ * cp.appendSystemPath();
+ * </code></ul>
+ *
+ * <p>If the default class pool cannot find any class files,
+ * try <code>ClassClassPath</code> and <code>LoaderClassPath</code>.
+ *
+ * @see ClassClassPath
+ * @see LoaderClassPath
+ */
+ public static synchronized ClassPool getDefault() {
+ if (defaultPool == null) {
+ defaultPool = new ClassPool(null);
+ defaultPool.appendSystemPath();
+ }
+
+ return defaultPool;
+ }
+
+ private static ClassPool defaultPool = null;
+
+ /**
+ * Provide a hook so that subclasses can do their own
+ * caching of classes.
+ *
+ * @see #cacheCtClass(String,CtClass,boolean)
+ * @see #removeCached(String)
+ */
+ protected CtClass getCached(String classname) {
+ return (CtClass)classes.get(classname);
+ }
+
+ /**
+ * Provides a hook so that subclasses can do their own
+ * caching of classes.
+ *
+ * @see #getCached(String)
+ * @see #removeCached(String,CtClass)
+ */
+ protected void cacheCtClass(String classname, CtClass c, boolean dynamic) {
+ classes.put(classname, c);
+ }
+
+ /**
+ * Provide a hook so that subclasses can do their own
+ * caching of classes.
+ *
+ * @see #getCached(String)
+ * @see #cacheCtClass(String,CtClass,boolean)
+ */
+ protected CtClass removeCached(String classname) {
+ return (CtClass)classes.remove(classname);
+ }
+
+ /**
+ * Returns the class search path.
+ */
+ public String toString() {
+ return source.toString();
+ }
+
+ /**
+ * This method is periodically invoked so that memory
+ * footprint will be minimized.
+ */
+ void compress() {
+ if (compressCount++ > COMPRESS_THRESHOLD) {
+ compressCount = 0;
+ Enumeration e = classes.elements();
+ while (e.hasMoreElements())
+ ((CtClass)e.nextElement()).compress();
+ }
+ }
+
+ /**
+ * Record a package name so that the Javassist compiler searches
+ * the package to resolve a class name.
+ * Don't record the <code>java.lang</code> package, which has
+ * been implicitly recorded by default.
+ *
+ * <p>Since version 3.14, <code>packageName</code> can be a
+ * fully-qualified class name.
+ *
+ * <p>Note that <code>get()</code> in <code>ClassPool</code> does
+ * not search the recorded package. Only the compiler searches it.
+ *
+ * @param packageName the package name.
+ * It must not include the last '.' (dot).
+ * For example, "java.util" is valid but "java.util." is wrong.
+ * @since 3.1
+ */
+ public void importPackage(String packageName) {
+ importedPackages.add(packageName);
+ }
+
+ /**
+ * Clear all the package names recorded by <code>importPackage()</code>.
+ * The <code>java.lang</code> package is not removed.
+ *
+ * @see #importPackage(String)
+ * @since 3.1
+ */
+ public void clearImportedPackages() {
+ importedPackages = new ArrayList();
+ importedPackages.add("java.lang");
+ }
+
+ /**
+ * Returns all the package names recorded by <code>importPackage()</code>.
+ *
+ * @see #importPackage(String)
+ * @since 3.1
+ */
+ public Iterator getImportedPackages() {
+ return importedPackages.iterator();
+ }
+
+ /**
+ * Records a name that never exists.
+ * For example, a package name can be recorded by this method.
+ * This would improve execution performance
+ * since <code>get()</code> does not search the class path at all
+ * if the given name is an invalid name recorded by this method.
+ * Note that searching the class path takes relatively long time.
+ *
+ * @param name a class name (separeted by dot).
+ */
+ public void recordInvalidClassName(String name) {
+ source.recordInvalidClassName(name);
+ }
+
+ /**
+ * Records the <code>$cflow</code> variable for the field specified
+ * by <code>cname</code> and <code>fname</code>.
+ *
+ * @param name variable name
+ * @param cname class name
+ * @param fname field name
+ */
+ void recordCflow(String name, String cname, String fname) {
+ if (cflow == null)
+ cflow = new Hashtable();
+
+ cflow.put(name, new Object[] { cname, fname });
+ }
+
+ /**
+ * Undocumented method. Do not use; internal-use only.
+ *
+ * @param name the name of <code>$cflow</code> variable
+ */
+ public Object[] lookupCflow(String name) {
+ if (cflow == null)
+ cflow = new Hashtable();
+
+ return (Object[])cflow.get(name);
+ }
+
+ /**
+ * Reads a class file and constructs a <code>CtClass</code>
+ * object with a new name.
+ * This method is useful if you want to generate a new class as a copy
+ * of another class (except the class name). For example,
+ *
+ * <ul><pre>
+ * getAndRename("Point", "Pair")
+ * </pre></ul>
+ *
+ * returns a <code>CtClass</code> object representing <code>Pair</code>
+ * class. The definition of <code>Pair</code> is the same as that of
+ * <code>Point</code> class except the class name since <code>Pair</code>
+ * is defined by reading <code>Point.class</code>.
+ *
+ * @param orgName the original (fully-qualified) class name
+ * @param newName the new class name
+ */
+ public CtClass getAndRename(String orgName, String newName)
+ throws NotFoundException
+ {
+ CtClass clazz = get0(orgName, false);
+ if (clazz == null)
+ throw new NotFoundException(orgName);
+
+ if (clazz instanceof CtClassType)
+ ((CtClassType)clazz).setClassPool(this);
+
+ clazz.setName(newName); // indirectly calls
+ // classNameChanged() in this class
+ return clazz;
+ }
+
+ /*
+ * This method is invoked by CtClassType.setName(). It removes a
+ * CtClass object from the hash table and inserts it with the new
+ * name. Don't delegate to the parent.
+ */
+ synchronized void classNameChanged(String oldname, CtClass clazz) {
+ CtClass c = (CtClass)getCached(oldname);
+ if (c == clazz) // must check this equation.
+ removeCached(oldname); // see getAndRename().
+
+ String newName = clazz.getName();
+ checkNotFrozen(newName);
+ cacheCtClass(newName, clazz, false);
+ }
+
+ /**
+ * Reads a class file from the source and returns a reference
+ * to the <code>CtClass</code>
+ * object representing that class file. If that class file has been
+ * already read, this method returns a reference to the
+ * <code>CtClass</code> created when that class file was read at the
+ * first time.
+ *
+ * <p>If <code>classname</code> ends with "[]", then this method
+ * returns a <code>CtClass</code> object for that array type.
+ *
+ * <p>To obtain an inner class, use "$" instead of "." for separating
+ * the enclosing class name and the inner class name.
+ *
+ * @param classname a fully-qualified class name.
+ */
+ public CtClass get(String classname) throws NotFoundException {
+ CtClass clazz;
+ if (classname == null)
+ clazz = null;
+ else
+ clazz = get0(classname, true);
+
+ if (clazz == null)
+ throw new NotFoundException(classname);
+ else {
+ clazz.incGetCounter();
+ return clazz;
+ }
+ }
+
+ /**
+ * Reads a class file from the source and returns a reference
+ * to the <code>CtClass</code>
+ * object representing that class file.
+ * This method is equivalent to <code>get</code> except
+ * that it returns <code>null</code> when a class file is
+ * not found and it never throws an exception.
+ *
+ * @param classname a fully-qualified class name.
+ * @return a <code>CtClass</code> object or <code>null</code>.
+ * @see #get(String)
+ * @see #find(String)
+ * @since 3.13
+ */
+ public CtClass getOrNull(String classname) {
+ CtClass clazz = null;
+ if (classname == null)
+ clazz = null;
+ else
+ try {
+ /* ClassPool.get0() never throws an exception
+ but its subclass may implement get0 that
+ may throw an exception.
+ */
+ clazz = get0(classname, true);
+ }
+ catch (NotFoundException e){}
+
+ if (clazz != null)
+ clazz.incGetCounter();
+
+ return clazz;
+ }
+
+ /**
+ * Returns a <code>CtClass</code> object with the given name.
+ * This is almost equivalent to <code>get(String)</code> except
+ * that classname can be an array-type "descriptor" (an encoded
+ * type name) such as <code>[Ljava/lang/Object;</code>.
+ *
+ * <p>Using this method is not recommended; this method should be
+ * used only to obtain the <code>CtClass</code> object
+ * with a name returned from <code>getClassInfo</code> in
+ * <code>javassist.bytecode.ClassPool</code>. <code>getClassInfo</code>
+ * returns a fully-qualified class name but, if the class is an array
+ * type, it returns a descriptor.
+ *
+ * @param classname a fully-qualified class name or a descriptor
+ * representing an array type.
+ * @see #get(String)
+ * @see javassist.bytecode.ConstPool#getClassInfo(int)
+ * @see javassist.bytecode.Descriptor#toCtClass(String, ClassPool)
+ * @since 3.8.1
+ */
+ public CtClass getCtClass(String classname) throws NotFoundException {
+ if (classname.charAt(0) == '[')
+ return Descriptor.toCtClass(classname, this);
+ else
+ return get(classname);
+ }
+
+ /**
+ * @param useCache false if the cached CtClass must be ignored.
+ * @param searchParent false if the parent class pool is not searched.
+ * @return null if the class could not be found.
+ */
+ protected synchronized CtClass get0(String classname, boolean useCache)
+ throws NotFoundException
+ {
+ CtClass clazz = null;
+ if (useCache) {
+ clazz = getCached(classname);
+ if (clazz != null)
+ return clazz;
+ }
+
+ if (!childFirstLookup && parent != null) {
+ clazz = parent.get0(classname, useCache);
+ if (clazz != null)
+ return clazz;
+ }
+
+ clazz = createCtClass(classname, useCache);
+ if (clazz != null) {
+ // clazz.getName() != classname if classname is "[L<name>;".
+ if (useCache)
+ cacheCtClass(clazz.getName(), clazz, false);
+
+ return clazz;
+ }
+
+ if (childFirstLookup && parent != null)
+ clazz = parent.get0(classname, useCache);
+
+ return clazz;
+ }
+
+ /**
+ * Creates a CtClass object representing the specified class.
+ * It first examines whether or not the corresponding class
+ * file exists. If yes, it creates a CtClass object.
+ *
+ * @return null if the class file could not be found.
+ */
+ protected CtClass createCtClass(String classname, boolean useCache) {
+ // accept "[L<class name>;" as a class name.
+ if (classname.charAt(0) == '[')
+ classname = Descriptor.toClassName(classname);
+
+ if (classname.endsWith("[]")) {
+ String base = classname.substring(0, classname.indexOf('['));
+ if ((!useCache || getCached(base) == null) && find(base) == null)
+ return null;
+ else
+ return new CtArray(classname, this);
+ }
+ else
+ if (find(classname) == null)
+ return null;
+ else
+ return new CtClassType(classname, this);
+ }
+
+ /**
+ * Searches the class path to obtain the URL of the class file
+ * specified by classname. It is also used to determine whether
+ * the class file exists.
+ *
+ * @param classname a fully-qualified class name.
+ * @return null if the class file could not be found.
+ * @see CtClass#getURL()
+ */
+ public URL find(String classname) {
+ return source.find(classname);
+ }
+
+ /*
+ * Is invoked by CtClassType.setName() and methods in this class.
+ * This method throws an exception if the class is already frozen or
+ * if this class pool cannot edit the class since it is in a parent
+ * class pool.
+ *
+ * @see checkNotExists(String)
+ */
+ void checkNotFrozen(String classname) throws RuntimeException {
+ CtClass clazz = getCached(classname);
+ if (clazz == null) {
+ if (!childFirstLookup && parent != null) {
+ try {
+ clazz = parent.get0(classname, true);
+ }
+ catch (NotFoundException e) {}
+ if (clazz != null)
+ throw new RuntimeException(classname
+ + " is in a parent ClassPool. Use the parent.");
+ }
+ }
+ else
+ if (clazz.isFrozen())
+ throw new RuntimeException(classname
+ + ": frozen class (cannot edit)");
+ }
+
+ /*
+ * This method returns null if this or its parent class pool does
+ * not contain a CtClass object with the class name.
+ *
+ * @see checkNotFrozen(String)
+ */
+ CtClass checkNotExists(String classname) {
+ CtClass clazz = getCached(classname);
+ if (clazz == null)
+ if (!childFirstLookup && parent != null) {
+ try {
+ clazz = parent.get0(classname, true);
+ }
+ catch (NotFoundException e) {}
+ }
+
+ return clazz;
+ }
+
+ /* for CtClassType.getClassFile2(). Don't delegate to the parent.
+ */
+ InputStream openClassfile(String classname) throws NotFoundException {
+ return source.openClassfile(classname);
+ }
+
+ void writeClassfile(String classname, OutputStream out)
+ throws NotFoundException, IOException, CannotCompileException
+ {
+ source.writeClassfile(classname, out);
+ }
+
+ /**
+ * Reads class files from the source and returns an array of
+ * <code>CtClass</code>
+ * objects representing those class files.
+ *
+ * <p>If an element of <code>classnames</code> ends with "[]",
+ * then this method
+ * returns a <code>CtClass</code> object for that array type.
+ *
+ * @param classnames an array of fully-qualified class name.
+ */
+ public CtClass[] get(String[] classnames) throws NotFoundException {
+ if (classnames == null)
+ return new CtClass[0];
+
+ int num = classnames.length;
+ CtClass[] result = new CtClass[num];
+ for (int i = 0; i < num; ++i)
+ result[i] = get(classnames[i]);
+
+ return result;
+ }
+
+ /**
+ * Reads a class file and obtains a compile-time method.
+ *
+ * @param classname the class name
+ * @param methodname the method name
+ * @see CtClass#getDeclaredMethod(String)
+ */
+ public CtMethod getMethod(String classname, String methodname)
+ throws NotFoundException
+ {
+ CtClass c = get(classname);
+ return c.getDeclaredMethod(methodname);
+ }
+
+ /**
+ * Creates a new class (or interface) from the given class file.
+ * If there already exists a class with the same name, the new class
+ * overwrites that previous class.
+ *
+ * <p>This method is used for creating a <code>CtClass</code> object
+ * directly from a class file. The qualified class name is obtained
+ * from the class file; you do not have to explicitly give the name.
+ *
+ * @param classfile class file.
+ * @throws RuntimeException if there is a frozen class with the
+ * the same name.
+ * @see #makeClassIfNew(InputStream)
+ * @see javassist.ByteArrayClassPath
+ */
+ public CtClass makeClass(InputStream classfile)
+ throws IOException, RuntimeException
+ {
+ return makeClass(classfile, true);
+ }
+
+ /**
+ * Creates a new class (or interface) from the given class file.
+ * If there already exists a class with the same name, the new class
+ * overwrites that previous class.
+ *
+ * <p>This method is used for creating a <code>CtClass</code> object
+ * directly from a class file. The qualified class name is obtained
+ * from the class file; you do not have to explicitly give the name.
+ *
+ * @param classfile class file.
+ * @param ifNotFrozen throws a RuntimeException if this parameter is true
+ * and there is a frozen class with the same name.
+ * @see javassist.ByteArrayClassPath
+ */
+ public CtClass makeClass(InputStream classfile, boolean ifNotFrozen)
+ throws IOException, RuntimeException
+ {
+ compress();
+ classfile = new BufferedInputStream(classfile);
+ CtClass clazz = new CtClassType(classfile, this);
+ clazz.checkModify();
+ String classname = clazz.getName();
+ if (ifNotFrozen)
+ checkNotFrozen(classname);
+
+ cacheCtClass(classname, clazz, true);
+ return clazz;
+ }
+
+ /**
+ * Creates a new class (or interface) from the given class file.
+ * If there already exists a class with the same name, this method
+ * returns the existing class; a new class is never created from
+ * the given class file.
+ *
+ * <p>This method is used for creating a <code>CtClass</code> object
+ * directly from a class file. The qualified class name is obtained
+ * from the class file; you do not have to explicitly give the name.
+ *
+ * @param classfile the class file.
+ * @see #makeClass(InputStream)
+ * @see javassist.ByteArrayClassPath
+ * @since 3.9
+ */
+ public CtClass makeClassIfNew(InputStream classfile)
+ throws IOException, RuntimeException
+ {
+ compress();
+ classfile = new BufferedInputStream(classfile);
+ CtClass clazz = new CtClassType(classfile, this);
+ clazz.checkModify();
+ String classname = clazz.getName();
+ CtClass found = checkNotExists(classname);
+ if (found != null)
+ return found;
+ else {
+ cacheCtClass(classname, clazz, true);
+ return clazz;
+ }
+ }
+
+ /**
+ * Creates a new public class.
+ * If there already exists a class with the same name, the new class
+ * overwrites that previous class.
+ *
+ * <p>If no constructor is explicitly added to the created new
+ * class, Javassist generates constructors and adds it when
+ * the class file is generated. It generates a new constructor
+ * for each constructor of the super class. The new constructor
+ * takes the same set of parameters and invokes the
+ * corresponding constructor of the super class. All the received
+ * parameters are passed to it.
+ *
+ * @param classname a fully-qualified class name.
+ * @throws RuntimeException if the existing class is frozen.
+ */
+ public CtClass makeClass(String classname) throws RuntimeException {
+ return makeClass(classname, null);
+ }
+
+ /**
+ * Creates a new public class.
+ * If there already exists a class/interface with the same name,
+ * the new class overwrites that previous class.
+ *
+ * <p>If no constructor is explicitly added to the created new
+ * class, Javassist generates constructors and adds it when
+ * the class file is generated. It generates a new constructor
+ * for each constructor of the super class. The new constructor
+ * takes the same set of parameters and invokes the
+ * corresponding constructor of the super class. All the received
+ * parameters are passed to it.
+ *
+ * @param classname a fully-qualified class name.
+ * @param superclass the super class.
+ * @throws RuntimeException if the existing class is frozen.
+ */
+ public synchronized CtClass makeClass(String classname, CtClass superclass)
+ throws RuntimeException
+ {
+ checkNotFrozen(classname);
+ CtClass clazz = new CtNewClass(classname, this, false, superclass);
+ cacheCtClass(classname, clazz, true);
+ return clazz;
+ }
+
+ /**
+ * Creates a new public nested class.
+ * This method is called by CtClassType.makeNestedClass().
+ *
+ * @param classname a fully-qualified class name.
+ * @return the nested class.
+ */
+ synchronized CtClass makeNestedClass(String classname) {
+ checkNotFrozen(classname);
+ CtClass clazz = new CtNewNestedClass(classname, this, false, null);
+ cacheCtClass(classname, clazz, true);
+ return clazz;
+ }
+
+ /**
+ * Creates a new public interface.
+ * If there already exists a class/interface with the same name,
+ * the new interface overwrites that previous one.
+ *
+ * @param name a fully-qualified interface name.
+ * @throws RuntimeException if the existing interface is frozen.
+ */
+ public CtClass makeInterface(String name) throws RuntimeException {
+ return makeInterface(name, null);
+ }
+
+ /**
+ * Creates a new public interface.
+ * If there already exists a class/interface with the same name,
+ * the new interface overwrites that previous one.
+ *
+ * @param name a fully-qualified interface name.
+ * @param superclass the super interface.
+ * @throws RuntimeException if the existing interface is frozen.
+ */
+ public synchronized CtClass makeInterface(String name, CtClass superclass)
+ throws RuntimeException
+ {
+ checkNotFrozen(name);
+ CtClass clazz = new CtNewClass(name, this, true, superclass);
+ cacheCtClass(name, clazz, true);
+ return clazz;
+ }
+
+ /**
+ * Appends the system search path to the end of the
+ * search path. The system search path
+ * usually includes the platform library, extension
+ * libraries, and the search path specified by the
+ * <code>-classpath</code> option or the <code>CLASSPATH</code>
+ * environment variable.
+ *
+ * @return the appended class path.
+ */
+ public ClassPath appendSystemPath() {
+ return source.appendSystemPath();
+ }
+
+ /**
+ * Insert a <code>ClassPath</code> object at the head of the
+ * search path.
+ *
+ * @return the inserted class path.
+ * @see javassist.ClassPath
+ * @see javassist.URLClassPath
+ * @see javassist.ByteArrayClassPath
+ */
+ public ClassPath insertClassPath(ClassPath cp) {
+ return source.insertClassPath(cp);
+ }
+
+ /**
+ * Appends a <code>ClassPath</code> object to the end of the
+ * search path.
+ *
+ * @return the appended class path.
+ * @see javassist.ClassPath
+ * @see javassist.URLClassPath
+ * @see javassist.ByteArrayClassPath
+ */
+ public ClassPath appendClassPath(ClassPath cp) {
+ return source.appendClassPath(cp);
+ }
+
+ /**
+ * Inserts a directory or a jar (or zip) file at the head of the
+ * search path.
+ *
+ * @param pathname the path name of the directory or jar file.
+ * It must not end with a path separator ("/").
+ * If the path name ends with "/*", then all the
+ * jar files matching the path name are inserted.
+ *
+ * @return the inserted class path.
+ * @throws NotFoundException if the jar file is not found.
+ */
+ public ClassPath insertClassPath(String pathname)
+ throws NotFoundException
+ {
+ return source.insertClassPath(pathname);
+ }
+
+ /**
+ * Appends a directory or a jar (or zip) file to the end of the
+ * search path.
+ *
+ * @param pathname the path name of the directory or jar file.
+ * It must not end with a path separator ("/").
+ * If the path name ends with "/*", then all the
+ * jar files matching the path name are appended.
+ *
+ * @return the appended class path.
+ * @throws NotFoundException if the jar file is not found.
+ */
+ public ClassPath appendClassPath(String pathname)
+ throws NotFoundException
+ {
+ return source.appendClassPath(pathname);
+ }
+
+ /**
+ * Detatches the <code>ClassPath</code> object from the search path.
+ * The detached <code>ClassPath</code> object cannot be added
+ * to the pathagain.
+ */
+ public void removeClassPath(ClassPath cp) {
+ source.removeClassPath(cp);
+ }
+
+ /**
+ * Appends directories and jar files for search.
+ *
+ * <p>The elements of the given path list must be separated by colons
+ * in Unix or semi-colons in Windows.
+ *
+ * @param pathlist a (semi)colon-separated list of
+ * the path names of directories and jar files.
+ * The directory name must not end with a path
+ * separator ("/").
+ * @throws NotFoundException if a jar file is not found.
+ */
+ public void appendPathList(String pathlist) throws NotFoundException {
+ char sep = File.pathSeparatorChar;
+ int i = 0;
+ for (;;) {
+ int j = pathlist.indexOf(sep, i);
+ if (j < 0) {
+ appendClassPath(pathlist.substring(i));
+ break;
+ }
+ else {
+ appendClassPath(pathlist.substring(i, j));
+ i = j + 1;
+ }
+ }
+ }
+
+ /**
+ * Converts the given class to a <code>java.lang.Class</code> object.
+ * Once this method is called, further modifications are not
+ * allowed any more.
+ * To load the class, this method uses the context class loader
+ * of the current thread. It is obtained by calling
+ * <code>getClassLoader()</code>.
+ *
+ * <p>This behavior can be changed by subclassing the pool and changing
+ * the <code>getClassLoader()</code> method.
+ * If the program is running on some application
+ * server, the context class loader might be inappropriate to load the
+ * class.
+ *
+ * <p>This method is provided for convenience. If you need more
+ * complex functionality, you should write your own class loader.
+ *
+ * <p><b>Warining:</b> A Class object returned by this method may not
+ * work with a security manager or a signed jar file because a
+ * protection domain is not specified.
+ *
+ * @see #toClass(CtClass, java.lang.ClassLoader, ProtectionDomain)
+ * @see #getClassLoader()
+ */
+ public Class toClass(CtClass clazz) throws CannotCompileException {
+ // Some subclasses of ClassPool may override toClass(CtClass,ClassLoader).
+ // So we should call that method instead of toClass(.., ProtectionDomain).
+ return toClass(clazz, getClassLoader());
+ }
+
+ /**
+ * Get the classloader for <code>toClass()</code>, <code>getAnnotations()</code> in
+ * <code>CtClass</code>, etc.
+ *
+ * <p>The default is the context class loader.
+ *
+ * @return the classloader for the pool
+ * @see #toClass(CtClass)
+ * @see CtClass#getAnnotations()
+ */
+ public ClassLoader getClassLoader() {
+ return getContextClassLoader();
+ }
+
+ /**
+ * Obtains a class loader that seems appropriate to look up a class
+ * by name.
+ */
+ static ClassLoader getContextClassLoader() {
+ return Thread.currentThread().getContextClassLoader();
+ }
+
+ /**
+ * Converts the class to a <code>java.lang.Class</code> object.
+ * Do not override this method any more at a subclass because
+ * <code>toClass(CtClass)</code> never calls this method.
+ *
+ * <p><b>Warining:</b> A Class object returned by this method may not
+ * work with a security manager or a signed jar file because a
+ * protection domain is not specified.
+ *
+ * @deprecated Replaced by {@link #toClass(CtClass,ClassLoader,ProtectionDomain)}.
+ * A subclass of <code>ClassPool</code> that has been
+ * overriding this method should be modified. It should override
+ * {@link #toClass(CtClass,ClassLoader,ProtectionDomain)}.
+ */
+ public Class toClass(CtClass ct, ClassLoader loader)
+ throws CannotCompileException
+ {
+ return toClass(ct, loader, null);
+ }
+
+ /**
+ * Converts the class to a <code>java.lang.Class</code> object.
+ * Once this method is called, further modifications are not allowed
+ * any more.
+ *
+ * <p>The class file represented by the given <code>CtClass</code> is
+ * loaded by the given class loader to construct a
+ * <code>java.lang.Class</code> object. Since a private method
+ * on the class loader is invoked through the reflection API,
+ * the caller must have permissions to do that.
+ *
+ * <p>An easy way to obtain <code>ProtectionDomain</code> object is
+ * to call <code>getProtectionDomain()</code>
+ * in <code>java.lang.Class</code>. It returns the domain that the
+ * class belongs to.
+ *
+ * <p>This method is provided for convenience. If you need more
+ * complex functionality, you should write your own class loader.
+ *
+ * @param loader the class loader used to load this class.
+ * For example, the loader returned by
+ * <code>getClassLoader()</code> can be used
+ * for this parameter.
+ * @param domain the protection domain for the class.
+ * If it is null, the default domain created
+ * by <code>java.lang.ClassLoader</code> is used.
+ *
+ * @see #getClassLoader()
+ * @since 3.3
+ */
+ public Class toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)
+ throws CannotCompileException
+ {
+ try {
+ byte[] b = ct.toBytecode();
+ java.lang.reflect.Method method;
+ Object[] args;
+ if (domain == null) {
+ method = defineClass1;
+ args = new Object[] { ct.getName(), b, new Integer(0),
+ new Integer(b.length)};
+ }
+ else {
+ method = defineClass2;
+ args = new Object[] { ct.getName(), b, new Integer(0),
+ new Integer(b.length), domain};
+ }
+
+ return toClass2(method, loader, args);
+ }
+ catch (RuntimeException e) {
+ throw e;
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw new CannotCompileException(e.getTargetException());
+ }
+ catch (Exception e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private static synchronized Class toClass2(Method method,
+ ClassLoader loader, Object[] args)
+ throws Exception
+ {
+ method.setAccessible(true);
+ try {
+ return (Class)method.invoke(loader, args);
+ }
+ finally {
+ method.setAccessible(false);
+ }
+ }
+}
diff --git a/src/main/javassist/ClassPoolTail.java b/src/main/javassist/ClassPoolTail.java
new file mode 100644
index 0000000..aa1aefe
--- /dev/null
+++ b/src/main/javassist/ClassPoolTail.java
@@ -0,0 +1,442 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.*;
+import java.util.jar.*;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.Hashtable;
+
+final class ClassPathList {
+ ClassPathList next;
+ ClassPath path;
+
+ ClassPathList(ClassPath p, ClassPathList n) {
+ next = n;
+ path = p;
+ }
+}
+
+final class DirClassPath implements ClassPath {
+ String directory;
+
+ DirClassPath(String dirName) {
+ directory = dirName;
+ }
+
+ public InputStream openClassfile(String classname) {
+ try {
+ char sep = File.separatorChar;
+ String filename = directory + sep
+ + classname.replace('.', sep) + ".class";
+ return new FileInputStream(filename.toString());
+ }
+ catch (FileNotFoundException e) {}
+ catch (SecurityException e) {}
+ return null;
+ }
+
+ public URL find(String classname) {
+ char sep = File.separatorChar;
+ String filename = directory + sep
+ + classname.replace('.', sep) + ".class";
+ File f = new File(filename);
+ if (f.exists())
+ try {
+ return f.getCanonicalFile().toURI().toURL();
+ }
+ catch (MalformedURLException e) {}
+ catch (IOException e) {}
+
+ return null;
+ }
+
+ public void close() {}
+
+ public String toString() {
+ return directory;
+ }
+}
+
+final class JarDirClassPath implements ClassPath {
+ JarClassPath[] jars;
+
+ JarDirClassPath(String dirName) throws NotFoundException {
+ File[] files = new File(dirName).listFiles(new FilenameFilter() {
+ public boolean accept(File dir, String name) {
+ name = name.toLowerCase();
+ return name.endsWith(".jar") || name.endsWith(".zip");
+ }
+ });
+
+ if (files != null) {
+ jars = new JarClassPath[files.length];
+ for (int i = 0; i < files.length; i++)
+ jars[i] = new JarClassPath(files[i].getPath());
+ }
+ }
+
+ public InputStream openClassfile(String classname) throws NotFoundException {
+ if (jars != null)
+ for (int i = 0; i < jars.length; i++) {
+ InputStream is = jars[i].openClassfile(classname);
+ if (is != null)
+ return is;
+ }
+
+ return null; // not found
+ }
+
+ public URL find(String classname) {
+ if (jars != null)
+ for (int i = 0; i < jars.length; i++) {
+ URL url = jars[i].find(classname);
+ if (url != null)
+ return url;
+ }
+
+ return null; // not found
+ }
+
+ public void close() {
+ if (jars != null)
+ for (int i = 0; i < jars.length; i++)
+ jars[i].close();
+ }
+}
+
+final class JarClassPath implements ClassPath {
+ JarFile jarfile;
+ String jarfileURL;
+
+ JarClassPath(String pathname) throws NotFoundException {
+ try {
+ jarfile = new JarFile(pathname);
+ jarfileURL = new File(pathname).getCanonicalFile()
+ .toURI().toURL().toString();
+ return;
+ }
+ catch (IOException e) {}
+ throw new NotFoundException(pathname);
+ }
+
+ public InputStream openClassfile(String classname)
+ throws NotFoundException
+ {
+ try {
+ String jarname = classname.replace('.', '/') + ".class";
+ JarEntry je = jarfile.getJarEntry(jarname);
+ if (je != null)
+ return jarfile.getInputStream(je);
+ else
+ return null; // not found
+ }
+ catch (IOException e) {}
+ throw new NotFoundException("broken jar file?: "
+ + jarfile.getName());
+ }
+
+ public URL find(String classname) {
+ String jarname = classname.replace('.', '/') + ".class";
+ JarEntry je = jarfile.getJarEntry(jarname);
+ if (je != null)
+ try {
+ return new URL("jar:" + jarfileURL + "!/" + jarname);
+ }
+ catch (MalformedURLException e) {}
+
+ return null; // not found
+ }
+
+ public void close() {
+ try {
+ jarfile.close();
+ jarfile = null;
+ }
+ catch (IOException e) {}
+ }
+
+ public String toString() {
+ return jarfile == null ? "<null>" : jarfile.toString();
+ }
+}
+
+final class ClassPoolTail {
+ protected ClassPathList pathList;
+ private Hashtable packages; // should be synchronized.
+
+ public ClassPoolTail() {
+ pathList = null;
+ packages = new Hashtable();
+ }
+
+ public String toString() {
+ StringBuffer buf = new StringBuffer();
+ buf.append("[class path: ");
+ ClassPathList list = pathList;
+ while (list != null) {
+ buf.append(list.path.toString());
+ buf.append(File.pathSeparatorChar);
+ list = list.next;
+ }
+
+ buf.append(']');
+ return buf.toString();
+ }
+
+ public synchronized ClassPath insertClassPath(ClassPath cp) {
+ pathList = new ClassPathList(cp, pathList);
+ return cp;
+ }
+
+ public synchronized ClassPath appendClassPath(ClassPath cp) {
+ ClassPathList tail = new ClassPathList(cp, null);
+ ClassPathList list = pathList;
+ if (list == null)
+ pathList = tail;
+ else {
+ while (list.next != null)
+ list = list.next;
+
+ list.next = tail;
+ }
+
+ return cp;
+ }
+
+ public synchronized void removeClassPath(ClassPath cp) {
+ ClassPathList list = pathList;
+ if (list != null)
+ if (list.path == cp)
+ pathList = list.next;
+ else {
+ while (list.next != null)
+ if (list.next.path == cp)
+ list.next = list.next.next;
+ else
+ list = list.next;
+ }
+
+ cp.close();
+ }
+
+ public ClassPath appendSystemPath() {
+ return appendClassPath(new ClassClassPath());
+ }
+
+ public ClassPath insertClassPath(String pathname)
+ throws NotFoundException
+ {
+ return insertClassPath(makePathObject(pathname));
+ }
+
+ public ClassPath appendClassPath(String pathname)
+ throws NotFoundException
+ {
+ return appendClassPath(makePathObject(pathname));
+ }
+
+ private static ClassPath makePathObject(String pathname)
+ throws NotFoundException
+ {
+ String lower = pathname.toLowerCase();
+ if (lower.endsWith(".jar") || lower.endsWith(".zip"))
+ return new JarClassPath(pathname);
+
+ int len = pathname.length();
+ if (len > 2 && pathname.charAt(len - 1) == '*'
+ && (pathname.charAt(len - 2) == '/'
+ || pathname.charAt(len - 2) == File.separatorChar)) {
+ String dir = pathname.substring(0, len - 2);
+ return new JarDirClassPath(dir);
+ }
+
+ return new DirClassPath(pathname);
+ }
+
+ /**
+ * You can record "System" so that java.lang.System can be quickly
+ * found although "System" is not a package name.
+ */
+ public void recordInvalidClassName(String name) {
+ packages.put(name, name);
+ }
+
+ /**
+ * This method does not close the output stream.
+ */
+ void writeClassfile(String classname, OutputStream out)
+ throws NotFoundException, IOException, CannotCompileException
+ {
+ InputStream fin = openClassfile(classname);
+ if (fin == null)
+ throw new NotFoundException(classname);
+
+ try {
+ copyStream(fin, out);
+ }
+ finally {
+ fin.close();
+ }
+ }
+
+ /*
+ -- faster version --
+ void checkClassName(String classname) throws NotFoundException {
+ if (find(classname) == null)
+ throw new NotFoundException(classname);
+ }
+
+ -- slower version --
+
+ void checkClassName(String classname) throws NotFoundException {
+ InputStream fin = openClassfile(classname);
+ try {
+ fin.close();
+ }
+ catch (IOException e) {}
+ }
+ */
+
+
+ /**
+ * Opens the class file for the class specified by
+ * <code>classname</code>.
+ *
+ * @param classname a fully-qualified class name
+ * @return null if the file has not been found.
+ * @throws NotFoundException if any error is reported by ClassPath.
+ */
+ InputStream openClassfile(String classname)
+ throws NotFoundException
+ {
+ if (packages.get(classname) != null)
+ return null; // not found
+
+ ClassPathList list = pathList;
+ InputStream ins = null;
+ NotFoundException error = null;
+ while (list != null) {
+ try {
+ ins = list.path.openClassfile(classname);
+ }
+ catch (NotFoundException e) {
+ if (error == null)
+ error = e;
+ }
+
+ if (ins == null)
+ list = list.next;
+ else
+ return ins;
+ }
+
+ if (error != null)
+ throw error;
+ else
+ return null; // not found
+ }
+
+ /**
+ * Searches the class path to obtain the URL of the class file
+ * specified by classname. It is also used to determine whether
+ * the class file exists.
+ *
+ * @param classname a fully-qualified class name.
+ * @return null if the class file could not be found.
+ */
+ public URL find(String classname) {
+ if (packages.get(classname) != null)
+ return null;
+
+ ClassPathList list = pathList;
+ URL url = null;
+ while (list != null) {
+ url = list.path.find(classname);
+ if (url == null)
+ list = list.next;
+ else
+ return url;
+ }
+
+ return null;
+ }
+
+ /**
+ * Reads from an input stream until it reaches the end.
+ *
+ * @return the contents of that input stream
+ */
+ public static byte[] readStream(InputStream fin) throws IOException {
+ byte[][] bufs = new byte[8][];
+ int bufsize = 4096;
+
+ for (int i = 0; i < 8; ++i) {
+ bufs[i] = new byte[bufsize];
+ int size = 0;
+ int len = 0;
+ do {
+ len = fin.read(bufs[i], size, bufsize - size);
+ if (len >= 0)
+ size += len;
+ else {
+ byte[] result = new byte[bufsize - 4096 + size];
+ int s = 0;
+ for (int j = 0; j < i; ++j) {
+ System.arraycopy(bufs[j], 0, result, s, s + 4096);
+ s = s + s + 4096;
+ }
+
+ System.arraycopy(bufs[i], 0, result, s, size);
+ return result;
+ }
+ } while (size < bufsize);
+ bufsize *= 2;
+ }
+
+ throw new IOException("too much data");
+ }
+
+ /**
+ * Reads from an input stream and write to an output stream
+ * until it reaches the end. This method does not close the
+ * streams.
+ */
+ public static void copyStream(InputStream fin, OutputStream fout)
+ throws IOException
+ {
+ int bufsize = 4096;
+ for (int i = 0; i < 8; ++i) {
+ byte[] buf = new byte[bufsize];
+ int size = 0;
+ int len = 0;
+ do {
+ len = fin.read(buf, size, bufsize - size);
+ if (len >= 0)
+ size += len;
+ else {
+ fout.write(buf, 0, size);
+ return;
+ }
+ } while (size < bufsize);
+ fout.write(buf);
+ bufsize *= 2;
+ }
+
+ throw new IOException("too much data");
+ }
+}
diff --git a/src/main/javassist/CodeConverter.java b/src/main/javassist/CodeConverter.java
new file mode 100644
index 0000000..44881d5
--- /dev/null
+++ b/src/main/javassist/CodeConverter.java
@@ -0,0 +1,799 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.convert.*;
+
+/**
+ * Simple translator of method bodies
+ * (also see the <code>javassist.expr</code> package).
+ *
+ * <p>Instances of this class specifies how to instrument of the
+ * bytecodes representing a method body. They are passed to
+ * <code>CtClass.instrument()</code> or
+ * <code>CtMethod.instrument()</code> as a parameter.
+ *
+ * <p>Example:
+ * <ul><pre>
+ * ClassPool cp = ClassPool.getDefault();
+ * CtClass point = cp.get("Point");
+ * CtClass singleton = cp.get("Singleton");
+ * CtClass client = cp.get("Client");
+ * CodeConverter conv = new CodeConverter();
+ * conv.replaceNew(point, singleton, "makePoint");
+ * client.instrument(conv);
+ * </pre></ul>
+ *
+ * <p>This program substitutes "<code>Singleton.makePoint()</code>"
+ * for all occurrences of "<code>new Point()</code>"
+ * appearing in methods declared in a <code>Client</code> class.
+ *
+ * @see javassist.CtClass#instrument(CodeConverter)
+ * @see javassist.CtMethod#instrument(CodeConverter)
+ * @see javassist.expr.ExprEditor
+ */
+public class CodeConverter {
+ protected Transformer transformers = null;
+
+ /**
+ * Modify a method body so that instantiation of the specified class
+ * is replaced with a call to the specified static method. For example,
+ * <code>replaceNew(ctPoint, ctSingleton, "createPoint")</code>
+ * (where <code>ctPoint</code> and <code>ctSingleton</code> are
+ * compile-time classes for class <code>Point</code> and class
+ * <code>Singleton</code>, respectively)
+ * replaces all occurrences of:
+ *
+ * <ul><code>new Point(x, y)</code></ul>
+ *
+ * in the method body with:
+ *
+ * <ul><code>Singleton.createPoint(x, y)</code></ul>
+ *
+ * <p>This enables to intercept instantiation of <code>Point</code>
+ * and change the samentics. For example, the following
+ * <code>createPoint()</code> implements the singleton pattern:
+ *
+ * <ul><pre>public static Point createPoint(int x, int y) {
+ * if (aPoint == null)
+ * aPoint = new Point(x, y);
+ * return aPoint;
+ * }
+ * </pre></ul>
+ *
+ * <p>The static method call substituted for the original <code>new</code>
+ * expression must be
+ * able to receive the same set of parameters as the original
+ * constructor. If there are multiple constructors with different
+ * parameter types, then there must be multiple static methods
+ * with the same name but different parameter types.
+ *
+ * <p>The return type of the substituted static method must be
+ * the exactly same as the type of the instantiated class specified by
+ * <code>newClass</code>.
+ *
+ * @param newClass the instantiated class.
+ * @param calledClass the class in which the static method is
+ * declared.
+ * @param calledMethod the name of the static method.
+ */
+ public void replaceNew(CtClass newClass,
+ CtClass calledClass, String calledMethod) {
+ transformers = new TransformNew(transformers, newClass.getName(),
+ calledClass.getName(), calledMethod);
+ }
+
+ /**
+ * Modify a method body so that instantiation of the class
+ * specified by <code>oldClass</code>
+ * is replaced with instantiation of another class <code>newClass</code>.
+ * For example,
+ * <code>replaceNew(ctPoint, ctPoint2)</code>
+ * (where <code>ctPoint</code> and <code>ctPoint2</code> are
+ * compile-time classes for class <code>Point</code> and class
+ * <code>Point2</code>, respectively)
+ * replaces all occurrences of:
+ *
+ * <ul><code>new Point(x, y)</code></ul>
+ *
+ * in the method body with:
+ *
+ * <ul><code>new Point2(x, y)</code></ul>
+ *
+ * <p>Note that <code>Point2</code> must be type-compatible with <code>Point</code>.
+ * It must have the same set of methods, fields, and constructors as the
+ * replaced class.
+ */
+ public void replaceNew(CtClass oldClass, CtClass newClass) {
+ transformers = new TransformNewClass(transformers, oldClass.getName(),
+ newClass.getName());
+ }
+
+ /**
+ * Modify a method body so that field read/write expressions access
+ * a different field from the original one.
+ *
+ * <p>Note that this method changes only the filed name and the class
+ * declaring the field; the type of the target object does not change.
+ * Therefore, the substituted field must be declared in the same class
+ * or a superclass of the original class.
+ *
+ * <p>Also, <code>clazz</code> and <code>newClass</code> must specify
+ * the class directly declaring the field. They must not specify
+ * a subclass of that class.
+ *
+ * @param field the originally accessed field.
+ * @param newClass the class declaring the substituted field.
+ * @param newFieldname the name of the substituted field.
+ */
+ public void redirectFieldAccess(CtField field,
+ CtClass newClass, String newFieldname) {
+ transformers = new TransformFieldAccess(transformers, field,
+ newClass.getName(),
+ newFieldname);
+ }
+
+ /**
+ * Modify a method body so that an expression reading the specified
+ * field is replaced with a call to the specified <i>static</i> method.
+ * This static method receives the target object of the original
+ * read expression as a parameter. It must return a value of
+ * the same type as the field.
+ *
+ * <p>For example, the program below
+ *
+ * <ul><pre>Point p = new Point();
+ * int newX = p.x + 3;</pre></ul>
+ *
+ * <p>can be translated into:
+ *
+ * <ul><pre>Point p = new Point();
+ * int newX = Accessor.readX(p) + 3;</pre></ul>
+ *
+ * <p>where
+ *
+ * <ul><pre>public class Accessor {
+ * public static int readX(Object target) { ... }
+ * }</pre></ul>
+ *
+ * <p>The type of the parameter of <code>readX()</code> must
+ * be <code>java.lang.Object</code> independently of the actual
+ * type of <code>target</code>. The return type must be the same
+ * as the field type.
+ *
+ * @param field the field.
+ * @param calledClass the class in which the static method is
+ * declared.
+ * @param calledMethod the name of the static method.
+ */
+ public void replaceFieldRead(CtField field,
+ CtClass calledClass, String calledMethod) {
+ transformers = new TransformReadField(transformers, field,
+ calledClass.getName(),
+ calledMethod);
+ }
+
+ /**
+ * Modify a method body so that an expression writing the specified
+ * field is replaced with a call to the specified static method.
+ * This static method receives two parameters: the target object of
+ * the original
+ * write expression and the assigned value. The return type of the
+ * static method is <code>void</code>.
+ *
+ * <p>For example, the program below
+ *
+ * <ul><pre>Point p = new Point();
+ * p.x = 3;</pre></ul>
+ *
+ * <p>can be translated into:
+ *
+ * <ul><pre>Point p = new Point();
+ * Accessor.writeX(3);</pre></ul>
+ *
+ * <p>where
+ *
+ * <ul><pre>public class Accessor {
+ * public static void writeX(Object target, int value) { ... }
+ * }</pre></ul>
+ *
+ * <p>The type of the first parameter of <code>writeX()</code> must
+ * be <code>java.lang.Object</code> independently of the actual
+ * type of <code>target</code>. The type of the second parameter
+ * is the same as the field type.
+ *
+ * @param field the field.
+ * @param calledClass the class in which the static method is
+ * declared.
+ * @param calledMethod the name of the static method.
+ */
+ public void replaceFieldWrite(CtField field,
+ CtClass calledClass, String calledMethod) {
+ transformers = new TransformWriteField(transformers, field,
+ calledClass.getName(),
+ calledMethod);
+ }
+
+ /**
+ * Modify a method body, so that ALL accesses to an array are replaced with
+ * calls to static methods within another class. In the case of reading an
+ * element from the array, this is replaced with a call to a static method with
+ * the array and the index as arguments, the return value is the value read from
+ * the array. If writing to an array, this is replaced with a call to a static
+ * method with the array, index and new value as parameters, the return value of
+ * the static method is <code>void</code>.
+ *
+ * <p>The <code>calledClass</code> parameter is the class containing the static methods to be used
+ * for array replacement. The <code>names</code> parameter points to an implementation of
+ * <code>ArrayAccessReplacementMethodNames</code> which specifies the names of the method to be
+ * used for access for each type of array. For example reading from an <code>int[]</code> will
+ * require a different method than if writing to an <code>int[]</code>, and writing to a <code>long[]</code>
+ * will require a different method than if writing to a <code>byte[]</code>. If the implementation
+ * of <code>ArrayAccessReplacementMethodNames</code> does not contain the name for access for a
+ * type of array, that access is not replaced.
+ *
+ * <p>A default implementation of <code>ArrayAccessReplacementMethodNames</code> called
+ * <code>DefaultArrayAccessReplacementMethodNames</code> has been provided and is what is used in the
+ * following example. This also assumes that <code>'foo.ArrayAdvisor'</code> is the name of the
+ * <code>CtClass</code> passed in.
+ *
+ * <p>If we have the following class:
+ * <pre>class POJO{
+ * int[] ints = new int[]{1, 2, 3, 4, 5};
+ * long[] longs = new int[]{10, 20, 30};
+ * Object objects = new Object[]{true, false};
+ * Integer[] integers = new Integer[]{new Integer(10)};
+ * }
+ * </pre>
+ * and this is accessed as:
+ * <pre>POJO p = new POJO();
+ *
+ * //Write to int array
+ * p.ints[2] = 7;
+ *
+ * //Read from int array
+ * int i = p.ints[2];
+ *
+ * //Write to long array
+ * p.longs[2] = 1000L;
+ *
+ * //Read from long array
+ * long l = p.longs[2];
+ *
+ * //Write to Object array
+ * p.objects[2] = "Hello";
+ *
+ * //Read from Object array
+ * Object o = p.objects[2];
+ *
+ * //Write to Integer array
+ * Integer integer = new Integer(5);
+ * p.integers[0] = integer;
+ *
+ * //Read from Object array
+ * integer = p.integers[0];
+ * </pre>
+ *
+ * Following instrumentation we will have
+ * <pre>POJO p = new POJO();
+ *
+ * //Write to int array
+ * ArrayAdvisor.arrayWriteInt(p.ints, 2, 7);
+ *
+ * //Read from int array
+ * int i = ArrayAdvisor.arrayReadInt(p.ints, 2);
+ *
+ * //Write to long array
+ * ArrayAdvisor.arrayWriteLong(p.longs, 2, 1000L);
+ *
+ * //Read from long array
+ * long l = ArrayAdvisor.arrayReadLong(p.longs, 2);
+ *
+ * //Write to Object array
+ * ArrayAdvisor.arrayWriteObject(p.objects, 2, "Hello");
+ *
+ * //Read from Object array
+ * Object o = ArrayAdvisor.arrayReadObject(p.objects, 2);
+ *
+ * //Write to Integer array
+ * Integer integer = new Integer(5);
+ * ArrayAdvisor.arrayWriteObject(p.integers, 0, integer);
+ *
+ * //Read from Object array
+ * integer = ArrayAdvisor.arrayWriteObject(p.integers, 0);
+ * </pre>
+ *
+ * @see DefaultArrayAccessReplacementMethodNames
+ *
+ * @param calledClass the class containing the static methods.
+ * @param names contains the names of the methods to replace
+ * the different kinds of array access with.
+ */
+ public void replaceArrayAccess(CtClass calledClass, ArrayAccessReplacementMethodNames names)
+ throws NotFoundException
+ {
+ transformers = new TransformAccessArrayField(transformers, calledClass.getName(), names);
+ }
+
+ /**
+ * Modify method invocations in a method body so that a different
+ * method will be invoked.
+ *
+ * <p>Note that the target object, the parameters, or
+ * the type of invocation
+ * (static method call, interface call, or private method call)
+ * are not modified. Only the method name is changed. The substituted
+ * method must have the same signature that the original one has.
+ * If the original method is a static method, the substituted method
+ * must be static.
+ *
+ * @param origMethod original method
+ * @param substMethod substituted method
+ */
+ public void redirectMethodCall(CtMethod origMethod,
+ CtMethod substMethod)
+ throws CannotCompileException
+ {
+ String d1 = origMethod.getMethodInfo2().getDescriptor();
+ String d2 = substMethod.getMethodInfo2().getDescriptor();
+ if (!d1.equals(d2))
+ throw new CannotCompileException("signature mismatch: "
+ + substMethod.getLongName());
+
+ int mod1 = origMethod.getModifiers();
+ int mod2 = substMethod.getModifiers();
+ if (Modifier.isStatic(mod1) != Modifier.isStatic(mod2)
+ || (Modifier.isPrivate(mod1) && !Modifier.isPrivate(mod2))
+ || origMethod.getDeclaringClass().isInterface()
+ != substMethod.getDeclaringClass().isInterface())
+ throw new CannotCompileException("invoke-type mismatch "
+ + substMethod.getLongName());
+
+ transformers = new TransformCall(transformers, origMethod,
+ substMethod);
+ }
+
+ /**
+ * Correct invocations to a method that has been renamed.
+ * If a method is renamed, calls to that method must be also
+ * modified so that the method with the new name will be called.
+ *
+ * <p>The method must be declared in the same class before and
+ * after it is renamed.
+ *
+ * <p>Note that the target object, the parameters, or
+ * the type of invocation
+ * (static method call, interface call, or private method call)
+ * are not modified. Only the method name is changed.
+ *
+ * @param oldMethodName the old name of the method.
+ * @param newMethod the method with the new name.
+ * @see javassist.CtMethod#setName(String)
+ */
+ public void redirectMethodCall(String oldMethodName,
+ CtMethod newMethod)
+ throws CannotCompileException
+ {
+ transformers
+ = new TransformCall(transformers, oldMethodName, newMethod);
+ }
+
+ /**
+ * Insert a call to another method before an existing method call.
+ * That "before" method must be static. The return type must be
+ * <code>void</code>. As parameters, the before method receives
+ * the target object and all the parameters to the originally invoked
+ * method. For example, if the originally invoked method is
+ * <code>move()</code>:
+ *
+ * <ul><pre>class Point {
+ * Point move(int x, int y) { ... }
+ * }</pre></ul>
+ *
+ * <p>Then the before method must be something like this:
+ *
+ * <ul><pre>class Verbose {
+ * static void print(Point target, int x, int y) { ... }
+ * }</pre></ul>
+ *
+ * <p>The <code>CodeConverter</code> would translate bytecode
+ * equivalent to:
+ *
+ * <ul><pre>Point p2 = p.move(x + y, 0);</pre></ul>
+ *
+ * <p>into the bytecode equivalent to:
+ *
+ * <ul><pre>int tmp1 = x + y;
+ * int tmp2 = 0;
+ * Verbose.print(p, tmp1, tmp2);
+ * Point p2 = p.move(tmp1, tmp2);</pre></ul>
+ *
+ * @param origMethod the method originally invoked.
+ * @param beforeMethod the method invoked before
+ * <code>origMethod</code>.
+ */
+ public void insertBeforeMethod(CtMethod origMethod,
+ CtMethod beforeMethod)
+ throws CannotCompileException
+ {
+ try {
+ transformers = new TransformBefore(transformers, origMethod,
+ beforeMethod);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Inserts a call to another method after an existing method call.
+ * That "after" method must be static. The return type must be
+ * <code>void</code>. As parameters, the after method receives
+ * the target object and all the parameters to the originally invoked
+ * method. For example, if the originally invoked method is
+ * <code>move()</code>:
+ *
+ * <ul><pre>class Point {
+ * Point move(int x, int y) { ... }
+ * }</pre></ul>
+ *
+ * <p>Then the after method must be something like this:
+ *
+ * <ul><pre>class Verbose {
+ * static void print(Point target, int x, int y) { ... }
+ * }</pre></ul>
+ *
+ * <p>The <code>CodeConverter</code> would translate bytecode
+ * equivalent to:
+ *
+ * <ul><pre>Point p2 = p.move(x + y, 0);</pre></ul>
+ *
+ * <p>into the bytecode equivalent to:
+ *
+ * <ul><pre>int tmp1 = x + y;
+ * int tmp2 = 0;
+ * Point p2 = p.move(tmp1, tmp2);
+ * Verbose.print(p, tmp1, tmp2);</pre></ul>
+ *
+ * @param origMethod the method originally invoked.
+ * @param afterMethod the method invoked after
+ * <code>origMethod</code>.
+ */
+ public void insertAfterMethod(CtMethod origMethod,
+ CtMethod afterMethod)
+ throws CannotCompileException
+ {
+ try {
+ transformers = new TransformAfter(transformers, origMethod,
+ afterMethod);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Performs code conversion.
+ */
+ protected void doit(CtClass clazz, MethodInfo minfo, ConstPool cp)
+ throws CannotCompileException
+ {
+ Transformer t;
+ CodeAttribute codeAttr = minfo.getCodeAttribute();
+ if (codeAttr == null || transformers == null)
+ return;
+ for (t = transformers; t != null; t = t.getNext())
+ t.initialize(cp, clazz, minfo);
+
+ CodeIterator iterator = codeAttr.iterator();
+ while (iterator.hasNext()) {
+ try {
+ int pos = iterator.next();
+ for (t = transformers; t != null; t = t.getNext())
+ pos = t.transform(clazz, pos, iterator, cp);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ int locals = 0;
+ int stack = 0;
+ for (t = transformers; t != null; t = t.getNext()) {
+ int s = t.extraLocals();
+ if (s > locals)
+ locals = s;
+
+ s = t.extraStack();
+ if (s > stack)
+ stack = s;
+ }
+
+ for (t = transformers; t != null; t = t.getNext())
+ t.clean();
+
+ if (locals > 0)
+ codeAttr.setMaxLocals(codeAttr.getMaxLocals() + locals);
+
+ if (stack > 0)
+ codeAttr.setMaxStack(codeAttr.getMaxStack() + stack);
+ }
+
+ /**
+ * Interface containing the method names to be used
+ * as array access replacements.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.16 $
+ */
+ public interface ArrayAccessReplacementMethodNames
+ {
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)B</code> to replace reading from a byte[].
+ */
+ String byteOrBooleanRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;IB)V</code> to replace writing to a byte[].
+ */
+ String byteOrBooleanWrite();
+
+ /**
+ * @return the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)C</code> to replace reading from a char[].
+ */
+ String charRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;IC)V</code> to replace writing to a byte[].
+ */
+ String charWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)D</code> to replace reading from a double[].
+ */
+ String doubleRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;ID)V</code> to replace writing to a double[].
+ */
+ String doubleWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)F</code> to replace reading from a float[].
+ */
+ String floatRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;IF)V</code> to replace writing to a float[].
+ */
+ String floatWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)I</code> to replace reading from a int[].
+ */
+ String intRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;II)V</code> to replace writing to a int[].
+ */
+ String intWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)J</code> to replace reading from a long[].
+ */
+ String longRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;IJ)V</code> to replace writing to a long[].
+ */
+ String longWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)Ljava/lang/Object;</code>
+ * to replace reading from a Object[] (or any subclass of object).
+ */
+ String objectRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;ILjava/lang/Object;)V</code>
+ * to replace writing to a Object[] (or any subclass of object).
+ */
+ String objectWrite();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;I)S</code> to replace reading from a short[].
+ */
+ String shortRead();
+
+ /**
+ * Returns the name of a static method with the signature
+ * <code>(Ljava/lang/Object;IS)V</code> to replace writing to a short[].
+ */
+ String shortWrite();
+ }
+
+ /**
+ * Default implementation of the <code>ArrayAccessReplacementMethodNames</code>
+ * interface giving default values for method names to be used for replacing
+ * accesses to array elements.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.16 $
+ */
+ public static class DefaultArrayAccessReplacementMethodNames
+ implements ArrayAccessReplacementMethodNames
+ {
+ /**
+ * Returns "arrayReadByteOrBoolean" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)B to replace reading from a byte[].
+ */
+ public String byteOrBooleanRead()
+ {
+ return "arrayReadByteOrBoolean";
+ }
+
+ /**
+ * Returns "arrayWriteByteOrBoolean" as the name of the static method with the signature
+ * (Ljava/lang/Object;IB)V to replace writing to a byte[].
+ */
+ public String byteOrBooleanWrite()
+ {
+ return "arrayWriteByteOrBoolean";
+ }
+
+ /**
+ * Returns "arrayReadChar" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)C to replace reading from a char[].
+ */
+ public String charRead()
+ {
+ return "arrayReadChar";
+ }
+
+ /**
+ * Returns "arrayWriteChar" as the name of the static method with the signature
+ * (Ljava/lang/Object;IC)V to replace writing to a byte[].
+ */
+ public String charWrite()
+ {
+ return "arrayWriteChar";
+ }
+
+ /**
+ * Returns "arrayReadDouble" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)D to replace reading from a double[].
+ */
+ public String doubleRead()
+ {
+ return "arrayReadDouble";
+ }
+
+ /**
+ * Returns "arrayWriteDouble" as the name of the static method with the signature
+ * (Ljava/lang/Object;ID)V to replace writing to a double[].
+ */
+ public String doubleWrite()
+ {
+ return "arrayWriteDouble";
+ }
+
+ /**
+ * Returns "arrayReadFloat" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)F to replace reading from a float[].
+ */
+ public String floatRead()
+ {
+ return "arrayReadFloat";
+ }
+
+ /**
+ * Returns "arrayWriteFloat" as the name of the static method with the signature
+ * (Ljava/lang/Object;IF)V to replace writing to a float[].
+ */
+ public String floatWrite()
+ {
+ return "arrayWriteFloat";
+ }
+
+ /**
+ * Returns "arrayReadInt" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)I to replace reading from a int[].
+ */
+ public String intRead()
+ {
+ return "arrayReadInt";
+ }
+
+ /**
+ * Returns "arrayWriteInt" as the name of the static method with the signature
+ * (Ljava/lang/Object;II)V to replace writing to a int[].
+ */
+ public String intWrite()
+ {
+ return "arrayWriteInt";
+ }
+
+ /**
+ * Returns "arrayReadLong" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)J to replace reading from a long[].
+ */
+ public String longRead()
+ {
+ return "arrayReadLong";
+ }
+
+ /**
+ * Returns "arrayWriteLong" as the name of the static method with the signature
+ * (Ljava/lang/Object;IJ)V to replace writing to a long[].
+ */
+ public String longWrite()
+ {
+ return "arrayWriteLong";
+ }
+
+ /**
+ * Returns "arrayReadObject" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)Ljava/lang/Object; to replace reading from a Object[] (or any subclass of object).
+ */
+ public String objectRead()
+ {
+ return "arrayReadObject";
+ }
+
+ /**
+ * Returns "arrayWriteObject" as the name of the static method with the signature
+ * (Ljava/lang/Object;ILjava/lang/Object;)V to replace writing to a Object[] (or any subclass of object).
+ */
+ public String objectWrite()
+ {
+ return "arrayWriteObject";
+ }
+
+ /**
+ * Returns "arrayReadShort" as the name of the static method with the signature
+ * (Ljava/lang/Object;I)S to replace reading from a short[].
+ */
+ public String shortRead()
+ {
+ return "arrayReadShort";
+ }
+
+ /**
+ * Returns "arrayWriteShort" as the name of the static method with the signature
+ * (Ljava/lang/Object;IS)V to replace writing to a short[].
+ */
+ public String shortWrite()
+ {
+ return "arrayWriteShort";
+ }
+ }
+}
diff --git a/src/main/javassist/CtArray.java b/src/main/javassist/CtArray.java
new file mode 100644
index 0000000..42fe609
--- /dev/null
+++ b/src/main/javassist/CtArray.java
@@ -0,0 +1,112 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+/**
+ * Array types.
+ */
+final class CtArray extends CtClass {
+ protected ClassPool pool;
+
+ // the name of array type ends with "[]".
+ CtArray(String name, ClassPool cp) {
+ super(name);
+ pool = cp;
+ }
+
+ public ClassPool getClassPool() {
+ return pool;
+ }
+
+ public boolean isArray() {
+ return true;
+ }
+
+ private CtClass[] interfaces = null;
+
+ public int getModifiers() {
+ int mod = Modifier.FINAL;
+ try {
+ mod |= getComponentType().getModifiers()
+ & (Modifier.PROTECTED | Modifier.PUBLIC | Modifier.PRIVATE);
+ }
+ catch (NotFoundException e) {}
+ return mod;
+ }
+
+ public CtClass[] getInterfaces() throws NotFoundException {
+ if (interfaces == null) {
+ Class[] intfs = Object[].class.getInterfaces();
+ // java.lang.Cloneable and java.io.Serializable.
+ // If the JVM is CLDC, intfs is empty.
+ interfaces = new CtClass[intfs.length];
+ for (int i = 0; i < intfs.length; i++)
+ interfaces[i] = pool.get(intfs[i].getName());
+ }
+
+ return interfaces;
+ }
+
+ public boolean subtypeOf(CtClass clazz) throws NotFoundException {
+ if (super.subtypeOf(clazz))
+ return true;
+
+ String cname = clazz.getName();
+ if (cname.equals(javaLangObject))
+ return true;
+
+ CtClass[] intfs = getInterfaces();
+ for (int i = 0; i < intfs.length; i++)
+ if (intfs[i].subtypeOf(clazz))
+ return true;
+
+ return clazz.isArray()
+ && getComponentType().subtypeOf(clazz.getComponentType());
+ }
+
+ public CtClass getComponentType() throws NotFoundException {
+ String name = getName();
+ return pool.get(name.substring(0, name.length() - 2));
+ }
+
+ public CtClass getSuperclass() throws NotFoundException {
+ return pool.get(javaLangObject);
+ }
+
+ public CtMethod[] getMethods() {
+ try {
+ return getSuperclass().getMethods();
+ }
+ catch (NotFoundException e) {
+ return super.getMethods();
+ }
+ }
+
+ public CtMethod getMethod(String name, String desc)
+ throws NotFoundException
+ {
+ return getSuperclass().getMethod(name, desc);
+ }
+
+ public CtConstructor[] getConstructors() {
+ try {
+ return getSuperclass().getConstructors();
+ }
+ catch (NotFoundException e) {
+ return super.getConstructors();
+ }
+ }
+}
diff --git a/src/main/javassist/CtBehavior.java b/src/main/javassist/CtBehavior.java
new file mode 100644
index 0000000..1414d05
--- /dev/null
+++ b/src/main/javassist/CtBehavior.java
@@ -0,0 +1,1152 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.Javac;
+import javassist.compiler.CompileError;
+import javassist.expr.ExprEditor;
+
+/**
+ * <code>CtBehavior</code> represents a method, a constructor,
+ * or a static constructor (class initializer).
+ * It is the abstract super class of
+ * <code>CtMethod</code> and <code>CtConstructor</code>.
+ */
+public abstract class CtBehavior extends CtMember {
+ protected MethodInfo methodInfo;
+
+ protected CtBehavior(CtClass clazz, MethodInfo minfo) {
+ super(clazz);
+ methodInfo = minfo;
+ }
+
+ /**
+ * @param isCons true if this is a constructor.
+ */
+ void copy(CtBehavior src, boolean isCons, ClassMap map)
+ throws CannotCompileException
+ {
+ CtClass declaring = declaringClass;
+ MethodInfo srcInfo = src.methodInfo;
+ CtClass srcClass = src.getDeclaringClass();
+ ConstPool cp = declaring.getClassFile2().getConstPool();
+
+ map = new ClassMap(map);
+ map.put(srcClass.getName(), declaring.getName());
+ try {
+ boolean patch = false;
+ CtClass srcSuper = srcClass.getSuperclass();
+ CtClass destSuper = declaring.getSuperclass();
+ String destSuperName = null;
+ if (srcSuper != null && destSuper != null) {
+ String srcSuperName = srcSuper.getName();
+ destSuperName = destSuper.getName();
+ if (!srcSuperName.equals(destSuperName))
+ if (srcSuperName.equals(CtClass.javaLangObject))
+ patch = true;
+ else
+ map.putIfNone(srcSuperName, destSuperName);
+ }
+
+ // a stack map table is copied from srcInfo.
+ methodInfo = new MethodInfo(cp, srcInfo.getName(), srcInfo, map);
+ if (isCons && patch)
+ methodInfo.setSuperclass(destSuperName);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ protected void extendToString(StringBuffer buffer) {
+ buffer.append(' ');
+ buffer.append(getName());
+ buffer.append(' ');
+ buffer.append(methodInfo.getDescriptor());
+ }
+
+ /**
+ * Returns the method or constructor name followed by parameter types
+ * such as <code>javassist.CtBehavior.stBody(String)</code>.
+ *
+ * @since 3.5
+ */
+ public abstract String getLongName();
+
+ /**
+ * Returns the MethodInfo representing this method/constructor in the
+ * class file.
+ */
+ public MethodInfo getMethodInfo() {
+ declaringClass.checkModify();
+ return methodInfo;
+ }
+
+ /**
+ * Returns the MethodInfo representing the method/constructor in the
+ * class file (read only).
+ * Normal applications do not need calling this method. Use
+ * <code>getMethodInfo()</code>.
+ *
+ * <p>The <code>MethodInfo</code> object obtained by this method
+ * is read only. Changes to this object might not be reflected
+ * on a class file generated by <code>toBytecode()</code>,
+ * <code>toClass()</code>, etc in <code>CtClass</code>.
+ *
+ * <p>This method is available even if the <code>CtClass</code>
+ * containing this method is frozen. However, if the class is
+ * frozen, the <code>MethodInfo</code> might be also pruned.
+ *
+ * @see #getMethodInfo()
+ * @see CtClass#isFrozen()
+ * @see CtClass#prune()
+ */
+ public MethodInfo getMethodInfo2() { return methodInfo; }
+
+ /**
+ * Obtains the modifiers of the method/constructor.
+ *
+ * @return modifiers encoded with
+ * <code>javassist.Modifier</code>.
+ * @see Modifier
+ */
+ public int getModifiers() {
+ return AccessFlag.toModifier(methodInfo.getAccessFlags());
+ }
+
+ /**
+ * Sets the encoded modifiers of the method/constructor.
+ *
+ * <p>Changing the modifiers may cause a problem.
+ * For example, if a non-static method is changed to static,
+ * the method will be rejected by the bytecode verifier.
+ *
+ * @see Modifier
+ */
+ public void setModifiers(int mod) {
+ declaringClass.checkModify();
+ methodInfo.setAccessFlags(AccessFlag.of(mod));
+ }
+
+ /**
+ * Returns true if the class has the specified annotation class.
+ *
+ * @param clz the annotation class.
+ * @return <code>true</code> if the annotation is found,
+ * otherwise <code>false</code>.
+ * @since 3.11
+ */
+ public boolean hasAnnotation(Class clz) {
+ MethodInfo mi = getMethodInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.hasAnnotationType(clz,
+ getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the annotation if the class has the specified annotation class.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this method/constructor, an <code>Author</code> object is returned.
+ * The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @param clz the annotation class.
+ * @return the annotation if found, otherwise <code>null</code>.
+ * @since 3.11
+ */
+ public Object getAnnotation(Class clz) throws ClassNotFoundException {
+ MethodInfo mi = getMethodInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.getAnnotationType(clz,
+ getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the annotations associated with this method or constructor.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAvailableAnnotations()
+ * @since 3.1
+ */
+ public Object[] getAnnotations() throws ClassNotFoundException {
+ return getAnnotations(false);
+ }
+
+ /**
+ * Returns the annotations associated with this method or constructor.
+ * If any annotations are not on the classpath, they are not included
+ * in the returned array.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAnnotations()
+ * @since 3.3
+ */
+ public Object[] getAvailableAnnotations(){
+ try{
+ return getAnnotations(true);
+ }
+ catch (ClassNotFoundException e){
+ throw new RuntimeException("Unexpected exception", e);
+ }
+ }
+
+ private Object[] getAnnotations(boolean ignoreNotFound)
+ throws ClassNotFoundException
+ {
+ MethodInfo mi = getMethodInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ mi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.toAnnotationType(ignoreNotFound,
+ getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the parameter annotations associated with this method or constructor.
+ *
+ * @return an array of annotation-type objects. The length of the returned array is
+ * equal to the number of the formal parameters. If each parameter has no
+ * annotation, the elements of the returned array are empty arrays.
+ *
+ * @see #getAvailableParameterAnnotations()
+ * @see #getAnnotations()
+ * @since 3.1
+ */
+ public Object[][] getParameterAnnotations() throws ClassNotFoundException {
+ return getParameterAnnotations(false);
+ }
+
+ /**
+ * Returns the parameter annotations associated with this method or constructor.
+ * If any annotations are not on the classpath, they are not included in the
+ * returned array.
+ *
+ * @return an array of annotation-type objects. The length of the returned array is
+ * equal to the number of the formal parameters. If each parameter has no
+ * annotation, the elements of the returned array are empty arrays.
+ *
+ * @see #getParameterAnnotations()
+ * @see #getAvailableAnnotations()
+ * @since 3.3
+ */
+ public Object[][] getAvailableParameterAnnotations(){
+ try {
+ return getParameterAnnotations(true);
+ }
+ catch(ClassNotFoundException e) {
+ throw new RuntimeException("Unexpected exception", e);
+ }
+ }
+
+ Object[][] getParameterAnnotations(boolean ignoreNotFound)
+ throws ClassNotFoundException
+ {
+ MethodInfo mi = getMethodInfo2();
+ ParameterAnnotationsAttribute ainfo = (ParameterAnnotationsAttribute)
+ mi.getAttribute(ParameterAnnotationsAttribute.invisibleTag);
+ ParameterAnnotationsAttribute ainfo2 = (ParameterAnnotationsAttribute)
+ mi.getAttribute(ParameterAnnotationsAttribute.visibleTag);
+ return CtClassType.toAnnotationType(ignoreNotFound,
+ getDeclaringClass().getClassPool(),
+ ainfo, ainfo2, mi);
+ }
+
+ /**
+ * Obtains parameter types of this method/constructor.
+ */
+ public CtClass[] getParameterTypes() throws NotFoundException {
+ return Descriptor.getParameterTypes(methodInfo.getDescriptor(),
+ declaringClass.getClassPool());
+ }
+
+ /**
+ * Obtains the type of the returned value.
+ */
+ CtClass getReturnType0() throws NotFoundException {
+ return Descriptor.getReturnType(methodInfo.getDescriptor(),
+ declaringClass.getClassPool());
+ }
+
+ /**
+ * Returns the method signature (the parameter types
+ * and the return type).
+ * The method signature is represented by a character string
+ * called method descriptor, which is defined in the JVM specification.
+ * If two methods/constructors have
+ * the same parameter types
+ * and the return type, <code>getSignature()</code> returns the
+ * same string (the return type of constructors is <code>void</code>).
+ *
+ * <p>Note that the returned string is not the type signature
+ * contained in the <code>SignatureAttirbute</code>. It is
+ * a descriptor. To obtain a type signature, call the following
+ * methods:
+ *
+ * <ul><pre>getMethodInfo().getAttribute(SignatureAttribute.tag)
+ * </pre></ul>
+ *
+ * @see javassist.bytecode.Descriptor
+ * @see javassist.bytecode.SignatureAttribute
+ */
+ public String getSignature() {
+ return methodInfo.getDescriptor();
+ }
+
+ /**
+ * Obtains exceptions that this method/constructor may throw.
+ *
+ * @return a zero-length array if there is no throws clause.
+ */
+ public CtClass[] getExceptionTypes() throws NotFoundException {
+ String[] exceptions;
+ ExceptionsAttribute ea = methodInfo.getExceptionsAttribute();
+ if (ea == null)
+ exceptions = null;
+ else
+ exceptions = ea.getExceptions();
+
+ return declaringClass.getClassPool().get(exceptions);
+ }
+
+ /**
+ * Sets exceptions that this method/constructor may throw.
+ */
+ public void setExceptionTypes(CtClass[] types) throws NotFoundException {
+ declaringClass.checkModify();
+ if (types == null || types.length == 0) {
+ methodInfo.removeExceptionsAttribute();
+ return;
+ }
+
+ String[] names = new String[types.length];
+ for (int i = 0; i < types.length; ++i)
+ names[i] = types[i].getName();
+
+ ExceptionsAttribute ea = methodInfo.getExceptionsAttribute();
+ if (ea == null) {
+ ea = new ExceptionsAttribute(methodInfo.getConstPool());
+ methodInfo.setExceptionsAttribute(ea);
+ }
+
+ ea.setExceptions(names);
+ }
+
+ /**
+ * Returns true if the body is empty.
+ */
+ public abstract boolean isEmpty();
+
+ /**
+ * Sets a method/constructor body.
+ *
+ * @param src the source code representing the body.
+ * It must be a single statement or block.
+ * If it is <code>null</code>, the substituted
+ * body does nothing except returning zero or null.
+ */
+ public void setBody(String src) throws CannotCompileException {
+ setBody(src, null, null);
+ }
+
+ /**
+ * Sets a method/constructor body.
+ *
+ * @param src the source code representing the body.
+ * It must be a single statement or block.
+ * If it is <code>null</code>, the substituted
+ * body does nothing except returning zero or null.
+ * @param delegateObj the source text specifying the object
+ * that is called on by <code>$proceed()</code>.
+ * @param delegateMethod the name of the method
+ * that is called by <code>$proceed()</code>.
+ */
+ public void setBody(String src,
+ String delegateObj, String delegateMethod)
+ throws CannotCompileException
+ {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ try {
+ Javac jv = new Javac(cc);
+ if (delegateMethod != null)
+ jv.recordProceed(delegateObj, delegateMethod);
+
+ Bytecode b = jv.compileBody(this, src);
+ methodInfo.setCodeAttribute(b.toCodeAttribute());
+ methodInfo.setAccessFlags(methodInfo.getAccessFlags()
+ & ~AccessFlag.ABSTRACT);
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ declaringClass.rebuildClassFile();
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ } catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ static void setBody0(CtClass srcClass, MethodInfo srcInfo,
+ CtClass destClass, MethodInfo destInfo,
+ ClassMap map)
+ throws CannotCompileException
+ {
+ destClass.checkModify();
+
+ map = new ClassMap(map);
+ map.put(srcClass.getName(), destClass.getName());
+ try {
+ CodeAttribute cattr = srcInfo.getCodeAttribute();
+ if (cattr != null) {
+ ConstPool cp = destInfo.getConstPool();
+ CodeAttribute ca = (CodeAttribute)cattr.copy(cp, map);
+ destInfo.setCodeAttribute(ca);
+ // a stack map table is copied to destInfo.
+ }
+ }
+ catch (CodeAttribute.RuntimeCopyException e) {
+ /* the exception may be thrown by copy() in CodeAttribute.
+ */
+ throw new CannotCompileException(e);
+ }
+
+ destInfo.setAccessFlags(destInfo.getAccessFlags()
+ & ~AccessFlag.ABSTRACT);
+ destClass.rebuildClassFile();
+ }
+
+ /**
+ * Obtains an attribute with the given name.
+ * If that attribute is not found in the class file, this
+ * method returns null.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format. It is not an annotation.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ */
+ public byte[] getAttribute(String name) {
+ AttributeInfo ai = methodInfo.getAttribute(name);
+ if (ai == null)
+ return null;
+ else
+ return ai.get();
+ }
+
+ /**
+ * Adds an attribute. The attribute is saved in the class file.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format. It is not an annotation.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ * @param data attribute value
+ */
+ public void setAttribute(String name, byte[] data) {
+ declaringClass.checkModify();
+ methodInfo.addAttribute(new AttributeInfo(methodInfo.getConstPool(),
+ name, data));
+ }
+
+ /**
+ * Declares to use <code>$cflow</code> for this method/constructor.
+ * If <code>$cflow</code> is used, the class files modified
+ * with Javassist requires a support class
+ * <code>javassist.runtime.Cflow</code> at runtime
+ * (other Javassist classes are not required at runtime).
+ *
+ * <p>Every <code>$cflow</code> variable is given a unique name.
+ * For example, if the given name is <code>"Point.paint"</code>,
+ * then the variable is indicated by <code>$cflow(Point.paint)</code>.
+ *
+ * @param name <code>$cflow</code> name. It can include
+ * alphabets, numbers, <code>_</code>,
+ * <code>$</code>, and <code>.</code> (dot).
+ *
+ * @see javassist.runtime.Cflow
+ */
+ public void useCflow(String name) throws CannotCompileException {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ ClassPool pool = cc.getClassPool();
+ String fname;
+ int i = 0;
+ while (true) {
+ fname = "_cflow$" + i++;
+ try {
+ cc.getDeclaredField(fname);
+ }
+ catch(NotFoundException e) {
+ break;
+ }
+ }
+
+ pool.recordCflow(name, declaringClass.getName(), fname);
+ try {
+ CtClass type = pool.get("javassist.runtime.Cflow");
+ CtField field = new CtField(type, fname, cc);
+ field.setModifiers(Modifier.PUBLIC | Modifier.STATIC);
+ cc.addField(field, CtField.Initializer.byNew(type));
+ insertBefore(fname + ".enter();", false);
+ String src = fname + ".exit();";
+ insertAfter(src, true);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Declares a new local variable. The scope of this variable is the
+ * whole method body. The initial value of that variable is not set.
+ * The declared variable can be accessed in the code snippet inserted
+ * by <code>insertBefore()</code>, <code>insertAfter()</code>, etc.
+ *
+ * <p>If the second parameter <code>asFinally</code> to
+ * <code>insertAfter()</code> is true, the declared local variable
+ * is not visible from the code inserted by <code>insertAfter()</code>.
+ *
+ * @param name the name of the variable
+ * @param type the type of the variable
+ * @see #insertBefore(String)
+ * @see #insertAfter(String)
+ */
+ public void addLocalVariable(String name, CtClass type)
+ throws CannotCompileException
+ {
+ declaringClass.checkModify();
+ ConstPool cp = methodInfo.getConstPool();
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ if (ca == null)
+ throw new CannotCompileException("no method body");
+
+ LocalVariableAttribute va = (LocalVariableAttribute)ca.getAttribute(
+ LocalVariableAttribute.tag);
+ if (va == null) {
+ va = new LocalVariableAttribute(cp);
+ ca.getAttributes().add(va);
+ }
+
+ int maxLocals = ca.getMaxLocals();
+ String desc = Descriptor.of(type);
+ va.addEntry(0, ca.getCodeLength(),
+ cp.addUtf8Info(name), cp.addUtf8Info(desc), maxLocals);
+ ca.setMaxLocals(maxLocals + Descriptor.dataSize(desc));
+ }
+
+ /**
+ * Inserts a new parameter, which becomes the first parameter.
+ */
+ public void insertParameter(CtClass type)
+ throws CannotCompileException
+ {
+ declaringClass.checkModify();
+ String desc = methodInfo.getDescriptor();
+ String desc2 = Descriptor.insertParameter(type, desc);
+ try {
+ addParameter2(Modifier.isStatic(getModifiers()) ? 0 : 1, type, desc);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+
+ methodInfo.setDescriptor(desc2);
+ }
+
+ /**
+ * Appends a new parameter, which becomes the last parameter.
+ */
+ public void addParameter(CtClass type)
+ throws CannotCompileException
+ {
+ declaringClass.checkModify();
+ String desc = methodInfo.getDescriptor();
+ String desc2 = Descriptor.appendParameter(type, desc);
+ int offset = Modifier.isStatic(getModifiers()) ? 0 : 1;
+ try {
+ addParameter2(offset + Descriptor.paramSize(desc), type, desc);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+
+ methodInfo.setDescriptor(desc2);
+ }
+
+ private void addParameter2(int where, CtClass type, String desc)
+ throws BadBytecode
+ {
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ if (ca != null) {
+ int size = 1;
+ char typeDesc = 'L';
+ int classInfo = 0;
+ if (type.isPrimitive()) {
+ CtPrimitiveType cpt = (CtPrimitiveType)type;
+ size = cpt.getDataSize();
+ typeDesc = cpt.getDescriptor();
+ }
+ else
+ classInfo = methodInfo.getConstPool().addClassInfo(type);
+
+ ca.insertLocalVar(where, size);
+ LocalVariableAttribute va
+ = (LocalVariableAttribute)
+ ca.getAttribute(LocalVariableAttribute.tag);
+ if (va != null)
+ va.shiftIndex(where, size);
+
+ StackMapTable smt = (StackMapTable)ca.getAttribute(StackMapTable.tag);
+ if (smt != null)
+ smt.insertLocal(where, StackMapTable.typeTagOf(typeDesc), classInfo);
+
+ StackMap sm = (StackMap)ca.getAttribute(StackMap.tag);
+ if (sm != null)
+ sm.insertLocal(where, StackMapTable.typeTagOf(typeDesc), classInfo);
+ }
+ }
+
+ /**
+ * Modifies the method/constructor body.
+ *
+ * @param converter specifies how to modify.
+ */
+ public void instrument(CodeConverter converter)
+ throws CannotCompileException
+ {
+ declaringClass.checkModify();
+ ConstPool cp = methodInfo.getConstPool();
+ converter.doit(getDeclaringClass(), methodInfo, cp);
+ }
+
+ /**
+ * Modifies the method/constructor body.
+ *
+ * @param editor specifies how to modify.
+ */
+ public void instrument(ExprEditor editor)
+ throws CannotCompileException
+ {
+ // if the class is not frozen,
+ // does not turn the modified flag on.
+ if (declaringClass.isFrozen())
+ declaringClass.checkModify();
+
+ if (editor.doit(declaringClass, methodInfo))
+ declaringClass.checkModify();
+ }
+
+ /**
+ * Inserts bytecode at the beginning of the body.
+ *
+ * <p>If this object represents a constructor,
+ * the bytecode is inserted before
+ * a constructor in the super class or this class is called.
+ * Therefore, the inserted bytecode is subject to constraints described
+ * in Section 4.8.2 of The Java Virtual Machine Specification (2nd ed).
+ * For example, it cannot access instance fields or methods although
+ * it may assign a value to an instance field directly declared in this
+ * class. Accessing static fields and methods is allowed.
+ * Use <code>insertBeforeBody()</code> in <code>CtConstructor</code>.
+ *
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ * @see CtConstructor#insertBeforeBody(String)
+ */
+ public void insertBefore(String src) throws CannotCompileException {
+ insertBefore(src, true);
+ }
+
+ private void insertBefore(String src, boolean rebuild)
+ throws CannotCompileException
+ {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ if (ca == null)
+ throw new CannotCompileException("no method body");
+
+ CodeIterator iterator = ca.iterator();
+ Javac jv = new Javac(cc);
+ try {
+ int nvars = jv.recordParams(getParameterTypes(),
+ Modifier.isStatic(getModifiers()));
+ jv.recordParamNames(ca, nvars);
+ jv.recordLocalVariables(ca, 0);
+ jv.recordType(getReturnType0());
+ jv.compileStmnt(src);
+ Bytecode b = jv.getBytecode();
+ int stack = b.getMaxStack();
+ int locals = b.getMaxLocals();
+
+ if (stack > ca.getMaxStack())
+ ca.setMaxStack(stack);
+
+ if (locals > ca.getMaxLocals())
+ ca.setMaxLocals(locals);
+
+ int pos = iterator.insertEx(b.get());
+ iterator.insert(b.getExceptionTable(), pos);
+ if (rebuild)
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Inserts bytecode at the end of the body.
+ * The bytecode is inserted just before every return insturction.
+ * It is not executed when an exception is thrown.
+ *
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ */
+ public void insertAfter(String src)
+ throws CannotCompileException
+ {
+ insertAfter(src, false);
+ }
+
+ /**
+ * Inserts bytecode at the end of the body.
+ * The bytecode is inserted just before every return insturction.
+ *
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ * @param asFinally true if the inserted bytecode is executed
+ * not only when the control normally returns
+ * but also when an exception is thrown.
+ * If this parameter is true, the inserted code cannot
+ * access local variables.
+ */
+ public void insertAfter(String src, boolean asFinally)
+ throws CannotCompileException
+ {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ ConstPool pool = methodInfo.getConstPool();
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ if (ca == null)
+ throw new CannotCompileException("no method body");
+
+ CodeIterator iterator = ca.iterator();
+ int retAddr = ca.getMaxLocals();
+ Bytecode b = new Bytecode(pool, 0, retAddr + 1);
+ b.setStackDepth(ca.getMaxStack() + 1);
+ Javac jv = new Javac(b, cc);
+ try {
+ int nvars = jv.recordParams(getParameterTypes(),
+ Modifier.isStatic(getModifiers()));
+ jv.recordParamNames(ca, nvars);
+ CtClass rtype = getReturnType0();
+ int varNo = jv.recordReturnType(rtype, true);
+ jv.recordLocalVariables(ca, 0);
+
+ // finally clause for exceptions
+ int handlerLen = insertAfterHandler(asFinally, b, rtype, varNo,
+ jv, src);
+ // finally clause for normal termination
+ insertAfterAdvice(b, jv, src, pool, rtype, varNo);
+
+ ca.setMaxStack(b.getMaxStack());
+ ca.setMaxLocals(b.getMaxLocals());
+
+ int gapPos = iterator.append(b.get());
+ iterator.append(b.getExceptionTable(), gapPos);
+
+ if (asFinally)
+ ca.getExceptionTable().add(getStartPosOfBody(ca), gapPos, gapPos, 0);
+
+ int gapLen = iterator.getCodeLength() - gapPos - handlerLen;
+ int subr = iterator.getCodeLength() - gapLen;
+
+ while (iterator.hasNext()) {
+ int pos = iterator.next();
+ if (pos >= subr)
+ break;
+
+ int c = iterator.byteAt(pos);
+ if (c == Opcode.ARETURN || c == Opcode.IRETURN
+ || c == Opcode.FRETURN || c == Opcode.LRETURN
+ || c == Opcode.DRETURN || c == Opcode.RETURN) {
+ insertGoto(iterator, subr, pos);
+ subr = iterator.getCodeLength() - gapLen;
+ }
+ }
+
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private void insertAfterAdvice(Bytecode code, Javac jv, String src,
+ ConstPool cp, CtClass rtype, int varNo)
+ throws CompileError
+ {
+ if (rtype == CtClass.voidType) {
+ code.addOpcode(Opcode.ACONST_NULL);
+ code.addAstore(varNo);
+ jv.compileStmnt(src);
+ code.addOpcode(Opcode.RETURN);
+ if (code.getMaxLocals() < 1)
+ code.setMaxLocals(1);
+ }
+ else {
+ code.addStore(varNo, rtype);
+ jv.compileStmnt(src);
+ code.addLoad(varNo, rtype);
+ if (rtype.isPrimitive())
+ code.addOpcode(((CtPrimitiveType)rtype).getReturnOp());
+ else
+ code.addOpcode(Opcode.ARETURN);
+ }
+ }
+
+ /*
+ * assert subr > pos
+ */
+ private void insertGoto(CodeIterator iterator, int subr, int pos)
+ throws BadBytecode
+ {
+ iterator.setMark(subr);
+ // the gap length might be a multiple of 4.
+ iterator.writeByte(Opcode.NOP, pos);
+ boolean wide = subr + 2 - pos > Short.MAX_VALUE;
+ pos = iterator.insertGapAt(pos, wide ? 4 : 2, false).position;
+ int offset = iterator.getMark() - pos;
+ if (wide) {
+ iterator.writeByte(Opcode.GOTO_W, pos);
+ iterator.write32bit(offset, pos + 1);
+ }
+ else if (offset <= Short.MAX_VALUE) {
+ iterator.writeByte(Opcode.GOTO, pos);
+ iterator.write16bit(offset, pos + 1);
+ }
+ else {
+ pos = iterator.insertGapAt(pos, 2, false).position;
+ iterator.writeByte(Opcode.GOTO_W, pos);
+ iterator.write32bit(iterator.getMark() - pos, pos + 1);
+ }
+ }
+
+ /* insert a finally clause
+ */
+ private int insertAfterHandler(boolean asFinally, Bytecode b,
+ CtClass rtype, int returnVarNo,
+ Javac javac, String src)
+ throws CompileError
+ {
+ if (!asFinally)
+ return 0;
+
+ int var = b.getMaxLocals();
+ b.incMaxLocals(1);
+ int pc = b.currentPc();
+ b.addAstore(var); // store an exception
+ if (rtype.isPrimitive()) {
+ char c = ((CtPrimitiveType)rtype).getDescriptor();
+ if (c == 'D') {
+ b.addDconst(0.0);
+ b.addDstore(returnVarNo);
+ }
+ else if (c == 'F') {
+ b.addFconst(0);
+ b.addFstore(returnVarNo);
+ }
+ else if (c == 'J') {
+ b.addLconst(0);
+ b.addLstore(returnVarNo);
+ }
+ else if (c == 'V') {
+ b.addOpcode(Opcode.ACONST_NULL);
+ b.addAstore(returnVarNo);
+ }
+ else { // int, boolean, char, short, ...
+ b.addIconst(0);
+ b.addIstore(returnVarNo);
+ }
+ }
+ else {
+ b.addOpcode(Opcode.ACONST_NULL);
+ b.addAstore(returnVarNo);
+ }
+
+ javac.compileStmnt(src);
+ b.addAload(var);
+ b.addOpcode(Opcode.ATHROW);
+ return b.currentPc() - pc;
+ }
+
+ /* -- OLD version --
+
+ public void insertAfter(String src) throws CannotCompileException {
+ declaringClass.checkModify();
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ CodeIterator iterator = ca.iterator();
+ Bytecode b = new Bytecode(methodInfo.getConstPool(),
+ ca.getMaxStack(), ca.getMaxLocals());
+ b.setStackDepth(ca.getMaxStack());
+ Javac jv = new Javac(b, declaringClass);
+ try {
+ jv.recordParams(getParameterTypes(),
+ Modifier.isStatic(getModifiers()));
+ CtClass rtype = getReturnType0();
+ int varNo = jv.recordReturnType(rtype, true);
+ boolean isVoid = rtype == CtClass.voidType;
+ if (isVoid) {
+ b.addOpcode(Opcode.ACONST_NULL);
+ b.addAstore(varNo);
+ jv.compileStmnt(src);
+ }
+ else {
+ b.addStore(varNo, rtype);
+ jv.compileStmnt(src);
+ b.addLoad(varNo, rtype);
+ }
+
+ byte[] code = b.get();
+ ca.setMaxStack(b.getMaxStack());
+ ca.setMaxLocals(b.getMaxLocals());
+ while (iterator.hasNext()) {
+ int pos = iterator.next();
+ int c = iterator.byteAt(pos);
+ if (c == Opcode.ARETURN || c == Opcode.IRETURN
+ || c == Opcode.FRETURN || c == Opcode.LRETURN
+ || c == Opcode.DRETURN || c == Opcode.RETURN)
+ iterator.insert(pos, code);
+ }
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+ */
+
+ /**
+ * Adds a catch clause that handles an exception thrown in the
+ * body. The catch clause must end with a return or throw statement.
+ *
+ * @param src the source code representing the catch clause.
+ * It must be a single statement or block.
+ * @param exceptionType the type of the exception handled by the
+ * catch clause.
+ */
+ public void addCatch(String src, CtClass exceptionType)
+ throws CannotCompileException
+ {
+ addCatch(src, exceptionType, "$e");
+ }
+
+ /**
+ * Adds a catch clause that handles an exception thrown in the
+ * body. The catch clause must end with a return or throw statement.
+ *
+ * @param src the source code representing the catch clause.
+ * It must be a single statement or block.
+ * @param exceptionType the type of the exception handled by the
+ * catch clause.
+ * @param exceptionName the name of the variable containing the
+ * caught exception, for example,
+ * <code>$e</code>.
+ */
+ public void addCatch(String src, CtClass exceptionType,
+ String exceptionName)
+ throws CannotCompileException
+ {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ ConstPool cp = methodInfo.getConstPool();
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ CodeIterator iterator = ca.iterator();
+ Bytecode b = new Bytecode(cp, ca.getMaxStack(), ca.getMaxLocals());
+ b.setStackDepth(1);
+ Javac jv = new Javac(b, cc);
+ try {
+ jv.recordParams(getParameterTypes(),
+ Modifier.isStatic(getModifiers()));
+ int var = jv.recordVariable(exceptionType, exceptionName);
+ b.addAstore(var);
+ jv.compileStmnt(src);
+
+ int stack = b.getMaxStack();
+ int locals = b.getMaxLocals();
+
+ if (stack > ca.getMaxStack())
+ ca.setMaxStack(stack);
+
+ if (locals > ca.getMaxLocals())
+ ca.setMaxLocals(locals);
+
+ int len = iterator.getCodeLength();
+ int pos = iterator.append(b.get());
+ ca.getExceptionTable().add(getStartPosOfBody(ca), len, len,
+ cp.addClassInfo(exceptionType));
+ iterator.append(b.getExceptionTable(), pos);
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ } catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /* CtConstructor overrides this method.
+ */
+ int getStartPosOfBody(CodeAttribute ca) throws CannotCompileException {
+ return 0;
+ }
+
+ /**
+ * Inserts bytecode at the specified line in the body.
+ * It is equivalent to:
+ *
+ * <br><code>insertAt(lineNum, true, src)</code>
+ *
+ * <br>See this method as well.
+ *
+ * @param lineNum the line number. The bytecode is inserted at the
+ * beginning of the code at the line specified by this
+ * line number.
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ * @return the line number at which the bytecode has been inserted.
+ *
+ * @see CtBehavior#insertAt(int,boolean,String)
+ */
+ public int insertAt(int lineNum, String src)
+ throws CannotCompileException
+ {
+ return insertAt(lineNum, true, src);
+ }
+
+ /**
+ * Inserts bytecode at the specified line in the body.
+ *
+ * <p>If there is not
+ * a statement at the specified line, the bytecode might be inserted
+ * at the line including the first statement after that line specified.
+ * For example, if there is only a closing brace at that line, the
+ * bytecode would be inserted at another line below.
+ * To know exactly where the bytecode will be inserted, call with
+ * <code>modify</code> set to <code>false</code>.
+ *
+ * @param lineNum the line number. The bytecode is inserted at the
+ * beginning of the code at the line specified by this
+ * line number.
+ * @param modify if false, this method does not insert the bytecode.
+ * It instead only returns the line number at which
+ * the bytecode would be inserted.
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ * If modify is false, the value of src can be null.
+ * @return the line number at which the bytecode has been inserted.
+ */
+ public int insertAt(int lineNum, boolean modify, String src)
+ throws CannotCompileException
+ {
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ if (ca == null)
+ throw new CannotCompileException("no method body");
+
+ LineNumberAttribute ainfo
+ = (LineNumberAttribute)ca.getAttribute(LineNumberAttribute.tag);
+ if (ainfo == null)
+ throw new CannotCompileException("no line number info");
+
+ LineNumberAttribute.Pc pc = ainfo.toNearPc(lineNum);
+ lineNum = pc.line;
+ int index = pc.index;
+ if (!modify)
+ return lineNum;
+
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ CodeIterator iterator = ca.iterator();
+ Javac jv = new Javac(cc);
+ try {
+ jv.recordLocalVariables(ca, index);
+ jv.recordParams(getParameterTypes(),
+ Modifier.isStatic(getModifiers()));
+ jv.setMaxLocals(ca.getMaxLocals());
+ jv.compileStmnt(src);
+ Bytecode b = jv.getBytecode();
+ int locals = b.getMaxLocals();
+ int stack = b.getMaxStack();
+ ca.setMaxLocals(locals);
+
+ /* We assume that there is no values in the operand stack
+ * at the position where the bytecode is inserted.
+ */
+ if (stack > ca.getMaxStack())
+ ca.setMaxStack(stack);
+
+ index = iterator.insertAt(index, b.get());
+ iterator.insert(b.getExceptionTable(), index);
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ return lineNum;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+}
diff --git a/src/main/javassist/CtClass.java b/src/main/javassist/CtClass.java
new file mode 100644
index 0000000..e805c20
--- /dev/null
+++ b/src/main/javassist/CtClass.java
@@ -0,0 +1,1440 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URL;
+import java.security.ProtectionDomain;
+import java.util.Collection;
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.Opcode;
+import javassist.expr.ExprEditor;
+
+/* Note:
+ *
+ * This class is an abstract class and several methods just return null
+ * or throw an exception. Those methods are overridden in subclasses
+ * of this class. Read the source code of CtClassType if you are
+ * interested in the implementation of Javassist.
+ *
+ * Subclasses of CtClass are CtClassType, CtPrimitiveType, and CtArray.
+ */
+
+/**
+ * An instance of <code>CtClass</code> represents a class.
+ * It is obtained from <code>ClassPool</code>.
+ *
+ * @see ClassPool#get(String)
+ */
+public abstract class CtClass {
+ protected String qualifiedName;
+
+ /**
+ * The version number of this release.
+ */
+ public static final String version = "3.14.0.GA";
+
+ /**
+ * Prints the version number and the copyright notice.
+ *
+ * <p>The following command invokes this method:
+ *
+ * <ul><pre>java -jar javassist.jar</pre></ul>
+ */
+ public static void main(String[] args) {
+ System.out.println("Javassist version " + CtClass.version);
+ System.out.println("Copyright (C) 1999-2010 Shigeru Chiba."
+ + " All Rights Reserved.");
+ }
+
+ static final String javaLangObject = "java.lang.Object";
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>boolean</code> type.
+ */
+ public static CtClass booleanType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>char</code> type.
+ */
+ public static CtClass charType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>byte</code> type.
+ */
+ public static CtClass byteType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>short</code> type.
+ */
+ public static CtClass shortType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>int</code> type.
+ */
+ public static CtClass intType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>long</code> type.
+ */
+ public static CtClass longType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>float</code> type.
+ */
+ public static CtClass floatType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>double</code> type.
+ */
+ public static CtClass doubleType;
+
+ /**
+ * The <code>CtClass</code> object representing
+ * the <code>void</code> type.
+ */
+ public static CtClass voidType;
+
+ static CtClass[] primitiveTypes;
+
+ static {
+ primitiveTypes = new CtClass[9];
+
+ booleanType =
+ new CtPrimitiveType("boolean", 'Z', "java.lang.Boolean",
+ "booleanValue", "()Z", Opcode.IRETURN,
+ Opcode.T_BOOLEAN, 1);
+ primitiveTypes[0] = booleanType;
+
+ charType = new CtPrimitiveType("char", 'C', "java.lang.Character",
+ "charValue", "()C", Opcode.IRETURN,
+ Opcode.T_CHAR, 1);
+ primitiveTypes[1] = charType;
+
+ byteType = new CtPrimitiveType("byte", 'B', "java.lang.Byte",
+ "byteValue", "()B", Opcode.IRETURN,
+ Opcode.T_BYTE, 1);
+ primitiveTypes[2] = byteType;
+
+ shortType = new CtPrimitiveType("short", 'S', "java.lang.Short",
+ "shortValue", "()S", Opcode.IRETURN,
+ Opcode.T_SHORT, 1);
+ primitiveTypes[3] = shortType;
+
+ intType = new CtPrimitiveType("int", 'I', "java.lang.Integer",
+ "intValue", "()I", Opcode.IRETURN,
+ Opcode.T_INT, 1);
+ primitiveTypes[4] = intType;
+
+ longType = new CtPrimitiveType("long", 'J', "java.lang.Long",
+ "longValue", "()J", Opcode.LRETURN,
+ Opcode.T_LONG, 2);
+ primitiveTypes[5] = longType;
+
+ floatType = new CtPrimitiveType("float", 'F', "java.lang.Float",
+ "floatValue", "()F", Opcode.FRETURN,
+ Opcode.T_FLOAT, 1);
+ primitiveTypes[6] = floatType;
+
+ doubleType = new CtPrimitiveType("double", 'D', "java.lang.Double",
+ "doubleValue", "()D", Opcode.DRETURN,
+ Opcode.T_DOUBLE, 2);
+ primitiveTypes[7] = doubleType;
+
+ voidType = new CtPrimitiveType("void", 'V', "java.lang.Void",
+ null, null, Opcode.RETURN, 0, 0);
+ primitiveTypes[8] = voidType;
+ }
+
+ protected CtClass(String name) {
+ qualifiedName = name;
+ }
+
+ /**
+ * Converts the object to a string.
+ */
+ public String toString() {
+ StringBuffer buf = new StringBuffer(getClass().getName());
+ buf.append("@");
+ buf.append(Integer.toHexString(hashCode()));
+ buf.append("[");
+ extendToString(buf);
+ buf.append("]");
+ return buf.toString();
+ }
+
+ /**
+ * Implemented in subclasses to add to the {@link #toString()} result.
+ * Subclasses should put a space before each token added to the buffer.
+ */
+ protected void extendToString(StringBuffer buffer) {
+ buffer.append(getName());
+ }
+
+ /**
+ * Returns a <code>ClassPool</code> for this class.
+ */
+ public ClassPool getClassPool() { return null; }
+
+ /**
+ * Returns a class file for this class.
+ *
+ * <p>This method is not available if <code>isFrozen()</code>
+ * is true.
+ */
+ public ClassFile getClassFile() {
+ checkModify();
+ return getClassFile2();
+ }
+
+ /**
+ * Returns a class file for this class (read only).
+ * Normal applications do not need calling this method. Use
+ * <code>getClassFile()</code>.
+ *
+ * <p>The <code>ClassFile</code> object obtained by this method
+ * is read only. Changes to this object might not be reflected
+ * on a class file generated by <code>toBytecode()</code>,
+ * <code>toClass()</code>, etc.
+ *
+ * <p>This method is available even if <code>isFrozen()</code>
+ * is true. However, if the class is frozen, it might be also
+ * pruned.
+ *
+ * @see CtClass#getClassFile()
+ * @see CtClass#isFrozen()
+ * @see CtClass#prune()
+ */
+ public ClassFile getClassFile2() { return null; }
+
+ /**
+ * Undocumented method. Do not use; internal-use only.
+ */
+ public javassist.compiler.AccessorMaker getAccessorMaker() {
+ return null;
+ }
+
+ /**
+ * Returns the uniform resource locator (URL) of the class file.
+ */
+ public URL getURL() throws NotFoundException {
+ throw new NotFoundException(getName());
+ }
+
+ /**
+ * Returns true if the definition of the class has been modified.
+ */
+ public boolean isModified() { return false; }
+
+ /**
+ * Returns true if the class has been loaded or written out
+ * and thus it cannot be modified any more.
+ *
+ * @see #defrost()
+ * @see #detach()
+ */
+ public boolean isFrozen() { return true; }
+
+ /**
+ * Makes the class frozen.
+ *
+ * @see #isFrozen()
+ * @see #defrost()
+ * @since 3.6
+ */
+ public void freeze() {}
+
+ /* Note: this method is overridden by CtClassType
+ */
+ void checkModify() throws RuntimeException {
+ if (isFrozen())
+ throw new RuntimeException(getName() + " class is frozen");
+
+ // isModified() must return true after this method is invoked.
+ }
+
+ /**
+ * Defrosts the class so that the class can be modified again.
+ *
+ * <p>To avoid changes that will be never reflected,
+ * the class is frozen to be unmodifiable if it is loaded or
+ * written out. This method should be called only in a case
+ * that the class will be reloaded or written out later again.
+ *
+ * <p>If <code>defrost()</code> will be called later, pruning
+ * must be disallowed in advance.
+ *
+ * @see #isFrozen()
+ * @see #stopPruning(boolean)
+ * @see #detach()
+ */
+ public void defrost() {
+ throw new RuntimeException("cannot defrost " + getName());
+ }
+
+ /**
+ * Returns <code>true</code> if this object represents a primitive
+ * Java type: boolean, byte, char, short, int, long, float, double,
+ * or void.
+ */
+ public boolean isPrimitive() { return false; }
+
+ /**
+ * Returns <code>true</code> if this object represents an array type.
+ */
+ public boolean isArray() {
+ return false;
+ }
+
+ /**
+ * If this object represents an array, this method returns the component
+ * type of the array. Otherwise, it returns <code>null</code>.
+ */
+ public CtClass getComponentType() throws NotFoundException {
+ return null;
+ }
+
+ /**
+ * Returns <code>true</code> if this class extends or implements
+ * <code>clazz</code>. It also returns <code>true</code> if
+ * this class is the same as <code>clazz</code>.
+ */
+ public boolean subtypeOf(CtClass clazz) throws NotFoundException {
+ return this == clazz || getName().equals(clazz.getName());
+ }
+
+ /**
+ * Obtains the fully-qualified name of the class.
+ */
+ public String getName() { return qualifiedName; }
+
+ /**
+ * Obtains the not-qualified class name.
+ */
+ public final String getSimpleName() {
+ String qname = qualifiedName;
+ int index = qname.lastIndexOf('.');
+ if (index < 0)
+ return qname;
+ else
+ return qname.substring(index + 1);
+ }
+
+ /**
+ * Obtains the package name. It may be <code>null</code>.
+ */
+ public final String getPackageName() {
+ String qname = qualifiedName;
+ int index = qname.lastIndexOf('.');
+ if (index < 0)
+ return null;
+ else
+ return qname.substring(0, index);
+ }
+
+ /**
+ * Sets the class name
+ *
+ * @param name fully-qualified name
+ */
+ public void setName(String name) {
+ checkModify();
+ if (name != null)
+ qualifiedName = name;
+ }
+
+ /**
+ * Substitutes <code>newName</code> for all occurrences of a class
+ * name <code>oldName</code> in the class file.
+ *
+ * @param oldName replaced class name
+ * @param newName substituted class name
+ */
+ public void replaceClassName(String oldName, String newName) {
+ checkModify();
+ }
+
+ /**
+ * Changes class names appearing in the class file according to the
+ * given <code>map</code>.
+ *
+ * <p>All the class names appearing in the class file are tested
+ * with <code>map</code> to determine whether each class name is
+ * replaced or not. Thus this method can be used for collecting
+ * all the class names in the class file. To do that, first define
+ * a subclass of <code>ClassMap</code> so that <code>get()</code>
+ * records all the given parameters. Then, make an instance of
+ * that subclass as an empty hash-table. Finally, pass that instance
+ * to this method. After this method finishes, that instance would
+ * contain all the class names appearing in the class file.
+ *
+ * @param map the hashtable associating replaced class names
+ * with substituted names.
+ */
+ public void replaceClassName(ClassMap map) {
+ checkModify();
+ }
+
+ /**
+ * Returns a collection of the names of all the classes
+ * referenced in this class.
+ * That collection includes the name of this class.
+ *
+ * <p>This method may return <code>null</code>.
+ *
+ * @return a <code>Collection<String></code> object.
+ */
+ public synchronized Collection getRefClasses() {
+ ClassFile cf = getClassFile2();
+ if (cf != null) {
+ ClassMap cm = new ClassMap() {
+ public void put(String oldname, String newname) {
+ put0(oldname, newname);
+ }
+
+ public Object get(Object jvmClassName) {
+ String n = toJavaName((String)jvmClassName);
+ put0(n, n);
+ return null;
+ }
+
+ public void fix(String name) {}
+ };
+ cf.getRefClasses(cm);
+ return cm.values();
+ }
+ else
+ return null;
+ }
+
+ /**
+ * Determines whether this object represents a class or an interface.
+ * It returns <code>true</code> if this object represents an interface.
+ */
+ public boolean isInterface() {
+ return false;
+ }
+
+ /**
+ * Determines whether this object represents an annotation type.
+ * It returns <code>true</code> if this object represents an annotation type.
+ *
+ * @since 3.2
+ */
+ public boolean isAnnotation() {
+ return false;
+ }
+
+ /**
+ * Determines whether this object represents an enum.
+ * It returns <code>true</code> if this object represents an enum.
+ *
+ * @since 3.2
+ */
+ public boolean isEnum() {
+ return false;
+ }
+
+ /**
+ * Returns the modifiers for this class, encoded in an integer.
+ * For decoding, use <code>javassist.Modifier</code>.
+ *
+ * <p>If the class is a static nested class (a.k.a. static inner class),
+ * the returned modifiers include <code>Modifier.STATIC</code>.
+ *
+ * @see Modifier
+ */
+ public int getModifiers() {
+ return 0;
+ }
+
+ /**
+ * Returns true if the class has the specified annotation class.
+ *
+ * @param clz the annotation class.
+ * @return <code>true</code> if the annotation is found, otherwise <code>false</code>.
+ * @since 3.11
+ */
+ public boolean hasAnnotation(Class clz) {
+ return false;
+ }
+
+ /**
+ * Returns the annotation if the class has the specified annotation class.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this class, an <code>Author</code> object is returned.
+ * The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @param clz the annotation class.
+ * @return the annotation if found, otherwise <code>null</code>.
+ * @since 3.11
+ */
+ public Object getAnnotation(Class clz) throws ClassNotFoundException {
+ return null;
+ }
+
+ /**
+ * Returns the annotations associated with this class.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this class, the returned array contains an <code>Author</code>
+ * object. The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @return an array of annotation-type objects.
+ * @see CtMember#getAnnotations()
+ * @since 3.1
+ */
+ public Object[] getAnnotations() throws ClassNotFoundException {
+ return new Object[0];
+ }
+
+ /**
+ * Returns the annotations associated with this class.
+ * This method is equivalent to <code>getAnnotations()</code>
+ * except that, if any annotations are not on the classpath,
+ * they are not included in the returned array.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAnnotations()
+ * @see CtMember#getAvailableAnnotations()
+ * @since 3.3
+ */
+ public Object[] getAvailableAnnotations(){
+ return new Object[0];
+ }
+
+ /**
+ * Returns an array of nested classes declared in the class.
+ * Nested classes are inner classes, anonymous classes, local classes,
+ * and static nested classes.
+ *
+ * @since 3.2
+ */
+ public CtClass[] getNestedClasses() throws NotFoundException {
+ return new CtClass[0];
+ }
+
+ /**
+ * Sets the modifiers.
+ *
+ * <p>If the class is a nested class, this method also modifies
+ * the class declaring that nested class (i.e. the enclosing
+ * class is modified).
+ *
+ * @param mod modifiers encoded by
+ * <code>javassist.Modifier</code>
+ * @see Modifier
+ */
+ public void setModifiers(int mod) {
+ checkModify();
+ }
+
+ /**
+ * Determines whether the class directly or indirectly extends
+ * the given class. If this class extends a class A and
+ * the class A extends a class B, then subclassof(B) returns true.
+ *
+ * <p>This method returns true if the given class is identical to
+ * the class represented by this object.
+ */
+ public boolean subclassOf(CtClass superclass) {
+ return false;
+ }
+
+ /**
+ * Obtains the class object representing the superclass of the
+ * class.
+ * It returns null if this object represents the
+ * <code>java.lang.Object</code> class and thus it does not have
+ * the super class.
+ *
+ * <p>If this object represents an interface, this method
+ * always returns the <code>java.lang.Object</code> class.
+ * To obtain the super interfaces
+ * extended by that interface, call <code>getInterfaces()</code>.
+ */
+ public CtClass getSuperclass() throws NotFoundException {
+ return null;
+ }
+
+ /**
+ * Changes a super class unless this object represents an interface.
+ * The new super class must be compatible with the old one; for example,
+ * it should inherit from the old super class.
+ *
+ * <p>If this object represents an interface, this method is equivalent
+ * to <code>addInterface()</code>; it appends <code>clazz</code> to
+ * the list of the super interfaces extended by that interface.
+ * Note that an interface can extend multiple super interfaces.
+ *
+ * @see #replaceClassName(String, String)
+ * @see #replaceClassName(ClassMap)
+ */
+ public void setSuperclass(CtClass clazz) throws CannotCompileException {
+ checkModify();
+ }
+
+ /**
+ * Obtains the class objects representing the interfaces implemented
+ * by the class or, if this object represents an interface, the interfaces
+ * extended by that interface.
+ */
+ public CtClass[] getInterfaces() throws NotFoundException {
+ return new CtClass[0];
+ }
+
+ /**
+ * Sets implemented interfaces. If this object represents an interface,
+ * this method sets the interfaces extended by that interface.
+ *
+ * @param list a list of the <code>CtClass</code> objects
+ * representing interfaces, or
+ * <code>null</code> if the class implements
+ * no interfaces.
+ */
+ public void setInterfaces(CtClass[] list) {
+ checkModify();
+ }
+
+ /**
+ * Adds an interface.
+ *
+ * @param anInterface the added interface.
+ */
+ public void addInterface(CtClass anInterface) {
+ checkModify();
+ }
+
+ /**
+ * If this class is a member class or interface of another class,
+ * then the class enclosing this class is returned.
+ *
+ * @return null if this class is a top-level class or an anonymous class.
+ */
+ public CtClass getDeclaringClass() throws NotFoundException {
+ return null;
+ }
+
+ /**
+ * Returns the immediately enclosing method of this class.
+ * This method works only with JDK 1.5 or later.
+ *
+ * @return null if this class is not a local class or an anonymous
+ * class.
+ */
+ public CtMethod getEnclosingMethod() throws NotFoundException {
+ return null;
+ }
+
+ /**
+ * Makes a new public nested class. If this method is called,
+ * the <code>CtClass</code>, which encloses the nested class, is modified
+ * since a class file includes a list of nested classes.
+ *
+ * <p>The current implementation only supports a static nested class.
+ * <code>isStatic</code> must be true.
+ *
+ * @param name the simple name of the nested class.
+ * @param isStatic true if the nested class is static.
+ */
+ public CtClass makeNestedClass(String name, boolean isStatic) {
+ throw new RuntimeException(getName() + " is not a class");
+ }
+
+ /**
+ * Returns an array containing <code>CtField</code> objects
+ * representing all the non-private fields of the class.
+ * That array includes non-private fields inherited from the
+ * superclasses.
+ */
+ public CtField[] getFields() { return new CtField[0]; }
+
+ /**
+ * Returns the field with the specified name. The returned field
+ * may be a private field declared in a super class or interface.
+ */
+ public CtField getField(String name) throws NotFoundException {
+ return getField(name, null);
+ }
+
+ /**
+ * Returns the field with the specified name and type. The returned field
+ * may be a private field declared in a super class or interface.
+ * Unlike Java, the JVM allows a class to have
+ * multiple fields with the same name but different types.
+ *
+ * @param name the field name.
+ * @param desc the type descriptor of the field. It is available by
+ * {@link CtField#getSignature()}.
+ * @see CtField#getSignature()
+ */
+ public CtField getField(String name, String desc) throws NotFoundException {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * @return null if the specified field is not found.
+ */
+ CtField getField2(String name, String desc) { return null; }
+
+ /**
+ * Gets all the fields declared in the class. The inherited fields
+ * are not included.
+ *
+ * <p>Note: the result does not include inherited fields.
+ */
+ public CtField[] getDeclaredFields() { return new CtField[0]; }
+
+ /**
+ * Retrieves the field with the specified name among the fields
+ * declared in the class.
+ *
+ * <p>Note: this method does not search the super classes.
+ */
+ public CtField getDeclaredField(String name) throws NotFoundException {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * Retrieves the field with the specified name and type among the fields
+ * declared in the class. Unlike Java, the JVM allows a class to have
+ * multiple fields with the same name but different types.
+ *
+ * <p>Note: this method does not search the super classes.
+ *
+ * @param name the field name.
+ * @param desc the type descriptor of the field. It is available by
+ * {@link CtField#getSignature()}.
+ * @see CtField#getSignature()
+ */
+ public CtField getDeclaredField(String name, String desc) throws NotFoundException {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * Gets all the constructors and methods declared in the class.
+ */
+ public CtBehavior[] getDeclaredBehaviors() {
+ return new CtBehavior[0];
+ }
+
+ /**
+ * Returns an array containing <code>CtConstructor</code> objects
+ * representing all the non-private constructors of the class.
+ */
+ public CtConstructor[] getConstructors() {
+ return new CtConstructor[0];
+ }
+
+ /**
+ * Returns the constructor with the given signature,
+ * which is represented by a character string
+ * called method descriptor.
+ * For details of the method descriptor, see the JVM specification
+ * or <code>javassist.bytecode.Descriptor</code>.
+ *
+ * @param desc method descriptor
+ * @see javassist.bytecode.Descriptor
+ */
+ public CtConstructor getConstructor(String desc)
+ throws NotFoundException
+ {
+ throw new NotFoundException("no such constructor");
+ }
+
+ /**
+ * Gets all the constructors declared in the class.
+ *
+ * @see javassist.CtConstructor
+ */
+ public CtConstructor[] getDeclaredConstructors() {
+ return new CtConstructor[0];
+ }
+
+ /**
+ * Returns a constructor receiving the specified parameters.
+ *
+ * @param params parameter types.
+ */
+ public CtConstructor getDeclaredConstructor(CtClass[] params)
+ throws NotFoundException
+ {
+ String desc = Descriptor.ofConstructor(params);
+ return getConstructor(desc);
+ }
+
+ /**
+ * Gets the class initializer (static constructor)
+ * declared in the class.
+ * This method returns <code>null</code> if
+ * no class initializer is not declared.
+ *
+ * @see #makeClassInitializer()
+ * @see javassist.CtConstructor
+ */
+ public CtConstructor getClassInitializer() {
+ return null;
+ }
+
+ /**
+ * Returns an array containing <code>CtMethod</code> objects
+ * representing all the non-private methods of the class.
+ * That array includes non-private methods inherited from the
+ * superclasses.
+ */
+ public CtMethod[] getMethods() {
+ return new CtMethod[0];
+ }
+
+ /**
+ * Returns the method with the given name and signature.
+ * The returned method may be declared in a super class.
+ * The method signature is represented by a character string
+ * called method descriptor,
+ * which is defined in the JVM specification.
+ *
+ * @param name method name
+ * @param desc method descriptor
+ * @see CtBehavior#getSignature()
+ * @see javassist.bytecode.Descriptor
+ */
+ public CtMethod getMethod(String name, String desc)
+ throws NotFoundException
+ {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * Gets all methods declared in the class. The inherited methods
+ * are not included.
+ *
+ * @see javassist.CtMethod
+ */
+ public CtMethod[] getDeclaredMethods() {
+ return new CtMethod[0];
+ }
+
+ /**
+ * Retrieves the method with the specified name and parameter types
+ * among the methods declared in the class.
+ *
+ * <p>Note: this method does not search the superclasses.
+ *
+ * @param name method name
+ * @param params parameter types
+ * @see javassist.CtMethod
+ */
+ public CtMethod getDeclaredMethod(String name, CtClass[] params)
+ throws NotFoundException
+ {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * Retrieves the method with the specified name among the methods
+ * declared in the class. If there are multiple methods with
+ * the specified name, then this method returns one of them.
+ *
+ * <p>Note: this method does not search the superclasses.
+ *
+ * @see javassist.CtMethod
+ */
+ public CtMethod getDeclaredMethod(String name) throws NotFoundException {
+ throw new NotFoundException(name);
+ }
+
+ /**
+ * Makes an empty class initializer (static constructor).
+ * If the class already includes a class initializer,
+ * this method returns it.
+ *
+ * @see #getClassInitializer()
+ */
+ public CtConstructor makeClassInitializer()
+ throws CannotCompileException
+ {
+ throw new CannotCompileException("not a class");
+ }
+
+ /**
+ * Adds a constructor. To add a class initializer (static constructor),
+ * call <code>makeClassInitializer()</code>.
+ *
+ * @see #makeClassInitializer()
+ */
+ public void addConstructor(CtConstructor c)
+ throws CannotCompileException
+ {
+ checkModify();
+ }
+
+ /**
+ * Removes a constructor declared in this class.
+ *
+ * @param c removed constructor.
+ * @throws NotFoundException if the constructor is not found.
+ */
+ public void removeConstructor(CtConstructor c) throws NotFoundException {
+ checkModify();
+ }
+
+ /**
+ * Adds a method.
+ */
+ public void addMethod(CtMethod m) throws CannotCompileException {
+ checkModify();
+ }
+
+ /**
+ * Removes a method declared in this class.
+ *
+ * @param m removed method.
+ * @throws NotFoundException if the method is not found.
+ */
+ public void removeMethod(CtMethod m) throws NotFoundException {
+ checkModify();
+ }
+
+ /**
+ * Adds a field.
+ *
+ * <p>The <code>CtField</code> belonging to another
+ * <code>CtClass</code> cannot be directly added to this class.
+ * Only a field created for this class can be added.
+ *
+ * @see javassist.CtField#CtField(CtField,CtClass)
+ */
+ public void addField(CtField f) throws CannotCompileException {
+ addField(f, (CtField.Initializer)null);
+ }
+
+ /**
+ * Adds a field with an initial value.
+ *
+ * <p>The <code>CtField</code> belonging to another
+ * <code>CtClass</code> cannot be directly added to this class.
+ * Only a field created for this class can be added.
+ *
+ * <p>The initial value is given as an expression written in Java.
+ * Any regular Java expression can be used for specifying the initial
+ * value. The followings are examples.
+ *
+ * <ul><pre>
+ * cc.addField(f, "0") // the initial value is 0.
+ * cc.addField(f, "i + 1") // i + 1.
+ * cc.addField(f, "new Point()"); // a Point object.
+ * </pre></ul>
+ *
+ * <p>Here, the type of variable <code>cc</code> is <code>CtClass</code>.
+ * The type of <code>f</code> is <code>CtField</code>.
+ *
+ * <p>Note: do not change the modifier of the field
+ * (in particular, do not add or remove <code>static</code>
+ * to/from the modifier)
+ * after it is added to the class by <code>addField()</code>.
+ *
+ * @param init an expression for the initial value.
+ *
+ * @see javassist.CtField.Initializer#byExpr(String)
+ * @see javassist.CtField#CtField(CtField,CtClass)
+ */
+ public void addField(CtField f, String init)
+ throws CannotCompileException
+ {
+ checkModify();
+ }
+
+ /**
+ * Adds a field with an initial value.
+ *
+ * <p>The <code>CtField</code> belonging to another
+ * <code>CtClass</code> cannot be directly added to this class.
+ * Only a field created for this class can be added.
+ *
+ * <p>For example,
+ *
+ * <ul><pre>
+ * CtClass cc = ...;
+ * addField(new CtField(CtClass.intType, "i", cc),
+ * CtField.Initializer.constant(1));
+ * </pre></ul>
+ *
+ * <p>This code adds an <code>int</code> field named "i". The
+ * initial value of this field is 1.
+ *
+ * @param init specifies the initial value of the field.
+ *
+ * @see javassist.CtField#CtField(CtField,CtClass)
+ */
+ public void addField(CtField f, CtField.Initializer init)
+ throws CannotCompileException
+ {
+ checkModify();
+ }
+
+ /**
+ * Removes a field declared in this class.
+ *
+ * @param f removed field.
+ * @throws NotFoundException if the field is not found.
+ */
+ public void removeField(CtField f) throws NotFoundException {
+ checkModify();
+ }
+
+ /**
+ * Obtains an attribute with the given name.
+ * If that attribute is not found in the class file, this
+ * method returns null.
+ *
+ * <p>This is a convenient method mainly for obtaining
+ * a user-defined attribute. For dealing with attributes, see the
+ * <code>javassist.bytecode</code> package. For example, the following
+ * expression returns all the attributes of a class file.
+ *
+ * <ul><pre>
+ * getClassFile().getAttributes()
+ * </pre></ul>
+ *
+ * @param name attribute name
+ * @see javassist.bytecode.AttributeInfo
+ */
+ public byte[] getAttribute(String name) {
+ return null;
+ }
+
+ /**
+ * Adds a named attribute.
+ * An arbitrary data (smaller than 64Kb) can be saved in the class
+ * file. Some attribute name are reserved by the JVM.
+ * The attributes with the non-reserved names are ignored when a
+ * class file is loaded into the JVM.
+ * If there is already an attribute with
+ * the same name, this method substitutes the new one for it.
+ *
+ * <p>This is a convenient method mainly for adding
+ * a user-defined attribute. For dealing with attributes, see the
+ * <code>javassist.bytecode</code> package. For example, the following
+ * expression adds an attribute <code>info</code> to a class file.
+ *
+ * <ul><pre>
+ * getClassFile().addAttribute(info)
+ * </pre></ul>
+ *
+ * @param name attribute name
+ * @param data attribute value
+ * @see javassist.bytecode.AttributeInfo
+ */
+ public void setAttribute(String name, byte[] data) {
+ checkModify();
+ }
+
+ /**
+ * Applies the given converter to all methods and constructors
+ * declared in the class. This method calls <code>instrument()</code>
+ * on every <code>CtMethod</code> and <code>CtConstructor</code> object
+ * in the class.
+ *
+ * @param converter specifies how to modify.
+ */
+ public void instrument(CodeConverter converter)
+ throws CannotCompileException
+ {
+ checkModify();
+ }
+
+ /**
+ * Modifies the bodies of all methods and constructors
+ * declared in the class. This method calls <code>instrument()</code>
+ * on every <code>CtMethod</code> and <code>CtConstructor</code> object
+ * in the class.
+ *
+ * @param editor specifies how to modify.
+ */
+ public void instrument(ExprEditor editor)
+ throws CannotCompileException
+ {
+ checkModify();
+ }
+
+ /**
+ * Converts this class to a <code>java.lang.Class</code> object.
+ * Once this method is called, further modifications are not
+ * allowed any more.
+ * To load the class, this method uses the context class loader
+ * of the current thread. If the program is running on some application
+ * server, the context class loader might be inappropriate to load the
+ * class.
+ *
+ * <p>This method is provided for convenience. If you need more
+ * complex functionality, you should write your own class loader.
+ *
+ * <p>Note: this method calls <code>toClass()</code>
+ * in <code>ClassPool</code>.
+ *
+ * <p><b>Warining:</b> A Class object returned by this method may not
+ * work with a security manager or a signed jar file because a
+ * protection domain is not specified.
+ *
+ * @see #toClass(java.lang.ClassLoader,ProtectionDomain)
+ * @see ClassPool#toClass(CtClass)
+ */
+ public Class toClass() throws CannotCompileException {
+ return getClassPool().toClass(this);
+ }
+
+ /**
+ * Converts this class to a <code>java.lang.Class</code> object.
+ * Once this method is called, further modifications are not allowed
+ * any more.
+ *
+ * <p>The class file represented by this <code>CtClass</code> is
+ * loaded by the given class loader to construct a
+ * <code>java.lang.Class</code> object. Since a private method
+ * on the class loader is invoked through the reflection API,
+ * the caller must have permissions to do that.
+ *
+ * <p>An easy way to obtain <code>ProtectionDomain</code> object is
+ * to call <code>getProtectionDomain()</code>
+ * in <code>java.lang.Class</code>. It returns the domain that
+ * the class belongs to.
+ *
+ * <p>This method is provided for convenience. If you need more
+ * complex functionality, you should write your own class loader.
+ *
+ * <p>Note: this method calls <code>toClass()</code>
+ * in <code>ClassPool</code>.
+ *
+ * @param loader the class loader used to load this class.
+ * If it is null, the class loader returned by
+ * {@link ClassPool#getClassLoader()} is used.
+ * @param domain the protection domain that the class belongs to.
+ * If it is null, the default domain created
+ * by <code>java.lang.ClassLoader</code> is used.
+ * @see ClassPool#toClass(CtClass,java.lang.ClassLoader)
+ * @since 3.3
+ */
+ public Class toClass(ClassLoader loader, ProtectionDomain domain)
+ throws CannotCompileException
+ {
+ ClassPool cp = getClassPool();
+ if (loader == null)
+ loader = cp.getClassLoader();
+
+ return cp.toClass(this, loader, domain);
+ }
+
+ /**
+ * Converts this class to a <code>java.lang.Class</code> object.
+ *
+ * <p><b>Warining:</b> A Class object returned by this method may not
+ * work with a security manager or a signed jar file because a
+ * protection domain is not specified.
+ *
+ * @deprecated Replaced by {@link #toClass(ClassLoader,ProtectionDomain)}
+ */
+ public final Class toClass(ClassLoader loader)
+ throws CannotCompileException
+ {
+ return getClassPool().toClass(this, loader);
+ }
+
+ /**
+ * Removes this <code>CtClass</code> object from the
+ * <code>ClassPool</code>.
+ * After this method is called, any method cannot be called on the
+ * removed <code>CtClass</code> object.
+ *
+ * <p>If <code>get()</code> in <code>ClassPool</code> is called
+ * with the name of the removed method,
+ * the <code>ClassPool</code> will read the class file again
+ * and constructs another <code>CtClass</code> object representing
+ * the same class.
+ */
+ public void detach() {
+ ClassPool cp = getClassPool();
+ CtClass obj = cp.removeCached(getName());
+ if (obj != this)
+ cp.cacheCtClass(getName(), obj, false);
+ }
+
+ /**
+ * Disallows (or allows) automatically pruning this <code>CtClass</code>
+ * object.
+ *
+ * <p>
+ * Javassist can automatically prune a <code>CtClass</code> object
+ * when <code>toBytecode()</code> (or <code>toClass()</code>,
+ * <code>writeFile()</code>) is called.
+ * Since a <code>ClassPool</code> holds all instances of <code>CtClass</code>
+ * even after <code>toBytecode()</code> (or <code>toClass()</code>,
+ * <code>writeFile()</code>) is called, pruning may significantly
+ * save memory consumption.
+ *
+ * <p>If <code>ClassPool.doPruning</code> is true, the automatic pruning
+ * is on by default. Otherwise, it is off. The default value of
+ * <code>ClassPool.doPruning</code> is false.
+ *
+ * @param stop disallow pruning if true. Otherwise, allow.
+ * @return the previous status of pruning. true if pruning is already stopped.
+ *
+ * @see #detach()
+ * @see #prune()
+ * @see ClassPool#doPruning
+ */
+ public boolean stopPruning(boolean stop) { return true; }
+
+ /**
+ * Discards unnecessary attributes, in particular,
+ * <code>CodeAttribute</code>s (method bodies) of the class,
+ * to minimize the memory footprint.
+ * After calling this method, the class is read only.
+ * It cannot be modified any more.
+ * Furthermore, <code>toBytecode()</code>,
+ * <code>writeFile()</code>, <code>toClass()</code>,
+ * or <code>instrument()</code> cannot be called.
+ * However, the method names and signatures in the class etc.
+ * are still accessible.
+ *
+ * <p><code>toBytecode()</code>, <code>writeFile()</code>, and
+ * <code>toClass()</code> internally call this method if
+ * automatic pruning is on.
+ *
+ * <p>According to some experiments, pruning does not really reduce
+ * memory consumption. Only about 20%. Since pruning takes time,
+ * it might not pay off. So the automatic pruning is off by default.
+ *
+ * @see #stopPruning(boolean)
+ * @see #detach()
+ * @see ClassPool#doPruning
+ *
+ * @see #toBytecode()
+ * @see #toClass()
+ * @see #writeFile()
+ * @see #instrument(CodeConverter)
+ * @see #instrument(ExprEditor)
+ */
+ public void prune() {}
+
+ /* Called by get() in ClassPool.
+ * CtClassType overrides this method.
+ */
+ void incGetCounter() {}
+
+ /**
+ * If this method is called, the class file will be
+ * rebuilt when it is finally generated by
+ * <code>toBytecode()</code> and <code>writeFile()</code>.
+ * For a performance reason, the symbol table of the
+ * class file may contain unused entries, for example,
+ * after a method or a filed is deleted.
+ * This method
+ * removes those unused entries. This removal will
+ * minimize the size of the class file.
+ *
+ * @since 3.8.1
+ */
+ public void rebuildClassFile() {}
+
+ /**
+ * Converts this class to a class file.
+ * Once this method is called, further modifications are not
+ * possible any more.
+ *
+ * @return the contents of the class file.
+ */
+ public byte[] toBytecode() throws IOException, CannotCompileException {
+ ByteArrayOutputStream barray = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(barray);
+ try {
+ toBytecode(out);
+ }
+ finally {
+ out.close();
+ }
+
+ return barray.toByteArray();
+ }
+
+ /**
+ * Writes a class file represented by this <code>CtClass</code>
+ * object in the current directory.
+ * Once this method is called, further modifications are not
+ * possible any more.
+ *
+ * @see #debugWriteFile()
+ */
+ public void writeFile()
+ throws NotFoundException, IOException, CannotCompileException
+ {
+ writeFile(".");
+ }
+
+ /**
+ * Writes a class file represented by this <code>CtClass</code>
+ * object on a local disk.
+ * Once this method is called, further modifications are not
+ * possible any more.
+ *
+ * @param directoryName it must end without a directory separator.
+ * @see #debugWriteFile(String)
+ */
+ public void writeFile(String directoryName)
+ throws CannotCompileException, IOException
+ {
+ String classname = getName();
+ String filename = directoryName + File.separatorChar
+ + classname.replace('.', File.separatorChar) + ".class";
+ int pos = filename.lastIndexOf(File.separatorChar);
+ if (pos > 0) {
+ String dir = filename.substring(0, pos);
+ if (!dir.equals("."))
+ new File(dir).mkdirs();
+ }
+
+ DataOutputStream out
+ = new DataOutputStream(new BufferedOutputStream(
+ new DelayedFileOutputStream(filename)));
+ try {
+ toBytecode(out);
+ }
+ finally {
+ out.close();
+ }
+ }
+
+ /**
+ * Writes a class file as <code>writeFile()</code> does although this
+ * method does not prune or freeze the class after writing the class
+ * file. Note that, once <code>writeFile()</code> or <code>toBytecode()</code>
+ * is called, it cannot be called again since the class is pruned and frozen.
+ * This method would be useful for debugging.
+ */
+ public void debugWriteFile() {
+ debugWriteFile(".");
+ }
+
+ /**
+ * Writes a class file as <code>writeFile()</code> does although this
+ * method does not prune or freeze the class after writing the class
+ * file. Note that, once <code>writeFile()</code> or <code>toBytecode()</code>
+ * is called, it cannot be called again since the class is pruned and frozen.
+ * This method would be useful for debugging.
+ *
+ * @param directoryName it must end without a directory separator.
+ */
+ public void debugWriteFile(String directoryName) {
+ try {
+ boolean p = stopPruning(true);
+ writeFile(directoryName);
+ defrost();
+ stopPruning(p);
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static class DelayedFileOutputStream extends OutputStream {
+ private FileOutputStream file;
+ private String filename;
+
+ DelayedFileOutputStream(String name) {
+ file = null;
+ filename = name;
+ }
+
+ private void init() throws IOException {
+ if (file == null)
+ file = new FileOutputStream(filename);
+ }
+
+ public void write(int b) throws IOException {
+ init();
+ file.write(b);
+ }
+
+ public void write(byte[] b) throws IOException {
+ init();
+ file.write(b);
+ }
+
+ public void write(byte[] b, int off, int len) throws IOException {
+ init();
+ file.write(b, off, len);
+
+ }
+
+ public void flush() throws IOException {
+ init();
+ file.flush();
+ }
+
+ public void close() throws IOException {
+ init();
+ file.close();
+ }
+ }
+
+ /**
+ * Converts this class to a class file.
+ * Once this method is called, further modifications are not
+ * possible any more.
+ *
+ * <p>This method dose not close the output stream in the end.
+ *
+ * @param out the output stream that a class file is written to.
+ */
+ public void toBytecode(DataOutputStream out)
+ throws CannotCompileException, IOException
+ {
+ throw new CannotCompileException("not a class");
+ }
+
+ /**
+ * Makes a unique member name. This method guarantees that
+ * the returned name is not used as a prefix of any methods
+ * or fields visible in this class.
+ * If the returned name is XYZ, then any method or field names
+ * in this class do not start with XYZ.
+ *
+ * @param prefix the prefix of the member name.
+ */
+ public String makeUniqueName(String prefix) {
+ throw new RuntimeException("not available in " + getName());
+ }
+
+ /* Invoked from ClassPool#compress().
+ * This method is overridden by CtClassType.
+ */
+ void compress() {}
+}
diff --git a/src/main/javassist/CtClassType.java b/src/main/javassist/CtClassType.java
new file mode 100644
index 0000000..dad5db7
--- /dev/null
+++ b/src/main/javassist/CtClassType.java
@@ -0,0 +1,1695 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.lang.ref.WeakReference;
+import java.io.BufferedInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ByteArrayInputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Set;
+
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.AttributeInfo;
+import javassist.bytecode.AnnotationsAttribute;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.ConstantAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.EnclosingMethodAttribute;
+import javassist.bytecode.FieldInfo;
+import javassist.bytecode.InnerClassesAttribute;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.ParameterAnnotationsAttribute;
+import javassist.bytecode.annotation.Annotation;
+import javassist.compiler.AccessorMaker;
+import javassist.compiler.CompileError;
+import javassist.compiler.Javac;
+import javassist.expr.ExprEditor;
+
+/**
+ * Class types.
+ */
+class CtClassType extends CtClass {
+ ClassPool classPool;
+ boolean wasChanged;
+ private boolean wasFrozen;
+ boolean wasPruned;
+ boolean gcConstPool; // if true, the constant pool entries will be garbage collected.
+ ClassFile classfile;
+ byte[] rawClassfile; // backup storage
+
+ private WeakReference memberCache;
+ private AccessorMaker accessors;
+
+ private FieldInitLink fieldInitializers;
+ private Hashtable hiddenMethods; // must be synchronous
+ private int uniqueNumberSeed;
+
+ private boolean doPruning = ClassPool.doPruning;
+ private int getCount;
+ private static final int GET_THRESHOLD = 2; // see compress()
+
+ CtClassType(String name, ClassPool cp) {
+ super(name);
+ classPool = cp;
+ wasChanged = wasFrozen = wasPruned = gcConstPool = false;
+ classfile = null;
+ rawClassfile = null;
+ memberCache = null;
+ accessors = null;
+ fieldInitializers = null;
+ hiddenMethods = null;
+ uniqueNumberSeed = 0;
+ getCount = 0;
+ }
+
+ CtClassType(InputStream ins, ClassPool cp) throws IOException {
+ this((String)null, cp);
+ classfile = new ClassFile(new DataInputStream(ins));
+ qualifiedName = classfile.getName();
+ }
+
+ protected void extendToString(StringBuffer buffer) {
+ if (wasChanged)
+ buffer.append("changed ");
+
+ if (wasFrozen)
+ buffer.append("frozen ");
+
+ if (wasPruned)
+ buffer.append("pruned ");
+
+ buffer.append(Modifier.toString(getModifiers()));
+ buffer.append(" class ");
+ buffer.append(getName());
+
+ try {
+ CtClass ext = getSuperclass();
+ if (ext != null) {
+ String name = ext.getName();
+ if (!name.equals("java.lang.Object"))
+ buffer.append(" extends " + ext.getName());
+ }
+ }
+ catch (NotFoundException e) {
+ buffer.append(" extends ??");
+ }
+
+ try {
+ CtClass[] intf = getInterfaces();
+ if (intf.length > 0)
+ buffer.append(" implements ");
+
+ for (int i = 0; i < intf.length; ++i) {
+ buffer.append(intf[i].getName());
+ buffer.append(", ");
+ }
+ }
+ catch (NotFoundException e) {
+ buffer.append(" extends ??");
+ }
+
+ CtMember.Cache memCache = getMembers();
+ exToString(buffer, " fields=",
+ memCache.fieldHead(), memCache.lastField());
+ exToString(buffer, " constructors=",
+ memCache.consHead(), memCache.lastCons());
+ exToString(buffer, " methods=",
+ memCache.methodHead(), memCache.lastMethod());
+ }
+
+ private void exToString(StringBuffer buffer, String msg,
+ CtMember head, CtMember tail) {
+ buffer.append(msg);
+ while (head != tail) {
+ head = head.next();
+ buffer.append(head);
+ buffer.append(", ");
+ }
+ }
+
+ public AccessorMaker getAccessorMaker() {
+ if (accessors == null)
+ accessors = new AccessorMaker(this);
+
+ return accessors;
+ }
+
+ public ClassFile getClassFile2() {
+ ClassFile cfile = classfile;
+ if (cfile != null)
+ return cfile;
+
+ classPool.compress();
+ if (rawClassfile != null) {
+ try {
+ classfile = new ClassFile(new DataInputStream(
+ new ByteArrayInputStream(rawClassfile)));
+ rawClassfile = null;
+ getCount = GET_THRESHOLD;
+ return classfile;
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e.toString(), e);
+ }
+ }
+
+ InputStream fin = null;
+ try {
+ fin = classPool.openClassfile(getName());
+ if (fin == null)
+ throw new NotFoundException(getName());
+
+ fin = new BufferedInputStream(fin);
+ ClassFile cf = new ClassFile(new DataInputStream(fin));
+ if (!cf.getName().equals(qualifiedName))
+ throw new RuntimeException("cannot find " + qualifiedName + ": "
+ + cf.getName() + " found in "
+ + qualifiedName.replace('.', '/') + ".class");
+
+ classfile = cf;
+ return cf;
+ }
+ catch (NotFoundException e) {
+ throw new RuntimeException(e.toString(), e);
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e.toString(), e);
+ }
+ finally {
+ if (fin != null)
+ try {
+ fin.close();
+ }
+ catch (IOException e) {}
+ }
+ }
+
+ /* Inherited from CtClass. Called by get() in ClassPool.
+ *
+ * @see javassist.CtClass#incGetCounter()
+ * @see #toBytecode(DataOutputStream)
+ */
+ final void incGetCounter() { ++getCount; }
+
+ /**
+ * Invoked from ClassPool#compress().
+ * It releases the class files that have not been recently used
+ * if they are unmodified.
+ */
+ void compress() {
+ if (getCount < GET_THRESHOLD)
+ if (!isModified() && ClassPool.releaseUnmodifiedClassFile)
+ removeClassFile();
+ else if (isFrozen() && !wasPruned)
+ saveClassFile();
+
+ getCount = 0;
+ }
+
+ /**
+ * Converts a ClassFile object into a byte array
+ * for saving memory space.
+ */
+ private synchronized void saveClassFile() {
+ /* getMembers() and releaseClassFile() are also synchronized.
+ */
+ if (classfile == null || hasMemberCache() != null)
+ return;
+
+ ByteArrayOutputStream barray = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(barray);
+ try {
+ classfile.write(out);
+ barray.close();
+ rawClassfile = barray.toByteArray();
+ classfile = null;
+ }
+ catch (IOException e) {}
+ }
+
+ private synchronized void removeClassFile() {
+ if (classfile != null && !isModified() && hasMemberCache() == null)
+ classfile = null;
+ }
+
+ public ClassPool getClassPool() { return classPool; }
+
+ void setClassPool(ClassPool cp) { classPool = cp; }
+
+ public URL getURL() throws NotFoundException {
+ URL url = classPool.find(getName());
+ if (url == null)
+ throw new NotFoundException(getName());
+ else
+ return url;
+ }
+
+ public boolean isModified() { return wasChanged; }
+
+ public boolean isFrozen() { return wasFrozen; }
+
+ public void freeze() { wasFrozen = true; }
+
+ void checkModify() throws RuntimeException {
+ if (isFrozen()) {
+ String msg = getName() + " class is frozen";
+ if (wasPruned)
+ msg += " and pruned";
+
+ throw new RuntimeException(msg);
+ }
+
+ wasChanged = true;
+ }
+
+ public void defrost() {
+ checkPruned("defrost");
+ wasFrozen = false;
+ }
+
+ public boolean subtypeOf(CtClass clazz) throws NotFoundException {
+ int i;
+ String cname = clazz.getName();
+ if (this == clazz || getName().equals(cname))
+ return true;
+
+ ClassFile file = getClassFile2();
+ String supername = file.getSuperclass();
+ if (supername != null && supername.equals(cname))
+ return true;
+
+ String[] ifs = file.getInterfaces();
+ int num = ifs.length;
+ for (i = 0; i < num; ++i)
+ if (ifs[i].equals(cname))
+ return true;
+
+ if (supername != null && classPool.get(supername).subtypeOf(clazz))
+ return true;
+
+ for (i = 0; i < num; ++i)
+ if (classPool.get(ifs[i]).subtypeOf(clazz))
+ return true;
+
+ return false;
+ }
+
+ public void setName(String name) throws RuntimeException {
+ String oldname = getName();
+ if (name.equals(oldname))
+ return;
+
+ // check this in advance although classNameChanged() below does.
+ classPool.checkNotFrozen(name);
+ ClassFile cf = getClassFile2();
+ super.setName(name);
+ cf.setName(name);
+ nameReplaced();
+ classPool.classNameChanged(oldname, this);
+ }
+
+ public void replaceClassName(ClassMap classnames)
+ throws RuntimeException
+ {
+ String oldClassName = getName();
+ String newClassName
+ = (String)classnames.get(Descriptor.toJvmName(oldClassName));
+ if (newClassName != null) {
+ newClassName = Descriptor.toJavaName(newClassName);
+ // check this in advance although classNameChanged() below does.
+ classPool.checkNotFrozen(newClassName);
+ }
+
+ super.replaceClassName(classnames);
+ ClassFile cf = getClassFile2();
+ cf.renameClass(classnames);
+ nameReplaced();
+
+ if (newClassName != null) {
+ super.setName(newClassName);
+ classPool.classNameChanged(oldClassName, this);
+ }
+ }
+
+ public void replaceClassName(String oldname, String newname)
+ throws RuntimeException
+ {
+ String thisname = getName();
+ if (thisname.equals(oldname))
+ setName(newname);
+ else {
+ super.replaceClassName(oldname, newname);
+ getClassFile2().renameClass(oldname, newname);
+ nameReplaced();
+ }
+ }
+
+ public boolean isInterface() {
+ return Modifier.isInterface(getModifiers());
+ }
+
+ public boolean isAnnotation() {
+ return Modifier.isAnnotation(getModifiers());
+ }
+
+ public boolean isEnum() {
+ return Modifier.isEnum(getModifiers());
+ }
+
+ public int getModifiers() {
+ ClassFile cf = getClassFile2();
+ int acc = cf.getAccessFlags();
+ acc = AccessFlag.clear(acc, AccessFlag.SUPER);
+ int inner = cf.getInnerAccessFlags();
+ if (inner != -1 && (inner & AccessFlag.STATIC) != 0)
+ acc |= AccessFlag.STATIC;
+
+ return AccessFlag.toModifier(acc);
+ }
+
+ public CtClass[] getNestedClasses() throws NotFoundException {
+ ClassFile cf = getClassFile2();
+ InnerClassesAttribute ica
+ = (InnerClassesAttribute)cf.getAttribute(InnerClassesAttribute.tag);
+ if (ica == null)
+ return new CtClass[0];
+
+ String thisName = cf.getName() + "$";
+ int n = ica.tableLength();
+ ArrayList list = new ArrayList(n);
+ for (int i = 0; i < n; i++) {
+ String name = ica.innerClass(i);
+ if (name != null)
+ if (name.startsWith(thisName)) {
+ // if it is an immediate nested class
+ if (name.lastIndexOf('$') < thisName.length())
+ list.add(classPool.get(name));
+ }
+ }
+
+ return (CtClass[])list.toArray(new CtClass[list.size()]);
+ }
+
+ public void setModifiers(int mod) {
+ ClassFile cf = getClassFile2();
+ if (Modifier.isStatic(mod)) {
+ int flags = cf.getInnerAccessFlags();
+ if (flags != -1 && (flags & AccessFlag.STATIC) != 0)
+ mod = mod & ~Modifier.STATIC;
+ else
+ throw new RuntimeException("cannot change " + getName() + " into a static class");
+ }
+
+ checkModify();
+ cf.setAccessFlags(AccessFlag.of(mod));
+ }
+
+ public boolean hasAnnotation(Class clz) {
+ ClassFile cf = getClassFile2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.visibleTag);
+ return hasAnnotationType(clz, getClassPool(), ainfo, ainfo2);
+ }
+
+ static boolean hasAnnotationType(Class clz, ClassPool cp,
+ AnnotationsAttribute a1, AnnotationsAttribute a2)
+ {
+ Annotation[] anno1, anno2;
+
+ if (a1 == null)
+ anno1 = null;
+ else
+ anno1 = a1.getAnnotations();
+
+ if (a2 == null)
+ anno2 = null;
+ else
+ anno2 = a2.getAnnotations();
+
+ String typeName = clz.getName();
+ if (anno1 != null)
+ for (int i = 0; i < anno1.length; i++)
+ if (anno1[i].getTypeName().equals(typeName))
+ return true;
+
+ if (anno2 != null)
+ for (int i = 0; i < anno2.length; i++)
+ if (anno2[i].getTypeName().equals(typeName))
+ return true;
+
+ return false;
+ }
+
+ public Object getAnnotation(Class clz) throws ClassNotFoundException {
+ ClassFile cf = getClassFile2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.visibleTag);
+ return getAnnotationType(clz, getClassPool(), ainfo, ainfo2);
+ }
+
+ static Object getAnnotationType(Class clz, ClassPool cp,
+ AnnotationsAttribute a1, AnnotationsAttribute a2)
+ throws ClassNotFoundException
+ {
+ Annotation[] anno1, anno2;
+
+ if (a1 == null)
+ anno1 = null;
+ else
+ anno1 = a1.getAnnotations();
+
+ if (a2 == null)
+ anno2 = null;
+ else
+ anno2 = a2.getAnnotations();
+
+ String typeName = clz.getName();
+ if (anno1 != null)
+ for (int i = 0; i < anno1.length; i++)
+ if (anno1[i].getTypeName().equals(typeName))
+ return toAnnoType(anno1[i], cp);
+
+ if (anno2 != null)
+ for (int i = 0; i < anno2.length; i++)
+ if (anno2[i].getTypeName().equals(typeName))
+ return toAnnoType(anno2[i], cp);
+
+ return null;
+ }
+
+ public Object[] getAnnotations() throws ClassNotFoundException {
+ return getAnnotations(false);
+ }
+
+ public Object[] getAvailableAnnotations(){
+ try {
+ return getAnnotations(true);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException("Unexpected exception ", e);
+ }
+ }
+
+ private Object[] getAnnotations(boolean ignoreNotFound)
+ throws ClassNotFoundException
+ {
+ ClassFile cf = getClassFile2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ cf.getAttribute(AnnotationsAttribute.visibleTag);
+ return toAnnotationType(ignoreNotFound, getClassPool(), ainfo, ainfo2);
+ }
+
+ static Object[] toAnnotationType(boolean ignoreNotFound, ClassPool cp,
+ AnnotationsAttribute a1, AnnotationsAttribute a2)
+ throws ClassNotFoundException
+ {
+ Annotation[] anno1, anno2;
+ int size1, size2;
+
+ if (a1 == null) {
+ anno1 = null;
+ size1 = 0;
+ }
+ else {
+ anno1 = a1.getAnnotations();
+ size1 = anno1.length;
+ }
+
+ if (a2 == null) {
+ anno2 = null;
+ size2 = 0;
+ }
+ else {
+ anno2 = a2.getAnnotations();
+ size2 = anno2.length;
+ }
+
+ if (!ignoreNotFound){
+ Object[] result = new Object[size1 + size2];
+ for (int i = 0; i < size1; i++)
+ result[i] = toAnnoType(anno1[i], cp);
+
+ for (int j = 0; j < size2; j++)
+ result[j + size1] = toAnnoType(anno2[j], cp);
+
+ return result;
+ }
+ else{
+ ArrayList annotations = new ArrayList();
+ for (int i = 0 ; i < size1 ; i++){
+ try{
+ annotations.add(toAnnoType(anno1[i], cp));
+ }
+ catch(ClassNotFoundException e){}
+ }
+ for (int j = 0; j < size2; j++) {
+ try{
+ annotations.add(toAnnoType(anno2[j], cp));
+ }
+ catch(ClassNotFoundException e){}
+ }
+
+ return annotations.toArray();
+ }
+ }
+
+ static Object[][] toAnnotationType(boolean ignoreNotFound, ClassPool cp,
+ ParameterAnnotationsAttribute a1,
+ ParameterAnnotationsAttribute a2,
+ MethodInfo minfo)
+ throws ClassNotFoundException
+ {
+ int numParameters = 0;
+ if (a1 != null)
+ numParameters = a1.numParameters();
+ else if (a2 != null)
+ numParameters = a2.numParameters();
+ else
+ numParameters = Descriptor.numOfParameters(minfo.getDescriptor());
+
+ Object[][] result = new Object[numParameters][];
+ for (int i = 0; i < numParameters; i++) {
+ Annotation[] anno1, anno2;
+ int size1, size2;
+
+ if (a1 == null) {
+ anno1 = null;
+ size1 = 0;
+ }
+ else {
+ anno1 = a1.getAnnotations()[i];
+ size1 = anno1.length;
+ }
+
+ if (a2 == null) {
+ anno2 = null;
+ size2 = 0;
+ }
+ else {
+ anno2 = a2.getAnnotations()[i];
+ size2 = anno2.length;
+ }
+
+ if (!ignoreNotFound){
+ result[i] = new Object[size1 + size2];
+ for (int j = 0; j < size1; ++j)
+ result[i][j] = toAnnoType(anno1[j], cp);
+
+ for (int j = 0; j < size2; ++j)
+ result[i][j + size1] = toAnnoType(anno2[j], cp);
+ }
+ else{
+ ArrayList annotations = new ArrayList();
+ for (int j = 0 ; j < size1 ; j++){
+ try{
+ annotations.add(toAnnoType(anno1[j], cp));
+ }
+ catch(ClassNotFoundException e){}
+ }
+ for (int j = 0; j < size2; j++){
+ try{
+ annotations.add(toAnnoType(anno2[j], cp));
+ }
+ catch(ClassNotFoundException e){}
+ }
+
+ result[i] = annotations.toArray();
+ }
+ }
+
+ return result;
+ }
+
+ private static Object toAnnoType(Annotation anno, ClassPool cp)
+ throws ClassNotFoundException
+ {
+ try {
+ ClassLoader cl = cp.getClassLoader();
+ return anno.toAnnotationType(cl, cp);
+ }
+ catch (ClassNotFoundException e) {
+ ClassLoader cl2 = cp.getClass().getClassLoader();
+ return anno.toAnnotationType(cl2, cp);
+ }
+ }
+
+ public boolean subclassOf(CtClass superclass) {
+ if (superclass == null)
+ return false;
+
+ String superName = superclass.getName();
+ CtClass curr = this;
+ try {
+ while (curr != null) {
+ if (curr.getName().equals(superName))
+ return true;
+
+ curr = curr.getSuperclass();
+ }
+ }
+ catch (Exception ignored) {}
+ return false;
+ }
+
+ public CtClass getSuperclass() throws NotFoundException {
+ String supername = getClassFile2().getSuperclass();
+ if (supername == null)
+ return null;
+ else
+ return classPool.get(supername);
+ }
+
+ public void setSuperclass(CtClass clazz) throws CannotCompileException {
+ checkModify();
+ if (isInterface())
+ addInterface(clazz);
+ else
+ getClassFile2().setSuperclass(clazz.getName());
+ }
+
+ public CtClass[] getInterfaces() throws NotFoundException {
+ String[] ifs = getClassFile2().getInterfaces();
+ int num = ifs.length;
+ CtClass[] ifc = new CtClass[num];
+ for (int i = 0; i < num; ++i)
+ ifc[i] = classPool.get(ifs[i]);
+
+ return ifc;
+ }
+
+ public void setInterfaces(CtClass[] list) {
+ checkModify();
+ String[] ifs;
+ if (list == null)
+ ifs = new String[0];
+ else {
+ int num = list.length;
+ ifs = new String[num];
+ for (int i = 0; i < num; ++i)
+ ifs[i] = list[i].getName();
+ }
+
+ getClassFile2().setInterfaces(ifs);
+ }
+
+ public void addInterface(CtClass anInterface) {
+ checkModify();
+ if (anInterface != null)
+ getClassFile2().addInterface(anInterface.getName());
+ }
+
+ public CtClass getDeclaringClass() throws NotFoundException {
+ ClassFile cf = getClassFile2();
+ InnerClassesAttribute ica = (InnerClassesAttribute)cf.getAttribute(
+ InnerClassesAttribute.tag);
+ if (ica == null)
+ return null;
+
+ String name = getName();
+ int n = ica.tableLength();
+ for (int i = 0; i < n; ++i)
+ if (name.equals(ica.innerClass(i))) {
+ String outName = ica.outerClass(i);
+ if (outName != null)
+ return classPool.get(outName);
+ else {
+ // maybe anonymous or local class.
+ EnclosingMethodAttribute ema
+ = (EnclosingMethodAttribute)cf.getAttribute(
+ EnclosingMethodAttribute.tag);
+ if (ema != null)
+ return classPool.get(ema.className());
+ }
+ }
+
+ return null;
+ }
+
+ public CtMethod getEnclosingMethod() throws NotFoundException {
+ ClassFile cf = getClassFile2();
+ EnclosingMethodAttribute ema
+ = (EnclosingMethodAttribute)cf.getAttribute(
+ EnclosingMethodAttribute.tag);
+ if (ema != null) {
+ CtClass enc = classPool.get(ema.className());
+ return enc.getMethod(ema.methodName(), ema.methodDescriptor());
+ }
+
+ return null;
+ }
+
+ public CtClass makeNestedClass(String name, boolean isStatic) {
+ if (!isStatic)
+ throw new RuntimeException(
+ "sorry, only nested static class is supported");
+
+ checkModify();
+ CtClass c = classPool.makeNestedClass(getName() + "$" + name);
+ ClassFile cf = getClassFile2();
+ ClassFile cf2 = c.getClassFile2();
+ InnerClassesAttribute ica = (InnerClassesAttribute)cf.getAttribute(
+ InnerClassesAttribute.tag);
+ if (ica == null) {
+ ica = new InnerClassesAttribute(cf.getConstPool());
+ cf.addAttribute(ica);
+ }
+
+ ica.append(c.getName(), this.getName(), name,
+ (cf2.getAccessFlags() & ~AccessFlag.SUPER) | AccessFlag.STATIC);
+ cf2.addAttribute(ica.copy(cf2.getConstPool(), null));
+ return c;
+ }
+
+ /* flush cached names.
+ */
+ private void nameReplaced() {
+ CtMember.Cache cache = hasMemberCache();
+ if (cache != null) {
+ CtMember mth = cache.methodHead();
+ CtMember tail = cache.lastMethod();
+ while (mth != tail) {
+ mth = mth.next();
+ mth.nameReplaced();
+ }
+ }
+ }
+
+ /**
+ * Returns null if members are not cached.
+ */
+ protected CtMember.Cache hasMemberCache() {
+ if (memberCache != null)
+ return (CtMember.Cache)memberCache.get();
+ else
+ return null;
+ }
+
+ protected synchronized CtMember.Cache getMembers() {
+ CtMember.Cache cache = null;
+ if (memberCache == null
+ || (cache = (CtMember.Cache)memberCache.get()) == null) {
+ cache = new CtMember.Cache(this);
+ makeFieldCache(cache);
+ makeBehaviorCache(cache);
+ memberCache = new WeakReference(cache);
+ }
+
+ return cache;
+ }
+
+ private void makeFieldCache(CtMember.Cache cache) {
+ List list = getClassFile2().getFields();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ CtField newField = new CtField(finfo, this);
+ cache.addField(newField);
+ }
+ }
+
+ private void makeBehaviorCache(CtMember.Cache cache) {
+ List list = getClassFile2().getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ if (minfo.isMethod()) {
+ CtMethod newMethod = new CtMethod(minfo, this);
+ cache.addMethod(newMethod);
+ }
+ else {
+ CtConstructor newCons = new CtConstructor(minfo, this);
+ cache.addConstructor(newCons);
+ }
+ }
+ }
+
+ public CtField[] getFields() {
+ ArrayList alist = new ArrayList();
+ getFields(alist, this);
+ return (CtField[])alist.toArray(new CtField[alist.size()]);
+ }
+
+ private static void getFields(ArrayList alist, CtClass cc) {
+ int i, num;
+ if (cc == null)
+ return;
+
+ try {
+ getFields(alist, cc.getSuperclass());
+ }
+ catch (NotFoundException e) {}
+
+ try {
+ CtClass[] ifs = cc.getInterfaces();
+ num = ifs.length;
+ for (i = 0; i < num; ++i)
+ getFields(alist, ifs[i]);
+ }
+ catch (NotFoundException e) {}
+
+ CtMember.Cache memCache = ((CtClassType)cc).getMembers();
+ CtMember field = memCache.fieldHead();
+ CtMember tail = memCache.lastField();
+ while (field != tail) {
+ field = field.next();
+ if (!Modifier.isPrivate(field.getModifiers()))
+ alist.add(field);
+ }
+ }
+
+ public CtField getField(String name, String desc) throws NotFoundException {
+ CtField f = getField2(name, desc);
+ return checkGetField(f, name, desc);
+ }
+
+ private CtField checkGetField(CtField f, String name, String desc)
+ throws NotFoundException
+ {
+ if (f == null) {
+ String msg = "field: " + name;
+ if (desc != null)
+ msg += " type " + desc;
+
+ throw new NotFoundException(msg + " in " + getName());
+ }
+ else
+ return f;
+ }
+
+ CtField getField2(String name, String desc) {
+ CtField df = getDeclaredField2(name, desc);
+ if (df != null)
+ return df;
+
+ try {
+ CtClass[] ifs = getInterfaces();
+ int num = ifs.length;
+ for (int i = 0; i < num; ++i) {
+ CtField f = ifs[i].getField2(name, desc);
+ if (f != null)
+ return f;
+ }
+
+ CtClass s = getSuperclass();
+ if (s != null)
+ return s.getField2(name, desc);
+ }
+ catch (NotFoundException e) {}
+ return null;
+ }
+
+ public CtField[] getDeclaredFields() {
+ CtMember.Cache memCache = getMembers();
+ CtMember field = memCache.fieldHead();
+ CtMember tail = memCache.lastField();
+ int num = CtMember.Cache.count(field, tail);
+ CtField[] cfs = new CtField[num];
+ int i = 0;
+ while (field != tail) {
+ field = field.next();
+ cfs[i++] = (CtField)field;
+ }
+
+ return cfs;
+ }
+
+ public CtField getDeclaredField(String name) throws NotFoundException {
+ return getDeclaredField(name, null);
+ }
+
+ public CtField getDeclaredField(String name, String desc) throws NotFoundException {
+ CtField f = getDeclaredField2(name, desc);
+ return checkGetField(f, name, desc);
+ }
+
+ private CtField getDeclaredField2(String name, String desc) {
+ CtMember.Cache memCache = getMembers();
+ CtMember field = memCache.fieldHead();
+ CtMember tail = memCache.lastField();
+ while (field != tail) {
+ field = field.next();
+ if (field.getName().equals(name)
+ && (desc == null || desc.equals(field.getSignature())))
+ return (CtField)field;
+ }
+
+ return null;
+ }
+
+ public CtBehavior[] getDeclaredBehaviors() {
+ CtMember.Cache memCache = getMembers();
+ CtMember cons = memCache.consHead();
+ CtMember consTail = memCache.lastCons();
+ int cnum = CtMember.Cache.count(cons, consTail);
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+ int mnum = CtMember.Cache.count(mth, mthTail);
+
+ CtBehavior[] cb = new CtBehavior[cnum + mnum];
+ int i = 0;
+ while (cons != consTail) {
+ cons = cons.next();
+ cb[i++] = (CtBehavior)cons;
+ }
+
+ while (mth != mthTail) {
+ mth = mth.next();
+ cb[i++] = (CtBehavior)mth;
+ }
+
+ return cb;
+ }
+
+ public CtConstructor[] getConstructors() {
+ CtMember.Cache memCache = getMembers();
+ CtMember cons = memCache.consHead();
+ CtMember consTail = memCache.lastCons();
+
+ int n = 0;
+ CtMember mem = cons;
+ while (mem != consTail) {
+ mem = mem.next();
+ if (isPubCons((CtConstructor)mem))
+ n++;
+ }
+
+ CtConstructor[] result = new CtConstructor[n];
+ int i = 0;
+ mem = cons;
+ while (mem != consTail) {
+ mem = mem.next();
+ CtConstructor cc = (CtConstructor)mem;
+ if (isPubCons(cc))
+ result[i++] = cc;
+ }
+
+ return result;
+ }
+
+ private static boolean isPubCons(CtConstructor cons) {
+ return !Modifier.isPrivate(cons.getModifiers())
+ && cons.isConstructor();
+ }
+
+ public CtConstructor getConstructor(String desc)
+ throws NotFoundException
+ {
+ CtMember.Cache memCache = getMembers();
+ CtMember cons = memCache.consHead();
+ CtMember consTail = memCache.lastCons();
+
+ while (cons != consTail) {
+ cons = cons.next();
+ CtConstructor cc = (CtConstructor)cons;
+ if (cc.getMethodInfo2().getDescriptor().equals(desc)
+ && cc.isConstructor())
+ return cc;
+ }
+
+ return super.getConstructor(desc);
+ }
+
+ public CtConstructor[] getDeclaredConstructors() {
+ CtMember.Cache memCache = getMembers();
+ CtMember cons = memCache.consHead();
+ CtMember consTail = memCache.lastCons();
+
+ int n = 0;
+ CtMember mem = cons;
+ while (mem != consTail) {
+ mem = mem.next();
+ CtConstructor cc = (CtConstructor)mem;
+ if (cc.isConstructor())
+ n++;
+ }
+
+ CtConstructor[] result = new CtConstructor[n];
+ int i = 0;
+ mem = cons;
+ while (mem != consTail) {
+ mem = mem.next();
+ CtConstructor cc = (CtConstructor)mem;
+ if (cc.isConstructor())
+ result[i++] = cc;
+ }
+
+ return result;
+ }
+
+ public CtConstructor getClassInitializer() {
+ CtMember.Cache memCache = getMembers();
+ CtMember cons = memCache.consHead();
+ CtMember consTail = memCache.lastCons();
+
+ while (cons != consTail) {
+ cons = cons.next();
+ CtConstructor cc = (CtConstructor)cons;
+ if (cc.isClassInitializer())
+ return cc;
+ }
+
+ return null;
+ }
+
+ public CtMethod[] getMethods() {
+ HashMap h = new HashMap();
+ getMethods0(h, this);
+ return (CtMethod[])h.values().toArray(new CtMethod[h.size()]);
+ }
+
+ private static void getMethods0(HashMap h, CtClass cc) {
+ try {
+ CtClass[] ifs = cc.getInterfaces();
+ int size = ifs.length;
+ for (int i = 0; i < size; ++i)
+ getMethods0(h, ifs[i]);
+ }
+ catch (NotFoundException e) {}
+
+ try {
+ CtClass s = cc.getSuperclass();
+ if (s != null)
+ getMethods0(h, s);
+ }
+ catch (NotFoundException e) {}
+
+ if (cc instanceof CtClassType) {
+ CtMember.Cache memCache = ((CtClassType)cc).getMembers();
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+
+ while (mth != mthTail) {
+ mth = mth.next();
+ if (!Modifier.isPrivate(mth.getModifiers()))
+ h.put(((CtMethod)mth).getStringRep(), mth);
+ }
+ }
+ }
+
+ public CtMethod getMethod(String name, String desc)
+ throws NotFoundException
+ {
+ CtMethod m = getMethod0(this, name, desc);
+ if (m != null)
+ return m;
+ else
+ throw new NotFoundException(name + "(..) is not found in "
+ + getName());
+ }
+
+ private static CtMethod getMethod0(CtClass cc,
+ String name, String desc) {
+ if (cc instanceof CtClassType) {
+ CtMember.Cache memCache = ((CtClassType)cc).getMembers();
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+
+ while (mth != mthTail) {
+ mth = mth.next();
+ if (mth.getName().equals(name)
+ && ((CtMethod)mth).getMethodInfo2().getDescriptor().equals(desc))
+ return (CtMethod)mth;
+ }
+ }
+
+ try {
+ CtClass s = cc.getSuperclass();
+ if (s != null) {
+ CtMethod m = getMethod0(s, name, desc);
+ if (m != null)
+ return m;
+ }
+ }
+ catch (NotFoundException e) {}
+
+ try {
+ CtClass[] ifs = cc.getInterfaces();
+ int size = ifs.length;
+ for (int i = 0; i < size; ++i) {
+ CtMethod m = getMethod0(ifs[i], name, desc);
+ if (m != null)
+ return m;
+ }
+ }
+ catch (NotFoundException e) {}
+ return null;
+ }
+
+ public CtMethod[] getDeclaredMethods() {
+ CtMember.Cache memCache = getMembers();
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+ int num = CtMember.Cache.count(mth, mthTail);
+ CtMethod[] cms = new CtMethod[num];
+ int i = 0;
+ while (mth != mthTail) {
+ mth = mth.next();
+ cms[i++] = (CtMethod)mth;
+ }
+
+ return cms;
+ }
+
+ public CtMethod getDeclaredMethod(String name) throws NotFoundException {
+ CtMember.Cache memCache = getMembers();
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+ while (mth != mthTail) {
+ mth = mth.next();
+ if (mth.getName().equals(name))
+ return (CtMethod)mth;
+ }
+
+ throw new NotFoundException(name + "(..) is not found in "
+ + getName());
+ }
+
+ public CtMethod getDeclaredMethod(String name, CtClass[] params)
+ throws NotFoundException
+ {
+ String desc = Descriptor.ofParameters(params);
+ CtMember.Cache memCache = getMembers();
+ CtMember mth = memCache.methodHead();
+ CtMember mthTail = memCache.lastMethod();
+
+ while (mth != mthTail) {
+ mth = mth.next();
+ if (mth.getName().equals(name)
+ && ((CtMethod)mth).getMethodInfo2().getDescriptor().startsWith(desc))
+ return (CtMethod)mth;
+ }
+
+ throw new NotFoundException(name + "(..) is not found in "
+ + getName());
+ }
+
+ public void addField(CtField f, String init)
+ throws CannotCompileException
+ {
+ addField(f, CtField.Initializer.byExpr(init));
+ }
+
+ public void addField(CtField f, CtField.Initializer init)
+ throws CannotCompileException
+ {
+ checkModify();
+ if (f.getDeclaringClass() != this)
+ throw new CannotCompileException("cannot add");
+
+ if (init == null)
+ init = f.getInit();
+
+ if (init != null) {
+ init.check(f.getSignature());
+ int mod = f.getModifiers();
+ if (Modifier.isStatic(mod) && Modifier.isFinal(mod))
+ try {
+ ConstPool cp = getClassFile2().getConstPool();
+ int index = init.getConstantValue(cp, f.getType());
+ if (index != 0) {
+ f.getFieldInfo2().addAttribute(new ConstantAttribute(cp, index));
+ init = null;
+ }
+ }
+ catch (NotFoundException e) {}
+ }
+
+ getMembers().addField(f);
+ getClassFile2().addField(f.getFieldInfo2());
+
+ if (init != null) {
+ FieldInitLink fil = new FieldInitLink(f, init);
+ FieldInitLink link = fieldInitializers;
+ if (link == null)
+ fieldInitializers = fil;
+ else {
+ while (link.next != null)
+ link = link.next;
+
+ link.next = fil;
+ }
+ }
+ }
+
+ public void removeField(CtField f) throws NotFoundException {
+ checkModify();
+ FieldInfo fi = f.getFieldInfo2();
+ ClassFile cf = getClassFile2();
+ if (cf.getFields().remove(fi)) {
+ getMembers().remove(f);
+ gcConstPool = true;
+ }
+ else
+ throw new NotFoundException(f.toString());
+ }
+
+ public CtConstructor makeClassInitializer()
+ throws CannotCompileException
+ {
+ CtConstructor clinit = getClassInitializer();
+ if (clinit != null)
+ return clinit;
+
+ checkModify();
+ ClassFile cf = getClassFile2();
+ Bytecode code = new Bytecode(cf.getConstPool(), 0, 0);
+ modifyClassConstructor(cf, code, 0, 0);
+ return getClassInitializer();
+ }
+
+ public void addConstructor(CtConstructor c)
+ throws CannotCompileException
+ {
+ checkModify();
+ if (c.getDeclaringClass() != this)
+ throw new CannotCompileException("cannot add");
+
+ getMembers().addConstructor(c);
+ getClassFile2().addMethod(c.getMethodInfo2());
+ }
+
+ public void removeConstructor(CtConstructor m) throws NotFoundException {
+ checkModify();
+ MethodInfo mi = m.getMethodInfo2();
+ ClassFile cf = getClassFile2();
+ if (cf.getMethods().remove(mi)) {
+ getMembers().remove(m);
+ gcConstPool = true;
+ }
+ else
+ throw new NotFoundException(m.toString());
+ }
+
+ public void addMethod(CtMethod m) throws CannotCompileException {
+ checkModify();
+ if (m.getDeclaringClass() != this)
+ throw new CannotCompileException("bad declaring class");
+
+ int mod = m.getModifiers();
+ if ((getModifiers() & Modifier.INTERFACE) != 0) {
+ m.setModifiers(mod | Modifier.PUBLIC);
+ if ((mod & Modifier.ABSTRACT) == 0)
+ throw new CannotCompileException(
+ "an interface method must be abstract: " + m.toString());
+ }
+
+ getMembers().addMethod(m);
+ getClassFile2().addMethod(m.getMethodInfo2());
+ if ((mod & Modifier.ABSTRACT) != 0)
+ setModifiers(getModifiers() | Modifier.ABSTRACT);
+ }
+
+ public void removeMethod(CtMethod m) throws NotFoundException {
+ checkModify();
+ MethodInfo mi = m.getMethodInfo2();
+ ClassFile cf = getClassFile2();
+ if (cf.getMethods().remove(mi)) {
+ getMembers().remove(m);
+ gcConstPool = true;
+ }
+ else
+ throw new NotFoundException(m.toString());
+ }
+
+ public byte[] getAttribute(String name) {
+ AttributeInfo ai = getClassFile2().getAttribute(name);
+ if (ai == null)
+ return null;
+ else
+ return ai.get();
+ }
+
+ public void setAttribute(String name, byte[] data) {
+ checkModify();
+ ClassFile cf = getClassFile2();
+ cf.addAttribute(new AttributeInfo(cf.getConstPool(), name, data));
+ }
+
+ public void instrument(CodeConverter converter)
+ throws CannotCompileException
+ {
+ checkModify();
+ ClassFile cf = getClassFile2();
+ ConstPool cp = cf.getConstPool();
+ List list = cf.getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ converter.doit(this, minfo, cp);
+ }
+ }
+
+ public void instrument(ExprEditor editor)
+ throws CannotCompileException
+ {
+ checkModify();
+ ClassFile cf = getClassFile2();
+ List list = cf.getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ editor.doit(this, minfo);
+ }
+ }
+
+ /**
+ * @see javassist.CtClass#prune()
+ * @see javassist.CtClass#stopPruning(boolean)
+ */
+ public void prune() {
+ if (wasPruned)
+ return;
+
+ wasPruned = wasFrozen = true;
+ getClassFile2().prune();
+ }
+
+ public void rebuildClassFile() { gcConstPool = true; }
+
+ public void toBytecode(DataOutputStream out)
+ throws CannotCompileException, IOException
+ {
+ try {
+ if (isModified()) {
+ checkPruned("toBytecode");
+ ClassFile cf = getClassFile2();
+ if (gcConstPool) {
+ cf.compact();
+ gcConstPool = false;
+ }
+
+ modifyClassConstructor(cf);
+ modifyConstructors(cf);
+ cf.write(out);
+ out.flush();
+ fieldInitializers = null;
+ if (doPruning) {
+ // to save memory
+ cf.prune();
+ wasPruned = true;
+ }
+ }
+ else {
+ classPool.writeClassfile(getName(), out);
+ // to save memory
+ // classfile = null;
+ }
+
+ getCount = 0;
+ wasFrozen = true;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (IOException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /* See also checkModified()
+ */
+ private void checkPruned(String method) {
+ if (wasPruned)
+ throw new RuntimeException(method + "(): " + getName()
+ + " was pruned.");
+ }
+
+ public boolean stopPruning(boolean stop) {
+ boolean prev = !doPruning;
+ doPruning = !stop;
+ return prev;
+ }
+
+ private void modifyClassConstructor(ClassFile cf)
+ throws CannotCompileException, NotFoundException
+ {
+ if (fieldInitializers == null)
+ return;
+
+ Bytecode code = new Bytecode(cf.getConstPool(), 0, 0);
+ Javac jv = new Javac(code, this);
+ int stacksize = 0;
+ boolean doInit = false;
+ for (FieldInitLink fi = fieldInitializers; fi != null; fi = fi.next) {
+ CtField f = fi.field;
+ if (Modifier.isStatic(f.getModifiers())) {
+ doInit = true;
+ int s = fi.init.compileIfStatic(f.getType(), f.getName(),
+ code, jv);
+ if (stacksize < s)
+ stacksize = s;
+ }
+ }
+
+ if (doInit) // need an initializer for static fileds.
+ modifyClassConstructor(cf, code, stacksize, 0);
+ }
+
+ private void modifyClassConstructor(ClassFile cf, Bytecode code,
+ int stacksize, int localsize)
+ throws CannotCompileException
+ {
+ MethodInfo m = cf.getStaticInitializer();
+ if (m == null) {
+ code.add(Bytecode.RETURN);
+ code.setMaxStack(stacksize);
+ code.setMaxLocals(localsize);
+ m = new MethodInfo(cf.getConstPool(), "<clinit>", "()V");
+ m.setAccessFlags(AccessFlag.STATIC);
+ m.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(m);
+ CtMember.Cache cache = hasMemberCache();
+ if (cache != null)
+ cache.addConstructor(new CtConstructor(m, this));
+ }
+ else {
+ CodeAttribute codeAttr = m.getCodeAttribute();
+ if (codeAttr == null)
+ throw new CannotCompileException("empty <clinit>");
+
+ try {
+ CodeIterator it = codeAttr.iterator();
+ int pos = it.insertEx(code.get());
+ it.insert(code.getExceptionTable(), pos);
+ int maxstack = codeAttr.getMaxStack();
+ if (maxstack < stacksize)
+ codeAttr.setMaxStack(stacksize);
+
+ int maxlocals = codeAttr.getMaxLocals();
+ if (maxlocals < localsize)
+ codeAttr.setMaxLocals(localsize);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ try {
+ m.rebuildStackMapIf6(classPool, cf);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private void modifyConstructors(ClassFile cf)
+ throws CannotCompileException, NotFoundException
+ {
+ if (fieldInitializers == null)
+ return;
+
+ ConstPool cp = cf.getConstPool();
+ List list = cf.getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ if (minfo.isConstructor()) {
+ CodeAttribute codeAttr = minfo.getCodeAttribute();
+ if (codeAttr != null)
+ try {
+ Bytecode init = new Bytecode(cp, 0,
+ codeAttr.getMaxLocals());
+ CtClass[] params
+ = Descriptor.getParameterTypes(
+ minfo.getDescriptor(),
+ classPool);
+ int stacksize = makeFieldInitializer(init, params);
+ insertAuxInitializer(codeAttr, init, stacksize);
+ minfo.rebuildStackMapIf6(classPool, cf);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+ }
+ }
+
+ private static void insertAuxInitializer(CodeAttribute codeAttr,
+ Bytecode initializer,
+ int stacksize)
+ throws BadBytecode
+ {
+ CodeIterator it = codeAttr.iterator();
+ int index = it.skipSuperConstructor();
+ if (index < 0) {
+ index = it.skipThisConstructor();
+ if (index >= 0)
+ return; // this() is called.
+
+ // Neither this() or super() is called.
+ }
+
+ int pos = it.insertEx(initializer.get());
+ it.insert(initializer.getExceptionTable(), pos);
+ int maxstack = codeAttr.getMaxStack();
+ if (maxstack < stacksize)
+ codeAttr.setMaxStack(stacksize);
+ }
+
+ private int makeFieldInitializer(Bytecode code, CtClass[] parameters)
+ throws CannotCompileException, NotFoundException
+ {
+ int stacksize = 0;
+ Javac jv = new Javac(code, this);
+ try {
+ jv.recordParams(parameters, false);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+
+ for (FieldInitLink fi = fieldInitializers; fi != null; fi = fi.next) {
+ CtField f = fi.field;
+ if (!Modifier.isStatic(f.getModifiers())) {
+ int s = fi.init.compile(f.getType(), f.getName(), code,
+ parameters, jv);
+ if (stacksize < s)
+ stacksize = s;
+ }
+ }
+
+ return stacksize;
+ }
+
+ // Methods used by CtNewWrappedMethod
+
+ Hashtable getHiddenMethods() {
+ if (hiddenMethods == null)
+ hiddenMethods = new Hashtable();
+
+ return hiddenMethods;
+ }
+
+ int getUniqueNumber() { return uniqueNumberSeed++; }
+
+ public String makeUniqueName(String prefix) {
+ HashMap table = new HashMap();
+ makeMemberList(table);
+ Set keys = table.keySet();
+ String[] methods = new String[keys.size()];
+ keys.toArray(methods);
+
+ if (notFindInArray(prefix, methods))
+ return prefix;
+
+ int i = 100;
+ String name;
+ do {
+ if (i > 999)
+ throw new RuntimeException("too many unique name");
+
+ name = prefix + i++;
+ } while (!notFindInArray(name, methods));
+ return name;
+ }
+
+ private static boolean notFindInArray(String prefix, String[] values) {
+ int len = values.length;
+ for (int i = 0; i < len; i++)
+ if (values[i].startsWith(prefix))
+ return false;
+
+ return true;
+ }
+
+ private void makeMemberList(HashMap table) {
+ int mod = getModifiers();
+ if (Modifier.isAbstract(mod) || Modifier.isInterface(mod))
+ try {
+ CtClass[] ifs = getInterfaces();
+ int size = ifs.length;
+ for (int i = 0; i < size; i++) {
+ CtClass ic =ifs[i];
+ if (ic != null && ic instanceof CtClassType)
+ ((CtClassType)ic).makeMemberList(table);
+ }
+ }
+ catch (NotFoundException e) {}
+
+ try {
+ CtClass s = getSuperclass();
+ if (s != null && s instanceof CtClassType)
+ ((CtClassType)s).makeMemberList(table);
+ }
+ catch (NotFoundException e) {}
+
+ List list = getClassFile2().getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; i++) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ table.put(minfo.getName(), this);
+ }
+
+ list = getClassFile2().getFields();
+ n = list.size();
+ for (int i = 0; i < n; i++) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ table.put(finfo.getName(), this);
+ }
+ }
+}
+
+class FieldInitLink {
+ FieldInitLink next;
+ CtField field;
+ CtField.Initializer init;
+
+ FieldInitLink(CtField f, CtField.Initializer i) {
+ next = null;
+ field = f;
+ init = i;
+ }
+}
diff --git a/src/main/javassist/CtConstructor.java b/src/main/javassist/CtConstructor.java
new file mode 100644
index 0000000..a90b73c
--- /dev/null
+++ b/src/main/javassist/CtConstructor.java
@@ -0,0 +1,402 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.Javac;
+import javassist.compiler.CompileError;
+
+/**
+ * An instance of CtConstructor represents a constructor.
+ * It may represent a static constructor
+ * (class initializer). To distinguish a constructor and a class
+ * initializer, call <code>isClassInitializer()</code>.
+ *
+ * <p>See the super class <code>CtBehavior</code> as well since
+ * a number of useful methods are in <code>CtBehavior</code>.
+ *
+ * @see CtClass#getDeclaredConstructors()
+ * @see CtClass#getClassInitializer()
+ * @see CtNewConstructor
+ */
+public final class CtConstructor extends CtBehavior {
+ protected CtConstructor(MethodInfo minfo, CtClass declaring) {
+ super(declaring, minfo);
+ }
+
+ /**
+ * Creates a constructor with no constructor body.
+ * The created constructor
+ * must be added to a class with <code>CtClass.addConstructor()</code>.
+ *
+ * <p>The created constructor does not include a constructor body,
+ * which must be specified with <code>setBody()</code>.
+ *
+ * @param declaring the class to which the created method is added.
+ * @param parameters a list of the parameter types
+ *
+ * @see CtClass#addConstructor(CtConstructor)
+ * @see CtConstructor#setBody(String)
+ * @see CtConstructor#setBody(CtConstructor,ClassMap)
+ */
+ public CtConstructor(CtClass[] parameters, CtClass declaring) {
+ this((MethodInfo)null, declaring);
+ ConstPool cp = declaring.getClassFile2().getConstPool();
+ String desc = Descriptor.ofConstructor(parameters);
+ methodInfo = new MethodInfo(cp, "<init>", desc);
+ setModifiers(Modifier.PUBLIC);
+ }
+
+ /**
+ * Creates a copy of a <code>CtConstructor</code> object.
+ * The created constructor must be
+ * added to a class with <code>CtClass.addConstructor()</code>.
+ *
+ * <p>All occurrences of class names in the created constructor
+ * are replaced with names specified by
+ * <code>map</code> if <code>map</code> is not <code>null</code>.
+ *
+ * <p>By default, all the occurrences of the names of the class
+ * declaring <code>src</code> and the superclass are replaced
+ * with the name of the class and the superclass that
+ * the created constructor is added to.
+ * This is done whichever <code>map</code> is null or not.
+ * To prevent this replacement, call <code>ClassMap.fix()</code>
+ * or <code>put()</code> to explicitly specify replacement.
+ *
+ * <p><b>Note:</b> if the <code>.class</code> notation (for example,
+ * <code>String.class</code>) is included in an expression, the
+ * Javac compiler may produce a helper method.
+ * Since this constructor never
+ * copies this helper method, the programmers have the responsiblity of
+ * copying it. Otherwise, use <code>Class.forName()</code> in the
+ * expression.
+ *
+ * @param src the source method.
+ * @param declaring the class to which the created method is added.
+ * @param map the hashtable associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ *
+ * @see CtClass#addConstructor(CtConstructor)
+ * @see ClassMap#fix(String)
+ */
+ public CtConstructor(CtConstructor src, CtClass declaring, ClassMap map)
+ throws CannotCompileException
+ {
+ this((MethodInfo)null, declaring);
+ copy(src, true, map);
+ }
+
+ /**
+ * Returns true if this object represents a constructor.
+ */
+ public boolean isConstructor() {
+ return methodInfo.isConstructor();
+ }
+
+ /**
+ * Returns true if this object represents a static initializer.
+ */
+ public boolean isClassInitializer() {
+ return methodInfo.isStaticInitializer();
+ }
+
+ /**
+ * Returns the constructor name followed by parameter types
+ * such as <code>javassist.CtConstructor(CtClass[],CtClass)</code>.
+ *
+ * @since 3.5
+ */
+ public String getLongName() {
+ return getDeclaringClass().getName()
+ + (isConstructor() ? Descriptor.toString(getSignature())
+ : ("." + MethodInfo.nameClinit + "()"));
+ }
+
+ /**
+ * Obtains the name of this constructor.
+ * It is the same as the simple name of the class declaring this
+ * constructor. If this object represents a class initializer,
+ * then this method returns <code>"<clinit>"</code>.
+ */
+ public String getName() {
+ if (methodInfo.isStaticInitializer())
+ return MethodInfo.nameClinit;
+ else
+ return declaringClass.getSimpleName();
+ }
+
+ /**
+ * Returns true if the constructor (or static initializer)
+ * is the default one. This method returns true if the constructor
+ * takes some arguments but it does not perform anything except
+ * calling <code>super()</code> (the no-argument constructor of
+ * the super class).
+ */
+ public boolean isEmpty() {
+ CodeAttribute ca = getMethodInfo2().getCodeAttribute();
+ if (ca == null)
+ return false; // native or abstract??
+ // they are not allowed, though.
+
+ ConstPool cp = ca.getConstPool();
+ CodeIterator it = ca.iterator();
+ try {
+ int pos, desc;
+ int op0 = it.byteAt(it.next());
+ return op0 == Opcode.RETURN // empty static initializer
+ || (op0 == Opcode.ALOAD_0
+ && it.byteAt(pos = it.next()) == Opcode.INVOKESPECIAL
+ && (desc = cp.isConstructor(getSuperclassName(),
+ it.u16bitAt(pos + 1))) != 0
+ && "()V".equals(cp.getUtf8Info(desc))
+ && it.byteAt(it.next()) == Opcode.RETURN
+ && !it.hasNext());
+ }
+ catch (BadBytecode e) {}
+ return false;
+ }
+
+ private String getSuperclassName() {
+ ClassFile cf = declaringClass.getClassFile2();
+ return cf.getSuperclass();
+ }
+
+ /**
+ * Returns true if this constructor calls a constructor
+ * of the super class. This method returns false if it
+ * calls another constructor of this class by <code>this()</code>.
+ */
+ public boolean callsSuper() throws CannotCompileException {
+ CodeAttribute codeAttr = methodInfo.getCodeAttribute();
+ if (codeAttr != null) {
+ CodeIterator it = codeAttr.iterator();
+ try {
+ int index = it.skipSuperConstructor();
+ return index >= 0;
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Sets a constructor body.
+ *
+ * @param src the source code representing the constructor body.
+ * It must be a single statement or block.
+ * If it is <code>null</code>, the substituted
+ * constructor body does nothing except calling
+ * <code>super()</code>.
+ */
+ public void setBody(String src) throws CannotCompileException {
+ if (src == null)
+ if (isClassInitializer())
+ src = ";";
+ else
+ src = "super();";
+
+ super.setBody(src);
+ }
+
+ /**
+ * Copies a constructor body from another constructor.
+ *
+ * <p>All occurrences of the class names in the copied body
+ * are replaced with the names specified by
+ * <code>map</code> if <code>map</code> is not <code>null</code>.
+ *
+ * @param src the method that the body is copied from.
+ * @param map the hashtable associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ */
+ public void setBody(CtConstructor src, ClassMap map)
+ throws CannotCompileException
+ {
+ setBody0(src.declaringClass, src.methodInfo,
+ declaringClass, methodInfo, map);
+ }
+
+ /**
+ * Inserts bytecode just after another constructor in the super class
+ * or this class is called.
+ * It does not work if this object represents a class initializer.
+ *
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ */
+ public void insertBeforeBody(String src) throws CannotCompileException {
+ CtClass cc = declaringClass;
+ cc.checkModify();
+ if (isClassInitializer())
+ throw new CannotCompileException("class initializer");
+
+ CodeAttribute ca = methodInfo.getCodeAttribute();
+ CodeIterator iterator = ca.iterator();
+ Bytecode b = new Bytecode(methodInfo.getConstPool(),
+ ca.getMaxStack(), ca.getMaxLocals());
+ b.setStackDepth(ca.getMaxStack());
+ Javac jv = new Javac(b, cc);
+ try {
+ jv.recordParams(getParameterTypes(), false);
+ jv.compileStmnt(src);
+ ca.setMaxStack(b.getMaxStack());
+ ca.setMaxLocals(b.getMaxLocals());
+ iterator.skipConstructor();
+ int pos = iterator.insertEx(b.get());
+ iterator.insert(b.getExceptionTable(), pos);
+ methodInfo.rebuildStackMapIf6(cc.getClassPool(), cc.getClassFile2());
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /* This method is called by addCatch() in CtBehavior.
+ * super() and this() must not be in a try statement.
+ */
+ int getStartPosOfBody(CodeAttribute ca) throws CannotCompileException {
+ CodeIterator ci = ca.iterator();
+ try {
+ ci.skipConstructor();
+ return ci.next();
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Makes a copy of this constructor and converts it into a method.
+ * The signature of the mehtod is the same as the that of this constructor.
+ * The return type is <code>void</code>. The resulting method must be
+ * appended to the class specified by <code>declaring</code>.
+ * If this constructor is a static initializer, the resulting method takes
+ * no parameter.
+ *
+ * <p>An occurrence of another constructor call <code>this()</code>
+ * or a super constructor call <code>super()</code> is
+ * eliminated from the resulting method.
+ *
+ * <p>The immediate super class of the class declaring this constructor
+ * must be also a super class of the class declaring the resulting method.
+ * If the constructor accesses a field, the class declaring the resulting method
+ * must also declare a field with the same name and type.
+ *
+ * @param name the name of the resulting method.
+ * @param declaring the class declaring the resulting method.
+ */
+ public CtMethod toMethod(String name, CtClass declaring)
+ throws CannotCompileException
+ {
+ return toMethod(name, declaring, null);
+ }
+
+ /**
+ * Makes a copy of this constructor and converts it into a method.
+ * The signature of the method is the same as the that of this constructor.
+ * The return type is <code>void</code>. The resulting method must be
+ * appended to the class specified by <code>declaring</code>.
+ * If this constructor is a static initializer, the resulting method takes
+ * no parameter.
+ *
+ * <p>An occurrence of another constructor call <code>this()</code>
+ * or a super constructor call <code>super()</code> is
+ * eliminated from the resulting method.
+ *
+ * <p>The immediate super class of the class declaring this constructor
+ * must be also a super class of the class declaring the resulting method
+ * (this is obviously true if the second parameter <code>declaring</code> is
+ * the same as the class declaring this constructor).
+ * If the constructor accesses a field, the class declaring the resulting method
+ * must also declare a field with the same name and type.
+ *
+ * @param name the name of the resulting method.
+ * @param declaring the class declaring the resulting method.
+ * It is normally the same as the class declaring this
+ * constructor.
+ * @param map the hash table associating original class names
+ * with substituted names. The original class names will be
+ * replaced while making a copy.
+ * <code>map</code> can be <code>null</code>.
+ */
+ public CtMethod toMethod(String name, CtClass declaring, ClassMap map)
+ throws CannotCompileException
+ {
+ CtMethod method = new CtMethod(null, declaring);
+ method.copy(this, false, map);
+ if (isConstructor()) {
+ MethodInfo minfo = method.getMethodInfo2();
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca != null) {
+ removeConsCall(ca);
+ try {
+ methodInfo.rebuildStackMapIf6(declaring.getClassPool(),
+ declaring.getClassFile2());
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+ }
+
+ method.setName(name);
+ return method;
+ }
+
+ private static void removeConsCall(CodeAttribute ca)
+ throws CannotCompileException
+ {
+ CodeIterator iterator = ca.iterator();
+ try {
+ int pos = iterator.skipConstructor();
+ if (pos >= 0) {
+ int mref = iterator.u16bitAt(pos + 1);
+ String desc = ca.getConstPool().getMethodrefType(mref);
+ int num = Descriptor.numOfParameters(desc) + 1;
+ if (num > 3)
+ pos = iterator.insertGapAt(pos, num - 3, false).position;
+
+ iterator.writeByte(Opcode.POP, pos++); // this
+ iterator.writeByte(Opcode.NOP, pos);
+ iterator.writeByte(Opcode.NOP, pos + 1);
+ Descriptor.Iterator it = new Descriptor.Iterator(desc);
+ while (true) {
+ it.next();
+ if (it.isParameter())
+ iterator.writeByte(it.is2byte() ? Opcode.POP2 : Opcode.POP,
+ pos++);
+ else
+ break;
+ }
+ }
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+}
diff --git a/src/main/javassist/CtField.java b/src/main/javassist/CtField.java
new file mode 100644
index 0000000..c4af7e5
--- /dev/null
+++ b/src/main/javassist/CtField.java
@@ -0,0 +1,1389 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.Javac;
+import javassist.compiler.SymbolTable;
+import javassist.compiler.CompileError;
+import javassist.compiler.ast.ASTree;
+import javassist.compiler.ast.IntConst;
+import javassist.compiler.ast.DoubleConst;
+import javassist.compiler.ast.StringL;
+
+/**
+ * An instance of CtField represents a field.
+ *
+ * @see CtClass#getDeclaredFields()
+ */
+public class CtField extends CtMember {
+ static final String javaLangString = "java.lang.String";
+
+ protected FieldInfo fieldInfo;
+
+ /**
+ * Creates a <code>CtField</code> object.
+ * The created field must be added to a class
+ * with <code>CtClass.addField()</code>.
+ * An initial value of the field is specified
+ * by a <code>CtField.Initializer</code> object.
+ *
+ * <p>If getter and setter methods are needed,
+ * call <code>CtNewMethod.getter()</code> and
+ * <code>CtNewMethod.setter()</code>.
+ *
+ * @param type field type
+ * @param name field name
+ * @param declaring the class to which the field will be added.
+ *
+ * @see CtClass#addField(CtField)
+ * @see CtNewMethod#getter(String,CtField)
+ * @see CtNewMethod#setter(String,CtField)
+ * @see CtField.Initializer
+ */
+ public CtField(CtClass type, String name, CtClass declaring)
+ throws CannotCompileException
+ {
+ this(Descriptor.of(type), name, declaring);
+ }
+
+ /**
+ * Creates a copy of the given field.
+ * The created field must be added to a class
+ * with <code>CtClass.addField()</code>.
+ * An initial value of the field is specified
+ * by a <code>CtField.Initializer</code> object.
+ *
+ * <p>If getter and setter methods are needed,
+ * call <code>CtNewMethod.getter()</code> and
+ * <code>CtNewMethod.setter()</code>.
+ *
+ * @param src the original field
+ * @param declaring the class to which the field will be added.
+ * @see CtNewMethod#getter(String,CtField)
+ * @see CtNewMethod#setter(String,CtField)
+ * @see CtField.Initializer
+ */
+ public CtField(CtField src, CtClass declaring)
+ throws CannotCompileException
+ {
+ this(src.fieldInfo.getDescriptor(), src.fieldInfo.getName(),
+ declaring);
+ java.util.ListIterator iterator
+ = src.fieldInfo.getAttributes().listIterator();
+ FieldInfo fi = fieldInfo;
+ fi.setAccessFlags(src.fieldInfo.getAccessFlags());
+ ConstPool cp = fi.getConstPool();
+ while (iterator.hasNext()) {
+ AttributeInfo ainfo = (AttributeInfo)iterator.next();
+ fi.addAttribute(ainfo.copy(cp, null));
+ }
+ }
+
+ private CtField(String typeDesc, String name, CtClass clazz)
+ throws CannotCompileException
+ {
+ super(clazz);
+ ClassFile cf = clazz.getClassFile2();
+ if (cf == null)
+ throw new CannotCompileException("bad declaring class: "
+ + clazz.getName());
+
+ fieldInfo = new FieldInfo(cf.getConstPool(), name, typeDesc);
+ }
+
+ CtField(FieldInfo fi, CtClass clazz) {
+ super(clazz);
+ fieldInfo = fi;
+ }
+
+ /**
+ * Returns a String representation of the object.
+ */
+ public String toString() {
+ return getDeclaringClass().getName() + "." + getName()
+ + ":" + fieldInfo.getDescriptor();
+ }
+
+ protected void extendToString(StringBuffer buffer) {
+ buffer.append(' ');
+ buffer.append(getName());
+ buffer.append(' ');
+ buffer.append(fieldInfo.getDescriptor());
+ }
+
+ /* Javac.CtFieldWithInit overrides.
+ */
+ protected ASTree getInitAST() { return null; }
+
+ /* Called by CtClassType.addField().
+ */
+ Initializer getInit() {
+ ASTree tree = getInitAST();
+ if (tree == null)
+ return null;
+ else
+ return Initializer.byExpr(tree);
+ }
+
+ /**
+ * Compiles the given source code and creates a field.
+ * Examples of the source code are:
+ *
+ * <ul><pre>
+ * "public String name;"
+ * "public int k = 3;"</pre></ul>
+ *
+ * <p>Note that the source code ends with <code>';'</code>
+ * (semicolon).
+ *
+ * @param src the source text.
+ * @param declaring the class to which the created field is added.
+ */
+ public static CtField make(String src, CtClass declaring)
+ throws CannotCompileException
+ {
+ Javac compiler = new Javac(declaring);
+ try {
+ CtMember obj = compiler.compile(src);
+ if (obj instanceof CtField)
+ return (CtField)obj; // an instance of Javac.CtFieldWithInit
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+
+ throw new CannotCompileException("not a field");
+ }
+
+ /**
+ * Returns the FieldInfo representing the field in the class file.
+ */
+ public FieldInfo getFieldInfo() {
+ declaringClass.checkModify();
+ return fieldInfo;
+ }
+
+ /**
+ * Returns the FieldInfo representing the field in the class
+ * file (read only).
+ * Normal applications do not need calling this method. Use
+ * <code>getFieldInfo()</code>.
+ *
+ * <p>The <code>FieldInfo</code> object obtained by this method
+ * is read only. Changes to this object might not be reflected
+ * on a class file generated by <code>toBytecode()</code>,
+ * <code>toClass()</code>, etc in <code>CtClass</code>.
+ *
+ * <p>This method is available even if the <code>CtClass</code>
+ * containing this field is frozen. However, if the class is
+ * frozen, the <code>FieldInfo</code> might be also pruned.
+ *
+ * @see #getFieldInfo()
+ * @see CtClass#isFrozen()
+ * @see CtClass#prune()
+ */
+ public FieldInfo getFieldInfo2() { return fieldInfo; }
+
+ /**
+ * Returns the class declaring the field.
+ */
+ public CtClass getDeclaringClass() {
+ // this is redundant but for javadoc.
+ return super.getDeclaringClass();
+ }
+
+ /**
+ * Returns the name of the field.
+ */
+ public String getName() {
+ return fieldInfo.getName();
+ }
+
+ /**
+ * Changes the name of the field.
+ */
+ public void setName(String newName) {
+ declaringClass.checkModify();
+ fieldInfo.setName(newName);
+ }
+
+ /**
+ * Returns the encoded modifiers of the field.
+ *
+ * @see Modifier
+ */
+ public int getModifiers() {
+ return AccessFlag.toModifier(fieldInfo.getAccessFlags());
+ }
+
+ /**
+ * Sets the encoded modifiers of the field.
+ *
+ * @see Modifier
+ */
+ public void setModifiers(int mod) {
+ declaringClass.checkModify();
+ fieldInfo.setAccessFlags(AccessFlag.of(mod));
+ }
+
+ /**
+ * Returns true if the class has the specified annotation class.
+ *
+ * @param clz the annotation class.
+ * @return <code>true</code> if the annotation is found, otherwise <code>false</code>.
+ * @since 3.11
+ */
+ public boolean hasAnnotation(Class clz) {
+ FieldInfo fi = getFieldInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.hasAnnotationType(clz, getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the annotation if the class has the specified annotation class.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this field, an <code>Author</code> object is returned.
+ * The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @param clz the annotation class.
+ * @return the annotation if found, otherwise <code>null</code>.
+ * @since 3.11
+ */
+ public Object getAnnotation(Class clz) throws ClassNotFoundException {
+ FieldInfo fi = getFieldInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.getAnnotationType(clz, getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the annotations associated with this field.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAvailableAnnotations()
+ * @since 3.1
+ */
+ public Object[] getAnnotations() throws ClassNotFoundException {
+ return getAnnotations(false);
+ }
+
+ /**
+ * Returns the annotations associated with this field.
+ * If any annotations are not on the classpath, they are not included
+ * in the returned array.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAnnotations()
+ * @since 3.3
+ */
+ public Object[] getAvailableAnnotations(){
+ try {
+ return getAnnotations(true);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException("Unexpected exception", e);
+ }
+ }
+
+ private Object[] getAnnotations(boolean ignoreNotFound) throws ClassNotFoundException {
+ FieldInfo fi = getFieldInfo2();
+ AnnotationsAttribute ainfo = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.invisibleTag);
+ AnnotationsAttribute ainfo2 = (AnnotationsAttribute)
+ fi.getAttribute(AnnotationsAttribute.visibleTag);
+ return CtClassType.toAnnotationType(ignoreNotFound, getDeclaringClass().getClassPool(),
+ ainfo, ainfo2);
+ }
+
+ /**
+ * Returns the character string representing the type of the field.
+ * The field signature is represented by a character string
+ * called a field descriptor, which is defined in the JVM specification.
+ * If two fields have the same type,
+ * <code>getSignature()</code> returns the same string.
+ *
+ * <p>Note that the returned string is not the type signature
+ * contained in the <code>SignatureAttirbute</code>. It is
+ * a descriptor. To obtain a type signature, call the following
+ * methods:
+ *
+ * <ul><pre>getFieldInfo().getAttribute(SignatureAttribute.tag)
+ * </pre></ul>
+ *
+ * @see javassist.bytecode.Descriptor
+ * @see javassist.bytecode.SignatureAttribute
+ */
+ public String getSignature() {
+ return fieldInfo.getDescriptor();
+ }
+
+ /**
+ * Returns the type of the field.
+ */
+ public CtClass getType() throws NotFoundException {
+ return Descriptor.toCtClass(fieldInfo.getDescriptor(),
+ declaringClass.getClassPool());
+ }
+
+ /**
+ * Sets the type of the field.
+ */
+ public void setType(CtClass clazz) {
+ declaringClass.checkModify();
+ fieldInfo.setDescriptor(Descriptor.of(clazz));
+ }
+
+ /**
+ * Returns the value of this field if it is a constant field.
+ * This method works only if the field type is a primitive type
+ * or <code>String</code> type. Otherwise, it returns <code>null</code>.
+ * A constant field is <code>static</code> and <code>final</code>.
+ *
+ * @return a <code>Integer</code>, <code>Long</code>, <code>Float</code>,
+ * <code>Double</code>, <code>Boolean</code>,
+ * or <code>String</code> object
+ * representing the constant value.
+ * <code>null</code> if it is not a constant field
+ * or if the field type is not a primitive type
+ * or <code>String</code>.
+ */
+ public Object getConstantValue() {
+ // When this method is modified,
+ // see also getConstantFieldValue() in TypeChecker.
+
+ int index = fieldInfo.getConstantValue();
+ if (index == 0)
+ return null;
+
+ ConstPool cp = fieldInfo.getConstPool();
+ switch (cp.getTag(index)) {
+ case ConstPool.CONST_Long :
+ return new Long(cp.getLongInfo(index));
+ case ConstPool.CONST_Float :
+ return new Float(cp.getFloatInfo(index));
+ case ConstPool.CONST_Double :
+ return new Double(cp.getDoubleInfo(index));
+ case ConstPool.CONST_Integer :
+ int value = cp.getIntegerInfo(index);
+ // "Z" means boolean type.
+ if ("Z".equals(fieldInfo.getDescriptor()))
+ return new Boolean(value != 0);
+ else
+ return new Integer(value);
+ case ConstPool.CONST_String :
+ return cp.getStringInfo(index);
+ default :
+ throw new RuntimeException("bad tag: " + cp.getTag(index)
+ + " at " + index);
+ }
+ }
+
+ /**
+ * Obtains an attribute with the given name.
+ * If that attribute is not found in the class file, this
+ * method returns null.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ */
+ public byte[] getAttribute(String name) {
+ AttributeInfo ai = fieldInfo.getAttribute(name);
+ if (ai == null)
+ return null;
+ else
+ return ai.get();
+ }
+
+ /**
+ * Adds an attribute. The attribute is saved in the class file.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ * @param data attribute value
+ */
+ public void setAttribute(String name, byte[] data) {
+ declaringClass.checkModify();
+ fieldInfo.addAttribute(new AttributeInfo(fieldInfo.getConstPool(),
+ name, data));
+ }
+
+ // inner classes
+
+ /**
+ * Instances of this class specify how to initialize a field.
+ * <code>Initializer</code> is passed to
+ * <code>CtClass.addField()</code> with a <code>CtField</code>.
+ *
+ * <p>This class cannot be instantiated with the <code>new</code> operator.
+ * Factory methods such as <code>byParameter()</code> and
+ * <code>byNew</code>
+ * must be used for the instantiation. They create a new instance with
+ * the given parameters and return it.
+ *
+ * @see CtClass#addField(CtField,CtField.Initializer)
+ */
+ public static abstract class Initializer {
+ /**
+ * Makes an initializer that assigns a constant integer value.
+ * The field must be integer, short, char, or byte type.
+ */
+ public static Initializer constant(int i) {
+ return new IntInitializer(i);
+ }
+
+ /**
+ * Makes an initializer that assigns a constant boolean value.
+ * The field must be boolean type.
+ */
+ public static Initializer constant(boolean b) {
+ return new IntInitializer(b ? 1 : 0);
+ }
+
+ /**
+ * Makes an initializer that assigns a constant long value.
+ * The field must be long type.
+ */
+ public static Initializer constant(long l) {
+ return new LongInitializer(l);
+ }
+
+ /**
+ * Makes an initializer that assigns a constant float value.
+ * The field must be float type.
+ */
+ public static Initializer constant(float l) {
+ return new FloatInitializer(l);
+ }
+
+ /**
+ * Makes an initializer that assigns a constant double value.
+ * The field must be double type.
+ */
+ public static Initializer constant(double d) {
+ return new DoubleInitializer(d);
+ }
+
+ /**
+ * Makes an initializer that assigns a constant string value.
+ * The field must be <code>java.lang.String</code> type.
+ */
+ public static Initializer constant(String s) {
+ return new StringInitializer(s);
+ }
+
+ /**
+ * Makes an initializer using a constructor parameter.
+ *
+ * <p>The initial value is the
+ * N-th parameter given to the constructor of the object including
+ * the field. If the constructor takes less than N parameters,
+ * the field is not initialized.
+ * If the field is static, it is never initialized.
+ *
+ * @param nth the n-th (>= 0) parameter is used as
+ * the initial value.
+ * If nth is 0, then the first parameter is
+ * used.
+ */
+ public static Initializer byParameter(int nth) {
+ ParamInitializer i = new ParamInitializer();
+ i.nthParam = nth;
+ return i;
+ }
+
+ /**
+ * Makes an initializer creating a new object.
+ *
+ * <p>This initializer creates a new object and uses it as the initial
+ * value of the field. The constructor of the created object receives
+ * the parameter:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the constructor does
+ * not receive any parameters.
+ *
+ * @param objectType the class instantiated for the initial value.
+ */
+ public static Initializer byNew(CtClass objectType) {
+ NewInitializer i = new NewInitializer();
+ i.objectType = objectType;
+ i.stringParams = null;
+ i.withConstructorParams = false;
+ return i;
+ }
+
+ /**
+ * Makes an initializer creating a new object.
+ *
+ * <p>This initializer creates a new object and uses it as the initial
+ * value of the field. The constructor of the created object receives
+ * the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>String[] strs</code> - the character strings specified
+ * by <code>stringParams</code><br>
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the constructor
+ * receives only <code>strs</code>.
+ *
+ * @param objectType the class instantiated for the initial value.
+ * @param stringParams the array of strings passed to the
+ * constructor.
+ */
+ public static Initializer byNew(CtClass objectType,
+ String[] stringParams) {
+ NewInitializer i = new NewInitializer();
+ i.objectType = objectType;
+ i.stringParams = stringParams;
+ i.withConstructorParams = false;
+ return i;
+ }
+
+ /**
+ * Makes an initializer creating a new object.
+ *
+ * <p>This initializer creates a new object and uses it as the initial
+ * value of the field. The constructor of the created object receives
+ * the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>Object[] args</code> - the parameters passed to the
+ * constructor of the object including the
+ * filed.
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the constructor does
+ * not receive any parameters.
+ *
+ * @param objectType the class instantiated for the initial value.
+ *
+ * @see javassist.CtField.Initializer#byNewArray(CtClass,int)
+ * @see javassist.CtField.Initializer#byNewArray(CtClass,int[])
+ */
+ public static Initializer byNewWithParams(CtClass objectType) {
+ NewInitializer i = new NewInitializer();
+ i.objectType = objectType;
+ i.stringParams = null;
+ i.withConstructorParams = true;
+ return i;
+ }
+
+ /**
+ * Makes an initializer creating a new object.
+ *
+ * <p>This initializer creates a new object and uses it as the initial
+ * value of the field. The constructor of the created object receives
+ * the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>String[] strs</code> - the character strings specified
+ * by <code>stringParams</code><br>
+ * <code>Object[] args</code> - the parameters passed to the
+ * constructor of the object including the
+ * filed.
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the constructor receives
+ * only <code>strs</code>.
+ *
+ * @param objectType the class instantiated for the initial value.
+ * @param stringParams the array of strings passed to the
+ * constructor.
+ */
+ public static Initializer byNewWithParams(CtClass objectType,
+ String[] stringParams) {
+ NewInitializer i = new NewInitializer();
+ i.objectType = objectType;
+ i.stringParams = stringParams;
+ i.withConstructorParams = true;
+ return i;
+ }
+
+ /**
+ * Makes an initializer calling a static method.
+ *
+ * <p>This initializer calls a static method and uses the returned
+ * value as the initial value of the field.
+ * The called method receives the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the method does
+ * not receive any parameters.
+ *
+ * <p>The type of the returned value must be the same as the field
+ * type.
+ *
+ * @param methodClass the class that the static method is
+ * declared in.
+ * @param methodName the name of the satic method.
+ */
+ public static Initializer byCall(CtClass methodClass,
+ String methodName) {
+ MethodInitializer i = new MethodInitializer();
+ i.objectType = methodClass;
+ i.methodName = methodName;
+ i.stringParams = null;
+ i.withConstructorParams = false;
+ return i;
+ }
+
+ /**
+ * Makes an initializer calling a static method.
+ *
+ * <p>This initializer calls a static method and uses the returned
+ * value as the initial value of the field. The called method
+ * receives the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>String[] strs</code> - the character strings specified
+ * by <code>stringParams</code><br>
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the method
+ * receive only <code>strs</code>.
+ *
+ * <p>The type of the returned value must be the same as the field
+ * type.
+ *
+ * @param methodClass the class that the static method is
+ * declared in.
+ * @param methodName the name of the satic method.
+ * @param stringParams the array of strings passed to the
+ * static method.
+ */
+ public static Initializer byCall(CtClass methodClass,
+ String methodName,
+ String[] stringParams) {
+ MethodInitializer i = new MethodInitializer();
+ i.objectType = methodClass;
+ i.methodName = methodName;
+ i.stringParams = stringParams;
+ i.withConstructorParams = false;
+ return i;
+ }
+
+ /**
+ * Makes an initializer calling a static method.
+ *
+ * <p>This initializer calls a static method and uses the returned
+ * value as the initial value of the field. The called method
+ * receives the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>Object[] args</code> - the parameters passed to the
+ * constructor of the object including the
+ * filed.
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the method does
+ * not receive any parameters.
+ *
+ * <p>The type of the returned value must be the same as the field
+ * type.
+ *
+ * @param methodClass the class that the static method is
+ * declared in.
+ * @param methodName the name of the satic method.
+ */
+ public static Initializer byCallWithParams(CtClass methodClass,
+ String methodName) {
+ MethodInitializer i = new MethodInitializer();
+ i.objectType = methodClass;
+ i.methodName = methodName;
+ i.stringParams = null;
+ i.withConstructorParams = true;
+ return i;
+ }
+
+ /**
+ * Makes an initializer calling a static method.
+ *
+ * <p>This initializer calls a static method and uses the returned
+ * value as the initial value of the field. The called method
+ * receives the parameters:
+ *
+ * <ul><code>Object obj</code> - the object including the field.<br>
+ * <code>String[] strs</code> - the character strings specified
+ * by <code>stringParams</code><br>
+ * <code>Object[] args</code> - the parameters passed to the
+ * constructor of the object including the
+ * filed.
+ * </ul>
+ *
+ * <p>If the initialized field is static, then the method
+ * receive only <code>strs</code>.
+ *
+ * <p>The type of the returned value must be the same as the field
+ * type.
+ *
+ * @param methodClass the class that the static method is
+ * declared in.
+ * @param methodName the name of the satic method.
+ * @param stringParams the array of strings passed to the
+ * static method.
+ */
+ public static Initializer byCallWithParams(CtClass methodClass,
+ String methodName, String[] stringParams) {
+ MethodInitializer i = new MethodInitializer();
+ i.objectType = methodClass;
+ i.methodName = methodName;
+ i.stringParams = stringParams;
+ i.withConstructorParams = true;
+ return i;
+ }
+
+ /**
+ * Makes an initializer creating a new array.
+ *
+ * @param type the type of the array.
+ * @param size the size of the array.
+ * @throws NotFoundException if the type of the array components
+ * is not found.
+ */
+ public static Initializer byNewArray(CtClass type, int size)
+ throws NotFoundException
+ {
+ return new ArrayInitializer(type.getComponentType(), size);
+ }
+
+ /**
+ * Makes an initializer creating a new multi-dimensional array.
+ *
+ * @param type the type of the array.
+ * @param sizes an <code>int</code> array of the size in every
+ * dimension.
+ * The first element is the size in the first
+ * dimension. The second is in the second, etc.
+ */
+ public static Initializer byNewArray(CtClass type, int[] sizes) {
+ return new MultiArrayInitializer(type, sizes);
+ }
+
+ /**
+ * Makes an initializer.
+ *
+ * @param source initializer expression.
+ */
+ public static Initializer byExpr(String source) {
+ return new CodeInitializer(source);
+ }
+
+ static Initializer byExpr(ASTree source) {
+ return new PtreeInitializer(source);
+ }
+
+ // Check whether this initializer is valid for the field type.
+ // If it is invaild, this method throws an exception.
+ void check(String desc) throws CannotCompileException {}
+
+ // produce codes for initialization
+ abstract int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException;
+
+ // produce codes for initialization
+ abstract int compileIfStatic(CtClass type, String name,
+ Bytecode code, Javac drv) throws CannotCompileException;
+
+ // returns the index of CONSTANT_Integer_info etc
+ // if the value is constant. Otherwise, 0.
+ int getConstantValue(ConstPool cp, CtClass type) { return 0; }
+ }
+
+ static abstract class CodeInitializer0 extends Initializer {
+ abstract void compileExpr(Javac drv) throws CompileError;
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ try {
+ code.addAload(0);
+ compileExpr(drv);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return code.getMaxStack();
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ try {
+ compileExpr(drv);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return code.getMaxStack();
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ int getConstantValue2(ConstPool cp, CtClass type, ASTree tree) {
+ if (type.isPrimitive()) {
+ if (tree instanceof IntConst) {
+ long value = ((IntConst)tree).get();
+ if (type == CtClass.doubleType)
+ return cp.addDoubleInfo((double)value);
+ else if (type == CtClass.floatType)
+ return cp.addFloatInfo((float)value);
+ else if (type == CtClass.longType)
+ return cp.addLongInfo(value);
+ else if (type != CtClass.voidType)
+ return cp.addIntegerInfo((int)value);
+ }
+ else if (tree instanceof DoubleConst) {
+ double value = ((DoubleConst)tree).get();
+ if (type == CtClass.floatType)
+ return cp.addFloatInfo((float)value);
+ else if (type == CtClass.doubleType)
+ return cp.addDoubleInfo(value);
+ }
+ }
+ else if (tree instanceof StringL
+ && type.getName().equals(javaLangString))
+ return cp.addStringInfo(((StringL)tree).get());
+
+ return 0;
+ }
+ }
+
+ static class CodeInitializer extends CodeInitializer0 {
+ private String expression;
+
+ CodeInitializer(String expr) { expression = expr; }
+
+ void compileExpr(Javac drv) throws CompileError {
+ drv.compileExpr(expression);
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ try {
+ ASTree t = Javac.parseExpr(expression, new SymbolTable());
+ return getConstantValue2(cp, type, t);
+ }
+ catch (CompileError e) {
+ return 0;
+ }
+ }
+ }
+
+ static class PtreeInitializer extends CodeInitializer0 {
+ private ASTree expression;
+
+ PtreeInitializer(ASTree expr) { expression = expr; }
+
+ void compileExpr(Javac drv) throws CompileError {
+ drv.compileExpr(expression);
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ return getConstantValue2(cp, type, expression);
+ }
+ }
+
+ /**
+ * A field initialized with a parameter passed to the constructor
+ * of the class containing that field.
+ */
+ static class ParamInitializer extends Initializer {
+ int nthParam;
+
+ ParamInitializer() {}
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ if (parameters != null && nthParam < parameters.length) {
+ code.addAload(0);
+ int nth = nthParamToLocal(nthParam, parameters, false);
+ int s = code.addLoad(nth, type) + 1;
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return s; // stack size
+ }
+ else
+ return 0; // do not initialize
+ }
+
+ /**
+ * Computes the index of the local variable that the n-th parameter
+ * is assigned to.
+ *
+ * @param nth n-th parameter
+ * @param params list of parameter types
+ * @param isStatic true if the method is static.
+ */
+ static int nthParamToLocal(int nth, CtClass[] params,
+ boolean isStatic) {
+ CtClass longType = CtClass.longType;
+ CtClass doubleType = CtClass.doubleType;
+ int k;
+ if (isStatic)
+ k = 0;
+ else
+ k = 1; // 0 is THIS.
+
+ for (int i = 0; i < nth; ++i) {
+ CtClass type = params[i];
+ if (type == longType || type == doubleType)
+ k += 2;
+ else
+ ++k;
+ }
+
+ return k;
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ return 0;
+ }
+ }
+
+ /**
+ * A field initialized with an object created by the new operator.
+ */
+ static class NewInitializer extends Initializer {
+ CtClass objectType;
+ String[] stringParams;
+ boolean withConstructorParams;
+
+ NewInitializer() {}
+
+ /**
+ * Produces codes in which a new object is created and assigned to
+ * the field as the initial value.
+ */
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ int stacksize;
+
+ code.addAload(0);
+ code.addNew(objectType);
+ code.add(Bytecode.DUP);
+ code.addAload(0);
+
+ if (stringParams == null)
+ stacksize = 4;
+ else
+ stacksize = compileStringParameter(code) + 4;
+
+ if (withConstructorParams)
+ stacksize += CtNewWrappedMethod.compileParameterList(code,
+ parameters, 1);
+
+ code.addInvokespecial(objectType, "<init>", getDescriptor());
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return stacksize;
+ }
+
+ private String getDescriptor() {
+ final String desc3
+ = "(Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)V";
+
+ if (stringParams == null)
+ if (withConstructorParams)
+ return "(Ljava/lang/Object;[Ljava/lang/Object;)V";
+ else
+ return "(Ljava/lang/Object;)V";
+ else
+ if (withConstructorParams)
+ return desc3;
+ else
+ return "(Ljava/lang/Object;[Ljava/lang/String;)V";
+ }
+
+ /**
+ * Produces codes for a static field.
+ */
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ String desc;
+
+ code.addNew(objectType);
+ code.add(Bytecode.DUP);
+
+ int stacksize = 2;
+ if (stringParams == null)
+ desc = "()V";
+ else {
+ desc = "([Ljava/lang/String;)V";
+ stacksize += compileStringParameter(code);
+ }
+
+ code.addInvokespecial(objectType, "<init>", desc);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return stacksize;
+ }
+
+ protected final int compileStringParameter(Bytecode code)
+ throws CannotCompileException
+ {
+ int nparam = stringParams.length;
+ code.addIconst(nparam);
+ code.addAnewarray(javaLangString);
+ for (int j = 0; j < nparam; ++j) {
+ code.add(Bytecode.DUP); // dup
+ code.addIconst(j); // iconst_<j>
+ code.addLdc(stringParams[j]); // ldc ...
+ code.add(Bytecode.AASTORE); // aastore
+ }
+
+ return 4;
+ }
+
+ }
+
+ /**
+ * A field initialized with the result of a static method call.
+ */
+ static class MethodInitializer extends NewInitializer {
+ String methodName;
+ // the method class is specified by objectType.
+
+ MethodInitializer() {}
+
+ /**
+ * Produces codes in which a new object is created and assigned to
+ * the field as the initial value.
+ */
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ int stacksize;
+
+ code.addAload(0);
+ code.addAload(0);
+
+ if (stringParams == null)
+ stacksize = 2;
+ else
+ stacksize = compileStringParameter(code) + 2;
+
+ if (withConstructorParams)
+ stacksize += CtNewWrappedMethod.compileParameterList(code,
+ parameters, 1);
+
+ String typeDesc = Descriptor.of(type);
+ String mDesc = getDescriptor() + typeDesc;
+ code.addInvokestatic(objectType, methodName, mDesc);
+ code.addPutfield(Bytecode.THIS, name, typeDesc);
+ return stacksize;
+ }
+
+ private String getDescriptor() {
+ final String desc3
+ = "(Ljava/lang/Object;[Ljava/lang/String;[Ljava/lang/Object;)";
+
+ if (stringParams == null)
+ if (withConstructorParams)
+ return "(Ljava/lang/Object;[Ljava/lang/Object;)";
+ else
+ return "(Ljava/lang/Object;)";
+ else
+ if (withConstructorParams)
+ return desc3;
+ else
+ return "(Ljava/lang/Object;[Ljava/lang/String;)";
+ }
+
+ /**
+ * Produces codes for a static field.
+ */
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ String desc;
+
+ int stacksize = 1;
+ if (stringParams == null)
+ desc = "()";
+ else {
+ desc = "([Ljava/lang/String;)";
+ stacksize += compileStringParameter(code);
+ }
+
+ String typeDesc = Descriptor.of(type);
+ code.addInvokestatic(objectType, methodName, desc + typeDesc);
+ code.addPutstatic(Bytecode.THIS, name, typeDesc);
+ return stacksize;
+ }
+ }
+
+ static class IntInitializer extends Initializer {
+ int value;
+
+ IntInitializer(int v) { value = v; }
+
+ void check(String desc) throws CannotCompileException {
+ char c = desc.charAt(0);
+ if (c != 'I' && c != 'S' && c != 'B' && c != 'C' && c != 'Z')
+ throw new CannotCompileException("type mismatch");
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ code.addIconst(value);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ code.addIconst(value);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 1; // stack size
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ return cp.addIntegerInfo(value);
+ }
+ }
+
+ static class LongInitializer extends Initializer {
+ long value;
+
+ LongInitializer(long v) { value = v; }
+
+ void check(String desc) throws CannotCompileException {
+ if (!desc.equals("J"))
+ throw new CannotCompileException("type mismatch");
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ code.addLdc2w(value);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 3; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ code.addLdc2w(value);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ if (type == CtClass.longType)
+ return cp.addLongInfo(value);
+ else
+ return 0;
+ }
+ }
+
+ static class FloatInitializer extends Initializer {
+ float value;
+
+ FloatInitializer(float v) { value = v; }
+
+ void check(String desc) throws CannotCompileException {
+ if (!desc.equals("F"))
+ throw new CannotCompileException("type mismatch");
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ code.addFconst(value);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 3; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ code.addFconst(value);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ if (type == CtClass.floatType)
+ return cp.addFloatInfo(value);
+ else
+ return 0;
+ }
+ }
+
+ static class DoubleInitializer extends Initializer {
+ double value;
+
+ DoubleInitializer(double v) { value = v; }
+
+ void check(String desc) throws CannotCompileException {
+ if (!desc.equals("D"))
+ throw new CannotCompileException("type mismatch");
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ code.addLdc2w(value);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 3; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ code.addLdc2w(value);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ if (type == CtClass.doubleType)
+ return cp.addDoubleInfo(value);
+ else
+ return 0;
+ }
+ }
+
+ static class StringInitializer extends Initializer {
+ String value;
+
+ StringInitializer(String v) { value = v; }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ code.addLdc(value);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ code.addLdc(value);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 1; // stack size
+ }
+
+ int getConstantValue(ConstPool cp, CtClass type) {
+ if (type.getName().equals(javaLangString))
+ return cp.addStringInfo(value);
+ else
+ return 0;
+ }
+ }
+
+ static class ArrayInitializer extends Initializer {
+ CtClass type;
+ int size;
+
+ ArrayInitializer(CtClass t, int s) { type = t; size = s; }
+
+ private void addNewarray(Bytecode code) {
+ if (type.isPrimitive())
+ code.addNewarray(((CtPrimitiveType)type).getArrayType(),
+ size);
+ else
+ code.addAnewarray(type, size);
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ addNewarray(code);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return 2; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ addNewarray(code);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return 1; // stack size
+ }
+ }
+
+ static class MultiArrayInitializer extends Initializer {
+ CtClass type;
+ int[] dim;
+
+ MultiArrayInitializer(CtClass t, int[] d) { type = t; dim = d; }
+
+ void check(String desc) throws CannotCompileException {
+ if (desc.charAt(0) != '[')
+ throw new CannotCompileException("type mismatch");
+ }
+
+ int compile(CtClass type, String name, Bytecode code,
+ CtClass[] parameters, Javac drv)
+ throws CannotCompileException
+ {
+ code.addAload(0);
+ int s = code.addMultiNewarray(type, dim);
+ code.addPutfield(Bytecode.THIS, name, Descriptor.of(type));
+ return s + 1; // stack size
+ }
+
+ int compileIfStatic(CtClass type, String name, Bytecode code,
+ Javac drv) throws CannotCompileException
+ {
+ int s = code.addMultiNewarray(type, dim);
+ code.addPutstatic(Bytecode.THIS, name, Descriptor.of(type));
+ return s; // stack size
+ }
+ }
+}
diff --git a/src/main/javassist/CtMember.java b/src/main/javassist/CtMember.java
new file mode 100644
index 0000000..0956642
--- /dev/null
+++ b/src/main/javassist/CtMember.java
@@ -0,0 +1,295 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+/**
+ * An instance of <code>CtMember</code> represents a field, a constructor,
+ * or a method.
+ */
+public abstract class CtMember {
+ CtMember next; // for internal use
+ protected CtClass declaringClass;
+
+ /* Make a circular link of CtMembers declared in the
+ * same class so that they are garbage-collected together
+ * at the same time.
+ */
+ static class Cache extends CtMember {
+ protected void extendToString(StringBuffer buffer) {}
+ public boolean hasAnnotation(Class clz) { return false; }
+ public Object getAnnotation(Class clz)
+ throws ClassNotFoundException { return null; }
+ public Object[] getAnnotations()
+ throws ClassNotFoundException { return null; }
+ public byte[] getAttribute(String name) { return null; }
+ public Object[] getAvailableAnnotations() { return null; }
+ public int getModifiers() { return 0; }
+ public String getName() { return null; }
+ public String getSignature() { return null; }
+ public void setAttribute(String name, byte[] data) {}
+ public void setModifiers(int mod) {}
+
+ private CtMember methodTail;
+ private CtMember consTail; // constructor tail
+ private CtMember fieldTail;
+
+ Cache(CtClassType decl) {
+ super(decl);
+ methodTail = this;
+ consTail = this;
+ fieldTail = this;
+ fieldTail.next = this;
+ }
+
+ CtMember methodHead() { return this; }
+ CtMember lastMethod() { return methodTail; }
+ CtMember consHead() { return methodTail; } // may include a static initializer
+ CtMember lastCons() { return consTail; }
+ CtMember fieldHead() { return consTail; }
+ CtMember lastField() { return fieldTail; }
+
+ void addMethod(CtMember method) {
+ method.next = methodTail.next;
+ methodTail.next = method;
+ if (methodTail == consTail) {
+ consTail = method;
+ if (methodTail == fieldTail)
+ fieldTail = method;
+ }
+
+ methodTail = method;
+ }
+
+ /* Both constructors and a class initializer.
+ */
+ void addConstructor(CtMember cons) {
+ cons.next = consTail.next;
+ consTail.next = cons;
+ if (consTail == fieldTail)
+ fieldTail = cons;
+
+ consTail = cons;
+ }
+
+ void addField(CtMember field) {
+ field.next = this; // or fieldTail.next
+ fieldTail.next = field;
+ fieldTail = field;
+ }
+
+ static int count(CtMember head, CtMember tail) {
+ int n = 0;
+ while (head != tail) {
+ n++;
+ head = head.next;
+ }
+
+ return n;
+ }
+
+ void remove(CtMember mem) {
+ CtMember m = this;
+ CtMember node;
+ while ((node = m.next) != this) {
+ if (node == mem) {
+ m.next = node.next;
+ if (node == methodTail)
+ methodTail = m;
+
+ if (node == consTail)
+ consTail = m;
+
+ if (node == fieldTail)
+ fieldTail = m;
+
+ break;
+ }
+ else
+ m = m.next;
+ }
+ }
+ }
+
+ protected CtMember(CtClass clazz) {
+ declaringClass = clazz;
+ next = null;
+ }
+
+ final CtMember next() { return next; }
+
+ /**
+ * This method is invoked when setName() or replaceClassName()
+ * in CtClass is called.
+ *
+ * @see CtMethod#nameReplaced()
+ */
+ void nameReplaced() {}
+
+ public String toString() {
+ StringBuffer buffer = new StringBuffer(getClass().getName());
+ buffer.append("@");
+ buffer.append(Integer.toHexString(hashCode()));
+ buffer.append("[");
+ buffer.append(Modifier.toString(getModifiers()));
+ extendToString(buffer);
+ buffer.append("]");
+ return buffer.toString();
+ }
+
+ /**
+ * Invoked by {@link #toString()} to add to the buffer and provide the
+ * complete value. Subclasses should invoke this method, adding a
+ * space before each token. The modifiers for the member are
+ * provided first; subclasses should provide additional data such
+ * as return type, field or method name, etc.
+ */
+ protected abstract void extendToString(StringBuffer buffer);
+
+ /**
+ * Returns the class that declares this member.
+ */
+ public CtClass getDeclaringClass() { return declaringClass; }
+
+ /**
+ * Returns true if this member is accessible from the given class.
+ */
+ public boolean visibleFrom(CtClass clazz) {
+ int mod = getModifiers();
+ if (Modifier.isPublic(mod))
+ return true;
+ else if (Modifier.isPrivate(mod))
+ return clazz == declaringClass;
+ else { // package or protected
+ String declName = declaringClass.getPackageName();
+ String fromName = clazz.getPackageName();
+ boolean visible;
+ if (declName == null)
+ visible = fromName == null;
+ else
+ visible = declName.equals(fromName);
+
+ if (!visible && Modifier.isProtected(mod))
+ return clazz.subclassOf(declaringClass);
+
+ return visible;
+ }
+ }
+
+ /**
+ * Obtains the modifiers of the member.
+ *
+ * @return modifiers encoded with
+ * <code>javassist.Modifier</code>.
+ * @see Modifier
+ */
+ public abstract int getModifiers();
+
+ /**
+ * Sets the encoded modifiers of the member.
+ *
+ * @see Modifier
+ */
+ public abstract void setModifiers(int mod);
+
+ /**
+ * Returns true if the class has the specified annotation class.
+ *
+ * @param clz the annotation class.
+ * @return <code>true</code> if the annotation is found, otherwise <code>false</code>.
+ * @since 3.11
+ */
+ public abstract boolean hasAnnotation(Class clz);
+
+ /**
+ * Returns the annotation if the class has the specified annotation class.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this member, an <code>Author</code> object is returned.
+ * The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @param clz the annotation class.
+ * @return the annotation if found, otherwise <code>null</code>.
+ * @since 3.11
+ */
+ public abstract Object getAnnotation(Class clz) throws ClassNotFoundException;
+
+ /**
+ * Returns the annotations associated with this member.
+ * For example, if an annotation <code>@Author</code> is associated
+ * with this member, the returned array contains an <code>Author</code>
+ * object. The member values can be obtained by calling methods on
+ * the <code>Author</code> object.
+ *
+ * @return an array of annotation-type objects.
+ * @see CtClass#getAnnotations()
+ */
+ public abstract Object[] getAnnotations() throws ClassNotFoundException;
+
+ /**
+ * Returns the annotations associated with this member.
+ * This method is equivalent to <code>getAnnotations()</code>
+ * except that, if any annotations are not on the classpath,
+ * they are not included in the returned array.
+ *
+ * @return an array of annotation-type objects.
+ * @see #getAnnotations()
+ * @see CtClass#getAvailableAnnotations()
+ * @since 3.3
+ */
+ public abstract Object[] getAvailableAnnotations();
+
+ /**
+ * Obtains the name of the member.
+ *
+ * <p>As for constructor names, see <code>getName()</code>
+ * in <code>CtConstructor</code>.
+ *
+ * @see CtConstructor#getName()
+ */
+ public abstract String getName();
+
+ /**
+ * Returns the character string representing the signature of the member.
+ * If two members have the same signature (parameter types etc.),
+ * <code>getSignature()</code> returns the same string.
+ */
+ public abstract String getSignature();
+
+ /**
+ * Obtains a user-defined attribute with the given name.
+ * If that attribute is not found in the class file, this
+ * method returns null.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ */
+ public abstract byte[] getAttribute(String name);
+
+ /**
+ * Adds a user-defined attribute. The attribute is saved in the class file.
+ *
+ * <p>Note that an attribute is a data block specified by
+ * the class file format.
+ * See {@link javassist.bytecode.AttributeInfo}.
+ *
+ * @param name attribute name
+ * @param data attribute value
+ */
+ public abstract void setAttribute(String name, byte[] data);
+}
diff --git a/src/main/javassist/CtMethod.java b/src/main/javassist/CtMethod.java
new file mode 100644
index 0000000..727ff5b
--- /dev/null
+++ b/src/main/javassist/CtMethod.java
@@ -0,0 +1,435 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+
+/**
+ * An instance of <code>CtMethod</code> represents a method.
+ *
+ * <p>See the super class <code>CtBehavior</code> since
+ * a number of useful methods are in <code>CtBehavior</code>.
+ * A number of useful factory methods are in <code>CtNewMethod</code>.
+ *
+ * @see CtClass#getDeclaredMethods()
+ * @see CtNewMethod
+ */
+public final class CtMethod extends CtBehavior {
+ protected String cachedStringRep;
+
+ /**
+ * @see #make(MethodInfo minfo, CtClass declaring)
+ */
+ CtMethod(MethodInfo minfo, CtClass declaring) {
+ super(declaring, minfo);
+ cachedStringRep = null;
+ }
+
+ /**
+ * Creates a public abstract method. The created method must be
+ * added to a class with <code>CtClass.addMethod()</code>.
+ *
+ * @param declaring the class to which the created method is added.
+ * @param returnType the type of the returned value
+ * @param mname the method name
+ * @param parameters a list of the parameter types
+ *
+ * @see CtClass#addMethod(CtMethod)
+ */
+ public CtMethod(CtClass returnType, String mname,
+ CtClass[] parameters, CtClass declaring) {
+ this(null, declaring);
+ ConstPool cp = declaring.getClassFile2().getConstPool();
+ String desc = Descriptor.ofMethod(returnType, parameters);
+ methodInfo = new MethodInfo(cp, mname, desc);
+ setModifiers(Modifier.PUBLIC | Modifier.ABSTRACT);
+ }
+
+ /**
+ * Creates a copy of a <code>CtMethod</code> object.
+ * The created method must be
+ * added to a class with <code>CtClass.addMethod()</code>.
+ *
+ * <p>All occurrences of class names in the created method
+ * are replaced with names specified by
+ * <code>map</code> if <code>map</code> is not <code>null</code>.
+ *
+ * <p>For example, suppose that a method <code>at()</code> is as
+ * follows:
+ *
+ * <ul><pre>public X at(int i) {
+ * return (X)super.elementAt(i);
+ * }</pre></ul>
+ *
+ * <p>(<code>X</code> is a class name.) If <code>map</code> substitutes
+ * <code>String</code> for <code>X</code>, then the created method is:
+ *
+ * <ul><pre>public String at(int i) {
+ * return (String)super.elementAt(i);
+ * }</pre></ul>
+ *
+ * <p>By default, all the occurrences of the names of the class
+ * declaring <code>at()</code> and the superclass are replaced
+ * with the name of the class and the superclass that the
+ * created method is added to.
+ * This is done whichever <code>map</code> is null or not.
+ * To prevent this replacement, call <code>ClassMap.fix()</code>
+ * or <code>put()</code> to explicitly specify replacement.
+ *
+ * <p><b>Note:</b> if the <code>.class</code> notation (for example,
+ * <code>String.class</code>) is included in an expression, the
+ * Javac compiler may produce a helper method.
+ * Since this constructor never
+ * copies this helper method, the programmers have the responsiblity of
+ * copying it. Otherwise, use <code>Class.forName()</code> in the
+ * expression.
+ *
+ * @param src the source method.
+ * @param declaring the class to which the created method is added.
+ * @param map the hashtable associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ *
+ * @see CtClass#addMethod(CtMethod)
+ * @see ClassMap#fix(String)
+ */
+ public CtMethod(CtMethod src, CtClass declaring, ClassMap map)
+ throws CannotCompileException
+ {
+ this(null, declaring);
+ copy(src, false, map);
+ }
+
+ /**
+ * Compiles the given source code and creates a method.
+ * This method simply delegates to <code>make()</code> in
+ * <code>CtNewMethod</code>. See it for more details.
+ * <code>CtNewMethod</code> has a number of useful factory methods.
+ *
+ * @param src the source text.
+ * @param declaring the class to which the created method is added.
+ * @see CtNewMethod#make(String, CtClass)
+ */
+ public static CtMethod make(String src, CtClass declaring)
+ throws CannotCompileException
+ {
+ return CtNewMethod.make(src, declaring);
+ }
+
+ /**
+ * Creates a method from a <code>MethodInfo</code> object.
+ *
+ * @param declaring the class declaring the method.
+ * @throws CannotCompileException if the the <code>MethodInfo</code>
+ * object and the declaring class have different
+ * <code>ConstPool</code> objects
+ * @since 3.6
+ */
+ public static CtMethod make(MethodInfo minfo, CtClass declaring)
+ throws CannotCompileException
+ {
+ if (declaring.getClassFile2().getConstPool() != minfo.getConstPool())
+ throw new CannotCompileException("bad declaring class");
+
+ return new CtMethod(minfo, declaring);
+ }
+
+ /**
+ * Returns a hash code value for the method.
+ * If two methods have the same name and signature, then
+ * the hash codes for the two methods are equal.
+ */
+ public int hashCode() {
+ return getStringRep().hashCode();
+ }
+
+ /**
+ * This method is invoked when setName() or replaceClassName()
+ * in CtClass is called.
+ */
+ void nameReplaced() {
+ cachedStringRep = null;
+ }
+
+ /* This method is also called by CtClassType.getMethods0().
+ */
+ final String getStringRep() {
+ if (cachedStringRep == null)
+ cachedStringRep = methodInfo.getName()
+ + Descriptor.getParamDescriptor(methodInfo.getDescriptor());
+
+ return cachedStringRep;
+ }
+
+ /**
+ * Indicates whether <code>obj</code> has the same name and the
+ * same signature as this method.
+ */
+ public boolean equals(Object obj) {
+ return obj != null && obj instanceof CtMethod
+ && ((CtMethod)obj).getStringRep().equals(getStringRep());
+ }
+
+ /**
+ * Returns the method name followed by parameter types
+ * such as <code>javassist.CtMethod.setBody(String)</code>.
+ *
+ * @since 3.5
+ */
+ public String getLongName() {
+ return getDeclaringClass().getName() + "."
+ + getName() + Descriptor.toString(getSignature());
+ }
+
+ /**
+ * Obtains the name of this method.
+ */
+ public String getName() {
+ return methodInfo.getName();
+ }
+
+ /**
+ * Changes the name of this method.
+ */
+ public void setName(String newname) {
+ declaringClass.checkModify();
+ methodInfo.setName(newname);
+ }
+
+ /**
+ * Obtains the type of the returned value.
+ */
+ public CtClass getReturnType() throws NotFoundException {
+ return getReturnType0();
+ }
+
+ /**
+ * Returns true if the method body is empty, that is, <code>{}</code>.
+ * It also returns true if the method is an abstract method.
+ */
+ public boolean isEmpty() {
+ CodeAttribute ca = getMethodInfo2().getCodeAttribute();
+ if (ca == null) // abstract or native
+ return (getModifiers() & Modifier.ABSTRACT) != 0;
+
+ CodeIterator it = ca.iterator();
+ try {
+ return it.hasNext() && it.byteAt(it.next()) == Opcode.RETURN
+ && !it.hasNext();
+ }
+ catch (BadBytecode e) {}
+ return false;
+ }
+
+ /**
+ * Copies a method body from another method.
+ * If this method is abstract, the abstract modifier is removed
+ * after the method body is copied.
+ *
+ * <p>All occurrences of the class names in the copied method body
+ * are replaced with the names specified by
+ * <code>map</code> if <code>map</code> is not <code>null</code>.
+ *
+ * @param src the method that the body is copied from.
+ * @param map the hashtable associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ */
+ public void setBody(CtMethod src, ClassMap map)
+ throws CannotCompileException
+ {
+ setBody0(src.declaringClass, src.methodInfo,
+ declaringClass, methodInfo, map);
+ }
+
+ /**
+ * Replace a method body with a new method body wrapping the
+ * given method.
+ *
+ * @param mbody the wrapped method
+ * @param constParam the constant parameter given to
+ * the wrapped method
+ * (maybe <code>null</code>).
+ *
+ * @see CtNewMethod#wrapped(CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)
+ */
+ public void setWrappedBody(CtMethod mbody, ConstParameter constParam)
+ throws CannotCompileException
+ {
+ declaringClass.checkModify();
+
+ CtClass clazz = getDeclaringClass();
+ CtClass[] params;
+ CtClass retType;
+ try {
+ params = getParameterTypes();
+ retType = getReturnType();
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ Bytecode code = CtNewWrappedMethod.makeBody(clazz,
+ clazz.getClassFile2(),
+ mbody,
+ params, retType,
+ constParam);
+ CodeAttribute cattr = code.toCodeAttribute();
+ methodInfo.setCodeAttribute(cattr);
+ methodInfo.setAccessFlags(methodInfo.getAccessFlags()
+ & ~AccessFlag.ABSTRACT);
+ // rebuilding a stack map table is not needed.
+ }
+
+ // inner classes
+
+ /**
+ * Instances of this class represent a constant parameter.
+ * They are used to specify the parameter given to the methods
+ * created by <code>CtNewMethod.wrapped()</code>.
+ *
+ * @see CtMethod#setWrappedBody(CtMethod,CtMethod.ConstParameter)
+ * @see CtNewMethod#wrapped(CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)
+ * @see CtNewConstructor#make(CtClass[],CtClass[],int,CtMethod,CtMethod.ConstParameter,CtClass)
+ */
+ public static class ConstParameter {
+ /**
+ * Makes an integer constant.
+ *
+ * @param i the constant value.
+ */
+ public static ConstParameter integer(int i) {
+ return new IntConstParameter(i);
+ }
+
+ /**
+ * Makes a long integer constant.
+ *
+ * @param i the constant value.
+ */
+ public static ConstParameter integer(long i) {
+ return new LongConstParameter(i);
+ }
+
+ /**
+ * Makes an <code>String</code> constant.
+ *
+ * @param s the constant value.
+ */
+ public static ConstParameter string(String s) {
+ return new StringConstParameter(s);
+ }
+
+ ConstParameter() {}
+
+ /**
+ * @return the size of the stack consumption.
+ */
+ int compile(Bytecode code) throws CannotCompileException {
+ return 0;
+ }
+
+ String descriptor() {
+ return defaultDescriptor();
+ }
+
+ /**
+ * @see CtNewWrappedMethod
+ */
+ static String defaultDescriptor() {
+ return "([Ljava/lang/Object;)Ljava/lang/Object;";
+ }
+
+ /**
+ * Returns the descriptor for constructors.
+ *
+ * @see CtNewWrappedConstructor
+ */
+ String constDescriptor() {
+ return defaultConstDescriptor();
+ }
+
+ /**
+ * Returns the default descriptor for constructors.
+ */
+ static String defaultConstDescriptor() {
+ return "([Ljava/lang/Object;)V";
+ }
+ }
+
+ static class IntConstParameter extends ConstParameter {
+ int param;
+
+ IntConstParameter(int i) {
+ param = i;
+ }
+
+ int compile(Bytecode code) throws CannotCompileException {
+ code.addIconst(param);
+ return 1;
+ }
+
+ String descriptor() {
+ return "([Ljava/lang/Object;I)Ljava/lang/Object;";
+ }
+
+ String constDescriptor() {
+ return "([Ljava/lang/Object;I)V";
+ }
+ }
+
+ static class LongConstParameter extends ConstParameter {
+ long param;
+
+ LongConstParameter(long l) {
+ param = l;
+ }
+
+ int compile(Bytecode code) throws CannotCompileException {
+ code.addLconst(param);
+ return 2;
+ }
+
+ String descriptor() {
+ return "([Ljava/lang/Object;J)Ljava/lang/Object;";
+ }
+
+ String constDescriptor() {
+ return "([Ljava/lang/Object;J)V";
+ }
+ }
+
+ static class StringConstParameter extends ConstParameter {
+ String param;
+
+ StringConstParameter(String s) {
+ param = s;
+ }
+
+ int compile(Bytecode code) throws CannotCompileException {
+ code.addLdc(param);
+ return 1;
+ }
+
+ String descriptor() {
+ return "([Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;";
+ }
+
+ String constDescriptor() {
+ return "([Ljava/lang/Object;Ljava/lang/String;)V";
+ }
+ }
+}
diff --git a/src/main/javassist/CtNewClass.java b/src/main/javassist/CtNewClass.java
new file mode 100644
index 0000000..ba48e93
--- /dev/null
+++ b/src/main/javassist/CtNewClass.java
@@ -0,0 +1,125 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.DataOutputStream;
+import java.io.IOException;
+import javassist.bytecode.ClassFile;
+
+class CtNewClass extends CtClassType {
+ /* true if the class is an interface.
+ */
+ protected boolean hasConstructor;
+
+ CtNewClass(String name, ClassPool cp,
+ boolean isInterface, CtClass superclass) {
+ super(name, cp);
+ wasChanged = true;
+ String superName;
+ if (isInterface || superclass == null)
+ superName = null;
+ else
+ superName = superclass.getName();
+
+ classfile = new ClassFile(isInterface, name, superName);
+ if (isInterface && superclass != null)
+ classfile.setInterfaces(new String[] { superclass.getName() });
+
+ setModifiers(Modifier.setPublic(getModifiers()));
+ hasConstructor = isInterface;
+ }
+
+ protected void extendToString(StringBuffer buffer) {
+ if (hasConstructor)
+ buffer.append("hasConstructor ");
+
+ super.extendToString(buffer);
+ }
+
+ public void addConstructor(CtConstructor c)
+ throws CannotCompileException
+ {
+ hasConstructor = true;
+ super.addConstructor(c);
+ }
+
+ public void toBytecode(DataOutputStream out)
+ throws CannotCompileException, IOException
+ {
+ if (!hasConstructor)
+ try {
+ inheritAllConstructors();
+ hasConstructor = true;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ super.toBytecode(out);
+ }
+
+ /**
+ * Adds constructors inhrited from the super class.
+ *
+ * <p>After this method is called, the class inherits all the
+ * constructors from the super class. The added constructor
+ * calls the super's constructor with the same signature.
+ */
+ public void inheritAllConstructors()
+ throws CannotCompileException, NotFoundException
+ {
+ CtClass superclazz;
+ CtConstructor[] cs;
+
+ superclazz = getSuperclass();
+ cs = superclazz.getDeclaredConstructors();
+
+ int n = 0;
+ for (int i = 0; i < cs.length; ++i) {
+ CtConstructor c = cs[i];
+ int mod = c.getModifiers();
+ if (isInheritable(mod, superclazz)) {
+ CtConstructor cons
+ = CtNewConstructor.make(c.getParameterTypes(),
+ c.getExceptionTypes(), this);
+ cons.setModifiers(mod & (Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE));
+ addConstructor(cons);
+ ++n;
+ }
+ }
+
+ if (n < 1)
+ throw new CannotCompileException(
+ "no inheritable constructor in " + superclazz.getName());
+
+ }
+
+ private boolean isInheritable(int mod, CtClass superclazz) {
+ if (Modifier.isPrivate(mod))
+ return false;
+
+ if (Modifier.isPackage(mod)) {
+ String pname = getPackageName();
+ String pname2 = superclazz.getPackageName();
+ if (pname == null)
+ return pname2 == null;
+ else
+ return pname.equals(pname2);
+ }
+
+ return true;
+ }
+}
diff --git a/src/main/javassist/CtNewConstructor.java b/src/main/javassist/CtNewConstructor.java
new file mode 100644
index 0000000..f510356
--- /dev/null
+++ b/src/main/javassist/CtNewConstructor.java
@@ -0,0 +1,316 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.Javac;
+import javassist.compiler.CompileError;
+import javassist.CtMethod.ConstParameter;
+
+/**
+ * A collection of static methods for creating a <code>CtConstructor</code>.
+ * An instance of this class does not make any sense.
+ *
+ * <p>A class initializer (static constructor) cannot be created by the
+ * methods in this class. Call <code>makeClassInitializer()</code> in
+ * <code>CtClass</code> and append code snippet to the body of the class
+ * initializer obtained by <code>makeClassInitializer()</code>.
+ *
+ * @see CtClass#addConstructor(CtConstructor)
+ * @see CtClass#makeClassInitializer()
+ */
+public class CtNewConstructor {
+ /**
+ * Specifies that no parameters are passed to a super-class'
+ * constructor. That is, the default constructor is invoked.
+ */
+ public static final int PASS_NONE = 0; // call super()
+
+ /**
+ * Specifies that parameters are converted into an array of
+ * <code>Object</code> and passed to a super-class'
+ * constructor.
+ */
+ public static final int PASS_ARRAY = 1; // an array of parameters
+
+ /**
+ * Specifies that parameters are passed <i>as is</i>
+ * to a super-class' constructor. The signature of that
+ * constructor must be the same as that of the created constructor.
+ */
+ public static final int PASS_PARAMS = 2;
+
+ /**
+ * Compiles the given source code and creates a constructor.
+ * The source code must include not only the constructor body
+ * but the whole declaration.
+ *
+ * @param src the source text.
+ * @param declaring the class to which the created constructor is added.
+ */
+ public static CtConstructor make(String src, CtClass declaring)
+ throws CannotCompileException
+ {
+ Javac compiler = new Javac(declaring);
+ try {
+ CtMember obj = compiler.compile(src);
+ if (obj instanceof CtConstructor) {
+ // a stack map table has been already created.
+ return (CtConstructor)obj;
+ }
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+
+ throw new CannotCompileException("not a constructor");
+ }
+
+ /**
+ * Creates a public constructor.
+ *
+ * @param parameters a list of the parameter types.
+ * @param exceptions a list of the exception types.
+ * @param body the source text of the constructor body.
+ * It must be a block surrounded by <code>{}</code>.
+ * If it is <code>null</code>, the substituted
+ * constructor body does nothing except calling
+ * <code>super()</code>.
+ * @param declaring the class to which the created method is added.
+ */
+ public static CtConstructor make(CtClass[] parameters,
+ CtClass[] exceptions,
+ String body, CtClass declaring)
+ throws CannotCompileException
+ {
+ try {
+ CtConstructor cc = new CtConstructor(parameters, declaring);
+ cc.setExceptionTypes(exceptions);
+ cc.setBody(body);
+ return cc;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Creates a copy of a constructor.
+ * This is a convenience method for calling
+ * {@link CtConstructor#CtConstructor(CtConstructor, CtClass, ClassMap) this constructor}.
+ * See the description of the constructor for particular behavior of the copying.
+ *
+ * @param c the copied constructor.
+ * @param declaring the class to which the created method is added.
+ * @param map the hash table associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ *
+ * @see CtConstructor#CtConstructor(CtConstructor,CtClass,ClassMap)
+ */
+ public static CtConstructor copy(CtConstructor c, CtClass declaring,
+ ClassMap map) throws CannotCompileException {
+ return new CtConstructor(c, declaring, map);
+ }
+
+ /**
+ * Creates a default (public) constructor.
+ *
+ * <p>The created constructor takes no parameter. It calls
+ * <code>super()</code>.
+ */
+ public static CtConstructor defaultConstructor(CtClass declaring)
+ throws CannotCompileException
+ {
+ CtConstructor cons = new CtConstructor((CtClass[])null, declaring);
+
+ ConstPool cp = declaring.getClassFile2().getConstPool();
+ Bytecode code = new Bytecode(cp, 1, 1);
+ code.addAload(0);
+ try {
+ code.addInvokespecial(declaring.getSuperclass(),
+ "<init>", "()V");
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ code.add(Bytecode.RETURN);
+
+ // no need to construct a stack map table.
+ cons.getMethodInfo2().setCodeAttribute(code.toCodeAttribute());
+ return cons;
+ }
+
+ /**
+ * Creates a public constructor that only calls a constructor
+ * in the super class. The created constructor receives parameters
+ * specified by <code>parameters</code> but calls the super's
+ * constructor without those parameters (that is, it calls the default
+ * constructor).
+ *
+ * <p>The parameters passed to the created constructor should be
+ * used for field initialization. <code>CtField.Initializer</code>
+ * objects implicitly insert initialization code in constructor
+ * bodies.
+ *
+ * @param parameters parameter types
+ * @param exceptions exception types
+ * @param declaring the class to which the created constructor
+ * is added.
+ * @see CtField.Initializer#byParameter(int)
+ */
+ public static CtConstructor skeleton(CtClass[] parameters,
+ CtClass[] exceptions, CtClass declaring)
+ throws CannotCompileException
+ {
+ return make(parameters, exceptions, PASS_NONE,
+ null, null, declaring);
+ }
+
+ /**
+ * Creates a public constructor that only calls a constructor
+ * in the super class. The created constructor receives parameters
+ * specified by <code>parameters</code> and calls the super's
+ * constructor with those parameters.
+ *
+ * @param parameters parameter types
+ * @param exceptions exception types
+ * @param declaring the class to which the created constructor
+ * is added.
+ */
+ public static CtConstructor make(CtClass[] parameters,
+ CtClass[] exceptions, CtClass declaring)
+ throws CannotCompileException
+ {
+ return make(parameters, exceptions, PASS_PARAMS,
+ null, null, declaring);
+ }
+
+ /**
+ * Creates a public constructor.
+ *
+ * <p>If <code>howto</code> is <code>PASS_PARAMS</code>,
+ * the created constructor calls the super's constructor with the
+ * same signature. The superclass must contain
+ * a constructor taking the same set of parameters as the created one.
+ *
+ * <p>If <code>howto</code> is <code>PASS_NONE</code>,
+ * the created constructor calls the super's default constructor.
+ * The superclass must contain a constructor taking no parameters.
+ *
+ * <p>If <code>howto</code> is <code>PASS_ARRAY</code>,
+ * the created constructor calls the super's constructor
+ * with the given parameters in the form of an array of
+ * <code>Object</code>. The signature of the super's constructor
+ * must be:
+ *
+ * <ul><code>constructor(Object[] params, <type> cvalue)
+ * </code></ul>
+ *
+ * <p>Here, <code>cvalue</code> is the constant value specified
+ * by <code>cparam</code>.
+ *
+ * <p>If <code>cparam</code> is <code>null</code>, the signature
+ * must be:
+ *
+ * <ul><code>constructor(Object[] params)</code></ul>
+ *
+ * <p>If <code>body</code> is not null, a copy of that method is
+ * embedded in the body of the created constructor.
+ * The embedded method is executed after
+ * the super's constructor is called and the values of fields are
+ * initialized. Note that <code>body</code> must not
+ * be a constructor but a method.
+ *
+ * <p>Since the embedded method is wrapped
+ * in parameter-conversion code
+ * as in <code>CtNewMethod.wrapped()</code>,
+ * the constructor parameters are
+ * passed in the form of an array of <code>Object</code>.
+ * The method specified by <code>body</code> must have the
+ * signature shown below:
+ *
+ * <ul><code>Object method(Object[] params, <type> cvalue)
+ * </code></ul>
+ *
+ * <p>If <code>cparam</code> is <code>null</code>, the signature
+ * must be:
+ *
+ * <ul><code>Object method(Object[] params)</code></ul>
+ *
+ * <p>Although the type of the returned value is <code>Object</code>,
+ * the value must be always <code>null</code>.
+ *
+ * <p><i>Example:</i>
+ *
+ * <ul><pre>ClassPool pool = ... ;
+ * CtClass xclass = pool.makeClass("X");
+ * CtMethod method = pool.getMethod("Sample", "m");
+ * xclass.setSuperclass(pool.get("Y"));
+ * CtClass[] argTypes = { CtClass.intType };
+ * ConstParameter cparam = ConstParameter.string("test");
+ * CtConstructor c = CtNewConstructor.make(argTypes, null,
+ * PASS_PARAMS, method, cparam, xclass);
+ * xclass.addConstructor(c);</pre></ul>
+ *
+ * <p>where the class <code>Sample</code> is as follows:
+ *
+ * <ul><pre>public class Sample {
+ * public Object m(Object[] args, String msg) {
+ * System.out.println(msg);
+ * return null;
+ * }
+ * }</pre></ul>
+ *
+ * <p>This program produces the following class:
+ *
+ * <ul><pre>public class X extends Y {
+ * public X(int p0) {
+ * super(p0);
+ * String msg = "test";
+ * Object[] args = new Object[] { p0 };
+ * // begin of copied body
+ * System.out.println(msg);
+ * Object result = null;
+ * // end
+ * }
+ * }</pre></ul>
+ *
+ * @param parameters a list of the parameter types
+ * @param exceptions a list of the exceptions
+ * @param howto how to pass parameters to the super-class'
+ * constructor (<code>PASS_NONE</code>,
+ * <code>PASS_ARRAY</code>,
+ * or <code>PASS_PARAMS</code>)
+ * @param body appended body (may be <code>null</code>).
+ * It must be not a constructor but a method.
+ * @param cparam constant parameter (may be <code>null</code>.)
+ * @param declaring the class to which the created constructor
+ * is added.
+ *
+ * @see CtNewMethod#wrapped(CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)
+ */
+ public static CtConstructor make(CtClass[] parameters,
+ CtClass[] exceptions, int howto,
+ CtMethod body, ConstParameter cparam,
+ CtClass declaring)
+ throws CannotCompileException
+ {
+ return CtNewWrappedConstructor.wrapped(parameters, exceptions,
+ howto, body, cparam, declaring);
+ }
+}
diff --git a/src/main/javassist/CtNewMethod.java b/src/main/javassist/CtNewMethod.java
new file mode 100644
index 0000000..ec2a5fa
--- /dev/null
+++ b/src/main/javassist/CtNewMethod.java
@@ -0,0 +1,470 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.Javac;
+import javassist.compiler.CompileError;
+import javassist.CtMethod.ConstParameter;
+
+/**
+ * A collection of static methods for creating a <code>CtMethod</code>.
+ * An instance of this class does not make any sense.
+ *
+ * @see CtClass#addMethod(CtMethod)
+ */
+public class CtNewMethod {
+
+ /**
+ * Compiles the given source code and creates a method.
+ * The source code must include not only the method body
+ * but the whole declaration, for example,
+ *
+ * <ul><pre>"public Object id(Object obj) { return obj; }"</pre></ul>
+ *
+ * @param src the source text.
+ * @param declaring the class to which the created method is added.
+ */
+ public static CtMethod make(String src, CtClass declaring)
+ throws CannotCompileException
+ {
+ return make(src, declaring, null, null);
+ }
+
+ /**
+ * Compiles the given source code and creates a method.
+ * The source code must include not only the method body
+ * but the whole declaration, for example,
+ *
+ * <ul><pre>"public Object id(Object obj) { return obj; }"</pre></ul>
+ *
+ * <p>If the source code includes <code>$proceed()</code>, then
+ * it is compiled into a method call on the specified object.
+ *
+ * @param src the source text.
+ * @param declaring the class to which the created method is added.
+ * @param delegateObj the source text specifying the object
+ * that is called on by <code>$proceed()</code>.
+ * @param delegateMethod the name of the method
+ * that is called by <code>$proceed()</code>.
+ */
+ public static CtMethod make(String src, CtClass declaring,
+ String delegateObj, String delegateMethod)
+ throws CannotCompileException
+ {
+ Javac compiler = new Javac(declaring);
+ try {
+ if (delegateMethod != null)
+ compiler.recordProceed(delegateObj, delegateMethod);
+
+ CtMember obj = compiler.compile(src);
+ if (obj instanceof CtMethod)
+ return (CtMethod)obj;
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+
+ throw new CannotCompileException("not a method");
+ }
+
+ /**
+ * Creates a public (non-static) method. The created method cannot
+ * be changed to a static method later.
+ *
+ * @param returnType the type of the returned value.
+ * @param mname the method name.
+ * @param parameters a list of the parameter types.
+ * @param exceptions a list of the exception types.
+ * @param body the source text of the method body.
+ * It must be a block surrounded by <code>{}</code>.
+ * If it is <code>null</code>, the created method
+ * does nothing except returning zero or null.
+ * @param declaring the class to which the created method is added.
+ * @see #make(int, CtClass, String, CtClass[], CtClass[], String, CtClass)
+ */
+ public static CtMethod make(CtClass returnType,
+ String mname, CtClass[] parameters,
+ CtClass[] exceptions,
+ String body, CtClass declaring)
+ throws CannotCompileException
+ {
+ return make(Modifier.PUBLIC, returnType, mname, parameters, exceptions,
+ body, declaring);
+ }
+
+ /**
+ * Creates a method. <code>modifiers</code> can contain
+ * <code>Modifier.STATIC</code>.
+ *
+ * @param modifiers access modifiers.
+ * @param returnType the type of the returned value.
+ * @param mname the method name.
+ * @param parameters a list of the parameter types.
+ * @param exceptions a list of the exception types.
+ * @param body the source text of the method body.
+ * It must be a block surrounded by <code>{}</code>.
+ * If it is <code>null</code>, the created method
+ * does nothing except returning zero or null.
+ * @param declaring the class to which the created method is added.
+ *
+ * @see Modifier
+ */
+ public static CtMethod make(int modifiers, CtClass returnType,
+ String mname, CtClass[] parameters,
+ CtClass[] exceptions,
+ String body, CtClass declaring)
+ throws CannotCompileException
+ {
+ try {
+ CtMethod cm
+ = new CtMethod(returnType, mname, parameters, declaring);
+ cm.setModifiers(modifiers);
+ cm.setExceptionTypes(exceptions);
+ cm.setBody(body);
+ return cm;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Creates a copy of a method. This method is provided for creating
+ * a new method based on an existing method.
+ * This is a convenience method for calling
+ * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}.
+ * See the description of the constructor for particular behavior of the copying.
+ *
+ * @param src the source method.
+ * @param declaring the class to which the created method is added.
+ * @param map the hash table associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ *
+ * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap)
+ */
+ public static CtMethod copy(CtMethod src, CtClass declaring,
+ ClassMap map) throws CannotCompileException {
+ return new CtMethod(src, declaring, map);
+ }
+
+ /**
+ * Creates a copy of a method with a new name.
+ * This method is provided for creating
+ * a new method based on an existing method.
+ * This is a convenience method for calling
+ * {@link CtMethod#CtMethod(CtMethod, CtClass, ClassMap) this constructor}.
+ * See the description of the constructor for particular behavior of the copying.
+ *
+ * @param src the source method.
+ * @param name the name of the created method.
+ * @param declaring the class to which the created method is added.
+ * @param map the hash table associating original class names
+ * with substituted names.
+ * It can be <code>null</code>.
+ *
+ * @see CtMethod#CtMethod(CtMethod,CtClass,ClassMap)
+ */
+ public static CtMethod copy(CtMethod src, String name, CtClass declaring,
+ ClassMap map) throws CannotCompileException {
+ CtMethod cm = new CtMethod(src, declaring, map);
+ cm.setName(name);
+ return cm;
+ }
+
+ /**
+ * Creates a public abstract method.
+ *
+ * @param returnType the type of the returned value
+ * @param mname the method name
+ * @param parameters a list of the parameter types
+ * @param exceptions a list of the exception types
+ * @param declaring the class to which the created method is added.
+ *
+ * @see CtMethod#CtMethod(CtClass,String,CtClass[],CtClass)
+ */
+ public static CtMethod abstractMethod(CtClass returnType,
+ String mname,
+ CtClass[] parameters,
+ CtClass[] exceptions,
+ CtClass declaring)
+ throws NotFoundException
+ {
+ CtMethod cm = new CtMethod(returnType, mname, parameters, declaring);
+ cm.setExceptionTypes(exceptions);
+ return cm;
+ }
+
+ /**
+ * Creates a public getter method. The getter method returns the value
+ * of the specified field in the class to which this method is added.
+ * The created method is initially not static even if the field is
+ * static. Change the modifiers if the method should be static.
+ *
+ * @param methodName the name of the getter
+ * @param field the field accessed.
+ */
+ public static CtMethod getter(String methodName, CtField field)
+ throws CannotCompileException
+ {
+ FieldInfo finfo = field.getFieldInfo2();
+ String fieldType = finfo.getDescriptor();
+ String desc = "()" + fieldType;
+ ConstPool cp = finfo.getConstPool();
+ MethodInfo minfo = new MethodInfo(cp, methodName, desc);
+ minfo.setAccessFlags(AccessFlag.PUBLIC);
+
+ Bytecode code = new Bytecode(cp, 2, 1);
+ try {
+ String fieldName = finfo.getName();
+ if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
+ code.addAload(0);
+ code.addGetfield(Bytecode.THIS, fieldName, fieldType);
+ }
+ else
+ code.addGetstatic(Bytecode.THIS, fieldName, fieldType);
+
+ code.addReturn(field.getType());
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ return new CtMethod(minfo, field.getDeclaringClass());
+ }
+
+ /**
+ * Creates a public setter method. The setter method assigns the
+ * value of the first parameter to the specified field
+ * in the class to which this method is added.
+ * The created method is not static even if the field is
+ * static. You may not change it to be static
+ * by <code>setModifiers()</code> in <code>CtBehavior</code>.
+ *
+ * @param methodName the name of the setter
+ * @param field the field accessed.
+ */
+ public static CtMethod setter(String methodName, CtField field)
+ throws CannotCompileException
+ {
+ FieldInfo finfo = field.getFieldInfo2();
+ String fieldType = finfo.getDescriptor();
+ String desc = "(" + fieldType + ")V";
+ ConstPool cp = finfo.getConstPool();
+ MethodInfo minfo = new MethodInfo(cp, methodName, desc);
+ minfo.setAccessFlags(AccessFlag.PUBLIC);
+
+ Bytecode code = new Bytecode(cp, 3, 3);
+ try {
+ String fieldName = finfo.getName();
+ if ((finfo.getAccessFlags() & AccessFlag.STATIC) == 0) {
+ code.addAload(0);
+ code.addLoad(1, field.getType());
+ code.addPutfield(Bytecode.THIS, fieldName, fieldType);
+ }
+ else {
+ code.addLoad(1, field.getType());
+ code.addPutstatic(Bytecode.THIS, fieldName, fieldType);
+ }
+
+ code.addReturn(null);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ return new CtMethod(minfo, field.getDeclaringClass());
+ }
+
+ /**
+ * Creates a method forwarding to a delegate in
+ * a super class. The created method calls a method specified
+ * by <code>delegate</code> with all the parameters passed to the
+ * created method. If the delegate method returns a value,
+ * the created method returns that value to the caller.
+ * The delegate method must be declared in a super class.
+ *
+ * <p>The following method is an example of the created method.
+ *
+ * <ul><pre>int f(int p, int q) {
+ * return super.f(p, q);
+ * }</pre></ul>
+ *
+ * <p>The name of the created method can be changed by
+ * <code>setName()</code>.
+ *
+ * @param delegate the method that the created method forwards to.
+ * @param declaring the class to which the created method is
+ * added.
+ */
+ public static CtMethod delegator(CtMethod delegate, CtClass declaring)
+ throws CannotCompileException
+ {
+ try {
+ return delegator0(delegate, declaring);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private static CtMethod delegator0(CtMethod delegate, CtClass declaring)
+ throws CannotCompileException, NotFoundException
+ {
+ MethodInfo deleInfo = delegate.getMethodInfo2();
+ String methodName = deleInfo.getName();
+ String desc = deleInfo.getDescriptor();
+ ConstPool cp = declaring.getClassFile2().getConstPool();
+ MethodInfo minfo = new MethodInfo(cp, methodName, desc);
+ minfo.setAccessFlags(deleInfo.getAccessFlags());
+
+ ExceptionsAttribute eattr = deleInfo.getExceptionsAttribute();
+ if (eattr != null)
+ minfo.setExceptionsAttribute(
+ (ExceptionsAttribute)eattr.copy(cp, null));
+
+ Bytecode code = new Bytecode(cp, 0, 0);
+ boolean isStatic = Modifier.isStatic(delegate.getModifiers());
+ CtClass deleClass = delegate.getDeclaringClass();
+ CtClass[] params = delegate.getParameterTypes();
+ int s;
+ if (isStatic) {
+ s = code.addLoadParameters(params, 0);
+ code.addInvokestatic(deleClass, methodName, desc);
+ }
+ else {
+ code.addLoad(0, deleClass);
+ s = code.addLoadParameters(params, 1);
+ code.addInvokespecial(deleClass, methodName, desc);
+ }
+
+ code.addReturn(delegate.getReturnType());
+ code.setMaxLocals(++s);
+ code.setMaxStack(s < 2 ? 2 : s); // for a 2-word return value
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ return new CtMethod(minfo, declaring);
+ }
+
+ /**
+ * Creates a wrapped method. The wrapped method receives parameters
+ * in the form of an array of <code>Object</code>.
+ *
+ * <p>The body of the created method is a copy of the body of the method
+ * specified by <code>body</code>. However, it is wrapped in
+ * parameter-conversion code.
+ *
+ * <p>The method specified by <code>body</code> must have this singature:
+ *
+ * <ul><code>Object method(Object[] params, <type> cvalue)
+ * </code></ul>
+ *
+ * <p>The type of the <code>cvalue</code> depends on
+ * <code>constParam</code>.
+ * If <code>constParam</code> is <code>null</code>, the signature
+ * must be:
+ *
+ * <ul><code>Object method(Object[] params)</code></ul>
+ *
+ * <p>The method body copied from <code>body</code> is wrapped in
+ * parameter-conversion code, which converts parameters specified by
+ * <code>parameterTypes</code> into an array of <code>Object</code>.
+ * The returned value is also converted from the <code>Object</code>
+ * type to the type specified by <code>returnType</code>. Thus,
+ * the resulting method body is as follows:
+ *
+ * <ul><pre>Object[] params = new Object[] { p0, p1, ... };
+ * <<i>type</i>> cvalue = <<i>constant-value</i>>;
+ * <i>... copied method body ...</i>
+ * Object result = <<i>returned value</i>>
+ * return (<i><returnType></i>)result;
+ * </pre></ul>
+ *
+ * <p>The variables <code>p0</code>, <code>p2</code>, ... represent
+ * formal parameters of the created method.
+ * The value of <code>cvalue</code> is specified by
+ * <code>constParam</code>.
+ *
+ * <p>If the type of a parameter or a returned value is a primitive
+ * type, then the value is converted into a wrapper object such as
+ * <code>java.lang.Integer</code>. If the type of the returned value
+ * is <code>void</code>, the returned value is discarded.
+ *
+ * <p><i>Example:</i>
+ *
+ * <ul><pre>ClassPool pool = ... ;
+ * CtClass vec = pool.makeClass("intVector");
+ * vec.setSuperclass(pool.get("java.util.Vector"));
+ * CtMethod addMethod = pool.getMethod("Sample", "add0");
+ *
+ * CtClass[] argTypes = { CtClass.intType };
+ * CtMethod m = CtNewMethod.wrapped(CtClass.voidType, "add", argTypes,
+ * null, addMethod, null, vec);
+ * vec.addMethod(m);</pre></ul>
+ *
+ * <p>where the class <code>Sample</code> is as follows:
+ *
+ * <ul><pre>public class Sample extends java.util.Vector {
+ * public Object add0(Object[] args) {
+ * super.addElement(args[0]);
+ * return null;
+ * }
+ * }</pre></ul>
+ *
+ * <p>This program produces a class <code>intVector</code>:
+ *
+ * <ul><pre>public class intVector extends java.util.Vector {
+ * public void add(int p0) {
+ * Object[] args = new Object[] { p0 };
+ * // begin of the copied body
+ * super.addElement(args[0]);
+ * Object result = null;
+ * // end
+ * }
+ * }</pre></ul>
+ *
+ * <p>Note that the type of the parameter to <code>add()</code> depends
+ * only on the value of <code>argTypes</code> passed to
+ * <code>CtNewMethod.wrapped()</code>. Thus, it is easy to
+ * modify this program to produce a
+ * <code>StringVector</code> class, which is a vector containing
+ * only <code>String</code> objects, and other vector classes.
+ *
+ * @param returnType the type of the returned value.
+ * @param mname the method name.
+ * @param parameterTypes a list of the parameter types.
+ * @param exceptionTypes a list of the exception types.
+ * @param body the method body
+ * (must not be a static method).
+ * @param constParam the constant parameter
+ * (maybe <code>null</code>).
+ * @param declaring the class to which the created method is
+ * added.
+ */
+ public static CtMethod wrapped(CtClass returnType,
+ String mname,
+ CtClass[] parameterTypes,
+ CtClass[] exceptionTypes,
+ CtMethod body, ConstParameter constParam,
+ CtClass declaring)
+ throws CannotCompileException
+ {
+ return CtNewWrappedMethod.wrapped(returnType, mname, parameterTypes,
+ exceptionTypes, body, constParam, declaring);
+ }
+}
diff --git a/src/main/javassist/CtNewNestedClass.java b/src/main/javassist/CtNewNestedClass.java
new file mode 100644
index 0000000..3611443
--- /dev/null
+++ b/src/main/javassist/CtNewNestedClass.java
@@ -0,0 +1,66 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.InnerClassesAttribute;
+
+/**
+ * A newly created public nested class.
+ */
+class CtNewNestedClass extends CtNewClass {
+ CtNewNestedClass(String realName, ClassPool cp, boolean isInterface,
+ CtClass superclass) {
+ super(realName, cp, isInterface, superclass);
+ }
+
+ /**
+ * This method does not change the STATIC bit. The original value is kept.
+ */
+ public void setModifiers(int mod) {
+ mod = mod & ~Modifier.STATIC;
+ super.setModifiers(mod);
+ updateInnerEntry(mod, getName(), this, true);
+ }
+
+ private static void updateInnerEntry(int mod, String name, CtClass clazz, boolean outer) {
+ ClassFile cf = clazz.getClassFile2();
+ InnerClassesAttribute ica = (InnerClassesAttribute)cf.getAttribute(
+ InnerClassesAttribute.tag);
+ if (ica == null)
+ return;
+
+ int n = ica.tableLength();
+ for (int i = 0; i < n; i++)
+ if (name.equals(ica.innerClass(i))) {
+ int acc = ica.accessFlags(i) & AccessFlag.STATIC;
+ ica.setAccessFlags(i, mod | acc);
+ String outName = ica.outerClass(i);
+ if (outName != null && outer)
+ try {
+ CtClass parent = clazz.getClassPool().get(outName);
+ updateInnerEntry(mod, name, parent, false);
+ }
+ catch (NotFoundException e) {
+ throw new RuntimeException("cannot find the declaring class: "
+ + outName);
+ }
+
+ break;
+ }
+ }
+}
diff --git a/src/main/javassist/CtNewWrappedConstructor.java b/src/main/javassist/CtNewWrappedConstructor.java
new file mode 100644
index 0000000..78ab399
--- /dev/null
+++ b/src/main/javassist/CtNewWrappedConstructor.java
@@ -0,0 +1,101 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.CtMethod.ConstParameter;
+
+class CtNewWrappedConstructor extends CtNewWrappedMethod {
+ private static final int PASS_NONE = CtNewConstructor.PASS_NONE;
+ // private static final int PASS_ARRAY = CtNewConstructor.PASS_ARRAY;
+ private static final int PASS_PARAMS = CtNewConstructor.PASS_PARAMS;
+
+ public static CtConstructor wrapped(CtClass[] parameterTypes,
+ CtClass[] exceptionTypes,
+ int howToCallSuper,
+ CtMethod body,
+ ConstParameter constParam,
+ CtClass declaring)
+ throws CannotCompileException
+ {
+ try {
+ CtConstructor cons = new CtConstructor(parameterTypes, declaring);
+ cons.setExceptionTypes(exceptionTypes);
+ Bytecode code = makeBody(declaring, declaring.getClassFile2(),
+ howToCallSuper, body,
+ parameterTypes, constParam);
+ cons.getMethodInfo2().setCodeAttribute(code.toCodeAttribute());
+ return cons;
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ protected static Bytecode makeBody(CtClass declaring, ClassFile classfile,
+ int howToCallSuper,
+ CtMethod wrappedBody,
+ CtClass[] parameters,
+ ConstParameter cparam)
+ throws CannotCompileException
+ {
+ int stacksize, stacksize2;
+
+ int superclazz = classfile.getSuperclassId();
+ Bytecode code = new Bytecode(classfile.getConstPool(), 0, 0);
+ code.setMaxLocals(false, parameters, 0);
+ code.addAload(0);
+ if (howToCallSuper == PASS_NONE) {
+ stacksize = 1;
+ code.addInvokespecial(superclazz, "<init>", "()V");
+ }
+ else if (howToCallSuper == PASS_PARAMS) {
+ stacksize = code.addLoadParameters(parameters, 1) + 1;
+ code.addInvokespecial(superclazz, "<init>",
+ Descriptor.ofConstructor(parameters));
+ }
+ else {
+ stacksize = compileParameterList(code, parameters, 1);
+ String desc;
+ if (cparam == null) {
+ stacksize2 = 2;
+ desc = ConstParameter.defaultConstDescriptor();
+ }
+ else {
+ stacksize2 = cparam.compile(code) + 2;
+ desc = cparam.constDescriptor();
+ }
+
+ if (stacksize < stacksize2)
+ stacksize = stacksize2;
+
+ code.addInvokespecial(superclazz, "<init>", desc);
+ }
+
+ if (wrappedBody == null)
+ code.add(Bytecode.RETURN);
+ else {
+ stacksize2 = makeBody0(declaring, classfile, wrappedBody,
+ false, parameters, CtClass.voidType,
+ cparam, code);
+ if (stacksize < stacksize2)
+ stacksize = stacksize2;
+ }
+
+ code.setMaxStack(stacksize);
+ return code;
+ }
+}
diff --git a/src/main/javassist/CtNewWrappedMethod.java b/src/main/javassist/CtNewWrappedMethod.java
new file mode 100644
index 0000000..94cabd6
--- /dev/null
+++ b/src/main/javassist/CtNewWrappedMethod.java
@@ -0,0 +1,196 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.*;
+import javassist.compiler.JvstCodeGen;
+import java.util.Hashtable;
+import javassist.CtMethod.ConstParameter;
+
+class CtNewWrappedMethod {
+
+ private static final String addedWrappedMethod = "_added_m$";
+
+ public static CtMethod wrapped(CtClass returnType, String mname,
+ CtClass[] parameterTypes,
+ CtClass[] exceptionTypes,
+ CtMethod body, ConstParameter constParam,
+ CtClass declaring)
+ throws CannotCompileException
+ {
+ CtMethod mt = new CtMethod(returnType, mname, parameterTypes,
+ declaring);
+ mt.setModifiers(body.getModifiers());
+ try {
+ mt.setExceptionTypes(exceptionTypes);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ Bytecode code = makeBody(declaring, declaring.getClassFile2(), body,
+ parameterTypes, returnType, constParam);
+ mt.getMethodInfo2().setCodeAttribute(code.toCodeAttribute());
+ return mt;
+ }
+
+ static Bytecode makeBody(CtClass clazz, ClassFile classfile,
+ CtMethod wrappedBody,
+ CtClass[] parameters,
+ CtClass returnType,
+ ConstParameter cparam)
+ throws CannotCompileException
+ {
+ boolean isStatic = Modifier.isStatic(wrappedBody.getModifiers());
+ Bytecode code = new Bytecode(classfile.getConstPool(), 0, 0);
+ int stacksize = makeBody0(clazz, classfile, wrappedBody, isStatic,
+ parameters, returnType, cparam, code);
+ code.setMaxStack(stacksize);
+ code.setMaxLocals(isStatic, parameters, 0);
+ return code;
+ }
+
+ /* The generated method body does not need a stack map table
+ * because it does not contain a branch instruction.
+ */
+ protected static int makeBody0(CtClass clazz, ClassFile classfile,
+ CtMethod wrappedBody,
+ boolean isStatic, CtClass[] parameters,
+ CtClass returnType, ConstParameter cparam,
+ Bytecode code)
+ throws CannotCompileException
+ {
+ if (!(clazz instanceof CtClassType))
+ throw new CannotCompileException("bad declaring class"
+ + clazz.getName());
+
+ if (!isStatic)
+ code.addAload(0);
+
+ int stacksize = compileParameterList(code, parameters,
+ (isStatic ? 0 : 1));
+ int stacksize2;
+ String desc;
+ if (cparam == null) {
+ stacksize2 = 0;
+ desc = ConstParameter.defaultDescriptor();
+ }
+ else {
+ stacksize2 = cparam.compile(code);
+ desc = cparam.descriptor();
+ }
+
+ checkSignature(wrappedBody, desc);
+
+ String bodyname;
+ try {
+ bodyname = addBodyMethod((CtClassType)clazz, classfile,
+ wrappedBody);
+ /* if an exception is thrown below, the method added above
+ * should be removed. (future work :<)
+ */
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+
+ if (isStatic)
+ code.addInvokestatic(Bytecode.THIS, bodyname, desc);
+ else
+ code.addInvokespecial(Bytecode.THIS, bodyname, desc);
+
+ compileReturn(code, returnType); // consumes 2 stack entries
+
+ if (stacksize < stacksize2 + 2)
+ stacksize = stacksize2 + 2;
+
+ return stacksize;
+ }
+
+ private static void checkSignature(CtMethod wrappedBody,
+ String descriptor)
+ throws CannotCompileException
+ {
+ if (!descriptor.equals(wrappedBody.getMethodInfo2().getDescriptor()))
+ throw new CannotCompileException(
+ "wrapped method with a bad signature: "
+ + wrappedBody.getDeclaringClass().getName()
+ + '.' + wrappedBody.getName());
+ }
+
+ private static String addBodyMethod(CtClassType clazz,
+ ClassFile classfile,
+ CtMethod src)
+ throws BadBytecode, CannotCompileException
+ {
+ Hashtable bodies = clazz.getHiddenMethods();
+ String bodyname = (String)bodies.get(src);
+ if (bodyname == null) {
+ do {
+ bodyname = addedWrappedMethod + clazz.getUniqueNumber();
+ } while (classfile.getMethod(bodyname) != null);
+ ClassMap map = new ClassMap();
+ map.put(src.getDeclaringClass().getName(), clazz.getName());
+ MethodInfo body = new MethodInfo(classfile.getConstPool(),
+ bodyname, src.getMethodInfo2(),
+ map);
+ int acc = body.getAccessFlags();
+ body.setAccessFlags(AccessFlag.setPrivate(acc));
+ body.addAttribute(new SyntheticAttribute(classfile.getConstPool()));
+ // a stack map is copied. rebuilding it is not needed.
+ classfile.addMethod(body);
+ bodies.put(src, bodyname);
+ CtMember.Cache cache = clazz.hasMemberCache();
+ if (cache != null)
+ cache.addMethod(new CtMethod(body, clazz));
+ }
+
+ return bodyname;
+ }
+
+ /* compileParameterList() returns the stack size used
+ * by the produced code.
+ *
+ * @param regno the index of the local variable in which
+ * the first argument is received.
+ * (0: static method, 1: regular method.)
+ */
+ static int compileParameterList(Bytecode code,
+ CtClass[] params, int regno) {
+ return JvstCodeGen.compileParameterList(code, params, regno);
+ }
+
+ /*
+ * The produced codes cosume 1 or 2 stack entries.
+ */
+ private static void compileReturn(Bytecode code, CtClass type) {
+ if (type.isPrimitive()) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ if (pt != CtClass.voidType) {
+ String wrapper = pt.getWrapperName();
+ code.addCheckcast(wrapper);
+ code.addInvokevirtual(wrapper, pt.getGetMethodName(),
+ pt.getGetMethodDescriptor());
+ }
+
+ code.addOpcode(pt.getReturnOp());
+ }
+ else {
+ code.addCheckcast(type);
+ code.addOpcode(Bytecode.ARETURN);
+ }
+ }
+}
diff --git a/src/main/javassist/CtPrimitiveType.java b/src/main/javassist/CtPrimitiveType.java
new file mode 100644
index 0000000..faf6700
--- /dev/null
+++ b/src/main/javassist/CtPrimitiveType.java
@@ -0,0 +1,111 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+/**
+ * An instance of <code>CtPrimitiveType</code> represents a primitive type.
+ * It is obtained from <code>CtClass</code>.
+ */
+public final class CtPrimitiveType extends CtClass {
+ private char descriptor;
+ private String wrapperName;
+ private String getMethodName;
+ private String mDescriptor;
+ private int returnOp;
+ private int arrayType;
+ private int dataSize;
+
+ CtPrimitiveType(String name, char desc, String wrapper,
+ String methodName, String mDesc, int opcode, int atype,
+ int size) {
+ super(name);
+ descriptor = desc;
+ wrapperName = wrapper;
+ getMethodName = methodName;
+ mDescriptor = mDesc;
+ returnOp = opcode;
+ arrayType = atype;
+ dataSize = size;
+ }
+
+ /**
+ * Returns <code>true</code> if this object represents a primitive
+ * Java type: boolean, byte, char, short, int, long, float, double,
+ * or void.
+ */
+ public boolean isPrimitive() { return true; }
+
+ /**
+ * Returns the modifiers for this type.
+ * For decoding, use <code>javassist.Modifier</code>.
+ *
+ * @see Modifier
+ */
+ public int getModifiers() {
+ return Modifier.PUBLIC | Modifier.FINAL;
+ }
+
+ /**
+ * Returns the descriptor representing this type.
+ * For example, if the type is int, then the descriptor is I.
+ */
+ public char getDescriptor() { return descriptor; }
+
+ /**
+ * Returns the name of the wrapper class.
+ * For example, if the type is int, then the wrapper class is
+ * <code>java.lang.Integer</code>.
+ */
+ public String getWrapperName() { return wrapperName; }
+
+ /**
+ * Returns the name of the method for retrieving the value
+ * from the wrapper object.
+ * For example, if the type is int, then the method name is
+ * <code>intValue</code>.
+ */
+ public String getGetMethodName() { return getMethodName; }
+
+ /**
+ * Returns the descriptor of the method for retrieving the value
+ * from the wrapper object.
+ * For example, if the type is int, then the method descriptor is
+ * <code>()I</code>.
+ */
+ public String getGetMethodDescriptor() { return mDescriptor; }
+
+ /**
+ * Returns the opcode for returning a value of the type.
+ * For example, if the type is int, then the returned opcode is
+ * <code>javassit.bytecode.Opcode.IRETURN</code>.
+ */
+ public int getReturnOp() { return returnOp; }
+
+ /**
+ * Returns the array-type code representing the type.
+ * It is used for the newarray instruction.
+ * For example, if the type is int, then this method returns
+ * <code>javassit.bytecode.Opcode.T_INT</code>.
+ */
+ public int getArrayType() { return arrayType; }
+
+ /**
+ * Returns the data size of the primitive type.
+ * If the type is long or double, this method returns 2.
+ * Otherwise, it returns 1.
+ */
+ public int getDataSize() { return dataSize; }
+}
diff --git a/src/main/javassist/Loader.java b/src/main/javassist/Loader.java
new file mode 100644
index 0000000..160ef6e
--- /dev/null
+++ b/src/main/javassist/Loader.java
@@ -0,0 +1,446 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.*;
+import java.util.Hashtable;
+import java.util.Vector;
+import java.security.ProtectionDomain;
+
+/**
+ * The class loader for Javassist.
+ *
+ * <p>This is a sample class loader using <code>ClassPool</code>.
+ * Unlike a regular class loader, this class loader obtains bytecode
+ * from a <code>ClassPool</code>.
+ *
+ * <p>Note that Javassist can be used without this class loader; programmers
+ * can define their own versions of class loader. They can run
+ * a program even without any user-defined class loader if that program
+ * is statically translated with Javassist.
+ * This class loader is just provided as a utility class.
+ *
+ * <p>Suppose that an instance of <code>MyTranslator</code> implementing
+ * the interface <code>Translator</code> is responsible for modifying
+ * class files.
+ * The startup program of an application using <code>MyTranslator</code>
+ * should be something like this:
+ *
+ * <ul><pre>
+ * import javassist.*;
+ *
+ * public class Main {
+ * public static void main(String[] args) throws Throwable {
+ * MyTranslator myTrans = new MyTranslator();
+ * ClassPool cp = ClassPool.getDefault();
+ * Loader cl = new Loader(cp);
+ * cl.addTranslator(cp, myTrans);
+ * cl.run("MyApp", args);
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p>Class <code>MyApp</code> is the main program of the application.
+ *
+ * <p>This program should be executed as follows:
+ *
+ * <ul><pre>
+ * % java Main <i>arg1</i> <i>arg2</i>...
+ * </pre></ul>
+ *
+ * <p>It modifies the class <code>MyApp</code> with a <code>MyTranslator</code>
+ * object before the JVM loads it.
+ * Then it calls <code>main()</code> in <code>MyApp</code> with arguments
+ * <i>arg1</i>, <i>arg2</i>, ...
+ *
+ * <p>This program execution is equivalent to:
+ *
+ * <ul><pre>
+ * % java MyApp <i>arg1</i> <i>arg2</i>...
+ * </pre></ul>
+ *
+ * <p>except that classes are translated by <code>MyTranslator</code>
+ * at load time.
+ *
+ * <p>If only a particular class must be modified when it is loaded,
+ * the startup program can be simpler; <code>MyTranslator</code> is
+ * unnecessary. For example, if only a class <code>test.Rectangle</code>
+ * is modified, the <code>main()</code> method above will be the following:
+ *
+ * <ul><pre>
+ * ClassPool cp = ClassPool.getDefault();
+ * Loader cl = new Loader(cp);
+ * CtClass ct = cp.get("test.Rectangle");
+ * ct.setSuperclass(cp.get("test.Point"));
+ * cl.run("MyApp", args);</pre></ul>
+ *
+ * <p>This program changes the super class of the <code>test.Rectangle</code>
+ * class.
+ *
+ * <p><b>Note 1:</b>
+ *
+ * <p>This class loader does not allow the users to intercept the loading
+ * of <code>java.*</code> and <code>javax.*</code> classes (and
+ * <code>sun.*</code>, <code>org.xml.*</code>, ...) unless
+ * <code>Loader.doDelegation</code> is <code>false</code>. This is because
+ * the JVM prohibits a user class loader from loading a system class.
+ * Also see Note 2.
+ * If this behavior is not appropriate, a subclass of <code>Loader</code>
+ * must be defined and <code>loadClassByDelegation()</code> must be overridden.
+ *
+ * <p><b>Note 2:</b>
+ *
+ * <p>If classes are loaded with different class loaders, they belong to
+ * separate name spaces. If class <code>C</code> is loaded by a class
+ * loader <code>CL</code>, all classes that the class <code>C</code>
+ * refers to are also loaded by <code>CL</code>. However, if <code>CL</code>
+ * delegates the loading of the class <code>C</code> to <code>CL'</code>,
+ * then those classes that the class <code>C</code> refers to
+ * are loaded by a parent class loader <code>CL'</code>
+ * instead of <code>CL</code>.
+ *
+ * <p>If an object of class <code>C</code> is assigned
+ * to a variable of class <code>C</code> belonging to a different name
+ * space, then a <code>ClassCastException</code> is thrown.
+ *
+ * <p>Because of the fact above, this loader delegates only the loading of
+ * <code>javassist.Loader</code>
+ * and classes included in package <code>java.*</code> and
+ * <code>javax.*</code> to the parent class
+ * loader. Other classes are directly loaded by this loader.
+ *
+ * <p>For example, suppose that <code>java.lang.String</code> would be loaded
+ * by this loader while <code>java.io.File</code> is loaded by the parent
+ * class loader. If the constructor of <code>java.io.File</code> is called
+ * with an instance of <code>java.lang.String</code>, then it may throw
+ * an exception since it accepts an instance of only the
+ * <code>java.lang.String</code> loaded by the parent class loader.
+ *
+ * @see javassist.ClassPool
+ * @see javassist.Translator
+ */
+public class Loader extends ClassLoader {
+ private Hashtable notDefinedHere; // must be atomic.
+ private Vector notDefinedPackages; // must be atomic.
+ private ClassPool source;
+ private Translator translator;
+ private ProtectionDomain domain;
+
+ /**
+ * Specifies the algorithm of class loading.
+ *
+ * <p>This class loader uses the parent class loader for
+ * <code>java.*</code> and <code>javax.*</code> classes.
+ * If this variable <code>doDelegation</code>
+ * is <code>false</code>, this class loader does not delegate those
+ * classes to the parent class loader.
+ *
+ * <p>The default value is <code>true</code>.
+ */
+ public boolean doDelegation = true;
+
+ /**
+ * Creates a new class loader.
+ */
+ public Loader() {
+ this(null);
+ }
+
+ /**
+ * Creates a new class loader.
+ *
+ * @param cp the source of class files.
+ */
+ public Loader(ClassPool cp) {
+ init(cp);
+ }
+
+ /**
+ * Creates a new class loader
+ * using the specified parent class loader for delegation.
+ *
+ * @param parent the parent class loader.
+ * @param cp the source of class files.
+ */
+ public Loader(ClassLoader parent, ClassPool cp) {
+ super(parent);
+ init(cp);
+ }
+
+ private void init(ClassPool cp) {
+ notDefinedHere = new Hashtable();
+ notDefinedPackages = new Vector();
+ source = cp;
+ translator = null;
+ domain = null;
+ delegateLoadingOf("javassist.Loader");
+ }
+
+ /**
+ * Records a class so that the loading of that class is delegated
+ * to the parent class loader.
+ *
+ * <p>If the given class name ends with <code>.</code> (dot), then
+ * that name is interpreted as a package name. All the classes
+ * in that package and the sub packages are delegated.
+ */
+ public void delegateLoadingOf(String classname) {
+ if (classname.endsWith("."))
+ notDefinedPackages.addElement(classname);
+ else
+ notDefinedHere.put(classname, this);
+ }
+
+ /**
+ * Sets the protection domain for the classes handled by this class
+ * loader. Without registering an appropriate protection domain,
+ * the program loaded by this loader will not work with a security
+ * manager or a signed jar file.
+ */
+ public void setDomain(ProtectionDomain d) {
+ domain = d;
+ }
+
+ /**
+ * Sets the soruce <code>ClassPool</code>.
+ */
+ public void setClassPool(ClassPool cp) {
+ source = cp;
+ }
+
+ /**
+ * Adds a translator, which is called whenever a class is loaded.
+ *
+ * @param cp the <code>ClassPool</code> object for obtaining
+ * a class file.
+ * @param t a translator.
+ * @throws NotFoundException if <code>t.start()</code> throws an exception.
+ * @throws CannotCompileException if <code>t.start()</code> throws an exception.
+ */
+ public void addTranslator(ClassPool cp, Translator t)
+ throws NotFoundException, CannotCompileException {
+ source = cp;
+ translator = t;
+ t.start(cp);
+ }
+
+ /**
+ * Loads a class with an instance of <code>Loader</code>
+ * and calls <code>main()</code> of that class.
+ *
+ * <p>This method calls <code>run()</code>.
+ *
+ * @param args command line parameters.
+ * <ul>
+ * <code>args[0]</code> is the class name to be loaded.
+ * <br><code>args[1..n]</code> are parameters passed
+ * to the target <code>main()</code>.
+ * </ul>
+ *
+ * @see javassist.Loader#run(String[])
+ */
+ public static void main(String[] args) throws Throwable {
+ Loader cl = new Loader();
+ cl.run(args);
+ }
+
+ /**
+ * Loads a class and calls <code>main()</code> in that class.
+ *
+ * @param args command line parameters.
+ * <ul>
+ * <code>args[0]</code> is the class name to be loaded.
+ * <br><code>args[1..n]</code> are parameters passed
+ * to the target <code>main()</code>.
+ * </ul>
+ */
+ public void run(String[] args) throws Throwable {
+ int n = args.length - 1;
+ if (n >= 0) {
+ String[] args2 = new String[n];
+ for (int i = 0; i < n; ++i)
+ args2[i] = args[i + 1];
+
+ run(args[0], args2);
+ }
+ }
+
+ /**
+ * Loads a class and calls <code>main()</code> in that class.
+ *
+ * @param classname the loaded class.
+ * @param args parameters passed to <code>main()</code>.
+ */
+ public void run(String classname, String[] args) throws Throwable {
+ Class c = loadClass(classname);
+ try {
+ c.getDeclaredMethod("main", new Class[] { String[].class }).invoke(
+ null,
+ new Object[] { args });
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+ }
+
+ /**
+ * Requests the class loader to load a class.
+ */
+ protected Class loadClass(String name, boolean resolve)
+ throws ClassFormatError, ClassNotFoundException {
+ name = name.intern();
+ synchronized (name) {
+ Class c = findLoadedClass(name);
+ if (c == null)
+ c = loadClassByDelegation(name);
+
+ if (c == null)
+ c = findClass(name);
+
+ if (c == null)
+ c = delegateToParent(name);
+
+ if (resolve)
+ resolveClass(c);
+
+ return c;
+ }
+ }
+
+ /**
+ * Finds the specified class using <code>ClassPath</code>.
+ * If the source throws an exception, this returns null.
+ *
+ * <p>This method can be overridden by a subclass of
+ * <code>Loader</code>. Note that the overridden method must not throw
+ * an exception when it just fails to find a class file.
+ *
+ * @return null if the specified class could not be found.
+ * @throws ClassNotFoundException if an exception is thrown while
+ * obtaining a class file.
+ */
+ protected Class findClass(String name) throws ClassNotFoundException {
+ byte[] classfile;
+ try {
+ if (source != null) {
+ if (translator != null)
+ translator.onLoad(source, name);
+
+ try {
+ classfile = source.get(name).toBytecode();
+ }
+ catch (NotFoundException e) {
+ return null;
+ }
+ }
+ else {
+ String jarname = "/" + name.replace('.', '/') + ".class";
+ InputStream in = this.getClass().getResourceAsStream(jarname);
+ if (in == null)
+ return null;
+
+ classfile = ClassPoolTail.readStream(in);
+ }
+ }
+ catch (Exception e) {
+ throw new ClassNotFoundException(
+ "caught an exception while obtaining a class file for "
+ + name, e);
+ }
+
+ int i = name.lastIndexOf('.');
+ if (i != -1) {
+ String pname = name.substring(0, i);
+ if (getPackage(pname) == null)
+ try {
+ definePackage(
+ pname, null, null, null, null, null, null, null);
+ }
+ catch (IllegalArgumentException e) {
+ // ignore. maybe the package object for the same
+ // name has been created just right away.
+ }
+ }
+
+ if (domain == null)
+ return defineClass(name, classfile, 0, classfile.length);
+ else
+ return defineClass(name, classfile, 0, classfile.length, domain);
+ }
+
+ protected Class loadClassByDelegation(String name)
+ throws ClassNotFoundException
+ {
+ /* The swing components must be loaded by a system
+ * class loader.
+ * javax.swing.UIManager loads a (concrete) subclass
+ * of LookAndFeel by a system class loader and cast
+ * an instance of the class to LookAndFeel for
+ * (maybe) a security reason. To avoid failure of
+ * type conversion, LookAndFeel must not be loaded
+ * by this class loader.
+ */
+
+ Class c = null;
+ if (doDelegation)
+ if (name.startsWith("java.")
+ || name.startsWith("javax.")
+ || name.startsWith("sun.")
+ || name.startsWith("com.sun.")
+ || name.startsWith("org.w3c.")
+ || name.startsWith("org.xml.")
+ || notDelegated(name))
+ c = delegateToParent(name);
+
+ return c;
+ }
+
+ private boolean notDelegated(String name) {
+ if (notDefinedHere.get(name) != null)
+ return true;
+
+ int n = notDefinedPackages.size();
+ for (int i = 0; i < n; ++i)
+ if (name.startsWith((String)notDefinedPackages.elementAt(i)))
+ return true;
+
+ return false;
+ }
+
+ protected Class delegateToParent(String classname)
+ throws ClassNotFoundException
+ {
+ ClassLoader cl = getParent();
+ if (cl != null)
+ return cl.loadClass(classname);
+ else
+ return findSystemClass(classname);
+ }
+
+ protected Package getPackage(String name) {
+ return super.getPackage(name);
+ }
+ /*
+ // Package p = super.getPackage(name);
+ Package p = null;
+ if (p == null)
+ return definePackage(name, null, null, null,
+ null, null, null, null);
+ else
+ return p;
+ }
+ */
+}
diff --git a/src/main/javassist/LoaderClassPath.java b/src/main/javassist/LoaderClassPath.java
new file mode 100644
index 0000000..5ecb02e
--- /dev/null
+++ b/src/main/javassist/LoaderClassPath.java
@@ -0,0 +1,95 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.InputStream;
+import java.net.URL;
+import java.lang.ref.WeakReference;
+
+/**
+ * A class search-path representing a class loader.
+ *
+ * <p>It is used for obtaining a class file from the given
+ * class loader by <code>getResourceAsStream()</code>.
+ * The <code>LoaderClassPath</code> refers to the class loader through
+ * <code>WeakReference</code>. If the class loader is garbage collected,
+ * the other search pathes are examined.
+ *
+ * <p>The given class loader must have both <code>getResourceAsStream()</code>
+ * and <code>getResource()</code>.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ *
+ * @see ClassPool#insertClassPath(ClassPath)
+ * @see ClassPool#appendClassPath(ClassPath)
+ * @see ClassClassPath
+ */
+public class LoaderClassPath implements ClassPath {
+ private WeakReference clref;
+
+ /**
+ * Creates a search path representing a class loader.
+ */
+ public LoaderClassPath(ClassLoader cl) {
+ clref = new WeakReference(cl);
+ }
+
+ public String toString() {
+ Object cl = null;
+ if (clref != null)
+ cl = clref.get();
+
+ return cl == null ? "<null>" : cl.toString();
+ }
+
+ /**
+ * Obtains a class file from the class loader.
+ * This method calls <code>getResourceAsStream(String)</code>
+ * on the class loader.
+ */
+ public InputStream openClassfile(String classname) {
+ String cname = classname.replace('.', '/') + ".class";
+ ClassLoader cl = (ClassLoader)clref.get();
+ if (cl == null)
+ return null; // not found
+ else
+ return cl.getResourceAsStream(cname);
+ }
+
+ /**
+ * Obtains the URL of the specified class file.
+ * This method calls <code>getResource(String)</code>
+ * on the class loader.
+ *
+ * @return null if the class file could not be found.
+ */
+ public URL find(String classname) {
+ String cname = classname.replace('.', '/') + ".class";
+ ClassLoader cl = (ClassLoader)clref.get();
+ if (cl == null)
+ return null; // not found
+ else
+ return cl.getResource(cname);
+ }
+
+ /**
+ * Closes this class path.
+ */
+ public void close() {
+ clref = null;
+ }
+}
diff --git a/src/main/javassist/Modifier.java b/src/main/javassist/Modifier.java
new file mode 100644
index 0000000..c1b30d6
--- /dev/null
+++ b/src/main/javassist/Modifier.java
@@ -0,0 +1,218 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import javassist.bytecode.AccessFlag;
+
+/**
+ * The Modifier class provides static methods and constants to decode
+ * class and member access modifiers. The constant values are equivalent
+ * to the corresponding values in <code>javassist.bytecode.AccessFlag</code>.
+ *
+ * <p>All the methods/constants in this class are compatible with
+ * ones in <code>java.lang.reflect.Modifier</code>.
+ *
+ * @see CtClass#getModifiers()
+ */
+public class Modifier {
+ public static final int PUBLIC = AccessFlag.PUBLIC;
+ public static final int PRIVATE = AccessFlag.PRIVATE;
+ public static final int PROTECTED = AccessFlag.PROTECTED;
+ public static final int STATIC = AccessFlag.STATIC;
+ public static final int FINAL = AccessFlag.FINAL;
+ public static final int SYNCHRONIZED = AccessFlag.SYNCHRONIZED;
+ public static final int VOLATILE = AccessFlag.VOLATILE;
+ public static final int VARARGS = AccessFlag.VARARGS;
+ public static final int TRANSIENT = AccessFlag.TRANSIENT;
+ public static final int NATIVE = AccessFlag.NATIVE;
+ public static final int INTERFACE = AccessFlag.INTERFACE;
+ public static final int ABSTRACT = AccessFlag.ABSTRACT;
+ public static final int STRICT = AccessFlag.STRICT;
+ public static final int ANNOTATION = AccessFlag.ANNOTATION;
+ public static final int ENUM = AccessFlag.ENUM;
+
+ /**
+ * Returns true if the modifiers include the <tt>public</tt>
+ * modifier.
+ */
+ public static boolean isPublic(int mod) {
+ return (mod & PUBLIC) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>private</tt>
+ * modifier.
+ */
+ public static boolean isPrivate(int mod) {
+ return (mod & PRIVATE) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>protected</tt>
+ * modifier.
+ */
+ public static boolean isProtected(int mod) {
+ return (mod & PROTECTED) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers do not include either
+ * <tt>public</tt>, <tt>protected</tt>, or <tt>private</tt>.
+ */
+ public static boolean isPackage(int mod) {
+ return (mod & (PUBLIC | PRIVATE | PROTECTED)) == 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>static</tt>
+ * modifier.
+ */
+ public static boolean isStatic(int mod) {
+ return (mod & STATIC) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>final</tt>
+ * modifier.
+ */
+ public static boolean isFinal(int mod) {
+ return (mod & FINAL) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>synchronized</tt>
+ * modifier.
+ */
+ public static boolean isSynchronized(int mod) {
+ return (mod & SYNCHRONIZED) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>volatile</tt>
+ * modifier.
+ */
+ public static boolean isVolatile(int mod) {
+ return (mod & VOLATILE) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>transient</tt>
+ * modifier.
+ */
+ public static boolean isTransient(int mod) {
+ return (mod & TRANSIENT) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>native</tt>
+ * modifier.
+ */
+ public static boolean isNative(int mod) {
+ return (mod & NATIVE) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>interface</tt>
+ * modifier.
+ */
+ public static boolean isInterface(int mod) {
+ return (mod & INTERFACE) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>annotation</tt>
+ * modifier.
+ *
+ * @since 3.2
+ */
+ public static boolean isAnnotation(int mod) {
+ return (mod & ANNOTATION) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>enum</tt>
+ * modifier.
+ *
+ * @since 3.2
+ */
+ public static boolean isEnum(int mod) {
+ return (mod & ENUM) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>abstract</tt>
+ * modifier.
+ */
+ public static boolean isAbstract(int mod) {
+ return (mod & ABSTRACT) != 0;
+ }
+
+ /**
+ * Returns true if the modifiers include the <tt>strictfp</tt>
+ * modifier.
+ */
+ public static boolean isStrict(int mod) {
+ return (mod & STRICT) != 0;
+ }
+
+ /**
+ * Truns the public bit on. The protected and private bits are
+ * cleared.
+ */
+ public static int setPublic(int mod) {
+ return (mod & ~(PRIVATE | PROTECTED)) | PUBLIC;
+ }
+
+ /**
+ * Truns the protected bit on. The protected and public bits are
+ * cleared.
+ */
+ public static int setProtected(int mod) {
+ return (mod & ~(PRIVATE | PUBLIC)) | PROTECTED;
+ }
+
+ /**
+ * Truns the private bit on. The protected and private bits are
+ * cleared.
+ */
+ public static int setPrivate(int mod) {
+ return (mod & ~(PROTECTED | PUBLIC)) | PRIVATE;
+ }
+
+ /**
+ * Clears the public, protected, and private bits.
+ */
+ public static int setPackage(int mod) {
+ return (mod & ~(PROTECTED | PUBLIC | PRIVATE));
+ }
+
+ /**
+ * Clears a specified bit in <code>mod</code>.
+ */
+ public static int clear(int mod, int clearBit) {
+ return mod & ~clearBit;
+ }
+
+ /**
+ * Return a string describing the access modifier flags in
+ * the specified modifier.
+ *
+ * @param mod modifier flags.
+ */
+ public static String toString(int mod) {
+ return java.lang.reflect.Modifier.toString(mod);
+ }
+}
diff --git a/src/main/javassist/NotFoundException.java b/src/main/javassist/NotFoundException.java
new file mode 100644
index 0000000..61de140
--- /dev/null
+++ b/src/main/javassist/NotFoundException.java
@@ -0,0 +1,29 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+/**
+ * Signals that something could not be found.
+ */
+public class NotFoundException extends Exception {
+ public NotFoundException(String msg) {
+ super(msg);
+ }
+
+ public NotFoundException(String msg, Exception e) {
+ super(msg + " because of " + e.toString());
+ }
+}
diff --git a/src/main/javassist/SerialVersionUID.java b/src/main/javassist/SerialVersionUID.java
new file mode 100644
index 0000000..5e62310
--- /dev/null
+++ b/src/main/javassist/SerialVersionUID.java
@@ -0,0 +1,210 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.*;
+import java.lang.reflect.Modifier;
+
+import javassist.bytecode.*;
+import java.util.*;
+import java.security.*;
+
+/**
+ * Utility for calculating serialVersionUIDs for Serializable classes.
+ *
+ * @author Bob Lee (crazybob@crazybob.org)
+ * @author modified by Shigeru Chiba
+ */
+public class SerialVersionUID {
+
+ /**
+ * Adds serialVersionUID if one does not already exist. Call this before
+ * modifying a class to maintain serialization compatability.
+ */
+ public static void setSerialVersionUID(CtClass clazz)
+ throws CannotCompileException, NotFoundException
+ {
+ // check for pre-existing field.
+ try {
+ clazz.getDeclaredField("serialVersionUID");
+ return;
+ }
+ catch (NotFoundException e) {}
+
+ // check if the class is serializable.
+ if (!isSerializable(clazz))
+ return;
+
+ // add field with default value.
+ CtField field = new CtField(CtClass.longType, "serialVersionUID",
+ clazz);
+ field.setModifiers(Modifier.PRIVATE | Modifier.STATIC |
+ Modifier.FINAL);
+ clazz.addField(field, calculateDefault(clazz) + "L");
+ }
+
+ /**
+ * Does the class implement Serializable?
+ */
+ private static boolean isSerializable(CtClass clazz)
+ throws NotFoundException
+ {
+ ClassPool pool = clazz.getClassPool();
+ return clazz.subtypeOf(pool.get("java.io.Serializable"));
+ }
+
+ /**
+ * Calculate default value. See Java Serialization Specification, Stream
+ * Unique Identifiers.
+ */
+ static long calculateDefault(CtClass clazz)
+ throws CannotCompileException
+ {
+ try {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(bout);
+ ClassFile classFile = clazz.getClassFile();
+
+ // class name.
+ String javaName = javaName(clazz);
+ out.writeUTF(javaName);
+
+ CtMethod[] methods = clazz.getDeclaredMethods();
+
+ // class modifiers.
+ int classMods = clazz.getModifiers();
+ if ((classMods & Modifier.INTERFACE) != 0)
+ if (methods.length > 0)
+ classMods = classMods | Modifier.ABSTRACT;
+ else
+ classMods = classMods & ~Modifier.ABSTRACT;
+
+ out.writeInt(classMods);
+
+ // interfaces.
+ String[] interfaces = classFile.getInterfaces();
+ for (int i = 0; i < interfaces.length; i++)
+ interfaces[i] = javaName(interfaces[i]);
+
+ Arrays.sort(interfaces);
+ for (int i = 0; i < interfaces.length; i++)
+ out.writeUTF(interfaces[i]);
+
+ // fields.
+ CtField[] fields = clazz.getDeclaredFields();
+ Arrays.sort(fields, new Comparator() {
+ public int compare(Object o1, Object o2) {
+ CtField field1 = (CtField)o1;
+ CtField field2 = (CtField)o2;
+ return field1.getName().compareTo(field2.getName());
+ }
+ });
+
+ for (int i = 0; i < fields.length; i++) {
+ CtField field = (CtField) fields[i];
+ int mods = field.getModifiers();
+ if (((mods & Modifier.PRIVATE) == 0) ||
+ ((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0)) {
+ out.writeUTF(field.getName());
+ out.writeInt(mods);
+ out.writeUTF(field.getFieldInfo2().getDescriptor());
+ }
+ }
+
+ // static initializer.
+ if (classFile.getStaticInitializer() != null) {
+ out.writeUTF("<clinit>");
+ out.writeInt(Modifier.STATIC);
+ out.writeUTF("()V");
+ }
+
+ // constructors.
+ CtConstructor[] constructors = clazz.getDeclaredConstructors();
+ Arrays.sort(constructors, new Comparator() {
+ public int compare(Object o1, Object o2) {
+ CtConstructor c1 = (CtConstructor)o1;
+ CtConstructor c2 = (CtConstructor)o2;
+ return c1.getMethodInfo2().getDescriptor().compareTo(
+ c2.getMethodInfo2().getDescriptor());
+ }
+ });
+
+ for (int i = 0; i < constructors.length; i++) {
+ CtConstructor constructor = constructors[i];
+ int mods = constructor.getModifiers();
+ if ((mods & Modifier.PRIVATE) == 0) {
+ out.writeUTF("<init>");
+ out.writeInt(mods);
+ out.writeUTF(constructor.getMethodInfo2()
+ .getDescriptor().replace('/', '.'));
+ }
+ }
+
+ // methods.
+ Arrays.sort(methods, new Comparator() {
+ public int compare(Object o1, Object o2) {
+ CtMethod m1 = (CtMethod)o1;
+ CtMethod m2 = (CtMethod)o2;
+ int value = m1.getName().compareTo(m2.getName());
+ if (value == 0)
+ value = m1.getMethodInfo2().getDescriptor()
+ .compareTo(m2.getMethodInfo2().getDescriptor());
+
+ return value;
+ }
+ });
+
+ for (int i = 0; i < methods.length; i++) {
+ CtMethod method = methods[i];
+ int mods = method.getModifiers()
+ & (Modifier.PUBLIC | Modifier.PRIVATE
+ | Modifier.PROTECTED | Modifier.STATIC
+ | Modifier.FINAL | Modifier.SYNCHRONIZED
+ | Modifier.NATIVE | Modifier.ABSTRACT | Modifier.STRICT);
+ if ((mods & Modifier.PRIVATE) == 0) {
+ out.writeUTF(method.getName());
+ out.writeInt(mods);
+ out.writeUTF(method.getMethodInfo2()
+ .getDescriptor().replace('/', '.'));
+ }
+ }
+
+ // calculate hash.
+ out.flush();
+ MessageDigest digest = MessageDigest.getInstance("SHA");
+ byte[] digested = digest.digest(bout.toByteArray());
+ long hash = 0;
+ for (int i = Math.min(digested.length, 8) - 1; i >= 0; i--)
+ hash = (hash << 8) | (digested[i] & 0xFF);
+
+ return hash;
+ }
+ catch (IOException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (NoSuchAlgorithmException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private static String javaName(CtClass clazz) {
+ return Descriptor.toJavaName(Descriptor.toJvmName(clazz));
+ }
+
+ private static String javaName(String name) {
+ return Descriptor.toJavaName(Descriptor.toJvmName(name));
+ }
+}
diff --git a/src/main/javassist/Translator.java b/src/main/javassist/Translator.java
new file mode 100644
index 0000000..ea44034
--- /dev/null
+++ b/src/main/javassist/Translator.java
@@ -0,0 +1,70 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+/**
+ * An observer of <code>Loader</code>.
+ * The users can define a class implementing this
+ * interface and attach an instance of that class to a
+ * <code>Loader</code> object so that it can translate a class file
+ * when the class file is loaded into the JVM.
+ *
+ * @see Loader#addTranslator(ClassPool, Translator)
+ */
+public interface Translator {
+ /**
+ * Is invoked by a <code>Loader</code> for initialization
+ * when the object is attached to the <code>Loader</code> object.
+ * This method can be used for getting (for caching) some
+ * <code>CtClass</code> objects that will be accessed
+ * in <code>onLoad()</code> in <code>Translator</code>.
+ *
+ * @param pool the <code>ClassPool</code> that this translator
+ * should use.
+ * @see Loader
+ * @throws NotFoundException if a <code>CtClass</code> cannot be found.
+ * @throws CannotCompileException if the initialization by this method
+ * fails.
+ */
+ void start(ClassPool pool)
+ throws NotFoundException, CannotCompileException;
+
+ /**
+ * Is invoked by a <code>Loader</code> for notifying that
+ * a class is loaded. The <code>Loader</code> calls
+ *
+ * <ul><pre>
+ * pool.get(classname).toBytecode()</pre></ul>
+ *
+ * to read the class file after <code>onLoad()</code> returns.
+ *
+ * <p><code>classname</code> may be the name of a class
+ * that has not been created yet.
+ * If so, <code>onLoad()</code> must create that class so that
+ * the <code>Loader</code> can read it after <code>onLoad()</code>
+ * returns.
+ *
+ * @param pool the <code>ClassPool</code> that this translator
+ * should use.
+ * @param classname the name of the class being loaded.
+ * @see Loader
+ * @throws NotFoundException if a <code>CtClass</code> cannot be found.
+ * @throws CannotCompileException if the code transformation
+ * by this method fails.
+ */
+ void onLoad(ClassPool pool, String classname)
+ throws NotFoundException, CannotCompileException;
+}
diff --git a/src/main/javassist/URLClassPath.java b/src/main/javassist/URLClassPath.java
new file mode 100644
index 0000000..0cdb820
--- /dev/null
+++ b/src/main/javassist/URLClassPath.java
@@ -0,0 +1,178 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * A class search-path specified with URL (http).
+ *
+ * @see javassist.ClassPath
+ * @see ClassPool#insertClassPath(ClassPath)
+ * @see ClassPool#appendClassPath(ClassPath)
+ */
+public class URLClassPath implements ClassPath {
+ protected String hostname;
+ protected int port;
+ protected String directory;
+ protected String packageName;
+
+ /**
+ * Creates a search path specified with URL (http).
+ *
+ * <p>This search path is used only if a requested
+ * class name starts with the name specified by <code>packageName</code>.
+ * If <code>packageName</code> is "org.javassist." and a requested class is
+ * "org.javassist.test.Main", then the given URL is used for loading that class.
+ * The <code>URLClassPath</code> obtains a class file from:
+ *
+ * <ul><pre>http://www.javassist.org:80/java/classes/org/javassist/test/Main.class
+ * </pre></ul>
+ *
+ * <p>Here, we assume that <code>host</code> is "www.javassist.org",
+ * <code>port</code> is 80, and <code>directory</code> is "/java/classes/".
+ *
+ * <p>If <code>packageName</code> is <code>null</code>, the URL is used
+ * for loading any class.
+ *
+ * @param host host name
+ * @param port port number
+ * @param directory directory name ending with "/".
+ * It can be "/" (root directory).
+ * It must start with "/".
+ * @param packageName package name. It must end with "." (dot).
+ */
+ public URLClassPath(String host, int port,
+ String directory, String packageName) {
+ hostname = host;
+ this.port = port;
+ this.directory = directory;
+ this.packageName = packageName;
+ }
+
+ public String toString() {
+ return hostname + ":" + port + directory;
+ }
+
+ /**
+ * Opens a class file with http.
+ *
+ * @return null if the class file could not be found.
+ */
+ public InputStream openClassfile(String classname) {
+ try {
+ URLConnection con = openClassfile0(classname);
+ if (con != null)
+ return con.getInputStream();
+ }
+ catch (IOException e) {}
+ return null; // not found
+ }
+
+ private URLConnection openClassfile0(String classname) throws IOException {
+ if (packageName == null || classname.startsWith(packageName)) {
+ String jarname
+ = directory + classname.replace('.', '/') + ".class";
+ return fetchClass0(hostname, port, jarname);
+ }
+ else
+ return null; // not found
+ }
+
+ /**
+ * Returns the URL.
+ *
+ * @return null if the class file could not be obtained.
+ */
+ public URL find(String classname) {
+ try {
+ URLConnection con = openClassfile0(classname);
+ InputStream is = con.getInputStream();
+ if (is != null) {
+ is.close();
+ return con.getURL();
+ }
+ }
+ catch (IOException e) {}
+ return null;
+ }
+
+ /**
+ * Closes this class path.
+ */
+ public void close() {}
+
+ /**
+ * Reads a class file on an http server.
+ *
+ * @param host host name
+ * @param port port number
+ * @param directory directory name ending with "/".
+ * It can be "/" (root directory).
+ * It must start with "/".
+ * @param classname fully-qualified class name
+ */
+ public static byte[] fetchClass(String host, int port,
+ String directory, String classname)
+ throws IOException
+ {
+ byte[] b;
+ URLConnection con = fetchClass0(host, port,
+ directory + classname.replace('.', '/') + ".class");
+ int size = con.getContentLength();
+ InputStream s = con.getInputStream();
+ try {
+ if (size <= 0)
+ b = ClassPoolTail.readStream(s);
+ else {
+ b = new byte[size];
+ int len = 0;
+ do {
+ int n = s.read(b, len, size - len);
+ if (n < 0)
+ throw new IOException("the stream was closed: "
+ + classname);
+
+ len += n;
+ } while (len < size);
+ }
+ }
+ finally {
+ s.close();
+ }
+
+ return b;
+ }
+
+ private static URLConnection fetchClass0(String host, int port,
+ String filename)
+ throws IOException
+ {
+ URL url;
+ try {
+ url = new URL("http", host, port, filename);
+ }
+ catch (MalformedURLException e) {
+ // should never reache here.
+ throw new IOException("invalid URL?");
+ }
+
+ URLConnection con = url.openConnection();
+ con.connect();
+ return con;
+ }
+}
diff --git a/src/main/javassist/bytecode/AccessFlag.java b/src/main/javassist/bytecode/AccessFlag.java
new file mode 100644
index 0000000..6dda112
--- /dev/null
+++ b/src/main/javassist/bytecode/AccessFlag.java
@@ -0,0 +1,132 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * A support class providing static methods and constants
+ * for access modifiers such as public, rivate, ...
+ */
+public class AccessFlag {
+ public static final int PUBLIC = 0x0001;
+ public static final int PRIVATE = 0x0002;
+ public static final int PROTECTED = 0x0004;
+ public static final int STATIC = 0x0008;
+ public static final int FINAL = 0x0010;
+ public static final int SYNCHRONIZED = 0x0020;
+ public static final int VOLATILE = 0x0040;
+ public static final int BRIDGE = 0x0040; // for method_info
+ public static final int TRANSIENT = 0x0080;
+ public static final int VARARGS = 0x0080; // for method_info
+ public static final int NATIVE = 0x0100;
+ public static final int INTERFACE = 0x0200;
+ public static final int ABSTRACT = 0x0400;
+ public static final int STRICT = 0x0800;
+ public static final int SYNTHETIC = 0x1000;
+ public static final int ANNOTATION = 0x2000;
+ public static final int ENUM = 0x4000;
+
+ public static final int SUPER = 0x0020;
+
+ // Note: 0x0020 is assigned to both ACC_SUPER and ACC_SYNCHRONIZED
+ // although java.lang.reflect.Modifier does not recognize ACC_SUPER.
+
+ /**
+ * Truns the public bit on. The protected and private bits are
+ * cleared.
+ */
+ public static int setPublic(int accflags) {
+ return (accflags & ~(PRIVATE | PROTECTED)) | PUBLIC;
+ }
+
+ /**
+ * Truns the protected bit on. The protected and public bits are
+ * cleared.
+ */
+ public static int setProtected(int accflags) {
+ return (accflags & ~(PRIVATE | PUBLIC)) | PROTECTED;
+ }
+
+ /**
+ * Truns the private bit on. The protected and private bits are
+ * cleared.
+ */
+ public static int setPrivate(int accflags) {
+ return (accflags & ~(PROTECTED | PUBLIC)) | PRIVATE;
+ }
+
+ /**
+ * Clears the public, protected, and private bits.
+ */
+ public static int setPackage(int accflags) {
+ return (accflags & ~(PROTECTED | PUBLIC | PRIVATE));
+ }
+
+ /**
+ * Returns true if the access flags include the public bit.
+ */
+ public static boolean isPublic(int accflags) {
+ return (accflags & PUBLIC) != 0;
+ }
+
+ /**
+ * Returns true if the access flags include the protected bit.
+ */
+ public static boolean isProtected(int accflags) {
+ return (accflags & PROTECTED) != 0;
+ }
+
+ /**
+ * Returns true if the access flags include the private bit.
+ */
+ public static boolean isPrivate(int accflags) {
+ return (accflags & PRIVATE) != 0;
+ }
+
+ /**
+ * Returns true if the access flags include neither public, protected,
+ * or private.
+ */
+ public static boolean isPackage(int accflags) {
+ return (accflags & (PROTECTED | PUBLIC | PRIVATE)) == 0;
+ }
+
+ /**
+ * Clears a specified bit in <code>accflags</code>.
+ */
+ public static int clear(int accflags, int clearBit) {
+ return accflags & ~clearBit;
+ }
+
+ /**
+ * Converts a javassist.Modifier into
+ * a javassist.bytecode.AccessFlag.
+ *
+ * @param modifier javassist.Modifier
+ */
+ public static int of(int modifier) {
+ return modifier;
+ }
+
+ /**
+ * Converts a javassist.bytecode.AccessFlag
+ * into a javassist.Modifier.
+ *
+ * @param accflags javassist.bytecode.Accessflag
+ */
+ public static int toModifier(int accflags) {
+ return accflags;
+ }
+}
diff --git a/src/main/javassist/bytecode/AnnotationDefaultAttribute.java b/src/main/javassist/bytecode/AnnotationDefaultAttribute.java
new file mode 100644
index 0000000..d591ac8
--- /dev/null
+++ b/src/main/javassist/bytecode/AnnotationDefaultAttribute.java
@@ -0,0 +1,159 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import javassist.CtClass;
+import javassist.bytecode.annotation.AnnotationsWriter;
+import javassist.bytecode.annotation.MemberValue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * A class representing <code>AnnotationDefault_attribute</code>.
+ *
+ * <p>For example, if you declare the following annotation type:
+ *
+ * <ul><pre>
+ * @interface Author {
+ * String name() default "Shakespeare";
+ * int age() default 99;
+ * }
+ * </pre></ul>
+ *
+ * <p>The defautl values of <code>name</code> and <code>age</code>
+ * are stored as annotation default attributes in <code>Author.class</code>.
+ * The following code snippet obtains the default value of <code>name</code>:
+ *
+ * <ul><pre>
+ * ClassPool pool = ...
+ * CtClass cc = pool.get("Author");
+ * CtMethod cm = cc.getDeclaredMethod("age");
+ * MethodInfo minfo = cm.getMethodInfo();
+ * AnnotationDefaultAttribute ada
+ * = (AnnotationDefaultAttribute)
+ * minfo.getAttribute(AnnotationDefaultAttribute.tag);
+ * MemberValue value = ada.getDefaultValue()); // default value of age
+ * </pre></ul>
+ *
+ * <p>If the following statement is executed after the code above,
+ * the default value of age is set to 80:
+ *
+ * <ul><pre>
+ * ada.setDefaultValue(new IntegerMemberValue(minfo.getConstPool(), 80));
+ * </pre></ul>
+ *
+ * @see AnnotationsAttribute
+ * @see javassist.bytecode.annotation.MemberValue
+ */
+
+public class AnnotationDefaultAttribute extends AttributeInfo {
+ /**
+ * The name of the <code>AnnotationDefault</code> attribute.
+ */
+ public static final String tag = "AnnotationDefault";
+
+ /**
+ * Constructs an <code>AnnotationDefault_attribute</code>.
+ *
+ * @param cp constant pool
+ * @param info the contents of this attribute. It does not
+ * include <code>attribute_name_index</code> or
+ * <code>attribute_length</code>.
+ */
+ public AnnotationDefaultAttribute(ConstPool cp, byte[] info) {
+ super(cp, tag, info);
+ }
+
+ /**
+ * Constructs an empty <code>AnnotationDefault_attribute</code>.
+ * The default value can be set by <code>setDefaultValue()</code>.
+ *
+ * @param cp constant pool
+ * @see #setDefaultValue(javassist.bytecode.annotation.MemberValue)
+ */
+ public AnnotationDefaultAttribute(ConstPool cp) {
+ this(cp, new byte[] { 0, 0 });
+ }
+
+ /**
+ * @param n the attribute name.
+ */
+ AnnotationDefaultAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Copies this attribute and returns a new copy.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ AnnotationsAttribute.Copier copier
+ = new AnnotationsAttribute.Copier(info, constPool, newCp, classnames);
+ try {
+ copier.memberValue(0);
+ return new AnnotationDefaultAttribute(newCp, copier.close());
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Obtains the default value represented by this attribute.
+ */
+ public MemberValue getDefaultValue()
+ {
+ try {
+ return new AnnotationsAttribute.Parser(info, constPool)
+ .parseMemberValue();
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Changes the default value represented by this attribute.
+ *
+ * @param value the new value.
+ * @see javassist.bytecode.annotation.Annotation#createMemberValue(ConstPool, CtClass)
+ */
+ public void setDefaultValue(MemberValue value) {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ AnnotationsWriter writer = new AnnotationsWriter(output, constPool);
+ try {
+ value.write(writer);
+ writer.close();
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e); // should never reach here.
+ }
+
+ set(output.toByteArray());
+
+ }
+
+ /**
+ * Returns a string representation of this object.
+ */
+ public String toString() {
+ return getDefaultValue().toString();
+ }
+}
diff --git a/src/main/javassist/bytecode/AnnotationsAttribute.java b/src/main/javassist/bytecode/AnnotationsAttribute.java
new file mode 100644
index 0000000..0d2ac09
--- /dev/null
+++ b/src/main/javassist/bytecode/AnnotationsAttribute.java
@@ -0,0 +1,701 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.io.IOException;
+import java.io.DataInputStream;
+import java.io.ByteArrayOutputStream;
+import javassist.bytecode.annotation.*;
+
+/**
+ * A class representing
+ * <code>RuntimeVisibleAnnotations_attribute</code> and
+ * <code>RuntimeInvisibleAnnotations_attribute</code>.
+ *
+ * <p>To obtain an AnnotationAttribute object, invoke
+ * <code>getAttribute(AnnotationsAttribute.visibleTag)</code>
+ * in <code>ClassFile</code>, <code>MethodInfo</code>,
+ * or <code>FieldInfo</code>. The obtained attribute is a
+ * runtime visible annotations attribute.
+ * If the parameter is
+ * <code>AnnotationAttribute.invisibleTag</code>, then the obtained
+ * attribute is a runtime invisible one.
+ *
+ * <p>For example,
+ *
+ * <ul><pre>
+ * import javassist.bytecode.annotation.Annotation;
+ * :
+ * CtMethod m = ... ;
+ * MethodInfo minfo = m.getMethodInfo();
+ * AnnotationsAttribute attr = (AnnotationsAttribute)
+ * minfo.getAttribute(AnnotationsAttribute.invisibleTag);
+ * Annotation an = attr.getAnnotation("Author");
+ * String s = ((StringMemberValue)an.getMemberValue("name")).getValue();
+ * System.out.println("@Author(name=" + s + ")");
+ * </pre></ul>
+ *
+ * <p>This code snippet retrieves an annotation of the type <code>Author</code>
+ * from the <code>MethodInfo</code> object specified by <code>minfo</code>.
+ * Then, it prints the value of <code>name</code> in <code>Author</code>.
+ *
+ * <p>If the annotation type <code>Author</code> is annotated by a meta annotation:
+ *
+ * <ul><pre>
+ * @Retention(RetentionPolicy.RUNTIME)
+ * </pre></ul>
+ *
+ * <p>Then <code>Author</code> is visible at runtime. Therefore, the third
+ * statement of the code snippet above must be changed into:
+ *
+ * <ul><pre>
+ * AnnotationsAttribute attr = (AnnotationsAttribute)
+ * minfo.getAttribute(AnnotationsAttribute.visibleTag);
+ * </pre></ul>
+ *
+ * <p>The attribute tag must be <code>visibleTag</code> instead of
+ * <code>invisibleTag</code>.
+ *
+ * <p>If the member value of an annotation is not specified, the default value
+ * is used as that member value. If so, <code>getMemberValue()</code> in
+ * <code>Annotation</code> returns <code>null</code>
+ * since the default value is not included in the
+ * <code>AnnotationsAttribute</code>. It is included in the
+ * <code>AnnotationDefaultAttribute</code> of the method declared in the
+ * annotation type.
+ *
+ * <p>If you want to record a new AnnotationAttribute object, execute the
+ * following snippet:
+ *
+ * <ul><pre>
+ * ClassFile cf = ... ;
+ * ConstPool cp = cf.getConstPool();
+ * AnnotationsAttribute attr
+ * = new AnnotationsAttribute(cp, AnnotationsAttribute.visibleTag);
+ * Annotation a = new Annotation("Author", cp);
+ * a.addMemberValue("name", new StringMemberValue("Chiba", cp));
+ * attr.setAnnotation(a);
+ * cf.addAttribute(attr);
+ * cf.setVersionToJava5();
+ * </pre></ul>
+ *
+ * <p>The last statement is necessary if the class file was produced by
+ * Javassist or JDK 1.4. Otherwise, it is not necessary.
+ *
+ * @see AnnotationDefaultAttribute
+ * @see javassist.bytecode.annotation.Annotation
+ */
+public class AnnotationsAttribute extends AttributeInfo {
+ /**
+ * The name of the <code>RuntimeVisibleAnnotations</code> attribute.
+ */
+ public static final String visibleTag = "RuntimeVisibleAnnotations";
+
+ /**
+ * The name of the <code>RuntimeInvisibleAnnotations</code> attribute.
+ */
+ public static final String invisibleTag = "RuntimeInvisibleAnnotations";
+
+ /**
+ * Constructs a <code>Runtime(In)VisibleAnnotations_attribute</code>.
+ *
+ * @param cp constant pool
+ * @param attrname attribute name (<code>visibleTag</code> or
+ * <code>invisibleTag</code>).
+ * @param info the contents of this attribute. It does not
+ * include <code>attribute_name_index</code> or
+ * <code>attribute_length</code>.
+ */
+ public AnnotationsAttribute(ConstPool cp, String attrname, byte[] info) {
+ super(cp, attrname, info);
+ }
+
+ /**
+ * Constructs an empty
+ * <code>Runtime(In)VisibleAnnotations_attribute</code>.
+ * A new annotation can be later added to the created attribute
+ * by <code>setAnnotations()</code>.
+ *
+ * @param cp constant pool
+ * @param attrname attribute name (<code>visibleTag</code> or
+ * <code>invisibleTag</code>).
+ * @see #setAnnotations(Annotation[])
+ */
+ public AnnotationsAttribute(ConstPool cp, String attrname) {
+ this(cp, attrname, new byte[] { 0, 0 });
+ }
+
+ /**
+ * @param n the attribute name.
+ */
+ AnnotationsAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Returns <code>num_annotations</code>.
+ */
+ public int numAnnotations() {
+ return ByteArray.readU16bit(info, 0);
+ }
+
+ /**
+ * Copies this attribute and returns a new copy.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ Copier copier = new Copier(info, constPool, newCp, classnames);
+ try {
+ copier.annotationArray();
+ return new AnnotationsAttribute(newCp, getName(), copier.close());
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Parses the annotations and returns a data structure representing
+ * the annotation with the specified type. See also
+ * <code>getAnnotations()</code> as to the returned data structure.
+ *
+ * @param type the annotation type.
+ * @return null if the specified annotation type is not included.
+ * @see #getAnnotations()
+ */
+ public Annotation getAnnotation(String type) {
+ Annotation[] annotations = getAnnotations();
+ for (int i = 0; i < annotations.length; i++) {
+ if (annotations[i].getTypeName().equals(type))
+ return annotations[i];
+ }
+
+ return null;
+ }
+
+ /**
+ * Adds an annotation. If there is an annotation with the same type,
+ * it is removed before the new annotation is added.
+ *
+ * @param annotation the added annotation.
+ */
+ public void addAnnotation(Annotation annotation) {
+ String type = annotation.getTypeName();
+ Annotation[] annotations = getAnnotations();
+ for (int i = 0; i < annotations.length; i++) {
+ if (annotations[i].getTypeName().equals(type)) {
+ annotations[i] = annotation;
+ setAnnotations(annotations);
+ return;
+ }
+ }
+
+ Annotation[] newlist = new Annotation[annotations.length + 1];
+ System.arraycopy(annotations, 0, newlist, 0, annotations.length);
+ newlist[annotations.length] = annotation;
+ setAnnotations(newlist);
+ }
+
+ /**
+ * Parses the annotations and returns a data structure representing
+ * that parsed annotations. Note that changes of the node values of the
+ * returned tree are not reflected on the annotations represented by
+ * this object unless the tree is copied back to this object by
+ * <code>setAnnotations()</code>.
+ *
+ * @see #setAnnotations(Annotation[])
+ */
+ public Annotation[] getAnnotations() {
+ try {
+ return new Parser(info, constPool).parseAnnotations();
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Changes the annotations represented by this object according to
+ * the given array of <code>Annotation</code> objects.
+ *
+ * @param annotations the data structure representing the
+ * new annotations.
+ */
+ public void setAnnotations(Annotation[] annotations) {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ AnnotationsWriter writer = new AnnotationsWriter(output, constPool);
+ try {
+ int n = annotations.length;
+ writer.numAnnotations(n);
+ for (int i = 0; i < n; ++i)
+ annotations[i].write(writer);
+
+ writer.close();
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e); // should never reach here.
+ }
+
+ set(output.toByteArray());
+ }
+
+ /**
+ * Changes the annotations. A call to this method is equivalent to:
+ * <ul><pre>setAnnotations(new Annotation[] { annotation })</pre></ul>
+ *
+ * @param annotation the data structure representing
+ * the new annotation.
+ */
+ public void setAnnotation(Annotation annotation) {
+ setAnnotations(new Annotation[] { annotation });
+ }
+
+ /**
+ * @param oldname a JVM class name.
+ * @param newname a JVM class name.
+ */
+ void renameClass(String oldname, String newname) {
+ HashMap map = new HashMap();
+ map.put(oldname, newname);
+ renameClass(map);
+ }
+
+ void renameClass(Map classnames) {
+ Renamer renamer = new Renamer(info, getConstPool(), classnames);
+ try {
+ renamer.annotationArray();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ void getRefClasses(Map classnames) { renameClass(classnames); }
+
+ /**
+ * Returns a string representation of this object.
+ */
+ public String toString() {
+ Annotation[] a = getAnnotations();
+ StringBuilder sbuf = new StringBuilder();
+ int i = 0;
+ while (i < a.length) {
+ sbuf.append(a[i++].toString());
+ if (i != a.length)
+ sbuf.append(", ");
+ }
+
+ return sbuf.toString();
+ }
+
+ static class Walker {
+ byte[] info;
+
+ Walker(byte[] attrInfo) {
+ info = attrInfo;
+ }
+
+ final void parameters() throws Exception {
+ int numParam = info[0] & 0xff;
+ parameters(numParam, 1);
+ }
+
+ void parameters(int numParam, int pos) throws Exception {
+ for (int i = 0; i < numParam; ++i)
+ pos = annotationArray(pos);
+ }
+
+ final void annotationArray() throws Exception {
+ annotationArray(0);
+ }
+
+ final int annotationArray(int pos) throws Exception {
+ int num = ByteArray.readU16bit(info, pos);
+ return annotationArray(pos + 2, num);
+ }
+
+ int annotationArray(int pos, int num) throws Exception {
+ for (int i = 0; i < num; ++i)
+ pos = annotation(pos);
+
+ return pos;
+ }
+
+ final int annotation(int pos) throws Exception {
+ int type = ByteArray.readU16bit(info, pos);
+ int numPairs = ByteArray.readU16bit(info, pos + 2);
+ return annotation(pos + 4, type, numPairs);
+ }
+
+ int annotation(int pos, int type, int numPairs) throws Exception {
+ for (int j = 0; j < numPairs; ++j)
+ pos = memberValuePair(pos);
+
+ return pos;
+ }
+
+ final int memberValuePair(int pos) throws Exception {
+ int nameIndex = ByteArray.readU16bit(info, pos);
+ return memberValuePair(pos + 2, nameIndex);
+ }
+
+ int memberValuePair(int pos, int nameIndex) throws Exception {
+ return memberValue(pos);
+ }
+
+ final int memberValue(int pos) throws Exception {
+ int tag = info[pos] & 0xff;
+ if (tag == 'e') {
+ int typeNameIndex = ByteArray.readU16bit(info, pos + 1);
+ int constNameIndex = ByteArray.readU16bit(info, pos + 3);
+ enumMemberValue(pos, typeNameIndex, constNameIndex);
+ return pos + 5;
+ }
+ else if (tag == 'c') {
+ int index = ByteArray.readU16bit(info, pos + 1);
+ classMemberValue(pos, index);
+ return pos + 3;
+ }
+ else if (tag == '@')
+ return annotationMemberValue(pos + 1);
+ else if (tag == '[') {
+ int num = ByteArray.readU16bit(info, pos + 1);
+ return arrayMemberValue(pos + 3, num);
+ }
+ else { // primitive types or String.
+ int index = ByteArray.readU16bit(info, pos + 1);
+ constValueMember(tag, index);
+ return pos + 3;
+ }
+ }
+
+ void constValueMember(int tag, int index) throws Exception {}
+
+ void enumMemberValue(int pos, int typeNameIndex, int constNameIndex)
+ throws Exception {
+ }
+
+ void classMemberValue(int pos, int index) throws Exception {}
+
+ int annotationMemberValue(int pos) throws Exception {
+ return annotation(pos);
+ }
+
+ int arrayMemberValue(int pos, int num) throws Exception {
+ for (int i = 0; i < num; ++i) {
+ pos = memberValue(pos);
+ }
+
+ return pos;
+ }
+ }
+
+ static class Renamer extends Walker {
+ ConstPool cpool;
+ Map classnames;
+
+ /**
+ * Constructs a renamer. It renames some class names
+ * into the new names specified by <code>map</code>.
+ *
+ * @param info the annotations attribute.
+ * @param cp the constant pool.
+ * @param map pairs of replaced and substituted class names.
+ * It can be null.
+ */
+ Renamer(byte[] info, ConstPool cp, Map map) {
+ super(info);
+ cpool = cp;
+ classnames = map;
+ }
+
+ int annotation(int pos, int type, int numPairs) throws Exception {
+ renameType(pos - 4, type);
+ return super.annotation(pos, type, numPairs);
+ }
+
+ void enumMemberValue(int pos, int typeNameIndex, int constNameIndex)
+ throws Exception
+ {
+ renameType(pos + 1, typeNameIndex);
+ super.enumMemberValue(pos, typeNameIndex, constNameIndex);
+ }
+
+ void classMemberValue(int pos, int index) throws Exception {
+ renameType(pos + 1, index);
+ super.classMemberValue(pos, index);
+ }
+
+ private void renameType(int pos, int index) {
+ String name = cpool.getUtf8Info(index);
+ String newName = Descriptor.rename(name, classnames);
+ if (!name.equals(newName)) {
+ int index2 = cpool.addUtf8Info(newName);
+ ByteArray.write16bit(index2, info, pos);
+ }
+ }
+ }
+
+ static class Copier extends Walker {
+ ByteArrayOutputStream output;
+ AnnotationsWriter writer;
+ ConstPool srcPool, destPool;
+ Map classnames;
+
+ /**
+ * Constructs a copier. This copier renames some class names
+ * into the new names specified by <code>map</code> when it copies
+ * an annotation attribute.
+ *
+ * @param info the source attribute.
+ * @param src the constant pool of the source class.
+ * @param dest the constant pool of the destination class.
+ * @param map pairs of replaced and substituted class names.
+ * It can be null.
+ */
+ Copier(byte[] info, ConstPool src, ConstPool dest, Map map) {
+ super(info);
+ output = new ByteArrayOutputStream();
+ writer = new AnnotationsWriter(output, dest);
+ srcPool = src;
+ destPool = dest;
+ classnames = map;
+ }
+
+ byte[] close() throws IOException {
+ writer.close();
+ return output.toByteArray();
+ }
+
+ void parameters(int numParam, int pos) throws Exception {
+ writer.numParameters(numParam);
+ super.parameters(numParam, pos);
+ }
+
+ int annotationArray(int pos, int num) throws Exception {
+ writer.numAnnotations(num);
+ return super.annotationArray(pos, num);
+ }
+
+ int annotation(int pos, int type, int numPairs) throws Exception {
+ writer.annotation(copyType(type), numPairs);
+ return super.annotation(pos, type, numPairs);
+ }
+
+ int memberValuePair(int pos, int nameIndex) throws Exception {
+ writer.memberValuePair(copy(nameIndex));
+ return super.memberValuePair(pos, nameIndex);
+ }
+
+ void constValueMember(int tag, int index) throws Exception {
+ writer.constValueIndex(tag, copy(index));
+ super.constValueMember(tag, index);
+ }
+
+ void enumMemberValue(int pos, int typeNameIndex, int constNameIndex)
+ throws Exception
+ {
+ writer.enumConstValue(copyType(typeNameIndex), copy(constNameIndex));
+ super.enumMemberValue(pos, typeNameIndex, constNameIndex);
+ }
+
+ void classMemberValue(int pos, int index) throws Exception {
+ writer.classInfoIndex(copyType(index));
+ super.classMemberValue(pos, index);
+ }
+
+ int annotationMemberValue(int pos) throws Exception {
+ writer.annotationValue();
+ return super.annotationMemberValue(pos);
+ }
+
+ int arrayMemberValue(int pos, int num) throws Exception {
+ writer.arrayValue(num);
+ return super.arrayMemberValue(pos, num);
+ }
+
+ /**
+ * Copies a constant pool entry into the destination constant pool
+ * and returns the index of the copied entry.
+ *
+ * @param srcIndex the index of the copied entry into the source
+ * constant pool.
+ * @return the index of the copied item into the destination
+ * constant pool.
+ */
+ int copy(int srcIndex) {
+ return srcPool.copy(srcIndex, destPool, classnames);
+ }
+
+ /**
+ * Copies a constant pool entry into the destination constant pool
+ * and returns the index of the copied entry. That entry must be
+ * a Utf8Info representing a class name in the L<class name>; form.
+ *
+ * @param srcIndex the index of the copied entry into the source
+ * constant pool.
+ * @return the index of the copied item into the destination
+ * constant pool.
+ */
+ int copyType(int srcIndex) {
+ String name = srcPool.getUtf8Info(srcIndex);
+ String newName = Descriptor.rename(name, classnames);
+ return destPool.addUtf8Info(newName);
+ }
+ }
+
+ static class Parser extends Walker {
+ ConstPool pool;
+ Annotation[][] allParams; // all parameters
+ Annotation[] allAnno; // all annotations
+ Annotation currentAnno; // current annotation
+ MemberValue currentMember; // current member
+
+ /**
+ * Constructs a parser. This parser constructs a parse tree of
+ * the annotations.
+ *
+ * @param info the attribute.
+ * @param src the constant pool.
+ */
+ Parser(byte[] info, ConstPool cp) {
+ super(info);
+ pool = cp;
+ }
+
+ Annotation[][] parseParameters() throws Exception {
+ parameters();
+ return allParams;
+ }
+
+ Annotation[] parseAnnotations() throws Exception {
+ annotationArray();
+ return allAnno;
+ }
+
+ MemberValue parseMemberValue() throws Exception {
+ memberValue(0);
+ return currentMember;
+ }
+
+ void parameters(int numParam, int pos) throws Exception {
+ Annotation[][] params = new Annotation[numParam][];
+ for (int i = 0; i < numParam; ++i) {
+ pos = annotationArray(pos);
+ params[i] = allAnno;
+ }
+
+ allParams = params;
+ }
+
+ int annotationArray(int pos, int num) throws Exception {
+ Annotation[] array = new Annotation[num];
+ for (int i = 0; i < num; ++i) {
+ pos = annotation(pos);
+ array[i] = currentAnno;
+ }
+
+ allAnno = array;
+ return pos;
+ }
+
+ int annotation(int pos, int type, int numPairs) throws Exception {
+ currentAnno = new Annotation(type, pool);
+ return super.annotation(pos, type, numPairs);
+ }
+
+ int memberValuePair(int pos, int nameIndex) throws Exception {
+ pos = super.memberValuePair(pos, nameIndex);
+ currentAnno.addMemberValue(nameIndex, currentMember);
+ return pos;
+ }
+
+ void constValueMember(int tag, int index) throws Exception {
+ MemberValue m;
+ ConstPool cp = pool;
+ switch (tag) {
+ case 'B' :
+ m = new ByteMemberValue(index, cp);
+ break;
+ case 'C' :
+ m = new CharMemberValue(index, cp);
+ break;
+ case 'D' :
+ m = new DoubleMemberValue(index, cp);
+ break;
+ case 'F' :
+ m = new FloatMemberValue(index, cp);
+ break;
+ case 'I' :
+ m = new IntegerMemberValue(index, cp);
+ break;
+ case 'J' :
+ m = new LongMemberValue(index, cp);
+ break;
+ case 'S' :
+ m = new ShortMemberValue(index, cp);
+ break;
+ case 'Z' :
+ m = new BooleanMemberValue(index, cp);
+ break;
+ case 's' :
+ m = new StringMemberValue(index, cp);
+ break;
+ default :
+ throw new RuntimeException("unknown tag:" + tag);
+ }
+
+ currentMember = m;
+ super.constValueMember(tag, index);
+ }
+
+ void enumMemberValue(int pos, int typeNameIndex, int constNameIndex)
+ throws Exception
+ {
+ currentMember = new EnumMemberValue(typeNameIndex,
+ constNameIndex, pool);
+ super.enumMemberValue(pos, typeNameIndex, constNameIndex);
+ }
+
+ void classMemberValue(int pos, int index) throws Exception {
+ currentMember = new ClassMemberValue(index, pool);
+ super.classMemberValue(pos, index);
+ }
+
+ int annotationMemberValue(int pos) throws Exception {
+ Annotation anno = currentAnno;
+ pos = super.annotationMemberValue(pos);
+ currentMember = new AnnotationMemberValue(currentAnno, pool);
+ currentAnno = anno;
+ return pos;
+ }
+
+ int arrayMemberValue(int pos, int num) throws Exception {
+ ArrayMemberValue amv = new ArrayMemberValue(pool);
+ MemberValue[] elements = new MemberValue[num];
+ for (int i = 0; i < num; ++i) {
+ pos = memberValue(pos);
+ elements[i] = currentMember;
+ }
+
+ amv.setValue(elements);
+ currentMember = amv;
+ return pos;
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/AttributeInfo.java b/src/main/javassist/bytecode/AttributeInfo.java
new file mode 100644
index 0000000..c5da7e1
--- /dev/null
+++ b/src/main/javassist/bytecode/AttributeInfo.java
@@ -0,0 +1,286 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.ArrayList;
+import java.util.ListIterator;
+import java.util.List;
+import java.util.Iterator;
+
+// Note: if you define a new subclass of AttributeInfo, then
+// update AttributeInfo.read(), .copy(), and (maybe) write().
+
+/**
+ * <code>attribute_info</code> structure.
+ */
+public class AttributeInfo {
+ protected ConstPool constPool;
+ int name;
+ byte[] info;
+
+ protected AttributeInfo(ConstPool cp, int attrname, byte[] attrinfo) {
+ constPool = cp;
+ name = attrname;
+ info = attrinfo;
+ }
+
+ protected AttributeInfo(ConstPool cp, String attrname) {
+ this(cp, attrname, (byte[])null);
+ }
+
+ /**
+ * Constructs an <code>attribute_info</code> structure.
+ *
+ * @param cp constant pool table
+ * @param attrname attribute name
+ * @param attrinfo <code>info</code> field
+ * of <code>attribute_info</code> structure.
+ */
+ public AttributeInfo(ConstPool cp, String attrname, byte[] attrinfo) {
+ this(cp, cp.addUtf8Info(attrname), attrinfo);
+ }
+
+ protected AttributeInfo(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ constPool = cp;
+ name = n;
+ int len = in.readInt();
+ info = new byte[len];
+ if (len > 0)
+ in.readFully(info);
+ }
+
+ static AttributeInfo read(ConstPool cp, DataInputStream in)
+ throws IOException
+ {
+ int name = in.readUnsignedShort();
+ String nameStr = cp.getUtf8Info(name);
+ if (nameStr.charAt(0) < 'L') {
+ if (nameStr.equals(AnnotationDefaultAttribute.tag))
+ return new AnnotationDefaultAttribute(cp, name, in);
+ else if (nameStr.equals(CodeAttribute.tag))
+ return new CodeAttribute(cp, name, in);
+ else if (nameStr.equals(ConstantAttribute.tag))
+ return new ConstantAttribute(cp, name, in);
+ else if (nameStr.equals(DeprecatedAttribute.tag))
+ return new DeprecatedAttribute(cp, name, in);
+ else if (nameStr.equals(EnclosingMethodAttribute.tag))
+ return new EnclosingMethodAttribute(cp, name, in);
+ else if (nameStr.equals(ExceptionsAttribute.tag))
+ return new ExceptionsAttribute(cp, name, in);
+ else if (nameStr.equals(InnerClassesAttribute.tag))
+ return new InnerClassesAttribute(cp, name, in);
+ }
+ else {
+ /* Note that the names of Annotations attributes begin with 'R'.
+ */
+ if (nameStr.equals(LineNumberAttribute.tag))
+ return new LineNumberAttribute(cp, name, in);
+ else if (nameStr.equals(LocalVariableAttribute.tag))
+ return new LocalVariableAttribute(cp, name, in);
+ else if (nameStr.equals(LocalVariableTypeAttribute.tag))
+ return new LocalVariableTypeAttribute(cp, name, in);
+ else if (nameStr.equals(AnnotationsAttribute.visibleTag)
+ || nameStr.equals(AnnotationsAttribute.invisibleTag)) {
+ // RuntimeVisibleAnnotations or RuntimeInvisibleAnnotations
+ return new AnnotationsAttribute(cp, name, in);
+ }
+ else if (nameStr.equals(ParameterAnnotationsAttribute.visibleTag)
+ || nameStr.equals(ParameterAnnotationsAttribute.invisibleTag))
+ return new ParameterAnnotationsAttribute(cp, name, in);
+ else if (nameStr.equals(SignatureAttribute.tag))
+ return new SignatureAttribute(cp, name, in);
+ else if (nameStr.equals(SourceFileAttribute.tag))
+ return new SourceFileAttribute(cp, name, in);
+ else if (nameStr.equals(SyntheticAttribute.tag))
+ return new SyntheticAttribute(cp, name, in);
+ else if (nameStr.equals(StackMap.tag))
+ return new StackMap(cp, name, in);
+ else if (nameStr.equals(StackMapTable.tag))
+ return new StackMapTable(cp, name, in);
+ }
+
+ return new AttributeInfo(cp, name, in);
+ }
+
+ /**
+ * Returns an attribute name.
+ */
+ public String getName() {
+ return constPool.getUtf8Info(name);
+ }
+
+ /**
+ * Returns a constant pool table.
+ */
+ public ConstPool getConstPool() { return constPool; }
+
+ /**
+ * Returns the length of this <code>attribute_info</code>
+ * structure.
+ * The returned value is <code>attribute_length + 6</code>.
+ */
+ public int length() {
+ return info.length + 6;
+ }
+
+ /**
+ * Returns the <code>info</code> field
+ * of this <code>attribute_info</code> structure.
+ *
+ * <p>This method is not available if the object is an instance
+ * of <code>CodeAttribute</code>.
+ */
+ public byte[] get() { return info; }
+
+ /**
+ * Sets the <code>info</code> field
+ * of this <code>attribute_info</code> structure.
+ *
+ * <p>This method is not available if the object is an instance
+ * of <code>CodeAttribute</code>.
+ */
+ public void set(byte[] newinfo) { info = newinfo; }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ int s = info.length;
+ byte[] srcInfo = info;
+ byte[] newInfo = new byte[s];
+ for (int i = 0; i < s; ++i)
+ newInfo[i] = srcInfo[i];
+
+ return new AttributeInfo(newCp, getName(), newInfo);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(name);
+ out.writeInt(info.length);
+ if (info.length > 0)
+ out.write(info);
+ }
+
+ static int getLength(ArrayList list) {
+ int size = 0;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ AttributeInfo attr = (AttributeInfo)list.get(i);
+ size += attr.length();
+ }
+
+ return size;
+ }
+
+ static AttributeInfo lookup(ArrayList list, String name) {
+ if (list == null)
+ return null;
+
+ ListIterator iterator = list.listIterator();
+ while (iterator.hasNext()) {
+ AttributeInfo ai = (AttributeInfo)iterator.next();
+ if (ai.getName().equals(name))
+ return ai;
+ }
+
+ return null; // no such attribute
+ }
+
+ static synchronized void remove(ArrayList list, String name) {
+ if (list == null)
+ return;
+
+ ListIterator iterator = list.listIterator();
+ while (iterator.hasNext()) {
+ AttributeInfo ai = (AttributeInfo)iterator.next();
+ if (ai.getName().equals(name))
+ iterator.remove();
+ }
+ }
+
+ static void writeAll(ArrayList list, DataOutputStream out)
+ throws IOException
+ {
+ if (list == null)
+ return;
+
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ AttributeInfo attr = (AttributeInfo)list.get(i);
+ attr.write(out);
+ }
+ }
+
+ static ArrayList copyAll(ArrayList list, ConstPool cp) {
+ if (list == null)
+ return null;
+
+ ArrayList newList = new ArrayList();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ AttributeInfo attr = (AttributeInfo)list.get(i);
+ newList.add(attr.copy(cp, null));
+ }
+
+ return newList;
+ }
+
+ /* The following two methods are used to implement
+ * ClassFile.renameClass().
+ * Only CodeAttribute, LocalVariableAttribute,
+ * AnnotationsAttribute, and SignatureAttribute
+ * override these methods.
+ */
+ void renameClass(String oldname, String newname) {}
+ void renameClass(Map classnames) {}
+
+ static void renameClass(List attributes, String oldname, String newname) {
+ Iterator iterator = attributes.iterator();
+ while (iterator.hasNext()) {
+ AttributeInfo ai = (AttributeInfo)iterator.next();
+ ai.renameClass(oldname, newname);
+ }
+ }
+
+ static void renameClass(List attributes, Map classnames) {
+ Iterator iterator = attributes.iterator();
+ while (iterator.hasNext()) {
+ AttributeInfo ai = (AttributeInfo)iterator.next();
+ ai.renameClass(classnames);
+ }
+ }
+
+ void getRefClasses(Map classnames) {}
+
+ static void getRefClasses(List attributes, Map classnames) {
+ Iterator iterator = attributes.iterator();
+ while (iterator.hasNext()) {
+ AttributeInfo ai = (AttributeInfo)iterator.next();
+ ai.getRefClasses(classnames);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/BadBytecode.java b/src/main/javassist/bytecode/BadBytecode.java
new file mode 100644
index 0000000..2f93b52
--- /dev/null
+++ b/src/main/javassist/bytecode/BadBytecode.java
@@ -0,0 +1,33 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * Signals that a bad bytecode sequence has been found.
+ */
+public class BadBytecode extends Exception {
+ public BadBytecode(int opcode) {
+ super("bytecode " + opcode);
+ }
+
+ public BadBytecode(String msg) {
+ super(msg);
+ }
+
+ public BadBytecode(String msg, Throwable cause) {
+ super(msg, cause);
+ }
+}
diff --git a/src/main/javassist/bytecode/ByteArray.java b/src/main/javassist/bytecode/ByteArray.java
new file mode 100644
index 0000000..e564822
--- /dev/null
+++ b/src/main/javassist/bytecode/ByteArray.java
@@ -0,0 +1,76 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * A collection of static methods for reading and writing a byte array.
+ */
+public class ByteArray {
+ /**
+ * Reads an unsigned 16bit integer at the index.
+ */
+ public static int readU16bit(byte[] code, int index) {
+ return ((code[index] & 0xff) << 8) | (code[index + 1] & 0xff);
+ }
+
+ /**
+ * Reads a signed 16bit integer at the index.
+ */
+ public static int readS16bit(byte[] code, int index) {
+ return (code[index] << 8) | (code[index + 1] & 0xff);
+ }
+
+ /**
+ * Writes a 16bit integer at the index.
+ */
+ public static void write16bit(int value, byte[] code, int index) {
+ code[index] = (byte)(value >>> 8);
+ code[index + 1] = (byte)value;
+ }
+
+ /**
+ * Reads a 32bit integer at the index.
+ */
+ public static int read32bit(byte[] code, int index) {
+ return (code[index] << 24) | ((code[index + 1] & 0xff) << 16)
+ | ((code[index + 2] & 0xff) << 8) | (code[index + 3] & 0xff);
+ }
+
+ /**
+ * Writes a 32bit integer at the index.
+ */
+ public static void write32bit(int value, byte[] code, int index) {
+ code[index] = (byte)(value >>> 24);
+ code[index + 1] = (byte)(value >>> 16);
+ code[index + 2] = (byte)(value >>> 8);
+ code[index + 3] = (byte)value;
+ }
+
+ /**
+ * Copies a 32bit integer.
+ *
+ * @param src the source byte array.
+ * @param isrc the index into the source byte array.
+ * @param dest the destination byte array.
+ * @param idest the index into the destination byte array.
+ */
+ static void copy32bit(byte[] src, int isrc, byte[] dest, int idest) {
+ dest[idest] = src[isrc];
+ dest[idest + 1] = src[isrc + 1];
+ dest[idest + 2] = src[isrc + 2];
+ dest[idest + 3] = src[isrc + 3];
+ }
+}
diff --git a/src/main/javassist/bytecode/ByteStream.java b/src/main/javassist/bytecode/ByteStream.java
new file mode 100644
index 0000000..82b30c9
--- /dev/null
+++ b/src/main/javassist/bytecode/ByteStream.java
@@ -0,0 +1,193 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.OutputStream;
+import java.io.IOException;
+
+final class ByteStream extends OutputStream {
+ private byte[] buf;
+ private int count;
+
+ public ByteStream() { this(32); }
+
+ public ByteStream(int size) {
+ buf = new byte[size];
+ count = 0;
+ }
+
+ public int getPos() { return count; }
+ public int size() { return count; }
+
+ public void writeBlank(int len) {
+ enlarge(len);
+ count += len;
+ }
+
+ public void write(byte[] data) {
+ write(data, 0, data.length);
+ }
+
+ public void write(byte[] data, int off, int len) {
+ enlarge(len);
+ System.arraycopy(data, off, buf, count, len);
+ count += len;
+ }
+
+ public void write(int b) {
+ enlarge(1);
+ int oldCount = count;
+ buf[oldCount] = (byte)b;
+ count = oldCount + 1;
+ }
+
+ public void writeShort(int s) {
+ enlarge(2);
+ int oldCount = count;
+ buf[oldCount] = (byte)(s >>> 8);
+ buf[oldCount + 1] = (byte)s;
+ count = oldCount + 2;
+ }
+
+ public void writeInt(int i) {
+ enlarge(4);
+ int oldCount = count;
+ buf[oldCount] = (byte)(i >>> 24);
+ buf[oldCount + 1] = (byte)(i >>> 16);
+ buf[oldCount + 2] = (byte)(i >>> 8);
+ buf[oldCount + 3] = (byte)i;
+ count = oldCount + 4;
+ }
+
+ public void writeLong(long i) {
+ enlarge(8);
+ int oldCount = count;
+ buf[oldCount] = (byte)(i >>> 56);
+ buf[oldCount + 1] = (byte)(i >>> 48);
+ buf[oldCount + 2] = (byte)(i >>> 40);
+ buf[oldCount + 3] = (byte)(i >>> 32);
+ buf[oldCount + 4] = (byte)(i >>> 24);
+ buf[oldCount + 5] = (byte)(i >>> 16);
+ buf[oldCount + 6] = (byte)(i >>> 8);
+ buf[oldCount + 7] = (byte)i;
+ count = oldCount + 8;
+ }
+
+ public void writeFloat(float v) {
+ writeInt(Float.floatToIntBits(v));
+ }
+
+ public void writeDouble(double v) {
+ writeLong(Double.doubleToLongBits(v));
+ }
+
+ public void writeUTF(String s) {
+ int sLen = s.length();
+ int pos = count;
+ enlarge(sLen + 2);
+
+ byte[] buffer = buf;
+ buffer[pos++] = (byte)(sLen >>> 8);
+ buffer[pos++] = (byte)sLen;
+ for (int i = 0; i < sLen; ++i) {
+ char c = s.charAt(i);
+ if (0x01 <= c && c <= 0x7f)
+ buffer[pos++] = (byte)c;
+ else {
+ writeUTF2(s, sLen, i);
+ return;
+ }
+ }
+
+ count = pos;
+ }
+
+ private void writeUTF2(String s, int sLen, int offset) {
+ int size = sLen;
+ for (int i = offset; i < sLen; i++) {
+ int c = s.charAt(i);
+ if (c > 0x7ff)
+ size += 2; // 3 bytes code
+ else if (c == 0 || c > 0x7f)
+ ++size; // 2 bytes code
+ }
+
+ if (size > 65535)
+ throw new RuntimeException(
+ "encoded string too long: " + sLen + size + " bytes");
+
+ enlarge(size + 2);
+ int pos = count;
+ byte[] buffer = buf;
+ buffer[pos] = (byte)(size >>> 8);
+ buffer[pos + 1] = (byte)size;
+ pos += 2 + offset;
+ for (int j = offset; j < sLen; ++j) {
+ int c = s.charAt(j);
+ if (0x01 <= c && c <= 0x7f)
+ buffer[pos++] = (byte) c;
+ else if (c > 0x07ff) {
+ buffer[pos] = (byte)(0xe0 | ((c >> 12) & 0x0f));
+ buffer[pos + 1] = (byte)(0x80 | ((c >> 6) & 0x3f));
+ buffer[pos + 2] = (byte)(0x80 | (c & 0x3f));
+ pos += 3;
+ }
+ else {
+ buffer[pos] = (byte)(0xc0 | ((c >> 6) & 0x1f));
+ buffer[pos + 1] = (byte)(0x80 | (c & 0x3f));
+ pos += 2;
+ }
+ }
+
+ count = pos;
+ }
+
+ public void write(int pos, int value) {
+ buf[pos] = (byte)value;
+ }
+
+ public void writeShort(int pos, int value) {
+ buf[pos] = (byte)(value >>> 8);
+ buf[pos + 1] = (byte)value;
+ }
+
+ public void writeInt(int pos, int value) {
+ buf[pos] = (byte)(value >>> 24);
+ buf[pos + 1] = (byte)(value >>> 16);
+ buf[pos + 2] = (byte)(value >>> 8);
+ buf[pos + 3] = (byte)value;
+ }
+
+ public byte[] toByteArray() {
+ byte[] buf2 = new byte[count];
+ System.arraycopy(buf, 0, buf2, 0, count);
+ return buf2;
+ }
+
+ public void writeTo(OutputStream out) throws IOException {
+ out.write(buf, 0, count);
+ }
+
+ public void enlarge(int delta) {
+ int newCount = count + delta;
+ if (newCount > buf.length) {
+ int newLen = buf.length << 1;
+ byte[] newBuf = new byte[newLen > newCount ? newLen : newCount];
+ System.arraycopy(buf, 0, newBuf, 0, count);
+ buf = newBuf;
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/Bytecode.java b/src/main/javassist/bytecode/Bytecode.java
new file mode 100644
index 0000000..92fd1f0
--- /dev/null
+++ b/src/main/javassist/bytecode/Bytecode.java
@@ -0,0 +1,1410 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import javassist.CtClass;
+import javassist.CtPrimitiveType;
+
+class ByteVector implements Cloneable {
+ private byte[] buffer;
+ private int size;
+
+ public ByteVector() {
+ buffer = new byte[64];
+ size = 0;
+ }
+
+ public Object clone() throws CloneNotSupportedException {
+ ByteVector bv = (ByteVector)super.clone();
+ bv.buffer = (byte[])buffer.clone();
+ return bv;
+ }
+
+ public final int getSize() { return size; }
+
+ public final byte[] copy() {
+ byte[] b = new byte[size];
+ System.arraycopy(buffer, 0, b, 0, size);
+ return b;
+ }
+
+ public int read(int offset) {
+ if (offset < 0 || size <= offset)
+ throw new ArrayIndexOutOfBoundsException(offset);
+
+ return buffer[offset];
+ }
+
+ public void write(int offset, int value) {
+ if (offset < 0 || size <= offset)
+ throw new ArrayIndexOutOfBoundsException(offset);
+
+ buffer[offset] = (byte)value;
+ }
+
+ public void add(int code) {
+ addGap(1);
+ buffer[size - 1] = (byte)code;
+ }
+
+ public void add(int b1, int b2) {
+ addGap(2);
+ buffer[size - 2] = (byte)b1;
+ buffer[size - 1] = (byte)b2;
+ }
+
+ public void add(int b1, int b2, int b3, int b4) {
+ addGap(4);
+ buffer[size - 4] = (byte)b1;
+ buffer[size - 3] = (byte)b2;
+ buffer[size - 2] = (byte)b3;
+ buffer[size - 1] = (byte)b4;
+ }
+
+ public void addGap(int length) {
+ if (size + length > buffer.length) {
+ int newSize = size << 1;
+ if (newSize < size + length)
+ newSize = size + length;
+
+ byte[] newBuf = new byte[newSize];
+ System.arraycopy(buffer, 0, newBuf, 0, size);
+ buffer = newBuf;
+ }
+
+ size += length;
+ }
+}
+
+/**
+ * A utility class for producing a bytecode sequence.
+ *
+ * <p>A <code>Bytecode</code> object is an unbounded array
+ * containing bytecode. For example,
+ *
+ * <ul><pre>ConstPool cp = ...; // constant pool table
+ * Bytecode b = new Bytecode(cp, 1, 0);
+ * b.addIconst(3);
+ * b.addReturn(CtClass.intType);
+ * CodeAttribute ca = b.toCodeAttribute();</ul></pre>
+ *
+ * <p>This program produces a Code attribute including a bytecode
+ * sequence:
+ *
+ * <ul><pre>iconst_3
+ * ireturn</pre></ul>
+ *
+ * @see ConstPool
+ * @see CodeAttribute
+ */
+public class Bytecode extends ByteVector implements Cloneable, Opcode {
+ /**
+ * Represents the <code>CtClass</code> file using the
+ * constant pool table given to this <code>Bytecode</code> object.
+ */
+ public static final CtClass THIS = ConstPool.THIS;
+
+ ConstPool constPool;
+ int maxStack, maxLocals;
+ ExceptionTable tryblocks;
+ private int stackDepth;
+
+ /**
+ * Constructs a <code>Bytecode</code> object with an empty bytecode
+ * sequence.
+ *
+ * <p>The parameters <code>stacksize</code> and <code>localvars</code>
+ * specify initial values
+ * of <code>max_stack</code> and <code>max_locals</code>.
+ * They can be changed later.
+ *
+ * @param cp constant pool table.
+ * @param stacksize <code>max_stack</code>.
+ * @param localvars <code>max_locals</code>.
+ */
+ public Bytecode(ConstPool cp, int stacksize, int localvars) {
+ constPool = cp;
+ maxStack = stacksize;
+ maxLocals = localvars;
+ tryblocks = new ExceptionTable(cp);
+ stackDepth = 0;
+ }
+
+ /**
+ * Constructs a <code>Bytecode</code> object with an empty bytecode
+ * sequence. The initial values of <code>max_stack</code> and
+ * <code>max_locals</code> are zero.
+ *
+ * @param cp constant pool table.
+ * @see Bytecode#setMaxStack(int)
+ * @see Bytecode#setMaxLocals(int)
+ */
+ public Bytecode(ConstPool cp) {
+ this(cp, 0, 0);
+ }
+
+ /**
+ * Creates and returns a copy of this object.
+ * The constant pool object is shared between this object
+ * and the cloned object.
+ */
+ public Object clone() {
+ try {
+ Bytecode bc = (Bytecode)super.clone();
+ bc.tryblocks = (ExceptionTable)tryblocks.clone();
+ return bc;
+ }
+ catch (CloneNotSupportedException cnse) {
+ throw new RuntimeException(cnse);
+ }
+ }
+
+ /**
+ * Gets a constant pool table.
+ */
+ public ConstPool getConstPool() { return constPool; }
+
+ /**
+ * Returns <code>exception_table</code>.
+ */
+ public ExceptionTable getExceptionTable() { return tryblocks; }
+
+ /**
+ * Converts to a <code>CodeAttribute</code>.
+ */
+ public CodeAttribute toCodeAttribute() {
+ return new CodeAttribute(constPool, maxStack, maxLocals,
+ get(), tryblocks);
+ }
+
+ /**
+ * Returns the length of the bytecode sequence.
+ */
+ public int length() {
+ return getSize();
+ }
+
+ /**
+ * Returns the produced bytecode sequence.
+ */
+ public byte[] get() {
+ return copy();
+ }
+
+ /**
+ * Gets <code>max_stack</code>.
+ */
+ public int getMaxStack() { return maxStack; }
+
+ /**
+ * Sets <code>max_stack</code>.
+ *
+ * <p>This value may be automatically updated when an instruction
+ * is appended. A <code>Bytecode</code> object maintains the current
+ * stack depth whenever an instruction is added
+ * by <code>addOpcode()</code>. For example, if DUP is appended,
+ * the current stack depth is increased by one. If the new stack
+ * depth is more than <code>max_stack</code>, then it is assigned
+ * to <code>max_stack</code>. However, if branch instructions are
+ * appended, the current stack depth may not be correctly maintained.
+ *
+ * @see #addOpcode(int)
+ */
+ public void setMaxStack(int size) {
+ maxStack = size;
+ }
+
+ /**
+ * Gets <code>max_locals</code>.
+ */
+ public int getMaxLocals() { return maxLocals; }
+
+ /**
+ * Sets <code>max_locals</code>.
+ */
+ public void setMaxLocals(int size) {
+ maxLocals = size;
+ }
+
+ /**
+ * Sets <code>max_locals</code>.
+ *
+ * <p>This computes the number of local variables
+ * used to pass method parameters and sets <code>max_locals</code>
+ * to that number plus <code>locals</code>.
+ *
+ * @param isStatic true if <code>params</code> must be
+ * interpreted as parameters to a static method.
+ * @param params parameter types.
+ * @param locals the number of local variables excluding
+ * ones used to pass parameters.
+ */
+ public void setMaxLocals(boolean isStatic, CtClass[] params,
+ int locals) {
+ if (!isStatic)
+ ++locals;
+
+ if (params != null) {
+ CtClass doubleType = CtClass.doubleType;
+ CtClass longType = CtClass.longType;
+ int n = params.length;
+ for (int i = 0; i < n; ++i) {
+ CtClass type = params[i];
+ if (type == doubleType || type == longType)
+ locals += 2;
+ else
+ ++locals;
+ }
+ }
+
+ maxLocals = locals;
+ }
+
+ /**
+ * Increments <code>max_locals</code>.
+ */
+ public void incMaxLocals(int diff) {
+ maxLocals += diff;
+ }
+
+ /**
+ * Adds a new entry of <code>exception_table</code>.
+ */
+ public void addExceptionHandler(int start, int end,
+ int handler, CtClass type) {
+ addExceptionHandler(start, end, handler,
+ constPool.addClassInfo(type));
+ }
+
+ /**
+ * Adds a new entry of <code>exception_table</code>.
+ *
+ * @param type the fully-qualified name of a throwable class.
+ */
+ public void addExceptionHandler(int start, int end,
+ int handler, String type) {
+ addExceptionHandler(start, end, handler,
+ constPool.addClassInfo(type));
+ }
+
+ /**
+ * Adds a new entry of <code>exception_table</code>.
+ */
+ public void addExceptionHandler(int start, int end,
+ int handler, int type) {
+ tryblocks.add(start, end, handler, type);
+ }
+
+ /**
+ * Returns the length of bytecode sequence
+ * that have been added so far.
+ */
+ public int currentPc() {
+ return getSize();
+ }
+
+ /**
+ * Reads a signed 8bit value at the offset from the beginning of the
+ * bytecode sequence.
+ *
+ * @throws ArrayIndexOutOfBoundsException if offset is invalid.
+ */
+ public int read(int offset) {
+ return super.read(offset);
+ }
+
+ /**
+ * Reads a signed 16bit value at the offset from the beginning of the
+ * bytecode sequence.
+ */
+ public int read16bit(int offset) {
+ int v1 = read(offset);
+ int v2 = read(offset + 1);
+ return (v1 << 8) + (v2 & 0xff);
+ }
+
+ /**
+ * Reads a signed 32bit value at the offset from the beginning of the
+ * bytecode sequence.
+ */
+ public int read32bit(int offset) {
+ int v1 = read16bit(offset);
+ int v2 = read16bit(offset + 2);
+ return (v1 << 16) + (v2 & 0xffff);
+ }
+
+ /**
+ * Writes an 8bit value at the offset from the beginning of the
+ * bytecode sequence.
+ *
+ * @throws ArrayIndexOutOfBoundsException if offset is invalid.
+ */
+ public void write(int offset, int value) {
+ super.write(offset, value);
+ }
+
+ /**
+ * Writes an 16bit value at the offset from the beginning of the
+ * bytecode sequence.
+ */
+ public void write16bit(int offset, int value) {
+ write(offset, value >> 8);
+ write(offset + 1, value);
+ }
+
+ /**
+ * Writes an 32bit value at the offset from the beginning of the
+ * bytecode sequence.
+ */
+ public void write32bit(int offset, int value) {
+ write16bit(offset, value >> 16);
+ write16bit(offset + 2, value);
+ }
+
+ /**
+ * Appends an 8bit value to the end of the bytecode sequence.
+ */
+ public void add(int code) {
+ super.add(code);
+ }
+
+ /**
+ * Appends a 32bit value to the end of the bytecode sequence.
+ */
+ public void add32bit(int value) {
+ add(value >> 24, value >> 16, value >> 8, value);
+ }
+
+ /**
+ * Appends the length-byte gap to the end of the bytecode sequence.
+ *
+ * @param length the gap length in byte.
+ */
+ public void addGap(int length) {
+ super.addGap(length);
+ }
+
+ /**
+ * Appends an 8bit opcode to the end of the bytecode sequence.
+ * The current stack depth is updated.
+ * <code>max_stack</code> is updated if the current stack depth
+ * is the deepest so far.
+ *
+ * <p>Note: some instructions such as INVOKEVIRTUAL does not
+ * update the current stack depth since the increment depends
+ * on the method signature.
+ * <code>growStack()</code> must be explicitly called.
+ */
+ public void addOpcode(int code) {
+ add(code);
+ growStack(STACK_GROW[code]);
+ }
+
+ /**
+ * Increases the current stack depth.
+ * It also updates <code>max_stack</code> if the current stack depth
+ * is the deepest so far.
+ *
+ * @param diff the number added to the current stack depth.
+ */
+ public void growStack(int diff) {
+ setStackDepth(stackDepth + diff);
+ }
+
+ /**
+ * Returns the current stack depth.
+ */
+ public int getStackDepth() { return stackDepth; }
+
+ /**
+ * Sets the current stack depth.
+ * It also updates <code>max_stack</code> if the current stack depth
+ * is the deepest so far.
+ *
+ * @param depth new value.
+ */
+ public void setStackDepth(int depth) {
+ stackDepth = depth;
+ if (stackDepth > maxStack)
+ maxStack = stackDepth;
+ }
+
+ /**
+ * Appends a 16bit value to the end of the bytecode sequence.
+ * It never changes the current stack depth.
+ */
+ public void addIndex(int index) {
+ add(index >> 8, index);
+ }
+
+ /**
+ * Appends ALOAD or (WIDE) ALOAD_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addAload(int n) {
+ if (n < 4)
+ addOpcode(42 + n); // aload_<n>
+ else if (n < 0x100) {
+ addOpcode(ALOAD); // aload
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(ALOAD);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends ASTORE or (WIDE) ASTORE_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addAstore(int n) {
+ if (n < 4)
+ addOpcode(75 + n); // astore_<n>
+ else if (n < 0x100) {
+ addOpcode(ASTORE); // astore
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(ASTORE);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends ICONST or ICONST_<n>
+ *
+ * @param n the pushed integer constant.
+ */
+ public void addIconst(int n) {
+ if (n < 6 && -2 < n)
+ addOpcode(3 + n); // iconst_<i> -1..5
+ else if (n <= 127 && -128 <= n) {
+ addOpcode(16); // bipush
+ add(n);
+ }
+ else if (n <= 32767 && -32768 <= n) {
+ addOpcode(17); // sipush
+ add(n >> 8);
+ add(n);
+ }
+ else
+ addLdc(constPool.addIntegerInfo(n));
+ }
+
+ /**
+ * Appends an instruction for pushing zero or null on the stack.
+ * If the type is void, this method does not append any instruction.
+ *
+ * @param type the type of the zero value (or null).
+ */
+ public void addConstZero(CtClass type) {
+ if (type.isPrimitive()) {
+ if (type == CtClass.longType)
+ addOpcode(LCONST_0);
+ else if (type == CtClass.floatType)
+ addOpcode(FCONST_0);
+ else if (type == CtClass.doubleType)
+ addOpcode(DCONST_0);
+ else if (type == CtClass.voidType)
+ throw new RuntimeException("void type?");
+ else
+ addOpcode(ICONST_0);
+ }
+ else
+ addOpcode(ACONST_NULL);
+ }
+
+ /**
+ * Appends ILOAD or (WIDE) ILOAD_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addIload(int n) {
+ if (n < 4)
+ addOpcode(26 + n); // iload_<n>
+ else if (n < 0x100) {
+ addOpcode(ILOAD); // iload
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(ILOAD);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends ISTORE or (WIDE) ISTORE_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addIstore(int n) {
+ if (n < 4)
+ addOpcode(59 + n); // istore_<n>
+ else if (n < 0x100) {
+ addOpcode(ISTORE); // istore
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(ISTORE);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends LCONST or LCONST_<n>
+ *
+ * @param n the pushed long integer constant.
+ */
+ public void addLconst(long n) {
+ if (n == 0 || n == 1)
+ addOpcode(9 + (int)n); // lconst_<n>
+ else
+ addLdc2w(n);
+ }
+
+ /**
+ * Appends LLOAD or (WIDE) LLOAD_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addLload(int n) {
+ if (n < 4)
+ addOpcode(30 + n); // lload_<n>
+ else if (n < 0x100) {
+ addOpcode(LLOAD); // lload
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(LLOAD);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends LSTORE or LSTORE_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addLstore(int n) {
+ if (n < 4)
+ addOpcode(63 + n); // lstore_<n>
+ else if (n < 0x100) {
+ addOpcode(LSTORE); // lstore
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(LSTORE);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends DCONST or DCONST_<n>
+ *
+ * @param d the pushed double constant.
+ */
+ public void addDconst(double d) {
+ if (d == 0.0 || d == 1.0)
+ addOpcode(14 + (int)d); // dconst_<n>
+ else
+ addLdc2w(d);
+ }
+
+ /**
+ * Appends DLOAD or (WIDE) DLOAD_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addDload(int n) {
+ if (n < 4)
+ addOpcode(38 + n); // dload_<n>
+ else if (n < 0x100) {
+ addOpcode(DLOAD); // dload
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(DLOAD);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends DSTORE or (WIDE) DSTORE_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addDstore(int n) {
+ if (n < 4)
+ addOpcode(71 + n); // dstore_<n>
+ else if (n < 0x100) {
+ addOpcode(DSTORE); // dstore
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(DSTORE);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends FCONST or FCONST_<n>
+ *
+ * @param f the pushed float constant.
+ */
+ public void addFconst(float f) {
+ if (f == 0.0f || f == 1.0f || f == 2.0f)
+ addOpcode(11 + (int)f); // fconst_<n>
+ else
+ addLdc(constPool.addFloatInfo(f));
+ }
+
+ /**
+ * Appends FLOAD or (WIDE) FLOAD_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addFload(int n) {
+ if (n < 4)
+ addOpcode(34 + n); // fload_<n>
+ else if (n < 0x100) {
+ addOpcode(FLOAD); // fload
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(FLOAD);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends FSTORE or FSTORE_<n>
+ *
+ * @param n an index into the local variable array.
+ */
+ public void addFstore(int n) {
+ if (n < 4)
+ addOpcode(67 + n); // fstore_<n>
+ else if (n < 0x100) {
+ addOpcode(FSTORE); // fstore
+ add(n);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(FSTORE);
+ addIndex(n);
+ }
+ }
+
+ /**
+ * Appends an instruction for loading a value from the
+ * local variable at the index <code>n</code>.
+ *
+ * @param n the index.
+ * @param type the type of the loaded value.
+ * @return the size of the value (1 or 2 word).
+ */
+ public int addLoad(int n, CtClass type) {
+ if (type.isPrimitive()) {
+ if (type == CtClass.booleanType || type == CtClass.charType
+ || type == CtClass.byteType || type == CtClass.shortType
+ || type == CtClass.intType)
+ addIload(n);
+ else if (type == CtClass.longType) {
+ addLload(n);
+ return 2;
+ }
+ else if(type == CtClass.floatType)
+ addFload(n);
+ else if(type == CtClass.doubleType) {
+ addDload(n);
+ return 2;
+ }
+ else
+ throw new RuntimeException("void type?");
+ }
+ else
+ addAload(n);
+
+ return 1;
+ }
+
+ /**
+ * Appends an instruction for storing a value into the
+ * local variable at the index <code>n</code>.
+ *
+ * @param n the index.
+ * @param type the type of the stored value.
+ * @return 2 if the type is long or double. Otherwise 1.
+ */
+ public int addStore(int n, CtClass type) {
+ if (type.isPrimitive()) {
+ if (type == CtClass.booleanType || type == CtClass.charType
+ || type == CtClass.byteType || type == CtClass.shortType
+ || type == CtClass.intType)
+ addIstore(n);
+ else if (type == CtClass.longType) {
+ addLstore(n);
+ return 2;
+ }
+ else if (type == CtClass.floatType)
+ addFstore(n);
+ else if (type == CtClass.doubleType) {
+ addDstore(n);
+ return 2;
+ }
+ else
+ throw new RuntimeException("void type?");
+ }
+ else
+ addAstore(n);
+
+ return 1;
+ }
+
+ /**
+ * Appends instructions for loading all the parameters onto the
+ * operand stack.
+ *
+ * @param offset the index of the first parameter. It is 0
+ * if the method is static. Otherwise, it is 1.
+ */
+ public int addLoadParameters(CtClass[] params, int offset) {
+ int stacksize = 0;
+ if (params != null) {
+ int n = params.length;
+ for (int i = 0; i < n; ++i)
+ stacksize += addLoad(stacksize + offset, params[i]);
+ }
+
+ return stacksize;
+ }
+
+ /**
+ * Appends CHECKCAST.
+ *
+ * @param c the type.
+ */
+ public void addCheckcast(CtClass c) {
+ addOpcode(CHECKCAST);
+ addIndex(constPool.addClassInfo(c));
+ }
+
+ /**
+ * Appends CHECKCAST.
+ *
+ * @param classname a fully-qualified class name.
+ */
+ public void addCheckcast(String classname) {
+ addOpcode(CHECKCAST);
+ addIndex(constPool.addClassInfo(classname));
+ }
+
+ /**
+ * Appends INSTANCEOF.
+ *
+ * @param classname the class name.
+ */
+ public void addInstanceof(String classname) {
+ addOpcode(INSTANCEOF);
+ addIndex(constPool.addClassInfo(classname));
+ }
+
+ /**
+ * Appends GETFIELD.
+ *
+ * @param c the class.
+ * @param name the field name.
+ * @param type the descriptor of the field type.
+ *
+ * @see Descriptor#of(CtClass)
+ */
+ public void addGetfield(CtClass c, String name, String type) {
+ add(GETFIELD);
+ int ci = constPool.addClassInfo(c);
+ addIndex(constPool.addFieldrefInfo(ci, name, type));
+ growStack(Descriptor.dataSize(type) - 1);
+ }
+
+ /**
+ * Appends GETFIELD.
+ *
+ * @param c the fully-qualified class name.
+ * @param name the field name.
+ * @param type the descriptor of the field type.
+ *
+ * @see Descriptor#of(CtClass)
+ */
+ public void addGetfield(String c, String name, String type) {
+ add(GETFIELD);
+ int ci = constPool.addClassInfo(c);
+ addIndex(constPool.addFieldrefInfo(ci, name, type));
+ growStack(Descriptor.dataSize(type) - 1);
+ }
+
+ /**
+ * Appends GETSTATIC.
+ *
+ * @param c the class
+ * @param name the field name
+ * @param type the descriptor of the field type.
+ *
+ * @see Descriptor#of(CtClass)
+ */
+ public void addGetstatic(CtClass c, String name, String type) {
+ add(GETSTATIC);
+ int ci = constPool.addClassInfo(c);
+ addIndex(constPool.addFieldrefInfo(ci, name, type));
+ growStack(Descriptor.dataSize(type));
+ }
+
+ /**
+ * Appends GETSTATIC.
+ *
+ * @param c the fully-qualified class name
+ * @param name the field name
+ * @param type the descriptor of the field type.
+ *
+ * @see Descriptor#of(CtClass)
+ */
+ public void addGetstatic(String c, String name, String type) {
+ add(GETSTATIC);
+ int ci = constPool.addClassInfo(c);
+ addIndex(constPool.addFieldrefInfo(ci, name, type));
+ growStack(Descriptor.dataSize(type));
+ }
+
+ /**
+ * Appends INVOKESPECIAL.
+ *
+ * @param clazz the target class.
+ * @param name the method name.
+ * @param returnType the return type.
+ * @param paramTypes the parameter types.
+ */
+ public void addInvokespecial(CtClass clazz, String name,
+ CtClass returnType, CtClass[] paramTypes) {
+ String desc = Descriptor.ofMethod(returnType, paramTypes);
+ addInvokespecial(clazz, name, desc);
+ }
+
+ /**
+ * Appends INVOKESPECIAL.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ * @see Descriptor#ofConstructor(CtClass[])
+ */
+ public void addInvokespecial(CtClass clazz, String name, String desc) {
+ addInvokespecial(constPool.addClassInfo(clazz), name, desc);
+ }
+
+ /**
+ * Appends INVOKESPECIAL.
+ *
+ * @param clazz the fully-qualified class name.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ * @see Descriptor#ofConstructor(CtClass[])
+ */
+ public void addInvokespecial(String clazz, String name, String desc) {
+ addInvokespecial(constPool.addClassInfo(clazz), name, desc);
+ }
+
+ /**
+ * Appends INVOKESPECIAL.
+ *
+ * @param clazz the index of <code>CONSTANT_Class_info</code>
+ * structure.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ * @see Descriptor#ofConstructor(CtClass[])
+ */
+ public void addInvokespecial(int clazz, String name, String desc) {
+ add(INVOKESPECIAL);
+ addIndex(constPool.addMethodrefInfo(clazz, name, desc));
+ growStack(Descriptor.dataSize(desc) - 1);
+ }
+
+ /**
+ * Appends INVOKESTATIC.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param returnType the return type.
+ * @param paramTypes the parameter types.
+ */
+ public void addInvokestatic(CtClass clazz, String name,
+ CtClass returnType, CtClass[] paramTypes) {
+ String desc = Descriptor.ofMethod(returnType, paramTypes);
+ addInvokestatic(clazz, name, desc);
+ }
+
+ /**
+ * Appends INVOKESTATIC.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokestatic(CtClass clazz, String name, String desc) {
+ addInvokestatic(constPool.addClassInfo(clazz), name, desc);
+ }
+
+ /**
+ * Appends INVOKESTATIC.
+ *
+ * @param classname the fully-qualified class name.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokestatic(String classname, String name, String desc) {
+ addInvokestatic(constPool.addClassInfo(classname), name, desc);
+ }
+
+ /**
+ * Appends INVOKESTATIC.
+ *
+ * @param clazz the index of <code>CONSTANT_Class_info</code>
+ * structure.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokestatic(int clazz, String name, String desc) {
+ add(INVOKESTATIC);
+ addIndex(constPool.addMethodrefInfo(clazz, name, desc));
+ growStack(Descriptor.dataSize(desc));
+ }
+
+ /**
+ * Appends INVOKEVIRTUAL.
+ *
+ * <p>The specified method must not be an inherited method.
+ * It must be directly declared in the class specified
+ * in <code>clazz</code>.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param returnType the return type.
+ * @param paramTypes the parameter types.
+ */
+ public void addInvokevirtual(CtClass clazz, String name,
+ CtClass returnType, CtClass[] paramTypes) {
+ String desc = Descriptor.ofMethod(returnType, paramTypes);
+ addInvokevirtual(clazz, name, desc);
+ }
+
+ /**
+ * Appends INVOKEVIRTUAL.
+ *
+ * <p>The specified method must not be an inherited method.
+ * It must be directly declared in the class specified
+ * in <code>clazz</code>.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokevirtual(CtClass clazz, String name, String desc) {
+ addInvokevirtual(constPool.addClassInfo(clazz), name, desc);
+ }
+
+ /**
+ * Appends INVOKEVIRTUAL.
+ *
+ * <p>The specified method must not be an inherited method.
+ * It must be directly declared in the class specified
+ * in <code>classname</code>.
+ *
+ * @param classname the fully-qualified class name.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokevirtual(String classname, String name, String desc) {
+ addInvokevirtual(constPool.addClassInfo(classname), name, desc);
+ }
+
+ /**
+ * Appends INVOKEVIRTUAL.
+ *
+ * <p>The specified method must not be an inherited method.
+ * It must be directly declared in the class specified
+ * by <code>clazz</code>.
+ *
+ * @param clazz the index of <code>CONSTANT_Class_info</code>
+ * structure.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokevirtual(int clazz, String name, String desc) {
+ add(INVOKEVIRTUAL);
+ addIndex(constPool.addMethodrefInfo(clazz, name, desc));
+ growStack(Descriptor.dataSize(desc) - 1);
+ }
+
+ /**
+ * Appends INVOKEINTERFACE.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param returnType the return type.
+ * @param paramTypes the parameter types.
+ * @param count the count operand of the instruction.
+ */
+ public void addInvokeinterface(CtClass clazz, String name,
+ CtClass returnType, CtClass[] paramTypes,
+ int count) {
+ String desc = Descriptor.ofMethod(returnType, paramTypes);
+ addInvokeinterface(clazz, name, desc, count);
+ }
+
+ /**
+ * Appends INVOKEINTERFACE.
+ *
+ * @param clazz the target class.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ * @param count the count operand of the instruction.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokeinterface(CtClass clazz, String name,
+ String desc, int count) {
+ addInvokeinterface(constPool.addClassInfo(clazz), name, desc,
+ count);
+ }
+
+ /**
+ * Appends INVOKEINTERFACE.
+ *
+ * @param classname the fully-qualified class name.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ * @param count the count operand of the instruction.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokeinterface(String classname, String name,
+ String desc, int count) {
+ addInvokeinterface(constPool.addClassInfo(classname), name, desc,
+ count);
+ }
+
+ /**
+ * Appends INVOKEINTERFACE.
+ *
+ * @param clazz the index of <code>CONSTANT_Class_info</code>
+ * structure.
+ * @param name the method name
+ * @param desc the descriptor of the method signature.
+ * @param count the count operand of the instruction.
+ *
+ * @see Descriptor#ofMethod(CtClass,CtClass[])
+ */
+ public void addInvokeinterface(int clazz, String name,
+ String desc, int count) {
+ add(INVOKEINTERFACE);
+ addIndex(constPool.addInterfaceMethodrefInfo(clazz, name, desc));
+ add(count);
+ add(0);
+ growStack(Descriptor.dataSize(desc) - 1);
+ }
+
+ /**
+ * Appends LDC or LDC_W. The pushed item is a <code>String</code>
+ * object.
+ *
+ * @param s the character string pushed by LDC or LDC_W.
+ */
+ public void addLdc(String s) {
+ addLdc(constPool.addStringInfo(s));
+ }
+
+ /**
+ * Appends LDC or LDC_W.
+ *
+ * @param i index into the constant pool.
+ */
+ public void addLdc(int i) {
+ if (i > 0xFF) {
+ addOpcode(LDC_W);
+ addIndex(i);
+ }
+ else {
+ addOpcode(LDC);
+ add(i);
+ }
+ }
+
+ /**
+ * Appends LDC2_W. The pushed item is a long value.
+ */
+ public void addLdc2w(long l) {
+ addOpcode(LDC2_W);
+ addIndex(constPool.addLongInfo(l));
+ }
+
+ /**
+ * Appends LDC2_W. The pushed item is a double value.
+ */
+ public void addLdc2w(double d) {
+ addOpcode(LDC2_W);
+ addIndex(constPool.addDoubleInfo(d));
+ }
+
+ /**
+ * Appends NEW.
+ *
+ * @param clazz the class of the created instance.
+ */
+ public void addNew(CtClass clazz) {
+ addOpcode(NEW);
+ addIndex(constPool.addClassInfo(clazz));
+ }
+
+ /**
+ * Appends NEW.
+ *
+ * @param classname the fully-qualified class name.
+ */
+ public void addNew(String classname) {
+ addOpcode(NEW);
+ addIndex(constPool.addClassInfo(classname));
+ }
+
+ /**
+ * Appends ANEWARRAY.
+ *
+ * @param classname the qualified class name of the element type.
+ */
+ public void addAnewarray(String classname) {
+ addOpcode(ANEWARRAY);
+ addIndex(constPool.addClassInfo(classname));
+ }
+
+ /**
+ * Appends ICONST and ANEWARRAY.
+ *
+ * @param clazz the elememnt type.
+ * @param length the array length.
+ */
+ public void addAnewarray(CtClass clazz, int length) {
+ addIconst(length);
+ addOpcode(ANEWARRAY);
+ addIndex(constPool.addClassInfo(clazz));
+ }
+
+ /**
+ * Appends NEWARRAY for primitive types.
+ *
+ * @param atype <code>T_BOOLEAN</code>, <code>T_CHAR</code>, ...
+ * @see Opcode
+ */
+ public void addNewarray(int atype, int length) {
+ addIconst(length);
+ addOpcode(NEWARRAY);
+ add(atype);
+ }
+
+ /**
+ * Appends MULTINEWARRAY.
+ *
+ * @param clazz the array type.
+ * @param dimensions the sizes of all dimensions.
+ * @return the length of <code>dimensions</code>.
+ */
+ public int addMultiNewarray(CtClass clazz, int[] dimensions) {
+ int len = dimensions.length;
+ for (int i = 0; i < len; ++i)
+ addIconst(dimensions[i]);
+
+ growStack(len);
+ return addMultiNewarray(clazz, len);
+ }
+
+ /**
+ * Appends MULTINEWARRAY. The size of every dimension must have been
+ * already pushed on the stack.
+ *
+ * @param clazz the array type.
+ * @param dim the number of the dimensions.
+ * @return the value of <code>dim</code>.
+ */
+ public int addMultiNewarray(CtClass clazz, int dim) {
+ add(MULTIANEWARRAY);
+ addIndex(constPool.addClassInfo(clazz));
+ add(dim);
+ growStack(1 - dim);
+ return dim;
+ }
+
+ /**
+ * Appends MULTINEWARRAY.
+ *
+ * @param desc the type descriptor of the created array.
+ * @param dim dimensions.
+ * @return the value of <code>dim</code>.
+ */
+ public int addMultiNewarray(String desc, int dim) {
+ add(MULTIANEWARRAY);
+ addIndex(constPool.addClassInfo(desc));
+ add(dim);
+ growStack(1 - dim);
+ return dim;
+ }
+
+ /**
+ * Appends PUTFIELD.
+ *
+ * @param c the target class.
+ * @param name the field name.
+ * @param desc the descriptor of the field type.
+ */
+ public void addPutfield(CtClass c, String name, String desc) {
+ addPutfield0(c, null, name, desc);
+ }
+
+ /**
+ * Appends PUTFIELD.
+ *
+ * @param classname the fully-qualified name of the target class.
+ * @param name the field name.
+ * @param desc the descriptor of the field type.
+ */
+ public void addPutfield(String classname, String name, String desc) {
+ // if classnaem is null, the target class is THIS.
+ addPutfield0(null, classname, name, desc);
+ }
+
+ private void addPutfield0(CtClass target, String classname,
+ String name, String desc) {
+ add(PUTFIELD);
+ // target is null if it represents THIS.
+ int ci = classname == null ? constPool.addClassInfo(target)
+ : constPool.addClassInfo(classname);
+ addIndex(constPool.addFieldrefInfo(ci, name, desc));
+ growStack(-1 - Descriptor.dataSize(desc));
+ }
+
+ /**
+ * Appends PUTSTATIC.
+ *
+ * @param c the target class.
+ * @param name the field name.
+ * @param desc the descriptor of the field type.
+ */
+ public void addPutstatic(CtClass c, String name, String desc) {
+ addPutstatic0(c, null, name, desc);
+ }
+
+ /**
+ * Appends PUTSTATIC.
+ *
+ * @param classname the fully-qualified name of the target class.
+ * @param fieldName the field name.
+ * @param desc the descriptor of the field type.
+ */
+ public void addPutstatic(String classname, String fieldName, String desc) {
+ // if classname is null, the target class is THIS.
+ addPutstatic0(null, classname, fieldName, desc);
+ }
+
+ private void addPutstatic0(CtClass target, String classname,
+ String fieldName, String desc) {
+ add(PUTSTATIC);
+ // target is null if it represents THIS.
+ int ci = classname == null ? constPool.addClassInfo(target)
+ : constPool.addClassInfo(classname);
+ addIndex(constPool.addFieldrefInfo(ci, fieldName, desc));
+ growStack(-Descriptor.dataSize(desc));
+ }
+
+ /**
+ * Appends ARETURN, IRETURN, .., or RETURN.
+ *
+ * @param type the return type.
+ */
+ public void addReturn(CtClass type) {
+ if (type == null)
+ addOpcode(RETURN);
+ else if (type.isPrimitive()) {
+ CtPrimitiveType ptype = (CtPrimitiveType)type;
+ addOpcode(ptype.getReturnOp());
+ }
+ else
+ addOpcode(ARETURN);
+ }
+
+ /**
+ * Appends RET.
+ *
+ * @param var local variable
+ */
+ public void addRet(int var) {
+ if (var < 0x100) {
+ addOpcode(RET);
+ add(var);
+ }
+ else {
+ addOpcode(WIDE);
+ addOpcode(RET);
+ addIndex(var);
+ }
+ }
+
+ /**
+ * Appends instructions for executing
+ * <code>java.lang.System.println(<i>message</i>)</code>.
+ *
+ * @param message printed message.
+ */
+ public void addPrintln(String message) {
+ addGetstatic("java.lang.System", "err", "Ljava/io/PrintStream;");
+ addLdc(message);
+ addInvokevirtual("java.io.PrintStream",
+ "println", "(Ljava/lang/String;)V");
+ }
+}
diff --git a/src/main/javassist/bytecode/ClassFile.java b/src/main/javassist/bytecode/ClassFile.java
new file mode 100644
index 0000000..d07d108
--- /dev/null
+++ b/src/main/javassist/bytecode/ClassFile.java
@@ -0,0 +1,889 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import javassist.CannotCompileException;
+
+/**
+ * <code>ClassFile</code> represents a Java <code>.class</code> file, which
+ * consists of a constant pool, methods, fields, and attributes.
+ *
+ * @see javassist.CtClass#getClassFile()
+ */
+public final class ClassFile {
+ int major, minor; // version number
+ ConstPool constPool;
+ int thisClass;
+ int accessFlags;
+ int superClass;
+ int[] interfaces;
+ ArrayList fields;
+ ArrayList methods;
+ ArrayList attributes;
+ String thisclassname; // not JVM-internal name
+ String[] cachedInterfaces;
+ String cachedSuperclass;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.1.
+ */
+ public static final int JAVA_1 = 45;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.2.
+ */
+ public static final int JAVA_2 = 46;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.3.
+ */
+ public static final int JAVA_3 = 47;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.4.
+ */
+ public static final int JAVA_4 = 48;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.5.
+ */
+ public static final int JAVA_5 = 49;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.6.
+ */
+ public static final int JAVA_6 = 50;
+
+ /**
+ * The major version number of class files
+ * for JDK 1.7.
+ */
+ public static final int JAVA_7 = 51;
+
+ /**
+ * The major version number of class files created
+ * from scratch. The default value is 47 (JDK 1.3)
+ * or 49 (JDK 1.5) if the JVM supports <code>java.lang.StringBuilder</code>.
+ */
+ public static int MAJOR_VERSION = JAVA_3;
+
+ static {
+ try {
+ Class.forName("java.lang.StringBuilder");
+ MAJOR_VERSION = JAVA_5;
+ }
+ catch (Throwable t) {}
+ }
+
+ /**
+ * Constructs a class file from a byte stream.
+ */
+ public ClassFile(DataInputStream in) throws IOException {
+ read(in);
+ }
+
+ /**
+ * Constructs a class file including no members.
+ *
+ * @param isInterface
+ * true if this is an interface. false if this is a class.
+ * @param classname
+ * a fully-qualified class name
+ * @param superclass
+ * a fully-qualified super class name
+ */
+ public ClassFile(boolean isInterface, String classname, String superclass) {
+ major = MAJOR_VERSION;
+ minor = 0; // JDK 1.3 or later
+ constPool = new ConstPool(classname);
+ thisClass = constPool.getThisClassInfo();
+ if (isInterface)
+ accessFlags = AccessFlag.INTERFACE | AccessFlag.ABSTRACT;
+ else
+ accessFlags = AccessFlag.SUPER;
+
+ initSuperclass(superclass);
+ interfaces = null;
+ fields = new ArrayList();
+ methods = new ArrayList();
+ thisclassname = classname;
+
+ attributes = new ArrayList();
+ attributes.add(new SourceFileAttribute(constPool,
+ getSourcefileName(thisclassname)));
+ }
+
+ private void initSuperclass(String superclass) {
+ if (superclass != null) {
+ this.superClass = constPool.addClassInfo(superclass);
+ cachedSuperclass = superclass;
+ }
+ else {
+ this.superClass = constPool.addClassInfo("java.lang.Object");
+ cachedSuperclass = "java.lang.Object";
+ }
+ }
+
+ private static String getSourcefileName(String qname) {
+ int index = qname.lastIndexOf('.');
+ if (index >= 0)
+ qname = qname.substring(index + 1);
+
+ return qname + ".java";
+ }
+
+ /**
+ * Eliminates dead constant pool items. If a method or a field is removed,
+ * the constant pool items used by that method/field become dead items. This
+ * method recreates a constant pool.
+ */
+ public void compact() {
+ ConstPool cp = compact0();
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ minfo.compact(cp);
+ }
+
+ list = fields;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ finfo.compact(cp);
+ }
+
+ attributes = AttributeInfo.copyAll(attributes, cp);
+ constPool = cp;
+ }
+
+ private ConstPool compact0() {
+ ConstPool cp = new ConstPool(thisclassname);
+ thisClass = cp.getThisClassInfo();
+ String sc = getSuperclass();
+ if (sc != null)
+ superClass = cp.addClassInfo(getSuperclass());
+
+ if (interfaces != null) {
+ int n = interfaces.length;
+ for (int i = 0; i < n; ++i)
+ interfaces[i]
+ = cp.addClassInfo(constPool.getClassInfo(interfaces[i]));
+ }
+
+ return cp;
+ }
+
+ /**
+ * Discards all attributes, associated with both the class file and the
+ * members such as a code attribute and exceptions attribute. The unused
+ * constant pool entries are also discarded (a new packed constant pool is
+ * constructed).
+ */
+ public void prune() {
+ ConstPool cp = compact0();
+ ArrayList newAttributes = new ArrayList();
+ AttributeInfo invisibleAnnotations
+ = getAttribute(AnnotationsAttribute.invisibleTag);
+ if (invisibleAnnotations != null) {
+ invisibleAnnotations = invisibleAnnotations.copy(cp, null);
+ newAttributes.add(invisibleAnnotations);
+ }
+
+ AttributeInfo visibleAnnotations
+ = getAttribute(AnnotationsAttribute.visibleTag);
+ if (visibleAnnotations != null) {
+ visibleAnnotations = visibleAnnotations.copy(cp, null);
+ newAttributes.add(visibleAnnotations);
+ }
+
+ AttributeInfo signature
+ = getAttribute(SignatureAttribute.tag);
+ if (signature != null) {
+ signature = signature.copy(cp, null);
+ newAttributes.add(signature);
+ }
+
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ minfo.prune(cp);
+ }
+
+ list = fields;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ finfo.prune(cp);
+ }
+
+ attributes = newAttributes;
+ constPool = cp;
+ }
+
+ /**
+ * Returns a constant pool table.
+ */
+ public ConstPool getConstPool() {
+ return constPool;
+ }
+
+ /**
+ * Returns true if this is an interface.
+ */
+ public boolean isInterface() {
+ return (accessFlags & AccessFlag.INTERFACE) != 0;
+ }
+
+ /**
+ * Returns true if this is a final class or interface.
+ */
+ public boolean isFinal() {
+ return (accessFlags & AccessFlag.FINAL) != 0;
+ }
+
+ /**
+ * Returns true if this is an abstract class or an interface.
+ */
+ public boolean isAbstract() {
+ return (accessFlags & AccessFlag.ABSTRACT) != 0;
+ }
+
+ /**
+ * Returns access flags.
+ *
+ * @see javassist.bytecode.AccessFlag
+ */
+ public int getAccessFlags() {
+ return accessFlags;
+ }
+
+ /**
+ * Changes access flags.
+ *
+ * @see javassist.bytecode.AccessFlag
+ */
+ public void setAccessFlags(int acc) {
+ if ((acc & AccessFlag.INTERFACE) == 0)
+ acc |= AccessFlag.SUPER;
+
+ accessFlags = acc;
+ }
+
+ /**
+ * Returns access and property flags of this nested class.
+ * This method returns -1 if the class is not a nested class.
+ *
+ * <p>The returned value is obtained from <code>inner_class_access_flags</code>
+ * of the entry representing this nested class itself
+ * in <code>InnerClasses_attribute</code>>.
+ */
+ public int getInnerAccessFlags() {
+ InnerClassesAttribute ica
+ = (InnerClassesAttribute)getAttribute(InnerClassesAttribute.tag);
+ if (ica == null)
+ return -1;
+
+ String name = getName();
+ int n = ica.tableLength();
+ for (int i = 0; i < n; ++i)
+ if (name.equals(ica.innerClass(i)))
+ return ica.accessFlags(i);
+
+ return -1;
+ }
+
+ /**
+ * Returns the class name.
+ */
+ public String getName() {
+ return thisclassname;
+ }
+
+ /**
+ * Sets the class name. This method substitutes the new name for all
+ * occurrences of the old class name in the class file.
+ */
+ public void setName(String name) {
+ renameClass(thisclassname, name);
+ }
+
+ /**
+ * Returns the super class name.
+ */
+ public String getSuperclass() {
+ if (cachedSuperclass == null)
+ cachedSuperclass = constPool.getClassInfo(superClass);
+
+ return cachedSuperclass;
+ }
+
+ /**
+ * Returns the index of the constant pool entry representing the super
+ * class.
+ */
+ public int getSuperclassId() {
+ return superClass;
+ }
+
+ /**
+ * Sets the super class.
+ *
+ * <p>
+ * The new super class should inherit from the old super class.
+ * This method modifies constructors so that they call constructors declared
+ * in the new super class.
+ */
+ public void setSuperclass(String superclass) throws CannotCompileException {
+ if (superclass == null)
+ superclass = "java.lang.Object";
+
+ try {
+ this.superClass = constPool.addClassInfo(superclass);
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ minfo.setSuperclass(superclass);
+ }
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ cachedSuperclass = superclass;
+ }
+
+ /**
+ * Replaces all occurrences of a class name in the class file.
+ *
+ * <p>
+ * If class X is substituted for class Y in the class file, X and Y must
+ * have the same signature. If Y provides a method m(), X must provide it
+ * even if X inherits m() from the super class. If this fact is not
+ * guaranteed, the bytecode verifier may cause an error.
+ *
+ * @param oldname
+ * the replaced class name
+ * @param newname
+ * the substituted class name
+ */
+ public final void renameClass(String oldname, String newname) {
+ ArrayList list;
+ int n;
+
+ if (oldname.equals(newname))
+ return;
+
+ if (oldname.equals(thisclassname))
+ thisclassname = newname;
+
+ oldname = Descriptor.toJvmName(oldname);
+ newname = Descriptor.toJvmName(newname);
+ constPool.renameClass(oldname, newname);
+
+ AttributeInfo.renameClass(attributes, oldname, newname);
+ list = methods;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ String desc = minfo.getDescriptor();
+ minfo.setDescriptor(Descriptor.rename(desc, oldname, newname));
+ AttributeInfo.renameClass(minfo.getAttributes(), oldname, newname);
+ }
+
+ list = fields;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ String desc = finfo.getDescriptor();
+ finfo.setDescriptor(Descriptor.rename(desc, oldname, newname));
+ AttributeInfo.renameClass(finfo.getAttributes(), oldname, newname);
+ }
+ }
+
+ /**
+ * Replaces all occurrences of several class names in the class file.
+ *
+ * @param classnames
+ * specifies which class name is replaced with which new name.
+ * Class names must be described with the JVM-internal
+ * representation like <code>java/lang/Object</code>.
+ * @see #renameClass(String,String)
+ */
+ public final void renameClass(Map classnames) {
+ String jvmNewThisName = (String)classnames.get(Descriptor
+ .toJvmName(thisclassname));
+ if (jvmNewThisName != null)
+ thisclassname = Descriptor.toJavaName(jvmNewThisName);
+
+ constPool.renameClass(classnames);
+
+ AttributeInfo.renameClass(attributes, classnames);
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ String desc = minfo.getDescriptor();
+ minfo.setDescriptor(Descriptor.rename(desc, classnames));
+ AttributeInfo.renameClass(minfo.getAttributes(), classnames);
+ }
+
+ list = fields;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ String desc = finfo.getDescriptor();
+ finfo.setDescriptor(Descriptor.rename(desc, classnames));
+ AttributeInfo.renameClass(finfo.getAttributes(), classnames);
+ }
+ }
+
+ /**
+ * Internal-use only.
+ * <code>CtClass.getRefClasses()</code> calls this method.
+ */
+ public final void getRefClasses(Map classnames) {
+ constPool.renameClass(classnames);
+
+ AttributeInfo.getRefClasses(attributes, classnames);
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ String desc = minfo.getDescriptor();
+ Descriptor.rename(desc, classnames);
+ AttributeInfo.getRefClasses(minfo.getAttributes(), classnames);
+ }
+
+ list = fields;
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ String desc = finfo.getDescriptor();
+ Descriptor.rename(desc, classnames);
+ AttributeInfo.getRefClasses(finfo.getAttributes(), classnames);
+ }
+ }
+
+ /**
+ * Returns the names of the interfaces implemented by the class.
+ * The returned array is read only.
+ */
+ public String[] getInterfaces() {
+ if (cachedInterfaces != null)
+ return cachedInterfaces;
+
+ String[] rtn = null;
+ if (interfaces == null)
+ rtn = new String[0];
+ else {
+ int n = interfaces.length;
+ String[] list = new String[n];
+ for (int i = 0; i < n; ++i)
+ list[i] = constPool.getClassInfo(interfaces[i]);
+
+ rtn = list;
+ }
+
+ cachedInterfaces = rtn;
+ return rtn;
+ }
+
+ /**
+ * Sets the interfaces.
+ *
+ * @param nameList
+ * the names of the interfaces.
+ */
+ public void setInterfaces(String[] nameList) {
+ cachedInterfaces = null;
+ if (nameList != null) {
+ int n = nameList.length;
+ interfaces = new int[n];
+ for (int i = 0; i < n; ++i)
+ interfaces[i] = constPool.addClassInfo(nameList[i]);
+ }
+ }
+
+ /**
+ * Appends an interface to the interfaces implemented by the class.
+ */
+ public void addInterface(String name) {
+ cachedInterfaces = null;
+ int info = constPool.addClassInfo(name);
+ if (interfaces == null) {
+ interfaces = new int[1];
+ interfaces[0] = info;
+ }
+ else {
+ int n = interfaces.length;
+ int[] newarray = new int[n + 1];
+ System.arraycopy(interfaces, 0, newarray, 0, n);
+ newarray[n] = info;
+ interfaces = newarray;
+ }
+ }
+
+ /**
+ * Returns all the fields declared in the class.
+ *
+ * @return a list of <code>FieldInfo</code>.
+ * @see FieldInfo
+ */
+ public List getFields() {
+ return fields;
+ }
+
+ /**
+ * Appends a field to the class.
+ *
+ * @throws DuplicateMemberException when the field is already included.
+ */
+ public void addField(FieldInfo finfo) throws DuplicateMemberException {
+ testExistingField(finfo.getName(), finfo.getDescriptor());
+ fields.add(finfo);
+ }
+
+ /**
+ * Just appends a field to the class.
+ * It does not check field duplication.
+ * Use this method only when minimizing performance overheads
+ * is seriously required.
+ *
+ * @since 3.13
+ */
+ public final void addField2(FieldInfo finfo) {
+ fields.add(finfo);
+ }
+
+ private void testExistingField(String name, String descriptor)
+ throws DuplicateMemberException {
+ ListIterator it = fields.listIterator(0);
+ while (it.hasNext()) {
+ FieldInfo minfo = (FieldInfo)it.next();
+ if (minfo.getName().equals(name))
+ throw new DuplicateMemberException("duplicate field: " + name);
+ }
+ }
+
+ /**
+ * Returns all the methods declared in the class.
+ *
+ * @return a list of <code>MethodInfo</code>.
+ * @see MethodInfo
+ */
+ public List getMethods() {
+ return methods;
+ }
+
+ /**
+ * Returns the method with the specified name. If there are multiple methods
+ * with that name, this method returns one of them.
+ *
+ * @return null if no such method is found.
+ */
+ public MethodInfo getMethod(String name) {
+ ArrayList list = methods;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ if (minfo.getName().equals(name))
+ return minfo;
+ }
+
+ return null;
+ }
+
+ /**
+ * Returns a static initializer (class initializer), or null if it does not
+ * exist.
+ */
+ public MethodInfo getStaticInitializer() {
+ return getMethod(MethodInfo.nameClinit);
+ }
+
+ /**
+ * Appends a method to the class.
+ * If there is a bridge method with the same name and signature,
+ * then the bridge method is removed before a new method is added.
+ *
+ * @throws DuplicateMemberException when the method is already included.
+ */
+ public void addMethod(MethodInfo minfo) throws DuplicateMemberException {
+ testExistingMethod(minfo);
+ methods.add(minfo);
+ }
+
+ /**
+ * Just appends a method to the class.
+ * It does not check method duplication or remove a bridge method.
+ * Use this method only when minimizing performance overheads
+ * is seriously required.
+ *
+ * @since 3.13
+ */
+ public final void addMethod2(MethodInfo minfo) {
+ methods.add(minfo);
+ }
+
+ private void testExistingMethod(MethodInfo newMinfo)
+ throws DuplicateMemberException
+ {
+ String name = newMinfo.getName();
+ String descriptor = newMinfo.getDescriptor();
+ ListIterator it = methods.listIterator(0);
+ while (it.hasNext())
+ if (isDuplicated(newMinfo, name, descriptor, (MethodInfo)it.next(), it))
+ throw new DuplicateMemberException("duplicate method: " + name
+ + " in " + this.getName());
+ }
+
+ private static boolean isDuplicated(MethodInfo newMethod, String newName,
+ String newDesc, MethodInfo minfo,
+ ListIterator it)
+ {
+ if (!minfo.getName().equals(newName))
+ return false;
+
+ String desc = minfo.getDescriptor();
+ if (!Descriptor.eqParamTypes(desc, newDesc))
+ return false;
+
+ if (desc.equals(newDesc)) {
+ if (notBridgeMethod(minfo))
+ return true;
+ else {
+ it.remove();
+ return false;
+ }
+ }
+ else
+ return notBridgeMethod(minfo) && notBridgeMethod(newMethod);
+ }
+
+ /* For a bridge method, see Sec. 15.12.4.5 of JLS 3rd Ed.
+ */
+ private static boolean notBridgeMethod(MethodInfo minfo) {
+ return (minfo.getAccessFlags() & AccessFlag.BRIDGE) == 0;
+ }
+
+ /**
+ * Returns all the attributes. The returned <code>List</code> object
+ * is shared with this object. If you add a new attribute to the list,
+ * the attribute is also added to the classs file represented by this
+ * object. If you remove an attribute from the list, it is also removed
+ * from the class file.
+ *
+ * @return a list of <code>AttributeInfo</code> objects.
+ * @see AttributeInfo
+ */
+ public List getAttributes() {
+ return attributes;
+ }
+
+ /**
+ * Returns the attribute with the specified name. If there are multiple
+ * attributes with that name, this method returns either of them. It
+ * returns null if the specified attributed is not found.
+ *
+ * @param name attribute name
+ * @see #getAttributes()
+ */
+ public AttributeInfo getAttribute(String name) {
+ ArrayList list = attributes;
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ AttributeInfo ai = (AttributeInfo)list.get(i);
+ if (ai.getName().equals(name))
+ return ai;
+ }
+
+ return null;
+ }
+
+ /**
+ * Appends an attribute. If there is already an attribute with the same
+ * name, the new one substitutes for it.
+ *
+ * @see #getAttributes()
+ */
+ public void addAttribute(AttributeInfo info) {
+ AttributeInfo.remove(attributes, info.getName());
+ attributes.add(info);
+ }
+
+ /**
+ * Returns the source file containing this class.
+ *
+ * @return null if this information is not available.
+ */
+ public String getSourceFile() {
+ SourceFileAttribute sf
+ = (SourceFileAttribute)getAttribute(SourceFileAttribute.tag);
+ if (sf == null)
+ return null;
+ else
+ return sf.getFileName();
+ }
+
+ private void read(DataInputStream in) throws IOException {
+ int i, n;
+ int magic = in.readInt();
+ if (magic != 0xCAFEBABE)
+ throw new IOException("bad magic number: " + Integer.toHexString(magic));
+
+ minor = in.readUnsignedShort();
+ major = in.readUnsignedShort();
+ constPool = new ConstPool(in);
+ accessFlags = in.readUnsignedShort();
+ thisClass = in.readUnsignedShort();
+ constPool.setThisClassInfo(thisClass);
+ superClass = in.readUnsignedShort();
+ n = in.readUnsignedShort();
+ if (n == 0)
+ interfaces = null;
+ else {
+ interfaces = new int[n];
+ for (i = 0; i < n; ++i)
+ interfaces[i] = in.readUnsignedShort();
+ }
+
+ ConstPool cp = constPool;
+ n = in.readUnsignedShort();
+ fields = new ArrayList();
+ for (i = 0; i < n; ++i)
+ addField2(new FieldInfo(cp, in));
+
+ n = in.readUnsignedShort();
+ methods = new ArrayList();
+ for (i = 0; i < n; ++i)
+ addMethod2(new MethodInfo(cp, in));
+
+ attributes = new ArrayList();
+ n = in.readUnsignedShort();
+ for (i = 0; i < n; ++i)
+ addAttribute(AttributeInfo.read(cp, in));
+
+ thisclassname = constPool.getClassInfo(thisClass);
+ }
+
+ /**
+ * Writes a class file represened by this object into an output stream.
+ */
+ public void write(DataOutputStream out) throws IOException {
+ int i, n;
+
+ out.writeInt(0xCAFEBABE); // magic
+ out.writeShort(minor); // minor version
+ out.writeShort(major); // major version
+ constPool.write(out); // constant pool
+ out.writeShort(accessFlags);
+ out.writeShort(thisClass);
+ out.writeShort(superClass);
+
+ if (interfaces == null)
+ n = 0;
+ else
+ n = interfaces.length;
+
+ out.writeShort(n);
+ for (i = 0; i < n; ++i)
+ out.writeShort(interfaces[i]);
+
+ ArrayList list = fields;
+ n = list.size();
+ out.writeShort(n);
+ for (i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ finfo.write(out);
+ }
+
+ list = methods;
+ n = list.size();
+ out.writeShort(n);
+ for (i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ minfo.write(out);
+ }
+
+ out.writeShort(attributes.size());
+ AttributeInfo.writeAll(attributes, out);
+ }
+
+ /**
+ * Get the Major version.
+ *
+ * @return the major version
+ */
+ public int getMajorVersion() {
+ return major;
+ }
+
+ /**
+ * Set the major version.
+ *
+ * @param major
+ * the major version
+ */
+ public void setMajorVersion(int major) {
+ this.major = major;
+ }
+
+ /**
+ * Get the minor version.
+ *
+ * @return the minor version
+ */
+ public int getMinorVersion() {
+ return minor;
+ }
+
+ /**
+ * Set the minor version.
+ *
+ * @param minor
+ * the minor version
+ */
+ public void setMinorVersion(int minor) {
+ this.minor = minor;
+ }
+
+ /**
+ * Sets the major and minor version to Java 5.
+ *
+ * If the major version is older than 49, Java 5
+ * extensions such as annotations are ignored
+ * by the JVM.
+ */
+ public void setVersionToJava5() {
+ this.major = 49;
+ this.minor = 0;
+ }
+}
diff --git a/src/main/javassist/bytecode/ClassFilePrinter.java b/src/main/javassist/bytecode/ClassFilePrinter.java
new file mode 100644
index 0000000..08078dc
--- /dev/null
+++ b/src/main/javassist/bytecode/ClassFilePrinter.java
@@ -0,0 +1,152 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.PrintWriter;
+import javassist.Modifier;
+import java.util.List;
+
+/**
+ * A utility class for priting the contents of a class file.
+ * It prints a constant pool table, fields, and methods in a
+ * human readable representation.
+ */
+public class ClassFilePrinter {
+ /**
+ * Prints the contents of a class file to the standard output stream.
+ */
+ public static void print(ClassFile cf) {
+ print(cf, new PrintWriter(System.out, true));
+ }
+
+ /**
+ * Prints the contents of a class file.
+ */
+ public static void print(ClassFile cf, PrintWriter out) {
+ List list;
+ int n;
+
+ /* 0x0020 (SYNCHRONIZED) means ACC_SUPER if the modifiers
+ * are of a class.
+ */
+ int mod
+ = AccessFlag.toModifier(cf.getAccessFlags()
+ & ~AccessFlag.SYNCHRONIZED);
+ out.println("major: " + cf.major + ", minor: " + cf.minor
+ + " modifiers: " + Integer.toHexString(cf.getAccessFlags()));
+ out.println(Modifier.toString(mod) + " class "
+ + cf.getName() + " extends " + cf.getSuperclass());
+
+ String[] infs = cf.getInterfaces();
+ if (infs != null && infs.length > 0) {
+ out.print(" implements ");
+ out.print(infs[0]);
+ for (int i = 1; i < infs.length; ++i)
+ out.print(", " + infs[i]);
+
+ out.println();
+ }
+
+ out.println();
+ list = cf.getFields();
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ FieldInfo finfo = (FieldInfo)list.get(i);
+ int acc = finfo.getAccessFlags();
+ out.println(Modifier.toString(AccessFlag.toModifier(acc))
+ + " " + finfo.getName() + "\t"
+ + finfo.getDescriptor());
+ printAttributes(finfo.getAttributes(), out, 'f');
+ }
+
+ out.println();
+ list = cf.getMethods();
+ n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ int acc = minfo.getAccessFlags();
+ out.println(Modifier.toString(AccessFlag.toModifier(acc))
+ + " " + minfo.getName() + "\t"
+ + minfo.getDescriptor());
+ printAttributes(minfo.getAttributes(), out, 'm');
+ out.println();
+ }
+
+ out.println();
+ printAttributes(cf.getAttributes(), out, 'c');
+ }
+
+ static void printAttributes(List list, PrintWriter out, char kind) {
+ if (list == null)
+ return;
+
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ AttributeInfo ai = (AttributeInfo)list.get(i);
+ if (ai instanceof CodeAttribute) {
+ CodeAttribute ca = (CodeAttribute)ai;
+ out.println("attribute: " + ai.getName() + ": "
+ + ai.getClass().getName());
+ out.println("max stack " + ca.getMaxStack()
+ + ", max locals " + ca.getMaxLocals()
+ + ", " + ca.getExceptionTable().size()
+ + " catch blocks");
+ out.println("<code attribute begin>");
+ printAttributes(ca.getAttributes(), out, kind);
+ out.println("<code attribute end>");
+ }
+ else if (ai instanceof AnnotationsAttribute) {
+ out.println("annnotation: " + ai.toString());
+ }
+ else if (ai instanceof ParameterAnnotationsAttribute) {
+ out.println("parameter annnotations: " + ai.toString());
+ }
+ else if (ai instanceof StackMapTable) {
+ out.println("<stack map table begin>");
+ StackMapTable.Printer.print((StackMapTable)ai, out);
+ out.println("<stack map table end>");
+ }
+ else if (ai instanceof StackMap) {
+ out.println("<stack map begin>");
+ ((StackMap)ai).print(out);
+ out.println("<stack map end>");
+ }
+ else if (ai instanceof SignatureAttribute) {
+ SignatureAttribute sa = (SignatureAttribute)ai;
+ String sig = sa.getSignature();
+ out.println("signature: " + sig);
+ try {
+ String s;
+ if (kind == 'c')
+ s = SignatureAttribute.toClassSignature(sig).toString();
+ else if (kind == 'm')
+ s = SignatureAttribute.toMethodSignature(sig).toString();
+ else
+ s = SignatureAttribute.toFieldSignature(sig).toString();
+
+ out.println(" " + s);
+ }
+ catch (BadBytecode e) {
+ out.println(" syntax error");
+ }
+ }
+ else
+ out.println("attribute: " + ai.getName()
+ + " (" + ai.get().length + " byte): "
+ + ai.getClass().getName());
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/ClassFileWriter.java b/src/main/javassist/bytecode/ClassFileWriter.java
new file mode 100644
index 0000000..bb7342a
--- /dev/null
+++ b/src/main/javassist/bytecode/ClassFileWriter.java
@@ -0,0 +1,731 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.OutputStream;
+import java.io.DataOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+/**
+ * A quick class-file writer. This is useful when a generated
+ * class file is simple and the code generation should be fast.
+ *
+ * <p>Example:
+ *
+ * <blockquote><pre>
+ * ClassFileWriter cfw = new ClassFileWriter(ClassFile.JAVA_4, 0);
+ * ConstPoolWriter cpw = cfw.getConstPool();
+ *
+ * FieldWriter fw = cfw.getFieldWriter();
+ * fw.add(AccessFlag.PUBLIC, "value", "I", null);
+ * fw.add(AccessFlag.PUBLIC, "value2", "J", null);
+ *
+ * int thisClass = cpw.addClassInfo("sample/Test");
+ * int superClass = cpw.addClassInfo("java/lang/Object");
+ *
+ * MethodWriter mw = cfw.getMethodWriter();
+ *
+ * mw.begin(AccessFlag.PUBLIC, MethodInfo.nameInit, "()V", null, null);
+ * mw.add(Opcode.ALOAD_0);
+ * mw.add(Opcode.INVOKESPECIAL);
+ * int signature = cpw.addNameAndTypeInfo(MethodInfo.nameInit, "()V");
+ * mw.add16(cpw.addMethodrefInfo(superClass, signature));
+ * mw.add(Opcode.RETURN);
+ * mw.codeEnd(1, 1);
+ * mw.end(null, null);
+ *
+ * mw.begin(AccessFlag.PUBLIC, "one", "()I", null, null);
+ * mw.add(Opcode.ICONST_1);
+ * mw.add(Opcode.IRETURN);
+ * mw.codeEnd(1, 1);
+ * mw.end(null, null);
+ *
+ * byte[] classfile = cfw.end(AccessFlag.PUBLIC, thisClass, superClass,
+ * null, null);
+ * </pre></blockquote>
+ *
+ * <p>The code above generates the following class:
+ *
+ * <blockquote><pre>
+ * package sample;
+ * public class Test {
+ * public int value;
+ * public long value2;
+ * public Test() { super(); }
+ * public one() { return 1; }
+ * }
+ * </pre></blockquote>
+ *
+ * @since 3.13
+ */
+public class ClassFileWriter {
+ private ByteStream output;
+ private ConstPoolWriter constPool;
+ private FieldWriter fields;
+ private MethodWriter methods;
+ int thisClass, superClass;
+
+ /**
+ * Constructs a class file writer.
+ *
+ * @param major the major version ({@link ClassFile#JAVA_4}, {@link ClassFile#JAVA_5}, ...).
+ * @param minor the minor version (0 for JDK 1.3 and later).
+ */
+ public ClassFileWriter(int major, int minor) {
+ output = new ByteStream(512);
+ output.writeInt(0xCAFEBABE); // magic
+ output.writeShort(minor);
+ output.writeShort(major);
+ constPool = new ConstPoolWriter(output);
+ fields = new FieldWriter(constPool);
+ methods = new MethodWriter(constPool);
+
+ }
+
+ /**
+ * Returns a constant pool.
+ */
+ public ConstPoolWriter getConstPool() { return constPool; }
+
+ /**
+ * Returns a filed writer.
+ */
+ public FieldWriter getFieldWriter() { return fields; }
+
+ /**
+ * Returns a method writer.
+ */
+ public MethodWriter getMethodWriter() { return methods; }
+
+ /**
+ * Ends writing and returns the contents of the class file.
+ *
+ * @param accessFlags access flags.
+ * @param thisClass this class. an index indicating its <code>CONSTANT_Class_info</code>.
+ * @param superClass super class. an index indicating its <code>CONSTANT_Class_info</code>.
+ * @param interfaces implemented interfaces.
+ * index numbers indicating their <code>ClassInfo</code>.
+ * It may be null.
+ * @param aw attributes of the class file. May be null.
+ *
+ * @see AccessFlag
+ */
+ public byte[] end(int accessFlags, int thisClass, int superClass,
+ int[] interfaces, AttributeWriter aw) {
+ constPool.end();
+ output.writeShort(accessFlags);
+ output.writeShort(thisClass);
+ output.writeShort(superClass);
+ if (interfaces == null)
+ output.writeShort(0);
+ else {
+ int n = interfaces.length;
+ output.writeShort(n);
+ for (int i = 0; i < n; i++)
+ output.writeShort(interfaces[i]);
+ }
+
+ output.enlarge(fields.dataSize() + methods.dataSize() + 6);
+ try {
+ output.writeShort(fields.size());
+ fields.write(output);
+
+ output.writeShort(methods.size());
+ methods.write(output);
+ }
+ catch (IOException e) {}
+
+ writeAttribute(output, aw, 0);
+ return output.toByteArray();
+ }
+
+ /**
+ * Ends writing and writes the contents of the class file into the
+ * given output stream.
+ *
+ * @param accessFlags access flags.
+ * @param thisClass this class. an index indicating its <code>CONSTANT_Class_info</code>.
+ * @param superClass super class. an index indicating its <code>CONSTANT_Class_info</code>.
+ * @param interfaces implemented interfaces.
+ * index numbers indicating their <code>CONSTATNT_Class_info</code>.
+ * It may be null.
+ * @param aw attributes of the class file. May be null.
+ *
+ * @see AccessFlag
+ */
+ public void end(DataOutputStream out,
+ int accessFlags, int thisClass, int superClass,
+ int[] interfaces, AttributeWriter aw)
+ throws IOException
+ {
+ constPool.end();
+ output.writeTo(out);
+ out.writeShort(accessFlags);
+ out.writeShort(thisClass);
+ out.writeShort(superClass);
+ if (interfaces == null)
+ out.writeShort(0);
+ else {
+ int n = interfaces.length;
+ out.writeShort(n);
+ for (int i = 0; i < n; i++)
+ out.writeShort(interfaces[i]);
+ }
+
+ out.writeShort(fields.size());
+ fields.write(out);
+
+ out.writeShort(methods.size());
+ methods.write(out);
+ if (aw == null)
+ out.writeShort(0);
+ else {
+ out.writeShort(aw.size());
+ aw.write(out);
+ }
+ }
+
+ /**
+ * This writes attributes.
+ *
+ * <p>For example, the following object writes a synthetic attribute:
+ *
+ * <pre>
+ * ConstPoolWriter cpw = ...;
+ * final int tag = cpw.addUtf8Info("Synthetic");
+ * AttributeWriter aw = new AttributeWriter() {
+ * public int size() {
+ * return 1;
+ * }
+ * public void write(DataOutputStream out) throws java.io.IOException {
+ * out.writeShort(tag);
+ * out.writeInt(0);
+ * }
+ * };
+ * </pre>
+ */
+ public static interface AttributeWriter {
+ /**
+ * Returns the number of attributes that this writer will
+ * write.
+ */
+ public int size();
+
+ /**
+ * Writes all the contents of the attributes. The binary representation
+ * of the contents is an array of <code>attribute_info</code>.
+ */
+ public void write(DataOutputStream out) throws IOException;
+ }
+
+ static void writeAttribute(ByteStream bs, AttributeWriter aw, int attrCount) {
+ if (aw == null) {
+ bs.writeShort(attrCount);
+ return;
+ }
+
+ bs.writeShort(aw.size() + attrCount);
+ DataOutputStream dos = new DataOutputStream(bs);
+ try {
+ aw.write(dos);
+ dos.flush();
+ }
+ catch (IOException e) {}
+ }
+
+ /**
+ * Field.
+ */
+ public static final class FieldWriter {
+ protected ByteStream output;
+ protected ConstPoolWriter constPool;
+ private int fieldCount;
+
+ FieldWriter(ConstPoolWriter cp) {
+ output = new ByteStream(128);
+ constPool = cp;
+ fieldCount = 0;
+ }
+
+ /**
+ * Adds a new field.
+ *
+ * @param accessFlags access flags.
+ * @param name the field name.
+ * @param descriptor the field type.
+ * @param aw the attributes of the field. may be null.
+ * @see AccessFlag
+ */
+ public void add(int accessFlags, String name, String descriptor, AttributeWriter aw) {
+ int nameIndex = constPool.addUtf8Info(name);
+ int descIndex = constPool.addUtf8Info(descriptor);
+ add(accessFlags, nameIndex, descIndex, aw);
+ }
+
+ /**
+ * Adds a new field.
+ *
+ * @param accessFlags access flags.
+ * @param name the field name. an index indicating its <code>CONSTANT_Utf8_info</code>.
+ * @param descriptor the field type. an index indicating its <code>CONSTANT_Utf8_info</code>.
+ * @param aw the attributes of the field. may be null.
+ * @see AccessFlag
+ */
+ public void add(int accessFlags, int name, int descriptor, AttributeWriter aw) {
+ ++fieldCount;
+ output.writeShort(accessFlags);
+ output.writeShort(name);
+ output.writeShort(descriptor);
+ writeAttribute(output, aw, 0);
+ }
+
+ int size() { return fieldCount; }
+
+ int dataSize() { return output.size(); }
+
+ /**
+ * Writes the added fields.
+ */
+ void write(OutputStream out) throws IOException {
+ output.writeTo(out);
+ }
+ }
+
+ /**
+ * Method.
+ */
+ public static final class MethodWriter {
+ protected ByteStream output;
+ protected ConstPoolWriter constPool;
+ private int methodCount;
+ protected int codeIndex;
+ protected int throwsIndex;
+ protected int stackIndex;
+
+ private int startPos;
+ private boolean isAbstract;
+ private int catchPos;
+ private int catchCount;
+
+ MethodWriter(ConstPoolWriter cp) {
+ output = new ByteStream(256);
+ constPool = cp;
+ methodCount = 0;
+ codeIndex = 0;
+ throwsIndex = 0;
+ stackIndex = 0;
+ }
+
+ /**
+ * Starts Adding a new method.
+ *
+ * @param accessFlags access flags.
+ * @param name the method name.
+ * @param descriptor the method signature.
+ * @param exceptions throws clause. It may be null.
+ * The class names must be the JVM-internal
+ * representations like <code>java/lang/Exception</code>.
+ * @param aw attributes to the <code>Method_info</code>.
+ */
+ public void begin(int accessFlags, String name, String descriptor,
+ String[] exceptions, AttributeWriter aw) {
+ int nameIndex = constPool.addUtf8Info(name);
+ int descIndex = constPool.addUtf8Info(descriptor);
+ int[] intfs;
+ if (exceptions == null)
+ intfs = null;
+ else
+ intfs = constPool.addClassInfo(exceptions);
+
+ begin(accessFlags, nameIndex, descIndex, intfs, aw);
+ }
+
+ /**
+ * Starts adding a new method.
+ *
+ * @param accessFlags access flags.
+ * @param name the method name. an index indicating its <code>CONSTANT_Utf8_info</code>.
+ * @param descriptor the field type. an index indicating its <code>CONSTANT_Utf8_info</code>.
+ * @param exceptions throws clause. indexes indicating <code>CONSTANT_Class_info</code>s.
+ * It may be null.
+ * @param aw attributes to the <code>Method_info</code>.
+ */
+ public void begin(int accessFlags, int name, int descriptor, int[] exceptions, AttributeWriter aw) {
+ ++methodCount;
+ output.writeShort(accessFlags);
+ output.writeShort(name);
+ output.writeShort(descriptor);
+ isAbstract = (accessFlags & AccessFlag.ABSTRACT) != 0;
+
+ int attrCount = isAbstract ? 0 : 1;
+ if (exceptions != null)
+ ++attrCount;
+
+ writeAttribute(output, aw, attrCount);
+
+ if (exceptions != null)
+ writeThrows(exceptions);
+
+ if (!isAbstract) {
+ if (codeIndex == 0)
+ codeIndex = constPool.addUtf8Info(CodeAttribute.tag);
+
+ startPos = output.getPos();
+ output.writeShort(codeIndex);
+ output.writeBlank(12); // attribute_length, maxStack, maxLocals, code_lenth
+ }
+
+ catchPos = -1;
+ catchCount = 0;
+ }
+
+ private void writeThrows(int[] exceptions) {
+ if (throwsIndex == 0)
+ throwsIndex = constPool.addUtf8Info(ExceptionsAttribute.tag);
+
+ output.writeShort(throwsIndex);
+ output.writeInt(exceptions.length * 2 + 2);
+ output.writeShort(exceptions.length);
+ for (int i = 0; i < exceptions.length; i++)
+ output.writeShort(exceptions[i]);
+ }
+
+ /**
+ * Appends an 8bit value of bytecode.
+ *
+ * @see Opcode
+ */
+ public void add(int b) {
+ output.write(b);
+ }
+
+ /**
+ * Appends a 16bit value of bytecode.
+ */
+ public void add16(int b) {
+ output.writeShort(b);
+ }
+
+ /**
+ * Appends a 32bit value of bytecode.
+ */
+ public void add32(int b) {
+ output.writeInt(b);
+ }
+
+ /**
+ * Appends a invokevirtual, inovkespecial, or invokestatic bytecode.
+ *
+ * @see Opcode
+ */
+ public void addInvoke(int opcode, String targetClass, String methodName,
+ String descriptor) {
+ int target = constPool.addClassInfo(targetClass);
+ int nt = constPool.addNameAndTypeInfo(methodName, descriptor);
+ int method = constPool.addMethodrefInfo(target, nt);
+ add(opcode);
+ add16(method);
+ }
+
+ /**
+ * Ends appending bytecode.
+ */
+ public void codeEnd(int maxStack, int maxLocals) {
+ if (!isAbstract) {
+ output.writeShort(startPos + 6, maxStack);
+ output.writeShort(startPos + 8, maxLocals);
+ output.writeInt(startPos + 10, output.getPos() - startPos - 14); // code_length
+ catchPos = output.getPos();
+ catchCount = 0;
+ output.writeShort(0); // number of catch clauses
+ }
+ }
+
+ /**
+ * Appends an <code>exception_table</code> entry to the
+ * <code>Code_attribute</code>. This method is available
+ * only after the <code>codeEnd</code> method is called.
+ *
+ * @param catchType an index indicating a <code>CONSTANT_Class_info</code>.
+ */
+ public void addCatch(int startPc, int endPc, int handlerPc, int catchType) {
+ ++catchCount;
+ output.writeShort(startPc);
+ output.writeShort(endPc);
+ output.writeShort(handlerPc);
+ output.writeShort(catchType);
+ }
+
+ /**
+ * Ends adding a new method. The <code>add</code> method must be
+ * called before the <code>end</code> method is called.
+ *
+ * @param smap a stack map table. may be null.
+ * @param aw attributes to the <code>Code_attribute</code>.
+ * may be null.
+ */
+ public void end(StackMapTable.Writer smap, AttributeWriter aw) {
+ if (isAbstract)
+ return;
+
+ // exception_table_length
+ output.writeShort(catchPos, catchCount);
+
+ int attrCount = smap == null ? 0 : 1;
+ writeAttribute(output, aw, attrCount);
+
+ if (smap != null) {
+ if (stackIndex == 0)
+ stackIndex = constPool.addUtf8Info(StackMapTable.tag);
+
+ output.writeShort(stackIndex);
+ byte[] data = smap.toByteArray();
+ output.writeInt(data.length);
+ output.write(data);
+ }
+
+ // Code attribute_length
+ output.writeInt(startPos + 2, output.getPos() - startPos - 6);
+ }
+
+ int size() { return methodCount; }
+
+ int dataSize() { return output.size(); }
+
+ /**
+ * Writes the added methods.
+ */
+ void write(OutputStream out) throws IOException {
+ output.writeTo(out);
+ }
+ }
+
+ /**
+ * Constant Pool.
+ */
+ public static final class ConstPoolWriter {
+ ByteStream output;
+ protected int startPos;
+ protected int num;
+
+ ConstPoolWriter(ByteStream out) {
+ output = out;
+ startPos = out.getPos();
+ num = 1;
+ output.writeShort(1); // number of entries
+ }
+
+ /**
+ * Makes <code>CONSTANT_Class_info</code> objects for each class name.
+ *
+ * @return an array of indexes indicating <code>CONSTANT_Class_info</code>s.
+ */
+ public int[] addClassInfo(String[] classNames) {
+ int n = classNames.length;
+ int[] result = new int[n];
+ for (int i = 0; i < n; i++)
+ result[i] = addClassInfo(classNames[i]);
+
+ return result;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Class_info</code> structure.
+ *
+ * <p>This also adds a <code>CONSTANT_Utf8_info</code> structure
+ * for storing the class name.
+ *
+ * @param jvmname the JVM-internal representation of a class name.
+ * e.g. <code>java/lang/Object</code>.
+ * @return the index of the added entry.
+ */
+ public int addClassInfo(String jvmname) {
+ int utf8 = addUtf8Info(jvmname);
+ output.write(ClassInfo.tag);
+ output.writeShort(utf8);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Class_info</code> structure.
+ *
+ * @param name <code>name_index</code>
+ * @return the index of the added entry.
+ */
+ public int addClassInfo(int name) {
+ output.write(ClassInfo.tag);
+ output.writeShort(name);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
+ *
+ * @param name <code>name_index</code>
+ * @param type <code>descriptor_index</code>
+ * @return the index of the added entry.
+ */
+ public int addNameAndTypeInfo(String name, String type) {
+ return addNameAndTypeInfo(addUtf8Info(name), addUtf8Info(type));
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
+ *
+ * @param name <code>name_index</code>
+ * @param type <code>descriptor_index</code>
+ * @return the index of the added entry.
+ */
+ public int addNameAndTypeInfo(int name, int type) {
+ output.write(NameAndTypeInfo.tag);
+ output.writeShort(name);
+ output.writeShort(type);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Fieldref_info</code> structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addFieldrefInfo(int classInfo, int nameAndTypeInfo) {
+ output.write(FieldrefInfo.tag);
+ output.writeShort(classInfo);
+ output.writeShort(nameAndTypeInfo);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Methodref_info</code> structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addMethodrefInfo(int classInfo, int nameAndTypeInfo) {
+ output.write(MethodrefInfo.tag);
+ output.writeShort(classInfo);
+ output.writeShort(nameAndTypeInfo);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_InterfaceMethodref_info</code>
+ * structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addInterfaceMethodrefInfo(int classInfo,
+ int nameAndTypeInfo) {
+ output.write(InterfaceMethodrefInfo.tag);
+ output.writeShort(classInfo);
+ output.writeShort(nameAndTypeInfo);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_String_info</code>
+ * structure.
+ *
+ * <p>This also adds a new <code>CONSTANT_Utf8_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addStringInfo(String str) {
+ int utf8 = addUtf8Info(str);
+ output.write(StringInfo.tag);
+ output.writeShort(utf8);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Integer_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addIntegerInfo(int i) {
+ output.write(IntegerInfo.tag);
+ output.writeInt(i);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Float_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addFloatInfo(float f) {
+ output.write(FloatInfo.tag);
+ output.writeFloat(f);
+ return num++;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Long_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addLongInfo(long l) {
+ output.write(LongInfo.tag);
+ output.writeLong(l);
+ int n = num;
+ num += 2;
+ return n;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Double_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addDoubleInfo(double d) {
+ output.write(DoubleInfo.tag);
+ output.writeDouble(d);
+ int n = num;
+ num += 2;
+ return n;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Utf8_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addUtf8Info(String utf8) {
+ output.write(Utf8Info.tag);
+ output.writeUTF(utf8);
+ return num++;
+ }
+
+ /**
+ * Writes the contents of this class pool.
+ */
+ void end() {
+ output.writeShort(startPos, num);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/CodeAnalyzer.java b/src/main/javassist/bytecode/CodeAnalyzer.java
new file mode 100644
index 0000000..a078e1f
--- /dev/null
+++ b/src/main/javassist/bytecode/CodeAnalyzer.java
@@ -0,0 +1,262 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * Utility for computing <code>max_stack</code>.
+ */
+class CodeAnalyzer implements Opcode {
+ private ConstPool constPool;
+ private CodeAttribute codeAttr;
+
+ public CodeAnalyzer(CodeAttribute ca) {
+ codeAttr = ca;
+ constPool = ca.getConstPool();
+ }
+
+ public int computeMaxStack()
+ throws BadBytecode
+ {
+ /* d = stack[i]
+ * d == 0: not visited
+ * d > 0: the depth is d - 1 after executing the bytecode at i.
+ * d < 0: not visited. the initial depth (before execution) is 1 - d.
+ */
+ CodeIterator ci = codeAttr.iterator();
+ int length = ci.getCodeLength();
+ int[] stack = new int[length];
+ constPool = codeAttr.getConstPool();
+ initStack(stack, codeAttr);
+ boolean repeat;
+ do {
+ repeat = false;
+ for (int i = 0; i < length; ++i)
+ if (stack[i] < 0) {
+ repeat = true;
+ visitBytecode(ci, stack, i);
+ }
+ } while (repeat);
+
+ int maxStack = 1;
+ for (int i = 0; i < length; ++i)
+ if (stack[i] > maxStack)
+ maxStack = stack[i];
+
+ return maxStack - 1; // the base is 1.
+ }
+
+ private void initStack(int[] stack, CodeAttribute ca) {
+ stack[0] = -1;
+ ExceptionTable et = ca.getExceptionTable();
+ if (et != null) {
+ int size = et.size();
+ for (int i = 0; i < size; ++i)
+ stack[et.handlerPc(i)] = -2; // an exception is on stack
+ }
+ }
+
+ private void visitBytecode(CodeIterator ci, int[] stack, int index)
+ throws BadBytecode
+ {
+ int codeLength = stack.length;
+ ci.move(index);
+ int stackDepth = -stack[index];
+ int[] jsrDepth = new int[1];
+ jsrDepth[0] = -1;
+ while (ci.hasNext()) {
+ index = ci.next();
+ stack[index] = stackDepth;
+ int op = ci.byteAt(index);
+ stackDepth = visitInst(op, ci, index, stackDepth);
+ if (stackDepth < 1)
+ throw new BadBytecode("stack underflow at " + index);
+
+ if (processBranch(op, ci, index, codeLength, stack, stackDepth, jsrDepth))
+ break;
+
+ if (isEnd(op)) // return, ireturn, athrow, ...
+ break;
+
+ if (op == JSR || op == JSR_W)
+ --stackDepth;
+ }
+ }
+
+ private boolean processBranch(int opcode, CodeIterator ci, int index,
+ int codeLength, int[] stack, int stackDepth, int[] jsrDepth)
+ throws BadBytecode
+ {
+ if ((IFEQ <= opcode && opcode <= IF_ACMPNE)
+ || opcode == IFNULL || opcode == IFNONNULL) {
+ int target = index + ci.s16bitAt(index + 1);
+ checkTarget(index, target, codeLength, stack, stackDepth);
+ }
+ else {
+ int target, index2;
+ switch (opcode) {
+ case GOTO :
+ target = index + ci.s16bitAt(index + 1);
+ checkTarget(index, target, codeLength, stack, stackDepth);
+ return true;
+ case GOTO_W :
+ target = index + ci.s32bitAt(index + 1);
+ checkTarget(index, target, codeLength, stack, stackDepth);
+ return true;
+ case JSR :
+ case JSR_W :
+ if (opcode == JSR)
+ target = index + ci.s16bitAt(index + 1);
+ else
+ target = index + ci.s32bitAt(index + 1);
+
+ checkTarget(index, target, codeLength, stack, stackDepth);
+ /*
+ * It is unknown which RET comes back to this JSR.
+ * So we assume that if the stack depth at one JSR instruction
+ * is N, then it is also N at other JSRs and N - 1 at all RET
+ * instructions. Note that STACK_GROW[JSR] is 1 since it pushes
+ * a return address on the operand stack.
+ */
+ if (jsrDepth[0] < 0) {
+ jsrDepth[0] = stackDepth;
+ return false;
+ }
+ else if (stackDepth == jsrDepth[0])
+ return false;
+ else
+ throw new BadBytecode(
+ "sorry, cannot compute this data flow due to JSR: "
+ + stackDepth + "," + jsrDepth[0]);
+ case RET :
+ if (jsrDepth[0] < 0) {
+ jsrDepth[0] = stackDepth + 1;
+ return false;
+ }
+ else if (stackDepth + 1 == jsrDepth[0])
+ return true;
+ else
+ throw new BadBytecode(
+ "sorry, cannot compute this data flow due to RET: "
+ + stackDepth + "," + jsrDepth[0]);
+ case LOOKUPSWITCH :
+ case TABLESWITCH :
+ index2 = (index & ~3) + 4;
+ target = index + ci.s32bitAt(index2);
+ checkTarget(index, target, codeLength, stack, stackDepth);
+ if (opcode == LOOKUPSWITCH) {
+ int npairs = ci.s32bitAt(index2 + 4);
+ index2 += 12;
+ for (int i = 0; i < npairs; ++i) {
+ target = index + ci.s32bitAt(index2);
+ checkTarget(index, target, codeLength,
+ stack, stackDepth);
+ index2 += 8;
+ }
+ }
+ else {
+ int low = ci.s32bitAt(index2 + 4);
+ int high = ci.s32bitAt(index2 + 8);
+ int n = high - low + 1;
+ index2 += 12;
+ for (int i = 0; i < n; ++i) {
+ target = index + ci.s32bitAt(index2);
+ checkTarget(index, target, codeLength,
+ stack, stackDepth);
+ index2 += 4;
+ }
+ }
+
+ return true; // always branch.
+ }
+ }
+
+ return false; // may not branch.
+ }
+
+ private void checkTarget(int opIndex, int target, int codeLength,
+ int[] stack, int stackDepth)
+ throws BadBytecode
+ {
+ if (target < 0 || codeLength <= target)
+ throw new BadBytecode("bad branch offset at " + opIndex);
+
+ int d = stack[target];
+ if (d == 0)
+ stack[target] = -stackDepth;
+ else if (d != stackDepth && d != -stackDepth)
+ throw new BadBytecode("verification error (" + stackDepth +
+ "," + d + ") at " + opIndex);
+ }
+
+ private static boolean isEnd(int opcode) {
+ return (IRETURN <= opcode && opcode <= RETURN) || opcode == ATHROW;
+ }
+
+ /**
+ * Visits an instruction.
+ */
+ private int visitInst(int op, CodeIterator ci, int index, int stack)
+ throws BadBytecode
+ {
+ String desc;
+ switch (op) {
+ case GETFIELD :
+ stack += getFieldSize(ci, index) - 1;
+ break;
+ case PUTFIELD :
+ stack -= getFieldSize(ci, index) + 1;
+ break;
+ case GETSTATIC :
+ stack += getFieldSize(ci, index);
+ break;
+ case PUTSTATIC :
+ stack -= getFieldSize(ci, index);
+ break;
+ case INVOKEVIRTUAL :
+ case INVOKESPECIAL :
+ desc = constPool.getMethodrefType(ci.u16bitAt(index + 1));
+ stack += Descriptor.dataSize(desc) - 1;
+ break;
+ case INVOKESTATIC :
+ desc = constPool.getMethodrefType(ci.u16bitAt(index + 1));
+ stack += Descriptor.dataSize(desc);
+ break;
+ case INVOKEINTERFACE :
+ desc = constPool.getInterfaceMethodrefType(
+ ci.u16bitAt(index + 1));
+ stack += Descriptor.dataSize(desc) - 1;
+ break;
+ case ATHROW :
+ stack = 1; // the stack becomes empty (1 means no values).
+ break;
+ case MULTIANEWARRAY :
+ stack += 1 - ci.byteAt(index + 3);
+ break;
+ case WIDE :
+ op = ci.byteAt(index + 1);
+ // don't break here.
+ default :
+ stack += STACK_GROW[op];
+ }
+
+ return stack;
+ }
+
+ private int getFieldSize(CodeIterator ci, int index) {
+ String desc = constPool.getFieldrefType(ci.u16bitAt(index + 1));
+ return Descriptor.dataSize(desc);
+ }
+}
diff --git a/src/main/javassist/bytecode/CodeAttribute.java b/src/main/javassist/bytecode/CodeAttribute.java
new file mode 100644
index 0000000..99dca1d
--- /dev/null
+++ b/src/main/javassist/bytecode/CodeAttribute.java
@@ -0,0 +1,585 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * <code>Code_attribute</code>.
+ *
+ * <p>To browse the <code>code</code> field of
+ * a <code>Code_attribute</code> structure,
+ * use <code>CodeIterator</code>.
+ *
+ * @see CodeIterator
+ */
+public class CodeAttribute extends AttributeInfo implements Opcode {
+ /**
+ * The name of this attribute <code>"Code"</code>.
+ */
+ public static final String tag = "Code";
+
+ // code[] is stored in AttributeInfo.info.
+
+ private int maxStack;
+ private int maxLocals;
+ private ExceptionTable exceptions;
+ private ArrayList attributes;
+
+ /**
+ * Constructs a <code>Code_attribute</code>.
+ *
+ * @param cp constant pool table
+ * @param stack <code>max_stack</code>
+ * @param locals <code>max_locals</code>
+ * @param code <code>code[]</code>
+ * @param etable <code>exception_table[]</code>
+ */
+ public CodeAttribute(ConstPool cp, int stack, int locals, byte[] code,
+ ExceptionTable etable)
+ {
+ super(cp, tag);
+ maxStack = stack;
+ maxLocals = locals;
+ info = code;
+ exceptions = etable;
+ attributes = new ArrayList();
+ }
+
+ /**
+ * Constructs a copy of <code>Code_attribute</code>.
+ * Specified class names are replaced during the copy.
+ *
+ * @param cp constant pool table.
+ * @param src source Code attribute.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ private CodeAttribute(ConstPool cp, CodeAttribute src, Map classnames)
+ throws BadBytecode
+ {
+ super(cp, tag);
+
+ maxStack = src.getMaxStack();
+ maxLocals = src.getMaxLocals();
+ exceptions = src.getExceptionTable().copy(cp, classnames);
+ attributes = new ArrayList();
+ List src_attr = src.getAttributes();
+ int num = src_attr.size();
+ for (int i = 0; i < num; ++i) {
+ AttributeInfo ai = (AttributeInfo)src_attr.get(i);
+ attributes.add(ai.copy(cp, classnames));
+ }
+
+ info = src.copyCode(cp, classnames, exceptions, this);
+ }
+
+ CodeAttribute(ConstPool cp, int name_id, DataInputStream in)
+ throws IOException
+ {
+ super(cp, name_id, (byte[])null);
+ int attr_len = in.readInt();
+
+ maxStack = in.readUnsignedShort();
+ maxLocals = in.readUnsignedShort();
+
+ int code_len = in.readInt();
+ info = new byte[code_len];
+ in.readFully(info);
+
+ exceptions = new ExceptionTable(cp, in);
+
+ attributes = new ArrayList();
+ int num = in.readUnsignedShort();
+ for (int i = 0; i < num; ++i)
+ attributes.add(AttributeInfo.read(cp, in));
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ * @exception RuntimeCopyException if a <code>BadBytecode</code>
+ * exception is thrown, it is
+ * converted into
+ * <code>RuntimeCopyException</code>.
+ *
+ * @return <code>CodeAttribute</code> object.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames)
+ throws RuntimeCopyException
+ {
+ try {
+ return new CodeAttribute(newCp, this, classnames);
+ }
+ catch (BadBytecode e) {
+ throw new RuntimeCopyException("bad bytecode. fatal?");
+ }
+ }
+
+ /**
+ * An exception that may be thrown by <code>copy()</code>
+ * in <code>CodeAttribute</code>.
+ */
+ public static class RuntimeCopyException extends RuntimeException {
+ /**
+ * Constructs an exception.
+ */
+ public RuntimeCopyException(String s) {
+ super(s);
+ }
+ }
+
+ /**
+ * Returns the length of this <code>attribute_info</code>
+ * structure.
+ * The returned value is <code>attribute_length + 6</code>.
+ */
+ public int length() {
+ return 18 + info.length + exceptions.size() * 8
+ + AttributeInfo.getLength(attributes);
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(name); // attribute_name_index
+ out.writeInt(length() - 6); // attribute_length
+ out.writeShort(maxStack); // max_stack
+ out.writeShort(maxLocals); // max_locals
+ out.writeInt(info.length); // code_length
+ out.write(info); // code
+ exceptions.write(out);
+ out.writeShort(attributes.size()); // attributes_count
+ AttributeInfo.writeAll(attributes, out); // attributes
+ }
+
+ /**
+ * This method is not available.
+ *
+ * @throws java.lang.UnsupportedOperationException always thrown.
+ */
+ public byte[] get() {
+ throw new UnsupportedOperationException("CodeAttribute.get()");
+ }
+
+ /**
+ * This method is not available.
+ *
+ * @throws java.lang.UnsupportedOperationException always thrown.
+ */
+ public void set(byte[] newinfo) {
+ throw new UnsupportedOperationException("CodeAttribute.set()");
+ }
+
+ void renameClass(String oldname, String newname) {
+ AttributeInfo.renameClass(attributes, oldname, newname);
+ }
+
+ void renameClass(Map classnames) {
+ AttributeInfo.renameClass(attributes, classnames);
+ }
+
+ void getRefClasses(Map classnames) {
+ AttributeInfo.getRefClasses(attributes, classnames);
+ }
+
+ /**
+ * Returns the name of the class declaring the method including
+ * this code attribute.
+ */
+ public String getDeclaringClass() {
+ ConstPool cp = getConstPool();
+ return cp.getClassName();
+ }
+
+ /**
+ * Returns <code>max_stack</code>.
+ */
+ public int getMaxStack() {
+ return maxStack;
+ }
+
+ /**
+ * Sets <code>max_stack</code>.
+ */
+ public void setMaxStack(int value) {
+ maxStack = value;
+ }
+
+ /**
+ * Computes the maximum stack size and sets <code>max_stack</code>
+ * to the computed size.
+ *
+ * @throws BadBytecode if this method fails in computing.
+ * @return the newly computed value of <code>max_stack</code>
+ */
+ public int computeMaxStack() throws BadBytecode {
+ maxStack = new CodeAnalyzer(this).computeMaxStack();
+ return maxStack;
+ }
+
+ /**
+ * Returns <code>max_locals</code>.
+ */
+ public int getMaxLocals() {
+ return maxLocals;
+ }
+
+ /**
+ * Sets <code>max_locals</code>.
+ */
+ public void setMaxLocals(int value) {
+ maxLocals = value;
+ }
+
+ /**
+ * Returns <code>code_length</code>.
+ */
+ public int getCodeLength() {
+ return info.length;
+ }
+
+ /**
+ * Returns <code>code[]</code>.
+ */
+ public byte[] getCode() {
+ return info;
+ }
+
+ /**
+ * Sets <code>code[]</code>.
+ */
+ void setCode(byte[] newinfo) { super.set(newinfo); }
+
+ /**
+ * Makes a new iterator for reading this code attribute.
+ */
+ public CodeIterator iterator() {
+ return new CodeIterator(this);
+ }
+
+ /**
+ * Returns <code>exception_table[]</code>.
+ */
+ public ExceptionTable getExceptionTable() { return exceptions; }
+
+ /**
+ * Returns <code>attributes[]</code>.
+ * It returns a list of <code>AttributeInfo</code>.
+ * A new element can be added to the returned list
+ * and an existing element can be removed from the list.
+ *
+ * @see AttributeInfo
+ */
+ public List getAttributes() { return attributes; }
+
+ /**
+ * Returns the attribute with the specified name.
+ * If it is not found, this method returns null.
+ *
+ * @param name attribute name
+ * @return an <code>AttributeInfo</code> object or null.
+ */
+ public AttributeInfo getAttribute(String name) {
+ return AttributeInfo.lookup(attributes, name);
+ }
+
+ /**
+ * Adds a stack map table. If another copy of stack map table
+ * is already contained, the old one is removed.
+ *
+ * @param smt the stack map table added to this code attribute.
+ * If it is null, a new stack map is not added.
+ * Only the old stack map is removed.
+ */
+ public void setAttribute(StackMapTable smt) {
+ AttributeInfo.remove(attributes, StackMapTable.tag);
+ if (smt != null)
+ attributes.add(smt);
+ }
+
+ /**
+ * Adds a stack map table for J2ME (CLDC). If another copy of stack map table
+ * is already contained, the old one is removed.
+ *
+ * @param sm the stack map table added to this code attribute.
+ * If it is null, a new stack map is not added.
+ * Only the old stack map is removed.
+ * @since 3.12
+ */
+ public void setAttribute(StackMap sm) {
+ AttributeInfo.remove(attributes, StackMap.tag);
+ if (sm != null)
+ attributes.add(sm);
+ }
+
+ /**
+ * Copies code.
+ */
+ private byte[] copyCode(ConstPool destCp, Map classnames,
+ ExceptionTable etable, CodeAttribute destCa)
+ throws BadBytecode
+ {
+ int len = getCodeLength();
+ byte[] newCode = new byte[len];
+ destCa.info = newCode;
+ LdcEntry ldc = copyCode(this.info, 0, len, this.getConstPool(),
+ newCode, destCp, classnames);
+ return LdcEntry.doit(newCode, ldc, etable, destCa);
+ }
+
+ private static LdcEntry copyCode(byte[] code, int beginPos, int endPos,
+ ConstPool srcCp, byte[] newcode,
+ ConstPool destCp, Map classnameMap)
+ throws BadBytecode
+ {
+ int i2, index;
+ LdcEntry ldcEntry = null;
+
+ for (int i = beginPos; i < endPos; i = i2) {
+ i2 = CodeIterator.nextOpcode(code, i);
+ byte c = code[i];
+ newcode[i] = c;
+ switch (c & 0xff) {
+ case LDC_W :
+ case LDC2_W :
+ case GETSTATIC :
+ case PUTSTATIC :
+ case GETFIELD :
+ case PUTFIELD :
+ case INVOKEVIRTUAL :
+ case INVOKESPECIAL :
+ case INVOKESTATIC :
+ case NEW :
+ case ANEWARRAY :
+ case CHECKCAST :
+ case INSTANCEOF :
+ copyConstPoolInfo(i + 1, code, srcCp, newcode, destCp,
+ classnameMap);
+ break;
+ case LDC :
+ index = code[i + 1] & 0xff;
+ index = srcCp.copy(index, destCp, classnameMap);
+ if (index < 0x100)
+ newcode[i + 1] = (byte)index;
+ else {
+ newcode[i] = NOP;
+ newcode[i + 1] = NOP;
+ LdcEntry ldc = new LdcEntry();
+ ldc.where = i;
+ ldc.index = index;
+ ldc.next = ldcEntry;
+ ldcEntry = ldc;
+ }
+ break;
+ case INVOKEINTERFACE :
+ copyConstPoolInfo(i + 1, code, srcCp, newcode, destCp,
+ classnameMap);
+ newcode[i + 3] = code[i + 3];
+ newcode[i + 4] = code[i + 4];
+ break;
+ case MULTIANEWARRAY :
+ copyConstPoolInfo(i + 1, code, srcCp, newcode, destCp,
+ classnameMap);
+ newcode[i + 3] = code[i + 3];
+ break;
+ default :
+ while (++i < i2)
+ newcode[i] = code[i];
+
+ break;
+ }
+ }
+
+ return ldcEntry;
+ }
+
+ private static void copyConstPoolInfo(int i, byte[] code, ConstPool srcCp,
+ byte[] newcode, ConstPool destCp,
+ Map classnameMap) {
+ int index = ((code[i] & 0xff) << 8) | (code[i + 1] & 0xff);
+ index = srcCp.copy(index, destCp, classnameMap);
+ newcode[i] = (byte)(index >> 8);
+ newcode[i + 1] = (byte)index;
+ }
+
+ static class LdcEntry {
+ LdcEntry next;
+ int where;
+ int index;
+
+ static byte[] doit(byte[] code, LdcEntry ldc, ExceptionTable etable,
+ CodeAttribute ca)
+ throws BadBytecode
+ {
+ if (ldc != null)
+ code = CodeIterator.changeLdcToLdcW(code, etable, ca, ldc);
+
+ /* The original code was the following:
+
+ while (ldc != null) {
+ int where = ldc.where;
+ code = CodeIterator.insertGapCore0(code, where, 1, false, etable, ca);
+ code[where] = (byte)Opcode.LDC_W;
+ ByteArray.write16bit(ldc.index, code, where + 1);
+ ldc = ldc.next;
+ }
+
+ But this code does not support a large method > 32KB.
+ */
+
+ return code;
+ }
+ }
+
+ /**
+ * Changes the index numbers of the local variables
+ * to append a new parameter.
+ * This method does not update <code>LocalVariableAttribute</code>,
+ * <code>StackMapTable</code>, or <code>StackMap</code>.
+ * These attributes must be explicitly updated.
+ *
+ * @param where the index of the new parameter.
+ * @param size the type size of the new parameter (1 or 2).
+ *
+ * @see LocalVariableAttribute#shiftIndex(int, int)
+ * @see StackMapTable#insertLocal(int, int, int)
+ * @see StackMap#insertLocal(int, int, int)
+ */
+ public void insertLocalVar(int where, int size) throws BadBytecode {
+ CodeIterator ci = iterator();
+ while (ci.hasNext())
+ shiftIndex(ci, where, size);
+
+ setMaxLocals(getMaxLocals() + size);
+ }
+
+ /**
+ * @param lessThan If the index of the local variable is
+ * less than this value, it does not change.
+ * Otherwise, the index is increased.
+ * @param delta the indexes of the local variables are
+ * increased by this value.
+ */
+ private static void shiftIndex(CodeIterator ci, int lessThan, int delta) throws BadBytecode {
+ int index = ci.next();
+ int opcode = ci.byteAt(index);
+ if (opcode < ILOAD)
+ return;
+ else if (opcode < IASTORE) {
+ if (opcode < ILOAD_0) {
+ // iload, lload, fload, dload, aload
+ shiftIndex8(ci, index, opcode, lessThan, delta);
+ }
+ else if (opcode < IALOAD) {
+ // iload_0, ..., aload_3
+ shiftIndex0(ci, index, opcode, lessThan, delta, ILOAD_0, ILOAD);
+ }
+ else if (opcode < ISTORE)
+ return;
+ else if (opcode < ISTORE_0) {
+ // istore, lstore, ...
+ shiftIndex8(ci, index, opcode, lessThan, delta);
+ }
+ else {
+ // istore_0, ..., astore_3
+ shiftIndex0(ci, index, opcode, lessThan, delta, ISTORE_0, ISTORE);
+ }
+ }
+ else if (opcode == IINC) {
+ int var = ci.byteAt(index + 1);
+ if (var < lessThan)
+ return;
+
+ var += delta;
+ if (var < 0x100)
+ ci.writeByte(var, index + 1);
+ else {
+ int plus = (byte)ci.byteAt(index + 2);
+ int pos = ci.insertExGap(3);
+ ci.writeByte(WIDE, pos - 3);
+ ci.writeByte(IINC, pos - 2);
+ ci.write16bit(var, pos - 1);
+ ci.write16bit(plus, pos + 1);
+ }
+ }
+ else if (opcode == RET)
+ shiftIndex8(ci, index, opcode, lessThan, delta);
+ else if (opcode == WIDE) {
+ int var = ci.u16bitAt(index + 2);
+ if (var < lessThan)
+ return;
+
+ var += delta;
+ ci.write16bit(var, index + 2);
+ }
+ }
+
+ private static void shiftIndex8(CodeIterator ci, int index, int opcode,
+ int lessThan, int delta)
+ throws BadBytecode
+ {
+ int var = ci.byteAt(index + 1);
+ if (var < lessThan)
+ return;
+
+ var += delta;
+ if (var < 0x100)
+ ci.writeByte(var, index + 1);
+ else {
+ int pos = ci.insertExGap(2);
+ ci.writeByte(WIDE, pos - 2);
+ ci.writeByte(opcode, pos - 1);
+ ci.write16bit(var, pos);
+ }
+ }
+
+ private static void shiftIndex0(CodeIterator ci, int index, int opcode,
+ int lessThan, int delta,
+ int opcode_i_0, int opcode_i)
+ throws BadBytecode
+ {
+ int var = (opcode - opcode_i_0) % 4;
+ if (var < lessThan)
+ return;
+
+ var += delta;
+ if (var < 4)
+ ci.writeByte(opcode + delta, index);
+ else {
+ opcode = (opcode - opcode_i_0) / 4 + opcode_i;
+ if (var < 0x100) {
+ int pos = ci.insertExGap(1);
+ ci.writeByte(opcode, pos - 1);
+ ci.writeByte(var, pos);
+ }
+ else {
+ int pos = ci.insertExGap(3);
+ ci.writeByte(WIDE, pos - 1);
+ ci.writeByte(opcode, pos);
+ ci.write16bit(var, pos + 1);
+ }
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/CodeIterator.java b/src/main/javassist/bytecode/CodeIterator.java
new file mode 100644
index 0000000..7781b70
--- /dev/null
+++ b/src/main/javassist/bytecode/CodeIterator.java
@@ -0,0 +1,1571 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.util.ArrayList;
+
+/**
+ * An iterator for editing a code attribute.
+ *
+ * <p>If there are multiple <code>CodeIterator</code>s referring to the
+ * same <code>Code_attribute</code>, then inserting a gap by one
+ * <code>CodeIterator</code> will break the other
+ * <code>CodeIterator</code>.
+ *
+ * <p>This iterator does not provide <code>remove()</code>.
+ * If a piece of code in a <code>Code_attribute</code> is unnecessary,
+ * it should be overwritten with <code>NOP</code>.
+ *
+ * @see CodeAttribute#iterator()
+ */
+public class CodeIterator implements Opcode {
+ protected CodeAttribute codeAttr;
+ protected byte[] bytecode;
+ protected int endPos;
+ protected int currentPos;
+ protected int mark;
+
+ protected CodeIterator(CodeAttribute ca) {
+ codeAttr = ca;
+ bytecode = ca.getCode();
+ begin();
+ }
+
+ /**
+ * Moves to the first instruction.
+ */
+ public void begin() {
+ currentPos = mark = 0;
+ endPos = getCodeLength();
+ }
+
+ /**
+ * Moves to the given index.
+ *
+ * <p>The index of the next instruction is set to the given index.
+ * The successive call to <code>next()</code>
+ * returns the index that has been given to <code>move()</code>.
+ *
+ * <p>Note that the index is into the byte array returned by
+ * <code>get().getCode()</code>.
+ *
+ * @see CodeAttribute#getCode()
+ */
+ public void move(int index) {
+ currentPos = index;
+ }
+
+ /**
+ * Sets a mark to the bytecode at the given index.
+ * The mark can be used to track the position of that bytecode
+ * when code blocks are inserted.
+ * If a code block is inclusively inserted at the position of the
+ * bytecode, the mark is set to the inserted code block.
+ *
+ * @see #getMark()
+ * @since 3.11
+ */
+ public void setMark(int index) {
+ mark = index;
+ }
+
+ /**
+ * Gets the index of the position of the mark set by
+ * <code>setMark</code>.
+ *
+ * @return the index of the position.
+ * @see #setMark(int)
+ * @since 3.11
+ */
+ public int getMark() { return mark; }
+
+ /**
+ * Returns a Code attribute read with this iterator.
+ */
+ public CodeAttribute get() {
+ return codeAttr;
+ }
+
+ /**
+ * Returns <code>code_length</code> of <code>Code_attribute</code>.
+ */
+ public int getCodeLength() {
+ return bytecode.length;
+ }
+
+ /**
+ * Returns the unsigned 8bit value at the given index.
+ */
+ public int byteAt(int index) { return bytecode[index] & 0xff; }
+
+ /**
+ * Writes an 8bit value at the given index.
+ */
+ public void writeByte(int value, int index) {
+ bytecode[index] = (byte)value;
+ }
+
+ /**
+ * Returns the unsigned 16bit value at the given index.
+ */
+ public int u16bitAt(int index) {
+ return ByteArray.readU16bit(bytecode, index);
+ }
+
+ /**
+ * Returns the signed 16bit value at the given index.
+ */
+ public int s16bitAt(int index) {
+ return ByteArray.readS16bit(bytecode, index);
+ }
+
+ /**
+ * Writes a 16 bit integer at the index.
+ */
+ public void write16bit(int value, int index) {
+ ByteArray.write16bit(value, bytecode, index);
+ }
+
+ /**
+ * Returns the signed 32bit value at the given index.
+ */
+ public int s32bitAt(int index) {
+ return ByteArray.read32bit(bytecode, index);
+ }
+
+ /**
+ * Writes a 32bit integer at the index.
+ */
+ public void write32bit(int value, int index) {
+ ByteArray.write32bit(value, bytecode, index);
+ }
+
+ /**
+ * Writes a byte array at the index.
+ *
+ * @param code may be a zero-length array.
+ */
+ public void write(byte[] code, int index) {
+ int len = code.length;
+ for (int j = 0; j < len; ++j)
+ bytecode[index++] = code[j];
+ }
+
+ /**
+ * Returns true if there is more instructions.
+ */
+ public boolean hasNext() { return currentPos < endPos; }
+
+ /**
+ * Returns the index of the next instruction
+ * (not the operand following the current opcode).
+ *
+ * <p>Note that the index is into the byte array returned by
+ * <code>get().getCode()</code>.
+ *
+ * @see CodeAttribute#getCode()
+ * @see CodeIterator#byteAt(int)
+ */
+ public int next() throws BadBytecode {
+ int pos = currentPos;
+ currentPos = nextOpcode(bytecode, pos);
+ return pos;
+ }
+
+ /**
+ * Obtains the value that the next call
+ * to <code>next()</code> will return.
+ *
+ * <p>This method is side-effects free.
+ * Successive calls to <code>lookAhead()</code> return the
+ * same value until <code>next()</code> is called.
+ */
+ public int lookAhead() {
+ return currentPos;
+ }
+
+ /**
+ * Moves to the instruction for
+ * either <code>super()</code> or <code>this()</code>.
+ *
+ * <p>This method skips all the instructions for computing arguments
+ * to <code>super()</code> or <code>this()</code>, which should be
+ * placed at the beginning of a constructor body.
+ *
+ * <p>This method returns the index of INVOKESPECIAL instruction
+ * executing <code>super()</code> or <code>this()</code>.
+ * A successive call to <code>next()</code> returns the
+ * index of the next instruction following that INVOKESPECIAL.
+ *
+ * <p>This method works only for a constructor.
+ *
+ * @return the index of the INVOKESPECIAL instruction, or -1
+ * if a constructor invocation is not found.
+ */
+ public int skipConstructor() throws BadBytecode {
+ return skipSuperConstructor0(-1);
+ }
+
+ /**
+ * Moves to the instruction for <code>super()</code>.
+ *
+ * <p>This method skips all the instructions for computing arguments to
+ * <code>super()</code>, which should be
+ * placed at the beginning of a constructor body.
+ *
+ * <p>This method returns the index of INVOKESPECIAL instruction
+ * executing <code>super()</code>.
+ * A successive call to <code>next()</code> returns the
+ * index of the next instruction following that INVOKESPECIAL.
+ *
+ * <p>This method works only for a constructor.
+ *
+ * @return the index of the INVOKESPECIAL instruction, or -1
+ * if a super constructor invocation is not found
+ * but <code>this()</code> is found.
+ */
+ public int skipSuperConstructor() throws BadBytecode {
+ return skipSuperConstructor0(0);
+ }
+
+ /**
+ * Moves to the instruction for <code>this()</code>.
+ *
+ * <p>This method skips all the instructions for computing arguments to
+ * <code>this()</code>, which should be
+ * placed at the beginning of a constructor body.
+ *
+ * <p>This method returns the index of INVOKESPECIAL instruction
+ * executing <code>this()</code>.
+ * A successive call to <code>next()</code> returns the
+ * index of the next instruction following that INVOKESPECIAL.
+ *
+ * <p>This method works only for a constructor.
+ *
+ * @return the index of the INVOKESPECIAL instruction, or -1
+ * if a explicit constructor invocation is not found
+ * but <code>super()</code> is found.
+ */
+ public int skipThisConstructor() throws BadBytecode {
+ return skipSuperConstructor0(1);
+ }
+
+ /* skipSuper 1: this(), 0: super(), -1: both.
+ */
+ private int skipSuperConstructor0(int skipThis) throws BadBytecode {
+ begin();
+ ConstPool cp = codeAttr.getConstPool();
+ String thisClassName = codeAttr.getDeclaringClass();
+ int nested = 0;
+ while (hasNext()) {
+ int index = next();
+ int c = byteAt(index);
+ if (c == NEW)
+ ++nested;
+ else if (c == INVOKESPECIAL) {
+ int mref = ByteArray.readU16bit(bytecode, index + 1);
+ if (cp.getMethodrefName(mref).equals(MethodInfo.nameInit))
+ if (--nested < 0) {
+ if (skipThis < 0)
+ return index;
+
+ String cname = cp.getMethodrefClassName(mref);
+ if (cname.equals(thisClassName) == (skipThis > 0))
+ return index;
+ else
+ break;
+ }
+ }
+ }
+
+ begin();
+ return -1;
+ }
+
+ /**
+ * Inserts the given bytecode sequence
+ * before the next instruction that would be returned by
+ * <code>next()</code> (not before the instruction returned
+ * by the last call to <code>next()</code>).
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the next instruction is at the beginning of a block statement,
+ * then the bytecode is inserted within that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * @param code inserted bytecode sequence.
+ * @return the index indicating the first byte of the
+ * inserted byte sequence.
+ */
+ public int insert(byte[] code)
+ throws BadBytecode
+ {
+ return insert0(currentPos, code, false);
+ }
+
+ /**
+ * Inserts the given bytecode sequence
+ * before the instruction at the given index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the bytecode is inserted within that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * <p>The index at which the byte sequence is actually inserted
+ * might be different from pos since some other bytes might be
+ * inserted at other positions (e.g. to change <code>GOTO</code>
+ * to <code>GOTO_W</code>).
+ *
+ * @param pos the index at which a byte sequence is inserted.
+ * @param code inserted bytecode sequence.
+ */
+ public void insert(int pos, byte[] code) throws BadBytecode {
+ insert0(pos, code, false);
+ }
+
+ /**
+ * Inserts the given bytecode sequence
+ * before the instruction at the given index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the bytecode is inserted within that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * @param pos the index at which a byte sequence is inserted.
+ * @param code inserted bytecode sequence.
+ * @return the index indicating the first byte of the
+ * inserted byte sequence, which might be
+ * different from pos.
+ * @since 3.11
+ */
+ public int insertAt(int pos, byte[] code) throws BadBytecode {
+ return insert0(pos, code, false);
+ }
+
+ /**
+ * Inserts the given bytecode sequence exclusively
+ * before the next instruction that would be returned by
+ * <code>next()</code> (not before the instruction returned
+ * by tha last call to <code>next()</code>).
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the next instruction is at the beginning of a block statement,
+ * then the bytecode is excluded from that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * @param code inserted bytecode sequence.
+ * @return the index indicating the first byte of the
+ * inserted byte sequence.
+ */
+ public int insertEx(byte[] code)
+ throws BadBytecode
+ {
+ return insert0(currentPos, code, true);
+ }
+
+ /**
+ * Inserts the given bytecode sequence exclusively
+ * before the instruction at the given index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the bytecode is excluded from that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * <p>The index at which the byte sequence is actually inserted
+ * might be different from pos since some other bytes might be
+ * inserted at other positions (e.g. to change <code>GOTO</code>
+ * to <code>GOTO_W</code>).
+ *
+ * @param pos the index at which a byte sequence is inserted.
+ * @param code inserted bytecode sequence.
+ */
+ public void insertEx(int pos, byte[] code) throws BadBytecode {
+ insert0(pos, code, true);
+ }
+
+ /**
+ * Inserts the given bytecode sequence exclusively
+ * before the instruction at the given index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the bytecode is excluded from that block.
+ *
+ * <p>An extra gap may be inserted at the end of the inserted
+ * bytecode sequence for adjusting alignment if the code attribute
+ * includes <code>LOOKUPSWITCH</code> or <code>TABLESWITCH</code>.
+ *
+ * @param pos the index at which a byte sequence is inserted.
+ * @param code inserted bytecode sequence.
+ * @return the index indicating the first byte of the
+ * inserted byte sequence, which might be
+ * different from pos.
+ * @since 3.11
+ */
+ public int insertExAt(int pos, byte[] code) throws BadBytecode {
+ return insert0(pos, code, true);
+ }
+
+ /**
+ * @return the index indicating the first byte of the
+ * inserted byte sequence.
+ */
+ private int insert0(int pos, byte[] code, boolean exclusive)
+ throws BadBytecode
+ {
+ int len = code.length;
+ if (len <= 0)
+ return pos;
+
+ // currentPos will change.
+ pos = insertGapAt(pos, len, exclusive).position;
+
+ int p = pos;
+ for (int j = 0; j < len; ++j)
+ bytecode[p++] = code[j];
+
+ return pos;
+ }
+
+ /**
+ * Inserts a gap
+ * before the next instruction that would be returned by
+ * <code>next()</code> (not before the instruction returned
+ * by the last call to <code>next()</code>).
+ * Branch offsets and the exception table are also updated.
+ * The inserted gap is filled with NOP. The gap length may be
+ * extended to a multiple of 4.
+ *
+ * <p>If the next instruction is at the beginning of a block statement,
+ * then the gap is inserted within that block.
+ *
+ * @param length gap length
+ * @return the index indicating the first byte of the inserted gap.
+ */
+ public int insertGap(int length) throws BadBytecode {
+ return insertGapAt(currentPos, length, false).position;
+ }
+
+ /**
+ * Inserts a gap in front of the instruction at the given
+ * index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ * The inserted gap is filled with NOP. The gap length may be
+ * extended to a multiple of 4.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the gap is inserted within that block.
+ *
+ * @param pos the index at which a gap is inserted.
+ * @param length gap length.
+ * @return the length of the inserted gap.
+ * It might be bigger than <code>length</code>.
+ */
+ public int insertGap(int pos, int length) throws BadBytecode {
+ return insertGapAt(pos, length, false).length;
+ }
+
+ /**
+ * Inserts an exclusive gap
+ * before the next instruction that would be returned by
+ * <code>next()</code> (not before the instruction returned
+ * by the last call to <code>next()</code>).
+ * Branch offsets and the exception table are also updated.
+ * The inserted gap is filled with NOP. The gap length may be
+ * extended to a multiple of 4.
+ *
+ * <p>If the next instruction is at the beginning of a block statement,
+ * then the gap is excluded from that block.
+ *
+ * @param length gap length
+ * @return the index indicating the first byte of the inserted gap.
+ */
+ public int insertExGap(int length) throws BadBytecode {
+ return insertGapAt(currentPos, length, true).position;
+ }
+
+ /**
+ * Inserts an exclusive gap in front of the instruction at the given
+ * index <code>pos</code>.
+ * Branch offsets and the exception table are also updated.
+ * The inserted gap is filled with NOP. The gap length may be
+ * extended to a multiple of 4.
+ *
+ * <p>If the instruction at the given index is at the beginning
+ * of a block statement,
+ * then the gap is excluded from that block.
+ *
+ * @param pos the index at which a gap is inserted.
+ * @param length gap length.
+ * @return the length of the inserted gap.
+ * It might be bigger than <code>length</code>.
+ */
+ public int insertExGap(int pos, int length) throws BadBytecode {
+ return insertGapAt(pos, length, true).length;
+ }
+
+ /**
+ * An inserted gap.
+ *
+ * @since 3.11
+ */
+ public static class Gap {
+ /**
+ * The position of the gap.
+ */
+ public int position;
+
+ /**
+ * The length of the gap.
+ */
+ public int length;
+ }
+
+ /**
+ * Inserts an inclusive or exclusive gap in front of the instruction
+ * at the given index <code>pos</code>.
+ * Branch offsets and the exception table in the method body
+ * are also updated. The inserted gap is filled with NOP.
+ * The gap length may be extended to a multiple of 4.
+ *
+ * <p>Suppose that the instruction at the given index is at the
+ * beginning of a block statement. If the gap is inclusive,
+ * then it is included within that block. If the gap is exclusive,
+ * then it is excluded from that block.
+ *
+ * <p>The index at which the gap is actually inserted
+ * might be different from pos since some other bytes might be
+ * inserted at other positions (e.g. to change <code>GOTO</code>
+ * to <code>GOTO_W</code>). The index is available from the <code>Gap</code>
+ * object returned by this method.
+ *
+ * <p>Suppose that the gap is inserted at the position of
+ * the next instruction that would be returned by
+ * <code>next()</code> (not the last instruction returned
+ * by the last call to <code>next()</code>). The next
+ * instruction returned by <code>next()</code> after the gap is
+ * inserted is still the same instruction. It is not <code>NOP</code>
+ * at the first byte of the inserted gap.
+ *
+ * @param pos the index at which a gap is inserted.
+ * @param length gap length.
+ * @param exclusive true if exclusive, otherwise false.
+ * @return the position and the length of the inserted gap.
+ * @since 3.11
+ */
+ public Gap insertGapAt(int pos, int length, boolean exclusive)
+ throws BadBytecode
+ {
+ /**
+ * cursorPos indicates the next bytecode whichever exclusive is
+ * true or false.
+ */
+ Gap gap = new Gap();
+ if (length <= 0) {
+ gap.position = pos;
+ gap.length = 0;
+ return gap;
+ }
+
+ byte[] c;
+ int length2;
+ if (bytecode.length + length > Short.MAX_VALUE) {
+ // currentPos might change after calling insertGapCore0w().
+ c = insertGapCore0w(bytecode, pos, length, exclusive,
+ get().getExceptionTable(), codeAttr, gap);
+ pos = gap.position;
+ length2 = length; // == gap.length
+ }
+ else {
+ int cur = currentPos;
+ c = insertGapCore0(bytecode, pos, length, exclusive,
+ get().getExceptionTable(), codeAttr);
+ // insertGapCore0() never changes pos.
+ length2 = c.length - bytecode.length;
+ gap.position = pos;
+ gap.length = length2;
+ if (cur >= pos)
+ currentPos = cur + length2;
+
+ if (mark > pos || (mark == pos && exclusive))
+ mark += length2;
+ }
+
+ codeAttr.setCode(c);
+ bytecode = c;
+ endPos = getCodeLength();
+ updateCursors(pos, length2);
+ return gap;
+ }
+
+ /**
+ * Is called when a gap is inserted. The default implementation is empty.
+ * A subclass can override this method so that cursors will be updated.
+ *
+ * @param pos the position where a gap is inserted.
+ * @param length the length of the gap.
+ */
+ protected void updateCursors(int pos, int length) {
+ // empty
+ }
+
+ /**
+ * Copies and inserts the entries in the given exception table
+ * at the beginning of the exception table in the code attribute
+ * edited by this object.
+ *
+ * @param offset the value added to the code positions included
+ * in the entries.
+ */
+ public void insert(ExceptionTable et, int offset) {
+ codeAttr.getExceptionTable().add(0, et, offset);
+ }
+
+ /**
+ * Appends the given bytecode sequence at the end.
+ *
+ * @param code the bytecode appended.
+ * @return the position of the first byte of the appended bytecode.
+ */
+ public int append(byte[] code) {
+ int size = getCodeLength();
+ int len = code.length;
+ if (len <= 0)
+ return size;
+
+ appendGap(len);
+ byte[] dest = bytecode;
+ for (int i = 0; i < len; ++i)
+ dest[i + size] = code[i];
+
+ return size;
+ }
+
+ /**
+ * Appends a gap at the end of the bytecode sequence.
+ *
+ * @param gapLength gap length
+ */
+ public void appendGap(int gapLength) {
+ byte[] code = bytecode;
+ int codeLength = code.length;
+ byte[] newcode = new byte[codeLength + gapLength];
+
+ int i;
+ for (i = 0; i < codeLength; ++i)
+ newcode[i] = code[i];
+
+ for (i = codeLength; i < codeLength + gapLength; ++i)
+ newcode[i] = NOP;
+
+ codeAttr.setCode(newcode);
+ bytecode = newcode;
+ endPos = getCodeLength();
+ }
+
+ /**
+ * Copies and appends the entries in the given exception table
+ * at the end of the exception table in the code attribute
+ * edited by this object.
+ *
+ * @param offset the value added to the code positions included
+ * in the entries.
+ */
+ public void append(ExceptionTable et, int offset) {
+ ExceptionTable table = codeAttr.getExceptionTable();
+ table.add(table.size(), et, offset);
+ }
+
+ /* opcodeLegth is used for implementing nextOpcode().
+ */
+ private static final int opcodeLength[] = {
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 3,
+ 3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 0, 0, 1, 1, 1, 1, 1, 1, 3, 3,
+ 3, 3, 3, 3, 3, 5, 0, 3, 2, 3, 1, 1, 3, 3, 1, 1, 0, 4, 3, 3,
+ 5, 5
+ };
+ // 0 .. UNUSED (186), LOOKUPSWITCH, TABLESWITCH, WIDE
+
+ /**
+ * Calculates the index of the next opcode.
+ */
+ static int nextOpcode(byte[] code, int index)
+ throws BadBytecode
+ {
+ int opcode;
+ try {
+ opcode = code[index] & 0xff;
+ }
+ catch (IndexOutOfBoundsException e) {
+ throw new BadBytecode("invalid opcode address");
+ }
+
+ try {
+ int len = opcodeLength[opcode];
+ if (len > 0)
+ return index + len;
+ else if (opcode == WIDE)
+ if (code[index + 1] == (byte)IINC) // WIDE IINC
+ return index + 6;
+ else
+ return index + 4; // WIDE ...
+ else {
+ int index2 = (index & ~3) + 8;
+ if (opcode == LOOKUPSWITCH) {
+ int npairs = ByteArray.read32bit(code, index2);
+ return index2 + npairs * 8 + 4;
+ }
+ else if (opcode == TABLESWITCH) {
+ int low = ByteArray.read32bit(code, index2);
+ int high = ByteArray.read32bit(code, index2 + 4);
+ return index2 + (high - low + 1) * 4 + 8;
+ }
+ // else
+ // throw new BadBytecode(opcode);
+ }
+ }
+ catch (IndexOutOfBoundsException e) {
+ }
+
+ // opcode is UNUSED or an IndexOutOfBoundsException was thrown.
+ throw new BadBytecode(opcode);
+ }
+
+ // methods for implementing insertGap().
+
+ static class AlignmentException extends Exception {}
+
+ /**
+ * insertGapCore0() inserts a gap (some NOPs).
+ * It cannot handle a long code sequence more than 32K. All branch offsets must be
+ * signed 16bits.
+ *
+ * If "where" is the beginning of a block statement and exclusive is false,
+ * then the inserted gap is also included in the block statement.
+ * "where" must indicate the first byte of an opcode.
+ * The inserted gap is filled with NOP. gapLength may be extended to
+ * a multiple of 4.
+ *
+ * This method was also called from CodeAttribute.LdcEntry.doit().
+ *
+ * @param where It must indicate the first byte of an opcode.
+ */
+ static byte[] insertGapCore0(byte[] code, int where, int gapLength,
+ boolean exclusive, ExceptionTable etable, CodeAttribute ca)
+ throws BadBytecode
+ {
+ if (gapLength <= 0)
+ return code;
+
+ try {
+ return insertGapCore1(code, where, gapLength, exclusive, etable, ca);
+ }
+ catch (AlignmentException e) {
+ try {
+ return insertGapCore1(code, where, (gapLength + 3) & ~3,
+ exclusive, etable, ca);
+ }
+ catch (AlignmentException e2) {
+ throw new RuntimeException("fatal error?");
+ }
+ }
+ }
+
+ private static byte[] insertGapCore1(byte[] code, int where, int gapLength,
+ boolean exclusive, ExceptionTable etable,
+ CodeAttribute ca)
+ throws BadBytecode, AlignmentException
+ {
+ int codeLength = code.length;
+ byte[] newcode = new byte[codeLength + gapLength];
+ insertGap2(code, where, gapLength, codeLength, newcode, exclusive);
+ etable.shiftPc(where, gapLength, exclusive);
+ LineNumberAttribute na
+ = (LineNumberAttribute)ca.getAttribute(LineNumberAttribute.tag);
+ if (na != null)
+ na.shiftPc(where, gapLength, exclusive);
+
+ LocalVariableAttribute va = (LocalVariableAttribute)ca.getAttribute(
+ LocalVariableAttribute.tag);
+ if (va != null)
+ va.shiftPc(where, gapLength, exclusive);
+
+ LocalVariableAttribute vta
+ = (LocalVariableAttribute)ca.getAttribute(
+ LocalVariableAttribute.typeTag);
+ if (vta != null)
+ vta.shiftPc(where, gapLength, exclusive);
+
+ StackMapTable smt = (StackMapTable)ca.getAttribute(StackMapTable.tag);
+ if (smt != null)
+ smt.shiftPc(where, gapLength, exclusive);
+
+ StackMap sm = (StackMap)ca.getAttribute(StackMap.tag);
+ if (sm != null)
+ sm.shiftPc(where, gapLength, exclusive);
+
+ return newcode;
+ }
+
+ private static void insertGap2(byte[] code, int where, int gapLength,
+ int endPos, byte[] newcode, boolean exclusive)
+ throws BadBytecode, AlignmentException
+ {
+ int nextPos;
+ int i = 0;
+ int j = 0;
+ for (; i < endPos; i = nextPos) {
+ if (i == where) {
+ int j2 = j + gapLength;
+ while (j < j2)
+ newcode[j++] = NOP;
+ }
+
+ nextPos = nextOpcode(code, i);
+ int inst = code[i] & 0xff;
+ // if<cond>, if_icmp<cond>, if_acmp<cond>, goto, jsr
+ if ((153 <= inst && inst <= 168)
+ || inst == IFNULL || inst == IFNONNULL) {
+ /* 2bytes *signed* offset */
+ int offset = (code[i + 1] << 8) | (code[i + 2] & 0xff);
+ offset = newOffset(i, offset, where, gapLength, exclusive);
+ newcode[j] = code[i];
+ ByteArray.write16bit(offset, newcode, j + 1);
+ j += 3;
+ }
+ else if (inst == GOTO_W || inst == JSR_W) {
+ /* 4bytes offset */
+ int offset = ByteArray.read32bit(code, i + 1);
+ offset = newOffset(i, offset, where, gapLength, exclusive);
+ newcode[j++] = code[i];
+ ByteArray.write32bit(offset, newcode, j);
+ j += 4;
+ }
+ else if (inst == TABLESWITCH) {
+ if (i != j && (gapLength & 3) != 0)
+ throw new AlignmentException();
+
+ int i2 = (i & ~3) + 4; // 0-3 byte padding
+ // IBM JVM 1.4.2 cannot run the following code:
+ // int i0 = i;
+ // while (i0 < i2)
+ // newcode[j++] = code[i0++];
+ // So extracting this code into an external method.
+ // see JIRA JASSIST-74.
+ j = copyGapBytes(newcode, j, code, i, i2);
+
+ int defaultbyte = newOffset(i, ByteArray.read32bit(code, i2),
+ where, gapLength, exclusive);
+ ByteArray.write32bit(defaultbyte, newcode, j);
+ int lowbyte = ByteArray.read32bit(code, i2 + 4);
+ ByteArray.write32bit(lowbyte, newcode, j + 4);
+ int highbyte = ByteArray.read32bit(code, i2 + 8);
+ ByteArray.write32bit(highbyte, newcode, j + 8);
+ j += 12;
+ int i0 = i2 + 12;
+ i2 = i0 + (highbyte - lowbyte + 1) * 4;
+ while (i0 < i2) {
+ int offset = newOffset(i, ByteArray.read32bit(code, i0),
+ where, gapLength, exclusive);
+ ByteArray.write32bit(offset, newcode, j);
+ j += 4;
+ i0 += 4;
+ }
+ }
+ else if (inst == LOOKUPSWITCH) {
+ if (i != j && (gapLength & 3) != 0)
+ throw new AlignmentException();
+
+ int i2 = (i & ~3) + 4; // 0-3 byte padding
+
+ // IBM JVM 1.4.2 cannot run the following code:
+ // int i0 = i;
+ // while (i0 < i2)
+ // newcode[j++] = code[i0++];
+ // So extracting this code into an external method.
+ // see JIRA JASSIST-74.
+ j = copyGapBytes(newcode, j, code, i, i2);
+
+ int defaultbyte = newOffset(i, ByteArray.read32bit(code, i2),
+ where, gapLength, exclusive);
+ ByteArray.write32bit(defaultbyte, newcode, j);
+ int npairs = ByteArray.read32bit(code, i2 + 4);
+ ByteArray.write32bit(npairs, newcode, j + 4);
+ j += 8;
+ int i0 = i2 + 8;
+ i2 = i0 + npairs * 8;
+ while (i0 < i2) {
+ ByteArray.copy32bit(code, i0, newcode, j);
+ int offset = newOffset(i,
+ ByteArray.read32bit(code, i0 + 4),
+ where, gapLength, exclusive);
+ ByteArray.write32bit(offset, newcode, j + 4);
+ j += 8;
+ i0 += 8;
+ }
+ }
+ else
+ while (i < nextPos)
+ newcode[j++] = code[i++];
+ }
+ }
+
+
+ private static int copyGapBytes(byte[] newcode, int j, byte[] code, int i, int iEnd) {
+ switch (iEnd - i) {
+ case 4:
+ newcode[j++] = code[i++];
+ case 3:
+ newcode[j++] = code[i++];
+ case 2:
+ newcode[j++] = code[i++];
+ case 1:
+ newcode[j++] = code[i++];
+ default:
+ }
+
+ return j;
+ }
+
+ private static int newOffset(int i, int offset, int where,
+ int gapLength, boolean exclusive) {
+ int target = i + offset;
+ if (i < where) {
+ if (where < target || (exclusive && where == target))
+ offset += gapLength;
+ }
+ else if (i == where) {
+ // This code is different from the code in Branch#shiftOffset().
+ // see JASSIST-124.
+ if (target < where)
+ offset -= gapLength;
+ }
+ else
+ if (target < where || (!exclusive && where == target))
+ offset -= gapLength;
+
+ return offset;
+ }
+
+ static class Pointers {
+ int cursor;
+ int mark0, mark;
+ ExceptionTable etable;
+ LineNumberAttribute line;
+ LocalVariableAttribute vars, types;
+ StackMapTable stack;
+ StackMap stack2;
+
+ Pointers(int cur, int m, int m0, ExceptionTable et, CodeAttribute ca) {
+ cursor = cur;
+ mark = m;
+ mark0 = m0;
+ etable = et; // non null
+ line = (LineNumberAttribute)ca.getAttribute(LineNumberAttribute.tag);
+ vars = (LocalVariableAttribute)ca.getAttribute(LocalVariableAttribute.tag);
+ types = (LocalVariableAttribute)ca.getAttribute(LocalVariableAttribute.typeTag);
+ stack = (StackMapTable)ca.getAttribute(StackMapTable.tag);
+ stack2 = (StackMap)ca.getAttribute(StackMap.tag);
+ }
+
+ void shiftPc(int where, int gapLength, boolean exclusive) throws BadBytecode {
+ if (where < cursor || (where == cursor && exclusive))
+ cursor += gapLength;
+
+ if (where < mark || (where == mark && exclusive))
+ mark += gapLength;
+
+ if (where < mark0 || (where == mark0 && exclusive))
+ mark0 += gapLength;
+
+ etable.shiftPc(where, gapLength, exclusive);
+ if (line != null)
+ line.shiftPc(where, gapLength, exclusive);
+
+ if (vars != null)
+ vars.shiftPc(where, gapLength, exclusive);
+
+ if (types != null)
+ types.shiftPc(where, gapLength, exclusive);
+
+ if (stack != null)
+ stack.shiftPc(where, gapLength, exclusive);
+
+ if (stack2 != null)
+ stack2.shiftPc(where, gapLength, exclusive);
+ }
+ }
+
+ /*
+ * This method is called from CodeAttribute.LdcEntry.doit().
+ */
+ static byte[] changeLdcToLdcW(byte[] code, ExceptionTable etable,
+ CodeAttribute ca, CodeAttribute.LdcEntry ldcs)
+ throws BadBytecode
+ {
+ ArrayList jumps = makeJumpList(code, code.length);
+ while (ldcs != null) {
+ addLdcW(ldcs, jumps);
+ ldcs = ldcs.next;
+ }
+
+ Pointers pointers = new Pointers(0, 0, 0, etable, ca);
+ byte[] r = insertGap2w(code, 0, 0, false, jumps, pointers);
+ return r;
+ }
+
+ private static void addLdcW(CodeAttribute.LdcEntry ldcs, ArrayList jumps) {
+ int where = ldcs.where;
+ LdcW ldcw = new LdcW(where, ldcs.index);
+ int s = jumps.size();
+ for (int i = 0; i < s; i++)
+ if (where < ((Branch)jumps.get(i)).orgPos) {
+ jumps.add(i, ldcw);
+ return;
+ }
+
+ jumps.add(ldcw);
+ }
+
+ /*
+ * insertGapCore0w() can handle a long code sequence more than 32K.
+ * It guarantees that the length of the inserted gap (NOPs) is equal to
+ * gapLength. No other NOPs except some NOPs following TABLESWITCH or
+ * LOOKUPSWITCH will not be inserted.
+ *
+ * Note: currentPos might be moved.
+ *
+ * @param where It must indicate the first byte of an opcode.
+ * @param newWhere It contains the updated index of the position where a gap
+ * is inserted and the length of the gap.
+ * It must not be null.
+ */
+ private byte[] insertGapCore0w(byte[] code, int where, int gapLength, boolean exclusive,
+ ExceptionTable etable, CodeAttribute ca, Gap newWhere)
+ throws BadBytecode
+ {
+ if (gapLength <= 0)
+ return code;
+
+ ArrayList jumps = makeJumpList(code, code.length);
+ Pointers pointers = new Pointers(currentPos, mark, where, etable, ca);
+ byte[] r = insertGap2w(code, where, gapLength, exclusive, jumps, pointers);
+ currentPos = pointers.cursor;
+ mark = pointers.mark;
+ int where2 = pointers.mark0;
+ if (where2 == currentPos && !exclusive)
+ currentPos += gapLength;
+
+ if (exclusive)
+ where2 -= gapLength;
+
+ newWhere.position = where2;
+ newWhere.length = gapLength;
+ return r;
+ }
+
+ private static byte[] insertGap2w(byte[] code, int where, int gapLength,
+ boolean exclusive, ArrayList jumps, Pointers ptrs)
+ throws BadBytecode
+ {
+ int n = jumps.size();
+ if (gapLength > 0) {
+ ptrs.shiftPc(where, gapLength, exclusive);
+ for (int i = 0; i < n; i++)
+ ((Branch)jumps.get(i)).shift(where, gapLength, exclusive);
+ }
+
+ boolean unstable = true;
+ do {
+ while (unstable) {
+ unstable = false;
+ for (int i = 0; i < n; i++) {
+ Branch b = (Branch)jumps.get(i);
+ if (b.expanded()) {
+ unstable = true;
+ int p = b.pos;
+ int delta = b.deltaSize();
+ ptrs.shiftPc(p, delta, false);
+ for (int j = 0; j < n; j++)
+ ((Branch)jumps.get(j)).shift(p, delta, false);
+ }
+ }
+ }
+
+ for (int i = 0; i < n; i++) {
+ Branch b = (Branch)jumps.get(i);
+ int diff = b.gapChanged();
+ if (diff > 0) {
+ unstable = true;
+ int p = b.pos;
+ ptrs.shiftPc(p, diff, false);
+ for (int j = 0; j < n; j++)
+ ((Branch)jumps.get(j)).shift(p, diff, false);
+ }
+ }
+ } while (unstable);
+
+ return makeExapndedCode(code, jumps, where, gapLength);
+ }
+
+ private static ArrayList makeJumpList(byte[] code, int endPos)
+ throws BadBytecode
+ {
+ ArrayList jumps = new ArrayList();
+ int nextPos;
+ for (int i = 0; i < endPos; i = nextPos) {
+ nextPos = nextOpcode(code, i);
+ int inst = code[i] & 0xff;
+ // if<cond>, if_icmp<cond>, if_acmp<cond>, goto, jsr
+ if ((153 <= inst && inst <= 168)
+ || inst == IFNULL || inst == IFNONNULL) {
+ /* 2bytes *signed* offset */
+ int offset = (code[i + 1] << 8) | (code[i + 2] & 0xff);
+ Branch b;
+ if (inst == GOTO || inst == JSR)
+ b = new Jump16(i, offset);
+ else
+ b = new If16(i, offset);
+
+ jumps.add(b);
+ }
+ else if (inst == GOTO_W || inst == JSR_W) {
+ /* 4bytes offset */
+ int offset = ByteArray.read32bit(code, i + 1);
+ jumps.add(new Jump32(i, offset));
+ }
+ else if (inst == TABLESWITCH) {
+ int i2 = (i & ~3) + 4; // 0-3 byte padding
+ int defaultbyte = ByteArray.read32bit(code, i2);
+ int lowbyte = ByteArray.read32bit(code, i2 + 4);
+ int highbyte = ByteArray.read32bit(code, i2 + 8);
+ int i0 = i2 + 12;
+ int size = highbyte - lowbyte + 1;
+ int[] offsets = new int[size];
+ for (int j = 0; j < size; j++) {
+ offsets[j] = ByteArray.read32bit(code, i0);
+ i0 += 4;
+ }
+
+ jumps.add(new Table(i, defaultbyte, lowbyte, highbyte, offsets));
+ }
+ else if (inst == LOOKUPSWITCH) {
+ int i2 = (i & ~3) + 4; // 0-3 byte padding
+ int defaultbyte = ByteArray.read32bit(code, i2);
+ int npairs = ByteArray.read32bit(code, i2 + 4);
+ int i0 = i2 + 8;
+ int[] matches = new int[npairs];
+ int[] offsets = new int[npairs];
+ for (int j = 0; j < npairs; j++) {
+ matches[j] = ByteArray.read32bit(code, i0);
+ offsets[j] = ByteArray.read32bit(code, i0 + 4);
+ i0 += 8;
+ }
+
+ jumps.add(new Lookup(i, defaultbyte, matches, offsets));
+ }
+ }
+
+ return jumps;
+ }
+
+ private static byte[] makeExapndedCode(byte[] code, ArrayList jumps,
+ int where, int gapLength)
+ throws BadBytecode
+ {
+ int n = jumps.size();
+ int size = code.length + gapLength;
+ for (int i = 0; i < n; i++) {
+ Branch b = (Branch)jumps.get(i);
+ size += b.deltaSize();
+ }
+
+ byte[] newcode = new byte[size];
+ int src = 0, dest = 0, bindex = 0;
+ int len = code.length;
+ Branch b;
+ int bpos;
+ if (0 < n) {
+ b = (Branch)jumps.get(0);
+ bpos = b.orgPos;
+ }
+ else {
+ b = null;
+ bpos = len; // src will be never equal to bpos
+ }
+
+ while (src < len) {
+ if (src == where) {
+ int pos2 = dest + gapLength;
+ while (dest < pos2)
+ newcode[dest++] = NOP;
+ }
+
+ if (src != bpos)
+ newcode[dest++] = code[src++];
+ else {
+ int s = b.write(src, code, dest, newcode);
+ src += s;
+ dest += s + b.deltaSize();
+ if (++bindex < n) {
+ b = (Branch)jumps.get(bindex);
+ bpos = b.orgPos;
+ }
+ else {
+ b = null;
+ bpos = len;
+ }
+ }
+ }
+
+ return newcode;
+ }
+
+ static abstract class Branch {
+ int pos, orgPos;
+ Branch(int p) { pos = orgPos = p; }
+ void shift(int where, int gapLength, boolean exclusive) {
+ if (where < pos || (where == pos && exclusive))
+ pos += gapLength;
+ }
+
+ static int shiftOffset(int i, int offset, int where,
+ int gapLength, boolean exclusive) {
+ int target = i + offset;
+ if (i < where) {
+ if (where < target || (exclusive && where == target))
+ offset += gapLength;
+ }
+ else if (i == where) {
+ // This code is different from the code in CodeIterator#newOffset().
+ // see JASSIST-124.
+ if (target < where && exclusive)
+ offset -= gapLength;
+ else if (where < target && !exclusive)
+ offset += gapLength;
+ }
+ else
+ if (target < where || (!exclusive && where == target))
+ offset -= gapLength;
+
+ return offset;
+ }
+
+ boolean expanded() { return false; }
+ int gapChanged() { return 0; }
+ int deltaSize() { return 0; } // newSize - oldSize
+
+ // This returns the original instruction size.
+ abstract int write(int srcPos, byte[] code, int destPos, byte[] newcode);
+ }
+
+ /* used by changeLdcToLdcW() and CodeAttribute.LdcEntry.
+ */
+ static class LdcW extends Branch {
+ int index;
+ boolean state;
+ LdcW(int p, int i) {
+ super(p);
+ index = i;
+ state = true;
+ }
+
+ boolean expanded() {
+ if (state) {
+ state = false;
+ return true;
+ }
+ else
+ return false;
+ }
+
+ int deltaSize() { return 1; }
+
+ int write(int srcPos, byte[] code, int destPos, byte[] newcode) {
+ newcode[destPos] = LDC_W;
+ ByteArray.write16bit(index, newcode, destPos + 1);
+ return 2;
+ }
+ }
+
+ static abstract class Branch16 extends Branch {
+ int offset;
+ int state;
+ static final int BIT16 = 0;
+ static final int EXPAND = 1;
+ static final int BIT32 = 2;
+
+ Branch16(int p, int off) {
+ super(p);
+ offset = off;
+ state = BIT16;
+ }
+
+ void shift(int where, int gapLength, boolean exclusive) {
+ offset = shiftOffset(pos, offset, where, gapLength, exclusive);
+ super.shift(where, gapLength, exclusive);
+ if (state == BIT16)
+ if (offset < Short.MIN_VALUE || Short.MAX_VALUE < offset)
+ state = EXPAND;
+ }
+
+ boolean expanded() {
+ if (state == EXPAND) {
+ state = BIT32;
+ return true;
+ }
+ else
+ return false;
+ }
+
+ abstract int deltaSize();
+ abstract void write32(int src, byte[] code, int dest, byte[] newcode);
+
+ int write(int src, byte[] code, int dest, byte[] newcode) {
+ if (state == BIT32)
+ write32(src, code, dest, newcode);
+ else {
+ newcode[dest] = code[src];
+ ByteArray.write16bit(offset, newcode, dest + 1);
+ }
+
+ return 3;
+ }
+ }
+
+ // GOTO or JSR
+ static class Jump16 extends Branch16 {
+ Jump16(int p, int off) {
+ super(p, off);
+ }
+
+ int deltaSize() {
+ return state == BIT32 ? 2 : 0;
+ }
+
+ void write32(int src, byte[] code, int dest, byte[] newcode) {
+ newcode[dest] = (byte)(((code[src] & 0xff) == GOTO) ? GOTO_W : JSR_W);
+ ByteArray.write32bit(offset, newcode, dest + 1);
+ }
+ }
+
+ // if<cond>, if_icmp<cond>, or if_acmp<cond>
+ static class If16 extends Branch16 {
+ If16(int p, int off) {
+ super(p, off);
+ }
+
+ int deltaSize() {
+ return state == BIT32 ? 5 : 0;
+ }
+
+ void write32(int src, byte[] code, int dest, byte[] newcode) {
+ newcode[dest] = (byte)opcode(code[src] & 0xff);
+ newcode[dest + 1] = 0;
+ newcode[dest + 2] = 8; // branch_offset = 8
+ newcode[dest + 3] = (byte)GOTO_W;
+ ByteArray.write32bit(offset - 3, newcode, dest + 4);
+ }
+
+ int opcode(int op) {
+ if (op == IFNULL)
+ return IFNONNULL;
+ else if (op == IFNONNULL)
+ return IFNULL;
+ else {
+ if (((op - IFEQ) & 1) == 0)
+ return op + 1;
+ else
+ return op - 1;
+ }
+ }
+ }
+
+ static class Jump32 extends Branch {
+ int offset;
+
+ Jump32(int p, int off) {
+ super(p);
+ offset = off;
+ }
+
+ void shift(int where, int gapLength, boolean exclusive) {
+ offset = shiftOffset(pos, offset, where, gapLength, exclusive);
+ super.shift(where, gapLength, exclusive);
+ }
+
+ int write(int src, byte[] code, int dest, byte[] newcode) {
+ newcode[dest] = code[src];
+ ByteArray.write32bit(offset, newcode, dest + 1);
+ return 5;
+ }
+ }
+
+ static abstract class Switcher extends Branch {
+ int gap, defaultByte;
+ int[] offsets;
+
+ Switcher(int pos, int defaultByte, int[] offsets) {
+ super(pos);
+ this.gap = 3 - (pos & 3);
+ this.defaultByte = defaultByte;
+ this.offsets = offsets;
+ }
+
+ void shift(int where, int gapLength, boolean exclusive) {
+ int p = pos;
+ defaultByte = shiftOffset(p, defaultByte, where, gapLength, exclusive);
+ int num = offsets.length;
+ for (int i = 0; i < num; i++)
+ offsets[i] = shiftOffset(p, offsets[i], where, gapLength, exclusive);
+
+ super.shift(where, gapLength, exclusive);
+ }
+
+ int gapChanged() {
+ int newGap = 3 - (pos & 3);
+ if (newGap > gap) {
+ int diff = newGap - gap;
+ gap = newGap;
+ return diff;
+ }
+
+ return 0;
+ }
+
+ int deltaSize() {
+ return gap - (3 - (orgPos & 3));
+ }
+
+ int write(int src, byte[] code, int dest, byte[] newcode) {
+ int padding = 3 - (pos & 3);
+ int nops = gap - padding;
+ int bytecodeSize = 5 + (3 - (orgPos & 3)) + tableSize();
+ adjustOffsets(bytecodeSize, nops);
+ newcode[dest++] = code[src];
+ while (padding-- > 0)
+ newcode[dest++] = 0;
+
+ ByteArray.write32bit(defaultByte, newcode, dest);
+ int size = write2(dest + 4, newcode);
+ dest += size + 4;
+ while (nops-- > 0)
+ newcode[dest++] = NOP;
+
+ return 5 + (3 - (orgPos & 3)) + size;
+ }
+
+ abstract int write2(int dest, byte[] newcode);
+ abstract int tableSize();
+
+ /* If the new bytecode size is shorter than the original, some NOPs
+ * are appended after this branch instruction (tableswitch or
+ * lookupswitch) to fill the gap.
+ * This method changes a branch offset to point to the first NOP
+ * if the offset originally points to the bytecode next to this
+ * branch instruction. Otherwise, the bytecode would contain
+ * dead code. It complicates the generation of StackMap and
+ * StackMapTable.
+ */
+ void adjustOffsets(int size, int nops) {
+ if (defaultByte == size)
+ defaultByte -= nops;
+
+ for (int i = 0; i < offsets.length; i++)
+ if (offsets[i] == size)
+ offsets[i] -= nops;
+ }
+ }
+
+ static class Table extends Switcher {
+ int low, high;
+
+ Table(int pos, int defaultByte, int low, int high, int[] offsets) {
+ super(pos, defaultByte, offsets);
+ this.low = low;
+ this.high = high;
+ }
+
+ int write2(int dest, byte[] newcode) {
+ ByteArray.write32bit(low, newcode, dest);
+ ByteArray.write32bit(high, newcode, dest + 4);
+ int n = offsets.length;
+ dest += 8;
+ for (int i = 0; i < n; i++) {
+ ByteArray.write32bit(offsets[i], newcode, dest);
+ dest += 4;
+ }
+
+ return 8 + 4 * n;
+ }
+
+ int tableSize() { return 8 + 4 * offsets.length; }
+ }
+
+ static class Lookup extends Switcher {
+ int[] matches;
+
+ Lookup(int pos, int defaultByte, int[] matches, int[] offsets) {
+ super(pos, defaultByte, offsets);
+ this.matches = matches;
+ }
+
+ int write2(int dest, byte[] newcode) {
+ int n = matches.length;
+ ByteArray.write32bit(n, newcode, dest);
+ dest += 4;
+ for (int i = 0; i < n; i++) {
+ ByteArray.write32bit(matches[i], newcode, dest);
+ ByteArray.write32bit(offsets[i], newcode, dest + 4);
+ dest += 8;
+ }
+
+ return 4 + 8 * n;
+ }
+
+ int tableSize() { return 4 + 8 * matches.length; }
+ }
+}
diff --git a/src/main/javassist/bytecode/ConstPool.java b/src/main/javassist/bytecode/ConstPool.java
new file mode 100644
index 0000000..df4e542
--- /dev/null
+++ b/src/main/javassist/bytecode/ConstPool.java
@@ -0,0 +1,1572 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javassist.CtClass;
+
+/**
+ * Constant pool table.
+ */
+public final class ConstPool {
+ LongVector items;
+ int numOfItems;
+ HashMap classes;
+ HashMap strings;
+ ConstInfo[] constInfoCache;
+ int[] constInfoIndexCache;
+ int thisClassInfo;
+
+ private static final int CACHE_SIZE = 32;
+
+ /**
+ * A hash function for CACHE_SIZE
+ */
+ private static int hashFunc(int a, int b) {
+ int h = -2128831035;
+ final int prime = 16777619;
+ h = (h ^ (a & 0xff)) * prime;
+ h = (h ^ (b & 0xff)) * prime;
+
+ // changing the hash key size from 32bit to 5bit
+ h = (h >> 5) ^ (h & 0x1f);
+ return h & 0x1f; // 0..31
+ }
+
+ /**
+ * <code>CONSTANT_Class</code>
+ */
+ public static final int CONST_Class = ClassInfo.tag;
+
+ /**
+ * <code>CONSTANT_Fieldref</code>
+ */
+ public static final int CONST_Fieldref = FieldrefInfo.tag;
+
+ /**
+ * <code>CONSTANT_Methodref</code>
+ */
+ public static final int CONST_Methodref = MethodrefInfo.tag;
+
+ /**
+ * <code>CONSTANT_InterfaceMethodref</code>
+ */
+ public static final int CONST_InterfaceMethodref
+ = InterfaceMethodrefInfo.tag;
+
+ /**
+ * <code>CONSTANT_String</code>
+ */
+ public static final int CONST_String = StringInfo.tag;
+
+ /**
+ * <code>CONSTANT_Integer</code>
+ */
+ public static final int CONST_Integer = IntegerInfo.tag;
+
+ /**
+ * <code>CONSTANT_Float</code>
+ */
+ public static final int CONST_Float = FloatInfo.tag;
+
+ /**
+ * <code>CONSTANT_Long</code>
+ */
+ public static final int CONST_Long = LongInfo.tag;
+
+ /**
+ * <code>CONSTANT_Double</code>
+ */
+ public static final int CONST_Double = DoubleInfo.tag;
+
+ /**
+ * <code>CONSTANT_NameAndType</code>
+ */
+ public static final int CONST_NameAndType = NameAndTypeInfo.tag;
+
+ /**
+ * <code>CONSTANT_Utf8</code>
+ */
+ public static final int CONST_Utf8 = Utf8Info.tag;
+
+ /**
+ * Represents the class using this constant pool table.
+ */
+ public static final CtClass THIS = null;
+
+ /**
+ * Constructs a constant pool table.
+ *
+ * @param thisclass the name of the class using this constant
+ * pool table
+ */
+ public ConstPool(String thisclass) {
+ items = new LongVector();
+ numOfItems = 0;
+ addItem(null); // index 0 is reserved by the JVM.
+ classes = new HashMap();
+ strings = new HashMap();
+ constInfoCache = new ConstInfo[CACHE_SIZE];
+ constInfoIndexCache = new int[CACHE_SIZE];
+ thisClassInfo = addClassInfo(thisclass);
+ }
+
+ /**
+ * Constructs a constant pool table from the given byte stream.
+ *
+ * @param in byte stream.
+ */
+ public ConstPool(DataInputStream in) throws IOException {
+ classes = new HashMap();
+ strings = new HashMap();
+ constInfoCache = new ConstInfo[CACHE_SIZE];
+ constInfoIndexCache = new int[CACHE_SIZE];
+ thisClassInfo = 0;
+ /* read() initializes items and numOfItems, and do addItem(null).
+ */
+ read(in);
+ }
+
+ void prune() {
+ classes = new HashMap();
+ strings = new HashMap();
+ constInfoCache = new ConstInfo[CACHE_SIZE];
+ constInfoIndexCache = new int[CACHE_SIZE];
+ }
+
+ /**
+ * Returns the number of entries in this table.
+ */
+ public int getSize() {
+ return numOfItems;
+ }
+
+ /**
+ * Returns the name of the class using this constant pool table.
+ */
+ public String getClassName() {
+ return getClassInfo(thisClassInfo);
+ }
+
+ /**
+ * Returns the index of <code>CONSTANT_Class_info</code> structure
+ * specifying the class using this constant pool table.
+ */
+ public int getThisClassInfo() {
+ return thisClassInfo;
+ }
+
+ void setThisClassInfo(int i) {
+ thisClassInfo = i;
+ }
+
+ ConstInfo getItem(int n) {
+ return items.elementAt(n);
+ }
+
+ /**
+ * Returns the <code>tag</code> field of the constant pool table
+ * entry at the given index.
+ */
+ public int getTag(int index) {
+ return getItem(index).getTag();
+ }
+
+ /**
+ * Reads <code>CONSTANT_Class_info</code> structure
+ * at the given index.
+ *
+ * @return a fully-qualified class or interface name specified
+ * by <code>name_index</code>. If the type is an array
+ * type, this method returns an encoded name like
+ * <code>[java.lang.Object;</code> (note that the separators
+ * are not slashes but dots).
+ * @see javassist.ClassPool#getCtClass(String)
+ */
+ public String getClassInfo(int index) {
+ ClassInfo c = (ClassInfo)getItem(index);
+ if (c == null)
+ return null;
+ else
+ return Descriptor.toJavaName(getUtf8Info(c.name));
+ }
+
+ /**
+ * Reads the <code>name_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * at the given index.
+ */
+ public int getNameAndTypeName(int index) {
+ NameAndTypeInfo ntinfo = (NameAndTypeInfo)getItem(index);
+ return ntinfo.memberName;
+ }
+
+ /**
+ * Reads the <code>descriptor_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * at the given index.
+ */
+ public int getNameAndTypeDescriptor(int index) {
+ NameAndTypeInfo ntinfo = (NameAndTypeInfo)getItem(index);
+ return ntinfo.typeDescriptor;
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_Fieldref_info</code>,
+ * <code>CONSTANT_Methodref_info</code>,
+ * or <code>CONSTANT_Interfaceref_info</code>,
+ * structure at the given index.
+ *
+ * @since 3.6
+ */
+ public int getMemberClass(int index) {
+ MemberrefInfo minfo = (MemberrefInfo)getItem(index);
+ return minfo.classIndex;
+ }
+
+ /**
+ * Reads the <code>name_and_type_index</code> field of the
+ * <code>CONSTANT_Fieldref_info</code>,
+ * <code>CONSTANT_Methodref_info</code>,
+ * or <code>CONSTANT_Interfaceref_info</code>,
+ * structure at the given index.
+ *
+ * @since 3.6
+ */
+ public int getMemberNameAndType(int index) {
+ MemberrefInfo minfo = (MemberrefInfo)getItem(index);
+ return minfo.nameAndTypeIndex;
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_Fieldref_info</code> structure
+ * at the given index.
+ */
+ public int getFieldrefClass(int index) {
+ FieldrefInfo finfo = (FieldrefInfo)getItem(index);
+ return finfo.classIndex;
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_Fieldref_info</code> structure
+ * at the given index.
+ *
+ * @return the name of the class at that <code>class_index</code>.
+ */
+ public String getFieldrefClassName(int index) {
+ FieldrefInfo f = (FieldrefInfo)getItem(index);
+ if (f == null)
+ return null;
+ else
+ return getClassInfo(f.classIndex);
+ }
+
+ /**
+ * Reads the <code>name_and_type_index</code> field of the
+ * <code>CONSTANT_Fieldref_info</code> structure
+ * at the given index.
+ */
+ public int getFieldrefNameAndType(int index) {
+ FieldrefInfo finfo = (FieldrefInfo)getItem(index);
+ return finfo.nameAndTypeIndex;
+ }
+
+ /**
+ * Reads the <code>name_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to a <code>CONSTANT_Fieldref_info</code>.
+ * @return the name of the field.
+ */
+ public String getFieldrefName(int index) {
+ FieldrefInfo f = (FieldrefInfo)getItem(index);
+ if (f == null)
+ return null;
+ else {
+ NameAndTypeInfo n = (NameAndTypeInfo)getItem(f.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.memberName);
+ }
+ }
+
+ /**
+ * Reads the <code>descriptor_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to a <code>CONSTANT_Fieldref_info</code>.
+ * @return the type descriptor of the field.
+ */
+ public String getFieldrefType(int index) {
+ FieldrefInfo f = (FieldrefInfo)getItem(index);
+ if (f == null)
+ return null;
+ else {
+ NameAndTypeInfo n = (NameAndTypeInfo)getItem(f.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.typeDescriptor);
+ }
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_Methodref_info</code> structure
+ * at the given index.
+ */
+ public int getMethodrefClass(int index) {
+ MethodrefInfo minfo = (MethodrefInfo)getItem(index);
+ return minfo.classIndex;
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_Methodref_info</code> structure
+ * at the given index.
+ *
+ * @return the name of the class at that <code>class_index</code>.
+ */
+ public String getMethodrefClassName(int index) {
+ MethodrefInfo minfo = (MethodrefInfo)getItem(index);
+ if (minfo == null)
+ return null;
+ else
+ return getClassInfo(minfo.classIndex);
+ }
+
+ /**
+ * Reads the <code>name_and_type_index</code> field of the
+ * <code>CONSTANT_Methodref_info</code> structure
+ * at the given index.
+ */
+ public int getMethodrefNameAndType(int index) {
+ MethodrefInfo minfo = (MethodrefInfo)getItem(index);
+ return minfo.nameAndTypeIndex;
+ }
+
+ /**
+ * Reads the <code>name_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to a <code>CONSTANT_Methodref_info</code>.
+ * @return the name of the method.
+ */
+ public String getMethodrefName(int index) {
+ MethodrefInfo minfo = (MethodrefInfo)getItem(index);
+ if (minfo == null)
+ return null;
+ else {
+ NameAndTypeInfo n
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.memberName);
+ }
+ }
+
+ /**
+ * Reads the <code>descriptor_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to a <code>CONSTANT_Methodref_info</code>.
+ * @return the descriptor of the method.
+ */
+ public String getMethodrefType(int index) {
+ MethodrefInfo minfo = (MethodrefInfo)getItem(index);
+ if (minfo == null)
+ return null;
+ else {
+ NameAndTypeInfo n
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.typeDescriptor);
+ }
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_InterfaceMethodref_info</code> structure
+ * at the given index.
+ */
+ public int getInterfaceMethodrefClass(int index) {
+ InterfaceMethodrefInfo minfo
+ = (InterfaceMethodrefInfo)getItem(index);
+ return minfo.classIndex;
+ }
+
+ /**
+ * Reads the <code>class_index</code> field of the
+ * <code>CONSTANT_InterfaceMethodref_info</code> structure
+ * at the given index.
+ *
+ * @return the name of the class at that <code>class_index</code>.
+ */
+ public String getInterfaceMethodrefClassName(int index) {
+ InterfaceMethodrefInfo minfo
+ = (InterfaceMethodrefInfo)getItem(index);
+ return getClassInfo(minfo.classIndex);
+ }
+
+ /**
+ * Reads the <code>name_and_type_index</code> field of the
+ * <code>CONSTANT_InterfaceMethodref_info</code> structure
+ * at the given index.
+ */
+ public int getInterfaceMethodrefNameAndType(int index) {
+ InterfaceMethodrefInfo minfo
+ = (InterfaceMethodrefInfo)getItem(index);
+ return minfo.nameAndTypeIndex;
+ }
+
+ /**
+ * Reads the <code>name_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to
+ * a <code>CONSTANT_InterfaceMethodref_info</code>.
+ * @return the name of the method.
+ */
+ public String getInterfaceMethodrefName(int index) {
+ InterfaceMethodrefInfo minfo
+ = (InterfaceMethodrefInfo)getItem(index);
+ if (minfo == null)
+ return null;
+ else {
+ NameAndTypeInfo n
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.memberName);
+ }
+ }
+
+ /**
+ * Reads the <code>descriptor_index</code> field of the
+ * <code>CONSTANT_NameAndType_info</code> structure
+ * indirectly specified by the given index.
+ *
+ * @param index an index to
+ * a <code>CONSTANT_InterfaceMethodref_info</code>.
+ * @return the descriptor of the method.
+ */
+ public String getInterfaceMethodrefType(int index) {
+ InterfaceMethodrefInfo minfo
+ = (InterfaceMethodrefInfo)getItem(index);
+ if (minfo == null)
+ return null;
+ else {
+ NameAndTypeInfo n
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if(n == null)
+ return null;
+ else
+ return getUtf8Info(n.typeDescriptor);
+ }
+ }
+ /**
+ * Reads <code>CONSTANT_Integer_info</code>, <code>_Float_info</code>,
+ * <code>_Long_info</code>, <code>_Double_info</code>, or
+ * <code>_String_info</code> structure.
+ * These are used with the LDC instruction.
+ *
+ * @return a <code>String</code> value or a wrapped primitive-type
+ * value.
+ */
+ public Object getLdcValue(int index) {
+ ConstInfo constInfo = this.getItem(index);
+ Object value = null;
+ if (constInfo instanceof StringInfo)
+ value = this.getStringInfo(index);
+ else if (constInfo instanceof FloatInfo)
+ value = new Float(getFloatInfo(index));
+ else if (constInfo instanceof IntegerInfo)
+ value = new Integer(getIntegerInfo(index));
+ else if (constInfo instanceof LongInfo)
+ value = new Long(getLongInfo(index));
+ else if (constInfo instanceof DoubleInfo)
+ value = new Double(getDoubleInfo(index));
+ else
+ value = null;
+
+ return value;
+ }
+
+ /**
+ * Reads <code>CONSTANT_Integer_info</code> structure
+ * at the given index.
+ *
+ * @return the value specified by this entry.
+ */
+ public int getIntegerInfo(int index) {
+ IntegerInfo i = (IntegerInfo)getItem(index);
+ return i.value;
+ }
+
+ /**
+ * Reads <code>CONSTANT_Float_info</code> structure
+ * at the given index.
+ *
+ * @return the value specified by this entry.
+ */
+ public float getFloatInfo(int index) {
+ FloatInfo i = (FloatInfo)getItem(index);
+ return i.value;
+ }
+
+ /**
+ * Reads <code>CONSTANT_Long_info</code> structure
+ * at the given index.
+ *
+ * @return the value specified by this entry.
+ */
+ public long getLongInfo(int index) {
+ LongInfo i = (LongInfo)getItem(index);
+ return i.value;
+ }
+
+ /**
+ * Reads <code>CONSTANT_Double_info</code> structure
+ * at the given index.
+ *
+ * @return the value specified by this entry.
+ */
+ public double getDoubleInfo(int index) {
+ DoubleInfo i = (DoubleInfo)getItem(index);
+ return i.value;
+ }
+
+ /**
+ * Reads <code>CONSTANT_String_info</code> structure
+ * at the given index.
+ *
+ * @return the string specified by <code>string_index</code>.
+ */
+ public String getStringInfo(int index) {
+ StringInfo si = (StringInfo)getItem(index);
+ return getUtf8Info(si.string);
+ }
+
+ /**
+ * Reads <code>CONSTANT_utf8_info</code> structure
+ * at the given index.
+ *
+ * @return the string specified by this entry.
+ */
+ public String getUtf8Info(int index) {
+ Utf8Info utf = (Utf8Info)getItem(index);
+ return utf.string;
+ }
+
+ /**
+ * Determines whether <code>CONSTANT_Methodref_info</code>
+ * structure at the given index represents the constructor
+ * of the given class.
+ *
+ * @return the <code>descriptor_index</code> specifying
+ * the type descriptor of the that constructor.
+ * If it is not that constructor,
+ * <code>isConstructor()</code> returns 0.
+ */
+ public int isConstructor(String classname, int index) {
+ return isMember(classname, MethodInfo.nameInit, index);
+ }
+
+ /**
+ * Determines whether <code>CONSTANT_Methodref_info</code>,
+ * <code>CONSTANT_Fieldref_info</code>, or
+ * <code>CONSTANT_InterfaceMethodref_info</code> structure
+ * at the given index represents the member with the specified
+ * name and declaring class.
+ *
+ * @param classname the class declaring the member
+ * @param membername the member name
+ * @param index the index into the constant pool table
+ *
+ * @return the <code>descriptor_index</code> specifying
+ * the type descriptor of that member.
+ * If it is not that member,
+ * <code>isMember()</code> returns 0.
+ */
+ public int isMember(String classname, String membername, int index) {
+ MemberrefInfo minfo = (MemberrefInfo)getItem(index);
+ if (getClassInfo(minfo.classIndex).equals(classname)) {
+ NameAndTypeInfo ntinfo
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if (getUtf8Info(ntinfo.memberName).equals(membername))
+ return ntinfo.typeDescriptor;
+ }
+
+ return 0; // false
+ }
+
+ /**
+ * Determines whether <code>CONSTANT_Methodref_info</code>,
+ * <code>CONSTANT_Fieldref_info</code>, or
+ * <code>CONSTANT_InterfaceMethodref_info</code> structure
+ * at the given index has the name and the descriptor
+ * given as the arguments.
+ *
+ * @param membername the member name
+ * @param desc the descriptor of the member.
+ * @param index the index into the constant pool table
+ *
+ * @return the name of the target class specified by
+ * the <code>..._info</code> structure
+ * at <code>index</code>.
+ * Otherwise, null if that structure does not
+ * match the given member name and descriptor.
+ */
+ public String eqMember(String membername, String desc, int index) {
+ MemberrefInfo minfo = (MemberrefInfo)getItem(index);
+ NameAndTypeInfo ntinfo
+ = (NameAndTypeInfo)getItem(minfo.nameAndTypeIndex);
+ if (getUtf8Info(ntinfo.memberName).equals(membername)
+ && getUtf8Info(ntinfo.typeDescriptor).equals(desc))
+ return getClassInfo(minfo.classIndex);
+ else
+ return null; // false
+ }
+
+ private int addItem(ConstInfo info) {
+ items.addElement(info);
+ return numOfItems++;
+ }
+
+ /**
+ * Copies the n-th item in this ConstPool object into the destination
+ * ConstPool object.
+ * The class names that the item refers to are renamed according
+ * to the given map.
+ *
+ * @param n the <i>n</i>-th item
+ * @param dest destination constant pool table
+ * @param classnames the map or null.
+ * @return the index of the copied item into the destination ClassPool.
+ */
+ public int copy(int n, ConstPool dest, Map classnames) {
+ if (n == 0)
+ return 0;
+
+ ConstInfo info = getItem(n);
+ return info.copy(this, dest, classnames);
+ }
+
+ int addConstInfoPadding() {
+ return addItem(new ConstInfoPadding());
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Class_info</code> structure.
+ *
+ * <p>This also adds a <code>CONSTANT_Utf8_info</code> structure
+ * for storing the class name.
+ *
+ * @return the index of the added entry.
+ */
+ public int addClassInfo(CtClass c) {
+ if (c == THIS)
+ return thisClassInfo;
+ else if (!c.isArray())
+ return addClassInfo(c.getName());
+ else {
+ // an array type is recorded in the hashtable with
+ // the key "[L<classname>;" instead of "<classname>".
+ //
+ // note: toJvmName(toJvmName(c)) is equal to toJvmName(c).
+
+ return addClassInfo(Descriptor.toJvmName(c));
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Class_info</code> structure.
+ *
+ * <p>This also adds a <code>CONSTANT_Utf8_info</code> structure
+ * for storing the class name.
+ *
+ * @param qname a fully-qualified class name
+ * (or the JVM-internal representation of that name).
+ * @return the index of the added entry.
+ */
+ public int addClassInfo(String qname) {
+ ClassInfo info = (ClassInfo)classes.get(qname);
+ if (info != null)
+ return info.index;
+ else {
+ int utf8 = addUtf8Info(Descriptor.toJvmName(qname));
+ info = new ClassInfo(utf8, numOfItems);
+ classes.put(qname, info);
+ return addItem(info);
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
+ *
+ * <p>This also adds <code>CONSTANT_Utf8_info</code> structures.
+ *
+ * @param name <code>name_index</code>
+ * @param type <code>descriptor_index</code>
+ * @return the index of the added entry.
+ */
+ public int addNameAndTypeInfo(String name, String type) {
+ return addNameAndTypeInfo(addUtf8Info(name), addUtf8Info(type));
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_NameAndType_info</code> structure.
+ *
+ * @param name <code>name_index</code>
+ * @param type <code>descriptor_index</code>
+ * @return the index of the added entry.
+ */
+ public int addNameAndTypeInfo(int name, int type) {
+ int h = hashFunc(name, type);
+ ConstInfo ci = constInfoCache[h];
+ if (ci != null && ci instanceof NameAndTypeInfo && ci.hashCheck(name, type))
+ return constInfoIndexCache[h];
+ else {
+ NameAndTypeInfo item = new NameAndTypeInfo(name, type);
+ constInfoCache[h] = item;
+ int i = addItem(item);
+ constInfoIndexCache[h] = i;
+ return i;
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Fieldref_info</code> structure.
+ *
+ * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
+ * structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param name <code>name_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @param type <code>descriptor_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @return the index of the added entry.
+ */
+ public int addFieldrefInfo(int classInfo, String name, String type) {
+ int nt = addNameAndTypeInfo(name, type);
+ return addFieldrefInfo(classInfo, nt);
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Fieldref_info</code> structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addFieldrefInfo(int classInfo, int nameAndTypeInfo) {
+ int h = hashFunc(classInfo, nameAndTypeInfo);
+ ConstInfo ci = constInfoCache[h];
+ if (ci != null && ci instanceof FieldrefInfo && ci.hashCheck(classInfo, nameAndTypeInfo))
+ return constInfoIndexCache[h];
+ else {
+ FieldrefInfo item = new FieldrefInfo(classInfo, nameAndTypeInfo);
+ constInfoCache[h] = item;
+ int i = addItem(item);
+ constInfoIndexCache[h] = i;
+ return i;
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Methodref_info</code> structure.
+ *
+ * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
+ * structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param name <code>name_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @param type <code>descriptor_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @return the index of the added entry.
+ */
+ public int addMethodrefInfo(int classInfo, String name, String type) {
+ int nt = addNameAndTypeInfo(name, type);
+ return addMethodrefInfo(classInfo, nt);
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Methodref_info</code> structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addMethodrefInfo(int classInfo, int nameAndTypeInfo) {
+ int h = hashFunc(classInfo, nameAndTypeInfo);
+ ConstInfo ci = constInfoCache[h];
+ if (ci != null && ci instanceof MethodrefInfo && ci.hashCheck(classInfo, nameAndTypeInfo))
+ return constInfoIndexCache[h];
+ else {
+ MethodrefInfo item = new MethodrefInfo(classInfo, nameAndTypeInfo);
+ constInfoCache[h] = item;
+ int i = addItem(item);
+ constInfoIndexCache[h] = i;
+ return i;
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_InterfaceMethodref_info</code>
+ * structure.
+ *
+ * <p>This also adds a new <code>CONSTANT_NameAndType_info</code>
+ * structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param name <code>name_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @param type <code>descriptor_index</code>
+ * of <code>CONSTANT_NameAndType_info</code>.
+ * @return the index of the added entry.
+ */
+ public int addInterfaceMethodrefInfo(int classInfo, String name,
+ String type) {
+ int nt = addNameAndTypeInfo(name, type);
+ return addInterfaceMethodrefInfo(classInfo, nt);
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_InterfaceMethodref_info</code>
+ * structure.
+ *
+ * @param classInfo <code>class_index</code>
+ * @param nameAndTypeInfo <code>name_and_type_index</code>.
+ * @return the index of the added entry.
+ */
+ public int addInterfaceMethodrefInfo(int classInfo,
+ int nameAndTypeInfo) {
+ int h = hashFunc(classInfo, nameAndTypeInfo);
+ ConstInfo ci = constInfoCache[h];
+ if (ci != null && ci instanceof InterfaceMethodrefInfo && ci.hashCheck(classInfo, nameAndTypeInfo))
+ return constInfoIndexCache[h];
+ else {
+ InterfaceMethodrefInfo item =new InterfaceMethodrefInfo(classInfo, nameAndTypeInfo);
+ constInfoCache[h] = item;
+ int i = addItem(item);
+ constInfoIndexCache[h] = i;
+ return i;
+ }
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_String_info</code>
+ * structure.
+ *
+ * <p>This also adds a new <code>CONSTANT_Utf8_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addStringInfo(String str) {
+ return addItem(new StringInfo(addUtf8Info(str)));
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Integer_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addIntegerInfo(int i) {
+ return addItem(new IntegerInfo(i));
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Float_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addFloatInfo(float f) {
+ return addItem(new FloatInfo(f));
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Long_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addLongInfo(long l) {
+ int i = addItem(new LongInfo(l));
+ addItem(new ConstInfoPadding());
+ return i;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Double_info</code>
+ * structure.
+ *
+ * @return the index of the added entry.
+ */
+ public int addDoubleInfo(double d) {
+ int i = addItem(new DoubleInfo(d));
+ addItem(new ConstInfoPadding());
+ return i;
+ }
+
+ /**
+ * Adds a new <code>CONSTANT_Utf8_info</code>
+ * structure.
+ *
+ * <p>If the given utf8 string has been already recorded in the
+ * table, then this method does not add a new entry to avoid adding
+ * a duplicated entry.
+ * Instead, it returns the index of the entry already recorded.
+ *
+ * @return the index of the added entry.
+ */
+ public int addUtf8Info(String utf8) {
+ Utf8Info info = (Utf8Info)strings.get(utf8);
+ if (info != null)
+ return info.index;
+ else {
+ info = new Utf8Info(utf8, numOfItems);
+ strings.put(utf8, info);
+ return addItem(info);
+ }
+ }
+
+ /**
+ * Get all the class names.
+ *
+ * @return a set of class names
+ */
+ public Set getClassNames()
+ {
+ HashSet result = new HashSet();
+ LongVector v = items;
+ int size = numOfItems;
+ for (int i = 1; i < size; ++i) {
+ String className = v.elementAt(i).getClassName(this);
+ if (className != null)
+ result.add(className);
+ }
+ return result;
+ }
+
+ /**
+ * Replaces all occurrences of a class name.
+ *
+ * @param oldName the replaced name (JVM-internal representation).
+ * @param newName the substituted name (JVM-internal representation).
+ */
+ public void renameClass(String oldName, String newName) {
+ LongVector v = items;
+ int size = numOfItems;
+ classes = new HashMap(classes.size() * 2);
+ for (int i = 1; i < size; ++i) {
+ ConstInfo ci = v.elementAt(i);
+ ci.renameClass(this, oldName, newName);
+ ci.makeHashtable(this);
+ }
+ }
+
+ /**
+ * Replaces all occurrences of class names.
+ *
+ * @param classnames specifies pairs of replaced and substituted
+ * name.
+ */
+ public void renameClass(Map classnames) {
+ LongVector v = items;
+ int size = numOfItems;
+ classes = new HashMap(classes.size() * 2);
+ for (int i = 1; i < size; ++i) {
+ ConstInfo ci = v.elementAt(i);
+ ci.renameClass(this, classnames);
+ ci.makeHashtable(this);
+ }
+ }
+
+ private void read(DataInputStream in) throws IOException {
+ int n = in.readUnsignedShort();
+
+ items = new LongVector(n);
+ numOfItems = 0;
+ addItem(null); // index 0 is reserved by the JVM.
+
+ while (--n > 0) { // index 0 is reserved by JVM
+ int tag = readOne(in);
+ if ((tag == LongInfo.tag) || (tag == DoubleInfo.tag)) {
+ addItem(new ConstInfoPadding());
+ --n;
+ }
+ }
+
+ int i = 1;
+ while (true) {
+ ConstInfo info = items.elementAt(i++);
+ if (info == null)
+ break;
+ else
+ info.makeHashtable(this);
+ }
+ }
+
+ private int readOne(DataInputStream in) throws IOException {
+ ConstInfo info;
+ int tag = in.readUnsignedByte();
+ switch (tag) {
+ case Utf8Info.tag : // 1
+ info = new Utf8Info(in, numOfItems);
+ strings.put(((Utf8Info)info).string, info);
+ break;
+ case IntegerInfo.tag : // 3
+ info = new IntegerInfo(in);
+ break;
+ case FloatInfo.tag : // 4
+ info = new FloatInfo(in);
+ break;
+ case LongInfo.tag : // 5
+ info = new LongInfo(in);
+ break;
+ case DoubleInfo.tag : // 6
+ info = new DoubleInfo(in);
+ break;
+ case ClassInfo.tag : // 7
+ info = new ClassInfo(in, numOfItems);
+ // classes.put(<classname>, info);
+ break;
+ case StringInfo.tag : // 8
+ info = new StringInfo(in);
+ break;
+ case FieldrefInfo.tag : // 9
+ info = new FieldrefInfo(in);
+ break;
+ case MethodrefInfo.tag : // 10
+ info = new MethodrefInfo(in);
+ break;
+ case InterfaceMethodrefInfo.tag : // 11
+ info = new InterfaceMethodrefInfo(in);
+ break;
+ case NameAndTypeInfo.tag : // 12
+ info = new NameAndTypeInfo(in);
+ break;
+ default :
+ throw new IOException("invalid constant type: " + tag);
+ }
+
+ addItem(info);
+ return tag;
+ }
+
+ /**
+ * Writes the contents of the constant pool table.
+ */
+ public void write(DataOutputStream out) throws IOException {
+ out.writeShort(numOfItems);
+ LongVector v = items;
+ int size = numOfItems;
+ for (int i = 1; i < size; ++i)
+ v.elementAt(i).write(out);
+ }
+
+ /**
+ * Prints the contents of the constant pool table.
+ */
+ public void print() {
+ print(new PrintWriter(System.out, true));
+ }
+
+ /**
+ * Prints the contents of the constant pool table.
+ */
+ public void print(PrintWriter out) {
+ int size = numOfItems;
+ for (int i = 1; i < size; ++i) {
+ out.print(i);
+ out.print(" ");
+ items.elementAt(i).print(out);
+ }
+ }
+}
+
+abstract class ConstInfo {
+ public abstract int getTag();
+
+ public String getClassName(ConstPool cp) { return null; }
+ public void renameClass(ConstPool cp, String oldName, String newName) {}
+ public void renameClass(ConstPool cp, Map classnames) {}
+ public abstract int copy(ConstPool src, ConstPool dest, Map classnames);
+ // ** classnames is a mapping between JVM names.
+
+ public abstract void write(DataOutputStream out) throws IOException;
+ public abstract void print(PrintWriter out);
+
+ void makeHashtable(ConstPool cp) {} // called after read() finishes in ConstPool.
+
+ boolean hashCheck(int a, int b) { return false; }
+
+ public String toString() {
+ ByteArrayOutputStream bout = new ByteArrayOutputStream();
+ PrintWriter out = new PrintWriter(bout);
+ print(out);
+ return bout.toString();
+ }
+}
+
+/* padding following DoubleInfo or LongInfo.
+ */
+class ConstInfoPadding extends ConstInfo {
+ public int getTag() { return 0; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addConstInfoPadding();
+ }
+
+ public void write(DataOutputStream out) throws IOException {}
+
+ public void print(PrintWriter out) {
+ out.println("padding");
+ }
+}
+
+class ClassInfo extends ConstInfo {
+ static final int tag = 7;
+ int name;
+ int index;
+
+ public ClassInfo(int className, int i) {
+ name = className;
+ index = i;
+ }
+
+ public ClassInfo(DataInputStream in, int i) throws IOException {
+ name = in.readUnsignedShort();
+ index = i;
+ }
+
+ public int getTag() { return tag; }
+
+ public String getClassName(ConstPool cp) {
+ return cp.getUtf8Info(name);
+ };
+
+ public void renameClass(ConstPool cp, String oldName, String newName) {
+ String nameStr = cp.getUtf8Info(name);
+ if (nameStr.equals(oldName))
+ name = cp.addUtf8Info(newName);
+ else if (nameStr.charAt(0) == '[') {
+ String nameStr2 = Descriptor.rename(nameStr, oldName, newName);
+ if (nameStr != nameStr2)
+ name = cp.addUtf8Info(nameStr2);
+ }
+ }
+
+ public void renameClass(ConstPool cp, Map map) {
+ String oldName = cp.getUtf8Info(name);
+ if (oldName.charAt(0) == '[') {
+ String newName = Descriptor.rename(oldName, map);
+ if (oldName != newName)
+ name = cp.addUtf8Info(newName);
+ }
+ else {
+ String newName = (String)map.get(oldName);
+ if (newName != null && !newName.equals(oldName))
+ name = cp.addUtf8Info(newName);
+ }
+ }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ String classname = src.getUtf8Info(name);
+ if (map != null) {
+ String newname = (String)map.get(classname);
+ if (newname != null)
+ classname = newname;
+ }
+
+ return dest.addClassInfo(classname);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeShort(name);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("Class #");
+ out.println(name);
+ }
+
+ void makeHashtable(ConstPool cp) {
+ String name = Descriptor.toJavaName(getClassName(cp));
+ cp.classes.put(name, this);
+ }
+}
+
+class NameAndTypeInfo extends ConstInfo {
+ static final int tag = 12;
+ int memberName;
+ int typeDescriptor;
+
+ public NameAndTypeInfo(int name, int type) {
+ memberName = name;
+ typeDescriptor = type;
+ }
+
+ public NameAndTypeInfo(DataInputStream in) throws IOException {
+ memberName = in.readUnsignedShort();
+ typeDescriptor = in.readUnsignedShort();
+ }
+
+ boolean hashCheck(int a, int b) { return a == memberName && b == typeDescriptor; }
+
+ public int getTag() { return tag; }
+
+ public void renameClass(ConstPool cp, String oldName, String newName) {
+ String type = cp.getUtf8Info(typeDescriptor);
+ String type2 = Descriptor.rename(type, oldName, newName);
+ if (type != type2)
+ typeDescriptor = cp.addUtf8Info(type2);
+ }
+
+ public void renameClass(ConstPool cp, Map map) {
+ String type = cp.getUtf8Info(typeDescriptor);
+ String type2 = Descriptor.rename(type, map);
+ if (type != type2)
+ typeDescriptor = cp.addUtf8Info(type2);
+ }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ String mname = src.getUtf8Info(memberName);
+ String tdesc = src.getUtf8Info(typeDescriptor);
+ tdesc = Descriptor.rename(tdesc, map);
+ return dest.addNameAndTypeInfo(dest.addUtf8Info(mname),
+ dest.addUtf8Info(tdesc));
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeShort(memberName);
+ out.writeShort(typeDescriptor);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("NameAndType #");
+ out.print(memberName);
+ out.print(", type #");
+ out.println(typeDescriptor);
+ }
+}
+
+abstract class MemberrefInfo extends ConstInfo {
+ int classIndex;
+ int nameAndTypeIndex;
+
+ public MemberrefInfo(int cindex, int ntindex) {
+ classIndex = cindex;
+ nameAndTypeIndex = ntindex;
+ }
+
+ public MemberrefInfo(DataInputStream in) throws IOException {
+ classIndex = in.readUnsignedShort();
+ nameAndTypeIndex = in.readUnsignedShort();
+ }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ int classIndex2 = src.getItem(classIndex).copy(src, dest, map);
+ int ntIndex2 = src.getItem(nameAndTypeIndex).copy(src, dest, map);
+ return copy2(dest, classIndex2, ntIndex2);
+ }
+
+ boolean hashCheck(int a, int b) { return a == classIndex && b == nameAndTypeIndex; }
+
+ abstract protected int copy2(ConstPool dest, int cindex, int ntindex);
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(getTag());
+ out.writeShort(classIndex);
+ out.writeShort(nameAndTypeIndex);
+ }
+
+ public void print(PrintWriter out) {
+ out.print(getTagName() + " #");
+ out.print(classIndex);
+ out.print(", name&type #");
+ out.println(nameAndTypeIndex);
+ }
+
+ public abstract String getTagName();
+}
+
+class FieldrefInfo extends MemberrefInfo {
+ static final int tag = 9;
+
+ public FieldrefInfo(int cindex, int ntindex) {
+ super(cindex, ntindex);
+ }
+
+ public FieldrefInfo(DataInputStream in) throws IOException {
+ super(in);
+ }
+
+ public int getTag() { return tag; }
+
+ public String getTagName() { return "Field"; }
+
+ protected int copy2(ConstPool dest, int cindex, int ntindex) {
+ return dest.addFieldrefInfo(cindex, ntindex);
+ }
+}
+
+class MethodrefInfo extends MemberrefInfo {
+ static final int tag = 10;
+
+ public MethodrefInfo(int cindex, int ntindex) {
+ super(cindex, ntindex);
+ }
+
+ public MethodrefInfo(DataInputStream in) throws IOException {
+ super(in);
+ }
+
+ public int getTag() { return tag; }
+
+ public String getTagName() { return "Method"; }
+
+ protected int copy2(ConstPool dest, int cindex, int ntindex) {
+ return dest.addMethodrefInfo(cindex, ntindex);
+ }
+}
+
+class InterfaceMethodrefInfo extends MemberrefInfo {
+ static final int tag = 11;
+
+ public InterfaceMethodrefInfo(int cindex, int ntindex) {
+ super(cindex, ntindex);
+ }
+
+ public InterfaceMethodrefInfo(DataInputStream in) throws IOException {
+ super(in);
+ }
+
+ public int getTag() { return tag; }
+
+ public String getTagName() { return "Interface"; }
+
+ protected int copy2(ConstPool dest, int cindex, int ntindex) {
+ return dest.addInterfaceMethodrefInfo(cindex, ntindex);
+ }
+}
+
+class StringInfo extends ConstInfo {
+ static final int tag = 8;
+ int string;
+
+ public StringInfo(int str) {
+ string = str;
+ }
+
+ public StringInfo(DataInputStream in) throws IOException {
+ string = in.readUnsignedShort();
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addStringInfo(src.getUtf8Info(string));
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeShort(string);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("String #");
+ out.println(string);
+ }
+}
+
+class IntegerInfo extends ConstInfo {
+ static final int tag = 3;
+ int value;
+
+ public IntegerInfo(int i) {
+ value = i;
+ }
+
+ public IntegerInfo(DataInputStream in) throws IOException {
+ value = in.readInt();
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addIntegerInfo(value);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeInt(value);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("Integer ");
+ out.println(value);
+ }
+}
+
+class FloatInfo extends ConstInfo {
+ static final int tag = 4;
+ float value;
+
+ public FloatInfo(float f) {
+ value = f;
+ }
+
+ public FloatInfo(DataInputStream in) throws IOException {
+ value = in.readFloat();
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addFloatInfo(value);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeFloat(value);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("Float ");
+ out.println(value);
+ }
+}
+
+class LongInfo extends ConstInfo {
+ static final int tag = 5;
+ long value;
+
+ public LongInfo(long l) {
+ value = l;
+ }
+
+ public LongInfo(DataInputStream in) throws IOException {
+ value = in.readLong();
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addLongInfo(value);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeLong(value);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("Long ");
+ out.println(value);
+ }
+}
+
+class DoubleInfo extends ConstInfo {
+ static final int tag = 6;
+ double value;
+
+ public DoubleInfo(double d) {
+ value = d;
+ }
+
+ public DoubleInfo(DataInputStream in) throws IOException {
+ value = in.readDouble();
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addDoubleInfo(value);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeDouble(value);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("Double ");
+ out.println(value);
+ }
+}
+
+class Utf8Info extends ConstInfo {
+ static final int tag = 1;
+ String string;
+ int index;
+
+ public Utf8Info(String utf8, int i) {
+ string = utf8;
+ index = i;
+ }
+
+ public Utf8Info(DataInputStream in, int i) throws IOException {
+ string = in.readUTF();
+ index = i;
+ }
+
+ public int getTag() { return tag; }
+
+ public int copy(ConstPool src, ConstPool dest, Map map) {
+ return dest.addUtf8Info(string);
+ }
+
+ public void write(DataOutputStream out) throws IOException {
+ out.writeByte(tag);
+ out.writeUTF(string);
+ }
+
+ public void print(PrintWriter out) {
+ out.print("UTF8 \"");
+ out.print(string);
+ out.println("\"");
+ }
+}
diff --git a/src/main/javassist/bytecode/ConstantAttribute.java b/src/main/javassist/bytecode/ConstantAttribute.java
new file mode 100644
index 0000000..47f993b
--- /dev/null
+++ b/src/main/javassist/bytecode/ConstantAttribute.java
@@ -0,0 +1,72 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.util.Map;
+import java.io.IOException;
+
+/**
+ * <code>ConstantValue_attribute</code>.
+ */
+public class ConstantAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"ConstantValue"</code>.
+ */
+ public static final String tag = "ConstantValue";
+
+ ConstantAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a ConstantValue attribute.
+ *
+ * @param cp a constant pool table.
+ * @param index <code>constantvalue_index</code>
+ * of <code>ConstantValue_attribute</code>.
+ */
+ public ConstantAttribute(ConstPool cp, int index) {
+ super(cp, tag);
+ byte[] bvalue = new byte[2];
+ bvalue[0] = (byte)(index >>> 8);
+ bvalue[1] = (byte)index;
+ set(bvalue);
+ }
+
+ /**
+ * Returns <code>constantvalue_index</code>.
+ */
+ public int getConstantValue() {
+ return ByteArray.readU16bit(get(), 0);
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ int index = getConstPool().copy(getConstantValue(), newCp,
+ classnames);
+ return new ConstantAttribute(newCp, index);
+ }
+}
diff --git a/src/main/javassist/bytecode/DeprecatedAttribute.java b/src/main/javassist/bytecode/DeprecatedAttribute.java
new file mode 100644
index 0000000..41099ce
--- /dev/null
+++ b/src/main/javassist/bytecode/DeprecatedAttribute.java
@@ -0,0 +1,55 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>Deprecated_attribute</code>.
+ */
+public class DeprecatedAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"Deprecated"</code>.
+ */
+ public static final String tag = "Deprecated";
+
+ DeprecatedAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a Deprecated attribute.
+ *
+ * @param cp a constant pool table.
+ */
+ public DeprecatedAttribute(ConstPool cp) {
+ super(cp, tag, new byte[0]);
+ }
+
+ /**
+ * Makes a copy.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames should be null.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ return new DeprecatedAttribute(newCp);
+ }
+}
diff --git a/src/main/javassist/bytecode/Descriptor.java b/src/main/javassist/bytecode/Descriptor.java
new file mode 100644
index 0000000..5662222
--- /dev/null
+++ b/src/main/javassist/bytecode/Descriptor.java
@@ -0,0 +1,871 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtPrimitiveType;
+import javassist.NotFoundException;
+import java.util.Map;
+
+/**
+ * A support class for dealing with descriptors.
+ *
+ * <p>See chapter 4.3 in "The Java Virtual Machine Specification (2nd ed.)"
+ */
+public class Descriptor {
+ /**
+ * Converts a class name into the internal representation used in
+ * the JVM.
+ *
+ * <p>Note that <code>toJvmName(toJvmName(s))</code> is equivalent
+ * to <code>toJvmName(s)</code>.
+ */
+ public static String toJvmName(String classname) {
+ return classname.replace('.', '/');
+ }
+
+ /**
+ * Converts a class name from the internal representation used in
+ * the JVM to the normal one used in Java.
+ * This method does not deal with an array type name such as
+ * "[Ljava/lang/Object;" and "[I;". For such names, use
+ * <code>toClassName()</code>.
+ *
+ * @see #toClassName(String)
+ */
+ public static String toJavaName(String classname) {
+ return classname.replace('/', '.');
+ }
+
+ /**
+ * Returns the internal representation of the class name in the
+ * JVM.
+ */
+ public static String toJvmName(CtClass clazz) {
+ if (clazz.isArray())
+ return of(clazz);
+ else
+ return toJvmName(clazz.getName());
+ }
+
+ /**
+ * Converts to a Java class name from a descriptor.
+ *
+ * @param descriptor type descriptor.
+ */
+ public static String toClassName(String descriptor) {
+ int arrayDim = 0;
+ int i = 0;
+ char c = descriptor.charAt(0);
+ while (c == '[') {
+ ++arrayDim;
+ c = descriptor.charAt(++i);
+ }
+
+ String name;
+ if (c == 'L') {
+ int i2 = descriptor.indexOf(';', i++);
+ name = descriptor.substring(i, i2).replace('/', '.');
+ i = i2;
+ }
+ else if (c == 'V')
+ name = "void";
+ else if (c == 'I')
+ name = "int";
+ else if (c == 'B')
+ name = "byte";
+ else if (c == 'J')
+ name = "long";
+ else if (c == 'D')
+ name = "double";
+ else if (c == 'F')
+ name = "float";
+ else if (c == 'C')
+ name = "char";
+ else if (c == 'S')
+ name = "short";
+ else if (c == 'Z')
+ name = "boolean";
+ else
+ throw new RuntimeException("bad descriptor: " + descriptor);
+
+ if (i + 1 != descriptor.length())
+ throw new RuntimeException("multiple descriptors?: " + descriptor);
+
+ if (arrayDim == 0)
+ return name;
+ else {
+ StringBuffer sbuf = new StringBuffer(name);
+ do {
+ sbuf.append("[]");
+ } while (--arrayDim > 0);
+
+ return sbuf.toString();
+ }
+ }
+
+ /**
+ * Converts to a descriptor from a Java class name
+ */
+ public static String of(String classname) {
+ if (classname.equals("void"))
+ return "V";
+ else if (classname.equals("int"))
+ return "I";
+ else if (classname.equals("byte"))
+ return "B";
+ else if (classname.equals("long"))
+ return "J";
+ else if (classname.equals("double"))
+ return "D";
+ else if (classname.equals("float"))
+ return "F";
+ else if (classname.equals("char"))
+ return "C";
+ else if (classname.equals("short"))
+ return "S";
+ else if (classname.equals("boolean"))
+ return "Z";
+ else
+ return "L" + toJvmName(classname) + ";";
+ }
+
+ /**
+ * Substitutes a class name
+ * in the given descriptor string.
+ *
+ * @param desc descriptor string
+ * @param oldname replaced JVM class name
+ * @param newname substituted JVM class name
+ *
+ * @see Descriptor#toJvmName(String)
+ */
+ public static String rename(String desc, String oldname, String newname) {
+ if (desc.indexOf(oldname) < 0)
+ return desc;
+
+ StringBuffer newdesc = new StringBuffer();
+ int head = 0;
+ int i = 0;
+ for (;;) {
+ int j = desc.indexOf('L', i);
+ if (j < 0)
+ break;
+ else if (desc.startsWith(oldname, j + 1)
+ && desc.charAt(j + oldname.length() + 1) == ';') {
+ newdesc.append(desc.substring(head, j));
+ newdesc.append('L');
+ newdesc.append(newname);
+ newdesc.append(';');
+ head = i = j + oldname.length() + 2;
+ }
+ else {
+ i = desc.indexOf(';', j) + 1;
+ if (i < 1)
+ break; // ';' was not found.
+ }
+ }
+
+ if (head == 0)
+ return desc;
+ else {
+ int len = desc.length();
+ if (head < len)
+ newdesc.append(desc.substring(head, len));
+
+ return newdesc.toString();
+ }
+ }
+
+ /**
+ * Substitutes class names in the given descriptor string
+ * according to the given <code>map</code>.
+ *
+ * @param map a map between replaced and substituted
+ * JVM class names.
+ * @see Descriptor#toJvmName(String)
+ */
+ public static String rename(String desc, Map map) {
+ if (map == null)
+ return desc;
+
+ StringBuffer newdesc = new StringBuffer();
+ int head = 0;
+ int i = 0;
+ for (;;) {
+ int j = desc.indexOf('L', i);
+ if (j < 0)
+ break;
+
+ int k = desc.indexOf(';', j);
+ if (k < 0)
+ break;
+
+ i = k + 1;
+ String name = desc.substring(j + 1, k);
+ String name2 = (String)map.get(name);
+ if (name2 != null) {
+ newdesc.append(desc.substring(head, j));
+ newdesc.append('L');
+ newdesc.append(name2);
+ newdesc.append(';');
+ head = i;
+ }
+ }
+
+ if (head == 0)
+ return desc;
+ else {
+ int len = desc.length();
+ if (head < len)
+ newdesc.append(desc.substring(head, len));
+
+ return newdesc.toString();
+ }
+ }
+
+ /**
+ * Returns the descriptor representing the given type.
+ */
+ public static String of(CtClass type) {
+ StringBuffer sbuf = new StringBuffer();
+ toDescriptor(sbuf, type);
+ return sbuf.toString();
+ }
+
+ private static void toDescriptor(StringBuffer desc, CtClass type) {
+ if (type.isArray()) {
+ desc.append('[');
+ try {
+ toDescriptor(desc, type.getComponentType());
+ }
+ catch (NotFoundException e) {
+ desc.append('L');
+ String name = type.getName();
+ desc.append(toJvmName(name.substring(0, name.length() - 2)));
+ desc.append(';');
+ }
+ }
+ else if (type.isPrimitive()) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ desc.append(pt.getDescriptor());
+ }
+ else { // class type
+ desc.append('L');
+ desc.append(type.getName().replace('.', '/'));
+ desc.append(';');
+ }
+ }
+
+ /**
+ * Returns the descriptor representing a constructor receiving
+ * the given parameter types.
+ *
+ * @param paramTypes parameter types
+ */
+ public static String ofConstructor(CtClass[] paramTypes) {
+ return ofMethod(CtClass.voidType, paramTypes);
+ }
+
+ /**
+ * Returns the descriptor representing a method that receives
+ * the given parameter types and returns the given type.
+ *
+ * @param returnType return type
+ * @param paramTypes parameter types
+ */
+ public static String ofMethod(CtClass returnType, CtClass[] paramTypes) {
+ StringBuffer desc = new StringBuffer();
+ desc.append('(');
+ if (paramTypes != null) {
+ int n = paramTypes.length;
+ for (int i = 0; i < n; ++i)
+ toDescriptor(desc, paramTypes[i]);
+ }
+
+ desc.append(')');
+ if (returnType != null)
+ toDescriptor(desc, returnType);
+
+ return desc.toString();
+ }
+
+ /**
+ * Returns the descriptor representing a list of parameter types.
+ * For example, if the given parameter types are two <code>int</code>,
+ * then this method returns <code>"(II)"</code>.
+ *
+ * @param paramTypes parameter types
+ */
+ public static String ofParameters(CtClass[] paramTypes) {
+ return ofMethod(null, paramTypes);
+ }
+
+ /**
+ * Appends a parameter type to the parameter list represented
+ * by the given descriptor.
+ *
+ * <p><code>classname</code> must not be an array type.
+ *
+ * @param classname parameter type (not primitive type)
+ * @param desc descriptor
+ */
+ public static String appendParameter(String classname, String desc) {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ return desc;
+ else {
+ StringBuffer newdesc = new StringBuffer();
+ newdesc.append(desc.substring(0, i));
+ newdesc.append('L');
+ newdesc.append(classname.replace('.', '/'));
+ newdesc.append(';');
+ newdesc.append(desc.substring(i));
+ return newdesc.toString();
+ }
+ }
+
+ /**
+ * Inserts a parameter type at the beginning of the parameter
+ * list represented
+ * by the given descriptor.
+ *
+ * <p><code>classname</code> must not be an array type.
+ *
+ * @param classname parameter type (not primitive type)
+ * @param desc descriptor
+ */
+ public static String insertParameter(String classname, String desc) {
+ if (desc.charAt(0) != '(')
+ return desc;
+ else
+ return "(L" + classname.replace('.', '/') + ';'
+ + desc.substring(1);
+ }
+
+ /**
+ * Appends a parameter type to the parameter list represented
+ * by the given descriptor. The appended parameter becomes
+ * the last parameter.
+ *
+ * @param type the type of the appended parameter.
+ * @param descriptor the original descriptor.
+ */
+ public static String appendParameter(CtClass type, String descriptor) {
+ int i = descriptor.indexOf(')');
+ if (i < 0)
+ return descriptor;
+ else {
+ StringBuffer newdesc = new StringBuffer();
+ newdesc.append(descriptor.substring(0, i));
+ toDescriptor(newdesc, type);
+ newdesc.append(descriptor.substring(i));
+ return newdesc.toString();
+ }
+ }
+
+ /**
+ * Inserts a parameter type at the beginning of the parameter
+ * list represented
+ * by the given descriptor.
+ *
+ * @param type the type of the inserted parameter.
+ * @param descriptor the descriptor of the method.
+ */
+ public static String insertParameter(CtClass type,
+ String descriptor) {
+ if (descriptor.charAt(0) != '(')
+ return descriptor;
+ else
+ return "(" + of(type) + descriptor.substring(1);
+ }
+
+ /**
+ * Changes the return type included in the given descriptor.
+ *
+ * <p><code>classname</code> must not be an array type.
+ *
+ * @param classname return type
+ * @param desc descriptor
+ */
+ public static String changeReturnType(String classname, String desc) {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ return desc;
+ else {
+ StringBuffer newdesc = new StringBuffer();
+ newdesc.append(desc.substring(0, i + 1));
+ newdesc.append('L');
+ newdesc.append(classname.replace('.', '/'));
+ newdesc.append(';');
+ return newdesc.toString();
+ }
+ }
+
+ /**
+ * Returns the <code>CtClass</code> objects representing the parameter
+ * types specified by the given descriptor.
+ *
+ * @param desc descriptor
+ * @param cp the class pool used for obtaining
+ * a <code>CtClass</code> object.
+ */
+ public static CtClass[] getParameterTypes(String desc, ClassPool cp)
+ throws NotFoundException
+ {
+ if (desc.charAt(0) != '(')
+ return null;
+ else {
+ int num = numOfParameters(desc);
+ CtClass[] args = new CtClass[num];
+ int n = 0;
+ int i = 1;
+ do {
+ i = toCtClass(cp, desc, i, args, n++);
+ } while (i > 0);
+ return args;
+ }
+ }
+
+ /**
+ * Returns true if the list of the parameter types of desc1 is equal to
+ * that of desc2.
+ * For example, "(II)V" and "(II)I" are equal.
+ */
+ public static boolean eqParamTypes(String desc1, String desc2) {
+ if (desc1.charAt(0) != '(')
+ return false;
+
+ for (int i = 0; true; ++i) {
+ char c = desc1.charAt(i);
+ if (c != desc2.charAt(i))
+ return false;
+
+ if (c == ')')
+ return true;
+ }
+ }
+
+ /**
+ * Returns the signature of the given descriptor. The signature does
+ * not include the return type. For example, the signature of "(I)V"
+ * is "(I)".
+ */
+ public static String getParamDescriptor(String decl) {
+ return decl.substring(0, decl.indexOf(')') + 1);
+ }
+
+ /**
+ * Returns the <code>CtClass</code> object representing the return
+ * type specified by the given descriptor.
+ *
+ * @param desc descriptor
+ * @param cp the class pool used for obtaining
+ * a <code>CtClass</code> object.
+ */
+ public static CtClass getReturnType(String desc, ClassPool cp)
+ throws NotFoundException
+ {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ return null;
+ else {
+ CtClass[] type = new CtClass[1];
+ toCtClass(cp, desc, i + 1, type, 0);
+ return type[0];
+ }
+ }
+
+ /**
+ * Returns the number of the prameters included in the given
+ * descriptor.
+ *
+ * @param desc descriptor
+ */
+ public static int numOfParameters(String desc) {
+ int n = 0;
+ int i = 1;
+ for (;;) {
+ char c = desc.charAt(i);
+ if (c == ')')
+ break;
+
+ while (c == '[')
+ c = desc.charAt(++i);
+
+ if (c == 'L') {
+ i = desc.indexOf(';', i) + 1;
+ if (i <= 0)
+ throw new IndexOutOfBoundsException("bad descriptor");
+ }
+ else
+ ++i;
+
+ ++n;
+ }
+
+ return n;
+ }
+
+ /**
+ * Returns a <code>CtClass</code> object representing the type
+ * specified by the given descriptor.
+ *
+ * <p>This method works even if the package-class separator is
+ * not <code>/</code> but <code>.</code> (period). For example,
+ * it accepts <code>Ljava.lang.Object;</code>
+ * as well as <code>Ljava/lang/Object;</code>.
+ *
+ * @param desc descriptor.
+ * @param cp the class pool used for obtaining
+ * a <code>CtClass</code> object.
+ */
+ public static CtClass toCtClass(String desc, ClassPool cp)
+ throws NotFoundException
+ {
+ CtClass[] clazz = new CtClass[1];
+ int res = toCtClass(cp, desc, 0, clazz, 0);
+ if (res >= 0)
+ return clazz[0];
+ else {
+ // maybe, you forgot to surround the class name with
+ // L and ;. It violates the protocol, but I'm tolerant...
+ return cp.get(desc.replace('/', '.'));
+ }
+ }
+
+ private static int toCtClass(ClassPool cp, String desc, int i,
+ CtClass[] args, int n)
+ throws NotFoundException
+ {
+ int i2;
+ String name;
+
+ int arrayDim = 0;
+ char c = desc.charAt(i);
+ while (c == '[') {
+ ++arrayDim;
+ c = desc.charAt(++i);
+ }
+
+ if (c == 'L') {
+ i2 = desc.indexOf(';', ++i);
+ name = desc.substring(i, i2++).replace('/', '.');
+ }
+ else {
+ CtClass type = toPrimitiveClass(c);
+ if (type == null)
+ return -1; // error
+
+ i2 = i + 1;
+ if (arrayDim == 0) {
+ args[n] = type;
+ return i2; // neither an array type or a class type
+ }
+ else
+ name = type.getName();
+ }
+
+ if (arrayDim > 0) {
+ StringBuffer sbuf = new StringBuffer(name);
+ while (arrayDim-- > 0)
+ sbuf.append("[]");
+
+ name = sbuf.toString();
+ }
+
+ args[n] = cp.get(name);
+ return i2;
+ }
+
+ static CtClass toPrimitiveClass(char c) {
+ CtClass type = null;
+ switch (c) {
+ case 'Z' :
+ type = CtClass.booleanType;
+ break;
+ case 'C' :
+ type = CtClass.charType;
+ break;
+ case 'B' :
+ type = CtClass.byteType;
+ break;
+ case 'S' :
+ type = CtClass.shortType;
+ break;
+ case 'I' :
+ type = CtClass.intType;
+ break;
+ case 'J' :
+ type = CtClass.longType;
+ break;
+ case 'F' :
+ type = CtClass.floatType;
+ break;
+ case 'D' :
+ type = CtClass.doubleType;
+ break;
+ case 'V' :
+ type = CtClass.voidType;
+ break;
+ }
+
+ return type;
+ }
+
+ /**
+ * Computes the dimension of the array represented by the given
+ * descriptor. For example, if the descriptor is <code>"[[I"</code>,
+ * then this method returns 2.
+ *
+ * @param desc the descriptor.
+ * @return 0 if the descriptor does not represent an array type.
+ */
+ public static int arrayDimension(String desc) {
+ int dim = 0;
+ while (desc.charAt(dim) == '[')
+ ++dim;
+
+ return dim;
+ }
+
+ /**
+ * Returns the descriptor of the type of the array component.
+ * For example, if the given descriptor is
+ * <code>"[[Ljava/lang/String;"</code> and the given dimension is 2,
+ * then this method returns <code>"Ljava/lang/String;"</code>.
+ *
+ * @param desc the descriptor.
+ * @param dim the array dimension.
+ */
+ public static String toArrayComponent(String desc, int dim) {
+ return desc.substring(dim);
+ }
+
+ /**
+ * Computes the data size specified by the given descriptor.
+ * For example, if the descriptor is "D", this method returns 2.
+ *
+ * <p>If the descriptor represents a method type, this method returns
+ * (the size of the returned value) - (the sum of the data sizes
+ * of all the parameters). For example, if the descriptor is
+ * <code>"(I)D"</code>, then this method returns 1 (= 2 - 1).
+ *
+ * @param desc descriptor
+ */
+ public static int dataSize(String desc) {
+ return dataSize(desc, true);
+ }
+
+ /**
+ * Computes the data size of parameters.
+ * If one of the parameters is double type, the size of that parameter
+ * is 2 words. For example, if the given descriptor is
+ * <code>"(IJ)D"</code>, then this method returns 3. The size of the
+ * return type is not computed.
+ *
+ * @param desc a method descriptor.
+ */
+ public static int paramSize(String desc) {
+ return -dataSize(desc, false);
+ }
+
+ private static int dataSize(String desc, boolean withRet) {
+ int n = 0;
+ char c = desc.charAt(0);
+ if (c == '(') {
+ int i = 1;
+ for (;;) {
+ c = desc.charAt(i);
+ if (c == ')') {
+ c = desc.charAt(i + 1);
+ break;
+ }
+
+ boolean array = false;
+ while (c == '[') {
+ array = true;
+ c = desc.charAt(++i);
+ }
+
+ if (c == 'L') {
+ i = desc.indexOf(';', i) + 1;
+ if (i <= 0)
+ throw new IndexOutOfBoundsException("bad descriptor");
+ }
+ else
+ ++i;
+
+ if (!array && (c == 'J' || c == 'D'))
+ n -= 2;
+ else
+ --n;
+ }
+ }
+
+ if (withRet)
+ if (c == 'J' || c == 'D')
+ n += 2;
+ else if (c != 'V')
+ ++n;
+
+ return n;
+ }
+
+ /**
+ * Returns a human-readable representation of the
+ * given descriptor. For example, <code>Ljava/lang/Object;</code>
+ * is converted into <code>java.lang.Object</code>.
+ * <code>(I[I)V</code> is converted into <code>(int, int[])</code>
+ * (the return type is ignored).
+ */
+ public static String toString(String desc) {
+ return PrettyPrinter.toString(desc);
+ }
+
+ static class PrettyPrinter {
+ static String toString(String desc) {
+ StringBuffer sbuf = new StringBuffer();
+ if (desc.charAt(0) == '(') {
+ int pos = 1;
+ sbuf.append('(');
+ while (desc.charAt(pos) != ')') {
+ if (pos > 1)
+ sbuf.append(',');
+
+ pos = readType(sbuf, pos, desc);
+ }
+
+ sbuf.append(')');
+ }
+ else
+ readType(sbuf, 0, desc);
+
+ return sbuf.toString();
+ }
+
+ static int readType(StringBuffer sbuf, int pos, String desc) {
+ char c = desc.charAt(pos);
+ int arrayDim = 0;
+ while (c == '[') {
+ arrayDim++;
+ c = desc.charAt(++pos);
+ }
+
+ if (c == 'L')
+ while (true) {
+ c = desc.charAt(++pos);
+ if (c == ';')
+ break;
+
+ if (c == '/')
+ c = '.';
+
+ sbuf.append(c);
+ }
+ else {
+ CtClass t = toPrimitiveClass(c);
+ sbuf.append(t.getName());
+ }
+
+ while (arrayDim-- > 0)
+ sbuf.append("[]");
+
+ return pos + 1;
+ }
+ }
+
+ /**
+ * An Iterator over a descriptor.
+ */
+ public static class Iterator {
+ private String desc;
+ private int index, curPos;
+ private boolean param;
+
+ /**
+ * Constructs an iterator.
+ *
+ * @param s descriptor.
+ */
+ public Iterator(String s) {
+ desc = s;
+ index = curPos = 0;
+ param = false;
+ }
+
+ /**
+ * Returns true if the iteration has more elements.
+ */
+ public boolean hasNext() {
+ return index < desc.length();
+ }
+
+ /**
+ * Returns true if the current element is a parameter type.
+ */
+ public boolean isParameter() { return param; }
+
+ /**
+ * Returns the first character of the current element.
+ */
+ public char currentChar() { return desc.charAt(curPos); }
+
+ /**
+ * Returns true if the current element is double or long type.
+ */
+ public boolean is2byte() {
+ char c = currentChar();
+ return c == 'D' || c == 'J';
+ }
+
+ /**
+ * Returns the position of the next type character.
+ * That type character becomes a new current element.
+ */
+ public int next() {
+ int nextPos = index;
+ char c = desc.charAt(nextPos);
+ if (c == '(') {
+ ++index;
+ c = desc.charAt(++nextPos);
+ param = true;
+ }
+
+ if (c == ')') {
+ ++index;
+ c = desc.charAt(++nextPos);
+ param = false;
+ }
+
+ while (c == '[')
+ c = desc.charAt(++nextPos);
+
+ if (c == 'L') {
+ nextPos = desc.indexOf(';', nextPos) + 1;
+ if (nextPos <= 0)
+ throw new IndexOutOfBoundsException("bad descriptor");
+ }
+ else
+ ++nextPos;
+
+ curPos = index;
+ index = nextPos;
+ return curPos;
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/DuplicateMemberException.java b/src/main/javassist/bytecode/DuplicateMemberException.java
new file mode 100644
index 0000000..7c1e0e6
--- /dev/null
+++ b/src/main/javassist/bytecode/DuplicateMemberException.java
@@ -0,0 +1,30 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import javassist.CannotCompileException;
+
+/**
+ * An exception thrown when adding a duplicate member is requested.
+ *
+ * @see ClassFile#addMethod(MethodInfo)
+ * @see ClassFile#addField(FieldInfo)
+ */
+public class DuplicateMemberException extends CannotCompileException {
+ public DuplicateMemberException(String msg) {
+ super(msg);
+ }
+}
diff --git a/src/main/javassist/bytecode/EnclosingMethodAttribute.java b/src/main/javassist/bytecode/EnclosingMethodAttribute.java
new file mode 100644
index 0000000..c924f50
--- /dev/null
+++ b/src/main/javassist/bytecode/EnclosingMethodAttribute.java
@@ -0,0 +1,133 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>EnclosingMethod_attribute</code>.
+ */
+public class EnclosingMethodAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"EnclosingMethod"</code>.
+ */
+ public static final String tag = "EnclosingMethod";
+
+ EnclosingMethodAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs an EnclosingMethod attribute.
+ *
+ * @param cp a constant pool table.
+ * @param className the name of the innermost enclosing class.
+ * @param methodName the name of the enclosing method.
+ * @param methodDesc the descriptor of the enclosing method.
+ */
+ public EnclosingMethodAttribute(ConstPool cp, String className,
+ String methodName, String methodDesc) {
+ super(cp, tag);
+ int ci = cp.addClassInfo(className);
+ int ni = cp.addNameAndTypeInfo(methodName, methodDesc);
+ byte[] bvalue = new byte[4];
+ bvalue[0] = (byte)(ci >>> 8);
+ bvalue[1] = (byte)ci;
+ bvalue[2] = (byte)(ni >>> 8);
+ bvalue[3] = (byte)ni;
+ set(bvalue);
+ }
+
+ /**
+ * Constructs an EnclosingMethod attribute.
+ * The value of <code>method_index</code> is set to 0.
+ *
+ * @param cp a constant pool table.
+ * @param className the name of the innermost enclosing class.
+ */
+ public EnclosingMethodAttribute(ConstPool cp, String className) {
+ super(cp, tag);
+ int ci = cp.addClassInfo(className);
+ int ni = 0;
+ byte[] bvalue = new byte[4];
+ bvalue[0] = (byte)(ci >>> 8);
+ bvalue[1] = (byte)ci;
+ bvalue[2] = (byte)(ni >>> 8);
+ bvalue[3] = (byte)ni;
+ set(bvalue);
+ }
+
+ /**
+ * Returns the value of <code>class_index</code>.
+ */
+ public int classIndex() {
+ return ByteArray.readU16bit(get(), 0);
+ }
+
+ /**
+ * Returns the value of <code>method_index</code>.
+ */
+ public int methodIndex() {
+ return ByteArray.readU16bit(get(), 2);
+ }
+
+ /**
+ * Returns the name of the class specified by <code>class_index</code>.
+ */
+ public String className() {
+ return getConstPool().getClassInfo(classIndex());
+ }
+
+ /**
+ * Returns the method name specified by <code>method_index</code>.
+ */
+ public String methodName() {
+ ConstPool cp = getConstPool();
+ int mi = methodIndex();
+ int ni = cp.getNameAndTypeName(mi);
+ return cp.getUtf8Info(ni);
+ }
+
+ /**
+ * Returns the method descriptor specified by <code>method_index</code>.
+ */
+ public String methodDescriptor() {
+ ConstPool cp = getConstPool();
+ int mi = methodIndex();
+ int ti = cp.getNameAndTypeDescriptor(mi);
+ return cp.getUtf8Info(ti);
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ if (methodIndex() == 0)
+ return new EnclosingMethodAttribute(newCp, className());
+ else
+ return new EnclosingMethodAttribute(newCp, className(),
+ methodName(), methodDescriptor());
+ }
+}
diff --git a/src/main/javassist/bytecode/ExceptionTable.java b/src/main/javassist/bytecode/ExceptionTable.java
new file mode 100644
index 0000000..1c74e6e
--- /dev/null
+++ b/src/main/javassist/bytecode/ExceptionTable.java
@@ -0,0 +1,280 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Map;
+
+class ExceptionTableEntry {
+ int startPc;
+ int endPc;
+ int handlerPc;
+ int catchType;
+
+ ExceptionTableEntry(int start, int end, int handle, int type) {
+ startPc = start;
+ endPc = end;
+ handlerPc = handle;
+ catchType = type;
+ }
+}
+
+/**
+ * <code>exception_table[]</code> of <code>Code_attribute</code>.
+ */
+public class ExceptionTable implements Cloneable {
+ private ConstPool constPool;
+ private ArrayList entries;
+
+ /**
+ * Constructs an <code>exception_table[]</code>.
+ *
+ * @param cp constant pool table.
+ */
+ public ExceptionTable(ConstPool cp) {
+ constPool = cp;
+ entries = new ArrayList();
+ }
+
+ ExceptionTable(ConstPool cp, DataInputStream in) throws IOException {
+ constPool = cp;
+ int length = in.readUnsignedShort();
+ ArrayList list = new ArrayList(length);
+ for (int i = 0; i < length; ++i) {
+ int start = in.readUnsignedShort();
+ int end = in.readUnsignedShort();
+ int handle = in.readUnsignedShort();
+ int type = in.readUnsignedShort();
+ list.add(new ExceptionTableEntry(start, end, handle, type));
+ }
+
+ entries = list;
+ }
+
+ /**
+ * Creates and returns a copy of this object.
+ * The constant pool object is shared between this object
+ * and the cloned object.
+ */
+ public Object clone() throws CloneNotSupportedException {
+ ExceptionTable r = (ExceptionTable)super.clone();
+ r.entries = new ArrayList(entries);
+ return r;
+ }
+
+ /**
+ * Returns <code>exception_table_length</code>, which is the number
+ * of entries in the <code>exception_table[]</code>.
+ */
+ public int size() {
+ return entries.size();
+ }
+
+ /**
+ * Returns <code>startPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ */
+ public int startPc(int nth) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ return e.startPc;
+ }
+
+ /**
+ * Sets <code>startPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ * @param value new value.
+ */
+ public void setStartPc(int nth, int value) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ e.startPc = value;
+ }
+
+ /**
+ * Returns <code>endPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ */
+ public int endPc(int nth) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ return e.endPc;
+ }
+
+ /**
+ * Sets <code>endPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ * @param value new value.
+ */
+ public void setEndPc(int nth, int value) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ e.endPc = value;
+ }
+
+ /**
+ * Returns <code>handlerPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ */
+ public int handlerPc(int nth) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ return e.handlerPc;
+ }
+
+ /**
+ * Sets <code>handlerPc</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ * @param value new value.
+ */
+ public void setHandlerPc(int nth, int value) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ e.handlerPc = value;
+ }
+
+ /**
+ * Returns <code>catchType</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ * @return an index into the <code>constant_pool</code> table,
+ * or zero if this exception handler is for all exceptions.
+ */
+ public int catchType(int nth) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ return e.catchType;
+ }
+
+ /**
+ * Sets <code>catchType</code> of the <i>n</i>-th entry.
+ *
+ * @param nth the <i>n</i>-th (>= 0).
+ * @param value new value.
+ */
+ public void setCatchType(int nth, int value) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(nth);
+ e.catchType = value;
+ }
+
+ /**
+ * Copies the given exception table at the specified position
+ * in the table.
+ *
+ * @param index index (>= 0) at which the entry is to be inserted.
+ * @param offset the offset added to the code position.
+ */
+ public void add(int index, ExceptionTable table, int offset) {
+ int len = table.size();
+ while (--len >= 0) {
+ ExceptionTableEntry e
+ = (ExceptionTableEntry)table.entries.get(len);
+ add(index, e.startPc + offset, e.endPc + offset,
+ e.handlerPc + offset, e.catchType);
+ }
+ }
+
+ /**
+ * Adds a new entry at the specified position in the table.
+ *
+ * @param index index (>= 0) at which the entry is to be inserted.
+ * @param start <code>startPc</code>
+ * @param end <code>endPc</code>
+ * @param handler <code>handlerPc</code>
+ * @param type <code>catchType</code>
+ */
+ public void add(int index, int start, int end, int handler, int type) {
+ if (start < end)
+ entries.add(index,
+ new ExceptionTableEntry(start, end, handler, type));
+ }
+
+ /**
+ * Appends a new entry at the end of the table.
+ *
+ * @param start <code>startPc</code>
+ * @param end <code>endPc</code>
+ * @param handler <code>handlerPc</code>
+ * @param type <code>catchType</code>
+ */
+ public void add(int start, int end, int handler, int type) {
+ if (start < end)
+ entries.add(new ExceptionTableEntry(start, end, handler, type));
+ }
+
+ /**
+ * Removes the entry at the specified position in the table.
+ *
+ * @param index the index of the removed entry.
+ */
+ public void remove(int index) {
+ entries.remove(index);
+ }
+
+ /**
+ * Makes a copy of this <code>exception_table[]</code>.
+ * Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public ExceptionTable copy(ConstPool newCp, Map classnames) {
+ ExceptionTable et = new ExceptionTable(newCp);
+ ConstPool srcCp = constPool;
+ int len = size();
+ for (int i = 0; i < len; ++i) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(i);
+ int type = srcCp.copy(e.catchType, newCp, classnames);
+ et.add(e.startPc, e.endPc, e.handlerPc, type);
+ }
+
+ return et;
+ }
+
+ void shiftPc(int where, int gapLength, boolean exclusive) {
+ int len = size();
+ for (int i = 0; i < len; ++i) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(i);
+ e.startPc = shiftPc(e.startPc, where, gapLength, exclusive);
+ e.endPc = shiftPc(e.endPc, where, gapLength, exclusive);
+ e.handlerPc = shiftPc(e.handlerPc, where, gapLength, exclusive);
+ }
+ }
+
+ private static int shiftPc(int pc, int where, int gapLength,
+ boolean exclusive) {
+ if (pc > where || (exclusive && pc == where))
+ pc += gapLength;
+
+ return pc;
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ int len = size();
+ out.writeShort(len); // exception_table_length
+ for (int i = 0; i < len; ++i) {
+ ExceptionTableEntry e = (ExceptionTableEntry)entries.get(i);
+ out.writeShort(e.startPc);
+ out.writeShort(e.endPc);
+ out.writeShort(e.handlerPc);
+ out.writeShort(e.catchType);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/ExceptionsAttribute.java b/src/main/javassist/bytecode/ExceptionsAttribute.java
new file mode 100644
index 0000000..2fe34dd
--- /dev/null
+++ b/src/main/javassist/bytecode/ExceptionsAttribute.java
@@ -0,0 +1,173 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>Exceptions_attribute</code>.
+ */
+public class ExceptionsAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"Exceptions"</code>.
+ */
+ public static final String tag = "Exceptions";
+
+ ExceptionsAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a copy of an exceptions attribute.
+ *
+ * @param cp constant pool table.
+ * @param src source attribute.
+ */
+ private ExceptionsAttribute(ConstPool cp, ExceptionsAttribute src,
+ Map classnames) {
+ super(cp, tag);
+ copyFrom(src, classnames);
+ }
+
+ /**
+ * Constructs a new exceptions attribute.
+ *
+ * @param cp constant pool table.
+ */
+ public ExceptionsAttribute(ConstPool cp) {
+ super(cp, tag);
+ byte[] data = new byte[2];
+ data[0] = data[1] = 0; // empty
+ this.info = data;
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names. It can be <code>null</code>.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ return new ExceptionsAttribute(newCp, this, classnames);
+ }
+
+ /**
+ * Copies the contents from a source attribute.
+ * Specified class names are replaced during the copy.
+ *
+ * @param srcAttr source Exceptions attribute
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ private void copyFrom(ExceptionsAttribute srcAttr, Map classnames) {
+ ConstPool srcCp = srcAttr.constPool;
+ ConstPool destCp = this.constPool;
+ byte[] src = srcAttr.info;
+ int num = src.length;
+ byte[] dest = new byte[num];
+ dest[0] = src[0];
+ dest[1] = src[1]; // the number of elements.
+ for (int i = 2; i < num; i += 2) {
+ int index = ByteArray.readU16bit(src, i);
+ ByteArray.write16bit(srcCp.copy(index, destCp, classnames),
+ dest, i);
+ }
+
+ this.info = dest;
+ }
+
+ /**
+ * Returns <code>exception_index_table[]</code>.
+ */
+ public int[] getExceptionIndexes() {
+ byte[] blist = info;
+ int n = blist.length;
+ if (n <= 2)
+ return null;
+
+ int[] elist = new int[n / 2 - 1];
+ int k = 0;
+ for (int j = 2; j < n; j += 2)
+ elist[k++] = ((blist[j] & 0xff) << 8) | (blist[j + 1] & 0xff);
+
+ return elist;
+ }
+
+ /**
+ * Returns the names of exceptions that the method may throw.
+ */
+ public String[] getExceptions() {
+ byte[] blist = info;
+ int n = blist.length;
+ if (n <= 2)
+ return null;
+
+ String[] elist = new String[n / 2 - 1];
+ int k = 0;
+ for (int j = 2; j < n; j += 2) {
+ int index = ((blist[j] & 0xff) << 8) | (blist[j + 1] & 0xff);
+ elist[k++] = constPool.getClassInfo(index);
+ }
+
+ return elist;
+ }
+
+ /**
+ * Sets <code>exception_index_table[]</code>.
+ */
+ public void setExceptionIndexes(int[] elist) {
+ int n = elist.length;
+ byte[] blist = new byte[n * 2 + 2];
+ ByteArray.write16bit(n, blist, 0);
+ for (int i = 0; i < n; ++i)
+ ByteArray.write16bit(elist[i], blist, i * 2 + 2);
+
+ info = blist;
+ }
+
+ /**
+ * Sets the names of exceptions that the method may throw.
+ */
+ public void setExceptions(String[] elist) {
+ int n = elist.length;
+ byte[] blist = new byte[n * 2 + 2];
+ ByteArray.write16bit(n, blist, 0);
+ for (int i = 0; i < n; ++i)
+ ByteArray.write16bit(constPool.addClassInfo(elist[i]),
+ blist, i * 2 + 2);
+
+ info = blist;
+ }
+
+ /**
+ * Returns <code>number_of_exceptions</code>.
+ */
+ public int tableLength() { return info.length / 2 - 1; }
+
+ /**
+ * Returns the value of <code>exception_index_table[nth]</code>.
+ */
+ public int getException(int nth) {
+ int index = nth * 2 + 2; // nth >= 0
+ return ((info[index] & 0xff) << 8) | (info[index + 1] & 0xff);
+ }
+}
diff --git a/src/main/javassist/bytecode/FieldInfo.java b/src/main/javassist/bytecode/FieldInfo.java
new file mode 100644
index 0000000..f474373
--- /dev/null
+++ b/src/main/javassist/bytecode/FieldInfo.java
@@ -0,0 +1,266 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.List;
+import java.util.ArrayList;
+
+/**
+ * <code>field_info</code> structure.
+ *
+ * @see javassist.CtField#getFieldInfo()
+ */
+public final class FieldInfo {
+ ConstPool constPool;
+ int accessFlags;
+ int name;
+ String cachedName;
+ String cachedType;
+ int descriptor;
+ ArrayList attribute; // may be null.
+
+ private FieldInfo(ConstPool cp) {
+ constPool = cp;
+ accessFlags = 0;
+ attribute = null;
+ }
+
+ /**
+ * Constructs a <code>field_info</code> structure.
+ *
+ * @param cp a constant pool table
+ * @param fieldName field name
+ * @param desc field descriptor
+ *
+ * @see Descriptor
+ */
+ public FieldInfo(ConstPool cp, String fieldName, String desc) {
+ this(cp);
+ name = cp.addUtf8Info(fieldName);
+ cachedName = fieldName;
+ descriptor = cp.addUtf8Info(desc);
+ }
+
+ FieldInfo(ConstPool cp, DataInputStream in) throws IOException {
+ this(cp);
+ read(in);
+ }
+
+ /**
+ * Returns a string representation of the object.
+ */
+ public String toString() {
+ return getName() + " " + getDescriptor();
+ }
+
+ /**
+ * Copies all constant pool items to a given new constant pool
+ * and replaces the original items with the new ones.
+ * This is used for garbage collecting the items of removed fields
+ * and methods.
+ *
+ * @param cp the destination
+ */
+ void compact(ConstPool cp) {
+ name = cp.addUtf8Info(getName());
+ descriptor = cp.addUtf8Info(getDescriptor());
+ attribute = AttributeInfo.copyAll(attribute, cp);
+ constPool = cp;
+ }
+
+ void prune(ConstPool cp) {
+ ArrayList newAttributes = new ArrayList();
+ AttributeInfo invisibleAnnotations
+ = getAttribute(AnnotationsAttribute.invisibleTag);
+ if (invisibleAnnotations != null) {
+ invisibleAnnotations = invisibleAnnotations.copy(cp, null);
+ newAttributes.add(invisibleAnnotations);
+ }
+
+ AttributeInfo visibleAnnotations
+ = getAttribute(AnnotationsAttribute.visibleTag);
+ if (visibleAnnotations != null) {
+ visibleAnnotations = visibleAnnotations.copy(cp, null);
+ newAttributes.add(visibleAnnotations);
+ }
+
+ AttributeInfo signature
+ = getAttribute(SignatureAttribute.tag);
+ if (signature != null) {
+ signature = signature.copy(cp, null);
+ newAttributes.add(signature);
+ }
+
+ int index = getConstantValue();
+ if (index != 0) {
+ index = constPool.copy(index, cp, null);
+ newAttributes.add(new ConstantAttribute(cp, index));
+ }
+
+ attribute = newAttributes;
+ name = cp.addUtf8Info(getName());
+ descriptor = cp.addUtf8Info(getDescriptor());
+ constPool = cp;
+ }
+
+ /**
+ * Returns the constant pool table used
+ * by this <code>field_info</code>.
+ */
+ public ConstPool getConstPool() {
+ return constPool;
+ }
+
+ /**
+ * Returns the field name.
+ */
+ public String getName() {
+ if (cachedName == null)
+ cachedName = constPool.getUtf8Info(name);
+
+ return cachedName;
+ }
+
+ /**
+ * Sets the field name.
+ */
+ public void setName(String newName) {
+ name = constPool.addUtf8Info(newName);
+ cachedName = newName;
+ }
+
+ /**
+ * Returns the access flags.
+ *
+ * @see AccessFlag
+ */
+ public int getAccessFlags() {
+ return accessFlags;
+ }
+
+ /**
+ * Sets the access flags.
+ *
+ * @see AccessFlag
+ */
+ public void setAccessFlags(int acc) {
+ accessFlags = acc;
+ }
+
+ /**
+ * Returns the field descriptor.
+ *
+ * @see Descriptor
+ */
+ public String getDescriptor() {
+ return constPool.getUtf8Info(descriptor);
+ }
+
+ /**
+ * Sets the field descriptor.
+ *
+ * @see Descriptor
+ */
+ public void setDescriptor(String desc) {
+ if (!desc.equals(getDescriptor()))
+ descriptor = constPool.addUtf8Info(desc);
+ }
+
+ /**
+ * Finds a ConstantValue attribute and returns the index into
+ * the <code>constant_pool</code> table.
+ *
+ * @return 0 if a ConstantValue attribute is not found.
+ */
+ public int getConstantValue() {
+ if ((accessFlags & AccessFlag.STATIC) == 0)
+ return 0;
+
+ ConstantAttribute attr
+ = (ConstantAttribute)getAttribute(ConstantAttribute.tag);
+ if (attr == null)
+ return 0;
+ else
+ return attr.getConstantValue();
+ }
+
+ /**
+ * Returns all the attributes. The returned <code>List</code> object
+ * is shared with this object. If you add a new attribute to the list,
+ * the attribute is also added to the field represented by this
+ * object. If you remove an attribute from the list, it is also removed
+ * from the field.
+ *
+ * @return a list of <code>AttributeInfo</code> objects.
+ * @see AttributeInfo
+ */
+ public List getAttributes() {
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ return attribute;
+ }
+
+ /**
+ * Returns the attribute with the specified name.
+ * It returns null if the specified attribute is not found.
+ *
+ * @param name attribute name
+ * @see #getAttributes()
+ */
+ public AttributeInfo getAttribute(String name) {
+ return AttributeInfo.lookup(attribute, name);
+ }
+
+ /**
+ * Appends an attribute. If there is already an attribute with
+ * the same name, the new one substitutes for it.
+ *
+ * @see #getAttributes()
+ */
+ public void addAttribute(AttributeInfo info) {
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ AttributeInfo.remove(attribute, info.getName());
+ attribute.add(info);
+ }
+
+ private void read(DataInputStream in) throws IOException {
+ accessFlags = in.readUnsignedShort();
+ name = in.readUnsignedShort();
+ descriptor = in.readUnsignedShort();
+ int n = in.readUnsignedShort();
+ attribute = new ArrayList();
+ for (int i = 0; i < n; ++i)
+ attribute.add(AttributeInfo.read(constPool, in));
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(accessFlags);
+ out.writeShort(name);
+ out.writeShort(descriptor);
+ if (attribute == null)
+ out.writeShort(0);
+ else {
+ out.writeShort(attribute.size());
+ AttributeInfo.writeAll(attribute, out);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/InnerClassesAttribute.java b/src/main/javassist/bytecode/InnerClassesAttribute.java
new file mode 100644
index 0000000..df5645a
--- /dev/null
+++ b/src/main/javassist/bytecode/InnerClassesAttribute.java
@@ -0,0 +1,241 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.util.Map;
+import java.io.IOException;
+
+/**
+ * <code>InnerClasses_attribute</code>.
+ */
+public class InnerClassesAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"InnerClasses"</code>.
+ */
+ public static final String tag = "InnerClasses";
+
+ InnerClassesAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ private InnerClassesAttribute(ConstPool cp, byte[] info) {
+ super(cp, tag, info);
+ }
+
+ /**
+ * Constructs an empty InnerClasses attribute.
+ *
+ * @see #append(String, String, String, int)
+ */
+ public InnerClassesAttribute(ConstPool cp) {
+ super(cp, tag, new byte[2]);
+ ByteArray.write16bit(0, get(), 0);
+ }
+
+ /**
+ * Returns <code>number_of_classes</code>.
+ */
+ public int tableLength() { return ByteArray.readU16bit(get(), 0); }
+
+ /**
+ * Returns <code>classes[nth].inner_class_info_index</code>.
+ */
+ public int innerClassIndex(int nth) {
+ return ByteArray.readU16bit(get(), nth * 8 + 2);
+ }
+
+ /**
+ * Returns the class name indicated
+ * by <code>classes[nth].inner_class_info_index</code>.
+ *
+ * @return null or the class name.
+ */
+ public String innerClass(int nth) {
+ int i = innerClassIndex(nth);
+ if (i == 0)
+ return null;
+ else
+ return constPool.getClassInfo(i);
+ }
+
+ /**
+ * Sets <code>classes[nth].inner_class_info_index</code> to
+ * the given index.
+ */
+ public void setInnerClassIndex(int nth, int index) {
+ ByteArray.write16bit(index, get(), nth * 8 + 2);
+ }
+
+ /**
+ * Returns <code>classes[nth].outer_class_info_index</code>.
+ */
+ public int outerClassIndex(int nth) {
+ return ByteArray.readU16bit(get(), nth * 8 + 4);
+ }
+
+ /**
+ * Returns the class name indicated
+ * by <code>classes[nth].outer_class_info_index</code>.
+ *
+ * @return null or the class name.
+ */
+ public String outerClass(int nth) {
+ int i = outerClassIndex(nth);
+ if (i == 0)
+ return null;
+ else
+ return constPool.getClassInfo(i);
+ }
+
+ /**
+ * Sets <code>classes[nth].outer_class_info_index</code> to
+ * the given index.
+ */
+ public void setOuterClassIndex(int nth, int index) {
+ ByteArray.write16bit(index, get(), nth * 8 + 4);
+ }
+
+ /**
+ * Returns <code>classes[nth].inner_name_index</code>.
+ */
+ public int innerNameIndex(int nth) {
+ return ByteArray.readU16bit(get(), nth * 8 + 6);
+ }
+
+ /**
+ * Returns the simple class name indicated
+ * by <code>classes[nth].inner_name_index</code>.
+ *
+ * @return null or the class name.
+ */
+ public String innerName(int nth) {
+ int i = innerNameIndex(nth);
+ if (i == 0)
+ return null;
+ else
+ return constPool.getUtf8Info(i);
+ }
+
+ /**
+ * Sets <code>classes[nth].inner_name_index</code> to
+ * the given index.
+ */
+ public void setInnerNameIndex(int nth, int index) {
+ ByteArray.write16bit(index, get(), nth * 8 + 6);
+ }
+
+ /**
+ * Returns <code>classes[nth].inner_class_access_flags</code>.
+ */
+ public int accessFlags(int nth) {
+ return ByteArray.readU16bit(get(), nth * 8 + 8);
+ }
+
+ /**
+ * Sets <code>classes[nth].inner_class_access_flags</code> to
+ * the given index.
+ */
+ public void setAccessFlags(int nth, int flags) {
+ ByteArray.write16bit(flags, get(), nth * 8 + 8);
+ }
+
+ /**
+ * Appends a new entry.
+ *
+ * @param inner <code>inner_class_info_index</code>
+ * @param outer <code>outer_class_info_index</code>
+ * @param name <code>inner_name_index</code>
+ * @param flags <code>inner_class_access_flags</code>
+ */
+ public void append(String inner, String outer, String name, int flags) {
+ int i = constPool.addClassInfo(inner);
+ int o = constPool.addClassInfo(outer);
+ int n = constPool.addUtf8Info(name);
+ append(i, o, n, flags);
+ }
+
+ /**
+ * Appends a new entry.
+ *
+ * @param inner <code>inner_class_info_index</code>
+ * @param outer <code>outer_class_info_index</code>
+ * @param name <code>inner_name_index</code>
+ * @param flags <code>inner_class_access_flags</code>
+ */
+ public void append(int inner, int outer, int name, int flags) {
+ byte[] data = get();
+ int len = data.length;
+ byte[] newData = new byte[len + 8];
+ for (int i = 2; i < len; ++i)
+ newData[i] = data[i];
+
+ int n = ByteArray.readU16bit(data, 0);
+ ByteArray.write16bit(n + 1, newData, 0);
+
+ ByteArray.write16bit(inner, newData, len);
+ ByteArray.write16bit(outer, newData, len + 2);
+ ByteArray.write16bit(name, newData, len + 4);
+ ByteArray.write16bit(flags, newData, len + 6);
+
+ set(newData);
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ byte[] src = get();
+ byte[] dest = new byte[src.length];
+ ConstPool cp = getConstPool();
+ InnerClassesAttribute attr = new InnerClassesAttribute(newCp, dest);
+ int n = ByteArray.readU16bit(src, 0);
+ ByteArray.write16bit(n, dest, 0);
+ int j = 2;
+ for (int i = 0; i < n; ++i) {
+ int innerClass = ByteArray.readU16bit(src, j);
+ int outerClass = ByteArray.readU16bit(src, j + 2);
+ int innerName = ByteArray.readU16bit(src, j + 4);
+ int innerAccess = ByteArray.readU16bit(src, j + 6);
+
+ if (innerClass != 0)
+ innerClass = cp.copy(innerClass, newCp, classnames);
+
+ ByteArray.write16bit(innerClass, dest, j);
+
+ if (outerClass != 0)
+ outerClass = cp.copy(outerClass, newCp, classnames);
+
+ ByteArray.write16bit(outerClass, dest, j + 2);
+
+ if (innerName != 0)
+ innerName = cp.copy(innerName, newCp, classnames);
+
+ ByteArray.write16bit(innerName, dest, j + 4);
+ ByteArray.write16bit(innerAccess, dest, j + 6);
+ j += 8;
+ }
+
+ return attr;
+ }
+}
diff --git a/src/main/javassist/bytecode/InstructionPrinter.java b/src/main/javassist/bytecode/InstructionPrinter.java
new file mode 100644
index 0000000..f0a20e1
--- /dev/null
+++ b/src/main/javassist/bytecode/InstructionPrinter.java
@@ -0,0 +1,281 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode;
+
+import java.io.PrintStream;
+
+import javassist.CtMethod;
+
+/**
+ * Simple utility class for printing the instructions of a method.
+ *
+ * @author Jason T. Greene
+ */
+public class InstructionPrinter implements Opcode {
+
+ private final static String opcodes[] = Mnemonic.OPCODE;
+ private final PrintStream stream;
+
+ public InstructionPrinter(PrintStream stream) {
+ this.stream = stream;
+ }
+
+ public static void print(CtMethod method, PrintStream stream) {
+ (new InstructionPrinter(stream)).print(method);
+ }
+
+ public void print(CtMethod method) {
+ MethodInfo info = method.getMethodInfo2();
+ ConstPool pool = info.getConstPool();
+ CodeAttribute code = info.getCodeAttribute();
+ if (code == null)
+ return;
+
+ CodeIterator iterator = code.iterator();
+ while (iterator.hasNext()) {
+ int pos;
+ try {
+ pos = iterator.next();
+ } catch (BadBytecode e) {
+ throw new RuntimeException(e);
+ }
+
+ stream.println(pos + ": " + instructionString(iterator, pos, pool));
+ }
+ }
+
+ public static String instructionString(CodeIterator iter, int pos, ConstPool pool) {
+ int opcode = iter.byteAt(pos);
+
+ if (opcode > opcodes.length || opcode < 0)
+ throw new IllegalArgumentException("Invalid opcode, opcode: " + opcode + " pos: "+ pos);
+
+ String opstring = opcodes[opcode];
+ switch (opcode) {
+ case BIPUSH:
+ return opstring + " " + iter.byteAt(pos + 1);
+ case SIPUSH:
+ return opstring + " " + iter.s16bitAt(pos + 1);
+ case LDC:
+ return opstring + " " + ldc(pool, iter.byteAt(pos + 1));
+ case LDC_W :
+ case LDC2_W :
+ return opstring + " " + ldc(pool, iter.u16bitAt(pos + 1));
+ case ILOAD:
+ case LLOAD:
+ case FLOAD:
+ case DLOAD:
+ case ALOAD:
+ case ISTORE:
+ case LSTORE:
+ case FSTORE:
+ case DSTORE:
+ case ASTORE:
+ return opstring + " " + iter.byteAt(pos + 1);
+ case IFEQ:
+ case IFGE:
+ case IFGT:
+ case IFLE:
+ case IFLT:
+ case IFNE:
+ case IFNONNULL:
+ case IFNULL:
+ case IF_ACMPEQ:
+ case IF_ACMPNE:
+ case IF_ICMPEQ:
+ case IF_ICMPGE:
+ case IF_ICMPGT:
+ case IF_ICMPLE:
+ case IF_ICMPLT:
+ case IF_ICMPNE:
+ return opstring + " " + (iter.s16bitAt(pos + 1) + pos);
+ case IINC:
+ return opstring + " " + iter.byteAt(pos + 1);
+ case GOTO:
+ case JSR:
+ return opstring + " " + (iter.s16bitAt(pos + 1) + pos);
+ case RET:
+ return opstring + " " + iter.byteAt(pos + 1);
+ case TABLESWITCH:
+ return tableSwitch(iter, pos);
+ case LOOKUPSWITCH:
+ return lookupSwitch(iter, pos);
+ case GETSTATIC:
+ case PUTSTATIC:
+ case GETFIELD:
+ case PUTFIELD:
+ return opstring + " " + fieldInfo(pool, iter.u16bitAt(pos + 1));
+ case INVOKEVIRTUAL:
+ case INVOKESPECIAL:
+ case INVOKESTATIC:
+ return opstring + " " + methodInfo(pool, iter.u16bitAt(pos + 1));
+ case INVOKEINTERFACE:
+ return opstring + " " + interfaceMethodInfo(pool, iter.u16bitAt(pos + 1));
+ case 186:
+ throw new RuntimeException("Bad opcode 186");
+ case NEW:
+ return opstring + " " + classInfo(pool, iter.u16bitAt(pos + 1));
+ case NEWARRAY:
+ return opstring + " " + arrayInfo(iter.byteAt(pos + 1));
+ case ANEWARRAY:
+ case CHECKCAST:
+ return opstring + " " + classInfo(pool, iter.u16bitAt(pos + 1));
+ case WIDE:
+ return wide(iter, pos);
+ case MULTIANEWARRAY:
+ return opstring + " " + classInfo(pool, iter.u16bitAt(pos + 1));
+ case GOTO_W:
+ case JSR_W:
+ return opstring + " " + (iter.s32bitAt(pos + 1)+ pos);
+ default:
+ return opstring;
+ }
+ }
+
+
+ private static String wide(CodeIterator iter, int pos) {
+ int opcode = iter.byteAt(pos + 1);
+ int index = iter.u16bitAt(pos + 2);
+ switch (opcode) {
+ case ILOAD:
+ case LLOAD:
+ case FLOAD:
+ case DLOAD:
+ case ALOAD:
+ case ISTORE:
+ case LSTORE:
+ case FSTORE:
+ case DSTORE:
+ case ASTORE:
+ case IINC:
+ case RET:
+ return opcodes[opcode] + " " + index;
+ default:
+ throw new RuntimeException("Invalid WIDE operand");
+ }
+ }
+
+
+ private static String arrayInfo(int type) {
+ switch (type) {
+ case T_BOOLEAN:
+ return "boolean";
+ case T_CHAR:
+ return "char";
+ case T_BYTE:
+ return "byte";
+ case T_SHORT:
+ return "short";
+ case T_INT:
+ return "int";
+ case T_LONG:
+ return "long";
+ case T_FLOAT:
+ return "float";
+ case T_DOUBLE:
+ return "double";
+ default:
+ throw new RuntimeException("Invalid array type");
+ }
+ }
+
+
+ private static String classInfo(ConstPool pool, int index) {
+ return "#" + index + " = Class " + pool.getClassInfo(index);
+ }
+
+
+ private static String interfaceMethodInfo(ConstPool pool, int index) {
+ return "#" + index + " = Method "
+ + pool.getInterfaceMethodrefClassName(index) + "."
+ + pool.getInterfaceMethodrefName(index) + "("
+ + pool.getInterfaceMethodrefType(index) + ")";
+ }
+
+ private static String methodInfo(ConstPool pool, int index) {
+ return "#" + index + " = Method "
+ + pool.getMethodrefClassName(index) + "."
+ + pool.getMethodrefName(index) + "("
+ + pool.getMethodrefType(index) + ")";
+ }
+
+
+ private static String fieldInfo(ConstPool pool, int index) {
+ return "#" + index + " = Field "
+ + pool.getFieldrefClassName(index) + "."
+ + pool.getFieldrefName(index) + "("
+ + pool.getFieldrefType(index) + ")";
+ }
+
+
+ private static String lookupSwitch(CodeIterator iter, int pos) {
+ StringBuffer buffer = new StringBuffer("lookupswitch {\n");
+ int index = (pos & ~3) + 4;
+ // default
+ buffer.append("\t\tdefault: ").append(pos + iter.s32bitAt(index)).append("\n");
+ int npairs = iter.s32bitAt(index += 4);
+ int end = npairs * 8 + (index += 4);
+
+ for (; index < end; index += 8) {
+ int match = iter.s32bitAt(index);
+ int target = iter.s32bitAt(index + 4) + pos;
+ buffer.append("\t\t").append(match).append(": ").append(target).append("\n");
+ }
+
+ buffer.setCharAt(buffer.length() - 1, '}');
+ return buffer.toString();
+ }
+
+
+ private static String tableSwitch(CodeIterator iter, int pos) {
+ StringBuffer buffer = new StringBuffer("tableswitch {\n");
+ int index = (pos & ~3) + 4;
+ // default
+ buffer.append("\t\tdefault: ").append(pos + iter.s32bitAt(index)).append("\n");
+ int low = iter.s32bitAt(index += 4);
+ int high = iter.s32bitAt(index += 4);
+ int end = (high - low + 1) * 4 + (index += 4);
+
+ // Offset table
+ for (int key = low; index < end; index += 4, key++) {
+ int target = iter.s32bitAt(index) + pos;
+ buffer.append("\t\t").append(key).append(": ").append(target).append("\n");
+ }
+
+ buffer.setCharAt(buffer.length() - 1, '}');
+ return buffer.toString();
+ }
+
+
+ private static String ldc(ConstPool pool, int index) {
+ int tag = pool.getTag(index);
+ switch (tag) {
+ case ConstPool.CONST_String:
+ return "#" + index + " = \"" + pool.getStringInfo(index) + "\"";
+ case ConstPool.CONST_Integer:
+ return "#" + index + " = int " + pool.getIntegerInfo(index);
+ case ConstPool.CONST_Float:
+ return "#" + index + " = float " + pool.getFloatInfo(index);
+ case ConstPool.CONST_Long:
+ return "#" + index + " = long " + pool.getLongInfo(index);
+ case ConstPool.CONST_Double:
+ return "#" + index + " = int " + pool.getDoubleInfo(index);
+ case ConstPool.CONST_Class:
+ return classInfo(pool, index);
+ default:
+ throw new RuntimeException("bad LDC: " + tag);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/LineNumberAttribute.java b/src/main/javassist/bytecode/LineNumberAttribute.java
new file mode 100644
index 0000000..f384d2f
--- /dev/null
+++ b/src/main/javassist/bytecode/LineNumberAttribute.java
@@ -0,0 +1,181 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>LineNumberTable_attribute</code>.
+ */
+public class LineNumberAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"LineNumberTable"</code>.
+ */
+ public static final String tag = "LineNumberTable";
+
+ LineNumberAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ private LineNumberAttribute(ConstPool cp, byte[] i) {
+ super(cp, tag, i);
+ }
+
+ /**
+ * Returns <code>line_number_table_length</code>.
+ * This represents the number of entries in the table.
+ */
+ public int tableLength() {
+ return ByteArray.readU16bit(info, 0);
+ }
+
+ /**
+ * Returns <code>line_number_table[i].start_pc</code>.
+ * This represents the index into the code array at which the code
+ * for a new line in the original source file begins.
+ *
+ * @param i the i-th entry.
+ */
+ public int startPc(int i) {
+ return ByteArray.readU16bit(info, i * 4 + 2);
+ }
+
+ /**
+ * Returns <code>line_number_table[i].line_number</code>.
+ * This represents the corresponding line number in the original
+ * source file.
+ *
+ * @param i the i-th entry.
+ */
+ public int lineNumber(int i) {
+ return ByteArray.readU16bit(info, i * 4 + 4);
+ }
+
+ /**
+ * Returns the line number corresponding to the specified bytecode.
+ *
+ * @param pc the index into the code array.
+ */
+ public int toLineNumber(int pc) {
+ int n = tableLength();
+ int i = 0;
+ for (; i < n; ++i)
+ if (pc < startPc(i))
+ if (i == 0)
+ return lineNumber(0);
+ else
+ break;
+
+ return lineNumber(i - 1);
+ }
+
+ /**
+ * Returns the index into the code array at which the code for
+ * the specified line begins.
+ *
+ * @param line the line number.
+ * @return -1 if the specified line is not found.
+ */
+ public int toStartPc(int line) {
+ int n = tableLength();
+ for (int i = 0; i < n; ++i)
+ if (line == lineNumber(i))
+ return startPc(i);
+
+ return -1;
+ }
+
+ /**
+ * Used as a return type of <code>toNearPc()</code>.
+ */
+ static public class Pc {
+ /**
+ * The index into the code array.
+ */
+ public int index;
+ /**
+ * The line number.
+ */
+ public int line;
+ }
+
+ /**
+ * Returns the index into the code array at which the code for
+ * the specified line (or the nearest line after the specified one)
+ * begins.
+ *
+ * @param line the line number.
+ * @return a pair of the index and the line number of the
+ * bytecode at that index.
+ */
+ public Pc toNearPc(int line) {
+ int n = tableLength();
+ int nearPc = 0;
+ int distance = 0;
+ if (n > 0) {
+ distance = lineNumber(0) - line;
+ nearPc = startPc(0);
+ }
+
+ for (int i = 1; i < n; ++i) {
+ int d = lineNumber(i) - line;
+ if ((d < 0 && d > distance)
+ || (d >= 0 && (d < distance || distance < 0))) {
+ distance = d;
+ nearPc = startPc(i);
+ }
+ }
+
+ Pc res = new Pc();
+ res.index = nearPc;
+ res.line = line + distance;
+ return res;
+ }
+
+ /**
+ * Makes a copy.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames should be null.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ byte[] src = info;
+ int num = src.length;
+ byte[] dest = new byte[num];
+ for (int i = 0; i < num; ++i)
+ dest[i] = src[i];
+
+ LineNumberAttribute attr = new LineNumberAttribute(newCp, dest);
+ return attr;
+ }
+
+ /**
+ * Adjusts start_pc if bytecode is inserted in a method body.
+ */
+ void shiftPc(int where, int gapLength, boolean exclusive) {
+ int n = tableLength();
+ for (int i = 0; i < n; ++i) {
+ int pos = i * 4 + 2;
+ int pc = ByteArray.readU16bit(info, pos);
+ if (pc > where || (exclusive && pc == where))
+ ByteArray.write16bit(pc + gapLength, info, pos);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/LocalVariableAttribute.java b/src/main/javassist/bytecode/LocalVariableAttribute.java
new file mode 100644
index 0000000..3d44a29
--- /dev/null
+++ b/src/main/javassist/bytecode/LocalVariableAttribute.java
@@ -0,0 +1,333 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>LocalVariableTable_attribute</code>.
+ */
+public class LocalVariableAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"LocalVariableTable"</code>.
+ */
+ public static final String tag = "LocalVariableTable";
+
+ /**
+ * The name of the attribute <code>"LocalVariableTypeTable"</code>.
+ */
+ public static final String typeTag = "LocalVariableTypeTable";
+
+ /**
+ * Constructs an empty LocalVariableTable.
+ */
+ public LocalVariableAttribute(ConstPool cp) {
+ super(cp, tag, new byte[2]);
+ ByteArray.write16bit(0, info, 0);
+ }
+
+ /**
+ * Constructs an empty LocalVariableTable.
+ *
+ * @param name the attribute name.
+ * <code>LocalVariableAttribute.tag</code> or
+ * <code>LocalVariableAttribute.typeTag</code>.
+ * @see #tag
+ * @see #typeTag
+ * @since 3.1
+ * @deprecated
+ */
+ public LocalVariableAttribute(ConstPool cp, String name) {
+ super(cp, name, new byte[2]);
+ ByteArray.write16bit(0, info, 0);
+ }
+
+ LocalVariableAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ LocalVariableAttribute(ConstPool cp, String name, byte[] i) {
+ super(cp, name, i);
+ }
+
+ /**
+ * Appends a new entry to <code>local_variable_table</code>.
+ *
+ * @param startPc <code>start_pc</code>
+ * @param length <code>length</code>
+ * @param nameIndex <code>name_index</code>
+ * @param descriptorIndex <code>descriptor_index</code>
+ * @param index <code>index</code>
+ */
+ public void addEntry(int startPc, int length, int nameIndex,
+ int descriptorIndex, int index) {
+ int size = info.length;
+ byte[] newInfo = new byte[size + 10];
+ ByteArray.write16bit(tableLength() + 1, newInfo, 0);
+ for (int i = 2; i < size; ++i)
+ newInfo[i] = info[i];
+
+ ByteArray.write16bit(startPc, newInfo, size);
+ ByteArray.write16bit(length, newInfo, size + 2);
+ ByteArray.write16bit(nameIndex, newInfo, size + 4);
+ ByteArray.write16bit(descriptorIndex, newInfo, size + 6);
+ ByteArray.write16bit(index, newInfo, size + 8);
+ info = newInfo;
+ }
+
+ void renameClass(String oldname, String newname) {
+ ConstPool cp = getConstPool();
+ int n = tableLength();
+ for (int i = 0; i < n; ++i) {
+ int pos = i * 10 + 2;
+ int index = ByteArray.readU16bit(info, pos + 6);
+ if (index != 0) {
+ String desc = cp.getUtf8Info(index);
+ desc = renameEntry(desc, oldname, newname);
+ ByteArray.write16bit(cp.addUtf8Info(desc), info, pos + 6);
+ }
+ }
+ }
+
+ String renameEntry(String desc, String oldname, String newname) {
+ return Descriptor.rename(desc, oldname, newname);
+ }
+
+ void renameClass(Map classnames) {
+ ConstPool cp = getConstPool();
+ int n = tableLength();
+ for (int i = 0; i < n; ++i) {
+ int pos = i * 10 + 2;
+ int index = ByteArray.readU16bit(info, pos + 6);
+ if (index != 0) {
+ String desc = cp.getUtf8Info(index);
+ desc = renameEntry(desc, classnames);
+ ByteArray.write16bit(cp.addUtf8Info(desc), info, pos + 6);
+ }
+ }
+ }
+
+ String renameEntry(String desc, Map classnames) {
+ return Descriptor.rename(desc, classnames);
+ }
+
+ /**
+ * For each <code>local_variable_table[i].index</code>,
+ * this method increases <code>index</code> by <code>delta</code>.
+ *
+ * @param lessThan the index does not change if it
+ * is less than this value.
+ */
+ public void shiftIndex(int lessThan, int delta) {
+ int size = info.length;
+ for (int i = 2; i < size; i += 10){
+ int org = ByteArray.readU16bit(info, i + 8);
+ if (org >= lessThan)
+ ByteArray.write16bit(org + delta, info, i + 8);
+ }
+ }
+
+ /**
+ * Returns <code>local_variable_table_length</code>.
+ * This represents the number of entries in the table.
+ */
+ public int tableLength() {
+ return ByteArray.readU16bit(info, 0);
+ }
+
+ /**
+ * Returns <code>local_variable_table[i].start_pc</code>.
+ * This represents the index into the code array from which the local
+ * variable is effective.
+ *
+ * @param i the i-th entry.
+ */
+ public int startPc(int i) {
+ return ByteArray.readU16bit(info, i * 10 + 2);
+ }
+
+ /**
+ * Returns <code>local_variable_table[i].length</code>.
+ * This represents the length of the code region in which the local
+ * variable is effective.
+ *
+ * @param i the i-th entry.
+ */
+ public int codeLength(int i) {
+ return ByteArray.readU16bit(info, i * 10 + 4);
+ }
+
+ /**
+ * Adjusts start_pc and length if bytecode is inserted in a method body.
+ */
+ void shiftPc(int where, int gapLength, boolean exclusive) {
+ int n = tableLength();
+ for (int i = 0; i < n; ++i) {
+ int pos = i * 10 + 2;
+ int pc = ByteArray.readU16bit(info, pos);
+ int len = ByteArray.readU16bit(info, pos + 2);
+
+ /* if pc == 0, then the local variable is a method parameter.
+ */
+ if (pc > where || (exclusive && pc == where && pc != 0))
+ ByteArray.write16bit(pc + gapLength, info, pos);
+ else if (pc + len > where || (exclusive && pc + len == where))
+ ByteArray.write16bit(len + gapLength, info, pos + 2);
+ }
+ }
+
+ /**
+ * Returns the value of <code>local_variable_table[i].name_index</code>.
+ * This represents the name of the local variable.
+ *
+ * @param i the i-th entry.
+ */
+ public int nameIndex(int i) {
+ return ByteArray.readU16bit(info, i * 10 + 6);
+ }
+
+ /**
+ * Returns the name of the local variable
+ * specified by <code>local_variable_table[i].name_index</code>.
+ *
+ * @param i the i-th entry.
+ */
+ public String variableName(int i) {
+ return getConstPool().getUtf8Info(nameIndex(i));
+ }
+
+ /**
+ * Returns the value of
+ * <code>local_variable_table[i].descriptor_index</code>.
+ * This represents the type descriptor of the local variable.
+ * <p>
+ * If this attribute represents a LocalVariableTypeTable attribute,
+ * this method returns the value of
+ * <code>local_variable_type_table[i].signature_index</code>.
+ * It represents the type of the local variable.
+ *
+ * @param i the i-th entry.
+ */
+ public int descriptorIndex(int i) {
+ return ByteArray.readU16bit(info, i * 10 + 8);
+ }
+
+ /**
+ * This method is equivalent to <code>descriptorIndex()</code>.
+ * If this attribute represents a LocalVariableTypeTable attribute,
+ * this method should be used instead of <code>descriptorIndex()</code>
+ * since the method name is more appropriate.
+ *
+ * @param i the i-th entry.
+ * @see #descriptorIndex(int)
+ * @see SignatureAttribute#toFieldSignature(String)
+ */
+ public int signatureIndex(int i) {
+ return descriptorIndex(i);
+ }
+
+ /**
+ * Returns the type descriptor of the local variable
+ * specified by <code>local_variable_table[i].descriptor_index</code>.
+ * <p>
+ * If this attribute represents a LocalVariableTypeTable attribute,
+ * this method returns the type signature of the local variable
+ * specified by <code>local_variable_type_table[i].signature_index</code>.
+ *
+ * @param i the i-th entry.
+ */
+ public String descriptor(int i) {
+ return getConstPool().getUtf8Info(descriptorIndex(i));
+ }
+
+ /**
+ * This method is equivalent to <code>descriptor()</code>.
+ * If this attribute represents a LocalVariableTypeTable attribute,
+ * this method should be used instead of <code>descriptor()</code>
+ * since the method name is more appropriate.
+ *
+ * <p>To parse the string, call <code>toFieldSignature(String)</code>
+ * in <code>SignatureAttribute</code>.
+ *
+ * @param i the i-th entry.
+ * @see #descriptor(int)
+ * @see SignatureAttribute#toFieldSignature(String)
+ */
+ public String signature(int i) {
+ return descriptor(i);
+ }
+
+ /**
+ * Returns <code>local_variable_table[i].index</code>.
+ * This represents the index of the local variable.
+ *
+ * @param i the i-th entry.
+ */
+ public int index(int i) {
+ return ByteArray.readU16bit(info, i * 10 + 10);
+ }
+
+ /**
+ * Makes a copy.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames should be null.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ byte[] src = get();
+ byte[] dest = new byte[src.length];
+ ConstPool cp = getConstPool();
+ LocalVariableAttribute attr = makeThisAttr(newCp, dest);
+ int n = ByteArray.readU16bit(src, 0);
+ ByteArray.write16bit(n, dest, 0);
+ int j = 2;
+ for (int i = 0; i < n; ++i) {
+ int start = ByteArray.readU16bit(src, j);
+ int len = ByteArray.readU16bit(src, j + 2);
+ int name = ByteArray.readU16bit(src, j + 4);
+ int type = ByteArray.readU16bit(src, j + 6);
+ int index = ByteArray.readU16bit(src, j + 8);
+
+ ByteArray.write16bit(start, dest, j);
+ ByteArray.write16bit(len, dest, j + 2);
+ if (name != 0)
+ name = cp.copy(name, newCp, null);
+
+ ByteArray.write16bit(name, dest, j + 4);
+
+ if (type != 0) {
+ String sig = cp.getUtf8Info(type);
+ sig = Descriptor.rename(sig, classnames);
+ type = newCp.addUtf8Info(sig);
+ }
+
+ ByteArray.write16bit(type, dest, j + 6);
+ ByteArray.write16bit(index, dest, j + 8);
+ j += 10;
+ }
+
+ return attr;
+ }
+
+ // LocalVariableTypeAttribute overrides this method.
+ LocalVariableAttribute makeThisAttr(ConstPool cp, byte[] dest) {
+ return new LocalVariableAttribute(cp, tag, dest);
+ }
+}
diff --git a/src/main/javassist/bytecode/LocalVariableTypeAttribute.java b/src/main/javassist/bytecode/LocalVariableTypeAttribute.java
new file mode 100644
index 0000000..d7ac098
--- /dev/null
+++ b/src/main/javassist/bytecode/LocalVariableTypeAttribute.java
@@ -0,0 +1,62 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>LocalVariableTypeTable_attribute</code>.
+ *
+ * @since 3.11
+ */
+public class LocalVariableTypeAttribute extends LocalVariableAttribute {
+ /**
+ * The name of the attribute <code>"LocalVariableTypeTable"</code>.
+ */
+ public static final String tag = LocalVariableAttribute.typeTag;
+
+ /**
+ * Constructs an empty LocalVariableTypeTable.
+ */
+ public LocalVariableTypeAttribute(ConstPool cp) {
+ super(cp, tag, new byte[2]);
+ ByteArray.write16bit(0, info, 0);
+ }
+
+ LocalVariableTypeAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ private LocalVariableTypeAttribute(ConstPool cp, byte[] dest) {
+ super(cp, tag, dest);
+ }
+
+ String renameEntry(String desc, String oldname, String newname) {
+ return SignatureAttribute.renameClass(desc, oldname, newname);
+ }
+
+ String renameEntry(String desc, Map classnames) {
+ return SignatureAttribute.renameClass(desc, classnames);
+ }
+
+ LocalVariableAttribute makeThisAttr(ConstPool cp, byte[] dest) {
+ return new LocalVariableTypeAttribute(cp, dest);
+ }
+}
diff --git a/src/main/javassist/bytecode/LongVector.java b/src/main/javassist/bytecode/LongVector.java
new file mode 100644
index 0000000..1f76b4a
--- /dev/null
+++ b/src/main/javassist/bytecode/LongVector.java
@@ -0,0 +1,63 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+final class LongVector {
+ static final int ASIZE = 128;
+ static final int ABITS = 7; // ASIZE = 2^ABITS
+ static final int VSIZE = 8;
+ private ConstInfo[][] objects;
+ private int elements;
+
+ public LongVector() {
+ objects = new ConstInfo[VSIZE][];
+ elements = 0;
+ }
+
+ public LongVector(int initialSize) {
+ int vsize = ((initialSize >> ABITS) & ~(VSIZE - 1)) + VSIZE;
+ objects = new ConstInfo[vsize][];
+ elements = 0;
+ }
+
+ public int size() { return elements; }
+
+ public int capacity() { return objects.length * ASIZE; }
+
+ public ConstInfo elementAt(int i) {
+ if (i < 0 || elements <= i)
+ return null;
+
+ return objects[i >> ABITS][i & (ASIZE - 1)];
+ }
+
+ public void addElement(ConstInfo value) {
+ int nth = elements >> ABITS;
+ int offset = elements & (ASIZE - 1);
+ int len = objects.length;
+ if (nth >= len) {
+ ConstInfo[][] newObj = new ConstInfo[len + VSIZE][];
+ System.arraycopy(objects, 0, newObj, 0, len);
+ objects = newObj;
+ }
+
+ if (objects[nth] == null)
+ objects[nth] = new ConstInfo[ASIZE];
+
+ objects[nth][offset] = value;
+ elements++;
+ }
+}
diff --git a/src/main/javassist/bytecode/MethodInfo.java b/src/main/javassist/bytecode/MethodInfo.java
new file mode 100644
index 0000000..aae98ea
--- /dev/null
+++ b/src/main/javassist/bytecode/MethodInfo.java
@@ -0,0 +1,542 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import javassist.ClassPool;
+import javassist.bytecode.stackmap.MapMaker;
+
+/**
+ * <code>method_info</code> structure.
+ *
+ * @see javassist.CtMethod#getMethodInfo()
+ * @see javassist.CtConstructor#getMethodInfo()
+ */
+public class MethodInfo {
+ ConstPool constPool;
+ int accessFlags;
+ int name;
+ String cachedName;
+ int descriptor;
+ ArrayList attribute; // may be null
+
+ /**
+ * If this value is true, Javassist maintains a <code>StackMap</code> attribute
+ * generated by the <code>preverify</code> tool of J2ME (CLDC). The initial
+ * value of this field is <code>false</code>.
+ */
+ public static boolean doPreverify = false;
+
+ /**
+ * The name of constructors: <code><init></code>.
+ */
+ public static final String nameInit = "<init>";
+
+ /**
+ * The name of class initializer (static initializer):
+ * <code><clinit></code>.
+ */
+ public static final String nameClinit = "<clinit>";
+
+ private MethodInfo(ConstPool cp) {
+ constPool = cp;
+ attribute = null;
+ }
+
+ /**
+ * Constructs a <code>method_info</code> structure. The initial value of
+ * <code>access_flags</code> is zero.
+ *
+ * @param cp
+ * a constant pool table
+ * @param methodname
+ * method name
+ * @param desc
+ * method descriptor
+ * @see Descriptor
+ */
+ public MethodInfo(ConstPool cp, String methodname, String desc) {
+ this(cp);
+ accessFlags = 0;
+ name = cp.addUtf8Info(methodname);
+ cachedName = methodname;
+ descriptor = constPool.addUtf8Info(desc);
+ }
+
+ MethodInfo(ConstPool cp, DataInputStream in) throws IOException {
+ this(cp);
+ read(in);
+ }
+
+ /**
+ * Constructs a copy of <code>method_info</code> structure. Class names
+ * appearing in the source <code>method_info</code> are renamed according
+ * to <code>classnameMap</code>.
+ *
+ * <p>
+ * Note: only <code>Code</code> and <code>Exceptions</code> attributes
+ * are copied from the source. The other attributes are ignored.
+ *
+ * @param cp
+ * a constant pool table
+ * @param methodname
+ * a method name
+ * @param src
+ * a source <code>method_info</code>
+ * @param classnameMap
+ * specifies pairs of replaced and substituted name.
+ * @see Descriptor
+ */
+ public MethodInfo(ConstPool cp, String methodname, MethodInfo src,
+ Map classnameMap) throws BadBytecode {
+ this(cp);
+ read(src, methodname, classnameMap);
+ }
+
+ /**
+ * Returns a string representation of the object.
+ */
+ public String toString() {
+ return getName() + " " + getDescriptor();
+ }
+
+ /**
+ * Copies all constant pool items to a given new constant pool
+ * and replaces the original items with the new ones.
+ * This is used for garbage collecting the items of removed fields
+ * and methods.
+ *
+ * @param cp the destination
+ */
+ void compact(ConstPool cp) {
+ name = cp.addUtf8Info(getName());
+ descriptor = cp.addUtf8Info(getDescriptor());
+ attribute = AttributeInfo.copyAll(attribute, cp);
+ constPool = cp;
+ }
+
+ void prune(ConstPool cp) {
+ ArrayList newAttributes = new ArrayList();
+
+ AttributeInfo invisibleAnnotations
+ = getAttribute(AnnotationsAttribute.invisibleTag);
+ if (invisibleAnnotations != null) {
+ invisibleAnnotations = invisibleAnnotations.copy(cp, null);
+ newAttributes.add(invisibleAnnotations);
+ }
+
+ AttributeInfo visibleAnnotations
+ = getAttribute(AnnotationsAttribute.visibleTag);
+ if (visibleAnnotations != null) {
+ visibleAnnotations = visibleAnnotations.copy(cp, null);
+ newAttributes.add(visibleAnnotations);
+ }
+
+ AttributeInfo parameterInvisibleAnnotations
+ = getAttribute(ParameterAnnotationsAttribute.invisibleTag);
+ if (parameterInvisibleAnnotations != null) {
+ parameterInvisibleAnnotations = parameterInvisibleAnnotations.copy(cp, null);
+ newAttributes.add(parameterInvisibleAnnotations);
+ }
+
+ AttributeInfo parameterVisibleAnnotations
+ = getAttribute(ParameterAnnotationsAttribute.visibleTag);
+ if (parameterVisibleAnnotations != null) {
+ parameterVisibleAnnotations = parameterVisibleAnnotations.copy(cp, null);
+ newAttributes.add(parameterVisibleAnnotations);
+ }
+
+ AnnotationDefaultAttribute defaultAttribute
+ = (AnnotationDefaultAttribute) getAttribute(AnnotationDefaultAttribute.tag);
+ if (defaultAttribute != null)
+ newAttributes.add(defaultAttribute);
+
+ ExceptionsAttribute ea = getExceptionsAttribute();
+ if (ea != null)
+ newAttributes.add(ea);
+
+ AttributeInfo signature
+ = getAttribute(SignatureAttribute.tag);
+ if (signature != null) {
+ signature = signature.copy(cp, null);
+ newAttributes.add(signature);
+ }
+
+ attribute = newAttributes;
+ name = cp.addUtf8Info(getName());
+ descriptor = cp.addUtf8Info(getDescriptor());
+ constPool = cp;
+ }
+
+ /**
+ * Returns a method name.
+ */
+ public String getName() {
+ if (cachedName == null)
+ cachedName = constPool.getUtf8Info(name);
+
+ return cachedName;
+ }
+
+ /**
+ * Sets a method name.
+ */
+ public void setName(String newName) {
+ name = constPool.addUtf8Info(newName);
+ cachedName = newName;
+ }
+
+ /**
+ * Returns true if this is not a constructor or a class initializer (static
+ * initializer).
+ */
+ public boolean isMethod() {
+ String n = getName();
+ return !n.equals(nameInit) && !n.equals(nameClinit);
+ }
+
+ /**
+ * Returns a constant pool table used by this method.
+ */
+ public ConstPool getConstPool() {
+ return constPool;
+ }
+
+ /**
+ * Returns true if this is a constructor.
+ */
+ public boolean isConstructor() {
+ return getName().equals(nameInit);
+ }
+
+ /**
+ * Returns true if this is a class initializer (static initializer).
+ */
+ public boolean isStaticInitializer() {
+ return getName().equals(nameClinit);
+ }
+
+ /**
+ * Returns access flags.
+ *
+ * @see AccessFlag
+ */
+ public int getAccessFlags() {
+ return accessFlags;
+ }
+
+ /**
+ * Sets access flags.
+ *
+ * @see AccessFlag
+ */
+ public void setAccessFlags(int acc) {
+ accessFlags = acc;
+ }
+
+ /**
+ * Returns a method descriptor.
+ *
+ * @see Descriptor
+ */
+ public String getDescriptor() {
+ return constPool.getUtf8Info(descriptor);
+ }
+
+ /**
+ * Sets a method descriptor.
+ *
+ * @see Descriptor
+ */
+ public void setDescriptor(String desc) {
+ if (!desc.equals(getDescriptor()))
+ descriptor = constPool.addUtf8Info(desc);
+ }
+
+ /**
+ * Returns all the attributes. The returned <code>List</code> object
+ * is shared with this object. If you add a new attribute to the list,
+ * the attribute is also added to the method represented by this
+ * object. If you remove an attribute from the list, it is also removed
+ * from the method.
+ *
+ * @return a list of <code>AttributeInfo</code> objects.
+ * @see AttributeInfo
+ */
+ public List getAttributes() {
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ return attribute;
+ }
+
+ /**
+ * Returns the attribute with the specified name. If it is not found, this
+ * method returns null.
+ *
+ * @param name attribute name
+ * @return an <code>AttributeInfo</code> object or null.
+ * @see #getAttributes()
+ */
+ public AttributeInfo getAttribute(String name) {
+ return AttributeInfo.lookup(attribute, name);
+ }
+
+ /**
+ * Appends an attribute. If there is already an attribute with the same
+ * name, the new one substitutes for it.
+ *
+ * @see #getAttributes()
+ */
+ public void addAttribute(AttributeInfo info) {
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ AttributeInfo.remove(attribute, info.getName());
+ attribute.add(info);
+ }
+
+ /**
+ * Returns an Exceptions attribute.
+ *
+ * @return an Exceptions attribute or null if it is not specified.
+ */
+ public ExceptionsAttribute getExceptionsAttribute() {
+ AttributeInfo info = AttributeInfo.lookup(attribute,
+ ExceptionsAttribute.tag);
+ return (ExceptionsAttribute)info;
+ }
+
+ /**
+ * Returns a Code attribute.
+ *
+ * @return a Code attribute or null if it is not specified.
+ */
+ public CodeAttribute getCodeAttribute() {
+ AttributeInfo info = AttributeInfo.lookup(attribute, CodeAttribute.tag);
+ return (CodeAttribute)info;
+ }
+
+ /**
+ * Removes an Exception attribute.
+ */
+ public void removeExceptionsAttribute() {
+ AttributeInfo.remove(attribute, ExceptionsAttribute.tag);
+ }
+
+ /**
+ * Adds an Exception attribute.
+ *
+ * <p>
+ * The added attribute must share the same constant pool table as this
+ * <code>method_info</code> structure.
+ */
+ public void setExceptionsAttribute(ExceptionsAttribute cattr) {
+ removeExceptionsAttribute();
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ attribute.add(cattr);
+ }
+
+ /**
+ * Removes a Code attribute.
+ */
+ public void removeCodeAttribute() {
+ AttributeInfo.remove(attribute, CodeAttribute.tag);
+ }
+
+ /**
+ * Adds a Code attribute.
+ *
+ * <p>
+ * The added attribute must share the same constant pool table as this
+ * <code>method_info</code> structure.
+ */
+ public void setCodeAttribute(CodeAttribute cattr) {
+ removeCodeAttribute();
+ if (attribute == null)
+ attribute = new ArrayList();
+
+ attribute.add(cattr);
+ }
+
+ /**
+ * Rebuilds a stack map table if the class file is for Java 6
+ * or later. Java 5 or older Java VMs do not recognize a stack
+ * map table. If <code>doPreverify</code> is true, this method
+ * also rebuilds a stack map for J2ME (CLDC).
+ *
+ * @param pool used for making type hierarchy.
+ * @param cf rebuild if this class file is for Java 6 or later.
+ * @see #rebuildStackMap(ClassPool)
+ * @see #rebuildStackMapForME(ClassPool)
+ * @since 3.6
+ */
+ public void rebuildStackMapIf6(ClassPool pool, ClassFile cf)
+ throws BadBytecode
+ {
+ if (cf.getMajorVersion() >= ClassFile.JAVA_6)
+ rebuildStackMap(pool);
+
+ if (doPreverify)
+ rebuildStackMapForME(pool);
+ }
+
+ /**
+ * Rebuilds a stack map table. If no stack map table is included,
+ * a new one is created. If this <code>MethodInfo</code> does not
+ * include a code attribute, nothing happens.
+ *
+ * @param pool used for making type hierarchy.
+ * @see StackMapTable
+ * @since 3.6
+ */
+ public void rebuildStackMap(ClassPool pool) throws BadBytecode {
+ CodeAttribute ca = getCodeAttribute();
+ if (ca != null) {
+ StackMapTable smt = MapMaker.make(pool, this);
+ ca.setAttribute(smt);
+ }
+ }
+
+ /**
+ * Rebuilds a stack map table for J2ME (CLDC). If no stack map table is included,
+ * a new one is created. If this <code>MethodInfo</code> does not
+ * include a code attribute, nothing happens.
+ *
+ * @param pool used for making type hierarchy.
+ * @see StackMapTable
+ * @since 3.12
+ */
+ public void rebuildStackMapForME(ClassPool pool) throws BadBytecode {
+ CodeAttribute ca = getCodeAttribute();
+ if (ca != null) {
+ StackMap sm = MapMaker.make2(pool, this);
+ ca.setAttribute(sm);
+ }
+ }
+
+ /**
+ * Returns the line number of the source line corresponding to the specified
+ * bytecode contained in this method.
+ *
+ * @param pos
+ * the position of the bytecode (>= 0). an index into the code
+ * array.
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber(int pos) {
+ CodeAttribute ca = getCodeAttribute();
+ if (ca == null)
+ return -1;
+
+ LineNumberAttribute ainfo = (LineNumberAttribute)ca
+ .getAttribute(LineNumberAttribute.tag);
+ if (ainfo == null)
+ return -1;
+
+ return ainfo.toLineNumber(pos);
+ }
+
+ /**
+ * Changes a super constructor called by this constructor.
+ *
+ * <p>
+ * This method modifies a call to <code>super()</code>, which should be
+ * at the head of a constructor body, so that a constructor in a different
+ * super class is called. This method does not change actual parameters.
+ * Hence the new super class must have a constructor with the same signature
+ * as the original one.
+ *
+ * <p>
+ * This method should be called when the super class of the class declaring
+ * this method is changed.
+ *
+ * <p>
+ * This method does not perform anything unless this <code>MethodInfo</code>
+ * represents a constructor.
+ *
+ * @param superclass
+ * the new super class
+ */
+ public void setSuperclass(String superclass) throws BadBytecode {
+ if (!isConstructor())
+ return;
+
+ CodeAttribute ca = getCodeAttribute();
+ byte[] code = ca.getCode();
+ CodeIterator iterator = ca.iterator();
+ int pos = iterator.skipSuperConstructor();
+ if (pos >= 0) { // not this()
+ ConstPool cp = constPool;
+ int mref = ByteArray.readU16bit(code, pos + 1);
+ int nt = cp.getMethodrefNameAndType(mref);
+ int sc = cp.addClassInfo(superclass);
+ int mref2 = cp.addMethodrefInfo(sc, nt);
+ ByteArray.write16bit(mref2, code, pos + 1);
+ }
+ }
+
+ private void read(MethodInfo src, String methodname, Map classnames)
+ throws BadBytecode {
+ ConstPool destCp = constPool;
+ accessFlags = src.accessFlags;
+ name = destCp.addUtf8Info(methodname);
+ cachedName = methodname;
+ ConstPool srcCp = src.constPool;
+ String desc = srcCp.getUtf8Info(src.descriptor);
+ String desc2 = Descriptor.rename(desc, classnames);
+ descriptor = destCp.addUtf8Info(desc2);
+
+ attribute = new ArrayList();
+ ExceptionsAttribute eattr = src.getExceptionsAttribute();
+ if (eattr != null)
+ attribute.add(eattr.copy(destCp, classnames));
+
+ CodeAttribute cattr = src.getCodeAttribute();
+ if (cattr != null)
+ attribute.add(cattr.copy(destCp, classnames));
+ }
+
+ private void read(DataInputStream in) throws IOException {
+ accessFlags = in.readUnsignedShort();
+ name = in.readUnsignedShort();
+ descriptor = in.readUnsignedShort();
+ int n = in.readUnsignedShort();
+ attribute = new ArrayList();
+ for (int i = 0; i < n; ++i)
+ attribute.add(AttributeInfo.read(constPool, in));
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ out.writeShort(accessFlags);
+ out.writeShort(name);
+ out.writeShort(descriptor);
+
+ if (attribute == null)
+ out.writeShort(0);
+ else {
+ out.writeShort(attribute.size());
+ AttributeInfo.writeAll(attribute, out);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/Mnemonic.java b/src/main/javassist/bytecode/Mnemonic.java
new file mode 100644
index 0000000..2eb596a
--- /dev/null
+++ b/src/main/javassist/bytecode/Mnemonic.java
@@ -0,0 +1,241 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * JVM Instruction Names.
+ *
+ * <p>This interface has been separated from javassist.bytecode.Opcode
+ * because typical bytecode translators do not use mnemonics. If this
+ * interface were merged with Opcode, extra memory would be unnecessary
+ * consumed.
+ *
+ * @see Opcode
+ */
+public interface Mnemonic {
+
+ /**
+ * The instruction names (mnemonics) sorted by the opcode.
+ * The length of this array is 202 (jsr_w=201).
+ *
+ * <p>The value at index 186 is null since no instruction is
+ * assigned to 186.
+ */
+ String[] OPCODE = {
+ "nop", /* 0*/
+ "aconst_null", /* 1*/
+ "iconst_m1", /* 2*/
+ "iconst_0", /* 3*/
+ "iconst_1", /* 4*/
+ "iconst_2", /* 5*/
+ "iconst_3", /* 6*/
+ "iconst_4", /* 7*/
+ "iconst_5", /* 8*/
+ "lconst_0", /* 9*/
+ "lconst_1", /* 10*/
+ "fconst_0", /* 11*/
+ "fconst_1", /* 12*/
+ "fconst_2", /* 13*/
+ "dconst_0", /* 14*/
+ "dconst_1", /* 15*/
+ "bipush", /* 16*/
+ "sipush", /* 17*/
+ "ldc", /* 18*/
+ "ldc_w", /* 19*/
+ "ldc2_w", /* 20*/
+ "iload", /* 21*/
+ "lload", /* 22*/
+ "fload", /* 23*/
+ "dload", /* 24*/
+ "aload", /* 25*/
+ "iload_0", /* 26*/
+ "iload_1", /* 27*/
+ "iload_2", /* 28*/
+ "iload_3", /* 29*/
+ "lload_0", /* 30*/
+ "lload_1", /* 31*/
+ "lload_2", /* 32*/
+ "lload_3", /* 33*/
+ "fload_0", /* 34*/
+ "fload_1", /* 35*/
+ "fload_2", /* 36*/
+ "fload_3", /* 37*/
+ "dload_0", /* 38*/
+ "dload_1", /* 39*/
+ "dload_2", /* 40*/
+ "dload_3", /* 41*/
+ "aload_0", /* 42*/
+ "aload_1", /* 43*/
+ "aload_2", /* 44*/
+ "aload_3", /* 45*/
+ "iaload", /* 46*/
+ "laload", /* 47*/
+ "faload", /* 48*/
+ "daload", /* 49*/
+ "aaload", /* 50*/
+ "baload", /* 51*/
+ "caload", /* 52*/
+ "saload", /* 53*/
+ "istore", /* 54*/
+ "lstore", /* 55*/
+ "fstore", /* 56*/
+ "dstore", /* 57*/
+ "astore", /* 58*/
+ "istore_0", /* 59*/
+ "istore_1", /* 60*/
+ "istore_2", /* 61*/
+ "istore_3", /* 62*/
+ "lstore_0", /* 63*/
+ "lstore_1", /* 64*/
+ "lstore_2", /* 65*/
+ "lstore_3", /* 66*/
+ "fstore_0", /* 67*/
+ "fstore_1", /* 68*/
+ "fstore_2", /* 69*/
+ "fstore_3", /* 70*/
+ "dstore_0", /* 71*/
+ "dstore_1", /* 72*/
+ "dstore_2", /* 73*/
+ "dstore_3", /* 74*/
+ "astore_0", /* 75*/
+ "astore_1", /* 76*/
+ "astore_2", /* 77*/
+ "astore_3", /* 78*/
+ "iastore", /* 79*/
+ "lastore", /* 80*/
+ "fastore", /* 81*/
+ "dastore", /* 82*/
+ "aastore", /* 83*/
+ "bastore", /* 84*/
+ "castore", /* 85*/
+ "sastore", /* 86*/
+ "pop", /* 87*/
+ "pop2", /* 88*/
+ "dup", /* 89*/
+ "dup_x1", /* 90*/
+ "dup_x2", /* 91*/
+ "dup2", /* 92*/
+ "dup2_x1", /* 93*/
+ "dup2_x2", /* 94*/
+ "swap", /* 95*/
+ "iadd", /* 96*/
+ "ladd", /* 97*/
+ "fadd", /* 98*/
+ "dadd", /* 99*/
+ "isub", /* 100*/
+ "lsub", /* 101*/
+ "fsub", /* 102*/
+ "dsub", /* 103*/
+ "imul", /* 104*/
+ "lmul", /* 105*/
+ "fmul", /* 106*/
+ "dmul", /* 107*/
+ "idiv", /* 108*/
+ "ldiv", /* 109*/
+ "fdiv", /* 110*/
+ "ddiv", /* 111*/
+ "irem", /* 112*/
+ "lrem", /* 113*/
+ "frem", /* 114*/
+ "drem", /* 115*/
+ "ineg", /* 116*/
+ "lneg", /* 117*/
+ "fneg", /* 118*/
+ "dneg", /* 119*/
+ "ishl", /* 120*/
+ "lshl", /* 121*/
+ "ishr", /* 122*/
+ "lshr", /* 123*/
+ "iushr", /* 124*/
+ "lushr", /* 125*/
+ "iand", /* 126*/
+ "land", /* 127*/
+ "ior", /* 128*/
+ "lor", /* 129*/
+ "ixor", /* 130*/
+ "lxor", /* 131*/
+ "iinc", /* 132*/
+ "i2l", /* 133*/
+ "i2f", /* 134*/
+ "i2d", /* 135*/
+ "l2i", /* 136*/
+ "l2f", /* 137*/
+ "l2d", /* 138*/
+ "f2i", /* 139*/
+ "f2l", /* 140*/
+ "f2d", /* 141*/
+ "d2i", /* 142*/
+ "d2l", /* 143*/
+ "d2f", /* 144*/
+ "i2b", /* 145*/
+ "i2c", /* 146*/
+ "i2s", /* 147*/
+ "lcmp", /* 148*/
+ "fcmpl", /* 149*/
+ "fcmpg", /* 150*/
+ "dcmpl", /* 151*/
+ "dcmpg", /* 152*/
+ "ifeq", /* 153*/
+ "ifne", /* 154*/
+ "iflt", /* 155*/
+ "ifge", /* 156*/
+ "ifgt", /* 157*/
+ "ifle", /* 158*/
+ "if_icmpeq", /* 159*/
+ "if_icmpne", /* 160*/
+ "if_icmplt", /* 161*/
+ "if_icmpge", /* 162*/
+ "if_icmpgt", /* 163*/
+ "if_icmple", /* 164*/
+ "if_acmpeq", /* 165*/
+ "if_acmpne", /* 166*/
+ "goto", /* 167*/
+ "jsr", /* 168*/
+ "ret", /* 169*/
+ "tableswitch", /* 170*/
+ "lookupswitch", /* 171*/
+ "ireturn", /* 172*/
+ "lreturn", /* 173*/
+ "freturn", /* 174*/
+ "dreturn", /* 175*/
+ "areturn", /* 176*/
+ "return", /* 177*/
+ "getstatic", /* 178*/
+ "putstatic", /* 179*/
+ "getfield", /* 180*/
+ "putfield", /* 181*/
+ "invokevirtual", /* 182*/
+ "invokespecial", /* 183*/
+ "invokestatic", /* 184*/
+ "invokeinterface", /* 185*/
+ null,
+ "new", /* 187*/
+ "newarray", /* 188*/
+ "anewarray", /* 189*/
+ "arraylength", /* 190*/
+ "athrow", /* 191*/
+ "checkcast", /* 192*/
+ "instanceof", /* 193*/
+ "monitorenter", /* 194*/
+ "monitorexit", /* 195*/
+ "wide", /* 196*/
+ "multianewarray", /* 197*/
+ "ifnull", /* 198*/
+ "ifnonnull", /* 199*/
+ "goto_w", /* 200*/
+ "jsr_w" /* 201*/
+ };
+}
diff --git a/src/main/javassist/bytecode/Opcode.java b/src/main/javassist/bytecode/Opcode.java
new file mode 100644
index 0000000..db34b11
--- /dev/null
+++ b/src/main/javassist/bytecode/Opcode.java
@@ -0,0 +1,447 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+/**
+ * JVM Instruction Set.
+ *
+ * <p>This interface defines opcodes and
+ * array types for the NEWARRAY instruction.
+ *
+ * @see Mnemonic
+ */
+public interface Opcode {
+ /* Opcodes */
+
+ int AALOAD = 50;
+ int AASTORE = 83;
+ int ACONST_NULL = 1;
+ int ALOAD = 25;
+ int ALOAD_0 = 42;
+ int ALOAD_1 = 43;
+ int ALOAD_2 = 44;
+ int ALOAD_3 = 45;
+ int ANEWARRAY = 189;
+ int ARETURN = 176;
+ int ARRAYLENGTH = 190;
+ int ASTORE = 58;
+ int ASTORE_0 = 75;
+ int ASTORE_1 = 76;
+ int ASTORE_2 = 77;
+ int ASTORE_3 = 78;
+ int ATHROW = 191;
+ int BALOAD = 51;
+ int BASTORE = 84;
+ int BIPUSH = 16;
+ int CALOAD = 52;
+ int CASTORE = 85;
+ int CHECKCAST = 192;
+ int D2F = 144;
+ int D2I = 142;
+ int D2L = 143;
+ int DADD = 99;
+ int DALOAD = 49;
+ int DASTORE = 82;
+ int DCMPG = 152;
+ int DCMPL = 151;
+ int DCONST_0 = 14;
+ int DCONST_1 = 15;
+ int DDIV = 111;
+ int DLOAD = 24;
+ int DLOAD_0 = 38;
+ int DLOAD_1 = 39;
+ int DLOAD_2 = 40;
+ int DLOAD_3 = 41;
+ int DMUL = 107;
+ int DNEG = 119;
+ int DREM = 115;
+ int DRETURN = 175;
+ int DSTORE = 57;
+ int DSTORE_0 = 71;
+ int DSTORE_1 = 72;
+ int DSTORE_2 = 73;
+ int DSTORE_3 = 74;
+ int DSUB = 103;
+ int DUP = 89;
+ int DUP2 = 92;
+ int DUP2_X1 = 93;
+ int DUP2_X2 = 94;
+ int DUP_X1 = 90;
+ int DUP_X2 = 91;
+ int F2D = 141;
+ int F2I = 139;
+ int F2L = 140;
+ int FADD = 98;
+ int FALOAD = 48;
+ int FASTORE = 81;
+ int FCMPG = 150;
+ int FCMPL = 149;
+ int FCONST_0 = 11;
+ int FCONST_1 = 12;
+ int FCONST_2 = 13;
+ int FDIV = 110;
+ int FLOAD = 23;
+ int FLOAD_0 = 34;
+ int FLOAD_1 = 35;
+ int FLOAD_2 = 36;
+ int FLOAD_3 = 37;
+ int FMUL = 106;
+ int FNEG = 118;
+ int FREM = 114;
+ int FRETURN = 174;
+ int FSTORE = 56;
+ int FSTORE_0 = 67;
+ int FSTORE_1 = 68;
+ int FSTORE_2 = 69;
+ int FSTORE_3 = 70;
+ int FSUB = 102;
+ int GETFIELD = 180;
+ int GETSTATIC = 178;
+ int GOTO = 167;
+ int GOTO_W = 200;
+ int I2B = 145;
+ int I2C = 146;
+ int I2D = 135;
+ int I2F = 134;
+ int I2L = 133;
+ int I2S = 147;
+ int IADD = 96;
+ int IALOAD = 46;
+ int IAND = 126;
+ int IASTORE = 79;
+ int ICONST_0 = 3;
+ int ICONST_1 = 4;
+ int ICONST_2 = 5;
+ int ICONST_3 = 6;
+ int ICONST_4 = 7;
+ int ICONST_5 = 8;
+ int ICONST_M1 = 2;
+ int IDIV = 108;
+ int IFEQ = 153;
+ int IFGE = 156;
+ int IFGT = 157;
+ int IFLE = 158;
+ int IFLT = 155;
+ int IFNE = 154;
+ int IFNONNULL = 199;
+ int IFNULL = 198;
+ int IF_ACMPEQ = 165;
+ int IF_ACMPNE = 166;
+ int IF_ICMPEQ = 159;
+ int IF_ICMPGE = 162;
+ int IF_ICMPGT = 163;
+ int IF_ICMPLE = 164;
+ int IF_ICMPLT = 161;
+ int IF_ICMPNE = 160;
+ int IINC = 132;
+ int ILOAD = 21;
+ int ILOAD_0 = 26;
+ int ILOAD_1 = 27;
+ int ILOAD_2 = 28;
+ int ILOAD_3 = 29;
+ int IMUL = 104;
+ int INEG = 116;
+ int INSTANCEOF = 193;
+ int INVOKEINTERFACE = 185;
+ int INVOKESPECIAL = 183;
+ int INVOKESTATIC = 184;
+ int INVOKEVIRTUAL = 182;
+ int IOR = 128;
+ int IREM = 112;
+ int IRETURN = 172;
+ int ISHL = 120;
+ int ISHR = 122;
+ int ISTORE = 54;
+ int ISTORE_0 = 59;
+ int ISTORE_1 = 60;
+ int ISTORE_2 = 61;
+ int ISTORE_3 = 62;
+ int ISUB = 100;
+ int IUSHR = 124;
+ int IXOR = 130;
+ int JSR = 168;
+ int JSR_W = 201;
+ int L2D = 138;
+ int L2F = 137;
+ int L2I = 136;
+ int LADD = 97;
+ int LALOAD = 47;
+ int LAND = 127;
+ int LASTORE = 80;
+ int LCMP = 148;
+ int LCONST_0 = 9;
+ int LCONST_1 = 10;
+ int LDC = 18;
+ int LDC2_W = 20;
+ int LDC_W = 19;
+ int LDIV = 109;
+ int LLOAD = 22;
+ int LLOAD_0 = 30;
+ int LLOAD_1 = 31;
+ int LLOAD_2 = 32;
+ int LLOAD_3 = 33;
+ int LMUL = 105;
+ int LNEG = 117;
+ int LOOKUPSWITCH = 171;
+ int LOR = 129;
+ int LREM = 113;
+ int LRETURN = 173;
+ int LSHL = 121;
+ int LSHR = 123;
+ int LSTORE = 55;
+ int LSTORE_0 = 63;
+ int LSTORE_1 = 64;
+ int LSTORE_2 = 65;
+ int LSTORE_3 = 66;
+ int LSUB = 101;
+ int LUSHR = 125;
+ int LXOR = 131;
+ int MONITORENTER = 194;
+ int MONITOREXIT = 195;
+ int MULTIANEWARRAY = 197;
+ int NEW = 187;
+ int NEWARRAY = 188;
+ int NOP = 0;
+ int POP = 87;
+ int POP2 = 88;
+ int PUTFIELD = 181;
+ int PUTSTATIC = 179;
+ int RET = 169;
+ int RETURN = 177;
+ int SALOAD = 53;
+ int SASTORE = 86;
+ int SIPUSH = 17;
+ int SWAP = 95;
+ int TABLESWITCH = 170;
+ int WIDE = 196;
+
+ /* array-type code for the newarray instruction */
+
+ int T_BOOLEAN = 4;
+ int T_CHAR = 5;
+ int T_FLOAT = 6;
+ int T_DOUBLE = 7;
+ int T_BYTE = 8;
+ int T_SHORT = 9;
+ int T_INT = 10;
+ int T_LONG = 11;
+
+ /* how many values are pushed on the operand stack. */
+ int[] STACK_GROW = {
+ 0, // nop, 0
+ 1, // aconst_null, 1
+ 1, // iconst_m1, 2
+ 1, // iconst_0, 3
+ 1, // iconst_1, 4
+ 1, // iconst_2, 5
+ 1, // iconst_3, 6
+ 1, // iconst_4, 7
+ 1, // iconst_5, 8
+ 2, // lconst_0, 9
+ 2, // lconst_1, 10
+ 1, // fconst_0, 11
+ 1, // fconst_1, 12
+ 1, // fconst_2, 13
+ 2, // dconst_0, 14
+ 2, // dconst_1, 15
+ 1, // bipush, 16
+ 1, // sipush, 17
+ 1, // ldc, 18
+ 1, // ldc_w, 19
+ 2, // ldc2_w, 20
+ 1, // iload, 21
+ 2, // lload, 22
+ 1, // fload, 23
+ 2, // dload, 24
+ 1, // aload, 25
+ 1, // iload_0, 26
+ 1, // iload_1, 27
+ 1, // iload_2, 28
+ 1, // iload_3, 29
+ 2, // lload_0, 30
+ 2, // lload_1, 31
+ 2, // lload_2, 32
+ 2, // lload_3, 33
+ 1, // fload_0, 34
+ 1, // fload_1, 35
+ 1, // fload_2, 36
+ 1, // fload_3, 37
+ 2, // dload_0, 38
+ 2, // dload_1, 39
+ 2, // dload_2, 40
+ 2, // dload_3, 41
+ 1, // aload_0, 42
+ 1, // aload_1, 43
+ 1, // aload_2, 44
+ 1, // aload_3, 45
+ -1, // iaload, 46
+ 0, // laload, 47
+ -1, // faload, 48
+ 0, // daload, 49
+ -1, // aaload, 50
+ -1, // baload, 51
+ -1, // caload, 52
+ -1, // saload, 53
+ -1, // istore, 54
+ -2, // lstore, 55
+ -1, // fstore, 56
+ -2, // dstore, 57
+ -1, // astore, 58
+ -1, // istore_0, 59
+ -1, // istore_1, 60
+ -1, // istore_2, 61
+ -1, // istore_3, 62
+ -2, // lstore_0, 63
+ -2, // lstore_1, 64
+ -2, // lstore_2, 65
+ -2, // lstore_3, 66
+ -1, // fstore_0, 67
+ -1, // fstore_1, 68
+ -1, // fstore_2, 69
+ -1, // fstore_3, 70
+ -2, // dstore_0, 71
+ -2, // dstore_1, 72
+ -2, // dstore_2, 73
+ -2, // dstore_3, 74
+ -1, // astore_0, 75
+ -1, // astore_1, 76
+ -1, // astore_2, 77
+ -1, // astore_3, 78
+ -3, // iastore, 79
+ -4, // lastore, 80
+ -3, // fastore, 81
+ -4, // dastore, 82
+ -3, // aastore, 83
+ -3, // bastore, 84
+ -3, // castore, 85
+ -3, // sastore, 86
+ -1, // pop, 87
+ -2, // pop2, 88
+ 1, // dup, 89
+ 1, // dup_x1, 90
+ 1, // dup_x2, 91
+ 2, // dup2, 92
+ 2, // dup2_x1, 93
+ 2, // dup2_x2, 94
+ 0, // swap, 95
+ -1, // iadd, 96
+ -2, // ladd, 97
+ -1, // fadd, 98
+ -2, // dadd, 99
+ -1, // isub, 100
+ -2, // lsub, 101
+ -1, // fsub, 102
+ -2, // dsub, 103
+ -1, // imul, 104
+ -2, // lmul, 105
+ -1, // fmul, 106
+ -2, // dmul, 107
+ -1, // idiv, 108
+ -2, // ldiv, 109
+ -1, // fdiv, 110
+ -2, // ddiv, 111
+ -1, // irem, 112
+ -2, // lrem, 113
+ -1, // frem, 114
+ -2, // drem, 115
+ 0, // ineg, 116
+ 0, // lneg, 117
+ 0, // fneg, 118
+ 0, // dneg, 119
+ -1, // ishl, 120
+ -1, // lshl, 121
+ -1, // ishr, 122
+ -1, // lshr, 123
+ -1, // iushr, 124
+ -1, // lushr, 125
+ -1, // iand, 126
+ -2, // land, 127
+ -1, // ior, 128
+ -2, // lor, 129
+ -1, // ixor, 130
+ -2, // lxor, 131
+ 0, // iinc, 132
+ 1, // i2l, 133
+ 0, // i2f, 134
+ 1, // i2d, 135
+ -1, // l2i, 136
+ -1, // l2f, 137
+ 0, // l2d, 138
+ 0, // f2i, 139
+ 1, // f2l, 140
+ 1, // f2d, 141
+ -1, // d2i, 142
+ 0, // d2l, 143
+ -1, // d2f, 144
+ 0, // i2b, 145
+ 0, // i2c, 146
+ 0, // i2s, 147
+ -3, // lcmp, 148
+ -1, // fcmpl, 149
+ -1, // fcmpg, 150
+ -3, // dcmpl, 151
+ -3, // dcmpg, 152
+ -1, // ifeq, 153
+ -1, // ifne, 154
+ -1, // iflt, 155
+ -1, // ifge, 156
+ -1, // ifgt, 157
+ -1, // ifle, 158
+ -2, // if_icmpeq, 159
+ -2, // if_icmpne, 160
+ -2, // if_icmplt, 161
+ -2, // if_icmpge, 162
+ -2, // if_icmpgt, 163
+ -2, // if_icmple, 164
+ -2, // if_acmpeq, 165
+ -2, // if_acmpne, 166
+ 0, // goto, 167
+ 1, // jsr, 168
+ 0, // ret, 169
+ -1, // tableswitch, 170
+ -1, // lookupswitch, 171
+ -1, // ireturn, 172
+ -2, // lreturn, 173
+ -1, // freturn, 174
+ -2, // dreturn, 175
+ -1, // areturn, 176
+ 0, // return, 177
+ 0, // getstatic, 178 depends on the type
+ 0, // putstatic, 179 depends on the type
+ 0, // getfield, 180 depends on the type
+ 0, // putfield, 181 depends on the type
+ 0, // invokevirtual, 182 depends on the type
+ 0, // invokespecial, 183 depends on the type
+ 0, // invokestatic, 184 depends on the type
+ 0, // invokeinterface, 185 depends on the type
+ 0, // undefined, 186
+ 1, // new, 187
+ 0, // newarray, 188
+ 0, // anewarray, 189
+ 0, // arraylength, 190
+ -1, // athrow, 191 stack is cleared
+ 0, // checkcast, 192
+ 0, // instanceof, 193
+ -1, // monitorenter, 194
+ -1, // monitorexit, 195
+ 0, // wide, 196 depends on the following opcode
+ 0, // multianewarray, 197 depends on the dimensions
+ -1, // ifnull, 198
+ -1, // ifnonnull, 199
+ 0, // goto_w, 200
+ 1 // jsr_w, 201
+ };
+}
diff --git a/src/main/javassist/bytecode/ParameterAnnotationsAttribute.java b/src/main/javassist/bytecode/ParameterAnnotationsAttribute.java
new file mode 100644
index 0000000..246afc1
--- /dev/null
+++ b/src/main/javassist/bytecode/ParameterAnnotationsAttribute.java
@@ -0,0 +1,214 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.io.IOException;
+import java.io.DataInputStream;
+import java.io.ByteArrayOutputStream;
+
+import javassist.bytecode.AnnotationsAttribute.Copier;
+import javassist.bytecode.AnnotationsAttribute.Parser;
+import javassist.bytecode.AnnotationsAttribute.Renamer;
+import javassist.bytecode.annotation.*;
+
+/**
+ * A class representing <code>RuntimeVisibleAnnotations_attribute</code> and
+ * <code>RuntimeInvisibleAnnotations_attribute</code>.
+ *
+ * <p>To obtain an ParameterAnnotationAttribute object, invoke
+ * <code>getAttribute(ParameterAnnotationsAttribute.invisibleTag)</code>
+ * in <code>MethodInfo</code>.
+ * The obtained attribute is a
+ * runtime invisible annotations attribute.
+ * If the parameter is
+ * <code>ParameterAnnotationAttribute.visibleTag</code>, then the obtained
+ * attribute is a runtime visible one.
+ */
+public class ParameterAnnotationsAttribute extends AttributeInfo {
+ /**
+ * The name of the <code>RuntimeVisibleParameterAnnotations</code>
+ * attribute.
+ */
+ public static final String visibleTag
+ = "RuntimeVisibleParameterAnnotations";
+
+ /**
+ * The name of the <code>RuntimeInvisibleParameterAnnotations</code>
+ * attribute.
+ */
+ public static final String invisibleTag
+ = "RuntimeInvisibleParameterAnnotations";
+ /**
+ * Constructs
+ * a <code>Runtime(In)VisibleParameterAnnotations_attribute</code>.
+ *
+ * @param cp constant pool
+ * @param attrname attribute name (<code>visibleTag</code> or
+ * <code>invisibleTag</code>).
+ * @param info the contents of this attribute. It does not
+ * include <code>attribute_name_index</code> or
+ * <code>attribute_length</code>.
+ */
+ public ParameterAnnotationsAttribute(ConstPool cp, String attrname,
+ byte[] info) {
+ super(cp, attrname, info);
+ }
+
+ /**
+ * Constructs an empty
+ * <code>Runtime(In)VisibleParameterAnnotations_attribute</code>.
+ * A new annotation can be later added to the created attribute
+ * by <code>setAnnotations()</code>.
+ *
+ * @param cp constant pool
+ * @param attrname attribute name (<code>visibleTag</code> or
+ * <code>invisibleTag</code>).
+ * @see #setAnnotations(Annotation[][])
+ */
+ public ParameterAnnotationsAttribute(ConstPool cp, String attrname) {
+ this(cp, attrname, new byte[] { 0 });
+ }
+
+ /**
+ * @param n the attribute name.
+ */
+ ParameterAnnotationsAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Returns <code>num_parameters</code>.
+ */
+ public int numParameters() {
+ return info[0] & 0xff;
+ }
+
+ /**
+ * Copies this attribute and returns a new copy.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ Copier copier = new Copier(info, constPool, newCp, classnames);
+ try {
+ copier.parameters();
+ return new ParameterAnnotationsAttribute(newCp, getName(),
+ copier.close());
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Parses the annotations and returns a data structure representing
+ * that parsed annotations. Note that changes of the node values of the
+ * returned tree are not reflected on the annotations represented by
+ * this object unless the tree is copied back to this object by
+ * <code>setAnnotations()</code>.
+ *
+ * @return Each element of the returned array represents an array of
+ * annotations that are associated with each method parameter.
+ *
+ * @see #setAnnotations(Annotation[][])
+ */
+ public Annotation[][] getAnnotations() {
+ try {
+ return new Parser(info, constPool).parseParameters();
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Changes the annotations represented by this object according to
+ * the given array of <code>Annotation</code> objects.
+ *
+ * @param params the data structure representing the
+ * new annotations. Every element of this array
+ * is an array of <code>Annotation</code> and
+ * it represens annotations of each method parameter.
+ */
+ public void setAnnotations(Annotation[][] params) {
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+ AnnotationsWriter writer = new AnnotationsWriter(output, constPool);
+ try {
+ int n = params.length;
+ writer.numParameters(n);
+ for (int i = 0; i < n; ++i) {
+ Annotation[] anno = params[i];
+ writer.numAnnotations(anno.length);
+ for (int j = 0; j < anno.length; ++j)
+ anno[j].write(writer);
+ }
+
+ writer.close();
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e); // should never reach here.
+ }
+
+ set(output.toByteArray());
+ }
+
+ /**
+ * @param oldname a JVM class name.
+ * @param newname a JVM class name.
+ */
+ void renameClass(String oldname, String newname) {
+ HashMap map = new HashMap();
+ map.put(oldname, newname);
+ renameClass(map);
+ }
+
+ void renameClass(Map classnames) {
+ Renamer renamer = new Renamer(info, getConstPool(), classnames);
+ try {
+ renamer.parameters();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ void getRefClasses(Map classnames) { renameClass(classnames); }
+
+ /**
+ * Returns a string representation of this object.
+ */
+ public String toString() {
+ Annotation[][] aa = getAnnotations();
+ StringBuilder sbuf = new StringBuilder();
+ int k = 0;
+ while (k < aa.length) {
+ Annotation[] a = aa[k++];
+ int i = 0;
+ while (i < a.length) {
+ sbuf.append(a[i++].toString());
+ if (i != a.length)
+ sbuf.append(" ");
+ }
+
+ if (k != aa.length)
+ sbuf.append(", ");
+ }
+
+ return sbuf.toString();
+
+ }
+}
diff --git a/src/main/javassist/bytecode/SignatureAttribute.java b/src/main/javassist/bytecode/SignatureAttribute.java
new file mode 100644
index 0000000..958e93f
--- /dev/null
+++ b/src/main/javassist/bytecode/SignatureAttribute.java
@@ -0,0 +1,828 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+import java.util.ArrayList;
+import javassist.CtClass;
+
+/**
+ * <code>Signature_attribute</code>.
+ */
+public class SignatureAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"Signature"</code>.
+ */
+ public static final String tag = "Signature";
+
+ SignatureAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a Signature attribute.
+ *
+ * @param cp a constant pool table.
+ * @param signature the signature represented by this attribute.
+ */
+ public SignatureAttribute(ConstPool cp, String signature) {
+ super(cp, tag);
+ int index = cp.addUtf8Info(signature);
+ byte[] bvalue = new byte[2];
+ bvalue[0] = (byte)(index >>> 8);
+ bvalue[1] = (byte)index;
+ set(bvalue);
+ }
+
+ /**
+ * Returns the signature indicated by <code>signature_index</code>.
+ *
+ * @see #toClassSignature(String)
+ * @see #toMethodSignature(String)
+ */
+ public String getSignature() {
+ return getConstPool().getUtf8Info(ByteArray.readU16bit(get(), 0));
+ }
+
+ /**
+ * Sets <code>signature_index</code> to the index of the given signature,
+ * which is added to a constant pool.
+ *
+ * @param sig new signature.
+ * @since 3.11
+ */
+ public void setSignature(String sig) {
+ int index = getConstPool().addUtf8Info(sig);
+ ByteArray.write16bit(index, info, 0);
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ return new SignatureAttribute(newCp, getSignature());
+ }
+
+ void renameClass(String oldname, String newname) {
+ String sig = renameClass(getSignature(), oldname, newname);
+ setSignature(sig);
+ }
+
+ void renameClass(Map classnames) {
+ String sig = renameClass(getSignature(), classnames);
+ setSignature(sig);
+ }
+
+ static String renameClass(String desc, String oldname, String newname) {
+ Map map = new java.util.HashMap();
+ map.put(oldname, newname);
+ return renameClass(desc, map);
+ }
+
+ static String renameClass(String desc, Map map) {
+ if (map == null)
+ return desc;
+
+ StringBuilder newdesc = new StringBuilder();
+ int head = 0;
+ int i = 0;
+ for (;;) {
+ int j = desc.indexOf('L', i);
+ if (j < 0)
+ break;
+
+ StringBuilder nameBuf = new StringBuilder();
+ int k = j;
+ char c;
+ try {
+ while ((c = desc.charAt(++k)) != ';') {
+ nameBuf.append(c);
+ if (c == '<') {
+ while ((c = desc.charAt(++k)) != '>')
+ nameBuf.append(c);
+
+ nameBuf.append(c);
+ }
+ }
+ }
+ catch (IndexOutOfBoundsException e) { break; }
+ i = k + 1;
+ String name = nameBuf.toString();
+ String name2 = (String)map.get(name);
+ if (name2 != null) {
+ newdesc.append(desc.substring(head, j));
+ newdesc.append('L');
+ newdesc.append(name2);
+ newdesc.append(c);
+ head = i;
+ }
+ }
+
+ if (head == 0)
+ return desc;
+ else {
+ int len = desc.length();
+ if (head < len)
+ newdesc.append(desc.substring(head, len));
+
+ return newdesc.toString();
+ }
+ }
+
+ private static boolean isNamePart(int c) {
+ return c != ';' && c != '<';
+ }
+
+ static private class Cursor {
+ int position = 0;
+
+ int indexOf(String s, int ch) throws BadBytecode {
+ int i = s.indexOf(ch, position);
+ if (i < 0)
+ throw error(s);
+ else {
+ position = i + 1;
+ return i;
+ }
+ }
+ }
+
+ /**
+ * Class signature.
+ */
+ public static class ClassSignature {
+ TypeParameter[] params;
+ ClassType superClass;
+ ClassType[] interfaces;
+ ClassSignature(TypeParameter[] p, ClassType s, ClassType[] i) {
+ params = p;
+ superClass = s;
+ interfaces = i;
+ }
+
+ /**
+ * Returns the type parameters.
+ *
+ * @return a zero-length array if the type parameters are not specified.
+ */
+ public TypeParameter[] getParameters() {
+ return params;
+ }
+
+ /**
+ * Returns the super class.
+ */
+ public ClassType getSuperClass() { return superClass; }
+
+ /**
+ * Returns the super interfaces.
+ *
+ * @return a zero-length array if the super interfaces are not specified.
+ */
+ public ClassType[] getInterfaces() { return interfaces; }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+
+ TypeParameter.toString(sbuf, params);
+ sbuf.append(" extends ").append(superClass);
+ if (interfaces.length > 0) {
+ sbuf.append(" implements ");
+ Type.toString(sbuf, interfaces);
+ }
+
+ return sbuf.toString();
+ }
+ }
+
+ /**
+ * Method type signature.
+ */
+ public static class MethodSignature {
+ TypeParameter[] typeParams;
+ Type[] params;
+ Type retType;
+ ObjectType[] exceptions;
+
+ MethodSignature(TypeParameter[] tp, Type[] p, Type ret, ObjectType[] ex) {
+ typeParams = tp;
+ params = p;
+ retType = ret;
+ exceptions = ex;
+ }
+
+ /**
+ * Returns the formal type parameters.
+ *
+ * @return a zero-length array if the type parameters are not specified.
+ */
+ public TypeParameter[] getTypeParameters() { return typeParams; }
+
+ /**
+ * Returns the types of the formal parameters.
+ *
+ * @return a zero-length array if no formal parameter is taken.
+ */
+ public Type[] getParameterTypes() { return params; }
+
+ /**
+ * Returns the type of the returned value.
+ */
+ public Type getReturnType() { return retType; }
+
+ /**
+ * Returns the types of the exceptions that may be thrown.
+ *
+ * @return a zero-length array if exceptions are never thrown or
+ * the exception types are not parameterized types or type variables.
+ */
+ public ObjectType[] getExceptionTypes() { return exceptions; }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+
+ TypeParameter.toString(sbuf, typeParams);
+ sbuf.append(" (");
+ Type.toString(sbuf, params);
+ sbuf.append(") ");
+ sbuf.append(retType);
+ if (exceptions.length > 0) {
+ sbuf.append(" throws ");
+ Type.toString(sbuf, exceptions);
+ }
+
+ return sbuf.toString();
+ }
+ }
+
+ /**
+ * Formal type parameters.
+ */
+ public static class TypeParameter {
+ String name;
+ ObjectType superClass;
+ ObjectType[] superInterfaces;
+
+ TypeParameter(String sig, int nb, int ne, ObjectType sc, ObjectType[] si) {
+ name = sig.substring(nb, ne);
+ superClass = sc;
+ superInterfaces = si;
+ }
+
+ /**
+ * Returns the name of the type parameter.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Returns the class bound of this parameter.
+ *
+ * @return null if the class bound is not specified.
+ */
+ public ObjectType getClassBound() { return superClass; }
+
+ /**
+ * Returns the interface bound of this parameter.
+ *
+ * @return a zero-length array if the interface bound is not specified.
+ */
+ public ObjectType[] getInterfaceBound() { return superInterfaces; }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer(getName());
+ if (superClass != null)
+ sbuf.append(" extends ").append(superClass.toString());
+
+ int len = superInterfaces.length;
+ if (len > 0) {
+ for (int i = 0; i < len; i++) {
+ if (i > 0 || superClass != null)
+ sbuf.append(" & ");
+ else
+ sbuf.append(" extends ");
+
+ sbuf.append(superInterfaces[i].toString());
+ }
+ }
+
+ return sbuf.toString();
+ }
+
+ static void toString(StringBuffer sbuf, TypeParameter[] tp) {
+ sbuf.append('<');
+ for (int i = 0; i < tp.length; i++) {
+ if (i > 0)
+ sbuf.append(", ");
+
+ sbuf.append(tp[i]);
+ }
+
+ sbuf.append('>');
+ }
+ }
+
+ /**
+ * Type argument.
+ */
+ public static class TypeArgument {
+ ObjectType arg;
+ char wildcard;
+
+ TypeArgument(ObjectType a, char w) {
+ arg = a;
+ wildcard = w;
+ }
+
+ /**
+ * Returns the kind of this type argument.
+ *
+ * @return <code>' '</code> (not-wildcard), <code>'*'</code> (wildcard), <code>'+'</code> (wildcard with
+ * upper bound), or <code>'-'</code> (wildcard with lower bound).
+ */
+ public char getKind() { return wildcard; }
+
+ /**
+ * Returns true if this type argument is a wildcard type
+ * such as <code>?</code>, <code>? extends String</code>, or <code>? super Integer</code>.
+ */
+ public boolean isWildcard() { return wildcard != ' '; }
+
+ /**
+ * Returns the type represented by this argument
+ * if the argument is not a wildcard type. Otherwise, this method
+ * returns the upper bound (if the kind is '+'),
+ * the lower bound (if the kind is '-'), or null (if the upper or lower
+ * bound is not specified).
+ */
+ public ObjectType getType() { return arg; }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ if (wildcard == '*')
+ return "?";
+
+ String type = arg.toString();
+ if (wildcard == ' ')
+ return type;
+ else if (wildcard == '+')
+ return "? extends " + type;
+ else
+ return "? super " + type;
+ }
+ }
+
+ /**
+ * Primitive types and object types.
+ */
+ public static abstract class Type {
+ static void toString(StringBuffer sbuf, Type[] ts) {
+ for (int i = 0; i < ts.length; i++) {
+ if (i > 0)
+ sbuf.append(", ");
+
+ sbuf.append(ts[i]);
+ }
+ }
+ }
+
+ /**
+ * Primitive types.
+ */
+ public static class BaseType extends Type {
+ char descriptor;
+ BaseType(char c) { descriptor = c; }
+
+ /**
+ * Returns the descriptor representing this primitive type.
+ *
+ * @see javassist.bytecode.Descriptor
+ */
+ public char getDescriptor() { return descriptor; }
+
+ /**
+ * Returns the <code>CtClass</code> representing this
+ * primitive type.
+ */
+ public CtClass getCtlass() {
+ return Descriptor.toPrimitiveClass(descriptor);
+ }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ return Descriptor.toClassName(Character.toString(descriptor));
+ }
+ }
+
+ /**
+ * Class types, array types, and type variables.
+ */
+ public static abstract class ObjectType extends Type {}
+
+ /**
+ * Class types.
+ */
+ public static class ClassType extends ObjectType {
+ String name;
+ TypeArgument[] arguments;
+
+ static ClassType make(String s, int b, int e,
+ TypeArgument[] targs, ClassType parent) {
+ if (parent == null)
+ return new ClassType(s, b, e, targs);
+ else
+ return new NestedClassType(s, b, e, targs, parent);
+ }
+
+ ClassType(String signature, int begin, int end, TypeArgument[] targs) {
+ name = signature.substring(begin, end).replace('/', '.');
+ arguments = targs;
+ }
+
+ /**
+ * Returns the class name.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Returns the type arguments.
+ *
+ * @return null if no type arguments are given to this class.
+ */
+ public TypeArgument[] getTypeArguments() { return arguments; }
+
+ /**
+ * If this class is a member of another class, returns the
+ * class in which this class is declared.
+ *
+ * @return null if this class is not a member of another class.
+ */
+ public ClassType getDeclaringClass() { return null; }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+ ClassType parent = getDeclaringClass();
+ if (parent != null)
+ sbuf.append(parent.toString()).append('.');
+
+ sbuf.append(name);
+ if (arguments != null) {
+ sbuf.append('<');
+ int n = arguments.length;
+ for (int i = 0; i < n; i++) {
+ if (i > 0)
+ sbuf.append(", ");
+
+ sbuf.append(arguments[i].toString());
+ }
+
+ sbuf.append('>');
+ }
+
+ return sbuf.toString();
+ }
+ }
+
+ /**
+ * Nested class types.
+ */
+ public static class NestedClassType extends ClassType {
+ ClassType parent;
+ NestedClassType(String s, int b, int e,
+ TypeArgument[] targs, ClassType p) {
+ super(s, b, e, targs);
+ parent = p;
+ }
+
+ /**
+ * Returns the class that declares this nested class.
+ * This nested class is a member of that declaring class.
+ */
+ public ClassType getDeclaringClass() { return parent; }
+ }
+
+ /**
+ * Array types.
+ */
+ public static class ArrayType extends ObjectType {
+ int dim;
+ Type componentType;
+
+ public ArrayType(int d, Type comp) {
+ dim = d;
+ componentType = comp;
+ }
+
+ /**
+ * Returns the dimension of the array.
+ */
+ public int getDimension() { return dim; }
+
+ /**
+ * Returns the component type.
+ */
+ public Type getComponentType() {
+ return componentType;
+ }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer(componentType.toString());
+ for (int i = 0; i < dim; i++)
+ sbuf.append("[]");
+
+ return sbuf.toString();
+ }
+ }
+
+ /**
+ * Type variables.
+ */
+ public static class TypeVariable extends ObjectType {
+ String name;
+
+ TypeVariable(String sig, int begin, int end) {
+ name = sig.substring(begin, end);
+ }
+
+ /**
+ * Returns the variable name.
+ */
+ public String getName() {
+ return name;
+ }
+
+ /**
+ * Returns the string representation.
+ */
+ public String toString() {
+ return name;
+ }
+ }
+
+ /**
+ * Parses the given signature string as a class signature.
+ *
+ * @param sig the signature.
+ * @throws BadBytecode thrown when a syntactical error is found.
+ * @since 3.5
+ */
+ public static ClassSignature toClassSignature(String sig) throws BadBytecode {
+ try {
+ return parseSig(sig);
+ }
+ catch (IndexOutOfBoundsException e) {
+ throw error(sig);
+ }
+ }
+
+ /**
+ * Parses the given signature string as a method type signature.
+ *
+ * @param sig the signature.
+ * @throws BadBytecode thrown when a syntactical error is found.
+ * @since 3.5
+ */
+ public static MethodSignature toMethodSignature(String sig) throws BadBytecode {
+ try {
+ return parseMethodSig(sig);
+ }
+ catch (IndexOutOfBoundsException e) {
+ throw error(sig);
+ }
+ }
+
+ /**
+ * Parses the given signature string as a field type signature.
+ *
+ * @param sig the signature string.
+ * @return the field type signature.
+ * @throws BadBytecode thrown when a syntactical error is found.
+ * @since 3.5
+ */
+ public static ObjectType toFieldSignature(String sig) throws BadBytecode {
+ try {
+ return parseObjectType(sig, new Cursor(), false);
+ }
+ catch (IndexOutOfBoundsException e) {
+ throw error(sig);
+ }
+ }
+
+ private static ClassSignature parseSig(String sig)
+ throws BadBytecode, IndexOutOfBoundsException
+ {
+ Cursor cur = new Cursor();
+ TypeParameter[] tp = parseTypeParams(sig, cur);
+ ClassType superClass = parseClassType(sig, cur);
+ int sigLen = sig.length();
+ ArrayList ifArray = new ArrayList();
+ while (cur.position < sigLen && sig.charAt(cur.position) == 'L')
+ ifArray.add(parseClassType(sig, cur));
+
+ ClassType[] ifs
+ = (ClassType[])ifArray.toArray(new ClassType[ifArray.size()]);
+ return new ClassSignature(tp, superClass, ifs);
+ }
+
+ private static MethodSignature parseMethodSig(String sig)
+ throws BadBytecode
+ {
+ Cursor cur = new Cursor();
+ TypeParameter[] tp = parseTypeParams(sig, cur);
+ if (sig.charAt(cur.position++) != '(')
+ throw error(sig);
+
+ ArrayList params = new ArrayList();
+ while (sig.charAt(cur.position) != ')') {
+ Type t = parseType(sig, cur);
+ params.add(t);
+ }
+
+ cur.position++;
+ Type ret = parseType(sig, cur);
+ int sigLen = sig.length();
+ ArrayList exceptions = new ArrayList();
+ while (cur.position < sigLen && sig.charAt(cur.position) == '^') {
+ cur.position++;
+ ObjectType t = parseObjectType(sig, cur, false);
+ if (t instanceof ArrayType)
+ throw error(sig);
+
+ exceptions.add(t);
+ }
+
+ Type[] p = (Type[])params.toArray(new Type[params.size()]);
+ ObjectType[] ex = (ObjectType[])exceptions.toArray(new ObjectType[exceptions.size()]);
+ return new MethodSignature(tp, p, ret, ex);
+ }
+
+ private static TypeParameter[] parseTypeParams(String sig, Cursor cur)
+ throws BadBytecode
+ {
+ ArrayList typeParam = new ArrayList();
+ if (sig.charAt(cur.position) == '<') {
+ cur.position++;
+ while (sig.charAt(cur.position) != '>') {
+ int nameBegin = cur.position;
+ int nameEnd = cur.indexOf(sig, ':');
+ ObjectType classBound = parseObjectType(sig, cur, true);
+ ArrayList ifBound = new ArrayList();
+ while (sig.charAt(cur.position) == ':') {
+ cur.position++;
+ ObjectType t = parseObjectType(sig, cur, false);
+ ifBound.add(t);
+ }
+
+ TypeParameter p = new TypeParameter(sig, nameBegin, nameEnd,
+ classBound, (ObjectType[])ifBound.toArray(new ObjectType[ifBound.size()]));
+ typeParam.add(p);
+ }
+
+ cur.position++;
+ }
+
+ return (TypeParameter[])typeParam.toArray(new TypeParameter[typeParam.size()]);
+ }
+
+ private static ObjectType parseObjectType(String sig, Cursor c, boolean dontThrow)
+ throws BadBytecode
+ {
+ int i;
+ int begin = c.position;
+ switch (sig.charAt(begin)) {
+ case 'L' :
+ return parseClassType2(sig, c, null);
+ case 'T' :
+ i = c.indexOf(sig, ';');
+ return new TypeVariable(sig, begin + 1, i);
+ case '[' :
+ return parseArray(sig, c);
+ default :
+ if (dontThrow)
+ return null;
+ else
+ throw error(sig);
+ }
+ }
+
+ private static ClassType parseClassType(String sig, Cursor c)
+ throws BadBytecode
+ {
+ if (sig.charAt(c.position) == 'L')
+ return parseClassType2(sig, c, null);
+ else
+ throw error(sig);
+ }
+
+ private static ClassType parseClassType2(String sig, Cursor c, ClassType parent)
+ throws BadBytecode
+ {
+ int start = ++c.position;
+ char t;
+ do {
+ t = sig.charAt(c.position++);
+ } while (t != '$' && t != '<' && t != ';');
+ int end = c.position - 1;
+ TypeArgument[] targs;
+ if (t == '<') {
+ targs = parseTypeArgs(sig, c);
+ t = sig.charAt(c.position++);
+ }
+ else
+ targs = null;
+
+ ClassType thisClass = ClassType.make(sig, start, end, targs, parent);
+ if (t == '$') {
+ c.position--;
+ return parseClassType2(sig, c, thisClass);
+ }
+ else
+ return thisClass;
+ }
+
+ private static TypeArgument[] parseTypeArgs(String sig, Cursor c) throws BadBytecode {
+ ArrayList args = new ArrayList();
+ char t;
+ while ((t = sig.charAt(c.position++)) != '>') {
+ TypeArgument ta;
+ if (t == '*' )
+ ta = new TypeArgument(null, '*');
+ else {
+ if (t != '+' && t != '-') {
+ t = ' ';
+ c.position--;
+ }
+
+ ta = new TypeArgument(parseObjectType(sig, c, false), t);
+ }
+
+ args.add(ta);
+ }
+
+ return (TypeArgument[])args.toArray(new TypeArgument[args.size()]);
+ }
+
+ private static ObjectType parseArray(String sig, Cursor c) throws BadBytecode {
+ int dim = 1;
+ while (sig.charAt(++c.position) == '[')
+ dim++;
+
+ return new ArrayType(dim, parseType(sig, c));
+ }
+
+ private static Type parseType(String sig, Cursor c) throws BadBytecode {
+ Type t = parseObjectType(sig, c, true);
+ if (t == null)
+ t = new BaseType(sig.charAt(c.position++));
+
+ return t;
+ }
+
+ private static BadBytecode error(String sig) {
+ return new BadBytecode("bad signature: " + sig);
+ }
+}
diff --git a/src/main/javassist/bytecode/SourceFileAttribute.java b/src/main/javassist/bytecode/SourceFileAttribute.java
new file mode 100644
index 0000000..c104eb7
--- /dev/null
+++ b/src/main/javassist/bytecode/SourceFileAttribute.java
@@ -0,0 +1,70 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>SourceFile_attribute</code>.
+ */
+public class SourceFileAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"SourceFile"</code>.
+ */
+ public static final String tag = "SourceFile";
+
+ SourceFileAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a SourceFile attribute.
+ *
+ * @param cp a constant pool table.
+ * @param filename the name of the source file.
+ */
+ public SourceFileAttribute(ConstPool cp, String filename) {
+ super(cp, tag);
+ int index = cp.addUtf8Info(filename);
+ byte[] bvalue = new byte[2];
+ bvalue[0] = (byte)(index >>> 8);
+ bvalue[1] = (byte)index;
+ set(bvalue);
+ }
+
+ /**
+ * Returns the file name indicated by <code>sourcefile_index</code>.
+ */
+ public String getFileName() {
+ return getConstPool().getUtf8Info(ByteArray.readU16bit(get(), 0));
+ }
+
+ /**
+ * Makes a copy. Class names are replaced according to the
+ * given <code>Map</code> object.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames pairs of replaced and substituted
+ * class names.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ return new SourceFileAttribute(newCp, getFileName());
+ }
+}
diff --git a/src/main/javassist/bytecode/StackMap.java b/src/main/javassist/bytecode/StackMap.java
new file mode 100644
index 0000000..ac0582e
--- /dev/null
+++ b/src/main/javassist/bytecode/StackMap.java
@@ -0,0 +1,544 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+import javassist.CannotCompileException;
+import javassist.bytecode.StackMapTable.InsertLocal;
+import javassist.bytecode.StackMapTable.NewRemover;
+import javassist.bytecode.StackMapTable.Shifter;
+
+/**
+ * Another <code>stack_map</code> attribute defined in CLDC 1.1 for J2ME.
+ *
+ * <p>This is an entry in the attributes table of a Code attribute.
+ * It was introduced by J2ME CLDC 1.1 (JSR 139) for pre-verification.
+ *
+ * <p>According to the CLDC specification, the sizes of some fields are not 16bit
+ * but 32bit if the code size is more than 64K or the number of the local variables
+ * is more than 64K. However, for the J2ME CLDC technology, they are always 16bit.
+ * The implementation of the StackMap class assumes they are 16bit.
+ *
+ * @see MethodInfo#doPreverify
+ * @see StackMapTable
+ * @since 3.12
+ */
+public class StackMap extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"StackMap"</code>.
+ */
+ public static final String tag = "StackMap";
+
+
+ /**
+ * Constructs a <code>stack_map</code> attribute.
+ */
+ StackMap(ConstPool cp, byte[] newInfo) {
+ super(cp, tag, newInfo);
+ }
+
+ StackMap(ConstPool cp, int name_id, DataInputStream in)
+ throws IOException
+ {
+ super(cp, name_id, in);
+ }
+
+ /**
+ * Returns <code>number_of_entries</code>.
+ */
+ public int numOfEntries() {
+ return ByteArray.readU16bit(info, 0);
+ }
+
+ /**
+ * <code>Top_variable_info.tag</code>.
+ */
+ public static final int TOP = 0;
+
+ /**
+ * <code>Integer_variable_info.tag</code>.
+ */
+ public static final int INTEGER = 1;
+
+ /**
+ * <code>Float_variable_info.tag</code>.
+ */
+ public static final int FLOAT = 2;
+
+ /**
+ * <code>Double_variable_info.tag</code>.
+ */
+ public static final int DOUBLE = 3;
+
+ /**
+ * <code>Long_variable_info.tag</code>.
+ */
+ public static final int LONG = 4;
+
+ /**
+ * <code>Null_variable_info.tag</code>.
+ */
+ public static final int NULL = 5;
+
+ /**
+ * <code>UninitializedThis_variable_info.tag</code>.
+ */
+ public static final int THIS = 6;
+
+ /**
+ * <code>Object_variable_info.tag</code>.
+ */
+ public static final int OBJECT = 7;
+
+ /**
+ * <code>Uninitialized_variable_info.tag</code>.
+ */
+ public static final int UNINIT = 8;
+
+ /**
+ * Makes a copy.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ Copier copier = new Copier(this, newCp, classnames);
+ copier.visit();
+ return copier.getStackMap();
+ }
+
+ /**
+ * A code walker for a StackMap attribute.
+ */
+ public static class Walker {
+ byte[] info;
+
+ /**
+ * Constructs a walker.
+ */
+ public Walker(StackMap sm) {
+ info = sm.get();
+ }
+
+ /**
+ * Visits each entry of the stack map frames.
+ */
+ public void visit() {
+ int num = ByteArray.readU16bit(info, 0);
+ int pos = 2;
+ for (int i = 0; i < num; i++) {
+ int offset = ByteArray.readU16bit(info, pos);
+ int numLoc = ByteArray.readU16bit(info, pos + 2);
+ pos = locals(pos + 4, offset, numLoc);
+ int numStack = ByteArray.readU16bit(info, pos);
+ pos = stack(pos + 2, offset, numStack);
+ }
+ }
+
+ /**
+ * Invoked when <code>locals</code> of <code>stack_map_frame</code>
+ * is visited.
+ */
+ public int locals(int pos, int offset, int num) {
+ return typeInfoArray(pos, offset, num, true);
+ }
+
+ /**
+ * Invoked when <code>stack</code> of <code>stack_map_frame</code>
+ * is visited.
+ */
+ public int stack(int pos, int offset, int num) {
+ return typeInfoArray(pos, offset, num, false);
+ }
+
+ /**
+ * Invoked when an array of <code>verification_type_info</code> is
+ * visited.
+ *
+ * @param num the number of elements.
+ * @param isLocals true if this array is for <code>locals</code>.
+ * false if it is for <code>stack</code>.
+ */
+ public int typeInfoArray(int pos, int offset, int num, boolean isLocals) {
+ for (int k = 0; k < num; k++)
+ pos = typeInfoArray2(k, pos);
+
+ return pos;
+ }
+
+ int typeInfoArray2(int k, int pos) {
+ byte tag = info[pos];
+ if (tag == OBJECT) {
+ int clazz = ByteArray.readU16bit(info, pos + 1);
+ objectVariable(pos, clazz);
+ pos += 3;
+ }
+ else if (tag == UNINIT) {
+ int offsetOfNew = ByteArray.readU16bit(info, pos + 1);
+ uninitialized(pos, offsetOfNew);
+ pos += 3;
+ }
+ else {
+ typeInfo(pos, tag);
+ pos++;
+ }
+
+ return pos;
+ }
+
+ /**
+ * Invoked when an element of <code>verification_type_info</code>
+ * (except <code>Object_variable_info</code> and
+ * <code>Uninitialized_variable_info</code>) is visited.
+ */
+ public void typeInfo(int pos, byte tag) {}
+
+ /**
+ * Invoked when an element of type <code>Object_variable_info</code>
+ * is visited.
+ */
+ public void objectVariable(int pos, int clazz) {}
+
+ /**
+ * Invoked when an element of type <code>Uninitialized_variable_info</code>
+ * is visited.
+ */
+ public void uninitialized(int pos, int offset) {}
+ }
+
+ static class Copier extends Walker {
+ byte[] dest;
+ ConstPool srcCp, destCp;
+ Map classnames;
+
+ Copier(StackMap map, ConstPool newCp, Map classnames) {
+ super(map);
+ srcCp = map.getConstPool();
+ dest = new byte[info.length];
+ destCp = newCp;
+ this.classnames = classnames;
+ }
+
+ public void visit() {
+ int num = ByteArray.readU16bit(info, 0);
+ ByteArray.write16bit(num, dest, 0);
+ super.visit();
+ }
+
+ public int locals(int pos, int offset, int num) {
+ ByteArray.write16bit(offset, dest, pos - 4);
+ return super.locals(pos, offset, num);
+ }
+
+ public int typeInfoArray(int pos, int offset, int num, boolean isLocals) {
+ ByteArray.write16bit(num, dest, pos - 2);
+ return super.typeInfoArray(pos, offset, num, isLocals);
+ }
+
+ public void typeInfo(int pos, byte tag) {
+ dest[pos] = tag;
+ }
+
+ public void objectVariable(int pos, int clazz) {
+ dest[pos] = OBJECT;
+ int newClazz = srcCp.copy(clazz, destCp, classnames);
+ ByteArray.write16bit(newClazz, dest, pos + 1);
+ }
+
+ public void uninitialized(int pos, int offset) {
+ dest[pos] = UNINIT;
+ ByteArray.write16bit(offset, dest, pos + 1);
+ }
+
+ public StackMap getStackMap() {
+ return new StackMap(destCp, dest);
+ }
+ }
+
+ /**
+ * Updates this stack map table when a new local variable is inserted
+ * for a new parameter.
+ *
+ * @param index the index of the added local variable.
+ * @param tag the type tag of that local variable.
+ * It is available by <code>StackMapTable.typeTagOf(char)</code>.
+ * @param classInfo the index of the <code>CONSTANT_Class_info</code> structure
+ * in a constant pool table. This should be zero unless the tag
+ * is <code>ITEM_Object</code>.
+ *
+ * @see javassist.CtBehavior#addParameter(javassist.CtClass)
+ * @see StackMapTable#typeTagOf(char)
+ * @see ConstPool
+ */
+ public void insertLocal(int index, int tag, int classInfo)
+ throws BadBytecode
+ {
+ byte[] data = new InsertLocal(this, index, tag, classInfo).doit();
+ this.set(data);
+ }
+
+ static class SimpleCopy extends Walker {
+ Writer writer;
+
+ SimpleCopy(StackMap map) {
+ super(map);
+ writer = new Writer();
+ }
+
+ byte[] doit() {
+ visit();
+ return writer.toByteArray();
+ }
+
+ public void visit() {
+ int num = ByteArray.readU16bit(info, 0);
+ writer.write16bit(num);
+ super.visit();
+ }
+
+ public int locals(int pos, int offset, int num) {
+ writer.write16bit(offset);
+ return super.locals(pos, offset, num);
+ }
+
+ public int typeInfoArray(int pos, int offset, int num, boolean isLocals) {
+ writer.write16bit(num);
+ return super.typeInfoArray(pos, offset, num, isLocals);
+ }
+
+ public void typeInfo(int pos, byte tag) {
+ writer.writeVerifyTypeInfo(tag, 0);
+ }
+
+ public void objectVariable(int pos, int clazz) {
+ writer.writeVerifyTypeInfo(OBJECT, clazz);
+ }
+
+ public void uninitialized(int pos, int offset) {
+ writer.writeVerifyTypeInfo(UNINIT, offset);
+ }
+ }
+
+ static class InsertLocal extends SimpleCopy {
+ private int varIndex;
+ private int varTag, varData;
+
+ InsertLocal(StackMap map, int varIndex, int varTag, int varData) {
+ super(map);
+ this.varIndex = varIndex;
+ this.varTag = varTag;
+ this.varData = varData;
+ }
+
+ public int typeInfoArray(int pos, int offset, int num, boolean isLocals) {
+ if (!isLocals || num < varIndex)
+ return super.typeInfoArray(pos, offset, num, isLocals);
+
+ writer.write16bit(num + 1);
+ for (int k = 0; k < num; k++) {
+ if (k == varIndex)
+ writeVarTypeInfo();
+
+ pos = typeInfoArray2(k, pos);
+ }
+
+ if (num == varIndex)
+ writeVarTypeInfo();
+
+ return pos;
+ }
+
+ private void writeVarTypeInfo() {
+ if (varTag == OBJECT)
+ writer.writeVerifyTypeInfo(OBJECT, varData);
+ else if (varTag == UNINIT)
+ writer.writeVerifyTypeInfo(UNINIT, varData);
+ else
+ writer.writeVerifyTypeInfo(varTag, 0);
+ }
+ }
+
+ void shiftPc(int where, int gapSize, boolean exclusive)
+ throws BadBytecode
+ {
+ new Shifter(this, where, gapSize, exclusive).visit();
+ }
+
+ static class Shifter extends Walker {
+ private int where, gap;
+ private boolean exclusive;
+
+ public Shifter(StackMap smt, int where, int gap, boolean exclusive) {
+ super(smt);
+ this.where = where;
+ this.gap = gap;
+ this.exclusive = exclusive;
+ }
+
+ public int locals(int pos, int offset, int num) {
+ if (exclusive ? where <= offset : where < offset)
+ ByteArray.write16bit(offset + gap, info, pos - 4);
+
+ return super.locals(pos, offset, num);
+ }
+ }
+
+ /**
+ * Undocumented method. Do not use; internal-use only.
+ *
+ * <p>This method is for javassist.convert.TransformNew.
+ * It is called to update the stack map when
+ * the NEW opcode (and the following DUP) is removed.
+ *
+ * @param where the position of the removed NEW opcode.
+ */
+ public void removeNew(int where) throws CannotCompileException {
+ byte[] data = new NewRemover(this, where).doit();
+ this.set(data);
+ }
+
+ static class NewRemover extends SimpleCopy {
+ int posOfNew;
+
+ NewRemover(StackMap map, int where) {
+ super(map);
+ posOfNew = where;
+ }
+
+ public int stack(int pos, int offset, int num) {
+ return stackTypeInfoArray(pos, offset, num);
+ }
+
+ private int stackTypeInfoArray(int pos, int offset, int num) {
+ int p = pos;
+ int count = 0;
+ for (int k = 0; k < num; k++) {
+ byte tag = info[p];
+ if (tag == OBJECT)
+ p += 3;
+ else if (tag == UNINIT) {
+ int offsetOfNew = ByteArray.readU16bit(info, p + 1);
+ if (offsetOfNew == posOfNew)
+ count++;
+
+ p += 3;
+ }
+ else
+ p++;
+ }
+
+ writer.write16bit(num - count);
+ for (int k = 0; k < num; k++) {
+ byte tag = info[pos];
+ if (tag == OBJECT) {
+ int clazz = ByteArray.readU16bit(info, pos + 1);
+ objectVariable(pos, clazz);
+ pos += 3;
+ }
+ else if (tag == UNINIT) {
+ int offsetOfNew = ByteArray.readU16bit(info, pos + 1);
+ if (offsetOfNew != posOfNew)
+ uninitialized(pos, offsetOfNew);
+
+ pos += 3;
+ }
+ else {
+ typeInfo(pos, tag);
+ pos++;
+ }
+ }
+
+ return pos;
+ }
+ }
+
+ /**
+ * Prints this stack map.
+ */
+ public void print(java.io.PrintWriter out) {
+ new Printer(this, out).print();
+ }
+
+ static class Printer extends Walker {
+ private java.io.PrintWriter writer;
+
+ public Printer(StackMap map, java.io.PrintWriter out) {
+ super(map);
+ writer = out;
+ }
+
+ public void print() {
+ int num = ByteArray.readU16bit(info, 0);
+ writer.println(num + " entries");
+ visit();
+ }
+
+ public int locals(int pos, int offset, int num) {
+ writer.println(" * offset " + offset);
+ return super.locals(pos, offset, num);
+ }
+ }
+
+ /**
+ * Internal use only.
+ */
+ public static class Writer {
+ // see javassist.bytecode.stackmap.MapMaker
+
+ private ByteArrayOutputStream output;
+
+ /**
+ * Constructs a writer.
+ */
+ public Writer() {
+ output = new ByteArrayOutputStream();
+ }
+
+ /**
+ * Converts the written data into a byte array.
+ */
+ public byte[] toByteArray() {
+ return output.toByteArray();
+ }
+
+ /**
+ * Converts to a <code>StackMap</code> attribute.
+ */
+ public StackMap toStackMap(ConstPool cp) {
+ return new StackMap(cp, output.toByteArray());
+ }
+
+ /**
+ * Writes a <code>union verification_type_info</code> value.
+ *
+ * @param data <code>cpool_index</code> or <code>offset</code>.
+ */
+ public void writeVerifyTypeInfo(int tag, int data) {
+ output.write(tag);
+ if (tag == StackMap.OBJECT || tag == StackMap.UNINIT)
+ write16bit(data);
+ }
+
+ /**
+ * Writes a 16bit value.
+ */
+ public void write16bit(int value) {
+ output.write((value >>> 8) & 0xff);
+ output.write(value & 0xff);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/StackMapTable.java b/src/main/javassist/bytecode/StackMapTable.java
new file mode 100644
index 0000000..f3cea6f
--- /dev/null
+++ b/src/main/javassist/bytecode/StackMapTable.java
@@ -0,0 +1,949 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintWriter;
+import java.io.IOException;
+import java.util.Map;
+import javassist.CannotCompileException;
+
+/**
+ * <code>stack_map</code> attribute.
+ *
+ * <p>This is an entry in the attributes table of a Code attribute.
+ * It was introduced by J2SE 6 for the process of verification by
+ * typechecking.
+ *
+ * @see StackMap
+ * @since 3.4
+ */
+public class StackMapTable extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"StackMapTable"</code>.
+ */
+ public static final String tag = "StackMapTable";
+
+ /**
+ * Constructs a <code>stack_map</code> attribute.
+ */
+ StackMapTable(ConstPool cp, byte[] newInfo) {
+ super(cp, tag, newInfo);
+ }
+
+ StackMapTable(ConstPool cp, int name_id, DataInputStream in)
+ throws IOException
+ {
+ super(cp, name_id, in);
+ }
+
+ /**
+ * Makes a copy.
+ *
+ * @exception RuntimeCopyException if a <code>BadBytecode</code>
+ * exception is thrown while copying,
+ * it is converted into
+ * <code>RuntimeCopyException</code>.
+ *
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames)
+ throws RuntimeCopyException
+ {
+ try {
+ return new StackMapTable(newCp,
+ new Copier(this.constPool, info, newCp).doit());
+ }
+ catch (BadBytecode e) {
+ throw new RuntimeCopyException("bad bytecode. fatal?");
+ }
+ }
+
+ /**
+ * An exception that may be thrown by <code>copy()</code>
+ * in <code>StackMapTable</code>.
+ */
+ public static class RuntimeCopyException extends RuntimeException {
+ /**
+ * Constructs an exception.
+ */
+ public RuntimeCopyException(String s) {
+ super(s);
+ }
+ }
+
+ void write(DataOutputStream out) throws IOException {
+ super.write(out);
+ }
+
+ /**
+ * <code>Top_variable_info.tag</code>.
+ */
+ public static final int TOP = 0;
+
+ /**
+ * <code>Integer_variable_info.tag</code>.
+ */
+ public static final int INTEGER = 1;
+
+ /**
+ * <code>Float_variable_info.tag</code>.
+ */
+ public static final int FLOAT = 2;
+
+ /**
+ * <code>Double_variable_info.tag</code>.
+ */
+ public static final int DOUBLE = 3;
+
+ /**
+ * <code>Long_variable_info.tag</code>.
+ */
+ public static final int LONG = 4;
+
+ /**
+ * <code>Null_variable_info.tag</code>.
+ */
+ public static final int NULL = 5;
+
+ /**
+ * <code>UninitializedThis_variable_info.tag</code>.
+ */
+ public static final int THIS = 6;
+
+ /**
+ * <code>Object_variable_info.tag</code>.
+ */
+ public static final int OBJECT = 7;
+
+ /**
+ * <code>Uninitialized_variable_info.tag</code>.
+ */
+ public static final int UNINIT = 8;
+
+ /**
+ * A code walker for a StackMapTable attribute.
+ */
+ public static class Walker {
+ byte[] info;
+ int numOfEntries;
+
+ /**
+ * Constructs a walker.
+ *
+ * @param smt the StackMapTable that this walker
+ * walks around.
+ */
+ public Walker(StackMapTable smt) {
+ this(smt.get());
+ }
+
+ /**
+ * Constructs a walker.
+ *
+ * @param data the <code>info</code> field of the
+ * <code>attribute_info</code> structure.
+ * It can be obtained by <code>get()</code>
+ * in the <code>AttributeInfo</code> class.
+ */
+ public Walker(byte[] data) {
+ info = data;
+ numOfEntries = ByteArray.readU16bit(data, 0);
+ }
+
+ /**
+ * Returns the number of the entries.
+ */
+ public final int size() { return numOfEntries; }
+
+ /**
+ * Visits each entry of the stack map frames.
+ */
+ public void parse() throws BadBytecode {
+ int n = numOfEntries;
+ int pos = 2;
+ for (int i = 0; i < n; i++)
+ pos = stackMapFrames(pos, i);
+ }
+
+ /**
+ * Invoked when the next entry of the stack map frames is visited.
+ *
+ * @param pos the position of the frame in the <code>info</code>
+ * field of <code>attribute_info</code> structure.
+ * @param nth the frame is the N-th
+ * (0, 1st, 2nd, 3rd, 4th, ...) entry.
+ * @return the position of the next frame.
+ */
+ int stackMapFrames(int pos, int nth) throws BadBytecode {
+ int type = info[pos] & 0xff;
+ if (type < 64) {
+ sameFrame(pos, type);
+ pos++;
+ }
+ else if (type < 128)
+ pos = sameLocals(pos, type);
+ else if (type < 247)
+ throw new BadBytecode("bad frame_type in StackMapTable");
+ else if (type == 247) // SAME_LOCALS_1_STACK_ITEM_EXTENDED
+ pos = sameLocals(pos, type);
+ else if (type < 251) {
+ int offset = ByteArray.readU16bit(info, pos + 1);
+ chopFrame(pos, offset, 251 - type);
+ pos += 3;
+ }
+ else if (type == 251) { // SAME_FRAME_EXTENDED
+ int offset = ByteArray.readU16bit(info, pos + 1);
+ sameFrame(pos, offset);
+ pos += 3;
+ }
+ else if (type < 255)
+ pos = appendFrame(pos, type);
+ else // FULL_FRAME
+ pos = fullFrame(pos);
+
+ return pos;
+ }
+
+ /**
+ * Invoked if the visited frame is a <code>same_frame</code> or
+ * a <code>same_frame_extended</code>.
+ *
+ * @param pos the position of this frame in the <code>info</code>
+ * field of <code>attribute_info</code> structure.
+ * @param offsetDelta
+ */
+ public void sameFrame(int pos, int offsetDelta) throws BadBytecode {}
+
+ private int sameLocals(int pos, int type) throws BadBytecode {
+ int top = pos;
+ int offset;
+ if (type < 128)
+ offset = type - 64;
+ else { // type == 247
+ offset = ByteArray.readU16bit(info, pos + 1);
+ pos += 2;
+ }
+
+ int tag = info[pos + 1] & 0xff;
+ int data = 0;
+ if (tag == OBJECT || tag == UNINIT) {
+ data = ByteArray.readU16bit(info, pos + 2);
+ pos += 2;
+ }
+
+ sameLocals(top, offset, tag, data);
+ return pos + 2;
+ }
+
+ /**
+ * Invoked if the visited frame is a <code>same_locals_1_stack_item_frame</code>
+ * or a <code>same_locals_1_stack_item_frame_extended</code>.
+ *
+ * @param pos the position.
+ * @param offsetDelta
+ * @param stackTag <code>stack[0].tag</code>.
+ * @param stackData <code>stack[0].cpool_index</code>
+ * if the tag is <code>OBJECT</code>,
+ * or <code>stack[0].offset</code>
+ * if the tag is <code>UNINIT</code>.
+ */
+ public void sameLocals(int pos, int offsetDelta, int stackTag, int stackData)
+ throws BadBytecode {}
+
+ /**
+ * Invoked if the visited frame is a <code>chop_frame</code>.
+ *
+ * @param pos the position.
+ * @param offsetDelta
+ * @param k the <cod>k</code> last locals are absent.
+ */
+ public void chopFrame(int pos, int offsetDelta, int k) throws BadBytecode {}
+
+ private int appendFrame(int pos, int type) throws BadBytecode {
+ int k = type - 251;
+ int offset = ByteArray.readU16bit(info, pos + 1);
+ int[] tags = new int[k];
+ int[] data = new int[k];
+ int p = pos + 3;
+ for (int i = 0; i < k; i++) {
+ int tag = info[p] & 0xff;
+ tags[i] = tag;
+ if (tag == OBJECT || tag == UNINIT) {
+ data[i] = ByteArray.readU16bit(info, p + 1);
+ p += 3;
+ }
+ else {
+ data[i] = 0;
+ p++;
+ }
+ }
+
+ appendFrame(pos, offset, tags, data);
+ return p;
+ }
+
+ /**
+ * Invoked if the visited frame is a <code>append_frame</code>.
+ *
+ * @param pos the position.
+ * @param offsetDelta
+ * @param tags <code>locals[i].tag</code>.
+ * @param data <code>locals[i].cpool_index</code>
+ * or <cod>locals[i].offset</code>.
+ */
+ public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data)
+ throws BadBytecode {}
+
+ private int fullFrame(int pos) throws BadBytecode {
+ int offset = ByteArray.readU16bit(info, pos + 1);
+ int numOfLocals = ByteArray.readU16bit(info, pos + 3);
+ int[] localsTags = new int[numOfLocals];
+ int[] localsData = new int[numOfLocals];
+ int p = verifyTypeInfo(pos + 5, numOfLocals, localsTags, localsData);
+ int numOfItems = ByteArray.readU16bit(info, p);
+ int[] itemsTags = new int[numOfItems];
+ int[] itemsData = new int[numOfItems];
+ p = verifyTypeInfo(p + 2, numOfItems, itemsTags, itemsData);
+ fullFrame(pos, offset, localsTags, localsData, itemsTags, itemsData);
+ return p;
+ }
+
+ /**
+ * Invoked if the visited frame is <code>full_frame</code>.
+ *
+ * @param pos the position.
+ * @param offsetDelta
+ * @param localTags <code>locals[i].tag</code>
+ * @param localData <code>locals[i].cpool_index</code>
+ * or <code>locals[i].offset</code>
+ * @param stackTags <code>stack[i].tag</code>
+ * @param stackData <code>stack[i].cpool_index</code>
+ * or <code>stack[i].offset</code>
+ */
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData)
+ throws BadBytecode {}
+
+ private int verifyTypeInfo(int pos, int n, int[] tags, int[] data) {
+ for (int i = 0; i < n; i++) {
+ int tag = info[pos++] & 0xff;
+ tags[i] = tag;
+ if (tag == OBJECT || tag == UNINIT) {
+ data[i] = ByteArray.readU16bit(info, pos);
+ pos += 2;
+ }
+ }
+
+ return pos;
+ }
+ }
+
+ static class SimpleCopy extends Walker {
+ private Writer writer;
+
+ public SimpleCopy(byte[] data) {
+ super(data);
+ writer = new Writer(data.length);
+ }
+
+ public byte[] doit() throws BadBytecode {
+ parse();
+ return writer.toByteArray();
+ }
+
+ public void sameFrame(int pos, int offsetDelta) {
+ writer.sameFrame(offsetDelta);
+ }
+
+ public void sameLocals(int pos, int offsetDelta, int stackTag, int stackData) {
+ writer.sameLocals(offsetDelta, stackTag, copyData(stackTag, stackData));
+ }
+
+ public void chopFrame(int pos, int offsetDelta, int k) {
+ writer.chopFrame(offsetDelta, k);
+ }
+
+ public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data) {
+ writer.appendFrame(offsetDelta, tags, copyData(tags, data));
+ }
+
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ writer.fullFrame(offsetDelta, localTags, copyData(localTags, localData),
+ stackTags, copyData(stackTags, stackData));
+ }
+
+ protected int copyData(int tag, int data) {
+ return data;
+ }
+
+ protected int[] copyData(int[] tags, int[] data) {
+ return data;
+ }
+ }
+
+ static class Copier extends SimpleCopy {
+ private ConstPool srcPool, destPool;
+
+ public Copier(ConstPool src, byte[] data, ConstPool dest) {
+ super(data);
+ srcPool = src;
+ destPool = dest;
+ }
+
+ protected int copyData(int tag, int data) {
+ if (tag == OBJECT)
+ return srcPool.copy(data, destPool, null);
+ else
+ return data;
+ }
+
+ protected int[] copyData(int[] tags, int[] data) {
+ int[] newData = new int[data.length];
+ for (int i = 0; i < data.length; i++)
+ if (tags[i] == OBJECT)
+ newData[i] = srcPool.copy(data[i], destPool, null);
+ else
+ newData[i] = data[i];
+
+ return newData;
+ }
+ }
+
+ /**
+ * Updates this stack map table when a new local variable is inserted
+ * for a new parameter.
+ *
+ * @param index the index of the added local variable.
+ * @param tag the type tag of that local variable.
+ * @param classInfo the index of the <code>CONSTANT_Class_info</code> structure
+ * in a constant pool table. This should be zero unless the tag
+ * is <code>ITEM_Object</code>.
+ *
+ * @see javassist.CtBehavior#addParameter(javassist.CtClass)
+ * @see #typeTagOf(char)
+ * @see ConstPool
+ */
+ public void insertLocal(int index, int tag, int classInfo)
+ throws BadBytecode
+ {
+ byte[] data = new InsertLocal(this.get(), index, tag, classInfo).doit();
+ this.set(data);
+ }
+
+ /**
+ * Returns the tag of the type specified by the
+ * descriptor. This method returns <code>INTEGER</code>
+ * unless the descriptor is either D (double), F (float),
+ * J (long), L (class type), or [ (array).
+ *
+ * @param descriptor the type descriptor.
+ * @see Descriptor
+ */
+ public static int typeTagOf(char descriptor) {
+ switch (descriptor) {
+ case 'D' :
+ return DOUBLE;
+ case 'F' :
+ return FLOAT;
+ case 'J' :
+ return LONG;
+ case 'L' :
+ case '[' :
+ return OBJECT;
+ // case 'V' :
+ default :
+ return INTEGER;
+ }
+ }
+
+ /* This implementation assumes that a local variable initially
+ * holding a parameter value is never changed to be a different
+ * type.
+ *
+ */
+ static class InsertLocal extends SimpleCopy {
+ private int varIndex;
+ private int varTag, varData;
+
+ public InsertLocal(byte[] data, int varIndex, int varTag, int varData) {
+ super(data);
+ this.varIndex = varIndex;
+ this.varTag = varTag;
+ this.varData = varData;
+ }
+
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ int len = localTags.length;
+ if (len < varIndex) {
+ super.fullFrame(pos, offsetDelta, localTags, localData, stackTags, stackData);
+ return;
+ }
+
+ int typeSize = (varTag == LONG || varTag == DOUBLE) ? 2 : 1;
+ int[] localTags2 = new int[len + typeSize];
+ int[] localData2 = new int[len + typeSize];
+ int index = varIndex;
+ int j = 0;
+ for (int i = 0; i < len; i++) {
+ if (j == index)
+ j += typeSize;
+
+ localTags2[j] = localTags[i];
+ localData2[j++] = localData[i];
+ }
+
+ localTags2[index] = varTag;
+ localData2[index] = varData;
+ if (typeSize > 1) {
+ localTags2[index + 1] = TOP;
+ localData2[index + 1] = 0;
+ }
+
+ super.fullFrame(pos, offsetDelta, localTags2, localData2, stackTags, stackData);
+ }
+ }
+
+ /**
+ * A writer of stack map tables.
+ */
+ public static class Writer {
+ ByteArrayOutputStream output;
+ int numOfEntries;
+
+ /**
+ * Constructs a writer.
+ * @param size the initial buffer size.
+ */
+ public Writer(int size) {
+ output = new ByteArrayOutputStream(size);
+ numOfEntries = 0;
+ output.write(0); // u2 number_of_entries
+ output.write(0);
+ }
+
+ /**
+ * Returns the stack map table written out.
+ */
+ public byte[] toByteArray() {
+ byte[] b = output.toByteArray();
+ ByteArray.write16bit(numOfEntries, b, 0);
+ return b;
+ }
+
+ /**
+ * Constructs and a return a stack map table containing
+ * the written stack map entries.
+ *
+ * @param cp the constant pool used to write
+ * the stack map entries.
+ */
+ public StackMapTable toStackMapTable(ConstPool cp) {
+ return new StackMapTable(cp, toByteArray());
+ }
+
+ /**
+ * Writes a <code>same_frame</code> or a <code>same_frame_extended</code>.
+ */
+ public void sameFrame(int offsetDelta) {
+ numOfEntries++;
+ if (offsetDelta < 64)
+ output.write(offsetDelta);
+ else {
+ output.write(251); // SAME_FRAME_EXTENDED
+ write16(offsetDelta);
+ }
+ }
+
+ /**
+ * Writes a <code>same_locals_1_stack_item</code>
+ * or a <code>same_locals_1_stack_item_extended</code>.
+ *
+ * @param tag <code>stack[0].tag</code>.
+ * @param data <code>stack[0].cpool_index</code>
+ * if the tag is <code>OBJECT</code>,
+ * or <cod>stack[0].offset</code>
+ * if the tag is <code>UNINIT</code>.
+ * Otherwise, this parameter is not used.
+ */
+ public void sameLocals(int offsetDelta, int tag, int data) {
+ numOfEntries++;
+ if (offsetDelta < 64)
+ output.write(offsetDelta + 64);
+ else {
+ output.write(247); // SAME_LOCALS_1_STACK_ITEM_EXTENDED
+ write16(offsetDelta);
+ }
+
+ writeTypeInfo(tag, data);
+ }
+
+ /**
+ * Writes a <code>chop_frame</code>.
+ *
+ * @param k the number of absent locals. 1, 2, or 3.
+ */
+ public void chopFrame(int offsetDelta, int k) {
+ numOfEntries++;
+ output.write(251 - k);
+ write16(offsetDelta);
+ }
+
+ /**
+ * Writes a <code>append_frame</code>. The number of the appended
+ * locals is specified by the length of <code>tags</code>.
+ *
+ * @param tags <code>locals[].tag</code>.
+ * The length of this array must be
+ * either 1, 2, or 3.
+ * @param data <code>locals[].cpool_index</code>
+ * if the tag is <code>OBJECT</code>,
+ * or <cod>locals[].offset</code>
+ * if the tag is <code>UNINIT</code>.
+ * Otherwise, this parameter is not used.
+ */
+ public void appendFrame(int offsetDelta, int[] tags, int[] data) {
+ numOfEntries++;
+ int k = tags.length; // k is 1, 2, or 3
+ output.write(k + 251);
+ write16(offsetDelta);
+ for (int i = 0; i < k; i++)
+ writeTypeInfo(tags[i], data[i]);
+ }
+
+ /**
+ * Writes a <code>full_frame</code>.
+ * <code>number_of_locals</code> and <code>number_of_stack_items</code>
+ * are specified by the the length of <code>localTags</code> and
+ * <code>stackTags</code>.
+ *
+ * @param localTags <code>locals[].tag</code>.
+ * @param localData <code>locals[].cpool_index</code>
+ * if the tag is <code>OBJECT</code>,
+ * or <cod>locals[].offset</code>
+ * if the tag is <code>UNINIT</code>.
+ * Otherwise, this parameter is not used.
+ * @param stackTags <code>stack[].tag</code>.
+ * @param stackData <code>stack[].cpool_index</code>
+ * if the tag is <code>OBJECT</code>,
+ * or <cod>stack[].offset</code>
+ * if the tag is <code>UNINIT</code>.
+ * Otherwise, this parameter is not used.
+ */
+ public void fullFrame(int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ numOfEntries++;
+ output.write(255); // FULL_FRAME
+ write16(offsetDelta);
+ int n = localTags.length;
+ write16(n);
+ for (int i = 0; i < n; i++)
+ writeTypeInfo(localTags[i], localData[i]);
+
+ n = stackTags.length;
+ write16(n);
+ for (int i = 0; i < n; i++)
+ writeTypeInfo(stackTags[i], stackData[i]);
+ }
+
+ private void writeTypeInfo(int tag, int data) {
+ output.write(tag);
+ if (tag == OBJECT || tag == UNINIT)
+ write16(data);
+ }
+
+ private void write16(int value) {
+ output.write((value >>> 8) & 0xff);
+ output.write(value & 0xff);
+ }
+ }
+
+ /**
+ * Prints the stack table map.
+ */
+ public void println(PrintWriter w) {
+ Printer.print(this, w);
+ }
+
+ /**
+ * Prints the stack table map.
+ *
+ * @param ps a print stream such as <code>System.out</code>.
+ */
+ public void println(java.io.PrintStream ps) {
+ Printer.print(this, new java.io.PrintWriter(ps, true));
+ }
+
+ static class Printer extends Walker {
+ private PrintWriter writer;
+ private int offset;
+
+ /**
+ * Prints the stack table map.
+ */
+ public static void print(StackMapTable smt, PrintWriter writer) {
+ try {
+ new Printer(smt.get(), writer).parse();
+ }
+ catch (BadBytecode e) {
+ writer.println(e.getMessage());
+ }
+ }
+
+ Printer(byte[] data, PrintWriter pw) {
+ super(data);
+ writer = pw;
+ offset = -1;
+ }
+
+ public void sameFrame(int pos, int offsetDelta) {
+ offset += offsetDelta + 1;
+ writer.println(offset + " same frame: " + offsetDelta);
+ }
+
+ public void sameLocals(int pos, int offsetDelta, int stackTag, int stackData) {
+ offset += offsetDelta + 1;
+ writer.println(offset + " same locals: " + offsetDelta);
+ printTypeInfo(stackTag, stackData);
+ }
+
+ public void chopFrame(int pos, int offsetDelta, int k) {
+ offset += offsetDelta + 1;
+ writer.println(offset + " chop frame: " + offsetDelta + ", " + k + " last locals");
+ }
+
+ public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data) {
+ offset += offsetDelta + 1;
+ writer.println(offset + " append frame: " + offsetDelta);
+ for (int i = 0; i < tags.length; i++)
+ printTypeInfo(tags[i], data[i]);
+ }
+
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ offset += offsetDelta + 1;
+ writer.println(offset + " full frame: " + offsetDelta);
+ writer.println("[locals]");
+ for (int i = 0; i < localTags.length; i++)
+ printTypeInfo(localTags[i], localData[i]);
+
+ writer.println("[stack]");
+ for (int i = 0; i < stackTags.length; i++)
+ printTypeInfo(stackTags[i], stackData[i]);
+ }
+
+ private void printTypeInfo(int tag, int data) {
+ String msg = null;
+ switch (tag) {
+ case TOP :
+ msg = "top";
+ break;
+ case INTEGER :
+ msg = "integer";
+ break;
+ case FLOAT :
+ msg = "float";
+ break;
+ case DOUBLE :
+ msg = "double";
+ break;
+ case LONG :
+ msg = "long";
+ break;
+ case NULL :
+ msg = "null";
+ break;
+ case THIS :
+ msg = "this";
+ break;
+ case OBJECT :
+ msg = "object (cpool_index " + data + ")";
+ break;
+ case UNINIT :
+ msg = "uninitialized (offset " + data + ")";
+ break;
+ }
+
+ writer.print(" ");
+ writer.println(msg);
+ }
+ }
+
+ void shiftPc(int where, int gapSize, boolean exclusive)
+ throws BadBytecode
+ {
+ new Shifter(this, where, gapSize, exclusive).doit();
+ }
+
+ static class Shifter extends Walker {
+ private StackMapTable stackMap;
+ private int where, gap;
+ private int position;
+ private byte[] updatedInfo;
+ private boolean exclusive;
+
+ public Shifter(StackMapTable smt, int where, int gap, boolean exclusive) {
+ super(smt);
+ stackMap = smt;
+ this.where = where;
+ this.gap = gap;
+ this.position = 0;
+ this.updatedInfo = null;
+ this.exclusive = exclusive;
+ }
+
+ public void doit() throws BadBytecode {
+ parse();
+ if (updatedInfo != null)
+ stackMap.set(updatedInfo);
+ }
+
+ public void sameFrame(int pos, int offsetDelta) {
+ update(pos, offsetDelta, 0, 251);
+ }
+
+ public void sameLocals(int pos, int offsetDelta, int stackTag, int stackData) {
+ update(pos, offsetDelta, 64, 247);
+ }
+
+ private void update(int pos, int offsetDelta, int base, int entry) {
+ int oldPos = position;
+ position = oldPos + offsetDelta + (oldPos == 0 ? 0 : 1);
+ boolean match;
+ if (exclusive)
+ match = oldPos < where && where <= position;
+ else
+ match = oldPos <= where && where < position;
+
+ if (match) {
+ int newDelta = offsetDelta + gap;
+ position += gap;
+ if (newDelta < 64)
+ info[pos] = (byte)(newDelta + base);
+ else if (offsetDelta < 64) {
+ byte[] newinfo = insertGap(info, pos, 2);
+ newinfo[pos] = (byte)entry;
+ ByteArray.write16bit(newDelta, newinfo, pos + 1);
+ updatedInfo = newinfo;
+ }
+ else
+ ByteArray.write16bit(newDelta, info, pos + 1);
+ }
+ }
+
+ private static byte[] insertGap(byte[] info, int where, int gap) {
+ int len = info.length;
+ byte[] newinfo = new byte[len + gap];
+ for (int i = 0; i < len; i++)
+ newinfo[i + (i < where ? 0 : gap)] = info[i];
+
+ return newinfo;
+ }
+
+ public void chopFrame(int pos, int offsetDelta, int k) {
+ update(pos, offsetDelta);
+ }
+
+ public void appendFrame(int pos, int offsetDelta, int[] tags, int[] data) {
+ update(pos, offsetDelta);
+ }
+
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ update(pos, offsetDelta);
+ }
+
+ private void update(int pos, int offsetDelta) {
+ int oldPos = position;
+ position = oldPos + offsetDelta + (oldPos == 0 ? 0 : 1);
+ boolean match;
+ if (exclusive)
+ match = oldPos < where && where <= position;
+ else
+ match = oldPos <= where && where < position;
+
+ if (match) {
+ int newDelta = offsetDelta + gap;
+ ByteArray.write16bit(newDelta, info, pos + 1);
+ position += gap;
+ }
+ }
+ }
+
+ /**
+ * Undocumented method. Do not use; internal-use only.
+ *
+ * <p>This method is for javassist.convert.TransformNew.
+ * It is called to update the stack map table when
+ * the NEW opcode (and the following DUP) is removed.
+ *
+ * @param where the position of the removed NEW opcode.
+ */
+ public void removeNew(int where) throws CannotCompileException {
+ try {
+ byte[] data = new NewRemover(this.get(), where).doit();
+ this.set(data);
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("bad stack map table", e);
+ }
+ }
+
+ static class NewRemover extends SimpleCopy {
+ int posOfNew;
+
+ public NewRemover(byte[] data, int pos) {
+ super(data);
+ posOfNew = pos;
+ }
+
+ public void sameLocals(int pos, int offsetDelta, int stackTag, int stackData) {
+ if (stackTag == UNINIT && stackData == posOfNew)
+ super.sameFrame(pos, offsetDelta);
+ else
+ super.sameLocals(pos, offsetDelta, stackTag, stackData);
+ }
+
+ public void fullFrame(int pos, int offsetDelta, int[] localTags, int[] localData,
+ int[] stackTags, int[] stackData) {
+ int n = stackTags.length - 1;
+ for (int i = 0; i < n; i++)
+ if (stackTags[i] == UNINIT && stackData[i] == posOfNew
+ && stackTags[i + 1] == UNINIT && stackData[i + 1] == posOfNew) {
+ n++;
+ int[] stackTags2 = new int[n - 2];
+ int[] stackData2 = new int[n - 2];
+ int k = 0;
+ for (int j = 0; j < n; j++)
+ if (j == i)
+ j++;
+ else {
+ stackTags2[k] = stackTags[j];
+ stackData2[k++] = stackData[j];
+ }
+
+ stackTags = stackTags2;
+ stackData = stackData2;
+ break;
+ }
+
+ super.fullFrame(pos, offsetDelta, localTags, localData, stackTags, stackData);
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/SyntheticAttribute.java b/src/main/javassist/bytecode/SyntheticAttribute.java
new file mode 100644
index 0000000..8cc697d
--- /dev/null
+++ b/src/main/javassist/bytecode/SyntheticAttribute.java
@@ -0,0 +1,55 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * <code>Synthetic_attribute</code>.
+ */
+public class SyntheticAttribute extends AttributeInfo {
+ /**
+ * The name of this attribute <code>"Synthetic"</code>.
+ */
+ public static final String tag = "Synthetic";
+
+ SyntheticAttribute(ConstPool cp, int n, DataInputStream in)
+ throws IOException
+ {
+ super(cp, n, in);
+ }
+
+ /**
+ * Constructs a Synthetic attribute.
+ *
+ * @param cp a constant pool table.
+ */
+ public SyntheticAttribute(ConstPool cp) {
+ super(cp, tag, new byte[0]);
+ }
+
+ /**
+ * Makes a copy.
+ *
+ * @param newCp the constant pool table used by the new copy.
+ * @param classnames should be null.
+ */
+ public AttributeInfo copy(ConstPool newCp, Map classnames) {
+ return new SyntheticAttribute(newCp);
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/Analyzer.java b/src/main/javassist/bytecode/analysis/Analyzer.java
new file mode 100644
index 0000000..ea56599
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Analyzer.java
@@ -0,0 +1,422 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.Iterator;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.ExceptionTable;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+
+/**
+ * A data-flow analyzer that determines the type state of the stack and local
+ * variable table at every reachable instruction in a method. During analysis,
+ * bytecode verification is performed in a similar manner to that described
+ * in the JVM specification.
+ *
+ * <p>Example:</p>
+ *
+ * <pre>
+ * // Method to analyze
+ * public Object doSomething(int x) {
+ * Number n;
+ * if (x < 5) {
+ * n = new Double(0);
+ * } else {
+ * n = new Long(0);
+ * }
+ *
+ * return n;
+ * }
+ *
+ * // Which compiles to:
+ * // 0: iload_1
+ * // 1: iconst_5
+ * // 2: if_icmpge 17
+ * // 5: new #18; //class java/lang/Double
+ * // 8: dup
+ * // 9: dconst_0
+ * // 10: invokespecial #44; //Method java/lang/Double."<init>":(D)V
+ * // 13: astore_2
+ * // 14: goto 26
+ * // 17: new #16; //class java/lang/Long
+ * // 20: dup
+ * // 21: lconst_1
+ * // 22: invokespecial #47; //Method java/lang/Long."<init>":(J)V
+ * // 25: astore_2
+ * // 26: aload_2
+ * // 27: areturn
+ *
+ * public void analyzeIt(CtClass clazz, MethodInfo method) {
+ * Analyzer analyzer = new Analyzer();
+ * Frame[] frames = analyzer.analyze(clazz, method);
+ * frames[0].getLocal(0).getCtClass(); // returns clazz;
+ * frames[0].getLocal(1).getCtClass(); // returns java.lang.String
+ * frames[1].peek(); // returns Type.INTEGER
+ * frames[27].peek().getCtClass(); // returns java.lang.Number
+ * }
+ * </pre>
+ *
+ * @see FramePrinter
+ * @author Jason T. Greene
+ */
+public class Analyzer implements Opcode {
+ private final SubroutineScanner scanner = new SubroutineScanner();
+ private CtClass clazz;
+ private ExceptionInfo[] exceptions;
+ private Frame[] frames;
+ private Subroutine[] subroutines;
+
+ private static class ExceptionInfo {
+ private int end;
+ private int handler;
+ private int start;
+ private Type type;
+
+ private ExceptionInfo(int start, int end, int handler, Type type) {
+ this.start = start;
+ this.end = end;
+ this.handler = handler;
+ this.type = type;
+ }
+ }
+
+ /**
+ * Performs data-flow analysis on a method and returns an array, indexed by
+ * instruction position, containing the starting frame state of all reachable
+ * instructions. Non-reachable code, and illegal code offsets are represented
+ * as a null in the frame state array. This can be used to detect dead code.
+ *
+ * If the method does not contain code (it is either native or abstract), null
+ * is returned.
+ *
+ * @param clazz the declaring class of the method
+ * @param method the method to analyze
+ * @return an array, indexed by instruction position, of the starting frame state,
+ * or null if this method doesn't have code
+ * @throws BadBytecode if the bytecode does not comply with the JVM specification
+ */
+ public Frame[] analyze(CtClass clazz, MethodInfo method) throws BadBytecode {
+ this.clazz = clazz;
+ CodeAttribute codeAttribute = method.getCodeAttribute();
+ // Native or Abstract
+ if (codeAttribute == null)
+ return null;
+
+ int maxLocals = codeAttribute.getMaxLocals();
+ int maxStack = codeAttribute.getMaxStack();
+ int codeLength = codeAttribute.getCodeLength();
+
+ CodeIterator iter = codeAttribute.iterator();
+ IntQueue queue = new IntQueue();
+
+ exceptions = buildExceptionInfo(method);
+ subroutines = scanner.scan(method);
+
+ Executor executor = new Executor(clazz.getClassPool(), method.getConstPool());
+ frames = new Frame[codeLength];
+ frames[iter.lookAhead()] = firstFrame(method, maxLocals, maxStack);
+ queue.add(iter.next());
+ while (!queue.isEmpty()) {
+ analyzeNextEntry(method, iter, queue, executor);
+ }
+
+ return frames;
+ }
+
+ /**
+ * Performs data-flow analysis on a method and returns an array, indexed by
+ * instruction position, containing the starting frame state of all reachable
+ * instructions. Non-reachable code, and illegal code offsets are represented
+ * as a null in the frame state array. This can be used to detect dead code.
+ *
+ * If the method does not contain code (it is either native or abstract), null
+ * is returned.
+ *
+ * @param method the method to analyze
+ * @return an array, indexed by instruction position, of the starting frame state,
+ * or null if this method doesn't have code
+ * @throws BadBytecode if the bytecode does not comply with the JVM specification
+ */
+ public Frame[] analyze(CtMethod method) throws BadBytecode {
+ return analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ }
+
+ private void analyzeNextEntry(MethodInfo method, CodeIterator iter,
+ IntQueue queue, Executor executor) throws BadBytecode {
+ int pos = queue.take();
+ iter.move(pos);
+ iter.next();
+
+ Frame frame = frames[pos].copy();
+ Subroutine subroutine = subroutines[pos];
+
+ try {
+ executor.execute(method, pos, iter, frame, subroutine);
+ } catch (RuntimeException e) {
+ throw new BadBytecode(e.getMessage() + "[pos = " + pos + "]", e);
+ }
+
+ int opcode = iter.byteAt(pos);
+
+ if (opcode == TABLESWITCH) {
+ mergeTableSwitch(queue, pos, iter, frame);
+ } else if (opcode == LOOKUPSWITCH) {
+ mergeLookupSwitch(queue, pos, iter, frame);
+ } else if (opcode == RET) {
+ mergeRet(queue, iter, pos, frame, subroutine);
+ } else if (Util.isJumpInstruction(opcode)) {
+ int target = Util.getJumpTarget(pos, iter);
+
+ if (Util.isJsr(opcode)) {
+ // Merge the state before the jsr into the next instruction
+ mergeJsr(queue, frames[pos], subroutines[target], pos, lookAhead(iter, pos));
+ } else if (! Util.isGoto(opcode)) {
+ merge(queue, frame, lookAhead(iter, pos));
+ }
+
+ merge(queue, frame, target);
+ } else if (opcode != ATHROW && ! Util.isReturn(opcode)) {
+ // Can advance to next instruction
+ merge(queue, frame, lookAhead(iter, pos));
+ }
+
+ // Merge all exceptions that are reachable from this instruction.
+ // The redundancy is intentional, since the state must be based
+ // on the current instruction frame.
+ mergeExceptionHandlers(queue, method, pos, frame);
+ }
+
+ private ExceptionInfo[] buildExceptionInfo(MethodInfo method) {
+ ConstPool constPool = method.getConstPool();
+ ClassPool classes = clazz.getClassPool();
+
+ ExceptionTable table = method.getCodeAttribute().getExceptionTable();
+ ExceptionInfo[] exceptions = new ExceptionInfo[table.size()];
+ for (int i = 0; i < table.size(); i++) {
+ int index = table.catchType(i);
+ Type type;
+ try {
+ type = index == 0 ? Type.THROWABLE : Type.get(classes.get(constPool.getClassInfo(index)));
+ } catch (NotFoundException e) {
+ throw new IllegalStateException(e.getMessage());
+ }
+
+ exceptions[i] = new ExceptionInfo(table.startPc(i), table.endPc(i), table.handlerPc(i), type);
+ }
+
+ return exceptions;
+ }
+
+ private Frame firstFrame(MethodInfo method, int maxLocals, int maxStack) {
+ int pos = 0;
+
+ Frame first = new Frame(maxLocals, maxStack);
+ if ((method.getAccessFlags() & AccessFlag.STATIC) == 0) {
+ first.setLocal(pos++, Type.get(clazz));
+ }
+
+ CtClass[] parameters;
+ try {
+ parameters = Descriptor.getParameterTypes(method.getDescriptor(), clazz.getClassPool());
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+
+ for (int i = 0; i < parameters.length; i++) {
+ Type type = zeroExtend(Type.get(parameters[i]));
+ first.setLocal(pos++, type);
+ if (type.getSize() == 2)
+ first.setLocal(pos++, Type.TOP);
+ }
+
+ return first;
+ }
+
+ private int getNext(CodeIterator iter, int of, int restore) throws BadBytecode {
+ iter.move(of);
+ iter.next();
+ int next = iter.lookAhead();
+ iter.move(restore);
+ iter.next();
+
+ return next;
+ }
+
+ private int lookAhead(CodeIterator iter, int pos) throws BadBytecode {
+ if (! iter.hasNext())
+ throw new BadBytecode("Execution falls off end! [pos = " + pos + "]");
+
+ return iter.lookAhead();
+ }
+
+
+ private void merge(IntQueue queue, Frame frame, int target) {
+ Frame old = frames[target];
+ boolean changed;
+
+ if (old == null) {
+ frames[target] = frame.copy();
+ changed = true;
+ } else {
+ changed = old.merge(frame);
+ }
+
+ if (changed) {
+ queue.add(target);
+ }
+ }
+
+ private void mergeExceptionHandlers(IntQueue queue, MethodInfo method, int pos, Frame frame) {
+ for (int i = 0; i < exceptions.length; i++) {
+ ExceptionInfo exception = exceptions[i];
+
+ // Start is inclusive, while end is exclusive!
+ if (pos >= exception.start && pos < exception.end) {
+ Frame newFrame = frame.copy();
+ newFrame.clearStack();
+ newFrame.push(exception.type);
+ merge(queue, newFrame, exception.handler);
+ }
+ }
+ }
+
+ private void mergeJsr(IntQueue queue, Frame frame, Subroutine sub, int pos, int next) throws BadBytecode {
+ if (sub == null)
+ throw new BadBytecode("No subroutine at jsr target! [pos = " + pos + "]");
+
+ Frame old = frames[next];
+ boolean changed = false;
+
+ if (old == null) {
+ old = frames[next] = frame.copy();
+ changed = true;
+ } else {
+ for (int i = 0; i < frame.localsLength(); i++) {
+ // Skip everything accessed by a subroutine, mergeRet must handle this
+ if (!sub.isAccessed(i)) {
+ Type oldType = old.getLocal(i);
+ Type newType = frame.getLocal(i);
+ if (oldType == null) {
+ old.setLocal(i, newType);
+ changed = true;
+ continue;
+ }
+
+ newType = oldType.merge(newType);
+ // Always set the type, in case a multi-type switched to a standard type.
+ old.setLocal(i, newType);
+ if (!newType.equals(oldType) || newType.popChanged())
+ changed = true;
+ }
+ }
+ }
+
+ if (! old.isJsrMerged()) {
+ old.setJsrMerged(true);
+ changed = true;
+ }
+
+ if (changed && old.isRetMerged())
+ queue.add(next);
+
+ }
+
+ private void mergeLookupSwitch(IntQueue queue, int pos, CodeIterator iter, Frame frame) throws BadBytecode {
+ int index = (pos & ~3) + 4;
+ // default
+ merge(queue, frame, pos + iter.s32bitAt(index));
+ int npairs = iter.s32bitAt(index += 4);
+ int end = npairs * 8 + (index += 4);
+
+ // skip "match"
+ for (index += 4; index < end; index += 8) {
+ int target = iter.s32bitAt(index) + pos;
+ merge(queue, frame, target);
+ }
+ }
+
+ private void mergeRet(IntQueue queue, CodeIterator iter, int pos, Frame frame, Subroutine subroutine) throws BadBytecode {
+ if (subroutine == null)
+ throw new BadBytecode("Ret on no subroutine! [pos = " + pos + "]");
+
+ Iterator callerIter = subroutine.callers().iterator();
+ while (callerIter.hasNext()) {
+ int caller = ((Integer) callerIter.next()).intValue();
+ int returnLoc = getNext(iter, caller, pos);
+ boolean changed = false;
+
+ Frame old = frames[returnLoc];
+ if (old == null) {
+ old = frames[returnLoc] = frame.copyStack();
+ changed = true;
+ } else {
+ changed = old.mergeStack(frame);
+ }
+
+ for (Iterator i = subroutine.accessed().iterator(); i.hasNext(); ) {
+ int index = ((Integer)i.next()).intValue();
+ Type oldType = old.getLocal(index);
+ Type newType = frame.getLocal(index);
+ if (oldType != newType) {
+ old.setLocal(index, newType);
+ changed = true;
+ }
+ }
+
+ if (! old.isRetMerged()) {
+ old.setRetMerged(true);
+ changed = true;
+ }
+
+ if (changed && old.isJsrMerged())
+ queue.add(returnLoc);
+ }
+ }
+
+
+ private void mergeTableSwitch(IntQueue queue, int pos, CodeIterator iter, Frame frame) throws BadBytecode {
+ // Skip 4 byte alignment padding
+ int index = (pos & ~3) + 4;
+ // default
+ merge(queue, frame, pos + iter.s32bitAt(index));
+ int low = iter.s32bitAt(index += 4);
+ int high = iter.s32bitAt(index += 4);
+ int end = (high - low + 1) * 4 + (index += 4);
+
+ // Offset table
+ for (; index < end; index += 4) {
+ int target = iter.s32bitAt(index) + pos;
+ merge(queue, frame, target);
+ }
+ }
+
+ private Type zeroExtend(Type type) {
+ if (type == Type.SHORT || type == Type.BYTE || type == Type.CHAR || type == Type.BOOLEAN)
+ return Type.INTEGER;
+
+ return type;
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/Executor.java b/src/main/javassist/bytecode/analysis/Executor.java
new file mode 100644
index 0000000..562cc5d
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Executor.java
@@ -0,0 +1,1031 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+
+/**
+ * Executor is responsible for modeling the effects of a JVM instruction on a frame.
+ *
+ * @author Jason T. Greene
+ */
+public class Executor implements Opcode {
+ private final ConstPool constPool;
+ private final ClassPool classPool;
+ private final Type STRING_TYPE;
+ private final Type CLASS_TYPE;
+ private final Type THROWABLE_TYPE;
+ private int lastPos;
+
+ public Executor(ClassPool classPool, ConstPool constPool) {
+ this.constPool = constPool;
+ this.classPool = classPool;
+
+ try {
+ STRING_TYPE = getType("java.lang.String");
+ CLASS_TYPE = getType("java.lang.Class");
+ THROWABLE_TYPE = getType("java.lang.Throwable");
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+
+ /**
+ * Execute the instruction, modeling the effects on the specified frame and subroutine.
+ * If a subroutine is passed, the access flags will be modified if this instruction accesses
+ * the local variable table.
+ *
+ * @param method the method containing the instruction
+ * @param pos the position of the instruction in the method
+ * @param iter the code iterator used to find the instruction
+ * @param frame the frame to modify to represent the result of the instruction
+ * @param subroutine the optional subroutine this instruction belongs to.
+ * @throws BadBytecode if the bytecode violates the jvm spec
+ */
+ public void execute(MethodInfo method, int pos, CodeIterator iter, Frame frame, Subroutine subroutine) throws BadBytecode {
+ this.lastPos = pos;
+ int opcode = iter.byteAt(pos);
+
+
+ // Declared opcode in order
+ switch (opcode) {
+ case NOP:
+ break;
+ case ACONST_NULL:
+ frame.push(Type.UNINIT);
+ break;
+ case ICONST_M1:
+ case ICONST_0:
+ case ICONST_1:
+ case ICONST_2:
+ case ICONST_3:
+ case ICONST_4:
+ case ICONST_5:
+ frame.push(Type.INTEGER);
+ break;
+ case LCONST_0:
+ case LCONST_1:
+ frame.push(Type.LONG);
+ frame.push(Type.TOP);
+ break;
+ case FCONST_0:
+ case FCONST_1:
+ case FCONST_2:
+ frame.push(Type.FLOAT);
+ break;
+ case DCONST_0:
+ case DCONST_1:
+ frame.push(Type.DOUBLE);
+ frame.push(Type.TOP);
+ break;
+ case BIPUSH:
+ case SIPUSH:
+ frame.push(Type.INTEGER);
+ break;
+ case LDC:
+ evalLDC(iter.byteAt(pos + 1), frame);
+ break;
+ case LDC_W :
+ case LDC2_W :
+ evalLDC(iter.u16bitAt(pos + 1), frame);
+ break;
+ case ILOAD:
+ evalLoad(Type.INTEGER, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case LLOAD:
+ evalLoad(Type.LONG, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case FLOAD:
+ evalLoad(Type.FLOAT, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case DLOAD:
+ evalLoad(Type.DOUBLE, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case ALOAD:
+ evalLoad(Type.OBJECT, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case ILOAD_0:
+ case ILOAD_1:
+ case ILOAD_2:
+ case ILOAD_3:
+ evalLoad(Type.INTEGER, opcode - ILOAD_0, frame, subroutine);
+ break;
+ case LLOAD_0:
+ case LLOAD_1:
+ case LLOAD_2:
+ case LLOAD_3:
+ evalLoad(Type.LONG, opcode - LLOAD_0, frame, subroutine);
+ break;
+ case FLOAD_0:
+ case FLOAD_1:
+ case FLOAD_2:
+ case FLOAD_3:
+ evalLoad(Type.FLOAT, opcode - FLOAD_0, frame, subroutine);
+ break;
+ case DLOAD_0:
+ case DLOAD_1:
+ case DLOAD_2:
+ case DLOAD_3:
+ evalLoad(Type.DOUBLE, opcode - DLOAD_0, frame, subroutine);
+ break;
+ case ALOAD_0:
+ case ALOAD_1:
+ case ALOAD_2:
+ case ALOAD_3:
+ evalLoad(Type.OBJECT, opcode - ALOAD_0, frame, subroutine);
+ break;
+ case IALOAD:
+ evalArrayLoad(Type.INTEGER, frame);
+ break;
+ case LALOAD:
+ evalArrayLoad(Type.LONG, frame);
+ break;
+ case FALOAD:
+ evalArrayLoad(Type.FLOAT, frame);
+ break;
+ case DALOAD:
+ evalArrayLoad(Type.DOUBLE, frame);
+ break;
+ case AALOAD:
+ evalArrayLoad(Type.OBJECT, frame);
+ break;
+ case BALOAD:
+ case CALOAD:
+ case SALOAD:
+ evalArrayLoad(Type.INTEGER, frame);
+ break;
+ case ISTORE:
+ evalStore(Type.INTEGER, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case LSTORE:
+ evalStore(Type.LONG, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case FSTORE:
+ evalStore(Type.FLOAT, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case DSTORE:
+ evalStore(Type.DOUBLE, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case ASTORE:
+ evalStore(Type.OBJECT, iter.byteAt(pos + 1), frame, subroutine);
+ break;
+ case ISTORE_0:
+ case ISTORE_1:
+ case ISTORE_2:
+ case ISTORE_3:
+ evalStore(Type.INTEGER, opcode - ISTORE_0, frame, subroutine);
+ break;
+ case LSTORE_0:
+ case LSTORE_1:
+ case LSTORE_2:
+ case LSTORE_3:
+ evalStore(Type.LONG, opcode - LSTORE_0, frame, subroutine);
+ break;
+ case FSTORE_0:
+ case FSTORE_1:
+ case FSTORE_2:
+ case FSTORE_3:
+ evalStore(Type.FLOAT, opcode - FSTORE_0, frame, subroutine);
+ break;
+ case DSTORE_0:
+ case DSTORE_1:
+ case DSTORE_2:
+ case DSTORE_3:
+ evalStore(Type.DOUBLE, opcode - DSTORE_0, frame, subroutine);
+ break;
+ case ASTORE_0:
+ case ASTORE_1:
+ case ASTORE_2:
+ case ASTORE_3:
+ evalStore(Type.OBJECT, opcode - ASTORE_0, frame, subroutine);
+ break;
+ case IASTORE:
+ evalArrayStore(Type.INTEGER, frame);
+ break;
+ case LASTORE:
+ evalArrayStore(Type.LONG, frame);
+ break;
+ case FASTORE:
+ evalArrayStore(Type.FLOAT, frame);
+ break;
+ case DASTORE:
+ evalArrayStore(Type.DOUBLE, frame);
+ break;
+ case AASTORE:
+ evalArrayStore(Type.OBJECT, frame);
+ break;
+ case BASTORE:
+ case CASTORE:
+ case SASTORE:
+ evalArrayStore(Type.INTEGER, frame);
+ break;
+ case POP:
+ if (frame.pop() == Type.TOP)
+ throw new BadBytecode("POP can not be used with a category 2 value, pos = " + pos);
+ break;
+ case POP2:
+ frame.pop();
+ frame.pop();
+ break;
+ case DUP: {
+ Type type = frame.peek();
+ if (type == Type.TOP)
+ throw new BadBytecode("DUP can not be used with a category 2 value, pos = " + pos);
+
+ frame.push(frame.peek());
+ break;
+ }
+ case DUP_X1:
+ case DUP_X2: {
+ Type type = frame.peek();
+ if (type == Type.TOP)
+ throw new BadBytecode("DUP can not be used with a category 2 value, pos = " + pos);
+ int end = frame.getTopIndex();
+ int insert = end - (opcode - DUP_X1) - 1;
+ frame.push(type);
+
+ while (end > insert) {
+ frame.setStack(end, frame.getStack(end - 1));
+ end--;
+ }
+ frame.setStack(insert, type);
+ break;
+ }
+ case DUP2:
+ frame.push(frame.getStack(frame.getTopIndex() - 1));
+ frame.push(frame.getStack(frame.getTopIndex() - 1));
+ break;
+ case DUP2_X1:
+ case DUP2_X2: {
+ int end = frame.getTopIndex();
+ int insert = end - (opcode - DUP2_X1) - 1;
+ Type type1 = frame.getStack(frame.getTopIndex() - 1);
+ Type type2 = frame.peek();
+ frame.push(type1);
+ frame.push(type2);
+ while (end > insert) {
+ frame.setStack(end, frame.getStack(end - 2));
+ end--;
+ }
+ frame.setStack(insert, type2);
+ frame.setStack(insert - 1, type1);
+ break;
+ }
+ case SWAP: {
+ Type type1 = frame.pop();
+ Type type2 = frame.pop();
+ if (type1.getSize() == 2 || type2.getSize() == 2)
+ throw new BadBytecode("Swap can not be used with category 2 values, pos = " + pos);
+ frame.push(type1);
+ frame.push(type2);
+ break;
+ }
+
+ // Math
+ case IADD:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LADD:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case FADD:
+ evalBinaryMath(Type.FLOAT, frame);
+ break;
+ case DADD:
+ evalBinaryMath(Type.DOUBLE, frame);
+ break;
+ case ISUB:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LSUB:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case FSUB:
+ evalBinaryMath(Type.FLOAT, frame);
+ break;
+ case DSUB:
+ evalBinaryMath(Type.DOUBLE, frame);
+ break;
+ case IMUL:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LMUL:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case FMUL:
+ evalBinaryMath(Type.FLOAT, frame);
+ break;
+ case DMUL:
+ evalBinaryMath(Type.DOUBLE, frame);
+ break;
+ case IDIV:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LDIV:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case FDIV:
+ evalBinaryMath(Type.FLOAT, frame);
+ break;
+ case DDIV:
+ evalBinaryMath(Type.DOUBLE, frame);
+ break;
+ case IREM:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LREM:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case FREM:
+ evalBinaryMath(Type.FLOAT, frame);
+ break;
+ case DREM:
+ evalBinaryMath(Type.DOUBLE, frame);
+ break;
+
+ // Unary
+ case INEG:
+ verifyAssignable(Type.INTEGER, simplePeek(frame));
+ break;
+ case LNEG:
+ verifyAssignable(Type.LONG, simplePeek(frame));
+ break;
+ case FNEG:
+ verifyAssignable(Type.FLOAT, simplePeek(frame));
+ break;
+ case DNEG:
+ verifyAssignable(Type.DOUBLE, simplePeek(frame));
+ break;
+
+ // Shifts
+ case ISHL:
+ evalShift(Type.INTEGER, frame);
+ break;
+ case LSHL:
+ evalShift(Type.LONG, frame);
+ break;
+ case ISHR:
+ evalShift(Type.INTEGER, frame);
+ break;
+ case LSHR:
+ evalShift(Type.LONG, frame);
+ break;
+ case IUSHR:
+ evalShift(Type.INTEGER,frame);
+ break;
+ case LUSHR:
+ evalShift(Type.LONG, frame);
+ break;
+
+ // Bitwise Math
+ case IAND:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LAND:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case IOR:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LOR:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+ case IXOR:
+ evalBinaryMath(Type.INTEGER, frame);
+ break;
+ case LXOR:
+ evalBinaryMath(Type.LONG, frame);
+ break;
+
+ case IINC: {
+ int index = iter.byteAt(pos + 1);
+ verifyAssignable(Type.INTEGER, frame.getLocal(index));
+ access(index, Type.INTEGER, subroutine);
+ break;
+ }
+
+ // Conversion
+ case I2L:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ simplePush(Type.LONG, frame);
+ break;
+ case I2F:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ simplePush(Type.FLOAT, frame);
+ break;
+ case I2D:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ simplePush(Type.DOUBLE, frame);
+ break;
+ case L2I:
+ verifyAssignable(Type.LONG, simplePop(frame));
+ simplePush(Type.INTEGER, frame);
+ break;
+ case L2F:
+ verifyAssignable(Type.LONG, simplePop(frame));
+ simplePush(Type.FLOAT, frame);
+ break;
+ case L2D:
+ verifyAssignable(Type.LONG, simplePop(frame));
+ simplePush(Type.DOUBLE, frame);
+ break;
+ case F2I:
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ simplePush(Type.INTEGER, frame);
+ break;
+ case F2L:
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ simplePush(Type.LONG, frame);
+ break;
+ case F2D:
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ simplePush(Type.DOUBLE, frame);
+ break;
+ case D2I:
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ simplePush(Type.INTEGER, frame);
+ break;
+ case D2L:
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ simplePush(Type.LONG, frame);
+ break;
+ case D2F:
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ simplePush(Type.FLOAT, frame);
+ break;
+ case I2B:
+ case I2C:
+ case I2S:
+ verifyAssignable(Type.INTEGER, frame.peek());
+ break;
+ case LCMP:
+ verifyAssignable(Type.LONG, simplePop(frame));
+ verifyAssignable(Type.LONG, simplePop(frame));
+ frame.push(Type.INTEGER);
+ break;
+ case FCMPL:
+ case FCMPG:
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ frame.push(Type.INTEGER);
+ break;
+ case DCMPL:
+ case DCMPG:
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ frame.push(Type.INTEGER);
+ break;
+
+ // Control flow
+ case IFEQ:
+ case IFNE:
+ case IFLT:
+ case IFGE:
+ case IFGT:
+ case IFLE:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ break;
+ case IF_ICMPEQ:
+ case IF_ICMPNE:
+ case IF_ICMPLT:
+ case IF_ICMPGE:
+ case IF_ICMPGT:
+ case IF_ICMPLE:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ break;
+ case IF_ACMPEQ:
+ case IF_ACMPNE:
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ break;
+ case GOTO:
+ break;
+ case JSR:
+ frame.push(Type.RETURN_ADDRESS);
+ break;
+ case RET:
+ verifyAssignable(Type.RETURN_ADDRESS, frame.getLocal(iter.byteAt(pos + 1)));
+ break;
+ case TABLESWITCH:
+ case LOOKUPSWITCH:
+ case IRETURN:
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ break;
+ case LRETURN:
+ verifyAssignable(Type.LONG, simplePop(frame));
+ break;
+ case FRETURN:
+ verifyAssignable(Type.FLOAT, simplePop(frame));
+ break;
+ case DRETURN:
+ verifyAssignable(Type.DOUBLE, simplePop(frame));
+ break;
+ case ARETURN:
+ try {
+ CtClass returnType = Descriptor.getReturnType(method.getDescriptor(), classPool);
+ verifyAssignable(Type.get(returnType), simplePop(frame));
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ break;
+ case RETURN:
+ break;
+ case GETSTATIC:
+ evalGetField(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case PUTSTATIC:
+ evalPutField(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case GETFIELD:
+ evalGetField(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case PUTFIELD:
+ evalPutField(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case INVOKEVIRTUAL:
+ case INVOKESPECIAL:
+ case INVOKESTATIC:
+ evalInvokeMethod(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case INVOKEINTERFACE:
+ evalInvokeIntfMethod(opcode, iter.u16bitAt(pos + 1), frame);
+ break;
+ case 186:
+ throw new RuntimeException("Bad opcode 186");
+ case NEW:
+ frame.push(resolveClassInfo(constPool.getClassInfo(iter.u16bitAt(pos + 1))));
+ break;
+ case NEWARRAY:
+ evalNewArray(pos, iter, frame);
+ break;
+ case ANEWARRAY:
+ evalNewObjectArray(pos, iter, frame);
+ break;
+ case ARRAYLENGTH: {
+ Type array = simplePop(frame);
+ if (! array.isArray() && array != Type.UNINIT)
+ throw new BadBytecode("Array length passed a non-array [pos = " + pos + "]: " + array);
+ frame.push(Type.INTEGER);
+ break;
+ }
+ case ATHROW:
+ verifyAssignable(THROWABLE_TYPE, simplePop(frame));
+ break;
+ case CHECKCAST:
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ frame.push(typeFromDesc(constPool.getClassInfo(iter.u16bitAt(pos + 1))));
+ break;
+ case INSTANCEOF:
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ frame.push(Type.INTEGER);
+ break;
+ case MONITORENTER:
+ case MONITOREXIT:
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ break;
+ case WIDE:
+ evalWide(pos, iter, frame, subroutine);
+ break;
+ case MULTIANEWARRAY:
+ evalNewObjectArray(pos, iter, frame);
+ break;
+ case IFNULL:
+ case IFNONNULL:
+ verifyAssignable(Type.OBJECT, simplePop(frame));
+ break;
+ case GOTO_W:
+ break;
+ case JSR_W:
+ frame.push(Type.RETURN_ADDRESS);
+ break;
+ }
+ }
+
+ private Type zeroExtend(Type type) {
+ if (type == Type.SHORT || type == Type.BYTE || type == Type.CHAR || type == Type.BOOLEAN)
+ return Type.INTEGER;
+
+ return type;
+ }
+
+ private void evalArrayLoad(Type expectedComponent, Frame frame) throws BadBytecode {
+ Type index = frame.pop();
+ Type array = frame.pop();
+
+ // Special case, an array defined by aconst_null
+ // TODO - we might need to be more inteligent about this
+ if (array == Type.UNINIT) {
+ verifyAssignable(Type.INTEGER, index);
+ if (expectedComponent == Type.OBJECT) {
+ simplePush(Type.UNINIT, frame);
+ } else {
+ simplePush(expectedComponent, frame);
+ }
+ return;
+ }
+
+ Type component = array.getComponent();
+
+ if (component == null)
+ throw new BadBytecode("Not an array! [pos = " + lastPos + "]: " + component);
+
+ component = zeroExtend(component);
+
+ verifyAssignable(expectedComponent, component);
+ verifyAssignable(Type.INTEGER, index);
+ simplePush(component, frame);
+ }
+
+ private void evalArrayStore(Type expectedComponent, Frame frame) throws BadBytecode {
+ Type value = simplePop(frame);
+ Type index = frame.pop();
+ Type array = frame.pop();
+
+ if (array == Type.UNINIT) {
+ verifyAssignable(Type.INTEGER, index);
+ return;
+ }
+
+ Type component = array.getComponent();
+
+ if (component == null)
+ throw new BadBytecode("Not an array! [pos = " + lastPos + "]: " + component);
+
+ component = zeroExtend(component);
+
+ verifyAssignable(expectedComponent, component);
+ verifyAssignable(Type.INTEGER, index);
+
+ // This intentionally only checks for Object on aastore
+ // downconverting of an array (no casts)
+ // e.g. Object[] blah = new String[];
+ // blah[2] = (Object) "test";
+ // blah[3] = new Integer(); // compiler doesnt catch it (has legal bytecode),
+ // // but will throw arraystoreexception
+ if (expectedComponent == Type.OBJECT) {
+ verifyAssignable(expectedComponent, value);
+ } else {
+ verifyAssignable(component, value);
+ }
+ }
+
+ private void evalBinaryMath(Type expected, Frame frame) throws BadBytecode {
+ Type value2 = simplePop(frame);
+ Type value1 = simplePop(frame);
+
+ verifyAssignable(expected, value2);
+ verifyAssignable(expected, value1);
+ simplePush(value1, frame);
+ }
+
+ private void evalGetField(int opcode, int index, Frame frame) throws BadBytecode {
+ String desc = constPool.getFieldrefType(index);
+ Type type = zeroExtend(typeFromDesc(desc));
+
+ if (opcode == GETFIELD) {
+ Type objectType = resolveClassInfo(constPool.getFieldrefClassName(index));
+ verifyAssignable(objectType, simplePop(frame));
+ }
+
+ simplePush(type, frame);
+ }
+
+ private void evalInvokeIntfMethod(int opcode, int index, Frame frame) throws BadBytecode {
+ String desc = constPool.getInterfaceMethodrefType(index);
+ Type[] types = paramTypesFromDesc(desc);
+ int i = types.length;
+
+ while (i > 0)
+ verifyAssignable(zeroExtend(types[--i]), simplePop(frame));
+
+ String classInfo = constPool.getInterfaceMethodrefClassName(index);
+ Type objectType = resolveClassInfo(classInfo);
+ verifyAssignable(objectType, simplePop(frame));
+
+ Type returnType = returnTypeFromDesc(desc);
+ if (returnType != Type.VOID)
+ simplePush(zeroExtend(returnType), frame);
+ }
+
+ private void evalInvokeMethod(int opcode, int index, Frame frame) throws BadBytecode {
+ String desc = constPool.getMethodrefType(index);
+ Type[] types = paramTypesFromDesc(desc);
+ int i = types.length;
+
+ while (i > 0)
+ verifyAssignable(zeroExtend(types[--i]), simplePop(frame));
+
+ if (opcode != INVOKESTATIC) {
+ Type objectType = resolveClassInfo(constPool.getMethodrefClassName(index));
+ verifyAssignable(objectType, simplePop(frame));
+ }
+
+ Type returnType = returnTypeFromDesc(desc);
+ if (returnType != Type.VOID)
+ simplePush(zeroExtend(returnType), frame);
+ }
+
+
+ private void evalLDC(int index, Frame frame) throws BadBytecode {
+ int tag = constPool.getTag(index);
+ Type type;
+ switch (tag) {
+ case ConstPool.CONST_String:
+ type = STRING_TYPE;
+ break;
+ case ConstPool.CONST_Integer:
+ type = Type.INTEGER;
+ break;
+ case ConstPool.CONST_Float:
+ type = Type.FLOAT;
+ break;
+ case ConstPool.CONST_Long:
+ type = Type.LONG;
+ break;
+ case ConstPool.CONST_Double:
+ type = Type.DOUBLE;
+ break;
+ case ConstPool.CONST_Class:
+ type = CLASS_TYPE;
+ break;
+ default:
+ throw new BadBytecode("bad LDC [pos = " + lastPos + "]: " + tag);
+ }
+
+ simplePush(type, frame);
+ }
+
+ private void evalLoad(Type expected, int index, Frame frame, Subroutine subroutine) throws BadBytecode {
+ Type type = frame.getLocal(index);
+
+ verifyAssignable(expected, type);
+
+ simplePush(type, frame);
+ access(index, type, subroutine);
+ }
+
+ private void evalNewArray(int pos, CodeIterator iter, Frame frame) throws BadBytecode {
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ Type type = null;
+ int typeInfo = iter.byteAt(pos + 1);
+ switch (typeInfo) {
+ case T_BOOLEAN:
+ type = getType("boolean[]");
+ break;
+ case T_CHAR:
+ type = getType("char[]");
+ break;
+ case T_BYTE:
+ type = getType("byte[]");
+ break;
+ case T_SHORT:
+ type = getType("short[]");
+ break;
+ case T_INT:
+ type = getType("int[]");
+ break;
+ case T_LONG:
+ type = getType("long[]");
+ break;
+ case T_FLOAT:
+ type = getType("float[]");
+ break;
+ case T_DOUBLE:
+ type = getType("double[]");
+ break;
+ default:
+ throw new BadBytecode("Invalid array type [pos = " + pos + "]: " + typeInfo);
+
+ }
+
+ frame.push(type);
+ }
+
+ private void evalNewObjectArray(int pos, CodeIterator iter, Frame frame) throws BadBytecode {
+ // Convert to x[] format
+ Type type = resolveClassInfo(constPool.getClassInfo(iter.u16bitAt(pos + 1)));
+ String name = type.getCtClass().getName();
+ int opcode = iter.byteAt(pos);
+ int dimensions;
+
+ if (opcode == MULTIANEWARRAY) {
+ dimensions = iter.byteAt(pos + 3);
+ } else {
+ name = name + "[]";
+ dimensions = 1;
+ }
+
+ while (dimensions-- > 0) {
+ verifyAssignable(Type.INTEGER, simplePop(frame));
+ }
+
+ simplePush(getType(name), frame);
+ }
+
+ private void evalPutField(int opcode, int index, Frame frame) throws BadBytecode {
+ String desc = constPool.getFieldrefType(index);
+ Type type = zeroExtend(typeFromDesc(desc));
+
+ verifyAssignable(type, simplePop(frame));
+
+ if (opcode == PUTFIELD) {
+ Type objectType = resolveClassInfo(constPool.getFieldrefClassName(index));
+ verifyAssignable(objectType, simplePop(frame));
+ }
+ }
+
+ private void evalShift(Type expected, Frame frame) throws BadBytecode {
+ Type value2 = simplePop(frame);
+ Type value1 = simplePop(frame);
+
+ verifyAssignable(Type.INTEGER, value2);
+ verifyAssignable(expected, value1);
+ simplePush(value1, frame);
+ }
+
+ private void evalStore(Type expected, int index, Frame frame, Subroutine subroutine) throws BadBytecode {
+ Type type = simplePop(frame);
+
+ // RETURN_ADDRESS is allowed by ASTORE
+ if (! (expected == Type.OBJECT && type == Type.RETURN_ADDRESS))
+ verifyAssignable(expected, type);
+ simpleSetLocal(index, type, frame);
+ access(index, type, subroutine);
+ }
+
+ private void evalWide(int pos, CodeIterator iter, Frame frame, Subroutine subroutine) throws BadBytecode {
+ int opcode = iter.byteAt(pos + 1);
+ int index = iter.u16bitAt(pos + 2);
+ switch (opcode) {
+ case ILOAD:
+ evalLoad(Type.INTEGER, index, frame, subroutine);
+ break;
+ case LLOAD:
+ evalLoad(Type.LONG, index, frame, subroutine);
+ break;
+ case FLOAD:
+ evalLoad(Type.FLOAT, index, frame, subroutine);
+ break;
+ case DLOAD:
+ evalLoad(Type.DOUBLE, index, frame, subroutine);
+ break;
+ case ALOAD:
+ evalLoad(Type.OBJECT, index, frame, subroutine);
+ break;
+ case ISTORE:
+ evalStore(Type.INTEGER, index, frame, subroutine);
+ break;
+ case LSTORE:
+ evalStore(Type.LONG, index, frame, subroutine);
+ break;
+ case FSTORE:
+ evalStore(Type.FLOAT, index, frame, subroutine);
+ break;
+ case DSTORE:
+ evalStore(Type.DOUBLE, index, frame, subroutine);
+ break;
+ case ASTORE:
+ evalStore(Type.OBJECT, index, frame, subroutine);
+ break;
+ case IINC:
+ verifyAssignable(Type.INTEGER, frame.getLocal(index));
+ break;
+ case RET:
+ verifyAssignable(Type.RETURN_ADDRESS, frame.getLocal(index));
+ break;
+ default:
+ throw new BadBytecode("Invalid WIDE operand [pos = " + pos + "]: " + opcode);
+ }
+
+ }
+
+ private Type getType(String name) throws BadBytecode {
+ try {
+ return Type.get(classPool.get(name));
+ } catch (NotFoundException e) {
+ throw new BadBytecode("Could not find class [pos = " + lastPos + "]: " + name);
+ }
+ }
+
+ private Type[] paramTypesFromDesc(String desc) throws BadBytecode {
+ CtClass classes[] = null;
+ try {
+ classes = Descriptor.getParameterTypes(desc, classPool);
+ } catch (NotFoundException e) {
+ throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());
+ }
+
+ if (classes == null)
+ throw new BadBytecode("Could not obtain parameters for descriptor [pos = " + lastPos + "]: " + desc);
+
+ Type[] types = new Type[classes.length];
+ for (int i = 0; i < types.length; i++)
+ types[i] = Type.get(classes[i]);
+
+ return types;
+ }
+
+ private Type returnTypeFromDesc(String desc) throws BadBytecode {
+ CtClass clazz = null;
+ try {
+ clazz = Descriptor.getReturnType(desc, classPool);
+ } catch (NotFoundException e) {
+ throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());
+ }
+
+ if (clazz == null)
+ throw new BadBytecode("Could not obtain return type for descriptor [pos = " + lastPos + "]: " + desc);
+
+ return Type.get(clazz);
+ }
+
+ private Type simplePeek(Frame frame) {
+ Type type = frame.peek();
+ return (type == Type.TOP) ? frame.getStack(frame.getTopIndex() - 1) : type;
+ }
+
+ private Type simplePop(Frame frame) {
+ Type type = frame.pop();
+ return (type == Type.TOP) ? frame.pop() : type;
+ }
+
+ private void simplePush(Type type, Frame frame) {
+ frame.push(type);
+ if (type.getSize() == 2)
+ frame.push(Type.TOP);
+ }
+
+ private void access(int index, Type type, Subroutine subroutine) {
+ if (subroutine == null)
+ return;
+ subroutine.access(index);
+ if (type.getSize() == 2)
+ subroutine.access(index + 1);
+ }
+
+ private void simpleSetLocal(int index, Type type, Frame frame) {
+ frame.setLocal(index, type);
+ if (type.getSize() == 2)
+ frame.setLocal(index + 1, Type.TOP);
+ }
+
+ private Type resolveClassInfo(String info) throws BadBytecode {
+ CtClass clazz = null;
+ try {
+ if (info.charAt(0) == '[') {
+ clazz = Descriptor.toCtClass(info, classPool);
+ } else {
+ clazz = classPool.get(info);
+ }
+
+ } catch (NotFoundException e) {
+ throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());
+ }
+
+ if (clazz == null)
+ throw new BadBytecode("Could not obtain type for descriptor [pos = " + lastPos + "]: " + info);
+
+ return Type.get(clazz);
+ }
+
+ private Type typeFromDesc(String desc) throws BadBytecode {
+ CtClass clazz = null;
+ try {
+ clazz = Descriptor.toCtClass(desc, classPool);
+ } catch (NotFoundException e) {
+ throw new BadBytecode("Could not find class in descriptor [pos = " + lastPos + "]: " + e.getMessage());
+ }
+
+ if (clazz == null)
+ throw new BadBytecode("Could not obtain type for descriptor [pos = " + lastPos + "]: " + desc);
+
+ return Type.get(clazz);
+ }
+
+ private void verifyAssignable(Type expected, Type type) throws BadBytecode {
+ if (! expected.isAssignableFrom(type))
+ throw new BadBytecode("Expected type: " + expected + " Got: " + type + " [pos = " + lastPos + "]");
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/Frame.java b/src/main/javassist/bytecode/analysis/Frame.java
new file mode 100644
index 0000000..cf646f4
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Frame.java
@@ -0,0 +1,288 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+
+/**
+ * Represents the stack frame and local variable table at a particular point in time.
+ *
+ * @author Jason T. Greene
+ */
+public class Frame {
+ private Type[] locals;
+ private Type[] stack;
+ private int top;
+ private boolean jsrMerged;
+ private boolean retMerged;
+
+ /**
+ * Create a new frame with the specified local variable table size, and max stack size
+ *
+ * @param locals the number of local variable table entries
+ * @param stack the maximum stack size
+ */
+ public Frame(int locals, int stack) {
+ this.locals = new Type[locals];
+ this.stack = new Type[stack];
+ }
+
+ /**
+ * Returns the local varaible table entry at index.
+ *
+ * @param index the position in the table
+ * @return the type if one exists, or null if the position is empty
+ */
+ public Type getLocal(int index) {
+ return locals[index];
+ }
+
+ /**
+ * Sets the local variable table entry at index to a type.
+ *
+ * @param index the position in the table
+ * @param type the type to set at the position
+ */
+ public void setLocal(int index, Type type) {
+ locals[index] = type;
+ }
+
+
+ /**
+ * Returns the type on the stack at the specified index.
+ *
+ * @param index the position on the stack
+ * @return the type of the stack position
+ */
+ public Type getStack(int index) {
+ return stack[index];
+ }
+
+ /**
+ * Sets the type of the stack position
+ *
+ * @param index the position on the stack
+ * @param type the type to set
+ */
+ public void setStack(int index, Type type) {
+ stack[index] = type;
+ }
+
+ /**
+ * Empties the stack
+ */
+ public void clearStack() {
+ top = 0;
+ }
+
+ /**
+ * Gets the index of the type sitting at the top of the stack.
+ * This is not to be confused with a length operation which
+ * would return the number of elements, not the position of
+ * the last element.
+ *
+ * @return the position of the element at the top of the stack
+ */
+ public int getTopIndex() {
+ return top - 1;
+ }
+
+ /**
+ * Returns the number of local variable table entries, specified
+ * at construction.
+ *
+ * @return the number of local variable table entries
+ */
+ public int localsLength() {
+ return locals.length;
+ }
+
+ /**
+ * Gets the top of the stack without altering it
+ *
+ * @return the top of the stack
+ */
+ public Type peek() {
+ if (top < 1)
+ throw new IndexOutOfBoundsException("Stack is empty");
+
+ return stack[top - 1];
+ }
+
+ /**
+ * Alters the stack to contain one less element and return it.
+ *
+ * @return the element popped from the stack
+ */
+ public Type pop() {
+ if (top < 1)
+ throw new IndexOutOfBoundsException("Stack is empty");
+ return stack[--top];
+ }
+
+ /**
+ * Alters the stack by placing the passed type on the top
+ *
+ * @param type the type to add to the top
+ */
+ public void push(Type type) {
+ stack[top++] = type;
+ }
+
+
+ /**
+ * Makes a shallow copy of this frame, i.e. the type instances will
+ * remain the same.
+ *
+ * @return the shallow copy
+ */
+ public Frame copy() {
+ Frame frame = new Frame(locals.length, stack.length);
+ System.arraycopy(locals, 0, frame.locals, 0, locals.length);
+ System.arraycopy(stack, 0, frame.stack, 0, stack.length);
+ frame.top = top;
+ return frame;
+ }
+
+ /**
+ * Makes a shallow copy of the stack portion of this frame. The local
+ * variable table size will be copied, but its contents will be empty.
+ *
+ * @return the shallow copy of the stack
+ */
+ public Frame copyStack() {
+ Frame frame = new Frame(locals.length, stack.length);
+ System.arraycopy(stack, 0, frame.stack, 0, stack.length);
+ frame.top = top;
+ return frame;
+ }
+
+ /**
+ * Merges all types on the stack of this frame instance with that of the specified frame.
+ * The local variable table is left untouched.
+ *
+ * @param frame the frame to merge the stack from
+ * @return true if any changes where made
+ */
+ public boolean mergeStack(Frame frame) {
+ boolean changed = false;
+ if (top != frame.top)
+ throw new RuntimeException("Operand stacks could not be merged, they are different sizes!");
+
+ for (int i = 0; i < top; i++) {
+ if (stack[i] != null) {
+ Type prev = stack[i];
+ Type merged = prev.merge(frame.stack[i]);
+ if (merged == Type.BOGUS)
+ throw new RuntimeException("Operand stacks could not be merged due to differing primitive types: pos = " + i);
+
+ stack[i] = merged;
+ // always replace the instance in case a multi-interface type changes to a normal Type
+ if ((! merged.equals(prev)) || merged.popChanged()) {
+ changed = true;
+ }
+ }
+ }
+
+ return changed;
+ }
+
+ /**
+ * Merges all types on the stack and local variable table of this frame with that of the specified
+ * type.
+ *
+ * @param frame the frame to merge with
+ * @return true if any changes to this frame where made by this merge
+ */
+ public boolean merge(Frame frame) {
+ boolean changed = false;
+
+ // Local variable table
+ for (int i = 0; i < locals.length; i++) {
+ if (locals[i] != null) {
+ Type prev = locals[i];
+ Type merged = prev.merge(frame.locals[i]);
+ // always replace the instance in case a multi-interface type changes to a normal Type
+ locals[i] = merged;
+ if (! merged.equals(prev) || merged.popChanged()) {
+ changed = true;
+ }
+ } else if (frame.locals[i] != null) {
+ locals[i] = frame.locals[i];
+ changed = true;
+ }
+ }
+
+ changed |= mergeStack(frame);
+ return changed;
+ }
+
+ public String toString() {
+ StringBuffer buffer = new StringBuffer();
+
+ buffer.append("locals = [");
+ for (int i = 0; i < locals.length; i++) {
+ buffer.append(locals[i] == null ? "empty" : locals[i].toString());
+ if (i < locals.length - 1)
+ buffer.append(", ");
+ }
+ buffer.append("] stack = [");
+ for (int i = 0; i < top; i++) {
+ buffer.append(stack[i]);
+ if (i < top - 1)
+ buffer.append(", ");
+ }
+ buffer.append("]");
+
+ return buffer.toString();
+ }
+
+ /**
+ * Whether or not state from the source JSR instruction has been merged
+ *
+ * @return true if JSR state has been merged
+ */
+ boolean isJsrMerged() {
+ return jsrMerged;
+ }
+
+ /**
+ * Sets whether of not the state from the source JSR instruction has been merged
+ *
+ * @param jsrMerged true if merged, otherwise false
+ */
+ void setJsrMerged(boolean jsrMerged) {
+ this.jsrMerged = jsrMerged;
+ }
+
+ /**
+ * Whether or not state from the RET instruction, of the subroutine that was jumped
+ * to has been merged.
+ *
+ * @return true if RET state has been merged
+ */
+ boolean isRetMerged() {
+ return retMerged;
+ }
+
+ /**
+ * Sets whether or not state from the RET instruction, of the subroutine that was jumped
+ * to has been merged.
+ *
+ * @param retMerged true if RET state has been merged
+ */
+ void setRetMerged(boolean retMerged) {
+ this.retMerged = retMerged;
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/FramePrinter.java b/src/main/javassist/bytecode/analysis/FramePrinter.java
new file mode 100644
index 0000000..fc99cd3
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/FramePrinter.java
@@ -0,0 +1,147 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.io.PrintStream;
+
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.Modifier;
+import javassist.NotFoundException;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.InstructionPrinter;
+import javassist.bytecode.MethodInfo;
+
+/**
+ * A utility class for printing a merged view of the frame state and the
+ * instructions of a method.
+ *
+ * @author Jason T. Greene
+ */
+public final class FramePrinter {
+ private final PrintStream stream;
+
+ /**
+ * Constructs a bytecode printer.
+ */
+ public FramePrinter(PrintStream stream) {
+ this.stream = stream;
+ }
+
+ /**
+ * Prints all the methods declared in the given class.
+ */
+ public static void print(CtClass clazz, PrintStream stream) {
+ (new FramePrinter(stream)).print(clazz);
+ }
+
+ /**
+ * Prints all the methods declared in the given class.
+ */
+ public void print(CtClass clazz) {
+ CtMethod[] methods = clazz.getDeclaredMethods();
+ for (int i = 0; i < methods.length; i++) {
+ print(methods[i]);
+ }
+ }
+
+ private String getMethodString(CtMethod method) {
+ try {
+ return Modifier.toString(method.getModifiers()) + " "
+ + method.getReturnType().getName() + " " + method.getName()
+ + Descriptor.toString(method.getSignature()) + ";";
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Prints the instructions and the frame states of the given method.
+ */
+ public void print(CtMethod method) {
+ stream.println("\n" + getMethodString(method));
+ MethodInfo info = method.getMethodInfo2();
+ ConstPool pool = info.getConstPool();
+ CodeAttribute code = info.getCodeAttribute();
+ if (code == null)
+ return;
+
+ Frame[] frames;
+ try {
+ frames = (new Analyzer()).analyze(method.getDeclaringClass(), info);
+ } catch (BadBytecode e) {
+ throw new RuntimeException(e);
+ }
+
+ int spacing = String.valueOf(code.getCodeLength()).length();
+
+ CodeIterator iterator = code.iterator();
+ while (iterator.hasNext()) {
+ int pos;
+ try {
+ pos = iterator.next();
+ } catch (BadBytecode e) {
+ throw new RuntimeException(e);
+ }
+
+ stream.println(pos + ": " + InstructionPrinter.instructionString(iterator, pos, pool));
+
+ addSpacing(spacing + 3);
+ Frame frame = frames[pos];
+ if (frame == null) {
+ stream.println("--DEAD CODE--");
+ continue;
+ }
+ printStack(frame);
+
+ addSpacing(spacing + 3);
+ printLocals(frame);
+ }
+
+ }
+
+ private void printStack(Frame frame) {
+ stream.print("stack [");
+ int top = frame.getTopIndex();
+ for (int i = 0; i <= top; i++) {
+ if (i > 0)
+ stream.print(", ");
+ Type type = frame.getStack(i);
+ stream.print(type);
+ }
+ stream.println("]");
+ }
+
+ private void printLocals(Frame frame) {
+ stream.print("locals [");
+ int length = frame.localsLength();
+ for (int i = 0; i < length; i++) {
+ if (i > 0)
+ stream.print(", ");
+ Type type = frame.getLocal(i);
+ stream.print(type == null ? "empty" : type.toString());
+ }
+ stream.println("]");
+ }
+
+ private void addSpacing(int count) {
+ while (count-- > 0)
+ stream.print(' ');
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/IntQueue.java b/src/main/javassist/bytecode/analysis/IntQueue.java
new file mode 100644
index 0000000..d50cddc
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/IntQueue.java
@@ -0,0 +1,56 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.NoSuchElementException;
+
+class IntQueue {
+ private static class Entry {
+ private IntQueue.Entry next;
+ private int value;
+ private Entry(int value) {
+ this.value = value;
+ }
+ }
+ private IntQueue.Entry head;
+
+ private IntQueue.Entry tail;
+
+ void add(int value) {
+ IntQueue.Entry entry = new Entry(value);
+ if (tail != null)
+ tail.next = entry;
+ tail = entry;
+
+ if (head == null)
+ head = entry;
+ }
+
+ boolean isEmpty() {
+ return head == null;
+ }
+
+ int take() {
+ if (head == null)
+ throw new NoSuchElementException();
+
+ int value = head.value;
+ head = head.next;
+ if (head == null)
+ tail = null;
+
+ return value;
+ }
+}
\ No newline at end of file
diff --git a/src/main/javassist/bytecode/analysis/MultiArrayType.java b/src/main/javassist/bytecode/analysis/MultiArrayType.java
new file mode 100644
index 0000000..750116c
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/MultiArrayType.java
@@ -0,0 +1,129 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+
+/**
+ * Represents an array of {@link MultiType} instances.
+ *
+ * @author Jason T. Greene
+ */
+public class MultiArrayType extends Type {
+ private MultiType component;
+ private int dims;
+
+ public MultiArrayType(MultiType component, int dims) {
+ super(null);
+ this.component = component;
+ this.dims = dims;
+ }
+
+ public CtClass getCtClass() {
+ CtClass clazz = component.getCtClass();
+ if (clazz == null)
+ return null;
+
+ ClassPool pool = clazz.getClassPool();
+ if (pool == null)
+ pool = ClassPool.getDefault();
+
+ String name = arrayName(clazz.getName(), dims);
+
+ try {
+ return pool.get(name);
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ boolean popChanged() {
+ return component.popChanged();
+ }
+
+ public int getDimensions() {
+ return dims;
+ }
+
+ public Type getComponent() {
+ return dims == 1 ? (Type)component : new MultiArrayType(component, dims - 1);
+ }
+
+ public int getSize() {
+ return 1;
+ }
+
+ public boolean isArray() {
+ return true;
+ }
+
+ public boolean isAssignableFrom(Type type) {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ public boolean isReference() {
+ return true;
+ }
+
+ public boolean isAssignableTo(Type type) {
+ if (eq(type.getCtClass(), Type.OBJECT.getCtClass()))
+ return true;
+
+ if (eq(type.getCtClass(), Type.CLONEABLE.getCtClass()))
+ return true;
+
+ if (eq(type.getCtClass(), Type.SERIALIZABLE.getCtClass()))
+ return true;
+
+ if (! type.isArray())
+ return false;
+
+ Type typeRoot = getRootComponent(type);
+ int typeDims = type.getDimensions();
+
+ if (typeDims > dims)
+ return false;
+
+ if (typeDims < dims) {
+ if (eq(typeRoot.getCtClass(), Type.OBJECT.getCtClass()))
+ return true;
+
+ if (eq(typeRoot.getCtClass(), Type.CLONEABLE.getCtClass()))
+ return true;
+
+ if (eq(typeRoot.getCtClass(), Type.SERIALIZABLE.getCtClass()))
+ return true;
+
+ return false;
+ }
+
+ return component.isAssignableTo(typeRoot);
+ }
+
+ public boolean equals(Object o) {
+ if (! (o instanceof MultiArrayType))
+ return false;
+ MultiArrayType multi = (MultiArrayType)o;
+
+ return component.equals(multi.component) && dims == multi.dims;
+ }
+
+ public String toString() {
+ // follows the same detailed formating scheme as component
+ return arrayName(component.toString(), dims);
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/MultiType.java b/src/main/javassist/bytecode/analysis/MultiType.java
new file mode 100644
index 0000000..3fb1488
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/MultiType.java
@@ -0,0 +1,313 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javassist.CtClass;
+
+/**
+ * MultiType represents an unresolved type. Whenever two <literal>Type</literal>
+ * instances are merged, if they share more than one super type (either an
+ * interface or a superclass), then a <literal>MultiType</literal> is used to
+ * represent the possible super types. The goal of a <literal>MultiType</literal>
+ * is to reduce the set of possible types down to a single resolved type. This
+ * is done by eliminating non-assignable types from the typeset when the
+ * <literal>MultiType</literal> is passed as an argument to
+ * {@link Type#isAssignableFrom(Type)}, as well as removing non-intersecting
+ * types during a merge.
+ *
+ * Note: Currently the <litera>MultiType</literal> instance is reused as much
+ * as possible so that updates are visible from all frames. In addition, all
+ * <literal>MultiType</literal> merge paths are also updated. This is somewhat
+ * hackish, but it appears to handle most scenarios.
+ *
+ * @author Jason T. Greene
+ */
+
+/* TODO - A better, but more involved, approach would be to track the instruction
+ * offset that resulted in the creation of this type, and
+ * whenever the typeset changes, to force a merge on that position. This
+ * would require creating a new MultiType instance every time the typeset
+ * changes, and somehow communicating assignment changes to the Analyzer
+ */
+public class MultiType extends Type {
+ private Map interfaces;
+ private Type resolved;
+ private Type potentialClass;
+ private MultiType mergeSource;
+ private boolean changed = false;
+
+ public MultiType(Map interfaces) {
+ this(interfaces, null);
+ }
+
+ public MultiType(Map interfaces, Type potentialClass) {
+ super(null);
+ this.interfaces = interfaces;
+ this.potentialClass = potentialClass;
+ }
+
+ /**
+ * Gets the class that corresponds with this type. If this information
+ * is not yet known, java.lang.Object will be returned.
+ */
+ public CtClass getCtClass() {
+ if (resolved != null)
+ return resolved.getCtClass();
+
+ return Type.OBJECT.getCtClass();
+ }
+
+ /**
+ * Always returns null since this type is never used for an array.
+ */
+ public Type getComponent() {
+ return null;
+ }
+
+ /**
+ * Always returns 1, since this type is a reference.
+ */
+ public int getSize() {
+ return 1;
+ }
+
+ /**
+ * Always reutnrs false since this type is never used for an array
+ */
+ public boolean isArray() {
+ return false;
+ }
+
+ /**
+ * Returns true if the internal state has changed.
+ */
+ boolean popChanged() {
+ boolean changed = this.changed;
+ this.changed = false;
+ return changed;
+ }
+
+ public boolean isAssignableFrom(Type type) {
+ throw new UnsupportedOperationException("Not implemented");
+ }
+
+ public boolean isAssignableTo(Type type) {
+ if (resolved != null)
+ return type.isAssignableFrom(resolved);
+
+ if (Type.OBJECT.equals(type))
+ return true;
+
+ if (potentialClass != null && !type.isAssignableFrom(potentialClass))
+ potentialClass = null;
+
+ Map map = mergeMultiAndSingle(this, type);
+
+ if (map.size() == 1 && potentialClass == null) {
+ // Update previous merge paths to the same resolved type
+ resolved = Type.get((CtClass)map.values().iterator().next());
+ propogateResolved();
+
+ return true;
+ }
+
+ // Keep all previous merge paths up to date
+ if (map.size() >= 1) {
+ interfaces = map;
+ propogateState();
+
+ return true;
+ }
+
+ if (potentialClass != null) {
+ resolved = potentialClass;
+ propogateResolved();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ private void propogateState() {
+ MultiType source = mergeSource;
+ while (source != null) {
+ source.interfaces = interfaces;
+ source.potentialClass = potentialClass;
+ source = source.mergeSource;
+ }
+ }
+
+ private void propogateResolved() {
+ MultiType source = mergeSource;
+ while (source != null) {
+ source.resolved = resolved;
+ source = source.mergeSource;
+ }
+ }
+
+ /**
+ * Always returns true, since this type is always a reference.
+ *
+ * @return true
+ */
+ public boolean isReference() {
+ return true;
+ }
+
+ private Map getAllMultiInterfaces(MultiType type) {
+ Map map = new HashMap();
+
+ Iterator iter = type.interfaces.values().iterator();
+ while (iter.hasNext()) {
+ CtClass intf = (CtClass)iter.next();
+ map.put(intf.getName(), intf);
+ getAllInterfaces(intf, map);
+ }
+
+ return map;
+ }
+
+
+ private Map mergeMultiInterfaces(MultiType type1, MultiType type2) {
+ Map map1 = getAllMultiInterfaces(type1);
+ Map map2 = getAllMultiInterfaces(type2);
+
+ return findCommonInterfaces(map1, map2);
+ }
+
+ private Map mergeMultiAndSingle(MultiType multi, Type single) {
+ Map map1 = getAllMultiInterfaces(multi);
+ Map map2 = getAllInterfaces(single.getCtClass(), null);
+
+ return findCommonInterfaces(map1, map2);
+ }
+
+ private boolean inMergeSource(MultiType source) {
+ while (source != null) {
+ if (source == this)
+ return true;
+
+ source = source.mergeSource;
+ }
+
+ return false;
+ }
+
+ public Type merge(Type type) {
+ if (this == type)
+ return this;
+
+ if (type == UNINIT)
+ return this;
+
+ if (type == BOGUS)
+ return BOGUS;
+
+ if (type == null)
+ return this;
+
+ if (resolved != null)
+ return resolved.merge(type);
+
+ if (potentialClass != null) {
+ Type mergePotential = potentialClass.merge(type);
+ if (! mergePotential.equals(potentialClass) || mergePotential.popChanged()) {
+ potentialClass = Type.OBJECT.equals(mergePotential) ? null : mergePotential;
+ changed = true;
+ }
+ }
+
+ Map merged;
+
+ if (type instanceof MultiType) {
+ MultiType multi = (MultiType)type;
+
+ if (multi.resolved != null) {
+ merged = mergeMultiAndSingle(this, multi.resolved);
+ } else {
+ merged = mergeMultiInterfaces(multi, this);
+ if (! inMergeSource(multi))
+ mergeSource = multi;
+ }
+ } else {
+ merged = mergeMultiAndSingle(this, type);
+ }
+
+ // Keep all previous merge paths up to date
+ if (merged.size() > 1 || (merged.size() == 1 && potentialClass != null)) {
+ // Check for changes
+ if (merged.size() != interfaces.size()) {
+ changed = true;
+ } else if (changed == false){
+ Iterator iter = merged.keySet().iterator();
+ while (iter.hasNext())
+ if (! interfaces.containsKey(iter.next()))
+ changed = true;
+ }
+
+ interfaces = merged;
+ propogateState();
+
+ return this;
+ }
+
+ if (merged.size() == 1) {
+ resolved = Type.get((CtClass) merged.values().iterator().next());
+ } else if (potentialClass != null){
+ resolved = potentialClass;
+ } else {
+ resolved = OBJECT;
+ }
+
+ propogateResolved();
+
+ return resolved;
+ }
+
+ public boolean equals(Object o) {
+ if (! (o instanceof MultiType))
+ return false;
+
+ MultiType multi = (MultiType) o;
+ if (resolved != null)
+ return resolved.equals(multi.resolved);
+ else if (multi.resolved != null)
+ return false;
+
+ return interfaces.keySet().equals(multi.interfaces.keySet());
+ }
+
+ public String toString() {
+ if (resolved != null)
+ return resolved.toString();
+
+ StringBuffer buffer = new StringBuffer("{");
+ Iterator iter = interfaces.keySet().iterator();
+ while (iter.hasNext()) {
+ buffer.append(iter.next());
+ buffer.append(", ");
+ }
+ buffer.setLength(buffer.length() - 2);
+ if (potentialClass != null)
+ buffer.append(", *").append(potentialClass.toString());
+ buffer.append("}");
+ return buffer.toString();
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/Subroutine.java b/src/main/javassist/bytecode/analysis/Subroutine.java
new file mode 100644
index 0000000..1347813
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Subroutine.java
@@ -0,0 +1,66 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Represents a nested method subroutine (marked by JSR and RET).
+ *
+ * @author Jason T. Greene
+ */
+public class Subroutine {
+ //private Set callers = new HashSet();
+ private List callers = new ArrayList();
+ private Set access = new HashSet();
+ private int start;
+
+ public Subroutine(int start, int caller) {
+ this.start = start;
+ callers.add(new Integer(caller));
+ }
+
+ public void addCaller(int caller) {
+ callers.add(new Integer(caller));
+ }
+
+ public int start() {
+ return start;
+ }
+
+ public void access(int index) {
+ access.add(new Integer(index));
+ }
+
+ public boolean isAccessed(int index) {
+ return access.contains(new Integer(index));
+ }
+
+ public Collection accessed() {
+ return access;
+ }
+
+ public Collection callers() {
+ return callers;
+ }
+
+ public String toString() {
+ return "start = " + start + " callers = " + callers.toString();
+ }
+}
\ No newline at end of file
diff --git a/src/main/javassist/bytecode/analysis/SubroutineScanner.java b/src/main/javassist/bytecode/analysis/SubroutineScanner.java
new file mode 100644
index 0000000..f42202e
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/SubroutineScanner.java
@@ -0,0 +1,156 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ExceptionTable;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+
+/**
+ * Discovers the subroutines in a method, and tracks all callers.
+ *
+ * @author Jason T. Greene
+ */
+public class SubroutineScanner implements Opcode {
+
+ private Subroutine[] subroutines;
+ Map subTable = new HashMap();
+ Set done = new HashSet();
+
+
+ public Subroutine[] scan(MethodInfo method) throws BadBytecode {
+ CodeAttribute code = method.getCodeAttribute();
+ CodeIterator iter = code.iterator();
+
+ subroutines = new Subroutine[code.getCodeLength()];
+ subTable.clear();
+ done.clear();
+
+ scan(0, iter, null);
+
+ ExceptionTable exceptions = code.getExceptionTable();
+ for (int i = 0; i < exceptions.size(); i++) {
+ int handler = exceptions.handlerPc(i);
+ // If an exception is thrown in subroutine, the handler
+ // is part of the same subroutine.
+ scan(handler, iter, subroutines[exceptions.startPc(i)]);
+ }
+
+ return subroutines;
+ }
+
+ private void scan(int pos, CodeIterator iter, Subroutine sub) throws BadBytecode {
+ // Skip already processed blocks
+ if (done.contains(new Integer(pos)))
+ return;
+
+ done.add(new Integer(pos));
+
+ int old = iter.lookAhead();
+ iter.move(pos);
+
+ boolean next;
+ do {
+ pos = iter.next();
+ next = scanOp(pos, iter, sub) && iter.hasNext();
+ } while (next);
+
+ iter.move(old);
+ }
+
+ private boolean scanOp(int pos, CodeIterator iter, Subroutine sub) throws BadBytecode {
+ subroutines[pos] = sub;
+
+ int opcode = iter.byteAt(pos);
+
+ if (opcode == TABLESWITCH) {
+ scanTableSwitch(pos, iter, sub);
+
+ return false;
+ }
+
+ if (opcode == LOOKUPSWITCH) {
+ scanLookupSwitch(pos, iter, sub);
+
+ return false;
+ }
+
+ // All forms of return and throw end current code flow
+ if (Util.isReturn(opcode) || opcode == RET || opcode == ATHROW)
+ return false;
+
+ if (Util.isJumpInstruction(opcode)) {
+ int target = Util.getJumpTarget(pos, iter);
+ if (opcode == JSR || opcode == JSR_W) {
+ Subroutine s = (Subroutine) subTable.get(new Integer(target));
+ if (s == null) {
+ s = new Subroutine(target, pos);
+ subTable.put(new Integer(target), s);
+ scan(target, iter, s);
+ } else {
+ s.addCaller(pos);
+ }
+ } else {
+ scan(target, iter, sub);
+
+ // GOTO ends current code flow
+ if (Util.isGoto(opcode))
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ private void scanLookupSwitch(int pos, CodeIterator iter, Subroutine sub) throws BadBytecode {
+ int index = (pos & ~3) + 4;
+ // default
+ scan(pos + iter.s32bitAt(index), iter, sub);
+ int npairs = iter.s32bitAt(index += 4);
+ int end = npairs * 8 + (index += 4);
+
+ // skip "match"
+ for (index += 4; index < end; index += 8) {
+ int target = iter.s32bitAt(index) + pos;
+ scan(target, iter, sub);
+ }
+ }
+
+ private void scanTableSwitch(int pos, CodeIterator iter, Subroutine sub) throws BadBytecode {
+ // Skip 4 byte alignment padding
+ int index = (pos & ~3) + 4;
+ // default
+ scan(pos + iter.s32bitAt(index), iter, sub);
+ int low = iter.s32bitAt(index += 4);
+ int high = iter.s32bitAt(index += 4);
+ int end = (high - low + 1) * 4 + (index += 4);
+
+ // Offset table
+ for (; index < end; index += 4) {
+ int target = iter.s32bitAt(index) + pos;
+ scan(target, iter, sub);
+ }
+ }
+
+
+}
diff --git a/src/main/javassist/bytecode/analysis/Type.java b/src/main/javassist/bytecode/analysis/Type.java
new file mode 100644
index 0000000..234f050
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Type.java
@@ -0,0 +1,592 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+
+/**
+ * Represents a JVM type in data-flow analysis. This abstraction is necessary since
+ * a JVM type not only includes all normal Java types, but also a few special types
+ * that are used by the JVM internally. See the static field types on this class for
+ * more info on these special types.
+ *
+ * All primitive and special types reuse the same instance, so identity comparison can
+ * be used when examining them. Normal java types must use {@link #equals(Object)} to
+ * compare type instances.
+ *
+ * In most cases, applications which consume this API, only need to call {@link #getCtClass()}
+ * to obtain the needed type information.
+ *
+ * @author Jason T. Greene
+ */
+public class Type {
+ private final CtClass clazz;
+ private final boolean special;
+
+ private static final Map prims = new IdentityHashMap();
+ /** Represents the double primitive type */
+ public static final Type DOUBLE = new Type(CtClass.doubleType);
+ /** Represents the boolean primitive type */
+ public static final Type BOOLEAN = new Type(CtClass.booleanType);
+ /** Represents the long primitive type */
+ public static final Type LONG = new Type(CtClass.longType);
+ /** Represents the char primitive type */
+ public static final Type CHAR = new Type(CtClass.charType);
+ /** Represents the byte primitive type */
+ public static final Type BYTE = new Type(CtClass.byteType);
+ /** Represents the short primitive type */
+ public static final Type SHORT = new Type(CtClass.shortType);
+ /** Represents the integer primitive type */
+ public static final Type INTEGER = new Type(CtClass.intType);
+ /** Represents the float primitive type */
+ public static final Type FLOAT = new Type(CtClass.floatType);
+ /** Represents the void primitive type */
+ public static final Type VOID = new Type(CtClass.voidType);
+
+ /**
+ * Represents an unknown, or null type. This occurs when aconst_null is used.
+ * It is important not to treat this type as java.lang.Object, since a null can
+ * be assigned to any reference type. The analyzer will replace these with
+ * an actual known type if it can be determined by a merged path with known type
+ * information. If this type is encountered on a frame then it is guaranteed to
+ * be null, and the type information is simply not available. Any attempts to
+ * infer the type, without further information from the compiler would be a guess.
+ */
+ public static final Type UNINIT = new Type(null);
+
+ /**
+ * Represents an internal JVM return address, which is used by the RET
+ * instruction to return to a JSR that invoked the subroutine.
+ */
+ public static final Type RETURN_ADDRESS = new Type(null, true);
+
+ /** A placeholder used by the analyzer for the second word position of a double-word type */
+ public static final Type TOP = new Type(null, true);
+
+ /**
+ * Represents a non-accessible value. Code cannot access the value this type
+ * represents. It occurs when bytecode reuses a local variable table
+ * position with non-mergable types. An example would be compiled code which
+ * uses the same position for a primitive type in one branch, and a reference type
+ * in another branch.
+ */
+ public static final Type BOGUS = new Type(null, true);
+
+ /** Represents the java.lang.Object reference type */
+ public static final Type OBJECT = lookupType("java.lang.Object");
+ /** Represents the java.io.Serializable reference type */
+ public static final Type SERIALIZABLE = lookupType("java.io.Serializable");
+ /** Represents the java.lang.Coneable reference type */
+ public static final Type CLONEABLE = lookupType("java.lang.Cloneable");
+ /** Represents the java.lang.Throwable reference type */
+ public static final Type THROWABLE = lookupType("java.lang.Throwable");
+
+ static {
+ prims.put(CtClass.doubleType, DOUBLE);
+ prims.put(CtClass.longType, LONG);
+ prims.put(CtClass.charType, CHAR);
+ prims.put(CtClass.shortType, SHORT);
+ prims.put(CtClass.intType, INTEGER);
+ prims.put(CtClass.floatType, FLOAT);
+ prims.put(CtClass.byteType, BYTE);
+ prims.put(CtClass.booleanType, BOOLEAN);
+ prims.put(CtClass.voidType, VOID);
+
+ }
+
+ /**
+ * Obtain the Type for a given class. If the class is a primitive,
+ * the the unique type instance for the primitive will be returned.
+ * Otherwise a new Type instance representing the class is returned.
+ *
+ * @param clazz The java class
+ * @return a type instance for this class
+ */
+ public static Type get(CtClass clazz) {
+ Type type = (Type)prims.get(clazz);
+ return type != null ? type : new Type(clazz);
+ }
+
+ private static Type lookupType(String name) {
+ try {
+ return new Type(ClassPool.getDefault().get(name));
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ Type(CtClass clazz) {
+ this(clazz, false);
+ }
+
+ private Type(CtClass clazz, boolean special) {
+ this.clazz = clazz;
+ this.special = special;
+ }
+
+ // Used to indicate a merge internally triggered a change
+ boolean popChanged() {
+ return false;
+ }
+
+ /**
+ * Gets the word size of this type. Double-word types, such as long and double
+ * will occupy two positions on the local variable table or stack.
+ *
+ * @return the number of words needed to hold this type
+ */
+ public int getSize() {
+ return clazz == CtClass.doubleType || clazz == CtClass.longType || this == TOP ? 2 : 1;
+ }
+
+ /**
+ * Returns the class this type represents. If the type is special, null will be returned.
+ *
+ * @return the class for this type, or null if special
+ */
+ public CtClass getCtClass() {
+ return clazz;
+ }
+
+ /**
+ * Returns whether or not this type is a normal java reference, i.e. it is or extends java.lang.Object.
+ *
+ * @return true if a java reference, false if a primitive or special
+ */
+ public boolean isReference() {
+ return !special && (clazz == null || !clazz.isPrimitive());
+ }
+
+ /**
+ * Returns whether or not the type is special. A special type is one that is either used
+ * for internal tracking, or is only used internally by the JVM.
+ *
+ * @return true if special, false if not
+ */
+ public boolean isSpecial() {
+ return special;
+ }
+
+ /**
+ * Returns whether or not this type is an array.
+ *
+ * @return true if an array, false if not
+ */
+ public boolean isArray() {
+ return clazz != null && clazz.isArray();
+ }
+
+ /**
+ * Returns the number of dimensions of this array. If the type is not an
+ * array zero is returned.
+ *
+ * @return zero if not an array, otherwise the number of array dimensions.
+ */
+ public int getDimensions() {
+ if (!isArray()) return 0;
+
+ String name = clazz.getName();
+ int pos = name.length() - 1;
+ int count = 0;
+ while (name.charAt(pos) == ']' ) {
+ pos -= 2;
+ count++;
+ }
+
+ return count;
+ }
+
+ /**
+ * Returns the array component if this type is an array. If the type
+ * is not an array null is returned.
+ *
+ * @return the array component if an array, otherwise null
+ */
+ public Type getComponent() {
+ if (this.clazz == null || !this.clazz.isArray())
+ return null;
+
+ CtClass component;
+ try {
+ component = this.clazz.getComponentType();
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+
+ Type type = (Type)prims.get(component);
+ return (type != null) ? type : new Type(component);
+ }
+
+ /**
+ * Determines whether this type is assignable, to the passed type.
+ * A type is assignable to another if it is either the same type, or
+ * a sub-type.
+ *
+ * @param type the type to test assignability to
+ * @return true if this is assignable to type, otherwise false
+ */
+ public boolean isAssignableFrom(Type type) {
+ if (this == type)
+ return true;
+
+ if ((type == UNINIT && isReference()) || this == UNINIT && type.isReference())
+ return true;
+
+ if (type instanceof MultiType)
+ return ((MultiType)type).isAssignableTo(this);
+
+ if (type instanceof MultiArrayType)
+ return ((MultiArrayType)type).isAssignableTo(this);
+
+
+ // Primitives and Special types must be identical
+ if (clazz == null || clazz.isPrimitive())
+ return false;
+
+ try {
+ return type.clazz.subtypeOf(clazz);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * Finds the common base type, or interface which both this and the specified
+ * type can be assigned. If there is more than one possible answer, then a {@link MultiType},
+ * or a {@link MultiArrayType} is returned. Multi-types have special rules,
+ * and successive merges and assignment tests on them will alter their internal state,
+ * as well as other multi-types they have been merged with. This method is used by
+ * the data-flow analyzer to merge the type state from multiple branches.
+ *
+ * @param type the type to merge with
+ * @return the merged type
+ */
+ public Type merge(Type type) {
+ if (type == this)
+ return this;
+ if (type == null)
+ return this;
+ if (type == Type.UNINIT)
+ return this;
+ if (this == Type.UNINIT)
+ return type;
+
+ // Unequal primitives and special types can not be merged
+ if (! type.isReference() || ! this.isReference())
+ return BOGUS;
+
+ // Centralize merging of multi-interface types
+ if (type instanceof MultiType)
+ return type.merge(this);
+
+ if (type.isArray() && this.isArray())
+ return mergeArray(type);
+
+ try {
+ return mergeClasses(type);
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ Type getRootComponent(Type type) {
+ while (type.isArray())
+ type = type.getComponent();
+
+ return type;
+ }
+
+ private Type createArray(Type rootComponent, int dims) {
+ if (rootComponent instanceof MultiType)
+ return new MultiArrayType((MultiType) rootComponent, dims);
+
+ String name = arrayName(rootComponent.clazz.getName(), dims);
+
+ Type type;
+ try {
+ type = Type.get(getClassPool(rootComponent).get(name));
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+
+ return type;
+ }
+
+ String arrayName(String component, int dims) {
+ // Using char[] since we have no StringBuilder in JDK4, and StringBuffer is slow.
+ // Although, this is more efficient even if we did have one.
+ int i = component.length();
+ int size = i + dims * 2;
+ char[] string = new char[size];
+ component.getChars(0, i, string, 0);
+ while (i < size) {
+ string[i++] = '[';
+ string[i++] = ']';
+ }
+ component = new String(string);
+ return component;
+ }
+
+ private ClassPool getClassPool(Type rootComponent) {
+ ClassPool pool = rootComponent.clazz.getClassPool();
+ return pool != null ? pool : ClassPool.getDefault();
+ }
+
+ private Type mergeArray(Type type) {
+ Type typeRoot = getRootComponent(type);
+ Type thisRoot = getRootComponent(this);
+ int typeDims = type.getDimensions();
+ int thisDims = this.getDimensions();
+
+ // Array commponents can be merged when the dimensions are equal
+ if (typeDims == thisDims) {
+ Type mergedComponent = thisRoot.merge(typeRoot);
+
+ // If the components can not be merged (a primitive component mixed with a different type)
+ // then Object is the common type.
+ if (mergedComponent == Type.BOGUS)
+ return Type.OBJECT;
+
+ return createArray(mergedComponent, thisDims);
+ }
+
+ Type targetRoot;
+ int targetDims;
+
+ if (typeDims < thisDims) {
+ targetRoot = typeRoot;
+ targetDims = typeDims;
+ } else {
+ targetRoot = thisRoot;
+ targetDims = thisDims;
+ }
+
+ // Special case, arrays are cloneable and serializable, so prefer them when dimensions differ
+ if (eq(CLONEABLE.clazz, targetRoot.clazz) || eq(SERIALIZABLE.clazz, targetRoot.clazz))
+ return createArray(targetRoot, targetDims);
+
+ return createArray(OBJECT, targetDims);
+ }
+
+ private static CtClass findCommonSuperClass(CtClass one, CtClass two) throws NotFoundException {
+ CtClass deep = one;
+ CtClass shallow = two;
+ CtClass backupShallow = shallow;
+ CtClass backupDeep = deep;
+
+ // Phase 1 - Find the deepest hierarchy, set deep and shallow correctly
+ for (;;) {
+ // In case we get lucky, and find a match early
+ if (eq(deep, shallow) && deep.getSuperclass() != null)
+ return deep;
+
+ CtClass deepSuper = deep.getSuperclass();
+ CtClass shallowSuper = shallow.getSuperclass();
+
+ if (shallowSuper == null) {
+ // right, now reset shallow
+ shallow = backupShallow;
+ break;
+ }
+
+ if (deepSuper == null) {
+ // wrong, swap them, since deep is now useless, its our tmp before we swap it
+ deep = backupDeep;
+ backupDeep = backupShallow;
+ backupShallow = deep;
+
+ deep = shallow;
+ shallow = backupShallow;
+ break;
+ }
+
+ deep = deepSuper;
+ shallow = shallowSuper;
+ }
+
+ // Phase 2 - Move deepBackup up by (deep end - deep)
+ for (;;) {
+ deep = deep.getSuperclass();
+ if (deep == null)
+ break;
+
+ backupDeep = backupDeep.getSuperclass();
+ }
+
+ deep = backupDeep;
+
+ // Phase 3 - The hierarchy positions are now aligned
+ // The common super class is easy to find now
+ while (!eq(deep, shallow)) {
+ deep = deep.getSuperclass();
+ shallow = shallow.getSuperclass();
+ }
+
+ return deep;
+ }
+
+ private Type mergeClasses(Type type) throws NotFoundException {
+ CtClass superClass = findCommonSuperClass(this.clazz, type.clazz);
+
+ // If its Object, then try and find a common interface(s)
+ if (superClass.getSuperclass() == null) {
+ Map interfaces = findCommonInterfaces(type);
+ if (interfaces.size() == 1)
+ return new Type((CtClass) interfaces.values().iterator().next());
+ if (interfaces.size() > 1)
+ return new MultiType(interfaces);
+
+ // Only Object is in common
+ return new Type(superClass);
+ }
+
+ // Check for a common interface that is not on the found supertype
+ Map commonDeclared = findExclusiveDeclaredInterfaces(type, superClass);
+ if (commonDeclared.size() > 0) {
+ return new MultiType(commonDeclared, new Type(superClass));
+ }
+
+ return new Type(superClass);
+ }
+
+ private Map findCommonInterfaces(Type type) {
+ Map typeMap = getAllInterfaces(type.clazz, null);
+ Map thisMap = getAllInterfaces(this.clazz, null);
+
+ return findCommonInterfaces(typeMap, thisMap);
+ }
+
+ private Map findExclusiveDeclaredInterfaces(Type type, CtClass exclude) {
+ Map typeMap = getDeclaredInterfaces(type.clazz, null);
+ Map thisMap = getDeclaredInterfaces(this.clazz, null);
+ Map excludeMap = getAllInterfaces(exclude, null);
+
+ Iterator i = excludeMap.keySet().iterator();
+ while (i.hasNext()) {
+ Object intf = i.next();
+ typeMap.remove(intf);
+ thisMap.remove(intf);
+ }
+
+ return findCommonInterfaces(typeMap, thisMap);
+ }
+
+
+ Map findCommonInterfaces(Map typeMap, Map alterMap) {
+ Iterator i = alterMap.keySet().iterator();
+ while (i.hasNext()) {
+ if (! typeMap.containsKey(i.next()))
+ i.remove();
+ }
+
+ // Reduce to subinterfaces
+ // This does not need to be recursive since we make a copy,
+ // and that copy contains all super types for the whole hierarchy
+ i = new ArrayList(alterMap.values()).iterator();
+ while (i.hasNext()) {
+ CtClass intf = (CtClass) i.next();
+ CtClass[] interfaces;
+ try {
+ interfaces = intf.getInterfaces();
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+
+ for (int c = 0; c < interfaces.length; c++)
+ alterMap.remove(interfaces[c].getName());
+ }
+
+ return alterMap;
+ }
+
+ Map getAllInterfaces(CtClass clazz, Map map) {
+ if (map == null)
+ map = new HashMap();
+
+ if (clazz.isInterface())
+ map.put(clazz.getName(), clazz);
+ do {
+ try {
+ CtClass[] interfaces = clazz.getInterfaces();
+ for (int i = 0; i < interfaces.length; i++) {
+ CtClass intf = interfaces[i];
+ map.put(intf.getName(), intf);
+ getAllInterfaces(intf, map);
+ }
+
+ clazz = clazz.getSuperclass();
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ } while (clazz != null);
+
+ return map;
+ }
+
+ Map getDeclaredInterfaces(CtClass clazz, Map map) {
+ if (map == null)
+ map = new HashMap();
+
+ if (clazz.isInterface())
+ map.put(clazz.getName(), clazz);
+
+ CtClass[] interfaces;
+ try {
+ interfaces = clazz.getInterfaces();
+ } catch (NotFoundException e) {
+ throw new RuntimeException(e);
+ }
+
+ for (int i = 0; i < interfaces.length; i++) {
+ CtClass intf = interfaces[i];
+ map.put(intf.getName(), intf);
+ getDeclaredInterfaces(intf, map);
+ }
+
+ return map;
+ }
+
+ public boolean equals(Object o) {
+ if (! (o instanceof Type))
+ return false;
+
+ return o.getClass() == getClass() && eq(clazz, ((Type)o).clazz);
+ }
+
+ static boolean eq(CtClass one, CtClass two) {
+ return one == two || (one != null && two != null && one.getName().equals(two.getName()));
+ }
+
+ public String toString() {
+ if (this == BOGUS)
+ return "BOGUS";
+ if (this == UNINIT)
+ return "UNINIT";
+ if (this == RETURN_ADDRESS)
+ return "RETURN ADDRESS";
+ if (this == TOP)
+ return "TOP";
+
+ return clazz == null ? "null" : clazz.getName();
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/Util.java b/src/main/javassist/bytecode/analysis/Util.java
new file mode 100644
index 0000000..a8cdfcc
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/Util.java
@@ -0,0 +1,47 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.analysis;
+
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.Opcode;
+
+/**
+ * A set of common utility methods.
+ *
+ * @author Jason T. Greene
+ */
+public class Util implements Opcode {
+ public static int getJumpTarget(int pos, CodeIterator iter) {
+ int opcode = iter.byteAt(pos);
+ pos += (opcode == JSR_W || opcode == GOTO_W) ? iter.s32bitAt(pos + 1) : iter.s16bitAt(pos + 1);
+ return pos;
+ }
+
+ public static boolean isJumpInstruction(int opcode) {
+ return (opcode >= IFEQ && opcode <= JSR) || opcode == IFNULL || opcode == IFNONNULL || opcode == JSR_W || opcode == GOTO_W;
+ }
+
+ public static boolean isGoto(int opcode) {
+ return opcode == GOTO || opcode == GOTO_W;
+ }
+
+ public static boolean isJsr(int opcode) {
+ return opcode == JSR || opcode == JSR_W;
+ }
+
+ public static boolean isReturn(int opcode) {
+ return (opcode >= IRETURN && opcode <= RETURN);
+ }
+}
diff --git a/src/main/javassist/bytecode/analysis/package.html b/src/main/javassist/bytecode/analysis/package.html
new file mode 100644
index 0000000..b141670
--- /dev/null
+++ b/src/main/javassist/bytecode/analysis/package.html
@@ -0,0 +1,19 @@
+<html>
+<body>
+Bytecode Analysis API.
+
+<p>This package provides an API for performing data-flow analysis on a method's bytecode.
+This allows the user to determine the type state of the stack and local variable table
+at the start of every instruction. In addition this API can be used to validate
+bytecode, find dead bytecode, and identify unnecessary checkcasts.
+
+<p>The users of this package must know the specifications of
+class file and Java bytecode. For more details, read this book:
+
+<ul>Tim Lindholm and Frank Yellin,
+"The Java Virtual Machine Specification 2nd Ed.",
+Addison-Wesley, 1999.
+</ul>
+
+</body>
+</html>
diff --git a/src/main/javassist/bytecode/annotation/Annotation.java b/src/main/javassist/bytecode/annotation/Annotation.java
new file mode 100644
index 0000000..b48cc8e
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/Annotation.java
@@ -0,0 +1,347 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+
+import java.io.IOException;
+import java.util.LinkedHashMap;
+import java.util.Set;
+import java.util.Iterator;
+
+/**
+ * The <code>annotation</code> structure.
+ *
+ * <p>An instance of this class is returned by
+ * <code>getAnnotations()</code> in <code>AnnotationsAttribute</code>
+ * or in <code>ParameterAnnotationsAttribute</code>.
+ *
+ * @see javassist.bytecode.AnnotationsAttribute#getAnnotations()
+ * @see javassist.bytecode.ParameterAnnotationsAttribute#getAnnotations()
+ * @see MemberValue
+ * @see MemberValueVisitor
+ * @see AnnotationsWriter
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ * @author <a href="mailto:adrian@jboss.org">Adrian Brock</a>
+ */
+public class Annotation {
+ static class Pair {
+ int name;
+ MemberValue value;
+ }
+
+ ConstPool pool;
+ int typeIndex;
+ LinkedHashMap members; // this sould be LinkedHashMap
+ // but it is not supported by JDK 1.3.
+
+ /**
+ * Constructs an annotation including no members. A member can be
+ * later added to the created annotation by <code>addMemberValue()</code>.
+ *
+ * @param type the index into the constant pool table.
+ * the entry at that index must be the
+ * <code>CONSTANT_Utf8_Info</code> structure
+ * repreenting the name of the annotation interface type.
+ * @param cp the constant pool table.
+ *
+ * @see #addMemberValue(String, MemberValue)
+ */
+ public Annotation(int type, ConstPool cp) {
+ pool = cp;
+ typeIndex = type;
+ members = null;
+ }
+
+ /**
+ * Constructs an annotation including no members. A member can be
+ * later added to the created annotation by <code>addMemberValue()</code>.
+ *
+ * @param typeName the name of the annotation interface type.
+ * @param cp the constant pool table.
+ *
+ * @see #addMemberValue(String, MemberValue)
+ */
+ public Annotation(String typeName, ConstPool cp) {
+ this(cp.addUtf8Info(Descriptor.of(typeName)), cp);
+ }
+
+ /**
+ * Constructs an annotation that can be accessed through the interface
+ * represented by <code>clazz</code>. The values of the members are
+ * not specified.
+ *
+ * @param cp the constant pool table.
+ * @param clazz the interface.
+ * @throws NotFoundException when the clazz is not found
+ */
+ public Annotation(ConstPool cp, CtClass clazz)
+ throws NotFoundException
+ {
+ // todo Enums are not supported right now.
+ this(cp.addUtf8Info(Descriptor.of(clazz.getName())), cp);
+
+ if (!clazz.isInterface())
+ throw new RuntimeException(
+ "Only interfaces are allowed for Annotation creation.");
+
+ CtMethod methods[] = clazz.getDeclaredMethods();
+ if (methods.length > 0) {
+ members = new LinkedHashMap();
+ }
+
+ for (int i = 0; i < methods.length; i++) {
+ CtClass returnType = methods[i].getReturnType();
+ addMemberValue(methods[i].getName(),
+ createMemberValue(cp, returnType));
+
+ }
+ }
+
+ /**
+ * Makes an instance of <code>MemberValue</code>.
+ *
+ * @param cp the constant pool table.
+ * @param type the type of the member.
+ * @return the member value
+ * @throws NotFoundException when the type is not found
+ */
+ public static MemberValue createMemberValue(ConstPool cp, CtClass type)
+ throws NotFoundException
+ {
+ if (type == CtClass.booleanType)
+ return new BooleanMemberValue(cp);
+ else if (type == CtClass.byteType)
+ return new ByteMemberValue(cp);
+ else if (type == CtClass.charType)
+ return new CharMemberValue(cp);
+ else if (type == CtClass.shortType)
+ return new ShortMemberValue(cp);
+ else if (type == CtClass.intType)
+ return new IntegerMemberValue(cp);
+ else if (type == CtClass.longType)
+ return new LongMemberValue(cp);
+ else if (type == CtClass.floatType)
+ return new FloatMemberValue(cp);
+ else if (type == CtClass.doubleType)
+ return new DoubleMemberValue(cp);
+ else if (type.getName().equals("java.lang.Class"))
+ return new ClassMemberValue(cp);
+ else if (type.getName().equals("java.lang.String"))
+ return new StringMemberValue(cp);
+ else if (type.isArray()) {
+ CtClass arrayType = type.getComponentType();
+ MemberValue member = createMemberValue(cp, arrayType);
+ return new ArrayMemberValue(member, cp);
+ }
+ else if (type.isInterface()) {
+ Annotation info = new Annotation(cp, type);
+ return new AnnotationMemberValue(info, cp);
+ }
+ else {
+ // treat as enum. I know this is not typed,
+ // but JBoss has an Annotation Compiler for JDK 1.4
+ // and I want it to work with that. - Bill Burke
+ EnumMemberValue emv = new EnumMemberValue(cp);
+ emv.setType(type.getName());
+ return emv;
+ }
+ }
+
+ /**
+ * Adds a new member.
+ *
+ * @param nameIndex the index into the constant pool table.
+ * The entry at that index must be
+ * a <code>CONSTANT_Utf8_info</code> structure.
+ * structure representing the member name.
+ * @param value the member value.
+ */
+ public void addMemberValue(int nameIndex, MemberValue value) {
+ Pair p = new Pair();
+ p.name = nameIndex;
+ p.value = value;
+ addMemberValue(p);
+ }
+
+ /**
+ * Adds a new member.
+ *
+ * @param name the member name.
+ * @param value the member value.
+ */
+ public void addMemberValue(String name, MemberValue value) {
+ Pair p = new Pair();
+ p.name = pool.addUtf8Info(name);
+ p.value = value;
+ if (members == null)
+ members = new LinkedHashMap();
+
+ members.put(name, p);
+ }
+
+ private void addMemberValue(Pair pair) {
+ String name = pool.getUtf8Info(pair.name);
+ if (members == null)
+ members = new LinkedHashMap();
+
+ members.put(name, pair);
+ }
+
+ /**
+ * Returns a string representation of the annotation.
+ */
+ public String toString() {
+ StringBuffer buf = new StringBuffer("@");
+ buf.append(getTypeName());
+ if (members != null) {
+ buf.append("(");
+ Iterator mit = members.keySet().iterator();
+ while (mit.hasNext()) {
+ String name = (String)mit.next();
+ buf.append(name).append("=").append(getMemberValue(name));
+ if (mit.hasNext())
+ buf.append(", ");
+ }
+ buf.append(")");
+ }
+
+ return buf.toString();
+ }
+
+ /**
+ * Obtains the name of the annotation type.
+ *
+ * @return the type name
+ */
+ public String getTypeName() {
+ return Descriptor.toClassName(pool.getUtf8Info(typeIndex));
+ }
+
+ /**
+ * Obtains all the member names.
+ *
+ * @return null if no members are defined.
+ */
+ public Set getMemberNames() {
+ if (members == null)
+ return null;
+ else
+ return members.keySet();
+ }
+
+ /**
+ * Obtains the member value with the given name.
+ *
+ * <p>If this annotation does not have a value for the
+ * specified member,
+ * this method returns null. It does not return a
+ * <code>MemberValue</code> with the default value.
+ * The default value can be obtained from the annotation type.
+ *
+ * @param name the member name
+ * @return null if the member cannot be found or if the value is
+ * the default value.
+ *
+ * @see javassist.bytecode.AnnotationDefaultAttribute
+ */
+ public MemberValue getMemberValue(String name) {
+ if (members == null)
+ return null;
+ else {
+ Pair p = (Pair)members.get(name);
+ if (p == null)
+ return null;
+ else
+ return p.value;
+ }
+ }
+
+ /**
+ * Constructs an annotation-type object representing this annotation.
+ * For example, if this annotation represents <code>@Author</code>,
+ * this method returns an <code>Author</code> object.
+ *
+ * @param cl class loader for loading an annotation type.
+ * @param cp class pool for obtaining class files.
+ * @return the annotation
+ * @throws ClassNotFoundException if the class cannot found.
+ * @throws NoSuchClassError if the class linkage fails.
+ */
+ public Object toAnnotationType(ClassLoader cl, ClassPool cp)
+ throws ClassNotFoundException, NoSuchClassError
+ {
+ return AnnotationImpl.make(cl,
+ MemberValue.loadClass(cl, getTypeName()),
+ cp, this);
+ }
+
+ /**
+ * Writes this annotation.
+ *
+ * @param writer the output.
+ * @throws IOException for an error during the write
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ String typeName = pool.getUtf8Info(typeIndex);
+ if (members == null) {
+ writer.annotation(typeName, 0);
+ return;
+ }
+
+ writer.annotation(typeName, members.size());
+ Iterator it = members.values().iterator();
+ while (it.hasNext()) {
+ Pair pair = (Pair)it.next();
+ writer.memberValuePair(pair.name);
+ pair.value.write(writer);
+ }
+ }
+
+ /**
+ * Returns true if the given object represents the same annotation
+ * as this object. The equality test checks the member values.
+ */
+ public boolean equals(Object obj) {
+ if (obj == this)
+ return true;
+ if (obj == null || obj instanceof Annotation == false)
+ return false;
+
+ Annotation other = (Annotation) obj;
+
+ if (getTypeName().equals(other.getTypeName()) == false)
+ return false;
+
+ LinkedHashMap otherMembers = other.members;
+ if (members == otherMembers)
+ return true;
+ else if (members == null)
+ return otherMembers == null;
+ else
+ if (otherMembers == null)
+ return false;
+ else
+ return members.equals(otherMembers);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/AnnotationImpl.java b/src/main/javassist/bytecode/annotation/AnnotationImpl.java
new file mode 100644
index 0000000..dfd23bb
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/AnnotationImpl.java
@@ -0,0 +1,304 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.AnnotationDefaultAttribute;
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.MethodInfo;
+
+/**
+ * Internal-use only. This is a helper class internally used for implementing
+ * <code>toAnnotationType()</code> in <code>Annotation</code>.
+ *
+ * @author Shigeru Chiba
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author <a href="mailto:adrian@jboss.org">Adrian Brock</a>
+ */
+public class AnnotationImpl implements InvocationHandler {
+ private static final String JDK_ANNOTATION_CLASS_NAME = "java.lang.annotation.Annotation";
+ private static Method JDK_ANNOTATION_TYPE_METHOD = null;
+
+ private Annotation annotation;
+ private ClassPool pool;
+ private ClassLoader classLoader;
+ private transient Class annotationType;
+ private transient int cachedHashCode = Integer.MIN_VALUE;
+
+ static {
+ // Try to resolve the JDK annotation type method
+ try {
+ Class clazz = Class.forName(JDK_ANNOTATION_CLASS_NAME);
+ JDK_ANNOTATION_TYPE_METHOD = clazz.getMethod("annotationType", (Class[])null);
+ }
+ catch (Exception ignored) {
+ // Probably not JDK5+
+ }
+ }
+
+ /**
+ * Constructs an annotation object.
+ *
+ * @param cl class loader for obtaining annotation types.
+ * @param clazz the annotation type.
+ * @param cp class pool for containing an annotation
+ * type (or null).
+ * @param anon the annotation.
+ * @return the annotation
+ */
+ public static Object make(ClassLoader cl, Class clazz, ClassPool cp,
+ Annotation anon) {
+ AnnotationImpl handler = new AnnotationImpl(anon, cp, cl);
+ return Proxy.newProxyInstance(cl, new Class[] { clazz }, handler);
+ }
+
+ private AnnotationImpl(Annotation a, ClassPool cp, ClassLoader loader) {
+ annotation = a;
+ pool = cp;
+ classLoader = loader;
+ }
+
+ /**
+ * Obtains the name of the annotation type.
+ *
+ * @return the type name
+ */
+ public String getTypeName() {
+ return annotation.getTypeName();
+ }
+
+ /**
+ * Get the annotation type
+ *
+ * @return the annotation class
+ * @throws NoClassDefFoundError when the class could not loaded
+ */
+ private Class getAnnotationType() {
+ if (annotationType == null) {
+ String typeName = annotation.getTypeName();
+ try {
+ annotationType = classLoader.loadClass(typeName);
+ }
+ catch (ClassNotFoundException e) {
+ NoClassDefFoundError error = new NoClassDefFoundError("Error loading annotation class: " + typeName);
+ error.setStackTrace(e.getStackTrace());
+ throw error;
+ }
+ }
+ return annotationType;
+ }
+
+ /**
+ * Obtains the internal data structure representing the annotation.
+ *
+ * @return the annotation
+ */
+ public Annotation getAnnotation() {
+ return annotation;
+ }
+
+ /**
+ * Executes a method invocation on a proxy instance.
+ * The implementations of <code>toString()</code>, <code>equals()</code>,
+ * and <code>hashCode()</code> are directly supplied by the
+ * <code>AnnotationImpl</code>. The <code>annotationType()</code> method
+ * is also available on the proxy instance.
+ */
+ public Object invoke(Object proxy, Method method, Object[] args)
+ throws Throwable
+ {
+ String name = method.getName();
+ if (Object.class == method.getDeclaringClass()) {
+ if ("equals".equals(name)) {
+ Object obj = args[0];
+ return new Boolean(checkEquals(obj));
+ }
+ else if ("toString".equals(name))
+ return annotation.toString();
+ else if ("hashCode".equals(name))
+ return new Integer(hashCode());
+ }
+ else if ("annotationType".equals(name)
+ && method.getParameterTypes().length == 0)
+ return getAnnotationType();
+
+ MemberValue mv = annotation.getMemberValue(name);
+ if (mv == null)
+ return getDefault(name, method);
+ else
+ return mv.getValue(classLoader, pool, method);
+ }
+
+ private Object getDefault(String name, Method method)
+ throws ClassNotFoundException, RuntimeException
+ {
+ String classname = annotation.getTypeName();
+ if (pool != null) {
+ try {
+ CtClass cc = pool.get(classname);
+ ClassFile cf = cc.getClassFile2();
+ MethodInfo minfo = cf.getMethod(name);
+ if (minfo != null) {
+ AnnotationDefaultAttribute ainfo
+ = (AnnotationDefaultAttribute)
+ minfo.getAttribute(AnnotationDefaultAttribute.tag);
+ if (ainfo != null) {
+ MemberValue mv = ainfo.getDefaultValue();
+ return mv.getValue(classLoader, pool, method);
+ }
+ }
+ }
+ catch (NotFoundException e) {
+ throw new RuntimeException("cannot find a class file: "
+ + classname);
+ }
+ }
+
+ throw new RuntimeException("no default value: " + classname + "."
+ + name + "()");
+ }
+
+ /**
+ * Returns a hash code value for this object.
+ */
+ public int hashCode() {
+ if (cachedHashCode == Integer.MIN_VALUE) {
+ int hashCode = 0;
+
+ // Load the annotation class
+ getAnnotationType();
+
+ Method[] methods = annotationType.getDeclaredMethods();
+ for (int i = 0; i < methods.length; ++ i) {
+ String name = methods[i].getName();
+ int valueHashCode = 0;
+
+ // Get the value
+ MemberValue mv = annotation.getMemberValue(name);
+ Object value = null;
+ try {
+ if (mv != null)
+ value = mv.getValue(classLoader, pool, methods[i]);
+ if (value == null)
+ value = getDefault(name, methods[i]);
+ }
+ catch (RuntimeException e) {
+ throw e;
+ }
+ catch (Exception e) {
+ throw new RuntimeException("Error retrieving value " + name + " for annotation " + annotation.getTypeName(), e);
+ }
+
+ // Calculate the hash code
+ if (value != null) {
+ if (value.getClass().isArray())
+ valueHashCode = arrayHashCode(value);
+ else
+ valueHashCode = value.hashCode();
+ }
+ hashCode += 127 * name.hashCode() ^ valueHashCode;
+ }
+
+ cachedHashCode = hashCode;
+ }
+ return cachedHashCode;
+ }
+
+ /**
+ * Check that another annotation equals ourselves.
+ *
+ * @param obj the other annotation
+ * @return the true when equals false otherwise
+ * @throws Exception for any problem
+ */
+ private boolean checkEquals(Object obj) throws Exception {
+ if (obj == null)
+ return false;
+
+ // Optimization when the other is one of ourselves
+ if (obj instanceof Proxy) {
+ InvocationHandler ih = Proxy.getInvocationHandler(obj);
+ if (ih instanceof AnnotationImpl) {
+ AnnotationImpl other = (AnnotationImpl) ih;
+ return annotation.equals(other.annotation);
+ }
+ }
+
+ Class otherAnnotationType = (Class) JDK_ANNOTATION_TYPE_METHOD.invoke(obj, (Object[])null);
+ if (getAnnotationType().equals(otherAnnotationType) == false)
+ return false;
+
+ Method[] methods = annotationType.getDeclaredMethods();
+ for (int i = 0; i < methods.length; ++ i) {
+ String name = methods[i].getName();
+
+ // Get the value
+ MemberValue mv = annotation.getMemberValue(name);
+ Object value = null;
+ Object otherValue = null;
+ try {
+ if (mv != null)
+ value = mv.getValue(classLoader, pool, methods[i]);
+ if (value == null)
+ value = getDefault(name, methods[i]);
+ otherValue = methods[i].invoke(obj, (Object[])null);
+ }
+ catch (RuntimeException e) {
+ throw e;
+ }
+ catch (Exception e) {
+ throw new RuntimeException("Error retrieving value " + name + " for annotation " + annotation.getTypeName(), e);
+ }
+
+ if (value == null && otherValue != null)
+ return false;
+ if (value != null && value.equals(otherValue) == false)
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Calculates the hashCode of an array using the same
+ * algorithm as java.util.Arrays.hashCode()
+ *
+ * @param object the object
+ * @return the hashCode
+ */
+ private static int arrayHashCode(Object object)
+ {
+ if (object == null)
+ return 0;
+
+ int result = 1;
+
+ Object[] array = (Object[]) object;
+ for (int i = 0; i < array.length; ++i) {
+ int elementHashCode = 0;
+ if (array[i] != null)
+ elementHashCode = array[i].hashCode();
+ result = 31 * result + elementHashCode;
+ }
+ return result;
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/AnnotationMemberValue.java b/src/main/javassist/bytecode/annotation/AnnotationMemberValue.java
new file mode 100644
index 0000000..368c82a
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/AnnotationMemberValue.java
@@ -0,0 +1,95 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Nested annotation.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class AnnotationMemberValue extends MemberValue {
+ Annotation value;
+
+ /**
+ * Constructs an annotation member. The initial value is not specified.
+ */
+ public AnnotationMemberValue(ConstPool cp) {
+ this(null, cp);
+ }
+
+ /**
+ * Constructs an annotation member. The initial value is specified by
+ * the first parameter.
+ */
+ public AnnotationMemberValue(Annotation a, ConstPool cp) {
+ super('@', cp);
+ value = a;
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m)
+ throws ClassNotFoundException
+ {
+ return AnnotationImpl.make(cl, getType(cl), cp, value);
+ }
+
+ Class getType(ClassLoader cl) throws ClassNotFoundException {
+ if (value == null)
+ throw new ClassNotFoundException("no type specified");
+ else
+ return loadClass(cl, value.getTypeName());
+ }
+
+ /**
+ * Obtains the value.
+ */
+ public Annotation getValue() {
+ return value;
+ }
+
+ /**
+ * Sets the value of this member.
+ */
+ public void setValue(Annotation newValue) {
+ value = newValue;
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return value.toString();
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.annotationValue();
+ value.write(writer);
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitAnnotationMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/AnnotationsWriter.java b/src/main/javassist/bytecode/annotation/AnnotationsWriter.java
new file mode 100644
index 0000000..f435d8f
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/AnnotationsWriter.java
@@ -0,0 +1,353 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import java.io.*;
+
+import javassist.bytecode.ByteArray;
+import javassist.bytecode.ConstPool;
+
+/**
+ * A convenience class for constructing a
+ * <code>..Annotations_attribute</code>.
+ * See the source code of the <code>AnnotationsAttribute.Copier</code> class.
+ *
+ * <p>The following code snippet is an example of use of this class:
+ *
+ * <ul><pre>
+ * ConstPool pool = ...;
+ * output = new ByteArrayOutputStream();
+ * writer = new AnnotationsWriter(output, pool);
+ *
+ * writer.numAnnotations(1);
+ * writer.annotation("Author", 2);
+ * writer.memberValuePair("name");
+ * writer.constValueIndex("chiba");
+ * writer.memberValuePair("address");
+ * writer.constValueIndex("tokyo");
+ *
+ * writer.close();
+ * byte[] attribute_info = output.toByteArray();
+ * AnnotationsAttribute anno
+ * = new AnnotationsAttribute(pool, AnnotationsAttribute.visibleTag,
+ * attribute_info);
+ * </pre></ul>
+ *
+ * <p>The code snippet above generates the annotation attribute
+ * corresponding to this annotation:
+ *
+ * <ul><pre>
+ * @Author(name = "chiba", address = "tokyo")
+ * </pre></ul>
+ *
+ * @see javassist.bytecode.AnnotationsAttribute
+ * @see javassist.bytecode.ParameterAnnotationsAttribute
+ */
+public class AnnotationsWriter {
+ private OutputStream output;
+ private ConstPool pool;
+
+ /**
+ * Constructs with the given output stream.
+ *
+ * @param os the output stream.
+ * @param cp the constant pool.
+ */
+ public AnnotationsWriter(OutputStream os, ConstPool cp) {
+ output = os;
+ pool = cp;
+ }
+
+ /**
+ * Obtains the constant pool given to the constructor.
+ */
+ public ConstPool getConstPool() {
+ return pool;
+ }
+
+ /**
+ * Closes the output stream.
+ *
+ */
+ public void close() throws IOException {
+ output.close();
+ }
+
+ /**
+ * Writes <code>num_parameters</code> in
+ * <code>Runtime(In)VisibleParameterAnnotations_attribute</code>.
+ * This method must be followed by <code>num</code> calls to
+ * <code>numAnnotations()</code>.
+ */
+ public void numParameters(int num) throws IOException {
+ output.write(num);
+ }
+
+ /**
+ * Writes <code>num_annotations</code> in
+ * <code>Runtime(In)VisibleAnnotations_attribute</code>.
+ * This method must be followed by <code>num</code> calls to
+ * <code>annotation()</code>.
+ */
+ public void numAnnotations(int num) throws IOException {
+ write16bit(num);
+ }
+
+ /**
+ * Writes <code>annotation</code>.
+ * This method must be followed by <code>numMemberValuePairs</code>
+ * calls to <code>memberValuePair()</code>.
+ *
+ * @param type the annotation interface name.
+ * @param numMemberValuePairs <code>num_member_value_pairs</code>
+ * in <code>annotation</code>.
+ */
+ public void annotation(String type, int numMemberValuePairs)
+ throws IOException
+ {
+ annotation(pool.addUtf8Info(type), numMemberValuePairs);
+ }
+
+ /**
+ * Writes <code>annotation</code>.
+ * This method must be followed by <code>numMemberValuePairs</code>
+ * calls to <code>memberValuePair()</code>.
+ *
+ * @param typeIndex <code>type_index</code> in <code>annotation</code>.
+ * @param numMemberValuePairs <code>num_member_value_pairs</code>
+ * in <code>annotation</code>.
+ */
+ public void annotation(int typeIndex, int numMemberValuePairs)
+ throws IOException
+ {
+ write16bit(typeIndex);
+ write16bit(numMemberValuePairs);
+ }
+
+ /**
+ * Writes an element of a <code>member_value_pairs</code> array
+ * in <code>annotation</code>.
+ * This method must be followed by a
+ * call to <code>constValueIndex()</code>, <code>enumConstValue()</code>,
+ * etc.
+ *
+ * @param memberName the name of the annotation type member.
+ */
+ public void memberValuePair(String memberName) throws IOException {
+ memberValuePair(pool.addUtf8Info(memberName));
+ }
+
+ /**
+ * Writes an element of a <code>member_value_pairs</code> array
+ * in <code>annotation</code>.
+ * This method must be followed by a
+ * call to <code>constValueIndex()</code>, <code>enumConstValue()</code>,
+ * etc.
+ *
+ * @param memberNameIndex <code>member_name_index</code>
+ * in <code>member_value_pairs</code> array.
+ */
+ public void memberValuePair(int memberNameIndex) throws IOException {
+ write16bit(memberNameIndex);
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(boolean value) throws IOException {
+ constValueIndex('Z', pool.addIntegerInfo(value ? 1 : 0));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(byte value) throws IOException {
+ constValueIndex('B', pool.addIntegerInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(char value) throws IOException {
+ constValueIndex('C', pool.addIntegerInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(short value) throws IOException {
+ constValueIndex('S', pool.addIntegerInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(int value) throws IOException {
+ constValueIndex('I', pool.addIntegerInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(long value) throws IOException {
+ constValueIndex('J', pool.addLongInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(float value) throws IOException {
+ constValueIndex('F', pool.addFloatInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(double value) throws IOException {
+ constValueIndex('D', pool.addDoubleInfo(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param value the constant value.
+ */
+ public void constValueIndex(String value) throws IOException {
+ constValueIndex('s', pool.addUtf8Info(value));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>const_value_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param tag <code>tag</code> in <code>member_value</code>.
+ * @param index <code>const_value_index</code>
+ * in <code>member_value</code>.
+ */
+ public void constValueIndex(int tag, int index)
+ throws IOException
+ {
+ output.write(tag);
+ write16bit(index);
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>enum_const_value</code>
+ * in <code>member_value</code>.
+ *
+ * @param typeName the type name of the enum constant.
+ * @param constName the simple name of the enum constant.
+ */
+ public void enumConstValue(String typeName, String constName)
+ throws IOException
+ {
+ enumConstValue(pool.addUtf8Info(typeName),
+ pool.addUtf8Info(constName));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>enum_const_value</code>
+ * in <code>member_value</code>.
+ *
+ * @param typeNameIndex <code>type_name_index</code>
+ * in <code>member_value</code>.
+ * @param constNameIndex <code>const_name_index</code>
+ * in <code>member_value</code>.
+ */
+ public void enumConstValue(int typeNameIndex, int constNameIndex)
+ throws IOException
+ {
+ output.write('e');
+ write16bit(typeNameIndex);
+ write16bit(constNameIndex);
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>class_info_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param name the class name.
+ */
+ public void classInfoIndex(String name) throws IOException {
+ classInfoIndex(pool.addUtf8Info(name));
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>class_info_index</code>
+ * in <code>member_value</code>.
+ *
+ * @param index <code>class_info_index</code>
+ */
+ public void classInfoIndex(int index) throws IOException {
+ output.write('c');
+ write16bit(index);
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>annotation_value</code>
+ * in <code>member_value</code>.
+ * This method must be followed by a call to <code>annotation()</code>.
+ */
+ public void annotationValue() throws IOException {
+ output.write('@');
+ }
+
+ /**
+ * Writes <code>tag</code> and <code>array_value</code>
+ * in <code>member_value</code>.
+ * This method must be followed by <code>numValues</code> calls
+ * to <code>constValueIndex()</code>, <code>enumConstValue()</code>,
+ * etc.
+ *
+ * @param numValues <code>num_values</code>
+ * in <code>array_value</code>.
+ */
+ public void arrayValue(int numValues) throws IOException {
+ output.write('[');
+ write16bit(numValues);
+ }
+
+ private void write16bit(int value) throws IOException {
+ byte[] buf = new byte[2];
+ ByteArray.write16bit(value, buf, 0);
+ output.write(buf);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/ArrayMemberValue.java b/src/main/javassist/bytecode/annotation/ArrayMemberValue.java
new file mode 100644
index 0000000..75ffe13
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/ArrayMemberValue.java
@@ -0,0 +1,144 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+
+/**
+ * Array member.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class ArrayMemberValue extends MemberValue {
+ MemberValue type;
+ MemberValue[] values;
+
+ /**
+ * Constructs an array. The initial value or type are not specified.
+ */
+ public ArrayMemberValue(ConstPool cp) {
+ super('[', cp);
+ type = null;
+ values = null;
+ }
+
+ /**
+ * Constructs an array. The initial value is not specified.
+ *
+ * @param t the type of the array elements.
+ */
+ public ArrayMemberValue(MemberValue t, ConstPool cp) {
+ super('[', cp);
+ type = t;
+ values = null;
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method method)
+ throws ClassNotFoundException
+ {
+ if (values == null)
+ throw new ClassNotFoundException(
+ "no array elements found: " + method.getName());
+
+ int size = values.length;
+ Class clazz;
+ if (type == null) {
+ clazz = method.getReturnType().getComponentType();
+ if (clazz == null || size > 0)
+ throw new ClassNotFoundException("broken array type: "
+ + method.getName());
+ }
+ else
+ clazz = type.getType(cl);
+
+ Object a = Array.newInstance(clazz, size);
+ for (int i = 0; i < size; i++)
+ Array.set(a, i, values[i].getValue(cl, cp, method));
+
+ return a;
+ }
+
+ Class getType(ClassLoader cl) throws ClassNotFoundException {
+ if (type == null)
+ throw new ClassNotFoundException("no array type specified");
+
+ Object a = Array.newInstance(type.getType(cl), 0);
+ return a.getClass();
+ }
+
+ /**
+ * Obtains the type of the elements.
+ *
+ * @return null if the type is not specified.
+ */
+ public MemberValue getType() {
+ return type;
+ }
+
+ /**
+ * Obtains the elements of the array.
+ */
+ public MemberValue[] getValue() {
+ return values;
+ }
+
+ /**
+ * Sets the elements of the array.
+ */
+ public void setValue(MemberValue[] elements) {
+ values = elements;
+ if (elements != null && elements.length > 0)
+ type = elements[0];
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ StringBuffer buf = new StringBuffer("{");
+ if (values != null) {
+ for (int i = 0; i < values.length; i++) {
+ buf.append(values[i].toString());
+ if (i + 1 < values.length)
+ buf.append(", ");
+ }
+ }
+
+ buf.append("}");
+ return buf.toString();
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ int num = values.length;
+ writer.arrayValue(num);
+ for (int i = 0; i < num; ++i)
+ values[i].write(writer);
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitArrayMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/BooleanMemberValue.java b/src/main/javassist/bytecode/annotation/BooleanMemberValue.java
new file mode 100644
index 0000000..29432b1
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/BooleanMemberValue.java
@@ -0,0 +1,102 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Boolean constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class BooleanMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a boolean constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Integer_info structure.
+ */
+ public BooleanMemberValue(int index, ConstPool cp) {
+ super('Z', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a boolean constant value.
+ *
+ * @param b the initial value.
+ */
+ public BooleanMemberValue(boolean b, ConstPool cp) {
+ super('Z', cp);
+ setValue(b);
+ }
+
+ /**
+ * Constructs a boolean constant value. The initial value is false.
+ */
+ public BooleanMemberValue(ConstPool cp) {
+ super('Z', cp);
+ setValue(false);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Boolean(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return boolean.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public boolean getValue() {
+ return cp.getIntegerInfo(valueIndex) != 0;
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(boolean newValue) {
+ valueIndex = cp.addIntegerInfo(newValue ? 1 : 0);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return getValue() ? "true" : "false";
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitBooleanMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/ByteMemberValue.java b/src/main/javassist/bytecode/annotation/ByteMemberValue.java
new file mode 100644
index 0000000..90763b0
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/ByteMemberValue.java
@@ -0,0 +1,102 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Byte constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class ByteMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a byte constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Integer_info structure.
+ */
+ public ByteMemberValue(int index, ConstPool cp) {
+ super('B', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a byte constant value.
+ *
+ * @param b the initial value.
+ */
+ public ByteMemberValue(byte b, ConstPool cp) {
+ super('B', cp);
+ setValue(b);
+ }
+
+ /**
+ * Constructs a byte constant value. The initial value is 0.
+ */
+ public ByteMemberValue(ConstPool cp) {
+ super('B', cp);
+ setValue((byte)0);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Byte(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return byte.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public byte getValue() {
+ return (byte)cp.getIntegerInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(byte newValue) {
+ valueIndex = cp.addIntegerInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Byte.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitByteMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/CharMemberValue.java b/src/main/javassist/bytecode/annotation/CharMemberValue.java
new file mode 100644
index 0000000..f6691df
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/CharMemberValue.java
@@ -0,0 +1,103 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Char constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class CharMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a char constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Integer_info structure.
+ */
+ public CharMemberValue(int index, ConstPool cp) {
+ super('C', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a char constant value.
+ *
+ * @param c the initial value.
+ */
+ public CharMemberValue(char c, ConstPool cp) {
+ super('C', cp);
+ setValue(c);
+ }
+
+ /**
+ * Constructs a char constant value. The initial value is '\0'.
+ */
+ public CharMemberValue(ConstPool cp) {
+ super('C', cp);
+ setValue('\0');
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Character(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return char.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public char getValue() {
+ return (char)cp.getIntegerInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(char newValue) {
+ valueIndex = cp.addIntegerInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Character.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitCharMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/ClassMemberValue.java b/src/main/javassist/bytecode/annotation/ClassMemberValue.java
new file mode 100644
index 0000000..c29dbb2
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/ClassMemberValue.java
@@ -0,0 +1,132 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Class value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class ClassMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a class value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Utf8_info structure.
+ */
+ public ClassMemberValue(int index, ConstPool cp) {
+ super('c', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a class value.
+ *
+ * @param className the initial value.
+ */
+ public ClassMemberValue(String className, ConstPool cp) {
+ super('c', cp);
+ setValue(className);
+ }
+
+ /**
+ * Constructs a class value.
+ * The initial value is java.lang.Class.
+ */
+ public ClassMemberValue(ConstPool cp) {
+ super('c', cp);
+ setValue("java.lang.Class");
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m)
+ throws ClassNotFoundException {
+ final String classname = getValue();
+ if (classname.equals("void"))
+ return void.class;
+ else if (classname.equals("int"))
+ return int.class;
+ else if (classname.equals("byte"))
+ return byte.class;
+ else if (classname.equals("long"))
+ return long.class;
+ else if (classname.equals("double"))
+ return double.class;
+ else if (classname.equals("float"))
+ return float.class;
+ else if (classname.equals("char"))
+ return char.class;
+ else if (classname.equals("short"))
+ return short.class;
+ else if (classname.equals("boolean"))
+ return boolean.class;
+ else
+ return loadClass(cl, classname);
+ }
+
+ Class getType(ClassLoader cl) throws ClassNotFoundException {
+ return loadClass(cl, "java.lang.Class");
+ }
+
+ /**
+ * Obtains the value of the member.
+ *
+ * @return fully-qualified class name.
+ */
+ public String getValue() {
+ String v = cp.getUtf8Info(valueIndex);
+ return Descriptor.toClassName(v);
+ }
+
+ /**
+ * Sets the value of the member.
+ *
+ * @param newClassName fully-qualified class name.
+ */
+ public void setValue(String newClassName) {
+ String setTo = Descriptor.of(newClassName);
+ valueIndex = cp.addUtf8Info(setTo);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return "<" + getValue() + " class>";
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.classInfoIndex(cp.getUtf8Info(valueIndex));
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitClassMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/DoubleMemberValue.java b/src/main/javassist/bytecode/annotation/DoubleMemberValue.java
new file mode 100644
index 0000000..f2825ad
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/DoubleMemberValue.java
@@ -0,0 +1,104 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Double floating-point number constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ * @version $Revision: 1.7 $
+ */
+public class DoubleMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a double constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Double_info structure.
+ */
+ public DoubleMemberValue(int index, ConstPool cp) {
+ super('D', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a double constant value.
+ *
+ * @param d the initial value.
+ */
+ public DoubleMemberValue(double d, ConstPool cp) {
+ super('D', cp);
+ setValue(d);
+ }
+
+ /**
+ * Constructs a double constant value. The initial value is 0.0.
+ */
+ public DoubleMemberValue(ConstPool cp) {
+ super('D', cp);
+ setValue(0.0);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Double(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return double.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public double getValue() {
+ return cp.getDoubleInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(double newValue) {
+ valueIndex = cp.addDoubleInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Double.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitDoubleMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/EnumMemberValue.java b/src/main/javassist/bytecode/annotation/EnumMemberValue.java
new file mode 100644
index 0000000..effec09
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/EnumMemberValue.java
@@ -0,0 +1,125 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+
+/**
+ * Enum constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class EnumMemberValue extends MemberValue {
+ int typeIndex, valueIndex;
+
+ /**
+ * Constructs an enum constant value. The initial value is specified
+ * by the constant pool entries at the given indexes.
+ *
+ * @param type the index of a CONSTANT_Utf8_info structure
+ * representing the enum type.
+ * @param value the index of a CONSTANT_Utf8_info structure.
+ * representing the enum value.
+ */
+ public EnumMemberValue(int type, int value, ConstPool cp) {
+ super('e', cp);
+ this.typeIndex = type;
+ this.valueIndex = value;
+ }
+
+ /**
+ * Constructs an enum constant value.
+ * The initial value is not specified.
+ */
+ public EnumMemberValue(ConstPool cp) {
+ super('e', cp);
+ typeIndex = valueIndex = 0;
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m)
+ throws ClassNotFoundException
+ {
+ try {
+ return getType(cl).getField(getValue()).get(null);
+ }
+ catch (NoSuchFieldException e) {
+ throw new ClassNotFoundException(getType() + "." + getValue());
+ }
+ catch (IllegalAccessException e) {
+ throw new ClassNotFoundException(getType() + "." + getValue());
+ }
+ }
+
+ Class getType(ClassLoader cl) throws ClassNotFoundException {
+ return loadClass(cl, getType());
+ }
+
+ /**
+ * Obtains the enum type name.
+ *
+ * @return a fully-qualified type name.
+ */
+ public String getType() {
+ return Descriptor.toClassName(cp.getUtf8Info(typeIndex));
+ }
+
+ /**
+ * Changes the enum type name.
+ *
+ * @param typename a fully-qualified type name.
+ */
+ public void setType(String typename) {
+ typeIndex = cp.addUtf8Info(Descriptor.of(typename));
+ }
+
+ /**
+ * Obtains the name of the enum constant value.
+ */
+ public String getValue() {
+ return cp.getUtf8Info(valueIndex);
+ }
+
+ /**
+ * Changes the name of the enum constant value.
+ */
+ public void setValue(String name) {
+ valueIndex = cp.addUtf8Info(name);
+ }
+
+ public String toString() {
+ return getType() + "." + getValue();
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.enumConstValue(cp.getUtf8Info(typeIndex), getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitEnumMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/FloatMemberValue.java b/src/main/javassist/bytecode/annotation/FloatMemberValue.java
new file mode 100644
index 0000000..7188b5e
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/FloatMemberValue.java
@@ -0,0 +1,104 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Floating-point number constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ * @version $Revision: 1.7 $
+ */
+public class FloatMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a float constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Float_info structure.
+ */
+ public FloatMemberValue(int index, ConstPool cp) {
+ super('F', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a float constant value.
+ *
+ * @param f the initial value.
+ */
+ public FloatMemberValue(float f, ConstPool cp) {
+ super('F', cp);
+ setValue(f);
+ }
+
+ /**
+ * Constructs a float constant value. The initial value is 0.0.
+ */
+ public FloatMemberValue(ConstPool cp) {
+ super('F', cp);
+ setValue(0.0F);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Float(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return float.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public float getValue() {
+ return cp.getFloatInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(float newValue) {
+ valueIndex = cp.addFloatInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Float.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitFloatMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/IntegerMemberValue.java b/src/main/javassist/bytecode/annotation/IntegerMemberValue.java
new file mode 100644
index 0000000..2f2a907
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/IntegerMemberValue.java
@@ -0,0 +1,109 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Integer constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class IntegerMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs an int constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Integer_info structure.
+ */
+ public IntegerMemberValue(int index, ConstPool cp) {
+ super('I', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs an int constant value.
+ * Note that this constructor receives <b>the initial value
+ * as the second parameter</b>
+ * unlike the corresponding constructors in the sibling classes.
+ * This is for making a difference from the constructor that receives
+ * an index into the constant pool table as the first parameter.
+ * Note that the index is also int type.
+ *
+ * @param value the initial value.
+ */
+ public IntegerMemberValue(ConstPool cp, int value) {
+ super('I', cp);
+ setValue(value);
+ }
+
+ /**
+ * Constructs an int constant value. The initial value is 0.
+ */
+ public IntegerMemberValue(ConstPool cp) {
+ super('I', cp);
+ setValue(0);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Integer(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return int.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public int getValue() {
+ return cp.getIntegerInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(int newValue) {
+ valueIndex = cp.addIntegerInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Integer.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitIntegerMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/LongMemberValue.java b/src/main/javassist/bytecode/annotation/LongMemberValue.java
new file mode 100644
index 0000000..2afd4a0
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/LongMemberValue.java
@@ -0,0 +1,103 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Long integer constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class LongMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a long constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Long_info structure.
+ */
+ public LongMemberValue(int index, ConstPool cp) {
+ super('J', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a long constant value.
+ *
+ * @param j the initial value.
+ */
+ public LongMemberValue(long j, ConstPool cp) {
+ super('J', cp);
+ setValue(j);
+ }
+
+ /**
+ * Constructs a long constant value. The initial value is 0.
+ */
+ public LongMemberValue(ConstPool cp) {
+ super('J', cp);
+ setValue(0L);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Long(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return long.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public long getValue() {
+ return cp.getLongInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(long newValue) {
+ valueIndex = cp.addLongInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Long.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitLongMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/MemberValue.java b/src/main/javassist/bytecode/annotation/MemberValue.java
new file mode 100644
index 0000000..18796ee
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/MemberValue.java
@@ -0,0 +1,88 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+
+/**
+ * The value of a member declared in an annotation.
+ *
+ * @see Annotation#getMemberValue(String)
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public abstract class MemberValue {
+ ConstPool cp;
+ char tag;
+
+ MemberValue(char tag, ConstPool cp) {
+ this.cp = cp;
+ this.tag = tag;
+ }
+
+ /**
+ * Returns the value. If the value type is a primitive type, the
+ * returned value is boxed.
+ */
+ abstract Object getValue(ClassLoader cl, ClassPool cp, Method m)
+ throws ClassNotFoundException;
+
+ abstract Class getType(ClassLoader cl) throws ClassNotFoundException;
+
+ static Class loadClass(ClassLoader cl, String classname)
+ throws ClassNotFoundException, NoSuchClassError
+ {
+ try {
+ return Class.forName(convertFromArray(classname), true, cl);
+ }
+ catch (LinkageError e) {
+ throw new NoSuchClassError(classname, e);
+ }
+ }
+
+ private static String convertFromArray(String classname)
+ {
+ int index = classname.indexOf("[]");
+ if (index != -1) {
+ String rawType = classname.substring(0, index);
+ StringBuffer sb = new StringBuffer(Descriptor.of(rawType));
+ while (index != -1) {
+ sb.insert(0, "[");
+ index = classname.indexOf("[]", index + 1);
+ }
+ return sb.toString().replace('/', '.');
+ }
+ return classname;
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public abstract void accept(MemberValueVisitor visitor);
+
+ /**
+ * Writes the value.
+ */
+ public abstract void write(AnnotationsWriter w) throws IOException;
+}
+
+
diff --git a/src/main/javassist/bytecode/annotation/MemberValueVisitor.java b/src/main/javassist/bytecode/annotation/MemberValueVisitor.java
new file mode 100644
index 0000000..6944bd0
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/MemberValueVisitor.java
@@ -0,0 +1,38 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+/**
+ * Visitor for traversing member values included in an annotation.
+ *
+ * @see MemberValue#accept(MemberValueVisitor)
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ */
+public interface MemberValueVisitor {
+ public void visitAnnotationMemberValue(AnnotationMemberValue node);
+ public void visitArrayMemberValue(ArrayMemberValue node);
+ public void visitBooleanMemberValue(BooleanMemberValue node);
+ public void visitByteMemberValue(ByteMemberValue node);
+ public void visitCharMemberValue(CharMemberValue node);
+ public void visitDoubleMemberValue(DoubleMemberValue node);
+ public void visitEnumMemberValue(EnumMemberValue node);
+ public void visitFloatMemberValue(FloatMemberValue node);
+ public void visitIntegerMemberValue(IntegerMemberValue node);
+ public void visitLongMemberValue(LongMemberValue node);
+ public void visitShortMemberValue(ShortMemberValue node);
+ public void visitStringMemberValue(StringMemberValue node);
+ public void visitClassMemberValue(ClassMemberValue node);
+}
diff --git a/src/main/javassist/bytecode/annotation/NoSuchClassError.java b/src/main/javassist/bytecode/annotation/NoSuchClassError.java
new file mode 100644
index 0000000..c6d1a12
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/NoSuchClassError.java
@@ -0,0 +1,39 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2009 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+/**
+ * Thrown if the linkage fails.
+ * It keeps the name of the class that caused this error.
+ */
+public class NoSuchClassError extends Error {
+ private String className;
+
+ /**
+ * Constructs an exception.
+ */
+ public NoSuchClassError(String className, Error cause) {
+ super(cause.toString(), cause);
+ this.className = className;
+ }
+
+ /**
+ * Returns the name of the class not found.
+ */
+ public String getClassName() {
+ return className;
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/ShortMemberValue.java b/src/main/javassist/bytecode/annotation/ShortMemberValue.java
new file mode 100644
index 0000000..3ccf380
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/ShortMemberValue.java
@@ -0,0 +1,103 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * Short integer constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class ShortMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a short constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Integer_info structure.
+ */
+ public ShortMemberValue(int index, ConstPool cp) {
+ super('S', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a short constant value.
+ *
+ * @param s the initial value.
+ */
+ public ShortMemberValue(short s, ConstPool cp) {
+ super('S', cp);
+ setValue(s);
+ }
+
+ /**
+ * Constructs a short constant value. The initial value is 0.
+ */
+ public ShortMemberValue(ConstPool cp) {
+ super('S', cp);
+ setValue((short)0);
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return new Short(getValue());
+ }
+
+ Class getType(ClassLoader cl) {
+ return short.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public short getValue() {
+ return (short)cp.getIntegerInfo(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(short newValue) {
+ valueIndex = cp.addIntegerInfo(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return Short.toString(getValue());
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitShortMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/StringMemberValue.java b/src/main/javassist/bytecode/annotation/StringMemberValue.java
new file mode 100644
index 0000000..970fb8f
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/StringMemberValue.java
@@ -0,0 +1,103 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 2004 Bill Burke. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.annotation;
+
+import javassist.ClassPool;
+import javassist.bytecode.ConstPool;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+/**
+ * String constant value.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author Shigeru Chiba
+ */
+public class StringMemberValue extends MemberValue {
+ int valueIndex;
+
+ /**
+ * Constructs a string constant value. The initial value is specified
+ * by the constant pool entry at the given index.
+ *
+ * @param index the index of a CONSTANT_Utf8_info structure.
+ */
+ public StringMemberValue(int index, ConstPool cp) {
+ super('s', cp);
+ this.valueIndex = index;
+ }
+
+ /**
+ * Constructs a string constant value.
+ *
+ * @param str the initial value.
+ */
+ public StringMemberValue(String str, ConstPool cp) {
+ super('s', cp);
+ setValue(str);
+ }
+
+ /**
+ * Constructs a string constant value. The initial value is "".
+ */
+ public StringMemberValue(ConstPool cp) {
+ super('s', cp);
+ setValue("");
+ }
+
+ Object getValue(ClassLoader cl, ClassPool cp, Method m) {
+ return getValue();
+ }
+
+ Class getType(ClassLoader cl) {
+ return String.class;
+ }
+
+ /**
+ * Obtains the value of the member.
+ */
+ public String getValue() {
+ return cp.getUtf8Info(valueIndex);
+ }
+
+ /**
+ * Sets the value of the member.
+ */
+ public void setValue(String newValue) {
+ valueIndex = cp.addUtf8Info(newValue);
+ }
+
+ /**
+ * Obtains the string representation of this object.
+ */
+ public String toString() {
+ return "\"" + getValue() + "\"";
+ }
+
+ /**
+ * Writes the value.
+ */
+ public void write(AnnotationsWriter writer) throws IOException {
+ writer.constValueIndex(getValue());
+ }
+
+ /**
+ * Accepts a visitor.
+ */
+ public void accept(MemberValueVisitor visitor) {
+ visitor.visitStringMemberValue(this);
+ }
+}
diff --git a/src/main/javassist/bytecode/annotation/package.html b/src/main/javassist/bytecode/annotation/package.html
new file mode 100644
index 0000000..d0656db
--- /dev/null
+++ b/src/main/javassist/bytecode/annotation/package.html
@@ -0,0 +1,8 @@
+<html>
+<body>
+Bytecode-level Annotations API.
+
+<p>This package provides low-level API for editing annotations attributes.
+
+</body>
+</html>
diff --git a/src/main/javassist/bytecode/package.html b/src/main/javassist/bytecode/package.html
new file mode 100644
index 0000000..9da3888
--- /dev/null
+++ b/src/main/javassist/bytecode/package.html
@@ -0,0 +1,18 @@
+<html>
+<body>
+Bytecode-level API.
+
+<p>This package provides low-level API for editing a raw class file.
+It allows the users to read and modify a constant pool entry, a single
+bytecode instruction, and so on.
+
+<p>The users of this package must know the specifications of
+class file and Java bytecode. For more details, read this book:
+
+<ul>Tim Lindholm and Frank Yellin,
+"The Java Virtual Machine Specification 2nd Ed.",
+Addison-Wesley, 1999.
+</ul>
+
+</body>
+</html>
diff --git a/src/main/javassist/bytecode/stackmap/BasicBlock.java b/src/main/javassist/bytecode/stackmap/BasicBlock.java
new file mode 100644
index 0000000..e5b64d3
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/BasicBlock.java
@@ -0,0 +1,398 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.bytecode.*;
+import java.util.HashMap;
+import java.util.ArrayList;
+
+/**
+ * A basic block is a sequence of bytecode that does not contain jump/branch
+ * instructions except at the last bytecode.
+ * Since Java6 or later does not allow JSR, this class deals with JSR as a
+ * non-branch instruction.
+ */
+public class BasicBlock {
+ public int position, length;
+ public int incoming; // the number of incoming branches.
+ public BasicBlock[] exit; // null if the block is a leaf.
+ public boolean stop; // true if the block ends with an unconditional jump.
+ public Catch toCatch;
+
+ protected BasicBlock(int pos) {
+ position = pos;
+ length = 0;
+ incoming = 0;
+ }
+
+ public static BasicBlock find(BasicBlock[] blocks, int pos)
+ throws BadBytecode
+ {
+ for (int i = 0; i < blocks.length; i++) {
+ int iPos = blocks[i].position;
+ if (iPos <= pos && pos < iPos + blocks[i].length)
+ return blocks[i];
+ }
+
+ throw new BadBytecode("no basic block at " + pos);
+ }
+
+ public static class Catch {
+ Catch next;
+ BasicBlock body;
+ int typeIndex;
+ Catch(BasicBlock b, int i, Catch c) {
+ body = b;
+ typeIndex = i;
+ next = c;
+ }
+ }
+
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+ String cname = this.getClass().getName();
+ int i = cname.lastIndexOf('.');
+ sbuf.append(i < 0 ? cname : cname.substring(i + 1));
+ sbuf.append("[");
+ toString2(sbuf);
+ sbuf.append("]");
+ return sbuf.toString();
+ }
+
+ protected void toString2(StringBuffer sbuf) {
+ sbuf.append("pos=").append(position).append(", len=")
+ .append(length).append(", in=").append(incoming)
+ .append(", exit{");
+ if (exit != null) {
+ for (int i = 0; i < exit.length; i++)
+ sbuf.append(exit[i].position).append(", ");
+ }
+
+ sbuf.append("}, {");
+ Catch th = toCatch;
+ while (th != null) {
+ sbuf.append("(").append(th.body.position).append(", ")
+ .append(th.typeIndex).append("), ");
+ th = th.next;
+ }
+
+ sbuf.append("}");
+ }
+
+ static class Mark implements Comparable {
+ int position;
+ BasicBlock block;
+ BasicBlock[] jump;
+ boolean alwaysJmp; // true if a unconditional branch.
+ int size; // 0 unless the mark indicates RETURN etc.
+ Catch catcher;
+
+ Mark(int p) {
+ position = p;
+ block = null;
+ jump = null;
+ alwaysJmp = false;
+ size = 0;
+ catcher = null;
+ }
+
+ public int compareTo(Object obj) {
+ if (obj instanceof Mark) {
+ int pos = ((Mark)obj).position;
+ return position - pos;
+ }
+
+ return -1;
+ }
+
+ void setJump(BasicBlock[] bb, int s, boolean always) {
+ jump = bb;
+ size = s;
+ alwaysJmp = always;
+ }
+ }
+
+ public static class Maker {
+ /* Override these two methods if a subclass of BasicBlock must be
+ * instantiated.
+ */
+ protected BasicBlock makeBlock(int pos) {
+ return new BasicBlock(pos);
+ }
+
+ protected BasicBlock[] makeArray(int size) {
+ return new BasicBlock[size];
+ }
+
+ private BasicBlock[] makeArray(BasicBlock b) {
+ BasicBlock[] array = makeArray(1);
+ array[0] = b;
+ return array;
+ }
+
+ private BasicBlock[] makeArray(BasicBlock b1, BasicBlock b2) {
+ BasicBlock[] array = makeArray(2);
+ array[0] = b1;
+ array[1] = b2;
+ return array;
+ }
+
+ public BasicBlock[] make(MethodInfo minfo) throws BadBytecode {
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca == null)
+ return null;
+
+ CodeIterator ci = ca.iterator();
+ return make(ci, 0, ci.getCodeLength(), ca.getExceptionTable());
+ }
+
+ public BasicBlock[] make(CodeIterator ci, int begin, int end,
+ ExceptionTable et)
+ throws BadBytecode
+ {
+ HashMap marks = makeMarks(ci, begin, end, et);
+ BasicBlock[] bb = makeBlocks(marks);
+ addCatchers(bb, et);
+ return bb;
+ }
+
+ /* Branch target
+ */
+ private Mark makeMark(HashMap table, int pos) {
+ return makeMark0(table, pos, true, true);
+ }
+
+ /* Branch instruction.
+ * size > 0
+ */
+ private Mark makeMark(HashMap table, int pos, BasicBlock[] jump,
+ int size, boolean always) {
+ Mark m = makeMark0(table, pos, false, false);
+ m.setJump(jump, size, always);
+ return m;
+ }
+
+ private Mark makeMark0(HashMap table, int pos,
+ boolean isBlockBegin, boolean isTarget) {
+ Integer p = new Integer(pos);
+ Mark m = (Mark)table.get(p);
+ if (m == null) {
+ m = new Mark(pos);
+ table.put(p, m);
+ }
+
+ if (isBlockBegin) {
+ if (m.block == null)
+ m.block = makeBlock(pos);
+
+ if (isTarget)
+ m.block.incoming++;
+ }
+
+ return m;
+ }
+
+ private HashMap makeMarks(CodeIterator ci, int begin, int end,
+ ExceptionTable et)
+ throws BadBytecode
+ {
+ ci.begin();
+ ci.move(begin);
+ HashMap marks = new HashMap();
+ while (ci.hasNext()) {
+ int index = ci.next();
+ if (index >= end)
+ break;
+
+ int op = ci.byteAt(index);
+ if ((Opcode.IFEQ <= op && op <= Opcode.IF_ACMPNE)
+ || op == Opcode.IFNULL || op == Opcode.IFNONNULL) {
+ Mark to = makeMark(marks, index + ci.s16bitAt(index + 1));
+ Mark next = makeMark(marks, index + 3);
+ makeMark(marks, index, makeArray(to.block, next.block), 3, false);
+ }
+ else if (Opcode.GOTO <= op && op <= Opcode.LOOKUPSWITCH)
+ switch (op) {
+ case Opcode.GOTO :
+ makeGoto(marks, index, index + ci.s16bitAt(index + 1), 3);
+ break;
+ case Opcode.JSR :
+ makeJsr(marks, index, index + ci.s16bitAt(index + 1), 3);
+ break;
+ case Opcode.RET :
+ makeMark(marks, index, null, 2, true);
+ break;
+ case Opcode.TABLESWITCH : {
+ int pos = (index & ~3) + 4;
+ int low = ci.s32bitAt(pos + 4);
+ int high = ci.s32bitAt(pos + 8);
+ int ncases = high - low + 1;
+ BasicBlock[] to = makeArray(ncases + 1);
+ to[0] = makeMark(marks, index + ci.s32bitAt(pos)).block; // default branch target
+ int p = pos + 12;
+ int n = p + ncases * 4;
+ int k = 1;
+ while (p < n) {
+ to[k++] = makeMark(marks, index + ci.s32bitAt(p)).block;
+ p += 4;
+ }
+ makeMark(marks, index, to, n - index, true);
+ break; }
+ case Opcode.LOOKUPSWITCH : {
+ int pos = (index & ~3) + 4;
+ int ncases = ci.s32bitAt(pos + 4);
+ BasicBlock[] to = makeArray(ncases + 1);
+ to[0] = makeMark(marks, index + ci.s32bitAt(pos)).block; // default branch target
+ int p = pos + 8 + 4;
+ int n = p + ncases * 8 - 4;
+ int k = 1;
+ while (p < n) {
+ to[k++] = makeMark(marks, index + ci.s32bitAt(p)).block;
+ p += 8;
+ }
+ makeMark(marks, index, to, n - index, true);
+ break; }
+ }
+ else if ((Opcode.IRETURN <= op && op <= Opcode.RETURN) || op == Opcode.ATHROW)
+ makeMark(marks, index, null, 1, true);
+ else if (op == Opcode.GOTO_W)
+ makeGoto(marks, index, index + ci.s32bitAt(index + 1), 5);
+ else if (op == Opcode.JSR_W)
+ makeJsr(marks, index, index + ci.s32bitAt(index + 1), 5);
+ else if (op == Opcode.WIDE && ci.byteAt(index + 1) == Opcode.RET)
+ makeMark(marks, index, null, 1, true);
+ }
+
+ if (et != null) {
+ int i = et.size();
+ while (--i >= 0) {
+ makeMark0(marks, et.startPc(i), true, false);
+ makeMark(marks, et.handlerPc(i));
+ }
+ }
+
+ return marks;
+ }
+
+ private void makeGoto(HashMap marks, int pos, int target, int size) {
+ Mark to = makeMark(marks, target);
+ BasicBlock[] jumps = makeArray(to.block);
+ makeMark(marks, pos, jumps, size, true);
+ }
+
+ /**
+ * We ignore JSR since Java 6 or later does not allow it.
+ */
+ protected void makeJsr(HashMap marks, int pos, int target, int size) {
+ /*
+ Mark to = makeMark(marks, target);
+ Mark next = makeMark(marks, pos + size);
+ BasicBlock[] jumps = makeArray(to.block, next.block);
+ makeMark(marks, pos, jumps, size, false);
+ */
+ }
+
+ private BasicBlock[] makeBlocks(HashMap markTable) {
+ Mark[] marks = (Mark[])markTable.values()
+ .toArray(new Mark[markTable.size()]);
+ java.util.Arrays.sort(marks);
+ ArrayList blocks = new ArrayList();
+ int i = 0;
+ BasicBlock prev;
+ if (marks.length > 0 && marks[0].position == 0 && marks[0].block != null)
+ prev = getBBlock(marks[i++]);
+ else
+ prev = makeBlock(0);
+
+ blocks.add(prev);
+ while (i < marks.length) {
+ Mark m = marks[i++];
+ BasicBlock bb = getBBlock(m);
+ if (bb == null) {
+ // the mark indicates a branch instruction
+ if (prev.length > 0) {
+ // the previous mark already has exits.
+ prev = makeBlock(prev.position + prev.length);
+ blocks.add(prev);
+ }
+
+ prev.length = m.position + m.size - prev.position;
+ prev.exit = m.jump;
+ prev.stop = m.alwaysJmp;
+ }
+ else {
+ // the mark indicates a branch target
+ if (prev.length == 0) {
+ prev.length = m.position - prev.position;
+ bb.incoming++;
+ prev.exit = makeArray(bb);
+ }
+ else {
+ // the previous mark already has exits.
+ int prevPos = prev.position;
+ if (prevPos + prev.length < m.position) {
+ prev = makeBlock(prevPos + prev.length);
+ prev.length = m.position - prevPos;
+ // the incoming flow from dead code is not counted
+ // bb.incoming++;
+ prev.exit = makeArray(bb);
+ }
+ }
+
+ blocks.add(bb);
+ prev = bb;
+ }
+ }
+
+ return (BasicBlock[])blocks.toArray(makeArray(blocks.size()));
+ }
+
+ private static BasicBlock getBBlock(Mark m) {
+ BasicBlock b = m.block;
+ if (b != null && m.size > 0) {
+ b.exit = m.jump;
+ b.length = m.size;
+ b.stop = m.alwaysJmp;
+ }
+
+ return b;
+ }
+
+ private void addCatchers(BasicBlock[] blocks, ExceptionTable et)
+ throws BadBytecode
+ {
+ if (et == null)
+ return;
+
+ int i = et.size();
+ while (--i >= 0) {
+ BasicBlock handler = find(blocks, et.handlerPc(i));
+ int start = et.startPc(i);
+ int end = et.endPc(i);
+ int type = et.catchType(i);
+ handler.incoming--;
+ for (int k = 0; k < blocks.length; k++) {
+ BasicBlock bb = blocks[k];
+ int iPos = bb.position;
+ if (start <= iPos && iPos < end) {
+ bb.toCatch = new Catch(handler, type, bb.toCatch);
+ handler.incoming++;
+ }
+ }
+ }
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/stackmap/Liveness.java b/src/main/javassist/bytecode/stackmap/Liveness.java
new file mode 100644
index 0000000..4acd65e
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/Liveness.java
@@ -0,0 +1,365 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+ package javassist.bytecode.stackmap;
+
+import javassist.bytecode.*;
+
+public class Liveness {
+ protected static final byte UNKNOWN = 0;
+ protected static final byte READ = 1;
+ protected static final byte UPDATED = 2;
+ protected byte[] localsUsage;
+
+ /**
+ * If true, all the arguments become alive within the whole method body.
+ *
+ * To correctly compute a stack map table, all the arguments must
+ * be alive (localsUsage[?] must be READ) at least in the first block.
+ */
+ public static boolean useArgs = true;
+
+ public void compute(CodeIterator ci, TypedBlock[] blocks, int maxLocals,
+ TypeData[] args)
+ throws BadBytecode
+ {
+ computeUsage(ci, blocks, maxLocals);
+ if (useArgs)
+ useAllArgs(blocks, args);
+
+ computeLiveness1(blocks[0]);
+ while (hasChanged(blocks))
+ computeLiveness2(blocks[0]);
+ }
+
+ private void useAllArgs(TypedBlock[] blocks, TypeData[] args) {
+ for (int k = 0; k < blocks.length; k++) {
+ byte[] usage = blocks[k].localsUsage;
+ for (int i = 0; i < args.length; i++)
+ if (args[i] != TypeTag.TOP)
+ usage[i] = READ;
+ }
+ }
+
+ static final int NOT_YET = 0;
+ static final int CHANGED_LAST = 1;
+ static final int DONE = 2;
+ static final int CHANGED_NOW = 3;
+
+ private void computeLiveness1(TypedBlock tb) {
+ if (tb.updating) {
+ // a loop was detected.
+ computeLiveness1u(tb);
+ return;
+ }
+
+ if (tb.inputs != null)
+ return;
+
+ tb.updating = true;
+ byte[] usage = tb.localsUsage;
+ int n = usage.length;
+ boolean[] in = new boolean[n];
+ for (int i = 0; i < n; i++)
+ in[i] = usage[i] == READ;
+
+ BasicBlock.Catch handlers = tb.toCatch;
+ while (handlers != null) {
+ TypedBlock h = (TypedBlock)handlers.body;
+ computeLiveness1(h);
+ for (int k = 0; k < n; k++)
+ if (h.inputs[k])
+ in[k] = true;
+
+ handlers = handlers.next;
+ }
+
+ if (tb.exit != null) {
+ for (int i = 0; i < tb.exit.length; i++) {
+ TypedBlock e = (TypedBlock)tb.exit[i];
+ computeLiveness1(e);
+ for (int k = 0; k < n; k++)
+ if (!in[k])
+ in[k] = usage[k] == UNKNOWN && e.inputs[k];
+ }
+ }
+
+ tb.updating = false;
+ if (tb.inputs == null) {
+ tb.inputs = in;
+ tb.status = DONE;
+ }
+ else {
+ for (int i = 0; i < n; i++)
+ if (in[i] && !tb.inputs[i]) {
+ tb.inputs[i] = true;
+ tb.status = CHANGED_NOW;
+ }
+ }
+ }
+
+ private void computeLiveness1u(TypedBlock tb) {
+ if (tb.inputs == null) {
+ byte[] usage = tb.localsUsage;
+ int n = usage.length;
+ boolean[] in = new boolean[n];
+ for (int i = 0; i < n; i++)
+ in[i] = usage[i] == READ;
+
+ tb.inputs = in;
+ tb.status = DONE;
+ }
+ }
+
+ private void computeLiveness2(TypedBlock tb) {
+ if (tb.updating || tb.status >= DONE)
+ return;
+
+ tb.updating = true;
+ if (tb.exit == null)
+ tb.status = DONE;
+ else {
+ boolean changed = false;
+ for (int i = 0; i < tb.exit.length; i++) {
+ TypedBlock e = (TypedBlock)tb.exit[i];
+ computeLiveness2(e);
+ if (e.status != DONE)
+ changed = true;
+ }
+
+ if (changed) {
+ changed = false;
+ byte[] usage = tb.localsUsage;
+ int n = usage.length;
+ for (int i = 0; i < tb.exit.length; i++) {
+ TypedBlock e = (TypedBlock)tb.exit[i];
+ if (e.status != DONE)
+ for (int k = 0; k < n; k++)
+ if (!tb.inputs[k]) {
+ if (usage[k] == UNKNOWN && e.inputs[k]) {
+ tb.inputs[k] = true;
+ changed = true;
+ }
+ }
+ }
+
+ tb.status = changed ? CHANGED_NOW : DONE;
+ }
+ else
+ tb.status = DONE;
+ }
+
+ if (computeLiveness2except(tb))
+ tb.status = CHANGED_NOW;
+
+ tb.updating = false;
+ }
+
+ private boolean computeLiveness2except(TypedBlock tb) {
+ BasicBlock.Catch handlers = tb.toCatch;
+ boolean changed = false;
+ while (handlers != null) {
+ TypedBlock h = (TypedBlock)handlers.body;
+ computeLiveness2(h);
+ if (h.status != DONE) {
+ boolean[] in = tb.inputs;
+ int n = in.length;
+ for (int k = 0; k < n; k++)
+ if (!in[k] && h.inputs[k]) {
+ in[k] = true;
+ changed = true;
+ }
+ }
+
+ handlers = handlers.next;
+ }
+
+ return changed;
+ }
+
+ private boolean hasChanged(TypedBlock[] blocks) {
+ int n = blocks.length;
+ boolean changed = false;
+ for (int i = 0; i < n; i++) {
+ TypedBlock tb = blocks[i];
+ if (tb.status == CHANGED_NOW) {
+ tb.status = CHANGED_LAST;
+ changed = true;
+ }
+ else
+ tb.status = NOT_YET;
+ }
+
+ return changed;
+ }
+
+ private void computeUsage(CodeIterator ci, TypedBlock[] blocks, int maxLocals)
+ throws BadBytecode
+ {
+ int n = blocks.length;
+ for (int i = 0; i < n; i++) {
+ TypedBlock tb = blocks[i];
+ localsUsage = tb.localsUsage = new byte[maxLocals];
+ int pos = tb.position;
+ analyze(ci, pos, pos + tb.length);
+ localsUsage = null;
+ }
+ }
+
+ protected final void readLocal(int reg) {
+ if (localsUsage[reg] == UNKNOWN)
+ localsUsage[reg] = READ;
+ }
+
+ protected final void writeLocal(int reg) {
+ if (localsUsage[reg] == UNKNOWN)
+ localsUsage[reg] = UPDATED;
+ }
+
+ protected void analyze(CodeIterator ci, int begin, int end)
+ throws BadBytecode
+ {
+ ci.begin();
+ ci.move(begin);
+ while (ci.hasNext()) {
+ int index = ci.next();
+ if (index >= end)
+ break;
+
+ int op = ci.byteAt(index);
+ if (op < 96)
+ if (op < 54)
+ doOpcode0_53(ci, index, op);
+ else
+ doOpcode54_95(ci, index, op);
+ else
+ if (op == Opcode.IINC) {
+ // this does not call writeLocal().
+ readLocal(ci.byteAt(index + 1));
+ }
+ else if (op == Opcode.WIDE)
+ doWIDE(ci, index);
+ }
+ }
+
+ private void doOpcode0_53(CodeIterator ci, int pos, int op) {
+ switch (op) {
+ case Opcode.ILOAD :
+ case Opcode.LLOAD :
+ case Opcode.FLOAD :
+ case Opcode.DLOAD :
+ case Opcode.ALOAD :
+ readLocal(ci.byteAt(pos + 1));
+ break;
+ case Opcode.ILOAD_0 :
+ case Opcode.ILOAD_1 :
+ case Opcode.ILOAD_2 :
+ case Opcode.ILOAD_3 :
+ readLocal(op - Opcode.ILOAD_0);
+ break;
+ case Opcode.LLOAD_0 :
+ case Opcode.LLOAD_1 :
+ case Opcode.LLOAD_2 :
+ case Opcode.LLOAD_3 :
+ readLocal(op - Opcode.LLOAD_0);
+ break;
+ case Opcode.FLOAD_0 :
+ case Opcode.FLOAD_1 :
+ case Opcode.FLOAD_2 :
+ case Opcode.FLOAD_3 :
+ readLocal(op - Opcode.FLOAD_0);
+ break;
+ case Opcode.DLOAD_0 :
+ case Opcode.DLOAD_1 :
+ case Opcode.DLOAD_2 :
+ case Opcode.DLOAD_3 :
+ readLocal(op - Opcode.DLOAD_0);
+ break;
+ case Opcode.ALOAD_0 :
+ case Opcode.ALOAD_1 :
+ case Opcode.ALOAD_2 :
+ case Opcode.ALOAD_3 :
+ readLocal(op - Opcode.ALOAD_0);
+ break;
+ }
+ }
+
+ private void doOpcode54_95(CodeIterator ci, int pos, int op) {
+ switch (op) {
+ case Opcode.ISTORE :
+ case Opcode.LSTORE :
+ case Opcode.FSTORE :
+ case Opcode.DSTORE :
+ case Opcode.ASTORE :
+ writeLocal(ci.byteAt(pos + 1));
+ break;
+ case Opcode.ISTORE_0 :
+ case Opcode.ISTORE_1 :
+ case Opcode.ISTORE_2 :
+ case Opcode.ISTORE_3 :
+ writeLocal(op - Opcode.ISTORE_0);
+ break;
+ case Opcode.LSTORE_0 :
+ case Opcode.LSTORE_1 :
+ case Opcode.LSTORE_2 :
+ case Opcode.LSTORE_3 :
+ writeLocal(op - Opcode.LSTORE_0);
+ break;
+ case Opcode.FSTORE_0 :
+ case Opcode.FSTORE_1 :
+ case Opcode.FSTORE_2 :
+ case Opcode.FSTORE_3 :
+ writeLocal(op - Opcode.FSTORE_0);
+ break;
+ case Opcode.DSTORE_0 :
+ case Opcode.DSTORE_1 :
+ case Opcode.DSTORE_2 :
+ case Opcode.DSTORE_3 :
+ writeLocal(op - Opcode.DSTORE_0);
+ break;
+ case Opcode.ASTORE_0 :
+ case Opcode.ASTORE_1 :
+ case Opcode.ASTORE_2 :
+ case Opcode.ASTORE_3 :
+ writeLocal(op - Opcode.ASTORE_0);
+ break;
+ }
+ }
+
+ private void doWIDE(CodeIterator ci, int pos) throws BadBytecode {
+ int op = ci.byteAt(pos + 1);
+ int var = ci.u16bitAt(pos + 2);
+ switch (op) {
+ case Opcode.ILOAD :
+ case Opcode.LLOAD :
+ case Opcode.FLOAD :
+ case Opcode.DLOAD :
+ case Opcode.ALOAD :
+ readLocal(var);
+ break;
+ case Opcode.ISTORE :
+ case Opcode.LSTORE :
+ case Opcode.FSTORE :
+ case Opcode.DSTORE :
+ case Opcode.ASTORE :
+ writeLocal(var);
+ break;
+ case Opcode.IINC :
+ readLocal(var);
+ // this does not call writeLocal().
+ break;
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/stackmap/MapMaker.java b/src/main/javassist/bytecode/stackmap/MapMaker.java
new file mode 100644
index 0000000..92cd37c
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/MapMaker.java
@@ -0,0 +1,526 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.ClassPool;
+import javassist.bytecode.*;
+
+/**
+ * Stack map maker.
+ */
+public class MapMaker extends Tracer {
+ /*
+ public static void main(String[] args) throws Exception {
+ boolean useMain2 = args[0].equals("0");
+ if (useMain2 && args.length > 1) {
+ main2(args);
+ return;
+ }
+
+ for (int i = 0; i < args.length; i++)
+ main1(args[i]);
+ }
+
+ public static void main1(String className) throws Exception {
+ ClassPool cp = ClassPool.getDefault();
+ //javassist.CtClass cc = cp.get(className);
+ javassist.CtClass cc = cp.makeClass(new java.io.FileInputStream(className));
+ System.out.println(className);
+ ClassFile cf = cc.getClassFile();
+ java.util.List minfos = cf.getMethods();
+ for (int i = 0; i < minfos.size(); i++) {
+ MethodInfo minfo = (MethodInfo)minfos.get(i);
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca != null)
+ ca.setAttribute(make(cp, minfo));
+ }
+
+ cc.writeFile("tmp");
+ }
+
+ public static void main2(String[] args) throws Exception {
+ ClassPool cp = ClassPool.getDefault();
+ //javassist.CtClass cc = cp.get(args[1]);
+ javassist.CtClass cc = cp.makeClass(new java.io.FileInputStream(args[1]));
+ MethodInfo minfo;
+ if (args[2].equals("_init_"))
+ minfo = cc.getDeclaredConstructors()[0].getMethodInfo();
+ // minfo = cc.getClassInitializer().getMethodInfo();
+ else
+ minfo = cc.getDeclaredMethod(args[2]).getMethodInfo();
+
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca == null) {
+ System.out.println("abstarct method");
+ return;
+ }
+
+ TypedBlock[] blocks = TypedBlock.makeBlocks(minfo, ca, false);
+ MapMaker mm = new MapMaker(cp, minfo, ca);
+ mm.make(blocks, ca.getCode());
+ for (int i = 0; i < blocks.length; i++)
+ System.out.println(blocks[i]);
+ }
+ */
+
+ /**
+ * Computes the stack map table of the given method and returns it.
+ * It returns null if the given method does not have to have a
+ * stack map table.
+ */
+ public static StackMapTable make(ClassPool classes, MethodInfo minfo)
+ throws BadBytecode
+ {
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca == null)
+ return null;
+
+ TypedBlock[] blocks = TypedBlock.makeBlocks(minfo, ca, true);
+ if (blocks == null)
+ return null;
+
+ MapMaker mm = new MapMaker(classes, minfo, ca);
+ mm.make(blocks, ca.getCode());
+ return mm.toStackMap(blocks);
+ }
+
+ /**
+ * Computes the stack map table for J2ME.
+ * It returns null if the given method does not have to have a
+ * stack map table.
+ */
+ public static StackMap make2(ClassPool classes, MethodInfo minfo)
+ throws BadBytecode
+ {
+ CodeAttribute ca = minfo.getCodeAttribute();
+ if (ca == null)
+ return null;
+
+ TypedBlock[] blocks = TypedBlock.makeBlocks(minfo, ca, true);
+ if (blocks == null)
+ return null;
+
+ MapMaker mm = new MapMaker(classes, minfo, ca);
+ mm.make(blocks, ca.getCode());
+ return mm.toStackMap2(minfo.getConstPool(), blocks);
+ }
+
+ public MapMaker(ClassPool classes, MethodInfo minfo, CodeAttribute ca) {
+ super(classes, minfo.getConstPool(),
+ ca.getMaxStack(), ca.getMaxLocals(),
+ TypedBlock.getRetType(minfo.getDescriptor()));
+ }
+
+ protected MapMaker(MapMaker old, boolean copyStack) {
+ super(old, copyStack);
+ }
+
+ /**
+ * Runs an analyzer (Phase 1 and 2).
+ */
+ void make(TypedBlock[] blocks, byte[] code)
+ throws BadBytecode
+ {
+ TypedBlock first = blocks[0];
+ fixParamTypes(first);
+ TypeData[] srcTypes = first.localsTypes;
+ copyFrom(srcTypes.length, srcTypes, this.localsTypes);
+ make(code, first);
+
+ int n = blocks.length;
+ for (int i = 0; i < n; i++)
+ evalExpected(blocks[i]);
+ }
+
+ /*
+ * If a parameter type is String but it is used only as Object
+ * within the method body, this MapMaker class will report its type
+ * is Object. To avoid this, fixParamTypes calls TypeData.setType()
+ * on each parameter type.
+ */
+ private void fixParamTypes(TypedBlock first) throws BadBytecode {
+ TypeData[] types = first.localsTypes;
+ int n = types.length;
+ for (int i = 0; i < n; i++) {
+ TypeData t = types[i];
+ if (t instanceof TypeData.ClassName) {
+ /* Skip the following statement if t.isNullType() is true
+ * although a parameter type is never null type.
+ */
+ TypeData.setType(t, t.getName(), classPool);
+ }
+ }
+ }
+
+ // Phase 1
+
+ private void make(byte[] code, TypedBlock tb)
+ throws BadBytecode
+ {
+ BasicBlock.Catch handlers = tb.toCatch;
+ while (handlers != null) {
+ traceException(code, handlers);
+ handlers = handlers.next;
+ }
+
+ int pos = tb.position;
+ int end = pos + tb.length;
+ while (pos < end)
+ pos += doOpcode(pos, code);
+
+ if (tb.exit != null) {
+ for (int i = 0; i < tb.exit.length; i++) {
+ TypedBlock e = (TypedBlock)tb.exit[i];
+ if (e.alreadySet())
+ mergeMap(e, true);
+ else {
+ recordStackMap(e);
+ MapMaker maker = new MapMaker(this, true);
+ maker.make(code, e);
+ }
+ }
+ }
+ }
+
+ private void traceException(byte[] code, TypedBlock.Catch handler)
+ throws BadBytecode
+ {
+ TypedBlock tb = (TypedBlock)handler.body;
+ if (tb.alreadySet())
+ mergeMap(tb, false);
+ else {
+ recordStackMap(tb, handler.typeIndex);
+ MapMaker maker = new MapMaker(this, false);
+
+ /* the following code is equivalent to maker.copyFrom(this)
+ * except stackTypes are not copied.
+ */
+ maker.stackTypes[0] = tb.stackTypes[0].getSelf();
+ maker.stackTop = 1;
+ maker.make(code, tb);
+ }
+ }
+
+ private void mergeMap(TypedBlock dest, boolean mergeStack) {
+ boolean[] inputs = dest.inputs;
+ int n = inputs.length;
+ for (int i = 0; i < n; i++)
+ if (inputs[i])
+ merge(localsTypes[i], dest.localsTypes[i]);
+
+ if (mergeStack) {
+ n = stackTop;
+ for (int i = 0; i < n; i++)
+ merge(stackTypes[i], dest.stackTypes[i]);
+ }
+ }
+
+ private void merge(TypeData td, TypeData target) {
+ boolean tdIsObj = false;
+ boolean targetIsObj = false;
+ // td or target is null if it is TOP.
+ if (td != TOP && td.isObjectType())
+ tdIsObj = true;
+
+ if (target != TOP && target.isObjectType())
+ targetIsObj = true;
+
+ if (tdIsObj && targetIsObj)
+ target.merge(td);
+ }
+
+ private void recordStackMap(TypedBlock target)
+ throws BadBytecode
+ {
+ TypeData[] tStackTypes = new TypeData[stackTypes.length];
+ int st = stackTop;
+ copyFrom(st, stackTypes, tStackTypes);
+ recordStackMap0(target, st, tStackTypes);
+ }
+
+ private void recordStackMap(TypedBlock target, int exceptionType)
+ throws BadBytecode
+ {
+ String type;
+ if (exceptionType == 0)
+ type = "java.lang.Throwable";
+ else
+ type = cpool.getClassInfo(exceptionType);
+
+ TypeData[] tStackTypes = new TypeData[stackTypes.length];
+ tStackTypes[0] = new TypeData.ClassName(type);
+
+ recordStackMap0(target, 1, tStackTypes);
+ }
+
+ private void recordStackMap0(TypedBlock target, int st, TypeData[] tStackTypes)
+ throws BadBytecode
+ {
+ int n = localsTypes.length;
+ TypeData[] tLocalsTypes = new TypeData[n];
+ int k = copyFrom(n, localsTypes, tLocalsTypes);
+
+ boolean[] inputs = target.inputs;
+ for (int i = 0; i < n; i++)
+ if (!inputs[i])
+ tLocalsTypes[i] = TOP;
+
+ target.setStackMap(st, tStackTypes, k, tLocalsTypes);
+ }
+
+ // Phase 2
+
+ void evalExpected(TypedBlock target) throws BadBytecode {
+ ClassPool cp = classPool;
+ evalExpected(cp, target.stackTop, target.stackTypes);
+ TypeData[] types = target.localsTypes;
+ if (types != null) // unless this block is dead code
+ evalExpected(cp, types.length, types);
+ }
+
+ private static void evalExpected(ClassPool cp, int n, TypeData[] types)
+ throws BadBytecode
+ {
+ for (int i = 0; i < n; i++) {
+ TypeData td = types[i];
+ if (td != null)
+ td.evalExpectedType(cp);
+ }
+ }
+
+ // Phase 3
+
+ public StackMapTable toStackMap(TypedBlock[] blocks) {
+ StackMapTable.Writer writer = new StackMapTable.Writer(32);
+ int n = blocks.length;
+ TypedBlock prev = blocks[0];
+ int offsetDelta = prev.length;
+ if (prev.incoming > 0) { // the first instruction is a branch target.
+ writer.sameFrame(0);
+ offsetDelta--;
+ }
+
+ for (int i = 1; i < n; i++) {
+ TypedBlock bb = blocks[i];
+ if (isTarget(bb, blocks[i - 1])) {
+ bb.resetNumLocals();
+ int diffL = stackMapDiff(prev.numLocals, prev.localsTypes,
+ bb.numLocals, bb.localsTypes);
+ toStackMapBody(writer, bb, diffL, offsetDelta, prev);
+ offsetDelta = bb.length - 1;
+ prev = bb;
+ }
+ else
+ offsetDelta += bb.length;
+ }
+
+ return writer.toStackMapTable(cpool);
+ }
+
+ /**
+ * Returns true if cur is a branch target.
+ */
+ private boolean isTarget(TypedBlock cur, TypedBlock prev) {
+ int in = cur.incoming;
+ if (in > 1)
+ return true;
+ else if (in < 1)
+ return false;
+
+ return prev.stop;
+ }
+
+ private void toStackMapBody(StackMapTable.Writer writer, TypedBlock bb,
+ int diffL, int offsetDelta, TypedBlock prev) {
+ // if diffL is -100, two TypeData arrays do not share
+ // any elements.
+
+ int stackTop = bb.stackTop;
+ if (stackTop == 0) {
+ if (diffL == 0) {
+ writer.sameFrame(offsetDelta);
+ return;
+ }
+ else if (0 > diffL && diffL >= -3) {
+ writer.chopFrame(offsetDelta, -diffL);
+ return;
+ }
+ else if (0 < diffL && diffL <= 3) {
+ int[] data = new int[diffL];
+ int[] tags = fillStackMap(bb.numLocals - prev.numLocals,
+ prev.numLocals, data,
+ bb.localsTypes);
+ writer.appendFrame(offsetDelta, tags, data);
+ return;
+ }
+ }
+ else if (stackTop == 1 && diffL == 0) {
+ TypeData td = bb.stackTypes[0];
+ if (td == TOP)
+ writer.sameLocals(offsetDelta, StackMapTable.TOP, 0);
+ else
+ writer.sameLocals(offsetDelta, td.getTypeTag(),
+ td.getTypeData(cpool));
+ return;
+ }
+ else if (stackTop == 2 && diffL == 0) {
+ TypeData td = bb.stackTypes[0];
+ if (td != TOP && td.is2WordType()) {
+ // bb.stackTypes[1] must be TOP.
+ writer.sameLocals(offsetDelta, td.getTypeTag(),
+ td.getTypeData(cpool));
+ return;
+ }
+ }
+
+ int[] sdata = new int[stackTop];
+ int[] stags = fillStackMap(stackTop, 0, sdata, bb.stackTypes);
+ int[] ldata = new int[bb.numLocals];
+ int[] ltags = fillStackMap(bb.numLocals, 0, ldata, bb.localsTypes);
+ writer.fullFrame(offsetDelta, ltags, ldata, stags, sdata);
+ }
+
+ private int[] fillStackMap(int num, int offset, int[] data, TypeData[] types) {
+ int realNum = diffSize(types, offset, offset + num);
+ ConstPool cp = cpool;
+ int[] tags = new int[realNum];
+ int j = 0;
+ for (int i = 0; i < num; i++) {
+ TypeData td = types[offset + i];
+ if (td == TOP) {
+ tags[j] = StackMapTable.TOP;
+ data[j] = 0;
+ }
+ else {
+ tags[j] = td.getTypeTag();
+ data[j] = td.getTypeData(cp);
+ if (td.is2WordType())
+ i++;
+ }
+
+ j++;
+ }
+
+ return tags;
+ }
+
+ private static int stackMapDiff(int oldTdLen, TypeData[] oldTd,
+ int newTdLen, TypeData[] newTd)
+ {
+ int diff = newTdLen - oldTdLen;
+ int len;
+ if (diff > 0)
+ len = oldTdLen;
+ else
+ len = newTdLen;
+
+ if (stackMapEq(oldTd, newTd, len))
+ if (diff > 0)
+ return diffSize(newTd, len, newTdLen);
+ else
+ return -diffSize(oldTd, len, oldTdLen);
+ else
+ return -100;
+ }
+
+ private static boolean stackMapEq(TypeData[] oldTd, TypeData[] newTd, int len) {
+ for (int i = 0; i < len; i++) {
+ TypeData td = oldTd[i];
+ if (td == TOP) { // the next element to LONG/DOUBLE is TOP.
+ if (newTd[i] != TOP)
+ return false;
+ }
+ else
+ if (!oldTd[i].equals(newTd[i]))
+ return false;
+ }
+
+ return true;
+ }
+
+ private static int diffSize(TypeData[] types, int offset, int len) {
+ int num = 0;
+ while (offset < len) {
+ TypeData td = types[offset++];
+ num++;
+ if (td != TOP && td.is2WordType())
+ offset++;
+ }
+
+ return num;
+ }
+
+ // Phase 3 for J2ME
+
+ public StackMap toStackMap2(ConstPool cp, TypedBlock[] blocks) {
+ StackMap.Writer writer = new StackMap.Writer();
+ int n = blocks.length; // should be > 0
+ boolean[] effective = new boolean[n];
+ TypedBlock prev = blocks[0];
+
+ // Is the first instruction a branch target?
+ effective[0] = prev.incoming > 0;
+
+ int num = effective[0] ? 1 : 0;
+ for (int i = 1; i < n; i++) {
+ TypedBlock bb = blocks[i];
+ if (effective[i] = isTarget(bb, blocks[i - 1])) {
+ bb.resetNumLocals();
+ prev = bb;
+ num++;
+ }
+ }
+
+ if (num == 0)
+ return null;
+
+ writer.write16bit(num);
+ for (int i = 0; i < n; i++)
+ if (effective[i])
+ writeStackFrame(writer, cp, blocks[i].position, blocks[i]);
+
+ return writer.toStackMap(cp);
+ }
+
+ private void writeStackFrame(StackMap.Writer writer, ConstPool cp, int offset, TypedBlock tb) {
+ writer.write16bit(offset);
+ writeVerifyTypeInfo(writer, cp, tb.localsTypes, tb.numLocals);
+ writeVerifyTypeInfo(writer, cp, tb.stackTypes, tb.stackTop);
+ }
+
+ private void writeVerifyTypeInfo(StackMap.Writer writer, ConstPool cp, TypeData[] types, int num) {
+ int numDWord = 0;
+ for (int i = 0; i < num; i++) {
+ TypeData td = types[i];
+ if (td != null && td.is2WordType()) {
+ numDWord++;
+ i++;
+ }
+ }
+
+ writer.write16bit(num - numDWord);
+ for (int i = 0; i < num; i++) {
+ TypeData td = types[i];
+ if (td == TOP)
+ writer.writeVerifyTypeInfo(StackMap.TOP, 0);
+ else {
+ writer.writeVerifyTypeInfo(td.getTypeTag(), td.getTypeData(cp));
+ if (td.is2WordType())
+ i++;
+ }
+ }
+ }
+}
diff --git a/src/main/javassist/bytecode/stackmap/Tracer.java b/src/main/javassist/bytecode/stackmap/Tracer.java
new file mode 100644
index 0000000..89e788d
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/Tracer.java
@@ -0,0 +1,920 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.bytecode.ByteArray;
+import javassist.bytecode.Opcode;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.BadBytecode;
+import javassist.ClassPool;
+
+/*
+ * A class for performing abstract interpretation.
+ * See also MapMaker class.
+ */
+
+public abstract class Tracer implements TypeTag {
+ protected ClassPool classPool;
+ protected ConstPool cpool;
+ protected String returnType;
+
+ protected int stackTop;
+ protected TypeData[] stackTypes;
+ protected TypeData[] localsTypes;
+
+ public Tracer(ClassPool classes, ConstPool cp, int maxStack, int maxLocals,
+ String retType) {
+ classPool = classes;
+ cpool = cp;
+ returnType = retType;
+ stackTop = 0;
+ stackTypes = new TypeData[maxStack];
+ localsTypes = new TypeData[maxLocals];
+ }
+
+ public Tracer(Tracer t, boolean copyStack) {
+ classPool = t.classPool;
+ cpool = t.cpool;
+ returnType = t.returnType;
+
+ stackTop = t.stackTop;
+ int size = t.stackTypes.length;
+ stackTypes = new TypeData[size];
+ if (copyStack)
+ copyFrom(t.stackTop, t.stackTypes, stackTypes);
+
+ int size2 = t.localsTypes.length;
+ localsTypes = new TypeData[size2];
+ copyFrom(size2, t.localsTypes, localsTypes);
+ }
+
+ protected static int copyFrom(int n, TypeData[] srcTypes, TypeData[] destTypes) {
+ int k = -1;
+ for (int i = 0; i < n; i++) {
+ TypeData t = srcTypes[i];
+ destTypes[i] = t == TOP ? TOP : t.getSelf();
+ if (t != TOP)
+ if (t.is2WordType())
+ k = i + 1;
+ else
+ k = i;
+ }
+
+ return k + 1;
+ }
+
+ /**
+ * Does abstract interpretation on the given bytecode instruction.
+ * It records whether or not a local variable (i.e. register) is accessed.
+ * If the instruction requires that a local variable or
+ * a stack element has a more specific type, this method updates the
+ * type of it.
+ *
+ * @param pos the position of the instruction.
+ * @return the size of the instruction at POS.
+ */
+ protected int doOpcode(int pos, byte[] code) throws BadBytecode {
+ try {
+ int op = code[pos] & 0xff;
+ if (op < 96)
+ if (op < 54)
+ return doOpcode0_53(pos, code, op);
+ else
+ return doOpcode54_95(pos, code, op);
+ else
+ if (op < 148)
+ return doOpcode96_147(pos, code, op);
+ else
+ return doOpcode148_201(pos, code, op);
+ }
+ catch (ArrayIndexOutOfBoundsException e) {
+ throw new BadBytecode("inconsistent stack height " + e.getMessage());
+ }
+ }
+
+ protected void visitBranch(int pos, byte[] code, int offset) throws BadBytecode {}
+ protected void visitGoto(int pos, byte[] code, int offset) throws BadBytecode {}
+ protected void visitReturn(int pos, byte[] code) throws BadBytecode {}
+ protected void visitThrow(int pos, byte[] code) throws BadBytecode {}
+
+ /**
+ * @param pos the position of TABLESWITCH
+ * @param code bytecode
+ * @param n the number of case labels
+ * @param offsetPos the position of the branch-target table.
+ * @param defaultOffset the offset to the default branch target.
+ */
+ protected void visitTableSwitch(int pos, byte[] code, int n,
+ int offsetPos, int defaultOffset) throws BadBytecode {}
+
+ /**
+ * @param pos the position of LOOKUPSWITCH
+ * @param code bytecode
+ * @param n the number of case labels
+ * @param offsetPos the position of the table of pairs of a value and a branch target.
+ * @param defaultOffset the offset to the default branch target.
+ */
+ protected void visitLookupSwitch(int pos, byte[] code, int n,
+ int pairsPos, int defaultOffset) throws BadBytecode {}
+
+ /**
+ * Invoked when the visited instruction is jsr.
+ * Java6 or later does not allow using RET.
+ */
+ protected void visitJSR(int pos, byte[] code) throws BadBytecode {
+ /* Since JSR pushes a return address onto the operand stack,
+ * the stack map at the entry point of a subroutine is
+ * stackTypes resulting after executing the following code:
+ *
+ * stackTypes[stackTop++] = TOP;
+ */
+ }
+
+ /**
+ * Invoked when the visited instruction is ret or wide ret.
+ * Java6 or later does not allow using RET.
+ */
+ protected void visitRET(int pos, byte[] code) throws BadBytecode {}
+
+ private int doOpcode0_53(int pos, byte[] code, int op) throws BadBytecode {
+ int reg;
+ TypeData[] stackTypes = this.stackTypes;
+ switch (op) {
+ case Opcode.NOP :
+ break;
+ case Opcode.ACONST_NULL :
+ stackTypes[stackTop++] = new TypeData.NullType();
+ break;
+ case Opcode.ICONST_M1 :
+ case Opcode.ICONST_0 :
+ case Opcode.ICONST_1 :
+ case Opcode.ICONST_2 :
+ case Opcode.ICONST_3 :
+ case Opcode.ICONST_4 :
+ case Opcode.ICONST_5 :
+ stackTypes[stackTop++] = INTEGER;
+ break;
+ case Opcode.LCONST_0 :
+ case Opcode.LCONST_1 :
+ stackTypes[stackTop++] = LONG;
+ stackTypes[stackTop++] = TOP;
+ break;
+ case Opcode.FCONST_0 :
+ case Opcode.FCONST_1 :
+ case Opcode.FCONST_2 :
+ stackTypes[stackTop++] = FLOAT;
+ break;
+ case Opcode.DCONST_0 :
+ case Opcode.DCONST_1 :
+ stackTypes[stackTop++] = DOUBLE;
+ stackTypes[stackTop++] = TOP;
+ break;
+ case Opcode.BIPUSH :
+ case Opcode.SIPUSH :
+ stackTypes[stackTop++] = INTEGER;
+ return op == Opcode.SIPUSH ? 3 : 2;
+ case Opcode.LDC :
+ doLDC(code[pos + 1] & 0xff);
+ return 2;
+ case Opcode.LDC_W :
+ case Opcode.LDC2_W :
+ doLDC(ByteArray.readU16bit(code, pos + 1));
+ return 3;
+ case Opcode.ILOAD :
+ return doXLOAD(INTEGER, code, pos);
+ case Opcode.LLOAD :
+ return doXLOAD(LONG, code, pos);
+ case Opcode.FLOAD :
+ return doXLOAD(FLOAT, code, pos);
+ case Opcode.DLOAD :
+ return doXLOAD(DOUBLE, code, pos);
+ case Opcode.ALOAD :
+ return doALOAD(code[pos + 1] & 0xff);
+ case Opcode.ILOAD_0 :
+ case Opcode.ILOAD_1 :
+ case Opcode.ILOAD_2 :
+ case Opcode.ILOAD_3 :
+ stackTypes[stackTop++] = INTEGER;
+ break;
+ case Opcode.LLOAD_0 :
+ case Opcode.LLOAD_1 :
+ case Opcode.LLOAD_2 :
+ case Opcode.LLOAD_3 :
+ stackTypes[stackTop++] = LONG;
+ stackTypes[stackTop++] = TOP;
+ break;
+ case Opcode.FLOAD_0 :
+ case Opcode.FLOAD_1 :
+ case Opcode.FLOAD_2 :
+ case Opcode.FLOAD_3 :
+ stackTypes[stackTop++] = FLOAT;
+ break;
+ case Opcode.DLOAD_0 :
+ case Opcode.DLOAD_1 :
+ case Opcode.DLOAD_2 :
+ case Opcode.DLOAD_3 :
+ stackTypes[stackTop++] = DOUBLE;
+ stackTypes[stackTop++] = TOP;
+ break;
+ case Opcode.ALOAD_0 :
+ case Opcode.ALOAD_1 :
+ case Opcode.ALOAD_2 :
+ case Opcode.ALOAD_3 :
+ reg = op - Opcode.ALOAD_0;
+ stackTypes[stackTop++] = localsTypes[reg];
+ break;
+ case Opcode.IALOAD :
+ stackTypes[--stackTop - 1] = INTEGER;
+ break;
+ case Opcode.LALOAD :
+ stackTypes[stackTop - 2] = LONG;
+ stackTypes[stackTop - 1] = TOP;
+ break;
+ case Opcode.FALOAD :
+ stackTypes[--stackTop - 1] = FLOAT;
+ break;
+ case Opcode.DALOAD :
+ stackTypes[stackTop - 2] = DOUBLE;
+ stackTypes[stackTop - 1] = TOP;
+ break;
+ case Opcode.AALOAD : {
+ int s = --stackTop - 1;
+ TypeData data = stackTypes[s];
+ if (data == null || !data.isObjectType())
+ throw new BadBytecode("bad AALOAD");
+ else
+ stackTypes[s] = new TypeData.ArrayElement(data);
+
+ break; }
+ case Opcode.BALOAD :
+ case Opcode.CALOAD :
+ case Opcode.SALOAD :
+ stackTypes[--stackTop - 1] = INTEGER;
+ break;
+ default :
+ throw new RuntimeException("fatal");
+ }
+
+ return 1;
+ }
+
+ private void doLDC(int index) {
+ TypeData[] stackTypes = this.stackTypes;
+ int tag = cpool.getTag(index);
+ if (tag == ConstPool.CONST_String)
+ stackTypes[stackTop++] = new TypeData.ClassName("java.lang.String");
+ else if (tag == ConstPool.CONST_Integer)
+ stackTypes[stackTop++] = INTEGER;
+ else if (tag == ConstPool.CONST_Float)
+ stackTypes[stackTop++] = FLOAT;
+ else if (tag == ConstPool.CONST_Long) {
+ stackTypes[stackTop++] = LONG;
+ stackTypes[stackTop++] = TOP;
+ }
+ else if (tag == ConstPool.CONST_Double) {
+ stackTypes[stackTop++] = DOUBLE;
+ stackTypes[stackTop++] = TOP;
+ }
+ else if (tag == ConstPool.CONST_Class)
+ stackTypes[stackTop++] = new TypeData.ClassName("java.lang.Class");
+ else
+ throw new RuntimeException("bad LDC: " + tag);
+ }
+
+ private int doXLOAD(TypeData type, byte[] code, int pos) {
+ int localVar = code[pos + 1] & 0xff;
+ return doXLOAD(localVar, type);
+ }
+
+ private int doXLOAD(int localVar, TypeData type) {
+ stackTypes[stackTop++] = type;
+ if (type.is2WordType())
+ stackTypes[stackTop++] = TOP;
+
+ return 2;
+ }
+
+ private int doALOAD(int localVar) { // int localVar, TypeData type) {
+ stackTypes[stackTop++] = localsTypes[localVar];
+ return 2;
+ }
+
+ private int doOpcode54_95(int pos, byte[] code, int op) throws BadBytecode {
+ TypeData[] localsTypes = this.localsTypes;
+ TypeData[] stackTypes = this.stackTypes;
+ switch (op) {
+ case Opcode.ISTORE :
+ return doXSTORE(pos, code, INTEGER);
+ case Opcode.LSTORE :
+ return doXSTORE(pos, code, LONG);
+ case Opcode.FSTORE :
+ return doXSTORE(pos, code, FLOAT);
+ case Opcode.DSTORE :
+ return doXSTORE(pos, code, DOUBLE);
+ case Opcode.ASTORE :
+ return doASTORE(code[pos + 1] & 0xff);
+ case Opcode.ISTORE_0 :
+ case Opcode.ISTORE_1 :
+ case Opcode.ISTORE_2 :
+ case Opcode.ISTORE_3 :
+ { int var = op - Opcode.ISTORE_0;
+ localsTypes[var] = INTEGER;
+ stackTop--; }
+ break;
+ case Opcode.LSTORE_0 :
+ case Opcode.LSTORE_1 :
+ case Opcode.LSTORE_2 :
+ case Opcode.LSTORE_3 :
+ { int var = op - Opcode.LSTORE_0;
+ localsTypes[var] = LONG;
+ localsTypes[var + 1] = TOP;
+ stackTop -= 2; }
+ break;
+ case Opcode.FSTORE_0 :
+ case Opcode.FSTORE_1 :
+ case Opcode.FSTORE_2 :
+ case Opcode.FSTORE_3 :
+ { int var = op - Opcode.FSTORE_0;
+ localsTypes[var] = FLOAT;
+ stackTop--; }
+ break;
+ case Opcode.DSTORE_0 :
+ case Opcode.DSTORE_1 :
+ case Opcode.DSTORE_2 :
+ case Opcode.DSTORE_3 :
+ { int var = op - Opcode.DSTORE_0;
+ localsTypes[var] = DOUBLE;
+ localsTypes[var + 1] = TOP;
+ stackTop -= 2; }
+ break;
+ case Opcode.ASTORE_0 :
+ case Opcode.ASTORE_1 :
+ case Opcode.ASTORE_2 :
+ case Opcode.ASTORE_3 :
+ { int var = op - Opcode.ASTORE_0;
+ doASTORE(var);
+ break; }
+ case Opcode.IASTORE :
+ case Opcode.LASTORE :
+ case Opcode.FASTORE :
+ case Opcode.DASTORE :
+ stackTop -= (op == Opcode.LASTORE || op == Opcode.DASTORE) ? 4 : 3;
+ break;
+ case Opcode.AASTORE :
+ TypeData.setType(stackTypes[stackTop - 1],
+ TypeData.ArrayElement.getElementType(stackTypes[stackTop - 3].getName()),
+ classPool);
+ stackTop -= 3;
+ break;
+ case Opcode.BASTORE :
+ case Opcode.CASTORE :
+ case Opcode.SASTORE :
+ stackTop -= 3;
+ break;
+ case Opcode.POP :
+ stackTop--;
+ break;
+ case Opcode.POP2 :
+ stackTop -= 2;
+ break;
+ case Opcode.DUP : {
+ int sp = stackTop;
+ stackTypes[sp] = stackTypes[sp - 1];
+ stackTop = sp + 1;
+ break; }
+ case Opcode.DUP_X1 :
+ case Opcode.DUP_X2 : {
+ int len = op - Opcode.DUP_X1 + 2;
+ doDUP_XX(1, len);
+ int sp = stackTop;
+ stackTypes[sp - len] = stackTypes[sp];
+ stackTop = sp + 1;
+ break; }
+ case Opcode.DUP2 :
+ doDUP_XX(2, 2);
+ stackTop += 2;
+ break;
+ case Opcode.DUP2_X1 :
+ case Opcode.DUP2_X2 : {
+ int len = op - Opcode.DUP2_X1 + 3;
+ doDUP_XX(2, len);
+ int sp = stackTop;
+ stackTypes[sp - len] = stackTypes[sp];
+ stackTypes[sp - len + 1] = stackTypes[sp + 1];
+ stackTop = sp + 2;
+ break; }
+ case Opcode.SWAP : {
+ int sp = stackTop - 1;
+ TypeData t = stackTypes[sp];
+ stackTypes[sp] = stackTypes[sp - 1];
+ stackTypes[sp - 1] = t;
+ break; }
+ default :
+ throw new RuntimeException("fatal");
+ }
+
+ return 1;
+ }
+
+ private int doXSTORE(int pos, byte[] code, TypeData type) {
+ int index = code[pos + 1] & 0xff;
+ return doXSTORE(index, type);
+ }
+
+ private int doXSTORE(int index, TypeData type) {
+ stackTop--;
+ localsTypes[index] = type;
+ if (type.is2WordType()) {
+ stackTop--;
+ localsTypes[index + 1] = TOP;
+ }
+
+ return 2;
+ }
+
+ private int doASTORE(int index) {
+ stackTop--;
+ // implicit upcast might be done.
+ localsTypes[index] = stackTypes[stackTop].copy();
+ return 2;
+ }
+
+ private void doDUP_XX(int delta, int len) {
+ TypeData types[] = stackTypes;
+ int sp = stackTop - 1;
+ int end = sp - len;
+ while (sp > end) {
+ types[sp + delta] = types[sp];
+ sp--;
+ }
+ }
+
+ private int doOpcode96_147(int pos, byte[] code, int op) {
+ if (op <= Opcode.LXOR) { // IADD...LXOR
+ stackTop += Opcode.STACK_GROW[op];
+ return 1;
+ }
+
+ switch (op) {
+ case Opcode.IINC :
+ // this does not call writeLocal().
+ return 3;
+ case Opcode.I2L :
+ stackTypes[stackTop] = LONG;
+ stackTypes[stackTop - 1] = TOP;
+ stackTop++;
+ break;
+ case Opcode.I2F :
+ stackTypes[stackTop - 1] = FLOAT;
+ break;
+ case Opcode.I2D :
+ stackTypes[stackTop] = DOUBLE;
+ stackTypes[stackTop - 1] = TOP;
+ stackTop++;
+ break;
+ case Opcode.L2I :
+ stackTypes[--stackTop - 1] = INTEGER;
+ break;
+ case Opcode.L2F :
+ stackTypes[--stackTop - 1] = FLOAT;
+ break;
+ case Opcode.L2D :
+ stackTypes[stackTop - 1] = DOUBLE;
+ break;
+ case Opcode.F2I :
+ stackTypes[stackTop - 1] = INTEGER;
+ break;
+ case Opcode.F2L :
+ stackTypes[stackTop - 1] = TOP;
+ stackTypes[stackTop++] = LONG;
+ break;
+ case Opcode.F2D :
+ stackTypes[stackTop - 1] = TOP;
+ stackTypes[stackTop++] = DOUBLE;
+ break;
+ case Opcode.D2I :
+ stackTypes[--stackTop - 1] = INTEGER;
+ break;
+ case Opcode.D2L :
+ stackTypes[stackTop - 1] = LONG;
+ break;
+ case Opcode.D2F :
+ stackTypes[--stackTop - 1] = FLOAT;
+ break;
+ case Opcode.I2B :
+ case Opcode.I2C :
+ case Opcode.I2S :
+ break;
+ default :
+ throw new RuntimeException("fatal");
+ }
+
+ return 1;
+ }
+
+ private int doOpcode148_201(int pos, byte[] code, int op) throws BadBytecode {
+ switch (op) {
+ case Opcode.LCMP :
+ stackTypes[stackTop - 4] = INTEGER;
+ stackTop -= 3;
+ break;
+ case Opcode.FCMPL :
+ case Opcode.FCMPG :
+ stackTypes[--stackTop - 1] = INTEGER;
+ break;
+ case Opcode.DCMPL :
+ case Opcode.DCMPG :
+ stackTypes[stackTop - 4] = INTEGER;
+ stackTop -= 3;
+ break;
+ case Opcode.IFEQ :
+ case Opcode.IFNE :
+ case Opcode.IFLT :
+ case Opcode.IFGE :
+ case Opcode.IFGT :
+ case Opcode.IFLE :
+ stackTop--; // branch
+ visitBranch(pos, code, ByteArray.readS16bit(code, pos + 1));
+ return 3;
+ case Opcode.IF_ICMPEQ :
+ case Opcode.IF_ICMPNE :
+ case Opcode.IF_ICMPLT :
+ case Opcode.IF_ICMPGE :
+ case Opcode.IF_ICMPGT :
+ case Opcode.IF_ICMPLE :
+ case Opcode.IF_ACMPEQ :
+ case Opcode.IF_ACMPNE :
+ stackTop -= 2; // branch
+ visitBranch(pos, code, ByteArray.readS16bit(code, pos + 1));
+ return 3;
+ case Opcode.GOTO :
+ visitGoto(pos, code, ByteArray.readS16bit(code, pos + 1));
+ return 3; // branch
+ case Opcode.JSR :
+ visitJSR(pos, code);
+ return 3; // branch
+ case Opcode.RET :
+ visitRET(pos, code);
+ return 2;
+ case Opcode.TABLESWITCH : {
+ stackTop--; // branch
+ int pos2 = (pos & ~3) + 8;
+ int low = ByteArray.read32bit(code, pos2);
+ int high = ByteArray.read32bit(code, pos2 + 4);
+ int n = high - low + 1;
+ visitTableSwitch(pos, code, n, pos2 + 8, ByteArray.read32bit(code, pos2 - 4));
+ return n * 4 + 16 - (pos & 3); }
+ case Opcode.LOOKUPSWITCH : {
+ stackTop--; // branch
+ int pos2 = (pos & ~3) + 8;
+ int n = ByteArray.read32bit(code, pos2);
+ visitLookupSwitch(pos, code, n, pos2 + 4, ByteArray.read32bit(code, pos2 - 4));
+ return n * 8 + 12 - (pos & 3); }
+ case Opcode.IRETURN :
+ stackTop--;
+ visitReturn(pos, code);
+ break;
+ case Opcode.LRETURN :
+ stackTop -= 2;
+ visitReturn(pos, code);
+ break;
+ case Opcode.FRETURN :
+ stackTop--;
+ visitReturn(pos, code);
+ break;
+ case Opcode.DRETURN :
+ stackTop -= 2;
+ visitReturn(pos, code);
+ break;
+ case Opcode.ARETURN :
+ TypeData.setType(stackTypes[--stackTop], returnType, classPool);
+ visitReturn(pos, code);
+ break;
+ case Opcode.RETURN :
+ visitReturn(pos, code);
+ break;
+ case Opcode.GETSTATIC :
+ return doGetField(pos, code, false);
+ case Opcode.PUTSTATIC :
+ return doPutField(pos, code, false);
+ case Opcode.GETFIELD :
+ return doGetField(pos, code, true);
+ case Opcode.PUTFIELD :
+ return doPutField(pos, code, true);
+ case Opcode.INVOKEVIRTUAL :
+ case Opcode.INVOKESPECIAL :
+ return doInvokeMethod(pos, code, true);
+ case Opcode.INVOKESTATIC :
+ return doInvokeMethod(pos, code, false);
+ case Opcode.INVOKEINTERFACE :
+ return doInvokeIntfMethod(pos, code);
+ case 186 :
+ throw new RuntimeException("bad opcode 186");
+ case Opcode.NEW : {
+ int i = ByteArray.readU16bit(code, pos + 1);
+ stackTypes[stackTop++]
+ = new TypeData.UninitData(pos, cpool.getClassInfo(i));
+ return 3; }
+ case Opcode.NEWARRAY :
+ return doNEWARRAY(pos, code);
+ case Opcode.ANEWARRAY : {
+ int i = ByteArray.readU16bit(code, pos + 1);
+ String type = cpool.getClassInfo(i).replace('.', '/');
+ if (type.charAt(0) == '[')
+ type = "[" + type;
+ else
+ type = "[L" + type + ";";
+
+ stackTypes[stackTop - 1]
+ = new TypeData.ClassName(type);
+ return 3; }
+ case Opcode.ARRAYLENGTH :
+ TypeData.setType(stackTypes[stackTop - 1], "[Ljava.lang.Object;", classPool);
+ stackTypes[stackTop - 1] = INTEGER;
+ break;
+ case Opcode.ATHROW :
+ TypeData.setType(stackTypes[--stackTop], "java.lang.Throwable", classPool);
+ visitThrow(pos, code);
+ break;
+ case Opcode.CHECKCAST : {
+ // TypeData.setType(stackTypes[stackTop - 1], "java.lang.Object", classPool);
+ int i = ByteArray.readU16bit(code, pos + 1);
+ stackTypes[stackTop - 1] = new TypeData.ClassName(cpool.getClassInfo(i));
+ return 3; }
+ case Opcode.INSTANCEOF :
+ // TypeData.setType(stackTypes[stackTop - 1], "java.lang.Object", classPool);
+ stackTypes[stackTop - 1] = INTEGER;
+ return 3;
+ case Opcode.MONITORENTER :
+ case Opcode.MONITOREXIT :
+ stackTop--;
+ // TypeData.setType(stackTypes[stackTop], "java.lang.Object", classPool);
+ break;
+ case Opcode.WIDE :
+ return doWIDE(pos, code);
+ case Opcode.MULTIANEWARRAY :
+ return doMultiANewArray(pos, code);
+ case Opcode.IFNULL :
+ case Opcode.IFNONNULL :
+ stackTop--; // branch
+ visitBranch(pos, code, ByteArray.readS16bit(code, pos + 1));
+ return 3;
+ case Opcode.GOTO_W :
+ visitGoto(pos, code, ByteArray.read32bit(code, pos + 1));
+ return 5; // branch
+ case Opcode.JSR_W :
+ visitJSR(pos, code);
+ return 5;
+ }
+ return 1;
+ }
+
+ private int doWIDE(int pos, byte[] code) throws BadBytecode {
+ int op = code[pos + 1] & 0xff;
+ switch (op) {
+ case Opcode.ILOAD :
+ doWIDE_XLOAD(pos, code, INTEGER);
+ break;
+ case Opcode.LLOAD :
+ doWIDE_XLOAD(pos, code, LONG);
+ break;
+ case Opcode.FLOAD :
+ doWIDE_XLOAD(pos, code, FLOAT);
+ break;
+ case Opcode.DLOAD :
+ doWIDE_XLOAD(pos, code, DOUBLE);
+ break;
+ case Opcode.ALOAD : {
+ int index = ByteArray.readU16bit(code, pos + 2);
+ doALOAD(index);
+ break; }
+ case Opcode.ISTORE :
+ doWIDE_STORE(pos, code, INTEGER);
+ break;
+ case Opcode.LSTORE :
+ doWIDE_STORE(pos, code, LONG);
+ break;
+ case Opcode.FSTORE :
+ doWIDE_STORE(pos, code, FLOAT);
+ break;
+ case Opcode.DSTORE :
+ doWIDE_STORE(pos, code, DOUBLE);
+ break;
+ case Opcode.ASTORE : {
+ int index = ByteArray.readU16bit(code, pos + 2);
+ doASTORE(index);
+ break; }
+ case Opcode.IINC :
+ // this does not call writeLocal().
+ return 6;
+ case Opcode.RET :
+ visitRET(pos, code);
+ break;
+ default :
+ throw new RuntimeException("bad WIDE instruction: " + op);
+ }
+
+ return 4;
+ }
+
+ private void doWIDE_XLOAD(int pos, byte[] code, TypeData type) {
+ int index = ByteArray.readU16bit(code, pos + 2);
+ doXLOAD(index, type);
+ }
+
+ private void doWIDE_STORE(int pos, byte[] code, TypeData type) {
+ int index = ByteArray.readU16bit(code, pos + 2);
+ doXSTORE(index, type);
+ }
+
+ private int doPutField(int pos, byte[] code, boolean notStatic) throws BadBytecode {
+ int index = ByteArray.readU16bit(code, pos + 1);
+ String desc = cpool.getFieldrefType(index);
+ stackTop -= Descriptor.dataSize(desc);
+ char c = desc.charAt(0);
+ if (c == 'L')
+ TypeData.setType(stackTypes[stackTop], getFieldClassName(desc, 0), classPool);
+ else if (c == '[')
+ TypeData.setType(stackTypes[stackTop], desc, classPool);
+
+ setFieldTarget(notStatic, index);
+ return 3;
+ }
+
+ private int doGetField(int pos, byte[] code, boolean notStatic) throws BadBytecode {
+ int index = ByteArray.readU16bit(code, pos + 1);
+ setFieldTarget(notStatic, index);
+ String desc = cpool.getFieldrefType(index);
+ pushMemberType(desc);
+ return 3;
+ }
+
+ private void setFieldTarget(boolean notStatic, int index) throws BadBytecode {
+ if (notStatic) {
+ String className = cpool.getFieldrefClassName(index);
+ TypeData.setType(stackTypes[--stackTop], className, classPool);
+ }
+ }
+
+ private int doNEWARRAY(int pos, byte[] code) {
+ int s = stackTop - 1;
+ String type;
+ switch (code[pos + 1] & 0xff) {
+ case Opcode.T_BOOLEAN :
+ type = "[Z";
+ break;
+ case Opcode.T_CHAR :
+ type = "[C";
+ break;
+ case Opcode.T_FLOAT :
+ type = "[F";
+ break;
+ case Opcode.T_DOUBLE :
+ type = "[D";
+ break;
+ case Opcode.T_BYTE :
+ type = "[B";
+ break;
+ case Opcode.T_SHORT :
+ type = "[S";
+ break;
+ case Opcode.T_INT :
+ type = "[I";
+ break;
+ case Opcode.T_LONG :
+ type = "[J";
+ break;
+ default :
+ throw new RuntimeException("bad newarray");
+ }
+
+ stackTypes[s] = new TypeData.ClassName(type);
+ return 2;
+ }
+
+ private int doMultiANewArray(int pos, byte[] code) {
+ int i = ByteArray.readU16bit(code, pos + 1);
+ int dim = code[pos + 3] & 0xff;
+ stackTop -= dim - 1;
+
+ String type = cpool.getClassInfo(i).replace('.', '/');
+ stackTypes[stackTop - 1] = new TypeData.ClassName(type);
+ return 4;
+ }
+
+ private int doInvokeMethod(int pos, byte[] code, boolean notStatic) throws BadBytecode {
+ int i = ByteArray.readU16bit(code, pos + 1);
+ String desc = cpool.getMethodrefType(i);
+ checkParamTypes(desc, 1);
+ if (notStatic) {
+ String className = cpool.getMethodrefClassName(i);
+ TypeData.setType(stackTypes[--stackTop], className, classPool);
+ }
+
+ pushMemberType(desc);
+ return 3;
+ }
+
+ private int doInvokeIntfMethod(int pos, byte[] code) throws BadBytecode {
+ int i = ByteArray.readU16bit(code, pos + 1);
+ String desc = cpool.getInterfaceMethodrefType(i);
+ checkParamTypes(desc, 1);
+ String className = cpool.getInterfaceMethodrefClassName(i);
+ TypeData.setType(stackTypes[--stackTop], className, classPool);
+ pushMemberType(desc);
+ return 5;
+ }
+
+ private void pushMemberType(String descriptor) {
+ int top = 0;
+ if (descriptor.charAt(0) == '(') {
+ top = descriptor.indexOf(')') + 1;
+ if (top < 1)
+ throw new IndexOutOfBoundsException("bad descriptor: "
+ + descriptor);
+ }
+
+ TypeData[] types = stackTypes;
+ int index = stackTop;
+ switch (descriptor.charAt(top)) {
+ case '[' :
+ types[index] = new TypeData.ClassName(descriptor.substring(top));
+ break;
+ case 'L' :
+ types[index] = new TypeData.ClassName(getFieldClassName(descriptor, top));
+ break;
+ case 'J' :
+ types[index] = LONG;
+ types[index + 1] = TOP;
+ stackTop += 2;
+ return;
+ case 'F' :
+ types[index] = FLOAT;
+ break;
+ case 'D' :
+ types[index] = DOUBLE;
+ types[index + 1] = TOP;
+ stackTop += 2;
+ return;
+ case 'V' :
+ return;
+ default : // C, B, S, I, Z
+ types[index] = INTEGER;
+ break;
+ }
+
+ stackTop++;
+ }
+
+ private static String getFieldClassName(String desc, int index) {
+ return desc.substring(index + 1, desc.length() - 1).replace('/', '.');
+ }
+
+ private void checkParamTypes(String desc, int i) throws BadBytecode {
+ char c = desc.charAt(i);
+ if (c == ')')
+ return;
+
+ int k = i;
+ boolean array = false;
+ while (c == '[') {
+ array = true;
+ c = desc.charAt(++k);
+ }
+
+ if (c == 'L') {
+ k = desc.indexOf(';', k) + 1;
+ if (k <= 0)
+ throw new IndexOutOfBoundsException("bad descriptor");
+ }
+ else
+ k++;
+
+ checkParamTypes(desc, k);
+ if (!array && (c == 'J' || c == 'D'))
+ stackTop -= 2;
+ else
+ stackTop--;
+
+ if (array)
+ TypeData.setType(stackTypes[stackTop],
+ desc.substring(i, k), classPool);
+ else if (c == 'L')
+ TypeData.setType(stackTypes[stackTop],
+ desc.substring(i + 1, k - 1).replace('/', '.'), classPool);
+ }
+}
diff --git a/src/main/javassist/bytecode/stackmap/TypeData.java b/src/main/javassist/bytecode/stackmap/TypeData.java
new file mode 100644
index 0000000..f6c6c4e
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/TypeData.java
@@ -0,0 +1,509 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.StackMapTable;
+import javassist.bytecode.BadBytecode;
+import java.util.ArrayList;
+
+public abstract class TypeData {
+ /* Memo:
+ * array type is a subtype of Cloneable and Serializable
+ */
+
+ protected TypeData() {}
+
+ public abstract void merge(TypeData neighbor);
+
+ /**
+ * Sets the type name of this object type. If the given type name is
+ * a subclass of the current type name, then the given name becomes
+ * the name of this object type.
+ *
+ * @param className dot-separated name unless the type is an array type.
+ */
+ static void setType(TypeData td, String className, ClassPool cp) throws BadBytecode {
+ if (td == TypeTag.TOP)
+ throw new BadBytecode("unset variable");
+ else
+ td.setType(className, cp);
+ }
+
+ public abstract boolean equals(Object obj);
+
+ public abstract int getTypeTag();
+ public abstract int getTypeData(ConstPool cp);
+
+ /*
+ * See UninitData.getSelf().
+ */
+ public TypeData getSelf() { return this; }
+
+ /* An operand value is copied when it is stored in a
+ * local variable.
+ */
+ public abstract TypeData copy();
+
+ public abstract boolean isObjectType();
+ public boolean is2WordType() { return false; }
+ public boolean isNullType() { return false; }
+
+ public abstract String getName() throws BadBytecode;
+ protected abstract void setType(String s, ClassPool cp) throws BadBytecode;
+ public abstract void evalExpectedType(ClassPool cp) throws BadBytecode;
+ public abstract String getExpected() throws BadBytecode;
+
+ /**
+ * Primitive types.
+ */
+ protected static class BasicType extends TypeData {
+ private String name;
+ private int typeTag;
+
+ public BasicType(String type, int tag) {
+ name = type;
+ typeTag = tag;
+ }
+
+ public void merge(TypeData neighbor) {}
+
+ public boolean equals(Object obj) {
+ return this == obj;
+ }
+
+ public int getTypeTag() { return typeTag; }
+ public int getTypeData(ConstPool cp) { return 0; }
+
+ public boolean isObjectType() { return false; }
+
+ public boolean is2WordType() {
+ return typeTag == StackMapTable.LONG
+ || typeTag == StackMapTable.DOUBLE;
+ }
+
+ public TypeData copy() {
+ return this;
+ }
+
+ public void evalExpectedType(ClassPool cp) throws BadBytecode {}
+
+ public String getExpected() throws BadBytecode {
+ return name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ protected void setType(String s, ClassPool cp) throws BadBytecode {
+ throw new BadBytecode("conflict: " + name + " and " + s);
+ }
+
+ public String toString() { return name; }
+ }
+
+ protected static abstract class TypeName extends TypeData {
+ protected ArrayList equivalences;
+
+ protected String expectedName;
+ private CtClass cache;
+ private boolean evalDone;
+
+ protected TypeName() {
+ equivalences = new ArrayList();
+ equivalences.add(this);
+ expectedName = null;
+ cache = null;
+ evalDone = false;
+ }
+
+ public void merge(TypeData neighbor) {
+ if (this == neighbor)
+ return;
+
+ if (!(neighbor instanceof TypeName))
+ return; // neighbor might be UninitData
+
+ TypeName neighbor2 = (TypeName)neighbor;
+ ArrayList list = equivalences;
+ ArrayList list2 = neighbor2.equivalences;
+ if (list == list2)
+ return;
+
+ int n = list2.size();
+ for (int i = 0; i < n; i++) {
+ TypeName tn = (TypeName)list2.get(i);
+ add(list, tn);
+ tn.equivalences = list;
+ }
+ }
+
+ private static void add(ArrayList list, TypeData td) {
+ int n = list.size();
+ for (int i = 0; i < n; i++)
+ if (list.get(i) == td)
+ return;
+
+ list.add(td);
+ }
+
+ /* NullType overrides this method.
+ */
+ public int getTypeTag() { return StackMapTable.OBJECT; }
+
+ public int getTypeData(ConstPool cp) {
+ String type;
+ try {
+ type = getExpected();
+ } catch (BadBytecode e) {
+ throw new RuntimeException("fatal error: ", e);
+ }
+
+ return getTypeData2(cp, type);
+ }
+
+ /* NullType overrides this method.
+ */
+ protected int getTypeData2(ConstPool cp, String type) {
+ return cp.addClassInfo(type);
+ }
+
+ public boolean equals(Object obj) {
+ if (obj instanceof TypeName) {
+ try {
+ TypeName tn = (TypeName)obj;
+ return getExpected().equals(tn.getExpected());
+ }
+ catch (BadBytecode e) {}
+ }
+
+ return false;
+ }
+
+ public boolean isObjectType() { return true; }
+
+ protected void setType(String typeName, ClassPool cp) throws BadBytecode {
+ if (update(cp, expectedName, typeName))
+ expectedName = typeName;
+ }
+
+ public void evalExpectedType(ClassPool cp) throws BadBytecode {
+ if (this.evalDone)
+ return;
+
+ ArrayList equiv = this.equivalences;
+ int n = equiv.size();
+ String name = evalExpectedType2(equiv, n);
+ if (name == null) {
+ name = this.expectedName;
+ for (int i = 0; i < n; i++) {
+ TypeData td = (TypeData)equiv.get(i);
+ if (td instanceof TypeName) {
+ TypeName tn = (TypeName)td;
+ if (update(cp, name, tn.expectedName))
+ name = tn.expectedName;
+ }
+ }
+ }
+
+ for (int i = 0; i < n; i++) {
+ TypeData td = (TypeData)equiv.get(i);
+ if (td instanceof TypeName) {
+ TypeName tn = (TypeName)td;
+ tn.expectedName = name;
+ tn.cache = null;
+ tn.evalDone = true;
+ }
+ }
+ }
+
+ private String evalExpectedType2(ArrayList equiv, int n) throws BadBytecode {
+ String origName = null;
+ for (int i = 0; i < n; i++) {
+ TypeData td = (TypeData)equiv.get(i);
+ if (!td.isNullType())
+ if (origName == null)
+ origName = td.getName();
+ else if (!origName.equals(td.getName()))
+ return null;
+ }
+
+ return origName;
+ }
+
+ protected boolean isTypeName() { return true; }
+
+ private boolean update(ClassPool cp, String oldName, String typeName) throws BadBytecode {
+ if (typeName == null)
+ return false;
+ else if (oldName == null)
+ return true;
+ else if (oldName.equals(typeName))
+ return false;
+ else if (typeName.charAt(0) == '['
+ && oldName.equals("[Ljava.lang.Object;")) {
+ /* this rule is not correct but Tracer class sets the type
+ of the operand of arraylength to java.lang.Object[].
+ Thus, int[] etc. must be a subtype of java.lang.Object[].
+ */
+ return true;
+ }
+
+ try {
+ if (cache == null)
+ cache = cp.get(oldName);
+
+ CtClass cache2 = cp.get(typeName);
+ if (cache2.subtypeOf(cache)) {
+ cache = cache2;
+ return true;
+ }
+ else
+ return false;
+ }
+ catch (NotFoundException e) {
+ throw new BadBytecode("cannot find " + e.getMessage());
+ }
+ }
+
+ /* See also NullType.getExpected().
+ */
+ public String getExpected() throws BadBytecode {
+ ArrayList equiv = equivalences;
+ if (equiv.size() == 1)
+ return getName();
+ else {
+ String en = expectedName;
+ if (en == null)
+ return "java.lang.Object";
+ else
+ return en;
+ }
+ }
+
+ public String toString() {
+ try {
+ String en = expectedName;
+ if (en != null)
+ return en;
+
+ String name = getName();
+ if (equivalences.size() == 1)
+ return name;
+ else
+ return name + "?";
+ }
+ catch (BadBytecode e) {
+ return "<" + e.getMessage() + ">";
+ }
+ }
+ }
+
+ /**
+ * Type data for OBJECT.
+ */
+ public static class ClassName extends TypeName {
+ private String name; // dot separated. null if this object is a copy of another.
+
+ public ClassName(String n) {
+ name = n;
+ }
+
+ public TypeData copy() {
+ return new ClassName(name);
+ }
+
+ public String getName() { // never returns null.
+ return name;
+ }
+ }
+
+ /**
+ * Type data for NULL or OBJECT.
+ * The types represented by the instances of this class are
+ * initially NULL but will be OBJECT.
+ */
+ public static class NullType extends ClassName {
+ public NullType() {
+ super("null"); // type name
+ }
+
+ public TypeData copy() {
+ return new NullType();
+ }
+
+ public boolean isNullType() { return true; }
+
+ public int getTypeTag() {
+ try {
+ if ("null".equals(getExpected()))
+ return StackMapTable.NULL;
+ else
+ return super.getTypeTag();
+ }
+ catch (BadBytecode e) {
+ throw new RuntimeException("fatal error: ", e);
+ }
+ }
+
+ protected int getTypeData2(ConstPool cp, String type) {
+ if ("null".equals(type))
+ return 0;
+ else
+ return super.getTypeData2(cp, type);
+ }
+
+ public String getExpected() throws BadBytecode {
+ String en = expectedName;
+ if (en == null) {
+ // ArrayList equiv = equivalences;
+ // if (equiv.size() == 1)
+ // return getName();
+ // else
+ return "java.lang.Object";
+ }
+ else
+ return en;
+ }
+ }
+
+ /**
+ * Type data for OBJECT if the type is an object type and is
+ * derived as an element type from an array type by AALOAD.
+ */
+ public static class ArrayElement extends TypeName {
+ TypeData array;
+
+ public ArrayElement(TypeData a) { // a is never null
+ array = a;
+ }
+
+ public TypeData copy() {
+ return new ArrayElement(array);
+ }
+
+ protected void setType(String typeName, ClassPool cp) throws BadBytecode {
+ super.setType(typeName, cp);
+ array.setType(getArrayType(typeName), cp);
+ }
+
+ public String getName() throws BadBytecode {
+ String name = array.getName();
+ if (name.length() > 1 && name.charAt(0) == '[') {
+ char c = name.charAt(1);
+ if (c == 'L')
+ return name.substring(2, name.length() - 1).replace('/', '.');
+ else if (c == '[')
+ return name.substring(1);
+ }
+
+ throw new BadBytecode("bad array type for AALOAD: "
+ + name);
+ }
+
+ public static String getArrayType(String elementType) {
+ if (elementType.charAt(0) == '[')
+ return "[" + elementType;
+ else
+ return "[L" + elementType.replace('.', '/') + ";";
+ }
+
+ public static String getElementType(String arrayType) {
+ char c = arrayType.charAt(1);
+ if (c == 'L')
+ return arrayType.substring(2, arrayType.length() - 1).replace('/', '.');
+ else if (c == '[')
+ return arrayType.substring(1);
+ else
+ return arrayType;
+ }
+ }
+
+ /**
+ * Type data for UNINIT.
+ */
+ public static class UninitData extends TypeData {
+ String className;
+ int offset;
+ boolean initialized;
+
+ UninitData(int offset, String className) {
+ this.className = className;
+ this.offset = offset;
+ this.initialized = false;
+ }
+
+ public void merge(TypeData neighbor) {}
+
+ public int getTypeTag() { return StackMapTable.UNINIT; }
+ public int getTypeData(ConstPool cp) { return offset; }
+
+ public boolean equals(Object obj) {
+ if (obj instanceof UninitData) {
+ UninitData ud = (UninitData)obj;
+ return offset == ud.offset && className.equals(ud.className);
+ }
+ else
+ return false;
+ }
+
+ public TypeData getSelf() {
+ if (initialized)
+ return copy();
+ else
+ return this;
+ }
+
+ public TypeData copy() {
+ return new ClassName(className);
+ }
+
+ public boolean isObjectType() { return true; }
+
+ protected void setType(String typeName, ClassPool cp) throws BadBytecode {
+ initialized = true;
+ }
+
+ public void evalExpectedType(ClassPool cp) throws BadBytecode {}
+
+ public String getName() {
+ return className;
+ }
+
+ public String getExpected() { return className; }
+
+ public String toString() { return "uninit:" + className + "@" + offset; }
+ }
+
+ public static class UninitThis extends UninitData {
+ UninitThis(String className) {
+ super(-1, className);
+ }
+
+ public int getTypeTag() { return StackMapTable.THIS; }
+ public int getTypeData(ConstPool cp) { return 0; }
+
+ public boolean equals(Object obj) {
+ return obj instanceof UninitThis;
+ }
+
+ public String toString() { return "uninit:this"; }
+ }
+}
diff --git a/src/main/javassist/bytecode/stackmap/TypeTag.java b/src/main/javassist/bytecode/stackmap/TypeTag.java
new file mode 100644
index 0000000..4172068
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/TypeTag.java
@@ -0,0 +1,28 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.bytecode.StackMapTable;
+
+public interface TypeTag {
+ TypeData TOP = null;
+ TypeData INTEGER = new TypeData.BasicType("int", StackMapTable.INTEGER);
+ TypeData FLOAT = new TypeData.BasicType("float", StackMapTable.FLOAT);
+ TypeData DOUBLE = new TypeData.BasicType("double", StackMapTable.DOUBLE);
+ TypeData LONG = new TypeData.BasicType("long", StackMapTable.LONG);
+
+ // and NULL, THIS, OBJECT, UNINIT
+}
diff --git a/src/main/javassist/bytecode/stackmap/TypedBlock.java b/src/main/javassist/bytecode/stackmap/TypedBlock.java
new file mode 100644
index 0000000..65dce97
--- /dev/null
+++ b/src/main/javassist/bytecode/stackmap/TypedBlock.java
@@ -0,0 +1,249 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.bytecode.stackmap;
+
+import javassist.bytecode.*;
+
+public class TypedBlock extends BasicBlock {
+ public int stackTop, numLocals;
+ public TypeData[] stackTypes, localsTypes;
+
+ // set by a Liveness object.
+ // inputs[i] is true if the i-th variable is used within this block.
+ public boolean[] inputs;
+
+ // working area for Liveness class.
+ public boolean updating;
+ public int status;
+ public byte[] localsUsage;
+
+ /**
+ * Divides the method body into basic blocks.
+ * The type information of the first block is initialized.
+ *
+ * @param optmize if it is true and the method does not include
+ * branches, this method returns null.
+ */
+ public static TypedBlock[] makeBlocks(MethodInfo minfo, CodeAttribute ca,
+ boolean optimize)
+ throws BadBytecode
+ {
+ TypedBlock[] blocks = (TypedBlock[])new Maker().make(minfo);
+ if (optimize && blocks.length < 2)
+ if (blocks.length == 0 || blocks[0].incoming == 0)
+ return null;
+
+ ConstPool pool = minfo.getConstPool();
+ boolean isStatic = (minfo.getAccessFlags() & AccessFlag.STATIC) != 0;
+ blocks[0].initFirstBlock(ca.getMaxStack(), ca.getMaxLocals(),
+ pool.getClassName(), minfo.getDescriptor(),
+ isStatic, minfo.isConstructor());
+ new Liveness().compute(ca.iterator(), blocks, ca.getMaxLocals(),
+ blocks[0].localsTypes);
+ return blocks;
+ }
+
+ protected TypedBlock(int pos) {
+ super(pos);
+ localsTypes = null;
+ inputs = null;
+ updating = false;
+ }
+
+ protected void toString2(StringBuffer sbuf) {
+ super.toString2(sbuf);
+ sbuf.append(",\n stack={");
+ printTypes(sbuf, stackTop, stackTypes);
+ sbuf.append("}, locals={");
+ printTypes(sbuf, numLocals, localsTypes);
+ sbuf.append("}, inputs={");
+ if (inputs != null)
+ for (int i = 0; i < inputs.length; i++)
+ sbuf.append(inputs[i] ? "1, " : "0, ");
+
+ sbuf.append('}');
+ }
+
+ private void printTypes(StringBuffer sbuf, int size,
+ TypeData[] types) {
+ if (types == null)
+ return;
+
+ for (int i = 0; i < size; i++) {
+ if (i > 0)
+ sbuf.append(", ");
+
+ TypeData td = types[i];
+ sbuf.append(td == null ? "<>" : td.toString());
+ }
+ }
+
+ public boolean alreadySet() {
+ return localsTypes != null;
+ }
+
+ public void setStackMap(int st, TypeData[] stack, int nl, TypeData[] locals)
+ throws BadBytecode
+ {
+ stackTop = st;
+ stackTypes = stack;
+ numLocals = nl;
+ localsTypes = locals;
+ }
+
+ /*
+ * Computes the correct value of numLocals.
+ */
+ public void resetNumLocals() {
+ if (localsTypes != null) {
+ int nl = localsTypes.length;
+ while (nl > 0 && localsTypes[nl - 1] == TypeTag.TOP) {
+ if (nl > 1) {
+ TypeData td = localsTypes[nl - 2];
+ if (td == TypeTag.LONG || td == TypeTag.DOUBLE)
+ break;
+ }
+
+ --nl;
+ }
+
+ numLocals = nl;
+ }
+ }
+
+ public static class Maker extends BasicBlock.Maker {
+ protected BasicBlock makeBlock(int pos) {
+ return new TypedBlock(pos);
+ }
+
+ protected BasicBlock[] makeArray(int size) {
+ return new TypedBlock[size];
+ }
+ }
+
+ /**
+ * Initializes the first block by the given method descriptor.
+ *
+ * @param block the first basic block that this method initializes.
+ * @param className a dot-separated fully qualified class name.
+ * For example, <code>javassist.bytecode.stackmap.BasicBlock</code>.
+ * @param methodDesc method descriptor.
+ * @param isStatic true if the method is a static method.
+ * @param isConstructor true if the method is a constructor.
+ */
+ void initFirstBlock(int maxStack, int maxLocals, String className,
+ String methodDesc, boolean isStatic, boolean isConstructor)
+ throws BadBytecode
+ {
+ if (methodDesc.charAt(0) != '(')
+ throw new BadBytecode("no method descriptor: " + methodDesc);
+
+ stackTop = 0;
+ stackTypes = new TypeData[maxStack];
+ TypeData[] locals = new TypeData[maxLocals];
+ if (isConstructor)
+ locals[0] = new TypeData.UninitThis(className);
+ else if (!isStatic)
+ locals[0] = new TypeData.ClassName(className);
+
+ int n = isStatic ? -1 : 0;
+ int i = 1;
+ try {
+ while ((i = descToTag(methodDesc, i, ++n, locals)) > 0)
+ if (locals[n].is2WordType())
+ locals[++n] = TypeTag.TOP;
+ }
+ catch (StringIndexOutOfBoundsException e) {
+ throw new BadBytecode("bad method descriptor: "
+ + methodDesc);
+ }
+
+ numLocals = n;
+ localsTypes = locals;
+ }
+
+ private static int descToTag(String desc, int i,
+ int n, TypeData[] types)
+ throws BadBytecode
+ {
+ int i0 = i;
+ int arrayDim = 0;
+ char c = desc.charAt(i);
+ if (c == ')')
+ return 0;
+
+ while (c == '[') {
+ ++arrayDim;
+ c = desc.charAt(++i);
+ }
+
+ if (c == 'L') {
+ int i2 = desc.indexOf(';', ++i);
+ if (arrayDim > 0)
+ types[n] = new TypeData.ClassName(desc.substring(i0, ++i2));
+ else
+ types[n] = new TypeData.ClassName(desc.substring(i0 + 1, ++i2 - 1)
+ .replace('/', '.'));
+ return i2;
+ }
+ else if (arrayDim > 0) {
+ types[n] = new TypeData.ClassName(desc.substring(i0, ++i));
+ return i;
+ }
+ else {
+ TypeData t = toPrimitiveTag(c);
+ if (t == null)
+ throw new BadBytecode("bad method descriptor: " + desc);
+
+ types[n] = t;
+ return i + 1;
+ }
+ }
+
+ private static TypeData toPrimitiveTag(char c) {
+ switch (c) {
+ case 'Z' :
+ case 'C' :
+ case 'B' :
+ case 'S' :
+ case 'I' :
+ return TypeTag.INTEGER;
+ case 'J' :
+ return TypeTag.LONG;
+ case 'F' :
+ return TypeTag.FLOAT;
+ case 'D' :
+ return TypeTag.DOUBLE;
+ case 'V' :
+ default :
+ return null;
+ }
+ }
+
+ public static String getRetType(String desc) {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ return "java.lang.Object";
+
+ char c = desc.charAt(i + 1);
+ if (c == '[')
+ return desc.substring(i + 1);
+ else if (c == 'L')
+ return desc.substring(i + 2, desc.length() - 1).replace('/', '.');
+ else
+ return "java.lang.Object";
+ }
+}
diff --git a/src/main/javassist/compiler/AccessorMaker.java b/src/main/javassist/compiler/AccessorMaker.java
new file mode 100644
index 0000000..7f4f918
--- /dev/null
+++ b/src/main/javassist/compiler/AccessorMaker.java
@@ -0,0 +1,259 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.*;
+import javassist.bytecode.*;
+import java.util.HashMap;
+
+/**
+ * AccessorMaker maintains accessors to private members of an enclosing
+ * class. It is necessary for compiling a method in an inner class.
+ */
+public class AccessorMaker {
+ private CtClass clazz;
+ private int uniqueNumber;
+ private HashMap accessors;
+
+ static final String lastParamType = "javassist.runtime.Inner";
+
+ public AccessorMaker(CtClass c) {
+ clazz = c;
+ uniqueNumber = 1;
+ accessors = new HashMap();
+ }
+
+ public String getConstructor(CtClass c, String desc, MethodInfo orig)
+ throws CompileError
+ {
+ String key = "<init>:" + desc;
+ String consDesc = (String)accessors.get(key);
+ if (consDesc != null)
+ return consDesc; // already exists.
+
+ consDesc = Descriptor.appendParameter(lastParamType, desc);
+ ClassFile cf = clazz.getClassFile(); // turn on the modified flag.
+ try {
+ ConstPool cp = cf.getConstPool();
+ ClassPool pool = clazz.getClassPool();
+ MethodInfo minfo
+ = new MethodInfo(cp, MethodInfo.nameInit, consDesc);
+ minfo.setAccessFlags(0);
+ minfo.addAttribute(new SyntheticAttribute(cp));
+ ExceptionsAttribute ea = orig.getExceptionsAttribute();
+ if (ea != null)
+ minfo.addAttribute(ea.copy(cp, null));
+
+ CtClass[] params = Descriptor.getParameterTypes(desc, pool);
+ Bytecode code = new Bytecode(cp);
+ code.addAload(0);
+ int regno = 1;
+ for (int i = 0; i < params.length; ++i)
+ regno += code.addLoad(regno, params[i]);
+ code.setMaxLocals(regno + 1); // the last parameter is added.
+ code.addInvokespecial(clazz, MethodInfo.nameInit, desc);
+
+ code.addReturn(null);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ }
+ catch (CannotCompileException e) {
+ throw new CompileError(e);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e);
+ }
+
+ accessors.put(key, consDesc);
+ return consDesc;
+ }
+
+ /**
+ * Returns the name of the method for accessing a private method.
+ *
+ * @param name the name of the private method.
+ * @param desc the descriptor of the private method.
+ * @param accDesc the descriptor of the accessor method. The first
+ * parameter type is <code>clazz</code>.
+ * If the private method is static,
+ * <code>accDesc<code> must be identical to <code>desc</code>.
+ *
+ * @param orig the method info of the private method.
+ * @return
+ */
+ public String getMethodAccessor(String name, String desc, String accDesc,
+ MethodInfo orig)
+ throws CompileError
+ {
+ String key = name + ":" + desc;
+ String accName = (String)accessors.get(key);
+ if (accName != null)
+ return accName; // already exists.
+
+ ClassFile cf = clazz.getClassFile(); // turn on the modified flag.
+ accName = findAccessorName(cf);
+ try {
+ ConstPool cp = cf.getConstPool();
+ ClassPool pool = clazz.getClassPool();
+ MethodInfo minfo
+ = new MethodInfo(cp, accName, accDesc);
+ minfo.setAccessFlags(AccessFlag.STATIC);
+ minfo.addAttribute(new SyntheticAttribute(cp));
+ ExceptionsAttribute ea = orig.getExceptionsAttribute();
+ if (ea != null)
+ minfo.addAttribute(ea.copy(cp, null));
+
+ CtClass[] params = Descriptor.getParameterTypes(accDesc, pool);
+ int regno = 0;
+ Bytecode code = new Bytecode(cp);
+ for (int i = 0; i < params.length; ++i)
+ regno += code.addLoad(regno, params[i]);
+
+ code.setMaxLocals(regno);
+ if (desc == accDesc)
+ code.addInvokestatic(clazz, name, desc);
+ else
+ code.addInvokevirtual(clazz, name, desc);
+
+ code.addReturn(Descriptor.getReturnType(desc, pool));
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ }
+ catch (CannotCompileException e) {
+ throw new CompileError(e);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e);
+ }
+
+ accessors.put(key, accName);
+ return accName;
+ }
+
+ /**
+ * Returns the method_info representing the added getter.
+ */
+ public MethodInfo getFieldGetter(FieldInfo finfo, boolean is_static)
+ throws CompileError
+ {
+ String fieldName = finfo.getName();
+ String key = fieldName + ":getter";
+ Object res = accessors.get(key);
+ if (res != null)
+ return (MethodInfo)res; // already exists.
+
+ ClassFile cf = clazz.getClassFile(); // turn on the modified flag.
+ String accName = findAccessorName(cf);
+ try {
+ ConstPool cp = cf.getConstPool();
+ ClassPool pool = clazz.getClassPool();
+ String fieldType = finfo.getDescriptor();
+ String accDesc;
+ if (is_static)
+ accDesc = "()" + fieldType;
+ else
+ accDesc = "(" + Descriptor.of(clazz) + ")" + fieldType;
+
+ MethodInfo minfo = new MethodInfo(cp, accName, accDesc);
+ minfo.setAccessFlags(AccessFlag.STATIC);
+ minfo.addAttribute(new SyntheticAttribute(cp));
+ Bytecode code = new Bytecode(cp);
+ if (is_static) {
+ code.addGetstatic(Bytecode.THIS, fieldName, fieldType);
+ }
+ else {
+ code.addAload(0);
+ code.addGetfield(Bytecode.THIS, fieldName, fieldType);
+ code.setMaxLocals(1);
+ }
+
+ code.addReturn(Descriptor.toCtClass(fieldType, pool));
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ accessors.put(key, minfo);
+ return minfo;
+ }
+ catch (CannotCompileException e) {
+ throw new CompileError(e);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e);
+ }
+ }
+
+ /**
+ * Returns the method_info representing the added setter.
+ */
+ public MethodInfo getFieldSetter(FieldInfo finfo, boolean is_static)
+ throws CompileError
+ {
+ String fieldName = finfo.getName();
+ String key = fieldName + ":setter";
+ Object res = accessors.get(key);
+ if (res != null)
+ return (MethodInfo)res; // already exists.
+
+ ClassFile cf = clazz.getClassFile(); // turn on the modified flag.
+ String accName = findAccessorName(cf);
+ try {
+ ConstPool cp = cf.getConstPool();
+ ClassPool pool = clazz.getClassPool();
+ String fieldType = finfo.getDescriptor();
+ String accDesc;
+ if (is_static)
+ accDesc = "(" + fieldType + ")V";
+ else
+ accDesc = "(" + Descriptor.of(clazz) + fieldType + ")V";
+
+ MethodInfo minfo = new MethodInfo(cp, accName, accDesc);
+ minfo.setAccessFlags(AccessFlag.STATIC);
+ minfo.addAttribute(new SyntheticAttribute(cp));
+ Bytecode code = new Bytecode(cp);
+ int reg;
+ if (is_static) {
+ reg = code.addLoad(0, Descriptor.toCtClass(fieldType, pool));
+ code.addPutstatic(Bytecode.THIS, fieldName, fieldType);
+ }
+ else {
+ code.addAload(0);
+ reg = code.addLoad(1, Descriptor.toCtClass(fieldType, pool))
+ + 1;
+ code.addPutfield(Bytecode.THIS, fieldName, fieldType);
+ }
+
+ code.addReturn(null);
+ code.setMaxLocals(reg);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ accessors.put(key, minfo);
+ return minfo;
+ }
+ catch (CannotCompileException e) {
+ throw new CompileError(e);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e);
+ }
+ }
+
+ private String findAccessorName(ClassFile cf) {
+ String accName;
+ do {
+ accName = "access$" + uniqueNumber++;
+ } while (cf.getMethod(accName) != null);
+ return accName;
+ }
+}
diff --git a/src/main/javassist/compiler/CodeGen.java b/src/main/javassist/compiler/CodeGen.java
new file mode 100644
index 0000000..470a976
--- /dev/null
+++ b/src/main/javassist/compiler/CodeGen.java
@@ -0,0 +1,1921 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import javassist.compiler.ast.*;
+import javassist.bytecode.*;
+
+/* The code generator is implemeted by three files:
+ * CodeGen.java, MemberCodeGen.java, and JvstCodeGen.
+ * I just wanted to split a big file into three smaller ones.
+ */
+
+public abstract class CodeGen extends Visitor implements Opcode, TokenId {
+ static final String javaLangObject = "java.lang.Object";
+ static final String jvmJavaLangObject = "java/lang/Object";
+
+ static final String javaLangString = "java.lang.String";
+ static final String jvmJavaLangString = "java/lang/String";
+
+ protected Bytecode bytecode;
+ private int tempVar;
+ TypeChecker typeChecker;
+
+ /**
+ * true if the last visited node is a return statement.
+ */
+ protected boolean hasReturned;
+
+ /**
+ * Must be true if compilation is for a static method.
+ */
+ public boolean inStaticMethod;
+
+ protected ArrayList breakList, continueList;
+
+ /**
+ * doit() in ReturnHook is called from atReturn().
+ */
+ protected static abstract class ReturnHook {
+ ReturnHook next;
+
+ /**
+ * Returns true if the generated code ends with return,
+ * throw, or goto.
+ */
+ protected abstract boolean doit(Bytecode b, int opcode);
+
+ protected ReturnHook(CodeGen gen) {
+ next = gen.returnHooks;
+ gen.returnHooks = this;
+ }
+
+ protected void remove(CodeGen gen) {
+ gen.returnHooks = next;
+ }
+ }
+
+ protected ReturnHook returnHooks;
+
+ /* The following fields are used by atXXX() methods
+ * for returning the type of the compiled expression.
+ */
+ protected int exprType; // VOID, NULL, CLASS, BOOLEAN, INT, ...
+ protected int arrayDim;
+ protected String className; // JVM-internal representation
+
+ public CodeGen(Bytecode b) {
+ bytecode = b;
+ tempVar = -1;
+ typeChecker = null;
+ hasReturned = false;
+ inStaticMethod = false;
+ breakList = null;
+ continueList = null;
+ returnHooks = null;
+ }
+
+ public void setTypeChecker(TypeChecker checker) {
+ typeChecker = checker;
+ }
+
+ protected static void fatal() throws CompileError {
+ throw new CompileError("fatal");
+ }
+
+ public static boolean is2word(int type, int dim) {
+ return dim == 0 && (type == DOUBLE || type == LONG);
+ }
+
+ public int getMaxLocals() { return bytecode.getMaxLocals(); }
+
+ public void setMaxLocals(int n) {
+ bytecode.setMaxLocals(n);
+ }
+
+ protected void incMaxLocals(int size) {
+ bytecode.incMaxLocals(size);
+ }
+
+ /**
+ * Returns a local variable that single or double words can be
+ * stored in.
+ */
+ protected int getTempVar() {
+ if (tempVar < 0) {
+ tempVar = getMaxLocals();
+ incMaxLocals(2);
+ }
+
+ return tempVar;
+ }
+
+ protected int getLocalVar(Declarator d) {
+ int v = d.getLocalVar();
+ if (v < 0) {
+ v = getMaxLocals(); // delayed variable allocation.
+ d.setLocalVar(v);
+ incMaxLocals(1);
+ }
+
+ return v;
+ }
+
+ /**
+ * Returns the JVM-internal representation of this class name.
+ */
+ protected abstract String getThisName();
+
+ /**
+ * Returns the JVM-internal representation of this super class name.
+ */
+ protected abstract String getSuperName() throws CompileError;
+
+ /* Converts a class name into a JVM-internal representation.
+ *
+ * It may also expand a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected abstract String resolveClassName(ASTList name)
+ throws CompileError;
+
+ /* Expands a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected abstract String resolveClassName(String jvmClassName)
+ throws CompileError;
+
+ /**
+ * @param name the JVM-internal representation.
+ * name is not exapnded to java.lang.*.
+ */
+ protected static String toJvmArrayName(String name, int dim) {
+ if (name == null)
+ return null;
+
+ if (dim == 0)
+ return name;
+ else {
+ StringBuffer sbuf = new StringBuffer();
+ int d = dim;
+ while (d-- > 0)
+ sbuf.append('[');
+
+ sbuf.append('L');
+ sbuf.append(name);
+ sbuf.append(';');
+
+ return sbuf.toString();
+ }
+ }
+
+ protected static String toJvmTypeName(int type, int dim) {
+ char c = 'I';
+ switch(type) {
+ case BOOLEAN :
+ c = 'Z';
+ break;
+ case BYTE :
+ c = 'B';
+ break;
+ case CHAR :
+ c = 'C';
+ break;
+ case SHORT :
+ c = 'S';
+ break;
+ case INT :
+ c = 'I';
+ break;
+ case LONG :
+ c = 'J';
+ break;
+ case FLOAT :
+ c = 'F';
+ break;
+ case DOUBLE :
+ c = 'D';
+ break;
+ case VOID :
+ c = 'V';
+ break;
+ }
+
+ StringBuffer sbuf = new StringBuffer();
+ while (dim-- > 0)
+ sbuf.append('[');
+
+ sbuf.append(c);
+ return sbuf.toString();
+ }
+
+ public void compileExpr(ASTree expr) throws CompileError {
+ doTypeCheck(expr);
+ expr.accept(this);
+ }
+
+ public boolean compileBooleanExpr(boolean branchIf, ASTree expr)
+ throws CompileError
+ {
+ doTypeCheck(expr);
+ return booleanExpr(branchIf, expr);
+ }
+
+ public void doTypeCheck(ASTree expr) throws CompileError {
+ if (typeChecker != null)
+ expr.accept(typeChecker);
+ }
+
+ public void atASTList(ASTList n) throws CompileError { fatal(); }
+
+ public void atPair(Pair n) throws CompileError { fatal(); }
+
+ public void atSymbol(Symbol n) throws CompileError { fatal(); }
+
+ public void atFieldDecl(FieldDecl field) throws CompileError {
+ field.getInit().accept(this);
+ }
+
+ public void atMethodDecl(MethodDecl method) throws CompileError {
+ ASTList mods = method.getModifiers();
+ setMaxLocals(1);
+ while (mods != null) {
+ Keyword k = (Keyword)mods.head();
+ mods = mods.tail();
+ if (k.get() == STATIC) {
+ setMaxLocals(0);
+ inStaticMethod = true;
+ }
+ }
+
+ ASTList params = method.getParams();
+ while (params != null) {
+ atDeclarator((Declarator)params.head());
+ params = params.tail();
+ }
+
+ Stmnt s = method.getBody();
+ atMethodBody(s, method.isConstructor(),
+ method.getReturn().getType() == VOID);
+ }
+
+ /**
+ * @param isCons true if super() must be called.
+ * false if the method is a class initializer.
+ */
+ public void atMethodBody(Stmnt s, boolean isCons, boolean isVoid)
+ throws CompileError
+ {
+ if (s == null)
+ return;
+
+ if (isCons && needsSuperCall(s))
+ insertDefaultSuperCall();
+
+ hasReturned = false;
+ s.accept(this);
+ if (!hasReturned)
+ if (isVoid) {
+ bytecode.addOpcode(Opcode.RETURN);
+ hasReturned = true;
+ }
+ else
+ throw new CompileError("no return statement");
+ }
+
+ private boolean needsSuperCall(Stmnt body) throws CompileError {
+ if (body.getOperator() == BLOCK)
+ body = (Stmnt)body.head();
+
+ if (body != null && body.getOperator() == EXPR) {
+ ASTree expr = body.head();
+ if (expr != null && expr instanceof Expr
+ && ((Expr)expr).getOperator() == CALL) {
+ ASTree target = ((Expr)expr).head();
+ if (target instanceof Keyword) {
+ int token = ((Keyword)target).get();
+ return token != THIS && token != SUPER;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ protected abstract void insertDefaultSuperCall() throws CompileError;
+
+ public void atStmnt(Stmnt st) throws CompileError {
+ if (st == null)
+ return; // empty
+
+ int op = st.getOperator();
+ if (op == EXPR) {
+ ASTree expr = st.getLeft();
+ doTypeCheck(expr);
+ if (expr instanceof AssignExpr)
+ atAssignExpr((AssignExpr)expr, false);
+ else if (isPlusPlusExpr(expr)) {
+ Expr e = (Expr)expr;
+ atPlusPlus(e.getOperator(), e.oprand1(), e, false);
+ }
+ else {
+ expr.accept(this);
+ if (is2word(exprType, arrayDim))
+ bytecode.addOpcode(POP2);
+ else if (exprType != VOID)
+ bytecode.addOpcode(POP);
+ }
+ }
+ else if (op == DECL || op == BLOCK) {
+ ASTList list = st;
+ while (list != null) {
+ ASTree h = list.head();
+ list = list.tail();
+ if (h != null)
+ h.accept(this);
+ }
+ }
+ else if (op == IF)
+ atIfStmnt(st);
+ else if (op == WHILE || op == DO)
+ atWhileStmnt(st, op == WHILE);
+ else if (op == FOR)
+ atForStmnt(st);
+ else if (op == BREAK || op == CONTINUE)
+ atBreakStmnt(st, op == BREAK);
+ else if (op == TokenId.RETURN)
+ atReturnStmnt(st);
+ else if (op == THROW)
+ atThrowStmnt(st);
+ else if (op == TRY)
+ atTryStmnt(st);
+ else if (op == SWITCH)
+ atSwitchStmnt(st);
+ else if (op == SYNCHRONIZED)
+ atSyncStmnt(st);
+ else {
+ // LABEL, SWITCH label stament might be null?.
+ hasReturned = false;
+ throw new CompileError(
+ "sorry, not supported statement: TokenId " + op);
+ }
+ }
+
+ private void atIfStmnt(Stmnt st) throws CompileError {
+ ASTree expr = st.head();
+ Stmnt thenp = (Stmnt)st.tail().head();
+ Stmnt elsep = (Stmnt)st.tail().tail().head();
+ compileBooleanExpr(false, expr);
+ int pc = bytecode.currentPc();
+ int pc2 = 0;
+ bytecode.addIndex(0); // correct later
+
+ hasReturned = false;
+ if (thenp != null)
+ thenp.accept(this);
+
+ boolean thenHasReturned = hasReturned;
+ hasReturned = false;
+
+ if (elsep != null && !thenHasReturned) {
+ bytecode.addOpcode(Opcode.GOTO);
+ pc2 = bytecode.currentPc();
+ bytecode.addIndex(0);
+ }
+
+ bytecode.write16bit(pc, bytecode.currentPc() - pc + 1);
+
+ if (elsep != null) {
+ elsep.accept(this);
+ if (!thenHasReturned)
+ bytecode.write16bit(pc2, bytecode.currentPc() - pc2 + 1);
+
+ hasReturned = thenHasReturned && hasReturned;
+ }
+ }
+
+ private void atWhileStmnt(Stmnt st, boolean notDo) throws CompileError {
+ ArrayList prevBreakList = breakList;
+ ArrayList prevContList = continueList;
+ breakList = new ArrayList();
+ continueList = new ArrayList();
+
+ ASTree expr = st.head();
+ Stmnt body = (Stmnt)st.tail();
+
+ int pc = 0;
+ if (notDo) {
+ bytecode.addOpcode(Opcode.GOTO);
+ pc = bytecode.currentPc();
+ bytecode.addIndex(0);
+ }
+
+ int pc2 = bytecode.currentPc();
+ if (body != null)
+ body.accept(this);
+
+ int pc3 = bytecode.currentPc();
+ if (notDo)
+ bytecode.write16bit(pc, pc3 - pc + 1);
+
+ boolean alwaysBranch = compileBooleanExpr(true, expr);
+ bytecode.addIndex(pc2 - bytecode.currentPc() + 1);
+
+ patchGoto(breakList, bytecode.currentPc());
+ patchGoto(continueList, pc3);
+ continueList = prevContList;
+ breakList = prevBreakList;
+ hasReturned = alwaysBranch;
+ }
+
+ protected void patchGoto(ArrayList list, int targetPc) {
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ int pc = ((Integer)list.get(i)).intValue();
+ bytecode.write16bit(pc, targetPc - pc + 1);
+ }
+ }
+
+ private void atForStmnt(Stmnt st) throws CompileError {
+ ArrayList prevBreakList = breakList;
+ ArrayList prevContList = continueList;
+ breakList = new ArrayList();
+ continueList = new ArrayList();
+
+ Stmnt init = (Stmnt)st.head();
+ ASTList p = st.tail();
+ ASTree expr = p.head();
+ p = p.tail();
+ Stmnt update = (Stmnt)p.head();
+ Stmnt body = (Stmnt)p.tail();
+
+ if (init != null)
+ init.accept(this);
+
+ int pc = bytecode.currentPc();
+ int pc2 = 0;
+ if (expr != null) {
+ compileBooleanExpr(false, expr);
+ pc2 = bytecode.currentPc();
+ bytecode.addIndex(0);
+ }
+
+ if (body != null)
+ body.accept(this);
+
+ int pc3 = bytecode.currentPc();
+ if (update != null)
+ update.accept(this);
+
+ bytecode.addOpcode(Opcode.GOTO);
+ bytecode.addIndex(pc - bytecode.currentPc() + 1);
+
+ int pc4 = bytecode.currentPc();
+ if (expr != null)
+ bytecode.write16bit(pc2, pc4 - pc2 + 1);
+
+ patchGoto(breakList, pc4);
+ patchGoto(continueList, pc3);
+ continueList = prevContList;
+ breakList = prevBreakList;
+ hasReturned = false;
+ }
+
+ private void atSwitchStmnt(Stmnt st) throws CompileError {
+ compileExpr(st.head());
+
+ ArrayList prevBreakList = breakList;
+ breakList = new ArrayList();
+ int opcodePc = bytecode.currentPc();
+ bytecode.addOpcode(LOOKUPSWITCH);
+ int npads = 3 - (opcodePc & 3);
+ while (npads-- > 0)
+ bytecode.add(0);
+
+ Stmnt body = (Stmnt)st.tail();
+ int npairs = 0;
+ for (ASTList list = body; list != null; list = list.tail())
+ if (((Stmnt)list.head()).getOperator() == CASE)
+ ++npairs;
+
+ // opcodePc2 is the position at which the default jump offset is.
+ int opcodePc2 = bytecode.currentPc();
+ bytecode.addGap(4);
+ bytecode.add32bit(npairs);
+ bytecode.addGap(npairs * 8);
+
+ long[] pairs = new long[npairs];
+ int ipairs = 0;
+ int defaultPc = -1;
+ for (ASTList list = body; list != null; list = list.tail()) {
+ Stmnt label = (Stmnt)list.head();
+ int op = label.getOperator();
+ if (op == DEFAULT)
+ defaultPc = bytecode.currentPc();
+ else if (op != CASE)
+ fatal();
+ else {
+ pairs[ipairs++]
+ = ((long)computeLabel(label.head()) << 32) +
+ ((long)(bytecode.currentPc() - opcodePc) & 0xffffffff);
+ }
+
+ hasReturned = false;
+ ((Stmnt)label.tail()).accept(this);
+ }
+
+ Arrays.sort(pairs);
+ int pc = opcodePc2 + 8;
+ for (int i = 0; i < npairs; ++i) {
+ bytecode.write32bit(pc, (int)(pairs[i] >>> 32));
+ bytecode.write32bit(pc + 4, (int)pairs[i]);
+ pc += 8;
+ }
+
+ if (defaultPc < 0 || breakList.size() > 0)
+ hasReturned = false;
+
+ int endPc = bytecode.currentPc();
+ if (defaultPc < 0)
+ defaultPc = endPc;
+
+ bytecode.write32bit(opcodePc2, defaultPc - opcodePc);
+
+ patchGoto(breakList, endPc);
+ breakList = prevBreakList;
+ }
+
+ private int computeLabel(ASTree expr) throws CompileError {
+ doTypeCheck(expr);
+ expr = TypeChecker.stripPlusExpr(expr);
+ if (expr instanceof IntConst)
+ return (int)((IntConst)expr).get();
+ else
+ throw new CompileError("bad case label");
+ }
+
+ private void atBreakStmnt(Stmnt st, boolean notCont)
+ throws CompileError
+ {
+ if (st.head() != null)
+ throw new CompileError(
+ "sorry, not support labeled break or continue");
+
+ bytecode.addOpcode(Opcode.GOTO);
+ Integer pc = new Integer(bytecode.currentPc());
+ bytecode.addIndex(0);
+ if (notCont)
+ breakList.add(pc);
+ else
+ continueList.add(pc);
+ }
+
+ protected void atReturnStmnt(Stmnt st) throws CompileError {
+ atReturnStmnt2(st.getLeft());
+ }
+
+ protected final void atReturnStmnt2(ASTree result) throws CompileError {
+ int op;
+ if (result == null)
+ op = Opcode.RETURN;
+ else {
+ compileExpr(result);
+ if (arrayDim > 0)
+ op = ARETURN;
+ else {
+ int type = exprType;
+ if (type == DOUBLE)
+ op = DRETURN;
+ else if (type == FLOAT)
+ op = FRETURN;
+ else if (type == LONG)
+ op = LRETURN;
+ else if (isRefType(type))
+ op = ARETURN;
+ else
+ op = IRETURN;
+ }
+ }
+
+ for (ReturnHook har = returnHooks; har != null; har = har.next)
+ if (har.doit(bytecode, op)) {
+ hasReturned = true;
+ return;
+ }
+
+ bytecode.addOpcode(op);
+ hasReturned = true;
+ }
+
+ private void atThrowStmnt(Stmnt st) throws CompileError {
+ ASTree e = st.getLeft();
+ compileExpr(e);
+ if (exprType != CLASS || arrayDim > 0)
+ throw new CompileError("bad throw statement");
+
+ bytecode.addOpcode(ATHROW);
+ hasReturned = true;
+ }
+
+ /* overridden in MemberCodeGen
+ */
+ protected void atTryStmnt(Stmnt st) throws CompileError {
+ hasReturned = false;
+ }
+
+ private void atSyncStmnt(Stmnt st) throws CompileError {
+ int nbreaks = getListSize(breakList);
+ int ncontinues = getListSize(continueList);
+
+ compileExpr(st.head());
+ if (exprType != CLASS && arrayDim == 0)
+ throw new CompileError("bad type expr for synchronized block");
+
+ Bytecode bc = bytecode;
+ final int var = bc.getMaxLocals();
+ bc.incMaxLocals(1);
+ bc.addOpcode(DUP);
+ bc.addAstore(var);
+ bc.addOpcode(MONITORENTER);
+
+ ReturnHook rh = new ReturnHook(this) {
+ protected boolean doit(Bytecode b, int opcode) {
+ b.addAload(var);
+ b.addOpcode(MONITOREXIT);
+ return false;
+ }
+ };
+
+ int pc = bc.currentPc();
+ Stmnt body = (Stmnt)st.tail();
+ if (body != null)
+ body.accept(this);
+
+ int pc2 = bc.currentPc();
+ int pc3 = 0;
+ if (!hasReturned) {
+ rh.doit(bc, 0); // the 2nd arg is ignored.
+ bc.addOpcode(Opcode.GOTO);
+ pc3 = bc.currentPc();
+ bc.addIndex(0);
+ }
+
+ if (pc < pc2) { // if the body is not empty
+ int pc4 = bc.currentPc();
+ rh.doit(bc, 0); // the 2nd arg is ignored.
+ bc.addOpcode(ATHROW);
+ bc.addExceptionHandler(pc, pc2, pc4, 0);
+ }
+
+ if (!hasReturned)
+ bc.write16bit(pc3, bc.currentPc() - pc3 + 1);
+
+ rh.remove(this);
+
+ if (getListSize(breakList) != nbreaks
+ || getListSize(continueList) != ncontinues)
+ throw new CompileError(
+ "sorry, cannot break/continue in synchronized block");
+ }
+
+ private static int getListSize(ArrayList list) {
+ return list == null ? 0 : list.size();
+ }
+
+ private static boolean isPlusPlusExpr(ASTree expr) {
+ if (expr instanceof Expr) {
+ int op = ((Expr)expr).getOperator();
+ return op == PLUSPLUS || op == MINUSMINUS;
+ }
+
+ return false;
+ }
+
+ public void atDeclarator(Declarator d) throws CompileError {
+ d.setLocalVar(getMaxLocals());
+ d.setClassName(resolveClassName(d.getClassName()));
+
+ int size;
+ if (is2word(d.getType(), d.getArrayDim()))
+ size = 2;
+ else
+ size = 1;
+
+ incMaxLocals(size);
+
+ /* NOTE: Array initializers has not been supported.
+ */
+ ASTree init = d.getInitializer();
+ if (init != null) {
+ doTypeCheck(init);
+ atVariableAssign(null, '=', null, d, init, false);
+ }
+ }
+
+ public abstract void atNewExpr(NewExpr n) throws CompileError;
+
+ public abstract void atArrayInit(ArrayInit init) throws CompileError;
+
+ public void atAssignExpr(AssignExpr expr) throws CompileError {
+ atAssignExpr(expr, true);
+ }
+
+ protected void atAssignExpr(AssignExpr expr, boolean doDup)
+ throws CompileError
+ {
+ // =, %=, &=, *=, /=, +=, -=, ^=, |=, <<=, >>=, >>>=
+ int op = expr.getOperator();
+ ASTree left = expr.oprand1();
+ ASTree right = expr.oprand2();
+ if (left instanceof Variable)
+ atVariableAssign(expr, op, (Variable)left,
+ ((Variable)left).getDeclarator(),
+ right, doDup);
+ else {
+ if (left instanceof Expr) {
+ Expr e = (Expr)left;
+ if (e.getOperator() == ARRAY) {
+ atArrayAssign(expr, op, (Expr)left, right, doDup);
+ return;
+ }
+ }
+
+ atFieldAssign(expr, op, left, right, doDup);
+ }
+ }
+
+ protected static void badAssign(Expr expr) throws CompileError {
+ String msg;
+ if (expr == null)
+ msg = "incompatible type for assignment";
+ else
+ msg = "incompatible type for " + expr.getName();
+
+ throw new CompileError(msg);
+ }
+
+ /* op is either =, %=, &=, *=, /=, +=, -=, ^=, |=, <<=, >>=, or >>>=.
+ *
+ * expr and var can be null.
+ */
+ private void atVariableAssign(Expr expr, int op, Variable var,
+ Declarator d, ASTree right,
+ boolean doDup) throws CompileError
+ {
+ int varType = d.getType();
+ int varArray = d.getArrayDim();
+ String varClass = d.getClassName();
+ int varNo = getLocalVar(d);
+
+ if (op != '=')
+ atVariable(var);
+
+ // expr is null if the caller is atDeclarator().
+ if (expr == null && right instanceof ArrayInit)
+ atArrayVariableAssign((ArrayInit)right, varType, varArray, varClass);
+ else
+ atAssignCore(expr, op, right, varType, varArray, varClass);
+
+ if (doDup)
+ if (is2word(varType, varArray))
+ bytecode.addOpcode(DUP2);
+ else
+ bytecode.addOpcode(DUP);
+
+ if (varArray > 0)
+ bytecode.addAstore(varNo);
+ else if (varType == DOUBLE)
+ bytecode.addDstore(varNo);
+ else if (varType == FLOAT)
+ bytecode.addFstore(varNo);
+ else if (varType == LONG)
+ bytecode.addLstore(varNo);
+ else if (isRefType(varType))
+ bytecode.addAstore(varNo);
+ else
+ bytecode.addIstore(varNo);
+
+ exprType = varType;
+ arrayDim = varArray;
+ className = varClass;
+ }
+
+ protected abstract void atArrayVariableAssign(ArrayInit init,
+ int varType, int varArray, String varClass) throws CompileError;
+
+ private void atArrayAssign(Expr expr, int op, Expr array,
+ ASTree right, boolean doDup) throws CompileError
+ {
+ arrayAccess(array.oprand1(), array.oprand2());
+
+ if (op != '=') {
+ bytecode.addOpcode(DUP2);
+ bytecode.addOpcode(getArrayReadOp(exprType, arrayDim));
+ }
+
+ int aType = exprType;
+ int aDim = arrayDim;
+ String cname = className;
+
+ atAssignCore(expr, op, right, aType, aDim, cname);
+
+ if (doDup)
+ if (is2word(aType, aDim))
+ bytecode.addOpcode(DUP2_X2);
+ else
+ bytecode.addOpcode(DUP_X2);
+
+ bytecode.addOpcode(getArrayWriteOp(aType, aDim));
+ exprType = aType;
+ arrayDim = aDim;
+ className = cname;
+ }
+
+ protected abstract void atFieldAssign(Expr expr, int op, ASTree left,
+ ASTree right, boolean doDup) throws CompileError;
+
+ protected void atAssignCore(Expr expr, int op, ASTree right,
+ int type, int dim, String cname)
+ throws CompileError
+ {
+ if (op == PLUS_E && dim == 0 && type == CLASS)
+ atStringPlusEq(expr, type, dim, cname, right);
+ else {
+ right.accept(this);
+ if (invalidDim(exprType, arrayDim, className, type, dim, cname,
+ false) || (op != '=' && dim > 0))
+ badAssign(expr);
+
+ if (op != '=') {
+ int token = assignOps[op - MOD_E];
+ int k = lookupBinOp(token);
+ if (k < 0)
+ fatal();
+
+ atArithBinExpr(expr, token, k, type);
+ }
+ }
+
+ if (op != '=' || (dim == 0 && !isRefType(type)))
+ atNumCastExpr(exprType, type);
+
+ // type check should be done here.
+ }
+
+ private void atStringPlusEq(Expr expr, int type, int dim, String cname,
+ ASTree right)
+ throws CompileError
+ {
+ if (!jvmJavaLangString.equals(cname))
+ badAssign(expr);
+
+ convToString(type, dim); // the value might be null.
+ right.accept(this);
+ convToString(exprType, arrayDim);
+ bytecode.addInvokevirtual(javaLangString, "concat",
+ "(Ljava/lang/String;)Ljava/lang/String;");
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangString;
+ }
+
+ private boolean invalidDim(int srcType, int srcDim, String srcClass,
+ int destType, int destDim, String destClass,
+ boolean isCast)
+ {
+ if (srcDim != destDim)
+ if (srcType == NULL)
+ return false;
+ else if (destDim == 0 && destType == CLASS
+ && jvmJavaLangObject.equals(destClass))
+ return false;
+ else if (isCast && srcDim == 0 && srcType == CLASS
+ && jvmJavaLangObject.equals(srcClass))
+ return false;
+ else
+ return true;
+
+ return false;
+ }
+
+ public void atCondExpr(CondExpr expr) throws CompileError {
+ booleanExpr(false, expr.condExpr());
+ int pc = bytecode.currentPc();
+ bytecode.addIndex(0); // correct later
+ expr.thenExpr().accept(this);
+ int dim1 = arrayDim;
+ bytecode.addOpcode(Opcode.GOTO);
+ int pc2 = bytecode.currentPc();
+ bytecode.addIndex(0);
+ bytecode.write16bit(pc, bytecode.currentPc() - pc + 1);
+ expr.elseExpr().accept(this);
+ if (dim1 != arrayDim)
+ throw new CompileError("type mismatch in ?:");
+
+ bytecode.write16bit(pc2, bytecode.currentPc() - pc2 + 1);
+ }
+
+ static final int[] binOp = {
+ '+', DADD, FADD, LADD, IADD,
+ '-', DSUB, FSUB, LSUB, ISUB,
+ '*', DMUL, FMUL, LMUL, IMUL,
+ '/', DDIV, FDIV, LDIV, IDIV,
+ '%', DREM, FREM, LREM, IREM,
+ '|', NOP, NOP, LOR, IOR,
+ '^', NOP, NOP, LXOR, IXOR,
+ '&', NOP, NOP, LAND, IAND,
+ LSHIFT, NOP, NOP, LSHL, ISHL,
+ RSHIFT, NOP, NOP, LSHR, ISHR,
+ ARSHIFT, NOP, NOP, LUSHR, IUSHR };
+
+ static int lookupBinOp(int token) {
+ int[] code = binOp;
+ int s = code.length;
+ for (int k = 0; k < s; k = k + 5)
+ if (code[k] == token)
+ return k;
+
+ return -1;
+ }
+
+ public void atBinExpr(BinExpr expr) throws CompileError {
+ int token = expr.getOperator();
+
+ /* arithmetic operators: +, -, *, /, %, |, ^, &, <<, >>, >>>
+ */
+ int k = lookupBinOp(token);
+ if (k >= 0) {
+ expr.oprand1().accept(this);
+ ASTree right = expr.oprand2();
+ if (right == null)
+ return; // see TypeChecker.atBinExpr().
+
+ int type1 = exprType;
+ int dim1 = arrayDim;
+ String cname1 = className;
+ right.accept(this);
+ if (dim1 != arrayDim)
+ throw new CompileError("incompatible array types");
+
+ if (token == '+' && dim1 == 0
+ && (type1 == CLASS || exprType == CLASS))
+ atStringConcatExpr(expr, type1, dim1, cname1);
+ else
+ atArithBinExpr(expr, token, k, type1);
+ }
+ else {
+ /* equation: &&, ||, ==, !=, <=, >=, <, >
+ */
+ booleanExpr(true, expr);
+ bytecode.addIndex(7);
+ bytecode.addIconst(0); // false
+ bytecode.addOpcode(Opcode.GOTO);
+ bytecode.addIndex(4);
+ bytecode.addIconst(1); // true
+ }
+ }
+
+ /* arrayDim values of the two oprands must be equal.
+ * If an oprand type is not a numeric type, this method
+ * throws an exception.
+ */
+ private void atArithBinExpr(Expr expr, int token,
+ int index, int type1) throws CompileError
+ {
+ if (arrayDim != 0)
+ badTypes(expr);
+
+ int type2 = exprType;
+ if (token == LSHIFT || token == RSHIFT || token == ARSHIFT)
+ if (type2 == INT || type2 == SHORT
+ || type2 == CHAR || type2 == BYTE)
+ exprType = type1;
+ else
+ badTypes(expr);
+ else
+ convertOprandTypes(type1, type2, expr);
+
+ int p = typePrecedence(exprType);
+ if (p >= 0) {
+ int op = binOp[index + p + 1];
+ if (op != NOP) {
+ if (p == P_INT && exprType != BOOLEAN)
+ exprType = INT; // type1 may be BYTE, ...
+
+ bytecode.addOpcode(op);
+ return;
+ }
+ }
+
+ badTypes(expr);
+ }
+
+ private void atStringConcatExpr(Expr expr, int type1, int dim1,
+ String cname1) throws CompileError
+ {
+ int type2 = exprType;
+ int dim2 = arrayDim;
+ boolean type2Is2 = is2word(type2, dim2);
+ boolean type2IsString
+ = (type2 == CLASS && jvmJavaLangString.equals(className));
+
+ if (type2Is2)
+ convToString(type2, dim2);
+
+ if (is2word(type1, dim1)) {
+ bytecode.addOpcode(DUP_X2);
+ bytecode.addOpcode(POP);
+ }
+ else
+ bytecode.addOpcode(SWAP);
+
+ // even if type1 is String, the left operand might be null.
+ convToString(type1, dim1);
+ bytecode.addOpcode(SWAP);
+
+ if (!type2Is2 && !type2IsString)
+ convToString(type2, dim2);
+
+ bytecode.addInvokevirtual(javaLangString, "concat",
+ "(Ljava/lang/String;)Ljava/lang/String;");
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangString;
+ }
+
+ private void convToString(int type, int dim) throws CompileError {
+ final String method = "valueOf";
+
+ if (isRefType(type) || dim > 0)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(Ljava/lang/Object;)Ljava/lang/String;");
+ else if (type == DOUBLE)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(D)Ljava/lang/String;");
+ else if (type == FLOAT)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(F)Ljava/lang/String;");
+ else if (type == LONG)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(J)Ljava/lang/String;");
+ else if (type == BOOLEAN)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(Z)Ljava/lang/String;");
+ else if (type == CHAR)
+ bytecode.addInvokestatic(javaLangString, method,
+ "(C)Ljava/lang/String;");
+ else if (type == VOID)
+ throw new CompileError("void type expression");
+ else /* INT, BYTE, SHORT */
+ bytecode.addInvokestatic(javaLangString, method,
+ "(I)Ljava/lang/String;");
+ }
+
+ /* Produces the opcode to branch if the condition is true.
+ * The oprand is not produced.
+ *
+ * @return true if the compiled code is GOTO (always branch).
+ */
+ private boolean booleanExpr(boolean branchIf, ASTree expr)
+ throws CompileError
+ {
+ boolean isAndAnd;
+ int op = getCompOperator(expr);
+ if (op == EQ) { // ==, !=, ...
+ BinExpr bexpr = (BinExpr)expr;
+ int type1 = compileOprands(bexpr);
+ // here, arrayDim might represent the array dim. of the left oprand
+ // if the right oprand is NULL.
+ compareExpr(branchIf, bexpr.getOperator(), type1, bexpr);
+ }
+ else if (op == '!')
+ booleanExpr(!branchIf, ((Expr)expr).oprand1());
+ else if ((isAndAnd = (op == ANDAND)) || op == OROR) {
+ BinExpr bexpr = (BinExpr)expr;
+ booleanExpr(!isAndAnd, bexpr.oprand1());
+ int pc = bytecode.currentPc();
+ bytecode.addIndex(0); // correct later
+
+ booleanExpr(isAndAnd, bexpr.oprand2());
+ bytecode.write16bit(pc, bytecode.currentPc() - pc + 3);
+ if (branchIf != isAndAnd) {
+ bytecode.addIndex(6); // skip GOTO instruction
+ bytecode.addOpcode(Opcode.GOTO);
+ }
+ }
+ else if (isAlwaysBranch(expr, branchIf)) {
+ bytecode.addOpcode(Opcode.GOTO);
+ return true; // always branch
+ }
+ else { // others
+ expr.accept(this);
+ if (exprType != BOOLEAN || arrayDim != 0)
+ throw new CompileError("boolean expr is required");
+
+ bytecode.addOpcode(branchIf ? IFNE : IFEQ);
+ }
+
+ exprType = BOOLEAN;
+ arrayDim = 0;
+ return false;
+ }
+
+
+ private static boolean isAlwaysBranch(ASTree expr, boolean branchIf) {
+ if (expr instanceof Keyword) {
+ int t = ((Keyword)expr).get();
+ return branchIf ? t == TRUE : t == FALSE;
+ }
+
+ return false;
+ }
+
+ static int getCompOperator(ASTree expr) throws CompileError {
+ if (expr instanceof Expr) {
+ Expr bexpr = (Expr)expr;
+ int token = bexpr.getOperator();
+ if (token == '!')
+ return '!';
+ else if ((bexpr instanceof BinExpr)
+ && token != OROR && token != ANDAND
+ && token != '&' && token != '|')
+ return EQ; // ==, !=, ...
+ else
+ return token;
+ }
+
+ return ' '; // others
+ }
+
+ private int compileOprands(BinExpr expr) throws CompileError {
+ expr.oprand1().accept(this);
+ int type1 = exprType;
+ int dim1 = arrayDim;
+ expr.oprand2().accept(this);
+ if (dim1 != arrayDim)
+ if (type1 != NULL && exprType != NULL)
+ throw new CompileError("incompatible array types");
+ else if (exprType == NULL)
+ arrayDim = dim1;
+
+ if (type1 == NULL)
+ return exprType;
+ else
+ return type1;
+ }
+
+ private static final int ifOp[] = { EQ, IF_ICMPEQ, IF_ICMPNE,
+ NEQ, IF_ICMPNE, IF_ICMPEQ,
+ LE, IF_ICMPLE, IF_ICMPGT,
+ GE, IF_ICMPGE, IF_ICMPLT,
+ '<', IF_ICMPLT, IF_ICMPGE,
+ '>', IF_ICMPGT, IF_ICMPLE };
+
+ private static final int ifOp2[] = { EQ, IFEQ, IFNE,
+ NEQ, IFNE, IFEQ,
+ LE, IFLE, IFGT,
+ GE, IFGE, IFLT,
+ '<', IFLT, IFGE,
+ '>', IFGT, IFLE };
+
+ /* Produces the opcode to branch if the condition is true.
+ * The oprands are not produced.
+ *
+ * Parameter expr - compare expression ==, !=, <=, >=, <, >
+ */
+ private void compareExpr(boolean branchIf,
+ int token, int type1, BinExpr expr)
+ throws CompileError
+ {
+ if (arrayDim == 0)
+ convertOprandTypes(type1, exprType, expr);
+
+ int p = typePrecedence(exprType);
+ if (p == P_OTHER || arrayDim > 0)
+ if (token == EQ)
+ bytecode.addOpcode(branchIf ? IF_ACMPEQ : IF_ACMPNE);
+ else if (token == NEQ)
+ bytecode.addOpcode(branchIf ? IF_ACMPNE : IF_ACMPEQ);
+ else
+ badTypes(expr);
+ else
+ if (p == P_INT) {
+ int op[] = ifOp;
+ for (int i = 0; i < op.length; i += 3)
+ if (op[i] == token) {
+ bytecode.addOpcode(op[i + (branchIf ? 1 : 2)]);
+ return;
+ }
+
+ badTypes(expr);
+ }
+ else {
+ if (p == P_DOUBLE)
+ if (token == '<' || token == LE)
+ bytecode.addOpcode(DCMPG);
+ else
+ bytecode.addOpcode(DCMPL);
+ else if (p == P_FLOAT)
+ if (token == '<' || token == LE)
+ bytecode.addOpcode(FCMPG);
+ else
+ bytecode.addOpcode(FCMPL);
+ else if (p == P_LONG)
+ bytecode.addOpcode(LCMP); // 1: >, 0: =, -1: <
+ else
+ fatal();
+
+ int[] op = ifOp2;
+ for (int i = 0; i < op.length; i += 3)
+ if (op[i] == token) {
+ bytecode.addOpcode(op[i + (branchIf ? 1 : 2)]);
+ return;
+ }
+
+ badTypes(expr);
+ }
+ }
+
+ protected static void badTypes(Expr expr) throws CompileError {
+ throw new CompileError("invalid types for " + expr.getName());
+ }
+
+ private static final int P_DOUBLE = 0;
+ private static final int P_FLOAT = 1;
+ private static final int P_LONG = 2;
+ private static final int P_INT = 3;
+ private static final int P_OTHER = -1;
+
+ protected static boolean isRefType(int type) {
+ return type == CLASS || type == NULL;
+ }
+
+ private static int typePrecedence(int type) {
+ if (type == DOUBLE)
+ return P_DOUBLE;
+ else if (type == FLOAT)
+ return P_FLOAT;
+ else if (type == LONG)
+ return P_LONG;
+ else if (isRefType(type))
+ return P_OTHER;
+ else if (type == VOID)
+ return P_OTHER; // this is wrong, but ...
+ else
+ return P_INT; // BOOLEAN, BYTE, CHAR, SHORT, INT
+ }
+
+ // used in TypeChecker.
+ static boolean isP_INT(int type) {
+ return typePrecedence(type) == P_INT;
+ }
+
+ // used in TypeChecker.
+ static boolean rightIsStrong(int type1, int type2) {
+ int type1_p = typePrecedence(type1);
+ int type2_p = typePrecedence(type2);
+ return type1_p >= 0 && type2_p >= 0 && type1_p > type2_p;
+ }
+
+ private static final int[] castOp = {
+ /* D F L I */
+ /* double */ NOP, D2F, D2L, D2I,
+ /* float */ F2D, NOP, F2L, F2I,
+ /* long */ L2D, L2F, NOP, L2I,
+ /* other */ I2D, I2F, I2L, NOP };
+
+ /* do implicit type conversion.
+ * arrayDim values of the two oprands must be zero.
+ */
+ private void convertOprandTypes(int type1, int type2, Expr expr)
+ throws CompileError
+ {
+ boolean rightStrong;
+ int type1_p = typePrecedence(type1);
+ int type2_p = typePrecedence(type2);
+
+ if (type2_p < 0 && type1_p < 0) // not primitive types
+ return;
+
+ if (type2_p < 0 || type1_p < 0) // either is not a primitive type
+ badTypes(expr);
+
+ int op, result_type;
+ if (type1_p <= type2_p) {
+ rightStrong = false;
+ exprType = type1;
+ op = castOp[type2_p * 4 + type1_p];
+ result_type = type1_p;
+ }
+ else {
+ rightStrong = true;
+ op = castOp[type1_p * 4 + type2_p];
+ result_type = type2_p;
+ }
+
+ if (rightStrong) {
+ if (result_type == P_DOUBLE || result_type == P_LONG) {
+ if (type1_p == P_DOUBLE || type1_p == P_LONG)
+ bytecode.addOpcode(DUP2_X2);
+ else
+ bytecode.addOpcode(DUP2_X1);
+
+ bytecode.addOpcode(POP2);
+ bytecode.addOpcode(op);
+ bytecode.addOpcode(DUP2_X2);
+ bytecode.addOpcode(POP2);
+ }
+ else if (result_type == P_FLOAT) {
+ if (type1_p == P_LONG) {
+ bytecode.addOpcode(DUP_X2);
+ bytecode.addOpcode(POP);
+ }
+ else
+ bytecode.addOpcode(SWAP);
+
+ bytecode.addOpcode(op);
+ bytecode.addOpcode(SWAP);
+ }
+ else
+ fatal();
+ }
+ else if (op != NOP)
+ bytecode.addOpcode(op);
+ }
+
+ public void atCastExpr(CastExpr expr) throws CompileError {
+ String cname = resolveClassName(expr.getClassName());
+ String toClass = checkCastExpr(expr, cname);
+ int srcType = exprType;
+ exprType = expr.getType();
+ arrayDim = expr.getArrayDim();
+ className = cname;
+ if (toClass == null)
+ atNumCastExpr(srcType, exprType); // built-in type
+ else
+ bytecode.addCheckcast(toClass);
+ }
+
+ public void atInstanceOfExpr(InstanceOfExpr expr) throws CompileError {
+ String cname = resolveClassName(expr.getClassName());
+ String toClass = checkCastExpr(expr, cname);
+ bytecode.addInstanceof(toClass);
+ exprType = BOOLEAN;
+ arrayDim = 0;
+ }
+
+ private String checkCastExpr(CastExpr expr, String name)
+ throws CompileError
+ {
+ final String msg = "invalid cast";
+ ASTree oprand = expr.getOprand();
+ int dim = expr.getArrayDim();
+ int type = expr.getType();
+ oprand.accept(this);
+ int srcType = exprType;
+ if (invalidDim(srcType, arrayDim, className, type, dim, name, true)
+ || srcType == VOID || type == VOID)
+ throw new CompileError(msg);
+
+ if (type == CLASS) {
+ if (!isRefType(srcType))
+ throw new CompileError(msg);
+
+ return toJvmArrayName(name, dim);
+ }
+ else
+ if (dim > 0)
+ return toJvmTypeName(type, dim);
+ else
+ return null; // built-in type
+ }
+
+ void atNumCastExpr(int srcType, int destType)
+ throws CompileError
+ {
+ if (srcType == destType)
+ return;
+
+ int op, op2;
+ int stype = typePrecedence(srcType);
+ int dtype = typePrecedence(destType);
+ if (0 <= stype && stype < 3)
+ op = castOp[stype * 4 + dtype];
+ else
+ op = NOP;
+
+ if (destType == DOUBLE)
+ op2 = I2D;
+ else if (destType == FLOAT)
+ op2 = I2F;
+ else if (destType == LONG)
+ op2 = I2L;
+ else if (destType == SHORT)
+ op2 = I2S;
+ else if (destType == CHAR)
+ op2 = I2C;
+ else if (destType == BYTE)
+ op2 = I2B;
+ else
+ op2 = NOP;
+
+ if (op != NOP)
+ bytecode.addOpcode(op);
+
+ if (op == NOP || op == L2I || op == F2I || op == D2I)
+ if (op2 != NOP)
+ bytecode.addOpcode(op2);
+ }
+
+ public void atExpr(Expr expr) throws CompileError {
+ // array access, member access,
+ // (unary) +, (unary) -, ++, --, !, ~
+
+ int token = expr.getOperator();
+ ASTree oprand = expr.oprand1();
+ if (token == '.') {
+ String member = ((Symbol)expr.oprand2()).get();
+ if (member.equals("class"))
+ atClassObject(expr); // .class
+ else
+ atFieldRead(expr);
+ }
+ else if (token == MEMBER) { // field read
+ /* MEMBER ('#') is an extension by Javassist.
+ * The compiler internally uses # for compiling .class
+ * expressions such as "int.class".
+ */
+ atFieldRead(expr);
+ }
+ else if (token == ARRAY)
+ atArrayRead(oprand, expr.oprand2());
+ else if (token == PLUSPLUS || token == MINUSMINUS)
+ atPlusPlus(token, oprand, expr, true);
+ else if (token == '!') {
+ booleanExpr(false, expr);
+ bytecode.addIndex(7);
+ bytecode.addIconst(1);
+ bytecode.addOpcode(Opcode.GOTO);
+ bytecode.addIndex(4);
+ bytecode.addIconst(0);
+ }
+ else if (token == CALL) // method call
+ fatal();
+ else {
+ expr.oprand1().accept(this);
+ int type = typePrecedence(exprType);
+ if (arrayDim > 0)
+ badType(expr);
+
+ if (token == '-') {
+ if (type == P_DOUBLE)
+ bytecode.addOpcode(DNEG);
+ else if (type == P_FLOAT)
+ bytecode.addOpcode(FNEG);
+ else if (type == P_LONG)
+ bytecode.addOpcode(LNEG);
+ else if (type == P_INT) {
+ bytecode.addOpcode(INEG);
+ exprType = INT; // type may be BYTE, ...
+ }
+ else
+ badType(expr);
+ }
+ else if (token == '~') {
+ if (type == P_INT) {
+ bytecode.addIconst(-1);
+ bytecode.addOpcode(IXOR);
+ exprType = INT; // type may be BYTE. ...
+ }
+ else if (type == P_LONG) {
+ bytecode.addLconst(-1);
+ bytecode.addOpcode(LXOR);
+ }
+ else
+ badType(expr);
+
+ }
+ else if (token == '+') {
+ if (type == P_OTHER)
+ badType(expr);
+
+ // do nothing. ignore.
+ }
+ else
+ fatal();
+ }
+ }
+
+ protected static void badType(Expr expr) throws CompileError {
+ throw new CompileError("invalid type for " + expr.getName());
+ }
+
+ public abstract void atCallExpr(CallExpr expr) throws CompileError;
+
+ protected abstract void atFieldRead(ASTree expr) throws CompileError;
+
+ public void atClassObject(Expr expr) throws CompileError {
+ ASTree op1 = expr.oprand1();
+ if (!(op1 instanceof Symbol))
+ throw new CompileError("fatal error: badly parsed .class expr");
+
+ String cname = ((Symbol)op1).get();
+ if (cname.startsWith("[")) {
+ int i = cname.indexOf("[L");
+ if (i >= 0) {
+ String name = cname.substring(i + 2, cname.length() - 1);
+ String name2 = resolveClassName(name);
+ if (!name.equals(name2)) {
+ /* For example, to obtain String[].class,
+ * "[Ljava.lang.String;" (not "[Ljava/lang/String"!)
+ * must be passed to Class.forName().
+ */
+ name2 = MemberResolver.jvmToJavaName(name2);
+ StringBuffer sbuf = new StringBuffer();
+ while (i-- >= 0)
+ sbuf.append('[');
+
+ sbuf.append('L').append(name2).append(';');
+ cname = sbuf.toString();
+ }
+ }
+ }
+ else {
+ cname = resolveClassName(MemberResolver.javaToJvmName(cname));
+ cname = MemberResolver.jvmToJavaName(cname);
+ }
+
+ atClassObject2(cname);
+ exprType = CLASS;
+ arrayDim = 0;
+ className = "java/lang/Class";
+ }
+
+ /* MemberCodeGen overrides this method.
+ */
+ protected void atClassObject2(String cname) throws CompileError {
+ int start = bytecode.currentPc();
+ bytecode.addLdc(cname);
+ bytecode.addInvokestatic("java.lang.Class", "forName",
+ "(Ljava/lang/String;)Ljava/lang/Class;");
+ int end = bytecode.currentPc();
+ bytecode.addOpcode(Opcode.GOTO);
+ int pc = bytecode.currentPc();
+ bytecode.addIndex(0); // correct later
+
+ bytecode.addExceptionHandler(start, end, bytecode.currentPc(),
+ "java.lang.ClassNotFoundException");
+
+ /* -- the following code is for inlining a call to DotClass.fail().
+
+ int var = getMaxLocals();
+ incMaxLocals(1);
+ bytecode.growStack(1);
+ bytecode.addAstore(var);
+
+ bytecode.addNew("java.lang.NoClassDefFoundError");
+ bytecode.addOpcode(DUP);
+ bytecode.addAload(var);
+ bytecode.addInvokevirtual("java.lang.ClassNotFoundException",
+ "getMessage", "()Ljava/lang/String;");
+ bytecode.addInvokespecial("java.lang.NoClassDefFoundError", "<init>",
+ "(Ljava/lang/String;)V");
+ */
+
+ bytecode.growStack(1);
+ bytecode.addInvokestatic("javassist.runtime.DotClass", "fail",
+ "(Ljava/lang/ClassNotFoundException;)"
+ + "Ljava/lang/NoClassDefFoundError;");
+ bytecode.addOpcode(ATHROW);
+ bytecode.write16bit(pc, bytecode.currentPc() - pc + 1);
+ }
+
+ public void atArrayRead(ASTree array, ASTree index)
+ throws CompileError
+ {
+ arrayAccess(array, index);
+ bytecode.addOpcode(getArrayReadOp(exprType, arrayDim));
+ }
+
+ protected void arrayAccess(ASTree array, ASTree index)
+ throws CompileError
+ {
+ array.accept(this);
+ int type = exprType;
+ int dim = arrayDim;
+ if (dim == 0)
+ throw new CompileError("bad array access");
+
+ String cname = className;
+
+ index.accept(this);
+ if (typePrecedence(exprType) != P_INT || arrayDim > 0)
+ throw new CompileError("bad array index");
+
+ exprType = type;
+ arrayDim = dim - 1;
+ className = cname;
+ }
+
+ protected static int getArrayReadOp(int type, int dim) {
+ if (dim > 0)
+ return AALOAD;
+
+ switch (type) {
+ case DOUBLE :
+ return DALOAD;
+ case FLOAT :
+ return FALOAD;
+ case LONG :
+ return LALOAD;
+ case INT :
+ return IALOAD;
+ case SHORT :
+ return SALOAD;
+ case CHAR :
+ return CALOAD;
+ case BYTE :
+ case BOOLEAN :
+ return BALOAD;
+ default :
+ return AALOAD;
+ }
+ }
+
+ protected static int getArrayWriteOp(int type, int dim) {
+ if (dim > 0)
+ return AASTORE;
+
+ switch (type) {
+ case DOUBLE :
+ return DASTORE;
+ case FLOAT :
+ return FASTORE;
+ case LONG :
+ return LASTORE;
+ case INT :
+ return IASTORE;
+ case SHORT :
+ return SASTORE;
+ case CHAR :
+ return CASTORE;
+ case BYTE :
+ case BOOLEAN :
+ return BASTORE;
+ default :
+ return AASTORE;
+ }
+ }
+
+ private void atPlusPlus(int token, ASTree oprand, Expr expr,
+ boolean doDup) throws CompileError
+ {
+ boolean isPost = oprand == null; // ++i or i++?
+ if (isPost)
+ oprand = expr.oprand2();
+
+ if (oprand instanceof Variable) {
+ Declarator d = ((Variable)oprand).getDeclarator();
+ int t = exprType = d.getType();
+ arrayDim = d.getArrayDim();
+ int var = getLocalVar(d);
+ if (arrayDim > 0)
+ badType(expr);
+
+ if (t == DOUBLE) {
+ bytecode.addDload(var);
+ if (doDup && isPost)
+ bytecode.addOpcode(DUP2);
+
+ bytecode.addDconst(1.0);
+ bytecode.addOpcode(token == PLUSPLUS ? DADD : DSUB);
+ if (doDup && !isPost)
+ bytecode.addOpcode(DUP2);
+
+ bytecode.addDstore(var);
+ }
+ else if (t == LONG) {
+ bytecode.addLload(var);
+ if (doDup && isPost)
+ bytecode.addOpcode(DUP2);
+
+ bytecode.addLconst((long)1);
+ bytecode.addOpcode(token == PLUSPLUS ? LADD : LSUB);
+ if (doDup && !isPost)
+ bytecode.addOpcode(DUP2);
+
+ bytecode.addLstore(var);
+ }
+ else if (t == FLOAT) {
+ bytecode.addFload(var);
+ if (doDup && isPost)
+ bytecode.addOpcode(DUP);
+
+ bytecode.addFconst(1.0f);
+ bytecode.addOpcode(token == PLUSPLUS ? FADD : FSUB);
+ if (doDup && !isPost)
+ bytecode.addOpcode(DUP);
+
+ bytecode.addFstore(var);
+ }
+ else if (t == BYTE || t == CHAR || t == SHORT || t == INT) {
+ if (doDup && isPost)
+ bytecode.addIload(var);
+
+ int delta = token == PLUSPLUS ? 1 : -1;
+ if (var > 0xff) {
+ bytecode.addOpcode(WIDE);
+ bytecode.addOpcode(IINC);
+ bytecode.addIndex(var);
+ bytecode.addIndex(delta);
+ }
+ else {
+ bytecode.addOpcode(IINC);
+ bytecode.add(var);
+ bytecode.add(delta);
+ }
+
+ if (doDup && !isPost)
+ bytecode.addIload(var);
+ }
+ else
+ badType(expr);
+ }
+ else {
+ if (oprand instanceof Expr) {
+ Expr e = (Expr)oprand;
+ if (e.getOperator() == ARRAY) {
+ atArrayPlusPlus(token, isPost, e, doDup);
+ return;
+ }
+ }
+
+ atFieldPlusPlus(token, isPost, oprand, expr, doDup);
+ }
+ }
+
+ public void atArrayPlusPlus(int token, boolean isPost,
+ Expr expr, boolean doDup) throws CompileError
+ {
+ arrayAccess(expr.oprand1(), expr.oprand2());
+ int t = exprType;
+ int dim = arrayDim;
+ if (dim > 0)
+ badType(expr);
+
+ bytecode.addOpcode(DUP2);
+ bytecode.addOpcode(getArrayReadOp(t, arrayDim));
+ int dup_code = is2word(t, dim) ? DUP2_X2 : DUP_X2;
+ atPlusPlusCore(dup_code, doDup, token, isPost, expr);
+ bytecode.addOpcode(getArrayWriteOp(t, dim));
+ }
+
+ protected void atPlusPlusCore(int dup_code, boolean doDup,
+ int token, boolean isPost,
+ Expr expr) throws CompileError
+ {
+ int t = exprType;
+
+ if (doDup && isPost)
+ bytecode.addOpcode(dup_code);
+
+ if (t == INT || t == BYTE || t == CHAR || t == SHORT) {
+ bytecode.addIconst(1);
+ bytecode.addOpcode(token == PLUSPLUS ? IADD : ISUB);
+ exprType = INT;
+ }
+ else if (t == LONG) {
+ bytecode.addLconst((long)1);
+ bytecode.addOpcode(token == PLUSPLUS ? LADD : LSUB);
+ }
+ else if (t == FLOAT) {
+ bytecode.addFconst(1.0f);
+ bytecode.addOpcode(token == PLUSPLUS ? FADD : FSUB);
+ }
+ else if (t == DOUBLE) {
+ bytecode.addDconst(1.0);
+ bytecode.addOpcode(token == PLUSPLUS ? DADD : DSUB);
+ }
+ else
+ badType(expr);
+
+ if (doDup && !isPost)
+ bytecode.addOpcode(dup_code);
+ }
+
+ protected abstract void atFieldPlusPlus(int token, boolean isPost,
+ ASTree oprand, Expr expr, boolean doDup) throws CompileError;
+
+ public abstract void atMember(Member n) throws CompileError;
+
+ public void atVariable(Variable v) throws CompileError {
+ Declarator d = v.getDeclarator();
+ exprType = d.getType();
+ arrayDim = d.getArrayDim();
+ className = d.getClassName();
+ int var = getLocalVar(d);
+
+ if (arrayDim > 0)
+ bytecode.addAload(var);
+ else
+ switch (exprType) {
+ case CLASS :
+ bytecode.addAload(var);
+ break;
+ case LONG :
+ bytecode.addLload(var);
+ break;
+ case FLOAT :
+ bytecode.addFload(var);
+ break;
+ case DOUBLE :
+ bytecode.addDload(var);
+ break;
+ default : // BOOLEAN, BYTE, CHAR, SHORT, INT
+ bytecode.addIload(var);
+ break;
+ }
+ }
+
+ public void atKeyword(Keyword k) throws CompileError {
+ arrayDim = 0;
+ int token = k.get();
+ switch (token) {
+ case TRUE :
+ bytecode.addIconst(1);
+ exprType = BOOLEAN;
+ break;
+ case FALSE :
+ bytecode.addIconst(0);
+ exprType = BOOLEAN;
+ break;
+ case NULL :
+ bytecode.addOpcode(ACONST_NULL);
+ exprType = NULL;
+ break;
+ case THIS :
+ case SUPER :
+ if (inStaticMethod)
+ throw new CompileError("not-available: "
+ + (token == THIS ? "this" : "super"));
+
+ bytecode.addAload(0);
+ exprType = CLASS;
+ if (token == THIS)
+ className = getThisName();
+ else
+ className = getSuperName();
+ break;
+ default :
+ fatal();
+ }
+ }
+
+ public void atStringL(StringL s) throws CompileError {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangString;
+ bytecode.addLdc(s.get());
+ }
+
+ public void atIntConst(IntConst i) throws CompileError {
+ arrayDim = 0;
+ long value = i.get();
+ int type = i.getType();
+ if (type == IntConstant || type == CharConstant) {
+ exprType = (type == IntConstant ? INT : CHAR);
+ bytecode.addIconst((int)value);
+ }
+ else {
+ exprType = LONG;
+ bytecode.addLconst(value);
+ }
+ }
+
+ public void atDoubleConst(DoubleConst d) throws CompileError {
+ arrayDim = 0;
+ if (d.getType() == DoubleConstant) {
+ exprType = DOUBLE;
+ bytecode.addDconst(d.get());
+ }
+ else {
+ exprType = FLOAT;
+ bytecode.addFconst((float)d.get());
+ }
+ }
+}
diff --git a/src/main/javassist/compiler/CompileError.java b/src/main/javassist/compiler/CompileError.java
new file mode 100644
index 0000000..2756d15
--- /dev/null
+++ b/src/main/javassist/compiler/CompileError.java
@@ -0,0 +1,52 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.CannotCompileException;
+import javassist.NotFoundException;
+
+public class CompileError extends Exception {
+ private Lex lex;
+ private String reason;
+
+ public CompileError(String s, Lex l) {
+ reason = s;
+ lex = l;
+ }
+
+ public CompileError(String s) {
+ reason = s;
+ lex = null;
+ }
+
+ public CompileError(CannotCompileException e) {
+ this(e.getReason());
+ }
+
+ public CompileError(NotFoundException e) {
+ this("cannot find " + e.getMessage());
+ }
+
+ public Lex getLex() { return lex; }
+
+ public String getMessage() {
+ return reason;
+ }
+
+ public String toString() {
+ return "compile error: " + reason;
+ }
+}
diff --git a/src/main/javassist/compiler/Javac.java b/src/main/javassist/compiler/Javac.java
new file mode 100644
index 0000000..9314bbc
--- /dev/null
+++ b/src/main/javassist/compiler/Javac.java
@@ -0,0 +1,609 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.CtClass;
+import javassist.CtPrimitiveType;
+import javassist.CtMember;
+import javassist.CtField;
+import javassist.CtBehavior;
+import javassist.CtMethod;
+import javassist.CtConstructor;
+import javassist.CannotCompileException;
+import javassist.Modifier;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.LocalVariableAttribute;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Opcode;
+import javassist.NotFoundException;
+
+import javassist.compiler.ast.*;
+
+public class Javac {
+ JvstCodeGen gen;
+ SymbolTable stable;
+ private Bytecode bytecode;
+
+ public static final String param0Name = "$0";
+ public static final String resultVarName = "$_";
+ public static final String proceedName = "$proceed";
+
+ /**
+ * Constructs a compiler.
+ *
+ * @param thisClass the class that a compiled method/field
+ * belongs to.
+ */
+ public Javac(CtClass thisClass) {
+ this(new Bytecode(thisClass.getClassFile2().getConstPool(), 0, 0),
+ thisClass);
+ }
+
+ /**
+ * Constructs a compiler.
+ * The produced bytecode is stored in the <code>Bytecode</code> object
+ * specified by <code>b</code>.
+ *
+ * @param thisClass the class that a compiled method/field
+ * belongs to.
+ */
+ public Javac(Bytecode b, CtClass thisClass) {
+ gen = new JvstCodeGen(b, thisClass, thisClass.getClassPool());
+ stable = new SymbolTable();
+ bytecode = b;
+ }
+
+ /**
+ * Returns the produced bytecode.
+ */
+ public Bytecode getBytecode() { return bytecode; }
+
+ /**
+ * Compiles a method, constructor, or field declaration
+ * to a class.
+ * A field declaration can declare only one field.
+ *
+ * <p>In a method or constructor body, $0, $1, ... and $_
+ * are not available.
+ *
+ * @return a <code>CtMethod</code>, <code>CtConstructor</code>,
+ * or <code>CtField</code> object.
+ * @see #recordProceed(String,String)
+ */
+ public CtMember compile(String src) throws CompileError {
+ Parser p = new Parser(new Lex(src));
+ ASTList mem = p.parseMember1(stable);
+ try {
+ if (mem instanceof FieldDecl)
+ return compileField((FieldDecl)mem);
+ else {
+ CtBehavior cb = compileMethod(p, (MethodDecl)mem);
+ CtClass decl = cb.getDeclaringClass();
+ cb.getMethodInfo2()
+ .rebuildStackMapIf6(decl.getClassPool(),
+ decl.getClassFile2());
+ return cb;
+ }
+ }
+ catch (BadBytecode bb) {
+ throw new CompileError(bb.getMessage());
+ }
+ catch (CannotCompileException e) {
+ throw new CompileError(e.getMessage());
+ }
+ }
+
+ public static class CtFieldWithInit extends CtField {
+ private ASTree init;
+
+ CtFieldWithInit(CtClass type, String name, CtClass declaring)
+ throws CannotCompileException
+ {
+ super(type, name, declaring);
+ init = null;
+ }
+
+ protected void setInit(ASTree i) { init = i; }
+
+ protected ASTree getInitAST() {
+ return init;
+ }
+ }
+
+ private CtField compileField(FieldDecl fd)
+ throws CompileError, CannotCompileException
+ {
+ CtFieldWithInit f;
+ Declarator d = fd.getDeclarator();
+ f = new CtFieldWithInit(gen.resolver.lookupClass(d),
+ d.getVariable().get(), gen.getThisClass());
+ f.setModifiers(MemberResolver.getModifiers(fd.getModifiers()));
+ if (fd.getInit() != null)
+ f.setInit(fd.getInit());
+
+ return f;
+ }
+
+ private CtBehavior compileMethod(Parser p, MethodDecl md)
+ throws CompileError
+ {
+ int mod = MemberResolver.getModifiers(md.getModifiers());
+ CtClass[] plist = gen.makeParamList(md);
+ CtClass[] tlist = gen.makeThrowsList(md);
+ recordParams(plist, Modifier.isStatic(mod));
+ md = p.parseMethod2(stable, md);
+ try {
+ if (md.isConstructor()) {
+ CtConstructor cons = new CtConstructor(plist,
+ gen.getThisClass());
+ cons.setModifiers(mod);
+ md.accept(gen);
+ cons.getMethodInfo().setCodeAttribute(
+ bytecode.toCodeAttribute());
+ cons.setExceptionTypes(tlist);
+ return cons;
+ }
+ else {
+ Declarator r = md.getReturn();
+ CtClass rtype = gen.resolver.lookupClass(r);
+ recordReturnType(rtype, false);
+ CtMethod method = new CtMethod(rtype, r.getVariable().get(),
+ plist, gen.getThisClass());
+ method.setModifiers(mod);
+ gen.setThisMethod(method);
+ md.accept(gen);
+ if (md.getBody() != null)
+ method.getMethodInfo().setCodeAttribute(
+ bytecode.toCodeAttribute());
+ else
+ method.setModifiers(mod | Modifier.ABSTRACT);
+
+ method.setExceptionTypes(tlist);
+ return method;
+ }
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e.toString());
+ }
+ }
+
+ /**
+ * Compiles a method (or constructor) body.
+ *
+ * @src a single statement or a block.
+ * If null, this method produces a body returning zero or null.
+ */
+ public Bytecode compileBody(CtBehavior method, String src)
+ throws CompileError
+ {
+ try {
+ int mod = method.getModifiers();
+ recordParams(method.getParameterTypes(), Modifier.isStatic(mod));
+
+ CtClass rtype;
+ if (method instanceof CtMethod) {
+ gen.setThisMethod((CtMethod)method);
+ rtype = ((CtMethod)method).getReturnType();
+ }
+ else
+ rtype = CtClass.voidType;
+
+ recordReturnType(rtype, false);
+ boolean isVoid = rtype == CtClass.voidType;
+
+ if (src == null)
+ makeDefaultBody(bytecode, rtype);
+ else {
+ Parser p = new Parser(new Lex(src));
+ SymbolTable stb = new SymbolTable(stable);
+ Stmnt s = p.parseStatement(stb);
+ if (p.hasMore())
+ throw new CompileError(
+ "the method/constructor body must be surrounded by {}");
+
+ boolean callSuper = false;
+ if (method instanceof CtConstructor)
+ callSuper = !((CtConstructor)method).isClassInitializer();
+
+ gen.atMethodBody(s, callSuper, isVoid);
+ }
+
+ return bytecode;
+ }
+ catch (NotFoundException e) {
+ throw new CompileError(e.toString());
+ }
+ }
+
+ private static void makeDefaultBody(Bytecode b, CtClass type) {
+ int op;
+ int value;
+ if (type instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ op = pt.getReturnOp();
+ if (op == Opcode.DRETURN)
+ value = Opcode.DCONST_0;
+ else if (op == Opcode.FRETURN)
+ value = Opcode.FCONST_0;
+ else if (op == Opcode.LRETURN)
+ value = Opcode.LCONST_0;
+ else if (op == Opcode.RETURN)
+ value = Opcode.NOP;
+ else
+ value = Opcode.ICONST_0;
+ }
+ else {
+ op = Opcode.ARETURN;
+ value = Opcode.ACONST_NULL;
+ }
+
+ if (value != Opcode.NOP)
+ b.addOpcode(value);
+
+ b.addOpcode(op);
+ }
+
+ /**
+ * Records local variables available at the specified program counter.
+ * If the LocalVariableAttribute is not available, this method does not
+ * record any local variable. It only returns false.
+ *
+ * @param pc program counter (>= 0)
+ * @return false if the CodeAttribute does not include a
+ * LocalVariableAttribute.
+ */
+ public boolean recordLocalVariables(CodeAttribute ca, int pc)
+ throws CompileError
+ {
+ LocalVariableAttribute va
+ = (LocalVariableAttribute)
+ ca.getAttribute(LocalVariableAttribute.tag);
+ if (va == null)
+ return false;
+
+ int n = va.tableLength();
+ for (int i = 0; i < n; ++i) {
+ int start = va.startPc(i);
+ int len = va.codeLength(i);
+ if (start <= pc && pc < start + len)
+ gen.recordVariable(va.descriptor(i), va.variableName(i),
+ va.index(i), stable);
+ }
+
+ return true;
+ }
+
+ /**
+ * Records parameter names if the LocalVariableAttribute is available.
+ * It returns false unless the LocalVariableAttribute is available.
+ *
+ * @param numOfLocalVars the number of local variables used
+ * for storing the parameters.
+ * @return false if the CodeAttribute does not include a
+ * LocalVariableAttribute.
+ */
+ public boolean recordParamNames(CodeAttribute ca, int numOfLocalVars)
+ throws CompileError
+ {
+ LocalVariableAttribute va
+ = (LocalVariableAttribute)
+ ca.getAttribute(LocalVariableAttribute.tag);
+ if (va == null)
+ return false;
+
+ int n = va.tableLength();
+ for (int i = 0; i < n; ++i) {
+ int index = va.index(i);
+ if (index < numOfLocalVars)
+ gen.recordVariable(va.descriptor(i), va.variableName(i),
+ index, stable);
+ }
+
+ return true;
+ }
+
+
+ /**
+ * Makes variables $0 (this), $1, $2, ..., and $args represent method
+ * parameters. $args represents an array of all the parameters.
+ * It also makes $$ available as a parameter list of method call.
+ *
+ * <p>This must be called before calling <code>compileStmnt()</code> and
+ * <code>compileExpr()</code>. The correct value of
+ * <code>isStatic</code> must be recorded before compilation.
+ * <code>maxLocals</code> is updated to include $0,...
+ */
+ public int recordParams(CtClass[] params, boolean isStatic)
+ throws CompileError
+ {
+ return gen.recordParams(params, isStatic, "$", "$args", "$$", stable);
+ }
+
+ /**
+ * Makes variables $0, $1, $2, ..., and $args represent method
+ * parameters. $args represents an array of all the parameters.
+ * It also makes $$ available as a parameter list of method call.
+ * $0 can represent a local variable other than THIS (variable 0).
+ * $class is also made available.
+ *
+ * <p>This must be called before calling <code>compileStmnt()</code> and
+ * <code>compileExpr()</code>. The correct value of
+ * <code>isStatic</code> must be recorded before compilation.
+ * <code>maxLocals</code> is updated to include $0,...
+ *
+ * @paaram use0 true if $0 is used.
+ * @param varNo the register number of $0 (use0 is true)
+ * or $1 (otherwise).
+ * @param target the type of $0 (it can be null if use0 is false).
+ * It is used as the name of the type represented
+ * by $class.
+ * @param isStatic true if the method in which the compiled bytecode
+ * is embedded is static.
+ */
+ public int recordParams(String target, CtClass[] params,
+ boolean use0, int varNo, boolean isStatic)
+ throws CompileError
+ {
+ return gen.recordParams(params, isStatic, "$", "$args", "$$",
+ use0, varNo, target, stable);
+ }
+
+ /**
+ * Sets <code>maxLocals</code> to <code>max</code>.
+ * This method tells the compiler the local variables that have been
+ * allocated for the rest of the code. When the compiler needs
+ * new local variables, the local variables at the index <code>max</code>,
+ * <code>max + 1</code>, ... are assigned.
+ *
+ * <p>This method is indirectly called by <code>recordParams</code>.
+ */
+ public void setMaxLocals(int max) {
+ gen.setMaxLocals(max);
+ }
+
+ /**
+ * Prepares to use cast $r, $w, $_, and $type.
+ * $type is made to represent the specified return type.
+ * It also enables to write a return statement with a return value
+ * for void method.
+ *
+ * <p>If the return type is void, ($r) does nothing.
+ * The type of $_ is java.lang.Object.
+ *
+ * @param type the return type.
+ * @param useResultVar true if $_ is used.
+ * @return -1 or the variable index assigned to $_.
+ * @see #recordType(CtClass)
+ */
+ public int recordReturnType(CtClass type, boolean useResultVar)
+ throws CompileError
+ {
+ gen.recordType(type);
+ return gen.recordReturnType(type, "$r",
+ (useResultVar ? resultVarName : null), stable);
+ }
+
+ /**
+ * Prepares to use $type. Note that recordReturnType() overwrites
+ * the value of $type.
+ *
+ * @param t the type represented by $type.
+ */
+ public void recordType(CtClass t) {
+ gen.recordType(t);
+ }
+
+ /**
+ * Makes the given variable available.
+ *
+ * @param type variable type
+ * @param name variable name
+ */
+ public int recordVariable(CtClass type, String name)
+ throws CompileError
+ {
+ return gen.recordVariable(type, name, stable);
+ }
+
+ /**
+ * Prepares to use $proceed().
+ * If the return type of $proceed() is void, null is pushed on the
+ * stack.
+ *
+ * @param target an expression specifying the target object.
+ * if null, "this" is the target.
+ * @param method the method name.
+ */
+ public void recordProceed(String target, String method)
+ throws CompileError
+ {
+ Parser p = new Parser(new Lex(target));
+ final ASTree texpr = p.parseExpression(stable);
+ final String m = method;
+
+ ProceedHandler h = new ProceedHandler() {
+ public void doit(JvstCodeGen gen, Bytecode b, ASTList args)
+ throws CompileError
+ {
+ ASTree expr = new Member(m);
+ if (texpr != null)
+ expr = Expr.make('.', texpr, expr);
+
+ expr = CallExpr.makeCall(expr, args);
+ gen.compileExpr(expr);
+ gen.addNullIfVoid();
+ }
+
+ public void setReturnType(JvstTypeChecker check, ASTList args)
+ throws CompileError
+ {
+ ASTree expr = new Member(m);
+ if (texpr != null)
+ expr = Expr.make('.', texpr, expr);
+
+ expr = CallExpr.makeCall(expr, args);
+ expr.accept(check);
+ check.addNullIfVoid();
+ }
+ };
+
+ gen.setProceedHandler(h, proceedName);
+ }
+
+ /**
+ * Prepares to use $proceed() representing a static method.
+ * If the return type of $proceed() is void, null is pushed on the
+ * stack.
+ *
+ * @param targetClass the fully-qualified dot-separated name
+ * of the class declaring the method.
+ * @param method the method name.
+ */
+ public void recordStaticProceed(String targetClass, String method)
+ throws CompileError
+ {
+ final String c = targetClass;
+ final String m = method;
+
+ ProceedHandler h = new ProceedHandler() {
+ public void doit(JvstCodeGen gen, Bytecode b, ASTList args)
+ throws CompileError
+ {
+ Expr expr = Expr.make(TokenId.MEMBER,
+ new Symbol(c), new Member(m));
+ expr = CallExpr.makeCall(expr, args);
+ gen.compileExpr(expr);
+ gen.addNullIfVoid();
+ }
+
+ public void setReturnType(JvstTypeChecker check, ASTList args)
+ throws CompileError
+ {
+ Expr expr = Expr.make(TokenId.MEMBER,
+ new Symbol(c), new Member(m));
+ expr = CallExpr.makeCall(expr, args);
+ expr.accept(check);
+ check.addNullIfVoid();
+ }
+ };
+
+ gen.setProceedHandler(h, proceedName);
+ }
+
+ /**
+ * Prepares to use $proceed() representing a private/super's method.
+ * If the return type of $proceed() is void, null is pushed on the
+ * stack. This method is for methods invoked by INVOKESPECIAL.
+ *
+ * @param target an expression specifying the target object.
+ * if null, "this" is the target.
+ * @param classname the class name declaring the method.
+ * @param methodname the method name.
+ * @param descriptor the method descriptor.
+ */
+ public void recordSpecialProceed(String target, String classname,
+ String methodname, String descriptor)
+ throws CompileError
+ {
+ Parser p = new Parser(new Lex(target));
+ final ASTree texpr = p.parseExpression(stable);
+ final String cname = classname;
+ final String method = methodname;
+ final String desc = descriptor;
+
+ ProceedHandler h = new ProceedHandler() {
+ public void doit(JvstCodeGen gen, Bytecode b, ASTList args)
+ throws CompileError
+ {
+ gen.compileInvokeSpecial(texpr, cname, method, desc, args);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.compileInvokeSpecial(texpr, cname, method, desc, args);
+ }
+
+ };
+
+ gen.setProceedHandler(h, proceedName);
+ }
+
+ /**
+ * Prepares to use $proceed().
+ */
+ public void recordProceed(ProceedHandler h) {
+ gen.setProceedHandler(h, proceedName);
+ }
+
+ /**
+ * Compiles a statement (or a block).
+ * <code>recordParams()</code> must be called before invoking
+ * this method.
+ *
+ * <p>Local variables that are not declared
+ * in the compiled source text might not be accessible within that
+ * source text. Fields and method parameters ($0, $1, ..) are available.
+ */
+ public void compileStmnt(String src) throws CompileError {
+ Parser p = new Parser(new Lex(src));
+ SymbolTable stb = new SymbolTable(stable);
+ while (p.hasMore()) {
+ Stmnt s = p.parseStatement(stb);
+ if (s != null)
+ s.accept(gen);
+ }
+ }
+
+ /**
+ * Compiles an exression. <code>recordParams()</code> must be
+ * called before invoking this method.
+ *
+ * <p>Local variables are not accessible
+ * within the compiled source text. Fields and method parameters
+ * ($0, $1, ..) are available if <code>recordParams()</code>
+ * have been invoked.
+ */
+ public void compileExpr(String src) throws CompileError {
+ ASTree e = parseExpr(src, stable);
+ compileExpr(e);
+ }
+
+ /**
+ * Parsers an expression.
+ */
+ public static ASTree parseExpr(String src, SymbolTable st)
+ throws CompileError
+ {
+ Parser p = new Parser(new Lex(src));
+ return p.parseExpression(st);
+ }
+
+ /**
+ * Compiles an exression. <code>recordParams()</code> must be
+ * called before invoking this method.
+ *
+ * <p>Local variables are not accessible
+ * within the compiled source text. Fields and method parameters
+ * ($0, $1, ..) are available if <code>recordParams()</code>
+ * have been invoked.
+ */
+ public void compileExpr(ASTree e) throws CompileError {
+ if (e != null)
+ gen.compileExpr(e);
+ }
+}
diff --git a/src/main/javassist/compiler/JvstCodeGen.java b/src/main/javassist/compiler/JvstCodeGen.java
new file mode 100644
index 0000000..91b0eca
--- /dev/null
+++ b/src/main/javassist/compiler/JvstCodeGen.java
@@ -0,0 +1,709 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.ast.*;
+
+/* Code generator accepting extended Java syntax for Javassist.
+ */
+
+public class JvstCodeGen extends MemberCodeGen {
+ String paramArrayName = null;
+ String paramListName = null;
+ CtClass[] paramTypeList = null;
+ private int paramVarBase = 0; // variable index for $0 or $1.
+ private boolean useParam0 = false; // true if $0 is used.
+ private String param0Type = null; // JVM name
+ public static final String sigName = "$sig";
+ public static final String dollarTypeName = "$type";
+ public static final String clazzName = "$class";
+ private CtClass dollarType = null;
+ CtClass returnType = null;
+ String returnCastName = null;
+ private String returnVarName = null; // null if $_ is not used.
+ public static final String wrapperCastName = "$w";
+ String proceedName = null;
+ public static final String cflowName = "$cflow";
+ ProceedHandler procHandler = null; // null if not used.
+
+ public JvstCodeGen(Bytecode b, CtClass cc, ClassPool cp) {
+ super(b, cc, cp);
+ setTypeChecker(new JvstTypeChecker(cc, cp, this));
+ }
+
+ /* Index of $1.
+ */
+ private int indexOfParam1() {
+ return paramVarBase + (useParam0 ? 1 : 0);
+ }
+
+ /* Records a ProceedHandler obejct.
+ *
+ * @param name the name of the special method call.
+ * it is usually $proceed.
+ */
+ public void setProceedHandler(ProceedHandler h, String name) {
+ proceedName = name;
+ procHandler = h;
+ }
+
+ /* If the type of the expression compiled last is void,
+ * add ACONST_NULL and change exprType, arrayDim, className.
+ */
+ public void addNullIfVoid() {
+ if (exprType == VOID) {
+ bytecode.addOpcode(ACONST_NULL);
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangObject;
+ }
+ }
+
+ /* To support $args, $sig, and $type.
+ * $args is an array of parameter list.
+ */
+ public void atMember(Member mem) throws CompileError {
+ String name = mem.get();
+ if (name.equals(paramArrayName)) {
+ compileParameterList(bytecode, paramTypeList, indexOfParam1());
+ exprType = CLASS;
+ arrayDim = 1;
+ className = jvmJavaLangObject;
+ }
+ else if (name.equals(sigName)) {
+ bytecode.addLdc(Descriptor.ofMethod(returnType, paramTypeList));
+ bytecode.addInvokestatic("javassist/runtime/Desc", "getParams",
+ "(Ljava/lang/String;)[Ljava/lang/Class;");
+ exprType = CLASS;
+ arrayDim = 1;
+ className = "java/lang/Class";
+ }
+ else if (name.equals(dollarTypeName)) {
+ if (dollarType == null)
+ throw new CompileError(dollarTypeName + " is not available");
+
+ bytecode.addLdc(Descriptor.of(dollarType));
+ callGetType("getType");
+ }
+ else if (name.equals(clazzName)) {
+ if (param0Type == null)
+ throw new CompileError(clazzName + " is not available");
+
+ bytecode.addLdc(param0Type);
+ callGetType("getClazz");
+ }
+ else
+ super.atMember(mem);
+ }
+
+ private void callGetType(String method) {
+ bytecode.addInvokestatic("javassist/runtime/Desc", method,
+ "(Ljava/lang/String;)Ljava/lang/Class;");
+ exprType = CLASS;
+ arrayDim = 0;
+ className = "java/lang/Class";
+ }
+
+ protected void atFieldAssign(Expr expr, int op, ASTree left,
+ ASTree right, boolean doDup) throws CompileError
+ {
+ if (left instanceof Member
+ && ((Member)left).get().equals(paramArrayName)) {
+ if (op != '=')
+ throw new CompileError("bad operator for " + paramArrayName);
+
+ right.accept(this);
+ if (arrayDim != 1 || exprType != CLASS)
+ throw new CompileError("invalid type for " + paramArrayName);
+
+ atAssignParamList(paramTypeList, bytecode);
+ if (!doDup)
+ bytecode.addOpcode(POP);
+ }
+ else
+ super.atFieldAssign(expr, op, left, right, doDup);
+ }
+
+ protected void atAssignParamList(CtClass[] params, Bytecode code)
+ throws CompileError
+ {
+ if (params == null)
+ return;
+
+ int varNo = indexOfParam1();
+ int n = params.length;
+ for (int i = 0; i < n; ++i) {
+ code.addOpcode(DUP);
+ code.addIconst(i);
+ code.addOpcode(AALOAD);
+ compileUnwrapValue(params[i], code);
+ code.addStore(varNo, params[i]);
+ varNo += is2word(exprType, arrayDim) ? 2 : 1;
+ }
+ }
+
+ public void atCastExpr(CastExpr expr) throws CompileError {
+ ASTList classname = expr.getClassName();
+ if (classname != null && expr.getArrayDim() == 0) {
+ ASTree p = classname.head();
+ if (p instanceof Symbol && classname.tail() == null) {
+ String typename = ((Symbol)p).get();
+ if (typename.equals(returnCastName)) {
+ atCastToRtype(expr);
+ return;
+ }
+ else if (typename.equals(wrapperCastName)) {
+ atCastToWrapper(expr);
+ return;
+ }
+ }
+ }
+
+ super.atCastExpr(expr);
+ }
+
+ /**
+ * Inserts a cast operator to the return type.
+ * If the return type is void, this does nothing.
+ */
+ protected void atCastToRtype(CastExpr expr) throws CompileError {
+ expr.getOprand().accept(this);
+ if (exprType == VOID || isRefType(exprType) || arrayDim > 0)
+ compileUnwrapValue(returnType, bytecode);
+ else if (returnType instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)returnType;
+ int destType = MemberResolver.descToType(pt.getDescriptor());
+ atNumCastExpr(exprType, destType);
+ exprType = destType;
+ arrayDim = 0;
+ className = null;
+ }
+ else
+ throw new CompileError("invalid cast");
+ }
+
+ protected void atCastToWrapper(CastExpr expr) throws CompileError {
+ expr.getOprand().accept(this);
+ if (isRefType(exprType) || arrayDim > 0)
+ return; // Object type. do nothing.
+
+ CtClass clazz = resolver.lookupClass(exprType, arrayDim, className);
+ if (clazz instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)clazz;
+ String wrapper = pt.getWrapperName();
+ bytecode.addNew(wrapper); // new <wrapper>
+ bytecode.addOpcode(DUP); // dup
+ if (pt.getDataSize() > 1)
+ bytecode.addOpcode(DUP2_X2); // dup2_x2
+ else
+ bytecode.addOpcode(DUP2_X1); // dup2_x1
+
+ bytecode.addOpcode(POP2); // pop2
+ bytecode.addInvokespecial(wrapper, "<init>",
+ "(" + pt.getDescriptor() + ")V");
+ // invokespecial
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangObject;
+ }
+ }
+
+ /* Delegates to a ProcHandler object if the method call is
+ * $proceed(). It may process $cflow().
+ */
+ public void atCallExpr(CallExpr expr) throws CompileError {
+ ASTree method = expr.oprand1();
+ if (method instanceof Member) {
+ String name = ((Member)method).get();
+ if (procHandler != null && name.equals(proceedName)) {
+ procHandler.doit(this, bytecode, (ASTList)expr.oprand2());
+ return;
+ }
+ else if (name.equals(cflowName)) {
+ atCflow((ASTList)expr.oprand2());
+ return;
+ }
+ }
+
+ super.atCallExpr(expr);
+ }
+
+ /* To support $cflow().
+ */
+ protected void atCflow(ASTList cname) throws CompileError {
+ StringBuffer sbuf = new StringBuffer();
+ if (cname == null || cname.tail() != null)
+ throw new CompileError("bad " + cflowName);
+
+ makeCflowName(sbuf, cname.head());
+ String name = sbuf.toString();
+ Object[] names = resolver.getClassPool().lookupCflow(name);
+ if (names == null)
+ throw new CompileError("no such " + cflowName + ": " + name);
+
+ bytecode.addGetstatic((String)names[0], (String)names[1],
+ "Ljavassist/runtime/Cflow;");
+ bytecode.addInvokevirtual("javassist.runtime.Cflow",
+ "value", "()I");
+ exprType = INT;
+ arrayDim = 0;
+ className = null;
+ }
+
+ /* Syntax:
+ *
+ * <cflow> : $cflow '(' <cflow name> ')'
+ * <cflow name> : <identifier> ('.' <identifier>)*
+ */
+ private static void makeCflowName(StringBuffer sbuf, ASTree name)
+ throws CompileError
+ {
+ if (name instanceof Symbol) {
+ sbuf.append(((Symbol)name).get());
+ return;
+ }
+ else if (name instanceof Expr) {
+ Expr expr = (Expr)name;
+ if (expr.getOperator() == '.') {
+ makeCflowName(sbuf, expr.oprand1());
+ sbuf.append('.');
+ makeCflowName(sbuf, expr.oprand2());
+ return;
+ }
+ }
+
+ throw new CompileError("bad " + cflowName);
+ }
+
+ /* To support $$. ($$) is equivalent to ($1, ..., $n).
+ * It can be used only as a parameter list of method call.
+ */
+ public boolean isParamListName(ASTList args) {
+ if (paramTypeList != null
+ && args != null && args.tail() == null) {
+ ASTree left = args.head();
+ return (left instanceof Member
+ && ((Member)left).get().equals(paramListName));
+ }
+ else
+ return false;
+ }
+
+ /*
+ public int getMethodArgsLength(ASTList args) {
+ if (!isParamListName(args))
+ return super.getMethodArgsLength(args);
+
+ return paramTypeList.length;
+ }
+ */
+
+ public int getMethodArgsLength(ASTList args) {
+ String pname = paramListName;
+ int n = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ if (a instanceof Member && ((Member)a).get().equals(pname)) {
+ if (paramTypeList != null)
+ n += paramTypeList.length;
+ }
+ else
+ ++n;
+
+ args = args.tail();
+ }
+
+ return n;
+ }
+
+ public void atMethodArgs(ASTList args, int[] types, int[] dims,
+ String[] cnames) throws CompileError {
+ CtClass[] params = paramTypeList;
+ String pname = paramListName;
+ int i = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ if (a instanceof Member && ((Member)a).get().equals(pname)) {
+ if (params != null) {
+ int n = params.length;
+ int regno = indexOfParam1();
+ for (int k = 0; k < n; ++k) {
+ CtClass p = params[k];
+ regno += bytecode.addLoad(regno, p);
+ setType(p);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ }
+ }
+ }
+ else {
+ a.accept(this);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ }
+
+ args = args.tail();
+ }
+ }
+
+ /*
+ public void atMethodArgs(ASTList args, int[] types, int[] dims,
+ String[] cnames) throws CompileError {
+ if (!isParamListName(args)) {
+ super.atMethodArgs(args, types, dims, cnames);
+ return;
+ }
+
+ CtClass[] params = paramTypeList;
+ if (params == null)
+ return;
+
+ int n = params.length;
+ int regno = indexOfParam1();
+ for (int i = 0; i < n; ++i) {
+ CtClass p = params[i];
+ regno += bytecode.addLoad(regno, p);
+ setType(p);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ }
+ }
+ */
+
+ /* called by Javac#recordSpecialProceed().
+ */
+ void compileInvokeSpecial(ASTree target, String classname,
+ String methodname, String descriptor,
+ ASTList args)
+ throws CompileError
+ {
+ target.accept(this);
+ int nargs = getMethodArgsLength(args);
+ atMethodArgs(args, new int[nargs], new int[nargs],
+ new String[nargs]);
+ bytecode.addInvokespecial(classname, methodname, descriptor);
+ setReturnType(descriptor, false, false);
+ addNullIfVoid();
+ }
+
+ /*
+ * Makes it valid to write "return <expr>;" for a void method.
+ */
+ protected void atReturnStmnt(Stmnt st) throws CompileError {
+ ASTree result = st.getLeft();
+ if (result != null && returnType == CtClass.voidType) {
+ compileExpr(result);
+ if (is2word(exprType, arrayDim))
+ bytecode.addOpcode(POP2);
+ else if (exprType != VOID)
+ bytecode.addOpcode(POP);
+
+ result = null;
+ }
+
+ atReturnStmnt2(result);
+ }
+
+ /**
+ * Makes a cast to the return type ($r) available.
+ * It also enables $_.
+ *
+ * <p>If the return type is void, ($r) does nothing.
+ * The type of $_ is java.lang.Object.
+ *
+ * @param resultName null if $_ is not used.
+ * @return -1 or the variable index assigned to $_.
+ */
+ public int recordReturnType(CtClass type, String castName,
+ String resultName, SymbolTable tbl) throws CompileError
+ {
+ returnType = type;
+ returnCastName = castName;
+ returnVarName = resultName;
+ if (resultName == null)
+ return -1;
+ else {
+ int varNo = getMaxLocals();
+ int locals = varNo + recordVar(type, resultName, varNo, tbl);
+ setMaxLocals(locals);
+ return varNo;
+ }
+ }
+
+ /**
+ * Makes $type available.
+ */
+ public void recordType(CtClass t) {
+ dollarType = t;
+ }
+
+ /**
+ * Makes method parameters $0, $1, ..., $args, $$, and $class available.
+ * $0 is equivalent to THIS if the method is not static. Otherwise,
+ * if the method is static, then $0 is not available.
+ */
+ public int recordParams(CtClass[] params, boolean isStatic,
+ String prefix, String paramVarName,
+ String paramsName, SymbolTable tbl)
+ throws CompileError
+ {
+ return recordParams(params, isStatic, prefix, paramVarName,
+ paramsName, !isStatic, 0, getThisName(), tbl);
+ }
+
+ /**
+ * Makes method parameters $0, $1, ..., $args, $$, and $class available.
+ * $0 is available only if use0 is true. It might not be equivalent
+ * to THIS.
+ *
+ * @param params the parameter types (the types of $1, $2, ..)
+ * @param prefix it must be "$" (the first letter of $0, $1, ...)
+ * @param paramVarName it must be "$args"
+ * @param paramsName it must be "$$"
+ * @param use0 true if $0 is used.
+ * @param paramBase the register number of $0 (use0 is true)
+ * or $1 (otherwise).
+ * @param target the class of $0. If use0 is false, target
+ * can be null. The value of "target" is also used
+ * as the name of the type represented by $class.
+ * @param isStatic true if the method in which the compiled bytecode
+ * is embedded is static.
+ */
+ public int recordParams(CtClass[] params, boolean isStatic,
+ String prefix, String paramVarName,
+ String paramsName, boolean use0,
+ int paramBase, String target,
+ SymbolTable tbl)
+ throws CompileError
+ {
+ int varNo;
+
+ paramTypeList = params;
+ paramArrayName = paramVarName;
+ paramListName = paramsName;
+ paramVarBase = paramBase;
+ useParam0 = use0;
+
+ if (target != null)
+ param0Type = MemberResolver.jvmToJavaName(target);
+
+ inStaticMethod = isStatic;
+ varNo = paramBase;
+ if (use0) {
+ String varName = prefix + "0";
+ Declarator decl
+ = new Declarator(CLASS, MemberResolver.javaToJvmName(target),
+ 0, varNo++, new Symbol(varName));
+ tbl.append(varName, decl);
+ }
+
+ for (int i = 0; i < params.length; ++i)
+ varNo += recordVar(params[i], prefix + (i + 1), varNo, tbl);
+
+ if (getMaxLocals() < varNo)
+ setMaxLocals(varNo);
+
+ return varNo;
+ }
+
+ /**
+ * Makes the given variable name available.
+ *
+ * @param type variable type
+ * @param varName variable name
+ */
+ public int recordVariable(CtClass type, String varName, SymbolTable tbl)
+ throws CompileError
+ {
+ if (varName == null)
+ return -1;
+ else {
+ int varNo = getMaxLocals();
+ int locals = varNo + recordVar(type, varName, varNo, tbl);
+ setMaxLocals(locals);
+ return varNo;
+ }
+ }
+
+ private int recordVar(CtClass cc, String varName, int varNo,
+ SymbolTable tbl) throws CompileError
+ {
+ if (cc == CtClass.voidType) {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangObject;
+ }
+ else
+ setType(cc);
+
+ Declarator decl
+ = new Declarator(exprType, className, arrayDim,
+ varNo, new Symbol(varName));
+ tbl.append(varName, decl);
+ return is2word(exprType, arrayDim) ? 2 : 1;
+ }
+
+ /**
+ * Makes the given variable name available.
+ *
+ * @param typeDesc the type descriptor of the variable
+ * @param varName variable name
+ * @param varNo an index into the local variable array
+ */
+ public void recordVariable(String typeDesc, String varName, int varNo,
+ SymbolTable tbl) throws CompileError
+ {
+ char c;
+ int dim = 0;
+ while ((c = typeDesc.charAt(dim)) == '[')
+ ++dim;
+
+ int type = MemberResolver.descToType(c);
+ String cname = null;
+ if (type == CLASS) {
+ if (dim == 0)
+ cname = typeDesc.substring(1, typeDesc.length() - 1);
+ else
+ cname = typeDesc.substring(dim + 1, typeDesc.length() - 1);
+ }
+
+ Declarator decl
+ = new Declarator(type, cname, dim, varNo, new Symbol(varName));
+ tbl.append(varName, decl);
+ }
+
+ /* compileParameterList() returns the stack size used
+ * by the produced code.
+ *
+ * This method correctly computes the max_stack value.
+ *
+ * @param regno the index of the local variable in which
+ * the first argument is received.
+ * (0: static method, 1: regular method.)
+ */
+ public static int compileParameterList(Bytecode code,
+ CtClass[] params, int regno) {
+ if (params == null) {
+ code.addIconst(0); // iconst_0
+ code.addAnewarray(javaLangObject); // anewarray Object
+ return 1;
+ }
+ else {
+ CtClass[] args = new CtClass[1];
+ int n = params.length;
+ code.addIconst(n); // iconst_<n>
+ code.addAnewarray(javaLangObject); // anewarray Object
+ for (int i = 0; i < n; ++i) {
+ code.addOpcode(Bytecode.DUP); // dup
+ code.addIconst(i); // iconst_<i>
+ if (params[i].isPrimitive()) {
+ CtPrimitiveType pt = (CtPrimitiveType)params[i];
+ String wrapper = pt.getWrapperName();
+ code.addNew(wrapper); // new <wrapper>
+ code.addOpcode(Bytecode.DUP); // dup
+ int s = code.addLoad(regno, pt); // ?load <regno>
+ regno += s;
+ args[0] = pt;
+ code.addInvokespecial(wrapper, "<init>",
+ Descriptor.ofMethod(CtClass.voidType, args));
+ // invokespecial
+ }
+ else {
+ code.addAload(regno); // aload <regno>
+ ++regno;
+ }
+
+ code.addOpcode(Bytecode.AASTORE); // aastore
+ }
+
+ return 8;
+ }
+ }
+
+ protected void compileUnwrapValue(CtClass type, Bytecode code)
+ throws CompileError
+ {
+ if (type == CtClass.voidType) {
+ addNullIfVoid();
+ return;
+ }
+
+ if (exprType == VOID)
+ throw new CompileError("invalid type for " + returnCastName);
+
+ if (type instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ // pt is not voidType.
+ String wrapper = pt.getWrapperName();
+ code.addCheckcast(wrapper);
+ code.addInvokevirtual(wrapper, pt.getGetMethodName(),
+ pt.getGetMethodDescriptor());
+ setType(type);
+ }
+ else {
+ code.addCheckcast(type);
+ setType(type);
+ }
+ }
+
+ /* Sets exprType, arrayDim, and className;
+ * If type is void, then this method does nothing.
+ */
+ public void setType(CtClass type) throws CompileError {
+ setType(type, 0);
+ }
+
+ private void setType(CtClass type, int dim) throws CompileError {
+ if (type.isPrimitive()) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ exprType = MemberResolver.descToType(pt.getDescriptor());
+ arrayDim = dim;
+ className = null;
+ }
+ else if (type.isArray())
+ try {
+ setType(type.getComponentType(), dim + 1);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError("undefined type: " + type.getName());
+ }
+ else {
+ exprType = CLASS;
+ arrayDim = dim;
+ className = MemberResolver.javaToJvmName(type.getName());
+ }
+ }
+
+ /* Performs implicit coercion from exprType to type.
+ */
+ public void doNumCast(CtClass type) throws CompileError {
+ if (arrayDim == 0 && !isRefType(exprType))
+ if (type instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ atNumCastExpr(exprType,
+ MemberResolver.descToType(pt.getDescriptor()));
+ }
+ else
+ throw new CompileError("type mismatch");
+ }
+}
diff --git a/src/main/javassist/compiler/JvstTypeChecker.java b/src/main/javassist/compiler/JvstTypeChecker.java
new file mode 100644
index 0000000..d88909e
--- /dev/null
+++ b/src/main/javassist/compiler/JvstTypeChecker.java
@@ -0,0 +1,281 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.*;
+import javassist.compiler.ast.*;
+
+/* Type checker accepting extended Java syntax for Javassist.
+ */
+
+public class JvstTypeChecker extends TypeChecker {
+ private JvstCodeGen codeGen;
+
+ public JvstTypeChecker(CtClass cc, ClassPool cp, JvstCodeGen gen) {
+ super(cc, cp);
+ codeGen = gen;
+ }
+
+ /* If the type of the expression compiled last is void,
+ * add ACONST_NULL and change exprType, arrayDim, className.
+ */
+ public void addNullIfVoid() {
+ if (exprType == VOID) {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangObject;
+ }
+ }
+
+ /* To support $args, $sig, and $type.
+ * $args is an array of parameter list.
+ */
+ public void atMember(Member mem) throws CompileError {
+ String name = mem.get();
+ if (name.equals(codeGen.paramArrayName)) {
+ exprType = CLASS;
+ arrayDim = 1;
+ className = jvmJavaLangObject;
+ }
+ else if (name.equals(JvstCodeGen.sigName)) {
+ exprType = CLASS;
+ arrayDim = 1;
+ className = "java/lang/Class";
+ }
+ else if (name.equals(JvstCodeGen.dollarTypeName)
+ || name.equals(JvstCodeGen.clazzName)) {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = "java/lang/Class";
+ }
+ else
+ super.atMember(mem);
+ }
+
+ protected void atFieldAssign(Expr expr, int op, ASTree left, ASTree right)
+ throws CompileError
+ {
+ if (left instanceof Member
+ && ((Member)left).get().equals(codeGen.paramArrayName)) {
+ right.accept(this);
+ CtClass[] params = codeGen.paramTypeList;
+ if (params == null)
+ return;
+
+ int n = params.length;
+ for (int i = 0; i < n; ++i)
+ compileUnwrapValue(params[i]);
+ }
+ else
+ super.atFieldAssign(expr, op, left, right);
+ }
+
+ public void atCastExpr(CastExpr expr) throws CompileError {
+ ASTList classname = expr.getClassName();
+ if (classname != null && expr.getArrayDim() == 0) {
+ ASTree p = classname.head();
+ if (p instanceof Symbol && classname.tail() == null) {
+ String typename = ((Symbol)p).get();
+ if (typename.equals(codeGen.returnCastName)) {
+ atCastToRtype(expr);
+ return;
+ }
+ else if (typename.equals(JvstCodeGen.wrapperCastName)) {
+ atCastToWrapper(expr);
+ return;
+ }
+ }
+ }
+
+ super.atCastExpr(expr);
+ }
+
+ /**
+ * Inserts a cast operator to the return type.
+ * If the return type is void, this does nothing.
+ */
+ protected void atCastToRtype(CastExpr expr) throws CompileError {
+ CtClass returnType = codeGen.returnType;
+ expr.getOprand().accept(this);
+ if (exprType == VOID || CodeGen.isRefType(exprType) || arrayDim > 0)
+ compileUnwrapValue(returnType);
+ else if (returnType instanceof CtPrimitiveType) {
+ CtPrimitiveType pt = (CtPrimitiveType)returnType;
+ int destType = MemberResolver.descToType(pt.getDescriptor());
+ exprType = destType;
+ arrayDim = 0;
+ className = null;
+ }
+ }
+
+ protected void atCastToWrapper(CastExpr expr) throws CompileError {
+ expr.getOprand().accept(this);
+ if (CodeGen.isRefType(exprType) || arrayDim > 0)
+ return; // Object type. do nothing.
+
+ CtClass clazz = resolver.lookupClass(exprType, arrayDim, className);
+ if (clazz instanceof CtPrimitiveType) {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangObject;
+ }
+ }
+
+ /* Delegates to a ProcHandler object if the method call is
+ * $proceed(). It may process $cflow().
+ */
+ public void atCallExpr(CallExpr expr) throws CompileError {
+ ASTree method = expr.oprand1();
+ if (method instanceof Member) {
+ String name = ((Member)method).get();
+ if (codeGen.procHandler != null
+ && name.equals(codeGen.proceedName)) {
+ codeGen.procHandler.setReturnType(this,
+ (ASTList)expr.oprand2());
+ return;
+ }
+ else if (name.equals(JvstCodeGen.cflowName)) {
+ atCflow((ASTList)expr.oprand2());
+ return;
+ }
+ }
+
+ super.atCallExpr(expr);
+ }
+
+ /* To support $cflow().
+ */
+ protected void atCflow(ASTList cname) throws CompileError {
+ exprType = INT;
+ arrayDim = 0;
+ className = null;
+ }
+
+ /* To support $$. ($$) is equivalent to ($1, ..., $n).
+ * It can be used only as a parameter list of method call.
+ */
+ public boolean isParamListName(ASTList args) {
+ if (codeGen.paramTypeList != null
+ && args != null && args.tail() == null) {
+ ASTree left = args.head();
+ return (left instanceof Member
+ && ((Member)left).get().equals(codeGen.paramListName));
+ }
+ else
+ return false;
+ }
+
+ public int getMethodArgsLength(ASTList args) {
+ String pname = codeGen.paramListName;
+ int n = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ if (a instanceof Member && ((Member)a).get().equals(pname)) {
+ if (codeGen.paramTypeList != null)
+ n += codeGen.paramTypeList.length;
+ }
+ else
+ ++n;
+
+ args = args.tail();
+ }
+
+ return n;
+ }
+
+ public void atMethodArgs(ASTList args, int[] types, int[] dims,
+ String[] cnames) throws CompileError {
+ CtClass[] params = codeGen.paramTypeList;
+ String pname = codeGen.paramListName;
+ int i = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ if (a instanceof Member && ((Member)a).get().equals(pname)) {
+ if (params != null) {
+ int n = params.length;
+ for (int k = 0; k < n; ++k) {
+ CtClass p = params[k];
+ setType(p);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ }
+ }
+ }
+ else {
+ a.accept(this);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ }
+
+ args = args.tail();
+ }
+ }
+
+ /* called by Javac#recordSpecialProceed().
+ */
+ void compileInvokeSpecial(ASTree target, String classname,
+ String methodname, String descriptor,
+ ASTList args)
+ throws CompileError
+ {
+ target.accept(this);
+ int nargs = getMethodArgsLength(args);
+ atMethodArgs(args, new int[nargs], new int[nargs],
+ new String[nargs]);
+ setReturnType(descriptor);
+ addNullIfVoid();
+ }
+
+ protected void compileUnwrapValue(CtClass type) throws CompileError
+ {
+ if (type == CtClass.voidType)
+ addNullIfVoid();
+ else
+ setType(type);
+ }
+
+ /* Sets exprType, arrayDim, and className;
+ * If type is void, then this method does nothing.
+ */
+ public void setType(CtClass type) throws CompileError {
+ setType(type, 0);
+ }
+
+ private void setType(CtClass type, int dim) throws CompileError {
+ if (type.isPrimitive()) {
+ CtPrimitiveType pt = (CtPrimitiveType)type;
+ exprType = MemberResolver.descToType(pt.getDescriptor());
+ arrayDim = dim;
+ className = null;
+ }
+ else if (type.isArray())
+ try {
+ setType(type.getComponentType(), dim + 1);
+ }
+ catch (NotFoundException e) {
+ throw new CompileError("undefined type: " + type.getName());
+ }
+ else {
+ exprType = CLASS;
+ arrayDim = dim;
+ className = MemberResolver.javaToJvmName(type.getName());
+ }
+ }
+}
diff --git a/src/main/javassist/compiler/KeywordTable.java b/src/main/javassist/compiler/KeywordTable.java
new file mode 100644
index 0000000..3a22a79
--- /dev/null
+++ b/src/main/javassist/compiler/KeywordTable.java
@@ -0,0 +1,32 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+public final class KeywordTable extends java.util.HashMap {
+ public KeywordTable() { super(); }
+
+ public int lookup(String name) {
+ Object found = get(name);
+ if (found == null)
+ return -1;
+ else
+ return ((Integer)found).intValue();
+ }
+
+ public void append(String name, int t) {
+ put(name, new Integer(t));
+ }
+}
diff --git a/src/main/javassist/compiler/Lex.java b/src/main/javassist/compiler/Lex.java
new file mode 100644
index 0000000..5233a25
--- /dev/null
+++ b/src/main/javassist/compiler/Lex.java
@@ -0,0 +1,550 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+class Token {
+ public Token next = null;
+ public int tokenId;
+
+ public long longValue;
+ public double doubleValue;
+ public String textValue;
+}
+
+public class Lex implements TokenId {
+ private int lastChar;
+ private StringBuffer textBuffer;
+ private Token currentToken;
+ private Token lookAheadTokens;
+
+ private String input;
+ private int position, maxlen, lineNumber;
+
+ /**
+ * Constructs a lexical analyzer.
+ */
+ public Lex(String s) {
+ lastChar = -1;
+ textBuffer = new StringBuffer();
+ currentToken = new Token();
+ lookAheadTokens = null;
+
+ input = s;
+ position = 0;
+ maxlen = s.length();
+ lineNumber = 0;
+ }
+
+ public int get() {
+ if (lookAheadTokens == null)
+ return get(currentToken);
+ else {
+ Token t;
+ currentToken = t = lookAheadTokens;
+ lookAheadTokens = lookAheadTokens.next;
+ return t.tokenId;
+ }
+ }
+
+ /**
+ * Looks at the next token.
+ */
+ public int lookAhead() {
+ return lookAhead(0);
+ }
+
+ public int lookAhead(int i) {
+ Token tk = lookAheadTokens;
+ if (tk == null) {
+ lookAheadTokens = tk = currentToken; // reuse an object!
+ tk.next = null;
+ get(tk);
+ }
+
+ for (; i-- > 0; tk = tk.next)
+ if (tk.next == null) {
+ Token tk2;
+ tk.next = tk2 = new Token();
+ get(tk2);
+ }
+
+ currentToken = tk;
+ return tk.tokenId;
+ }
+
+ public String getString() {
+ return currentToken.textValue;
+ }
+
+ public long getLong() {
+ return currentToken.longValue;
+ }
+
+ public double getDouble() {
+ return currentToken.doubleValue;
+ }
+
+ private int get(Token token) {
+ int t;
+ do {
+ t = readLine(token);
+ } while (t == '\n');
+ token.tokenId = t;
+ return t;
+ }
+
+ private int readLine(Token token) {
+ int c = getNextNonWhiteChar();
+ if(c < 0)
+ return c;
+ else if(c == '\n') {
+ ++lineNumber;
+ return '\n';
+ }
+ else if (c == '\'')
+ return readCharConst(token);
+ else if (c == '"')
+ return readStringL(token);
+ else if ('0' <= c && c <= '9')
+ return readNumber(c, token);
+ else if(c == '.'){
+ c = getc();
+ if ('0' <= c && c <= '9') {
+ StringBuffer tbuf = textBuffer;
+ tbuf.setLength(0);
+ tbuf.append('.');
+ return readDouble(tbuf, c, token);
+ }
+ else{
+ ungetc(c);
+ return readSeparator('.');
+ }
+ }
+ else if (Character.isJavaIdentifierStart((char)c))
+ return readIdentifier(c, token);
+ else
+ return readSeparator(c);
+ }
+
+ private int getNextNonWhiteChar() {
+ int c;
+ do {
+ c = getc();
+ if (c == '/') {
+ c = getc();
+ if (c == '/')
+ do {
+ c = getc();
+ } while (c != '\n' && c != '\r' && c != -1);
+ else if (c == '*')
+ while (true) {
+ c = getc();
+ if (c == -1)
+ break;
+ else if (c == '*')
+ if ((c = getc()) == '/') {
+ c = ' ';
+ break;
+ }
+ else
+ ungetc(c);
+ }
+ else {
+ ungetc(c);
+ c = '/';
+ }
+ }
+ } while(isBlank(c));
+ return c;
+ }
+
+ private int readCharConst(Token token) {
+ int c;
+ int value = 0;
+ while ((c = getc()) != '\'')
+ if (c == '\\')
+ value = readEscapeChar();
+ else if (c < 0x20) {
+ if (c == '\n')
+ ++lineNumber;
+
+ return BadToken;
+ }
+ else
+ value = c;
+
+ token.longValue = value;
+ return CharConstant;
+ }
+
+ private int readEscapeChar() {
+ int c = getc();
+ if (c == 'n')
+ c = '\n';
+ else if (c == 't')
+ c = '\t';
+ else if (c == 'r')
+ c = '\r';
+ else if (c == 'f')
+ c = '\f';
+ else if (c == '\n')
+ ++lineNumber;
+
+ return c;
+ }
+
+ private int readStringL(Token token) {
+ int c;
+ StringBuffer tbuf = textBuffer;
+ tbuf.setLength(0);
+ for (;;) {
+ while ((c = getc()) != '"') {
+ if (c == '\\')
+ c = readEscapeChar();
+ else if (c == '\n' || c < 0) {
+ ++lineNumber;
+ return BadToken;
+ }
+
+ tbuf.append((char)c);
+ }
+
+ for (;;) {
+ c = getc();
+ if (c == '\n')
+ ++lineNumber;
+ else if (!isBlank(c))
+ break;
+ }
+
+ if (c != '"') {
+ ungetc(c);
+ break;
+ }
+ }
+
+ token.textValue = tbuf.toString();
+ return StringL;
+ }
+
+ private int readNumber(int c, Token token) {
+ long value = 0;
+ int c2 = getc();
+ if (c == '0')
+ if (c2 == 'X' || c2 == 'x')
+ for (;;) {
+ c = getc();
+ if ('0' <= c && c <= '9')
+ value = value * 16 + (long)(c - '0');
+ else if ('A' <= c && c <= 'F')
+ value = value * 16 + (long)(c - 'A' + 10);
+ else if ('a' <= c && c <= 'f')
+ value = value * 16 + (long)(c - 'a' + 10);
+ else {
+ token.longValue = value;
+ if (c == 'L' || c == 'l')
+ return LongConstant;
+ else {
+ ungetc(c);
+ return IntConstant;
+ }
+ }
+ }
+ else if ('0' <= c2 && c2 <= '7') {
+ value = c2 - '0';
+ for (;;) {
+ c = getc();
+ if ('0' <= c && c <= '7')
+ value = value * 8 + (long)(c - '0');
+ else {
+ token.longValue = value;
+ if (c == 'L' || c == 'l')
+ return LongConstant;
+ else {
+ ungetc(c);
+ return IntConstant;
+ }
+ }
+ }
+ }
+
+ value = c - '0';
+ while ('0' <= c2 && c2 <= '9') {
+ value = value * 10 + c2 - '0';
+ c2 = getc();
+ }
+
+ token.longValue = value;
+ if (c2 == 'F' || c2 == 'f') {
+ token.doubleValue = (double)value;
+ return FloatConstant;
+ }
+ else if (c2 == 'E' || c2 == 'e'
+ || c2 == 'D' || c2 == 'd' || c2 == '.') {
+ StringBuffer tbuf = textBuffer;
+ tbuf.setLength(0);
+ tbuf.append(value);
+ return readDouble(tbuf, c2, token);
+ }
+ else if (c2 == 'L' || c2 == 'l')
+ return LongConstant;
+ else {
+ ungetc(c2);
+ return IntConstant;
+ }
+ }
+
+ private int readDouble(StringBuffer sbuf, int c, Token token) {
+ if (c != 'E' && c != 'e' && c != 'D' && c != 'd') {
+ sbuf.append((char)c);
+ for (;;) {
+ c = getc();
+ if ('0' <= c && c <= '9')
+ sbuf.append((char)c);
+ else
+ break;
+ }
+ }
+
+ if (c == 'E' || c == 'e') {
+ sbuf.append((char)c);
+ c = getc();
+ if (c == '+' || c == '-') {
+ sbuf.append((char)c);
+ c = getc();
+ }
+
+ while ('0' <= c && c <= '9') {
+ sbuf.append((char)c);
+ c = getc();
+ }
+ }
+
+ try {
+ token.doubleValue = Double.parseDouble(sbuf.toString());
+ }
+ catch (NumberFormatException e) {
+ return BadToken;
+ }
+
+ if (c == 'F' || c == 'f')
+ return FloatConstant;
+ else {
+ if (c != 'D' && c != 'd')
+ ungetc(c);
+
+ return DoubleConstant;
+ }
+ }
+
+ // !"#$%&'( )*+,-./0 12345678 9:;<=>?
+ private static final int[] equalOps
+ = { NEQ, 0, 0, 0, MOD_E, AND_E, 0, 0,
+ 0, MUL_E, PLUS_E, 0, MINUS_E, 0, DIV_E, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, LE, EQ, GE, 0 };
+
+ private int readSeparator(int c) {
+ int c2, c3;
+ if ('!' <= c && c <= '?') {
+ int t = equalOps[c - '!'];
+ if (t == 0)
+ return c;
+ else {
+ c2 = getc();
+ if (c == c2)
+ switch (c) {
+ case '=' :
+ return EQ;
+ case '+' :
+ return PLUSPLUS;
+ case '-' :
+ return MINUSMINUS;
+ case '&' :
+ return ANDAND;
+ case '<' :
+ c3 = getc();
+ if (c3 == '=')
+ return LSHIFT_E;
+ else {
+ ungetc(c3);
+ return LSHIFT;
+ }
+ case '>' :
+ c3 = getc();
+ if (c3 == '=')
+ return RSHIFT_E;
+ else if (c3 == '>') {
+ c3 = getc();
+ if (c3 == '=')
+ return ARSHIFT_E;
+ else {
+ ungetc(c3);
+ return ARSHIFT;
+ }
+ }
+ else {
+ ungetc(c3);
+ return RSHIFT;
+ }
+ default :
+ break;
+ }
+ else if (c2 == '=')
+ return t;
+ }
+ }
+ else if (c == '^') {
+ c2 = getc();
+ if (c2 == '=')
+ return EXOR_E;
+ }
+ else if (c == '|') {
+ c2 = getc();
+ if (c2 == '=')
+ return OR_E;
+ else if (c2 == '|')
+ return OROR;
+ }
+ else
+ return c;
+
+ ungetc(c2);
+ return c;
+ }
+
+ private int readIdentifier(int c, Token token) {
+ StringBuffer tbuf = textBuffer;
+ tbuf.setLength(0);
+
+ do {
+ tbuf.append((char)c);
+ c = getc();
+ } while (Character.isJavaIdentifierPart((char)c));
+
+ ungetc(c);
+
+ String name = tbuf.toString();
+ int t = ktable.lookup(name);
+ if (t >= 0)
+ return t;
+ else {
+ /* tbuf.toString() is executed quickly since it does not
+ * need memory copy. Using a hand-written extensible
+ * byte-array class instead of StringBuffer is not a good idea
+ * for execution speed. Converting a byte array to a String
+ * object is very slow. Using an extensible char array
+ * might be OK.
+ */
+ token.textValue = name;
+ return Identifier;
+ }
+ }
+
+ private static final KeywordTable ktable = new KeywordTable();
+
+ static {
+ ktable.append("abstract", ABSTRACT);
+ ktable.append("boolean", BOOLEAN);
+ ktable.append("break", BREAK);
+ ktable.append("byte", BYTE);
+ ktable.append("case", CASE);
+ ktable.append("catch", CATCH);
+ ktable.append("char", CHAR);
+ ktable.append("class", CLASS);
+ ktable.append("const", CONST);
+ ktable.append("continue", CONTINUE);
+ ktable.append("default", DEFAULT);
+ ktable.append("do", DO);
+ ktable.append("double", DOUBLE);
+ ktable.append("else", ELSE);
+ ktable.append("extends", EXTENDS);
+ ktable.append("false", FALSE);
+ ktable.append("final", FINAL);
+ ktable.append("finally", FINALLY);
+ ktable.append("float", FLOAT);
+ ktable.append("for", FOR);
+ ktable.append("goto", GOTO);
+ ktable.append("if", IF);
+ ktable.append("implements", IMPLEMENTS);
+ ktable.append("import", IMPORT);
+ ktable.append("instanceof", INSTANCEOF);
+ ktable.append("int", INT);
+ ktable.append("interface", INTERFACE);
+ ktable.append("long", LONG);
+ ktable.append("native", NATIVE);
+ ktable.append("new", NEW);
+ ktable.append("null", NULL);
+ ktable.append("package", PACKAGE);
+ ktable.append("private", PRIVATE);
+ ktable.append("protected", PROTECTED);
+ ktable.append("public", PUBLIC);
+ ktable.append("return", RETURN);
+ ktable.append("short", SHORT);
+ ktable.append("static", STATIC);
+ ktable.append("strictfp", STRICT);
+ ktable.append("super", SUPER);
+ ktable.append("switch", SWITCH);
+ ktable.append("synchronized", SYNCHRONIZED);
+ ktable.append("this", THIS);
+ ktable.append("throw", THROW);
+ ktable.append("throws", THROWS);
+ ktable.append("transient", TRANSIENT);
+ ktable.append("true", TRUE);
+ ktable.append("try", TRY);
+ ktable.append("void", VOID);
+ ktable.append("volatile", VOLATILE);
+ ktable.append("while", WHILE);
+ }
+
+ private static boolean isBlank(int c) {
+ return c == ' ' || c == '\t' || c == '\f' || c == '\r'
+ || c == '\n';
+ }
+
+ private static boolean isDigit(int c) {
+ return '0' <= c && c <= '9';
+ }
+
+ private void ungetc(int c) {
+ lastChar = c;
+ }
+
+ public String getTextAround() {
+ int begin = position - 10;
+ if (begin < 0)
+ begin = 0;
+
+ int end = position + 10;
+ if (end > maxlen)
+ end = maxlen;
+
+ return input.substring(begin, end);
+ }
+
+ private int getc() {
+ if (lastChar < 0)
+ if (position < maxlen)
+ return input.charAt(position++);
+ else
+ return -1;
+ else {
+ int c = lastChar;
+ lastChar = -1;
+ return c;
+ }
+ }
+}
diff --git a/src/main/javassist/compiler/MemberCodeGen.java b/src/main/javassist/compiler/MemberCodeGen.java
new file mode 100644
index 0000000..cbff0a4
--- /dev/null
+++ b/src/main/javassist/compiler/MemberCodeGen.java
@@ -0,0 +1,1148 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.ast.*;
+
+import java.util.ArrayList;
+
+/* Code generator methods depending on javassist.* classes.
+ */
+public class MemberCodeGen extends CodeGen {
+ protected MemberResolver resolver;
+ protected CtClass thisClass;
+ protected MethodInfo thisMethod;
+
+ protected boolean resultStatic;
+
+ public MemberCodeGen(Bytecode b, CtClass cc, ClassPool cp) {
+ super(b);
+ resolver = new MemberResolver(cp);
+ thisClass = cc;
+ thisMethod = null;
+ }
+
+ /**
+ * Returns the major version of the class file
+ * targeted by this compilation.
+ */
+ public int getMajorVersion() {
+ ClassFile cf = thisClass.getClassFile2();
+ if (cf == null)
+ return ClassFile.MAJOR_VERSION; // JDK 1.3
+ else
+ return cf.getMajorVersion();
+ }
+
+ /**
+ * Records the currently compiled method.
+ */
+ public void setThisMethod(CtMethod m) {
+ thisMethod = m.getMethodInfo2();
+ if (typeChecker != null)
+ typeChecker.setThisMethod(thisMethod);
+ }
+
+ public CtClass getThisClass() { return thisClass; }
+
+ /**
+ * Returns the JVM-internal representation of this class name.
+ */
+ protected String getThisName() {
+ return MemberResolver.javaToJvmName(thisClass.getName());
+ }
+
+ /**
+ * Returns the JVM-internal representation of this super class name.
+ */
+ protected String getSuperName() throws CompileError {
+ return MemberResolver.javaToJvmName(
+ MemberResolver.getSuperclass(thisClass).getName());
+ }
+
+ protected void insertDefaultSuperCall() throws CompileError {
+ bytecode.addAload(0);
+ bytecode.addInvokespecial(MemberResolver.getSuperclass(thisClass),
+ "<init>", "()V");
+ }
+
+ static class JsrHook extends ReturnHook {
+ ArrayList jsrList;
+ CodeGen cgen;
+ int var;
+
+ JsrHook(CodeGen gen) {
+ super(gen);
+ jsrList = new ArrayList();
+ cgen = gen;
+ var = -1;
+ }
+
+ private int getVar(int size) {
+ if (var < 0) {
+ var = cgen.getMaxLocals();
+ cgen.incMaxLocals(size);
+ }
+
+ return var;
+ }
+
+ private void jsrJmp(Bytecode b) {
+ b.addOpcode(Opcode.GOTO);
+ jsrList.add(new int[] {b.currentPc(), var});
+ b.addIndex(0);
+ }
+
+ protected boolean doit(Bytecode b, int opcode) {
+ switch (opcode) {
+ case Opcode.RETURN :
+ jsrJmp(b);
+ break;
+ case ARETURN :
+ b.addAstore(getVar(1));
+ jsrJmp(b);
+ b.addAload(var);
+ break;
+ case IRETURN :
+ b.addIstore(getVar(1));
+ jsrJmp(b);
+ b.addIload(var);
+ break;
+ case LRETURN :
+ b.addLstore(getVar(2));
+ jsrJmp(b);
+ b.addLload(var);
+ break;
+ case DRETURN :
+ b.addDstore(getVar(2));
+ jsrJmp(b);
+ b.addDload(var);
+ break;
+ case FRETURN :
+ b.addFstore(getVar(1));
+ jsrJmp(b);
+ b.addFload(var);
+ break;
+ default :
+ throw new RuntimeException("fatal");
+ }
+
+ return false;
+ }
+ }
+
+ static class JsrHook2 extends ReturnHook {
+ int var;
+ int target;
+
+ JsrHook2(CodeGen gen, int[] retTarget) {
+ super(gen);
+ target = retTarget[0];
+ var = retTarget[1];
+ }
+
+ protected boolean doit(Bytecode b, int opcode) {
+ switch (opcode) {
+ case Opcode.RETURN :
+ break;
+ case ARETURN :
+ b.addAstore(var);
+ break;
+ case IRETURN :
+ b.addIstore(var);
+ break;
+ case LRETURN :
+ b.addLstore(var);
+ break;
+ case DRETURN :
+ b.addDstore(var);
+ break;
+ case FRETURN :
+ b.addFstore(var);
+ break;
+ default :
+ throw new RuntimeException("fatal");
+ }
+
+ b.addOpcode(Opcode.GOTO);
+ b.addIndex(target - b.currentPc() + 3);
+ return true;
+ }
+ }
+
+ protected void atTryStmnt(Stmnt st) throws CompileError {
+ Bytecode bc = bytecode;
+ Stmnt body = (Stmnt)st.getLeft();
+ if (body == null)
+ return;
+
+ ASTList catchList = (ASTList)st.getRight().getLeft();
+ Stmnt finallyBlock = (Stmnt)st.getRight().getRight().getLeft();
+ ArrayList gotoList = new ArrayList();
+
+ JsrHook jsrHook = null;
+ if (finallyBlock != null)
+ jsrHook = new JsrHook(this);
+
+ int start = bc.currentPc();
+ body.accept(this);
+ int end = bc.currentPc();
+ if (start == end)
+ throw new CompileError("empty try block");
+
+ boolean tryNotReturn = !hasReturned;
+ if (tryNotReturn) {
+ bc.addOpcode(Opcode.GOTO);
+ gotoList.add(new Integer(bc.currentPc()));
+ bc.addIndex(0); // correct later
+ }
+
+ int var = getMaxLocals();
+ incMaxLocals(1);
+ while (catchList != null) {
+ // catch clause
+ Pair p = (Pair)catchList.head();
+ catchList = catchList.tail();
+ Declarator decl = (Declarator)p.getLeft();
+ Stmnt block = (Stmnt)p.getRight();
+
+ decl.setLocalVar(var);
+
+ CtClass type = resolver.lookupClassByJvmName(decl.getClassName());
+ decl.setClassName(MemberResolver.javaToJvmName(type.getName()));
+ bc.addExceptionHandler(start, end, bc.currentPc(), type);
+ bc.growStack(1);
+ bc.addAstore(var);
+ hasReturned = false;
+ if (block != null)
+ block.accept(this);
+
+ if (!hasReturned) {
+ bc.addOpcode(Opcode.GOTO);
+ gotoList.add(new Integer(bc.currentPc()));
+ bc.addIndex(0); // correct later
+ tryNotReturn = true;
+ }
+ }
+
+ if (finallyBlock != null) {
+ jsrHook.remove(this);
+ // catch (any) clause
+ int pcAnyCatch = bc.currentPc();
+ bc.addExceptionHandler(start, pcAnyCatch, pcAnyCatch, 0);
+ bc.growStack(1);
+ bc.addAstore(var);
+ hasReturned = false;
+ finallyBlock.accept(this);
+ if (!hasReturned) {
+ bc.addAload(var);
+ bc.addOpcode(ATHROW);
+ }
+
+ addFinally(jsrHook.jsrList, finallyBlock);
+ }
+
+ int pcEnd = bc.currentPc();
+ patchGoto(gotoList, pcEnd);
+ hasReturned = !tryNotReturn;
+ if (finallyBlock != null) {
+ if (tryNotReturn)
+ finallyBlock.accept(this);
+ }
+ }
+
+ /**
+ * Adds a finally clause for earch return statement.
+ */
+ private void addFinally(ArrayList returnList, Stmnt finallyBlock)
+ throws CompileError
+ {
+ Bytecode bc = bytecode;
+ int n = returnList.size();
+ for (int i = 0; i < n; ++i) {
+ final int[] ret = (int[])returnList.get(i);
+ int pc = ret[0];
+ bc.write16bit(pc, bc.currentPc() - pc + 1);
+ ReturnHook hook = new JsrHook2(this, ret);
+ finallyBlock.accept(this);
+ hook.remove(this);
+ if (!hasReturned) {
+ bc.addOpcode(Opcode.GOTO);
+ bc.addIndex(pc + 3 - bc.currentPc());
+ }
+ }
+ }
+
+ public void atNewExpr(NewExpr expr) throws CompileError {
+ if (expr.isArray())
+ atNewArrayExpr(expr);
+ else {
+ CtClass clazz = resolver.lookupClassByName(expr.getClassName());
+ String cname = clazz.getName();
+ ASTList args = expr.getArguments();
+ bytecode.addNew(cname);
+ bytecode.addOpcode(DUP);
+
+ atMethodCallCore(clazz, MethodInfo.nameInit, args,
+ false, true, -1, null);
+
+ exprType = CLASS;
+ arrayDim = 0;
+ className = MemberResolver.javaToJvmName(cname);
+ }
+ }
+
+ public void atNewArrayExpr(NewExpr expr) throws CompileError {
+ int type = expr.getArrayType();
+ ASTList size = expr.getArraySize();
+ ASTList classname = expr.getClassName();
+ ArrayInit init = expr.getInitializer();
+ if (size.length() > 1) {
+ if (init != null)
+ throw new CompileError(
+ "sorry, multi-dimensional array initializer " +
+ "for new is not supported");
+
+ atMultiNewArray(type, classname, size);
+ return;
+ }
+
+ ASTree sizeExpr = size.head();
+ atNewArrayExpr2(type, sizeExpr, Declarator.astToClassName(classname, '/'), init);
+ }
+
+ private void atNewArrayExpr2(int type, ASTree sizeExpr,
+ String jvmClassname, ArrayInit init) throws CompileError {
+ if (init == null)
+ if (sizeExpr == null)
+ throw new CompileError("no array size");
+ else
+ sizeExpr.accept(this);
+ else
+ if (sizeExpr == null) {
+ int s = init.length();
+ bytecode.addIconst(s);
+ }
+ else
+ throw new CompileError("unnecessary array size specified for new");
+
+ String elementClass;
+ if (type == CLASS) {
+ elementClass = resolveClassName(jvmClassname);
+ bytecode.addAnewarray(MemberResolver.jvmToJavaName(elementClass));
+ }
+ else {
+ elementClass = null;
+ int atype = 0;
+ switch (type) {
+ case BOOLEAN :
+ atype = T_BOOLEAN;
+ break;
+ case CHAR :
+ atype = T_CHAR;
+ break;
+ case FLOAT :
+ atype = T_FLOAT;
+ break;
+ case DOUBLE :
+ atype = T_DOUBLE;
+ break;
+ case BYTE :
+ atype = T_BYTE;
+ break;
+ case SHORT :
+ atype = T_SHORT;
+ break;
+ case INT :
+ atype = T_INT;
+ break;
+ case LONG :
+ atype = T_LONG;
+ break;
+ default :
+ badNewExpr();
+ break;
+ }
+
+ bytecode.addOpcode(NEWARRAY);
+ bytecode.add(atype);
+ }
+
+ if (init != null) {
+ int s = init.length();
+ ASTList list = init;
+ for (int i = 0; i < s; i++) {
+ bytecode.addOpcode(DUP);
+ bytecode.addIconst(i);
+ list.head().accept(this);
+ if (!isRefType(type))
+ atNumCastExpr(exprType, type);
+
+ bytecode.addOpcode(getArrayWriteOp(type, 0));
+ list = list.tail();
+ }
+ }
+
+ exprType = type;
+ arrayDim = 1;
+ className = elementClass;
+ }
+
+ private static void badNewExpr() throws CompileError {
+ throw new CompileError("bad new expression");
+ }
+
+ protected void atArrayVariableAssign(ArrayInit init, int varType,
+ int varArray, String varClass) throws CompileError {
+ atNewArrayExpr2(varType, null, varClass, init);
+ }
+
+ public void atArrayInit(ArrayInit init) throws CompileError {
+ throw new CompileError("array initializer is not supported");
+ }
+
+ protected void atMultiNewArray(int type, ASTList classname, ASTList size)
+ throws CompileError
+ {
+ int count, dim;
+ dim = size.length();
+ for (count = 0; size != null; size = size.tail()) {
+ ASTree s = size.head();
+ if (s == null)
+ break; // int[][][] a = new int[3][4][];
+
+ ++count;
+ s.accept(this);
+ if (exprType != INT)
+ throw new CompileError("bad type for array size");
+ }
+
+ String desc;
+ exprType = type;
+ arrayDim = dim;
+ if (type == CLASS) {
+ className = resolveClassName(classname);
+ desc = toJvmArrayName(className, dim);
+ }
+ else
+ desc = toJvmTypeName(type, dim);
+
+ bytecode.addMultiNewarray(desc, count);
+ }
+
+ public void atCallExpr(CallExpr expr) throws CompileError {
+ String mname = null;
+ CtClass targetClass = null;
+ ASTree method = expr.oprand1();
+ ASTList args = (ASTList)expr.oprand2();
+ boolean isStatic = false;
+ boolean isSpecial = false;
+ int aload0pos = -1;
+
+ MemberResolver.Method cached = expr.getMethod();
+ if (method instanceof Member) {
+ mname = ((Member)method).get();
+ targetClass = thisClass;
+ if (inStaticMethod || (cached != null && cached.isStatic()))
+ isStatic = true; // should be static
+ else {
+ aload0pos = bytecode.currentPc();
+ bytecode.addAload(0); // this
+ }
+ }
+ else if (method instanceof Keyword) { // constructor
+ isSpecial = true;
+ mname = MethodInfo.nameInit; // <init>
+ targetClass = thisClass;
+ if (inStaticMethod)
+ throw new CompileError("a constructor cannot be static");
+ else
+ bytecode.addAload(0); // this
+
+ if (((Keyword)method).get() == SUPER)
+ targetClass = MemberResolver.getSuperclass(targetClass);
+ }
+ else if (method instanceof Expr) {
+ Expr e = (Expr)method;
+ mname = ((Symbol)e.oprand2()).get();
+ int op = e.getOperator();
+ if (op == MEMBER) { // static method
+ targetClass
+ = resolver.lookupClass(((Symbol)e.oprand1()).get(), false);
+ isStatic = true;
+ }
+ else if (op == '.') {
+ ASTree target = e.oprand1();
+ if (target instanceof Keyword)
+ if (((Keyword)target).get() == SUPER)
+ isSpecial = true;
+
+ try {
+ target.accept(this);
+ }
+ catch (NoFieldException nfe) {
+ if (nfe.getExpr() != target)
+ throw nfe;
+
+ // it should be a static method.
+ exprType = CLASS;
+ arrayDim = 0;
+ className = nfe.getField(); // JVM-internal
+ resolver.recordPackage(className);
+ isStatic = true;
+ }
+
+ if (arrayDim > 0)
+ targetClass = resolver.lookupClass(javaLangObject, true);
+ else if (exprType == CLASS /* && arrayDim == 0 */)
+ targetClass = resolver.lookupClassByJvmName(className);
+ else
+ badMethod();
+ }
+ else
+ badMethod();
+ }
+ else
+ fatal();
+
+ atMethodCallCore(targetClass, mname, args, isStatic, isSpecial,
+ aload0pos, cached);
+ }
+
+ private static void badMethod() throws CompileError {
+ throw new CompileError("bad method");
+ }
+
+ /*
+ * atMethodCallCore() is also called by doit() in NewExpr.ProceedForNew
+ *
+ * @param targetClass the class at which method lookup starts.
+ * @param found not null if the method look has been already done.
+ */
+ public void atMethodCallCore(CtClass targetClass, String mname,
+ ASTList args, boolean isStatic, boolean isSpecial,
+ int aload0pos, MemberResolver.Method found)
+ throws CompileError
+ {
+ int nargs = getMethodArgsLength(args);
+ int[] types = new int[nargs];
+ int[] dims = new int[nargs];
+ String[] cnames = new String[nargs];
+
+ if (!isStatic && found != null && found.isStatic()) {
+ bytecode.addOpcode(POP);
+ isStatic = true;
+ }
+
+ int stack = bytecode.getStackDepth();
+
+ // generate code for evaluating arguments.
+ atMethodArgs(args, types, dims, cnames);
+
+ // used by invokeinterface
+ int count = bytecode.getStackDepth() - stack + 1;
+
+ if (found == null)
+ found = resolver.lookupMethod(targetClass, thisClass, thisMethod,
+ mname, types, dims, cnames);
+
+ if (found == null) {
+ String msg;
+ if (mname.equals(MethodInfo.nameInit))
+ msg = "constructor not found";
+ else
+ msg = "Method " + mname + " not found in "
+ + targetClass.getName();
+
+ throw new CompileError(msg);
+ }
+
+ atMethodCallCore2(targetClass, mname, isStatic, isSpecial,
+ aload0pos, count, found);
+ }
+
+ private void atMethodCallCore2(CtClass targetClass, String mname,
+ boolean isStatic, boolean isSpecial,
+ int aload0pos, int count,
+ MemberResolver.Method found)
+ throws CompileError
+ {
+ CtClass declClass = found.declaring;
+ MethodInfo minfo = found.info;
+ String desc = minfo.getDescriptor();
+ int acc = minfo.getAccessFlags();
+
+ if (mname.equals(MethodInfo.nameInit)) {
+ isSpecial = true;
+ if (declClass != targetClass)
+ throw new CompileError("no such constructor");
+
+ if (declClass != thisClass && AccessFlag.isPrivate(acc)) {
+ desc = getAccessibleConstructor(desc, declClass, minfo);
+ bytecode.addOpcode(Opcode.ACONST_NULL); // the last parameter
+ }
+ }
+ else if (AccessFlag.isPrivate(acc))
+ if (declClass == thisClass)
+ isSpecial = true;
+ else {
+ isSpecial = false;
+ isStatic = true;
+ String origDesc = desc;
+ if ((acc & AccessFlag.STATIC) == 0)
+ desc = Descriptor.insertParameter(declClass.getName(),
+ origDesc);
+
+ acc = AccessFlag.setPackage(acc) | AccessFlag.STATIC;
+ mname = getAccessiblePrivate(mname, origDesc, desc,
+ minfo, declClass);
+ }
+
+ boolean popTarget = false;
+ if ((acc & AccessFlag.STATIC) != 0) {
+ if (!isStatic) {
+ /* this method is static but the target object is
+ on stack. It must be popped out. If aload0pos >= 0,
+ then the target object was pushed by aload_0. It is
+ overwritten by NOP.
+ */
+ isStatic = true;
+ if (aload0pos >= 0)
+ bytecode.write(aload0pos, NOP);
+ else
+ popTarget = true;
+ }
+
+ bytecode.addInvokestatic(declClass, mname, desc);
+ }
+ else if (isSpecial) // if (isSpecial && notStatic(acc))
+ bytecode.addInvokespecial(declClass, mname, desc);
+ else {
+ if (!Modifier.isPublic(declClass.getModifiers())
+ || declClass.isInterface() != targetClass.isInterface())
+ declClass = targetClass;
+
+ if (declClass.isInterface())
+ bytecode.addInvokeinterface(declClass, mname, desc, count);
+ else
+ if (isStatic)
+ throw new CompileError(mname + " is not static");
+ else
+ bytecode.addInvokevirtual(declClass, mname, desc);
+ }
+
+ setReturnType(desc, isStatic, popTarget);
+ }
+
+ /*
+ * Finds (or adds if necessary) a hidden accessor if the method
+ * is in an enclosing class.
+ *
+ * @param desc the descriptor of the method.
+ * @param declClass the class declaring the method.
+ */
+ protected String getAccessiblePrivate(String methodName, String desc,
+ String newDesc, MethodInfo minfo,
+ CtClass declClass)
+ throws CompileError
+ {
+ if (isEnclosing(declClass, thisClass)) {
+ AccessorMaker maker = declClass.getAccessorMaker();
+ if (maker != null)
+ return maker.getMethodAccessor(methodName, desc, newDesc,
+ minfo);
+ }
+
+ throw new CompileError("Method " + methodName
+ + " is private");
+ }
+
+ /*
+ * Finds (or adds if necessary) a hidden constructor if the given
+ * constructor is in an enclosing class.
+ *
+ * @param desc the descriptor of the constructor.
+ * @param declClass the class declaring the constructor.
+ * @param minfo the method info of the constructor.
+ * @return the descriptor of the hidden constructor.
+ */
+ protected String getAccessibleConstructor(String desc, CtClass declClass,
+ MethodInfo minfo)
+ throws CompileError
+ {
+ if (isEnclosing(declClass, thisClass)) {
+ AccessorMaker maker = declClass.getAccessorMaker();
+ if (maker != null)
+ return maker.getConstructor(declClass, desc, minfo);
+ }
+
+ throw new CompileError("the called constructor is private in "
+ + declClass.getName());
+ }
+
+ private boolean isEnclosing(CtClass outer, CtClass inner) {
+ try {
+ while (inner != null) {
+ inner = inner.getDeclaringClass();
+ if (inner == outer)
+ return true;
+ }
+ }
+ catch (NotFoundException e) {}
+ return false;
+ }
+
+ public int getMethodArgsLength(ASTList args) {
+ return ASTList.length(args);
+ }
+
+ public void atMethodArgs(ASTList args, int[] types, int[] dims,
+ String[] cnames) throws CompileError {
+ int i = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ a.accept(this);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ args = args.tail();
+ }
+ }
+
+ void setReturnType(String desc, boolean isStatic, boolean popTarget)
+ throws CompileError
+ {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ badMethod();
+
+ char c = desc.charAt(++i);
+ int dim = 0;
+ while (c == '[') {
+ ++dim;
+ c = desc.charAt(++i);
+ }
+
+ arrayDim = dim;
+ if (c == 'L') {
+ int j = desc.indexOf(';', i + 1);
+ if (j < 0)
+ badMethod();
+
+ exprType = CLASS;
+ className = desc.substring(i + 1, j);
+ }
+ else {
+ exprType = MemberResolver.descToType(c);
+ className = null;
+ }
+
+ int etype = exprType;
+ if (isStatic) {
+ if (popTarget) {
+ if (is2word(etype, dim)) {
+ bytecode.addOpcode(DUP2_X1);
+ bytecode.addOpcode(POP2);
+ bytecode.addOpcode(POP);
+ }
+ else if (etype == VOID)
+ bytecode.addOpcode(POP);
+ else {
+ bytecode.addOpcode(SWAP);
+ bytecode.addOpcode(POP);
+ }
+ }
+ }
+ }
+
+ protected void atFieldAssign(Expr expr, int op, ASTree left,
+ ASTree right, boolean doDup) throws CompileError
+ {
+ CtField f = fieldAccess(left, false);
+ boolean is_static = resultStatic;
+ if (op != '=' && !is_static)
+ bytecode.addOpcode(DUP);
+
+ int fi;
+ if (op == '=') {
+ FieldInfo finfo = f.getFieldInfo2();
+ setFieldType(finfo);
+ AccessorMaker maker = isAccessibleField(f, finfo);
+ if (maker == null)
+ fi = addFieldrefInfo(f, finfo);
+ else
+ fi = 0;
+ }
+ else
+ fi = atFieldRead(f, is_static);
+
+ int fType = exprType;
+ int fDim = arrayDim;
+ String cname = className;
+
+ atAssignCore(expr, op, right, fType, fDim, cname);
+
+ boolean is2w = is2word(fType, fDim);
+ if (doDup) {
+ int dup_code;
+ if (is_static)
+ dup_code = (is2w ? DUP2 : DUP);
+ else
+ dup_code = (is2w ? DUP2_X1 : DUP_X1);
+
+ bytecode.addOpcode(dup_code);
+ }
+
+ atFieldAssignCore(f, is_static, fi, is2w);
+
+ exprType = fType;
+ arrayDim = fDim;
+ className = cname;
+ }
+
+ /* If fi == 0, the field must be a private field in an enclosing class.
+ */
+ private void atFieldAssignCore(CtField f, boolean is_static, int fi,
+ boolean is2byte) throws CompileError {
+ if (fi != 0) {
+ if (is_static) {
+ bytecode.add(PUTSTATIC);
+ bytecode.growStack(is2byte ? -2 : -1);
+ }
+ else {
+ bytecode.add(PUTFIELD);
+ bytecode.growStack(is2byte ? -3 : -2);
+ }
+
+ bytecode.addIndex(fi);
+ }
+ else {
+ CtClass declClass = f.getDeclaringClass();
+ AccessorMaker maker = declClass.getAccessorMaker();
+ // make should be non null.
+ FieldInfo finfo = f.getFieldInfo2();
+ MethodInfo minfo = maker.getFieldSetter(finfo, is_static);
+ bytecode.addInvokestatic(declClass, minfo.getName(),
+ minfo.getDescriptor());
+ }
+ }
+
+ /* overwritten in JvstCodeGen.
+ */
+ public void atMember(Member mem) throws CompileError {
+ atFieldRead(mem);
+ }
+
+ protected void atFieldRead(ASTree expr) throws CompileError
+ {
+ CtField f = fieldAccess(expr, true);
+ if (f == null) {
+ atArrayLength(expr);
+ return;
+ }
+
+ boolean is_static = resultStatic;
+ ASTree cexpr = TypeChecker.getConstantFieldValue(f);
+ if (cexpr == null)
+ atFieldRead(f, is_static);
+ else {
+ cexpr.accept(this);
+ setFieldType(f.getFieldInfo2());
+ }
+ }
+
+ private void atArrayLength(ASTree expr) throws CompileError {
+ if (arrayDim == 0)
+ throw new CompileError(".length applied to a non array");
+
+ bytecode.addOpcode(ARRAYLENGTH);
+ exprType = INT;
+ arrayDim = 0;
+ }
+
+ /**
+ * Generates bytecode for reading a field value.
+ * It returns a fieldref_info index or zero if the field is a private
+ * one declared in an enclosing class.
+ */
+ private int atFieldRead(CtField f, boolean isStatic) throws CompileError {
+ FieldInfo finfo = f.getFieldInfo2();
+ boolean is2byte = setFieldType(finfo);
+ AccessorMaker maker = isAccessibleField(f, finfo);
+ if (maker != null) {
+ MethodInfo minfo = maker.getFieldGetter(finfo, isStatic);
+ bytecode.addInvokestatic(f.getDeclaringClass(), minfo.getName(),
+ minfo.getDescriptor());
+ return 0;
+ }
+ else {
+ int fi = addFieldrefInfo(f, finfo);
+ if (isStatic) {
+ bytecode.add(GETSTATIC);
+ bytecode.growStack(is2byte ? 2 : 1);
+ }
+ else {
+ bytecode.add(GETFIELD);
+ bytecode.growStack(is2byte ? 1 : 0);
+ }
+
+ bytecode.addIndex(fi);
+ return fi;
+ }
+ }
+
+ /**
+ * Returns null if the field is accessible. Otherwise, it throws
+ * an exception or it returns AccessorMaker if the field is a private
+ * one declared in an enclosing class.
+ */
+ private AccessorMaker isAccessibleField(CtField f, FieldInfo finfo)
+ throws CompileError
+ {
+ if (AccessFlag.isPrivate(finfo.getAccessFlags())
+ && f.getDeclaringClass() != thisClass) {
+ CtClass declClass = f.getDeclaringClass();
+ if (isEnclosing(declClass, thisClass)) {
+ AccessorMaker maker = declClass.getAccessorMaker();
+ if (maker != null)
+ return maker;
+ else
+ throw new CompileError("fatal error. bug?");
+ }
+ else
+ throw new CompileError("Field " + f.getName() + " in "
+ + declClass.getName() + " is private.");
+ }
+
+ return null; // accessible field
+ }
+
+ /**
+ * Sets exprType, arrayDim, and className.
+ *
+ * @return true if the field type is long or double.
+ */
+ private boolean setFieldType(FieldInfo finfo) throws CompileError {
+ String type = finfo.getDescriptor();
+
+ int i = 0;
+ int dim = 0;
+ char c = type.charAt(i);
+ while (c == '[') {
+ ++dim;
+ c = type.charAt(++i);
+ }
+
+ arrayDim = dim;
+ exprType = MemberResolver.descToType(c);
+
+ if (c == 'L')
+ className = type.substring(i + 1, type.indexOf(';', i + 1));
+ else
+ className = null;
+
+ boolean is2byte = (c == 'J' || c == 'D');
+ return is2byte;
+ }
+
+ private int addFieldrefInfo(CtField f, FieldInfo finfo) {
+ ConstPool cp = bytecode.getConstPool();
+ String cname = f.getDeclaringClass().getName();
+ int ci = cp.addClassInfo(cname);
+ String name = finfo.getName();
+ String type = finfo.getDescriptor();
+ return cp.addFieldrefInfo(ci, name, type);
+ }
+
+ protected void atClassObject2(String cname) throws CompileError {
+ if (getMajorVersion() < ClassFile.JAVA_5)
+ super.atClassObject2(cname);
+ else
+ bytecode.addLdc(bytecode.getConstPool().addClassInfo(cname));
+ }
+
+ protected void atFieldPlusPlus(int token, boolean isPost,
+ ASTree oprand, Expr expr, boolean doDup)
+ throws CompileError
+ {
+ CtField f = fieldAccess(oprand, false);
+ boolean is_static = resultStatic;
+ if (!is_static)
+ bytecode.addOpcode(DUP);
+
+ int fi = atFieldRead(f, is_static);
+ int t = exprType;
+ boolean is2w = is2word(t, arrayDim);
+
+ int dup_code;
+ if (is_static)
+ dup_code = (is2w ? DUP2 : DUP);
+ else
+ dup_code = (is2w ? DUP2_X1 : DUP_X1);
+
+ atPlusPlusCore(dup_code, doDup, token, isPost, expr);
+ atFieldAssignCore(f, is_static, fi, is2w);
+ }
+
+ /* This method also returns a value in resultStatic.
+ *
+ * @param acceptLength true if array length is acceptable
+ */
+ protected CtField fieldAccess(ASTree expr, boolean acceptLength)
+ throws CompileError
+ {
+ if (expr instanceof Member) {
+ String name = ((Member)expr).get();
+ CtField f = null;
+ try {
+ f = thisClass.getField(name);
+ }
+ catch (NotFoundException e) {
+ // EXPR might be part of a static member access?
+ throw new NoFieldException(name, expr);
+ }
+
+ boolean is_static = Modifier.isStatic(f.getModifiers());
+ if (!is_static)
+ if (inStaticMethod)
+ throw new CompileError(
+ "not available in a static method: " + name);
+ else
+ bytecode.addAload(0); // this
+
+ resultStatic = is_static;
+ return f;
+ }
+ else if (expr instanceof Expr) {
+ Expr e = (Expr)expr;
+ int op = e.getOperator();
+ if (op == MEMBER) {
+ /* static member by # (extension by Javassist)
+ * For example, if int.class is parsed, the resulting tree
+ * is (# "java.lang.Integer" "TYPE").
+ */
+ CtField f = resolver.lookupField(((Symbol)e.oprand1()).get(),
+ (Symbol)e.oprand2());
+ resultStatic = true;
+ return f;
+ }
+ else if (op == '.') {
+ CtField f = null;
+ try {
+ e.oprand1().accept(this);
+ /* Don't call lookupFieldByJvmName2().
+ * The left operand of . is not a class name but
+ * a normal expression.
+ */
+ if (exprType == CLASS && arrayDim == 0)
+ f = resolver.lookupFieldByJvmName(className,
+ (Symbol)e.oprand2());
+ else if (acceptLength && arrayDim > 0
+ && ((Symbol)e.oprand2()).get().equals("length"))
+ return null; // expr is an array length.
+ else
+ badLvalue();
+
+ boolean is_static = Modifier.isStatic(f.getModifiers());
+ if (is_static)
+ bytecode.addOpcode(POP);
+
+ resultStatic = is_static;
+ return f;
+ }
+ catch (NoFieldException nfe) {
+ if (nfe.getExpr() != e.oprand1())
+ throw nfe;
+
+ /* EXPR should be a static field.
+ * If EXPR might be part of a qualified class name,
+ * lookupFieldByJvmName2() throws NoFieldException.
+ */
+ Symbol fname = (Symbol)e.oprand2();
+ String cname = nfe.getField();
+ f = resolver.lookupFieldByJvmName2(cname, fname, expr);
+ resolver.recordPackage(cname);
+ resultStatic = true;
+ return f;
+ }
+ }
+ else
+ badLvalue();
+ }
+ else
+ badLvalue();
+
+ resultStatic = false;
+ return null; // never reach
+ }
+
+ private static void badLvalue() throws CompileError {
+ throw new CompileError("bad l-value");
+ }
+
+ public CtClass[] makeParamList(MethodDecl md) throws CompileError {
+ CtClass[] params;
+ ASTList plist = md.getParams();
+ if (plist == null)
+ params = new CtClass[0];
+ else {
+ int i = 0;
+ params = new CtClass[plist.length()];
+ while (plist != null) {
+ params[i++] = resolver.lookupClass((Declarator)plist.head());
+ plist = plist.tail();
+ }
+ }
+
+ return params;
+ }
+
+ public CtClass[] makeThrowsList(MethodDecl md) throws CompileError {
+ CtClass[] clist;
+ ASTList list = md.getThrows();
+ if (list == null)
+ return null;
+ else {
+ int i = 0;
+ clist = new CtClass[list.length()];
+ while (list != null) {
+ clist[i++] = resolver.lookupClassByName((ASTList)list.head());
+ list = list.tail();
+ }
+
+ return clist;
+ }
+ }
+
+ /* Converts a class name into a JVM-internal representation.
+ *
+ * It may also expand a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected String resolveClassName(ASTList name) throws CompileError {
+ return resolver.resolveClassName(name);
+ }
+
+ /* Expands a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected String resolveClassName(String jvmName) throws CompileError {
+ return resolver.resolveJvmClassName(jvmName);
+ }
+}
diff --git a/src/main/javassist/compiler/MemberResolver.java b/src/main/javassist/compiler/MemberResolver.java
new file mode 100644
index 0000000..fb2aa9b
--- /dev/null
+++ b/src/main/javassist/compiler/MemberResolver.java
@@ -0,0 +1,583 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import java.util.List;
+import java.util.Iterator;
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.ast.*;
+
+/* Code generator methods depending on javassist.* classes.
+ */
+public class MemberResolver implements TokenId {
+ private ClassPool classPool;
+
+ public MemberResolver(ClassPool cp) {
+ classPool = cp;
+ }
+
+ public ClassPool getClassPool() { return classPool; }
+
+ private static void fatal() throws CompileError {
+ throw new CompileError("fatal");
+ }
+
+ /**
+ * @param jvmClassName a class name. Not a package name.
+ */
+ public void recordPackage(String jvmClassName) {
+ String classname = jvmToJavaName(jvmClassName);
+ for (;;) {
+ int i = classname.lastIndexOf('.');
+ if (i > 0) {
+ classname = classname.substring(0, i);
+ classPool.recordInvalidClassName(classname);
+ }
+ else
+ break;
+ }
+ }
+
+ public static class Method {
+ public CtClass declaring;
+ public MethodInfo info;
+ public int notmatch;
+
+ public Method(CtClass c, MethodInfo i, int n) {
+ declaring = c;
+ info = i;
+ notmatch = n;
+ }
+
+ /**
+ * Returns true if the invoked method is static.
+ */
+ public boolean isStatic() {
+ int acc = info.getAccessFlags();
+ return (acc & AccessFlag.STATIC) != 0;
+ }
+ }
+
+ public Method lookupMethod(CtClass clazz, CtClass currentClass, MethodInfo current,
+ String methodName,
+ int[] argTypes, int[] argDims,
+ String[] argClassNames)
+ throws CompileError
+ {
+ Method maybe = null;
+ // to enable the creation of a recursively called method
+ if (current != null && clazz == currentClass)
+ if (current.getName().equals(methodName)) {
+ int res = compareSignature(current.getDescriptor(),
+ argTypes, argDims, argClassNames);
+ if (res != NO) {
+ Method r = new Method(clazz, current, res);
+ if (res == YES)
+ return r;
+ else
+ maybe = r;
+ }
+ }
+
+ Method m = lookupMethod(clazz, methodName, argTypes, argDims,
+ argClassNames, maybe != null);
+ if (m != null)
+ return m;
+ else
+ return maybe;
+ }
+
+ private Method lookupMethod(CtClass clazz, String methodName,
+ int[] argTypes, int[] argDims,
+ String[] argClassNames, boolean onlyExact)
+ throws CompileError
+ {
+ Method maybe = null;
+ ClassFile cf = clazz.getClassFile2();
+ // If the class is an array type, the class file is null.
+ // If so, search the super class java.lang.Object for clone() etc.
+ if (cf != null) {
+ List list = cf.getMethods();
+ int n = list.size();
+ for (int i = 0; i < n; ++i) {
+ MethodInfo minfo = (MethodInfo)list.get(i);
+ if (minfo.getName().equals(methodName)) {
+ int res = compareSignature(minfo.getDescriptor(),
+ argTypes, argDims, argClassNames);
+ if (res != NO) {
+ Method r = new Method(clazz, minfo, res);
+ if (res == YES)
+ return r;
+ else if (maybe == null || maybe.notmatch > res)
+ maybe = r;
+ }
+ }
+ }
+ }
+
+ if (onlyExact)
+ maybe = null;
+ else
+ onlyExact = maybe != null;
+
+ int mod = clazz.getModifiers();
+ boolean isIntf = Modifier.isInterface(mod);
+ try {
+ // skip searching java.lang.Object if clazz is an interface type.
+ if (!isIntf) {
+ CtClass pclazz = clazz.getSuperclass();
+ if (pclazz != null) {
+ Method r = lookupMethod(pclazz, methodName, argTypes,
+ argDims, argClassNames, onlyExact);
+ if (r != null)
+ return r;
+ }
+ }
+ }
+ catch (NotFoundException e) {}
+
+ if (isIntf || Modifier.isAbstract(mod))
+ try {
+ CtClass[] ifs = clazz.getInterfaces();
+ int size = ifs.length;
+ for (int i = 0; i < size; ++i) {
+ Method r = lookupMethod(ifs[i], methodName,
+ argTypes, argDims, argClassNames,
+ onlyExact);
+ if (r != null)
+ return r;
+ }
+
+ if (isIntf) {
+ // finally search java.lang.Object.
+ CtClass pclazz = clazz.getSuperclass();
+ if (pclazz != null) {
+ Method r = lookupMethod(pclazz, methodName, argTypes,
+ argDims, argClassNames, onlyExact);
+ if (r != null)
+ return r;
+ }
+ }
+ }
+ catch (NotFoundException e) {}
+
+ return maybe;
+ }
+
+ private static final int YES = 0;
+ private static final int NO = -1;
+
+ /*
+ * Returns YES if actual parameter types matches the given signature.
+ *
+ * argTypes, argDims, and argClassNames represent actual parameters.
+ *
+ * This method does not correctly implement the Java method dispatch
+ * algorithm.
+ *
+ * If some of the parameter types exactly match but others are subtypes of
+ * the corresponding type in the signature, this method returns the number
+ * of parameter types that do not exactly match.
+ */
+ private int compareSignature(String desc, int[] argTypes,
+ int[] argDims, String[] argClassNames)
+ throws CompileError
+ {
+ int result = YES;
+ int i = 1;
+ int nArgs = argTypes.length;
+ if (nArgs != Descriptor.numOfParameters(desc))
+ return NO;
+
+ int len = desc.length();
+ for (int n = 0; i < len; ++n) {
+ char c = desc.charAt(i++);
+ if (c == ')')
+ return (n == nArgs ? result : NO);
+ else if (n >= nArgs)
+ return NO;
+
+ int dim = 0;
+ while (c == '[') {
+ ++dim;
+ c = desc.charAt(i++);
+ }
+
+ if (argTypes[n] == NULL) {
+ if (dim == 0 && c != 'L')
+ return NO;
+
+ if (c == 'L')
+ i = desc.indexOf(';', i) + 1;
+ }
+ else if (argDims[n] != dim) {
+ if (!(dim == 0 && c == 'L'
+ && desc.startsWith("java/lang/Object;", i)))
+ return NO;
+
+ // if the thread reaches here, c must be 'L'.
+ i = desc.indexOf(';', i) + 1;
+ result++;
+ if (i <= 0)
+ return NO; // invalid descriptor?
+ }
+ else if (c == 'L') { // not compare
+ int j = desc.indexOf(';', i);
+ if (j < 0 || argTypes[n] != CLASS)
+ return NO;
+
+ String cname = desc.substring(i, j);
+ if (!cname.equals(argClassNames[n])) {
+ CtClass clazz = lookupClassByJvmName(argClassNames[n]);
+ try {
+ if (clazz.subtypeOf(lookupClassByJvmName(cname)))
+ result++;
+ else
+ return NO;
+ }
+ catch (NotFoundException e) {
+ result++; // should be NO?
+ }
+ }
+
+ i = j + 1;
+ }
+ else {
+ int t = descToType(c);
+ int at = argTypes[n];
+ if (t != at)
+ if (t == INT
+ && (at == SHORT || at == BYTE || at == CHAR))
+ result++;
+ else
+ return NO;
+ }
+ }
+
+ return NO;
+ }
+
+ /**
+ * Only used by fieldAccess() in MemberCodeGen and TypeChecker.
+ *
+ * @param jvmClassName a JVM class name. e.g. java/lang/String
+ */
+ public CtField lookupFieldByJvmName2(String jvmClassName, Symbol fieldSym,
+ ASTree expr) throws NoFieldException
+ {
+ String field = fieldSym.get();
+ CtClass cc = null;
+ try {
+ cc = lookupClass(jvmToJavaName(jvmClassName), true);
+ }
+ catch (CompileError e) {
+ // EXPR might be part of a qualified class name.
+ throw new NoFieldException(jvmClassName + "/" + field, expr);
+ }
+
+ try {
+ return cc.getField(field);
+ }
+ catch (NotFoundException e) {
+ // maybe an inner class.
+ jvmClassName = javaToJvmName(cc.getName());
+ throw new NoFieldException(jvmClassName + "$" + field, expr);
+ }
+ }
+
+ /**
+ * @param jvmClassName a JVM class name. e.g. java/lang/String
+ */
+ public CtField lookupFieldByJvmName(String jvmClassName, Symbol fieldName)
+ throws CompileError
+ {
+ return lookupField(jvmToJavaName(jvmClassName), fieldName);
+ }
+
+ /**
+ * @param name a qualified class name. e.g. java.lang.String
+ */
+ public CtField lookupField(String className, Symbol fieldName)
+ throws CompileError
+ {
+ CtClass cc = lookupClass(className, false);
+ try {
+ return cc.getField(fieldName.get());
+ }
+ catch (NotFoundException e) {}
+ throw new CompileError("no such field: " + fieldName.get());
+ }
+
+ public CtClass lookupClassByName(ASTList name) throws CompileError {
+ return lookupClass(Declarator.astToClassName(name, '.'), false);
+ }
+
+ public CtClass lookupClassByJvmName(String jvmName) throws CompileError {
+ return lookupClass(jvmToJavaName(jvmName), false);
+ }
+
+ public CtClass lookupClass(Declarator decl) throws CompileError {
+ return lookupClass(decl.getType(), decl.getArrayDim(),
+ decl.getClassName());
+ }
+
+ /**
+ * @parma classname jvm class name.
+ */
+ public CtClass lookupClass(int type, int dim, String classname)
+ throws CompileError
+ {
+ String cname = "";
+ CtClass clazz;
+ if (type == CLASS) {
+ clazz = lookupClassByJvmName(classname);
+ if (dim > 0)
+ cname = clazz.getName();
+ else
+ return clazz;
+ }
+ else
+ cname = getTypeName(type);
+
+ while (dim-- > 0)
+ cname += "[]";
+
+ return lookupClass(cname, false);
+ }
+
+ /*
+ * type cannot be CLASS
+ */
+ static String getTypeName(int type) throws CompileError {
+ String cname = "";
+ switch (type) {
+ case BOOLEAN :
+ cname = "boolean";
+ break;
+ case CHAR :
+ cname = "char";
+ break;
+ case BYTE :
+ cname = "byte";
+ break;
+ case SHORT :
+ cname = "short";
+ break;
+ case INT :
+ cname = "int";
+ break;
+ case LONG :
+ cname = "long";
+ break;
+ case FLOAT :
+ cname = "float";
+ break;
+ case DOUBLE :
+ cname = "double";
+ break;
+ case VOID :
+ cname = "void";
+ break;
+ default :
+ fatal();
+ }
+
+ return cname;
+ }
+
+ /**
+ * @param name a qualified class name. e.g. java.lang.String
+ */
+ public CtClass lookupClass(String name, boolean notCheckInner)
+ throws CompileError
+ {
+ try {
+ return lookupClass0(name, notCheckInner);
+ }
+ catch (NotFoundException e) {
+ return searchImports(name);
+ }
+ }
+
+ private CtClass searchImports(String orgName)
+ throws CompileError
+ {
+ if (orgName.indexOf('.') < 0) {
+ Iterator it = classPool.getImportedPackages();
+ while (it.hasNext()) {
+ String pac = (String)it.next();
+ String fqName = pac + '.' + orgName;
+ try {
+ CtClass cc = classPool.get(fqName);
+ // if the class is found,
+ classPool.recordInvalidClassName(orgName);
+ return cc;
+ }
+ catch (NotFoundException e) {
+ classPool.recordInvalidClassName(fqName);
+ try {
+ if (pac.endsWith("." + orgName)) {
+ CtClass cc = classPool.get(pac);
+ // if the class is found,
+ classPool.recordInvalidClassName(orgName);
+ return cc;
+ }
+ }
+ catch (NotFoundException e2) {
+ classPool.recordInvalidClassName(pac);
+ }
+ }
+ }
+ }
+
+ throw new CompileError("no such class: " + orgName);
+ }
+
+ private CtClass lookupClass0(String classname, boolean notCheckInner)
+ throws NotFoundException
+ {
+ CtClass cc = null;
+ do {
+ try {
+ cc = classPool.get(classname);
+ }
+ catch (NotFoundException e) {
+ int i = classname.lastIndexOf('.');
+ if (notCheckInner || i < 0)
+ throw e;
+ else {
+ StringBuffer sbuf = new StringBuffer(classname);
+ sbuf.setCharAt(i, '$');
+ classname = sbuf.toString();
+ }
+ }
+ } while (cc == null);
+ return cc;
+ }
+
+ /* Converts a class name into a JVM-internal representation.
+ *
+ * It may also expand a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ public String resolveClassName(ASTList name) throws CompileError {
+ if (name == null)
+ return null;
+ else
+ return javaToJvmName(lookupClassByName(name).getName());
+ }
+
+ /* Expands a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ public String resolveJvmClassName(String jvmName) throws CompileError {
+ if (jvmName == null)
+ return null;
+ else
+ return javaToJvmName(lookupClassByJvmName(jvmName).getName());
+ }
+
+ public static CtClass getSuperclass(CtClass c) throws CompileError {
+ try {
+ CtClass sc = c.getSuperclass();
+ if (sc != null)
+ return sc;
+ }
+ catch (NotFoundException e) {}
+ throw new CompileError("cannot find the super class of "
+ + c.getName());
+ }
+
+ public static String javaToJvmName(String classname) {
+ return classname.replace('.', '/');
+ }
+
+ public static String jvmToJavaName(String classname) {
+ return classname.replace('/', '.');
+ }
+
+ public static int descToType(char c) throws CompileError {
+ switch (c) {
+ case 'Z' :
+ return BOOLEAN;
+ case 'C' :
+ return CHAR;
+ case 'B' :
+ return BYTE;
+ case 'S' :
+ return SHORT;
+ case 'I' :
+ return INT;
+ case 'J' :
+ return LONG;
+ case 'F' :
+ return FLOAT;
+ case 'D' :
+ return DOUBLE;
+ case 'V' :
+ return VOID;
+ case 'L' :
+ case '[' :
+ return CLASS;
+ default :
+ fatal();
+ return VOID; // never reach here
+ }
+ }
+
+ public static int getModifiers(ASTList mods) {
+ int m = 0;
+ while (mods != null) {
+ Keyword k = (Keyword)mods.head();
+ mods = mods.tail();
+ switch (k.get()) {
+ case STATIC :
+ m |= Modifier.STATIC;
+ break;
+ case FINAL :
+ m |= Modifier.FINAL;
+ break;
+ case SYNCHRONIZED :
+ m |= Modifier.SYNCHRONIZED;
+ break;
+ case ABSTRACT :
+ m |= Modifier.ABSTRACT;
+ break;
+ case PUBLIC :
+ m |= Modifier.PUBLIC;
+ break;
+ case PROTECTED :
+ m |= Modifier.PROTECTED;
+ break;
+ case PRIVATE :
+ m |= Modifier.PRIVATE;
+ break;
+ case VOLATILE :
+ m |= Modifier.VOLATILE;
+ break;
+ case TRANSIENT :
+ m |= Modifier.TRANSIENT;
+ break;
+ case STRICT :
+ m |= Modifier.STRICT;
+ break;
+ }
+ }
+
+ return m;
+ }
+}
diff --git a/src/main/javassist/compiler/NoFieldException.java b/src/main/javassist/compiler/NoFieldException.java
new file mode 100644
index 0000000..f6e114b
--- /dev/null
+++ b/src/main/javassist/compiler/NoFieldException.java
@@ -0,0 +1,39 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.compiler.ast.ASTree;
+
+public class NoFieldException extends CompileError {
+ private String fieldName;
+ private ASTree expr;
+
+ /* NAME must be JVM-internal representation.
+ */
+ public NoFieldException(String name, ASTree e) {
+ super("no such field: " + name);
+ fieldName = name;
+ expr = e;
+ }
+
+ /* The returned name should be JVM-internal representation.
+ */
+ public String getField() { return fieldName; }
+
+ /* Returns the expression where this exception is thrown.
+ */
+ public ASTree getExpr() { return expr; }
+}
diff --git a/src/main/javassist/compiler/Parser.java b/src/main/javassist/compiler/Parser.java
new file mode 100644
index 0000000..d483814
--- /dev/null
+++ b/src/main/javassist/compiler/Parser.java
@@ -0,0 +1,1342 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.compiler.ast.*;
+
+public final class Parser implements TokenId {
+ private Lex lex;
+
+ public Parser(Lex lex) {
+ this.lex = lex;
+ }
+
+ public boolean hasMore() { return lex.lookAhead() >= 0; }
+
+ /* member.declaration
+ * : method.declaration | field.declaration
+ */
+ public ASTList parseMember(SymbolTable tbl) throws CompileError {
+ ASTList mem = parseMember1(tbl);
+ if (mem instanceof MethodDecl)
+ return parseMethod2(tbl, (MethodDecl)mem);
+ else
+ return mem;
+ }
+
+ /* A method body is not parsed.
+ */
+ public ASTList parseMember1(SymbolTable tbl) throws CompileError {
+ ASTList mods = parseMemberMods();
+ Declarator d;
+ boolean isConstructor = false;
+ if (lex.lookAhead() == Identifier && lex.lookAhead(1) == '(') {
+ d = new Declarator(VOID, 0);
+ isConstructor = true;
+ }
+ else
+ d = parseFormalType(tbl);
+
+ if (lex.get() != Identifier)
+ throw new SyntaxError(lex);
+
+ String name;
+ if (isConstructor)
+ name = MethodDecl.initName;
+ else
+ name = lex.getString();
+
+ d.setVariable(new Symbol(name));
+ if (isConstructor || lex.lookAhead() == '(')
+ return parseMethod1(tbl, isConstructor, mods, d);
+ else
+ return parseField(tbl, mods, d);
+ }
+
+ /* field.declaration
+ * : member.modifiers
+ * formal.type Identifier
+ * [ "=" expression ] ";"
+ */
+ private FieldDecl parseField(SymbolTable tbl, ASTList mods,
+ Declarator d) throws CompileError
+ {
+ ASTree expr = null;
+ if (lex.lookAhead() == '=') {
+ lex.get();
+ expr = parseExpression(tbl);
+ }
+
+ int c = lex.get();
+ if (c == ';')
+ return new FieldDecl(mods, new ASTList(d, new ASTList(expr)));
+ else if (c == ',')
+ throw new CompileError(
+ "only one field can be declared in one declaration", lex);
+ else
+ throw new SyntaxError(lex);
+ }
+
+ /* method.declaration
+ * : member.modifiers
+ * [ formal.type ]
+ * Identifier "(" [ formal.parameter ( "," formal.parameter )* ] ")"
+ * array.dimension
+ * [ THROWS class.type ( "," class.type ) ]
+ * ( block.statement | ";" )
+ *
+ * Note that a method body is not parsed.
+ */
+ private MethodDecl parseMethod1(SymbolTable tbl, boolean isConstructor,
+ ASTList mods, Declarator d)
+ throws CompileError
+ {
+ if (lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ ASTList parms = null;
+ if (lex.lookAhead() != ')')
+ while (true) {
+ parms = ASTList.append(parms, parseFormalParam(tbl));
+ int t = lex.lookAhead();
+ if (t == ',')
+ lex.get();
+ else if (t == ')')
+ break;
+ }
+
+ lex.get(); // ')'
+ d.addArrayDim(parseArrayDimension());
+ if (isConstructor && d.getArrayDim() > 0)
+ throw new SyntaxError(lex);
+
+ ASTList throwsList = null;
+ if (lex.lookAhead() == THROWS) {
+ lex.get();
+ while (true) {
+ throwsList = ASTList.append(throwsList, parseClassType(tbl));
+ if (lex.lookAhead() == ',')
+ lex.get();
+ else
+ break;
+ }
+ }
+
+ return new MethodDecl(mods, new ASTList(d,
+ ASTList.make(parms, throwsList, null)));
+ }
+
+ /* Parses a method body.
+ */
+ public MethodDecl parseMethod2(SymbolTable tbl, MethodDecl md)
+ throws CompileError
+ {
+ Stmnt body = null;
+ if (lex.lookAhead() == ';')
+ lex.get();
+ else {
+ body = parseBlock(tbl);
+ if (body == null)
+ body = new Stmnt(BLOCK);
+ }
+
+ md.sublist(4).setHead(body);
+ return md;
+ }
+
+ /* member.modifiers
+ * : ( FINAL | SYNCHRONIZED | ABSTRACT
+ * | PUBLIC | PROTECTED | PRIVATE | STATIC
+ * | VOLATILE | TRANSIENT | STRICT )*
+ */
+ private ASTList parseMemberMods() {
+ int t;
+ ASTList list = null;
+ while (true) {
+ t = lex.lookAhead();
+ if (t == ABSTRACT || t == FINAL || t == PUBLIC || t == PROTECTED
+ || t == PRIVATE || t == SYNCHRONIZED || t == STATIC
+ || t == VOLATILE || t == TRANSIENT || t == STRICT)
+ list = new ASTList(new Keyword(lex.get()), list);
+ else
+ break;
+ }
+
+ return list;
+ }
+
+ /* formal.type : ( build-in-type | class.type ) array.dimension
+ */
+ private Declarator parseFormalType(SymbolTable tbl) throws CompileError {
+ int t = lex.lookAhead();
+ if (isBuiltinType(t) || t == VOID) {
+ lex.get(); // primitive type
+ int dim = parseArrayDimension();
+ return new Declarator(t, dim);
+ }
+ else {
+ ASTList name = parseClassType(tbl);
+ int dim = parseArrayDimension();
+ return new Declarator(name, dim);
+ }
+ }
+
+ private static boolean isBuiltinType(int t) {
+ return (t == BOOLEAN || t == BYTE || t == CHAR || t == SHORT
+ || t == INT || t == LONG || t == FLOAT || t == DOUBLE);
+ }
+
+ /* formal.parameter : formal.type Identifier array.dimension
+ */
+ private Declarator parseFormalParam(SymbolTable tbl)
+ throws CompileError
+ {
+ Declarator d = parseFormalType(tbl);
+ if (lex.get() != Identifier)
+ throw new SyntaxError(lex);
+
+ String name = lex.getString();
+ d.setVariable(new Symbol(name));
+ d.addArrayDim(parseArrayDimension());
+ tbl.append(name, d);
+ return d;
+ }
+
+ /* statement : [ label ":" ]* labeled.statement
+ *
+ * labeled.statement
+ * : block.statement
+ * | if.statement
+ * | while.statement
+ * | do.statement
+ * | for.statement
+ * | switch.statement
+ * | try.statement
+ * | return.statement
+ * | thorw.statement
+ * | break.statement
+ * | continue.statement
+ * | declaration.or.expression
+ * | ";"
+ *
+ * This method may return null (empty statement).
+ */
+ public Stmnt parseStatement(SymbolTable tbl)
+ throws CompileError
+ {
+ int t = lex.lookAhead();
+ if (t == '{')
+ return parseBlock(tbl);
+ else if (t == ';') {
+ lex.get();
+ return new Stmnt(BLOCK); // empty statement
+ }
+ else if (t == Identifier && lex.lookAhead(1) == ':') {
+ lex.get(); // Identifier
+ String label = lex.getString();
+ lex.get(); // ':'
+ return Stmnt.make(LABEL, new Symbol(label), parseStatement(tbl));
+ }
+ else if (t == IF)
+ return parseIf(tbl);
+ else if (t == WHILE)
+ return parseWhile(tbl);
+ else if (t == DO)
+ return parseDo(tbl);
+ else if (t == FOR)
+ return parseFor(tbl);
+ else if (t == TRY)
+ return parseTry(tbl);
+ else if (t == SWITCH)
+ return parseSwitch(tbl);
+ else if (t == SYNCHRONIZED)
+ return parseSynchronized(tbl);
+ else if (t == RETURN)
+ return parseReturn(tbl);
+ else if (t == THROW)
+ return parseThrow(tbl);
+ else if (t == BREAK)
+ return parseBreak(tbl);
+ else if (t == CONTINUE)
+ return parseContinue(tbl);
+ else
+ return parseDeclarationOrExpression(tbl, false);
+ }
+
+ /* block.statement : "{" statement* "}"
+ */
+ private Stmnt parseBlock(SymbolTable tbl) throws CompileError {
+ if (lex.get() != '{')
+ throw new SyntaxError(lex);
+
+ Stmnt body = null;
+ SymbolTable tbl2 = new SymbolTable(tbl);
+ while (lex.lookAhead() != '}') {
+ Stmnt s = parseStatement(tbl2);
+ if (s != null)
+ body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s));
+ }
+
+ lex.get(); // '}'
+ if (body == null)
+ return new Stmnt(BLOCK); // empty block
+ else
+ return body;
+ }
+
+ /* if.statement : IF "(" expression ")" statement
+ * [ ELSE statement ]
+ */
+ private Stmnt parseIf(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // IF
+ ASTree expr = parseParExpression(tbl);
+ Stmnt thenp = parseStatement(tbl);
+ Stmnt elsep;
+ if (lex.lookAhead() == ELSE) {
+ lex.get();
+ elsep = parseStatement(tbl);
+ }
+ else
+ elsep = null;
+
+ return new Stmnt(t, expr, new ASTList(thenp, new ASTList(elsep)));
+ }
+
+ /* while.statement : WHILE "(" expression ")" statement
+ */
+ private Stmnt parseWhile(SymbolTable tbl)
+ throws CompileError
+ {
+ int t = lex.get(); // WHILE
+ ASTree expr = parseParExpression(tbl);
+ Stmnt body = parseStatement(tbl);
+ return new Stmnt(t, expr, body);
+ }
+
+ /* do.statement : DO statement WHILE "(" expression ")" ";"
+ */
+ private Stmnt parseDo(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // DO
+ Stmnt body = parseStatement(tbl);
+ if (lex.get() != WHILE || lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ ASTree expr = parseExpression(tbl);
+ if (lex.get() != ')' || lex.get() != ';')
+ throw new SyntaxError(lex);
+
+ return new Stmnt(t, expr, body);
+ }
+
+ /* for.statement : FOR "(" decl.or.expr expression ";" expression ")"
+ * statement
+ */
+ private Stmnt parseFor(SymbolTable tbl) throws CompileError {
+ Stmnt expr1, expr3;
+ ASTree expr2;
+ int t = lex.get(); // FOR
+
+ SymbolTable tbl2 = new SymbolTable(tbl);
+
+ if (lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ if (lex.lookAhead() == ';') {
+ lex.get();
+ expr1 = null;
+ }
+ else
+ expr1 = parseDeclarationOrExpression(tbl2, true);
+
+ if (lex.lookAhead() == ';')
+ expr2 = null;
+ else
+ expr2 = parseExpression(tbl2);
+
+ if (lex.get() != ';')
+ throw new CompileError("; is missing", lex);
+
+ if (lex.lookAhead() == ')')
+ expr3 = null;
+ else
+ expr3 = parseExprList(tbl2);
+
+ if (lex.get() != ')')
+ throw new CompileError(") is missing", lex);
+
+ Stmnt body = parseStatement(tbl2);
+ return new Stmnt(t, expr1, new ASTList(expr2,
+ new ASTList(expr3, body)));
+ }
+
+ /* switch.statement : SWITCH "(" expression ")" "{" switch.block "}"
+ *
+ * swtich.block : ( switch.label statement* )*
+ *
+ * swtich.label : DEFAULT ":"
+ * | CASE const.expression ":"
+ */
+ private Stmnt parseSwitch(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // SWITCH
+ ASTree expr = parseParExpression(tbl);
+ Stmnt body = parseSwitchBlock(tbl);
+ return new Stmnt(t, expr, body);
+ }
+
+ private Stmnt parseSwitchBlock(SymbolTable tbl) throws CompileError {
+ if (lex.get() != '{')
+ throw new SyntaxError(lex);
+
+ SymbolTable tbl2 = new SymbolTable(tbl);
+ Stmnt s = parseStmntOrCase(tbl2);
+ if (s == null)
+ throw new CompileError("empty switch block", lex);
+
+ int op = s.getOperator();
+ if (op != CASE && op != DEFAULT)
+ throw new CompileError("no case or default in a switch block",
+ lex);
+
+ Stmnt body = new Stmnt(BLOCK, s);
+ while (lex.lookAhead() != '}') {
+ Stmnt s2 = parseStmntOrCase(tbl2);
+ if (s2 != null) {
+ int op2 = s2.getOperator();
+ if (op2 == CASE || op2 == DEFAULT) {
+ body = (Stmnt)ASTList.concat(body, new Stmnt(BLOCK, s2));
+ s = s2;
+ }
+ else
+ s = (Stmnt)ASTList.concat(s, new Stmnt(BLOCK, s2));
+ }
+ }
+
+ lex.get(); // '}'
+ return body;
+ }
+
+ private Stmnt parseStmntOrCase(SymbolTable tbl) throws CompileError {
+ int t = lex.lookAhead();
+ if (t != CASE && t != DEFAULT)
+ return parseStatement(tbl);
+
+ lex.get();
+ Stmnt s;
+ if (t == CASE)
+ s = new Stmnt(t, parseExpression(tbl));
+ else
+ s = new Stmnt(DEFAULT);
+
+ if (lex.get() != ':')
+ throw new CompileError(": is missing", lex);
+
+ return s;
+ }
+
+ /* synchronized.statement :
+ * SYNCHRONIZED "(" expression ")" block.statement
+ */
+ private Stmnt parseSynchronized(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // SYNCHRONIZED
+ if (lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ ASTree expr = parseExpression(tbl);
+ if (lex.get() != ')')
+ throw new SyntaxError(lex);
+
+ Stmnt body = parseBlock(tbl);
+ return new Stmnt(t, expr, body);
+ }
+
+ /* try.statement
+ * : TRY block.statement
+ * [ CATCH "(" class.type Identifier ")" block.statement ]*
+ * [ FINALLY block.statement ]*
+ */
+ private Stmnt parseTry(SymbolTable tbl) throws CompileError {
+ lex.get(); // TRY
+ Stmnt block = parseBlock(tbl);
+ ASTList catchList = null;
+ while (lex.lookAhead() == CATCH) {
+ lex.get(); // CATCH
+ if (lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ SymbolTable tbl2 = new SymbolTable(tbl);
+ Declarator d = parseFormalParam(tbl2);
+ if (d.getArrayDim() > 0 || d.getType() != CLASS)
+ throw new SyntaxError(lex);
+
+ if (lex.get() != ')')
+ throw new SyntaxError(lex);
+
+ Stmnt b = parseBlock(tbl2);
+ catchList = ASTList.append(catchList, new Pair(d, b));
+ }
+
+ Stmnt finallyBlock = null;
+ if (lex.lookAhead() == FINALLY) {
+ lex.get(); // FINALLY
+ finallyBlock = parseBlock(tbl);
+ }
+
+ return Stmnt.make(TRY, block, catchList, finallyBlock);
+ }
+
+ /* return.statement : RETURN [ expression ] ";"
+ */
+ private Stmnt parseReturn(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // RETURN
+ Stmnt s = new Stmnt(t);
+ if (lex.lookAhead() != ';')
+ s.setLeft(parseExpression(tbl));
+
+ if (lex.get() != ';')
+ throw new CompileError("; is missing", lex);
+
+ return s;
+ }
+
+ /* throw.statement : THROW expression ";"
+ */
+ private Stmnt parseThrow(SymbolTable tbl) throws CompileError {
+ int t = lex.get(); // THROW
+ ASTree expr = parseExpression(tbl);
+ if (lex.get() != ';')
+ throw new CompileError("; is missing", lex);
+
+ return new Stmnt(t, expr);
+ }
+
+ /* break.statement : BREAK [ Identifier ] ";"
+ */
+ private Stmnt parseBreak(SymbolTable tbl)
+ throws CompileError
+ {
+ return parseContinue(tbl);
+ }
+
+ /* continue.statement : CONTINUE [ Identifier ] ";"
+ */
+ private Stmnt parseContinue(SymbolTable tbl)
+ throws CompileError
+ {
+ int t = lex.get(); // CONTINUE
+ Stmnt s = new Stmnt(t);
+ int t2 = lex.get();
+ if (t2 == Identifier) {
+ s.setLeft(new Symbol(lex.getString()));
+ t2 = lex.get();
+ }
+
+ if (t2 != ';')
+ throw new CompileError("; is missing", lex);
+
+ return s;
+ }
+
+ /* declaration.or.expression
+ * : [ FINAL ] built-in-type array.dimension declarators
+ * | [ FINAL ] class.type array.dimension declarators
+ * | expression ';'
+ * | expr.list ';' if exprList is true
+ *
+ * Note: FINAL is currently ignored. This must be fixed
+ * in future.
+ */
+ private Stmnt parseDeclarationOrExpression(SymbolTable tbl,
+ boolean exprList)
+ throws CompileError
+ {
+ int t = lex.lookAhead();
+ while (t == FINAL) {
+ lex.get();
+ t = lex.lookAhead();
+ }
+
+ if (isBuiltinType(t)) {
+ t = lex.get();
+ int dim = parseArrayDimension();
+ return parseDeclarators(tbl, new Declarator(t, dim));
+ }
+ else if (t == Identifier) {
+ int i = nextIsClassType(0);
+ if (i >= 0)
+ if (lex.lookAhead(i) == Identifier) {
+ ASTList name = parseClassType(tbl);
+ int dim = parseArrayDimension();
+ return parseDeclarators(tbl, new Declarator(name, dim));
+ }
+ }
+
+ Stmnt expr;
+ if (exprList)
+ expr = parseExprList(tbl);
+ else
+ expr = new Stmnt(EXPR, parseExpression(tbl));
+
+ if (lex.get() != ';')
+ throw new CompileError("; is missing", lex);
+
+ return expr;
+ }
+
+ /* expr.list : ( expression ',')* expression
+ */
+ private Stmnt parseExprList(SymbolTable tbl) throws CompileError {
+ Stmnt expr = null;
+ for (;;) {
+ Stmnt e = new Stmnt(EXPR, parseExpression(tbl));
+ expr = (Stmnt)ASTList.concat(expr, new Stmnt(BLOCK, e));
+ if (lex.lookAhead() == ',')
+ lex.get();
+ else
+ return expr;
+ }
+ }
+
+ /* declarators : declarator [ ',' declarator ]* ';'
+ */
+ private Stmnt parseDeclarators(SymbolTable tbl, Declarator d)
+ throws CompileError
+ {
+ Stmnt decl = null;
+ for (;;) {
+ decl = (Stmnt)ASTList.concat(decl,
+ new Stmnt(DECL, parseDeclarator(tbl, d)));
+ int t = lex.get();
+ if (t == ';')
+ return decl;
+ else if (t != ',')
+ throw new CompileError("; is missing", lex);
+ }
+ }
+
+ /* declarator : Identifier array.dimension [ '=' initializer ]
+ */
+ private Declarator parseDeclarator(SymbolTable tbl, Declarator d)
+ throws CompileError
+ {
+ if (lex.get() != Identifier || d.getType() == VOID)
+ throw new SyntaxError(lex);
+
+ String name = lex.getString();
+ Symbol symbol = new Symbol(name);
+ int dim = parseArrayDimension();
+ ASTree init = null;
+ if (lex.lookAhead() == '=') {
+ lex.get();
+ init = parseInitializer(tbl);
+ }
+
+ Declarator decl = d.make(symbol, dim, init);
+ tbl.append(name, decl);
+ return decl;
+ }
+
+ /* initializer : expression | array.initializer
+ */
+ private ASTree parseInitializer(SymbolTable tbl) throws CompileError {
+ if (lex.lookAhead() == '{')
+ return parseArrayInitializer(tbl);
+ else
+ return parseExpression(tbl);
+ }
+
+ /* array.initializer :
+ * '{' (( array.initializer | expression ) ',')* '}'
+ */
+ private ArrayInit parseArrayInitializer(SymbolTable tbl)
+ throws CompileError
+ {
+ lex.get(); // '{'
+ ASTree expr = parseExpression(tbl);
+ ArrayInit init = new ArrayInit(expr);
+ while (lex.lookAhead() == ',') {
+ lex.get();
+ expr = parseExpression(tbl);
+ ASTList.append(init, expr);
+ }
+
+ if (lex.get() != '}')
+ throw new SyntaxError(lex);
+
+ return init;
+ }
+
+ /* par.expression : '(' expression ')'
+ */
+ private ASTree parseParExpression(SymbolTable tbl) throws CompileError {
+ if (lex.get() != '(')
+ throw new SyntaxError(lex);
+
+ ASTree expr = parseExpression(tbl);
+ if (lex.get() != ')')
+ throw new SyntaxError(lex);
+
+ return expr;
+ }
+
+ /* expression : conditional.expr
+ * | conditional.expr assign.op expression (right-to-left)
+ */
+ public ASTree parseExpression(SymbolTable tbl) throws CompileError {
+ ASTree left = parseConditionalExpr(tbl);
+ if (!isAssignOp(lex.lookAhead()))
+ return left;
+
+ int t = lex.get();
+ ASTree right = parseExpression(tbl);
+ return AssignExpr.makeAssign(t, left, right);
+ }
+
+ private static boolean isAssignOp(int t) {
+ return t == '=' || t == MOD_E || t == AND_E
+ || t == MUL_E || t == PLUS_E || t == MINUS_E || t == DIV_E
+ || t == EXOR_E || t == OR_E || t == LSHIFT_E
+ || t == RSHIFT_E || t == ARSHIFT_E;
+ }
+
+ /* conditional.expr (right-to-left)
+ * : logical.or.expr [ '?' expression ':' conditional.expr ]
+ */
+ private ASTree parseConditionalExpr(SymbolTable tbl) throws CompileError {
+ ASTree cond = parseBinaryExpr(tbl);
+ if (lex.lookAhead() == '?') {
+ lex.get();
+ ASTree thenExpr = parseExpression(tbl);
+ if (lex.get() != ':')
+ throw new CompileError(": is missing", lex);
+
+ ASTree elseExpr = parseExpression(tbl);
+ return new CondExpr(cond, thenExpr, elseExpr);
+ }
+ else
+ return cond;
+ }
+
+ /* logical.or.expr 10 (operator precedence)
+ * : logical.and.expr
+ * | logical.or.expr OROR logical.and.expr left-to-right
+ *
+ * logical.and.expr 9
+ * : inclusive.or.expr
+ * | logical.and.expr ANDAND inclusive.or.expr
+ *
+ * inclusive.or.expr 8
+ * : exclusive.or.expr
+ * | inclusive.or.expr "|" exclusive.or.expr
+ *
+ * exclusive.or.expr 7
+ * : and.expr
+ * | exclusive.or.expr "^" and.expr
+ *
+ * and.expr 6
+ * : equality.expr
+ * | and.expr "&" equality.expr
+ *
+ * equality.expr 5
+ * : relational.expr
+ * | equality.expr (EQ | NEQ) relational.expr
+ *
+ * relational.expr 4
+ * : shift.expr
+ * | relational.expr (LE | GE | "<" | ">") shift.expr
+ * | relational.expr INSTANCEOF class.type ("[" "]")*
+ *
+ * shift.expr 3
+ * : additive.expr
+ * | shift.expr (LSHIFT | RSHIFT | ARSHIFT) additive.expr
+ *
+ * additive.expr 2
+ * : multiply.expr
+ * | additive.expr ("+" | "-") multiply.expr
+ *
+ * multiply.expr 1
+ * : unary.expr
+ * | multiply.expr ("*" | "/" | "%") unary.expr
+ */
+ private ASTree parseBinaryExpr(SymbolTable tbl) throws CompileError {
+ ASTree expr = parseUnaryExpr(tbl);
+ for (;;) {
+ int t = lex.lookAhead();
+ int p = getOpPrecedence(t);
+ if (p == 0)
+ return expr;
+ else
+ expr = binaryExpr2(tbl, expr, p);
+ }
+ }
+
+ private ASTree parseInstanceOf(SymbolTable tbl, ASTree expr)
+ throws CompileError
+ {
+ int t = lex.lookAhead();
+ if (isBuiltinType(t)) {
+ lex.get(); // primitive type
+ int dim = parseArrayDimension();
+ return new InstanceOfExpr(t, dim, expr);
+ }
+ else {
+ ASTList name = parseClassType(tbl);
+ int dim = parseArrayDimension();
+ return new InstanceOfExpr(name, dim, expr);
+ }
+ }
+
+ private ASTree binaryExpr2(SymbolTable tbl, ASTree expr, int prec)
+ throws CompileError
+ {
+ int t = lex.get();
+ if (t == INSTANCEOF)
+ return parseInstanceOf(tbl, expr);
+
+ ASTree expr2 = parseUnaryExpr(tbl);
+ for (;;) {
+ int t2 = lex.lookAhead();
+ int p2 = getOpPrecedence(t2);
+ if (p2 != 0 && prec > p2)
+ expr2 = binaryExpr2(tbl, expr2, p2);
+ else
+ return BinExpr.makeBin(t, expr, expr2);
+ }
+ }
+
+ // !"#$%&'( )*+,-./0 12345678 9:;<=>?
+ private static final int[] binaryOpPrecedence
+ = { 0, 0, 0, 0, 1, 6, 0, 0,
+ 0, 1, 2, 0, 2, 0, 1, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 4, 0, 4, 0 };
+
+ private int getOpPrecedence(int c) {
+ if ('!' <= c && c <= '?')
+ return binaryOpPrecedence[c - '!'];
+ else if (c == '^')
+ return 7;
+ else if (c == '|')
+ return 8;
+ else if (c == ANDAND)
+ return 9;
+ else if (c == OROR)
+ return 10;
+ else if (c == EQ || c == NEQ)
+ return 5;
+ else if (c == LE || c == GE || c == INSTANCEOF)
+ return 4;
+ else if (c == LSHIFT || c == RSHIFT || c == ARSHIFT)
+ return 3;
+ else
+ return 0; // not a binary operator
+ }
+
+ /* unary.expr : "++"|"--" unary.expr
+ | "+"|"-" unary.expr
+ | "!"|"~" unary.expr
+ | cast.expr
+ | postfix.expr
+
+ unary.expr.not.plus.minus is a unary expression starting without
+ "+", "-", "++", or "--".
+ */
+ private ASTree parseUnaryExpr(SymbolTable tbl) throws CompileError {
+ int t;
+ switch (lex.lookAhead()) {
+ case '+' :
+ case '-' :
+ case PLUSPLUS :
+ case MINUSMINUS :
+ case '!' :
+ case '~' :
+ t = lex.get();
+ if (t == '-') {
+ int t2 = lex.lookAhead();
+ switch (t2) {
+ case LongConstant :
+ case IntConstant :
+ case CharConstant :
+ lex.get();
+ return new IntConst(-lex.getLong(), t2);
+ case DoubleConstant :
+ case FloatConstant :
+ lex.get();
+ return new DoubleConst(-lex.getDouble(), t2);
+ default :
+ break;
+ }
+ }
+
+ return Expr.make(t, parseUnaryExpr(tbl));
+ case '(' :
+ return parseCast(tbl);
+ default :
+ return parsePostfix(tbl);
+ }
+ }
+
+ /* cast.expr : "(" builtin.type ("[" "]")* ")" unary.expr
+ | "(" class.type ("[" "]")* ")" unary.expr2
+
+ unary.expr2 is a unary.expr beginning with "(", NULL, StringL,
+ Identifier, THIS, SUPER, or NEW.
+
+ Either "(int.class)" or "(String[].class)" is a not cast expression.
+ */
+ private ASTree parseCast(SymbolTable tbl) throws CompileError {
+ int t = lex.lookAhead(1);
+ if (isBuiltinType(t) && nextIsBuiltinCast()) {
+ lex.get(); // '('
+ lex.get(); // primitive type
+ int dim = parseArrayDimension();
+ if (lex.get() != ')')
+ throw new CompileError(") is missing", lex);
+
+ return new CastExpr(t, dim, parseUnaryExpr(tbl));
+ }
+ else if (t == Identifier && nextIsClassCast()) {
+ lex.get(); // '('
+ ASTList name = parseClassType(tbl);
+ int dim = parseArrayDimension();
+ if (lex.get() != ')')
+ throw new CompileError(") is missing", lex);
+
+ return new CastExpr(name, dim, parseUnaryExpr(tbl));
+ }
+ else
+ return parsePostfix(tbl);
+ }
+
+ private boolean nextIsBuiltinCast() {
+ int t;
+ int i = 2;
+ while ((t = lex.lookAhead(i++)) == '[')
+ if (lex.lookAhead(i++) != ']')
+ return false;
+
+ return lex.lookAhead(i - 1) == ')';
+ }
+
+ private boolean nextIsClassCast() {
+ int i = nextIsClassType(1);
+ if (i < 0)
+ return false;
+
+ int t = lex.lookAhead(i);
+ if (t != ')')
+ return false;
+
+ t = lex.lookAhead(i + 1);
+ return t == '(' || t == NULL || t == StringL
+ || t == Identifier || t == THIS || t == SUPER || t == NEW
+ || t == TRUE || t == FALSE || t == LongConstant
+ || t == IntConstant || t == CharConstant
+ || t == DoubleConstant || t == FloatConstant;
+ }
+
+ private int nextIsClassType(int i) {
+ int t;
+ while (lex.lookAhead(++i) == '.')
+ if (lex.lookAhead(++i) != Identifier)
+ return -1;
+
+ while ((t = lex.lookAhead(i++)) == '[')
+ if (lex.lookAhead(i++) != ']')
+ return -1;
+
+ return i - 1;
+ }
+
+ /* array.dimension : [ "[" "]" ]*
+ */
+ private int parseArrayDimension() throws CompileError {
+ int arrayDim = 0;
+ while (lex.lookAhead() == '[') {
+ ++arrayDim;
+ lex.get();
+ if (lex.get() != ']')
+ throw new CompileError("] is missing", lex);
+ }
+
+ return arrayDim;
+ }
+
+ /* class.type : Identifier ( "." Identifier )*
+ */
+ private ASTList parseClassType(SymbolTable tbl) throws CompileError {
+ ASTList list = null;
+ for (;;) {
+ if (lex.get() != Identifier)
+ throw new SyntaxError(lex);
+
+ list = ASTList.append(list, new Symbol(lex.getString()));
+ if (lex.lookAhead() == '.')
+ lex.get();
+ else
+ break;
+ }
+
+ return list;
+ }
+
+ /* postfix.expr : number.literal
+ * | primary.expr
+ * | method.expr
+ * | postfix.expr "++" | "--"
+ * | postfix.expr "[" array.size "]"
+ * | postfix.expr "." Identifier
+ * | postfix.expr ( "[" "]" )* "." CLASS
+ * | postfix.expr "#" Identifier
+ *
+ * "#" is not an operator of regular Java. It separates
+ * a class name and a member name in an expression for static member
+ * access. For example,
+ * java.lang.Integer.toString(3) in regular Java
+ * can be written like this:
+ * java.lang.Integer#toString(3) for this compiler.
+ */
+ private ASTree parsePostfix(SymbolTable tbl) throws CompileError {
+ int token = lex.lookAhead();
+ switch (token) { // see also parseUnaryExpr()
+ case LongConstant :
+ case IntConstant :
+ case CharConstant :
+ lex.get();
+ return new IntConst(lex.getLong(), token);
+ case DoubleConstant :
+ case FloatConstant :
+ lex.get();
+ return new DoubleConst(lex.getDouble(), token);
+ default :
+ break;
+ }
+
+ String str;
+ ASTree index;
+ ASTree expr = parsePrimaryExpr(tbl);
+ int t;
+ while (true) {
+ switch (lex.lookAhead()) {
+ case '(' :
+ expr = parseMethodCall(tbl, expr);
+ break;
+ case '[' :
+ if (lex.lookAhead(1) == ']') {
+ int dim = parseArrayDimension();
+ if (lex.get() != '.' || lex.get() != CLASS)
+ throw new SyntaxError(lex);
+
+ expr = parseDotClass(expr, dim);
+ }
+ else {
+ index = parseArrayIndex(tbl);
+ if (index == null)
+ throw new SyntaxError(lex);
+
+ expr = Expr.make(ARRAY, expr, index);
+ }
+ break;
+ case PLUSPLUS :
+ case MINUSMINUS :
+ t = lex.get();
+ expr = Expr.make(t, null, expr);
+ break;
+ case '.' :
+ lex.get();
+ t = lex.get();
+ if (t == CLASS) {
+ expr = parseDotClass(expr, 0);
+ }
+ else if (t == Identifier) {
+ str = lex.getString();
+ expr = Expr.make('.', expr, new Member(str));
+ }
+ else
+ throw new CompileError("missing member name", lex);
+ break;
+ case '#' :
+ lex.get();
+ t = lex.get();
+ if (t != Identifier)
+ throw new CompileError("missing static member name", lex);
+
+ str = lex.getString();
+ expr = Expr.make(MEMBER, new Symbol(toClassName(expr)),
+ new Member(str));
+ break;
+ default :
+ return expr;
+ }
+ }
+ }
+
+ /* Parse a .class expression on a class type. For example,
+ * String.class => ('.' "String" "class")
+ * String[].class => ('.' "[LString;" "class")
+ */
+ private ASTree parseDotClass(ASTree className, int dim)
+ throws CompileError
+ {
+ String cname = toClassName(className);
+ if (dim > 0) {
+ StringBuffer sbuf = new StringBuffer();
+ while (dim-- > 0)
+ sbuf.append('[');
+
+ sbuf.append('L').append(cname.replace('.', '/')).append(';');
+ cname = sbuf.toString();
+ }
+
+ return Expr.make('.', new Symbol(cname), new Member("class"));
+ }
+
+ /* Parses a .class expression on a built-in type. For example,
+ * int.class => ('#' "java.lang.Integer" "TYPE")
+ * int[].class => ('.' "[I", "class")
+ */
+ private ASTree parseDotClass(int builtinType, int dim)
+ throws CompileError
+ {
+ if (dim > 0) {
+ String cname = CodeGen.toJvmTypeName(builtinType, dim);
+ return Expr.make('.', new Symbol(cname), new Member("class"));
+ }
+ else {
+ String cname;
+ switch(builtinType) {
+ case BOOLEAN :
+ cname = "java.lang.Boolean";
+ break;
+ case BYTE :
+ cname = "java.lang.Byte";
+ break;
+ case CHAR :
+ cname = "java.lang.Character";
+ break;
+ case SHORT :
+ cname = "java.lang.Short";
+ break;
+ case INT :
+ cname = "java.lang.Integer";
+ break;
+ case LONG :
+ cname = "java.lang.Long";
+ break;
+ case FLOAT :
+ cname = "java.lang.Float";
+ break;
+ case DOUBLE :
+ cname = "java.lang.Double";
+ break;
+ case VOID :
+ cname = "java.lang.Void";
+ break;
+ default :
+ throw new CompileError("invalid builtin type: "
+ + builtinType);
+ }
+
+ return Expr.make(MEMBER, new Symbol(cname), new Member("TYPE"));
+ }
+ }
+
+ /* method.call : method.expr "(" argument.list ")"
+ * method.expr : THIS | SUPER | Identifier
+ * | postfix.expr "." Identifier
+ * | postfix.expr "#" Identifier
+ */
+ private ASTree parseMethodCall(SymbolTable tbl, ASTree expr)
+ throws CompileError
+ {
+ if (expr instanceof Keyword) {
+ int token = ((Keyword)expr).get();
+ if (token != THIS && token != SUPER)
+ throw new SyntaxError(lex);
+ }
+ else if (expr instanceof Symbol) // Identifier
+ ;
+ else if (expr instanceof Expr) {
+ int op = ((Expr)expr).getOperator();
+ if (op != '.' && op != MEMBER)
+ throw new SyntaxError(lex);
+ }
+
+ return CallExpr.makeCall(expr, parseArgumentList(tbl));
+ }
+
+ private String toClassName(ASTree name)
+ throws CompileError
+ {
+ StringBuffer sbuf = new StringBuffer();
+ toClassName(name, sbuf);
+ return sbuf.toString();
+ }
+
+ private void toClassName(ASTree name, StringBuffer sbuf)
+ throws CompileError
+ {
+ if (name instanceof Symbol) {
+ sbuf.append(((Symbol)name).get());
+ return;
+ }
+ else if (name instanceof Expr) {
+ Expr expr = (Expr)name;
+ if (expr.getOperator() == '.') {
+ toClassName(expr.oprand1(), sbuf);
+ sbuf.append('.');
+ toClassName(expr.oprand2(), sbuf);
+ return;
+ }
+ }
+
+ throw new CompileError("bad static member access", lex);
+ }
+
+ /* primary.expr : THIS | SUPER | TRUE | FALSE | NULL
+ * | StringL
+ * | Identifier
+ * | NEW new.expr
+ * | "(" expression ")"
+ * | builtin.type ( "[" "]" )* "." CLASS
+ *
+ * Identifier represents either a local variable name, a member name,
+ * or a class name.
+ */
+ private ASTree parsePrimaryExpr(SymbolTable tbl) throws CompileError {
+ int t;
+ String name;
+ Declarator decl;
+ ASTree expr;
+
+ switch (t = lex.get()) {
+ case THIS :
+ case SUPER :
+ case TRUE :
+ case FALSE :
+ case NULL :
+ return new Keyword(t);
+ case Identifier :
+ name = lex.getString();
+ decl = tbl.lookup(name);
+ if (decl == null)
+ return new Member(name); // this or static member
+ else
+ return new Variable(name, decl); // local variable
+ case StringL :
+ return new StringL(lex.getString());
+ case NEW :
+ return parseNew(tbl);
+ case '(' :
+ expr = parseExpression(tbl);
+ if (lex.get() == ')')
+ return expr;
+ else
+ throw new CompileError(") is missing", lex);
+ default :
+ if (isBuiltinType(t) || t == VOID) {
+ int dim = parseArrayDimension();
+ if (lex.get() == '.' && lex.get() == CLASS)
+ return parseDotClass(t, dim);
+ }
+
+ throw new SyntaxError(lex);
+ }
+ }
+
+ /* new.expr : class.type "(" argument.list ")"
+ * | class.type array.size [ array.initializer ]
+ * | primitive.type array.size [ array.initializer ]
+ */
+ private NewExpr parseNew(SymbolTable tbl) throws CompileError {
+ ArrayInit init = null;
+ int t = lex.lookAhead();
+ if (isBuiltinType(t)) {
+ lex.get();
+ ASTList size = parseArraySize(tbl);
+ if (lex.lookAhead() == '{')
+ init = parseArrayInitializer(tbl);
+
+ return new NewExpr(t, size, init);
+ }
+ else if (t == Identifier) {
+ ASTList name = parseClassType(tbl);
+ t = lex.lookAhead();
+ if (t == '(') {
+ ASTList args = parseArgumentList(tbl);
+ return new NewExpr(name, args);
+ }
+ else if (t == '[') {
+ ASTList size = parseArraySize(tbl);
+ if (lex.lookAhead() == '{')
+ init = parseArrayInitializer(tbl);
+
+ return NewExpr.makeObjectArray(name, size, init);
+ }
+ }
+
+ throw new SyntaxError(lex);
+ }
+
+ /* array.size : [ array.index ]*
+ */
+ private ASTList parseArraySize(SymbolTable tbl) throws CompileError {
+ ASTList list = null;
+ while (lex.lookAhead() == '[')
+ list = ASTList.append(list, parseArrayIndex(tbl));
+
+ return list;
+ }
+
+ /* array.index : "[" [ expression ] "]"
+ */
+ private ASTree parseArrayIndex(SymbolTable tbl) throws CompileError {
+ lex.get(); // '['
+ if (lex.lookAhead() == ']') {
+ lex.get();
+ return null;
+ }
+ else {
+ ASTree index = parseExpression(tbl);
+ if (lex.get() != ']')
+ throw new CompileError("] is missing", lex);
+
+ return index;
+ }
+ }
+
+ /* argument.list : "(" [ expression [ "," expression ]* ] ")"
+ */
+ private ASTList parseArgumentList(SymbolTable tbl) throws CompileError {
+ if (lex.get() != '(')
+ throw new CompileError("( is missing", lex);
+
+ ASTList list = null;
+ if (lex.lookAhead() != ')')
+ for (;;) {
+ list = ASTList.append(list, parseExpression(tbl));
+ if (lex.lookAhead() == ',')
+ lex.get();
+ else
+ break;
+ }
+
+ if (lex.get() != ')')
+ throw new CompileError(") is missing", lex);
+
+ return list;
+ }
+}
+
diff --git a/src/main/javassist/compiler/ProceedHandler.java b/src/main/javassist/compiler/ProceedHandler.java
new file mode 100644
index 0000000..fd77f0e
--- /dev/null
+++ b/src/main/javassist/compiler/ProceedHandler.java
@@ -0,0 +1,30 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.bytecode.Bytecode;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * An interface to an object for implementing $proceed().
+ *
+ * @see javassist.compiler.JvstCodeGen#setProceedHandler(ProceedHandler, String)
+ * @see javassist.compiler.JvstCodeGen#atMethodCall(Expr)
+ */
+public interface ProceedHandler {
+ void doit(JvstCodeGen gen, Bytecode b, ASTList args) throws CompileError;
+ void setReturnType(JvstTypeChecker c, ASTList args) throws CompileError;
+}
diff --git a/src/main/javassist/compiler/SymbolTable.java b/src/main/javassist/compiler/SymbolTable.java
new file mode 100644
index 0000000..8f35f36
--- /dev/null
+++ b/src/main/javassist/compiler/SymbolTable.java
@@ -0,0 +1,44 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import java.util.HashMap;
+import javassist.compiler.ast.Declarator;
+
+public final class SymbolTable extends HashMap {
+ private SymbolTable parent;
+
+ public SymbolTable() { this(null); }
+
+ public SymbolTable(SymbolTable p) {
+ super();
+ parent = p;
+ }
+
+ public SymbolTable getParent() { return parent; }
+
+ public Declarator lookup(String name) {
+ Declarator found = (Declarator)get(name);
+ if (found == null && parent != null)
+ return parent.lookup(name);
+ else
+ return found;
+ }
+
+ public void append(String name, Declarator value) {
+ put(name, value);
+ }
+}
diff --git a/src/main/javassist/compiler/SyntaxError.java b/src/main/javassist/compiler/SyntaxError.java
new file mode 100644
index 0000000..dcbb937
--- /dev/null
+++ b/src/main/javassist/compiler/SyntaxError.java
@@ -0,0 +1,22 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+public class SyntaxError extends CompileError {
+ public SyntaxError(Lex lexer) {
+ super("syntax error near \"" + lexer.getTextAround() + "\"", lexer);
+ }
+}
diff --git a/src/main/javassist/compiler/TokenId.java b/src/main/javassist/compiler/TokenId.java
new file mode 100644
index 0000000..6a94768
--- /dev/null
+++ b/src/main/javassist/compiler/TokenId.java
@@ -0,0 +1,124 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+public interface TokenId {
+ int ABSTRACT = 300;
+ int BOOLEAN = 301;
+ int BREAK = 302;
+ int BYTE = 303;
+ int CASE = 304;
+ int CATCH = 305;
+ int CHAR = 306;
+ int CLASS = 307;
+ int CONST = 308; // reserved keyword
+ int CONTINUE = 309;
+ int DEFAULT = 310;
+ int DO = 311;
+ int DOUBLE = 312;
+ int ELSE = 313;
+ int EXTENDS = 314;
+ int FINAL = 315;
+ int FINALLY = 316;
+ int FLOAT = 317;
+ int FOR = 318;
+ int GOTO = 319; // reserved keyword
+ int IF = 320;
+ int IMPLEMENTS = 321;
+ int IMPORT = 322;
+ int INSTANCEOF = 323;
+ int INT = 324;
+ int INTERFACE = 325;
+ int LONG = 326;
+ int NATIVE = 327;
+ int NEW = 328;
+ int PACKAGE = 329;
+ int PRIVATE = 330;
+ int PROTECTED = 331;
+ int PUBLIC = 332;
+ int RETURN = 333;
+ int SHORT = 334;
+ int STATIC = 335;
+ int SUPER = 336;
+ int SWITCH = 337;
+ int SYNCHRONIZED = 338;
+ int THIS = 339;
+ int THROW = 340;
+ int THROWS = 341;
+ int TRANSIENT = 342;
+ int TRY = 343;
+ int VOID = 344;
+ int VOLATILE = 345;
+ int WHILE = 346;
+ int STRICT = 347;
+
+ int NEQ = 350; // !=
+ int MOD_E = 351; // %=
+ int AND_E = 352; // &=
+ int MUL_E = 353; // *=
+ int PLUS_E = 354; // +=
+ int MINUS_E = 355; // -=
+ int DIV_E = 356; // /=
+ int LE = 357; // <=
+ int EQ = 358; // ==
+ int GE = 359; // >=
+ int EXOR_E = 360; // ^=
+ int OR_E = 361; // |=
+ int PLUSPLUS = 362; // ++
+ int MINUSMINUS = 363; // --
+ int LSHIFT = 364; // <<
+ int LSHIFT_E = 365; // <<=
+ int RSHIFT = 366; // >>
+ int RSHIFT_E = 367; // >>=
+ int OROR = 368; // ||
+ int ANDAND = 369; // &&
+ int ARSHIFT = 370; // >>>
+ int ARSHIFT_E = 371; // >>>=
+
+ // operators from NEQ to ARSHIFT_E
+ String opNames[] = { "!=", "%=", "&=", "*=", "+=", "-=", "/=",
+ "<=", "==", ">=", "^=", "|=", "++", "--",
+ "<<", "<<=", ">>", ">>=", "||", "&&", ">>>",
+ ">>>=" };
+
+ // operators from MOD_E to ARSHIFT_E
+ int assignOps[] = { '%', '&', '*', '+', '-', '/', 0, 0, 0,
+ '^', '|', 0, 0, 0, LSHIFT, 0, RSHIFT, 0, 0, 0,
+ ARSHIFT };
+
+ int Identifier = 400;
+ int CharConstant = 401;
+ int IntConstant = 402;
+ int LongConstant = 403;
+ int FloatConstant = 404;
+ int DoubleConstant = 405;
+ int StringL = 406;
+
+ int TRUE = 410;
+ int FALSE = 411;
+ int NULL = 412;
+
+ int CALL = 'C'; // method call
+ int ARRAY = 'A'; // array access
+ int MEMBER = '#'; // static member access
+
+ int EXPR = 'E'; // expression statement
+ int LABEL = 'L'; // label statement
+ int BLOCK = 'B'; // block statement
+ int DECL = 'D'; // declaration statement
+
+ int BadToken = 500;
+}
diff --git a/src/main/javassist/compiler/TypeChecker.java b/src/main/javassist/compiler/TypeChecker.java
new file mode 100644
index 0000000..d2cb861
--- /dev/null
+++ b/src/main/javassist/compiler/TypeChecker.java
@@ -0,0 +1,1008 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler;
+
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.ClassPool;
+import javassist.Modifier;
+import javassist.NotFoundException;
+import javassist.compiler.ast.*;
+import javassist.bytecode.*;
+
+public class TypeChecker extends Visitor implements Opcode, TokenId {
+ static final String javaLangObject = "java.lang.Object";
+ static final String jvmJavaLangObject = "java/lang/Object";
+ static final String jvmJavaLangString = "java/lang/String";
+ static final String jvmJavaLangClass = "java/lang/Class";
+
+ /* The following fields are used by atXXX() methods
+ * for returning the type of the compiled expression.
+ */
+ protected int exprType; // VOID, NULL, CLASS, BOOLEAN, INT, ...
+ protected int arrayDim;
+ protected String className; // JVM-internal representation
+
+ protected MemberResolver resolver;
+ protected CtClass thisClass;
+ protected MethodInfo thisMethod;
+
+ public TypeChecker(CtClass cc, ClassPool cp) {
+ resolver = new MemberResolver(cp);
+ thisClass = cc;
+ thisMethod = null;
+ }
+
+ /*
+ * Converts an array of tuples of exprType, arrayDim, and className
+ * into a String object.
+ */
+ protected static String argTypesToString(int[] types, int[] dims,
+ String[] cnames) {
+ StringBuffer sbuf = new StringBuffer();
+ sbuf.append('(');
+ int n = types.length;
+ if (n > 0) {
+ int i = 0;
+ while (true) {
+ typeToString(sbuf, types[i], dims[i], cnames[i]);
+ if (++i < n)
+ sbuf.append(',');
+ else
+ break;
+ }
+ }
+
+ sbuf.append(')');
+ return sbuf.toString();
+ }
+
+ /*
+ * Converts a tuple of exprType, arrayDim, and className
+ * into a String object.
+ */
+ protected static StringBuffer typeToString(StringBuffer sbuf,
+ int type, int dim, String cname) {
+ String s;
+ if (type == CLASS)
+ s = MemberResolver.jvmToJavaName(cname);
+ else if (type == NULL)
+ s = "Object";
+ else
+ try {
+ s = MemberResolver.getTypeName(type);
+ }
+ catch (CompileError e) {
+ s = "?";
+ }
+
+ sbuf.append(s);
+ while (dim-- > 0)
+ sbuf.append("[]");
+
+ return sbuf;
+ }
+
+ /**
+ * Records the currently compiled method.
+ */
+ public void setThisMethod(MethodInfo m) {
+ thisMethod = m;
+ }
+
+ protected static void fatal() throws CompileError {
+ throw new CompileError("fatal");
+ }
+
+ /**
+ * Returns the JVM-internal representation of this class name.
+ */
+ protected String getThisName() {
+ return MemberResolver.javaToJvmName(thisClass.getName());
+ }
+
+ /**
+ * Returns the JVM-internal representation of this super class name.
+ */
+ protected String getSuperName() throws CompileError {
+ return MemberResolver.javaToJvmName(
+ MemberResolver.getSuperclass(thisClass).getName());
+ }
+
+ /* Converts a class name into a JVM-internal representation.
+ *
+ * It may also expand a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected String resolveClassName(ASTList name) throws CompileError {
+ return resolver.resolveClassName(name);
+ }
+
+ /* Expands a simple class name to java.lang.*.
+ * For example, this converts Object into java/lang/Object.
+ */
+ protected String resolveClassName(String jvmName) throws CompileError {
+ return resolver.resolveJvmClassName(jvmName);
+ }
+
+ public void atNewExpr(NewExpr expr) throws CompileError {
+ if (expr.isArray())
+ atNewArrayExpr(expr);
+ else {
+ CtClass clazz = resolver.lookupClassByName(expr.getClassName());
+ String cname = clazz.getName();
+ ASTList args = expr.getArguments();
+ atMethodCallCore(clazz, MethodInfo.nameInit, args);
+ exprType = CLASS;
+ arrayDim = 0;
+ className = MemberResolver.javaToJvmName(cname);
+ }
+ }
+
+ public void atNewArrayExpr(NewExpr expr) throws CompileError {
+ int type = expr.getArrayType();
+ ASTList size = expr.getArraySize();
+ ASTList classname = expr.getClassName();
+ ASTree init = expr.getInitializer();
+ if (init != null)
+ init.accept(this);
+
+ if (size.length() > 1)
+ atMultiNewArray(type, classname, size);
+ else {
+ ASTree sizeExpr = size.head();
+ if (sizeExpr != null)
+ sizeExpr.accept(this);
+
+ exprType = type;
+ arrayDim = 1;
+ if (type == CLASS)
+ className = resolveClassName(classname);
+ else
+ className = null;
+ }
+ }
+
+ public void atArrayInit(ArrayInit init) throws CompileError {
+ ASTList list = init;
+ while (list != null) {
+ ASTree h = list.head();
+ list = list.tail();
+ if (h != null)
+ h.accept(this);
+ }
+ }
+
+ protected void atMultiNewArray(int type, ASTList classname, ASTList size)
+ throws CompileError
+ {
+ int count, dim;
+ dim = size.length();
+ for (count = 0; size != null; size = size.tail()) {
+ ASTree s = size.head();
+ if (s == null)
+ break; // int[][][] a = new int[3][4][];
+
+ ++count;
+ s.accept(this);
+ }
+
+ exprType = type;
+ arrayDim = dim;
+ if (type == CLASS)
+ className = resolveClassName(classname);
+ else
+ className = null;
+ }
+
+ public void atAssignExpr(AssignExpr expr) throws CompileError {
+ // =, %=, &=, *=, /=, +=, -=, ^=, |=, <<=, >>=, >>>=
+ int op = expr.getOperator();
+ ASTree left = expr.oprand1();
+ ASTree right = expr.oprand2();
+ if (left instanceof Variable)
+ atVariableAssign(expr, op, (Variable)left,
+ ((Variable)left).getDeclarator(),
+ right);
+ else {
+ if (left instanceof Expr) {
+ Expr e = (Expr)left;
+ if (e.getOperator() == ARRAY) {
+ atArrayAssign(expr, op, (Expr)left, right);
+ return;
+ }
+ }
+
+ atFieldAssign(expr, op, left, right);
+ }
+ }
+
+ /* op is either =, %=, &=, *=, /=, +=, -=, ^=, |=, <<=, >>=, or >>>=.
+ *
+ * expr and var can be null.
+ */
+ private void atVariableAssign(Expr expr, int op, Variable var,
+ Declarator d, ASTree right)
+ throws CompileError
+ {
+ int varType = d.getType();
+ int varArray = d.getArrayDim();
+ String varClass = d.getClassName();
+
+ if (op != '=')
+ atVariable(var);
+
+ right.accept(this);
+ exprType = varType;
+ arrayDim = varArray;
+ className = varClass;
+ }
+
+ private void atArrayAssign(Expr expr, int op, Expr array,
+ ASTree right) throws CompileError
+ {
+ atArrayRead(array.oprand1(), array.oprand2());
+ int aType = exprType;
+ int aDim = arrayDim;
+ String cname = className;
+ right.accept(this);
+ exprType = aType;
+ arrayDim = aDim;
+ className = cname;
+ }
+
+ protected void atFieldAssign(Expr expr, int op, ASTree left, ASTree right)
+ throws CompileError
+ {
+ CtField f = fieldAccess(left);
+ atFieldRead(f);
+ int fType = exprType;
+ int fDim = arrayDim;
+ String cname = className;
+ right.accept(this);
+ exprType = fType;
+ arrayDim = fDim;
+ className = cname;
+ }
+
+ public void atCondExpr(CondExpr expr) throws CompileError {
+ booleanExpr(expr.condExpr());
+ expr.thenExpr().accept(this);
+ int type1 = exprType;
+ int dim1 = arrayDim;
+ String cname1 = className;
+ expr.elseExpr().accept(this);
+
+ if (dim1 == 0 && dim1 == arrayDim)
+ if (CodeGen.rightIsStrong(type1, exprType))
+ expr.setThen(new CastExpr(exprType, 0, expr.thenExpr()));
+ else if (CodeGen.rightIsStrong(exprType, type1)) {
+ expr.setElse(new CastExpr(type1, 0, expr.elseExpr()));
+ exprType = type1;
+ }
+ }
+
+ /*
+ * If atBinExpr() substitutes a new expression for the original
+ * binary-operator expression, it changes the operator name to '+'
+ * (if the original is not '+') and sets the new expression to the
+ * left-hand-side expression and null to the right-hand-side expression.
+ */
+ public void atBinExpr(BinExpr expr) throws CompileError {
+ int token = expr.getOperator();
+ int k = CodeGen.lookupBinOp(token);
+ if (k >= 0) {
+ /* arithmetic operators: +, -, *, /, %, |, ^, &, <<, >>, >>>
+ */
+ if (token == '+') {
+ Expr e = atPlusExpr(expr);
+ if (e != null) {
+ /* String concatenation has been translated into
+ * an expression using StringBuffer.
+ */
+ e = CallExpr.makeCall(Expr.make('.', e,
+ new Member("toString")), null);
+ expr.setOprand1(e);
+ expr.setOprand2(null); // <---- look at this!
+ className = jvmJavaLangString;
+ }
+ }
+ else {
+ ASTree left = expr.oprand1();
+ ASTree right = expr.oprand2();
+ left.accept(this);
+ int type1 = exprType;
+ right.accept(this);
+ if (!isConstant(expr, token, left, right))
+ computeBinExprType(expr, token, type1);
+ }
+ }
+ else {
+ /* equation: &&, ||, ==, !=, <=, >=, <, >
+ */
+ booleanExpr(expr);
+ }
+ }
+
+ /* EXPR must be a + expression.
+ * atPlusExpr() returns non-null if the given expression is string
+ * concatenation. The returned value is "new StringBuffer().append..".
+ */
+ private Expr atPlusExpr(BinExpr expr) throws CompileError {
+ ASTree left = expr.oprand1();
+ ASTree right = expr.oprand2();
+ if (right == null) {
+ // this expression has been already type-checked.
+ // see atBinExpr() above.
+ left.accept(this);
+ return null;
+ }
+
+ if (isPlusExpr(left)) {
+ Expr newExpr = atPlusExpr((BinExpr)left);
+ if (newExpr != null) {
+ right.accept(this);
+ exprType = CLASS;
+ arrayDim = 0;
+ className = "java/lang/StringBuffer";
+ return makeAppendCall(newExpr, right);
+ }
+ }
+ else
+ left.accept(this);
+
+ int type1 = exprType;
+ int dim1 = arrayDim;
+ String cname = className;
+ right.accept(this);
+
+ if (isConstant(expr, '+', left, right))
+ return null;
+
+ if ((type1 == CLASS && dim1 == 0 && jvmJavaLangString.equals(cname))
+ || (exprType == CLASS && arrayDim == 0
+ && jvmJavaLangString.equals(className))) {
+ ASTList sbufClass = ASTList.make(new Symbol("java"),
+ new Symbol("lang"), new Symbol("StringBuffer"));
+ ASTree e = new NewExpr(sbufClass, null);
+ exprType = CLASS;
+ arrayDim = 0;
+ className = "java/lang/StringBuffer";
+ return makeAppendCall(makeAppendCall(e, left), right);
+ }
+ else {
+ computeBinExprType(expr, '+', type1);
+ return null;
+ }
+ }
+
+ private boolean isConstant(BinExpr expr, int op, ASTree left,
+ ASTree right) throws CompileError
+ {
+ left = stripPlusExpr(left);
+ right = stripPlusExpr(right);
+ ASTree newExpr = null;
+ if (left instanceof StringL && right instanceof StringL && op == '+')
+ newExpr = new StringL(((StringL)left).get()
+ + ((StringL)right).get());
+ else if (left instanceof IntConst)
+ newExpr = ((IntConst)left).compute(op, right);
+ else if (left instanceof DoubleConst)
+ newExpr = ((DoubleConst)left).compute(op, right);
+
+ if (newExpr == null)
+ return false; // not a constant expression
+ else {
+ expr.setOperator('+');
+ expr.setOprand1(newExpr);
+ expr.setOprand2(null);
+ newExpr.accept(this); // for setting exprType, arrayDim, ...
+ return true;
+ }
+ }
+
+ /* CodeGen.atSwitchStmnt() also calls stripPlusExpr().
+ */
+ static ASTree stripPlusExpr(ASTree expr) {
+ if (expr instanceof BinExpr) {
+ BinExpr e = (BinExpr)expr;
+ if (e.getOperator() == '+' && e.oprand2() == null)
+ return e.getLeft();
+ }
+ else if (expr instanceof Expr) { // note: BinExpr extends Expr.
+ Expr e = (Expr)expr;
+ int op = e.getOperator();
+ if (op == MEMBER) {
+ ASTree cexpr = getConstantFieldValue((Member)e.oprand2());
+ if (cexpr != null)
+ return cexpr;
+ }
+ else if (op == '+' && e.getRight() == null)
+ return e.getLeft();
+ }
+ else if (expr instanceof Member) {
+ ASTree cexpr = getConstantFieldValue((Member)expr);
+ if (cexpr != null)
+ return cexpr;
+ }
+
+ return expr;
+ }
+
+ /**
+ * If MEM is a static final field, this method returns a constant
+ * expression representing the value of that field.
+ */
+ private static ASTree getConstantFieldValue(Member mem) {
+ return getConstantFieldValue(mem.getField());
+ }
+
+ public static ASTree getConstantFieldValue(CtField f) {
+ if (f == null)
+ return null;
+
+ Object value = f.getConstantValue();
+ if (value == null)
+ return null;
+
+ if (value instanceof String)
+ return new StringL((String)value);
+ else if (value instanceof Double || value instanceof Float) {
+ int token = (value instanceof Double)
+ ? DoubleConstant : FloatConstant;
+ return new DoubleConst(((Number)value).doubleValue(), token);
+ }
+ else if (value instanceof Number) {
+ int token = (value instanceof Long) ? LongConstant : IntConstant;
+ return new IntConst(((Number)value).longValue(), token);
+ }
+ else if (value instanceof Boolean)
+ return new Keyword(((Boolean)value).booleanValue()
+ ? TokenId.TRUE : TokenId.FALSE);
+ else
+ return null;
+ }
+
+ private static boolean isPlusExpr(ASTree expr) {
+ if (expr instanceof BinExpr) {
+ BinExpr bexpr = (BinExpr)expr;
+ int token = bexpr.getOperator();
+ return token == '+';
+ }
+
+ return false;
+ }
+
+ private static Expr makeAppendCall(ASTree target, ASTree arg) {
+ return CallExpr.makeCall(Expr.make('.', target, new Member("append")),
+ new ASTList(arg));
+ }
+
+ private void computeBinExprType(BinExpr expr, int token, int type1)
+ throws CompileError
+ {
+ // arrayDim should be 0.
+ int type2 = exprType;
+ if (token == LSHIFT || token == RSHIFT || token == ARSHIFT)
+ exprType = type1;
+ else
+ insertCast(expr, type1, type2);
+
+ if (CodeGen.isP_INT(exprType))
+ exprType = INT; // type1 may be BYTE, ...
+ }
+
+ private void booleanExpr(ASTree expr)
+ throws CompileError
+ {
+ int op = CodeGen.getCompOperator(expr);
+ if (op == EQ) { // ==, !=, ...
+ BinExpr bexpr = (BinExpr)expr;
+ bexpr.oprand1().accept(this);
+ int type1 = exprType;
+ int dim1 = arrayDim;
+ bexpr.oprand2().accept(this);
+ if (dim1 == 0 && arrayDim == 0)
+ insertCast(bexpr, type1, exprType);
+ }
+ else if (op == '!')
+ ((Expr)expr).oprand1().accept(this);
+ else if (op == ANDAND || op == OROR) {
+ BinExpr bexpr = (BinExpr)expr;
+ bexpr.oprand1().accept(this);
+ bexpr.oprand2().accept(this);
+ }
+ else // others
+ expr.accept(this);
+
+ exprType = BOOLEAN;
+ arrayDim = 0;
+ }
+
+ private void insertCast(BinExpr expr, int type1, int type2)
+ throws CompileError
+ {
+ if (CodeGen.rightIsStrong(type1, type2))
+ expr.setLeft(new CastExpr(type2, 0, expr.oprand1()));
+ else
+ exprType = type1;
+ }
+
+ public void atCastExpr(CastExpr expr) throws CompileError {
+ String cname = resolveClassName(expr.getClassName());
+ expr.getOprand().accept(this);
+ exprType = expr.getType();
+ arrayDim = expr.getArrayDim();
+ className = cname;
+ }
+
+ public void atInstanceOfExpr(InstanceOfExpr expr) throws CompileError {
+ expr.getOprand().accept(this);
+ exprType = BOOLEAN;
+ arrayDim = 0;
+ }
+
+ public void atExpr(Expr expr) throws CompileError {
+ // array access, member access,
+ // (unary) +, (unary) -, ++, --, !, ~
+
+ int token = expr.getOperator();
+ ASTree oprand = expr.oprand1();
+ if (token == '.') {
+ String member = ((Symbol)expr.oprand2()).get();
+ if (member.equals("length"))
+ atArrayLength(expr);
+ else if (member.equals("class"))
+ atClassObject(expr); // .class
+ else
+ atFieldRead(expr);
+ }
+ else if (token == MEMBER) { // field read
+ String member = ((Symbol)expr.oprand2()).get();
+ if (member.equals("class"))
+ atClassObject(expr); // .class
+ else
+ atFieldRead(expr);
+ }
+ else if (token == ARRAY)
+ atArrayRead(oprand, expr.oprand2());
+ else if (token == PLUSPLUS || token == MINUSMINUS)
+ atPlusPlus(token, oprand, expr);
+ else if (token == '!')
+ booleanExpr(expr);
+ else if (token == CALL) // method call
+ fatal();
+ else {
+ oprand.accept(this);
+ if (!isConstant(expr, token, oprand))
+ if (token == '-' || token == '~')
+ if (CodeGen.isP_INT(exprType))
+ exprType = INT; // type may be BYTE, ...
+ }
+ }
+
+ private boolean isConstant(Expr expr, int op, ASTree oprand) {
+ oprand = stripPlusExpr(oprand);
+ if (oprand instanceof IntConst) {
+ IntConst c = (IntConst)oprand;
+ long v = c.get();
+ if (op == '-')
+ v = -v;
+ else if (op == '~')
+ v = ~v;
+ else
+ return false;
+
+ c.set(v);
+ }
+ else if (oprand instanceof DoubleConst) {
+ DoubleConst c = (DoubleConst)oprand;
+ if (op == '-')
+ c.set(-c.get());
+ else
+ return false;
+ }
+ else
+ return false;
+
+ expr.setOperator('+');
+ return true;
+ }
+
+ public void atCallExpr(CallExpr expr) throws CompileError {
+ String mname = null;
+ CtClass targetClass = null;
+ ASTree method = expr.oprand1();
+ ASTList args = (ASTList)expr.oprand2();
+
+ if (method instanceof Member) {
+ mname = ((Member)method).get();
+ targetClass = thisClass;
+ }
+ else if (method instanceof Keyword) { // constructor
+ mname = MethodInfo.nameInit; // <init>
+ if (((Keyword)method).get() == SUPER)
+ targetClass = MemberResolver.getSuperclass(thisClass);
+ else
+ targetClass = thisClass;
+ }
+ else if (method instanceof Expr) {
+ Expr e = (Expr)method;
+ mname = ((Symbol)e.oprand2()).get();
+ int op = e.getOperator();
+ if (op == MEMBER) // static method
+ targetClass
+ = resolver.lookupClass(((Symbol)e.oprand1()).get(),
+ false);
+ else if (op == '.') {
+ ASTree target = e.oprand1();
+ try {
+ target.accept(this);
+ }
+ catch (NoFieldException nfe) {
+ if (nfe.getExpr() != target)
+ throw nfe;
+
+ // it should be a static method.
+ exprType = CLASS;
+ arrayDim = 0;
+ className = nfe.getField(); // JVM-internal
+ e.setOperator(MEMBER);
+ e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(
+ className)));
+ }
+
+ if (arrayDim > 0)
+ targetClass = resolver.lookupClass(javaLangObject, true);
+ else if (exprType == CLASS /* && arrayDim == 0 */)
+ targetClass = resolver.lookupClassByJvmName(className);
+ else
+ badMethod();
+ }
+ else
+ badMethod();
+ }
+ else
+ fatal();
+
+ MemberResolver.Method minfo
+ = atMethodCallCore(targetClass, mname, args);
+ expr.setMethod(minfo);
+ }
+
+ private static void badMethod() throws CompileError {
+ throw new CompileError("bad method");
+ }
+
+ /**
+ * @return a pair of the class declaring the invoked method
+ * and the MethodInfo of that method. Never null.
+ */
+ public MemberResolver.Method atMethodCallCore(CtClass targetClass,
+ String mname, ASTList args)
+ throws CompileError
+ {
+ int nargs = getMethodArgsLength(args);
+ int[] types = new int[nargs];
+ int[] dims = new int[nargs];
+ String[] cnames = new String[nargs];
+ atMethodArgs(args, types, dims, cnames);
+
+ MemberResolver.Method found
+ = resolver.lookupMethod(targetClass, thisClass, thisMethod,
+ mname, types, dims, cnames);
+ if (found == null) {
+ String clazz = targetClass.getName();
+ String signature = argTypesToString(types, dims, cnames);
+ String msg;
+ if (mname.equals(MethodInfo.nameInit))
+ msg = "cannot find constructor " + clazz + signature;
+ else
+ msg = mname + signature + " not found in " + clazz;
+
+ throw new CompileError(msg);
+ }
+
+ String desc = found.info.getDescriptor();
+ setReturnType(desc);
+ return found;
+ }
+
+ public int getMethodArgsLength(ASTList args) {
+ return ASTList.length(args);
+ }
+
+ public void atMethodArgs(ASTList args, int[] types, int[] dims,
+ String[] cnames) throws CompileError {
+ int i = 0;
+ while (args != null) {
+ ASTree a = args.head();
+ a.accept(this);
+ types[i] = exprType;
+ dims[i] = arrayDim;
+ cnames[i] = className;
+ ++i;
+ args = args.tail();
+ }
+ }
+
+ void setReturnType(String desc) throws CompileError {
+ int i = desc.indexOf(')');
+ if (i < 0)
+ badMethod();
+
+ char c = desc.charAt(++i);
+ int dim = 0;
+ while (c == '[') {
+ ++dim;
+ c = desc.charAt(++i);
+ }
+
+ arrayDim = dim;
+ if (c == 'L') {
+ int j = desc.indexOf(';', i + 1);
+ if (j < 0)
+ badMethod();
+
+ exprType = CLASS;
+ className = desc.substring(i + 1, j);
+ }
+ else {
+ exprType = MemberResolver.descToType(c);
+ className = null;
+ }
+ }
+
+ private void atFieldRead(ASTree expr) throws CompileError {
+ atFieldRead(fieldAccess(expr));
+ }
+
+ private void atFieldRead(CtField f) throws CompileError {
+ FieldInfo finfo = f.getFieldInfo2();
+ String type = finfo.getDescriptor();
+
+ int i = 0;
+ int dim = 0;
+ char c = type.charAt(i);
+ while (c == '[') {
+ ++dim;
+ c = type.charAt(++i);
+ }
+
+ arrayDim = dim;
+ exprType = MemberResolver.descToType(c);
+
+ if (c == 'L')
+ className = type.substring(i + 1, type.indexOf(';', i + 1));
+ else
+ className = null;
+ }
+
+ /* if EXPR is to access a static field, fieldAccess() translates EXPR
+ * into an expression using '#' (MEMBER). For example, it translates
+ * java.lang.Integer.TYPE into java.lang.Integer#TYPE. This translation
+ * speeds up type resolution by MemberCodeGen.
+ */
+ protected CtField fieldAccess(ASTree expr) throws CompileError {
+ if (expr instanceof Member) {
+ Member mem = (Member)expr;
+ String name = mem.get();
+ try {
+ CtField f = thisClass.getField(name);
+ if (Modifier.isStatic(f.getModifiers()))
+ mem.setField(f);
+
+ return f;
+ }
+ catch (NotFoundException e) {
+ // EXPR might be part of a static member access?
+ throw new NoFieldException(name, expr);
+ }
+ }
+ else if (expr instanceof Expr) {
+ Expr e = (Expr)expr;
+ int op = e.getOperator();
+ if (op == MEMBER) {
+ Member mem = (Member)e.oprand2();
+ CtField f
+ = resolver.lookupField(((Symbol)e.oprand1()).get(), mem);
+ mem.setField(f);
+ return f;
+ }
+ else if (op == '.') {
+ try {
+ e.oprand1().accept(this);
+ }
+ catch (NoFieldException nfe) {
+ if (nfe.getExpr() != e.oprand1())
+ throw nfe;
+
+ /* EXPR should be a static field.
+ * If EXPR might be part of a qualified class name,
+ * lookupFieldByJvmName2() throws NoFieldException.
+ */
+ return fieldAccess2(e, nfe.getField());
+ }
+
+ CompileError err = null;
+ try {
+ if (exprType == CLASS && arrayDim == 0)
+ return resolver.lookupFieldByJvmName(className,
+ (Symbol)e.oprand2());
+ }
+ catch (CompileError ce) {
+ err = ce;
+ }
+
+ /* If a filed name is the same name as a package's,
+ * a static member of a class in that package is not
+ * visible. For example,
+ *
+ * class Foo {
+ * int javassist;
+ * }
+ *
+ * It is impossible to add the following method:
+ *
+ * String m() { return javassist.CtClass.intType.toString(); }
+ *
+ * because javassist is a field name. However, this is
+ * often inconvenient, this compiler allows it. The following
+ * code is for that.
+ */
+ ASTree oprnd1 = e.oprand1();
+ if (oprnd1 instanceof Symbol)
+ return fieldAccess2(e, ((Symbol)oprnd1).get());
+
+ if (err != null)
+ throw err;
+ }
+ }
+
+ throw new CompileError("bad filed access");
+ }
+
+ private CtField fieldAccess2(Expr e, String jvmClassName) throws CompileError {
+ Member fname = (Member)e.oprand2();
+ CtField f = resolver.lookupFieldByJvmName2(jvmClassName, fname, e);
+ e.setOperator(MEMBER);
+ e.setOprand1(new Symbol(MemberResolver.jvmToJavaName(jvmClassName)));
+ fname.setField(f);
+ return f;
+ }
+
+ public void atClassObject(Expr expr) throws CompileError {
+ exprType = CLASS;
+ arrayDim = 0;
+ className =jvmJavaLangClass;
+ }
+
+ public void atArrayLength(Expr expr) throws CompileError {
+ expr.oprand1().accept(this);
+ exprType = INT;
+ arrayDim = 0;
+ }
+
+ public void atArrayRead(ASTree array, ASTree index)
+ throws CompileError
+ {
+ array.accept(this);
+ int type = exprType;
+ int dim = arrayDim;
+ String cname = className;
+ index.accept(this);
+ exprType = type;
+ arrayDim = dim - 1;
+ className = cname;
+ }
+
+ private void atPlusPlus(int token, ASTree oprand, Expr expr)
+ throws CompileError
+ {
+ boolean isPost = oprand == null; // ++i or i++?
+ if (isPost)
+ oprand = expr.oprand2();
+
+ if (oprand instanceof Variable) {
+ Declarator d = ((Variable)oprand).getDeclarator();
+ exprType = d.getType();
+ arrayDim = d.getArrayDim();
+ }
+ else {
+ if (oprand instanceof Expr) {
+ Expr e = (Expr)oprand;
+ if (e.getOperator() == ARRAY) {
+ atArrayRead(e.oprand1(), e.oprand2());
+ // arrayDim should be 0.
+ int t = exprType;
+ if (t == INT || t == BYTE || t == CHAR || t == SHORT)
+ exprType = INT;
+
+ return;
+ }
+ }
+
+ atFieldPlusPlus(oprand);
+ }
+ }
+
+ protected void atFieldPlusPlus(ASTree oprand) throws CompileError
+ {
+ CtField f = fieldAccess(oprand);
+ atFieldRead(f);
+ int t = exprType;
+ if (t == INT || t == BYTE || t == CHAR || t == SHORT)
+ exprType = INT;
+ }
+
+ public void atMember(Member mem) throws CompileError {
+ atFieldRead(mem);
+ }
+
+ public void atVariable(Variable v) throws CompileError {
+ Declarator d = v.getDeclarator();
+ exprType = d.getType();
+ arrayDim = d.getArrayDim();
+ className = d.getClassName();
+ }
+
+ public void atKeyword(Keyword k) throws CompileError {
+ arrayDim = 0;
+ int token = k.get();
+ switch (token) {
+ case TRUE :
+ case FALSE :
+ exprType = BOOLEAN;
+ break;
+ case NULL :
+ exprType = NULL;
+ break;
+ case THIS :
+ case SUPER :
+ exprType = CLASS;
+ if (token == THIS)
+ className = getThisName();
+ else
+ className = getSuperName();
+ break;
+ default :
+ fatal();
+ }
+ }
+
+ public void atStringL(StringL s) throws CompileError {
+ exprType = CLASS;
+ arrayDim = 0;
+ className = jvmJavaLangString;
+ }
+
+ public void atIntConst(IntConst i) throws CompileError {
+ arrayDim = 0;
+ int type = i.getType();
+ if (type == IntConstant || type == CharConstant)
+ exprType = (type == IntConstant ? INT : CHAR);
+ else
+ exprType = LONG;
+ }
+
+ public void atDoubleConst(DoubleConst d) throws CompileError {
+ arrayDim = 0;
+ if (d.getType() == DoubleConstant)
+ exprType = DOUBLE;
+ else
+ exprType = FLOAT;
+ }
+}
diff --git a/src/main/javassist/compiler/ast/ASTList.java b/src/main/javassist/compiler/ast/ASTList.java
new file mode 100644
index 0000000..b486668
--- /dev/null
+++ b/src/main/javassist/compiler/ast/ASTList.java
@@ -0,0 +1,159 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * A linked list.
+ * The right subtree must be an ASTList object or null.
+ */
+public class ASTList extends ASTree {
+ private ASTree left;
+ private ASTList right;
+
+ public ASTList(ASTree _head, ASTList _tail) {
+ left = _head;
+ right = _tail;
+ }
+
+ public ASTList(ASTree _head) {
+ left = _head;
+ right = null;
+ }
+
+ public static ASTList make(ASTree e1, ASTree e2, ASTree e3) {
+ return new ASTList(e1, new ASTList(e2, new ASTList(e3)));
+ }
+
+ public ASTree getLeft() { return left; }
+
+ public ASTree getRight() { return right; }
+
+ public void setLeft(ASTree _left) { left = _left; }
+
+ public void setRight(ASTree _right) {
+ right = (ASTList)_right;
+ }
+
+ /**
+ * Returns the car part of the list.
+ */
+ public ASTree head() { return left; }
+
+ public void setHead(ASTree _head) {
+ left = _head;
+ }
+
+ /**
+ * Returns the cdr part of the list.
+ */
+ public ASTList tail() { return right; }
+
+ public void setTail(ASTList _tail) {
+ right = _tail;
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atASTList(this); }
+
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+ sbuf.append("(<");
+ sbuf.append(getTag());
+ sbuf.append('>');
+ ASTList list = this;
+ while (list != null) {
+ sbuf.append(' ');
+ ASTree a = list.left;
+ sbuf.append(a == null ? "<null>" : a.toString());
+ list = list.right;
+ }
+
+ sbuf.append(')');
+ return sbuf.toString();
+ }
+
+ /**
+ * Returns the number of the elements in this list.
+ */
+ public int length() {
+ return length(this);
+ }
+
+ public static int length(ASTList list) {
+ if (list == null)
+ return 0;
+
+ int n = 0;
+ while (list != null) {
+ list = list.right;
+ ++n;
+ }
+
+ return n;
+ }
+
+ /**
+ * Returns a sub list of the list. The sub list begins with the
+ * n-th element of the list.
+ *
+ * @param nth zero or more than zero.
+ */
+ public ASTList sublist(int nth) {
+ ASTList list = this;
+ while (nth-- > 0)
+ list = list.right;
+
+ return list;
+ }
+
+ /**
+ * Substitutes <code>newObj</code> for <code>oldObj</code> in the
+ * list.
+ */
+ public boolean subst(ASTree newObj, ASTree oldObj) {
+ for (ASTList list = this; list != null; list = list.right)
+ if (list.left == oldObj) {
+ list.left = newObj;
+ return true;
+ }
+
+ return false;
+ }
+
+ /**
+ * Appends an object to a list.
+ */
+ public static ASTList append(ASTList a, ASTree b) {
+ return concat(a, new ASTList(b));
+ }
+
+ /**
+ * Concatenates two lists.
+ */
+ public static ASTList concat(ASTList a, ASTList b) {
+ if (a == null)
+ return b;
+ else {
+ ASTList list = a;
+ while (list.right != null)
+ list = list.right;
+
+ list.right = b;
+ return a;
+ }
+ }
+}
diff --git a/src/main/javassist/compiler/ast/ASTree.java b/src/main/javassist/compiler/ast/ASTree.java
new file mode 100644
index 0000000..a0c4330
--- /dev/null
+++ b/src/main/javassist/compiler/ast/ASTree.java
@@ -0,0 +1,58 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import java.io.Serializable;
+import javassist.compiler.CompileError;
+
+/**
+ * Abstract Syntax Tree. An ASTree object represents a node of
+ * a binary tree. If the node is a leaf node, both <code>getLeft()</code>
+ * and <code>getRight()</code> returns null.
+ */
+public abstract class ASTree implements Serializable {
+ public ASTree getLeft() { return null; }
+
+ public ASTree getRight() { return null; }
+
+ public void setLeft(ASTree _left) {}
+
+ public void setRight(ASTree _right) {}
+
+ /**
+ * Is a method for the visitor pattern. It calls
+ * <code>atXXX()</code> on the given visitor, where
+ * <code>XXX</code> is the class name of the node object.
+ */
+ public abstract void accept(Visitor v) throws CompileError;
+
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+ sbuf.append('<');
+ sbuf.append(getTag());
+ sbuf.append('>');
+ return sbuf.toString();
+ }
+
+ /**
+ * Returns the type of this node. This method is used by
+ * <code>toString()</code>.
+ */
+ protected String getTag() {
+ String name = getClass().getName();
+ return name.substring(name.lastIndexOf('.') + 1);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/ArrayInit.java b/src/main/javassist/compiler/ast/ArrayInit.java
new file mode 100644
index 0000000..a9c6c2f
--- /dev/null
+++ b/src/main/javassist/compiler/ast/ArrayInit.java
@@ -0,0 +1,31 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Array initializer such as <code>{ 1, 2, 3 }</code>.
+ */
+public class ArrayInit extends ASTList {
+ public ArrayInit(ASTree firstElement) {
+ super(firstElement);
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atArrayInit(this); }
+
+ public String getTag() { return "array"; }
+}
diff --git a/src/main/javassist/compiler/ast/AssignExpr.java b/src/main/javassist/compiler/ast/AssignExpr.java
new file mode 100644
index 0000000..9e61447
--- /dev/null
+++ b/src/main/javassist/compiler/ast/AssignExpr.java
@@ -0,0 +1,40 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Assignment expression.
+ */
+public class AssignExpr extends Expr {
+ /* operator must be either of:
+ * =, %=, &=, *=, +=, -=, /=, ^=, |=, <<=, >>=, >>>=
+ */
+
+ private AssignExpr(int op, ASTree _head, ASTList _tail) {
+ super(op, _head, _tail);
+ }
+
+ public static AssignExpr makeAssign(int op, ASTree oprand1,
+ ASTree oprand2) {
+ return new AssignExpr(op, oprand1, new ASTList(oprand2));
+ }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atAssignExpr(this);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/BinExpr.java b/src/main/javassist/compiler/ast/BinExpr.java
new file mode 100644
index 0000000..1fb5a6a
--- /dev/null
+++ b/src/main/javassist/compiler/ast/BinExpr.java
@@ -0,0 +1,41 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Binary expression.
+ *
+ * <p>If the operator is +, the right node might be null.
+ * See TypeChecker.atBinExpr().
+ */
+public class BinExpr extends Expr {
+ /* operator must be either of:
+ * ||, &&, |, ^, &, ==, !=, <=, >=, <, >,
+ * <<, >>, >>>, +, -, *, /, %
+ */
+
+ private BinExpr(int op, ASTree _head, ASTList _tail) {
+ super(op, _head, _tail);
+ }
+
+ public static BinExpr makeBin(int op, ASTree oprand1, ASTree oprand2) {
+ return new BinExpr(op, oprand1, new ASTList(oprand2));
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atBinExpr(this); }
+}
diff --git a/src/main/javassist/compiler/ast/CallExpr.java b/src/main/javassist/compiler/ast/CallExpr.java
new file mode 100644
index 0000000..544ce24
--- /dev/null
+++ b/src/main/javassist/compiler/ast/CallExpr.java
@@ -0,0 +1,46 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+import javassist.compiler.TokenId;
+import javassist.compiler.MemberResolver;
+
+/**
+ * Method call expression.
+ */
+public class CallExpr extends Expr {
+ private MemberResolver.Method method; // cached result of lookupMethod()
+
+ private CallExpr(ASTree _head, ASTList _tail) {
+ super(TokenId.CALL, _head, _tail);
+ method = null;
+ }
+
+ public void setMethod(MemberResolver.Method m) {
+ method = m;
+ }
+
+ public MemberResolver.Method getMethod() {
+ return method;
+ }
+
+ public static CallExpr makeCall(ASTree target, ASTree args) {
+ return new CallExpr(target, new ASTList(args));
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atCallExpr(this); }
+}
diff --git a/src/main/javassist/compiler/ast/CastExpr.java b/src/main/javassist/compiler/ast/CastExpr.java
new file mode 100644
index 0000000..3fb5640
--- /dev/null
+++ b/src/main/javassist/compiler/ast/CastExpr.java
@@ -0,0 +1,55 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.TokenId;
+import javassist.compiler.CompileError;
+
+/**
+ * Cast expression.
+ */
+public class CastExpr extends ASTList implements TokenId {
+ protected int castType;
+ protected int arrayDim;
+
+ public CastExpr(ASTList className, int dim, ASTree expr) {
+ super(className, new ASTList(expr));
+ castType = CLASS;
+ arrayDim = dim;
+ }
+
+ public CastExpr(int type, int dim, ASTree expr) {
+ super(null, new ASTList(expr));
+ castType = type;
+ arrayDim = dim;
+ }
+
+ /* Returns CLASS, BOOLEAN, INT, or ...
+ */
+ public int getType() { return castType; }
+
+ public int getArrayDim() { return arrayDim; }
+
+ public ASTList getClassName() { return (ASTList)getLeft(); }
+
+ public ASTree getOprand() { return getRight().getLeft(); }
+
+ public void setOprand(ASTree t) { getRight().setLeft(t); }
+
+ public String getTag() { return "cast:" + castType + ":" + arrayDim; }
+
+ public void accept(Visitor v) throws CompileError { v.atCastExpr(this); }
+}
diff --git a/src/main/javassist/compiler/ast/CondExpr.java b/src/main/javassist/compiler/ast/CondExpr.java
new file mode 100644
index 0000000..2fb9603
--- /dev/null
+++ b/src/main/javassist/compiler/ast/CondExpr.java
@@ -0,0 +1,43 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Conditional expression.
+ */
+public class CondExpr extends ASTList {
+ public CondExpr(ASTree cond, ASTree thenp, ASTree elsep) {
+ super(cond, new ASTList(thenp, new ASTList(elsep)));
+ }
+
+ public ASTree condExpr() { return head(); }
+
+ public void setCond(ASTree t) { setHead(t); }
+
+ public ASTree thenExpr() { return tail().head(); }
+
+ public void setThen(ASTree t) { tail().setHead(t); }
+
+ public ASTree elseExpr() { return tail().tail().head(); }
+
+ public void setElse(ASTree t) { tail().tail().setHead(t); }
+
+ public String getTag() { return "?:"; }
+
+ public void accept(Visitor v) throws CompileError { v.atCondExpr(this); }
+}
diff --git a/src/main/javassist/compiler/ast/Declarator.java b/src/main/javassist/compiler/ast/Declarator.java
new file mode 100644
index 0000000..d3a43f0
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Declarator.java
@@ -0,0 +1,127 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.TokenId;
+import javassist.compiler.CompileError;
+
+/**
+ * Variable declarator.
+ */
+public class Declarator extends ASTList implements TokenId {
+ protected int varType;
+ protected int arrayDim;
+ protected int localVar;
+ protected String qualifiedClass; // JVM-internal representation
+
+ public Declarator(int type, int dim) {
+ super(null);
+ varType = type;
+ arrayDim = dim;
+ localVar = -1;
+ qualifiedClass = null;
+ }
+
+ public Declarator(ASTList className, int dim) {
+ super(null);
+ varType = CLASS;
+ arrayDim = dim;
+ localVar = -1;
+ qualifiedClass = astToClassName(className, '/');
+ }
+
+ /* For declaring a pre-defined? local variable.
+ */
+ public Declarator(int type, String jvmClassName, int dim,
+ int var, Symbol sym) {
+ super(null);
+ varType = type;
+ arrayDim = dim;
+ localVar = var;
+ qualifiedClass = jvmClassName;
+ setLeft(sym);
+ append(this, null); // initializer
+ }
+
+ public Declarator make(Symbol sym, int dim, ASTree init) {
+ Declarator d = new Declarator(this.varType, this.arrayDim + dim);
+ d.qualifiedClass = this.qualifiedClass;
+ d.setLeft(sym);
+ append(d, init);
+ return d;
+ }
+
+ /* Returns CLASS, BOOLEAN, BYTE, CHAR, SHORT, INT, LONG, FLOAT,
+ * or DOUBLE (or VOID)
+ */
+ public int getType() { return varType; }
+
+ public int getArrayDim() { return arrayDim; }
+
+ public void addArrayDim(int d) { arrayDim += d; }
+
+ public String getClassName() { return qualifiedClass; }
+
+ public void setClassName(String s) { qualifiedClass = s; }
+
+ public Symbol getVariable() { return (Symbol)getLeft(); }
+
+ public void setVariable(Symbol sym) { setLeft(sym); }
+
+ public ASTree getInitializer() {
+ ASTList t = tail();
+ if (t != null)
+ return t.head();
+ else
+ return null;
+ }
+
+ public void setLocalVar(int n) { localVar = n; }
+
+ public int getLocalVar() { return localVar; }
+
+ public String getTag() { return "decl"; }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atDeclarator(this);
+ }
+
+ public static String astToClassName(ASTList name, char sep) {
+ if (name == null)
+ return null;
+
+ StringBuffer sbuf = new StringBuffer();
+ astToClassName(sbuf, name, sep);
+ return sbuf.toString();
+ }
+
+ private static void astToClassName(StringBuffer sbuf, ASTList name,
+ char sep) {
+ for (;;) {
+ ASTree h = name.head();
+ if (h instanceof Symbol)
+ sbuf.append(((Symbol)h).get());
+ else if (h instanceof ASTList)
+ astToClassName(sbuf, (ASTList)h, sep);
+
+ name = name.tail();
+ if (name == null)
+ break;
+
+ sbuf.append(sep);
+ }
+ }
+}
diff --git a/src/main/javassist/compiler/ast/DoubleConst.java b/src/main/javassist/compiler/ast/DoubleConst.java
new file mode 100644
index 0000000..5276c2f
--- /dev/null
+++ b/src/main/javassist/compiler/ast/DoubleConst.java
@@ -0,0 +1,94 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+import javassist.compiler.TokenId;
+
+/**
+ * Double constant.
+ */
+public class DoubleConst extends ASTree {
+ protected double value;
+ protected int type;
+
+ public DoubleConst(double v, int tokenId) { value = v; type = tokenId; }
+
+ public double get() { return value; }
+
+ public void set(double v) { value = v; }
+
+ /* Returns DoubleConstant or FloatConstant
+ */
+ public int getType() { return type; }
+
+ public String toString() { return Double.toString(value); }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atDoubleConst(this);
+ }
+
+ public ASTree compute(int op, ASTree right) {
+ if (right instanceof IntConst)
+ return compute0(op, (IntConst)right);
+ else if (right instanceof DoubleConst)
+ return compute0(op, (DoubleConst)right);
+ else
+ return null;
+ }
+
+ private DoubleConst compute0(int op, DoubleConst right) {
+ int newType;
+ if (this.type == TokenId.DoubleConstant
+ || right.type == TokenId.DoubleConstant)
+ newType = TokenId.DoubleConstant;
+ else
+ newType = TokenId.FloatConstant;
+
+ return compute(op, this.value, right.value, newType);
+ }
+
+ private DoubleConst compute0(int op, IntConst right) {
+ return compute(op, this.value, (double)right.value, this.type);
+ }
+
+ private static DoubleConst compute(int op, double value1, double value2,
+ int newType)
+ {
+ double newValue;
+ switch (op) {
+ case '+' :
+ newValue = value1 + value2;
+ break;
+ case '-' :
+ newValue = value1 - value2;
+ break;
+ case '*' :
+ newValue = value1 * value2;
+ break;
+ case '/' :
+ newValue = value1 / value2;
+ break;
+ case '%' :
+ newValue = value1 % value2;
+ break;
+ default :
+ return null;
+ }
+
+ return new DoubleConst(newValue, newType);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/Expr.java b/src/main/javassist/compiler/ast/Expr.java
new file mode 100644
index 0000000..ec11200
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Expr.java
@@ -0,0 +1,84 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.TokenId;
+import javassist.compiler.CompileError;
+
+/**
+ * Expression.
+ */
+public class Expr extends ASTList implements TokenId {
+ /* operator must be either of:
+ * (unary) +, (unary) -, ++, --, !, ~,
+ * ARRAY, . (dot), MEMBER (static member access).
+ * Otherwise, the object should be an instance of a subclass.
+ */
+
+ protected int operatorId;
+
+ Expr(int op, ASTree _head, ASTList _tail) {
+ super(_head, _tail);
+ operatorId = op;
+ }
+
+ Expr(int op, ASTree _head) {
+ super(_head);
+ operatorId = op;
+ }
+
+ public static Expr make(int op, ASTree oprand1, ASTree oprand2) {
+ return new Expr(op, oprand1, new ASTList(oprand2));
+ }
+
+ public static Expr make(int op, ASTree oprand1) {
+ return new Expr(op, oprand1);
+ }
+
+ public int getOperator() { return operatorId; }
+
+ public void setOperator(int op) { operatorId = op; }
+
+ public ASTree oprand1() { return getLeft(); }
+
+ public void setOprand1(ASTree expr) {
+ setLeft(expr);
+ }
+
+ public ASTree oprand2() { return getRight().getLeft(); }
+
+ public void setOprand2(ASTree expr) {
+ getRight().setLeft(expr);
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atExpr(this); }
+
+ public String getName() {
+ int id = operatorId;
+ if (id < 128)
+ return String.valueOf((char)id);
+ else if (NEQ <= id && id <= ARSHIFT_E)
+ return opNames[id - NEQ];
+ else if (id == INSTANCEOF)
+ return "instanceof";
+ else
+ return String.valueOf(id);
+ }
+
+ protected String getTag() {
+ return "op:" + getName();
+ }
+}
diff --git a/src/main/javassist/compiler/ast/FieldDecl.java b/src/main/javassist/compiler/ast/FieldDecl.java
new file mode 100644
index 0000000..ce32b87
--- /dev/null
+++ b/src/main/javassist/compiler/ast/FieldDecl.java
@@ -0,0 +1,34 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+public class FieldDecl extends ASTList {
+ public FieldDecl(ASTree _head, ASTList _tail) {
+ super(_head, _tail);
+ }
+
+ public ASTList getModifiers() { return (ASTList)getLeft(); }
+
+ public Declarator getDeclarator() { return (Declarator)tail().head(); }
+
+ public ASTree getInit() { return (ASTree)sublist(2).head(); }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atFieldDecl(this);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/InstanceOfExpr.java b/src/main/javassist/compiler/ast/InstanceOfExpr.java
new file mode 100644
index 0000000..9813ce8
--- /dev/null
+++ b/src/main/javassist/compiler/ast/InstanceOfExpr.java
@@ -0,0 +1,39 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Instanceof expression.
+ */
+public class InstanceOfExpr extends CastExpr {
+ public InstanceOfExpr(ASTList className, int dim, ASTree expr) {
+ super(className, dim, expr);
+ }
+
+ public InstanceOfExpr(int type, int dim, ASTree expr) {
+ super(type, dim, expr);
+ }
+
+ public String getTag() {
+ return "instanceof:" + castType + ":" + arrayDim;
+ }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atInstanceOfExpr(this);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/IntConst.java b/src/main/javassist/compiler/ast/IntConst.java
new file mode 100644
index 0000000..703a0bf
--- /dev/null
+++ b/src/main/javassist/compiler/ast/IntConst.java
@@ -0,0 +1,138 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+import javassist.compiler.TokenId;
+
+/**
+ * Integer constant.
+ */
+public class IntConst extends ASTree {
+ protected long value;
+ protected int type;
+
+ public IntConst(long v, int tokenId) { value = v; type = tokenId; }
+
+ public long get() { return value; }
+
+ public void set(long v) { value = v; }
+
+ /* Returns IntConstant, CharConstant, or LongConstant.
+ */
+ public int getType() { return type; }
+
+ public String toString() { return Long.toString(value); }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atIntConst(this);
+ }
+
+ public ASTree compute(int op, ASTree right) {
+ if (right instanceof IntConst)
+ return compute0(op, (IntConst)right);
+ else if (right instanceof DoubleConst)
+ return compute0(op, (DoubleConst)right);
+ else
+ return null;
+ }
+
+ private IntConst compute0(int op, IntConst right) {
+ int type1 = this.type;
+ int type2 = right.type;
+ int newType;
+ if (type1 == TokenId.LongConstant || type2 == TokenId.LongConstant)
+ newType = TokenId.LongConstant;
+ else if (type1 == TokenId.CharConstant
+ && type2 == TokenId.CharConstant)
+ newType = TokenId.CharConstant;
+ else
+ newType = TokenId.IntConstant;
+
+ long value1 = this.value;
+ long value2 = right.value;
+ long newValue;
+ switch (op) {
+ case '+' :
+ newValue = value1 + value2;
+ break;
+ case '-' :
+ newValue = value1 - value2;
+ break;
+ case '*' :
+ newValue = value1 * value2;
+ break;
+ case '/' :
+ newValue = value1 / value2;
+ break;
+ case '%' :
+ newValue = value1 % value2;
+ break;
+ case '|' :
+ newValue = value1 | value2;
+ break;
+ case '^' :
+ newValue = value1 ^ value2;
+ break;
+ case '&' :
+ newValue = value1 & value2;
+ break;
+ case TokenId.LSHIFT :
+ newValue = value << (int)value2;
+ newType = type1;
+ break;
+ case TokenId.RSHIFT :
+ newValue = value >> (int)value2;
+ newType = type1;
+ break;
+ case TokenId.ARSHIFT :
+ newValue = value >>> (int)value2;
+ newType = type1;
+ break;
+ default :
+ return null;
+ }
+
+ return new IntConst(newValue, newType);
+ }
+
+ private DoubleConst compute0(int op, DoubleConst right) {
+ double value1 = (double)this.value;
+ double value2 = right.value;
+ double newValue;
+ switch (op) {
+ case '+' :
+ newValue = value1 + value2;
+ break;
+ case '-' :
+ newValue = value1 - value2;
+ break;
+ case '*' :
+ newValue = value1 * value2;
+ break;
+ case '/' :
+ newValue = value1 / value2;
+ break;
+ case '%' :
+ newValue = value1 % value2;
+ break;
+ default :
+ return null;
+ }
+
+ return new DoubleConst(newValue, right.type);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/Keyword.java b/src/main/javassist/compiler/ast/Keyword.java
new file mode 100644
index 0000000..a1a9ebf
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Keyword.java
@@ -0,0 +1,35 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Keyword.
+ */
+public class Keyword extends ASTree {
+ protected int tokenId;
+
+ public Keyword(int token) {
+ tokenId = token;
+ }
+
+ public int get() { return tokenId; }
+
+ public String toString() { return "id:" + tokenId; }
+
+ public void accept(Visitor v) throws CompileError { v.atKeyword(this); }
+}
diff --git a/src/main/javassist/compiler/ast/Member.java b/src/main/javassist/compiler/ast/Member.java
new file mode 100644
index 0000000..404f2b8
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Member.java
@@ -0,0 +1,39 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+import javassist.CtField;
+
+/**
+ * Member name.
+ */
+public class Member extends Symbol {
+ // cache maintained by fieldAccess() in TypeChecker.
+ // this is used to obtain the value of a static final field.
+ private CtField field;
+
+ public Member(String name) {
+ super(name);
+ field = null;
+ }
+
+ public void setField(CtField f) { field = f; }
+
+ public CtField getField() { return field; }
+
+ public void accept(Visitor v) throws CompileError { v.atMember(this); }
+}
diff --git a/src/main/javassist/compiler/ast/MethodDecl.java b/src/main/javassist/compiler/ast/MethodDecl.java
new file mode 100644
index 0000000..8d0661c
--- /dev/null
+++ b/src/main/javassist/compiler/ast/MethodDecl.java
@@ -0,0 +1,45 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+public class MethodDecl extends ASTList {
+ public static final String initName = "<init>";
+
+ public MethodDecl(ASTree _head, ASTList _tail) {
+ super(_head, _tail);
+ }
+
+ public boolean isConstructor() {
+ Symbol sym = getReturn().getVariable();
+ return sym != null && initName.equals(sym.get());
+ }
+
+ public ASTList getModifiers() { return (ASTList)getLeft(); }
+
+ public Declarator getReturn() { return (Declarator)tail().head(); }
+
+ public ASTList getParams() { return (ASTList)sublist(2).head(); }
+
+ public ASTList getThrows() { return (ASTList)sublist(3).head(); }
+
+ public Stmnt getBody() { return (Stmnt)sublist(4).head(); }
+
+ public void accept(Visitor v) throws CompileError {
+ v.atMethodDecl(this);
+ }
+}
diff --git a/src/main/javassist/compiler/ast/NewExpr.java b/src/main/javassist/compiler/ast/NewExpr.java
new file mode 100644
index 0000000..db3cb51
--- /dev/null
+++ b/src/main/javassist/compiler/ast/NewExpr.java
@@ -0,0 +1,77 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.TokenId;
+import javassist.compiler.CompileError;
+
+/**
+ * New Expression.
+ */
+public class NewExpr extends ASTList implements TokenId {
+ protected boolean newArray;
+ protected int arrayType;
+
+ public NewExpr(ASTList className, ASTList args) {
+ super(className, new ASTList(args));
+ newArray = false;
+ arrayType = CLASS;
+ }
+
+ public NewExpr(int type, ASTList arraySize, ArrayInit init) {
+ super(null, new ASTList(arraySize));
+ newArray = true;
+ arrayType = type;
+ if (init != null)
+ append(this, init);
+ }
+
+ public static NewExpr makeObjectArray(ASTList className,
+ ASTList arraySize, ArrayInit init) {
+ NewExpr e = new NewExpr(className, arraySize);
+ e.newArray = true;
+ if (init != null)
+ append(e, init);
+
+ return e;
+ }
+
+ public boolean isArray() { return newArray; }
+
+ /* TokenId.CLASS, TokenId.INT, ...
+ */
+ public int getArrayType() { return arrayType; }
+
+ public ASTList getClassName() { return (ASTList)getLeft(); }
+
+ public ASTList getArguments() { return (ASTList)getRight().getLeft(); }
+
+ public ASTList getArraySize() { return getArguments(); }
+
+ public ArrayInit getInitializer() {
+ ASTree t = getRight().getRight();
+ if (t == null)
+ return null;
+ else
+ return (ArrayInit)t.getLeft();
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atNewExpr(this); }
+
+ protected String getTag() {
+ return newArray ? "new[]" : "new";
+ }
+}
diff --git a/src/main/javassist/compiler/ast/Pair.java b/src/main/javassist/compiler/ast/Pair.java
new file mode 100644
index 0000000..1831a35
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Pair.java
@@ -0,0 +1,51 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * A node of a a binary tree. This class provides concrete methods
+ * overriding abstract methods in ASTree.
+ */
+public class Pair extends ASTree {
+ protected ASTree left, right;
+
+ public Pair(ASTree _left, ASTree _right) {
+ left = _left;
+ right = _right;
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atPair(this); }
+
+ public String toString() {
+ StringBuffer sbuf = new StringBuffer();
+ sbuf.append("(<Pair> ");
+ sbuf.append(left == null ? "<null>" : left.toString());
+ sbuf.append(" . ");
+ sbuf.append(right == null ? "<null>" : right.toString());
+ sbuf.append(')');
+ return sbuf.toString();
+ }
+
+ public ASTree getLeft() { return left; }
+
+ public ASTree getRight() { return right; }
+
+ public void setLeft(ASTree _left) { left = _left; }
+
+ public void setRight(ASTree _right) { right = _right; }
+}
diff --git a/src/main/javassist/compiler/ast/Stmnt.java b/src/main/javassist/compiler/ast/Stmnt.java
new file mode 100644
index 0000000..d5c6d62
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Stmnt.java
@@ -0,0 +1,59 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.TokenId;
+import javassist.compiler.CompileError;
+
+/**
+ * Statement.
+ */
+public class Stmnt extends ASTList implements TokenId {
+ protected int operatorId;
+
+ public Stmnt(int op, ASTree _head, ASTList _tail) {
+ super(_head, _tail);
+ operatorId = op;
+ }
+
+ public Stmnt(int op, ASTree _head) {
+ super(_head);
+ operatorId = op;
+ }
+
+ public Stmnt(int op) {
+ this(op, null);
+ }
+
+ public static Stmnt make(int op, ASTree oprand1, ASTree oprand2) {
+ return new Stmnt(op, oprand1, new ASTList(oprand2));
+ }
+
+ public static Stmnt make(int op, ASTree op1, ASTree op2, ASTree op3) {
+ return new Stmnt(op, op1, new ASTList(op2, new ASTList(op3)));
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atStmnt(this); }
+
+ public int getOperator() { return operatorId; }
+
+ protected String getTag() {
+ if (operatorId < 128)
+ return "stmnt:" + (char)operatorId;
+ else
+ return "stmnt:" + operatorId;
+ }
+}
diff --git a/src/main/javassist/compiler/ast/StringL.java b/src/main/javassist/compiler/ast/StringL.java
new file mode 100644
index 0000000..b9e5fe8
--- /dev/null
+++ b/src/main/javassist/compiler/ast/StringL.java
@@ -0,0 +1,35 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * String literal.
+ */
+public class StringL extends ASTree {
+ protected String text;
+
+ public StringL(String t) {
+ text = t;
+ }
+
+ public String get() { return text; }
+
+ public String toString() { return "\"" + text + "\""; }
+
+ public void accept(Visitor v) throws CompileError { v.atStringL(this); }
+}
diff --git a/src/main/javassist/compiler/ast/Symbol.java b/src/main/javassist/compiler/ast/Symbol.java
new file mode 100644
index 0000000..0b26e75
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Symbol.java
@@ -0,0 +1,35 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Identifier.
+ */
+public class Symbol extends ASTree {
+ protected String identifier;
+
+ public Symbol(String sym) {
+ identifier = sym;
+ }
+
+ public String get() { return identifier; }
+
+ public String toString() { return identifier; }
+
+ public void accept(Visitor v) throws CompileError { v.atSymbol(this); }
+}
diff --git a/src/main/javassist/compiler/ast/Variable.java b/src/main/javassist/compiler/ast/Variable.java
new file mode 100644
index 0000000..353690e
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Variable.java
@@ -0,0 +1,38 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * Variable.
+ */
+public class Variable extends Symbol {
+ protected Declarator declarator;
+
+ public Variable(String sym, Declarator d) {
+ super(sym);
+ declarator = d;
+ }
+
+ public Declarator getDeclarator() { return declarator; }
+
+ public String toString() {
+ return identifier + ":" + declarator.getType();
+ }
+
+ public void accept(Visitor v) throws CompileError { v.atVariable(this); }
+}
diff --git a/src/main/javassist/compiler/ast/Visitor.java b/src/main/javassist/compiler/ast/Visitor.java
new file mode 100644
index 0000000..b4cbf34
--- /dev/null
+++ b/src/main/javassist/compiler/ast/Visitor.java
@@ -0,0 +1,51 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.compiler.ast;
+
+import javassist.compiler.CompileError;
+
+/**
+ * The visitor pattern.
+ *
+ * @see ast.ASTree#accept(Visitor)
+ */
+public class Visitor {
+ public void atASTList(ASTList n) throws CompileError {}
+ public void atPair(Pair n) throws CompileError {}
+
+ public void atFieldDecl(FieldDecl n) throws CompileError {}
+ public void atMethodDecl(MethodDecl n) throws CompileError {}
+ public void atStmnt(Stmnt n) throws CompileError {}
+ public void atDeclarator(Declarator n) throws CompileError {}
+
+ public void atAssignExpr(AssignExpr n) throws CompileError {}
+ public void atCondExpr(CondExpr n) throws CompileError {}
+ public void atBinExpr(BinExpr n) throws CompileError {}
+ public void atExpr(Expr n) throws CompileError {}
+ public void atCallExpr(CallExpr n) throws CompileError {}
+ public void atCastExpr(CastExpr n) throws CompileError {}
+ public void atInstanceOfExpr(InstanceOfExpr n) throws CompileError {}
+ public void atNewExpr(NewExpr n) throws CompileError {}
+
+ public void atSymbol(Symbol n) throws CompileError {}
+ public void atMember(Member n) throws CompileError {}
+ public void atVariable(Variable n) throws CompileError {}
+ public void atKeyword(Keyword n) throws CompileError {}
+ public void atStringL(StringL n) throws CompileError {}
+ public void atIntConst(IntConst n) throws CompileError {}
+ public void atDoubleConst(DoubleConst n) throws CompileError {}
+ public void atArrayInit(ArrayInit n) throws CompileError {}
+}
diff --git a/src/main/javassist/convert/TransformAccessArrayField.java b/src/main/javassist/convert/TransformAccessArrayField.java
new file mode 100644
index 0000000..f70148f
--- /dev/null
+++ b/src/main/javassist/convert/TransformAccessArrayField.java
@@ -0,0 +1,269 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.convert;
+
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.NotFoundException;
+import javassist.CodeConverter.ArrayAccessReplacementMethodNames;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.Descriptor;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.analysis.Analyzer;
+import javassist.bytecode.analysis.Frame;
+
+/**
+ * A transformer which replaces array access with static method invocations.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @author Jason T. Greene
+ * @version $Revision: 1.8 $
+ */
+public final class TransformAccessArrayField extends Transformer {
+ private final String methodClassname;
+ private final ArrayAccessReplacementMethodNames names;
+ private Frame[] frames;
+ private int offset;
+
+ public TransformAccessArrayField(Transformer next, String methodClassname,
+ ArrayAccessReplacementMethodNames names) throws NotFoundException {
+ super(next);
+ this.methodClassname = methodClassname;
+ this.names = names;
+
+ }
+
+ public void initialize(ConstPool cp, CtClass clazz, MethodInfo minfo) throws CannotCompileException {
+ /*
+ * This transformer must be isolated from other transformers, since some
+ * of them affect the local variable and stack maximums without updating
+ * the code attribute to reflect the changes. This screws up the
+ * data-flow analyzer, since it relies on consistent code state. Even
+ * if the attribute values were updated correctly, we would have to
+ * detect it, and redo analysis, which is not cheap. Instead, we are
+ * better off doing all changes in initialize() before everyone else has
+ * a chance to muck things up.
+ */
+ CodeIterator iterator = minfo.getCodeAttribute().iterator();
+ while (iterator.hasNext()) {
+ try {
+ int pos = iterator.next();
+ int c = iterator.byteAt(pos);
+
+ if (c == AALOAD)
+ initFrames(clazz, minfo);
+
+ if (c == AALOAD || c == BALOAD || c == CALOAD || c == DALOAD
+ || c == FALOAD || c == IALOAD || c == LALOAD
+ || c == SALOAD) {
+ pos = replace(cp, iterator, pos, c, getLoadReplacementSignature(c));
+ } else if (c == AASTORE || c == BASTORE || c == CASTORE
+ || c == DASTORE || c == FASTORE || c == IASTORE
+ || c == LASTORE || c == SASTORE) {
+ pos = replace(cp, iterator, pos, c, getStoreReplacementSignature(c));
+ }
+
+ } catch (Exception e) {
+ throw new CannotCompileException(e);
+ }
+ }
+ }
+
+ public void clean() {
+ frames = null;
+ offset = -1;
+ }
+
+ public int transform(CtClass tclazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws BadBytecode {
+ // Do nothing, see above comment
+ return pos;
+ }
+
+ private Frame getFrame(int pos) throws BadBytecode {
+ return frames[pos - offset]; // Adjust pos
+ }
+
+ private void initFrames(CtClass clazz, MethodInfo minfo) throws BadBytecode {
+ if (frames == null) {
+ frames = ((new Analyzer())).analyze(clazz, minfo);
+ offset = 0; // start tracking changes
+ }
+ }
+
+ private int updatePos(int pos, int increment) {
+ if (offset > -1)
+ offset += increment;
+
+ return pos + increment;
+ }
+
+ private String getTopType(int pos) throws BadBytecode {
+ Frame frame = getFrame(pos);
+ if (frame == null)
+ return null;
+
+ CtClass clazz = frame.peek().getCtClass();
+ return clazz != null ? Descriptor.toJvmName(clazz) : null;
+ }
+
+ private int replace(ConstPool cp, CodeIterator iterator, int pos,
+ int opcode, String signature) throws BadBytecode {
+ String castType = null;
+ String methodName = getMethodName(opcode);
+ if (methodName != null) {
+ // See if the object must be cast
+ if (opcode == AALOAD) {
+ castType = getTopType(iterator.lookAhead());
+ // Do not replace an AALOAD instruction that we do not have a type for
+ // This happens when the state is guaranteed to be null (Type.UNINIT)
+ // So we don't really care about this case.
+ if (castType == null)
+ return pos;
+ if ("java/lang/Object".equals(castType))
+ castType = null;
+ }
+
+ // The gap may include extra padding
+ // Write a nop in case the padding pushes the instruction forward
+ iterator.writeByte(NOP, pos);
+ CodeIterator.Gap gap
+ = iterator.insertGapAt(pos, castType != null ? 5 : 2, false);
+ pos = gap.position;
+ int mi = cp.addClassInfo(methodClassname);
+ int methodref = cp.addMethodrefInfo(mi, methodName, signature);
+ iterator.writeByte(INVOKESTATIC, pos);
+ iterator.write16bit(methodref, pos + 1);
+
+ if (castType != null) {
+ int index = cp.addClassInfo(castType);
+ iterator.writeByte(CHECKCAST, pos + 3);
+ iterator.write16bit(index, pos + 4);
+ }
+
+ pos = updatePos(pos, gap.length);
+ }
+
+ return pos;
+ }
+
+ private String getMethodName(int opcode) {
+ String methodName = null;
+ switch (opcode) {
+ case AALOAD:
+ methodName = names.objectRead();
+ break;
+ case BALOAD:
+ methodName = names.byteOrBooleanRead();
+ break;
+ case CALOAD:
+ methodName = names.charRead();
+ break;
+ case DALOAD:
+ methodName = names.doubleRead();
+ break;
+ case FALOAD:
+ methodName = names.floatRead();
+ break;
+ case IALOAD:
+ methodName = names.intRead();
+ break;
+ case SALOAD:
+ methodName = names.shortRead();
+ break;
+ case LALOAD:
+ methodName = names.longRead();
+ break;
+ case AASTORE:
+ methodName = names.objectWrite();
+ break;
+ case BASTORE:
+ methodName = names.byteOrBooleanWrite();
+ break;
+ case CASTORE:
+ methodName = names.charWrite();
+ break;
+ case DASTORE:
+ methodName = names.doubleWrite();
+ break;
+ case FASTORE:
+ methodName = names.floatWrite();
+ break;
+ case IASTORE:
+ methodName = names.intWrite();
+ break;
+ case SASTORE:
+ methodName = names.shortWrite();
+ break;
+ case LASTORE:
+ methodName = names.longWrite();
+ break;
+ }
+
+ if (methodName.equals(""))
+ methodName = null;
+
+ return methodName;
+ }
+
+ private String getLoadReplacementSignature(int opcode) throws BadBytecode {
+ switch (opcode) {
+ case AALOAD:
+ return "(Ljava/lang/Object;I)Ljava/lang/Object;";
+ case BALOAD:
+ return "(Ljava/lang/Object;I)B";
+ case CALOAD:
+ return "(Ljava/lang/Object;I)C";
+ case DALOAD:
+ return "(Ljava/lang/Object;I)D";
+ case FALOAD:
+ return "(Ljava/lang/Object;I)F";
+ case IALOAD:
+ return "(Ljava/lang/Object;I)I";
+ case SALOAD:
+ return "(Ljava/lang/Object;I)S";
+ case LALOAD:
+ return "(Ljava/lang/Object;I)J";
+ }
+
+ throw new BadBytecode(opcode);
+ }
+
+ private String getStoreReplacementSignature(int opcode) throws BadBytecode {
+ switch (opcode) {
+ case AASTORE:
+ return "(Ljava/lang/Object;ILjava/lang/Object;)V";
+ case BASTORE:
+ return "(Ljava/lang/Object;IB)V";
+ case CASTORE:
+ return "(Ljava/lang/Object;IC)V";
+ case DASTORE:
+ return "(Ljava/lang/Object;ID)V";
+ case FASTORE:
+ return "(Ljava/lang/Object;IF)V";
+ case IASTORE:
+ return "(Ljava/lang/Object;II)V";
+ case SASTORE:
+ return "(Ljava/lang/Object;IS)V";
+ case LASTORE:
+ return "(Ljava/lang/Object;IJ)V";
+ }
+
+ throw new BadBytecode(opcode);
+ }
+}
diff --git a/src/main/javassist/convert/TransformAfter.java b/src/main/javassist/convert/TransformAfter.java
new file mode 100644
index 0000000..6015115
--- /dev/null
+++ b/src/main/javassist/convert/TransformAfter.java
@@ -0,0 +1,46 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.*;
+
+public class TransformAfter extends TransformBefore {
+ public TransformAfter(Transformer next,
+ CtMethod origMethod, CtMethod afterMethod)
+ throws NotFoundException
+ {
+ super(next, origMethod, afterMethod);
+ }
+
+ protected int match2(int pos, CodeIterator iterator) throws BadBytecode {
+ iterator.move(pos);
+ iterator.insert(saveCode);
+ iterator.insert(loadCode);
+ int p = iterator.insertGap(3);
+ iterator.setMark(p);
+ iterator.insert(loadCode);
+ pos = iterator.next();
+ p = iterator.getMark();
+ iterator.writeByte(iterator.byteAt(pos), p);
+ iterator.write16bit(iterator.u16bitAt(pos + 1), p + 1);
+ iterator.writeByte(INVOKESTATIC, pos);
+ iterator.write16bit(newIndex, pos + 1);
+ iterator.move(p);
+ return iterator.next();
+ }
+}
diff --git a/src/main/javassist/convert/TransformBefore.java b/src/main/javassist/convert/TransformBefore.java
new file mode 100644
index 0000000..2ad585f
--- /dev/null
+++ b/src/main/javassist/convert/TransformBefore.java
@@ -0,0 +1,107 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.*;
+
+public class TransformBefore extends TransformCall {
+ protected CtClass[] parameterTypes;
+ protected int locals;
+ protected int maxLocals;
+ protected byte[] saveCode, loadCode;
+
+ public TransformBefore(Transformer next,
+ CtMethod origMethod, CtMethod beforeMethod)
+ throws NotFoundException
+ {
+ super(next, origMethod, beforeMethod);
+
+ // override
+ methodDescriptor = origMethod.getMethodInfo2().getDescriptor();
+
+ parameterTypes = origMethod.getParameterTypes();
+ locals = 0;
+ maxLocals = 0;
+ saveCode = loadCode = null;
+ }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {
+ super.initialize(cp, attr);
+ locals = 0;
+ maxLocals = attr.getMaxLocals();
+ saveCode = loadCode = null;
+ }
+
+ protected int match(int c, int pos, CodeIterator iterator,
+ int typedesc, ConstPool cp) throws BadBytecode
+ {
+ if (newIndex == 0) {
+ String desc = Descriptor.ofParameters(parameterTypes) + 'V';
+ desc = Descriptor.insertParameter(classname, desc);
+ int nt = cp.addNameAndTypeInfo(newMethodname, desc);
+ int ci = cp.addClassInfo(newClassname);
+ newIndex = cp.addMethodrefInfo(ci, nt);
+ constPool = cp;
+ }
+
+ if (saveCode == null)
+ makeCode(parameterTypes, cp);
+
+ return match2(pos, iterator);
+ }
+
+ protected int match2(int pos, CodeIterator iterator) throws BadBytecode {
+ iterator.move(pos);
+ iterator.insert(saveCode);
+ iterator.insert(loadCode);
+ int p = iterator.insertGap(3);
+ iterator.writeByte(INVOKESTATIC, p);
+ iterator.write16bit(newIndex, p + 1);
+ iterator.insert(loadCode);
+ return iterator.next();
+ }
+
+ public int extraLocals() { return locals; }
+
+ protected void makeCode(CtClass[] paramTypes, ConstPool cp) {
+ Bytecode save = new Bytecode(cp, 0, 0);
+ Bytecode load = new Bytecode(cp, 0, 0);
+
+ int var = maxLocals;
+ int len = (paramTypes == null) ? 0 : paramTypes.length;
+ load.addAload(var);
+ makeCode2(save, load, 0, len, paramTypes, var + 1);
+ save.addAstore(var);
+
+ saveCode = save.get();
+ loadCode = load.get();
+ }
+
+ private void makeCode2(Bytecode save, Bytecode load,
+ int i, int n, CtClass[] paramTypes, int var)
+ {
+ if (i < n) {
+ int size = load.addLoad(var, paramTypes[i]);
+ makeCode2(save, load, i + 1, n, paramTypes, var + size);
+ save.addStore(var, paramTypes[i]);
+ }
+ else
+ locals = var - maxLocals;
+ }
+}
diff --git a/src/main/javassist/convert/TransformCall.java b/src/main/javassist/convert/TransformCall.java
new file mode 100644
index 0000000..fb8395e
--- /dev/null
+++ b/src/main/javassist/convert/TransformCall.java
@@ -0,0 +1,129 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.ClassPool;
+import javassist.Modifier;
+import javassist.NotFoundException;
+import javassist.bytecode.*;
+
+public class TransformCall extends Transformer {
+ protected String classname, methodname, methodDescriptor;
+ protected String newClassname, newMethodname;
+ protected boolean newMethodIsPrivate;
+
+ /* cache */
+ protected int newIndex;
+ protected ConstPool constPool;
+
+ public TransformCall(Transformer next, CtMethod origMethod,
+ CtMethod substMethod)
+ {
+ this(next, origMethod.getName(), substMethod);
+ classname = origMethod.getDeclaringClass().getName();
+ }
+
+ public TransformCall(Transformer next, String oldMethodName,
+ CtMethod substMethod)
+ {
+ super(next);
+ methodname = oldMethodName;
+ methodDescriptor = substMethod.getMethodInfo2().getDescriptor();
+ classname = newClassname = substMethod.getDeclaringClass().getName();
+ newMethodname = substMethod.getName();
+ constPool = null;
+ newMethodIsPrivate = Modifier.isPrivate(substMethod.getModifiers());
+ }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {
+ if (constPool != cp)
+ newIndex = 0;
+ }
+
+ /**
+ * Modify INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC and INVOKEVIRTUAL
+ * so that a different method is invoked. The class name in the operand
+ * of these instructions might be a subclass of the target class specified
+ * by <code>classname</code>. This method transforms the instruction
+ * in that case unless the subclass overrides the target method.
+ */
+ public int transform(CtClass clazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws BadBytecode
+ {
+ int c = iterator.byteAt(pos);
+ if (c == INVOKEINTERFACE || c == INVOKESPECIAL
+ || c == INVOKESTATIC || c == INVOKEVIRTUAL) {
+ int index = iterator.u16bitAt(pos + 1);
+ String cname = cp.eqMember(methodname, methodDescriptor, index);
+ if (cname != null && matchClass(cname, clazz.getClassPool())) {
+ int ntinfo = cp.getMemberNameAndType(index);
+ pos = match(c, pos, iterator,
+ cp.getNameAndTypeDescriptor(ntinfo), cp);
+ }
+ }
+
+ return pos;
+ }
+
+ private boolean matchClass(String name, ClassPool pool) {
+ if (classname.equals(name))
+ return true;
+
+ try {
+ CtClass clazz = pool.get(name);
+ CtClass declClazz = pool.get(classname);
+ if (clazz.subtypeOf(declClazz))
+ try {
+ CtMethod m = clazz.getMethod(methodname, methodDescriptor);
+ return m.getDeclaringClass().getName().equals(classname);
+ }
+ catch (NotFoundException e) {
+ // maybe the original method has been removed.
+ return true;
+ }
+ }
+ catch (NotFoundException e) {
+ return false;
+ }
+
+ return false;
+ }
+
+ protected int match(int c, int pos, CodeIterator iterator,
+ int typedesc, ConstPool cp) throws BadBytecode
+ {
+ if (newIndex == 0) {
+ int nt = cp.addNameAndTypeInfo(cp.addUtf8Info(newMethodname),
+ typedesc);
+ int ci = cp.addClassInfo(newClassname);
+ if (c == INVOKEINTERFACE)
+ newIndex = cp.addInterfaceMethodrefInfo(ci, nt);
+ else {
+ if (newMethodIsPrivate && c == INVOKEVIRTUAL)
+ iterator.writeByte(INVOKESPECIAL, pos);
+
+ newIndex = cp.addMethodrefInfo(ci, nt);
+ }
+
+ constPool = cp;
+ }
+
+ iterator.write16bit(newIndex, pos + 1);
+ return pos;
+ }
+}
diff --git a/src/main/javassist/convert/TransformFieldAccess.java b/src/main/javassist/convert/TransformFieldAccess.java
new file mode 100644
index 0000000..d97c95d
--- /dev/null
+++ b/src/main/javassist/convert/TransformFieldAccess.java
@@ -0,0 +1,81 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.bytecode.*;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.Modifier;
+
+final public class TransformFieldAccess extends Transformer {
+ private String newClassname, newFieldname;
+ private String fieldname;
+ private CtClass fieldClass;
+ private boolean isPrivate;
+
+ /* cache */
+ private int newIndex;
+ private ConstPool constPool;
+
+ public TransformFieldAccess(Transformer next, CtField field,
+ String newClassname, String newFieldname)
+ {
+ super(next);
+ this.fieldClass = field.getDeclaringClass();
+ this.fieldname = field.getName();
+ this.isPrivate = Modifier.isPrivate(field.getModifiers());
+ this.newClassname = newClassname;
+ this.newFieldname = newFieldname;
+ this.constPool = null;
+ }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {
+ if (constPool != cp)
+ newIndex = 0;
+ }
+
+ /**
+ * Modify GETFIELD, GETSTATIC, PUTFIELD, and PUTSTATIC so that
+ * a different field is accessed. The new field must be declared
+ * in a superclass of the class in which the original field is
+ * declared.
+ */
+ public int transform(CtClass clazz, int pos,
+ CodeIterator iterator, ConstPool cp)
+ {
+ int c = iterator.byteAt(pos);
+ if (c == GETFIELD || c == GETSTATIC
+ || c == PUTFIELD || c == PUTSTATIC) {
+ int index = iterator.u16bitAt(pos + 1);
+ String typedesc
+ = TransformReadField.isField(clazz.getClassPool(), cp,
+ fieldClass, fieldname, isPrivate, index);
+ if (typedesc != null) {
+ if (newIndex == 0) {
+ int nt = cp.addNameAndTypeInfo(newFieldname,
+ typedesc);
+ newIndex = cp.addFieldrefInfo(
+ cp.addClassInfo(newClassname), nt);
+ constPool = cp;
+ }
+
+ iterator.write16bit(newIndex, pos + 1);
+ }
+ }
+
+ return pos;
+ }
+}
diff --git a/src/main/javassist/convert/TransformNew.java b/src/main/javassist/convert/TransformNew.java
new file mode 100644
index 0000000..f796489
--- /dev/null
+++ b/src/main/javassist/convert/TransformNew.java
@@ -0,0 +1,102 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.bytecode.*;
+import javassist.CtClass;
+import javassist.CannotCompileException;
+
+final public class TransformNew extends Transformer {
+ private int nested;
+ private String classname, trapClass, trapMethod;
+
+ public TransformNew(Transformer next,
+ String classname, String trapClass, String trapMethod) {
+ super(next);
+ this.classname = classname;
+ this.trapClass = trapClass;
+ this.trapMethod = trapMethod;
+ }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {
+ nested = 0;
+ }
+
+ /**
+ * Replace a sequence of
+ * NEW classname
+ * DUP
+ * ...
+ * INVOKESPECIAL
+ * with
+ * NOP
+ * NOP
+ * ...
+ * INVOKESTATIC trapMethod in trapClass
+ */
+ public int transform(CtClass clazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws CannotCompileException
+ {
+ int index;
+ int c = iterator.byteAt(pos);
+ if (c == NEW) {
+ index = iterator.u16bitAt(pos + 1);
+ if (cp.getClassInfo(index).equals(classname)) {
+ if (iterator.byteAt(pos + 3) != DUP)
+ throw new CannotCompileException(
+ "NEW followed by no DUP was found");
+
+ iterator.writeByte(NOP, pos);
+ iterator.writeByte(NOP, pos + 1);
+ iterator.writeByte(NOP, pos + 2);
+ iterator.writeByte(NOP, pos + 3);
+ ++nested;
+
+ StackMapTable smt
+ = (StackMapTable)iterator.get().getAttribute(StackMapTable.tag);
+ if (smt != null)
+ smt.removeNew(pos);
+
+ StackMap sm
+ = (StackMap)iterator.get().getAttribute(StackMap.tag);
+ if (sm != null)
+ sm.removeNew(pos);
+ }
+ }
+ else if (c == INVOKESPECIAL) {
+ index = iterator.u16bitAt(pos + 1);
+ int typedesc = cp.isConstructor(classname, index);
+ if (typedesc != 0 && nested > 0) {
+ int methodref = computeMethodref(typedesc, cp);
+ iterator.writeByte(INVOKESTATIC, pos);
+ iterator.write16bit(methodref, pos + 1);
+ --nested;
+ }
+ }
+
+ return pos;
+ }
+
+ private int computeMethodref(int typedesc, ConstPool cp) {
+ int classIndex = cp.addClassInfo(trapClass);
+ int mnameIndex = cp.addUtf8Info(trapMethod);
+ typedesc = cp.addUtf8Info(
+ Descriptor.changeReturnType(classname,
+ cp.getUtf8Info(typedesc)));
+ return cp.addMethodrefInfo(classIndex,
+ cp.addNameAndTypeInfo(mnameIndex, typedesc));
+ }
+}
diff --git a/src/main/javassist/convert/TransformNewClass.java b/src/main/javassist/convert/TransformNewClass.java
new file mode 100644
index 0000000..f34ef83
--- /dev/null
+++ b/src/main/javassist/convert/TransformNewClass.java
@@ -0,0 +1,82 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.bytecode.*;
+import javassist.CtClass;
+import javassist.CannotCompileException;
+
+final public class TransformNewClass extends Transformer {
+ private int nested;
+ private String classname, newClassName;
+ private int newClassIndex, newMethodNTIndex, newMethodIndex;
+
+ public TransformNewClass(Transformer next,
+ String classname, String newClassName) {
+ super(next);
+ this.classname = classname;
+ this.newClassName = newClassName;
+ }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {
+ nested = 0;
+ newClassIndex = newMethodNTIndex = newMethodIndex = 0;
+ }
+
+ /**
+ * Modifies a sequence of
+ * NEW classname
+ * DUP
+ * ...
+ * INVOKESPECIAL classname:method
+ */
+ public int transform(CtClass clazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws CannotCompileException
+ {
+ int index;
+ int c = iterator.byteAt(pos);
+ if (c == NEW) {
+ index = iterator.u16bitAt(pos + 1);
+ if (cp.getClassInfo(index).equals(classname)) {
+ if (iterator.byteAt(pos + 3) != DUP)
+ throw new CannotCompileException(
+ "NEW followed by no DUP was found");
+
+ if (newClassIndex == 0)
+ newClassIndex = cp.addClassInfo(newClassName);
+
+ iterator.write16bit(newClassIndex, pos + 1);
+ ++nested;
+ }
+ }
+ else if (c == INVOKESPECIAL) {
+ index = iterator.u16bitAt(pos + 1);
+ int typedesc = cp.isConstructor(classname, index);
+ if (typedesc != 0 && nested > 0) {
+ int nt = cp.getMethodrefNameAndType(index);
+ if (newMethodNTIndex != nt) {
+ newMethodNTIndex = nt;
+ newMethodIndex = cp.addMethodrefInfo(newClassIndex, nt);
+ }
+
+ iterator.write16bit(newMethodIndex, pos + 1);
+ --nested;
+ }
+ }
+
+ return pos;
+ }
+}
diff --git a/src/main/javassist/convert/TransformReadField.java b/src/main/javassist/convert/TransformReadField.java
new file mode 100644
index 0000000..a9e613c
--- /dev/null
+++ b/src/main/javassist/convert/TransformReadField.java
@@ -0,0 +1,95 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.bytecode.*;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.NotFoundException;
+import javassist.Modifier;
+
+public class TransformReadField extends Transformer {
+ protected String fieldname;
+ protected CtClass fieldClass;
+ protected boolean isPrivate;
+ protected String methodClassname, methodName;
+
+ public TransformReadField(Transformer next, CtField field,
+ String methodClassname, String methodName)
+ {
+ super(next);
+ this.fieldClass = field.getDeclaringClass();
+ this.fieldname = field.getName();
+ this.methodClassname = methodClassname;
+ this.methodName = methodName;
+ this.isPrivate = Modifier.isPrivate(field.getModifiers());
+ }
+
+ static String isField(ClassPool pool, ConstPool cp, CtClass fclass,
+ String fname, boolean is_private, int index) {
+ if (!cp.getFieldrefName(index).equals(fname))
+ return null;
+
+ try {
+ CtClass c = pool.get(cp.getFieldrefClassName(index));
+ if (c == fclass || (!is_private && isFieldInSuper(c, fclass, fname)))
+ return cp.getFieldrefType(index);
+ }
+ catch (NotFoundException e) {}
+ return null;
+ }
+
+ static boolean isFieldInSuper(CtClass clazz, CtClass fclass, String fname) {
+ if (!clazz.subclassOf(fclass))
+ return false;
+
+ try {
+ CtField f = clazz.getField(fname);
+ return f.getDeclaringClass() == fclass;
+ }
+ catch (NotFoundException e) {}
+ return false;
+ }
+
+ public int transform(CtClass tclazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws BadBytecode
+ {
+ int c = iterator.byteAt(pos);
+ if (c == GETFIELD || c == GETSTATIC) {
+ int index = iterator.u16bitAt(pos + 1);
+ String typedesc = isField(tclazz.getClassPool(), cp,
+ fieldClass, fieldname, isPrivate, index);
+ if (typedesc != null) {
+ if (c == GETSTATIC) {
+ iterator.move(pos);
+ pos = iterator.insertGap(1); // insertGap() may insert 4 bytes.
+ iterator.writeByte(ACONST_NULL, pos);
+ pos = iterator.next();
+ }
+
+ String type = "(Ljava/lang/Object;)" + typedesc;
+ int mi = cp.addClassInfo(methodClassname);
+ int methodref = cp.addMethodrefInfo(mi, methodName, type);
+ iterator.writeByte(INVOKESTATIC, pos);
+ iterator.write16bit(methodref, pos + 1);
+ return pos;
+ }
+ }
+
+ return pos;
+ }
+}
diff --git a/src/main/javassist/convert/TransformWriteField.java b/src/main/javassist/convert/TransformWriteField.java
new file mode 100644
index 0000000..2b6f8bb
--- /dev/null
+++ b/src/main/javassist/convert/TransformWriteField.java
@@ -0,0 +1,71 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.CtClass;
+import javassist.CtField;
+import javassist.bytecode.*;
+
+final public class TransformWriteField extends TransformReadField {
+ public TransformWriteField(Transformer next, CtField field,
+ String methodClassname, String methodName)
+ {
+ super(next, field, methodClassname, methodName);
+ }
+
+ public int transform(CtClass tclazz, int pos, CodeIterator iterator,
+ ConstPool cp) throws BadBytecode
+ {
+ int c = iterator.byteAt(pos);
+ if (c == PUTFIELD || c == PUTSTATIC) {
+ int index = iterator.u16bitAt(pos + 1);
+ String typedesc = isField(tclazz.getClassPool(), cp,
+ fieldClass, fieldname, isPrivate, index);
+ if (typedesc != null) {
+ if (c == PUTSTATIC) {
+ CodeAttribute ca = iterator.get();
+ iterator.move(pos);
+ char c0 = typedesc.charAt(0);
+ if (c0 == 'J' || c0 == 'D') { // long or double
+ // insertGap() may insert 4 bytes.
+ pos = iterator.insertGap(3);
+ iterator.writeByte(ACONST_NULL, pos);
+ iterator.writeByte(DUP_X2, pos + 1);
+ iterator.writeByte(POP, pos + 2);
+ ca.setMaxStack(ca.getMaxStack() + 2);
+ }
+ else {
+ // insertGap() may insert 4 bytes.
+ pos = iterator.insertGap(2);
+ iterator.writeByte(ACONST_NULL, pos);
+ iterator.writeByte(SWAP, pos + 1);
+ ca.setMaxStack(ca.getMaxStack() + 1);
+ }
+
+ pos = iterator.next();
+ }
+
+ int mi = cp.addClassInfo(methodClassname);
+ String type = "(Ljava/lang/Object;" + typedesc + ")V";
+ int methodref = cp.addMethodrefInfo(mi, methodName, type);
+ iterator.writeByte(INVOKESTATIC, pos);
+ iterator.write16bit(methodref, pos + 1);
+ }
+ }
+
+ return pos;
+ }
+}
diff --git a/src/main/javassist/convert/Transformer.java b/src/main/javassist/convert/Transformer.java
new file mode 100644
index 0000000..4dd3807
--- /dev/null
+++ b/src/main/javassist/convert/Transformer.java
@@ -0,0 +1,56 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.convert;
+
+import javassist.CannotCompileException;
+import javassist.CtClass;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+
+/**
+ * Transformer and its subclasses are used for executing
+ * code transformation specified by CodeConverter.
+ *
+ * @see javassist.CodeConverter
+ */
+public abstract class Transformer implements Opcode {
+ private Transformer next;
+
+ public Transformer(Transformer t) {
+ next = t;
+ }
+
+ public Transformer getNext() { return next; }
+
+ public void initialize(ConstPool cp, CodeAttribute attr) {}
+
+ public void initialize(ConstPool cp, CtClass clazz, MethodInfo minfo) throws CannotCompileException {
+ initialize(cp, minfo.getCodeAttribute());
+ }
+
+ public void clean() {}
+
+ public abstract int transform(CtClass clazz, int pos, CodeIterator it,
+ ConstPool cp) throws CannotCompileException, BadBytecode;
+
+ public int extraLocals() { return 0; }
+
+ public int extraStack() { return 0; }
+}
diff --git a/src/main/javassist/expr/Cast.java b/src/main/javassist/expr/Cast.java
new file mode 100644
index 0000000..1ef87be
--- /dev/null
+++ b/src/main/javassist/expr/Cast.java
@@ -0,0 +1,165 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * Explicit type cast.
+ */
+public class Cast extends Expr {
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected Cast(int pos, CodeIterator i, CtClass declaring, MethodInfo m) {
+ super(pos, i, declaring, m);
+ }
+
+ /**
+ * Returns the method or constructor containing the type cast
+ * expression represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * type-cast expression.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the type-cast expression.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the <code>CtClass</code> object representing
+ * the type specified by the cast.
+ */
+ public CtClass getType() throws NotFoundException {
+ ConstPool cp = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+ String name = cp.getClassInfo(index);
+ return thisClass.getClassPool().getCtClass(name);
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Replaces the explicit cast operator with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available but the value is <code>null</code>.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ thisClass.getClassFile(); // to call checkModify().
+ ConstPool constPool = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+
+ Javac jc = new Javac(thisClass);
+ ClassPool cp = thisClass.getClassPool();
+ CodeAttribute ca = iterator.get();
+
+ try {
+ CtClass[] params
+ = new CtClass[] { cp.get(javaLangObject) };
+ CtClass retType = getType();
+
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(javaLangObject, params, true, paramVar,
+ withinStatic());
+ int retVar = jc.recordReturnType(retType, true);
+ jc.recordProceed(new ProceedForCast(index, retType));
+
+ /* Is $_ included in the source code?
+ */
+ checkResultValue(retType, statement);
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, true, paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ bytecode.addConstZero(retType);
+ bytecode.addStore(retVar, retType); // initialize $_
+
+ jc.compileStmnt(statement);
+ bytecode.addLoad(retVar, retType);
+
+ replace0(pos, bytecode, 3);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+
+ /* <type> $proceed(Object obj)
+ */
+ static class ProceedForCast implements ProceedHandler {
+ int index;
+ CtClass retType;
+
+ ProceedForCast(int i, CtClass t) {
+ index = i;
+ retType = t;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ if (gen.getMethodArgsLength(args) != 1)
+ throw new CompileError(Javac.proceedName
+ + "() cannot take more than one parameter "
+ + "for cast");
+
+ gen.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ bytecode.addOpcode(Opcode.CHECKCAST);
+ bytecode.addIndex(index);
+ gen.setType(retType);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ c.setType(retType);
+ }
+ }
+}
diff --git a/src/main/javassist/expr/ConstructorCall.java b/src/main/javassist/expr/ConstructorCall.java
new file mode 100644
index 0000000..3a6a02f
--- /dev/null
+++ b/src/main/javassist/expr/ConstructorCall.java
@@ -0,0 +1,69 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.MethodInfo;
+
+/**
+ * Constructor call such as <code>this()</code> and <code>super()</code>
+ * within a constructor body.
+ *
+ * @see NewExpr
+ */
+public class ConstructorCall extends MethodCall {
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected ConstructorCall(int pos, CodeIterator i, CtClass decl, MethodInfo m) {
+ super(pos, i, decl, m);
+ }
+
+ /**
+ * Returns <code>"super"</code> or "<code>"this"</code>.
+ */
+ public String getMethodName() {
+ return isSuper() ? "super" : "this";
+ }
+
+ /**
+ * Always throws a <code>NotFoundException</code>.
+ *
+ * @see #getConstructor()
+ */
+ public CtMethod getMethod() throws NotFoundException {
+ throw new NotFoundException("this is a constructor call. Call getConstructor().");
+ }
+
+ /**
+ * Returns the called constructor.
+ */
+ public CtConstructor getConstructor() throws NotFoundException {
+ return getCtClass().getConstructor(getSignature());
+ }
+
+ /**
+ * Returns true if the called constructor is not <code>this()</code>
+ * but <code>super()</code> (a constructor declared in the super class).
+ */
+ public boolean isSuper() {
+ return super.isSuper();
+ }
+}
diff --git a/src/main/javassist/expr/Expr.java b/src/main/javassist/expr/Expr.java
new file mode 100644
index 0000000..75de54a
--- /dev/null
+++ b/src/main/javassist/expr/Expr.java
@@ -0,0 +1,329 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtBehavior;
+import javassist.CtClass;
+import javassist.CtConstructor;
+import javassist.CtPrimitiveType;
+import javassist.NotFoundException;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.CodeAttribute;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.ConstPool;
+import javassist.bytecode.ExceptionTable;
+import javassist.bytecode.ExceptionsAttribute;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+import javassist.compiler.Javac;
+
+import java.util.Iterator;
+import java.util.LinkedList;
+
+/**
+ * Expression.
+ */
+public abstract class Expr implements Opcode {
+ int currentPos;
+ CodeIterator iterator;
+ CtClass thisClass;
+ MethodInfo thisMethod;
+ boolean edited;
+ int maxLocals, maxStack;
+
+ static final String javaLangObject = "java.lang.Object";
+
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected Expr(int pos, CodeIterator i, CtClass declaring, MethodInfo m) {
+ currentPos = pos;
+ iterator = i;
+ thisClass = declaring;
+ thisMethod = m;
+ }
+
+ /**
+ * Returns the class that declares the method enclosing
+ * this expression.
+ *
+ * @since 3.7
+ */
+ public CtClass getEnclosingClass() { return thisClass; }
+
+ protected final ConstPool getConstPool() {
+ return thisMethod.getConstPool();
+ }
+
+ protected final boolean edited() {
+ return edited;
+ }
+
+ protected final int locals() {
+ return maxLocals;
+ }
+
+ protected final int stack() {
+ return maxStack;
+ }
+
+ /**
+ * Returns true if this method is static.
+ */
+ protected final boolean withinStatic() {
+ return (thisMethod.getAccessFlags() & AccessFlag.STATIC) != 0;
+ }
+
+ /**
+ * Returns the constructor or method containing the expression.
+ */
+ public CtBehavior where() {
+ MethodInfo mi = thisMethod;
+ CtBehavior[] cb = thisClass.getDeclaredBehaviors();
+ for (int i = cb.length - 1; i >= 0; --i)
+ if (cb[i].getMethodInfo2() == mi)
+ return cb[i];
+
+ CtConstructor init = thisClass.getClassInitializer();
+ if (init != null && init.getMethodInfo2() == mi)
+ return init;
+
+ /* getDeclaredBehaviors() returns a list of methods/constructors.
+ * Although the list is cached in a CtClass object, it might be
+ * recreated for some reason. Thus, the member name and the signature
+ * must be also checked.
+ */
+ for (int i = cb.length - 1; i >= 0; --i) {
+ if (thisMethod.getName().equals(cb[i].getMethodInfo2().getName())
+ && thisMethod.getDescriptor()
+ .equals(cb[i].getMethodInfo2().getDescriptor())) {
+ return cb[i];
+ }
+ }
+
+ throw new RuntimeException("fatal: not found");
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw. This list
+ * includes both the exceptions that the try-catch statements including the
+ * expression can catch and the exceptions that the throws declaration
+ * allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ ClassPool pool = thisClass.getClassPool();
+ ConstPool cp = thisMethod.getConstPool();
+ LinkedList list = new LinkedList();
+ try {
+ CodeAttribute ca = thisMethod.getCodeAttribute();
+ ExceptionTable et = ca.getExceptionTable();
+ int pos = currentPos;
+ int n = et.size();
+ for (int i = 0; i < n; ++i)
+ if (et.startPc(i) <= pos && pos < et.endPc(i)) {
+ int t = et.catchType(i);
+ if (t > 0)
+ try {
+ addClass(list, pool.get(cp.getClassInfo(t)));
+ }
+ catch (NotFoundException e) {
+ }
+ }
+ }
+ catch (NullPointerException e) {
+ }
+
+ ExceptionsAttribute ea = thisMethod.getExceptionsAttribute();
+ if (ea != null) {
+ String[] exceptions = ea.getExceptions();
+ if (exceptions != null) {
+ int n = exceptions.length;
+ for (int i = 0; i < n; ++i)
+ try {
+ addClass(list, pool.get(exceptions[i]));
+ }
+ catch (NotFoundException e) {
+ }
+ }
+ }
+
+ return (CtClass[])list.toArray(new CtClass[list.size()]);
+ }
+
+ private static void addClass(LinkedList list, CtClass c) {
+ Iterator it = list.iterator();
+ while (it.hasNext())
+ if (it.next() == c)
+ return;
+
+ list.add(c);
+ }
+
+ /**
+ * Returns the index of the bytecode corresponding to the expression. It is
+ * the index into the byte array containing the Java bytecode that
+ * implements the method.
+ */
+ public int indexOfBytecode() {
+ return currentPos;
+ }
+
+ /**
+ * Returns the line number of the source line containing the expression.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return thisMethod.getLineNumber(currentPos);
+ }
+
+ /**
+ * Returns the source file containing the expression.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ ClassFile cf = thisClass.getClassFile2();
+ if (cf == null)
+ return null;
+ else
+ return cf.getSourceFile();
+ }
+
+ static final boolean checkResultValue(CtClass retType, String prog)
+ throws CannotCompileException {
+ /*
+ * Is $_ included in the source code?
+ */
+ boolean hasIt = (prog.indexOf(Javac.resultVarName) >= 0);
+ if (!hasIt && retType != CtClass.voidType)
+ throw new CannotCompileException(
+ "the resulting value is not stored in "
+ + Javac.resultVarName);
+
+ return hasIt;
+ }
+
+ /*
+ * If isStaticCall is true, null is assigned to $0. So $0 must be declared
+ * by calling Javac.recordParams().
+ *
+ * After executing this method, the current stack depth might be less than
+ * 0.
+ */
+ static final void storeStack(CtClass[] params, boolean isStaticCall,
+ int regno, Bytecode bytecode) {
+ storeStack0(0, params.length, params, regno + 1, bytecode);
+ if (isStaticCall)
+ bytecode.addOpcode(ACONST_NULL);
+
+ bytecode.addAstore(regno);
+ }
+
+ private static void storeStack0(int i, int n, CtClass[] params, int regno,
+ Bytecode bytecode) {
+ if (i >= n)
+ return;
+ else {
+ CtClass c = params[i];
+ int size;
+ if (c instanceof CtPrimitiveType)
+ size = ((CtPrimitiveType)c).getDataSize();
+ else
+ size = 1;
+
+ storeStack0(i + 1, n, params, regno + size, bytecode);
+ bytecode.addStore(regno, c);
+ }
+ }
+
+ // The implementation of replace() should call thisClass.checkModify()
+ // so that isModify() will return true. Otherwise, thisClass.classfile
+ // might be released during compilation and the compiler might generate
+ // bytecode with a wrong copy of ConstPool.
+
+ /**
+ * Replaces this expression with the bytecode derived from
+ * the given source text.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public abstract void replace(String statement) throws CannotCompileException;
+
+ /**
+ * Replaces this expression with the bytecode derived from
+ * the given source text and <code>ExprEditor</code>.
+ *
+ * @param statement a Java statement except try-catch.
+ * @param recursive if not null, the substituted bytecode
+ * is recursively processed by the given
+ * <code>ExprEditor</code>.
+ * @since 3.1
+ */
+ public void replace(String statement, ExprEditor recursive)
+ throws CannotCompileException
+ {
+ replace(statement);
+ if (recursive != null)
+ runEditor(recursive, iterator);
+ }
+
+ protected void replace0(int pos, Bytecode bytecode, int size)
+ throws BadBytecode {
+ byte[] code = bytecode.get();
+ edited = true;
+ int gap = code.length - size;
+ for (int i = 0; i < size; ++i)
+ iterator.writeByte(NOP, pos + i);
+
+ if (gap > 0)
+ pos = iterator.insertGapAt(pos, gap, false).position;
+
+ iterator.write(code, pos);
+ iterator.insert(bytecode.getExceptionTable(), pos);
+ maxLocals = bytecode.getMaxLocals();
+ maxStack = bytecode.getMaxStack();
+ }
+
+ protected void runEditor(ExprEditor ed, CodeIterator oldIterator)
+ throws CannotCompileException
+ {
+ CodeAttribute codeAttr = oldIterator.get();
+ int orgLocals = codeAttr.getMaxLocals();
+ int orgStack = codeAttr.getMaxStack();
+ int newLocals = locals();
+ codeAttr.setMaxStack(stack());
+ codeAttr.setMaxLocals(newLocals);
+ ExprEditor.LoopContext context
+ = new ExprEditor.LoopContext(newLocals);
+ int size = oldIterator.getCodeLength();
+ int endPos = oldIterator.lookAhead();
+ oldIterator.move(currentPos);
+ if (ed.doit(thisClass, thisMethod, context, oldIterator, endPos))
+ edited = true;
+
+ oldIterator.move(endPos + oldIterator.getCodeLength() - size);
+ codeAttr.setMaxLocals(orgLocals);
+ codeAttr.setMaxStack(orgStack);
+ maxLocals = context.maxLocals;
+ maxStack += context.maxStack;
+ }
+}
diff --git a/src/main/javassist/expr/ExprEditor.java b/src/main/javassist/expr/ExprEditor.java
new file mode 100644
index 0000000..80ddd4b
--- /dev/null
+++ b/src/main/javassist/expr/ExprEditor.java
@@ -0,0 +1,316 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.bytecode.*;
+import javassist.CtClass;
+import javassist.CannotCompileException;
+
+/**
+ * A translator of method bodies.
+ *
+ * <p>The users can define a subclass of this class to customize how to
+ * modify a method body. The overall architecture is similar to the
+ * strategy pattern.
+ *
+ * <p>If <code>instrument()</code> is called in
+ * <code>CtMethod</code>, the method body is scanned from the beginning
+ * to the end.
+ * Whenever an expression, such as a method call and a <tt>new</tt>
+ * expression (object creation),
+ * is found, <code>edit()</code> is called in <code>ExprEdit</code>.
+ * <code>edit()</code> can inspect and modify the given expression.
+ * The modification is reflected on the original method body. If
+ * <code>edit()</code> does nothing, the original method body is not
+ * changed.
+ *
+ * <p>The following code is an example:
+ *
+ * <ul><pre>
+ * CtMethod cm = ...;
+ * cm.instrument(new ExprEditor() {
+ * public void edit(MethodCall m) throws CannotCompileException {
+ * if (m.getClassName().equals("Point")) {
+ * System.out.println(m.getMethodName() + " line: "
+ * + m.getLineNumber());
+ * }
+ * });
+ * </pre></ul>
+ *
+ * <p>This code inspects all method calls appearing in the method represented
+ * by <code>cm</code> and it prints the names and the line numbers of the
+ * methods declared in class <code>Point</code>. This code does not modify
+ * the body of the method represented by <code>cm</code>. If the method
+ * body must be modified, call <code>replace()</code>
+ * in <code>MethodCall</code>.
+ *
+ * @see javassist.CtClass#instrument(ExprEditor)
+ * @see javassist.CtMethod#instrument(ExprEditor)
+ * @see javassist.CtConstructor#instrument(ExprEditor)
+ * @see MethodCall
+ * @see NewExpr
+ * @see FieldAccess
+ *
+ * @see javassist.CodeConverter
+ */
+public class ExprEditor {
+ /**
+ * Default constructor. It does nothing.
+ */
+ public ExprEditor() {}
+
+ /**
+ * Undocumented method. Do not use; internal-use only.
+ */
+ public boolean doit(CtClass clazz, MethodInfo minfo)
+ throws CannotCompileException
+ {
+ CodeAttribute codeAttr = minfo.getCodeAttribute();
+ if (codeAttr == null)
+ return false;
+
+ CodeIterator iterator = codeAttr.iterator();
+ boolean edited = false;
+ LoopContext context = new LoopContext(codeAttr.getMaxLocals());
+
+ while (iterator.hasNext())
+ if (loopBody(iterator, clazz, minfo, context))
+ edited = true;
+
+ ExceptionTable et = codeAttr.getExceptionTable();
+ int n = et.size();
+ for (int i = 0; i < n; ++i) {
+ Handler h = new Handler(et, i, iterator, clazz, minfo);
+ edit(h);
+ if (h.edited()) {
+ edited = true;
+ context.updateMax(h.locals(), h.stack());
+ }
+ }
+
+ // codeAttr might be modified by other partiess
+ // so I check the current value of max-locals.
+ if (codeAttr.getMaxLocals() < context.maxLocals)
+ codeAttr.setMaxLocals(context.maxLocals);
+
+ codeAttr.setMaxStack(codeAttr.getMaxStack() + context.maxStack);
+ try {
+ if (edited)
+ minfo.rebuildStackMapIf6(clazz.getClassPool(),
+ clazz.getClassFile2());
+ }
+ catch (BadBytecode b) {
+ throw new CannotCompileException(b.getMessage(), b);
+ }
+
+ return edited;
+ }
+
+ /**
+ * Visits each bytecode in the given range.
+ */
+ boolean doit(CtClass clazz, MethodInfo minfo, LoopContext context,
+ CodeIterator iterator, int endPos)
+ throws CannotCompileException
+ {
+ boolean edited = false;
+ while (iterator.hasNext() && iterator.lookAhead() < endPos) {
+ int size = iterator.getCodeLength();
+ if (loopBody(iterator, clazz, minfo, context)) {
+ edited = true;
+ int size2 = iterator.getCodeLength();
+ if (size != size2) // the body was modified.
+ endPos += size2 - size;
+ }
+ }
+
+ return edited;
+ }
+
+ final static class NewOp {
+ NewOp next;
+ int pos;
+ String type;
+
+ NewOp(NewOp n, int p, String t) {
+ next = n;
+ pos = p;
+ type = t;
+ }
+ }
+
+ final static class LoopContext {
+ NewOp newList;
+ int maxLocals;
+ int maxStack;
+
+ LoopContext(int locals) {
+ maxLocals = locals;
+ maxStack = 0;
+ newList = null;
+ }
+
+ void updateMax(int locals, int stack) {
+ if (maxLocals < locals)
+ maxLocals = locals;
+
+ if (maxStack < stack)
+ maxStack = stack;
+ }
+ }
+
+ final boolean loopBody(CodeIterator iterator, CtClass clazz,
+ MethodInfo minfo, LoopContext context)
+ throws CannotCompileException
+ {
+ try {
+ Expr expr = null;
+ int pos = iterator.next();
+ int c = iterator.byteAt(pos);
+
+ if (c < Opcode.GETSTATIC) // c < 178
+ /* skip */;
+ else if (c < Opcode.NEWARRAY) { // c < 188
+ if (c == Opcode.INVOKESTATIC
+ || c == Opcode.INVOKEINTERFACE
+ || c == Opcode.INVOKEVIRTUAL) {
+ expr = new MethodCall(pos, iterator, clazz, minfo);
+ edit((MethodCall)expr);
+ }
+ else if (c == Opcode.GETFIELD || c == Opcode.GETSTATIC
+ || c == Opcode.PUTFIELD
+ || c == Opcode.PUTSTATIC) {
+ expr = new FieldAccess(pos, iterator, clazz, minfo, c);
+ edit((FieldAccess)expr);
+ }
+ else if (c == Opcode.NEW) {
+ int index = iterator.u16bitAt(pos + 1);
+ context.newList = new NewOp(context.newList, pos,
+ minfo.getConstPool().getClassInfo(index));
+ }
+ else if (c == Opcode.INVOKESPECIAL) {
+ NewOp newList = context.newList;
+ if (newList != null
+ && minfo.getConstPool().isConstructor(newList.type,
+ iterator.u16bitAt(pos + 1)) > 0) {
+ expr = new NewExpr(pos, iterator, clazz, minfo,
+ newList.type, newList.pos);
+ edit((NewExpr)expr);
+ context.newList = newList.next;
+ }
+ else {
+ MethodCall mcall = new MethodCall(pos, iterator, clazz, minfo);
+ if (mcall.getMethodName().equals(MethodInfo.nameInit)) {
+ ConstructorCall ccall = new ConstructorCall(pos, iterator, clazz, minfo);
+ expr = ccall;
+ edit(ccall);
+ }
+ else {
+ expr = mcall;
+ edit(mcall);
+ }
+ }
+ }
+ }
+ else { // c >= 188
+ if (c == Opcode.NEWARRAY || c == Opcode.ANEWARRAY
+ || c == Opcode.MULTIANEWARRAY) {
+ expr = new NewArray(pos, iterator, clazz, minfo, c);
+ edit((NewArray)expr);
+ }
+ else if (c == Opcode.INSTANCEOF) {
+ expr = new Instanceof(pos, iterator, clazz, minfo);
+ edit((Instanceof)expr);
+ }
+ else if (c == Opcode.CHECKCAST) {
+ expr = new Cast(pos, iterator, clazz, minfo);
+ edit((Cast)expr);
+ }
+ }
+
+ if (expr != null && expr.edited()) {
+ context.updateMax(expr.locals(), expr.stack());
+ return true;
+ }
+ else
+ return false;
+ }
+ catch (BadBytecode e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ /**
+ * Edits a <tt>new</tt> expression (overridable).
+ * The default implementation performs nothing.
+ *
+ * @param e the <tt>new</tt> expression creating an object.
+ */
+ public void edit(NewExpr e) throws CannotCompileException {}
+
+ /**
+ * Edits an expression for array creation (overridable).
+ * The default implementation performs nothing.
+ *
+ * @param a the <tt>new</tt> expression for creating an array.
+ * @throws CannotCompileException
+ */
+ public void edit(NewArray a) throws CannotCompileException {}
+
+ /**
+ * Edits a method call (overridable).
+ *
+ * The default implementation performs nothing.
+ */
+ public void edit(MethodCall m) throws CannotCompileException {}
+
+ /**
+ * Edits a constructor call (overridable).
+ * The constructor call is either
+ * <code>super()</code> or <code>this()</code>
+ * included in a constructor body.
+ *
+ * The default implementation performs nothing.
+ *
+ * @see #edit(NewExpr)
+ */
+ public void edit(ConstructorCall c) throws CannotCompileException {}
+
+ /**
+ * Edits a field-access expression (overridable).
+ * Field access means both read and write.
+ * The default implementation performs nothing.
+ */
+ public void edit(FieldAccess f) throws CannotCompileException {}
+
+ /**
+ * Edits an instanceof expression (overridable).
+ * The default implementation performs nothing.
+ */
+ public void edit(Instanceof i) throws CannotCompileException {}
+
+ /**
+ * Edits an expression for explicit type casting (overridable).
+ * The default implementation performs nothing.
+ */
+ public void edit(Cast c) throws CannotCompileException {}
+
+ /**
+ * Edits a catch clause (overridable).
+ * The default implementation performs nothing.
+ */
+ public void edit(Handler h) throws CannotCompileException {}
+}
diff --git a/src/main/javassist/expr/FieldAccess.java b/src/main/javassist/expr/FieldAccess.java
new file mode 100644
index 0000000..56ead16
--- /dev/null
+++ b/src/main/javassist/expr/FieldAccess.java
@@ -0,0 +1,322 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * Expression for accessing a field.
+ */
+public class FieldAccess extends Expr {
+ int opcode;
+
+ protected FieldAccess(int pos, CodeIterator i, CtClass declaring,
+ MethodInfo m, int op) {
+ super(pos, i, declaring, m);
+ opcode = op;
+ }
+
+ /**
+ * Returns the method or constructor containing the field-access
+ * expression represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * field access.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the field access.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns true if the field is static.
+ */
+ public boolean isStatic() {
+ return isStatic(opcode);
+ }
+
+ static boolean isStatic(int c) {
+ return c == Opcode.GETSTATIC || c == Opcode.PUTSTATIC;
+ }
+
+ /**
+ * Returns true if the field is read.
+ */
+ public boolean isReader() {
+ return opcode == Opcode.GETFIELD || opcode == Opcode.GETSTATIC;
+ }
+
+ /**
+ * Returns true if the field is written in.
+ */
+ public boolean isWriter() {
+ return opcode == Opcode.PUTFIELD || opcode == Opcode.PUTSTATIC;
+ }
+
+ /**
+ * Returns the class in which the field is declared.
+ */
+ private CtClass getCtClass() throws NotFoundException {
+ return thisClass.getClassPool().get(getClassName());
+ }
+
+ /**
+ * Returns the name of the class in which the field is declared.
+ */
+ public String getClassName() {
+ int index = iterator.u16bitAt(currentPos + 1);
+ return getConstPool().getFieldrefClassName(index);
+ }
+
+ /**
+ * Returns the name of the field.
+ */
+ public String getFieldName() {
+ int index = iterator.u16bitAt(currentPos + 1);
+ return getConstPool().getFieldrefName(index);
+ }
+
+ /**
+ * Returns the field accessed by this expression.
+ */
+ public CtField getField() throws NotFoundException {
+ CtClass cc = getCtClass();
+ return cc.getField(getFieldName());
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Returns the signature of the field type.
+ * The signature is represented by a character string
+ * called field descriptor, which is defined in the JVM specification.
+ *
+ * @see javassist.bytecode.Descriptor#toCtClass(String, ClassPool)
+ * @since 3.1
+ */
+ public String getSignature() {
+ int index = iterator.u16bitAt(currentPos + 1);
+ return getConstPool().getFieldrefType(index);
+ }
+
+ /**
+ * Replaces the method call with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available even if the called method is static.
+ * If the field access is writing, $_ is available but the value
+ * of $_ is ignored.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ thisClass.getClassFile(); // to call checkModify().
+ ConstPool constPool = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+
+ Javac jc = new Javac(thisClass);
+ CodeAttribute ca = iterator.get();
+ try {
+ CtClass[] params;
+ CtClass retType;
+ CtClass fieldType
+ = Descriptor.toCtClass(constPool.getFieldrefType(index),
+ thisClass.getClassPool());
+ boolean read = isReader();
+ if (read) {
+ params = new CtClass[0];
+ retType = fieldType;
+ }
+ else {
+ params = new CtClass[1];
+ params[0] = fieldType;
+ retType = CtClass.voidType;
+ }
+
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(constPool.getFieldrefClassName(index), params,
+ true, paramVar, withinStatic());
+
+ /* Is $_ included in the source code?
+ */
+ boolean included = checkResultValue(retType, statement);
+ if (read)
+ included = true;
+
+ int retVar = jc.recordReturnType(retType, included);
+ if (read)
+ jc.recordProceed(new ProceedForRead(retType, opcode,
+ index, paramVar));
+ else {
+ // because $type is not the return type...
+ jc.recordType(fieldType);
+ jc.recordProceed(new ProceedForWrite(params[0], opcode,
+ index, paramVar));
+ }
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, isStatic(), paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ if (included)
+ if (retType == CtClass.voidType) {
+ bytecode.addOpcode(ACONST_NULL);
+ bytecode.addAstore(retVar);
+ }
+ else {
+ bytecode.addConstZero(retType);
+ bytecode.addStore(retVar, retType); // initialize $_
+ }
+
+ jc.compileStmnt(statement);
+ if (read)
+ bytecode.addLoad(retVar, retType);
+
+ replace0(pos, bytecode, 3);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+
+ /* <field type> $proceed()
+ */
+ static class ProceedForRead implements ProceedHandler {
+ CtClass fieldType;
+ int opcode;
+ int targetVar, index;
+
+ ProceedForRead(CtClass type, int op, int i, int var) {
+ fieldType = type;
+ targetVar = var;
+ opcode = op;
+ index = i;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ if (args != null && !gen.isParamListName(args))
+ throw new CompileError(Javac.proceedName
+ + "() cannot take a parameter for field reading");
+
+ int stack;
+ if (isStatic(opcode))
+ stack = 0;
+ else {
+ stack = -1;
+ bytecode.addAload(targetVar);
+ }
+
+ if (fieldType instanceof CtPrimitiveType)
+ stack += ((CtPrimitiveType)fieldType).getDataSize();
+ else
+ ++stack;
+
+ bytecode.add(opcode);
+ bytecode.addIndex(index);
+ bytecode.growStack(stack);
+ gen.setType(fieldType);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.setType(fieldType);
+ }
+ }
+
+ /* void $proceed(<field type>)
+ * the return type is not the field type but void.
+ */
+ static class ProceedForWrite implements ProceedHandler {
+ CtClass fieldType;
+ int opcode;
+ int targetVar, index;
+
+ ProceedForWrite(CtClass type, int op, int i, int var) {
+ fieldType = type;
+ targetVar = var;
+ opcode = op;
+ index = i;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ if (gen.getMethodArgsLength(args) != 1)
+ throw new CompileError(Javac.proceedName
+ + "() cannot take more than one parameter "
+ + "for field writing");
+
+ int stack;
+ if (isStatic(opcode))
+ stack = 0;
+ else {
+ stack = -1;
+ bytecode.addAload(targetVar);
+ }
+
+ gen.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ gen.doNumCast(fieldType);
+ if (fieldType instanceof CtPrimitiveType)
+ stack -= ((CtPrimitiveType)fieldType).getDataSize();
+ else
+ --stack;
+
+ bytecode.add(opcode);
+ bytecode.addIndex(index);
+ bytecode.growStack(stack);
+ gen.setType(CtClass.voidType);
+ gen.addNullIfVoid();
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ c.setType(CtClass.voidType);
+ c.addNullIfVoid();
+ }
+ }
+}
diff --git a/src/main/javassist/expr/Handler.java b/src/main/javassist/expr/Handler.java
new file mode 100644
index 0000000..dd7e53f
--- /dev/null
+++ b/src/main/javassist/expr/Handler.java
@@ -0,0 +1,145 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+
+/**
+ * A <code>catch</code> clause or a <code>finally</code> block.
+ */
+public class Handler extends Expr {
+ private static String EXCEPTION_NAME = "$1";
+ private ExceptionTable etable;
+ private int index;
+
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected Handler(ExceptionTable et, int nth,
+ CodeIterator it, CtClass declaring, MethodInfo m) {
+ super(et.handlerPc(nth), it, declaring, m);
+ etable = et;
+ index = nth;
+ }
+
+ /**
+ * Returns the method or constructor containing the catch clause.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the source line number of the catch clause.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the catch clause.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the list of exceptions that the catch clause may throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Returns the type handled by the catch clause.
+ * If this is a <code>finally</code> block, <code>null</code> is returned.
+ */
+ public CtClass getType() throws NotFoundException {
+ int type = etable.catchType(index);
+ if (type == 0)
+ return null;
+ else {
+ ConstPool cp = getConstPool();
+ String name = cp.getClassInfo(type);
+ return thisClass.getClassPool().getCtClass(name);
+ }
+ }
+
+ /**
+ * Returns true if this is a <code>finally</code> block.
+ */
+ public boolean isFinally() {
+ return etable.catchType(index) == 0;
+ }
+
+ /**
+ * This method has not been implemented yet.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ throw new RuntimeException("not implemented yet");
+ }
+
+ /**
+ * Inserts bytecode at the beginning of the catch clause.
+ * The caught exception is stored in <code>$1</code>.
+ *
+ * @param src the source code representing the inserted bytecode.
+ * It must be a single statement or block.
+ */
+ public void insertBefore(String src) throws CannotCompileException {
+ edited = true;
+
+ ConstPool cp = getConstPool();
+ CodeAttribute ca = iterator.get();
+ Javac jv = new Javac(thisClass);
+ Bytecode b = jv.getBytecode();
+ b.setStackDepth(1);
+ b.setMaxLocals(ca.getMaxLocals());
+
+ try {
+ CtClass type = getType();
+ int var = jv.recordVariable(type, EXCEPTION_NAME);
+ jv.recordReturnType(type, false);
+ b.addAstore(var);
+ jv.compileStmnt(src);
+ b.addAload(var);
+
+ int oldHandler = etable.handlerPc(index);
+ b.addOpcode(Opcode.GOTO);
+ b.addIndex(oldHandler - iterator.getCodeLength()
+ - b.currentPc() + 1);
+
+ maxStack = b.getMaxStack();
+ maxLocals = b.getMaxLocals();
+
+ int pos = iterator.append(b.get());
+ iterator.append(b.getExceptionTable(), pos);
+ etable.setHandlerPc(index, pos);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+ catch (CompileError e) {
+ throw new CannotCompileException(e);
+ }
+ }
+}
diff --git a/src/main/javassist/expr/Instanceof.java b/src/main/javassist/expr/Instanceof.java
new file mode 100644
index 0000000..1ceed13
--- /dev/null
+++ b/src/main/javassist/expr/Instanceof.java
@@ -0,0 +1,169 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * Instanceof operator.
+ */
+public class Instanceof extends Expr {
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected Instanceof(int pos, CodeIterator i, CtClass declaring,
+ MethodInfo m) {
+ super(pos, i, declaring, m);
+ }
+
+ /**
+ * Returns the method or constructor containing the instanceof
+ * expression represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * instanceof expression.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the
+ * instanceof expression.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the <code>CtClass</code> object representing
+ * the type name on the right hand side
+ * of the instanceof operator.
+ */
+ public CtClass getType() throws NotFoundException {
+ ConstPool cp = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+ String name = cp.getClassInfo(index);
+ return thisClass.getClassPool().getCtClass(name);
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Replaces the instanceof operator with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available but the value is <code>null</code>.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ thisClass.getClassFile(); // to call checkModify().
+ ConstPool constPool = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+
+ Javac jc = new Javac(thisClass);
+ ClassPool cp = thisClass.getClassPool();
+ CodeAttribute ca = iterator.get();
+
+ try {
+ CtClass[] params
+ = new CtClass[] { cp.get(javaLangObject) };
+ CtClass retType = CtClass.booleanType;
+
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(javaLangObject, params, true, paramVar,
+ withinStatic());
+ int retVar = jc.recordReturnType(retType, true);
+ jc.recordProceed(new ProceedForInstanceof(index));
+
+ // because $type is not the return type...
+ jc.recordType(getType());
+
+ /* Is $_ included in the source code?
+ */
+ checkResultValue(retType, statement);
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, true, paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ bytecode.addConstZero(retType);
+ bytecode.addStore(retVar, retType); // initialize $_
+
+ jc.compileStmnt(statement);
+ bytecode.addLoad(retVar, retType);
+
+ replace0(pos, bytecode, 3);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+
+ /* boolean $proceed(Object obj)
+ */
+ static class ProceedForInstanceof implements ProceedHandler {
+ int index;
+
+ ProceedForInstanceof(int i) {
+ index = i;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ if (gen.getMethodArgsLength(args) != 1)
+ throw new CompileError(Javac.proceedName
+ + "() cannot take more than one parameter "
+ + "for instanceof");
+
+ gen.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ bytecode.addOpcode(Opcode.INSTANCEOF);
+ bytecode.addIndex(index);
+ gen.setType(CtClass.booleanType);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.atMethodArgs(args, new int[1], new int[1], new String[1]);
+ c.setType(CtClass.booleanType);
+ }
+ }
+}
diff --git a/src/main/javassist/expr/MethodCall.java b/src/main/javassist/expr/MethodCall.java
new file mode 100644
index 0000000..9e9d1db
--- /dev/null
+++ b/src/main/javassist/expr/MethodCall.java
@@ -0,0 +1,246 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+
+/**
+ * Method invocation (caller-side expression).
+ */
+public class MethodCall extends Expr {
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected MethodCall(int pos, CodeIterator i, CtClass declaring,
+ MethodInfo m) {
+ super(pos, i, declaring, m);
+ }
+
+ private int getNameAndType(ConstPool cp) {
+ int pos = currentPos;
+ int c = iterator.byteAt(pos);
+ int index = iterator.u16bitAt(pos + 1);
+
+ if (c == INVOKEINTERFACE)
+ return cp.getInterfaceMethodrefNameAndType(index);
+ else
+ return cp.getMethodrefNameAndType(index);
+ }
+
+ /**
+ * Returns the method or constructor containing the method-call
+ * expression represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * method call.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the method call.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the class of the target object,
+ * which the method is called on.
+ */
+ protected CtClass getCtClass() throws NotFoundException {
+ return thisClass.getClassPool().get(getClassName());
+ }
+
+ /**
+ * Returns the class name of the target object,
+ * which the method is called on.
+ */
+ public String getClassName() {
+ String cname;
+
+ ConstPool cp = getConstPool();
+ int pos = currentPos;
+ int c = iterator.byteAt(pos);
+ int index = iterator.u16bitAt(pos + 1);
+
+ if (c == INVOKEINTERFACE)
+ cname = cp.getInterfaceMethodrefClassName(index);
+ else
+ cname = cp.getMethodrefClassName(index);
+
+ if (cname.charAt(0) == '[')
+ cname = Descriptor.toClassName(cname);
+
+ return cname;
+ }
+
+ /**
+ * Returns the name of the called method.
+ */
+ public String getMethodName() {
+ ConstPool cp = getConstPool();
+ int nt = getNameAndType(cp);
+ return cp.getUtf8Info(cp.getNameAndTypeName(nt));
+ }
+
+ /**
+ * Returns the called method.
+ */
+ public CtMethod getMethod() throws NotFoundException {
+ return getCtClass().getMethod(getMethodName(), getSignature());
+ }
+
+ /**
+ * Returns the method signature (the parameter types
+ * and the return type).
+ * The method signature is represented by a character string
+ * called method descriptor, which is defined in the JVM specification.
+ *
+ * @see javassist.CtBehavior#getSignature()
+ * @see javassist.bytecode.Descriptor
+ * @since 3.1
+ */
+ public String getSignature() {
+ ConstPool cp = getConstPool();
+ int nt = getNameAndType(cp);
+ return cp.getUtf8Info(cp.getNameAndTypeDescriptor(nt));
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Returns true if the called method is of a superclass of the current
+ * class.
+ */
+ public boolean isSuper() {
+ return iterator.byteAt(currentPos) == INVOKESPECIAL
+ && !where().getDeclaringClass().getName().equals(getClassName());
+ }
+
+ /*
+ * Returns the parameter types of the called method.
+
+ public CtClass[] getParameterTypes() throws NotFoundException {
+ return Descriptor.getParameterTypes(getMethodDesc(),
+ thisClass.getClassPool());
+ }
+ */
+
+ /*
+ * Returns the return type of the called method.
+
+ public CtClass getReturnType() throws NotFoundException {
+ return Descriptor.getReturnType(getMethodDesc(),
+ thisClass.getClassPool());
+ }
+ */
+
+ /**
+ * Replaces the method call with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available even if the called method is static.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ thisClass.getClassFile(); // to call checkModify().
+ ConstPool constPool = getConstPool();
+ int pos = currentPos;
+ int index = iterator.u16bitAt(pos + 1);
+
+ String classname, methodname, signature;
+ int opcodeSize;
+ int c = iterator.byteAt(pos);
+ if (c == INVOKEINTERFACE) {
+ opcodeSize = 5;
+ classname = constPool.getInterfaceMethodrefClassName(index);
+ methodname = constPool.getInterfaceMethodrefName(index);
+ signature = constPool.getInterfaceMethodrefType(index);
+ }
+ else if (c == INVOKESTATIC
+ || c == INVOKESPECIAL || c == INVOKEVIRTUAL) {
+ opcodeSize = 3;
+ classname = constPool.getMethodrefClassName(index);
+ methodname = constPool.getMethodrefName(index);
+ signature = constPool.getMethodrefType(index);
+ }
+ else
+ throw new CannotCompileException("not method invocation");
+
+ Javac jc = new Javac(thisClass);
+ ClassPool cp = thisClass.getClassPool();
+ CodeAttribute ca = iterator.get();
+ try {
+ CtClass[] params = Descriptor.getParameterTypes(signature, cp);
+ CtClass retType = Descriptor.getReturnType(signature, cp);
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(classname, params,
+ true, paramVar, withinStatic());
+ int retVar = jc.recordReturnType(retType, true);
+ if (c == INVOKESTATIC)
+ jc.recordStaticProceed(classname, methodname);
+ else if (c == INVOKESPECIAL)
+ jc.recordSpecialProceed(Javac.param0Name, classname,
+ methodname, signature);
+ else
+ jc.recordProceed(Javac.param0Name, methodname);
+
+ /* Is $_ included in the source code?
+ */
+ checkResultValue(retType, statement);
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, c == INVOKESTATIC, paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ if (retType != CtClass.voidType) {
+ bytecode.addConstZero(retType);
+ bytecode.addStore(retVar, retType); // initialize $_
+ }
+
+ jc.compileStmnt(statement);
+ if (retType != CtClass.voidType)
+ bytecode.addLoad(retVar, retType);
+
+ replace0(pos, bytecode, opcodeSize);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+}
diff --git a/src/main/javassist/expr/NewArray.java b/src/main/javassist/expr/NewArray.java
new file mode 100644
index 0000000..c5ac41e
--- /dev/null
+++ b/src/main/javassist/expr/NewArray.java
@@ -0,0 +1,282 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * Array creation.
+ *
+ * <p>This class does not provide methods for obtaining the initial
+ * values of array elements.
+ */
+public class NewArray extends Expr {
+ int opcode;
+
+ protected NewArray(int pos, CodeIterator i, CtClass declaring,
+ MethodInfo m, int op) {
+ super(pos, i, declaring, m);
+ opcode = op;
+ }
+
+ /**
+ * Returns the method or constructor containing the array creation
+ * represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * array creation.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the array creation.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /**
+ * Returns the type of array components. If the created array is
+ * a two-dimensional array of <tt>int</tt>,
+ * the type returned by this method is
+ * not <tt>int[]</tt> but <tt>int</tt>.
+ */
+ public CtClass getComponentType() throws NotFoundException {
+ if (opcode == Opcode.NEWARRAY) {
+ int atype = iterator.byteAt(currentPos + 1);
+ return getPrimitiveType(atype);
+ }
+ else if (opcode == Opcode.ANEWARRAY
+ || opcode == Opcode.MULTIANEWARRAY) {
+ int index = iterator.u16bitAt(currentPos + 1);
+ String desc = getConstPool().getClassInfo(index);
+ int dim = Descriptor.arrayDimension(desc);
+ desc = Descriptor.toArrayComponent(desc, dim);
+ return Descriptor.toCtClass(desc, thisClass.getClassPool());
+ }
+ else
+ throw new RuntimeException("bad opcode: " + opcode);
+ }
+
+ CtClass getPrimitiveType(int atype) {
+ switch (atype) {
+ case Opcode.T_BOOLEAN :
+ return CtClass.booleanType;
+ case Opcode.T_CHAR :
+ return CtClass.charType;
+ case Opcode.T_FLOAT :
+ return CtClass.floatType;
+ case Opcode.T_DOUBLE :
+ return CtClass.doubleType;
+ case Opcode.T_BYTE :
+ return CtClass.byteType;
+ case Opcode.T_SHORT :
+ return CtClass.shortType;
+ case Opcode.T_INT :
+ return CtClass.intType;
+ case Opcode.T_LONG :
+ return CtClass.longType;
+ default :
+ throw new RuntimeException("bad atype: " + atype);
+ }
+ }
+
+ /**
+ * Returns the dimension of the created array.
+ */
+ public int getDimension() {
+ if (opcode == Opcode.NEWARRAY)
+ return 1;
+ else if (opcode == Opcode.ANEWARRAY
+ || opcode == Opcode.MULTIANEWARRAY) {
+ int index = iterator.u16bitAt(currentPos + 1);
+ String desc = getConstPool().getClassInfo(index);
+ return Descriptor.arrayDimension(desc)
+ + (opcode == Opcode.ANEWARRAY ? 1 : 0);
+ }
+ else
+ throw new RuntimeException("bad opcode: " + opcode);
+ }
+
+ /**
+ * Returns the number of dimensions of arrays to be created.
+ * If the opcode is multianewarray, this method returns the second
+ * operand. Otherwise, it returns 1.
+ */
+ public int getCreatedDimensions() {
+ if (opcode == Opcode.MULTIANEWARRAY)
+ return iterator.byteAt(currentPos + 3);
+ else
+ return 1;
+ }
+
+ /**
+ * Replaces the array creation with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available even if the called method is static.
+ * If the field access is writing, $_ is available but the value
+ * of $_ is ignored.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ try {
+ replace2(statement);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+
+ private void replace2(String statement)
+ throws CompileError, NotFoundException, BadBytecode,
+ CannotCompileException
+ {
+ thisClass.getClassFile(); // to call checkModify().
+ ConstPool constPool = getConstPool();
+ int pos = currentPos;
+ CtClass retType;
+ int codeLength;
+ int index = 0;
+ int dim = 1;
+ String desc;
+ if (opcode == Opcode.NEWARRAY) {
+ index = iterator.byteAt(currentPos + 1); // atype
+ CtPrimitiveType cpt = (CtPrimitiveType)getPrimitiveType(index);
+ desc = "[" + cpt.getDescriptor();
+ codeLength = 2;
+ }
+ else if (opcode == Opcode.ANEWARRAY) {
+ index = iterator.u16bitAt(pos + 1);
+ desc = constPool.getClassInfo(index);
+ if (desc.startsWith("["))
+ desc = "[" + desc;
+ else
+ desc = "[L" + desc + ";";
+
+ codeLength = 3;
+ }
+ else if (opcode == Opcode.MULTIANEWARRAY) {
+ index = iterator.u16bitAt(currentPos + 1);
+ desc = constPool.getClassInfo(index);
+ dim = iterator.byteAt(currentPos + 3);
+ codeLength = 4;
+ }
+ else
+ throw new RuntimeException("bad opcode: " + opcode);
+
+ retType = Descriptor.toCtClass(desc, thisClass.getClassPool());
+
+ Javac jc = new Javac(thisClass);
+ CodeAttribute ca = iterator.get();
+
+ CtClass[] params = new CtClass[dim];
+ for (int i = 0; i < dim; ++i)
+ params[i] = CtClass.intType;
+
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(javaLangObject, params,
+ true, paramVar, withinStatic());
+
+ /* Is $_ included in the source code?
+ */
+ checkResultValue(retType, statement);
+ int retVar = jc.recordReturnType(retType, true);
+ jc.recordProceed(new ProceedForArray(retType, opcode, index, dim));
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, true, paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ bytecode.addOpcode(ACONST_NULL); // initialize $_
+ bytecode.addAstore(retVar);
+
+ jc.compileStmnt(statement);
+ bytecode.addAload(retVar);
+
+ replace0(pos, bytecode, codeLength);
+ }
+
+ /* <array type> $proceed(<dim> ..)
+ */
+ static class ProceedForArray implements ProceedHandler {
+ CtClass arrayType;
+ int opcode;
+ int index, dimension;
+
+ ProceedForArray(CtClass type, int op, int i, int dim) {
+ arrayType = type;
+ opcode = op;
+ index = i;
+ dimension = dim;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ int num = gen.getMethodArgsLength(args);
+ if (num != dimension)
+ throw new CompileError(Javac.proceedName
+ + "() with a wrong number of parameters");
+
+ gen.atMethodArgs(args, new int[num],
+ new int[num], new String[num]);
+ bytecode.addOpcode(opcode);
+ if (opcode == Opcode.ANEWARRAY)
+ bytecode.addIndex(index);
+ else if (opcode == Opcode.NEWARRAY)
+ bytecode.add(index);
+ else /* if (opcode == Opcode.MULTIANEWARRAY) */ {
+ bytecode.addIndex(index);
+ bytecode.add(dimension);
+ bytecode.growStack(1 - dimension);
+ }
+
+ gen.setType(arrayType);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.setType(arrayType);
+ }
+ }
+}
diff --git a/src/main/javassist/expr/NewExpr.java b/src/main/javassist/expr/NewExpr.java
new file mode 100644
index 0000000..c2ab044
--- /dev/null
+++ b/src/main/javassist/expr/NewExpr.java
@@ -0,0 +1,247 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.expr;
+
+import javassist.*;
+import javassist.bytecode.*;
+import javassist.compiler.*;
+import javassist.compiler.ast.ASTList;
+
+/**
+ * Object creation (<tt>new</tt> expression).
+ */
+public class NewExpr extends Expr {
+ String newTypeName;
+ int newPos;
+
+ /**
+ * Undocumented constructor. Do not use; internal-use only.
+ */
+ protected NewExpr(int pos, CodeIterator i, CtClass declaring,
+ MethodInfo m, String type, int np) {
+ super(pos, i, declaring, m);
+ newTypeName = type;
+ newPos = np;
+ }
+
+ /*
+ * Not used
+ *
+ private int getNameAndType(ConstPool cp) {
+ int pos = currentPos;
+ int c = iterator.byteAt(pos);
+ int index = iterator.u16bitAt(pos + 1);
+
+ if (c == INVOKEINTERFACE)
+ return cp.getInterfaceMethodrefNameAndType(index);
+ else
+ return cp.getMethodrefNameAndType(index);
+ } */
+
+ /**
+ * Returns the method or constructor containing the <tt>new</tt>
+ * expression represented by this object.
+ */
+ public CtBehavior where() { return super.where(); }
+
+ /**
+ * Returns the line number of the source line containing the
+ * <tt>new</tt> expression.
+ *
+ * @return -1 if this information is not available.
+ */
+ public int getLineNumber() {
+ return super.getLineNumber();
+ }
+
+ /**
+ * Returns the source file containing the <tt>new</tt> expression.
+ *
+ * @return null if this information is not available.
+ */
+ public String getFileName() {
+ return super.getFileName();
+ }
+
+ /**
+ * Returns the class of the created object.
+ */
+ private CtClass getCtClass() throws NotFoundException {
+ return thisClass.getClassPool().get(newTypeName);
+ }
+
+ /**
+ * Returns the class name of the created object.
+ */
+ public String getClassName() {
+ return newTypeName;
+ }
+
+ /**
+ * Get the signature of the constructor
+ *
+ * The signature is represented by a character string
+ * called method descriptor, which is defined in the JVM specification.
+ *
+ * @see javassist.CtBehavior#getSignature()
+ * @see javassist.bytecode.Descriptor
+ * @return the signature
+ */
+ public String getSignature() {
+ ConstPool constPool = getConstPool();
+ int methodIndex = iterator.u16bitAt(currentPos + 1); // constructor
+ return constPool.getMethodrefType(methodIndex);
+ }
+
+ /**
+ * Returns the constructor called for creating the object.
+ */
+ public CtConstructor getConstructor() throws NotFoundException {
+ ConstPool cp = getConstPool();
+ int index = iterator.u16bitAt(currentPos + 1);
+ String desc = cp.getMethodrefType(index);
+ return getCtClass().getConstructor(desc);
+ }
+
+ /**
+ * Returns the list of exceptions that the expression may throw.
+ * This list includes both the exceptions that the try-catch statements
+ * including the expression can catch and the exceptions that
+ * the throws declaration allows the method to throw.
+ */
+ public CtClass[] mayThrow() {
+ return super.mayThrow();
+ }
+
+ /*
+ * Returns the parameter types of the constructor.
+
+ public CtClass[] getParameterTypes() throws NotFoundException {
+ ConstPool cp = getConstPool();
+ int index = iterator.u16bitAt(currentPos + 1);
+ String desc = cp.getMethodrefType(index);
+ return Descriptor.getParameterTypes(desc, thisClass.getClassPool());
+ }
+ */
+
+ private int canReplace() throws CannotCompileException {
+ int op = iterator.byteAt(newPos + 3);
+ if (op == Opcode.DUP)
+ return 4;
+ else if (op == Opcode.DUP_X1
+ && iterator.byteAt(newPos + 4) == Opcode.SWAP)
+ return 5;
+ else
+ return 3; // for Eclipse. The generated code may include no DUP.
+ // throw new CannotCompileException(
+ // "sorry, cannot edit NEW followed by no DUP");
+ }
+
+ /**
+ * Replaces the <tt>new</tt> expression with the bytecode derived from
+ * the given source text.
+ *
+ * <p>$0 is available but the value is null.
+ *
+ * @param statement a Java statement except try-catch.
+ */
+ public void replace(String statement) throws CannotCompileException {
+ thisClass.getClassFile(); // to call checkModify().
+
+ final int bytecodeSize = 3;
+ int pos = newPos;
+
+ int newIndex = iterator.u16bitAt(pos + 1);
+
+ /* delete the preceding NEW and DUP (or DUP_X1, SWAP) instructions.
+ */
+ int codeSize = canReplace();
+ int end = pos + codeSize;
+ for (int i = pos; i < end; ++i)
+ iterator.writeByte(NOP, i);
+
+ ConstPool constPool = getConstPool();
+ pos = currentPos;
+ int methodIndex = iterator.u16bitAt(pos + 1); // constructor
+
+ String signature = constPool.getMethodrefType(methodIndex);
+
+ Javac jc = new Javac(thisClass);
+ ClassPool cp = thisClass.getClassPool();
+ CodeAttribute ca = iterator.get();
+ try {
+ CtClass[] params = Descriptor.getParameterTypes(signature, cp);
+ CtClass newType = cp.get(newTypeName);
+ int paramVar = ca.getMaxLocals();
+ jc.recordParams(newTypeName, params,
+ true, paramVar, withinStatic());
+ int retVar = jc.recordReturnType(newType, true);
+ jc.recordProceed(new ProceedForNew(newType, newIndex,
+ methodIndex));
+
+ /* Is $_ included in the source code?
+ */
+ checkResultValue(newType, statement);
+
+ Bytecode bytecode = jc.getBytecode();
+ storeStack(params, true, paramVar, bytecode);
+ jc.recordLocalVariables(ca, pos);
+
+ bytecode.addConstZero(newType);
+ bytecode.addStore(retVar, newType); // initialize $_
+
+ jc.compileStmnt(statement);
+ if (codeSize > 3) // if the original code includes DUP.
+ bytecode.addAload(retVar);
+
+ replace0(pos, bytecode, bytecodeSize);
+ }
+ catch (CompileError e) { throw new CannotCompileException(e); }
+ catch (NotFoundException e) { throw new CannotCompileException(e); }
+ catch (BadBytecode e) {
+ throw new CannotCompileException("broken method");
+ }
+ }
+
+ static class ProceedForNew implements ProceedHandler {
+ CtClass newType;
+ int newIndex, methodIndex;
+
+ ProceedForNew(CtClass nt, int ni, int mi) {
+ newType = nt;
+ newIndex = ni;
+ methodIndex = mi;
+ }
+
+ public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
+ throws CompileError
+ {
+ bytecode.addOpcode(NEW);
+ bytecode.addIndex(newIndex);
+ bytecode.addOpcode(DUP);
+ gen.atMethodCallCore(newType, MethodInfo.nameInit, args,
+ false, true, -1, null);
+ gen.setType(newType);
+ }
+
+ public void setReturnType(JvstTypeChecker c, ASTList args)
+ throws CompileError
+ {
+ c.atMethodCallCore(newType, MethodInfo.nameInit, args);
+ c.setType(newType);
+ }
+ }
+}
diff --git a/src/main/javassist/expr/package.html b/src/main/javassist/expr/package.html
new file mode 100644
index 0000000..12a2c63
--- /dev/null
+++ b/src/main/javassist/expr/package.html
@@ -0,0 +1,8 @@
+<html>
+<body>
+
+<p>This package contains the classes for modifying a method body.
+See <code>ExprEditor</code> (expression editor) for more details.
+
+</body>
+</html>
diff --git a/src/main/javassist/package.html b/src/main/javassist/package.html
new file mode 100644
index 0000000..f5b66b9
--- /dev/null
+++ b/src/main/javassist/package.html
@@ -0,0 +1,22 @@
+<html>
+<body>
+The Javassist Core API.
+
+<p>Javassist (<i>Java</i> programming <i>assist</i>ant) makes bytecode
+engineering simple. It is a class library for editing
+bytecode in Java; it enables Java programs to define a new class at
+runtime and to modify a given class file when the JVM loads it.
+
+<p>The most significant class of this package is <code>CtClass</code>.
+See the description of this class first.
+
+<p>To know the version number of this package, type the following command:
+
+<ul><pre>
+java -jar javassist.jar
+</pre></ul>
+
+<p>It prints the version number on the console.
+
+</body>
+</html>
diff --git a/src/main/javassist/runtime/Cflow.java b/src/main/javassist/runtime/Cflow.java
new file mode 100644
index 0000000..641c63f
--- /dev/null
+++ b/src/main/javassist/runtime/Cflow.java
@@ -0,0 +1,52 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.runtime;
+
+/**
+ * A support class for implementing <code>$cflow</code>.
+ * This support class is required at runtime
+ * only if <code>$cflow</code> is used.
+ *
+ * @see javassist.CtBehavior#useCflow(String)
+ */
+public class Cflow extends ThreadLocal {
+ private static class Depth {
+ private int depth;
+ Depth() { depth = 0; }
+ int get() { return depth; }
+ void inc() { ++depth; }
+ void dec() { --depth; }
+ }
+
+ protected synchronized Object initialValue() {
+ return new Depth();
+ }
+
+ /**
+ * Increments the counter.
+ */
+ public void enter() { ((Depth)get()).inc(); }
+
+ /**
+ * Decrements the counter.
+ */
+ public void exit() { ((Depth)get()).dec(); }
+
+ /**
+ * Returns the value of the counter.
+ */
+ public int value() { return ((Depth)get()).get(); }
+}
diff --git a/src/main/javassist/runtime/Desc.java b/src/main/javassist/runtime/Desc.java
new file mode 100644
index 0000000..fa86a74
--- /dev/null
+++ b/src/main/javassist/runtime/Desc.java
@@ -0,0 +1,161 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.runtime;
+
+/**
+ * A support class for implementing <code>$sig</code> and
+ * <code>$type</code>.
+ * This support class is required at runtime
+ * only if <code>$sig</code> or <code>$type</code> is used.
+ */
+public class Desc {
+
+ /**
+ * Specifies how a <code>java.lang.Class</code> object is loaded.
+ *
+ * <p>If true, it is loaded by:
+ * <ul><pre>Thread.currentThread().getContextClassLoader().loadClass()</pre></ul>
+ * <p>If false, it is loaded by <code>Class.forName()</code>.
+ * The default value is false.
+ */
+ public static boolean useContextClassLoader = false;
+
+ private static Class getClassObject(String name)
+ throws ClassNotFoundException
+ {
+ if (useContextClassLoader)
+ return Thread.currentThread().getContextClassLoader()
+ .loadClass(name);
+ else
+ return Class.forName(name);
+ }
+
+ /**
+ * Interprets the given class name.
+ * It is used for implementing <code>$class</code>.
+ */
+ public static Class getClazz(String name) {
+ try {
+ return getClassObject(name);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException(
+ "$class: internal error, could not find class '" + name
+ + "' (Desc.useContextClassLoader: "
+ + Boolean.toString(useContextClassLoader) + ")", e);
+ }
+ }
+
+ /**
+ * Interprets the given type descriptor representing a method
+ * signature. It is used for implementing <code>$sig</code>.
+ */
+ public static Class[] getParams(String desc) {
+ if (desc.charAt(0) != '(')
+ throw new RuntimeException("$sig: internal error");
+
+ return getType(desc, desc.length(), 1, 0);
+ }
+
+ /**
+ * Interprets the given type descriptor.
+ * It is used for implementing <code>$type</code>.
+ */
+ public static Class getType(String desc) {
+ Class[] result = getType(desc, desc.length(), 0, 0);
+ if (result == null || result.length != 1)
+ throw new RuntimeException("$type: internal error");
+
+ return result[0];
+ }
+
+ private static Class[] getType(String desc, int descLen,
+ int start, int num) {
+ Class clazz;
+ if (start >= descLen)
+ return new Class[num];
+
+ char c = desc.charAt(start);
+ switch (c) {
+ case 'Z' :
+ clazz = Boolean.TYPE;
+ break;
+ case 'C' :
+ clazz = Character.TYPE;
+ break;
+ case 'B' :
+ clazz = Byte.TYPE;
+ break;
+ case 'S' :
+ clazz = Short.TYPE;
+ break;
+ case 'I' :
+ clazz = Integer.TYPE;
+ break;
+ case 'J' :
+ clazz = Long.TYPE;
+ break;
+ case 'F' :
+ clazz = Float.TYPE;
+ break;
+ case 'D' :
+ clazz = Double.TYPE;
+ break;
+ case 'V' :
+ clazz = Void.TYPE;
+ break;
+ case 'L' :
+ case '[' :
+ return getClassType(desc, descLen, start, num);
+ default :
+ return new Class[num];
+ }
+
+ Class[] result = getType(desc, descLen, start + 1, num + 1);
+ result[num] = clazz;
+ return result;
+ }
+
+ private static Class[] getClassType(String desc, int descLen,
+ int start, int num) {
+ int end = start;
+ while (desc.charAt(end) == '[')
+ ++end;
+
+ if (desc.charAt(end) == 'L') {
+ end = desc.indexOf(';', end);
+ if (end < 0)
+ throw new IndexOutOfBoundsException("bad descriptor");
+ }
+
+ String cname;
+ if (desc.charAt(start) == 'L')
+ cname = desc.substring(start + 1, end);
+ else
+ cname = desc.substring(start, end + 1);
+
+ Class[] result = getType(desc, descLen, end + 1, num + 1);
+ try {
+ result[num] = getClassObject(cname.replace('/', '.'));
+ }
+ catch (ClassNotFoundException e) {
+ // "new RuntimeException(e)" is not available in JDK 1.3.
+ throw new RuntimeException(e.getMessage());
+ }
+
+ return result;
+ }
+}
diff --git a/src/main/javassist/runtime/DotClass.java b/src/main/javassist/runtime/DotClass.java
new file mode 100644
index 0000000..29db811
--- /dev/null
+++ b/src/main/javassist/runtime/DotClass.java
@@ -0,0 +1,28 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.runtime;
+
+/**
+ * A support class for implementing <code>.class</code> notation.
+ * This is required at runtime
+ * only if <code>.class</code> notation is used in source code given
+ * to the Javassist compiler.
+ */
+public class DotClass {
+ public static NoClassDefFoundError fail(ClassNotFoundException e) {
+ return new NoClassDefFoundError(e.getMessage());
+ }
+}
diff --git a/src/main/javassist/runtime/Inner.java b/src/main/javassist/runtime/Inner.java
new file mode 100644
index 0000000..ef96c50
--- /dev/null
+++ b/src/main/javassist/runtime/Inner.java
@@ -0,0 +1,24 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.runtime;
+
+/**
+ * A support class for compiling a method declared in an inner class.
+ * This support class is required at runtime
+ * only if the method calls a private constructor in the enclosing class.
+ */
+public class Inner {
+}
diff --git a/src/main/javassist/runtime/package.html b/src/main/javassist/runtime/package.html
new file mode 100644
index 0000000..313648f
--- /dev/null
+++ b/src/main/javassist/runtime/package.html
@@ -0,0 +1,12 @@
+<html>
+<body>
+Runtime support classes required by modified bytecode.
+
+<p>This package includes support classes that may be required by
+classes modified with Javassist. Note that most of the modified
+classes do not require these support classes. See the documentation
+of every support class to know which kind of modification needs
+a support class.
+
+</body>
+</html>
diff --git a/src/main/javassist/scopedpool/ScopedClassPool.java b/src/main/javassist/scopedpool/ScopedClassPool.java
new file mode 100644
index 0000000..4833773
--- /dev/null
+++ b/src/main/javassist/scopedpool/ScopedClassPool.java
@@ -0,0 +1,308 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import java.lang.ref.WeakReference;
+import java.security.ProtectionDomain;
+import java.util.Iterator;
+import java.util.Map;
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.LoaderClassPath;
+import javassist.NotFoundException;
+
+/**
+ * A scoped class pool.
+ *
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ * @author <a href="adrian@jboss.com">Adrian Brock</a>
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.8 $
+ */
+public class ScopedClassPool extends ClassPool {
+ protected ScopedClassPoolRepository repository;
+
+ protected WeakReference classLoader;
+
+ protected LoaderClassPath classPath;
+
+ protected SoftValueHashMap softcache = new SoftValueHashMap();
+
+ boolean isBootstrapCl = true;
+
+ static {
+ ClassPool.doPruning = false;
+ ClassPool.releaseUnmodifiedClassFile = false;
+ }
+
+ /**
+ * Create a new ScopedClassPool.
+ *
+ * @param cl
+ * the classloader
+ * @param src
+ * the original class pool
+ * @param repository
+ * the repository
+ *@deprecated
+ */
+ protected ScopedClassPool(ClassLoader cl, ClassPool src,
+ ScopedClassPoolRepository repository) {
+ this(cl, src, repository, false);
+ }
+
+ /**
+ * Create a new ScopedClassPool.
+ *
+ * @param cl
+ * the classloader
+ * @param src
+ * the original class pool
+ * @param repository
+ * the repository
+ * @param isTemp
+ * Whether this is a temporary pool used to resolve references
+ */
+ protected ScopedClassPool(ClassLoader cl, ClassPool src, ScopedClassPoolRepository repository, boolean isTemp)
+ {
+ super(src);
+ this.repository = repository;
+ this.classLoader = new WeakReference(cl);
+ if (cl != null) {
+ classPath = new LoaderClassPath(cl);
+ this.insertClassPath(classPath);
+ }
+ childFirstLookup = true;
+ if (!isTemp && cl == null)
+ {
+ isBootstrapCl = true;
+ }
+ }
+
+ /**
+ * Get the class loader
+ *
+ * @return the class loader
+ */
+ public ClassLoader getClassLoader() {
+ ClassLoader cl = getClassLoader0();
+ if (cl == null && !isBootstrapCl)
+ {
+ throw new IllegalStateException(
+ "ClassLoader has been garbage collected");
+ }
+ return cl;
+ }
+
+ protected ClassLoader getClassLoader0() {
+ return (ClassLoader)classLoader.get();
+ }
+
+ /**
+ * Close the class pool
+ */
+ public void close() {
+ this.removeClassPath(classPath);
+ classPath.close();
+ classes.clear();
+ softcache.clear();
+ }
+
+ /**
+ * Flush a class
+ *
+ * @param classname
+ * the class to flush
+ */
+ public synchronized void flushClass(String classname) {
+ classes.remove(classname);
+ softcache.remove(classname);
+ }
+
+ /**
+ * Soften a class
+ *
+ * @param clazz
+ * the class
+ */
+ public synchronized void soften(CtClass clazz) {
+ if (repository.isPrune())
+ clazz.prune();
+ classes.remove(clazz.getName());
+ softcache.put(clazz.getName(), clazz);
+ }
+
+ /**
+ * Whether the classloader is loader
+ *
+ * @return false always
+ */
+ public boolean isUnloadedClassLoader() {
+ return false;
+ }
+
+ /**
+ * Get the cached class
+ *
+ * @param classname
+ * the class name
+ * @return the class
+ */
+ protected CtClass getCached(String classname) {
+ CtClass clazz = getCachedLocally(classname);
+ if (clazz == null) {
+ boolean isLocal = false;
+
+ ClassLoader dcl = getClassLoader0();
+ if (dcl != null) {
+ final int lastIndex = classname.lastIndexOf('$');
+ String classResourceName = null;
+ if (lastIndex < 0) {
+ classResourceName = classname.replaceAll("[\\.]", "/")
+ + ".class";
+ }
+ else {
+ classResourceName = classname.substring(0, lastIndex)
+ .replaceAll("[\\.]", "/")
+ + classname.substring(lastIndex) + ".class";
+ }
+
+ isLocal = dcl.getResource(classResourceName) != null;
+ }
+
+ if (!isLocal) {
+ Map registeredCLs = repository.getRegisteredCLs();
+ synchronized (registeredCLs) {
+ Iterator it = registeredCLs.values().iterator();
+ while (it.hasNext()) {
+ ScopedClassPool pool = (ScopedClassPool)it.next();
+ if (pool.isUnloadedClassLoader()) {
+ repository.unregisterClassLoader(pool
+ .getClassLoader());
+ continue;
+ }
+
+ clazz = pool.getCachedLocally(classname);
+ if (clazz != null) {
+ return clazz;
+ }
+ }
+ }
+ }
+ }
+ // *NOTE* NEED TO TEST WHEN SUPERCLASS IS IN ANOTHER UCL!!!!!!
+ return clazz;
+ }
+
+ /**
+ * Cache a class
+ *
+ * @param classname
+ * the class name
+ * @param c
+ * the ctClass
+ * @param dynamic
+ * whether the class is dynamically generated
+ */
+ protected void cacheCtClass(String classname, CtClass c, boolean dynamic) {
+ if (dynamic) {
+ super.cacheCtClass(classname, c, dynamic);
+ }
+ else {
+ if (repository.isPrune())
+ c.prune();
+ softcache.put(classname, c);
+ }
+ }
+
+ /**
+ * Lock a class into the cache
+ *
+ * @param c
+ * the class
+ */
+ public void lockInCache(CtClass c) {
+ super.cacheCtClass(c.getName(), c, false);
+ }
+
+ /**
+ * Whether the class is cached in this pooled
+ *
+ * @param classname
+ * the class name
+ * @return the cached class
+ */
+ protected CtClass getCachedLocally(String classname) {
+ CtClass cached = (CtClass)classes.get(classname);
+ if (cached != null)
+ return cached;
+ synchronized (softcache) {
+ return (CtClass)softcache.get(classname);
+ }
+ }
+
+ /**
+ * Get any local copy of the class
+ *
+ * @param classname
+ * the class name
+ * @return the class
+ * @throws NotFoundException
+ * when the class is not found
+ */
+ public synchronized CtClass getLocally(String classname)
+ throws NotFoundException {
+ softcache.remove(classname);
+ CtClass clazz = (CtClass)classes.get(classname);
+ if (clazz == null) {
+ clazz = createCtClass(classname, true);
+ if (clazz == null)
+ throw new NotFoundException(classname);
+ super.cacheCtClass(classname, clazz, false);
+ }
+
+ return clazz;
+ }
+
+ /**
+ * Convert a javassist class to a java class
+ *
+ * @param ct
+ * the javassist class
+ * @param loader
+ * the loader
+ * @throws CannotCompileException
+ * for any error
+ */
+ public Class toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)
+ throws CannotCompileException {
+ // We need to pass up the classloader stored in this pool, as the
+ // default implementation uses the Thread context cl.
+ // In the case of JSP's in Tomcat,
+ // org.apache.jasper.servlet.JasperLoader will be stored here, while
+ // it's parent
+ // org.jboss.web.tomcat.tc5.WebCtxLoader$ENCLoader is used as the Thread
+ // context cl. The invocation class needs to
+ // be generated in the JasperLoader classloader since in the case of
+ // method invocations, the package name will be
+ // the same as for the class generated from the jsp, i.e.
+ // org.apache.jsp. For classes belonging to org.apache.jsp,
+ // JasperLoader does NOT delegate to its parent if it cannot find them.
+ lockInCache(ct);
+ return super.toClass(ct, getClassLoader0(), domain);
+ }
+}
diff --git a/src/main/javassist/scopedpool/ScopedClassPoolFactory.java b/src/main/javassist/scopedpool/ScopedClassPoolFactory.java
new file mode 100644
index 0000000..1a998a9
--- /dev/null
+++ b/src/main/javassist/scopedpool/ScopedClassPoolFactory.java
@@ -0,0 +1,38 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import javassist.ClassPool;
+
+/**
+ * A factory interface.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.4 $
+ */
+public interface ScopedClassPoolFactory {
+ /**
+ * Makes an instance.
+ */
+ ScopedClassPool create(ClassLoader cl, ClassPool src,
+ ScopedClassPoolRepository repository);
+
+ /**
+ * Makes an instance.
+ */
+ ScopedClassPool create(ClassPool src,
+ ScopedClassPoolRepository repository);
+}
diff --git a/src/main/javassist/scopedpool/ScopedClassPoolFactoryImpl.java b/src/main/javassist/scopedpool/ScopedClassPoolFactoryImpl.java
new file mode 100644
index 0000000..b8e66d6
--- /dev/null
+++ b/src/main/javassist/scopedpool/ScopedClassPoolFactoryImpl.java
@@ -0,0 +1,42 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import javassist.ClassPool;
+
+/**
+ * An implementation of factory.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.5 $
+ */
+public class ScopedClassPoolFactoryImpl implements ScopedClassPoolFactory {
+ /**
+ * Makes an instance.
+ */
+ public ScopedClassPool create(ClassLoader cl, ClassPool src,
+ ScopedClassPoolRepository repository) {
+ return new ScopedClassPool(cl, src, repository, false);
+ }
+
+ /**
+ * Makes an instance.
+ */
+ public ScopedClassPool create(ClassPool src,
+ ScopedClassPoolRepository repository) {
+ return new ScopedClassPool(null, src, repository, true);
+ }
+}
diff --git a/src/main/javassist/scopedpool/ScopedClassPoolRepository.java b/src/main/javassist/scopedpool/ScopedClassPoolRepository.java
new file mode 100644
index 0000000..7ebf8f8
--- /dev/null
+++ b/src/main/javassist/scopedpool/ScopedClassPoolRepository.java
@@ -0,0 +1,97 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import java.util.Map;
+
+import javassist.ClassPool;
+
+/**
+ * An interface to <code>ScopedClassPoolRepositoryImpl</code>.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.4 $
+ */
+public interface ScopedClassPoolRepository {
+ /**
+ * Records a factory.
+ */
+ void setClassPoolFactory(ScopedClassPoolFactory factory);
+
+ /**
+ * Obtains the recorded factory.
+ */
+ ScopedClassPoolFactory getClassPoolFactory();
+
+ /**
+ * Returns whether or not the class pool is pruned.
+ *
+ * @return the prune.
+ */
+ boolean isPrune();
+
+ /**
+ * Sets the prune flag.
+ *
+ * @param prune a new value.
+ */
+ void setPrune(boolean prune);
+
+ /**
+ * Create a scoped classpool.
+ *
+ * @param cl the classloader.
+ * @param src the original classpool.
+ * @return the classpool.
+ */
+ ScopedClassPool createScopedClassPool(ClassLoader cl, ClassPool src);
+
+ /**
+ * Finds a scoped classpool registered under the passed in classloader.
+ *
+ * @param cl the classloader.
+ * @return the classpool.
+ */
+ ClassPool findClassPool(ClassLoader cl);
+
+ /**
+ * Register a classloader.
+ *
+ * @param ucl the classloader.
+ * @return the classpool.
+ */
+ ClassPool registerClassLoader(ClassLoader ucl);
+
+ /**
+ * Get the registered classloaders.
+ *
+ * @return the registered classloaders.
+ */
+ Map getRegisteredCLs();
+
+ /**
+ * This method will check to see if a register classloader has been
+ * undeployed (as in JBoss).
+ */
+ void clearUnregisteredClassLoaders();
+
+ /**
+ * Unregisters a classpool and unregisters its classloader.
+ *
+ * @param cl the classloader the pool is stored under.
+ */
+ void unregisterClassLoader(ClassLoader cl);
+}
diff --git a/src/main/javassist/scopedpool/ScopedClassPoolRepositoryImpl.java b/src/main/javassist/scopedpool/ScopedClassPoolRepositoryImpl.java
new file mode 100644
index 0000000..2245c7d
--- /dev/null
+++ b/src/main/javassist/scopedpool/ScopedClassPoolRepositoryImpl.java
@@ -0,0 +1,187 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import javassist.ClassPool;
+import javassist.LoaderClassPath;
+
+/**
+ * An implementation of <code>ScopedClassPoolRepository</code>.
+ * It is an singleton.
+ *
+ * @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
+ * @version $Revision: 1.4 $
+ */
+public class ScopedClassPoolRepositoryImpl implements ScopedClassPoolRepository {
+ /** The instance */
+ private static final ScopedClassPoolRepositoryImpl instance = new ScopedClassPoolRepositoryImpl();
+
+ /** Whether to prune */
+ private boolean prune = true;
+
+ /** Whether to prune when added to the classpool's cache */
+ boolean pruneWhenCached;
+
+ /** The registered classloaders */
+ protected Map registeredCLs = Collections
+ .synchronizedMap(new WeakHashMap());
+
+ /** The default class pool */
+ protected ClassPool classpool;
+
+ /** The factory for creating class pools */
+ protected ScopedClassPoolFactory factory = new ScopedClassPoolFactoryImpl();
+
+ /**
+ * Get the instance.
+ *
+ * @return the instance.
+ */
+ public static ScopedClassPoolRepository getInstance() {
+ return instance;
+ }
+
+ /**
+ * Singleton.
+ */
+ private ScopedClassPoolRepositoryImpl() {
+ classpool = ClassPool.getDefault();
+ // FIXME This doesn't look correct
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ classpool.insertClassPath(new LoaderClassPath(cl));
+ }
+
+ /**
+ * Returns the value of the prune attribute.
+ *
+ * @return the prune.
+ */
+ public boolean isPrune() {
+ return prune;
+ }
+
+ /**
+ * Set the prune attribute.
+ *
+ * @param prune a new value.
+ */
+ public void setPrune(boolean prune) {
+ this.prune = prune;
+ }
+
+ /**
+ * Create a scoped classpool.
+ *
+ * @param cl the classloader.
+ * @param src the original classpool.
+ * @return the classpool
+ */
+ public ScopedClassPool createScopedClassPool(ClassLoader cl, ClassPool src) {
+ return factory.create(cl, src, this);
+ }
+
+ public ClassPool findClassPool(ClassLoader cl) {
+ if (cl == null)
+ return registerClassLoader(ClassLoader.getSystemClassLoader());
+
+ return registerClassLoader(cl);
+ }
+
+ /**
+ * Register a classloader.
+ *
+ * @param ucl the classloader.
+ * @return the classpool
+ */
+ public ClassPool registerClassLoader(ClassLoader ucl) {
+ synchronized (registeredCLs) {
+ // FIXME: Probably want to take this method out later
+ // so that AOP framework can be independent of JMX
+ // This is in here so that we can remove a UCL from the ClassPool as
+ // a
+ // ClassPool.classpath
+ if (registeredCLs.containsKey(ucl)) {
+ return (ClassPool)registeredCLs.get(ucl);
+ }
+ ScopedClassPool pool = createScopedClassPool(ucl, classpool);
+ registeredCLs.put(ucl, pool);
+ return pool;
+ }
+ }
+
+ /**
+ * Get the registered classloaders.
+ */
+ public Map getRegisteredCLs() {
+ clearUnregisteredClassLoaders();
+ return registeredCLs;
+ }
+
+ /**
+ * This method will check to see if a register classloader has been
+ * undeployed (as in JBoss)
+ */
+ public void clearUnregisteredClassLoaders() {
+ ArrayList toUnregister = null;
+ synchronized (registeredCLs) {
+ Iterator it = registeredCLs.values().iterator();
+ while (it.hasNext()) {
+ ScopedClassPool pool = (ScopedClassPool)it.next();
+ if (pool.isUnloadedClassLoader()) {
+ it.remove();
+ ClassLoader cl = pool.getClassLoader();
+ if (cl != null) {
+ if (toUnregister == null) {
+ toUnregister = new ArrayList();
+ }
+ toUnregister.add(cl);
+ }
+ }
+ }
+ if (toUnregister != null) {
+ for (int i = 0; i < toUnregister.size(); i++) {
+ unregisterClassLoader((ClassLoader)toUnregister.get(i));
+ }
+ }
+ }
+ }
+
+ public void unregisterClassLoader(ClassLoader cl) {
+ synchronized (registeredCLs) {
+ ScopedClassPool pool = (ScopedClassPool)registeredCLs.remove(cl);
+ if (pool != null)
+ pool.close();
+ }
+ }
+
+ public void insertDelegate(ScopedClassPoolRepository delegate) {
+ // Noop - this is the end
+ }
+
+ public void setClassPoolFactory(ScopedClassPoolFactory factory) {
+ this.factory = factory;
+ }
+
+ public ScopedClassPoolFactory getClassPoolFactory() {
+ return factory;
+ }
+}
diff --git a/src/main/javassist/scopedpool/SoftValueHashMap.java b/src/main/javassist/scopedpool/SoftValueHashMap.java
new file mode 100644
index 0000000..6a73d9e
--- /dev/null
+++ b/src/main/javassist/scopedpool/SoftValueHashMap.java
@@ -0,0 +1,232 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.scopedpool;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.SoftReference;
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * This Map will remove entries when the value in the map has been cleaned from
+ * garbage collection
+ *
+ * @version <tt>$Revision: 1.4 $</tt>
+ * @author <a href="mailto:bill@jboss.org">Bill Burke</a>
+ */
+public class SoftValueHashMap extends AbstractMap implements Map {
+ private static class SoftValueRef extends SoftReference {
+ public Object key;
+
+ private SoftValueRef(Object key, Object val, ReferenceQueue q) {
+ super(val, q);
+ this.key = key;
+ }
+
+ private static SoftValueRef create(Object key, Object val,
+ ReferenceQueue q) {
+ if (val == null)
+ return null;
+ else
+ return new SoftValueRef(key, val, q);
+ }
+
+ }
+
+ /**
+ * Returns a set of the mappings contained in this hash table.
+ */
+ public Set entrySet() {
+ processQueue();
+ return hash.entrySet();
+ }
+
+ /* Hash table mapping WeakKeys to values */
+ private Map hash;
+
+ /* Reference queue for cleared WeakKeys */
+ private ReferenceQueue queue = new ReferenceQueue();
+
+ /*
+ * Remove all invalidated entries from the map, that is, remove all entries
+ * whose values have been discarded.
+ */
+ private void processQueue() {
+ SoftValueRef ref;
+ while ((ref = (SoftValueRef)queue.poll()) != null) {
+ if (ref == (SoftValueRef)hash.get(ref.key)) {
+ // only remove if it is the *exact* same WeakValueRef
+ //
+ hash.remove(ref.key);
+ }
+ }
+ }
+
+ /* -- Constructors -- */
+
+ /**
+ * Constructs a new, empty <code>WeakHashMap</code> with the given initial
+ * capacity and the given load factor.
+ *
+ * @param initialCapacity
+ * The initial capacity of the <code>WeakHashMap</code>
+ *
+ * @param loadFactor
+ * The load factor of the <code>WeakHashMap</code>
+ *
+ * @throws IllegalArgumentException
+ * If the initial capacity is less than zero, or if the load
+ * factor is nonpositive
+ */
+ public SoftValueHashMap(int initialCapacity, float loadFactor) {
+ hash = new HashMap(initialCapacity, loadFactor);
+ }
+
+ /**
+ * Constructs a new, empty <code>WeakHashMap</code> with the given initial
+ * capacity and the default load factor, which is <code>0.75</code>.
+ *
+ * @param initialCapacity
+ * The initial capacity of the <code>WeakHashMap</code>
+ *
+ * @throws IllegalArgumentException
+ * If the initial capacity is less than zero
+ */
+ public SoftValueHashMap(int initialCapacity) {
+ hash = new HashMap(initialCapacity);
+ }
+
+ /**
+ * Constructs a new, empty <code>WeakHashMap</code> with the default
+ * initial capacity and the default load factor, which is <code>0.75</code>.
+ */
+ public SoftValueHashMap() {
+ hash = new HashMap();
+ }
+
+ /**
+ * Constructs a new <code>WeakHashMap</code> with the same mappings as the
+ * specified <tt>Map</tt>. The <code>WeakHashMap</code> is created with
+ * an initial capacity of twice the number of mappings in the specified map
+ * or 11 (whichever is greater), and a default load factor, which is
+ * <tt>0.75</tt>.
+ *
+ * @param t the map whose mappings are to be placed in this map.
+ */
+ public SoftValueHashMap(Map t) {
+ this(Math.max(2 * t.size(), 11), 0.75f);
+ putAll(t);
+ }
+
+ /* -- Simple queries -- */
+
+ /**
+ * Returns the number of key-value mappings in this map. <strong>Note:</strong>
+ * <em>In contrast with most implementations of the
+ * <code>Map</code> interface, the time required by this operation is
+ * linear in the size of the map.</em>
+ */
+ public int size() {
+ processQueue();
+ return hash.size();
+ }
+
+ /**
+ * Returns <code>true</code> if this map contains no key-value mappings.
+ */
+ public boolean isEmpty() {
+ processQueue();
+ return hash.isEmpty();
+ }
+
+ /**
+ * Returns <code>true</code> if this map contains a mapping for the
+ * specified key.
+ *
+ * @param key
+ * The key whose presence in this map is to be tested.
+ */
+ public boolean containsKey(Object key) {
+ processQueue();
+ return hash.containsKey(key);
+ }
+
+ /* -- Lookup and modification operations -- */
+
+ /**
+ * Returns the value to which this map maps the specified <code>key</code>.
+ * If this map does not contain a value for this key, then return
+ * <code>null</code>.
+ *
+ * @param key
+ * The key whose associated value, if any, is to be returned.
+ */
+ public Object get(Object key) {
+ processQueue();
+ SoftReference ref = (SoftReference)hash.get(key);
+ if (ref != null)
+ return ref.get();
+ return null;
+ }
+
+ /**
+ * Updates this map so that the given <code>key</code> maps to the given
+ * <code>value</code>. If the map previously contained a mapping for
+ * <code>key</code> then that mapping is replaced and the previous value
+ * is returned.
+ *
+ * @param key
+ * The key that is to be mapped to the given <code>value</code>
+ * @param value
+ * The value to which the given <code>key</code> is to be
+ * mapped
+ *
+ * @return The previous value to which this key was mapped, or
+ * <code>null</code> if if there was no mapping for the key
+ */
+ public Object put(Object key, Object value) {
+ processQueue();
+ Object rtn = hash.put(key, SoftValueRef.create(key, value, queue));
+ if (rtn != null)
+ rtn = ((SoftReference)rtn).get();
+ return rtn;
+ }
+
+ /**
+ * Removes the mapping for the given <code>key</code> from this map, if
+ * present.
+ *
+ * @param key
+ * The key whose mapping is to be removed.
+ *
+ * @return The value to which this key was mapped, or <code>null</code> if
+ * there was no mapping for the key.
+ */
+ public Object remove(Object key) {
+ processQueue();
+ return hash.remove(key);
+ }
+
+ /**
+ * Removes all mappings from this map.
+ */
+ public void clear() {
+ processQueue();
+ hash.clear();
+ }
+}
diff --git a/src/main/javassist/scopedpool/package.html b/src/main/javassist/scopedpool/package.html
new file mode 100644
index 0000000..946e5e1
--- /dev/null
+++ b/src/main/javassist/scopedpool/package.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+<p>A custom class pool for several JBoss products.
+It is not part of Javassist.
+</p>
+</body>
+</html>
diff --git a/src/main/javassist/tools/Dump.java b/src/main/javassist/tools/Dump.java
new file mode 100644
index 0000000..2f064a8
--- /dev/null
+++ b/src/main/javassist/tools/Dump.java
@@ -0,0 +1,57 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools;
+
+import java.io.*;
+import javassist.bytecode.ClassFile;
+import javassist.bytecode.ClassFilePrinter;
+
+/**
+ * Dump is a tool for viewing the class definition in the given
+ * class file. Unlike the JDK javap tool, Dump works even if
+ * the class file is broken.
+ *
+ * <p>For example,
+ * <ul><pre>% java javassist.tools.Dump foo.class</pre></ul>
+ *
+ * <p>prints the contents of the constant pool and the list of methods
+ * and fields.
+ */
+public class Dump {
+ private Dump() {}
+
+ /**
+ * Main method.
+ *
+ * @param args <code>args[0]</code> is the class file name.
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length != 1) {
+ System.err.println("Usage: java Dump <class file name>");
+ return;
+ }
+
+ DataInputStream in = new DataInputStream(
+ new FileInputStream(args[0]));
+ ClassFile w = new ClassFile(in);
+ PrintWriter out = new PrintWriter(System.out, true);
+ out.println("*** constant pool ***");
+ w.getConstPool().print(out);
+ out.println();
+ out.println("*** members ***");
+ ClassFilePrinter.print(w, out);
+ }
+}
diff --git a/src/main/javassist/tools/framedump.java b/src/main/javassist/tools/framedump.java
new file mode 100644
index 0000000..0a30fb1
--- /dev/null
+++ b/src/main/javassist/tools/framedump.java
@@ -0,0 +1,47 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba, and others. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.tools;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.bytecode.analysis.FramePrinter;
+
+/**
+ * framedump is a tool for viewing a merged combination of the instructions and frame state
+ * of all methods in a class.
+ *
+ * <p>For example,
+ * <ul><pre>% java javassist.tools.framedump foo.class</pre></ul>
+ */
+public class framedump {
+ private framedump() {}
+
+ /**
+ * Main method.
+ *
+ * @param args <code>args[0]</code> is the class file name.
+ */
+ public static void main(String[] args) throws Exception {
+ if (args.length != 1) {
+ System.err.println("Usage: java javassist.tools.framedump <class file name>");
+ return;
+ }
+
+ ClassPool pool = ClassPool.getDefault();
+ CtClass clazz = pool.get(args[0]);
+ System.out.println("Frame Dump of " + clazz.getName() + ":");
+ FramePrinter.print(clazz, System.out);
+ }
+}
diff --git a/src/main/javassist/tools/package.html b/src/main/javassist/tools/package.html
new file mode 100644
index 0000000..bee6208
--- /dev/null
+++ b/src/main/javassist/tools/package.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+Covenient tools.
+
+</body>
+</html>
diff --git a/src/main/javassist/tools/reflect/CannotCreateException.java b/src/main/javassist/tools/reflect/CannotCreateException.java
new file mode 100644
index 0000000..75ffe0c
--- /dev/null
+++ b/src/main/javassist/tools/reflect/CannotCreateException.java
@@ -0,0 +1,29 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+/**
+ * Signals that <code>ClassMetaobject.newInstance()</code> fails.
+ */
+public class CannotCreateException extends Exception {
+ public CannotCreateException(String s) {
+ super(s);
+ }
+
+ public CannotCreateException(Exception e) {
+ super("by " + e.toString());
+ }
+}
diff --git a/src/main/javassist/tools/reflect/CannotInvokeException.java b/src/main/javassist/tools/reflect/CannotInvokeException.java
new file mode 100644
index 0000000..8c063d7
--- /dev/null
+++ b/src/main/javassist/tools/reflect/CannotInvokeException.java
@@ -0,0 +1,68 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.IllegalAccessException;
+
+/**
+ * Thrown when method invocation using the reflection API has thrown
+ * an exception.
+ *
+ * @see javassist.tools.reflect.Metaobject#trapMethodcall(int, Object[])
+ * @see javassist.tools.reflect.ClassMetaobject#trapMethodcall(int, Object[])
+ * @see javassist.tools.reflect.ClassMetaobject#invoke(Object, int, Object[])
+ */
+public class CannotInvokeException extends RuntimeException {
+
+ private Throwable err = null;
+
+ /**
+ * Returns the cause of this exception. It may return null.
+ */
+ public Throwable getReason() { return err; }
+
+ /**
+ * Constructs a CannotInvokeException with an error message.
+ */
+ public CannotInvokeException(String reason) {
+ super(reason);
+ }
+
+ /**
+ * Constructs a CannotInvokeException with an InvocationTargetException.
+ */
+ public CannotInvokeException(InvocationTargetException e) {
+ super("by " + e.getTargetException().toString());
+ err = e.getTargetException();
+ }
+
+ /**
+ * Constructs a CannotInvokeException with an IllegalAccessException.
+ */
+ public CannotInvokeException(IllegalAccessException e) {
+ super("by " + e.toString());
+ err = e;
+ }
+
+ /**
+ * Constructs a CannotInvokeException with an ClassNotFoundException.
+ */
+ public CannotInvokeException(ClassNotFoundException e) {
+ super("by " + e.toString());
+ err = e;
+ }
+}
diff --git a/src/main/javassist/tools/reflect/CannotReflectException.java b/src/main/javassist/tools/reflect/CannotReflectException.java
new file mode 100644
index 0000000..0af2892
--- /dev/null
+++ b/src/main/javassist/tools/reflect/CannotReflectException.java
@@ -0,0 +1,34 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import javassist.CannotCompileException;
+
+/**
+ * Thrown by <code>makeReflective()</code> in <code>Reflection</code>
+ * when there is an attempt to reflect
+ * a class that is either an interface or a subclass of
+ * either ClassMetaobject or Metaobject.
+ *
+ * @author Brett Randall
+ * @see javassist.tools.reflect.Reflection#makeReflective(CtClass,CtClass,CtClass)
+ * @see javassist.CannotCompileException
+ */
+public class CannotReflectException extends CannotCompileException {
+ public CannotReflectException(String msg) {
+ super(msg);
+ }
+}
diff --git a/src/main/javassist/tools/reflect/ClassMetaobject.java b/src/main/javassist/tools/reflect/ClassMetaobject.java
new file mode 100644
index 0000000..208d104
--- /dev/null
+++ b/src/main/javassist/tools/reflect/ClassMetaobject.java
@@ -0,0 +1,369 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import java.lang.reflect.*;
+import java.util.Arrays;
+import java.io.Serializable;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/**
+ * A runtime class metaobject.
+ *
+ * <p>A <code>ClassMetaobject</code> is created for every
+ * class of reflective objects. It can be used to hold values
+ * shared among the reflective objects of the same class.
+ *
+ * <p>To obtain a class metaobject, calls <code>_getClass()</code>
+ * on a reflective object. For example,
+ *
+ * <ul><pre>ClassMetaobject cm = ((Metalevel)reflectiveObject)._getClass();
+ * </pre></ul>
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.Metalevel
+ */
+public class ClassMetaobject implements Serializable {
+ /**
+ * The base-level methods controlled by a metaobject
+ * are renamed so that they begin with
+ * <code>methodPrefix "_m_"</code>.
+ */
+ static final String methodPrefix = "_m_";
+ static final int methodPrefixLen = 3;
+
+ private Class javaClass;
+ private Constructor[] constructors;
+ private Method[] methods;
+
+ /**
+ * Specifies how a <code>java.lang.Class</code> object is loaded.
+ *
+ * <p>If true, it is loaded by:
+ * <ul><pre>Thread.currentThread().getContextClassLoader().loadClass()</pre></ul>
+ * <p>If false, it is loaded by <code>Class.forName()</code>.
+ * The default value is false.
+ */
+ public static boolean useContextClassLoader = false;
+
+ /**
+ * Constructs a <code>ClassMetaobject</code>.
+ *
+ * @param params <code>params[0]</code> is the name of the class
+ * of the reflective objects.
+ */
+ public ClassMetaobject(String[] params)
+ {
+ try {
+ javaClass = getClassObject(params[0]);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException("not found: " + params[0]
+ + ", useContextClassLoader: "
+ + Boolean.toString(useContextClassLoader), e);
+ }
+
+ constructors = javaClass.getConstructors();
+ methods = null;
+ }
+
+ private void writeObject(ObjectOutputStream out) throws IOException {
+ out.writeUTF(javaClass.getName());
+ }
+
+ private void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException
+ {
+ javaClass = getClassObject(in.readUTF());
+ constructors = javaClass.getConstructors();
+ methods = null;
+ }
+
+ private Class getClassObject(String name) throws ClassNotFoundException {
+ if (useContextClassLoader)
+ return Thread.currentThread().getContextClassLoader()
+ .loadClass(name);
+ else
+ return Class.forName(name);
+ }
+
+ /**
+ * Obtains the <code>java.lang.Class</code> representing this class.
+ */
+ public final Class getJavaClass() {
+ return javaClass;
+ }
+
+ /**
+ * Obtains the name of this class.
+ */
+ public final String getName() {
+ return javaClass.getName();
+ }
+
+ /**
+ * Returns true if <code>obj</code> is an instance of this class.
+ */
+ public final boolean isInstance(Object obj) {
+ return javaClass.isInstance(obj);
+ }
+
+ /**
+ * Creates a new instance of the class.
+ *
+ * @param args the arguments passed to the constructor.
+ */
+ public final Object newInstance(Object[] args)
+ throws CannotCreateException
+ {
+ int n = constructors.length;
+ for (int i = 0; i < n; ++i) {
+ try {
+ return constructors[i].newInstance(args);
+ }
+ catch (IllegalArgumentException e) {
+ // try again
+ }
+ catch (InstantiationException e) {
+ throw new CannotCreateException(e);
+ }
+ catch (IllegalAccessException e) {
+ throw new CannotCreateException(e);
+ }
+ catch (InvocationTargetException e) {
+ throw new CannotCreateException(e);
+ }
+ }
+
+ throw new CannotCreateException("no constructor matches");
+ }
+
+ /**
+ * Is invoked when <code>static</code> fields of the base-level
+ * class are read and the runtime system intercepts it.
+ * This method simply returns the value of the field.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ */
+ public Object trapFieldRead(String name) {
+ Class jc = getJavaClass();
+ try {
+ return jc.getField(name).get(null);
+ }
+ catch (NoSuchFieldException e) {
+ throw new RuntimeException(e.toString());
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Is invoked when <code>static</code> fields of the base-level
+ * class are modified and the runtime system intercepts it.
+ * This method simply sets the field to the given value.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ */
+ public void trapFieldWrite(String name, Object value) {
+ Class jc = getJavaClass();
+ try {
+ jc.getField(name).set(null, value);
+ }
+ catch (NoSuchFieldException e) {
+ throw new RuntimeException(e.toString());
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Invokes a method whose name begins with
+ * <code>methodPrefix "_m_"</code> and the identifier.
+ *
+ * @exception CannotInvokeException if the invocation fails.
+ */
+ static public Object invoke(Object target, int identifier, Object[] args)
+ throws Throwable
+ {
+ Method[] allmethods = target.getClass().getMethods();
+ int n = allmethods.length;
+ String head = methodPrefix + identifier;
+ for (int i = 0; i < n; ++i)
+ if (allmethods[i].getName().startsWith(head)) {
+ try {
+ return allmethods[i].invoke(target, args);
+ } catch (java.lang.reflect.InvocationTargetException e) {
+ throw e.getTargetException();
+ } catch (java.lang.IllegalAccessException e) {
+ throw new CannotInvokeException(e);
+ }
+ }
+
+ throw new CannotInvokeException("cannot find a method");
+ }
+
+ /**
+ * Is invoked when <code>static</code> methods of the base-level
+ * class are called and the runtime system intercepts it.
+ * This method simply executes the intercepted method invocation
+ * with the original parameters and returns the resulting value.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ */
+ public Object trapMethodcall(int identifier, Object[] args)
+ throws Throwable
+ {
+ try {
+ Method[] m = getReflectiveMethods();
+ return m[identifier].invoke(null, args);
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+ catch (java.lang.IllegalAccessException e) {
+ throw new CannotInvokeException(e);
+ }
+ }
+
+ /**
+ * Returns an array of the methods defined on the given reflective
+ * object. This method is for the internal use only.
+ */
+ public final Method[] getReflectiveMethods() {
+ if (methods != null)
+ return methods;
+
+ Class baseclass = getJavaClass();
+ Method[] allmethods = baseclass.getDeclaredMethods();
+ int n = allmethods.length;
+ int[] index = new int[n];
+ int max = 0;
+ for (int i = 0; i < n; ++i) {
+ Method m = allmethods[i];
+ String mname = m.getName();
+ if (mname.startsWith(methodPrefix)) {
+ int k = 0;
+ for (int j = methodPrefixLen;; ++j) {
+ char c = mname.charAt(j);
+ if ('0' <= c && c <= '9')
+ k = k * 10 + c - '0';
+ else
+ break;
+ }
+
+ index[i] = ++k;
+ if (k > max)
+ max = k;
+ }
+ }
+
+ methods = new Method[max];
+ for (int i = 0; i < n; ++i)
+ if (index[i] > 0)
+ methods[index[i] - 1] = allmethods[i];
+
+ return methods;
+ }
+
+ /**
+ * Returns the <code>java.lang.reflect.Method</code> object representing
+ * the method specified by <code>identifier</code>.
+ *
+ * <p>Note that the actual method returned will be have an altered,
+ * reflective name i.e. <code>_m_2_..</code>.
+ *
+ * @param identifier the identifier index
+ * given to <code>trapMethodcall()</code> etc.
+ * @see Metaobject#trapMethodcall(int,Object[])
+ * @see #trapMethodcall(int,Object[])
+ */
+ public final Method getMethod(int identifier) {
+ return getReflectiveMethods()[identifier];
+ }
+
+ /**
+ * Returns the name of the method specified
+ * by <code>identifier</code>.
+ */
+ public final String getMethodName(int identifier) {
+ String mname = getReflectiveMethods()[identifier].getName();
+ int j = ClassMetaobject.methodPrefixLen;
+ for (;;) {
+ char c = mname.charAt(j++);
+ if (c < '0' || '9' < c)
+ break;
+ }
+
+ return mname.substring(j);
+ }
+
+ /**
+ * Returns an array of <code>Class</code> objects representing the
+ * formal parameter types of the method specified
+ * by <code>identifier</code>.
+ */
+ public final Class[] getParameterTypes(int identifier) {
+ return getReflectiveMethods()[identifier].getParameterTypes();
+ }
+
+ /**
+ * Returns a <code>Class</code> objects representing the
+ * return type of the method specified by <code>identifier</code>.
+ */
+ public final Class getReturnType(int identifier) {
+ return getReflectiveMethods()[identifier].getReturnType();
+ }
+
+ /**
+ * Returns the identifier index of the method, as identified by its
+ * original name.
+ *
+ * <p>This method is useful, in conjuction with
+ * <link>ClassMetaobject#getMethod()</link>, to obtain a quick reference
+ * to the original method in the reflected class (i.e. not the proxy
+ * method), using the original name of the method.
+ *
+ * <p>Written by Brett Randall and Shigeru Chiba.
+ *
+ * @param originalName The original name of the reflected method
+ * @param argTypes array of Class specifying the method signature
+ * @return the identifier index of the original method
+ * @throws NoSuchMethodException if the method does not exist
+ *
+ * @see ClassMetaobject#getMethod(int)
+ */
+ public final int getMethodIndex(String originalName, Class[] argTypes)
+ throws NoSuchMethodException
+ {
+ Method[] mthds = getReflectiveMethods();
+ for (int i = 0; i < mthds.length; i++) {
+ if (mthds[i] == null)
+ continue;
+
+ // check name and parameter types match
+ if (getMethodName(i).equals(originalName)
+ && Arrays.equals(argTypes, mthds[i].getParameterTypes()))
+ return i;
+ }
+
+ throw new NoSuchMethodException("Method " + originalName
+ + " not found");
+ }
+}
diff --git a/src/main/javassist/tools/reflect/Compiler.java b/src/main/javassist/tools/reflect/Compiler.java
new file mode 100644
index 0000000..5375584
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Compiler.java
@@ -0,0 +1,162 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import javassist.CtClass;
+import javassist.ClassPool;
+import java.io.PrintStream;
+
+class CompiledClass {
+ public String classname;
+ public String metaobject;
+ public String classobject;
+}
+
+/**
+ * A bytecode translator for reflection.
+ *
+ * <p>This translator directly modifies class files on a local disk so that
+ * the classes represented by those class files are reflective.
+ * After the modification, the class files can be run with the standard JVM
+ * without <code>javassist.tools.reflect.Loader</code>
+ * or any other user-defined class loader.
+ *
+ * <p>The modified class files are given as the command-line parameters,
+ * which are a sequence of fully-qualified class names followed by options:
+ *
+ * <p><code>-m <i>classname</i></code> : specifies the class of the
+ * metaobjects associated with instances of the class followed by
+ * this option. The default is <code>javassit.reflect.Metaobject</code>.
+ *
+ * <p><code>-c <i>classname</i></code> : specifies the class of the
+ * class metaobjects associated with instances of the class followed by
+ * this option. The default is <code>javassit.reflect.ClassMetaobject</code>.
+ *
+ * <p>If a class name is not followed by any options, the class indicated
+ * by that class name is not reflective.
+ *
+ * <p>For example,
+ * <ul><pre>% java Compiler Dog -m MetaDog -c CMetaDog Cat -m MetaCat Cow
+ * </pre></ul>
+ *
+ * <p>modifies class files <code>Dog.class</code>, <code>Cat.class</code>,
+ * and <code>Cow.class</code>.
+ * The metaobject of a Dog object is a MetaDog object and the class
+ * metaobject is a CMetaDog object.
+ * The metaobject of a Cat object is a MetaCat object but
+ * the class metaobject is a default one.
+ * Cow objects are not reflective.
+ *
+ * <p>Note that if the super class is also made reflective, it must be done
+ * before the sub class.
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.ClassMetaobject
+ * @see javassist.tools.reflect.Reflection
+ */
+public class Compiler {
+
+ public static void main(String[] args) throws Exception {
+ if (args.length == 0) {
+ help(System.err);
+ return;
+ }
+
+ CompiledClass[] entries = new CompiledClass[args.length];
+ int n = parse(args, entries);
+
+ if (n < 1) {
+ System.err.println("bad parameter.");
+ return;
+ }
+
+ processClasses(entries, n);
+ }
+
+ private static void processClasses(CompiledClass[] entries, int n)
+ throws Exception
+ {
+ Reflection implementor = new Reflection();
+ ClassPool pool = ClassPool.getDefault();
+ implementor.start(pool);
+
+ for (int i = 0; i < n; ++i) {
+ CtClass c = pool.get(entries[i].classname);
+ if (entries[i].metaobject != null
+ || entries[i].classobject != null) {
+ String metaobj, classobj;
+
+ if (entries[i].metaobject == null)
+ metaobj = "javassist.tools.reflect.Metaobject";
+ else
+ metaobj = entries[i].metaobject;
+
+ if (entries[i].classobject == null)
+ classobj = "javassist.tools.reflect.ClassMetaobject";
+ else
+ classobj = entries[i].classobject;
+
+ if (!implementor.makeReflective(c, pool.get(metaobj),
+ pool.get(classobj)))
+ System.err.println("Warning: " + c.getName()
+ + " is reflective. It was not changed.");
+
+ System.err.println(c.getName() + ": " + metaobj + ", "
+ + classobj);
+ }
+ else
+ System.err.println(c.getName() + ": not reflective");
+ }
+
+ for (int i = 0; i < n; ++i) {
+ implementor.onLoad(pool, entries[i].classname);
+ pool.get(entries[i].classname).writeFile();
+ }
+ }
+
+ private static int parse(String[] args, CompiledClass[] result) {
+ int n = -1;
+ for (int i = 0; i < args.length; ++i) {
+ String a = args[i];
+ if (a.equals("-m"))
+ if (n < 0 || i + 1 > args.length)
+ return -1;
+ else
+ result[n].metaobject = args[++i];
+ else if (a.equals("-c"))
+ if (n < 0 || i + 1 > args.length)
+ return -1;
+ else
+ result[n].classobject = args[++i];
+ else if (a.charAt(0) == '-')
+ return -1;
+ else {
+ CompiledClass cc = new CompiledClass();
+ cc.classname = a;
+ cc.metaobject = null;
+ cc.classobject = null;
+ result[++n] = cc;
+ }
+ }
+
+ return n + 1;
+ }
+
+ private static void help(PrintStream out) {
+ out.println("Usage: java javassist.tools.reflect.Compiler");
+ out.println(" (<class> [-m <metaobject>] [-c <class metaobject>])+");
+ }
+}
diff --git a/src/main/javassist/tools/reflect/Loader.java b/src/main/javassist/tools/reflect/Loader.java
new file mode 100644
index 0000000..a9aef4b
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Loader.java
@@ -0,0 +1,163 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import javassist.CannotCompileException;
+import javassist.NotFoundException;
+import javassist.ClassPool;
+
+/**
+ * A class loader for reflection.
+ *
+ * <p>To run a program, say <code>MyApp</code>,
+ * including a reflective class,
+ * you must write a start-up program as follows:
+ *
+ * <ul><pre>
+ * public class Main {
+ * public static void main(String[] args) throws Throwable {
+ * javassist.tools.reflect.Loader cl
+ * = (javassist.tools.reflect.Loader)Main.class.getClassLoader();
+ * cl.makeReflective("Person", "MyMetaobject",
+ * "javassist.tools.reflect.ClassMetaobject");
+ * cl.run("MyApp", args);
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p>Then run this program as follows:
+ *
+ * <ul><pre>% java javassist.tools.reflect.Loader Main arg1, ...</pre></ul>
+ *
+ * <p>This command runs <code>Main.main()</code> with <code>arg1</code>, ...
+ * and <code>Main.main()</code> runs <code>MyApp.main()</code> with
+ * <code>arg1</code>, ...
+ * The <code>Person</code> class is modified
+ * to be a reflective class. Method calls on a <code>Person</code>
+ * object are intercepted by an instance of <code>MyMetaobject</code>.
+ *
+ * <p>Also, you can run <code>MyApp</code> in a slightly different way:
+ *
+ * <ul><pre>
+ * public class Main2 {
+ * public static void main(String[] args) throws Throwable {
+ * javassist.tools.reflect.Loader cl = new javassist.tools.reflect.Loader();
+ * cl.makeReflective("Person", "MyMetaobject",
+ * "javassist.tools.reflect.ClassMetaobject");
+ * cl.run("MyApp", args);
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p>This program is run as follows:
+ *
+ * <ul><pre>% java Main2 arg1, ...</pre></ul>
+ *
+ * <p>The difference from the former one is that the class <code>Main</code>
+ * is loaded by <code>javassist.tools.reflect.Loader</code> whereas the class
+ * <code>Main2</code> is not. Thus, <code>Main</code> belongs
+ * to the same name space (security domain) as <code>MyApp</code>
+ * whereas <code>Main2</code> does not; <code>Main2</code> belongs
+ * to the same name space as <code>javassist.tools.reflect.Loader</code>.
+ * For more details,
+ * see the notes in the manual page of <code>javassist.Loader</code>.
+ *
+ * <p>The class <code>Main2</code> is equivalent to this class:
+ *
+ * <ul><pre>
+ * public class Main3 {
+ * public static void main(String[] args) throws Throwable {
+ * Reflection reflection = new Reflection();
+ * javassist.Loader cl
+ * = new javassist.Loader(ClassPool.getDefault(reflection));
+ * reflection.makeReflective("Person", "MyMetaobject",
+ * "javassist.tools.reflect.ClassMetaobject");
+ * cl.run("MyApp", args);
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p><b>Note:</b>
+ *
+ * <p><code>javassist.tools.reflect.Loader</code> does not make a class reflective
+ * if that class is in a <code>java.*</code> or
+ * <code>javax.*</code> pacakge because of the specifications
+ * on the class loading algorithm of Java. The JVM does not allow to
+ * load such a system class with a user class loader.
+ *
+ * <p>To avoid this limitation, those classes should be statically
+ * modified with <code>javassist.tools.reflect.Compiler</code> and the original
+ * class files should be replaced.
+ *
+ * @see javassist.tools.reflect.Reflection
+ * @see javassist.tools.reflect.Compiler
+ * @see javassist.Loader
+ */
+public class Loader extends javassist.Loader {
+ protected Reflection reflection;
+
+ /**
+ * Loads a class with an instance of <code>Loader</code>
+ * and calls <code>main()</code> in that class.
+ *
+ * @param args command line parameters.
+ * <ul>
+ * <code>args[0]</code> is the class name to be loaded.
+ * <br><code>args[1..n]</code> are parameters passed
+ * to the target <code>main()</code>.
+ * </ul>
+ */
+ public static void main(String[] args) throws Throwable {
+ Loader cl = new Loader();
+ cl.run(args);
+ }
+
+ /**
+ * Constructs a new class loader.
+ */
+ public Loader() throws CannotCompileException, NotFoundException {
+ super();
+ delegateLoadingOf("javassist.tools.reflect.Loader");
+
+ reflection = new Reflection();
+ ClassPool pool = ClassPool.getDefault();
+ addTranslator(pool, reflection);
+ }
+
+ /**
+ * Produces a reflective class.
+ * If the super class is also made reflective, it must be done
+ * before the sub class.
+ *
+ * @param clazz the reflective class.
+ * @param metaobject the class of metaobjects.
+ * It must be a subclass of
+ * <code>Metaobject</code>.
+ * @param metaclass the class of the class metaobject.
+ * It must be a subclass of
+ * <code>ClassMetaobject</code>.
+ * @return <code>false</code> if the class is already reflective.
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.ClassMetaobject
+ */
+ public boolean makeReflective(String clazz,
+ String metaobject, String metaclass)
+ throws CannotCompileException, NotFoundException
+ {
+ return reflection.makeReflective(clazz, metaobject, metaclass);
+ }
+}
diff --git a/src/main/javassist/tools/reflect/Metalevel.java b/src/main/javassist/tools/reflect/Metalevel.java
new file mode 100644
index 0000000..4361fac
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Metalevel.java
@@ -0,0 +1,38 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+/**
+ * An interface to access a metaobject and a class metaobject.
+ * This interface is implicitly implemented by the reflective
+ * class.
+ */
+public interface Metalevel {
+ /**
+ * Obtains the class metaobject associated with this object.
+ */
+ ClassMetaobject _getClass();
+
+ /**
+ * Obtains the metaobject associated with this object.
+ */
+ Metaobject _getMetaobject();
+
+ /**
+ * Changes the metaobject associated with this object.
+ */
+ void _setMetaobject(Metaobject m);
+}
diff --git a/src/main/javassist/tools/reflect/Metaobject.java b/src/main/javassist/tools/reflect/Metaobject.java
new file mode 100644
index 0000000..cd3a5f5
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Metaobject.java
@@ -0,0 +1,236 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import java.lang.reflect.Method;
+import java.io.Serializable;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+
+/**
+ * A runtime metaobject.
+ *
+ * <p>A <code>Metaobject</code> is created for
+ * every object at the base level. A different reflective object is
+ * associated with a different metaobject.
+ *
+ * <p>The metaobject intercepts method calls
+ * on the reflective object at the base-level. To change the behavior
+ * of the method calls, a subclass of <code>Metaobject</code>
+ * should be defined.
+ *
+ * <p>To obtain a metaobject, calls <code>_getMetaobject()</code>
+ * on a reflective object. For example,
+ *
+ * <ul><pre>Metaobject m = ((Metalevel)reflectiveObject)._getMetaobject();
+ * </pre></ul>
+ *
+ * @see javassist.tools.reflect.ClassMetaobject
+ * @see javassist.tools.reflect.Metalevel
+ */
+public class Metaobject implements Serializable {
+ protected ClassMetaobject classmetaobject;
+ protected Metalevel baseobject;
+ protected Method[] methods;
+
+ /**
+ * Constructs a <code>Metaobject</code>. The metaobject is
+ * constructed before the constructor is called on the base-level
+ * object.
+ *
+ * @param self the object that this metaobject is associated with.
+ * @param args the parameters passed to the constructor of
+ * <code>self</code>.
+ */
+ public Metaobject(Object self, Object[] args) {
+ baseobject = (Metalevel)self;
+ classmetaobject = baseobject._getClass();
+ methods = classmetaobject.getReflectiveMethods();
+ }
+
+ /**
+ * Constructs a <code>Metaobject</code> without initialization.
+ * If calling this constructor, a subclass should be responsible
+ * for initialization.
+ */
+ protected Metaobject() {
+ baseobject = null;
+ classmetaobject = null;
+ methods = null;
+ }
+
+ private void writeObject(ObjectOutputStream out) throws IOException {
+ out.writeObject(baseobject);
+ }
+
+ private void readObject(ObjectInputStream in)
+ throws IOException, ClassNotFoundException
+ {
+ baseobject = (Metalevel)in.readObject();
+ classmetaobject = baseobject._getClass();
+ methods = classmetaobject.getReflectiveMethods();
+ }
+
+ /**
+ * Obtains the class metaobject associated with this metaobject.
+ *
+ * @see javassist.tools.reflect.ClassMetaobject
+ */
+ public final ClassMetaobject getClassMetaobject() {
+ return classmetaobject;
+ }
+
+ /**
+ * Obtains the object controlled by this metaobject.
+ */
+ public final Object getObject() {
+ return baseobject;
+ }
+
+ /**
+ * Changes the object controlled by this metaobject.
+ *
+ * @param self the object
+ */
+ public final void setObject(Object self) {
+ baseobject = (Metalevel)self;
+ classmetaobject = baseobject._getClass();
+ methods = classmetaobject.getReflectiveMethods();
+
+ // call _setMetaobject() after the metaobject is settled.
+ baseobject._setMetaobject(this);
+ }
+
+ /**
+ * Returns the name of the method specified
+ * by <code>identifier</code>.
+ */
+ public final String getMethodName(int identifier) {
+ String mname = methods[identifier].getName();
+ int j = ClassMetaobject.methodPrefixLen;
+ for (;;) {
+ char c = mname.charAt(j++);
+ if (c < '0' || '9' < c)
+ break;
+ }
+
+ return mname.substring(j);
+ }
+
+ /**
+ * Returns an array of <code>Class</code> objects representing the
+ * formal parameter types of the method specified
+ * by <code>identifier</code>.
+ */
+ public final Class[] getParameterTypes(int identifier) {
+ return methods[identifier].getParameterTypes();
+ }
+
+ /**
+ * Returns a <code>Class</code> objects representing the
+ * return type of the method specified by <code>identifier</code>.
+ */
+ public final Class getReturnType(int identifier) {
+ return methods[identifier].getReturnType();
+ }
+
+ /**
+ * Is invoked when public fields of the base-level
+ * class are read and the runtime system intercepts it.
+ * This method simply returns the value of the field.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ */
+ public Object trapFieldRead(String name) {
+ Class jc = getClassMetaobject().getJavaClass();
+ try {
+ return jc.getField(name).get(getObject());
+ }
+ catch (NoSuchFieldException e) {
+ throw new RuntimeException(e.toString());
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Is invoked when public fields of the base-level
+ * class are modified and the runtime system intercepts it.
+ * This method simply sets the field to the given value.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ */
+ public void trapFieldWrite(String name, Object value) {
+ Class jc = getClassMetaobject().getJavaClass();
+ try {
+ jc.getField(name).set(getObject(), value);
+ }
+ catch (NoSuchFieldException e) {
+ throw new RuntimeException(e.toString());
+ }
+ catch (IllegalAccessException e) {
+ throw new RuntimeException(e.toString());
+ }
+ }
+
+ /**
+ * Is invoked when base-level method invocation is intercepted.
+ * This method simply executes the intercepted method invocation
+ * with the original parameters and returns the resulting value.
+ *
+ * <p>Every subclass of this class should redefine this method.
+ *
+ * <p>Note: this method is not invoked if the base-level method
+ * is invoked by a constructor in the super class. For example,
+ *
+ * <ul><pre>abstract class A {
+ * abstract void initialize();
+ * A() {
+ * initialize(); // not intercepted
+ * }
+ * }
+ *
+ * class B extends A {
+ * void initialize() { System.out.println("initialize()"); }
+ * B() {
+ * super();
+ * initialize(); // intercepted
+ * }
+ * }</pre></ul>
+ *
+ * <p>if an instance of B is created,
+ * the invocation of initialize() in B is intercepted only once.
+ * The first invocation by the constructor in A is not intercepted.
+ * This is because the link between a base-level object and a
+ * metaobject is not created until the execution of a
+ * constructor of the super class finishes.
+ */
+ public Object trapMethodcall(int identifier, Object[] args)
+ throws Throwable
+ {
+ try {
+ return methods[identifier].invoke(getObject(), args);
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+ catch (java.lang.IllegalAccessException e) {
+ throw new CannotInvokeException(e);
+ }
+ }
+}
diff --git a/src/main/javassist/tools/reflect/Reflection.java b/src/main/javassist/tools/reflect/Reflection.java
new file mode 100644
index 0000000..cb93096
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Reflection.java
@@ -0,0 +1,384 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+import javassist.*;
+import javassist.CtMethod.ConstParameter;
+
+/**
+ * The class implementing the behavioral reflection mechanism.
+ *
+ * <p>If a class is reflective,
+ * then all the method invocations on every
+ * instance of that class are intercepted by the runtime
+ * metaobject controlling that instance. The methods inherited from the
+ * super classes are also intercepted except final methods. To intercept
+ * a final method in a super class, that super class must be also reflective.
+ *
+ * <p>To do this, the original class file representing a reflective class:
+ *
+ * <ul><pre>
+ * class Person {
+ * public int f(int i) { return i + 1; }
+ * public int value;
+ * }
+ * </pre></ul>
+ *
+ * <p>is modified so that it represents a class:
+ *
+ * <ul><pre>
+ * class Person implements Metalevel {
+ * public int _original_f(int i) { return i + 1; }
+ * public int f(int i) { <i>delegate to the metaobject</i> }
+ *
+ * public int value;
+ * public int _r_value() { <i>read "value"</i> }
+ * public void _w_value(int v) { <i>write "value"</i> }
+ *
+ * public ClassMetaobject _getClass() { <i>return a class metaobject</i> }
+ * public Metaobject _getMetaobject() { <i>return a metaobject</i> }
+ * public void _setMetaobject(Metaobject m) { <i>change a metaobject</i> }
+ * }
+ * </pre></ul>
+ *
+ * @see javassist.tools.reflect.ClassMetaobject
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.Loader
+ * @see javassist.tools.reflect.Compiler
+ */
+public class Reflection implements Translator {
+
+ static final String classobjectField = "_classobject";
+ static final String classobjectAccessor = "_getClass";
+ static final String metaobjectField = "_metaobject";
+ static final String metaobjectGetter = "_getMetaobject";
+ static final String metaobjectSetter = "_setMetaobject";
+ static final String readPrefix = "_r_";
+ static final String writePrefix = "_w_";
+
+ static final String metaobjectClassName = "javassist.tools.reflect.Metaobject";
+ static final String classMetaobjectClassName
+ = "javassist.tools.reflect.ClassMetaobject";
+
+ protected CtMethod trapMethod, trapStaticMethod;
+ protected CtMethod trapRead, trapWrite;
+ protected CtClass[] readParam;
+
+ protected ClassPool classPool;
+ protected CodeConverter converter;
+
+ private boolean isExcluded(String name) {
+ return name.startsWith(ClassMetaobject.methodPrefix)
+ || name.equals(classobjectAccessor)
+ || name.equals(metaobjectSetter)
+ || name.equals(metaobjectGetter)
+ || name.startsWith(readPrefix)
+ || name.startsWith(writePrefix);
+ }
+
+ /**
+ * Constructs a new <code>Reflection</code> object.
+ */
+ public Reflection() {
+ classPool = null;
+ converter = new CodeConverter();
+ }
+
+ /**
+ * Initializes the object.
+ */
+ public void start(ClassPool pool) throws NotFoundException {
+ classPool = pool;
+ final String msg
+ = "javassist.tools.reflect.Sample is not found or broken.";
+ try {
+ CtClass c = classPool.get("javassist.tools.reflect.Sample");
+ trapMethod = c.getDeclaredMethod("trap");
+ trapStaticMethod = c.getDeclaredMethod("trapStatic");
+ trapRead = c.getDeclaredMethod("trapRead");
+ trapWrite = c.getDeclaredMethod("trapWrite");
+ readParam
+ = new CtClass[] { classPool.get("java.lang.Object") };
+ }
+ catch (NotFoundException e) {
+ throw new RuntimeException(msg);
+ }
+ }
+
+ /**
+ * Inserts hooks for intercepting accesses to the fields declared
+ * in reflective classes.
+ */
+ public void onLoad(ClassPool pool, String classname)
+ throws CannotCompileException, NotFoundException
+ {
+ CtClass clazz = pool.get(classname);
+ clazz.instrument(converter);
+ }
+
+ /**
+ * Produces a reflective class.
+ * If the super class is also made reflective, it must be done
+ * before the sub class.
+ *
+ * @param classname the name of the reflective class
+ * @param metaobject the class name of metaobjects.
+ * @param metaclass the class name of the class metaobject.
+ * @return <code>false</code> if the class is already reflective.
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.ClassMetaobject
+ */
+ public boolean makeReflective(String classname,
+ String metaobject, String metaclass)
+ throws CannotCompileException, NotFoundException
+ {
+ return makeReflective(classPool.get(classname),
+ classPool.get(metaobject),
+ classPool.get(metaclass));
+ }
+
+ /**
+ * Produces a reflective class.
+ * If the super class is also made reflective, it must be done
+ * before the sub class.
+ *
+ * @param clazz the reflective class.
+ * @param metaobject the class of metaobjects.
+ * It must be a subclass of
+ * <code>Metaobject</code>.
+ * @param metaclass the class of the class metaobject.
+ * It must be a subclass of
+ * <code>ClassMetaobject</code>.
+ * @return <code>false</code> if the class is already reflective.
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.ClassMetaobject
+ */
+ public boolean makeReflective(Class clazz,
+ Class metaobject, Class metaclass)
+ throws CannotCompileException, NotFoundException
+ {
+ return makeReflective(clazz.getName(), metaobject.getName(),
+ metaclass.getName());
+ }
+
+ /**
+ * Produces a reflective class. It modifies the given
+ * <code>CtClass</code> object and makes it reflective.
+ * If the super class is also made reflective, it must be done
+ * before the sub class.
+ *
+ * @param clazz the reflective class.
+ * @param metaobject the class of metaobjects.
+ * It must be a subclass of
+ * <code>Metaobject</code>.
+ * @param metaclass the class of the class metaobject.
+ * It must be a subclass of
+ * <code>ClassMetaobject</code>.
+ * @return <code>false</code> if the class is already reflective.
+ *
+ * @see javassist.tools.reflect.Metaobject
+ * @see javassist.tools.reflect.ClassMetaobject
+ */
+ public boolean makeReflective(CtClass clazz,
+ CtClass metaobject, CtClass metaclass)
+ throws CannotCompileException, CannotReflectException,
+ NotFoundException
+ {
+ if (clazz.isInterface())
+ throw new CannotReflectException(
+ "Cannot reflect an interface: " + clazz.getName());
+
+ if (clazz.subclassOf(classPool.get(classMetaobjectClassName)))
+ throw new CannotReflectException(
+ "Cannot reflect a subclass of ClassMetaobject: "
+ + clazz.getName());
+
+ if (clazz.subclassOf(classPool.get(metaobjectClassName)))
+ throw new CannotReflectException(
+ "Cannot reflect a subclass of Metaobject: "
+ + clazz.getName());
+
+ registerReflectiveClass(clazz);
+ return modifyClassfile(clazz, metaobject, metaclass);
+ }
+
+ /**
+ * Registers a reflective class. The field accesses to the instances
+ * of this class are instrumented.
+ */
+ private void registerReflectiveClass(CtClass clazz) {
+ CtField[] fs = clazz.getDeclaredFields();
+ for (int i = 0; i < fs.length; ++i) {
+ CtField f = fs[i];
+ int mod = f.getModifiers();
+ if ((mod & Modifier.PUBLIC) != 0 && (mod & Modifier.FINAL) == 0) {
+ String name = f.getName();
+ converter.replaceFieldRead(f, clazz, readPrefix + name);
+ converter.replaceFieldWrite(f, clazz, writePrefix + name);
+ }
+ }
+ }
+
+ private boolean modifyClassfile(CtClass clazz, CtClass metaobject,
+ CtClass metaclass)
+ throws CannotCompileException, NotFoundException
+ {
+ if (clazz.getAttribute("Reflective") != null)
+ return false; // this is already reflective.
+ else
+ clazz.setAttribute("Reflective", new byte[0]);
+
+ CtClass mlevel = classPool.get("javassist.tools.reflect.Metalevel");
+ boolean addMeta = !clazz.subtypeOf(mlevel);
+ if (addMeta)
+ clazz.addInterface(mlevel);
+
+ processMethods(clazz, addMeta);
+ processFields(clazz);
+
+ CtField f;
+ if (addMeta) {
+ f = new CtField(classPool.get("javassist.tools.reflect.Metaobject"),
+ metaobjectField, clazz);
+ f.setModifiers(Modifier.PROTECTED);
+ clazz.addField(f, CtField.Initializer.byNewWithParams(metaobject));
+
+ clazz.addMethod(CtNewMethod.getter(metaobjectGetter, f));
+ clazz.addMethod(CtNewMethod.setter(metaobjectSetter, f));
+ }
+
+ f = new CtField(classPool.get("javassist.tools.reflect.ClassMetaobject"),
+ classobjectField, clazz);
+ f.setModifiers(Modifier.PRIVATE | Modifier.STATIC);
+ clazz.addField(f, CtField.Initializer.byNew(metaclass,
+ new String[] { clazz.getName() }));
+
+ clazz.addMethod(CtNewMethod.getter(classobjectAccessor, f));
+ return true;
+ }
+
+ private void processMethods(CtClass clazz, boolean dontSearch)
+ throws CannotCompileException, NotFoundException
+ {
+ CtMethod[] ms = clazz.getMethods();
+ for (int i = 0; i < ms.length; ++i) {
+ CtMethod m = ms[i];
+ int mod = m.getModifiers();
+ if (Modifier.isPublic(mod) && !Modifier.isAbstract(mod))
+ processMethods0(mod, clazz, m, i, dontSearch);
+ }
+ }
+
+ private void processMethods0(int mod, CtClass clazz,
+ CtMethod m, int identifier, boolean dontSearch)
+ throws CannotCompileException, NotFoundException
+ {
+ CtMethod body;
+ String name = m.getName();
+
+ if (isExcluded(name)) // internally-used method inherited
+ return; // from a reflective class.
+
+ CtMethod m2;
+ if (m.getDeclaringClass() == clazz) {
+ if (Modifier.isNative(mod))
+ return;
+
+ m2 = m;
+ if (Modifier.isFinal(mod)) {
+ mod &= ~Modifier.FINAL;
+ m2.setModifiers(mod);
+ }
+ }
+ else {
+ if (Modifier.isFinal(mod))
+ return;
+
+ mod &= ~Modifier.NATIVE;
+ m2 = CtNewMethod.delegator(findOriginal(m, dontSearch), clazz);
+ m2.setModifiers(mod);
+ clazz.addMethod(m2);
+ }
+
+ m2.setName(ClassMetaobject.methodPrefix + identifier
+ + "_" + name);
+
+ if (Modifier.isStatic(mod))
+ body = trapStaticMethod;
+ else
+ body = trapMethod;
+
+ CtMethod wmethod
+ = CtNewMethod.wrapped(m.getReturnType(), name,
+ m.getParameterTypes(), m.getExceptionTypes(),
+ body, ConstParameter.integer(identifier),
+ clazz);
+ wmethod.setModifiers(mod);
+ clazz.addMethod(wmethod);
+ }
+
+ private CtMethod findOriginal(CtMethod m, boolean dontSearch)
+ throws NotFoundException
+ {
+ if (dontSearch)
+ return m;
+
+ String name = m.getName();
+ CtMethod[] ms = m.getDeclaringClass().getDeclaredMethods();
+ for (int i = 0; i < ms.length; ++i) {
+ String orgName = ms[i].getName();
+ if (orgName.endsWith(name)
+ && orgName.startsWith(ClassMetaobject.methodPrefix)
+ && ms[i].getSignature().equals(m.getSignature()))
+ return ms[i];
+ }
+
+ return m;
+ }
+
+ private void processFields(CtClass clazz)
+ throws CannotCompileException, NotFoundException
+ {
+ CtField[] fs = clazz.getDeclaredFields();
+ for (int i = 0; i < fs.length; ++i) {
+ CtField f = fs[i];
+ int mod = f.getModifiers();
+ if ((mod & Modifier.PUBLIC) != 0 && (mod & Modifier.FINAL) == 0) {
+ mod |= Modifier.STATIC;
+ String name = f.getName();
+ CtClass ftype = f.getType();
+ CtMethod wmethod
+ = CtNewMethod.wrapped(ftype, readPrefix + name,
+ readParam, null, trapRead,
+ ConstParameter.string(name),
+ clazz);
+ wmethod.setModifiers(mod);
+ clazz.addMethod(wmethod);
+ CtClass[] writeParam = new CtClass[2];
+ writeParam[0] = classPool.get("java.lang.Object");
+ writeParam[1] = ftype;
+ wmethod = CtNewMethod.wrapped(CtClass.voidType,
+ writePrefix + name,
+ writeParam, null, trapWrite,
+ ConstParameter.string(name), clazz);
+ wmethod.setModifiers(mod);
+ clazz.addMethod(wmethod);
+ }
+ }
+ }
+}
diff --git a/src/main/javassist/tools/reflect/Sample.java b/src/main/javassist/tools/reflect/Sample.java
new file mode 100644
index 0000000..d76df19
--- /dev/null
+++ b/src/main/javassist/tools/reflect/Sample.java
@@ -0,0 +1,56 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.reflect;
+
+/**
+ * A template used for defining a reflective class.
+ */
+public class Sample {
+ private Metaobject _metaobject;
+ private static ClassMetaobject _classobject;
+
+ public Object trap(Object[] args, int identifier) throws Throwable {
+ Metaobject mobj;
+ mobj = _metaobject;
+ if (mobj == null)
+ return ClassMetaobject.invoke(this, identifier, args);
+ else
+ return mobj.trapMethodcall(identifier, args);
+ }
+
+ public static Object trapStatic(Object[] args, int identifier)
+ throws Throwable
+ {
+ return _classobject.trapMethodcall(identifier, args);
+ }
+
+ public static Object trapRead(Object[] args, String name) {
+ if (args[0] == null)
+ return _classobject.trapFieldRead(name);
+ else
+ return ((Metalevel)args[0])._getMetaobject().trapFieldRead(name);
+ }
+
+ public static Object trapWrite(Object[] args, String name) {
+ Metalevel base = (Metalevel)args[0];
+ if (base == null)
+ _classobject.trapFieldWrite(name, args[1]);
+ else
+ base._getMetaobject().trapFieldWrite(name, args[1]);
+
+ return null;
+ }
+}
diff --git a/src/main/javassist/tools/reflect/package.html b/src/main/javassist/tools/reflect/package.html
new file mode 100644
index 0000000..10a4196
--- /dev/null
+++ b/src/main/javassist/tools/reflect/package.html
@@ -0,0 +1,35 @@
+<html>
+<body>
+Runtime Behavioral Reflection.
+
+<p>(also recently known as interceptors or AOP?)
+
+<p>This package enables a metaobject to trap method calls and field
+accesses on a regular Java object. It provides a class
+<code>Reflection</code>, which is a main module for implementing
+runtime behavioral reflection.
+It also provides
+a class <code>Loader</code> and <code>Compiler</code>
+as utilities for dynamically or statically
+translating a regular class into a reflective class.
+
+<p>An instance of the reflective class is associated with
+a runtime metaobject and a runtime class metaobject, which control
+the behavior of that instance.
+The runtime
+metaobject is created for every (base-level) instance but the
+runtime class metaobject is created for every (base-level) class.
+<code>Metaobject</code> is the root class of the runtime
+metaobject and <code>ClassMetaobject</code> is the root class
+of the runtime class metaobject.
+
+<p>This package is provided as a sample implementation of the
+reflection mechanism with Javassist. All the programs in this package
+uses only the regular Javassist API; they never call any hidden
+methods.
+
+<p>The most significant class in this package is <code>Reflection</code>.
+See the description of this class first.
+
+</body>
+</html>
diff --git a/src/main/javassist/tools/rmi/AppletServer.java b/src/main/javassist/tools/rmi/AppletServer.java
new file mode 100644
index 0000000..b2678f3
--- /dev/null
+++ b/src/main/javassist/tools/rmi/AppletServer.java
@@ -0,0 +1,250 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+import java.io.*;
+
+import javassist.tools.web.*;
+import javassist.CannotCompileException;
+import javassist.NotFoundException;
+import javassist.ClassPool;
+import java.lang.reflect.Method;
+import java.util.Hashtable;
+import java.util.Vector;
+
+/**
+ * An AppletServer object is a web server that an ObjectImporter
+ * communicates with. It makes the objects specified by
+ * <code>exportObject()</code> remotely accessible from applets.
+ * If the classes of the exported objects are requested by the client-side
+ * JVM, this web server sends proxy classes for the requested classes.
+ *
+ * @see javassist.tools.rmi.ObjectImporter
+ */
+public class AppletServer extends Webserver {
+ private StubGenerator stubGen;
+ private Hashtable exportedNames;
+ private Vector exportedObjects;
+
+ private static final byte[] okHeader
+ = "HTTP/1.0 200 OK\r\n\r\n".getBytes();
+
+ /**
+ * Constructs a web server.
+ *
+ * @param port port number
+ */
+ public AppletServer(String port)
+ throws IOException, NotFoundException, CannotCompileException
+ {
+ this(Integer.parseInt(port));
+ }
+
+ /**
+ * Constructs a web server.
+ *
+ * @param port port number
+ */
+ public AppletServer(int port)
+ throws IOException, NotFoundException, CannotCompileException
+ {
+ this(ClassPool.getDefault(), new StubGenerator(), port);
+ }
+
+ /**
+ * Constructs a web server.
+ *
+ * @param port port number
+ * @param src the source of classs files.
+ */
+ public AppletServer(int port, ClassPool src)
+ throws IOException, NotFoundException, CannotCompileException
+ {
+ this(new ClassPool(src), new StubGenerator(), port);
+ }
+
+ private AppletServer(ClassPool loader, StubGenerator gen, int port)
+ throws IOException, NotFoundException, CannotCompileException
+ {
+ super(port);
+ exportedNames = new Hashtable();
+ exportedObjects = new Vector();
+ stubGen = gen;
+ addTranslator(loader, gen);
+ }
+
+ /**
+ * Begins the HTTP service.
+ */
+ public void run() {
+ super.run();
+ }
+
+ /**
+ * Exports an object.
+ * This method produces the bytecode of the proxy class used
+ * to access the exported object. A remote applet can load
+ * the proxy class and call a method on the exported object.
+ *
+ * @param name the name used for looking the object up.
+ * @param obj the exported object.
+ * @return the object identifier
+ *
+ * @see javassist.tools.rmi.ObjectImporter#lookupObject(String)
+ */
+ public synchronized int exportObject(String name, Object obj)
+ throws CannotCompileException
+ {
+ Class clazz = obj.getClass();
+ ExportedObject eo = new ExportedObject();
+ eo.object = obj;
+ eo.methods = clazz.getMethods();
+ exportedObjects.addElement(eo);
+ eo.identifier = exportedObjects.size() - 1;
+ if (name != null)
+ exportedNames.put(name, eo);
+
+ try {
+ stubGen.makeProxyClass(clazz);
+ }
+ catch (NotFoundException e) {
+ throw new CannotCompileException(e);
+ }
+
+ return eo.identifier;
+ }
+
+ /**
+ * Processes a request from a web browser (an ObjectImporter).
+ */
+ public void doReply(InputStream in, OutputStream out, String cmd)
+ throws IOException, BadHttpRequest
+ {
+ if (cmd.startsWith("POST /rmi "))
+ processRMI(in, out);
+ else if (cmd.startsWith("POST /lookup "))
+ lookupName(cmd, in, out);
+ else
+ super.doReply(in, out, cmd);
+ }
+
+ private void processRMI(InputStream ins, OutputStream outs)
+ throws IOException
+ {
+ ObjectInputStream in = new ObjectInputStream(ins);
+
+ int objectId = in.readInt();
+ int methodId = in.readInt();
+ Exception err = null;
+ Object rvalue = null;
+ try {
+ ExportedObject eo
+ = (ExportedObject)exportedObjects.elementAt(objectId);
+ Object[] args = readParameters(in);
+ rvalue = convertRvalue(eo.methods[methodId].invoke(eo.object,
+ args));
+ }
+ catch(Exception e) {
+ err = e;
+ logging2(e.toString());
+ }
+
+ outs.write(okHeader);
+ ObjectOutputStream out = new ObjectOutputStream(outs);
+ if (err != null) {
+ out.writeBoolean(false);
+ out.writeUTF(err.toString());
+ }
+ else
+ try {
+ out.writeBoolean(true);
+ out.writeObject(rvalue);
+ }
+ catch (NotSerializableException e) {
+ logging2(e.toString());
+ }
+ catch (InvalidClassException e) {
+ logging2(e.toString());
+ }
+
+ out.flush();
+ out.close();
+ in.close();
+ }
+
+ private Object[] readParameters(ObjectInputStream in)
+ throws IOException, ClassNotFoundException
+ {
+ int n = in.readInt();
+ Object[] args = new Object[n];
+ for (int i = 0; i < n; ++i) {
+ Object a = in.readObject();
+ if (a instanceof RemoteRef) {
+ RemoteRef ref = (RemoteRef)a;
+ ExportedObject eo
+ = (ExportedObject)exportedObjects.elementAt(ref.oid);
+ a = eo.object;
+ }
+
+ args[i] = a;
+ }
+
+ return args;
+ }
+
+ private Object convertRvalue(Object rvalue)
+ throws CannotCompileException
+ {
+ if (rvalue == null)
+ return null; // the return type is void.
+
+ String classname = rvalue.getClass().getName();
+ if (stubGen.isProxyClass(classname))
+ return new RemoteRef(exportObject(null, rvalue), classname);
+ else
+ return rvalue;
+ }
+
+ private void lookupName(String cmd, InputStream ins, OutputStream outs)
+ throws IOException
+ {
+ ObjectInputStream in = new ObjectInputStream(ins);
+ String name = DataInputStream.readUTF(in);
+ ExportedObject found = (ExportedObject)exportedNames.get(name);
+ outs.write(okHeader);
+ ObjectOutputStream out = new ObjectOutputStream(outs);
+ if (found == null) {
+ logging2(name + "not found.");
+ out.writeInt(-1); // error code
+ out.writeUTF("error");
+ }
+ else {
+ logging2(name);
+ out.writeInt(found.identifier);
+ out.writeUTF(found.object.getClass().getName());
+ }
+
+ out.flush();
+ out.close();
+ in.close();
+ }
+}
+
+class ExportedObject {
+ public int identifier;
+ public Object object;
+ public Method[] methods;
+}
diff --git a/src/main/javassist/tools/rmi/ObjectImporter.java b/src/main/javassist/tools/rmi/ObjectImporter.java
new file mode 100644
index 0000000..e6692ef
--- /dev/null
+++ b/src/main/javassist/tools/rmi/ObjectImporter.java
@@ -0,0 +1,298 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+import java.io.*;
+import java.net.*;
+import java.applet.Applet;
+import java.lang.reflect.*;
+
+/**
+ * The object importer enables applets to call a method on a remote
+ * object running on the <code>Webserver</code> (the <b>main</b> class of this
+ * package).
+ *
+ * <p>To access the remote
+ * object, the applet first calls <code>lookupObject()</code> and
+ * obtains a proxy object, which is a reference to that object.
+ * The class name of the proxy object is identical to that of
+ * the remote object.
+ * The proxy object provides the same set of methods as the remote object.
+ * If one of the methods is invoked on the proxy object,
+ * the invocation is delegated to the remote object.
+ * From the viewpoint of the applet, therefore, the two objects are
+ * identical. The applet can access the object on the server
+ * with the regular Java syntax without concern about the actual
+ * location.
+ *
+ * <p>The methods remotely called by the applet must be <code>public</code>.
+ * This is true even if the applet's class and the remote object's classs
+ * belong to the same package.
+ *
+ * <p>If class X is a class of remote objects, a subclass of X must be
+ * also a class of remote objects. On the other hand, this restriction
+ * is not applied to the superclass of X. The class X does not have to
+ * contain a constructor taking no arguments.
+ *
+ * <p>The parameters to a remote method is passed in the <i>call-by-value</i>
+ * manner. Thus all the parameter classes must implement
+ * <code>java.io.Serializable</code>. However, if the parameter is the
+ * proxy object, the reference to the remote object instead of a copy of
+ * the object is passed to the method.
+ *
+ * <p>Because of the limitations of the current implementation,
+ * <ul>
+ * <li>The parameter objects cannot contain the proxy
+ * object as a field value.
+ * <li>If class <code>C</code> is of the remote object, then
+ * the applet cannot instantiate <code>C</code> locally or remotely.
+ * </ul>
+ *
+ * <p>All the exceptions thrown by the remote object are converted
+ * into <code>RemoteException</code>. Since this exception is a subclass
+ * of <code>RuntimeException</code>, the caller method does not need
+ * to catch the exception. However, good programs should catch
+ * the <code>RuntimeException</code>.
+ *
+ * @see javassist.tools.rmi.AppletServer
+ * @see javassist.tools.rmi.RemoteException
+ * @see javassist.tools.web.Viewer
+ */
+public class ObjectImporter implements java.io.Serializable {
+ private final byte[] endofline = { 0x0d, 0x0a };
+ private String servername, orgServername;
+ private int port, orgPort;
+
+ protected byte[] lookupCommand = "POST /lookup HTTP/1.0".getBytes();
+ protected byte[] rmiCommand = "POST /rmi HTTP/1.0".getBytes();
+
+ /**
+ * Constructs an object importer.
+ *
+ * <p>Remote objects are imported from the web server that the given
+ * applet has been loaded from.
+ *
+ * @param applet the applet loaded from the <code>Webserver</code>.
+ */
+ public ObjectImporter(Applet applet) {
+ URL codebase = applet.getCodeBase();
+ orgServername = servername = codebase.getHost();
+ orgPort = port = codebase.getPort();
+ }
+
+ /**
+ * Constructs an object importer.
+ *
+ * <p>If you run a program with <code>javassist.tools.web.Viewer</code>,
+ * you can construct an object importer as follows:
+ *
+ * <ul><pre>
+ * Viewer v = (Viewer)this.getClass().getClassLoader();
+ * ObjectImporter oi = new ObjectImporter(v.getServer(), v.getPort());
+ * </pre></ul>
+ *
+ * @see javassist.tools.web.Viewer
+ */
+ public ObjectImporter(String servername, int port) {
+ this.orgServername = this.servername = servername;
+ this.orgPort = this.port = port;
+ }
+
+ /**
+ * Finds the object exported by a server with the specified name.
+ * If the object is not found, this method returns null.
+ *
+ * @param name the name of the exported object.
+ * @return the proxy object or null.
+ */
+ public Object getObject(String name) {
+ try {
+ return lookupObject(name);
+ }
+ catch (ObjectNotFoundException e) {
+ return null;
+ }
+ }
+
+ /**
+ * Sets an http proxy server. After this method is called, the object
+ * importer connects a server through the http proxy server.
+ */
+ public void setHttpProxy(String host, int port) {
+ String proxyHeader = "POST http://" + orgServername + ":" + orgPort;
+ String cmd = proxyHeader + "/lookup HTTP/1.0";
+ lookupCommand = cmd.getBytes();
+ cmd = proxyHeader + "/rmi HTTP/1.0";
+ rmiCommand = cmd.getBytes();
+ this.servername = host;
+ this.port = port;
+ }
+
+ /**
+ * Finds the object exported by the server with the specified name.
+ * It sends a POST request to the server (via an http proxy server
+ * if needed).
+ *
+ * @param name the name of the exported object.
+ * @return the proxy object.
+ */
+ public Object lookupObject(String name) throws ObjectNotFoundException
+ {
+ try {
+ Socket sock = new Socket(servername, port);
+ OutputStream out = sock.getOutputStream();
+ out.write(lookupCommand);
+ out.write(endofline);
+ out.write(endofline);
+
+ ObjectOutputStream dout = new ObjectOutputStream(out);
+ dout.writeUTF(name);
+ dout.flush();
+
+ InputStream in = new BufferedInputStream(sock.getInputStream());
+ skipHeader(in);
+ ObjectInputStream din = new ObjectInputStream(in);
+ int n = din.readInt();
+ String classname = din.readUTF();
+ din.close();
+ dout.close();
+ sock.close();
+
+ if (n >= 0)
+ return createProxy(n, classname);
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ throw new ObjectNotFoundException(name, e);
+ }
+
+ throw new ObjectNotFoundException(name);
+ }
+
+ private static final Class[] proxyConstructorParamTypes
+ = new Class[] { ObjectImporter.class, int.class };
+
+ private Object createProxy(int oid, String classname) throws Exception {
+ Class c = Class.forName(classname);
+ Constructor cons = c.getConstructor(proxyConstructorParamTypes);
+ return cons.newInstance(new Object[] { this, new Integer(oid) });
+ }
+
+ /**
+ * Calls a method on a remote object.
+ * It sends a POST request to the server (via an http proxy server
+ * if needed).
+ *
+ * <p>This method is called by only proxy objects.
+ */
+ public Object call(int objectid, int methodid, Object[] args)
+ throws RemoteException
+ {
+ boolean result;
+ Object rvalue;
+ String errmsg;
+
+ try {
+ /* This method establishes a raw tcp connection for sending
+ * a POST message. Thus the object cannot communicate a
+ * remote object beyond a fire wall. To avoid this problem,
+ * the connection should be established with a mechanism
+ * collaborating a proxy server. Unfortunately, java.lang.URL
+ * does not seem to provide such a mechanism.
+ *
+ * You might think that using HttpURLConnection is a better
+ * way than constructing a raw tcp connection. Unfortunately,
+ * URL.openConnection() does not return an HttpURLConnection
+ * object in Netscape's JVM. It returns a
+ * netscape.net.URLConnection object.
+ *
+ * lookupObject() has the same problem.
+ */
+ Socket sock = new Socket(servername, port);
+ OutputStream out = new BufferedOutputStream(
+ sock.getOutputStream());
+ out.write(rmiCommand);
+ out.write(endofline);
+ out.write(endofline);
+
+ ObjectOutputStream dout = new ObjectOutputStream(out);
+ dout.writeInt(objectid);
+ dout.writeInt(methodid);
+ writeParameters(dout, args);
+ dout.flush();
+
+ InputStream ins = new BufferedInputStream(sock.getInputStream());
+ skipHeader(ins);
+ ObjectInputStream din = new ObjectInputStream(ins);
+ result = din.readBoolean();
+ rvalue = null;
+ errmsg = null;
+ if (result)
+ rvalue = din.readObject();
+ else
+ errmsg = din.readUTF();
+
+ din.close();
+ dout.close();
+ sock.close();
+
+ if (rvalue instanceof RemoteRef) {
+ RemoteRef ref = (RemoteRef)rvalue;
+ rvalue = createProxy(ref.oid, ref.classname);
+ }
+ }
+ catch (ClassNotFoundException e) {
+ throw new RemoteException(e);
+ }
+ catch (IOException e) {
+ throw new RemoteException(e);
+ }
+ catch (Exception e) {
+ throw new RemoteException(e);
+ }
+
+ if (result)
+ return rvalue;
+ else
+ throw new RemoteException(errmsg);
+ }
+
+ private void skipHeader(InputStream in) throws IOException {
+ int len;
+ do {
+ int c;
+ len = 0;
+ while ((c = in.read()) >= 0 && c != 0x0d)
+ ++len;
+
+ in.read(); /* skip 0x0a (LF) */
+ } while (len > 0);
+ }
+
+ private void writeParameters(ObjectOutputStream dout, Object[] params)
+ throws IOException
+ {
+ int n = params.length;
+ dout.writeInt(n);
+ for (int i = 0; i < n; ++i)
+ if (params[i] instanceof Proxy) {
+ Proxy p = (Proxy)params[i];
+ dout.writeObject(new RemoteRef(p._getObjectId()));
+ }
+ else
+ dout.writeObject(params[i]);
+ }
+}
diff --git a/src/main/javassist/tools/rmi/ObjectNotFoundException.java b/src/main/javassist/tools/rmi/ObjectNotFoundException.java
new file mode 100644
index 0000000..8ec3a46
--- /dev/null
+++ b/src/main/javassist/tools/rmi/ObjectNotFoundException.java
@@ -0,0 +1,26 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+public class ObjectNotFoundException extends Exception {
+ public ObjectNotFoundException(String name) {
+ super(name + " is not exported");
+ }
+
+ public ObjectNotFoundException(String name, Exception e) {
+ super(name + " because of " + e.toString());
+ }
+}
diff --git a/src/main/javassist/tools/rmi/Proxy.java b/src/main/javassist/tools/rmi/Proxy.java
new file mode 100644
index 0000000..5ea8a70
--- /dev/null
+++ b/src/main/javassist/tools/rmi/Proxy.java
@@ -0,0 +1,25 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+/**
+ * An interface implemented by proxy classes.
+ *
+ * @see javassist.tools.rmi.StubGenerator
+ */
+public interface Proxy {
+ int _getObjectId();
+}
diff --git a/src/main/javassist/tools/rmi/RemoteException.java b/src/main/javassist/tools/rmi/RemoteException.java
new file mode 100644
index 0000000..19a107f
--- /dev/null
+++ b/src/main/javassist/tools/rmi/RemoteException.java
@@ -0,0 +1,30 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+/**
+ * <code>RemoteException</code> represents any exception thrown
+ * during remote method invocation.
+ */
+public class RemoteException extends RuntimeException {
+ public RemoteException(String msg) {
+ super(msg);
+ }
+
+ public RemoteException(Exception e) {
+ super("by " + e.toString());
+ }
+}
diff --git a/src/main/javassist/tools/rmi/RemoteRef.java b/src/main/javassist/tools/rmi/RemoteRef.java
new file mode 100644
index 0000000..fb1c2e1
--- /dev/null
+++ b/src/main/javassist/tools/rmi/RemoteRef.java
@@ -0,0 +1,35 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+/**
+ * Remote reference. This class is internally used for sending a remote
+ * reference through a network stream.
+ */
+public class RemoteRef implements java.io.Serializable {
+ public int oid;
+ public String classname;
+
+ public RemoteRef(int i) {
+ oid = i;
+ classname = null;
+ }
+
+ public RemoteRef(int i, String name) {
+ oid = i;
+ classname = name;
+ }
+}
diff --git a/src/main/javassist/tools/rmi/Sample.java b/src/main/javassist/tools/rmi/Sample.java
new file mode 100644
index 0000000..12c799b
--- /dev/null
+++ b/src/main/javassist/tools/rmi/Sample.java
@@ -0,0 +1,36 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+/**
+ * A template used for defining a proxy class.
+ * The class file of this class is read by the <code>StubGenerator</code>
+ * class.
+ */
+public class Sample {
+ private ObjectImporter importer;
+ private int objectId;
+
+ public Object forward(Object[] args, int identifier) {
+ return importer.call(objectId, identifier, args);
+ }
+
+ public static Object forwardStatic(Object[] args, int identifier)
+ throws RemoteException
+ {
+ throw new RemoteException("cannot call a static method.");
+ }
+}
diff --git a/src/main/javassist/tools/rmi/StubGenerator.java b/src/main/javassist/tools/rmi/StubGenerator.java
new file mode 100644
index 0000000..8b6604a
--- /dev/null
+++ b/src/main/javassist/tools/rmi/StubGenerator.java
@@ -0,0 +1,255 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.rmi;
+
+import javassist.*;
+import java.lang.reflect.Method;
+import java.util.Hashtable;
+import javassist.CtMethod.ConstParameter;
+
+/**
+ * A stub-code generator. It is used for producing a proxy class.
+ *
+ * <p>The proxy class for class A is as follows:
+ *
+ * <ul><pre>public class A implements Proxy, Serializable {
+ * private ObjectImporter importer;
+ * private int objectId;
+ * public int _getObjectId() { return objectId; }
+ * public A(ObjectImporter oi, int id) {
+ * importer = oi; objectId = id;
+ * }
+ *
+ * ... the same methods that the original class A declares ...
+ * }</pre></ul>
+ *
+ * <p>Instances of the proxy class is created by an
+ * <code>ObjectImporter</code> object.
+ */
+public class StubGenerator implements Translator {
+ private static final String fieldImporter = "importer";
+ private static final String fieldObjectId = "objectId";
+ private static final String accessorObjectId = "_getObjectId";
+ private static final String sampleClass = "javassist.tools.rmi.Sample";
+
+ private ClassPool classPool;
+ private Hashtable proxyClasses;
+ private CtMethod forwardMethod;
+ private CtMethod forwardStaticMethod;
+
+ private CtClass[] proxyConstructorParamTypes;
+ private CtClass[] interfacesForProxy;
+ private CtClass[] exceptionForProxy;
+
+ /**
+ * Constructs a stub-code generator.
+ */
+ public StubGenerator() {
+ proxyClasses = new Hashtable();
+ }
+
+ /**
+ * Initializes the object.
+ * This is a method declared in javassist.Translator.
+ *
+ * @see javassist.Translator#start(ClassPool)
+ */
+ public void start(ClassPool pool) throws NotFoundException {
+ classPool = pool;
+ CtClass c = pool.get(sampleClass);
+ forwardMethod = c.getDeclaredMethod("forward");
+ forwardStaticMethod = c.getDeclaredMethod("forwardStatic");
+
+ proxyConstructorParamTypes
+ = pool.get(new String[] { "javassist.tools.rmi.ObjectImporter",
+ "int" });
+ interfacesForProxy
+ = pool.get(new String[] { "java.io.Serializable",
+ "javassist.tools.rmi.Proxy" });
+ exceptionForProxy
+ = new CtClass[] { pool.get("javassist.tools.rmi.RemoteException") };
+ }
+
+ /**
+ * Does nothing.
+ * This is a method declared in javassist.Translator.
+ * @see javassist.Translator#onLoad(ClassPool,String)
+ */
+ public void onLoad(ClassPool pool, String classname) {}
+
+ /**
+ * Returns <code>true</code> if the specified class is a proxy class
+ * recorded by <code>makeProxyClass()</code>.
+ *
+ * @param name a fully-qualified class name
+ */
+ public boolean isProxyClass(String name) {
+ return proxyClasses.get(name) != null;
+ }
+
+ /**
+ * Makes a proxy class. The produced class is substituted
+ * for the original class.
+ *
+ * @param clazz the class referenced
+ * through the proxy class.
+ * @return <code>false</code> if the proxy class
+ * has been already produced.
+ */
+ public synchronized boolean makeProxyClass(Class clazz)
+ throws CannotCompileException, NotFoundException
+ {
+ String classname = clazz.getName();
+ if (proxyClasses.get(classname) != null)
+ return false;
+ else {
+ CtClass ctclazz = produceProxyClass(classPool.get(classname),
+ clazz);
+ proxyClasses.put(classname, ctclazz);
+ modifySuperclass(ctclazz);
+ return true;
+ }
+ }
+
+ private CtClass produceProxyClass(CtClass orgclass, Class orgRtClass)
+ throws CannotCompileException, NotFoundException
+ {
+ int modify = orgclass.getModifiers();
+ if (Modifier.isAbstract(modify) || Modifier.isNative(modify)
+ || !Modifier.isPublic(modify))
+ throw new CannotCompileException(orgclass.getName()
+ + " must be public, non-native, and non-abstract.");
+
+ CtClass proxy = classPool.makeClass(orgclass.getName(),
+ orgclass.getSuperclass());
+
+ proxy.setInterfaces(interfacesForProxy);
+
+ CtField f
+ = new CtField(classPool.get("javassist.tools.rmi.ObjectImporter"),
+ fieldImporter, proxy);
+ f.setModifiers(Modifier.PRIVATE);
+ proxy.addField(f, CtField.Initializer.byParameter(0));
+
+ f = new CtField(CtClass.intType, fieldObjectId, proxy);
+ f.setModifiers(Modifier.PRIVATE);
+ proxy.addField(f, CtField.Initializer.byParameter(1));
+
+ proxy.addMethod(CtNewMethod.getter(accessorObjectId, f));
+
+ proxy.addConstructor(CtNewConstructor.defaultConstructor(proxy));
+ CtConstructor cons
+ = CtNewConstructor.skeleton(proxyConstructorParamTypes,
+ null, proxy);
+ proxy.addConstructor(cons);
+
+ try {
+ addMethods(proxy, orgRtClass.getMethods());
+ return proxy;
+ }
+ catch (SecurityException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private CtClass toCtClass(Class rtclass) throws NotFoundException {
+ String name;
+ if (!rtclass.isArray())
+ name = rtclass.getName();
+ else {
+ StringBuffer sbuf = new StringBuffer();
+ do {
+ sbuf.append("[]");
+ rtclass = rtclass.getComponentType();
+ } while(rtclass.isArray());
+ sbuf.insert(0, rtclass.getName());
+ name = sbuf.toString();
+ }
+
+ return classPool.get(name);
+ }
+
+ private CtClass[] toCtClass(Class[] rtclasses) throws NotFoundException {
+ int n = rtclasses.length;
+ CtClass[] ctclasses = new CtClass[n];
+ for (int i = 0; i < n; ++i)
+ ctclasses[i] = toCtClass(rtclasses[i]);
+
+ return ctclasses;
+ }
+
+ /* ms must not be an array of CtMethod. To invoke a method ms[i]
+ * on a server, a client must send i to the server.
+ */
+ private void addMethods(CtClass proxy, Method[] ms)
+ throws CannotCompileException, NotFoundException
+ {
+ CtMethod wmethod;
+ for (int i = 0; i < ms.length; ++i) {
+ Method m = ms[i];
+ int mod = m.getModifiers();
+ if (m.getDeclaringClass() != Object.class
+ && !Modifier.isFinal(mod))
+ if (Modifier.isPublic(mod)) {
+ CtMethod body;
+ if (Modifier.isStatic(mod))
+ body = forwardStaticMethod;
+ else
+ body = forwardMethod;
+
+ wmethod
+ = CtNewMethod.wrapped(toCtClass(m.getReturnType()),
+ m.getName(),
+ toCtClass(m.getParameterTypes()),
+ exceptionForProxy,
+ body,
+ ConstParameter.integer(i),
+ proxy);
+ wmethod.setModifiers(mod);
+ proxy.addMethod(wmethod);
+ }
+ else if (!Modifier.isProtected(mod)
+ && !Modifier.isPrivate(mod))
+ // if package method
+ throw new CannotCompileException(
+ "the methods must be public, protected, or private.");
+ }
+ }
+
+ /**
+ * Adds a default constructor to the super classes.
+ */
+ private void modifySuperclass(CtClass orgclass)
+ throws CannotCompileException, NotFoundException
+ {
+ CtClass superclazz;
+ for (;; orgclass = superclazz) {
+ superclazz = orgclass.getSuperclass();
+ if (superclazz == null)
+ break;
+
+ try {
+ superclazz.getDeclaredConstructor(null);
+ break; // the constructor with no arguments is found.
+ }
+ catch (NotFoundException e) {
+ }
+
+ superclazz.addConstructor(
+ CtNewConstructor.defaultConstructor(superclazz));
+ }
+ }
+}
diff --git a/src/main/javassist/tools/rmi/package.html b/src/main/javassist/tools/rmi/package.html
new file mode 100644
index 0000000..5432a94
--- /dev/null
+++ b/src/main/javassist/tools/rmi/package.html
@@ -0,0 +1,16 @@
+<html>
+<body>
+Sample implementation of remote method invocation.
+
+<p>This package enables applets to access remote objects
+running on the web server with regular Java syntax.
+It is provided as a sample implementation with Javassist.
+All the programs in this package uses only the regular
+Javassist API; they never call any hidden methods.
+
+<p>The most significant class of this package is
+<code>ObjectImporter</code>.
+See the description of this class first.
+
+</body>
+</html>
diff --git a/src/main/javassist/tools/web/BadHttpRequest.java b/src/main/javassist/tools/web/BadHttpRequest.java
new file mode 100644
index 0000000..0010203
--- /dev/null
+++ b/src/main/javassist/tools/web/BadHttpRequest.java
@@ -0,0 +1,34 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.web;
+
+/**
+ * Thrown when receiving an invalid HTTP request.
+ */
+public class BadHttpRequest extends Exception {
+ private Exception e;
+
+ public BadHttpRequest() { e = null; }
+
+ public BadHttpRequest(Exception _e) { e = _e; }
+
+ public String toString() {
+ if (e == null)
+ return super.toString();
+ else
+ return e.toString();
+ }
+}
diff --git a/src/main/javassist/tools/web/Viewer.java b/src/main/javassist/tools/web/Viewer.java
new file mode 100644
index 0000000..de7afae
--- /dev/null
+++ b/src/main/javassist/tools/web/Viewer.java
@@ -0,0 +1,208 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.web;
+
+import java.io.*;
+import java.net.*;
+
+/**
+ * A sample applet viewer.
+ *
+ * <p>This is a sort of applet viewer that can run any program even if
+ * the main class is not a subclass of <code>Applet</code>.
+ * This viewwer first calls <code>main()</code> in the main class.
+ *
+ * <p>To run, you should type:
+ *
+ * <ul><code>% java javassist.tools.web.Viewer <i>host port</i> Main arg1, ...</code></ul>
+ *
+ * <p>This command calls <code>Main.main()</code> with <code>arg1,...</code>
+ * All classes including <code>Main</code> are fetched from
+ * a server http://<i>host</i>:<i>port</i>.
+ * Only the class file for <code>Viewer</code> must exist
+ * on a local file system at the client side; even other
+ * <code>javassist.*</code> classes are not needed at the client side.
+ * <code>Viewer</code> uses only Java core API classes.
+ *
+ * <p>Note: since a <code>Viewer</code> object is a class loader,
+ * a program loaded by this object can call a method in <code>Viewer</code>.
+ * For example, you can write something like this:
+ *
+ * <ul><pre>
+ * Viewer v = (Viewer)this.getClass().getClassLoader();
+ * String port = v.getPort();
+ * </pre></ul>
+ *
+ */
+public class Viewer extends ClassLoader {
+ private String server;
+ private int port;
+
+ /**
+ * Starts a program.
+ */
+ public static void main(String[] args) throws Throwable {
+ if (args.length >= 3) {
+ Viewer cl = new Viewer(args[0], Integer.parseInt(args[1]));
+ String[] args2 = new String[args.length - 3];
+ System.arraycopy(args, 3, args2, 0, args.length - 3);
+ cl.run(args[2], args2);
+ }
+ else
+ System.err.println(
+ "Usage: java javassist.tools.web.Viewer <host> <port> class [args ...]");
+ }
+
+ /**
+ * Constructs a viewer.
+ *
+ * @param host server name
+ * @param p port number
+ */
+ public Viewer(String host, int p) {
+ server = host;
+ port = p;
+ }
+
+ /**
+ * Returns the server name.
+ */
+ public String getServer() { return server; }
+
+ /**
+ * Returns the port number.
+ */
+ public int getPort() { return port; }
+
+ /**
+ * Invokes main() in the class specified by <code>classname</code>.
+ *
+ * @param classname executed class
+ * @param args the arguments passed to <code>main()</code>.
+ */
+ public void run(String classname, String[] args)
+ throws Throwable
+ {
+ Class c = loadClass(classname);
+ try {
+ c.getDeclaredMethod("main", new Class[] { String[].class })
+ .invoke(null, new Object[] { args });
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+ }
+
+ /**
+ * Requests the class loader to load a class.
+ */
+ protected synchronized Class loadClass(String name, boolean resolve)
+ throws ClassNotFoundException
+ {
+ Class c = findLoadedClass(name);
+ if (c == null)
+ c = findClass(name);
+
+ if (c == null)
+ throw new ClassNotFoundException(name);
+
+ if (resolve)
+ resolveClass(c);
+
+ return c;
+ }
+
+ /**
+ * Finds the specified class. The implementation in this class
+ * fetches the class from the http server. If the class is
+ * either <code>java.*</code>, <code>javax.*</code>, or
+ * <code>Viewer</code>, then it is loaded by the parent class
+ * loader.
+ *
+ * <p>This method can be overridden by a subclass of
+ * <code>Viewer</code>.
+ */
+ protected Class findClass(String name) throws ClassNotFoundException {
+ Class c = null;
+ if (name.startsWith("java.") || name.startsWith("javax.")
+ || name.equals("javassist.tools.web.Viewer"))
+ c = findSystemClass(name);
+
+ if (c == null)
+ try {
+ byte[] b = fetchClass(name);
+ if (b != null)
+ c = defineClass(name, b, 0, b.length);
+ }
+ catch (Exception e) {
+ }
+
+ return c;
+ }
+
+ /**
+ * Fetches the class file of the specified class from the http
+ * server.
+ */
+ protected byte[] fetchClass(String classname) throws Exception
+ {
+ byte[] b;
+ URL url = new URL("http", server, port,
+ "/" + classname.replace('.', '/') + ".class");
+ URLConnection con = url.openConnection();
+ con.connect();
+ int size = con.getContentLength();
+ InputStream s = con.getInputStream();
+ if (size <= 0)
+ b = readStream(s);
+ else {
+ b = new byte[size];
+ int len = 0;
+ do {
+ int n = s.read(b, len, size - len);
+ if (n < 0) {
+ s.close();
+ throw new IOException("the stream was closed: "
+ + classname);
+ }
+ len += n;
+ } while (len < size);
+ }
+
+ s.close();
+ return b;
+ }
+
+ private byte[] readStream(InputStream fin) throws IOException {
+ byte[] buf = new byte[4096];
+ int size = 0;
+ int len = 0;
+ do {
+ size += len;
+ if (buf.length - size <= 0) {
+ byte[] newbuf = new byte[buf.length * 2];
+ System.arraycopy(buf, 0, newbuf, 0, size);
+ buf = newbuf;
+ }
+
+ len = fin.read(buf, size, buf.length - size);
+ } while (len >= 0);
+
+ byte[] result = new byte[size];
+ System.arraycopy(buf, 0, result, 0, size);
+ return result;
+ }
+}
diff --git a/src/main/javassist/tools/web/Webserver.java b/src/main/javassist/tools/web/Webserver.java
new file mode 100644
index 0000000..952d56d
--- /dev/null
+++ b/src/main/javassist/tools/web/Webserver.java
@@ -0,0 +1,407 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.tools.web;
+
+import java.net.*;
+import java.io.*;
+import java.util.Date;
+import javassist.*;
+
+/**
+ * A web server for running sample programs.
+ *
+ * <p>This enables a Java program to instrument class files loaded by
+ * web browsers for applets. Since the (standard) security manager
+ * does not allow an applet to create and use a class loader,
+ * instrumenting class files must be done by this web server.
+ *
+ * <p><b>Note:</b> although this class is included in the Javassist API,
+ * it is provided as a sample implementation of the web server using
+ * Javassist. Especially, there might be security flaws in this server.
+ * Please use this with YOUR OWN RISK.
+ */
+public class Webserver {
+ private ServerSocket socket;
+ private ClassPool classPool;
+ protected Translator translator;
+
+ private final static byte[] endofline = { 0x0d, 0x0a };
+
+ private final static int typeHtml = 1;
+ private final static int typeClass = 2;
+ private final static int typeGif = 3;
+ private final static int typeJpeg = 4;
+ private final static int typeText = 5;
+
+ /**
+ * If this field is not null, the class files taken from
+ * <code>ClassPool</code> are written out under the directory
+ * specified by this field. The directory name must not end
+ * with a directory separator.
+ */
+ public String debugDir = null;
+
+ /**
+ * The top directory of html (and .gif, .class, ...) files.
+ * It must end with the directory separator such as "/".
+ * (For portability, "/" should be used as the directory separator.
+ * Javassist automatically translates "/" into a platform-dependent
+ * character.)
+ * If this field is null, the top directory is the current one where
+ * the JVM is running.
+ *
+ * <p>If the given URL indicates a class file and the class file
+ * is not found under the directory specified by this variable,
+ * then <code>Class.getResourceAsStream()</code> is called
+ * for searching the Java class paths.
+ */
+ public String htmlfileBase = null;
+
+ /**
+ * Starts a web server.
+ * The port number is specified by the first argument.
+ */
+ public static void main(String[] args) throws IOException {
+ if (args.length == 1) {
+ Webserver web = new Webserver(args[0]);
+ web.run();
+ }
+ else
+ System.err.println(
+ "Usage: java javassist.tools.web.Webserver <port number>");
+ }
+
+ /**
+ * Constructs a web server.
+ *
+ * @param port port number
+ */
+ public Webserver(String port) throws IOException {
+ this(Integer.parseInt(port));
+ }
+
+ /**
+ * Constructs a web server.
+ *
+ * @param port port number
+ */
+ public Webserver(int port) throws IOException {
+ socket = new ServerSocket(port);
+ classPool = null;
+ translator = null;
+ }
+
+ /**
+ * Requests the web server to use the specified
+ * <code>ClassPool</code> object for obtaining a class file.
+ */
+ public void setClassPool(ClassPool loader) {
+ classPool = loader;
+ }
+
+ /**
+ * Adds a translator, which is called whenever a client requests
+ * a class file.
+ *
+ * @param cp the <code>ClassPool</code> object for obtaining
+ * a class file.
+ * @param t a translator.
+ */
+ public void addTranslator(ClassPool cp, Translator t)
+ throws NotFoundException, CannotCompileException
+ {
+ classPool = cp;
+ translator = t;
+ t.start(classPool);
+ }
+
+ /**
+ * Closes the socket.
+ */
+ public void end() throws IOException {
+ socket.close();
+ }
+
+ /**
+ * Prints a log message.
+ */
+ public void logging(String msg) {
+ System.out.println(msg);
+ }
+
+ /**
+ * Prints a log message.
+ */
+ public void logging(String msg1, String msg2) {
+ System.out.print(msg1);
+ System.out.print(" ");
+ System.out.println(msg2);
+ }
+
+ /**
+ * Prints a log message.
+ */
+ public void logging(String msg1, String msg2, String msg3) {
+ System.out.print(msg1);
+ System.out.print(" ");
+ System.out.print(msg2);
+ System.out.print(" ");
+ System.out.println(msg3);
+ }
+
+ /**
+ * Prints a log message with indentation.
+ */
+ public void logging2(String msg) {
+ System.out.print(" ");
+ System.out.println(msg);
+ }
+
+ /**
+ * Begins the HTTP service.
+ */
+ public void run() {
+ System.err.println("ready to service...");
+ for (;;)
+ try {
+ ServiceThread th = new ServiceThread(this, socket.accept());
+ th.start();
+ }
+ catch (IOException e) {
+ logging(e.toString());
+ }
+ }
+
+ final void process(Socket clnt) throws IOException {
+ InputStream in = new BufferedInputStream(clnt.getInputStream());
+ String cmd = readLine(in);
+ logging(clnt.getInetAddress().getHostName(),
+ new Date().toString(), cmd);
+ while (skipLine(in) > 0){
+ }
+
+ OutputStream out = new BufferedOutputStream(clnt.getOutputStream());
+ try {
+ doReply(in, out, cmd);
+ }
+ catch (BadHttpRequest e) {
+ replyError(out, e);
+ }
+
+ out.flush();
+ in.close();
+ out.close();
+ clnt.close();
+ }
+
+ private String readLine(InputStream in) throws IOException {
+ StringBuffer buf = new StringBuffer();
+ int c;
+ while ((c = in.read()) >= 0 && c != 0x0d)
+ buf.append((char)c);
+
+ in.read(); /* skip 0x0a (LF) */
+ return buf.toString();
+ }
+
+ private int skipLine(InputStream in) throws IOException {
+ int c;
+ int len = 0;
+ while ((c = in.read()) >= 0 && c != 0x0d)
+ ++len;
+
+ in.read(); /* skip 0x0a (LF) */
+ return len;
+ }
+
+ /**
+ * Proceses a HTTP request from a client.
+ *
+ * @param out the output stream to a client
+ * @param cmd the command received from a client
+ */
+ public void doReply(InputStream in, OutputStream out, String cmd)
+ throws IOException, BadHttpRequest
+ {
+ int len;
+ int fileType;
+ String filename, urlName;
+
+ if (cmd.startsWith("GET /"))
+ filename = urlName = cmd.substring(5, cmd.indexOf(' ', 5));
+ else
+ throw new BadHttpRequest();
+
+ if (filename.endsWith(".class"))
+ fileType = typeClass;
+ else if (filename.endsWith(".html") || filename.endsWith(".htm"))
+ fileType = typeHtml;
+ else if (filename.endsWith(".gif"))
+ fileType = typeGif;
+ else if (filename.endsWith(".jpg"))
+ fileType = typeJpeg;
+ else
+ fileType = typeText; // or textUnknown
+
+ len = filename.length();
+ if (fileType == typeClass
+ && letUsersSendClassfile(out, filename, len))
+ return;
+
+ checkFilename(filename, len);
+ if (htmlfileBase != null)
+ filename = htmlfileBase + filename;
+
+ if (File.separatorChar != '/')
+ filename = filename.replace('/', File.separatorChar);
+
+ File file = new File(filename);
+ if (file.canRead()) {
+ sendHeader(out, file.length(), fileType);
+ FileInputStream fin = new FileInputStream(file);
+ byte[] filebuffer = new byte[4096];
+ for (;;) {
+ len = fin.read(filebuffer);
+ if (len <= 0)
+ break;
+ else
+ out.write(filebuffer, 0, len);
+ }
+
+ fin.close();
+ return;
+ }
+
+ // If the file is not found under the html-file directory,
+ // then Class.getResourceAsStream() is tried.
+
+ if (fileType == typeClass) {
+ InputStream fin
+ = getClass().getResourceAsStream("/" + urlName);
+ if (fin != null) {
+ ByteArrayOutputStream barray = new ByteArrayOutputStream();
+ byte[] filebuffer = new byte[4096];
+ for (;;) {
+ len = fin.read(filebuffer);
+ if (len <= 0)
+ break;
+ else
+ barray.write(filebuffer, 0, len);
+ }
+
+ byte[] classfile = barray.toByteArray();
+ sendHeader(out, classfile.length, typeClass);
+ out.write(classfile);
+ fin.close();
+ return;
+ }
+ }
+
+ throw new BadHttpRequest();
+ }
+
+ private void checkFilename(String filename, int len)
+ throws BadHttpRequest
+ {
+ for (int i = 0; i < len; ++i) {
+ char c = filename.charAt(i);
+ if (!Character.isJavaIdentifierPart(c) && c != '.' && c != '/')
+ throw new BadHttpRequest();
+ }
+
+ if (filename.indexOf("..") >= 0)
+ throw new BadHttpRequest();
+ }
+
+ private boolean letUsersSendClassfile(OutputStream out,
+ String filename, int length)
+ throws IOException, BadHttpRequest
+ {
+ if (classPool == null)
+ return false;
+
+ byte[] classfile;
+ String classname
+ = filename.substring(0, length - 6).replace('/', '.');
+ try {
+ if (translator != null)
+ translator.onLoad(classPool, classname);
+
+ CtClass c = classPool.get(classname);
+ classfile = c.toBytecode();
+ if (debugDir != null)
+ c.writeFile(debugDir);
+ }
+ catch (Exception e) {
+ throw new BadHttpRequest(e);
+ }
+
+ sendHeader(out, classfile.length, typeClass);
+ out.write(classfile);
+ return true;
+ }
+
+ private void sendHeader(OutputStream out, long dataLength, int filetype)
+ throws IOException
+ {
+ out.write("HTTP/1.0 200 OK".getBytes());
+ out.write(endofline);
+ out.write("Content-Length: ".getBytes());
+ out.write(Long.toString(dataLength).getBytes());
+ out.write(endofline);
+ if (filetype == typeClass)
+ out.write("Content-Type: application/octet-stream".getBytes());
+ else if (filetype == typeHtml)
+ out.write("Content-Type: text/html".getBytes());
+ else if (filetype == typeGif)
+ out.write("Content-Type: image/gif".getBytes());
+ else if (filetype == typeJpeg)
+ out.write("Content-Type: image/jpg".getBytes());
+ else if (filetype == typeText)
+ out.write("Content-Type: text/plain".getBytes());
+
+ out.write(endofline);
+ out.write(endofline);
+ }
+
+ private void replyError(OutputStream out, BadHttpRequest e)
+ throws IOException
+ {
+ logging2("bad request: " + e.toString());
+ out.write("HTTP/1.0 400 Bad Request".getBytes());
+ out.write(endofline);
+ out.write(endofline);
+ out.write("<H1>Bad Request</H1>".getBytes());
+ }
+}
+
+class ServiceThread extends Thread {
+ Webserver web;
+ Socket sock;
+
+ public ServiceThread(Webserver w, Socket s) {
+ web = w;
+ sock = s;
+ }
+
+ public void run() {
+ try {
+ web.process(sock);
+ }
+ catch (IOException e) {
+ }
+ }
+}
diff --git a/src/main/javassist/tools/web/package.html b/src/main/javassist/tools/web/package.html
new file mode 100644
index 0000000..0c7fb45
--- /dev/null
+++ b/src/main/javassist/tools/web/package.html
@@ -0,0 +1,7 @@
+<html>
+<body>
+Simple web server for running sample code.
+
+<p>This package provides a simple web server for sample packages.
+</body>
+</html>
diff --git a/src/main/javassist/util/HotSwapper.java b/src/main/javassist/util/HotSwapper.java
new file mode 100644
index 0000000..3536adf
--- /dev/null
+++ b/src/main/javassist/util/HotSwapper.java
@@ -0,0 +1,252 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util;
+
+import com.sun.jdi.*;
+import com.sun.jdi.connect.*;
+import com.sun.jdi.event.*;
+import com.sun.jdi.request.*;
+import java.io.*;
+import java.util.*;
+
+class Trigger {
+ void doSwap() {}
+}
+
+/**
+ * A utility class for dynamically reloading a class by
+ * the Java Platform Debugger Architecture (JPDA), or <it>HotSwap</code>.
+ * It works only with JDK 1.4 and later.
+ *
+ * <p><b>Note:</b> The new definition of the reloaded class must declare
+ * the same set of methods and fields as the original definition. The
+ * schema change between the original and new definitions is not allowed
+ * by the JPDA.
+ *
+ * <p>To use this class, the JVM must be launched with the following
+ * command line options:
+ *
+ * <ul>
+ * <p>For Java 1.4,<br>
+ * <pre>java -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000</pre>
+ * <p>For Java 5,<br>
+ * <pre>java -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000</pre>
+ * </ul>
+ *
+ * <p>Note that 8000 is the port number used by <code>HotSwapper</code>.
+ * Any port number can be specified. Since <code>HotSwapper</code> does not
+ * launch another JVM for running a target application, this port number
+ * is used only for inter-thread communication.
+ *
+ * <p>Furthermore, <code>JAVA_HOME/lib/tools.jar</code> must be included
+ * in the class path.
+ *
+ * <p>Using <code>HotSwapper</code> is easy. See the following example:
+ *
+ * <ul><pre>
+ * CtClass clazz = ...
+ * byte[] classFile = clazz.toBytecode();
+ * HotSwapper hs = new HostSwapper(8000); // 8000 is a port number.
+ * hs.reload("Test", classFile);
+ * </pre></ul>
+ *
+ * <p><code>reload()</code>
+ * first unload the <code>Test</code> class and load a new version of
+ * the <code>Test</code> class.
+ * <code>classFile</code> is a byte array containing the new contents of
+ * the class file for the <code>Test</code> class. The developers can
+ * repatedly call <code>reload()</code> on the same <code>HotSwapper</code>
+ * object so that they can reload a number of classes.
+ *
+ * @since 3.1
+ */
+public class HotSwapper {
+ private VirtualMachine jvm;
+ private MethodEntryRequest request;
+ private Map newClassFiles;
+
+ private Trigger trigger;
+
+ private static final String HOST_NAME = "localhost";
+ private static final String TRIGGER_NAME = Trigger.class.getName();
+
+ /**
+ * Connects to the JVM.
+ *
+ * @param port the port number used for the connection to the JVM.
+ */
+ public HotSwapper(int port)
+ throws IOException, IllegalConnectorArgumentsException
+ {
+ this(Integer.toString(port));
+ }
+
+ /**
+ * Connects to the JVM.
+ *
+ * @param port the port number used for the connection to the JVM.
+ */
+ public HotSwapper(String port)
+ throws IOException, IllegalConnectorArgumentsException
+ {
+ jvm = null;
+ request = null;
+ newClassFiles = null;
+ trigger = new Trigger();
+ AttachingConnector connector
+ = (AttachingConnector)findConnector("com.sun.jdi.SocketAttach");
+
+ Map arguments = connector.defaultArguments();
+ ((Connector.Argument)arguments.get("hostname")).setValue(HOST_NAME);
+ ((Connector.Argument)arguments.get("port")).setValue(port);
+ jvm = connector.attach(arguments);
+ EventRequestManager manager = jvm.eventRequestManager();
+ request = methodEntryRequests(manager, TRIGGER_NAME);
+ }
+
+ private Connector findConnector(String connector) throws IOException {
+ List connectors = Bootstrap.virtualMachineManager().allConnectors();
+ Iterator iter = connectors.iterator();
+ while (iter.hasNext()) {
+ Connector con = (Connector)iter.next();
+ if (con.name().equals(connector)) {
+ return con;
+ }
+ }
+
+ throw new IOException("Not found: " + connector);
+ }
+
+ private static MethodEntryRequest methodEntryRequests(
+ EventRequestManager manager,
+ String classpattern) {
+ MethodEntryRequest mereq = manager.createMethodEntryRequest();
+ mereq.addClassFilter(classpattern);
+ mereq.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
+ return mereq;
+ }
+
+ /* Stops triggering a hotswapper when reload() is called.
+ */
+ private void deleteEventRequest(EventRequestManager manager,
+ MethodEntryRequest request) {
+ manager.deleteEventRequest(request);
+ }
+
+ /**
+ * Reloads a class.
+ *
+ * @param className the fully-qualified class name.
+ * @param classFile the contents of the class file.
+ */
+ public void reload(String className, byte[] classFile) {
+ ReferenceType classtype = toRefType(className);
+ Map map = new HashMap();
+ map.put(classtype, classFile);
+ reload2(map, className);
+ }
+
+ /**
+ * Reloads a class.
+ *
+ * @param classFiles a map between fully-qualified class names
+ * and class files. The type of the class names
+ * is <code>String</code> and the type of the
+ * class files is <code>byte[]</code>.
+ */
+ public void reload(Map classFiles) {
+ Set set = classFiles.entrySet();
+ Iterator it = set.iterator();
+ Map map = new HashMap();
+ String className = null;
+ while (it.hasNext()) {
+ Map.Entry e = (Map.Entry)it.next();
+ className = (String)e.getKey();
+ map.put(toRefType(className), e.getValue());
+ }
+
+ if (className != null)
+ reload2(map, className + " etc.");
+ }
+
+ private ReferenceType toRefType(String className) {
+ List list = jvm.classesByName(className);
+ if (list == null || list.isEmpty())
+ throw new RuntimeException("no such class: " + className);
+ else
+ return (ReferenceType)list.get(0);
+ }
+
+ private void reload2(Map map, String msg) {
+ synchronized (trigger) {
+ startDaemon();
+ newClassFiles = map;
+ request.enable();
+ trigger.doSwap();
+ request.disable();
+ Map ncf = newClassFiles;
+ if (ncf != null) {
+ newClassFiles = null;
+ throw new RuntimeException("failed to reload: " + msg);
+ }
+ }
+ }
+
+ private void startDaemon() {
+ new Thread() {
+ private void errorMsg(Throwable e) {
+ System.err.print("Exception in thread \"HotSwap\" ");
+ e.printStackTrace(System.err);
+ }
+
+ public void run() {
+ EventSet events = null;
+ try {
+ events = waitEvent();
+ EventIterator iter = events.eventIterator();
+ while (iter.hasNext()) {
+ Event event = iter.nextEvent();
+ if (event instanceof MethodEntryEvent) {
+ hotswap();
+ break;
+ }
+ }
+ }
+ catch (Throwable e) {
+ errorMsg(e);
+ }
+ try {
+ if (events != null)
+ events.resume();
+ }
+ catch (Throwable e) {
+ errorMsg(e);
+ }
+ }
+ }.start();
+ }
+
+ EventSet waitEvent() throws InterruptedException {
+ EventQueue queue = jvm.eventQueue();
+ return queue.remove();
+ }
+
+ void hotswap() {
+ Map map = newClassFiles;
+ jvm.redefineClasses(map);
+ newClassFiles = null;
+ }
+}
diff --git a/src/main/javassist/util/package.html b/src/main/javassist/util/package.html
new file mode 100644
index 0000000..349d996
--- /dev/null
+++ b/src/main/javassist/util/package.html
@@ -0,0 +1,5 @@
+<html>
+<body>
+Utility classes.
+</body>
+</html>
diff --git a/src/main/javassist/util/proxy/FactoryHelper.java b/src/main/javassist/util/proxy/FactoryHelper.java
new file mode 100644
index 0000000..50d1944
--- /dev/null
+++ b/src/main/javassist/util/proxy/FactoryHelper.java
@@ -0,0 +1,236 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.lang.reflect.Method;
+import java.io.BufferedOutputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.security.ProtectionDomain;
+
+import javassist.CannotCompileException;
+import javassist.bytecode.ClassFile;
+
+/**
+ * A helper class for implementing <code>ProxyFactory</code>.
+ * The users of <code>ProxyFactory</code> do not have to see this class.
+ *
+ * @see ProxyFactory
+ */
+public class FactoryHelper {
+ private static java.lang.reflect.Method defineClass1, defineClass2;
+
+ static {
+ try {
+ Class cl = Class.forName("java.lang.ClassLoader");
+ defineClass1 = SecurityActions.getDeclaredMethod(
+ cl,
+ "defineClass",
+ new Class[] { String.class, byte[].class,
+ int.class, int.class });
+
+ defineClass2 = SecurityActions.getDeclaredMethod(
+ cl,
+ "defineClass",
+ new Class[] { String.class, byte[].class,
+ int.class, int.class, ProtectionDomain.class });
+ }
+ catch (Exception e) {
+ throw new RuntimeException("cannot initialize");
+ }
+ }
+
+ /**
+ * Returns an index for accessing arrays in this class.
+ *
+ * @throws RuntimeException if a given type is not a primitive type.
+ */
+ public static final int typeIndex(Class type) {
+ Class[] list = primitiveTypes;
+ int n = list.length;
+ for (int i = 0; i < n; i++)
+ if (list[i] == type)
+ return i;
+
+ throw new RuntimeException("bad type:" + type.getName());
+ }
+
+ /**
+ * <code>Class</code> objects representing primitive types.
+ */
+ public static final Class[] primitiveTypes = {
+ Boolean.TYPE, Byte.TYPE, Character.TYPE, Short.TYPE, Integer.TYPE,
+ Long.TYPE, Float.TYPE, Double.TYPE, Void.TYPE
+ };
+
+ /**
+ * The fully-qualified names of wrapper classes for primitive types.
+ */
+ public static final String[] wrapperTypes = {
+ "java.lang.Boolean", "java.lang.Byte", "java.lang.Character",
+ "java.lang.Short", "java.lang.Integer", "java.lang.Long",
+ "java.lang.Float", "java.lang.Double", "java.lang.Void"
+ };
+
+ /**
+ * The descriptors of the constructors of wrapper classes.
+ */
+ public static final String[] wrapperDesc = {
+ "(Z)V", "(B)V", "(C)V", "(S)V", "(I)V", "(J)V",
+ "(F)V", "(D)V"
+ };
+
+ /**
+ * The names of methods for obtaining a primitive value
+ * from a wrapper object. For example, <code>intValue()</code>
+ * is such a method for obtaining an integer value from a
+ * <code>java.lang.Integer</code> object.
+ */
+ public static final String[] unwarpMethods = {
+ "booleanValue", "byteValue", "charValue", "shortValue",
+ "intValue", "longValue", "floatValue", "doubleValue"
+ };
+
+ /**
+ * The descriptors of the unwrapping methods contained
+ * in <code>unwrapMethods</code>.
+ */
+ public static final String[] unwrapDesc = {
+ "()Z", "()B", "()C", "()S", "()I", "()J", "()F", "()D"
+ };
+
+ /**
+ * The data size of primitive types. <code>long</code>
+ * and <code>double</code> are 2; the others are 1.
+ */
+ public static final int[] dataSize = {
+ 1, 1, 1, 1, 1, 2, 1, 2
+ };
+
+ /**
+ * Loads a class file by a given class loader.
+ * This method uses a default protection domain for the class
+ * but it may not work with a security manager or a sigend jar file.
+ *
+ * @see #toClass(ClassFile,ClassLoader,ProtectionDomain)
+ */
+ public static Class toClass(ClassFile cf, ClassLoader loader)
+ throws CannotCompileException
+ {
+ return toClass(cf, loader, null);
+ }
+
+ /**
+ * Loads a class file by a given class loader.
+ *
+ * @param domain if it is null, a default domain is used.
+ * @since 3.3
+ */
+ public static Class toClass(ClassFile cf, ClassLoader loader, ProtectionDomain domain)
+ throws CannotCompileException
+ {
+ try {
+ byte[] b = toBytecode(cf);
+ Method method;
+ Object[] args;
+ if (domain == null) {
+ method = defineClass1;
+ args = new Object[] { cf.getName(), b, new Integer(0),
+ new Integer(b.length) };
+ }
+ else {
+ method = defineClass2;
+ args = new Object[] { cf.getName(), b, new Integer(0),
+ new Integer(b.length), domain };
+ }
+
+ return toClass2(method, loader, args);
+ }
+ catch (RuntimeException e) {
+ throw e;
+ }
+ catch (java.lang.reflect.InvocationTargetException e) {
+ throw new CannotCompileException(e.getTargetException());
+ }
+ catch (Exception e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private static synchronized Class toClass2(Method method,
+ ClassLoader loader, Object[] args)
+ throws Exception
+ {
+ SecurityActions.setAccessible(method, true);
+ Class clazz = (Class)method.invoke(loader, args);
+ SecurityActions.setAccessible(method, false);
+ return clazz;
+ }
+
+ private static byte[] toBytecode(ClassFile cf) throws IOException {
+ ByteArrayOutputStream barray = new ByteArrayOutputStream();
+ DataOutputStream out = new DataOutputStream(barray);
+ try {
+ cf.write(out);
+ }
+ finally {
+ out.close();
+ }
+
+ return barray.toByteArray();
+ }
+
+ /**
+ * Writes a class file.
+ */
+ public static void writeFile(ClassFile cf, String directoryName)
+ throws CannotCompileException {
+ try {
+ writeFile0(cf, directoryName);
+ }
+ catch (IOException e) {
+ throw new CannotCompileException(e);
+ }
+ }
+
+ private static void writeFile0(ClassFile cf, String directoryName)
+ throws CannotCompileException, IOException {
+ String classname = cf.getName();
+ String filename = directoryName + File.separatorChar
+ + classname.replace('.', File.separatorChar) + ".class";
+ int pos = filename.lastIndexOf(File.separatorChar);
+ if (pos > 0) {
+ String dir = filename.substring(0, pos);
+ if (!dir.equals("."))
+ new File(dir).mkdirs();
+ }
+
+ DataOutputStream out = new DataOutputStream(new BufferedOutputStream(
+ new FileOutputStream(filename)));
+ try {
+ cf.write(out);
+ }
+ catch (IOException e) {
+ throw e;
+ }
+ finally {
+ out.close();
+ }
+ }
+}
diff --git a/src/main/javassist/util/proxy/MethodFilter.java b/src/main/javassist/util/proxy/MethodFilter.java
new file mode 100644
index 0000000..76084ff
--- /dev/null
+++ b/src/main/javassist/util/proxy/MethodFilter.java
@@ -0,0 +1,30 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.lang.reflect.Method;
+
+/**
+ * Selector of the methods implemented by a handler.
+ *
+ * @see ProxyFactory#setFilter(MethodFilter)
+ */
+public interface MethodFilter {
+ /**
+ * Returns true if the given method is implemented by a handler.
+ */
+ boolean isHandled(Method m);
+}
diff --git a/src/main/javassist/util/proxy/MethodHandler.java b/src/main/javassist/util/proxy/MethodHandler.java
new file mode 100644
index 0000000..2bb32cc
--- /dev/null
+++ b/src/main/javassist/util/proxy/MethodHandler.java
@@ -0,0 +1,48 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.lang.reflect.Method;
+
+/**
+ * The interface implemented by the invocation handler of a proxy
+ * instance.
+ *
+ * @see ProxyFactory#setHandler(MethodHandler)
+ */
+public interface MethodHandler {
+ /**
+ * Is called when a method is invoked on a proxy instance associated
+ * with this handler. This method must process that method invocation.
+ *
+ * @param self the proxy instance.
+ * @param thisMethod the overridden method declared in the super
+ * class or interface.
+ * @param proceed the forwarder method for invoking the overridden
+ * method. It is null if the overridden mehtod is
+ * abstract or declared in the interface.
+ * @param args an array of objects containing the values of
+ * the arguments passed in the method invocation
+ * on the proxy instance. If a parameter type is
+ * a primitive type, the type of the array element
+ * is a wrapper class.
+ * @return the resulting value of the method invocation.
+ *
+ * @throws Throwable if the method invocation fails.
+ */
+ Object invoke(Object self, Method thisMethod, Method proceed,
+ Object[] args) throws Throwable;
+}
diff --git a/src/main/javassist/util/proxy/ProxyFactory.java b/src/main/javassist/util/proxy/ProxyFactory.java
new file mode 100644
index 0000000..0750950
--- /dev/null
+++ b/src/main/javassist/util/proxy/ProxyFactory.java
@@ -0,0 +1,1334 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+import java.security.ProtectionDomain;
+import java.util.*;
+import java.lang.ref.WeakReference;
+
+import javassist.CannotCompileException;
+import javassist.bytecode.*;
+
+/*
+ * This class is implemented only with the lower-level API of Javassist.
+ * This design decision is for maximizing performance.
+ */
+
+/**
+ * Factory of dynamic proxy classes.
+ *
+ * <p>This factory generates a class that extends the given super class and implements
+ * the given interfaces. The calls of the methods inherited from the super class are
+ * forwarded and then <code>invoke()</code> is called on the method handler
+ * associated with instances of the generated class. The calls of the methods from
+ * the interfaces are also forwarded to the method handler.
+ *
+ * <p>For example, if the following code is executed,
+ *
+ * <ul><pre>
+ * ProxyFactory f = new ProxyFactory();
+ * f.setSuperclass(Foo.class);
+ * f.setFilter(new MethodFilter() {
+ * public boolean isHandled(Method m) {
+ * // ignore finalize()
+ * return !m.getName().equals("finalize");
+ * }
+ * });
+ * Class c = f.createClass();
+ * MethodHandler mi = new MethodHandler() {
+ * public Object invoke(Object self, Method m, Method proceed,
+ * Object[] args) throws Throwable {
+ * System.out.println("Name: " + m.getName());
+ * return proceed.invoke(self, args); // execute the original method.
+ * }
+ * };
+ * Foo foo = (Foo)c.newInstance();
+ * ((ProxyObject)foo).setHandler(mi);
+ * </pre></ul>
+ *
+ * <p>Then, the following method call will be forwarded to MethodHandler
+ * <code>mi</code> and prints a message before executing the originally called method
+ * <code>bar()</code> in <code>Foo</code>.
+ *
+ * <ul><pre>
+ * foo.bar();
+ * </pre></ul>
+ *
+ * <p>The last three lines of the code shown above can be replaced with a call to
+ * the helper method <code>create</code>, which generates a proxy class, instantiates
+ * it, and sets the method handler of the instance:
+ *
+ * <ul><pre>
+ * :
+ * Foo foo = (Foo)f.create(new Class[0], new Object[0], mi);
+ * </pre></ul>
+ *
+ * <p>To change the method handler during runtime,
+ * execute the following code:
+ *
+ * <ul><pre>
+ * MethodHandler mi = ... ; // alternative handler
+ * ((ProxyObject)foo).setHandler(mi);
+ * </pre></ul>
+ *
+ * <p> If setHandler is never called for a proxy instance then it will
+ * employ the default handler which proceeds by invoking the original method.
+ * The behaviour of the default handler is identical to the following
+ * handler:
+ *
+ * <ul><pre>
+ * class EmptyHandler implements MethodHandler {
+ * public Object invoke(Object self, Method m,
+ * Method proceed, Object[] args) throws Exception {
+ * return proceed.invoke(self, args);
+ * }
+ * }
+ * </pre></ul>
+ *
+ * <p>A proxy factory caches and reuses proxy classes by default. It is possible to reset
+ * this default globally by setting static field {@link ProxyFactory#useCache} to false.
+ * Caching may also be configured for a specific factory by calling instance method
+ * {@link ProxyFactory#setUseCache(boolean)}. It is strongly recommended that new clients
+ * of class ProxyFactory enable caching. Failure to do so may lead to exhaustion of
+ * the heap memory area used to store classes.
+ *
+ * <p>Caching is automatically disabled for any given proxy factory if deprecated instance
+ * method {@link ProxyFactory#setHandler(MethodHandler)} is called. This method was
+ * used to specify a default handler which newly created proxy classes should install
+ * when they create their instances. It is only retained to provide backward compatibility
+ * with previous releases of javassist. Unfortunately,this legacy behaviour makes caching
+ * and reuse of proxy classes impossible. The current programming model expects javassist
+ * clients to set the handler of a proxy instance explicitly by calling method
+ * {@link ProxyObject#setHandler(MethodHandler)} as shown in the sample code above. New
+ * clients are strongly recommended to use this model rather than calling
+ * {@link ProxyFactory#setHandler(MethodHandler)}.
+ *
+ * <p>A proxy object generated by <code>ProxyFactory</code> is serializable
+ * if its super class or any of its interfaces implement <code>java.io.Serializable</code>.
+ * However, a serialized proxy object may not be compatible with future releases.
+ * The serialization support should be used for short-term storage or RMI.
+ *
+ * <p>For compatibility with older releases serialization of proxy objects is implemented by
+ * adding a writeReplace method to the proxy class. This allows a proxy to be serialized
+ * to a conventional {@link java.io.ObjectOutputStream} and deserialized from a corresponding
+ * {@link java.io.ObjectInputStream}. However this method suffers from several problems, the most
+ * notable one being that it fails to serialize state inherited from the proxy's superclass.
+ * <p>
+ * An alternative method of serializing proxy objects is available which fixes these problems. It
+ * requires inhibiting generation of the writeReplace method and instead using instances of
+ * {@link javassist.util.proxy.ProxyObjectOutputStream} and {@link javassist.util.proxy.ProxyObjectInputStream}
+ * (which are subclasses of {@link java.io.ObjectOutputStream} and {@link java.io.ObjectInputStream})
+ * to serialize and deserialize, respectively, the proxy. These streams recognise javassist proxies and ensure
+ * that they are serialized and deserialized without the need for the proxy class to implement special methods
+ * such as writeReplace. Generation of the writeReplace method can be disabled globally by setting static field
+ * {@link ProxyFactory#useWriteReplace} to false. Alternatively, it may be
+ * configured per factory by calling instance method {@link ProxyFactory#setUseWriteReplace(boolean)}.
+ *
+ * @see MethodHandler
+ * @since 3.1
+ * @author Muga Nishizawa
+ * @author Shigeru Chiba
+ * @author Andrew Dinn
+ */
+public class ProxyFactory {
+ private Class superClass;
+ private Class[] interfaces;
+ private MethodFilter methodFilter;
+ private MethodHandler handler; // retained for legacy usage
+ private List signatureMethods;
+ private byte[] signature;
+ private String classname;
+ private String basename;
+ private String superName;
+ private Class thisClass;
+ /**
+ * per factory setting initialised from current setting for useCache but able to be reset before each create call
+ */
+ private boolean factoryUseCache;
+ /**
+ * per factory setting initialised from current setting for useWriteReplace but able to be reset before each create call
+ */
+ private boolean factoryWriteReplace;
+
+
+ /**
+ * If the value of this variable is not null, the class file of
+ * the generated proxy class is written under the directory specified
+ * by this variable. For example, if the value is
+ * <code>"."</code>, then the class file is written under the current
+ * directory. This method is for debugging.
+ *
+ * <p>The default value is null.
+ */
+ public String writeDirectory;
+
+ private static final Class OBJECT_TYPE = Object.class;
+
+ private static final String HOLDER = "_methods_";
+ private static final String HOLDER_TYPE = "[Ljava/lang/reflect/Method;";
+ private static final String FILTER_SIGNATURE_FIELD = "_filter_signature";
+ private static final String FILTER_SIGNATURE_TYPE = "[B";
+ private static final String HANDLER = "handler";
+ private static final String NULL_INTERCEPTOR_HOLDER = "javassist.util.proxy.RuntimeSupport";
+ private static final String DEFAULT_INTERCEPTOR = "default_interceptor";
+ private static final String HANDLER_TYPE
+ = 'L' + MethodHandler.class.getName().replace('.', '/') + ';';
+ private static final String HANDLER_SETTER = "setHandler";
+ private static final String HANDLER_SETTER_TYPE = "(" + HANDLER_TYPE + ")V";
+
+ private static final String HANDLER_GETTER = "getHandler";
+ private static final String HANDLER_GETTER_TYPE = "()" + HANDLER_TYPE;
+
+ private static final String SERIAL_VERSION_UID_FIELD = "serialVersionUID";
+ private static final String SERIAL_VERSION_UID_TYPE = "J";
+ private static final int SERIAL_VERSION_UID_VALUE = -1;
+
+ /**
+ * If true, a generated proxy class is cached and it will be reused
+ * when generating the proxy class with the same properties is requested.
+ * The default value is true.
+ *
+ * Note that this value merely specifies the initial setting employed by any newly created
+ * proxy factory. The factory setting may be overwritten by calling factory instance method
+ * {@link #setUseCache(boolean)}
+ *
+ * @since 3.4
+ */
+ public static volatile boolean useCache = true;
+
+ /**
+ * If true, a generated proxy class will implement method writeReplace enabling
+ * serialization of its proxies to a conventional ObjectOutputStream. this (default)
+ * setting retains the old javassist behaviour which has the advantage that it
+ * retains compatibility with older releases and requires no extra work on the part
+ * of the client performing the serialization. However, it has the disadvantage that
+ * state inherited from the superclasses of the proxy is lost during serialization.
+ * if false then serialization/deserialization of the proxy instances will preserve
+ * all fields. However, serialization must be performed via a {@link ProxyObjectOutputStream}
+ * and deserialization must be via {@link ProxyObjectInputStream}. Any attempt to serialize
+ * proxies whose class was created with useWriteReplace set to false via a normal
+ * {@link java.io.ObjectOutputStream} will fail.
+ *
+ * Note that this value merely specifies the initial setting employed by any newly created
+ * proxy factory. The factory setting may be overwritten by calling factory instance method
+ * {@link #setUseWriteReplace(boolean)}
+ *
+ * @since 3.4
+ */
+ public static volatile boolean useWriteReplace = true;
+
+ /*
+ * methods allowing individual factory settings for factoryUseCache and factoryWriteReplace to be reset
+ */
+
+ /**
+ * test whether this factory uses the proxy cache
+ * @return true if this factory uses the proxy cache otherwise false
+ */
+ public boolean isUseCache()
+ {
+ return factoryUseCache;
+ }
+
+ /**
+ * configure whether this factory should use the proxy cache
+ * @param useCache true if this factory should use the proxy cache and false if it should not use the cache
+ * @throws RuntimeException if a default interceptor has been set for the factory
+ */
+ public void setUseCache(boolean useCache)
+ {
+ // we cannot allow caching to be used if the factory is configured to install a default interceptor
+ // field into generated classes
+ if (handler != null && useCache) {
+ throw new RuntimeException("caching cannot be enabled if the factory default interceptor has been set");
+ }
+ factoryUseCache = useCache;
+ }
+
+ /**
+ * test whether this factory installs a writeReplace method in created classes
+ * @return true if this factory installs a writeReplace method in created classes otherwise false
+ */
+ public boolean isUseWriteReplace()
+ {
+ return factoryWriteReplace;
+ }
+
+ /**
+ * configure whether this factory should add a writeReplace method to created classes
+ * @param useWriteReplace true if this factory should add a writeReplace method to created classes and false if it
+ * should not add a writeReplace method
+ */
+ public void setUseWriteReplace(boolean useWriteReplace)
+ {
+ factoryWriteReplace = useWriteReplace;
+ }
+
+ private static WeakHashMap proxyCache = new WeakHashMap();
+
+ /**
+ * determine if a class is a javassist proxy class
+ * @param cl
+ * @return true if the class is a javassist proxy class otherwise false
+ */
+ public static boolean isProxyClass(Class cl)
+ {
+ // all proxies implement ProxyObject. nothing else should.
+ return (ProxyObject.class.isAssignableFrom(cl));
+ }
+
+ /**
+ * used to store details of a specific proxy class in the second tier of the proxy cache. this entry
+ * will be located in a hashmap keyed by the unique identifying name of the proxy class. the hashmap is
+ * located in a weak hashmap keyed by the classloader common to all proxy classes in the second tier map.
+ */
+ static class ProxyDetails {
+ /**
+ * the unique signature of any method filter whose behaviour will be met by this class. each bit in
+ * the byte array is set if the filter redirects the corresponding super or interface method and clear
+ * if it does not redirect it.
+ */
+ byte[] signature;
+ /**
+ * a hexadecimal string representation of the signature bit sequence. this string also forms part
+ * of the proxy class name.
+ */
+ WeakReference proxyClass;
+ /**
+ * a flag which is true this class employs writeReplace to perform serialization of its instances
+ * and false if serialization must employ of a ProxyObjectOutputStream and ProxyObjectInputStream
+ */
+ boolean isUseWriteReplace;
+
+ ProxyDetails(byte[] signature, Class proxyClass, boolean isUseWriteReplace)
+ {
+ this.signature = signature;
+ this.proxyClass = new WeakReference(proxyClass);
+ this.isUseWriteReplace = isUseWriteReplace;
+ }
+ }
+
+ /**
+ * Constructs a factory of proxy class.
+ */
+ public ProxyFactory() {
+ superClass = null;
+ interfaces = null;
+ methodFilter = null;
+ handler = null;
+ signature = null;
+ signatureMethods = null;
+ thisClass = null;
+ writeDirectory = null;
+ factoryUseCache = useCache;
+ factoryWriteReplace = useWriteReplace;
+ }
+
+ /**
+ * Sets the super class of a proxy class.
+ */
+ public void setSuperclass(Class clazz) {
+ superClass = clazz;
+ // force recompute of signature
+ signature = null;
+ }
+
+ /**
+ * Obtains the super class set by <code>setSuperclass()</code>.
+ *
+ * @since 3.4
+ */
+ public Class getSuperclass() { return superClass; }
+
+ /**
+ * Sets the interfaces of a proxy class.
+ */
+ public void setInterfaces(Class[] ifs) {
+ interfaces = ifs;
+ // force recompute of signature
+ signature = null;
+ }
+
+ /**
+ * Obtains the interfaces set by <code>setInterfaces</code>.
+ *
+ * @since 3.4
+ */
+ public Class[] getInterfaces() { return interfaces; }
+
+ /**
+ * Sets a filter that selects the methods that will be controlled by a handler.
+ */
+ public void setFilter(MethodFilter mf) {
+ methodFilter = mf;
+ // force recompute of signature
+ signature = null;
+ }
+
+ /**
+ * Generates a proxy class using the current filter.
+ */
+ public Class createClass() {
+ if (signature == null) {
+ computeSignature(methodFilter);
+ }
+ return createClass1();
+ }
+
+ /**
+ * Generates a proxy class using the supplied filter.
+ */
+ public Class createClass(MethodFilter filter) {
+ computeSignature(filter);
+ return createClass1();
+ }
+
+ /**
+ * Generates a proxy class with a specific signature.
+ * access is package local so ProxyObjectInputStream can use this
+ * @param signature
+ * @return
+ */
+ Class createClass(byte[] signature)
+ {
+ installSignature(signature);
+ return createClass1();
+ }
+
+ private Class createClass1() {
+ if (thisClass == null) {
+ ClassLoader cl = getClassLoader();
+ synchronized (proxyCache) {
+ if (factoryUseCache)
+ createClass2(cl);
+ else
+ createClass3(cl);
+ }
+ }
+
+ // don't retain any unwanted references
+ Class result = thisClass;
+ thisClass = null;
+
+ return result;
+ }
+
+ private static char[] hexDigits =
+ { '0', '1', '2', '3', '4', '5', '6', '7',
+ '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+ public String getKey(Class superClass, Class[] interfaces, byte[] signature, boolean useWriteReplace)
+ {
+ StringBuffer sbuf = new StringBuffer();
+ if (superClass != null){
+ sbuf.append(superClass.getName());
+ }
+ sbuf.append(":");
+ for (int i = 0; i < interfaces.length; i++) {
+ sbuf.append(interfaces[i].getName());
+ sbuf.append(":");
+ }
+ for (int i = 0; i < signature.length; i++) {
+ byte b = signature[i];
+ int lo = b & 0xf;
+ int hi = (b >> 4) & 0xf;
+ sbuf.append(hexDigits[lo]);
+ sbuf.append(hexDigits[hi]);
+ }
+ if (useWriteReplace) {
+ sbuf.append(":w");
+ }
+
+ return sbuf.toString();
+ }
+
+ private void createClass2(ClassLoader cl) {
+ String key = getKey(superClass, interfaces, signature, factoryWriteReplace);
+ /*
+ * Excessive concurrency causes a large memory footprint and slows the
+ * execution speed down (with JDK 1.5). Thus, we use a jumbo lock for
+ * reducing concrrency.
+ */
+ // synchronized (proxyCache) {
+ HashMap cacheForTheLoader = (HashMap)proxyCache.get(cl);
+ ProxyDetails details;
+ if (cacheForTheLoader == null) {
+ cacheForTheLoader = new HashMap();
+ proxyCache.put(cl, cacheForTheLoader);
+ }
+ details = (ProxyDetails)cacheForTheLoader.get(key);
+ if (details != null) {
+ WeakReference reference = details.proxyClass;
+ thisClass = (Class)reference.get();
+ if (thisClass != null) {
+ return;
+ }
+ }
+ createClass3(cl);
+ details = new ProxyDetails(signature, thisClass, factoryWriteReplace);
+ cacheForTheLoader.put(key, details);
+ // }
+ }
+
+ private void createClass3(ClassLoader cl) {
+ // we need a new class so we need a new class name
+ allocateClassName();
+
+ try {
+ ClassFile cf = make();
+ if (writeDirectory != null)
+ FactoryHelper.writeFile(cf, writeDirectory);
+
+ thisClass = FactoryHelper.toClass(cf, cl, getDomain());
+ setField(FILTER_SIGNATURE_FIELD, signature);
+ // legacy behaviour : we only set the default interceptor static field if we are not using the cache
+ if (!factoryUseCache) {
+ setField(DEFAULT_INTERCEPTOR, handler);
+ }
+ }
+ catch (CannotCompileException e) {
+ throw new RuntimeException(e.getMessage(), e);
+ }
+
+ }
+
+ private void setField(String fieldName, Object value) {
+ if (thisClass != null && value != null)
+ try {
+ Field f = thisClass.getField(fieldName);
+ SecurityActions.setAccessible(f, true);
+ f.set(null, value);
+ SecurityActions.setAccessible(f, false);
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static byte[] getFilterSignature(Class clazz) {
+ return (byte[])getField(clazz, FILTER_SIGNATURE_FIELD);
+ }
+
+ private static Object getField(Class clazz, String fieldName) {
+ try {
+ Field f = clazz.getField(fieldName);
+ f.setAccessible(true);
+ Object value = f.get(null);
+ f.setAccessible(false);
+ return value;
+ }
+ catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ /**
+ * A provider of class loaders.
+ *
+ * @see #classLoaderProvider
+ * @since 3.4
+ */
+ public static interface ClassLoaderProvider {
+ /**
+ * Returns a class loader.
+ *
+ * @param pf a proxy factory that is going to obtain a class loader.
+ */
+ public ClassLoader get(ProxyFactory pf);
+ }
+
+ /**
+ * A provider used by <code>createClass()</code> for obtaining
+ * a class loader.
+ * <code>get()</code> on this <code>ClassLoaderProvider</code> object
+ * is called to obtain a class loader.
+ *
+ * <p>The value of this field can be updated for changing the default
+ * implementation.
+ *
+ * <p>Example:
+ * <ul><pre>
+ * ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {
+ * public ClassLoader get(ProxyFactory pf) {
+ * return Thread.currentThread().getContextClassLoader();
+ * }
+ * };
+ * </pre></ul>
+ *
+ * @since 3.4
+ */
+ public static ClassLoaderProvider classLoaderProvider
+ = new ClassLoaderProvider() {
+ public ClassLoader get(ProxyFactory pf) {
+ return pf.getClassLoader0();
+ }
+ };
+
+ protected ClassLoader getClassLoader() {
+ return classLoaderProvider.get(this);
+ }
+
+ protected ClassLoader getClassLoader0() {
+ ClassLoader loader = null;
+ if (superClass != null && !superClass.getName().equals("java.lang.Object"))
+ loader = superClass.getClassLoader();
+ else if (interfaces != null && interfaces.length > 0)
+ loader = interfaces[0].getClassLoader();
+
+ if (loader == null) {
+ loader = getClass().getClassLoader();
+ // In case javassist is in the endorsed dir
+ if (loader == null) {
+ loader = Thread.currentThread().getContextClassLoader();
+ if (loader == null)
+ loader = ClassLoader.getSystemClassLoader();
+ }
+ }
+
+ return loader;
+ }
+
+ protected ProtectionDomain getDomain() {
+ Class clazz;
+ if (superClass != null && !superClass.getName().equals("java.lang.Object"))
+ clazz = superClass;
+ else if (interfaces != null && interfaces.length > 0)
+ clazz = interfaces[0];
+ else
+ clazz = this.getClass();
+
+ return clazz.getProtectionDomain();
+ }
+
+ /**
+ * Creates a proxy class and returns an instance of that class.
+ *
+ * @param paramTypes parameter types for a constructor.
+ * @param args arguments passed to a constructor.
+ * @param mh the method handler for the proxy class.
+ * @since 3.4
+ */
+ public Object create(Class[] paramTypes, Object[] args, MethodHandler mh)
+ throws NoSuchMethodException, IllegalArgumentException,
+ InstantiationException, IllegalAccessException, InvocationTargetException
+ {
+ Object obj = create(paramTypes, args);
+ ((ProxyObject)obj).setHandler(mh);
+ return obj;
+ }
+
+ /**
+ * Creates a proxy class and returns an instance of that class.
+ *
+ * @param paramTypes parameter types for a constructor.
+ * @param args arguments passed to a constructor.
+ */
+ public Object create(Class[] paramTypes, Object[] args)
+ throws NoSuchMethodException, IllegalArgumentException,
+ InstantiationException, IllegalAccessException, InvocationTargetException
+ {
+ Class c = createClass();
+ Constructor cons = c.getConstructor(paramTypes);
+ return cons.newInstance(args);
+ }
+
+ /**
+ * Sets the default invocation handler. This invocation handler is shared
+ * among all the instances of a proxy class unless another is explicitly
+ * specified.
+ * @deprecated since 3.12
+ * use of this method is incompatible with proxy class caching.
+ * instead clients should call method {@link ProxyObject#setHandler(MethodHandler)} to set the handler
+ * for each newly created proxy instance.
+ * calling this method will automatically disable caching of classes created by the proxy factory.
+ */
+ public void setHandler(MethodHandler mi) {
+ // if we were using the cache and the handler is non-null then we must stop caching
+ if (factoryUseCache && mi != null) {
+ factoryUseCache = false;
+ // clear any currently held class so we don't try to reuse it or set its handler field
+ thisClass = null;
+ }
+ handler = mi;
+ // this retains the behaviour of the old code which resets any class we were holding on to
+ // this is probably not what is wanted
+ setField(DEFAULT_INTERCEPTOR, handler);
+ }
+
+ private static int counter = 0;
+
+ private static synchronized String makeProxyName(String classname) {
+ return classname + "_$$_javassist_" + counter++;
+ }
+
+ private ClassFile make() throws CannotCompileException {
+ ClassFile cf = new ClassFile(false, classname, superName);
+ cf.setAccessFlags(AccessFlag.PUBLIC);
+ setInterfaces(cf, interfaces);
+ ConstPool pool = cf.getConstPool();
+
+ // legacy: we only add the static field for the default interceptor if caching is disabled
+ if (!factoryUseCache) {
+ FieldInfo finfo = new FieldInfo(pool, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
+ finfo.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ cf.addField(finfo);
+ }
+
+ // handler is per instance
+ FieldInfo finfo2 = new FieldInfo(pool, HANDLER, HANDLER_TYPE);
+ finfo2.setAccessFlags(AccessFlag.PRIVATE);
+ cf.addField(finfo2);
+
+ // filter signature is per class
+ FieldInfo finfo3 = new FieldInfo(pool, FILTER_SIGNATURE_FIELD, FILTER_SIGNATURE_TYPE);
+ finfo3.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ cf.addField(finfo3);
+
+ // the proxy class serial uid must always be a fixed value
+ FieldInfo finfo4 = new FieldInfo(pool, SERIAL_VERSION_UID_FIELD, SERIAL_VERSION_UID_TYPE);
+ finfo4.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC| AccessFlag.FINAL);
+ cf.addField(finfo4);
+
+ // HashMap allMethods = getMethods(superClass, interfaces);
+ // int size = allMethods.size();
+ makeConstructors(classname, cf, pool, classname);
+ int s = overrideMethods(cf, pool, classname);
+ addMethodsHolder(cf, pool, classname, s);
+ addSetter(classname, cf, pool);
+ addGetter(classname, cf, pool);
+
+ if (factoryWriteReplace) {
+ try {
+ cf.addMethod(makeWriteReplace(pool));
+ }
+ catch (DuplicateMemberException e) {
+ // writeReplace() is already declared in the super class/interfaces.
+ }
+ }
+
+ thisClass = null;
+ return cf;
+ }
+
+ private void checkClassAndSuperName()
+ {
+ if (interfaces == null)
+ interfaces = new Class[0];
+
+ if (superClass == null) {
+ superClass = OBJECT_TYPE;
+ superName = superClass.getName();
+ basename = interfaces.length == 0 ? superName
+ : interfaces[0].getName();
+ } else {
+ superName = superClass.getName();
+ basename = superName;
+ }
+
+ if (Modifier.isFinal(superClass.getModifiers()))
+ throw new RuntimeException(superName + " is final");
+
+ if (basename.startsWith("java."))
+ basename = "org.javassist.tmp." + basename;
+ }
+
+ private void allocateClassName()
+ {
+ classname = makeProxyName(basename);
+ }
+
+ private static Comparator sorter = new Comparator() {
+
+ public int compare(Object o1, Object o2) {
+ Map.Entry e1 = (Map.Entry)o1;
+ Map.Entry e2 = (Map.Entry)o2;
+ String key1 = (String)e1.getKey();
+ String key2 = (String)e2.getKey();
+ return key1.compareTo(key2);
+ }
+ };
+
+ private void makeSortedMethodList()
+ {
+ checkClassAndSuperName();
+
+ HashMap allMethods = getMethods(superClass, interfaces);
+ signatureMethods = new ArrayList(allMethods.entrySet());
+ Collections.sort(signatureMethods, sorter);
+ }
+
+ private void computeSignature(MethodFilter filter) // throws CannotCompileException
+ {
+ makeSortedMethodList();
+
+ int l = signatureMethods.size();
+ int maxBytes = ((l + 7) >> 3);
+ signature = new byte[maxBytes];
+ for (int idx = 0; idx < l; idx++)
+ {
+ Map.Entry e = (Map.Entry)signatureMethods.get(idx);
+ Method m = (Method)e.getValue();
+ int mod = m.getModifiers();
+ if (!Modifier.isFinal(mod) && !Modifier.isStatic(mod)
+ && isVisible(mod, basename, m) && (filter == null || filter.isHandled(m))) {
+ setBit(signature, idx);
+ }
+ }
+ }
+
+ private void installSignature(byte[] signature) // throws CannotCompileException
+ {
+ makeSortedMethodList();
+
+ int l = signatureMethods.size();
+ int maxBytes = ((l + 7) >> 3);
+ if (signature.length != maxBytes) {
+ throw new RuntimeException("invalid filter signature length for deserialized proxy class");
+ }
+
+ this.signature = signature;
+ }
+
+ private boolean testBit(byte[] signature, int idx)
+ {
+ int byteIdx = idx >> 3;
+ if (byteIdx > signature.length) {
+ return false;
+ } else {
+ int bitIdx = idx & 0x7;
+ int mask = 0x1 << bitIdx;
+ int sigByte = signature[byteIdx];
+ return ((sigByte & mask) != 0);
+ }
+ }
+
+ private void setBit(byte[] signature, int idx)
+ {
+ int byteIdx = idx >> 3;
+ if (byteIdx < signature.length) {
+ int bitIdx = idx & 0x7;
+ int mask = 0x1 << bitIdx;
+ int sigByte = signature[byteIdx];
+ signature[byteIdx] = (byte)(sigByte | mask);
+ }
+ }
+
+ private static void setInterfaces(ClassFile cf, Class[] interfaces) {
+ String setterIntf = ProxyObject.class.getName();
+ String[] list;
+ if (interfaces == null || interfaces.length == 0)
+ list = new String[] { setterIntf };
+ else {
+ list = new String[interfaces.length + 1];
+ for (int i = 0; i < interfaces.length; i++)
+ list[i] = interfaces[i].getName();
+
+ list[interfaces.length] = setterIntf;
+ }
+
+ cf.setInterfaces(list);
+ }
+
+ private static void addMethodsHolder(ClassFile cf, ConstPool cp,
+ String classname, int size)
+ throws CannotCompileException
+ {
+ FieldInfo finfo = new FieldInfo(cp, HOLDER, HOLDER_TYPE);
+ finfo.setAccessFlags(AccessFlag.PRIVATE | AccessFlag.STATIC);
+ cf.addField(finfo);
+ MethodInfo minfo = new MethodInfo(cp, "<clinit>", "()V");
+ minfo.setAccessFlags(AccessFlag.STATIC);
+ Bytecode code = new Bytecode(cp, 0, 0);
+ code.addIconst(size * 2);
+ code.addAnewarray("java.lang.reflect.Method");
+ code.addPutstatic(classname, HOLDER, HOLDER_TYPE);
+ // also need to set serial version uid
+ code.addLconst(-1L);
+ code.addPutstatic(classname, SERIAL_VERSION_UID_FIELD, SERIAL_VERSION_UID_TYPE);
+ code.addOpcode(Bytecode.RETURN);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ }
+
+ private static void addSetter(String classname, ClassFile cf, ConstPool cp)
+ throws CannotCompileException
+ {
+ MethodInfo minfo = new MethodInfo(cp, HANDLER_SETTER,
+ HANDLER_SETTER_TYPE);
+ minfo.setAccessFlags(AccessFlag.PUBLIC);
+ Bytecode code = new Bytecode(cp, 2, 2);
+ code.addAload(0);
+ code.addAload(1);
+ code.addPutfield(classname, HANDLER, HANDLER_TYPE);
+ code.addOpcode(Bytecode.RETURN);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ }
+
+ private static void addGetter(String classname, ClassFile cf, ConstPool cp)
+ throws CannotCompileException
+ {
+ MethodInfo minfo = new MethodInfo(cp, HANDLER_GETTER,
+ HANDLER_GETTER_TYPE);
+ minfo.setAccessFlags(AccessFlag.PUBLIC);
+ Bytecode code = new Bytecode(cp, 1, 1);
+ code.addAload(0);
+ code.addGetfield(classname, HANDLER, HANDLER_TYPE);
+ code.addOpcode(Bytecode.ARETURN);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ cf.addMethod(minfo);
+ }
+
+ private int overrideMethods(ClassFile cf, ConstPool cp, String className)
+ throws CannotCompileException
+ {
+ String prefix = makeUniqueName("_d", signatureMethods);
+ Iterator it = signatureMethods.iterator();
+ int index = 0;
+ while (it.hasNext()) {
+ Map.Entry e = (Map.Entry)it.next();
+ String key = (String)e.getKey();
+ Method meth = (Method)e.getValue();
+ int mod = meth.getModifiers();
+ if (testBit(signature, index)) {
+ override(className, meth, prefix, index,
+ keyToDesc(key), cf, cp);
+ }
+ index++;
+ }
+
+ return index;
+ }
+
+ private void override(String thisClassname, Method meth, String prefix,
+ int index, String desc, ClassFile cf, ConstPool cp)
+ throws CannotCompileException
+ {
+ Class declClass = meth.getDeclaringClass();
+ String delegatorName = prefix + index + meth.getName();
+ if (Modifier.isAbstract(meth.getModifiers()))
+ delegatorName = null;
+ else {
+ MethodInfo delegator
+ = makeDelegator(meth, desc, cp, declClass, delegatorName);
+ // delegator is not a bridge method. See Sec. 15.12.4.5 of JLS 3rd Ed.
+ delegator.setAccessFlags(delegator.getAccessFlags() & ~AccessFlag.BRIDGE);
+ cf.addMethod(delegator);
+ }
+
+ MethodInfo forwarder
+ = makeForwarder(thisClassname, meth, desc, cp, declClass,
+ delegatorName, index);
+ cf.addMethod(forwarder);
+ }
+
+ private void makeConstructors(String thisClassName, ClassFile cf,
+ ConstPool cp, String classname) throws CannotCompileException
+ {
+ Constructor[] cons = SecurityActions.getDeclaredConstructors(superClass);
+ // legacy: if we are not caching then we need to initialise the default handler
+ boolean doHandlerInit = !factoryUseCache;
+ for (int i = 0; i < cons.length; i++) {
+ Constructor c = cons[i];
+ int mod = c.getModifiers();
+ if (!Modifier.isFinal(mod) && !Modifier.isPrivate(mod)
+ && isVisible(mod, basename, c)) {
+ MethodInfo m = makeConstructor(thisClassName, c, cp, superClass, doHandlerInit);
+ cf.addMethod(m);
+ }
+ }
+ }
+
+ private static String makeUniqueName(String name, List sortedMethods) {
+ if (makeUniqueName0(name, sortedMethods.iterator()))
+ return name;
+
+ for (int i = 100; i < 999; i++) {
+ String s = name + i;
+ if (makeUniqueName0(s, sortedMethods.iterator()))
+ return s;
+ }
+
+ throw new RuntimeException("cannot make a unique method name");
+ }
+
+ private static boolean makeUniqueName0(String name, Iterator it) {
+ while (it.hasNext()) {
+ Map.Entry e = (Map.Entry)it.next();
+ String key = (String)e.getKey();
+ if (key.startsWith(name))
+ return false;
+ }
+
+ return true;
+ }
+
+ /**
+ * Returns true if the method is visible from the package.
+ *
+ * @param mod the modifiers of the method.
+ */
+ private static boolean isVisible(int mod, String from, Member meth) {
+ if ((mod & Modifier.PRIVATE) != 0)
+ return false;
+ else if ((mod & (Modifier.PUBLIC | Modifier.PROTECTED)) != 0)
+ return true;
+ else {
+ String p = getPackageName(from);
+ String q = getPackageName(meth.getDeclaringClass().getName());
+ if (p == null)
+ return q == null;
+ else
+ return p.equals(q);
+ }
+ }
+
+ private static String getPackageName(String name) {
+ int i = name.lastIndexOf('.');
+ if (i < 0)
+ return null;
+ else
+ return name.substring(0, i);
+ }
+
+ private static HashMap getMethods(Class superClass, Class[] interfaceTypes) {
+ HashMap hash = new HashMap();
+ for (int i = 0; i < interfaceTypes.length; i++)
+ getMethods(hash, interfaceTypes[i]);
+
+ getMethods(hash, superClass);
+ return hash;
+ }
+
+ private static void getMethods(HashMap hash, Class clazz) {
+ Class[] ifs = clazz.getInterfaces();
+ for (int i = 0; i < ifs.length; i++)
+ getMethods(hash, ifs[i]);
+
+ Class parent = clazz.getSuperclass();
+ if (parent != null)
+ getMethods(hash, parent);
+
+ Method[] methods = SecurityActions.getDeclaredMethods(clazz);
+ for (int i = 0; i < methods.length; i++)
+ if (!Modifier.isPrivate(methods[i].getModifiers())) {
+ Method m = methods[i];
+ String key = m.getName() + ':' + RuntimeSupport.makeDescriptor(m);
+ // JIRA JASSIST-85
+ // put the method to the cache, retrieve previous definition (if any)
+ Method oldMethod = (Method)hash.put(key, methods[i]);
+
+ // check if visibility has been reduced
+ if (null != oldMethod && Modifier.isPublic(oldMethod.getModifiers())
+ && !Modifier.isPublic(methods[i].getModifiers()) ) {
+ // we tried to overwrite a public definition with a non-public definition,
+ // use the old definition instead.
+ hash.put(key, oldMethod);
+ }
+ }
+ }
+
+ private static String keyToDesc(String key) {
+ return key.substring(key.indexOf(':') + 1);
+ }
+
+ private static MethodInfo makeConstructor(String thisClassName, Constructor cons,
+ ConstPool cp, Class superClass, boolean doHandlerInit) {
+ String desc = RuntimeSupport.makeDescriptor(cons.getParameterTypes(),
+ Void.TYPE);
+ MethodInfo minfo = new MethodInfo(cp, "<init>", desc);
+ minfo.setAccessFlags(Modifier.PUBLIC); // cons.getModifiers() & ~Modifier.NATIVE
+ setThrows(minfo, cp, cons.getExceptionTypes());
+ Bytecode code = new Bytecode(cp, 0, 0);
+
+ // legacy: if we are not using caching then we initialise the instance's handler
+ // from the class's static default interceptor and skip the next few instructions if
+ // it is non-null
+ if (doHandlerInit) {
+ code.addAload(0);
+ code.addGetstatic(thisClassName, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
+ code.addPutfield(thisClassName, HANDLER, HANDLER_TYPE);
+ code.addGetstatic(thisClassName, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
+ code.addOpcode(Opcode.IFNONNULL);
+ code.addIndex(10);
+ }
+ // if caching is enabled then we don't have a handler to initialise so this else branch will install
+ // the handler located in the static field of class RuntimeSupport.
+ code.addAload(0);
+ code.addGetstatic(NULL_INTERCEPTOR_HOLDER, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
+ code.addPutfield(thisClassName, HANDLER, HANDLER_TYPE);
+ int pc = code.currentPc();
+
+ code.addAload(0);
+ int s = addLoadParameters(code, cons.getParameterTypes(), 1);
+ code.addInvokespecial(superClass.getName(), "<init>", desc);
+ code.addOpcode(Opcode.RETURN);
+ code.setMaxLocals(s + 1);
+ CodeAttribute ca = code.toCodeAttribute();
+ minfo.setCodeAttribute(ca);
+
+ StackMapTable.Writer writer = new StackMapTable.Writer(32);
+ writer.sameFrame(pc);
+ ca.setAttribute(writer.toStackMapTable(cp));
+ return minfo;
+ }
+
+ private static MethodInfo makeDelegator(Method meth, String desc,
+ ConstPool cp, Class declClass, String delegatorName) {
+ MethodInfo delegator = new MethodInfo(cp, delegatorName, desc);
+ delegator.setAccessFlags(Modifier.FINAL | Modifier.PUBLIC
+ | (meth.getModifiers() & ~(Modifier.PRIVATE
+ | Modifier.PROTECTED
+ | Modifier.ABSTRACT
+ | Modifier.NATIVE
+ | Modifier.SYNCHRONIZED)));
+ setThrows(delegator, cp, meth);
+ Bytecode code = new Bytecode(cp, 0, 0);
+ code.addAload(0);
+ int s = addLoadParameters(code, meth.getParameterTypes(), 1);
+ code.addInvokespecial(declClass.getName(), meth.getName(), desc);
+ addReturn(code, meth.getReturnType());
+ code.setMaxLocals(++s);
+ delegator.setCodeAttribute(code.toCodeAttribute());
+ return delegator;
+ }
+
+ /**
+ * @param delegatorName null if the original method is abstract.
+ */
+ private static MethodInfo makeForwarder(String thisClassName,
+ Method meth, String desc, ConstPool cp,
+ Class declClass, String delegatorName, int index) {
+ MethodInfo forwarder = new MethodInfo(cp, meth.getName(), desc);
+ forwarder.setAccessFlags(Modifier.FINAL
+ | (meth.getModifiers() & ~(Modifier.ABSTRACT
+ | Modifier.NATIVE
+ | Modifier.SYNCHRONIZED)));
+ setThrows(forwarder, cp, meth);
+ int args = Descriptor.paramSize(desc);
+ Bytecode code = new Bytecode(cp, 0, args + 2);
+ /*
+ * if (methods[index * 2] == null) {
+ * methods[index * 2]
+ * = RuntimeSupport.findSuperMethod(this, <overridden name>, <desc>);
+ * methods[index * 2 + 1]
+ * = RuntimeSupport.findMethod(this, <delegator name>, <desc>);
+ * or = null // the original method is abstract.
+ * }
+ * return ($r)handler.invoke(this, methods[index * 2],
+ * methods[index * 2 + 1], $args);
+ */
+ int origIndex = index * 2;
+ int delIndex = index * 2 + 1;
+ int arrayVar = args + 1;
+ code.addGetstatic(thisClassName, HOLDER, HOLDER_TYPE);
+ code.addAstore(arrayVar);
+
+ callFind2Methods(code, meth.getName(), delegatorName, origIndex, desc, arrayVar);
+
+ code.addAload(0);
+ code.addGetfield(thisClassName, HANDLER, HANDLER_TYPE);
+ code.addAload(0);
+
+ code.addAload(arrayVar);
+ code.addIconst(origIndex);
+ code.addOpcode(Opcode.AALOAD);
+
+ code.addAload(arrayVar);
+ code.addIconst(delIndex);
+ code.addOpcode(Opcode.AALOAD);
+
+ makeParameterList(code, meth.getParameterTypes());
+ code.addInvokeinterface(MethodHandler.class.getName(), "invoke",
+ "(Ljava/lang/Object;Ljava/lang/reflect/Method;Ljava/lang/reflect/Method;[Ljava/lang/Object;)Ljava/lang/Object;",
+ 5);
+ Class retType = meth.getReturnType();
+ addUnwrapper(code, retType);
+ addReturn(code, retType);
+
+ CodeAttribute ca = code.toCodeAttribute();
+ forwarder.setCodeAttribute(ca);
+ return forwarder;
+ }
+
+ private static void setThrows(MethodInfo minfo, ConstPool cp, Method orig) {
+ Class[] exceptions = orig.getExceptionTypes();
+ setThrows(minfo, cp, exceptions);
+ }
+
+ private static void setThrows(MethodInfo minfo, ConstPool cp,
+ Class[] exceptions) {
+ if (exceptions.length == 0)
+ return;
+
+ String[] list = new String[exceptions.length];
+ for (int i = 0; i < exceptions.length; i++)
+ list[i] = exceptions[i].getName();
+
+ ExceptionsAttribute ea = new ExceptionsAttribute(cp);
+ ea.setExceptions(list);
+ minfo.setExceptionsAttribute(ea);
+ }
+
+ private static int addLoadParameters(Bytecode code, Class[] params,
+ int offset) {
+ int stacksize = 0;
+ int n = params.length;
+ for (int i = 0; i < n; ++i)
+ stacksize += addLoad(code, stacksize + offset, params[i]);
+
+ return stacksize;
+ }
+
+ private static int addLoad(Bytecode code, int n, Class type) {
+ if (type.isPrimitive()) {
+ if (type == Long.TYPE) {
+ code.addLload(n);
+ return 2;
+ }
+ else if (type == Float.TYPE)
+ code.addFload(n);
+ else if (type == Double.TYPE) {
+ code.addDload(n);
+ return 2;
+ }
+ else
+ code.addIload(n);
+ }
+ else
+ code.addAload(n);
+
+ return 1;
+ }
+
+ private static int addReturn(Bytecode code, Class type) {
+ if (type.isPrimitive()) {
+ if (type == Long.TYPE) {
+ code.addOpcode(Opcode.LRETURN);
+ return 2;
+ }
+ else if (type == Float.TYPE)
+ code.addOpcode(Opcode.FRETURN);
+ else if (type == Double.TYPE) {
+ code.addOpcode(Opcode.DRETURN);
+ return 2;
+ }
+ else if (type == Void.TYPE) {
+ code.addOpcode(Opcode.RETURN);
+ return 0;
+ }
+ else
+ code.addOpcode(Opcode.IRETURN);
+ }
+ else
+ code.addOpcode(Opcode.ARETURN);
+
+ return 1;
+ }
+
+ private static void makeParameterList(Bytecode code, Class[] params) {
+ int regno = 1;
+ int n = params.length;
+ code.addIconst(n);
+ code.addAnewarray("java/lang/Object");
+ for (int i = 0; i < n; i++) {
+ code.addOpcode(Opcode.DUP);
+ code.addIconst(i);
+ Class type = params[i];
+ if (type.isPrimitive())
+ regno = makeWrapper(code, type, regno);
+ else {
+ code.addAload(regno);
+ regno++;
+ }
+
+ code.addOpcode(Opcode.AASTORE);
+ }
+ }
+
+ private static int makeWrapper(Bytecode code, Class type, int regno) {
+ int index = FactoryHelper.typeIndex(type);
+ String wrapper = FactoryHelper.wrapperTypes[index];
+ code.addNew(wrapper);
+ code.addOpcode(Opcode.DUP);
+ addLoad(code, regno, type);
+ code.addInvokespecial(wrapper, "<init>",
+ FactoryHelper.wrapperDesc[index]);
+ return regno + FactoryHelper.dataSize[index];
+ }
+
+ /**
+ * @param thisMethod might be null.
+ */
+ private static void callFind2Methods(Bytecode code, String superMethod, String thisMethod,
+ int index, String desc, int arrayVar) {
+ String findClass = RuntimeSupport.class.getName();
+ String findDesc
+ = "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;[Ljava/lang/reflect/Method;)V";
+
+ code.addAload(0);
+ code.addLdc(superMethod);
+ if (thisMethod == null)
+ code.addOpcode(Opcode.ACONST_NULL);
+ else
+ code.addLdc(thisMethod);
+
+ code.addIconst(index);
+ code.addLdc(desc);
+ code.addAload(arrayVar);
+ code.addInvokestatic(findClass, "find2Methods", findDesc);
+ }
+
+ private static void addUnwrapper(Bytecode code, Class type) {
+ if (type.isPrimitive()) {
+ if (type == Void.TYPE)
+ code.addOpcode(Opcode.POP);
+ else {
+ int index = FactoryHelper.typeIndex(type);
+ String wrapper = FactoryHelper.wrapperTypes[index];
+ code.addCheckcast(wrapper);
+ code.addInvokevirtual(wrapper,
+ FactoryHelper.unwarpMethods[index],
+ FactoryHelper.unwrapDesc[index]);
+ }
+ }
+ else
+ code.addCheckcast(type.getName());
+ }
+
+ private static MethodInfo makeWriteReplace(ConstPool cp) {
+ MethodInfo minfo = new MethodInfo(cp, "writeReplace", "()Ljava/lang/Object;");
+ String[] list = new String[1];
+ list[0] = "java.io.ObjectStreamException";
+ ExceptionsAttribute ea = new ExceptionsAttribute(cp);
+ ea.setExceptions(list);
+ minfo.setExceptionsAttribute(ea);
+ Bytecode code = new Bytecode(cp, 0, 1);
+ code.addAload(0);
+ code.addInvokestatic("javassist.util.proxy.RuntimeSupport",
+ "makeSerializedProxy",
+ "(Ljava/lang/Object;)Ljavassist/util/proxy/SerializedProxy;");
+ code.addOpcode(Opcode.ARETURN);
+ minfo.setCodeAttribute(code.toCodeAttribute());
+ return minfo;
+ }
+}
diff --git a/src/main/javassist/util/proxy/ProxyObject.java b/src/main/javassist/util/proxy/ProxyObject.java
new file mode 100644
index 0000000..08febd6
--- /dev/null
+++ b/src/main/javassist/util/proxy/ProxyObject.java
@@ -0,0 +1,36 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+/**
+ * The interface implemented by proxy classes.
+ *
+ * @see ProxyFactory
+ */
+public interface ProxyObject {
+ /**
+ * Sets a handler. It can be used for changing handlers
+ * during runtime.
+ */
+ void setHandler(MethodHandler mi);
+
+ /**
+ * Get the handler.
+ * This can be used to access values of the underlying MethodHandler
+ * or to serialize it properly.
+ */
+ MethodHandler getHandler();
+}
diff --git a/src/main/javassist/util/proxy/ProxyObjectInputStream.java b/src/main/javassist/util/proxy/ProxyObjectInputStream.java
new file mode 100644
index 0000000..62c5eea
--- /dev/null
+++ b/src/main/javassist/util/proxy/ProxyObjectInputStream.java
@@ -0,0 +1,99 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectStreamClass;
+
+/**
+ * An input stream class which knows how to deserialize proxies created via {@link ProxyFactory} and
+ * serializedo via a {@link ProxyObjectOutputStream}. It must be used when deserialising proxies created
+ * from a proxy factory configured with {@link ProxyFactory#useWriteReplace} set to false.
+ *
+ * @author Andrew Dinn
+ */
+public class ProxyObjectInputStream extends ObjectInputStream
+{
+ /**
+ * create an input stream which can be used to deserialize an object graph which includes proxies created
+ * using class ProxyFactory. the classloader used to resolve proxy superclass and interface names
+ * read from the input stream will default to the current thread's context class loader or the system
+ * classloader if the context class loader is null.
+ * @param in
+ * @throws java.io.StreamCorruptedException whenever ObjectInputStream would also do so
+ * @throws IOException whenever ObjectInputStream would also do so
+ * @throws SecurityException whenever ObjectInputStream would also do so
+ * @throws NullPointerException if in is null
+ */
+ public ProxyObjectInputStream(InputStream in) throws IOException
+ {
+ super(in);
+ loader = Thread.currentThread().getContextClassLoader();
+ if (loader == null) {
+ loader = ClassLoader.getSystemClassLoader();
+ }
+ }
+
+ /**
+ * Reset the loader to be
+ * @param loader
+ */
+ public void setClassLoader(ClassLoader loader)
+ {
+ if (loader != null) {
+ this.loader = loader;
+ } else {
+ loader = ClassLoader.getSystemClassLoader();
+ }
+ }
+
+ protected ObjectStreamClass readClassDescriptor() throws IOException, ClassNotFoundException {
+ boolean isProxy = readBoolean();
+ if (isProxy) {
+ String name = (String)readObject();
+ Class superClass = loader.loadClass(name);
+ int length = readInt();
+ Class[] interfaces = new Class[length];
+ for (int i = 0; i < length; i++) {
+ name = (String)readObject();
+ interfaces[i] = loader.loadClass(name);
+ }
+ length = readInt();
+ byte[] signature = new byte[length];
+ read(signature);
+ ProxyFactory factory = new ProxyFactory();
+ // we must always use the cache and never use writeReplace when using
+ // ProxyObjectOutputStream and ProxyObjectInputStream
+ factory.setUseCache(true);
+ factory.setUseWriteReplace(false);
+ factory.setSuperclass(superClass);
+ factory.setInterfaces(interfaces);
+ Class proxyClass = factory.createClass(signature);
+ return ObjectStreamClass.lookup(proxyClass);
+ } else {
+ return super.readClassDescriptor();
+ }
+ }
+
+ /**
+ * the loader to use to resolve classes for proxy superclass and interface names read
+ * from the stream. defaults to the context class loader of the thread which creates
+ * the input stream or the system class loader if the context class loader is null.
+ */
+ private ClassLoader loader;
+}
\ No newline at end of file
diff --git a/src/main/javassist/util/proxy/ProxyObjectOutputStream.java b/src/main/javassist/util/proxy/ProxyObjectOutputStream.java
new file mode 100644
index 0000000..b2f8bd4
--- /dev/null
+++ b/src/main/javassist/util/proxy/ProxyObjectOutputStream.java
@@ -0,0 +1,71 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2010 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.ObjectStreamClass;
+import java.io.OutputStream;
+
+/**
+ * An input stream class which knows how to serialize proxies created via {@link ProxyFactory}. It must
+ * be used when serialising proxies created from a proxy factory configured with
+ * {@link ProxyFactory#useWriteReplace} set to false. Subsequent deserialization of the serialized data
+ * must employ a {@link ProxyObjectInputStream}
+ *
+ * @author Andrew Dinn
+ */
+public class ProxyObjectOutputStream extends ObjectOutputStream
+{
+ /**
+ * create an output stream which can be used to serialize an object graph which includes proxies created
+ * using class ProxyFactory
+ * @param out
+ * @throws IOException whenever ObjectOutputStream would also do so
+ * @throws SecurityException whenever ObjectOutputStream would also do so
+ * @throws NullPointerException if out is null
+ */
+ public ProxyObjectOutputStream(OutputStream out) throws IOException
+ {
+ super(out);
+ }
+
+ protected void writeClassDescriptor(ObjectStreamClass desc) throws IOException {
+ Class cl = desc.forClass();
+ if (ProxyFactory.isProxyClass(cl)) {
+ writeBoolean(true);
+ Class superClass = cl.getSuperclass();
+ Class[] interfaces = cl.getInterfaces();
+ byte[] signature = ProxyFactory.getFilterSignature(cl);
+ String name = superClass.getName();
+ writeObject(name);
+ // we don't write the marker interface ProxyObject
+ writeInt(interfaces.length - 1);
+ for (int i = 0; i < interfaces.length; i++) {
+ Class interfaze = interfaces[i];
+ if (interfaze != ProxyObject.class) {
+ name = interfaces[i].getName();
+ writeObject(name);
+ }
+ }
+ writeInt(signature.length);
+ write(signature);
+ } else {
+ writeBoolean(false);
+ super.writeClassDescriptor(desc);
+ }
+ }
+}
diff --git a/src/main/javassist/util/proxy/RuntimeSupport.java b/src/main/javassist/util/proxy/RuntimeSupport.java
new file mode 100644
index 0000000..817ab4c
--- /dev/null
+++ b/src/main/javassist/util/proxy/RuntimeSupport.java
@@ -0,0 +1,211 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.lang.reflect.Method;
+import java.io.Serializable;
+
+/**
+ * Runtime support routines that the classes generated by ProxyFactory use.
+ *
+ * @see ProxyFactory
+ */
+public class RuntimeSupport {
+ /**
+ * A method handler that only executes a method.
+ */
+ public static MethodHandler default_interceptor = new DefaultMethodHandler();
+
+ static class DefaultMethodHandler implements MethodHandler, Serializable {
+ public Object invoke(Object self, Method m,
+ Method proceed, Object[] args)
+ throws Exception
+ {
+ return proceed.invoke(self, args);
+ }
+ };
+
+ /**
+ * Finds two methods specified by the parameters and stores them
+ * into the given array.
+ *
+ * @throws RuntimeException if the methods are not found.
+ * @see javassist.util.proxy.ProxyFactory
+ */
+ public static void find2Methods(Object self, String superMethod,
+ String thisMethod, int index,
+ String desc, java.lang.reflect.Method[] methods)
+ {
+ synchronized (methods) {
+ if (methods[index] == null) {
+ methods[index + 1] = thisMethod == null ? null
+ : findMethod(self, thisMethod, desc);
+ methods[index] = findSuperMethod(self, superMethod, desc);
+ }
+ }
+ }
+
+ /**
+ * Finds a method with the given name and descriptor.
+ * It searches only the class of self.
+ *
+ * @throws RuntimeException if the method is not found.
+ */
+ public static Method findMethod(Object self, String name, String desc) {
+ Method m = findMethod2(self.getClass(), name, desc);
+ if (m == null)
+ error(self, name, desc);
+
+ return m;
+ }
+
+ /**
+ * Finds a method that has the given name and descriptor and is declared
+ * in the super class.
+ *
+ * @throws RuntimeException if the method is not found.
+ */
+ public static Method findSuperMethod(Object self, String name, String desc) {
+ Class clazz = self.getClass();
+ Method m = findSuperMethod2(clazz.getSuperclass(), name, desc);
+ if (m == null)
+ m = searchInterfaces(clazz, name, desc);
+
+ if (m == null)
+ error(self, name, desc);
+
+ return m;
+ }
+
+ private static void error(Object self, String name, String desc) {
+ throw new RuntimeException("not found " + name + ":" + desc
+ + " in " + self.getClass().getName());
+ }
+
+ private static Method findSuperMethod2(Class clazz, String name, String desc) {
+ Method m = findMethod2(clazz, name, desc);
+ if (m != null)
+ return m;
+
+ Class superClass = clazz.getSuperclass();
+ if (superClass != null) {
+ m = findSuperMethod2(superClass, name, desc);
+ if (m != null)
+ return m;
+ }
+
+ return searchInterfaces(clazz, name, desc);
+ }
+
+ private static Method searchInterfaces(Class clazz, String name, String desc) {
+ Method m = null;
+ Class[] interfaces = clazz.getInterfaces();
+ for (int i = 0; i < interfaces.length; i++) {
+ m = findSuperMethod2(interfaces[i], name, desc);
+ if (m != null)
+ return m;
+ }
+
+ return m;
+ }
+
+ private static Method findMethod2(Class clazz, String name, String desc) {
+ Method[] methods = SecurityActions.getDeclaredMethods(clazz);
+ int n = methods.length;
+ for (int i = 0; i < n; i++)
+ if (methods[i].getName().equals(name)
+ && makeDescriptor(methods[i]).equals(desc))
+ return methods[i];
+
+ return null;
+ }
+
+ /**
+ * Makes a descriptor for a given method.
+ */
+ public static String makeDescriptor(Method m) {
+ Class[] params = m.getParameterTypes();
+ return makeDescriptor(params, m.getReturnType());
+ }
+
+ /**
+ * Makes a descriptor for a given method.
+ *
+ * @param params parameter types.
+ * @param retType return type.
+ */
+ public static String makeDescriptor(Class[] params, Class retType) {
+ StringBuffer sbuf = new StringBuffer();
+ sbuf.append('(');
+ for (int i = 0; i < params.length; i++)
+ makeDesc(sbuf, params[i]);
+
+ sbuf.append(')');
+ makeDesc(sbuf, retType);
+ return sbuf.toString();
+ }
+
+ private static void makeDesc(StringBuffer sbuf, Class type) {
+ if (type.isArray()) {
+ sbuf.append('[');
+ makeDesc(sbuf, type.getComponentType());
+ }
+ else if (type.isPrimitive()) {
+ if (type == Void.TYPE)
+ sbuf.append('V');
+ else if (type == Integer.TYPE)
+ sbuf.append('I');
+ else if (type == Byte.TYPE)
+ sbuf.append('B');
+ else if (type == Long.TYPE)
+ sbuf.append('J');
+ else if (type == Double.TYPE)
+ sbuf.append('D');
+ else if (type == Float.TYPE)
+ sbuf.append('F');
+ else if (type == Character.TYPE)
+ sbuf.append('C');
+ else if (type == Short.TYPE)
+ sbuf.append('S');
+ else if (type == Boolean.TYPE)
+ sbuf.append('Z');
+ else
+ throw new RuntimeException("bad type: " + type.getName());
+ }
+ else
+ sbuf.append('L').append(type.getName().replace('.', '/'))
+ .append(';');
+ }
+
+ /**
+ * Converts a proxy object to an object that is writable to an
+ * object stream. This method is called by <code>writeReplace()</code>
+ * in a proxy class.
+ *
+ * @since 3.4
+ */
+ public static SerializedProxy makeSerializedProxy(Object proxy)
+ throws java.io.InvalidClassException
+ {
+ Class clazz = proxy.getClass();
+
+ MethodHandler methodHandler = null;
+ if (proxy instanceof ProxyObject)
+ methodHandler = ((ProxyObject)proxy).getHandler();
+
+ return new SerializedProxy(clazz, ProxyFactory.getFilterSignature(clazz), methodHandler);
+ }
+}
diff --git a/src/main/javassist/util/proxy/SecurityActions.java b/src/main/javassist/util/proxy/SecurityActions.java
new file mode 100644
index 0000000..40741e4
--- /dev/null
+++ b/src/main/javassist/util/proxy/SecurityActions.java
@@ -0,0 +1,135 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+package javassist.util.proxy;
+
+import java.lang.reflect.AccessibleObject;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+
+class SecurityActions {
+ static Method[] getDeclaredMethods(final Class clazz) {
+ if (System.getSecurityManager() == null)
+ return clazz.getDeclaredMethods();
+ else {
+ return (Method[]) AccessController
+ .doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ return clazz.getDeclaredMethods();
+ }
+ });
+ }
+ }
+
+ static Constructor[] getDeclaredConstructors(final Class clazz) {
+ if (System.getSecurityManager() == null)
+ return clazz.getDeclaredConstructors();
+ else {
+ return (Constructor[]) AccessController
+ .doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ return clazz.getDeclaredConstructors();
+ }
+ });
+ }
+ }
+
+ static Method getDeclaredMethod(final Class clazz, final String name,
+ final Class[] types) throws NoSuchMethodException {
+ if (System.getSecurityManager() == null)
+ return clazz.getDeclaredMethod(name, types);
+ else {
+ try {
+ return (Method) AccessController
+ .doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws Exception {
+ return clazz.getDeclaredMethod(name, types);
+ }
+ });
+ }
+ catch (PrivilegedActionException e) {
+ if (e.getCause() instanceof NoSuchMethodException)
+ throw (NoSuchMethodException) e.getCause();
+
+ throw new RuntimeException(e.getCause());
+ }
+ }
+ }
+
+ static Constructor getDeclaredConstructor(final Class clazz,
+ final Class[] types)
+ throws NoSuchMethodException
+ {
+ if (System.getSecurityManager() == null)
+ return clazz.getDeclaredConstructor(types);
+ else {
+ try {
+ return (Constructor) AccessController
+ .doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws Exception {
+ return clazz.getDeclaredConstructor(types);
+ }
+ });
+ }
+ catch (PrivilegedActionException e) {
+ if (e.getCause() instanceof NoSuchMethodException)
+ throw (NoSuchMethodException) e.getCause();
+
+ throw new RuntimeException(e.getCause());
+ }
+ }
+ }
+
+ static void setAccessible(final AccessibleObject ao,
+ final boolean accessible) {
+ if (System.getSecurityManager() == null)
+ ao.setAccessible(accessible);
+ else {
+ AccessController.doPrivileged(new PrivilegedAction() {
+ public Object run() {
+ ao.setAccessible(accessible);
+ return null;
+ }
+ });
+ }
+ }
+
+ static void set(final Field fld, final Object target, final Object value)
+ throws IllegalAccessException
+ {
+ if (System.getSecurityManager() == null)
+ fld.set(target, value);
+ else {
+ try {
+ AccessController.doPrivileged(new PrivilegedExceptionAction() {
+ public Object run() throws Exception {
+ fld.set(target, value);
+ return null;
+ }
+ });
+ }
+ catch (PrivilegedActionException e) {
+ if (e.getCause() instanceof NoSuchMethodException)
+ throw (IllegalAccessException) e.getCause();
+
+ throw new RuntimeException(e.getCause());
+ }
+ }
+ }
+}
diff --git a/src/main/javassist/util/proxy/SerializedProxy.java b/src/main/javassist/util/proxy/SerializedProxy.java
new file mode 100644
index 0000000..cddfab4
--- /dev/null
+++ b/src/main/javassist/util/proxy/SerializedProxy.java
@@ -0,0 +1,97 @@
+/*
+ * Javassist, a Java-bytecode translator toolkit.
+ * Copyright (C) 1999-2007 Shigeru Chiba. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Mozilla Public License Version
+ * 1.1 (the "License"); you may not use this file except in compliance with
+ * the License. Alternatively, the contents of this file may be used under
+ * the terms of the GNU Lesser General Public License Version 2.1 or later.
+ *
+ * Software distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
+ * for the specific language governing rights and limitations under the
+ * License.
+ */
+
+package javassist.util.proxy;
+
+import java.io.Serializable;
+import java.io.ObjectStreamException;
+import java.security.AccessController;
+import java.security.PrivilegedActionException;
+import java.security.PrivilegedExceptionAction;
+import java.security.ProtectionDomain;
+
+/**
+ * A proxy object is converted into an instance of this class
+ * when it is written to an output stream.
+ *
+ * @see RuntimeSupport#makeSerializedProxy(Object)
+ */
+class SerializedProxy implements Serializable {
+ private String superClass;
+ private String[] interfaces;
+ private byte[] filterSignature;
+ private MethodHandler handler;
+
+ SerializedProxy(Class proxy, byte[] sig, MethodHandler h) {
+ filterSignature = sig;
+ handler = h;
+ superClass = proxy.getSuperclass().getName();
+ Class[] infs = proxy.getInterfaces();
+ int n = infs.length;
+ interfaces = new String[n - 1];
+ String setterInf = ProxyObject.class.getName();
+ for (int i = 0; i < n; i++) {
+ String name = infs[i].getName();
+ if (!name.equals(setterInf))
+ interfaces[i] = name;
+ }
+ }
+
+ /**
+ * Load class.
+ *
+ * @param className the class name
+ * @return loaded class
+ * @throws ClassNotFoundException for any error
+ */
+ protected Class loadClass(final String className) throws ClassNotFoundException {
+ try {
+ return (Class)AccessController.doPrivileged(new PrivilegedExceptionAction(){
+ public Object run() throws Exception{
+ ClassLoader cl = Thread.currentThread().getContextClassLoader();
+ return Class.forName(className, true, cl);
+ }
+ });
+ }
+ catch (PrivilegedActionException pae) {
+ throw new RuntimeException("cannot load the class: " + className, pae.getException());
+ }
+ }
+
+ Object readResolve() throws ObjectStreamException {
+ try {
+ int n = interfaces.length;
+ Class[] infs = new Class[n];
+ for (int i = 0; i < n; i++)
+ infs[i] = loadClass(interfaces[i]);
+
+ ProxyFactory f = new ProxyFactory();
+ f.setSuperclass(loadClass(superClass));
+ f.setInterfaces(infs);
+ ProxyObject proxy = (ProxyObject)f.createClass(filterSignature).newInstance();
+ proxy.setHandler(handler);
+ return proxy;
+ }
+ catch (ClassNotFoundException e) {
+ throw new java.io.InvalidClassException(e.getMessage());
+ }
+ catch (InstantiationException e2) {
+ throw new java.io.InvalidObjectException(e2.getMessage());
+ }
+ catch (IllegalAccessException e3) {
+ throw new java.io.InvalidClassException(e3.getMessage());
+ }
+ }
+}
diff --git a/src/main/javassist/util/proxy/package.html b/src/main/javassist/util/proxy/package.html
new file mode 100644
index 0000000..6c77804
--- /dev/null
+++ b/src/main/javassist/util/proxy/package.html
@@ -0,0 +1,6 @@
+<html>
+<body>
+Dynamic proxy (similar to <code>Enhancer</code> of <a href="http://cglib.sourceforge.net/">cglib</a>).
+See <code>ProxyFactory</code> for more details.
+</body>
+</html>
diff --git a/src/test/test/javassist/bytecode/analysis/AnalyzerTest.java b/src/test/test/javassist/bytecode/analysis/AnalyzerTest.java
new file mode 100644
index 0000000..0c5a77e
--- /dev/null
+++ b/src/test/test/javassist/bytecode/analysis/AnalyzerTest.java
@@ -0,0 +1,411 @@
+package test.javassist.bytecode.analysis;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Iterator;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.BadBytecode;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.CodeIterator;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+import javassist.bytecode.analysis.Analyzer;
+import javassist.bytecode.analysis.Frame;
+import javassist.bytecode.analysis.Type;
+import junit.framework.TestCase;
+
+/**
+ * Tests Analyzer
+ *
+ * @author Jason T. Greene
+ */
+public class AnalyzerTest extends TestCase {
+
+ public void testCommonSupperArray() throws Exception {
+ ClassPool pool = ClassPool.getDefault();
+ CtClass clazz = pool.get(getClass().getName() + "$Dummy");
+ CtMethod method = clazz.getDeclaredMethod("commonSuperArray");
+ verifyArrayLoad(clazz, method, "java.lang.Number");
+ }
+
+ public void testCommonInterfaceArray() throws Exception {
+ ClassPool pool = ClassPool.getDefault();
+ CtClass clazz = pool.get(getClass().getName() + "$Dummy");
+ CtMethod method = clazz.getDeclaredMethod("commonInterfaceArray");
+ verifyArrayLoad(clazz, method, "java.io.Serializable");
+ }
+
+ public void testSharedInterfaceAndSuperClass() throws Exception {
+ CtMethod method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "sharedInterfaceAndSuperClass");
+ verifyReturn(method, "java.io.Serializable");
+
+ method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "sharedOffsetInterfaceAndSuperClass");
+ verifyReturn(method, "java.io.Serializable");
+
+ method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "sharedSuperWithSharedInterface");
+ verifyReturn(method, getClass().getName() + "$Dummy$A");
+ }
+
+ public void testArrayDifferentDims() throws Exception {
+ CtMethod method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "arrayDifferentDimensions1");
+ verifyReturn(method, "java.lang.Cloneable[]");
+
+ method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "arrayDifferentDimensions2");
+ verifyReturn(method, "java.lang.Object[][]");
+ }
+
+ public void testReusedLocalMerge() throws Exception {
+ CtMethod method = ClassPool.getDefault().getMethod(
+ getClass().getName() + "$Dummy", "reusedLocalMerge");
+
+ MethodInfo info = method.getMethodInfo2();
+ Analyzer analyzer = new Analyzer();
+ Frame[] frames = analyzer.analyze(method.getDeclaringClass(), info);
+ assertNotNull(frames);
+ int pos = findOpcode(info, Opcode.RETURN);
+ Frame frame = frames[pos];
+ assertEquals("java.lang.Object", frame.getLocal(2).getCtClass().getName());
+ }
+
+ private static int findOpcode(MethodInfo info, int opcode) throws BadBytecode {
+ CodeIterator iter = info.getCodeAttribute().iterator();
+
+ // find return
+ int pos = 0;
+ while (iter.hasNext()) {
+ pos = iter.next();
+ if (iter.byteAt(pos) == opcode)
+ break;
+ }
+ return pos;
+ }
+
+
+ private static void verifyReturn(CtMethod method, String expected) throws BadBytecode {
+ MethodInfo info = method.getMethodInfo2();
+ CodeIterator iter = info.getCodeAttribute().iterator();
+
+ // find areturn
+ int pos = 0;
+ while (iter.hasNext()) {
+ pos = iter.next();
+ if (iter.byteAt(pos) == Opcode.ARETURN)
+ break;
+ }
+
+ Analyzer analyzer = new Analyzer();
+ Frame[] frames = analyzer.analyze(method.getDeclaringClass(), info);
+ assertNotNull(frames);
+ Frame frame = frames[pos];
+ assertEquals(expected, frame.peek().getCtClass().getName());
+ }
+
+ private static void verifyArrayLoad(CtClass clazz, CtMethod method, String component)
+ throws BadBytecode {
+ MethodInfo info = method.getMethodInfo2();
+ CodeIterator iter = info.getCodeAttribute().iterator();
+
+ // find aaload
+ int pos = 0;
+ while (iter.hasNext()) {
+ pos = iter.next();
+ if (iter.byteAt(pos) == Opcode.AALOAD)
+ break;
+ }
+
+ Analyzer analyzer = new Analyzer();
+ Frame[] frames = analyzer.analyze(clazz, info);
+ assertNotNull(frames);
+ Frame frame = frames[pos];
+ assertNotNull(frame);
+
+ Type type = frame.getStack(frame.getTopIndex() - 1);
+ assertEquals(component + "[]", type.getCtClass().getName());
+
+ pos = iter.next();
+ frame = frames[pos];
+ assertNotNull(frame);
+
+ type = frame.getStack(frame.getTopIndex());
+ assertEquals(component, type.getCtClass().getName());
+ }
+
+ private static void addJump(Bytecode code, int opcode, int pos) {
+ int current = code.currentPc();
+ code.addOpcode(opcode);
+ code.addIndex(pos - current);
+ }
+
+ public void testDeadCode() throws Exception {
+ CtMethod method = generateDeadCode(ClassPool.getDefault());
+ Analyzer analyzer = new Analyzer();
+ Frame[] frames = analyzer.analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ assertNotNull(frames);
+ assertNull(frames[4]);
+ assertNotNull(frames[5]);
+ verifyReturn(method, "java.lang.String");
+ }
+
+ public void testInvalidCode() throws Exception {
+ CtMethod method = generateInvalidCode(ClassPool.getDefault());
+ Analyzer analyzer = new Analyzer();
+ try {
+ analyzer.analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ } catch (BadBytecode e) {
+ return;
+ }
+
+ fail("Invalid code should have triggered a BadBytecode exception");
+ }
+
+ public void testCodeFalloff() throws Exception {
+ CtMethod method = generateCodeFalloff(ClassPool.getDefault());
+ Analyzer analyzer = new Analyzer();
+ try {
+ analyzer.analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ } catch (BadBytecode e) {
+ return;
+ }
+
+ fail("Code falloff should have triggered a BadBytecode exception");
+ }
+
+ public void testJsrMerge() throws Exception {
+ CtMethod method = generateJsrMerge(ClassPool.getDefault());
+ Analyzer analyzer = new Analyzer();
+ analyzer.analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ verifyReturn(method, "java.lang.String");
+ }
+
+ public void testJsrMerge2() throws Exception {
+ CtMethod method = generateJsrMerge2(ClassPool.getDefault());
+ Analyzer analyzer = new Analyzer();
+ analyzer.analyze(method.getDeclaringClass(), method.getMethodInfo2());
+ verifyReturn(method, "java.lang.String");
+ }
+
+ private CtMethod generateDeadCode(ClassPool pool) throws Exception {
+ CtClass clazz = pool.makeClass(getClass().getName() + "$Generated0");
+ CtClass stringClass = pool.get("java.lang.String");
+ CtMethod method = new CtMethod(stringClass, "foo", new CtClass[0], clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ Bytecode code = new Bytecode(info.getConstPool(), 1, 2);
+ /* 0 */ code.addIconst(1);
+ /* 1 */ addJump(code, Opcode.GOTO, 5);
+ /* 4 */ code.addIconst(0); // DEAD
+ /* 5 */ code.addIconst(1);
+ /* 6 */ code.addInvokestatic(stringClass, "valueOf", stringClass, new CtClass[]{CtClass.intType});
+ /* 9 */ code.addOpcode(Opcode.ARETURN);
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+
+ return method;
+ }
+
+ private CtMethod generateInvalidCode(ClassPool pool) throws Exception {
+ CtClass clazz = pool.makeClass(getClass().getName() + "$Generated4");
+ CtClass intClass = pool.get("java.lang.Integer");
+ CtClass stringClass = pool.get("java.lang.String");
+ CtMethod method = new CtMethod(stringClass, "foo", new CtClass[0], clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ Bytecode code = new Bytecode(info.getConstPool(), 1, 2);
+ /* 0 */ code.addIconst(1);
+ /* 1 */ code.addInvokestatic(intClass, "valueOf", intClass, new CtClass[]{CtClass.intType});
+ /* 4 */ code.addOpcode(Opcode.ARETURN);
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+
+ return method;
+ }
+
+
+ private CtMethod generateCodeFalloff(ClassPool pool) throws Exception {
+ CtClass clazz = pool.makeClass(getClass().getName() + "$Generated3");
+ CtClass stringClass = pool.get("java.lang.String");
+ CtMethod method = new CtMethod(stringClass, "foo", new CtClass[0], clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ Bytecode code = new Bytecode(info.getConstPool(), 1, 2);
+ /* 0 */ code.addIconst(1);
+ /* 1 */ code.addInvokestatic(stringClass, "valueOf", stringClass, new CtClass[]{CtClass.intType});
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+
+ return method;
+ }
+
+ private CtMethod generateJsrMerge(ClassPool pool) throws Exception {
+ CtClass clazz = pool.makeClass(getClass().getName() + "$Generated1");
+ CtClass stringClass = pool.get("java.lang.String");
+ CtMethod method = new CtMethod(stringClass, "foo", new CtClass[0], clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ Bytecode code = new Bytecode(info.getConstPool(), 1, 2);
+ /* 0 */ code.addIconst(5);
+ /* 1 */ code.addIstore(0);
+ /* 2 */ addJump(code, Opcode.JSR, 7);
+ /* 5 */ code.addAload(0);
+ /* 6 */ code.addOpcode(Opcode.ARETURN);
+ /* 7 */ code.addAstore(1);
+ /* 8 */ code.addIconst(3);
+ /* 9 */ code.addInvokestatic(stringClass, "valueOf", stringClass, new CtClass[]{CtClass.intType});
+ /* 12 */ code.addAstore(0);
+ /* 12 */ code.addRet(1);
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+ //System.out.println(clazz.toClass().getMethod("foo", new Class[0]).invoke(null, new Object[0]));
+
+ return method;
+ }
+
+ private CtMethod generateJsrMerge2(ClassPool pool) throws Exception {
+ CtClass clazz = pool.makeClass(getClass().getName() + "$Generated2");
+ CtClass stringClass = pool.get("java.lang.String");
+ CtMethod method = new CtMethod(stringClass, "foo", new CtClass[0], clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC | AccessFlag.STATIC);
+ Bytecode code = new Bytecode(info.getConstPool(), 1, 2);
+ /* 0 */ addJump(code, Opcode.JSR, 5);
+ /* 3 */ code.addAload(0);
+ /* 4 */ code.addOpcode(Opcode.ARETURN);
+ /* 5 */ code.addAstore(1);
+ /* 6 */ code.addIconst(4);
+ /* 7 */ code.addInvokestatic(stringClass, "valueOf", stringClass, new CtClass[]{CtClass.intType});
+ /* 10 */ code.addAstore(0);
+ /* 11 */ code.addRet(1);
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+
+ return method;
+ }
+
+ public static class Dummy {
+ public Serializable commonSuperArray(int x) {
+ Number[] n;
+
+ if (x > 5) {
+ n = new Long[10];
+ } else {
+ n = new Double[5];
+ }
+
+ return n[x];
+ }
+
+ public Serializable commonInterfaceArray(int x) {
+ Serializable[] n;
+
+ if (x > 5) {
+ n = new Long[10];
+ } else if (x > 3) {
+ n = new Double[5];
+ } else {
+ n = new String[3];
+ }
+
+ return n[x];
+ }
+
+
+ public static class A {};
+ public static class B1 extends A implements Serializable {};
+ public static class B2 extends A implements Serializable {};
+ public static class A2 implements Serializable, Cloneable {};
+ public static class A3 implements Serializable, Cloneable {};
+
+ public static class B3 extends A {};
+ public static class C31 extends B3 implements Serializable {};
+
+
+ public void dummy(Serializable s) {}
+
+ public Object sharedInterfaceAndSuperClass(int x) {
+ Serializable s;
+
+ if (x > 5) {
+ s = new B1();
+ } else {
+ s = new B2();
+ }
+
+ dummy(s);
+
+ return s;
+ }
+
+ public A sharedSuperWithSharedInterface(int x) {
+ A a;
+
+ if (x > 5) {
+ a = new B1();
+ } else if (x > 3) {
+ a = new B2();
+ } else {
+ a = new C31();
+ }
+
+ return a;
+ }
+
+
+ public void reusedLocalMerge() {
+ ArrayList list = new ArrayList();
+ try {
+ Iterator i = list.iterator();
+ i.hasNext();
+ } catch (Exception e) {
+ }
+ }
+
+ public Object sharedOffsetInterfaceAndSuperClass(int x) {
+ Serializable s;
+
+ if (x > 5) {
+ s = new B1();
+ } else {
+ s = new C31();
+ }
+
+ dummy(s);
+
+ return s;
+ }
+
+
+ public Object arrayDifferentDimensions1(int x) {
+ Object[] n;
+
+ if ( x > 5) {
+ n = new Number[1][1];
+ } else {
+ n = new Cloneable[1];
+ }
+
+
+ return n;
+ }
+
+ public Object arrayDifferentDimensions2(int x) {
+ Object[] n;
+
+ if ( x> 5) {
+ n = new String[1][1];
+ } else {
+ n = new Number[1][1][1][1];
+ }
+
+ return n;
+ }
+ }
+}
diff --git a/src/test/test/javassist/bytecode/analysis/ErrorFinder.java b/src/test/test/javassist/bytecode/analysis/ErrorFinder.java
new file mode 100644
index 0000000..e131ffb
--- /dev/null
+++ b/src/test/test/javassist/bytecode/analysis/ErrorFinder.java
@@ -0,0 +1,63 @@
+package test.javassist.bytecode.analysis;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.bytecode.analysis.Analyzer;
+
+/**
+ * Simple testing tool that verifies class files can be analyzed.
+ *
+ * @author Jason T. Greene
+ */
+public class ErrorFinder {
+
+ public static void main(String[] args) throws Exception {
+ ClassPool pool = ClassPool.getDefault();
+
+ String className = args[0];
+ if (!className.equals("-file")) {
+ analyzeClass(pool, className);
+ return;
+ }
+
+ FileReader reader = new FileReader(args[1]);
+ BufferedReader lineReader = new BufferedReader(reader);
+
+
+ String line = lineReader.readLine();
+ while (line != null) {
+ analyzeClass(pool, line);
+ line = lineReader.readLine();
+ }
+ }
+
+ private static void analyzeClass(ClassPool pool, String className) {
+ try {
+
+ CtClass clazz = pool.get(className);
+ CtMethod[] methods = clazz.getDeclaredMethods();
+ for (int i = 0; i < methods.length; i++)
+ analyzeMethod(clazz, methods[i]);
+ } catch (Throwable e) {
+ System.out.println("FAIL: CLASS: " + className + " " + e.getClass() + ":" + e.getMessage());
+ }
+ }
+
+ private static void analyzeMethod(CtClass clazz, CtMethod method) {
+ String methodName = clazz.getName() + "." + method.getName() + method.getSignature();
+ System.out.println("START: " + methodName);
+ Analyzer analyzer = new Analyzer();
+
+ long time = System.currentTimeMillis();
+ try {
+ analyzer.analyze(clazz, method.getMethodInfo2());
+ System.out.println("SUCCESS: " + methodName + " - " + (System.currentTimeMillis() - time));
+ } catch (Exception e) {
+ System.out.println("FAIL: " + methodName + " - " + (e.getMessage() == null ? e.getClass().getName() : e.getMessage()));
+ }
+ }
+}
diff --git a/src/test/test/javassist/bytecode/analysis/ScannerTest.java b/src/test/test/javassist/bytecode/analysis/ScannerTest.java
new file mode 100644
index 0000000..10f2936
--- /dev/null
+++ b/src/test/test/javassist/bytecode/analysis/ScannerTest.java
@@ -0,0 +1,185 @@
+package test.javassist.bytecode.analysis;
+
+import java.io.IOException;
+
+import javassist.CannotCompileException;
+import javassist.ClassPool;
+import javassist.CtClass;
+import javassist.CtMethod;
+import javassist.NotFoundException;
+import javassist.bytecode.AccessFlag;
+import javassist.bytecode.Bytecode;
+import javassist.bytecode.MethodInfo;
+import javassist.bytecode.Opcode;
+import javassist.bytecode.analysis.Subroutine;
+import javassist.bytecode.analysis.SubroutineScanner;
+import junit.framework.TestCase;
+
+/**
+ * Tests Subroutine Scanner
+ *
+ * @author Jason T. Greene
+ */
+public class ScannerTest extends TestCase {
+
+ public void testNestedFinally() throws Exception {
+ ClassPool pool = ClassPool.getDefault();
+ generate(pool);
+ CtClass clazz = pool.get("test.ScannerTest$GeneratedTest");
+ CtMethod method = clazz.getDeclaredMethod("doit");
+
+ SubroutineScanner scanner = new SubroutineScanner();
+ Subroutine[] subs = scanner.scan(method.getMethodInfo2());
+
+ verifySubroutine(subs, 31, 31, new int[]{125, 25});
+ verifySubroutine(subs, 32, 31, new int[]{125, 25});
+ verifySubroutine(subs, 33, 31, new int[]{125, 25});
+ verifySubroutine(subs, 60, 31, new int[]{125, 25});
+ verifySubroutine(subs, 61, 31, new int[]{125, 25});
+ verifySubroutine(subs, 63, 31, new int[]{125, 25});
+ verifySubroutine(subs, 66, 31, new int[]{125, 25});
+ verifySubroutine(subs, 69, 31, new int[]{125, 25});
+ verifySubroutine(subs, 71, 31, new int[]{125, 25});
+ verifySubroutine(subs, 74, 31, new int[]{125, 25});
+ verifySubroutine(subs, 76, 31, new int[]{125, 25});
+ verifySubroutine(subs, 77, 77, new int[]{111, 71});
+ verifySubroutine(subs, 79, 77, new int[]{111, 71});
+ verifySubroutine(subs, 80, 77, new int[]{111, 71});
+ verifySubroutine(subs, 82, 77, new int[]{111, 71});
+ verifySubroutine(subs, 85, 77, new int[]{111, 71});
+ verifySubroutine(subs, 88, 77, new int[]{111, 71});
+ verifySubroutine(subs, 90, 77, new int[]{111, 71});
+ verifySubroutine(subs, 93, 77, new int[]{111, 71});
+ verifySubroutine(subs, 95, 77, new int[]{111, 71});
+ verifySubroutine(subs, 96, 96, new int[]{106, 90});
+ verifySubroutine(subs, 98, 96, new int[]{106, 90});
+ verifySubroutine(subs, 99, 96, new int[]{106, 90});
+ verifySubroutine(subs, 101, 96, new int[]{106, 90});
+ verifySubroutine(subs, 104, 96, new int[]{106, 90});
+ verifySubroutine(subs, 106, 77, new int[]{111, 71});
+ verifySubroutine(subs, 109, 77, new int[]{111, 71});
+ verifySubroutine(subs, 111, 31, new int[]{125, 25});
+ verifySubroutine(subs, 114, 31, new int[]{125, 25});
+ verifySubroutine(subs, 117, 31, new int[]{125, 25});
+ verifySubroutine(subs, 118, 31, new int[]{125, 25});
+ verifySubroutine(subs, 120, 31, new int[]{125, 25});
+ verifySubroutine(subs, 123, 31, new int[]{125, 25});
+ }
+
+ private static void verifySubroutine(Subroutine[] subs, int pos, int start,
+ int[] callers) {
+ Subroutine sub = subs[pos];
+ assertNotNull(sub);
+ assertEquals(sub.start(), start);
+ for (int i = 0; i < callers.length; i++)
+ assertTrue(sub.callers().contains(new Integer(callers[i])));
+ }
+
+ private static void generate(ClassPool pool) throws CannotCompileException, IOException, NotFoundException {
+ // Generated from eclipse JDK4 compiler:
+ // public void doit(int x) {
+ // println("null");
+ // try {
+ // println("try");
+ // } catch (RuntimeException e) {
+ // e.printStackTrace();
+ // } finally {
+ // switch (x) {
+ // default:
+ // case 15:
+ // try {
+ // println("inner-try");
+ // } finally {
+ // try {
+ // println("inner-inner-try");
+ // } finally {
+ // println("inner-finally");
+ // }
+ // }
+ // break;
+ // case 1789:
+ // println("switch -17");
+ // }
+ // }
+ //}
+
+ CtClass clazz = pool.makeClass("test.ScannerTest$GeneratedTest");
+ CtMethod method = new CtMethod(CtClass.voidType, "doit", new CtClass[] {CtClass.intType}, clazz);
+ MethodInfo info = method.getMethodInfo2();
+ info.setAccessFlags(AccessFlag.PUBLIC);
+ CtClass stringClass = pool.get("java.lang.String");
+ Bytecode code = new Bytecode(info.getConstPool(), 2, 9);
+ /* 0 */ code.addAload(0);
+ /* 1 */ code.addLdc("start");
+ /* 3 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 6 */ code.addAload(0);
+ /* 7 */ code.addLdc("try");
+ /* 9 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 12 */ addJump(code, Opcode.GOTO, 125);
+ /* 14 */ code.addAstore(2);
+ /* 16 */ code.addAload(2);
+ /* 17 */ code.addInvokevirtual("java.lang.Exception", "printStackTrace", "()V");
+ /* 20 */ addJump(code, Opcode.GOTO, 125);
+ /* 23 */ code.addAstore(4);
+ /* 25 */ addJump(code, Opcode.JSR, 31);
+ /* 28 */ code.addAload(4);
+ /* 30 */ code.addOpcode(Opcode.ATHROW);
+ /* 31 */ code.addAstore(3);
+ /* 32 */ code.addIload(1);
+ int spos = code.currentPc();
+ /* 33 */ code.addOpcode(Opcode.LOOKUPSWITCH);
+ code.addIndex(0); // 2 bytes pad - gets us to 36
+ code.add32bit(60 - spos); // default
+ code.add32bit(2); // 2 pairs
+ code.add32bit(15); code.add32bit(60 - spos);
+ code.add32bit(1789); code.add32bit(117 - spos);
+ /* 60 */ code.addAload(0);
+ /* 61 */ code.addLdc("inner-try");
+ /* 63 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 66 */ addJump(code, Opcode.GOTO, 111);
+ /* 69 */ code.addAstore(6);
+ /* 71 */ addJump(code, Opcode.JSR, 77);
+ /* 74 */ code.addAload(6);
+ /* 76 */ code.add(Opcode.ATHROW);
+ /* 77 */ code.addAstore(5);
+ /* 79 */ code.addAload(0);
+ /* 80 */ code.addLdc("inner-inner-try");
+ /* 82 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 85 */ addJump(code, Opcode.GOTO, 106);
+ /* 88 */ code.addAstore(8);
+ /* 90 */ addJump(code, Opcode.JSR, 96);
+ /* 93 */ code.addAload(8);
+ /* 95 */ code.add(Opcode.ATHROW);
+ /* 96 */ code.addAstore(7);
+ /* 98 */ code.addAload(0);
+ /* 99 */ code.addLdc("inner-finally");
+ /* 101 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 104 */ code.addRet(7);
+ /* 106 */ addJump(code, Opcode.JSR, 96);
+ /* 109 */ code.addRet(5);
+ /* 111 */ addJump(code, Opcode.JSR, 77);
+ /* 114 */ addJump(code, Opcode.GOTO, 123);
+ /* 117 */ code.addAload(0);
+ /* 118 */ code.addLdc("switch - 1789");
+ /* 120 */ code.addInvokevirtual(clazz, "println", CtClass.voidType, new CtClass[] {stringClass});
+ /* 123 */ code.addRet(3);
+ /* 125 */ addJump(code, Opcode.JSR, 31);
+ /* 128 */ code.addOpcode(Opcode.RETURN);
+ code.addExceptionHandler(6, 12, 15, "java.lang.RuntimeException");
+ code.addExceptionHandler(6, 20, 23, 0);
+ code.addExceptionHandler(125, 128, 23, 0);
+ code.addExceptionHandler(60, 69, 69, 0);
+ code.addExceptionHandler(111, 114, 69, 0);
+ code.addExceptionHandler(79, 88, 88, 0);
+ code.addExceptionHandler(106, 109, 88, 0);
+ info.setCodeAttribute(code.toCodeAttribute());
+ clazz.addMethod(method);
+ clazz.writeFile("/tmp");
+ }
+
+ private static void addJump(Bytecode code, int opcode, int pos) {
+ int current = code.currentPc();
+ code.addOpcode(opcode);
+ code.addIndex(pos - current);
+ }
+}
diff --git a/src/test/test/javassist/convert/ArrayAccessReplaceTest.java b/src/test/test/javassist/convert/ArrayAccessReplaceTest.java
new file mode 100644
index 0000000..09387ce
--- /dev/null
+++ b/src/test/test/javassist/convert/ArrayAccessReplaceTest.java
@@ -0,0 +1,433 @@
+package test.javassist.convert;
+
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.HashMap;
+import java.util.Map;
+
+import javassist.ClassPool;
+import javassist.CodeConverter;
+import javassist.CtClass;
+import junit.framework.TestCase;
+
+public class ArrayAccessReplaceTest extends TestCase {
+ private static SimpleInterface simple;
+
+ public void setUp() throws Exception {
+ ClassPool pool = new ClassPool(true);
+ CtClass echoClass = pool.get(ArrayAccessReplaceTest.class.getName() + "$Echo");
+ CtClass simpleClass = pool.get(ArrayAccessReplaceTest.class.getName() + "$Simple");
+ CodeConverter converter = new CodeConverter();
+ converter.replaceArrayAccess(echoClass, new CodeConverter.DefaultArrayAccessReplacementMethodNames());
+ simpleClass.instrument(converter);
+ //simpleClass.writeFile("/tmp");
+ simple = (SimpleInterface) simpleClass.toClass(new URLClassLoader(new URL[0], getClass().getClassLoader()), Class.class.getProtectionDomain()).newInstance();
+ }
+
+ public void testComplex() throws Exception {
+ ClassPool pool = new ClassPool(true);
+ CtClass clazz = pool.get(ArrayAccessReplaceTest.class.getName() + "$Complex");
+
+ CodeConverter converter = new CodeConverter();
+ converter.replaceArrayAccess(clazz, new CodeConverter.DefaultArrayAccessReplacementMethodNames());
+ clazz.instrument(converter);
+ ComplexInterface instance = (ComplexInterface) clazz.toClass(new URLClassLoader(new URL[0], getClass().getClassLoader()), Class.class.getProtectionDomain()).newInstance();
+ assertEquals(new Integer(5), instance.complexRead(4));
+ }
+
+ public void testBoolean() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ boolean value = i % 5 == 0;
+ simple.setBoolean(i, value);
+ }
+
+ for (int i = 0; i < 100; i++) {
+ boolean value = i % 5 == 0;
+ assertEquals(value, simple.getBoolean(i));
+ }
+ }
+
+ public void testByte() throws Exception {
+ for (byte i = 0; i < 100; i++) {
+ simple.setByte(i, i);
+ }
+
+ for (byte i = 0; i < 100; i++) {
+ assertEquals(i, simple.getByte(i));
+ }
+ }
+
+ public void testShort() throws Exception {
+ for (short i = 0; i < 100; i++) {
+ simple.setShort(i, i);
+ }
+
+ for (short i = 0; i < 100; i++) {
+ assertEquals(i, simple.getShort(i));
+ }
+ }
+
+ public void testChar() throws Exception {
+ for (char i = 0; i < 100; i++) {
+ simple.setChar(i, i);
+ }
+
+ for (char i = 0; i < 100; i++) {
+ assertEquals(i, simple.getChar(i));
+ }
+ }
+
+ public void testInt() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setInt(i, i);
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals(i, simple.getInt(i));
+ }
+ }
+
+ public void testLong() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setLong(i, i);
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals(i, simple.getLong(i));
+ }
+ }
+
+ public void testFloat() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setFloat(i, i);
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals((float)i, simple.getFloat(i), 0);
+ }
+ }
+
+ public void testDouble() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setDouble(i, i);
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals((double)i, simple.getDouble(i), 0);
+ }
+ }
+
+ public void testObject() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setObject(i, new Integer(i));
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals(new Integer(i), simple.getObject(i));
+ }
+ }
+
+ public void testFoo() throws Exception {
+ for (int i = 0; i < 100; i++) {
+ simple.setFoo(i, new Foo(i));
+ }
+
+ for (int i = 0; i < 100; i++) {
+ assertEquals(new Foo(i), simple.getFoo(i));
+ }
+ }
+
+ public void testMulti() throws Exception {
+ for (int i = 2; i < 100; i++) {
+ simple.setMultiFoo(0, 1, i, new Foo(i));
+ }
+
+ for (int i = 2; i < 100; i++) {
+ assertEquals(new Foo(i), simple.getMultiFoo(0, 1, i));
+ }
+ }
+
+ public static class Echo {
+ public static Map byteMap = new HashMap();
+ public static Map charMap = new HashMap();
+ public static Map doubleMap = new HashMap();
+ public static Map floatMap = new HashMap();
+ public static Map intMap = new HashMap();
+ public static Map longMap = new HashMap();
+ public static Map objectMap = new HashMap();
+ public static Map shortMap = new HashMap();
+
+ public static Object arrayReadObject(Object array, int index) {
+ return objectMap.get(new Integer(index));
+ }
+
+ public static void arrayWriteObject(Object array, int index, Object element) {
+ objectMap.put(new Integer(index), element);
+ }
+
+ public static byte arrayReadByteOrBoolean(Object array, int index) {
+ return ((Byte)byteMap.get(new Integer(index))).byteValue();
+ }
+
+ public static void arrayWriteByteOrBoolean(Object array, int index, byte element) {
+ byteMap.put(new Integer(index), new Byte(element));
+ }
+
+ public static char arrayReadChar(Object array, int index) {
+ return ((Character)charMap.get(new Integer(index))).charValue();
+ }
+
+ public static void arrayWriteChar(Object array, int index, char element) {
+ charMap.put(new Integer(index), new Character(element));
+ }
+
+ public static double arrayReadDouble(Object array, int index) {
+ return ((Double)doubleMap.get(new Integer(index))).doubleValue();
+ }
+
+ public static void arrayWriteDouble(Object array, int index, double element) {
+ doubleMap.put(new Integer(index), new Double(element));
+ }
+
+ public static float arrayReadFloat(Object array, int index) {
+ return ((Float)floatMap.get(new Integer(index))).floatValue();
+ }
+
+ public static void arrayWriteFloat(Object array, int index, float element) {
+ floatMap.put(new Integer(index), new Float(element));
+ }
+
+ public static int arrayReadInt(Object array, int index) {
+ return ((Integer)intMap.get(new Integer(index))).intValue();
+ }
+
+ public static void arrayWriteInt(Object array, int index, int element) {
+ intMap.put(new Integer(index), new Integer(element));
+ }
+
+ public static long arrayReadLong(Object array, int index) {
+ return ((Long)longMap.get(new Integer(index))).longValue();
+ }
+
+ public static void arrayWriteLong(Object array, int index, long element) {
+ longMap.put(new Integer(index), new Long(element));
+ }
+
+ public static short arrayReadShort(Object array, int index) {
+ return ((Short)shortMap.get(new Integer(index))).shortValue();
+ }
+
+ public static void arrayWriteShort(Object array, int index, short element) {
+ shortMap.put(new Integer(index), new Short(element));
+ }
+ }
+
+ public static class Foo {
+ public int bar;
+
+ public Foo(int bar) {
+ this.bar = bar;
+ }
+
+ public int hashCode() {
+ return bar;
+ }
+
+ public boolean equals(Object o) {
+ if (! (o instanceof Foo))
+ return false;
+
+ return ((Foo)o).bar == bar;
+ }
+ }
+
+ public static interface SimpleInterface {
+ public void setBoolean(int pos, boolean value);
+ public boolean getBoolean(int pos);
+
+ public void setByte(int pos, byte value);
+ public byte getByte(int pos);
+
+ public void setShort(int pos, short value);
+ public short getShort(int pos);
+
+ public void setChar(int pos, char value);
+ public char getChar(int pos);
+
+ public void setInt(int pos, int value);
+ public int getInt(int pos);
+
+ public void setLong(int pos, long value);
+ public long getLong(int pos);
+
+ public void setFloat(int pos, float value);
+ public float getFloat(int pos);
+
+ public void setDouble(int pos, double value);
+ public double getDouble(int pos);
+
+ public void setObject(int pos, Object value);
+ public Object getObject(int pos);
+
+ public void setFoo(int pos, Foo value);
+ public Foo getFoo(int pos);
+
+ public void setMultiFoo(int one, int two, int three, Foo foo);
+ public Foo getMultiFoo(int one, int two, int three);
+ }
+
+ public static class Simple implements SimpleInterface {
+ private boolean[] booleans;
+ private byte[] bytes;
+ private short[] shorts;
+ private char[] chars;
+ private int[] ints;
+ private long[] longs;
+ private float[] floats;
+ private double[] doubles;
+ private Object[] objects;
+ private Foo[] foos;
+ private Foo[][][] multi;
+
+ public Simple() {
+ multi[0] = new Foo[0][0];
+ multi[0][1] = new Foo[0];
+ }
+
+ public boolean getBoolean(int pos) {
+ return booleans[pos];
+ }
+
+ public byte getByte(int pos) {
+ return bytes[pos];
+ }
+
+ public char getChar(int pos) {
+ return chars[pos];
+ }
+
+ public double getDouble(int pos) {
+ return doubles[pos];
+ }
+
+ public float getFloat(int pos) {
+ return floats[pos];
+ }
+
+ public Foo getFoo(int pos) {
+ return foos[pos];
+ }
+
+ public int getInt(int pos) {
+ return ints[pos];
+ }
+
+ public long getLong(int pos) {
+ return longs[pos];
+ }
+
+ public Object getObject(int pos) {
+ return objects[pos];
+ }
+
+ public short getShort(int pos) {
+ return shorts[pos];
+ }
+
+ public Foo getMultiFoo(int one, int two, int three) {
+ return multi[one][two][three];
+ }
+
+ public void setBoolean(int pos, boolean value) {
+ booleans[pos] = value;
+ }
+
+ public void setByte(int pos, byte value) {
+ bytes[pos] = value;
+ }
+
+ public void setChar(int pos, char value) {
+ chars[pos] = value;
+ }
+
+ public void setDouble(int pos, double value) {
+ doubles[pos] = value;
+ }
+
+ public void setFloat(int pos, float value) {
+ floats[pos] = value;
+ }
+
+ public void setFoo(int pos, Foo value) {
+ foos[pos] = value;
+ }
+
+ public void setInt(int pos, int value) {
+ ints[pos] = value;
+ }
+
+ public void setLong(int pos, long value) {
+ longs[pos] = value;
+ }
+
+ public void setObject(int pos, Object value) {
+ objects[pos] = value;
+ }
+
+ public void setShort(int pos, short value) {
+ shorts[pos] = value;
+ }
+
+ public void setMultiFoo(int one, int two, int three, Foo foo) {
+ multi[one][two][three] = foo;
+ }
+ }
+
+ public static interface ComplexInterface {
+ public Number complexRead(int x);
+ }
+
+ public static class Complex implements ComplexInterface {
+ private Integer[] nums;
+ private Long[] longNums;
+ private static Integer justRead;
+
+ public static Object arrayReadObject(Object array, int offset) {
+ return new Integer(justRead.intValue() + offset);
+ }
+
+ public static void arrayWriteObject(Object array, int offset, Object element) {
+ justRead = (Integer) element;
+ }
+
+ public Object getInteger(int i) {
+ return (Object) new Integer(i);
+ }
+
+ public Number complexRead(int x) {
+ Number[] ns = null;
+ Number n1, n2, n3, n4;
+ try {
+ ((Object[])ns)[1] = getInteger(x);
+ // We have to throw an error since we can't intercept
+ // a guaranteed null array read yet (likely never will be able to)
+ throw new Error("hi");
+ } catch (Error error) {
+ ns = nums;
+ } catch (Exception exception) {
+ ns = longNums;
+ } finally {
+ n1 = ns[1];
+ n2 = ns[2];
+ n3 = ns[3];
+ n4 = ns[4];
+
+ n2.intValue();
+ n3.intValue();
+ n4.intValue();
+ }
+
+ return n1;
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/test/test/javassist/proxy/JASSIST113RegressionTest.java b/src/test/test/javassist/proxy/JASSIST113RegressionTest.java
new file mode 100644
index 0000000..baecdb9
--- /dev/null
+++ b/src/test/test/javassist/proxy/JASSIST113RegressionTest.java
@@ -0,0 +1,22 @@
+package test.javassist.proxy;
+
+import javassist.util.proxy.ProxyFactory;
+import junit.framework.TestCase;
+
+/**
+ * Test for regression error detailed in JASSIST-113
+ */
+public class JASSIST113RegressionTest extends TestCase
+{
+ interface Bear
+ {
+ void hibernate();
+ }
+
+ public void testProxyFactoryWithNonPublicInterface()
+ {
+ ProxyFactory proxyFactory = new ProxyFactory();
+ proxyFactory.setInterfaces(new Class[]{Bear.class});
+ proxyFactory.createClass();
+ }
+}
diff --git a/src/test/test/javassist/proxy/ProxyCacheGCTest.java b/src/test/test/javassist/proxy/ProxyCacheGCTest.java
new file mode 100644
index 0000000..379fefc
--- /dev/null
+++ b/src/test/test/javassist/proxy/ProxyCacheGCTest.java
@@ -0,0 +1,121 @@
+package test.javassist.proxy;
+
+import javassist.*;
+import javassist.util.proxy.MethodFilter;
+import javassist.util.proxy.MethodHandler;
+import javassist.util.proxy.ProxyFactory;
+import javassist.util.proxy.ProxyObject;
+import junit.framework.TestCase;
+
+/**
+ * test which checks that proxy classes are not retained after their classloader is released.
+ * this is a before and after test which validates JASSIST-104
+ */
+public class ProxyCacheGCTest extends TestCase
+{
+ /**
+ * creates a large number of proxies in separate classloaders then lets go of the classloaders and
+ * forces a GC. If we run out of heap then we know there is a problem.
+ */
+
+ public final static int REPETITION_COUNT = 10000;
+ private ClassPool basePool;
+ private CtClass baseHandler;
+ private CtClass baseFilter;
+
+ protected void setUp()
+ {
+ basePool = ClassPool.getDefault();
+ try {
+ baseHandler = basePool.get("javassist.util.proxy.MethodHandler");
+ baseFilter = basePool.get("javassist.util.proxy.MethodFilter");
+ } catch (NotFoundException e) {
+ e.printStackTrace();
+ fail("could not find class " + e);
+ }
+ }
+
+ public void testCacheGC()
+ {
+ ClassLoader oldCL = Thread.currentThread().getContextClassLoader();
+ try {
+ ProxyFactory.useCache = false;
+ for (int i = 0; i < REPETITION_COUNT; i++) {
+ ClassLoader newCL = new TestLoader();
+ try {
+ Thread.currentThread().setContextClassLoader(newCL);
+ createProxy(i);
+ } finally {
+ Thread.currentThread().setContextClassLoader(oldCL);
+ }
+ }
+ } finally {
+ ProxyFactory.useCache = true;
+ }
+ }
+
+ /**
+ * called when a specific classloader is in place on the thread to create a method handler, method filter
+ * and proxy in the current loader and then
+ */
+ public void createProxy(int counter)
+ {
+ try {
+ ClassPool classPool = new ClassPool(basePool);
+
+ // create a target class in the current class loader
+ String targetName = "test.javassist.MyTarget_" + counter;
+ String targetConstructorName = "MyTarget_" + counter;
+ CtClass ctTargetClass = classPool.makeClass(targetName);
+ CtMethod targetMethod = CtNewMethod.make("public Object test() { return this; }", ctTargetClass);
+ ctTargetClass.addMethod(targetMethod);
+ CtConstructor targetConstructor = CtNewConstructor.make("public " + targetConstructorName + "() { }", ctTargetClass);
+ ctTargetClass.addConstructor(targetConstructor);
+
+ // create a handler in the current classloader
+ String handlerName = "test.javassist.MyHandler_" + counter;
+ CtClass ctHandlerClass = classPool.makeClass(handlerName);
+ ctHandlerClass.addInterface(baseHandler);
+ CtMethod handlerInvoke = CtNewMethod.make("public Object invoke(Object self, java.lang.reflect.Method thisMethod, java.lang.reflect.Method proceed, Object[] args) throws Throwable { return proceed.invoke(self, args); }", ctHandlerClass);
+ ctHandlerClass.addMethod(handlerInvoke);
+
+ // create a filter in the current classloader
+ String filterName = "test.javassist.MyFilter" + counter;
+ CtClass ctFilterClass = classPool.makeClass(filterName);
+ ctFilterClass.addInterface(baseFilter);
+ CtMethod filterIsHandled = CtNewMethod.make("public boolean isHandled(java.lang.reflect.Method m) { return true; }", ctFilterClass);
+ ctFilterClass.addMethod(filterIsHandled);
+
+ // now create a proxyfactory and use it to create a proxy
+
+ ProxyFactory factory = new ProxyFactory();
+ Class javaTargetClass = classPool.toClass(ctTargetClass);
+ Class javaHandlerClass = classPool.toClass(ctHandlerClass);
+ Class javaFilterClass = classPool.toClass(ctFilterClass);
+
+ MethodHandler handler= (MethodHandler)javaHandlerClass.newInstance();
+ MethodFilter filter = (MethodFilter)javaFilterClass.newInstance();
+
+ // ok, now create a factory and a proxy class and proxy from that factory
+ factory.setFilter(filter);
+ factory.setSuperclass(javaTargetClass);
+ // factory.setSuperclass(Object.class);
+
+ Class proxyClass = factory.createClass();
+ Object target = proxyClass.newInstance();
+ ((ProxyObject)target).setHandler(handler);
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail("cannot create proxy " + e);
+ }
+
+ }
+
+ /**
+ * a classloader which inherits from the system class loader and within which a proxy handler,
+ * filter and proxy will be located.
+ */
+ public static class TestLoader extends ClassLoader
+ {
+ }
+}
diff --git a/src/test/test/javassist/proxy/ProxyFactoryCompatibilityTest.java b/src/test/test/javassist/proxy/ProxyFactoryCompatibilityTest.java
new file mode 100644
index 0000000..5b72d82
--- /dev/null
+++ b/src/test/test/javassist/proxy/ProxyFactoryCompatibilityTest.java
@@ -0,0 +1,115 @@
+package test.javassist.proxy;
+
+import javassist.*;
+import javassist.util.proxy.MethodFilter;
+import javassist.util.proxy.MethodHandler;
+import javassist.util.proxy.ProxyFactory;
+import javassist.util.proxy.ProxyObject;
+import junit.framework.TestCase;
+
+import java.lang.reflect.Method;
+
+/**
+ * test which checks that it is still possible to use the old style proxy factory api
+ * to create proxy classes which set their own handler. it checks that caching is
+ * automatically disabled if this legacy api is used. it also exercises the new style
+ * api, ensuring that caching works correctly with this model.
+ */
+public class ProxyFactoryCompatibilityTest extends TestCase
+{
+ private ClassPool basePool;
+ MethodFilter filter;
+ MethodHandler handler;
+
+ protected void setUp()
+ {
+ basePool = ClassPool.getDefault();
+ filter = new MethodFilter() {
+ public boolean isHandled(Method m) {
+ return !m.getName().equals("finalize");
+ }
+ };
+
+ handler = new MethodHandler() {
+ public Object invoke(Object self, Method m, Method proceed,
+ Object[] args) throws Throwable {
+ System.out.println("calling: " + m.getName());
+ return proceed.invoke(self, args); // execute the original method.
+ }
+ };
+ }
+
+ public void testFactoryCompatibility() throws Exception
+ {
+ System.out.println("ProxyFactory.useCache = " + ProxyFactory.useCache);
+ // create a factory which, by default, uses caching
+ ProxyFactory factory = new ProxyFactory();
+ factory.setSuperclass(TestClass.class);
+ factory.setInterfaces(new Class[] { TestInterface.class});
+ factory.setFilter(filter);
+
+ // create the same class twice and check that it is reused
+ Class proxyClass1 = factory.createClass();
+ System.out.println("created first class " + proxyClass1.getName());
+ TestClass proxy1 = (TestClass)proxyClass1.newInstance();
+ ((ProxyObject) proxy1).setHandler(handler);
+ proxy1.testMethod();
+ assertTrue(proxy1.isTestCalled());
+
+ Class proxyClass2 = factory.createClass();
+ System.out.println("created second class " + proxyClass2.getName());
+ TestClass proxy2 = (TestClass)proxyClass2.newInstance();
+ ((ProxyObject) proxy2).setHandler(handler);
+ proxy2.testMethod();
+ assertTrue(proxy2.isTestCalled());
+
+ assertTrue(proxyClass1 == proxyClass2);
+
+ // create a factory which, by default, uses caching then set the handler so it creates
+ // classes which do not get cached.
+ ProxyFactory factory2 = new ProxyFactory();
+ factory.setSuperclass(TestClass.class);
+ factory.setInterfaces(new Class[] { TestInterface.class});
+ factory.setFilter(filter);
+ factory.setHandler(handler);
+
+ // create the same class twice and check that it is reused
+ Class proxyClass3 = factory.createClass();
+ System.out.println("created third class " + proxyClass3.getName());
+ TestClass proxy3 = (TestClass)proxyClass3.newInstance();
+ proxy3.testMethod();
+ assertTrue(proxy3.isTestCalled());
+
+ Class proxyClass4 = factory.createClass();
+ System.out.println("created fourth class " + proxyClass4.getName());
+ TestClass proxy4 = (TestClass)proxyClass4.newInstance();
+ proxy4.testMethod();
+ assertTrue(proxy4.isTestCalled());
+
+ assertTrue(proxyClass3 != proxyClass4);
+ }
+
+ /**
+ * test class used as the super for the proxy
+ */
+ public static class TestClass {
+ private boolean testCalled = false;
+ public void testMethod()
+ {
+ // record the call
+ testCalled = true;
+ }
+ public boolean isTestCalled()
+ {
+ return testCalled;
+ }
+ }
+
+ /**
+ * test interface used as an interface implemented by the proxy
+ */
+ public static interface TestInterface {
+ public void testMethod();
+ }
+
+}
\ No newline at end of file
diff --git a/src/test/test/javassist/proxy/ProxySerializationTest.java b/src/test/test/javassist/proxy/ProxySerializationTest.java
new file mode 100644
index 0000000..28125de
--- /dev/null
+++ b/src/test/test/javassist/proxy/ProxySerializationTest.java
@@ -0,0 +1,151 @@
+package test.javassist.proxy;
+
+import javassist.util.proxy.*;
+import junit.framework.TestCase;
+
+import java.io.*;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * Test to ensure that serialization and deserialization of javassist proxies via
+ * {@link javassist.util.proxy.ProxyObjectOutputStream} and @link javassist.util.proxy.ProxyObjectInputStream}
+ * reuses classes located in the proxy cache. This tests the fixes provided for JASSIST-42 and JASSIST-97.
+ */
+public class ProxySerializationTest extends TestCase
+{
+ public void testSerialization()
+ {
+ ProxyFactory factory = new ProxyFactory();
+ factory.setSuperclass(TestClass.class);
+ factory.setInterfaces(new Class[] {TestInterface.class});
+
+ factory.setUseWriteReplace(true);
+ Class proxyClass = factory.createClass(new TestFilter());
+
+ MethodHandler handler = new TestHandler();
+
+ // first try serialization using writeReplace
+
+ try {
+ String name = "proxytest_1";
+ Constructor constructor = proxyClass.getConstructor(new Class[] {String.class});
+ TestClass proxy = (TestClass)constructor.newInstance(new Object[] {name});
+ ((ProxyObject)proxy).setHandler(handler);
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ ObjectOutputStream out = new ObjectOutputStream(bos);
+ out.writeObject(proxy);
+ out.close();
+ byte[] bytes = bos.toByteArray();
+ ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
+ ObjectInputStream in = new ObjectInputStream(bis);
+ TestClass newProxy = (TestClass)in.readObject();
+ // inherited fields should not have been deserialized
+ assertTrue("new name should be null", newProxy.getName() == null);
+ // since we are reading into the same JVM the new proxy should have the same class as the old proxy
+ assertTrue("classes should be equal", newProxy.getClass() == proxy.getClass());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+
+ // second try serialization using proxy object output/input streams
+
+ factory.setUseWriteReplace(false);
+ proxyClass = factory.createClass(new TestFilter());
+
+ try {
+ String name = "proxytest_2";
+ Constructor constructor = proxyClass.getConstructor(new Class[] {String.class});
+ TestClass proxy = (TestClass)constructor.newInstance(new Object[] {name});
+ ((ProxyObject)proxy).setHandler(handler);
+ ByteArrayOutputStream bos = new ByteArrayOutputStream();
+ ProxyObjectOutputStream out = new ProxyObjectOutputStream(bos);
+ out.writeObject(proxy);
+ out.close();
+ byte[] bytes = bos.toByteArray();
+ ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
+ ProxyObjectInputStream in = new ProxyObjectInputStream(bis);
+ TestClass newProxy = (TestClass)in.readObject();
+ // inherited fields should have been deserialized
+ assertTrue("names should be equal", proxy.getName().equals(newProxy.getName()));
+ // since we are reading into the same JVM the new proxy should have the same class as the old proxy
+ assertTrue("classes should still be equal", newProxy.getClass() == proxy.getClass());
+ } catch (Exception e) {
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+ public static class TestFilter implements MethodFilter, Serializable
+ {
+ public boolean isHandled(Method m) {
+ if (m.getName().equals("getName")) {
+ return true;
+ }
+ return false;
+ }
+
+ public boolean equals(Object o)
+ {
+ if (o instanceof TestFilter) {
+ // all test filters are equal
+ return true;
+ }
+
+ return false;
+ }
+
+ public int hashCode()
+ {
+ return TestFilter.class.hashCode();
+ }
+ }
+
+ public static class TestHandler implements MethodHandler, Serializable
+ {
+ public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable
+ {
+ return proceed.invoke(self, args);
+ }
+ public boolean equals(Object o)
+ {
+ if (o instanceof TestHandler) {
+ // all test handlers are equal
+ return true;
+ }
+
+ return false;
+ }
+
+ public int hashCode()
+ {
+ return TestHandler.class.hashCode();
+ }
+ }
+
+ public static class TestClass implements Serializable
+ {
+ public String name;
+
+ public TestClass()
+ {
+ }
+
+ public TestClass(String name)
+ {
+ this.name = name;
+ }
+
+ public String getName()
+ {
+ return name;
+ }
+ }
+
+ public static interface TestInterface
+ {
+ public String getName();
+ }
+}
diff --git a/src/test/test/javassist/proxy/ProxySimpleTest.java b/src/test/test/javassist/proxy/ProxySimpleTest.java
new file mode 100644
index 0000000..f74fce4
--- /dev/null
+++ b/src/test/test/javassist/proxy/ProxySimpleTest.java
@@ -0,0 +1,64 @@
+package test.javassist.proxy;
+
+import junit.framework.TestCase;
+
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
+import java.lang.reflect.Method;
+
+import javassist.util.proxy.ProxyFactory;
+
+public class ProxySimpleTest extends TestCase {
+ public void testReadWrite() throws Exception {
+ final String fileName = "read-write.bin";
+ ProxyFactory.ClassLoaderProvider cp = ProxyFactory.classLoaderProvider;
+ ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {
+ public ClassLoader get(ProxyFactory pf) {
+ return new javassist.Loader();
+ }
+ };
+ ProxyFactory pf = new ProxyFactory();
+ pf.setSuperclass(ReadWriteData.class);
+ Object data = pf.createClass().newInstance();
+ // Object data = new ReadWriteData();
+ ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(fileName));
+ oos.writeObject(data);
+ oos.close();
+ ProxyFactory.classLoaderProvider = cp;
+
+ ObjectInputStream ois = new ObjectInputStream(new FileInputStream(fileName));
+ Object data2 = ois.readObject();
+ ois.close();
+ int i = ((ReadWriteData)data2).foo();
+ assertEquals(4, i);
+ }
+
+ public static class ReadWriteData implements Serializable {
+ public int foo() { return 4; }
+ }
+
+ public void testWriteReplace() throws Exception {
+ ProxyFactory pf = new ProxyFactory();
+ pf.setSuperclass(WriteReplace.class);
+ Object data = pf.createClass().newInstance();
+ assertEquals(data, ((WriteReplace)data).writeReplace());
+
+ ProxyFactory pf2 = new ProxyFactory();
+ pf2.setSuperclass(WriteReplace2.class);
+ Object data2 = pf2.createClass().newInstance();
+ Method meth = data2.getClass().getDeclaredMethod("writeReplace", new Class[0]);
+ assertEquals("javassist.util.proxy.SerializedProxy",
+ meth.invoke(data2, new Object[0]).getClass().getName());
+ }
+
+ public static class WriteReplace implements Serializable {
+ public Object writeReplace() { return this; }
+ }
+
+ public static class WriteReplace2 implements Serializable {
+ public Object writeReplace(int i) { return new Integer(i); }
+ }
+}
diff --git a/tutorial/brown.css b/tutorial/brown.css
new file mode 100644
index 0000000..7570549
--- /dev/null
+++ b/tutorial/brown.css
@@ -0,0 +1,19 @@
+h1,h2,h3 {
+ color:#663300;
+ padding:4px 6px 6px 10px;
+ border-width:1px 0px 1px 0px;
+ border-color:#F5DEB3;
+ border-style:solid;
+}
+
+h3 {
+ padding-left: 30px;
+}
+
+h4 {
+ color:#663300;
+}
+
+em {
+ color:#cc0000;
+}
diff --git a/tutorial/tutorial.html b/tutorial/tutorial.html
new file mode 100644
index 0000000..d62743d
--- /dev/null
+++ b/tutorial/tutorial.html
@@ -0,0 +1,1101 @@
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+ <title>Javassist Tutorial</title>
+ <link rel="stylesheet" type="text/css" href="brown.css">
+</head>
+<body>
+
+<b>
+<font size="+3">
+Getting Started with Javassist
+</font>
+
+<p><font size="+2">
+Shigeru Chiba
+</font>
+</b>
+
+<p><div align="right"><a href="tutorial2.html">Next page</a></div>
+
+<ul>1. <a href="#read">Reading and writing bytecode</a>
+<br>2. <a href="#pool">ClassPool</a>
+<br>3. <a href="#load">Class loader</a>
+<br>4. <a href="tutorial2.html#intro">Introspection and customization</a>
+<br>5. <a href="tutorial3.html#intro">Bytecode level API</a>
+<br>6. <a href="tutorial3.html#generics">Generics</a>
+<br>7. <a href="tutorial3.html#varargs">Varargs</a>
+<br>8. <a href="tutorial3.html#j2me">J2ME</a>
+</ul>
+
+<p><br>
+
+<a name="read">
+<h2>1. Reading and writing bytecode</h2>
+
+<p>Javassist is a class library for dealing with Java bytecode.
+Java bytecode is stored in a binary file called a class file.
+Each class file contains one Java class or interface.
+
+<p>The class <code>Javassist.CtClass</code> is an absatract
+representation of a class file. A <code>CtClass</code> (compile-time
+class) object is a handle for dealing with a class file. The
+following program is a very simple example:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("test.Rectangle");
+cc.setSuperclass(pool.get("test.Point"));
+cc.writeFile();
+</pre></ul>
+
+<p>This program first obtains a <code>ClassPool</code> object, which
+controls bytecode modification with Javassist. The
+<code>ClassPool</code> object is a container of <code>CtClass</code>
+object representing a class file. It reads a class file on demand for
+constructing a <code>CtClass</code> object and records the
+constructed object for responding later accesses.
+
+To modify the definition of a class, the users must first obtain
+from a <code>ClassPool</code> object
+a reference to a <code>CtClass</code> object representing that class.
+<code>get()</code> in <code>ClassPool</code> is used for this purpose.
+In the case of the program shown above, the
+<code>CtClass</code> object representing a class
+<code>test.Rectangle</code> is obtained from the
+<code>ClassPool</code> object and it is assigned to a variable
+<code>cc</code>.
+The <code>ClassPool</code> object returned by <code>getDfault()</code>
+searches the default system search path.
+
+<p>From the implementation viewpoint, <code>ClassPool</code> is a hash
+table of <code>CtClass</code> objects, which uses the class names as
+keys. <code>get()</code> in <code>ClassPool</code> searches this hash
+table to find a <code>CtClass</code> object associated with the
+specified key. If such a <code>CtClass</code> object is not found,
+<code>get()</code> reads a class file to construct a new
+<code>CtClass</code> object, which is recorded in the hash table and
+then returned as the resulting value of <code>get()</code>.
+
+<p>The <code>CtClass</code> object obtained from a <code>ClassPool</code>
+object can be modified
+(<a href="tutorial2.html#intro">details of how to modify
+a <code>CtClass</code></a> will be presented later).
+In the example above, it is modified so that the superclass of
+<code>test.Rectangle</code> is changed into a class
+<code>test.Point</code>. This change is reflected on the original
+class file when <code>writeFile()</code> in <code>CtClass()</code> is
+finally called.
+
+<p><code>writeFile()</code> translates the <code>CtClass</code> object
+into a class file and writes it on a local disk.
+Javassist also provides a method for directly obtaining the
+modified bytecode. To obtain the bytecode, call <code>toBytecode()</code>:
+
+<ul><pre>
+byte[] b = cc.toBytecode();
+</pre></ul>
+
+<p>You can directly load the <code>CtClass</code> as well:
+
+<ul><pre>
+Class clazz = cc.toClass();
+</pre></ul>
+
+<p><code>toClass()</code> requests the context class loader for the current
+thread to load the class file represented by the <code>CtClass</code>. It
+returns a <code>java.lang.Class</code> object representing the loaded class.
+For more details, please see <a href="#toclass">this section below</a>.
+
+<a name="def">
+<h4>Defining a new class</h4>
+
+<p>To define a new class from scratch, <code>makeClass()</code>
+must be called on a <code>ClassPool</code>.
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.makeClass("Point");
+</pre></ul>
+
+<p>This program defines a class <code>Point</code>
+including no members.
+Member methods of <code>Point</code> can be created with
+factory methods declared in <code>CtNewMethod</code> and
+appended to <code>Point</code> with <code>addMethod()</code>
+in <code>CtClass</code>.
+
+<p><code>makeClass()</code> cannot create a new interface;
+<code>makeInterface()</code> in <code>ClassPool</code> can do.
+Member methods in an interface can be created with
+<code>abstractMethod()</code> in <code>CtNewMethod</code>.
+Note that an interface method is an abstract method.
+
+<a name="frozenclasses">
+<h4>Frozen classes</h4></a>
+
+<p>If a <code>CtClass</code> object is converted into a class file by
+<code>writeFile()</code>, <code>toClass()</code>, or
+<code>toBytecode()</code>, Javassist freezes that <code>CtClass</code>
+object. Further modifications of that <code>CtClass</code> object are
+not permitted. This is for warning the developers when they attempt
+to modify a class file that has been already loaded since the JVM does
+not allow reloading a class.
+
+<p>A frozen <code>CtClass</code> can be defrost so that
+modifications of the class definition will be permitted. For example,
+
+<ul><pre>
+CtClasss cc = ...;
+ :
+cc.writeFile();
+cc.defrost();
+cc.setSuperclass(...); // OK since the class is not frozen.
+</pre></ul>
+
+<p>After <code>defrost()</code> is called, the <code>CtClass</code>
+object can be modified again.
+
+<p>If <code>ClassPool.doPruning</code> is set to <code>true</code>,
+then Javassist prunes the data structure contained
+in a <code>CtClass</code> object
+when Javassist freezes that object.
+To reduce memory
+consumption, pruning discards unnecessary attributes
+(<code>attribute_info</code> structures) in that object.
+For example, <code>Code_attribute</code> structures (method bodies)
+are discarded.
+Thus, after a
+<code>CtClass</code> object is pruned, the bytecode of a method is not
+accessible except method names, signatures, and annotations.
+The pruned <code>CtClass</code> object cannot be defrost again.
+The default value of <code>ClassPool.doPruning</code> is <code>false</code>.
+
+<p>To disallow pruning a particular <code>CtClass</code>,
+<code>stopPruning()</code> must be called on that object in advance:
+
+<ul><pre>
+CtClasss cc = ...;
+cc.stopPruning(true);
+ :
+cc.writeFile(); // convert to a class file.
+// cc is not pruned.
+</pre></ul>
+
+<p>The <code>CtClass</code> object <code>cc</code> is not pruned.
+Thus it can be defrost after <code>writeFile()</code> is called.
+
+<ul><b>Note:</b>
+While debugging, you might want to temporarily stop pruning and freezing
+and write a modified class file to a disk drive.
+<code>debugWriteFile()</code> is a convenient method
+for that purpose. It stops pruning, writes a class file, defrosts it,
+and turns pruning on again (if it was initially on).
+</ul>
+
+
+
+<h4>Class search path</h4>
+
+<p>The default <code>ClassPool</code> returned
+by a static method <code>ClassPool.getDefault()</code>
+searches the same path that the underlying JVM (Java virtual machine) has.
+<em>If a program is running on a web application server such as JBoss and Tomcat,
+the <code>ClassPool</code> object may not be able to find user classes</em>
+since such a web application server uses multiple class loaders as well as
+the system class loader. In that case, an additional class path must be
+registered to the <code>ClassPool</code>. Suppose that <code>pool</code>
+refers to a <code>ClassPool</code> object:
+
+<ul><pre>
+pool.insertClassPath(new ClassClassPath(this.getClass()));
+</pre></ul>
+
+<p>
+This statement registers the class path that was used for loading
+the class of the object that <code>this</code> refers to.
+You can use any <code>Class</code> object as an argument instead of
+<code>this.getClass()</code>. The class path used for loading the
+class represented by that <code>Class</code> object is registered.
+
+<p>
+You can register a directory name as the class search path.
+For example, the following code adds a directory
+<code>/usr/local/javalib</code>
+to the search path:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+pool.insertClassPath("/usr/local/javalib");
+</pre></ul>
+
+<p>The search path that the users can add is not only a directory but also
+a URL:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
+pool.insertClassPath(cp);
+</pre></ul>
+
+<p>This program adds "http://www.javassist.org:80/java/" to the class search
+path. This URL is used only for searching classes belonging to a
+package <code>org.javassist</code>. For example, to load a class
+<code>org.javassist.test.Main</code>, its class file will be obtained from:
+
+<ul><pre>http://www.javassist.org:80/java/org/javassist/test/Main.class
+</pre></ul>
+
+<p>Furthermore, you can directly give a byte array
+to a <code>ClassPool</code> object
+and construct a <code>CtClass</code> object from that array. To do this,
+use <code>ByteArrayClassPath</code>. For example,
+
+<ul><pre>
+ClassPool cp = ClassPool.getDefault();
+byte[] b = <em>a byte array</em>;
+String name = <em>class name</em>;
+cp.insertClassPath(new ByteArrayClassPath(name, b));
+CtClass cc = cp.get(name);
+</pre></ul>
+
+<p>The obtained <code>CtClass</code> object represents
+a class defined by the class file specified by <code>b</code>.
+The <code>ClassPool</code> reads a class file from the given
+<code>ByteArrayClassPath</code> if <code>get()</code> is called
+and the class name given to <code>get()</code> is equal to
+one specified by <code>name</code>.
+
+<p>If you do not know the fully-qualified name of the class, then you
+can use <code>makeClass()</code> in <code>ClassPool</code>:
+
+<ul><pre>
+ClassPool cp = ClassPool.getDefault();
+InputStream ins = <em>an input stream for reading a class file</em>;
+CtClass cc = cp.makeClass(ins);
+</pre></ul>
+
+<p><code>makeClass()</code> returns the <code>CtClass</code> object
+constructed from the given input stream. You can use
+<code>makeClass()</code> for eagerly feeding class files to
+the <code>ClassPool</code> object. This might improve performance
+if the search path includes a large jar file. Since
+a <code>ClassPool</code> object reads a class file on demand,
+it might repeatedly search the whole jar file for every class file.
+<code>makeClass()</code> can be used for optimizing this search.
+The <code>CtClass</code> constructed by <code>makeClass()</code>
+is kept in the <code>ClassPool</code> object and the class file is never
+read again.
+
+<p>The users can extend the class search path. They can define a new
+class implementing <code>ClassPath</code> interface and give an
+instance of that class to <code>insertClassPath()</code> in
+<code>ClassPool</code>. This allows a non-standard resource to be
+included in the search path.
+
+<p><br>
+
+<a name="pool">
+<h2>2. ClassPool</h2>
+
+<p>
+A <code>ClassPool</code> object is a container of <code>CtClass</code>
+objects. Once a <code>CtClass</code> object is created, it is
+recorded in a <code>ClassPool</code> for ever. This is because a
+compiler may need to access the <code>CtClass</code> object later when
+it compiles source code that refers to the class represented by that
+<code>CtClass</code>.
+
+<p>
+For example, suppose that a new method <code>getter()</code> is added
+to a <code>CtClass</code> object representing <code>Point</code>
+class. Later, the program attempts to compile source code including a
+method call to <code>getter()</code> in <code>Point</code> and use the
+compiled code as the body of a method, which will be added to another
+class <code>Line</code>. If the <code>CtClass</code> object representing
+<code>Point</code> is lost, the compiler cannot compile the method call
+to <code>getter()</code>. Note that the original class definition does
+not include <code>getter()</code>. Therefore, to correctly compile
+such a method call, the <code>ClassPool</code>
+must contain all the instances of <code>CtClass</code> all the time of
+program execution.
+
+<a name="avoidmemory">
+<h4>Avoid out of memory</h4>
+</a>
+
+<p>
+This specification of <code>ClassPool</code> may cause huge memory
+consumption if the number of <code>CtClass</code> objects becomes
+amazingly large (this rarely happens since Javassist tries to reduce
+memory consumption in <a href="#frozenclasses">various ways</a>).
+To avoid this problem, you
+can explicitly remove an unnecessary <code>CtClass</code> object from
+the <code>ClassPool</code>. If you call <code>detach()</code> on a
+<code>CtClass</code> object, then that <code>CtClass</code> object is
+removed from the <code>ClassPool</code>. For example,
+
+<ul><pre>
+CtClass cc = ... ;
+cc.writeFile();
+cc.detach();
+</pre></ul>
+
+<p>You must not call any method on that
+<code>CtClass</code> object after <code>detach()</code> is called.
+However, you can call <code>get()</code> on <code>ClassPool</code>
+to make a new instance of <code>CtClass</code> representing
+the same class. If you call <code>get()</code>, the <code>ClassPool</code>
+reads a class file again and newly creates a <code>CtClass</code>
+object, which is returned by <code>get()</code>.
+
+<p>
+Another idea is to occasionally replace a <code>ClassPool</code> with
+a new one and discard the old one. If an old <code>ClassPool</code>
+is garbage collected, the <code>CtClass</code> objects included in
+that <code>ClassPool</code> are also garbage collected.
+To create a new instance of <code>ClassPool</code>, execute the following
+code snippet:
+
+<ul><pre>
+ClassPool cp = new ClassPool(true);
+// if needed, append an extra search path by appendClassPath()
+</pre></ul>
+
+<p>This creates a <code>ClassPool</code> object that behaves as the
+default <code>ClassPool</code> returned by
+<code>ClassPool.getDefault()</code> does.
+Note that <code>ClassPool.getDefault()</code> is a singleton factory method
+provided for convenience. It creates a <code>ClassPool</code> object in
+the same way shown above although it keeps a single instance of
+<code>ClassPool</code> and reuses it.
+A <code>ClassPool</code> object returned by <code>getDefault()</code>
+does not have a special role. <code>getDefault()</code> is a convenience
+method.
+
+<p>Note that <code>new ClassPool(true)</code> is a convenient constructor,
+which constructs a <code>ClassPool</code> object and appends the system
+search path to it. Calling that constructor is
+equivalent to the following code:
+
+<ul><pre>
+ClassPool cp = new ClassPool();
+cp.appendSystemPath(); // or append another path by appendClassPath()
+</pre></ul>
+
+<h4>Cascaded ClassPools</h4>
+
+<p>
+<em>If a program is running on a web application server,</em>
+creating multiple instances of <code>ClassPool</code> might be necessary;
+an instance of <code>ClassPool</code> should be created
+for each class loader (i.e. container).
+The program should create a <code>ClassPool</code> object by not calling
+<code>getDefault()</code> but a constructor of <code>ClassPool</code>.
+
+<p>
+Multiple <code>ClassPool</code> objects can be cascaded like
+<code>java.lang.ClassLoader</code>. For example,
+
+<ul><pre>
+ClassPool parent = ClassPool.getDefault();
+ClassPool child = new ClassPool(parent);
+child.insertClassPath("./classes");
+</pre></ul>
+
+<p>
+If <code>child.get()</code> is called, the child <code>ClassPool</code>
+first delegates to the parent <code>ClassPool</code>. If the parent
+<code>ClassPool</code> fails to find a class file, then the child
+<code>ClassPool</code> attempts to find a class file
+under the <code>./classes</code> directory.
+
+<p>
+If <code>child.childFirstLookup</code> is true, the child
+<code>ClassPool</code> attempts to find a class file before delegating
+to the parent <code>ClassPool</code>. For example,
+
+<ul><pre>
+ClassPool parent = ClassPool.getDefault();
+ClassPool child = new ClassPool(parent);
+child.appendSystemPath(); // the same class path as the default one.
+child.childFirstLookup = true; // changes the behavior of the child.
+</pre></ul>
+
+<h4>Changing a class name for defining a new class</h4>
+
+<p>A new class can be defined as a copy of an existing class.
+The program below does that:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.setName("Pair");
+</pre></ul>
+
+<p>This program first obtains the <code>CtClass</code> object for
+class <code>Point</code>. Then it calls <code>setName()</code> to
+give a new name <code>Pair</code> to that <code>CtClass</code> object.
+After this call, all occurrences of the class name in the class
+definition represented by that <code>CtClass</code> object are changed
+from <code>Point</code> to <code>Pair</code>. The other part of the
+class definition does not change.
+
+<p>Note that <code>setName()</code> in <code>CtClass</code> changes a
+record in the <code>ClassPool</code> object. From the implementation
+viewpoint, a <code>ClassPool</code> object is a hash table of
+<code>CtClass</code> objects. <code>setName()</code> changes
+the key associated to the <code>CtClass</code> object in the hash
+table. The key is changed from the original class name to the new
+class name.
+
+<p>Therefore, if <code>get("Point")</code> is later called on the
+<code>ClassPool</code> object again, then it never returns the
+<code>CtClass</code> object that the variable <code>cc</code> refers to.
+The <code>ClassPool</code> object reads
+a class file
+<code>Point.class</code> again and it constructs a new <code>CtClass</code>
+object for class <code>Point</code>.
+This is because the <code>CtClass</code> object associated with the name
+<code>Point</code> does not exist any more.
+See the followings:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+CtClass cc1 = pool.get("Point"); // cc1 is identical to cc.
+cc.setName("Pair");
+CtClass cc2 = pool.get("Pair"); // cc2 is identical to cc.
+CtClass cc3 = pool.get("Point"); // cc3 is not identical to cc.
+</pre></ul>
+
+<p><code>cc1</code> and <code>cc2</code> refer to the same instance of
+<code>CtClass</code> that <code>cc</code> does whereas
+<code>cc3</code> does not. Note that, after
+<code>cc.setName("Pair")</code> is executed, the <code>CtClass</code>
+object that <code>cc</code> and <code>cc1</code> refer to represents
+the <code>Pair</code> class.
+
+<p>The <code>ClassPool</code> object is used to maintain one-to-one
+mapping between classes and <code>CtClass</code> objects. Javassist
+never allows two distinct <code>CtClass</code> objects to represent
+the same class unless two independent <code>ClassPool</code> are created.
+This is a significant feature for consistent program
+transformation.
+
+<p>To create another copy of the default instance of
+<code>ClassPool</code>, which is returned by
+<code>ClassPool.getDefault()</code>, execute the following code
+snippet (this code was already <a href="#avoidmemory">shown above</a>):
+
+<ul><pre>
+ClassPool cp = new ClassPool(true);
+</pre></ul>
+
+<p>If you have two <code>ClassPool</code> objects, then you can
+obtain, from each <code>ClassPool</code>, a distinct
+<code>CtClass</code> object representing the same class file. You can
+differently modify these <code>CtClass</code> objects to generate
+different versions of the class.
+
+<h4>Renaming a frozen class for defining a new class</h4>
+
+<p>Once a <code>CtClass</code> object is converted into a class file
+by <code>writeFile()</code> or <code>toBytecode()</code>, Javassist
+rejects further modifications of that <code>CtClass</code> object.
+Hence, after the <code>CtClass</code> object representing <code>Point</code>
+class is converted into a class file, you cannot define <code>Pair</code>
+class as a copy of <code>Point</code> since executing <code>setName()</code>
+on <code>Point</code> is rejected.
+The following code snippet is wrong:
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.writeFile();
+cc.setName("Pair"); // wrong since writeFile() has been called.
+</pre></ul>
+
+<p>To avoid this restriction, you should call <code>getAndRename()</code>
+in <code>ClassPool</code>. For example,
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+cc.writeFile();
+CtClass cc2 = pool.getAndRename("Point", "Pair");
+</pre></ul>
+
+<p>If <code>getAndRename()</code> is called, the <code>ClassPool</code>
+first reads <code>Point.class</code> for creating a new <code>CtClass</code>
+object representing <code>Point</code> class. However, it renames that
+<code>CtClass</code> object from <code>Point</code> to <code>Pair</code> before
+it records that <code>CtClass</code> object in a hash table.
+Thus <code>getAndRename()</code>
+can be executed after <code>writeFile()</code> or <code>toBytecode()</code>
+is called on the the <code>CtClass</code> object representing <code>Point</code>
+class.
+
+<p><br>
+
+<a name="load">
+<h2>3. Class loader</h2>
+
+<p>If what classes must be modified is known in advance,
+the easiest way for modifying the classes is as follows:
+
+<ul><li>1. Get a <code>CtClass</code> object by calling
+ <code>ClassPool.get()</code>,
+ <li>2. Modify it, and
+ <li>3. Call <code>writeFile()</code> or <code>toBytecode()</code>
+ on that <code>CtClass</code> object to obtain a modified class file.
+</ul>
+
+<p>If whether a class is modified or not is determined at load time,
+the users must make Javassist collaborate with a class loader.
+Javassist can be used with a class loader so that bytecode can be
+modified at load time. The users of Javassist can define their own
+version of class loader but they can also use a class loader provided
+by Javassist.
+
+
+<p><br>
+
+<a name="toclass">
+<h3>3.1 The <code>toClass</code> method in <code>CtClass</code></h3>
+</a>
+
+<p>The <code>CtClass</code> provides a convenience method
+<code>toClass()</code>, which requests the context class loader for
+the current thread to load the class represented by the <code>CtClass</code>
+object. To call this method, the caller must have appropriate permission;
+otherwise, a <code>SecurityException</code> may be thrown.
+
+<p>The following program shows how to use <code>toClass()</code>:
+
+<ul><pre>
+public class Hello {
+ public void say() {
+ System.out.println("Hello");
+ }
+}
+
+public class Test {
+ public static void main(String[] args) throws Exception {
+ ClassPool cp = ClassPool.getDefault();
+ CtClass cc = cp.get("Hello");
+ CtMethod m = cc.getDeclaredMethod("say");
+ m.insertBefore("{ System.out.println(\"Hello.say():\"); }");
+ Class c = cc.toClass();
+ Hello h = (Hello)c.newInstance();
+ h.say();
+ }
+}
+</pre></ul>
+
+<p><code>Test.main()</code> inserts a call to <code>println()</code>
+in the method body of <code>say()</code> in <code>Hello</code>. Then
+it constructs an instance of the modified <code>Hello</code> class
+and calls <code>say()</code> on that instance.
+
+<p>Note that the program above depends on the fact that the
+<code>Hello</code> class is never loaded before <code>toClass()</code>
+is invoked. If not, the JVM would load the original
+<code>Hello</code> class before <code>toClass()</code> requests to
+load the modified <code>Hello</code> class. Hence loading the
+modified <code>Hello</code> class would be failed
+(<code>LinkageError</code> is thrown). For example, if
+<code>main()</code> in <code>Test</code> is something like this:
+
+<ul><pre>
+public static void main(String[] args) throws Exception {
+ Hello orig = new Hello();
+ ClassPool cp = ClassPool.getDefault();
+ CtClass cc = cp.get("Hello");
+ :
+}
+</pre></ul>
+
+<p>then the original <code>Hello</code> class is loaded at the first
+line of <code>main</code> and the call to <code>toClass()</code>
+throws an exception since the class loader cannot load two different
+versions of the <code>Hello</code> class at the same time.
+
+<p><em>If the program is running on some application server such as
+JBoss and Tomcat,</em> the context class loader used by
+<code>toClass()</code> might be inappropriate. In this case, you
+would see an unexpected <code>ClassCastException</code>. To avoid
+this exception, you must explicitly give an appropriate class loader
+to <code>toClass()</code>. For example, if <code>bean</code> is your
+session bean object, then the following code:
+
+<ul><pre>CtClass cc = ...;
+Class c = cc.toClass(bean.getClass().getClassLoader());
+</pre></ul>
+
+<p>would work. You should give <code>toClass()</code> the class loader
+that has loaded your program (in the above example, the class of
+the <code>bean</code> object).
+
+<p><code>toClass()</code> is provided for convenience. If you need
+more complex functionality, you should write your own class loader.
+
+<p><br>
+
+<h3>3.2 Class loading in Java</h3>
+
+<p>In Java, multiple class loaders can coexist and
+each class loader creates its own name space.
+Different class loaders can load different class files with the
+same class name. The loaded two classes are regarded as different
+ones. This feature enables us to run multiple application programs
+on a single JVM even if these programs include different classes
+with the same name.
+
+<ul>
+<b>Note:</b> The JVM does not allow dynamically reloading a class.
+Once a class loader loads a class, it cannot reload a modified
+version of that class during runtime. Thus, you cannot alter
+the definition of a class after the JVM loads it.
+However, the JPDA (Java Platform Debugger Architecture) provides
+limited ability for reloading a class.
+See <a href="#hotswap">Section 3.6</a>.
+</ul>
+
+<p>If the same class file is loaded by two distinct class loaders,
+the JVM makes two distinct classes with the same name and definition.
+The two classes are regarded as different ones.
+Since the two classes are not identical, an instance of one class is
+not assignable to a variable of the other class. The cast operation
+between the two classes fails
+and throws a <em><code>ClassCastException</code></em>.
+
+<p>For example, the following code snippet throws an exception:
+
+<ul><pre>
+MyClassLoader myLoader = new MyClassLoader();
+Class clazz = myLoader.loadClass("Box");
+Object obj = clazz.newInstance();
+Box b = (Box)obj; // this always throws ClassCastException.
+</pre></ul>
+
+<p>
+The <code>Box</code> class is loaded by two class loaders.
+Suppose that a class loader CL loads a class including this code snippet.
+Since this code snippet refers to <code>MyClassLoader</code>,
+<code>Class</code>, <code>Object</code>, and <code>Box</code>,
+CL also loads these classes (unless it delegates to another class loader).
+Hence the type of the variable <code>b</code> is the <code>Box</code>
+class loaded by CL.
+On the other hand, <code>myLoader</code> also loads the <code>Box</code>
+class. The object <code>obj</code> is an instance of
+the <code>Box</code> class loaded by <code>myLoader</code>.
+Therefore, the last statement always throws a
+<code>ClassCastException</code> since the class of <code>obj</code> is
+a different verison of the <code>Box</code> class from one used as the
+type of the variable <code>b</code>.
+
+<p>Multiple class loaders form a tree structure.
+Each class loader except the bootstrap loader has a
+parent class loader, which has normally loaded the class of that child
+class loader. Since the request to load a class can be delegated along this
+hierarchy of class loaders, a class may be loaded by a class loader that
+you do not request the class loading.
+Therefore, the class loader that has been requested to load a class C
+may be different from the loader that actually loads the class C.
+For distinction, we call the former loader <em>the initiator of C</em>
+and we call the latter loader <em>the real loader of C</em>.
+
+<p>
+Furthermore, if a class loader CL requested to load a class C
+(the initiator of C) delegates
+to the parent class loader PL, then the class loader CL is never requested
+to load any classes referred to in the definition of the class C.
+CL is not the initiator of those classes.
+Instead, the parent class loader PL becomes their initiators
+and it is requested to load them.
+<em>The classes that the definition of a class C referes to are loaded by
+the real loader of C.</em>
+
+<p>To understand this behavior, let's consider the following example.
+
+<ul><pre>
+public class Point { // loaded by PL
+ private int x, y;
+ public int getX() { return x; }
+ :
+}
+
+public class Box { // the initiator is L but the real loader is PL
+ private Point upperLeft, size;
+ public int getBaseX() { return upperLeft.x; }
+ :
+}
+
+public class Window { // loaded by a class loader L
+ private Box box;
+ public int getBaseX() { return box.getBaseX(); }
+}</pre></ul>
+
+<p>Suppose that a class <code>Window</code> is loaded by a class loader L.
+Both the initiator and the real loader of <code>Window</code> are L.
+Since the definition of <code>Window</code> refers to <code>Box</code>,
+the JVM will request L to load <code>Box</code>.
+Here, suppose that L delegates this task to the parent class loader PL.
+The initiator of <code>Box</code> is L but the real loader is PL.
+In this case, the initiator of <code>Point</code> is not L but PL
+since it is the same as the real loader of <code>Box</code>.
+Thus L is never requested to load <code>Point</code>.
+
+<p>Next, let's consider a slightly modified example.
+
+<ul><pre>
+public class Point {
+ private int x, y;
+ public int getX() { return x; }
+ :
+}
+
+public class Box { // the initiator is L but the real loader is PL
+ private Point upperLeft, size;
+ public Point getSize() { return size; }
+ :
+}
+
+public class Window { // loaded by a class loader L
+ private Box box;
+ public boolean widthIs(int w) {
+ Point p = box.getSize();
+ return w == p.getX();
+ }
+}</pre></ul>
+
+<p>Now, the definition of <code>Window</code> also refers to
+<code>Point</code>. In this case, the class loader L must
+also delegate to PL if it is requested to load <code>Point</code>.
+<em>You must avoid having two class loaders doubly load the same
+class.</em> One of the two loaders must delegate to
+the other.
+
+<p>
+If L does not delegate to PL when <code>Point</code>
+is loaded, <code>widthIs()</code> would throw a ClassCastException.
+Since the real loader of <code>Box</code> is PL,
+<code>Point</code> referred to in <code>Box</code> is also loaded by PL.
+Therefore, the resulting value of <code>getSize()</code>
+is an instance of <code>Point</code> loaded by PL
+whereas the type of the variable <code>p</code> in <code>widthIs()</code>
+is <code>Point</code> loaded by L.
+The JVM regards them as distinct types and thus it throws an exception
+because of type mismatch.
+
+<p>This behavior is somewhat inconvenient but necessary.
+If the following statement:
+
+<ul><pre>
+Point p = box.getSize();
+</pre></ul>
+
+<p>did not throw an exception,
+then the programmer of <code>Window</code> could break the encapsulation
+of <code>Point</code> objects.
+For example, the field <code>x</code>
+is private in <code>Point</code> loaded by PL.
+However, the <code>Window</code> class could
+directly access the value of <code>x</code>
+if L loads <code>Point</code> with the following definition:
+
+<ul><pre>
+public class Point {
+ public int x, y; // not private
+ public int getX() { return x; }
+ :
+}
+</pre></ul>
+
+<p>
+For more details of class loaders in Java, the following paper would
+be helpful:
+
+<ul>Sheng Liang and Gilad Bracha,
+"Dynamic Class Loading in the Java Virtual Machine",
+<br><i>ACM OOPSLA'98</i>, pp.36-44, 1998.</ul>
+
+<p><br>
+
+<h3>3.3 Using <code>javassist.Loader</code></h3>
+
+<p>Javassist provides a class loader
+<code>javassist.Loader</code>. This class loader uses a
+<code>javassist.ClassPool</code> object for reading a class file.
+
+<p>For example, <code>javassist.Loader</code> can be used for loading
+a particular class modified with Javassist.
+
+<ul><pre>
+import javassist.*;
+import test.Rectangle;
+
+public class Main {
+ public static void main(String[] args) throws Throwable {
+ ClassPool pool = ClassPool.getDefault();
+ Loader cl = new Loader(pool);
+
+ CtClass ct = pool.get("test.Rectangle");
+ ct.setSuperclass(pool.get("test.Point"));
+
+ Class c = cl.loadClass("test.Rectangle");
+ Object rect = c.newInstance();
+ :
+ }
+}
+</pre></ul>
+
+<p>This program modifies a class <code>test.Rectangle</code>. The
+superclass of <code>test.Rectangle</code> is set to a
+<code>test.Point</code> class. Then this program loads the modified
+class, and creates a new instance of the
+<code>test.Rectangle</code> class.
+
+<p>If the users want to modify a class on demand when it is loaded,
+the users can add an event listener to a <code>javassist.Loader</code>.
+The added event listener is
+notified when the class loader loads a class.
+The event-listener class must implement the following interface:
+
+<ul><pre>public interface Translator {
+ public void start(ClassPool pool)
+ throws NotFoundException, CannotCompileException;
+ public void onLoad(ClassPool pool, String classname)
+ throws NotFoundException, CannotCompileException;
+}</pre></ul>
+
+<p>The method <code>start()</code> is called when this event listener
+is added to a <code>javassist.Loader</code> object by
+<code>addTranslator()</code> in <code>javassist.Loader</code>. The
+method <code>onLoad()</code> is called before
+<code>javassist.Loader</code> loads a class. <code>onLoad()</code>
+can modify the definition of the loaded class.
+
+<p>For example, the following event listener changes all classes
+to public classes just before they are loaded.
+
+<ul><pre>public class MyTranslator implements Translator {
+ void start(ClassPool pool)
+ throws NotFoundException, CannotCompileException {}
+ void onLoad(ClassPool pool, String classname)
+ throws NotFoundException, CannotCompileException
+ {
+ CtClass cc = pool.get(classname);
+ cc.setModifiers(Modifier.PUBLIC);
+ }
+}</pre></ul>
+
+<p>Note that <code>onLoad()</code> does not have to call
+<code>toBytecode()</code> or <code>writeFile()</code> since
+<code>javassist.Loader</code> calls these methods to obtain a class
+file.
+
+<p>To run an application class <code>MyApp</code> with a
+<code>MyTranslator</code> object, write a main class as following:
+
+<ul><pre>
+import javassist.*;
+
+public class Main2 {
+ public static void main(String[] args) throws Throwable {
+ Translator t = new MyTranslator();
+ ClassPool pool = ClassPool.getDefault();
+ Loader cl = new Loader();
+ cl.addTranslator(pool, t);
+ cl.run("MyApp", args);
+ }
+}
+</pre></ul>
+
+<p>To run this program, do:
+
+<ul><pre>
+% java Main2 <i>arg1</i> <i>arg2</i>...
+</pre></ul>
+
+<p>The class <code>MyApp</code> and the other application classes
+are translated by <code>MyTranslator</code>.
+
+<p>Note that <em>application</em> classes like <code>MyApp</code> cannot
+access the <em>loader</em> classes such as <code>Main2</code>,
+<code>MyTranslator</code>, and <code>ClassPool</code> because they
+are loaded by different loaders. The application classes are loaded
+by <code>javassist.Loader</code> whereas the loader classes such as
+<code>Main2</code> are by the default Java class loader.
+
+<p><code>javassist.Loader</code> searches for classes in a different
+order from <code>java.lang.ClassLoader</code>.
+<code>ClassLoader</code> first delegates the loading operations to
+the parent class loader and then attempts to load the classes
+only if the parent class loader cannot find them.
+On the other hand,
+<code>javassist.Loader</code> attempts
+to load the classes before delegating to the parent class loader.
+It delegates only if:
+
+<ul><li>the classes are not found by calling <code>get()</code> on
+a <code>ClassPool</code> object, or
+
+<p><li>the classes have been specified by using
+<code>delegateLoadingOf()</code>
+to be loaded by the parent class loader.
+</ul>
+
+<p>This search order allows loading modified classes by Javassist.
+However, it delegates to the parent class loader if it fails
+to find modified classes for some reason. Once a class is loaded by
+the parent class loader, the other classes referred to in that class will be
+also loaded by the parent class loader and thus they are never modified.
+Recall that all the classes referred to in a class C are loaded by the
+real loader of C.
+<em>If your program fails to load a modified class,</em> you should
+make sure whether all the classes using that class have been loaded by
+<code>javassist.Loader</code>.
+
+<p><br>
+
+<h3>3.4 Writing a class loader</h3>
+
+<p>A simple class loader using Javassist is as follows:
+
+<ul><pre>import javassist.*;
+
+public class SampleLoader extends ClassLoader {
+ /* Call MyApp.main().
+ */
+ public static void main(String[] args) throws Throwable {
+ SampleLoader s = new SampleLoader();
+ Class c = s.loadClass("MyApp");
+ c.getDeclaredMethod("main", new Class[] { String[].class })
+ .invoke(null, new Object[] { args });
+ }
+
+ private ClassPool pool;
+
+ public SampleLoader() throws NotFoundException {
+ pool = new ClassPool();
+ pool.insertClassPath("./class"); // <em>MyApp.class must be there.</em>
+ }
+
+ /* Finds a specified class.
+ * The bytecode for that class can be modified.
+ */
+ protected Class findClass(String name) throws ClassNotFoundException {
+ try {
+ CtClass cc = pool.get(name);
+ // <em>modify the CtClass object here</em>
+ byte[] b = cc.toBytecode();
+ return defineClass(name, b, 0, b.length);
+ } catch (NotFoundException e) {
+ throw new ClassNotFoundException();
+ } catch (IOException e) {
+ throw new ClassNotFoundException();
+ } catch (CannotCompileException e) {
+ throw new ClassNotFoundException();
+ }
+ }
+}</pre></ul>
+
+<p>The class <code>MyApp</code> is an application program.
+To execute this program, first put the class file under the
+<code>./class</code> directory, which must <em>not</em> be included
+in the class search path. Otherwise, <code>MyApp.class</code> would
+be loaded by the default system class loader, which is the parent
+loader of <code>SampleLoader</code>.
+The directory name <code>./class</code> is specified by
+<code>insertClassPath()</code> in the constructor.
+You can choose a different name instead of <code>./class</code> if you want.
+Then do as follows:
+
+<ul><code>% java SampleLoader</code></ul>
+
+<p>The class loader loads the class <code>MyApp</code>
+(<code>./class/MyApp.class</code>) and calls
+<code>MyApp.main()</code> with the command line parameters.
+
+<p>This is the simplest way of using Javassist. However, if you write
+a more complex class loader, you may need detailed knowledge of
+Java's class loading mechanism. For example, the program above puts the
+<code>MyApp</code> class in a name space separated from the name space
+that the class <code>SampleLoader</code> belongs to because the two
+classes are loaded by different class loaders.
+Hence, the
+<code>MyApp</code> class cannot directly access the class
+<code>SampleLoader</code>.
+
+<p><br>
+
+<h3>3.5 Modifying a system class</h3>
+
+<p>The system classes like <code>java.lang.String</code> cannot be
+loaded by a class loader other than the system class loader.
+Therefore, <code>SampleLoader</code> or <code>javassist.Loader</code>
+shown above cannot modify the system classes at loading time.
+
+<p>If your application needs to do that, the system classes must be
+<em>statically</em> modified. For example, the following program
+adds a new field <code>hiddenValue</code> to <code>java.lang.String</code>:
+
+<ul><pre>ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("java.lang.String");
+cc.addField(new CtField(CtClass.intType, "hiddenValue", cc));
+cc.writeFile(".");</pre></ul>
+
+<p>This program produces a file <code>"./java/lang/String.class"</code>.
+
+<p>To run your program <code>MyApp</code>
+with this modified <code>String</code> class, do as follows:
+
+<ul><pre>
+% java -Xbootclasspath/p:. MyApp <i>arg1</i> <i>arg2</i>...
+</pre></ul>
+
+<p>Suppose that the definition of <code>MyApp</code> is as follows:
+
+<ul><pre>public class MyApp {
+ public static void main(String[] args) throws Exception {
+ System.out.println(String.class.getField("hiddenValue").getName());
+ }
+}</pre></ul>
+
+<p>If the modified <code>String</code> class is correctly loaded,
+<code>MyApp</code> prints <code>hiddenValue</code>.
+
+<p><i>Note: Applications that use this technique for the purpose of
+overriding a system class in <code>rt.jar</code> should not be
+deployed as doing so would contravene the Java 2 Runtime Environment
+binary code license.</i>
+
+<p><br>
+
+<a name="hotswap">
+<h3>3.6 Reloading a class at runtime</h3></a>
+
+<p>If the JVM is launched with the JPDA (Java Platform Debugger
+Architecture) enabled, a class is dynamically reloadable. After the
+JVM loads a class, the old version of the class definition can be
+unloaded and a new one can be reloaded again. That is, the definition
+of that class can be dynamically modified during runtime. However,
+the new class definition must be somewhat compatible to the old one.
+<em>The JVM does not allow schema changes between the two versions.</em>
+They have the same set of methods and fields.
+
+<p>Javassist provides a convenient class for reloading a class at runtime.
+For more information, see the API documentation of
+<code>javassist.tools.HotSwapper</code>.
+
+<p><br>
+
+<a href="tutorial2.html">Next page</a>
+
+<hr>
+Java(TM) is a trademark of Sun Microsystems, Inc.<br>
+Copyright (C) 2000-2010 by Shigeru Chiba, All rights reserved.
+</body>
+</html>
diff --git a/tutorial/tutorial2.html b/tutorial/tutorial2.html
new file mode 100644
index 0000000..445fc90
--- /dev/null
+++ b/tutorial/tutorial2.html
@@ -0,0 +1,1627 @@
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+ <title>Javassist Tutorial</title>
+ <link rel="stylesheet" type="text/css" href="brown.css">
+</head>
+
+<body>
+
+<div align="right">Getting Started with Javassist</div>
+
+<div align="left"><a href="tutorial.html">Previous page</a></div>
+<div align="right"><a href="tutorial3.html">Next page</a></div>
+
+<p>
+<a href="#intro">4. Introspection and customization</a>
+<ul>
+<li><a href="#before">Inserting source text at the beginning/end of a method body</a>
+<br><li><a href="#alter">Altering a method body</a>
+<br><li><a href="#add">Adding a new method or field</a>
+<br><li><a href="#runtime">Runtime support classes</a>
+<br><li><a href="#annotation">Annotations</a>
+<br><li><a href="#import">Import</a>
+<br><li><a href="#limit">Limitations</a>
+</ul>
+
+<p><br>
+
+<a name="intro">
+<h2>4. Introspection and customization</h2>
+
+<p><code>CtClass</code> provides methods for introspection. The
+introspective ability of Javassist is compatible with that of
+the Java reflection API. <code>CtClass</code> provides
+<code>getName()</code>, <code>getSuperclass()</code>,
+<code>getMethods()</code>, and so on.
+<code>CtClass</code> also provides methods for modifying a class
+definition. It allows to add a new field, constructor, and method.
+Instrumenting a method body is also possible.
+
+<p>
+Methods are represented by <code>CtMethod</code> objects.
+<code>CtMethod</code> provides several methods for modifying
+the definition of the method. Note that if a method is inherited
+from a super class, then
+the same <code>CtMethod</code> object
+that represents the inherited method represents the method declared
+in that super class.
+A <code>CtMethod</code> object corresponds to every method declaration.
+
+<p>
+For example, if class <code>Point</code> declares method <code>move()</code>
+and a subclass <code>ColorPoint</code> of <code>Point</code> does
+not override <code>move()</code>, the two <code>move()</code> methods
+declared in <code>Point</code> and inherited in <code>ColorPoint</code>
+are represented by the identical <code>CtMethod</code> object.
+If the method definition represented by this
+<code>CtMethod</code> object is modified, the modification is
+reflected on both the methods.
+If you want to modify only the <code>move()</code> method in
+<code>ColorPoint</code>, you first have to add to <code>ColorPoint</code>
+a copy of the <code>CtMethod</code> object representing <code>move()</code>
+in <code>Point</code>. A copy of the the <code>CtMethod</code> object
+can be obtained by <code>CtNewMethod.copy()</code>.
+
+
+<p><hr width="40%">
+
+<ul>
+Javassist does not allow to remove a method or field, but it allows
+to change the name. So if a method is not necessary any more, it should be
+renamed and changed to be a private method by calling
+<code>setName()</code>
+and <code>setModifiers()</code> declared in <code>CtMethod</code>.
+
+<p>Javassist does not allow to add an extra parameter to an existing
+method, either. Instead of doing that, a new method receiving the
+extra parameter as well as the other parameters should be added to the
+same class. For example, if you want to add an extra <code>int</code>
+parameter <code>newZ</code> to a method:
+
+<ul><pre>void move(int newX, int newY) { x = newX; y = newY; }</pre></ul>
+
+<p>in a <code>Point</code> class, then you should add the following
+method to the <code>Point</code> class:
+
+<ul><pre>void move(int newX, int newY, int newZ) {
+ // do what you want with newZ.
+ move(newX, newY);
+}</pre></ul>
+
+</ul>
+
+<p><hr width="40%">
+
+<p>Javassist also provides low-level API for directly editing a raw
+class file. For example, <code>getClassFile()</code> in
+<code>CtClass</code> returns a <code>ClassFile</code> object
+representing a raw class file. <code>getMethodInfo()</code> in
+<code>CtMethod</code> returns a <code>MethodInfo</code> object
+representing a <code>method_info</code> structure included in a class
+file. The low-level API uses the vocabulary from the Java Virtual
+machine specification. The users must have the knowledge about class
+files and bytecode. For more details, the users should see the
+<a href="tutorial3.html#intro"><code>javassist.bytecode</code> package</a>.
+
+<p>The class files modified by Javassist requires the
+<code>javassist.runtime</code> package for runtime support
+only if some special identifiers starting with <code>$</code>
+are used. Those special identifiers are described below.
+The class files modified without those special identifiers
+do not need the <code>javassist.runtime</code> package or any
+other Javassist packages at runtime.
+For more details, see the API documentation
+of the <code>javassist.runtime</code> package.
+
+<p><br>
+
+<a name="before">
+<h3>4.1 Inserting source text at the beginning/end of a method body</h3>
+
+<p><code>CtMethod</code> and <code>CtConstructor</code> provide
+methods <code>insertBefore()</code>, <code>insertAfter()</code>, and
+<code>addCatch()</code>. They are used for inserting a code fragment
+into the body of an existing method. The users can specify those code
+fragments with <em>source text</em> written in Java.
+Javassist includes a simple Java compiler for processing source
+text. It receives source text
+written in Java and compiles it into Java bytecode, which will be
+<em>inlined</em> into a method body.
+
+<p>
+Inserting a code fragment at the position specified by a line number
+is also possible
+(if the line number table is contained in the class file).
+<code>insertAt()</code> in <code>CtMethod</code> and
+<code>CtConstructor</code> takes source text and a line number in the source
+file of the original class definition.
+It compiles the source text and inserts the compiled code at the line number.
+
+<p>The methods <code>insertBefore()</code>, <code>insertAfter()</code>,
+<code>addCatch()</code>, and <code>insertAt()</code>
+receive a <code>String</code> object representing
+a statement or a block. A statement is a single control structure like
+<code>if</code> and <code>while</code> or an expression ending with
+a semi colon (<code>;</code>). A block is a set of
+statements surrounded with braces <code>{}</code>.
+Hence each of the following lines is an example of valid statement or block:
+
+<ul><pre>System.out.println("Hello");
+{ System.out.println("Hello"); }
+if (i < 0) { i = -i; }
+</pre></ul>
+
+<p>The statement and the block can refer to fields and methods.
+They can also refer to the parameters
+to the method that they are inserted into
+if that method was compiled with the -g option
+(to include a local variable attribute in the class file).
+Otherwise, they must access the method parameters through the special
+variables <code>$0</code>, <code>$1</code>, <code>$2</code>, ... described
+below.
+<em>Accessing local variables declared in the method is not allowed</em>
+although declaring a new local variable in the block is allowed.
+However, <code>insertAt()</code> allows the statement and the block
+to access local variables
+if these variables are available at the specified line number
+and the target method was compiled with the -g option.
+
+
+<!--
+<p><center><table border=8 cellspacing=0 bordercolor="#cfcfcf">
+<tr><td bgcolor="#cfcfcf">
+<b>Tip:</b>
+<br>    Local variables are not accessible.  
+</td></tr>
+</table></center>
+-->
+
+<p>The <code>String</code> object passed to the methods
+<code>insertBefore()</code>, <code>insertAfter()</code>,
+<code>addCatch()</code>, and <code>insertAt()</code> are compiled by
+the compiler included in Javassist.
+Since the compiler supports language extensions,
+several identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+<tr>
+<td><code>$0</code>, <code>$1</code>, <code>$2</code>, ...    </td>
+<td><code>this</code> and actual parameters</td>
+</tr>
+
+<tr>
+<td><code>$args</code></td>
+<td>An array of parameters.
+The type of <code>$args</code> is <code>Object[]</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$$</code></td>
+<td rowspan=2>All actual parameters.<br>
+For example, <code>m($$)</code> is equivalent to
+<code>m($1,$2,</code>...<code>)</code></td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$cflow(</code>...<code>)</code></td>
+<td><code>cflow</code> variable</td>
+</tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>The result type. It is used in a cast expression.</td>
+</tr>
+
+<tr>
+<td><code>$w</code></td>
+<td>The wrapper type. It is used in a cast expression.</td>
+</tr>
+
+<tr>
+<td><code>$_</code></td>
+<td>The resulting value</td>
+</tr>
+
+<tr>
+<td><code>$sig</code></td>
+<td>An array of <code>java.lang.Class</code> objects representing
+the formal parameter types.
+</td>
+</tr>
+
+<tr>
+<td><code>$type</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the formal result type.</td>
+</tr>
+
+<tr>
+<td><code>$class</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the class currently edited.</td>
+</tr>
+
+</table>
+</ul>
+
+<h4>$0, $1, $2, ...</h4>
+
+<p>The parameters passed to the target method
+are accessible with
+<code>$1</code>, <code>$2</code>, ... instead of
+the original parameter names.
+<code>$1</code> represents the
+first parameter, <code>$2</code> represents the second parameter, and
+so on. The types of those variables are identical to the parameter
+types.
+<code>$0</code> is
+equivalent to <code>this</code>. If the method is static,
+<code>$0</code> is not available.
+
+<p>These variables are used as following. Suppose that a class
+<code>Point</code>:
+
+<pre><ul>class Point {
+ int x, y;
+ void move(int dx, int dy) { x += dx; y += dy; }
+}
+</ul></pre>
+
+<p>To print the values of <code>dx</code> and <code>dy</code>
+whenever the method <code>move()</code> is called, execute this
+program:
+
+<ul><pre>ClassPool pool = ClassPool.getDefault();
+CtClass cc = pool.get("Point");
+CtMethod m = cc.getDeclaredMethod("move");
+m.insertBefore("{ System.out.println($1); System.out.println($2); }");
+cc.writeFile();
+</pre></ul>
+
+<p>Note that the source text passed to <code>insertBefore()</code> is
+surrounded with braces <code>{}</code>.
+<code>insertBefore()</code> accepts only a single statement or a block
+surrounded with braces.
+
+<p>The definition of the class <code>Point</code> after the
+modification is like this:
+
+<pre><ul>class Point {
+ int x, y;
+ void move(int dx, int dy) {
+ { System.out.println(dx); System.out.println(dy); }
+ x += dx; y += dy;
+ }
+}
+</ul></pre>
+
+<p><code>$1</code> and <code>$2</code> are replaced with
+<code>dx</code> and <code>dy</code>, respectively.
+
+<p><code>$1</code>, <code>$2</code>, <code>$3</code> ... are
+updatable. If a new value is assigend to one of those variables,
+then the value of the parameter represented by that variable is
+also updated.
+
+
+<h4>$args</h4>
+
+<p>The variable <code>$args</code> represents an array of all the
+parameters. The type of that variable is an array of class
+<code>Object</code>. If a parameter type is a primitive type such as
+<code>int</code>, then the parameter value is converted into a wrapper
+object such as <code>java.lang.Integer</code> to store in
+<code>$args</code>. Thus, <code>$args[0]</code> is equivalent to
+<code>$1</code> unless the type of the first parameter is a primitive
+type. Note that <code>$args[0]</code> is not equivalent to
+<code>$0</code>; <code>$0</code> represents <code>this</code>.
+
+<p>If an array of <code>Object</code> is assigned to
+<code>$args</code>, then each element of that array is
+assigned to each parameter. If a parameter type is a primitive
+type, the type of the corresponding element must be a wrapper type.
+The value is converted from the wrapper type to the primitive type
+before it is assigned to the parameter.
+
+<h4>$$</h4>
+
+<p>The variable <code>$$</code> is abbreviation of a list of
+all the parameters separated by commas.
+For example, if the number of the parameters
+to method <code>move()</code> is three, then
+
+<ul><pre>move($$)</pre></ul>
+
+<p>is equivalent to this:
+
+<ul><pre>move($1, $2, $3)</pre></ul>
+
+<p>If <code>move()</code> does not take any parameters,
+then <code>move($$)</code> is
+equivalent to <code>move()</code>.
+
+<p><code>$$</code> can be used with another method.
+If you write an expression:
+
+<ul><pre>exMove($$, context)</pre></ul>
+
+<p>then this expression is equivalent to:
+
+<ul><pre>exMove($1, $2, $3, context)</pre></ul>
+
+<p>Note that <code>$$</code> enables generic notation of method call
+with respect to the number of parameters.
+It is typically used with <code>$proceed</code> shown later.
+
+<h4>$cflow</h4>
+
+<p><code>$cflow</code> means "control flow".
+This read-only variable returns the depth of the recursive calls
+to a specific method.
+
+<p>Suppose that the method shown below is represented by a
+<code>CtMethod</code> object <code>cm</code>:
+
+<ul><pre>int fact(int n) {
+ if (n <= 1)
+ return n;
+ else
+ return n * fact(n - 1);
+}</pre></ul>
+
+<p>To use <code>$cflow</code>, first declare that <code>$cflow</code>
+is used for monitoring calls to the method <code>fact()</code>:
+
+<ul><pre>CtMethod cm = ...;
+cm.useCflow("fact");</pre></ul>
+
+<p>The parameter to <code>useCflow()</code> is the identifier of the
+declared <code>$cflow</code> variable. Any valid Java name can be
+used as the identifier. Since the identifier can also include
+<code>.</code> (dot), for example, <code>"my.Test.fact"</code>
+is a valid identifier.
+
+<p>Then, <code>$cflow(fact)</code> represents the depth of the
+recursive calls to the method specified by <code>cm</code>. The value
+of <code>$cflow(fact)</code> is 0 (zero) when the method is
+first called whereas it is 1 when the method is recursively called
+within the method. For example,
+
+<ul><pre>
+cm.insertBefore("if ($cflow(fact) == 0)"
+ + " System.out.println(\"fact \" + $1);");
+</pre></ul>
+
+<p>translates the method <code>fact()</code> so that it shows the
+parameter. Since the value of <code>$cflow(fact)</code> is checked,
+the method <code>fact()</code> does not show the parameter if it is
+recursively called within <code>fact()</code>.
+
+<p>The value of <code>$cflow</code> is the number of stack frames
+associated with the specified method <code>cm</code>
+under the current topmost
+stack frame for the current thread. <code>$cflow</code> is also
+accessible within a method different from the specified method
+<code>cm</code>.
+
+<h4>$r</h4>
+
+<p><code>$r</code> represents the result type (return type) of the method.
+It must be used as the cast type in a cast expression.
+For example, this is a typical use:
+
+<ul><pre>Object result = ... ;
+$_ = ($r)result;</pre></ul>
+
+<p>If the result type is a primitive type, then <code>($r)</code>
+follows special semantics. First, if the operand type of the cast
+expression is a primitive type, <code>($r)</code> works as a normal
+cast operator to the result type.
+On the other hand, if the operand type is a wrapper type,
+<code>($r)</code> converts from the wrapper type to the result type.
+For example, if the result type is <code>int</code>, then
+<code>($r)</code> converts from <code>java.lang.Integer</code> to
+<code>int</code>.
+
+<p>If the result type is <code>void</code>, then
+<code>($r)</code> does not convert a type; it does nothing.
+However, if the operand is a call to a <code>void</code> method,
+then <code>($r)</code> results in <code>null</code>. For example,
+if the result type is <code>void</code> and
+<code>foo()</code> is a <code>void</code> method, then
+
+<ul><pre>$_ = ($r)foo();</pre></ul>
+
+<p>is a valid statement.
+
+<p>The cast operator <code>($r)</code> is also useful in a
+<code>return</code> statement. Even if the result type is
+<code>void</code>, the following <code>return</code> statement is valid:
+
+<ul><pre>return ($r)result;</pre></ul>
+
+<p>Here, <code>result</code> is some local variable.
+Since <code>($r)</code> is specified, the resulting value is
+discarded.
+This <code>return</code> statement is regarded as the equivalent
+of the <code>return</code> statement without a resulting value:
+
+<ul><pre>return;</pre></ul>
+
+<h4>$w</h4>
+
+<p><code>$w</code> represents a wrapper type.
+It must be used as the cast type in a cast expression.
+<code>($w)</code> converts from a primitive type to the corresponding
+wrapper type.
+
+The following code is an example:
+
+<ul><pre>Integer i = ($w)5;</pre></ul>
+
+<p>The selected wrapper type depends on the type of the expression
+following <code>($w)</code>. If the type of the expression is
+<code>double</code>, then the wrapper type is <code>java.lang.Double</code>.
+
+<p>If the type of the expression following <code>($w)</code> is not
+a primitive type, then <code>($w)</code> does nothing.
+
+<h4>$_</h4>
+
+<p><code>insertAfter()</code> in <code>CtMethod</code> and
+<code>CtConstructor</code> inserts the
+compiled code at the end of the method. In the statement given to
+<code>insertAfter()</code>, not only the variables shown above such as
+<code>$0</code>, <code>$1</code>, ... but also <code>$_</code> is
+available.
+
+<p>The variable <code>$_</code> represents the resulting value of the
+method. The type of that variable is the type of the result type (the
+return type) of the method. If the result type is <code>void</code>,
+then the type of <code>$_</code> is <code>Object</code> and the value
+of <code>$_</code> is <code>null</code>.
+
+<p>Although the compiled code inserted by <code>insertAfter()</code>
+is executed just before the control normally returns from the method,
+it can be also executed when an exception is thrown from the method.
+To execute it when an exception is thrown, the second parameter
+<code>asFinally</code> to <code>insertAfter()</code> must be
+<code>true</code>.
+
+<p>If an exception is thrown, the compiled code inserted by
+<code>insertAfter()</code> is executed as a <code>finally</code>
+clause. The value of <code>$_</code> is <code>0</code> or
+<code>null</code> in the compiled code. After the execution of the
+compiled code terminates, the exception originally thrown is re-thrown
+to the caller. Note that the value of <code>$_</code> is never thrown
+to the caller; it is rather discarded.
+
+<h4>$sig</h4>
+
+<p>The value of <code>$sig</code> is an array of
+<code>java.lang.Class</code> objects that represent the formal
+parameter types in declaration order.
+
+<h4>$type</h4>
+
+<p>The value of <code>$type</code> is an <code>java.lang.Class</code>
+object representing the formal type of the result value. This
+variable refers to <code>Void.class</code> if this is a constructor.
+
+<h4>$class</h4>
+
+<p>The value of <code>$class</code> is an <code>java.lang.Class</code>
+object representing the class in which the edited method is declared.
+This represents the type of <code>$0</code>.
+
+<h4>addCatch()</h4>
+
+<p><code>addCatch()</code> inserts a code fragment into a method body
+so that the code fragment is executed when the method body throws
+an exception and the control returns to the caller. In the source
+text representing the inserted code fragment, the exception value
+is referred to with the special variable <code>$e</code>.
+
+<p>For example, this program:
+
+<ul><pre>
+CtMethod m = ...;
+CtClass etype = ClassPool.getDefault().get("java.io.IOException");
+m.addCatch("{ System.out.println($e); throw $e; }", etype);
+</pre></ul>
+
+<p>translates the method body represented by <code>m</code> into
+something like this:
+
+<ul><pre>
+try {
+ <font face="serif"><em>the original method body</em></font>
+}
+catch (java.io.IOException e) {
+ System.out.println(e);
+ throw e;
+}
+</pre></ul>
+
+<p>Note that the inserted code fragment must end with a
+<code>throw</code> or <code>return</code> statement.
+
+<p><br>
+
+<a name="alter">
+<h3>4.2 Altering a method body</h3>
+
+<p><code>CtMethod</code> and <code>CtConstructor</code> provide
+<code>setBody()</code> for substituting a whole
+method body. They compile the given source text into Java bytecode
+and substitutes it for the original method body. If the given source
+text is <code>null</code>, the substituted body includes only a
+<code>return</code> statement, which returns zero or null unless the
+result type is <code>void</code>.
+
+<p>In the source text given to <code>setBody()</code>, the identifiers
+starting with <code>$</code> have special meaning
+
+<ul><table border=0>
+<tr>
+<td><code>$0</code>, <code>$1</code>, <code>$2</code>, ...    </td>
+<td><code>this</code> and actual parameters</td>
+</tr>
+
+<tr>
+<td><code>$args</code></td>
+<td>An array of parameters.
+The type of <code>$args</code> is <code>Object[]</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$$</code></td>
+<td>All actual parameters.<br>
+</tr>
+
+<tr>
+<td><code>$cflow(</code>...<code>)</code></td>
+<td><code>cflow</code> variable</td>
+</tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>The result type. It is used in a cast expression.</td>
+</tr>
+
+<tr>
+<td><code>$w</code></td>
+<td>The wrapper type. It is used in a cast expression.</td>
+</tr>
+
+<tr>
+<td><code>$sig</code></td>
+<td>An array of <code>java.lang.Class</code> objects representing
+the formal parameter types.
+</td>
+</tr>
+
+<tr>
+<td><code>$type</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the formal result type.</td>
+</tr>
+
+<tr>
+<td><code>$class</code></td>
+<td rowspan=2>A <code>java.lang.Class</code> object representing
+the class that declares the method<br>
+currently edited (the type of $0).</td>
+</tr>
+
+<tr><td> </td></tr>
+
+</table>
+</ul>
+
+Note that <code>$_</code> is not available.
+
+<h4>Substituting source text for an existing expression</h4>
+
+<p>Javassist allows modifying only an expression included in a method body.
+<code>javassist.expr.ExprEditor</code> is a class
+for replacing an expression in a method body.
+The users can define a subclass of <code>ExprEditor</code>
+to specify how an expression is modified.
+
+<p>To run an <code>ExprEditor</code> object, the users must
+call <code>instrument()</code> in <code>CtMethod</code> or
+<code>CtClass</code>.
+
+For example,
+
+<ul><pre>
+CtMethod cm = ... ;
+cm.instrument(
+ new ExprEditor() {
+ public void edit(MethodCall m)
+ throws CannotCompileException
+ {
+ if (m.getClassName().equals("Point")
+ && m.getMethodName().equals("move"))
+ m.replace("{ $1 = 0; $_ = $proceed($$); }");
+ }
+ });
+</pre></ul>
+
+<p>searches the method body represented by <code>cm</code> and
+replaces all calls to <code>move()</code> in class <code>Point</code>
+with a block:
+
+<ul><pre>{ $1 = 0; $_ = $proceed($$); }
+</pre></ul>
+
+<p>so that the first parameter to <code>move()</code> is always 0.
+Note that the substituted code is not an expression but
+a statement or a block. It cannot be or contain a try-catch statement.
+
+<p>The method <code>instrument()</code> searches a method body.
+If it finds an expression such as a method call, field access, and object
+creation, then it calls <code>edit()</code> on the given
+<code>ExprEditor</code> object. The parameter to <code>edit()</code>
+is an object representing the found expression. The <code>edit()</code>
+method can inspect and replace the expression through that object.
+
+<p>Calling <code>replace()</code> on the parameter to <code>edit()</code>
+substitutes the given statement or block for the expression. If the given
+block is an empty block, that is, if <code>replace("{}")</code>
+is executed, then the expression is removed from the method body.
+
+If you want to insert a statement (or a block) before/after the
+expression, a block like the following should be passed to
+<code>replace()</code>:
+
+<ul><pre>
+{ <em>before-statements;</em>
+ $_ = $proceed($$);
+ <em>after-statements;</em> }
+</pre></ul>
+
+<p>whichever the expression is either a method call, field access,
+object creation, or others. The second statement could be:
+
+<ul><pre>$_ = $proceed();</pre></ul>
+
+<p>if the expression is read access, or
+
+<ul><pre>$proceed($$);</pre></ul>
+
+<p>if the expression is write access.
+
+<p>Local variables available in the target expression is
+also available in the source text passed to <code>replace()</code>
+if the method searched by <code>instrument()</code> was compiled
+with the -g option (the class file includes a local variable
+attribute).
+
+<h4>javassist.expr.MethodCall</h4>
+
+<p>A <code>MethodCall</code> object represents a method call.
+The method <code>replace()</code> in
+<code>MethodCall</code> substitutes a statement or
+a block for the method call.
+It receives source text representing the substitued statement or
+block, in which the identifiers starting with <code>$</code>
+have special meaning as in the source text passed to
+<code>insertBefore()</code>.
+
+<ul><table border=0>
+<tr>
+<td><code>$0</code></td>
+<td rowspan=3>
+The target object of the method call.<br>
+This is not equivalent to <code>this</code>, which represents
+the caller-side <code>this</code> object.<br>
+<code>$0</code> is <code>null</code> if the method is static.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$1</code>, <code>$2</code>, ...    </td>
+<td>
+The parameters of the method call.
+</td>
+</tr>
+
+<tr><td>
+<code>$_</code></td>
+<td>The resulting value of the method call.</td>
+</tr>
+
+<tr><td><code>$r</code></td>
+<td>The result type of the method call.</td>
+</tr>
+
+<tr><td><code>$class</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the class declaring the method.
+</td>
+</tr>
+
+<tr><td><code>$sig</code>    </td>
+<td>An array of <code>java.lang.Class</code> objects representing
+the formal parameter types.</td>
+</tr>
+
+<tr><td><code>$type</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the formal result type.</td>
+</tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td>The name of the method originally called
+in the expression.</td>
+</tr>
+
+</table>
+</ul>
+
+<p>Here the method call means the one represented by the
+<code>MethodCall</code> object.
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<p>Unless the result type of the method call is <code>void</code>,
+a value must be assigned to
+<code>$_</code> in the source text and the type of <code>$_</code>
+is the result type.
+If the result type is <code>void</code>, the type of <code>$_</code>
+is <code>Object</code> and the value assigned to <code>$_</code>
+is ignored.
+
+<p><code>$proceed</code> is not a <code>String</code> value but special
+syntax. It must be followed by an argument list surrounded by parentheses
+<code>( )</code>.
+
+<h4>javassist.expr.ConstructorCall</h4>
+
+<p>A <code>ConstructorCall</code> object represents a constructor call
+such as <code>this()</code> and <code>super</code> included in a constructor
+body.
+The method <code>replace()</code> in
+<code>ConstructorCall</code> substitutes a statement or
+a block for the constructor call.
+It receives source text representing the substituted statement or
+block, in which the identifiers starting with <code>$</code>
+have special meaning as in the source text passed to
+<code>insertBefore()</code>.
+
+<ul><table border=0>
+<tr>
+<td><code>$0</code></td>
+<td>
+The target object of the constructor call.
+This is equivalent to <code>this</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$1</code>, <code>$2</code>, ...    </td>
+<td>
+The parameters of the constructor call.
+</td>
+</tr>
+
+<tr><td><code>$class</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the class declaring the constructor.
+</td>
+</tr>
+
+<tr><td><code>$sig</code>    </td>
+<td>An array of <code>java.lang.Class</code> objects representing
+the formal parameter types.</td>
+</tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td>The name of the constructor originally called
+in the expression.</td>
+</tr>
+
+</table>
+</ul>
+
+<p>Here the constructor call means the one represented by the
+<code>ConstructorCall</code> object.
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<p>Since any constructor must call either a constructor of the super
+class or another constructor of the same class,
+the substituted statement must include a constructor call,
+normally a call to <code>$proceed()</code>.
+
+<p><code>$proceed</code> is not a <code>String</code> value but special
+syntax. It must be followed by an argument list surrounded by parentheses
+<code>( )</code>.
+
+<h4>javassist.expr.FieldAccess</h4>
+
+<p>A <code>FieldAccess</code> object represents field access.
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if field access is found.
+The method <code>replace()</code> in
+<code>FieldAccess</code> receives
+source text representing the substitued statement or
+block for the field access.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+<tr>
+<td><code>$0</code></td>
+<td rowspan=3>
+The object containing the field accessed by the expression.
+This is not equivalent to <code>this</code>.<br>
+<code>this</code> represents the object that the method including the
+expression is invoked on.<br>
+<code>$0</code> is <code>null</code> if the field is static.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$1</code></td>
+<td rowspan=2>
+The value that would be stored in the field
+if the expression is write access.
+<br>Otherwise, <code>$1</code> is not available.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$_</code></td>
+<td rowspan=2>
+The resulting value of the field access
+if the expression is read access.
+<br>Otherwise, the value stored in <code>$_</code> is discarded.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+<tr>
+<td><code>$r</code></td>
+<td rowspan=2>
+The type of the field if the expression is read access.
+<br>Otherwise, <code>$r</code> is <code>void</code>.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr><td><code>$class</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the class declaring the field.
+</td></tr>
+
+<tr><td><code>$type</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the field type.</td>
+</tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td>The name of a virtual method executing the original
+field access.
+.</td>
+</tr>
+
+</table>
+</ul>
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<p>If the expression is read access, a value must be assigned to
+<code>$_</code> in the source text. The type of <code>$_</code>
+is the type of the field.
+
+<h4>javassist.expr.NewExpr</h4>
+
+<p>A <code>NewExpr</code> object represents object creation
+with the <code>new</code> operator (not including array creation).
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if object creation is found.
+The method <code>replace()</code> in
+<code>NewExpr</code> receives
+source text representing the substitued statement or
+block for the object creation.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+
+<tr>
+<td><code>$0</code></td>
+<td>
+<code>null</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$1</code>, <code>$2</code>, ...    </td>
+<td>
+The parameters to the constructor.
+</td>
+</tr>
+
+<tr>
+<td><code>$_</code></td>
+<td rowspan=2>
+The resulting value of the object creation.
+<br>A newly created object must be stored in this variable.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>
+The type of the created object.
+</td>
+</tr>
+
+<tr><td><code>$sig</code>    </td>
+<td>An array of <code>java.lang.Class</code> objects representing
+the formal parameter types.</td>
+</tr>
+
+<tr><td><code>$type</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the class of the created object.
+</td></tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td>The name of a virtual method executing the original
+object creation.
+.</td>
+</tr>
+
+</table>
+</ul>
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<h4>javassist.expr.NewArray</h4>
+
+<p>A <code>NewArray</code> object represents array creation
+with the <code>new</code> operator.
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if array creation is found.
+The method <code>replace()</code> in
+<code>NewArray</code> receives
+source text representing the substitued statement or
+block for the array creation.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+
+<tr>
+<td><code>$0</code></td>
+<td>
+<code>null</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$1</code>, <code>$2</code>, ...    </td>
+<td>
+The size of each dimension.
+</td>
+</tr>
+
+<tr>
+<td><code>$_</code></td>
+<td rowspan=2>
+The resulting value of the array creation.
+<br>A newly created array must be stored in this variable.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>
+The type of the created array.
+</td>
+</tr>
+
+<tr><td><code>$type</code>    </td>
+<td>A <code>java.lang.Class</code> object representing
+the class of the created array.
+</td></tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td>The name of a virtual method executing the original
+array creation.
+.</td>
+</tr>
+
+</table>
+</ul>
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<p>For example, if the array creation is the following expression,
+
+<ul><pre>
+String[][] s = new String[3][4];
+</pre></ul>
+
+then the value of $1 and $2 are 3 and 4, respectively. $3 is not available.
+
+<p>If the array creation is the following expression,
+
+<ul><pre>
+String[][] s = new String[3][];
+</pre></ul>
+
+then the value of $1 is 3 but $2 is not available.
+
+<h4>javassist.expr.Instanceof</h4>
+
+<p>A <code>Instanceof</code> object represents an <code>instanceof</code>
+expression.
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if an instanceof expression is found.
+The method <code>replace()</code> in
+<code>Instanceof</code> receives
+source text representing the substitued statement or
+block for the expression.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+
+<tr>
+<td><code>$0</code></td>
+<td>
+<code>null</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$1</code></td>
+<td>
+The value on the left hand side of the original
+<code>instanceof</code> operator.
+</td>
+</tr>
+
+<tr>
+<td><code>$_</code></td>
+<td>
+The resulting value of the expression.
+The type of <code>$_</code> is <code>boolean</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>
+The type on the right hand side of the <code>instanceof</code> operator.
+</td>
+</tr>
+
+<tr><td><code>$type</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the type on the right hand side of the <code>instanceof</code> operator.
+</td>
+</tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td rowspan=4>The name of a virtual method executing the original
+<code>instanceof</code> expression.
+<br>It takes one parameter (the type is <code>java.lang.Object</code>)
+and returns true
+<br>if the parameter value is an instance of the type on the right
+hand side of
+<br>the original <code>instanceof</code> operator.
+Otherwise, it returns false.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+<tr><td> </td></tr>
+<tr><td> </td></tr>
+
+</table>
+</ul>
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<h4>javassist.expr.Cast</h4>
+
+<p>A <code>Cast</code> object represents an expression for
+explicit type casting.
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if explicit type casting is found.
+The method <code>replace()</code> in
+<code>Cast</code> receives
+source text representing the substitued statement or
+block for the expression.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have special meaning:
+
+<ul><table border=0>
+
+<tr>
+<td><code>$0</code></td>
+<td>
+<code>null</code>.
+</td>
+</tr>
+
+<tr>
+<td><code>$1</code></td>
+<td>
+The value the type of which is explicitly cast.
+</td>
+</tr>
+
+<tr>
+<td><code>$_</code></td>
+<td rowspan=2>
+The resulting value of the expression.
+The type of <code>$_</code> is the same as the type
+<br>after the explicit casting, that is, the type surrounded
+by <code>( )</code>.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>the type after the explicit casting, or the type surrounded
+by <code>( )</code>.
+</td>
+</tr>
+
+<tr><td><code>$type</code></td>
+<td>A <code>java.lang.Class</code> object representing
+the same type as <code>$r</code>.
+</td>
+</tr>
+
+<tr><td><code>$proceed</code>    </td>
+<td rowspan=3>The name of a virtual method executing the original
+type casting.
+<br>It takes one parameter of the type <code>java.lang.Object</code>
+and returns it after
+<br>the explicit type casting specified by the original expression.
+
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+<tr><td> </td></tr>
+
+</table>
+</ul>
+
+<p>The other identifiers such as <code>$w</code>,
+<code>$args</code> and <code>$$</code>
+are also available.
+
+<h4>javassist.expr.Handler</h4>
+
+<p>A <code>Handler</code> object represents a <code>catch</code>
+clause of <code>try-catch</code> statement.
+The method <code>edit()</code> in <code>ExprEditor</code>
+receives this object if a <code>catch</code> is found.
+The method <code>insertBefore()</code> in
+<code>Handler</code> compiles the received
+source text and inserts it at the beginning of the <code>catch</code> clause.
+
+<p>
+In the source text, the identifiers starting with <code>$</code>
+have meaning:
+
+<ul><table border=0>
+
+<tr>
+<td><code>$1</code></td>
+<td>
+The exception object caught by the <code>catch</code> clause.
+</td>
+</tr>
+
+<tr>
+<td><code>$r</code></td>
+<td>the type of the exception caught by the <code>catch</code> clause.
+It is used in a cast expression.
+</td>
+</tr>
+
+<tr>
+<td><code>$w</code></td>
+<td>The wrapper type. It is used in a cast expression.
+</td>
+</tr>
+
+<tr><td><code>$type</code>    </td>
+<td rowspan=2>
+A <code>java.lang.Class</code> object representing
+<br>the type of the exception caught by the <code>catch</code> clause.
+</td>
+</tr>
+
+<tr><td> </td></tr>
+
+</table>
+</ul>
+
+<p>If a new exception object is assigned to <code>$1</code>,
+it is passed to the original <code>catch</code> clause as the caught
+exception.
+
+<p><br>
+
+<a name="add">
+<h3>4.3 Adding a new method or field</h3>
+
+<h4>Adding a method</h4>
+
+<p>Javassist allows the users to create a new method and constructor
+from scratch. <code>CtNewMethod</code>
+and <code>CtNewConstructor</code> provide several factory methods,
+which are static methods for creating <code>CtMethod</code> or
+<code>CtConstructor</code> objects.
+Especially, <code>make()</code> creates
+a <code>CtMethod</code> or <code>CtConstructor</code> object
+from the given source text.
+
+<p>For example, this program:
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtMethod m = CtNewMethod.make(
+ "public int xmove(int dx) { x += dx; }",
+ point);
+point.addMethod(m);
+</pre></ul>
+
+<p>adds a public method <code>xmove()</code> to class <code>Point</code>.
+In this example, <code>x</code> is a <code>int</code> field in
+the class <code>Point</code>.
+
+<p>The source text passed to <code>make()</code> can include the
+identifiers starting with <code>$</code> except <code>$_</code>
+as in <code>setBody()</code>.
+It can also include
+<code>$proceed</code> if the target object and the target method name
+are also given to <code>make()</code>. For example,
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtMethod m = CtNewMethod.make(
+ "public int ymove(int dy) { $proceed(0, dy); }",
+ point, "this", "move");
+</pre></ul>
+
+<p>this program creates a method <code>ymove()</code> defined below:
+
+<ul><pre>
+public int ymove(int dy) { this.move(0, dy); }
+</pre></ul>
+
+<p>Note that <code>$proceed</code> has been replaced with
+<code>this.move</code>.
+
+<p>Javassist provides another way to add a new method.
+You can first create an abstract method and later give it a method body:
+
+<ul><pre>
+CtClass cc = ... ;
+CtMethod m = new CtMethod(CtClass.intType, "move",
+ new CtClass[] { CtClass.intType }, cc);
+cc.addMethod(m);
+m.setBody("{ x += $1; }");
+cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
+</pre></ul>
+
+<p>Since Javassist makes a class abstract if an abstract method is
+added to the class, you have to explicitly change the class back to a
+non-abstract one after calling <code>setBody()</code>.
+
+
+<h4>Mutual recursive methods</h4>
+
+<p>Javassist cannot compile a method if it calls another method that
+has not been added to a class. (Javassist can compile a method that
+calls itself recursively.) To add mutual recursive methods to a class,
+you need a trick shown below. Suppose that you want to add methods
+<code>m()</code> and <code>n()</code> to a class represented
+by <code>cc</code>:
+
+<ul><pre>
+CtClass cc = ... ;
+CtMethod m = CtNewMethod.make("public abstract int m(int i);", cc);
+CtMethod n = CtNewMethod.make("public abstract int n(int i);", cc);
+cc.addMethod(m);
+cc.addMethod(n);
+m.setBody("{ return ($1 <= 0) ? 1 : (n($1 - 1) * $1); }");
+n.setBody("{ return m($1); }");
+cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);
+</pre></ul>
+
+<p>You must first make two abstract methods and add them to the class.
+Then you can give the method bodies to these methods even if the method
+bodies include method calls to each other. Finally you must change the
+class to a not-abstract class since <code>addMethod()</code> automatically
+changes a class into an abstract one if an abstract method is added.
+
+<h4>Adding a field</h4>
+
+<p>Javassist also allows the users to create a new field.
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = new CtField(CtClass.intType, "z", point);
+point.addField(f);
+</pre></ul>
+
+<p>This program adds a field named <code>z</code> to class
+<code>Point</code>.
+
+<p>If the initial value of the added field must be specified,
+the program shown above must be modified into:
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = new CtField(CtClass.intType, "z", point);
+point.addField(f, "0"); <em>// initial value is 0.</em>
+</pre></ul>
+
+<p>Now, the method <code>addField()</code> receives the second parameter,
+which is the source text representing an expression computing the initial
+value. This source text can be any Java expression if the result type
+of the expression matches the type of the field. Note that an expression
+does not end with a semi colon (<code>;</code>).
+
+<p>Furthermore, the above code can be rewritten into the following
+simple code:
+
+<ul><pre>
+CtClass point = ClassPool.getDefault().get("Point");
+CtField f = CtField.make("public int z = 0;", point);
+point.addField(f);
+</pre></ul>
+
+<h4>Removing a member</h4>
+
+<p>To remove a field or a method, call <code>removeField()</code>
+or <code>removeMethod()</code> in <code>CtClass</code>. A
+<code>CtConstructor</code> can be removed by <code>removeConstructor()</code>
+in <code>CtClass</code>.
+
+<p><br>
+
+<a name="annotation">
+<h3>4.4 Annotations</h3>
+
+<p><code>CtClass</code>, <code>CtMethod</code>, <code>CtField</code>
+and <code>CtConstructor</code> provides a convenient method
+<code>getAnnotations()</code> for reading annotations.
+It returns an annotation-type object.
+
+<p>For example, suppose the following annotation:
+
+<ul><pre>
+public @interface Author {
+ String name();
+ int year();
+}
+</pre></ul>
+
+<p>This annotation is used as the following:
+
+<ul><pre>
+@Author(name="Chiba", year=2005)
+public class Point {
+ int x, y;
+}
+</pre></ul>
+
+<p>Then, the value of the annotation can be obtained by
+<code>getAnnotations()</code>.
+It returns an array containing
+annotation-type objects.
+
+<ul><pre>
+CtClass cc = ClassPool.getDefault().get("Point");
+Object[] all = cc.getAnnotations();
+Author a = (Author)all[0];
+String name = a.name();
+int year = a.year();
+System.out.println("name: " + name + ", year: " + year);
+</pre></ul>
+
+<p>This code snippet should print:
+
+<ul><pre>
+name: Chiba, year: 2005
+</pre></ul>
+
+<p>
+Since the annoation of <code>Point</code> is only <code>@Author</code>,
+the length of the array <code>all</code> is one
+and <code>all[0]</code> is an <code>Author</code> object.
+The member values of the annotation can be obtained
+by calling <code>name()</code> and <code>year()</code>
+on the <code>Author</code> object.
+
+<p>To use <code>getAnnotations()</code>, annotation types
+such as <code>Author</code> must be included in the current
+class path. <em>They must be also accessible from a
+<code>ClassPool</code> object.</em> If the class file of an annotation
+type is not found, Javassist cannot obtain the default values
+of the members of that annotation type.
+
+<p><br>
+
+<a name="runtime">
+<h3>4.5 Runtime support classes</h3>
+
+<p>In most cases, a class modified by Javassist does not require
+Javassist to run. However, some kinds of bytecode generated by the
+Javassist compiler need runtime support classes, which are in the
+<code>javassist.runtime</code> package (for details, please read
+the API reference of that package). Note that the
+<code>javassist.runtime</code> package is the only package that
+classes modified by Javassist may need for running. The other
+Javassist classes are never used at runtime of the modified classes.
+
+<p><br>
+
+<a name="import">
+<h3>4.6 Import</h3>
+
+<p>All the class names in source code must be fully qualified
+(they must include package names).
+However, the <code>java.lang</code> package is an
+exception; for example, the Javassist compiler can
+resolve <code>Object</code> as
+well as <code>java.lang.Object</code>.
+
+<p>To tell the compiler to search other packages when resolving a
+class name, call <code>importPackage()</code> in <code>ClassPool</code>.
+For example,
+
+<ul><pre>
+ClassPool pool = ClassPool.getDefault();
+pool.importPackage("java.awt");
+CtClass cc = pool.makeClass("Test");
+CtField f = CtField.make("public Point p;", cc);
+cc.addField(f);
+</pre></ul>
+
+<p>The seconde line instructs the compiler
+to import the <code>java.awt</code> package.
+Thus, the third line will not throw an exception.
+The compiler can recognize <code>Point</code>
+as <code>java.awt.Point</code>.
+
+<p>Note that <code>importPackage()</code> <em>does not</em> affect
+the <code>get()</code> method in <code>ClassPool</code>.
+Only the compiler considers the imported packages.
+The parameter to <code>get()</code>
+must be always a fully qualified name.
+
+<p><br>
+
+<a name="limit">
+<h3>4.7 Limitations</h3>
+
+<p>In the current implementation, the Java compiler included in Javassist
+has several limitations with respect to the language that the compiler can
+accept. Those limitations are:
+
+<p><li>The new syntax introduced by J2SE 5.0 (including enums and generics)
+has not been supported. Annotations are supported only by the low level
+API of Javassist.
+See the <code>javassist.bytecode.annotation</code> package.
+
+<p><li>Array initializers, a comma-separated list of expressions
+enclosed by braces <code>{</code> and <code>}</code>, are not
+available unless the array dimension is one.
+
+<p><li>Inner classes or anonymous classes are not supported.
+
+<p><li>Labeled <code>continue</code> and <code>break</code> statements
+are not supported.
+
+<p><li>The compiler does not correctly implement the Java method dispatch
+algorithm. The compiler may confuse if methods defined in a class
+have the same name but take different parameter lists.
+
+<p>For example,
+
+<ul><pre>
+class A {}
+class B extends A {}
+class C extends B {}
+
+class X {
+ void foo(A a) { .. }
+ void foo(B b) { .. }
+}
+</pre></ul>
+
+<p>If the compiled expression is <code>x.foo(new C())</code>, where
+<code>x</code> is an instance of X, the compiler may produce a call
+to <code>foo(A)</code> although the compiler can correctly compile
+<code>foo((B)new C())</code>.
+
+<p><li>The users are recommended to use <code>#</code> as the separator
+between a class name and a static method or field name.
+For example, in regular Java,
+
+<ul><pre>javassist.CtClass.intType.getName()</pre></ul>
+
+<p>calls a method <code>getName()</code> on
+the object indicated by the static field <code>intType</code>
+in <code>javassist.CtClass</code>. In Javassist, the users can
+write the expression shown above but they are recommended to
+write:
+
+<ul><pre>javassist.CtClass#intType.getName()</pre></ul>
+
+<p>so that the compiler can quickly parse the expression.
+</ul>
+
+<p><br>
+
+<a href="tutorial.html">Previous page</a>
+ <a href="tutorial3.html">Next page</a>
+
+<hr>
+Java(TM) is a trademark of Sun Microsystems, Inc.<br>
+Copyright (C) 2000-2010 by Shigeru Chiba, All rights reserved.
+</body>
+</html>
diff --git a/tutorial/tutorial3.html b/tutorial/tutorial3.html
new file mode 100644
index 0000000..dd4fb79
--- /dev/null
+++ b/tutorial/tutorial3.html
@@ -0,0 +1,366 @@
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
+ <title>Javassist Tutorial</title>
+ <link rel="stylesheet" type="text/css" href="brown.css">
+</head>
+
+<body>
+
+<div align="right">Getting Started with Javassist</div>
+
+<div align="left"><a href="tutorial2.html">Previous page</a></div>
+
+<p>
+<a href="#intro">5. Bytecode level API</a>
+<ul>
+<li><a href="#classfile">Obtaining a <code>ClassFile</code> object</a>
+<br><li><a href="#member">Adding and removing a member</a>
+<br><li><a href="#traverse">Traversing a method body</a>
+<br><li><a href="#bytecode">Producing a bytecode sequence</a>
+<br><li><a href="#annotation">Annotations (Meta tags)</a>
+
+</ul>
+
+<p><a href="#generics">6. Generics</a>
+
+<p><a href="#varargs">7. Varargs</a>
+
+<p><a href="#j2me">8. J2ME</a>
+
+<p><br>
+
+<a name="intro">
+<h2>5. Bytecode level API</h2>
+
+<p>
+Javassist also provides lower-level API for directly editing
+a class file. To use this level of API, you need detailed
+knowledge of the Java bytecode and the class file format
+while this level of API allows you any kind of modification
+of class files.
+
+<p>
+If you want to just produce a simple class file,
+<code>javassist.bytecode.ClassFileWriter</code> might provide
+the best API for you. It is much faster than
+<code>javassist.bytecode.ClassFile</code> although its API
+is minimum.
+
+<a name="classfile">
+<h3>5.1 Obtaining a <code>ClassFile</code> object</h3>
+
+<p>A <code>javassist.bytecode.ClassFile</code> object represents
+a class file. To obtian this object, <code>getClassFile()</code>
+in <code>CtClass</code> should be called.
+
+<p>Otherwise, you can construct a
+<code>javassist.bytecode.ClassFile</code> directly from a class file.
+For example,
+
+<ul><pre>
+BufferedInputStream fin
+ = new BufferedInputStream(new FileInputStream("Point.class"));
+ClassFile cf = new ClassFile(new DataInputStream(fin));
+</pre></ul>
+
+<p>
+This code snippet creats a <code>ClassFile</code> object from
+<code>Point.class</code>.
+
+<p>
+A <code>ClassFile</code> object can be written back to a
+class file. <code>write()</code> in <code>ClassFile</code>
+writes the contents of the class file to a given
+<code>DataOutputStream</code>.
+
+<p><br>
+
+<a name="member">
+<h3>5.2 Adding and removing a member</h3>
+
+<p>
+<code>ClassFile</code> provides <code>addField()</code> and
+<code>addMethod()</code> for adding a field or a method (note that
+a constructor is regarded as a method at the bytecode level).
+It also provides <code>addAttribute()</code> for adding an attribute
+to the class file.
+
+<p>
+Note that <code>FieldInfo</code>, <code>MethodInfo</code>, and
+<code>AttributeInfo</code> objects include a link to a
+<code>ConstPool</code> (constant pool table) object. The <code>ConstPool</code>
+object must be common to the <code>ClassFile</code> object and
+a <code>FieldInfo</code> (or <code>MethodInfo</code> etc.) object
+that is added to that <code>ClassFile</code> object.
+In other words, a <code>FieldInfo</code> (or <code>MethodInfo</code> etc.) object
+must not be shared among different <code>ClassFile</code> objects.
+
+<p>
+To remove a field or a method from a <code>ClassFile</code> object,
+you must first obtain a <code>java.util.List</code>
+object containing all the fields of the class. <code>getFields()</code>
+and <code>getMethods()</code> return the lists. A field or a method can
+be removed by calling <code>remove()</code> on the <code>List</code> object.
+An attribute can be removed in a similar way.
+Call <code>getAttributes()</code> in <code>FieldInfo</code> or
+<code>MethodInfo</code> to obtain the list of attributes,
+and remove one from the list.
+
+
+<p><br>
+
+<a name="traverse">
+<h3>5.3 Traversing a method body</h3>
+
+<p>
+To examine every bytecode instruction in a method body,
+<code>CodeIterator</code> is useful. To otbain this object,
+do as follows:
+
+<ul><pre>
+ClassFile cf = ... ;
+MethodInfo minfo = cf.getMethod("move"); // we assume move is not overloaded.
+CodeAttribute ca = minfo.getCodeAttribute();
+CodeIterator i = ca.iterator();
+</pre></ul>
+
+<p>
+A <code>CodeIterator</code> object allows you to visit every
+bytecode instruction one by one from the beginning to the end.
+The following methods are part of the methods declared in
+<code>CodeIterator</code>:
+
+<ul>
+<li><code>void begin()</code><br>
+Move to the first instruction.<br>
+<li><code>void move(int index)</code><br>
+Move to the instruction specified by the given index.<br>
+<li><code>boolean hasNext()</code><br>
+Returns true if there is more instructions.<br>
+<li><code>int next()</code><br>
+Returns the index of the next instruction.<br>
+<em>Note that it does not return the opcode of the next
+instruction.</em><br>
+<li><code>int byteAt(int index)</code><br>
+Returns the unsigned 8bit value at the index.<br>
+<li><code>int u16bitAt(int index)</code><br>
+Returns the unsigned 16bit value at the index.<br>
+<li><code>int write(byte[] code, int index)</code><br>
+Writes a byte array at the index.<br>
+<li><code>void insert(int index, byte[] code)</code><br>
+Inserts a byte array at the index.
+Branch offsets etc. are automatically adjusted.<br>
+</ul>
+
+<p>The following code snippet displays all the instructions included
+in a method body:
+
+<ul><pre>
+CodeIterator ci = ... ;
+while (ci.hasNext()) {
+ int index = ci.next();
+ int op = ci.byteAt(index);
+ System.out.println(Mnemonic.OPCODE[op]);
+}
+</pre></ul>
+
+<p><br>
+
+<a name="bytecode">
+<h3>5.4 Producing a bytecode sequence</h3>
+
+<p>
+A <code>Bytecode</code> object represents a sequence of bytecode
+instructions. It is a growable array of bytecode.
+Here is a sample code snippet:
+
+<ul><pre>
+ConstPool cp = ...; // constant pool table
+Bytecode b = new Bytecode(cp, 1, 0);
+b.addIconst(3);
+b.addReturn(CtClass.intType);
+CodeAttribute ca = b.toCodeAttribute();
+</pre></ul>
+
+<p>
+This produces the code attribute representing the following sequence:
+
+<ul><pre>
+iconst_3
+ireturn
+</pre></ul>
+
+<p>
+You can also obtain a byte array containing this sequence by
+calling <code>get()</code> in <code>Bytecode</code>. The
+obtained array can be inserted in another code attribute.
+
+<p>
+While <code>Bytecode</code> provides a number of methods for adding a
+specific instruction to the sequence, it provides
+<code>addOpcode()</code> for adding an 8bit opcode and
+<code>addIndex()</code> for adding an index.
+The 8bit value of each opcode is defined in the <code>Opcode</code>
+interface.
+
+<p>
+<code>addOpcode()</code> and other methods for adding a specific
+instruction are automatically maintain the maximum stack depth
+unless the control flow does not include a branch.
+This value can be obtained by calling <code>getMaxStack()</code>
+on the <code>Bytecode</code> object.
+It is also reflected on the <code>CodeAttribute</code> object
+constructed from the <code>Bytecode</code> object.
+To recompute the maximum stack depth of a method body,
+call <code>computeMaxStack()</code> in <code>CodeAttribute</code>.
+
+<p><br>
+
+<a name="annotation">
+<h3>5.5 Annotations (Meta tags)</h3>
+
+<p>Annotations are stored in a class file
+as runtime invisible (or visible) annotations attribute.
+These attributes can be obtained from <code>ClassFile</code>,
+<code>MethodInfo</code>, or <code>FieldInfo</code> objects.
+Call <code>getAttribute(AnnotationsAttribute.invisibleTag)</code>
+on those objects. For more details, see the javadoc manual
+of <code>javassist.bytecode.AnnotationsAttribute</code> class
+and the <code>javassist.bytecode.annotation</code> package.
+
+<p>Javassist also let you access annotations by the higher-level
+API.
+If you want to access annotations through <code>CtClass</code>,
+call <code>getAnnotations()</code> in <code>CtClass</code> or
+<code>CtBehavior</code>.
+
+<p><br>
+
+<h2><a name="generics">6. Generics</a></h2>
+
+<p>The lower-level API of Javassist fully supports generics
+introduced by Java 5. On the other hand, the higher-level
+API such as <code>CtClass</code> does not directly support
+generics. However, this is not a serious problem for bytecode
+transformation.
+
+<p>The generics of Java is implemented by the erasure technique.
+After compilation, all type parameters are dropped off. For
+example, suppose that your source code declares a parameterized
+type <code>Vector<String></code>:
+
+<ul><pre>
+Vector<String> v = new Vector<String>();
+ :
+String s = v.get(0);
+</pre></ul>
+
+<p>The compiled bytecode is equivalent to the following code:
+
+<ul><pre>
+Vector v = new Vector();
+ :
+String s = (String)v.get(0);
+</pre></ul>
+
+<p>So when you write a bytecode transformer, you can just drop
+off all type parameters. For example, if you have a class:
+
+<ul><pre>
+public class Wrapper<T> {
+ T value;
+ public Wrapper(T t) { value = t; }
+}
+</pre></ul>
+
+<p>and want to add an interface <code>Getter<T></code> to the
+class <code>Wrapper<T></code>:
+
+<ul><pre>
+public interface Getter<T> {
+ T get();
+}
+</pre></ul>
+
+<p>Then the interface you really have to add is <code>Getter</code>
+(the type parameters <code><T></code> drops off)
+and the method you also have to add to the <code>Wrapper</code>
+class is this simple one:
+
+<ul><pre>
+public Object get() { return value; }
+</pre></ul>
+
+<p>Note that no type parameters are necessary.
+
+<p><br>
+
+<h2><a name="varargs">7. Varargs</a></h2>
+
+<p>Currently, Javassist does not directly support varargs. So to make a method with varargs,
+you must explicitly set a method modifier. But this is easy.
+Suppose that now you want to make the following method:
+
+<ul><pre>
+public int length(int... args) { return args.length; }
+</pre></ul>
+
+<p>The following code using Javassist will make the method shown above:
+
+<ul><pre>
+CtClass cc = /* target class */;
+CtMethod m = CtMethod.make("public int length(int[] args) { return args.length; }", cc);
+m.setModifiers(m.getModifiers() | Modifier.VARARGS);
+cc.addMethod(m);
+<pre></ul>
+
+<p>The parameter type <code>int...</code> is changed into <code>int[]</code>
+and <code>Modifier.VARARGS</code> is added to the method modifiers.
+
+<p>To call this method, you must write:
+
+<ul><pre>
+length(new int[] { 1, 2, 3 });
+</pre></ul>
+
+<p>instead of this method call using the varargs mechanism:
+
+<ul><pre>
+length(1, 2, 3);
+</pre></ul>
+
+<p><br>
+
+<h2><a name="j2me">8. J2ME</a></h2>
+
+<p>If you modify a class file for the J2ME execution environment,
+you must perform <it>preverification</it>. Preverifying is basically
+producing stack maps, which is similar to stack map tables introduced
+into J2SE at JDK 1.6. Javassist maintains the stack maps for J2ME only if
+<code>javassist.bytecode.MethodInfo.doPreverify</code> is true.
+
+<p>You can also manually
+produce a stack map for a modified method.
+For a given method represented by a <code>CtMethod</code> object <code>m</code>,
+you can produce a stack map by calling the following methods:
+
+<ul><pre>
+m.getMethodInfo().rebuildStackMapForME(cpool);
+</pre></ul>
+
+<p>Here, <code>cpool</code> is a <code>ClassPool</code> object, which is
+available by calling <code>getClassPool()</code> on a <code>CtClass</code>
+object. A <code>ClassPool</code> object is responsible for finding
+class files from given class pathes. To obtain all the <code>CtMethod</code>
+objects, call the <code>getDeclaredMethods</code> method on a <code>CtClass</code> object.
+
+<p><br>
+
+<a href="tutorial2.html">Previous page</a>
+
+<hr>
+Java(TM) is a trademark of Sun Microsystems, Inc.<br>
+Copyright (C) 2000-2010 by Shigeru Chiba, All rights reserved.
+</body>
+</html>
