Example #1
0
 /**
  * Registers an attribute and gives it a type so that it can be mapped to DOM attribute types at
  * run-time.
  */
 public int registerAttribute(QName name) {
   Integer code = (Integer) _attributes.get(name.toString());
   if (code == null) {
     code = new Integer(_nextGType++);
     _attributes.put(name.toString(), code);
     final String uri = name.getNamespace();
     final String local = "@" + name.getLocalPart();
     if ((uri != null) && (!uri.equals(""))) _namesIndex.addElement(uri + ":" + local);
     else _namesIndex.addElement(local);
     if (name.getLocalPart().equals("*")) {
       registerNamespace(name.getNamespace());
     }
   }
   return code.intValue();
 }
  /**
   * Type check a call to a standard function. Insert CastExprs when needed. If as a result of the
   * insertion of a CastExpr a type check error is thrown, then catch it and re-throw it with a new
   * "this".
   */
  public Type typeCheckStandard(SymbolTable stable) throws TypeCheckError {
    _fname.clearNamespace(); // HACK!!!

    final int n = _arguments.size();
    final Vector argsType = typeCheckArgs(stable);
    final MethodType args = new MethodType(Type.Void, argsType);
    final MethodType ptype = lookupPrimop(stable, _fname.getLocalPart(), args);

    if (ptype != null) {
      for (int i = 0; i < n; i++) {
        final Type argType = (Type) ptype.argsType().elementAt(i);
        final Expression exp = (Expression) _arguments.elementAt(i);
        if (!argType.identicalTo(exp.getType())) {
          try {
            _arguments.setElementAt(new CastExpr(exp, argType), i);
          } catch (TypeCheckError e) {
            throw new TypeCheckError(this); // invalid conversion
          }
        }
      }
      _chosenMethodType = ptype;
      return _type = ptype.resultType();
    }
    throw new TypeCheckError(this);
  }
Example #3
0
 /**
  * Registers an element and gives it a type so that it can be mapped to DOM element types at
  * run-time.
  */
 public int registerElement(QName name) {
   // Register element (full QName)
   Integer code = (Integer) _elements.get(name.toString());
   if (code == null) {
     _elements.put(name.toString(), code = new Integer(_nextGType++));
     _namesIndex.addElement(name.toString());
   }
   if (name.getLocalPart().equals("*")) {
     registerNamespace(name.getNamespace());
   }
   return code.intValue();
 }
  /** Return the signature of the current method */
  private String getMethodSignature(Vector argsType) {
    final StringBuffer buf = new StringBuffer(_className);
    buf.append('.').append(_fname.getLocalPart()).append('(');

    int nArgs = argsType.size();
    for (int i = 0; i < nArgs; i++) {
      final Type intType = (Type) argsType.elementAt(i);
      buf.append(intType.toString());
      if (i < nArgs - 1) buf.append(", ");
    }

    buf.append(')');
    return buf.toString();
  }
