Changeset 3178


Ignore:
Timestamp:
May 23, 2013, 6:08:50 AM (5 years ago)
Author:
cameron
Message:

Penultimate check-in for icXML 0.9

Location:
icXML/icXML-devel/src
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • icXML/icXML-devel/src/Makefile.am

    r3157 r3178  
    800800        xercesc/util/Mutexes.cpp \
    801801        xercesc/util/PanicHandler.cpp \
    802         xercesc/util/PlatformUtils.cpp \
     802        icxercesc/util/PlatformUtils.cpp \
    803803        xercesc/util/PSVIUni.cpp \
    804804        icxercesc/util/QName.cpp \
  • icXML/icXML-devel/src/Makefile.in

    r3157 r3178  
    21302130        xercesc/util/Mutexes.cpp \
    21312131        xercesc/util/PanicHandler.cpp \
    2132         xercesc/util/PlatformUtils.cpp \
     2132        icxercesc/util/PlatformUtils.cpp \
    21332133        xercesc/util/PSVIUni.cpp \
    21342134        icxercesc/util/QName.cpp \
  • icXML/icXML-devel/src/icxercesc/framework/XMLBuffer.cpp

    r3157 r3178  
    8585}
    8686
    87 void XMLBuffer::set(const XMLCh* const chars)
    88 {
    89     fIndex = 0;
    90     if (chars != 0 && *chars != 0)
    91         append(chars);
    92 }
    93 
    9487XERCES_CPP_NAMESPACE_END
    9588
  • icXML/icXML-devel/src/icxercesc/framework/XMLBuffer.hpp

    r3157 r3178  
    174174        }
    175175
    176     void set (const XMLCh* const chars);
    177 
    178     void set (const XMLCh ch)
     176    inline void set(const XMLCh* const chars)
     177    {
     178        fIndex = 0;
     179        if (chars != 0 && *chars != 0)
     180            append(chars);
     181    }
     182
     183    inline void set (const XMLCh ch)
    179184    {
    180185        fBuffer[0] = ch;
     
    182187    }
    183188
    184     void fill(const XMLCh value, const XMLSize_t count)
     189    inline void fill(const XMLCh value, const XMLSize_t count)
    185190    {
    186191        if (unlikely(count >= fCapacity))
     
    193198    }
    194199
    195         const XMLCh* getRawBuffer() const
     200    inline const XMLCh* getRawBuffer() const
    196201        {
    197202                fBuffer[fIndex] = 0;
     
    199204        }
    200205
    201         XMLCh* getRawBuffer()
     206    inline XMLCh* getRawBuffer()
    202207        {
    203208                fBuffer[fIndex] = 0;
    204209                return fBuffer;
    205210        }
    206 
    207     XMLCh* getInternalBuffer()
    208     {
    209         return fBuffer;
    210     }
    211211
    212212        void reset()
  • icXML/icXML-devel/src/icxercesc/internal/MemoryManagerImpl.cpp

    r3150 r3178  
    2626#include <icxercesc/internal/MemoryManagerImpl.hpp>
    2727#include <xercesc/util/OutOfMemoryException.hpp>
    28 #include <simd-lib/builtins.hpp>
    29 #include <icxmlc/XMLConfig.hpp>
    30 #include <icxmlc/Array.hpp>
    3128
    3229XERCES_CPP_NAMESPACE_BEGIN
     
    3431MemoryManager* MemoryManagerImpl::getExceptionMemoryManager()
    3532{
    36         return this;
     33  return this;
    3734}
    3835
    3936void* MemoryManagerImpl::allocate(XMLSize_t size)
    4037{
    41         void* p;
    42 
    43         try
    44         {
    45         p = ::operator new(size);
    46         if (likely(p != NULL))
    47         {
    48             return p;
    49         }
    50         }
    51         catch (...)
    52         {
    53 
    54         }
     38    void* memptr;
     39    try {
     40        memptr = ::operator new(size);
     41    }
     42    catch(...) {
     43        throw OutOfMemoryException();
     44    }
     45    if (memptr != NULL) {
     46        return memptr;
     47    }
    5548    throw OutOfMemoryException();
    5649}
     
    5851void MemoryManagerImpl::deallocate(void* p)
    5952{
    60     ::operator delete(p);
     53    if (p)
     54        ::operator delete(p);
    6155}
    6256
  • icXML/icXML-devel/src/icxercesc/internal/MemoryManagerImpl.hpp

    r3107 r3178  
    4040public:
    4141
    42         /** @name Constructor */
    43         //@{
     42    /** @name Constructor */
     43    //@{
    4444
    45         /**
    46           * Default constructor
    47           */
    48         MemoryManagerImpl()
    49         {
    50         }
    51         //@}
     45    /**
     46      * Default constructor
     47      */
     48    MemoryManagerImpl()
     49    {
     50    }
     51    //@}
    5252
    53         /** @name Destructor */
    54         //@{
     53    /** @name Destructor */
     54    //@{
    5555
    56         /**
    57           * Default destructor
    58           */
    59         virtual ~MemoryManagerImpl()
    60         {
    61         }
    62         //@}
     56    /**
     57      * Default destructor
     58      */
     59    virtual ~MemoryManagerImpl()
     60    {
     61    }
     62    //@}
    6363
    6464
    65         /**
    66           * This method is called to obtain the memory manager that should be
    67           * used to allocate memory used in exceptions.
    68           *
    69           * @return A pointer to the memory manager
    70           */
    71         virtual MemoryManager* getExceptionMemoryManager();
     65    /**
     66      * This method is called to obtain the memory manager that should be
     67      * used to allocate memory used in exceptions.
     68      *
     69      * @return A pointer to the memory manager
     70      */
     71    virtual MemoryManager* getExceptionMemoryManager();
    7272
    7373
    74         /** @name The virtual methods in MemoryManager */
    75         //@{
     74    /** @name The virtual methods in MemoryManager */
     75    //@{
    7676
    77         /**
    78           * This method allocates requested memory.
    79           *
    80           * @param size The requested memory size
    81           *
    82           * @return A pointer to the allocated memory
    83           */
    84         virtual void* allocate(XMLSize_t size);
     77    /**
     78      * This method allocates requested memory.
     79      *
     80      * @param size The requested memory size
     81      *
     82      * @return A pointer to the allocated memory
     83      */
     84    virtual void* allocate(XMLSize_t size);
    8585
    86         /**
    87           * This method deallocates memory
    88           *
    89           * @param p The pointer to the allocated memory to be deleted
    90           */
    91         virtual void deallocate(void* p);
     86    /**
     87      * This method deallocates memory
     88      *
     89      * @param p The pointer to the allocated memory to be deleted
     90      */
     91    virtual void deallocate(void* p);
    9292
    93         //@}
     93    //@}
    9494
    9595private:
    96         // -----------------------------------------------------------------------
    97         //  Unimplemented constructors and operators
    98         // -----------------------------------------------------------------------
    99         MemoryManagerImpl(const MemoryManagerImpl&);
    100         MemoryManagerImpl& operator=(const MemoryManagerImpl&);
     96    // -----------------------------------------------------------------------
     97    //  Unimplemented constructors and operators
     98    // -----------------------------------------------------------------------
     99    MemoryManagerImpl(const MemoryManagerImpl&);
     100    MemoryManagerImpl& operator=(const MemoryManagerImpl&);
    101101
    102102};
  • icXML/icXML-devel/src/icxercesc/parsers/AbstractDOMParser.cpp

    r2774 r3178  
    7979
    8080AbstractDOMParser::AbstractDOMParser( XMLValidator* const   valToAdopt
    81                                                                         , MemoryManager* const  manager
    82                                                                         , XMLGrammarPool* const gramPool) :
     81                                    , MemoryManager* const  manager
     82                                    , XMLGrammarPool* const gramPool) :
    8383
    8484  fCreateEntityReferenceNodes(true)
     
    9999, fDocumentVector(0)
    100100, fGrammarResolver(0)
     101, fURIStringPool(0)
    101102, fValidator(valToAdopt)
    102103, fMemoryManager(manager)
     
    106107, fPSVIHandler(0)
    107108{
    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();
     109    CleanupType cleanup(this, &AbstractDOMParser::cleanUp);
     110
     111    try
     112    {
     113        initialize();
     114    }
     115    catch(const OutOfMemoryException&)
     116    {
     117        // Don't cleanup when out of memory, since executing the
     118        // code can cause problems.
     119        cleanup.release();
     120
     121        throw;
     122    }
     123
     124    cleanup.release();
    124125}
    125126
     
    127128AbstractDOMParser::~AbstractDOMParser()
    128129{
    129         cleanUp();
     130    cleanUp();
    130131}
    131132
     
    135136void AbstractDOMParser::initialize()
    136137{
    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();
     138    //  Create grammar resolver and string pool to pass to the scanner
     139    fGrammarResolver = new (fMemoryManager) GrammarResolver(fGrammarPool, fMemoryManager);
     140
     141    //  Create a scanner and tell it what validator to use. Then set us
     142    //  as the document event handler so we can fill the DOM document.
     143    fScanner = XMLScannerResolver::getDefaultScanner(fValidator, fGrammarResolver, fMemoryManager);
     144    fScanner->setDocHandler(this);
     145    fScanner->setDocTypeHandler(this);
     146
     147    this->reset();
    146148}
    147149
    148150void AbstractDOMParser::cleanUp()
    149151{
    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;
     152    if (fDocumentVector)
     153        delete fDocumentVector;
     154
     155    if (!fDocumentAdoptedByUser && fDocument)
     156        fDocument->release();
     157
     158    delete fScanner;
     159    delete fGrammarResolver;
     160    // grammar pool *always* owns this
     161    //delete fURIStringPool;
     162    fMemoryManager->deallocate(fImplementationFeatures);
     163
     164    if (fValidator)
     165        delete fValidator;
    164166}
    165167
     
    169171void AbstractDOMParser::reset()
    170172{
    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();
     173    // if fDocument exists already, store the old pointer in the vector for deletion later
     174    if (fDocument && !fDocumentAdoptedByUser) {
     175        if (!fDocumentVector) {
     176            // allocate the vector if not exists yet
     177            fDocumentVector  = new (fMemoryManager) RefVectorOf<DOMDocumentImpl>(10, true, fMemoryManager) ;
     178        }
     179        fDocumentVector->addElement(fDocument);
     180    }
     181
     182    fDocument = 0;
     183    resetDocType();
     184    fCurrentParent   = 0;
     185    fCurrentNode     = 0;
     186    fCurrentEntity   = 0;
     187    fWithinElement   = false;
     188    fDocumentAdoptedByUser = false;
     189    fInternalSubset.reset();
    188190}
    189191
     
    191193void AbstractDOMParser::resetInProgress()
    192194{
    193         fParseInProgress = false;
     195    fParseInProgress = false;
    194196}
    195197
     
    197199void AbstractDOMParser::resetPool()
    198200{
    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;
     201    //  We cannot enter here while a regular parse is in progress.
     202    if (fParseInProgress)
     203        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     204
     205    if (fDocumentVector)
     206        fDocumentVector->removeAllElements();
     207
     208    if (!fDocumentAdoptedByUser && fDocument)
     209        fDocument->release();
     210
     211    fDocument = 0;
    210212}
    211213
    212214bool AbstractDOMParser::isDocumentAdopted() const
    213215{
    214         return fDocumentAdoptedByUser;
     216    return fDocumentAdoptedByUser;
    215217}
    216218
    217219DOMDocument* AbstractDOMParser::adoptDocument()
    218220{
    219         fDocumentAdoptedByUser = true;
    220         return fDocument;
     221    fDocumentAdoptedByUser = true;
     222    return fDocument;
    221223}
    222224
     
    227229DOMDocument* AbstractDOMParser::getDocument()
    228230{
    229         return fDocument;
     231    return fDocument;
    230232}
    231233
    232234const XMLValidator& AbstractDOMParser::getValidator() const
    233235{
    234         return *fScanner->getValidator();
     236    return *fScanner->getValidator();
    235237}
    236238
    237239bool AbstractDOMParser::getDoNamespaces() const
    238240{
    239         return fScanner->getDoNamespaces();
     241    return fScanner->getDoNamespaces();
    240242}
    241243
    242244bool AbstractDOMParser::getGenerateSyntheticAnnotations() const
    243245{
    244         return fScanner->getGenerateSyntheticAnnotations();
     246    return fScanner->getGenerateSyntheticAnnotations();
    245247}
    246248
    247249bool AbstractDOMParser::getValidateAnnotations() const
    248250{
    249         return fScanner->getValidateAnnotations();
     251    return fScanner->getValidateAnnotations();
    250252}
    251253
    252254bool AbstractDOMParser::getExitOnFirstFatalError() const
    253255{
    254         return fScanner->getExitOnFirstFatal();
     256    return fScanner->getExitOnFirstFatal();
    255257}
    256258
    257259bool AbstractDOMParser::getValidationConstraintFatal() const
    258260{
    259         return fScanner->getValidationConstraintFatal();
     261    return fScanner->getValidationConstraintFatal();
    260262}
    261263
    262264AbstractDOMParser::ValSchemes AbstractDOMParser::getValidationScheme() const
    263265{
    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;
     266    const XMLScanner::ValSchemes scheme = fScanner->getValidationScheme();
     267
     268    if (scheme == XMLScanner::Val_Always)
     269        return Val_Always;
     270    else if (scheme == XMLScanner::Val_Never)
     271        return Val_Never;
     272
     273    return Val_Auto;
    272274}
    273275
    274276bool AbstractDOMParser::getDoSchema() const
    275277{
    276         return fScanner->getDoSchema();
     278    return fScanner->getDoSchema();
    277279}
    278280
    279281bool AbstractDOMParser::getValidationSchemaFullChecking() const
    280282{
    281         return fScanner->getValidationSchemaFullChecking();
     283    return fScanner->getValidationSchemaFullChecking();
    282284}
    283285
    284286bool AbstractDOMParser::getIdentityConstraintChecking() const
    285287{
    286         return fScanner->getIdentityConstraintChecking();
     288    return fScanner->getIdentityConstraintChecking();
    287289}
    288290
    289291XMLSize_t AbstractDOMParser::getErrorCount() const
    290292{
    291         return fScanner->getErrorCount();
     293    return fScanner->getErrorCount();
    292294}
    293295
    294296XMLCh* AbstractDOMParser::getExternalSchemaLocation() const
    295297{
    296         return fScanner->getExternalSchemaLocation();
     298    return fScanner->getExternalSchemaLocation();
    297299}
    298300
    299301XMLCh* AbstractDOMParser::getExternalNoNamespaceSchemaLocation() const
    300302{
    301         return fScanner->getExternalNoNamespaceSchemaLocation();
     303    return fScanner->getExternalNoNamespaceSchemaLocation();
    302304}
    303305
    304306SecurityManager* AbstractDOMParser::getSecurityManager() const
    305307{
    306         return fScanner->getSecurityManager();
     308    return fScanner->getSecurityManager();
    307309}
    308310
     
    311313const XMLSize_t& AbstractDOMParser::getLowWaterMark() const
    312314{
    313         return fScanner->getLowWaterMark();
     315    return fScanner->getLowWaterMark();
    314316}
    315317
    316318bool AbstractDOMParser::getLoadExternalDTD() const
    317319{
    318         return fScanner->getLoadExternalDTD();
     320    return fScanner->getLoadExternalDTD();
    319321}
    320322
    321323bool AbstractDOMParser::getLoadSchema() const
    322324{
    323         return fScanner->getLoadSchema();
     325    return fScanner->getLoadSchema();
    324326}
    325327
    326328bool AbstractDOMParser::getCalculateSrcOfs() const
    327329{
    328         return fScanner->getCalculateSrcOfs();
     330    return fScanner->getCalculateSrcOfs();
    329331}
    330332
    331333bool AbstractDOMParser::getStandardUriConformant() const
    332334{
    333         return fScanner->getStandardUriConformant();
     335    return fScanner->getStandardUriConformant();
    334336}
    335337
    336338bool AbstractDOMParser::getIgnoreAnnotations() const
    337339{
    338         return fScanner->getIgnoreAnnotations();
     340    return fScanner->getIgnoreAnnotations();
    339341}
    340342
    341343bool AbstractDOMParser::getDisableDefaultEntityResolution() const
    342344{
    343         return fScanner->getDisableDefaultEntityResolution();
     345    return fScanner->getDisableDefaultEntityResolution();
    344346}
    345347
    346348bool AbstractDOMParser::getSkipDTDValidation() const
    347349{
    348         return fScanner->getSkipDTDValidation();
     350    return fScanner->getSkipDTDValidation();
    349351}
    350352
    351353bool AbstractDOMParser::getHandleMultipleImports() const
    352354{
    353         return fScanner->getHandleMultipleImports();
     355    return fScanner->getHandleMultipleImports();
    354356}
    355357
     
    359361void AbstractDOMParser::setPSVIHandler(PSVIHandler* const handler)
    360362{
    361         fPSVIHandler = handler;
    362         if (fPSVIHandler) {
    363                 fScanner->setPSVIHandler(this);
    364         }
    365         else if(!fCreateSchemaInfo) {
    366                 fScanner->setPSVIHandler(0);
    367         }
     363    fPSVIHandler = handler;
     364    if (fPSVIHandler) {
     365        fScanner->setPSVIHandler(this);
     366    }
     367    else if(!fCreateSchemaInfo) {
     368        fScanner->setPSVIHandler(0);
     369    }
    368370}
    369371
     
    371373void AbstractDOMParser::setDoNamespaces(const bool newState)
    372374{
    373         fScanner->setDoNamespaces(newState);
     375    fScanner->setDoNamespaces(newState);
    374376}
    375377
    376378void AbstractDOMParser::setGenerateSyntheticAnnotations(const bool newState)
    377379{
    378         fScanner->setGenerateSyntheticAnnotations(newState);
     380    fScanner->setGenerateSyntheticAnnotations(newState);
    379381}
    380382
    381383void AbstractDOMParser::setValidateAnnotations(const bool newState)
    382384{
    383         fScanner->setValidateAnnotations(newState);
     385    fScanner->setValidateAnnotations(newState);
    384386}
    385387
    386388void AbstractDOMParser::setExitOnFirstFatalError(const bool newState)
    387389{
    388         fScanner->setExitOnFirstFatal(newState);
     390    fScanner->setExitOnFirstFatal(newState);
    389391}
    390392
    391393void AbstractDOMParser::setValidationConstraintFatal(const bool newState)
    392394{
    393         fScanner->setValidationConstraintFatal(newState);
     395    fScanner->setValidationConstraintFatal(newState);
    394396}
    395397
    396398void AbstractDOMParser::setValidationScheme(const ValSchemes newScheme)
    397399{
    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);
     400    if (newScheme == Val_Never)
     401        fScanner->setValidationScheme(XMLScanner::Val_Never);
     402    else if (newScheme == Val_Always)
     403        fScanner->setValidationScheme(XMLScanner::Val_Always);
     404    else
     405        fScanner->setValidationScheme(XMLScanner::Val_Auto);
    404406}
    405407
    406408void AbstractDOMParser::setDoSchema(const bool newState)
    407409{
    408         fScanner->setDoSchema(newState);
     410    fScanner->setDoSchema(newState);
    409411}
    410412
    411413void AbstractDOMParser::setValidationSchemaFullChecking(const bool schemaFullChecking)
    412414{
    413         fScanner->setValidationSchemaFullChecking(schemaFullChecking);
     415    fScanner->setValidationSchemaFullChecking(schemaFullChecking);
    414416}
    415417
    416418void AbstractDOMParser::setIdentityConstraintChecking(const bool identityConstraintChecking)
    417419{
    418         fScanner->setIdentityConstraintChecking(identityConstraintChecking);
     420    fScanner->setIdentityConstraintChecking(identityConstraintChecking);
    419421}
    420422
    421423void AbstractDOMParser::setExternalSchemaLocation(const XMLCh* const schemaLocation)
    422424{
    423         fScanner->setExternalSchemaLocation(schemaLocation);
     425    fScanner->setExternalSchemaLocation(schemaLocation);
    424426}
    425427void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation)
    426428{
    427         fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
     429    fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
    428430}
    429431
    430432void AbstractDOMParser::setExternalSchemaLocation(const char* const schemaLocation)
    431433{
    432         fScanner->setExternalSchemaLocation(schemaLocation);
     434    fScanner->setExternalSchemaLocation(schemaLocation);
    433435}
    434436void AbstractDOMParser::setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation)
    435437{
    436         fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
     438    fScanner->setExternalNoNamespaceSchemaLocation(noNamespaceSchemaLocation);
    437439}
    438440
    439441void AbstractDOMParser::setSecurityManager(SecurityManager* const securityManager)
    440442{
    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);
     443    // since this could impact various components, don't permit it to change
     444    // during a parse
     445    if (fParseInProgress)
     446        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     447
     448    fScanner->setSecurityManager(securityManager);
    447449}
    448450
    449451void AbstractDOMParser::setLowWaterMark(XMLSize_t lwm)
    450452{
    451         fScanner->setLowWaterMark(lwm);
     453    fScanner->setLowWaterMark(lwm);
    452454}
    453455
    454456void AbstractDOMParser::setLoadExternalDTD(const bool newState)
    455457{
    456         fScanner->setLoadExternalDTD(newState);
     458    fScanner->setLoadExternalDTD(newState);
    457459}
    458460
    459461void AbstractDOMParser::setLoadSchema(const bool newState)
    460462{
    461         fScanner->setLoadSchema(newState);
     463    fScanner->setLoadSchema(newState);
    462464}
    463465
    464466void AbstractDOMParser::setCalculateSrcOfs(const bool newState)
    465467{
    466         fScanner->setCalculateSrcOfs(newState);
     468    fScanner->setCalculateSrcOfs(newState);
    467469}
    468470
    469471void AbstractDOMParser::setStandardUriConformant(const bool newState)
    470472{
    471         fScanner->setStandardUriConformant(newState);
     473    fScanner->setStandardUriConformant(newState);
    472474}
    473475
    474476void AbstractDOMParser::useScanner(const XMLCh* const scannerName)
    475477{
    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         }
     478    XMLScanner* tempScanner = XMLScannerResolver::resolveScanner
     479    (
     480        scannerName
     481        , fValidator
     482        , fGrammarResolver
     483        , fMemoryManager
     484    );
     485
     486    if (tempScanner) {
     487
     488        tempScanner->setParseSettings(fScanner);
     489        tempScanner->setURIStringPool(fURIStringPool);
     490        delete fScanner;
     491        fScanner = tempScanner;
     492    }
    490493}
    491494
    492495void AbstractDOMParser::setCreateSchemaInfo(const bool create)
    493496{
    494         fCreateSchemaInfo = create;
    495         if(fCreateSchemaInfo)
    496                 fScanner->setPSVIHandler(this);
    497         else if(!fPSVIHandler)
    498                 fScanner->setPSVIHandler(0);
     497    fCreateSchemaInfo = create;
     498    if(fCreateSchemaInfo)
     499        fScanner->setPSVIHandler(this);
     500    else if(!fPSVIHandler)
     501        fScanner->setPSVIHandler(0);
    499502}
    500503
    501504void AbstractDOMParser::setIgnoreAnnotations(const bool newValue)
    502505{
    503         fScanner->setIgnoreAnnotations(newValue);
     506    fScanner->setIgnoreAnnotations(newValue);
    504507}
    505508
    506509void AbstractDOMParser::setDisableDefaultEntityResolution(const bool newValue)
    507510{
    508         fScanner->setDisableDefaultEntityResolution(newValue);
     511    fScanner->setDisableDefaultEntityResolution(newValue);
    509512}
    510513
    511514void AbstractDOMParser::setSkipDTDValidation(const bool newValue)
    512515{
    513         fScanner->setSkipDTDValidation(newValue);
     516    fScanner->setSkipDTDValidation(newValue);
    514517}
    515518
    516519void AbstractDOMParser::setHandleMultipleImports(const bool newValue)
    517520{
    518         fScanner->setHandleMultipleImports(newValue);
     521    fScanner->setHandleMultipleImports(newValue);
    519522}
    520523
    521524void AbstractDOMParser::setDocument(DOMDocument* toSet)
    522525{
    523         fDocument = (DOMDocumentImpl *)toSet;
     526    fDocument = (DOMDocumentImpl *)toSet;
    524527}
    525528
     
    529532void AbstractDOMParser::parse(const InputSource& source)
    530533{
    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         }
     534    // Avoid multiple entrance
     535    if (fParseInProgress)
     536        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     537
     538    ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
     539
     540    try
     541    {
     542        fParseInProgress = true;
     543        fScanner->scanDocument(source);
     544
     545        if (fDoXInclude && getErrorCount()==0){
     546                    DOMDocument *doc = getDocument();
     547            // after XInclude, the document must be normalized
     548            if(doc)
     549                doc->normalizeDocument();
     550        }
     551    }
     552    catch(const OutOfMemoryException&)
     553    {
     554        resetInProgress.release();
     555
     556        throw;
     557    }
    555558}
    556559
    557560void AbstractDOMParser::parse(const XMLCh* const systemId)
    558561{
    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         }
     562    // Avoid multiple entrance
     563    if (fParseInProgress)
     564        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     565
     566    ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
     567
     568    try
     569    {
     570        fParseInProgress = true;
     571        fScanner->scanDocument(systemId);
     572
     573        if (fDoXInclude && getErrorCount()==0){
     574                    DOMDocument *doc = getDocument();
     575            // after XInclude, the document must be normalized
     576            if(doc)
     577                doc->normalizeDocument();
     578        }
     579    }
     580    catch(const OutOfMemoryException&)
     581    {
     582        resetInProgress.release();
     583
     584        throw;
     585    }
    583586}
    584587
    585588void AbstractDOMParser::parse(const char* const systemId)
    586589{
    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         }
     590    // Avoid multiple entrance
     591    if (fParseInProgress)
     592        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     593
     594    ResetInProgressType     resetInProgress(this, &AbstractDOMParser::resetInProgress);
     595
     596    try
     597    {
     598        fParseInProgress = true;
     599        fScanner->scanDocument(systemId);
     600
     601        if (fDoXInclude && getErrorCount()==0){
     602                    DOMDocument *doc = getDocument();
     603            // after XInclude, the document must be normalized
     604            if(doc)
     605                doc->normalizeDocument();
     606        }
     607    }
     608    catch(const OutOfMemoryException&)
     609    {
     610        resetInProgress.release();
     611
     612        throw;
     613    }
    611614}
    612615
     
    617620// ---------------------------------------------------------------------------
    618621bool 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);
     622                                   ,       XMLPScanToken&  toFill)
     623{
     624    //
     625    //  Avoid multiple entrance. We cannot enter here while a regular parse
     626    //  is in progress.
     627    //
     628    if (fParseInProgress)
     629        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     630
     631    return fScanner->scanFirst(systemId, toFill);
    629632}
    630633
    631634bool 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);
     635                                   ,       XMLPScanToken&      toFill)
     636{
     637    //
     638    //  Avoid multiple entrance. We cannot enter here while a regular parse
     639    //  is in progress.
     640    //
     641    if (fParseInProgress)
     642        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     643
     644    return fScanner->scanFirst(systemId, toFill);
    642645}
    643646
    644647bool 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);
     648                                   ,       XMLPScanToken&  toFill)
     649{
     650    //
     651    //  Avoid multiple entrance. We cannot enter here while a regular parse
     652    //  is in progress.
     653    //
     654    if (fParseInProgress)
     655        ThrowXMLwithMemMgr(IOException, XMLExcepts::Gen_ParseInProgress, fMemoryManager);
     656
     657    return fScanner->scanFirst(source, toFill);
    655658}
    656659
    657660bool AbstractDOMParser::parseNext(XMLPScanToken& token)
    658661{
    659         return fScanner->scanNext(token);
     662    return fScanner->scanNext(token);
    660663}
    661664
    662665void AbstractDOMParser::parseReset(XMLPScanToken& token)
    663666{
    664         // Reset the scanner, and then reset the parser
    665         fScanner->scanReset(token);
    666         reset();
     667    // Reset the scanner, and then reset the parser
     668    fScanner->scanReset(token);
     669    reset();
    667670}
    668671
     
    672675// ---------------------------------------------------------------------------
    673676void 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);
     677                                        , const XMLCh* const            uri
     678                                        ,       PSVIElement *           elementInfo)
     679{
     680    // associate the info now; if the user wants, she can override what we did
     681    if(fCreateSchemaInfo)
     682    {
     683        DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
     684        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, elementInfo->getValidity());
     685        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, elementInfo->getValidationAttempted());
     686        if(elementInfo->getTypeDefinition())
     687        {
     688            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, elementInfo->getTypeDefinition()->getTypeCategory());
     689            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, elementInfo->getTypeDefinition()->getAnonymous());
     690            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
     691                fDocument->getPooledString(elementInfo->getTypeDefinition()->getNamespace()));
     692            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
     693                fDocument->getPooledString(elementInfo->getTypeDefinition()->getName()));
     694        }
     695        else if(elementInfo->getValidity()==PSVIItem::VALIDITY_VALID)
     696        {
     697            // if we are valid but we don't have a type validator, we are xs:anyType
     698            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::COMPLEX_TYPE);
     699            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
     700            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
     701            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgATTVAL_ANYTYPE);
     702        }
     703        if(elementInfo->getMemberTypeDefinition())
     704        {
     705            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, elementInfo->getMemberTypeDefinition()->getAnonymous());
     706            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
     707                fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getNamespace()));
     708            typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
     709                fDocument->getPooledString(elementInfo->getMemberTypeDefinition()->getName()));
     710        }
     711        if(elementInfo->getElementDeclaration())
     712            typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Nil, elementInfo->getElementDeclaration()->getNillable());
     713        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(elementInfo->getSchemaDefault()));
     714        typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(elementInfo->getSchemaNormalizedValue()));
     715        typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
     716        ((DOMElementNSImpl*)fCurrentParent)->setSchemaTypeInfo(typeInfo);
     717    }
     718    if(fPSVIHandler)
     719        fPSVIHandler->handleElementPSVI(localName, uri, elementInfo);
    717720}
    718721
    719722void AbstractDOMParser::handlePartialElementPSVI(const XMLCh* const            localName
    720                                                                                            , const XMLCh* const            uri
    721                                                                                            ,       PSVIElement *           elementInfo)
    722 {
    723         if(fPSVIHandler)
    724                 fPSVIHandler->handlePartialElementPSVI(localName, uri, elementInfo);
     723                                               , const XMLCh* const            uri
     724                                               ,       PSVIElement *           elementInfo)
     725{
     726    if(fPSVIHandler)
     727        fPSVIHandler->handlePartialElementPSVI(localName, uri, elementInfo);
    725728}
    726729
    727730void 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);
     731                                            , const XMLCh* const            uri
     732                                            ,       PSVIAttributeList *     psviAttributes)
     733{
     734    if(fCreateSchemaInfo)
     735    {
     736        for (XMLSize_t index=0; index < psviAttributes->getLength(); index++) {
     737            XERCES_CPP_NAMESPACE_QUALIFIER PSVIAttribute *attrInfo=psviAttributes->getAttributePSVIAtIndex(index);
     738            XERCES_CPP_NAMESPACE_QUALIFIER DOMNode* pAttrNode=fCurrentNode->getAttributes()->getNamedItemNS(psviAttributes->getAttributeNamespaceAtIndex(index),
     739                                                                                                            psviAttributes->getAttributeNameAtIndex(index));
     740            if(pAttrNode!=NULL)
     741            {
     742                DOMTypeInfoImpl* typeInfo=new (getDocument()) DOMTypeInfoImpl();
     743                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validity, attrInfo->getValidity());
     744                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Validation_Attempted, attrInfo->getValidationAttempted());
     745                if(attrInfo->getTypeDefinition())
     746                {
     747                    typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
     748                    typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, attrInfo->getTypeDefinition()->getAnonymous());
     749                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace,
     750                        fDocument->getPooledString(attrInfo->getTypeDefinition()->getNamespace()));
     751                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name,
     752                        fDocument->getPooledString(attrInfo->getTypeDefinition()->getName()));
     753                }
     754                else if(attrInfo->getValidity()==PSVIItem::VALIDITY_VALID)
     755                {
     756                    // if we are valid but we don't have a type validator, we are xs:anySimpleType
     757                    typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Type, XSTypeDefinition::SIMPLE_TYPE);
     758                    typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Anonymous, false);
     759                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Namespace, SchemaSymbols::fgURI_SCHEMAFORSCHEMA);
     760                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Type_Definition_Name, SchemaSymbols::fgDT_ANYSIMPLETYPE);
     761                }
     762                if(attrInfo->getMemberTypeDefinition())
     763                {
     764                    typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Anonymous, attrInfo->getMemberTypeDefinition()->getAnonymous());
     765                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Namespace,
     766                        fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getNamespace()));
     767                    typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Member_Type_Definition_Name,
     768                        fDocument->getPooledString(attrInfo->getMemberTypeDefinition()->getName()));
     769                }
     770                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Default, fDocument->getPooledString(attrInfo->getSchemaDefault()));
     771                typeInfo->setStringProperty(DOMPSVITypeInfo::PSVI_Schema_Normalized_Value, fDocument->getPooledString(attrInfo->getSchemaNormalizedValue()));
     772                typeInfo->setNumericProperty(DOMPSVITypeInfo::PSVI_Schema_Specified, true);
     773                ((DOMAttrImpl*)pAttrNode)->setSchemaTypeInfo(typeInfo);
     774            }
     775        }
     776    }
     777    // associate the info now; if the user wants, she can override what we did
     778    if(fPSVIHandler)
     779        fPSVIHandler->handleAttributesPSVI(localName, uri, psviAttributes);
    777780}
    778781
     
    781784// ---------------------------------------------------------------------------
    782785void 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         }
     786                              , const XMLSize_t    length
     787                              , const bool         cdataSection)
     788{
     789    // Ignore chars outside of content
     790    if (!fWithinElement)
     791        return;
     792
     793    if (cdataSection == true)
     794    {
     795        DOMCDATASection *node = createCDATASection (chars, length);
     796        castToParentImpl (fCurrentParent)->appendChildFast (node);
     797        fCurrentNode = node;
     798    }
     799    else
     800    {
     801        if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
     802        {
     803            DOMTextImpl *node = (DOMTextImpl*)fCurrentNode;
     804            node->appendData(chars, length);
     805        }
     806        else
     807        {
     808            DOMText *node = createText (chars, length);
     809            castToParentImpl (fCurrentParent)->appendChildFast (node);
     810            fCurrentNode = node;
     811        }
     812    }
    810813}
    811814
     
    813816void AbstractDOMParser::docComment(const XMLCh* const comment)
    814817{
    815         if (fCreateCommentNodes) {
    816                 DOMComment *dcom = fDocument->createComment(comment);
    817                 castToParentImpl (fCurrentParent)->appendChildFast (dcom);
    818                 fCurrentNode = dcom;
    819         }
     818    if (fCreateCommentNodes) {
     819        DOMComment *dcom = fDocument->createComment(comment);
     820        castToParentImpl (fCurrentParent)->appendChildFast (dcom);
     821        fCurrentNode = dcom;
     822    }
    820823}
    821824
    822825
    823826void 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;
     827                      , const XMLCh* const    data)
     828{
     829    DOMProcessingInstruction *pi = fDocument->createProcessingInstruction
     830        (
     831        target
     832        , data
     833        );
     834    castToParentImpl (fCurrentParent)->appendChildFast (pi);
     835    fCurrentNode = pi;
    833836}
    834837
     
    836839void AbstractDOMParser::endEntityReference(const XMLEntityDecl&)
    837840{
    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);
     841    if (!fCreateEntityReferenceNodes)
     842      return;
     843
     844    DOMEntityReferenceImpl *erImpl = 0;
     845
     846    if (fCurrentParent->getNodeType() == DOMNode::ENTITY_REFERENCE_NODE)
     847        erImpl = (DOMEntityReferenceImpl *) fCurrentParent;
     848
     849    fCurrentNode   = fCurrentParent;
     850    fCurrentParent = fCurrentNode->getParentNode ();
     851
     852    // When the document is invalid but we continue parsing, we may
     853    // end up seeing more 'end' events than the 'start' ones.
     854    //
     855    if (fCurrentParent == 0 && fDocument != 0)
     856    {
     857      fCurrentNode = fDocument->getDocumentElement ();
     858      fCurrentParent = fCurrentNode;
     859    }
     860
     861    if (erImpl)
     862        erImpl->setReadOnly(true, true);
    860863}
    861864
    862865
    863866void 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         }
     867                           , const unsigned int
     868                           , const bool
     869                           , const XMLCh* const)
     870{
     871    fCurrentNode   = fCurrentParent;
     872    fCurrentParent = fCurrentNode->getParentNode ();
     873
     874    // When the document is invalid but we continue parsing, we may
     875    // end up seeing more 'end' events than the 'start' ones.
     876    //
     877    if (fCurrentParent == 0 && fDocument != 0)
     878    {
     879      fCurrentNode = fDocument->getDocumentElement ();
     880      fCurrentParent = fCurrentNode;
     881    }
     882
     883    // If we've hit the end of content, clear the flag.
     884    //
     885    if (fCurrentParent == fDocument)
     886        fWithinElement = false;
     887
     888    if(fDoXInclude &&
     889       (XIncludeUtils::isXIIncludeDOMNode(fCurrentNode) ||
     890        ((XIncludeUtils::isXIFallbackDOMNode(fCurrentNode) &&
     891          !XMLString::equals(fCurrentParent->getNamespaceURI(), XIncludeUtils::fgXIIIncludeNamespaceURI)))))
     892    {
     893        XIncludeUtils xiu((XMLErrorReporter *) this);
     894            // process the XInclude node, then update the fCurrentNode with the new content
     895            if(xiu.parseDOMNodeDoingXInclude(fCurrentNode, fDocument, getScanner()->getEntityHandler()))
     896            fCurrentNode = fCurrentParent->getLastChild();
     897    }
    895898}
    896899
    897900
    898901void 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;
     902                                            , const XMLSize_t       length
     903                                            , const bool)
     904{
     905    // Ignore chars before the root element
     906    if (!fWithinElement || !fIncludeIgnorableWhitespace)
     907        return;
     908
     909    // revisit.  Not safe to slam in a null like this.
     910    XMLCh savedChar = chars[length];
     911    XMLCh *ncChars  = (XMLCh *)chars;   // cast off const
     912    ncChars[length] = chNull;
     913
     914    if (fCurrentNode->getNodeType() == DOMNode::TEXT_NODE)
     915    {
     916        DOMText *node = (DOMText *)fCurrentNode;
     917        node->appendData(chars);
     918    }
     919    else
     920    {
     921        DOMTextImpl *node = (DOMTextImpl *)fDocument->createTextNode(chars);
     922        node->setIgnorableWhitespace(true);
     923        castToParentImpl (fCurrentParent)->appendChildFast (node);
     924
     925        fCurrentNode = node;
     926    }
     927    ncChars[length] = savedChar;
    925928}
    926929
     
    928931void AbstractDOMParser::resetDocument()
    929932{
    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();
     933    //
     934    //  The reset methods are called before a new parse event occurs.
     935    //  Reset this parsers state to clear out anything that may be left
     936    //  from a previous use, in particular the DOM document itself.
     937    //
     938    this->reset();
    936939}
    937940
     
    939942void AbstractDOMParser::startDocument()
    940943{
    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());
     944    if(fImplementationFeatures == 0)
     945        fDocument = (DOMDocumentImpl *)DOMImplementation::getImplementation()->createDocument(fMemoryManager);
     946    else
     947        fDocument = (DOMDocumentImpl *)DOMImplementationRegistry::getDOMImplementation(fImplementationFeatures)->createDocument(fMemoryManager);
     948
     949    // Just set the document as the current parent and current node
     950    fCurrentParent = fDocument;
     951    fCurrentNode   = fDocument;
     952    // set DOM error checking off
     953    fDocument->setErrorChecking(false);
     954    fDocument->setDocumentURI(fScanner->getLocator()->getSystemId());
     955    fDocument->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
    953956}
    954957
     
    956959void AbstractDOMParser::endDocument()
    957960{
    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);
     961    // set DOM error checking back on
     962    fDocument->setErrorChecking(true);
     963
     964    // DOM L2 does not support editing DocumentType nodes
     965    if (fDocumentType && fScanner -> getDoNamespaces())
     966        fDocumentType->setReadOnly(true, true);
    964967}
    965968
    966969
    967970void 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)
     971                             , const unsigned int            urlId
     972                             , const XMLCh* const            elemPrefix
     973                             , const RefVectorOf<XMLAttr>&   attrList
     974                             , const XMLSize_t               attrCount
     975                             , const bool                    isEmpty
     976                             , const bool                    isRoot)
     977{
     978    DOMElement     *elem;
     979    DOMElementImpl *elemImpl;
     980    const XMLCh* namespaceURI = 0;
     981    bool doNamespaces = fScanner->getDoNamespaces();
     982
     983    // Create the element name. Here we are going to bypass the
     984    // DOMDocument::createElement() interface and instantiate the
     985    // required types directly in order to avoid name checking
     986    // overhead.
     987    //
     988    if (doNamespaces)
     989    {
     990        //DOM Level 2, doNamespaces on
     991        //
     992        const XMLCh* localName = elemDecl.getBaseName();
     993
     994        if (urlId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
     995
     996            namespaceURI = fScanner->getURIText(urlId); //get namespaceURI
     997
     998            if (elemPrefix && *elemPrefix)
     999            {
     1000                XMLBufBid elemQName(&fBufMgr);
     1001
     1002                elemQName.set(elemPrefix);
     1003                elemQName.append(chColon);
     1004                elemQName.append(localName);
     1005
     1006                elem = createElementNS (
     1007                  namespaceURI, elemPrefix, localName, elemQName.getRawBuffer());
     1008            }
     1009            else
     1010              elem = createElementNS (namespaceURI, 0, localName, localName);
     1011        }
     1012        else
     1013          elem = createElementNS (namespaceURI, 0, localName, localName);
     1014    }
     1015    else
     1016    {   //DOM Level 1
     1017        elem = createElement (elemDecl.getFullName());
     1018    }
     1019
     1020    elemImpl = (DOMElementImpl *) elem;
     1021
     1022    if (attrCount)
     1023    {
     1024      unsigned int xmlnsNSId = fScanner->getXMLNSNamespaceId();
     1025      unsigned int emptyNSId = fScanner->getEmptyNamespaceId();
     1026
     1027      DOMAttrMapImpl* map = elemImpl->fAttributes;
     1028      map->reserve (attrCount);
     1029
     1030      for (XMLSize_t index = 0; index < attrCount; ++index)
     1031      {
     1032        const XMLAttr* oneAttrib = attrList.elementAt(index);
     1033        DOMAttrImpl *attr = 0;
     1034
     1035        if (doNamespaces)
     1036        {
     1037            //DOM Level 2, doNamespaces on
     1038            //
     1039            unsigned int attrURIId = oneAttrib->getURIId();
     1040            const XMLCh* localName = oneAttrib->getName();
     1041            const XMLCh* prefix = oneAttrib->getPrefix();
     1042            namespaceURI = 0;
     1043
     1044            if ((prefix==0 || *prefix==0) && XMLString::equals(localName, XMLUni::fgXMLNSString))
     1045            {
     1046                // xmlns=...
     1047                attrURIId = xmlnsNSId;
     1048            }
     1049            if (attrURIId != emptyNSId)
     1050            {
     1051                //TagName has a prefix
     1052                namespaceURI = fScanner->getURIText(attrURIId);
     1053            }
     1054
     1055            attr = (DOMAttrImpl*) createAttrNS (namespaceURI,
     1056                                                prefix,
     1057                                                localName,
     1058                                                oneAttrib->getQName());
     1059
     1060            map->setNamedItemNSFast(attr);
     1061        }
     1062        else
     1063        {
     1064            attr = (DOMAttrImpl*) createAttr (oneAttrib->getName());
     1065            map->setNamedItemFast(attr);
     1066        }
     1067
     1068        attr->setValueFast(oneAttrib->getValue());
     1069
     1070        // Attributes of type ID.  If this is one, add it to the hashtable of IDs
     1071        //   that is constructed for use by GetElementByID().
     1072        //
     1073        if (oneAttrib->getType()==XMLAttDef::ID)
     1074        {
     1075            if (fDocument->fNodeIDMap == 0)
     1076                fDocument->fNodeIDMap = new (fDocument) DOMNodeIDMap(500, fDocument);
     1077            fDocument->fNodeIDMap->add(attr);
     1078            attr->fNode.isIdAttr(true);
     1079        }
     1080
     1081        attr->setSpecified(oneAttrib->getSpecified());
     1082
     1083        // store DTD validation information
     1084        if(fCreateSchemaInfo)
     1085        {
     1086            switch(oneAttrib->getType())
     1087            {
     1088            case XMLAttDef::CData:          attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
     1089            case XMLAttDef::ID:             attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
     1090            case XMLAttDef::IDRef:          attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
     1091            case XMLAttDef::IDRefs:         attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
     1092            case XMLAttDef::Entity:         attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
     1093            case XMLAttDef::Entities:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
     1094            case XMLAttDef::NmToken:        attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
     1095            case XMLAttDef::NmTokens:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
     1096            case XMLAttDef::Notation:       attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
     1097            case XMLAttDef::Enumeration:    attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
     1098            default:                        attr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
     1099            }
     1100        }
     1101      }
     1102    }
     1103
     1104    //Set up the default attributes if any.
     1105    //
     1106    if (elemDecl.hasAttDefs())
     1107    {
     1108        XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
     1109        XMLAttDef* attr = 0;
     1110        DOMAttrImpl * insertAttr = 0;
     1111
     1112        for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
     1113        {
     1114            attr = &defAttrs->getAttDef(i);
     1115
     1116            const XMLAttDef::DefAttTypes defType = attr->getDefaultType();
     1117            if ((defType == XMLAttDef::Default)
     1118            ||  (defType == XMLAttDef::Fixed))
     1119            {
     1120
     1121                if (doNamespaces)
    10281122                {
    1029                     namespaceURI = 0;
    1030                     if (XMLString::equals(localName, XMLUni::fgXMLNSString))
     1123                    // DOM Level 2 wants all namespace declaration attributes
     1124                    // to be bound to "http://www.w3.org/2000/xmlns/"
     1125                    // So as long as the XML parser doesn't do it, it needs to
     1126                    // be done here.
     1127                    const XMLCh* qualifiedName = attr->getFullName();
     1128                    XMLBufBid bbPrefixQName(&fBufMgr);
     1129                    XMLBuffer& prefixBuf = bbPrefixQName.getBuffer();
     1130                    int colonPos = -1;
     1131                    unsigned int uriId = fScanner->resolveQName(qualifiedName, prefixBuf, ElemStack::Mode_Attribute, colonPos);
     1132
     1133                    const XMLCh* namespaceURI = 0;
     1134                    if (XMLString::equals(qualifiedName, XMLUni::fgXMLNSString))    //for xmlns=...
     1135                        uriId = fScanner->getXMLNSNamespaceId();
     1136                    if (uriId != fScanner->getEmptyNamespaceId()) {  //TagName has a prefix
     1137                        namespaceURI = fScanner->getURIText(uriId);
     1138                    }
     1139
     1140                    insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(namespaceURI,     // NameSpaceURI
     1141                                                                              qualifiedName);   // qualified name
     1142
     1143                    DOMAttr* remAttr = elemImpl->setDefaultAttributeNodeNS(insertAttr);
     1144                    if (remAttr)
     1145                        remAttr->release();
     1146                }
     1147                else
     1148                {
     1149                    // Namespaces is turned off...
     1150                    insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
     1151
     1152                    DOMNode* remAttr = elemImpl->setDefaultAttributeNode(insertAttr);
     1153                    if (remAttr)
     1154                        remAttr->release();
     1155                }
     1156                //need to do this before the get as otherwise we overwrite any value in the attr
     1157                if (attr->getValue() != 0)
     1158                {
     1159                    insertAttr->setValueFast(attr->getValue());
     1160                    insertAttr->setSpecified(false);
     1161                }
     1162
     1163                // store DTD validation information
     1164                if(fCreateSchemaInfo)
     1165                {
     1166                    switch(attr->getType())
    10311167                    {
    1032                         // xmlns=...
    1033                         namespaceURI = fScanner->getURIText(XMLNamespaceResolver::fXMLNSUriId);
     1168                    case XMLAttDef::CData:          insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedCDATAAttribute); break;
     1169                    case XMLAttDef::ID:             insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDAttribute); break;
     1170                    case XMLAttDef::IDRef:          insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFAttribute); break;
     1171                    case XMLAttDef::IDRefs:         insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedIDREFSAttribute); break;
     1172                    case XMLAttDef::Entity:         insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITYAttribute); break;
     1173                    case XMLAttDef::Entities:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENTITIESAttribute); break;
     1174                    case XMLAttDef::NmToken:        insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENAttribute); break;
     1175                    case XMLAttDef::NmTokens:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNMTOKENSAttribute); break;
     1176                    case XMLAttDef::Notation:       insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedNOTATIONAttribute); break;
     1177                    case XMLAttDef::Enumeration:    insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdValidatedENUMERATIONAttribute); break;
     1178                    default:                        insertAttr->setSchemaTypeInfo(&DOMTypeInfoImpl::g_DtdNotValidatedAttribute); break;
    10341179                    }
    10351180                }
    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);
     1181            }
     1182
     1183            insertAttr = 0;
     1184            attr->reset();
     1185        }
     1186    }
     1187
     1188    if (fCurrentParent != fDocument)
     1189      castToParentImpl (fCurrentParent)->appendChildFast (elem);
     1190    else
     1191      fCurrentParent->appendChild (elem);
     1192
     1193    fCurrentParent = elem;
     1194    fCurrentNode = elem;
     1195    fWithinElement = true;
     1196
     1197    // If an empty element, do end right now (no endElement() will be called)
     1198    if (isEmpty)
     1199        endElement(elemDecl, urlId, isRoot, elemPrefix);
    11881200}
    11891201
     
    11911203void AbstractDOMParser::startEntityReference(const XMLEntityDecl& entDecl)
    11921204{
    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         }
     1205    const XMLCh * entName = entDecl.getName();
     1206    DOMNamedNodeMap *entities = fDocumentType->getEntities();
     1207    DOMEntityImpl* entity = (DOMEntityImpl*)entities->getNamedItem(entName);
     1208    if (entity)
     1209        entity->setInputEncoding(fScanner->getReaderMgr()->getCurrentEncodingStr());
     1210    fCurrentEntity = entity;
     1211
     1212
     1213    // Following line has been moved up so that erImpl is only declared
     1214    // and used if create entity ref flag is true
     1215    if (fCreateEntityReferenceNodes == true)    {
     1216        DOMEntityReference *er = fDocument->createEntityReferenceByParser(entName);
     1217
     1218        //set the readOnly flag to false before appending node, will be reset
     1219        // in endEntityReference
     1220        DOMEntityReferenceImpl *erImpl = (DOMEntityReferenceImpl *) er;
     1221        erImpl->setReadOnly(false, true);
     1222
     1223        castToParentImpl (fCurrentParent)->appendChildFast (er);
     1224
     1225        fCurrentParent = er;
     1226        fCurrentNode = er;
     1227
     1228    // this entityRef needs to be stored in Entity map too.
     1229    // We'd decide later whether the entity nodes should be created by a
     1230    // separated method in parser or not. For now just stick it in if
     1231    // the ref nodes are created
     1232        if (entity)
     1233            entity->setEntityRef(er);
     1234    }
    12231235}
    12241236
    12251237
    12261238void 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);
     1239                                , const XMLCh* const encoding
     1240                                , const XMLCh* const standalone
     1241                                , const XMLCh* const actualEncStr)
     1242{
     1243    fDocument->setXmlStandalone(XMLString::equals(XMLUni::fgYesString, standalone));
     1244    fDocument->setXmlVersion(version);
     1245    fDocument->setXmlEncoding(encoding);
     1246    fDocument->setInputEncoding(actualEncStr);
    12351247}
    12361248
     
    12421254void AbstractDOMParser::attDef
    12431255(
    1244         const   DTDElementDecl&     elemDecl
    1245         , const DTDAttDef&          attDef
    1246         , const bool
     1256    const   DTDElementDecl&     elemDecl
     1257    , const DTDAttDef&          attDef
     1258    , const bool
    12471259)
    12481260{
    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         }
     1261    if (fDocumentType->isIntSubsetReading())
     1262    {
     1263        if (elemDecl.hasAttDefs())
     1264        {
     1265            fInternalSubset.append(attDef.getFullName());
     1266
     1267            // Get the type and display it
     1268            const XMLAttDef::AttTypes type = attDef.getType();
     1269            switch(type)
     1270            {
     1271            case XMLAttDef::CData :
     1272                fInternalSubset.append(chSpace);
     1273                fInternalSubset.append(XMLUni::fgCDATAString);
     1274                break;
     1275            case XMLAttDef::ID :
     1276                fInternalSubset.append(chSpace);
     1277                fInternalSubset.append(XMLUni::fgIDString);
     1278                break;
     1279            case XMLAttDef::IDRef :
     1280                fInternalSubset.append(chSpace);
     1281                fInternalSubset.append(XMLUni::fgIDRefString);
     1282                break;
     1283            case XMLAttDef::IDRefs :
     1284                fInternalSubset.append(chSpace);
     1285                fInternalSubset.append(XMLUni::fgIDRefsString);
     1286                break;
     1287            case XMLAttDef::Entity :
     1288                fInternalSubset.append(chSpace);
     1289                fInternalSubset.append(XMLUni::fgEntityString);
     1290                break;
     1291            case XMLAttDef::Entities :
     1292                fInternalSubset.append(chSpace);
     1293                fInternalSubset.append(XMLUni::fgEntitiesString);
     1294                break;
     1295            case XMLAttDef::NmToken :
     1296                fInternalSubset.append(chSpace);
     1297                fInternalSubset.append(XMLUni::fgNmTokenString);
     1298                break;
     1299            case XMLAttDef::NmTokens :
     1300                fInternalSubset.append(chSpace);
     1301                fInternalSubset.append(XMLUni::fgNmTokensString);
     1302                break;
     1303
     1304            case XMLAttDef::Notation :
     1305                fInternalSubset.append(chSpace);
     1306                fInternalSubset.append(XMLUni::fgNotationString);
     1307                break;
     1308
     1309            case XMLAttDef::Enumeration :
     1310                {
     1311                    fInternalSubset.append(chSpace);
     1312                    const XMLCh* enumString = attDef.getEnumeration();
     1313                    XMLSize_t length = XMLString::stringLen(enumString);
     1314                    if (length > 0) {
     1315
     1316                        fInternalSubset.append(chOpenParen );
     1317                        for(XMLSize_t i=0; i<length; i++) {
     1318                            if (enumString[i] == chSpace)
     1319                                fInternalSubset.append(chPipe);
     1320                            else
     1321                                fInternalSubset.append(enumString[i]);
     1322                        }
     1323                        fInternalSubset.append(chCloseParen);
     1324                    }
     1325                }
     1326                break;
     1327            default:
     1328                // remaining types don't belong to a DTD
     1329                break;
     1330            }
     1331            //get te default types of the attlist
     1332            const XMLAttDef::DefAttTypes def = attDef.getDefaultType();
     1333            switch(def)
     1334            {
     1335            case XMLAttDef::Required :
     1336                fInternalSubset.append(chSpace);
     1337                fInternalSubset.append(XMLUni::fgRequiredString);
     1338                break;
     1339            case XMLAttDef::Implied :
     1340                fInternalSubset.append(chSpace);
     1341                fInternalSubset.append(XMLUni::fgImpliedString);
     1342                break;
     1343            case XMLAttDef::Fixed :
     1344                fInternalSubset.append(chSpace);
     1345                fInternalSubset.append(XMLUni::fgFixedString);
     1346                break;
     1347            default:
     1348                // remaining types don't belong to a DTD
     1349                break;
     1350            }
     1351
     1352            const XMLCh* defaultValue = attDef.getValue();
     1353            if (defaultValue != 0) {
     1354                fInternalSubset.append(chSpace);
     1355                fInternalSubset.append(chDoubleQuote);
     1356                fInternalSubset.append(defaultValue);
     1357                fInternalSubset.append(chDoubleQuote);
     1358            }
     1359        }
     1360    }
    13491361}
    13501362
    13511363void AbstractDOMParser::doctypeComment
    13521364(
    1353         const   XMLCh* const    comment
     1365    const   XMLCh* const    comment
    13541366)
    13551367{
    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         }
     1368    if (fDocumentType->isIntSubsetReading())
     1369    {
     1370        if (comment != 0)
     1371        {
     1372            fInternalSubset.append(XMLUni::fgCommentString);
     1373            fInternalSubset.append(chSpace);
     1374            fInternalSubset.append(comment);
     1375            fInternalSubset.append(chSpace);
     1376            fInternalSubset.append(chDash);
     1377            fInternalSubset.append(chDash);
     1378            fInternalSubset.append(chCloseAngle);
     1379        }
     1380    }
    13691381}
    13701382
    13711383void AbstractDOMParser::doctypeDecl
    13721384(
    1373         const   DTDElementDecl& elemDecl
    1374         , const XMLCh* const    publicId
    1375         , const XMLCh* const    systemId
    1376         , const bool
    1377         , const bool
     1385    const   DTDElementDecl& elemDecl
     1386    , const XMLCh* const    publicId
     1387    , const XMLCh* const    systemId
     1388    , const bool
     1389    , const bool
    13781390)
    13791391{
    1380         fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
    1381         fDocument->setDocumentType(fDocumentType);
     1392    fDocumentType = (DOMDocumentTypeImpl *) fDocument->createDocumentType(elemDecl.getFullName(), publicId, systemId);
     1393    fDocument->setDocumentType(fDocumentType);
    13821394
    13831395}
     
    13851397void AbstractDOMParser::doctypePI
    13861398(
    1387         const   XMLCh* const    target
    1388         , const XMLCh* const    data
     1399    const   XMLCh* const    target
     1400    , const XMLCh* const    data
    13891401)
    13901402{
    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         }
     1403    if (fDocumentType->isIntSubsetReading())
     1404    {
     1405        //add these chars to internalSubset variable
     1406        fInternalSubset.append(chOpenAngle);
     1407        fInternalSubset.append(chQuestion);
     1408        fInternalSubset.append(target);
     1409        fInternalSubset.append(chSpace);
     1410        fInternalSubset.append(data);
     1411        fInternalSubset.append(chQuestion);
     1412        fInternalSubset.append(chCloseAngle);
     1413    }
    14021414}
    14031415
     
    14051417void AbstractDOMParser::doctypeWhitespace
    14061418(
    1407         const   XMLCh* const    chars
    1408         , const XMLSize_t       length
     1419    const   XMLCh* const    chars
     1420    , const XMLSize_t       length
    14091421)
    14101422{
    1411         if (fDocumentType->isIntSubsetReading())
    1412                 fInternalSubset.append(chars, length);
     1423    if (fDocumentType->isIntSubsetReading())
     1424        fInternalSubset.append(chars, length);
    14131425}
    14141426
    14151427void AbstractDOMParser::elementDecl
    14161428(
    1417         const   DTDElementDecl& decl
    1418         , const bool
     1429    const   DTDElementDecl& decl
     1430    , const bool
    14191431)
    14201432{
    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         }
     1433    if (fDocumentType->isIntSubsetReading())
     1434    {
     1435        fInternalSubset.append(chOpenAngle);
     1436        fInternalSubset.append(chBang);
     1437        fInternalSubset.append(XMLUni::fgElemString);
     1438        fInternalSubset.append(chSpace);
     1439        fInternalSubset.append(decl.getFullName());
     1440
     1441        //get the ContentSpec information
     1442        const XMLCh* contentModel = decl.getFormattedContentModel();
     1443        if (contentModel != 0) {
     1444            fInternalSubset.append(chSpace);
     1445            fInternalSubset.append(contentModel);
     1446        }
     1447
     1448        fInternalSubset.append(chCloseAngle);
     1449    }
    14381450}
    14391451
    14401452void AbstractDOMParser::endAttList
    14411453(
    1442         const   DTDElementDecl& elemDecl
     1454    const   DTDElementDecl& elemDecl
    14431455)
    14441456{
    1445         if (fDocumentType->isIntSubsetReading())
    1446         {
    1447                 //print the closing angle
    1448                 fInternalSubset.append(chCloseAngle);
    1449         }
     1457    if (fDocumentType->isIntSubsetReading())
     1458    {
     1459        //print the closing angle
     1460        fInternalSubset.append(chCloseAngle);
     1461    }
    14501462
    14511463        // this section sets up default attributes.
     
    14561468        if (elemDecl.hasAttDefs())
    14571469        {
    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         }
     1470        XMLAttDefList* defAttrs = &elemDecl.getAttDefList();
     1471        XMLAttDef* attr = 0;
     1472
     1473        DOMAttrImpl * insertAttr = 0;
     1474        DOMElement     *elem  = fDocument->createElement(elemDecl.getFullName());
     1475        DOMElementImpl *elemImpl = (DOMElementImpl *) elem;
     1476        bool doNamespaces = fScanner->getDoNamespaces();
     1477
     1478        for(XMLSize_t i=0; i<defAttrs->getAttDefCount(); i++)
     1479        {
     1480            attr = &defAttrs->getAttDef(i);
     1481            if (attr->getValue() != 0)
     1482            {
     1483                if (doNamespaces)
     1484                {
     1485                    // DOM Level 2 wants all namespace declaration attributes
     1486                    // to be bound to "http://www.w3.org/2000/xmlns/"
     1487                    // So as long as the XML parser doesn't do it, it needs to
     1488                    // done here.
     1489                    const XMLCh* qualifiedName = attr->getFullName();
     1490                    int index = DOMDocumentImpl::indexofQualifiedName(qualifiedName);
     1491
     1492                    XMLBufBid bbQName(&fBufMgr);
     1493                    XMLBuffer& buf = bbQName.getBuffer();
     1494                    static const XMLCh XMLNS[] = {
     1495                        chLatin_x, chLatin_m, chLatin_l, chLatin_n, chLatin_s, chNull};
     1496
     1497                    if (index > 0) {
     1498                        // there is prefix
     1499                        // map to XML URI for all cases except when prefix == "xmlns"
     1500                        XMLCh* prefix;
     1501                        XMLCh temp[1000];
     1502
     1503                        if (index > 999)
     1504                            prefix = (XMLCh*) fMemoryManager->allocate
     1505                            (
     1506                                (index + 1) * sizeof(XMLCh)
     1507                            );//new XMLCh[index+1];
     1508                        else
     1509                            prefix = temp;
     1510
     1511                        XMLString::subString(prefix ,qualifiedName, 0, index, fMemoryManager);
     1512
     1513                        if (XMLString::equals(prefix,XMLNS))
     1514                            buf.append(XMLUni::fgXMLNSURIName);
     1515                        else
     1516                            buf.append(XMLUni::fgXMLURIName);
     1517
     1518                        if (index > 999)
     1519                            fMemoryManager->deallocate(prefix);//delete [] prefix;
     1520                    }
     1521                    else {
     1522                        //   No prefix
     1523                        if (XMLString::equals(qualifiedName,XMLNS))
     1524                            buf.append(XMLUni::fgXMLNSURIName);
     1525                    }
     1526
     1527                    insertAttr = (DOMAttrImpl *) fDocument->createAttributeNS(
     1528                       buf.getRawBuffer(),     // NameSpaceURI
     1529                       qualifiedName);   // qualified name
     1530
     1531                    DOMNode* remAttr = elemImpl->setAttributeNodeNS(insertAttr);
     1532                    if (remAttr)
     1533                        remAttr->release();
     1534                }
     1535                else
     1536                {
     1537                    // Namespaces is turned off...
     1538                    insertAttr = (DOMAttrImpl *) fDocument->createAttribute(attr->getFullName());
     1539                    DOMNode* remAttr = elemImpl->setAttributeNode(insertAttr);
     1540                    if (remAttr)
     1541                        remAttr->release();
     1542                }
     1543
     1544                insertAttr->setValueFast(attr->getValue());
     1545                insertAttr->setSpecified(false);
     1546            }
     1547        }
     1548        DOMNode* rem = fDocumentType->getElements()->setNamedItem(elemImpl);
     1549        if (rem)
     1550            rem->release();
     1551    }
    15401552}
    15411553
    15421554void AbstractDOMParser::endIntSubset()
    15431555{
    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;
     1556    fDocumentType->setInternalSubset(fInternalSubset.getRawBuffer());
     1557    // the buffer shouldn't be released as it is reused in the next parse
     1558    // fBufMgr.releaseBuffer(fInternalSubset);
     1559    fDocumentType->fIntSubsetReading = false;
    15481560}
    15491561
     
    15541566void AbstractDOMParser::entityDecl
    15551567(
    1556         const   DTDEntityDecl&  entityDecl
    1557         , const bool
    1558         , const bool
     1568    const   DTDEntityDecl&  entityDecl
     1569    , const bool
     1570    , const bool
    15591571)
    15601572{
    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         }
     1573    DOMEntityImpl* entity = (DOMEntityImpl *) fDocument->createEntity(entityDecl.getName());
     1574
     1575    entity->setPublicId(entityDecl.getPublicId());
     1576    entity->setSystemId(entityDecl.getSystemId());
     1577    entity->setNotationName(entityDecl.getNotationName());
     1578    entity->setBaseURI(entityDecl.getBaseURI());
     1579
     1580    DOMEntityImpl *previousDef = (DOMEntityImpl *)
     1581            fDocumentType->getEntities()->setNamedItem( entity );
     1582
     1583    if (previousDef)
     1584        previousDef->release();
     1585
     1586    if (fDocumentType->isIntSubsetReading())
     1587    {
     1588        //add thes chars to internalSubset variable
     1589        fInternalSubset.append(chOpenAngle);
     1590        fInternalSubset.append(chBang);
     1591        fInternalSubset.append(XMLUni::fgEntityString);
     1592        fInternalSubset.append(chSpace);
     1593
     1594        fInternalSubset.append(entityDecl.getName());
     1595
     1596        const XMLCh* id = entity->getPublicId();
     1597        if (id != 0) {
     1598            fInternalSubset.append(chSpace);
     1599            fInternalSubset.append(XMLUni::fgPubIDString);
     1600            fInternalSubset.append(chSpace);
     1601            fInternalSubset.append(chDoubleQuote);
     1602            fInternalSubset.append(id);
     1603            fInternalSubset.append(chDoubleQuote);
     1604        }
     1605        id = entity->getSystemId();
     1606        if (id != 0) {
     1607            fInternalSubset.append(chSpace);
     1608            fInternalSubset.append(XMLUni::fgSysIDString);
     1609            fInternalSubset.append(chSpace);
     1610            fInternalSubset.append(chDoubleQuote);
     1611            fInternalSubset.append(id);
     1612            fInternalSubset.append(chDoubleQuote);
     1613
     1614        }
     1615        id = entity->getNotationName();
     1616        if (id != 0) {
     1617            fInternalSubset.append(chSpace);
     1618            fInternalSubset.append(XMLUni::fgNDATAString);
     1619            fInternalSubset.append(chSpace);
     1620            fInternalSubset.append(id);
     1621        }
     1622        id = entityDecl.getValue();
     1623        if (id !=0) {
     1624            fInternalSubset.append(chSpace);
     1625            fInternalSubset.append(chDoubleQuote);
     1626            fInternalSubset.append(id);
     1627            fInternalSubset.append(chDoubleQuote);
     1628        }
     1629
     1630        fInternalSubset.append(chCloseAngle);
     1631    }
    16201632
    16211633}
     
    16281640void AbstractDOMParser::notationDecl
    16291641(
    1630         const   XMLNotationDecl&    notDecl
    1631         , const bool
     1642    const   XMLNotationDecl&    notDecl
     1643    , const bool
    16321644)
    16331645{
    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         }
     1646    DOMNotationImpl* notation = (DOMNotationImpl *)fDocument->createNotation(notDecl.getName());
     1647    notation->setPublicId(notDecl.getPublicId());
     1648    notation->setSystemId(notDecl.getSystemId());
     1649    notation->setBaseURI(notDecl.getBaseURI());
     1650
     1651    DOMNode* rem = fDocumentType->getNotations()->setNamedItem( notation );
     1652    if (rem)
     1653        rem->release();
     1654
     1655    if (fDocumentType->isIntSubsetReading())
     1656    {
     1657        //add thes chars to internalSubset variable
     1658        fInternalSubset.append(chOpenAngle);
     1659        fInternalSubset.append(chBang);
     1660        fInternalSubset.append(XMLUni::fgNotationString);
     1661        fInternalSubset.append(chSpace);
     1662
     1663        fInternalSubset.append(notDecl.getName());
     1664
     1665        const XMLCh* id = notation->getPublicId();
     1666        if (id != 0) {
     1667            fInternalSubset.append(chSpace);
     1668            fInternalSubset.append(XMLUni::fgPubIDString);
     1669            fInternalSubset.append(chSpace);
     1670            fInternalSubset.append(chDoubleQuote);
     1671            fInternalSubset.append(id);
     1672            fInternalSubset.append(chDoubleQuote);
     1673        }
     1674        id = notation->getSystemId();
     1675        if (id != 0) {
     1676            fInternalSubset.append(chSpace);
     1677            fInternalSubset.append(XMLUni::fgSysIDString);
     1678            fInternalSubset.append(chSpace);
     1679            fInternalSubset.append(chDoubleQuote);
     1680            fInternalSubset.append(id);
     1681            fInternalSubset.append(chDoubleQuote);
     1682
     1683        }
     1684        fInternalSubset.append(chCloseAngle);
     1685    }
    16741686}
    16751687
    16761688void AbstractDOMParser::startAttList
    16771689(
    1678         const   DTDElementDecl& elemDecl
     1690    const   DTDElementDecl& elemDecl
    16791691)
    16801692{
    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         }
     1693    if (fDocumentType->isIntSubsetReading())
     1694    {
     1695        fInternalSubset.append(chOpenAngle);
     1696        fInternalSubset.append(chBang);
     1697        fInternalSubset.append(XMLUni::fgAttListString);
     1698        fInternalSubset.append(chSpace);
     1699        fInternalSubset.append(elemDecl.getFullName());
     1700    }
    16891701}
    16901702
     
    17001712void AbstractDOMParser::TextDecl
    17011713(
    1702         const   XMLCh* const    versionStr
    1703         , const XMLCh* const    encodingStr
     1714    const   XMLCh* const    versionStr
     1715    , const XMLCh* const    encodingStr
    17041716)
    17051717{
    1706         if (fCurrentEntity) {
    1707                 fCurrentEntity->setXmlVersion(versionStr);
    1708                 fCurrentEntity->setXmlEncoding(encodingStr);
    1709         }
     1718    if (fCurrentEntity) {
     1719        fCurrentEntity->setXmlVersion(versionStr);
     1720        fCurrentEntity->setXmlEncoding(encodingStr);
     1721    }
    17101722}
    17111723
     
    17141726{
    17151727  return new (fDocument, DOMMemoryManager::CDATA_SECTION_OBJECT)
    1716         DOMCDATASectionImpl(fDocument, s, n);
     1728    DOMCDATASectionImpl(fDocument, s, n);
    17171729}
    17181730
     
    17221734{
    17231735  return new (fDocument, DOMMemoryManager::TEXT_OBJECT)
    1724         DOMTextImpl(fDocument, s, n);
     1736    DOMTextImpl(fDocument, s, n);
    17251737}
    17261738
     
    17301742{
    17311743  return new (fDocument, DOMMemoryManager::ELEMENT_OBJECT)
    1732         DOMElementImpl(fDocument, name);
     1744    DOMElementImpl(fDocument, name);
    17331745}
    17341746
    17351747DOMElement* AbstractDOMParser::
    17361748createElementNS (const XMLCh* namespaceURI,
    1737                                 const XMLCh* elemPrefix,
    1738                                 const XMLCh* localName,
    1739                                 const XMLCh* qName)
     1749                const XMLCh* elemPrefix,
     1750                const XMLCh* localName,
     1751                const XMLCh* qName)
    17401752{
    17411753  return new (fDocument, DOMMemoryManager::ELEMENT_NS_OBJECT)
    1742         DOMElementNSImpl (fDocument,
    1743                                           namespaceURI,
    1744                                           elemPrefix,
    1745                                           localName,
    1746                                           qName);
     1754    DOMElementNSImpl (fDocument,
     1755                      namespaceURI,
     1756                      elemPrefix,
     1757                      localName,
     1758                      qName);
    17471759}
    17481760
     
    17511763{
    17521764  return new (fDocument, DOMMemoryManager::ATTR_OBJECT)
    1753         DOMAttrImpl(fDocument, name);
     1765    DOMAttrImpl(fDocument, name);
    17541766}
    17551767
    17561768DOMAttr* AbstractDOMParser::
    17571769createAttrNS (const XMLCh* namespaceURI,
    1758                           const XMLCh* elemPrefix,
    1759                           const XMLCh* localName,
    1760                           const XMLCh* qName)
     1770              const XMLCh* elemPrefix,
     1771              const XMLCh* localName,
     1772              const XMLCh* qName)
    17611773{
    17621774  return new (fDocument, DOMMemoryManager::ATTR_NS_OBJECT)
    1763         DOMAttrNSImpl (fDocument,
    1764                                    namespaceURI,
    1765                                    elemPrefix,
    1766                                    localName,
    1767                                    qName);
     1775    DOMAttrNSImpl (fDocument,
     1776                   namespaceURI,
     1777                   elemPrefix,
     1778                   localName,
     1779                   qName);
    17681780}
    17691781
  • icXML/icXML-devel/src/icxercesc/parsers/AbstractDOMParser.hpp

    r3157 r3178  
    3434#include <icxercesc/framework/XMLBufferMgr.hpp>
    3535#include <xercesc/framework/psvi/PSVIHandler.hpp>
    36 #include <icxmlc/XMLConfig.hpp>
    37 #ifdef TEST_NAMESPACE_RESOLVER
    38 #include <icxmlc/XMLNamespaceResolver.hpp>
    39 #endif
    4036
    4137XERCES_CPP_NAMESPACE_BEGIN
     
    5147class XMLGrammarPool;
    5248class PSVIHandler;
    53 class IGXMLScanner;
    54 class SGXMLScanner;
    55 class TraverseSchema;
    5649
    5750/**
     
    6154class PARSERS_EXPORT AbstractDOMParser :
    6255
    63         public XMemory
    64         , public XMLDocumentHandler
    65         , public XMLErrorReporter
    66         , public XMLEntityHandler
    67         , public DocTypeHandler
    68         , public PSVIHandler
     56    public XMemory
     57    , public XMLDocumentHandler
     58    , public XMLErrorReporter
     59    , public XMLEntityHandler
     60    , public DocTypeHandler
     61    , public PSVIHandler
    6962{
    70         friend class IGXMLScanner;
    71         friend class SGXMLScanner;
    72         friend class TraverseSchema;
     63    friend class IGXMLScanner;
     64    friend class SGXMLScanner;
     65    friend class TraverseSchema;
    7366
    7467public :
    75         // -----------------------------------------------------------------------
    76         //  Class types
    77         // -----------------------------------------------------------------------
    78         /** @name Public constants */
    79         //@{
    80 
    81         /** ValScheme enum used in setValidationScheme
    82           *    Val_Never:  Do not report validation errors.
    83           *    Val_Always: The parser will always report validation errors.
    84           *    Val_Auto:   The parser will report validation errors only if a grammar is specified.
    85           *
    86           * @see #setValidationScheme
    87           */
    88         enum ValSchemes
    89         {
    90                 Val_Never
    91                 , Val_Always
    92                 , Val_Auto
    93         };
    94 
    95         //@}
    96 
    97 
    98         // -----------------------------------------------------------------------
    99         //  Constructors and Destructor
    100         // -----------------------------------------------------------------------
    101         /** @name Destructor */
    102         //@{
    103 
    104         /**
    105           * Destructor
    106           */
    107         virtual ~AbstractDOMParser();
    108 
    109         //@}
    110 
    111         // -----------------------------------------------------------------------
    112         //  Utility methods
    113         // -----------------------------------------------------------------------
    114 
    115         /** @name Utility methods */
    116         //@{
    117         /** Reset the parser
    118           *
    119           * This method resets the state of the DOM driver and makes
    120           * it ready for a fresh parse run.
    121           */
    122         void reset();
    123 
    124         /** Adopt the DOM document
    125           *
    126           * This method returns the DOMDocument object representing the
    127           * root of the document tree.
    128           *
    129           * The caller will adopt the DOMDocument and thus is responsible to
    130           * call DOMDocument::release() to release the associated memory.
    131           * The parser will not delete it.   The ownership is transferred
    132           * from the parser to the caller.
    133           *
    134           * @return The adopted DOMDocument object which represents the entire
    135           *         XML document.
    136           */
    137         DOMDocument* adoptDocument();
    138 
    139         //@}
    140 
    141 
    142         // -----------------------------------------------------------------------
    143         //  Getter methods
    144         // -----------------------------------------------------------------------
    145 
    146         /** @name Getter methods */
    147         //@{
    148 
    149         /** Get the DOM document
    150           *
    151           * This method returns the DOMDocument object representing the
    152           * root of the document tree. This object provides the primary
    153           * access to the document's data.
    154           *
    155           * The returned DOMDocument object is owned by the parser.
    156           *
    157           * @return The DOMDocument object which represents the entire
    158           *         XML document.
    159           */
    160         DOMDocument* getDocument();
    161 
    162         /** Get a const reference to the validator
    163           *
    164           * This method returns a reference to the parser's installed
    165           * validator.
    166           *
    167           * @return A const reference to the installed validator object.
    168           */
    169         const XMLValidator& getValidator() const;
    170 
    171         /**
    172           * This method returns an enumerated value that indicates the current
    173           * validation scheme set on this parser.
    174           *
    175           * @return The ValSchemes value current set on this parser.
    176           * @see #setValidationScheme
    177           */
    178         ValSchemes getValidationScheme() const;
    179 
    180         /** Get the 'do schema' flag
    181           *
    182           * This method returns the state of the parser's schema processing
    183           * flag.
    184           *
    185           * @return true, if the parser is currently configured to
    186           *         understand schema, false otherwise.
    187           *
    188           * @see #setDoSchema
    189           */
    190         bool getDoSchema() const;
    191 
    192         /** Get the 'full schema constraint checking' flag
    193           *
    194           * This method returns the state of the parser's full schema constraint
    195           * checking flag.
    196           *
    197           * @return true, if the parser is currently configured to
    198           *         have full schema constraint checking, false otherwise.
    199           *
    200           * @see #setValidationSchemaFullChecking
    201           */
    202         bool getValidationSchemaFullChecking() const;
    203 
    204         /** Get the identity constraint checking' flag
    205           *
    206           * This method returns the state of the parser's identity constraint
    207           * checking flag.
    208           *
    209           * @return true, if the parser is currently configured to
    210           *         have identity constraint checking, false otherwise.
    211           *
    212           * @see setIdentityConstraintChecking
    213           */
    214         bool getIdentityConstraintChecking() const;
    215 
    216         /** Get error count from the last parse operation.
    217           *
    218           * This method returns the error count from the last parse
    219           * operation. Note that this count is actually stored in the
    220           * scanner, so this method simply returns what the
    221           * scanner reports.
    222           *
    223           * @return number of errors encountered during the latest
    224           *                     parse operation.
    225           *
    226           */
    227         XMLSize_t getErrorCount() const;
    228 
    229         /** Get the 'do namespaces' flag
    230           *
    231           * This method returns the state of the parser's namespace processing
    232           * flag.
    233           *
    234           * @return true, if the parser is currently configured to
    235           *         understand namespaces, false otherwise.
    236           *
    237           * @see #setDoNamespaces
    238           */
    239         bool getDoNamespaces() const;
    240 
    241         /** Get the 'exit on first error' flag
    242           *
    243           * This method returns the state of the parser's
    244           * exit-on-First-Fatal-Error flag. If this flag is true, then the
    245           * parse will exit the first time it sees any non-wellformed XML or
    246           * any validity error. The default state is true.
    247           *
    248           * @return true, if the parser is currently configured to
    249           *         exit on the first fatal error, false otherwise.
    250           *
    251           * @see #setExitOnFirstFatalError
    252           */
    253         bool getExitOnFirstFatalError() const;
    254 
    255         /**
    256           * This method returns the state of the parser's
    257           * validation-constraint-fatal flag.
    258           *
    259           * @return true, if the parser is currently configured to
    260           *         set validation constraint errors as fatal, false
    261           *         otherwise.
    262           *
    263           * @see #setValidationConstraintFatal
    264           */
    265         bool getValidationConstraintFatal() const;
    266 
    267         /** Get the 'include entity references' flag
    268           *
    269           * This method returns the flag that specifies whether the parser is
    270           * creating entity reference nodes in the DOM tree being produced.
    271           *
    272           * @return  The state of the create entity reference node
    273           *               flag.
    274           * @see #setCreateEntityReferenceNodes
    275           */
    276         bool  getCreateEntityReferenceNodes()const;
     68    // -----------------------------------------------------------------------
     69    //  Class types
     70    // -----------------------------------------------------------------------
     71    /** @name Public constants */
     72    //@{
     73
     74    /** ValScheme enum used in setValidationScheme
     75      *    Val_Never:  Do not report validation errors.
     76      *    Val_Always: The parser will always report validation errors.
     77      *    Val_Auto:   The parser will report validation errors only if a grammar is specified.
     78      *
     79      * @see #setValidationScheme
     80      */
     81    enum ValSchemes
     82    {
     83        Val_Never
     84        , Val_Always
     85        , Val_Auto
     86    };
     87
     88    //@}
     89
     90
     91    // -----------------------------------------------------------------------
     92    //  Constructors and Destructor
     93    // -----------------------------------------------------------------------
     94    /** @name Destructor */
     95    //@{
     96
     97    /**
     98      * Destructor
     99      */
     100    virtual ~AbstractDOMParser();
     101
     102    //@}
     103
     104    // -----------------------------------------------------------------------
     105    //  Utility methods
     106    // -----------------------------------------------------------------------
     107
     108    /** @name Utility methods */
     109    //@{
     110    /** Reset the parser
     111      *
     112      * This method resets the state of the DOM driver and makes
     113      * it ready for a fresh parse run.
     114      */
     115    void reset();
     116
     117    /** Adopt the DOM document
     118      *
     119      * This method returns the DOMDocument object representing the
     120      * root of the document tree.
     121      *
     122      * The caller will adopt the DOMDocument and thus is responsible to
     123      * call DOMDocument::release() to release the associated memory.
     124      * The parser will not delete it.   The ownership is transferred
     125      * from the parser to the caller.
     126      *
     127      * @return The adopted DOMDocument object which represents the entire
     128      *         XML document.
     129      */
     130    DOMDocument* adoptDocument();
     131
     132    //@}
     133
     134
     135    // -----------------------------------------------------------------------
     136    //  Getter methods
     137    // -----------------------------------------------------------------------
     138
     139    /** @name Getter methods */
     140    //@{
     141
     142    /** Get the DOM document
     143      *
     144      * This method returns the DOMDocument object representing the
     145      * root of the document tree. This object provides the primary
     146      * access to the document's data.
     147      *
     148      * The returned DOMDocument object is owned by the parser.
     149      *
     150      * @return The DOMDocument object which represents the entire
     151      *         XML document.
     152      */
     153    DOMDocument* getDocument();
     154
     155    /** Get a const reference to the validator
     156      *
     157      * This method returns a reference to the parser's installed
     158      * validator.
     159      *
     160      * @return A const reference to the installed validator object.
     161      */
     162    const XMLValidator& getValidator() const;
     163
     164    /**
     165      * This method returns an enumerated value that indicates the current
     166      * validation scheme set on this parser.
     167      *
     168      * @return The ValSchemes value current set on this parser.
     169      * @see #setValidationScheme
     170      */
     171    ValSchemes getValidationScheme() const;
     172
     173    /** Get the 'do schema' flag
     174      *
     175      * This method returns the state of the parser's schema processing
     176      * flag.
     177      *
     178      * @return true, if the parser is currently configured to
     179      *         understand schema, false otherwise.
     180      *
     181      * @see #setDoSchema
     182      */
     183    bool getDoSchema() const;
     184
     185    /** Get the 'full schema constraint checking' flag
     186      *
     187      * This method returns the state of the parser's full schema constraint
     188      * checking flag.
     189      *
     190      * @return true, if the parser is currently configured to
     191      *         have full schema constraint checking, false otherwise.
     192      *
     193      * @see #setValidationSchemaFullChecking
     194      */
     195    bool getValidationSchemaFullChecking() const;
     196
     197    /** Get the identity constraint checking' flag
     198      *
     199      * This method returns the state of the parser's identity constraint
     200      * checking flag.
     201      *
     202      * @return true, if the parser is currently configured to
     203      *         have identity constraint checking, false otherwise.
     204      *
     205      * @see setIdentityConstraintChecking
     206      */
     207    bool getIdentityConstraintChecking() const;
     208
     209    /** Get error count from the last parse operation.
     210      *
     211      * This method returns the error count from the last parse
     212      * operation. Note that this count is actually stored in the
     213      * scanner, so this method simply returns what the
     214      * scanner reports.
     215      *
     216      * @return number of errors encountered during the latest
     217      *                 parse operation.
     218      *
     219      */
     220    XMLSize_t getErrorCount() const;
     221
     222    /** Get the 'do namespaces' flag
     223      *
     224      * This method returns the state of the parser's namespace processing
     225      * flag.
     226      *
     227      * @return true, if the parser is currently configured to
     228      *         understand namespaces, false otherwise.
     229      *
     230      * @see #setDoNamespaces
     231      */
     232    bool getDoNamespaces() const;
     233
     234    /** Get the 'exit on first error' flag
     235      *
     236      * This method returns the state of the parser's
     237      * exit-on-First-Fatal-Error flag. If this flag is true, then the
     238      * parse will exit the first time it sees any non-wellformed XML or
     239      * any validity error. The default state is true.
     240      *
     241      * @return true, if the parser is currently configured to
     242      *         exit on the first fatal error, false otherwise.
     243      *
     244      * @see #setExitOnFirstFatalError
     245      */
     246    bool getExitOnFirstFatalError() const;
     247
     248    /**
     249      * This method returns the state of the parser's
     250      * validation-constraint-fatal flag.
     251      *
     252      * @return true, if the parser is currently configured to
     253      *         set validation constraint errors as fatal, false
     254      *         otherwise.
     255      *
     256      * @see #setValidationConstraintFatal
     257      */
     258    bool getValidationConstraintFatal() const;
     259
     260    /** Get the 'include entity references' flag
     261      *
     262      * This method returns the flag that specifies whether the parser is
     263      * creating entity reference nodes in the DOM tree being produced.
     264      *
     265      * @return  The state of the create entity reference node
     266      *               flag.
     267      * @see #setCreateEntityReferenceNodes
     268      */
     269    bool  getCreateEntityReferenceNodes()const;
    277270
    278271   /** Get the 'include ignorable whitespace' flag.
    279           *
    280           * This method returns the state of the parser's include ignorable
    281           * whitespace flag.
    282           *
    283           * @return 'true' if the include ignorable whitespace flag is set on
    284           *         the parser, 'false' otherwise.
    285           *
    286           * @see #setIncludeIgnorableWhitespace
    287           */
    288         bool getIncludeIgnorableWhitespace() const;
     272      *
     273      * This method returns the state of the parser's include ignorable
     274      * whitespace flag.
     275      *
     276      * @return 'true' if the include ignorable whitespace flag is set on
     277      *         the parser, 'false' otherwise.
     278      *
     279      * @see #setIncludeIgnorableWhitespace
     280      */
     281    bool getIncludeIgnorableWhitespace() const;
    289282
    290283   /** Get the set of Namespace/SchemaLocation that is specified externally.
    291           *
    292           * This method returns the list of Namespace/SchemaLocation that was
    293           * specified using setExternalSchemaLocation.
    294           *
    295           * The parser owns the returned string, and the memory allocated for
    296           * the returned string will be destroyed when the parser is deleted.
    297           *
    298           * To ensure accessibility of the returned information after the parser
    299           * is deleted, callers need to copy and store the returned information
    300           * somewhere else.
    301           *
    302           * @return a pointer to the list of Namespace/SchemaLocation that was
    303           *         specified externally.  The pointer spans the same life-time as
    304           *         the parser.  A null pointer is returned if nothing
    305           *         was specified externally.
    306           *
    307           * @see #setExternalSchemaLocation(const XMLCh* const)
    308           */
    309         XMLCh* getExternalSchemaLocation() const;
     284      *
     285      * This method returns the list of Namespace/SchemaLocation that was
     286      * specified using setExternalSchemaLocation.
     287      *
     288      * The parser owns the returned string, and the memory allocated for
     289      * the returned string will be destroyed when the parser is deleted.
     290      *
     291      * To ensure accessibility of the returned information after the parser
     292      * is deleted, callers need to copy and store the returned information
     293      * somewhere else.
     294      *
     295      * @return a pointer to the list of Namespace/SchemaLocation that was
     296      *         specified externally.  The pointer spans the same life-time as
     297      *         the parser.  A null pointer is returned if nothing
     298      *         was specified externally.
     299      *
     300      * @see #setExternalSchemaLocation(const XMLCh* const)
     301      */
     302    XMLCh* getExternalSchemaLocation() const;
    310303
    311304   /** Get the noNamespace SchemaLocation that is specified externally.
    312           *
    313           * This method returns the no target namespace XML Schema Location
    314           * that was specified using setExternalNoNamespaceSchemaLocation.
    315           *
    316           * The parser owns the returned string, and the memory allocated for
    317           * the returned string will be destroyed when the parser is deleted.
    318           *
    319           * To ensure accessibility of the returned information after the parser
    320           * is deleted, callers need to copy and store the returned information
    321           * somewhere else.
    322           *
    323           * @return a pointer to the no target namespace Schema Location that was
    324           *         specified externally.  The pointer spans the same life-time as
    325           *         the parser.  A null pointer is returned if nothing
    326           *         was specified externally.
    327           *
    328           * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
    329           */
    330         XMLCh* getExternalNoNamespaceSchemaLocation() const;
    331 
    332         /** Get the SecurityManager instance attached to this parser.
    333           *
    334           * This method returns the security manager
    335           * that was specified using setSecurityManager.
    336           *
    337           * The SecurityManager instance must have been specified by the application;
    338           * this should not be deleted until after the parser has been deleted (or
    339           * a new SecurityManager instance has been supplied to the parser).
    340           *
    341           * @return a pointer to the SecurityManager instance
    342           *         specified externally.  A null pointer is returned if nothing
    343           *         was specified externally.
    344           *
    345           * @see #setSecurityManager
    346           */
    347         SecurityManager* getSecurityManager() const;
    348 
    349         /** Get the raw buffer low water mark for this parser.
    350           *
    351           * If the number of available bytes in the raw buffer is less than
    352           * the low water mark the parser will attempt to read more data before
    353           * continuing parsing. By default the value for this parameter is 100
    354           * bytes. You may want to set this parameter to 0 if you would like
    355           * the parser to parse the available data immediately without
    356           * potentially blocking while waiting for more date.
    357           *
    358           * @return current low water mark
    359           *
    360           * @see #setSecurityManager
    361           */
    362         const XMLSize_t& getLowWaterMark() const;
    363 
    364         /** Get the 'Loading External DTD' flag
    365           *
    366           * This method returns the state of the parser's loading external DTD
    367           * flag.
    368           *
    369           * @return false, if the parser is currently configured to
    370           *         ignore external DTD completely, true otherwise.
    371           *
    372           * @see #setLoadExternalDTD
    373           * @see #getValidationScheme
    374           */
    375         bool getLoadExternalDTD() const;
    376 
    377         /** Get the 'Loading Schema' flag
    378           *
    379           * This method returns the state of the parser's loading schema
    380           * flag.
    381           *
    382           * @return true, if the parser is currently configured to
    383           *         automatically load schemas that are not in the
    384           *         grammar pool, false otherwise.
    385           *
    386           * @see #setLoadSchema
    387           */
    388         bool getLoadSchema() const;
    389 
    390         /** Get the 'create comment node' flag
    391           *
    392           * This method returns the flag that specifies whether the parser is
    393           * creating comment nodes in the DOM tree being produced.
    394           *
    395           * @return  The state of the create comment node flag.
    396           * @see #setCreateCommentNodes
    397           */
    398         bool  getCreateCommentNodes()const;
    399 
    400         /**
    401           * Get the 'calculate src offset flag'
    402           *
    403           * This method returns the state of the parser's src offset calculation
    404           * when parsing an XML document.
    405           *
    406           * @return true, if the parser is currently configured to
    407           *         calculate src offsets, false otherwise.
    408           *
    409           * @see #setCalculateSrcOfs
    410           */
    411         bool getCalculateSrcOfs() const;
    412 
    413         /**
    414           * Get the 'force standard uri flag'
    415           *
    416           * This method returns the state if the parser forces standard uri
    417           *
    418           * @return true, if the parser is currently configured to
    419           *         force standard uri, i.e. malformed uri will be rejected.
    420           *
    421           * @see #setStandardUriConformant
    422           */
    423         bool getStandardUriConformant() const;
    424 
    425         /**
    426           * This method returns the installed PSVI handler. Suitable
    427           * for 'lvalue' usages.
    428           *
    429           * @return The pointer to the installed PSVI handler object.
    430           */
    431         PSVIHandler* getPSVIHandler();
    432 
    433         /**
    434           * This method returns the installed PSVI handler. Suitable
    435           * for 'rvalue' usages.
    436           *
    437           * @return A const pointer to the installed PSVI handler object.
    438           */
    439         const PSVIHandler* getPSVIHandler() const;
    440 
    441         /** Get the 'associate schema info' flag
    442           *
    443           * This method returns the flag that specifies whether
    444           * the parser is storing schema informations in the element
    445           * and attribute nodes in the DOM tree being produced.
    446           *
    447           * @return  The state of the associate schema info flag.
    448           * @see #setCreateSchemaInfo
    449           */
    450         bool getCreateSchemaInfo() const;
    451 
    452         /** Get the 'do XInclude' flag
    453           *
    454           * This method returns the flag that specifies whether
    455           * the parser will process XInclude nodes
    456           * in the DOM tree being produced.
    457           *
    458           * @return  The state of the 'do XInclude' flag.
    459           * @see #setDoXInclude
    460           */
    461         bool getDoXInclude() const;
    462 
    463         /** Get the 'generate synthetic annotations' flag
    464           *
    465           * @return true, if the parser is currently configured to
    466           *         generate synthetic annotations, false otherwise.
    467           *         A synthetic XSAnnotation is created when a schema
    468           *         component has non-schema attributes but has no
    469           *         child annotations so that the non-schema attributes
    470           *         can be recovered under PSVI.
    471           *
    472           * @see #setGenerateSyntheticAnnotations
    473           */
    474         bool getGenerateSyntheticAnnotations() const;
    475 
    476         /** Get the 'validate annotations' flag
    477           *
    478           * @return true, if the parser is currently configured to
    479           *         validate annotations, false otherwise.
    480           *
    481           * @see #setValidateAnnotations
    482           */
    483         bool getValidateAnnotations() const;
    484 
    485         /** Get the 'ignore annotations' flag
    486           *
    487           * @return true, if the parser is currently configured to
    488           *         ignore annotations, false otherwise.
    489           *
    490           * @see #setIgnoreAnnotations
    491           */
    492         bool getIgnoreAnnotations() const;
    493 
    494         /** Get the 'disable default entity resolution' flag
    495           *
    496           * @return true, if the parser is currently configured to
    497           *         not perform default entity resolution, false otherwise.
    498           *
    499           * @see #setDisableDefaultEntityResolution
    500           */
    501         bool getDisableDefaultEntityResolution() const;
    502 
    503         /** Get the 'skip DTD validation' flag
    504           *
    505           * @return true, if the parser is currently configured to
    506           *         skip DTD validation, false otherwise.
    507           *
    508           * @see #setSkipDTDValidation
    509           */
    510         bool getSkipDTDValidation() const;
    511 
    512         /** Get the 'handle multiple schema imports' flag
    513           *
    514           * @return true, if the parser is currently configured to
    515           *         import multiple schemas with the same namespace, false otherwise.
    516           *
    517           * @see #setHandleMultipleImports
    518           */
    519         bool getHandleMultipleImports() const;
    520         //@}
    521 
    522 
    523         // -----------------------------------------------------------------------
    524         //  Setter methods
    525         // -----------------------------------------------------------------------
    526 
    527         /** @name Setter methods */
    528         //@{
    529         /** set the 'generate synthetic annotations' flag
    530           *
    531           * @param newValue The value for specifying whether Synthetic Annotations
    532           *        should be generated or not.
    533           *         A synthetic XSAnnotation is created when a schema
    534           *         component has non-schema attributes but has no
    535           *         child annotations so that the non-schema attributes
    536           *         can be recovered under PSVI.
    537           *
    538           * @see #getGenerateSyntheticAnnotations
    539           */
    540         void setGenerateSyntheticAnnotations(const bool newValue);
    541 
    542         /** set the 'validlate annotations' flag
    543           *
    544           * @param newValue The value for specifying whether Annotations
    545           *        should be validated or not.
    546           *
    547           * @see #getValidateAnnotations
    548           */
    549         void setValidateAnnotations(const bool newValue);
    550 
    551         /** Set the 'do namespaces' flag
    552           *
    553           * This method allows users to enable or disable the parser's
    554           * namespace processing. When set to true, parser starts enforcing
    555           * all the constraints and rules specified by the NameSpace
    556           * specification.
    557           *
    558           * The parser's default state is: false.
    559           *
    560           * @param newState The value specifying whether NameSpace rules should
    561           *                 be enforced or not.
    562           *
    563           * @see #getDoNamespaces
    564           */
    565         void setDoNamespaces(const bool newState);
    566 
    567         /** Set the 'exit on first error' flag
    568           *
    569           * This method allows users to set the parser's behaviour when it
    570           * encounters the first fatal error. If set to true, the parser
    571           * will exit at the first fatal error. If false, then it will
    572           * report the error and continue processing.
    573           *
    574           * The default value is 'true' and the parser exits on the
    575           * first fatal error.
    576           *
    577           * @param newState The value specifying whether the parser should
    578           *                 continue or exit when it encounters the first
    579           *                 fatal error.
    580           *
    581           * @see #getExitOnFirstFatalError
    582           */
    583         void setExitOnFirstFatalError(const bool newState);
    584 
    585         /**
    586           * This method allows users to set the parser's behaviour when it
    587           * encounters a validation constraint error. If set to true, and the
    588           * the parser will treat validation error as fatal and will exit depends on the
    589           * state of "getExitOnFirstFatalError". If false, then it will
    590           * report the error and continue processing.
    591           *
    592           * Note: setting this true does not mean the validation error will be printed with
    593           * the word "Fatal Error".   It is still printed as "Error", but the parser
    594           * will exit if "setExitOnFirstFatalError" is set to true.
    595           *
    596           * <p>The default value is 'false'.</p>
    597           *
    598           * @param newState If true, the parser will exit if "setExitOnFirstFatalError"
    599           *                 is set to true.
    600           *
    601           * @see #getValidationConstraintFatal
    602           * @see #setExitOnFirstFatalError
    603           */
    604         void setValidationConstraintFatal(const bool newState);
    605 
    606         /** Set the 'include entity references' flag
    607           *
    608           * This method allows the user to specify whether the parser should
    609           * create entity reference nodes in the DOM tree being produced.
    610           * When the 'create' flag is
    611           * true, the parser will create EntityReference nodes in the DOM tree.
    612           * The EntityReference nodes and their child nodes will be read-only.
    613           * When the 'create' flag is false, no EntityReference nodes will be created.
    614           * <p>The replacement text
    615           * of the entity is included in either case, either as a
    616           * child of the Entity Reference node or in place at the location
    617           * of the reference.
    618           * <p>The default value is 'true'.
    619           *
    620           * @param create The new state of the create entity reference nodes
    621           *               flag.
    622           * @see #getCreateEntityReferenceNodes
    623           */
    624         void setCreateEntityReferenceNodes(const bool create);
     305      *
     306      * This method returns the no target namespace XML Schema Location
     307      * that was specified using setExternalNoNamespaceSchemaLocation.
     308      *
     309      * The parser owns the returned string, and the memory allocated for
     310      * the returned string will be destroyed when the parser is deleted.
     311      *
     312      * To ensure accessibility of the returned information after the parser
     313      * is deleted, callers need to copy and store the returned information
     314      * somewhere else.
     315      *
     316      * @return a pointer to the no target namespace Schema Location that was
     317      *         specified externally.  The pointer spans the same life-time as
     318      *         the parser.  A null pointer is returned if nothing
     319      *         was specified externally.
     320      *
     321      * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
     322      */
     323    XMLCh* getExternalNoNamespaceSchemaLocation() const;
     324
     325    /** Get the SecurityManager instance attached to this parser.
     326      *
     327      * This method returns the security manager
     328      * that was specified using setSecurityManager.
     329      *
     330      * The SecurityManager instance must have been specified by the application;
     331      * this should not be deleted until after the parser has been deleted (or
     332      * a new SecurityManager instance has been supplied to the parser).
     333      *
     334      * @return a pointer to the SecurityManager instance
     335      *         specified externally.  A null pointer is returned if nothing
     336      *         was specified externally.
     337      *
     338      * @see #setSecurityManager
     339      */
     340    SecurityManager* getSecurityManager() const;
     341
     342    /** Get the raw buffer low water mark for this parser.
     343      *
     344      * If the number of available bytes in the raw buffer is less than
     345      * the low water mark the parser will attempt to read more data before
     346      * continuing parsing. By default the value for this parameter is 100
     347      * bytes. You may want to set this parameter to 0 if you would like
     348      * the parser to parse the available data immediately without
     349      * potentially blocking while waiting for more date.
     350      *
     351      * @return current low water mark
     352      *
     353      * @see #setSecurityManager
     354      */
     355    const XMLSize_t& getLowWaterMark() const;
     356
     357    /** Get the 'Loading External DTD' flag
     358      *
     359      * This method returns the state of the parser's loading external DTD
     360      * flag.
     361      *
     362      * @return false, if the parser is currently configured to
     363      *         ignore external DTD completely, true otherwise.
     364      *
     365      * @see #setLoadExternalDTD
     366      * @see #getValidationScheme
     367      */
     368    bool getLoadExternalDTD() const;
     369
     370    /** Get the 'Loading Schema' flag
     371      *
     372      * This method returns the state of the parser's loading schema
     373      * flag.
     374      *
     375      * @return true, if the parser is currently configured to
     376      *         automatically load schemas that are not in the
     377      *         grammar pool, false otherwise.
     378      *
     379      * @see #setLoadSchema
     380      */
     381    bool getLoadSchema() const;
     382
     383    /** Get the 'create comment node' flag
     384      *
     385      * This method returns the flag that specifies whether the parser is
     386      * creating comment nodes in the DOM tree being produced.
     387      *
     388      * @return  The state of the create comment node flag.
     389      * @see #setCreateCommentNodes
     390      */
     391    bool  getCreateCommentNodes()const;
     392
     393    /**
     394      * Get the 'calculate src offset flag'
     395      *
     396      * This method returns the state of the parser's src offset calculation
     397      * when parsing an XML document.
     398      *
     399      * @return true, if the parser is currently configured to
     400      *         calculate src offsets, false otherwise.
     401      *
     402      * @see #setCalculateSrcOfs
     403      */
     404    bool getCalculateSrcOfs() const;
     405
     406    /**
     407      * Get the 'force standard uri flag'
     408      *
     409      * This method returns the state if the parser forces standard uri
     410      *
     411      * @return true, if the parser is currently configured to
     412      *         force standard uri, i.e. malformed uri will be rejected.
     413      *
     414      * @see #setStandardUriConformant
     415      */
     416    bool getStandardUriConformant() const;
     417
     418    /**
     419      * This method returns the installed PSVI handler. Suitable
     420      * for 'lvalue' usages.
     421      *
     422      * @return The pointer to the installed PSVI handler object.
     423      */
     424    PSVIHandler* getPSVIHandler();
     425
     426    /**
     427      * This method returns the installed PSVI handler. Suitable
     428      * for 'rvalue' usages.
     429      *
     430      * @return A const pointer to the installed PSVI handler object.
     431      */
     432    const PSVIHandler* getPSVIHandler() const;
     433
     434    /** Get the 'associate schema info' flag
     435      *
     436      * This method returns the flag that specifies whether
     437      * the parser is storing schema informations in the element
     438      * and attribute nodes in the DOM tree being produced.
     439      *
     440      * @return  The state of the associate schema info flag.
     441      * @see #setCreateSchemaInfo
     442      */
     443    bool getCreateSchemaInfo() const;
     444
     445    /** Get the 'do XInclude' flag
     446      *
     447      * This method returns the flag that specifies whether
     448      * the parser will process XInclude nodes
     449      * in the DOM tree being produced.
     450      *
     451      * @return  The state of the 'do XInclude' flag.
     452      * @see #setDoXInclude
     453      */
     454    bool getDoXInclude() const;
     455
     456    /** Get the 'generate synthetic annotations' flag
     457      *
     458      * @return true, if the parser is currently configured to
     459      *         generate synthetic annotations, false otherwise.
     460      *         A synthetic XSAnnotation is created when a schema
     461      *         component has non-schema attributes but has no
     462      *         child annotations so that the non-schema attributes
     463      *         can be recovered under PSVI.
     464      *
     465      * @see #setGenerateSyntheticAnnotations
     466      */
     467    bool getGenerateSyntheticAnnotations() const;
     468
     469    /** Get the 'validate annotations' flag
     470      *
     471      * @return true, if the parser is currently configured to
     472      *         validate annotations, false otherwise.
     473      *
     474      * @see #setValidateAnnotations
     475      */
     476    bool getValidateAnnotations() const;
     477
     478    /** Get the 'ignore annotations' flag
     479      *
     480      * @return true, if the parser is currently configured to
     481      *         ignore annotations, false otherwise.
     482      *
     483      * @see #setIgnoreAnnotations
     484      */
     485    bool getIgnoreAnnotations() const;
     486
     487    /** Get the 'disable default entity resolution' flag
     488      *
     489      * @return true, if the parser is currently configured to
     490      *         not perform default entity resolution, false otherwise.
     491      *
     492      * @see #setDisableDefaultEntityResolution
     493      */
     494    bool getDisableDefaultEntityResolution() const;
     495
     496    /** Get the 'skip DTD validation' flag
     497      *
     498      * @return true, if the parser is currently configured to
     499      *         skip DTD validation, false otherwise.
     500      *
     501      * @see #setSkipDTDValidation
     502      */
     503    bool getSkipDTDValidation() const;
     504
     505    /** Get the 'handle multiple schema imports' flag
     506      *
     507      * @return true, if the parser is currently configured to
     508      *         import multiple schemas with the same namespace, false otherwise.
     509      *
     510      * @see #setHandleMultipleImports
     511      */
     512    bool getHandleMultipleImports() const;
     513    //@}
     514
     515
     516    // -----------------------------------------------------------------------
     517    //  Setter methods
     518    // -----------------------------------------------------------------------
     519
     520    /** @name Setter methods */
     521    //@{
     522    /** set the 'generate synthetic annotations' flag
     523      *
     524      * @param newValue The value for specifying whether Synthetic Annotations
     525      *        should be generated or not.
     526      *         A synthetic XSAnnotation is created when a schema
     527      *         component has non-schema attributes but has no
     528      *         child annotations so that the non-schema attributes
     529      *         can be recovered under PSVI.
     530      *
     531      * @see #getGenerateSyntheticAnnotations
     532      */
     533    void setGenerateSyntheticAnnotations(const bool newValue);
     534
     535    /** set the 'validlate annotations' flag
     536      *
     537      * @param newValue The value for specifying whether Annotations
     538      *        should be validated or not.
     539      *
     540      * @see #getValidateAnnotations
     541      */
     542    void setValidateAnnotations(const bool newValue);
     543
     544    /** Set the 'do namespaces' flag
     545      *
     546      * This method allows users to enable or disable the parser's
     547      * namespace processing. When set to true, parser starts enforcing
     548      * all the constraints and rules specified by the NameSpace
     549      * specification.
     550      *
     551      * The parser's default state is: false.
     552      *
     553      * @param newState The value specifying whether NameSpace rules should
     554      *                 be enforced or not.
     555      *
     556      * @see #getDoNamespaces
     557      */
     558    void setDoNamespaces(const bool newState);
     559
     560    /** Set the 'exit on first error' flag
     561      *
     562      * This method allows users to set the parser's behaviour when it
     563      * encounters the first fatal error. If set to true, the parser
     564      * will exit at the first fatal error. If false, then it will
     565      * report the error and continue processing.
     566      *
     567      * The default value is 'true' and the parser exits on the
     568      * first fatal error.
     569      *
     570      * @param newState The value specifying whether the parser should
     571      *                 continue or exit when it encounters the first
     572      *                 fatal error.
     573      *
     574      * @see #getExitOnFirstFatalError
     575      */
     576    void setExitOnFirstFatalError(const bool newState);
     577
     578    /**
     579      * This method allows users to set the parser's behaviour when it
     580      * encounters a validation constraint error. If set to true, and the
     581      * the parser will treat validation error as fatal and will exit depends on the
     582      * state of "getExitOnFirstFatalError". If false, then it will
     583      * report the error and continue processing.
     584      *
     585      * Note: setting this true does not mean the validation error will be printed with
     586      * the word "Fatal Error".   It is still printed as "Error", but the parser
     587      * will exit if "setExitOnFirstFatalError" is set to true.
     588      *
     589      * <p>The default value is 'false'.</p>
     590      *
     591      * @param newState If true, the parser will exit if "setExitOnFirstFatalError"
     592      *                 is set to true.
     593      *
     594      * @see #getValidationConstraintFatal
     595      * @see #setExitOnFirstFatalError
     596      */
     597    void setValidationConstraintFatal(const bool newState);
     598
     599    /** Set the 'include entity references' flag
     600      *
     601      * This method allows the user to specify whether the parser should
     602      * create entity reference nodes in the DOM tree being produced.
     603      * When the 'create' flag is
     604      * true, the parser will create EntityReference nodes in the DOM tree.
     605      * The EntityReference nodes and their child nodes will be read-only.
     606      * When the 'create' flag is false, no EntityReference nodes will be created.
     607      * <p>The replacement text
     608      * of the entity is included in either case, either as a
     609      * child of the Entity Reference node or in place at the location
     610      * of the reference.
     611      * <p>The default value is 'true'.
     612      *
     613      * @param create The new state of the create entity reference nodes
     614      *               flag.
     615      * @see #getCreateEntityReferenceNodes
     616      */
     617    void setCreateEntityReferenceNodes(const bool create);
    625618
    626619   /** Set the 'include ignorable whitespace' flag
    627           *
    628           * This method allows the user to specify whether a validating parser
    629           * should include ignorable whitespaces as text nodes.  It has no effect
    630           * on non-validating parsers which always include non-markup text.
    631           * <p>When set to true (also the default), ignorable whitespaces will be
    632           * added to the DOM tree as text nodes.  The method
    633           * DOMText::isIgnorableWhitespace() will return true for those text
    634           * nodes only.
    635           * <p>When set to false, all ignorable whitespace will be discarded and
    636           * no text node is added to the DOM tree.  Note: applications intended
    637           * to process the "xml:space" attribute should not set this flag to false.
    638           * And this flag also overrides any schema datateye whitespace facets,
    639           * that is, all ignorable whitespace will be discarded even though
    640           * 'preserve' is set in schema datatype whitespace facets.
    641           *
    642           * @param include The new state of the include ignorable whitespace
    643           *                flag.
    644           *
    645           * @see #getIncludeIgnorableWhitespace
    646           */
    647         void setIncludeIgnorableWhitespace(const bool include);
    648 
    649         /**
    650           * This method allows users to set the validation scheme to be used
    651           * by this parser. The value is one of the ValSchemes enumerated values
    652           * defined by this class:
    653           *
    654           * <br>  Val_Never  - turn off validation
    655           * <br>  Val_Always - turn on validation
    656           * <br>  Val_Auto   - turn on validation if any internal/external
    657           *                  DTD subset have been seen
    658           *
    659           * <p>The parser's default state is: Val_Never.</p>
    660           *
    661           * @param newScheme The new validation scheme to use.
    662           *
    663           * @see #getValidationScheme
    664           */
    665         void setValidationScheme(const ValSchemes newScheme);
    666 
    667         /** Set the 'do schema' flag
    668           *
    669           * This method allows users to enable or disable the parser's
    670           * schema processing. When set to false, parser will not process
    671           * any schema found.
    672           *
    673           * The parser's default state is: false.
    674           *
    675           * Note: If set to true, namespace processing must also be turned on.
    676           *
    677           * @param newState The value specifying whether schema support should
    678           *                 be enforced or not.
    679           *
    680           * @see #getDoSchema
    681           */
    682         void setDoSchema(const bool newState);
    683 
    684         /**
    685           * This method allows the user to turn full Schema constraint checking on/off.
    686           * Only takes effect if Schema validation is enabled.
    687           * If turned off, partial constraint checking is done.
    688           *
    689           * Full schema constraint checking includes those checking that may
    690           * be time-consuming or memory intensive. Currently, particle unique
    691           * attribution constraint checking and particle derivation restriction checking
    692           * are controlled by this option.
    693           *
    694           * The parser's default state is: false.
    695           *
    696           * @param schemaFullChecking True to turn on full schema constraint checking.
    697           *
    698           * @see #getValidationSchemaFullChecking
    699           */
    700         void setValidationSchemaFullChecking(const bool schemaFullChecking);
    701 
    702         /**
    703           * This method allows users to enable or disable the parser's identity
    704           * constraint checks.
    705           *
    706           * <p>By default, the parser does identity constraint checks.
    707           *    The default value is true.</p>
    708           *
    709           * @param newState The value specifying whether the parser should
    710           *                 do identity constraint checks or not in the
    711           *                 input XML document.
    712           *
    713           * @see #getIdentityConstraintChecking
    714           */
    715         void setIdentityConstraintChecking(const bool newState);
    716 
    717         /**
    718           * This method allows the user to specify a list of schemas to use.
    719           * If the targetNamespace of a schema specified using this method matches
    720           * the targetNamespace of a schema occurring in the instance document in
    721           * the schemaLocation attribute, or if the targetNamespace matches the
    722           * namespace attribute of the "import" element, the schema specified by the
    723           * user using this method will be used (i.e., the schemaLocation attribute
    724           * in the instance document or on the "import" element will be effectively ignored).
    725           *
    726           * If this method is called more than once, only the last one takes effect.
    727           *
    728           * The syntax is the same as for schemaLocation attributes in instance
    729           * documents: e.g, "http://www.example.com file_name.xsd". The user can
    730           * specify more than one XML Schema in the list.
    731           *
    732           * @param schemaLocation the list of schemas to use
    733           *
    734           * @see #getExternalSchemaLocation
    735           */
    736 
    737         void setExternalSchemaLocation(const XMLCh* const schemaLocation);
    738 
    739         /**
    740           * This method is same as setExternalSchemaLocation(const XMLCh* const).
    741           * It takes native char string as parameter
    742           *
    743           * @param schemaLocation the list of schemas to use
    744           *
    745           * @see #setExternalSchemaLocation(const XMLCh* const)
    746           */
    747         void setExternalSchemaLocation(const char* const schemaLocation);
    748 
    749         /**
    750           * This method allows the user to specify the no target namespace XML
    751           * Schema Location externally.  If specified, the instance document's
    752           * noNamespaceSchemaLocation attribute will be effectively ignored.
    753           *
    754           * If this method is called more than once, only the last one takes effect.
    755           *
    756           * The syntax is the same as for the noNamespaceSchemaLocation attribute
    757           * that may occur in an instance document: e.g."file_name.xsd".
    758           *
    759           * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
    760           *
    761           * @see #getExternalNoNamespaceSchemaLocation
    762           */
    763         void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
    764 
    765         /**
    766           * This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const).
    767           * It takes native char string as parameter
    768           *
    769           * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
    770           *
    771           * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
    772           */
    773         void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
    774 
    775         /**
    776           * This allows an application to set a SecurityManager on
    777           * the parser; this object stores information that various
    778           * components use to limit their consumption of system
    779           * resources while processing documents.
    780           *
    781           * If this method is called more than once, only the last one takes effect.
    782           * It may not be reset during a parse.
    783           *
    784           *
    785           * @param securityManager  the SecurityManager instance to
    786           * be used by this parser
    787           *
    788           * @see #getSecurityManager
    789           */
    790         void setSecurityManager(SecurityManager* const securityManager);
    791 
    792         /** Set the raw buffer low water mark for this parser.
    793           *
    794           * If the number of available bytes in the raw buffer is less than
    795           * the low water mark the parser will attempt to read more data before
    796           * continuing parsing. By default the value for this parameter is 100
    797           * bytes. You may want to set this parameter to 0 if you would like
    798           * the parser to parse the available data immediately without
    799           * potentially blocking while waiting for more date.
    800           *
    801           * @param lwm new low water mark
    802           *
    803           * @see #getSecurityManager
    804           */
    805         void setLowWaterMark(XMLSize_t lwm);
    806 
    807         /** Set the 'Loading External DTD' flag
    808           *
    809           * This method allows users to enable or disable the loading of external DTD.
    810           * When set to false, the parser will ignore any external DTD completely
    811           * if the validationScheme is set to Val_Never.
    812           *
    813           * The parser's default state is: true.
    814           *
    815           * This flag is ignored if the validationScheme is set to Val_Always or Val_Auto.
    816           *
    817           * @param newState The value specifying whether external DTD should
    818           *                 be loaded or not.
    819           *
    820           * @see #getLoadExternalDTD
    821           * @see #setValidationScheme
    822           */
    823         void setLoadExternalDTD(const bool newState);
    824 
    825         /** Set the 'Loading Schema' flag
    826           *
    827           * This method allows users to enable or disable the loading of schemas.
    828           * When set to false, the parser not attempt to load schemas beyond
    829           * querying the grammar pool for them.
    830           *
    831           * The parser's default state is: true.
    832           *
    833           * @param newState The value specifying whether schemas should
    834           *                 be loaded if they're not found in the grammar
    835           *                 pool.
    836           *
    837           * @see #getLoadSchema
    838           * @see #setDoSchema
    839           */
    840         void setLoadSchema(const bool newState);
    841 
    842          /** Set the 'create comment nodes' flag
    843           *
    844           * This method allows the user to specify whether the parser should
    845           * create comment nodes in the DOM tree being produced.
    846           * <p>The default value is 'true'.
    847           *
    848           * @param create The new state of the create comment nodes
    849           *               flag.
    850           * @see #getCreateCommentNodes
    851           */
    852         void setCreateCommentNodes(const bool create);
    853 
    854         /** Enable/disable src offset calculation
    855           *
    856           * This method allows users to enable/disable src offset calculation.
    857           * Disabling the calculation will improve performance.
    858           *
    859           * The parser's default state is: false.
    860           *
    861           * @param newState The value specifying whether we should enable or
    862           *                 disable src offset calculation
    863           *
    864           * @see #getCalculateSrcOfs
    865           */
    866         void setCalculateSrcOfs(const bool newState);
    867 
    868         /** Force standard uri
    869           *
    870           * This method allows users to tell the parser to force standard uri conformance.
    871           *
    872           * The parser's default state is: false.
    873           *
    874           * @param newState The value specifying whether the parser should reject malformed URI.
    875           *
    876           * @see #getStandardUriConformant
    877           */
    878         void setStandardUriConformant(const bool newState);
    879 
    880         /** Set the scanner to use when scanning the XML document
    881           *
    882           * This method allows users to set the  scanner to use
    883           * when scanning a given XML document.
    884           *
    885           * @param scannerName The name of the desired scanner
    886           */
    887         void useScanner(const XMLCh* const scannerName);
    888 
    889         /** Set the implementation to use when creating the  document
    890           *
    891           * This method allows users to set the implementation to use
    892           * to create the document when parseing.
    893           *
    894           * @param implementationFeatures The names of the desired features the implementation should have.
    895           */
    896         void useImplementation(const XMLCh* const implementationFeatures);
    897 
    898         /**
    899           * This method installs the user specified PSVI handler on
    900           * the parser.
    901           *
    902           * @param handler A pointer to the PSVI handler to be called
    903           *                when the parser comes across 'PSVI' events
    904           *                as per the schema specification.
    905           */
    906         virtual void setPSVIHandler(PSVIHandler* const handler);
    907 
    908         /** Set the 'associate schema info' flag
    909           *
    910           * This method allows users to specify whether
    911           * the parser should store schema informations in the element
    912           * and attribute nodes in the DOM tree being produced.
    913           *
    914           * @param newState The state to set
    915           * @see #getCreateSchemaInfo
    916           */
    917         void  setCreateSchemaInfo(const bool newState);
    918 
    919         /** Set the 'do XInclude' flag
    920           *
    921           * This method allows users to specify whether
    922           * the parser should process XInclude nodes
    923           * in the DOM tree being produced.
    924           *
    925           * @param newState The state to set
    926           * @see #getDoXInclude
    927           */
    928         void  setDoXInclude(const bool newState);
    929 
    930         /** Set the 'ignore annotation' flag
    931           *
    932           * This method gives users the option to not generate XSAnnotations
    933           * when "traversing" a schema.
    934           *
    935           * The parser's default state is false
    936           *
    937           * @param newValue The state to set
    938           */
    939         void setIgnoreAnnotations(const bool newValue);
    940 
    941         /** Set the 'disable default entity resolution' flag
    942           *
    943           * This method gives users the option to not perform default entity
    944           * resolution.  If the user's resolveEntity method returns NULL the
    945           * parser will try to resolve the entity on its own.  When this option
    946           * is set to true, the parser will not attempt to resolve the entity
    947           * when the resolveEntity method returns NULL.
    948           *
    949           * The parser's default state is false
    950           *
    951           * @param newValue The state to set
    952           *
    953           * @see #EntityResolver
    954           */
    955         void setDisableDefaultEntityResolution(const bool newValue);
    956 
    957         /** Set the 'skip DTD validation' flag
    958           *
    959           * This method gives users the option to skip DTD validation only when
    960           * schema validation is on (i.e. when performing validation,  we will
    961           * ignore the DTD, except for entities, when schema validation is enabled).
    962           *
    963           * NOTE: This option is ignored if schema validation is disabled.
    964           *
    965           * The parser's default state is false
    966           *
    967           * @param newValue The state to set
    968           */
    969         void setSkipDTDValidation(const bool newValue);
    970 
    971         /** Set the 'handle multiple schema imports' flag
    972           *
    973           * This method gives users the ability to import multiple schemas that
    974           * have the same namespace.
    975           *
    976           * NOTE: This option is ignored if schema validation is disabled.
    977           *
    978           * The parser's default state is false
    979           *
    980           * @param newValue The state to set
    981           */
    982         void setHandleMultipleImports(const bool newValue);
    983         //@}
    984 
    985 
    986         // -----------------------------------------------------------------------
    987         //  Parsing methods
    988         // -----------------------------------------------------------------------
    989 
    990         /** @name Parsing methods */
    991         //@{
    992 
    993         /** Parse via an input source object
    994           *
    995           * This method invokes the parsing process on the XML file specified
    996           * by the InputSource parameter. This API is borrowed from the
    997           * SAX Parser interface.
    998           *
    999           * @param source A const reference to the InputSource object which
    1000           *               points to the XML file to be parsed.
    1001           * @exception SAXException Any SAX exception, possibly
    1002           *            wrapping another exception.
    1003           * @exception XMLException An exception from the parser or client
    1004           *            handler code.
    1005           * @exception DOMException A DOM exception as per DOM spec.
    1006           * @see InputSource#InputSource
    1007           */
    1008         void parse(const InputSource& source);
    1009 
    1010         /** Parse via a file path or URL
    1011           *
    1012           * This method invokes the parsing process on the XML file specified by
    1013           * the Unicode string parameter 'systemId'. This method is borrowed
    1014           * from the SAX Parser interface.
    1015           *
    1016           * @param systemId A const XMLCh pointer to the Unicode string which
    1017           *                 contains the path to the XML file to be parsed.
    1018           *
    1019           * @exception SAXException Any SAX exception, possibly
    1020           *            wrapping another exception.
    1021           * @exception XMLException An exception from the parser or client
    1022           *            handler code.
    1023           * @exception DOMException A DOM exception as per DOM spec.
    1024           * @see #parse(InputSource,...)
    1025           */
    1026         void parse(const XMLCh* const systemId);
    1027 
    1028         /** Parse via a file path or URL (in the local code page)
    1029           *
    1030           * This method invokes the parsing process on the XML file specified by
    1031           * the native char* string parameter 'systemId'.
    1032           *
    1033           * @param systemId A const char pointer to a native string which
    1034           *                 contains the path to the XML file to be parsed.
    1035           *
    1036           * @exception SAXException Any SAX exception, possibly
    1037           *            wrapping another exception.
    1038           * @exception XMLException An exception from the parser or client
    1039           *            handler code.
    1040           * @exception DOMException A DOM exception as per DOM spec.
    1041           * @see #parse(InputSource,...)
    1042           */
    1043         void parse(const char* const systemId);
    1044 
    1045         /** Begin a progressive parse operation
    1046           *
    1047           * This method is used to start a progressive parse on a XML file.
    1048           * To continue parsing, subsequent calls must be to the parseNext
    1049           * method.
    1050           *
    1051           * It scans through the prolog and returns a token to be used on
    1052           * subsequent scanNext() calls. If the return value is true, then the
    1053           * token is legal and ready for further use. If it returns false, then
    1054           * the scan of the prolog failed and the token is not going to work on
    1055           * subsequent scanNext() calls.
    1056           *
    1057           * @param systemId A pointer to a Unicode string representing the path
    1058           *                 to the XML file to be parsed.
    1059           * @param toFill   A token maintaing state information to maintain
    1060           *                 internal consistency between invocation of 'parseNext'
    1061           *                 calls.
    1062           * @return 'true', if successful in parsing the prolog. It indicates the
    1063           *         user can go ahead with parsing the rest of the file. It
    1064           *         returns 'false' to indicate that the parser could not parse
    1065           *         the prolog.
    1066           *
    1067           * @see #parseNext
    1068           * @see #parseFirst(char*,...)
    1069           * @see #parseFirst(InputSource&,...)
    1070           */
    1071         bool parseFirst
    1072         (
    1073                 const   XMLCh* const    systemId
    1074                 ,       XMLPScanToken&  toFill
    1075         );
    1076 
    1077         /** Begin a progressive parse operation
    1078           *
    1079           * This method is used to start a progressive parse on a XML file.
    1080           * To continue parsing, subsequent calls must be to the parseNext
    1081           * method.
    1082           *
    1083           * It scans through the prolog and returns a token to be used on
    1084           * subsequent scanNext() calls. If the return value is true, then the
    1085           * token is legal and ready for further use. If it returns false, then
    1086           * the scan of the prolog failed and the token is not going to work on
    1087           * subsequent scanNext() calls.
    1088           *
    1089           * @param systemId A pointer to a regular native string representing
    1090           *                 the path to the XML file to be parsed.
    1091           * @param toFill   A token maintaing state information to maintain
    1092           *                 internal consistency between invocation of 'parseNext'
    1093           *                 calls.
    1094           *
    1095           * @return 'true', if successful in parsing the prolog. It indicates the
    1096           *         user can go ahead with parsing the rest of the file. It
    1097           *         returns 'false' to indicate that the parser could not parse
    1098           *         the prolog.
    1099           *
    1100           * @see #parseNext
    1101           * @see #parseFirst(XMLCh*,...)
    1102           * @see #parseFirst(InputSource&,...)
    1103           */
    1104         bool parseFirst
    1105         (
    1106                 const   char* const     systemId
    1107                 ,       XMLPScanToken&  toFill
    1108         );
    1109 
    1110         /** Begin a progressive parse operation
    1111           *
    1112           * This method is used to start a progressive parse on a XML file.
    1113           * To continue parsing, subsequent calls must be to the parseNext
    1114           * method.
    1115           *
    1116           * It scans through the prolog and returns a token to be used on
    1117           * subsequent scanNext() calls. If the return value is true, then the
    1118           * token is legal and ready for further use. If it returns false, then
    1119           * the scan of the prolog failed and the token is not going to work on
    1120           * subsequent scanNext() calls.
    1121           *
    1122           * @param source   A const reference to the InputSource object which
    1123           *                 points to the XML file to be parsed.
    1124           * @param toFill   A token maintaing state information to maintain
    1125           *                 internal consistency between invocation of 'parseNext'
    1126           *                 calls.
    1127           *
    1128           * @return 'true', if successful in parsing the prolog. It indicates the
    1129           *         user can go ahead with parsing the rest of the file. It
    1130           *         returns 'false' to indicate that the parser could not parse
    1131           *         the prolog.
    1132           *
    1133           * @see #parseNext
    1134           * @see #parseFirst(XMLCh*,...)
    1135           * @see #parseFirst(char*,...)
    1136           */
    1137         bool parseFirst
    1138         (
    1139                 const   InputSource&    source
    1140                 ,       XMLPScanToken&  toFill
    1141         );
    1142 
    1143         /** Continue a progressive parse operation
    1144           *
    1145           * This method is used to continue with progressive parsing of
    1146           * XML files started by a call to 'parseFirst' method.
    1147           *
    1148           * It parses the XML file and stops as soon as it comes across
    1149           * a XML token (as defined in the XML specification).
    1150           *
    1151           * @param token A token maintaing state information to maintain
    1152           *              internal consistency between invocation of 'parseNext'
    1153           *              calls.
    1154           *
    1155           * @return 'true', if successful in parsing the next XML token.
    1156           *         It indicates the user can go ahead with parsing the rest
    1157           *         of the file. It returns 'false' to indicate that the parser
    1158           *         could not find next token as per the XML specification
    1159           *         production rule.
    1160           *
    1161           * @see #parseFirst(XMLCh*,...)
    1162           * @see #parseFirst(char*,...)
    1163           * @see #parseFirst(InputSource&,...)
    1164           */
    1165         bool parseNext(XMLPScanToken& token);
    1166 
    1167         /** Reset the parser after a progressive parse
    1168           *
    1169           * If a progressive parse loop exits before the end of the document
    1170           * is reached, the parser has no way of knowing this. So it will leave
    1171           * open any files or sockets or memory buffers that were in use at
    1172           * the time that the parse loop exited.
    1173           *
    1174           * The next parse operation will cause these open files and such to
    1175           * be closed, but the next parse operation might occur at some unknown
    1176           * future point. To avoid this problem, you should reset the parser if
    1177           * you exit the loop early.
    1178           *
    1179           * If you exited because of an error, then this cleanup will be done
    1180           * for you. Its only when you exit the file prematurely of your own
    1181           * accord, because you've found what you wanted in the file most
    1182           * likely.
    1183           *
    1184           * @param token A token maintaing state information to maintain
    1185           *              internal consistency between invocation of 'parseNext'
    1186           *              calls.
    1187           *
    1188           * @see #parseFirst(XMLCh*,...)
    1189           * @see #parseFirst(char*,...)
    1190           * @see #parseFirst(InputSource&,...)
    1191           */
    1192         void parseReset(XMLPScanToken& token);
    1193 
    1194         //@}
    1195 
    1196         // -----------------------------------------------------------------------
    1197         //  Implementation of the PSVIHandler interface.
    1198         // -----------------------------------------------------------------------
    1199 
    1200         /** @name Implementation of the PSVIHandler interface. */
    1201         //@{
    1202 
    1203         /** Receive notification of the PSVI properties of an element.
    1204           * The scanner will issue this call after the XMLDocumentHandler
    1205           * endElement call.  Since the scanner will issue the psviAttributes
    1206           * call immediately after reading the start tag of an element, all element
    1207           * content will be effectively bracketed by these two calls.
    1208           * @param  localName The name of the element whose end tag was just
    1209           *                     parsed.
    1210           * @param  uri       The namespace to which the element is bound
    1211           * @param  elementInfo    Object containing the element's PSVI properties
    1212           */
    1213         virtual void handleElementPSVI
    1214         (
    1215                 const   XMLCh* const            localName
    1216                 , const XMLCh* const            uri
    1217                 ,       PSVIElement *           elementInfo
    1218         );
    1219 
    1220         virtual void handlePartialElementPSVI
    1221         (
    1222                 const   XMLCh* const            localName
    1223                 , const XMLCh* const            uri
    1224                 ,       PSVIElement *           elementInfo
    1225         );
    1226         /**
    1227           * Enables PSVI information about attributes to be passed back to the
    1228           * application.  This callback will be made on *all*
    1229           * elements; on elements with no attributes, the final parameter will
    1230           * be null.
    1231           * @param  localName The name of the element upon which start tag
    1232           *          these attributes were encountered.
    1233           * @param  uri       The namespace to which the element is bound
    1234           * @param  psviAttributes   Object containing the attributes' PSVI properties
    1235           *          with information to identify them.
    1236           */
    1237         virtual void handleAttributesPSVI
    1238         (
    1239                 const   XMLCh* const            localName
    1240                 , const XMLCh* const            uri
    1241                 ,       PSVIAttributeList *     psviAttributes
    1242         );
    1243         //@}
    1244 
    1245         // -----------------------------------------------------------------------
    1246         //  Implementation of the XMLDocumentHandler interface.
    1247         // -----------------------------------------------------------------------
    1248 
    1249         /** @name Implementation of the XMLDocumentHandler interface. */
    1250         //@{
    1251 
    1252         /** Handle document character events
    1253           *
    1254           * This method is used to report all the characters scanned by the
    1255           * parser. This DOM implementation stores this data in the appropriate
    1256           * DOM node, creating one if necessary.
    1257           *
    1258           * @param chars   A const pointer to a Unicode string representing the
    1259           *                character data.
    1260           * @param length  The length of the Unicode string returned in 'chars'.
    1261           * @param cdataSection  A flag indicating if the characters represent
    1262           *                      content from the CDATA section.
    1263           */
    1264         virtual void docCharacters
    1265         (
    1266                 const   XMLCh* const    chars
    1267                 , const XMLSize_t       length
    1268                 , const bool            cdataSection
    1269         );
    1270 
    1271         /** Handle a document comment event
    1272           *
    1273           * This method is used to report any comments scanned by the parser.
    1274           * A new comment node is created which stores this data.
    1275           *
    1276           * @param comment A const pointer to a null terminated Unicode
    1277           *                string representing the comment text.
    1278           */
    1279         virtual void docComment
    1280         (
    1281                 const   XMLCh* const    comment
    1282         );
    1283 
    1284         /** Handle a document PI event
    1285           *
    1286           * This method is used to report any PI scanned by the parser. A new
    1287           * PI node is created and appended as a child of the current node in
    1288           * the tree.
    1289           *
    1290           * @param target A const pointer to a Unicode string representing the
    1291           *               target of the PI declaration.
    1292           * @param data   A const pointer to a Unicode string representing the
    1293           *               data of the PI declaration. See the PI production rule
    1294           *               in the XML specification for details.
    1295           */
    1296         virtual void docPI
    1297         (
    1298                 const   XMLCh* const    target
    1299                 , const XMLCh* const    data
    1300         );
    1301 
    1302         /** Handle the end of document event
    1303           *
    1304           * This method is used to indicate the end of the current document.
    1305           */
    1306         virtual void endDocument();
    1307 
    1308         /** Handle and end of element event
    1309           *
    1310           * This method is used to indicate the end tag of an element. The
    1311           * DOM parser pops the current element off the top of the element
    1312           * stack, and make it the new current element.
    1313           *
    1314           * @param elemDecl A const reference to the object containing element
    1315           *                 declaration information.
    1316           * @param urlId    An id referring to the namespace prefix, if
    1317           *                 namespaces setting is switched on.
    1318           * @param isRoot   A flag indicating whether this element was the
    1319           *                 root element.
    1320           * @param elemPrefix A const pointer to a Unicode string containing
    1321           *                 the namespace prefix for this element. Applicable
    1322           *                 only when namespace processing is enabled.
    1323           */
    1324         virtual void endElement
    1325         (
    1326                 const   XMLElementDecl& elemDecl
    1327                 , const unsigned int    urlId
    1328                 , const bool            isRoot
    1329                 , const XMLCh* const    elemPrefix
    1330         );
    1331 
    1332         /** Handle and end of entity reference event
    1333           *
    1334           * This method is used to indicate that an end of an entity reference
    1335           * was just scanned.
    1336           *
    1337           * @param entDecl A const reference to the object containing the
    1338           *                entity declaration information.
    1339           */
    1340         virtual void endEntityReference
    1341         (
    1342                 const   XMLEntityDecl&  entDecl
    1343         );
    1344 
    1345         /** Handle an ignorable whitespace vent
    1346           *
    1347           * This method is used to report all the whitespace characters, which
    1348           * are determined to be 'ignorable'. This distinction between characters
    1349           * is only made, if validation is enabled.
    1350           *
    1351           * Any whitespace before content is ignored. If the current node is
    1352           * already of type DOMNode::TEXT_NODE, then these whitespaces are
    1353           * appended, otherwise a new Text node is created which stores this
    1354           * data. Essentially all contiguous ignorable characters are collected
    1355           * in one node.
    1356           *
    1357           * @param chars   A const pointer to a Unicode string representing the
    1358           *                ignorable whitespace character data.
    1359           * @param length  The length of the Unicode string 'chars'.
    1360           * @param cdataSection  A flag indicating if the characters represent
    1361           *                      content from the CDATA section.
    1362           */
    1363         virtual void ignorableWhitespace
    1364         (
    1365                 const   XMLCh* const    chars
    1366                 , const XMLSize_t       length
    1367                 , const bool            cdataSection
    1368         );
    1369 
    1370         /** Handle a document reset event
    1371           *
    1372           * This method allows the user installed Document Handler to 'reset'
    1373           * itself, freeing all the memory resources. The scanner calls this
    1374           * method before starting a new parse event.
    1375           */
    1376         virtual void resetDocument();
    1377 
    1378         /** Handle a start document event
    1379           *
    1380           * This method is used to report the start of the parsing process.
    1381           */
    1382         virtual void startDocument();
    1383 
    1384         /** Handle a start element event
    1385           *
    1386           * This method is used to report the start of an element. It is
    1387           * called at the end of the element, by which time all attributes
    1388           * specified are also parsed. A new DOM Element node is created
    1389           * along with as many attribute nodes as required. This new element
    1390           * is added appended as a child of the current node in the tree, and
    1391           * then replaces it as the current node (if the isEmpty flag is false.)
    1392           *
    1393           * @param elemDecl A const reference to the object containing element
    1394           *                 declaration information.
    1395           * @param urlId    An id referring to the namespace prefix, if
    1396           *                 namespaces setting is switched on.
    1397           * @param elemPrefix A const pointer to a Unicode string containing
    1398           *                 the namespace prefix for this element. Applicable
    1399           *                 only when namespace processing is enabled.
    1400           * @param attrList A const reference to the object containing the
    1401           *                 list of attributes just scanned for this element.
    1402           * @param attrCount A count of number of attributes in the list
    1403           *                 specified by the parameter 'attrList'.
    1404           * @param isEmpty  A flag indicating whether this is an empty element
    1405           *                 or not. If empty, then no endElement() call will
    1406           *                 be made.
    1407           * @param isRoot   A flag indicating whether this element was the
    1408           *                 root element.
    1409           * @see DocumentHandler#startElement
    1410           */
    1411         virtual void startElement
    1412         (
    1413                 const   XMLElementDecl&         elemDecl
    1414                 , const unsigned int            urlId
    1415                 , const XMLCh* const            elemPrefix
    1416                 , const RefVectorOf<XMLAttr>&   attrList
    1417                 , const XMLSize_t               attrCount
    1418                 , const bool                    isEmpty
    1419                 , const bool                    isRoot
    1420         );
    1421 
    1422         /** Handle a start entity reference event
    1423           *
    1424           * This method is used to indicate the start of an entity reference.
    1425           * If the expand entity reference flag is true, then a new
    1426           * DOM Entity reference node is created.
    1427           *
    1428           * @param entDecl A const reference to the object containing the
    1429           *                entity declaration information.
    1430           */
    1431         virtual void startEntityReference
    1432         (
    1433                 const   XMLEntityDecl&  entDecl
    1434         );
    1435 
    1436         /** Handle an XMLDecl event
    1437           *
    1438           * This method is used to report the XML decl scanned by the parser.
    1439           * Refer to the XML specification to see the meaning of parameters.
    1440           *
    1441           * <b>This method is a no-op for this DOM
    1442           * implementation.</b>
    1443           *
    1444           * @param versionStr A const pointer to a Unicode string representing
    1445           *                   version string value.
    1446           * @param encodingStr A const pointer to a Unicode string representing
    1447           *                    the encoding string value.
    1448           * @param standaloneStr A const pointer to a Unicode string
    1449           *                      representing the standalone string value.
    1450           * @param actualEncStr A const pointer to a Unicode string
    1451           *                     representing the actual encoding string
    1452           *                     value.
    1453           */
    1454         virtual void XMLDecl
    1455         (
    1456                 const   XMLCh* const    versionStr
    1457                 , const XMLCh* const    encodingStr
    1458                 , const XMLCh* const    standaloneStr
    1459                 , const XMLCh* const    actualEncStr
    1460         );
    1461 
    1462         //@}
    1463 
    1464         // -----------------------------------------------------------------------
    1465         //  Implementation of the deprecated DocTypeHandler interface.
    1466         // -----------------------------------------------------------------------
    1467         /** @name Deprecated DocTypeHandler Interfaces */
    1468         //@{
    1469         virtual void attDef
    1470         (
    1471                 const   DTDElementDecl&     elemDecl
    1472                 , const DTDAttDef&          attDef
    1473                 , const bool                ignoring
    1474         );
    1475 
    1476         virtual void doctypeComment
    1477         (
    1478                 const   XMLCh* const    comment
    1479         );
    1480 
    1481         virtual void doctypeDecl
    1482         (
    1483                 const   DTDElementDecl& elemDecl
    1484                 , const XMLCh* const    publicId
    1485                 , const XMLCh* const    systemId
    1486                 , const bool            hasIntSubset
    1487                 , const bool            hasExtSubset = false
    1488         );
    1489 
    1490         virtual void doctypePI
    1491         (
    1492                 const   XMLCh* const    target
    1493                 , const XMLCh* const    data
    1494         );
    1495 
    1496         virtual void doctypeWhitespace
    1497         (
    1498                 const   XMLCh* const    chars
    1499                 , const XMLSize_t       length
    1500         );
    1501 
    1502         virtual void elementDecl
    1503         (
    1504                 const   DTDElementDecl& decl
    1505                 , const bool            isIgnored
    1506         );
    1507 
    1508         virtual void endAttList
    1509         (
    1510                 const   DTDElementDecl& elemDecl
    1511         );
    1512 
    1513         virtual void endIntSubset();
    1514 
    1515         virtual void endExtSubset();
    1516 
    1517         virtual void entityDecl
    1518         (
    1519                 const   DTDEntityDecl&  entityDecl
    1520                 , const bool            isPEDecl
    1521                 , const bool            isIgnored
    1522         );
    1523 
    1524         virtual void resetDocType();
    1525 
    1526         virtual void notationDecl
    1527         (
    1528                 const   XMLNotationDecl&    notDecl
    1529                 , const bool                isIgnored
    1530         );
    1531 
    1532         virtual void startAttList
    1533         (
    1534                 const   DTDElementDecl& elemDecl
    1535         );
    1536 
    1537         virtual void startIntSubset();
    1538 
    1539         virtual void startExtSubset();
    1540 
    1541         virtual void TextDecl
    1542         (
    1543                 const   XMLCh* const    versionStr
    1544                 , const XMLCh* const    encodingStr
    1545         );
    1546 
    1547         //@}
     620      *
     621      * This method allows the user to specify whether a validating parser
     622      * should include ignorable whitespaces as text nodes.  It has no effect
     623      * on non-validating parsers which always include non-markup text.
     624      * <p>When set to true (also the default), ignorable whitespaces will be
     625      * added to the DOM tree as text nodes.  The method
     626      * DOMText::isIgnorableWhitespace() will return true for those text
     627      * nodes only.
     628      * <p>When set to false, all ignorable whitespace will be discarded and
     629      * no text node is added to the DOM tree.  Note: applications intended
     630      * to process the "xml:space" attribute should not set this flag to false.
     631      * And this flag also overrides any schema datateye whitespace facets,
     632      * that is, all ignorable whitespace will be discarded even though
     633      * 'preserve' is set in schema datatype whitespace facets.
     634      *
     635      * @param include The new state of the include ignorable whitespace
     636      *                flag.
     637      *
     638      * @see #getIncludeIgnorableWhitespace
     639      */
     640    void setIncludeIgnorableWhitespace(const bool include);
     641
     642    /**
     643      * This method allows users to set the validation scheme to be used
     644      * by this parser. The value is one of the ValSchemes enumerated values
     645      * defined by this class:
     646      *
     647      * <br>  Val_Never  - turn off validation
     648      * <br>  Val_Always - turn on validation
     649      * <br>  Val_Auto   - turn on validation if any internal/external
     650      *                  DTD subset have been seen
     651      *
     652      * <p>The parser's default state is: Val_Never.</p>
     653      *
     654      * @param newScheme The new validation scheme to use.
     655      *
     656      * @see #getValidationScheme
     657      */
     658    void setValidationScheme(const ValSchemes newScheme);
     659
     660    /** Set the 'do schema' flag
     661      *
     662      * This method allows users to enable or disable the parser's
     663      * schema processing. When set to false, parser will not process
     664      * any schema found.
     665      *
     666      * The parser's default state is: false.
     667      *
     668      * Note: If set to true, namespace processing must also be turned on.
     669      *
     670      * @param newState The value specifying whether schema support should
     671      *                 be enforced or not.
     672      *
     673      * @see #getDoSchema
     674      */
     675    void setDoSchema(const bool newState);
     676
     677    /**
     678      * This method allows the user to turn full Schema constraint checking on/off.
     679      * Only takes effect if Schema validation is enabled.
     680      * If turned off, partial constraint checking is done.
     681      *
     682      * Full schema constraint checking includes those checking that may
     683      * be time-consuming or memory intensive. Currently, particle unique
     684      * attribution constraint checking and particle derivation restriction checking
     685      * are controlled by this option.
     686      *
     687      * The parser's default state is: false.
     688      *
     689      * @param schemaFullChecking True to turn on full schema constraint checking.
     690      *
     691      * @see #getValidationSchemaFullChecking
     692      */
     693    void setValidationSchemaFullChecking(const bool schemaFullChecking);
     694
     695    /**
     696      * This method allows users to enable or disable the parser's identity
     697      * constraint checks.
     698      *
     699      * <p>By default, the parser does identity constraint checks.
     700      *    The default value is true.</p>
     701      *
     702      * @param newState The value specifying whether the parser should
     703      *                 do identity constraint checks or not in the
     704      *                 input XML document.
     705      *
     706      * @see #getIdentityConstraintChecking
     707      */
     708    void setIdentityConstraintChecking(const bool newState);
     709
     710    /**
     711      * This method allows the user to specify a list of schemas to use.
     712      * If the targetNamespace of a schema specified using this method matches
     713      * the targetNamespace of a schema occurring in the instance document in
     714      * the schemaLocation attribute, or if the targetNamespace matches the
     715      * namespace attribute of the "import" element, the schema specified by the
     716      * user using this method will be used (i.e., the schemaLocation attribute
     717      * in the instance document or on the "import" element will be effectively ignored).
     718      *
     719      * If this method is called more than once, only the last one takes effect.
     720      *
     721      * The syntax is the same as for schemaLocation attributes in instance
     722      * documents: e.g, "http://www.example.com file_name.xsd". The user can
     723      * specify more than one XML Schema in the list.
     724      *
     725      * @param schemaLocation the list of schemas to use
     726      *
     727      * @see #getExternalSchemaLocation
     728      */
     729
     730    void setExternalSchemaLocation(const XMLCh* const schemaLocation);
     731
     732    /**
     733      * This method is same as setExternalSchemaLocation(const XMLCh* const).
     734      * It takes native char string as parameter
     735      *
     736      * @param schemaLocation the list of schemas to use
     737      *
     738      * @see #setExternalSchemaLocation(const XMLCh* const)
     739      */
     740    void setExternalSchemaLocation(const char* const schemaLocation);
     741
     742    /**
     743      * This method allows the user to specify the no target namespace XML
     744      * Schema Location externally.  If specified, the instance document's
     745      * noNamespaceSchemaLocation attribute will be effectively ignored.
     746      *
     747      * If this method is called more than once, only the last one takes effect.
     748      *
     749      * The syntax is the same as for the noNamespaceSchemaLocation attribute
     750      * that may occur in an instance document: e.g."file_name.xsd".
     751      *
     752      * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
     753      *
     754      * @see #getExternalNoNamespaceSchemaLocation
     755      */
     756    void setExternalNoNamespaceSchemaLocation(const XMLCh* const noNamespaceSchemaLocation);
     757
     758    /**
     759      * This method is same as setExternalNoNamespaceSchemaLocation(const XMLCh* const).
     760      * It takes native char string as parameter
     761      *
     762      * @param noNamespaceSchemaLocation the XML Schema Location with no target namespace
     763      *
     764      * @see #setExternalNoNamespaceSchemaLocation(const XMLCh* const)
     765      */
     766    void setExternalNoNamespaceSchemaLocation(const char* const noNamespaceSchemaLocation);
     767
     768    /**
     769      * This allows an application to set a SecurityManager on
     770      * the parser; this object stores information that various
     771      * components use to limit their consumption of system
     772      * resources while processing documents.
     773      *
     774      * If this method is called more than once, only the last one takes effect.
     775      * It may not be reset during a parse.
     776      *
     777      *
     778      * @param securityManager  the SecurityManager instance to
     779      * be used by this parser
     780      *
     781      * @see #getSecurityManager
     782      */
     783    void setSecurityManager(SecurityManager* const securityManager);
     784
     785    /** Set the raw buffer low water mark for this parser.
     786      *
     787      * If the number of available bytes in the raw buffer is less than
     788      * the low water mark the parser will attempt to read more data before
     789      * continuing parsing. By default the value for this parameter is 100
     790      * bytes. You may want to set this parameter to 0 if you would like
     791      * the parser to parse the available data immediately without
     792      * potentially blocking while waiting for more date.
     793      *
     794      * @param lwm new low water mark
     795      *
     796      * @see #getSecurityManager
     797      */
     798    void setLowWaterMark(XMLSize_t lwm);
     799
     800    /** Set the 'Loading External DTD' flag
     801      *
     802      * This method allows users to enable or disable the loading of external DTD.
     803      * When set to false, the parser will ignore any external DTD completely
     804      * if the validationScheme is set to Val_Never.
     805      *
     806      * The parser's default state is: true.
     807      *
     808      * This flag is ignored if the validationScheme is set to Val_Always or Val_Auto.
     809      *
     810      * @param newState The value specifying whether external DTD should
     811      *                 be loaded or not.
     812      *
     813      * @see #getLoadExternalDTD
     814      * @see #setValidationScheme
     815      */
     816    void setLoadExternalDTD(const bool newState);
     817
     818    /** Set the 'Loading Schema' flag
     819      *
     820      * This method allows users to enable or disable the loading of schemas.
     821      * When set to false, the parser not attempt to load schemas beyond
     822      * querying the grammar pool for them.
     823      *
     824      * The parser's default state is: true.
     825      *
     826      * @param newState The value specifying whether schemas should
     827      *                 be loaded if they're not found in the grammar
     828      *                 pool.
     829      *
     830      * @see #getLoadSchema
     831      * @see #setDoSchema
     832      */
     833    void setLoadSchema(const bool newState);
     834
     835     /** Set the 'create comment nodes' flag
     836      *
     837      * This method allows the user to specify whether the parser should
     838      * create comment nodes in the DOM tree being produced.
     839      * <p>The default value is 'true'.
     840      *
     841      * @param create The new state of the create comment nodes
     842      *               flag.
     843      * @see #getCreateCommentNodes
     844      */
     845    void setCreateCommentNodes(const bool create);
     846
     847    /** Enable/disable src offset calculation
     848      *
     849      * This method allows users to enable/disable src offset calculation.
     850      * Disabling the calculation will improve performance.
     851      *
     852      * The parser's default state is: false.
     853      *
     854      * @param newState The value specifying whether we should enable or
     855      *                 disable src offset calculation
     856      *
     857      * @see #getCalculateSrcOfs
     858      */
     859    void setCalculateSrcOfs(const bool newState);
     860
     861    /** Force standard uri
     862      *
     863      * This method allows users to tell the parser to force standard uri conformance.
     864      *
     865      * The parser's default state is: false.
     866      *
     867      * @param newState The value specifying whether the parser should reject malformed URI.
     868      *
     869      * @see #getStandardUriConformant
     870      */
     871    void setStandardUriConformant(const bool newState);
     872
     873    /** Set the scanner to use when scanning the XML document
     874      *
     875      * This method allows users to set the  scanner to use
     876      * when scanning a given XML document.
     877      *
     878      * @param scannerName The name of the desired scanner
     879      */
     880    void useScanner(const XMLCh* const scannerName);
     881
     882    /** Set the implementation to use when creating the  document
     883      *
     884      * This method allows users to set the implementation to use
     885      * to create the document when parseing.
     886      *
     887      * @param implementationFeatures The names of the desired features the implementation should have.
     888      */
     889    void useImplementation(const XMLCh* const implementationFeatures);
     890
     891    /**
     892      * This method installs the user specified PSVI handler on
     893      * the parser.
     894      *
     895      * @param handler A pointer to the PSVI handler to be called
     896      *                when the parser comes across 'PSVI' events
     897      *                as per the schema specification.
     898      */
     899    virtual void setPSVIHandler(PSVIHandler* const handler);
     900
     901    /** Set the 'associate schema info' flag
     902      *
     903      * This method allows users to specify whether
     904      * the parser should store schema informations in the element
     905      * and attribute nodes in the DOM tree being produced.
     906      *
     907      * @param newState The state to set
     908      * @see #getCreateSchemaInfo
     909      */
     910    void  setCreateSchemaInfo(const bool newState);
     911
     912    /** Set the 'do XInclude' flag
     913      *
     914      * This method allows users to specify whether
     915      * the parser should process XInclude nodes
     916      * in the DOM tree being produced.
     917      *
     918      * @param newState The state to set