Project

Profile

Help

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

he / latest10 / hen / csource / api / FeatureKeys.cs @ aac4a1be

1

    
2
using System;
3

    
4
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
5

    
6
namespace Saxon.Api 
7
{
8

    
9
/// <summary>
10
/// <c>FeatureKeys</c> defines a set of constants, representing the names of Saxon configuration
11
/// options which can be supplied to the Saxon implementations of the JAXP
12
/// interfaces <c>TransformerFactory</c>, <c>SchemaFactory</c>, <c>Validator</c>, and <c>ValidationHandler</c>,
13
/// and to other interfaces such as the s9api <c>net.sf.saxon.s9api.Processor</c> 
14
/// </summary>
15

    
16
public abstract class FeatureKeys 
17
{
18

    
19

    
20
    /// <summary><para>ALLOW_EXTERNAL_FUNCTIONS determines whether calls to reflexive external functions are
21
    ///                allowed.</para>
22
    /// </summary>
23
    /// <remarks>
24
    ///            <para>More specifically, if set to <b>false</b> it disallows all of the
25
    ///                following:</para>
26
    ///            <list>
27
    ///                <item>Calls to reflexive Java extension functions</item>
28
    ///                <item>Use of the XSLT <code>system-property()</code> function to access Java system
29
    ///                    properties</item>
30
    ///                <item>Use of a URI in the <code>href</code> attribute of an <code>xsl:result-document</code> instruction</item>
31
    ///                <item>Calls to XSLT extension instructions</item>
32
    ///            </list>
33
    ///            <para>The default value is <b>true</b>. The setting <b>false</b> is recommended in an
34
    ///                environment where untrusted stylesheets may be executed.</para>
35
    ///            <para>This option does not disable use of the <code>doc()</code> function or similar
36
    ///                functions to access the filestore of the machine where the transformation or query
37
    ///                is running. That should be done using a user-supplied <code>URIResolver</code>.</para>
38
    ///            <para>Note that integrated extension functions are trusted; calls to such functions are
39
    ///                allowed even if this configuration option is false. In cases where an integrated
40
    ///                extension function is used to load and execute untrusted code, it should check this
41
    ///                configuration option before doing so.</para>
42
    ///            <para>If the value of the property is false, then it will also be set to false on any new
43
    ///            Configuration created using the <code>fn:transform()</code> function.</para>
44
    ///        
45
    /// </remarks>
46

    
47
    public const String ALLOW_EXTERNAL_FUNCTIONS = 
48
        "http://saxon.sf.net/feature/allow-external-functions";
49

    
50
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
51

    
52

    
53
    /// <summary><para>ALLOW_MULTITHREADING determines whether multi-threading is allowed.</para>
54
    /// </summary>
55
    /// <remarks>
56
    ///            <para>If true (the default), the presence of the attribute <code>saxon:threads="N"</code>
57
    ///                on an <code>xsl:for-each</code> instruction, when running under Saxon-EE, causes
58
    ///                multi-threaded execution. If set to false, the value of the
59
    ///                    <code>saxon:threads</code> argument is ignored.</para>
60
    ///            <para>Setting the value to false also disables asynchronous processing of
61
    ///                    <code>xsl:result-document</code> instructions.</para>
62
    ///            <para>The default value is true if Saxon-EE is in use, false otherwise.</para>
63
    ///        
64
    /// </remarks>
65

    
66
    public const String ALLOW_MULTITHREADING = 
67
        "http://saxon.sf.net/feature/allow-multithreading";
68

    
69
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
70

    
71

    
72
    /// <summary><para>ALLOW_OLD_JAVA_URI_FORMAT determines whether extension function calls to
73
    ///                dynamically-loaded Java extension functions may use the URI format supported in
74
    ///                older Saxon releases.</para>
75
    /// </summary>
76
    /// <remarks>
77
    ///            <para>If the value is false (the default), the only URI format accepted is (for example)
78
    ///                "java:java.util.Date" - that is, a URI consisting of the string "java:" followed by
79
    ///                the Java qualified class name of the class containing the implementation of the
80
    ///                extension function.</para>
81
    ///            <para>If the value is true, then in addition to this format, the following are accepted:
82
    ///                (a) the Java class name on its own ("java.util.Date"), and (b) any URI in which the
83
    ///                Java class name follows the last "/" character (for example
84
    ///                "http://my.com/extensions/java.util.Date"). This last format was originally provided
85
    ///                for compatibility with xt and xalan, but it causes problems because it leads to
86
    ///                unnecessary attempts to load spurious classes when the user did not intend the URI
87
    ///                to represent a dynamically-loaded Java class.</para>
88
    ///        
89
    /// </remarks>
90

    
91
    public const String ALLOW_OLD_JAVA_URI_FORMAT = 
92
        "http://saxon.sf.net/feature/allow-old-java-uri-format";
93

    
94
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
95

    
96

    
97
    /// <summary><para>This flag must be set to enable use of extensions to XPath, XQuery and XSLT
98
    ///                syntax that go beyond what is allowed by the extensibility mechanisms in the spec.
99
    ///                In some cases these extensions are experimental and may not be carried forward to future
100
    ///            Saxon releases.</para>
101
    /// </summary>
102
    /// <remarks>
103
    ///            <para>Syntax extensions in Saxon 10 include the use of type aliases (<code>type(...)</code> where
104
    ///                an item type is expected, and <code>declare type NAME = item-type</code> in the XQuery Prolog); 
105
    ///                and simple inline functions (for example <code>.{. + 1}</code>).</para>
106
    ///        
107
    /// </remarks>
108

    
109
    public const String ALLOW_SYNTAX_EXTENSIONS = 
110
        "http://saxon.sf.net/feature/allowSyntaxExtensions";
111

    
112
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
113

    
114

    
115
    /// <summary><para>ASSERTIONS_CAN_SEE_COMMENTS determines whether comment and processing instructions in
116
    ///                a document being validated are visible to assertions in an XSD 1.1 schema.</para>
117
    /// </summary>
118
    /// <remarks>
119
    ///            <para>If the value is false (the default), comments and processing instructions are
120
    ///                stripped from the view of the document that is made visible to the XPath expression
121
    ///                that implements the assertion. If this creates adjacent text nodes, they are
122
    ///                collapsed into a single text node.</para>
123
    ///            <para>If the value is true, then comments and processing instructions are visible to the
124
    ///                XPath assertion.</para>
125
    ///        
126
    /// </remarks>
127

    
128
    public const String ASSERTIONS_CAN_SEE_COMMENTS = 
129
        "http://saxon.sf.net/feature/assertionsCanSeeComments";
130

    
131
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
132

    
133

    
134
    /// <summary><para>The supplied <code>CollationURIResolver</code> is used to process any collation URIs
135
    ///                found in the query or stylesheet, returning an object of class
136
    ///                    <see cref="net.sf.saxon.lib.StringCollator" /> that implements the requested
137
    ///                collation.</para>
138
    /// </summary>
139

    
140
    public const String COLLATION_URI_RESOLVER = 
141
        "http://saxon.sf.net/feature/collation-uri-resolver";
142

    
143
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
144

    
145

    
146
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
147
    ///                the <see cref="COLLATION_URI_RESOLVER" /> property.</para>
148
    /// </summary>
149

    
150
    public const String COLLATION_URI_RESOLVER_CLASS = 
151
        "http://saxon.sf.net/feature/collation-uri-resolver-class";
152

    
153
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
154

    
155

    
156
    /// <summary><para>The supplied <code>CollectionFinder</code> is used to retrieve a <see cref="net.sf.saxon.lib.ResourceCollection" /> object given by any URI defined in
157
    ///                calls to the <code>collection()</code> or the <code>uri-collection()</code> function.</para>
158
    /// </summary>
159
    /// <remarks>
160
    ///            <para>If the argument is not specified then a default <code>ResourceCollection</code> should be handled.
161
    ///                <code>CollectionFinder</code> returns a <see cref="net.sf.saxon.lib.ResourceCollection" /> which is used to map the URI of collection into a
162
    ///                sequence of <see cref="net.sf.saxon.lib.Resource" /> objects
163
    ///                (which are then resolved in the same way as URIs passed to the <code>doc()</code>
164
    ///                function), or it may return an item (typically a node but can handle JSON documents).</para>
165
    ///        
166
    /// </remarks>
167

    
168
    public const String COLLECTION_FINDER = 
169
        "http://saxon.sf.net/feature/collection-finder";
170

    
171
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
172

    
173

    
174
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
175
    ///                the <see cref="COLLECTION_FINDER" /> property.</para>
176
    /// </summary>
177

    
178
    public const String COLLECTION_FINDER_CLASS = 
179
        "http://saxon.sf.net/feature/collection-finder-class";
180

    
181
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
182

    
183

    
184
    /// <summary><para>If run-time tracing of stylesheet or query execution is required, then the code must
185
    ///                be compiled with tracing enabled.</para>
186
    /// </summary>
187
    /// <remarks>
188
    ///            <para>Default is false. This option causes code to be
189
    ///                compiled that makes calls to a <see cref="net.sf.saxon.lib.TraceListener" />, but this
190
    ///                has no effect unless a <code>TraceListener</code> is registered at execution
191
    ///                time.</para>
192
    ///        
193
    /// </remarks>
194

    
195
    public const String COMPILE_WITH_TRACING = 
196
        "http://saxon.sf.net/feature/compile-with-tracing";
197

    
198
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
199

    
200

    
201
    /// <summary><para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself,
202
    ///                but it can be set on various JAXP factory objects such as a
203
    ///                <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
204
    ///                ensure that several such factories use the same <code>Configuration</code>.</para>
205
    /// </summary>
206
    /// <remarks>
207
    ///            <para>Note that other configuration options are held in the <code>Configuration</code> object,
208
    ///                so setting this attribute will cancel all others that have been set. Also, if two
209
    ///                factories share the same <code>Configuration</code>, then setting an attribute on
210
    ///                one affects all the others.</para>
211
    ///        
212
    /// </remarks>
213

    
214
    public const String CONFIGURATION = 
215
        "http://saxon.sf.net/feature/configuration";
216

    
217
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
218

    
219

    
220
    /// <summary><para>Defines a configuration file to be applied to the configuration.</para>
221
    /// </summary>
222
    /// <remarks>
223
    ///            <para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself, but it can be
224
    ///                set on various JAXP factory objects such as a <code>TransformerFactory</code> or
225
    ///                    <code>DocumentBuilderFactory</code>. It is particularly useful when running
226
    ///                transformations via the Ant xslt task, where it can be set as follows to define all
227
    ///                configuration settings: </para>
228
    ///            <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
229
    ///                    name="http://saxon.sf.net/feature/configuration-file"
230
    ///                    value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
231
    ///            </para>
232
    ///        
233
    /// </remarks>
234

    
235
    public const String CONFIGURATION_FILE = 
236
        "http://saxon.sf.net/feature/configuration-file";
237

    
238
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
239

    
240

    
241
    /// <summary><para>This option is set to indicate that bytecode generation should be run in debugging
242
    ///                mode; it injects diagnostic tracing calls into the generated bytecode. This should
243
    ///                be used only if requested by Saxonica support to diagnose a problem related to
244
    ///                bytecode generation.</para>
245
    /// </summary>
246

    
247
    public const String DEBUG_BYTE_CODE = 
248
        "http://saxon.sf.net/feature/debugByteCode";
249

    
250
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
251

    
252

    
253
    /// <summary><para>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
254
    ///                defines a directory to which files containing bytecode in human-readable form will
255
    ///                be written. There will be one such file for each generated class, with a filename
256
    ///                designed to give some kind of clue as to its relationship to the source code.</para>
257
    /// </summary>
258
    /// <remarks>
259
    ///            <para>The default value is the directory <code>saxonByteCode</code> within the current
260
    ///                working directory.</para>
261
    ///            <para>The named directory is created if it does not already exist.</para>
262
    ///            <para>Because the generation of class names involves random numbers, files will tend to
263
    ///                accumulate in the supplied directory, even when the same source code is compiled
264
    ///                repeatedly.</para>
265
    ///        
266
    /// </remarks>
267

    
268
    public const String DEBUG_BYTE_CODE_DIR = 
269
        "http://saxon.sf.net/feature/debugByteCodeDir";
270

    
271
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
272

    
273

    
274
    /// <summary><para>This option determines the collation that is used for comparing strings when no
275
    ///                explicit collation is requested. It is not necessary for this collation to exist (or
276
    ///                to have been registered) when setting this option; it only needs to exist by the
277
    ///                time it is used.</para>
278
    /// </summary>
279
    /// <remarks>
280
    ///            <para>In XSLT it is possible to override this setting using the
281
    ///                    <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
282
    ///                XQuery, it can be overridden using the <code>declare default collation</code>
283
    ///                declaration in the query prolog, or via a setter method in class
284
    ///                    <see cref="net.sf.saxon.query.StaticQueryContext" />.</para>
285
    ///            <para>If no value is specified, the Unicode codepoint collation is used.</para>
286
    ///        
287
    /// </remarks>
288

    
289
    public const String DEFAULT_COLLATION = 
290
        "http://saxon.sf.net/feature/defaultCollation";
291

    
292
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
293

    
294

    
295
    /// <summary><para>This determines the collection that is used when the <code>fn:collection()</code>
296
    ///                function is called with no arguments; the effect is the same as if it were called
297
    ///                passing the URI that is the value of this configuration property.</para>
298
    /// </summary>
299

    
300
    public const String DEFAULT_COLLECTION = 
301
        "http://saxon.sf.net/feature/defaultCollection";
302

    
303
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
304

    
305

    
306
    /// <summary><para>This determines the country that is used by <code>format-date()</code> and similar
307
    ///                functions if no country code is supplied explicitly. If no value is given for this
308
    ///                property, the default is taken from the Java Locale, which in turn typically depends
309
    ///                on settings for the current user in the operating system.</para>
310
    /// </summary>
311

    
312
    public const String DEFAULT_COUNTRY = 
313
        "http://saxon.sf.net/feature/defaultCountry";
314

    
315
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
316

    
317

    
318
    /// <summary><para>This option determines the language that is used by <code>format-date()</code>,
319
    ///                    <code>xsl:number</code> and similar constructs if no language code is supplied
320
    ///                explicitly. If no value is given for this property, the default is taken from the
321
    ///                Java Locale, which in turn typically depends on settings for the current user in the
322
    ///                operating system.</para>
323
    /// </summary>
324

    
325
    public const String DEFAULT_LANGUAGE = 
326
        "http://saxon.sf.net/feature/defaultLanguage";
327

    
328
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
329

    
330

    
331
    /// <summary><para>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
332
    ///            such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
333
    ///            in the pattern facet of a schema.</para>
334
    /// </summary>
335
    /// <remarks>
336
    ///            <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
337
    ///            provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
338
    ///            follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
339
    ///            <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
340
    ///                provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
341
    ///            in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
342
    ///            regex engine.</para>
343
    ///            <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
344
    ///            ";j", or ";n" to the flags argument of the relevant call. (This does not apply to XSD patterns, where no flags argument is available)</para>
345
    ///            <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
346
    ///            when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
347
    ///            expression dialect rather than the W3C dialect.</para>
348
    ///        
349
    /// </remarks>
350

    
351
    public const String DEFAULT_REGEX_ENGINE = 
352
        "http://saxon.sf.net/feature/defaultRegexEngine";
353

    
354
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
355

    
356

    
357
    /// <summary><para>This option disables the <code>xsl:evaluate</code> instruction.</para>
358
    /// </summary>
359
    /// <remarks>
360
    ///            <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
361
    ///                run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.) 
362
    ///                The feature is always disabled (statically) in Saxon-HE.</para>
363
    ///        
364
    /// </remarks>
365

    
366
    public const String DISABLE_XSL_EVALUATE = 
367
        "http://saxon.sf.net/feature/disableXslEvaluate";
368

    
369
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
370

    
371

    
372
    /// <summary><para>This option is set to indicate that bytecode generation should be run in display
373
    ///                mode. The effect is to output files (one per class) containing a human-readable
374
    ///                print of the generated bytecode. The files are placed in the directory identified by
375
    ///                the <code>DEBUG_BYTE_CODE_DIR</code> option.</para>
376
    /// </summary>
377

    
378
    public const String DISPLAY_BYTE_CODE = 
379
        "http://saxon.sf.net/feature/displayByteCode";
380

    
381
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
382

    
383

    
384
    /// <summary><para>If true, the XML parser is requested to perform validation of source documents
385
    ///                against their DTD. Default is false.</para>
386
    /// </summary>
387
    /// <remarks>
388
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
389
    ///                or schema documents) are parsed. The option can be overridden for individual
390
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
391
    ///                individual document, for example from a <code>URIResolver</code>.</para>
392
    ///        
393
    /// </remarks>
394

    
395
    public const String DTD_VALIDATION = 
396
        "http://saxon.sf.net/feature/validation";
397

    
398
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
399

    
400

    
401
    /// <summary><para>This option determines whether DTD validation failures should be treated as
402
    ///                recoverable. If the option is set, a validation failure is reported as a warning
403
    ///                rather than an error. The default is false.</para>
404
    /// </summary>
405
    /// <remarks>
406
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
407
    ///                or schema documents) are parsed. The option can be overridden for individual
408
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
409
    ///                individual document, for example from a <code>URIResolver</code>.</para>
410
    ///        
411
    /// </remarks>
412

    
413
    public const String DTD_VALIDATION_RECOVERABLE = 
414
        "http://saxon.sf.net/feature/dtd-validation-recoverable";
415

    
416
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
417

    
418

    
419
    /// <summary><para>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
420
    ///                for example when evaluating variables and function results. This can make for easier debugging.</para>
421
    /// </summary>
422
    /// <remarks>
423
    ///            <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
424
    ///            object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
425
    ///            intermediate expressions using iterators.</para>
426
    ///        
427
    /// </remarks>
428

    
429
    public const String EAGER_EVALUATION = 
430
        "http://saxon.sf.net/feature/eagerEvaluation";
431

    
432
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
433

    
434

    
435
    /// <summary><para>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
436
    ///                used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
437
    ///                documents. It is not used with a user-supplied <code>XMLReader</code>.</para>
438
    /// </summary>
439
    /// <remarks>
440
    ///            <para>The default value is <see cref="net.sf.saxon.lib.StandardEntityResolver" />. This is an entity
441
    ///                resolver that recognizes the names of many standard W3C DTDs and external entity
442
    ///                files, and resolves them against local copies issued with the Saxon software, to
443
    ///                avoid the need to fetch them from the web.</para>
444
    ///            <para>The property can be set to a zero-length string, in which case no
445
    ///                    <code>EntityResolver</code> will be used.</para>
446
    ///
447
    ///        
448
    /// </remarks>
449

    
450
    public const String ENTITY_RESOLVER_CLASS = 
451
        "http://saxon.sf.net/feature/entityResolverClass";
452

    
453
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
454

    
455

    
456
    /// <summary><para>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
457
    ///                be registered as the environment variable resolver for the
458
    ///                    <code>Configuration</code>. The setting is global: it affects all queries and
459
    ///                transformations using this configuration.</para>
460
    /// </summary>
461
    /// <remarks>
462
    ///            <para>The environment variable resolver is used when the XPath functions
463
    ///                    <code>available-environment-variables()</code> or
464
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
465
    ///                evaluation of the function to the external resolver.</para>
466
    ///        
467
    /// </remarks>
468

    
469
    public const String ENVIRONMENT_VARIABLE_RESOLVER = 
470
        "http://saxon.sf.net/feature/environmentVariableResolver";
471

    
472
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
473

    
474

    
475
    /// <summary><para>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
476
    ///                supplied class to be created, and registered as the environment variable resolver
477
    ///                for the <code>Configuration</code>. The setting is global: it affects all queries
478
    ///                and transformations using this configuration.</para>
479
    /// </summary>
480
    /// <remarks>
481
    ///            <para>The environment variable resolver is used when the XPath functions
482
    ///                    <code>available-environment-variables()</code> or
483
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
484
    ///                evaluation of the function to the external resolver.</para>
485
    ///        
486
    /// </remarks>
487

    
488
    public const String ENVIRONMENT_VARIABLE_RESOLVER_CLASS = 
489
        "http://saxon.sf.net/feature/environmentVariableResolverClass";
490

    
491
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
492

    
493

    
494
    /// <summary><para><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
495
    ///                <code>ErrorListener</code>. This is used both at compile time and at run-time.</para>
496
    /// </summary>
497
    /// <remarks>
498
    ///            <para>Currently if this option is specified, the class is instantiated, and the same
499
    ///                instance is used for all processes running under this configuration. This may change
500
    ///                in future so that a new instance is created for each compilation or evaluation.</para>
501
    ///            <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
502
    ///                specific XSLT or XQuery compilation or evaluation.</para>
503
    ///        
504
    /// </remarks>
505

    
506
    public const String ERROR_LISTENER_CLASS = 
507
        "http://saxon.sf.net/feature/errorListenerClass";
508

    
509
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
510

    
511

    
512
    /// <summary><para><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
513
    ///                defined in a schema or DTD will be expanded (both on input and on output documents,
514
    ///                if validation is requested).</para>
515
    /// </summary>
516
    /// <remarks>
517
    ///            <para>By default (and for conformance with the specification)
518
    ///                validation against a DTD or schema will cause default values defined in the schema
519
    ///                or DTD to be inserted into the document. Setting this feature to false suppresses
520
    ///                this behavior. In the case of DTD-defined defaults this only works if the XML parser
521
    ///                reports whether each attribute was specified in the source or generated by expanding
522
    ///                a default value. Not all XML parsers report this information.</para>
523
    ///        
524
    /// </remarks>
525

    
526
    public const String EXPAND_ATTRIBUTE_DEFAULTS = 
527
        "http://saxon.sf.net/feature/expandAttributeDefaults";
528

    
529
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
530

    
531

    
532
    /// <summary><para><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
533
    ///                and directories created in the EXPath File module should be automatically deleted on
534
    ///                closure of the JVM.</para>
535
    /// </summary>
536
    /// <remarks>
537
    ///            <para>The default value is <b>false</b>, to align with the standard. The setting
538
    ///                    <b>false</b> is recommended when external 'sweep-up' features aren't
539
    ///                available.</para>
540
    ///        
541
    /// </remarks>
542

    
543
    public const String EXPATH_FILE_DELETE_TEMPORARY_FILES = 
544
        "http://saxon.sf.net/feature/expathFileDeleteTemporaryFiles";
545

    
546
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
547

    
548

    
549
    /// <summary><para>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
550
    ///                query or stylesheet that are amenable to such treatment. Setting this option to
551
    ///                false disables this.</para>
552
    /// </summary>
553
    /// <remarks>
554
    ///            <para>For backwards compatibility, this option when used at the level of <code>Configuration.setConfigurationProperty()</code>
555
    ///            can also be used to set the value of <code>THRESHOLD_FOR_HOTSPOT_BYTECODE</code>. If the value on that interface is supplied
556
    ///            as an integer (or a string in the form of an integer) then a value of 1 or more sets the threshold for hotspot detection, while
557
    ///            a value of zero or less disables bytecode generation entirely. On other interfaces the value of the property must be a boolean.</para>
558
    ///        
559
    /// </remarks>
560

    
561
    public const String GENERATE_BYTE_CODE = 
562
        "http://saxon.sf.net/feature/generateByteCode";
563

    
564
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
565

    
566

    
567
    /// <summary><para>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
568
    ///                input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
569
    ///                supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
570
    ///                    <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
571
    ///                    <code>XMLReader</code> created using the value of the
572
    ///                    <code>SOURCE_PARSER_CLASS</code> option in preference.</para>
573
    /// </summary>
574
    /// <remarks>
575
    ///            <para>The defining use case for this feature is when calling a Saxon transformation from
576
    ///                Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
577
    ///                parser instantiated using the default JAXP mechanism. A different parser set using
578
    ///                the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
579
    ///                normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
580
    ///                option overrides this. This is especially useful if the input format is not in fact
581
    ///                XML, but some other format converted to a SAX event stream by means of a custom
582
    ///                parser.</para>
583
    ///        
584
    /// </remarks>
585

    
586
    public const String IGNORE_SAX_SOURCE_PARSER = 
587
        "http://saxon.sf.net/feature/ignoreSAXSourceParser";
588

    
589
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
590

    
591

    
592
    /// <summary><para><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
593
    ///                present in the containing schema document. </para>
594
    /// </summary>
595
    /// <remarks>
596
    ///            <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
597
    ///            because they were part of a different schema, or because there are cyclic references within a schema.</para>
598
    ///            <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
599
    ///            for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
600
    ///            and setting this option allows such schemas to be loaded by Saxon.</para>
601
    ///        
602
    /// </remarks>
603

    
604
    public const String IMPLICIT_SCHEMA_IMPORTS = 
605
        "http://saxon.sf.net/feature/implicitSchemaImports";
606

    
607
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
608

    
609

    
610
    /// <summary><para><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
611
    ///                constructed lazily. The default setting is false; there are a few situations (but
612
    ///                not many) where setting this to true can give a performance benefit (especially a
613
    ///                memory saving).</para>
614
    /// </summary>
615
    /// <remarks>
616
    ///            <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
617
    ///                is, when the client calls the query processor to deliver the result as a stream of
618
    ///                nodes, rather than running the query and piping the results into a serializer.</para>
619
    ///        
620
    /// </remarks>
621

    
622
    public const String LAZY_CONSTRUCTION_MODE = 
623
        "http://saxon.sf.net/feature/lazyConstructionMode";
624

    
625
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
626

    
627

    
628
    /// <summary><para><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
629
    ///                is held.</para>
630
    /// </summary>
631
    /// <remarks>
632
    ///            <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
633
    ///                Setting this property causes Saxon to
634
    ///                immediately read the specified file and register the license data, assuming it can
635
    ///                be found at this location. The property is not recognized for reading, and it is not
636
    ///                recognized for writing except in Saxon-PE and Saxon-EE.</para>
637
    ///        
638
    /// </remarks>
639

    
640
    public const String LICENSE_FILE_LOCATION = 
641
        "http://saxon.sf.net/feature/licenseFileLocation";
642

    
643
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
644

    
645

    
646
    /// <summary><para>Default is false. If true, line and column number information is retained for all
647
    ///                source documents. This information is accessible using the
648
    ///                    <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
649
    ///                extension functions.</para>
650
    /// </summary>
651
    /// <remarks>
652
    ///            <para>Note that the information is only as good as the XML parser supplies. SAX parsers
653
    ///                generally report the position of an element node using the line and column number of
654
    ///                the "&gt;" character that forms the last character of the start tag.</para>
655
    ///            <para>When this option is set, location information attached to a node (system ID, line
656
    ///            number, and column number) is retained when the node is copied. This has the side effect
657
    ///            that the base URI of a node is also copied, which in some cases runs contrary to the
658
    ///            XSLT or XQuery specification.</para>
659
    ///        
660
    /// </remarks>
661

    
662
    public const String LINE_NUMBERING = 
663
        "http://saxon.sf.net/feature/linenumbering";
664

    
665
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
666

    
667

    
668
    /// <summary><para>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
669
    ///            that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
670
    ///            document but was defined by a default value in a DTD or schema). This information is available to applications
671
    ///            via the <code>saxon:is-defaulted()</code> extension function.</para>
672
    /// </summary>
673
    /// <remarks>
674
    ///            <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
675
    ///            using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
676
    ///            is retained only if this option is set.</para>
677
    ///        
678
    /// </remarks>
679

    
680
    public const String MARK_DEFAULTED_ATTRIBUTES = 
681
        "http://saxon.sf.net/feature/markDefaultedAttributes";
682

    
683
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
684

    
685

    
686
    /// <summary><para>Places a limit on the number of classes for which Saxon will generate bytecode.</para>
687
    /// </summary>
688
    /// <remarks>
689
    ///            <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
690
    ///                in stylesheets or queries. This can become problematic if a configuration uses a very large number
691
    ///                of different stylesheets and queries, because it creates memory pressure (in some environments classes
692
    ///                are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
693
    ///            is generated, and queries/stylesheets are interpreted instead.</para>
694
    ///        
695
    /// </remarks>
696

    
697
    public const String MAX_COMPILED_CLASSES = 
698
        "http://saxon.sf.net/feature/maxCompiledClasses";
699

    
700
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
701

    
702

    
703
    /// <summary><para>Use the specified <code>Receiver</code> to process the output from
704
    ///                    <code>xsl:message</code>. The class must implement the
705
    ///                    <code>net.sf.saxon.event.Receiver</code> interface. This interface is similar to
706
    ///                a SAX <code>ContentHandler</code>, in that it takes a stream of events to generate
707
    ///                output.</para>
708
    /// </summary>
709
    /// <remarks>
710
    ///            <para>By default the standard XML emitter is used, configured to write to the standard
711
    ///                error stream, and to include no XML declaration. </para>
712
    ///            <para>In general the content of a message is an XML fragment. Each message is output as a
713
    ///                new document. The sequence of calls to this <code>Receiver</code> is as follows:
714
    ///                there is a single <code>open()</code> call at the start of the transformation, and a
715
    ///                single <code>close()</code> call at the end; and each evaluation of an
716
    ///                    <code>xsl:message</code> instruction starts with a <code>startDocument()</code>
717
    ///                call and ends with <code>endDocument()</code>. </para>
718
    ///            <para>The <code>startDocument()</code> event has a <code>properties</code> argument
719
    ///                indicating whether <code>terminate="yes"</code> was specified, and the
720
    ///                    <code>locationId</code> on calls such as <code>startElement()</code> and
721
    ///                    <code>characters()</code> can be used to identify the location in the stylesheet
722
    ///                where the message data originated (this is achieved by passing the supplied
723
    ///                    <code>locationId</code> in a call to
724
    ///                    <code>getPipelineConfiguration().getLocator().getSystemId(locationId)</code>, or
725
    ///                to <code>getLineNumber()</code> on the same object). </para>
726
    ///            <para>Select the class <code>net.sf.saxon.event.MessageWarner</code> to have
727
    ///                    <code>xsl:message</code> output notified to the JAXP <code>ErrorListener</code>,
728
    ///                as described in the JAXP documentation.</para>
729
    ///        
730
    /// </remarks>
731

    
732
    public const String MESSAGE_EMITTER_CLASS = 
733
        "http://saxon.sf.net/feature/messageEmitterClass";
734

    
735
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
736

    
737

    
738
    /// <summary><para>Affects XQuery only. An instance of a user-written class implementing Saxon's
739
    ///                    <see cref="net.sf.saxon.lib.ModuleURIResolver" /> interface. This is used to
740
    ///                process any URIs used in <code>import module</code> directives in XQuery.</para>
741
    /// </summary>
742

    
743
    public const String MODULE_URI_RESOLVER = 
744
        "http://saxon.sf.net/feature/moduleURIResolver";
745

    
746
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
747

    
748

    
749
    /// <summary><para>Affects XQuery only. The name of a user-written class implementing Saxon's
750
    ///                    <see cref="net.sf.saxon.lib.ModuleURIResolver" /> interface. This is used to
751
    ///                process any URIs used in <code>import module</code> directives in XQuery.</para>
752
    /// </summary>
753

    
754
    public const String MODULE_URI_RESOLVER_CLASS = 
755
        "http://saxon.sf.net/feature/moduleURIResolverClass";
756

    
757
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
758

    
759

    
760
    /// <summary><para>When set from the Transform or Query command line, a report on bytecode generation is
761
    ///                produced at the end of the transformation or query.</para>
762
    /// </summary>
763
    /// <remarks>
764
    ///            <para>When set from an application, the bytecode report is produced only on request, by
765
    ///                calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
766
    ///            <para>The bytecode report is an XML file containing one entry for each expression that has
767
    ///                been compiled into bytecode. Each entry contains the following details, where
768
    ///                applicable:</para>
769
    ///                <list>
770
    ///                <item><code>text</code> Abbreviated text of the expression</item>
771
    ///                <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
772
    ///                <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
773
    ///                <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
774
    ///                <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
775
    ///                <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
776
    ///                <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
777
    ///                <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
778
    ///                <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
779
    ///                <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
780
    ///                <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
781
    ///                <item><code>module</code> URI of the module containing the expression</item>
782
    ///                <item><code>line</code> Line number of the expression within this module</item>
783
    ///            </list>
784
    ///        
785
    /// </remarks>
786

    
787
    public const String MONITOR_HOT_SPOT_BYTE_CODE = 
788
        "http://saxon.sf.net/feature/monitorHotSpotByteCode";
789

    
790
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
791

    
792

    
793
    /// <summary><para>Affects schema construction (whether for standalone validation, or in the context of
794
    ///                XSLT or XQuery).</para>
795
    /// </summary>
796
    /// <remarks>
797
    ///            <para>If set to true, the schema processor attempts to fetch a schema
798
    ///                document appearing in an <code>xs:import</code> directive, whether or not a schema
799
    ///                for that namespace has already been loaded, unless the absolute URI formed from the
800
    ///                    <code>schemaLocation</code> is the same as the absolute URI that was used to
801
    ///                load that namespace. If set to false, the schema processor ignores the
802
    ///                    <code>schemaLocation</code> on an <code>xs:import</code> declaration if schema
803
    ///                components for the requested namespace are already available. Note that setting the
804
    ///                value to true might cause spurious errors due to like-named schema components being
805
    ///                loaded more than once. On the other hand, setting the value to false might result in
806
    ///                validation failing because schema components are missing.</para>
807
    ///            <para>Note: Both settings are conformant with the W3C recommendation, which leaves the
808
    ///                details implementation-defined. It is possible (and advisable) to write schemas in
809
    ///                such a way that this setting makes no difference, by ensuring that all imports for a
810
    ///                particular namespace go via a "home" schema document for that namespace, where the
811
    ///                home schema document contains <code>xs:include</code> declarations for all the
812
    ///                schema documents defining components in that namespace.</para>
813
    ///        
814
    /// </remarks>
815

    
816
    public const String MULTIPLE_SCHEMA_IMPORTS = 
817
        "http://saxon.sf.net/feature/multipleSchemaImports";
818

    
819
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
820

    
821

    
822
    /// <summary><para>Indicates that the supplied <code>NamePool</code> should be used as the target
823
    ///                (run-time) <code>NamePool</code> by all stylesheets compiled (using
824
    ///                <code>newTemplates()</code>) after this call on <code>setAttribute</code>.</para>
825
    /// </summary>
826
    /// <remarks>
827
    ///            <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
828
    ///                compiled while the Java VM remains loaded; this attribute allows user control over
829
    ///                the allocation of name pools. Note that source trees used as input to a
830
    ///                transformation must be built using the same <code>NamePool</code> that is used when
831
    ///                the stylesheet is compiled: this will happen automatically if the input to a
832
    ///                transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
833
    ///                but it is under user control if you build the source tree yourself.</para>
834
    ///            <para>This option can be used to make two <code>Configuration</code> objects share a
835
    ///                    <code>NamePool</code> even though they differ in other respects.</para>
836
    ///        
837
    /// </remarks>
838

    
839
    public const String NAME_POOL = 
840
        "http://saxon.sf.net/feature/namePool";
841

    
842
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
843

    
844

    
845
    /// <summary><para><code>OCCURRENCE_LIMITS</code> determines the largest values of
846
    ///                <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
847
    ///                compiling an "expanded" finite state machine to represent an XSD content model
848
    ///                grammar.</para>
849
    /// </summary>
850
    /// <remarks>
851
    ///            <para>These limits do not apply in the common cases where the grammar can be
852
    ///                implemented using a counting finite-state-machine, but in those cases where this is
853
    ///                not possible, any <code>minOccurs</code> value greater than the first integer is
854
    ///                reduced to the value of the first integer, and any <code>maxOccurs</code> value
855
    ///                greater than the second integer is treated as "unbounded".</para>
856
    ///            <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
857
    ///                the size of the finite state machine constructed by Saxon increases linearly with
858
    ///                the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
859
    ///        
860
    /// </remarks>
861

    
862
    public const String OCCURRENCE_LIMITS = 
863
        "http://saxon.sf.net/feature/occurrenceLimits";
864

    
865
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
866

    
867

    
868
    /// <summary><para>Allows individual optimizations to be enabled or disabled selectively.</para>
869
    /// </summary>
870
    /// <remarks>
871
    ///            <para>There is a set of single-letter flags identifying particular optimizations:</para>
872
    ///            <list>
873
    ///                <item>c: generate bytecode</item>
874
    ///                <item>e: cache regular expressions</item>
875
    ///                <item>f: inline functions</item>
876
    ///                <item>g: extract global variables</item>
877
    ///                <item>j: just-in-time compilation of template rules</item>
878
    ///                <item>k: create keys</item>
879
    ///                <item>l: loop lifting</item>
880
    ///                <item>m: miscellaneous</item>
881
    ///                <item>n: constant folding</item>
882
    ///                <item>r: template rule-sets</item>
883
    ///                <item>s: extract common subexpressions</item>
884
    ///                <item>v: inline variables</item>
885
    ///                <item>w: create switch statements</item>
886
    ///                <item>x: index predicates</item>
887
    ///            </list>
888
    ///            <para>A value such as <code>gs</code> runs with only the selected optimizations;
889
    ///                <code>-gs</code> runs with the selected optimizations disabled and all others enabled. The
890
    ///                value <code>0</code> suppresses all optimizations. The default is full optimization; this
891
    ///                feature allows optimization to be suppressed in cases where reducing compile time is
892
    ///                important, or where optimization gets in the way of debugging, or causes extension
893
    ///                functions with side-effects to behave unpredictably. (Note however, that even with
894
    ///                no optimization, lazy evaluation may still cause the evaluation order to be not as
895
    ///                expected.) </para>
896
    ///            <para><i>Note that disabling optimizations may prevent streamed execution. This is because
897
    ///            there are cases where streamed execution is only possible because the optimizer is able to detect
898
    ///            that sorting nodes into document order is unnecessary.</i></para>
899
    ///        
900
    /// </remarks>
901

    
902
    public const String OPTIMIZATION_LEVEL = 
903
        "http://saxon.sf.net/feature/optimizationLevel";
904

    
905
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
906

    
907

    
908
    /// <summary><para>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
909
    ///                result documents selected in the <code>href</code> attribute of the XSLT
910
    ///                    <code>xsl:result-document</code> instruction.</para>
911
    /// </summary>
912

    
913
    public const String OUTPUT_URI_RESOLVER = 
914
        "http://saxon.sf.net/feature/outputURIResolver";
915

    
916
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
917

    
918

    
919
    /// <summary><para>The supplied class will be instantiated, and the resulting
920
    ///                    <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
921
    ///                documents selected in the <code>href</code> attribute of the XSLT
922
    ///                    <code>xsl:result-document</code> instruction.</para>
923
    /// </summary>
924

    
925
    public const String OUTPUT_URI_RESOLVER_CLASS = 
926
        "http://saxon.sf.net/feature/outputURIResolverClass";
927

    
928
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
929

    
930

    
931
    /// <summary><para>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
932
    ///                their arguments are known at compile time, will be evaluated at compile time, and
933
    ///                the resulting document will be stored as part of the Saxon
934
    ///                <see cref="net.sf.saxon.Configuration" /> and shared by all queries and
935
    ///                transformations running within that <code>Configuration</code>.</para>
936
    /// </summary>
937
    /// <remarks>
938
    ///            <para>This is useful for reference documents that have stable content and are used by many different 
939
    ///                queries and transformations. The default is false, which means each query or transformation
940
    ///                will reload the document from disk.</para>
941
    ///            <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
942
    ///                compile time is to use the new facility of static global variables.</para>
943
    ///        
944
    /// </remarks>
945

    
946
    public const String PRE_EVALUATE_DOC_FUNCTION = 
947
        "http://saxon.sf.net/feature/preEvaluateDocFunction";
948

    
949
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
950

    
951

    
952
    /// <summary><para>Relevant only on .NET, determines whether the Java Classpath parser is used in
953
    ///                preference to the Microsoft .NET parser.</para>
954
    /// </summary>
955
    /// <remarks>
956
    ///            <para>This option has no effect on the Java platform. The default is <b>true</b>. When
957
    ///                running on the .NET platform, if the option is true it causes the Apache Xerces
958
    ///                parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
959
    ///                If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
960
    ///                reason for providing this option is that the .NET XML parser does not report ID
961
    ///                attributes, which means that the <code>id()</code> function does not work.</para>
962
    ///        
963
    /// </remarks>
964

    
965
    public const String PREFER_JAXP_PARSER = 
966
        "http://saxon.sf.net/feature/preferJaxpParser";
967

    
968
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
969

    
970

    
971
    /// <summary><para>True if the standard URI resolver is to recognize query parameters included in
972
    ///                the URI (for example, <code>?val=strict</code>). Such parameters can then be used in
973
    ///                URIs passed to the <code>doc()</code> or <code>document()</code> functions. For
974
    ///                details of the query parameters available, see <span class="link" data-href="/sourcedocs">Source Documents</span>. The default is false.</para>
975
    /// </summary>
976
    /// <remarks>
977
    ///            <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
978
    ///                unless the user-supplied <code>URIResolver</code> chooses to inherit this
979
    ///                functionality from the standard <code>URIResolver</code>.</para>
980
    ///            <para>Allowed parameters include <code>validation=strict|lax|strip</code> to perform schema
981
    ///                validation, <code>strip-space=yes|ignorable|no</code> to control whitespace
982
    ///                stripping, and <code>xinclude=yes|no</code> to control whether XInclude processing
983
    ///                takes place (assuming the XML parser supports it).</para>
984
    ///        
985
    /// </remarks>
986

    
987
    public const String RECOGNIZE_URI_QUERY_PARAMETERS = 
988
        "http://saxon.sf.net/feature/recognize-uri-query-parameters";
989

    
990
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
991

    
992

    
993
    /// <summary><para>An integer, one of <see cref="net.sf.saxon.trans.RecoveryPolicy#RECOVER_SILENTLY" />,
994
    ///                <see cref="net.sf.saxon.trans.RecoveryPolicy#RECOVER_WITH_WARNINGS" />, or
995
    ///                <see cref="net.sf.saxon.trans.RecoveryPolicy#DO_NOT_RECOVER" />. Indicates the policy for
996
    ///                handling dynamic errors that the XSLT specification defines as recoverable.</para>
997
    /// </summary>
998
    /// <remarks>
999
    ///            <para>0 means recover silently; 1 means recover after signalling a warning to the
1000
    ///                    <code>ErrorListener</code>; 2 means treat the error as fatal. An example of a
1001
    ///                recoverable error is when two template rules match the same node.</para>
1002
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1003
    ///                specification.</para>
1004
    ///        
1005
    /// </remarks>
1006

    
1007
    public const String RECOVERY_POLICY = 
1008
        "http://saxon.sf.net/feature/recoveryPolicy";
1009

    
1010
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1011

    
1012

    
1013
    /// <summary><para>Indicates the policy for handling dynamic errors that the XSLT specification defines
1014
    ///                as recoverable.</para>
1015
    /// </summary>
1016
    /// <remarks>
1017
    ///            <para>"recoverSilently" means recover silently; "recoverWithWarnings"
1018
    ///                means recover after signalling a warning to the <code>ErrorListener</code>;
1019
    ///                "doNotRecover" means treat the error as fatal. An example of a recoverable error is
1020
    ///                when two template rules match the same node. </para>
1021
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1022
    ///                specification.</para>
1023
    ///        
1024
    /// </remarks>
1025

    
1026
    public const String RECOVERY_POLICY_NAME = 
1027
        "http://saxon.sf.net/feature/recoveryPolicyName";
1028

    
1029
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1030

    
1031

    
1032
    /// <summary><para>Indicates the maximum number of threads to be used for processing
1033
    ///                    <code>xsl:result-document</code> instructions in parallel. If the maximum number
1034
    ///                of threads are already in use, the <code>xsl:result-document</code> instruction will
1035
    ///                be executed synchronously within its parent thread.</para>
1036
    /// </summary>
1037
    /// <remarks>
1038
    ///            <para>The default value is initialized to
1039
    ///                    <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
1040
    ///                represent the number of "processors" (under some definition) available from the
1041
    ///                hardware.</para>
1042
    ///            <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
1043
    ///                on the same server under separate Saxon <code>Configuration</code> objects, then it
1044
    ///                may be desirable to lower the limit.</para>
1045
    ///            <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
1046
    ///                achieved (for a specific <code>xsl:result-document</code> instruction) by setting
1047
    ///                the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
1048
    ///                multithreading may be desirable in a stylesheet that calls extension functions with
1049
    ///                side-effects.</para>
1050
    ///        
1051
    /// </remarks>
1052

    
1053
    public const String RESULT_DOCUMENT_THREADS = 
1054
        "http://saxon.sf.net/feature/resultDocumentThreads";
1055

    
1056
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1057

    
1058

    
1059
    /// <summary><para>If set to true, indicates that when input is obtained from a SAX parser, the
1060
    ///                DTD-based attribute type notified by the XML parser should be used to set the type
1061
    ///                annotation of the resulting node: for example a DTD type of NMTOKENS results in a
1062
    ///                type annotation of xs:NMTOKENS. </para>
1063
    /// </summary>
1064
    /// <remarks>
1065
    ///            <para>This option is retained for backwards compatibility (at some time in the past, it was
1066
    ///                the default), but is deprecated.</para>
1067
    ///        
1068
    /// </remarks>
1069

    
1070
    public const String RETAIN_DTD_ATTRIBUTE_TYPES = 
1071
        "http://saxon.sf.net/feature/retain-dtd-attribute-types";
1072

    
1073
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1074

    
1075

    
1076
    /// <summary><para>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
1077
    ///                documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
1078
    ///                    <code>import schema</code> in XQuery, references from one schema document to
1079
    ///                another using <code>xs:include</code> or <code>xs:import</code>, and references from
1080
    ///                an instance document to a schema using <code>xsi:schemaLocation</code>.</para>
1081
    /// </summary>
1082

    
1083
    public const String SCHEMA_URI_RESOLVER = 
1084
        "http://saxon.sf.net/feature/schemaURIResolver";
1085

    
1086
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1087

    
1088

    
1089
    /// <summary><para>The name of a class that implements the interface <code>SchemaURIResolver</code>;
1090
    ///                this class will be instantiated and the resulting instance will be used as the value
1091
    ///                of the <see cref="SCHEMA_URI_RESOLVER" /> property.</para>
1092
    /// </summary>
1093

    
1094
    public const String SCHEMA_URI_RESOLVER_CLASS = 
1095
        "http://saxon.sf.net/feature/schemaURIResolverClass";
1096

    
1097
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1098

    
1099

    
1100
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1101
    ///                documents.</para>
1102
    /// </summary>
1103

    
1104
    public const String SCHEMA_VALIDATION = 
1105
        "http://saxon.sf.net/feature/schema-validation";
1106

    
1107
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1108

    
1109

    
1110
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1111
    ///                documents.</para>
1112
    /// </summary>
1113

    
1114
    public const String SCHEMA_VALIDATION_MODE = 
1115
        "http://saxon.sf.net/feature/schema-validation-mode";
1116

    
1117
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1118

    
1119

    
1120
    /// <summary><para>The class will be instantiated and the resulting <code>SerializerFactory</code> will
1121
    ///                be used to create the serialization pipeline for XSLT and XQuery results.</para>
1122
    /// </summary>
1123
    /// <remarks>
1124
    ///            <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
1125
    ///                many aspects of the output produced by the Serializer, or to introduce new
1126
    ///                serialization methods and parameters.</para>
1127
    ///        
1128
    /// </remarks>
1129

    
1130
    public const String SERIALIZER_FACTORY_CLASS = 
1131
        "http://saxon.sf.net/feature/serializerFactoryClass";
1132

    
1133
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1134

    
1135

    
1136
    /// <summary><para>XML parser used for source documents.</para>
1137
    /// </summary>
1138
    /// <remarks>
1139
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1140
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1141
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1142
    ///                parse source documents (that is, the principal source document plus any secondary
1143
    ///                source documents read using the <code>doc()</code>, <code>document()</code>, or
1144
    ///                    <code>collection()</code> function).</para>
1145
    ///            <para>Note that the selected parser is used only when the input is supplied in the form of
1146
    ///                a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
1147
    ///                pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
1148
    ///                configuration option has no effect when running transformations from an Ant script,
1149
    ///                since the Ant <code>xslt</code> task always supplies the input in the form of a
1150
    ///                    <code>SAXSource</code>.</para>
1151
    ///        
1152
    /// </remarks>
1153

    
1154
    public const String SOURCE_PARSER_CLASS = 
1155
        "http://saxon.sf.net/feature/sourceParserClass";
1156

    
1157
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1158

    
1159

    
1160
    /// <summary><para>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
1161
    ///                of <code>Source</code> is provided that Saxon does not recognize, it will be passed
1162
    ///                to the user-supplied <code>SourceResolver</code>, which has the opportunity to
1163
    ///                convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
1164
    ///                new kinds of input to be supplied as input to Saxon's query, transformation, and
1165
    ///                validation engines.</para>
1166
    /// </summary>
1167

    
1168
    public const String SOURCE_RESOLVER_CLASS = 
1169
        "http://saxon.sf.net/feature/sourceResolverClass";
1170

    
1171
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1172

    
1173

    
1174
    /// <summary><para><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
1175
    ///                the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
1176
    ///                should be <i>stable</i>, that is, repeated calls on these functions with the same
1177
    ///                collection URI (within the scope of a single query or transformation) should return
1178
    ///                identical results.</para>
1179
    /// </summary>
1180
    /// <remarks>
1181
    ///            <para>Setting this option may be expensive because it requires that the entire collection
1182
    ///                be saved in memory; it is rarely necessary in practice, but is required for strict
1183
    ///                conformance with the W3C specifications.</para>
1184
    ///            <para>It is also possible to indicate that a collection is stable by means of the
1185
    ///                    <code>CollectionFinder</code> API.</para>
1186
    ///        
1187
    /// </remarks>
1188

    
1189
    public const String STABLE_COLLECTION_URI = 
1190
        "http://saxon.sf.net/feature/stableCollectionUri";
1191

    
1192
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1193

    
1194

    
1195
    /// <summary><para><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
1196
    ///                repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
1197
    ///                and <code>unparsed-text-available()</code> are consistent: calling these functions
1198
    ///                twice during the evaluation of a stylesheet or query will return the same
1199
    ///                results.</para>
1200
    /// </summary>
1201
    /// <remarks>
1202
    ///            <para>Setting this option may be expensive because it requires that the file contents be
1203
    ///                saved in memory; it is rarely necessary in practice, but is required for strict
1204
    ///                conformance with the W3C specifications.</para>
1205
    ///        
1206
    /// </remarks>
1207

    
1208
    public const String STABLE_UNPARSED_TEXT = 
1209
        "http://saxon.sf.net/feature/stableUnparsedText";
1210

    
1211
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1212

    
1213

    
1214
    /// <summary><para><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
1215
    ///                redirect output that would otherwise go to the operating system standard error
1216
    ///                stream (System.err). This is the fallback destination for various tracing and
1217
    ///                diagnostic output. In some cases a more specific mechanism exists to select the
1218
    ///                destination for particular kinds of output.</para>
1219
    /// </summary>
1220
    /// <remarks>
1221
    ///            <para>Note that if the <code>Configuration</code> is used in more than one processing
1222
    ///                thread, the messages from different threads will be interleaved in the output file.
1223
    ///                A more selective approach is to use a different <code>ErrorListener</code> in
1224
    ///                different processing threads, and arrange for each <code>ErrorListener</code> to
1225
    ///                write to its own logging destination.</para>
1226
    ///        
1227
    /// </remarks>
1228

    
1229
    public const String STANDARD_ERROR_OUTPUT_FILE = 
1230
        "http://saxon.sf.net/feature/standardErrorOutputFile";
1231

    
1232
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1233

    
1234

    
1235
    /// <summary><para>The <code>STREAMABILITY</code> option can be used to disable streaming.</para>
1236
    /// </summary>
1237
    /// <remarks>
1238
    ///            <para>In earlier Saxon releases a third value "extended" was supported, to enable Saxon
1239
    ///                streaming extensions. Since nearly all these extensions found their way into the W3C
1240
    ///                specification, the distinction between "standard" and "extended" became meaningless,
1241
    ///                so the value "extended" has been dropped.</para>
1242
    ///            <para>The value "off" causes Saxon to behave as a non-streaming processor; that is, it does
1243
    ///                not analyze constructs that are declared streamable, and it processes them as if
1244
    ///                streaming were not requested. This is the only option available when using a Saxon
1245
    ///                version or license that does not enable streaming.</para>
1246
    ///            <para>The value "standard" is a misnomer. For strict adherence to W3C streamability rules,
1247
    ///                set the property <code>STRICT_STREAMABILITY</code>. The streamability rules applied
1248
    ///                by default are (in nearly all cases) identical to the W3C rules, but by default they
1249
    ///                are applied to the expression tree after type-checking and optimization, which makes
1250
    ///                some constructs streamable that would not be so otherwise.</para>
1251
    ///            <para>Whichever option is chosen, the <code>STREAMING_FALLBACK</code> option can be used to
1252
    ///                control what happens when code is deemed non-streamable; it provides a choice
1253
    ///                between throwing a static (compile-time) error, and falling back to a non-streaming
1254
    ///                implementation.</para>
1255
    ///        
1256
    /// </remarks>
1257

    
1258
    public const String STREAMABILITY = 
1259
        "http://saxon.sf.net/feature/streamability";
1260

    
1261
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1262

    
1263

    
1264
    /// <summary><para>Causes the XSLT processor to verify that constructs that are declared streamable are
1265
    ///                in fact "guaranteed streamable" according to the W3C rules.</para>
1266
    /// </summary>
1267
    /// <remarks>
1268
    ///            <para>Normally, Saxon performs a variety of simplifications and optimizations on the
1269
    ///                expression tree before performing streamability analysis. Sometimes these tree
1270
    ///                rewrites will turn a non-streamable expression into a streamable one. An obvious
1271
    ///                example is variable inlining: the expression <code>let $x := ./item/price return
1272
    ///                    sum($x)</code> is not streamable, but the rewritten form
1273
    ///                    <code>sum(./item/price)</code> is.</para>
1274
    ///            <para>The XSLT 3.0 specification requires conformant streaming processors to have a mode of
1275
    ///                operation in which the streamability rules are enforced as they appear in the spec,
1276
    ///                and this option enables this mode.</para>
1277
    ///            <para>This analysis is expensive, and should only be used during development when testing
1278
    ///                stylesheet code for portability. When this mode is enabled, Saxon applies the
1279
    ///                streamability rules at the earliest possible stage of processing; it then performs
1280
    ///                its normal type checking and optimization phases, before doing a second stage of
1281
    ///                streamability analysis to construct a streamed execution plan.</para>
1282
    ///        
1283
    /// </remarks>
1284

    
1285
    public const String STRICT_STREAMABILITY = 
1286
        "http://saxon.sf.net/feature/strictStreamability";
1287

    
1288
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1289

    
1290

    
1291
    /// <summary><para>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
1292
    ///                streaming is requested (such as templates in a streaming mode, the
1293
    ///                    <code>xsl:source-document</code> instruction with attribute
1294
    ///                    <code>streamable="yes"</code>, and streamable accumulators) will be executed in
1295
    ///                non-streaming mode if the code is not actually streamable. A compile-time warning
1296
    ///                will always be given when the fallback option is taken.</para>
1297
    /// </summary>
1298

    
1299
    public const String STREAMING_FALLBACK = 
1300
        "http://saxon.sf.net/feature/streamingFallback";
1301

    
1302
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1303

    
1304

    
1305
    /// <summary><para>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
1306
    ///                a DTD or schema as having element-only content should be stripped from source
1307
    ///                documents.</para>
1308
    /// </summary>
1309
    /// <remarks>
1310
    ///            <para>The default is "ignorable". This whitespace stripping is additional to
1311
    ///                any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
1312
    ///                XSLT stylesheet.</para>
1313
    ///        
1314
    /// </remarks>
1315

    
1316
    public const String STRIP_WHITESPACE = 
1317
        "http://saxon.sf.net/feature/strip-whitespace";
1318

    
1319
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1320

    
1321

    
1322
    /// <summary><para>XML parser used for stylesheets and schema documents.</para>
1323
    /// </summary>
1324
    /// <remarks>
1325
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1326
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1327
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1328
    ///                parse stylesheet documents (that is, the principal stylesheet module plus any
1329
    ///                secondary source documents read using <code>xsl:include</code> or
1330
    ///                    <code>xsl:import</code>) and also schema documents.</para>
1331
    ///        
1332
    /// </remarks>
1333

    
1334
    public const String STYLE_PARSER_CLASS = 
1335
        "http://saxon.sf.net/feature/styleParserClass";
1336

    
1337
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1338

    
1339

    
1340
    /// <summary><para>This is set to true to suppress the warning otherwise issued by command-line
1341
    ///                interfaces indicating that an evaluation license is in use and is due to expire in a
1342
    ///                set number of days.</para>
1343
    /// </summary>
1344

    
1345
    public const String SUPPRESS_EVALUATION_EXPIRY_WARNING = 
1346
        "http://saxon.sf.net/feature/suppressEvaluationExpiryWarning";
1347

    
1348
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1349

    
1350

    
1351
    /// <summary><para>Suppresses all warnings issued by the XPath and XQuery parsers.</para>
1352
    /// </summary>
1353
    /// <remarks>
1354
    ///            <para>Examples of warnings that are suppressed are the warning produced when keywords such
1355
    ///                as <code>true</code> and <code>return</code> are interpreted as element names.</para>
1356
    ///        
1357
    /// </remarks>
1358

    
1359
    public const String SUPPRESS_XPATH_WARNINGS = 
1360
        "http://saxon.sf.net/feature/suppressXPathWarnings";
1361

    
1362
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1363

    
1364

    
1365
    /// <summary><para>This is set to true to suppress the warning when there is no commonality between the
1366
    ///                namespaces used in stylesheet match patterns and the namespaces used in the source
1367
    ///                document.</para>
1368
    /// </summary>
1369

    
1370
    public const String SUPPRESS_XSLT_NAMESPACE_CHECK = 
1371
        "http://saxon.sf.net/feature/suppressXsltNamespaceCheck";
1372

    
1373
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1374

    
1375

    
1376
    /// <summary><para>Indicates how often an XSD simple type definition must be used before Saxon generates
1377
    ///                bytecode to implement validation of input data against that type.</para>
1378
    /// </summary>
1379
    /// <remarks>
1380
    ///            <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
1381
    ///                strings against user-defined simple types after the type has been used 100 times
1382
    ///                (during the life of a Saxon Configuration). This threshold may be changed using this
1383
    ///                configuration option. It may be useful to raise the threshold if the number of
1384
    ///                user-defined types is large, and the bytecode is creating memory pressure.</para>
1385
    ///        
1386
    /// </remarks>
1387

    
1388
    public const String THRESHOLD_FOR_COMPILING_TYPES = 
1389
        "http://saxon.sf.net/feature/thresholdForCompilingTypes";
1390

    
1391
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1392

    
1393

    
1394
    /// <summary><para>This is set to true to cause basic timing and tracing information to be output to the
1395
    ///                standard error output stream.</para>
1396
    /// </summary>
1397
    /// <remarks>
1398
    ///            <para>The name of the feature is poorly chosen, since much
1399
    ///                of the information that is output has nothing to do with timing, for example the
1400
    ///                names of output files for <code>xsl:result-document</code> are traced, as are the
1401
    ///                names of schema documents loaded.</para>
1402
    ///        
1403
    /// </remarks>
1404

    
1405
    public const String TIMING = 
1406
        "http://saxon.sf.net/feature/timing";
1407

    
1408
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1409

    
1410

    
1411
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) progress
1412
    ///                information about its attempts to locate and disambiguate references to reflexive
1413
    ///                Java extension functions. This is useful for diagnostics if the XQuery or XSLT
1414
    ///                compiler is failing to locate user-written extension functions.</para>
1415
    /// </summary>
1416

    
1417
    public const String TRACE_EXTERNAL_FUNCTIONS = 
1418
        "http://saxon.sf.net/feature/trace-external-functions";
1419

    
1420
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1421

    
1422

    
1423
    /// <summary><para>The <code>TraceListener</code> will be notified of significant events occurring
1424
    ///                during a query or transformation, for tracing or debugging purposes.</para>
1425
    /// </summary>
1426
    /// <remarks>
1427
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1428
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1429
    ///            <para>Avoid this option if more than one transformation or query is running concurrently:
1430
    ///                use the feature <see cref="TRACE_LISTENER_CLASS" />
1431
    ///                instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
1432
    ///                individual query or transformation.</para>
1433
    ///        
1434
    /// </remarks>
1435

    
1436
    public const String TRACE_LISTENER = 
1437
        "http://saxon.sf.net/feature/traceListener";
1438

    
1439
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1440

    
1441

    
1442
    /// <summary><para>The class will be instantiated once for each query or transformation, and the
1443
    ///                resulting <code>TraceListener</code> will be notified of significant events
1444
    ///                occurring during that query or transformation, for tracing or debugging
1445
    ///                purposes.</para>
1446
    /// </summary>
1447
    /// <remarks>
1448
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1449
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1450
    ///        
1451
    /// </remarks>
1452

    
1453
    public const String TRACE_LISTENER_CLASS = 
1454
        "http://saxon.sf.net/feature/traceListenerClass";
1455

    
1456
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1457

    
1458

    
1459
    /// <summary><para>When trace listening is switched on (for example by using -T on the command line),
1460
    ///                this file will be supplied to the trace listener to use as the output destination.
1461
    ///                If the option is not supplied, trace listener output is sent to the standard error
1462
    ///                stream.</para>
1463
    /// </summary>
1464

    
1465
    public const String TRACE_LISTENER_OUTPUT_FILE = 
1466
        "http://saxon.sf.net/feature/traceListenerOutputFile";
1467

    
1468
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1469

    
1470

    
1471
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) detailed
1472
    ///                information about the rewrites to the expression tree made by the optimizer. This
