public GenericMethodDescriptor(List<String> typeParameters, List<List<GenericType>> typeParameterBounds, List<GenericType> parameterTypes, GenericType returnType, List<GenericType> exceptionTypes) { this.typeParameters = substitute(typeParameters); this.typeParameterBounds = substitute(typeParameterBounds); this.parameterTypes = substitute(parameterTypes); this.returnType = returnType; this.exceptionTypes = substitute(exceptionTypes); }
public GenericType decreaseArrayDim() { assert arrayDim > 0 : this; return new GenericType(this, arrayDim - 1); }
public static GenericFieldDescriptor parseFieldSignature(String signature) { try { return new GenericFieldDescriptor(new GenericType(signature)); } catch (RuntimeException e) { DecompilerContext.getLogger().writeMessage("Invalid signature: " + signature, IFernflowerLogger.Severity.WARN); return null; } }
public static GenericClassDescriptor parseClassSignature(String signature) { String original = signature; try { GenericClassDescriptor descriptor = new GenericClassDescriptor(); signature = parseFormalParameters(signature, descriptor.fparameters, descriptor.fbounds); String superCl = GenericType.getNextType(signature); descriptor.superclass = new GenericType(superCl); signature = signature.substring(superCl.length()); while (signature.length() > 0) { String superIf = GenericType.getNextType(signature); descriptor.superinterfaces.add(new GenericType(superIf)); signature = signature.substring(superIf.length()); } return descriptor; } catch (RuntimeException e) { DecompilerContext.getLogger().writeMessage("Invalid signature: " + original, IFernflowerLogger.Severity.WARN); return null; } }
private static void parseArgumentsList(String value, GenericType type) { if (value == null) { return; } while (value.length() > 0) { String typeStr = getNextType(value); int len = typeStr.length(); int wildcard = WILDCARD_NO; switch (typeStr.charAt(0)) { case '*': wildcard = WILDCARD_UNBOUND; break; case '+': wildcard = WILDCARD_EXTENDS; break; case '-': wildcard = WILDCARD_SUPER; break; } type.getWildcards().add(wildcard); if (wildcard != WILDCARD_NO) { typeStr = typeStr.substring(1); } type.getArguments().add(typeStr.length() == 0 ? null : new GenericType(typeStr)); value = value.substring(len); } }
List<String> typeParameters = new ArrayList<>(); List<List<GenericType>> typeParameterBounds = new ArrayList<>(); signature = parseFormalParameters(signature, typeParameters, typeParameterBounds); String par = GenericType.getNextType(parameters); parameterTypes.add(new GenericType(par)); parameters = parameters.substring(par.length()); String ret = GenericType.getNextType(signature); GenericType returnType = new GenericType(ret); signature = signature.substring(ret.length()); String[] exceptions = signature.split("\\^"); for (int i = 1; i < exceptions.length; i++) { exceptionTypes.add(new GenericType(exceptions[i])); return new GenericMethodDescriptor(typeParameters, typeParameterBounds, parameterTypes, returnType, exceptionTypes);
private static void appendTypeArguments(GenericType type, StringBuilder buffer) { if (!type.getArguments().isEmpty()) { buffer.append('<'); for (int i = 0; i < type.getArguments().size(); i++) { if (i > 0) { buffer.append(", "); int wildcard = type.getWildcards().get(i); switch (wildcard) { case GenericType.WILDCARD_UNBOUND: GenericType genPar = type.getArguments().get(i); if (genPar != null) { buffer.append(getGenericCastTypeName(genPar));
String cl = getNextClassSignature(signature); GenericType type11 = new GenericType(CodeConstants.TYPE_OBJECT, 0, name); parseArgumentsList(args, type11); enclosingClasses.add(type11); parseArgumentsList(args, this); break;
StructGenericSignatureAttribute attr = mt.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { descriptor = GenericMain.parseMethodSignature(attr.getSignature()); if (descriptor != null) { long actualParams = md.params.length; buffer.append(GenericMain.getGenericCastTypeName(descriptor.returnType)); isVarArg &= parameterType.arrayDim > 0; if (isVarArg) { parameterType = parameterType.decreaseArrayDim(); typeName = GenericMain.getGenericCastTypeName(parameterType); buffer.append(GenericMain.getGenericCastTypeName(type));
String signature = attr.getSignature(originalIndex, visibleOffset); if (signature != null) { GenericFieldDescriptor descriptor = GenericMain.parseFieldSignature(signature); if (descriptor != null) { buffer.append(GenericMain.getGenericCastTypeName(descriptor.type)); return;
private static void appendClassName(GenericType type, StringBuilder buffer) { List<GenericType> enclosingClasses = type.getEnclosingClasses(); if (enclosingClasses.isEmpty()) { String name = type.value.replace('/', '.'); buffer.append(DecompilerContext.getImportCollector().getShortName(name)); } else { for (GenericType tp : enclosingClasses) { if (buffer.length() == 0) { buffer.append(DecompilerContext.getImportCollector().getShortName(tp.value.replace('/', '.'))); } else { buffer.append(tp.value); } appendTypeArguments(tp, buffer); buffer.append('.'); } buffer.append(type.value); } appendTypeArguments(type, buffer); }
String bound = GenericType.getNextType(value); lstBounds.add(new GenericType(bound)); value = value.substring(bound.length());
public static void appendTypeParameters(TextBuffer buffer, List<String> parameters, List<? extends List<GenericType>> bounds) { buffer.append('<'); for (int i = 0; i < parameters.size(); i++) { if (i > 0) { buffer.append(", "); } buffer.append(parameters.get(i)); List<GenericType> parameterBounds = bounds.get(i); if (parameterBounds.size() > 1 || !"java/lang/Object".equals(parameterBounds.get(0).value)) { buffer.append(" extends "); buffer.append(GenericMain.getGenericCastTypeName(parameterBounds.get(0))); for (int j = 1; j < parameterBounds.size(); j++) { buffer.append(" & "); buffer.append(GenericMain.getGenericCastTypeName(parameterBounds.get(j))); } } } buffer.append('>'); } }
public static String getGenericCastTypeName(GenericType type) { StringBuilder s = new StringBuilder(getTypeName(type)); TextUtil.append(s, "[]", type.arrayDim); return s.toString(); }
private static String getTypeName(GenericType type) { int tp = type.type; if (tp <= CodeConstants.TYPE_BOOLEAN) { return typeNames[tp]; } else if (tp == CodeConstants.TYPE_VOID) { return "void"; } else if (tp == CodeConstants.TYPE_GENVAR) { return type.value; } else if (tp == CodeConstants.TYPE_OBJECT) { StringBuilder buffer = new StringBuilder(); appendClassName(type, buffer); return buffer.toString(); } throw new RuntimeException("Invalid type: " + type); }
public static GenericClassDescriptor getGenericClassDescriptor(StructClass cl) { if (DecompilerContext.getOption(IFernflowerPreferences.DECOMPILE_GENERIC_SIGNATURES)) { StructGenericSignatureAttribute attr = cl.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { return GenericMain.parseClassSignature(attr.getSignature()); } } return null; }
StructGenericSignatureAttribute attr = fd.getAttribute(StructGeneralAttribute.ATTRIBUTE_SIGNATURE); if (attr != null) { descriptor = GenericMain.parseFieldSignature(attr.getSignature()); buffer.append(GenericMain.getGenericCastTypeName(descriptor.type));
if (descriptor != null) { if (descriptor.superinterfaces.isEmpty()) { buf.append(GenericMain.getGenericCastTypeName(descriptor.superclass)); IFernflowerLogger.Severity.WARN); buf.append(GenericMain.getGenericCastTypeName(descriptor.superinterfaces.get(0)));
public static String getGenericCastTypeName(GenericType type) { String s = getTypeName(type); int dim = type.arrayDim; while (dim-- > 0) { s += "[]"; } return s; }
buffer.append("extends "); if (descriptor != null) { buffer.append(GenericMain.getGenericCastTypeName(descriptor.superclass)); buffer.append(GenericMain.getGenericCastTypeName(descriptor.superinterfaces.get(i)));