Project

Profile

Help

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

he / latest9.9 / hen / csource / api / Saxon.Api / FeatureKeys.cs @ a2e6e9df

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 (and potentially 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 9.8 include the use of type aliases (<code>~aliasName</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>fn{. + 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>The supplied <code>CollectionURIResolver</code> is used to process any URIs used in
185
    ///                calls to the <code>collection()</code> function. The
186
    ///                    <code>CollectionURIResolver</code> may either return a sequence of URIs (which
187
    ///                are then resolved in the same way as URIs passed to the <code>doc()</code>
188
    ///                function), or it may return a sequence of (typically document) nodes.</para>
189
    /// </summary>
190

    
191
    public const String COLLECTION_URI_RESOLVER = 
192
        "http://saxon.sf.net/feature/collection-uri-resolver";
193

    
194
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
195

    
196

    
197
    /// <summary><para>The supplied class is instantiated and the resulting instance is used as the value of
198
    ///                the <see cref="COLLECTION_URI_RESOLVER" /> property.</para>
199
    /// </summary>
200

    
201
    public const String COLLECTION_URI_RESOLVER_CLASS = 
202
        "http://saxon.sf.net/feature/collection-uri-resolver-class";
203

    
204
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
205

    
206

    
207
    /// <summary><para>If run-time tracing of stylesheet or query execution is required, then the code must
208
    ///                be compiled with tracing enabled.</para>
209
    /// </summary>
210
    /// <remarks>
211
    ///            <para>Default is false. This option causes code to be
212
    ///                compiled that makes calls to a <see cref="net.sf.saxon.lib.TraceListener" />, but this
213
    ///                has no effect unless a <code>TraceListener</code> is registered at execution
214
    ///                time.</para>
215
    ///        
216
    /// </remarks>
217

    
218
    public const String COMPILE_WITH_TRACING = 
219
        "http://saxon.sf.net/feature/compile-with-tracing";
220

    
221
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
222

    
223

    
224
    /// <summary><para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself,
225
    ///                but it can be set on various JAXP factory objects such as a
226
    ///                <code>TransformerFactory</code> or <code>DocumentBuilderFactory</code>, to
227
    ///                ensure that several such factories use the same <code>Configuration</code>.</para>
228
    /// </summary>
229
    /// <remarks>
230
    ///            <para>Note that other configuration options are held in the <code>Configuration</code> object,
231
    ///                so setting this attribute will cancel all others that have been set. Also, if two
232
    ///                factories share the same <code>Configuration</code>, then setting an attribute on
233
    ///                one affects all the others.</para>
234
    ///        
235
    /// </remarks>
236

    
237
    public const String CONFIGURATION = 
238
        "http://saxon.sf.net/feature/configuration";
239

    
240
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
241

    
242

    
243
    /// <summary><para>Defines a configuration file to be applied to the configuration.</para>
244
    /// </summary>
245
    /// <remarks>
246
    ///            <para>This attribute cannot be set on the <see cref="net.sf.saxon.Configuration" /> itself, but it can be
247
    ///                set on various JAXP factory objects such as a <code>TransformerFactory</code> or
248
    ///                    <code>DocumentBuilderFactory</code>. It is particularly useful when running
249
    ///                transformations via the Ant xslt task, where it can be set as follows to define all
250
    ///                configuration settings: </para>
251
    ///            <para><code>&lt;factory name="net.sf.saxon.TransformerFactoryImpl"&gt; &lt;attribute
252
    ///                    name="http://saxon.sf.net/feature/configuration-file"
253
    ///                    value="c:/saxon/config.xml"/&gt; &lt;/factory&gt;</code>
254
    ///            </para>
255
    ///        
256
    /// </remarks>
257

    
258
    public const String CONFIGURATION_FILE = 
259
        "http://saxon.sf.net/feature/configuration-file";
260

    
261
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
262

    
263

    
264
    /// <summary><para>This option is set to indicate that bytecode generation should be run in debugging
265
    ///                mode; it injects diagnostic tracing calls into the generated bytecode. This should
266
    ///                be used only if requested by Saxonica support to diagnose a problem related to
267
    ///                bytecode generation.</para>
268
    /// </summary>
269

    
270
    public const String DEBUG_BYTE_CODE = 
271
        "http://saxon.sf.net/feature/debugByteCode";
272

    
273
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
274

    
275

    
276
    /// <summary><para>This option is relevant only if <code>DISPLAY_BYTE_CODE</code> is set to true. It
277
    ///                defines a directory to which files containing bytecode in human-readable form will
278
    ///                be written. There will be one such file for each generated class, with a filename
279
    ///                designed to give some kind of clue as to its relationship to the source code.</para>
280
    /// </summary>
281
    /// <remarks>
282
    ///            <para>The default value is the directory <code>saxonByteCode</code> within the current
283
    ///                working directory.</para>
284
    ///            <para>The named directory is created if it does not already exist.</para>
285
    ///            <para>Because the generation of class names involves random numbers, files will tend to
286
    ///                accumulate in the supplied directory, even when the same source code is compiled
287
    ///                repeatedly.</para>
288
    ///        
289
    /// </remarks>
290

    
291
    public const String DEBUG_BYTE_CODE_DIR = 
292
        "http://saxon.sf.net/feature/debugByteCodeDir";
293

    
294
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
295

    
296

    
297
    /// <summary><para>This option determines the collation that is used for comparing strings when no
298
    ///                explicit collation is requested. It is not necessary for this collation to exist (or
299
    ///                to have been registered) when setting this option; it only needs to exist by the
300
    ///                time it is used.</para>
301
    /// </summary>
302
    /// <remarks>
303
    ///            <para>In XSLT it is possible to override this setting using the
304
    ///                    <code>[xsl:]default-collation</code> attribute on any stylesheet element. In
305
    ///                XQuery, it can be overridden using the <code>declare default collation</code>
306
    ///                declaration in the query prolog, or via a setter method in class
307
    ///                    <see cref="net.sf.saxon.query.StaticQueryContext" />.</para>
308
    ///            <para>If no value is specified, the Unicode codepoint collation is used.</para>
309
    ///        
310
    /// </remarks>
311

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

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

    
317

    
318
    /// <summary><para>This determines the collection that is used when the <code>fn:collection()</code>
319
    ///                function is called with no arguments; the effect is the same as if it were called
320
    ///                passing the URI that is the value of this configuration property.</para>
321
    /// </summary>
322

    
323
    public const String DEFAULT_COLLECTION = 
324
        "http://saxon.sf.net/feature/defaultCollection";
325

    
326
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
327

    
328

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

    
335
    public const String DEFAULT_COUNTRY = 
336
        "http://saxon.sf.net/feature/defaultCountry";
337

    
338
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
339

    
340

    
341
    /// <summary><para>This option determines the language that is used by <code>format-date()</code>,
342
    ///                    <code>xsl:number</code> and similar constructs if no language code is supplied
343
    ///                explicitly. If no value is given for this property, the default is taken from the
344
    ///                Java Locale, which in turn typically depends on settings for the current user in the
345
    ///                operating system.</para>
346
    /// </summary>
347

    
348
    public const String DEFAULT_LANGUAGE = 
349
        "http://saxon.sf.net/feature/defaultLanguage";
350

    
351
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
352

    
353

    
354
    /// <summary><para>Determines which regular expression engine should be used for evaluating regular expressions occuring in constructs
355
    ///            such as <code>fn:matches()</code>, <code>fn:replace</code>, and <code>xsl:analyze-string</code>, and also
356
    ///            in the pattern facet of a schema.</para>
357
    /// </summary>
358
    /// <remarks>
359
    ///            <para>On the Java platform the permitted values are "S" (default), and "J". The value "J" selects the regex engine
360
    ///            provided in the JDK in preference to the Saxon regular expression engine. This means that regular expressions must
361
    ///            follow the Java syntax and semantics rather than the XPath syntax and semantics.</para>
362
    ///            <para>On the .NET platform the permitted values are "S" (default), "J", and "N". The value "J" selects the regex engine
363
    ///                provided in the IKVMC run-time, which is derived from OpenJDK. The value "N" selects the regex engine provided
364
    ///            in the Microsoft .NET platform. In each case, the regular expression must follow the syntax and semantics of the selected
365
    ///            regex engine.</para>
366
    ///            <para>The choice of regular expression may be overridden in a particular invocation by appending the value ";s",
367
    ///            ";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>
368
    ///            <para>Use of this feature is not conformant with W3C specifications. Use of the setting "N", however, can be useful
369
    ///            when schemas have been written with the Microsoft schema processor in mind, since this uses the Microsoft regular
370
    ///            expression dialect rather than the W3C dialect.</para>
371
    ///        
372
    /// </remarks>
373

    
374
    public const String DEFAULT_REGEX_ENGINE = 
375
        "http://saxon.sf.net/feature/defaultRegexEngine";
376

    
377
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
378

    
379

    
380
    /// <summary><para>This option disables the <code>xsl:evaluate</code> instruction.</para>
381
    /// </summary>
382
    /// <remarks>
383
    ///            <para>If set at stylesheet compile time, the feature is statically disabled. If set at 
384
    ///                run-time it is dynamically disabled. (These terms are defined in the XSLT 3.0 spec.) 
385
    ///                The feature is always disabled (statically) in Saxon-HE.</para>
386
    ///        
387
    /// </remarks>
388

    
389
    public const String DISABLE_XSL_EVALUATE = 
390
        "http://saxon.sf.net/feature/disableXslEvaluate";
391

    
392
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
393

    
394

    
395
    /// <summary><para>This option is set to indicate that bytecode generation should be run in display
396
    ///                mode. The effect is to output files (one per class) containing a human-readable
397
    ///                print of the generated bytecode. The files are placed in the directory identified by
398
    ///                the <code>DEBUG_BYTE_CODE_DIR</code> option.</para>
399
    /// </summary>
400

    
401
    public const String DISPLAY_BYTE_CODE = 
402
        "http://saxon.sf.net/feature/displayByteCode";
403

    
404
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
405

    
406

    
407
    /// <summary><para>If true, the XML parser is requested to perform validation of source documents
408
    ///                against their DTD. Default is false.</para>
409
    /// </summary>
410
    /// <remarks>
411
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
412
    ///                or schema documents) are parsed. The option can be overridden for individual
413
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
414
    ///                individual document, for example from a <code>URIResolver</code>.</para>
415
    ///        
416
    /// </remarks>
417

    
418
    public const String DTD_VALIDATION = 
419
        "http://saxon.sf.net/feature/validation";
420

    
421
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
422

    
423

    
424
    /// <summary><para>This option determines whether DTD validation failures should be treated as
425
    ///                recoverable. If the option is set, a validation failure is reported as a warning
426
    ///                rather than an error. The default is false.</para>
427
    /// </summary>
428
    /// <remarks>
429
    ///            <para>This option establishes a default for use whenever source documents (not stylesheets
430
    ///                or schema documents) are parsed. The option can be overridden for individual
431
    ///                documents by setting the <see cref="net.sf.saxon.lib.ParseOptions" /> for that
432
    ///                individual document, for example from a <code>URIResolver</code>.</para>
433
    ///        
434
    /// </remarks>
435

    
436
    public const String DTD_VALIDATION_RECOVERABLE = 
437
        "http://saxon.sf.net/feature/dtd-validation-recoverable";
438

    
439
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
440

    
441

    
442
    /// <summary><para>Forces Saxon to do eager evaluation of expressions in contexts where normally it would do lazy evaluation,
443
    ///                for example when evaluating variables and function results. This can make for easier debugging.</para>
444
    /// </summary>
445
    /// <remarks>
446
    ///            <para>Note that this only applies to situations where Saxon would normally save a <code>Closure</code>
447
    ///            object as the result of an expression. It does not prevent Saxon from using pipelined evaluation of
448
    ///            intermediate expressions using iterators.</para>
449
    ///        
450
    /// </remarks>
451

    
452
    public const String EAGER_EVALUATION = 
453
        "http://saxon.sf.net/feature/eagerEvaluation";
454

    
455
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
456

    
457

    
458
    /// <summary><para>The supplied class is instantiated and the resulting <code>EntityResolver</code> is
459
    ///                used whenever Saxon itself creates an <code>XMLReader</code> for parsing source
460
    ///                documents. It is not used with a user-supplied <code>XMLReader</code>.</para>
461
    /// </summary>
462
    /// <remarks>
463
    ///            <para>The default value is <see cref="net.sf.saxon.lib.StandardEntityResolver" />. This is an entity
464
    ///                resolver that recognizes the names of many standard W3C DTDs and external entity
465
    ///                files, and resolves them against local copies issued with the Saxon software, to
466
    ///                avoid the need to fetch them from the web.</para>
467
    ///            <para>The property can be set to a zero-length string, in which case no
468
    ///                    <code>EntityResolver</code> will be used.</para>
469
    ///
470
    ///        
471
    /// </remarks>
472

    
473
    public const String ENTITY_RESOLVER_CLASS = 
474
        "http://saxon.sf.net/feature/entityResolverClass";
475

    
476
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
477

    
478

    
479
    /// <summary><para>Setting the <code>ENVIRONMENT_VARIABLE_RESOLVER</code> causes the supplied object to
480
    ///                be registered as the environment variable resolver for the
481
    ///                    <code>Configuration</code>. The setting is global: it affects all queries and
482
    ///                transformations using this configuration.</para>
483
    /// </summary>
484
    /// <remarks>
485
    ///            <para>The environment variable resolver is used when the XPath functions
486
    ///                    <code>available-environment-variables()</code> or
487
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
488
    ///                evaluation of the function to the external resolver.</para>
489
    ///        
490
    /// </remarks>
491

    
492
    public const String ENVIRONMENT_VARIABLE_RESOLVER = 
493
        "http://saxon.sf.net/feature/environmentVariableResolver";
494

    
495
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
496

    
497

    
498
    /// <summary><para>Setting <code>ENVIRONMENT_VARIABLE_RESOLVER_CLASS</code> causes an instance of the
499
    ///                supplied class to be created, and registered as the environment variable resolver
500
    ///                for the <code>Configuration</code>. The setting is global: it affects all queries
501
    ///                and transformations using this configuration.</para>
502
    /// </summary>
503
    /// <remarks>
504
    ///            <para>The environment variable resolver is used when the XPath functions
505
    ///                    <code>available-environment-variables()</code> or
506
    ///                    <code>environment-variable()</code> are called. Saxon essentially delegates the
507
    ///                evaluation of the function to the external resolver.</para>
508
    ///        
509
    /// </remarks>
510

    
511
    public const String ENVIRONMENT_VARIABLE_RESOLVER_CLASS = 
512
        "http://saxon.sf.net/feature/environmentVariableResolverClass";
513

    
514
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
515

    
516

    
517
    /// <summary><para><code>ERROR_LISTENER_CLASS</code> is the name of the class used to implement the JAXP
518
    ///                <code>ErrorListener</code>. This is used both at compile time and at run-time.</para>
519
    /// </summary>
520
    /// <remarks>
521
    ///            <para>Currently if this option is specified, the class is instantiated, and the same
522
    ///                instance is used for all processes running under this configuration. This may change
523
    ///                in future so that a new instance is created for each compilation or evaluation.</para>
524
    ///            <para>Finer control can be obtained by setting the <code>ErrorListener</code> for a
525
    ///                specific XSLT or XQuery compilation or evaluation.</para>
526
    ///        
527
    /// </remarks>
528

    
529
    public const String ERROR_LISTENER_CLASS = 
530
        "http://saxon.sf.net/feature/errorListenerClass";
531

    
532
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
533

    
534

    
535
    /// <summary><para><code>EXPAND_ATTRIBUTE_DEFAULTS</code> determines whether fixed and default values
536
    ///                defined in a schema or DTD will be expanded (both on input and on output documents,
537
    ///                if validation is requested).</para>
538
    /// </summary>
539
    /// <remarks>
540
    ///            <para>By default (and for conformance with the specification)
541
    ///                validation against a DTD or schema will cause default values defined in the schema
542
    ///                or DTD to be inserted into the document. Setting this feature to false suppresses
543
    ///                this behavior. In the case of DTD-defined defaults this only works if the XML parser
544
    ///                reports whether each attribute was specified in the source or generated by expanding
545
    ///                a default value. Not all XML parsers report this information.</para>
546
    ///        
547
    /// </remarks>
548

    
549
    public const String EXPAND_ATTRIBUTE_DEFAULTS = 
550
        "http://saxon.sf.net/feature/expandAttributeDefaults";
551

    
552
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
553

    
554

    
555
    /// <summary><para><code>EXPATH_FILE_DELETE_TEMPORARY_FILES</code> determines whether temporary files
556
    ///                and directories created in the EXPath File module should be automatically deleted on
557
    ///                closure of the JVM.</para>
558
    /// </summary>
559
    /// <remarks>
560
    ///            <para>The default value is <b>false</b>, to align with the standard. The setting
561
    ///                    <b>false</b> is recommended when external 'sweep-up' features aren't
562
    ///                available.</para>
563
    ///        
564
    /// </remarks>
565

    
566
    public const String EXPATH_FILE_DELETE_TEMPORARY_FILES = 
567
        "http://saxon.sf.net/feature/expathFileDeleteTemporaryFiles";
568

    
569
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
570

    
571

    
572
    /// <summary><para>By default, Saxon-EE attempts to generate Java bytecode for evaluation of parts of a
573
    ///                query or stylesheet that are amenable to such treatment. Setting this option to
574
    ///                false disables this.</para>
575
    /// </summary>
576

    
577
    public const String GENERATE_BYTE_CODE = 
578
        "http://saxon.sf.net/feature/generateByteCode";
579

    
580
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
581

    
582

    
583
    /// <summary><para>If this option is set to true, then when a <code>SAXSource</code> is supplied as the
584
    ///                input to an XSLT transformation, Saxon will ignore the <code>XMLReader</code>
585
    ///                supplied in the <code>SAXSource</code> (in fact, it will modify the supplied
586
    ///                    <code>SAXSource</code> setting the <code>XMLReader</code> to null) and use an
587
    ///                    <code>XMLReader</code> created using the value of the
588
    ///                    <code>SOURCE_PARSER_CLASS</code> option in preference.</para>
589
    /// </summary>
590
    /// <remarks>
591
    ///            <para>The defining use case for this feature is when calling a Saxon transformation from
592
    ///                Ant. Ant always supplies the source document as a <code>SAXSource</code> using a
593
    ///                parser instantiated using the default JAXP mechanism. A different parser set using
594
    ///                the property <code>http://saxon.sf.net/feature/sourceParserClass</code> will
595
    ///                normally be ignored in this case; setting the <code>ignoreSAXSourceParser</code>
596
    ///                option overrides this. This is especially useful if the input format is not in fact
597
    ///                XML, but some other format converted to a SAX event stream by means of a custom
598
    ///                parser.</para>
599
    ///        
600
    /// </remarks>
601

    
602
    public const String IGNORE_SAX_SOURCE_PARSER = 
603
        "http://saxon.sf.net/feature/ignoreSAXSourceParser";
604

    
605
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
606

    
607

    
608
    /// <summary><para><code>IMPLICIT_SCHEMA_IMPORTS</code> allows reference to schema components without an <code>xs:import</code> for the relevant namespace being
609
    ///                present in the containing schema document. </para>
610
    /// </summary>
611
    /// <remarks>
612
    ///            <para>This only works if the referenced components are already present among the schema components known to the configuration, perhaps
613
    ///            because they were part of a different schema, or because there are cyclic references within a schema.</para>
614
    ///            <para>This option is not conformant with the XSD specification, which requires explicit <code>xs:import</code> declarations
615
    ///            for all cross-namespace component references. However, some "industry-standard" schemas are known to violate this rule,
616
    ///            and setting this option allows such schemas to be loaded by Saxon.</para>
617
    ///        
618
    /// </remarks>
619

    
620
    public const String IMPLICIT_SCHEMA_IMPORTS = 
621
        "http://saxon.sf.net/feature/implicitSchemaImports";
622

    
623
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
624

    
625

    
626
    /// <summary><para><code>LAZY_CONSTRUCTION_MODE</code> determines whether temporary trees are
627
    ///                constructed lazily. The default setting is false; there are a few situations (but
628
    ///                not many) where setting this to true can give a performance benefit (especially a
629
    ///                memory saving).</para>
630
    /// </summary>
631
    /// <remarks>
632
    ///            <para>The option is most likely to be effective when executing XQuery in "pull" mode, that
633
    ///                is, when the client calls the query processor to deliver the result as a stream of
634
    ///                nodes, rather than running the query and piping the results into a serializer.</para>
635
    ///        
636
    /// </remarks>
637

    
638
    public const String LAZY_CONSTRUCTION_MODE = 
639
        "http://saxon.sf.net/feature/lazyConstructionMode";
640

    
641
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
642

    
643

    
644
    /// <summary><para><code>LICENSE_FILE_LOCATION</code> holds the filename in which the Saxon license file
645
    ///                is held.</para>
646
    /// </summary>
647
    /// <remarks>
648
    ///            <para>This is the full file name, for example <code>c:/saxon/license/license.lic</code>. 
649
    ///                Setting this property causes Saxon to
650
    ///                immediately read the specified file and register the license data, assuming it can
651
    ///                be found at this location. The property is not recognized for reading, and it is not
652
    ///                recognized for writing except in Saxon-PE and Saxon-EE.</para>
653
    ///        
654
    /// </remarks>
655

    
656
    public const String LICENSE_FILE_LOCATION = 
657
        "http://saxon.sf.net/feature/licenseFileLocation";
658

    
659
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
660

    
661

    
662
    /// <summary><para>Default is false. If true, line and column number information is retained for all
663
    ///                source documents. This information is accessible using the
664
    ///                    <code>saxon:line-number()</code> and <code>saxon:column-number()</code>
665
    ///                extension functions.</para>
666
    /// </summary>
667
    /// <remarks>
668
    ///            <para>Note that the information is only as good as the XML parser supplies. SAX parsers
669
    ///                generally report the position of an element node using the line and column number of
670
    ///                the "&gt;" character that forms the last character of the start tag.</para>
671
    ///            <para>When this option is set, location information attached to a node (system ID, line
672
    ///            number, and column number) is retained when the node is copied. This has the side effect
673
    ///            that the base URI of a node is also copied, which in some cases runs contrary to the
674
    ///            XSLT or XQuery specification.</para>
675
    ///        
676
    /// </remarks>
677

    
678
    public const String LINE_NUMBERING = 
679
        "http://saxon.sf.net/feature/linenumbering";
680

    
681
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
682

    
683

    
684
    /// <summary><para>Setting the <code>MARK_DEFAULTED_ATTRIBUTES</code> option causes Saxon to retain details of attributes
685
    ///            that were notified by the XML parser as being defaulted (that is, the attribute was not present in the instance
686
    ///            document but was defined by a default value in a DTD or schema). This information is available to applications
687
    ///            via the <code>saxon:is-defaulted()</code> extension function.</para>
688
    /// </summary>
689
    /// <remarks>
690
    ///            <para>Note: information about defaulted attributes is retained automatically where the attribute is processed
691
    ///            using Saxon's schema processor; but in the case where the information comes from an external XML parser, it
692
    ///            is retained only if this option is set.</para>
693
    ///        
694
    /// </remarks>
695

    
696
    public const String MARK_DEFAULTED_ATTRIBUTES = 
697
        "http://saxon.sf.net/feature/markDefaultedAttributes";
698

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

    
701

    
702
    /// <summary><para>Places a limit on the number of classes for which Saxon will generate bytecode.</para>
703
    /// </summary>
704
    /// <remarks>
705
    ///            <para>If bytecode generation is enabled, Saxon will generate bytecode for frequently used constructs appearing
706
    ///                in stylesheets or queries. This can become problematic if a configuration uses a very large number
707
    ///                of different stylesheets and queries, because it creates memory pressure (in some environments classes
708
    ///                are never garbage collected). When this limit (which defaults to 10,000) is exceeded, no more bytecode
709
    ///            is generated, and queries/stylesheets are interpreted instead.</para>
710
    ///        
711
    /// </remarks>
712

    
713
    public const String MAX_COMPILED_CLASSES = 
714
        "http://saxon.sf.net/feature/maxCompiledClasses";
715

    
716
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
717

    
718

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

    
748
    public const String MESSAGE_EMITTER_CLASS = 
749
        "http://saxon.sf.net/feature/messageEmitterClass";
750

    
751
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
752

    
753

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

    
759
    public const String MODULE_URI_RESOLVER = 
760
        "http://saxon.sf.net/feature/moduleURIResolver";
761

    
762
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
763

    
764

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

    
770
    public const String MODULE_URI_RESOLVER_CLASS = 
771
        "http://saxon.sf.net/feature/moduleURIResolverClass";
772

    
773
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
774

    
775

    
776
    /// <summary><para>When set from the Transform or Query command line, a report on bytecode generation is
777
    ///                produced at the end of the transformation or query.</para>
778
    /// </summary>
779
    /// <remarks>
780
    ///            <para>When set from an application, the bytecode report is produced only on request, by
781
    ///                calling <code>Configuration.createByteCodeReport(fileName)</code>.</para>
782
    ///            <para>The bytecode report is an XML file containing one entry for each expression that has
783
    ///                been compiled into bytecode. Each entry contains the following details, where
784
    ///                applicable:</para>
785
    ///                <list>
786
    ///                <item><code>text</code> Abbreviated text of the expression</item>
787
    ///                <item><code>intCount</code> Number of times the expression was evaluated in the interpreter</item>
788
    ///                <item><code>intTime</code> Cumulative time spent evaluating the expression (including subexpressions) in the interpreter</item>
789
    ///                <item><code>bcCount</code> Number of times the expression was evaluated as byte-code</item>
790
    ///                <item><code>bcTime</code> Cumulative time spent evaluating the expression (including subexpressions) as byte-code</item>
791
    ///                <item><code>compileTime</code> Time spent generating bytecode for the expression</item>
792
    ///                <item><code>ratio</code> Average byte-code execution time as a proportion of average interpreted execution time</item>
793
    ///                <item><code>ebv</code> Number of evaluations of the expressions <code>effectiveBooleanValue()</code> method</item>
794
    ///                <item><code>eval</code> Number of evaluations of the expressions <code>evaluateItem()</code> method</item>
795
    ///                <item><code>iterate</code> Number of evaluations of the expressions <code>iterate()</code> method</item>
796
    ///                <item><code>process</code> Number of evaluations of the expressions <code>process()</code> method</item>
797
    ///                <item><code>module</code> URI of the module containing the expression</item>
798
    ///                <item><code>line</code> Line number of the expression within this module</item>
799
    ///            </list>
800
    ///        
801
    /// </remarks>
802

    
803
    public const String MONITOR_HOT_SPOT_BYTE_CODE = 
804
        "http://saxon.sf.net/feature/monitorHotSpotByteCode";
805

    
806
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
807

    
808

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

    
832
    public const String MULTIPLE_SCHEMA_IMPORTS = 
833
        "http://saxon.sf.net/feature/multipleSchemaImports";
834

    
835
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
836

    
837

    
838
    /// <summary><para>Indicates that the supplied <code>NamePool</code> should be used as the target
839
    ///                (run-time) <code>NamePool</code> by all stylesheets compiled (using
840
    ///                <code>newTemplates()</code>) after this call on <code>setAttribute</code>.</para>
841
    /// </summary>
842
    /// <remarks>
843
    ///            <para>Normally a single system-allocated <code>NamePool</code> is used for all stylesheets
844
    ///                compiled while the Java VM remains loaded; this attribute allows user control over
845
    ///                the allocation of name pools. Note that source trees used as input to a
846
    ///                transformation must be built using the same <code>NamePool</code> that is used when
847
    ///                the stylesheet is compiled: this will happen automatically if the input to a
848
    ///                transformation is supplied as a <code>SAXSource</code> or <code>StreamSource</code>
849
    ///                but it is under user control if you build the source tree yourself.</para>
850
    ///            <para>This option can be used to make two <code>Configuration</code> objects share a
851
    ///                    <code>NamePool</code> even though they differ in other respects.</para>
852
    ///        
853
    /// </remarks>
854

    
855
    public const String NAME_POOL = 
856
        "http://saxon.sf.net/feature/namePool";
857

    
858
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
859

    
860

    
861
    /// <summary><para><code>OCCURRENCE_LIMITS</code> determines the largest values of
862
    ///                <code>minOccurs</code> and <code>maxOccurs</code> that can be accommodated when
863
    ///                compiling an "expanded" finite state machine to represent an XSD content model
864
    ///                grammar.</para>
865
    /// </summary>
866
    /// <remarks>
867
    ///            <para>These limits do not apply in the common cases where the grammar can be
868
    ///                implemented using a counting finite-state-machine, but in those cases where this is
869
    ///                not possible, any <code>minOccurs</code> value greater than the first integer is
870
    ///                reduced to the value of the first integer, and any <code>maxOccurs</code> value
871
    ///                greater than the second integer is treated as "unbounded".</para>
872
    ///            <para>Setting these values too high may cause an <code>OutOfMemoryException</code> since
873
    ///                the size of the finite state machine constructed by Saxon increases linearly with
874
    ///                the values of <code>minOccurs</code> and <code>maxOccurs</code>.</para>
875
    ///        
876
    /// </remarks>
877

    
878
    public const String OCCURRENCE_LIMITS = 
879
        "http://saxon.sf.net/feature/occurrenceLimits";
880

    
881
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
882

    
883

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

    
917
    public const String OPTIMIZATION_LEVEL = 
918
        "http://saxon.sf.net/feature/optimizationLevel";
919

    
920
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
921

    
922

    
923
    /// <summary><para>The supplied <code>OutputURIResolver</code> will be used to resolve URIs of secondary
924
    ///                result documents selected in the <code>href</code> attribute of the XSLT
925
    ///                    <code>xsl:result-document</code> instruction.</para>
926
    /// </summary>
927

    
928
    public const String OUTPUT_URI_RESOLVER = 
929
        "http://saxon.sf.net/feature/outputURIResolver";
930

    
931
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
932

    
933

    
934
    /// <summary><para>The supplied class will be instantiated, and the resulting
935
    ///                    <code>OutputURIResolver</code> will be used to resolve URIs of secondary result
936
    ///                documents selected in the <code>href</code> attribute of the XSLT
937
    ///                    <code>xsl:result-document</code> instruction.</para>
938
    /// </summary>
939

    
940
    public const String OUTPUT_URI_RESOLVER_CLASS = 
941
        "http://saxon.sf.net/feature/outputURIResolverClass";
942

    
943
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
944

    
945

    
946
    /// <summary><para>If true, calls on the <code>doc()</code> and <code>document()</code> functions, if
947
    ///                their arguments are known at compile time, will be evaluated at compile time, and
948
    ///                the resulting document will be stored as part of the Saxon
949
    ///                <see cref="net.sf.saxon.Configuration" /> and shared by all queries and
950
    ///                transformations running within that <code>Configuration</code>.</para>
951
    /// </summary>
952
    /// <remarks>
953
    ///            <para>This is useful for reference documents that have stable content and are used by many different 
954
    ///                queries and transformations. The default is false, which means each query or transformation
955
    ///                will reload the document from disk.</para>
956
    ///            <para>In XSLT 3.0 a better way of having external documents pre-loaded at stylesheet
957
    ///                compile time is to use the new facility of static global variables.</para>
958
    ///        
959
    /// </remarks>
960

    
961
    public const String PRE_EVALUATE_DOC_FUNCTION = 
962
        "http://saxon.sf.net/feature/preEvaluateDocFunction";
963

    
964
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
965

    
966

    
967
    /// <summary><para>Relevant only on .NET, determines whether the Java Classpath parser is used in
968
    ///                preference to the Microsoft .NET parser.</para>
969
    /// </summary>
970
    /// <remarks>
971
    ///            <para>This option has no effect on the Java platform. The default is <b>true</b>. When
972
    ///                running on the .NET platform, if the option is true it causes the Apache Xerces
973
    ///                parser (cross-compiled using IKVMC) to be used in preference to the .NET XML parser.
974
    ///                If false the .NET XML parser (<code>System.Xml.XmlTextReader</code>) is used. One
975
    ///                reason for providing this option is that the .NET XML parser does not report ID
976
    ///                attributes, which means that the <code>id()</code> function does not work.</para>
977
    ///        
978
    /// </remarks>
979

    
980
    public const String PREFER_JAXP_PARSER = 
981
        "http://saxon.sf.net/feature/preferJaxpParser";
982

    
983
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
984

    
985

    
986
    /// <summary><para>True if the standard URI resolver is to recognize query parameters included in
987
    ///                the URI (for example, <code>?val=strict</code>). Such parameters can then be used in
988
    ///                URIs passed to the <code>doc()</code> or <code>document()</code> functions. For
989
    ///                details of the query parameters available, see <span class="link" data-href="/sourcedocs">Source Documents</span>. The default is false.</para>
990
    /// </summary>
991
    /// <remarks>
992
    ///            <para>This option has no effect if a user-supplied <code>URIResolver</code> is in use,
993
    ///                unless the user-supplied <code>URIResolver</code> chooses to inherit this
994
    ///                functionality from the standard <code>URIResolver</code>.</para>
995
    ///            <para>Allowed parameters include <code>validation=strict|lax|strip</code> to perform schema
996
    ///                validation, <code>strip-space=yes|ignorable|no</code> to control whitespace
997
    ///                stripping, and <code>xinclude=yes|no</code> to control whether XInclude processing
998
    ///                takes place (assuming the XML parser supports it).</para>
999
    ///        
1000
    /// </remarks>
1001

    
1002
    public const String RECOGNIZE_URI_QUERY_PARAMETERS = 
1003
        "http://saxon.sf.net/feature/recognize-uri-query-parameters";
1004

    
1005
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1006

    
1007

    
1008
    /// <summary><para>An integer, one of <see cref="net.sf.saxon.Configuration#RECOVER_SILENTLY" />,
1009
    ///                <see cref="net.sf.saxon.Configuration#RECOVER_WITH_WARNINGS" />, or
1010
    ///                <see cref="net.sf.saxon.Configuration#DO_NOT_RECOVER" />. Indicates the policy for
1011
    ///                handling dynamic errors that the XSLT specification defines as recoverable.</para>
1012
    /// </summary>
1013
    /// <remarks>
1014
    ///            <para>0 means recover silently; 1 means recover after signalling a warning to the
1015
    ///                    <code>ErrorListener</code>; 2 means treat the error as fatal. An example of a
1016
    ///                recoverable error is when two template rules match the same node.</para>
1017
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1018
    ///                specification.</para>
1019
    ///        
1020
    /// </remarks>
1021

    
1022
    public const String RECOVERY_POLICY = 
1023
        "http://saxon.sf.net/feature/recoveryPolicy";
1024

    
1025
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1026

    
1027

    
1028
    /// <summary><para>Indicates the policy for handling dynamic errors that the XSLT specification defines
1029
    ///                as recoverable.</para>
1030
    /// </summary>
1031
    /// <remarks>
1032
    ///            <para>"recoverSilently" means recover silently; "recoverWithWarnings"
1033
    ///                means recover after signalling a warning to the <code>ErrorListener</code>;
1034
    ///                "doNotRecover" means treat the error as fatal. An example of a recoverable error is
1035
    ///                when two template rules match the same node. </para>
1036
    ///            <para>Note that XSLT 3.0 has eliminated all "recoverable errors" from the
1037
    ///                specification.</para>
1038
    ///        
1039
    /// </remarks>
1040

    
1041
    public const String RECOVERY_POLICY_NAME = 
1042
        "http://saxon.sf.net/feature/recoveryPolicyName";
1043

    
1044
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1045

    
1046

    
1047
    /// <summary><para>Indicates the maximum number of threads to be used for processing
1048
    ///                    <code>xsl:result-document</code> instructions in parallel. If the maximum number
1049
    ///                of threads are already in use, the <code>xsl:result-document</code> instruction will
1050
    ///                be executed synchronously within its parent thread.</para>
1051
    /// </summary>
1052
    /// <remarks>
1053
    ///            <para>The default value is initialized to
1054
    ///                    <code>Runtime.getRuntime().availableProcessors()</code> which is intended to
1055
    ///                represent the number of "processors" (under some definition) available from the
1056
    ///                hardware.</para>
1057
    ///            <para>The limit applies per <code>Configuration</code>. If multiple workloads are running
1058
    ///                on the same server under separate Saxon <code>Configuration</code> objects, then it
1059
    ///                may be desirable to lower the limit.</para>
1060
    ///            <para>Setting a value of zero or one suppresses multithreading entirely. This can also be
1061
    ///                achieved (for a specific <code>xsl:result-document</code> instruction) by setting
1062
    ///                the attribute <code>saxon:asynchronous="no"</code> in the stylesheet. Suppressing
1063
    ///                multithreading may be desirable in a stylesheet that calls extension functions with
1064
    ///                side-effects.</para>
1065
    ///        
1066
    /// </remarks>
1067

    
1068
    public const String RESULT_DOCUMENT_THREADS = 
1069
        "http://saxon.sf.net/feature/resultDocumentThreads";
1070

    
1071
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1072

    
1073

    
1074
    /// <summary><para>If set to true, indicates that when input is obtained from a SAX parser, the
1075
    ///                DTD-based attribute type notified by the XML parser should be used to set the type
1076
    ///                annotation of the resulting node: for example a DTD type of NMTOKENS results in a
1077
    ///                type annotation of xs:NMTOKENS. </para>
1078
    /// </summary>
1079
    /// <remarks>
1080
    ///            <para>This option is retained for backwards compatibility (at some time in the past, it was
1081
    ///                the default), but is deprecated.</para>
1082
    ///        
1083
    /// </remarks>
1084

    
1085
    public const String RETAIN_DTD_ATTRIBUTE_TYPES = 
1086
        "http://saxon.sf.net/feature/retain-dtd-attribute-types";
1087

    
1088
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1089

    
1090

    
1091
    /// <summary><para>The supplied <code>SchemaURIResolver</code> will be used to resolve URIs of schema
1092
    ///                documents referenced in <code>xsl:import-schema</code> declarations in XSLT,
1093
    ///                    <code>import schema</code> in XQuery, references from one schema document to
1094
    ///                another using <code>xs:include</code> or <code>xs:import</code>, and references from
1095
    ///                an instance document to a schema using <code>xsi:schemaLocation</code>.</para>
1096
    /// </summary>
1097

    
1098
    public const String SCHEMA_URI_RESOLVER = 
1099
        "http://saxon.sf.net/feature/schemaURIResolver";
1100

    
1101
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1102

    
1103

    
1104
    /// <summary><para>The name of a class that implements the interface <code>SchemaURIResolver</code>;
1105
    ///                this class will be instantiated and the resulting instance will be used as the value
1106
    ///                of the <see cref="SCHEMA_URI_RESOLVER" /> property.</para>
1107
    /// </summary>
1108

    
1109
    public const String SCHEMA_URI_RESOLVER_CLASS = 
1110
        "http://saxon.sf.net/feature/schemaURIResolverClass";
1111

    
1112
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1113

    
1114

    
1115
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1116
    ///                documents.</para>
1117
    /// </summary>
1118

    
1119
    public const String SCHEMA_VALIDATION = 
1120
        "http://saxon.sf.net/feature/schema-validation";
1121

    
1122
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1123

    
1124

    
1125
    /// <summary><para>Indicates whether and how schema validation should be applied to source
1126
    ///                documents.</para>
1127
    /// </summary>
1128

    
1129
    public const String SCHEMA_VALIDATION_MODE = 
1130
        "http://saxon.sf.net/feature/schema-validation-mode";
1131

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

    
1134

    
1135
    /// <summary><para>The class will be instantiated and the resulting <code>SerializerFactory</code> will
1136
    ///                be used to create the serialization pipeline for XSLT and XQuery results.</para>
1137
    /// </summary>
1138
    /// <remarks>
1139
    ///            <para>By subclassing the standard <code>SerializerFactory</code> it is possible to customize
1140
    ///                many aspects of the output produced by the Serializer, or to introduce new
1141
    ///                serialization methods and parameters.</para>
1142
    ///        
1143
    /// </remarks>
1144

    
1145
    public const String SERIALIZER_FACTORY_CLASS = 
1146
        "http://saxon.sf.net/feature/serializerFactoryClass";
1147

    
1148
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1149

    
1150

    
1151
    /// <summary><para>XML parser used for source documents.</para>
1152
    /// </summary>
1153
    /// <remarks>
1154
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1155
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1156
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1157
    ///                parse source documents (that is, the principal source document plus any secondary
1158
    ///                source documents read using the <code>doc()</code>, <code>document()</code>, or
1159
    ///                    <code>collection()</code> function).</para>
1160
    ///            <para>Note that the selected parser is used only when the input is supplied in the form of
1161
    ///                a <code>StreamSource</code>; it is ignored when a <code>SAXSource</code> with a
1162
    ///                pre-initialized <code>XMLReader</code> is supplied. A consequence is that this
1163
    ///                configuration option has no effect when running transformations from an Ant script,
1164
    ///                since the Ant <code>xslt</code> task always supplies the input in the form of a
1165
    ///                    <code>SAXSource</code>.</para>
1166
    ///        
1167
    /// </remarks>
1168

    
1169
    public const String SOURCE_PARSER_CLASS = 
1170
        "http://saxon.sf.net/feature/sourceParserClass";
1171

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

    
1174

    
1175
    /// <summary><para>On interfaces that allow an <code>org.xml.sax.Source</code> to be supplied, if a kind
1176
    ///                of <code>Source</code> is provided that Saxon does not recognize, it will be passed
1177
    ///                to the user-supplied <code>SourceResolver</code>, which has the opportunity to
1178
    ///                convert it to a kind of <code>Source</code> that Saxon does recognize. This allows
1179
    ///                new kinds of input to be supplied as input to Saxon's query, transformation, and
1180
    ///                validation engines.</para>
1181
    /// </summary>
1182

    
1183
    public const String SOURCE_RESOLVER_CLASS = 
1184
        "http://saxon.sf.net/feature/sourceResolverClass";
1185

    
1186
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1187

    
1188

    
1189
    /// <summary><para><code>STABLE_COLLECTION_URI</code>, if set, indicates that collections returned by
1190
    ///                the <code>fn:collection()</code> and <code>fn:uri-collection()</code> functions
1191
    ///                should be <i>stable</i>, that is, repeated calls on these functions with the same
1192
    ///                collection URI (within the scope of a single query or transformation) should return
1193
    ///                identical results.</para>
1194
    /// </summary>
1195
    /// <remarks>
1196
    ///            <para>Setting this option may be expensive because it requires that the entire collection
1197
    ///                be saved in memory; it is rarely necessary in practice, but is required for strict
1198
    ///                conformance with the W3C specifications.</para>
1199
    ///            <para>It is also possible to indicate that a collection is stable by means of the
1200
    ///                    <code>CollectionFinder</code> API.</para>
1201
    ///        
1202
    /// </remarks>
1203

    
1204
    public const String STABLE_COLLECTION_URI = 
1205
        "http://saxon.sf.net/feature/stableCollectionUri";
1206

    
1207
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1208

    
1209

    
1210
    /// <summary><para><code>STABLE_UNPARSED_TEXT</code>, if set, indicates that the results returned by
1211
    ///                repeated calls of <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>,
1212
    ///                and <code>unparsed-text-available()</code> are consistent: calling these functions
1213
    ///                twice during the evaluation of a stylesheet or query will return the same
1214
    ///                results.</para>
1215
    /// </summary>
1216
    /// <remarks>
1217
    ///            <para>Setting this option may be expensive because it requires that the file contents be
1218
    ///                saved in memory; it is rarely necessary in practice, but is required for strict
1219
    ///                conformance with the W3C specifications.</para>
1220
    ///        
1221
    /// </remarks>
1222

    
1223
    public const String STABLE_UNPARSED_TEXT = 
1224
        "http://saxon.sf.net/feature/stableUnparsedText";
1225

    
1226
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1227

    
1228

    
1229
    /// <summary><para><code>STANDARD_ERROR_OUTPUT_FILE</code> is the name of a file to which Saxon will
1230
    ///                redirect output that would otherwise go to the operating system standard error
1231
    ///                stream (System.err). This is the fallback destination for various tracing and
1232
    ///                diagnostic output. In some cases a more specific mechanism exists to select the
1233
    ///                destination for particular kinds of output.</para>
1234
    /// </summary>
1235
    /// <remarks>
1236
    ///            <para>Note that if the <code>Configuration</code> is used in more than one processing
1237
    ///                thread, the messages from different threads will be interleaved in the output file.
1238
    ///                A more selective approach is to use a different <code>ErrorListener</code> in
1239
    ///                different processing threads, and arrange for each <code>ErrorListener</code> to
1240
    ///                write to its own logging destination.</para>
1241
    ///        
1242
    /// </remarks>
1243

    
1244
    public const String STANDARD_ERROR_OUTPUT_FILE = 
1245
        "http://saxon.sf.net/feature/standardErrorOutputFile";
1246

    
1247
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1248

    
1249

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

    
1273
    public const String STREAMABILITY = 
1274
        "http://saxon.sf.net/feature/streamability";
1275

    
1276
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1277

    
1278

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

    
1300
    public const String STRICT_STREAMABILITY = 
1301
        "http://saxon.sf.net/feature/strictStreamability";
1302

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

    
1305

    
1306
    /// <summary><para>If the <code>STREAMING_FALLBACK</code> option is set, then constructs for which
1307
    ///                streaming is requested (such as templates in a streaming mode, the
1308
    ///                    <code>xsl:source-document</code> instruction with attribute
1309
    ///                    <code>streamable="yes"</code>, and streamable accumulators) will be executed in
1310
    ///                non-streaming mode if the code is not actually streamable. A compile-time warning
1311
    ///                will always be given when the fallback option is taken.</para>
1312
    /// </summary>
1313

    
1314
    public const String STREAMING_FALLBACK = 
1315
        "http://saxon.sf.net/feature/streamingFallback";
1316

    
1317
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1318

    
1319

    
1320
    /// <summary><para>Indicates whether all whitespace, no whitespace, or whitespace in elements defined in
1321
    ///                a DTD or schema as having element-only content should be stripped from source
1322
    ///                documents.</para>
1323
    /// </summary>
1324
    /// <remarks>
1325
    ///            <para>The default is "ignorable". This whitespace stripping is additional to
1326
    ///                any stripping done as a result of the <code>xsl:strip-space</code> declaration in an
1327
    ///                XSLT stylesheet.</para>
1328
    ///        
1329
    /// </remarks>
1330

    
1331
    public const String STRIP_WHITESPACE = 
1332
        "http://saxon.sf.net/feature/strip-whitespace";
1333

    
1334
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1335

    
1336

    
1337
    /// <summary><para>XML parser used for stylesheets and schema documents.</para>
1338
    /// </summary>
1339
    /// <remarks>
1340
    ///            <para>The class will be instantiated. If it is an <code>XMLReader</code> it is used
1341
    ///                directly; if it is a <code>SAXParserFactory</code> it is used to instantiate an
1342
    ///                    <code>XMLReader</code>. The resulting <code>XMLReader</code> will be used to
1343
    ///                parse stylesheet documents (that is, the principal stylesheet module plus any
1344
    ///                secondary source documents read using <code>xsl:include</code> or
1345
    ///                    <code>xsl:import</code>) and also schema documents.</para>
1346
    ///        
1347
    /// </remarks>
1348

    
1349
    public const String STYLE_PARSER_CLASS = 
1350
        "http://saxon.sf.net/feature/styleParserClass";
1351

    
1352
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1353

    
1354

    
1355
    /// <summary><para>This is set to true to suppress the warning otherwise issued by command-line
1356
    ///                interfaces indicating that an evaluation license is in use and is due to expire in a
1357
    ///                set number of days.</para>
1358
    /// </summary>
1359

    
1360
    public const String SUPPRESS_EVALUATION_EXPIRY_WARNING = 
1361
        "http://saxon.sf.net/feature/suppressEvaluationExpiryWarning";
1362

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

    
1365

    
1366
    /// <summary><para>Suppresses all warnings issued by the XPath and XQuery parsers.</para>
1367
    /// </summary>
1368
    /// <remarks>
1369
    ///            <para>Examples of warnings that are suppressed are the warning produced when keywords such
1370
    ///                as <code>true</code> and <code>return</code> are interpreted as element names.</para>
1371
    ///        
1372
    /// </remarks>
1373

    
1374
    public const String SUPPRESS_XPATH_WARNINGS = 
1375
        "http://saxon.sf.net/feature/suppressXPathWarnings";
1376

    
1377
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1378

    
1379

    
1380
    /// <summary><para>This is set to true to suppress the warning when there is no commonality between the
1381
    ///                namespaces used in stylesheet match patterns and the namespaces used in the source
1382
    ///                document.</para>
1383
    /// </summary>
1384

    
1385
    public const String SUPPRESS_XSLT_NAMESPACE_CHECK = 
1386
        "http://saxon.sf.net/feature/suppressXsltNamespaceCheck";
1387

    
1388
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1389

    
1390

    
1391
    /// <summary><para>Indicates how often an XSD simple type definition must be used before Saxon generates
1392
    ///                bytecode to implement validation of input data against that type.</para>
1393
    /// </summary>
1394
    /// <remarks>
1395
    ///            <para>By default, Saxon-EE generates Java bytecode to speed up the validation of input
1396
    ///                strings against user-defined simple types after the type has been used 100 times
1397
    ///                (during the life of a Saxon Configuration). This threshold may be changed using this
1398
    ///                configuration option. It may be useful to raise the threshold if the number of
1399
    ///                user-defined types is large, and the bytecode is creating memory pressure.</para>
1400
    ///        
1401
    /// </remarks>
1402

    
1403
    public const String THRESHOLD_FOR_COMPILING_TYPES = 
1404
        "http://saxon.sf.net/feature/thresholdForCompilingTypes";
1405

    
1406
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1407

    
1408

    
1409
    /// <summary><para>This is set to true to cause basic timing and tracing information to be output to the
1410
    ///                standard error output stream.</para>
1411
    /// </summary>
1412
    /// <remarks>
1413
    ///            <para>The name of the feature is poorly chosen, since much
1414
    ///                of the information that is output has nothing to do with timing, for example the
1415
    ///                names of output files for <code>xsl:result-document</code> are traced, as are the
1416
    ///                names of schema documents loaded.</para>
1417
    ///        
1418
    /// </remarks>
1419

    
1420
    public const String TIMING = 
1421
        "http://saxon.sf.net/feature/timing";
1422

    
1423
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1424

    
1425

    
1426
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) progress
1427
    ///                information about its attempts to locate and disambiguate references to reflexive
1428
    ///                Java extension functions. This is useful for diagnostics if the XQuery or XSLT
1429
    ///                compiler is failing to locate user-written extension functions.</para>
1430
    /// </summary>
1431

    
1432
    public const String TRACE_EXTERNAL_FUNCTIONS = 
1433
        "http://saxon.sf.net/feature/trace-external-functions";
1434

    
1435
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1436

    
1437

    
1438
    /// <summary><para>The <code>TraceListener</code> will be notified of significant events occurring
1439
    ///                during a query or transformation, for tracing or debugging purposes.</para>
1440
    /// </summary>
1441
    /// <remarks>
1442
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1443
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1444
    ///            <para>Avoid this option if more than one transformation or query is running concurrently:
1445
    ///                use the feature <see cref="TRACE_LISTENER_CLASS" />
1446
    ///                instead. Alternatively, it is possible to set a <code>TraceListener</code> for an
1447
    ///                individual query or transformation.</para>
1448
    ///        
1449
    /// </remarks>
1450

    
1451
    public const String TRACE_LISTENER = 
1452
        "http://saxon.sf.net/feature/traceListener";
1453

    
1454
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1455

    
1456

    
1457
    /// <summary><para>The class will be instantiated once for each query or transformation, and the
1458
    ///                resulting <code>TraceListener</code> will be notified of significant events
1459
    ///                occurring during that query or transformation, for tracing or debugging
1460
    ///                purposes.</para>
1461
    /// </summary>
1462
    /// <remarks>
1463
    ///            <para>Setting a <code>TraceListener</code> automatically sets the
1464
    ///                    <see cref="COMPILE_WITH_TRACING" /> option.</para>
1465
    ///        
1466
    /// </remarks>
1467

    
1468
    public const String TRACE_LISTENER_CLASS = 
1469
        "http://saxon.sf.net/feature/traceListenerClass";
1470

    
1471
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1472

    
1473

    
1474
    /// <summary><para>When trace listening is switched on (for example by using -T on the command line),
1475
    ///                this file will be supplied to the trace listener to use as the output destination.
1476
    ///                If the option is not supplied, trace listener output is sent to the standard error
1477
    ///                stream.</para>
1478
    /// </summary>
1479

    
1480
    public const String TRACE_LISTENER_OUTPUT_FILE = 
1481
        "http://saxon.sf.net/feature/traceListenerOutputFile";
1482

    
1483
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1484

    
1485

    
1486
    /// <summary><para>If this option is set, Saxon will output (to the standard error output) detailed
1487
    ///                information about the rewrites to the expression tree made by the optimizer. This
1488
    ///                information is mainly useful for internal system debugging, but it is also possible
1489
    ///                to digest it to analyze the ways in which the expression has been optimized for the
1490
    ///                purpose of performance analysis and tuning.</para>
1491
    /// </summary>
1492

    
1493
    public const String TRACE_OPTIMIZER_DECISIONS = 
1494
        "http://saxon.sf.net/feature/trace-optimizer-decisions";
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>TINY_TREE</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 = 
1509
        "http://saxon.sf.net/feature/treeModel";
1510

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

    
1513

    
1514
    /// <summary><para>Selects an implementation of the Saxon tree model. The default is
1515
    ///                    <code>tinyTree</code>.</para>
1516
    /// </summary>
1517
    /// <remarks>
1518
    ///            <para>For running XQuery Update, use the linked tree, because it is the only implementation
1519
    ///                that is updateable.</para>
1520
    ///        
1521
    /// </remarks>
1522

    
1523
    public const String TREE_MODEL_NAME = 
1524
        "http://saxon.sf.net/feature/treeModelName";
1525

    
1526
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1527

    
1528

    
1529
    /// <summary><para>The supplied <code>UnparsedTextURIResolver</code> will be used to resolve
1530
    ///                (dereference) all URIs specifed in calls to the <code>unparsed-text()</code>,
1531
    ///                    <code>unparsed-text-lines()</code>, and <code>unparsed-text-available()</code>
1532
    ///                functions.</para>
1533
    /// </summary>
1534

    
1535
    public const String UNPARSED_TEXT_URI_RESOLVER = 
1536
        "http://saxon.sf.net/feature/unparsedTextURIResolver";
1537

    
1538
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1539

    
1540

    
1541
    /// <summary><para>An instance of the specified <code>UnparsedTextURIResolver</code> class will be
1542
    ///                created, and used to resolve (dereference) all URIs specifed in calls to the
1543
    ///                    <code>unparsed-text()</code>, <code>unparsed-text-lines()</code>, and
1544
    ///                    <code>unparsed-text-available()</code> functions.</para>
1545
    /// </summary>
1546

    
1547
    public const String UNPARSED_TEXT_URI_RESOLVER_CLASS = 
1548
        "http://saxon.sf.net/feature/unparsedTextURIResolverClass";
1549

    
1550
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1551

    
1552

    
1553
    /// <summary><para>An instance of the specified <code>URIResolver</code> class will be created, and used
1554
    ///                to resolve (dereference) all URIs specifed in calls to the <code>doc()</code> and
1555
    ///                    <code>document()</code> functions, as well as URIs used in
1556
    ///                    <code>xsl:include</code> and <code>xsl:import</code> and location hints for
1557
    ///                XQuery modules and XSD schema documents.</para>
1558
    /// </summary>
1559

    
1560
    public const String URI_RESOLVER_CLASS = 
1561
        "http://saxon.sf.net/feature/uriResolverClass";
1562

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

    
1565

    
1566
    /// <summary><para>This option determines whether a <code>TransformerHandler</code> created with this
1567
    ///                    <code>TransformerFactory</code> or <code>Configuration</code> recognizes the
1568
    ///                JAXP-defined processing instructions <code>Result.PI_DISABLE_OUTPUT_ESCAPING</code>
1569
    ///                and <code>Result.PI_ENABLE_OUTPUT_ESCAPING</code> in the input stream as
1570
    ///                instructions to disable or to re-enable output escaping. The default value is
1571
    ///                    <b>false</b>.</para>
1572
    /// </summary>
1573

    
1574
    public const String USE_PI_DISABLE_OUTPUT_ESCAPING = 
1575
        "http://saxon.sf.net/feature/use-pi-disable-output-escaping";
1576

    
1577
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1578

    
1579

    
1580
    /// <summary><para>This option is relevant only when the TinyTree is used; it determines whether (for a
1581
    ///                validated document) a cache will be maintained containing the typed values of nodes.</para>
1582
    /// </summary>
1583
    /// <remarks>
1584
    ///            <para>Typed values are held in the cache only for elements and attributes whose type is
1585
    ///                other than string, untypedAtomic, or anyURI. The default value is true. Setting this
1586
    ///                value to false can reduce memory requirements at the cost of requiring recomputation
1587
    ///                of typed values on each access.</para>
1588
    ///        
1589
    /// </remarks>
1590

    
1591
    public const String USE_TYPED_VALUE_CACHE = 
1592
        "http://saxon.sf.net/feature/use-typed-value-cache";
1593

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

    
1596

    
1597
    /// <summary><para>This option determines whether or not to use the <code>xsi:schemaLocation</code>
1598
    ///                    and<code> xsi:noNamespaceSchemaLocation</code> attributes in an instance
1599
    ///                document to locate a schema for validation.</para>
1600
    /// </summary>
1601
    /// <remarks>
1602
    ///            <para>Note, these attribute are only consulted if validation is requested; the presence of
1603
    ///                one of these attributes never by itself triggers validation.</para>
1604
    ///        
1605
    /// </remarks>
1606

    
1607
    public const String USE_XSI_SCHEMA_LOCATION = 
1608
        "http://saxon.sf.net/feature/useXsiSchemaLocation";
1609

    
1610
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1611

    
1612

    
1613
    /// <summary><para>This option determines whether non-fatal validation errors in XQuery or XSLT result
1614
    ///                documents should result in comments being inserted into the result tree. The
1615
    ///                command-line flag <code>-outval:recover</code> sets both this option and the
1616
    ///                    <see cref="VALIDATION_WARNINGS" /> option.</para>
1617
    /// </summary>
1618

    
1619
    public const String VALIDATION_COMMENTS = 
1620
        "http://saxon.sf.net/feature/validation-comments";
1621

    
1622
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1623

    
1624

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

    
1648
    public const String VALIDATION_WARNINGS = 
1649
        "http://saxon.sf.net/feature/validation-warnings";
1650

    
1651
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1652

    
1653

    
1654
    /// <summary><para>Indicates whether a warning message should be notified (to the
1655
    ///                <code>ErrorListener</code>) if running Saxon against an XSLT stylesheet that
1656
    ///                specifies <code>version="1.0"</code>.</para>
1657
    /// </summary>
1658
    /// <remarks>
1659
    ///            <para>From Saxon 9.8, the warning is no longer output (since XSLT 3.0 does not require
1660
    ///                it), so this option is ignored.</para>
1661
    ///            
1662
    ///        
1663
    /// </remarks>
1664

    
1665
    public const String VERSION_WARNING = 
1666
        "http://saxon.sf.net/feature/version-warning";
1667

    
1668
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1669

    
1670

    
1671
    /// <summary><para>Indicates whether source documents should have any XInclude directives expanded.</para>
1672
    /// </summary>
1673
    /// <remarks>
1674
    ///            <para>The default is false. The option applies to all input XML documents, including
1675
    ///                stylesheets and schema documents. It can be overridden for individual documents
1676
    ///                using the <see cref="net.sf.saxon.lib.ParseOptions" /> class.</para>
1677
    ///            <para>This option relies on support in the underlying XML parser. If the XML parser does
1678
    ///                not support XInclude processing, the option is ignored.</para>
1679
    ///        
1680
    /// </remarks>
1681

    
1682
    public const String XINCLUDE = 
1683
        "http://saxon.sf.net/feature/xinclude-aware";
1684

    
1685
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1686

    
1687

    
1688
    /// <summary><para>This determines the XML version used by the <code>Configuration</code>.</para>
1689
    /// </summary>
1690
    /// <remarks>
1691
    ///            <para>Note that source documents specifying <code>xml version="1.0"</code> or
1692
    ///                    <code>"1.1"</code> are accepted regardless of this setting. The effect of this
1693
    ///                switch is to change the validation rules for types such as <code>xs:Name</code> and
1694
    ///                    <code>xs:NCName</code>, to change the characters allowed in names within XPath
1695
    ///                expressions (etc.), to change the meaning of <code>\i</code> and <code>\c</code> in
1696
    ///                regular expressions, and to determine whether the serializer allows XML 1.1
1697
    ///                documents to be constructed. </para>
1698
    ///            <para>The default is currently 1.0, but may change.</para>
1699
    ///        
1700
    /// </remarks>
1701

    
1702
    public const String XML_VERSION = 
1703
        "http://saxon.sf.net/feature/xml-version";
1704

    
1705
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1706

    
1707

    
1708
    /// <summary><para>Sets the value of a parser feature flag. The feature name is any fully-qualified
1709
    ///                URI.</para>
1710
    /// </summary>
1711
    /// <remarks>
1712
    ///            <para>For example if the parser supports a feature
1713
    ///                    <code>http://xml.org/sax/features/external-parameter-entities</code> then this
1714
    ///                can be set by setting the value of the Configuration property:
1715
    ///                    <code>http://saxon.sf.net/feature/parserFeature?uri=http%3A//xml.org/sax/features/external-parameter-entities</code>
1716
    ///                to true.</para>
1717
    ///        
1718
    /// </remarks>
1719

    
1720
    public const String XML_PARSER_FEATURE = 
1721
        "http://saxon.sf.net/feature/parserFeature?uri=";
1722

    
1723
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1724

    
1725

    
1726
    /// <summary><para>Sets the value of a parser property flag. The property name is any fully-qualified
1727
    ///                URI.</para>
1728
    /// </summary>
1729
    /// <remarks>
1730
    ///            <para>For example if the parser supports a property
1731
    ///                    <code>http://apache.org/xml/properties/schema/external-schemaLocation</code>
1732
    ///                then this can be set using the value of the Configuration property:
1733
    ///                    <code>http://saxon.sf.net/feature/parserProperty?uri=http%3A//apache.org/xml/properties/schema/external-schemaLocation</code>
1734
    ///                to the required value.</para>
1735
    ///        
1736
    /// </remarks>
1737

    
1738
    public const String XML_PARSER_PROPERTY = 
1739
        "http://saxon.sf.net/feature/parserProperty?uri=";
1740

    
1741
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1742

    
1743

    
1744
    /// <summary><para>Determines whether XQuery Update syntax is accepted.</para>
1745
    /// </summary>
1746
    /// <remarks>
1747
    ///            <para>If true, update syntax is accepted, if false, it is not accepted. Setting the value to 
1748
    ///                true does not mean that the query has to use update syntax, only that it may do so.</para>
1749
    ///            <para>From Saxon 9.6, XQuery Update syntax and XQuery 3.0 syntax can be mixed, although
1750
    ///                this combination is not defined by any W3C specification at the time of writing.</para>
1751
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1752
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1753
    ///            <para>On the command line, this option is combined with the option "discard" which
1754
    ///                indicates that updates are allowed, but the updates are not written back to
1755
    ///                filestore. This does not correspond to any option in the Java API, where writing an
1756
    ///                updated document back to filestore only happens if explicitly requested.</para>
1757
    ///        
1758
    /// </remarks>
1759

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

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

    
1765

    
1766
    /// <summary><para>This option defines the default value of the construction mode in the XQuery static
1767
    ///                context (overridable in the query prolog).</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_CONSTRUCTION_MODE = 
1776
        "http://saxon.sf.net/feature/xqueryConstructionMode";
1777

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

    
1780

    
1781
    /// <summary><para>This property defines the default namespace for elements and types that are not
1782
    ///                qualified 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_ELEMENT_NAMESPACE = 
1791
        "http://saxon.sf.net/feature/xqueryDefaultElementNamespace";
1792

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

    
1795

    
1796
    /// <summary><para>This property defines the default namespace for function names that are not qualified
1797
    ///                by a namespace prefix.</para>
1798
    /// </summary>
1799
    /// <remarks>
1800
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1801
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1802
    ///        
1803
    /// </remarks>
1804

    
1805
    public const String XQUERY_DEFAULT_FUNCTION_NAMESPACE = 
1806
        "http://saxon.sf.net/feature/xqueryDefaultFunctionNamespace";
1807

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

    
1810

    
1811
    /// <summary><para>This property defines how the empty sequence is handled in XQuery sorting (the "order
1812
    ///                by" clause). If true, <code>()</code> comes at the start of the sorted sequence; if
1813
    ///                false, it comes last.</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_EMPTY_LEAST = 
1822
        "http://saxon.sf.net/feature/xqueryEmptyLeast";
1823

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

    
1826

    
1827
    /// <summary><para>This property defines the default value of the <code>inherit-namespaces</code>
1828
    ///                property in the XQuery static context.</para>
1829
    /// </summary>
1830
    /// <remarks>
1831
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1832
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1833
    ///        
1834
    /// </remarks>
1835

    
1836
    public const String XQUERY_INHERIT_NAMESPACES = 
1837
        "http://saxon.sf.net/feature/xqueryInheritNamespaces";
1838

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

    
1841

    
1842
    /// <summary><para>If the value is false, then when an <code>import module</code> declaration is
1843
    ///                encountered for a module URI that is already among the known loaded modules (or
1844
    ///                modules in the process of being compiled), the <code>import module</code> is treated
1845
    ///                as a reference to the existing module. If the value is true, the system first checks
1846
    ///                whether the supplied "location hints" match the known location of the existing
1847
    ///                module, and the existing module is used only if there is a match.</para>
1848
    /// </summary>
1849

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

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

    
1855

    
1856
    /// <summary><para>This property defines whether "boundary space" (insignificant space in direct element
1857
    ///                constructors) should be retained or not.</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_BOUNDARY_SPACE = 
1866
        "http://saxon.sf.net/feature/xqueryPreserveBoundarySpace";
1867

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

    
1870

    
1871
    /// <summary><para>This property defines whether unused namespace declarations are retained by XQuery
1872
    ///                element copy operations.</para>
1873
    /// </summary>
1874
    /// <remarks>
1875
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1876
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1877
    ///        
1878
    /// </remarks>
1879

    
1880
    public const String XQUERY_PRESERVE_NAMESPACES = 
1881
        "http://saxon.sf.net/feature/xqueryPreserveNamespaces";
1882

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

    
1885

    
1886
    /// <summary><para>This property defines the default expected context item type for a query.</para>
1887
    /// </summary>
1888
    /// <remarks>
1889
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1890
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1891
    ///        
1892
    /// </remarks>
1893

    
1894
    public const String XQUERY_REQUIRED_CONTEXT_ITEM_TYPE = 
1895
        "http://saxon.sf.net/feature/xqueryRequiredContextItemType";
1896

    
1897
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1898

    
1899

    
1900
    /// <summary><para>A query will automatically be schema-aware if it contains an <code>import
1901
    ///                    schema</code> declaration. This property allows a query to be marked as
1902
    ///                schema-aware even if it contains no <code>import schema</code> declaration. It is
1903
    ///                necessary for a query to be compiled as schema-aware if it is to handle typed
1904
    ///                (validated) input documents in which nodes have type annotations based on their
1905
    ///                schema-defined type.</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
    ///        
1911
    /// </remarks>
1912

    
1913
    public const String XQUERY_SCHEMA_AWARE = 
1914
        "http://saxon.sf.net/feature/xquerySchemaAware";
1915

    
1916
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1917

    
1918

    
1919
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
1920
    ///                reports of static errors in a query will go to this <code>ErrorListener</code>.</para>
1921
    /// </summary>
1922
    /// <remarks>
1923
    ///            <para>This option can be set for a particular XQuery compilation. When the option is set at
1924
    ///                the <code>Configuration</code> level, it acts as a default.</para>
1925
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
1926
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
1927
    ///                property is used.</para>
1928
    ///        
1929
    /// </remarks>
1930

    
1931
    public const String XQUERY_STATIC_ERROR_LISTENER_CLASS = 
1932
        "http://saxon.sf.net/feature/xqueryStaticErrorListenerClass";
1933

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

    
1936

    
1937
    /// <summary><para>This property determines the version of XQuery used by the
1938
    ///                <code>Configuration</code>.</para>
1939
    /// </summary>
1940
    /// <remarks>
1941
    ///            <para>From Saxon 9.8, an XQuery 3.1 processor is always used by default. So setting this
1942
    ///                property has no effect.</para>
1943
    ///            
1944
    ///        
1945
    /// </remarks>
1946

    
1947
    public const String XQUERY_VERSION = 
1948
        "http://saxon.sf.net/feature/xqueryVersion";
1949

    
1950
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1951

    
1952

    
1953
    /// <summary><para>This property determines the version of XML Schema used by the
1954
    ///                <code>Configuration</code>.</para>
1955
    /// </summary>
1956
    /// <remarks>
1957
    ///            <para>From Saxon 9.8, the default is XSD 1.1. If XSD 1.0 is
1958
    ///                selected, XSD 1.1 features will be rejected, with the exception of the version
1959
    ///                control attributes that allow sections of the schema to be marked as requiring XSD
1960
    ///                1.0 or XSD 1.1.</para>
1961
    ///        
1962
    /// </remarks>
1963

    
1964
    public const String XSD_VERSION = 
1965
        "http://saxon.sf.net/feature/xsd-version";
1966

    
1967
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
1968

    
1969

    
1970
    /// <summary><para>This property indicates whether assertions (XSLT 3.0 xsl:assert instructions) are
1971
    ///                enabled or disabled. They are disabled by default. Setting this property on causes
1972
    ///                assertions to be enabled at compile time for all XSLT packages compiled using the
1973
    ///                default configuration options.</para>
1974
    /// </summary>
1975
    /// <remarks>
1976
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
1977
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
1978
    ///                acts as a default.</para>
1979
    ///            <para>If assertions have been enabled at compile time for a particular package, they can
1980
    ///                still be disabled at run-time (for all packages) by setting an option on the
1981
    ///                    <code>Xslt30Transformer</code>. But if assertions were disabled at compile time,
1982
    ///                enabling them at run-time has no effect.</para>
1983
    ///        
1984
    /// </remarks>
1985

    
1986
    public const String XSLT_ENABLE_ASSERTIONS = 
1987
        "http://saxon.sf.net/feature/enableAssertions";
1988

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

    
1991

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

    
2002
    public const String XSLT_INITIAL_MODE = 
2003
        "http://saxon.sf.net/feature/initialMode";
2004

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

    
2007

    
2008
    /// <summary><para>This property indicates the name of a named template within a stylesheet where
2009
    ///                execution should begin.</para>
2010
    /// </summary>
2011
    /// <remarks>
2012
    ///            <para>This option can be set for a particular XSLT transformation. When the option is set
2013
    ///                at the <code>Configuration</code> level (or on a <code>TransformerFactory</code>),
2014
    ///                it acts as a default.</para>
2015
    ///        
2016
    /// </remarks>
2017

    
2018
    public const String XSLT_INITIAL_TEMPLATE = 
2019
        "http://saxon.sf.net/feature/initialTemplate";
2020

    
2021
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2022

    
2023

    
2024
    /// <summary><para>This property indicates whether stylesheets should be compiled with the ability to
2025
    ///                handle schema-typed input documents. By default a stylesheet is compiled to handle
2026
    ///                such input if it contains an <code>xsl:import-schema</code> instruction, and not
2027
    ///                otherwise. It is necessary for a stylesheet to be compiled as schema-aware if it is
2028
    ///                to handle typed (validated) input documents in which nodes have type annotations
2029
    ///                based on their schema-defined type.</para>
2030
    /// </summary>
2031
    /// <remarks>
2032
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2033
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2034
    ///                acts as a default.</para>
2035
    ///        
2036
    /// </remarks>
2037

    
2038
    public const String XSLT_SCHEMA_AWARE = 
2039
        "http://saxon.sf.net/feature/xsltSchemaAware";
2040

    
2041
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2042

    
2043

    
2044
    /// <summary><para>The specified class is instantiated to create an <code>ErrorListener</code>, and all
2045
    ///                reports of static errors in a stylesheet will go to this
2046
    ///                <code>ErrorListener</code>.</para>
2047
    /// </summary>
2048
    /// <remarks>
2049
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2050
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2051
    ///                acts as a default.</para>
2052
    ///            <para>In the absence of this property, the global <code>ErrorListener</code> specified as
2053
    ///                the value of the <see cref="ERROR_LISTENER_CLASS" />
2054
    ///                property is used.</para>
2055
    ///        
2056
    /// </remarks>
2057

    
2058
    public const String XSLT_STATIC_ERROR_LISTENER_CLASS = 
2059
        "http://saxon.sf.net/feature/stylesheetErrorListener";
2060

    
2061
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2062

    
2063

    
2064
    /// <summary><para>This property defines a <code>URIResolver</code> used when dereferencing the URIs
2065
    ///                that appear in the <code>href</code> attributes of the <code>xsl:include</code> and
2066
    ///                    <code>xsl:import</code> declarations. Note that this defaults to the setting of
2067
    ///                the global <code>URI_RESOLVER</code> property.</para>
2068
    /// </summary>
2069
    /// <remarks>
2070
    ///            <para>This option can be set for a particular XSLT compilation. When the option is set at
2071
    ///                the <code>Configuration</code> level (or on a <code>TransformerFactory</code>), it
2072
    ///                acts as a default.</para>
2073
    ///            <para>In the absence of this property, the global <code>URIResolver</code> specified as the
2074
    ///                value of the <see cref="URI_RESOLVER_CLASS" /> property
2075
    ///                is used.</para>
2076
    ///        
2077
    /// </remarks>
2078

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

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

    
2084

    
2085
    /// <summary><para>This property determines the version of XSLT to be supported by default.</para>
2086
    /// </summary>
2087
    /// <remarks>
2088
    ///            <para>From Saxon 9.8, an XSLT 3.0 processor is always used by default. So setting this
2089
    ///                property has no effect.</para>
2090
    ///            
2091
    ///        
2092
    /// </remarks>
2093

    
2094
    public const String XSLT_VERSION = 
2095
        "http://saxon.sf.net/feature/xsltVersion";
2096

    
2097
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2098

    
2099

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

    
2116
    public const String REGEX_BACKTRACKING_LIMIT = 
2117
        "http://saxon.sf.net/feature/regexBacktrackingLimit";
2118

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

    
2121

    
2122
    /// <summary><para>The XSD 1.1 specification states that XPath version 2.0 is used for expressions appearing in assertions and type
2123
    ///                alternatives. This option allows XPath 3.0 or 3.1 to be used instead.</para>
2124
    /// </summary>
2125
    /// <remarks>
2126
    ///            <para>The recognized values are the integers 20, 30, and 31 representing versions 2.0, 3.0, and 3.1 respectively.</para>           
2127
    ///        
2128
    /// </remarks>
2129

    
2130
    public const String XPATH_VERSION_FOR_XSD = 
2131
        "http://saxon.sf.net/feature/xpathVersionForXsd";
2132

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

    
2135

    
2136
    /// <summary><para>The XSLT 3.0 specification states that processors are required to support XPath 3.0 expressions within stylesheets, together
2137
    ///                with some extensions (maps) selected from the XPath 3.1 specification. Support for the full syntax of XPath 3.1 is
2138
    ///                optional, but it is the default in Saxon. This option allows a different XPath language level to be selected.</para>
2139
    /// </summary>
2140
    /// <remarks>
2141
    ///            <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
2142
    ///                with the extensions defined in the XSLT 3.0 specification.</para>
2143
    ///        
2144
    /// </remarks>
2145

    
2146
    public const String XPATH_VERSION_FOR_XSLT = 
2147
        "http://saxon.sf.net/feature/xpathVersionForXslt";
2148

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

    
2151

    
2152
    /// <summary><para>Saxon-EE performs inlining of user-defined functions that are sufficiently simple: they must not be recursive,
2153
    ///                and they must be below a certain size. This option defines the size.</para>
2154
    /// </summary>
2155
    /// <remarks>
2156
    ///            <para>The value is (roughly) the number of nodes in the expression tree representing the function body. This
2157
    ///                includes both explicit subexpressions, and subexpressions added by Saxon itself to perform implicit
2158
    ///                operations such as type checking or conversion of function arguments. The default value is 100.</para>
2159
    ///        
2160
    /// </remarks>
2161

    
2162
    public const String THRESHOLD_FOR_FUNCTION_INLINING = 
2163
        "http://saxon.sf.net/feature/thresholdForFunctionInlining";
2164

    
2165
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2166

    
2167

    
2168
    /// <summary><para>Saxon-EE generates bytecode to give faster execution of frequently-evaluated subexpressions.
2169
    ///                Bytecode is generated when a candidate expression has been evaluated a certain number of
2170
    ///                times, controlled by this parameter.
2171
    ///            </para>
2172
    /// </summary>
2173
    /// <remarks>
2174
    ///            <para>Setting this parameter to 0 (or any negative value) has the effect of disabling bytecode
2175
    ///                generation completely. Setting the parameter to a positive value has the effect of enabling
2176
    ///                bytecode generation if it is not already enabled. Setting the value to 1 (one) causes bytecode
2177
    ///                to be generated for candidate expressions the first time it is executed.</para>
2178
    ///        
2179
    /// </remarks>
2180

    
2181
    public const String THRESHOLD_FOR_HOTSPOT_BYTE_CODE = 
2182
        "http://saxon.sf.net/feature/thresholdForHotspotByteCode";
2183

    
2184
// AUTO-GENERATED FROM FeatureKeys.xml - DO NOT EDIT THIS FILE
2185

    
2186

    
2187
} 
2188
}
2189

    
2190
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2191
// Copyright (c) 2018 Saxonica Limited.
2192
// This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0.
2193
// If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
2194
// This Source Code Form is "Incompatible With Secondary Licenses", as defined by the Mozilla Public License, v. 2.0.
2195
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
(6-6/13)