/**
* Override this method to create you own classes on the fly. The name contains the special token
* $$BCEL$$. Everything before that token is consddered to be a package name. You can encode you
* own arguments into the subsequent string. You must regard however not to use any "illegal"
* characters, i.e., characters that may not appear in a Java class name too<br>
* The default implementation interprets the string as a encoded compressed Java class, unpacks
* and decodes it with the Utility.decode() method, and parses the resulting byte array and
* returns the resulting JavaClass object.
*
* @param class_name compressed byte code with "$$BCEL$$" in it
*/
protected JavaClass createClass(String class_name) {
int index = class_name.indexOf("$$BCEL$$");
String real_name = class_name.substring(index + 8);
JavaClass clazz = null;
try {
byte[] bytes = Utility.decode(real_name, true);
ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), "foo");
clazz = parser.parse();
} catch (Throwable e) {
e.printStackTrace();
return null;
}
// Adapt the class name to the passed value
ConstantPool cp = clazz.getConstantPool();
ConstantClass cl =
(ConstantClass) cp.getConstant(clazz.getClassNameIndex(), Constants.CONSTANT_Class);
ConstantUtf8 name = (ConstantUtf8) cp.getConstant(cl.getNameIndex(), Constants.CONSTANT_Utf8);
name.setBytes(class_name.replace('.', '/'));
return clazz;
}
/** Machine-generated. */
public void pass4Button_ActionPerformed(java.awt.event.ActionEvent actionEvent) {
pass2Button_ActionPerformed(actionEvent);
Color color = Color.green;
Verifier v = VerifierFactory.getVerifier(class_name);
VerificationResult vr = v.doPass2();
if (vr.getStatus() == VerificationResult.VERIFIED_OK) {
JavaClass jc = Repository.lookupClass(class_name);
int nr = jc.getMethods().length;
for (int i = 0; i < nr; i++) {
vr = v.doPass3b(i);
if (vr.getStatus() != VerificationResult.VERIFIED_OK) {
color = Color.red;
break;
}
}
} else {
color = Color.yellow;
}
getPass3Panel().setBackground(color);
getPass3Panel().repaint();
}
public void run() {
JavaClass clazz = snapshot.findClass(query);
String instancesOf;
if (newObjects) instancesOf = "New instances of ";
else instancesOf = "Instances of ";
if (includeSubclasses) {
startHtml(instancesOf + query + " (including subclasses)");
} else {
startHtml(instancesOf + query);
}
if (clazz == null) {
error("Class not found");
} else {
out.print("<strong>");
printClass(clazz);
out.print("</strong><br><br>");
Enumeration objects = clazz.getInstances(includeSubclasses);
long totalSize = 0;
long instances = 0;
while (objects.hasMoreElements()) {
JavaHeapObject obj = (JavaHeapObject) objects.nextElement();
if (newObjects && !obj.isNew()) continue;
printThing(obj);
out.println("<br>");
totalSize += obj.getSize();
instances++;
}
out.println(
"<h2>Total of " + instances + " instances occupying " + totalSize + " bytes.</h2>");
}
endHtml();
}
public static boolean isCompiledKotlinPackageClass(@NotNull JavaClass javaClass) {
if (javaClass.getOriginKind() == JavaClass.OriginKind.COMPILED) {
return javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE) != null
|| javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE_FRAGMENT) != null;
}
return false;
}
/**
* Write contents of the given JavaClass into HTML files.
*
* @param java_class The class to write
* @param dir The directory to put the files in
*/
public Class2HTML(JavaClass java_class, String dir) throws IOException {
Method[] methods = java_class.getMethods();
this.java_class = java_class;
this.dir = dir;
class_name = java_class.getClassName(); // Remember full name
constant_pool = java_class.getConstantPool();
// Get package name by tacking off everything after the last `.'
int index = class_name.lastIndexOf('.');
if (index > -1) class_package = class_name.substring(0, index);
else class_package = ""; // default package
ConstantHTML constant_html =
new ConstantHTML(dir, class_name, class_package, methods, constant_pool);
/* Attributes can't be written in one step, so we just open a file
* which will be written consequently.
*/
AttributeHTML attribute_html = new AttributeHTML(dir, class_name, constant_pool, constant_html);
// MethodHTML method_html = new MethodHTML(dir, class_name, methods, java_class.getFields(),
// constant_html, attribute_html);
// Write main file (with frames, yuk)
writeMainHTML(attribute_html);
new CodeHTML(dir, class_name, methods, constant_pool, constant_html);
attribute_html.close();
}
@Test
public void shouldReturnUnparsableClassIfClassCannotBeFound() {
JavaClass javaClass = builder.createClass("foo.bar.com");
assertThat(javaClass).isInstanceOf(UnparsableClass.class);
assertThat(javaClass.getName()).isEqualTo("foo.bar.com");
assertThat(javaClass.getImports()).isEmpty();
}
public Set<String> getIndexedClasses() {
Set<String> classes = newHashSet();
Set<JavaClass> vertexSet = graph.vertexSet();
for (JavaClass each : vertexSet) {
classes.add(each.getName());
}
return classes;
}
private JavaClass findClass(String classname) {
for (JavaClass jClass : graph.vertexSet()) {
if (jClass.getName().equals(classname)) {
return jClass;
}
}
return null;
}
private void updateParentReferences(JavaClass parentClass) {
for (String child : parentClass.getImports()) {
JavaClass childClass = findJavaClass(child);
if ((childClass != null) && !childClass.equals(parentClass)) {
if (graph.containsVertex(childClass)) {
graph.addEdge(parentClass, childClass);
}
}
}
}
public JavaClass findJavaClass(String classname) {
JavaClass clazz = findClass(classname);
if (clazz == null) {
clazz = builder.getClass(classname);
if (clazz.locatedInClassFile()) {
addToIndex(clazz);
}
}
return clazz;
}
private String parseClassName() throws IOException {
int entryIndex = in.readUnsignedShort();
String clazzName = getClassConstantName(entryIndex);
jClass.setName(clazzName);
jClass.setPackageName(getPackageName(clazzName));
debug("Parser: class name = " + clazzName);
debug("Parser: package name = " + getPackageName(clazzName));
return clazzName;
}
/**
* getParentType - return the Class which corresponds to our parent JavaClass we're going to do
* this a lot, so cache it.
*/
protected Class getParentType() {
if (parentType == null) {
Field targetField = (Field) getTarget();
JavaClass parentJavaClass = targetField.getJavaClass();
JavaClassJDKAdaptor pa =
(JavaClassJDKAdaptor)
EcoreUtil.getAdapter(parentJavaClass.eAdapters(), ReadAdaptor.TYPE_KEY);
if (pa != null) parentType = pa.getSourceType();
}
return parentType;
}
private void importInheritances(DbJVClass dbClaz, JavaClass claz) throws DbException {
String qualifiedName = claz.getSuperclassName();
if (!"java.lang.Object".equals(qualifiedName)) {
importInheritance(dbClaz, qualifiedName, false);
}
String[] qualifiedNames = claz.getInterfaceNames();
for (String qn : qualifiedNames) {
importInheritance(dbClaz, qn, true);
} // end for
}
public void visitJavaClass(JavaClass clazz) {
super.visitJavaClass(clazz);
JopClassInfo cli = (JopClassInfo) this.cli;
cpool = clazz.getConstantPool();
if (clazz.isInterface()) {
cli.interfaceID = ++cli.interfaceCnt;
cli.interfaceList.add(cli.interfaceID - 1, clazz.getClassName());
}
}
@Override
protected void doWithResourceDocument(ResourceDocument document, Class<?> classOfResource) {
// Check if the class is present in the builder.
if (javaDocBuilder.getClassByName(classOfResource.getName()) == null)
throw new IllegalArgumentException(
"Class " + classOfResource + " was not found within the specified source files.");
JavaClass javaClass = javaDocBuilder.getClassByName(classOfResource.getName());
document.setDescription(javaClass.getComment());
document.setTitle(titleOrNull(javaClass));
}
private DbJVClass importClass(JavaClass claz, Controller controller) throws DbException {
String packName = claz.getPackageName();
String qualifiedName = claz.getClassName();
int idx = qualifiedName.lastIndexOf('.');
String classname = qualifiedName.substring(idx + 1);
DbJVClass dbClaz = null;
try {
if (m_classModel != null) {
DbJVPackage pack = findPackageByName(packName);
// create class or interface
int value = claz.isInterface() ? JVClassCategory.INTERFACE : JVClassCategory.CLASS;
JVClassCategory catg = JVClassCategory.getInstance(value);
dbClaz =
(pack == null) ? new DbJVClass(this.m_classModel, catg) : new DbJVClass(pack, catg);
dbClaz.setName(classname);
// set class modifiers
dbClaz.setAbstract(claz.isAbstract());
dbClaz.setFinal(claz.isFinal());
dbClaz.setStatic(claz.isStatic());
dbClaz.setStrictfp(claz.isStrictfp());
dbClaz.setVisibility(toVisibility(claz));
// create inheritances
importInheritances(dbClaz, claz);
// create fields
if (m_params.createFields) {
Field[] fields = claz.getFields();
for (Field field : fields) {
importField(dbClaz, field);
}
}
// create methods
if (m_params.createMethods) {
Method[] methods = claz.getMethods();
for (Method method : methods) {
importMethod(dbClaz, method);
}
}
// keep user informed of progression
String pattern = LocaleMgr.misc.getString("0SuccessfullyCreated");
String msg = MessageFormat.format(pattern, qualifiedName);
controller.println(msg);
} // end if
} catch (DbException ex) {
controller.println(ex.toString());
} // end try
return dbClaz;
} // end importClass()
public void visitJavaClass(JavaClass clazz) {
clazz.accept(visitor);
Field[] fields = clazz.getFields();
for (int i = 0; i < fields.length; i++) fields[i].accept(this);
Method[] methods = clazz.getMethods();
for (int i = 0; i < methods.length; i++) methods[i].accept(this);
Attribute[] attributes = clazz.getAttributes();
for (int i = 0; i < attributes.length; i++) attributes[i].accept(this);
clazz.getConstantPool().accept(this);
}
@NotNull
public static Collection<JavaClass> getClassesInPackage(@NotNull JavaPackage javaPackage) {
Collection<JavaClass> classes = javaPackage.getClasses();
Set<FqName> addedQualifiedNames = new HashSet<FqName>(classes.size());
List<JavaClass> result = new ArrayList<JavaClass>(classes.size());
for (JavaClass javaClass : classes) {
FqName fqName = javaClass.getFqName();
if (fqName != null && addedQualifiedNames.add(fqName)) {
result.add(javaClass);
}
}
return result;
}
@JRubyMethod
public static IRubyObject to_java(
ThreadContext context, IRubyObject fromObject, IRubyObject type) {
if (type.isNil()) {
return to_java(context, fromObject);
}
Ruby runtime = context.runtime;
JavaClass targetType = getTargetType(context, runtime, type);
if (fromObject instanceof RubyArray) {
return targetType.javaArrayFromRubyArray(context, fromObject);
} else {
return Java.getInstance(runtime, fromObject.toJava(targetType.javaClass()));
}
}
/**
* Removes a file with a given name and its related files.
*
* @param pathname the name of the file to be removed
*/
public void removeJavaFile(String pathname) {
for (JavaFile jf : getJavaFiles()) {
if (pathname.compareTo(jf.getPath()) == 0) {
JavaClass.removeClassesRelatedTo(jf);
}
}
cleanJavaProjects();
}
/** Removes every information about this project stored in the cache. */
public static void removeAllCache() {
for (JavaProject jproj : cache.values()) {
jproj.getJavaPackages().clear();
}
cache.clear();
JavaClass.removeAllClassesInCache();
}
/**
* Translates the body of the package and writes it to the output stream.
*
* @param out The output stream.
* @return The output stream.
*/
public Printer translate(Printer out) {
// Include the header file
out.p("#include \"").p(getFilename()).pln(".h\"").pln();
// Print the array template specializations for the classes in this package
out.pln("namespace __rt {").incr();
for (JavaFile f : files) {
for (JavaClass cls : f.getClasses()) {
cls.translateArrayTemplate(out);
}
}
out.decr().pln("}").pln();
// Add the namespace
for (String part : pkg) {
out.indent().p("namespace ").p(part).pln(" {").incr();
}
// Print all the files in the package
for (JavaFile f : files) {
for (JavaClass cls : f.getClasses()) {
cls.translate(out).pln();
}
out.pln();
}
// Close the namespace
for (int i = 0; i < pkg.size(); i++) {
out.decr().indent().pln("}");
}
// If this package contains the main file, print the main method here
if (null != main) {
out.pln("int main(int argc, char *argv[]) {").incr();
out.indent().pln("__rt::Ptr<__rt::Array<String> > args = new __rt::Array<String>(argc-1);");
out.indent().pln("for (int i = 1; i < argc; i++) {").incr();
out.indent().pln("(*args)[i-1] = __rt::literal(argv[i]);");
out.decr().indent().pln("}");
out.indent();
if (!getNamespace().equals("")) out.p(getNamespace()).p("::");
out.p("__").p(main.getPublicClass().getName()).pln("::main$array1_String(args);");
out.decr().pln("}");
}
return out;
}
@Test
public void shouldLookForClassesInTargetDirectories() throws Exception {
newDir = new File("tempClassDir");
List<File> buildPaths = asList(newDir);
ClasspathProvider classpath =
new StandaloneClasspath(
buildPaths,
FakeEnvironments.systemClasspath() + pathSeparator + newDir.getAbsolutePath());
String classname = "org.fakeco.Foobar";
createClass(classname);
builder = new JavaClassBuilder(classpath);
JavaClass javaClass = builder.createClass(classname);
assertEquals(classname, javaClass.getName());
assertFalse(javaClass.isATest());
}
protected void checkClass(JavaClass c) {
enclosingScopes.push(c);
for (Decl d : c.declarations()) {
checkDeclaration(d);
}
enclosingScopes.pop();
}
/**
* Constructor is only used by following two factory methods: getTemplate for the dispatch of the
* creation with newClassInfo
*
* @param clazz
* @param ai
*/
private JopClassInfo(JavaClass clazz, OldAppInfo ai) {
super(clazz, ai);
methodsAddress = 0;
cpoolAddress = 0;
instSize = 0;
instGCinfo = 0;
cpoolUsed = new LinkedList<Integer>();
// the template class info is created with a null pointer
if (clazz != null) {
if (clazz.getClassName().equals(JOPizer.stringClass)) {
StringInfo.cli = this;
}
if (clazz.getClassName().equals(JOPizer.objectClass)) {
nrObjMethods = clazz.getMethods().length;
}
}
}
protected Class loadClass(String class_name, boolean resolve) throws ClassNotFoundException {
Class cl = null;
/* First try: lookup hash table.
*/
if ((cl = (Class) classes.get(class_name)) == null) {
/* Second try: Load system class using system class loader. You better
* don't mess around with them.
*/
for (int i = 0; i < ignored_packages.length; i++) {
if (class_name.startsWith(ignored_packages[i])) {
cl = deferTo.loadClass(class_name);
break;
}
}
if (cl == null) {
JavaClass clazz = null;
/* Third try: Special request?
*/
if (class_name.indexOf("$$BCEL$$") >= 0) clazz = createClass(class_name);
else { // Fourth try: Load classes via repository
if ((clazz = repository.loadClass(class_name)) != null) {
clazz = modifyClass(clazz);
} else throw new ClassNotFoundException(class_name);
}
if (clazz != null) {
byte[] bytes = clazz.getBytes();
cl = defineClass(class_name, bytes, 0, bytes.length);
} else // Fourth try: Use default class loader
cl = Class.forName(class_name);
}
if (resolve) resolveClass(cl);
}
classes.put(class_name, cl);
return cl;
}
/**
* Dumps the contents of the specified class to the specified directory. The file is named
* dump_dir/[class].bcel. It contains a synopsis of the fields and methods followed by the jvm
* code for each method.
*
* @param jc javaclass to dump
* @param dump_dir directory in which to write the file
*/
public static void dump(JavaClass jc, File dump_dir) {
try {
dump_dir.mkdir();
File path = new File(dump_dir, jc.getClassName() + ".bcel");
PrintStream p = new PrintStream(path);
// Print the class, super class and interfaces
p.printf("class %s extends %s\n", jc.getClassName(), jc.getSuperclassName());
String[] inames = jc.getInterfaceNames();
if ((inames != null) && (inames.length > 0)) {
p.printf(" ");
for (String iname : inames) p.printf("implements %s ", iname);
p.printf("\n");
}
// Print each field
p.printf("\nFields\n");
for (Field f : jc.getFields()) p.printf(" %s\n", f);
// Print the signature of each method
p.printf("\nMethods\n");
for (Method m : jc.getMethods()) p.printf(" %s\n", m);
// If this is not an interface, print the code for each method
if (!jc.isInterface()) {
for (Method m : jc.getMethods()) {
p.printf("\nMethod %s\n", m);
Code code = m.getCode();
if (code != null) p.printf(" %s\n", code.toString().replace("\n", "\n "));
}
}
// Print the details of the constant pool.
p.printf("Constant Pool:\n");
ConstantPool cp = jc.getConstantPool();
Constant[] constants = cp.getConstantPool();
for (int ii = 0; ii < constants.length; ii++) {
p.printf(" %d %s\n", ii, constants[ii]);
}
p.close();
} catch (Exception e) {
throw new Error("Unexpected error dumping javaclass", e);
}
}
protected String formatJavaTerms(
String fileName,
String absolutePath,
String content,
String javaClassContent,
List<String> javaTermSortExclusions,
List<String> testAnnotationsExclusions)
throws Exception {
JavaClass javaClass = new JavaClass(fileName, absolutePath, javaClassContent, StringPool.TAB);
String newJavaClassContent =
javaClass.formatJavaTerms(javaTermSortExclusions, testAnnotationsExclusions);
if (!javaClassContent.equals(newJavaClassContent)) {
return StringUtil.replaceFirst(content, javaClassContent, newJavaClassContent);
}
return content;
}
private void doExposePageLoadMethod(JavaClass jc) {
boolean hitOne = false;
for (Iterator itr = jc.findMethodsByName("Page_Load").iterator(); itr.hasNext(); ) {
JavaMethod jm = (JavaMethod) itr.next();
jm.addModifier(JavaKeywords.J_PUBLIC);
hitOne = true;
}
if (!hitOne) {
throw new RuntimeException(jc + " is a form class, but has no Page_Load method...");
}
}
private static JavaClass getTargetType(ThreadContext context, Ruby runtime, IRubyObject type) {
JavaClass targetType;
if (type instanceof RubyString || type instanceof RubySymbol) {
targetType = runtime.getJavaSupport().getNameClassMap().get(type.asJavaString());
if (targetType == null) targetType = JavaClass.forNameVerbose(runtime, type.asJavaString());
} else if (type instanceof RubyModule && type.respondsTo("java_class")) {
targetType = (JavaClass) Helpers.invoke(context, type, "java_class");
} else if (type instanceof JavaProxy) {
if (((JavaProxy) type).getObject() instanceof Class) {
targetType = JavaClass.get(runtime, (Class) ((JavaProxy) type).getObject());
} else {
throw runtime.newTypeError("not a valid target type: " + type);
}
} else {
throw runtime.newTypeError("unable to convert to type: " + type);
}
return targetType;
}