1473
    ///                information is mainly useful for internal system debugging, but it is also possible
1474
    ///                to digest it to analyze the ways in which the expression has been optimized for the
1475
    ///                purpose of performance analysis and tuning.</para>
1476
    /// </summary>
1477

    
1478
    public const String TRACE_OPTIMIZER_DECISIONS = 
1479
        "http://saxon.sf.net/feature/trace-optimizer-decisions";
1480

    
1481
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1482

    
1483

    
1484
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1485
    ///                    <code>TINY_TREE</code>.</para>
1486
    /// </summary>
1487
    /// <remarks>
1488
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1489
    ///                that is updateable.</para>
1490
    ///        
1491
    /// </remarks>
1492

    
1493
    public const String TREE_MODEL = 
1494
        "http://saxon.sf.net/feature/treeModel";
1495

    
1496
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1497

    
1498

    
1499
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1500
    ///                    <code>tinyTree</code>.</para>
1501
    /// </summary>
1502
    /// <remarks>
1503
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1504
    ///                that is updateable.</para>
1505
    ///        
1506
    /// </remarks>
1507

    
1508
    public const String TREE_MODEL_NAME = 
1509
        "http://saxon.sf.net/feature/treeModelName";
1510

    
1511
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1512

    
1513

    
1514
    /// <summary><para>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
