Ejemplo n.º 1
0
 private static void printDebug(String msg, MemberBox member, Object[] args) {
   if (debug) {
     StringBuffer sb = new StringBuffer();
     sb.append(" ----- ");
     sb.append(msg);
     sb.append(member.getDeclaringClass().getName());
     sb.append('.');
     if (member.isMethod()) {
       sb.append(member.getName());
     }
     sb.append(JavaMembers.liveConnectSignature(member.argTypes));
     sb.append(" for arguments (");
     sb.append(scriptSignature(args));
     sb.append(')');
     System.out.println(sb);
   }
 }
Ejemplo n.º 2
0
  /**
   * Find the index of the correct function to call given the set of methods or constructors and the
   * arguments. If no function can be found to call, return -1.
   */
  static int findFunction(Context cx, MemberBox[] methodsOrCtors, Object[] args) {
    if (methodsOrCtors.length == 0) {
      return -1;
    } else if (methodsOrCtors.length == 1) {
      MemberBox member = methodsOrCtors[0];
      Class<?>[] argTypes = member.argTypes;
      int alength = argTypes.length;

      if (member.vararg) {
        alength--;
        if (alength > args.length) {
          return -1;
        }
      } else {
        if (alength != args.length) {
          return -1;
        }
      }
      for (int j = 0; j != alength; ++j) {
        if (!NativeJavaObject.canConvert(args[j], argTypes[j])) {
          if (debug) printDebug("Rejecting (args can't convert) ", member, args);
          return -1;
        }
      }
      if (debug) printDebug("Found ", member, args);
      return 0;
    }

    int firstBestFit = -1;
    int[] extraBestFits = null;
    int extraBestFitsCount = 0;

    search:
    for (int i = 0; i < methodsOrCtors.length; i++) {
      MemberBox member = methodsOrCtors[i];
      Class<?>[] argTypes = member.argTypes;
      int alength = argTypes.length;
      if (member.vararg) {
        alength--;
        if (alength > args.length) {
          continue search;
        }
      } else {
        if (alength != args.length) {
          continue search;
        }
      }
      for (int j = 0; j < alength; j++) {
        if (!NativeJavaObject.canConvert(args[j], argTypes[j])) {
          if (debug) printDebug("Rejecting (args can't convert) ", member, args);
          continue search;
        }
      }
      if (firstBestFit < 0) {
        if (debug) printDebug("Found first applicable ", member, args);
        firstBestFit = i;
      } else {
        // Compare with all currently fit methods.
        // The loop starts from -1 denoting firstBestFit and proceed
        // until extraBestFitsCount to avoid extraBestFits allocation
        // in the most common case of no ambiguity
        int betterCount = 0; // number of times member was prefered over
        // best fits
        int worseCount = 0; // number of times best fits were prefered
        // over member
        for (int j = -1; j != extraBestFitsCount; ++j) {
          int bestFitIndex;
          if (j == -1) {
            bestFitIndex = firstBestFit;
          } else {
            bestFitIndex = extraBestFits[j];
          }
          MemberBox bestFit = methodsOrCtors[bestFitIndex];
          if (cx.hasFeature(Context.FEATURE_ENHANCED_JAVA_ACCESS)
              && (bestFit.member().getModifiers() & Modifier.PUBLIC)
                  != (member.member().getModifiers() & Modifier.PUBLIC)) {
            // When FEATURE_ENHANCED_JAVA_ACCESS gives us access
            // to non-public members, continue to prefer public
            // methods in overloading
            if ((bestFit.member().getModifiers() & Modifier.PUBLIC) == 0) ++betterCount;
            else ++worseCount;
          } else {
            int preference =
                preferSignature(args, argTypes, member.vararg, bestFit.argTypes, bestFit.vararg);
            if (preference == PREFERENCE_AMBIGUOUS) {
              break;
            } else if (preference == PREFERENCE_FIRST_ARG) {
              ++betterCount;
            } else if (preference == PREFERENCE_SECOND_ARG) {
              ++worseCount;
            } else {
              if (preference != PREFERENCE_EQUAL) Kit.codeBug();
              // This should not happen in theory
              // but on some JVMs, Class.getMethods will return all
              // static methods of the class hierarchy, even if
              // a derived class's parameters match exactly.
              // We want to call the derived class's method.
              if (bestFit.isStatic()
                  && bestFit.getDeclaringClass().isAssignableFrom(member.getDeclaringClass())) {
                // On some JVMs, Class.getMethods will return all
                // static methods of the class hierarchy, even if
                // a derived class's parameters match exactly.
                // We want to call the derived class's method.
                if (debug) printDebug("Substituting (overridden static)", member, args);
                if (j == -1) {
                  firstBestFit = i;
                } else {
                  extraBestFits[j] = i;
                }
              } else {
                if (debug) printDebug("Ignoring same signature member ", member, args);
              }
              continue search;
            }
          }
        }
        if (betterCount == 1 + extraBestFitsCount) {
          // member was prefered over all best fits
          if (debug) printDebug("New first applicable ", member, args);
          firstBestFit = i;
          extraBestFitsCount = 0;
        } else if (worseCount == 1 + extraBestFitsCount) {
          // all best fits were prefered over member, ignore it
          if (debug) printDebug("Rejecting (all current bests better) ", member, args);
        } else {
          // some ambiguity was present, add member to best fit set
          if (debug) printDebug("Added to best fit set ", member, args);
          if (extraBestFits == null) {
            // Allocate maximum possible array
            extraBestFits = new int[methodsOrCtors.length - 1];
          }
          extraBestFits[extraBestFitsCount] = i;
          ++extraBestFitsCount;
        }
      }
    }

    if (firstBestFit < 0) {
      // Nothing was found
      return -1;
    } else if (extraBestFitsCount == 0) {
      // single best fit
      return firstBestFit;
    }

    // report remaining ambiguity
    StringBuffer buf = new StringBuffer();
    for (int j = -1; j != extraBestFitsCount; ++j) {
      int bestFitIndex;
      if (j == -1) {
        bestFitIndex = firstBestFit;
      } else {
        bestFitIndex = extraBestFits[j];
      }
      buf.append("\n    ");
      buf.append(methodsOrCtors[bestFitIndex].toJavaDeclaration());
    }

    MemberBox firstFitMember = methodsOrCtors[firstBestFit];
    String memberName = firstFitMember.getName();
    String memberClass = firstFitMember.getDeclaringClass().getName();

    if (methodsOrCtors[0].isMethod()) {
      throw Context.reportRuntimeError3(
          "msg.constructor.ambiguous", memberName, scriptSignature(args), buf.toString());
    } else {
      throw Context.reportRuntimeError4(
          "msg.method.ambiguous", memberClass, memberName, scriptSignature(args), buf.toString());
    }
  }
