Ejemplo n.º 1
0
 /**
  * @param m a method reference
  * @return a SyntheticMethod corresponding to m; or null if none is available.
  */
 protected SyntheticMethod findOrCreateSyntheticMethod(MethodReference m, boolean isStatic) {
   if (syntheticMethods.containsKey(m)) {
     return syntheticMethods.get(m);
   } else {
     MethodSummary summ = null;
     if (canIgnore(m)) {
       TypeReference T = m.getDeclaringClass();
       IClass C = cha.lookupClass(T);
       if (C == null) {
         // did not load class; don't try to create a synthetic method
         syntheticMethods.put(m, null);
         return null;
       }
       summ = generateNoOp(m, isStatic);
     } else {
       summ = findSummary(m);
     }
     if (summ != null) {
       TypeReference T = m.getDeclaringClass();
       IClass C = cha.lookupClass(T);
       if (C == null) {
         syntheticMethods.put(m, null);
         return null;
       }
       SummarizedMethod n = new SummarizedMethod(m, summ, C);
       syntheticMethods.put(m, n);
       return n;
     } else {
       syntheticMethods.put(m, null);
       return null;
     }
   }
 }
Ejemplo n.º 2
0
  @Test
  public void testClassAnnotations3() throws Exception {

    TypeReference typeRef =
        TypeReference.findOrCreate(
            ClassLoaderReference.Application, "Lannotations/AnnotatedClass3");
    IClass klass = cha.lookupClass(typeRef);
    Assert.assertNotNull(klass);
    ShrikeClass shrikeClass = (ShrikeClass) klass;
    Collection<Annotation> classAnnotations = shrikeClass.getAnnotations(true);
    Assert.assertEquals(
        "[Annotation type <Application,Lannotations/AnnotationWithParams> {strParam=classStrParam}]",
        classAnnotations.toString());

    MethodReference methodRefUnderTest =
        MethodReference.findOrCreate(typeRef, Selector.make("foo()V"));

    IMethod methodUnderTest = cha.resolveMethod(methodRefUnderTest);
    Assert.assertNotNull(methodRefUnderTest.toString() + " not found", methodUnderTest);
    Assert.assertTrue(methodUnderTest instanceof ShrikeCTMethod);
    ShrikeCTMethod shrikeCTMethodUnderTest = (ShrikeCTMethod) methodUnderTest;

    Collection<Annotation> runtimeInvisibleAnnotations =
        shrikeCTMethodUnderTest.getAnnotations(true);
    Assert.assertEquals(
        "[Annotation type <Application,Lannotations/AnnotationWithParams> {enumParam=EnumElementValue [type=Lannotations/AnnotationEnum;, val=VAL1], strArrParam=ArrayElementValue [vals=[biz, boz]], annotParam=AnnotationElementValue [type=Lannotations/AnnotationWithSingleParam;, elementValues={value=sdfevs}], strParam=sdfsevs, intParam=25, klassParam=Ljava/lang/Integer;}]",
        runtimeInvisibleAnnotations.toString());
  }
Ejemplo n.º 3
0
  /** check that the types of all instance keys are assignable to declared type of pointer key */
  private void checkTypes(IntSet b) {
    assert PARANOID;
    if (b == null) return;
    if (!(pointerKey instanceof LocalPointerKey)) {
      return;
    }
    final LocalPointerKey lpk = (LocalPointerKey) pointerKey;
    CGNode node = lpk.getNode();
    final IClassHierarchy cha = node.getClassHierarchy();
    final IR ir = node.getIR();
    if (ir == null) return;
    TypeInference ti = TypeInference.make(ir, false);
    final IClass type = ti.getType(lpk.getValueNumber()).getType();
    if (type == null) return;
    // don't perform checking for exception variables
    if (cha.isAssignableFrom(cha.lookupClass(TypeReference.JavaLangThrowable), type)) {
      return;
    }
    b.foreach(
        new IntSetAction() {

          public void act(int x) {
            InstanceKey ik = instanceKeys.getMappedObject(x);
            IClass concreteType = ik.getConcreteType();
            if (!cha.isAssignableFrom(type, concreteType)) {
              System.err.println("BOOM");
              System.err.println(ir);
              System.err.println(lpk + " type " + type);
              System.err.println(ik + " type " + concreteType);
              Assertions.UNREACHABLE();
            }
          }
        });
  }
 @Override
 public IMethod getCalleeTarget(CGNode caller, CallSiteReference site, IClass receiver) {
   if (site.getDeclaredTarget().equals(JavaScriptMethods.ctorReference)) {
     assert cha.isSubclassOf(receiver, cha.lookupClass(JavaScriptTypes.Root));
     IR callerIR = caller.getIR();
     SSAAbstractInvokeInstruction callStmts[] = callerIR.getCalls(site);
     assert callStmts.length == 1;
     int nargs = callStmts[0].getNumberOfParameters();
     return findOrCreateConstructorMethod(callerIR, callStmts[0], receiver, nargs - 1);
   } else {
     return base.getCalleeTarget(caller, site, receiver);
   }
 }
 /**
  * @param type
  * @return a TypeAbstraction object representing this type. We just use ConeTypes by default,
  *     since we don't propagate information allowing us to distinguish between points and cones
  *     yet.
  */
 protected TypeAbstraction typeRef2TypeAbstraction(IClassHierarchy cha, TypeReference type) {
   IClass klass = cha.lookupClass(type);
   if (klass != null) {
     return new ConeType(klass);
   }
   Assertions.UNREACHABLE(type.toString());
   return null;
 }