1515
    ///                (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
1516
    ///                    <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
1517
    ///                functions.</para>
1518
    /// </summary>
1519

    
1520
    public const String UNPARSED_TEXT_URI_RESOLVER = 
1521
        "http://saxon.sf.net/feature/unparsedTextURIResolver";
1522

    
1523
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1524

    
1525

    
1526
    /// <summary><para>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
1527
    ///                created, and used to resolve (dereference) all URIs specifed in calls to the
1528
    ///                    <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
1529
    ///                    <code>unparsed-text-available()</code> functions.</para>
1530
    /// </summary>
1531

    
1532
    public const String UNPARSED_TEXT_URI_RESOLVER_CLASS = 
1533
        "http://saxon.sf.net/feature/unparsedTextURIResolverClass";
1534

    
1535
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1536

    
1537

    
1538
    /// <summary><para>An instance of the specified <code>URIResolver</code> class will be created, and used
1539
    ///                to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
1540
    ///                    <code>document()</code> functions, as well as URIs used in
1541
    ///                    <code>xsl:include</code> and <code>xsl:import</code> and location hints for
1542
    ///                XQuery modules and XSD schema documents.</para>
1543
    /// </summary>
1544

    
1545
    public const String URI_RESOLVER_CLASS = 
1546
        "http://saxon.sf.net/feature/uriResolverClass";
