This specification describes the p:validate-with-relax-ng
,
p:validate-with-schematron
, p:validate-with-xml-schema
,
p:validate-with-nvdl
, p:validate-with-json-schema
,
and p:validate-with-dtd
steps. Each is independently optional. A machine-readable description of
these steps may be found in
steps.xpl.
Familiarity with the general nature of [XProc 3.1] steps is assumed.
As described in PSVIs in XProc in XProc 3.0: An XML Pipeline Language,
steps may not produce PSVI output unless that behavior is explicitly
described. In this specification, the steps that may produce PSVI
output are p:validate-with-nvdl
, p:validate-with-schematron
and p:validate-with-xml-schema
.
All steps in this specification provide a boolean option assert-valid
. If any of the validated
documents is found to be invalid according to the respective schema, and possibly other parameters that influence
determination of validity, a dynamic error is raised.
Note
Historically, the validation steps (apart from p:validate-with-schematron
) could only report errors
by setting assert-valid
to true
and catching the errors. A c:errors
document on the error
port of the corresponding p:catch
recovery pipeline had to be sent to an
output, either verbatim or after postprocessing. Now, if assert-valid
is false
,
an XVRL document will be available on the report
port of the validation step. It uses the XVRL severity
vocabulary to indicate whether the validation failed, and to which degree. This allows more nuance in reporting
errors. Previously, assert-valid="true"
on p:validate-with-schematron
would always
throw an error even if the reported findings were only intended as less severe, for example if the schema author used
info
or warning
in sch:report/@role
.
If no such error is raised, each step generates at least one validation report document on its
report
port. Unless another format is requested, the mandatory report document for all steps
except p:validate-with-schematron
should be an [XVRL] document. A report format may be requested
by the report-format
option. The supported values for the report-format
option are implementation-defined. A processor should at least support
the value “xvrl
” for the XML validation steps and “svrl
” for
p:validate-with-schematron
.
It is a dynamic error (err:XC0117
) if a report-format
option
was specified that the processor does not support.
If a step performs multiple validations on a single document (for example, embedded Schematron validations in a Relax NG schema), all individual XVRL reports need to be consolidated into a single XVRL report by the step.
Each of the validation steps has a parameters
option. The parameters supported by the
validation steps and their semantics are
implementation-defined, and they can be different for each validation step. A special key in the
c
namespace, http://www.w3.org/ns/xproc-step
, called
c:compile
, can hold a map itself that controls schema compilation.
Schema compilation is, for example, the process of converting a Schematron schema into an XSLT
stylesheet. The c:compile
map will be used as parameters for the compilation process.
Map entries in the xvrl
namespace, http://www.xproc.org/ns/xvrl
will be passed as parameters to the XVRL generation process. XProc implementations that implement any of the XML validation steps
should support the basic parameters that are defined in the [XVRL]
specification, xvrl:default-severity
, xvrl:language
,
xvrl:map-to-severity
, and xvrl:xpath-notation
.
The p:validate-with-nvdl
step applies [NVDL] validation to the
source
document.
Summary
Input port | Primary | Sequence | Content types | Default binding |
---|---|---|---|---|
source | ✔ | xml html | ||
nvdl | xml | |||
schemas | ✔ | text xml | p:empty |
Output port | Primary | Sequence | Content types | Default binding |
---|---|---|---|---|
result | ✔ | xml html | ||
report | ✔ | xml json |
Option name | Type | Default value |
---|---|---|
assert-valid | xs:boolean | true() |
parameters | map(xs:QName,item()*)? | () |
report-format | xs:string | 'xvrl' |
Errors
Error code | Description |
---|---|
err:XC0053 | It is a dynamic error if the assert-valid option on p:validate-with-nvdl is true and the input document is not valid. |
err:XC0154 | It is a dynamic error if the document supplied on nvdl port is not a valid NVDL document. |
Declaration
<p:declare-step
type
="
p:validate-with-nvdl
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:input
port
="
nvdl
"
content-types
="
xml
"
/>
<p:input
port
="
schemas
"
sequence
="
true
"
content-types
="
text xml
"
>
<p:empty/>
</p:input>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
<p:option
name
="
report-format
"
select
="
'xvrl'
"
as
="
xs:string
"
/>
<p:option
name
="
parameters
"
as
="
map(xs:QName,item()*)?
"
/>
</p:declare-step>
The source
document is validated using the namespace dispatching rules contained in the
nvdl
document. It is a dynamic error (err:XC0154
)
if the document supplied on nvdl
port is not a valid NVDL document.
The dispatching rules may contain URI references that point to the actual schemas to be
used. As long as these schemas are accessible, it is not necessary to pass anything on the
schemas port. However, if one or more schemas are provided on the schemas
port,
then these schemas should be used in validation.
It is a dynamic error (err:XC0053
) if the assert-valid
option on
p:validate-with-nvdl
is
true
and the input document is not valid.
The output from this step is a copy of the input. The output of this step may include PSVI annotations.
Document properties
The p:validate-with-relax-ng
step applies [RELAX NG] validation
to the source
document.
Summary
Input port | Primary | Sequence | Content types |
---|---|---|---|
source | ✔ | xml html | |
schema | text xml |
Output port | Primary | Sequence | Content types |
---|---|---|---|
result | ✔ | xml html | |
report | ✔ | xml json |
Option name | Type | Default value |
---|---|---|
assert-valid | xs:boolean | true() |
dtd-attribute-values | xs:boolean | false() |
dtd-id-idref-warnings | xs:boolean | false() |
parameters | map(xs:QName,item()*)? | () |
report-format | xs:string | 'xvrl' |
Errors
Error code | Description |
---|---|
err:XC0153 | It is a dynamic error if the document supplied on schema port cannot be interpreted as an RELAX NG Grammar. |
err:XC0155 | It is a dynamic error if the assert-valid option on p:validate-with-relax-ng is true and the input document is not valid. |
Implementation details
Implementation | Description |
---|---|
Defined | Support for is implementation-defined. |
Declaration
<p:declare-step
type
="
p:validate-with-relax-ng
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:input
port
="
schema
"
content-types
="
text xml
"
/>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
dtd-attribute-values
"
select
="
false()
"
as
="
xs:boolean
"
/>
<p:option
name
="
dtd-id-idref-warnings
"
select
="
false()
"
as
="
xs:boolean
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
<p:option
name
="
report-format
"
select
="
'xvrl'
"
as
="
xs:string
"
/>
<p:option
name
="
parameters
"
as
="
map(xs:QName,item()*)?
"
/>
</p:declare-step>
The values of the dtd-attribute-values
and dtd-id-idref-warnings
options
must be booleans.
If the schema
document has an XML media type, then
it must be interpreted as a RELAX NG Grammar. If
the schema
document has a text media type, then it
must be interpreted as a
[RELAX NG
Compact Syntax] document for validation.
It is a dynamic error (err:XC0153
)
if the document supplied on schema
port cannot be interpreted
as an RELAX NG Grammar.
If the dtd-attribute-values
option is
true
, then the attribute value defaulting conventions of
[RELAX NG DTD Compatibility] are also applied.
If the dtd-id-idref-warnings
option is
true
, then the validator should
treat a schema that is incompatible with the ID/IDREF/IDREFs feature
of [RELAX NG DTD Compatibility] as if the document
was invalid.
It is a dynamic error (err:XC0155
)
if the assert-valid
option on p:validate-with-relax-ng
is true
and the input document is not valid.
The output from this step is a copy of the input, possibly augmented by application of the [RELAX NG DTD Compatibility]. The output of this step may include PSVI annotations.
Support for [RELAX NG DTD Compatibility] is implementation-defined.
Document properties
The p:validate-with-schematron
step applies
[Schematron]
processing to the source
document.
Summary
Input port | Primary | Sequence | Content types |
---|---|---|---|
source | ✔ | xml html | |
schema | xml |
Output port | Primary | Sequence | Content types |
---|---|---|---|
result | ✔ | xml html | |
report | ✔ | xml json |
Option name | Type | Default value |
---|---|---|
assert-valid | xs:boolean | true() |
parameters | map(xs:QName,item()*)? | () |
phase | xs:string | '#DEFAULT' |
report-format | xs:string | 'svrl' |
Errors
Error code | Description |
---|---|
err:XC0054 | It is a dynamic error if the assert-valid option is true and any Schematron assertions fail. |
err:XC0151 | It is a dynamic error if the document supplied on schema port is not a valid Schematron document. |
Implementation details
Implementation | Description |
---|---|
Defined | How the Schematron implementation is selected is implementation-defined. |
Defined | The list of supported Schematron implementations and their associated values is implementation-defined. |
Defined | Which parameters the c:compile map supports for a given Schematron implementation is implementation-defined. |
Defined | Which parameters this conversion from native reporting format to XVRL supports is implementation-defined. |
Declaration
<p:declare-step
type
="
p:validate-with-schematron
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:input
port
="
schema
"
content-types
="
xml
"
/>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
parameters
"
as
="
map(xs:QName,item()*)?
"
/>
<p:option
name
="
phase
"
select
="
'#DEFAULT'
"
as
="
xs:string
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
<p:option
name
="
report-format
"
select
="
'svrl'
"
as
="
xs:string
"
/>
</p:declare-step>
It is a dynamic error (err:XC0151
)
if the document supplied on schema
port is not a valid Schematron
document.
It is a dynamic error (err:XC0054
)
if the assert-valid
option is true
and any Schematron assertions fail.
Note
A Schematron validation with assert-valid="true"
will fail if any validation message is
produced by sch:assert
or sch:report
, even if the severity level of the failed assertion or
the successful report is below a certain threshold, for example if there is only an info
message. (The severity is conventionally conveyed by the @role
attribute on sch:assert
or
sch:report
.)
The value of the phase
option identifies the
Schematron validation phase with which validation begins.
The parameters
option provides name/value pairs which
correspond to Schematron external variables, to parameters that influence
code generation, or to parameters that influence SVRL to XVRL conversion.
There are multiple Schematron implementations. How the Schematron implementation is selected is
implementation-defined. A processor might select an implementation based on the
schema’s queryBinding
attribute and/or provide configuration options. In addition,
the special parameter map entry c:implementation
(value: QName) may be used to select a
Schematron implementation that the processor supports. The list of supported Schematron implementations and
their associated values is implementation-defined. If a requested implementation
is not available, the processor may throw an error or select another implementation.
The parameters
map may contain two special entries, c:compile
and
c:xvrl
, both are maps. If a code-generating implementation such as [Schematron Skeleton] is used, the entries of the c:compile
map, for example
allow-foreign
, will be passed to the code generator.
Which parameters the
c:compile
map supports for a given Schematron implementation is
implementation-defined.
If the Schematron implementation produces SVRL by default, the SVRL to XVRL conversion can be influenced by the
entries of the c:xvrl
map. The same map, with potentially another set of allowed keys and
values, can be used to influence XVRL generation from another reporting language.
Which parameters this conversion from native reporting format to XVRL supports is
implementation-defined.
All other parameters of the parameters
option will be passed to the generated code if applicable,
or to a hypothetical native Schematron validator that does without code generation.
The result
output from this step is a copy of the
input.
The output of this step may include PSVI annotations.
Document properties
The p:validate-with-xml-schema
step applies
[W3C XML Schema: Part 1]
validity assessment to the source
input.
Summary
Input port | Primary | Sequence | Content types |
---|---|---|---|
source | ✔ | xml html | |
schema | ✔ | xml |
Output port | Primary | Sequence | Content types |
---|---|---|---|
result | ✔ | xml html | |
report | ✔ | xml json |
Option name | Type | Values | Default value |
---|---|---|---|
assert-valid | xs:boolean | true() | |
mode | xs:string | ('strict','lax') | 'strict' |
parameters | map(xs:QName,item()*)? | () | |
report-format | xs:string | 'xvrl' | |
try-namespaces | xs:boolean | false() | |
use-location-hints | xs:boolean | false() | |
version | xs:string? | () |
Errors
Error code | Description |
---|---|
err:XC0011 | It is a dynamic error if the specified schema version is not available. |
err:XC0055 | It is a dynamic error if the implementation does not support the specified mode. |
err:XC0152 | It is a dynamic error if the document supplied on schema port is not a valid XML schema document. |
err:XC0156 | It is a dynamic error if the assert-valid option on p:validate-with-xml-schema is true and the input document is not valid. |
Implementation details
Implementation | Description |
---|---|
Defined | It is implementation-defined if the documents supplied on the schemas port are considered when resolving xs:include elements in the schema documents provided. |
Declaration
<p:declare-step
type
="
p:validate-with-xml-schema
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:input
port
="
schema
"
sequence
="
true
"
content-types
="
xml
"
/>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
use-location-hints
"
select
="
false()
"
as
="
xs:boolean
"
/>
<p:option
name
="
try-namespaces
"
select
="
false()
"
as
="
xs:boolean
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
<p:option
name
="
parameters
"
as
="
map(xs:QName,item()*)?
"
/>
<p:option
name
="
mode
"
select
="
'strict'
"
values
="
('strict','lax')
"
/>
<!--
string -->
<p:option
name
="
version
"
as
="
xs:string?
"
/>
<p:option
name
="
report-format
"
select
="
'xvrl'
"
as
="
xs:string
"
/>
</p:declare-step>
It is a dynamic error (err:XC0152
)
if the document supplied on schema
port is not a valid XML schema
document.
The values of the use-location-hints
,
try-namespaces
, and
assert-valid
options
must be boolean.
The value of the mode
option
must be an NMTOKEN whose value is either
“strict
” or “lax
”.
Validation is performed against the set of schemas represented
by the documents on the schema
port. These schemas must
be used in preference to any schema locations provided by schema
location hints encountered during schema validation, that is, schema
locations supplied for xs:import
or
xsi:schema-location
, or determined by
schema-processor-defined namespace-based strategies, for the
namespaces covered by the documents available on the schemas port.
If xs:include
elements occur within the supplied
schema documents, they are treated like any other
external documents (see [XProc 3.1]).
It is
implementation-defined if the documents supplied
on the schemas
port are considered when resolving
xs:include
elements in the schema documents provided.
The use-location-hints
and
try-namespaces
options allow the pipeline author to
control how the schema processor should attempt to locate schema
documents necessary but not provided on the schema
port. Any schema documents provided on the schema
port
must be used in preference to schema documents
located by other means.
If the use-location-hints
option is
“true
”, the processor should
make use of schema location hints to locate schema documents. If the
option is “false
”, the processor
should ignore any such hints.
If the try-namespaces
option is
“true
”, the processor should
attempt to dereference the namespace URI to locate schema documents.
If the
option is “false
”, the processor
should not dereference namespace URIs.
The mode
option allow the pipeline author to
control how schema validation begins. The “strict
”
mode means that the document element must be declared and
schema-valid, otherwise it will be treated as invalid. The
“lax
” mode means that the
absence of a declaration for the document element does not itself
count as an unsuccessful outcome of validation.
If the step specifies a version
, then that version
of XML Schema must be used to process the validation.
It is a
dynamic error (err:XC0011
) if the specified schema version
is not available. If the step does not specify a version, the
implementation may use any version it has available and may use any means
to determine what version to use, including, but not limited to,
examining the version of the schema(s).
It is a dynamic error (err:XC0156
)
if the assert-valid
option on p:validate-with-xml-schema
is true
and the input document is not valid. If the assert-valid
option is false
, it is not an error for the document
to be invalid. In this case, if the implementation does not
support the PSVI, p:validate-with-xml-schema
is essentially
just an “identity” step, but if the implementation does
support the PSVI, then the resulting document will have additional type
information (at least for the subtrees that are valid).
When XML Schema validation assessment
is performed, the processor is invoked in the mode specified by the
mode
option.
It is a dynamic error (err:XC0055
)
if the implementation does not support the specified mode.
The result
of the assessment is a document with the
Post-Schema-Validation-Infoset (PSVI) ([W3C XML Schema: Part 1]) annotations, if the pipeline implementation
supports such annotations. If not, the input document is reproduced
with any defaulting of attributes and elements performed as specified
by the XML Schema recommendation.
Document properties
The p:validate-with-json-schema
step applies
a JSON schema validation (as defined in [JSON schema] and
other publications) to the source
input.
Summary
Input port | Primary | Sequence | Content types |
---|---|---|---|
source | ✔ | json | |
schema | json |
Output port | Primary | Sequence | Content types |
---|---|---|---|
result | ✔ | json | |
report | ✔ | xml json |
Option name | Type | Default value |
---|---|---|
assert-valid | xs:boolean | true() |
default-version | xs:string? | () |
parameters | map(xs:QName,item()*)? | () |
report-format | xs:string | 'xvrl' |
Errors
Error code | Description |
---|---|
err:XC0163 | It is a dynamic error if the selected version is not supported. |
err:XC0164 | It is a dynamic error if the document supplied on schema port is not a valid JSON schema document in the selected version. |
err:XC0165 | It is a dynamic error if the assert-valid option on p:validate-with-json-schema is true and the input document is not valid. |
Implementation details
Implementation | Description |
---|---|
Defined | If the schema does not specify a version and option default-version is empty, the version used is implementation-defined. |
Declaration
<p:declare-step
type
="
p:validate-with-json-schema
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
json
"
/>
<p:input
port
="
schema
"
sequence
="
false
"
content-types
="
json
"
/>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
json
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
<p:option
name
="
default-version
"
as
="
xs:string?
"
/>
<p:option
name
="
parameters
"
as
="
map(xs:QName,item()*)?
"
/>
<p:option
name
="
report-format
"
select
="
'xvrl'
"
as
="
xs:string
"
/>
</p:declare-step>
The option default-version
can be used to
control the schema's version in case it does not specify one itself. If
the schema does not specify a version and option default-version
is empty, the version used is implementation-defined.
It is a dynamic error (err:XC0163
)
if the selected version is not supported.
It is a dynamic error (err:XC0164
)
if the document supplied on schema
port is not a valid JSON schema
document in the selected version.
It is a dynamic error (err:XC0165
)
if the assert-valid
option on p:validate-with-json-schema
is true
and the input document is not valid.
The output from this step is a copy of the input.
Document properties
The p:validate-with-dtd
step validates XML with a DTD.
Summary
Input port | Primary | Sequence | Content types |
---|---|---|---|
source | ✔ | xml html |
Output port | Primary | Sequence | Content types |
---|---|---|---|
result | ✔ | xml html | |
report | ✔ | xml json |
Option name | Type | Default value |
---|---|---|
assert-valid | xs:boolean | true() |
report-format | xs:string | 'xvrl' |
serialization | map(xs:QName,item()*)? | () |
Errors
Error code | Description |
---|---|
err:XC0210 | It is a dynamic error if the assert-valid option on p:validate-with-dtd is true and the input document is not valid. |
Declaration
<p:declare-step
type
="
p:validate-with-dtd
"
>
<p:input
port
="
source
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
result
"
primary
="
true
"
content-types
="
xml html
"
/>
<p:output
port
="
report
"
sequence
="
true
"
content-types
="
xml json
"
/>
<p:option
name
="
report-format
"
select
="
'xvrl'
"
as
="
xs:string
"
/>
<p:option
name
="
serialization
"
as
="
map(xs:QName,item()*)?
"
/>
<p:option
name
="
assert-valid
"
select
="
true()
"
as
="
xs:boolean
"
/>
</p:declare-step>
DTD validation differs from the other XML validation technologies in that it is applied during parsing. It isn’t possible to validate an XML data model with a DTD. This step necessarily serializes and reparses.
The p:validate-with-dtd
step serializes the document on the
source
port and parses the serialization with a validating XML
parser.
The serialization
option can be used to control the
serialization. If the document to be stored has a “serialization” property, the
serialization is controlled by the merger of the two maps where the entries in
the “serialization” property take precedence. Serialization is described in
[XProc 3.1].
Any warning or error messages produced by the parser will
appear on the report
port.
Note
The serialization options must include at least the
doctype-system
property (without a system identifier, the
document cannot be successfully parsed with a validating parser).
It is a dynamic error (err:XC0210
)
if the assert-valid
option on p:validate-with-dtd
is true
and the input document is not valid.
The output from this step is a copy of the input. If validation was successful, the output may have been augmented by the DTD. (For example, default attributes may have been added.)
Using an internal subset
To validate a document with an internal subset, construct a text document
that is a syntactically valid XML serialization with the internal
subset, use p:cast-content-type
to create an XML document,
and then validate the resulting document with this step.
Document properties
These steps can raise dynamic errors.
[Definition: A dynamic error is one which occurs while a pipeline is being evaluated.] Examples of dynamic errors include references to URIs that cannot be resolved, steps which fail, and pipelines that exhaust the capacity of an implementation (such as memory or disk space). For a more complete discussion of dynamic errors, see Dynamic Errors in XProc 3.0: An XML Pipeline Language.
If a step fails due to a dynamic error, failure propagates
upwards until either a p:try
is encountered or the entire
pipeline fails. In other words, outside of a p:try
, step
failure causes the entire pipeline to fail.
The following errors can be raised by this step:
err:XC0011
It is a dynamic error if the specified schema version is not available.
err:XC0053
It is a dynamic error if the assert-valid option on p:validate-with-nvdl is true and the input document is not valid.
See: Validate with NVDL
err:XC0054
It is a dynamic error if the assert-valid option is true and any Schematron assertions fail.
err:XC0055
It is a dynamic error if the implementation does not support the specified mode.
err:XC0117
It is a dynamic error if a report-format option was specified that the processor does not support.
err:XC0151
It is a dynamic error if the document supplied on schema port is not a valid Schematron document.
err:XC0152
It is a dynamic error if the document supplied on schema port is not a valid XML schema document.
err:XC0153
It is a dynamic error if the document supplied on schema port cannot be interpreted as an RELAX NG Grammar.
err:XC0154
It is a dynamic error if the document supplied on nvdl port is not a valid NVDL document.
See: Validate with NVDL
err:XC0155
It is a dynamic error if the assert-valid option on p:validate-with-relax-ng is true and the input document is not valid.
err:XC0156
It is a dynamic error if the assert-valid option on p:validate-with-xml-schema is true and the input document is not valid.
err:XC0163
It is a dynamic error if the selected version is not supported.
err:XC0164
It is a dynamic error if the document supplied on schema port is not a valid JSON schema document in the selected version.
err:XC0165
It is a dynamic error if the assert-valid option on p:validate-with-json-schema is true and the input document is not valid.
err:XC0210
It is a dynamic error if the assert-valid option on p:validate-with-dtd is true and the input document is not valid.
See: Validate with DTD
A. Conformance
Conformant processors must implement all of the features described in this specification except those that are explicitly identified as optional.
Some aspects of processor behavior are not completely specified; those features are either implementation-dependent or implementation-defined.
[Definition: An implementation-dependent feature is one where the implementation has discretion in how it is performed. Implementations are not required to document or explain how implementation-dependent features are performed.]
[Definition: An implementation-defined feature is one where the implementation has discretion in how it is performed. Conformant implementations must document how implementation-defined features are performed.]
The following features are implementation-defined:
- The supported values for the report-format option are implementation-defined. A processor should at least support the value “xvrl” for the XML validation steps and “svrl” for p:validate-with-schematron. See Section 2, “Common Options and Outputs”.
- The parameters supported by the validation steps and their semantics are implementation-defined, and they can be different for each validation step. See Section 2, “Common Options and Outputs”.
- Support for is implementation-defined. See Section 3.2, “Validate with RELAX NG”.
- How the Schematron implementation is selected is implementation-defined. See Section 3.3, “Validate with Schematron”.
- The list of supported Schematron implementations and their associated values is implementation-defined. See Section 3.3, “Validate with Schematron”.
- Which parameters the c:compile map supports for a given Schematron implementation is implementation-defined. See Section 3.3, “Validate with Schematron”.
- Which parameters this conversion from native reporting format to XVRL supports is implementation-defined. See Section 3.3, “Validate with Schematron”.
- It is implementation-defined if the documents supplied on the schemas port are considered when resolving xs:include elements in the schema documents provided. See Section 3.4, “Validate with XML Schema”.
- If the schema does not specify a version and option default-version is empty, the version used is implementation-defined. See Section 3.5, “Validate with JSON schema”.
B. References
[XProc 3.1] XProc 3.1: An XML Pipeline Language. Norman Walsh, Achim Berndzen, Gerrit Imsieke and Erik Siegel, editors.
[XVRL] Extensible Validation Reporting Language 2019.
[RELAX NG] ISO/IEC JTC 1/SC 34. ISO/IEC 19757-2:2008(E) Document Schema Definition Language (DSDL) -- Part 2: Regular-grammar-based validation -- RELAX NG 2008.
[Schematron] ISO/IEC JTC 1/SC 34. ISO/IEC 19757-3:2016(E) Document Schema Definition Languages (DSDL) — Part 3: Rule-based validation — Schematron 2016.
[NVDL] ISO/IEC JTC 1/SC 34. ISO/IEC 19757-4:2006(E) Document Schema Definition Languages (DSDL) — Part 4: Namespace-based Validation Dispatching Language (NVDL) 2006.
[Schematron Skeleton] Schematron “Skeleton” Implementation 2017.
[RELAX NG Compact Syntax] ISO/IEC JTC 1/SC 34. ISO/IEC 19757-2:2003/Amd 1:2006 Document Schema Definition Languages (DSDL) — Part 2: Grammar-based validation — RELAX NG AMENDMENT 1 Compact Syntax 2006.
[RELAX NG DTD Compatibility] RELAX NG DTD Compatibility. OASIS Committee Specification. 3 December 2001.
[W3C XML Schema: Part 1] XML Schema Part 1: Structures Second Edition. Henry S. Thompson, David Beech, Murray Maloney, et. al., editors. World Wide Web Consortium, 28 October 2004.
[JSON schema] JSON Schema Validation: A Vocabulary for Structural Validation of JSON. A.Wright, H. Andrews and B. Hutton, editors. Internet Engineering Task Force. June, 2022.
C. Glossary
- dynamic error
A dynamic error is one which occurs while a pipeline is being evaluated.
- implementation-defined
An implementation-defined feature is one where the implementation has discretion in how it is performed. Conformant implementations must document how implementation-defined features are performed.
- implementation-dependent
An implementation-dependent feature is one where the implementation has discretion in how it is performed. Implementations are not required to document or explain how implementation-dependent features are performed.
D. Change log
This appendix catalogs recent non-editorial changes.
-
Corrected an error in the sequence type for the
default-version
option onp:validate-with-json-schema
to allow it to be optional. -
Added the
p:validate-with-dtd
step.
E. Ancillary files
This specification includes by reference a number of ancillary files.
- steps.xpl
-
An XProc step library for the declared steps.