Ejemplo n.º 3
0
  @Override
  public Object call(Context cx, Scriptable scope, Scriptable thisObj, Object[] args) {
    // Find a method that matches the types given.
    if (methods.length == 0) {
      throw new RuntimeException("No methods defined for call");
    }

    int index = findFunction(cx, methods, args);
    if (index < 0) {
      Class<?> c = methods[0].method().getDeclaringClass();
      String sig = c.getName() + '.' + getFunctionName() + '(' + scriptSignature(args) + ')';
      throw Context.reportRuntimeError1("msg.java.no_such_method", sig);
    }

    MemberBox meth = methods[index];
    Class<?>[] argTypes = meth.argTypes;

    if (meth.vararg) {
      // marshall the explicit parameters
      Object[] newArgs = new Object[argTypes.length];
      for (int i = 0; i < argTypes.length - 1; i++) {
        newArgs[i] = Context.jsToJava(args[i], argTypes[i]);
      }

      Object varArgs;

      // Handle special situation where a single variable parameter
      // is given and it is a Java or ECMA array or is null.
      if (args.length == argTypes.length
          && (args[args.length - 1] == null
              || args[args.length - 1] instanceof NativeArray
              || args[args.length - 1] instanceof NativeJavaArray)) {
        // convert the ECMA array into a native array
        varArgs = Context.jsToJava(args[args.length - 1], argTypes[argTypes.length - 1]);
      } else {
        // marshall the variable parameters
        Class<?> componentType = argTypes[argTypes.length - 1].getComponentType();
        varArgs = Array.newInstance(componentType, args.length - argTypes.length + 1);
        for (int i = 0; i < Array.getLength(varArgs); i++) {
          Object value = Context.jsToJava(args[argTypes.length - 1 + i], componentType);
          Array.set(varArgs, i, value);
        }
      }

      // add varargs
      newArgs[argTypes.length - 1] = varArgs;
      // replace the original args with the new one
      args = newArgs;
    } else {
      // First, we marshall the args.
      Object[] origArgs = args;
      for (int i = 0; i < args.length; i++) {
        Object arg = args[i];
        Object coerced = Context.jsToJava(arg, argTypes[i]);
        if (coerced != arg) {
          if (origArgs == args) {
            args = args.clone();
          }
          args[i] = coerced;
        }
      }
    }
    Object javaObject;
    if (meth.isStatic()) {
      javaObject = null; // don't need an object
    } else {
      Scriptable o = thisObj;
      Class<?> c = meth.getDeclaringClass();
      for (; ; ) {
        if (o == null) {
          throw Context.reportRuntimeError3(
              "msg.nonjava.method",
              getFunctionName(),
              ScriptRuntime.toString(thisObj),
              c.getName());
        }
        if (o instanceof Wrapper) {
          javaObject = ((Wrapper) o).unwrap();
          if (c.isInstance(javaObject)) {
            break;
          }
        }
        o = o.getPrototype();
      }
    }
    if (debug) {
      printDebug("Calling ", meth, args);
    }

    Object retval = meth.invoke(javaObject, args);
    Class<?> staticType = meth.method().getReturnType();

    if (debug) {
      Class<?> actualType = (retval == null) ? null : retval.getClass();
      System.err.println(
          " ----- Returned " + retval + " actual = " + actualType + " expect = " + staticType);
    }

    Object wrapped =
        cx.getWrapFactory()
            .wrap(
                cx, scope,
                retval, staticType);
    if (debug) {
      Class<?> actualType = (wrapped == null) ? null : wrapped.getClass();
      System.err.println(" ----- Wrapped as " + wrapped + " class = " + actualType);
    }

    if (wrapped == null && staticType == Void.TYPE) {
      wrapped = Undefined.instance;
    }
    return wrapped;
  }