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)"); } }
@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 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(); }
/** * Get the number of parameters passed to method invocation. * * @param inv * @param cpg * @return int number of parameters */ public static int getNumParametersForInvocation(InvokeInstruction inv, ConstantPoolGen cpg) { SignatureParser sigParser = new SignatureParser(inv.getSignature(cpg)); return sigParser.getNumParameters(); }
@Override public int getNumParams() { // FIXME: cache this? return new SignatureParser(getSignature()).getNumParameters(); }
@Override public int getNumParams() { return new SignatureParser(getSignature()).getNumParameters(); }
public int getNumParams() { return new SignatureParser(getSignature()).getNumParameters(); }
/** * Get the number of arguments passed to given method invocation. * * @param ins * the method invocation instruction * @param cpg * the ConstantPoolGen for the class containing the method * @return number of arguments; note that this excludes the object instance * for instance methods */ public int getNumArguments(InvokeInstruction ins, ConstantPoolGen cpg) { SignatureParser parser = new SignatureParser(ins.getSignature(cpg)); return parser.getNumParameters(); }
/** * Get the <i>i</i>th argument passed to given method invocation. * * @param ins * the method invocation instruction * @param cpg * the ConstantPoolGen for the class containing the method * @param i * index of the argument; 0 for the first argument, etc. * @param numArguments * total number of arguments to the method * @return the <i>i</i>th argument * @throws DataflowAnalysisException */ @Deprecated public ValueType getArgument(InvokeInstruction ins, ConstantPoolGen cpg, int i, int numArguments) throws DataflowAnalysisException { SignatureParser sigParser = new SignatureParser(ins.getSignature(cpg)); return getArgument(ins, cpg, i, sigParser); }
@Override public boolean isReturnTypeReferenceType() { SignatureParser parser = new SignatureParser(getSignature()); String returnTypeSig = parser.getReturnTypeSignature(); return SignatureParser.isReferenceType(returnTypeSig); }
@Override public boolean isReturnTypeReferenceType() { SignatureParser parser = new SignatureParser(getSignature()); String returnTypeSig = parser.getReturnTypeSignature(); return SignatureParser.isReferenceType(returnTypeSig); }
@Override public org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(int parameter, String desc, boolean visible) { AnnotationValue value = new AnnotationValue(desc); int shift = 0; if (parameterCount >= 0) { // if we have synthetic parameter, shift `parameter` value shift = new SignatureParser(methodDesc).getNumParameters() - parameterCount; } mBuilder.addParameterAnnotation(parameter + shift, desc, value); return value.getAnnotationVisitor(); }
/** * Build map of value numbers to param indices. The first parameter has * index 0, the second has index 1, etc. * * @param methodSignature * signature of the method analyzed by the ValueNumberAnalysis * @param isStatic * true if the method is static, false if not * @return the value number to parameter index map */ public Map<ValueNumber, Integer> getValueNumberToParamMap(String methodSignature, boolean isStatic) { HashMap<ValueNumber, Integer> valueNumberToParamMap = new HashMap<>(); ValueNumberFrame frameAtEntry = getStartFact(getCFG().getEntry()); int numParams = new SignatureParser(methodSignature).getNumParameters(); int shift = isStatic ? 0 : 1; for (int i = 0; i < numParams; ++i) { valueNumberToParamMap.put(frameAtEntry.getValue(i + shift), i); } return valueNumberToParamMap; }
/** * @param result * @param m */ public static void addKnownTypeQualifiersForParameters(HashSet<? super TypeQualifierValue<?>> result, XMethod m) { int numParameters = new SignatureParser(m.getSignature()).getNumParameters(); for (int p = 0; p < numParameters; p++) { addKnownTypeQualifiers(result, TypeQualifierApplications.getApplicableApplications(m, p)); } }
private void processInvokeDynamic(DismantleBytecode dbc) { String signature = dbc.getSigConstantOperand(); int numberArguments = PreorderVisitor.getNumberArguments(signature); pop(numberArguments); pushBySignature(new SignatureParser(signature).getReturnTypeSignature(), dbc); }
@Test public void testNoParams() { SignatureParser sut = new SignatureParser("()V"); Iterator<String> i = sut.parameterSignatureIterator(); Assert.assertFalse(i.hasNext()); }
@Override public void visit(Code code) { SignatureParser sp = new SignatureParser(getMethodSig()); // Check to see if the method has expected return type String returnSignature = sp.getReturnTypeSignature(); if (!matchesReturnSignature(returnSignature)){ return; } if (isExplicitlyNullable()){ return; } super.visit(code); // make callbacks to sawOpcode for all opcodes bugAccumulator.reportAccumulatedBugs(); }
private void pushByInvoke(DismantleBytecode dbc, boolean popThis) { String signature = dbc.getSigConstantOperand(); if (Const.CONSTRUCTOR_NAME.equals(dbc.getNameConstantOperand()) && signature.endsWith(")V") && popThis) { pop(PreorderVisitor.getNumberArguments(signature)); Item constructed = pop(); if (getStackDepth() > 0) { Item next = getStackItem(0); if (constructed.equals(next)) { next = new Item(next); next.source = XFactory.createReferencedXMethod(dbc); next.pc = dbc.getPC(); replace(0, next); } } return; } pop(PreorderVisitor.getNumberArguments(signature) + (popThis ? 1 : 0)); pushBySignature(new SignatureParser(signature).getReturnTypeSignature(), dbc); }
private void registerParameterSources() { ValueNumberFrame vnaFrameAtEntry = vnaDataflow.getStartFact(cfg.getEntry()); SignatureParser sigParser = new SignatureParser(xmethod.getSignature()); int firstParamSlot = xmethod.isStatic() ? 0 : 1; int param = 0; int slotOffset = 0; for ( String paramSig : sigParser.parameterSignatures()) { // Get the TypeQualifierAnnotation for this parameter SourceSinkInfo info; TypeQualifierAnnotation tqa = TypeQualifierApplications.getEffectiveTypeQualifierAnnotation(xmethod, param, typeQualifierValue); When when = (tqa != null) ? tqa.when : When.UNKNOWN; ValueNumber vn = vnaFrameAtEntry.getValue(slotOffset + firstParamSlot); info = new SourceSinkInfo(SourceSinkType.PARAMETER, cfg.getLocationAtEntry(), vn, when); info.setParameterAndLocal(param, slotOffset + firstParamSlot); registerSourceSink(info); param++; slotOffset += SignatureParser.getNumSlotsForType(paramSig); } }