1547

    
1548
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1549

    
1550

    
1551
    /// <summary><para>This option determines whether a <code>TransformerHandler</code> created with this
1552
    ///                    <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
1553
    ///                JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
1554
    ///                and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
1555
    ///                instructions to disable or to re-enable output escaping. The default value is
1556
    ///                    <b>false</b>.</para>
1557
    /// </summary>
1558

    
1559
    public const String USE_PI_DISABLE_OUTPUT_ESCAPING = 
1560
        "http://saxon.sf.net/feature/use-pi-disable-output-escaping";
1561

    
1562
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1563

    
1564

    
1565
    /// <summary><para>This option is relevant only when the TinyTree is used; it determines whether (for a
1566
    ///                validated document) a cache will be maintained containing the typed values of nodes.</para>
1567
    /// </summary>
1568
    /// <remarks>
1569
    ///            <para>Typed values are held in the cache only for elements and attributes whose type is
1570
    ///                other than string, untypedAtomic, or anyURI. The default value is true. Setting this
1571
    ///                value to false can reduce memory requirements at the cost of requiring recomputation
1572
    ///                of typed values on each access.</para>
1573
    ///        
1574
    /// </remarks>
1575

    
1576
    public const String USE_TYPED_VALUE_CACHE = 
1577
        "http://saxon.sf.net/feature/use-typed-value-cache";