Ejemplo n.º 6
0
 /**
  * Return a view of an {@link IClassHierarchy} as a {@link Graph}, with edges from classes to
  * immediate subtypes
  */
 public static Graph<IClass> typeHierarchy2Graph(IClassHierarchy cha) throws WalaException {
   Graph<IClass> result = SlowSparseNumberedGraph.make();
   for (IClass c : cha) {
     result.addNode(c);
   }
   for (IClass c : cha) {
     for (IClass x : cha.getImmediateSubclasses(c)) {
       result.addEdge(c, x);
     }
     if (c.isInterface()) {
       for (IClass x : cha.getImplementors(c.getReference())) {
         result.addEdge(c, x);
       }
     }
   }
   return result;
 }
Ejemplo n.º 7
0
 /**
  * @param method
  * @return the receiver class for this method.
  */
 private IClass getReceiverClass(IMethod method) {
   TypeReference formalType = method.getParameterType(0);
   IClass C = cha.lookupClass(formalType);
   if (method.isStatic()) {
     Assertions.UNREACHABLE("asked for receiver of static method " + method);
   }
   if (C == null) {
     Assertions.UNREACHABLE("no class found for " + formalType + " recv of " + method);
   }
   return C;
 }
Ejemplo n.º 8
0
  /**
   * Usage: ScopeFileCallGraph -sourceDir file_path -mainClass class_name
   *
   * <p>If given -mainClass, uses main() method of class_name as entrypoint. Class name should start
   * with an 'L'.
   *
   * <p>Example args: -sourceDir /tmp/srcTest -mainClass LFoo
   */
  public static void main(String[] args)
      throws ClassHierarchyException, IllegalArgumentException, CallGraphBuilderCancelException,
          IOException {
    long start = System.currentTimeMillis();
    Properties p = CommandLine.parse(args);
    String sourceDir = p.getProperty("sourceDir");
    String mainClass = p.getProperty("mainClass");
    AnalysisScope scope = new JavaSourceAnalysisScope();
    // add standard libraries to scope
    String[] stdlibs = WalaProperties.getJ2SEJarFiles();
    for (int i = 0; i < stdlibs.length; i++) {
      scope.addToScope(ClassLoaderReference.Primordial, new JarFile(stdlibs[i]));
    }
    // add the source directory
    scope.addToScope(
        JavaSourceAnalysisScope.SOURCE, new SourceDirectoryTreeModule(new File(sourceDir)));

    // build the class hierarchy
    IClassHierarchy cha =
        ClassHierarchy.make(scope, new ECJClassLoaderFactory(scope.getExclusions()));
    System.out.println(cha.getNumberOfClasses() + " classes");
    System.out.println(Warnings.asString());
    Warnings.clear();
    AnalysisOptions options = new AnalysisOptions();
    Iterable<Entrypoint> entrypoints =
        Util.makeMainEntrypoints(JavaSourceAnalysisScope.SOURCE, cha, new String[] {mainClass});
    options.setEntrypoints(entrypoints);
    // you can dial down reflection handling if you like
    //    options.setReflectionOptions(ReflectionOptions.NONE);
    AnalysisCache cache = new AnalysisCache(AstIRFactory.makeDefaultFactory());
    // CallGraphBuilder builder = new ZeroCFABuilderFactory().make(options, cache, cha, scope,
    // false);
    CallGraphBuilder builder =
        new ZeroOneContainerCFABuilderFactory().make(options, cache, cha, scope, false);
    System.out.println("building call graph...");
    CallGraph cg = builder.makeCallGraph(options, null);
    long end = System.currentTimeMillis();
    System.out.println("done");
    System.out.println("took " + (end - start) + "ms");
    System.out.println(CallGraphStats.getStats(cg));
  }
 private IMethod findOrCreateConstructorMethod(
     IR callerIR, SSAAbstractInvokeInstruction callStmt, IClass receiver, int nargs) {
   if (receiver.getReference().equals(JavaScriptTypes.Object))
     return makeObjectConstructor(receiver, nargs);
   else if (receiver.getReference().equals(JavaScriptTypes.Array))
     return makeArrayConstructor(receiver, nargs);
   else if (receiver.getReference().equals(JavaScriptTypes.StringObject))
     return makeValueConstructor(receiver, nargs, "");
   else if (receiver.getReference().equals(JavaScriptTypes.BooleanObject)) {
     assert nargs == 1;
     return makeValueConstructor(receiver, nargs, null);
   } else if (receiver.getReference().equals(JavaScriptTypes.NumberObject))
     return makeValueConstructor(receiver, nargs, new Integer(0));
   else if (receiver.getReference().equals(JavaScriptTypes.Function))
     return makeFunctionConstructor(callerIR, callStmt, receiver, nargs);
   else if (cha.isSubclassOf(receiver, cha.lookupClass(JavaScriptTypes.CodeBody)))
     return makeFunctionObjectConstructor(receiver, nargs);
   else {
     return null;
   }
 }
