/*
* Copyright (c) 2003, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* build @BUILD_TAG_PLACEHOLDER@
*
* @COPYRIGHT_MINI_LEGAL_NOTICE_PLACEHOLDER@
*/
import java.io.*;
import java.lang.reflect.*;
/*
ClassLoader that knows how to fabricate exactly one class. The name
of the class is defined by the parameter singleClassName. When
asked to load a class, this loader first delegates to its parent as
usual, then, if that doesn't find the class and if the name is the
same as singleClassName, the class is fabricated. It is a public
class with no fields or methods and a single public no-arg
constructor that simply calls its parent's no-arg constructor. This
means that the parent must have a public or protected no-arg
constructor.
*/
public class SingleClassLoader extends ClassLoader {
SingleClassLoader(String singleClassName, Class superclass,
ClassLoader parent) {
super(parent);
Constructor superConstr;
try {
superConstr = superclass.getDeclaredConstructor(new Class[0]);
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException("Superclass must have no-arg " +
"constructor");
}
int superConstrMods = superConstr.getModifiers();
if ((superConstrMods & (Modifier.PUBLIC|Modifier.PROTECTED)) == 0) {
final String msg =
"Superclass no-arg constructor must be public or protected";
throw new IllegalArgumentException(msg);
}
this.singleClassName = singleClassName;
final Class c;
try {
c = makeClass(superclass);
} catch (IOException e) {
throw new RuntimeException(e.toString());
}
this.singleClass = c;
}
private Class makeClass(Class superclass) throws IOException {
final String superName = superclass.getName();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
dout = new DataOutputStream(bout);
String thisNameInternal = singleClassName.replace('.', '/');
String superNameInternal = superName.replace('.', '/');
dout.writeInt(0xcafebabe); // magic
dout.writeInt(0x0003002d); // major 45 minor 3
dout.writeShort(10); // cpool count (incl virtual 0 element)
cpoolIndex = 1;
int thisNameConst = writeUTFConst(thisNameInternal);
int thisClassConst = writeClassConst(thisNameConst);
int superNameConst = writeUTFConst(superNameInternal);
int superClassConst = writeClassConst(superNameConst);
int initNameConst = writeUTFConst("<init>");
int voidNoArgSigConst = writeUTFConst("()V");
int codeNameConst = writeUTFConst("Code");
int superConstructorNameAndTypeConst =
writeNameAndTypeConst(initNameConst, voidNoArgSigConst);
int superConstructorMethodRefConst =
writeMethodRefConst(superClassConst,
superConstructorNameAndTypeConst);
dout.writeShort(Modifier.PUBLIC | 0x20 /*SUPER*/);
dout.writeShort(thisClassConst);
dout.writeShort(superClassConst);
dout.writeInt(0); // n interfaces, n fields
dout.writeShort(1); // n methods
// <init> method
dout.writeShort(Modifier.PUBLIC);
dout.writeShort(initNameConst);
dout.writeShort(voidNoArgSigConst);
dout.writeShort(1); // attr count
// Code attribute
dout.writeShort(codeNameConst);
dout.writeInt(17); // len
dout.writeShort(1); // max stack
dout.writeShort(1); // max locals
dout.writeInt(5); // code len
dout.writeByte(42); // aload_0
dout.writeByte(183); // invokespecial
dout.writeShort(superConstructorMethodRefConst);
dout.writeByte(177); // return
dout.writeShort(0); // 0 catches
dout.writeShort(0); // 0 method attrs
dout.writeShort(0); // 0 class attrs
dout.close();
byte[] classBytes = bout.toByteArray();
dout = null;
return
defineClass(singleClassName, classBytes, 0, classBytes.length);
}
protected Class findClass(String name) throws ClassNotFoundException {
if (name.equals(singleClassName))
return singleClass;
else
throw new ClassNotFoundException(name);
}
private int writeUTFConst(String s) throws IOException {
dout.writeByte(1);
dout.writeUTF(s);
return cpoolIndex++;
}
private int writeClassConst(int nameIndex) throws IOException {
dout.writeByte(7);
dout.writeShort((short) nameIndex);
return cpoolIndex++;
}
private int writeNameAndTypeConst(int nameIndex, int typeIndex)
throws IOException {
dout.writeByte(12);
dout.writeShort((short) nameIndex);
dout.writeShort((short) typeIndex);
return cpoolIndex++;
}
private int writeMethodRefConst(int classIndex, int nameAndTypeIndex)
throws IOException {
dout.writeByte(10);
dout.writeShort((short) classIndex);
dout.writeShort((short) nameAndTypeIndex);
return cpoolIndex++;
}
private final String singleClassName;
private final Class singleClass;
private DataOutputStream dout;
private int cpoolIndex;
}