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

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

Changes to icxercesc files

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