Ejemplo n.º 10
0
 /** @return Map: IClass -> Integer, the number of allocation sites for each type. */
 private Map<IClass, Integer> countAllocsByType(CGNode node) {
   Map<IClass, Integer> count = HashMapFactory.make();
   for (Iterator it = contextInterpreter.iterateNewSites(node); it.hasNext(); ) {
     NewSiteReference n = (NewSiteReference) it.next();
     IClass alloc = cha.lookupClass(n.getDeclaredType());
     if (alloc != null) {
       Integer old = count.get(alloc);
       if (old == null) {
         count.put(alloc, new Integer(1));
       } else {
         count.put(alloc, new Integer(old.intValue() + 1));
       }
     }
   }
   return count;
 }
Ejemplo n.º 11
0
  private void testClassAnnotations(
      TypeReference typeUnderTest,
      Collection<Annotation> expectedRuntimeInvisibleAnnotations,
      Collection<Annotation> expectedRuntimeVisibleAnnotations)
      throws IOException, ClassHierarchyException, InvalidClassFileException {
    IClass classUnderTest = cha.lookupClass(typeUnderTest);
    Assert.assertNotNull(typeUnderTest.toString() + " not found", classUnderTest);
    Assert.assertTrue(classUnderTest instanceof ShrikeClass);
    ShrikeClass shrikeClassUnderTest = (ShrikeClass) classUnderTest;

    Collection<Annotation> runtimeInvisibleAnnotations =
        shrikeClassUnderTest.getRuntimeInvisibleAnnotations();
    assertEqualCollections(expectedRuntimeInvisibleAnnotations, runtimeInvisibleAnnotations);

    Collection<Annotation> runtimeVisibleAnnotations =
        shrikeClassUnderTest.getRuntimeVisibleAnnotations();
    assertEqualCollections(expectedRuntimeVisibleAnnotations, runtimeVisibleAnnotations);
  }
Ejemplo n.º 12
0
  public InstanceKey getInstanceKeyForAllocation(CGNode node, NewSiteReference allocation) {
    if (allocation == null) {
      throw new IllegalArgumentException("allocation is null");
    }
    TypeReference t = allocation.getDeclaredType();
    IClass C = cha.lookupClass(t);

    if (C != null && isInteresting(C)) {
      if (smushMany()) {
        if (exceedsSmushLimit(C, node)) {
          return smushed.getInstanceKeyForAllocation(node, allocation);
        } else {
          return siteBased.getInstanceKeyForAllocation(node, allocation);
        }
      } else {
        return siteBased.getInstanceKeyForAllocation(node, allocation);
      }
    } else {
      return classBased.getInstanceKeyForAllocation(node, allocation);
    }
  }
