Project

Profile

Help

How to connect?
Download (103 KB) Statistics
| Branch: | Tag: | Revision:

he / tags / 9.6.0.8 / samples / config / annotatedConfig.xsd @ 02f8308b

1
<?xml version="1.0" encoding="UTF-8"?>
2
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
3
           xmlns:saxon="http://saxon.sf.net/"
4
           xmlns:c="http://saxon.sf.net/ns/configuration"
5
           elementFormDefault="qualified"
6
           targetNamespace="http://saxon.sf.net/ns/configuration">
7
   <xs:import namespace="http://saxon.sf.net/" schemaLocation="saxon-attributes.xsd"/>
8

    
9
   <xs:element name="configuration">
10
      <xs:complexType>
11
         <xs:all>
12

    
13
            <xs:element ref="c:global" minOccurs="0"/>
14

    
15
            <xs:element ref="c:serialization" minOccurs="0"/>
16

    
17
            <xs:element ref="c:collations" minOccurs="0"/>
18

    
19
            <xs:element ref="c:localizations" minOccurs="0"/>
20

    
21
            <xs:element ref="c:xslt" minOccurs="0"/>
22

    
23
            <xs:element ref="c:xquery" minOccurs="0"/>
24

    
25
            <xs:element ref="c:xsd" minOccurs="0"/>
26

    
27
            <xs:element ref="c:resources" minOccurs="0"/>
28
         </xs:all>
29
         <xs:attribute name="edition" use="optional" type="c:editionType">
30
            <xs:annotation>
31
               <xs:documentation> Defines which Saxon edition is to be used. </xs:documentation>
32
            </xs:annotation>
33
         </xs:attribute>
34
      </xs:complexType>
35
   </xs:element>
36

    
37
   <xs:element name="global">
38
      <xs:annotation>
39
         <xs:documentation> Defines properties of the global configuration. </xs:documentation>
40
      </xs:annotation>
41
      <xs:complexType>
42
         <xs:attribute name="allowExternalFunctions" use="optional" type="xs:boolean">
43
            <xs:annotation>
44
               <xs:documentation>
45
                  <p>ALLOW_EXTERNAL_FUNCTIONS determines whether calls to reflexive external functions are
46
                allowed. More specifically, if set to <b>false</b> it disallows all of the
47
                following:</p>
48
                  <ul>
49
                     <li>Calls to reflexive Java extension functions</li>
50
                     <li>Use of the XSLT <code>system-property()</code> function to access Java system
51
                    properties</li>
52
                     <li>Use of a relative URI in the <code>xsl:result-document</code> instruction</li>
53
                     <li>Calls to XSLT extension instructions</li>
54
                  </ul>
55
                  <p>The default value is <b>true</b>. The setting <b>false</b> is recommended in an
56
                environment where untrusted stylesheets may be executed.</p>
57
                  <p>This option does not disable use of the <code>doc()</code> function or similar
58
                functions to access the filestore of the machine where the transformation or query
59
                is running. That should be done using a user-supplied <code>URIResolver</code>.</p>
60
                  <p>Note that integrated extension functions are trusted; calls to such functions are
61
                allowed even if this configuration option is false. In cases where an integrated
62
                extension function is used to load and execute untrusted code, it should check this
63
                configuration option before doing so.</p>
64
               </xs:documentation>
65
            </xs:annotation>
66
         </xs:attribute>
67
         <xs:attribute name="allowMultiThreading" use="optional" type="xs:boolean">
68
            <xs:annotation>
69
               <xs:documentation>
70
                  <p>ALLOW_MULTITHREADING determines whether multi-threading is allowed.</p>
71
                  <p>If true (the default), the presence of the attribute <code>saxon:threads="N"</code>
72
                on an <code>xsl:for-each</code> instruction, when running under Saxon-EE, causes
73
                multi-threaded execution. If set to false, the value of the
74
                    <code>saxon:threads</code> argument is ignored.</p>
75
                  <p>Setting the value to false also disables asynchronous processing of
76
                    <code>xsl:result-document</code> instructions.</p>
77
                  <p>The default value is true if Saxon-EE is in use, false otherwise.</p>
78
               </xs:documentation>
79
            </xs:annotation>
80
         </xs:attribute>
81
         <xs:attribute name="allowOldJavaUriFormat" use="optional" type="xs:boolean">
82
            <xs:annotation>
83
               <xs:documentation>
84
                  <p>ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to
85
                dynamically-loaded Java extension functions may use the URI format supported in
86
                older Saxon releases.</p>
87
                  <p>If the value is false (the default), the only URI format accepted is (for example)
88
                "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by
89
                the Java qualified class name of the class containing the implementation of the
90
                extension function.</p>
91
                  <p>If the value is true, then in addition to this format, the following are accepted:
