View Javadoc
1   /*
2    * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
3    */
4   
5   /*
6    * Copyright 2005 The Apache Software Foundation.
7    *
8    * Licensed under the Apache License, Version 2.0 (the "License");
9    * you may not use this file except in compliance with the License.
10   * 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.xml.internal.stream.dtd;
22  import com.sun.xml.internal.stream.dtd.nonvalidating.DTDGrammar;
23  import com.sun.xml.internal.stream.dtd.nonvalidating.XMLAttributeDecl;
24  import com.sun.xml.internal.stream.dtd.nonvalidating.XMLElementDecl;
25  import com.sun.xml.internal.stream.dtd.nonvalidating.XMLSimpleType;
26  import com.sun.org.apache.xerces.internal.impl.Constants;
27  import com.sun.org.apache.xerces.internal.impl.XMLEntityManager;
28  import com.sun.org.apache.xerces.internal.impl.XMLErrorReporter;
29  import com.sun.org.apache.xerces.internal.util.SymbolTable;
30  import com.sun.org.apache.xerces.internal.util.XMLChar;
31  import com.sun.org.apache.xerces.internal.util.XMLSymbols;
32  import com.sun.org.apache.xerces.internal.xni.Augmentations;
33  import com.sun.org.apache.xerces.internal.xni.QName;
34  import com.sun.org.apache.xerces.internal.xni.NamespaceContext;
35  import com.sun.org.apache.xerces.internal.xni.XMLAttributes;
36  import com.sun.org.apache.xerces.internal.xni.XMLDocumentHandler;
37  import com.sun.org.apache.xerces.internal.xni.XMLLocator;
38  import com.sun.org.apache.xerces.internal.xni.XMLString;
39  import com.sun.org.apache.xerces.internal.xni.XNIException;
40  import com.sun.org.apache.xerces.internal.xni.parser.XMLComponentManager;
41  import com.sun.org.apache.xerces.internal.xni.parser.XMLConfigurationException;
42  import com.sun.org.apache.xerces.internal.xni.parser.XMLDocumentSource;
43  import javax.xml.XMLConstants;
44  
45   /*
46    * @author Eric Ye, IBM
47    * @author Andy Clark, IBM
48    * @author Jeffrey Rodriguez IBM
49    * @author Neil Graham, IBM
50    * @author Sunitha Reddy, Sun Microsystems
51    */
52  
53  public class DTDGrammarUtil {
54  
55  
56      /** Property identifier: symbol table. */
57      protected static final String SYMBOL_TABLE =
58      Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY;
59  
60      protected static final String NAMESPACES =
61      Constants.SAX_FEATURE_PREFIX + Constants.NAMESPACES_FEATURE;
62  
63  
64      /** Compile to true to debug attributes. */
65      private static final boolean DEBUG_ATTRIBUTES = false;
66  
67      /** Compile to true to debug element children. */
68      private static final boolean DEBUG_ELEMENT_CHILDREN = false;
69  
70      protected DTDGrammar fDTDGrammar = null;
71      /** Namespaces. */
72      protected boolean fNamespaces;
73  
74      /** Symbol table. */
75      protected SymbolTable fSymbolTable = null;
76  
77      /** Current element index. */
78      private int fCurrentElementIndex = -1;
79  
80      /** Current content spec type. */
81      private int fCurrentContentSpecType = -1;
82  
83      /** Content spec type stack. */
84      private boolean[] fElementContentState = new boolean[8];
85  
86      /** Element depth. */
87      private int fElementDepth = -1;
88  
89      /** True if inside of element content. */
90      private boolean fInElementContent = false;
91  
92      /** Temporary atribute declaration. */
93      private XMLAttributeDecl fTempAttDecl = new XMLAttributeDecl();
94  
95      /** Temporary qualified name. */
96      private QName fTempQName = new QName();
97  
98      /** Temporary string buffers. */
99      private StringBuffer fBuffer = new StringBuffer();
100 
101     private NamespaceContext fNamespaceContext = null;
102 
103     /** Default constructor. */
104     public DTDGrammarUtil(SymbolTable symbolTable) {
105         fSymbolTable = symbolTable;
106     }
107 
108     public DTDGrammarUtil(DTDGrammar grammar, SymbolTable symbolTable) {
109         fDTDGrammar = grammar;
110         fSymbolTable = symbolTable;
111     }
112 
113     public DTDGrammarUtil(DTDGrammar grammar, SymbolTable symbolTable,
114             NamespaceContext namespaceContext) {
115         fDTDGrammar = grammar;
116         fSymbolTable = symbolTable;
117         fNamespaceContext = namespaceContext;
118     }
119 
120     /*
121      * Resets the component. The component can query the component manager
122      * about any features and properties that affect the operation of the
123      * component.
124      *
125      * @param componentManager The component manager.
126      *
127      * @throws SAXException Thrown by component on finitialization error.
128      *                      For example, if a feature or property is
129      *                      required for the operation of the component, the
130      *                      component manager may throw a
131      *                      SAXNotRecognizedException or a
132      *                      SAXNotSupportedException.
133      */
134     public void reset(XMLComponentManager componentManager)
135     throws XMLConfigurationException {
136 
137         fDTDGrammar = null;
138         fInElementContent = false;
139         fCurrentElementIndex = -1;
140         fCurrentContentSpecType = -1;
141         fNamespaces = componentManager.getFeature(NAMESPACES, true);
142         fSymbolTable = (SymbolTable) componentManager.getProperty(
143                 Constants.XERCES_PROPERTY_PREFIX + Constants.SYMBOL_TABLE_PROPERTY);
144         fElementDepth = -1;
145     }
146 
147 
148     /**
149      * The start of an element.
150      *
151      * @param element    The name of the element.
152      * @param attributes The element attributes.
153      * @param augs   Additional information that may include infoset augmentations
154      *
155      * @throws XNIException Thrown by handler to signal an error.
156      */
157     public void startElement(QName element, XMLAttributes attributes)  throws XNIException {
158         handleStartElement(element, attributes);
159     }
160 
161     /**
162      * The end of an element.
163      *
164      * @param element The name of the element.
165      * @param augs   Additional information that may include infoset augmentations
166      *
167      * @throws XNIException Thrown by handler to signal an error.
168      */
169     public void endElement(QName element) throws XNIException {
170         handleEndElement(element);
171     }
172 
173     /**
174      * The start of a CDATA section.
175      * @param augs   Additional information that may include infoset augmentations
176      *
177      * @throws XNIException Thrown by handler to signal an error.
178      */
179     public void startCDATA(Augmentations augs) throws XNIException {
180     }
181 
182     /**
183      * The end of a CDATA section.
184      * @param augs   Additional information that may include infoset augmentations
185      *
186      * @throws XNIException Thrown by handler to signal an error.
187      */
188     public void endCDATA(Augmentations augs) throws XNIException {
189     }
190 
191 
192 
193     /** Add default attributes and validate. */
194     public void addDTDDefaultAttrs(QName elementName, XMLAttributes attributes)
195     throws XNIException {
196 
197         int elementIndex;
198         elementIndex = fDTDGrammar.getElementDeclIndex(elementName);
199         // is there anything to do?
200         if (elementIndex == -1 || fDTDGrammar == null) {
201             return;
202         }
203 
204         //
205         // Check after all specified attrs are scanned
206         // (1) report error for REQUIRED attrs that are missing (V_TAGc)
207         // (2) add default attrs (FIXED and NOT_FIXED)
208         //
209         int attlistIndex = fDTDGrammar.getFirstAttributeDeclIndex(elementIndex);
210 
211         while (attlistIndex != -1) {
212 
213             fDTDGrammar.getAttributeDecl(attlistIndex, fTempAttDecl);
214 
215             if (DEBUG_ATTRIBUTES) {
216                 if (fTempAttDecl != null) {
217                     XMLElementDecl elementDecl = new XMLElementDecl();
218                     fDTDGrammar.getElementDecl(elementIndex, elementDecl);
219                     System.out.println("element: " + (elementDecl.name.localpart));
220                     System.out.println("attlistIndex " + attlistIndex + "\n" +
221                     "attName : '" + (fTempAttDecl.name.localpart) + "'\n"
222                     + "attType : " + fTempAttDecl.simpleType.type + "\n"
223                     + "attDefaultType : " + fTempAttDecl.simpleType.defaultType + "\n"
224                     + "attDefaultValue : '" + fTempAttDecl.simpleType.defaultValue + "'\n"
225                     + attributes.getLength() + "\n"
226                     );
227                 }
228             }
229             String attPrefix = fTempAttDecl.name.prefix;
230             String attLocalpart = fTempAttDecl.name.localpart;
231             String attRawName = fTempAttDecl.name.rawname;
232             String attType = getAttributeTypeName(fTempAttDecl);
233             int attDefaultType = fTempAttDecl.simpleType.defaultType;
234             String attValue = null;
235 
236             if (fTempAttDecl.simpleType.defaultValue != null) {
237                 attValue = fTempAttDecl.simpleType.defaultValue;
238             }
239             boolean specified = false;
240             boolean required = attDefaultType == XMLSimpleType.DEFAULT_TYPE_REQUIRED;
241             boolean cdata = attType == XMLSymbols.fCDATASymbol;
242 
243             if (!cdata || required || attValue != null) {
244 
245                 //check whether attribute is a namespace declaration
246                 if (fNamespaceContext != null && attRawName.startsWith(XMLConstants.XMLNS_ATTRIBUTE)) {
247                     String prefix = "";
248                     int pos = attRawName.indexOf(':');
249                     if (pos != -1) {
250                         prefix = attRawName.substring(0, pos);
251                     } else {
252                         prefix = attRawName;
253                     }
254                     prefix = fSymbolTable.addSymbol(prefix);
255                     if (!((com.sun.org.apache.xerces.internal.util.
256                             NamespaceSupport) fNamespaceContext).
257                             containsPrefixInCurrentContext(prefix)) {
258                         fNamespaceContext.declarePrefix(prefix, attValue);
259                     }
260                     specified = true;
261                 } else {
262 
263                     int attrCount = attributes.getLength();
264                     for (int i = 0; i < attrCount; i++) {
265                         if (attributes.getQName(i) == attRawName) {
266                             specified = true;
267                             break;
268                         }
269                     }
270 
271                 }
272 
273             }
274 
275             if (!specified) {
276                 if (attValue != null) {
277                     if (fNamespaces) {
278                         int index = attRawName.indexOf(':');
279                         if (index != -1) {
280                             attPrefix = attRawName.substring(0, index);
281                             attPrefix = fSymbolTable.addSymbol(attPrefix);
282                             attLocalpart = attRawName.substring(index + 1);
283                             attLocalpart = fSymbolTable.addSymbol(attLocalpart);
284                         }
285                     }
286                     fTempQName.setValues(attPrefix, attLocalpart, attRawName,
287                             fTempAttDecl.name.uri);
288                     int newAttr = attributes.addAttribute(fTempQName, attType,
289                             attValue);
290                 }
291             }
292             attlistIndex = fDTDGrammar.getNextAttributeDeclIndex(attlistIndex);
293         }
294 
295         // now iterate through the expanded attributes for
296         // 1. if every attribute seen is declared in the DTD
297         // 2. check if the VC: default_fixed holds
298         // 3. validate every attribute.
299         int attrCount = attributes.getLength();
300         for (int i = 0; i < attrCount; i++) {
301             String attrRawName = attributes.getQName(i);
302             boolean declared = false;
303             int position =
304             fDTDGrammar.getFirstAttributeDeclIndex(elementIndex);
305             while (position != -1) {
306                 fDTDGrammar.getAttributeDecl(position, fTempAttDecl);
307                 if (fTempAttDecl.name.rawname == attrRawName) {
308                     // found the match att decl,
309                     declared = true;
310                     break;
311                 }
312                 position = fDTDGrammar.getNextAttributeDeclIndex(position);
313             }
314             if (!declared) {
315                 continue;
316             }
317 
318             String type = getAttributeTypeName(fTempAttDecl);
319             attributes.setType(i, type);
320 
321             boolean changedByNormalization = false;
322             if (attributes.isSpecified(i) && type != XMLSymbols.fCDATASymbol) {
323                 changedByNormalization = normalizeAttrValue(attributes, i);
324             }
325         } // for all attributes
326 
327     } // addDTDDefaultAttrsAndValidate(int,XMLAttrList)
328 
329 
330     /**
331      * Normalize the attribute value of a non CDATA attributes collapsing
332      * sequences of space characters (x20)
333      *
334      * @param attributes The list of attributes
335      * @param index The index of the attribute to normalize
336      */
337     private boolean normalizeAttrValue(XMLAttributes attributes, int index) {
338         // vars
339         boolean leadingSpace = true;
340         boolean spaceStart = false;
341         boolean readingNonSpace = false;
342         int count = 0;
343         int eaten = 0;
344         String attrValue = attributes.getValue(index);
345         char[] attValue = new char[attrValue.length()];
346 
347         fBuffer.setLength(0);
348         attrValue.getChars(0, attrValue.length(), attValue, 0);
349         for (int i = 0; i < attValue.length; i++) {
350 
351             if (attValue[i] == ' ') {
352 
353                 // now the tricky part
354                 if (readingNonSpace) {
355                     spaceStart = true;
356                     readingNonSpace = false;
357                 }
358 
359                 if (spaceStart && !leadingSpace) {
360                     spaceStart = false;
361                     fBuffer.append(attValue[i]);
362                     count++;
363                 } else {
364                     if (leadingSpace || !spaceStart) {
365                         eaten++;
366                     }
367                 }
368 
369             } else {
370                 readingNonSpace = true;
371                 spaceStart = false;
372                 leadingSpace = false;
373                 fBuffer.append(attValue[i]);
374                 count++;
375             }
376         }
377 
378         // check if the last appended character is a space.
379         if (count > 0 && fBuffer.charAt(count - 1) == ' ') {
380             fBuffer.setLength(count - 1);
381 
382         }
383         String newValue = fBuffer.toString();
384         attributes.setValue(index, newValue);
385         return !attrValue.equals(newValue);
386     }
387 
388 
389 
390     /** convert attribute type from ints to strings */
391     private String getAttributeTypeName(XMLAttributeDecl attrDecl) {
392 
393         switch (attrDecl.simpleType.type) {
394             case XMLSimpleType.TYPE_ENTITY: {
395                 return attrDecl.simpleType.list ? XMLSymbols.fENTITIESSymbol :
396                     XMLSymbols.fENTITYSymbol;
397             }
398             case XMLSimpleType.TYPE_ENUMERATION: {
399                 StringBuffer buffer = new StringBuffer();
400                 buffer.append('(');
401                 for (int i = 0; i < attrDecl.simpleType.enumeration.length; i++) {
402                     if (i > 0) {
403                         buffer.append("|");
404                     }
405                     buffer.append(attrDecl.simpleType.enumeration[i]);
406                 }
407                 buffer.append(')');
408                 return fSymbolTable.addSymbol(buffer.toString());
409             }
410             case XMLSimpleType.TYPE_ID: {
411                 return XMLSymbols.fIDSymbol;
412             }
413             case XMLSimpleType.TYPE_IDREF: {
414                 return attrDecl.simpleType.list ? XMLSymbols.fIDREFSSymbol :
415                     XMLSymbols.fIDREFSymbol;
416             }
417             case XMLSimpleType.TYPE_NMTOKEN: {
418                 return attrDecl.simpleType.list ? XMLSymbols.fNMTOKENSSymbol :
419                     XMLSymbols.fNMTOKENSymbol;
420             }
421             case XMLSimpleType.TYPE_NOTATION: {
422                 return XMLSymbols.fNOTATIONSymbol;
423             }
424         }
425         return XMLSymbols.fCDATASymbol;
426 
427     }
428 
429 
430     /** ensure element stack capacity */
431     private void ensureStackCapacity(int newElementDepth) {
432         if (newElementDepth == fElementContentState.length) {
433             boolean[] newStack = new boolean[newElementDepth * 2];
434             System.arraycopy(this.fElementContentState, 0, newStack, 0,
435                     newElementDepth);
436             fElementContentState = newStack;
437         }
438     }
439 
440 
441 
442     /** Handle element
443      * @return true if validator is removed from the pipeline
444      */
445     protected void handleStartElement(QName element, XMLAttributes attributes) throws XNIException {
446 
447         if (fDTDGrammar == null) {
448             fCurrentElementIndex = -1;
449             fCurrentContentSpecType = -1;
450             fInElementContent = false;
451             return;
452         } else {
453             fCurrentElementIndex = fDTDGrammar.getElementDeclIndex(element);
454             fCurrentContentSpecType = fDTDGrammar.getContentSpecType(
455                     fCurrentElementIndex);
456             //handleDTDDefaultAttrs(element,attributes);
457             addDTDDefaultAttrs(element, attributes);
458         }
459 
460         fInElementContent = fCurrentContentSpecType == XMLElementDecl.TYPE_CHILDREN;
461         fElementDepth++;
462         ensureStackCapacity(fElementDepth);
463         fElementContentState[fElementDepth] = fInElementContent;
464     }
465 
466 
467     /** Handle end element. */
468     protected void handleEndElement(QName element) throws XNIException {
469         if (fDTDGrammar == null) return;
470         fElementDepth--;
471         if (fElementDepth < -1) {
472             throw new RuntimeException("FWK008 Element stack underflow");
473         }
474         if (fElementDepth < 0) {
475             fCurrentElementIndex = -1;
476             fCurrentContentSpecType = -1;
477             fInElementContent = false;
478             return;
479         }
480         fInElementContent =  fElementContentState[fElementDepth];
481     }
482 
483     public boolean isInElementContent() {
484         return fInElementContent;
485     }
486 
487     public boolean isIgnorableWhiteSpace(XMLString text) {
488         if (isInElementContent()) {
489             for (int i = text.offset; i < text.offset + text.length; i++) {
490                 if (!XMLChar.isSpace(text.ch[i])) {
491                     return false;
492                 }
493             }
494             return true;
495         }
496         return false;
497     }
498 }