Ejemplo n.º 13
0
  public static void addJ2EEBypassLogic(
      AnalysisOptions options,
      AnalysisScope scope,
      DeploymentMetaData dmd,
      IClassHierarchy cha,
      ReceiverTypeInferenceCache typeInference) {

    if (cha == null) {
      throw new IllegalArgumentException("cha is null");
    }
    MethodTargetSelector ms =
        new J2EEMethodTargetSelector(
            scope, options.getMethodTargetSelector(), dmd, cha, typeInference);
    options.setSelector(ms);

    ClassTargetSelector cs =
        new J2EEClassTargetSelector(
            options.getClassTargetSelector(),
            dmd,
            cha,
            cha.getLoader(scope.getLoader(Atom.findOrCreateUnicodeAtom("Synthetic"))));
    options.setSelector(cs);
  }
Ejemplo n.º 14
0
    /**
     * Add any exceptional edges generated by the last instruction in a basic block.
     *
     * @param last the last instruction in a basic block.
     */
    protected void addExceptionalEdges(IInstruction last) {
      IClassHierarchy cha = getMethod().getClassHierarchy();
      if (last.isPEI()) {
        Collection<TypeReference> exceptionTypes = null;
        boolean goToAllHandlers = false;

        ExceptionHandler[] hs = getExceptionHandlers();
        if (last instanceof ThrowInstruction) {
          // this class does not have the type information needed
          // to determine what the athrow throws. So, add an
          // edge to all reachable handlers. Better information can
          // be obtained later with SSA type propagation.
          // TODO: consider pruning to only the exception types that
          // this method either catches or allocates, since these are
          // the only types that can flow to an athrow.
          goToAllHandlers = true;
        } else {
          if (hs != null && hs.length > 0) {
            IClassLoader loader = getMethod().getDeclaringClass().getClassLoader();
            BytecodeLanguage l = (BytecodeLanguage) loader.getLanguage();
            exceptionTypes = l.getImplicitExceptionTypes(last);
            if (last instanceof IInvokeInstruction) {
              IInvokeInstruction call = (IInvokeInstruction) last;
              exceptionTypes = HashSetFactory.make(exceptionTypes);
              MethodReference target =
                  MethodReference.findOrCreate(
                      l,
                      loader.getReference(),
                      call.getClassType(),
                      call.getMethodName(),
                      call.getMethodSignature());
              try {
                exceptionTypes.addAll(l.inferInvokeExceptions(target, cha));
              } catch (InvalidClassFileException e) {
                e.printStackTrace();
                Assertions.UNREACHABLE();
              }
            }
          }
        }

        if (hs != null && hs.length > 0) {
          // found a handler for this PEI

          // create a mutable copy
          if (!goToAllHandlers) {
            exceptionTypes = HashSetFactory.make(exceptionTypes);
          }

          // this var gets set to false if goToAllHandlers is true but some enclosing exception
          // handler catches all
          // exceptions.  in such a case, we need not add an exceptional edge to the method exit
          boolean needEdgeToExitForAllHandlers = true;
          for (int j = 0; j < hs.length; j++) {
            if (DEBUG) {
              System.err.println(" handler " + hs[j]);
            }
            BasicBlock b = getBlockForInstruction(hs[j].getHandler());
            if (DEBUG) {
              System.err.println(" target " + b);
            }
            if (goToAllHandlers) {
              // add an edge to the catch block.
              if (DEBUG) {
                System.err.println(" gotoAllHandlers " + b);
              }
              addExceptionalEdgeTo(b);
              // if the handler catches all exceptions, we don't need to add an edge to the exit or
              // any other handlers
              if (hs[j].getCatchClass() == null) {
                needEdgeToExitForAllHandlers = false;
                break;
              }
            } else {
              TypeReference caughtException = null;
              if (hs[j].getCatchClass() != null) {
                ClassLoaderReference loader =
                    ShrikeCFG.this.getMethod().getDeclaringClass().getReference().getClassLoader();
                caughtException = ShrikeUtil.makeTypeReference(loader, hs[j].getCatchClass());
                if (DEBUG) {
                  System.err.println(" caughtException " + caughtException);
                }
                IClass caughtClass = cha.lookupClass(caughtException);
                if (caughtClass == null) {
                  // conservatively add the edge, and raise a warning
                  addExceptionalEdgeTo(b);
                  Warnings.add(FailedExceptionResolutionWarning.create(caughtException));
                  // null out caughtException, to avoid attempting to process it
                  caughtException = null;
                }
              } else {
                if (DEBUG) {
                  System.err.println(" catchClass() == null");
                }
                // hs[j].getCatchClass() == null.
                // this means that the handler catches all exceptions.
                // add the edge and null out all types
                if (!exceptionTypes.isEmpty()) {
                  addExceptionalEdgeTo(b);
                  exceptionTypes.clear();
                  caughtException = null;
                }
              }
              if (caughtException != null) {
                IClass caughtClass = cha.lookupClass(caughtException);
                // the set "caught" should be the set of exceptions that MUST
                // have been caught by the handlers in scope
                ArrayList<TypeReference> caught =
                    new ArrayList<TypeReference>(exceptionTypes.size());
                // check if we should add an edge to the catch block.
                for (TypeReference t : exceptionTypes) {
                  if (t != null) {
                    IClass klass = cha.lookupClass(t);
                    if (klass == null) {
                      Warnings.add(FailedExceptionResolutionWarning.create(caughtException));
                      // conservatively add an edge
                      addExceptionalEdgeTo(b);
                    } else {
                      boolean subtype1 = cha.isSubclassOf(klass, caughtClass);
                      if (subtype1 || cha.isSubclassOf(caughtClass, klass)) {
                        // add the edge and null out the type from the array
                        addExceptionalEdgeTo(b);
                        if (subtype1) {
                          caught.add(t);
                        }
                      }
                    }
                  }
                }
                exceptionTypes.removeAll(caught);
              }
            }
          }
          // if needed, add an edge to the exit block.
          if ((exceptionTypes == null && needEdgeToExitForAllHandlers)
              || (exceptionTypes != null && !exceptionTypes.isEmpty())) {
            BasicBlock exit = exit();
            addExceptionalEdgeTo(exit);
          }
        } else {
          // found no handler for this PEI ... link to the exit block.
          BasicBlock exit = exit();
          addExceptionalEdgeTo(exit);
        }
      }
    }