92
                (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the
93
                Java class name follows the last "/" character (for example
94
                "http://my.com/extensions/java.util.Date"). This last format was originally provided
95
                for compatibility with xt and xalan, but it causes problems because it leads to
96
                unnecessary attempts to load spurious classes when the user did not intend the URI
97
                to represent a dynamically-loaded Java class.</p>
98
               </xs:documentation>
99
            </xs:annotation>
100
         </xs:attribute>
101
         <xs:attribute name="allowStreamabilityExtensions"
102
                       use="optional"
103
                       type="xs:boolean">
104
            <xs:annotation>
105
               <xs:documentation> Saxon 9.5 only. </xs:documentation>
106
            </xs:annotation>
107
         </xs:attribute>
108
         <xs:attribute name="collationUriResolver"
109
                       use="optional"
110
                       type="c:javaClassNameType">
111
            <xs:annotation>
112
               <xs:documentation>
113
                  <p>The supplied class is instantiated and the resulting instance is used as the value of
114
                the <link>net.sf.saxon.lib.FeatureKeys#COLLATION_URI_RESOLVER</link> property.</p>
115
               </xs:documentation>
116
            </xs:annotation>
117
         </xs:attribute>
118
         <xs:attribute name="collectionUriResolver"
119
                       use="optional"
120
                       type="c:javaClassNameType">
121
            <xs:annotation>
122
               <xs:documentation>
123
                  <p>The supplied class is instantiated and the resulting instance is used as the value of
124
                the <link>net.sf.saxon.lib.FeatureKeys#COLLECTION_URI_RESOLVER</link> property.</p>
125
               </xs:documentation>
126
            </xs:annotation>
127
         </xs:attribute>
128
         <xs:attribute name="compileWithTracing" use="optional" type="xs:boolean">
129
            <xs:annotation>
130
               <xs:documentation>
131
                  <p>If run-time tracing of stylesheet or query execution is required, then the code must
132
                be compiled with tracing enabled. Default is false. This option causes code to be
133
                compiled that makes calls to a <link>net.sf.saxon.lib.TraceListener</link>, but this
134
                has no effect unless a <code>TraceListener</code> is registered at execution
135
                time.</p>
136
               </xs:documentation>
137
            </xs:annotation>
138
         </xs:attribute>
139
         <xs:attribute name="debugByteCode" use="optional" type="xs:boolean">
140
            <xs:annotation>
141
               <xs:documentation>
142
                  <p>This option is set to indicate that bytecode generation should be run in debugging
143
                mode; it injects diagnostic tracing calls into the generated bytecode. This should
144
                be used only if requested by Saxonica support to diagnose a problem related to
145
                bytecode generation.</p>
146
               </xs:documentation>
147
            </xs:annotation>
148
         </xs:attribute>
149
         <xs:attribute name="debugByteCodeDirectory" use="optional" type="c:fileNameType">
150
            <xs:annotation>
151
               <xs:documentation>
152
                  <p>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
153
                defines a directory to which files containing bytecode in human-readable form will
154
                be written. There will be one such file for each generated class, with a filename
155
                designed to give some kind of clue as to its relationship to the source code.</p>
156
                  <p>The default value is the directory <code>saxonByteCode</code> within the current
157
                working directory.</p>
158
                  <p>The named directory is created if it does not already exist.</p>
159
                  <p>Because the generation of class names involves random numbers, files will tend to
160
                accumulate in the supplied directory, even when the same source code is compiled
161
                repeatedly.</p>
162
               </xs:documentation>
163
            </xs:annotation>
164
         </xs:attribute>
165
         <xs:attribute name="defaultCollation" use="optional" type="xs:anyURI">
166
            <xs:annotation>
167
               <xs:documentation>
168
                  <p>This option determines the collation that is used for comparing strings when no
169
                explicit collation is requested. It is not necessary for this collation to exist (or
170
                to have been registered) when setting this option; it only needs to exist by the
171
                time it is used.</p>
172
                  <p>In XSLT it is possible to override this setting using the
173
                    <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
174
                XQuery, it can be overridden using the <code>declare default collation</code>
175
                declaration in the query prolog, or via a setter method in class
176
                    <link>net.sf.saxon.query.StaticQueryContext</link>.</p>
177
                  <p>If no value is specified, the Unicode codepoint collation is used.</p>
178
               </xs:documentation>
179
            </xs:annotation>
180
         </xs:attribute>
181
         <xs:attribute name="defaultCollection" use="optional" type="xs:anyURI">
182
            <xs:annotation>
183
               <xs:documentation>
184
                  <p> This determines the collection that is used when the <code>fn:collection()</code>
185
                function is called with no arguments; the effect is the same as if it were called
186
                passing the URI that is the value of this configuration property.</p>
187
               </xs:documentation>
188
            </xs:annotation>
189
         </xs:attribute>
190
         <xs:attribute name="displayByteCode" use="optional" type="xs:boolean">
191
            <xs:annotation>
192
               <xs:documentation>
193
                  <p>This option is set to indicate that bytecode generation should be run in display
194
                mode. The effect is to output files (one per class) containing a human-readable
195
                print of the generated bytecode. The files are placed in the directory identified by
196
                the <code>DEBUG_BYTE_CODE_DIR</code> option.</p>
197
               </xs:documentation>
198
            </xs:annotation>
199
         </xs:attribute>
200
         <xs:attribute name="dtdValidation" use="optional" type="xs:boolean">
201
            <xs:annotation>
202
               <xs:documentation>
203
                  <p>If true, the XML parser is requested to perform validation of source documents
204
                against their DTD. Default is false.</p>
205
                  <p>This option establishes a default for use whenever source documents (not stylesheets
206
                or schema documents) are parsed. The option can be overridden for individual
207
                documents by setting the <link>net.sf.saxon.lib.ParseOptions</link> for that
208
                individual document, for example from a <code>URIResolver</code>.</p>
209
               </xs:documentation>
210
            </xs:annotation>
211
         </xs:attribute>
212
         <xs:attribute name="dtdValidationRecoverable" use="optional" type="xs:boolean">
213
            <xs:annotation>
214
               <xs:documentation>
215
                  <p>This option determines whether DTD validation failures should be treated as
216
                recoverable. If the option is set, a validation failure is reported as a warning
217
                rather than an error. The default is false.</p>
218
                  <p>This option establishes a default for use whenever source documents (not stylesheets
219
                or schema documents) are parsed. The option can be overridden for individual
220
                documents by setting the <link>net.sf.saxon.lib.ParseOptions</link> for that
221
                individual document, for example from a <code>URIResolver</code>.</p>
222
               </xs:documentation>
223
            </xs:annotation>
224
         </xs:attribute>
225
         <xs:attribute name="entityResolver" use="optional" type="c:javaClassNameType">
226
            <xs:annotation>
227
               <xs:documentation>
228
                  <p>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
229
                used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
230
                documents. It is not used with a user-supplied <code>XMLReader</code>.</p>
231
                  <p>The default value is <link>net.sf.saxon.lib.EntityResolver</link>. This is an entity
232
                resolver that recognizes the names of many standard W3C DTDs and external entity
233
                files, and resolves them against local copies issued with the Saxon software, to
234
                avoid the need to fetch them from the web.</p>
235
                  <p>The property can be set to a zero-length string, in which case no
236
                    <code>EntityResolver</code> will be used.</p>
237
               </xs:documentation>
238
            </xs:annotation>
239
         </xs:attribute>
240
         <xs:attribute name="environmentVariableResolver"
241
                       use="optional"
242
                       type="c:javaClassNameType">
243
            <xs:annotation>
244
               <xs:documentation>
245
                  <p>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
246
                supplied class to be created, and registered as the environment variable resolver
247
                for the <code>Configuration</code>. The setting is global: it affects all queries
248
                and transformations using this configuration.</p>
249
                  <p>The environment variable resolver is used when the XPath functions
250
                    <code>available-environment-variables()</code> or
251
                    <code>environment-variable()</code> are called. Saxon essentially delegates the
252
                evaluation of the function to the external resolver.</p>
253
               </xs:documentation>
254
            </xs:annotation>
255
         </xs:attribute>
256
         <xs:attribute name="errorListener" use="optional" type="c:javaClassNameType">
257
            <xs:annotation>
258
               <xs:documentation>
259
                  <p>
260
                     <code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
261
                    <code>ErrorListener</code>. This is used both at compile time and at run-time.
262
                Currently if this option is specified, the class is instantiated, and the same
263
                instance is used for all processes running under this configuration. This may change
264
                in future so that a new instance is created for each compilation or evaluation.</p>
265
                  <p>Finer control can be obtained by setting the <code>ErrorListener</code> for a
266
                specific XSLT or XQuery compilation or evaluation.</p>
267
               </xs:documentation>
268
            </xs:annotation>
269
         </xs:attribute>
270
         <xs:attribute name="expandAttributeDefaults" use="optional" type="xs:boolean">
271
            <xs:annotation>
272
               <xs:documentation>
273
                  <p>
274
                     <code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
275
                defined in a schema or DTD will be expanded (both on input and on output documents,
276
                if validation is requested). By default (and for conformance with the specification)
277
                validation against a DTD or schema will cause default values defined in the schema
278
                or DTD to be inserted into the document. Setting this feature to false suppresses
279
                this behavior. In the case of DTD-defined defaults this only works if the XML parser
280
                reports whether each attribute was specified in the source or generated by expanding
281
                a default value. Not all XML parsers report this information.</p>
282
               </xs:documentation>
283
            </xs:annotation>
284
         </xs:attribute>
285
         <xs:attribute name="generateByteCode" use="optional" type="xs:boolean">
286
            <xs:annotation>
287
               <xs:documentation>
288
                  <p>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
289
                query or stylesheet that are amenable to such treatment. Setting this option to
290
                false disables this.</p>
291
               </xs:documentation>
292
            </xs:annotation>
293
         </xs:attribute>
294
         <xs:attribute name="ignoreSAXSourceParser" use="optional" type="xs:boolean">
295
            <xs:annotation>
296
               <xs:documentation>
297
                  <p>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
298
                input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
299
                supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
300
                    <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
301
                    <code>XMLReader</code> created using the value of the
302
                    <code>SOURCE_PARSER_CLASS</code> option in preference.</p>
303
                  <p>The defining use case for this feature is when calling a Saxon transformation from
304
                Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
305
                parser instantiated using the default JAXP mechanism. A different parser set using
306
                the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
307
                normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
308
                option overrides this. This is especially useful if the input format is not in fact
309
                XML, but some other format converted to a SAX event stream by means of a custom
310
                parser.</p>
311
               </xs:documentation>
312
            </xs:annotation>
313
         </xs:attribute>
314
         <xs:attribute name="lazyConstructionMode" use="optional" type="xs:boolean">
315
            <xs:annotation>
316
               <xs:documentation>
317
                  <p>
318
                     <code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
319
                constructed lazily. The default setting is false; there are a few situations (but
320
                not many) where setting this to true can give a performance benefit (especially a
321
                memory saving).</p>
322
                  <p>The option is most likely to be effective when executing XQuery in "pull" mode, that
323
                is, when the client calls the query processor to deliver the result as a stream of
324
                nodes, rather than running the query and piping the results into a serializer.</p>
325
               </xs:documentation>
326
            </xs:annotation>
327
         </xs:attribute>
328
         <xs:attribute name="lineNumbering" use="optional" type="xs:boolean">
329
            <xs:annotation>
330
               <xs:documentation>
331
                  <p>Default is false. If true, line and column number information is retained for all
332
                source documents. This information is accessible using the
333
                    <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
334
                extension functions.</p>
335
                  <p>Note that the information is only as good as the XML parser supplies. SAX parsers
336
                generally report the position of an element node using the line and column number of
337
                the "&gt;" character that forms the last character of the start tag.</p>
338
               </xs:documentation>
339
            </xs:annotation>
340
         </xs:attribute>
341
         <xs:attribute name="optimizationLevel" use="optional" type="xs:integer">
342
            <xs:annotation>
343
               <xs:documentation>
344
                  <p>A string whose value is an integer in the range 0 (no optimization) to 10 (full
345
                optimization); currently all values other than 0 result in full optimization but
346
                this is likely to change in future. The default is full optimization; this feature
347
                allows optimization to be suppressed in cases where reducing compile time is
348
                important, or where optimization gets in the way of debugging, or causes extension
349
                functions with side-effects to behave unpredictably. (Note however, that even with
350
                no optimization, lazy evaluation may still cause the evaluation order to be not as
351
                expected.) </p>
352
               </xs:documentation>
353
            </xs:annotation>
354
         </xs:attribute>
355
         <xs:attribute name="parser" use="optional" type="c:javaClassNameType">
356
            <xs:annotation>
357
               <xs:documentation>
358
                  <p>The class will be instantiated. If it is an <code>XMLReader</code> it is used
359
                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
360
                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
361
                parse source documents (that is, the principal source document plus any secondary
362
                source documents read using the <code>doc()</code>, <code>document()</code>, or
363
                    <code>collection()</code> function).</p>
364
                  <p>Note that the selected parser is used only when the input is supplied in the form of
365
                a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
366
                pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
367
                configuration option has no effect when running transformations from an Ant script,
368
                since the Ant <code>xslt</code> task always supplies the input in the form of a
369
                    <code>SAXSource</code>.</p>
370
               </xs:documentation>
371
            </xs:annotation>
372
         </xs:attribute>
373
         <xs:attribute name="preEvaluateDoc" use="optional" type="xs:boolean">
374
            <xs:annotation>
375
               <xs:documentation>
376
                  <p>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
377
                their arguments are known at compile time, will be evaluated at compile time, and
378
                the resulting document will be stored as part of the Saxon
379
                    <link>net.sf.saxon.Configuration</link> and shared by all queries and
380
                transformations running within that <code>Configuration</code>. This is useful for
381
                reference documents that have stable content and are used by many different queries
382
                and transformations. The default is false, which means each query or transformation
383
                will reload the document from disk.</p>
384
                  <p>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
385
                compile time is to use the new facility of static global variables.</p>
386
               </xs:documentation>
387
            </xs:annotation>
388
         </xs:attribute>
389
         <xs:attribute name="preferJaxpParser" use="optional" type="xs:boolean">
390
            <xs:annotation>
391
               <xs:documentation>
392
                  <p>This option has no effect on the Java platform. The default is <b>true</b>. When
393
                running on the .NET platform, if the option is true it causes the Apache Xerces
394
                parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
395
                If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
396
                reason for providing this option is that the .NET XML parser does not report ID
397
                attributes, which means that the <code>id()</code> function does not work.</p>
398
               </xs:documentation>
399
            </xs:annotation>
400
         </xs:attribute>
401
         <xs:attribute name="recognizeUriQueryParameters" use="optional" type="xs:boolean">
402
            <xs:annotation>
403
               <xs:documentation>
404
                  <p>True if the the standard URI resolver is to recognize query parameters included in
405
                the URI (for example, <code>?val=strict</code>). Such parameters can then be used in
406
                URIs passed to the <code>doc()</code> or <code>document()</code> functions. For
407
                details of the query parameters available, see <xref section="sourcedocs">Source
408
                    Documents</xref>. The default is false.</p>
409
                  <p>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
410
                unless the user-supplied <code>URIResolver</code> chooses to inherit this
411
                functionality from the standard <code>URIResolver</code>.</p>
412
                  <p>Allowed parameters include <code>validation=strict|lax|strip</code> to perform schema
413
                validation, <code>strip-space=yes|ignorable|no</code> to control whitespace
414
                stripping, and <code>xinclude=yes|no</code> to control whether XInclude processing
415
                takes place (assuming the XML parser supports it).</p>
416
               </xs:documentation>
417
            </xs:annotation>
418
         </xs:attribute>
419
         <xs:attribute name="schemaValidation"
420
                       use="optional"
421
                       type="c:schemaValidationType">
422
            <xs:annotation>
423
               <xs:documentation>
424
                  <p>Indicates whether and how schema validation should be applied to source
425
                documents.</p>
426
               </xs:documentation>
427
            </xs:annotation>
428
         </xs:attribute>
429
         <xs:attribute name="serializerFactory" use="optional" type="c:javaClassNameType">
430
            <xs:annotation>
431
               <xs:documentation>
432
                  <p>The class will be instantiated and the resulting <code>SerializerFactory</code> will
433
                be used to create the serialization pipeline for XSLT and XQuery results. By
434
                subclassing the standard <code>SerializerFactory</code> it is possible to customize
435
                many aspects of the output produced by the Serializer, or to introduce new
436
                serialization methods and parameters.</p>
437
               </xs:documentation>
438
            </xs:annotation>
439
         </xs:attribute>
440
         <xs:attribute name="sourceResolver" use="optional" type="c:javaClassNameType">
441
            <xs:annotation>
442
               <xs:documentation>
443
                  <p>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
444
                of <code>Source</code> is provided that Saxon does not recognize, it will be passed
445
                to the user-supplied <code>SourceResolver</code>, which has the opportunity to
446
                convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
447
                new kinds of input to be supplied as input to Saxon's query, transformation, and
448
                validation engines.</p>
449
               </xs:documentation>
450
            </xs:annotation>
451
         </xs:attribute>
452
         <xs:attribute name="standardErrorOutputFile" use="optional" type="c:fileNameType">
453
            <xs:annotation>
454
               <xs:documentation>
455
                  <p>
456
                     <code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
457
                redirect output that would otherwise go to the operating system standard error
458
                stream (System.err). This is the fallback destination for various tracing and
459
                diagnostic output. In some cases a more specific mechanism exists to select the
460
                destination for particular kinds of output.</p>
461
                  <p>Note that if the <code>Configuration</code> is used in more than one processing
462
                thread, the messages from different threads will be interleaved in the output file.
463
                A more selective approach is to use a different <code>ErrorListener</code> in
464
                different processing threads, and arrange for each <code>ErrorListener</code> to
465
                write to its own logging destination.</p>
466
               </xs:documentation>
467
            </xs:annotation>
468
         </xs:attribute>
469
         <xs:attribute name="streamability" use="optional" type="c:streamabilityType">
470
            <xs:annotation>
471
               <xs:documentation>
472
                  <p>
473
                     <code>STREAMABILITY</code> determines the test that Saxon applies to determine
474
                whether a construct is streamable, in cases where streaming is requested for example
475
                by use of the <code>xsl:stream</code> instruction, or by specifying
476
                    <code>streamable="yes"</code> on constructs such as <code>xsl:mode</code> and
477
                    <code>xsl:accumulator</code>.</p>
478
                  <p>The value "standard" means that Saxon applies the rules in the W3C XSLT 3.0
479
                specification as closely as possible. (Exact compliance is not always possible.)</p>
480
                  <p>The value "extended" means that use of Saxon streaming extensions is permitted. This
481
                is the default when using Saxon-EE with a suitable license.</p>
482
                  <p>The value "off" means that all constructs are treated as non-streamable. This is the
483
                only option available when using a Saxon version or license that does not enable
484
                streaming.</p>
485
                  <p>Whichever option is chosen, the <code>STREAMING_FALLBACK</code> option can be used to
486
                control what happens when code is deemed non-streamable; it provides a choice
487
                between throwing a static (compile-time) error, and falling back to a non-streaming
488
                implementation.</p>
489
               </xs:documentation>
490
            </xs:annotation>
491
         </xs:attribute>
492
         <xs:attribute name="streamingFallback" use="optional" type="xs:boolean">
493
            <xs:annotation>
494
               <xs:documentation>
495
                  <p>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
496
                streaming is requested (such as templates in a streaming mode, the
497
                    <code>xsl:stream</code> instruction, and streamable accumulators) will be
498
                executed in non-streaming mode if the code is not actually streamable. A
499
                compile-time warning will always be given when the fallback option is taken.</p>
500
               </xs:documentation>
501
            </xs:annotation>
502
         </xs:attribute>
503
         <xs:attribute name="stripSpace" use="optional" type="c:stripSpaceType">
504
            <xs:annotation>
505
               <xs:documentation>
506
                  <p>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
507
                a DTD or schema as having element-only content should be stripped from source
508
                documents. The default is "ignorable". This whitespace stripping is additional to
509
                any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
510
                XSLT stylesheet.</p>
511
               </xs:documentation>
512
            </xs:annotation>
513
         </xs:attribute>
514
         <xs:attribute name="styleParser" use="optional" type="c:javaClassNameType">
515
            <xs:annotation>
516
               <xs:documentation>
517
                  <p>The class will be instantiated. If it is an <code>XMLReader</code> it is used
518
                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
519
                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
520
                parse stylesheet documents (that is, the principal stylesheet module plus any
521
                secondary source documents read using <code>xsl:include</code> or
522
                    <code>xsl:import</code>) and also schema documents.</p>
523
               </xs:documentation>
524
            </xs:annotation>
525
         </xs:attribute>
526
         <xs:attribute name="suppressEvaluationExpiryWarning"
527
                       use="optional"
528
                       type="xs:boolean">
529
            <xs:annotation>
530
               <xs:documentation>
531
                  <p>This is set to true to suppress the warning otherwise issued by command-line
532
                interfaces indicating that an evaluation license is in use and is due to expire in a
533
                set number of days.</p>
534
               </xs:documentation>
535
            </xs:annotation>
536
         </xs:attribute>
537
         <xs:attribute name="suppressXsltNamespaceCheck" use="optional" type="xs:boolean">
538
            <xs:annotation>
539
               <xs:documentation>
540
                  <p>This is set to true to suppress the warning when there is no commonality between the
541
                namespaces used in stylesheet match patterns and the namespaces used in the source
542
                document.</p>
543
               </xs:documentation>
544
            </xs:annotation>
545
         </xs:attribute>
546
         <xs:attribute name="timing" use="optional" type="xs:boolean">
547
            <xs:annotation>
548
               <xs:documentation>
549
                  <p>This is set to true to cause basic timing and tracing information to be output to the
550
                standard error output stream. The name of the feature is poorly chosen, since much
551
                of the information that is output has nothing to do with timing, for example the
552
                names of output files for <code>xsl:result-document</code> are traced, as are the
553
                names of schema documents loaded.</p>
554
               </xs:documentation>
555
            </xs:annotation>
556
         </xs:attribute>
557
         <xs:attribute name="traceExternalFunctions" use="optional" type="xs:boolean">
558
            <xs:annotation>
559
               <xs:documentation>
560
                  <p>If this option is set, Saxon will output (to the standard error output) progress
561
                information about its attempts to locate and disambiguate references to reflexive
562
                Java extension functions. This is useful for diagnostics if the XQuery or XSLT
563
                compiler is failing to locate user-written extension functions.</p>
564
               </xs:documentation>
565
            </xs:annotation>
566
         </xs:attribute>
567
         <xs:attribute name="traceListener" use="optional" type="c:javaClassNameType">
568
            <xs:annotation>
569
               <xs:documentation>
570
                  <p>The class will be instantiated once for each query or transformation, and the
571
                resulting <code>TraceListener</code> will be notified of significant events
572
                occurring during that query or transformation, for tracing or debugging
573
                purposes.</p>
574
                  <p>Setting a <code>TraceListener</code> automatically sets the
575
                    <link>net.sf.saxon.lib.FeatureKeys#COMPILE_WITH_TRACING</link> option.</p>
576
               </xs:documentation>
577
            </xs:annotation>
578
         </xs:attribute>
579
         <xs:attribute name="traceOptimizerDecisions" use="optional" type="xs:boolean">
580
            <xs:annotation>
581
               <xs:documentation>
582
                  <p>If this option is set, Saxon will output (to the standard error output) detailed
583
                information about the rewrites to the expression tree made by the optimizer. This
584
                information is mainly useful for internal system debugging, but it is also possible
585
                to digest it to analyze the ways in which the expression has been optimized for the
586
                purpose of performance analysis and tuning.</p>
587
               </xs:documentation>
588
            </xs:annotation>
589
         </xs:attribute>
590
         <xs:attribute name="treeModel" use="optional" type="c:treeModelType">
591
            <xs:annotation>
592
               <xs:documentation>
593
                  <p>Selects an implementation of the Saxon tree model. The default is
594
                    <code>tinyTree</code>.</p>
595
                  <p>For running XQuery Update, use the linked tree, because it is the only implementation
596
                that is updateable.</p>
597
               </xs:documentation>
598
            </xs:annotation>
599
         </xs:attribute>
600
         <xs:attribute name="uriResolver" use="optional" type="c:javaClassNameType">
601
            <xs:annotation>
602
               <xs:documentation>
603
                  <p>An instance of the specified <code>URIResolver</code> class will be created, and used
604
                to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
605
                    <code>document()</code> functions, as well as URIs used in
606
                    <code>xsl:include</code> and <code>xsl:import</code> and location hints for
607
                XQuery modules and XSD schema documents.</p>
608
               </xs:documentation>
609
            </xs:annotation>
610
         </xs:attribute>
611
         <xs:attribute name="usePiDisableOutputEscaping" use="optional" type="xs:boolean">
612
            <xs:annotation>
613
               <xs:documentation>
614
                  <p>This option determines whether a <code>TransformerHandler</code> created with this
615
                    <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
616
                JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
617
                and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
618
                instructions to disable or to re-enable output escaping. The default value is
619
                    <b>false</b>.</p>
620
               </xs:documentation>
621
            </xs:annotation>
622
         </xs:attribute>
623
         <xs:attribute name="useTypedValueCache" use="optional" type="xs:boolean">
624
            <xs:annotation>
625
               <xs:documentation>
626
                  <p>This option is relevant only when the TinyTree is used; it determines whether (for a
627
                validated document) a cache will be maintained containing the typed values of nodes.
628
                Typed values are held in the cache only for elements and attributes whose type is
629
                other than string, untypedAtomic, or anyURI. The default value is true. Setting this
630
                value to false can reduce memory requirements at the cost of requiring recomputation
631
                of typed values on each access.</p>
632
               </xs:documentation>
633
            </xs:annotation>
634
         </xs:attribute>
635
         <xs:attribute name="validationComments" use="optional" type="xs:boolean">
636
            <xs:annotation>
637
               <xs:documentation>
638
                  <p>This option determines whether non-fatal validation errors in XQuery or XSLT result
639
                documents should result in comments being inserted into the result tree. The
640
                command-line flag <code>-outval:recover</code> sets both this option and the
641
                    <link>net.sf.saxon.lib.FeatureKeys#VALIDATION_WARNINGS</link> option.</p>
642
               </xs:documentation>
643
            </xs:annotation>
644
         </xs:attribute>
645
         <xs:attribute name="validationWarnings" use="optional" type="xs:boolean">
646
            <xs:annotation>
647
               <xs:documentation>
648
                  <p>This option indicates (if true) that errors occuring while validating a final result
649
                tree are not to be treated as fatal.</p>
650
                  <p>Regardless of the setting of this option, all validation errors are reported to the
651
                    <code>error()</code> method of the <code>ErrorListener</code>, and validation is
652
                terminated if the <code>error()</code> method throws an exception, or if the error
653
                limit set in the <code>ParseOptions</code> object is reached.</p>
654
                  <p>This option primarily controls what happens at the end of a validation episode. If
655
                the validation episode detected one or more validation errors, then when this option
656
                is off, an exception is thrown, which will normally result in any query or
657
                stylesheet failing with a dynamic error, and no output file being written. If the
658
                option is on, no exception is thrown, and the output is written as if validation had
659
                been successful. Note in this case that any type annotations present in a result
660
                document are unreliable.</p>
661
                  <p>If this option is set when running XSLT or XQuery, it is ignored as far as input
662
                files are concerned: validation errors in input files are still fatal. However, if
663
                the option is set and a validation error occurs in a final output file, the output
664
                file is still written and the process terminates as if successful.</p>
665
                  <p>The detailed interpretation of this option changed in Saxon 9.5.</p>
666
               </xs:documentation>
667
            </xs:annotation>
668
         </xs:attribute>
669
         <xs:attribute name="versionOfXml" use="optional" type="xs:decimal">
670
            <xs:annotation>
671
               <xs:documentation>
672
                  <p>This determines the XML version used by the <code>Configuration</code>.</p>
673
                  <p>Note that source documents specifying <code>xml version="1.0"</code> or
674
                    <code>"1.1"</code> are accepted regardless of this setting. The effect of this
675
                switch is to change the validation rules for types such as <code>xs:Name</code> and
676
                    <code>xs:NCName</code>, to change the characters allowed in names within XPath
677
                expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
678
                regular expressions, and to determine whether the serializer allows XML 1.1
679
                documents to be constructed. </p>
680
                  <p>The default is currently 1.0, but may change.</p>
681
               </xs:documentation>
682
            </xs:annotation>
683
         </xs:attribute>
684
         <xs:attribute name="xInclude" use="optional" type="xs:boolean">
685
            <xs:annotation>
686
               <xs:documentation>
687
                  <p>Indicates whether source documents should have any XInclude directives expanded. The
688
                default is false. The option applies to all input XML documents, including
689
                stylesheets and schema documents. It can be overridden for individual documents
690
                using the <link>net.sf.saxon.lib.ParseOptions</link> class.</p>
691
                  <p>This option relies on support in the underlying XML parser. If the XML parser does
692
                not support XInclude processing, the option is ignored.</p>
693
               </xs:documentation>
694
            </xs:annotation>
695
         </xs:attribute>
696
      </xs:complexType>
697
   </xs:element>
698

    
699
   <xs:element name="serialization">
700
      <xs:annotation>
701
         <xs:documentation> Defines defaults for serialization properties. </xs:documentation>
702
      </xs:annotation>
703
      <xs:complexType>
704
         <xs:attribute name="byte-order-mark" use="optional" type="c:yesOrNoType">
705
            <xs:annotation>
706
               <xs:documentation>Indicates whether serialized output should include a byte order mark</xs:documentation>
707
            </xs:annotation>
708
         </xs:attribute>
709
         <xs:attribute name="cdata-section-elements"
710
                       use="optional"
711
                       type="c:listOfQNameType">
712
            <xs:annotation>
713
               <xs:documentation>A list of element names whose content is to be serialized using CDATA sections</xs:documentation>
714
            </xs:annotation>
715
         </xs:attribute>
716
         <xs:attribute name="doctype-public" use="optional" type="xs:string">
717
            <xs:annotation>
718
               <xs:documentation>The public identifier to be used in the DOCTYPE declaration</xs:documentation>
719
            </xs:annotation>
720
         </xs:attribute>
721
         <xs:attribute name="doctype-system" use="optional" type="xs:anyURI">
722
            <xs:annotation>
723
               <xs:documentation>The system identifier (URI) to be used in the DOCTYPE declaration</xs:documentation>
724
            </xs:annotation>
725
         </xs:attribute>
726
         <xs:attribute name="encoding" use="optional" type="xs:string">
727
            <xs:annotation>
728
               <xs:documentation>The output encoding, for example utf-8 or us-ascii</xs:documentation>
729
            </xs:annotation>
730
         </xs:attribute>
731
         <xs:attribute name="escape-uri-attributes" use="optional" type="c:yesOrNoType">
732
            <xs:annotation>
733
               <xs:documentation>Defines whether URI-valued attributes in HTML/XHTML (for example href)
734
          are to be %HH-encoded</xs:documentation>
735
            </xs:annotation>
736
         </xs:attribute>
737
         <xs:attribute name="html-version" use="optional" type="xs:decimal">
738
            <xs:annotation>
739
               <xs:documentation>When the output method is HTML or XHTML, then if this attribute takes 
740
            decimal value 5.0, then the output produced is HTML 5.0 or XHTML 5.0 respectively. </xs:documentation>
741
            </xs:annotation>
742
         </xs:attribute>
743
         <xs:attribute name="include-content-type" use="optional" type="c:yesOrNoType">
744
            <xs:annotation>
745
               <xs:documentation>Defines whether a &lt;meta&gt; element should be added to the
746
          HTML &lt;head&gt; element to identify the media type of the output</xs:documentation>
747
            </xs:annotation>
748
         </xs:attribute>
749
         <xs:attribute name="indent" use="optional" type="c:yesOrNoType">
750
            <xs:annotation>
751
               <xs:documentation> Defines whether indentation is to be added to the output. </xs:documentation>
752
            </xs:annotation>
753
         </xs:attribute>
754
         <xs:attribute name="item-separator" use="optional" type="xs:string">
755
            <xs:annotation>
756
               <xs:documentation>Defines separator to be used between items in serialized output.</xs:documentation>
757
            </xs:annotation>
758
         </xs:attribute>
759
         <xs:attribute name="media-type" use="optional" type="xs:string">
760
            <xs:annotation>
761
               <xs:documentation> Defines the media type (MIME type) of the output. </xs:documentation>
762
            </xs:annotation>
763
         </xs:attribute>
764
         <xs:attribute name="method" use="optional" type="xs:QName">
765
            <xs:annotation>
766
               <xs:documentation> Defines the serialization method, for example 'xml' or 'html' or 'text'. </xs:documentation>
767
            </xs:annotation>
768
         </xs:attribute>
769
         <xs:attribute name="normalization-form" use="optional" type="xs:string">
770
            <xs:annotation>
771
               <xs:documentation> Defines whether Unicode normalization should be applied during serialization,
772
            and if so, which Unicode normalization form should be used. </xs:documentation>
773
            </xs:annotation>
774
         </xs:attribute>
775
         <xs:attribute name="omit-xml-declaration" use="optional" type="c:yesOrNoType">
776
            <xs:annotation>
777
               <xs:documentation> Defines whether the XML declaration should be omitted from XML output. </xs:documentation>
778
            </xs:annotation>
779
         </xs:attribute>
780
         <xs:attribute name="standalone" use="optional" type="c:yesOrNoOrOmitType">
781
            <xs:annotation>
782
               <xs:documentation> Defines whether the XML declaration in XML output should have a 'standalone' attribute. </xs:documentation>
783
            </xs:annotation>
784
         </xs:attribute>
785
         <xs:attribute name="suppress-indentation" use="optional" type="c:listOfQNameType">
786
            <xs:annotation>
787
               <xs:documentation> Defines a list of element names whose content should not be indented
788
            even when indent='yes' is specified. </xs:documentation>
789
            </xs:annotation>
790
         </xs:attribute>
791
         <xs:attribute name="undeclare-prefixes" use="optional" type="c:yesOrNoType">
792
            <xs:annotation>
793
               <xs:documentation> Defines whether namespaces present on a parent element but not on
794
            its children should be undeclared using XML Namespaces 1.1 syntax. </xs:documentation>
795
            </xs:annotation>
796
         </xs:attribute>
797
         <xs:attribute name="use-character-maps" use="optional" type="c:listOfQNameType">
798
            <xs:annotation>
799
               <xs:documentation> Defines a list of the names of character maps which will be 
800
            applied to transform individual characters during serialization. </xs:documentation>
801
            </xs:annotation>
802
         </xs:attribute>
803
         <xs:attribute name="version" use="optional" type="xs:string">
804
            <xs:annotation>
805
               <xs:documentation> Defines the version of XML or HTML to be used for the output. </xs:documentation>
806
            </xs:annotation>
807
         </xs:attribute>
808
         <xs:anyAttribute namespace="##other" processContents="lax"/>
809
      </xs:complexType>
810
   </xs:element>
811

    
812
   <xs:element name="collations">
813
      <xs:annotation>
814
         <xs:documentation> 
815
        Defines collation URIs for use in queries and stylesheets.
816
      </xs:documentation>
817
      </xs:annotation>
818
      <xs:complexType>
819
         <xs:sequence>
820

    
821
            <xs:element maxOccurs="unbounded" ref="c:collation"/>
822
         </xs:sequence>
823
      </xs:complexType>
824
   </xs:element>
825

    
826
   <xs:element name="collation">
827
      <xs:annotation>
828
         <xs:documentation> 
829
        Defines a collation URI for use in queries and stylesheets.
830
      </xs:documentation>
831
      </xs:annotation>
832
      <xs:complexType>
833
         <xs:attribute name="uri" use="required" type="xs:anyURI">
834
            <xs:annotation>
835
               <xs:documentation> 
836
            The collation URI as used in queries and stylesheets.
837
          </xs:documentation>
838
            </xs:annotation>
839
         </xs:attribute>
840
         <xs:attribute name="alphanumeric" use="optional" type="c:yesOrNoOrCodepointType">
841
            <xs:annotation>
842
               <xs:documentation> 
843
            Indicates whether a sequence of digits within a string is to be treated as a number,
844
            so that AB100 sorts after AB99.
845
          </xs:documentation>
846
            </xs:annotation>
847
         </xs:attribute>
848
         <xs:attribute name="case-order" use="optional" type="c:caseOrderType">
849
            <xs:annotation>
850
               <xs:documentation> 
851
            Indicates whether lower-case letters sort before or after upper-case.
852
          </xs:documentation>
853
            </xs:annotation>
854
         </xs:attribute>
855
         <xs:attribute name="class" use="optional" type="c:javaClassNameType">
856
            <xs:annotation>
857
               <xs:documentation> 
858
            The name of a Java class that performs the string comparison.
859
          </xs:documentation>
860
            </xs:annotation>
861
         </xs:attribute>
862
         <xs:attribute name="decomposition" use="optional" type="c:decompositionType">
863
            <xs:annotation>
864
               <xs:documentation> 
865
            Indicates whether composite (accented) Unicode characters should be decomposed
866
            before sorting.
867
          </xs:documentation>
868
            </xs:annotation>
869
         </xs:attribute>
870
         <xs:attribute name="ignore-case" use="optional" type="c:yesOrNoType">
871
            <xs:annotation>
872
               <xs:documentation> 
873
            Indicates whether differences of case are to be ignored during comparisons.
874
          </xs:documentation>
875
            </xs:annotation>
876
         </xs:attribute>
877
         <xs:attribute name="ignore-modifiers" use="optional" type="c:yesOrNoType">
878
            <xs:annotation>
879
               <xs:documentation> 
880
            Indicates whether modifiers (such as accents and diacritical marks) 
881
            are to be ignored during comparisons.
882
          </xs:documentation>
883
            </xs:annotation>
884
         </xs:attribute>
885
         <xs:attribute name="ignore-symbols" use="optional" type="c:yesOrNoType">
886
            <xs:annotation>
887
               <xs:documentation> 
888
            Indicates whether punctuation symbols 
889
            are to be ignored during comparisons (.NET only).
890
          </xs:documentation>
891
            </xs:annotation>
892
         </xs:attribute>
893
         <xs:attribute name="ignore-width" use="optional" type="c:yesOrNoType">
894
            <xs:annotation>
895
               <xs:documentation> 
896
            Indicates whether width differences between characters 
897
            are to be ignored during comparisons.
898
          </xs:documentation>
899
            </xs:annotation>
900
         </xs:attribute>
901
         <xs:attribute name="lang" use="optional" type="xs:language">
902
            <xs:annotation>
903
               <xs:documentation> 
904
            Indicates the natural language of the text, for example 'en' for English or 'de' for German.
905
          </xs:documentation>
906
            </xs:annotation>
907
         </xs:attribute>
908
         <xs:attribute name="rules" use="optional" type="xs:string">
909
            <xs:annotation>
910
               <xs:documentation> 
911
            Provides detailed sorting rules in the format of the Java RuleBasedCollator class.
912
          </xs:documentation>
913
            </xs:annotation>
914
         </xs:attribute>
915
         <xs:attribute name="strength" use="optional" type="c:strengthType">
916
            <xs:annotation>
917
               <xs:documentation> 
918
            The strength of the collation: primary, secondary, or tertiary. These terms are described
919
            in the Unicode Collation Algorithm.
920
          </xs:documentation>
921
            </xs:annotation>
922
         </xs:attribute>
923
      </xs:complexType>
924
   </xs:element>
925

    
926
   <xs:element name="localizations">
927
      <xs:annotation>
928
         <xs:documentation> 
929
        Defines localization of the output of format-date(), format-number(), and
930
        xsl:number. Note this relates to Saxon's native localization and has no effect when
931
        ICU localization is used.
932
      </xs:documentation>
933
      </xs:annotation>
934
      <xs:complexType>
935
         <xs:sequence>
936

    
937
            <xs:element maxOccurs="unbounded" ref="c:localization"/>
938
         </xs:sequence>
939
         <xs:attribute name="defaultCountry" use="optional" type="xs:NCName">
940
            <xs:annotation>
941
               <xs:documentation>
942
                  <p> This determines the country that is used by <code>format-date()</code> and similar
943
                functions if no country code is supplied explicitly. If no value is given for this
944
                property, the default is taken from the Java Locale, which in turn typically depends
945
                on settings for the current user in the operating system.</p>
946
               </xs:documentation>
947
            </xs:annotation>
948
         </xs:attribute>
949
         <xs:attribute name="defaultLanguage" use="optional" type="xs:NCName">
950
            <xs:annotation>
951
               <xs:documentation>
952
                  <p>This option determines the language that is used by <code>format-date()</code>,
953
                    <code>xsl:number</code> and similar constructs if no language code is supplied
954
                explicitly. If no value is given for this property, the default is taken from the
955
                Java Locale, which in turn typically depends on settings for the current user in the
956
                operating system.</p>
957
               </xs:documentation>
958
            </xs:annotation>
959
         </xs:attribute>
960
      </xs:complexType>
961
   </xs:element>
962

    
963
   <xs:element name="localization">
964
      <xs:annotation>
965
         <xs:documentation> 
966
        Defines localization of the output of format-date(), format-number(), and
967
        xsl:number for a specific language. 
968
      </xs:documentation>
969
      </xs:annotation>
970
      <xs:complexType>
971
         <xs:attribute name="lang" use="required" type="xs:language">
972
            <xs:annotation>
973
               <xs:documentation> 
974
            The language to which this localization applies, for example 'fr-CA' for Canadian French.
975
          </xs:documentation>
976
            </xs:annotation>
977
         </xs:attribute>
978
         <xs:attribute name="class" use="optional" type="c:javaClassNameType">
979
            <xs:annotation>
980
               <xs:documentation> 
981
            The Java class used to perform the localization.
982
          </xs:documentation>
983
            </xs:annotation>
984
         </xs:attribute>
985
         <xs:anyAttribute namespace="##other" processContents="lax">
986
            <xs:annotation>
987
               <xs:documentation> 
988
            Additional attributes are passed to the user-defined LocalizaterFactory in a Properties object,
989
            the propety names are the local names of the attributes, and the namespace is ignored.
990
          </xs:documentation>
991
            </xs:annotation>
992
         </xs:anyAttribute>
993
      </xs:complexType>
994
   </xs:element>
995

    
996
   <xs:element name="xslt">
997
      <xs:annotation>
998
         <xs:documentation> 
999
        Defines configuration properties specific to XSLT processing.
1000
      </xs:documentation>
1001
      </xs:annotation>
1002
      <xs:complexType>
1003
         <xs:sequence>
1004

    
1005
            <xs:element ref="c:extensionElement" minOccurs="0" maxOccurs="unbounded"/>
1006
         </xs:sequence>
1007
         <xs:attribute name="initialMode" use="optional" type="xs:QName">
1008
            <xs:annotation>
1009
               <xs:documentation>
1010
                  <p>This property indicates the name of a mode within a stylesheet in which execution
1011
                (using template rules) should begin.</p>
1012
                  <p>This option can be set for a particular XSLT transformation. When the option is set
1013
                at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
1014
                as a default.</p>
1015
               </xs:documentation>
1016
            </xs:annotation>
1017
         </xs:attribute>
1018
         <xs:attribute name="initialTemplate" use="optional" type="xs:QName">
1019
            <xs:annotation>
1020
               <xs:documentation>
1021
                  <p>This property indicates the name of a named template within a stylesheet where
1022
                execution should begin.</p>
1023
                  <p>This option can be set for a particular XSLT transformation. When the option is set
1024
                at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
1025
                it acts as a default.</p>
1026
               </xs:documentation>
1027
            </xs:annotation>
1028
         </xs:attribute>
1029
         <xs:attribute name="messageEmitter" use="optional" type="c:javaClassNameType">
1030
            <xs:annotation>
1031
               <xs:documentation>
1032
                  <p>Use the specified <code>Receiver</code> to process the output from
1033
                    <code>xsl:message</code>. The class must implement the
1034
                    <code>net.sf.saxon.event.Receiver</code> interface. This interface is similar to
1035
                a SAX <code>ContentHandler</code>, in that it takes a stream of events to generate
1036
                output.</p>
1037
                  <p> By default the standard XML emitter is used, configured to write to the standard
1038
                error stream, and to include no XML declaration. </p>
1039
                  <p>In general the content of a message is an XML fragment. Each message is output as a
1040
                new document. The sequence of calls to this <code>Receiver</code> is as follows:
1041
                there is a single <code>open()</code> call at the start of the transformation, and a
1042
                single <code>close()</code> call at the end; and each evaluation of an
1043
                    <code>xsl:message</code> instruction starts with a <code>startDocument()</code>
1044
                call and ends with <code>endDocument()</code>. </p>
1045
                  <p>The <code>startDocument()</code> event has a <code>properties</code> argument
1046
                indicating whether <code>terminate="yes"</code> was specified, and the
1047
                    <code>locationId</code> on calls such as <code>startElement()</code> and
1048
                    <code>characters()</code> can be used to identify the location in the stylesheet
1049
                where the message data originated (this is achieved by passing the supplied
1050
                    <code>locationId</code> in a call to
1051
                    <code>getPipelineConfiguration().getLocator().getSystemId(locationId)</code>, or
1052
                to <code>getLineNumber()</code> on the same object). </p>
1053
                  <p>Select the class <code>net.sf.saxon.event.MessageWarner</code> to have
1054
                    <code>xsl:message</code> output notified to the JAXP <code>ErrorListener</code>,
1055
                as described in the JAXP documentation.</p>
1056
               </xs:documentation>
1057
            </xs:annotation>
1058
         </xs:attribute>
1059
         <xs:attribute name="outputUriResolver" use="optional" type="c:javaClassNameType">
1060
            <xs:annotation>
1061
               <xs:documentation>
1062
                  <p>The supplied class will be instantiated, and the resulting
1063
                    <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
1064
                documents selected in the <code>href</code> attribute of the XSLT
1065
                    <code>xsl:result-document</code> instruction.</p>
1066
               </xs:documentation>
1067
            </xs:annotation>
1068
         </xs:attribute>
1069
         <xs:attribute name="recoveryPolicy" use="optional" type="c:recoveryPolicyType">
1070
            <xs:annotation>
1071
               <xs:documentation>
1072
                  <p>Indicates the policy for handling dynamic errors that the XSLT specification defines
1073
                as recoverable. "recoverSilently" means recover silently; "recoverWithWarnings"
1074
                means recover after signalling a warning to the <code>ErrorListener</code>;
1075
                "doNotRecover" means treat the error as fatal. An example of a recoverable error is
1076
                when two template rules match the same node. </p>
1077
                  <p>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1078
                specification.</p>
1079
               </xs:documentation>
1080
            </xs:annotation>
1081
         </xs:attribute>
1082
         <xs:attribute name="schemaAware" use="optional" type="xs:boolean">
1083
            <xs:annotation>
1084
               <xs:documentation>
1085
                  <p>This property indicates whether stylesheets should be compiled with the ability to
1086
                handle schema-typed input documents. By default a stylesheet is compiled to handle
1087
                such input if it contains an <code>xsl:import-schema</code> instruction, and not
1088
                otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
1089
                to handle typed (validated) input documents in which nodes have type annotations
1090
                based on their schema-defined type.</p>
1091
                  <p>This option can be set for a particular XSLT compilation. When the option is set at
1092
                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1093
                acts as a default.</p>
1094
               </xs:documentation>
1095
            </xs:annotation>
1096
         </xs:attribute>
1097
         <xs:attribute name="staticErrorListener"
1098
                       use="optional"
1099
                       type="c:javaClassNameType">
1100
            <xs:annotation>
1101
               <xs:documentation>
1102
                  <p>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1103
                reports of static errors in a stylesheet will go to this
1104
                <code>ErrorListener</code>.</p>
1105
                  <p>This option can be set for a particular XSLT compilation. When the option is set at
1106
                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1107
                acts as a default.</p>
1108
                  <p>In the absence of this property, the global <code>ErrorListener</code> specified as
1109
                the value of the <link>net.sf.saxon.lib.FeatureKeys#ERROR_LISTENER_CLASS</link>
1110
                property is used.</p>
1111
               </xs:documentation>
1112
            </xs:annotation>
1113
         </xs:attribute>
1114
         <xs:attribute name="staticUriResolver" use="optional" type="c:javaClassNameType">
1115
            <xs:annotation>
1116
               <xs:documentation>
1117
                  <p>This property defines a <code>URIResolver</code> used when dereferencing the URIs
1118
                that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
1119
                    <code>xsl:import</code> declarations. Note that this defaults to the setting of
1120
                the global <code>URI_RESOLVER</code> property.</p>
1121
                  <p>This option can be set for a particular XSLT compilation. When the option is set at
1122
                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1123
                acts as a default.</p>
1124
                  <p>In the absence of this property, the global <code>URIResolver</code> specified as the
1125
                value of the <link>net.sf.saxon.lib.FeatureKeys#URI_RESOLVER_CLASS</link> property
1126
                is used.</p>
1127
               </xs:documentation>
1128
            </xs:annotation>
1129
         </xs:attribute>
1130
         <xs:attribute name="styleParser" use="optional" type="c:javaClassNameType">
1131
            <xs:annotation>
1132
               <xs:documentation>
1133
                  <p>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1134
                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1135
                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1136
                parse stylesheet documents (that is, the principal stylesheet module plus any
1137
                secondary source documents read using <code>xsl:include</code> or
1138
                    <code>xsl:import</code>) and also schema documents.</p>
1139
               </xs:documentation>
1140
            </xs:annotation>
1141
         </xs:attribute>
1142
         <xs:attribute name="version" use="optional" type="xs:decimal">
1143
            <xs:annotation>
1144
               <xs:documentation>
1145
                  <p>This property determines the version of XSLT to be supported by default.</p>
1146
                  <p>XSLT 3.0 is supported only in Saxon EE. If no value is specified for the property, an
1147
                XSLT 2.0 or XSLT 3.0 processor is used depending on the value of the
1148
                    <code>version</code> attribute of the <code>xsl:stylesheet</code> element.</p>
1149
               </xs:documentation>
1150
            </xs:annotation>
1151
         </xs:attribute>
1152
         <xs:attribute name="versionWarning" use="optional" type="xs:boolean">
1153
            <xs:annotation>
1154
               <xs:documentation>
1155
                  <p>Indicates whether a warning message should be notified (to the
1156
                    <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
1157
                specifies <code>version="1.0"</code>. The warning that an XSLT 1.0 stylesheet is
1158
                being processed using an XSLT 2.0 processor is output by default (because the W3C
1159
                specification requires it), but it may be suppressed using this option.</p>
1160
               </xs:documentation>
1161
            </xs:annotation>
1162
         </xs:attribute>
1163
      </xs:complexType>
1164
   </xs:element>
1165

    
1166
   <xs:element name="extensionElement">
1167
      <xs:annotation>
1168
         <xs:documentation> 
1169
        Describes a user-supplied library of XSLT extension instructions.
1170
      </xs:documentation>
1171
      </xs:annotation>
1172
      <xs:complexType>
1173
         <xs:attribute name="factory" use="optional" type="c:javaClassNameType">
1174
            <xs:annotation>
1175
               <xs:documentation> 
1176
            The Java class that implements the extension instructions.
1177
          </xs:documentation>
1178
            </xs:annotation>
1179
         </xs:attribute>
1180
         <xs:attribute name="namespace" use="optional" type="xs:anyURI">
1181
            <xs:annotation>
1182
               <xs:documentation> 
1183
            The namespace URI of the extension instructions implemented by this extension library.
1184
          </xs:documentation>
1185
            </xs:annotation>
1186
         </xs:attribute>
1187
      </xs:complexType>
1188
   </xs:element>
1189

    
1190
   <xs:element name="xquery">
1191
      <xs:annotation>
1192
         <xs:documentation> 
1193
        Defines configuration properties specific to XQuery processing.
1194
      </xs:documentation>
1195
      </xs:annotation>
1196
      <xs:complexType>
1197
         <xs:attribute name="allowUpdate" use="optional" type="xs:boolean">
1198
            <xs:annotation>
1199
               <xs:documentation>
1200
                  <p>Determines whether XQuery Update syntax is accepted. If true, update syntax is
1201
                accepted, if false, it is not accepted. Setting the value to true does not mean that
1202
                the query has to use update syntax, only that it may do so.</p>
1203
                  <p>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
1204
                this combination is not defined by any W3C specification at the time of writing.</p>
1205
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1206
                the <code>Configuration</code> level, it acts as a default.</p>
1207
                  <p>On the command line, this option is combined with the option "discard" which
1208
                indicates that updates are allowed, but the updates are not written back to
1209
                filestore. This does not correspond to any option in the Java API, where writing an
1210
                updated document back to filestore only happens if explicitly requested.</p>
1211
               </xs:documentation>
1212
            </xs:annotation>
1213
         </xs:attribute>
1214
         <xs:attribute name="constructionMode"
1215
                       use="optional"
1216
                       type="c:constructionModeType">
1217
            <xs:annotation>
1218
               <xs:documentation>
1219
                  <p>This option defines the default value of the construction mode in the XQuery static
1220
                context (overridable in the query prolog).</p>
1221
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1222
                the <code>Configuration</code> level, it acts as a default.</p>
1223
               </xs:documentation>
1224
            </xs:annotation>
1225
         </xs:attribute>
1226
         <xs:attribute name="defaultElementNamespace" use="optional" type="xs:anyURI">
1227
            <xs:annotation>
1228
               <xs:documentation>
1229
                  <p>This property defines the default namespace for elements and types that are not
1230
                qualified by a namespace prefix.</p>
1231
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1232
                the <code>Configuration</code> level, it acts as a default.</p>
1233
               </xs:documentation>
1234
            </xs:annotation>
1235
         </xs:attribute>
1236
         <xs:attribute name="defaultFunctionNamespace" use="optional" type="xs:anyURI">
1237
            <xs:annotation>
1238
               <xs:documentation>
1239
                  <p>This property defines the default namespace for function names that are not
1240
                qualified by a namespace prefix.</p>
1241
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1242
                the <code>Configuration</code> level, it acts as a default.</p>
1243
               </xs:documentation>
1244
            </xs:annotation>
1245
         </xs:attribute>
1246
         <xs:attribute name="emptyLeast" use="optional" type="xs:boolean">
1247
            <xs:annotation>
1248
               <xs:documentation>
1249
                  <p>This property defines how the empty sequence is handled in XQuery sorting (the "order
1250
                by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
1251
                false, it comes last.</p>
1252
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1253
                the <code>Configuration</code> level, it acts as a default.</p>
1254
               </xs:documentation>
1255
            </xs:annotation>
1256
         </xs:attribute>
1257
         <xs:attribute name="inheritNamespaces" use="optional" type="xs:boolean">
1258
            <xs:annotation>
1259
               <xs:documentation>
1260
                  <p>This property defines the default value of the <code>inherit-namespaces</code>
1261
                property in the XQuery static context.</p>
1262
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1263
                the <code>Configuration</code> level, it acts as a default.</p>
1264
               </xs:documentation>
1265
            </xs:annotation>
1266
         </xs:attribute>
1267
         <xs:attribute name="moduleUriResolver" use="optional" type="c:javaClassNameType">
1268
            <xs:annotation>
1269
               <xs:documentation>
1270
                  <p>Affects XQuery only. The name of a user-written class implementing Saxon's
1271
                    <link>net.sf.saxon.lib.ModuleURIResolver</link> interface. This is used to
1272
                process any URIs used in <code>import module</code> directives in XQuery.</p>
1273
               </xs:documentation>
1274
            </xs:annotation>
1275
         </xs:attribute>
1276
         <xs:attribute name="preserveBoundarySpace" use="optional" type="xs:boolean">
1277
            <xs:annotation>
1278
               <xs:documentation>
1279
                  <p>This property defines whether "boundary space" (insignificant space in direct element
1280
                constructors) should be retained or not.</p>
1281
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1282
                the <code>Configuration</code> level, it acts as a default.</p>
1283
               </xs:documentation>
1284
            </xs:annotation>
1285
         </xs:attribute>
1286
         <xs:attribute name="preserveNamespaces" use="optional" type="xs:boolean">
1287
            <xs:annotation>
1288
               <xs:documentation>
1289
                  <p>This property defines whether unused namespace declarations are retained by XQuery
1290
                element copy operations.</p>
1291
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1292
                the <code>Configuration</code> level, it acts as a default.</p>
1293
               </xs:documentation>
1294
            </xs:annotation>
1295
         </xs:attribute>
1296
         <xs:attribute name="requiredContextItemType" use="optional" type="c:itemTypeType">
1297
            <xs:annotation>
1298
               <xs:documentation>
1299
                  <p>This property defines the default expected context item type for a query.</p>
1300
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1301
                the <code>Configuration</code> level, it acts as a default.</p>
1302
               </xs:documentation>
1303
            </xs:annotation>
1304
         </xs:attribute>
1305
         <xs:attribute name="schemaAware" use="optional" type="xs:boolean">
1306
            <xs:annotation>
1307
               <xs:documentation>
1308
                  <p>A query will automatically be schema-aware if it contains an <code>import
1309
                    schema</code> declaration. This property allows a query to be marked as
1310
                schema-aware even if it contains no <code>import schema</code> declaration. It is
1311
                necessary for a query to be compiled as schema-aware if it is to handle typed
1312
                (validated) input documents in which nodes have type annotations based on their
1313
                schema-defined type.</p>
1314
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1315
                the <code>Configuration</code> level, it acts as a default.</p>
1316
               </xs:documentation>
1317
            </xs:annotation>
1318
         </xs:attribute>
1319
         <xs:attribute name="staticErrorListener"
1320
                       use="optional"
1321
                       type="c:javaClassNameType">
1322
            <xs:annotation>
1323
               <xs:documentation>
1324
                  <p>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1325
                reports of static errors in a query will go to this <code>ErrorListener</code>.</p>
1326
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1327
                the <code>Configuration</code> level, it acts as a default.</p>
1328
                  <p>In the absence of this property, the global <code>ErrorListener</code> specified as
1329
                the value of the <link>net.sf.saxon.lib.FeatureKeys#ERROR_LISTENER_CLASS</link>
1330
                property is used.</p>
1331
               </xs:documentation>
1332
            </xs:annotation>
1333
         </xs:attribute>
1334
         <xs:attribute name="version" use="optional" type="xs:decimal">
1335
            <xs:annotation>
1336
               <xs:documentation>
1337
                  <p>This property determines the version of XQuery used by the
1338
                <code>Configuration</code>. In order to use XQuery 3.0, it is necessary both to set
1339
                the XQuery compiler to process XQuery 3.0, and to specify XQuery 3.0 in the query
1340
                prolog of each module that uses XQuery 3.0 features.</p>
1341
                  <p>This option can be set for a particular XQuery compilation. When the option is set at
1342
                the <code>Configuration</code> level, it acts as a default.</p>
1343
                  <p>Note that XQuery 3.0 features cannot be used with XQuery Update.</p>
1344
                  <p>XQuery 3.0 is supported only in Saxon EE.</p>
1345
               </xs:documentation>
1346
            </xs:annotation>
1347
         </xs:attribute>
1348
      </xs:complexType>
1349
   </xs:element>
1350

    
1351
   <xs:element name="xsd">
1352
      <xs:annotation>
1353
         <xs:documentation> 
1354
        Defines configuration properties specific to XML Schema processing.
1355
      </xs:documentation>
1356
      </xs:annotation>
1357
      <xs:complexType>
1358
         <xs:attribute name="assertionsCanSeeComments" use="optional" type="xs:boolean">
1359
            <xs:annotation>
1360
               <xs:documentation>
1361
                  <p>ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in
1362
                a document being validated are visible to assertions in an XSD 1.1 schema.</p>
1363
                  <p>If the value is false (the default), comments and processing instructions are
1364
                stripped from the view of the document that is made visible to the XPath expression
1365
                that implements the assertion. If this creates adjacent text nodes, they are
1366
                collapsed into a single text node.</p>
1367
                  <p>If the value is true, then comments and processing instructions are visible to the
1368
                XPath assertion.</p>
1369
               </xs:documentation>
1370
            </xs:annotation>
1371
         </xs:attribute>
1372
         <xs:attribute name="multipleSchemaImports" use="optional" type="xs:boolean">
1373
            <xs:annotation>
1374
               <xs:documentation>
1375
                  <p>Affects schema construction (whether for standalone validation, or in the context of
1376
                XSLT or XQuery). If set to true, the schema processor attempts to fetch a schema
1377
                document appearing in an <code>xs:import</code> directive, whether or not a schema
1378
                for that namespace has already been loaded, unless the absolute URI formed from the
1379
                    <code>schemaLocation</code> is the same as the absolute URI that was used to
1380
                load that namespace. If set to false, the schema processor ignores the
1381
                    <code>schemaLocation</code> on an <code>xs:import</code> declaration if schema
1382
                components for the requested namespace are already available. Note that setting the
1383
                value to true might cause spurious errors due to like-named schema components being
1384
                loaded more than once. On the other hand, setting the value to false might result in
1385
                validation failing because schema components are missing.</p>
1386
                  <p>Note: Both settings are conformant with the W3C recommendation, which leaves the
1387
                details implementation-defined. It is possible (and advisable) to write schemas in
1388
                such a way that this setting makes no difference, by ensuring that all imports for a
1389
                particular namespace go via a "home" schema document for that namespace, where the
1390
                home schema document contains <code>xs:include</code> declarations for all the
1391
                schema documents defining components in that namespace.</p>
1392
               </xs:documentation>
1393
            </xs:annotation>
1394
         </xs:attribute>
1395
         <xs:attribute name="occurrenceLimits"
1396
                       use="optional"
1397
                       type="c:occurrenceLimitsType">
1398
            <xs:annotation>
1399
               <xs:documentation>
1400
                  <p>
1401
                     <code>OCCURRENCE_LIMITS</code> determines the largest values of
1402
                    <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
1403
                compiling an "expanded" finite state machine to represent an XSD content model
1404
                grammar. These limits do not apply in the common cases where the grammar can be
1405
                implemented using a counting finite-state-machine, but in those cases where this is
1406
                not possible, any <code>minOccurs</code> value greater than the first integer is
1407
                reduced to the value of the first integer, and any <code>maxOccurs</code> value
1408
                greater than the second integer is treated as "unbounded".</p>
1409
                  <p>Setting these values too high may cause an <code>OutOfMemoryException</code> since
1410
                the size of the finite state machine constructed by Saxon increases linearly with
1411
                the values of <code>minOccurs</code> and <code>maxOccurs</code>.</p>
1412
               </xs:documentation>
1413
            </xs:annotation>
1414
         </xs:attribute>
1415
         <xs:attribute name="schemaUriResolver" use="optional" type="c:javaClassNameType">
1416
            <xs:annotation>
1417
               <xs:documentation>
1418
                  <p>The name of a class that implements the interface <code>SchemaURIResolver</code>;
1419
                this class will be instantiated and the resulting instance will be used as the value
1420
                of the <link>net.sf.saxon.lib.FeatureKeys#SCHEMA_URI_RESOLVER</link> property.</p>
1421
               </xs:documentation>
1422
            </xs:annotation>
1423
         </xs:attribute>
1424
         <xs:attribute name="useXsiSchemaLocation" use="optional" type="xs:boolean">
1425
            <xs:annotation>
1426
               <xs:documentation>
1427
                  <p>This option determines whether or not to use the <code>xsi:schemaLocation</code>
1428
                    and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
1429
                document to locate a schema for validation.</p>
1430
                  <p>Note, these attribute are only consulted if validation is requested; the presence of
1431
                one of these attributes never by itself triggers validation.</p>
1432
               </xs:documentation>
1433
            </xs:annotation>
1434
         </xs:attribute>
1435
         <xs:attribute name="version" use="optional" type="xs:decimal">
1436
            <xs:annotation>
1437
               <xs:documentation>
1438
                  <p>This property determines the version of XML Schema used by the
1439
                    <code>Configuration</code>. The default is XSD 1.0. If XSD 1.0 is selected, XSD
1440
                1.1 features will be rejected, with the exception of the version control attributes
1441
                that allow sections of the schema to be marked as requiring XSD 1.0 or XSD 1.1.</p>
1442
               </xs:documentation>
1443
            </xs:annotation>
1444
         </xs:attribute>
1445
      </xs:complexType>
1446
   </xs:element>
1447

    
1448
   <xs:element name="resources">
1449
      <xs:annotation>
1450
         <xs:documentation> 
1451
        Defines additional classes available for integration purposes.
1452
      </xs:documentation>
1453
      </xs:annotation>
1454
      <xs:complexType>
1455
         <xs:choice minOccurs="0" maxOccurs="unbounded">
1456

    
1457
            <xs:element ref="c:externalObjectModel"/>
1458

    
1459
            <xs:element ref="c:extensionFunction"/>
1460

    
1461
            <xs:element ref="c:schemaDocument"/>
1462

    
1463
            <xs:element ref="c:schemaComponentModel"/>
1464
         </xs:choice>
1465
      </xs:complexType>
1466
   </xs:element>
1467

    
1468
   <xs:element name="externalObjectModel" type="c:javaClassNameType">
1469
      <xs:annotation>
1470
         <xs:documentation> 
1471
        Defines an external object model (tree representation). The content is the name
1472
        of a Java class that implements <code>net.sf.saxon.lib.ExternalObjectModel</code>.
1473
      </xs:documentation>
1474
      </xs:annotation>
1475
   </xs:element>
1476

    
1477
   <xs:element name="extensionFunction" type="c:javaClassNameType">
1478
      <xs:annotation>
1479
         <xs:documentation> 
1480
        Defines an external function, implemented in Java, that can be called from
1481
        within an XPath expression. The content is the name of a Java class that
1482
        implements <code>net.sf.saxon.lib.ExtensionFunctionDefinition</code>
1483
         </xs:documentation>
1484
      </xs:annotation>
1485
   </xs:element>
1486

    
1487
   <xs:element name="schemaDocument" type="xs:anyURI">
1488
      <xs:annotation>
1489
         <xs:documentation> 
1490
        Provides the location of a schema document that will 
1491
        be preloaded into the configuration and made
1492
        available to all queries and stylesheets.
1493
      </xs:documentation>
1494
      </xs:annotation>
1495
   </xs:element>
1496

    
1497
   <xs:element name="schemaComponentModel" type="xs:anyURI">
1498
      <xs:annotation>
1499
         <xs:documentation> 
1500
        Provides the location of a schema in Saxon's SCM format that 
1501
        will be preloaded into the configuration and made
1502
        available to all queries and stylesheets.
1503
      </xs:documentation>
1504
      </xs:annotation>
1505
   </xs:element>
1506
   <xs:simpleType name="constructionModeType">
1507
      <xs:annotation>
1508
         <xs:documentation>
1509
            <p>Defines how an XQuery processor will handle whitespace in element
1510
        constructors. One of:</p>
1511
            <ul>
1512
               <li>strip - whitespace in the query is ignored </li>
1513
               <li>preserve - whitespace in the query is copied to the result tree </li>
1514
            </ul>
1515
         </xs:documentation>
1516
      </xs:annotation>
1517
      <xs:restriction base="xs:string">
1518
         <xs:enumeration value="strip">
1519
            <xs:annotation>
1520
               <xs:documentation> 
1521
            Whitespace in element constructors is ignored
1522
          </xs:documentation>
1523
            </xs:annotation>
1524
         </xs:enumeration>
1525
         <xs:enumeration value="preserve">
1526
            <xs:annotation>
1527
               <xs:documentation> 
1528
            Whitespace in element constructors is copied to the result tree
1529
          </xs:documentation>
1530
            </xs:annotation>
1531
         </xs:enumeration>
1532
      </xs:restriction>
1533
   </xs:simpleType>
1534
   <xs:simpleType name="caseOrderType">
1535
      <xs:annotation>
1536
         <xs:documentation> Used for the case-order property of a collation: defines whether lower-case
1537
        collates before or after upper-case, other things being equal. One of: upper-first,
1538
        lower-first, #default. 
1539
      </xs:documentation>
1540
      </xs:annotation>
1541
      <xs:restriction base="xs:string">
1542
         <xs:enumeration value="upper-first">
1543
            <xs:annotation>
1544
               <xs:documentation> 
1545
            Upper-case precedes lower-case in sort order
1546
          </xs:documentation>
1547
            </xs:annotation>
1548
         </xs:enumeration>
1549
         <xs:enumeration value="lower-first">
1550
            <xs:annotation>
1551
               <xs:documentation> 
1552
            Lower-case precedes upper-case in sort order
1553
          </xs:documentation>
1554
            </xs:annotation>
1555
         </xs:enumeration>
1556
         <xs:enumeration value="#default">
1557
            <xs:annotation>
1558
               <xs:documentation> 
1559
            This value imposes no constraints
1560
          </xs:documentation>
1561
            </xs:annotation>
1562
         </xs:enumeration>
1563
      </xs:restriction>
1564
   </xs:simpleType>
1565
   <xs:simpleType name="decompositionType">
1566
      <xs:annotation>
1567
         <xs:documentation> Used for the decomposition property of a collation: defines whether a
1568
        string is converted to decomposed normal form before comparisons are made, and if so, which
1569
        form is to be used. One of: none, standard, or full. </xs:documentation>
1570
      </xs:annotation>
1571
      <xs:restriction base="xs:string">
1572
         <xs:enumeration value="none">
1573
            <xs:annotation>
1574
               <xs:documentation> 
1575
            No decomposition of Unicode combining characters is performed before sorting
1576
          </xs:documentation>
1577
            </xs:annotation>
1578
         </xs:enumeration>
1579
         <xs:enumeration value="standard">
1580
            <xs:annotation>
1581
               <xs:documentation> 
1582
            Standard decomposition of Unicode combining characters is performed before sorting
1583
          </xs:documentation>
1584
            </xs:annotation>
1585
         </xs:enumeration>
1586
         <xs:enumeration value="full">
1587
            <xs:annotation>
1588
               <xs:documentation> 
1589
            Full decomposition of Unicode combining characters is performed before sorting
1590
          </xs:documentation>
1591
            </xs:annotation>
1592
         </xs:enumeration>
1593
      </xs:restriction>
1594
   </xs:simpleType>
1595
   <xs:simpleType name="editionType">
1596
      <xs:annotation>
1597
         <xs:documentation> Code describing a Saxon product edition. One of: HE (Home Edition), PE
1598
        (Professional Edition), EE (Enterprise Edition) </xs:documentation>
1599
      </xs:annotation>
1600
      <xs:restriction base="xs:string">
1601
         <xs:enumeration value="HE">
1602
            <xs:annotation>
1603
               <xs:documentation> 
1604
            Saxon Home Edition
1605
          </xs:documentation>
1606
            </xs:annotation>
1607
         </xs:enumeration>
1608
         <xs:enumeration value="PE">
1609
            <xs:annotation>
1610
               <xs:documentation> 
1611
            Saxon Professional Edition
1612
          </xs:documentation>
1613
            </xs:annotation>
1614
         </xs:enumeration>
1615
         <xs:enumeration value="EE">
1616
            <xs:annotation>
1617
               <xs:documentation> 
1618
            Saxon Enterprise Edition
1619
          </xs:documentation>
1620
            </xs:annotation>
1621
         </xs:enumeration>
1622
      </xs:restriction>
1623
   </xs:simpleType>
1624
   <xs:simpleType name="fileNameType">
1625
      <xs:annotation>
1626
         <xs:documentation> 
1627
        A file name, usually for output. Currently implemented simply as a string.
1628
      </xs:documentation>
1629
      </xs:annotation>
1630
      <xs:restriction base="xs:string"/>
1631
   </xs:simpleType>
1632
   <xs:simpleType name="itemTypeType">
1633
      <xs:annotation>
1634
         <xs:documentation> An XPath item type, such as "item()", "node()", "element(*, xs:anyType)",
1635
        or "xs:string". Currently implemented simply as a string. 
1636
      </xs:documentation>
1637
      </xs:annotation>
1638
      <xs:restriction base="xs:string">
1639
         <xs:minLength value="1"/>
1640
      </xs:restriction>
1641
   </xs:simpleType>
1642
   <xs:simpleType name="javaClassNameType">
1643
      <xs:annotation>
1644
         <xs:documentation> A fully-qualified Java class name: a sequence of identifiers separated by
1645
        periods, where each identifier starts with a letter (or dollar or underscore), and continues
1646
        with letters or digits (or dollar or underscore). The definition of "letter" used in this
1647
        regular expression does not exactly match the Java definition, but the differences are
1648
        unlikely to matter. May also be a zero-length string to indicate the default value.
1649
      </xs:documentation>
1650
      </xs:annotation>
1651
      <xs:restriction base="xs:string">
1652
         <xs:pattern value="(([\p{L}$_][\p{L}$_0-9]*)(\.[\p{L}$_][\p{L}$_0-9]*)*)?"/>
1653
      </xs:restriction>
1654
   </xs:simpleType>
1655
   <xs:simpleType name="listOfQNameType">
1656
      <xs:annotation>
1657
         <xs:documentation> A space-separated list of QNames. Used in serialization parameters such as
1658
        cdata-section-elements. </xs:documentation>
1659
      </xs:annotation>
1660
      <xs:list itemType="xs:QName"/>
1661
   </xs:simpleType>
1662
   <xs:simpleType name="occurrenceLimitsType">
1663
      <xs:annotation>
1664
         <xs:documentation> Highest values of minOccurs/maxOccurs for which accurate finite state
1665
        automata should be generated during schema compilation. High limits can cause a large amount
1666
        of memory to be used. Occurrence limits greater than these values may be non-strictly
1667
        enforced. Format is a pair of integers, comma-separated. </xs:documentation>
1668
      </xs:annotation>
1669
      <xs:restriction base="xs:string">
1670
         <xs:pattern value="[0-9]+,\s*[0-9]+"/>
1671
      </xs:restriction>
1672
   </xs:simpleType>
1673
   <xs:simpleType name="recoveryPolicyType">
1674
      <xs:annotation>
1675
         <xs:documentation> Defines how an XSLT processor will handle recoverable errors. One of: -
1676
        recoverSilently - take the recovery action and continue silently - recoverWithWarnings -
1677
        take the recovery action and continue with a warning - doNotRecover - terminate with a fatal
1678
        error </xs:documentation>
1679
      </xs:annotation>
1680
      <xs:restriction base="xs:string">
1681
         <xs:enumeration value="recoverSilently">
1682
            <xs:annotation>
1683
               <xs:documentation> 
1684
            For XSLT recoverable dynamic errors, Saxon recovers silently
1685
          </xs:documentation>
1686
            </xs:annotation>
1687
         </xs:enumeration>
1688
         <xs:enumeration value="recoverWithWarnings">
1689
            <xs:annotation>
1690
               <xs:documentation> 
1691
            For XSLT recoverable dynamic errors, Saxon recovers but outputs a warning
1692
          </xs:documentation>
1693
            </xs:annotation>
1694
         </xs:enumeration>
1695
         <xs:enumeration value="doNotRecover">
1696
            <xs:annotation>
1697
               <xs:documentation> 
1698
            For XSLT recoverable dynamic errors, Saxon reports an error and does not recover
1699
          </xs:documentation>
1700
            </xs:annotation>
1701
         </xs:enumeration>
1702
      </xs:restriction>
1703
   </xs:simpleType>
1704
   <xs:simpleType name="schemaValidationType">
1705
      <xs:annotation>
1706
         <xs:documentation> A request for schema validation (or non-validation). One of: strict -
1707
        validation must be performed lax - validation performed if an element declaration is
1708
        available preserve - existing type annotations are retained strip - no validation performed,
1709
        existing type annotations are dropped </xs:documentation>
1710
      </xs:annotation>
1711
      <xs:restriction base="xs:string">
1712
         <xs:enumeration value="strict">
1713
            <xs:annotation>
1714
               <xs:documentation> 
1715
            Strict validation: an element declaration must be present and the instance must be valid
1716
          </xs:documentation>
1717
            </xs:annotation>
1718
         </xs:enumeration>
1719
         <xs:enumeration value="lax">
1720
            <xs:annotation>
1721
               <xs:documentation> 
1722
            Lax validation: if an element declaration is present then the instance must be valid
1723
          </xs:documentation>
1724
            </xs:annotation>
1725
         </xs:enumeration>
1726
         <xs:enumeration value="preserve">
1727
            <xs:annotation>
1728
               <xs:documentation> 
1729
            Existing type annotations are preserved when copying, no validation takes place
1730
          </xs:documentation>
1731
            </xs:annotation>
1732
         </xs:enumeration>
1733
         <xs:enumeration value="strip">
1734
            <xs:annotation>
1735
               <xs:documentation> 
1736
            Existing type annotations are discarded when copying, no validation takes place
1737
          </xs:documentation>
1738
            </xs:annotation>
1739
         </xs:enumeration>
1740
      </xs:restriction>
1741
   </xs:simpleType>
1742
   <xs:simpleType name="strengthType">
1743
      <xs:annotation>
1744
         <xs:documentation> Defines the values of the strength property of a collation. Defines which
1745
        properties of a string are considered significant. One of: primary, secondary, tertiary, or
1746
        identical. </xs:documentation>
1747
      </xs:annotation>
1748
      <xs:restriction base="xs:string">
1749
         <xs:enumeration value="primary"/>
1750
         <xs:enumeration value="secondary"/>
1751
         <xs:enumeration value="tertiary"/>
1752
         <xs:enumeration value="identical"/>
1753
      </xs:restriction>
1754
   </xs:simpleType>
1755
   <xs:simpleType name="streamabilityType">
1756
      <xs:annotation>
1757
         <xs:documentation> Determines the test that Saxon applies to determine whether 
1758
        a construct is streamable, in cases where streaming is requested. </xs:documentation>
1759
      </xs:annotation>
1760
      <xs:restriction base="xs:string">
1761
         <xs:enumeration value="off">
1762
            <xs:annotation>
1763
               <xs:documentation> 
1764
            All constructs are treated as non-streamable. This is the only 
1765
            option available when using a Saxon version or license that does not enable streaming.
1766
          </xs:documentation>
1767
            </xs:annotation>
1768
         </xs:enumeration>
1769
         <xs:enumeration value="standard">
1770
            <xs:annotation>
1771
               <xs:documentation> 
1772
            Saxon applies the rules in the W3C XSLT 3.0 specification as 
1773
            closely as possible. (Exact compliance is not always possible.)
1774
          </xs:documentation>
1775
            </xs:annotation>
1776
         </xs:enumeration>
1777
         <xs:enumeration value="extended">
1778
            <xs:annotation>
1779
               <xs:documentation> 
1780
            Use of Saxon streaming extensions is permitted. This is the 
1781
            default when using Saxon-EE with a suitable license.
1782
          </xs:documentation>
1783
            </xs:annotation>
1784
         </xs:enumeration>
1785
      </xs:restriction>
1786
   </xs:simpleType>
1787
   <xs:simpleType name="stripSpaceType">
1788
      <xs:annotation>
1789
         <xs:documentation> Option for stripping whitespace in source documents. One of: all - all
1790
        whitespace text nodes are removed, unless xml:space="preserve" is present none - no
1791
        whitespace text nodes are removed ignorable - whitespace text nodes in element-only content
1792
        (identified by schema or DTD) are stripped </xs:documentation>
1793
      </xs:annotation>
1794
      <xs:restriction base="xs:string">
1795
         <xs:enumeration value="all">
1796
            <xs:annotation>
1797
               <xs:documentation> 
1798
            All whitespace-only text nodes are removed from the source document
1799
          </xs:documentation>
1800
            </xs:annotation>
1801
         </xs:enumeration>
1802
         <xs:enumeration value="none">
1803
            <xs:annotation>
1804
               <xs:documentation> 
1805
            No whitespace-only text nodes are removed from the source document
1806
          </xs:documentation>
1807
            </xs:annotation>
1808
         </xs:enumeration>
1809
         <xs:enumeration value="ignorable">
1810
            <xs:annotation>
1811
               <xs:documentation> 
1812
            Whitespace-only text nodes are removed from the source document if the containing element
1813
            is described in a DTD or schema as having element-only content
1814
          </xs:documentation>
1815
            </xs:annotation>
1816
         </xs:enumeration>
1817
      </xs:restriction>
1818
   </xs:simpleType>
1819
   <xs:simpleType name="treeModelType">
1820
      <xs:annotation>
1821
         <xs:documentation> Choice of XDM tree model implementation for representing source documents.
1822
        One of: linkedTree - mutable tree using one Java object per node tinyTree - compact
1823
        immutable tree (default) tinyTreeCondensed - tinyTree with extra compression of text and
1824
        attribute values </xs:documentation>
1825
      </xs:annotation>
1826
      <xs:restriction base="xs:string">
1827
         <xs:enumeration value="linkedTree">
1828
            <xs:annotation>
1829
               <xs:documentation> 
1830
            Saxon linked tree implementation (one object per node). Useful for XQuery update.
1831
          </xs:documentation>
1832
            </xs:annotation>
1833
         </xs:enumeration>
1834
         <xs:enumeration value="tinyTree">
1835
            <xs:annotation>
1836
               <xs:documentation> 
1837
            Saxon tiny tree implementation: the default choice. A compact tree offering fast navigation.
1838
          </xs:documentation>
1839
            </xs:annotation>
1840
         </xs:enumeration>
1841
         <xs:enumeration value="tinyTreeCondensed">
1842
            <xs:annotation>
1843
               <xs:documentation> 
1844
            Saxon condensed tiny tree implementation: reduces memory usage but takes longer to build;
1845
            no performance penalty during tree navigation.
1846
          </xs:documentation>
1847
            </xs:annotation>
1848
         </xs:enumeration>
1849
      </xs:restriction>
1850
   </xs:simpleType>
1851
   <xs:simpleType name="yesOrNoType">
1852
      <xs:annotation>
1853
         <xs:documentation> Used for serialization parameters, and for collation parameters. One of
1854
        "yes" or "no". </xs:documentation>
1855
      </xs:annotation>
1856
      <xs:restriction base="xs:string">
1857
         <xs:enumeration value="yes">
1858
            <xs:annotation>
1859
               <xs:documentation> 
1860
            Sets the option on.
1861
          </xs:documentation>
1862
            </xs:annotation>
1863
         </xs:enumeration>
1864
         <xs:enumeration value="no">
1865
            <xs:annotation>
1866
               <xs:documentation> 
1867
            Sets the option off.
1868
          </xs:documentation>
1869
            </xs:annotation>
1870
         </xs:enumeration>
1871
      </xs:restriction>
1872
   </xs:simpleType>
1873
   <xs:simpleType name="yesOrNoOrOmitType">
1874
      <xs:annotation>
1875
         <xs:documentation> Used for "standalone" serialization parameter. One of "yes" or "no" or
1876
        "omit". </xs:documentation>
1877
      </xs:annotation>
1878
      <xs:restriction base="xs:string">
1879
         <xs:enumeration value="yes">
1880
            <xs:annotation>
1881
               <xs:documentation> 
1882
            Sets standalone="yes" in the XML declaration.
1883
          </xs:documentation>
1884
            </xs:annotation>
1885
         </xs:enumeration>
1886
         <xs:enumeration value="no">
1887
            <xs:annotation>
1888
               <xs:documentation> 
1889
            Sets standalone="no" in the XML declaration.
1890
          </xs:documentation>
1891
            </xs:annotation>
1892
         </xs:enumeration>
1893
         <xs:enumeration value="omit">
1894
            <xs:annotation>
1895
               <xs:documentation> 
1896
            There will be no 'standalone' attribute in the XML declaration.
1897
          </xs:documentation>
1898
            </xs:annotation>
1899
         </xs:enumeration>
1900
      </xs:restriction>
1901
   </xs:simpleType>
1902
   <xs:simpleType name="yesOrNoOrCodepointType">
1903
      <xs:annotation>
1904
         <xs:documentation> Used for "alphanumeric" property of a collation. One of "yes" or "no" or
1905
        "codepoint". </xs:documentation>
1906
      </xs:annotation>
1907
      <xs:restriction base="xs:string">
1908
         <xs:enumeration value="yes">
1909
            <xs:annotation>
1910
               <xs:documentation> 
1911
            Selects a collation in which a sequence of digits is treated as a number: AA100 sorts after AA99
1912
          </xs:documentation>
1913
            </xs:annotation>
1914
         </xs:enumeration>
1915
         <xs:enumeration value="no">
1916
            <xs:annotation>
1917
               <xs:documentation> 
1918
            Selects a collation in which digits are sorted as individual characters: AA100 sorts before AA99
1919
          </xs:documentation>
1920
            </xs:annotation>
1921
         </xs:enumeration>
1922
         <xs:enumeration value="codepoint">
1923
            <xs:annotation>
1924
               <xs:documentation> 
1925
            Selects a collation in which a sequence of digits is treated as a number (AA100 sorts after AA99),
1926
            and other characters are sorted by Unicode codepoint value
1927
          </xs:documentation>
1928
            </xs:annotation>
1929
         </xs:enumeration>
1930
      </xs:restriction>
1931
   </xs:simpleType>
1932
</xs:schema>
(1-1/5)