public String getParameter(int pos) { int count = 0; for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) { String p = i.next(); if (pos == count) { return p; } ++count; } throw new IndexOutOfBoundsException("Asked for parameter " + pos + " of " + signature); }
public boolean hasReferenceParameters() { for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) { char c = i.next().charAt(0); if (c == 'L' || c == '[') { return true; } } return false; }
public String[] getArguments() { ArrayList<String> result = new ArrayList<>(); for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) { result.add(i.next()); } return result.toArray(new String[result.size()]); } /**
@Override public String[] analyze(IAnalysisCache analysisCache, MethodDescriptor descriptor) throws CheckedAnalysisException { SignatureParser parser = new SignatureParser(descriptor.getSignature()); ArrayList<String> resultList = new ArrayList<>(); for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) { resultList.add(i.next()); } return resultList.toArray(new String[resultList.size()]); } }
public static void main(String[] args) { if (args.length != 1) { System.err.println("Usage: " + SignatureParser.class.getName() + " '<method signature>'"); System.exit(1); } SignatureParser parser = new SignatureParser(args[0]); for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) { System.out.println(i.next()); } System.out.println(parser.getNumParameters() + " parameter(s)"); } }
@Nonnull int[] getParameterOffset() { if ( parameterOffset != null ) { return parameterOffset; } ArrayList<Integer> offsets = new ArrayList<>(); Iterator<String> i = parameterSignatureIterator(); int totalSize = 0; while (i.hasNext()) { String s = i.next(); if ("D".equals(s) || "J".equals(s)) { totalSize += 2; } else { totalSize += 1; } offsets.add(totalSize); } totalArgumentSize = totalSize; int numParameters = offsets.size(); parameterOffset = new int[numParameters]; for (int j = 0; j < numParameters; j++) { parameterOffset[j] = offsets.get(j); } return parameterOffset; }
public static String hashMethodSignature(String signature) { SignatureParser parser = new SignatureParser(signature); StringBuilder buf = new StringBuilder("("); for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) { String param = i.next(); buf.append(hashSignature(param)); } buf.append(")"); buf.append(hashSignature(parser.getReturnTypeSignature())); return buf.toString(); }
/** * Transform a method signature to allow it to be compared even if any of * its parameter types are moved to another package. * * @param signature * a method signature * @return the transformed signature */ public static String transformMethodSignature(String signature) { StringBuilder buf = new StringBuilder(); buf.append('('); SignatureParser parser = new SignatureParser(signature); for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) { String param = i.next(); param = transformSignature(param); buf.append(param); } buf.append(')'); return buf.toString(); }
/** * Rewrite a method signature. * * @param classNameRewriter * a ClassNameRewriter * @param methodSignature * a method signature * @return the rewritten method signature */ public static String rewriteMethodSignature(ClassNameRewriter classNameRewriter, String methodSignature) { if (classNameRewriter != IdentityClassNameRewriter.instance()) { SignatureParser parser = new SignatureParser(methodSignature); StringBuilder buf = new StringBuilder(); buf.append('('); for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext();) { buf.append(rewriteSignature(classNameRewriter, i.next())); } buf.append(')'); buf.append(rewriteSignature(classNameRewriter, parser.getReturnTypeSignature())); methodSignature = buf.toString(); } return methodSignature; }
static boolean compatibleParameters(String signature, String superSignature) { SignatureParser sig = new SignatureParser(signature); SignatureParser superSig = new SignatureParser(superSignature); if (sig.getNumParameters() == superSig.getNumParameters()) { Iterator<String> params = sig.parameterSignatureIterator(); Iterator<String> superParams = superSig.parameterSignatureIterator(); while (params.hasNext()) { String param = params.next(); String superParam = superParams.next(); if (areRelated(param, superParam)) { continue; } return false; } String retSig = sig.getReturnTypeSignature(); String superRetSig = superSig.getReturnTypeSignature(); if (areRelated(retSig, superRetSig)) { // it is compatible return true; } } return false; }
@Test public void testNoParams() { SignatureParser sut = new SignatureParser("()V"); Iterator<String> i = sut.parameterSignatureIterator(); Assert.assertFalse(i.hasNext()); }
for (Iterator<String> i = p.parameterSignatureIterator(); i.hasNext();) { String s = i.next(); LocalVariable localVariable = t.getLocalVariable(index, 0);
Iterator<String> signatureIterator = parser.parameterSignatureIterator(); int lowestCost = Integer.MAX_VALUE; for (int i = startIndex; i < localsThatAreParameters + startIndex; i++) {
Iterator<String> parameterIterator = sigParser.parameterSignatureIterator(); for (int i = 0; i < numParams; i++) { String parameterSignature = parameterIterator.next();
Iterator<String> signatureIterator = sigParser.parameterSignatureIterator(); int parameters = sigParser.getNumParameters(); for (int i = 0; i < parameters; i++) {
@Test public void testManyParams() { SignatureParser sut = new SignatureParser("(IJFDZLjava/lang/String;B)Ljava/lang/Object;"); Iterator<String> i = sut.parameterSignatureIterator(); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "I"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "J"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "F"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "D"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "Z"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "Ljava/lang/String;"); Assert.assertTrue(i.hasNext()); Assert.assertEquals(i.next(), "B"); Assert.assertFalse(i.hasNext()); } }
Iterator<String> signatureIterator = parser.parameterSignatureIterator(); for (int i = startIndex; i < localsThatAreParameters + startIndex; i++) { String sig = signatureIterator.next();
Iterator<String> paramIterator = parser.parameterSignatureIterator(); int i = 0; while (paramIterator.hasNext()) {
Iterator<String> s = new SignatureParser(m.getSignature()).parameterSignatureIterator(); Iterator<String> s2 = new SignatureParser(m2.getSignature()).parameterSignatureIterator(); while (s.hasNext()) { String p = s.next();
SignatureParser parser = new SignatureParser(getSigConstantOperand()); int count = 0; for (Iterator<String> i = parser.parameterSignatureIterator(); i.hasNext(); count++) { String parameter = i.next(); if ("Ljava/lang/Runnable;".equals(parameter)) {