source: icXML/icXML-devel/src/icxercesc/parsers/AbstractDOMParser.cpp @ 2774

Last change on this file since 2774 was 2774, checked in by cameron, 6 years ago

Various fixes

File size: 53.0 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/**
19*  This file contains code to build the DOM tree. It registers a document
20*  handler with the scanner. In these handler methods, appropriate DOM nodes
21*  are created and added to the DOM tree.
22*
23* $Id: AbstractDOMParser.cpp 935358 2010-04-18 15:40:35Z borisk $
24*
25*/
26
27// ---------------------------------------------------------------------------
28//  Includes
29// ---------------------------------------------------------------------------
30#include <icxercesc/parsers/AbstractDOMParser.hpp>
31#include <xercesc/internal/XMLScannerResolver.hpp>
32#include <icxercesc/internal/ElemStack.hpp>
33#include <xercesc/util/XMLUniDefs.hpp>
34#include <xercesc/framework/XMLNotationDecl.hpp>
35#include <icxercesc/framework/XMLValidator.hpp>
36#include <xercesc/framework/psvi/PSVIElement.hpp>
37#include <xercesc/framework/psvi/PSVIAttribute.hpp>
38#include <xercesc/framework/psvi/PSVIAttributeList.hpp>
39#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
40#include <xercesc/util/IOException.hpp>
41#include <xercesc/dom/DOMImplementation.hpp>
42#include <xercesc/dom/DOMImplementationRegistry.hpp>
43#include <xercesc/dom/DOMElement.hpp>
44#include <xercesc/dom/impl/DOMAttrImpl.hpp>
45#include <xercesc/dom/impl/DOMAttrNSImpl.hpp>
46#include <xercesc/dom/impl/DOMTypeInfoImpl.hpp>
47#include <xercesc/dom/impl/DOMCDATASectionImpl.hpp>
48#include <xercesc/dom/DOMComment.hpp>
49#include <xercesc/dom/impl/DOMTextImpl.hpp>
50#include <xercesc/dom/impl/DOMDocumentImpl.hpp>
51#include <xercesc/dom/impl/DOMDocumentTypeImpl.hpp>
52#include <xercesc/dom/DOMDocumentType.hpp>
53#include <xercesc/dom/impl/DOMElementNSImpl.hpp>
54#include <xercesc/dom/impl/DOMEntityImpl.hpp>
55#include <xercesc/dom/impl/DOMEntityReferenceImpl.hpp>
56#include <xercesc/dom/impl/DOMNotationImpl.hpp>
57#include <xercesc/dom/DOMNamedNodeMap.hpp>
58#include <xercesc/dom/DOMProcessingInstruction.hpp>
59#include <xercesc/dom/impl/DOMProcessingInstructionImpl.hpp>
60#include <xercesc/dom/impl/DOMNodeIDMap.hpp>
61#include <xercesc/dom/impl/DOMCasts.hpp>
62#include <xercesc/validators/common/ContentSpecNode.hpp>
63#include <icxercesc/validators/common/GrammarResolver.hpp>
64#include <icxercesc/validators/schema/SchemaSymbols.hpp>
65#include <xercesc/util/OutOfMemoryException.hpp>
66#include <xercesc/xinclude/XIncludeUtils.hpp>
67
68XERCES_CPP_NAMESPACE_BEGIN
69
70
71// ---------------------------------------------------------------------------
72//  AbstractDOMParser: Constructors and Destructor
73// ---------------------------------------------------------------------------
74
75
76typedef JanitorMemFunCall<AbstractDOMParser>    CleanupType;
77typedef JanitorMemFunCall<AbstractDOMParser>    ResetInProgressType;
78
79
80AbstractDOMParser::AbstractDOMParser( XMLValidator* const   valToAdopt
81                                                                        , MemoryManager* const  manager
82                                                                        , XMLGrammarPool* const gramPool) :
83
84  fCreateEntityReferenceNodes(true)
85, fIncludeIgnorableWhitespace(true)
86, fWithinElement(false)
87, fParseInProgress(false)
88, fCreateCommentNodes(true)
89, fDocumentAdoptedByUser(false)
90, fCreateSchemaInfo(false)
91, fDoXInclude(false)
92, fScanner(0)
93, fImplementationFeatures(0)
94, fCurrentParent(0)
95, fCurrentNode(0)
96, fCurrentEntity(0)
97, fDocument(0)
98, fDocumentType(0)
99, fDocumentVector(0)
100, fGrammarResolver(0)
101, fValidator(valToAdopt)
102, fMemoryManager(manager)
103, fGrammarPool(gramPool)
104, fBufMgr(manager)
105, fInternalSubset(fBufMgr.bidOnBuffer())
106, fPSVIHandler(0)
107{
108        CleanupType cleanup(this, &AbstractDOMParser::cleanUp);
109
110        try
111        {
112                initialize();
113        }
114        catch(const OutOfMemoryException&)
115        {
116                // Don't cleanup when out of memory, since executing the
117                // code can cause problems.
118                cleanup.release();
119
120                throw;
121        }
122
123        cleanup.release();
124}
125
126
127AbstractDOMParser::~AbstractDOMParser()
128{
129        cleanUp();
130}
131
132// ---------------------------------------------------------------------------
133//  AbstractDOMParser: Initialize/CleanUp methods
134// ---------------------------------------------------------------------------
135void AbstractDOMParser::initialize()
136{
137        //  Create grammar resolver and string pool to pass to the scanner
138        fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
139
140        //  Create a scanner and tell it what validator to use. Then set us
141        //  as the document event handler so we can fill the DOM document.
142        fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fGrammarResolver, fMemoryManager);
143        fScanner->setDocHandler(this);
144        fScanner->setDocTypeHandler(this);
145        this->reset();
146}
147
148void AbstractDOMParser::cleanUp()
149{
150        if (fDocumentVector)
151                delete fDocumentVector;
152
153        if (!fDocumentAdoptedByUser && fDocument)
154                fDocument->release();
155
156        delete fScanner;
157        delete fGrammarResolver;
158        // grammar pool *always* owns this
159        //delete fURIStringPool;
160        fMemoryManager->deallocate(fImplementationFeatures);
161
162        if (fValidator)
163                delete fValidator;
164}
165
166// ---------------------------------------------------------------------------
167//  AbstractDOMParser: Utilities
168// ---------------------------------------------------------------------------
169void AbstractDOMParser::reset()
170{
171        // if fDocument exists already, store the old pointer in the vector for deletion later
172        if (fDocument && !fDocumentAdoptedByUser) {
173                if (!fDocumentVector) {
174                        // allocate the vector if not exists yet
175                        fDocumentVector  = new (fMemoryManager) RefVectorOf<DOMDocumentImpl>(10, true, fMemoryManager) ;
176                }
177                fDocumentVector->addElement(fDocument);
178        }
179
180        fDocument = 0;
181        resetDocType();
182        fCurrentParent   = 0;
183        fCurrentNode     = 0;
184        fCurrentEntity   = 0;
185        fWithinElement   = false;
186        fDocumentAdoptedByUser = false;
187        fInternalSubset.reset();
188}
189
190
191void AbstractDOMParser::resetInProgress()
192{
193        fParseInProgress = false;
194}
195
196
197void AbstractDOMParser::resetPool()
198{
199        //  We cannot enter here while a regular parse is in progress.
200        if (fParseInProgress)
201                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
202
203        if (fDocumentVector)
204                fDocumentVector->removeAllElements();
205
206        if (!fDocumentAdoptedByUser && fDocument)
207                fDocument->release();
208
209        fDocument = 0;
210}
211
212bool AbstractDOMParser::isDocumentAdopted() const
213{
214        return fDocumentAdoptedByUser;
215}
216
217DOMDocument* AbstractDOMParser::adoptDocument()
218{
219        fDocumentAdoptedByUser = true;
220        return fDocument;
221}
222
223
224// ---------------------------------------------------------------------------
225//  AbstractDOMParser: Getter methods
226// ---------------------------------------------------------------------------
227DOMDocument* AbstractDOMParser::getDocument()
228{
229        return fDocument;
230}
231
232const XMLValidator& AbstractDOMParser::getValidator() const
233{
234        return *fScanner->getValidator();
235}
236
237bool AbstractDOMParser::getDoNamespaces() const
238{
239        return fScanner->getDoNamespaces();
240}
241
242bool AbstractDOMParser::getGenerateSyntheticAnnotations() const
243{
244        return fScanner->getGenerateSyntheticAnnotations();
245}
246
247bool AbstractDOMParser::getValidateAnnotations() const
248{
249        return fScanner->getValidateAnnotations();
250}
251
252bool AbstractDOMParser::getExitOnFirstFatalError() const
253{
254        return fScanner->getExitOnFirstFatal();
255}
256
257bool AbstractDOMParser::getValidationConstraintFatal() const
258{
259        return fScanner->getValidationConstraintFatal();
260}
261
262AbstractDOMParser::ValSchemes AbstractDOMParser::getValidationScheme() const
263{
264        const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
265
266        if (scheme == XMLScanner::Val_Always)
267                return Val_Always;
268        else if (scheme == XMLScanner::Val_Never)
269                return Val_Never;
270
271        return Val_Auto;
272}
273
274bool AbstractDOMParser::getDoSchema() const
275{
276        return fScanner->getDoSchema();
277}
278
279bool AbstractDOMParser::getValidationSchemaFullChecking() const
280{
281        return fScanner->getValidationSchemaFullChecking();
282}
283
284bool AbstractDOMParser::getIdentityConstraintChecking() const
285{
286        return fScanner->getIdentityConstraintChecking();
287}
288
289XMLSize_t AbstractDOMParser::getErrorCount() const
290{
291        return fScanner->getErrorCount();
292}
293
294XMLCh* AbstractDOMParser::getExternalSchemaLocation() const
295{
296        return fScanner->getExternalSchemaLocation();
297}
298
299XMLCh* AbstractDOMParser::getExternalNoNamespaceSchemaLocation() const
300{
301        return fScanner->getExternalNoNamespaceSchemaLocation();
302}
303
304SecurityManager* AbstractDOMParser::getSecurityManager() const
305{
306        return fScanner->getSecurityManager();
307}
308
309// Return it as a reference so that we cn return as void* from getParameter.
310//
311const XMLSize_t& AbstractDOMParser::getLowWaterMark() const
312{
313        return fScanner->getLowWaterMark();
314}
315
316bool AbstractDOMParser::getLoadExternalDTD() const
317{
318        return fScanner->getLoadExternalDTD();
319}
320
321bool AbstractDOMParser::getLoadSchema() const
322{
323        return fScanner->getLoadSchema();
324}
325
326bool AbstractDOMParser::getCalculateSrcOfs() const
327{
328        return fScanner->getCalculateSrcOfs();
329}
330
331bool AbstractDOMParser::getStandardUriConformant() const
332{
333        return fScanner->getStandardUriConformant();
334}
335
336bool AbstractDOMParser::getIgnoreAnnotations() const
337{
338        return fScanner->getIgnoreAnnotations();
339}
340
341bool AbstractDOMParser::getDisableDefaultEntityResolution() const
342{
343        return fScanner->getDisableDefaultEntityResolution();
344}
345
346bool AbstractDOMParser::getSkipDTDValidation() const
347{
348        return fScanner->getSkipDTDValidation();
349}
350
351bool AbstractDOMParser::getHandleMultipleImports() const
352{
353        return fScanner->getHandleMultipleImports();
354}
355
356// ---------------------------------------------------------------------------
357//  AbstractDOMParser: Setter methods
358// ---------------------------------------------------------------------------
359void AbstractDOMParser::setPSVIHandler(PSVIHandler* const handler)
360{
361        fPSVIHandler = handler;
362        if (fPSVIHandler) {
363                fScanner->setPSVIHandler(this);
364        }
365        else if(!fCreateSchemaInfo) {
366                fScanner->setPSVIHandler(0);
367        }
368}
369
370
371void AbstractDOMParser::setDoNamespaces(const bool newState)
372{
373        fScanner->setDoNamespaces(newState);
374}
375
376void AbstractDOMParser::setGenerateSyntheticAnnotations(const bool newState)
377{
378        fScanner->setGenerateSyntheticAnnotations(newState);
379}
380
381void AbstractDOMParser::setValidateAnnotations(const bool newState)
382{
383        fScanner->setValidateAnnotations(newState);
384}
385
386void AbstractDOMParser::setExitOnFirstFatalError(const bool newState)
387{
388        fScanner->setExitOnFirstFatal(newState);
389}
390
391void AbstractDOMParser::setValidationConstraintFatal(const bool newState)
392{
393        fScanner->setValidationConstraintFatal(newState);
394}
395
396void AbstractDOMParser::setValidationScheme(const ValSchemes newScheme)
397{
398        if (newScheme == Val_Never)
399                fScanner->setValidationScheme(XMLScanner::Val_Never);
400        else if (newScheme == Val_Always)
401                fScanner->setValidationScheme(XMLScanner::Val_Always);
402        else
403                fScanner->setValidationScheme(XMLScanner::Val_Auto);
404}
405
406void AbstractDOMParser::setDoSchema(const bool newState)
407{
408        fScanner->setDoSchema(newState);
409}
410
411void AbstractDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
412{
413        fScanner->setValidationSchemaFullChecking(schemaFullChecking);
414}
415
416void AbstractDOMParser::setIdentityConstraintChecking(const bool identityConstraintChecking)
417{
418        fScanner->setIdentityConstraintChecking(identityConstraintChecking);
419}
420
421void AbstractDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
422{
423        fScanner->setExternalSchemaLocation(schemaLocation);
424}
425void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
426{
427        fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
428}
429
430void AbstractDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
431{
432        fScanner->setExternalSchemaLocation(schemaLocation);
433}
434void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
435{
436        fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
437}
438
439void AbstractDOMParser::setSecurityManager(SecurityManager* const securityManager)
440{
441        // since this could impact various components, don't permit it to change
442        // during a parse
443        if (fParseInProgress)
444                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
445
446        fScanner->setSecurityManager(securityManager);
447}
448
449void AbstractDOMParser::setLowWaterMark(XMLSize_t lwm)
450{
451        fScanner->setLowWaterMark(lwm);
452}
453
454void AbstractDOMParser::setLoadExternalDTD(const bool newState)
455{
456        fScanner->setLoadExternalDTD(newState);
457}
458
459void AbstractDOMParser::setLoadSchema(const bool newState)
460{
461        fScanner->setLoadSchema(newState);
462}
463
464void AbstractDOMParser::setCalculateSrcOfs(const bool newState)
465{
466        fScanner->setCalculateSrcOfs(newState);
467}
468
469void AbstractDOMParser::setStandardUriConformant(const bool newState)
470{
471        fScanner->setStandardUriConformant(newState);
472}
473
474void AbstractDOMParser::useScanner(const XMLCh* const scannerName)
475{
476        XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
477        (
478                scannerName
479                , fValidator
480                , fGrammarResolver
481                , fMemoryManager
482        );
483
484        if (tempScanner)
485        {
486                tempScanner->setParseSettings(fScanner);
487                delete fScanner;
488                fScanner = tempScanner;
489        }
490}
491
492void AbstractDOMParser::setCreateSchemaInfo(const bool create)
493{
494        fCreateSchemaInfo = create;
495        if(fCreateSchemaInfo)
496                fScanner->setPSVIHandler(this);
497        else if(!fPSVIHandler)
498                fScanner->setPSVIHandler(0);
499}
500
501void AbstractDOMParser::setIgnoreAnnotations(const bool newValue)
502{
503        fScanner->setIgnoreAnnotations(newValue);
504}
505
506void AbstractDOMParser::setDisableDefaultEntityResolution(const bool newValue)
507{
508        fScanner->setDisableDefaultEntityResolution(newValue);
509}
510
511void AbstractDOMParser::setSkipDTDValidation(const bool newValue)
512{
513        fScanner->setSkipDTDValidation(newValue);
514}
515
516void AbstractDOMParser::setHandleMultipleImports(const bool newValue)
517{
518        fScanner->setHandleMultipleImports(newValue);
519}
520
521void AbstractDOMParser::setDocument(DOMDocument* toSet)
522{
523        fDocument = (DOMDocumentImpl *)toSet;
524}
525
526// ---------------------------------------------------------------------------
527//  AbstractDOMParser: Parsing methods
528// ---------------------------------------------------------------------------
529void AbstractDOMParser::parse(const InputSource& source)
530{
531        // Avoid multiple entrance
532        if (fParseInProgress)
533                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
534
535        ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
536
537        try
538        {
539                fParseInProgress = true;
540                fScanner->scanDocument(source);
541
542                if (fDoXInclude && getErrorCount()==0){
543                        DOMDocument *doc = getDocument();
544                        // after XInclude, the document must be normalized
545                        if(doc)
546                                doc->normalizeDocument();
547                }
548        }
549        catch(const OutOfMemoryException&)
550        {
551                resetInProgress.release();
552
553                throw;
554        }
555}
556
557void AbstractDOMParser::parse(const XMLCh* const systemId)
558{
559        // Avoid multiple entrance
560        if (fParseInProgress)
561                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
562
563        ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
564
565        try
566        {
567                fParseInProgress = true;
568                fScanner->scanDocument(systemId);
569
570                if (fDoXInclude && getErrorCount()==0){
571                        DOMDocument *doc = getDocument();
572                        // after XInclude, the document must be normalized
573                        if(doc)
574                                doc->normalizeDocument();
575                }
576        }
577        catch(const OutOfMemoryException&)
578        {
579                resetInProgress.release();
580
581                throw;
582        }
583}
584
585void AbstractDOMParser::parse(const char* const systemId)
586{
587        // Avoid multiple entrance
588        if (fParseInProgress)
589                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
590
591        ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
592
593        try
594        {
595                fParseInProgress = true;
596                fScanner->scanDocument(systemId);
597
598                if (fDoXInclude && getErrorCount()==0){
599                        DOMDocument *doc = getDocument();
600                        // after XInclude, the document must be normalized
601                        if(doc)
602                                doc->normalizeDocument();
603                }
604        }
605        catch(const OutOfMemoryException&)
606        {
607                resetInProgress.release();
608
609                throw;
610        }
611}
612
613
614
615// ---------------------------------------------------------------------------
616//  AbstractDOMParser: Progressive parse methods
617// ---------------------------------------------------------------------------
618bool AbstractDOMParser::parseFirst( const XMLCh* const    systemId
619                                                                   ,       XMLPScanToken&  toFill)
620{
621        //
622        //  Avoid multiple entrance. We cannot enter here while a regular parse
623        //  is in progress.
624        //
625        if (fParseInProgress)
626                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
627
628        return fScanner->scanFirst(systemId, toFill);
629}
630
631bool AbstractDOMParser::parseFirst( const char* const         systemId
632                                                                   ,       XMLPScanToken&      toFill)
633{
634        //
635        //  Avoid multiple entrance. We cannot enter here while a regular parse
636        //  is in progress.
637        //
638        if (fParseInProgress)
639                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
640
641        return fScanner->scanFirst(systemId, toFill);
642}
643
644bool AbstractDOMParser::parseFirst( const InputSource& source
645                                                                   ,       XMLPScanToken&  toFill)
646{
647        //
648        //  Avoid multiple entrance. We cannot enter here while a regular parse
649        //  is in progress.
650        //
651        if (fParseInProgress)
652                ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
653
654        return fScanner->scanFirst(source, toFill);
655}
656
657bool AbstractDOMParser::parseNext(XMLPScanToken& token)
658{
659        return fScanner->scanNext(token);
660}
661
662void AbstractDOMParser::parseReset(XMLPScanToken& token)
663{
664        // Reset the scanner, and then reset the parser
665        fScanner->scanReset(token);
666        reset();
667}
668
669
670// ---------------------------------------------------------------------------
671//  AbstractDOMParser: Implementation of PSVIHandler interface
672// ---------------------------------------------------------------------------
673void AbstractDOMParser::handleElementPSVI(const XMLCh* const            localName
674                                                                                , const XMLCh* const            uri
675                                                                                ,       PSVIElement *           elementInfo)
676{
677        // associate the info now; if the user wants, she can override what we did
678        if(fCreateSchemaInfo)
679        {
680                DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
681                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, elementInfo->getValidity());
682                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, elementInfo->getValidationAttempted());
683                if(elementInfo->getTypeDefinition())
684                {
685                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, elementInfo->getTypeDefinition()->getTypeCategory());
686                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, elementInfo->getTypeDefinition()->getAnonymous());
687                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
688                                fDocument->getPooledString(elementInfo->getTypeDefinition()->getNamespace()));
689                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
690                                fDocument->getPooledString(elementInfo->getTypeDefinition()->getName()));
691                }
692                else if(elementInfo->getValidity()==PSVIItem::VALIDITY_VALID)
693                {
694                        // if we are valid but we don't have a type validator, we are xs:anyType
695                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::COMPLEX_TYPE);
696                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
697                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
698                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgATTVAL_ANYTYPE);
699                }
700                if(elementInfo->getMemberTypeDefinition())
701                {
702                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, elementInfo->getMemberTypeDefinition()->getAnonymous());
703                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
704                                fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getNamespace()));
705                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
706                                fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getName()));
707                }
708                if(elementInfo->getElementDeclaration())
709                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Nil, elementInfo->getElementDeclaration()->getNillable());
710                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(elementInfo->getSchemaDefault()));
711                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(elementInfo->getSchemaNormalizedValue()));
712                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
713                ((DOMElementNSImpl*)fCurrentParent)->setSchemaTypeInfo(typeInfo);
714        }
715        if(fPSVIHandler)
716                fPSVIHandler->handleElementPSVI(localName, uri, elementInfo);
717}
718
719void AbstractDOMParser::handlePartialElementPSVI(const XMLCh* const            localName
720                                                                                           , const XMLCh* const            uri
721                                                                                           ,       PSVIElement *           elementInfo)
722{
723        if(fPSVIHandler)
724                fPSVIHandler->handlePartialElementPSVI(localName, uri, elementInfo);
725}
726
727void AbstractDOMParser::handleAttributesPSVI( const XMLCh* const            localName
728                                                                                        , const XMLCh* const            uri
729                                                                                        ,       PSVIAttributeList *     psviAttributes)
730{
731        if(fCreateSchemaInfo)
732        {
733                for (XMLSize_t index=0; index < psviAttributes->getLength(); index++) {
734                        XERCES_CPP_NAMESPACE_QUALIFIER PSVIAttribute *attrInfo=psviAttributes->getAttributePSVIAtIndex(index);
735                        XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* pAttrNode=fCurrentNode->getAttributes()->getNamedItemNS(psviAttributes->getAttributeNamespaceAtIndex(index),
736                                                                                                                                                                                                                        psviAttributes->getAttributeNameAtIndex(index));
737                        if(pAttrNode!=NULL)
738                        {
739                                DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
740                                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, attrInfo->getValidity());
741                                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, attrInfo->getValidationAttempted());
742                                if(attrInfo->getTypeDefinition())
743                                {
744                                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
745                                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, attrInfo->getTypeDefinition()->getAnonymous());
746                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
747                                                fDocument->getPooledString(attrInfo->getTypeDefinition()->getNamespace()));
748                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
749                                                fDocument->getPooledString(attrInfo->getTypeDefinition()->getName()));
750                                }
751                                else if(attrInfo->getValidity()==PSVIItem::VALIDITY_VALID)
752                                {
753                                        // if we are valid but we don't have a type validator, we are xs:anySimpleType
754                                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
755                                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
756                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
757                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgDT_ANYSIMPLETYPE);
758                                }
759                                if(attrInfo->getMemberTypeDefinition())
760                                {
761                                        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, attrInfo->getMemberTypeDefinition()->getAnonymous());
762                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
763                                                fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getNamespace()));
764                                        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
765                                                fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getName()));
766                                }
767                                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(attrInfo->getSchemaDefault()));
768                                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(attrInfo->getSchemaNormalizedValue()));
769                                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
770                                ((DOMAttrImpl*)pAttrNode)->setSchemaTypeInfo(typeInfo);
771                        }
772                }
773        }
774        // associate the info now; if the user wants, she can override what we did
775        if(fPSVIHandler)
776                fPSVIHandler->handleAttributesPSVI(localName, uri, psviAttributes);
777}
778
779// ---------------------------------------------------------------------------
780//  AbstractDOMParser: Implementation of XMLDocumentHandler interface
781// ---------------------------------------------------------------------------
782void AbstractDOMParser::docCharacters(  const   XMLCh* const    chars
783                                                          , const XMLSize_t    length
784                                                          , const bool         cdataSection)
785{
786        // Ignore chars outside of content
787        if (!fWithinElement)
788                return;
789
790        if (cdataSection == true)
791        {
792                DOMCDATASection *node = createCDATASection (chars, length);
793                castToParentImpl (fCurrentParent)->appendChildFast (node);
794                fCurrentNode = node;
795        }
796        else
797        {
798                if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
799                {
800                        DOMTextImpl *node = (DOMTextImpl*)fCurrentNode;
801                        node->appendData(chars, length);
802                }
803                else
804                {
805                        DOMText *node = createText (chars, length);
806                        castToParentImpl (fCurrentParent)->appendChildFast (node);
807                        fCurrentNode = node;
808                }
809        }
810}
811
812
813void AbstractDOMParser::docComment(const XMLCh* const comment)
814{
815        if (fCreateCommentNodes) {
816                DOMComment *dcom = fDocument->createComment(comment);
817                castToParentImpl (fCurrentParent)->appendChildFast (dcom);
818                fCurrentNode = dcom;
819        }
820}
821
822
823void AbstractDOMParser::docPI(  const   XMLCh* const    target
824                                          , const XMLCh* const    data)
825{
826        DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
827                (
828                target
829                , data
830                );
831        castToParentImpl (fCurrentParent)->appendChildFast (pi);
832        fCurrentNode = pi;
833}
834
835
836void AbstractDOMParser::endEntityReference(const XMLEntityDecl&)
837{
838        if (!fCreateEntityReferenceNodes)
839          return;
840
841        DOMEntityReferenceImpl *erImpl = 0;
842
843        if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE)
844                erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
845
846        fCurrentNode   = fCurrentParent;
847        fCurrentParent = fCurrentNode->getParentNode ();
848
849        // When the document is invalid but we continue parsing, we may
850        // end up seeing more 'end' events than the 'start' ones.
851        //
852        if (fCurrentParent == 0 && fDocument != 0)
853        {
854          fCurrentNode = fDocument->getDocumentElement ();
855          fCurrentParent = fCurrentNode;
856        }
857
858        if (erImpl)
859                erImpl->setReadOnly(true, true);
860}
861
862
863void AbstractDOMParser::endElement( const   XMLElementDecl&
864                                                   , const unsigned int
865                                                   , const bool
866                                                   , const XMLCh* const)
867{
868        fCurrentNode   = fCurrentParent;
869        fCurrentParent = fCurrentNode->getParentNode ();
870
871        // When the document is invalid but we continue parsing, we may
872        // end up seeing more 'end' events than the 'start' ones.
873        //
874        if (fCurrentParent == 0 && fDocument != 0)
875        {
876          fCurrentNode = fDocument->getDocumentElement ();
877          fCurrentParent = fCurrentNode;
878        }
879
880        // If we've hit the end of content, clear the flag.
881        //
882        if (fCurrentParent == fDocument)
883                fWithinElement = false;
884
885        if(fDoXInclude &&
886           (XIncludeUtils::isXIIncludeDOMNode(fCurrentNode) ||
887                ((XIncludeUtils::isXIFallbackDOMNode(fCurrentNode) &&
888                  !XMLString::equals(fCurrentParent->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)))))
889        {
890                XIncludeUtils xiu((XMLErrorReporter *) this);
891                // process the XInclude node, then update the fCurrentNode with the new content
892                if(xiu.parseDOMNodeDoingXInclude(fCurrentNode, fDocument, getScanner()->getEntityHandler()))
893                        fCurrentNode = fCurrentParent->getLastChild();
894        }
895}
896
897
898void AbstractDOMParser::ignorableWhitespace(  const XMLCh* const    chars
899                                                                                        , const XMLSize_t       length
900                                                                                        , const bool)
901{
902        // Ignore chars before the root element
903        if (!fWithinElement || !fIncludeIgnorableWhitespace)
904                return;
905
906        // revisit.  Not safe to slam in a null like this.
907        XMLCh savedChar = chars[length];
908        XMLCh *ncChars  = (XMLCh *)chars;   // cast off const
909        ncChars[length] = chNull;
910
911        if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
912        {
913                DOMText *node = (DOMText *)fCurrentNode;
914                node->appendData(chars);
915        }
916        else
917        {
918                DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
919                node->setIgnorableWhitespace(true);
920                castToParentImpl (fCurrentParent)->appendChildFast (node);
921
922                fCurrentNode = node;
923        }
924        ncChars[length] = savedChar;
925}
926
927
928void AbstractDOMParser::resetDocument()
929{
930        //
931        //  The reset methods are called before a new parse event occurs.
932        //  Reset this parsers state to clear out anything that may be left
933        //  from a previous use, in particular the DOM document itself.
934        //
935        this->reset();
936}
937
938
939void AbstractDOMParser::startDocument()
940{
941        if(fImplementationFeatures == 0)
942                fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument(fMemoryManager);
943        else
944                fDocument = (DOMDocumentImpl *)DOMImplementationRegistry::getDOMImplementation(fImplementationFeatures)->createDocument(fMemoryManager);
945
946        // Just set the document as the current parent and current node
947        fCurrentParent = fDocument;
948        fCurrentNode   = fDocument;
949        // set DOM error checking off
950        fDocument->setErrorChecking(false);
951        fDocument->setDocumentURI(fScanner->getLocator()->getSystemId());
952        fDocument->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
953}
954
955
956void AbstractDOMParser::endDocument()
957{
958        // set DOM error checking back on
959        fDocument->setErrorChecking(true);
960
961        // DOM L2 does not support editing DocumentType nodes
962        if (fDocumentType && fScanner -> getDoNamespaces())
963                fDocumentType->setReadOnly(true, true);
964}
965
966
967void AbstractDOMParser::startElement(const XMLElementDecl&   elemDecl
968                                                         , const unsigned int            urlId
969                                                         , const XMLCh* const            elemPrefix
970                                                         , const RefVectorOf<XMLAttr>&   attrList
971                                                         , const XMLSize_t               attrCount
972                                                         , const bool                    isEmpty
973                                                         , const bool                    isRoot)
974{
975        DOMElement     *elem;
976        DOMElementImpl *elemImpl;
977        const XMLCh* namespaceURI = 0;
978    const bool doNamespaces = fScanner->getDoNamespaces();
979
980        // Create the element name. Here we are going to bypass the
981        // DOMDocument::createElement() interface and instantiate the
982        // required types directly in order to avoid name checking
983        // overhead.
984        //
985        if (doNamespaces)
986        {
987                //DOM Level 2, doNamespaces on
988                //
989                const XMLCh* localName = elemDecl.getBaseName();
990
991                if (urlId != fScanner->getEmptyNamespaceId())
992                {
993                        namespaceURI = fScanner->getURIText(urlId); //get namespaceURI
994
995                        elem = createElementNS (namespaceURI, 0, localName, elemDecl.getFullName());
996                }
997                else
998                {
999                        elem = createElementNS (namespaceURI, 0, localName, localName);
1000                }
1001        }
1002        else
1003        {   //DOM Level 1
1004                elem = createElement (elemDecl.getFullName());
1005        }
1006
1007        elemImpl = (DOMElementImpl *) elem;
1008
1009        if (attrCount)
1010        {
1011                DOMAttrMapImpl* map = elemImpl->fAttributes;
1012                map->reserve (attrCount);
1013
1014                for (XMLSize_t index = 0; index < attrCount; ++index)
1015                {
1016                        const XMLAttr* attribute = attrList.elementAt(index);
1017                        DOMAttrImpl *attr = 0;
1018
1019                        if (doNamespaces)
1020                        {
1021                                //DOM Level 2, doNamespaces on
1022                                //
1023                                unsigned int attrURIId = attribute->getURIId();
1024                                const XMLCh* localName = attribute->getName();
1025                                const XMLCh* prefix = attribute->getPrefix();                           
1026
1027                if (attrURIId == XMLNamespaceResolver::fEmptyUriId)
1028                {
1029                    namespaceURI = 0;
1030                    if (XMLString::equals(localName, XMLUni::fgXMLNSString))
1031                    {
1032                        // xmlns=...
1033                        namespaceURI = fScanner->getURIText(XMLNamespaceResolver::fXMLNSUriId);
1034                    }
1035                }
1036                else // if (attrURIId != XMLNamespaceResolver::fEmptyUriId)
1037                                {
1038                                        namespaceURI = fScanner->getURIText(attrURIId);
1039                                }
1040
1041                attr = (DOMAttrImpl*) createAttrNS (namespaceURI, prefix, localName, attribute->getQName());
1042
1043                                map->setNamedItemNSFast(attr);
1044                        }
1045                        else
1046                        {
1047                                attr = (DOMAttrImpl*) createAttr (attribute->getQName());
1048                                map->setNamedItemFast(attr);
1049                        }
1050
1051                        attr->setValueFast(attribute->getValue());
1052
1053                        // Attributes of type ID.  If this is one, add it to the hashtable of IDs
1054                        //   that is constructed for use by GetElementByID().
1055                        //
1056                        if (attribute->getType()==XMLAttDef::ID)
1057                        {
1058                                if (fDocument->fNodeIDMap == 0)
1059                {
1060                                        fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
1061                }
1062                                fDocument->fNodeIDMap->add(attr);
1063                                attr->fNode.isIdAttr(true);
1064                        }
1065
1066                        attr->setSpecified(attribute->getSpecified());
1067
1068                        // store DTD validation information
1069            if (fCreateSchemaInfo)
1070                        {
1071                                switch(attribute->getType())
1072                                {
1073                                        case XMLAttDef::CData:          attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
1074                                        case XMLAttDef::ID:             attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
1075                                        case XMLAttDef::IDRef:          attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
1076                                        case XMLAttDef::IDRefs:         attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
1077                                        case XMLAttDef::Entity:         attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
1078                                        case XMLAttDef::Entities:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
1079                                        case XMLAttDef::NmToken:        attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
1080                                        case XMLAttDef::NmTokens:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
1081                                        case XMLAttDef::Notation:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
1082                                        case XMLAttDef::Enumeration:    attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
1083                                        default:                        attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
1084                                }
1085                        }
1086                }
1087        }
1088
1089        //Set up the default attributes if any.
1090        //
1091        if (elemDecl.hasAttDefs())
1092        {
1093                XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
1094                XMLAttDef* attr = 0;
1095                DOMAttrImpl * insertAttr = 0;
1096
1097                for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
1098                {
1099                        attr = &defAttrs->getAttDef(i);
1100
1101                        const XMLAttDef::DefAttTypes defType = attr->getDefaultType();
1102                        if ((defType == XMLAttDef::Default) ||  (defType == XMLAttDef::Fixed))
1103                        {
1104                                if (doNamespaces)
1105                                {
1106                                        // DOM Level 2 wants all namespace declaration attributes
1107                                        // to be bound to "http://www.w3.org/2000/xmlns/"
1108                                        // So as long as the XML parser doesn't do it, it needs to
1109                                        // be done here.
1110                    const XMLCh * qualifiedName = attr->getFullName();
1111
1112                    // int colonPos = -1;
1113                    unsigned int attrURIId = fScanner->getUriResolver()->resolveUriId(qualifiedName); // fScanner->resolveQName(qualifiedName, prefixBuf, ElemStack::Mode_Attribute, colonPos);
1114
1115                    if (attrURIId == XMLNamespaceResolver::fEmptyUriId)
1116                    {
1117                        namespaceURI = 0;
1118                        if (XMLString::equals(qualifiedName, XMLUni::fgXMLNSString))
1119                        {
1120                            // xmlns=...
1121                            namespaceURI = fScanner->getURIText(XMLNamespaceResolver::fXMLNSUriId);
1122                        }
1123                    }
1124                    else // if (attrURIId != XMLNamespaceResolver::fEmptyUriId)
1125                    {
1126                        namespaceURI = fScanner->getURIText(attrURIId);
1127                    }
1128
1129                    insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(namespaceURI, qualifiedName);
1130
1131                                        DOMAttr* remAttr = elemImpl->setDefaultAttributeNodeNS(insertAttr);
1132                                        if (remAttr)
1133                                                remAttr->release();
1134                                }
1135                                else
1136                                {
1137                                        // Namespaces is turned off...
1138                                        insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
1139
1140                                        DOMNode* remAttr = elemImpl->setDefaultAttributeNode(insertAttr);
1141                                        if (remAttr)
1142                                                remAttr->release();
1143                                }
1144                                //need to do this before the get as otherwise we overwrite any value in the attr
1145                                if (attr->getValue() != 0)
1146                                {
1147                                        insertAttr->setValueFast(attr->getValue());
1148                                        insertAttr->setSpecified(false);
1149                                }
1150
1151                                // store DTD validation information
1152                                if(fCreateSchemaInfo)
1153                                {
1154                                        switch(attr->getType())
1155                                        {
1156                        case XMLAttDef::CData:          insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
1157                        case XMLAttDef::ID:             insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
1158                        case XMLAttDef::IDRef:          insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
1159                        case XMLAttDef::IDRefs:         insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
1160                        case XMLAttDef::Entity:         insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
1161                        case XMLAttDef::Entities:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
1162                        case XMLAttDef::NmToken:        insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
1163                        case XMLAttDef::NmTokens:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
1164                        case XMLAttDef::Notation:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
1165                        case XMLAttDef::Enumeration:    insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
1166                        default:                        insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
1167                                        }
1168                                }
1169                        }
1170
1171                        insertAttr = 0;
1172                        attr->reset();
1173                }
1174        }
1175
1176        if (fCurrentParent != fDocument)
1177                castToParentImpl (fCurrentParent)->appendChildFast (elem);
1178        else
1179                fCurrentParent->appendChild (elem);
1180
1181        fCurrentParent = elem;
1182        fCurrentNode = elem;
1183        fWithinElement = true;
1184
1185        // If an empty element, do end right now (no endElement() will be called)
1186        if (isEmpty)
1187                endElement(elemDecl, urlId, isRoot, elemPrefix);
1188}
1189
1190
1191void AbstractDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
1192{
1193        const XMLCh * entName = entDecl.getName();
1194        DOMNamedNodeMap *entities = fDocumentType->getEntities();
1195        DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
1196        if (entity)
1197                entity->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
1198        fCurrentEntity = entity;
1199
1200
1201        // Following line has been moved up so that erImpl is only declared
1202        // and used if create entity ref flag is true
1203        if (fCreateEntityReferenceNodes == true)    {
1204                DOMEntityReference *er = fDocument->createEntityReferenceByParser(entName);
1205
1206                //set the readOnly flag to false before appending node, will be reset
1207                // in endEntityReference
1208                DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
1209                erImpl->setReadOnly(false, true);
1210
1211                castToParentImpl (fCurrentParent)->appendChildFast (er);
1212
1213                fCurrentParent = er;
1214                fCurrentNode = er;
1215
1216        // this entityRef needs to be stored in Entity map too.
1217        // We'd decide later whether the entity nodes should be created by a
1218        // separated method in parser or not. For now just stick it in if
1219        // the ref nodes are created
1220                if (entity)
1221                        entity->setEntityRef(er);
1222        }
1223}
1224
1225
1226void AbstractDOMParser::XMLDecl(const   XMLCh* const version
1227                                                                , const XMLCh* const encoding
1228                                                                , const XMLCh* const standalone
1229                                                                , const XMLCh* const actualEncStr)
1230{
1231        fDocument->setXmlStandalone(XMLString::equals(XMLUni::fgYesString, standalone));
1232        fDocument->setXmlVersion(version);
1233        fDocument->setXmlEncoding(encoding);
1234        fDocument->setInputEncoding(actualEncStr);
1235}
1236
1237// ---------------------------------------------------------------------------
1238//  AbstractDOMParser: Helper methods
1239// ---------------------------------------------------------------------------
1240
1241//doctypehandler interfaces
1242void AbstractDOMParser::attDef
1243(
1244        const   DTDElementDecl&     elemDecl
1245        , const DTDAttDef&          attDef
1246        , const bool
1247)
1248{
1249        if (fDocumentType->isIntSubsetReading())
1250        {
1251                if (elemDecl.hasAttDefs())
1252                {
1253                        fInternalSubset.append(attDef.getFullName());
1254
1255                        // Get the type and display it
1256                        const XMLAttDef::AttTypes type = attDef.getType();
1257                        switch(type)
1258                        {
1259                        case XMLAttDef::CData :
1260                                fInternalSubset.append(chSpace);
1261                                fInternalSubset.append(XMLUni::fgCDATAString);
1262                                break;
1263                        case XMLAttDef::ID :
1264                                fInternalSubset.append(chSpace);
1265                                fInternalSubset.append(XMLUni::fgIDString);
1266                                break;
1267                        case XMLAttDef::IDRef :
1268                                fInternalSubset.append(chSpace);
1269                                fInternalSubset.append(XMLUni::fgIDRefString);
1270                                break;
1271                        case XMLAttDef::IDRefs :
1272                                fInternalSubset.append(chSpace);
1273                                fInternalSubset.append(XMLUni::fgIDRefsString);
1274                                break;
1275                        case XMLAttDef::Entity :
1276                                fInternalSubset.append(chSpace);
1277                                fInternalSubset.append(XMLUni::fgEntityString);
1278                                break;
1279                        case XMLAttDef::Entities :
1280                                fInternalSubset.append(chSpace);
1281                                fInternalSubset.append(XMLUni::fgEntitiesString);
1282                                break;
1283                        case XMLAttDef::NmToken :
1284                                fInternalSubset.append(chSpace);
1285                                fInternalSubset.append(XMLUni::fgNmTokenString);
1286                                break;
1287                        case XMLAttDef::NmTokens :
1288                                fInternalSubset.append(chSpace);
1289                                fInternalSubset.append(XMLUni::fgNmTokensString);
1290                                break;
1291
1292                        case XMLAttDef::Notation :
1293                                fInternalSubset.append(chSpace);
1294                                fInternalSubset.append(XMLUni::fgNotationString);
1295                                break;
1296
1297                        case XMLAttDef::Enumeration :
1298                                {
1299                                        fInternalSubset.append(chSpace);
1300                                        const XMLCh* enumString = attDef.getEnumeration();
1301                                        XMLSize_t length = XMLString::stringLen(enumString);
1302                                        if (length > 0) {
1303
1304                                                fInternalSubset.append(chOpenParen );
1305                                                for(XMLSize_t i=0; i<length; i++) {
1306                                                        if (enumString[i] == chSpace)
1307                                                                fInternalSubset.append(chPipe);
1308                                                        else
1309                                                                fInternalSubset.append(enumString[i]);
1310                                                }
1311                                                fInternalSubset.append(chCloseParen);
1312                                        }
1313                                }
1314                                break;
1315                        default:
1316                                // remaining types don't belong to a DTD
1317                                break;
1318                        }
1319                        //get te default types of the attlist
1320                        const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
1321                        switch(def)
1322                        {
1323                        case XMLAttDef::Required :
1324                                fInternalSubset.append(chSpace);
1325                                fInternalSubset.append(XMLUni::fgRequiredString);
1326                                break;
1327                        case XMLAttDef::Implied :
1328                                fInternalSubset.append(chSpace);
1329                                fInternalSubset.append(XMLUni::fgImpliedString);
1330                                break;
1331                        case XMLAttDef::Fixed :
1332                                fInternalSubset.append(chSpace);
1333                                fInternalSubset.append(XMLUni::fgFixedString);
1334                                break;
1335                        default:
1336                                // remaining types don't belong to a DTD
1337                                break;
1338                        }
1339
1340                        const XMLCh* defaultValue = attDef.getValue();
1341                        if (defaultValue != 0) {
1342                                fInternalSubset.append(chSpace);
1343                                fInternalSubset.append(chDoubleQuote);
1344                                fInternalSubset.append(defaultValue);
1345                                fInternalSubset.append(chDoubleQuote);
1346                        }
1347                }
1348        }
1349}
1350
1351void AbstractDOMParser::doctypeComment
1352(
1353        const   XMLCh* const    comment
1354)
1355{
1356        if (fDocumentType->isIntSubsetReading())
1357        {
1358                if (comment != 0)
1359                {
1360                        fInternalSubset.append(XMLUni::fgCommentString);
1361                        fInternalSubset.append(chSpace);
1362                        fInternalSubset.append(comment);
1363                        fInternalSubset.append(chSpace);
1364                        fInternalSubset.append(chDash);
1365                        fInternalSubset.append(chDash);
1366                        fInternalSubset.append(chCloseAngle);
1367                }
1368        }
1369}
1370
1371void AbstractDOMParser::doctypeDecl
1372(
1373        const   DTDElementDecl& elemDecl
1374        , const XMLCh* const    publicId
1375        , const XMLCh* const    systemId
1376        , const bool
1377        , const bool
1378)
1379{
1380        fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
1381        fDocument->setDocumentType(fDocumentType);
1382
1383}
1384
1385void AbstractDOMParser::doctypePI
1386(
1387        const   XMLCh* const    target
1388        , const XMLCh* const    data
1389)
1390{
1391        if (fDocumentType->isIntSubsetReading())
1392        {
1393                //add these chars to internalSubset variable
1394                fInternalSubset.append(chOpenAngle);
1395                fInternalSubset.append(chQuestion);
1396                fInternalSubset.append(target);
1397                fInternalSubset.append(chSpace);
1398                fInternalSubset.append(data);
1399                fInternalSubset.append(chQuestion);
1400                fInternalSubset.append(chCloseAngle);
1401        }
1402}
1403
1404
1405void AbstractDOMParser::doctypeWhitespace
1406(
1407        const   XMLCh* const    chars
1408        , const XMLSize_t       length
1409)
1410{
1411        if (fDocumentType->isIntSubsetReading())
1412                fInternalSubset.append(chars, length);
1413}
1414
1415void AbstractDOMParser::elementDecl
1416(
1417        const   DTDElementDecl& decl
1418        , const bool
1419)
1420{
1421        if (fDocumentType->isIntSubsetReading())
1422        {
1423                fInternalSubset.append(chOpenAngle);
1424                fInternalSubset.append(chBang);
1425                fInternalSubset.append(XMLUni::fgElemString);
1426                fInternalSubset.append(chSpace);
1427                fInternalSubset.append(decl.getFullName());
1428
1429                //get the ContentSpec information
1430                const XMLCh* contentModel = decl.getFormattedContentModel();
1431                if (contentModel != 0) {
1432                        fInternalSubset.append(chSpace);
1433                        fInternalSubset.append(contentModel);
1434                }
1435
1436                fInternalSubset.append(chCloseAngle);
1437        }
1438}
1439
1440void AbstractDOMParser::endAttList
1441(
1442        const   DTDElementDecl& elemDecl
1443)
1444{
1445        if (fDocumentType->isIntSubsetReading())
1446        {
1447                //print the closing angle
1448                fInternalSubset.append(chCloseAngle);
1449        }
1450
1451        // this section sets up default attributes.
1452        // default attribute nodes are stored in a NamedNodeMap DocumentTypeImpl::elements
1453        // default attribute data attached to the document is used to conform to the
1454        // DOM spec regarding creating element nodes & removing attributes with default values
1455        // see DocumentTypeImpl
1456        if (elemDecl.hasAttDefs())
1457        {
1458                XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
1459                XMLAttDef* attr = 0;
1460
1461                DOMAttrImpl * insertAttr = 0;
1462                DOMElement     *elem  = fDocument->createElement(elemDecl.getFullName());
1463                DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
1464                bool doNamespaces = fScanner->getDoNamespaces();
1465
1466                for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
1467                {
1468                        attr = &defAttrs->getAttDef(i);
1469                        if (attr->getValue() != 0)
1470                        {
1471                                if (doNamespaces)
1472                                {
1473                                        // DOM Level 2 wants all namespace declaration attributes
1474                                        // to be bound to "http://www.w3.org/2000/xmlns/"
1475                                        // So as long as the XML parser doesn't do it, it needs to
1476                                        // done here.
1477                                        const XMLCh* qualifiedName = attr->getFullName();
1478                                        int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
1479
1480                                        XMLBufBid bbQName(&fBufMgr);
1481                                        XMLBuffer& buf = bbQName.getBuffer();
1482                                        static const XMLCh XMLNS[] = {
1483                                                chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
1484
1485                                        if (index > 0) {
1486                                                // there is prefix
1487                                                // map to XML URI for all cases except when prefix == "xmlns"
1488                                                XMLCh* prefix;
1489                                                XMLCh temp[1000];
1490
1491                                                if (index > 999)
1492                                                        prefix = (XMLCh*) fMemoryManager->allocate
1493                                                        (
1494                                                                (index + 1) * sizeof(XMLCh)
1495                                                        );//new XMLCh[index+1];
1496                                                else
1497                                                        prefix = temp;
1498
1499                                                XMLString::subString(prefix ,qualifiedName, 0, index, fMemoryManager);
1500
1501                                                if (XMLString::equals(prefix,XMLNS))
1502                                                        buf.append(XMLUni::fgXMLNSURIName);
1503                                                else
1504                                                        buf.append(XMLUni::fgXMLURIName);
1505
1506                                                if (index > 999)
1507                                                        fMemoryManager->deallocate(prefix);//delete [] prefix;
1508                                        }
1509                                        else {
1510                                                //   No prefix
1511                                                if (XMLString::equals(qualifiedName,XMLNS))
1512                                                        buf.append(XMLUni::fgXMLNSURIName);
1513                                        }
1514
1515                                        insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
1516                                           buf.getRawBuffer(),     // NameSpaceURI
1517                                           qualifiedName);   // qualified name
1518
1519                                        DOMNode* remAttr = elemImpl->setAttributeNodeNS(insertAttr);
1520                                        if (remAttr)
1521                                                remAttr->release();
1522                                }
1523                                else
1524                                {
1525                                        // Namespaces is turned off...
1526                                        insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
1527                                        DOMNode* remAttr = elemImpl->setAttributeNode(insertAttr);
1528                                        if (remAttr)
1529                                                remAttr->release();
1530                                }
1531
1532                                insertAttr->setValueFast(attr->getValue());
1533                                insertAttr->setSpecified(false);
1534                        }
1535                }
1536                DOMNode* rem = fDocumentType->getElements()->setNamedItem(elemImpl);
1537                if (rem)
1538                        rem->release();
1539        }
1540}
1541
1542void AbstractDOMParser::endIntSubset()
1543{
1544        fDocumentType->setInternalSubset(fInternalSubset.getRawBuffer());
1545        // the buffer shouldn't be released as it is reused in the next parse
1546        // fBufMgr.releaseBuffer(fInternalSubset);
1547        fDocumentType->fIntSubsetReading = false;
1548}
1549
1550void AbstractDOMParser::endExtSubset()
1551{
1552}
1553
1554void AbstractDOMParser::entityDecl
1555(
1556        const   DTDEntityDecl&  entityDecl
1557        , const bool
1558        , const bool
1559)
1560{
1561        DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
1562
1563        entity->setPublicId(entityDecl.getPublicId());
1564        entity->setSystemId(entityDecl.getSystemId());
1565        entity->setNotationName(entityDecl.getNotationName());
1566        entity->setBaseURI(entityDecl.getBaseURI());
1567
1568        DOMEntityImpl *previousDef = (DOMEntityImpl *)
1569                fDocumentType->getEntities()->setNamedItem( entity );
1570
1571        if (previousDef)
1572                previousDef->release();
1573
1574        if (fDocumentType->isIntSubsetReading())
1575        {
1576                //add thes chars to internalSubset variable
1577                fInternalSubset.append(chOpenAngle);
1578                fInternalSubset.append(chBang);
1579                fInternalSubset.append(XMLUni::fgEntityString);
1580                fInternalSubset.append(chSpace);
1581
1582                fInternalSubset.append(entityDecl.getName());
1583
1584                const XMLCh* id = entity->getPublicId();
1585                if (id != 0) {
1586                        fInternalSubset.append(chSpace);
1587                        fInternalSubset.append(XMLUni::fgPubIDString);
1588                        fInternalSubset.append(chSpace);
1589                        fInternalSubset.append(chDoubleQuote);
1590                        fInternalSubset.append(id);
1591                        fInternalSubset.append(chDoubleQuote);
1592                }
1593                id = entity->getSystemId();
1594                if (id != 0) {
1595                        fInternalSubset.append(chSpace);
1596                        fInternalSubset.append(XMLUni::fgSysIDString);
1597                        fInternalSubset.append(chSpace);
1598                        fInternalSubset.append(chDoubleQuote);
1599                        fInternalSubset.append(id);
1600                        fInternalSubset.append(chDoubleQuote);
1601
1602                }
1603                id = entity->getNotationName();
1604                if (id != 0) {
1605                        fInternalSubset.append(chSpace);
1606                        fInternalSubset.append(XMLUni::fgNDATAString);
1607                        fInternalSubset.append(chSpace);
1608                        fInternalSubset.append(id);
1609                }
1610                id = entityDecl.getValue();
1611                if (id !=0) {
1612                        fInternalSubset.append(chSpace);
1613                        fInternalSubset.append(chDoubleQuote);
1614                        fInternalSubset.append(id);
1615                        fInternalSubset.append(chDoubleQuote);
1616                }
1617
1618                fInternalSubset.append(chCloseAngle);
1619        }
1620
1621}
1622
1623void AbstractDOMParser::resetDocType()
1624{
1625        fDocumentType = 0;
1626}
1627
1628void AbstractDOMParser::notationDecl
1629(
1630        const   XMLNotationDecl&    notDecl
1631        , const bool
1632)
1633{
1634        DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
1635        notation->setPublicId(notDecl.getPublicId());
1636        notation->setSystemId(notDecl.getSystemId());
1637        notation->setBaseURI(notDecl.getBaseURI());
1638
1639        DOMNode* rem = fDocumentType->getNotations()->setNamedItem( notation );
1640        if (rem)
1641                rem->release();
1642
1643        if (fDocumentType->isIntSubsetReading())
1644        {
1645                //add thes chars to internalSubset variable
1646                fInternalSubset.append(chOpenAngle);
1647                fInternalSubset.append(chBang);
1648                fInternalSubset.append(XMLUni::fgNotationString);
1649                fInternalSubset.append(chSpace);
1650
1651                fInternalSubset.append(notDecl.getName());
1652
1653                const XMLCh* id = notation->getPublicId();
1654                if (id != 0) {
1655                        fInternalSubset.append(chSpace);
1656                        fInternalSubset.append(XMLUni::fgPubIDString);
1657                        fInternalSubset.append(chSpace);
1658                        fInternalSubset.append(chDoubleQuote);
1659                        fInternalSubset.append(id);
1660                        fInternalSubset.append(chDoubleQuote);
1661                }
1662                id = notation->getSystemId();
1663                if (id != 0) {
1664                        fInternalSubset.append(chSpace);
1665                        fInternalSubset.append(XMLUni::fgSysIDString);
1666                        fInternalSubset.append(chSpace);
1667                        fInternalSubset.append(chDoubleQuote);
1668                        fInternalSubset.append(id);
1669                        fInternalSubset.append(chDoubleQuote);
1670
1671                }
1672                fInternalSubset.append(chCloseAngle);
1673        }
1674}
1675
1676void AbstractDOMParser::startAttList
1677(
1678        const   DTDElementDecl& elemDecl
1679)
1680{
1681        if (fDocumentType->isIntSubsetReading())
1682        {
1683                fInternalSubset.append(chOpenAngle);
1684                fInternalSubset.append(chBang);
1685                fInternalSubset.append(XMLUni::fgAttListString);
1686                fInternalSubset.append(chSpace);
1687                fInternalSubset.append(elemDecl.getFullName());
1688        }
1689}
1690
1691void AbstractDOMParser::startIntSubset()
1692{
1693        fDocumentType->fIntSubsetReading = true;
1694}
1695
1696void AbstractDOMParser::startExtSubset()
1697{
1698}
1699
1700void AbstractDOMParser::TextDecl
1701(
1702        const   XMLCh* const    versionStr
1703        , const XMLCh* const    encodingStr
1704)
1705{
1706        if (fCurrentEntity) {
1707                fCurrentEntity->setXmlVersion(versionStr);
1708                fCurrentEntity->setXmlEncoding(encodingStr);
1709        }
1710}
1711
1712DOMCDATASection* AbstractDOMParser::
1713createCDATASection (const XMLCh* s, XMLSize_t n)
1714{
1715  return new (fDocument, DOMMemoryManager::CDATA_SECTION_OBJECT)
1716        DOMCDATASectionImpl(fDocument, s, n);
1717}
1718
1719
1720DOMText* AbstractDOMParser::
1721createText (const XMLCh* s, XMLSize_t n)
1722{
1723  return new (fDocument, DOMMemoryManager::TEXT_OBJECT)
1724        DOMTextImpl(fDocument, s, n);
1725}
1726
1727
1728DOMElement* AbstractDOMParser::
1729createElement (const XMLCh* name)
1730{
1731  return new (fDocument, DOMMemoryManager::ELEMENT_OBJECT)
1732        DOMElementImpl(fDocument, name);
1733}
1734
1735DOMElement* AbstractDOMParser::
1736createElementNS (const XMLCh* namespaceURI,
1737                                 const XMLCh* elemPrefix,
1738                                 const XMLCh* localName,
1739                                 const XMLCh* qName)
1740{
1741  return new (fDocument, DOMMemoryManager::ELEMENT_NS_OBJECT)
1742        DOMElementNSImpl (fDocument,
1743                                          namespaceURI,
1744                                          elemPrefix,
1745                                          localName,
1746                                          qName);
1747}
1748
1749DOMAttr* AbstractDOMParser::
1750createAttr (const XMLCh* name)
1751{
1752  return new (fDocument, DOMMemoryManager::ATTR_OBJECT)
1753        DOMAttrImpl(fDocument, name);
1754}
1755
1756DOMAttr* AbstractDOMParser::
1757createAttrNS (const XMLCh* namespaceURI,
1758                          const XMLCh* elemPrefix,
1759                          const XMLCh* localName,
1760                          const XMLCh* qName)
1761{
1762  return new (fDocument, DOMMemoryManager::ATTR_NS_OBJECT)
1763        DOMAttrNSImpl (fDocument,
1764                                   namespaceURI,
1765                                   elemPrefix,
1766                                   localName,
1767                                   qName);
1768}
1769
1770XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.