Examples of org.pdf4j.saxon.trans.XPathException

org.pdf4j.saxon.trans.XPathException
XPathException is used to indicate an error in an XPath expression. It will generally be either a StaticError or a DynamicError; ValidationExceptions (arising from schema validation) form a third category

            TailCall tc = applyTemplates(iter, thisMode, params, tunnels, c2, backwardsCompatible, getLocationId());
            while (tc != null) {
                tc = tc.processLeavingTail();
            }
        } catch (StackOverflowError e) {
            XPathException err = new XPathException("Too many nested apply-templates calls. The stylesheet may be looping.");
            err.setErrorCode(SaxonErrorCode.SXLM0001);
            err.setLocator(this);
            err.setXPathContext(context);
            throw err;
        }
        return null;


    }

View Full Code Here


                String hrefValue = EscapeURI.iriToUri(href.evaluateAsString(context)).toString();
                try {
                    result = resolver.resolve(hrefValue, base);
                } catch (Exception err) {
                    throw new XPathException("Exception thrown by OutputURIResolver", err);
                }
                if (result == null) {
                    resolver = StandardOutputResolver.getInstance();
                    result = resolver.resolve(hrefValue, base);
                }
            } catch (TransformerException e) {
                throw XPathException.makeXPathException(e);
            }
        }


        if (controller.getDocumentPool().find(result.getSystemId()) != null) {
            XPathException err = new XPathException("Cannot write to a URI that has already been read: " +
                    result.getSystemId());
            err.setXPathContext(context);
            err.setErrorCode("XTRE1500");
            throw err;
        }


        if (!controller.checkUniqueOutputDestination(result.getSystemId())) {
            XPathException err = new XPathException("Cannot write more than one result document to the same URI: " +
                    result.getSystemId());
            err.setXPathContext(context);
            err.setErrorCode("XTDE1490");
            throw err;
        } else {
            controller.addUnavailableOutputDestination(result.getSystemId());
            controller.setThereHasBeenAnExplicitResultDocument();
        }


        boolean timing = controller.getConfiguration().isTiming();
        if (timing) {
            String dest = result.getSystemId();
            if (dest == null) {
                if (result instanceof StreamResult) {
                    dest = "anonymous output stream";
                } else if (result instanceof SAXResult) {
                    dest = "SAX2 ContentHandler";
                } else if (result instanceof DOMResult) {
                    dest = "DOM tree";
                } else {
                    dest = result.getClass().getName();
                }
            }
            System.err.println("Writing to " + dest);
        }


        Properties computedGlobalProps = globalProperties;


        if (formatExpression != null) { 
            // format was an AVT and now needs to be computed
            CharSequence format = formatExpression.evaluateAsString(context);
            String[] parts;
            try {
                parts = controller.getConfiguration().getNameChecker().getQNameParts(format);
            } catch (QNameException e) {
                XPathException err = new XPathException("The requested output format " + Err.wrap(format) + " is not a valid QName");
                err.setErrorCode("XTDE1460");
                err.setXPathContext(context);
                throw err;
            }
            String uri = nsResolver.getURIForPrefix(parts[0], false);
            if (uri == null) {
                XPathException err = new XPathException("The namespace prefix in the format name " + format + " is undeclared");
                err.setErrorCode("XTDE1460");
                err.setXPathContext(context);
                throw err;
            }
            StructuredQName qName = new StructuredQName(parts[0], uri, parts[1]);
            computedGlobalProps = getExecutable().getOutputProperties(qName);
            if (computedGlobalProps == null) {
                XPathException err = new XPathException("There is no xsl:output format named " + format);
                err.setErrorCode("XTDE1460");
                err.setXPathContext(context);
                throw err;
            }


        }


        // Now combine the properties specified on xsl:result-document with those specified on xsl:output


        Properties computedLocalProps = new Properties(computedGlobalProps);


        // First handle the properties with fixed values on xsl:result-document


        final NameChecker checker = config.getNameChecker();
        for (Iterator citer=localProperties.keySet().iterator(); citer.hasNext();) {
            String key = (String)citer.next();
            String[] parts = NamePool.parseClarkName(key);
            try {
                setSerializationProperty(computedLocalProps, parts[0], parts[1],
                        localProperties.getProperty(key), nsResolver, true, checker);
            } catch (XPathException e) {
                e.maybeSetLocation(this);
                throw e;
            }
        }


        // Now add the properties that were specified as AVTs


        if (serializationAttributes.size() > 0) {
            for (IntIterator it = serializationAttributes.keyIterator(); it.hasNext();) {
                int key = it.next();
                Expression exp = (Expression) serializationAttributes.get(key);
                String value = exp.evaluateAsString(context).toString();
                String lname = namePool.getLocalName(key);
                String uri = namePool.getURI(key);
                try {
                    setSerializationProperty(computedLocalProps, uri, lname, value, nsResolver, false, checker);
                } catch (XPathException e) {
                    e.maybeSetLocation(this);
                    e.maybeSetContext(context);
                    if (NamespaceConstant.SAXON.equals(e.getErrorCodeNamespace()) &&
                            "warning".equals(e.getErrorCodeLocalPart())) {
                        try {
                            context.getController().getErrorListener().warning(e);
                        } catch (TransformerException e2) {
                            throw XPathException.makeXPathException(e2);
                        }
                    } else {
                        throw e;
                    }
                }
            }
        }


        // Handle properties specified using a dynamic xsl:output element
        // (Used when the instruction is generated from a saxon:result-document extension function call)


        if (dynamicOutputElement != null) {
            Item outputArg = dynamicOutputElement.evaluateItem(context);
            if (!(outputArg instanceof NodeInfo &&
                    ((NodeInfo)outputArg).getNodeKind() == Type.ELEMENT &&
                    ((NodeInfo)outputArg).getFingerprint() == StandardNames.XSL_OUTPUT)) {
                XPathException err = new XPathException(
                        "The third argument of saxon:result-document must be an <xsl:output> element");
                err.setLocator(this);
                err.setXPathContext(context);
                throw err;
            }
            Properties dynamicProperties = new Properties();
            Serialize.processXslOutputElement((NodeInfo)outputArg, dynamicProperties, context);
            for (Iterator it = dynamicProperties.keySet().iterator(); it.hasNext();) {

View Full Code Here

                    String[] parts;
                    try {
                        parts = checker.getQNameParts(value);
                        String prefix = parts[0];
                        if (prefix.length() == 0) {
                            XPathException err = new XPathException("method must be xml, html, xhtml, or text, or a prefixed name");
                            err.setErrorCode("XTSE1570");
                            err.setIsStaticError(true);
                            throw err;
                        } else {
                            String muri = nsResolver.getURIForPrefix(prefix, false);
                            if (muri==null) {
                                XPathException err = new XPathException("Namespace prefix '" + prefix + "' has not been declared");
                                err.setErrorCode("XTSE1570");
                                err.setIsStaticError(true);
                                throw err;
                            }
                            details.setProperty(OutputKeys.METHOD, '{' + muri + '}' + parts[1]);
                        }
                    } catch (QNameException e) {
                        XPathException err = new XPathException("Invalid method name. " + e.getMessage());
                        err.setErrorCode("XTSE1570");
                        err.setIsStaticError(true);
                        throw err;
                    }
                }
            } else


            if (lname.equals(StandardNames.OUTPUT_VERSION) || lname.equals(StandardNames.VERSION)) {
                details.setProperty(OutputKeys.VERSION, value);
            } else


            if (lname.equals(StandardNames.BYTE_ORDER_MARK)) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(SaxonOutputKeys.BYTE_ORDER_MARK, value);
                } else {
                    XPathException err = new XPathException("byte-order-mark value must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.INDENT)) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(OutputKeys.INDENT, value);
                } else {
                    XPathException err = new XPathException("indent must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.ENCODING)) {
                details.setProperty(OutputKeys.ENCODING, value);
            } else


            if (lname.equals(StandardNames.MEDIA_TYPE)) {
                details.setProperty(OutputKeys.MEDIA_TYPE, value);
            } else


            if (lname.equals(StandardNames.DOCTYPE_SYSTEM)) {
                details.setProperty(OutputKeys.DOCTYPE_SYSTEM, value);
            } else


            if (lname.equals(StandardNames.DOCTYPE_PUBLIC)) {
                details.setProperty(OutputKeys.DOCTYPE_PUBLIC, value);
            } else


            if (lname.equals(StandardNames.OMIT_XML_DECLARATION)) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(OutputKeys.OMIT_XML_DECLARATION, value);
                } else {
                    XPathException err = new XPathException("omit-xml-declaration attribute must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.STANDALONE)) {
                if (prevalidated || value.equals("yes") || value.equals("no") || value.equals("omit")) {
                    details.setProperty(OutputKeys.STANDALONE, value);
                } else {
                    XPathException err = new XPathException("standalone attribute must be 'yes' or 'no' or 'omit'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.CDATA_SECTION_ELEMENTS)) {
                String existing = details.getProperty(OutputKeys.CDATA_SECTION_ELEMENTS);
                if (existing == null) {
                    existing = "";
                }
                String s = parseListOfElementNames(value, nsResolver, prevalidated, checker, "XTDE0030");
                details.setProperty(OutputKeys.CDATA_SECTION_ELEMENTS, existing + s);


            } else


            if (lname.equals(StandardNames.USE_CHARACTER_MAPS)) {
                // The use-character-maps attribute is always turned into a Clark-format name at compile time
                String existing = details.getProperty(SaxonOutputKeys.USE_CHARACTER_MAPS);
                if (existing == null) {
                    existing = "";
                }
                details.setProperty(SaxonOutputKeys.USE_CHARACTER_MAPS, existing + value);
            } else




            if (lname.equals(StandardNames.UNDECLARE_PREFIXES)) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(SaxonOutputKeys.UNDECLARE_PREFIXES, value);
                } else {
                    XPathException err = new XPathException("undeclare-namespaces value must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.INCLUDE_CONTENT_TYPE)) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(SaxonOutputKeys.INCLUDE_CONTENT_TYPE, value);
                } else {
                    XPathException err = new XPathException("include-content-type attribute must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.ESCAPE_URI_ATTRIBUTES) || lname.equals("escape-uri-attibutes")) {
                        // misspelling was in Saxon 9.0 and previous releases
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(SaxonOutputKeys.ESCAPE_URI_ATTRIBUTES, value);
                } else {
                    XPathException err = new XPathException("escape-uri-attributes value must be 'yes' or 'no'");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else


            if (lname.equals(StandardNames.NORMALIZATION_FORM)) {
                if (Name11Checker.getInstance().isValidNmtoken(value)) {
//                if (prevalidated || value.equals("NFC") || value.equals("NFD") ||
//                        value.equals("NFKC") || value.equals("NFKD")) {
                    details.setProperty(SaxonOutputKeys.NORMALIZATION_FORM, value);
                } else if (value.equals("none")) {
                    // do nothing
                } else {
                    XPathException err = new XPathException("normalization-form must be a valid NMTOKEN");
                    err.setErrorCode("XTDE0030");
                    throw err;
                }
            } else {
                // Normally detected statically, but not with saxon:serialize
                XPathException err = new XPathException("Unknown serialization property " + lname);
                err.setErrorCode("XTDE0030");
                throw err;
            }


        } else if (uri.equals(NamespaceConstant.SAXON)) {


            if (lname.equals("character-representation")) {
                details.setProperty(SaxonOutputKeys.CHARACTER_REPRESENTATION, value);
            } else


            if (lname.equals("indent-spaces")) {
                try {
                    Integer.parseInt(value);
                    details.setProperty(OutputKeys.INDENT, "yes");
                    details.setProperty(SaxonOutputKeys.INDENT_SPACES, value);
                } catch (NumberFormatException err) {
                    XPathException e = new XPathException("saxon:indent-spaces must be an integer");
                    e.setErrorCode(NamespaceConstant.SAXON, SaxonErrorCode.SXWN9002);
                    throw e;
                }
            } else


            if (lname.equals("suppress-indentation")) {
                String existing = details.getProperty(SaxonOutputKeys.SUPPRESS_INDENTATION);
                if (existing == null) {
                    existing = "";
                }
                String s = parseListOfElementNames(value, nsResolver, prevalidated, checker, "XTDE0030");
                details.setProperty(SaxonOutputKeys.SUPPRESS_INDENTATION, existing + s);
            } else


            if (lname.equals("double-space")) {
                String existing = details.getProperty(SaxonOutputKeys.DOUBLE_SPACE);
                if (existing == null) {
                    existing = "";
                }
                String s = parseListOfElementNames(value, nsResolver, prevalidated, checker, "XTDE0030");
                details.setProperty(SaxonOutputKeys.SUPPRESS_INDENTATION, existing + s);
            } else


            if (lname.equals("next-in-chain")) {
                XPathException e = new XPathException("saxon:next-in-chain value cannot be specified dynamically");
                e.setErrorCode(NamespaceConstant.SAXON, SaxonErrorCode.SXWN9004);
                throw e;
            } else


            if (lname.equals("require-well-formed")) {
                if (prevalidated || value.equals("yes") || value.equals("no")) {
                    details.setProperty(SaxonOutputKeys.REQUIRE_WELL_FORMED, value);
                } else {
                    XPathException e = new XPathException("saxon:require-well-formed value must be 'yes' or 'no'");
                    e.setErrorCode(NamespaceConstant.SAXON, SaxonErrorCode.SXWN9003);
                    throw e;
                }
            }


        } else {

View Full Code Here

            } else {
                try {
                    String[] parts = checker.getQNameParts(displayname);
                    String muri = nsResolver.getURIForPrefix(parts[0], true);
                    if (muri==null) {
                        XPathException err = new XPathException("Namespace prefix '" + parts[0] + "' has not been declared");
                        err.setErrorCode(errorCode);
                        throw err;
                    }
                    s += " {" + muri + '}' + parts[1];
                } catch (QNameException err) {
                    XPathException e = new XPathException("Invalid element name. " + err.getMessage());
                    e.setErrorCode(errorCode);
                    throw e;
                }
            }
        }
        return s;

View Full Code Here

        int hh;
        while ((hh = data.indexOf("?>")) >= 0) {
            if (isXSLT()) {
                data = data.substring(0, hh + 1) + ' ' + data.substring(hh + 1);
            } else {
                XPathException err = new XPathException("Invalid characters (?>) in processing instruction", this);
                err.setErrorCode("XQDY0026");
                err.setXPathContext(context);
                throw dynamicError(this, err, context);
                //context.getController().recoverableError(err);
            }
        }
        data = Whitespace.removeLeadingWhitespace(data).toString();

View Full Code Here

        return expandedName;
    }


    private void checkName(String expandedName, XPathContext context) throws XPathException {
        if (!(context.getConfiguration().getNameChecker().isValidNCName(expandedName))) {
            XPathException e = new XPathException("Processing instruction name " + Err.wrap(expandedName) + " is not a valid NCName");
            e.setXPathContext(context);
            e.setErrorCode((isXSLT() ? "XTDE0890" : "XQDY0041"));
            throw dynamicError(this, e, context);
        }
        if (expandedName.equalsIgnoreCase("xml")) {
            XPathException e = new XPathException("Processing instructions cannot be named 'xml' in any combination of upper/lower case");
            e.setXPathContext(context);
            e.setErrorCode((isXSLT() ? "XTDE0890" : "XQDY0064"));
            throw dynamicError(this, e, context);
        }
    }

View Full Code Here

        DocumentInfo dtdRoot = (DocumentInfo)builder.getCurrentRoot();


        SequenceIterator children = dtdRoot.iterateAxis(Axis.CHILD);
        NodeInfo docType = (NodeInfo)children.next();
        if (docType == null || !("doctype".equals(docType.getLocalPart()))) {
            XPathException e = new XPathException("saxon:doctype instruction must contain dtd:doctype");
            e.setXPathContext(context);
            throw e;
        }
        String name = Navigator.getAttributeValue(docType, "", "name");
        String system = Navigator.getAttributeValue(docType, "", "system");
        String publicid = Navigator.getAttributeValue(docType, "", "public");


        if (name == null) {
            XPathException e = new XPathException("dtd:doctype must have a name attribute");
            e.setXPathContext(context);
            throw e;
        }


        write(out, "<!DOCTYPE " + name + ' ');
        if (system != null) {
            if (publicid != null) {
                write(out, "PUBLIC \"" + publicid + "\" \"" + system + '\"');
            } else {
                write(out, "SYSTEM \"" + system + '\"');
            }
        }


        boolean openSquare = false;
        children = docType.iterateAxis(Axis.CHILD);


        NodeInfo child = (NodeInfo)children.next();
        if (child != null) {
            write(out, " [");
            openSquare = true;
        }


        while (child != null) {
            String localname = child.getLocalPart();


            if ("element".equals(localname)) {
                String elname = Navigator.getAttributeValue(child, "", "name");
                String content = Navigator.getAttributeValue(child, "", "content");
                if (elname == null) {
                    XPathException e = new XPathException("dtd:element must have a name attribute");
                    e.setXPathContext(context);
                    throw e;
                }
                if (content == null) {
                    XPathException e = new XPathException("dtd:element must have a content attribute");
                    e.setXPathContext(context);
                    throw e;
                }
                write(out, "\n  <!ELEMENT " + elname + ' ' + content + '>');


            } else if (localname.equals("attlist")) {
                String elname = Navigator.getAttributeValue(child, "", "element");
                if (elname == null) {
                    XPathException e = new XPathException("dtd:attlist must have an attribute named 'element'");
                    e.setXPathContext(context);
                    throw e;
                }
                write(out, "\n  <!ATTLIST " + elname + ' ');


                SequenceIterator attributes = child.iterateAxis(Axis.CHILD);
                while (true) {
                    NodeInfo attDef = (NodeInfo)attributes.next();
                    if (attDef == null) {
                        break;
                    }


                    if ("attribute".equals(attDef.getLocalPart())) {


                        String atname = Navigator.getAttributeValue(attDef, "", "name");
                        String type = Navigator.getAttributeValue(attDef, "", "type");
                        String value = Navigator.getAttributeValue(attDef, "", "value");
                        if (atname == null) {
                            XPathException e = new XPathException("dtd:attribute must have a name attribute");
                            e.setXPathContext(context);
                            throw e;
                        }
                        if (type == null) {
                            XPathException e = new XPathException("dtd:attribute must have a type attribute");
                            e.setXPathContext(context);
                            throw e;
                        }
                        if (value == null) {
                            XPathException e = new XPathException("dtd:attribute must have a value attribute");
                            e.setXPathContext(context);
                            throw e;
                        }
                        write(out, "\n    " + atname + ' ' + type + ' ' + value);
                    } else {
                        XPathException e = new XPathException("Unrecognized element within dtd:attlist");
                        e.setXPathContext(context);
                        throw e;
                    }
                }
                write(out, ">");


            } else if (localname.equals("entity")) {


                String entname = Navigator.getAttributeValue(child, "", "name");
                String parameter = Navigator.getAttributeValue(child, "", "parameter");
                String esystem = Navigator.getAttributeValue(child, "", "system");
                String epublicid = Navigator.getAttributeValue(child, "", "public");
                String notation = Navigator.getAttributeValue(child, "", "notation");


                if (entname == null) {
                    XPathException e = new XPathException("dtd:entity must have a name attribute");
                    e.setXPathContext(context);
                    throw e;
                }


                // we could do a lot more checking now...


                write(out, "\n  <!ENTITY ");
                if ("yes".equals(parameter)) {
                    write(out, "% ");
                }
                write(out, entname + ' ');
                if (esystem != null) {
                    if (epublicid != null) {
                        write(out, "PUBLIC \"" + epublicid + "\" \"" + esystem + "\" ");
                    } else {
                        write(out, "SYSTEM \"" + esystem + "\" ");
                    }
                }
                if (notation != null) {
                    write(out, "NDATA " + notation + ' ');
                }


                SequenceIterator contents = child.iterateAxis(Axis.CHILD);
                while (true) {
                    NodeInfo content = (NodeInfo)contents.next();
                    if (content == null) {
                        break;
                    }
                    content.copy(out, NodeInfo.NO_NAMESPACES, false, locationId);
                }
                write(out, ">");


            } else if (localname.equals("notation")) {
                String notname = Navigator.getAttributeValue(child, "", "name");
                String nsystem = Navigator.getAttributeValue(child, "", "system");
                String npublicid = Navigator.getAttributeValue(child, "", "public");
                if (notname == null) {
                    XPathException e = new XPathException("dtd:notation must have a name attribute");
                    e.setXPathContext(context);
                    throw e;
                }
                if ((nsystem == null) && (npublicid == null)) {
                    XPathException e = new XPathException("dtd:notation must have a system attribute or a public attribute");
                    e.setXPathContext(context);
                    throw e;
                }
                write(out, "\n  <!NOTATION " + notname);
                if (npublicid != null) {
                    write(out, " PUBLIC \"" + npublicid + "\" ");
                    if (nsystem != null) {
                        write(out, '\"' + nsystem + "\" ");
                    }
                } else {
                    write(out, " SYSTEM \"" + nsystem + "\" ");
                }
                write(out, ">");
            } else {
                XPathException e = new XPathException("Unrecognized element " + localname + " in DTD output");
                e.setXPathContext(context);
                throw e;
            }
            child = (NodeInfo)children.next();
        }

View Full Code Here

            TailCall tc = t.expand(c2);
            while (tc != null) {
                tc = tc.processLeavingTail();
            }
        } catch (StackOverflowError e) {
            XPathException err = new XPathException("Too many nested template or function calls. The stylesheet may be looping.");
            err.setLocator(this);
            err.setXPathContext(context);
            throw err;
        }
    }

View Full Code Here


            if (th.isSubType(requiredItemType, BuiltInAtomicType.NUMERIC)) {
                ItemMappingFunction promoter = new ItemMappingFunction() {
                    public Item map(Item item) throws XPathException {
                        if (!(item instanceof NumericValue || item instanceof UntypedAtomicValue)) {
                            throw new XPathException(
                                    "Cannot promote non-numeric value to " + requiredItemType.toString(), "XPTY0004", context);
                        }
                        return ((AtomicValue)item).convert((AtomicType)requiredItemType, true, context).asAtomic();
                    }
                };
                iterator = new ItemMappingIterator(iterator, promoter);
            }


            // step 4: apply URI-to-string promotion


            if (requiredItemType.equals(BuiltInAtomicType.STRING) &&
                    th.relationship(suppliedItemType, BuiltInAtomicType.ANY_URI) != TypeHierarchy.DISJOINT) {
                ItemMappingFunction promoter = new ItemMappingFunction() {
                    public Item map(Item item) throws XPathException {
                        if (item instanceof AnyURIValue) {
                            return new StringValue(item.getStringValueCS());
                        } else {
                            return item;
                        }
                    }
                };
                iterator = new ItemMappingIterator(iterator, promoter);
            }
        }


        Value result = Value.asValue(SequenceExtent.makeSequenceExtent(iterator));
        XPathException err = TypeChecker.testConformance(result, requiredType, context);
        if (err != null) {
            throw err;
        }
        return result;
    }

