diff options
| author | Qt by Nokia <qt-info@nokia.com> | 2011-04-27 12:05:43 +0200 |
|---|---|---|
| committer | axis <qt-info@nokia.com> | 2011-04-27 12:05:43 +0200 |
| commit | e1b2c9deb5943faae2b29be6a5c006f75bb73f06 (patch) | |
| tree | fc79e45367c0a8fc71185e9afc33f7503a58653c /src/xmlpatterns/environment/qreportcontext_p.h | |
| download | qtxmlpatterns-e1b2c9deb5943faae2b29be6a5c006f75bb73f06.tar.gz | |
Initial import from the monolithic Qt.
This is the beginning of revision history for this module. If you
want to look at revision history older than this, please refer to the
Qt Git wiki for how to use Git history grafting. At the time of
writing, this wiki is located here:
http://qt.gitorious.org/qt/pages/GitIntroductionWithQt
If you have already performed the grafting and you don't see any
history beyond this commit, try running "git log" with the "--follow"
argument.
Branched from the monolithic repo, Qt master branch, at commit
896db169ea224deb96c59ce8af800d019de63f12
Diffstat (limited to 'src/xmlpatterns/environment/qreportcontext_p.h')
| -rw-r--r-- | src/xmlpatterns/environment/qreportcontext_p.h | 2464 |
1 files changed, 2464 insertions, 0 deletions
diff --git a/src/xmlpatterns/environment/qreportcontext_p.h b/src/xmlpatterns/environment/qreportcontext_p.h new file mode 100644 index 0000000..067c1d3 --- /dev/null +++ b/src/xmlpatterns/environment/qreportcontext_p.h @@ -0,0 +1,2464 @@ +/**************************************************************************** +** +** 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$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, 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. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $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 |