← Back to branch summary

~ubuntu-branches/ubuntu/karmic/libxerces2-java/karmic

« back to all changes in this revision

Viewing changes to src/org/apache/xerces/parsers/XML11Configuration.java

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-12-04 17:37:55 UTC
  • mfrom: (2.1.2 etch)
  • Revision ID: james.westby@ubuntu.com-20061204173755-hb6ybrrrk097zhx7
Tags: 2.8.1-1ubuntu1
* Merge with Debian unstable; remaining changes:
  - Build -gcj package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/org/apache/xerces/parsers/XML11Configuration.java
1
1
/*
2
 
 * The Apache Software License, Version 1.1
3
 
 *
4
 
 *
5
 
 * Copyright (c) 2001-2004 The Apache Software Foundation.  
6
 
 * All rights reserved.
7
 
 *
8
 
 * Redistribution and use in source and binary forms, with or without
9
 
 * modification, are permitted provided that the following conditions
10
 
 * are met:
11
 
 *
12
 
 * 1. Redistributions of source code must retain the above copyright
13
 
 *    notice, this list of conditions and the following disclaimer. 
14
 
 *
15
 
 * 2. Redistributions in binary form must reproduce the above copyright
16
 
 *    notice, this list of conditions and the following disclaimer in
17
 
 *    the documentation and/or other materials provided with the
18
 
 *    distribution.
19
 
 *
20
 
 * 3. The end-user documentation included with the redistribution,
21
 
 *    if any, must include the following acknowledgment:  
22
 
 *       "This product includes software developed by the
23
 
 *        Apache Software Foundation (http://www.apache.org/)."
24
 
 *    Alternately, this acknowledgment may appear in the software itself,
25
 
 *    if and wherever such third-party acknowledgments normally appear.
26
 
 *
27
 
 * 4. The names "Xerces" and "Apache Software Foundation" must
28
 
 *    not be used to endorse or promote products derived from this
29
 
 *    software without prior written permission. For written 
30
 
 *    permission, please contact apache@apache.org.
31
 
 *
32
 
 * 5. Products derived from this software may not be called "Apache",
33
 
 *    nor may "Apache" appear in their name, without prior written
34
 
 *    permission of the Apache Software Foundation.
35
 
 *
36
 
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37
 
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38
 
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39
 
 * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40
 
 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41
 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42
 
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43
 
 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44
 
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45
 
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46
 
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47
 
 * SUCH DAMAGE.
48
 
 * ====================================================================
49
 
 *
50
 
 * This software consists of voluntary contributions made by many
51
 
 * individuals on behalf of the Apache Software Foundation and was
52
 
 * originally based on software copyright (c) 2002, International
53
 
 * Business Machines, Inc., http://www.apache.org.  For more
54
 
 * information on the Apache Software Foundation, please see
55
 
 * <http://www.apache.org/>.
 
2
 * Copyright 2001-2006 The Apache Software Foundation.
 
3
 * 
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 * 
 
8
 *      http://www.apache.org/licenses/LICENSE-2.0
 
9
 * 
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
56
15
 */
57
16
 
58
17
package org.apache.xerces.parsers;
59
18
 
60
19
import java.io.IOException;
61
20
import java.util.ArrayList;
62
 
import java.util.Hashtable;
 
21
import java.util.HashMap;
63
22
import java.util.Locale;
64
 
import java.util.Vector;
65
23
 
66
24
import org.apache.xerces.impl.Constants;
67
25
import org.apache.xerces.impl.XML11DTDScannerImpl;
106
64
 
107
65
/**
108
66
 * This class is the configuration used to parse XML 1.0 and XML 1.1 documents.
109
 
 * This is the default Xerces configuration.
110
67
 *
111
68
 * @author Elena Litani, IBM
112
69
 * @author Neil Graham, IBM
113
70
 * @author Michael Glavassevich, IBM
114
71
 *
115
 
 * @version $Id: XML11Configuration.java,v 1.15 2004/02/11 16:57:28 mrglavas Exp $
 
72
 * @version $Id: XML11Configuration.java 371617 2006-01-23 18:41:49Z mrglavas $
116
73
 */
