示例#1
0
  /**
   * @return One of <tt>JAVA_*_TYPE</tt> constants to indicate desired type or {@link
   *     #JAVA_UNSUPPORTED_TYPE} if the convertion is not possible
   */
  public static int getTypeTag(Class type) {
    if (type == ScriptRuntime.StringClass) {
      return JAVA_STRING_TYPE;
    }
    if ((type == ScriptRuntime.IntegerClass) || (type == Integer.TYPE)) {
      return JAVA_INT_TYPE;
    }
    if ((type == ScriptRuntime.BooleanClass) || (type == Boolean.TYPE)) {
      return JAVA_BOOLEAN_TYPE;
    }
    if ((type == ScriptRuntime.DoubleClass) || (type == Double.TYPE)) {
      return JAVA_DOUBLE_TYPE;
    }
    if (ScriptRuntime.ScriptableClass.isAssignableFrom(type)) {
      return JAVA_SCRIPTABLE_TYPE;
    }
    if (type == ScriptRuntime.ObjectClass) {
      return JAVA_OBJECT_TYPE;
    }

    // Note that the long type is not supported; see the javadoc for
    // the constructor for this class

    return JAVA_UNSUPPORTED_TYPE;
  }
示例#2
0
  /**
   * Create a JavaScript function object from a Java method.
   *
   * <p>The <code>member</code> argument must be either a java.lang.reflect.Method
   * or a java.lang.reflect.Constructor and must match one of two forms.<p>
   *
   * The first form is a member with zero or more parameters
   * of the following types: Object, String, boolean, Scriptable,
   * int, or double. The Long type is not supported
   * because the double representation of a long (which is the
   * EMCA-mandated storage type for Numbers) may lose precision.
   * If the member is a Method, the return value must be void or one
   * of the types allowed for parameters.<p>
   *
   * The runtime will perform appropriate conversions based
   * upon the type of the parameter. A parameter type of
   * Object specifies that no conversions are to be done. A parameter
   * of type String will use Context.toString to convert arguments.
   * Similarly, parameters of type double, boolean, and Scriptable
   * will cause Context.toNumber, Context.toBoolean, and
   * Context.toObject, respectively, to be called.<p>
   *
   * If the method is not static, the Java 'this' value will
   * correspond to the JavaScript 'this' value. Any attempt
   * to call the function with a 'this' value that is not
   * of the right Java type will result in an error.<p>
   *
   * The second form is the variable arguments (or "varargs")
   * form. If the FunctionObject will be used as a constructor,
   * the member must have the following parameters
   * <pre>
   *      (Context cx, Object[] args, Function ctorObj,
   *       boolean inNewExpr)</pre>
   * and if it is a Method, be static and return an Object result.<p>
   *
   * Otherwise, if the FunctionObject will <i>not</i> be used to define a
   * constructor, the member must be a static Method with parameters
   *      (Context cx, Scriptable thisObj, Object[] args,
   *       Function funObj) </pre>
   * <pre>
   * and an Object result.<p>
   *
   * When the function varargs form is called as part of a function call,
   * the <code>args</code> parameter contains the
   * arguments, with <code>thisObj</code>
   * set to the JavaScript 'this' value. <code>funObj</code>
   * is the function object for the invoked function.<p>
   *
   * When the constructor varargs form is called or invoked while evaluating
   * a <code>new</code> expression, <code>args</code> contains the
   * arguments, <code>ctorObj</code> refers to this FunctionObject, and
   * <code>inNewExpr</code> is true if and only if  a <code>new</code>
   * expression caused the call. This supports defining a function that
   * has different behavior when called as a constructor than when
   * invoked as a normal function call. (For example, the Boolean
   * constructor, when called as a function,
   * will convert to boolean rather than creating a new object.)<p>
   *
   * @param name the name of the function
   * @param methodOrConstructor a java.lang.reflect.Method or a java.lang.reflect.Constructor
   *                            that defines the object
   * @param scope enclosing scope of function
   * @see gov.nbcs.rp.common.js.javascript.Scriptable
   */
  public FunctionObject(String name, Member methodOrConstructor, Scriptable scope) {
    if (methodOrConstructor instanceof Constructor) {
      member = new MemberBox((Constructor) methodOrConstructor);
      isStatic = true; // well, doesn't take a 'this'
    } else {
      member = new MemberBox((Method) methodOrConstructor);
      isStatic = member.isStatic();
    }
    String methodName = member.getName();
    this.functionName = name;
    Class[] types = member.argTypes;
    int arity = types.length;
    if ((arity == 4) && (types[1].isArray() || types[2].isArray())) {
      // Either variable args or an error.
      if (types[1].isArray()) {
        if (!isStatic
            || (types[0] != ScriptRuntime.ContextClass)
            || (types[1].getComponentType() != ScriptRuntime.ObjectClass)
            || (types[2] != ScriptRuntime.FunctionClass)
            || (types[3] != Boolean.TYPE)) {
          throw Context.reportRuntimeError1("msg.varargs.ctor", methodName);
        }
        parmsLength = VARARGS_CTOR;
      } else {
        if (!isStatic
            || (types[0] != ScriptRuntime.ContextClass)
            || (types[1] != ScriptRuntime.ScriptableClass)
            || (types[2].getComponentType() != ScriptRuntime.ObjectClass)
            || (types[3] != ScriptRuntime.FunctionClass)) {
          throw Context.reportRuntimeError1("msg.varargs.fun", methodName);
        }
        parmsLength = VARARGS_METHOD;
      }
    } else {
      parmsLength = arity;
      if (arity > 0) {
        typeTags = new byte[arity];
        for (int i = 0; i != arity; ++i) {
          int tag = getTypeTag(types[i]);
          if (tag == JAVA_UNSUPPORTED_TYPE) {
            throw Context.reportRuntimeError2("msg.bad.parms", types[i].getName(), methodName);
          }
          typeTags[i] = (byte) tag;
        }
      }
    }

    if (member.isMethod()) {
      Method method = member.method();
      Class returnType = method.getReturnType();
      if (returnType == Void.TYPE) {
        hasVoidReturn = true;
      } else {
        returnTypeTag = getTypeTag(returnType);
      }
    } else {
      Class ctorType = member.getDeclaringClass();
      if (!ScriptRuntime.ScriptableClass.isAssignableFrom(ctorType)) {
        throw Context.reportRuntimeError1("msg.bad.ctor.return", ctorType.getName());
      }
    }

    ScriptRuntime.setFunctionProtoAndParent(this, scope);
  }