public static ClassHolder copyClass(ClassReader original, ClassHolder target, boolean withPrograms) { target.setLevel(original.getLevel()); target.getModifiers().addAll(original.readModifiers()); target.setParent(original.getParent()); target.getInterfaces().addAll(original.getInterfaces()); for (MethodReader method : original.getMethods()) { target.addMethod(copyMethod(method, withPrograms)); } for (FieldReader field : original.getFields()) { target.addField(copyField(field)); } target.setOwnerName(original.getOwnerName()); copyAnnotations(original.getAnnotations(), target.getAnnotations()); return target; }
private MethodReader findOverriddenMethod(String className, MethodReader finalMethod) { if (finalMethod.getName().equals("<init>")) { return null; } return classSource.getAncestors(className) .skip(1) .map(cls -> cls.getMethod(finalMethod.getDescriptor())) .filter(Objects::nonNull) .findFirst() .orElse(null); }
for (String className : classSource.getClassNames()) { ClassReader cls = classSource.get(className); if (cls == null || cls.hasModifier(ElementModifier.INTERFACE)) { continue; for (String iface : cls.getInterfaces()) { String topmostImplementor = findTopmostImplementor(classSource, className, iface); markImplementor(classSource, topmostImplementor, iface, implementedBy); if (cls.getParent() == null || cls.getParent().equals(cls.getName())) { roots.add(className); } else { hierarchy.computeIfAbsent(cls.getParent(), key -> new ArrayList<>()).add(className); continue; if (cls.hasModifier(ElementModifier.INTERFACE)) { Set<String> implementorRoots = implementedBy.get(cls.getName()); if (implementorRoots != null) { List<Range> ifaceRanges = implementorRoots.stream()
private boolean needsData(ClassReader cls) { if (cls.hasModifier(ElementModifier.INTERFACE)) { return false; } return !cls.getName().equals(Structure.class.getName()) && !cls.getName().equals(Address.class.getName()); }
private boolean examineIfJavaScriptClass(String className) { ClassReader cls = classSource.get(className); if (cls == null || !(cls.hasModifier(ElementModifier.INTERFACE) || cls.hasModifier(ElementModifier.ABSTRACT))) { return false; } if (cls.getParent() != null) { if (isJavaScriptClass(cls.getParent())) { return true; } } return cls.getInterfaces().stream().anyMatch(this::isJavaScriptClass); }
private Set<MethodReference> findOverriddenMethods(ClassReader cls, MethodDescriptor methodDesc) { List<String> parents = new ArrayList<>(); if (cls.getParent() != null) { parents.add(cls.getParent()); } parents.addAll(cls.getInterfaces()); Set<String> visited = new HashSet<>(); Set<MethodReference> overridden = new HashSet<>(); for (String parent : parents) { findOverriddenMethods(parent, methodDesc, overridden, visited); } return overridden; }
@Override public ReflectMethod[] getDeclaredMethods() { resolve(); if (classReader == null) { return new ReflectMethod[0]; } return classReader.getMethods().stream() .filter(method -> !method.getName().equals("<clinit>")) .map(method -> getDeclaredMethod(method.getDescriptor())) .toArray(ReflectMethod[]::new); }
private void calculateLayout(ClassReader cls, ClassBinaryData data) { if (cls.getName().equals(Structure.class.getName()) || cls.getName().equals(Address.class.getName())) { data.size = 0; data.start = -1; return; } else if (cls.getName().equals(Function.class.getName())) { data.size = 0; data.start = -1; data.function = true; return; } else if (cls.getParent() != null) { addClass(ValueType.object(cls.getParent())); ClassBinaryData parentData = binaryDataMap.get(ValueType.object(cls.getParent())); data.size = parentData.size; data.alignment = parentData.alignment; data.isInferface = cls.hasModifier(ElementModifier.INTERFACE); data.cls = cls; for (FieldReader field : cls.getFields()) { int desiredAlignment = getTypeSize(field.getType()); if (field.hasModifier(ElementModifier.STATIC)) {
boolean isProperFunctor(ClassReader type) { if (!type.hasModifier(ElementModifier.INTERFACE)) { return false; } return type.getMethods().stream() .filter(method -> method.hasModifier(ElementModifier.ABSTRACT)) .count() == 1; }
private void substitute(ClassHolder cls, ClassHierarchy hierarchy) { ClassReader subst = hierarchy.getClassSource().get(TeaVMLoggerFactorySubstitution.class.getName()); for (FieldHolder field : cls.getFields().toArray(new FieldHolder[0])) { cls.removeField(field); } for (MethodHolder method : cls.getMethods().toArray(new MethodHolder[0])) { cls.removeMethod(method); } for (FieldReader field : subst.getFields()) { cls.addField(ModelUtils.copyField(field)); } for (MethodReader method : subst.getMethods()) { cls.addMethod(ModelUtils.copyMethod(method)); } } }
private void addPreservedMethods(String ifaceName, Set<MethodDescriptor> methods) { ClassReader iface = classSource.get(ifaceName); for (MethodReader method : iface.getMethods()) { methods.add(method.getDescriptor()); } for (String superIfaceName : iface.getInterfaces()) { addPreservedMethods(superIfaceName, methods); } }
@Override public void classReached(DependencyAgent agent, String className) { ClassReader cls = agent.getClassSource().get(className); if (cls == null) { return; } if (cls.hasModifier(ElementModifier.ABSTRACT) || cls.hasModifier(ElementModifier.INTERFACE)) { return; } MethodReader method = cls.getMethod(INIT_METHOD); if (method != null) { allClassesNode.propagate(agent.getType(className)); } }
private void getFunctorMethods(String className, Map<MethodDescriptor, MethodReference> methods) { classSource.getAncestors(className).forEach(cls -> { if (cls.getAnnotations().get(JSFunctor.class.getName()) != null && marshaller.isProperFunctor(cls)) { MethodReference method = cls.getMethods().iterator().next().getReference(); if (!methods.containsKey(method.getDescriptor())) { methods.put(method.getDescriptor(), method); } } }); }
private boolean addInterface(ExposedClass exposedCls, ClassReader cls) { if (cls.getName().equals(JSObject.class.getName())) { return true; } return addInterfaces(exposedCls, cls); }
private void createExposedClass(ClassReader cls, ExposedClass exposedCls) { if (cls.hasModifier(ElementModifier.INTERFACE)) { return; } if (cls.getParent() != null) { ExposedClass parent = getExposedClass(cls.getParent()); exposedCls.inheritedMethods.putAll(parent.inheritedMethods); exposedCls.inheritedMethods.putAll(parent.methods); exposedCls.implementedInterfaces.addAll(parent.implementedInterfaces); } addInterfaces(exposedCls, cls); }
@SuppressWarnings("unchecked") @Override public ReflectClass<? super T> getSuperclass() { resolve(); if (classReader == null || classReader.getParent() == null || classReader.getName().equals(classReader.getParent())) { return null; } return (ReflectClass<? super T>) context.getClass(new ValueType.Object(classReader.getParent())); }
private static List<String> pathToRoot(ClassReaderSource classSource, String className) { List<String> path = new ArrayList<>(); while (true) { path.add(className); ClassReader cls = classSource.get(className); if (cls == null || cls.getParent() == null) { break; } className = cls.getParent(); } return path; }
private boolean isStaticInit(String className) { ClassReader cls = unprocessedClassSource.get(className); if (cls == null) { return false; } return cls.getAnnotations().get(StaticInit.class.getName()) != null; }
private void writeFunctor(ClassReader cls, FieldReference functorField) throws IOException { AnnotationReader implAnnot = cls.getAnnotations().get(FunctorImpl.class.getName()); MethodDescriptor functorMethod = MethodDescriptor.parse(implAnnot.getValue("value").getString()); String alias = cls.getMethod(functorMethod).getAnnotations() .get(JSMethodToExpose.class.getName()).getValue("name").getString(); if (alias == null) { return; } writer.append("c.jso$functor$").append(alias).ws().append("=").ws().append("function()").ws().append("{") .indent().softNewLine(); writer.append("if").ws().append("(!this.").appendField(functorField).append(")").ws().append("{") .indent().softNewLine(); writer.append("var self").ws().append('=').ws().append("this;").softNewLine(); writer.append("this.").appendField(functorField).ws().append('=').ws().append("function("); appendArguments(functorMethod.parameterCount()); writer.append(")").ws().append('{').indent().softNewLine(); writer.append("return self.").appendMethod(functorMethod).append('('); appendArguments(functorMethod.parameterCount()); writer.append(");").softNewLine(); writer.outdent().append("};").softNewLine(); writer.outdent().append("}").softNewLine(); writer.append("return this.").appendField(functorField).append(';').softNewLine(); writer.outdent().append("};").softNewLine(); }