/** Display this instruction as an expression, for diagnostics */
 public void display(int level, PrintStream out, Configuration config) {
   out.println(ExpressionTool.indent(level) + "attribute ");
   out.println(
       ExpressionTool.indent(level + 1)
           + "name "
           + (config == null ? nameCode + "" : config.getNamePool().getDisplayName(nameCode)));
   super.display(level + 1, out, config);
 }
  /**
   * Set the expression defining the value of the attribute. If this is a constant, and if
   * validation against a schema type was requested, the validation is done immediately.
   *
   * @param select The expression defining the content of the attribute
   * @param config
   * @throws StaticError if the expression is a constant, and validation is requested, and the
   *     constant doesn't match the required type.
   */
  public void setSelect(Expression select, Configuration config) throws StaticError {
    super.setSelect(select, config);

    // Attempt early validation if possible
    if (select instanceof AtomicValue && schemaType != null && !schemaType.isNamespaceSensitive()) {
      CharSequence value = ((AtomicValue) select).getStringValueCS();
      XPathException err =
          schemaType.validateContent(
              value, DummyNamespaceResolver.getInstance(), config.getNameChecker());
      if (err != null) {
        StaticError se =
            new StaticError(
                "Attribute value "
                    + Err.wrap(value, Err.VALUE)
                    + " does not the match the required type "
                    + schemaType.getDescription()
                    + ". "
                    + err.getMessage());
        se.setErrorCode("XTTE1540");
        throw se;
      }
    }

    // If value is fixed, test whether there are any special characters that might need to be
    // escaped when the time comes for serialization
    if (select instanceof StringValue) {
      boolean special = false;
      CharSequence val = ((StringValue) select).getStringValueCS();
      for (int k = 0; k < val.length(); k++) {
        char c = val.charAt(k);
        if ((int) c < 33 || (int) c > 126 || c == '<' || c == '>' || c == '&' || c == '\"') {
          special = true;
          break;
        }
      }
      if (!special) {
        this.options |= ReceiverOptions.NO_SPECIAL_CHARS;
      }
    }

    // If attribute name is xml:id, add whitespace normalization
    if ((nameCode & NamePool.FP_MASK) == StandardNames.XML_ID) {
      Expression[] args = {select};
      FunctionCall fn =
          SystemFunction.makeSystemFunction("normalize-space", 1, config.getNamePool());
      fn.setArguments(args);
      select = fn;
      super.setSelect(select, config);
    }
  }
Esempio n. 3
0
  /** Create a StandaloneContext using a specific NamePool */
  public StandaloneContext(Configuration config) {
    this.config = config;
    namePool = config.getNamePool();
    stackFrameMap = config.makeSlotManager();
    clearNamespaces();

    // Set up a default function library. This can be overridden using setFunctionLibrary()

    FunctionLibraryList lib = new FunctionLibraryList();
    lib.addFunctionLibrary(new SystemFunctionLibrary(SystemFunctionLibrary.XPATH_ONLY));
    lib.addFunctionLibrary(getConfiguration().getVendorFunctionLibrary());
    lib.addFunctionLibrary(new ConstructorFunctionLibrary(getConfiguration()));
    if (config.isAllowExternalFunctions()) {
      xpathFunctionLibrary = new XPathFunctionLibrary();
      lib.addFunctionLibrary(xpathFunctionLibrary);
      lib.addFunctionLibrary(new JavaExtensionLibrary(getConfiguration()));
    }
    functionLibrary = lib;
  }