117
74
public class XML11Configuration extends ParserConfigurationSettings
118
 
    implements XMLPullParserConfiguration {
 
75
    implements XMLPullParserConfiguration, XML11Configurable {
119
76
 
120
77
    //
121
78
    // Constants
176
133
    /** feature identifier: XML Schema validation -- full checking */
177
134
    protected static final String XMLSCHEMA_FULL_CHECKING =
178
135
        Constants.XERCES_FEATURE_PREFIX + Constants.SCHEMA_FULL_CHECKING;
 
136
    
 
137
    /** Feature: generate synthetic annotations */
 
138
    protected static final String GENERATE_SYNTHETIC_ANNOTATIONS = 
 
139
        Constants.XERCES_FEATURE_PREFIX + Constants.GENERATE_SYNTHETIC_ANNOTATIONS_FEATURE;
 
140
    
 
141
    /** Feature identifier: validate annotations */
 
142
    protected static final String VALIDATE_ANNOTATIONS =
 
143
        Constants.XERCES_FEATURE_PREFIX + Constants.VALIDATE_ANNOTATIONS_FEATURE;
 
144
    
 
145
    /** Feature identifier: honour all schemaLocations */
 
146
    protected static final String HONOUR_ALL_SCHEMALOCATIONS = 
 
147
        Constants.XERCES_FEATURE_PREFIX + Constants.HONOUR_ALL_SCHEMALOCATIONS_FEATURE;
 
148
    
 
149
    /** Feature identifier: use grammar pool only */
 
150
    protected static final String USE_GRAMMAR_POOL_ONLY =
 
151
        Constants.XERCES_FEATURE_PREFIX + Constants.USE_GRAMMAR_POOL_ONLY_FEATURE;
179
152
        
180
153
        // feature identifiers
181
154
 
195
168
        protected static final String EXTERNAL_PARAMETER_ENTITIES =
196
169
                Constants.SAX_FEATURE_PREFIX + Constants.EXTERNAL_PARAMETER_ENTITIES_FEATURE;
197
170
                
 
171
        /** Feature identifier: whether to ignore xsi:type attributes until a global element declaration is encountered */
 
172
        protected static final String IGNORE_XSI_TYPE =
 
173
            Constants.XERCES_FEATURE_PREFIX + Constants.IGNORE_XSI_TYPE_FEATURE;
 
174
        
 
175
        /** Feature identifier: whether to ignore ID/IDREF errors */
 
176
        protected static final String ID_IDREF_CHECKING =
 
177
            Constants.XERCES_FEATURE_PREFIX + Constants.ID_IDREF_CHECKING_FEATURE;
 
178
        
 
179
        /** Feature identifier: whether to ignore unparsed entity errors */
 
180
        protected static final String UNPARSED_ENTITY_CHECKING =
 
181
            Constants.XERCES_FEATURE_PREFIX + Constants.UNPARSED_ENTITY_CHECKING_FEATURE;
 
182
        
 
183
        /** Feature identifier: whether to ignore identity constraint errors */
 
184
        protected static final String IDENTITY_CONSTRAINT_CHECKING =
 
185
            Constants.XERCES_FEATURE_PREFIX + Constants.IDC_CHECKING_FEATURE;
 
186
 
198
187
    
199
188
 
200
189
    // property identifiers
278
267
    protected static final String JAXP_SCHEMA_SOURCE =
279
268
        Constants.JAXP_PROPERTY_PREFIX + Constants.SCHEMA_SOURCE;
280
269
 
 
270
    /** Property identifier: root type definition. */
 
271
    protected static final String ROOT_TYPE_DEF =
 
272
        Constants.XERCES_PROPERTY_PREFIX + Constants.ROOT_TYPE_DEFINITION_PROPERTY;
 
273
 
281
274
    // debugging
282
275
 
283
276
    /** Set to true and recompile to print exception stack trace. */
462
455
                fRecognizedProperties = new ArrayList();
463
456
 
464
457
                // create table for features and properties
465
 
                fFeatures = new Hashtable();
466
 
                fProperties = new Hashtable();
 
458
                fFeatures = new HashMap();
 
459
                fProperties = new HashMap();
467
460
 
468
461
        // add default recognized features
469
 
        final String[] recognizedFeatures =
470
 
            {   
471
 
                CONTINUE_AFTER_FATAL_ERROR, LOAD_EXTERNAL_DTD, // from XMLDTDScannerImpl
472
 
                                VALIDATION,                 
473
 
                                NAMESPACES,
474
 
                NORMALIZE_DATA, SCHEMA_ELEMENT_DEFAULT, SCHEMA_AUGMENT_PSVI,
475
 
                // NOTE: These shouldn't really be here but since the XML Schema
476
 
                //       validator is constructed dynamically, its recognized
477
 
                //       features might not have been set and it would cause a
478
 
                //       not-recognized exception to be thrown. -Ac
479
 
                XMLSCHEMA_VALIDATION, XMLSCHEMA_FULL_CHECKING,                  
480
 
                                EXTERNAL_GENERAL_ENTITIES,  
481
 
                                EXTERNAL_PARAMETER_ENTITIES,
482
 
                                PARSER_SETTINGS
483
 
                        };
 
462
                final String[] recognizedFeatures =
 
463
                {   
 
464
                        CONTINUE_AFTER_FATAL_ERROR, LOAD_EXTERNAL_DTD, // from XMLDTDScannerImpl
 
465
                        VALIDATION,                 
 
466
                        NAMESPACES,
 
467
                        NORMALIZE_DATA, SCHEMA_ELEMENT_DEFAULT, SCHEMA_AUGMENT_PSVI,
 
468
                        GENERATE_SYNTHETIC_ANNOTATIONS, VALIDATE_ANNOTATIONS,
 
469
                        HONOUR_ALL_SCHEMALOCATIONS, IGNORE_XSI_TYPE,
 
470
                        ID_IDREF_CHECKING, IDENTITY_CONSTRAINT_CHECKING,
 
471
                        UNPARSED_ENTITY_CHECKING, USE_GRAMMAR_POOL_ONLY,
 
472
                        // NOTE: These shouldn't really be here but since the XML Schema
 
473
                        //       validator is constructed dynamically, its recognized
 
474
                        //       features might not have been set and it would cause a
 
475
                        //       not-recognized exception to be thrown. -Ac
 
476
                        XMLSCHEMA_VALIDATION, XMLSCHEMA_FULL_CHECKING,                  
 
477
                        EXTERNAL_GENERAL_ENTITIES,  
 
478
                        EXTERNAL_PARAMETER_ENTITIES,
 
479
                        PARSER_SETTINGS,
 
480
                        
 
481
                };
484
482
        addRecognizedFeatures(recognizedFeatures);
485
 
                // set state for default features
486
 
                fFeatures.put(VALIDATION, Boolean.FALSE);
487
 
                fFeatures.put(NAMESPACES, Boolean.TRUE);
488
 
                fFeatures.put(EXTERNAL_GENERAL_ENTITIES, Boolean.TRUE);
489
 
                fFeatures.put(EXTERNAL_PARAMETER_ENTITIES, Boolean.TRUE);
490
 
                fFeatures.put(CONTINUE_AFTER_FATAL_ERROR, Boolean.FALSE);
491
 
                fFeatures.put(LOAD_EXTERNAL_DTD, Boolean.TRUE);
492
 
                fFeatures.put(SCHEMA_ELEMENT_DEFAULT, Boolean.TRUE);
493
 
                fFeatures.put(NORMALIZE_DATA, Boolean.TRUE);
494
 
                fFeatures.put(SCHEMA_AUGMENT_PSVI, Boolean.TRUE);
495
 
                fFeatures.put(PARSER_SETTINGS, Boolean.TRUE);
 
483
        // set state for default features
 
484
        fFeatures.put(VALIDATION, Boolean.FALSE);
 
485
        fFeatures.put(NAMESPACES, Boolean.TRUE);
 
486
        fFeatures.put(EXTERNAL_GENERAL_ENTITIES, Boolean.TRUE);
 
487
        fFeatures.put(EXTERNAL_PARAMETER_ENTITIES, Boolean.TRUE);
 
488
        fFeatures.put(CONTINUE_AFTER_FATAL_ERROR, Boolean.FALSE);
 
489
        fFeatures.put(LOAD_EXTERNAL_DTD, Boolean.TRUE);
 
490
        fFeatures.put(SCHEMA_ELEMENT_DEFAULT, Boolean.TRUE);
 
491
        fFeatures.put(NORMALIZE_DATA, Boolean.TRUE);
 
492
        fFeatures.put(SCHEMA_AUGMENT_PSVI, Boolean.TRUE);
 
493
        fFeatures.put(GENERATE_SYNTHETIC_ANNOTATIONS, Boolean.FALSE);
 
494
        fFeatures.put(VALIDATE_ANNOTATIONS, Boolean.FALSE);
 
495
        fFeatures.put(HONOUR_ALL_SCHEMALOCATIONS, Boolean.FALSE);
 
496
        fFeatures.put(IGNORE_XSI_TYPE, Boolean.FALSE);
 
497
        fFeatures.put(ID_IDREF_CHECKING, Boolean.TRUE);
 
498
        fFeatures.put(IDENTITY_CONSTRAINT_CHECKING, Boolean.TRUE);
 
499
        fFeatures.put(UNPARSED_ENTITY_CHECKING, Boolean.TRUE);
 
500
        fFeatures.put(USE_GRAMMAR_POOL_ONLY, Boolean.FALSE);
 
501
        fFeatures.put(PARSER_SETTINGS, Boolean.TRUE);
496
502
 
497
503
        // add default recognized properties
498
504
        final String[] recognizedProperties =
499
 
            {                                
500
 
                                SYMBOL_TABLE,
501
 
                                ERROR_HANDLER,  
502
 
                                ENTITY_RESOLVER,
 
505
        {                                    
 
506
                SYMBOL_TABLE,
 
507
                ERROR_HANDLER,  
 
508
                ENTITY_RESOLVER,
503
509
                ERROR_REPORTER,
504
510
                ENTITY_MANAGER,
505
511
                DOCUMENT_SCANNER,
506
512
                DTD_SCANNER,
507
513
                DTD_PROCESSOR,
508
514
                DTD_VALIDATOR,
509
 
                                DATATYPE_VALIDATOR_FACTORY,
510
 
                                VALIDATION_MANAGER,
511
 
                                SCHEMA_VALIDATOR,
512
 
                                XML_STRING,
 
515
                DATATYPE_VALIDATOR_FACTORY,
 
516
                VALIDATION_MANAGER,
 
517
                SCHEMA_VALIDATOR,
 
518
                XML_STRING,
513
519
                XMLGRAMMAR_POOL, 
514
520
                JAXP_SCHEMA_SOURCE,
515
521
                JAXP_SCHEMA_LANGUAGE,                
516
 
                // NOTE: These shouldn't really be here but since the XML Schema
517
 
                //       validator is constructed dynamically, its recognized
518
 
                //       properties might not have been set and it would cause a
519
 
                //       not-recognized exception to be thrown. -Ac
520
 
                SCHEMA_LOCATION, SCHEMA_NONS_LOCATION, };
 
522
                // NOTE: These shouldn't really be here but since the XML Schema
 
523
                //       validator is constructed dynamically, its recognized
 
524
                //       properties might not have been set and it would cause a
 
525
                //       not-recognized exception to be thrown. -Ac
 
526
                SCHEMA_LOCATION,
 
527
                SCHEMA_NONS_LOCATION,
 
528
                ROOT_TYPE_DEF,
 
529
        };
521
530
        addRecognizedProperties(recognizedProperties);
522
531
                
523
532
                if (symbolTable == null) {
790
799
                resetCommon();
791
800
 
792
801
                short version = fVersionDetector.determineDocVersion(fInputSource);
793
 
                if (version == Constants.XML_VERSION_1_1) {
 
802
                // XML 1.0
 
803
                if (version == Constants.XML_VERSION_1_0) {
 
804
                    configurePipeline();
 
805
                    reset();
 
806
                }
 
807
                // XML 1.1
 
808
                else if (version == Constants.XML_VERSION_1_1) {
794
809
                    initXML11Components();
795
810
                    configureXML11Pipeline();
796
811
                    resetXML11();
797
 
                } else {
798
 
                    configurePipeline();
799
 
                    reset();
 
812
                }
 
813
                // Unrecoverable error reported during version detection
 
814
                else {
 
815
                   return false;
800
816
                }
801
817
                
802
818
                // mark configuration as fixed
1517
1533
            f11Initialized = true;
1518
1534
        }
1519
1535
    }
 
1536
    
 
1537
    /** 
 
1538
     * Returns the state of a feature. This method calls getFeature()
 
1539
     * on ParserConfigurationSettings, bypassing getFeature() on this
 
1540
     * class.
 
1541
     */
 
1542
    boolean getFeature0(String featureId)
 
1543
        throws XMLConfigurationException {
 
1544
        return super.getFeature(featureId);
 
1545
    }
1520
1546
 
1521
1547
} // class XML11Configuration