1578

    
1579
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1580

    
1581

    
1582
    /// <summary><para>This option determines whether or not to use the <code>xsi:schemaLocation</code>
1583
    ///                    and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
1584
    ///                document to locate a schema for validation.</para>
1585
    /// </summary>
1586
    /// <remarks>
1587
    ///            <para>Note, these attribute are only consulted if validation is requested; the presence of
1588
    ///                one of these attributes never by itself triggers validation.</para>
1589
    ///        
1590
    /// </remarks>
1591

    
1592
    public const String USE_XSI_SCHEMA_LOCATION = 
1593
        "http://saxon.sf.net/feature/useXsiSchemaLocation";
1594

    
1595
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1596

    
1597

    
1598
    /// <summary><para>This option determines whether non-fatal validation errors in XQuery or XSLT result
1599
    ///                documents should result in comments being inserted into the result tree. The
1600
    ///                command-line flag <code>-outval:recover</code> sets both this option and the
1601
    ///                    <see cref="VALIDATION_WARNINGS" /> option.</para>
1602
    /// </summary>
1603

    
1604
    public const String VALIDATION_COMMENTS = 
1605
        "http://saxon.sf.net/feature/validation-comments";
1606

    
1607
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1608

    
1609

    
1610
    /// <summary><para>This option indicates (if true) that errors occuring while validating a final result