Ejemplo n.º 15
0
 /*
  * @see com.ibm.wala.classLoader.IClass#getMethod(com.ibm.wala.classLoader.Selector)
  */
 @Override
 public IMethod getMethod(Selector sig) {
   return cha.lookupClass(getClassLoader().getLanguage().getRootType()).getMethod(sig);
 }
Ejemplo n.º 16
0
  // public static void addBypassLogic(AnalysisOptions options, AnalysisScope
  // scope, ClassLoader cl, String xmlFile,
  // IClassHierarchy cha) throws IllegalArgumentException {
  public static void addBypassLogic(
      AnalysisOptions options,
      AnalysisScope scope,
      InputStream xmlIStream,
      IClassHierarchy cha,
      MethodSummary extraSummary)
      throws IllegalArgumentException {

    if (scope == null) {
      throw new IllegalArgumentException("scope is null");
    }
    if (options == null) {
      throw new IllegalArgumentException("options is null");
    }
    // if (cl == null) {
    // throw new IllegalArgumentException("cl is null");
    // }
    if (cha == null) {
      throw new IllegalArgumentException("cha cannot be null");
    }

    InputStream s = null;
    try {
      Set<TypeReference> summaryClasses = HashSetFactory.make();
      Map<MethodReference, MethodSummary> summaries = HashMapFactory.make();

      if (null != xmlIStream) {
        XMLMethodSummaryReader newSummaryXML = loadMethodSummaries(scope, xmlIStream);
        summaryClasses.addAll(newSummaryXML.getAllocatableClasses());
        for (MethodSummary summary : newSummaryXML.getSummaries().values()) {
          logger.trace(
              "SSA instructions for summary of {}:\n{}",
              summary.getMethod().getSignature().toString(),
              Arrays.toString(summary.getStatements()));
        }
        summaries.putAll(newSummaryXML.getSummaries());
      }
      logger.debug("loaded " + summaries.size() + " new summaries");
      // for (MethodReference mr : summaries.keySet()) {
      // logger.debug("summary loaded for: "+mr.getSignature());
      // }

      s =
          new FileProvider()
              .getInputStreamFromClassLoader(
                  pathToSpec + File.separator + methodSpec,
                  AndroidAnalysisContext.class.getClassLoader());

      XMLMethodSummaryReader nativeSummaries = loadMethodSummaries(scope, s);

      logger.debug("loaded " + nativeSummaries.getSummaries().size() + " native summaries");

      summaries.putAll(nativeSummaries.getSummaries());
      summaryClasses.addAll(nativeSummaries.getAllocatableClasses());
      if (extraSummary != null) {
        summaries.put((MethodReference) extraSummary.getMethod(), extraSummary);
      }

      MethodTargetSelector ms =
          new BypassMethodTargetSelector(
              options.getMethodTargetSelector(), summaries,
              nativeSummaries.getIgnoredPackages(), cha);
      options.setSelector(ms);

      ClassTargetSelector cs =
          new BypassClassTargetSelector(
              options.getClassTargetSelector(),
              summaryClasses,
              cha,
              cha.getLoader(scope.getLoader(Atom.findOrCreateUnicodeAtom("Synthetic"))));
      options.setSelector(cs);
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } finally {
      if (null != s) {
        try {
          s.close();
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }
Ejemplo n.º 17
0
 /**
  * Generate a {@link MethodSummary} which is the "standard" representation of a method that does
  * nothing. Subclasses may override this method to implement alternative semantics concerning what
  * "do nothing" means.
  */
 public MethodSummary generateNoOp(MethodReference m, boolean isStatic) {
   Language l = cha.resolveMethod(m).getDeclaringClass().getClassLoader().getLanguage();
   return new NoOpSummary(l, m, isStatic);
 }
  private IMethod makeFunctionConstructor(
      IR callerIR, SSAAbstractInvokeInstruction callStmt, IClass cls, int nargs) {
    SymbolTable ST = callerIR.getSymbolTable();

    if (nargs == 0) {
      return makeFunctionConstructor(cls, cls);
    } else if (nargs == 1) {
      if (ST.isStringConstant(callStmt.getUse(1))) {
        TypeReference ref =
            TypeReference.findOrCreate(
                JavaScriptTypes.jsLoader,
                TypeName.string2TypeName((String) ST.getStringValue(callStmt.getUse(1))));

        if (DEBUG) {
          System.err.println(
              ("ctor type name is " + (String) ST.getStringValue(callStmt.getUse(1))));
        }

        IClass cls2 = cha.lookupClass(ref);
        if (cls2 != null) {
          return makeFunctionConstructor(cls, cls2);
        }
      }

      return makeFunctionConstructor(cls, cls);
    } else {
      assert nargs > 1;
      JavaScriptLoader cl = (JavaScriptLoader) cha.getLoader(JavaScriptTypes.jsLoader);

      for (int i = 1; i < callStmt.getNumberOfUses(); i++)
        if (!ST.isStringConstant(callStmt.getUse(i))) return makeFunctionConstructor(cls, cls);

      StringBuffer fun = new StringBuffer("function _fromctor (");
      for (int j = 1; j < callStmt.getNumberOfUses() - 1; j++) {
        if (j != 1) fun.append(",");
        fun.append(ST.getStringValue(callStmt.getUse(j)));
      }

      fun.append(") {");
      fun.append(ST.getStringValue(callStmt.getUse(callStmt.getNumberOfUses() - 1)));
      fun.append("}");

      try {
        String fileName = "ctor$" + ++ctorCount;
        File f = new File(System.getProperty("java.io.tmpdir") + File.separator + fileName);
        FileWriter FO = new FileWriter(f);
        FO.write(fun.toString());
        FO.close();

        Set<String> fnNames =
            JSCallGraphUtil.loadAdditionalFile(cha, cl, fileName, f.toURI().toURL());
        IClass fcls = null;
        for (String nm : fnNames) {
          if (nm.endsWith("_fromctor")) {
            fcls = cl.lookupClass(nm, cha);
          }
        }

        assert fcls != null : "cannot find class for " + fileName + " in " + f;

        f.delete();

        if (DEBUG) System.err.println(("looking for ctor " + ctorCount + " and got " + fcls));

        if (fcls != null) return makeFunctionConstructor(cls, fcls);

      } catch (IOException e) {

      }

      return makeFunctionConstructor(cls, cls);
    }
  }
Ejemplo n.º 19
0
 public static boolean isRemoteProcedure(MethodReference method, IClassHierarchy cha) {
   return isCapsuleInterface(cha.lookupClass(method.getDeclaringClass()));
 }