rev 1063 : 8172974: [JAXP] XALAN: Wrong result when transforming namespace unaware StAX Input

   1 /*
   2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20 
  21 package com.sun.org.apache.xerces.internal.jaxp;
  22 
  23 import com.sun.org.apache.xerces.internal.impl.Constants;
  24 import com.sun.org.apache.xerces.internal.util.SAXMessageFormatter;
  25 import java.util.HashMap;
  26 import java.util.Map;
  27 import javax.xml.XMLConstants;
  28 import javax.xml.parsers.ParserConfigurationException;
  29 import javax.xml.parsers.SAXParser;
  30 import javax.xml.parsers.SAXParserFactory;
  31 import javax.xml.validation.Schema;
  32 import org.xml.sax.SAXException;
  33 import org.xml.sax.SAXNotRecognizedException;
  34 import org.xml.sax.SAXNotSupportedException;
  35 
  36 /**
  37  * This is the implementation specific class for the
  38  * <code>javax.xml.parsers.SAXParserFactory</code>. This is the platform
  39  * default implementation for the platform.
  40  *
  41  * @author Rajiv Mordani
  42  * @author Edwin Goei
  43  *
  44  */
  45 public class SAXParserFactoryImpl extends SAXParserFactory {
  46 
  47     /** Feature identifier: validation. */
  48     private static final String VALIDATION_FEATURE =
  49         Constants.SAX_FEATURE_PREFIX + Constants.VALIDATION_FEATURE;
  50 
  51     /** Feature identifier: namespaces. */
  52     private static final String NAMESPACES_FEATURE =
  53         Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;
  54 
  55     /** Feature identifier: XInclude processing */
  56     private static final String XINCLUDE_FEATURE =
  57         Constants.XERCES_FEATURE_PREFIX + Constants.XINCLUDE_FEATURE;
  58 
  59     private Map<String, Boolean> features;
  60     private Schema grammar;

  61 
  62     /**
  63      * State of the secure processing feature, initially <code>false</code>
  64      */
  65     private boolean fSecureProcess = true;
  66 
  67     /**
  68      * Creates a new instance of <code>SAXParser</code> using the currently
  69      * configured factory parameters.
  70      * @return javax.xml.parsers.SAXParser
  71      */
  72     public SAXParser newSAXParser()
  73         throws ParserConfigurationException
  74     {
  75         SAXParser saxParserImpl;
  76         try {
  77             saxParserImpl = new SAXParserImpl(this, features, fSecureProcess);
  78         } catch (SAXException se) {
  79             // Translate to ParserConfigurationException
  80             throw new ParserConfigurationException(se.getMessage());
  81         }
  82         return saxParserImpl;
  83     }
  84 
  85     /**
  86      * Common code for translating exceptions
  87      */
  88     private SAXParserImpl newSAXParserImpl()
  89         throws ParserConfigurationException, SAXNotRecognizedException,
  90         SAXNotSupportedException
  91     {
  92         SAXParserImpl saxParserImpl;
  93         try {
  94             saxParserImpl = new SAXParserImpl(this, features);
  95         } catch (SAXNotSupportedException e) {
  96             throw e;
  97         } catch (SAXNotRecognizedException e) {
  98             throw e;
  99         } catch (SAXException se) {
 100             throw new ParserConfigurationException(se.getMessage());
 101         }
 102         return saxParserImpl;
 103     }
 104 
 105     /**
 106      * Sets the particular feature in the underlying implementation of
 107      * org.xml.sax.XMLReader.
 108      */
 109     public void setFeature(String name, boolean value)
 110         throws ParserConfigurationException, SAXNotRecognizedException,
 111                 SAXNotSupportedException {
 112         if (name == null) {
 113             throw new NullPointerException();
 114         }
 115         // If this is the secure processing feature, save it then return.
 116         if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 117             if (System.getSecurityManager() != null && (!value)) {
 118                 throw new ParserConfigurationException(
 119                         SAXMessageFormatter.formatMessage(null,
 120                         "jaxp-secureprocessing-feature", null));
 121             }
 122             fSecureProcess = value;
 123             putInFeatures(name, value);
 124             return;
 125         }
 126 
 127         // XXX This is ugly.  We have to collect the features and then
 128         // later create an XMLReader to verify the features.
 129         putInFeatures(name, value);
 130         // Test the feature by possibly throwing SAX exceptions
 131         try {
 132             newSAXParserImpl();
 133         } catch (SAXNotSupportedException e) {
 134             features.remove(name);
 135             throw e;
 136         } catch (SAXNotRecognizedException e) {
 137             features.remove(name);
 138             throw e;
 139         }
 140     }
 141 
 142     /**
 143      * returns the particular property requested for in the underlying
 144      * implementation of org.xml.sax.XMLReader.
 145      */
 146     public boolean getFeature(String name)
 147         throws ParserConfigurationException, SAXNotRecognizedException,
 148                 SAXNotSupportedException {
 149         if (name == null) {
 150             throw new NullPointerException();
 151         }
 152         if (name.equals(XMLConstants.FEATURE_SECURE_PROCESSING)) {
 153             return fSecureProcess;
 154         }
 155         // Check for valid name by creating a dummy XMLReader to get
 156         // feature value
 157         return newSAXParserImpl().getXMLReader().getFeature(name);
 158     }
 159 
 160     public Schema getSchema() {
 161         return grammar;
 162     }
 163 
 164     public void setSchema(Schema grammar) {
 165         this.grammar = grammar;
 166     }
 167 
 168     public boolean isXIncludeAware() {
 169         return getFromFeatures(XINCLUDE_FEATURE);
 170     }
 171 
 172     public void setXIncludeAware(boolean state) {
 173         putInFeatures(XINCLUDE_FEATURE, state);
 174     }
 175 
 176 
 177     public void setValidating(boolean validating) {
 178         putInFeatures(VALIDATION_FEATURE, validating);
 179     }
 180 
 181     public boolean isValidating() {
 182          return getFromFeatures(VALIDATION_FEATURE);
 183     }
 184 
 185     private void putInFeatures(String name, boolean value){
 186          if (features == null) {
 187             features = new HashMap<>();
 188         }
 189         features.put(name, value ? Boolean.TRUE : Boolean.FALSE);
 190     }
 191 
 192     private boolean getFromFeatures(String name){
 193          if (features == null){
 194             return false;
 195          }
 196          else {
 197              Boolean value = features.get(name);
 198              return (value == null) ? false : value;
 199          }
 200     }
 201 
 202     public boolean isNamespaceAware() {
 203         return getFromFeatures(NAMESPACES_FEATURE);
 204     }
 205 
 206     public void setNamespaceAware(boolean awareness) {
 207        putInFeatures(NAMESPACES_FEATURE, awareness);
 208     }
 209 
 210  }
--- EOF ---