View Full Code Here

        if (select != null) {
            select = visitor.typeCheck(select, contextItemType);
        } else {
            if (value==null) {
                // we are numbering the context node
                XPathException err = null;
                if (contextItemType == null) {
                    err = new XPathException(
                            "xsl:number requires a select attribute, a value attribute, or a context item");
                } else if (contextItemType.isAtomicType()) {
                    err = new XPathException(
                            "xsl:number requires the context item to be a node, but it is an atomic value");


                }
                if (err != null) {
                    err.setIsTypeError(true);
                    err.setErrorCode("XTTE0990");
                    err.setLocator(this);
                    throw err;
                }
            }
        }
        if (value != null) {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.pdf4j.saxon.trans.XPathException

org.pdf4j.saxon.charcode.CharacterSetFactory

org.pdf4j.saxon.Configuration

org.pdf4j.saxon.dom.DOMObjectModel

org.pdf4j.saxon.dom.DOMSender

org.pdf4j.saxon.dom.DOMTransform

org.pdf4j.saxon.dom.DOMWriter

org.pdf4j.saxon.dotnet.DotNetDomBuilder

org.pdf4j.saxon.dotnet.DotNetExtensionFunctionCall

org.pdf4j.saxon.dotnet.DotNetRegularExpression

org.pdf4j.saxon.dotnet.DotNetStandardModuleURIResolver

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.