Beispiel #1
0
  /**
   * Compile the function into a UserFunction object, which treats the function body as a single
   * XPath expression. This involves recursively translating xsl:variable declarations into let
   * expressions, withe the action part of the let expression containing the rest of the function
   * body. The UserFunction that is created will be linked from all calls to this function, so
   * nothing else needs to be done with the result. If there are no calls to it, the compiled
   * function will be garbage-collected away.
   *
   * @param exec the Executable
   * @param decl this xsl:function declaration
   * @throws XPathException if a failure occurs
   */
  private void compileAsExpression(Executable exec, Declaration decl) throws XPathException {
    Expression exp = compileSequenceConstructor(exec, decl, iterateAxis(Axis.CHILD), false);
    if (exp == null) {
      exp = Literal.makeEmptySequence();
    } else {
      ExpressionVisitor visitor = makeExpressionVisitor();
      exp = exp.simplify(visitor);
    }

    if (exec.getConfiguration().isCompileWithTracing()) {
      TraceExpression trace = new TraceExpression(exp);
      trace.setConstructType(StandardNames.XSL_FUNCTION);
      trace.setNamespaceResolver(getNamespaceResolver());
      trace.setObjectName(getObjectName());
      exp = trace;
    }

    UserFunction fn = exec.getConfiguration().newUserFunction(memoFunction);
    fn.setHostLanguage(Configuration.XSLT);
    fn.setBody(exp);
    fn.setFunctionName(getObjectName());
    setParameterDefinitions(fn);
    fn.setResultType(getResultType());
    fn.setLineNumber(getLineNumber());
    fn.setSystemId(getSystemId());
    fn.setStackFrameMap(stackFrameMap);
    fn.setExecutable(exec);
    compiledFunction = fn;
    fixupInstruction(fn);

    if (memoFunction && !fn.isMemoFunction()) {
      compileWarning(
          "Memo functions are not available in Saxon-HE: saxon:memo-function attribute ignored",
          SaxonErrorCode.SXWN9011);
    }
  }
  /**
   * @param result
   * @param expr
   */
  private static void serialize(
      FastStringBuffer result, Expression expr, Map reversePrefixMapping) {
    if (expr instanceof Assignation) {
      // XXX not yet supported
    } else if (expr instanceof AxisExpression) {
      AxisExpression axisExpression = (AxisExpression) expr;
      result.append(Axis.axisName[axisExpression.getAxis()]);
      result.append("::");

      final NodeTest nodeTest = axisExpression.getNodeTest();
      if (nodeTest == null) {
        result.append("node()");
      } else {
        result.append(fixPreFixes(nodeTest.toString(), reversePrefixMapping));
      }
    } else if (expr instanceof BinaryExpression) {
      BinaryExpression binaryExpression = (BinaryExpression) expr;
      result.append('(');
      serialize(result, binaryExpression.getOperands()[0], reversePrefixMapping);
      result.append(Token.tokens[binaryExpression.getOperator()]);
      serialize(result, binaryExpression.getOperands()[1], reversePrefixMapping);
      result.append(')');
    } else if (expr instanceof CompareToIntegerConstant) {
      CompareToIntegerConstant compareToIntegerConstant = (CompareToIntegerConstant) expr;
      result.append('(');
      serialize(result, compareToIntegerConstant.getOperand(), reversePrefixMapping);
      result.append(Token.tokens[compareToIntegerConstant.getComparisonOperator()]);
      result.append(Long.toString(compareToIntegerConstant.getComparand()));
      result.append(')');
    } else if (expr instanceof ConditionalSorter) {
      // XXX not yet supported
    } else if (expr instanceof ContextItemExpression) {
      result.append('.');
    } else if (expr instanceof ErrorExpression) {
      // Error do nothing
    } else if (expr instanceof FilterExpression) {
      FilterExpression filterExpression = (FilterExpression) expr;
      result.append('(');
      serialize(result, filterExpression.getControllingExpression(), reversePrefixMapping);
      result.append('[');
      serialize(result, filterExpression.getFilter(), reversePrefixMapping);
      result.append("])");

    } else if (expr instanceof FunctionCall) {
      FunctionCall functionCall = (FunctionCall) expr;
      StructuredQName name = functionCall.getFunctionName();
      if (name.getPrefix() != null && name.getPrefix().length() > 0) {
        result.append(name.getPrefix());
        result.append(":");
      }
      result.append(name.getLocalName());
      result.append("(");

      Iterator iter = functionCall.iterateSubExpressions();
      boolean first = true;
      while (iter.hasNext()) {
        result.append(first ? "" : ", ");
        SaxonXPathExpressionSerializer.serialize(
            result, (Expression) iter.next(), reversePrefixMapping);
        first = false;
      }

      result.append(")");
    } else if (expr instanceof Instruction) {
      // This is not an XPath expression
    } else if (expr instanceof IntegerRangeTest) {
      // XXX not yet supported
    } else if (expr instanceof IsLastExpression) {
      result.append("position() eq last()");
    } else if (expr instanceof Literal) {
      Literal literal = (Literal) expr;
      result.append(literal.getValue().toString());
    } else if (expr instanceof NumberInstruction) {
      // This is not an XPath expression
    } else if (expr instanceof PathExpression) {
      PathExpression pathExpression = (PathExpression) expr;
      result.append('(');
      serialize(result, pathExpression.getControllingExpression(), reversePrefixMapping);
      result.append('/');
      serialize(result, pathExpression.getControlledExpression(), reversePrefixMapping);
      result.append(')');
    } else if (expr instanceof PatternMatchExpression) {
      // XXX not yet supported
    } else if (expr instanceof PatternSponsor) {
      // XXX not yet supported
    } else if (expr instanceof SimpleContentConstructor) {
      // This is not an XPath expression
    } else if (expr instanceof SimpleExpression) {
      // This is not an XPath expression
    }
    /*
        else if (expr instanceof SimpleMappingExpression) {
    	    // XXX not yet supported
    	}
    */
    else if (expr instanceof ParentNodeExpression) {
      result.append("..");
    } else if (expr instanceof RootExpression) {
      // do nothing
    } else if (expr instanceof SortExpression) {
      // XXX not yet supported
    } else if (expr instanceof TailExpression) {
      // XXX not yet supported
    } else if (expr instanceof TupleExpression) {
      // This is not an XPath expression
    } else if (expr instanceof TupleSorter) {
      // This is not an XPath expression
    } else if (expr instanceof UnaryExpression) {
      UnaryExpression unaryExpression = (UnaryExpression) expr;
      serialize(
          result,
          unaryExpression.getBaseExpression(),
          reversePrefixMapping); // Not sure if this is correct in all cases
    } else if (expr instanceof VariableReference) {
      VariableReference variableReference = (VariableReference) expr;
      String d = variableReference.getDisplayName();
      result.append("$");
      result.append(d == null ? "$" : d);
    }
  }
Beispiel #3
0
 public Expression compile(Executable exec, Declaration decl) throws XPathException {
   return new ValueOf(Literal.makeLiteral(value), disable, false);
 }