| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the QtXmlPatterns module of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| // |
| // W A R N I N G |
| // ------------- |
| // |
| // This file is not part of the Qt API. It exists purely as an |
| // implementation detail. This header file may change from version to |
| // version without notice, or even be removed. |
| // |
| // We mean it. |
| |
| #ifndef Patternist_ReportContext_H |
| #define Patternist_ReportContext_H |
| |
| #include <QSharedData> |
| #include <QAbstractUriResolver> |
| #include <QSourceLocation> |
| |
| #include "qnamepool_p.h" |
| #include "qxmlname.h" |
| |
| QT_BEGIN_HEADER |
| |
| QT_BEGIN_NAMESPACE |
| |
| class QAbstractMessageHandler; |
| class QSourceLocation; |
| class QString; |
| |
| namespace QPatternist |
| { |
| class SourceLocationReflection; |
| |
| /** |
| * @short A callback for reporting errors. |
| * |
| * ReportContext receives messages of various severity and type via its |
| * functions warning() and error(). In turn, ReportContext create Message instances |
| * and submit them to the QAbstractMessageHandler instance returned by messageHandler(). |
| * |
| * The Message attributes are set as follows: |
| * |
| * - Message::description() - A translated, human-readable description |
| * - Message::type() - Message::Error if a static, dynamic or type error was encountered |
| * that halted compilation or evaluation, or Message::Warning in case of a warning |
| * - Message::identifier() - This is a URI consisting of the error namespace with the |
| * error code as fragment. For example, a Message representing a syntax error |
| * would return the type "http://www.w3.org/2005/xqt-errors#XPST0003". The convenience |
| * function codeFromURI() can be used to extract the error code. The error namespace |
| * is typically the namespace for XPath and XQuery errors(as in the previous example), but |
| * can also be user defined. |
| * |
| * @see <a href="http://www.w3.org/TR/xpath20/#id-identifying-errors">XML Path Language |
| * (XPath) 2.0, 2.3.2 Identifying and Reporting Errors</a> |
| * @see <a href="http://www.w3.org/TR/xpath-functions/#func-error">XQuery 1.0 and |
| * XPath 2.0 Functions and Operators, 3 The Error Function</a> |
| * @author Frans Englich <frans.englich@nokia.com> |
| * @warning This file is auto-generated from extractErrorCodes.xsl. Any |
| * modifications done to this file are lost. |
| */ |
| class Q_AUTOTEST_EXPORT ReportContext : public QSharedData |
| { |
| public: |
| typedef QHash<const SourceLocationReflection *, QSourceLocation> LocationHash; |
| |
| /** |
| * A smart pointer wrapping ReportContext instances. |
| */ |
| typedef QExplicitlySharedDataPointer<ReportContext> Ptr; |
| |
| /** |
| * @short Default constructors. |
| * |
| * For some reason GCC fails to synthesize it, so we provide an empty |
| * one here. |
| */ |
| inline ReportContext() {} |
| |
| virtual ~ReportContext(); |
| |
| /** |
| * Error codes that corresponds to the error codes defined in the |
| * relevant specifications. They are used throughout the API for |
| * identifying error conditions. |
| * |
| * While strings could have been used for identifying errors, enums |
| * reduces bugs by providing type safety. |
| * |
| * @see <a href="http://www.w3.org/TR/xpath20/#errors">XML |
| * Path Language (XPath) 2.0, 2.3 Error Handling</a> |
| * @see <a href="http://www.w3.org/TR/xpath-functions/#d1e10985">XQuery 1.0 |
| * and XPath 2.0 Functions and Operators, C Error Summary</a> |
| * @see <a href="http://www.w3.org/TR/xslt20/#error-summary">XSL Transformations |
| * (XSLT) Version 2.0, E Summary of Error Conditions (Non-Normative)</a> |
| * @note The enumerator values' Doxygen documentation is copied from the |
| * W3C documents |
| * <a href="http://www.w3.org/TR/xpath-functions">XQuery 1.0 and XPath |
| * 2.0 Functions and Operators</a>, |
| * <a href="http://www.w3.org/TR/xpath20">XML Path Language (XPath) 2.0</a>, and |
| * <a href="http://www.w3.org/TR/xslt20/">XSL Transformations (XSLT) |
| * Version 2.0</a>, respectively. The doxygen documentation is therefore covered |
| * by the following legal notice: |
| * "Copyright @ 2005 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C |
| * <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, |
| * <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and |
| * <a href="http://www.w3.org/Consortium/Legal/copyright-documents">document |
| * use</a> rules apply." |
| * @warning This enumerator is auto-generated from the relevant specifications |
| * by the XSL-T stylesheet extractErrorCodes.xsl. Hence, any modifications |
| * done to this file, in contrary to the stylesheet, are therefore lost. |
| */ |
| enum ErrorCode |
| { |
| /** |
| * XML Schema error code. |
| */ |
| XSDError, |
| |
| /** |
| * It is a static error if analysis of an expression relies on some |
| * component of the static context that has not been assigned a |
| * value. |
| */ |
| XPST0001, |
| |
| /** |
| * It is a dynamic error if evaluation of an expression relies on |
| * some part of the dynamic context that has not been assigned a |
| * value. |
| */ |
| XPDY0002, |
| |
| /** |
| * It is a static error if an expression is not a valid instance |
| * of the grammar defined in A.1 EBNF. |
| */ |
| XPST0003, |
| |
| /** |
| * It is a type error if, during the static analysis phase, an expression |
| * is found to have a static type that is not appropriate for the |
| * context in which the expression occurs, or during the dynamic |
| * evaluation phase, the dynamic type of a value does not match |
| * a required type as specified by the matching rules in 2.5.4 SequenceType |
| * Matching. |
| */ |
| XPTY0004, |
| |
| /** |
| * During the analysis phase, it is a static error if the static |
| * type assigned to an expression other than the expression () or |
| * data(()) is empty-sequence(). |
| */ |
| XPST0005, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XPTY0006, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XPTY0007, |
| |
| /** |
| * It is a static error if an expression refers to an element name, |
| * attribute name, schema type name, namespace prefix, or variable |
| * name that is not defined in the static context, except for an |
| * ElementName in an ElementTest or an AttributeName in an AttributeTest. |
| */ |
| XPST0008, |
| |
| /** |
| * An implementation that does not support the Schema Import Feature |
| * must raise a static error if a Prolog contains a schema import. |
| */ |
| XQST0009, |
| |
| /** |
| * An implementation must raise a static error if it encounters |
| * a reference to an axis that it does not support. |
| */ |
| XPST0010, |
| |
| /** |
| * It is a static error if the set of definitions contained in all |
| * schemas imported by a Prolog do not satisfy the conditions for |
| * schema validity specified in Sections 3 and 5 of [XML Schema] |
| * Part 1--i.e., each definition must be valid, complete, and unique. |
| */ |
| XQST0012, |
| |
| /** |
| * It is a static error if an implementation recognizes a pragma |
| * but determines that its content is invalid. |
| */ |
| XQST0013, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0014, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0015, |
| |
| /** |
| * An implementation that does not support the Module Feature raises |
| * a static error if it encounters a module declaration or a module |
| * import. |
| */ |
| XQST0016, |
| |
| /** |
| * It is a static error if the expanded QName and number of arguments |
| * in a function call do not match the name and arity of a function |
| * signature in the static context. |
| */ |
| XPST0017, |
| |
| /** |
| * It is a type error if the result of the last step in a path expression |
| * contains both nodes and atomic values. |
| */ |
| XPTY0018, |
| |
| /** |
| * It is a type error if the result of a step (other than the last |
| * step) in a path expression contains an atomic value. |
| */ |
| XPTY0019, |
| |
| /** |
| * It is a type error if, in an axis step, the context item is not |
| * a node. |
| */ |
| XPTY0020, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XPDY0021, |
| |
| /** |
| * It is a static error if the value of a namespace declaration |
| * attribute is not a URILiteral. |
| */ |
| XQST0022, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQTY0023, |
| |
| /** |
| * It is a type error if the content sequence in an element constructor |
| * contains an attribute node following a node that is not an attribute |
| * node. |
| */ |
| XQTY0024, |
| |
| /** |
| * It is a dynamic error if any attribute of a constructed element |
| * does not have a name that is distinct from the names of all other |
| * attributes of the constructed element. |
| */ |
| XQDY0025, |
| |
| /** |
| * It is a dynamic error if the result of the content expression |
| * of a computed processing instruction constructor contains the |
| * string "?>". |
| */ |
| XQDY0026, |
| |
| /** |
| * In a validate expression, it is a dynamic error if the root element |
| * information item in the PSVI resulting from validation does not |
| * have the expected validity property: valid if validation mode |
| * is strict, or either valid or notKnown if validation mode is |
| * lax. |
| */ |
| XQDY0027, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQTY0028, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQDY0029, |
| |
| /** |
| * It is a type error if the argument of a validate expression does |
| * not evaluate to exactly one document or element node. |
| */ |
| XQTY0030, |
| |
| /** |
| * It is a static error if the version number specified in a version |
| * declaration is not supported by the implementation. |
| */ |
| XQST0031, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one base |
| * URI declaration. |
| */ |
| XQST0032, |
| |
| /** |
| * It is a static error if a module contains multiple bindings for |
| * the same namespace prefix. |
| */ |
| XQST0033, |
| |
| /** |
| * It is a static error if multiple functions declared or imported |
| * by a module have the number of arguments and their expanded QNames |
| * are equal (as defined by the eq operator). |
| */ |
| XQST0034, |
| |
| /** |
| * It is a static error to import two schema components that both |
| * define the same name in the same symbol space and in the same |
| * scope. |
| */ |
| XQST0035, |
| |
| /** |
| * It is a static error to import a module if the importing module's |
| * in-scope schema types do not include definitions for the schema |
| * type names that appear in the declarations of variables and functions |
| * (whether in an argument type or return type) that are present |
| * in the imported module and are referenced in the importing module. |
| */ |
| XQST0036, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0037, |
| |
| /** |
| * It is a static error if a Prolog contains more than one default |
| * collation declaration, or the value specified by a default collation |
| * declaration is not present in statically known collations. |
| */ |
| XQST0038, |
| |
| /** |
| * It is a static error for a function declaration to have more |
| * than one parameter with the same name. |
| */ |
| XQST0039, |
| |
| /** |
| * It is a static error if the attributes specified by a direct |
| * element constructor do not have distinct expanded QNames. |
| */ |
| XQST0040, |
| |
| /** |
| * It is a dynamic error if the value of the name expression in |
| * a computed processing instruction constructor cannot be cast |
| * to the type xs:NCName. |
| */ |
| XQDY0041, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0042, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0043, |
| |
| /** |
| * It is a dynamic error if the node-name property of the node constructed |
| * by a computed attribute constructor is in the namespace http://www.w3.org/2000/xmlns/ |
| * (corresponding to namespace prefix xmlns), or is in no namespace |
| * and has local name xmlns. |
| */ |
| XQDY0044, |
| |
| /** |
| * It is a static error if the function name in a function declaration |
| * is in one of the following namespaces: http://www.w3.org/XML/1998/namespace, |
| * http://www.w3.org/2001/XMLSchema, http://www.w3.org/2001/XMLSchema-instance, |
| * http://www.w3.org/2005/xpath-functions. |
| */ |
| XQST0045, |
| |
| /** |
| * An implementation MAY raise a static error if the value of a |
| * URILiteral is of nonzero length and is not in the lexical space |
| * of xs:anyURI. |
| */ |
| XQST0046, |
| |
| /** |
| * It is a static error if multiple module imports in the same Prolog |
| * specify the same target namespace. |
| */ |
| XQST0047, |
| |
| /** |
| * It is a static error if a function or variable declared in a |
| * library module is not in the target namespace of the library |
| * module. |
| */ |
| XQST0048, |
| |
| /** |
| * It is a static error if two or more variables declared or imported |
| * by a module have equal expanded QNames (as defined by the eq |
| * operator.) |
| */ |
| XQST0049, |
| |
| /** |
| * It is a dynamic error if the dynamic type of the operand of a |
| * treat expression does not match the sequence type specified by |
| * the treat expression. This error might also be raised by a path |
| * expression beginning with "/" or "//" if the context node is |
| * not in a tree that is rooted at a document node. This is because |
| * a leading "/" or "//" in a path expression is an abbreviation |
| * for an initial step that includes the clause treat as document-node(). |
| */ |
| XPDY0050, |
| |
| /** |
| * It is a static error if a QName that is used as an AtomicType |
| * in a SequenceType is not defined in the in-scope schema types |
| * as an atomic type. |
| */ |
| XPST0051, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQDY0052, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0053, |
| |
| /** |
| * It is a static error if a variable depends on itself. |
| */ |
| XQST0054, |
| |
| /** |
| * It is a static error if a Prolog contains more than one copy-namespaces |
| * declaration. |
| */ |
| XQST0055, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0056, |
| |
| /** |
| * It is a static error if a schema import binds a namespace prefix |
| * but does not specify a target namespace other than a zero-length |
| * string. |
| */ |
| XQST0057, |
| |
| /** |
| * It is a static error if multiple schema imports specify the same |
| * target namespace. |
| */ |
| XQST0058, |
| |
| /** |
| * It is a static error if an implementation is unable to process |
| * a schema or module import by finding a schema or module with |
| * the specified target namespace. |
| */ |
| XQST0059, |
| |
| /** |
| * It is a static error if the name of a function in a function |
| * declaration is not in a namespace (expanded QName has a null |
| * namespace URI). |
| */ |
| XQST0060, |
| |
| /** |
| * It is a dynamic error if the operand of a validate expression |
| * is a document node whose children do not consist of exactly one |
| * element node and zero or more comment and processing instruction |
| * nodes, in any order. |
| */ |
| XQDY0061, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQDY0062, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0063, |
| |
| /** |
| * It is a dynamic error if the value of the name expression in |
| * a computed processing instruction constructor is equal to "XML" |
| * (in any combination of upper and lower case). |
| */ |
| XQDY0064, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one ordering |
| * mode declaration. |
| */ |
| XQST0065, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one default |
| * element/type namespace declaration, or more than one default |
| * function namespace declaration. |
| */ |
| XQST0066, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one construction |
| * declaration. |
| */ |
| XQST0067, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one boundary-space |
| * declaration. |
| */ |
| XQST0068, |
| |
| /** |
| * A static error is raised if a Prolog contains more than one empty |
| * order declaration. |
| */ |
| XQST0069, |
| |
| /** |
| * A static error is raised if a namespace URI is bound to the predefined |
| * prefix xmlns, or if a namespace URI other than http://www.w3.org/XML/1998/namespace |
| * is bound to the prefix xml, or if the prefix xml is bound to |
| * a namespace URI other than http://www.w3.org/XML/1998/namespace. |
| */ |
| XQST0070, |
| |
| /** |
| * A static error is raised if the namespace declaration attributes |
| * of a direct element constructor do not have distinct names. |
| */ |
| XQST0071, |
| |
| /** |
| * It is a dynamic error if the result of the content expression |
| * of a computed comment constructor contains two adjacent hyphens |
| * or ends with a hyphen. |
| */ |
| XQDY0072, |
| |
| /** |
| * It is a static error if the graph of module imports contains |
| * a cycle (that is, if there exists a sequence of modules M1 ... |
| * Mn such that each Mi imports Mi+1 and Mn imports M1), unless |
| * all the modules in the cycle share a common namespace. |
| */ |
| XQST0073, |
| |
| /** |
| * It is a dynamic error if the value of the name expression in |
| * a computed element or attribute constructor cannot be converted |
| * to an expanded QName (for example, because it contains a namespace |
| * prefix not found in statically known namespaces.) |
| */ |
| XQDY0074, |
| |
| /** |
| * An implementation that does not support the Validation Feature |
| * must raise a static error if it encounters a validate expression. |
| */ |
| XQST0075, |
| |
| /** |
| * It is a static error if a collation subclause in an order by |
| * clause of a FLWOR expression does not identify a collation that |
| * is present in statically known collations. |
| */ |
| XQST0076, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0077, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0078, |
| |
| /** |
| * It is a static error if an extension expression contains neither |
| * a pragma that is recognized by the implementation nor an expression |
| * enclosed in curly braces. |
| */ |
| XQST0079, |
| |
| /** |
| * It is a static error if the target type of a cast or castable |
| * expression is xs:NOTATION or xs:anyAtomicType. |
| */ |
| XPST0080, |
| |
| /** |
| * It is a static error if a QName used in a query contains a namespace |
| * prefix that cannot be expanded into a namespace URI by using |
| * the statically known namespaces. |
| */ |
| XPST0081, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XQST0082, |
| |
| /** |
| * (Not currently used.) |
| */ |
| XPST0083, |
| |
| /** |
| * It is a dynamic error if the element validated by a validate |
| * statement does not have a top-level element declaration in the |
| * in-scope element declarations, if validation mode is strict. |
| */ |
| XQDY0084, |
| |
| /** |
| * It is a static error if the namespace URI in a namespace declaration |
| * attribute is a zero-length string, and the implementation does |
| * not support [XML Names 1.1]. |
| */ |
| XQST0085, |
| |
| /** |
| * It is a type error if the typed value of a copied element or |
| * attribute node is namespace-sensitive when construction mode |
| * is preserve and copy-namespaces mode is no-preserve. |
| */ |
| XQTY0086, |
| |
| /** |
| * It is a static error if the encoding specified in a Version Declaration |
| * does not conform to the definition of EncName specified in [XML |
| * 1.0]. |
| */ |
| XQST0087, |
| |
| /** |
| * It is a static error if the literal that specifies the target |
| * namespace in a module import or a module declaration is of zero |
| * length. |
| */ |
| XQST0088, |
| |
| /** |
| * It is a static error if a variable bound in a for clause of a |
| * FLWOR expression, and its associated positional variable, do |
| * not have distinct names (expanded QNames). |
| */ |
| XQST0089, |
| |
| /** |
| * It is a static error if a character reference does not identify |
| * a valid character in the version of XML that is in use. |
| */ |
| XQST0090, |
| |
| /** |
| * An implementation MAY raise a dynamic error if an xml:id error, |
| * as defined in [XML ID], is encountered during construction of |
| * an attribute named xml:id. |
| */ |
| XQDY0091, |
| |
| /** |
| * An implementation MAY raise a dynamic error if a constructed |
| * attribute named xml:space has a value other than preserve or |
| * default. |
| */ |
| XQDY0092, |
| |
| /** |
| * It is a static error to import a module M1 if there exists a |
| * sequence of modules M1 ... Mi ... M1 such that each module directly |
| * depends on the next module in the sequence (informally, if M1 |
| * depends on itself through some chain of module dependencies.) |
| */ |
| XQST0093, |
| |
| /** |
| * Unidentified error. |
| */ |
| FOER0000, |
| |
| /** |
| * Division by zero. |
| */ |
| FOAR0001, |
| |
| /** |
| * Numeric operation overflow/underflow. |
| */ |
| FOAR0002, |
| |
| /** |
| * Input value too large for decimal. |
| */ |
| FOCA0001, |
| |
| /** |
| * Invalid lexical value. |
| */ |
| FOCA0002, |
| |
| /** |
| * Input value too large for integer. |
| */ |
| FOCA0003, |
| |
| /** |
| * NaN supplied as float/double value. |
| */ |
| FOCA0005, |
| |
| /** |
| * String to be cast to decimal has too many digits of precision. |
| */ |
| FOCA0006, |
| |
| /** |
| * Code point not valid. |
| */ |
| FOCH0001, |
| |
| /** |
| * Unsupported collation. |
| */ |
| FOCH0002, |
| |
| /** |
| * Unsupported normalization form. |
| */ |
| FOCH0003, |
| |
| /** |
| * Collation does not support collation units. |
| */ |
| FOCH0004, |
| |
| /** |
| * No context document. |
| */ |
| FODC0001, |
| |
| /** |
| * Error retrieving resource. |
| */ |
| FODC0002, |
| |
| /** |
| * Function stability not defined. |
| */ |
| FODC0003, |
| |
| /** |
| * Invalid argument to fn:collection. |
| */ |
| FODC0004, |
| |
| /** |
| * Invalid argument to fn:doc or fn:doc-available. |
| */ |
| FODC0005, |
| |
| /** |
| * Overflow/underflow in date/time operation. |
| */ |
| FODT0001, |
| |
| /** |
| * Overflow/underflow in duration operation. |
| */ |
| FODT0002, |
| |
| /** |
| * Invalid timezone value. |
| */ |
| FODT0003, |
| |
| /** |
| * No namespace found for prefix. |
| */ |
| FONS0004, |
| |
| /** |
| * Base-uri not defined in the static context. |
| */ |
| FONS0005, |
| |
| /** |
| * Invalid value for cast/constructor. |
| */ |
| FORG0001, |
| |
| /** |
| * Invalid argument to fn:resolve-uri(). |
| */ |
| FORG0002, |
| |
| /** |
| * fn:zero-or-one called with a sequence containing more than one |
| * item. |
| */ |
| FORG0003, |
| |
| /** |
| * fn:one-or-more called with a sequence containing no items. |
| */ |
| FORG0004, |
| |
| /** |
| * fn:exactly-one called with a sequence containing zero or more |
| * than one item. |
| */ |
| FORG0005, |
| |
| /** |
| * Invalid argument type. |
| */ |
| FORG0006, |
| |
| /** |
| * Both arguments to fn:dateTime have a specified timezone. |
| */ |
| FORG0008, |
| |
| /** |
| * Error in resolving a relative URI against a base URI in fn:resolve-uri. |
| */ |
| FORG0009, |
| |
| /** |
| * Invalid regular expression. flags |
| */ |
| FORX0001, |
| |
| /** |
| * Invalid regular expression. |
| */ |
| FORX0002, |
| |
| /** |
| * Regular expression matches zero-length string. |
| */ |
| FORX0003, |
| |
| /** |
| * Invalid replacement string. |
| */ |
| FORX0004, |
| |
| /** |
| * Argument node does not have a typed value. |
| */ |
| FOTY0012, |
| |
| /** |
| * It is an error if an item in S6 in sequence normalization is |
| * an attribute node or a namespace node. |
| */ |
| SENR0001, |
| |
| /** |
| * It is an error if the serializer is unable to satisfy the rules |
| * for either a well-formed XML document entity or a well-formed |
| * XML external general parsed entity, or both, except for content |
| * modified by the character expansion phase of serialization. |
| */ |
| SERE0003, |
| |
| /** |
| * It is an error to specify the doctype-system parameter, or to |
| * specify the standalone parameter with a value other than omit, |
| * if the instance of the data model contains text nodes or multiple |
| * element nodes as children of the root node. |
| */ |
| SEPM0004, |
| |
| /** |
| * It is an error if the serialized result would contain an NCName |
| * Names that contains a character that is not permitted by the |
| * version of Namespaces in XML specified by the version parameter. |
| */ |
| SERE0005, |
| |
| /** |
| * It is an error if the serialized result would contain a character |
| * that is not permitted by the version of XML specified by the |
| * version parameter. |
| */ |
| SERE0006, |
| |
| /** |
| * It is an error if an output encoding other than UTF-8 or UTF-16 |
| * is requested and the serializer does not support that encoding. |
| */ |
| SESU0007, |
| |
| /** |
| * It is an error if a character that cannot be represented in the |
| * encoding that the serializer is using for output appears in a |
| * context where character references are not allowed (for example |
| * if the character occurs in the name of an element). |
| */ |
| SERE0008, |
| |
| /** |
| * It is an error if the omit-xml-declaration parameter has the |
| * value yes, and the standalone attribute has a value other than |
| * omit; or the version parameter has a value other than 1.0 and |
| * the doctype-system parameter is specified. |
| */ |
| SEPM0009, |
| |
| /** |
| * It is an error if the output method is xml, the value of the |
| * undeclare-prefixes parameter is yes, and the value of the version |
| * parameter is 1.0. |
| */ |
| SEPM0010, |
| |
| /** |
| * It is an error if the value of the normalization-form parameter |
| * specifies a normalization form that is not supported by the serializer. |
| */ |
| SESU0011, |
| |
| /** |
| * It is an error if the value of the normalization-form parameter |
| * is fully-normalized and any relevant construct of the result |
| * begins with a combining character. |
| */ |
| SERE0012, |
| |
| /** |
| * It is an error if the serializer does not support the version |
| * of XML or HTML specified by the version parameter. |
| */ |
| SESU0013, |
| |
| /** |
| * It is an error to use the HTML output method when characters |
| * which are legal in XML but not in HTML, specifically the control |
| * characters \#x7F-#x9F, appear in the instance of the data model. |
| */ |
| SERE0014, |
| |
| /** |
| * It is an error to use the HTML output method when > appears within |
| * a processing instruction in the data model instance being serialized. |
| */ |
| SERE0015, |
| |
| /** |
| * It is a an error if a parameter value is invalid for the defined |
| * domain. |
| */ |
| SEPM0016, |
| |
| /** |
| * A static error is signaled if an XSLT-defined element is used |
| * in a context where it is not permitted, if a required attribute |
| * is omitted, or if the content of the element does not correspond |
| * to the content that is allowed for the element. |
| */ |
| XTSE0010, |
| |
| /** |
| * It is a static error if an attribute (other than an attribute |
| * written using curly brackets in a position where an attribute |
| * value template is permitted) contains a value that is not one |
| * of the permitted values for that attribute. |
| */ |
| XTSE0020, |
| |
| /** |
| * It is a static error to use a reserved namespace in the name |
| * of a named template, a mode, an attribute set, a key, a decimal-format, |
| * a variable or parameter, a stylesheet function, a named output |
| * definition, or a character map. |
| */ |
| XTSE0080, |
| |
| /** |
| * It is a static error for an element from the XSLT namespace to |
| * have an attribute whose namespace is either null (that is, an |
| * attribute with an unprefixed name) or the XSLT namespace, other |
| * than attributes defined for the element in this document. |
| */ |
| XTSE0090, |
| |
| /** |
| * The value of the version attribute must be a number: specifically, |
| * it must be a a valid instance of the type xs:decimal as defined |
| * in [XML Schema Part 2]. |
| */ |
| XTSE0110, |
| |
| /** |
| * An xsl:stylesheet element must not have any text node children. |
| */ |
| XTSE0120, |
| |
| /** |
| * It is a static error if the value of an [xsl:]default-collation |
| * attribute, after resolving against the base URI, contains no |
| * URI that the implementation recognizes as a collation URI. |
| */ |
| XTSE0125, |
| |
| /** |
| * It is a static error if the xsl:stylesheet element has a child |
| * element whose name has a null namespace URI. |
| */ |
| XTSE0130, |
| |
| /** |
| * A literal result element that is used as the outermost element |
| * of a simplified stylesheet module must have an xsl:version attribute. |
| */ |
| XTSE0150, |
| |
| /** |
| * It is a static error if the processor is not able to retrieve |
| * the resource identified by the URI reference [ in the href attribute |
| * of xsl:include or xsl:import] , or if the resource that is retrieved |
| * does not contain a stylesheet module conforming to this specification. |
| */ |
| XTSE0165, |
| |
| /** |
| * An xsl:include element must be a top-level element. |
| */ |
| XTSE0170, |
| |
| /** |
| * It is a static error if a stylesheet module directly or indirectly |
| * includes itself. |
| */ |
| XTSE0180, |
| |
| /** |
| * An xsl:import element must be a top-level element. |
| */ |
| XTSE0190, |
| |
| /** |
| * The xsl:import element children must precede all other element |
| * children of an xsl:stylesheet element, including any xsl:include |
| * element children and any user-defined data elements. |
| */ |
| XTSE0200, |
| |
| /** |
| * It is a static error if a stylesheet module directly or indirectly |
| * imports itself. |
| */ |
| XTSE0210, |
| |
| /** |
| * It is a static error if an xsl:import-schema element that contains |
| * an xs:schema element has a schema-location attribute, or if it |
| * has a namespace attribute that conflicts with the target namespace |
| * of the contained schema. |
| */ |
| XTSE0215, |
| |
| /** |
| * It is a static error if the synthetic schema document does not |
| * satisfy the constraints described in [XML Schema Part 1] (section |
| * 5.1, Errors in Schema Construction and Structure). This includes, |
| * without loss of generality, conflicts such as multiple definitions |
| * of the same name. |
| */ |
| XTSE0220, |
| |
| /** |
| * Within an XSLT element that is required to be empty, any content |
| * other than comments or processing instructions, including any |
| * whitespace text node preserved using the xml:space="preserve" |
| * attribute, is a static error. |
| */ |
| XTSE0260, |
| |
| /** |
| * It is a static error if there is a stylesheet module in the stylesheet |
| * that specifies input-type-annotations="strip" and another stylesheet |
| * module that specifies input-type-annotations="preserve". |
| */ |
| XTSE0265, |
| |
| /** |
| * In the case of a prefixed QName used as the value of an attribute |
| * in the stylesheet, or appearing within an XPath expression in |
| * the stylesheet, it is a static error if the defining element |
| * has no namespace node whose name matches the prefix of the QName. |
| */ |
| XTSE0280, |
| |
| /** |
| * Where an attribute is defined to contain a pattern, it is a static |
| * error if the pattern does not match the production Pattern. |
| */ |
| XTSE0340, |
| |
| /** |
| * It is a static error if an unescaped left curly bracket appears |
| * in a fixed part of an attribute value template without a matching |
| * right curly bracket. |
| */ |
| XTSE0350, |
| |
| /** |
| * It is a static error if an unescaped right curly bracket occurs |
| * in a fixed part of an attribute value template. |
| */ |
| XTSE0370, |
| |
| /** |
| * An xsl:template element must have either a match attribute or |
| * a name attribute, or both. An xsl:template element that has no |
| * match attribute must have no mode attribute and no priority attribute. |
| */ |
| XTSE0500, |
| |
| /** |
| * The value of this attribute [the priority attribute of the xsl:template |
| * element] must conform to the rules for the xs:decimal type defined |
| * in [XML Schema Part 2]. Negative values are permitted.. |
| */ |
| XTSE0530, |
| |
| /** |
| * It is a static error if the list [of modes in the mode attribute |
| * of xsl:template] is empty, if the same token is included more |
| * than once in the list, if the list contains an invalid token, |
| * or if the token \#all appears together with any other value. |
| */ |
| XTSE0550, |
| |
| /** |
| * It is a static error if two parameters of a template or of a |
| * stylesheet function have the same name. |
| */ |
| XTSE0580, |
| |
| /** |
| * It is a static error if a variable-binding element has a select |
| * attribute and has non-empty content. |
| */ |
| XTSE0620, |
| |
| /** |
| * It is a static error if a stylesheet contains more than one binding |
| * of a global variable with the same name and same import precedence, |
| * unless it also contains another binding with the same name and |
| * higher import precedence. |
| */ |
| XTSE0630, |
| |
| /** |
| * It is a static error if a stylesheet contains an xsl:call-template |
| * instruction whose name attribute does not match the name attribute |
| * of any xsl:template in the stylesheet. |
| */ |
| XTSE0650, |
| |
| /** |
| * It is a static error if a stylesheet contains more than one template |
| * with the same name and the same import precedence, unless it |
| * also contains a template with the same name and higher import |
| * precedence. |
| */ |
| XTSE0660, |
| |
| /** |
| * It is a static error if a single xsl:call-template, xsl:apply-templates, |
| * xsl:apply-imports, or xsl:next-match element contains two or |
| * more xsl:with-param elements with matching name attributes. |
| */ |
| XTSE0670, |
| |
| /** |
| * In the case of xsl:call-template, it is a static error to pass |
| * a non-tunnel parameter named x to a template that does not have |
| * a template parameter named x, unless backwards compatible behavior |
| * is enabled for the xsl:call-template instruction. |
| */ |
| XTSE0680, |
| |
| /** |
| * It is a static error if a template that is invoked using xsl:call-template |
| * declares a template parameter specifying required="yes" and not |
| * specifying tunnel="yes", if no value for this parameter is supplied |
| * by the calling instruction. |
| */ |
| XTSE0690, |
| |
| /** |
| * It is a static error if the value of the use-attribute-sets attribute |
| * of an xsl:copy, xsl:element, or xsl:attribute-set element, or |
| * the xsl:use-attribute-sets attribute of a literal result element, |
| * is not a whitespace-separated sequence of QNames, or if it contains |
| * a QName that does not match the name attribute of any xsl:attribute-set |
| * declaration in the stylesheet. |
| */ |
| XTSE0710, |
| |
| /** |
| * It is a static error if an xsl:attribute-set element directly |
| * or indirectly references itself via the names contained in the |
| * use-attribute-sets attribute. |
| */ |
| XTSE0720, |
| |
| /** |
| * A stylesheet function must have a prefixed name, to remove any |
| * risk of a clash with a function in the default function namespace. |
| * It is a static error if the name has no prefix. |
| */ |
| XTSE0740, |
| |
| /** |
| * Because arguments to a stylesheet function call must all be specified, |
| * the xsl:param elements within an xsl:function element must not |
| * specify a default value: this means they must be empty, and must |
| * not have a select attribute. |
| */ |
| XTSE0760, |
| |
| /** |
| * It is a static error for a stylesheet to contain two or more |
| * functions with the same expanded-QName, the same arity, and the |
| * same import precedence, unless there is another function with |
| * the same expanded-QName and arity, and a higher import precedence. |
| */ |
| XTSE0770, |
| |
| /** |
| * It is a static error if an attribute on a literal result element |
| * is in the XSLT namespace, unless it is one of the attributes |
| * explicitly defined in this specification. |
| */ |
| XTSE0805, |
| |
| /** |
| * It is a static error if a namespace prefix is used within the |
| * [xsl:]exclude-result-prefixes attribute and there is no namespace |
| * binding in scope for that prefix. |
| */ |
| XTSE0808, |
| |
| /** |
| * It is a static error if the value \#default is used within the |
| * [xsl:]exclude-result-prefixes attribute and the parent element |
| * of the [xsl:]exclude-result-prefixes attribute has no default |
| * namespace. |
| */ |
| XTSE0809, |
| |
| /** |
| * It is a static error if there is more than one such declaration |
| * [more than one xsl:namespace-alias declaration] with the same |
| * literal namespace URI and the same import precedence and different |
| * values for the target namespace URI, unless there is also an |
| * xsl:namespace-alias declaration with the same literal namespace |
| * URI and a higher import precedence. |
| */ |
| XTSE0810, |
| |
| /** |
| * It is a static error if a value other than \#default is specified |
| * for either the stylesheet-prefix or the result-prefix attributes |
| * of the xsl:namespace-alias element when there is no in-scope |
| * binding for that namespace prefix. |
| */ |
| XTSE0812, |
| |
| /** |
| * It is a static error if the select attribute of the xsl:attribute |
| * element is present unless the element has empty content. |
| */ |
| XTSE0840, |
| |
| /** |
| * It is a static error if the select attribute of the xsl:value-of |
| * element is present when the content of the element is non-empty, |
| * or if the select attribute is absent when the content is empty. |
| */ |
| XTSE0870, |
| |
| /** |
| * It is a static error if the select attribute of the xsl:processing-instruction |
| * element is present unless the element has empty content. |
| */ |
| XTSE0880, |
| |
| /** |
| * It is a static error if the select attribute of the xsl:namespace |
| * element is present when the element has content other than one |
| * or more xsl:fallback instructions, or if the select attribute |
| * is absent when the element has empty content. |
| */ |
| XTSE0910, |
| |
| /** |
| * It is a static error if the select attribute of the xsl:comment |
| * element is present unless the element has empty content. |
| */ |
| XTSE0940, |
| |
| /** |
| * It is a type error to use the xsl:copy or xsl:copy-of instruction |
| * to copy a node that has namespace-sensitive content if the copy-namespaces |
| * attribute has the value no and its explicit or implicit validation |
| * attribute has the value preserve. It is also a type error if |
| * either of these instructions (with validation="preserve") is |
| * used to copy an attribute having namespace-sensitive content, |
| * unless the parent element is also copied. A node has namespace-sensitive |
| * content if its typed value contains an item of type xs:QName |
| * or xs:NOTATION or a type derived therefrom. The reason this is |
| * an error is because the validity of the content depends on the |
| * namespace context being preserved. |
| */ |
| XTTE0950, |
| |
| /** |
| * It is a static error if the value attribute of xsl:number is |
| * present unless the select, level, count, and from attributes |
| * are all absent. |
| */ |
| XTSE0975, |
| |
| /** |
| * It is a static error if an xsl:sort element with a select attribute |
| * has non-empty content. |
| */ |
| XTSE1015, |
| |
| /** |
| * It is a static error if an xsl:sort element other than the first |
| * in a sequence of sibling xsl:sort elements has a stable attribute. |
| */ |
| XTSE1017, |
| |
| /** |
| * It is a static error if an xsl:perform-sort instruction with |
| * a select attribute has any content other than xsl:sort and xsl:fallback |
| * instructions. |
| */ |
| XTSE1040, |
| |
| /** |
| * It is a static error if the current-group function is used within |
| * a pattern. |
| */ |
| XTSE1060, |
| |
| /** |
| * It is a static error if the current-grouping-key function is |
| * used within a pattern. |
| */ |
| XTSE1070, |
| |
| /** |
| * These four attributes [the group-by, group-adjacent, group-starting-with, |
| * and group-ending-with attributes of xsl:for-each-group ] are |
| * mutually exclusive: it is a static error if none of these four |
| * attributes is present, or if more than one of them is present. |
| */ |
| XTSE1080, |
| |
| /** |
| * It is an error to specify the collation attribute if neither |
| * the group-by attribute nor group-adjacent attribute is specified. |
| */ |
| XTSE1090, |
| |
| /** |
| * It is a static error if the xsl:analyze-string instruction contains |
| * neither an xsl:matching-substring nor an xsl:non-matching-substring |
| * element. |
| */ |
| XTSE1130, |
| |
| /** |
| * It is a static error if an xsl:key declaration has a use attribute |
| * and has non-empty content, or if it has empty content and no |
| * use attribute. |
| */ |
| XTSE1205, |
| |
| /** |
| * It is a static error if the xsl:key declaration has a collation |
| * attribute whose value (after resolving against the base URI) |
| * is not a URI recognized by the implementation as referring to |
| * a collation. |
| */ |
| XTSE1210, |
| |
| /** |
| * It is a static error if there are several xsl:key declarations |
| * in the stylesheet with the same key name and different effective |
| * collations. Two collations are the same if their URIs are equal |
| * under the rules for comparing xs:anyURI values, or if the implementation |
| * can determine that they are different URIs referring to the same |
| * collation. |
| */ |
| XTSE1220, |
| |
| /** |
| * It is a static error if a named or unnamed decimal format contains |
| * two conflicting values for the same attribute in different xsl:decimal-format |
| * declarations having the same import precedence, unless there |
| * is another definition of the same attribute with higher import |
| * precedence. |
| */ |
| XTSE1290, |
| |
| /** |
| * It is a static error if the character specified in the zero-digit |
| * attribute is not a digit or is a digit that does not have the |
| * numeric value zero. |
| */ |
| XTSE1295, |
| |
| /** |
| * It is a static error if, for any named or unnamed decimal format, |
| * the variables representing characters used in a picture string |
| * do not each have distinct values. These variables are decimal-separator-sign, |
| * grouping-sign, percent-sign, per-mille-sign, digit-zero-sign, |
| * digit-sign, and pattern-separator-sign. |
| */ |
| XTSE1300, |
| |
| /** |
| * It is a static error if there is no namespace bound to the prefix |
| * on the element bearing the [xsl:]extension-element-prefixes attribute |
| * or, when \#default is specified, if there is no default namespace. |
| */ |
| XTSE1430, |
| |
| /** |
| * It is a static error if both the [xsl:]type and [xsl:]validation |
| * attributes are present on the xsl:element, xsl:attribute, xsl:copy, |
| * xsl:copy-of, xsl:document, or xsl:result-document instructions, |
| * or on a literal result element. |
| */ |
| XTSE1505, |
| |
| /** |
| * It is a static error if the value of the type attribute of an |
| * xsl:element, xsl:attribute, xsl:copy, xsl:copy-of, xsl:document, |
| * or xsl:result-document instruction, or the xsl:type attribute |
| * of a literal result element, is not a valid QName, or if it uses |
| * a prefix that is not defined in an in-scope namespace declaration, |
| * or if the QName is not the name of a type definition included |
| * in the in-scope schema components for the stylesheet. |
| */ |
| XTSE1520, |
| |
| /** |
| * It is a static error if the value of the type attribute of an |
| * xsl:attribute instruction refers to a complex type definition |
| */ |
| XTSE1530, |
| |
| /** |
| * It is a static error if two xsl:output declarations within an |
| * output definition specify explicit values for the same attribute |
| * (other than cdata-section-elements and use-character-maps), with |
| * the values of the attributes being not equal, unless there is |
| * another xsl:output declaration within the same output definition |
| * that has higher import precedence and that specifies an explicit |
| * value for the same attribute. |
| */ |
| XTSE1560, |
| |
| /** |
| * The value [of the method attribute on xsl:output ] must (if present) |
| * be a valid QName. If the QName does not have a prefix, then it |
| * identifies a method specified in [XSLT and XQuery Serialization] |
| * and must be one of xml, html, xhtml, or text. |
| */ |
| XTSE1570, |
| |
| /** |
| * It is a static error if the stylesheet contains two or more character |
| * maps with the same name and the same import precedence, unless |
| * it also contains another character map with the same name and |
| * higher import precedence. |
| */ |
| XTSE1580, |
| |
| /** |
| * It is a static error if a name in the use-character-maps attribute |
| * of the xsl:output or xsl:character-map elements does not match |
| * the name attribute of any xsl:character-map in the stylesheet. |
| */ |
| XTSE1590, |
| |
| /** |
| * It is a static error if a character map references itself, directly |
| * or indirectly, via a name in the use-character-maps attribute. |
| */ |
| XTSE1600, |
| |
| /** |
| * A basic XSLT processor must signal a static error if the stylesheet |
| * includes an xsl:import-schema declaration. |
| */ |
| XTSE1650, |
| |
| /** |
| * A basic XSLT processor must signal a static error if the stylesheet |
| * includes an [xsl:]type attribute, or an [xsl:]validation or default-validation |
| * attribute with a value other than strip. |
| */ |
| XTSE1660, |
| |
| /** |
| * It is a type error if the result of evaluating the sequence constructor |
| * cannot be converted to the required type. |
| */ |
| XTTE0505, |
| |
| /** |
| * It is a type error if an xsl:apply-templates instruction with |
| * no select attribute is evaluated when the context item is not |
| * a node. |
| */ |
| XTTE0510, |
| |
| /** |
| * It is a type error if the sequence returned by the select expression |
| * [of xsl:apply-templates] contains an item that is not a node. |
| */ |
| XTTE0520, |
| |
| /** |
| * It is a type error if the supplied value of a variable cannot |
| * be converted to the required type. |
| */ |
| XTTE0570, |
| |
| /** |
| * It is a type error if the conversion of the supplied value of |
| * a parameter to its required type fails. |
| */ |
| XTTE0590, |
| |
| /** |
| * If a default value is given explicitly, that is, if there is |
| * either a select attribute or a non-empty sequence constructor, |
| * then it is a type error if the default value cannot be converted |
| * to the required type, using the function conversion rules. |
| */ |
| XTTE0600, |
| |
| /** |
| * If the as attribute [of xsl:function ] is specified, then the |
| * result evaluated by the sequence constructor (see 5.7 Sequence |
| * Constructors) is converted to the required type, using the function |
| * conversion rules. It is a type error if this conversion fails. |
| */ |
| XTTE0780, |
| |
| /** |
| * If the value of a parameter to a stylesheet function cannot be |
| * converted to the required type, a type error is signaled. |
| */ |
| XTTE0790, |
| |
| /** |
| * It is a type error if the xsl:number instruction is evaluated, |
| * with no value or select attribute, when the context item is not |
| * a node. |
| */ |
| XTTE0990, |
| |
| /** |
| * It is a type error if the result of evaluating the select attribute |
| * of the xsl:number instruction is anything other than a single |
| * node. |
| */ |
| XTTE1000, |
| |
| /** |
| * If any sort key value, after atomization and any type conversion |
| * required by the data-type attribute, is a sequence containing |
| * more than one item, then the effect depends on whether the xsl:sort |
| * element is evaluated with backwards compatible behavior. With |
| * backwards compatible behavior, the effective sort key value is |
| * the first item in the sequence. In other cases, this is a type |
| * error. |
| */ |
| XTTE1020, |
| |
| /** |
| * It is a type error if the grouping key evaluated using the group-adjacent |
| * attribute is an empty sequence, or a sequence containing more |
| * than one item. |
| */ |
| XTTE1100, |
| |
| /** |
| * When the group-starting-with or group-ending-with attribute [of |
| * the xsl:for-each-group instruction] is used, it is a type error |
| * if the result of evaluating the select expression contains an |
| * item that is not a node. |
| */ |
| XTTE1120, |
| |
| /** |
| * If the validation attribute of an xsl:element, xsl:attribute, |
| * xsl:copy, xsl:copy-of, or xsl:result-document instruction, or |
| * the xsl:validation attribute of a literal result element, has |
| * the effective value strict, and schema validity assessment concludes |
| * that the validity of the element or attribute is invalid or unknown, |
| * a type error occurs. As with other type errors, the error may |
| * be signaled statically if it can be detected statically. |
| */ |
| XTTE1510, |
| |
| /** |
| * If the validation attribute of an xsl:element, xsl:attribute, |
| * xsl:copy, xsl:copy-of, or xsl:result-document instruction, or |
| * the xsl:validation attribute of a literal result element, has |
| * the effective value strict, and there is no matching top-level |
| * declaration in the schema, then a type error occurs. As with |
| * other type errors, the error may be signaled statically if it |
| * can be detected statically. |
| */ |
| XTTE1512, |
| |
| /** |
| * If the validation attribute of an xsl:element, xsl:attribute, |
| * xsl:copy, xsl:copy-of, or xsl:result-document instruction, or |
| * the xsl:validation attribute of a literal result element, has |
| * the effective value lax, and schema validity assessment concludes |
| * that the element or attribute is invalid, a type error occurs. |
| * As with other type errors, the error may be signaled statically |
| * if it can be detected statically. |
| */ |
| XTTE1515, |
| |
| /** |
| * It is a type error if an [xsl:]type attribute is defined for |
| * a constructed element or attribute, and the outcome of schema |
| * validity assessment against that type is that the validity property |
| * of that element or attribute information item is other than valid. |
| */ |
| XTTE1540, |
| |
| /** |
| * A type error occurs if a type or validation attribute is defined |
| * (explicitly or implicitly) for an instruction that constructs |
| * a new attribute node, if the effect of this is to cause the attribute |
| * value to be validated against a type that is derived from, or |
| * constructed by list or union from, the primitive types xs:QName |
| * or xs:NOTATION. |
| */ |
| XTTE1545, |
| |
| /** |
| * A type error occurs [when a document node is validated] unless |
| * the children of the document node comprise exactly one element |
| * node, no text nodes, and zero or more comment and processing |
| * instruction nodes, in any order. |
| */ |
| XTTE1550, |
| |
| /** |
| * It is a type error if, when validating a document node, document-level |
| * constraints are not satisfied. These constraints include identity |
| * constraints (xs:unique, xs:key, and xs:keyref) and ID/IDREF constraints. |
| */ |
| XTTE1555, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of an attribute written using curly brackets, in a position where |
| * an attribute value template is permitted, is a value that is |
| * not one of the permitted values for that attribute. If the processor |
| * is able to detect the error statically (for example, when any |
| * XPath expressions within the curly brackets can be evaluated |
| * statically), then the processor may optionally signal this as |
| * a static error. |
| */ |
| XTDE0030, |
| |
| /** |
| * It is a non-recoverable dynamic error if the invocation of the |
| * stylesheet specifies a template name that does not match the |
| * expanded-QName of a named template defined in the stylesheet. |
| */ |
| XTDE0040, |
| |
| /** |
| * It is a non-recoverable dynamic error if the invocation of the |
| * stylesheet specifies an initial mode (other than the default |
| * mode) that does not match the expanded-QName in the mode attribute |
| * of any template defined in the stylesheet. |
| */ |
| XTDE0045, |
| |
| /** |
| * It is a non-recoverable dynamic error if the invocation of the |
| * stylesheet specifies both an initial mode and an initial template. |
| */ |
| XTDE0047, |
| |
| /** |
| * It is a non-recoverable dynamic error if the stylesheet that |
| * is invoked declares a visible stylesheet parameter with required="yes" |
| * and no value for this parameter is supplied during the invocation |
| * of the stylesheet. A stylesheet parameter is visible if it is |
| * not masked by another global variable or parameter with the same |
| * name and higher import precedence. |
| */ |
| XTDE0050, |
| |
| /** |
| * It is a non-recoverable dynamic error if the initial template |
| * defines a template parameter that specifies required="yes". |
| */ |
| XTDE0060, |
| |
| /** |
| * If an implementation does not support backwards-compatible behavior, |
| * then it is a non-recoverable dynamic error if any element is |
| * evaluated that enables backwards-compatible behavior. |
| */ |
| XTDE0160, |
| |
| /** |
| * It is a recoverable dynamic error if this [the process of finding |
| * an xsl:strip-space or xsl:preserve-space declaration to match |
| * an element in the source document] leaves more than one match, |
| * unless all the matched declarations are equivalent (that is, |
| * they are all xsl:strip-space or they are all xsl:preserve-space). |
| * Action: The optional recovery action is to select, from the matches |
| * that are left, the one that occurs last in declaration order. |
| */ |
| XTRE0270, |
| |
| /** |
| * Where the result of evaluating an XPath expression (or an attribute |
| * value template) is required to be a lexical QName, then unless |
| * otherwise specified it is a non-recoverable dynamic error if |
| * the defining element has no namespace node whose name matches |
| * the prefix of the lexical QName. This error may be signaled as |
| * a static error if the value of the expression can be determined |
| * statically. |
| */ |
| XTDE0290, |
| |
| /** |
| * It is a non-recoverable dynamic error if the result sequence |
| * used to construct the content of an element node contains a namespace |
| * node or attribute node that is preceded in the sequence by a |
| * node that is neither a namespace node nor an attribute node. |
| */ |
| XTDE0410, |
| |
| /** |
| * It is a non-recoverable dynamic error if the result sequence |
| * used to construct the content of a document node contains a namespace |
| * node or attribute node. |
| */ |
| XTDE0420, |
| |
| /** |
| * It is a non-recoverable dynamic error if the result sequence |
| * contains two or more namespace nodes having the same name but |
| * different string values (that is, namespace nodes that map the |
| * same prefix to different namespace URIs). |
| */ |
| XTDE0430, |
| |
| /** |
| * It is a non-recoverable dynamic error if the result sequence |
| * contains a namespace node with no name and the element node being |
| * constructed has a null namespace URI (that is, it is an error |
| * to define a default namespace when the element is in no namespace). |
| */ |
| XTDE0440, |
| |
| /** |
| * It is a non-recoverable dynamic error if namespace fixup is performed |
| * on an element that contains among the typed values of the element |
| * and its attributes two values of type xs:QName or xs:NOTATION |
| * containing conflicting namespace prefixes, that is, two values |
| * that use the same prefix to refer to different namespace URIs. |
| */ |
| XTDE0485, |
| |
| /** |
| * It is a recoverable dynamic error if the conflict resolution |
| * algorithm for template rules leaves more than one matching template |
| * rule. Action: The optional recovery action is to select, from |
| * the matching template rules that are left, the one that occurs |
| * last in declaration order. |
| */ |
| XTRE0540, |
| |
| /** |
| * It is a non-recoverable dynamic error if xsl:apply-imports or |
| * xsl:next-match is evaluated when the current template rule is |
| * null. |
| */ |
| XTDE0560, |
| |
| /** |
| * If an optional parameter has no select attribute and has an empty |
| * sequence constructor, and if there is an as attribute, then the |
| * default value of the parameter is an empty sequence. If the empty |
| * sequence is not a valid instance of the required type defined |
| * in the as attribute, then the parameter is treated as a required |
| * parameter, which means that it is a non-recoverable dynamic error |
| * if the caller supplies no value for the parameter. |
| */ |
| XTDE0610, |
| |
| /** |
| * In general, a circularity in a stylesheet is a non-recoverable |
| * dynamic error. |
| */ |
| XTDE0640, |
| |
| /** |
| * In other cases, [with xsl:apply-templates, xsl:apply-imports, |
| * and xsl:next-match, or xsl:call-template with tunnel parameters] |
| * it is a non-recoverable dynamic error if the template that is |
| * invoked declares a template parameter with required="yes" and |
| * no value for this parameter is supplied by the calling instruction. |
| */ |
| XTDE0700, |
| |
| /** |
| * It is a recoverable dynamic error if the name of a constructed |
| * attribute is xml:space and the value is not either default or |
| * preserve. Action: The optional recovery action is to construct |
| * the attribute with the value as requested. |
| */ |
| XTRE0795, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the name attribute [of the xsl:element instruction] is not |
| * a lexical QName. |
| */ |
| XTDE0820, |
| |
| /** |
| * In the case of an xsl:element instruction with no namespace attribute, |
| * it is a non-recoverable dynamic error if the effective value |
| * of the name attribute is a QName whose prefix is not declared |
| * in an in-scope namespace declaration for the xsl:element instruction. |
| */ |
| XTDE0830, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the namespace attribute [of the xsl:element instruction] is |
| * not in the lexical space of the xs:anyURI data type. |
| */ |
| XTDE0835, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the name attribute [of an xsl:attribute instruction] is not |
| * a lexical QName. |
| */ |
| XTDE0850, |
| |
| /** |
| * In the case of an xsl:attribute instruction with no namespace |
| * attribute, it is a non-recoverable dynamic error if the effective |
| * value of the name attribute is the string xmlns. |
| */ |
| XTDE0855, |
| |
| /** |
| * In the case of an xsl:attribute instruction with no namespace |
| * attribute, it is a non-recoverable dynamic error if the effective |
| * value of the name attribute is a lexical QName whose prefix is |
| * not declared in an in-scope namespace declaration for the xsl:attribute |
| * instruction. |
| */ |
| XTDE0860, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the namespace attribute [of the xsl:attribute instruction] |
| * is not in the lexical space of the xs:anyURI data type. |
| */ |
| XTDE0865, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the name attribute [of the xsl:processing-instruction instruction] |
| * is not both an NCName Names and a PITarget XML. |
| */ |
| XTDE0890, |
| |
| /** |
| * It is a non-recoverable dynamic error if the string value of |
| * the new namespace node [created using xsl:namespace] is not valid |
| * in the lexical space of the data type xs:anyURI. [see ERR XTDE0835] |
| */ |
| XTDE0905, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the name attribute [of the xsl:namespace instruction] is neither |
| * a zero-length string nor an NCName Names, or if it is xmlns. |
| */ |
| XTDE0920, |
| |
| /** |
| * It is a non-recoverable dynamic error if the xsl:namespace instruction |
| * generates a namespace node whose name is xml and whose string |
| * value is not http://www.w3.org/XML/1998/namespace, or a namespace |
| * node whose string value is http://www.w3.org/XML/1998/namespace |
| * and whose name is not xml. |
| */ |
| XTDE0925, |
| |
| /** |
| * It is a non-recoverable dynamic error if evaluating the select |
| * attribute or the contained sequence constructor of an xsl:namespace |
| * instruction results in a zero-length string. |
| */ |
| XTDE0930, |
| |
| /** |
| * It is a non-recoverable dynamic error if any undiscarded item |
| * in the atomized sequence supplied as the value of the value attribute |
| * of xsl:number cannot be converted to an integer, or if the resulting |
| * integer is less than 0 (zero). |
| */ |
| XTDE0980, |
| |
| /** |
| * It is a non-recoverable dynamic error if, for any sort key component, |
| * the set of sort key values evaluated for all the items in the |
| * initial sequence, after any type conversion requested, contains |
| * a pair of ordinary values for which the result of the XPath lt |
| * operator is an error. |
| */ |
| XTDE1030, |
| |
| /** |
| * It is a non-recoverable dynamic error if the collation attribute |
| * of xsl:sort (after resolving against the base URI) is not a URI |
| * that is recognized by the implementation as referring to a collation. |
| */ |
| XTDE1035, |
| |
| /** |
| * It is a non-recoverable dynamic error if the collation URI specified |
| * to xsl:for-each-group (after resolving against the base URI) |
| * is a collation that is not recognized by the implementation. |
| * (For notes, [see ERR XTDE1035].) |
| */ |
| XTDE1110, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the regex attribute [of the xsl:analyze-string instruction] |
| * does not conform to the required syntax for regular expressions, |
| * as specified in [Functions and Operators]. If the regular expression |
| * is known statically (for example, if the attribute does not contain |
| * any expressions enclosed in curly brackets) then the processor |
| * may signal the error as a static error. |
| */ |
| XTDE1140, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the flags attribute [of the xsl:analyze-string instruction] |
| * has a value other than the values defined in [Functions and Operators]. |
| * If the value of the attribute is known statically (for example, |
| * if the attribute does not contain any expressions enclosed in |
| * curly brackets) then the processor may signal the error as a |
| * static error. |
| */ |
| XTDE1145, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the regex attribute [of the xsl:analyze-string instruction] |
| * is a regular expression that matches a zero-length string: or |
| * more specifically, if the regular expression $r and flags $f |
| * are such that matches("", $r, $f) returns true. If the regular |
| * expression is known statically (for example, if the attribute |
| * does not contain any expressions enclosed in curly brackets) |
| * then the processor may signal the error as a static error. |
| */ |
| XTDE1150, |
| |
| /** |
| * When a URI reference [supplied to the document function] contains |
| * a fragment identifier, it is a recoverable dynamic error if the |
| * media type is not one that is recognized by the processor, or |
| * if the fragment identifier does not conform to the rules for |
| * fragment identifiers for that media type, or if the fragment |
| * identifier selects something other than a sequence of nodes (for |
| * example, if it selects a range of characters within a text node). |
| * Action: The optional recovery action is to ignore the fragment |
| * identifier and return the document node. |
| */ |
| XTRE1160, |
| |
| /** |
| * It is a non-recoverable dynamic error if a URI [supplied in the |
| * first argument to the unparsed-text function] contains a fragment |
| * identifier, or if it cannot be used to retrieve a resource containing |
| * text. |
| */ |
| XTDE1170, |
| |
| /** |
| * It is a non-recoverable dynamic error if a resource [retrieved |
| * using the unparsed-text function] contains octets that cannot |
| * be decoded into Unicode characters using the specified encoding, |
| * or if the resulting characters are not permitted XML characters. |
| * This includes the case where the processor does not support the |
| * requested encoding. |
| */ |
| XTDE1190, |
| |
| /** |
| * It is a non-recoverable dynamic error if the second argument |
| * of the unparsed-text function is omitted and the processor cannot |
| * infer the encoding using external information and the encoding |
| * is not UTF-8. |
| */ |
| XTDE1200, |
| |
| /** |
| * It is a non-recoverable dynamic error if the value [of the first |
| * argument to the key function] is not a valid QName, or if there |
| * is no namespace declaration in scope for the prefix of the QName, |
| * or if the name obtained by expanding the QName is not the same |
| * as the expanded name of any xsl:key declaration in the stylesheet. |
| * If the processor is able to detect the error statically (for |
| * example, when the argument is supplied as a string literal), |
| * then the processor may optionally signal this as a static error. |
| */ |
| XTDE1260, |
| |
| /** |
| * It is a non-recoverable dynamic error to call the key function |
| * with two arguments if there is no context node, or if the root |
| * of the tree containing the context node is not a document node; |
| * or to call the function with three arguments if the root of the |
| * tree containing the node supplied in the third argument is not |
| * a document node. |
| */ |
| XTDE1270, |
| |
| /** |
| * It is a non-recoverable dynamic error if the name specified as |
| * the $decimal-format-name argument [ to the format-number function] |
| * is not a valid QName, or if its prefix has not been declared |
| * in an in-scope namespace declaration, or if the stylesheet does |
| * not contain a declaration of a decimal-format with a matching |
| * expanded-QName. If the processor is able to detect the error |
| * statically (for example, when the argument is supplied as a string |
| * literal), then the processor may optionally signal this as a |
| * static error. |
| */ |
| XTDE1280, |
| |
| /** |
| * The picture string [supplied to the format-number function] must |
| * conform to the following rules. [ See full specification.] It |
| * is a non-recoverable dynamic error if the picture string does |
| * not satisfy these rules. |
| */ |
| XTDE1310, |
| |
| /** |
| * It is a non-recoverable dynamic error if the syntax of the picture |
| * [used for date/time formatting] is incorrect. |
| */ |
| XTDE1340, |
| |
| /** |
| * It is a non-recoverable dynamic error if a component specifier |
| * within the picture [used for date/time formatting] refers to |
| * components that are not available in the given type of $value, |
| * for example if the picture supplied to the format-time refers |
| * to the year, month, or day component. |
| */ |
| XTDE1350, |
| |
| /** |
| * If the current function is evaluated within an expression that |
| * is evaluated when the context item is undefined, a non-recoverable |
| * dynamic error occurs. |
| */ |
| XTDE1360, |
| |
| /** |
| * It is a non-recoverable dynamic error if the unparsed-entity-uri |
| * function is called when there is no context node, or when the |
| * root of the tree containing the context node is not a document |
| * node. |
| */ |
| XTDE1370, |
| |
| /** |
| * It is a non-recoverable dynamic error if the unparsed-entity-public-id |
| * function is called when there is no context node, or when the |
| * root of the tree containing the context node is not a document |
| * node. |
| */ |
| XTDE1380, |
| |
| /** |
| * It is a non-recoverable dynamic error if the value [supplied |
| * as the $property-name argument to the system-property function] |
| * is not a valid QName, or if there is no namespace declaration |
| * in scope for the prefix of the QName. If the processor is able |
| * to detect the error statically (for example, when the argument |
| * is supplied as a string literal), then the processor may optionally |
| * signal this as a static error. |
| */ |
| XTDE1390, |
| |
| /** |
| * When a transformation is terminated by use of xsl:message terminate="yes", |
| * the effect is the same as when a non-recoverable dynamic error |
| * occurs during the transformation. |
| */ |
| XTMM9000, |
| |
| /** |
| * It is a non-recoverable dynamic error if the argument [passed |
| * to the function-available function] does not evaluate to a string |
| * that is a valid QName, or if there is no namespace declaration |
| * in scope for the prefix of the QName. If the processor is able |
| * to detect the error statically (for example, when the argument |
| * is supplied as a string literal), then the processor may optionally |
| * signal this as a static error. |
| */ |
| XTDE1400, |
| |
| /** |
| * It is a non-recoverable dynamic error if the arguments supplied |
| * to a call on an extension function do not satisfy the rules defined |
| * for that particular extension function, or if the extension function |
| * reports an error, or if the result of the extension function |
| * cannot be converted to an XPath value. |
| */ |
| XTDE1420, |
| |
| /** |
| * When backwards compatible behavior is enabled, it is a non-recoverable |
| * dynamic error to evaluate an extension function call if no implementation |
| * of the extension function is available. |
| */ |
| XTDE1425, |
| |
| /** |
| * It is a non-recoverable dynamic error if the argument [passed |
| * to the type-available function] does not evaluate to a string |
| * that is a valid QName, or if there is no namespace declaration |
| * in scope for the prefix of the QName. If the processor is able |
| * to detect the error statically (for example, when the argument |
| * is supplied as a string literal), then the processor may optionally |
| * signal this as a static error. |
| */ |
| XTDE1428, |
| |
| /** |
| * It is a non-recoverable dynamic error if the argument [passed |
| * to the element-available function] does not evaluate to a string |
| * that is a valid QName, or if there is no namespace declaration |
| * in scope for the prefix of the QName. If the processor is able |
| * to detect the error statically (for example, when the argument |
| * is supplied as a string literal), then the processor may optionally |
| * signal this as a static error. |
| */ |
| XTDE1440, |
| |
| /** |
| * When a processor performs fallback for an extension instruction |
| * that is not recognized, if the instruction element has one or |
| * more xsl:fallback children, then the content of each of the xsl:fallback |
| * children must be evaluated; it is a non-recoverable dynamic error |
| * if it has no xsl:fallback children. |
| */ |
| XTDE1450, |
| |
| /** |
| * It is a non-recoverable dynamic error if the effective value |
| * of the format attribute [of an xsl:result-document element] is |
| * not a valid lexical QName, or if it does not match the expanded-QName |
| * of an output definition in the stylesheet. If the processor is |
| * able to detect the error statically (for example, when the format |
| * attribute contains no curly brackets), then the processor may |
| * optionally signal this as a static error. |
| */ |
| XTDE1460, |
| |
| /** |
| * It is a non-recoverable dynamic error to evaluate the xsl:result-document |
| * instruction in temporary output state. |
| */ |
| XTDE1480, |
| |
| /** |
| * It is a non-recoverable dynamic error for a transformation to |
| * generate two or more final result trees with the same URI. |
| */ |
| XTDE1490, |
| |
| /** |
| * It is a recoverable dynamic error for a transformation to generate |
| * two or more final result trees with URIs that identify the same |
| * physical resource. The optional recovery action is implementation-dependent, |
| * since it may be impossible for the processor to detect the error. |
| */ |
| XTRE1495, |
| |
| /** |
| * It is a recoverable dynamic error for a stylesheet to write to |
| * an external resource and read from the same resource during a |
| * single transformation, whether or not the same URI is used to |
| * access the resource in both cases. Action: The optional recovery |
| * action is implementation-dependent: implementations are not required |
| * to detect the error condition. Note that if the error is not |
| * detected, it is undefined whether the document that is read from |
| * the resource reflects its state before or after the result tree |
| * is written. |
| */ |
| XTRE1500, |
| |
| /** |
| * It is a recoverable dynamic error if an xsl:value-of or xsl:text |
| * instruction specifies that output escaping is to be disabled |
| * and the implementation does not support this. Action: The optional |
| * recovery action is to ignore the disable-output-escaping attribute. |
| */ |
| XTRE1620, |
| |
| /** |
| * It is a recoverable dynamic error if an xsl:value-of or xsl:text |
| * instruction specifies that output escaping is to be disabled |
| * when writing to a final result tree that is not being serialized. |
| * Action: The optional recovery action is to ignore the disable-output-escaping |
| * attribute. |
| */ |
| XTRE1630, |
| |
| /** |
| * A basic XSLT processor must raise a non-recoverable dynamic error |
| * if the input to the processor includes a node with a type annotation |
| * other than xs:untyped or xs:untypedAtomic, or an atomic value |
| * of a type other than those which a basic XSLT processor supports. |
| */ |
| XTDE1665 |
| |
| }; |
| |
| /** |
| * Issues a warning, should not be used excessively. This can |
| * be used to communicate that a certain implementation defined |
| * feature is unsupported or that a certain expression most likely |
| * doesn't do what the users wants, to name a few examples. |
| * |
| * @see <a href="http://www.w3.org/TR/xpath20/#errors">XML Path Language (XPath) 2.0, |
| * 2.3 Error Handling</a> |
| * @param message the message to be read by the user. |
| * @param sourceLocation the location of where the warning originates from. |
| */ |
| void warning(const QString &message, const QSourceLocation &sourceLocation = QSourceLocation()); |
| |
| /** |
| * Issues an error. May be used at the static analysis phase or |
| * the dynamic evaluation phase. |
| * |
| * For SourceLocationReflection instances, the overload taking an SouourceLocationReflection should be used. |
| * |
| * @see <a href="http://www.w3.org/TR/xpath20/#errors">XML Path Language (XPath) 2.0, |
| * 2.3 Error Handling</a> |
| * @param message the message to be read by the user. |
| * @param errorCode identifies the error condition, as described |
| * @param sourceLocation the location of where the error originates from |
| * in "XML Path Language (XPath) 2.0" section "G Error Conditions" |
| */ |
| void error(const QString &message, |
| const ReportContext::ErrorCode errorCode, |
| const QSourceLocation &sourceLocation); |
| |
| /** |
| * Overload. |
| * |
| * Same as the above, but passes the SourceLocationReflection as reference for error reporting. |
| */ |
| void error(const QString &message, |
| const ReportContext::ErrorCode errorCode, |
| const SourceLocationReflection *const reflection); |
| |
| /** |
| * Issues an error which is not identified in the XPath specifications. This function |
| * is among other things used for implementing the <tt>fn:error()</tt> function. |
| */ |
| void error(const QString &message, |
| const QXmlName qName, |
| const SourceLocationReflection *const r); |
| |
| /** |
| * @return the QAbstractMessageHandler which functions such as warning() and |
| * error() should submit messages to. This function |
| * may never return @c null; a valid QAbstractMessageHandler pointer must always be returned. |
| */ |
| virtual QAbstractMessageHandler *messageHandler() const = 0; |
| |
| virtual NamePool::Ptr namePool() const = 0; |
| |
| /** |
| * Returns a string representation of the error code @p code. |
| * |
| * @see ReportContext::ErrorCode |
| * @param errorCode identifies the error condition, as described |
| * in <a href="http://www.w3.org/TR/xpath20/#id-errors">XML Path |
| * Language (XPath) 2.0, G Error Conditions</a> |
| */ |
| static QString codeToString(const ReportContext::ErrorCode errorCode); |
| |
| /** |
| * @returns the error code part of @p typeURI and sets @p uri to the error namespace. Note |
| * that the error namespace not necessarily is the namespace for XPath and |
| * XQuery errors, http://www.w3.org/2005/xqt-errors, but can be user defined. |
| */ |
| static QString codeFromURI(const QString &typeURI, |
| QString &uri); |
| |
| /** |
| * @short Returns the source location applying for @p reflection. |
| */ |
| virtual QSourceLocation locationFor(const SourceLocationReflection *const reflection) const = 0; |
| |
| /** |
| * Resolves @p relative against @p baseURI, possibly using a URI resolver. |
| */ |
| QUrl resolveURI(const QUrl &relative, |
| const QUrl &baseURI) const; |
| |
| /** |
| * @short The URI resolver in use. |
| * |
| * If no URI resolver is in use, a @c null pointer is returned. |
| * |
| * @note You should probably use resolveURI(), which handles the case of |
| * when uriResolver() is @c null. |
| */ |
| virtual const QAbstractUriResolver *uriResolver() const = 0; |
| |
| private: |
| void createError(const QString &description, |
| const QtMsgType type, |
| const QUrl &id, |
| const QSourceLocation &sourceLocation) const; |
| static inline QString finalizeDescription(const QString &desc); |
| QSourceLocation lookupSourceLocation(const SourceLocationReflection *const ref) const; |
| |
| Q_DISABLE_COPY(ReportContext) |
| }; |
| |
| /** |
| * @short This is the class type that is being thrown when a query error occur. |
| * |
| * @relates ReportContext |
| */ |
| typedef bool Exception; |
| } |
| |
| QT_END_NAMESPACE |
| |
| QT_END_HEADER |
| |
| #endif |