@Override public int getNumParams() { // FIXME: cache this? return new SignatureParser(getSignature()).getNumParameters(); }
@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()]); } }
/** * Get the value number assigned to the given parameter upon entry to the * method. * * @param param * a parameter (0 == first parameter) * @return the ValueNumber assigned to that parameter */ public ValueNumber getEntryValueForParameter(int param) { SignatureParser sigParser = new SignatureParser(methodGen.getSignature()); int p = 0; int slotOffset = methodGen.isStatic() ? 0 : 1; for ( String paramSig : sigParser.parameterSignatures()) { if (p == param) { return getEntryValue(slotOffset); } p++; slotOffset += SignatureParser.getNumSlotsForType(paramSig); } throw new IllegalStateException(); }
@Override public boolean isReturnTypeReferenceType() { SignatureParser parser = new SignatureParser(getSignature()); String returnTypeSig = parser.getReturnTypeSignature(); return SignatureParser.isReferenceType(returnTypeSig); }
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)"); } }
private void processInvokeDynamic(DismantleBytecode dbc) { String signature = dbc.getSigConstantOperand(); int numberArguments = PreorderVisitor.getNumberArguments(signature); pop(numberArguments); pushBySignature(new SignatureParser(signature).getReturnTypeSignature(), dbc); }
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; }
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(); }
SignatureParser sigParser = new SignatureParser(called.getSignature()); int numParams = sigParser.getNumParameters(); Iterator<String> parameterIterator = sigParser.parameterSignatureIterator(); for (int i = 0; i < numParams; i++) { String parameterSignature = parameterIterator.next(); continue; int offset = sigParser.getSlotsFromTopOfStackForParameter(i); if (invFrame != null) { int slot = invFrame.getStackLocation(offset);
SignatureParser parser = new SignatureParser(signature); String returnType = parser.getReturnTypeSignature(); @SlashedClassName String r = ClassName.fromFieldSignature(returnType); for (int i = 0; i < parser.getNumParameters(); i++) { String p = ClassName.fromFieldSignature(parser.getParameter(i)); if (getClassName().equals(p)) { funky = true;
SignatureParser sigParser = new SignatureParser(inv.getSignature(constantPool)); int numParams = sigParser.getNumParameters(); if (numParams == 0 || !sigParser.hasReferenceParameters()) { return Collections.emptySet(); continue; int argSlot = vnaFrame.getStackLocation(sigParser.getSlotsFromTopOfStackForParameter(i)); if (invFrame != null && !reportDereference(invFrame, argSlot)) { continue;
protected void addMethodParameterAnnotation(String cName, String mName, String mSig, boolean isStatic, int param, AnnotationEnum annotation) { // if (!Subtypes.DO_NOT_USE) { // subtypes.addNamedClass(cName); // } if (addClassOnly) { return; } SignatureParser parser = new SignatureParser(mSig); if (param < 0 || param >= parser.getNumParameters()) { throw new IllegalArgumentException("can't annotation parameter #" + param + " of " + cName + "." + mName + mSig); } String signature = parser.getParameter(param); char firstChar = signature.charAt(0); boolean isReference = firstChar == 'L' || firstChar == '['; if (onlyAppliesToReferenceParameters(annotation) && !isReference) { AnalysisContext.logError("Can't apply " + annotation + " to parameter " + param + " with signature " + signature + " of " + cName + "." + mName + " : " + mSig); return; } XMethod m = XFactory.createXMethod(cName, mName, mSig, isStatic); addDirectAnnotation(new XMethodParameter(m, param), annotation); } }
SignatureParser sigParser = new SignatureParser(m.getSignature()); int numParams = sigParser.getNumParameters(); int slot = sigParser.getSlotsFromTopOfStackForParameter(j); ValueNumber valueNumber = valueNumberFrame.getStackValue(slot); if (valueNumberForThis != valueNumber) { for (int j = unconditionallyDereferencedNullArgSet.nextSetBit(0); j >= 0; j = unconditionallyDereferencedNullArgSet .nextSetBit(j + 1)) { int slot = sigParser.getSlotsFromTopOfStackForParameter(j); ValueNumber valueNumber = valueNumberFrame.getStackValue(slot); if (valueNumberForThis != valueNumber) {
argSignature = argSignature.substring(0, argSignature.indexOf(')') + 1); String call = invokedMethodName+argSignature; SignatureParser sigParser = new SignatureParser(inv.getSignature(cpg)); lhsPos = sigParser.getSlotsFromTopOfStackForParameter(0); } else { lhsPos = sigParser.getTotalArgumentSize(); int stackPos = sigParser.getSlotsFromTopOfStackForParameter(pos);
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); }
/** * 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. * @return the <i>i</i>th argument * @throws DataflowAnalysisException */ public ValueType getArgument(InvokeInstruction ins, ConstantPoolGen cpg, int i, SignatureParser sigParser) throws DataflowAnalysisException { if (i >= sigParser.getNumParameters()) { throw new IllegalArgumentException("requesting parameter # " + i + " of " + sigParser); } return getStackValue(sigParser.getSlotsFromTopOfStackForParameter(i)); }
/** * 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); }
public int getTotalArgumentSize() { if ( parameterOffset == null) { getParameterOffset(); } return totalArgumentSize; }
@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(); }
String signature; if (rvo != null) { signature = new SignatureParser(rvo.getSignature()).getReturnTypeSignature(); } else if (field != null) { signature = field.getSignature(); 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)) { OpcodeStack.Item item = stack.getStackItem(parser.getNumParameters() - 1 - count); if ("Ljava/lang/Thread;".equals(item.getSignature())) { accumulator.accumulateBug(new BugInstance(this, "DMI_THREAD_PASSED_WHERE_RUNNABLE_EXPECTED",