Example #5
0
  /**
   * Registers a namespace prefix and gives it a type so that it can be mapped to DOM namespace
   * types at run-time.
   */
  public int registerNamespacePrefix(QName name) {

    Integer code = (Integer) _namespacePrefixes.get(name.toString());
    if (code == null) {
      code = new Integer(_nextGType++);
      _namespacePrefixes.put(name.toString(), code);
      final String uri = name.getNamespace();
      if ((uri != null) && (!uri.equals(""))) {
        // namespace::ext2:ped2 will be made empty in TypedNamespaceIterator
        _namesIndex.addElement("?");
      } else {
        _namesIndex.addElement("?" + name.getLocalPart());
      }
    }
    return code.intValue();
  }
  /**
   * Returns a vector with all methods named <code>_fname</code> after stripping its namespace or
   * <code>null</code> if no such methods exist.
   */
  private Vector findMethods() {

    Vector result = null;
    final String namespace = _fname.getNamespace();

    if (_className != null && _className.length() > 0) {
      final int nArgs = _arguments.size();
      try {
        if (_clazz == null) {
          _clazz =
              ObjectFactory.findProviderClass(_className, ObjectFactory.findClassLoader(), true);

          if (_clazz == null) {
            final ErrorMsg msg = new ErrorMsg(ErrorMsg.CLASS_NOT_FOUND_ERR, _className);
            getParser().reportError(Constants.ERROR, msg);
          }
        }

        final String methodName = _fname.getLocalPart();
        final Method[] methods = _clazz.getMethods();

        for (int i = 0; i < methods.length; i++) {
          final int mods = methods[i].getModifiers();
          // Is it public and same number of args ?
          if (Modifier.isPublic(mods)
              && methods[i].getName().equals(methodName)
              && methods[i].getParameterTypes().length == nArgs) {
            if (result == null) {
              result = new Vector();
            }
            result.addElement(methods[i]);
          }
        }
      } catch (ClassNotFoundException e) {
        final ErrorMsg msg = new ErrorMsg(ErrorMsg.CLASS_NOT_FOUND_ERR, _className);
        getParser().reportError(Constants.ERROR, msg);
      }
    }
    return result;
  }
  /**
   * Translate a function call. The compiled code will leave the function's return value on the
   * JVM's stack.
   */
  public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
    final int n = argumentCount();
    final ConstantPoolGen cpg = classGen.getConstantPool();
    final InstructionList il = methodGen.getInstructionList();
    final boolean isSecureProcessing = classGen.getParser().getXSLTC().isSecureProcessing();
    int index;

    // Translate calls to methods in the BasisLibrary
    if (isStandard() || isExtension()) {
      for (int i = 0; i < n; i++) {
        final Expression exp = argument(i);
        exp.translate(classGen, methodGen);
        exp.startIterator(classGen, methodGen);
      }

      // append "F" to the function's name
      final String name = _fname.toString().replace('-', '_') + "F";
      String args = Constants.EMPTYSTRING;

      // Special precautions for some method calls
      if (name.equals("sumF")) {
        args = DOM_INTF_SIG;
        il.append(methodGen.loadDOM());
      } else if (name.equals("normalize_spaceF")) {
        if (_chosenMethodType.toSignature(args).equals("()Ljava/lang/String;")) {
          args = "I" + DOM_INTF_SIG;
          il.append(methodGen.loadContextNode());
          il.append(methodGen.loadDOM());
        }
      }

      // Invoke the method in the basis library
      index = cpg.addMethodref(BASIS_LIBRARY_CLASS, name, _chosenMethodType.toSignature(args));
      il.append(new INVOKESTATIC(index));
    }
    // Add call to BasisLibrary.unresolved_externalF() to generate
    // run-time error message for unsupported external functions
    else if (unresolvedExternal) {
      index =
          cpg.addMethodref(BASIS_LIBRARY_CLASS, "unresolved_externalF", "(Ljava/lang/String;)V");
      il.append(new PUSH(cpg, _fname.toString()));
      il.append(new INVOKESTATIC(index));
    } else if (_isExtConstructor) {
      if (isSecureProcessing) translateUnallowedExtension(cpg, il);

      final String clazz = _chosenConstructor.getDeclaringClass().getName();
      Class[] paramTypes = _chosenConstructor.getParameterTypes();
      LocalVariableGen[] paramTemp = new LocalVariableGen[n];

      // Backwards branches are prohibited if an uninitialized object is
      // on the stack by section 4.9.4 of the JVM Specification, 2nd Ed.
      // We don't know whether this code might contain backwards branches
      // so we mustn't create the new object until after we've created
      // the suspect arguments to its constructor.  Instead we calculate
      // the values of the arguments to the constructor first, store them
      // in temporary variables, create the object and reload the
      // arguments from the temporaries to avoid the problem.

      for (int i = 0; i < n; i++) {
        final Expression exp = argument(i);
        Type expType = exp.getType();
        exp.translate(classGen, methodGen);
        // Convert the argument to its Java type
        exp.startIterator(classGen, methodGen);
        expType.translateTo(classGen, methodGen, paramTypes[i]);
        paramTemp[i] =
            methodGen.addLocalVariable(
                "function_call_tmp" + i, expType.toJCType(), il.getEnd(), null);
        il.append(expType.STORE(paramTemp[i].getIndex()));
      }

      il.append(new NEW(cpg.addClass(_className)));
      il.append(InstructionConstants.DUP);

      for (int i = 0; i < n; i++) {
        final Expression arg = argument(i);
        il.append(arg.getType().LOAD(paramTemp[i].getIndex()));
      }

      final StringBuffer buffer = new StringBuffer();
      buffer.append('(');
      for (int i = 0; i < paramTypes.length; i++) {
        buffer.append(getSignature(paramTypes[i]));
      }
      buffer.append(')');
      buffer.append("V");

      index = cpg.addMethodref(clazz, "<init>", buffer.toString());
      il.append(new INVOKESPECIAL(index));

      // Convert the return type back to our internal type
      (Type.Object).translateFrom(classGen, methodGen, _chosenConstructor.getDeclaringClass());

    }
    // Invoke function calls that are handled in separate classes
    else {
      if (isSecureProcessing) translateUnallowedExtension(cpg, il);

      final String clazz = _chosenMethod.getDeclaringClass().getName();
      Class[] paramTypes = _chosenMethod.getParameterTypes();

      // Push "this" if it is an instance method
      if (_thisArgument != null) {
        _thisArgument.translate(classGen, methodGen);
      }

      for (int i = 0; i < n; i++) {
        final Expression exp = argument(i);
        exp.translate(classGen, methodGen);
        // Convert the argument to its Java type
        exp.startIterator(classGen, methodGen);
        exp.getType().translateTo(classGen, methodGen, paramTypes[i]);
      }

      final StringBuffer buffer = new StringBuffer();
      buffer.append('(');
      for (int i = 0; i < paramTypes.length; i++) {
        buffer.append(getSignature(paramTypes[i]));
      }
      buffer.append(')');
      buffer.append(getSignature(_chosenMethod.getReturnType()));

      if (_thisArgument != null && _clazz.isInterface()) {
        index = cpg.addInterfaceMethodref(clazz, _fname.getLocalPart(), buffer.toString());
        il.append(new INVOKEINTERFACE(index, n + 1));
      } else {
        index = cpg.addMethodref(clazz, _fname.getLocalPart(), buffer.toString());
        il.append(
            _thisArgument != null
                ? (InvokeInstruction) new INVOKEVIRTUAL(index)
                : (InvokeInstruction) new INVOKESTATIC(index));
      }

      // Convert the return type back to our internal type
      _type.translateFrom(classGen, methodGen, _chosenMethod.getReturnType());
    }
  }
  /**
   * Type check a call to an external (Java) method. The method must be static an public, and a
   * legal type conversion must exist for all its arguments and its return type. Every method of
   * name <code>_fname</code> is inspected as a possible candidate.
   */
  public Type typeCheckExternal(SymbolTable stable) throws TypeCheckError {
    int nArgs = _arguments.size();
    final String name = _fname.getLocalPart();

    // check if function is a contructor 'new'
    if (_fname.getLocalPart().equals("new")) {
      return typeCheckConstructor(stable);
    }
    // check if we are calling an instance method
    else {
      boolean hasThisArgument = false;

      if (nArgs == 0) _isStatic = true;

      if (!_isStatic) {
        if (_namespace_format == NAMESPACE_FORMAT_JAVA
            || _namespace_format == NAMESPACE_FORMAT_PACKAGE) hasThisArgument = true;

        Expression firstArg = (Expression) _arguments.elementAt(0);
        Type firstArgType = (Type) firstArg.typeCheck(stable);

        if (_namespace_format == NAMESPACE_FORMAT_CLASS
            && firstArgType instanceof ObjectType
            && _clazz != null
            && _clazz.isAssignableFrom(((ObjectType) firstArgType).getJavaClass()))
          hasThisArgument = true;

        if (hasThisArgument) {
          _thisArgument = (Expression) _arguments.elementAt(0);
          _arguments.remove(0);
          nArgs--;
          if (firstArgType instanceof ObjectType) {
            _className = ((ObjectType) firstArgType).getJavaClassName();
          } else throw new TypeCheckError(ErrorMsg.NO_JAVA_FUNCT_THIS_REF, name);
        }
      } else if (_className.length() == 0) {
        /*
         * Warn user if external function could not be resolved.
         * Warning will _NOT_ be issued is the call is properly
         * wrapped in an <xsl:if> or <xsl:when> element. For details
         * see If.parserContents() and When.parserContents()
         */
        final Parser parser = getParser();
        if (parser != null) {
          reportWarning(this, parser, ErrorMsg.FUNCTION_RESOLVE_ERR, _fname.toString());
        }
        unresolvedExternal = true;
        return _type = Type.Int; // use "Int" as "unknown"
      }
    }

    final Vector methods = findMethods();

    if (methods == null) {
      // Method not found in this class
      throw new TypeCheckError(ErrorMsg.METHOD_NOT_FOUND_ERR, _className + "." + name);
    }

    Class extType = null;
    final int nMethods = methods.size();
    final Vector argsType = typeCheckArgs(stable);

    // Try all methods to identify the best fit
    int bestMethodDistance = Integer.MAX_VALUE;
    _type = null; // reset internal type
    for (int j, i = 0; i < nMethods; i++) {
      // Check if all paramteters to this method can be converted
      final Method method = (Method) methods.elementAt(i);
      final Class[] paramTypes = method.getParameterTypes();

      int currMethodDistance = 0;
      for (j = 0; j < nArgs; j++) {
        // Convert from internal (translet) type to external (Java) type
        extType = paramTypes[j];
        final Type intType = (Type) argsType.elementAt(j);
        Object match = _internal2Java.maps(intType, extType);
        if (match != null) {
          currMethodDistance += ((JavaType) match).distance;
        } else {
          // no mapping available
          //
          // Allow a Reference type to match any external (Java) type at
          // the moment. The real type checking is performed at runtime.
          if (intType instanceof ReferenceType) {
            currMethodDistance += 1;
          } else if (intType instanceof ObjectType) {
            ObjectType object = (ObjectType) intType;
            if (extType.getName().equals(object.getJavaClassName())) currMethodDistance += 0;
            else if (extType.isAssignableFrom(object.getJavaClass())) currMethodDistance += 1;
            else {
              currMethodDistance = Integer.MAX_VALUE;
              break;
            }
          } else {
            currMethodDistance = Integer.MAX_VALUE;
            break;
          }
        }
      }

      if (j == nArgs) {
        // Check if the return type can be converted
        extType = method.getReturnType();

        _type = (Type) _java2Internal.get(extType);
        if (_type == null) {
          _type = Type.newObjectType(extType);
        }

        // Use this method if all parameters & return type match
        if (_type != null && currMethodDistance < bestMethodDistance) {
          _chosenMethod = method;
          bestMethodDistance = currMethodDistance;
        }
      }
    }

    // It is an error if the chosen method is an instance menthod but we don't
    // have a this argument.
    if (_chosenMethod != null
        && _thisArgument == null
        && !Modifier.isStatic(_chosenMethod.getModifiers())) {
      throw new TypeCheckError(ErrorMsg.NO_JAVA_FUNCT_THIS_REF, getMethodSignature(argsType));
    }

    if (_type != null) {
      if (_type == Type.NodeSet) {
        getXSLTC().setMultiDocument(true);
      }
      return _type;
    }

    throw new TypeCheckError(ErrorMsg.ARGUMENT_CONVERSION_ERR, getMethodSignature(argsType));
  }
  /**
   * Type check a function call. Since different type conversions apply, type checking is different
   * for standard and external (Java) functions.
   */
  public Type typeCheck(SymbolTable stable) throws TypeCheckError {
    if (_type != null) return _type;

    final String namespace = _fname.getNamespace();
    String local = _fname.getLocalPart();

    if (isExtension()) {
      _fname = new QName(null, null, local);
      return typeCheckStandard(stable);
    } else if (isStandard()) {
      return typeCheckStandard(stable);
    }
    // Handle extension functions (they all have a namespace)
    else {
      try {
        _className = getClassNameFromUri(namespace);

        final int pos = local.lastIndexOf('.');
        if (pos > 0) {
          _isStatic = true;
          if (_className != null && _className.length() > 0) {
            _namespace_format = NAMESPACE_FORMAT_PACKAGE;
            _className = _className + "." + local.substring(0, pos);
          } else {
            _namespace_format = NAMESPACE_FORMAT_JAVA;
            _className = local.substring(0, pos);
          }

          _fname = new QName(namespace, null, local.substring(pos + 1));
        } else {
          if (_className != null && _className.length() > 0) {
            try {
              _clazz =
                  ObjectFactory.findProviderClass(
                      _className, ObjectFactory.findClassLoader(), true);
              _namespace_format = NAMESPACE_FORMAT_CLASS;
            } catch (ClassNotFoundException e) {
              _namespace_format = NAMESPACE_FORMAT_PACKAGE;
            }
          } else _namespace_format = NAMESPACE_FORMAT_JAVA;

          if (local.indexOf('-') > 0) {
            local = replaceDash(local);
          }

          String extFunction = (String) _extensionFunctionTable.get(namespace + ":" + local);
          if (extFunction != null) {
            _fname = new QName(null, null, extFunction);
            return typeCheckStandard(stable);
          } else _fname = new QName(namespace, null, local);
        }

        return typeCheckExternal(stable);
      } catch (TypeCheckError e) {
        ErrorMsg errorMsg = e.getErrorMsg();
        if (errorMsg == null) {
          final String name = _fname.getLocalPart();
          errorMsg = new ErrorMsg(ErrorMsg.METHOD_NOT_FOUND_ERR, name);
        }
        getParser().reportError(ERROR, errorMsg);
        return _type = Type.Void;
      }
    }
  }