1611
    ///                tree are not to be treated as fatal.</para>
1612
    /// </summary>
1613
    /// <remarks>
1614
    ///            <para>Regardless of the setting of this option, all validation errors are reported to the
1615
    ///                    <code>error()</code> method of the <code>ErrorListener</code>, and validation is
1616
    ///                terminated if the <code>error()</code> method throws an exception, or if the error
1617
    ///                limit set in the <code>ParseOptions</code> object is reached.</para>
1618
    ///            <para>This option primarily controls what happens at the end of a validation episode. If
1619
    ///                the validation episode detected one or more validation errors, then when this option
1620
    ///                is off, an exception is thrown, which will normally result in any query or
1621
    ///                stylesheet failing with a dynamic error, and no output file being written. If the
1622
    ///                option is on, no exception is thrown, and the output is written as if validation had
1623
    ///                been successful. Note in this case that any type annotations present in a result
1624
    ///                document are unreliable.</para>
1625
    ///            <para>If this option is set when running XSLT or XQuery, it is ignored as far as input
1626
    ///                files are concerned: validation errors in input files are still fatal. However, if
1627
    ///                the option is set and a validation error occurs in a final output file, the output
1628
    ///                file is still written and the process terminates as if successful.</para>
1629
    ///            <para>The detailed interpretation of this option changed in Saxon 9.5.</para>
1630
    ///        
1631
    /// </remarks>
1632

    
1633
    public const String VALIDATION_WARNINGS = 
1634
        "http://saxon.sf.net/feature/validation-warnings";
1635

    
1636
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1637

    
1638

    
1639
    /// <summary><para>Indicates whether a warning message should be notified (to the
1640
    ///                <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
1641
    ///                specifies <code>version="1.0"</code>.</para>
1642
    /// </summary>
1643
    /// <remarks>
1644
    ///            <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
1645
    ///                it), so this option is ignored.</para>
1646
    ///            
1647
    ///        
1648
    /// </remarks>
