Refine search
function Clazz() {}; Clazz.staticMethod = function() { alert('STATIC!!!'); }; Clazz.prototype.func = function() { this.constructor.staticMethod(); } var obj = new Clazz(); obj.func(); // <- Alert's "STATIC!!!"
analyzer.error( "AD for %s.%s uses an array of collections in return type (%s), Metatype allows either Vector or array", clazz.getClassName().getFQN(), defined.getName(), defined.getType().getFQN()); Matcher m = COLLECTION.matcher(rtype); if (m.matches()) { rtype = Clazz.objectDescriptorToFQN(m.group(3)); ad.cardinality = Integer.MIN_VALUE; TypeRef typeRef = analyzer.getTypeRefFromFQN(rtype); try { Clazz c = analyzer.findClass(typeRef); if (c != null && c.isEnum()) { parseOptionValues(c, ad.options); analyzer.error( "AD for %s.%s Can not parse option values from type (%s), %s", clazz.getClassName().getFQN(), defined.getName(), defined.getType().getFQN(), e.getMessage());
Analyzer a = new Analyzer(); Clazz clazz = new Clazz(a, "", new URLResource(url)); Map<String,String> d = ComponentAnnotationReader.getDefinition(clazz); Matcher matcher = REFERENCE.matcher(key); if (matcher.matches()) { Reference r = new Reference(); r.name = matcher.group(1); r.set = findMethod(matcher.group(2)); r.unset = findMethod(matcher.group(3));
Matcher m = Patterns.UPDATED_CONFIG_TYPES.matcher(callbackDescriptor); List<String> types = new ArrayList<>(); while (m.find()) { String type = m.group(5); if (type != null) { m_logger.debug("checking if type %s is an interface or an annotation", type); TypeRef typeRef = m_analyzer.getTypeRef(type); try { Clazz clazz = m_analyzer.findClass(typeRef); if (! clazz.isAnnotation() && ! clazz.isInterface()) { m_logger.debug("ignoring updated callback signature %s (argument type not an interface or an annotation", callbackDescriptor); continue;
private boolean identifiableCollection(TypeRef type, boolean intface, boolean topLevel) { try { Clazz clazz = analyzer.findClass(type); if (clazz != null && (!topLevel || !clazz.isAbstract()) && ((intface && clazz.isInterface()) ^ clazz.hasPublicNoArgsConstructor())) { TypeRef[] intfs = clazz.getInterfaces(); if (intfs != null) { for (TypeRef intf : intfs) { if (COLLECTION.matcher(intf.getFQN()) .matches() || identifiableCollection(intf, true, false)) { return true; } } } TypeRef ext = clazz.getSuper(); return ext != null && identifiableCollection(ext, false, false); } } catch (Exception e) { return false; } return false; }
if (!PACKAGEPATTERN.matcher(element.trim()) .matches()) { allElementsAreTypes = false; break; if (activatorClazz.isInterface()) { registerActivatorErrorLocation( error("The Bundle Activator %s is an interface and therefore cannot be instantiated.", bactivator, ActivatorErrorType.IS_INTERFACE); } else { if (activatorClazz.isAbstract()) { registerActivatorErrorLocation( error("The Bundle Activator %s is abstract and therefore cannot be instantiated.", bactivator, ActivatorErrorType.IS_ABSTRACT); if (!activatorClazz.isPublic()) { registerActivatorErrorLocation( error("Bundle Activator classes must be public, and %s is not.", bactivator), bactivator, ActivatorErrorType.NOT_PUBLIC); if (!activatorClazz.hasPublicNoArgsConstructor()) { registerActivatorErrorLocation(error( "Bundle Activator classes must have a public zero-argument constructor and %s does not.", if (!analyzer.assignable(activatorClazz.getFQN(), "org.osgi.framework.BundleActivator")) {
name); FileLine where = getHeader(Pattern.compile(Constants.SERVICE_COMPONENT), Pattern.compile(Pattern.quote(name))); if (where != null) { where.set(warning); Collection<Clazz> classes = analyzer.getClasses(null, "NAMED", name, "ANNOTATED", "aQute.bnd.annotation.component.Component"); clazz.getFQN()); TypeRef cname = clazz.getClassName(); String source = analyzer.getSourceFileFor(cname); if (source != null) { File f = getFile(source);
/* int max_stack = */in.readUnsignedShort(); /* int max_locals = */in.readUnsignedShort(); int code_length = in.readInt(); byte code[] = new byte[code_length]; in.readFully(code); crawl(code); int exception_table_length = in.readUnsignedShort(); in.skipBytes(exception_table_length * 8); doAttributes(in, ElementType.METHOD, false, 0);
/* int max_stack = */in.readUnsignedShort(); /* int max_locals = */in.readUnsignedShort(); int code_length = in.readInt(); byte code[] = new byte[code_length]; in.readFully(code); crawl(code); int exception_table_length = in.readUnsignedShort(); for (int i = 0; i < exception_table_length; i++) { int handler_pc = in.readUnsignedShort(); int catch_type = in.readUnsignedShort(); classConstRef(catch_type); doAttributes(in, ElementType.METHOD, false, 0);
case 'I' : // Integer case 'S' : // Short int const_value_index = in.readUnsignedShort(); return intPool[const_value_index]; int type_name_index = in.readUnsignedShort(); if (policy == RetentionPolicy.RUNTIME) { referTo(type_name_index, 0); if (api != null && (Modifier.isPublic(access_flags) || Modifier.isProtected(access_flags))) { TypeRef name = analyzer.getTypeRef((String) pool[type_name_index]); api.add(name.getPackageRef()); int class_info_index = in.readUnsignedShort(); if (policy == RetentionPolicy.RUNTIME) { referTo(class_info_index, 0); if (api != null && (Modifier.isPublic(access_flags) || Modifier.isProtected(access_flags))) { TypeRef name = analyzer.getTypeRef((String) pool[class_info_index]); api.add(name.getPackageRef()); return doAnnotation(in, member, policy, collect, access_flags); Object[] result = new Object[num_values]; for (int i = 0; i < num_values; i++) { result[i] = doElementValue(in, member, policy, collect, access_flags);
private void doAnnotations(DataInputStream in, ElementType member, RetentionPolicy policy, int access_flags) throws IOException { int num_annotations = in.readUnsignedShort(); // # of annotations for (int a = 0; a < num_annotations; a++) { if (cd == null) doAnnotation(in, member, policy, false, access_flags); else { Annotation annotion = doAnnotation(in, member, policy, true, access_flags); cd.annotation(annotion); } } }
Map<String, Clazz> mismatched = new HashMap<>(); String relativeDir = relativePath.substring(0, n); clazz = new Clazz(this, path, resource); clazz.parseClassFile(); } catch (Throwable e) { exception(e, "Invalid class file %s (%s)", relativePath, e); continue next; String calculatedPath = clazz.getClassName() .getPath(); if (!calculatedPath.equals(relativePath)) { mismatched.put(clazz.getAbsolutePath(), clazz); } else { classspace.put(clazz.getClassName(), clazz); PackageRef packageRef = clazz.getClassName() .getPackageRef(); learnPackage(jar, prefix, packageRef, contained); for (PackageRef p : clazz.getReferred()) { referred.put(p); refs.add(p); apiUses.addAll(packageRef, clazz.getAPIUses());
/** * Visit each class on the class path. * * @param visitor the visitor */ public void visit(ClassVisitor visitor) throws Exception { try (Analyzer analyzer = new Analyzer()) { for (File f : entries) { try (Jar jar = new Jar(f)) { for (String path : jar.getResources() .keySet()) { if (path.endsWith(".class")) { Resource r = jar.getResource(path); Clazz c = new Clazz(analyzer, path, r); c.parseClassFile(); visitor.visit(c); } } } } } }
return; Manifest m = analyzer.getJar().getManifest(); if (m == null) { error("No manifest"); Set<PackageRef> unresolvedReferences = new TreeSet<PackageRef>(analyzer.getReferred().keySet()); unresolvedReferences.removeAll(analyzer.getContained().keySet()); for ( String pname : domain.getImportPackage().keySet()) { PackageRef pref = analyzer.getPackageRef(pname); for (Clazz clazz : analyzer.getClassspace().values()) { if (hasOverlap(unresolvedReferences, clazz.getReferred())) culprits.add(clazz.getAbsolutePath());
/** * Visit each class on the class path. * * @param visitor * the visitor */ public void visit(ClassVisitor visitor) throws Exception { Analyzer analyzer = new Analyzer(); try { for (File f : entries) { Jar jar = new Jar(f); try { for (String path : jar.getResources().keySet()) { if (path.endsWith(".class")) { Resource r = jar.getResource(path); Clazz c = new Clazz(analyzer, path, r); c.parseClassFile(); visitor.visit(c); } } } finally { jar.close(); } } } finally { analyzer.close(); } }
public boolean analyzeJar(Analyzer analyzer) throws Exception { Parameters map = analyzer.parseHeader(analyzer.getProperty(Constants.METATYPE)); Jar jar = analyzer.getJar(); for (String name : map.keySet()) { Collection<Clazz> metatypes = analyzer.getClasses("", QUERY.ANNOTATED.toString(), Meta.OCD.class.getName(), // QUERY.NAMED.toString(), name // ); for (Clazz c : metatypes) { jar.putResource("OSGI-INF/metatype/" + c.getFQN() + ".xml", new MetaTypeReader(c, analyzer)); } } return false; } }
private ComponentDef getDef() throws Exception { if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) { if (clazz.is(ANNOTATED, COMPONENT_INSTR, analyzer)) { analyzer .error("The type %s is not a class and therfore not suitable for the @Component annotation", clazz.getFQN()) .details( new DeclarativeServicesAnnotationError(clazz.getFQN(), null, ErrorType.INVALID_COMPONENT_TYPE)); if (!clazz.is(ANNOTATED, COMPONENT_INSTR, analyzer)) { clazz.parseClassFileWithCollector(this); if (component.implementation == null) return null; break; Clazz ec = analyzer.findClass(extendsClass); if (ec == null) { analyzer .error("Missing super class for DS annotations: %s from %s", extendsClass, clazz.getClassName()) .details(new DeclarativeServicesAnnotationError(className.getFQN(), null, null, ErrorType.UNABLE_TO_LOCATE_SUPER_CLASS)); break; } else { ec.parseClassFileWithCollector(this);
public boolean analyzeJar(Analyzer analyzer) throws Exception { Parameters header = OSGiHeader.parseHeader(analyzer.getProperty(Constants.DSANNOTATIONS)); if (header.size() == 0) return false; Instructions instructions = new Instructions(header); Collection<Clazz> list = analyzer.getClassspace().values(); String sc = analyzer.getProperty(Constants.SERVICE_COMPONENT); List<String> names = new ArrayList<String>(); if (sc != null && sc.trim().length() > 0) names.add(sc); for (Clazz c: list) { for (Instruction instruction : instructions.keySet()) { if (instruction.matches(c.getFQN())) { if (instruction.isNegated()) break; ComponentDef definition = AnnotationReader.getDefinition(c, analyzer); if (definition != null) { definition.sortReferences(); definition.prepare(analyzer); String name = "OSGI-INF/" + analyzer.validResourcePath(definition.name, "Invalid component name") + ".xml"; names.add(name); analyzer.getJar().putResource(name, new TagResource(definition.getTag())); } } } } sc = Processor.append(names.toArray(new String[names.size()])); analyzer.setProperty(Constants.SERVICE_COMPONENT, sc); return false; }
private List<BeanDef> getDefs() throws Exception { if (clazz.isEnum() || clazz.isInterface() || clazz.isAnnotation()) { if (options.contains(Discover.all) && !clazz.is(QUERY.CONCRETE, null, analyzer)) { return null; if (clazz.is(QUERY.ANNOTATED, VETOED_INSTR, analyzer) || (!clazz.is(QUERY.INDIRECTLY_ANNOTATED, COMPONENTSCOPED_INSTR, analyzer) && !clazz.is(QUERY.INDIRECTLY_ANNOTATED, NORMALSCOPE_INSTR, analyzer) && !clazz.is(QUERY.INDIRECTLY_ANNOTATED, STEREOTYPE_INSTR, analyzer) && !clazz.is(QUERY.ANNOTATED, DEPENDENT_INSTR, analyzer) && !clazz.is(QUERY.ANNOTATED, INTERCEPTOR_INSTR, analyzer)) || clazz.is(QUERY.IMPLEMENTS, EXTENSION_INSTR, analyzer)) { Clazz packageClazz = analyzer.getPackageInfo(clazz.getClassName() .getPackageRef()); if (packageClazz != null && packageClazz.is(QUERY.ANNOTATED, VETOED_INSTR, analyzer)) { return null; clazz.parseClassFileWithCollector(this);
TypeRef typeRef = analyzer.getTypeRef(param.binary); try { Clazz clazz = analyzer.findClass(typeRef); if (clazz.isAnnotation()) { component.updateVersion(V1_3); clazz.parseClassFileWithCollector( new ComponentPropertyTypeDataCollector(propertyDefKey, memberDescriptor, details)); } else if (clazz.isInterface() && options.contains(Options.felixExtensions)) { component.updateVersion(V1_3); } else { analyzer .error("Non annotation type for activation object with descriptor %s, type %s", memberDescriptor, param.binary) .details(details);