1649

    
1650
    public const String VERSION_WARNING = 
1651
        "http://saxon.sf.net/feature/version-warning";
1652

    
1653
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1654

    
1655

    
1656
    /// <summary><para>Indicates whether source documents should have any XInclude directives expanded.</para>
1657
    /// </summary>
1658
    /// <remarks>
1659
    ///            <para>The default is false. The option applies to all input XML documents, including
1660
    ///                stylesheets and schema documents. It can be overridden for individual documents
1661
    ///                using the <see cref="net.sf.saxon.lib.ParseOptions" /> class.</para>
1662
    ///            <para>This option relies on support in the underlying XML parser. If the XML parser does
1663
    ///                not support XInclude processing, the option is ignored.</para>
1664
    ///        
1665
    /// </remarks>
1666

    
1667
    public const String XINCLUDE = 
1668
        "http://saxon.sf.net/feature/xinclude-aware";
1669

    
1670
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1671

    
1672

    
1673
    /// <summary><para>This determines the XML version used by the <code>Configuration</code>.</para>
1674
    /// </summary>
1675
    /// <remarks>
1676
    ///            <para>Note that source documents specifying <code>xml version="1.0"</code> or
1677
    ///                    <code>"1.1"</code> are accepted regardless of this setting. The effect of this
1678
    ///                switch is to change the validation rules for types such as <code>xs:Name</code> and
1679
    ///                    <code>xs:NCName</code>, to change the characters allowed in names within XPath
1680
    ///                expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
1681
    ///                regular expressions, and to determine whether the serializer allows XML 1.1
1682
    ///                documents to be constructed. </para>
1683
    ///            <para>The default is currently 1.0, but may change.</para>
1684
    ///        
1685
    /// </remarks>
1686

    
1687
    public const String XML_VERSION = 
1688
        "http://saxon.sf.net/feature/xml-version";
1689

    
1690
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1691

    
1692

    
1693
    /// <summary><para>Sets the value of a parser feature flag. The feature name is any fully-qualified
1694
    ///                URI.</para>
1695
    /// </summary>
1696
    /// <remarks>
1697
    ///            <para>For example if the parser supports a feature
1698
    ///                    <code>http://xml.org/sax/features/external-parameter-entities</code> then this
1699
    ///                can be set by setting the value of the Configuration property:
1700
    ///                    <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
1701
    ///                to true.</para>
1702
    ///        
1703
    /// </remarks>
1704

    
1705
    public const String XML_PARSER_FEATURE = 
1706
        "http://saxon.sf.net/feature/parserFeature?uri=";
1707

    
1708
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1709

    
1710

    
1711
    /// <summary><para>Sets the value of a parser property flag. The property name is any fully-qualified
1712
    ///                URI.</para>
1713
    /// </summary>
1714
    /// <remarks>
1715
    ///            <para>For example if the parser supports a property
1716
    ///                    <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
1717
    ///                then this can be set using the value of the Configuration property:
1718
    ///                    <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
1719
    ///                to the required value.</para>
1720
    ///        
1721
    /// </remarks>
1722

    
1723
    public const String XML_PARSER_PROPERTY = 
1724
        "http://saxon.sf.net/feature/parserProperty?uri=";
1725

    
1726
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1727

    
1728

    
1729
    /// <summary><para>Determines whether XQuery Update syntax is accepted.</para>
1730
    /// </summary>
1731
    /// <remarks>
1732
    ///            <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
1733
    ///                true does not mean that the query has to use update syntax, only that it may do so.</para>
1734
    ///            <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
1735
    ///                this combination is not defined by any W3C specification at the time of writing.</para>
1736
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1737
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1738
    ///            <para>On the command line, this option is combined with the option "discard" which
1739
    ///                indicates that updates are allowed, but the updates are not written back to
1740
    ///                filestore. This does not correspond to any option in the Java API, where writing an
1741
    ///                updated document back to filestore only happens if explicitly requested.</para>
1742
    ///        
1743
    /// </remarks>
1744

    
1745
    public const String XQUERY_ALLOW_UPDATE = 
1746
        "http://saxon.sf.net/feature/xqueryAllowUpdate";
1747

    
1748
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1749

    
1750

    
1751
    /// <summary><para>This option defines the default value of the construction mode in the XQuery static
1752
    ///                context (overridable in the query prolog).</para>
1753
    /// </summary>
1754
    /// <remarks>
1755
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1756
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1757
    ///        
1758
    /// </remarks>
1759

    
1760
    public const String XQUERY_CONSTRUCTION_MODE = 
1761
        "http://saxon.sf.net/feature/xqueryConstructionMode";
1762

    
1763
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1764

    
1765

    
1766
    /// <summary><para>This property defines the default namespace for elements and types that are not
1767
    ///                qualified by a namespace prefix.</para>
1768
    /// </summary>
1769
    /// <remarks>
1770
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1771
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1772
    ///        
1773
    /// </remarks>
1774

    
1775
    public const String XQUERY_DEFAULT_ELEMENT_NAMESPACE = 
1776
        "http://saxon.sf.net/feature/xqueryDefaultElementNamespace";
1777

    
1778
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1779

    
1780

    
1781
    /// <summary><para>This property defines the default namespace for function names that are not qualified
1782
    ///                by a namespace prefix.</para>
1783
    /// </summary>
1784
    /// <remarks>
1785
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1786
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1787
    ///        
1788
    /// </remarks>
1789

    
1790
    public const String XQUERY_DEFAULT_FUNCTION_NAMESPACE = 
1791
        "http://saxon.sf.net/feature/xqueryDefaultFunctionNamespace";
1792

    
1793
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1794

    
1795

    
1796
    /// <summary><para>This property defines how the empty sequence is handled in XQuery sorting (the "order
1797
    ///                by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
1798
    ///                false, it comes last.</para>
1799
    /// </summary>
1800
    /// <remarks>
1801
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1802
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1803
    ///        
1804
    /// </remarks>
1805

    
1806
    public const String XQUERY_EMPTY_LEAST = 
1807
        "http://saxon.sf.net/feature/xqueryEmptyLeast";
1808

    
1809
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1810

    
1811

    
1812
    /// <summary><para>This property defines the default value of the <code>inherit-namespaces</code>
1813
    ///                property in the XQuery static context.</para>
1814
    /// </summary>
1815
    /// <remarks>
1816
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1817
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1818
    ///        
1819
    /// </remarks>
1820

    
1821
    public const String XQUERY_INHERIT_NAMESPACES = 
1822
        "http://saxon.sf.net/feature/xqueryInheritNamespaces";
1823

    
1824
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1825

    
1826

    
1827
    /// <summary><para>If the value is false, then when an <code>import module</code> declaration is
1828
    ///                encountered for a module URI that is already among the known loaded modules (or
1829
    ///                modules in the process of being compiled), the <code>import module</code> is treated
1830
    ///                as a reference to the existing module. If the value is true, the system first checks
1831
    ///                whether the supplied "location hints" match the known location of the existing
1832
    ///                module, and the existing module is used only if there is a match.</para>
1833
    /// </summary>
1834

    
1835
    public const String XQUERY_MULTIPLE_MODULE_IMPORTS = 
1836
        "http://saxon.sf.net/feature/xqueryMultipleModuleImports";
1837

    
1838
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1839

    
1840

    
1841
    /// <summary><para>This property defines whether "boundary space" (insignificant space in direct element
1842
    ///                constructors) should be retained or not.</para>
1843
    /// </summary>
1844
    /// <remarks>
1845
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1846
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1847
    ///        
1848
    /// </remarks>
1849

    
1850
    public const String XQUERY_PRESERVE_BOUNDARY_SPACE = 
1851
        "http://saxon.sf.net/feature/xqueryPreserveBoundarySpace";
1852

    
1853
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1854

    
1855

    
1856
    /// <summary><para>This property defines whether unused namespace declarations are retained by XQuery
1857
    ///                element copy operations.</para>
1858
    /// </summary>
1859
    /// <remarks>
1860
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1861
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1862
    ///        
1863
    /// </remarks>
1864

    
1865
    public const String XQUERY_PRESERVE_NAMESPACES = 
1866
        "http://saxon.sf.net/feature/xqueryPreserveNamespaces";
1867

    
1868
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1869

    
1870

    
1871
    /// <summary><para>This property defines the default expected context item type for a query.</para>
1872
    /// </summary>
1873
    /// <remarks>
1874
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1875
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1876
    ///        
1877
    /// </remarks>
1878

    
1879
    public const String XQUERY_REQUIRED_CONTEXT_ITEM_TYPE = 
1880
        "http://saxon.sf.net/feature/xqueryRequiredContextItemType";
1881

    
1882
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1883

    
1884

    
1885
    /// <summary><para>A query will automatically be schema-aware if it contains an <code>import
1886
    ///                    schema</code> declaration. This property allows a query to be marked as
1887
    ///                schema-aware even if it contains no <code>import schema</code> declaration. It is
1888
    ///                necessary for a query to be compiled as schema-aware if it is to handle typed
1889
    ///                (validated) input documents in which nodes have type annotations based on their
1890
    ///                schema-defined type.</para>
1891
    /// </summary>
1892
    /// <remarks>
1893
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1894
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1895
    ///        
1896
    /// </remarks>
1897

    
1898
    public const String XQUERY_SCHEMA_AWARE = 
1899
        "http://saxon.sf.net/feature/xquerySchemaAware";
1900

    
1901
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1902

    
1903

    
1904
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1905
    ///                reports of static errors in a query will go to this <code>ErrorListener</code>.</para>
1906
    /// </summary>
1907
    /// <remarks>
1908
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1909
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1910
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
1911
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
1912
    ///                property is used.</para>
1913
    ///        
1914
    /// </remarks>
1915

    
1916
    public const String XQUERY_STATIC_ERROR_LISTENER_CLASS = 
1917
        "http://saxon.sf.net/feature/xqueryStaticErrorListenerClass";
1918

    
1919
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1920

    
1921

    
1922
    /// <summary><para>This property determines the version of XQuery used by the
1923
    ///                <code>Configuration</code>.</para>
1924
    /// </summary>
1925
    /// <remarks>
1926
    ///            <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
1927
    ///                property has no effect.</para>
1928
    ///            
1929
    ///        
1930
    /// </remarks>
1931

    
1932
    public const String XQUERY_VERSION = 
1933
        "http://saxon.sf.net/feature/xqueryVersion";
1934

    
1935
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1936

    
1937

    
1938
    /// <summary><para>This property determines the version of XML Schema used by the
1939
    ///                <code>Configuration</code>.</para>
1940
    /// </summary>
1941
    /// <remarks>
1942
    ///            <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
1943
    ///                selected, XSD 1.1 features will be rejected, with the exception of the version
1944
    ///                control attributes that allow sections of the schema to be marked as requiring XSD
1945
    ///                1.0 or XSD 1.1.</para>
1946
    ///        
1947
    /// </remarks>
1948

    
1949
    public const String XSD_VERSION = 
1950
        "http://saxon.sf.net/feature/xsd-version";
1951

    
1952
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1953

    
1954

    
1955
    /// <summary><para>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
1956
    ///                enabled or disabled. They are disabled by default. Setting this property on causes
1957
    ///                assertions to be enabled at compile time for all XSLT packages compiled using the
1958
    ///                default configuration options.</para>
1959
    /// </summary>
1960
    /// <remarks>
1961
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
1962
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1963
    ///                acts as a default.</para>
1964
    ///            <para>If assertions have been enabled at compile time for a particular package, they can
1965
    ///                still be disabled at run-time (for all packages) by setting an option on the
1966
    ///                    <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
1967
    ///                enabling them at run-time has no effect.</para>
1968
    ///        
1969
    /// </remarks>
1970

    
1971
    public const String XSLT_ENABLE_ASSERTIONS = 
1972
        "http://saxon.sf.net/feature/enableAssertions";
1973

    
1974
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1975

    
1976

    
1977
    /// <summary><para>This property indicates the name of a mode within a stylesheet in which execution
1978
    ///                (using template rules) should begin.</para>
1979
    /// </summary>
1980
    /// <remarks>
1981
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
1982
    ///                at the <code>Configuration</code> (or on a <code>TransformerFactory</code>), it acts
1983
    ///                as a default.</para>
1984
    ///        
1985
    /// </remarks>
1986

    
1987
    public const String XSLT_INITIAL_MODE = 
1988
        "http://saxon.sf.net/feature/initialMode";
1989

    
1990
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1991

    
1992

    
1993
    /// <summary><para>This property indicates the name of a named template within a stylesheet where
1994
    ///                execution should begin.</para>
1995
    /// </summary>
1996
    /// <remarks>
1997
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
1998
    ///                at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
1999
    ///                it acts as a default.</para>
2000
    ///        
2001
    /// </remarks>
2002

    
2003
    public const String XSLT_INITIAL_TEMPLATE = 
2004
        "http://saxon.sf.net/feature/initialTemplate";
2005

    
2006
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2007

    
2008

    
2009
    /// <summary><para>This property indicates whether stylesheets should be compiled with the ability to
2010
    ///                handle schema-typed input documents. By default a stylesheet is compiled to handle
2011
    ///                such input if it contains an <code>xsl:import-schema</code> instruction, and not
2012
    ///                otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
2013
    ///                to handle typed (validated) input documents in which nodes have type annotations
2014
    ///                based on their schema-defined type.</para>
2015
    /// </summary>
2016
    /// <remarks>
2017
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2018
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2019
    ///                acts as a default.</para>
2020
    ///        
2021
    /// </remarks>
2022

    
2023
    public const String XSLT_SCHEMA_AWARE = 
2024
        "http://saxon.sf.net/feature/xsltSchemaAware";
2025

    
2026
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2027

    
2028

    
2029
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
2030
    ///                reports of static errors in a stylesheet will go to this
2031
    ///                <code>ErrorListener</code>.</para>
2032
    /// </summary>
2033
    /// <remarks>
2034
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2035
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2036
    ///                acts as a default.</para>
2037
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
2038
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
2039
    ///                property is used.</para>
2040
    ///        
2041
    /// </remarks>
2042

    
2043
    public const String XSLT_STATIC_ERROR_LISTENER_CLASS = 
2044
        "http://saxon.sf.net/feature/stylesheetErrorListener";
2045

    
2046
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2047

    
2048

    
2049
    /// <summary><para>This property defines a <code>URIResolver</code> used when dereferencing the URIs
2050
    ///                that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
2051
    ///                    <code>xsl:import</code> declarations. Note that this defaults to the setting of
2052
    ///                the global <code>URI_RESOLVER</code> property.</para>
2053
    /// </summary>
2054
    /// <remarks>
2055
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2056
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2057
    ///                acts as a default.</para>
2058
    ///            <para>In the absence of this property, the global <code>URIResolver</code> specified as the
2059
    ///                value of the <see cref="URI_RESOLVER_CLASS" /> property
2060
    ///                is used.</para>
2061
    ///        
2062
    /// </remarks>
2063

    
2064
    public const String XSLT_STATIC_URI_RESOLVER_CLASS = 
2065
        "http://saxon.sf.net/feature/stylesheetURIResolver";
2066

    
2067
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2068

    
2069

    
2070
    /// <summary><para>This property determines the version of XSLT to be supported by default.</para>
2071
    /// </summary>
2072
    /// <remarks>
2073
    ///            <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
2074
    ///                property has no effect.</para>
2075
    ///            
2076
    ///        
2077
    /// </remarks>
2078

    
2079
    public const String XSLT_VERSION = 
2080
        "http://saxon.sf.net/feature/xsltVersion";
2081

    
2082
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2083

    
2084

    
2085
    /// <summary><para>This property sets a limit on the amount of backtracking performed during regular expression evaluation.</para>
2086
    /// </summary>
2087
    /// <remarks>
2088
    ///            <para>The default is 10000000 (ten million) which typically represents an evaluation time of about ten seconds.
2089
    ///            After this time, evaluation of the regular expression will fail rather than making further attempts to find a
2090
    ///            match. If this limit is reached, it often suggests that there might be a better way of writing the regular expression.
2091
    ///            The value can be set to -1 (minus one) to mean "unlimited".</para>
2092
    ///            <para>Excessive backtracking is usually caused by nested loops in the regular expression, combined with processing
2093
    ///            of long input strings. Try to ensure that when nested loops are used, there is an unambiguous condition that causes
2094
    ///            the inner loop to terminate. For example <code>(/[^/]*)+</code> is fine (it matches a sequence of path segments separated
2095
    ///                by <code>/</code> characters), because the presence of <code>/</code> forces the inner loop to terminate. By contrast,
2096
    ///                <code>(/.*)+</code> matches the same input, but in many different ways, which could lead to excessive backtracking
2097
    ///            to no useful purpose.</para>
2098
    ///        
2099
    /// </remarks>
2100

    
2101
    public const String REGEX_BACKTRACKING_LIMIT = 
2102
        "http://saxon.sf.net/feature/regexBacktrackingLimit";
2103

    
2104
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2105

    
2106

    
2107
    /// <summary><para>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
2108
    ///                alternatives. This option allows XPath 3.0 or 3.1 to be used instead.</para>
2109
    /// </summary>
2110
    /// <remarks>
2111
    ///            <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
2112
    ///        
2113
    /// </remarks>
2114

    
2115
    public const String XPATH_VERSION_FOR_XSD = 
2116
        "http://saxon.sf.net/feature/xpathVersionForXsd";
2117

    
2118
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2119

    
2120

    
2121
    /// <summary><para>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
2122
    ///                with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
2123
    ///                optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.</para>
2124
    /// </summary>
2125
    /// <remarks>
2126
    ///            <para>The integer values 20, 30, and 31 denote XPath 2.0, 3.0, and 3.1 respectively, while the value 305 denotes XPath 3.0
2127
    ///                with the extensions defined in the XSLT 3.0 specification.</para>
2128
    ///        
2129
    /// </remarks>
2130

    
2131
    public const String XPATH_VERSION_FOR_XSLT = 
2132
        "http://saxon.sf.net/feature/xpathVersionForXslt";
2133

    
2134
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2135

    
2136

    
2137
    /// <summary><para>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
2138
    ///                and they must be below a certain size. This option defines the size.</para>
2139
    /// </summary>
2140
    /// <remarks>
2141
    ///            <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
2142
    ///                includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
2143
    ///                operations such as type checking or conversion of function arguments. The default value is 100.</para>
2144
    ///        
2145
    /// </remarks>
2146

    
2147
    public const String THRESHOLD_FOR_FUNCTION_INLINING = 
2148
        "http://saxon.sf.net/feature/thresholdForFunctionInlining";
2149

    
2150
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2151

    
2152

    
2153
    /// <summary><para>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
2154
    ///                Bytecode is generated when a candidate expression has been evaluated a certain number of
2155
    ///                times, controlled by this parameter.
2156
    ///            </para>
2157
    /// </summary>
2158
    /// <remarks>
2159
    ///            <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
2160
    ///                generation completely. Setting the parameter to a positive value has the effect of enabling
2161
    ///                bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
2162
    ///                to be generated for candidate expressions the first time it is executed.</para>
2163
    ///        
2164
    /// </remarks>
2165

    
2166
    public const String THRESHOLD_FOR_HOTSPOT_BYTE_CODE = 
2167
        "http://saxon.sf.net/feature/thresholdForHotspotByteCode";
2168

    
2169
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2170

    
2171

    
2172
    /// <summary><para>When Saxon-supplied default resolvers are used for URIs (including the <code>URIResolver</code>,
2173
    ///                <code>UnparsedTextResolver</code>, <code>SchemaURIResolver</code>, <code>CollectionResolver</code>, <code>ModuleResolver</code>),
2174
    ///                this parameter defines which URI schemes/protocols are permitted.
2175
    ///            </para>
2176
    /// </summary>
2177
    /// <remarks>
2178
    ///            <para>The format is the same as for <code>XMLConstants.ACCESS_EXTERNAL_SCHEMA</code>: either <code>"all"</code> to allow
2179
    ///                all schemes/protocols, or a comma-separated list of scheme names such as <code>"http"</code>, <code>"file"</code>, <code>"ftp"</code>.
2180
    ///                For a JAR file scheme, use the format <code>"jar:<i>scheme</i>"</code>, for example <code>"jar:file"</code>. A zero-length
2181
    ///            string disallows all schemes.</para>
2182
    ///            <para>This configuration option affects the standard URI Resolvers built in to Saxon, but it does not constrain user-written
2183
    ///            resolvers.</para>
2184
    ///        
2185
    /// </remarks>
2186

    
2187
    public const String ALLOWED_PROTOCOLS = 
2188
        "http://saxon.sf.net/feature/allowedProtocols";
2189

    
2190
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2191

    
2192

    
2193
    /// <summary><para>By default, Saxon attempts to ensure that the run-time code contains no links to the original source stylesheet tree.
2194
    ///                This allows the garbage collector to free memory.
2195
    ///            </para>
2196
    /// </summary>
2197
    /// <remarks>
2198
    ///            <para>If this option is set, then <code>Location</code> objects held in the run-time expression tree may contain a link
2199
    ///                to an element node in the source stylesheet, enabling a user-written <code>ErrorListener</code> to produce
2200
    ///                improved diagnostics. This may be an appropriate setting to use, for example, in an IDE.</para>
2201
    ///            <para>Links to source nodes are not retained in an exported SEF file, regardless of this setting.</para>
2202
    ///        
2203
    /// </remarks>
2204

    
2205
    public const String RETAIN_NODE_FOR_DIAGNOSTICS = 
2206
        "http://saxon.sf.net/feature/retainNodeForDiagnostics";
2207

    
2208
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2209

    
2210

    
2211
    /// <summary><para>The W3C XSD specification (both 1.0 and 1.1) states that an unresolved
2212
    ///        reference to an absent schema component does not automatically make the schema
2213
    ///        invalid; the schema should be usable for validation provided that the missing
2214
    ///        components are not actually needed in a particular validation episode.
2215
    ///      </para>
2216
    /// </summary>
2217
    /// <remarks>
2218
    ///      <para>However, the W3C XSD conformance tests treat such an unresolved reference
2219
    ///      as an error; the test is expected to report the schema as invalid. And this
2220
    ///      is the way most schema processors actually operate, and probably what most
2221
    ///      users would expect.</para>
2222
    ///      <para>By default, the Saxon schema processor reports an unresolved reference
2223
    ///      as an error in the schema.</para>
2224
    ///      <para>If this option is set, then Saxon attempts to repair the schema so that
2225
    ///      it is usable for validation, by substituting the missing components with default
2226
    ///      components: for example if an attribute declaration refers to a type that has
2227
    ///      not been defined, then <code>xs:error</code> is substituted, making any instance
2228
    ///      of the attribute invalid.</para>
2229
    ///      
2230
    /// </remarks>
2231

    
2232
    public const String ALLOW_UNRESOLVED_SCHEMA_COMPONENTS = 
2233
        "http://saxon.sf.net/feature/allowUnresolvedSchemaComponents";
2234

    
2235
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2236

    
2237

    
2238
} 
2239
}
2240

    
2241
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2242
// Copyright (c) 2020 Saxonica Limited.
2243
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
2244
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
2245
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.
2246
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(6-6/13)